@chainvibe/components 0.2.0

package/dist/node_modules/@number-flow/react/dist/NumberFlow-client-48rw3j0J.js

@@ -0,0 +1,111 @@
+import * as React from "react";
+import { f as st, N as q, d as it } from "../../../number-flow/dist/lite-BtgQ9jUv.js";
+const REACT_MAJOR = parseInt(React.version.match(/^(\d+)\./)?.[1]), isReact19 = REACT_MAJOR >= 19, OBSERVED_ATTRIBUTES = [
+  "data",
+  "digits"
+];
+class NumberFlowElement extends q {
+  attributeChangedCallback(attr, _oldValue, newValue) {
+    this[attr] = JSON.parse(newValue);
+  }
+}
+NumberFlowElement.observedAttributes = isReact19 ? [] : OBSERVED_ATTRIBUTES;
+it("number-flow-react", NumberFlowElement);
+const formatters = {}, serialize = isReact19 ? (p) => p : JSON.stringify;
+function splitProps(props) {
+  const { transformTiming, spinTiming, opacityTiming, animated, respectMotionPreference, trend, plugins, ...rest } = props;
+  return [
+    {
+      transformTiming,
+      spinTiming,
+      opacityTiming,
+      animated,
+      respectMotionPreference,
+      trend,
+      plugins
+    },
+    rest
+  ];
+}
+class NumberFlowImpl extends React.Component {
+  // Update the non-`data` props to avoid JSON serialization
+  // Data needs to be set in render still:
+  updateProperties(prevProps) {
+    if (!this.el) return;
+    this.el.batched = !this.props.isolate;
+    const [nonData] = splitProps(this.props);
+    Object.entries(nonData).forEach(([k, v]) => {
+      this.el[k] = v ?? NumberFlowElement.defaultProps[k];
+    }), prevProps?.onAnimationsStart && this.el.removeEventListener("animationsstart", prevProps.onAnimationsStart), this.props.onAnimationsStart && this.el.addEventListener("animationsstart", this.props.onAnimationsStart), prevProps?.onAnimationsFinish && this.el.removeEventListener("animationsfinish", prevProps.onAnimationsFinish), this.props.onAnimationsFinish && this.el.addEventListener("animationsfinish", this.props.onAnimationsFinish);
+  }
+  componentDidMount() {
+    this.updateProperties(), isReact19 && this.el && (this.el.digits = this.props.digits, this.el.data = this.props.data);
+  }
+  getSnapshotBeforeUpdate(prevProps) {
+    if (this.updateProperties(prevProps), prevProps.data !== this.props.data) {
+      if (this.props.group)
+        return this.props.group.willUpdate(), () => this.props.group?.didUpdate();
+      if (!this.props.isolate)
+        return this.el?.willUpdate(), () => this.el?.didUpdate();
+    }
+    return null;
+  }
+  componentDidUpdate(_, __, didUpdate) {
+    didUpdate?.();
+  }
+  handleRef(el) {
+    this.props.innerRef && (this.props.innerRef.current = el), this.el = el;
+  }
+  render() {
+    const [_, { innerRef, className, data, willChange, isolate, group, digits, onAnimationsStart, onAnimationsFinish, ...rest }] = splitProps(this.props);
+    return (
+      // @ts-expect-error missing types
+      /* @__PURE__ */ React.createElement("number-flow-react", {
+        ref: this.handleRef,
+        "data-will-change": willChange ? "" : void 0,
+        // Have to rename this:
+        class: className,
+        ...rest,
+        dangerouslySetInnerHTML: {
+          __html: ""
+        },
+        suppressHydrationWarning: !0,
+        digits: serialize(digits),
+        // Make sure data is set last, everything else is updated:
+        data: serialize(data)
+      })
+    );
+  }
+  constructor(props) {
+    super(props), this.handleRef = this.handleRef.bind(this);
+  }
+}
+const NumberFlow = /* @__PURE__ */ React.forwardRef(function({ value, locales, format, prefix, suffix, ...props }, _ref) {
+  React.useImperativeHandle(_ref, () => ref.current, []);
+  const ref = React.useRef(), group = React.useContext(NumberFlowGroupContext);
+  group?.useRegister(ref);
+  const localesString = React.useMemo(() => locales ? JSON.stringify(locales) : "", [
+    locales
+  ]), formatString = React.useMemo(() => format ? JSON.stringify(format) : "", [
+    format
+  ]), data = React.useMemo(() => {
+    const formatter = formatters[`${localesString}:${formatString}`] ??= new Intl.NumberFormat(locales, format);
+    return st(value, formatter, prefix, suffix);
+  }, [
+    value,
+    localesString,
+    formatString,
+    prefix,
+    suffix
+  ]);
+  return /* @__PURE__ */ React.createElement(NumberFlowImpl, {
+    ...props,
+    group,
+    data,
+    innerRef: ref
+  });
+}), NumberFlowGroupContext = /* @__PURE__ */ React.createContext(void 0);
+export {
+  NumberFlow as N,
+  NumberFlowElement as a
+};

