@sifurai/cli 0.1.2 → 0.1.5

package/dist/codegen.js

@@ -0,0 +1,680 @@
+import { CliError } from './api.js';
+import { MAX_SELECTOR, redactUrl } from './evidence.js';
+import { appFolder } from './runner.js';
+// The API's limits for a step's fields.
+const MAX_STEP_SELECTOR = Math.min(500, MAX_SELECTOR);
+const MAX_VALUE = 2000;
+export const SUPPORTED = 'Sifur can replay opening a page, click (double-click, check and uncheck count as a click), fill, press and select, ' +
+    'and the recorder\'s "Assert text" and "Assert visibility" checks, on elements found by role, text, label, placeholder, ' +
+    'test id or CSS, in the page or a frame of it.';
+const PUNCT = ['=>', '...', '?.', '(', ')', '{', '}', '[', ']', ',', ';', '.', ':', '=', '-', '!', '?', '+', '*', '<', '>', '&', '|'];
+// After these, a `/` starts a regular expression rather than dividing.
+const BEFORE_REGEX = new Set(['(', ',', '=', ':', '[', '!', '&', '|', '?', '{', '}', ';', '=>']);
+function tokenize(source) {
+    const tokens = [];
+    let i = 0;
+    let line = 1;
+    const fail = (what) => {
+        throw new CliError(`Couldn't read the recording at line ${line}: ${what}.`);
+    };
+    while (i < source.length) {
+        const ch = source[i];
+        if (ch === '\n') {
+            line++;
+            i++;
+            continue;
+        }
+        if (/\s/.test(ch)) {
+            i++;
+            continue;
+        }
+        if (source.startsWith('//', i)) {
+            while (i < source.length && source[i] !== '\n')
+                i++;
+            continue;
+        }
+        if (source.startsWith('/*', i)) {
+            const close = source.indexOf('*/', i + 2);
+            if (close < 0)
+                fail('a comment never ends');
+            line += (source.slice(i, close).match(/\n/g) ?? []).length;
+            i = close + 2;
+            continue;
+        }
+        const start = i;
+        const startLine = line;
+        if (ch === "'" || ch === '"' || ch === '`') {
+            let value = '';
+            let interpolated = false;
+            i++;
+            for (;;) {
+                if (i >= source.length)
+                    fail('a string never ends');
+                const c = source[i];
+                if (c === ch) {
+                    i++;
+                    break;
+                }
+                if (c === '\n') {
+                    if (ch !== '`')
+                        fail('a string runs past the end of its line');
+                    line++;
+                }
+                if (ch === '`' && c === '$' && source[i + 1] === '{')
+                    interpolated = true;
+                if (c === '\\') {
+                    const next = source[i + 1] ?? '';
+                    i += 2;
+                    const simple = { n: '\n', t: '\t', r: '\r', b: '\b', f: '\f', v: '\v', 0: '\0' };
+                    if (next in simple)
+                        value += simple[next];
+                    else if (next === 'x') {
+                        value += String.fromCharCode(parseInt(source.slice(i, i + 2), 16));
+                        i += 2;
+                    }
+                    else if (next === 'u' && source[i] === '{') {
+                        const close = source.indexOf('}', i);
+                        value += String.fromCodePoint(parseInt(source.slice(i + 1, close), 16));
+                        i = close + 1;
+                    }
+                    else if (next === 'u') {
+                        value += String.fromCharCode(parseInt(source.slice(i, i + 4), 16));
+                        i += 4;
+                    }
+                    else if (next === '\n')
+                        line++;
+                    else
+                        value += next;
+                    continue;
+                }
+                value += c;
+                i++;
+            }
+            tokens.push({ kind: interpolated ? 'template' : 'string', value, start, end: i, line: startLine });
+            continue;
+        }
+        if (ch === '/' && (tokens.length === 0 || BEFORE_REGEX.has(tokens.at(-1).value) || tokens.at(-1).value === 'await')) {
+            let inClass = false;
+            i++;
+            let body = '';
+            for (;;) {
+                const c = source[i];
+                if (c === undefined || c === '\n')
+                    fail('a regular expression never ends');
+                if (c === '\\') {
+                    body += c + (source[i + 1] ?? '');
+                    i += 2;
+                    continue;
+                }
+                if (c === '[')
+                    inClass = true;
+                if (c === ']')
+                    inClass = false;
+                i++;
+                if (c === '/' && !inClass)
+                    break;
+                body += c;
+            }
+            const flags = /^[a-z]*/.exec(source.slice(i))[0];
+            i += flags.length;
+            tokens.push({ kind: 'regex', value: body, flags, start, end: i, line: startLine });
+            continue;
+        }
+        const number = /^\d+(\.\d+)?/.exec(source.slice(i));
+        if (number) {
+            i += number[0].length;
+            tokens.push({ kind: 'number', value: number[0], start, end: i, line: startLine });
+            continue;
+        }
+        const ident = /^[A-Za-z_$][\w$]*/.exec(source.slice(i));
+        if (ident) {
+            i += ident[0].length;
+            tokens.push({ kind: 'ident', value: ident[0], start, end: i, line: startLine });
+            continue;
+        }
+        const punct = PUNCT.find((p) => source.startsWith(p, i));
+        if (!punct)
+            fail(`unexpected "${ch}"`);
+        i += punct.length;
+        tokens.push({ kind: 'punct', value: punct, start, end: i, line: startLine });
+    }
+    return tokens;
+}
+class Unreadable extends Error {
+}
+const OPEN = { '(': ')', '{': '}', '[': ']' };
+class Parser {
+    tokens;
+    at = 0;
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    get done() {
+        return this.at >= this.tokens.length;
+    }
+    peek(offset = 0) {
+        return this.tokens[this.at + offset];
+    }
+    is(value, offset = 0) {
+        const token = this.peek(offset);
+        return token !== undefined && token.kind !== 'string' && token.kind !== 'template' && token.value === value;
+    }
+    take(value) {
+        const token = this.tokens[this.at];
+        if (!token || (value !== undefined && !this.is(value)))
+            throw new Unreadable();
+        this.at++;
+        return token;
+    }
+    /** Past one bracketed group, whatever is in it. */
+    skipGroup() {
+        const close = OPEN[this.take().value];
+        if (!close)
+            throw new Unreadable();
+        while (!this.is(close)) {
+            if (this.done)
+                throw new Unreadable();
+            if (OPEN[this.peek().value] && this.peek().kind === 'punct')
+                this.skipGroup();
+            else
+                this.at++;
+        }
+        this.take(close);
+    }
+    /** An arrow function's body, up to the comma or bracket that ends the argument. */
+    skipFunctionBody() {
+        if (this.is('{'))
+            return this.skipGroup();
+        while (!this.done && !this.is(',') && !this.is(')')) {
+            if (this.peek().kind === 'punct' && OPEN[this.peek().value])
+                this.skipGroup();
+            else
+                this.at++;
+        }
+    }
+    chain() {
+        const head = this.take();
+        if (head.kind !== 'ident')
+            throw new Unreadable();
+        const links = [{ name: head.value }];
+        for (;;) {
+            if (this.is('.') || this.is('?.')) {
+                this.at++;
+                const name = this.take();
+                if (name.kind !== 'ident')
+                    throw new Unreadable();
+                links.push({ name: name.value });
+            }
+            else if (this.is('(')) {
+                const last = links.at(-1);
+                if (last.args)
+                    throw new Unreadable();
+                last.args = this.args();
+            }
+            else {
+                return links;
+            }
+        }
+    }
+    args() {
+        this.take('(');
+        const values = [];
+        while (!this.is(')')) {
+            values.push(this.value());
+            if (!this.is(')'))
+                this.take(',');
+        }
+        this.take(')');
+        return values;
+    }
+    value() {
+        const token = this.peek();
+        if (!token)
+            throw new Unreadable();
+        if (token.kind === 'string') {
+            this.at++;
+            return { kind: 'string', value: token.value };
+        }
+        if (token.kind === 'regex') {
+            this.at++;
+            return { kind: 'regex', source: token.value, flags: token.flags ?? '' };
+        }
+        if (token.kind === 'number') {
+            this.at++;
+            return { kind: 'number', value: Number(token.value) };
+        }
+        if (this.is('-') && this.peek(1)?.kind === 'number') {
+            this.at++;
+            return { kind: 'number', value: -Number(this.take().value) };
+        }
+        if (this.is('true') || this.is('false'))
+            return { kind: 'boolean', value: this.take().value === 'true' };
+        if (this.is('{'))
+            return this.object();
+        if (this.is('[')) {
+            this.take('[');
+            const items = [];
+            while (!this.is(']')) {
+                items.push(this.value());
+                if (!this.is(']'))
+                    this.take(',');
+            }
+            this.take(']');
+            return { kind: 'array', items };
+        }
+        if (this.is('(')) {
+            this.skipGroup();
+            this.take('=>');
+            this.skipFunctionBody();
+            return { kind: 'other' };
+        }
+        if (token.kind === 'ident' && this.is('=>', 1)) {
+            this.at += 2;
+            this.skipFunctionBody();
+            return { kind: 'other' };
+        }
+        if (token.kind === 'ident')
+            return { kind: 'chain', links: this.chain() };
+        throw new Unreadable();
+    }
+    object() {
+        this.take('{');
+        const entries = {};
+        while (!this.is('}')) {
+            const key = this.take();
+            if (key.kind !== 'ident' && key.kind !== 'string')
+                throw new Unreadable();
+            this.take(':');
+            entries[key.value] = this.value();
+            if (!this.is('}'))
+                this.take(',');
+        }
+        this.take('}');
+        return { kind: 'object', entries };
+    }
+}
+/** The statements inside `test('…', async ({ page }) => { … })`, each with the tokens it's made of. */
+function testBody(tokens) {
+    let at = tokens.findIndex((t, i) => t.kind === 'ident' && t.value === 'test' && tokens[i + 1]?.value === '(' && tokens[i + 2]?.kind === 'string');
+    if (at < 0)
+        throw new CliError('The recording has no test in it: it isn\'t what Playwright\'s recorder writes.');
+    while (at < tokens.length && !(tokens[at].value === '=>' && tokens[at + 1]?.value === '{'))
+        at++;
+    if (at >= tokens.length)
+        throw new CliError('The recording\'s test has no body.');
+    at += 2;
+    const statements = [];
+    let current = [];
+    let depth = 0;
+    for (; at < tokens.length; at++) {
+        const token = tokens[at];
+        if (token.kind === 'punct' && OPEN[token.value])
+            depth++;
+        if (token.kind === 'punct' && Object.values(OPEN).includes(token.value)) {
+            if (depth === 0)
+                break;
+            depth--;
+        }
+        if (depth === 0 && token.kind === 'punct' && token.value === ';') {
+            if (current.length > 0)
+                statements.push(current);
+            current = [];
+            continue;
+        }
+        current.push(token);
+    }
+    if (current.length > 0)
+        statements.push(current);
+    return statements;
+}
+function quoted(value) {
+    return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+function regexText(value) {
+    return `/${value.source}/${value.flags}`;
+}
+const str = (value) => (value?.kind === 'string' ? value.value : undefined);
+const REASONS = {
+    hover: "hovering isn't replayed: click what the hover shows instead",
+    setInputFiles: "uploading a file isn't supported",
+    dragTo: "dragging isn't supported",
+    pressSequentially: 'typing key by key isn\'t supported: type into the field normally, so the recorder writes a fill',
+    type: 'typing key by key isn\'t supported: type into the field normally, so the recorder writes a fill',
+    tap: "tapping isn't supported: click instead",
+};
+/** A Playwright locator chain as one selector string that Sifur's runner (and `locate()`) understands. */
+function selectorOf(links) {
+    if (links[0]?.name !== 'page' || links[0].args)
+        return { reason: 'it acts on something other than the page' };
+    const segments = [];
+    // CSS (from `locator('…')`) can take `:has-text()`; the other engines can't.
+    let lastIsCss = false;
+    for (const link of links.slice(1)) {
+        const args = link.args;
+        if (!args)
+            return { reason: `.${link.name} isn't a locator Sifur knows` };
+        const [first, second] = args;
+        const options = second?.kind === 'object' ? second.entries : {};
+        const exact = options.exact?.kind === 'boolean' && options.exact.value;
+        let css = false;
+        switch (link.name) {
+            case 'getByRole': {
+                const role = str(first);
+                if (!role)
+                    return { reason: 'a role that isn\'t plain text' };
+                let attributes = '';
+                for (const [key, value] of Object.entries(options)) {
+                    if (key === 'exact')
+                        continue;
+                    if (key === 'name') {
+                        if (value.kind === 'regex')
+                            attributes += `[name=${regexText(value)}]`;
+                        else if (value.kind === 'string')
+                            attributes += exact ? `[name=${quoted(value.value)}]` : `[name*=${quoted(value.value)}i]`;
+                        else
+                            return { reason: 'a role\'s name that isn\'t plain text' };
+                    }
+                    else if (['checked', 'pressed', 'expanded', 'selected', 'disabled'].includes(key) && value.kind === 'boolean') {
+                        attributes += `[${key}=${value.value}]`;
+                    }
+                    else if (key === 'level' && value.kind === 'number') {
+                        attributes += `[level=${value.value}]`;
+                    }
+                    else if (key === 'includeHidden' && value.kind === 'boolean') {
+                        if (value.value)
+                            attributes += '[include-hidden]';
+                    }
+                    else {
+                        return { reason: `getByRole's ${key} option isn't supported` };
+                    }
+                }
+                segments.push(`role=${role}${attributes}`);
+                break;
+            }
+            case 'getByText': {
+                if (first?.kind === 'regex') {
+                    segments.push(`text=${regexText(first)}`);
+                    break;
+                }
+                const text = str(first);
+                if (text === undefined)
+                    return { reason: 'text that isn\'t plain text' };
+                if (exact)
+                    segments.push(`text=${quoted(text)}`);
+                else if (/^["'/]/.test(text) || text.includes('>>') || text !== text.trim() || text === '') {
+                    return { reason: `the text ${quoted(text)} can't be written as a Sifur selector` };
+                }
+                else
+                    segments.push(`text=${text}`);
+                break;
+            }
+            case 'getByLabel': {
+                const label = str(first);
+                if (label === undefined)
+                    return { reason: 'a label that isn\'t plain text' };
+                segments.push(`label=${label}`);
+                break;
+            }
+            case 'getByPlaceholder':
+            case 'getByAltText':
+            case 'getByTitle': {
+                const value = str(first);
+                if (value === undefined)
+                    return { reason: `${link.name} with a pattern isn't supported` };
+                const attribute = { getByPlaceholder: 'placeholder', getByAltText: 'alt', getByTitle: 'title' }[link.name];
+                segments.push(exact ? `[${attribute}=${quoted(value)}]` : `[${attribute}*=${quoted(value)} i]`);
+                css = true;
+                break;
+            }
+            case 'getByTestId': {
+                const id = str(first);
+                if (id === undefined)
+                    return { reason: 'a test id that isn\'t plain text' };
+                segments.push(`[data-testid=${quoted(id)}]`);
+                css = true;
+                break;
+            }
+            case 'locator': {
+                const selector = str(first);
+                if (selector === undefined)
+                    return { reason: 'a locator inside a locator isn\'t supported' };
+                if (selector.startsWith('internal:'))
+                    return { reason: 'it uses one of Playwright\'s internal selectors' };
+                if (second)
+                    return { reason: 'locator options aren\'t supported' };
+                segments.push(selector);
+                css = !/^[a-z-]+=/i.test(selector) && !selector.includes('>>') && !selector.startsWith('//');
+                break;
+            }
+            // The runner looks for every selector in the page and each of its frames.
+            case 'frameLocator':
+            case 'contentFrame':
+                segments.length = 0;
+                break;
+            case 'first':
+                segments.push('nth=0');
+                break;
+            case 'last':
+                segments.push('nth=-1');
+                break;
+            case 'nth':
+                if (first?.kind !== 'number')
+                    return { reason: 'nth() needs a number' };
+                segments.push(`nth=${first.value}`);
+                break;
+            case 'filter': {
+                if (first?.kind !== 'object')
+                    return { reason: 'a filter that isn\'t plain options' };
+                const entries = Object.entries(first.entries);
+                if (entries.length !== 1)
+                    return { reason: 'a filter with more than one condition isn\'t supported' };
+                const [key, value] = entries[0];
+                if (key === 'visible' && value.kind === 'boolean') {
+                    segments.push(`visible=${value.value}`);
+                }
+                else if (key === 'hasText' && value.kind === 'string' && lastIsCss) {
+                    segments[segments.length - 1] += `:has-text(${quoted(value.value)})`;
+                    css = true;
+                }
+                else if (key === 'hasText' && value.kind === 'regex') {
+                    return { reason: 'filtering by a pattern of the element\'s whole text has no exact equivalent Sifur can replay' };
+                }
+                else {
+                    return { reason: `filtering by ${key} isn't supported here` };
+                }
+                break;
+            }
+            default:
+                return { reason: `.${link.name}() isn't a locator Sifur knows` };
+        }
+        lastIsCss = css;
+    }
+    if (segments.length === 0)
+        return { reason: 'it names no element' };
+    if (segments.length > 1 && segments.some((s) => s.startsWith('label='))) {
+        return { reason: 'a label inside a chain can\'t be replayed: Sifur finds a field by its label only on its own' };
+    }
+    const selector = segments.join(' >> ');
+    if (selector.length > MAX_STEP_SELECTOR)
+        return { reason: `the selector is longer than ${MAX_STEP_SELECTOR} characters` };
+    return { selector };
+}
+/** Under the app's folder: the path from it, as the cases write it. Elsewhere: the whole address. */
+export function relativeUrl(url, baseUrl) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return url;
+    }
+    const folder = appFolder(baseUrl).toString();
+    const full = parsed.toString();
+    if (!full.startsWith(folder))
+        return full;
+    return full.slice(folder.length) || './';
+}
+function sameUrl(a, b) {
+    try {
+        return new URL(a).toString() === new URL(b).toString();
+    }
+    catch {
+        return a === b;
+    }
+}
+function mapStatement(links, options, first) {
+    const head = links[0];
+    if (head.name === 'expect') {
+        const subject = head.args?.[0];
+        if (head.args?.length !== 1 || subject?.kind !== 'chain')
+            return { reason: 'a check Sifur can\'t read' };
+        const matchers = links.slice(1);
+        if (matchers.some((m) => m.name === 'not'))
+            return { reason: 'a negative check (.not) isn\'t supported' };
+        const matcher = matchers[0];
+        if (matchers.length !== 1 || !matcher?.args)
+            return { reason: 'a check Sifur can\'t read' };
+        const expected = str(matcher.args[0]);
+        if (subject.links.length === 1 && subject.links[0].name === 'page') {
+            if (matcher.name === 'toHaveURL' && expected !== undefined)
+                return { step: { action: 'expectUrl', text: relativeUrl(expected, options.baseUrl) } };
+            return { reason: `${matcher.name} on the page isn't supported; only toHaveURL with an address is` };
+        }
+        const located = selectorOf(subject.links);
+        if ('reason' in located)
+            return located;
+        switch (matcher.name) {
+            case 'toContainText':
+            case 'toHaveText':
+                if (expected === undefined || matcher.args.length !== 1)
+                    return { reason: 'a text check needs plain text, not a pattern or a list' };
+                if (expected.length > MAX_VALUE)
+                    return { reason: `the text is longer than ${MAX_VALUE} characters` };
+                return { step: { action: 'expectText', selector: located.selector, text: expected } };
+            case 'toBeVisible':
+                if (matcher.args.length > 0)
+                    return { reason: 'toBeVisible with options isn\'t supported' };
+                return { step: { action: 'expectVisible', selector: located.selector } };
+            case 'toHaveValue':
+            case 'toBeEmpty':
+                return { reason: 'Sifur has no check for what\'s in a field: use "Assert text" or "Assert visibility" on what the change shows' };
+            case 'toBeChecked':
+                return { reason: 'Sifur has no check for a checkbox: use "Assert text" or "Assert visibility" on what the change shows' };
+            case 'toMatchAriaSnapshot':
+                return { reason: 'snapshot checks aren\'t supported: use "Assert text" or "Assert visibility"' };
+            default:
+                return { reason: `${matcher.name} isn't a check Sifur knows` };
+        }
+    }
+    if (head.name !== 'page')
+        return { reason: 'it acts on another page, a popup or a download, which Sifur can\'t follow' };
+    if (head.args)
+        return { reason: 'a step Sifur can\'t read' };
+    const second = links[1];
+    if (!second)
+        return { reason: 'a step Sifur can\'t read' };
+    if (['keyboard', 'mouse', 'touchscreen'].includes(second.name)) {
+        return { reason: `the ${second.name} isn't supported on its own: act on an element instead` };
+    }
+    if (links.length === 2) {
+        const arg = str(second.args?.[0]);
+        switch (second.name) {
+            case 'goto': {
+                if (arg === undefined || second.args.length !== 1)
+                    return { reason: 'a goto Sifur can\'t read' };
+                if (first && options.startUrl && sameUrl(arg, options.startUrl))
+                    return { skip: true };
+                if (redactUrl(arg, {}) !== arg)
+                    return { reason: 'the address carries a token, password or session: open the page by clicking to it instead' };
+                const url = relativeUrl(arg, options.baseUrl);
+                if (url.length > MAX_VALUE)
+                    return { reason: `the address is longer than ${MAX_VALUE} characters` };
+                return { step: { action: 'goto', url } };
+            }
+            case 'close':
+                return { skip: true };
+            case 'waitForTimeout':
+                if (second.args?.[0]?.kind !== 'number')
+                    return { reason: 'a wait Sifur can\'t read' };
+                return { step: { action: 'wait', value: String(second.args[0].value) } };
+            case 'once':
+            case 'on':
+                return { reason: arg === 'dialog' ? 'answering a dialog isn\'t supported' : `listening for ${arg ?? 'an event'} isn't supported` };
+            default:
+                return { reason: `page.${second.name}() isn't something Sifur can replay` };
+        }
+    }
+    const action = links.at(-1);
+    if (!action.args)
+        return { reason: `.${action.name} isn't something Sifur can replay` };
+    const known = ['click', 'dblclick', 'check', 'uncheck', 'fill', 'press', 'selectOption'];
+    if (!known.includes(action.name))
+        return { reason: REASONS[action.name] ?? `.${action.name}() isn't something Sifur can replay` };
+    const located = selectorOf(links.slice(0, -1));
+    if ('reason' in located)
+        return located;
+    const selector = located.selector;
+    const value = str(action.args[0]);
+    switch (action.name) {
+        case 'click':
+        case 'dblclick':
+        case 'check':
+        case 'uncheck':
+            if (action.args.length > 0) {
+                const keys = action.args[0]?.kind === 'object' ? Object.keys(action.args[0].entries).join(', ') : 'options';
+                return { reason: `a click with ${keys} (a right-click, a click with a key held, or at a point) isn't supported` };
+            }
+            return { step: { action: 'click', selector } };
+        case 'fill':
+        case 'press':
+        case 'selectOption':
+            if (value === undefined || action.args.length !== 1) {
+                return { reason: action.name === 'selectOption' ? 'choosing more than one option, or by label or index, isn\'t supported' : `a ${action.name} Sifur can't read` };
+            }
+            if (value.length > MAX_VALUE)
+                return { reason: `the value is longer than ${MAX_VALUE} characters` };
+            return { step: { action: action.name === 'selectOption' ? 'select' : action.name, selector, value } };
+    }
+    return { reason: 'a step Sifur can\'t read' };
+}
+/** A statement as shown back to the engineer, with anything typed hidden: it may be a password. */
+function shown(source, tokens) {
+    const text = source.slice(tokens[0].start, tokens.at(-1).end);
+    return text
+        .replace(/\.(fill|pressSequentially|type)\((['"`])(?:\\.|(?!\2).)*\2/g, '.$1(\'…\'')
+        .replace(/\s*\n\s*/g, ' ');
+}
+/** The steps of a test that Playwright's recorder wrote (`--target playwright-test`), and every line that can't be replayed. */
+export function parseRecording(source, options) {
+    const statements = testBody(tokenize(source));
+    const steps = [];
+    const refused = [];
+    for (const tokens of statements) {
+        const line = tokens[0].line;
+        const code = shown(source, tokens);
+        let mapped;
+        if (['const', 'let', 'var'].includes(tokens[0].value)) {
+            const popup = tokens.some((t) => (t.kind === 'string' && (t.value === 'popup' || t.value === 'download')) || (t.kind === 'ident' && /^(page\d+|download\d*)(Promise)?$/.test(t.value)));
+            mapped = { reason: popup ? 'it opens a new page, a popup or a download, which Sifur can\'t follow' : 'a variable Sifur can\'t follow' };
+        }
+        else {
+            try {
+                const parser = new Parser(tokens[0].value === 'await' ? tokens.slice(1) : tokens);
+                const links = parser.chain();
+                if (!parser.done)
+                    throw new Unreadable();
+                mapped = mapStatement(links, options, steps.length === 0 && refused.length === 0);
+            }
+            catch (error) {
+                if (!(error instanceof Unreadable))
+                    throw error;
+                mapped = { reason: 'a step Sifur can\'t read' };
+            }
+        }
+        if ('step' in mapped)
+            steps.push(mapped.step);
+        else if ('reason' in mapped)
+            refused.push({ line, code, reason: mapped.reason });
+    }
+    return { steps, refused };
+}