browser-debugger-cli 0.8.0 → 0.9.0

package/dist/utils/selectorFilters.js

@@ -3,29 +3,37 @@
  * `:visible`.
  *
  * They are not CSS, so the selector is split here (in Node) into the CSS the
- * browser runs and the filters the page applies to its matches. They are only
- * supported at the end of the last compound of each selector in a list
- * (`li.item:has-text("x"):visible`, `a:text-is("Home"), button:visible`):
- * there they narrow down the elements the CSS part matched. Anywhere else
- * (`div:has-text("x") > button`, `:not(:visible)`) they would have to be
- * evaluated inside the browser's selector matching, which bdg cannot do.
+ * browser runs and the filters the page applies to its matches. A filter
+ * applies to the compound it is written in (`li.item:has-text("x"):visible`,
+ * `a:visible.active`). On the last compound it narrows down the matches; on an
+ * earlier one it scopes the rest of the selector, which is then matched under
+ * each element passing the filter: `li:has-text("Buy milk") .toggle` is the
+ * `.toggle` inside the row that says "Buy milk". Only descendant and child
+ * combinators can follow a filtered compound. Inside `:has()` filters test
+ * what an element contains (`li:has(label:text-is("x"))`); inside other
+ * pseudo-classes (`:not(:visible)`) they would have to be evaluated by the
+ * browser's selector matching, which bdg cannot do.
  */
 import { CommandError } from '../errors/index.js';
-import { invalidSelectorFilterError, misplacedSelectorFilterError } from '../errors/messages.js';
+import { emptyTextFilterError, malformedSelectorError, invalidSelectorFilterError, misplacedSelectorFilterError, siblingAfterFilterError, siblingInHasError, } from '../errors/messages.js';
 import { EXIT_CODES } from './exitCodes.js';
 /** Cheap pre-check: selectors without any of the names are plain CSS. */
 const FILTER_NAME_HINT = /:(?:has-text|text-is|visible)/i;
 /** A filter name at a given position (sticky). */
 const FILTER_NAME = /:(has-text|text-is|visible)(?![\w-])/iy;
