ctrl-fx 0.0.1 → 0.1.1

package/dist/chunk-PKBMQBKP.js

@@ -0,0 +1,7 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+export {
+  __publicField
+};

package/dist/chunk-XICUXW4T.js

@@ -0,0 +1,252 @@
+// src/db/effects.ts
+function chain(effect, next) {
+  return {
+    _type: "FlatMap",
+    effect,
+    next,
+    flatMap(f) {
+      return chain(this, f);
+    },
+    map(f) {
+      return chain(this, (b) => ret(f(b)));
+    },
+    as(c) {
+      return chain(this, (_) => ret(c));
+    },
+    void() {
+      return this.map((_) => {
+      });
+    }
+  };
+}
+function ret(value) {
+  return {
+    _type: "Return",
+    value,
+    flatMap(f) {
+      return chain(this, f);
+    },
+    map(f) {
+      return chain(this, (a) => ret(f(a)));
+    },
+    as(b) {
+      return chain(this, (_) => ret(b));
+    },
+    void() {
+      return this.map((_) => {
+      });
+    }
+  };
+}
+function suspend(operation) {
+  return {
+    _type: "Suspend",
+    operation,
+    flatMap(f) {
+      return chain(this, f);
+    },
+    map(f) {
+      return chain(this, (a) => ret(f(a)));
+    },
+    as(b) {
+      return chain(this, (_) => ret(b));
+    },
+    void() {
+      return this.map((_) => {
+      });
+    }
+  };
+}
+function pure(a) {
+  return ret(a);
+}
+function noop() {
+  return ret(void 0);
+}
+function run(effect, interpreter, onComplete) {
+  switch (effect._type) {
+    case "Return":
+      return onComplete(effect.value);
+    case "Suspend":
+      return interpreter(effect.operation, onComplete);
+    case "FlatMap":
+      return run(
+        effect.effect,
+        interpreter,
+        (result) => run(effect.next(result), interpreter, onComplete)
+      );
+  }
+}
+function add(objectStore2, value) {
+  return suspend({ _type: "Add", objectStore: objectStore2, value });
+}
+function put(objectStore2, value) {
+  return suspend({ _type: "Put", objectStore: objectStore2, value });
+}
+function get(objectStore2, key) {
+  return suspend({ _type: "Get", objectStore: objectStore2, key });
+}
+function getAll(objectStore2) {
+  return suspend({ _type: "GetAll", objectStore: objectStore2 });
+}
+function deleteRecord(objectStore2, key) {
+  return suspend({ _type: "Delete", objectStore: objectStore2, key });
+}
+function count(objectStore2) {
+  return suspend({ _type: "Count", objectStore: objectStore2 });
+}
+
+// src/db/setup.ts
+function chain2(effect, next) {
+  return {
+    _type: "FlatMap",
+    effect,
+    next,
+    flatMap(f) {
+      return chain2(this, f);
+    },
+    map(f) {
+      return chain2(this, (b) => ret2(f(b)));
+    },
+    as(c) {
+      return chain2(this, (_) => ret2(c));
+    },
+    void() {
+      return this.map((_) => {
+      });
+    }
+  };
+}
+function ret2(value) {
+  return {
+    _type: "Return",
+    value,
+    flatMap(f) {
+      return chain2(this, f);
+    },
+    map(f) {
+      return chain2(this, (a) => ret2(f(a)));
+    },
+    as(b) {
+      return chain2(this, (_) => ret2(b));
+    },
+    void() {
+      return this.map((_) => {
+      });
+    }
+  };
+}
+function suspend2(operation) {
+  return {
+    _type: "Suspend",
+    operation,
+    flatMap(f) {
+      return chain2(this, f);
+    },
+    map(f) {
+      return chain2(this, (a) => ret2(f(a)));
+    },
+    as(b) {
+      return chain2(this, (_) => ret2(b));
+    },
+    void() {
+      return this.map((_) => {
+      });
+    }
+  };
+}
+function run2(effect, interpreter, onComplete) {
+  switch (effect._type) {
+    case "Return":
+      return onComplete(effect.value);
+    case "Suspend":
+      return interpreter(effect.operation, onComplete);
+    case "FlatMap":
+      return run2(
+        effect.effect,
+        interpreter,
+        (result) => run2(effect.next(result), interpreter, onComplete)
+      );
+  }
+}
+function createObjectStore(objectStore2, keyPath) {
+  return suspend2({ _type: "CreateObjectStore", objectStore: objectStore2, keyPath });
+}
+function createIndex(objectStore2, index2, keyPath, unique) {
+  return suspend2({ _type: "CreateIndex", objectStore: objectStore2, index: index2, keyPath, unique });
+}
+function deleteObjectStore(objectStore2) {
+  return suspend2({ _type: "DeleteObjectStore", objectStore: objectStore2 });
+}
+function deleteIndex(objectStore2, index2) {
+  return suspend2({ _type: "DeleteIndex", objectStore: objectStore2, index: index2 });
+}
+function getObjectStoreNames() {
+  return suspend2({ _type: "GetObjectStoreNames" });
+}
+function getIndexNames(objectStore2) {
+  return suspend2({ _type: "GetIndexNames", objectStore: objectStore2 });
+}
+function runDbEffect(effect) {
+  return suspend2({ _type: "RunDbEffect", effect });
+}
+
+// src/db/keypath.ts
+function autoIncrementPath(value) {
+  return { _type: "AutoIncrement", value };
+}
+function manualPath(value) {
+  return { _type: "Manual", value };
+}
+function multiPath(first, second, ...rest) {
+  return { _type: "Multi", first, second, rest };
+}
+function singleIndexPath(value) {
+  return { _type: "SingleIndex", value };
+}
+function multiIndexPath(first, second, rest, multiEntry) {
+  return { _type: "MultiIndex", first, second, rest, multiEntry };
+}
+
+// src/db/index.ts
+function dbName(value) {
+  return value;
+}
+function dbVersion(value) {
+  return value;
+}
+function objectStore(value) {
+  return value;
+}
+function index(value) {
+  return value;
+}
+
+export {
+  pure,
+  noop,
+  run,
+  add,
+  put,
+  get,
+  getAll,
+  deleteRecord,
+  count,
+  run2,
+  createObjectStore,
+  createIndex,
+  deleteObjectStore,
+  deleteIndex,
+  getObjectStoreNames,
+  getIndexNames,
+  runDbEffect,
+  autoIncrementPath,
+  manualPath,
+  multiPath,
+  singleIndexPath,
+  multiIndexPath,
+  dbName,
+  dbVersion,
+  objectStore,
+  index
+};

