bitz-react-admin-ui 2.10.6 → 2.10.7-beta.1

package/dist/node_modules/@babel/helper-validator-identifier/lib/keyword.mjs

@@ -0,0 +1,32 @@
+import { __exports as t } from "../../../../_virtual/keyword.mjs";
+Object.defineProperty(t, "__esModule", {
+  value: !0
+});
+t.isKeyword = l;
+t.isReservedWord = s;
+t.isStrictBindOnlyReservedWord = d;
+t.isStrictBindReservedWord = u;
+t.isStrictReservedWord = n;
+const i = {
+  keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
+  strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
+  strictBind: ["eval", "arguments"]
+}, o = new Set(i.keyword), c = new Set(i.strict), a = new Set(i.strictBind);
+function s(e, r) {
+  return r && e === "await" || e === "enum";
+}
+function n(e, r) {
+  return s(e, r) || c.has(e);
+}
+function d(e) {
+  return a.has(e);
+}
+function u(e, r) {
+  return n(e, r) || d(e);
+}
+function l(e) {
+  return o.has(e);
+}
+export {
+  t as default
+};

package/dist/node_modules/@babel/highlight/lib/index.mjs

@@ -0,0 +1,128 @@
+import { __exports as o } from "../../../../_virtual/index34.mjs";
+import { __require as R } from "../../../js-tokens/index.mjs";
+import "../../helper-validator-identifier/lib/index.mjs";
+import { __require as T } from "../../../picocolors/picocolors.browser.mjs";
+import { __require as P } from "../node_modules/chalk/index.mjs";
+import { __exports as W } from "../../../../_virtual/index18.mjs";
+var _;
+function I() {
+  if (_)
+    return o;
+  _ = 1, Object.defineProperty(o, "__esModule", {
+    value: !0
+  }), o.default = q, o.shouldHighlight = y;
+  var f = R(), c = W, l = g(T(), !0);
+  function p(e) {
+    if (typeof WeakMap != "function")
+      return null;
+    var t = /* @__PURE__ */ new WeakMap(), r = /* @__PURE__ */ new WeakMap();
+    return (p = function(n) {
+      return n ? r : t;
+    })(e);
+  }
+  function g(e, t) {
+    if (!t && e && e.__esModule)
+      return e;
+    if (e === null || typeof e != "object" && typeof e != "function")
+      return { default: e };
+    var r = p(t);
+    if (r && r.has(e))
+      return r.get(e);
+    var n = { __proto__: null }, i = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for (var u in e)
+      if (u !== "default" && {}.hasOwnProperty.call(e, u)) {
+        var a = i ? Object.getOwnPropertyDescriptor(e, u) : null;
+        a && (a.get || a.set) ? Object.defineProperty(n, u, a) : n[u] = e[u];
+      }
+    return n.default = e, r && r.set(e, n), n;
+  }
+  const d = typeof process == "object" && (process.env.FORCE_COLOR === "0" || process.env.FORCE_COLOR === "false") ? (0, l.createColors)(!1) : l.default, v = (e, t) => (r) => e(t(r)), m = /* @__PURE__ */ new Set(["as", "async", "from", "get", "of", "set"]);
+  function w(e) {
+    return {
+      keyword: e.cyan,
+      capitalized: e.yellow,
+      jsxIdentifier: e.yellow,
+      punctuator: e.yellow,
+      number: e.magenta,
+      string: e.green,
+      regex: e.magenta,
+      comment: e.gray,
+      invalid: v(v(e.white, e.bgRed), e.bold)
+    };
+  }
+  const b = /\r\n|[\n\r\u2028\u2029]/, C = /^[()[\]{}]$/;
+  let h;
+  {
+    const e = /^[a-z][\w-]*$/i, t = function(r, n, i) {
+      if (r.type === "name") {
+        if ((0, c.isKeyword)(r.value) || (0, c.isStrictReservedWord)(r.value, !0) || m.has(r.value))
+          return "keyword";
+        if (e.test(r.value) && (i[n - 1] === "<" || i.slice(n - 2, n) === "</"))
+          return "jsxIdentifier";
+        if (r.value[0] !== r.value[0].toLowerCase())
+          return "capitalized";
+      }
+      return r.type === "punctuator" && C.test(r.value) ? "bracket" : r.type === "invalid" && (r.value === "@" || r.value === "#") ? "punctuator" : r.type;
+    };
+    h = function* (r) {
+      let n;
+      for (; n = f.default.exec(r); ) {
+        const i = f.matchToToken(n);
+        yield {
+          type: t(i, n.index, r),
+          value: i.value
+        };
+      }
+    };
+  }
+  function O(e, t) {
+    let r = "";
+    for (const {
+      type: n,
+      value: i
+    } of h(t)) {
+      const u = e[n];
+      u ? r += i.split(b).map((a) => u(a)).join(`
+`) : r += i;
+    }
+    return r;
+  }
+  function y(e) {
+    return d.isColorSupported || e.forceColor;
+  }
+  let s;
+  function j(e) {
+    if (e) {
+      var t;
+      return (t = s) != null || (s = (0, l.createColors)(!0)), s;
+    }
+    return d;
+  }
+  function q(e, t = {}) {
+    if (e !== "" && y(t)) {
+      const r = w(j(t.forceColor));
+      return O(r, e);
+    } else
+      return e;
+  }
+  {
+    let e, t;
+    o.getChalk = ({
+      forceColor: r
+    }) => {
+      var n;
+      if ((n = e) != null || (e = P()), r) {
+        var i;
+        return (i = t) != null || (t = new e.constructor({
+          enabled: !0,
+          level: 1
+        })), t;
+      }
+      return e;
+    };
+  }
+  return o;
+}
+export {
+  I as __require
+};