package/dist/node_modules/compress-json/dist/config.js

@@ -0,0 +1,16 @@
+import { __exports as config } from "../../../_virtual/config.js";
+var hasRequiredConfig;
+function requireConfig() {
+  return hasRequiredConfig ? config : (hasRequiredConfig = 1, Object.defineProperty(config, "__esModule", { value: !0 }), config.config = void 0, config.config = {
+    // default will not sort the object key
+    sort_key: !1,
+    // default will convert into null silently like JSON.stringify
+    preserve_nan: !1,
+    error_on_nan: !1,
+    preserve_infinite: !1,
+    error_on_infinite: !1
+  }, config);
+}
+export {
+  requireConfig as __require
+};

package/dist/node_modules/compress-json/dist/core.js

@@ -0,0 +1,92 @@
+import { __exports as core } from "../../../_virtual/core.js";
+import { __require as requireDebug } from "./debug.js";
+import { __require as requireEncode } from "./encode.js";
+import { __require as requireMemory } from "./memory.js";
+import { __require as requireNumber } from "./number.js";
+var hasRequiredCore;
+function requireCore() {
+  if (hasRequiredCore) return core;
+  hasRequiredCore = 1, Object.defineProperty(core, "__esModule", { value: !0 }), core.compress = compress, core.decode = decode, core.decompress = decompress;
+  const debug_1 = requireDebug(), encode_1 = requireEncode(), memory_1 = requireMemory(), number_1 = requireNumber();
+  function compress(o) {
+    const mem = (0, memory_1.makeInMemoryMemory)(), root = (0, memory_1.addValue)(mem, o, void 0);
+    return [(0, memory_1.memToValues)(mem), root];
+  }
+  function decodeObject(values, s) {
+    if (s === "o|")
+      return {};
+    const o = {}, vs = s.split("|"), key_id = vs[1];
+    let keys = decode(values, key_id);
+    const n = vs.length;
+    n - 2 === 1 && !Array.isArray(keys) && (keys = [keys]);
+    for (let i = 2; i < n; i++) {
+      const k = keys[i - 2];
+      let v = vs[i];
+      v = decode(values, v), o[k] = v;
+    }
+    return o;
+  }
+  function decodeArray(values, s) {
+    if (s === "a|")
+      return [];
+    const vs = s.split("|"), n = vs.length - 1, xs = new Array(n);
+    for (let i = 0; i < n; i++) {
+      let v = vs[i + 1];
+      v = decode(values, v), xs[i] = v;
+    }
+    return xs;
+  }
+  function decode(values, key) {
+    if (key === "" || key === "_")
+      return null;
+    const id = (0, encode_1.decodeKey)(key), v = values[id];
+    if (v === null)
+      return v;
+    switch (typeof v) {
+      case "undefined":
+        return v;
+      case "number":
+        return v;
+      case "string":
+        if (v[1] === "|")
+          switch (v[0]) {
+            case "b":
+              switch (v[2]) {
+                case "T":
+                  return !0;
+                case "F":
+                  return !1;
+                default:
+                  return (0, debug_1.throwUnknownDataType)(v);
+              }
+            case "o":
+              return decodeObject(values, v);
+            case "n":
+              return (0, number_1.s_to_num)(v.slice(2));
+            case "N":
+              switch (v[2]) {
+                case "+":
+                  return 1 / 0;
+                case "-":
+                  return -1 / 0;
+                case "0":
+                  return NaN;
+                default:
+                  return (0, debug_1.throwUnknownDataType)(v);
+              }
+            case "a":
+              return decodeArray(values, v);
+          }
+        return (0, encode_1.decodeStr)(v);
+    }
+    return (0, debug_1.throwUnknownDataType)(v);
+  }
+  function decompress(c) {
+    const [values, root] = c;
+    return decode(values, root);
+  }
+  return core;
+}
+export {
+  requireCore as __require
+};

