@markuplint/rules 2.4.3 → 3.0.0-alpha.1

package/lib/permitted-contents/index.js

@@ -1,282 +1,111 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
 const ml_core_1 = require("@markuplint/ml-core");
-const helpers_1 = require("../helpers");
-const permitted_content_spec_to_regexp_1 = tslib_1.__importDefault(require("./permitted-content.spec-to-regexp"));
-const unfold_content_models_to_tags_1 = tslib_1.__importDefault(require("./unfold-content-models-to-tags"));
-const expMapOnNodeId = new Map();
+const content_model_1 = require("./content-model");
+const represent_transparent_nodes_1 = require("./represent-transparent-nodes");
 exports.default = (0, ml_core_1.createRule)({
     defaultValue: [],
     defaultOptions: {
         ignoreHasMutableChildren: true,
     },
     async verify({ document, report, t }) {
-        let idCounter = 0;
-        await document.walkOn('Element', node => {
-            var _a;
-            if (!node.rule.value) {
+        await document.walkOn('Element', el => {
+            var _a, _b, _c;
+            if (!el.rule.value) {
                 return;
             }
-            if (node.rule.option.ignoreHasMutableChildren && node.hasMutableChildren()) {
+            if (el.rule.option.ignoreHasMutableChildren && el.hasMutableChildren()) {
                 return;
             }
-            const specType = node.ns === 'html' ? 'HTML' : node.ns === 'svg' ? 'SVG' : 'Any Language';
-            const childNodes = node.getChildElementsAndTextNodeWithoutWhitespaces();
-            const spec = !node.isCustomElement && ((_a = (0, helpers_1.htmlSpec)(document.specs, node.nameWithNS)) === null || _a === void 0 ? void 0 : _a.permittedStructures);
-            const expGen = new permitted_content_spec_to_regexp_1.default(idCounter++);
-            if (spec) {
-                if (spec.ancestor && !node.closest(spec.ancestor)) {
-                    report({
-                        scope: node,
-                        message: t('{0} must be {1}', t('the "{0*}" {1}', node.nodeName, 'element'), t('{0} of {1}', 'descendant', t('the "{0*}" {1}', spec.ancestor, 'element'))),
-                    });
-                    return;
-                }
-                let matched = false;
-                if (spec.conditional) {
-                    for (const conditional of spec.conditional) {
-                        matched =
-                            ('hasAttr' in conditional.condition && node.hasAttribute(conditional.condition.hasAttr)) ||
-                                ('parent' in conditional.condition &&
-                                    !!node.parentNode &&
-                                    node.parentNode.type === 'Element' &&
-                                    node.parentNode.matches(conditional.condition.parent));
-                        // console.log({ ...conditional, matched });
-                        if (matched) {
-                            try {
-                                const parentExp = getRegExpFromParentNode(document.specs, node, expGen);
-                                const exp = expGen.specToRegExp(conditional.contents, parentExp, node.ns);
-                                const conditionalResult = match(exp, childNodes, node.ns, false);
-                                if (!conditionalResult) {
-                                    const message = t('{0} is {1:c}', t('{0} of {1}', t('the {0}', 'content'), t('the "{0*}" {1}', node.nodeName, 'element')), 'invalid');
-                                    report({
-                                        scope: node,
-                                        message: specType !== 'Any Language'
-                                            ? t('{0} according to {1}', message, `the ${specType} specification`)
-                                            : message,
-                                        line: node.startLine,
-                                        col: node.startCol,
-                                        raw: node.raw,
-                                    });
-                                    break;
-                                }
-                            }
-                            catch (e) {
-                                if (e instanceof Error) {
-                                    // eslint-disable-next-line no-console
-                                    console.warn(node.raw, 'conditional', conditional, e.message);
-                                }
-                                else {
-                                    throw e;
-                                }
-                            }
-                        }
+            const results = (0, content_model_1.contentModel)(el, el.rule.value, el.rule.option);
+            for (const { type, scope, query, hint } of results) {
+                let message = '';
+                if (hint) {
+                    if (hint.max != null) {
+                        message =
+                            t('there is more content than it needs') +
+                                t('. ') +
+                                t('the max number of elements required is {0}', `${hint.max}`);
                     }
                 }
-                if (!matched) {
-                    try {
-                        const exp = getRegExpFromNode(document.specs, node, expGen);
-                        const specResult = match(exp, childNodes, node.ns, false);
-                        if (!specResult) {
-                            const message = t('{0} is {1:c}', t('{0} of {1}', t('the {0}', 'content'), t('the "{0*}" {1}', node.nodeName, 'element')), 'invalid');
-                            report({
-                                scope: node,
-                                message: specType !== 'Any Language'
-                                    ? t('{0} according to {1}', message, `the ${specType} specification`)
-                                    : message,
-                            });
-                        }
+                switch (type) {
+                    case 'MATCHED':
+                    case 'MATCHED_ZERO': {
+                        break;
                     }
-                    catch (e) {
-                        if (e instanceof Error) {
-                            // eslint-disable-next-line no-console
-                            console.warn(node.raw, 'HTML Spec', e.message);
-                        }
-                        else {
-                            throw e;
-                        }
+                    case 'MISSING_NODE_ONE_OR_MORE': {
+                        message =
+                            message ||
+                                t('Require {0}', t('one or more elements')) + t('. ') + '(' + t('Need "{0*}"', query) + ')';
+                        report({
+                            scope,
+                            message,
+                        });
+                        break;
                     }
-                }
-            }
-            for (const rule of node.rule.value) {
-                if (rule.tag.toLowerCase() !== node.nodeName.toLowerCase()) {
-                    continue;
-                }
-                const parentExp = getRegExpFromParentNode(document.specs, node, expGen);
-                try {
-                    const exp = expGen.specToRegExp(rule.contents, parentExp, node.ns);
-                    // Evaluate the custom element if the optional schema.
-                    const r = match(exp, childNodes, node.ns, node.isCustomElement);
-                    if (!r) {
+                    case 'MISSING_NODE_REQUIRED': {
+                        message =
+                            message ||
+                                t('Require {0}', t('an {0}', 'element')) + t('. ') + '(' + t('Need "{0*}"', query) + ')';
                         report({
-                            scope: node,
-                            message: t('{0} is {1:c}', t('{0} of {1}', t('the {0}', 'content'), t('the "{0*}" {1}', node.nodeName, 'element')), 'invalid'),
-                            line: node.startLine,
-                            col: node.startCol,
-                            raw: node.raw,
+                            scope,
+                            message,
                         });
-                        return;
+                        break;
                     }
-                }
-                catch (e) {
-                    if (e instanceof Error) {
-                        // eslint-disable-next-line no-console
-                        console.warn(node.raw, 'rule', rule, e.message);
+                    case 'UNEXPECTED_EXTRA_NODE': {
+                        const not = (_a = hint.not) !== null && _a !== void 0 ? _a : scope;
+                        message =
+                            message ||
+                                (represent_transparent_nodes_1.transparentMode.has(scope)
+                                    ? t('{0} is not allowed in {1} through the transparent model in this context', name(not, t), name(el, t))
+                                    : t('{0} is not allowed in {1} in this context', name(not, t), name(el, t)));
+                        report({
+                            scope: not,
+                            message,
+                        });
+                        break;
+                    }
+                    case 'TRANSPARENT_MODEL_DISALLOWS': {
+                        const not = (_b = hint.not) !== null && _b !== void 0 ? _b : scope;
+                        const tp = (_c = hint.transparent) !== null && _c !== void 0 ? _c : el;
+                        report({
+                            scope: not,
+                            message: t('{0} is {1} but {2}', name(tp, t), t('a {0}', 'transparent model'), t('also disallows {0} in this context', name(not, t))),
+                        });
+                        break;
+                    }
+                    case 'VOID_ELEMENT': {
+                        report({
+                            scope: el,
+                            message: t('{0} is {1}', t('the {0}', 'element'), t('a {0}', 'void element')),
+                        });
+                        break;
                     }
-                    else {
-                        throw e;
+                    default: {
+                        throw new Error('Unreachable code');
                     }
                 }
             }
+            represent_transparent_nodes_1.transparentMode.clear();
         });
-        expMapOnNodeId.clear();
     },
 });
-function normalization(nodes, ownNS, evalCustomElement) {
-    return nodes
-        .map(node => {
-        // FIXME: https://github.com/markuplint/markuplint/issues/388
-        if (!evalCustomElement && node.type === 'Element' && node.isCustomElement) {
-            return '';
-        }
-        if (node.type !== 'Element') {
-            return '<#text>';
-        }
-        ownNS = ownNS || 'html';
-        const name = node.nameWithNS.replace(new RegExp(`^${ownNS}:`), '');
-        return `<${name}>`;
-    })
-        .join('');
-}
-function getRegExpFromNode(specs, node, expGen) {
-    var _a;
-    // console.log({ n: node.nodeName });
-    if (expMapOnNodeId.has(node.uuid)) {
-        return expMapOnNodeId.get(node.uuid);
+function name(scope, t) {
+    if (scope.is(scope.ELEMENT_NODE)) {
+        return t('the "{0}" {1}', scope.localName, 'element');
     }
-    const parentExp = node.parentNode ? getRegExpFromNode(specs, node.parentNode, expGen) : null;
-    const spec = !node.isCustomElement && ((_a = (0, helpers_1.htmlSpec)(specs, node.nameWithNS || node.nodeName.toLowerCase())) === null || _a === void 0 ? void 0 : _a.permittedStructures);
-    const contentRule = spec ? spec.contents : true;
-    const exp = expGen.specToRegExp(contentRule, parentExp, node.ns || null);
-    expMapOnNodeId.set(node.uuid, exp);
-    return exp;
-}
-function getRegExpFromParentNode(specs, node, expGen) {
-    // console.log({ p: node.nodeName });
-    const parentExp = node.parentNode ? getRegExpFromNode(specs, node.parentNode, expGen) : null;
-    return parentExp;
-}
-const matchingCacheMap = new Map();
-function match(exp, childNodes, ownNS, evalCustomElement) {
-    const target = normalization(childNodes, ownNS, evalCustomElement);
-    const cacheKey = target + exp.source + childNodes.map(n => (n.type == 'Element' ? n.toNormalizeString() : n.originRaw)).join('');
-    const res = matchingCacheMap.get(cacheKey);
-    if (res != null) {
-        return res;
+    if (scope.is(scope.TEXT_NODE)) {
+        return t('the {0}', 'text node');
     }
-    const matched = _match(target, exp, childNodes);
-    matchingCacheMap.set(cacheKey, matched);
-    return matched;
-}
-function _match(target, exp, childNodes) {
-    const result = exp.exec(target);
-    if (!result) {
-        return false;
+    if (scope.is(scope.CDATA_SECTION_NODE)) {
+        return t('the {0}', 'comment');
     }
-    const capGroups = result.groups;
-    // console.log({ exp, target, capGroups });
-    if (!capGroups) {
-        return true;
+    if (scope.is(scope.DOCUMENT_TYPE_NODE)) {
+        return t('the {0}', 'doctype');
     }
-    const groupNames = Object.keys(capGroups);
-    for (const groupName of groupNames) {
-        const matched = capGroups[groupName];
-        if (!matched) {
-            continue;
-        }
-        const [type, , ..._selector] = groupName.split(/(?<=[a-z0-9])_/gi);
-        // console.log({ type, _selector });
-        switch (type) {
-            case 'ACM': {
-                const [model, tag] = _selector;
-                const selectors = (0, unfold_content_models_to_tags_1.default)(`#${model}`).filter(selector => {
-                    const [, tagName] = /^([^[\]]+)(?:\[[^\]]+\])?$/.exec(selector) || [];
-                    return tagName.toLowerCase() === tag.toLowerCase();
-                });
-                for (const node of childNodes) {
-                    if (node.type === 'Text') {
-                        continue;
-                    }
-                    if (node.nodeName.toLowerCase() !== tag.toLowerCase()) {
-                        continue;
-                    }
-                    for (const selector of selectors) {
-                        const matched = node.matches(selector);
-                        // console.log({ raw: node.raw, selector, matched });
-                        if (matched) {
-                            return true;
-                        }
-                    }
-                    return false;
-                }
-                break;
-            }
-            case 'NAD': {
-                let targetsMaybeIncludesNotAllowedDescendants = Array.from(new Set(matched.split(/><|<|>/g).filter(_ => _)));
-                const contents = new Set();
-                const transparentGroupName = groupNames.find(name => /^TRANSPARENT_[0-9]+$/.test(name));
-                const inTransparent = _selector.includes('__InTRANSPARENT')
-                    ? transparentGroupName && capGroups[transparentGroupName]
-                        ? capGroups[transparentGroupName].split(/><|<|>/g).filter(_ => _)
-                        : null
-                    : null;
-                _selector.forEach(content => {
-                    if (content[0] === '_') {
-                        (0, unfold_content_models_to_tags_1.default)(content.replace('_', '#')).forEach(tag => contents.add(tag));
-                        return;
-                    }
-                    contents.add(content);
-                });
-                const selectors = Array.from(contents);
-                targetsMaybeIncludesNotAllowedDescendants = targetsMaybeIncludesNotAllowedDescendants.filter(content => inTransparent ? inTransparent.includes(content) : true);
-                // console.log({
-                // 	groupName,
-                // 	matched,
-                // 	_selector,
-                // 	type,
-                // 	selectors,
-                // 	inTransparent,
-                // 	targetsMaybeIncludesNotAllowedDescendants,
-                // });
-                for (const node of childNodes) {
-                    for (const target of targetsMaybeIncludesNotAllowedDescendants) {
-                        if (node.type === 'Text') {
-                            if (selectors.includes('#text')) {
-                                return false;
-                            }
-                            continue;
-                        }
-                        if (node.nodeName.toLowerCase() !== target.toLowerCase()) {
-                            continue;
-                        }
-                        for (const selector of selectors) {
-                            // console.log({ selector, target });
-                            // Self
-                            if (node.matches(selector)) {
-                                return false;
-                            }
-                            // Descendants
-                            const nodeList = node.querySelectorAll(selector);
-                            if (nodeList.length) {
-                                return false;
-                            }
-                        }
-                    }
-                }
-                break;
-            }
-        }
+    if (scope.is(scope.MARKUPLINT_PREPROCESSOR_BLOCK)) {
+        return t('the {0}', 'code block');
     }
-    return true;
+    return t('the {0}', 'node');
 }

package/lib/permitted-contents/matches-selector.d.ts

@@ -0,0 +1,3 @@
+import type { ChildNode, Options, Result, Specs } from './types';
+export declare type SelectorResult = Result<'UNMATCHED_SELECTOR_BUT_MAY_EMPTY' | 'MISSING_NODE' | 'UNMATCHED_SELECTORS'>;
+export declare function matchesSelector(query: string, node: ChildNode | undefined, specs: Specs, options: Options, depth: number): SelectorResult;

package/lib/permitted-contents/matches-selector.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesSelector = void 0;
+const ml_spec_1 = require("@markuplint/ml-spec");
+const debug_1 = require("./debug");
+const utils_1 = require("./utils");
+function matchesSelector(query, node, specs, options, depth) {
+    const nodeLog = debug_1.cmLog.extend(`node#${depth}`);
+    const { selector, hasText, hasCustom } = optCondition(query, specs);
+    if (node == null) {
+        if (hasText) {
+            nodeLog('<#text>.matches(%s) => ""', query);
+            return {
+                type: 'MATCHED_ZERO',
+                matched: node ? [node] : [],
+                unmatched: [],
+                zeroMatch: true,
+                query,
+                hint: {},
+            };
+        }
+        return {
+            type: 'MISSING_NODE',
+            matched: [],
+            unmatched: [],
+            zeroMatch: false,
+            query,
+            hint: {},
+        };
+    }
+    if (node.is(node.TEXT_NODE)) {
+        if (hasText) {
+            nodeLog('<#text>.matches(%s) => "%s"', query, node.raw.trim());
+            return {
+                type: 'MATCHED',
+                matched: [node],
+                unmatched: [],
+                zeroMatch: true,
+                query,
+                hint: {},
+            };
+        }
+        if (node.isWhitespace()) {
+            nodeLog('<#text>.matches(%s) => WHITESPACE', query);
+            return {
+                type: 'MATCHED',
+                matched: [node],
+                unmatched: [],
+                zeroMatch: true,
+                query,
+                hint: {},
+            };
+        }
+        // Disallows a text node
+        return {
+            type: 'UNEXPECTED_EXTRA_NODE',
+            matched: [],
+            unmatched: [node],
+            zeroMatch: false,
+            query,
+            hint: {},
+        };
+    }
+    if (node.is(node.MARKUPLINT_PREPROCESSOR_BLOCK)) {
+        nodeLog('%s.matches(%s) => PBlock', node.raw, query);
+        return {
+            type: 'MATCHED',
+            matched: [node],
+            unmatched: [],
+            zeroMatch: !!hasText,
+            query,
+            hint: {},
+        };
+    }
+    if (node.is(node.ELEMENT_NODE)) {
+        if (node.elementType !== 'html' && hasCustom) {
+            nodeLog('%s.matches(%s) => CustomElement', node.raw, query);
+            return {
+                type: 'MATCHED',
+                matched: [node],
+                unmatched: [],
+                zeroMatch: !!hasText,
+                query,
+                hint: {},
+            };
+        }
+        const result = (0, utils_1.matches)(selector, node, specs);
+        nodeLog('%s.matches(%s) => %s', node.raw, query, result.matched);
+        if (result.matched) {
+            return {
+                type: 'MATCHED',
+                matched: [node],
+                unmatched: [],
+                zeroMatch: !!hasText,
+                query,
+                hint: {},
+            };
+        }
+        if (hasText) {
+            return {
+                type: 'UNMATCHED_SELECTOR_BUT_MAY_EMPTY',
+                matched: [],
+                unmatched: [node],
+                zeroMatch: true,
+                query,
+                hint: {
+                    not: result.not,
+                },
+            };
+        }
+        return {
+            type: 'UNMATCHED_SELECTORS',
+            matched: [],
+            unmatched: [node],
+            zeroMatch: false,
+            query,
+            hint: {
+                not: result.not,
+            },
+        };
+    }
+    return {
+        type: 'MATCHED',
+        matched: [node],
+        unmatched: [],
+        zeroMatch: !!hasText,
+        query,
+        hint: {},
+    };
+}
+exports.matchesSelector = matchesSelector;
+const conditionWithoutSpecs = {
+    '#custom': {
+        selector: '#custom',
+        hasCustom: true,
+        hasText: false,
+    },
+    '#text': {
+        selector: '#text',
+        hasCustom: false,
+        hasText: true,
+    },
+};
+const optConditionSpecsBaseCaches = new Map();
+function optCondition(query, specs) {
+    var _a;
+    const condWithoutSpecs = conditionWithoutSpecs[query];
+    if (condWithoutSpecs) {
+        return condWithoutSpecs;
+    }
+    const queryCaches = (_a = optConditionSpecsBaseCaches.get(specs)) !== null && _a !== void 0 ? _a : new Map();
+    const cached = queryCaches.get(query);
+    if (cached) {
+        return cached;
+    }
+    let hasCustom = false;
+    let hasText = false;
+    const selector = query.replace(/^(?::model\(([^)]+)\)|#([a-z-]+))(.*)$/, (_, $model, _model, $last) => {
+        const _selectors = (0, ml_spec_1.contentModelCategoryToTagNames)(`#${$model !== null && $model !== void 0 ? $model : _model}`, specs.def);
+        if (_selectors.length === 0) {
+            throw new Error(`${$model !== null && $model !== void 0 ? $model : _model} is empty`);
+        }
+        const selectors = [];
+        for (const selector of _selectors) {
+            if (selector === '#custom') {
+                hasCustom = true;
+                continue;
+            }
+            if (selector === '#text') {
+                hasText = true;
+                continue;
+            }
+            selectors.push(selector);
+        }
+        return `:is(${selectors.join(',')})${$last !== null && $last !== void 0 ? $last : ''}`;
+    });
+    const result = {
+        selector,
+        hasCustom,
+        hasText,
+    };
+    queryCaches.set(query, result);
+    optConditionSpecsBaseCaches.set(specs, queryCaches);
+    return result;
+}

package/lib/permitted-contents/order.d.ts

@@ -0,0 +1,13 @@
+import type { ChildNode, Options, Result, Specs } from './types';
+import type { PermittedContentPattern } from '@markuplint/ml-spec';
+/**
+ * Check ordered array
+ *
+ * @param contents
+ * @param nodes
+ * @param specs
+ * @param options
+ * @param depth
+ * @returns
+ */
+export declare function order(contents: ReadonlyArray<PermittedContentPattern>, nodes: ReadonlyArray<ChildNode>, specs: Specs, options: Options, depth: number): Result;

package/lib/permitted-contents/order.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.order = void 0;
+const helpers_1 = require("../helpers");
+const complex_branch_1 = require("./complex-branch");
+const debug_1 = require("./debug");
+const utils_1 = require("./utils");
+/**
+ * Check ordered array
+ *
+ * @param contents
+ * @param nodes
+ * @param specs
+ * @param options
+ * @param depth
+ * @returns
+ */
+function order(contents, nodes, specs, options, depth) {
+    var _a, _b, _c, _d;
+    const orderLog = debug_1.cmLog.extend(`order#${depth}`);
+    const btLog = debug_1.cmLog.extend(`backtrack#${depth}`);
+    const patterns = (0, helpers_1.deepCopy)(contents);
+    const collection = new utils_1.Collection(nodes);
+    orderLog('Starts: %s', collection);
+    let result = undefined;
+    let backtrackMode = false;
+    let afterBacktrack = false;
+    const unmatchedResults = [];
+    while (patterns.length) {
+        result = (0, complex_branch_1.complexBranch)(patterns[0], collection.unmatched, specs, options, depth);
+        collection.addMatched(result.matched);
+        orderLog('stack: %s', collection);
+        if (result.type !== 'UNEXPECTED_EXTRA_NODE' && result.type !== 'MATCHED' && result.type !== 'MATCHED_ZERO') {
+            unmatchedResults.push(result);
+            if (backtrackMode) {
+                collection.back();
+                btLog('🔙');
+                backtrackMode = false;
+                afterBacktrack = true;
+                continue;
+            }
+            orderLog('conformed (%s): %s', result.type, collection.toString(true));
+            const barelyMatchedResult = unmatchedResults.sort((a, b) => b.matched.length - a.matched.length)[0];
+            if (!barelyMatchedResult) {
+                throw new Error('Unreachable code');
+            }
+            return {
+                type: barelyMatchedResult.type,
+                matched: collection.matched,
+                unmatched: collection.unmatched,
+                zeroMatch: barelyMatchedResult.zeroMatch,
+                query: barelyMatchedResult.query,
+                hint: barelyMatchedResult.hint,
+            };
+        }
+        if (afterBacktrack) {
+            collection.lock();
+            afterBacktrack = false;
+        }
+        if (result.zeroMatch) {
+            backtrackMode = true;
+        }
+        else {
+            backtrackMode = false;
+        }
+        patterns.shift();
+    }
+    if (collection.unmatched.length) {
+        orderLog('Conformed (UNEXPECTED_EXTRA_NODE): %s', collection.toString(true));
+        return {
+            type: 'UNEXPECTED_EXTRA_NODE',
+            matched: collection.matched,
+            unmatched: collection.unmatched,
+            zeroMatch: false,
+            query: (_a = result === null || result === void 0 ? void 0 : result.query) !== null && _a !== void 0 ? _a : 'N/A',
+            hint: (_b = result === null || result === void 0 ? void 0 : result.hint) !== null && _b !== void 0 ? _b : {},
+        };
+    }
+    orderLog('Conformed: %s', collection);
+    return {
+        type: collection.matched.length ? 'MATCHED' : 'MATCHED_ZERO',
+        matched: collection.matched,
+        unmatched: collection.unmatched,
+        zeroMatch: false,
+        query: (_c = result === null || result === void 0 ? void 0 : result.query) !== null && _c !== void 0 ? _c : 'N/A',
+        hint: (_d = result === null || result === void 0 ? void 0 : result.hint) !== null && _d !== void 0 ? _d : {},
+    };
+}
+exports.order = order;

package/lib/permitted-contents/recursive-branch.d.ts

@@ -0,0 +1,4 @@
+import type { SelectorResult } from './matches-selector';
+import type { ChildNode, Options, Specs } from './types';
+import type { PermittedContentPattern, Model } from '@markuplint/ml-spec';
+export declare function recursiveBranch(model: Model | PermittedContentPattern[], nodes: readonly ChildNode[], specs: Specs, options: Options, depth: number): SelectorResult;