package/dist/node_modules/@babel/highlight/node_modules/ansi-styles/index.mjs

@@ -0,0 +1,116 @@
+import { __module as b } from "../../../../../_virtual/index40.mjs";
+import { __require as B } from "../color-convert/index.mjs";
+b.exports;
+var m;
+function d() {
+  return m ? b.exports : (m = 1, function(f) {
+    const i = B(), a = (t, e) => function() {
+      return `\x1B[${t.apply(i, arguments) + e}m`;
+    }, g = (t, e) => function() {
+      const n = t.apply(i, arguments);
+      return `\x1B[${38 + e};5;${n}m`;
+    }, l = (t, e) => function() {
+      const n = t.apply(i, arguments);
+      return `\x1B[${38 + e};2;${n[0]};${n[1]};${n[2]}m`;
+    };
+    function y() {
+      const t = /* @__PURE__ */ new Map(), e = {
+        modifier: {
+          reset: [0, 0],
+          // 21 isn't widely supported and 22 does the same thing
+          bold: [1, 22],
+          dim: [2, 22],
+          italic: [3, 23],
+          underline: [4, 24],
+          inverse: [7, 27],
+          hidden: [8, 28],
+          strikethrough: [9, 29]
+        },
+        color: {
+          black: [30, 39],
+          red: [31, 39],
+          green: [32, 39],
+          yellow: [33, 39],
+          blue: [34, 39],
+          magenta: [35, 39],
+          cyan: [36, 39],
+          white: [37, 39],
+          gray: [90, 39],
+          // Bright color
+          redBright: [91, 39],
+          greenBright: [92, 39],
+          yellowBright: [93, 39],
+          blueBright: [94, 39],
+          magentaBright: [95, 39],
+          cyanBright: [96, 39],
+          whiteBright: [97, 39]
+        },
+        bgColor: {
+          bgBlack: [40, 49],
+          bgRed: [41, 49],
+          bgGreen: [42, 49],
+          bgYellow: [43, 49],
+          bgBlue: [44, 49],
+          bgMagenta: [45, 49],
+          bgCyan: [46, 49],
+          bgWhite: [47, 49],
+          // Bright color
+          bgBlackBright: [100, 49],
+          bgRedBright: [101, 49],
+          bgGreenBright: [102, 49],
+          bgYellowBright: [103, 49],
+          bgBlueBright: [104, 49],
+          bgMagentaBright: [105, 49],
+          bgCyanBright: [106, 49],
+          bgWhiteBright: [107, 49]
+        }
+      };
+      e.color.grey = e.color.gray;
+      for (const r of Object.keys(e)) {
+        const o = e[r];
+        for (const s of Object.keys(o)) {
+          const c = o[s];
+          e[s] = {
+            open: `\x1B[${c[0]}m`,
+            close: `\x1B[${c[1]}m`
+          }, o[s] = e[s], t.set(c[0], c[1]);
+        }
+        Object.defineProperty(e, r, {
+          value: o,
+          enumerable: !1
+        }), Object.defineProperty(e, "codes", {
+          value: t,
+          enumerable: !1
+        });
+      }
+      const n = (r) => r, u = (r, o, s) => [r, o, s];
+      e.color.close = "\x1B[39m", e.bgColor.close = "\x1B[49m", e.color.ansi = {
+        ansi: a(n, 0)
+      }, e.color.ansi256 = {
+        ansi256: g(n, 0)
+      }, e.color.ansi16m = {
+        rgb: l(u, 0)
+      }, e.bgColor.ansi = {
+        ansi: a(n, 10)
+      }, e.bgColor.ansi256 = {
+        ansi256: g(n, 10)
+      }, e.bgColor.ansi16m = {
+        rgb: l(u, 10)
+      };
+      for (let r of Object.keys(i)) {
+        if (typeof i[r] != "object")
+          continue;
+        const o = i[r];
+        r === "ansi16" && (r = "ansi"), "ansi16" in o && (e.color.ansi[r] = a(o.ansi16, 0), e.bgColor.ansi[r] = a(o.ansi16, 10)), "ansi256" in o && (e.color.ansi256[r] = g(o.ansi256, 0), e.bgColor.ansi256[r] = g(o.ansi256, 10)), "rgb" in o && (e.color.ansi16m[r] = l(o.rgb, 0), e.bgColor.ansi16m[r] = l(o.rgb, 10));
+      }
+      return e;
+    }
+    Object.defineProperty(f, "exports", {
+      enumerable: !0,
+      get: y
+    });
+  }(b), b.exports);
+}
+export {
+  d as __require
+};

