@blockbite/ui 1.0.4 → 2.0.0

package/dist/node_modules/memize/dist/index.js

@@ -0,0 +1,34 @@
+function g(f, a) {
+  var u = 0, n, t;
+  a = a || {};
+  function v() {
+    var e = n, i = arguments.length, l, r;
+    e: for (; e; ) {
+      if (e.args.length !== arguments.length) {
+        e = e.next;
+        continue;
+      }
+      for (r = 0; r < i; r++)
+        if (e.args[r] !== arguments[r]) {
+          e = e.next;
+          continue e;
+        }
+      return e !== n && (e === t && (t = e.prev), e.prev.next = e.next, e.next && (e.next.prev = e.prev), e.next = n, e.prev = null, n.prev = e, n = e), e.val;
+    }
+    for (l = new Array(i), r = 0; r < i; r++)
+      l[r] = arguments[r];
+    return e = {
+      args: l,
+      // Generate the result from original function
+      val: f.apply(null, l)
+    }, n ? (n.prev = e, e.next = n) : t = e, u === /** @type {MemizeOptions} */
+    a.maxSize ? (t = /** @type {MemizeCacheNode} */
+    t.prev, t.next = null) : u++, n = e, e.val;
+  }
+  return v.clear = function() {
+    n = null, t = null, u = 0;
+  }, v;
+}
+export {
+  g as default
+};

package/dist/node_modules/nanoid/non-secure/index.js

@@ -0,0 +1,10 @@
+let n = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict", r = (t = 21) => {
+  let e = "", l = t | 0;
+  for (; l--; )
+    e += n[Math.random() * 64 | 0];
+  return e;
+};
+var a = { nanoid: r };
+export {
+  a as n
+};

package/dist/node_modules/no-case/dist.es2015/index.js

@@ -0,0 +1,18 @@
+import { lowerCase as A } from "../../lower-case/dist.es2015/index.js";
+var R = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g], _ = /[^A-Z0-9]+/gi;
+function o(a, e) {
+  e === void 0 && (e = {});
+  for (var r = e.splitRegexp, l = r === void 0 ? R : r, i = e.stripRegexp, f = i === void 0 ? _ : i, d = e.transform, g = d === void 0 ? A : d, p = e.delimiter, s = p === void 0 ? " " : p, t = v(v(a, l, "$1\0$2"), f, "\0"), c = 0, n = t.length; t.charAt(c) === "\0"; )
+    c++;
+  for (; t.charAt(n - 1) === "\0"; )
+    n--;
+  return t.slice(c, n).split("\0").map(g).join(s);
+}
+function v(a, e, r) {
+  return e instanceof RegExp ? a.replace(e, r) : e.reduce(function(l, i) {
+    return l.replace(i, r);
+  }, a);
+}
+export {
+  o as noCase
+};

package/dist/node_modules/object-assign/index.js

@@ -0,0 +1,54 @@
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var f, i;
+function p() {
+  if (i) return f;
+  i = 1;
+  var u = Object.getOwnPropertySymbols, b = Object.prototype.hasOwnProperty, l = Object.prototype.propertyIsEnumerable;
+  function O(n) {
+    if (n == null)
+      throw new TypeError("Object.assign cannot be called with null or undefined");
+    return Object(n);
+  }
+  function j() {
+    try {
+      if (!Object.assign)
+        return !1;
+      var n = new String("abc");
+      if (n[5] = "de", Object.getOwnPropertyNames(n)[0] === "5")
+        return !1;
+      for (var s = {}, r = 0; r < 10; r++)
+        s["_" + String.fromCharCode(r)] = r;
+      var a = Object.getOwnPropertyNames(s).map(function(e) {
+        return s[e];
+      });
+      if (a.join("") !== "0123456789")
+        return !1;
+      var t = {};
+      return "abcdefghijklmnopqrst".split("").forEach(function(e) {
+        t[e] = e;
+      }), Object.keys(Object.assign({}, t)).join("") === "abcdefghijklmnopqrst";
+    } catch {
+      return !1;
+    }
+  }
+  return f = j() ? Object.assign : function(n, s) {
+    for (var r, a = O(n), t, e = 1; e < arguments.length; e++) {
+      r = Object(arguments[e]);
+      for (var c in r)
+        b.call(r, c) && (a[c] = r[c]);
+      if (u) {
+        t = u(r);
+        for (var o = 0; o < t.length; o++)
+          l.call(r, t[o]) && (a[t[o]] = r[t[o]]);
+      }
+    }
+    return a;
+  }, f;
+}
+export {
+  p as __require
+};