package/dist/node_modules/compress-json/dist/debug.js

@@ -0,0 +1,19 @@
+import { __exports as debug } from "../../../_virtual/debug.js";
+var hasRequiredDebug;
+function requireDebug() {
+  if (hasRequiredDebug) return debug;
+  hasRequiredDebug = 1, Object.defineProperty(debug, "__esModule", { value: !0 }), debug.getType = getType, debug.throwUnknownDataType = throwUnknownDataType, debug.throwUnsupportedData = throwUnsupportedData;
+  function getType(o) {
+    return Object.prototype.toString.call(o);
+  }
+  function throwUnknownDataType(o) {
+    throw new TypeError("unsupported data type: " + getType(o));
+  }
+  function throwUnsupportedData(name) {
+    throw new TypeError("unsupported data type: " + name);
+  }
+  return debug;
+}
+export {
+  requireDebug as __require
+};

package/dist/node_modules/compress-json/dist/encode.js

@@ -0,0 +1,58 @@
+import { __exports as encode } from "../../../_virtual/encode.js";
+import { __require as requireNumber } from "./number.js";
+var hasRequiredEncode;
+function requireEncode() {
+  if (hasRequiredEncode) return encode;
+  hasRequiredEncode = 1, Object.defineProperty(encode, "__esModule", { value: !0 }), encode.encodeNum = encodeNum, encode.decodeNum = decodeNum, encode.decodeKey = decodeKey, encode.encodeBool = encodeBool, encode.decodeBool = decodeBool, encode.encodeStr = encodeStr, encode.decodeStr = decodeStr;
+  const number_1 = requireNumber();
+  function encodeNum(num) {
+    return num === 1 / 0 ? "N|+" : num === -1 / 0 ? "N|-" : Number.isNaN(num) ? "N|0" : "n|" + (0, number_1.num_to_s)(num);
+  }
+  function decodeNum(s) {
+    if (s.length === 3 && s[0] === "N" && s[1] === "|")
+      switch (s[2]) {
+        case "+":
+          return 1 / 0;
+        case "-":
+          return -1 / 0;
+        case "0":
+          return NaN;
+      }
+    return (0, number_1.s_to_num)(s.slice(2));
+  }
+  function decodeKey(key) {
+    return typeof key == "number" ? key : (0, number_1.s_to_int)(key);
+  }
+  function encodeBool(b) {
+    return b ? "b|T" : "b|F";
+  }
+  function decodeBool(s) {
+    if (s.length === 3 && s[0] === "b" && s[1] === "|")
+      switch (s[2]) {
+        case "T":
+          return !0;
+        case "F":
+          return !1;
+      }
+    return !!s;
+  }
+  function encodeStr(str) {
+    if (str[1] === "|")
+      switch (str[0]) {
+        case "b":
+        case "o":
+        case "n":
+        case "a":
+        case "s":
+          return "s|" + str;
+      }
+    return str;
+  }
+  function decodeStr(s) {
+    return s[0] === "s" && s[1] === "|" ? s.substr(2) : s;
+  }
+  return encode;
+}
+export {
+  requireEncode as __require
+};

package/dist/node_modules/compress-json/dist/helpers.js