package/dist/db/index.d.ts

@@ -0,0 +1,234 @@
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+
+type DbAdd = {
+    readonly _type: 'Add';
+    readonly objectStore: ObjectStore;
+    readonly value: JsonValue;
+};
+type DbPut = {
+    readonly _type: 'Put';
+    readonly objectStore: ObjectStore;
+    readonly value: JsonValue;
+};
+type DbGet = {
+    readonly _type: 'Get';
+    readonly objectStore: ObjectStore;
+    readonly key: IDBValidKey;
+};
+type DbGetAll = {
+    readonly _type: 'GetAll';
+    readonly objectStore: ObjectStore;
+};
+type DbDelete = {
+    readonly _type: 'Delete';
+    readonly objectStore: ObjectStore;
+    readonly key: IDBValidKey;
+};
+type DbCount = {
+    readonly _type: 'Count';
+    readonly objectStore: ObjectStore;
+};
+type DbOperation = DbAdd | DbPut | DbGet | DbGetAll | DbDelete | DbCount;
+type DbReturn<A> = {
+    readonly _type: 'Return';
+    readonly value: A;
+    flatMap<B>(f: (a: A) => DbEffect<B>): DbEffect<B>;
+    map<B>(f: (a: A) => B): DbEffect<B>;
+    as<B>(b: B): DbEffect<B>;
+    void(): DbEffect<void>;
+};
+type DbSuspend<A> = {
+    readonly _type: 'Suspend';
+    readonly operation: DbOperation;
+    flatMap<B>(f: (a: A) => DbEffect<B>): DbEffect<B>;
+    map<B>(f: (a: A) => B): DbEffect<B>;
+    as<B>(b: B): DbEffect<B>;
+    void(): DbEffect<void>;
+};
+type DbChain<A> = {
+    readonly _type: 'FlatMap';
+    readonly effect: DbEffect<any>;
+    readonly next: (x: any) => DbEffect<A>;
+    flatMap<B>(f: (a: A) => DbEffect<B>): DbEffect<B>;
+    map<B>(f: (a: A) => B): DbEffect<B>;
+    as<B>(b: B): DbEffect<B>;
+    void(): DbEffect<void>;
+};
+/** A lazy, composable IndexedDB operation that produces a value of type `A`. Chain with `.flatMap`. */
+type DbEffect<A> = DbReturn<A> | DbSuspend<A> | DbChain<A>;
+/** Lifts a plain value into a `DbEffect` without performing any database operation. */
+declare function pure<A>(a: A): DbEffect<A>;
+/** A `DbEffect` that does nothing. Useful as a no-op in conditional chains. */
+declare function noop(): DbEffect<void>;
+/** A DbEffect describing an insert of `value` into `objectStore`. Fails if a record with the same key already exists. */
+declare function add(objectStore: ObjectStore, value: JsonValue): DbEffect<void>;
+/** A DbEffect describing an insert-or-replace of `value` in `objectStore` (upsert). */
+declare function put(objectStore: ObjectStore, value: JsonValue): DbEffect<void>;
+/** A DbEffect describing a retrieval of the record with `key` from `objectStore`, or `undefined` if not found. */
+declare function get(objectStore: ObjectStore, key: IDBValidKey): DbEffect<JsonValue | undefined>;
+/** A DbEffect describing a retrieval of all records from `objectStore`. */
+declare function getAll(objectStore: ObjectStore): DbEffect<JsonValue[]>;
+/** A DbEffect describing the deletion of the record with `key` from `objectStore`. */
+declare function deleteRecord(objectStore: ObjectStore, key: IDBValidKey): DbEffect<void>;
+/** A DbEffect describing a record count in `objectStore`. */
+declare function count(objectStore: ObjectStore): DbEffect<number>;
+
+type AutoIncrementPath = {
+    readonly _type: 'AutoIncrement';
+    readonly value: string;
+};
+type ManualPath = {
+    readonly _type: 'Manual';
+    readonly value: string;
+};
+type MultiPath = {
+    readonly _type: 'Multi';
+    readonly first: string;
+    readonly second: string;
+    readonly rest: readonly string[];
+};
+/** Describes how an object store's primary key is derived from stored values. */
+type KeyPath = AutoIncrementPath | ManualPath | MultiPath;
+/** Key is stored under `value` and auto-incremented by IndexedDB if absent. */
+declare function autoIncrementPath(value: string): KeyPath;
+/** Key is read from the `value` property of each stored object; caller must provide it. */
+declare function manualPath(value: string): KeyPath;
+/** Key is a compound of two or more property paths. */
+declare function multiPath(first: string, second: string, ...rest: string[]): KeyPath;
+type SingleIndexPath = {
+    readonly _type: 'SingleIndex';
+    readonly value: string;
+};
+type MultiIndexPath = {
+    readonly _type: 'MultiIndex';
+    readonly first: string;
+    readonly second: string;
+    readonly rest: readonly string[];
+    readonly multiEntry: boolean;
+};
+/** Describes how an IndexedDB index key is derived from stored values. */
+type IndexKeyPath = SingleIndexPath | MultiIndexPath;
+/** Index key is read from a single property. */
+declare function singleIndexPath(value: string): IndexKeyPath;
+/** Index key is a compound of two or more properties. Set `multiEntry: true` to index array values individually. */
+declare function multiIndexPath(first: string, second: string, rest: readonly string[], multiEntry: boolean): IndexKeyPath;
+
+type CreateObjectStore = {
+    readonly _type: 'CreateObjectStore';
+    readonly objectStore: ObjectStore;
+    readonly keyPath: KeyPath;
+};
+type CreateIndex = {
+    readonly _type: 'CreateIndex';
+    readonly objectStore: ObjectStore;
+    readonly index: Index;
+    readonly keyPath: IndexKeyPath;
+    readonly unique: boolean;
+};
+type DeleteObjectStore = {
+    readonly _type: 'DeleteObjectStore';
+    readonly objectStore: ObjectStore;
+};
+type DeleteIndex = {
+    readonly _type: 'DeleteIndex';
+    readonly objectStore: ObjectStore;
+    readonly index: Index;
+};
+type GetObjectStoreNames = {
+    readonly _type: 'GetObjectStoreNames';
+};
+type GetIndexNames = {
+    readonly _type: 'GetIndexNames';
+    readonly objectStore: ObjectStore;
+};
+type RunDbEffect = {
+    readonly _type: 'RunDbEffect';
+    readonly effect: DbEffect<void>;
+};
+type DbSetupOperation = CreateObjectStore | CreateIndex | DeleteObjectStore | DeleteIndex | GetObjectStoreNames | GetIndexNames | RunDbEffect;
+type DbSetupReturn<A> = {
+    readonly _type: 'Return';
+    readonly value: A;
+    flatMap<B>(f: (a: A) => DbSetupEffect<B>): DbSetupEffect<B>;
+    map<B>(f: (a: A) => B): DbSetupEffect<B>;
+    as<B>(b: B): DbSetupEffect<B>;
+    void(): DbSetupEffect<void>;
+};
+type DbSetupSuspend<A> = {
+    readonly _type: 'Suspend';
+    readonly operation: DbSetupOperation;
+    flatMap<B>(f: (a: A) => DbSetupEffect<B>): DbSetupEffect<B>;
+    map<B>(f: (a: A) => B): DbSetupEffect<B>;
+    as<B>(b: B): DbSetupEffect<B>;
+    void(): DbSetupEffect<void>;
+};
+type DbSetupChain<A> = {
+    readonly _type: 'FlatMap';
+    readonly effect: DbSetupEffect<any>;
+    readonly next: (x: any) => DbSetupEffect<A>;
+    flatMap<B>(f: (a: A) => DbSetupEffect<B>): DbSetupEffect<B>;
+    map<B>(f: (a: A) => B): DbSetupEffect<B>;
+    as<B>(b: B): DbSetupEffect<B>;
+    void(): DbSetupEffect<void>;
+};
+/** A lazy schema-migration operation that produces a value of type `A`. Run via `runDbEffect`. */
+type DbSetupEffect<A> = DbSetupReturn<A> | DbSetupSuspend<A> | DbSetupChain<A>;
+/** A DbSetupEffect describing the creation of a new object store with the given key path. */
+declare function createObjectStore(objectStore: ObjectStore, keyPath: KeyPath): DbSetupEffect<void>;
+/** A DbSetupEffect describing the creation of an index on an object store. */
+declare function createIndex(objectStore: ObjectStore, index: Index, keyPath: IndexKeyPath, unique: boolean): DbSetupEffect<void>;
+/** A DbSetupEffect describing the deletion of an object store. */
+declare function deleteObjectStore(objectStore: ObjectStore): DbSetupEffect<void>;
+/** A DbSetupEffect describing the deletion of an index from an object store. */
+declare function deleteIndex(objectStore: ObjectStore, index: Index): DbSetupEffect<void>;
+/** A DbSetupEffect describing a read of all object store names in the database. */
+declare function getObjectStoreNames(): DbSetupEffect<readonly string[]>;
+/** A DbSetupEffect describing a read of all index names on the given object store. */
+declare function getIndexNames(objectStore: ObjectStore): DbSetupEffect<readonly string[]>;
+/** A DbSetupEffect describing the embedding of a `DbEffect` inside a setup operation, useful for seeding data during an upgrade. */
+declare function runDbEffect(effect: DbEffect<void>): DbSetupEffect<void>;
+
+type DbError = UnexpectedError | NotFoundError | ConstraintError;
+interface UnexpectedError {
+    readonly _type: 'UnexpectedError';
+    readonly message?: string;
+    readonly cause?: Error;
+}
+interface NotFoundError {
+    readonly _type: 'NotFoundError';
+    readonly cause: Error;
+}
+interface ConstraintError {
+    readonly _type: 'ConstraintError';
+    readonly cause: Error;
+}
+
+/** Branded string representing an IndexedDB database name. */
+type DbName = string & {
+    __brand: 'DbName';
+};
+/** Creates a `DbName`. */
+declare function dbName(value: string): DbName;
+/** Branded number representing an IndexedDB database schema version. */
+type DbVersion = number & {
+    __brand: 'DbVersion';
+};
+/** Creates a `DbVersion`. */
+declare function dbVersion(value: number): DbVersion;
+/** Branded string representing the name of an IndexedDB object store. */
+type ObjectStore = string & {
+    __brand: 'ObjectStore';
+};
+/** Creates an `ObjectStore` name. */
+declare function objectStore(value: string): ObjectStore;
+/** Branded string representing the name of an IndexedDB index. */
+type Index = string & {
+    __brand: 'Index';
+};
+/** Creates an `Index` name. */
+declare function index(value: string): Index;
+
+export { type AutoIncrementPath, type ConstraintError, type DbEffect, type DbError, type DbName, type DbSetupEffect, type DbVersion, type Index, type IndexKeyPath, type JsonPrimitive, type JsonValue, type KeyPath, type ManualPath, type MultiIndexPath, type MultiPath, type NotFoundError, type ObjectStore, type SingleIndexPath, type UnexpectedError, add, autoIncrementPath, count, createIndex, createObjectStore, dbName, noop as dbNoop, pure as dbPure, dbVersion, deleteIndex, deleteObjectStore, deleteRecord, get, getAll, getIndexNames, getObjectStoreNames, index, manualPath, multiIndexPath, multiPath, objectStore, put, runDbEffect, singleIndexPath };

