ranuts 0.4.1-alpha.2 → 0.5.1

package/dist/src/utils/canvas.js

@@ -0,0 +1,103 @@
+import { DEG_TO_RAD as m } from "./visual/math/enums.js";
+var p = (t) => m * t, T = (t, e) => [+(Math.cos(t) * e).toFixed(8), +(Math.sin(t) * e).toFixed(8)], A = (t, e) => {
+  const n = -t / e;
+  return [n, -n * t + e];
+}, I = (t, e, n, o, l) => {
+  t.beginPath();
+  const a = p(90 / Math.PI / e * l), d = n + a, s = o - a;
+  t.arc(0, 0, e, d, s, !1), t.lineTo(...T((n + o) / 2, l / 2 / Math.abs(Math.sin((n - o) / 2)))), t.closePath();
+}, b = (t, ...[e, n, o, l, a]) => {
+  const d = Math.min(o, l), s = Math.PI;
+  a > d / 2 && (a = d / 2), t.beginPath(), t.moveTo(e + a, n), t.lineTo(e + a, n), t.lineTo(e + o - a, n), t.arc(e + o - a, n + a, a, -s / 2, 0), t.lineTo(e + o, n + l - a), t.arc(e + o - a, n + l - a, a, 0, s / 2), t.lineTo(e + a, n + l), t.arc(e + a, n + l - a, a, s / 2, s), t.lineTo(e, n + a), t.arc(e + a, n + a, a, s, -s / 2), t.closePath();
+}, v = "linear-gradient(", P = (t) => {
+  const e = t.indexOf(v), n = t.lastIndexOf(")");
+  if (e === -1 || n <= e + 16) throw new TypeError("getLinearGradient: background must be a linear-gradient(...) value");
+  return t.slice(e + 16, n);
+}, G = (t, e, n, o, l, a) => {
+  const d = P(a).split(",").map((i) => i.trim());
+  let s = d.shift(), r = [
+    0,
+    0,
+    0,
+    0
+  ];
+  if (s.includes("deg")) {
+    const i = Number(s.slice(0, -3)) % 360;
+    s = `${i}`;
+    const f = (c) => Math.tan(c / 180 * Math.PI);
+    i >= 0 && i < 45 ? r = [
+      e,
+      n + l,
+      e + o,
+      n + l - o * f(i - 0)
+    ] : i >= 45 && i < 90 ? r = [
+      e,
+      n + l,
+      e + o - l * f(i - 45),
+      n
+    ] : i >= 90 && i < 135 ? r = [
+      e + o,
+      n + l,
+      e + o - l * f(i - 90),
+      n
+    ] : i >= 135 && i < 180 ? r = [
+      e + o,
+      n + l,
+      e,
+      n + o * f(i - 135)
+    ] : i >= 180 && i < 225 ? r = [
+      e + o,
+      n,
+      e,
+      n + o * f(i - 180)
+    ] : i >= 225 && i < 270 ? r = [
+      e + o,
+      n,
+      e + l * f(i - 225),
+      n + l
+    ] : i >= 270 && i < 315 ? r = [
+      e,
+      n,
+      e + l * f(i - 270),
+      n + l
+    ] : i >= 315 && i < 360 && (r = [
+      e,
+      n,
+      e + o,
+      n + l - o * f(i - 315)
+    ]);
+  } else s.includes("top") ? r = [
+    e,
+    n + l,
+    e,
+    n
+  ] : s.includes("bottom") ? r = [
+    e,
+    n,
+    e,
+    n + l
+  ] : s.includes("left") ? r = [
+    e + o,
+    n,
+    e,
+    n
+  ] : s.includes("right") && (r = [
+    e,
+    n,
+    e + o,
+    n
+  ]);
+  const u = t.createLinearGradient(...r.map((i) => i >> 0));
+  return d.reduce((i, f, c) => {
+    const g = f.split(" ");
+    return g.length === 1 ? i.addColorStop(c, g[0]) : g.length === 2 && i.addColorStop(Number(g[1]), g[0]), i;
+  }, u);
+};
+export {
+  I as fanShapedByArc,
+  p as getAngle,
+  T as getArcPointerByDeg,
+  G as getLinearGradient,
+  A as getTangentByPointer,
+  b as roundRectByArc
+};

package/dist/src/utils/chain.js