@@ -0,0 +1,27 @@
+import { __exports as helpers } from "../../../_virtual/helpers.js";
+var hasRequiredHelpers;
+function requireHelpers() {
+  if (hasRequiredHelpers) return helpers;
+  hasRequiredHelpers = 1, Object.defineProperty(helpers, "__esModule", { value: !0 }), helpers.trimUndefined = trimUndefined, helpers.trimUndefinedRecursively = trimUndefinedRecursively;
+  function trimUndefined(object) {
+    for (const key in object)
+      object[key] === void 0 && delete object[key];
+  }
+  function trimUndefinedRecursively(object) {
+    trimUndefinedRecursivelyLoop(object, /* @__PURE__ */ new Set());
+  }
+  function trimUndefinedRecursivelyLoop(object, tracks) {
+    tracks.add(object);
+    for (const key in object)
+      if (object[key] === void 0)
+        delete object[key];
+      else {
+        const value = object[key];
+        value && typeof value == "object" && !tracks.has(value) && trimUndefinedRecursivelyLoop(value, tracks);
+      }
+  }
+  return helpers;
+}
+export {
+  requireHelpers as __require
+};

package/dist/node_modules/compress-json/dist/index.js

@@ -0,0 +1,38 @@
+import { __exports as dist } from "../../../_virtual/index2.js";
+import { __require as requireCore } from "./core.js";
+import { __require as requireMemory } from "./memory.js";
+import { __require as requireHelpers } from "./helpers.js";
+import { __require as requireConfig } from "./config.js";
+var hasRequiredDist;
+function requireDist() {
+  return hasRequiredDist ? dist : (hasRequiredDist = 1, (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: !0 }), exports$1.config = exports$1.trimUndefinedRecursively = exports$1.trimUndefined = exports$1.addValue = exports$1.decode = exports$1.decompress = exports$1.compress = void 0;
+    var core_1 = requireCore();
+    Object.defineProperty(exports$1, "compress", { enumerable: !0, get: function() {
+      return core_1.compress;
+    } }), Object.defineProperty(exports$1, "decompress", { enumerable: !0, get: function() {
+      return core_1.decompress;
+    } });
+    var core_2 = requireCore();
+    Object.defineProperty(exports$1, "decode", { enumerable: !0, get: function() {
+      return core_2.decode;
+    } });
+    var memory_1 = requireMemory();
+    Object.defineProperty(exports$1, "addValue", { enumerable: !0, get: function() {
+      return memory_1.addValue;
+    } });
+    var helpers_1 = requireHelpers();
+    Object.defineProperty(exports$1, "trimUndefined", { enumerable: !0, get: function() {
+      return helpers_1.trimUndefined;
+    } }), Object.defineProperty(exports$1, "trimUndefinedRecursively", { enumerable: !0, get: function() {
+      return helpers_1.trimUndefinedRecursively;
+    } });
+    var config_1 = requireConfig();
+    Object.defineProperty(exports$1, "config", { enumerable: !0, get: function() {
+      return config_1.config;
+    } });
+  })(dist), dist);
+}
+export {
+  requireDist as __require
+};

package/dist/node_modules/compress-json/dist/memory.js

