@asamuzakjp/dom-selector 8.1.5 → 8.2.1

package/src/js/matcher.js

@@ -33,6 +33,8 @@ const KEYS_FORM_PS_DISABLED = new Set([
   'option'
 ]);
 const KEYS_INPUT_EDIT = new Set(INPUT_EDIT);
+
+/* regexp */
 const REG_LANG_VALID = new RegExp(`^(?:\\*-)?${ALPHA_NUM}${LANG_PART}$`, 'i');
 
 /**

package/src/js/nwsapi.js

@@ -5,12 +5,12 @@
  */
 
 /* import */
-import { GenerationalCache } from '@asamuzakjp/generational-cache';
+import { LRUCache } from 'lru-cache';
 import { isContentEditable } from './utility.js';
 
 /* constants */
 import { DOCUMENT_NODE, ELEMENT_NODE } from './constant.js';
-const CACHE_SIZE = 2048;
+const CACHE_SIZE = 4096;
 const F_INIT = '"use strict";return function resolver(c,f,x,r)';
 const S_HEAD = 'var e,n,o,j=r.length-1,k=-1';
 const M_HEAD = 'var e,n,o';
@@ -465,13 +465,12 @@ export class Nwsapi {
   constructor(window, document, cacheSize = CACHE_SIZE) {
     this.#window = window;
     const cacheOpt = {
-      cacheFunction: true,
-      strictValidate: false
+      max: cacheSize
     };
-    this.#matchLambdas = new GenerationalCache(cacheSize, cacheOpt);
-    this.#selectLambdas = new GenerationalCache(cacheSize, cacheOpt);
-    this.#matchResolvers = new GenerationalCache(cacheSize, cacheOpt);
-    this.#selectResolvers = new GenerationalCache(cacheSize, cacheOpt);
+    this.#matchLambdas = new LRUCache(cacheOpt);
+    this.#selectLambdas = new LRUCache(cacheOpt);
+    this.#matchResolvers = new LRUCache(cacheOpt);
+    this.#selectResolvers = new LRUCache(cacheOpt);
     this.#nthChildState = {
       idx: 0,
       len: 0,

package/src/js/parser.js

@@ -55,10 +55,12 @@ const KEYS_PS_CLASS_STATE = new Set([
   'valid'
 ]);
 const KEYS_SHADOW_HOST = new Set(['host', 'host-context']);
+const U_FFFD = '\uFFFD';
+
+/* regexp */
 const REG_EMPTY_PS_FUNC =
   /(?<=:(?:dir|has|host(?:-context)?|is|lang|not|nth-(?:last-)?(?:child|of-type)|where))\(\s+\)/g;
 const REG_SHADOW_PS_ELEMENT = /^part|slotted$/;
-const U_FFFD = '\uFFFD';
 
 /**
  * Unescapes a CSS selector string.

package/src/js/utility.js

@@ -45,6 +45,8 @@ const KEYS_NODE_FOCUSABLE_SVG = new Set([
   'symbol',
   'title'
 ]);
+
+/* regexp */
 const REG_IS_HTML = /^(?:application\/xhtml\+x|text\/ht)ml$/;
 const REG_IS_XML =
   /^(?:application\/(?:[\w\-.]+\+)?|image\/[\w\-.]+\+|text\/)xml$/;
@@ -90,43 +92,6 @@ export const generateException = (msg, name, globalObject = globalThis) => {
   return new globalObject.DOMException(msg, name);
 };
 
-/**
- * Filter a list of nodes based on An+B logic
- * @param {Array.<object>} nodes - array of nodes to filter
- * @param {object} anb - An+B options
- * @param {number} anb.a - a
- * @param {number} anb.b - b
- * @param {boolean} [anb.reverse] - reverse order
- * @returns {Array.<object>} - array of matched nodes
- */
-export const filterNodesByAnB = (nodes, anb) => {
-  const { a, b, reverse } = anb;
-  const processedNodes = reverse ? [...nodes].reverse() : nodes;
-  const l = nodes.length;
-  const matched = [];
-  if (a === 0) {
-    if (b > 0 && b <= l) {
-      matched.push(processedNodes[b - 1]);
-    }
-    return matched;
-  }
-  let startIndex = b - 1;
-  if (a > 0) {
-    while (startIndex < 0) {
-      startIndex += a;
-    }
-    for (let i = startIndex; i < l; i += a) {
-      matched.push(processedNodes[i]);
-    }
-  } else if (startIndex >= 0) {
-    for (let i = startIndex; i >= 0; i += a) {
-      matched.push(processedNodes[i]);
-    }
-    return matched.reverse();
-  }
-  return matched;
-};
-
 /**
  * Resolve content document, root node, and check if it's in a shadow DOM.
  * @param {object} node - Document, DocumentFragment, or Element node.

package/types/js/constant.d.ts

@@ -2,6 +2,8 @@ export const ATRULE: "Atrule";
 export const ATTR_SELECTOR: "AttributeSelector";
 export const CLASS_SELECTOR: "ClassSelector";
 export const COMBINATOR: "Combinator";
+export const DIR_NEXT: "next";
+export const DIR_PREV: "prev";
 export const IDENT: "Identifier";
 export const ID_SELECTOR: "IdSelector";
 export const NOT_SUPPORTED_ERR: "NotSupportedError";

package/types/js/evaluator.d.ts

@@ -0,0 +1,59 @@
+export class Evaluator {
+    constructor(window: object);
+    window: object;
+    documentCache: WeakMap<WeakKey, any>;
+    setup(selector: string, node: object, opt?: {
+        check?: boolean | undefined;
+        noexcept?: boolean | undefined;
+        warn?: boolean | undefined;
+    }): object;
+    check: boolean | undefined;
+    noexcept: boolean | undefined;
+    warn: boolean | undefined;
+    matchOpts: {
+        warn: boolean;
+    } | undefined;
+    node: object | undefined;
+    pseudoElements: any[] | undefined;
+    invalidate: boolean | undefined;
+    onError: (e: Error, opt?: {
+        noexcept?: boolean | undefined;
+    }) => void;
+    clearResults: (all?: boolean) => void;
+    matchSelector: (ast: object, node: object, opt: object) => boolean;
+    matchLeaves: (leaves: Array<object>, node: object, opt: object) => boolean;
+    getFilterLeaves: (leaves: Array<object>) => Array<object>;
+    evaluateShadowHost: (ast: object, node: object) => boolean;
+    matchPseudoClassSelector: (ast: object, node: object, opt?: {
+        forgive?: boolean | undefined;
+        warn?: boolean | undefined;
+    }) => Set<object> | boolean;
+    createTreeWalker: (node: object, opt?: {
+        force?: boolean | undefined;
+        whatToShow?: number | undefined;
+    }) => object;
+    yieldCombinatorMatches(twig: object, node: object, opt?: {
+        dir?: string | undefined;
+    }): Generator<any, void, unknown>;
+    yieldTraverseAllDescendants(baseNode: object, leaves: Array<object>, opt: object): Generator<any, void, unknown>;
+    yieldFindDescendantNodes(leaves: Array<object>, baseNode: object, opt: object): Generator<any, void, unknown>;
+    private _handleFocusEvent;
+    private _handleKeyboardEvent;
+    private _handleMouseEvent;
+    private _registerEventListeners;
+    private _getSelectorBranches;
+    private _filterNthChildOfSelectorBranches;
+    private _matchAnPlusB;
+    private _hasCombinatorMatch;
+    private _matchHasPseudoFunc;
+    private _buildHasAllowlist;
+    private _evaluateHasPseudo;
+    private _matchLogicalPseudoFunc;
+    private _evaluateLogicalPseudo;
+    private _evaluatePseudoClassFunc;
+    private _evaluateHostPseudo;
+    private _evaluateHostContextPseudo;
+    private _matchSelectorForElement;
+    private _matchSelectorForShadowRoot;
+    #private;
+}

package/types/js/finder.d.ts

@@ -1,45 +1,8 @@
-export class Finder {
-    constructor(window: object);
-    onError: (e: Error, opt?: {
-        noexcept?: boolean | undefined;
-    }) => void;
-    setup: (selector: string, node: object, opt?: {
-        check?: boolean | undefined;
-        noexcept?: boolean | undefined;
-        warn?: boolean | undefined;
-    }) => object;
-    clearResults: (all?: boolean) => void;
-    private _handleFocusEvent;
-    private _handleKeyboardEvent;
-    private _handleMouseEvent;
-    private _registerEventListeners;
+export class Finder extends Evaluator {
+    find: (targetType: string) => Set<object> | object;
+    getAST: (selector: string) => object;
     private _processSelectorBranches;
     private _correspond;
-    private _createTreeWalker;
-    private _getSelectorBranches;
-    private _getFilteredChildren;
-    private _collectNthChild;
-    private _collectNthOfType;
-    private _matchAnPlusB;
-    private _matchHasPseudoFunc;
-    private _buildHasAllowlist;
-    private _evaluateHasPseudo;
-    private _matchLogicalPseudoFunc;
-    private _evaluateLogicalPseudo;
-    private _evaluatePseudoClassFunc;
-    private _matchPseudoClassSelector;
-    private _evaluateHostPseudo;
-    private _evaluateHostContextPseudo;
-    private _evaluateShadowHost;
-    private _matchSelectorForElement;
-    private _matchSelectorForShadowRoot;
-    private _matchSelector;
-    private _matchLeaves;
-    private _getFilterLeaves;
-    private _traverseAllDescendants;
-    private _findDescendantNodes;
-    private _collectCombinatorMatches;
-    private _matchCombinator;
     private _traverseAndCollectNodes;
     private _findPrecede;
     private _findNodeWalker;
@@ -54,12 +17,10 @@ export class Finder {
     private _determineTraversalStrategy;
     private _processPendingItems;
     private _collectNodes;
-    private _getCombinedNodes;
     private _matchNodeNext;
-    private _matchNodePrev;
+    private _hasValidPathPrev;
     private _processComplexBranchAll;
     private _processComplexBranchFirst;
-    find: (targetType: string) => Set<object>;
-    getAST: (selector: string) => object;
     #private;
 }
+import { Evaluator } from './evaluator.js';

package/types/js/utility.d.ts

@@ -1,11 +1,6 @@
 export function getType(o: object): string;
 export function verifyArray(arr: any[], type: string): any[];
 export function generateException(msg: string, name: string, globalObject?: object): DOMException;
-export function filterNodesByAnB(nodes: Array<object>, anb: {
-    a: number;
-    b: number;
-    reverse?: boolean | undefined;
-}): Array<object>;
 export function resolveContent(node: object): Array<object | boolean>;
 export function traverseNode(node: object, walker: object, force?: boolean): object | null;
 export function isCustomElement(node: object, { formAssociated }?: {