package/dist/db/index.js

@@ -0,0 +1,53 @@
+import {
+  add,
+  autoIncrementPath,
+  count,
+  createIndex,
+  createObjectStore,
+  dbName,
+  dbVersion,
+  deleteIndex,
+  deleteObjectStore,
+  deleteRecord,
+  get,
+  getAll,
+  getIndexNames,
+  getObjectStoreNames,
+  index,
+  manualPath,
+  multiIndexPath,
+  multiPath,
+  noop,
+  objectStore,
+  pure,
+  put,
+  runDbEffect,
+  singleIndexPath
+} from "../chunk-XICUXW4T.js";
+import "../chunk-PKBMQBKP.js";
+export {
+  add,
+  autoIncrementPath,
+  count,
+  createIndex,
+  createObjectStore,
+  dbName,
+  noop as dbNoop,
+  pure as dbPure,
+  dbVersion,
+  deleteIndex,
+  deleteObjectStore,
+  deleteRecord,
+  get,
+  getAll,
+  getIndexNames,
+  getObjectStoreNames,
+  index,
+  manualPath,
+  multiIndexPath,
+  multiPath,
+  objectStore,
+  put,
+  runDbEffect,
+  singleIndexPath
+};

package/dist/dom/index.d.ts

@@ -0,0 +1,2 @@
+export { aB as A, aC as Abbr, aD as Address, aE as Article, aF as Aside, A as Attr, aG as AttrArg, aH as AttrOrNodeIdArgs, aI as B, aJ as BlockElement, aK as Blockquote, aL as Br, aM as Button, aN as ButtonContent, aO as ChangeData, aP as Circle, aQ as Cite, aR as Code, C as Component, aS as ComponentElement, aT as CustomElement, aU as Dd, aV as Details, aW as Div, aX as Dl, aY as Dt, aZ as Element, a_ as Ellipse, a$ as Em, a as EventActions, b0 as EventListenerResult, b1 as EventOptions, b2 as Fieldset, b3 as Figcaption, b4 as Figure, b5 as FlowContent, b6 as Footer, b7 as Form, b8 as H1, b9 as H2, ba as H3, bb as H4, bc as H5, bd as H6, be as Header, bf as Hr, bg as I, bh as Image, bi as Img, bj as InlineElement, bk as Input, bl as Kbd, bm as KeyData, bn as Label, bo as Li, bp as Line, bq as Main, br as Mark, bs as MouseMoveData, bt as Nav, e as Node, N as NodeGroup, bu as NodeId, bv as NonTextNode, bw as NonVoidElement, bx as Ol, by as Option, bz as P, bA as Path, bB as PhrasingContent, bC as Polygon, bD as Polyline, bE as Pre, bF as Prop, bG as Q, bH as Rect, bI as ReplacedElement, bJ as S, bK as ScrollData, bL as Section, bM as Select, bN as Small, bO as Span, bP as Strong, bQ as Sub, bR as Summary, bS as Sup, bT as Svg, bU as SvgGraphicElement, bV as Table, bW as Tbody, bX as Td, bY as TextState, bZ as Textarea, b_ as Tfoot, b$ as Th, c0 as Thead, c1 as Time, c2 as TouchData, c3 as Tr, c4 as U, c5 as Ul, c6 as Use, c7 as View, c8 as VoidElement, c9 as WheelData, ca as attr, cb as component, cc as cssVars, cd as foldNode, ce as id, cf as makeDom, cg as nodeId, ch as preventDefault, ci as prop, cj as stopPropagation, ck as stopPropagationAndPreventDefault, cl as typeAttr } from '../index-fpCmXVEu.js';
+import '../db/index.js';