@@ -0,0 +1,76 @@
+var a = "http://www.w3.org/2000/svg", h = [
+  "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"
+], o = class i {
+  listener;
+  element;
+  constructor(e, t) {
+    this.element = this.create(e, t), this.listener = /* @__PURE__ */ new Map();
+  }
+  create = (e, t) => h.includes(e) ? document.createElementNS(a, e, t) : document.createElement(e, t);
+  setAttribute = (e, t) => (this.element.setAttribute(e, t), this);
+  removeAttribute = (e) => (this.element.removeAttribute(e), this);
+  append = (e) => (this.element.appendChild(e), this);
+  remove = (e) => (this.element.removeChild(e), this);
+  setTextContent = (e) => (this.element.textContent = e, this);
+  setStyle = (e, t) => (this.element.style.setProperty(e, t), this);
+  addElementByType = (e, t) => {
+    e instanceof i && t.appendChild(e.element), e instanceof HTMLElement && t.appendChild(e);
+  };
+  addChild = (e) => {
+    if (Array.isArray(e)) {
+      const t = document.createDocumentFragment();
+      e.forEach((r) => {
+        this.addElementByType(r, t);
+      }), this.element.appendChild(t);
+    } else this.addElementByType(e, this.element);
+    return this;
+  };
+  listen = (e, t, r) => {
+    let n = this.listener.get(e);
+    n || (n = /* @__PURE__ */ new Map(), this.listener.set(e, n));
+    const s = n.get(t.name);
+    return s === t && console.warn(`${s.name} listener has been added to ${e} event, please remove it first.`), this.element.addEventListener(e, t, r), n.set(t.name, t), this;
+  };
+  clearListener = (e, t, r) => {
+    this.element.removeEventListener(e, t, r);
+    const n = this.listener.get(e);
+    return n ? n.delete(t.name) : console.warn(`No ${e} event listener has been added.`), this;
+  };
+  clearAllListener = () => {
+    for (const [e, t] of this.listener) {
+      for (const [r, n] of t)
+        this.element.removeEventListener(e, n), t.delete(r);
+      this.listener.delete(e);
+    }
+    return this;
+  };
+}, d = (l, e) => new o(l, e);
+export {
+  o as Chain,
+  d as create
+};

package/dist/src/utils/charset.d.ts

@@ -0,0 +1,15 @@
+export declare const checkEncoding: (uint8Array: Uint8Array) => string;
+/**
+ * @description: Decode bytes into a string using the sniffed encoding. Required when reading
+ * text files of unknown provenance (a user-uploaded txt, content scraped off an old site) —
+ * a plain `new TextDecoder().decode()` turns GBK/Big5 into mojibake, and such files are a
+ * sizeable share of Chinese-language content.
+ * @param {ArrayBuffer | Uint8Array} buffer
+ * @return {string}
+ */
+export declare const arrayBufferToString: (buffer: ArrayBuffer | Uint8Array) => string;
+export interface TransformText {
+    encoding: string;
+    content: string;
+}
+export declare const transformText: (content: string | ArrayBuffer) => TransformText | undefined;

package/dist/src/utils/charset.js

@@ -0,0 +1,21 @@
+import { detect as i } from "jschardet";
+var a = (n) => {
+  const r = Array.from(n).map((e) => String.fromCharCode(e)).join("");
+  return i(r).encoding || "utf-8";
+}, g = (n) => {
+  const r = n instanceof Uint8Array ? n : new Uint8Array(n);
+  return new TextDecoder(a(r)).decode(r);
+}, s = (n) => {
+  if (n instanceof ArrayBuffer) {
+    const r = new Uint8Array(n), e = String.fromCharCode.apply(null, r), t = i(e), c = t.encoding || "utf-8", o = new TextDecoder(c).decode(n);
+    if (t.encoding && o) return {
+      encoding: t.encoding,
+      content: o
+    };
+  }
+};
+export {
+  g as arrayBufferToString,
+  a as checkEncoding,
+  s as transformText
+};

package/dist/src/utils/color.d.ts