package/dist/node_modules/param-case/dist.es2015/index.js

@@ -0,0 +1,8 @@
+import { __assign as i } from "../../tslib/tslib.es6.js";
+import { dotCase as m } from "../../dot-case/dist.es2015/index.js";
+function f(e, r) {
+  return r === void 0 && (r = {}), m(e, i({ delimiter: "-" }, r));
+}
+export {
+  f as paramCase
+};

package/dist/node_modules/parsel-js/dist/parsel.js

@@ -0,0 +1,128 @@
+const g = {
+  attribute: /\[\s*(?:(?<namespace>\*|[-\w\P{ASCII}]*)\|)?(?<name>[-\w\P{ASCII}]+)\s*(?:(?<operator>\W?=)\s*(?<value>.+?)\s*(\s(?<caseSensitive>[iIsS]))?\s*)?\]/gu,
+  id: /#(?<name>[-\w\P{ASCII}]+)/gu,
+  class: /\.(?<name>[-\w\P{ASCII}]+)/gu,
+  comma: /\s*,\s*/g,
+  combinator: /\s*[\s>+~]\s*/g,
+  "pseudo-element": /::(?<name>[-\w\P{ASCII}]+)(?:\((?<argument>¶*)\))?/gu,
+  "pseudo-class": /:(?<name>[-\w\P{ASCII}]+)(?:\((?<argument>¶*)\))?/gu,
+  universal: /(?:(?<namespace>\*|[-\w\P{ASCII}]*)\|)?\*/gu,
+  type: /(?:(?<namespace>\*|[-\w\P{ASCII}]*)\|)?(?<name>[-\w\P{ASCII}]+)/gu
+  // this must be last
+}, w = /* @__PURE__ */ new Set(["combinator", "comma"]), I = (n) => {
+  switch (n) {
+    case "pseudo-element":
+    case "pseudo-class":
+      return new RegExp(g[n].source.replace("(?<argument>¶*)", "(?<argument>.*)"), "gu");
+    default:
+      return g[n];
+  }
+};
+function b(n, u) {
+  let c = 0, r = "";
+  for (; u < n.length; u++) {
+    const o = n[u];
+    switch (o) {
+      case "(":
+        ++c;
+        break;
+      case ")":
+        --c;
+        break;
+    }
+    if (r += o, c === 0)
+      return r;
+  }
+  return r;
+}
+function S(n, u = g) {
+  if (!n)
+    return [];
+  const c = [n];
+  for (const [o, t] of Object.entries(u))
+    for (let e = 0; e < c.length; e++) {
+      const s = c[e];
+      if (typeof s != "string")
+        continue;
+      t.lastIndex = 0;
+      const a = t.exec(s);
+      if (!a)
+        continue;
+      const p = a.index - 1, i = [], m = a[0], h = s.slice(0, p + 1);
+      h && i.push(h), i.push({
+        ...a.groups,
+        type: o,
+        content: m
+      });
+      const l = s.slice(p + m.length + 1);
+      l && i.push(l), c.splice(e, 1, ...i);
+    }
+  let r = 0;
+  for (const o of c)
+    switch (typeof o) {
+      case "string":
+        throw new Error(`Unexpected sequence ${o} found at index ${r}`);
+      case "object":
+        r += o.content.length, o.pos = [r - o.content.length, r], w.has(o.type) && (o.content = o.content.trim() || " ");
+        break;
+    }
+  return c;
+}
+const k = /(['"])([^\\\n]+?)\1/g, A = /\\./g;
+function y(n, u = g) {
+  if (n = n.trim(), n === "")
+    return [];
+  const c = [];
+  n = n.replace(A, (t, e) => (c.push({ value: t, offset: e }), "".repeat(t.length))), n = n.replace(k, (t, e, s, a) => (c.push({ value: t, offset: a }), `${e}${"".repeat(s.length)}${e}`));
+  {
+    let t = 0, e;
+    for (; (e = n.indexOf("(", t)) > -1; ) {
+      const s = b(n, e);
+      c.push({ value: s, offset: e }), n = `${n.substring(0, e)}(${"¶".repeat(s.length - 2)})${n.substring(e + s.length)}`, t = e + s.length;
+    }
+  }
+  const r = S(n, u), o = /* @__PURE__ */ new Set();
+  for (const t of c.reverse())
+    for (const e of r) {
+      const { offset: s, value: a } = t;
+      if (!(e.pos[0] <= s && s + a.length <= e.pos[1]))
+        continue;
+      const { content: p } = e, i = s - e.pos[0];
+      e.content = p.slice(0, i) + a + p.slice(i + a.length), e.content !== p && o.add(e);
+    }
+  for (const t of o) {
+    const e = I(t.type);
+    if (!e)
+      throw new Error(`Unknown token type: ${t.type}`);
+    e.lastIndex = 0;
+    const s = e.exec(t.content);
+    if (!s)
+      throw new Error(`Unable to parse content for ${t.type}: ${t.content}`);
+    Object.assign(t, s.groups);
+  }
+  return r;
+}
+function f(n) {
+  if (Array.isArray(n))
+    return n.map((u) => u.content).join("");
+  switch (n.type) {
+    case "list":
+      return n.list.map(f).join(",");
+    case "relative":
+      return n.combinator + f(n.right);
+    case "complex":
+      return f(n.left) + n.combinator + f(n.right);
+    case "compound":
+      return n.list.map(f).join("");
+    default:
+      return n.content;
+  }
+}
+export {
+  g as TOKENS,
+  w as TRIM_TOKENS,
+  b as gobbleParens,
+  f as stringify,
+  y as tokenize,
+  S as tokenizeBy
+};

package/dist/node_modules/pascal-case/dist.es2015/index.js

@@ -0,0 +1,13 @@
+import { __assign as t } from "../../tslib/tslib.es6.js";
+import { noCase as o } from "../../no-case/dist.es2015/index.js";
+function f(a, r) {
+  var e = a.charAt(0), s = a.substr(1).toLowerCase();
+  return r > 0 && e >= "0" && e <= "9" ? "_" + e + s : "" + e.toUpperCase() + s;
+}
+function m(a, r) {
+  return r === void 0 && (r = {}), o(a, t({ delimiter: "", transform: f }, r));
+}
+export {
+  m as pascalCase,
+  f as pascalCaseTransform
+};

package/dist/node_modules/picocolors/picocolors.browser.js

@@ -0,0 +1,10 @@
+import { __module as e } from "../../_virtual/picocolors.browser.js";
+var r = String, g = function() {
+  return { isColorSupported: !1, reset: r, bold: r, dim: r, italic: r, underline: r, inverse: r, hidden: r, strikethrough: r, black: r, red: r, green: r, yellow: r, blue: r, magenta: r, cyan: r, white: r, gray: r, bgBlack: r, bgRed: r, bgGreen: r, bgYellow: r, bgBlue: r, bgMagenta: r, bgCyan: r, bgWhite: r, blackBright: r, redBright: r, greenBright: r, yellowBright: r, blueBright: r, magentaBright: r, cyanBright: r, whiteBright: r, bgBlackBright: r, bgRedBright: r, bgGreenBright: r, bgYellowBright: r, bgBlueBright: r, bgMagentaBright: r, bgCyanBright: r, bgWhiteBright: r };
+};
+e.exports = g();
+e.exports.createColors = g;
+var i = e.exports;
+export {
+  i as p
+};

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

@@ -0,0 +1,19 @@
+import { c as s } from "./container.js";
+let t = s;
+class r extends t {
+  constructor(e) {
+    super(e), this.type = "atrule";
+  }
+  append(...e) {
+    return this.proxyOf.nodes || (this.nodes = []), super.append(...e);
+  }
+  prepend(...e) {
+    return this.proxyOf.nodes || (this.nodes = []), super.prepend(...e);
+  }
+}
+var o = r;
+r.default = r;
+t.registerAtRule(r);
+export {
+  o as a
+};

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

@@ -0,0 +1,12 @@
+import { n as o } from "./node.js";
+let m = o;
+class e extends m {
+  constructor(t) {
+    super(t), this.type = "comment";
+  }
+}
+var r = e;
+e.default = e;
+export {
+  r as c
+};

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

@@ -0,0 +1,225 @@
+import { c as g } from "./comment.js";
+import { d as v } from "./declaration.js";
+import { n as k } from "./node.js";
+import "./symbols.js";
+import { __exports as R } from "../../../_virtual/symbols.js";
+let y = g, h = v, P = k, { isClean: p, my: x } = R, a, m, d, l;
+function w(i) {
+  return i.map((e) => (e.nodes && (e.nodes = w(e.nodes)), delete e.source, e));
+}
+function O(i) {
+  if (i[p] = !1, i.proxyOf.nodes)
+    for (let e of i.proxyOf.nodes)
+      O(e);
+}
+class f extends P {
+  get first() {
+    if (this.proxyOf.nodes)
+      return this.proxyOf.nodes[0];
+  }
+  get last() {
+    if (this.proxyOf.nodes)
+      return this.proxyOf.nodes[this.proxyOf.nodes.length - 1];
+  }
+  append(...e) {
+    for (let t of e) {
+      let r = this.normalize(t, this.last);
+      for (let s of r) this.proxyOf.nodes.push(s);
+    }
+    return this.markDirty(), this;
+  }
+  cleanRaws(e) {
+    if (super.cleanRaws(e), this.nodes)
+      for (let t of this.nodes) t.cleanRaws(e);
+  }
+  each(e) {
+    if (!this.proxyOf.nodes) return;
+    let t = this.getIterator(), r, s;
+    for (; this.indexes[t] < this.proxyOf.nodes.length && (r = this.indexes[t], s = e(this.proxyOf.nodes[r], r), s !== !1); )
+      this.indexes[t] += 1;
+    return delete this.indexes[t], s;
+  }
+  every(e) {
+    return this.nodes.every(e);
+  }
+  getIterator() {
+    this.lastEach || (this.lastEach = 0), this.indexes || (this.indexes = {}), this.lastEach += 1;
+    let e = this.lastEach;
+    return this.indexes[e] = 0, e;
+  }
+  getProxyProcessor() {
+    return {
+      get(e, t) {
+        return t === "proxyOf" ? e : e[t] ? t === "each" || typeof t == "string" && t.startsWith("walk") ? (...r) => e[t](
+          ...r.map((s) => typeof s == "function" ? (n, o) => s(n.toProxy(), o) : s)
+        ) : t === "every" || t === "some" ? (r) => e[t](
+          (s, ...n) => r(s.toProxy(), ...n)
+        ) : t === "root" ? () => e.root().toProxy() : t === "nodes" ? e.nodes.map((r) => r.toProxy()) : t === "first" || t === "last" ? e[t].toProxy() : e[t] : e[t];
+      },
+      set(e, t, r) {
+        return e[t] === r || (e[t] = r, (t === "name" || t === "params" || t === "selector") && e.markDirty()), !0;
+      }
+    };
+  }
+  index(e) {
+    return typeof e == "number" ? e : (e.proxyOf && (e = e.proxyOf), this.proxyOf.nodes.indexOf(e));
+  }
+  insertAfter(e, t) {
+    let r = this.index(e), s = this.normalize(t, this.proxyOf.nodes[r]).reverse();
+    r = this.index(e);
+    for (let o of s) this.proxyOf.nodes.splice(r + 1, 0, o);
+    let n;
+    for (let o in this.indexes)
+      n = this.indexes[o], r < n && (this.indexes[o] = n + s.length);
+    return this.markDirty(), this;
+  }
+  insertBefore(e, t) {
+    let r = this.index(e), s = r === 0 ? "prepend" : !1, n = this.normalize(
+      t,
+      this.proxyOf.nodes[r],
+      s
+    ).reverse();
+    r = this.index(e);
+    for (let u of n) this.proxyOf.nodes.splice(r, 0, u);
+    let o;
+    for (let u in this.indexes)
+      o = this.indexes[u], r <= o && (this.indexes[u] = o + n.length);
+    return this.markDirty(), this;
+  }
+  normalize(e, t) {
+    if (typeof e == "string")
+      e = w(m(e).nodes);
+    else if (typeof e > "u")
+      e = [];
+    else if (Array.isArray(e)) {
+      e = e.slice(0);
+      for (let s of e)
+        s.parent && s.parent.removeChild(s, "ignore");
+    } else if (e.type === "root" && this.type !== "document") {
+      e = e.nodes.slice(0);
+      for (let s of e)
+        s.parent && s.parent.removeChild(s, "ignore");
+    } else if (e.type)
+      e = [e];
+    else if (e.prop) {
+      if (typeof e.value > "u")
+        throw new Error("Value field is missed in node creation");
+      typeof e.value != "string" && (e.value = String(e.value)), e = [new h(e)];
+    } else if (e.selector || e.selectors)
+      e = [new l(e)];
+    else if (e.name)
+      e = [new a(e)];
+    else if (e.text)
+      e = [new y(e)];
+    else
+      throw new Error("Unknown node type in node creation");
+    return e.map((s) => (s[x] || f.rebuild(s), s = s.proxyOf, s.parent && s.parent.removeChild(s), s[p] && O(s), s.raws || (s.raws = {}), typeof s.raws.before > "u" && t && typeof t.raws.before < "u" && (s.raws.before = t.raws.before.replace(/\S/g, "")), s.parent = this.proxyOf, s));
+  }
+  prepend(...e) {
+    e = e.reverse();
+    for (let t of e) {
+      let r = this.normalize(t, this.first, "prepend").reverse();
+      for (let s of r) this.proxyOf.nodes.unshift(s);
+      for (let s in this.indexes)
+        this.indexes[s] = this.indexes[s] + r.length;
+    }
+    return this.markDirty(), this;
+  }
+  push(e) {
+    return e.parent = this, this.proxyOf.nodes.push(e), this;
+  }
+  removeAll() {
+    for (let e of this.proxyOf.nodes) e.parent = void 0;
+    return this.proxyOf.nodes = [], this.markDirty(), this;
+  }
+  removeChild(e) {
+    e = this.index(e), this.proxyOf.nodes[e].parent = void 0, this.proxyOf.nodes.splice(e, 1);
+    let t;
+    for (let r in this.indexes)
+      t = this.indexes[r], t >= e && (this.indexes[r] = t - 1);
+    return this.markDirty(), this;
+  }
+  replaceValues(e, t, r) {
+    return r || (r = t, t = {}), this.walkDecls((s) => {
+      t.props && !t.props.includes(s.prop) || t.fast && !s.value.includes(t.fast) || (s.value = s.value.replace(e, r));
+    }), this.markDirty(), this;
+  }
+  some(e) {
+    return this.nodes.some(e);
+  }
+  walk(e) {
+    return this.each((t, r) => {
+      let s;
+      try {
+        s = e(t, r);
+      } catch (n) {
+        throw t.addToError(n);
+      }
+      return s !== !1 && t.walk && (s = t.walk(e)), s;
+    });
+  }
+  walkAtRules(e, t) {
+    return t ? e instanceof RegExp ? this.walk((r, s) => {
+      if (r.type === "atrule" && e.test(r.name))
+        return t(r, s);
+    }) : this.walk((r, s) => {
+      if (r.type === "atrule" && r.name === e)
+        return t(r, s);
+    }) : (t = e, this.walk((r, s) => {
+      if (r.type === "atrule")
+        return t(r, s);
+    }));
+  }
+  walkComments(e) {
+    return this.walk((t, r) => {
+      if (t.type === "comment")
+        return e(t, r);
+    });
+  }
+  walkDecls(e, t) {
+    return t ? e instanceof RegExp ? this.walk((r, s) => {
+      if (r.type === "decl" && e.test(r.prop))
+        return t(r, s);
+    }) : this.walk((r, s) => {
+      if (r.type === "decl" && r.prop === e)
+        return t(r, s);
+    }) : (t = e, this.walk((r, s) => {
+      if (r.type === "decl")
+        return t(r, s);
+    }));
+  }
+  walkRules(e, t) {
+    return t ? e instanceof RegExp ? this.walk((r, s) => {
+      if (r.type === "rule" && e.test(r.selector))
+        return t(r, s);
+    }) : this.walk((r, s) => {
+      if (r.type === "rule" && r.selector === e)
+        return t(r, s);
+    }) : (t = e, this.walk((r, s) => {
+      if (r.type === "rule")
+        return t(r, s);
+    }));
+  }
+}
+f.registerParse = (i) => {
+  m = i;
+};
+f.registerRule = (i) => {
+  l = i;
+};
+f.registerAtRule = (i) => {
+  a = i;
+};
+f.registerRoot = (i) => {
+  d = i;
+};
+var z = f;
+f.default = f;
+f.rebuild = (i) => {
+  i.type === "atrule" ? Object.setPrototypeOf(i, a.prototype) : i.type === "rule" ? Object.setPrototypeOf(i, l.prototype) : i.type === "decl" ? Object.setPrototypeOf(i, h.prototype) : i.type === "comment" ? Object.setPrototypeOf(i, y.prototype) : i.type === "root" && Object.setPrototypeOf(i, d.prototype), i[x] = !0, i.nodes && i.nodes.forEach((e) => {
+    f.rebuild(e);
+  });
+};
+export {
+  z as c
+};

package/dist/node_modules/postcss/lib/css-syntax-error.js

@@ -0,0 +1,55 @@
+import { getDefaultExportFromCjs as b } from "../../../_virtual/_commonjsHelpers.js";
+import { p as M } from "../../picocolors/picocolors.browser.js";
+import L from "../../../_virtual/___vite-browser-external.js";
+let f = M, g = L;
+class a extends Error {
+  constructor(e, n, s, r, l, h) {
+    super(e), this.name = "CssSyntaxError", this.reason = e, l && (this.file = l), r && (this.source = r), h && (this.plugin = h), typeof n < "u" && typeof s < "u" && (typeof n == "number" ? (this.line = n, this.column = s) : (this.line = n.line, this.column = n.column, this.endLine = s.line, this.endColumn = s.column)), this.setMessage(), Error.captureStackTrace && Error.captureStackTrace(this, a);
+  }
+  setMessage() {
+    this.message = this.plugin ? this.plugin + ": " : "", this.message += this.file ? this.file : "<css input>", typeof this.line < "u" && (this.message += ":" + this.line + ":" + this.column), this.message += ": " + this.reason;
+  }
+  showSourceCode(e) {
+    if (!this.source) return "";
+    let n = this.source;
+    e == null && (e = f.isColorSupported);
+    let s = (t) => t, r = (t) => t, l = (t) => t;
+    if (e) {
+      let { bold: t, gray: c, red: o } = f.createColors(!0);
+      r = (i) => t(o(i)), s = (i) => c(i), g && (l = (i) => g(i));
+    }
+    let h = n.split(/\r?\n/), m = Math.max(this.line - 3, 0), p = Math.min(this.line + 2, h.length), d = String(p).length;
+    return h.slice(m, p).map((t, c) => {
+      let o = m + 1 + c, i = " " + (" " + o).slice(-d) + " | ";
+      if (o === this.line) {
+        if (t.length > 160) {
+          let u = 20, S = Math.max(0, this.column - u), C = Math.max(
+            this.column + u,
+            this.endColumn + u
+          ), E = t.slice(S, C), y = s(i.replace(/\d/g, " ")) + t.slice(0, Math.min(this.column - 1, u - 1)).replace(/[^\t]/g, " ");
+          return r(">") + s(i) + l(E) + `
+ ` + y + r("^");
+        }
+        let x = s(i.replace(/\d/g, " ")) + t.slice(0, this.column - 1).replace(/[^\t]/g, " ");
+        return r(">") + s(i) + l(t) + `
+ ` + x + r("^");
+      }
+      return " " + s(i) + l(t);
+    }).join(`
+`);
+  }
+  toString() {
+    let e = this.showSourceCode();
+    return e && (e = `
+
+` + e + `
+`), this.name + ": " + this.message + e;
+  }
+}
+var k = a;
+a.default = a;
+const T = /* @__PURE__ */ b(k);
+export {
+  k as c,
+  T as default
+};

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

@@ -0,0 +1,15 @@
+import { n as t } from "./node.js";
+let o = t;
+class r extends o {
+  get variable() {
+    return this.prop.startsWith("--") || this.prop[0] === "$";
+  }
+  constructor(e) {
+    e && typeof e.value < "u" && typeof e.value != "string" && (e = { ...e, value: String(e.value) }), super(e), this.type = "decl";
+  }
+}
+var a = r;
+r.default = r;
+export {
+  a as d
+};

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

@@ -0,0 +1,21 @@
+import { c as n } from "./container.js";
+let a = n, r, o;
+class e extends a {
+  constructor(s) {
+    super({ type: "document", ...s }), this.nodes || (this.nodes = []);
+  }
+  toResult(s = {}) {
+    return new r(new o(), this, s).stringify();
+  }
+}
+e.registerLazyResult = (t) => {
+  r = t;
+};
+e.registerProcessor = (t) => {
+  o = t;
+};
+var l = e;
+e.default = e;
+export {
+  l as d
+};