@blockbite/ui 1.0.0

package/dist/node_modules/postcss/lib/no-work-result.js

@@ -0,0 +1,90 @@
+import { m as l } from "./map-generator.js";
+import { p } from "./parse.js";
+import { r as c } from "./result.js";
+import { s as f } from "./stringify.js";
+import { w as g } from "./warn-once.js";
+let m = l, _ = p;
+const d = c;
+let w = f, S = g;
+class o {
+  get content() {
+    return this.result.css;
+  }
+  get css() {
+    return this.result.css;
+  }
+  get map() {
+    return this.result.map;
+  }
+  get messages() {
+    return [];
+  }
+  get opts() {
+    return this.result.opts;
+  }
+  get processor() {
+    return this.result.processor;
+  }
+  get root() {
+    if (this._root)
+      return this._root;
+    let t, r = _;
+    try {
+      t = r(this._css, this._opts);
+    } catch (s) {
+      this.error = s;
+    }
+    if (this.error)
+      throw this.error;
+    return this._root = t, t;
+  }
+  get [Symbol.toStringTag]() {
+    return "NoWorkResult";
+  }
+  constructor(t, r, s) {
+    r = r.toString(), this.stringified = !1, this._processor = t, this._css = r, this._opts = s, this._map = void 0;
+    let i, a = w;
+    this.result = new d(this._processor, i, this._opts), this.result.css = r;
+    let u = this;
+    Object.defineProperty(this.result, "root", {
+      get() {
+        return u.root;
+      }
+    });
+    let e = new m(a, i, this._opts, r);
+    if (e.isMap()) {
+      let [n, h] = e.generate();
+      n && (this.result.css = n), h && (this.result.map = h);
+    } else
+      e.clearAnnotation(), this.result.css = e.css;
+  }
+  async() {
+    return this.error ? Promise.reject(this.error) : Promise.resolve(this.result);
+  }
+  catch(t) {
+    return this.async().catch(t);
+  }
+  finally(t) {
+    return this.async().then(t, t);
+  }
+  sync() {
+    if (this.error) throw this.error;
+    return this.result;
+  }
+  then(t, r) {
+    return process.env.NODE_ENV !== "production" && ("from" in this._opts || S(
+      "Without `from` option PostCSS could generate wrong source map and will not find Browserslist config. Set it to CSS file path or to `undefined` to prevent this warning."
+    )), this.async().then(t, r);
+  }
+  toString() {
+    return this._css;
+  }
+  warnings() {
+    return [];
+  }
+}
+var W = o;
+o.default = o;
+export {
+  W as n
+};

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

