fec-dev-designer 1.0.0 → 1.0.2

package/es/node_modules/vuex/dist/vuex.esm-bundler.js

@@ -0,0 +1,667 @@
+import { watch as I, effectScope as B, reactive as K, inject as W, computed as Y } from "vue";
+import { setupDevtoolsPlugin as q } from "../../@vue/devtools-api/lib/esm/index.js";
+/*!
+ * vuex v4.1.0
+ * (c) 2022 Evan You
+ * @license MIT
+ */
+var V = "store";
+function ht(e) {
+  return e === void 0 && (e = null), W(e !== null ? e : V);
+}
+function _(e, t) {
+  Object.keys(e).forEach(function(n) {
+    return t(e[n], n);
+  });
+}
+function J(e) {
+  return e !== null && typeof e == "object";
+}
+function X(e) {
+  return e && typeof e.then == "function";
+}
+function h(e, t) {
+  if (!e)
+    throw new Error("[vuex] " + t);
+}
+function z(e, t) {
+  return function() {
+    return e(t);
+  };
+}
+function M(e, t, n) {
+  return t.indexOf(e) < 0 && (n && n.prepend ? t.unshift(e) : t.push(e)), function() {
+    var r = t.indexOf(e);
+    r > -1 && t.splice(r, 1);
+  };
+}
+function T(e, t) {
+  e._actions = /* @__PURE__ */ Object.create(null), e._mutations = /* @__PURE__ */ Object.create(null), e._wrappedGetters = /* @__PURE__ */ Object.create(null), e._modulesNamespaceMap = /* @__PURE__ */ Object.create(null);
+  var n = e.state;
+  E(e, n, [], e._modules.root, !0), w(e, n, t);
+}
+function w(e, t, n) {
+  var r = e._state, o = e._scope;
+  e.getters = {}, e._makeLocalGettersCache = /* @__PURE__ */ Object.create(null);
+  var i = e._wrappedGetters, s = {}, f = {}, a = B(!0);
+  a.run(function() {
+    _(i, function(p, c) {
+      s[c] = z(p, e), f[c] = Y(function() {
+        return s[c]();
+      }), Object.defineProperty(e.getters, c, {
+        get: function() {
+          return f[c].value;
+        },
+        enumerable: !0
+        // for local getters
+      });
+    });
+  }), e._state = K({
+    data: t
+  }), e._scope = a, e.strict && rt(e), r && n && e._withCommit(function() {
+    r.data = null;
+  }), o && o.stop();
+}
+function E(e, t, n, r, o) {
+  var i = !n.length, s = e._modules.getNamespace(n);
+  if (r.namespaced && (e._modulesNamespaceMap[s] && process.env.NODE_ENV !== "production" && console.error("[vuex] duplicate namespace " + s + " for the namespaced module " + n.join("/")), e._modulesNamespaceMap[s] = r), !i && !o) {
+    var f = C(t, n.slice(0, -1)), a = n[n.length - 1];
+    e._withCommit(function() {
+      process.env.NODE_ENV !== "production" && a in f && console.warn(
+        '[vuex] state field "' + a + '" was overridden by a module with the same name at "' + n.join(".") + '"'
+      ), f[a] = r.state;
+    });
+  }
+  var p = r.context = Q(e, s, n);
+  r.forEachMutation(function(c, u) {
+    var d = s + u;
+    Z(e, d, c, p);
+  }), r.forEachAction(function(c, u) {
+    var d = c.root ? u : s + u, l = c.handler || c;
+    tt(e, d, l, p);
+  }), r.forEachGetter(function(c, u) {
+    var d = s + u;
+    et(e, d, c, p);
+  }), r.forEachChild(function(c, u) {
+    E(e, t, n.concat(u), c, o);
+  });
+}
+function Q(e, t, n) {
+  var r = t === "", o = {
+    dispatch: r ? e.dispatch : function(i, s, f) {
+      var a = y(i, s, f), p = a.payload, c = a.options, u = a.type;
+      if ((!c || !c.root) && (u = t + u, process.env.NODE_ENV !== "production" && !e._actions[u])) {
+        console.error("[vuex] unknown local action type: " + a.type + ", global type: " + u);
+        return;
+      }
+      return e.dispatch(u, p);
+    },
+    commit: r ? e.commit : function(i, s, f) {
+      var a = y(i, s, f), p = a.payload, c = a.options, u = a.type;
+      if ((!c || !c.root) && (u = t + u, process.env.NODE_ENV !== "production" && !e._mutations[u])) {
+        console.error("[vuex] unknown local mutation type: " + a.type + ", global type: " + u);
+        return;
+      }
+      e.commit(u, p, c);
+    }
+  };
+  return Object.defineProperties(o, {
+    getters: {
+      get: r ? function() {
+        return e.getters;
+      } : function() {
+        return G(e, t);
+      }
+    },
+    state: {
+      get: function() {
+        return C(e.state, n);
+      }
+    }
+  }), o;
+}
+function G(e, t) {
+  if (!e._makeLocalGettersCache[t]) {
+    var n = {}, r = t.length;
+    Object.keys(e.getters).forEach(function(o) {
+      if (o.slice(0, r) === t) {
+        var i = o.slice(r);
+        Object.defineProperty(n, i, {
+          get: function() {
+            return e.getters[o];
+          },
+          enumerable: !0
+        });
+      }
+    }), e._makeLocalGettersCache[t] = n;
+  }
+  return e._makeLocalGettersCache[t];
+}
+function Z(e, t, n, r) {
+  var o = e._mutations[t] || (e._mutations[t] = []);
+  o.push(function(s) {
+    n.call(e, r.state, s);
+  });
+}
+function tt(e, t, n, r) {
+  var o = e._actions[t] || (e._actions[t] = []);
+  o.push(function(s) {
+    var f = n.call(e, {
+      dispatch: r.dispatch,
+      commit: r.commit,
+      getters: r.getters,
+      state: r.state,
+      rootGetters: e.getters,
+      rootState: e.state
+    }, s);
+    return X(f) || (f = Promise.resolve(f)), e._devtoolHook ? f.catch(function(a) {
+      throw e._devtoolHook.emit("vuex:error", a), a;
+    }) : f;
+  });
+}
+function et(e, t, n, r) {
+  if (e._wrappedGetters[t]) {
+    process.env.NODE_ENV !== "production" && console.error("[vuex] duplicate getter key: " + t);
+    return;
+  }
+  e._wrappedGetters[t] = function(i) {
+    return n(
+      r.state,
+      // local state
+      r.getters,
+      // local getters
+      i.state,
+      // root state
+      i.getters
+      // root getters
+    );
+  };
+}
+function rt(e) {
+  I(function() {
+    return e._state.data;
+  }, function() {
+    process.env.NODE_ENV !== "production" && h(e._committing, "do not mutate vuex store state outside mutation handlers.");
+  }, { deep: !0, flush: "sync" });
+}
+function C(e, t) {
+  return t.reduce(function(n, r) {
+    return n[r];
+  }, e);
+}
+function y(e, t, n) {
+  return J(e) && e.type && (n = t, t = e, e = e.type), process.env.NODE_ENV !== "production" && h(typeof e == "string", "expects string as the type, but found " + typeof e + "."), { type: e, payload: t, options: n };
+}
+var nt = "vuex bindings", S = "vuex:mutations", O = "vuex:actions", b = "vuex", ot = 0;
+function it(e, t) {
+  q(
+    {
+      id: "org.vuejs.vuex",
+      app: e,
+      label: "Vuex",
+      homepage: "https://next.vuex.vuejs.org/",
+      logo: "https://vuejs.org/images/icons/favicon-96x96.png",
+      packageName: "vuex",
+      componentStateTypes: [nt]
+    },
+    function(n) {
+      n.addTimelineLayer({
+        id: S,
+        label: "Vuex Mutations",
+        color: j
+      }), n.addTimelineLayer({
+        id: O,
+        label: "Vuex Actions",
+        color: j
+      }), n.addInspector({
+        id: b,
+        label: "Vuex",
+        icon: "storage",
+        treeFilterPlaceholder: "Filter stores..."
+      }), n.on.getInspectorTree(function(r) {
+        if (r.app === e && r.inspectorId === b)
+          if (r.filter) {
+            var o = [];
+            P(o, t._modules.root, r.filter, ""), r.rootNodes = o;
+          } else
+            r.rootNodes = [
+              R(t._modules.root, "")
+            ];
+      }), n.on.getInspectorState(function(r) {
+        if (r.app === e && r.inspectorId === b) {
+          var o = r.nodeId;
+          G(t, o), r.state = at(
+            ft(t._modules, o),
+            o === "root" ? t.getters : t._makeLocalGettersCache,
+            o
+          );
+        }
+      }), n.on.editInspectorState(function(r) {
+        if (r.app === e && r.inspectorId === b) {
+          var o = r.nodeId, i = r.path;
+          o !== "root" && (i = o.split("/").filter(Boolean).concat(i)), t._withCommit(function() {
+            r.set(t._state.data, i, r.state.value);
+          });
+        }
+      }), t.subscribe(function(r, o) {
+        var i = {};
+        r.payload && (i.payload = r.payload), i.state = o, n.notifyComponentUpdate(), n.sendInspectorTree(b), n.sendInspectorState(b), n.addTimelineEvent({
+          layerId: S,
+          event: {
+            time: Date.now(),
+            title: r.type,
+            data: i
+          }
+        });
+      }), t.subscribeAction({
+        before: function(r, o) {
+          var i = {};
+          r.payload && (i.payload = r.payload), r._id = ot++, r._time = Date.now(), i.state = o, n.addTimelineEvent({
+            layerId: O,
+            event: {
+              time: r._time,
+              title: r.type,
+              groupId: r._id,
+              subtitle: "start",
+              data: i
+            }
+          });
+        },
+        after: function(r, o) {
+          var i = {}, s = Date.now() - r._time;
+          i.duration = {
+            _custom: {
+              type: "duration",
+              display: s + "ms",
+              tooltip: "Action duration",
+              value: s
+            }
+          }, r.payload && (i.payload = r.payload), i.state = o, n.addTimelineEvent({
+            layerId: O,
+            event: {
+              time: Date.now(),
+              title: r.type,
+              groupId: r._id,
+              subtitle: "end",
+              data: i
+            }
+          });
+        }
+      });
+    }
+  );
+}
+var j = 8702998, st = 6710886, ct = 16777215, L = {
+  label: "namespaced",
+  textColor: ct,
+  backgroundColor: st
+};
+function $(e) {
+  return e && e !== "root" ? e.split("/").slice(-2, -1)[0] : "Root";
+}
+function R(e, t) {
+  return {
+    id: t || "root",
+    // all modules end with a `/`, we want the last segment only
+    // cart/ -> cart
+    // nested/cart/ -> cart
+    label: $(t),
+    tags: e.namespaced ? [L] : [],
+    children: Object.keys(e._children).map(
+      function(n) {
+        return R(
+          e._children[n],
+          t + n + "/"
+        );
+      }
+    )
+  };
+}
+function P(e, t, n, r) {
+  r.includes(n) && e.push({
+    id: r || "root",
+    label: r.endsWith("/") ? r.slice(0, r.length - 1) : r || "Root",
+    tags: t.namespaced ? [L] : []
+  }), Object.keys(t._children).forEach(function(o) {
+    P(e, t._children[o], n, r + o + "/");
+  });
+}
+function at(e, t, n) {
+  t = n === "root" ? t : t[n];
+  var r = Object.keys(t), o = {
+    state: Object.keys(e.state).map(function(s) {
+      return {
+        key: s,
+        editable: !0,
+        value: e.state[s]
+      };
+    })
+  };
+  if (r.length) {
+    var i = ut(t);
+    o.getters = Object.keys(i).map(function(s) {
+      return {
+        key: s.endsWith("/") ? $(s) : s,
+        editable: !1,
+        value: N(function() {
+          return i[s];
+        })
+      };
+    });
+  }
+  return o;
+}
+function ut(e) {
+  var t = {};
+  return Object.keys(e).forEach(function(n) {
+    var r = n.split("/");
+    if (r.length > 1) {
+      var o = t, i = r.pop();
+      r.forEach(function(s) {
+        o[s] || (o[s] = {
+          _custom: {
+            value: {},
+            display: s,
+            tooltip: "Module",
+            abstract: !0
+          }
+        }), o = o[s]._custom.value;
+      }), o[i] = N(function() {
+        return e[n];
+      });
+    } else
+      t[n] = N(function() {
+        return e[n];
+      });
+  }), t;
+}
+function ft(e, t) {
+  var n = t.split("/").filter(function(r) {
+    return r;
+  });
+  return n.reduce(
+    function(r, o, i) {
+      var s = r[o];
+      if (!s)
+        throw new Error('Missing module "' + o + '" for path "' + t + '".');
+      return i === n.length - 1 ? s : s._children;
+    },
+    t === "root" ? e : e.root._children
+  );
+}
+function N(e) {
+  try {
+    return e();
+  } catch (t) {
+    return t;
+  }
+}
+var m = function(t, n) {
+  this.runtime = n, this._children = /* @__PURE__ */ Object.create(null), this._rawModule = t;
+  var r = t.state;
+  this.state = (typeof r == "function" ? r() : r) || {};
+}, k = { namespaced: { configurable: !0 } };
+k.namespaced.get = function() {
+  return !!this._rawModule.namespaced;
+};
+m.prototype.addChild = function(t, n) {
+  this._children[t] = n;
+};
+m.prototype.removeChild = function(t) {
+  delete this._children[t];
+};
+m.prototype.getChild = function(t) {
+  return this._children[t];
+};
+m.prototype.hasChild = function(t) {
+  return t in this._children;
+};
+m.prototype.update = function(t) {
+  this._rawModule.namespaced = t.namespaced, t.actions && (this._rawModule.actions = t.actions), t.mutations && (this._rawModule.mutations = t.mutations), t.getters && (this._rawModule.getters = t.getters);
+};
+m.prototype.forEachChild = function(t) {
+  _(this._children, t);
+};
+m.prototype.forEachGetter = function(t) {
+  this._rawModule.getters && _(this._rawModule.getters, t);
+};
+m.prototype.forEachAction = function(t) {
+  this._rawModule.actions && _(this._rawModule.actions, t);
+};
+m.prototype.forEachMutation = function(t) {
+  this._rawModule.mutations && _(this._rawModule.mutations, t);
+};
+Object.defineProperties(m.prototype, k);
+var g = function(t) {
+  this.register([], t, !1);
+};
+g.prototype.get = function(t) {
+  return t.reduce(function(n, r) {
+    return n.getChild(r);
+  }, this.root);
+};
+g.prototype.getNamespace = function(t) {
+  var n = this.root;
+  return t.reduce(function(r, o) {
+    return n = n.getChild(o), r + (n.namespaced ? o + "/" : "");
+  }, "");
+};
+g.prototype.update = function(t) {
+  F([], this.root, t);
+};
+g.prototype.register = function(t, n, r) {
+  var o = this;
+  r === void 0 && (r = !0), process.env.NODE_ENV !== "production" && U(t, n);
+  var i = new m(n, r);
+  if (t.length === 0)
+    this.root = i;
+  else {
+    var s = this.get(t.slice(0, -1));
+    s.addChild(t[t.length - 1], i);
+  }
+  n.modules && _(n.modules, function(f, a) {
+    o.register(t.concat(a), f, r);
+  });
+};
+g.prototype.unregister = function(t) {
+  var n = this.get(t.slice(0, -1)), r = t[t.length - 1], o = n.getChild(r);
+  if (!o) {
+    process.env.NODE_ENV !== "production" && console.warn(
+      "[vuex] trying to unregister module '" + r + "', which is not registered"
+    );
+    return;
+  }
+  o.runtime && n.removeChild(r);
+};
+g.prototype.isRegistered = function(t) {
+  var n = this.get(t.slice(0, -1)), r = t[t.length - 1];
+  return n ? n.hasChild(r) : !1;
+};
+function F(e, t, n) {
+  if (process.env.NODE_ENV !== "production" && U(e, n), t.update(n), n.modules)
+    for (var r in n.modules) {
+      if (!t.getChild(r)) {
+        process.env.NODE_ENV !== "production" && console.warn(
+          "[vuex] trying to add a new module '" + r + "' on hot reloading, manual reload is needed"
+        );
+        return;
+      }
+      F(
+        e.concat(r),
+        t.getChild(r),
+        n.modules[r]
+      );
+    }
+}
+var D = {
+  assert: function(e) {
+    return typeof e == "function";
+  },
+  expected: "function"
+}, lt = {
+  assert: function(e) {
+    return typeof e == "function" || typeof e == "object" && typeof e.handler == "function";
+  },
+  expected: 'function or object with "handler" function'
+}, A = {
+  getters: D,
+  mutations: D,
+  actions: lt
+};
+function U(e, t) {
+  Object.keys(A).forEach(function(n) {
+    if (t[n]) {
+      var r = A[n];
+      _(t[n], function(o, i) {
+        h(
+          r.assert(o),
+          dt(e, n, i, o, r.expected)
+        );
+      });
+    }
+  });
+}
+function dt(e, t, n, r, o) {
+  var i = t + " should be " + o + ' but "' + t + "." + n + '"';
+  return e.length > 0 && (i += ' in module "' + e.join(".") + '"'), i += " is " + JSON.stringify(r) + ".", i;
+}
+function mt(e) {
+  return new v(e);
+}
+var v = function e(t) {
+  var n = this;
+  t === void 0 && (t = {}), process.env.NODE_ENV !== "production" && (h(typeof Promise < "u", "vuex requires a Promise polyfill in this browser."), h(this instanceof e, "store must be called with the new operator."));
+  var r = t.plugins;
+  r === void 0 && (r = []);
+  var o = t.strict;
+  o === void 0 && (o = !1);
+  var i = t.devtools;
+  this._committing = !1, this._actions = /* @__PURE__ */ Object.create(null), this._actionSubscribers = [], this._mutations = /* @__PURE__ */ Object.create(null), this._wrappedGetters = /* @__PURE__ */ Object.create(null), this._modules = new g(t), this._modulesNamespaceMap = /* @__PURE__ */ Object.create(null), this._subscribers = [], this._makeLocalGettersCache = /* @__PURE__ */ Object.create(null), this._scope = null, this._devtools = i;
+  var s = this, f = this, a = f.dispatch, p = f.commit;
+  this.dispatch = function(d, l) {
+    return a.call(s, d, l);
+  }, this.commit = function(d, l, H) {
+    return p.call(s, d, l, H);
+  }, this.strict = o;
+  var c = this._modules.root.state;
+  E(this, c, [], this._modules.root), w(this, c), r.forEach(function(u) {
+    return u(n);
+  });
+}, x = { state: { configurable: !0 } };
+v.prototype.install = function(t, n) {
+  t.provide(n || V, this), t.config.globalProperties.$store = this;
+  var r = this._devtools !== void 0 ? this._devtools : process.env.NODE_ENV !== "production" || !1;
+  r && it(t, this);
+};
+x.state.get = function() {
+  return this._state.data;
+};
+x.state.set = function(e) {
+  process.env.NODE_ENV !== "production" && h(!1, "use store.replaceState() to explicit replace store state.");
+};
+v.prototype.commit = function(t, n, r) {
+  var o = this, i = y(t, n, r), s = i.type, f = i.payload, a = i.options, p = { type: s, payload: f }, c = this._mutations[s];
+  if (!c) {
+    process.env.NODE_ENV !== "production" && console.error("[vuex] unknown mutation type: " + s);
+    return;
+  }
+  this._withCommit(function() {
+    c.forEach(function(d) {
+      d(f);
+    });
+  }), this._subscribers.slice().forEach(function(u) {
+    return u(p, o.state);
+  }), process.env.NODE_ENV !== "production" && a && a.silent && console.warn(
+    "[vuex] mutation type: " + s + ". Silent option has been removed. Use the filter functionality in the vue-devtools"
+  );
+};
+v.prototype.dispatch = function(t, n) {
+  var r = this, o = y(t, n), i = o.type, s = o.payload, f = { type: i, payload: s }, a = this._actions[i];
+  if (!a) {
+    process.env.NODE_ENV !== "production" && console.error("[vuex] unknown action type: " + i);
+    return;
+  }
+  try {
+    this._actionSubscribers.slice().filter(function(c) {
+      return c.before;
+    }).forEach(function(c) {
+      return c.before(f, r.state);
+    });
+  } catch (c) {
+    process.env.NODE_ENV !== "production" && (console.warn("[vuex] error in before action subscribers: "), console.error(c));
+  }
+  var p = a.length > 1 ? Promise.all(a.map(function(c) {
+    return c(s);
+  })) : a[0](s);
+  return new Promise(function(c, u) {
+    p.then(function(d) {
+      try {
+        r._actionSubscribers.filter(function(l) {
+          return l.after;
+        }).forEach(function(l) {
+          return l.after(f, r.state);
+        });
+      } catch (l) {
+        process.env.NODE_ENV !== "production" && (console.warn("[vuex] error in after action subscribers: "), console.error(l));
+      }
+      c(d);
+    }, function(d) {
+      try {
+        r._actionSubscribers.filter(function(l) {
+          return l.error;
+        }).forEach(function(l) {
+          return l.error(f, r.state, d);
+        });
+      } catch (l) {
+        process.env.NODE_ENV !== "production" && (console.warn("[vuex] error in error action subscribers: "), console.error(l));
+      }
+      u(d);
+    });
+  });
+};
+v.prototype.subscribe = function(t, n) {
+  return M(t, this._subscribers, n);
+};
+v.prototype.subscribeAction = function(t, n) {
+  var r = typeof t == "function" ? { before: t } : t;
+  return M(r, this._actionSubscribers, n);
+};
+v.prototype.watch = function(t, n, r) {
+  var o = this;
+  return process.env.NODE_ENV !== "production" && h(typeof t == "function", "store.watch only accepts a function."), I(function() {
+    return t(o.state, o.getters);
+  }, n, Object.assign({}, r));
+};
+v.prototype.replaceState = function(t) {
+  var n = this;
+  this._withCommit(function() {
+    n._state.data = t;
+  });
+};
+v.prototype.registerModule = function(t, n, r) {
+  r === void 0 && (r = {}), typeof t == "string" && (t = [t]), process.env.NODE_ENV !== "production" && (h(Array.isArray(t), "module path must be a string or an Array."), h(t.length > 0, "cannot register the root module by using registerModule.")), this._modules.register(t, n), E(this, this.state, t, this._modules.get(t), r.preserveState), w(this, this.state);
+};
+v.prototype.unregisterModule = function(t) {
+  var n = this;
+  typeof t == "string" && (t = [t]), process.env.NODE_ENV !== "production" && h(Array.isArray(t), "module path must be a string or an Array."), this._modules.unregister(t), this._withCommit(function() {
+    var r = C(n.state, t.slice(0, -1));
+    delete r[t[t.length - 1]];
+  }), T(this);
+};
+v.prototype.hasModule = function(t) {
+  return typeof t == "string" && (t = [t]), process.env.NODE_ENV !== "production" && h(Array.isArray(t), "module path must be a string or an Array."), this._modules.isRegistered(t);
+};
+v.prototype.hotUpdate = function(t) {
+  this._modules.update(t), T(this, !0);
+};
+v.prototype._withCommit = function(t) {
+  var n = this._committing;
+  this._committing = !0, t(), this._committing = n;
+};
+Object.defineProperties(v.prototype, x);
+export {
+  v as Store,
+  mt as createStore,
+  V as storeKey,
+  ht as useStore
+};