package/dist/dom/index.js

@@ -0,0 +1,30 @@
+import {
+  attr,
+  component,
+  cssVars,
+  foldNode,
+  id,
+  makeDom,
+  nodeId,
+  preventDefault,
+  prop,
+  stopPropagation,
+  stopPropagationAndPreventDefault,
+  typeAttr
+} from "../chunk-NSWOTCDU.js";
+import "../chunk-KNHJPAIU.js";
+import "../chunk-PKBMQBKP.js";
+export {
+  attr,
+  component,
+  cssVars,
+  foldNode,
+  id,
+  makeDom,
+  nodeId,
+  preventDefault,
+  prop,
+  stopPropagation,
+  stopPropagationAndPreventDefault,
+  typeAttr
+};

package/dist/effects.d.ts

@@ -0,0 +1,2 @@
+export { f as ClipboardError, g as DecodingError, h as DownloadInput, E as Effect, F as FlatMap, j as Fragment, k as Headers, d as HttpError, H as HttpRequest, b as HttpResponse, I as InternalLocation, J as Json, L as Lens, M as Method, l as Path, Q as QueryParam, c as RequestError, n as ResponseBody, R as Result, o as ResultTransformer, q as Return, r as ScrollElementError, S as ScrollOptions, s as StorageTarget, v as Suspend, T as TaskId, w as alert, x as async, y as cancelTask, z as clearAppBadge, B as clearLocalStorage, G as clearSessionStorage, K as confirm, O as customEffect, V as download, W as fireEvent, X as generateUuid, Y as getLocalStorageItem, Z as getLocation, _ as getNotificationPermission, $ as getRandom, a0 as getSessionStorageItem, a1 as getState, a2 as getTime, a3 as go, a4 as isEffect, a5 as log, a6 as makeEffects, a7 as makeHttpRequest, a8 as mapEvent, a9 as mapState, aa as noop, ab as openDatabase, ac as postBroadcastMessage, ad as product, ae as prompt, af as pure, ag as pushState, ah as readClipboard, ai as removeLocalStorageItem, aj as removeSessionStorageItem, ak as replaceState, al as requestNotificationPermission, am as resultT, an as runDbTransaction, ao as scheduleTask, ap as scrollElement, aq as scrollWindow, ar as setAppBadge, as as setDocumentTitle, at as setLocalStorageItem, au as setSessionStorageItem, av as setTimeout, aw as subscribeToBroadcastChannel, ax as taskId, ay as traverse, az as updateState, aA as writeClipboard } from './index-fpCmXVEu.js';
+export { ConstraintError, DbEffect, DbError, DbName, DbSetupEffect, DbVersion, NotFoundError, ObjectStore, UnexpectedError } from './db/index.js';