@@ -0,0 +1,240 @@
+import { c as d } from "./css-syntax-error.js";
+import { s as m } from "./stringifier.js";
+import { s as p } from "./stringify.js";
+import "./symbols.js";
+import { __exports as y } from "../../../_virtual/symbols.js";
+let x = d, w = m, g = p, { isClean: a, my: O } = y;
+function c(o, e) {
+  let t = new o.constructor();
+  for (let n in o) {
+    if (!Object.prototype.hasOwnProperty.call(o, n) || n === "proxyCache") continue;
+    let i = o[n], r = typeof i;
+    n === "parent" && r === "object" ? e && (t[n] = e) : n === "source" ? t[n] = i : Array.isArray(i) ? t[n] = i.map((s) => c(s, t)) : (r === "object" && i !== null && (i = c(i)), t[n] = i);
+  }
+  return t;
+}
+function f(o, e) {
+  if (e && typeof e.offset < "u")
+    return e.offset;
+  let t = 1, n = 1, i = 0;
+  for (let r = 0; r < o.length; r++) {
+    if (n === e.line && t === e.column) {
+      i = r;
+      break;
+    }
+    o[r] === `
+` ? (t = 1, n += 1) : t += 1;
+  }
+  return i;
+}
+class h {
+  get proxyOf() {
+    return this;
+  }
+  constructor(e = {}) {
+    this.raws = {}, this[a] = !1, this[O] = !0;
+    for (let t in e)
+      if (t === "nodes") {
+        this.nodes = [];
+        for (let n of e[t])
+          typeof n.clone == "function" ? this.append(n.clone()) : this.append(n);
+      } else
+        this[t] = e[t];
+  }
+  addToError(e) {
+    if (e.postcssNode = this, e.stack && this.source && /\n\s{4}at /.test(e.stack)) {
+      let t = this.source;
+      e.stack = e.stack.replace(
+        /\n\s{4}at /,
+        `$&${t.input.from}:${t.start.line}:${t.start.column}$&`
+      );
+    }
+    return e;
+  }
+  after(e) {
+    return this.parent.insertAfter(this, e), this;
+  }
+  assign(e = {}) {
+    for (let t in e)
+      this[t] = e[t];
+    return this;
+  }
+  before(e) {
+    return this.parent.insertBefore(this, e), this;
+  }
+  cleanRaws(e) {
+    delete this.raws.before, delete this.raws.after, e || delete this.raws.between;
+  }
+  clone(e = {}) {
+    let t = c(this);
+    for (let n in e)
+      t[n] = e[n];
+    return t;
+  }
+  cloneAfter(e = {}) {
+    let t = this.clone(e);
+    return this.parent.insertAfter(this, t), t;
+  }
+  cloneBefore(e = {}) {
+    let t = this.clone(e);
+    return this.parent.insertBefore(this, t), t;
+  }
+  error(e, t = {}) {
+    if (this.source) {
+      let { end: n, start: i } = this.rangeBy(t);
+      return this.source.input.error(
+        e,
+        { column: i.column, line: i.line },
+        { column: n.column, line: n.line },
+        t
+      );
+    }
+    return new x(e);
+  }
+  getProxyProcessor() {
+    return {
+      get(e, t) {
+        return t === "proxyOf" ? e : t === "root" ? () => e.root().toProxy() : e[t];
+      },
+      set(e, t, n) {
+        return e[t] === n || (e[t] = n, (t === "prop" || t === "value" || t === "name" || t === "params" || t === "important" || /* c8 ignore next */
+        t === "text") && e.markDirty()), !0;
+      }
+    };
+  }
+  /* c8 ignore next 3 */
+  markClean() {
+    this[a] = !0;
+  }
+  markDirty() {
+    if (this[a]) {
+      this[a] = !1;
+      let e = this;
+      for (; e = e.parent; )
+        e[a] = !1;
+    }
+  }
+  next() {
+    if (!this.parent) return;
+    let e = this.parent.index(this);
+    return this.parent.nodes[e + 1];
+  }
+  positionBy(e) {
+    let t = this.source.start;
+    if (e.index)
+      t = this.positionInside(e.index);
+    else if (e.word) {
+      let n = "document" in this.source.input ? this.source.input.document : this.source.input.css, r = n.slice(
+        f(n, this.source.start),
+        f(n, this.source.end)
+      ).indexOf(e.word);
+      r !== -1 && (t = this.positionInside(r));
+    }
+    return t;
+  }
+  positionInside(e) {
+    let t = this.source.start.column, n = this.source.start.line, i = "document" in this.source.input ? this.source.input.document : this.source.input.css, r = f(i, this.source.start), s = r + e;
+    for (let l = r; l < s; l++)
+      i[l] === `
+` ? (t = 1, n += 1) : t += 1;
+    return { column: t, line: n };
+  }
+  prev() {
+    if (!this.parent) return;
+    let e = this.parent.index(this);
+    return this.parent.nodes[e - 1];
+  }
+  rangeBy(e) {
+    let t = {
+      column: this.source.start.column,
+      line: this.source.start.line
+    }, n = this.source.end ? {
+      column: this.source.end.column + 1,
+      line: this.source.end.line
+    } : {
+      column: t.column + 1,
+      line: t.line
+    };
+    if (e.word) {
+      let i = "document" in this.source.input ? this.source.input.document : this.source.input.css, s = i.slice(
+        f(i, this.source.start),
+        f(i, this.source.end)
+      ).indexOf(e.word);
+      s !== -1 && (t = this.positionInside(s), n = this.positionInside(
+        s + e.word.length
+      ));
+    } else
+      e.start ? t = {
+        column: e.start.column,
+        line: e.start.line
+      } : e.index && (t = this.positionInside(e.index)), e.end ? n = {
+        column: e.end.column,
+        line: e.end.line
+      } : typeof e.endIndex == "number" ? n = this.positionInside(e.endIndex) : e.index && (n = this.positionInside(e.index + 1));
+    return (n.line < t.line || n.line === t.line && n.column <= t.column) && (n = { column: t.column + 1, line: t.line }), { end: n, start: t };
+  }
+  raw(e, t) {
+    return new w().raw(this, e, t);
+  }
+  remove() {
+    return this.parent && this.parent.removeChild(this), this.parent = void 0, this;
+  }
+  replaceWith(...e) {
+    if (this.parent) {
+      let t = this, n = !1;
+      for (let i of e)
+        i === this ? n = !0 : n ? (this.parent.insertAfter(t, i), t = i) : this.parent.insertBefore(t, i);
+      n || this.remove();
+    }
+    return this;
+  }
+  root() {
+    let e = this;
+    for (; e.parent && e.parent.type !== "document"; )
+      e = e.parent;
+    return e;
+  }
+  toJSON(e, t) {
+    let n = {}, i = t == null;
+    t = t || /* @__PURE__ */ new Map();
+    let r = 0;
+    for (let s in this) {
+      if (!Object.prototype.hasOwnProperty.call(this, s) || s === "parent" || s === "proxyCache") continue;
+      let l = this[s];
+      if (Array.isArray(l))
+        n[s] = l.map((u) => typeof u == "object" && u.toJSON ? u.toJSON(null, t) : u);
+      else if (typeof l == "object" && l.toJSON)
+        n[s] = l.toJSON(null, t);
+      else if (s === "source") {
+        let u = t.get(l.input);
+        u == null && (u = r, t.set(l.input, r), r++), n[s] = {
+          end: l.end,
+          inputId: u,
+          start: l.start
+        };
+      } else
+        n[s] = l;
+    }
+    return i && (n.inputs = [...t.keys()].map((s) => s.toJSON())), n;
+  }
+  toProxy() {
+    return this.proxyCache || (this.proxyCache = new Proxy(this, this.getProxyProcessor())), this.proxyCache;
+  }
+  toString(e = g) {
+    e.stringify && (e = e.stringify);
+    let t = "";
+    return e(this, (n) => {
+      t += n;
+    }), t;
+  }
+  warn(e, t, n) {
+    let i = { node: this };
+    for (let r in n) i[r] = n[r];
+    return e.warn(t, i);
+  }
+}
+var P = h;
+h.default = h;
+export {
+  P as n
+};

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