-/** CSS ending in a (not escaped) combinator still needs an element selector. */
-const ENDS_IN_COMBINATOR = /(^|[^\\])[\s>+~]$/;
+/** `:has(` at a given position (sticky). */
+const HAS_OPEN = /:has\(/iy;
+/** `:scope`, which a `:has()` with filters adds itself. */
+const SCOPE_PSEUDO = /:scope(?![\w-])/i;
+/** Characters that form combinators between compounds. */
+const COMBINATOR_CHAR = /[\s>+~]/;
 /**
  * Split a selector into the CSS part and filters of each selector of its
  * list.
  *
  * @param selector - Selector as the user gave it
  * @returns The parts, or null for plain CSS (no filters anywhere), which runs unchanged
- * @throws CommandError (81) for a filter that is not at the end, or a malformed one
+ * @throws CommandError (81) for a misplaced or malformed filter
  */
 export function parseSelectorFilters(selector) {
     if (!FILTER_NAME_HINT.test(selector))
@@ -33,6 +41,21 @@ export function parseSelectorFilters(selector) {
     const parts = splitSelectorList(selector).map((part) => parsePart(part, selector));
     return parts.some((part) => part.filters.length > 0) ? parts : null;
 }
+/**
+ * The parts with every `:visible` filter removed, to count what only
+ * visibility excluded.
+ *
+ * @param parts - Parsed selector parts
+ * @returns Parts without `:visible`, or null when they have none
+ */
+export function withoutVisibleFilters(parts) {
+    const json = JSON.stringify(parts);
+    if (!json.includes('"kind":"visible"'))
+        return null;
+    return JSON.parse(json, (key, value) => key === 'filters' && Array.isArray(value)
+        ? value.filter((filter) => filter.kind !== 'visible')
+        : value);
+}
 /**
  * Split a selector list at its top-level commas (not inside quotes,
  * attribute brackets or parentheses).
@@ -54,35 +77,32 @@ export function splitSelectorList(selector) {
     return parts;
 }
 /**
- * Walk a selector, calling `visit` for every character outside quotes,
- * escapes and attribute brackets, with the parenthesis depth.
+ * Walk a selector, calling `visit` at every token start outside quoted
+ * strings, escapes and attribute brackets (whose insides are skipped), with
+ * the parenthesis depth (for `)`, the depth inside it).
  *
  * @param text - Selector text
- * @param visit - Returns the index to continue after (to skip what it consumed)
+ * @param visit - Returns the index to continue after (`index` to let scan handle the character)
  */
 function scan(text, visit) {
     let depth = 0;
-    let inBrackets = false;
     for (let i = 0; i < text.length; i++) {
+        const next = visit(i, depth);
+        if (next !== i) {
+            i = next;
+            continue;
+        }
         const char = text[i];
-        if (char === '\\') {
+        if (char === '\\')
             i++;
-        }
-        else if (char === '"' || char === "'") {
+        else if (char === '"' || char === "'")
             i = quotedEnd(text, i) - 1;
-        }
-        else if (inBrackets) {
-            inBrackets = char !== ']';
-        }
-        else if (char === '[') {
-            inBrackets = true;
-        }
-        else if (char === '(' || char === ')') {
-            depth += char === '(' ? 1 : -1;
-        }
-        else {
-            i = visit(i, depth);
-        }
+        else if (char === '[')
+            i = bracketEnd(text, i) - 1;
+        else if (char === '(')
+            depth++;
+        else if (char === ')')
+            depth--;
     }
 }
 /**
@@ -96,6 +116,25 @@ function quotedEnd(text, start) {
     const end = closingQuote(text, start);
     return end === -1 ? text.length : end + 1;
 }
+/**
+ * End of an attribute selector (quotes and escapes inside skipped).
+ *
+ * @param text - Text containing it
+ * @param start - Index of the `[`
+ * @returns Index after the `]`, or the text length when unterminated
+ */
+function bracketEnd(text, start) {
+    for (let i = start + 1; i < text.length; i++) {
+        const char = text[i];
+        if (char === '\\')
+            i++;
+        else if (char === '"' || char === "'")
+            i = quotedEnd(text, i) - 1;
+        else if (char === ']')
+            return i + 1;
+    }
+    return text.length;
+}
 /**
  * Index of the quote closing the string opened at `start` (backslash escapes skipped).
  *
@@ -113,35 +152,210 @@ function closingQuote(text, start) {
     return -1;
 }
 /**
- * Split one selector of a list into its CSS part and trailing filters.
+ * Index of the parenthesis closing the one at `open` (quotes, escapes and
+ * attribute brackets skipped).
+ *
+ * @param text - Selector text
+ * @param open - Index of the `(`
+ * @returns Index of the `)`, or -1 when it is not closed
+ */
+function closingParenthesis(text, open) {
+    let close = -1;
+    scan(text.slice(open), (index, depth) => {
+        if (close !== -1 || text[open + index] !== ')' || depth !== 1)
+            return index;
+        close = open + index;
+        return text.length;
+    });
+    return close;
+}
+/**
+ * Throw an exit-81 error.
+ *
+ * @param err - Message and suggestion
+ * @throws CommandError (81)
+ */
+function reject(err) {
+    throw new CommandError(err.message, { suggestion: err.suggestion }, EXIT_CODES.INVALID_ARGUMENTS);
+}
+/**
+ * Parse one selector of a list.
  *
  * @param part - One selector of the list
  * @param selector - Whole selector, for error messages
- * @returns CSS part (`*` when only filters are given) and filters
- * @throws CommandError (81) when a filter is not at the end
+ * @returns CSS and filters of its first step, and the scoped steps after it
+ * @throws CommandError (81) for an empty selector or misplaced filters
  */
 function parsePart(part, selector) {
-    const matches = findFilters(part, selector);
-    const first = matches[0];
-    if (!first)
+    if (part.trim() === '')
+        reject(malformedSelectorError(selector, 'empty-in-list'));
+    if (!FILTER_NAME_HINT.test(part))
         return { css: part.trim(), filters: [] };
-    const misplaced = matches.find((match, i) => match.depth > 0 || match.end !== (matches[i + 1]?.start ?? part.trimEnd().length));
-    if (misplaced) {
-        const err = misplacedSelectorFilterError(selector, part.slice(misplaced.start, misplaced.end));
-        throw new CommandError(err.message, { suggestion: err.suggestion }, EXIT_CODES.INVALID_ARGUMENTS);
-    }
-    const css = part.slice(0, first.start);
-    const needsElement = css.trim() === '' || ENDS_IN_COMBINATOR.test(css);
+    const { leading, steps } = parseChain(part, selector);
+    if (leading)
+        reject(malformedSelectorError(selector, 'leading-combinator', leading));
+    const [first, ...rest] = steps;
     return {
-        css: (needsElement ? `${css}*` : css).trim(),
-        filters: matches.map((match) => match.filter),
+        css: first?.css ?? '*',
+        filters: first?.filters ?? [],
+        ...(rest.length > 0 && { steps: rest }),
     };
 }
 /**
- * Find every filter in a selector (at any parenthesis depth, outside quotes
- * and attribute brackets).
+ * Parse a complex selector into steps that end at each filtered compound.
+ *
+ * @param text - Selector (may start with a combinator inside `:has()`)
+ * @param selector - Whole selector, for error messages
+ * @returns The leading combinator (`''` for none) and the steps
+ * @throws CommandError (81) for a sibling combinator after a filter, or a trailing combinator
+ */
+function parseChain(text, selector) {
+    const compounds = splitCompounds(text.trim(), selector);
+    const leading = compounds[0]?.combinator ?? '';
+    const steps = [];
+    let combinator = ' ';
+    let css = '';
+    compounds.forEach((compound, i) => {
+        const parsed = parseCompound(compound.text, selector);
+        css += css ? joinCombinator(compound.combinator) + parsed.css : parsed.css;
+        const next = compounds[i + 1];
+        if (parsed.filters.length === 0 && next)
+            return;
+        steps.push({ combinator, css, filters: parsed.filters });
+        css = '';
+        if (!next)
+            return;
+        if (next.combinator !== ' ' && next.combinator !== '>') {
+            reject(siblingAfterFilterError(selector, next.combinator));
+        }
+        combinator = next.combinator;
+    });
+    return { leading, steps };
+}
+/**
+ * Combinator as written between two compounds of the CSS.
+ *
+ * @param combinator - ` `, `>`, `+` or `~`
+ * @returns The combinator with surrounding spaces
+ */
+function joinCombinator(combinator) {
+    return combinator === ' ' ? ' ' : ` ${combinator} `;
+}
+/**
+ * Split a complex selector into its compounds at top-level combinators.
  *
- * @param part - One selector of a list
+ * @param text - Trimmed selector
+ * @param selector - Whole selector, for error messages
+ * @returns Compounds with the combinator before each (`''` for the first, unless it leads)
+ * @throws CommandError (81) when the selector ends with a combinator
+ */
+function splitCompounds(text, selector) {
+    const compounds = [];
+    let combinator = '';
+    let start = -1;
+    scan(text, (index, depth) => {
+        const char = text[index] ?? '';
+        if (depth > 0 || !COMBINATOR_CHAR.test(char)) {
+            if (start === -1)
+                start = index;
+            return index;
+        }
+        if (start !== -1) {
+            compounds.push({ combinator, text: text.slice(start, index) });
+            start = -1;
+            combinator = ' ';
+        }
+        if (char.trim() && !combinator.trim())
+            combinator = char;
+        return index;
+    });
+    if (start === -1)
+        reject(malformedSelectorError(selector, 'trailing-combinator'));
+    compounds.push({ combinator, text: text.slice(start) });
+    return compounds;
+}
+/**
+ * Take the filters (and `:has()` containing filters) out of a compound.
+ *
+ * @param text - Compound selector
+ * @param selector - Whole selector, for error messages
+ * @returns The compound's CSS (`*` when only filters are given) and its filters
+ * @throws CommandError (81) for a filter inside another pseudo-class
+ */
+function parseCompound(text, selector) {
+    if (!FILTER_NAME_HINT.test(text))
+        return { css: text, filters: [] };
+    const hasFilters = findHasFilters(text, selector);
+    const inHas = (match) => hasFilters.some((has) => match.start >= has.start && match.end <= has.end);
+    const filters = findFilters(text, selector).filter((match) => !inHas(match));
+    const misplaced = filters.find((match) => match.depth > 0);
+    if (misplaced) {
+        reject(misplacedSelectorFilterError(selector, text.slice(misplaced.start, misplaced.end)));
+    }
+    const removed = [...hasFilters, ...filters].sort((a, b) => a.start - b.start);
+    let css = '';
+    let position = 0;
+    for (const match of removed) {
+        css += text.slice(position, match.start);
+        position = match.end;
+    }
+    css += text.slice(position);
+    return { css: css || '*', filters: removed.map((match) => match.filter) };
+}
+/**
+ * Find the top-level `:has()` of a compound whose argument uses filters.
+ *
+ * @param text - Compound selector
+ * @param selector - Whole selector, for error messages
+ * @returns The `:has()` filters with their positions
+ */
+function findHasFilters(text, selector) {
+    const matches = [];
+    scan(text, (index, depth) => {
+        HAS_OPEN.lastIndex = index;
+        if (depth > 0 || !HAS_OPEN.test(text))
+            return index;
+        const open = HAS_OPEN.lastIndex - 1;
+        const close = closingParenthesis(text, open);
+        if (close === -1)
+            return index;
+        const filter = parseHasArgument(text.slice(open + 1, close), selector);
+        if (filter)
+            matches.push({ start: index, end: close + 1, depth, filter });
+        return filter ? close : index;
+    });
+    return matches;
+}
+/**
+ * Parse the relative selector list of a `:has()` that may use filters.
+ *
+ * @param argument - Text between the parentheses
+ * @param selector - Whole selector, for error messages
+ * @returns The `has` filter, or null when the argument is plain CSS
+ * @throws CommandError (81) for a sibling combinator (`:has(+ x)`)
+ */
+function parseHasArgument(argument, selector) {
+    if (!FILTER_NAME_HINT.test(argument))
+        return null;
+    const selectors = splitSelectorList(argument).map((relative) => {
+        if (relative.trim() === '')
+            reject(malformedSelectorError(selector, 'empty-has'));
+        if (SCOPE_PSEUDO.test(relative))
+            reject(malformedSelectorError(selector, 'scope-in-has'));
+        const { leading, steps } = parseChain(relative, selector);
+        if (leading && leading !== '>')
+            reject(siblingInHasError(selector, leading));
+        const [first, ...rest] = steps;
+        return first ? [{ ...first, combinator: (leading || ' ') }, ...rest] : [];
+    });
+    const usesFilters = selectors.some((chain) => chain.some((step) => step.filters.length > 0));
+    return usesFilters ? { kind: 'has', selectors } : null;
+}
+/**
+ * Find every text and visibility filter in a compound (at any parenthesis
+ * depth, outside quotes and attribute brackets).
+ *
+ * @param part - Compound selector
  * @param selector - Whole selector, for error messages
  * @returns Filters in order
  */
@@ -169,15 +383,15 @@ function findFilters(part, selector) {
  * @param name - `has-text` or `text-is`
  * @param selector - Whole selector, for error messages
  * @returns The filter (text whitespace-normalized) and the index after it
- * @throws CommandError (81) when the argument is missing or not closed
+ * @throws CommandError (81) when the argument is missing or not closed, or `:has-text` is empty
  */
 function readTextFilter(part, start, name, selector) {
     const argument = part[start] === '(' ? readArgument(part, start + 1) : null;
-    if (!argument) {
-        const err = invalidSelectorFilterError(selector, `:${name}`);
-        throw new CommandError(err.message, { suggestion: err.suggestion }, EXIT_CODES.INVALID_ARGUMENTS);
-    }
+    if (!argument)
+        reject(invalidSelectorFilterError(selector, `:${name}`));
     const text = argument.text.replace(/\s+/g, ' ').trim();
+    if (name === 'has-text' && text === '')
+        reject(emptyTextFilterError(selector));
     const filter = name === 'has-text'
         ? { kind: 'has-text', text: text.toLowerCase() }
         : { kind: 'text-is', text };

package/dist/utils/shellDetection.d.ts

@@ -25,10 +25,16 @@ export declare function hasAttributeSelector(selector: string): boolean;
  */
 export declare function detectSelectorQuoteDamage(selector: string): ShellDamageResult;
 /**
- * Detects shell quote damage in JavaScript expressions.
+ * Detects shell quote damage in JavaScript expressions. Conservative: only an
+ * error stripped quotes cause (`x is not defined`,
+ * `missing ) after argument list`, `Unexpected identifier`,
+ * `Unexpected token '.'`, `Invalid or unexpected token`) counts, about an
+ * argument of a DOM method that takes a string (`querySelector(input)`),
+ * which the script does not declare itself.
  *
  * @param script - The script as received by the command
+ * @param errorMessage - The error the script raised
  * @returns Detection result with details and suggestions
  */
-export declare function detectScriptQuoteDamage(script: string): ShellDamageResult;
+export declare function detectScriptQuoteDamage(script: string, errorMessage: string): ShellDamageResult;
 //# sourceMappingURL=shellDetection.d.ts.map

package/dist/utils/shellDetection.js

@@ -4,16 +4,52 @@
  * Detects when shell quote handling has corrupted selectors or scripts,
  * providing actionable suggestions for recovery.
  */
+import { sessionCommand } from '../ui/messages/sessionCommand.js';
 const ATTRIBUTE_SELECTOR_PATTERN = /\[[\w-]+=/.source;
 const QUOTED_ATTRIBUTE_PATTERN = /\[[\w-]+=['"][^'"]*['"]\]/;
 const UNQUOTED_ATTRIBUTE_PATTERN = /\[([\w-]+)=([\w-]+)\]/;
-const BARE_ARGUMENT_PATTERN = /(\w+)\(\s*([a-zA-Z][\w-]*)\s*\)/;
-const UNEXPECTED_IDENTIFIER_PATTERN = /Unexpected identifier ['"]?(\w+)['"]?/;
+/** DOM methods whose one argument is a string (a selector, id, name or class) */
+const STRING_ARGUMENT_METHODS = new Set([
+    'querySelector',
+    'querySelectorAll',
+    'getElementById',
+    'getElementsByClassName',
+    'getElementsByTagName',
+    'getElementsByName',
+    'closest',
+    'matches',
+    'getAttribute',
+    'hasAttribute',
+    'removeAttribute',
+    'toggleAttribute',
+    'createElement',
+    'add',
+    'remove',
+    'toggle',
+]);
+/** A call with one argument and no quotes, parentheses or commas in it */
+const UNQUOTED_CALL_PATTERN = /([\w$]+)\(\s*([^()'"`,]+?)\s*\)/g;
+/** `x is not defined`: the shell may have turned `"x"` into `x` */
+const NOT_DEFINED_PATTERN = /^ReferenceError: ([\w$]+) is not defined/;
+/**
+ * The syntax errors V8 raises for `fn(div p)`: the shell may have turned
+ * `"div p"` into `div p`
+ */
+const SEVERAL_WORDS_PATTERN = /^SyntaxError: (?:missing \) after argument list|Unexpected identifier '([\w$]+)')/;
+/**
+ * The syntax errors V8 raises for a selector starting with punctuation:
+ * `fn(.btn)`, `fn(#main)`, `fn(> p)`
+ */
+const SELECTOR_SYNTAX_PATTERN = /^SyntaxError: (?:Unexpected token '[^']*'|Invalid or unexpected token|Private field '#[^']*' must be declared)/;
+/** Start of a CSS selector that is not a JavaScript expression */
+const SELECTOR_PUNCTUATION = /^[.#>~+*[:]/;
+/** Words that may start a valid expression of several words */
+const EXPRESSION_KEYWORDS = /^(?:new|typeof|void|delete|await|yield)\b/;
 function noDamage() {
     return { damaged: false };
 }
 function buildSelectorSuggestion(selector) {
-    return `Use the two-step pattern:\n  1. bdg dom query '${selector}'\n  2. bdg dom a11y describe 0`;
+    return `Use the two-step pattern:\n  1. ${sessionCommand(`bdg dom query '${selector}'`)}\n  2. ${sessionCommand('bdg dom a11y describe 0')}`;
 }
 function checkUnquotedAttribute(selector) {
     if (QUOTED_ATTRIBUTE_PATTERN.test(selector)) {
@@ -31,31 +67,66 @@ function checkUnquotedAttribute(selector) {
         suggestion: buildSelectorSuggestion(selector),
     };
 }
-function checkBareArgument(script) {
-    const match = BARE_ARGUMENT_PATTERN.exec(script);
-    if (!match) {
-        return noDamage();
-    }
-    const [matchedPart, funcName, bareArg] = match;
-    const fixedPart = `${funcName}("${bareArg}")`;
-    const fixedScript = script.replace(matchedPart, fixedPart);
-    return {
-        damaged: true,
-        type: 'unquoted-argument',
-        details: `${funcName}(${bareArg}) - quotes stripped by shell`,
-        suggestion: `Try: bdg dom eval '${fixedScript}'`,
-    };
+/**
+ * Whether the script declares a name itself (then it is a variable, not a
+ * string that lost its quotes).
+ *
+ * @param script - The script
+ * @param name - Identifier
+ * @returns True for a `const`/`let`/`var`/`function`/`class` declaration of it
+ */
+function declares(script, name) {
+    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`\\b(?:const|let|var|function|class)\\s+${escaped}\\b`).test(script);
 }
-function checkUnexpectedIdentifier(script) {
-    if (!UNEXPECTED_IDENTIFIER_PATTERN.test(script)) {
-        return noDamage();
-    }
-    return {
-        damaged: true,
-        type: 'unquoted-argument',
-        details: 'Unexpected identifier suggests quotes were stripped',
-        suggestion: "Use single quotes around the script: bdg dom eval '...'",
-    };
+/**
+ * Whether text starts with an identifier (and not with a longer one).
+ *
+ * @param text - Text
+ * @param name - Identifier
+ * @returns True when `text` is `name` or `name` followed by a non-identifier character
+ */
+function startsWithName(text, name) {
+    return text.startsWith(name) && !/^[\w$]/.test(text.slice(name.length));
+}
+/**
+ * Whether an unquoted argument is what the error complains about: for
+ * `ReferenceError` the argument starts with the undefined name (`input`,
+ * `my-id`, `button.primary`); for `SyntaxError` it is several bare words
+ * (`div p`), the unexpected one (when named) among the later ones; for a
+ * syntax error at punctuation it starts like a selector (`.btn`, `#main`).
+ *
+ * @param argument - Unquoted argument
+ * @param error - What the error says
+ * @returns True when quotes stripped from it explain the error
+ */
+function explainsError(argument, error) {
+    if (error.kind === 'undefined')
+        return startsWithName(argument, error.name);
+    if (error.kind === 'selector')
+        return SELECTOR_PUNCTUATION.test(argument);
+    const [, ...laterWords] = argument.split(/\s+/);
+    return (!EXPRESSION_KEYWORDS.test(argument) &&
+        laterWords.length > 0 &&
+        (error.name === undefined || laterWords.some((word) => startsWithName(word, error.name ?? ''))));
+}
+/**
+ * Read the identifier an error is about, when the error is one stripped
+ * quotes cause.
+ *
+ * @param errorMessage - The JavaScript error
+ * @returns The identifier and kind of error, or undefined for other errors
+ */
+function quoteRelatedError(errorMessage) {
+    const notDefined = NOT_DEFINED_PATTERN.exec(errorMessage);
+    if (notDefined?.[1])
+        return { kind: 'undefined', name: notDefined[1] };
+    if (SELECTOR_SYNTAX_PATTERN.test(errorMessage))
+        return { kind: 'selector' };
+    const syntax = SEVERAL_WORDS_PATTERN.exec(errorMessage);
+    if (!syntax)
+        return undefined;
+    return syntax[1] ? { kind: 'syntax', name: syntax[1] } : { kind: 'syntax' };
 }
 /**
  * Checks if a selector contains attribute syntax.
@@ -79,16 +150,32 @@ export function detectSelectorQuoteDamage(selector) {
     return checkUnquotedAttribute(selector);
 }
 /**
- * Detects shell quote damage in JavaScript expressions.
+ * Detects shell quote damage in JavaScript expressions. Conservative: only an
+ * error stripped quotes cause (`x is not defined`,
+ * `missing ) after argument list`, `Unexpected identifier`,
+ * `Unexpected token '.'`, `Invalid or unexpected token`) counts, about an
+ * argument of a DOM method that takes a string (`querySelector(input)`),
+ * which the script does not declare itself.
  *
  * @param script - The script as received by the command
+ * @param errorMessage - The error the script raised
  * @returns Detection result with details and suggestions
  */
-export function detectScriptQuoteDamage(script) {
-    const bareArgResult = checkBareArgument(script);
-    if (bareArgResult.damaged) {
-        return bareArgResult;
+export function detectScriptQuoteDamage(script, errorMessage) {
+    const error = quoteRelatedError(errorMessage);
+    if (!error || (error.name && declares(script, error.name)))
+        return noDamage();
+    for (const [call, method = '', argument = ''] of script.matchAll(UNQUOTED_CALL_PATTERN)) {
+        if (!STRING_ARGUMENT_METHODS.has(method) || !explainsError(argument, error))
+            continue;
+        const fixedScript = script.replace(call, `${method}("${argument}")`);
+        return {
+            damaged: true,
+            type: 'unquoted-argument',
+            details: `${method}(${argument}) - quotes stripped by shell`,
+            suggestion: `Try: ${sessionCommand(`bdg dom eval '${fixedScript}'`)}`,
+        };
     }
-    return checkUnexpectedIdentifier(script);
+    return noDamage();
 }
 //# sourceMappingURL=shellDetection.js.map

package/dist/utils/suggestions.d.ts

@@ -15,5 +15,31 @@ export declare function getSuggestion(input: string, candidates: readonly string
     prefix?: string;
     suffix?: string;
 }): string;
+/**
+ * Names (ids or classes) similar to one that matched nothing, best first, at
+ * most three: near-typos first (Levenshtein distance up to a fifth of the
+ * length, at least 2), then names sharing a long end, then names sharing a
+ * long start (at least a third of the name, at least 4 characters). The end
+ * ranks before the start because ids tend to name an action before the item
+ * (`add-to-cart-backpack` becomes `remove-backpack` once clicked).
+ *
+ * @param name - Id or class that matched nothing
+ * @param candidates - Ids or classes on the page
+ * @returns Up to three similar names
+ */
+export declare function findSimilarNames(name: string, candidates: readonly string[]): string[];
+/** A selector that is just one id or one class, e.g. `#save` or `.btn-primary` */
+export interface SingleNameSelector {
+    kind: 'id' | 'class';
+    name: string;
+}
+/**
+ * Whether a selector is a single id or class (the kind "did you mean" can
+ * suggest for).
+ *
+ * @param selector - CSS selector
+ * @returns The id or class, or null for any other selector
+ */
+export declare function parseSingleNameSelector(selector: string): SingleNameSelector | null;
 export {};
 //# sourceMappingURL=suggestions.d.ts.map