package/dist/effects.js

@@ -0,0 +1,111 @@
+import {
+  ResultTransformer,
+  alert,
+  async,
+  cancelTask,
+  clearAppBadge,
+  clearLocalStorage,
+  clearSessionStorage,
+  confirm,
+  customEffect,
+  download,
+  fireEvent,
+  generateUuid,
+  getLocalStorageItem,
+  getLocation,
+  getNotificationPermission,
+  getRandom,
+  getSessionStorageItem,
+  getState,
+  getTime,
+  go,
+  isEffect,
+  log,
+  makeEffects,
+  makeHttpRequest,
+  mapEvent,
+  mapState,
+  noop,
+  openDatabase,
+  postBroadcastMessage,
+  product,
+  prompt,
+  pure,
+  pushState,
+  readClipboard,
+  removeLocalStorageItem,
+  removeSessionStorageItem,
+  replaceState,
+  requestNotificationPermission,
+  resultT,
+  runDbTransaction,
+  scheduleTask,
+  scrollElement,
+  scrollWindow,
+  setAppBadge,
+  setDocumentTitle,
+  setLocalStorageItem,
+  setSessionStorageItem,
+  setTimeout,
+  subscribeToBroadcastChannel,
+  taskId,
+  traverse,
+  updateState,
+  writeClipboard
+} from "./chunk-KNHJPAIU.js";
+import "./chunk-PKBMQBKP.js";
+export {
+  ResultTransformer,
+  alert,
+  async,
+  cancelTask,
+  clearAppBadge,
+  clearLocalStorage,
+  clearSessionStorage,
+  confirm,
+  customEffect,
+  download,
+  fireEvent,
+  generateUuid,
+  getLocalStorageItem,
+  getLocation,
+  getNotificationPermission,
+  getRandom,
+  getSessionStorageItem,
+  getState,
+  getTime,
+  go,
+  isEffect,
+  log,
+  makeEffects,
+  makeHttpRequest,
+  mapEvent,
+  mapState,
+  noop,
+  openDatabase,
+  postBroadcastMessage,
+  product,
+  prompt,
+  pure,
+  pushState,
+  readClipboard,
+  removeLocalStorageItem,
+  removeSessionStorageItem,
+  replaceState,
+  requestNotificationPermission,
+  resultT,
+  runDbTransaction,
+  scheduleTask,
+  scrollElement,
+  scrollWindow,
+  setAppBadge,
+  setDocumentTitle,
+  setLocalStorageItem,
+  setSessionStorageItem,
+  setTimeout,
+  subscribeToBroadcastChannel,
+  taskId,
+  traverse,
+  updateState,
+  writeClipboard
+};