package/dist/node_modules/@babel/highlight/node_modules/chalk/index.mjs

@@ -0,0 +1,126 @@
+import { __module as g } from "../../../../../_virtual/index38.mjs";
+import { __require as C } from "../../../../escape-string-regexp/index.mjs";
+import { __require as O } from "../ansi-styles/index.mjs";
+import { __require as q } from "../supports-color/browser.mjs";
+import { __require as j } from "./templates.mjs";
+var _;
+function M() {
+  return _ ? g.exports : (_ = 1, function(i) {
+    const p = C(), r = O(), u = q().stdout, d = j(), h = process.platform === "win32" && !(process.env.TERM || "").toLowerCase().startsWith("xterm"), m = ["ansi", "ansi", "ansi256", "ansi16m"], y = /* @__PURE__ */ new Set(["gray"]), n = /* @__PURE__ */ Object.create(null);
+    function b(t, e) {
+      e = e || {};
+      const o = u ? u.level : 0;
+      t.level = e.level === void 0 ? o : e.level, t.enabled = "enabled" in e ? e.enabled : t.level > 0;
+    }
+    function c(t) {
+      if (!this || !(this instanceof c) || this.template) {
+        const e = {};
+        return b(e, t), e.template = function() {
+          const o = [].slice.call(arguments);
+          return x.apply(null, [e.template].concat(o));
+        }, Object.setPrototypeOf(e, c.prototype), Object.setPrototypeOf(e.template, e), e.template.constructor = c, e.template;
+      }
+      b(this, t);
+    }
+    h && (r.blue.open = "\x1B[94m");
+    for (const t of Object.keys(r))
+      r[t].closeRe = new RegExp(p(r[t].close), "g"), n[t] = {
+        get() {
+          const e = r[t];
+          return a.call(this, this._styles ? this._styles.concat(e) : [e], this._empty, t);
+        }
+      };
+    n.visible = {
+      get() {
+        return a.call(this, this._styles || [], !0, "visible");
+      }
+    }, r.color.closeRe = new RegExp(p(r.color.close), "g");
+    for (const t of Object.keys(r.color.ansi))
+      y.has(t) || (n[t] = {
+        get() {
+          const e = this.level;
+          return function() {
+            const l = {
+              open: r.color[m[e]][t].apply(null, arguments),
+              close: r.color.close,
+              closeRe: r.color.closeRe
+            };
+            return a.call(this, this._styles ? this._styles.concat(l) : [l], this._empty, t);
+          };
+        }
+      });
+    r.bgColor.closeRe = new RegExp(p(r.bgColor.close), "g");
+    for (const t of Object.keys(r.bgColor.ansi)) {
+      if (y.has(t))
+        continue;
+      const e = "bg" + t[0].toUpperCase() + t.slice(1);
+      n[e] = {
+        get() {
+          const o = this.level;
+          return function() {
+            const s = {
+              open: r.bgColor[m[o]][t].apply(null, arguments),
+              close: r.bgColor.close,
+              closeRe: r.bgColor.closeRe
+            };
+            return a.call(this, this._styles ? this._styles.concat(s) : [s], this._empty, t);
+          };
+        }
+      };
+    }
+    const v = Object.defineProperties(() => {
+    }, n);
+    function a(t, e, o) {
+      const l = function() {
+        return R.apply(l, arguments);
+      };
+      l._styles = t, l._empty = e;
+      const s = this;
+      return Object.defineProperty(l, "level", {
+        enumerable: !0,
+        get() {
+          return s.level;
+        },
+        set(f) {
+          s.level = f;
+        }
+      }), Object.defineProperty(l, "enabled", {
+        enumerable: !0,
+        get() {
+          return s.enabled;
+        },
+        set(f) {
+          s.enabled = f;
+        }
+      }), l.hasGrey = this.hasGrey || o === "gray" || o === "grey", l.__proto__ = v, l;
+    }
+    function R() {
+      const t = arguments, e = t.length;
+      let o = String(arguments[0]);
+      if (e === 0)
+        return "";
+      if (e > 1)
+        for (let s = 1; s < e; s++)
+          o += " " + t[s];
+      if (!this.enabled || this.level <= 0 || !o)
+        return this._empty ? "" : o;
+      const l = r.dim.open;
+      h && this.hasGrey && (r.dim.open = "");
+      for (const s of this._styles.slice().reverse())
+        o = s.open + o.replace(s.closeRe, s.open) + s.close, o = o.replace(/\r?\n/g, `${s.close}$&${s.open}`);
+      return r.dim.open = l, o;
+    }
+    function x(t, e) {
+      if (!Array.isArray(e))
+        return [].slice.call(arguments, 1).join(" ");
+      const o = [].slice.call(arguments, 2), l = [e.raw[0]];
+      for (let s = 1; s < e.length; s++)
+        l.push(String(o[s - 1]).replace(/[{}\\]/g, "\\$&")), l.push(String(e.raw[s]));
+      return d(t, l.join(""));
+    }
+    Object.defineProperties(c.prototype, n), i.exports = c(), i.exports.supportsColor = u, i.exports.default = i.exports;
+  }(g), g.exports);
+}
+export {
+  M as __require
+};