@@ -1,4 +1,3 @@
-export declare const FMT: Record<string, Array<string>>;
 type ColorVal = (string | number)[];
 export declare class Rgb {
     r: string | number;

package/dist/src/utils/color.js

@@ -0,0 +1,312 @@
+var u = Math.round, p = class {
+  r;
+  g;
+  b;
+  constructor(t) {
+    this.r = t[0], this.g = t[1], this.b = t[2];
+  }
+  toString() {
+    return `rgb(${this.r},${this.g},${this.b})`;
+  }
+}, R = class extends p {
+  a;
+  constructor(t) {
+    super(t), this.a = t[3];
+  }
+  toString() {
+    return `rgba(${this.r},${this.g},${this.b},${this.a})`;
+  }
+}, H = class {
+  h;
+  s;
+  l;
+  constructor(t) {
+    this.h = t[0], this.s = t[1], this.l = t[2];
+  }
+  toString() {
+    return `hsl(${this.h},${this.s}%,${this.l}%)`;
+  }
+}, w = class extends H {
+  a;
+  constructor(t) {
+    super(t), this.a = t[3];
+  }
+  toString() {
+    return `hsla(${this.h},${this.s}%,${this.l}%,${this.a})`;
+  }
+}, c = class {
+  r;
+  g;
+  b;
+  a;
+  rgb;
+  rgba;
+  hex;
+  hsl;
+  hsla;
+  h;
+  s;
+  l;
+  constructor(t, s = 0, r = 0, i = 1) {
+    if (typeof t == "string") {
+      let e = t;
+      e.charAt(0) !== "#" && (e = "#" + e), e.length < 7 && (e = "#" + e[1] + e[1] + e[2] + e[2] + e[3] + e[3]);
+      const a = $(e);
+      a && ([t, s, r] = a);
+    } else t instanceof Array && (i = t[3] || i, r = t[2], s = t[1], t = t[0]);
+    this.r = Number(t), this.g = Number(s), this.b = Number(r), this.a = i, this.rgb = new p([
+      this.r,
+      this.g,
+      this.b
+    ]), this.rgba = new R([
+      this.r,
+      this.g,
+      this.b,
+      this.a
+    ]), this.hex = v(this.r, this.g, this.b), this.hsl = new H(x(this.r, this.g, this.b)), this.h = this.hsl.h, this.s = this.hsl.s, this.l = this.hsl.l, this.hsla = new w([
+      this.h,
+      this.s,
+      this.l,
+      this.a
+    ]);
+  }
+  setHue(t) {
+    this.h = t, this.hsl.h = t, this.hsla.h = t, this.updateFromHsl();
+  }
+  setSat(t) {
+    this.s = t, this.hsl.s = t, this.hsla.s = t, this.updateFromHsl();
+  }
+  setLum(t) {
+    this.l = t, this.hsl.l = t, this.hsla.l = t, this.updateFromHsl();
+  }
+  setAlpha(t) {
+    this.a = t, this.hsla.a = t, this.rgba.a = t;
+  }
+  updateFromHsl() {
+    this.rgb = new p(m(this.h, this.s, this.l)), this.r = this.rgb.r, this.g = this.rgb.g, this.b = this.rgb.b, this.rgba.r = this.rgb.r, this.rgba.g = this.rgb.g, this.rgba.b = this.rgb.b, this.hex = v([
+      this.r,
+      this.g,
+      this.b
+    ]);
+  }
+}, C = function() {
+  const t = "#" + Math.random().toString(16).slice(2, 8);
+  return new c(t);
+}, $ = function(t) {
+  const s = t[0] === "#" ? t.slice(1) : t;
+  if (/^[a-f\d]{3}$/i.test(s)) return [
+    parseInt(s[0] + s[0], 16),
+    parseInt(s[1] + s[1], 16),
+    parseInt(s[2] + s[2], 16)
+  ];
+  const r = /^([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(s);
+  return r ? [
+    parseInt(r[1], 16),
+    parseInt(r[2], 16),
+    parseInt(r[3], 16)
+  ] : null;
+}, f = function(t) {
+  const s = t.toString(16);
+  return s.length === 1 ? "0" + s : s;
+}, v = function(t, s = 0, r = 0) {
+  return t instanceof Array && (r = t[2], s = t[1], t = t[0]), "#" + f(t) + f(s) + f(r);
+}, x = function(t, s = 0, r = 0) {
+  t instanceof Array && (r = t[2], s = t[1], t = t[0]);
+  let i, e, a, n = 0;
+  t /= 255, s /= 255, r /= 255;
+  const h = Math.max(t, s, r), o = Math.min(t, s, r);
+  if (e = (h + o) / 2, h === o) n = i = 0;
+  else {
+    switch (a = h - o, i = e > 0.5 ? a / (2 - h - o) : a / (h + o), h) {
+      case t:
+        n = (s - r) / a + (s < r ? 6 : 0);
+        break;
+      case s:
+        n = (r - t) / a + 2;
+        break;
+      case r:
+        n = (t - s) / a + 4;
+    }
+    n /= 6;
+  }
+  return n = u(n * 360), i = u(i * 100), e = u(e * 100), [
+    n,
+    i,
+    e
+  ];
+}, g = function(t, s, r) {
+  return r < 0 && (r += 1), r > 1 && (r -= 1), r < 1 / 6 ? t + (s - t) * 6 * r : r < 1 / 2 ? s : r < 2 / 3 ? t + (s - t) * (2 / 3 - r) * 6 : t;
+}, m = function(t, s, r) {
+  t instanceof Array && (r = t[2], s = t[1], t = t[0]), t = Number(t) / 360, s = Number(s) / 100, r = Number(r) / 100;
+  let i, e, a, n, h;
+  return s === 0 ? i = e = a = r : (n = r < 0.5 ? r * (1 + s) : r + s - r * s, h = 2 * r - n, i = g(h, n, t + 1 / 3), e = g(h, n, t), a = g(h, n, t - 1 / 3)), [
+    u(i * 255),
+    u(e * 255),
+    u(a * 255)
+  ];
+}, d = function(t, s, r) {
+  let i = 0, e, a;
+  t = t / 255, s = s / 255, r = r / 255;
+  const n = Math.max(t, s, r), h = Math.min(t, s, r);
+  a = n;
+  const o = n - h;
+  if (e = n === 0 ? 0 : o / n, n === h) i = 0;
+  else {
+    switch (n) {
+      case t:
+        i = (s - r) / o + (s < r ? 6 : 0);
+        break;
+      case s:
+        i = (r - t) / o + 2;
+        break;
+      case r:
+        i = (t - s) / o + 4;
+    }
+    i /= 6;
+  }
+  return i = u(i * 360), e = u(e * 100), a = u(a * 100), [
+    i,
+    e,
+    a
+  ];
+}, M = function(t, s, r) {
+  let i = 0, e = 0, a = 0;
+  if (r === 0) return [
+    0,
+    0,
+    0
+  ];
+  s = s / 100, r = r / 100, t = t / 60;
+  const n = Math.floor(t), h = t - n, o = r * (1 - s), l = r * (1 - s * h), b = r * (1 - s * (1 - h));
+  return n === 0 ? (i = r, e = b, a = o) : n === 1 ? (i = l, e = r, a = o) : n === 2 ? (i = o, e = r, a = b) : n === 3 ? (i = o, e = l, a = r) : n === 4 ? (i = b, e = o, a = r) : n === 5 && (i = r, e = o, a = l), i = u(i * 255), e = u(e * 255), a = u(a * 255), [
+    i,
+    e,
+    a
+  ];
+}, F = M, S = function(t, s, r) {
+  return x(M(t, s, r));
+}, I = S, E = d, y = function(t) {
+  const s = $(t);
+  return s ? d(s[0], s[1], s[2]) : null;
+}, O = y, N = function(t, s, r) {
+  const [i, e, a] = m(t, s, r);
+  return d(i, e, a);
+}, G = N, k = function(t) {
+  return u(parseInt(t, 16) / 255 * 100);
+}, P = function(t, s, r, i) {
+  return "rgba(" + [
+    t,
+    s,
+    r,
+    i / 100
+  ].join(",") + ")";
+}, A = function(t, s, r, i) {
+  const e = i / 100;
+  return [
+    Math.trunc((1 - e) * 255 + e * t),
+    Math.trunc((1 - e) * 255 + e * s),
+    Math.trunc((1 - e) * 255 + e * r)
+  ];
+}, X = function(t, s, r, i) {
+  const e = A(t, s, r, i);
+  return v(e[0], e[1], e[2]);
+}, _ = /^#([\da-f]{6}|[\da-f]{3})$/i, j = /^rgb\((\d{1,3}),(\d{1,3}),(\d{1,3})\)$/, B = /^rgba\((\d{1,3}),(\d{1,3}),(\d{1,3}),(\d{1,3}(\.\d+)?)\)$/, L = class {
+  palette;
+  constructor(t, s) {
+    this.palette = [], s === void 0 && t instanceof Array ? this.createFromColors(t) : this.createFromAngles(t, s);
+  }
+  createFromColors(t) {
+    for (const s in t) Object.prototype.hasOwnProperty.call(t, s) && this.palette.push(new c(t[s]));
+    return this.palette;
+  }
+  createFromAngles(t, s) {
+    this.palette.push(new c(t));
+    for (const r in s) if (Object.prototype.hasOwnProperty.call(s, r)) {
+      const i = (Number(this.palette[0].h) + s[r]) % 360;
+      this.palette.push(new c(m(i, Number(this.palette[0].s), Number(this.palette[0].l))));
+    }
+    return this.palette;
+  }
+  static Compl(t) {
+    return new this(t, [180]);
+  }
+  static Triad(t) {
+    return new this(t, [120, 240]);
+  }
+  static Tetrad(t) {
+    return new this(t, [
+      60,
+      180,
+      240
+    ]);
+  }
+  static Analog(t) {
+    return new this(t, [-45, 45]);
+  }
+  static Split(t) {
+    return new this(t, [150, 210]);
+  }
+  static Accent(t) {
+    return new this(t, [
+      -45,
+      45,
+      180
+    ]);
+  }
+}, q = (t) => t <= 0.04045 ? t / 12.92 : ((t + 0.055) / 1.055) ** 2.4, z = (t) => t <= 31308e-7 ? t * 12.92 : 1.055 * t ** (1 / 2.4) - 0.055, D = (t, s, r) => 0.299 * t + 0.587 * s + 0.114 * r, T = (t, s, r) => [
+  r(t[0], s[0]),
+  r(t[1], s[1]),
+  r(t[2], s[2])
+], J = (t, s) => T(t, s, (r, i) => 1 - (1 - r) * (1 - i)), K = (t, s) => T(t, s, (r, i) => r * i), Q = (t, s) => T(t, s, (r, i) => r < 0.5 ? 2 * r * i : 1 - 2 * (1 - r) * (1 - i)), U = (t, s, r) => t.map((i) => (i - 0.5) * r + 0.5 + s), W = (t, s) => {
+  const r = 0.2125 * t[0] + 0.7154 * t[1] + 0.0721 * t[2];
+  return t.map((i) => r + (i - r) * s);
+}, Y = (t, s) => {
+  const r = (t[0] + t[1] + t[2]) / 3, i = Math.max(t[0], t[1], t[2]), e = (i - r) * (-s * 3);
+  return t.map((a) => a + (i - a) * e);
+}, Z = (t, s, r, i, e) => [
+  0,
+  1,
+  2
+].map((a) => s[a] + r[a] * Math.cos(2 * Math.PI * (i[a] * t + e[a])));
+export {
+  c as Color,
+  L as ColorScheme,
+  _ as HEX_COLOR_REGEX,
+  H as Hsl,
+  w as Hsla,
+  B as RGBA_REGEX,
+  j as RGB_REGEX,
+  p as Rgb,
+  R as Rgba,
+  K as blendMultiply,
+  Q as blendOverlay,
+  J as blendScreen,
+  U as brightnessContrast,
+  f as componentToHex,
+  Z as cosinePalette,
+  k as hexToAlpha,
+  y as hexToHsb,
+  O as hexToHsv,
+  $ as hexToRgb,
+  S as hsbToHsl,
+  M as hsbToRgb,
+  N as hslToHsb,
+  G as hslToHsv,
+  m as hslToRgb,
+  I as hsvToHsl,
+  F as hsvToRgb,
+  g as hue2rgb,
+  z as linearToSrgb,
+  D as luma,
+  C as randomColor,
+  v as rgbToHex,
+  d as rgbToHsb,
+  x as rgbToHsl,
+  E as rgbToHsv,
+  P as rgbaString,
+  X as rgbaToHex,
+  A as rgbaToRgb,
+  W as saturation,
+  q as srgbToLinear,
+  Y as vibrance
+};

package/dist/src/utils/compose.js

@@ -0,0 +1,22 @@
+function i(e) {
+  if (!Array.isArray(e)) throw new TypeError("Middleware stack must be an array!");
+  for (const t of e) if (typeof t != "function") throw new TypeError("Middleware must be composed of functions!");
+  return function(t, o) {
+    let f = -1;
+    return s(0);
+    function s(r) {
+      if (r <= f) return Promise.reject(/* @__PURE__ */ new Error("next() called multiple times"));
+      f = r;
+      let n = e[r];
+      if (r === e.length && o && (n = o), !n) return Promise.resolve();
+      try {
+        return Promise.resolve(n(t, s.bind(null, r + 1)));
+      } catch (c) {
+        return Promise.reject(c);
+      }
+    }
+  };
+}
+export {
+  i as compose
+};

package/dist/src/utils/console.js

@@ -0,0 +1,22 @@
+import { noop as e } from "./noop.js";
+import { replaceOld as i } from "./obj.js";
+var p = [
+  "log",
+  "info",
+  "warn",
+  "error",
+  "assert"
+], s = (t = e) => {
+  if (typeof console > "u") return e;
+  const f = p.map((o) => i(console, o, (r) => {
+    if (typeof r != "function") return;
+    const c = r;
+    return function(...n) {
+      t(o, ...n), c.apply(console, n);
+    };
+  }));
+  return () => f.forEach((o) => o());
+};
+export {
+  s as handleConsole
+};

package/dist/src/utils/debounce.js

@@ -0,0 +1,18 @@
+var s = (o, r = 500) => {
+  let l = null, e, n = null;
+  const i = () => {
+    if (l = null, !n) return;
+    const u = n, c = e;
+    n = null, e = void 0, o.apply(c, u);
+  }, t = function(...u) {
+    e = this, n = u, l !== null && clearTimeout(l), l = setTimeout(i, r);
+  };
+  return t.cancel = () => {
+    l !== null && clearTimeout(l), l = null, n = null, e = void 0;
+  }, t.flush = () => {
+    l !== null && (clearTimeout(l), i());
+  }, t.pending = () => l !== null, t;
+};
+export {
+  s as debounce
+};

package/dist/src/utils/device.d.ts

@@ -11,15 +11,6 @@ export declare enum DEVICE {
 }
 export type CurrentDevice = 'ipad' | 'android' | 'iphone' | 'pc';
 export declare const currentDevice: () => CurrentDevice;
-/**
- * @description: Whether a `window` existed **when this module was first imported**.
- *
- * @deprecated Evaluated once at module load, so it is stuck at `false` for the life of the
- * process in any SSR-then-hydrate flow, and cannot be stubbed in a test. New code checks
- * `typeof window === 'undefined'` inside the function that needs it. Kept exported so
- * existing callers keep compiling.
- */
-export declare const isClient: boolean;
 /** Viewport breakpoint, matching where the mobile layout takes over */
 export declare const MOBILE_MEDIA_QUERY = "(max-width: 768px)";
 /**

package/dist/src/utils/device.js

@@ -0,0 +1,31 @@
+var o = /* @__PURE__ */ (function(e) {
+  return e.IPAD = "ipad", e.ANDROID = "android", e.IPhONE = "iphone", e.PC = "pc", e;
+})({}), d = () => {
+  if (typeof window < "u") {
+    const e = navigator.userAgent.toLowerCase();
+    return /ipad|ipod/.test(e) ? "ipad" : /android/.test(e) ? "android" : /iphone/.test(e) ? "iphone" : "pc";
+  }
+  return "pc";
+}, a = () => typeof window < "u", u = "(max-width: 768px)", s = (e) => typeof window > "u" || typeof window.matchMedia != "function" ? !1 : window.matchMedia(e).matches, f = (e, t) => {
+  if (typeof window > "u" || typeof window.matchMedia != "function")
+    return t(!1), () => {
+    };
+  const n = window.matchMedia(e), r = () => t(n.matches);
+  if (r(), typeof n.addEventListener == "function")
+    return n.addEventListener("change", r), () => n.removeEventListener("change", r);
+  const i = n;
+  return i.addListener(r), () => i.removeListener(r);
+}, c = () => a() ? window.navigator.userAgent.toLowerCase().includes("micromessenger") : !1, w = () => {
+  if (!a()) return !1;
+  const e = window.navigator.userAgent;
+  return !!/Android|webOS|iPhone|iPod|iPad|BlackBerry/i.test(e);
+};
+export {
+  o as DEVICE,
+  u as MOBILE_MEDIA_QUERY,
+  d as currentDevice,
+  w as isMobile,
+  c as isWeiXin,
+  s as matchMediaQuery,
+  f as watchMediaQuery
+};