@telia-ace/widget-components-grid 1.0.33 → 1.1.1-rc.1

package/grid-713c2f6f.mjs

@@ -0,0 +1,727 @@
+import { jsx as u } from "react/jsx-runtime";
+import { c as $, _ as pe, a as me, b as fe, T as te, P as V, C as re, u as A, d as L, e as j, f as he, g as ge, h as F, i as oe, j as ie, S as be, R as B, n as w, G as se, k as q, l as ae, m as ye, o as _, p as ve, q as xe, r as $e, s as Ce, t as we, v as Ee } from "./index-e0485d7b.mjs";
+import M, { Children as Se, isValidElement as G, cloneElement as z, useContext as J, useState as C, useCallback as Pe, useEffect as g, forwardRef as ce, useMemo as le, Suspense as De } from "react";
+import "react-dom";
+const Ne = (e) => e === "entering" || e === "entered", Ve = (e) => e === "exiting" || e === "exited", S = {
+  fade: {
+    in: "opacity: 1;",
+    out: "opacity: 0;"
+  },
+  "slide-left": {
+    in: "transform: translateX(0);",
+    out: "transform: translateX(-100%);"
+  },
+  "slide-right": {
+    in: "transform: translateX(0);",
+    out: "transform: translateX(100%);"
+  },
+  "slide-up": {
+    in: "transform: translateY(0);",
+    out: "transform: translateY(100%);"
+  },
+  "slide-down": {
+    in: "transform: translateY(0);",
+    out: "transform: translateY(-100%);"
+  },
+  scale: {
+    in: "transform: scale(1);",
+    out: "transform: scale(0);"
+  }
+}, Me = ["slide-up", "slide-down", "slide-left", "slide-right", "scale"], I = {
+  compose: (e = "exited", t) => {
+    const { enter: r, exit: o } = t, n = r.transitionKeys.split(" "), i = Me.indexOf(n[0]) > -1 ? "transform" : "opacity";
+    if (Ne(e))
+      return n && n.length > 0 ? $`
+                    ${n && n.length > 0 && n.map((a) => S[a] ? S[a].in : "")}
+                    transition: ${i} ${r.duration}ms ${r.easing};
+                ` : "";
+    const s = n && n.length > 0 && $`
+                ${n.map((a) => S[a] ? S[a].out : "")}
+            `;
+    if (Ve(e)) {
+      const a = o.transitionKeys.split(" ");
+      return a && a.length > 0 && e === "exiting" ? $`
+                    ${s};
+                    ${a.map((c) => S[c] ? S[c].out : "")}
+                    transition: ${i} ${o.duration}ms ${o.easing};
+                ` : s;
+    }
+  },
+  composeViewTransition: (e, t, r) => {
+    if (t === "slide")
+      return I.compose(e, {
+        enter: {
+          transitionKeys: r === "forth" ? "slide-right" : "slide-left",
+          duration: 500
+        },
+        exit: {
+          transitionKeys: r === "forth" ? "slide-left" : "slide-right",
+          duration: 500
+        }
+      });
+    if (t === "fade")
+      return I.compose(e, {
+        enter: {
+          transitionKeys: "fade",
+          duration: 500
+        },
+        exit: {
+          transitionKeys: "fade",
+          duration: 500
+        }
+      });
+  },
+  get: (e) => S[e]
+}, ne = (e = {}) => (Object.keys(e).forEach((t) => {
+  (e[t] === null || typeof e[t] > "u") && delete e[t];
+}), e);
+function Te(e) {
+  if (e === void 0)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return e;
+}
+function Q(e, t) {
+  var r = function(i) {
+    return t && G(i) ? t(i) : i;
+  }, o = /* @__PURE__ */ Object.create(null);
+  return e && Se.map(e, function(n) {
+    return n;
+  }).forEach(function(n) {
+    o[n.key] = r(n);
+  }), o;
+}
+function Re(e, t) {
+  e = e || {}, t = t || {};
+  function r(d) {
+    return d in t ? t[d] : e[d];
+  }
+  var o = /* @__PURE__ */ Object.create(null), n = [];
+  for (var i in e)
+    i in t ? n.length && (o[i] = n, n = []) : n.push(i);
+  var s, a = {};
+  for (var c in t) {
+    if (o[c])
+      for (s = 0; s < o[c].length; s++) {
+        var l = o[c][s];
+        a[o[c][s]] = r(l);
+      }
+    a[c] = r(c);
+  }
+  for (s = 0; s < n.length; s++)
+    a[n[s]] = r(n[s]);
+  return a;
+}
+function P(e, t, r) {
+  return r[t] != null ? r[t] : e.props[t];
+}
+function Oe(e, t) {
+  return Q(e.children, function(r) {
+    return z(r, {
+      onExited: t.bind(null, r),
+      in: !0,
+      appear: P(r, "appear", e),
+      enter: P(r, "enter", e),
+      exit: P(r, "exit", e)
+    });
+  });
+}
+function _e(e, t, r) {
+  var o = Q(e.children), n = Re(t, o);
+  return Object.keys(n).forEach(function(i) {
+    var s = n[i];
+    if (G(s)) {
+      var a = i in t, c = i in o, l = t[i], d = G(l) && !l.props.in;
+      c && (!a || d) ? n[i] = z(s, {
+        onExited: r.bind(null, s),
+        in: !0,
+        exit: P(s, "exit", e),
+        enter: P(s, "enter", e)
+      }) : !c && a && !d ? n[i] = z(s, {
+        in: !1
+      }) : c && a && G(l) && (n[i] = z(s, {
+        onExited: r.bind(null, s),
+        in: l.props.in,
+        exit: P(s, "exit", e),
+        enter: P(s, "enter", e)
+      }));
+    }
+  }), n;
+}
+var Ae = Object.values || function(e) {
+  return Object.keys(e).map(function(t) {
+    return e[t];
+  });
+}, je = {
+  component: "div",
+  childFactory: function(t) {
+    return t;
+  }
+}, Z = /* @__PURE__ */ function(e) {
+  pe(t, e);
+  function t(o, n) {
+    var i;
+    i = e.call(this, o, n) || this;
+    var s = i.handleExited.bind(Te(i));
+    return i.state = {
+      contextValue: {
+        isMounting: !0
+      },
+      handleExited: s,
+      firstRender: !0
+    }, i;
+  }
+  var r = t.prototype;
+  return r.componentDidMount = function() {
+    this.mounted = !0, this.setState({
+      contextValue: {
+        isMounting: !1
+      }
+    });
+  }, r.componentWillUnmount = function() {
+    this.mounted = !1;
+  }, t.getDerivedStateFromProps = function(n, i) {
+    var s = i.children, a = i.handleExited, c = i.firstRender;
+    return {
+      children: c ? Oe(n, a) : _e(n, s, a),
+      firstRender: !1
+    };
+  }, r.handleExited = function(n, i) {
+    var s = Q(this.props.children);
+    n.key in s || (n.props.onExited && n.props.onExited(i), this.mounted && this.setState(function(a) {
+      var c = me({}, a.children);
+      return delete c[n.key], {
+        children: c
+      };
+    }));
+  }, r.render = function() {
+    var n = this.props, i = n.component, s = n.childFactory, a = fe(n, ["component", "childFactory"]), c = this.state.contextValue, l = Ae(this.state.children).map(s);
+    return delete a.appear, delete a.enter, delete a.exit, i === null ? /* @__PURE__ */ M.createElement(te.Provider, {
+      value: c
+    }, l) : /* @__PURE__ */ M.createElement(te.Provider, {
+      value: c
+    }, /* @__PURE__ */ M.createElement(i, a, l));
+  }, t;
+}(M.Component);
+Z.propTypes = process.env.NODE_ENV !== "production" ? {
+  /**
+   * `<TransitionGroup>` renders a `<div>` by default. You can change this
+   * behavior by providing a `component` prop.
+   * If you use React v16+ and would like to avoid a wrapping `<div>` element
+   * you can pass in `component={null}`. This is useful if the wrapping div
+   * borks your css styles.
+   */
+  component: V.any,
+  /**
+   * A set of `<Transition>` components, that are toggled `in` and out as they
+   * leave. the `<TransitionGroup>` will inject specific transition props, so
+   * remember to spread them through if you are wrapping the `<Transition>` as
+   * with our `<Fade>` example.
+   *
+   * While this component is meant for multiple `Transition` or `CSSTransition`
+   * children, sometimes you may want to have a single transition child with
+   * content that you want to be transitioned out and in when you change it
+   * (e.g. routes, images etc.) In that case you can change the `key` prop of
+   * the transition child as you change its content, this will cause
+   * `TransitionGroup` to transition the child out and back in.
+   */
+  children: V.node,
+  /**
+   * A convenience prop that enables or disables appear animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  appear: V.bool,
+  /**
+   * A convenience prop that enables or disables enter animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  enter: V.bool,
+  /**
+   * A convenience prop that enables or disables exit animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  exit: V.bool,
+  /**
+   * You may need to apply reactive updates to a child as it is exiting.
+   * This is generally done by using `cloneElement` however in the case of an exiting
+   * child the element has already been removed and not accessible to the consumer.
+   *
+   * If you do need to update a child as it leaves you can provide a `childFactory`
+   * to wrap every child, even the ones that are leaving.
+   *
+   * @type Function(child: ReactElement) -> ReactElement
+   */
+  childFactory: V.func
+} : {};
+Z.defaultProps = je;
+const Fe = Z, ue = () => J(re), U = (e, t) => ({
+  id: e.id,
+  type: e.type,
+  name: e.name,
+  branch: t || "default"
+}), Ge = () => {
+  const e = A(), t = L(), [r, o] = C([]), n = j(), i = Pe(
+    (s) => {
+      if (t && n.current && s) {
+        const a = t.getBranch(s), c = s.getChildren(a).map((l) => U(l));
+        o(c);
+      }
+    },
+    [n, t, o, e]
+  );
+  return g(() => {
+    e && i(e);
+  }, [e, t]), g(() => {
+    if (t) {
+      const [s, a] = he(t.events);
+      return s("components:set-layout", (c, l) => {
+        (e === l.node.parent || l.node.parent === t.nodes.root) && i(l.node.parent);
+      }), s("components:node-appended", (c, l) => {
+        (e === l.node.parent || l.node.parent === t.nodes.root) && i(l.node.parent);
+      }), s("components:node-removed", (c, { parentNode: l }) => {
+        (l === e || l === t.nodes.root) && i(l);
+      }), () => {
+        a();
+      };
+    }
+  }, [e, t, i]), r;
+}, ze = () => J(ge), Le = (e, t) => {
+  const r = ue(), o = F(), [n, i] = C(void 0), s = j(), a = e || r.type || "";
+  return g(() => {
+    if (a) {
+      let c;
+      return (t || o).getAsync("componentResolver").then((l) => {
+        if (s.current) {
+          const d = l.getComponent(a);
+          i(d);
+        }
+        c = l.registerResolver(a, (d) => {
+          s.current && i(d);
+        });
+      }), () => {
+        c && c();
+      };
+    }
+  }, [s, a, t, o]), n;
+}, We = (e) => {
+  const t = A(e), r = L(), [o, n] = C({}), i = j();
+  return g(() => {
+    t && i.current && n(t.attributes.layout);
+  }, [t, i]), g(() => {
+    if (r) {
+      const s = r.events.subscribe(
+        "components:layout-changed",
+        (a, c) => {
+          t === c.node && i.current && n(c.node.attributes.layout);
+        }
+      );
+      return () => {
+        s();
+      };
+    }
+  }, [r, i, t]), o;
+}, k = () => J(oe), Ke = (e) => {
+  const t = F(), r = ie(), [o, n] = C({ name: "", params: {} }), i = j();
+  return g(() => {
+    const s = (e || t).get("$widget");
+    if (!s)
+      return;
+    const { events: a } = s;
+    return a.subscribe("router:change", (l, { next: { routeData: d } }) => {
+      if (i.current) {
+        const { name: p, params: b } = d;
+        ne(b), n({ name: p, params: b });
+      }
+    });
+  }, [i, e, t]), g(() => {
+    if (r && r.history && i.current) {
+      const s = r.getRouteData(), { name: a, params: c } = s;
+      ne(c), n({ name: a, params: c });
+    }
+  }, [r, i]), o;
+};
+var H = /* @__PURE__ */ ((e) => (e.back = "back", e.forth = "forth", e))(H || {});
+const Xe = (e, t, r) => typeof r[e] == "number" && typeof r[t] == "number" && r[e] > r[t] ? "back" : "forth", de = ({ views: e, location: t, render: r }) => /* @__PURE__ */ u(
+  be,
+  {
+    location: t && {
+      ...t,
+      pathname: t.pathname.split("?")[0]
+    },
+    children: [
+      ...Object.keys(e).filter((o) => !!e[o].path),
+      ...Object.keys(e).filter((o) => !e[o].path)
+    ].map((o) => {
+      const { path: n } = e[o];
+      return n ? Array.isArray(n) ? n.map((i) => /* @__PURE__ */ u(B, { exact: !0, path: i, render: () => r(o) }, o)) : /* @__PURE__ */ u(B, { exact: !0, path: n, render: () => r(o) }, o) : /* @__PURE__ */ u(B, { render: () => r(o) }, o);
+    })
+  }
+), Ye = w.div`
+  position: relative;
+  width: 100%;
+  flex: 1;
+`, Be = w(se)`
+  position: absolute;
+  left: 0;
+  right: 0;
+  ${(e) => !!e.animationCss && e.animationCss}
+  ${(e) => !!e.scrollableCss && e.scrollableCss}
+`, Ie = {
+  index: 1,
+  search: 2,
+  browse: 3,
+  guide: 4,
+  contact: 5,
+  "contact-method": 6,
+  conversation: 7
+}, Ue = ({ className: e = "", ...t }) => {
+  const [r, o] = C("index"), [n, i] = C(
+    H.forth
+  ), s = Ke(), a = ie(), c = k(), l = q(), d = F(), p = A(), { gap: b = "0" } = l, {
+    columns: D = 1,
+    animation: x = "none",
+    scrollable: f = !1,
+    ...T
+  } = c, [K, R] = ae(f);
+  if (!p || !a)
+    return null;
+  const { location: X } = a;
+  s.name !== r && s.name !== "" && x && (i(
+    Xe(r, s.name, Ie)
+  ), o(s.name));
+  const { views: y } = d.get("$settings");
+  if (!Object.keys(y).length)
+    return null;
+  const v = (m, E, N) => {
+    const h = Y(E, N), O = p.getChildren(m)[0];
+    return /* @__PURE__ */ u(
+      Be,
+      {
+        ...t,
+        ...T,
+        scrollableCss: K,
+        ref: R,
+        columns: D,
+        gap: b,
+        ...h,
+        className: _(e, "humany-view"),
+        children: /* @__PURE__ */ u(ee, { id: O.id, branch: "default" })
+      }
+    );
+  }, Y = (m, E) => {
+    if (x === "slide" || x === "fade")
+      return {
+        animationCss: I.composeViewTransition(
+          m,
+          x,
+          E
+        ),
+        "data-state": m
+      };
+  };
+  return /* @__PURE__ */ u(Ye, { className: "humany-animated-view", children: /* @__PURE__ */ u(
+    Fe,
+    {
+      component: null,
+      childFactory: (m) => M.cloneElement(m, { direction: n }),
+      children: /* @__PURE__ */ u(
+        ye,
+        {
+          timeout: { enter: 500, exit: 500 },
+          onEnter: (m) => m == null ? void 0 : m.clientHeight,
+          unmountOnExit: !0,
+          direction: H.forth,
+          children: (m, { direction: E }) => /* @__PURE__ */ u(
+            de,
+            {
+              views: y,
+              location: X,
+              render: (N) => v(N, m, E)
+            }
+          )
+        },
+        r
+      )
+    }
+  ) });
+}, He = w(se)`
+    ${(e) => !!e.scrollableCss && e.scrollableCss}
+`, qe = ({ className: e = "", ...t }) => {
+  const r = k(), o = q(), n = F(), i = A(), { views: s } = n.get("$settings"), { gap: a = "0" } = o, { columns: c = 1, animation: l = "none", scrollable: d = !1, ...p } = r, [b, D] = ae(d);
+  return i ? /* @__PURE__ */ u(
+    He,
+    {
+      ...t,
+      ...p,
+      scrollableCss: b,
+      ref: D,
+      columns: c,
+      gap: a,
+      className: _(e, "humany-view"),
+      children: /* @__PURE__ */ u(
+        de,
+        {
+          views: s,
+          render: (x) => {
+            const f = i.getChildren(x)[0];
+            return /* @__PURE__ */ u(ee, { id: f.id, node: f, branch: "default" });
+          }
+        }
+      )
+    }
+  ) : null;
+}, W = (e) => {
+  var t, r;
+  return $`
+    outline: none;
+    box-sizing: border-box;
+    * {
+        box-sizing: border-box;
+        outline: none;
+    }
+
+    grid-column: ${e["data-indent"] ? `${e["data-indent"] + 1} / ${e["data-indent"] + (e["data-width"] || 0) + 1}` : `span ${e["data-width"]}`};
+
+    ${((t = e.theme.fonts) == null ? void 0 : t.type) && `
+    font-family: ${e.theme.fonts.type};
+
+    input, textarea {
+      font-family: ${e.theme.fonts.type};
+    }
+  `}
+
+    ${((r = e.theme.fonts) == null ? void 0 : r.base) && `
+    font-size: ${e.theme.fonts.base};
+  `}
+
+  &:focus-visible {
+        ${ve(e)};
+    }
+`;
+}, Je = w(qe)`
+    ${(e) => W(e)}
+`, Qe = w(Ue)`
+    ${(e) => W(e)}
+`, Ze = w.div`
+    text-align: center;
+    ${(e) => {
+  var t, r, o;
+  return typeof ((t = e.theme.colors) == null ? void 0 : t.warning) < "u" && $`
+            color: ${(r = e.theme.colors) == null ? void 0 : r.warning};
+            border: 2px dashed ${(o = e.theme.colors) == null ? void 0 : o.warning};
+        `;
+}}
+    ${(e) => typeof e.theme.borderRadius < "u" && `border-radius: ${e.theme.borderRadius};`}
+  ${(e) => W(e)}
+`, ke = ce(
+  ({ className: e = "", children: t, ...r }, o) => {
+    const n = Le(), { name: i, type: s, id: a } = ue(), c = le(() => n ? w(n)`
+                    ${W}
+                    ${xe}
+                ` : null, [n]);
+    return typeof n > "u" ? null : n === null || c === null ? process.env.NODE_ENV !== "production" ? /* @__PURE__ */ u(
+      Ze,
+      {
+        ...r,
+        title: `type: ${s}, definition-id: ${i}, instance-id: ${a}`,
+        className: _(e, "humany-non-resolved-component"),
+        children: /* @__PURE__ */ u($e, { variant: "h5", children: "Non Resolved Component Type" })
+      }
+    ) : null : /* @__PURE__ */ u(De, { fallback: null, children: /* @__PURE__ */ u(
+      c,
+      {
+        ref: o,
+        ...r,
+        className: _(
+          e,
+          "humany-component",
+          `humany-component-${i}`
+        ),
+        children: t
+      }
+    ) });
+  }
+), et = (e) => {
+  const t = A(e), r = L(), [o, n] = C({}), i = j();
+  return g(() => {
+    t && i.current && n(t.attributes.properties);
+  }, [t, e, i]), g(() => {
+    if (r) {
+      const s = r.events.subscribe(
+        "components:properties-changed",
+        (a, c) => {
+          t === c.node && i.current && n(c.node.attributes.properties);
+        }
+      );
+      return () => {
+        s();
+      };
+    }
+  }, [r, i, e, t]), o;
+}, tt = (e, t) => t ? !0 : typeof e == "string" ? e === "full" : e > 0, ee = ce(
+  ({
+    className: e = "",
+    id: t,
+    branch: r,
+    node: o,
+    ariaLabel: n,
+    tabIndex: i,
+    context: s,
+    ...a
+  }, c) => {
+    const l = L(), d = F(), [p, b] = C(), D = ze(), x = q(t), f = et(t), { size: T = "none", indent: K = 0 } = We(t), R = tt(T, o);
+    if (g(() => {
+      if (l) {
+        if (t && !o) {
+          const h = l.nodes.get(t);
+          if (h && (b(U(h, r)), R)) {
+            const O = h.mount(d);
+            return () => {
+              O();
+            };
+          }
+        } else if (o) {
+          b(U(o, r));
+          const h = o.mount(d);
+          return () => {
+            h();
+          };
+        }
+      }
+    }, [l, t, o, R]), !p || !R)
+      return null;
+    const X = { ...x, ...s || {} }, {
+      cardinal: y,
+      fonts: v = {},
+      accessibility: Y = {},
+      ...m
+    } = X, E = {
+      type: v.type,
+      base: v.base || "16px",
+      small: v.small || "0.8em",
+      normal: v.normal || "1em",
+      medium: v.medium || "1.2em",
+      large: v.large || "1.6em",
+      huge: v.huge || "2.5em"
+    }, N = {
+      ...m,
+      fonts: E,
+      accessibility: {
+        ...Y
+      }
+    };
+    return typeof y == "number" && (N.sizes = {
+      cardinal: y,
+      small: `${y}px`,
+      normal: `${y * 3}px`,
+      medium: `${y * 5}px`,
+      large: `${y * 8}px`
+    }), /* @__PURE__ */ u(Ce, { theme: N, children: /* @__PURE__ */ u(re.Provider, { value: p, children: /* @__PURE__ */ u(oe.Provider, { value: f, children: (() => {
+      const h = {
+        "data-width": T === "full" ? D : Math.min(T, D),
+        "data-indent": K,
+        "data-name": p.name,
+        "data-node-id": p.id,
+        "data-component-type": p.type,
+        "aria-label": n,
+        tabIndex: i,
+        id: p.id,
+        role: f && f.role,
+        ...a
+      };
+      switch (p.type) {
+        case "view":
+          return typeof f.animation == "string" && f.animation !== "none" ? /* @__PURE__ */ u(Qe, { ...h, className: e }) : /* @__PURE__ */ u(Je, { ...h, className: e });
+        default: {
+          const O = we(f);
+          return /* @__PURE__ */ u(
+            ke,
+            {
+              ref: c,
+              ...h,
+              ...O,
+              className: e
+            }
+          );
+        }
+      }
+    })() }) }) });
+  }
+);
+M.lazy(() => import("./detached-component-dc527d32.mjs"));
+const nt = (e) => {
+  const t = e.map((n) => "min-content").join(" "), r = e[0].split(" ").map((n) => "1fr").join(" "), o = e.map((n) => `'${n}'`).join(" ");
+  return $`
+        grid-template-columns: ${r};
+        grid-template-rows: ${t};
+        grid-template-areas: ${o};
+    `;
+}, rt = (e) => {
+  const t = Ge(), r = le(() => Object.entries(e.areas).map(([o, n]) => {
+    const i = t.find((s) => s.name === o);
+    return Ee(n) ? {
+      name: o,
+      componentDef: i,
+      context: n.context,
+      areaSettings: n.areaSettings,
+      template: n.template,
+      areas: n.areas,
+      gap: n.gap
+    } : {
+      name: o,
+      componentDef: i,
+      areaSettings: n.areaSettings,
+      child: n.child,
+      context: n.context
+    };
+  }), [e, t]);
+  return /* @__PURE__ */ u(
+    ot,
+    {
+      "data-grid-area": e.gridArea,
+      gridArea: e.gridArea,
+      gap: e.gap,
+      template: e.template,
+      className: _(e.className, "humany-grid"),
+      children: r.map((o) => o.componentDef ? /* @__PURE__ */ u(
+        ee,
+        {
+          id: o.componentDef.id,
+          branch: "default",
+          context: {}
+        },
+        o.componentDef.id
+      ) : null)
+    }
+  );
+}, ot = w.div`
+    display: grid;
+    ${(e) => e.gridArea && $`
+            grid-area: ${e.gridArea};
+        `}
+    ${(e) => nt(e.template)}
+  ${(e) => e.gap && $`
+            grid-gap: ${e.gap}rem;
+        `}
+`, it = ({ className: e }) => {
+  const t = k();
+  return /* @__PURE__ */ u(
+    rt,
+    {
+      template: t.template,
+      areas: t.areas,
+      gap: t.gap,
+      areaSettings: t.areaSettings,
+      context: t.context
+    }
+  );
+}, ut = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: it
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  ee as C,
+  ut as g
+};