package/dist/node_modules/@babel/highlight/node_modules/chalk/templates.mjs

@@ -0,0 +1,86 @@
+var a, g;
+function x() {
+  if (g)
+    return a;
+  g = 1;
+  const m = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi, c = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g, E = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/, w = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi, y = /* @__PURE__ */ new Map([
+    ["n", `
+`],
+    ["r", "\r"],
+    ["t", "	"],
+    ["b", "\b"],
+    ["f", "\f"],
+    ["v", "\v"],
+    ["0", "\0"],
+    ["\\", "\\"],
+    ["e", "\x1B"],
+    ["a", "\x07"]
+  ]);
+  function f(s) {
+    return s[0] === "u" && s.length === 5 || s[0] === "x" && s.length === 3 ? String.fromCharCode(parseInt(s.slice(1), 16)) : y.get(s) || s;
+  }
+  function d(s, l) {
+    const e = [], n = l.trim().split(/\s*,\s*/g);
+    let t;
+    for (const r of n)
+      if (!isNaN(r))
+        e.push(Number(r));
+      else if (t = r.match(E))
+        e.push(t[2].replace(w, (u, o, i) => o ? f(o) : i));
+      else
+        throw new Error(`Invalid Chalk template style argument: ${r} (in style '${s}')`);
+    return e;
+  }
+  function k(s) {
+    c.lastIndex = 0;
+    const l = [];
+    let e;
+    for (; (e = c.exec(s)) !== null; ) {
+      const n = e[1];
+      if (e[2]) {
+        const t = d(n, e[2]);
+        l.push([n].concat(t));
+      } else
+        l.push([n]);
+    }
+    return l;
+  }
+  function h(s, l) {
+    const e = {};
+    for (const t of l)
+      for (const r of t.styles)
+        e[r[0]] = t.inverse ? null : r.slice(1);
+    let n = s;
+    for (const t of Object.keys(e))
+      if (Array.isArray(e[t])) {
+        if (!(t in n))
+          throw new Error(`Unknown Chalk style: ${t}`);
+        e[t].length > 0 ? n = n[t].apply(n, e[t]) : n = n[t];
+      }
+    return n;
+  }
+  return a = (s, l) => {
+    const e = [], n = [];
+    let t = [];
+    if (l.replace(m, (r, u, o, i, S, b) => {
+      if (u)
+        t.push(f(u));
+      else if (i) {
+        const p = t.join("");
+        t = [], n.push(e.length === 0 ? p : h(s, e)(p)), e.push({ inverse: o, styles: k(i) });
+      } else if (S) {
+        if (e.length === 0)
+          throw new Error("Found extraneous } in Chalk template literal");
+        n.push(h(s, e)(t.join(""))), t = [], e.pop();
+      } else
+        t.push(b);
+    }), n.push(t.join("")), e.length > 0) {
+      const r = `Chalk template literal is missing ${e.length} closing bracket${e.length === 1 ? "" : "s"} (\`}\`)`;
+      throw new Error(r);
+    }
+    return n.join("");
+  }, a;
+}
+export {
+  x as __require
+};