aboutsummaryrefslogtreecommitdiff
path: root/examples/05-http-requests/priv
diff options
context:
space:
mode:
Diffstat (limited to 'examples/05-http-requests/priv')
-rw-r--r--examples/05-http-requests/priv/static/app.mjs3072
1 files changed, 3072 insertions, 0 deletions
diff --git a/examples/05-http-requests/priv/static/app.mjs b/examples/05-http-requests/priv/static/app.mjs
new file mode 100644
index 0000000..ff806b3
--- /dev/null
+++ b/examples/05-http-requests/priv/static/app.mjs
@@ -0,0 +1,3072 @@
+// build/dev/javascript/prelude.mjs
+var CustomType = class {
+ withFields(fields) {
+ let properties = Object.keys(this).map(
+ (label2) => label2 in fields ? fields[label2] : this[label2]
+ );
+ return new this.constructor(...properties);
+ }
+};
+var List = class {
+ static fromArray(array3, tail) {
+ let t = tail || new Empty();
+ for (let i = array3.length - 1; i >= 0; --i) {
+ t = new NonEmpty(array3[i], t);
+ }
+ return t;
+ }
+ [Symbol.iterator]() {
+ return new ListIterator(this);
+ }
+ toArray() {
+ return [...this];
+ }
+ // @internal
+ atLeastLength(desired) {
+ for (let _ of this) {
+ if (desired <= 0)
+ return true;
+ desired--;
+ }
+ return desired <= 0;
+ }
+ // @internal
+ hasLength(desired) {
+ for (let _ of this) {
+ if (desired <= 0)
+ return false;
+ desired--;
+ }
+ return desired === 0;
+ }
+ countLength() {
+ let length4 = 0;
+ for (let _ of this)
+ length4++;
+ return length4;
+ }
+};
+function prepend(element2, tail) {
+ return new NonEmpty(element2, 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 _BitArray {
+ constructor(buffer) {
+ if (!(buffer instanceof Uint8Array)) {
+ throw "BitArray can only be constructed from a Uint8Array";
+ }
+ this.buffer = buffer;
+ }
+ // @internal
+ get length() {
+ return this.buffer.length;
+ }
+ // @internal
+ byteAt(index3) {
+ return this.buffer[index3];
+ }
+ // @internal
+ floatAt(index3) {
+ return byteArrayToFloat(this.buffer.slice(index3, index3 + 8));
+ }
+ // @internal
+ intFromSlice(start4, end) {
+ return byteArrayToInt(this.buffer.slice(start4, end));
+ }
+ // @internal
+ binaryFromSlice(start4, end) {
+ return new _BitArray(this.buffer.slice(start4, end));
+ }
+ // @internal
+ sliceAfter(index3) {
+ return new _BitArray(this.buffer.slice(index3));
+ }
+};
+function byteArrayToInt(byteArray) {
+ byteArray = byteArray.reverse();
+ let value = 0;
+ for (let i = byteArray.length - 1; i >= 0; i--) {
+ value = value * 256 + byteArray[i];
+ }
+ return value;
+}
+function byteArrayToFloat(byteArray) {
+ return new Float64Array(byteArray.reverse().buffer)[0];
+}
+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 values = [x, y];
+ while (values.length) {
+ let a = values.pop();
+ let b = values.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, get3] = getters(a);
+ for (let k of keys2(a)) {
+ values.push(get3(a, k), get3(b, k));
+ }
+ }
+ return true;
+}
+function getters(object3) {
+ if (object3 instanceof Map) {
+ return [(x) => x.keys(), (x, y) => x.get(y)];
+ } else {
+ let extra = object3 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.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, module, line, fn, message, extra) {
+ let error = new globalThis.Error(message);
+ error.gleam_error = variant;
+ error.module = module;
+ error.line = line;
+ error.fn = fn;
+ for (let k in extra)
+ error[k] = extra[k];
+ return error;
+}
+
+// build/dev/javascript/gleam_stdlib/gleam/option.mjs
+var Some = class extends CustomType {
+ constructor(x0) {
+ super();
+ this[0] = x0;
+ }
+};
+var None = class extends CustomType {
+};
+function to_result(option, e) {
+ if (option instanceof Some) {
+ let a = option[0];
+ return new Ok(a);
+ } else {
+ return new Error(e);
+ }
+}
+function from_result(result) {
+ if (result.isOk()) {
+ let a = result[0];
+ return new Some(a);
+ } else {
+ return new None();
+ }
+}
+function unwrap(option, default$) {
+ if (option instanceof Some) {
+ let x = option[0];
+ return x;
+ } else {
+ return default$;
+ }
+}
+function map(option, fun) {
+ if (option instanceof Some) {
+ let x = option[0];
+ return new Some(fun(x));
+ } else {
+ return new None();
+ }
+}
+
+// build/dev/javascript/gleam_stdlib/gleam/regex.mjs
+var Match = class extends CustomType {
+ constructor(content, submatches) {
+ super();
+ this.content = content;
+ this.submatches = submatches;
+ }
+};
+var CompileError = class extends CustomType {
+ constructor(error, byte_index) {
+ super();
+ this.error = error;
+ this.byte_index = byte_index;
+ }
+};
+var Options = class extends CustomType {
+ constructor(case_insensitive, multi_line) {
+ super();
+ this.case_insensitive = case_insensitive;
+ this.multi_line = multi_line;
+ }
+};
+function compile(pattern, options) {
+ return compile_regex(pattern, options);
+}
+function scan(regex, string3) {
+ return regex_scan(regex, string3);
+}
+
+// build/dev/javascript/gleam_stdlib/dict.mjs
+var referenceMap = /* @__PURE__ */ new WeakMap();
+var tempDataView = new DataView(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(root2, shift, hash, key, val, addedLeaf) {
+ switch (root2.type) {
+ case ARRAY_NODE:
+ return assocArray(root2, shift, hash, key, val, addedLeaf);
+ case INDEX_NODE:
+ return assocIndex(root2, shift, hash, key, val, addedLeaf);
+ case COLLISION_NODE:
+ return assocCollision(root2, shift, hash, key, val, addedLeaf);
+ }
+}
+function assocArray(root2, shift, hash, key, val, addedLeaf) {
+ const idx = mask(hash, shift);
+ const node = root2.array[idx];
+ if (node === void 0) {
+ addedLeaf.val = true;
+ return {
+ type: ARRAY_NODE,
+ size: root2.size + 1,
+ array: cloneAndSet(root2.array, idx, { type: ENTRY, k: key, v: val })
+ };
+ }
+ if (node.type === ENTRY) {
+ if (isEqual(key, node.k)) {
+ if (val === node.v) {
+ return root2;
+ }
+ return {
+ type: ARRAY_NODE,
+ size: root2.size,
+ array: cloneAndSet(root2.array, idx, {
+ type: ENTRY,
+ k: key,
+ v: val
+ })
+ };
+ }
+ addedLeaf.val = true;
+ return {
+ type: ARRAY_NODE,
+ size: root2.size,
+ array: cloneAndSet(
+ root2.array,
+ idx,
+ createNode(shift + SHIFT, node.k, node.v, hash, key, val)
+ )
+ };
+ }
+ const n = assoc(node, shift + SHIFT, hash, key, val, addedLeaf);
+ if (n === node) {
+ return root2;
+ }
+ return {
+ type: ARRAY_NODE,
+ size: root2.size,
+ array: cloneAndSet(root2.array, idx, n)
+ };
+}
+function assocIndex(root2, shift, hash, key, val, addedLeaf) {
+ const bit = bitpos(hash, shift);
+ const idx = index(root2.bitmap, bit);
+ if ((root2.bitmap & bit) !== 0) {
+ const node = root2.array[idx];
+ if (node.type !== ENTRY) {
+ const n = assoc(node, shift + SHIFT, hash, key, val, addedLeaf);
+ if (n === node) {
+ return root2;
+ }
+ return {
+ type: INDEX_NODE,
+ bitmap: root2.bitmap,
+ array: cloneAndSet(root2.array, idx, n)
+ };
+ }
+ const nodeKey = node.k;
+ if (isEqual(key, nodeKey)) {
+ if (val === node.v) {
+ return root2;
+ }
+ return {
+ type: INDEX_NODE,
+ bitmap: root2.bitmap,
+ array: cloneAndSet(root2.array, idx, {
+ type: ENTRY,
+ k: key,
+ v: val
+ })
+ };
+ }
+ addedLeaf.val = true;
+ return {
+ type: INDEX_NODE,
+ bitmap: root2.bitmap,
+ array: cloneAndSet(
+ root2.array,
+ idx,
+ createNode(shift + SHIFT, nodeKey, node.v, hash, key, val)
+ )
+ };
+ } else {
+ const n = root2.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 = root2.bitmap;
+ for (let i = 0; i < 32; i++) {
+ if ((bitmap & 1) !== 0) {
+ const node = root2.array[j++];
+ nodes[i] = node;
+ }
+ bitmap = bitmap >>> 1;
+ }
+ return {
+ type: ARRAY_NODE,
+ size: n + 1,
+ array: nodes
+ };
+ } else {
+ const newArray = spliceIn(root2.array, idx, {
+ type: ENTRY,
+ k: key,
+ v: val
+ });
+ addedLeaf.val = true;
+ return {
+ type: INDEX_NODE,
+ bitmap: root2.bitmap | bit,
+ array: newArray
+ };
+ }
+ }
+}
+function assocCollision(root2, shift, hash, key, val, addedLeaf) {
+ if (hash === root2.hash) {
+ const idx = collisionIndexOf(root2, key);
+ if (idx !== -1) {
+ const entry = root2.array[idx];
+ if (entry.v === val) {
+ return root2;
+ }
+ return {
+ type: COLLISION_NODE,
+ hash,
+ array: cloneAndSet(root2.array, idx, { type: ENTRY, k: key, v: val })
+ };
+ }
+ const size = root2.array.length;
+ addedLeaf.val = true;
+ return {
+ type: COLLISION_NODE,
+ hash,
+ array: cloneAndSet(root2.array, size, { type: ENTRY, k: key, v: val })
+ };
+ }
+ return assoc(
+ {
+ type: INDEX_NODE,
+ bitmap: bitpos(root2.hash, shift),
+ array: [root2]
+ },
+ shift,
+ hash,
+ key,
+ val,
+ addedLeaf
+ );
+}
+function collisionIndexOf(root2, key) {
+ const size = root2.array.length;
+ for (let i = 0; i < size; i++) {
+ if (isEqual(key, root2.array[i].k)) {
+ return i;
+ }
+ }
+ return -1;
+}
+function find(root2, shift, hash, key) {
+ switch (root2.type) {
+ case ARRAY_NODE:
+ return findArray(root2, shift, hash, key);
+ case INDEX_NODE:
+ return findIndex(root2, shift, hash, key);
+ case COLLISION_NODE:
+ return findCollision(root2, key);
+ }
+}
+function findArray(root2, shift, hash, key) {
+ const idx = mask(hash, shift);
+ const node = root2.array[idx];
+ if (node === void 0) {
+ return void 0;
+ }
+ if (node.type !== ENTRY) {
+ return find(node, shift + SHIFT, hash, key);
+ }
+ if (isEqual(key, node.k)) {
+ return node;
+ }
+ return void 0;
+}
+function findIndex(root2, shift, hash, key) {
+ const bit = bitpos(hash, shift);
+ if ((root2.bitmap & bit) === 0) {
+ return void 0;
+ }
+ const idx = index(root2.bitmap, bit);
+ const node = root2.array[idx];
+ if (node.type !== ENTRY) {
+ return find(node, shift + SHIFT, hash, key);
+ }
+ if (isEqual(key, node.k)) {
+ return node;
+ }
+ return void 0;
+}
+function findCollision(root2, key) {
+ const idx = collisionIndexOf(root2, key);
+ if (idx < 0) {
+ return void 0;
+ }
+ return root2.array[idx];
+}
+function without(root2, shift, hash, key) {
+ switch (root2.type) {
+ case ARRAY_NODE:
+ return withoutArray(root2, shift, hash, key);
+ case INDEX_NODE:
+ return withoutIndex(root2, shift, hash, key);
+ case COLLISION_NODE:
+ return withoutCollision(root2, key);
+ }
+}
+function withoutArray(root2, shift, hash, key) {
+ const idx = mask(hash, shift);
+ const node = root2.array[idx];
+ if (node === void 0) {
+ return root2;
+ }
+ let n = void 0;
+ if (node.type === ENTRY) {
+ if (!isEqual(node.k, key)) {
+ return root2;
+ }
+ } else {
+ n = without(node, shift + SHIFT, hash, key);
+ if (n === node) {
+ return root2;
+ }
+ }
+ if (n === void 0) {
+ if (root2.size <= MIN_ARRAY_NODE) {
+ const arr = root2.array;
+ const out = new Array(root2.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: root2.size - 1,
+ array: cloneAndSet(root2.array, idx, n)
+ };
+ }
+ return {
+ type: ARRAY_NODE,
+ size: root2.size,
+ array: cloneAndSet(root2.array, idx, n)
+ };
+}
+function withoutIndex(root2, shift, hash, key) {
+ const bit = bitpos(hash, shift);
+ if ((root2.bitmap & bit) === 0) {
+ return root2;
+ }
+ const idx = index(root2.bitmap, bit);
+ const node = root2.array[idx];
+ if (node.type !== ENTRY) {
+ const n = without(node, shift + SHIFT, hash, key);
+ if (n === node) {
+ return root2;
+ }
+ if (n !== void 0) {
+ return {
+ type: INDEX_NODE,
+ bitmap: root2.bitmap,
+ array: cloneAndSet(root2.array, idx, n)
+ };
+ }
+ if (root2.bitmap === bit) {
+ return void 0;
+ }
+ return {
+ type: INDEX_NODE,
+ bitmap: root2.bitmap ^ bit,
+ array: spliceOut(root2.array, idx)
+ };
+ }
+ if (isEqual(key, node.k)) {
+ if (root2.bitmap === bit) {
+ return void 0;
+ }
+ return {
+ type: INDEX_NODE,
+ bitmap: root2.bitmap ^ bit,
+ array: spliceOut(root2.array, idx)
+ };
+ }
+ return root2;
+}
+function withoutCollision(root2, key) {
+ const idx = collisionIndexOf(root2, key);
+ if (idx < 0) {
+ return root2;
+ }
+ if (root2.array.length === 1) {
+ return void 0;
+ }
+ return {
+ type: COLLISION_NODE,
+ hash: root2.hash,
+ array: spliceOut(root2.array, idx)
+ };
+}
+function forEach(root2, fn) {
+ if (root2 === void 0) {
+ return;
+ }
+ const items = root2.array;
+ const size = items.length;
+ for (let i = 0; i < size; 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(root2, size) {
+ this.root = root2;
+ this.size = size;
+ }
+ /**
+ * @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 root2 = this.root === void 0 ? EMPTY : this.root;
+ const newRoot = assoc(root2, 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;
+ }
+ let equal2 = true;
+ this.forEach((v, k) => {
+ equal2 = equal2 && isEqual(o.get(k, !v), v);
+ });
+ return equal2;
+ }
+};
+
+// 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 graphemes_iterator(string3) {
+ if (Intl && Intl.Segmenter) {
+ return new Intl.Segmenter().segment(string3)[Symbol.iterator]();
+ }
+}
+function pop_grapheme(string3) {
+ let first2;
+ const iterator = graphemes_iterator(string3);
+ if (iterator) {
+ first2 = iterator.next().value?.segment;
+ } else {
+ first2 = string3.match(/./su)?.[0];
+ }
+ if (first2) {
+ return new Ok([first2, string3.slice(first2.length)]);
+ } else {
+ return new Error(Nil);
+ }
+}
+function lowercase(string3) {
+ return string3.toLowerCase();
+}
+function concat(xs) {
+ let result = "";
+ for (const x of xs) {
+ result = result + x;
+ }
+ return result;
+}
+function starts_with(haystack, needle) {
+ return haystack.startsWith(needle);
+}
+function compile_regex(pattern, options) {
+ try {
+ let flags = "gu";
+ if (options.case_insensitive)
+ flags += "i";
+ if (options.multi_line)
+ flags += "m";
+ return new Ok(new RegExp(pattern, flags));
+ } catch (error) {
+ const number = (error.columnNumber || 0) | 0;
+ return new Error(new CompileError(error.message, number));
+ }
+}
+function regex_scan(regex, string3) {
+ const matches = Array.from(string3.matchAll(regex)).map((match) => {
+ const content = match[0];
+ const submatches = [];
+ for (let n = match.length - 1; n > 0; n--) {
+ if (match[n]) {
+ submatches[n - 1] = new Some(match[n]);
+ continue;
+ }
+ if (submatches.length > 0) {
+ submatches[n - 1] = new None();
+ }
+ }
+ return new Match(content, List.fromArray(submatches));
+ });
+ return List.fromArray(matches);
+}
+function map_get(map6, key) {
+ const value = map6.get(key, NOT_FOUND);
+ if (value === NOT_FOUND) {
+ return new Error(Nil);
+ }
+ return new Ok(value);
+}
+function classify_dynamic(data) {
+ if (typeof data === "string") {
+ return "String";
+ } 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 `Tuple of ${data.length} elements`;
+ } else if (typeof data === "number") {
+ return "Float";
+ } else if (data === null) {
+ return "Null";
+ } else if (data === void 0) {
+ return "Nil";
+ } else {
+ const type = typeof data;
+ return type.charAt(0).toUpperCase() + type.slice(1);
+ }
+}
+function decoder_error(expected, got) {
+ return decoder_error_no_classify(expected, classify_dynamic(got));
+}
+function decoder_error_no_classify(expected, got) {
+ return new Error(
+ List.fromArray([new DecodeError(expected, got, List.fromArray([]))])
+ );
+}
+function decode_string(data) {
+ return typeof data === "string" ? new Ok(data) : decoder_error("String", data);
+}
+function decode_int(data) {
+ return Number.isInteger(data) ? new Ok(data) : decoder_error("Int", data);
+}
+function decode_field(value, name) {
+ const not_a_map_error = () => decoder_error("Dict", value);
+ if (value instanceof Dict || value instanceof WeakMap || value instanceof Map) {
+ const entry = map_get(value, name);
+ return new Ok(entry.isOk() ? new Some(entry[0]) : new None());
+ } else if (value === null) {
+ return not_a_map_error();
+ } else if (Object.getPrototypeOf(value) == Object.prototype) {
+ return try_get_field(value, name, () => new Ok(new None()));
+ } else {
+ return try_get_field(value, name, not_a_map_error);
+ }
+}
+function try_get_field(value, field3, or_else) {
+ try {
+ return field3 in value ? new Ok(new Some(value[field3])) : or_else();
+ } catch {
+ return or_else();
+ }
+}
+
+// build/dev/javascript/gleam_stdlib/gleam/int.mjs
+function parse(string3) {
+ return parse_int(string3);
+}
+function to_string2(x) {
+ return to_string(x);
+}
+
+// build/dev/javascript/gleam_stdlib/gleam/pair.mjs
+function second(pair) {
+ let a = pair[1];
+ return a;
+}
+
+// build/dev/javascript/gleam_stdlib/gleam/list.mjs
+function do_reverse_acc(loop$remaining, loop$accumulator) {
+ while (true) {
+ let remaining = loop$remaining;
+ let accumulator = loop$accumulator;
+ if (remaining.hasLength(0)) {
+ return accumulator;
+ } else {
+ let item = remaining.head;
+ let rest$1 = remaining.tail;
+ loop$remaining = rest$1;
+ loop$accumulator = prepend(item, accumulator);
+ }
+ }
+}
+function do_reverse(list) {
+ return do_reverse_acc(list, toList([]));
+}
+function reverse(xs) {
+ return do_reverse(xs);
+}
+function first(list) {
+ if (list.hasLength(0)) {
+ return new Error(void 0);
+ } else {
+ let x = list.head;
+ return new Ok(x);
+ }
+}
+function do_map(loop$list, loop$fun, loop$acc) {
+ while (true) {
+ let list = loop$list;
+ let fun = loop$fun;
+ let acc = loop$acc;
+ if (list.hasLength(0)) {
+ return reverse(acc);
+ } else {
+ let x = list.head;
+ let xs = list.tail;
+ loop$list = xs;
+ loop$fun = fun;
+ loop$acc = prepend(fun(x), acc);
+ }
+ }
+}
+function map2(list, fun) {
+ return do_map(list, fun, toList([]));
+}
+function do_append_acc(loop$first, loop$second) {
+ while (true) {
+ let first2 = loop$first;
+ let second2 = loop$second;
+ if (first2.hasLength(0)) {
+ return second2;
+ } else {
+ let item = first2.head;
+ let rest$1 = first2.tail;
+ loop$first = rest$1;
+ loop$second = prepend(item, second2);
+ }
+ }
+}
+function do_append(first2, second2) {
+ return do_append_acc(reverse(first2), second2);
+}
+function append(first2, second2) {
+ return do_append(first2, second2);
+}
+function reverse_and_prepend(loop$prefix, loop$suffix) {
+ while (true) {
+ let prefix = loop$prefix;
+ let suffix = loop$suffix;
+ if (prefix.hasLength(0)) {
+ return suffix;
+ } else {
+ let first$1 = prefix.head;
+ let rest$1 = prefix.tail;
+ loop$prefix = rest$1;
+ loop$suffix = prepend(first$1, suffix);
+ }
+ }
+}
+function do_concat(loop$lists, loop$acc) {
+ while (true) {
+ let lists = loop$lists;
+ let acc = loop$acc;
+ if (lists.hasLength(0)) {
+ return reverse(acc);
+ } else {
+ let list = lists.head;
+ let further_lists = lists.tail;
+ loop$lists = further_lists;
+ loop$acc = reverse_and_prepend(list, acc);
+ }
+ }
+}
+function concat2(lists) {
+ return do_concat(lists, toList([]));
+}
+function fold(loop$list, loop$initial, loop$fun) {
+ while (true) {
+ let list = loop$list;
+ let initial = loop$initial;
+ let fun = loop$fun;
+ if (list.hasLength(0)) {
+ return initial;
+ } else {
+ let x = list.head;
+ let rest$1 = list.tail;
+ loop$list = rest$1;
+ loop$initial = fun(initial, x);
+ loop$fun = fun;
+ }
+ }
+}
+function do_repeat(loop$a, loop$times, loop$acc) {
+ while (true) {
+ let a = loop$a;
+ let times = loop$times;
+ let acc = loop$acc;
+ let $ = times <= 0;
+ if ($) {
+ return acc;
+ } else {
+ loop$a = a;
+ loop$times = times - 1;
+ loop$acc = prepend(a, acc);
+ }
+ }
+}
+function repeat(a, times) {
+ return do_repeat(a, times, toList([]));
+}
+
+// build/dev/javascript/gleam_stdlib/gleam/result.mjs
+function map3(result, fun) {
+ if (result.isOk()) {
+ let x = result[0];
+ return new Ok(fun(x));
+ } else {
+ let e = result[0];
+ return new Error(e);
+ }
+}
+function map_error(result, fun) {
+ if (result.isOk()) {
+ let x = result[0];
+ return new Ok(x);
+ } else {
+ let error = result[0];
+ return new Error(fun(error));
+ }
+}
+function try$(result, fun) {
+ if (result.isOk()) {
+ let x = result[0];
+ return fun(x);
+ } else {
+ let e = result[0];
+ return new Error(e);
+ }
+}
+function then$(result, fun) {
+ return try$(result, fun);
+}
+function unwrap2(result, default$) {
+ if (result.isOk()) {
+ let v = result[0];
+ return v;
+ } else {
+ return default$;
+ }
+}
+function nil_error(result) {
+ return map_error(result, (_) => {
+ return void 0;
+ });
+}
+
+// build/dev/javascript/gleam_stdlib/gleam/string_builder.mjs
+function from_strings(strings) {
+ return concat(strings);
+}
+function to_string3(builder) {
+ return identity(builder);
+}
+
+// build/dev/javascript/gleam_stdlib/gleam/dynamic.mjs
+var DecodeError = class extends CustomType {
+ constructor(expected, found, path) {
+ super();
+ this.expected = expected;
+ this.found = found;
+ this.path = path;
+ }
+};
+function from(a) {
+ return identity(a);
+}
+function string(data) {
+ return decode_string(data);
+}
+function classify(data) {
+ return classify_dynamic(data);
+}
+function int(data) {
+ return decode_int(data);
+}
+function any(decoders) {
+ return (data) => {
+ if (decoders.hasLength(0)) {
+ return new Error(
+ toList([new DecodeError("another type", classify(data), toList([]))])
+ );
+ } else {
+ let decoder2 = decoders.head;
+ let decoders$1 = decoders.tail;
+ let $ = decoder2(data);
+ if ($.isOk()) {
+ let decoded = $[0];
+ return new Ok(decoded);
+ } else {
+ return any(decoders$1)(data);
+ }
+ }
+ };
+}
+function all_errors(result) {
+ if (result.isOk()) {
+ return toList([]);
+ } else {
+ let errors = result[0];
+ return errors;
+ }
+}
+function push_path(error, name) {
+ let name$1 = from(name);
+ let decoder2 = any(
+ toList([string, (x) => {
+ return map3(int(x), to_string2);
+ }])
+ );
+ let name$2 = (() => {
+ let $ = decoder2(name$1);
+ if ($.isOk()) {
+ let name$22 = $[0];
+ return name$22;
+ } else {
+ let _pipe = toList(["<", classify(name$1), ">"]);
+ let _pipe$1 = from_strings(_pipe);
+ return to_string3(_pipe$1);
+ }
+ })();
+ return error.withFields({ path: prepend(name$2, error.path) });
+}
+function map_errors(result, f) {
+ return map_error(
+ result,
+ (_capture) => {
+ return map2(_capture, f);
+ }
+ );
+}
+function field(name, inner_type) {
+ return (value) => {
+ let missing_field_error = new DecodeError("field", "nothing", toList([]));
+ return try$(
+ decode_field(value, name),
+ (maybe_inner) => {
+ let _pipe = maybe_inner;
+ let _pipe$1 = to_result(_pipe, toList([missing_field_error]));
+ let _pipe$2 = try$(_pipe$1, inner_type);
+ return map_errors(
+ _pipe$2,
+ (_capture) => {
+ return push_path(_capture, name);
+ }
+ );
+ }
+ );
+ };
+}
+function decode2(constructor, t1, t2) {
+ return (value) => {
+ let $ = t1(value);
+ let $1 = t2(value);
+ if ($.isOk() && $1.isOk()) {
+ let a = $[0];
+ let b = $1[0];
+ return new Ok(constructor(a, b));
+ } else {
+ let a = $;
+ let b = $1;
+ return new Error(concat2(toList([all_errors(a), all_errors(b)])));
+ }
+ };
+}
+
+// build/dev/javascript/gleam_stdlib/gleam/string.mjs
+function lowercase2(string3) {
+ return lowercase(string3);
+}
+function starts_with2(string3, prefix) {
+ return starts_with(string3, prefix);
+}
+function concat3(strings) {
+ let _pipe = strings;
+ let _pipe$1 = from_strings(_pipe);
+ return to_string3(_pipe$1);
+}
+function pop_grapheme2(string3) {
+ return pop_grapheme(string3);
+}
+
+// build/dev/javascript/gleam_stdlib/gleam/bool.mjs
+function guard(requirement, consequence, alternative) {
+ if (requirement) {
+ return consequence;
+ } else {
+ return alternative();
+ }
+}
+
+// build/dev/javascript/gleam_json/gleam_json_ffi.mjs
+function decode(string3) {
+ try {
+ const result = JSON.parse(string3);
+ return new Ok(result);
+ } catch (err) {
+ return new Error(getJsonDecodeError(err, string3));
+ }
+}
+function getJsonDecodeError(stdErr, json) {
+ if (isUnexpectedEndOfInput(stdErr))
+ return new UnexpectedEndOfInput();
+ return toUnexpectedByteError(stdErr, json);
+}
+function isUnexpectedEndOfInput(err) {
+ const unexpectedEndOfInputRegex = /((unexpected (end|eof))|(end of data)|(unterminated string)|(json( parse error|\.parse)\: expected '(\:|\}|\])'))/i;
+ return unexpectedEndOfInputRegex.test(err.message);
+}
+function toUnexpectedByteError(err, json) {
+ let converters = [
+ v8UnexpectedByteError,
+ oldV8UnexpectedByteError,
+ jsCoreUnexpectedByteError,
+ spidermonkeyUnexpectedByteError
+ ];
+ for (let converter of converters) {
+ let result = converter(err, json);
+ if (result)
+ return result;
+ }
+ return new UnexpectedByte("", 0);
+}
+function v8UnexpectedByteError(err) {
+ const regex = /unexpected token '(.)', ".+" is not valid JSON/i;
+ const match = regex.exec(err.message);
+ if (!match)
+ return null;
+ const byte = toHex(match[1]);
+ return new UnexpectedByte(byte, -1);
+}
+function oldV8UnexpectedByteError(err) {
+ const regex = /unexpected token (.) in JSON at position (\d+)/i;
+ const match = regex.exec(err.message);
+ if (!match)
+ return null;
+ const byte = toHex(match[1]);
+ const position = Number(match[2]);
+ return new UnexpectedByte(byte, position);
+}
+function spidermonkeyUnexpectedByteError(err, json) {
+ const regex = /(unexpected character|expected .*) at line (\d+) column (\d+)/i;
+ const match = regex.exec(err.message);
+ if (!match)
+ return null;
+ const line = Number(match[2]);
+ const column = Number(match[3]);
+ const position = getPositionFromMultiline(line, column, json);
+ const byte = toHex(json[position]);
+ return new UnexpectedByte(byte, position);
+}
+function jsCoreUnexpectedByteError(err) {
+ const regex = /unexpected (identifier|token) "(.)"/i;
+ const match = regex.exec(err.message);
+ if (!match)
+ return null;
+ const byte = toHex(match[2]);
+ return new UnexpectedByte(byte, 0);
+}
+function toHex(char) {
+ return "0x" + char.charCodeAt(0).toString(16).toUpperCase();
+}
+function getPositionFromMultiline(line, column, string3) {
+ if (line === 1)
+ return column - 1;
+ let currentLn = 1;
+ let position = 0;
+ string3.split("").find((char, idx) => {
+ if (char === "\n")
+ currentLn += 1;
+ if (currentLn === line) {
+ position = idx + column;
+ return true;
+ }
+ return false;
+ });
+ return position;
+}
+
+// build/dev/javascript/gleam_json/gleam/json.mjs
+var UnexpectedEndOfInput = class extends CustomType {
+};
+var UnexpectedByte = class extends CustomType {
+ constructor(byte, position) {
+ super();
+ this.byte = byte;
+ this.position = position;
+ }
+};
+var UnexpectedFormat = class extends CustomType {
+ constructor(x0) {
+ super();
+ this[0] = x0;
+ }
+};
+function do_decode(json, decoder2) {
+ return then$(
+ decode(json),
+ (dynamic_value) => {
+ let _pipe = decoder2(dynamic_value);
+ return map_error(
+ _pipe,
+ (var0) => {
+ return new UnexpectedFormat(var0);
+ }
+ );
+ }
+ );
+}
+function decode3(json, decoder2) {
+ return do_decode(json, decoder2);
+}
+
+// build/dev/javascript/lustre/lustre/effect.mjs
+var Effect = class extends CustomType {
+ constructor(all) {
+ super();
+ this.all = all;
+ }
+};
+function from2(effect) {
+ return new Effect(toList([(dispatch, _) => {
+ return effect(dispatch);
+ }]));
+}
+function none() {
+ return new Effect(toList([]));
+}
+
+// build/dev/javascript/lustre/lustre/internals/vdom.mjs
+var Text = class extends CustomType {
+ constructor(content) {
+ super();
+ this.content = content;
+ }
+};
+var Element = class extends CustomType {
+ constructor(key, namespace, tag2, attrs, children, self_closing, void$) {
+ super();
+ this.key = key;
+ this.namespace = namespace;
+ this.tag = tag2;
+ this.attrs = attrs;
+ this.children = children;
+ this.self_closing = self_closing;
+ this.void = void$;
+ }
+};
+var Attribute = class extends CustomType {
+ constructor(x0, x1, as_property) {
+ super();
+ this[0] = x0;
+ this[1] = x1;
+ this.as_property = as_property;
+ }
+};
+var Event = class extends CustomType {
+ constructor(x0, x1) {
+ super();
+ this[0] = x0;
+ this[1] = x1;
+ }
+};
+
+// build/dev/javascript/lustre/lustre/attribute.mjs
+function attribute(name, value) {
+ return new Attribute(name, from(value), false);
+}
+function on(name, handler) {
+ return new Event("on" + name, handler);
+}
+function style(properties) {
+ return attribute(
+ "style",
+ fold(
+ properties,
+ "",
+ (styles, _use1) => {
+ let name$1 = _use1[0];
+ let value$1 = _use1[1];
+ return styles + name$1 + ":" + value$1 + ";";
+ }
+ )
+ );
+}
+function class$(name) {
+ return attribute("class", name);
+}
+function type_(name) {
+ return attribute("type", name);
+}
+
+// build/dev/javascript/lustre/lustre/element.mjs
+function element(tag2, attrs, children) {
+ if (tag2 === "area") {
+ return new Element("", "", tag2, attrs, toList([]), false, true);
+ } else if (tag2 === "base") {
+ return new Element("", "", tag2, attrs, toList([]), false, true);
+ } else if (tag2 === "br") {
+ return new Element("", "", tag2, attrs, toList([]), false, true);
+ } else if (tag2 === "col") {
+ return new Element("", "", tag2, attrs, toList([]), false, true);
+ } else if (tag2 === "embed") {
+ return new Element("", "", tag2, attrs, toList([]), false, true);
+ } else if (tag2 === "hr") {
+ return new Element("", "", tag2, attrs, toList([]), false, true);
+ } else if (tag2 === "img") {
+ return new Element("", "", tag2, attrs, toList([]), false, true);
+ } else if (tag2 === "input") {
+ return new Element("", "", tag2, attrs, toList([]), false, true);
+ } else if (tag2 === "link") {
+ return new Element("", "", tag2, attrs, toList([]), false, true);
+ } else if (tag2 === "meta") {
+ return new Element("", "", tag2, attrs, toList([]), false, true);
+ } else if (tag2 === "param") {
+ return new Element("", "", tag2, attrs, toList([]), false, true);
+ } else if (tag2 === "source") {
+ return new Element("", "", tag2, attrs, toList([]), false, true);
+ } else if (tag2 === "track") {
+ return new Element("", "", tag2, attrs, toList([]), false, true);
+ } else if (tag2 === "wbr") {
+ return new Element("", "", tag2, attrs, toList([]), false, true);
+ } else {
+ return new Element("", "", tag2, attrs, children, false, false);
+ }
+}
+function text(content) {
+ return new Text(content);
+}
+
+// build/dev/javascript/lustre/lustre/internals/runtime.mjs
+var Dispatch = class extends CustomType {
+ constructor(x0) {
+ super();
+ this[0] = x0;
+ }
+};
+var Shutdown = class extends CustomType {
+};
+
+// build/dev/javascript/lustre/vdom.ffi.mjs
+function morph(prev, next, dispatch, isComponent = false) {
+ let out;
+ let stack3 = [{ prev, next, parent: prev.parentNode }];
+ while (stack3.length) {
+ let { prev: prev2, next: next2, parent } = stack3.pop();
+ if (next2.subtree !== void 0)
+ next2 = next2.subtree();
+ if (next2.content !== void 0) {
+ if (!prev2) {
+ const created = document.createTextNode(next2.content);
+ parent.appendChild(created);
+ out ??= created;
+ } else if (prev2.nodeType === Node.TEXT_NODE) {
+ if (prev2.textContent !== next2.content)
+ prev2.textContent = next2.content;
+ out ??= prev2;
+ } else {
+ const created = document.createTextNode(next2.content);
+ parent.replaceChild(created, prev2);
+ out ??= created;
+ }
+ } else if (next2.tag !== void 0) {
+ const created = createElementNode({
+ prev: prev2,
+ next: next2,
+ dispatch,
+ stack: stack3,
+ isComponent
+ });
+ if (!prev2) {
+ parent.appendChild(created);
+ } else if (prev2 !== created) {
+ parent.replaceChild(created, prev2);
+ }
+ out ??= created;
+ }
+ }
+ return out;
+}
+function createElementNode({ prev, next, dispatch, stack: stack3 }) {
+ const namespace = next.namespace || "http://www.w3.org/1999/xhtml";
+ const canMorph = prev && prev.nodeType === Node.ELEMENT_NODE && prev.localName === next.tag && prev.namespaceURI === (next.namespace || "http://www.w3.org/1999/xhtml");
+ const el2 = canMorph ? prev : namespace ? document.createElementNS(namespace, next.tag) : document.createElement(next.tag);
+ let handlersForEl;
+ if (!registeredHandlers.has(el2)) {
+ const emptyHandlers = /* @__PURE__ */ new Map();
+ registeredHandlers.set(el2, emptyHandlers);
+ handlersForEl = emptyHandlers;
+ } else {
+ handlersForEl = registeredHandlers.get(el2);
+ }
+ const prevHandlers = canMorph ? new Set(handlersForEl.keys()) : null;
+ const prevAttributes = canMorph ? new Set(Array.from(prev.attributes, (a) => a.name)) : null;
+ let className = null;
+ let style2 = null;
+ let innerHTML = null;
+ for (const attr of next.attrs) {
+ const name = attr[0];
+ const value = attr[1];
+ const isProperty = attr[2];
+ if (isProperty) {
+ el2[name] = value;
+ } else if (name.startsWith("on")) {
+ const eventName = name.slice(2);
+ const callback = dispatch(value);
+ if (!handlersForEl.has(eventName)) {
+ el2.addEventListener(eventName, lustreGenericEventHandler);
+ }
+ handlersForEl.set(eventName, callback);
+ if (canMorph)
+ prevHandlers.delete(eventName);
+ } else if (name.startsWith("data-lustre-on-")) {
+ const eventName = name.slice(15);
+ const callback = dispatch(lustreServerEventHandler);
+ if (!handlersForEl.has(eventName)) {
+ el2.addEventListener(eventName, lustreGenericEventHandler);
+ }
+ handlersForEl.set(eventName, callback);
+ el2.setAttribute(name, value);
+ } else if (name === "class") {
+ className = className === null ? value : className + " " + value;
+ } else if (name === "style") {
+ style2 = style2 === null ? value : style2 + value;
+ } else if (name === "dangerous-unescaped-html") {
+ innerHTML = value;
+ } else {
+ el2.setAttribute(name, value);
+ if (name === "value")
+ el2[name] = value;
+ if (canMorph)
+ prevAttributes.delete(name);
+ }
+ }
+ if (className !== null) {
+ el2.setAttribute("class", className);
+ if (canMorph)
+ prevAttributes.delete("class");
+ }
+ if (style2 !== null) {
+ el2.setAttribute("style", style2);
+ if (canMorph)
+ prevAttributes.delete("style");
+ }
+ if (canMorph) {
+ for (const attr of prevAttributes) {
+ el2.removeAttribute(attr);
+ }
+ for (const eventName of prevHandlers) {
+ handlersForEl.delete(eventName);
+ el2.removeEventListener(eventName, lustreGenericEventHandler);
+ }
+ }
+ if (next.key !== void 0 && next.key !== "") {
+ el2.setAttribute("data-lustre-key", next.key);
+ } else if (innerHTML !== null) {
+ el2.innerHTML = innerHTML;
+ return el2;
+ }
+ let prevChild = el2.firstChild;
+ let seenKeys = null;
+ let keyedChildren = null;
+ let incomingKeyedChildren = null;
+ let firstChild = next.children[Symbol.iterator]().next().value;
+ if (canMorph && firstChild !== void 0 && // Explicit checks are more verbose but truthy checks force a bunch of comparisons
+ // we don't care about: it's never gonna be a number etc.
+ firstChild.key !== void 0 && firstChild.key !== "") {
+ seenKeys = /* @__PURE__ */ new Set();
+ keyedChildren = getKeyedChildren(prev);
+ incomingKeyedChildren = getKeyedChildren(next);
+ }
+ for (const child of next.children) {
+ if (child.key !== void 0 && seenKeys !== null) {
+ while (prevChild && !incomingKeyedChildren.has(prevChild.getAttribute("data-lustre-key"))) {
+ const nextChild = prevChild.nextSibling;
+ el2.removeChild(prevChild);
+ prevChild = nextChild;
+ }
+ if (keyedChildren.size === 0) {
+ stack3.unshift({ prev: prevChild, next: child, parent: el2 });
+ prevChild = prevChild?.nextSibling;
+ continue;
+ }
+ if (seenKeys.has(child.key)) {
+ console.warn(`Duplicate key found in Lustre vnode: ${child.key}`);
+ stack3.unshift({ prev: null, next: child, parent: el2 });
+ continue;
+ }
+ seenKeys.add(child.key);
+ const keyedChild = keyedChildren.get(child.key);
+ if (!keyedChild && !prevChild) {
+ stack3.unshift({ prev: null, next: child, parent: el2 });
+ continue;
+ }
+ if (!keyedChild && prevChild !== null) {
+ const placeholder = document.createTextNode("");
+ el2.insertBefore(placeholder, prevChild);
+ stack3.unshift({ prev: placeholder, next: child, parent: el2 });
+ continue;
+ }
+ if (!keyedChild || keyedChild === prevChild) {
+ stack3.unshift({ prev: prevChild, next: child, parent: el2 });
+ prevChild = prevChild?.nextSibling;
+ continue;
+ }
+ el2.insertBefore(keyedChild, prevChild);
+ stack3.unshift({ prev: keyedChild, next: child, parent: el2 });
+ } else {
+ stack3.unshift({ prev: prevChild, next: child, parent: el2 });
+ prevChild = prevChild?.nextSibling;
+ }
+ }
+ while (prevChild) {
+ const next2 = prevChild.nextSibling;
+ el2.removeChild(prevChild);
+ prevChild = next2;
+ }
+ return el2;
+}
+var registeredHandlers = /* @__PURE__ */ new WeakMap();
+function lustreGenericEventHandler(event2) {
+ const target = event2.currentTarget;
+ if (!registeredHandlers.has(target)) {
+ target.removeEventListener(event2.type, lustreGenericEventHandler);
+ return;
+ }
+ const handlersForEventTarget = registeredHandlers.get(target);
+ if (!handlersForEventTarget.has(event2.type)) {
+ target.removeEventListener(event2.type, lustreGenericEventHandler);
+ return;
+ }
+ handlersForEventTarget.get(event2.type)(event2);
+}
+function lustreServerEventHandler(event2) {
+ const el2 = event2.target;
+ const tag2 = el2.getAttribute(`data-lustre-on-${event2.type}`);
+ const data = JSON.parse(el2.getAttribute("data-lustre-data") || "{}");
+ const include = JSON.parse(el2.getAttribute("data-lustre-include") || "[]");
+ switch (event2.type) {
+ case "input":
+ case "change":
+ include.push("target.value");
+ break;
+ }
+ return {
+ tag: tag2,
+ data: include.reduce(
+ (data2, property) => {
+ const path = property.split(".");
+ for (let i = 0, o = data2, e = event2; i < path.length; i++) {
+ if (i === path.length - 1) {
+ o[path[i]] = e[path[i]];
+ } else {
+ o[path[i]] ??= {};
+ e = e[path[i]];
+ o = o[path[i]];
+ }
+ }
+ return data2;
+ },
+ { data }
+ )
+ };
+}
+function getKeyedChildren(el2) {
+ const keyedChildren = /* @__PURE__ */ new Map();
+ if (el2) {
+ for (const child of el2.children) {
+ const key = child.key || child?.getAttribute("data-lustre-key");
+ if (key)
+ keyedChildren.set(key, child);
+ }
+ }
+ return keyedChildren;
+}
+
+// build/dev/javascript/lustre/client-runtime.ffi.mjs
+var LustreClientApplication2 = class _LustreClientApplication {
+ #root = null;
+ #queue = [];
+ #effects = [];
+ #didUpdate = false;
+ #isComponent = false;
+ #model = null;
+ #update = null;
+ #view = null;
+ static start(flags, selector, init3, update3, view2) {
+ if (!is_browser())
+ return new Error(new NotABrowser());
+ const root2 = selector instanceof HTMLElement ? selector : document.querySelector(selector);
+ if (!root2)
+ return new Error(new ElementNotFound(selector));
+ const app = new _LustreClientApplication(init3(flags), update3, view2, root2);
+ return new Ok((msg) => app.send(msg));
+ }
+ constructor([model, effects], update3, view2, root2 = document.body, isComponent = false) {
+ this.#model = model;
+ this.#update = update3;
+ this.#view = view2;
+ this.#root = root2;
+ this.#effects = effects.all.toArray();
+ this.#didUpdate = true;
+ this.#isComponent = isComponent;
+ window.requestAnimationFrame(() => this.#tick());
+ }
+ send(action) {
+ switch (true) {
+ case action instanceof Dispatch: {
+ this.#queue.push(action[0]);
+ this.#tick();
+ return;
+ }
+ case action instanceof Shutdown: {
+ this.#shutdown();
+ return;
+ }
+ default:
+ return;
+ }
+ }
+ emit(event2, data) {
+ this.#root.dispatchEvent(
+ new CustomEvent(event2, {
+ bubbles: true,
+ detail: data,
+ composed: true
+ })
+ );
+ }
+ #tick() {
+ this.#flush_queue();
+ const vdom = this.#view(this.#model);
+ const dispatch = (handler) => (e) => {
+ const result = handler(e);
+ if (result instanceof Ok) {
+ this.send(new Dispatch(result[0]));
+ }
+ };
+ this.#didUpdate = false;
+ this.#root = morph(this.#root, vdom, dispatch, this.#isComponent);
+ }
+ #flush_queue(iterations = 0) {
+ while (this.#queue.length) {
+ const [next, effects] = this.#update(this.#model, this.#queue.shift());
+ this.#didUpdate ||= !isEqual(this.#model, next);
+ this.#model = next;
+ this.#effects = this.#effects.concat(effects.all.toArray());
+ }
+ while (this.#effects.length) {
+ this.#effects.shift()(
+ (msg) => this.send(new Dispatch(msg)),
+ (event2, data) => this.emit(event2, data)
+ );
+ }
+ if (this.#queue.length) {
+ if (iterations < 5) {
+ this.#flush_queue(++iterations);
+ } else {
+ window.requestAnimationFrame(() => this.#tick());
+ }
+ }
+ }
+ #shutdown() {
+ this.#root.remove();
+ this.#root = null;
+ this.#model = null;
+ this.#queue = [];
+ this.#effects = [];
+ this.#didUpdate = false;
+ this.#update = () => {
+ };
+ this.#view = () => {
+ };
+ }
+};
+var start = (app, selector, flags) => LustreClientApplication2.start(
+ flags,
+ selector,
+ app.init,
+ app.update,
+ app.view
+);
+var is_browser = () => window && window.document;
+
+// build/dev/javascript/lustre/lustre.mjs
+var App = class extends CustomType {
+ constructor(init3, update3, view2, on_attribute_change) {
+ super();
+ this.init = init3;
+ this.update = update3;
+ this.view = view2;
+ this.on_attribute_change = on_attribute_change;
+ }
+};
+var ElementNotFound = class extends CustomType {
+ constructor(selector) {
+ super();
+ this.selector = selector;
+ }
+};
+var NotABrowser = class extends CustomType {
+};
+function application(init3, update3, view2) {
+ return new App(init3, update3, view2, new None());
+}
+function start3(app, selector, flags) {
+ return guard(
+ !is_browser(),
+ new Error(new NotABrowser()),
+ () => {
+ return start(app, selector, flags);
+ }
+ );
+}
+
+// build/dev/javascript/lustre/lustre/element/html.mjs
+function div(attrs, children) {
+ return element("div", attrs, children);
+}
+function p(attrs, children) {
+ return element("p", attrs, children);
+}
+function button(attrs, children) {
+ return element("button", attrs, children);
+}
+
+// build/dev/javascript/lustre/lustre/event.mjs
+function on2(name, handler) {
+ return on(name, handler);
+}
+function on_click(msg) {
+ return on2("click", (_) => {
+ return new Ok(msg);
+ });
+}
+
+// build/dev/javascript/gleam_stdlib/gleam/uri.mjs
+var Uri = class extends CustomType {
+ constructor(scheme, userinfo, host, port, path, query, fragment) {
+ super();
+ this.scheme = scheme;
+ this.userinfo = userinfo;
+ this.host = host;
+ this.port = port;
+ this.path = path;
+ this.query = query;
+ this.fragment = fragment;
+ }
+};
+function regex_submatches(pattern, string3) {
+ let _pipe = pattern;
+ let _pipe$1 = compile(_pipe, new Options(true, false));
+ let _pipe$2 = nil_error(_pipe$1);
+ let _pipe$3 = map3(
+ _pipe$2,
+ (_capture) => {
+ return scan(_capture, string3);
+ }
+ );
+ let _pipe$4 = try$(_pipe$3, first);
+ let _pipe$5 = map3(_pipe$4, (m) => {
+ return m.submatches;
+ });
+ return unwrap2(_pipe$5, toList([]));
+}
+function noneify_query(x) {
+ if (x instanceof None) {
+ return new None();
+ } else {
+ let x$1 = x[0];
+ let $ = pop_grapheme2(x$1);
+ if ($.isOk() && $[0][0] === "?") {
+ let query = $[0][1];
+ return new Some(query);
+ } else {
+ return new None();
+ }
+ }
+}
+function noneify_empty_string(x) {
+ if (x instanceof Some && x[0] === "") {
+ return new None();
+ } else if (x instanceof None) {
+ return new None();
+ } else {
+ return x;
+ }
+}
+function extra_required(loop$list, loop$remaining) {
+ while (true) {
+ let list = loop$list;
+ let remaining = loop$remaining;
+ if (remaining === 0) {
+ return 0;
+ } else if (list.hasLength(0)) {
+ return remaining;
+ } else {
+ let xs = list.tail;
+ loop$list = xs;
+ loop$remaining = remaining - 1;
+ }
+ }
+}
+function pad_list(list, size) {
+ let _pipe = list;
+ return append(
+ _pipe,
+ repeat(new None(), extra_required(list, size))
+ );
+}
+function split_authority(authority) {
+ let $ = unwrap(authority, "");
+ if ($ === "") {
+ return [new None(), new None(), new None()];
+ } else if ($ === "//") {
+ return [new None(), new Some(""), new None()];
+ } else {
+ let authority$1 = $;
+ let matches = (() => {
+ let _pipe = "^(//)?((.*)@)?(\\[[a-zA-Z0-9:.]*\\]|[^:]*)(:(\\d*))?";
+ let _pipe$1 = regex_submatches(_pipe, authority$1);
+ return pad_list(_pipe$1, 6);
+ })();
+ if (matches.hasLength(6)) {
+ let userinfo = matches.tail.tail.head;
+ let host = matches.tail.tail.tail.head;
+ let port = matches.tail.tail.tail.tail.tail.head;
+ let userinfo$1 = noneify_empty_string(userinfo);
+ let host$1 = noneify_empty_string(host);
+ let port$1 = (() => {
+ let _pipe = port;
+ let _pipe$1 = unwrap(_pipe, "");
+ let _pipe$2 = parse(_pipe$1);
+ return from_result(_pipe$2);
+ })();
+ return [userinfo$1, host$1, port$1];
+ } else {
+ return [new None(), new None(), new None()];
+ }
+ }
+}
+function do_parse(uri_string) {
+ let pattern = "^(([a-z][a-z0-9\\+\\-\\.]*):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#.*)?";
+ let matches = (() => {
+ let _pipe = pattern;
+ let _pipe$1 = regex_submatches(_pipe, uri_string);
+ return pad_list(_pipe$1, 8);
+ })();
+ let $ = (() => {
+ if (matches.hasLength(8)) {
+ let scheme2 = matches.tail.head;
+ let authority_with_slashes = matches.tail.tail.head;
+ let path2 = matches.tail.tail.tail.tail.head;
+ let query_with_question_mark = matches.tail.tail.tail.tail.tail.head;
+ let fragment2 = matches.tail.tail.tail.tail.tail.tail.tail.head;
+ return [
+ scheme2,
+ authority_with_slashes,
+ path2,
+ query_with_question_mark,
+ fragment2
+ ];
+ } else {
+ return [new None(), new None(), new None(), new None(), new None()];
+ }
+ })();
+ let scheme = $[0];
+ let authority = $[1];
+ let path = $[2];
+ let query = $[3];
+ let fragment = $[4];
+ let scheme$1 = noneify_empty_string(scheme);
+ let path$1 = unwrap(path, "");
+ let query$1 = noneify_query(query);
+ let $1 = split_authority(authority);
+ let userinfo = $1[0];
+ let host = $1[1];
+ let port = $1[2];
+ let fragment$1 = (() => {
+ let _pipe = fragment;
+ let _pipe$1 = to_result(_pipe, void 0);
+ let _pipe$2 = try$(_pipe$1, pop_grapheme2);
+ let _pipe$3 = map3(_pipe$2, second);
+ return from_result(_pipe$3);
+ })();
+ let scheme$2 = (() => {
+ let _pipe = scheme$1;
+ let _pipe$1 = noneify_empty_string(_pipe);
+ return map(_pipe$1, lowercase2);
+ })();
+ return new Ok(
+ new Uri(scheme$2, userinfo, host, port, path$1, query$1, fragment$1)
+ );
+}
+function parse2(uri_string) {
+ return do_parse(uri_string);
+}
+function to_string5(uri) {
+ let parts = (() => {
+ let $ = uri.fragment;
+ if ($ instanceof Some) {
+ let fragment = $[0];
+ return toList(["#", fragment]);
+ } else {
+ return toList([]);
+ }
+ })();
+ let parts$1 = (() => {
+ let $ = uri.query;
+ if ($ instanceof Some) {
+ let query = $[0];
+ return prepend("?", prepend(query, parts));
+ } else {
+ return parts;
+ }
+ })();
+ let parts$2 = prepend(uri.path, parts$1);
+ let parts$3 = (() => {
+ let $ = uri.host;
+ let $1 = starts_with2(uri.path, "/");
+ if ($ instanceof Some && !$1 && $[0] !== "") {
+ let host = $[0];
+ return prepend("/", parts$2);
+ } else {
+ return parts$2;
+ }
+ })();
+ let parts$4 = (() => {
+ let $ = uri.host;
+ let $1 = uri.port;
+ if ($ instanceof Some && $1 instanceof Some) {
+ let port = $1[0];
+ return prepend(":", prepend(to_string2(port), parts$3));
+ } else {
+ return parts$3;
+ }
+ })();
+ let parts$5 = (() => {
+ let $ = uri.scheme;
+ let $1 = uri.userinfo;
+ let $2 = uri.host;
+ if ($ instanceof Some && $1 instanceof Some && $2 instanceof Some) {
+ let s = $[0];
+ let u = $1[0];
+ let h = $2[0];
+ return prepend(
+ s,
+ prepend(
+ "://",
+ prepend(u, prepend("@", prepend(h, parts$4)))
+ )
+ );
+ } else if ($ instanceof Some && $1 instanceof None && $2 instanceof Some) {
+ let s = $[0];
+ let h = $2[0];
+ return prepend(s, prepend("://", prepend(h, parts$4)));
+ } else if ($ instanceof Some && $1 instanceof Some && $2 instanceof None) {
+ let s = $[0];
+ return prepend(s, prepend(":", parts$4));
+ } else if ($ instanceof Some && $1 instanceof None && $2 instanceof None) {
+ let s = $[0];
+ return prepend(s, prepend(":", parts$4));
+ } else if ($ instanceof None && $1 instanceof None && $2 instanceof Some) {
+ let h = $2[0];
+ return prepend("//", prepend(h, parts$4));
+ } else {
+ return parts$4;
+ }
+ })();
+ return concat3(parts$5);
+}
+
+// build/dev/javascript/gleam_http/gleam/http.mjs
+var Get = class extends CustomType {
+};
+var Post = class extends CustomType {
+};
+var Head = class extends CustomType {
+};
+var Put = class extends CustomType {
+};
+var Delete = class extends CustomType {
+};
+var Trace = class extends CustomType {
+};
+var Connect = class extends CustomType {
+};
+var Options2 = class extends CustomType {
+};
+var Patch = class extends CustomType {
+};
+var Http = class extends CustomType {
+};
+var Https = class extends CustomType {
+};
+function method_to_string(method) {
+ if (method instanceof Connect) {
+ return "connect";
+ } else if (method instanceof Delete) {
+ return "delete";
+ } else if (method instanceof Get) {
+ return "get";
+ } else if (method instanceof Head) {
+ return "head";
+ } else if (method instanceof Options2) {
+ return "options";
+ } else if (method instanceof Patch) {
+ return "patch";
+ } else if (method instanceof Post) {
+ return "post";
+ } else if (method instanceof Put) {
+ return "put";
+ } else if (method instanceof Trace) {
+ return "trace";
+ } else {
+ let s = method[0];
+ return s;
+ }
+}
+function scheme_to_string(scheme) {
+ if (scheme instanceof Http) {
+ return "http";
+ } else {
+ return "https";
+ }
+}
+function scheme_from_string(scheme) {
+ let $ = lowercase2(scheme);
+ if ($ === "http") {
+ return new Ok(new Http());
+ } else if ($ === "https") {
+ return new Ok(new Https());
+ } else {
+ return new Error(void 0);
+ }
+}
+
+// build/dev/javascript/gleam_http/gleam/http/request.mjs
+var Request = class extends CustomType {
+ constructor(method, headers, body, scheme, host, port, path, query) {
+ super();
+ this.method = method;
+ this.headers = headers;
+ this.body = body;
+ this.scheme = scheme;
+ this.host = host;
+ this.port = port;
+ this.path = path;
+ this.query = query;
+ }
+};
+function to_uri(request) {
+ return new Uri(
+ new Some(scheme_to_string(request.scheme)),
+ new None(),
+ new Some(request.host),
+ request.port,
+ request.path,
+ request.query,
+ new None()
+ );
+}
+function from_uri(uri) {
+ return then$(
+ (() => {
+ let _pipe = uri.scheme;
+ let _pipe$1 = unwrap(_pipe, "");
+ return scheme_from_string(_pipe$1);
+ })(),
+ (scheme) => {
+ return then$(
+ (() => {
+ let _pipe = uri.host;
+ return to_result(_pipe, void 0);
+ })(),
+ (host) => {
+ let req = new Request(
+ new Get(),
+ toList([]),
+ "",
+ scheme,
+ host,
+ uri.port,
+ uri.path,
+ uri.query
+ );
+ return new Ok(req);
+ }
+ );
+ }
+ );
+}
+function to(url) {
+ let _pipe = url;
+ let _pipe$1 = parse2(_pipe);
+ return then$(_pipe$1, from_uri);
+}
+
+// build/dev/javascript/gleam_http/gleam/http/response.mjs
+var Response = class extends CustomType {
+ constructor(status, headers, body) {
+ super();
+ this.status = status;
+ this.headers = headers;
+ this.body = body;
+ }
+};
+
+// build/dev/javascript/gleam_javascript/ffi.mjs
+var PromiseLayer = class _PromiseLayer {
+ constructor(promise) {
+ this.promise = promise;
+ }
+ static wrap(value) {
+ return value instanceof Promise ? new _PromiseLayer(value) : value;
+ }
+ static unwrap(value) {
+ return value instanceof _PromiseLayer ? value.promise : value;
+ }
+};
+function resolve(value) {
+ return Promise.resolve(PromiseLayer.wrap(value));
+}
+function then(promise, fn) {
+ return promise.then((value) => fn(PromiseLayer.unwrap(value)));
+}
+function map_promise(promise, fn) {
+ return promise.then(
+ (value) => PromiseLayer.wrap(fn(PromiseLayer.unwrap(value)))
+ );
+}
+function rescue(promise, fn) {
+ return promise.catch((error) => fn(error));
+}
+
+// build/dev/javascript/gleam_javascript/gleam/javascript/promise.mjs
+function tap(promise, callback) {
+ let _pipe = promise;
+ return map_promise(
+ _pipe,
+ (a) => {
+ callback(a);
+ return a;
+ }
+ );
+}
+function try_await(promise, callback) {
+ let _pipe = promise;
+ return then(
+ _pipe,
+ (result) => {
+ if (result.isOk()) {
+ let a = result[0];
+ return callback(a);
+ } else {
+ let e = result[0];
+ return resolve(new Error(e));
+ }
+ }
+ );
+}
+
+// build/dev/javascript/gleam_fetch/ffi.mjs
+async function raw_send(request) {
+ try {
+ return new Ok(await fetch(request));
+ } catch (error) {
+ return new Error(new NetworkError(error.toString()));
+ }
+}
+function from_fetch_response(response) {
+ return new Response(
+ response.status,
+ List.fromArray([...response.headers]),
+ response
+ );
+}
+function to_fetch_request(request) {
+ let url = to_string5(to_uri(request));
+ let method = method_to_string(request.method).toUpperCase();
+ let options = {
+ headers: make_headers(request.headers),
+ method
+ };
+ if (method !== "GET" && method !== "HEAD")
+ options.body = request.body;
+ return new globalThis.Request(url, options);
+}
+function make_headers(headersList) {
+ let headers = new globalThis.Headers();
+ for (let [k, v] of headersList)
+ headers.append(k.toLowerCase(), v);
+ return headers;
+}
+async function read_text_body(response) {
+ let body;
+ try {
+ body = await response.body.text();
+ } catch (error) {
+ return new Error(new UnableToReadBody());
+ }
+ return new Ok(response.withFields({ body }));
+}
+
+// build/dev/javascript/gleam_fetch/gleam/fetch.mjs
+var NetworkError = class extends CustomType {
+ constructor(x0) {
+ super();
+ this[0] = x0;
+ }
+};
+var UnableToReadBody = class extends CustomType {
+};
+function send(request) {
+ let _pipe = request;
+ let _pipe$1 = to_fetch_request(_pipe);
+ let _pipe$2 = raw_send(_pipe$1);
+ return try_await(
+ _pipe$2,
+ (resp) => {
+ return resolve(new Ok(from_fetch_response(resp)));
+ }
+ );
+}
+
+// build/dev/javascript/lustre_http/lustre_http.mjs
+var BadUrl = class extends CustomType {
+ constructor(x0) {
+ super();
+ this[0] = x0;
+ }
+};
+var InternalServerError = class extends CustomType {
+ constructor(x0) {
+ super();
+ this[0] = x0;
+ }
+};
+var JsonError = class extends CustomType {
+ constructor(x0) {
+ super();
+ this[0] = x0;
+ }
+};
+var NetworkError2 = class extends CustomType {
+};
+var NotFound = class extends CustomType {
+};
+var OtherError = class extends CustomType {
+ constructor(x0, x1) {
+ super();
+ this[0] = x0;
+ this[1] = x1;
+ }
+};
+var Unauthorized = class extends CustomType {
+};
+var ExpectTextResponse = class extends CustomType {
+ constructor(run) {
+ super();
+ this.run = run;
+ }
+};
+function do_send(req, expect, dispatch) {
+ let _pipe = send(req);
+ let _pipe$1 = try_await(_pipe, read_text_body);
+ let _pipe$2 = map_promise(
+ _pipe$1,
+ (response) => {
+ if (response.isOk()) {
+ let res = response[0];
+ return expect.run(new Ok(res));
+ } else {
+ return expect.run(new Error(new NetworkError2()));
+ }
+ }
+ );
+ let _pipe$3 = rescue(
+ _pipe$2,
+ (_) => {
+ return expect.run(new Error(new NetworkError2()));
+ }
+ );
+ tap(_pipe$3, dispatch);
+ return void 0;
+}
+function get2(url, expect) {
+ return from2(
+ (dispatch) => {
+ let $ = to(url);
+ if ($.isOk()) {
+ let req = $[0];
+ return do_send(req, expect, dispatch);
+ } else {
+ return dispatch(expect.run(new Error(new BadUrl(url))));
+ }
+ }
+ );
+}
+function response_to_result(response) {
+ if (response instanceof Response && (200 <= response.status && response.status <= 299)) {
+ let status = response.status;
+ let body = response.body;
+ return new Ok(body);
+ } else if (response instanceof Response && response.status === 401) {
+ return new Error(new Unauthorized());
+ } else if (response instanceof Response && response.status === 404) {
+ return new Error(new NotFound());
+ } else if (response instanceof Response && response.status === 500) {
+ let body = response.body;
+ return new Error(new InternalServerError(body));
+ } else {
+ let code = response.status;
+ let body = response.body;
+ return new Error(new OtherError(code, body));
+ }
+}
+function expect_json(decoder2, to_msg) {
+ return new ExpectTextResponse(
+ (response) => {
+ let _pipe = response;
+ let _pipe$1 = then$(_pipe, response_to_result);
+ let _pipe$2 = then$(
+ _pipe$1,
+ (body) => {
+ let $ = decode3(body, decoder2);
+ if ($.isOk()) {
+ let json = $[0];
+ return new Ok(json);
+ } else {
+ let json_error = $[0];
+ return new Error(new JsonError(json_error));
+ }
+ }
+ );
+ return to_msg(_pipe$2);
+ }
+ );
+}
+
+// build/dev/javascript/lustre_ui/lustre/ui/button.mjs
+function button2(attributes, children) {
+ return button(
+ prepend(
+ class$("lustre-ui-button"),
+ prepend(type_("button"), attributes)
+ ),
+ children
+ );
+}
+
+// build/dev/javascript/lustre_ui/lustre/ui/layout/stack.mjs
+function of(element2, attributes, children) {
+ return element2(
+ prepend(class$("lustre-ui-stack"), attributes),
+ children
+ );
+}
+function stack(attributes, children) {
+ return of(div, attributes, children);
+}
+
+// build/dev/javascript/lustre_ui/lustre/ui/layout/aside.mjs
+function of2(element2, attributes, side, main2) {
+ return element2(
+ prepend(class$("lustre-ui-aside"), attributes),
+ toList([side, main2])
+ );
+}
+function aside(attributes, side, main2) {
+ return of2(div, attributes, side, main2);
+}
+function min_width(width) {
+ let $ = width < 10;
+ let $1 = width > 90;
+ if ($) {
+ return style(toList([["--min", "10%"]]));
+ } else if (!$ && !$1) {
+ return style(toList([["--min", to_string2(width) + "%"]]));
+ } else {
+ return style(toList([["--min", "90%"]]));
+ }
+}
+
+// build/dev/javascript/lustre_ui/lustre/ui/layout/centre.mjs
+function of3(element2, attributes, children) {
+ return element2(
+ prepend(class$("lustre-ui-centre"), attributes),
+ toList([children])
+ );
+}
+function centre(attributes, children) {
+ return of3(div, attributes, children);
+}
+
+// build/dev/javascript/gleam_community_colour/gleam_community/colour.mjs
+var Rgba = class extends CustomType {
+ constructor(r, g, b, a) {
+ super();
+ this.r = r;
+ this.g = g;
+ this.b = b;
+ this.a = a;
+ }
+};
+var light_red = new Rgba(
+ 0.9372549019607843,
+ 0.1607843137254902,
+ 0.1607843137254902,
+ 1
+);
+var red = new Rgba(0.8, 0, 0, 1);
+var dark_red = new Rgba(0.6431372549019608, 0, 0, 1);
+var light_orange = new Rgba(
+ 0.9882352941176471,
+ 0.6862745098039216,
+ 0.24313725490196078,
+ 1
+);
+var orange = new Rgba(0.9607843137254902, 0.4745098039215686, 0, 1);
+var dark_orange = new Rgba(
+ 0.807843137254902,
+ 0.3607843137254902,
+ 0,
+ 1
+);
+var light_yellow = new Rgba(
+ 1,
+ 0.9137254901960784,
+ 0.30980392156862746,
+ 1
+);
+var yellow = new Rgba(0.9294117647058824, 0.8313725490196079, 0, 1);
+var dark_yellow = new Rgba(
+ 0.7686274509803922,
+ 0.6274509803921569,
+ 0,
+ 1
+);
+var light_green = new Rgba(
+ 0.5411764705882353,
+ 0.8862745098039215,
+ 0.20392156862745098,
+ 1
+);
+var green = new Rgba(
+ 0.45098039215686275,
+ 0.8235294117647058,
+ 0.08627450980392157,
+ 1
+);
+var dark_green = new Rgba(
+ 0.3058823529411765,
+ 0.6039215686274509,
+ 0.023529411764705882,
+ 1
+);
+var light_blue = new Rgba(
+ 0.4470588235294118,
+ 0.6235294117647059,
+ 0.8117647058823529,
+ 1
+);
+var blue = new Rgba(
+ 0.20392156862745098,
+ 0.396078431372549,
+ 0.6431372549019608,
+ 1
+);
+var dark_blue = new Rgba(
+ 0.12549019607843137,
+ 0.2901960784313726,
+ 0.5294117647058824,
+ 1
+);
+var light_purple = new Rgba(
+ 0.6784313725490196,
+ 0.4980392156862745,
+ 0.6588235294117647,
+ 1
+);
+var purple = new Rgba(
+ 0.4588235294117647,
+ 0.3137254901960784,
+ 0.4823529411764706,
+ 1
+);
+var dark_purple = new Rgba(
+ 0.3607843137254902,
+ 0.20784313725490197,
+ 0.4,
+ 1
+);
+var light_brown = new Rgba(
+ 0.9137254901960784,
+ 0.7254901960784313,
+ 0.43137254901960786,
+ 1
+);
+var brown = new Rgba(
+ 0.7568627450980392,
+ 0.49019607843137253,
+ 0.06666666666666667,
+ 1
+);
+var dark_brown = new Rgba(
+ 0.5607843137254902,
+ 0.34901960784313724,
+ 0.00784313725490196,
+ 1
+);
+var black = new Rgba(0, 0, 0, 1);
+var white = new Rgba(1, 1, 1, 1);
+var light_grey = new Rgba(
+ 0.9333333333333333,
+ 0.9333333333333333,
+ 0.9254901960784314,
+ 1
+);
+var grey = new Rgba(
+ 0.8274509803921568,
+ 0.8431372549019608,
+ 0.8117647058823529,
+ 1
+);
+var dark_grey = new Rgba(
+ 0.7294117647058823,
+ 0.7411764705882353,
+ 0.7137254901960784,
+ 1
+);
+var light_gray = new Rgba(
+ 0.9333333333333333,
+ 0.9333333333333333,
+ 0.9254901960784314,
+ 1
+);
+var gray = new Rgba(
+ 0.8274509803921568,
+ 0.8431372549019608,
+ 0.8117647058823529,
+ 1
+);
+var dark_gray = new Rgba(
+ 0.7294117647058823,
+ 0.7411764705882353,
+ 0.7137254901960784,
+ 1
+);
+var light_charcoal = new Rgba(
+ 0.5333333333333333,
+ 0.5411764705882353,
+ 0.5215686274509804,
+ 1
+);
+var charcoal = new Rgba(
+ 0.3333333333333333,
+ 0.3411764705882353,
+ 0.3254901960784314,
+ 1
+);
+var dark_charcoal = new Rgba(
+ 0.1803921568627451,
+ 0.20392156862745098,
+ 0.21176470588235294,
+ 1
+);
+var pink = new Rgba(1, 0.6862745098039216, 0.9529411764705882, 1);
+
+// build/dev/javascript/lustre_ui/lustre/ui.mjs
+var aside2 = aside;
+var button3 = button2;
+var centre2 = centre;
+var stack2 = stack;
+
+// build/dev/javascript/app/app.mjs
+var Model = class extends CustomType {
+ constructor(quote) {
+ super();
+ this.quote = quote;
+ }
+};
+var Quote = class extends CustomType {
+ constructor(author, content) {
+ super();
+ this.author = author;
+ this.content = content;
+ }
+};
+var UserClickedRefresh = class extends CustomType {
+};
+var ApiUpdatedQuote = class extends CustomType {
+ constructor(x0) {
+ super();
+ this[0] = x0;
+ }
+};
+function init2(_) {
+ return [new Model(new None()), none()];
+}
+function get_quote() {
+ let url = "https://api.quotable.io/random";
+ let decoder2 = decode2(
+ (var0, var1) => {
+ return new Quote(var0, var1);
+ },
+ field("author", string),
+ field("content", string)
+ );
+ return get2(
+ url,
+ expect_json(
+ decoder2,
+ (var0) => {
+ return new ApiUpdatedQuote(var0);
+ }
+ )
+ );
+}
+function update2(model, msg) {
+ if (msg instanceof UserClickedRefresh) {
+ return [model, get_quote()];
+ } else if (msg instanceof ApiUpdatedQuote && msg[0].isOk()) {
+ let quote = msg[0][0];
+ return [new Model(new Some(quote)), none()];
+ } else {
+ return [model, none()];
+ }
+}
+function view_quote(quote) {
+ if (quote instanceof Some) {
+ let quote$1 = quote[0];
+ return stack2(
+ toList([]),
+ toList([
+ text(quote$1.author + " once said..."),
+ p(
+ toList([style(toList([["font-style", "italic"]]))]),
+ toList([text(quote$1.content)])
+ )
+ ])
+ );
+ } else {
+ return p(
+ toList([]),
+ toList([text("Click the button to get a quote!")])
+ );
+ }
+}
+function view(model) {
+ let styles = toList([
+ ["width", "100vw"],
+ ["height", "100vh"],
+ ["padding", "1rem"]
+ ]);
+ return centre2(
+ toList([style(styles)]),
+ aside2(
+ toList([
+ min_width(70),
+ style(toList([["width", "60ch"]]))
+ ]),
+ view_quote(model.quote),
+ button3(
+ toList([on_click(new UserClickedRefresh())]),
+ toList([text("New quote")])
+ )
+ )
+ );
+}
+function main() {
+ let app = application(init2, update2, view);
+ let $ = start3(app, "#app", void 0);
+ if (!$.isOk()) {
+ throw makeError(
+ "assignment_no_match",
+ "app",
+ 21,
+ "main",
+ "Assignment pattern did not match",
+ { value: $ }
+ );
+ }
+ return $;
+}
+
+// build/.lustre/entry.mjs
+main();
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-18 19:57:24 +0000