@vc-shell/framework 1.1.46 → 1.1.48

package/dist/vendor-cheerio-select-CVkYl3Z-.js

@@ -0,0 +1,191 @@
+import { _ as A, p as w } from "./vendor-css-select-CtIzVIiG.js";
+import { u as C, f as D, a as U, D as x } from "./vendor-domutils-D3Y2YQFR.js";
+import { b as F } from "./vendor-boolbase-Bgn9I6iN.js";
+import { p as E, i as y, S as p } from "./vendor-css-what-CZZaquJM.js";
+import { i as h } from "./vendor-domhandler-CL40eeX9.js";
+const O = /* @__PURE__ */ new Set([
+  "first",
+  "last",
+  "eq",
+  "gt",
+  "nth",
+  "lt",
+  "even",
+  "odd"
+]);
+function S(n) {
+  return n.type !== "pseudo" ? !1 : O.has(n.name) ? !0 : n.name === "not" && Array.isArray(n.data) ? n.data.some((t) => t.some(S)) : !1;
+}
+function R(n, t, e) {
+  const r = t != null ? parseInt(t, 10) : NaN;
+  switch (n) {
+    case "first":
+      return 1;
+    case "nth":
+    case "eq":
+      return isFinite(r) ? r >= 0 ? r + 1 : 1 / 0 : 0;
+    case "lt":
+      return isFinite(r) ? r >= 0 ? Math.min(r, e) : 1 / 0 : 0;
+    case "gt":
+      return isFinite(r) ? 1 / 0 : 0;
+    case "odd":
+      return 2 * e;
+    case "even":
+      return 2 * e - 1;
+    case "last":
+    case "not":
+      return 1 / 0;
+  }
+}
+function k(n) {
+  for (; n.parent; )
+    n = n.parent;
+  return n;
+}
+function N(n) {
+  const t = [], e = [];
+  for (const r of n)
+    r.some(S) ? t.push(r) : e.push(r);
+  return [e, t];
+}
+const z = {
+  type: p.Universal,
+  namespace: null
+}, B = {
+  type: p.Pseudo,
+  name: "scope",
+  data: null
+};
+function J(n, t, e = {}) {
+  return L([n], t, e);
+}
+function L(n, t, e = {}) {
+  if (typeof t == "function")
+    return n.some(t);
+  const [r, i] = N(E(t));
+  return r.length > 0 && n.some(A(r, e)) || i.some((s) => _(s, n, e).length > 0);
+}
+function M(n, t, e, r) {
+  const i = typeof e == "string" ? parseInt(e, 10) : NaN;
+  switch (n) {
+    case "first":
+    case "lt":
+      return t;
+    case "last":
+      return t.length > 0 ? [t[t.length - 1]] : t;
+    case "nth":
+    case "eq":
+      return isFinite(i) && Math.abs(i) < t.length ? [i < 0 ? t[t.length + i] : t[i]] : [];
+    case "gt":
+      return isFinite(i) ? t.slice(i + 1) : [];
+    case "even":
+      return t.filter((s, f) => f % 2 === 0);
+    case "odd":
+      return t.filter((s, f) => f % 2 === 1);
+    case "not": {
+      const s = new Set(T(e, t, r));
+      return t.filter((f) => !s.has(f));
+    }
+  }
+}
+function K(n, t, e = {}) {
+  return T(E(n), t, e);
+}
+function T(n, t, e) {
+  if (t.length === 0)
+    return [];
+  const [r, i] = N(n);
+  let s;
+  if (r.length) {
+    const f = I(t, r, e);
+    if (i.length === 0)
+      return f;
+    f.length && (s = new Set(f));
+  }
+  for (let f = 0; f < i.length && s?.size !== t.length; f++) {
+    const u = i[f];
+    if ((s ? t.filter((o) => h(o) && !s.has(o)) : t).length === 0)
+      break;
+    const a = _(u, t, e);
+    if (a.length)
+      if (s)
+        a.forEach((o) => s.add(o));
+      else {
+        if (f === i.length - 1)
+          return a;
+        s = new Set(a);
+      }
+  }
+  return typeof s < "u" ? s.size === t.length ? t : (
+    // Filter elements to preserve order
+    t.filter((f) => s.has(f))
+  ) : [];
+}
+function _(n, t, e) {
+  var r;
+  if (n.some(y)) {
+    const i = (r = e.root) !== null && r !== void 0 ? r : k(t[0]), s = { ...e, context: t, relativeSelector: !1 };
+    return n.push(B), m(i, n, s, !0, t.length);
+  }
+  return m(t, n, e, !1, t.length);
+}
+function Q(n, t, e = {}, r = 1 / 0) {
+  if (typeof n == "function")
+    return q(t, n);
+  const [i, s] = N(E(n)), f = s.map((u) => m(t, u, e, !0, r));
+  return i.length && f.push(v(t, i, e, r)), f.length === 0 ? [] : f.length === 1 ? f[0] : C(f.reduce((u, g) => [...u, ...g]));
+}
+function m(n, t, e, r, i) {
+  const s = t.findIndex(S), f = t.slice(0, s), u = t[s], g = t.length - 1 === s ? i : 1 / 0, a = R(u.name, u.data, g);
+  if (a === 0)
+    return [];
+  const P = (f.length === 0 && !Array.isArray(n) ? U(n).filter(h) : f.length === 0 ? (Array.isArray(n) ? n : [n]).filter(h) : r || f.some(y) ? v(n, [f], e, a) : I(n, [f], e)).slice(0, a);
+  let c = M(u.name, P, u.data, e);
+  if (c.length === 0 || t.length === s + 1)
+    return c;
+  const l = t.slice(s + 1), b = l.some(y);
+  if (b) {
+    if (y(l[0])) {
+      const { type: d } = l[0];
+      (d === p.Sibling || d === p.Adjacent) && (c = w(c, x, !0)), l.unshift(z);
+    }
+    e = {
+      ...e,
+      // Avoid absolutizing the selector
+      relativeSelector: !1,
+      /*
+       * Add a custom root func, to make sure traversals don't match elements
+       * that aren't a part of the considered tree.
+       */
+      rootFunc: (d) => c.includes(d)
+    };
+  } else e.rootFunc && e.rootFunc !== F.trueFunc && (e = { ...e, rootFunc: F.trueFunc });
+  return l.some(S) ? m(c, l, e, !1, i) : b ? (
+    // Query existing elements to resolve traversal.
+    v(c, [l], e, i)
+  ) : (
+    // If we don't have any more traversals, simply filter elements.
+    I(c, [l], e)
+  );
+}
+function v(n, t, e, r) {
+  const i = A(t, e, n);
+  return q(n, i, r);
+}
+function q(n, t, e = 1 / 0) {
+  const r = w(n, x, t.shouldTestNextSiblings);
+  return D((i) => h(i) && t(i), r, !0, e);
+}
+function I(n, t, e) {
+  const r = (Array.isArray(n) ? n : [n]).filter(h);
+  if (r.length === 0)
+    return r;
+  const i = A(t, e);
+  return i === F.trueFunc ? r : r.filter(i);
+}
+export {
+  L as a,
+  K as f,
+  J as i,
+  Q as s
+};