ranui 0.1.9 → 0.1.10-alpha.10

package/dist/arrow-down-B_hCY3Wt.js

@@ -0,0 +1,662 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const noop = () => {
+};
+const currentDevice = () => {
+  if (typeof window !== "undefined") {
+    const ua = navigator.userAgent.toLowerCase();
+    if (/ipad|ipod/.test(ua)) return "ipad";
+    if (/android/.test(ua)) return "android";
+    if (/iphone/.test(ua)) return "iphone";
+    return "pc";
+  }
+  return "pc";
+};
+const isClient = typeof window !== "undefined";
+const isMobile = () => {
+  if (!isClient) return false;
+  const ua = window.navigator.userAgent;
+  if (/Android|webOS|iPhone|iPod|iPad|BlackBerry/i.test(ua)) {
+    return true;
+  }
+  return false;
+};
+const K_sha2 = [
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+];
+class Int_64 {
+  constructor(msint_32, lsint_32) {
+    __publicField(this, "highOrder");
+    __publicField(this, "lowOrder");
+    this.highOrder = msint_32;
+    this.lowOrder = lsint_32;
+  }
+}
+[
+  new Int_64(K_sha2[0], 3609767458),
+  new Int_64(K_sha2[1], 602891725),
+  new Int_64(K_sha2[2], 3964484399),
+  new Int_64(K_sha2[3], 2173295548),
+  new Int_64(K_sha2[4], 4081628472),
+  new Int_64(K_sha2[5], 3053834265),
+  new Int_64(K_sha2[6], 2937671579),
+  new Int_64(K_sha2[7], 3664609560),
+  new Int_64(K_sha2[8], 2734883394),
+  new Int_64(K_sha2[9], 1164996542),
+  new Int_64(K_sha2[10], 1323610764),
+  new Int_64(K_sha2[11], 3590304994),
+  new Int_64(K_sha2[12], 4068182383),
+  new Int_64(K_sha2[13], 991336113),
+  new Int_64(K_sha2[14], 633803317),
+  new Int_64(K_sha2[15], 3479774868),
+  new Int_64(K_sha2[16], 2666613458),
+  new Int_64(K_sha2[17], 944711139),
+  new Int_64(K_sha2[18], 2341262773),
+  new Int_64(K_sha2[19], 2007800933),
+  new Int_64(K_sha2[20], 1495990901),
+  new Int_64(K_sha2[21], 1856431235),
+  new Int_64(K_sha2[22], 3175218132),
+  new Int_64(K_sha2[23], 2198950837),
+  new Int_64(K_sha2[24], 3999719339),
+  new Int_64(K_sha2[25], 766784016),
+  new Int_64(K_sha2[26], 2566594879),
+  new Int_64(K_sha2[27], 3203337956),
+  new Int_64(K_sha2[28], 1034457026),
+  new Int_64(K_sha2[29], 2466948901),
+  new Int_64(K_sha2[30], 3758326383),
+  new Int_64(K_sha2[31], 168717936),
+  new Int_64(K_sha2[32], 1188179964),
+  new Int_64(K_sha2[33], 1546045734),
+  new Int_64(K_sha2[34], 1522805485),
+  new Int_64(K_sha2[35], 2643833823),
+  new Int_64(K_sha2[36], 2343527390),
+  new Int_64(K_sha2[37], 1014477480),
+  new Int_64(K_sha2[38], 1206759142),
+  new Int_64(K_sha2[39], 344077627),
+  new Int_64(K_sha2[40], 1290863460),
+  new Int_64(K_sha2[41], 3158454273),
+  new Int_64(K_sha2[42], 3505952657),
+  new Int_64(K_sha2[43], 106217008),
+  new Int_64(K_sha2[44], 3606008344),
+  new Int_64(K_sha2[45], 1432725776),
+  new Int_64(K_sha2[46], 1467031594),
+  new Int_64(K_sha2[47], 851169720),
+  new Int_64(K_sha2[48], 3100823752),
+  new Int_64(K_sha2[49], 1363258195),
+  new Int_64(K_sha2[50], 3750685593),
+  new Int_64(K_sha2[51], 3785050280),
+  new Int_64(K_sha2[52], 3318307427),
+  new Int_64(K_sha2[53], 3812723403),
+  new Int_64(K_sha2[54], 2003034995),
+  new Int_64(K_sha2[55], 3602036899),
+  new Int_64(K_sha2[56], 1575990012),
+  new Int_64(K_sha2[57], 1125592928),
+  new Int_64(K_sha2[58], 2716904306),
+  new Int_64(K_sha2[59], 442776044),
+  new Int_64(K_sha2[60], 593698344),
+  new Int_64(K_sha2[61], 3733110249),
+  new Int_64(K_sha2[62], 2999351573),
+  new Int_64(K_sha2[63], 3815920427),
+  new Int_64(3391569614, 3928383900),
+  new Int_64(3515267271, 566280711),
+  new Int_64(3940187606, 3454069534),
+  new Int_64(4118630271, 4000239992),
+  new Int_64(116418474, 1914138554),
+  new Int_64(174292421, 2731055270),
+  new Int_64(289380356, 3203993006),
+  new Int_64(460393269, 320620315),
+  new Int_64(685471733, 587496836),
+  new Int_64(852142971, 1086792851),
+  new Int_64(1017036298, 365543100),
+  new Int_64(1126000580, 2618297676),
+  new Int_64(1288033470, 3409855158),
+  new Int_64(1501505948, 4234509866),
+  new Int_64(1607167915, 987167468),
+  new Int_64(1816402316, 1246189591)
+];
+[
+  new Int_64(0, 1),
+  new Int_64(0, 32898),
+  new Int_64(2147483648, 32906),
+  new Int_64(2147483648, 2147516416),
+  new Int_64(0, 32907),
+  new Int_64(0, 2147483649),
+  new Int_64(2147483648, 2147516545),
+  new Int_64(2147483648, 32777),
+  new Int_64(0, 138),
+  new Int_64(0, 136),
+  new Int_64(0, 2147516425),
+  new Int_64(0, 2147483658),
+  new Int_64(0, 2147516555),
+  new Int_64(2147483648, 139),
+  new Int_64(2147483648, 32905),
+  new Int_64(2147483648, 32771),
+  new Int_64(2147483648, 32770),
+  new Int_64(2147483648, 128),
+  new Int_64(0, 32778),
+  new Int_64(2147483648, 2147483658),
+  new Int_64(2147483648, 2147516545),
+  new Int_64(2147483648, 32896),
+  new Int_64(0, 2147483649),
+  new Int_64(2147483648, 2147516424)
+];
+function formatDuration(time) {
+  return time < 10 ? `0${time}` : time;
+}
+function timestampToTime(timestamp) {
+  let date = /* @__PURE__ */ new Date();
+  if (timestamp) {
+    date = new Date(timestamp);
+  }
+  date.format = (format = "YYYY-MM-DD HH:mm:ss") => {
+    const year = date.getFullYear();
+    const month = formatDuration(date.getMonth() + 1);
+    const day = formatDuration(date.getDate());
+    const hour = formatDuration(date.getHours());
+    const minute = formatDuration(date.getMinutes());
+    const second = formatDuration(date.getSeconds());
+    return format.replace(/Y+/gi, `${year}`).replace(/M+/g, `${month}`).replace(/D+/gi, `${day}`).replace(/H+/gi, `${hour}`).replace(/m+/g, `${minute}`).replace(/S+/gi, `${second}`);
+  };
+  return date;
+}
+const timeFormat = (time) => {
+  if (time === 0) return "00:00";
+  if (!time) return "";
+  const hour = Math.trunc(time / 3600);
+  const minute = Math.trunc(time % 3600 / 60);
+  const second = formatDuration(Math.trunc(time - hour * 3600 - minute * 60));
+  if (hour === 0) {
+    return `${formatDuration(minute)}:${second}`;
+  }
+  return `${formatDuration(hour)}:${formatDuration(minute)}:${second}`;
+};
+const getPixelRatio = (context) => {
+  const backingStore = context.backingStorePixelRatio || context.webkitBackingStorePixelRatio || context.mozBackingStorePixelRatio || context.msBackingStorePixelRatio || context.oBackingStorePixelRatio || 1;
+  return (isClient && window.devicePixelRatio || 1) / backingStore;
+};
+const addClassToElement = (element, addClass) => {
+  if (typeof document === "undefined") return void 0;
+  const classList = element.classList;
+  if (!classList.contains(addClass)) {
+    classList.add(addClass);
+  }
+};
+const removeClassToElement = (element, removeClass) => {
+  if (typeof document === "undefined") return void 0;
+  const classList = element.classList;
+  if (classList.contains(removeClass)) {
+    classList.remove(removeClass);
+  }
+};
+const createDocumentFragment = (list) => {
+  if (typeof document === "undefined") return void 0;
+  const Fragment = document.createDocumentFragment();
+  list.forEach((item) => Fragment.appendChild(item));
+  return Fragment;
+};
+const SVG_NS = "http://www.w3.org/2000/svg";
+const SVG_TAG_NAMES = [
+  "svg",
+  "path",
+  "g",
+  "circle",
+  "rect",
+  "line",
+  "polyline",
+  "polygon",
+  "ellipse",
+  "text",
+  "tspan",
+  "textPath",
+  "defs",
+  "marker",
+  "radialGradient",
+  "stop",
+  "linearGradient",
+  "clipPath",
+  "mask",
+  "pattern",
+  "image",
+  "use",
+  "symbol",
+  "foreignObject",
+  "feGaussianBlur",
+  "feColorMatrix"
+];
+class Chain {
+  constructor(tagName, options) {
+    __publicField(this, "listener");
+    __publicField(this, "element");
+    __publicField(this, "create", (tagName2, options2) => {
+      if (SVG_TAG_NAMES.includes(tagName2)) {
+        return document.createElementNS(SVG_NS, tagName2, options2);
+      }
+      return document.createElement(tagName2, options2);
+    });
+    __publicField(this, "setAttribute", (name, value) => {
+      this.element.setAttribute(name, value);
+      return this;
+    });
+    __publicField(this, "removeAttribute", (name) => {
+      this.element.removeAttribute(name);
+      return this;
+    });
+    __publicField(this, "append", (child) => {
+      this.element.appendChild(child);
+      return this;
+    });
+    __publicField(this, "remove", (child) => {
+      this.element.removeChild(child);
+      return this;
+    });
+    __publicField(this, "setTextContent", (text) => {
+      this.element.textContent = text;
+      return this;
+    });
+    __publicField(this, "setStyle", (name, value) => {
+      this.element.style.setProperty(name, value);
+      return this;
+    });
+    __publicField(this, "addElementByType", (item, parent) => {
+      if (item instanceof Chain) {
+        parent.appendChild(item.element);
+      }
+      if (item instanceof HTMLElement) {
+        parent.appendChild(item);
+      }
+    });
+    __publicField(this, "addChild", (child) => {
+      if (Array.isArray(child)) {
+        const Fragment = document.createDocumentFragment();
+        child.forEach((item) => {
+          this.addElementByType(item, Fragment);
+        });
+        this.element.appendChild(Fragment);
+      } else {
+        this.addElementByType(child, this.element);
+      }
+      return this;
+    });
+    __publicField(this, "listen", (type, listener, options2) => {
+      let event = this.listener.get(type);
+      if (!event) {
+        event = /* @__PURE__ */ new Map();
+        this.listener.set(type, event);
+      }
+      const value = event.get(listener.name);
+      if (value === listener) {
+        console.warn(`${value.name} listener has been added to ${type} event, please remove it first.`);
+      }
+      this.element.addEventListener(type, listener, options2);
+      event.set(listener.name, listener);
+      return this;
+    });
+    __publicField(this, "clearListener", (type, listener, options2) => {
+      this.element.removeEventListener(type, listener, options2);
+      const event = this.listener.get(type);
+      if (event) {
+        event.delete(listener.name);
+      } else {
+        console.warn(`No ${type} event listener has been added.`);
+      }
+      return this;
+    });
+    __publicField(this, "clearAllListener", () => {
+      for (const [key, value] of this.listener) {
+        for (const [k2, v2] of value) {
+          this.element.removeEventListener(key, v2);
+          value.delete(k2);
+        }
+        this.listener.delete(key);
+      }
+      return this;
+    });
+    this.element = this.create(tagName, options);
+    this.listener = /* @__PURE__ */ new Map();
+  }
+}
+const create = (tagName, options) => {
+  return new Chain(tagName, options);
+};
+const generateThrottle = () => {
+  let timer;
+  return function(fn, wait = 300) {
+    return function(...args) {
+      if (timer) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+      const context = this;
+      if (!timer) {
+        timer = setTimeout(() => {
+          fn.apply(context, args);
+          clearTimeout(timer);
+          timer = void 0;
+        }, wait);
+      }
+    };
+  };
+};
+const codes = /* @__PURE__ */ new Map([
+  [100, "Continue"],
+  [101, "Switching Protocols"],
+  [102, "Processing"],
+  [103, "Early Hints"],
+  [200, "OK"],
+  [201, "Created"],
+  [202, "Accepted"],
+  [203, "Non-Authoritative Information"],
+  [204, "No Content"],
+  [205, "Reset Content"],
+  [206, "Partial Content"],
+  [207, "Multi-Status"],
+  [208, "Already Reported"],
+  [226, "IM Used"],
+  [300, "Multiple Choices"],
+  [301, "Moved Permanently"],
+  [302, "Found"],
+  [303, "See Other"],
+  [304, "Not Modified"],
+  [305, "Use Proxy"],
+  [307, "Temporary Redirect"],
+  [308, "Permanent Redirect"],
+  [400, "Bad Request"],
+  [401, "Unauthorized"],
+  [402, "Payment Required"],
+  [403, "Forbidden"],
+  [404, "Not Found"],
+  [405, "Method Not Allowed"],
+  [406, "Not Acceptable"],
+  [407, "Proxy Authentication Required"],
+  [408, "Request Timeout"],
+  [409, "Conflict"],
+  [410, "Gone"],
+  [411, "Length Required"],
+  [412, "Precondition Failed"],
+  [413, "Payload Too Large"],
+  [414, "URI Too Long"],
+  [415, "Unsupported Media Type"],
+  [416, "Range Not Satisfiable"],
+  [417, "Expectation Failed"],
+  [418, "I'm a Teapot"],
+  [421, "Misdirected Request"],
+  [422, "Unprocessable Entity"],
+  [423, "Locked"],
+  [424, "Failed Dependency"],
+  [425, "Too Early"],
+  [426, "Upgrade Required"],
+  [428, "Precondition Required"],
+  [429, "Too Many Requests"],
+  [431, "Request Header Fields Too Large"],
+  [451, "Unavailable For Legal Reasons"],
+  [500, "Internal Server Error"],
+  [501, "Not Implemented"],
+  [502, "Bad Gateway"],
+  [503, "Service Unavailable"],
+  [504, "Gateway Timeout"],
+  [505, "HTTP Version Not Supported"],
+  [506, "Variant Also Negotiates"],
+  [507, "Insufficient Storage"],
+  [508, "Loop Detected"],
+  [509, "Bandwidth Limit Exceeded"],
+  [510, "Not Extended"],
+  [511, "Network Authentication Required"]
+]);
+({
+  // status code to message map
+  message: codes,
+  // status message (lower-case) to code map
+  code: createMessageToStatusCodeMap(codes),
+  // array of status codes
+  codes: createStatusCodeList(codes),
+  // status codes for redirects
+  redirect: {
+    300: true,
+    301: true,
+    302: true,
+    303: true,
+    305: true,
+    307: true,
+    308: true
+  },
+  // status codes for empty bodies
+  empty: {
+    204: true,
+    205: true,
+    304: true
+  },
+  // status codes for when you should retry the request
+  retry: {
+    502: true,
+    503: true,
+    504: true
+  }
+});
+function createMessageToStatusCodeMap(codes2) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [status2, message] of codes2) {
+    map.set(message.toLowerCase(), status2);
+  }
+  return map;
+}
+function createStatusCodeList(codes2) {
+  const codeList = [];
+  for (const [status2, _] of codes2) {
+    codeList.push(status2);
+  }
+  return codeList;
+}
+const perToNum = (str = "") => {
+  if (str.length === 0) return 0;
+  if (str.endsWith("%")) {
+    const value = Number(str.replace("%", ""));
+    return value > 1 ? value / 100 : value;
+  } else {
+    return Number(str);
+  }
+};
+const range = (num, min = 0, max = 1) => {
+  return Math.min(max, Math.max(min, num));
+};
+const _Mathjs = class _Mathjs2 {
+  constructor() {
+    __publicField(this, "getDecimalLength", (n2) => {
+      const [_, decimal] = n2.toString().split(".");
+      return decimal ? decimal.length : 0;
+    });
+    __publicField(this, "amend", (n2, precision = 15) => parseFloat(Number(n2).toPrecision(precision)));
+    __publicField(this, "power", (a2, b2) => Math.pow(10, Math.max(this.getDecimalLength(a2), this.getDecimalLength(b2))));
+  }
+};
+__publicField(_Mathjs, "handleMethod", (l2, r2) => {
+  const mathjs2 = new _Mathjs();
+  const { power, amend } = mathjs2;
+  const pow = power(l2, r2);
+  const a2 = amend(l2 * pow);
+  const b2 = amend(r2 * pow);
+  return (type) => {
+    switch (type) {
+      case "+":
+        return (a2 + b2) / pow;
+      case "-":
+        return (a2 - b2) / pow;
+      case "*":
+        return a2 * b2 / (pow * pow);
+      case "/":
+        return a2 / b2;
+    }
+  };
+});
+__publicField(_Mathjs, "add", (a2, b2) => {
+  return _Mathjs.handleMethod(a2, b2)("+");
+});
+__publicField(_Mathjs, "divide", (a2, b2) => {
+  return _Mathjs.handleMethod(a2, b2)("/");
+});
+__publicField(_Mathjs, "multiply", (a2, b2) => {
+  return _Mathjs.handleMethod(a2, b2)("*");
+});
+__publicField(_Mathjs, "subtract", (a2, b2) => {
+  return _Mathjs.handleMethod(a2, b2)("-");
+});
+const NEW_LISTENER = "NEW_LISTENER";
+class SyncHook {
+  constructor() {
+    __publicField(this, "_events");
+    __publicField(this, "tap", (eventName, eventItem) => {
+      if (this._events[eventName] && eventName !== Symbol.for(NEW_LISTENER)) {
+        this.call(Symbol.for(NEW_LISTENER), eventName);
+      }
+      const callbacks = this._events[eventName] || [];
+      if (typeof eventItem === "function") {
+        callbacks.push({
+          name: eventName,
+          callback: eventItem
+        });
+      } else {
+        callbacks.push(eventItem);
+      }
+      this._events[eventName] = callbacks;
+      return this;
+    });
+    __publicField(this, "call", (eventName, ...args) => {
+      const callbacks = this._events[eventName] || [];
+      callbacks.forEach((item) => {
+        const { callback } = item;
+        callback(...args);
+      });
+    });
+    __publicField(this, "callSync", async (eventName, ...args) => {
+      const callbacks = this._events[eventName] || [];
+      for (const item of callbacks) {
+        const { callback } = item;
+        await callback(...args);
+      }
+    });
+    __publicField(this, "once", (eventName, eventItem) => {
+      let one;
+      if (typeof eventItem === "function") {
+        one = {
+          name: eventName,
+          callback: (...args) => {
+            eventItem(...args);
+            this.off(eventName, one);
+          },
+          initialCallback: eventItem
+        };
+      } else {
+        const { callback } = eventItem;
+        one = {
+          name: eventName,
+          callback: (...args) => {
+            callback(...args);
+            this.off(eventName, one);
+          },
+          initialCallback: callback
+        };
+      }
+      this.tap(eventName, one);
+      return this;
+    });
+    __publicField(this, "off", (eventName, eventItem) => {
+      const callbacks = this._events[eventName] || [];
+      const newCallbacks = callbacks.filter((item) => {
+        if (typeof eventItem === "function") {
+          return item.callback !== eventItem && item.initialCallback !== eventItem;
+        } else {
+          const { callback } = eventItem;
+          return item.callback !== callback && item.initialCallback !== callback;
+        }
+      });
+      this._events[eventName] = newCallbacks;
+      return this;
+    });
+    this._events = {};
+  }
+}
+const arrowDown = { "success": true, "_identification": true, "data": '<svg viewBox="0 0 1024 1024" width="200" height="200" version="1.1"\n    fill="currentColor" xmlns="http://www.w3.org/2000/svg">\n    <path\n        d="M884 256h-75c-5.1 0-9.9 2.5-12.9 6.6L512 654.2 227.9 262.6c-3-4.1-7.8-6.6-12.9-6.6h-75c-6.5 0-10.3 7.4-6.5 12.7l352.6 486.1c12.8 17.6 39 17.6 51.7 0l352.6-486.1c3.9-5.3.1-12.7-6.4-12.7z"></path>\n</svg>' };
+const arrowDown$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: arrowDown
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  SyncHook as S,
+  addClassToElement as a,
+  currentDevice as b,
+  create as c,
+  createDocumentFragment as d,
+  range as e,
+  generateThrottle as f,
+  getPixelRatio as g,
+  timestampToTime as h,
+  isMobile as i,
+  arrowDown$1 as j,
+  noop as n,
+  perToNum as p,
+  removeClassToElement as r,
+  timeFormat as t
+};

package/dist/button.js

@@ -0,0 +1,7 @@
+import { B, a } from "./index-C6RcMHoH.js";
+import "./arrow-down-B_hCY3Wt.js";
+import "./index-DC5EA657.js";
+export {
+  B as Button,
+  a as default
+};

package/dist/checkbox.js

@@ -0,0 +1,7 @@
+import { C, a } from "./index-1v568_nq.js";
+import "./arrow-down-B_hCY3Wt.js";
+import "./index-DC5EA657.js";
+export {
+  C as Checkbox,
+  a as default
+};

package/dist/colorpicker.js

@@ -0,0 +1,11 @@
+import "./arrow-down-B_hCY3Wt.js";
+import "./index-DC5EA657.js";
+import { C, a } from "./index-CiWwvEMM.js";
+import "./index-D4y9c1Dj.js";
+import "./index-WfFw4LJT.js";
+import "./selectShadowless.js";
+import "./index-15M0olqa.js";
+export {
+  C as ColorPicker,
+  a as default
+};