@blockbite/ui 1.0.5 → 2.0.1

package/dist/node_modules/postcss/lib/previous-map.js

@@ -0,0 +1,88 @@
+import s from "../../../_virtual/___vite-browser-external.js";
+let { existsSync: p, readFileSync: d } = s, { dirname: a, join: g } = s, { SourceMapConsumer: f, SourceMapGenerator: h } = s;
+function b(r) {
+  return Buffer ? Buffer.from(r, "base64").toString() : window.atob(r);
+}
+class o {
+  constructor(t, e) {
+    if (e.map === !1) return;
+    this.loadAnnotation(t), this.inline = this.startWith(this.annotation, "data:");
+    let i = e.map ? e.map.prev : void 0, n = this.loadMap(e.from, i);
+    !this.mapFile && e.from && (this.mapFile = e.from), this.mapFile && (this.root = a(this.mapFile)), n && (this.text = n);
+  }
+  consumer() {
+    return this.consumerCache || (this.consumerCache = new f(this.text)), this.consumerCache;
+  }
+  decodeInline(t) {
+    let e = /^data:application\/json;charset=utf-?8;base64,/, i = /^data:application\/json;base64,/, n = /^data:application\/json;charset=utf-?8,/, c = /^data:application\/json,/, l = t.match(n) || t.match(c);
+    if (l)
+      return decodeURIComponent(t.substr(l[0].length));
+    let u = t.match(e) || t.match(i);
+    if (u)
+      return b(t.substr(u[0].length));
+    let m = t.match(/data:application\/json;([^,]+),/)[1];
+    throw new Error("Unsupported source map encoding " + m);
+  }
+  getAnnotationURL(t) {
+    return t.replace(/^\/\*\s*# sourceMappingURL=/, "").trim();
+  }
+  isMap(t) {
+    return typeof t != "object" ? !1 : typeof t.mappings == "string" || typeof t._mappings == "string" || Array.isArray(t.sections);
+  }
+  loadAnnotation(t) {
+    let e = t.match(/\/\*\s*# sourceMappingURL=/g);
+    if (!e) return;
+    let i = t.lastIndexOf(e.pop()), n = t.indexOf("*/", i);
+    i > -1 && n > -1 && (this.annotation = this.getAnnotationURL(t.substring(i, n)));
+  }
+  loadFile(t) {
+    if (this.root = a(t), p(t))
+      return this.mapFile = t, d(t, "utf-8").toString().trim();
+  }
+  loadMap(t, e) {
+    if (e === !1) return !1;
+    if (e) {
+      if (typeof e == "string")
+        return e;
+      if (typeof e == "function") {
+        let i = e(t);
+        if (i) {
+          let n = this.loadFile(i);
+          if (!n)
+            throw new Error(
+              "Unable to load previous source map: " + i.toString()
+            );
+          return n;
+        }
+      } else {
+        if (e instanceof f)
+          return h.fromSourceMap(e).toString();
+        if (e instanceof h)
+          return e.toString();
+        if (this.isMap(e))
+          return JSON.stringify(e);
+        throw new Error(
+          "Unsupported previous source map format: " + e.toString()
+        );
+      }
+    } else {
+      if (this.inline)
+        return this.decodeInline(this.annotation);
+      if (this.annotation) {
+        let i = this.annotation;
+        return t && (i = g(a(t), i)), this.loadFile(i);
+      }
+    }
+  }
+  startWith(t, e) {
+    return t ? t.substr(0, e.length) === e : !1;
+  }
+  withContent() {
+    return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0);
+  }
+}
+var S = o;
+o.default = o;
+export {
+  S as p
+};

package/dist/node_modules/postcss/lib/processor.js

@@ -0,0 +1,43 @@
+import { getDefaultExportFromCjs as o } from "../../../_virtual/_commonjsHelpers.js";
+import { d as i } from "./document.js";
+import { l as n } from "./lazy-result.js";
+import { n as l } from "./no-work-result.js";
+import { r as u } from "./root.js";
+let a = i, p = n, c = l, f = u;
+class t {
+  constructor(r = []) {
+    this.version = "8.5.3", this.plugins = this.normalize(r);
+  }
+  normalize(r) {
+    let e = [];
+    for (let s of r)
+      if (s.postcss === !0 ? s = s() : s.postcss && (s = s.postcss), typeof s == "object" && Array.isArray(s.plugins))
+        e = e.concat(s.plugins);
+      else if (typeof s == "object" && s.postcssPlugin)
+        e.push(s);
+      else if (typeof s == "function")
+        e.push(s);
+      else if (typeof s == "object" && (s.parse || s.stringify)) {
+        if (process.env.NODE_ENV !== "production")
+          throw new Error(
+            "PostCSS syntaxes cannot be used as plugins. Instead, please use one of the syntax/parser/stringifier options as outlined in your PostCSS runner documentation."
+          );
+      } else
+        throw new Error(s + " is not a PostCSS plugin");
+    return e;
+  }
+  process(r, e = {}) {
+    return !this.plugins.length && !e.parser && !e.stringifier && !e.syntax ? new c(this, r, e) : new p(this, r, e);
+  }
+  use(r) {
+    return this.plugins = this.plugins.concat(this.normalize([r])), this;
+  }
+}
+var m = t;
+t.default = t;
+f.registerProcessor(t);
+a.registerProcessor(t);
+const z = /* @__PURE__ */ o(m);
+export {
+  z as default
+};

package/dist/node_modules/postcss/lib/result.js

@@ -0,0 +1,26 @@
+import { w as r } from "./warning.js";
+let e = r;
+class n {
+  get content() {
+    return this.css;
+  }
+  constructor(s, t, i) {
+    this.processor = s, this.messages = [], this.root = t, this.opts = i, this.css = void 0, this.map = void 0;
+  }
+  toString() {
+    return this.css;
+  }
+  warn(s, t = {}) {
+    t.plugin || this.lastPlugin && this.lastPlugin.postcssPlugin && (t.plugin = this.lastPlugin.postcssPlugin);
+    let i = new e(s, t);
+    return this.messages.push(i), i;
+  }
+  warnings() {
+    return this.messages.filter((s) => s.type === "warning");
+  }
+}
+var g = n;
+n.default = n;
+export {
+  g as r
+};

package/dist/node_modules/postcss/lib/root.js

@@ -0,0 +1,37 @@
+import { c as d } from "./container.js";
+let n = d, f, l;
+class s extends n {
+  constructor(e) {
+    super(e), this.type = "root", this.nodes || (this.nodes = []);
+  }
+  normalize(e, r, o) {
+    let i = super.normalize(e);
+    if (r) {
+      if (o === "prepend")
+        this.nodes.length > 1 ? r.raws.before = this.nodes[1].raws.before : delete r.raws.before;
+      else if (this.first !== r)
+        for (let a of i)
+          a.raws.before = r.raws.before;
+    }
+    return i;
+  }
+  removeChild(e, r) {
+    let o = this.index(e);
+    return !r && o === 0 && this.nodes.length > 1 && (this.nodes[1].raws.before = this.nodes[o].raws.before), super.removeChild(e);
+  }
+  toResult(e = {}) {
+    return new f(new l(), this, e).stringify();
+  }
+}
+s.registerLazyResult = (t) => {
+  f = t;
+};
+s.registerProcessor = (t) => {
+  l = t;
+};
+var u = s;
+s.default = s;
+n.registerRoot(s);
+export {
+  u as r
+};

package/dist/node_modules/postcss/lib/rule.js

@@ -0,0 +1,21 @@
+import { c as o } from "./container.js";
+import { l as i } from "./list.js";
+let r = o, c = i;
+class e extends r {
+  get selectors() {
+    return c.comma(this.selector);
+  }
+  set selectors(t) {
+    let s = this.selector ? this.selector.match(/,\s*/) : null, l = s ? s[0] : "," + this.raw("between", "beforeOpen");
+    this.selector = t.join(l);
+  }
+  constructor(t) {
+    super(t), this.type = "rule", this.nodes || (this.nodes = []);
+  }
+}
+var u = e;
+e.default = e;
+r.registerRule(e);
+export {
+  u as r
+};

package/dist/node_modules/postcss/lib/stringifier.js

@@ -0,0 +1,192 @@
+const u = {
+  after: `
+`,
+  beforeClose: `
+`,
+  beforeComment: `
+`,
+  beforeDecl: `
+`,
+  beforeOpen: " ",
+  beforeRule: `
+`,
+  colon: ": ",
+  commentLeft: " ",
+  commentRight: " ",
+  emptyBody: "",
+  indent: "    ",
+  semicolon: !1
+};
+function o(s) {
+  return s[0].toUpperCase() + s.slice(1);
+}
+class n {
+  constructor(e) {
+    this.builder = e;
+  }
+  atrule(e, t) {
+    let r = "@" + e.name, l = e.params ? this.rawValue(e, "params") : "";
+    if (typeof e.raws.afterName < "u" ? r += e.raws.afterName : l && (r += " "), e.nodes)
+      this.block(e, r + l);
+    else {
+      let a = (e.raws.between || "") + (t ? ";" : "");
+      this.builder(r + l + a, e);
+    }
+  }
+  beforeAfter(e, t) {
+    let r;
+    e.type === "decl" ? r = this.raw(e, null, "beforeDecl") : e.type === "comment" ? r = this.raw(e, null, "beforeComment") : t === "before" ? r = this.raw(e, null, "beforeRule") : r = this.raw(e, null, "beforeClose");
+    let l = e.parent, a = 0;
+    for (; l && l.type !== "root"; )
+      a += 1, l = l.parent;
+    if (r.includes(`
+`)) {
+      let f = this.raw(e, null, "indent");
+      if (f.length)
+        for (let i = 0; i < a; i++) r += f;
+    }
+    return r;
+  }
+  block(e, t) {
+    let r = this.raw(e, "between", "beforeOpen");
+    this.builder(t + r + "{", e, "start");
+    let l;
+    e.nodes && e.nodes.length ? (this.body(e), l = this.raw(e, "after")) : l = this.raw(e, "after", "emptyBody"), l && this.builder(l), this.builder("}", e, "end");
+  }
+  body(e) {
+    let t = e.nodes.length - 1;
+    for (; t > 0 && e.nodes[t].type === "comment"; )
+      t -= 1;
+    let r = this.raw(e, "semicolon");
+    for (let l = 0; l < e.nodes.length; l++) {
+      let a = e.nodes[l], f = this.raw(a, "before");
+      f && this.builder(f), this.stringify(a, t !== l || r);
+    }
+  }
+  comment(e) {
+    let t = this.raw(e, "left", "commentLeft"), r = this.raw(e, "right", "commentRight");
+    this.builder("/*" + t + e.text + r + "*/", e);
+  }
+  decl(e, t) {
+    let r = this.raw(e, "between", "colon"), l = e.prop + r + this.rawValue(e, "value");
+    e.important && (l += e.raws.important || " !important"), t && (l += ";"), this.builder(l, e);
+  }
+  document(e) {
+    this.body(e);
+  }
+  raw(e, t, r) {
+    let l;
+    if (r || (r = t), t && (l = e.raws[t], typeof l < "u"))
+      return l;
+    let a = e.parent;
+    if (r === "before" && (!a || a.type === "root" && a.first === e || a && a.type === "document"))
+      return "";
+    if (!a) return u[r];
+    let f = e.root();
+    if (f.rawCache || (f.rawCache = {}), typeof f.rawCache[r] < "u")
+      return f.rawCache[r];
+    if (r === "before" || r === "after")
+      return this.beforeAfter(e, r);
+    {
+      let i = "raw" + o(r);
+      this[i] ? l = this[i](f, e) : f.walk((w) => {
+        if (l = w.raws[t], typeof l < "u") return !1;
+      });
+    }
+    return typeof l > "u" && (l = u[r]), f.rawCache[r] = l, l;
+  }
+  rawBeforeClose(e) {
+    let t;
+    return e.walk((r) => {
+      if (r.nodes && r.nodes.length > 0 && typeof r.raws.after < "u")
+        return t = r.raws.after, t.includes(`
+`) && (t = t.replace(/[^\n]+$/, "")), !1;
+    }), t && (t = t.replace(/\S/g, "")), t;
+  }
+  rawBeforeComment(e, t) {
+    let r;
+    return e.walkComments((l) => {
+      if (typeof l.raws.before < "u")
+        return r = l.raws.before, r.includes(`
+`) && (r = r.replace(/[^\n]+$/, "")), !1;
+    }), typeof r > "u" ? r = this.raw(t, null, "beforeDecl") : r && (r = r.replace(/\S/g, "")), r;
+  }
+  rawBeforeDecl(e, t) {
+    let r;
+    return e.walkDecls((l) => {
+      if (typeof l.raws.before < "u")
+        return r = l.raws.before, r.includes(`
+`) && (r = r.replace(/[^\n]+$/, "")), !1;
+    }), typeof r > "u" ? r = this.raw(t, null, "beforeRule") : r && (r = r.replace(/\S/g, "")), r;
+  }
+  rawBeforeOpen(e) {
+    let t;
+    return e.walk((r) => {
+      if (r.type !== "decl" && (t = r.raws.between, typeof t < "u"))
+        return !1;
+    }), t;
+  }
+  rawBeforeRule(e) {
+    let t;
+    return e.walk((r) => {
+      if (r.nodes && (r.parent !== e || e.first !== r) && typeof r.raws.before < "u")
+        return t = r.raws.before, t.includes(`
+`) && (t = t.replace(/[^\n]+$/, "")), !1;
+    }), t && (t = t.replace(/\S/g, "")), t;
+  }
+  rawColon(e) {
+    let t;
+    return e.walkDecls((r) => {
+      if (typeof r.raws.between < "u")
+        return t = r.raws.between.replace(/[^\s:]/g, ""), !1;
+    }), t;
+  }
+  rawEmptyBody(e) {
+    let t;
+    return e.walk((r) => {
+      if (r.nodes && r.nodes.length === 0 && (t = r.raws.after, typeof t < "u"))
+        return !1;
+    }), t;
+  }
+  rawIndent(e) {
+    if (e.raws.indent) return e.raws.indent;
+    let t;
+    return e.walk((r) => {
+      let l = r.parent;
+      if (l && l !== e && l.parent && l.parent === e && typeof r.raws.before < "u") {
+        let a = r.raws.before.split(`
+`);
+        return t = a[a.length - 1], t = t.replace(/\S/g, ""), !1;
+      }
+    }), t;
+  }
+  rawSemicolon(e) {
+    let t;
+    return e.walk((r) => {
+      if (r.nodes && r.nodes.length && r.last.type === "decl" && (t = r.raws.semicolon, typeof t < "u"))
+        return !1;
+    }), t;
+  }
+  rawValue(e, t) {
+    let r = e[t], l = e.raws[t];
+    return l && l.value === r ? l.raw : r;
+  }
+  root(e) {
+    this.body(e), e.raws.after && this.builder(e.raws.after);
+  }
+  rule(e) {
+    this.block(e, this.rawValue(e, "selector")), e.raws.ownSemicolon && this.builder(e.raws.ownSemicolon, e, "end");
+  }
+  stringify(e, t) {
+    if (!this[e.type])
+      throw new Error(
+        "Unknown AST node type " + e.type + ". Maybe you need to change PostCSS stringifier."
+      );
+    this[e.type](e, t);
+  }
+}
+var p = n;
+n.default = n;
+export {
+  p as s
+};

package/dist/node_modules/postcss/lib/stringify.js

@@ -0,0 +1,10 @@
+import { s } from "./stringifier.js";
+let f = s;
+function i(r, t) {
+  new f(t).stringify(r);
+}
+var g = i;
+i.default = i;
+export {
+  g as s
+};

package/dist/node_modules/postcss/lib/symbols.js

@@ -0,0 +1,6 @@
+import { __exports as m } from "../../../_virtual/symbols.js";
+m.isClean = Symbol("isClean");
+m.my = Symbol("my");
+export {
+  m as default
+};

package/dist/node_modules/postcss/lib/tokenize.js

@@ -0,0 +1,109 @@
+const l = /[\t\n\f\r "#'()/;[\\\]{}]/g, d = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g, B = /.[\r\n"'(/\\]/, u = /[\da-f]/i;
+var x = function(L, U = {}) {
+  let c = L.css.valueOf(), i = U.ignoreErrors, o, S, A, e, N, s, r, E, n, _, R = c.length, t = 0, h = [], C = [];
+  function I() {
+    return t;
+  }
+  function f(a) {
+    throw L.error("Unclosed " + a, t);
+  }
+  function P() {
+    return C.length === 0 && t >= R;
+  }
+  function g(a) {
+    if (C.length) return C.pop();
+    if (t >= R) return;
+    let O = a ? a.ignoreUnclosed : !1;
+    switch (o = c.charCodeAt(t), o) {
+      case 10:
+      case 32:
+      case 9:
+      case 13:
+      case 12: {
+        e = t;
+        do
+          e += 1, o = c.charCodeAt(e);
+        while (o === 32 || o === 10 || o === 9 || o === 13 || o === 12);
+        s = ["space", c.slice(t, e)], t = e - 1;
+        break;
+      }
+      case 91:
+      case 93:
+      case 123:
+      case 125:
+      case 58:
+      case 59:
+      case 41: {
+        let T = String.fromCharCode(o);
+        s = [T, T, t];
+        break;
+      }
+      case 40: {
+        if (_ = h.length ? h.pop()[1] : "", n = c.charCodeAt(t + 1), _ === "url" && n !== 39 && n !== 34 && n !== 32 && n !== 10 && n !== 9 && n !== 12 && n !== 13) {
+          e = t;
+          do {
+            if (r = !1, e = c.indexOf(")", e + 1), e === -1)
+              if (i || O) {
+                e = t;
+                break;
+              } else
+                f("bracket");
+            for (E = e; c.charCodeAt(E - 1) === 92; )
+              E -= 1, r = !r;
+          } while (r);
+          s = ["brackets", c.slice(t, e + 1), t, e], t = e;
+        } else
+          e = c.indexOf(")", t + 1), S = c.slice(t, e + 1), e === -1 || B.test(S) ? s = ["(", "(", t] : (s = ["brackets", S, t, e], t = e);
+        break;
+      }
+      case 39:
+      case 34: {
+        N = o === 39 ? "'" : '"', e = t;
+        do {
+          if (r = !1, e = c.indexOf(N, e + 1), e === -1)
+            if (i || O) {
+              e = t + 1;
+              break;
+            } else
+              f("string");
+          for (E = e; c.charCodeAt(E - 1) === 92; )
+            E -= 1, r = !r;
+        } while (r);
+        s = ["string", c.slice(t, e + 1), t, e], t = e;
+        break;
+      }
+      case 64: {
+        l.lastIndex = t + 1, l.test(c), l.lastIndex === 0 ? e = c.length - 1 : e = l.lastIndex - 2, s = ["at-word", c.slice(t, e + 1), t, e], t = e;
+        break;
+      }
+      case 92: {
+        for (e = t, A = !0; c.charCodeAt(e + 1) === 92; )
+          e += 1, A = !A;
+        if (o = c.charCodeAt(e + 1), A && o !== 47 && o !== 32 && o !== 10 && o !== 9 && o !== 13 && o !== 12 && (e += 1, u.test(c.charAt(e)))) {
+          for (; u.test(c.charAt(e + 1)); )
+            e += 1;
+          c.charCodeAt(e + 1) === 32 && (e += 1);
+        }
+        s = ["word", c.slice(t, e + 1), t, e], t = e;
+        break;
+      }
+      default: {
+        o === 47 && c.charCodeAt(t + 1) === 42 ? (e = c.indexOf("*/", t + 2) + 1, e === 0 && (i || O ? e = c.length : f("comment")), s = ["comment", c.slice(t, e + 1), t, e], t = e) : (d.lastIndex = t + 1, d.test(c), d.lastIndex === 0 ? e = c.length - 1 : e = d.lastIndex - 2, s = ["word", c.slice(t, e + 1), t, e], h.push(s), t = e);
+        break;
+      }
+    }
+    return t++, s;
+  }
+  function k(a) {
+    C.push(a);
+  }
+  return {
+    back: k,
+    endOfFile: P,
+    nextToken: g,
+    position: I
+  };
+};
+export {
+  x as t
+};

package/dist/node_modules/postcss/lib/warn-once.js

@@ -0,0 +1,7 @@
+let r = {};
+var o = function(n) {
+  r[n] || (r[n] = !0, typeof console < "u" && console.warn && console.warn(n));
+};
+export {
+  o as w
+};

package/dist/node_modules/postcss/lib/warning.js

@@ -0,0 +1,21 @@
+class i {
+  constructor(e, t = {}) {
+    if (this.type = "warning", this.text = e, t.node && t.node.source) {
+      let n = t.node.rangeBy(t);
+      this.line = n.start.line, this.column = n.start.column, this.endLine = n.end.line, this.endColumn = n.end.column;
+    }
+    for (let n in t) this[n] = t[n];
+  }
+  toString() {
+    return this.node ? this.node.error(this.text, {
+      index: this.index,
+      plugin: this.plugin,
+      word: this.word
+    }).message : this.plugin ? this.plugin + ": " + this.text : this.text;
+  }
+}
+var s = i;
+i.default = i;
+export {
+  s as w
+};

package/dist/node_modules/postcss-prefix-selector/index.js

@@ -0,0 +1,32 @@
+import { getDefaultExportFromCjs as m } from "../../_virtual/_commonjsHelpers.js";
+var p = function(e) {
+  const r = e.prefix, f = /\s+$/.test(r) ? r : `${r} `, c = e.ignoreFiles ? [].concat(e.ignoreFiles) : [], u = e.includeFiles ? [].concat(e.includeFiles) : [];
+  return function(t) {
+    c.length && t.source.input.file && a(t.source.input.file, c) || u.length && t.source.input.file && !a(t.source.input.file, u) || t.walkRules((i) => {
+      const l = [
+        "keyframes",
+        "-webkit-keyframes",
+        "-moz-keyframes",
+        "-o-keyframes",
+        "-ms-keyframes"
+      ];
+      i.parent && l.includes(i.parent.name) || (i.selectors = i.selectors.map((s) => e.exclude && x(s, e.exclude) ? s : e.transform ? e.transform(
+        r,
+        s,
+        f + s,
+        t.source.input.file,
+        i
+      ) : f + s));
+    });
+  };
+};
+function a(n, e) {
+  return e.some((r) => r instanceof RegExp ? r.test(n) : n.includes(r));
+}
+function x(n, e) {
+  return e.some((r) => r instanceof RegExp ? r.test(n) : n === r);
+}
+const k = /* @__PURE__ */ m(p);
+export {
+  k as default
+};

package/dist/node_modules/postcss-urlrebase/index.js

@@ -0,0 +1,28 @@
+import { getDefaultExportFromCjs as p } from "../../_virtual/_commonjsHelpers.js";
+import { __module as e } from "../../_virtual/index2.js";
+import { l as c } from "../postcss-value-parser/lib/index.js";
+const n = c;
+e.exports = (r) => {
+  const i = Object.assign({
+    skipHostRelativeUrls: !0
+  }, r);
+  return {
+    postcssPlugin: "rebaseUrl",
+    Declaration(t) {
+      const a = n(t.value);
+      let l = !1;
+      a.walk((s) => {
+        if (s.type !== "function" || s.value !== "url")
+          return;
+        const o = s.nodes[0].value, u = new URL(o, r.rootUrl);
+        return u.pathname === o && i.skipHostRelativeUrls || (s.nodes[0].value = u.toString(), l = !0), !1;
+      }), l && (t.value = n.stringify(a));
+    }
+  };
+};
+e.exports.postcss = !0;
+var f = e.exports;
+const g = /* @__PURE__ */ p(f);
+export {
+  g as default
+};

package/dist/node_modules/postcss-value-parser/lib/index.js

@@ -0,0 +1,21 @@
+import { p as o } from "./parse.js";
+import { w as e } from "./walk.js";
+import { s as a } from "./stringify.js";
+import { __require as f } from "./unit.js";
+var p = o, i = e, s = a;
+function r(t) {
+  return this instanceof r ? (this.nodes = p(t), this) : new r(t);
+}
+r.prototype.toString = function() {
+  return Array.isArray(this.nodes) ? s(this.nodes) : "";
+};
+r.prototype.walk = function(t, n) {
+  return i(this.nodes, t, n), this;
+};
+r.unit = f();
+r.walk = i;
+r.stringify = s;
+var l = r;
+export {
+  l
+};