@@ -0,0 +1,128 @@
+import { __exports as memory } from "../../../_virtual/memory.js";
+import { __require as requireConfig } from "./config.js";
+import { __require as requireDebug } from "./debug.js";
+import { __require as requireEncode } from "./encode.js";
+import { __require as requireNumber } from "./number.js";
+var hasRequiredMemory;
+function requireMemory() {
+  if (hasRequiredMemory) return memory;
+  hasRequiredMemory = 1, Object.defineProperty(memory, "__esModule", { value: !0 }), memory.memToValues = memToValues, memory.makeInMemoryStore = makeInMemoryStore, memory.makeInMemoryCache = makeInMemoryCache, memory.makeInMemoryMemory = makeInMemoryMemory, memory.addValue = addValue;
+  const config_1 = requireConfig(), debug_1 = requireDebug(), encode_1 = requireEncode(), number_1 = requireNumber();
+  function memToValues(mem) {
+    return mem.store.toArray();
+  }
+  function makeInMemoryStore() {
+    const mem = [];
+    return {
+      forEach(cb) {
+        for (let i = 0; i < mem.length; i++)
+          if (cb(mem[i]) === "break")
+            return;
+      },
+      add(value) {
+        mem.push(value);
+      },
+      toArray() {
+        return mem;
+      }
+    };
+  }
+  function makeInMemoryCache() {
+    const valueMem = /* @__PURE__ */ Object.create(null), schemaMem = /* @__PURE__ */ Object.create(null);
+    return {
+      getValue(key) {
+        return valueMem[key];
+      },
+      getSchema(key) {
+        return schemaMem[key];
+      },
+      forEachValue(cb) {
+        for (const [key, value] of Object.entries(valueMem))
+          if (cb(key, value) === "break")
+            return;
+      },
+      forEachSchema(cb) {
+        for (const [key, value] of Object.entries(schemaMem))
+          if (cb(key, value) === "break")
+            return;
+      },
+      setValue(key, value) {
+        valueMem[key] = value;
+      },
+      setSchema(key, value) {
+        schemaMem[key] = value;
+      },
+      hasValue(key) {
+        return key in valueMem;
+      },
+      hasSchema(key) {
+        return key in schemaMem;
+      }
+    };
+  }
+  function makeInMemoryMemory() {
+    return {
+      store: makeInMemoryStore(),
+      cache: makeInMemoryCache(),
+      keyCount: 0
+    };
+  }
+  function getValueKey(mem, value) {
+    if (mem.cache.hasValue(value))
+      return mem.cache.getValue(value);
+    const id = mem.keyCount++, key = (0, number_1.num_to_s)(id);
+    return mem.store.add(value), mem.cache.setValue(value, key), key;
+  }
+  function getSchema(mem, keys) {
+    config_1.config.sort_key && keys.sort();
+    const schema = keys.join(",");
+    if (mem.cache.hasSchema(schema))
+      return mem.cache.getSchema(schema);
+    const key_id = addValue(mem, keys, void 0);
+    return mem.cache.setSchema(schema, key_id), key_id;
+  }
+  function addValue(mem, o, parent) {
+    if (o === null)
+      return "";
+    switch (typeof o) {
+      case "undefined":
+        if (Array.isArray(parent))
+          return addValue(mem, null, parent);
+        break;
+      case "object":
+        if (o === null)
+          return getValueKey(mem, null);
+        if (Array.isArray(o)) {
+          let acc = "a";
+          for (let i = 0; i < o.length; i++) {
+            const v = o[i], key = v === null ? "_" : addValue(mem, v, o);
+            acc += "|" + key;
+          }
+          return acc === "a" && (acc = "a|"), getValueKey(mem, acc);
+        } else {
+          const keys = Object.keys(o);
+          if (keys.length === 0)
+            return getValueKey(mem, "o|");
+          let acc = "o";
+          const key_id = getSchema(mem, keys);
+          acc += "|" + key_id;
+          for (const key of keys) {
+            const value = o[key], v = addValue(mem, value, o);
+            acc += "|" + v;
+          }
+          return getValueKey(mem, acc);
+        }
+      case "boolean":
+        return getValueKey(mem, (0, encode_1.encodeBool)(o));
+      case "number":
+        return Number.isNaN(o) ? config_1.config.preserve_nan ? getValueKey(mem, "N|0") : (config_1.config.error_on_nan && (0, debug_1.throwUnsupportedData)("[number NaN]"), "") : Number.POSITIVE_INFINITY === o ? config_1.config.preserve_infinite ? getValueKey(mem, "N|+") : (config_1.config.error_on_infinite && (0, debug_1.throwUnsupportedData)("[number Infinity]"), "") : Number.NEGATIVE_INFINITY === o ? config_1.config.preserve_infinite ? getValueKey(mem, "N|-") : (config_1.config.error_on_infinite && (0, debug_1.throwUnsupportedData)("[number -Infinity]"), "") : getValueKey(mem, (0, encode_1.encodeNum)(o));
+      case "string":
+        return getValueKey(mem, (0, encode_1.encodeStr)(o));
+    }
+    return (0, debug_1.throwUnknownDataType)(o);
+  }
+  return memory;
+}
+export {
+  requireMemory as __require
+};

package/dist/node_modules/compress-json/dist/number.js

