@uiw/react-md-editor 3.20.1 → 3.20.2

package/dist/mdeditor.js

@@ -9661,9 +9661,7 @@ function _iterableToArrayLimit(arr, i) {
       if (_x = (_i = _i.call(arr)).next, 0 === i) {
         if (Object(_i) !== _i) return;
         _n = !1;
-      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0) {
-        ;
-      }
+      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
     } catch (err) {
       _d = !0, _e = err;
     } finally {
@@ -9679,9 +9677,7 @@ function _iterableToArrayLimit(arr, i) {
 ;// CONCATENATED MODULE: ../node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js
 function _arrayLikeToArray(arr, len) {
   if (len == null || len > arr.length) len = arr.length;
-  for (var i = 0, arr2 = new Array(len); i < len; i++) {
-    arr2[i] = arr[i];
-  }
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
   return arr2;
 }
 ;// CONCATENATED MODULE: ../node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
@@ -31389,7 +31385,7 @@ function rehypeAutolinkHeadings(options = {}) {
 }
 
 ;// CONCATENATED MODULE: ../node_modules/rehype-attr/lib/utils.js
-const getURLParameters = (url) => (url.match(/([^?=&]+)(=([^&]*))/g) || []).reduce((a, v) => ((a[v.slice(0, v.indexOf('='))] = v.slice(v.indexOf('=') + 1)), a), {});
+const getURLParameters = (url = '') => (url.match(/([^?=&]+)(=([^&]*))/g) || []).reduce((a, v) => ((a[v.slice(0, v.indexOf('='))] = v.slice(v.indexOf('=') + 1)), a), {});
 const prevChild = (data = [], index) => {
     let i = index;
     while (i > -1) {
@@ -31420,8 +31416,8 @@ const nextChild = (data = [], index, tagName, codeBlockParames) => {
                 return;
             if (element.type === 'text' && element.value.replace(/(\n|\s)/g, '') !== '')
                 return;
-            if (/^(comment|raw)$/ig.test(element?.type)) {
-                if (!/^rehype:/.test(element.value?.replace(/^(\s+)?<!--(.*?)-->/, '$2') || '')) {
+            if (element.type && /^(comment|raw)$/ig.test(element.type)) {
+                if (element.value && !/^rehype:/.test(element.value.replace(/^(\s+)?<!--(.*?)-->/, '$2') || '')) {
                     return;
                 }
                 ;
@@ -31429,11 +31425,11 @@ const nextChild = (data = [], index, tagName, codeBlockParames) => {
                     const nextNode = nextChild(data, i, 'pre', codeBlockParames);
                     if (nextNode)
                         return;
-                    element.value = element.value?.replace(/^(\n|\s)+/, '');
+                    element.value = (element.value || '').replace(/^(\n|\s)+/, '');
                     return element;
                 }
                 else {
-                    element.value = element.value?.replace(/^(\n|\s)+/, '');
+                    element.value = (element.value || '').replace(/^(\n|\s)+/, '');
                     return element;
                 }
             }
@@ -58435,36 +58431,13 @@ function direction(value) {
   return rtl.test(source) ? 'rtl' : ltr.test(source) ? 'ltr' : 'neutral'
 }
 
-;// CONCATENATED MODULE: ../node_modules/hast-util-select/lib/util.js
-/**
- * @typedef {import('./types.js').Node} Node
- * @typedef {import('./types.js').Element} Element
- * @typedef {import('./types.js').Parent} Parent
- * @typedef {import('hast-util-is-element').AssertPredicate<Element>} IsElement
- */
-
-
-
-/**
- * @param {Node} node
- * @returns {node is Parent}
- */
-function util_parent(node) {
-  // @ts-expect-error: hush.
-  return Array.isArray(node.children)
-}
-
-/** @type {IsElement} */
-// @ts-expect-error it works.
-const util_element = convertElement()
-
 ;// CONCATENATED MODULE: ../node_modules/hast-util-select/lib/enter-state.js
 /**
  * @typedef {import('./types.js').SelectState} SelectState
- * @typedef {import('./types.js').HastNode} HastNode
+ * @typedef {import('./types.js').Node} Node
  * @typedef {import('./types.js').ElementChild} ElementChild
  * @typedef {import('./types.js').Direction} Direction
- * @typedef {import('unist-util-visit/complex-types').Visitor<ElementChild>} Visitor
+ * @typedef {import('unist-util-visit/complex-types.js').Visitor<ElementChild>} Visitor
  */
 
 
@@ -58472,12 +58445,19 @@ const util_element = convertElement()
 
 
 
-
-
 /**
+ * Enter a node.
+ *
+ * The caller is responsible for calling the return value `exit`.
+ *
  * @param {SelectState} state
- * @param {HastNode} node
+ *   Current state.
+ *
+ *   Will be mutated: `exit` undos the changes.
+ * @param {Node} node
+ *   Node to enter.
  * @returns {() => void}
+ *   Call to exit.
  */
 // eslint-disable-next-line complexity
 function enterState(state, node) {
@@ -58485,30 +58465,25 @@ function enterState(state, node) {
   const language = state.language
   const currentDirection = state.direction
   const editableOrEditingHost = state.editableOrEditingHost
-  /** @type {Direction|undefined} */
+  /** @type {Direction | undefined} */
   let dirInferred
-  /** @type {boolean|undefined} */
-  let found
 
-  if (util_element(node) && node.properties) {
+  if (node.type === 'element' && node.properties) {
     const lang = node.properties.xmlLang || node.properties.lang
     const type = node.properties.type || 'text'
     const dir = dirProperty(node)
 
     if (lang !== undefined && lang !== null) {
       state.language = String(lang)
-      found = true
     }
 
     if (schema && schema.space === 'html') {
       if (node.properties.contentEditable === 'true') {
         state.editableOrEditingHost = true
-        found = true
       }
 
-      if (isElement(node, 'svg')) {
+      if (node.tagName === 'svg') {
         state.schema = property_information_svg
-        found = true
       }
 
       // See: <https://html.spec.whatwg.org/#the-directionality>.
@@ -58519,25 +58494,24 @@ function enterState(state, node) {
         // Explicit `[dir=ltr]`.
         dir === 'ltr' ||
         // HTML with an invalid or no `[dir]`.
-        (dir !== 'auto' && isElement(node, 'html')) ||
+        (dir !== 'auto' && node.tagName === 'html') ||
         // `input[type=tel]` with an invalid or no `[dir]`.
-        (dir !== 'auto' && isElement(node, 'input') && type === 'tel')
+        (dir !== 'auto' && node.tagName === 'input' && type === 'tel')
       ) {
         dirInferred = 'ltr'
         // `[dir=auto]` or `bdi` with an invalid or no `[dir]`.
-      } else if (dir === 'auto' || isElement(node, 'bdi')) {
-        if (isElement(node, 'textarea')) {
+      } else if (dir === 'auto' || node.tagName === 'bdi') {
+        if (node.tagName === 'textarea') {
           // Check contents of `<textarea>`.
           dirInferred = dirBidi(hast_util_to_string_toString(node))
         } else if (
-          isElement(node, 'input') &&
+          node.tagName === 'input' &&
           (type === 'email' ||
             type === 'search' ||
             type === 'tel' ||
             type === 'text')
         ) {
           // Check value of `<input>`.
-          // @ts-expect-error something is `never` in types but this is needed.
           dirInferred = node.properties.value
             ? // @ts-expect-error Assume string
               dirBidi(node.properties.value)
@@ -58550,17 +58524,15 @@ function enterState(state, node) {
 
       if (dirInferred) {
         state.direction = dirInferred
-        found = true
       }
     }
     // Turn off editing mode in non-HTML spaces.
     else if (state.editableOrEditingHost) {
       state.editableOrEditingHost = false
-      found = true
     }
   }
 
-  return found ? reset : noop
+  return reset
 
   function reset() {
     state.schema = schema
@@ -58573,12 +58545,16 @@ function enterState(state, node) {
   function inferDirectionality(child) {
     if (child.type === 'text') {
       dirInferred = dirBidi(child.value)
-      return dirInferred ? EXIT : null
+      return dirInferred ? EXIT : undefined
     }
 
     if (
       child !== node &&
-      (isElement(child, ['bdi', 'script', 'style', 'textare']) ||
+      child.type === 'element' &&
+      (child.tagName === 'bdi' ||
+        child.tagName === 'script' ||
+        child.tagName === 'style' ||
+        child.tagName === 'textare' ||
         dirProperty(child))
     ) {
       return SKIP
@@ -58588,7 +58564,7 @@ function enterState(state, node) {
 
 /**
  * @param {string} value
- * @returns {Direction|undefined}
+ * @returns {Direction | undefined}
  */
 function dirBidi(value) {
   const result = direction(value)
@@ -58597,11 +58573,13 @@ function dirBidi(value) {
 
 /**
  * @param {ElementChild} node
- * @returns {Direction|undefined}
+ * @returns {Direction | undefined}
  */
 function dirProperty(node) {
   const value =
-    util_element(node) && node.properties && typeof node.properties.dir === 'string'
+    node.type === 'element' &&
+    node.properties &&
+    typeof node.properties.dir === 'string'
       ? node.properties.dir.toLowerCase()
       : undefined
 
@@ -58610,231 +58588,297 @@ function dirProperty(node) {
     : undefined
 }
 
-function noop() {}
-
-;// CONCATENATED MODULE: ../node_modules/hast-util-select/lib/nest.js
+;// CONCATENATED MODULE: ../node_modules/hast-util-select/lib/attribute.js
 /**
  * @typedef {import('./types.js').Rule} Rule
- * @typedef {import('./types.js').Node} Node
+ * @typedef {import('./types.js').RuleAttr} RuleAttr
  * @typedef {import('./types.js').Element} Element
- * @typedef {import('./types.js').Parent} Parent
- * @typedef {import('./types.js').SelectState} SelectState
- * @typedef {import('./types.js').SelectIterator} SelectIterator
- * @typedef {import('./types.js').Handler} Handler
+ * @typedef {import('./types.js').Schema} Schema
+ * @typedef {import('./types.js').Info} Info
+ * @typedef {import('./types.js').PropertyValue} PropertyValue
  */
 
 
 
 
 
-const nest_own = {}.hasOwnProperty
 
-const handle = zwitch('nestingOperator', {
-  // @ts-expect-error: hush.
-  unknown: unknownNesting,
+
+/** @type {(query: RuleAttr, element: Element, info: Info) => boolean} */
+const handle = zwitch('operator', {
+  unknown: unknownOperator,
   // @ts-expect-error: hush.
-  invalid: topScan, // `undefined` is the top query selector.
+  invalid: exists,
   handlers: {
-    // @ts-expect-error: hush.
-    null: descendant, // `null` is the descendant combinator.
-    // @ts-expect-error: hush.
-    '>': child,
-    // @ts-expect-error: hush.
-    '+': adjacentSibling,
-    // @ts-expect-error: hush.
-    '~': generalSibling
+    '=': exact,
+    '~=': spaceSeparatedList,
+    '|=': exactOrPrefix,
+    '^=': begins,
+    '$=': ends,
+    '*=': contains
   }
 })
 
-/** @type {Handler} */
-function nest(query, node, index, parent, state) {
-  handle(query, node, index, parent, state)
-}
-
-// Shouldn’t be called, parser gives correct data.
-/* c8 ignore next 6 */
 /**
- * @param {{[x: string]: unknown, type: string}} query
+ * @param {Rule} query
+ * @param {Element} element
+ * @param {Schema} schema
+ * @returns {boolean}
  */
-function unknownNesting(query) {
-  throw new Error('Unexpected nesting `' + query.nestingOperator + '`')
-}
+function attribute(query, element, schema) {
+  const attrs = query.attrs
+  let index = -1
 
-/** @type {Handler} */
-function topScan(query, node, index, parent, state) {
-  // Shouldn’t happen.
-  /* c8 ignore next 3 */
-  if (parent || index === null) {
-    throw new Error('topScan is supposed to be called from the root node')
+  while (++index < attrs.length) {
+    if (!handle(attrs[index], element, find(schema, attrs[index].name))) {
+      return false
+    }
   }
 
-  // Shouldn’t happen.
-  /* c8 ignore next 3 */
-  if (!state.iterator) {
-    throw new Error('Expected `iterator`')
-  }
+  return true
+}
 
-  state.iterator(query, node, index, parent, state)
-  if (!state.shallow) descendant(query, node, index, parent, state)
+/**
+ * Check whether an attribute exists.
+ *
+ * `[attr]`
+ *
+ * @param {RuleAttr} _
+ * @param {Element} element
+ * @param {Info} info
+ * @returns {boolean}
+ */
+function exists(_, element, info) {
+  return hasProperty(element, info.property)
 }
 
-/** @type {Handler} */
-function descendant(query, node, index, parent, state) {
-  const previous = state.iterator
+/**
+ * Check whether an attribute has an exact value.
+ *
+ * `[attr=value]`
+ *
+ * @param {RuleAttr} query
+ * @param {Element} element
+ * @param {Info} info
+ * @returns {boolean}
+ */
+function exact(query, element, info) {
+  return Boolean(
+    hasProperty(element, info.property) &&
+      element.properties &&
+      normalizeValue(element.properties[info.property], info) === query.value
+  )
+}
 
-  state.iterator = iterator
-  child(query, node, index, parent, state)
+/**
+ * Check whether an attribute, interpreted as a space-separated list, contains
+ * a value.
+ *
+ * `[attr~=value]`
+ *
+ * @param {RuleAttr} query
+ * @param {Element} element
+ * @param {Info} info
+ * @returns {boolean}
+ */
+function spaceSeparatedList(query, element, info) {
+  const value = element.properties && element.properties[info.property]
 
-  /** @type {SelectIterator} */
-  function iterator(query, node, index, parent, state) {
-    // Shouldn’t happen.
-    /* c8 ignore next 3 */
-    if (!previous) {
-      throw new Error('Expected `iterator`')
-    }
+  return (
+    // If this is a space-separated list, and the query is contained in it, return
+    // true.
+    (!info.commaSeparated &&
+      value &&
+      typeof value === 'object' &&
+      query.value &&
+      value.includes(query.value)) ||
+    // For all other values (including comma-separated lists), return whether this
+    // is an exact match.
+    (hasProperty(element, info.property) &&
+      normalizeValue(value, info) === query.value)
+  )
+}
 
-    state.iterator = previous
-    previous(query, node, index, parent, state)
-    state.iterator = iterator
+/**
+ * Check whether an attribute has a substring as either the exact value or a
+ * prefix.
+ *
+ * `[attr|=value]`
+ *
+ * @param {RuleAttr} query
+ * @param {Element} element
+ * @param {Info} info
+ * @returns {boolean}
+ */
+function exactOrPrefix(query, element, info) {
+  const value = normalizeValue(
+    element.properties && element.properties[info.property],
+    info
+  )
 
-    if (state.one && state.found) return
+  return Boolean(
+    hasProperty(element, info.property) &&
+      query.value &&
+      (value === query.value ||
+        (value.slice(0, query.value.length) === query.value &&
+          value.charAt(query.value.length) === '-'))
+  )
+}
 
-    child(query, node, index, parent, state)
-  }
+/**
+ * Check whether an attribute has a substring as its start.
+ *
+ * `[attr^=value]`
+ *
+ * @param {RuleAttr} query
+ * @param {Element} element
+ * @param {Info} info
+ * @returns {boolean}
+ */
+function begins(query, element, info) {
+  return Boolean(
+    hasProperty(element, info.property) &&
+      element.properties &&
+      query.value &&
+      normalizeValue(element.properties[info.property], info).slice(
+        0,
+        query.value.length
+      ) === query.value
+  )
 }
 
-/** @type {Handler} */
-function child(query, node, _1, _2, state) {
-  if (!util_parent(node)) return
-  if (node.children.length === 0) return
-  indexedSearch(query, node, state)
+/**
+ * Check whether an attribute has a substring as its end.
+ *
+ * `[attr$=value]`
+ *
+ * @param {RuleAttr} query
+ * @param {Element} element
+ * @param {Info} info
+ * @returns {boolean}
+ */
+function ends(query, element, info) {
+  return Boolean(
+    hasProperty(element, info.property) &&
+      element.properties &&
+      query.value &&
+      normalizeValue(element.properties[info.property], info).slice(
+        -query.value.length
+      ) === query.value
+  )
 }
 
-/** @type {Handler} */
-function adjacentSibling(query, _, index, parent, state) {
-  // Shouldn’t happen.
-  /* c8 ignore next */
-  if (!parent || index === null) return
-  indexedSearch(query, parent, state, index + 1, true)
+/**
+ * Check whether an attribute contains a substring.
+ *
+ * `[attr*=value]`
+ *
+ * @param {RuleAttr} query
+ * @param {Element} element
+ * @param {Info} info
+ * @returns {boolean}
+ */
+function contains(query, element, info) {
+  return Boolean(
+    hasProperty(element, info.property) &&
+      element.properties &&
+      query.value &&
+      normalizeValue(element.properties[info.property], info).includes(
+        query.value
+      )
+  )
 }
 
-/** @type {Handler} */
-function generalSibling(query, _, index, parent, state) {
-  // Shouldn’t happen.
-  /* c8 ignore next */
-  if (!parent || index === null) return
-  indexedSearch(query, parent, state, index + 1)
+// Shouldn’t be called, Parser throws an error instead.
+/**
+ * @param {unknown} query
+ * @returns {never}
+ */
+/* c8 ignore next 4 */
+function unknownOperator(query) {
+  // @ts-expect-error: `operator` guaranteed.
+  throw new Error('Unknown operator `' + query.operator + '`')
 }
 
 /**
- * Handles `typeIndex` and `typeCount` properties for every walker.
+ * Stringify a hast value back to its HTML form.
  *
- * @param {Rule} query
- * @param {Parent} parent
- * @param {SelectState} state
- * @param {number} [from=0]
- * @param {boolean} [firstElementOnly=false]
+ * @param {PropertyValue} value
+ * @param {Info} info
+ * @returns {string}
  */
-function indexedSearch(query, parent, state, from, firstElementOnly) {
-  const handle = state.index ? delay : add
-  const children = parent.children
-  let elements = 0
-  let index = -1
-  /** @type {Record<string, number>} */
-  const types = {}
-  /** @type {Array<Function>} */
-  const delayed = []
-
-  // Start looking at `from`
-  if (from === undefined || from === null) from = 0
-
-  // Exit if there are no further nodes.
-  if (from >= children.length) return
-
-  // If we need to index for types, do so for all elements before `from`.
-  if (state.index) {
-    while (++index < from) {
-      const child = children[index]
-      if (util_element(child)) count(child.tagName)
-    }
-  }
-
-  index = from - 1
-
-  while (++index < children.length) {
-    const child = children[index]
-    // Only check elements.
-    // Check either all elements, or only check the first sibling
-    if (util_element(child)) {
-      handle(child, index)
-
-      // Stop if we’re looking for one node and it’s already found.
-      if (state.one && state.found) return
-      if (firstElementOnly) break
-    }
+function normalizeValue(value, info) {
+  if (typeof value === 'boolean') {
+    return info.attribute
   }
 
-  if (state.index) {
-    index = -1
-
-    while (++index < delayed.length) {
-      delayed[index]()
-      if (state.one && state.found) return
-    }
+  if (Array.isArray(value)) {
+    return (info.commaSeparated ? comma_separated_tokens_stringify : stringify)(value)
   }
 
-  /**
-   * @param {Element} node
-   * @param {number} childIndex
-   */
-  function delay(node, childIndex) {
-    const elementsBefore = elements
-    const elementsByTypeBefore = nest_own.call(types, node.tagName)
-      ? types[node.tagName]
-      : 0
-
-    count(node.tagName)
-
-    delayed.push(fn)
+  return String(value)
+}
 
-    function fn() {
-      // Before counting further elements:
-      state.elementIndex = elementsBefore
-      state.typeIndex = elementsByTypeBefore
+;// CONCATENATED MODULE: ../node_modules/hast-util-select/lib/class-name.js
+/**
+ * @typedef {import('./types.js').Rule} Rule
+ * @typedef {import('./types.js').Element} Element
+ */
 
-      // After counting all elements.
-      state.elementCount = elements
-      state.typeCount = types[node.tagName]
+/**
+ * Check whether an element has all class names.
+ *
+ * @param {Rule} query
+ * @param {Element} element
+ * @returns {boolean}
+ */
+function className(query, element) {
+  /** @type {readonly string[]} */
+  // @ts-expect-error Assume array.
+  const value = element.properties.className || []
+  let index = -1
 
-      add(node, childIndex)
+  if (query.classNames) {
+    while (++index < query.classNames.length) {
+      if (!value.includes(query.classNames[index])) return false
     }
   }
 
-  /**
-   * @param {Element} node
-   * @param {number} childIndex
-   */
-  function add(node, childIndex) {
-    const exit = enterState(state, node)
+  return true
+}
 
-    // Shouldn’t happen.
-    /* c8 ignore next 3 */
-    if (!state.iterator) {
-      throw new Error('Expected `iterator`')
-    }
+;// CONCATENATED MODULE: ../node_modules/hast-util-select/lib/id.js
+/**
+ * @typedef {import('./types.js').Rule} Rule
+ * @typedef {import('./types.js').Element} Element
+ */
 
-    state.iterator(query, node, childIndex, parent, state)
-    exit()
-  }
+/**
+ * Check whether an element has an ID.
+ *
+ * @param {Rule} query
+ * @param {Element} element
+ * @returns {boolean}
+ */
+function id(query, element) {
+  return Boolean(element.properties && element.properties.id === query.id)
+}
 
-  /**
-   * @param {string} name
-   */
-  function count(name) {
-    if (!nest_own.call(types, name)) types[name] = 0
-    elements++
-    types[name]++
-  }
+;// CONCATENATED MODULE: ../node_modules/hast-util-select/lib/name.js
+/**
+ * @typedef {import('./types.js').Rule} Rule
+ * @typedef {import('./types.js').Element} Element
+ */
+
+/**
+ * Check whether an element has a tag name.
+ *
+ * @param {Rule} query
+ * @param {Element} element
+ * @returns {boolean}
+ */
+function name_name(query, element) {
+  return query.tagName === '*' || query.tagName === element.tagName
 }
 
 ;// CONCATENATED MODULE: ../node_modules/bcp-47-match/index.js
@@ -59073,15 +59117,266 @@ function cast(values, name) {
   return value
 }
 
+;// CONCATENATED MODULE: ../node_modules/nth-check/lib/esm/parse.js
+// Following http://www.w3.org/TR/css3-selectors/#nth-child-pseudo
+// Whitespace as per https://www.w3.org/TR/selectors-3/#lex is " \t\r\n\f"
+const parse_whitespace = new Set([9, 10, 12, 13, 32]);
+const ZERO = "0".charCodeAt(0);
+const NINE = "9".charCodeAt(0);
+/**
+ * Parses an expression.
+ *
+ * @throws An `Error` if parsing fails.
+ * @returns An array containing the integer step size and the integer offset of the nth rule.
+ * @example nthCheck.parse("2n+3"); // returns [2, 3]
+ */
+function esm_parse_parse(formula) {
+    formula = formula.trim().toLowerCase();
+    if (formula === "even") {
+        return [2, 0];
+    }
+    else if (formula === "odd") {
+        return [2, 1];
+    }
+    // Parse [ ['-'|'+']? INTEGER? {N} [ S* ['-'|'+'] S* INTEGER ]?
+    let idx = 0;
+    let a = 0;
+    let sign = readSign();
+    let number = readNumber();
+    if (idx < formula.length && formula.charAt(idx) === "n") {
+        idx++;
+        a = sign * (number !== null && number !== void 0 ? number : 1);
+        skipWhitespace();
+        if (idx < formula.length) {
+            sign = readSign();
+            skipWhitespace();
+            number = readNumber();
+        }
+        else {
+            sign = number = 0;
+        }
+    }
+    // Throw if there is anything else
+    if (number === null || idx < formula.length) {
+        throw new Error(`n-th rule couldn't be parsed ('${formula}')`);
+    }
+    return [a, sign * number];
+    function readSign() {
+        if (formula.charAt(idx) === "-") {
+            idx++;
+            return -1;
+        }
+        if (formula.charAt(idx) === "+") {
+            idx++;
+        }
+        return 1;
+    }
+    function readNumber() {
+        const start = idx;
+        let value = 0;
+        while (idx < formula.length &&
+            formula.charCodeAt(idx) >= ZERO &&
+            formula.charCodeAt(idx) <= NINE) {
+            value = value * 10 + (formula.charCodeAt(idx) - ZERO);
+            idx++;
+        }
+        // Return `null` if we didn't read anything.
+        return idx === start ? null : value;
+    }
+    function skipWhitespace() {
+        while (idx < formula.length &&
+            parse_whitespace.has(formula.charCodeAt(idx))) {
+            idx++;
+        }
+    }
+}
+//# sourceMappingURL=parse.js.map
+// EXTERNAL MODULE: ../node_modules/boolbase/index.js
+var boolbase = __webpack_require__(286);
+;// CONCATENATED MODULE: ../node_modules/nth-check/lib/esm/compile.js
+
+/**
+ * Returns a function that checks if an elements index matches the given rule
+ * highly optimized to return the fastest solution.
+ *
+ * @param parsed A tuple [a, b], as returned by `parse`.
+ * @returns A highly optimized function that returns whether an index matches the nth-check.
+ * @example
+ *
+ * ```js
+ * const check = nthCheck.compile([2, 3]);
+ *
+ * check(0); // `false`
+ * check(1); // `false`
+ * check(2); // `true`
+ * check(3); // `false`
+ * check(4); // `true`
+ * check(5); // `false`
+ * check(6); // `true`
+ * ```
+ */
+function compile(parsed) {
+    const a = parsed[0];
+    // Subtract 1 from `b`, to convert from one- to zero-indexed.
+    const b = parsed[1] - 1;
+    /*
+     * When `b <= 0`, `a * n` won't be lead to any matches for `a < 0`.
+     * Besides, the specification states that no elements are
+     * matched when `a` and `b` are 0.
+     *
+     * `b < 0` here as we subtracted 1 from `b` above.
+     */
+    if (b < 0 && a <= 0)
+        return boolbase.falseFunc;
+    // When `a` is in the range -1..1, it matches any element (so only `b` is checked).
+    if (a === -1)
+        return (index) => index <= b;
+    if (a === 0)
+        return (index) => index === b;
+    // When `b <= 0` and `a === 1`, they match any element.
+    if (a === 1)
+        return b < 0 ? boolbase.trueFunc : (index) => index >= b;
+    /*
+     * Otherwise, modulo can be used to check if there is a match.
+     *
+     * Modulo doesn't care about the sign, so let's use `a`s absolute value.
+     */
+    const absA = Math.abs(a);
+    // Get `b mod a`, + a if this is negative.
+    const bMod = ((b % absA) + absA) % absA;
+    return a > 1
+        ? (index) => index >= b && index % absA === bMod
+        : (index) => index <= b && index % absA === bMod;
+}
+/**
+ * Returns a function that produces a monotonously increasing sequence of indices.
+ *
+ * If the sequence has an end, the returned function will return `null` after
+ * the last index in the sequence.
+ *
+ * @param parsed A tuple [a, b], as returned by `parse`.
+ * @returns A function that produces a sequence of indices.
+ * @example <caption>Always increasing (2n+3)</caption>
+ *
+ * ```js
+ * const gen = nthCheck.generate([2, 3])
+ *
+ * gen() // `1`
+ * gen() // `3`
+ * gen() // `5`
+ * gen() // `8`
+ * gen() // `11`
+ * ```
+ *
+ * @example <caption>With end value (-2n+10)</caption>
+ *
+ * ```js
+ *
+ * const gen = nthCheck.generate([-2, 5]);
+ *
+ * gen() // 0
+ * gen() // 2
+ * gen() // 4
+ * gen() // null
+ * ```
+ */
+function compile_generate(parsed) {
+    const a = parsed[0];
+    // Subtract 1 from `b`, to convert from one- to zero-indexed.
+    let b = parsed[1] - 1;
+    let n = 0;
+    // Make sure to always return an increasing sequence
+    if (a < 0) {
+        const aPos = -a;
+        // Get `b mod a`
+        const minValue = ((b % aPos) + aPos) % aPos;
+        return () => {
+            const val = minValue + aPos * n++;
+            return val > b ? null : val;
+        };
+    }
+    if (a === 0)
+        return b < 0
+            ? // There are no result — always return `null`
+                () => null
+            : // Return `b` exactly once
+                () => (n++ === 0 ? b : null);
+    if (b < 0) {
+        b += a * Math.ceil(-b / a);
+    }
+    return () => a * n++ + b;
+}
+//# sourceMappingURL=compile.js.map
+;// CONCATENATED MODULE: ../node_modules/nth-check/lib/esm/index.js
+
+
+
+/**
+ * Parses and compiles a formula to a highly optimized function.
+ * Combination of {@link parse} and {@link compile}.
+ *
+ * If the formula doesn't match any elements,
+ * it returns [`boolbase`](https://github.com/fb55/boolbase)'s `falseFunc`.
+ * Otherwise, a function accepting an _index_ is returned, which returns
+ * whether or not the passed _index_ matches the formula.
+ *
+ * Note: The nth-rule starts counting at `1`, the returned function at `0`.
+ *
+ * @param formula The formula to compile.
+ * @example
+ * const check = nthCheck("2n+3");
+ *
+ * check(0); // `false`
+ * check(1); // `false`
+ * check(2); // `true`
+ * check(3); // `false`
+ * check(4); // `true`
+ * check(5); // `false`
+ * check(6); // `true`
+ */
+function nthCheck(formula) {
+    return compile(esm_parse_parse(formula));
+}
+/**
+ * Parses and compiles a formula to a generator that produces a sequence of indices.
+ * Combination of {@link parse} and {@link generate}.
+ *
+ * @param formula The formula to compile.
+ * @returns A function that produces a sequence of indices.
+ * @example <caption>Always increasing</caption>
+ *
+ * ```js
+ * const gen = nthCheck.sequence('2n+3')
+ *
+ * gen() // `1`
+ * gen() // `3`
+ * gen() // `5`
+ * gen() // `8`
+ * gen() // `11`
+ * ```
+ *
+ * @example <caption>With end value</caption>
+ *
+ * ```js
+ *
+ * const gen = nthCheck.sequence('-2n+5');
+ *
+ * gen() // 0
+ * gen() // 2
+ * gen() // 4
+ * gen() // null
+ * ```
+ */
+function sequence(formula) {
+    return generate(parse(formula));
+}
+//# sourceMappingURL=index.js.map
 ;// CONCATENATED MODULE: ../node_modules/hast-util-select/lib/pseudo.js
 /**
  * @typedef {import('./types.js').Rule} Rule
  * @typedef {import('./types.js').RulePseudo} RulePseudo
- * @typedef {import('./types.js').RulePseudoNth} RulePseudoNth
  * @typedef {import('./types.js').RulePseudoSelector} RulePseudoSelector
  * @typedef {import('./types.js').Parent} Parent
- * @typedef {import('./types.js').Selector} Selector
- * @typedef {import('./types.js').Selectors} Selectors
  * @typedef {import('./types.js').SelectState} SelectState
  * @typedef {import('./types.js').Element} Element
  * @typedef {import('./types.js').ElementChild} ElementChild
@@ -59095,75 +59390,54 @@ function cast(values, name) {
 
 
 
+/** @type {import('nth-check').default} */
+// @ts-expect-error
+const pseudo_nthCheck = nthCheck["default"] || nthCheck
+
+/** @type {(rule: Rule | RulePseudo, element: Element, index: number | undefined, parent: Parent | undefined, state: SelectState) => boolean} */
 const pseudo_handle = zwitch('name', {
-  // @ts-expect-error: hush.
   unknown: unknownPseudo,
   invalid: invalidPseudo,
   handlers: {
-    // @ts-expect-error: hush.
     any: matches,
-    // @ts-expect-error: hush.
     'any-link': anyLink,
-    // @ts-expect-error: hush.
     blank,
-    // @ts-expect-error: hush.
     checked,
-    // @ts-expect-error: hush.
     dir,
-    // @ts-expect-error: hush.
     disabled,
-    // @ts-expect-error: hush.
     empty,
-    // @ts-expect-error: hush.
     enabled,
-    // @ts-expect-error: hush.
     'first-child': firstChild,
-    // @ts-expect-error: hush.
     'first-of-type': firstOfType,
-    // @ts-expect-error: hush.
     has,
-    // @ts-expect-error: hush.
     lang: pseudo_lang,
-    // @ts-expect-error: hush.
     'last-child': lastChild,
-    // @ts-expect-error: hush.
     'last-of-type': lastOfType,
-    // @ts-expect-error: hush.
     matches,
-    // @ts-expect-error: hush.
     not,
-    // @ts-expect-error: hush.
     'nth-child': nthChild,
-    // @ts-expect-error: hush.
     'nth-last-child': nthLastChild,
-    // @ts-expect-error: hush.
     'nth-of-type': nthOfType,
-    // @ts-expect-error: hush.
     'nth-last-of-type': nthLastOfType,
-    // @ts-expect-error: hush.
     'only-child': onlyChild,
-    // @ts-expect-error: hush.
     'only-of-type': onlyOfType,
-    // @ts-expect-error: hush.
     optional,
-    // @ts-expect-error: hush.
     'read-only': readOnly,
-    // @ts-expect-error: hush.
     'read-write': readWrite,
-    // @ts-expect-error: hush.
     required,
-    // @ts-expect-error: hush.
     root: pseudo_root,
-    // @ts-expect-error: hush.
     scope
   }
 })
 
 pseudo.needsIndex = [
+  'any',
   'first-child',
   'first-of-type',
   'last-child',
   'last-of-type',
+  'matches',
+  'not',
   'nth-child',
   'nth-last-child',
   'nth-of-type',
@@ -59173,10 +59447,12 @@ pseudo.needsIndex = [
 ]
 
 /**
+ * Check whether an element matches pseudo selectors.
+ *
  * @param {Rule} query
  * @param {Element} element
- * @param {number|null} index
- * @param {Parent|null} parent
+ * @param {number | undefined} index
+ * @param {Parent | undefined} parent
  * @param {SelectState} state
  * @returns {boolean}
  */
@@ -59192,58 +59468,51 @@ function pseudo(query, element, index, parent, state) {
 }
 
 /**
- * @param {RulePseudoSelector} query
- * @param {Element} element
- * @param {number|null} _1
- * @param {Parent|null} _2
- * @param {SelectState} state
- * @returns {boolean}
- */
-function matches(query, element, _1, _2, state) {
-  const shallow = state.shallow
-  const one = state.one
-
-  state.shallow = true
-  state.one = true
-
-  const result = any_any(query.value, element, state)[0] === element
-
-  state.shallow = shallow
-  state.one = one
-
-  return result
-}
-
-/**
- * @param {RulePseudoSelector} query
+ * Check whether an element matches an `:any-link` pseudo.
+ *
+ * @param {RulePseudo} _
  * @param {Element} element
- * @param {number|null} index
- * @param {Parent|null} parent
- * @param {SelectState} state
  * @returns {boolean}
  */
-function not(query, element, index, parent, state) {
-  return !matches(query, element, index, parent, state)
+function anyLink(_, element) {
+  return (
+    (element.tagName === 'a' ||
+      element.tagName === 'area' ||
+      element.tagName === 'link') &&
+    hasProperty(element, 'href')
+  )
 }
 
 /**
+ * Check whether an element matches a `:blank` pseudo.
+ *
  * @param {RulePseudo} _
  * @param {Element} element
  * @returns {boolean}
  */
-function anyLink(_, element) {
-  return (
-    isElement(element, ['a', 'area', 'link']) && hasProperty(element, 'href')
-  )
+function blank(_, element) {
+  return !someChildren(element, check)
+
+  /**
+   * @param {ElementChild} child
+   * @returns {boolean}
+   */
+  function check(child) {
+    return (
+      child.type === 'element' || (child.type === 'text' && !whitespace(child))
+    )
+  }
 }
 
 /**
+ * Check whether an element matches a `:checked` pseudo.
+ *
  * @param {RulePseudo} _
  * @param {Element} element
  * @returns {boolean}
  */
 function checked(_, element) {
-  if (isElement(element, ['input', 'menuitem'])) {
+  if (element.tagName === 'input' || element.tagName === 'menuitem') {
     return Boolean(
       element.properties &&
         (element.properties.type === 'checkbox' ||
@@ -59252,7 +59521,7 @@ function checked(_, element) {
     )
   }
 
-  if (isElement(element, 'option')) {
+  if (element.tagName === 'option') {
     return hasProperty(element, 'selected')
   }
 
@@ -59260,10 +59529,12 @@ function checked(_, element) {
 }
 
 /**
+ * Check whether an element matches a `:dir()` pseudo.
+ *
  * @param {RulePseudo} query
  * @param {Element} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
+ * @param {number | undefined} _2
+ * @param {Parent | undefined} _3
  * @param {SelectState} state
  * @returns {boolean}
  */
@@ -59272,168 +59543,119 @@ function dir(query, _1, _2, _3, state) {
 }
 
 /**
+ * Check whether an element matches a `:disabled` pseudo.
+ *
  * @param {RulePseudo} _
  * @param {Element} element
  * @returns {boolean}
  */
 function disabled(_, element) {
   return (
-    isElement(element, [
-      'button',
-      'input',
-      'select',
-      'textarea',
-      'optgroup',
-      'option',
-      'menuitem',
-      'fieldset'
-    ]) && hasProperty(element, 'disabled')
+    (element.tagName === 'button' ||
+      element.tagName === 'input' ||
+      element.tagName === 'select' ||
+      element.tagName === 'textarea' ||
+      element.tagName === 'optgroup' ||
+      element.tagName === 'option' ||
+      element.tagName === 'menuitem' ||
+      element.tagName === 'fieldset') &&
+    hasProperty(element, 'disabled')
   )
 }
 
 /**
- * @param {RulePseudo} query
- * @param {Element} element
- * @returns {boolean}
- */
-function enabled(query, element) {
-  return !disabled(query, element)
-}
-
-/**
+ * Check whether an element matches an `:empty` pseudo.
+ *
  * @param {RulePseudo} _
  * @param {Element} element
  * @returns {boolean}
  */
-function required(_, element) {
-  return (
-    isElement(element, ['input', 'textarea', 'select']) &&
-    hasProperty(element, 'required')
-  )
-}
+function empty(_, element) {
+  return !someChildren(element, check)
 
-/**
- * @param {RulePseudo} query
- * @param {Element} element
- * @returns {boolean}
- */
-function optional(query, element) {
-  return !required(query, element)
+  /**
+   * @param {ElementChild} child
+   * @returns {boolean}
+   */
+  function check(child) {
+    return child.type === 'element' || child.type === 'text'
+  }
 }
 
 /**
- * @param {RulePseudo} _
+ * Check whether an element matches an `:enabled` pseudo.
+ *
+ * @param {RulePseudo} query
  * @param {Element} element
- * @param {number|null} _1
- * @param {Parent|null} _2
- * @param {SelectState} state
  * @returns {boolean}
  */
-function readWrite(_, element, _1, _2, state) {
-  return isElement(element, ['input', 'textarea'])
-    ? !hasProperty(element, 'readOnly') && !hasProperty(element, 'disabled')
-    : Boolean(state.editableOrEditingHost)
+function enabled(query, element) {
+  return !disabled(query, element)
 }
 
 /**
+ * Check whether an element matches a `:first-child` pseudo.
+ *
  * @param {RulePseudo} query
- * @param {Element} element
- * @param {number|null} index
- * @param {Parent|null} parent
+ * @param {Element} _1
+ * @param {number | undefined} _2
+ * @param {Parent | undefined} _3
  * @param {SelectState} state
  * @returns {boolean}
  */
-function readOnly(query, element, index, parent, state) {
-  return !readWrite(query, element, index, parent, state)
+function firstChild(query, _1, _2, _3, state) {
+  assertDeep(state, query)
+  return state.elementIndex === 0
 }
 
 /**
- * @param {RulePseudo} _
- * @param {Element} element
- * @param {number|null} _1
- * @param {Parent|null} parent
+ * Check whether an element matches a `:first-of-type` pseudo.
+ *
+ * @param {RulePseudo} query
+ * @param {Element} _1
+ * @param {number | undefined} _2
+ * @param {Parent | undefined} _3
  * @param {SelectState} state
  * @returns {boolean}
  */
-function pseudo_root(_, element, _1, parent, state) {
-  return Boolean(
-    (!parent || parent.type === 'root') &&
-      state.schema &&
-      (state.schema.space === 'html' || state.schema.space === 'svg') &&
-      isElement(element, ['html', 'svg'])
-  )
+function firstOfType(query, _1, _2, _3, state) {
+  assertDeep(state, query)
+  return state.typeIndex === 0
 }
 
 /**
- * @param {RulePseudo} _
+ * @param {RulePseudoSelector} query
  * @param {Element} element
- * @param {number|null} _1
- * @param {Parent|null} _2
+ * @param {number | undefined} _1
+ * @param {Parent | undefined} _2
  * @param {SelectState} state
  * @returns {boolean}
  */
-function scope(_, element, _1, _2, state) {
-  return Boolean(
-    isElement(element) &&
-      state.scopeElements &&
-      state.scopeElements.includes(element)
-  )
-}
-
-/**
- * @param {RulePseudo} _
- * @param {Element} element
- * @returns {boolean}
- */
-function empty(_, element) {
-  return !someChildren(element, check)
-
-  /**
-   * @param {ElementChild} child
-   * @returns {boolean}
-   */
-  function check(child) {
-    return child.type === 'element' || child.type === 'text'
+function has(query, element, _1, _2, state) {
+  /** @type {SelectState} */
+  const childState = {
+    ...state,
+    // Do walk deep.
+    shallow: false,
+    // One result is enough.
+    one: true,
+    scopeElements: [element],
+    results: [],
+    rootQuery: queryToSelectors(query.value)
   }
-}
-
-/**
- * @param {RulePseudo} _
- * @param {Element} element
- * @returns {boolean}
- */
-function blank(_, element) {
-  return !someChildren(element, check)
 
-  /**
-   * @param {ElementChild} child
-   * @returns {boolean}
-   */
-  function check(child) {
-    return (
-      child.type === 'element' || (child.type === 'text' && !whitespace(child))
-    )
-  }
-}
+  walk_walk(childState, {type: 'root', children: element.children})
 
-/**
- * @param {RulePseudo} query
- * @param {Element} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
- * @param {SelectState} state
- * @returns {boolean}
- */
-function firstChild(query, _1, _2, _3, state) {
-  assertDeep(state, query)
-  return state.elementIndex === 0
+  return childState.results.length > 0
 }
 
 /**
+ * Check whether an element matches a `:lang()` pseudo.
+ *
  * @param {RulePseudo} query
  * @param {Element} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
+ * @param {number | undefined} _2
+ * @param {Parent | undefined} _3
  * @param {SelectState} state
  * @returns {boolean}
  */
@@ -59441,17 +59663,18 @@ function pseudo_lang(query, _1, _2, _3, state) {
   return (
     state.language !== '' &&
     state.language !== undefined &&
-    state.language !== null &&
     // @ts-expect-error never `selectors`.
     extendedFilter(state.language, comma_separated_tokens_parse(query.value)).length > 0
   )
 }
 
 /**
+ * Check whether an element matches a `:last-child` pseudo.
+ *
  * @param {RulePseudo} query
  * @param {Element} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
+ * @param {number | undefined} _2
+ * @param {Parent | undefined} _3
  * @param {SelectState} state
  * @returns {boolean}
  */
@@ -59463,115 +59686,160 @@ function lastChild(query, _1, _2, _3, state) {
 }
 
 /**
+ * Check whether an element matches a `:last-of-type` pseudo.
+ *
  * @param {RulePseudo} query
  * @param {Element} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
+ * @param {number | undefined} _2
+ * @param {Parent | undefined} _3
  * @param {SelectState} state
  * @returns {boolean}
  */
-function onlyChild(query, _1, _2, _3, state) {
+function lastOfType(query, _1, _2, _3, state) {
   assertDeep(state, query)
-  return state.elementCount === 1
+  return (
+    typeof state.typeIndex === 'number' &&
+    typeof state.typeCount === 'number' &&
+    state.typeIndex === state.typeCount - 1
+  )
 }
 
 /**
- * @param {RulePseudoNth} query
- * @param {Element} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
+ * Check whether an element `:matches` further selectors.
+ *
+ * @param {RulePseudoSelector} query
+ * @param {Element} element
+ * @param {number | undefined} _
+ * @param {Parent | undefined} parent
  * @param {SelectState} state
  * @returns {boolean}
  */
-function nthChild(query, _1, _2, _3, state) {
-  assertDeep(state, query)
-  return (
-    typeof state.elementIndex === 'number' && query.value(state.elementIndex)
-  )
+function matches(query, element, _, parent, state) {
+  /** @type {SelectState} */
+  const childState = {
+    ...state,
+    // Do walk deep.
+    shallow: false,
+    // One result is enough.
+    one: true,
+    scopeElements: [element],
+    results: [],
+    rootQuery: queryToSelectors(query.value)
+  }
+
+  walk_walk(childState, element)
+
+  return childState.results[0] === element
+}
+
+/**
+ * Check whether an element does `:not` match further selectors.
+ *
+ * @param {RulePseudoSelector} query
+ * @param {Element} element
+ * @param {number | undefined} index
+ * @param {Parent | undefined} parent
+ * @param {SelectState} state
+ * @returns {boolean}
+ */
+function not(query, element, index, parent, state) {
+  return !matches(query, element, index, parent, state)
 }
 
 /**
- * @param {RulePseudoNth} query
+ * Check whether an element matches an `:nth-child` pseudo.
+ *
+ * @param {RulePseudo} query
  * @param {Element} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
+ * @param {number | undefined} _2
+ * @param {Parent | undefined} _3
  * @param {SelectState} state
  * @returns {boolean}
  */
-function nthLastChild(query, _1, _2, _3, state) {
+function nthChild(query, _1, _2, _3, state) {
+  const fn = getCachedNthCheck(query)
   assertDeep(state, query)
-  return Boolean(
-    typeof state.elementCount === 'number' &&
-      typeof state.elementIndex === 'number' &&
-      query.value(state.elementCount - state.elementIndex - 1)
-  )
+  return typeof state.elementIndex === 'number' && fn(state.elementIndex)
 }
 
 /**
- * @param {RulePseudoNth} query
+ * Check whether an element matches an `:nth-last-child` pseudo.
+ *
+ * @param {RulePseudo} query
  * @param {Element} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
+ * @param {number | undefined} _2
+ * @param {Parent | undefined} _3
  * @param {SelectState} state
  * @returns {boolean}
  */
-function nthOfType(query, _1, _2, _3, state) {
+function nthLastChild(query, _1, _2, _3, state) {
+  const fn = getCachedNthCheck(query)
   assertDeep(state, query)
-  return typeof state.typeIndex === 'number' && query.value(state.typeIndex)
+  return Boolean(
+    typeof state.elementCount === 'number' &&
+      typeof state.elementIndex === 'number' &&
+      fn(state.elementCount - state.elementIndex - 1)
+  )
 }
 
 /**
- * @param {RulePseudoNth} query
+ * Check whether an element matches a `:nth-last-of-type` pseudo.
+ *
+ * @param {RulePseudo} query
  * @param {Element} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
+ * @param {number | undefined} _2
+ * @param {Parent | undefined} _3
  * @param {SelectState} state
  * @returns {boolean}
  */
 function nthLastOfType(query, _1, _2, _3, state) {
+  const fn = getCachedNthCheck(query)
   assertDeep(state, query)
   return (
     typeof state.typeCount === 'number' &&
     typeof state.typeIndex === 'number' &&
-    query.value(state.typeCount - 1 - state.typeIndex)
+    fn(state.typeCount - 1 - state.typeIndex)
   )
 }
 
 /**
+ * Check whether an element matches an `:nth-of-type` pseudo.
+ *
  * @param {RulePseudo} query
  * @param {Element} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
+ * @param {number | undefined} _2
+ * @param {Parent | undefined} _3
  * @param {SelectState} state
  * @returns {boolean}
  */
-function firstOfType(query, _1, _2, _3, state) {
+function nthOfType(query, _1, _2, _3, state) {
+  const fn = getCachedNthCheck(query)
   assertDeep(state, query)
-  return state.typeIndex === 0
+  return typeof state.typeIndex === 'number' && fn(state.typeIndex)
 }
 
 /**
+ * Check whether an element matches an `:only-child` pseudo.
+ *
  * @param {RulePseudo} query
  * @param {Element} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
+ * @param {number | undefined} _2
+ * @param {Parent | undefined} _3
  * @param {SelectState} state
  * @returns {boolean}
  */
-function lastOfType(query, _1, _2, _3, state) {
+function onlyChild(query, _1, _2, _3, state) {
   assertDeep(state, query)
-  return (
-    typeof state.typeIndex === 'number' &&
-    typeof state.typeCount === 'number' &&
-    state.typeIndex === state.typeCount - 1
-  )
+  return state.elementCount === 1
 }
 
 /**
+ * Check whether an element matches an `:only-of-type` pseudo.
+ *
  * @param {RulePseudo} query
  * @param {Element} _1
- * @param {number|null} _2
- * @param {Parent|null} _3
+ * @param {number | undefined} _2
+ * @param {Parent | undefined} _3
  * @param {SelectState} state
  * @returns {boolean}
  */
@@ -59581,389 +59849,168 @@ function onlyOfType(query, _1, _2, _3, state) {
 }
 
 /**
- * @param {Element} element
- * @param {(child: ElementChild) => boolean} check
- * @returns {boolean}
- */
-function someChildren(element, check) {
-  const children = element.children
-  let index = -1
-
-  while (++index < children.length) {
-    if (check(children[index])) return true
-  }
-
-  return false
-}
-
-// Shouldn’t be called, parser gives correct data.
-/* c8 ignore next 3 */
-function invalidPseudo() {
-  throw new Error('Invalid pseudo-selector')
-}
-
-/**
+ * Check whether an element matches an `:optional` pseudo.
+ *
  * @param {RulePseudo} query
- */
-function unknownPseudo(query) {
-  if (query.name) {
-    throw new Error('Unknown pseudo-selector `' + query.name + '`')
-  }
-
-  throw new Error('Unexpected pseudo-element or empty pseudo-class')
-}
-
-/**
- * @param {SelectState} state
- * @param {RulePseudo|RulePseudoNth} query
- */
-function assertDeep(state, query) {
-  if (state.shallow) {
-    throw new Error('Cannot use `:' + query.name + '` without parent')
-  }
-}
-
-/**
- * @param {RulePseudoSelector} query
  * @param {Element} element
- * @param {number|null} _2
- * @param {Parent|null} _3
- * @param {SelectState} state
  * @returns {boolean}
  */
-function has(query, element, _2, _3, state) {
-  const shallow = state.shallow
-  const one = state.one
-  const scopeElements = state.scopeElements
-  const value = appendScope(query.value)
-
-  state.shallow = false
-  state.one = true
-  state.scopeElements = [element]
-
-  const result = any_any(value, element, state).length > 0
-
-  state.shallow = shallow
-  state.one = one
-  state.scopeElements = scopeElements
-
-  return result
-}
-
-/**
- * @param {Selector} value
- * @returns {Selectors}
- */
-function appendScope(value) {
-  /** @type {Selectors} */
-  const selector =
-    value.type === 'ruleSet' ? {type: 'selectors', selectors: [value]} : value
-  let index = -1
-
-  while (++index < selector.selectors.length) {
-    const rule = selector.selectors[index].rule
-    rule.nestingOperator = null
-
-    if (
-      !rule.pseudos ||
-      rule.pseudos.length !== 1 ||
-      rule.pseudos[0].name !== 'scope'
-    ) {
-      selector.selectors[index] = {
-        type: 'ruleSet',
-        // @ts-expect-error pseudos are fine w/ just a name!
-        rule: {type: 'rule', rule, pseudos: [{name: 'scope'}]}
-      }
-    }
-  }
-
-  return selector
-}
-
-;// CONCATENATED MODULE: ../node_modules/hast-util-select/lib/attribute.js
-/**
- * @typedef {import('./types.js').Rule} Rule
- * @typedef {import('./types.js').RuleAttr} RuleAttr
- * @typedef {import('./types.js').Element} Element
- * @typedef {import('./types.js').Schema} Schema
- * @typedef {import('./types.js').Info} Info
- * @typedef {import('./types.js').PropertyValue} PropertyValue
- */
-
-
-
-
-
-
-
-const attribute_handle = zwitch('operator', {
-  // @ts-expect-error: hush.
-  unknown: unknownOperator,
-  // @ts-expect-error: hush.
-  invalid: exists,
-  handlers: {
-    // @ts-expect-error: hush.
-    '=': exact,
-    // @ts-expect-error: hush.
-    '~=': spaceSeparatedList,
-    // @ts-expect-error: hush.
-    '|=': exactOrPrefix,
-    // @ts-expect-error: hush.
-    '^=': begins,
-    // @ts-expect-error: hush.
-    '$=': ends,
-    // @ts-expect-error: hush.
-    '*=': contains
-  }
-})
-
-/**
- * @param {Rule} query
- * @param {Element} element
- * @param {Schema} schema
- * @returns {boolean}
- */
-function attribute(query, element, schema) {
-  const attrs = query.attrs
-  let index = -1
-
-  while (++index < attrs.length) {
-    if (!attribute_handle(attrs[index], element, find(schema, attrs[index].name))) {
-      return false
-    }
-  }
-
-  return true
+function optional(query, element) {
+  return !required(query, element)
 }
 
 /**
- * `[attr]`
+ * Check whether an element matches a `:read-only` pseudo.
  *
- * @param {RuleAttr} _
+ * @param {RulePseudo} query
  * @param {Element} element
- * @param {Info} info
+ * @param {number | undefined} index
+ * @param {Parent | undefined} parent
+ * @param {SelectState} state
  * @returns {boolean}
  */
-function exists(_, element, info) {
-  return hasProperty(element, info.property)
+function readOnly(query, element, index, parent, state) {
+  return !readWrite(query, element, index, parent, state)
 }
 
 /**
- * `[attr=value]`
+ * Check whether an element matches a `:read-write` pseudo.
  *
- * @param {RuleAttr} query
+ * @param {RulePseudo} _
  * @param {Element} element
- * @param {Info} info
+ * @param {number | undefined} _1
+ * @param {Parent | undefined} _2
+ * @param {SelectState} state
  * @returns {boolean}
  */
-function exact(query, element, info) {
-  return Boolean(
-    hasProperty(element, info.property) &&
-      element.properties &&
-      normalizeValue(element.properties[info.property], info) === query.value
-  )
+function readWrite(_, element, _1, _2, state) {
+  return element.tagName === 'input' || element.tagName === 'textarea'
+    ? !hasProperty(element, 'readOnly') && !hasProperty(element, 'disabled')
+    : Boolean(state.editableOrEditingHost)
 }
 
 /**
- * `[attr~=value]`
+ * Check whether an element matches a `:required` pseudo.
  *
- * @param {RuleAttr} query
+ * @param {RulePseudo} _
  * @param {Element} element
- * @param {Info} info
  * @returns {boolean}
  */
-function spaceSeparatedList(query, element, info) {
-  const value = element.properties && element.properties[info.property]
-
+function required(_, element) {
   return (
-    // If this is a comma-separated list, and the query is contained in it, return
-    // true.
-    (!info.commaSeparated &&
-      value &&
-      typeof value === 'object' &&
-      query.value &&
-      value.includes(query.value)) ||
-    // For all other values (including comma-separated lists), return whether this
-    // is an exact match.
-    (hasProperty(element, info.property) &&
-      normalizeValue(value, info) === query.value)
-  )
-}
-
-/**
- * `[attr|=value]`
- *
- * @param {RuleAttr} query
- * @param {Element} element
- * @param {Info} info
- * @returns {boolean}
- */
-function exactOrPrefix(query, element, info) {
-  const value = normalizeValue(
-    element.properties && element.properties[info.property],
-    info
-  )
-
-  return Boolean(
-    hasProperty(element, info.property) &&
-      query.value &&
-      (value === query.value ||
-        (value.slice(0, query.value.length) === query.value &&
-          value.charAt(query.value.length) === '-'))
-  )
-}
-
-/**
- * `[attr^=value]`
- *
- * @param {RuleAttr} query
- * @param {Element} element
- * @param {Info} info
- * @returns {boolean}
- */
-function begins(query, element, info) {
-  return Boolean(
-    hasProperty(element, info.property) &&
-      element.properties &&
-      query.value &&
-      normalizeValue(element.properties[info.property], info).slice(
-        0,
-        query.value.length
-      ) === query.value
+    (element.tagName === 'input' ||
+      element.tagName === 'textarea' ||
+      element.tagName === 'select') &&
+    hasProperty(element, 'required')
   )
 }
 
 /**
- * `[attr$=value]`
+ * Check whether an element matches a `:root` pseudo.
  *
- * @param {RuleAttr} query
+ * @param {RulePseudo} _
  * @param {Element} element
- * @param {Info} info
+ * @param {number | undefined} _1
+ * @param {Parent | undefined} parent
+ * @param {SelectState} state
  * @returns {boolean}
  */
-function ends(query, element, info) {
+function pseudo_root(_, element, _1, parent, state) {
   return Boolean(
-    hasProperty(element, info.property) &&
-      element.properties &&
-      query.value &&
-      normalizeValue(element.properties[info.property], info).slice(
-        -query.value.length
-      ) === query.value
+    (!parent || parent.type === 'root') &&
+      state.schema &&
+      (state.schema.space === 'html' || state.schema.space === 'svg') &&
+      (element.tagName === 'html' || element.tagName === 'svg')
   )
 }
 
 /**
- * `[attr*=value]`
+ * Check whether an element matches a `:scope` pseudo.
  *
- * @param {RuleAttr} query
+ * @param {RulePseudo} _
  * @param {Element} element
- * @param {Info} info
+ * @param {number | undefined} _1
+ * @param {Parent | undefined} _2
+ * @param {SelectState} state
  * @returns {boolean}
  */
-function contains(query, element, info) {
-  return Boolean(
-    hasProperty(element, info.property) &&
-      element.properties &&
-      query.value &&
-      normalizeValue(element.properties[info.property], info).includes(
-        query.value
-      )
-  )
+function scope(_, element, _1, _2, state) {
+  return state.scopeElements.includes(element)
 }
 
-// Shouldn’t be called, Parser throws an error instead.
-/**
- * @param {RuleAttr} query
- * @returns {boolean}
- */
+// Shouldn’t be called, parser gives correct data.
 /* c8 ignore next 3 */
-function unknownOperator(query) {
-  throw new Error('Unknown operator `' + query.operator + '`')
+function invalidPseudo() {
+  throw new Error('Invalid pseudo-selector')
 }
 
 /**
- * Stringify a hast value back to its HTML form.
- *
- * @param {PropertyValue} value
- * @param {Info} info
- * @returns {string}
+ * @param {unknown} query
+ * @returns {never}
  */
-function normalizeValue(value, info) {
-  if (typeof value === 'boolean') {
-    return info.attribute
-  }
-
-  if (Array.isArray(value)) {
-    return (info.commaSeparated ? comma_separated_tokens_stringify : stringify)(value)
+function unknownPseudo(query) {
+  // @ts-expect-error: indexable.
+  if (query.name) {
+    // @ts-expect-error: indexable.
+    throw new Error('Unknown pseudo-selector `' + query.name + '`')
   }
 
-  return String(value)
+  throw new Error('Unexpected pseudo-element or empty pseudo-class')
 }
 
-;// CONCATENATED MODULE: ../node_modules/hast-util-select/lib/class-name.js
 /**
- * @typedef {import('./types.js').Rule} Rule
- * @typedef {import('./types.js').Element} Element
- */
-
-/**
- * @param {Rule} query
+ * Check children.
+ *
  * @param {Element} element
+ * @param {(child: ElementChild) => boolean} check
  * @returns {boolean}
  */
-function className(query, element) {
-  /** @type {Array<string>} */
-  // @ts-expect-error Assume array.
-  const value = element.properties.className || []
+function someChildren(element, check) {
+  const children = element.children
   let index = -1
 
-  if (query.classNames) {
-    while (++index < query.classNames.length) {
-      if (!value.includes(query.classNames[index])) return false
-    }
+  while (++index < children.length) {
+    if (check(children[index])) return true
   }
 
-  return true
+  return false
 }
 
-;// CONCATENATED MODULE: ../node_modules/hast-util-select/lib/id.js
 /**
- * @typedef {import('./types.js').Rule} Rule
- * @typedef {import('./types.js').Element} Element
- */
-
-/**
- * @param {Rule} query
- * @param {Element} element
- * @returns {boolean}
+ * @param {SelectState} state
+ * @param {RulePseudo} query
  */
-function id(query, element) {
-  return Boolean(element.properties && element.properties.id === query.id)
+function assertDeep(state, query) {
+  if (state.shallow) {
+    throw new Error('Cannot use `:' + query.name + '` without parent')
+  }
 }
 
-;// CONCATENATED MODULE: ../node_modules/hast-util-select/lib/name.js
 /**
- * @typedef {import('./types.js').Rule} Rule
- * @typedef {import('./types.js').Element} Element
+ * @param {RulePseudo} query
+ * @returns {(value: number) => boolean}
  */
+function getCachedNthCheck(query) {
+  /** @type {(value: number) => boolean} */
+  // @ts-expect-error: cache.
+  let fn = query._cachedFn
 
-/**
- * @param {Rule} query
- * @param {Element} element
- * @returns {boolean}
- */
-function name_name(query, element) {
-  return query.tagName === '*' || query.tagName === element.tagName
+  if (!fn) {
+    // @ts-expect-error: always string.
+    fn = pseudo_nthCheck(query.value)
+    // @ts-expect-error: cache.
+    query._cachedFn = fn
+  }
+
+  return fn
 }
 
 ;// CONCATENATED MODULE: ../node_modules/hast-util-select/lib/test.js
 /**
  * @typedef {import('./types.js').Rule} Rule
- * @typedef {import('./types.js').HastNode} HastNode
  * @typedef {import('./types.js').Element} Element
  * @typedef {import('./types.js').Parent} Parent
  * @typedef {import('./types.js').SelectState} SelectState
- * @typedef {import('hast-util-is-element').AssertPredicate<Element>} IsElement
  */
 
 
@@ -59972,609 +60019,468 @@ function name_name(query, element) {
 
 
 
-
 /**
+ * Test a rule.
+ *
  * @param {Rule} query
- * @param {HastNode} node
- * @param {number|null} index
- * @param {Parent|null} parent
+ * @param {Element} element
+ * @param {number | undefined} index
+ * @param {Parent | undefined} parent
  * @param {SelectState} state
  * @returns {boolean}
  */
-function test(query, node, index, parent, state) {
+function test(query, element, index, parent, state) {
   return Boolean(
-    util_element(node) &&
-      state.schema &&
-      (!query.tagName || name_name(query, node)) &&
-      (!query.classNames || className(query, node)) &&
-      (!query.id || id(query, node)) &&
-      (!query.attrs || attribute(query, node, state.schema)) &&
-      (!query.pseudos || pseudo(query, node, index, parent, state))
+    (!query.tagName || name_name(query, element)) &&
+      (!query.classNames || className(query, element)) &&
+      (!query.id || id(query, element)) &&
+      (!query.attrs || attribute(query, element, state.schema)) &&
+      (!query.pseudos || pseudo(query, element, index, parent, state))
   )
 }
 
-;// CONCATENATED MODULE: ../node_modules/hast-util-select/lib/any.js
+;// CONCATENATED MODULE: ../node_modules/hast-util-select/lib/walk.js
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('./types.js').Selectors} Selectors
- * @typedef {import('./types.js').Rule} Rule
+ * @typedef {import('./types.js').Node} Node
+ * @typedef {import('./types.js').Element} Element
+ * @typedef {import('./types.js').Parent} Parent
  * @typedef {import('./types.js').RuleSet} RuleSet
- * @typedef {import('./types.js').HastNode} HastNode
- * @typedef {import('./types.js').SelectIterator} SelectIterator
  * @typedef {import('./types.js').SelectState} SelectState
+ * @typedef {import('./types.js').Selectors} Selectors
+ *
+ * @typedef Nest
+ *   Rule sets by nesting.
+ * @property {Array<RuleSet> | undefined} descendant
+ *   `a b`
+ * @property {Array<RuleSet> | undefined} directChild
+ *   `a > b`
+ * @property {Array<RuleSet> | undefined} adjacentSibling
+ *   `a + b`
+ * @property {Array<RuleSet> | undefined} generalSibling
+ *   `a ~ b`
+ *
+ * @typedef Counts
+ *   Info on elements in a parent.
+ * @property {number} count
+ *   Number of elements.
+ * @property {Map<string, number>} types
+ *   Number of elements by tag name.
  */
 
 
 
 
-
-
-
-
-const type = zwitch('type', {
-  // @ts-expect-error: hush.
-  unknown: unknownType,
-  invalid: invalidType,
-  // @ts-expect-error: hush.
-  handlers: {selectors, ruleSet, rule}
-})
+/** @type {Array<never>} */
+const walk_empty = []
 
 /**
- * @param {Selectors|RuleSet|Rule} query
- * @param {HastNode|undefined} node
- * @param {SelectState} state
- * @returns {Array<Element>}
- */
-function any_any(query, node, state) {
-  // @ts-expect-error zwitch types are off.
-  return query && node ? type(query, node, state) : []
-}
-
-/**
- * @param {Selectors} query
- * @param {HastNode} node
- * @param {SelectState} state
- * @returns {Array<Element>}
+ * Turn a query into a uniform object.
+ *
+ * @param {Selectors | RuleSet | null} query
+ * @returns {Selectors}
  */
-function selectors(query, node, state) {
-  const collector = new Collector(state.one)
-  let index = -1
+function queryToSelectors(query) {
+  if (query === null) {
+    return {type: 'selectors', selectors: []}
+  }
 
-  while (++index < query.selectors.length) {
-    collector.collectAll(ruleSet(query.selectors[index], node, state))
+  if (query.type === 'ruleSet') {
+    return {type: 'selectors', selectors: [query]}
   }
 
-  return collector.result
+  return query
 }
 
 /**
- * @param {RuleSet} query
- * @param {HastNode} node
+ * Walk a tree.
+ *
  * @param {SelectState} state
- * @returns {Array<Element>}
+ * @param {Node | undefined} tree
  */
-function ruleSet(query, node, state) {
-  return rule(query.rule, node, state)
+function walk_walk(state, tree) {
+  if (tree) {
+    walk_one(state, [], tree, undefined, undefined)
+  }
 }
 
 /**
- * @param {Rule} query
- * @param {HastNode} tree
+ * Check a node.
+ *
  * @param {SelectState} state
- * @returns {Array<Element>}
+ * @param {Array<RuleSet>} currentRules
+ * @param {Node} node
+ * @param {number | undefined} index
+ * @param {Parent | undefined} parent
+ * @returns {Nest}
  */
-function rule(query, tree, state) {
-  const collector = new Collector(state.one)
-
-  if (state.shallow && query.rule) {
-    throw new Error('Expected selector without nesting')
+function walk_one(state, currentRules, node, index, parent) {
+  /** @type {Nest} */
+  let nestResult = {
+    directChild: undefined,
+    descendant: undefined,
+    adjacentSibling: undefined,
+    generalSibling: undefined
   }
+  const exit = enterState(state, node)
 
-  nest(
-    query,
-    tree,
-    0,
-    null,
-    configure(query, {
-      schema: state.space === 'svg' ? property_information_svg : property_information_html,
-      language: undefined,
-      direction: 'ltr',
-      editableOrEditingHost: false,
-      // @ts-expect-error assume elements.
-      scopeElements: tree.type === 'root' ? tree.children : [tree],
-      iterator,
-      one: state.one,
-      shallow: state.shallow
-    })
-  )
-
-  return collector.result
-
-  /** @type {SelectIterator} */
-  function iterator(query, node, index, parent, state) {
-    const exit = enterState(state, node)
-
-    if (test(query, node, index, parent, state)) {
-      if (query.rule) {
-        nest(query.rule, node, index, parent, configure(query.rule, state))
-      } else {
-        // @ts-expect-error `test` also asserts `node is Element`
-        collector.collect(node)
-        state.found = true
-      }
-    }
-
-    exit()
+  if (node.type === 'element') {
+    nestResult = applySelectors(
+      state,
+      // Try the root rules for this element too.
+      combine(currentRules, state.rootQuery.selectors),
+      node,
+      index,
+      parent
+    )
   }
 
-  /**
-   * @template {SelectState} S
-   * @param {Rule} query
-   * @param {S} state
-   * @returns {S}
-   */
-  function configure(query, state) {
-    const pseudos = query.pseudos || []
-    let index = -1
+  // If this is a parent, and we want to delve into them, and we haven’t found
+  // our single result yet.
+  if ('children' in node && !state.shallow && !(state.one && state.found)) {
+    walk_all(state, nestResult, node)
+  }
 
-    while (++index < pseudos.length) {
-      if (pseudo.needsIndex.includes(pseudos[index].name)) {
-        state.index = true
-        break
-      }
-    }
+  exit()
 
-    return state
-  }
+  return nestResult
 }
 
-// Shouldn’t be called, all data is handled.
-/* c8 ignore next 6 */
 /**
- * @param {{[x: string]: unknown, type: string}} query
+ * Check a node.
+ *
+ * @param {SelectState} state
+ * @param {Nest} nest
+ * @param {Parent} node
+ * @returns {void}
  */
-function unknownType(query) {
-  throw new Error('Unknown type `' + query.type + '`')
-}
-
-// Shouldn’t be called, parser gives correct data.
-/* c8 ignore next 3 */
-function invalidType() {
-  throw new Error('Invalid type')
-}
-
-class Collector {
+function walk_all(state, nest, node) {
+  const fromParent = combine(nest.descendant, nest.directChild)
+  /** @type {Array<RuleSet> | undefined} */
+  let fromSibling
+  let index = -1
   /**
-   * @param {boolean|undefined} [one]
+   * Total counts.
+   * @type {Counts}
    */
-  constructor(one) {
-    /** @type {Array<Element>} */
-    this.result = []
-    /** @type {boolean|undefined} */
-    this.one = one
-    /** @type {boolean} */
-    this.found = false
-  }
-
+  const total = {count: 0, types: new Map()}
   /**
-   * Append nodes to array, filtering out duplicates.
-   *
-   * @param {Array<Element>} elements
+   * Counts of previous siblings.
+   * @type {Counts}
    */
-  collectAll(elements) {
-    let index = -1
+  const before = {count: 0, types: new Map()}
 
-    while (++index < elements.length) {
-      this.collect(elements[index])
-    }
+  while (++index < node.children.length) {
+    count(total, node.children[index])
   }
 
-  /**
-   * Append one node.
-   *
-   * @param {Element} element
-   */
-  collect(element) {
-    if (this.one) {
-      // Shouldn’t happen, safeguards performance problems.
-      /* c8 ignore next */
-      if (this.found) return
-      this.found = true
+  index = -1
+
+  while (++index < node.children.length) {
+    const child = node.children[index]
+    // Uppercase to prevent prototype polution, injecting `constructor` or so.
+    // Normalize because HTML is insensitive.
+    const name =
+      child.type === 'element' ? child.tagName.toUpperCase() : undefined
+    // Before counting further elements:
+    state.elementIndex = before.count
+    state.typeIndex = name ? before.types.get(name) || 0 : 0
+    // After counting all elements.
+    state.elementCount = total.count
+    state.typeCount = name ? total.types.get(name) : 0
+
+    // Only apply if this is a parent, this should be an element, but we check
+    // for parents so that we delve into custom nodes too.
+    if ('children' in child) {
+      const forSibling = combine(fromParent, fromSibling)
+      const nest = walk_one(state, forSibling, node.children[index], index, node)
+      fromSibling = combine(nest.generalSibling, nest.adjacentSibling)
+    }
+
+    // We found one thing, and one is enough.
+    if (state.one && state.found) {
+      break
     }
 
-    if (!this.result.includes(element)) this.result.push(element)
+    count(before, node.children[index])
   }
 }
 
-// EXTERNAL MODULE: ../node_modules/css-selector-parser/lib/index.js
-var css_selector_parser_lib = __webpack_require__(510);
-;// CONCATENATED MODULE: ../node_modules/nth-check/lib/esm/parse.js
-// Following http://www.w3.org/TR/css3-selectors/#nth-child-pseudo
-// Whitespace as per https://www.w3.org/TR/selectors-3/#lex is " \t\r\n\f"
-const parse_whitespace = new Set([9, 10, 12, 13, 32]);
-const ZERO = "0".charCodeAt(0);
-const NINE = "9".charCodeAt(0);
 /**
- * Parses an expression.
+ * Apply selectors to an element.
  *
- * @throws An `Error` if parsing fails.
- * @returns An array containing the integer step size and the integer offset of the nth rule.
- * @example nthCheck.parse("2n+3"); // returns [2, 3]
- */
-function esm_parse_parse(formula) {
-    formula = formula.trim().toLowerCase();
-    if (formula === "even") {
-        return [2, 0];
-    }
-    else if (formula === "odd") {
-        return [2, 1];
-    }
-    // Parse [ ['-'|'+']? INTEGER? {N} [ S* ['-'|'+'] S* INTEGER ]?
-    let idx = 0;
-    let a = 0;
-    let sign = readSign();
-    let number = readNumber();
-    if (idx < formula.length && formula.charAt(idx) === "n") {
-        idx++;
-        a = sign * (number !== null && number !== void 0 ? number : 1);
-        skipWhitespace();
-        if (idx < formula.length) {
-            sign = readSign();
-            skipWhitespace();
-            number = readNumber();
-        }
-        else {
-            sign = number = 0;
-        }
-    }
-    // Throw if there is anything else
-    if (number === null || idx < formula.length) {
-        throw new Error(`n-th rule couldn't be parsed ('${formula}')`);
+ * @param {SelectState} state
+ *   Current state.
+ * @param {Array<RuleSet>} rules
+ *   Rules to apply.
+ * @param {Element} node
+ *   Element to apply rules to.
+ * @param {number | undefined} index
+ *   Index of node in parent.
+ * @param {Parent | undefined} parent
+ *   Parent of node.
+ * @returns {Nest}
+ *   Further rules.
+ */
+function applySelectors(state, rules, node, index, parent) {
+  /** @type {Nest} */
+  const nestResult = {
+    directChild: undefined,
+    descendant: undefined,
+    adjacentSibling: undefined,
+    generalSibling: undefined
+  }
+  let selectorIndex = -1
+
+  while (++selectorIndex < rules.length) {
+    const ruleSet = rules[selectorIndex]
+
+    // We found one thing, and one is enough.
+    if (state.one && state.found) {
+      break
     }
-    return [a, sign * number];
-    function readSign() {
-        if (formula.charAt(idx) === "-") {
-            idx++;
-            return -1;
-        }
-        if (formula.charAt(idx) === "+") {
-            idx++;
+
+    // When shallow, we don’t allow nested rules.
+    // Idea: we could allow a stack of parents?
+    // Might get quite complex though.
+    if (state.shallow && ruleSet.rule.rule) {
+      throw new Error('Expected selector without nesting')
+    }
+
+    // If this rule matches:
+    if (test(ruleSet.rule, node, index, parent, state)) {
+      const nest = ruleSet.rule.rule
+
+      // Are there more?
+      if (nest) {
+        /** @type {RuleSet} */
+        const rule = {type: 'ruleSet', rule: nest}
+        /** @type {keyof Nest} */
+        const label =
+          nest.nestingOperator === '+'
+            ? 'adjacentSibling'
+            : nest.nestingOperator === '~'
+            ? 'generalSibling'
+            : nest.nestingOperator === '>'
+            ? 'directChild'
+            : 'descendant'
+        add(nestResult, label, rule)
+      } else {
+        // We have a match!
+        state.found = true
+
+        if (!state.results.includes(node)) {
+          state.results.push(node)
         }
-        return 1;
+      }
     }
-    function readNumber() {
-        const start = idx;
-        let value = 0;
-        while (idx < formula.length &&
-            formula.charCodeAt(idx) >= ZERO &&
-            formula.charCodeAt(idx) <= NINE) {
-            value = value * 10 + (formula.charCodeAt(idx) - ZERO);
-            idx++;
-        }
-        // Return `null` if we didn't read anything.
-        return idx === start ? null : value;
+
+    // Descendant.
+    if (ruleSet.rule.nestingOperator === null) {
+      add(nestResult, 'descendant', ruleSet)
     }
-    function skipWhitespace() {
-        while (idx < formula.length &&
-            parse_whitespace.has(formula.charCodeAt(idx))) {
-            idx++;
-        }
+    // Adjacent.
+    else if (ruleSet.rule.nestingOperator === '~') {
+      add(nestResult, 'generalSibling', ruleSet)
     }
-}
-//# sourceMappingURL=parse.js.map
-// EXTERNAL MODULE: ../node_modules/boolbase/index.js
-var boolbase = __webpack_require__(286);
-;// CONCATENATED MODULE: ../node_modules/nth-check/lib/esm/compile.js
+    // Drop top-level nesting (`undefined`), direct child (`>`), adjacent sibling (`+`).
+  }
 
-/**
- * Returns a function that checks if an elements index matches the given rule
- * highly optimized to return the fastest solution.
- *
- * @param parsed A tuple [a, b], as returned by `parse`.
- * @returns A highly optimized function that returns whether an index matches the nth-check.
- * @example
- *
- * ```js
- * const check = nthCheck.compile([2, 3]);
- *
- * check(0); // `false`
- * check(1); // `false`
- * check(2); // `true`
- * check(3); // `false`
- * check(4); // `true`
- * check(5); // `false`
- * check(6); // `true`
- * ```
- */
-function compile(parsed) {
-    const a = parsed[0];
-    // Subtract 1 from `b`, to convert from one- to zero-indexed.
-    const b = parsed[1] - 1;
-    /*
-     * When `b <= 0`, `a * n` won't be lead to any matches for `a < 0`.
-     * Besides, the specification states that no elements are
-     * matched when `a` and `b` are 0.
-     *
-     * `b < 0` here as we subtracted 1 from `b` above.
-     */
-    if (b < 0 && a <= 0)
-        return boolbase.falseFunc;
-    // When `a` is in the range -1..1, it matches any element (so only `b` is checked).
-    if (a === -1)
-        return (index) => index <= b;
-    if (a === 0)
-        return (index) => index === b;
-    // When `b <= 0` and `a === 1`, they match any element.
-    if (a === 1)
-        return b < 0 ? boolbase.trueFunc : (index) => index >= b;
-    /*
-     * Otherwise, modulo can be used to check if there is a match.
-     *
-     * Modulo doesn't care about the sign, so let's use `a`s absolute value.
-     */
-    const absA = Math.abs(a);
-    // Get `b mod a`, + a if this is negative.
-    const bMod = ((b % absA) + absA) % absA;
-    return a > 1
-        ? (index) => index >= b && index % absA === bMod
-        : (index) => index <= b && index % absA === bMod;
+  return nestResult
 }
+
 /**
- * Returns a function that produces a monotonously increasing sequence of indices.
- *
- * If the sequence has an end, the returned function will return `null` after
- * the last index in the sequence.
+ * Combine two lists, if needed.
  *
- * @param parsed A tuple [a, b], as returned by `parse`.
- * @returns A function that produces a sequence of indices.
- * @example <caption>Always increasing (2n+3)</caption>
+ * This is optimized to create as few lists as possible.
  *
- * ```js
- * const gen = nthCheck.generate([2, 3])
- *
- * gen() // `1`
- * gen() // `3`
- * gen() // `5`
- * gen() // `8`
- * gen() // `11`
- * ```
- *
- * @example <caption>With end value (-2n+10)</caption>
- *
- * ```js
- *
- * const gen = nthCheck.generate([-2, 5]);
- *
- * gen() // 0
- * gen() // 2
- * gen() // 4
- * gen() // null
- * ```
+ * @param {Array<RuleSet> | undefined} left
+ * @param {Array<RuleSet> | undefined} right
+ * @returns {Array<RuleSet>}
  */
-function compile_generate(parsed) {
-    const a = parsed[0];
-    // Subtract 1 from `b`, to convert from one- to zero-indexed.
-    let b = parsed[1] - 1;
-    let n = 0;
-    // Make sure to always return an increasing sequence
-    if (a < 0) {
-        const aPos = -a;
-        // Get `b mod a`
-        const minValue = ((b % aPos) + aPos) % aPos;
-        return () => {
-            const val = minValue + aPos * n++;
-            return val > b ? null : val;
-        };
-    }
-    if (a === 0)
-        return b < 0
-            ? // There are no result — always return `null`
-                () => null
-            : // Return `b` exactly once
-                () => (n++ === 0 ? b : null);
-    if (b < 0) {
-        b += a * Math.ceil(-b / a);
-    }
-    return () => a * n++ + b;
+function combine(left, right) {
+  return left && right && left.length > 0 && right.length > 0
+    ? [...left, ...right]
+    : left && left.length > 0
+    ? left
+    : right && right.length > 0
+    ? right
+    : walk_empty
 }
-//# sourceMappingURL=compile.js.map
-;// CONCATENATED MODULE: ../node_modules/nth-check/lib/esm/index.js
-
-
 
 /**
- * Parses and compiles a formula to a highly optimized function.
- * Combination of {@link parse} and {@link compile}.
+ * Add a rule to a nesting map.
  *
- * If the formula doesn't match any elements,
- * it returns [`boolbase`](https://github.com/fb55/boolbase)'s `falseFunc`.
- * Otherwise, a function accepting an _index_ is returned, which returns
- * whether or not the passed _index_ matches the formula.
- *
- * Note: The nth-rule starts counting at `1`, the returned function at `0`.
- *
- * @param formula The formula to compile.
- * @example
- * const check = nthCheck("2n+3");
- *
- * check(0); // `false`
- * check(1); // `false`
- * check(2); // `true`
- * check(3); // `false`
- * check(4); // `true`
- * check(5); // `false`
- * check(6); // `true`
+ * @param {Nest} nest
+ * @param {keyof Nest} field
+ * @param {RuleSet} rule
  */
-function nthCheck(formula) {
-    return compile(esm_parse_parse(formula));
+function add(nest, field, rule) {
+  const list = nest[field]
+  if (list) {
+    list.push(rule)
+  } else {
+    nest[field] = [rule]
+  }
 }
+
 /**
- * Parses and compiles a formula to a generator that produces a sequence of indices.
- * Combination of {@link parse} and {@link generate}.
- *
- * @param formula The formula to compile.
- * @returns A function that produces a sequence of indices.
- * @example <caption>Always increasing</caption>
- *
- * ```js
- * const gen = nthCheck.sequence('2n+3')
- *
- * gen() // `1`
- * gen() // `3`
- * gen() // `5`
- * gen() // `8`
- * gen() // `11`
- * ```
+ * Count a node.
  *
- * @example <caption>With end value</caption>
- *
- * ```js
- *
- * const gen = nthCheck.sequence('-2n+5');
- *
- * gen() // 0
- * gen() // 2
- * gen() // 4
- * gen() // null
- * ```
+ * @param {Counts} counts
+ *   Counts.
+ * @param {Node} node
+ *   Node (we’re looking for elements).
+ * @returns {void}
+ *   Nothing.
  */
-function sequence(formula) {
-    return generate(parse(formula));
+function count(counts, node) {
+  if (node.type === 'element') {
+    // Uppercase to prevent prototype polution, injecting `constructor` or so.
+    // Normalize because HTML is insensitive.
+    const name = node.tagName.toUpperCase()
+    const count = (counts.types.get(name) || 0) + 1
+    counts.count++
+    counts.types.set(name, count)
+  }
 }
-//# sourceMappingURL=index.js.map
+
+// EXTERNAL MODULE: ../node_modules/css-selector-parser/lib/index.js
+var css_selector_parser_lib = __webpack_require__(510);
 ;// CONCATENATED MODULE: ../node_modules/hast-util-select/lib/parse.js
 /**
- * @typedef {import('./types.js').Selector} Selector
  * @typedef {import('./types.js').Selectors} Selectors
  * @typedef {import('./types.js').RuleSet} RuleSet
- * @typedef {import('./types.js').Rule} Rule
- * @typedef {import('./types.js').RulePseudo} RulePseudo
- * @typedef {import('./types.js').RulePseudoNth} RulePseudoNth
  */
 
 
 
-
-
-/** @type {import('nth-check').default} */
-// @ts-expect-error
-const parse_nthCheck = nthCheck["default"] || nthCheck
-
-const nth = new Set([
-  'nth-child',
-  'nth-last-child',
-  'nth-of-type',
-  'nth-last-of-type'
-])
-
 const parse_parser = new css_selector_parser_lib/* CssSelectorParser */.N()
 
-// @ts-expect-error: hush.
-const parse_compile = zwitch('type', {handlers: {selectors: parse_selectors, ruleSet: parse_ruleSet, rule: parse_rule}})
-
 parse_parser.registerAttrEqualityMods('~', '|', '^', '$', '*')
 parse_parser.registerSelectorPseudos('any', 'matches', 'not', 'has')
 parse_parser.registerNestingOperators('>', '+', '~')
 
 /**
  * @param {string} selector
- * @returns {Selector}
+ * @returns {Selectors | RuleSet | null}
  */
 function lib_parse_parse(selector) {
   if (typeof selector !== 'string') {
     throw new TypeError('Expected `string` as selector, not `' + selector + '`')
   }
 
-  // @ts-expect-error types are wrong.
-  return parse_compile(parse_parser.parse(selector))
-}
-
-/**
- * @param {Selectors} query
- * @returns {Selectors}
- */
-function parse_selectors(query) {
-  let index = -1
-
-  while (++index < query.selectors.length) {
-    parse_compile(query.selectors[index])
-  }
-
-  return query
-}
-
-/**
- * @param {RuleSet} query
- * @returns {Rule}
- */
-function parse_ruleSet(query) {
-  return parse_rule(query.rule)
-}
-
-/**
- * @param {Rule} query
- * @returns {Rule}
- */
-function parse_rule(query) {
-  const pseudos = query.pseudos || []
-  let index = -1
-
-  while (++index < pseudos.length) {
-    const pseudo = pseudos[index]
-
-    if (nth.has(pseudo.name)) {
-      // @ts-expect-error Patch a non-primitive type.
-      pseudo.value = parse_nthCheck(pseudo.value)
-      // @ts-expect-error Patch a non-primitive type.
-      pseudo.valueType = 'function'
-    }
-  }
-
-  parse_compile(query.rule)
-
-  return query
+  return parse_parser.parse(selector)
 }
 
 ;// CONCATENATED MODULE: ../node_modules/hast-util-select/index.js
 /**
  * @typedef {import('./lib/types.js').Element} Element
- * @typedef {import('./lib/types.js').HastNode} HastNode
+ * @typedef {import('./lib/types.js').Node} Node
  * @typedef {import('./lib/types.js').Space} Space
+ * @typedef {import('./lib/types.js').SelectState} SelectState
  */
 
 
 
 
+
 /**
+ * Check that the given `node` matches `selector`.
+ *
+ * This only checks the element itself, not the surrounding tree.
+ * Thus, nesting in selectors is not supported (`p b`, `p > b`), neither are
+ * selectors like `:first-child`, etc.
+ * This only checks that the given element matches the selector.
+ *
  * @param {string} selector
- * @param {HastNode} [node]
- * @param {Space} [space]
+ *   CSS selector, such as (`h1`, `a, b`).
+ * @param {Node | null | undefined} [node]
+ *   Node that might match `selector`, should be an element.
+ * @param {Space | null | undefined} [space='html']
+ *   Name of namespace (`'svg'` or `'html'`).
  * @returns {boolean}
+ *   Whether `node` matches `selector`.
  */
 function hast_util_select_matches(selector, node, space) {
-  return Boolean(
-    any(parse(selector), node, {space, one: true, shallow: true})[0]
-  )
+  const state = createState(selector, node, space)
+  state.one = true
+  state.shallow = true
+  walk(state, node || undefined)
+  return state.results.length > 0
 }
 
 /**
+ * Select the first element that matches `selector` in the given `tree`.
+ * Searches the tree in *preorder*.
+ *
  * @param {string} selector
- * @param {HastNode} [node]
- * @param {Space} [space]
- * @returns {Element|null}
- */
-function hast_util_select_select(selector, node, space) {
-  return any(parse(selector), node, {space, one: true})[0] || null
+ *   CSS selector, such as (`h1`, `a, b`).
+ * @param {Node | null | undefined} [tree]
+ *   Tree to search.
+ * @param {Space | null | undefined} [space='html']
+ *   Name of namespace (`'svg'` or `'html'`).
+ * @returns {Element | null}
+ *   First element in `tree` that matches `selector` or `null` if nothing is
+ *   found.
+ *   This could be `tree` itself.
+ */
+function hast_util_select_select(selector, tree, space) {
+  const state = createState(selector, tree, space)
+  state.one = true
+  walk(state, tree || undefined)
+  // To do in major: return `undefined` instead.
+  return state.results[0] || null
 }
 
 /**
+ * Select all elements that match `selector` in the given `tree`.
+ * Searches the tree in *preorder*.
+ *
  * @param {string} selector
- * @param {HastNode} [node]
- * @param {Space} [space]
+ *   CSS selector, such as (`h1`, `a, b`).
+ * @param {Node | null | undefined} [tree]
+ *   Tree to search.
+ * @param {Space | null | undefined} [space='html']
+ *   Name of namespace (`'svg'` or `'html'`).
  * @returns {Array<Element>}
+ *   Elements in `tree` that match `selector`.
+ *   This could include `tree` itself.
  */
-function selectAll(selector, node, space) {
-  return any_any(lib_parse_parse(selector), node, {space})
+function selectAll(selector, tree, space) {
+  const state = createState(selector, tree, space)
+  walk_walk(state, tree || undefined)
+  return state.results
+}
+
+/**
+ * @param {string} selector
+ *   Tree to search.
+ * @param {Node | null | undefined} [tree]
+ *   Tree to search.
+ * @param {Space | null | undefined} [space='html']
+ *   Name of namespace (`'svg'` or `'html'`).
+ * @returns {SelectState} SelectState
+ */
+function createState(selector, tree, space) {
+  return {
+    // State of the query.
+    rootQuery: queryToSelectors(lib_parse_parse(selector)),
+    results: [],
+    // @ts-expect-error assume elements.
+    scopeElements: tree ? (tree.type === 'root' ? tree.children : [tree]) : [],
+    one: false,
+    shallow: false,
+    found: false,
+    // State in the tree.
+    schema: space === 'svg' ? property_information_svg : property_information_html,
+    language: undefined,
+    direction: 'ltr',
+    editableOrEditingHost: false,
+    typeIndex: undefined,
+    elementIndex: undefined,
+    typeCount: undefined,
+    elementCount: undefined
+  }
 }
 
 ;// CONCATENATED MODULE: ../node_modules/rehype-rewrite/lib/index.js