@@ -0,0 +1,22 @@
+import { c as n } from "./container.js";
+import { i as o } from "./input.js";
+import { p } from "./parser.js";
+let f = n, h = o, m = p;
+function e(a, s) {
+  let i = new h(a, s), t = new m(i);
+  try {
+    t.parse();
+  } catch (r) {
+    throw process.env.NODE_ENV !== "production" && r.name === "CssSyntaxError" && s && s.from && (/\.scss$/i.test(s.from) ? r.message += `
+You tried to parse SCSS with the standard CSS parser; try again with the postcss-scss parser` : /\.sass/i.test(s.from) ? r.message += `
+You tried to parse Sass with the standard CSS parser; try again with the postcss-sass parser` : /\.less$/i.test(s.from) && (r.message += `
+You tried to parse Less with the standard CSS parser; try again with the postcss-less parser`)), r;
+  }
+  return t.root;
+}
+var l = e;
+e.default = e;
+f.registerParse(e);
+export {
+  l as p
+};

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

@@ -0,0 +1,317 @@
+import { a as g } from "./at-rule.js";
+import { c as b } from "./comment.js";
+import { d as F } from "./declaration.js";
+import { r as y } from "./root.js";
+import { r as z } from "./rule.js";
+import { t as S } from "./tokenize.js";
+let x = g, C = b, P = F, A = y, m = z, T = S;
+const w = {
+  empty: !0,
+  space: !0
+};
+function W(p) {
+  for (let e = p.length - 1; e >= 0; e--) {
+    let t = p[e], s = t[3] || t[2];
+    if (s) return s;
+  }
+}
+class v {
+  constructor(e) {
+    this.input = e, this.root = new A(), this.current = this.root, this.spaces = "", this.semicolon = !1, this.createTokenizer(), this.root.source = { input: e, start: { column: 1, line: 1, offset: 0 } };
+  }
+  atrule(e) {
+    let t = new x();
+    t.name = e[1].slice(1), t.name === "" && this.unnamedAtrule(t, e), this.init(t, e[2]);
+    let s, i, r, o = !1, h = !1, n = [], l = [];
+    for (; !this.tokenizer.endOfFile(); ) {
+      if (e = this.tokenizer.nextToken(), s = e[0], s === "(" || s === "[" ? l.push(s === "(" ? ")" : "]") : s === "{" && l.length > 0 ? l.push("}") : s === l[l.length - 1] && l.pop(), l.length === 0)
+        if (s === ";") {
+          t.source.end = this.getPosition(e[2]), t.source.end.offset++, this.semicolon = !0;
+          break;
+        } else if (s === "{") {
+          h = !0;
+          break;
+        } else if (s === "}") {
+          if (n.length > 0) {
+            for (r = n.length - 1, i = n[r]; i && i[0] === "space"; )
+              i = n[--r];
+            i && (t.source.end = this.getPosition(i[3] || i[2]), t.source.end.offset++);
+          }
+          this.end(e);
+          break;
+        } else
+          n.push(e);
+      else
+        n.push(e);
+      if (this.tokenizer.endOfFile()) {
+        o = !0;
+        break;
+      }
+    }
+    t.raws.between = this.spacesAndCommentsFromEnd(n), n.length ? (t.raws.afterName = this.spacesAndCommentsFromStart(n), this.raw(t, "params", n), o && (e = n[n.length - 1], t.source.end = this.getPosition(e[3] || e[2]), t.source.end.offset++, this.spaces = t.raws.between, t.raws.between = "")) : (t.raws.afterName = "", t.params = ""), h && (t.nodes = [], this.current = t);
+  }
+  checkMissedSemicolon(e) {
+    let t = this.colon(e);
+    if (t === !1) return;
+    let s = 0, i;
+    for (let r = t - 1; r >= 0 && (i = e[r], !(i[0] !== "space" && (s += 1, s === 2))); r--)
+      ;
+    throw this.input.error(
+      "Missed semicolon",
+      i[0] === "word" ? i[3] + 1 : i[2]
+    );
+  }
+  colon(e) {
+    let t = 0, s, i, r;
+    for (let [o, h] of e.entries()) {
+      if (i = h, r = i[0], r === "(" && (t += 1), r === ")" && (t -= 1), t === 0 && r === ":")
+        if (!s)
+          this.doubleColon(i);
+        else {
+          if (s[0] === "word" && s[1] === "progid")
+            continue;
+          return o;
+        }
+      s = i;
+    }
+    return !1;
+  }
+  comment(e) {
+    let t = new C();
+    this.init(t, e[2]), t.source.end = this.getPosition(e[3] || e[2]), t.source.end.offset++;
+    let s = e[1].slice(2, -2);
+    if (/^\s*$/.test(s))
+      t.text = "", t.raws.left = s, t.raws.right = "";
+    else {
+      let i = s.match(/^(\s*)([^]*\S)(\s*)$/);
+      t.text = i[2], t.raws.left = i[1], t.raws.right = i[3];
+    }
+  }
+  createTokenizer() {
+    this.tokenizer = T(this.input);
+  }
+  decl(e, t) {
+    let s = new P();
+    this.init(s, e[0][2]);
+    let i = e[e.length - 1];
+    for (i[0] === ";" && (this.semicolon = !0, e.pop()), s.source.end = this.getPosition(
+      i[3] || i[2] || W(e)
+    ), s.source.end.offset++; e[0][0] !== "word"; )
+      e.length === 1 && this.unknownWord(e), s.raws.before += e.shift()[1];
+    for (s.source.start = this.getPosition(e[0][2]), s.prop = ""; e.length; ) {
+      let l = e[0][0];
+      if (l === ":" || l === "space" || l === "comment")
+        break;
+      s.prop += e.shift()[1];
+    }
+    s.raws.between = "";
+    let r;
+    for (; e.length; )
+      if (r = e.shift(), r[0] === ":") {
+        s.raws.between += r[1];
+        break;
+      } else
+        r[0] === "word" && /\w/.test(r[1]) && this.unknownWord([r]), s.raws.between += r[1];
+    (s.prop[0] === "_" || s.prop[0] === "*") && (s.raws.before += s.prop[0], s.prop = s.prop.slice(1));
+    let o = [], h;
+    for (; e.length && (h = e[0][0], !(h !== "space" && h !== "comment")); )
+      o.push(e.shift());
+    this.precheckMissedSemicolon(e);
+    for (let l = e.length - 1; l >= 0; l--) {
+      if (r = e[l], r[1].toLowerCase() === "!important") {
+        s.important = !0;
+        let c = this.stringFrom(e, l);
+        c = this.spacesFromEnd(e) + c, c !== " !important" && (s.raws.important = c);
+        break;
+      } else if (r[1].toLowerCase() === "important") {
+        let c = e.slice(0), f = "";
+        for (let a = l; a > 0; a--) {
+          let u = c[a][0];
+          if (f.trim().startsWith("!") && u !== "space")
+            break;
+          f = c.pop()[1] + f;
+        }
+        f.trim().startsWith("!") && (s.important = !0, s.raws.important = f, e = c);
+      }
+      if (r[0] !== "space" && r[0] !== "comment")
+        break;
+    }
+    e.some((l) => l[0] !== "space" && l[0] !== "comment") && (s.raws.between += o.map((l) => l[1]).join(""), o = []), this.raw(s, "value", o.concat(e), t), s.value.includes(":") && !t && this.checkMissedSemicolon(e);
+  }
+  doubleColon(e) {
+    throw this.input.error(
+      "Double colon",
+      { offset: e[2] },
+      { offset: e[2] + e[1].length }
+    );
+  }
+  emptyRule(e) {
+    let t = new m();
+    this.init(t, e[2]), t.selector = "", t.raws.between = "", this.current = t;
+  }
+  end(e) {
+    this.current.nodes && this.current.nodes.length && (this.current.raws.semicolon = this.semicolon), this.semicolon = !1, this.current.raws.after = (this.current.raws.after || "") + this.spaces, this.spaces = "", this.current.parent ? (this.current.source.end = this.getPosition(e[2]), this.current.source.end.offset++, this.current = this.current.parent) : this.unexpectedClose(e);
+  }
+  endFile() {
+    this.current.parent && this.unclosedBlock(), this.current.nodes && this.current.nodes.length && (this.current.raws.semicolon = this.semicolon), this.current.raws.after = (this.current.raws.after || "") + this.spaces, this.root.source.end = this.getPosition(this.tokenizer.position());
+  }
+  freeSemicolon(e) {
+    if (this.spaces += e[1], this.current.nodes) {
+      let t = this.current.nodes[this.current.nodes.length - 1];
+      t && t.type === "rule" && !t.raws.ownSemicolon && (t.raws.ownSemicolon = this.spaces, this.spaces = "", t.source.end = this.getPosition(e[2]), t.source.end.offset += t.raws.ownSemicolon.length);
+    }
+  }
+  // Helpers
+  getPosition(e) {
+    let t = this.input.fromOffset(e);
+    return {
+      column: t.col,
+      line: t.line,
+      offset: e
+    };
+  }
+  init(e, t) {
+    this.current.push(e), e.source = {
+      input: this.input,
+      start: this.getPosition(t)
+    }, e.raws.before = this.spaces, this.spaces = "", e.type !== "comment" && (this.semicolon = !1);
+  }
+  other(e) {
+    let t = !1, s = null, i = !1, r = null, o = [], h = e[1].startsWith("--"), n = [], l = e;
+    for (; l; ) {
+      if (s = l[0], n.push(l), s === "(" || s === "[")
+        r || (r = l), o.push(s === "(" ? ")" : "]");
+      else if (h && i && s === "{")
+        r || (r = l), o.push("}");
+      else if (o.length === 0)
+        if (s === ";")
+          if (i) {
+            this.decl(n, h);
+            return;
+          } else
+            break;
+        else if (s === "{") {
+          this.rule(n);
+          return;
+        } else if (s === "}") {
+          this.tokenizer.back(n.pop()), t = !0;
+          break;
+        } else s === ":" && (i = !0);
+      else s === o[o.length - 1] && (o.pop(), o.length === 0 && (r = null));
+      l = this.tokenizer.nextToken();
+    }
+    if (this.tokenizer.endOfFile() && (t = !0), o.length > 0 && this.unclosedBracket(r), t && i) {
+      if (!h)
+        for (; n.length && (l = n[n.length - 1][0], !(l !== "space" && l !== "comment")); )
+          this.tokenizer.back(n.pop());
+      this.decl(n, h);
+    } else
+      this.unknownWord(n);
+  }
+  parse() {
+    let e;
+    for (; !this.tokenizer.endOfFile(); )
+      switch (e = this.tokenizer.nextToken(), e[0]) {
+        case "space":
+          this.spaces += e[1];
+          break;
+        case ";":
+          this.freeSemicolon(e);
+          break;
+        case "}":
+          this.end(e);
+          break;
+        case "comment":
+          this.comment(e);
+          break;
+        case "at-word":
+          this.atrule(e);
+          break;
+        case "{":
+          this.emptyRule(e);
+          break;
+        default:
+          this.other(e);
+          break;
+      }
+    this.endFile();
+  }
+  precheckMissedSemicolon() {
+  }
+  raw(e, t, s, i) {
+    let r, o, h = s.length, n = "", l = !0, c, f;
+    for (let a = 0; a < h; a += 1)
+      r = s[a], o = r[0], o === "space" && a === h - 1 && !i ? l = !1 : o === "comment" ? (f = s[a - 1] ? s[a - 1][0] : "empty", c = s[a + 1] ? s[a + 1][0] : "empty", !w[f] && !w[c] ? n.slice(-1) === "," ? l = !1 : n += r[1] : l = !1) : n += r[1];
+    if (!l) {
+      let a = s.reduce((u, d) => u + d[1], "");
+      e.raws[t] = { raw: a, value: n };
+    }
+    e[t] = n;
+  }
+  rule(e) {
+    e.pop();
+    let t = new m();
+    this.init(t, e[0][2]), t.raws.between = this.spacesAndCommentsFromEnd(e), this.raw(t, "selector", e), this.current = t;
+  }
+  spacesAndCommentsFromEnd(e) {
+    let t, s = "";
+    for (; e.length && (t = e[e.length - 1][0], !(t !== "space" && t !== "comment")); )
+      s = e.pop()[1] + s;
+    return s;
+  }
+  // Errors
+  spacesAndCommentsFromStart(e) {
+    let t, s = "";
+    for (; e.length && (t = e[0][0], !(t !== "space" && t !== "comment")); )
+      s += e.shift()[1];
+    return s;
+  }
+  spacesFromEnd(e) {
+    let t, s = "";
+    for (; e.length && (t = e[e.length - 1][0], t === "space"); )
+      s = e.pop()[1] + s;
+    return s;
+  }
+  stringFrom(e, t) {
+    let s = "";
+    for (let i = t; i < e.length; i++)
+      s += e[i][1];
+    return e.splice(t, e.length - t), s;
+  }
+  unclosedBlock() {
+    let e = this.current.source.start;
+    throw this.input.error("Unclosed block", e.line, e.column);
+  }
+  unclosedBracket(e) {
+    throw this.input.error(
+      "Unclosed bracket",
+      { offset: e[2] },
+      { offset: e[2] + 1 }
+    );
+  }
+  unexpectedClose(e) {
+    throw this.input.error(
+      "Unexpected }",
+      { offset: e[2] },
+      { offset: e[2] + 1 }
+    );
+  }
+  unknownWord(e) {
+    throw this.input.error(
+      "Unknown word " + e[0][1],
+      { offset: e[0][2] },
+      { offset: e[0][2] + e[0][1].length }
+    );
+  }
+  unnamedAtrule(e, t) {
+    throw this.input.error(
+      "At-rule without name",
+      { offset: t[2] },
+      { offset: t[2] + t[1].length }
+    );
+  }
+}
+var U = v;
+export {
+  U as p
+};