@@ -0,0 +1,119 @@
+import { __exports as number } from "../../../_virtual/number.js";
+var hasRequiredNumber;
+function requireNumber() {
+  if (hasRequiredNumber) return number;
+  hasRequiredNumber = 1, Object.defineProperty(number, "__esModule", { value: !0 }), number.s_to_int = s_to_int, number.s_to_big_int = s_to_big_int, number.int_to_s = int_to_s, number.big_int_to_s = big_int_to_s, number.num_to_s = num_to_s, number.int_str_to_s = int_str_to_s, number.s_to_num = s_to_num;
+  let i_to_s = "";
+  for (let i = 0; i < 10; i++) {
+    const c = String.fromCharCode(48 + i);
+    i_to_s += c;
+  }
+  for (let i = 0; i < 26; i++) {
+    const c = String.fromCharCode(65 + i);
+    i_to_s += c;
+  }
+  for (let i = 0; i < 26; i++) {
+    const c = String.fromCharCode(97 + i);
+    i_to_s += c;
+  }
+  const N = i_to_s.length, s_to_i = {};
+  for (let i = 0; i < N; i++) {
+    const s = i_to_s[i];
+    s_to_i[s] = i;
+  }
+  function s_to_int(s) {
+    let acc = 0, pow = 1;
+    for (let i = s.length - 1; i >= 0; i--) {
+      const c = s[i];
+      let x = s_to_i[c];
+      x *= pow, acc += x, pow *= N;
+    }
+    return acc;
+  }
+  function s_to_big_int(s) {
+    let acc = BigInt(0), pow = BigInt(1);
+    const n = BigInt(N);
+    for (let i = s.length - 1; i >= 0; i--) {
+      const c = s[i];
+      let x = BigInt(s_to_i[c]);
+      x *= pow, acc += x, pow *= n;
+    }
+    return acc;
+  }
+  function int_to_s(int) {
+    if (int === 0)
+      return i_to_s[0];
+    const acc = [];
+    for (; int !== 0; ) {
+      const i = int % N, c = i_to_s[i];
+      acc.push(c), int -= i, int /= N;
+    }
+    return acc.reverse().join("");
+  }
+  function big_int_to_s(int) {
+    const zero = BigInt(0), n = BigInt(N);
+    if (int === zero)
+      return i_to_s[0];
+    const acc = [];
+    for (; int !== zero; ) {
+      const i = int % n, c = i_to_s[Number(i)];
+      acc.push(c), int /= n;
+    }
+    return acc.reverse().join("");
+  }
+  function reverse(s) {
+    return s.split("").reverse().join("");
+  }
+  function num_to_s(num) {
+    if (num < 0)
+      return "-" + num_to_s(-num);
+    let [a, b] = num.toString().split(".");
+    if (!b)
+      if (a.includes("e")) {
+        const [a1, a2] = a.split("e");
+        a = a1, b = "0e" + a2;
+      } else
+        return int_to_s(num);
+    let c;
+    b && ([b, c] = b.split("e")), a = int_str_to_s(a), b = reverse(b), b = int_str_to_s(b);
+    let str = a + "." + b;
+    if (c) {
+      switch (str += ".", c[0]) {
+        case "+":
+          c = c.slice(1);
+          break;
+        case "-":
+          str += "-", c = c.slice(1);
+          break;
+      }
+      c = int_str_to_s(c), str += c;
+    }
+    return str;
+  }
+  function int_str_to_s(int_str) {
+    const num = +int_str;
+    return num.toString() === int_str && num + 1 !== num && num - 1 !== num ? int_to_s(num) : ":" + big_int_to_s(BigInt(int_str));
+  }
+  function s_to_int_str(s) {
+    return s[0] === ":" ? s_to_big_int(s.substring(1)).toString() : s_to_int(s).toString();
+  }
+  function s_to_num(s) {
+    if (s[0] === "-")
+      return -s_to_num(s.substr(1));
+    let [a, b, c] = s.split(".");
+    if (!b)
+      return s_to_int(a);
+    a = s_to_int_str(a), b = s_to_int_str(b), b = reverse(b);
+    let str = a + "." + b;
+    if (c) {
+      str += "e";
+      let neg = !1;
+      c[0] === "-" && (neg = !0, c = c.slice(1)), c = s_to_int_str(c), str += neg ? -c : +c;
+    }
+    return +str;
+  }
+  return number;
+}
+export {
+  requireNumber as __require
+};