ctrl-fx 0.0.1 → 0.1.1

package/dist/chunk-NSWOTCDU.js

@@ -0,0 +1,916 @@
+import {
+  async,
+  isEffect,
+  pure
+} from "./chunk-KNHJPAIU.js";
+
+// src/dom/nodeid.ts
+function nodeId(value) {
+  return {
+    _tag: "node_id",
+    value,
+    eq(that) {
+      return this.value === that.value;
+    }
+  };
+}
+function isNodeId(value) {
+  if (value) {
+    if (typeof value === "object") {
+      if (Object.prototype.hasOwnProperty.call(value, "_tag")) {
+        const tag = value["_tag"];
+        if (tag) {
+          return tag === "node_id";
+        }
+      }
+    }
+  }
+  return false;
+}
+function findNodeId(items) {
+  return items.find(isNodeId);
+}
+
+// src/dom/attrs.ts
+function attr(name, value) {
+  return {
+    name,
+    value
+  };
+}
+function prop(name, value) {
+  return { name, value };
+}
+function normalizeAttrArg(arg) {
+  if (Array.isArray(arg)) {
+    return { name: arg[0], value: arg[1] };
+  } else if (typeof arg === "object") {
+    return arg;
+  } else {
+    return { name: arg };
+  }
+}
+function normalizeAttrArgs(args) {
+  const attrs = [];
+  args.forEach((arg) => {
+    if (!isNodeId(arg)) {
+      attrs.push(normalizeAttrArg(arg));
+    }
+  });
+  return attrs;
+}
+function getId(attrs) {
+  const id2 = attrs.find((a) => a.name.toLowerCase() === "id");
+  return id2 ? id2.value : void 0;
+}
+function id(value) {
+  return attr("id", value);
+}
+function typeAttr(value) {
+  return attr("type", value);
+}
+function cssVars(vars) {
+  return attr(
+    "style",
+    Object.entries(vars).map(([k, v]) => `${k}: ${v}`).join("; ")
+  );
+}
+
+// src/dom/events.ts
+var eventTypes = [
+  "blur",
+  "change",
+  "click",
+  "dblclick",
+  "focus",
+  "keydown",
+  "keyup",
+  "mouseenter",
+  "mouseleave",
+  "mousemove",
+  "scroll",
+  "scrollend",
+  "submit",
+  "textinput",
+  "touchstart",
+  "touchmove",
+  "touchend",
+  "touchcancel",
+  "wheel"
+];
+function eventSupport() {
+  return {
+    ...blurFocusSupport(),
+    ...changeSupport(),
+    ...clickSupport(),
+    ...customEventSupport(),
+    ...keySupport(),
+    ...dblClickSupport(),
+    ...mouseSupport(),
+    ...mouseMoveSupport(),
+    ...scrollSupport(),
+    ...submitSupport(),
+    ...wheelSupport(),
+    ...textInputSupport(),
+    ...touchSupport()
+  };
+}
+function customEventSupport() {
+  return {
+    onEvent(eventName, effect, options) {
+      return {
+        ...this,
+        eventListeners: [
+          ...this.eventListeners,
+          { _type: "custom", eventName, effect, options: options || {} }
+        ]
+      };
+    }
+  };
+}
+function blurFocusSupport() {
+  return {
+    onFocus(effect, options) {
+      return {
+        ...this,
+        eventListeners: [
+          ...this.eventListeners,
+          { _type: "focus", effect, options: options || {} }
+        ]
+      };
+    },
+    onBlur(effect, options) {
+      return {
+        ...this,
+        eventListeners: [
+          ...this.eventListeners,
+          { _type: "blur", effect, options: options || {} }
+        ]
+      };
+    }
+  };
+}
+function changeSupport() {
+  return {
+    onChange(effect, options) {
+      return {
+        ...this,
+        eventListeners: [
+          ...this.eventListeners,
+          { _type: "change", effect, options: options || {} }
+        ]
+      };
+    }
+  };
+}
+function clickSupport() {
+  return {
+    onClick(effect, options) {
+      return {
+        ...this,
+        eventListeners: [
+          ...this.eventListeners,
+          { _type: "click", effect, options: options || {} }
+        ]
+      };
+    }
+  };
+}
+function dblClickSupport() {
+  return {
+    onDblClick(effect, options) {
+      return {
+        ...this,
+        eventListeners: [
+          ...this.eventListeners,
+          { _type: "dblclick", effect, options: options || {} }
+        ]
+      };
+    }
+  };
+}
+function mouseMoveSupport() {
+  return {
+    onMouseMove(effect, options) {
+      return {
+        ...this,
+        eventListeners: [
+          ...this.eventListeners,
+          { _type: "mousemove", effect, options: options || {} }
+        ]
+      };
+    }
+  };
+}
+function wheelSupport() {
+  return {
+    onWheel(effect, options) {
+      return {
+        ...this,
+        eventListeners: [
+          ...this.eventListeners,
+          { _type: "wheel", effect, options: options || {} }
+        ]
+      };
+    }
+  };
+}
+function mouseSupport() {
+  return {
+    onMouseEnter(effect, options) {
+      return {
+        ...this,
+        eventListeners: [
+          ...this.eventListeners,
+          { _type: "mouseenter", effect, options: options || {} }
+        ]
+      };
+    },
+    onMouseLeave(effect, options) {
+      return {
+        ...this,
+        eventListeners: [
+          ...this.eventListeners,
+          { _type: "mouseleave", effect, options: options || {} }
+        ]
+      };
+    }
+  };
+}
+function submitSupport() {
+  return {
+    onSubmit(effect, options) {
+      return {
+        ...this,
+        eventListeners: [
+          ...this.eventListeners,
+          { _type: "submit", effect, options: options || {} }
+        ]
+      };
+    }
+  };
+}
+function scrollSupport() {
+  return {
+    onScroll(effect, options) {
+      return {
+        ...this,
+        eventListeners: [
+          ...this.eventListeners,
+          { _type: "scroll", effect, options: options || {} }
+        ]
+      };
+    },
+    onScrollEnd(effect, options) {
+      return {
+        ...this,
+        eventListeners: [
+          ...this.eventListeners,
+          { _type: "scrollend", effect, options: options || {} }
+        ]
+      };
+    }
+  };
+}
+function touchSupport() {
+  return {
+    onTouchStart(effect, options) {
+      return {
+        ...this,
+        eventListeners: [
+          ...this.eventListeners,
+          { _type: "touchstart", effect, options: options || {} }
+        ]
+      };
+    },
+    onTouchMove(effect, options) {
+      return {
+        ...this,
+        eventListeners: [
+          ...this.eventListeners,
+          { _type: "touchmove", effect, options: options || {} }
+        ]
+      };
+    },
+    onTouchEnd(effect, options) {
+      return {
+        ...this,
+        eventListeners: [
+          ...this.eventListeners,
+          { _type: "touchend", effect, options: options || {} }
+        ]
+      };
+    },
+    onTouchCancel(effect, options) {
+      return {
+        ...this,
+        eventListeners: [
+          ...this.eventListeners,
+          { _type: "touchcancel", effect, options: options || {} }
+        ]
+      };
+    }
+  };
+}
+function keySupport() {
+  return {
+    onKeyDown(effect, options) {
+      return {
+        ...this,
+        eventListeners: [
+          ...this.eventListeners,
+          { _type: "keydown", effect, options: options || {} }
+        ]
+      };
+    },
+    onKeyUp(effect, options) {
+      return {
+        ...this,
+        eventListeners: [
+          ...this.eventListeners,
+          { _type: "keyup", effect, options: options || {} }
+        ]
+      };
+    }
+  };
+}
+function textInputSupport() {
+  return {
+    onTextInput(effect, options) {
+      return {
+        ...this,
+        eventListeners: [
+          ...this.eventListeners,
+          { _type: "textinput", effect, options: options || {} }
+        ]
+      };
+    }
+  };
+}
+function preventDefault(effect) {
+  return async(effect, 0).as({ preventDefault: true });
+}
+function stopPropagation(effect) {
+  return async(effect, 0).as({ stopPropagation: true });
+}
+function stopPropagationAndPreventDefault(effect) {
+  return async(effect, 0).as({ stopPropagation: true, preventDefault: true });
+}
+var windowContainerEventTypes = ["resize", "popstate", "locationchange", "online", "offline"];
+var documentContainerEventTypes = ["keydown", "keyup", "visibilitychange"];
+var containerEventTypes = [
+  ...windowContainerEventTypes,
+  ...documentContainerEventTypes
+];
+
+// src/dom/views.ts
+function nodeGroup(...nodes) {
+  return {
+    _type: "NodeGroup",
+    nodes,
+    containerListeners: [],
+    onResize(effect) {
+      return {
+        ...this,
+        containerListeners: [
+          ...this.containerListeners,
+          {
+            _type: "resize",
+            onChange: effect,
+            options: {}
+          }
+        ]
+      };
+    },
+    onPopState(effect) {
+      return {
+        ...this,
+        containerListeners: [
+          ...this.containerListeners,
+          {
+            _type: "popstate",
+            onChange: effect,
+            options: {}
+          }
+        ]
+      };
+    },
+    onLocationChange(effect) {
+      return {
+        ...this,
+        containerListeners: [
+          ...this.containerListeners,
+          {
+            _type: "locationchange",
+            onChange: effect,
+            options: {}
+          }
+        ]
+      };
+    },
+    onKeyDown(effect) {
+      return {
+        ...this,
+        containerListeners: [
+          ...this.containerListeners,
+          {
+            _type: "keydown",
+            effect,
+            options: {}
+          }
+        ]
+      };
+    },
+    onKeyUp(effect) {
+      return {
+        ...this,
+        containerListeners: [
+          ...this.containerListeners,
+          { _type: "keyup", effect, options: {} }
+        ]
+      };
+    },
+    onVisibilityChange(effect) {
+      return {
+        ...this,
+        containerListeners: [
+          ...this.containerListeners,
+          { _type: "visibilitychange", onChange: effect, options: {} }
+        ]
+      };
+    },
+    onOnline(effect) {
+      return {
+        ...this,
+        containerListeners: [
+          ...this.containerListeners,
+          { _type: "online", effect, options: {} }
+        ]
+      };
+    },
+    onOffline(effect) {
+      return {
+        ...this,
+        containerListeners: [
+          ...this.containerListeners,
+          { _type: "offline", effect, options: {} }
+        ]
+      };
+    },
+    renderEffects: [],
+    onRender(...effects) {
+      return {
+        ...this,
+        renderEffects: effects
+      };
+    }
+  };
+}
+function _(...nodes) {
+  return nodeGroup(...nodes);
+}
+function view(id2, nodes) {
+  return (params) => ({
+    _type: "View",
+    nodeId: typeof id2 === "string" ? nodeId(id2) : id2,
+    params,
+    nodes: (params2) => {
+      const nodeOrNodeGroup = nodes(params2);
+      return isNodeGroup(nodeOrNodeGroup) ? nodeOrNodeGroup : _(nodeOrNodeGroup);
+    }
+  });
+}
+function fixedView(id2) {
+  return (nodes) => ({
+    _type: "View",
+    nodeId: typeof id2 === "string" ? nodeId(id2) : id2,
+    params: void 0,
+    nodes: () => isNodeGroup(nodes) ? nodes : _(nodes)
+  });
+}
+function isNodeGroup(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value !== "object") {
+    return false;
+  }
+  return Object.prototype.hasOwnProperty.call(value, "_type") && // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  value["_type"] === "NodeGroup" && Object.prototype.hasOwnProperty.call(value, "nodes") && Object.prototype.hasOwnProperty.call(value, "containerListeners");
+}
+
+// src/dom/components.ts
+function componentElem(component2, nodeId2, params) {
+  const resolvedComponent = params !== void 0 ? { ...component2, params } : component2;
+  return {
+    _type: "Component",
+    nodeId: nodeId2,
+    component: resolvedComponent,
+    componentEventListeners: [],
+    onEvent(eventListener) {
+      const eventListeners = this.componentEventListeners;
+      return {
+        ...this,
+        componentEventListeners: [...eventListeners, eventListener]
+      };
+    }
+  };
+}
+function toComponent(view2, initialState, params, css) {
+  return {
+    _type: "Component",
+    params,
+    css,
+    initialState(params2) {
+      const result = initialState(params2);
+      if (isEffect(result)) {
+        return result;
+      } else {
+        return pure(result);
+      }
+    },
+    view(state, params2) {
+      const result = view2(state, params2);
+      if (typeof result === "object" && result._type === "NodeGroup") {
+        return result;
+      } else {
+        return nodeGroup(result);
+      }
+    }
+  };
+}
+function toSimpleComponent(view2, initialState, css) {
+  return {
+    _type: "Component",
+    css,
+    initialState: () => {
+      if (isEffect(initialState)) {
+        return initialState;
+      } else {
+        return pure(initialState);
+      }
+    },
+    view: (state) => {
+      const result = view2(state);
+      if (typeof result === "object" && result["_type"] === "NodeGroup") {
+        return result;
+      } else {
+        return nodeGroup(result);
+      }
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    params: void 0
+  };
+}
+function component(...args) {
+  if (args.length <= 3 && (args.length < 3 || typeof args[2] === "string" || args[2] === void 0)) {
+    const [view2, initialState, css] = args;
+    return toSimpleComponent(view2, initialState, css);
+  } else {
+    const [view2, initialState, params, css] = args;
+    return toComponent(
+      view2,
+      initialState,
+      params,
+      css
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    );
+  }
+}
+
+// src/utils/apply.ts
+function applySupport() {
+  return {
+    apply(f) {
+      return f(this);
+    },
+    applyIf(condition, f) {
+      return condition ? f(this) : this;
+    }
+  };
+}
+
+// src/dom/elems.ts
+function propSupport() {
+  return {
+    prop(name, value) {
+      return {
+        ...this,
+        props: [...this.props, { name, value }],
+        ...propSupport()
+      };
+    }
+  };
+}
+function makeNonVoidElement(tag) {
+  return (...attrs) => {
+    return (...children) => {
+      return {
+        _type: "Element",
+        tag,
+        nodeId: findNodeId(attrs),
+        attrs: normalizeAttrArgs(attrs),
+        props: [],
+        children,
+        eventListeners: [],
+        ...eventSupport(),
+        ...propSupport(),
+        ...applySupport()
+      };
+    };
+  };
+}
+function makeVoidElement(tag) {
+  return (...attrs) => {
+    return {
+      _type: "Element",
+      tag,
+      nodeId: findNodeId(attrs),
+      attrs: normalizeAttrArgs(attrs),
+      props: [],
+      eventListeners: [],
+      ...eventSupport(),
+      ...propSupport(),
+      ...applySupport()
+    };
+  };
+}
+
+// src/dom/index.ts
+function makeDom() {
+  const functions = {
+    br: makeVoidElement("br"),
+    hr: makeVoidElement("hr"),
+    img: makeVoidElement("img"),
+    input: makeVoidElement("input"),
+    a: makeNonVoidElement("a"),
+    abbr: makeNonVoidElement("abbr"),
+    address: makeNonVoidElement("address"),
+    article: makeNonVoidElement("article"),
+    aside: makeNonVoidElement("aside"),
+    b: makeNonVoidElement("b"),
+    blockquote: makeNonVoidElement("blockquote"),
+    button: makeNonVoidElement("button"),
+    cite: makeNonVoidElement("cite"),
+    code: makeNonVoidElement("code"),
+    dd: makeNonVoidElement("dd"),
+    details: makeNonVoidElement("details"),
+    div: makeNonVoidElement("div"),
+    dl: makeNonVoidElement("dl"),
+    dt: makeNonVoidElement("dt"),
+    em: makeNonVoidElement("em"),
+    fieldset: makeNonVoidElement("fieldset"),
+    figcaption: makeNonVoidElement("figcaption"),
+    figure: makeNonVoidElement("figure"),
+    footer: makeNonVoidElement("footer"),
+    form: makeNonVoidElement("form"),
+    h1: makeNonVoidElement("h1"),
+    h2: makeNonVoidElement("h2"),
+    h3: makeNonVoidElement("h3"),
+    h4: makeNonVoidElement("h4"),
+    h5: makeNonVoidElement("h5"),
+    h6: makeNonVoidElement("h6"),
+    header: makeNonVoidElement("header"),
+    i: makeNonVoidElement("i"),
+    kbd: makeNonVoidElement("kbd"),
+    label: makeNonVoidElement("label"),
+    li: makeNonVoidElement("li"),
+    main: makeNonVoidElement("main"),
+    mark: makeNonVoidElement("mark"),
+    nav: makeNonVoidElement("nav"),
+    ol: makeNonVoidElement(
+      "ol"
+    ),
+    option: makeNonVoidElement(
+      "option"
+    ),
+    p: makeNonVoidElement("p"),
+    pre: makeNonVoidElement("pre"),
+    q: makeNonVoidElement("q"),
+    s: makeNonVoidElement("s"),
+    section: makeNonVoidElement("section"),
+    select: makeNonVoidElement("select"),
+    small: makeNonVoidElement("small"),
+    span: makeNonVoidElement("span"),
+    strong: makeNonVoidElement("strong"),
+    sub: makeNonVoidElement("sub"),
+    summary: makeNonVoidElement("summary"),
+    sup: makeNonVoidElement("sup"),
+    table: makeNonVoidElement("table"),
+    tbody: makeNonVoidElement("tbody"),
+    td: makeNonVoidElement("td"),
+    textarea: makeNonVoidElement("textarea"),
+    tfoot: makeNonVoidElement("tfoot"),
+    th: makeNonVoidElement("th"),
+    thead: makeNonVoidElement("thead"),
+    time: makeNonVoidElement("time"),
+    tr: makeNonVoidElement("tr"),
+    u: makeNonVoidElement("u"),
+    ul: makeNonVoidElement(
+      "ul"
+    ),
+    svg: makeNonVoidElement("svg/svg"),
+    circle: makeVoidElement("svg/circle"),
+    ellipse: makeVoidElement(
+      "svg/ellipse"
+    ),
+    image: makeVoidElement("svg/image"),
+    line: makeVoidElement("svg/line"),
+    polyline: makeVoidElement(
+      "svg/polyline"
+    ),
+    polygon: makeVoidElement(
+      "svg/polygon"
+    ),
+    path: makeVoidElement("svg/path"),
+    rect: makeVoidElement("svg/rect"),
+    use: makeVoidElement("svg/use"),
+    element: (tag) => makeNonVoidElement(tag),
+    nodeGroup,
+    _,
+    fixedView
+  };
+  return {
+    ...functions,
+    a_: functions.a(),
+    a__: (...attrs) => functions.a(...attrs)(),
+    abbr_: functions.abbr(),
+    abbr__: (...attrs) => functions.abbr(...attrs)(),
+    address_: functions.address(),
+    address__: (...attrs) => functions.address(...attrs)(),
+    article_: functions.article(),
+    article__: (...attrs) => functions.article(...attrs)(),
+    aside_: functions.aside(),
+    aside__: (...attrs) => functions.aside(...attrs)(),
+    b_: functions.b(),
+    b__: (...attrs) => functions.b(...attrs)(),
+    blockquote_: functions.blockquote(),
+    blockquote__: (...attrs) => functions.blockquote(...attrs)(),
+    button_: functions.button(),
+    button__: (...attrs) => functions.button(...attrs)(),
+    cite_: functions.cite(),
+    cite__: (...attrs) => functions.cite(...attrs)(),
+    code_: functions.code(),
+    code__: (...attrs) => functions.code(...attrs)(),
+    dd_: functions.dd(),
+    dd__: (...attrs) => functions.dd(...attrs)(),
+    details_: functions.details(),
+    details__: (...attrs) => functions.details(...attrs)(),
+    div_: functions.div(),
+    div__: (...attrs) => functions.div(...attrs)(),
+    dl_: functions.dl(),
+    dl__: (...attrs) => functions.dl(...attrs)(),
+    dt_: functions.dt(),
+    dt__: (...attrs) => functions.dt(...attrs)(),
+    em_: functions.em(),
+    em__: (...attrs) => functions.em(...attrs)(),
+    fieldset_: functions.fieldset(),
+    fieldset__: (...attrs) => functions.fieldset(...attrs)(),
+    figcaption_: functions.figcaption(),
+    figcaption__: (...attrs) => functions.figcaption(...attrs)(),
+    figure_: functions.figure(),
+    figure__: (...attrs) => functions.figure(...attrs)(),
+    footer_: functions.footer(),
+    footer__: (...attrs) => functions.footer(...attrs)(),
+    form_: functions.form(),
+    form__: (...attrs) => functions.form(...attrs)(),
+    h1_: functions.h1(),
+    h1__: (...attrs) => functions.h1(...attrs)(),
+    h2_: functions.h2(),
+    h2__: (...attrs) => functions.h2(...attrs)(),
+    h3_: functions.h3(),
+    h3__: (...attrs) => functions.h3(...attrs)(),
+    h4_: functions.h4(),
+    h4__: (...attrs) => functions.h4(...attrs)(),
+    h5_: functions.h5(),
+    h5__: (...attrs) => functions.h5(...attrs)(),
+    h6_: functions.h6(),
+    h6__: (...attrs) => functions.h6(...attrs)(),
+    header_: functions.header(),
+    header__: (...attrs) => functions.header(...attrs)(),
+    i_: functions.i(),
+    i__: (...attrs) => functions.i(...attrs)(),
+    kbd_: functions.kbd(),
+    kbd__: (...attrs) => functions.kbd(...attrs)(),
+    label_: functions.label(),
+    label__: (...attrs) => functions.label(...attrs)(),
+    li_: functions.li(),
+    li__: (...attrs) => functions.li(...attrs)(),
+    main_: functions.main(),
+    main__: (...attrs) => functions.main(...attrs)(),
+    mark_: functions.mark(),
+    mark__: (...attrs) => functions.mark(...attrs)(),
+    nav_: functions.nav(),
+    nav__: (...attrs) => functions.nav(...attrs)(),
+    ol_: functions.ol(),
+    ol__: (...attrs) => functions.ol(...attrs)(),
+    option_: functions.option(),
+    option__: (...attrs) => functions.option(...attrs)(),
+    p_: functions.p(),
+    p__: (...attrs) => functions.p(...attrs)(),
+    pre_: functions.pre(),
+    pre__: (...attrs) => functions.pre(...attrs)(),
+    q_: functions.q(),
+    q__: (...attrs) => functions.q(...attrs)(),
+    s_: functions.s(),
+    s__: (...attrs) => functions.s(...attrs)(),
+    section_: functions.section(),
+    section__: (...attrs) => functions.section(...attrs)(),
+    select_: functions.select(),
+    select__: (...attrs) => functions.select(...attrs)(),
+    small_: functions.small(),
+    small__: (...attrs) => functions.small(...attrs)(),
+    span_: functions.span(),
+    span__: (...attrs) => functions.span(...attrs)(),
+    strong_: functions.strong(),
+    strong__: (...attrs) => functions.strong(...attrs)(),
+    sub_: functions.sub(),
+    sub__: (...attrs) => functions.sub(...attrs)(),
+    summary_: functions.summary(),
+    summary__: (...attrs) => functions.summary(...attrs)(),
+    sup_: functions.sup(),
+    sup__: (...attrs) => functions.sup(...attrs)(),
+    svg_: functions.svg(),
+    svg__: (...attrs) => functions.svg(...attrs)(),
+    table_: functions.table(),
+    table__: (...attrs) => functions.table(...attrs)(),
+    tbody_: functions.tbody(),
+    tbody__: (...attrs) => functions.tbody(...attrs)(),
+    td_: functions.td(),
+    td__: (...attrs) => functions.td(...attrs)(),
+    textarea_: functions.textarea(),
+    textarea__: (...attrs) => functions.textarea(...attrs)(),
+    tfoot_: functions.tfoot(),
+    tfoot__: (...attrs) => functions.tfoot(...attrs)(),
+    th_: functions.th(),
+    th__: (...attrs) => functions.th(...attrs)(),
+    thead_: functions.thead(),
+    thead__: (...attrs) => functions.thead(...attrs)(),
+    time_: functions.time(),
+    time__: (...attrs) => functions.time(...attrs)(),
+    tr_: functions.tr(),
+    tr__: (...attrs) => functions.tr(...attrs)(),
+    u_: functions.u(),
+    u__: (...attrs) => functions.u(...attrs)(),
+    ul_: functions.ul(),
+    ul__: (...attrs) => functions.ul(...attrs)(),
+    view(nodeId2, nodes) {
+      return view(nodeId2, nodes);
+    },
+    componentElem(comp, nodeId2, params) {
+      return componentElem(comp, nodeId2, params);
+    }
+  };
+}
+function foldNode(node, cases) {
+  if (typeof node === "string") {
+    return cases.onText(node);
+  }
+  switch (node._type) {
+    case "Component":
+      return cases.onComponent(node);
+    case "View":
+      return cases.onView(node);
+    case "Element":
+      switch (node.tag) {
+        case "br":
+        case "hr":
+        case "img":
+        case "input":
+        case "svg/circle":
+        case "svg/ellipse":
+        case "svg/image":
+        case "svg/line":
+        case "svg/polyline":
+        case "svg/polygon":
+        case "svg/path":
+        case "svg/rect":
+        case "svg/use":
+          return cases.onVoidElement(node);
+        default:
+          return cases.onNonVoidElement(
+            node
+          );
+      }
+  }
+}
+
+export {
+  nodeId,
+  attr,
+  prop,
+  getId,
+  id,
+  typeAttr,
+  cssVars,
+  eventTypes,
+  preventDefault,
+  stopPropagation,
+  stopPropagationAndPreventDefault,
+  containerEventTypes,
+  component,
+  makeDom,
+  foldNode,
+  nodeGroup,
+  isNodeGroup
+};