magtool 1.4.3 → 1.5.1

package/dist/store.js

@@ -1,23 +1,646 @@
-import { createPinia as s, defineStore as o } from "pinia";
-const c = () => ({
+import { getCurrentInstance as H, ref as d, unref as F, computed as le, watch as Q, toRefs as De, nextTick as fe } from "vue";
+import { g as q, a as N, t as ne, b as ge, w as ke, c as oe, e as Be, f as Ue, h as Qe, j as qe, k as He, l as ye, o as We, u as Ge, m as Je, n as Xe } from "./vendor.js";
+import { createPinia as Ze, defineStore as he } from "pinia";
+function et(t) {
+  const e = H(), l = d(!1), o = d([]);
+  return {
+    updateExpandRows: () => {
+      const u = t.data.value || [], a = t.rowKey.value;
+      if (l.value)
+        o.value = u.slice();
+      else if (a) {
+        const i = q(o.value, a);
+        o.value = u.reduce((v, w) => {
+          const C = N(w, a);
+          return i[C] && v.push(w), v;
+        }, []);
+      } else
+        o.value = [];
+    },
+    toggleRowExpansion: (u, a) => {
+      ne(o.value, u, a, void 0, void 0, void 0, t.rowKey.value) && e.emit("expand-change", u, o.value.slice());
+    },
+    setExpandRowKeys: (u) => {
+      e.store.assertRowKey();
+      const a = t.data.value || [], i = t.rowKey.value, v = q(a, i);
+      o.value = u.reduce((w, C) => {
+        const I = v[C];
+        return I && w.push(I.row), w;
+      }, []);
+    },
+    isRowExpanded: (u) => {
+      const a = t.rowKey.value;
+      return a ? !!q(o.value, a)[N(u, a)] : o.value.includes(u);
+    },
+    states: {
+      expandRows: o,
+      defaultExpandAll: l
+    }
+  };
+}
+function tt(t) {
+  const e = H(), l = d(null), o = d(null), y = (a) => {
+    e.store.assertRowKey(), l.value = a, s(a);
+  }, O = () => {
+    l.value = null;
+  }, s = (a) => {
+    var i;
+    const { data: v, rowKey: w } = t;
+    let C = null;
+    w.value && (C = (i = (F(v) || []).find((I) => N(I, w.value) === a)) != null ? i : null), o.value = C ?? null, e.emit("current-change", o.value, null);
+  };
+  return {
+    setCurrentRowKey: y,
+    restoreCurrentRowKey: O,
+    setCurrentRowByKey: s,
+    updateCurrentRow: (a) => {
+      const i = o.value;
+      if (a && a !== i) {
+        o.value = a, e.emit("current-change", o.value, i);
+        return;
+      }
+      !a && i && (o.value = null, e.emit("current-change", null, i));
+    },
+    updateCurrentRowData: () => {
+      const a = t.rowKey.value, i = t.data.value || [], v = o.value;
+      if (v && !i.includes(v)) {
+        if (a) {
+          const w = N(v, a);
+          s(w);
+        } else
+          o.value = null;
+        ge(o.value) && e.emit("current-change", null, v);
+      } else l.value && (s(l.value), O());
+    },
+    states: {
+      _currentRowKey: l,
+      currentRow: o
+    }
+  };
+}
+function lt(t) {
+  const e = d([]), l = d({}), o = d(16), y = d(!1), O = d({}), s = d("hasChildren"), r = d("children"), u = d(!1), a = H(), i = le(() => {
+    if (!t.rowKey.value)
+      return {};
+    const c = t.data.value || [];
+    return w(c);
+  }), v = le(() => {
+    const c = t.rowKey.value, g = Object.keys(O.value), K = {};
+    return g.length && g.forEach((m) => {
+      if (O.value[m].length) {
+        const S = { children: [] };
+        O.value[m].forEach((T) => {
+          const b = N(T, c);
+          S.children.push(b), T[s.value] && !K[b] && (K[b] = { children: [] });
+        }), K[m] = S;
+      }
+    }), K;
+  }), w = (c) => {
+    const g = t.rowKey.value, K = {};
+    return ke(c, (m, S, T) => {
+      const b = N(m, g);
+      oe(S) ? K[b] = {
+        children: S.map((L) => N(L, g)),
+        level: T
+      } : y.value && (K[b] = {
+        children: [],
+        lazy: !0,
+        level: T
+      });
+    }, r.value, s.value, y.value), K;
+  }, C = (c = !1, g) => {
+    var K, m;
+    g || (g = (K = a.store) == null ? void 0 : K.states.defaultExpandAll.value);
+    const S = i.value, T = v.value, b = Object.keys(S), L = {};
+    if (b.length) {
+      const D = F(l), B = [], V = (_, A) => {
+        if (c)
+          return e.value ? g || e.value.includes(A) : !!(g || _ != null && _.expanded);
+        {
+          const z = g || e.value && e.value.includes(A);
+          return !!(_ != null && _.expanded || z);
+        }
+      };
+      b.forEach((_) => {
+        const A = D[_], z = { ...S[_] };
+        if (z.expanded = V(A, _), z.lazy) {
+          const { loaded: $ = !1, loading: U = !1 } = A || {};
+          z.loaded = !!$, z.loading = !!U, B.push(_);
+        }
+        L[_] = z;
+      });
+      const J = Object.keys(T);
+      y.value && J.length && B.length && J.forEach((_) => {
+        var A;
+        const z = D[_], $ = T[_].children;
+        if (B.includes(_)) {
+          if (((A = L[_].children) == null ? void 0 : A.length) !== 0)
+            throw new Error("[ElTable]children must be an empty array.");
+          L[_].children = $;
+        } else {
+          const { loaded: U = !1, loading: te = !1 } = z || {};
+          L[_] = {
+            lazy: !0,
+            loaded: !!U,
+            loading: !!te,
+            expanded: V(z, _),
+            children: $,
+            level: void 0
+          };
+        }
+      });
+    }
+    l.value = L, (m = a.store) == null || m.updateTableScrollY();
+  };
+  Q(() => e.value, () => {
+    C(!0);
+  }), Q(() => i.value, () => {
+    C();
+  }), Q(() => v.value, () => {
+    C();
+  });
+  const I = (c) => {
+    e.value = c, C();
+  }, W = (c) => y.value && c && "loaded" in c && !c.loaded, k = (c, g) => {
+    a.store.assertRowKey();
+    const K = t.rowKey.value, m = N(c, K), S = m && l.value[m];
+    if (m && S && "expanded" in S) {
+      const T = S.expanded;
+      g = Be(g) ? !S.expanded : g, l.value[m].expanded = g, T !== g && a.emit("expand-change", c, g), W(S) && Y(c, m, S), a.store.updateTableScrollY();
+    }
+  }, G = (c) => {
+    a.store.assertRowKey();
+    const g = t.rowKey.value, K = N(c, g), m = l.value[K];
+    W(m) ? Y(c, K, m) : k(c, void 0);
+  }, Y = (c, g, K) => {
+    const { load: m } = a.props;
+    m && !l.value[g].loaded && (l.value[g].loading = !0, m(c, K, (S) => {
+      if (!oe(S))
+        throw new TypeError("[ElTable] data must be an array");
+      l.value[g].loading = !1, l.value[g].loaded = !0, l.value[g].expanded = !0, S.length && (O.value[g] = S), a.emit("expand-change", c, !0);
+    }));
+  };
+  return {
+    loadData: Y,
+    loadOrToggle: G,
+    toggleTreeExpansion: k,
+    updateTreeExpandKeys: I,
+    updateTreeData: C,
+    updateKeyChildren: (c, g) => {
+      const { lazy: K, rowKey: m } = a.props;
+      if (K) {
+        if (!m)
+          throw new Error("[Table] rowKey is required in updateKeyChild");
+        O.value[c] && (O.value[c] = g);
+      }
+    },
+    normalize: w,
+    states: {
+      expandRowKeys: e,
+      treeData: l,
+      indent: o,
+      lazy: y,
+      lazyTreeNodeMap: O,
+      lazyColumnIdentifier: s,
+      childrenColumnName: r,
+      checkStrictly: u
+    }
+  };
+}
+const nt = (t, e) => {
+  const l = e.sortingColumn;
+  return !l || ye(l.sortable) ? t : We(t, e.sortProp, e.sortOrder, l.sortMethod, l.sortBy);
+}, ee = (t) => {
+  const e = [];
+  return t.forEach((l) => {
+    l.children && l.children.length > 0 ? e.push.apply(e, ee(l.children)) : e.push(l);
+  }), e;
+};
+function ot() {
+  var t;
+  const e = H(), { size: l } = De((t = e.proxy) == null ? void 0 : t.$props), o = d(null), y = d([]), O = d([]), s = d(!1), r = d([]), u = d([]), a = d([]), i = d([]), v = d([]), w = d([]), C = d([]), I = d([]), W = [], k = d(0), G = d(0), Y = d(0), M = d(!1), c = d([]), g = d(!1), K = d(!1), m = d(null), S = d({}), T = d(null), b = d(null), L = d(null), D = d(null), B = d(null), V = le(() => o.value ? q(c.value, o.value) : void 0);
+  Q(y, () => {
+    var n;
+    e.state && (z(!1), e.props.tableLayout === "auto" && ((n = e.refs.tableHeaderRef) == null || n.updateFixedColumnStyle()));
+  }, {
+    deep: !0
+  });
+  const J = () => {
+    if (!o.value)
+      throw new Error("[ElTable] prop row-key is required");
+  }, _ = (n) => {
+    var f;
+    (f = n.children) == null || f.forEach((p) => {
+      p.fixed = n.fixed, _(p);
+    });
+  }, A = () => {
+    r.value.forEach((E) => {
+      _(E);
+    }), i.value = r.value.filter((E) => [!0, "left"].includes(E.fixed));
+    const n = r.value.find((E) => E.type === "selection");
+    let f;
+    n && n.fixed !== "right" && !i.value.includes(n) && r.value.indexOf(n) === 0 && i.value.length && (i.value.unshift(n), f = !0), v.value = r.value.filter((E) => E.fixed === "right");
+    const p = r.value.filter((E) => (f ? E.type !== "selection" : !0) && !E.fixed);
+    u.value = Array.from(i.value).concat(p).concat(v.value);
+    const h = ee(p), x = ee(i.value), R = ee(v.value);
+    k.value = h.length, G.value = x.length, Y.value = R.length, a.value = Array.from(x).concat(h).concat(R), s.value = i.value.length > 0 || v.value.length > 0;
+  }, z = (n, f = !1) => {
+    n && A(), f ? e.state.doLayout() : e.state.debouncedUpdateLayout();
+  }, $ = (n) => V.value ? !!V.value[N(n, o.value)] : c.value.includes(n), U = () => {
+    M.value = !1;
+    const n = c.value;
+    c.value = [], n.length && e.emit("selection-change", []);
+  }, te = () => {
+    var n, f;
+    let p;
+    if (o.value) {
+      p = [];
+      const h = (f = (n = e == null ? void 0 : e.store) == null ? void 0 : n.states) == null ? void 0 : f.childrenColumnName.value, x = q(y.value, o.value, !0, h);
+      for (const R in V.value)
+        He(V.value, R) && !x[R] && p.push(V.value[R].row);
+    } else
+      p = c.value.filter((h) => !y.value.includes(h));
+    if (p.length) {
+      const h = c.value.filter((x) => !p.includes(x));
+      c.value = h, e.emit("selection-change", h.slice());
+    }
+  }, Ce = () => (c.value || []).slice(), xe = (n, f, p = !0, h = !1) => {
+    var x, R, E, P;
+    const j = {
+      children: (R = (x = e == null ? void 0 : e.store) == null ? void 0 : x.states) == null ? void 0 : R.childrenColumnName.value,
+      checkStrictly: (P = (E = e == null ? void 0 : e.store) == null ? void 0 : E.states) == null ? void 0 : P.checkStrictly.value
+    };
+    if (ne(c.value, n, f, j, h ? void 0 : m.value, y.value.indexOf(n), o.value)) {
+      const Z = (c.value || []).slice();
+      p && e.emit("select", Z, n), e.emit("selection-change", Z);
+    }
+  }, Se = () => {
+    var n, f;
+    const p = K.value ? !M.value : !(M.value || c.value.length);
+    M.value = p;
+    let h = !1, x = 0;
+    const R = (f = (n = e == null ? void 0 : e.store) == null ? void 0 : n.states) == null ? void 0 : f.rowKey.value, { childrenColumnName: E } = e.store.states, P = {
+      children: E.value,
+      checkStrictly: !1
+    };
+    y.value.forEach((j, X) => {
+      const Z = X + x;
+      ne(c.value, j, p, P, m.value, Z, R) && (h = !0), x += ue(N(j, R));
+    }), h && e.emit("selection-change", c.value ? c.value.slice() : []), e.emit("select-all", (c.value || []).slice());
+  }, Re = () => {
+    var n;
+    if (((n = y.value) == null ? void 0 : n.length) === 0) {
+      M.value = !1;
+      return;
+    }
+    const { childrenColumnName: f } = e.store.states;
+    let p = 0, h = 0;
+    const x = (E) => {
+      var P;
+      for (const j of E) {
+        const X = m.value && m.value.call(null, j, p);
+        if ($(j))
+          h++;
+        else if (!m.value || X)
+          return !1;
+        if (p++, (P = j[f.value]) != null && P.length && !x(j[f.value]))
+          return !1;
+      }
+      return !0;
+    }, R = x(y.value || []);
+    M.value = h === 0 ? !1 : R;
+  }, ue = (n) => {
+    var f;
+    if (!e || !e.store)
+      return 0;
+    const { treeData: p } = e.store.states;
+    let h = 0;
+    const x = (f = p.value[n]) == null ? void 0 : f.children;
+    return x && (h += x.length, x.forEach((R) => {
+      h += ue(R);
+    })), h;
+  }, Ke = (n, f) => {
+    const p = {};
+    return qe(n).forEach((h) => {
+      S.value[h.id] = f, p[h.columnKey || h.id] = f;
+    }), p;
+  }, ce = (n, f, p) => {
+    b.value && b.value !== n && (b.value.order = null), b.value = n, L.value = f, D.value = p;
+  }, ie = () => {
+    let n = F(O);
+    Object.keys(S.value).forEach((f) => {
+      const p = S.value[f];
+      if (!p || p.length === 0)
+        return;
+      const h = Qe({
+        columns: a.value
+      }, f);
+      h && h.filterMethod && (n = n.filter((x) => p.some((R) => h.filterMethod.call(null, R, x, h))));
+    }), T.value = n;
+  }, de = () => {
+    var n;
+    y.value = nt((n = T.value) != null ? n : [], {
+      sortingColumn: b.value,
+      sortProp: L.value,
+      sortOrder: D.value
+    });
+  }, Ee = (n = void 0) => {
+    n != null && n.filter || ie(), de();
+  }, _e = (n) => {
+    const { tableHeaderRef: f } = e.refs;
+    if (!f)
+      return;
+    const p = Object.assign({}, f.filterPanels), h = Object.keys(p);
+    if (h.length)
+      if (ye(n) && (n = [n]), oe(n)) {
+        const x = n.map((R) => Ue({
+          columns: a.value
+        }, R));
+        h.forEach((R) => {
+          const E = x.find((P) => P.id === R);
+          E && (E.filteredValue = []);
+        }), e.store.commit("filterChange", {
+          column: x,
+          values: [],
+          silent: !0,
+          multi: !0
+        });
+      } else
+        h.forEach((x) => {
+          const R = a.value.find((E) => E.id === x);
+          R && (R.filteredValue = []);
+        }), S.value = {}, e.store.commit("filterChange", {
+          column: {},
+          values: [],
+          silent: !0
+        });
+  }, be = () => {
+    b.value && (ce(null, null, null), e.store.commit("changeSortCondition", {
+      silent: !0
+    }));
+  }, {
+    setExpandRowKeys: Oe,
+    toggleRowExpansion: ve,
+    updateExpandRows: Te,
+    states: ze,
+    isRowExpanded: Ie
+  } = et({
+    data: y,
+    rowKey: o
+  }), {
+    updateTreeExpandKeys: Le,
+    toggleTreeExpansion: Ae,
+    updateTreeData: Fe,
+    updateKeyChildren: Ne,
+    loadOrToggle: Pe,
+    states: je
+  } = lt({
+    data: y,
+    rowKey: o
+  }), {
+    updateCurrentRowData: Me,
+    updateCurrentRow: Ve,
+    setCurrentRowKey: $e,
+    states: Ye
+  } = tt({
+    data: y,
+    rowKey: o
+  });
+  return {
+    assertRowKey: J,
+    updateColumns: A,
+    scheduleLayout: z,
+    isSelected: $,
+    clearSelection: U,
+    cleanSelection: te,
+    getSelectionRows: Ce,
+    toggleRowSelection: xe,
+    _toggleAllSelection: Se,
+    toggleAllSelection: null,
+    updateAllSelected: Re,
+    updateFilters: Ke,
+    updateCurrentRow: Ve,
+    updateSort: ce,
+    execFilter: ie,
+    execSort: de,
+    execQuery: Ee,
+    clearFilter: _e,
+    clearSort: be,
+    toggleRowExpansion: ve,
+    setExpandRowKeysAdapter: (n) => {
+      Oe(n), Le(n);
+    },
+    setCurrentRowKey: $e,
+    toggleRowExpansionAdapter: (n, f) => {
+      a.value.some(({ type: h }) => h === "expand") ? ve(n, f) : Ae(n, f);
+    },
+    isRowExpanded: Ie,
+    updateExpandRows: Te,
+    updateCurrentRowData: Me,
+    loadOrToggle: Pe,
+    updateTreeData: Fe,
+    updateKeyChildren: Ne,
+    states: {
+      tableSize: l,
+      rowKey: o,
+      data: y,
+      _data: O,
+      isComplex: s,
+      _columns: r,
+      originColumns: u,
+      columns: a,
+      fixedColumns: i,
+      rightFixedColumns: v,
+      leafColumns: w,
+      fixedLeafColumns: C,
+      rightFixedLeafColumns: I,
+      updateOrderFns: W,
+      leafColumnsLength: k,
+      fixedLeafColumnsLength: G,
+      rightFixedLeafColumnsLength: Y,
+      isAllSelected: M,
+      selection: c,
+      reserveSelection: g,
+      selectOnIndeterminate: K,
+      selectable: m,
+      filters: S,
+      filteredData: T,
+      sortingColumn: b,
+      sortProp: L,
+      sortOrder: D,
+      hoverRow: B,
+      ...ze,
+      ...je,
+      ...Ye
+    }
+  };
+}
+function ae(t, e) {
+  return t.map((l) => {
+    var o;
+    return l.id === e.id ? e : ((o = l.children) != null && o.length && (l.children = ae(l.children, e)), l);
+  });
+}
+function se(t) {
+  t.forEach((e) => {
+    var l, o;
+    e.no = (l = e.getColumnIndex) == null ? void 0 : l.call(e), (o = e.children) != null && o.length && se(e.children);
+  }), t.sort((e, l) => e.no - l.no);
+}
+function at() {
+  const t = H(), e = ot();
+  return {
+    ns: Ge("table"),
+    ...e,
+    mutations: {
+      setData(s, r) {
+        const u = F(s._data) !== r;
+        s.data.value = r, s._data.value = r, t.store.execQuery(), t.store.updateCurrentRowData(), t.store.updateExpandRows(), t.store.updateTreeData(t.store.states.defaultExpandAll.value), F(s.reserveSelection) ? t.store.assertRowKey() : u ? t.store.clearSelection() : t.store.cleanSelection(), t.store.updateAllSelected(), t.$ready && t.store.scheduleLayout();
+      },
+      insertColumn(s, r, u, a) {
+        var i;
+        const v = F(s._columns);
+        let w = [];
+        u ? (u && !u.children && (u.children = []), (i = u.children) == null || i.push(r), w = ae(v, u)) : (v.push(r), w = v), se(w), s._columns.value = w, s.updateOrderFns.push(a), r.type === "selection" && (s.selectable.value = r.selectable, s.reserveSelection.value = r.reserveSelection), t.$ready && (t.store.updateColumns(), t.store.scheduleLayout());
+      },
+      updateColumnOrder(s, r) {
+        var u;
+        ((u = r.getColumnIndex) == null ? void 0 : u.call(r)) !== r.no && (se(s._columns.value), t.$ready && t.store.updateColumns());
+      },
+      removeColumn(s, r, u, a) {
+        var i;
+        const v = F(s._columns) || [];
+        if (u)
+          (i = u.children) == null || i.splice(u.children.findIndex((C) => C.id === r.id), 1), fe(() => {
+            var C;
+            ((C = u.children) == null ? void 0 : C.length) === 0 && delete u.children;
+          }), s._columns.value = ae(v, u);
+        else {
+          const C = v.indexOf(r);
+          C > -1 && (v.splice(C, 1), s._columns.value = v);
+        }
+        const w = s.updateOrderFns.indexOf(a);
+        w > -1 && s.updateOrderFns.splice(w, 1), t.$ready && (t.store.updateColumns(), t.store.scheduleLayout());
+      },
+      sort(s, r) {
+        const { prop: u, order: a, init: i } = r;
+        if (u) {
+          const v = F(s.columns).find((w) => w.property === u);
+          v && (v.order = a, t.store.updateSort(v, u, a), t.store.commit("changeSortCondition", { init: i }));
+        }
+      },
+      changeSortCondition(s, r) {
+        const { sortingColumn: u, sortProp: a, sortOrder: i } = s, v = F(u), w = F(a), C = F(i);
+        ge(C) && (s.sortingColumn.value = null, s.sortProp.value = null);
+        const I = { filter: !0 };
+        t.store.execQuery(I), (!r || !(r.silent || r.init)) && t.emit("sort-change", {
+          column: v,
+          prop: w,
+          order: C
+        }), t.store.updateTableScrollY();
+      },
+      filterChange(s, r) {
+        const { column: u, values: a, silent: i } = r, v = t.store.updateFilters(u, a);
+        t.store.execQuery(), i || t.emit("filter-change", v), t.store.updateTableScrollY();
+      },
+      toggleAllSelection() {
+        var s, r;
+        (r = (s = t.store).toggleAllSelection) == null || r.call(s);
+      },
+      rowSelectedChanged(s, r) {
+        t.store.toggleRowSelection(r), t.store.updateAllSelected();
+      },
+      setHoverRow(s, r) {
+        s.hoverRow.value = r;
+      },
+      setCurrentRow(s, r) {
+        t.store.updateCurrentRow(r);
+      }
+    },
+    commit: function(s, ...r) {
+      const u = t.store.mutations;
+      if (u[s])
+        u[s].apply(t, [
+          t.store.states,
+          ...r
+        ]);
+      else
+        throw new Error(`Action not found: ${s}`);
+    },
+    updateTableScrollY: function() {
+      fe(() => t.layout.updateScrollY.apply(t.layout));
+    }
+  };
+}
+const re = {
+  rowKey: "rowKey",
+  defaultExpandAll: "defaultExpandAll",
+  selectOnIndeterminate: "selectOnIndeterminate",
+  indent: "indent",
+  lazy: "lazy",
+  data: "data",
+  "treeProps.hasChildren": {
+    key: "lazyColumnIdentifier",
+    default: "hasChildren"
+  },
+  "treeProps.children": {
+    key: "childrenColumnName",
+    default: "children"
+  },
+  "treeProps.checkStrictly": {
+    key: "checkStrictly",
+    default: !1
+  }
+};
+function pt(t, e) {
+  if (!t)
+    throw new Error("Table is required.");
+  const l = at();
+  return l.toggleAllSelection = Je(l._toggleAllSelection, 10), Object.keys(re).forEach((o) => {
+    me(we(e, o), o, l);
+  }), st(l, e), l;
+}
+function st(t, e) {
+  Object.keys(re).forEach((l) => {
+    Q(() => we(e, l), (o) => {
+      me(o, l, t);
+    });
+  });
+}
+function me(t, e, l) {
+  let o = t, y = re[e];
+  Xe(y) && (o = o || y.default, y = y.key), l.states[y].value = o;
+}
+function we(t, e) {
+  if (e.includes(".")) {
+    const l = e.split(".");
+    let o = t;
+    return l.forEach((y) => {
+      o = o[y];
+    }), o;
+  } else
+    return t[e];
+}
+const rt = () => ({
   lang: "en_us"
-}), r = {
+}), ut = {
   setLang(t) {
     this.lang = t;
   }
-}, d = {
-  state: c,
-  actions: r
-}, a = s(), p = (t) => {
-  const n = {};
-  return Object.keys(t).forEach((i) => {
-    const e = i.match(/chip\/(\S*).js/)[1];
-    n[e] = o(e, t[i].default);
-  }), n.init = o("init", d), window.$store = n, window.$pinia = a, {
-    store: n,
-    pinia: a
+}, ct = {
+  state: rt,
+  actions: ut
+}, pe = Ze(), gt = (t) => {
+  const e = {};
+  return Object.keys(t).forEach((l) => {
+    const o = l.match(/chip\/(\S*).js/)[1];
+    e[o] = he(o, t[l].default);
+  }), e.init = he("init", ct), window.$store = e, window.$pinia = pe, {
+    store: e,
+    pinia: pe
   };
 };
 export {
-  p as default
+  pt as c,
+  gt as p
 };