ctrl-fx 0.0.1 → 0.1.1

package/dist/chunk-KNHJPAIU.js

@@ -0,0 +1,1800 @@
+import {
+  __publicField
+} from "./chunk-PKBMQBKP.js";
+
+// src/utils/result.ts
+function map(f) {
+  return (result) => {
+    switch (result._tag) {
+      case "failure": {
+        return failure(result.error);
+      }
+      case "success": {
+        return success(f(result.value));
+      }
+    }
+  };
+}
+function andThen(f) {
+  return (result) => {
+    switch (result._tag) {
+      case "failure": {
+        return failure(result.error);
+      }
+      case "success": {
+        return f(result.value);
+      }
+    }
+  };
+}
+function success(value) {
+  return {
+    _tag: "success",
+    value,
+    map(f) {
+      return map(f)(this);
+    },
+    andThen(f) {
+      return andThen(f)(this);
+    },
+    errorMap(f) {
+      return errorMap(f)(this);
+    },
+    merge() {
+      return value;
+    },
+    recover(_f) {
+      return success(value);
+    },
+    fold(onSuccess, _onError) {
+      return onSuccess(value);
+    }
+  };
+}
+function failure(error) {
+  return {
+    _tag: "failure",
+    error,
+    map(f) {
+      return map(f)(this);
+    },
+    andThen(f) {
+      return andThen(f)(this);
+    },
+    errorMap(f) {
+      return errorMap(f)(this);
+    },
+    merge() {
+      return error;
+    },
+    recover(f) {
+      return f(error);
+    },
+    fold(_onSuccess, onError) {
+      return onError(error);
+    }
+  };
+}
+function errorMap(f) {
+  return (result) => {
+    switch (result._tag) {
+      case "failure": {
+        return failure(f(result.error));
+      }
+      case "success": {
+        return success(result.value);
+      }
+    }
+  };
+}
+
+// src/net/index.ts
+var Json = class {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor(wrapped) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    __publicField(this, "wrapped");
+    this.wrapped = wrapped;
+  }
+  decodeUnsafe() {
+    return this.wrapped;
+  }
+};
+var ResponseBody = class {
+  constructor(data) {
+    __publicField(this, "data");
+    this.data = data;
+  }
+  asString() {
+    return new TextDecoder().decode(this.data);
+  }
+  asBlob() {
+    return new Blob([this.data]);
+  }
+  asJson() {
+    try {
+      return success(new Json(JSON.parse(this.asString())));
+    } catch (err) {
+      if (err instanceof SyntaxError) {
+        return failure({ _type: "DecodingError", message: err.message });
+      } else {
+        return failure({
+          _type: "DecodingError",
+          message: `Unexpected decoding error: ${err}`
+        });
+      }
+    }
+  }
+};
+function getJson(uri) {
+  return makeHttpRequest({
+    uri,
+    method: "GET",
+    headers: {}
+  }).map(
+    (result) => result.andThen((rsp) => {
+      return rsp.body.asJson();
+    })
+  );
+}
+
+// src/utils/index.ts
+var todo = () => {
+  throw new Error("Unimplemented");
+};
+function exhaustivenessCheck(value) {
+  throw new Error(`Unhandled: ${value}`);
+}
+function eq(value1, value2) {
+  if (typeof value1 !== typeof value2) {
+    return false;
+  }
+  if (value1 === null) {
+    return value2 === null;
+  }
+  if (value2 === null) {
+    return false;
+  }
+  if (value1 === void 0) {
+    return value2 === void 0;
+  }
+  if (value2 === void 0) {
+    return false;
+  }
+  if (typeof value1 === "function") {
+    return true;
+  }
+  if (typeof value1 !== "object") {
+    return value1 === value2;
+  }
+  if (Array.isArray(value1)) {
+    if (!Array.isArray(value2)) {
+      return false;
+    }
+    if (value1.length != value2.length) {
+      return false;
+    }
+    for (let i = 0; i < value1.length; i++) {
+      if (!eq(value1[i], value2[i])) {
+        return false;
+      }
+    }
+    return true;
+  } else if (Array.isArray(value2)) {
+    return false;
+  }
+  if (typeof value1 === "object") {
+    const keys1 = Object.keys(value1);
+    const keys2 = Object.keys(value2);
+    if (keys1.length !== keys2.length) {
+      return false;
+    }
+    for (const key of keys1) {
+      if (!Object.prototype.hasOwnProperty.call(value2, key)) {
+        return false;
+      }
+      if (!eq(value1[key], value2[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return `${value1}` === `${value2}`;
+}
+function stringToInt(s) {
+  const result = Number.parseInt(s);
+  if (Number.isNaN(result)) {
+    return void 0;
+  } else {
+    return result;
+  }
+}
+function filterNot(value, f) {
+  if (value !== void 0) {
+    return f(value) ? void 0 : value;
+  } else {
+    return void 0;
+  }
+}
+
+// src/net/path.ts
+var emptyPath = {
+  elems: [],
+  format() {
+    return "";
+  },
+  matches(that) {
+    return that.elems.length === 0;
+  }
+};
+function parsePath(s) {
+  return {
+    elems: s.split("/"),
+    format() {
+      return this.elems.join("/");
+    },
+    matches(that) {
+      if (this.elems.length !== that.elems.length) {
+        return false;
+      }
+      for (let i = 0; i < this.elems.length; i++) {
+        if (this.elems[i].toLocaleLowerCase() !== that.elems[i].toLocaleLowerCase()) {
+          return false;
+        }
+      }
+      return true;
+    }
+  };
+}
+
+// src/net/fragment.ts
+function parseFragment(str) {
+  const normalizedInput = (str.startsWith("#") ? str.substring(1) : str).trim();
+  if (normalizedInput.length === 0) {
+    return;
+  }
+  const questionMark = normalizedInput.indexOf("?");
+  if (questionMark <= -1) {
+    return {
+      path: parsePath(normalizedInput),
+      queryParams: [],
+      format: normalizedInput
+    };
+  } else {
+    return todo();
+  }
+}
+
+// src/net/queryparam.ts
+function parseQueryParam(str) {
+  const eqIndx = str.indexOf("=");
+  if (eqIndx < 0) {
+    return {
+      name: str,
+      format: str
+    };
+  } else {
+    const name = str.substring(0, eqIndx);
+    const value = str.substring(eqIndx + 1);
+    return {
+      name,
+      value,
+      format: str
+    };
+  }
+}
+function parseAllQueryParams(str) {
+  const normalizedInput = str.startsWith("?") ? str.substring(1) : str;
+  const qps = normalizedInput.split("&").filter((s) => s.length > 0);
+  return qps.map(parseQueryParam);
+}
+function formatQueryString(queryParams) {
+  if (queryParams.length === 0) {
+    return "";
+  } else {
+    return "?" + queryParams.map((qp) => qp.format).join("&");
+  }
+}
+
+// src/net/location.ts
+function formatLocation(loc) {
+  return `${loc.path.format()}${formatQueryString(loc.queryParams)}${loc.fragment != null ? "#" + loc.fragment.format : ""}`;
+}
+function parseInternalLocation(s) {
+  const fragStart = s.indexOf("#");
+  let pathAndParams, fragment;
+  if (fragStart < 0) {
+    pathAndParams = s;
+    fragment = void 0;
+  } else {
+    pathAndParams = s.substring(0, fragStart);
+    fragment = parseFragment(s.substring(fragStart + 1));
+  }
+  let path, queryParams;
+  const paramsStart = pathAndParams.indexOf("?");
+  if (paramsStart < 0) {
+    path = parsePath(pathAndParams);
+    queryParams = [];
+  } else {
+    path = parsePath(pathAndParams.substring(0, paramsStart));
+    queryParams = parseAllQueryParams(pathAndParams.substring(paramsStart + 1));
+  }
+  return {
+    path,
+    queryParams,
+    fragment
+  };
+}
+function internalLocationFromLocation(location) {
+  return {
+    path: location.path,
+    queryParams: location.queryParams,
+    fragment: location.fragment
+  };
+}
+var emptyLocation = parseInternalLocation("");
+
+// src/effects.ts
+function taskId(id) {
+  return id;
+}
+function customEffect(f, test) {
+  return (args) => ({
+    _type: "Suspend",
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    operation: { _type: "CustomEffect", input: { args, f, test } },
+    flatMap(fn) {
+      return flatMap(this, fn);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(fn) {
+      return flatMap(this, (out) => pure(fn(out)));
+    },
+    as(b) {
+      return flatMap(this, (_) => pure(b));
+    },
+    void() {
+      return this.map((_out) => {
+      });
+    },
+    apply(fn) {
+      return fn(this);
+    }
+  });
+}
+function flatMap(effect, next) {
+  return {
+    _type: "FlatMap",
+    effect,
+    next,
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect2) {
+      return flatMap(this, (_) => effect2);
+    },
+    map(f) {
+      return this.flatMap((b) => pure(f(b)));
+    },
+    as(c) {
+      return this.flatMap((_) => pure(c));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function pure(value) {
+  return {
+    _type: "Return",
+    value,
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, (a) => pure(f(a)));
+    },
+    as(b) {
+      return flatMap(this, (_) => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function alert(message) {
+  return {
+    _type: "Suspend",
+    operation: {
+      _type: "Alert",
+      input: message
+    },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, () => pure(f()));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function confirm(message) {
+  return {
+    _type: "Suspend",
+    operation: { _type: "Confirm", input: message },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, (b) => pure(f(b)));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function prompt(message, defaultValue) {
+  return {
+    _type: "Suspend",
+    operation: { _type: "Prompt", input: { message, default: defaultValue } },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, (s) => pure(f(s)));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function clearAppBadge() {
+  return {
+    _type: "Suspend",
+    operation: { _type: "ClearAppBadge", input: void 0 },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, () => pure(f()));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function readClipboard() {
+  return {
+    _type: "Suspend",
+    operation: { _type: "ReadClipboard", input: void 0 },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, (result) => pure(f(result)));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function writeClipboard(text) {
+  return {
+    _type: "Suspend",
+    operation: { _type: "WriteClipboard", input: text },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, (result) => pure(f(result)));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function setDocumentTitle(title) {
+  return {
+    _type: "Suspend",
+    operation: { _type: "SetDocumentTitle", input: title },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, () => pure(f()));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function setAppBadge(count) {
+  return {
+    _type: "Suspend",
+    operation: { _type: "SetAppBadge", input: count },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, () => pure(f()));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function async(effect, delayInMillis = 0) {
+  return {
+    _type: "Suspend",
+    operation: {
+      _type: "Async",
+      input: { effect, delayInMillis }
+    },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect2) {
+      return flatMap(this, (_) => effect2);
+    },
+    map(f) {
+      return flatMap(this, (_) => pure(f()));
+    },
+    as(b) {
+      return flatMap(this, (_) => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function cancelTask(taskId2) {
+  return {
+    _type: "Suspend",
+    operation: {
+      _type: "CancelTask",
+      input: taskId2
+    },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, () => pure(f()));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function fireEvent(event) {
+  return {
+    _type: "Suspend",
+    operation: {
+      _type: "FireEvent",
+      input: event
+    },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, () => pure(f()));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function generateUuid() {
+  return {
+    _type: "Suspend",
+    operation: {
+      _type: "GenerateUuid",
+      input: void 0
+    },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, (uuid) => pure(f(uuid)));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function getTime() {
+  return {
+    _type: "Suspend",
+    operation: {
+      _type: "GetTime",
+      input: void 0
+    },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, (date) => pure(f(date)));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function getRandom() {
+  return {
+    _type: "Suspend",
+    operation: {
+      _type: "GetRandom",
+      input: void 0
+    },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, (n) => pure(f(n)));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function log(message) {
+  return {
+    _type: "Suspend",
+    operation: {
+      _type: "Log",
+      input: message
+    },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, () => pure(f()));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function makeHttpRequest(request) {
+  return {
+    _type: "Suspend",
+    operation: {
+      _type: "MakeHttpRequest",
+      input: request
+    },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, (result) => pure(f(result)));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function getLocation() {
+  return {
+    _type: "Suspend",
+    operation: { _type: "GetLocation", input: void 0 },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, (loc) => pure(f(loc)));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function getNotificationPermission() {
+  return {
+    _type: "Suspend",
+    operation: { _type: "GetNotificationPermission", input: void 0 },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, (p) => pure(f(p)));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function requestNotificationPermission() {
+  return {
+    _type: "Suspend",
+    operation: { _type: "RequestNotificationPermission", input: void 0 },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, (p) => pure(f(p)));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function getState() {
+  return {
+    _type: "Suspend",
+    operation: {
+      _type: "GetState",
+      input: void 0
+    },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, (state) => pure(f(state)));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function product(effectA, effectB) {
+  return {
+    _type: "Suspend",
+    operation: {
+      _type: "Product",
+      input: [effectA, effectB]
+    },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, (aAndB) => pure(f(aAndB)));
+    },
+    as(c) {
+      return flatMap(this, (_) => pure(c));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function scheduleTask(task, initialDelayInMillis, repeatIntervalInMillis, taskId2) {
+  return {
+    _type: "Suspend",
+    operation: {
+      _type: "ScheduleTask",
+      input: {
+        task,
+        initialDelayInMillis,
+        repeatIntervalInMillis,
+        taskId: taskId2
+      }
+    },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, (taskId3) => pure(f(taskId3)));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function setTimeout(delayInMilliseconds) {
+  return {
+    _type: "Suspend",
+    operation: {
+      _type: "SetTimeout",
+      input: delayInMilliseconds
+    },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, () => pure(f()));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function updateState(f) {
+  return {
+    _type: "Suspend",
+    operation: {
+      _type: "UpdateState",
+      input: f
+    },
+    flatMap(f2) {
+      return flatMap(this, f2);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f2) {
+      return flatMap(this, () => pure(f2()));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f2) {
+      return f2(this);
+    }
+  };
+}
+function openDatabase(db, version, setup) {
+  return {
+    _type: "Suspend",
+    operation: { _type: "OpenDatabase", input: { db, version, setup } },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, (result) => pure(f(result)));
+    },
+    as(b) {
+      return flatMap(this, (_) => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function runDbTransaction(db, objectStores, mode, effect) {
+  return {
+    _type: "Suspend",
+    operation: {
+      _type: "RunDbTransaction",
+      input: { db, objectStores, mode, effect }
+    },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect2) {
+      return flatMap(this, (_) => effect2);
+    },
+    map(f) {
+      return flatMap(this, (result) => pure(f(result)));
+    },
+    as(b) {
+      return flatMap(this, (_) => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function storageEffect(storage, key, value, tag) {
+  const input = tag === "SetStorageItem" ? { storage, key, value } : tag === "ClearStorage" ? { storage } : { storage, key };
+  return {
+    _type: "Suspend",
+    operation: { _type: tag, input },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(e) {
+      return flatMap(this, (_) => e);
+    },
+    map(f) {
+      return flatMap(this, (a) => pure(f(a)));
+    },
+    as(b) {
+      return flatMap(this, (_) => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function go(delta) {
+  return {
+    _type: "Suspend",
+    operation: { _type: "Go", input: delta },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, () => pure(f()));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function pushState(location) {
+  const loc = typeof location === "string" ? parseInternalLocation(location) : location;
+  return {
+    _type: "Suspend",
+    operation: { _type: "PushState", input: loc },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, () => pure(f()));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function replaceState(location) {
+  const loc = typeof location === "string" ? parseInternalLocation(location) : location;
+  return {
+    _type: "Suspend",
+    operation: { _type: "ReplaceState", input: loc },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, () => pure(f()));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function getLocalStorageItem(key) {
+  return storageEffect("local", key, void 0, "GetStorageItem");
+}
+function setLocalStorageItem(key, value) {
+  return storageEffect("local", key, value, "SetStorageItem");
+}
+function removeLocalStorageItem(key) {
+  return storageEffect("local", key, void 0, "RemoveStorageItem");
+}
+function clearLocalStorage() {
+  return storageEffect("local", "", void 0, "ClearStorage");
+}
+function getSessionStorageItem(key) {
+  return storageEffect("session", key, void 0, "GetStorageItem");
+}
+function setSessionStorageItem(key, value) {
+  return storageEffect("session", key, value, "SetStorageItem");
+}
+function removeSessionStorageItem(key) {
+  return storageEffect("session", key, void 0, "RemoveStorageItem");
+}
+function clearSessionStorage() {
+  return storageEffect("session", "", void 0, "ClearStorage");
+}
+function mapEvent(effect, f) {
+  switch (effect._type) {
+    case "Return": {
+      return pure(effect.value);
+    }
+    case "FlatMap": {
+      return flatMap(mapEvent(effect.effect, f), (x) => {
+        return mapEvent(effect.next(x), f);
+      });
+    }
+    case "Suspend": {
+      switch (effect.operation._type) {
+        case "Alert":
+        case "CancelTask":
+        case "ClearAppBadge":
+        case "ClearStorage":
+        case "Confirm":
+        case "CustomEffect":
+        case "Download":
+        case "GenerateUuid":
+        case "GetLocation":
+        case "GetNotificationPermission":
+        case "RequestNotificationPermission":
+        case "GetState":
+        case "GetStorageItem":
+        case "GetTime":
+        case "GetRandom":
+        case "Log":
+        case "PostBroadcastMessage":
+        case "Prompt":
+        case "MakeHttpRequest":
+        case "Go":
+        case "OpenDatabase":
+        case "PushState":
+        case "ReplaceState":
+        case "RemoveStorageItem":
+        case "ReadClipboard":
+        case "RunDbTransaction":
+        case "ScrollElement":
+        case "ScrollWindow":
+        case "SetAppBadge":
+        case "SetDocumentTitle":
+        case "SetStorageItem":
+        case "SetTimeout":
+        case "UpdateState":
+        case "WriteClipboard": {
+          return effect;
+        }
+        case "SubscribeToBroadcastChannel": {
+          return subscribeToBroadcastChannel(
+            effect.operation.input.channel,
+            (msg) => mapEvent(effect.operation.input.handler(msg), f),
+            effect.operation.input.taskId
+          );
+        }
+        case "ScheduleTask": {
+          return scheduleTask(
+            mapEvent(effect.operation.input.task, f),
+            effect.operation.input.initialDelayInMillis,
+            effect.operation.input.repeatIntervalInMillis,
+            effect.operation.input.taskId
+          );
+        }
+        case "Async": {
+          return async(mapEvent(effect.operation.input.effect, f), effect.operation.input.delayInMillis);
+        }
+        case "Product": {
+          return product(
+            mapEvent(effect.operation.input[0], f),
+            mapEvent(effect.operation.input[1], f)
+          );
+        }
+        case "FireEvent":
+          return fireEvent(f(effect.operation.input));
+      }
+    }
+  }
+}
+function mapState(effect, lens) {
+  switch (effect._type) {
+    case "Return": {
+      return pure(effect.value);
+    }
+    case "FlatMap": {
+      return flatMap(mapState(effect.effect, lens), (x) => {
+        return mapState(effect.next(x), lens);
+      });
+    }
+    case "Suspend": {
+      switch (effect.operation._type) {
+        case "Alert":
+        case "CancelTask":
+        case "ClearAppBadge":
+        case "ClearStorage":
+        case "Confirm":
+        case "CustomEffect":
+        case "Download":
+        case "FireEvent":
+        case "GenerateUuid":
+        case "GetLocation":
+        case "GetNotificationPermission":
+        case "RequestNotificationPermission":
+        case "PostBroadcastMessage":
+        case "Prompt":
+        case "GetStorageItem":
+        case "GetTime":
+        case "GetRandom":
+        case "Log":
+        case "MakeHttpRequest":
+        case "Go":
+        case "OpenDatabase":
+        case "PushState":
+        case "ReplaceState":
+        case "RemoveStorageItem":
+        case "ReadClipboard":
+        case "RunDbTransaction":
+        case "ScrollElement":
+        case "ScrollWindow":
+        case "SetAppBadge":
+        case "SetDocumentTitle":
+        case "SetStorageItem":
+        case "SetTimeout":
+        case "WriteClipboard": {
+          return effect;
+        }
+        case "SubscribeToBroadcastChannel": {
+          return subscribeToBroadcastChannel(
+            effect.operation.input.channel,
+            (msg) => mapState(effect.operation.input.handler(msg), lens),
+            effect.operation.input.taskId
+          );
+        }
+        case "Async": {
+          return async(mapState(effect.operation.input.effect, lens), effect.operation.input.delayInMillis);
+        }
+        case "ScheduleTask": {
+          return scheduleTask(
+            mapState(effect.operation.input.task, lens),
+            effect.operation.input.initialDelayInMillis,
+            effect.operation.input.repeatIntervalInMillis,
+            effect.operation.input.taskId
+          );
+        }
+        case "Product": {
+          return product(
+            mapState(effect.operation.input[0], lens),
+            mapState(effect.operation.input[1], lens)
+          );
+        }
+        case "UpdateState": {
+          return updateState((stateB) => {
+            const stateAUpdate = effect.operation.input;
+            const stateA = lens.get(stateB);
+            const updatedStateA = stateAUpdate(stateA);
+            return lens.set(stateB, updatedStateA);
+          });
+        }
+        case "GetState":
+          return getState().map((b) => {
+            return lens.get(b);
+          });
+      }
+    }
+  }
+}
+function isEffect(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value !== "object") {
+    return false;
+  }
+  if (value["_type"] === "Return") {
+    return Object.prototype.hasOwnProperty.call(value, "value");
+  } else if (value["_type"] === "Suspend") {
+    return Object.prototype.hasOwnProperty.call(value, "operation");
+  } else if (value["_type"] === "FlatMap") {
+    return Object.prototype.hasOwnProperty.call(value, "effect");
+  } else {
+    return false;
+  }
+}
+function scrollWindow(options) {
+  return {
+    _type: "Suspend",
+    operation: { _type: "ScrollWindow", input: options },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, () => pure(f()));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function scrollElement(selector, options) {
+  return {
+    _type: "Suspend",
+    operation: { _type: "ScrollElement", input: { selector, options } },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, (result) => pure(f(result)));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function download(filename, content, contentType = "text/plain") {
+  return {
+    _type: "Suspend",
+    operation: { _type: "Download", input: { filename, content, contentType } },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, () => pure(f()));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function postBroadcastMessage(channel, message) {
+  return {
+    _type: "Suspend",
+    operation: { _type: "PostBroadcastMessage", input: { channel, message } },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, () => pure(f()));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_b) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function subscribeToBroadcastChannel(channel, handler, taskId2 = void 0) {
+  return {
+    _type: "Suspend",
+    operation: {
+      _type: "SubscribeToBroadcastChannel",
+      input: { channel, handler, taskId: taskId2 }
+    },
+    flatMap(f) {
+      return flatMap(this, f);
+    },
+    and(effect) {
+      return flatMap(this, (_) => effect);
+    },
+    map(f) {
+      return flatMap(this, (id) => pure(f(id)));
+    },
+    as(b) {
+      return flatMap(this, () => pure(b));
+    },
+    void() {
+      return this.map((_id) => {
+      });
+    },
+    apply(f) {
+      return f(this);
+    }
+  };
+}
+function noop() {
+  return pure(void 0);
+}
+function makeEffects() {
+  return {
+    alert,
+    confirm,
+    prompt,
+    cancelTask,
+    getLocation,
+    getNotificationPermission,
+    requestNotificationPermission,
+    clearAppBadge,
+    readClipboard,
+    setAppBadge,
+    setDocumentTitle,
+    writeClipboard,
+    fireEvent,
+    getState,
+    getTime,
+    getRandom,
+    log,
+    makeHttpRequest,
+    scheduleTask,
+    setTimeout,
+    updateState,
+    pure(a) {
+      return pure(a);
+    },
+    noop,
+    generateUuid,
+    getJson,
+    go,
+    scrollWindow,
+    scrollElement,
+    download,
+    postBroadcastMessage,
+    subscribeToBroadcastChannel,
+    pushState,
+    replaceState,
+    getLocalStorageItem,
+    setLocalStorageItem,
+    removeLocalStorageItem,
+    clearLocalStorage,
+    getSessionStorageItem,
+    setSessionStorageItem,
+    removeSessionStorageItem,
+    clearSessionStorage,
+    resultT(effect) {
+      return resultT(effect);
+    }
+  };
+}
+function traverse(as, f) {
+  const effects = as.map(f);
+  if (effects.length === 0) {
+    return pure([]);
+  }
+  return effects.reduce(
+    (acc, effect) => {
+      return product(acc, effect).map((bsAndB) => {
+        return [...bsAndB[0], bsAndB[1]];
+      });
+    },
+    pure([])
+  );
+}
+var ResultTransformer = class _ResultTransformer {
+  constructor(value) {
+    /** The underlying wrapped effect. */
+    __publicField(this, "value");
+    this.value = value;
+  }
+  /** Transforms the success value. */
+  map(f) {
+    return new _ResultTransformer(
+      this.value.map((res) => {
+        return res.map(f);
+      })
+    );
+  }
+  /** Replaces the success value with `b`. */
+  as(b) {
+    return new _ResultTransformer(
+      this.value.map((res) => {
+        return res.map((_) => b);
+      })
+    );
+  }
+  /** Discards the success value. */
+  void() {
+    return new _ResultTransformer(
+      this.value.map((res) => {
+        return res.map((_) => {
+        });
+      })
+    );
+  }
+  /** Discards the error value. */
+  errorVoid() {
+    return this.errorMap((_) => {
+    });
+  }
+  /** Chains on success, short-circuits on failure. */
+  flatMap(f) {
+    return new _ResultTransformer(
+      this.value.flatMap((res) => {
+        switch (res._tag) {
+          case "failure":
+            return pure(failure(res.error));
+          case "success":
+            return f(res.value);
+        }
+      })
+    );
+  }
+  /** Like `flatMap` but `f` returns an unwrapped Effect rather than an Effect of Result. */
+  semiFlatMap(f) {
+    return new _ResultTransformer(
+      this.value.flatMap((res) => {
+        switch (res._tag) {
+          case "failure":
+            return pure(failure(res.error));
+          case "success":
+            return f(res.value).map((b) => success(b));
+        }
+      })
+    );
+  }
+  /** Sequences on success, short-circuits on failure. */
+  and(effect) {
+    return new _ResultTransformer(
+      this.value.flatMap((res) => {
+        switch (res._tag) {
+          case "failure":
+            return pure(failure(res.error));
+          case "success":
+            return effect;
+        }
+      })
+    );
+  }
+  /** Unwraps the Result, returning either the success value or the error. */
+  merge() {
+    return this.value.map((res) => res.merge());
+  }
+  /** Logs the error to the console without changing the Result. */
+  logError() {
+    return this.errorFlatMap((e) => log(e).map((_) => e));
+  }
+  /** Logs the error and converts it to void. */
+  logAndDropError() {
+    return this.logError().errorVoid();
+  }
+  /** Transforms the error value. */
+  errorMap(f) {
+    return new _ResultTransformer(this.value.map((res) => res.errorMap(f)));
+  }
+  /** Chains on failure, short-circuits on success. */
+  errorFlatMap(f) {
+    return new _ResultTransformer(
+      this.value.flatMap((res) => {
+        switch (res._tag) {
+          case "failure":
+            return f(res.error).map((e) => failure(e));
+          case "success":
+            return pure(success(res.value));
+        }
+      })
+    );
+  }
+};
+function resultT(effect) {
+  return new ResultTransformer(effect);
+}
+
+export {
+  success,
+  failure,
+  ResponseBody,
+  exhaustivenessCheck,
+  eq,
+  stringToInt,
+  filterNot,
+  emptyPath,
+  parsePath,
+  parseFragment,
+  parseAllQueryParams,
+  formatLocation,
+  parseInternalLocation,
+  internalLocationFromLocation,
+  emptyLocation,
+  taskId,
+  customEffect,
+  pure,
+  alert,
+  confirm,
+  prompt,
+  clearAppBadge,
+  readClipboard,
+  writeClipboard,
+  setDocumentTitle,
+  setAppBadge,
+  async,
+  cancelTask,
+  fireEvent,
+  generateUuid,
+  getTime,
+  getRandom,
+  log,
+  makeHttpRequest,
+  getLocation,
+  getNotificationPermission,
+  requestNotificationPermission,
+  getState,
+  product,
+  scheduleTask,
+  setTimeout,
+  updateState,
+  openDatabase,
+  runDbTransaction,
+  go,
+  pushState,
+  replaceState,
+  getLocalStorageItem,
+  setLocalStorageItem,
+  removeLocalStorageItem,
+  clearLocalStorage,
+  getSessionStorageItem,
+  setSessionStorageItem,
+  removeSessionStorageItem,
+  clearSessionStorage,
+  mapEvent,
+  mapState,
+  isEffect,
+  scrollWindow,
+  scrollElement,
+  download,
+  postBroadcastMessage,
+  subscribeToBroadcastChannel,
+  noop,
+  makeEffects,
+  traverse,
+  ResultTransformer,
+  resultT
+};