@poe-platform/safe-bash 0.1.726 → 0.1.727

package/dist/safe-bash/commands/text-programs/regex.js

@@ -96,6 +96,8 @@ export class Pattern {
     parsed;
     anchored;
     linear = false;
+    literalMatch;
+    simpleRepeatMatch;
     backreferences = false;
     constructor(source, extended = true, ignoreCase = false, dialect = "sed", modifiers = "") {
         this.ignoreCase = ignoreCase;
@@ -110,7 +112,11 @@ export class Pattern {
         let groups = 0;
         let depth = 0;
         const closedGroups = new Set();
-        const characterNode = (character) => ({ type: "character", accepts: candidate => ignoreCase ? candidate.toLowerCase() === character.toLowerCase() : candidate === character });
+        const characterNode = (character) => ({
+            type: "character",
+            ...(ignoreCase ? {} : { literal: character }),
+            accepts: candidate => ignoreCase ? candidate.toLowerCase() === character.toLowerCase() : candidate === character,
+        });
         const escaped = () => {
             const character = source[offset++];
             if (character === undefined)
@@ -305,7 +311,7 @@ export class Pattern {
             return;
         const { root, counts } = this.parsed;
         budget.step(counts.get(root) + 1);
-        await budget.checkpoint();
+        await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
         // Publish only a finished program. Cancelled or concurrent preparations own
         // separate arrays, so a failed caller cannot leave a partially patched NFA.
         const code = [];
@@ -318,7 +324,7 @@ export class Pattern {
                 return;
             yield;
             if (node.type === "character") {
-                emit({ kind: "character", accepts: node.accepts });
+                emit({ kind: "character", ...(node.literal !== undefined ? { literal: node.literal } : {}), accepts: node.accepts });
                 return;
             }
             if (node.type === "backreference") {
@@ -396,14 +402,97 @@ export class Pattern {
         let work = 0;
         for (const ignored of compile(root)) {
             if (++work % 64 === 0) {
-                await budget.checkpoint();
+                await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
                 budget.step(0);
             }
         }
         emit({ kind: "match" });
-        await budget.checkpoint();
+        await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
         budget.step(0);
         this.linear = code.every(instruction => instruction.kind === "character" || instruction.kind === "begin" || instruction.kind === "end" || instruction.kind === "match");
+        if (this.linear && !this.ignoreCase && this.dialect !== "jq") {
+            let validLiteral = true;
+            let anchoredStart = false;
+            let anchoredEnd = false;
+            let literalValue = "";
+            for (let i = 0; i < code.length - 1; i++) {
+                const inst = code[i];
+                if (inst.kind === "begin") {
+                    if (i === 0)
+                        anchoredStart = true;
+                    else {
+                        validLiteral = false;
+                        break;
+                    }
+                }
+                else if (inst.kind === "end") {
+                    if (i === code.length - 2)
+                        anchoredEnd = true;
+                    else {
+                        validLiteral = false;
+                        break;
+                    }
+                }
+                else if (inst.kind === "character" && inst.literal !== undefined) {
+                    literalValue += inst.literal;
+                }
+                else {
+                    validLiteral = false;
+                    break;
+                }
+            }
+            if (validLiteral) {
+                this.literalMatch = { value: literalValue, anchoredStart, anchoredEnd, groups: [literalValue] };
+            }
+        }
+        else if (!this.ignoreCase && this.dialect !== "jq" && root.type === "sequence" && this.groupCount <= 1) {
+            let startIdx = 0;
+            let endIdx = root.nodes.length;
+            let anchoredStart = false;
+            let anchoredEnd = false;
+            if (startIdx < endIdx && root.nodes[startIdx]?.type === "begin") {
+                anchoredStart = true;
+                startIdx++;
+            }
+            if (startIdx < endIdx && root.nodes[endIdx - 1]?.type === "end") {
+                anchoredEnd = true;
+                endIdx--;
+            }
+            if (startIdx < endIdx) {
+                let prefix = "";
+                let prefixValid = true;
+                for (let i = startIdx; i < endIdx - 1; i++) {
+                    const n = root.nodes[i];
+                    if (n.type === "character" && n.literal !== undefined) {
+                        prefix += n.literal;
+                    }
+                    else {
+                        prefixValid = false;
+                        break;
+                    }
+                }
+                const tail = root.nodes[endIdx - 1];
+                const captured = tail.type === "group" && tail.index === 1 && this.groupCount === 1;
+                const rawInner = captured ? tail.node : this.groupCount === 0 ? tail : undefined;
+                const repeatNode = rawInner?.type === "sequence" && rawInner.nodes.length === 1 ? rawInner.nodes[0] : rawInner;
+                if (prefixValid &&
+                    (anchoredStart || prefix.length > 0) &&
+                    repeatNode?.type === "repeat" &&
+                    repeatNode.minimum >= 1 &&
+                    repeatNode.maximum === Infinity &&
+                    !repeatNode.lazy &&
+                    repeatNode.node.type === "character") {
+                    this.simpleRepeatMatch = {
+                        prefix,
+                        anchoredStart,
+                        anchoredEnd,
+                        captured,
+                        minimum: repeatNode.minimum,
+                        accepts: repeatNode.node.accepts,
+                    };
+                }
+            }
+        }
         this.backreferences = code.some(instruction => instruction.kind === "backreference");
         this.code = code;
         this.parsed = undefined;
@@ -417,7 +506,7 @@ export class Pattern {
             let checkpoints = 0;
             while (pending.length) {
                 if (++checkpoints % 64 === 1)
-                    await budget.checkpoint();
+                    await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
                 budget.step();
                 const state = pending.pop();
                 if (options.end !== undefined && state.position > options.end)
@@ -499,12 +588,266 @@ export class Pattern {
         }
         return undefined;
     }
+    canFindSync() {
+        return this.code.length > 0 && this.dialect !== "jq" && Boolean(this.literalMatch || this.simpleRepeatMatch);
+    }
+    findSyncFast(text, budget, from = 0) {
+        if (this.simpleRepeatMatch) {
+            const { prefix, anchoredStart, anchoredEnd, captured, minimum, accepts } = this.simpleRepeatMatch;
+            if (from > text.length || (anchoredStart && from > 0))
+                return undefined;
+            let found = -1;
+            let matchEnd = -1;
+            let groupStart = -1;
+            let groupEnd = -1;
+            if (anchoredStart) {
+                if (text.startsWith(prefix)) {
+                    const pos = prefix.length;
+                    let cursor = pos;
+                    while (cursor < text.length && accepts(text[cursor]))
+                        cursor++;
+                    if (cursor - pos >= minimum && (!anchoredEnd || cursor === text.length)) {
+                        found = 0;
+                        matchEnd = cursor;
+                        groupStart = pos;
+                        groupEnd = cursor;
+                    }
+                }
+            }
+            else {
+                let searchFrom = from;
+                while (searchFrom <= text.length - prefix.length) {
+                    const idx = text.indexOf(prefix, searchFrom);
+                    if (idx < 0)
+                        break;
+                    const pos = idx + prefix.length;
+                    let cursor = pos;
+                    while (cursor < text.length && accepts(text[cursor]))
+                        cursor++;
+                    if (cursor - pos >= minimum && (!anchoredEnd || cursor === text.length)) {
+                        found = idx;
+                        matchEnd = cursor;
+                        groupStart = pos;
+                        groupEnd = cursor;
+                        break;
+                    }
+                    searchFrom = idx + 1;
+                }
+            }
+            const positionsTried = anchoredStart ? 1 : found >= 0 ? found - from + 1 : text.length - from + 1;
+            const len = found >= 0 ? matchEnd - found : 0;
+            budget.step(positionsTried * 2 + (found >= 0 ? this.code.length * 2 + len : 0));
+            if (found < 0)
+                return undefined;
+            if (len > budget.maxBufferBytes)
+                throw new ProgramError("text buffer limit exceeded");
+            const full = text.slice(found, matchEnd);
+            const groups = captured ? [full, text.slice(groupStart, groupEnd)] : [full];
+            return { start: found, end: matchEnd, groups };
+        }
+        const { value, anchoredStart, anchoredEnd, groups } = this.literalMatch;
+        const len = value.length;
+        if (from > text.length || (anchoredStart && from > 0))
+            return undefined;
+        let found = -1;
+        if (anchoredStart && anchoredEnd) {
+            if (from === 0 && text.length === len && text === value)
+                found = 0;
+        }
+        else if (anchoredStart) {
+            if (from === 0 && text.startsWith(value))
+                found = 0;
+        }
+        else if (anchoredEnd) {
+            const candidate = text.length - len;
+            if (candidate >= from && text.endsWith(value))
+                found = candidate;
+        }
+        else {
+            found = text.indexOf(value, from);
+        }
+        const positionsTried = anchoredStart ? 1 : found >= 0 ? found - from + 1 : text.length - from + 1;
+        budget.step(positionsTried * 2 + (found >= 0 ? this.code.length * 2 + len : 0));
+        if (found < 0)
+            return undefined;
+        if (len > budget.maxBufferBytes)
+            throw new ProgramError("text buffer limit exceeded");
+        return { start: found, end: found + len, groups };
+    }
+    tryFindSync(text, budget, from = 0) {
+        if (this.code.length && this.simpleRepeatMatch && this.dialect !== "jq") {
+            const initialCheck = (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
+            if (initialCheck)
+                return initialCheck.then(() => this.find(text, budget, from));
+            return this.execSimpleRepeat(text, budget, from);
+        }
+        if (!this.code.length || !this.literalMatch || this.dialect === "jq") {
+            return this.find(text, budget, from);
+        }
+        const initialCheck = (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
+        if (initialCheck)
+            return initialCheck.then(() => this.find(text, budget, from));
+        const { value, anchoredStart, anchoredEnd, groups } = this.literalMatch;
+        const len = value.length;
+        if (from > text.length || (anchoredStart && from > 0))
+            return undefined;
+        let found = -1;
+        if (anchoredStart && anchoredEnd) {
+            if (from === 0 && text.length === len && text === value)
+                found = 0;
+        }
+        else if (anchoredStart) {
+            if (from === 0 && text.startsWith(value))
+                found = 0;
+        }
+        else if (anchoredEnd) {
+            const candidate = text.length - len;
+            if (candidate >= from && text.endsWith(value))
+                found = candidate;
+        }
+        else {
+            found = text.indexOf(value, from);
+        }
+        const positionsTried = anchoredStart ? 1 : found >= 0 ? found - from + 1 : text.length - from + 1;
+        const stepCount = positionsTried * 2 + (found >= 0 ? this.code.length * 2 + len : 0);
+        budget.step(stepCount);
+        if (stepCount >= 64) {
+            const midCheck = (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
+            if (midCheck) {
+                if (found < 0)
+                    return midCheck.then(() => undefined);
+                if (len > budget.maxBufferBytes)
+                    throw new ProgramError("text buffer limit exceeded");
+                return midCheck.then(() => ({ start: found, end: found + len, groups }));
+            }
+        }
+        if (found < 0)
+            return undefined;
+        if (len > budget.maxBufferBytes)
+            throw new ProgramError("text buffer limit exceeded");
+        const endCheck = (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
+        if (endCheck)
+            return endCheck.then(() => ({ start: found, end: found + len, groups }));
+        return { start: found, end: found + len, groups };
+    }
+    execSimpleRepeat(text, budget, from) {
+        const { prefix, anchoredStart, anchoredEnd, captured, minimum, accepts } = this.simpleRepeatMatch;
+        if (from > text.length || (anchoredStart && from > 0))
+            return undefined;
+        let found = -1;
+        let matchEnd = -1;
+        let groupStart = -1;
+        let groupEnd = -1;
+        if (anchoredStart) {
+            if (text.startsWith(prefix)) {
+                const pos = prefix.length;
+                let cursor = pos;
+                while (cursor < text.length && accepts(text[cursor]))
+                    cursor++;
+                if (cursor - pos >= minimum && (!anchoredEnd || cursor === text.length)) {
+                    found = 0;
+                    matchEnd = cursor;
+                    groupStart = pos;
+                    groupEnd = cursor;
+                }
+            }
+        }
+        else {
+            let searchFrom = from;
+            while (searchFrom <= text.length - prefix.length) {
+                const idx = text.indexOf(prefix, searchFrom);
+                if (idx < 0)
+                    break;
+                const pos = idx + prefix.length;
+                let cursor = pos;
+                while (cursor < text.length && accepts(text[cursor]))
+                    cursor++;
+                if (cursor - pos >= minimum && (!anchoredEnd || cursor === text.length)) {
+                    found = idx;
+                    matchEnd = cursor;
+                    groupStart = pos;
+                    groupEnd = cursor;
+                    break;
+                }
+                searchFrom = idx + 1;
+            }
+        }
+        const positionsTried = anchoredStart ? 1 : found >= 0 ? found - from + 1 : text.length - from + 1;
+        const len = found >= 0 ? matchEnd - found : 0;
+        const stepCount = positionsTried * 2 + (found >= 0 ? this.code.length * 2 + len : 0);
+        budget.step(stepCount);
+        const finish = () => {
+            if (found < 0)
+                return undefined;
+            if (len > budget.maxBufferBytes)
+                throw new ProgramError("text buffer limit exceeded");
+            const full = text.slice(found, matchEnd);
+            const groups = captured ? [full, text.slice(groupStart, groupEnd)] : [full];
+            return { start: found, end: matchEnd, groups };
+        };
+        if (stepCount >= 64) {
+            const midCheck = (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
+            if (midCheck)
+                return midCheck.then(finish);
+        }
+        const endCheck = (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
+        if (endCheck)
+            return endCheck.then(finish);
+        return finish();
+    }
     async find(text, budget, from = 0) {
         if (!this.code.length)
             await this.prepare(budget);
         if (this.dialect === "jq")
             return (await this.findJq(text, budget, from))?.match;
-        await budget.checkpoint();
+        if (this.simpleRepeatMatch) {
+            const initialCheck = (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
+            if (initialCheck)
+                await initialCheck;
+            return await this.execSimpleRepeat(text, budget, from);
+        }
+        const initialCheck = (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
+        if (initialCheck)
+            await initialCheck;
+        if (this.literalMatch) {
+            const { value, anchoredStart, anchoredEnd, groups } = this.literalMatch;
+            const len = value.length;
+            if (from > text.length || (anchoredStart && from > 0))
+                return undefined;
+            let found = -1;
+            if (anchoredStart && anchoredEnd) {
+                if (from === 0 && text.length === len && text === value)
+                    found = 0;
+            }
+            else if (anchoredStart) {
+                if (from === 0 && text.startsWith(value))
+                    found = 0;
+            }
+            else if (anchoredEnd) {
+                const candidate = text.length - len;
+                if (candidate >= from && text.endsWith(value))
+                    found = candidate;
+            }
+            else {
+                found = text.indexOf(value, from);
+            }
+            const positionsTried = anchoredStart ? 1 : found >= 0 ? found - from + 1 : text.length - from + 1;
+            const stepCount = positionsTried * 2 + (found >= 0 ? this.code.length * 2 + len : 0);
+            budget.step(stepCount);
+            if (stepCount >= 64) {
+                const midCheck = (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
+                if (midCheck)
+                    await midCheck;
+            }
+            if (found < 0)
+                return undefined;
+            if (len > budget.maxBufferBytes)
+                throw new ProgramError("text buffer limit exceeded");
+            const endCheck = (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
+            if (endCheck)
+                await endCheck;
+            return { start: found, end: found + len, groups };
+        }
         let units = 0;
         const work = (count = 1) => {
             budget.step(count);
@@ -512,7 +855,7 @@ export class Pattern {
             if (units < 64)
                 return undefined;
             units %= 64;
-            return budget.checkpoint();
+            return (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
         };
         if (this.linear) {
             for (let start = from; start <= text.length && (!this.anchored || start === 0); start++) {
@@ -535,7 +878,7 @@ export class Pattern {
                         if (copied)
                             await copied;
                         const match = { start, end: position, groups: [text.slice(start, position)] };
-                        await budget.checkpoint();
+                        await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
                         return match;
                     }
                 }
@@ -754,7 +1097,7 @@ export class Pattern {
                     const end = bestCaptures[index * 2 + 1];
                     groups.push(begin === undefined || end === undefined ? undefined : text.slice(begin, end));
                 }
-                await budget.checkpoint();
+                await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
                 return { start: bestStart, end: bestEnd, groups };
             }
             return undefined;
@@ -771,7 +1114,7 @@ async function replacementLength(replacement, match, budget, available, syntax)
     let tokens = 0;
     for (let index = 0; index < replacement.length; index++) {
         if (tokens++ % 256 === 0)
-            await budget.checkpoint();
+            await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
         budget.step();
         const character = replacement[index];
         let size = 1;
@@ -801,7 +1144,7 @@ async function replacementText(replacement, match, buffer, budget, syntax) {
     let tokens = 0;
     for (let index = 0; index < replacement.length; index++) {
         if (tokens++ % 256 === 0)
-            await budget.checkpoint();
+            await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
         budget.step();
         const character = replacement[index];
         if (character !== "&" && (character !== "\\" || index + 1 === replacement.length))
@@ -828,7 +1171,152 @@ async function replacementText(replacement, match, buffer, budget, syntax) {
     }
     await buffer.append(replacement, literal);
 }
+function expandReplacementSync(replacement, match, budget, available, syntax) {
+    if (!replacement.includes("&") && !replacement.includes("\\")) {
+        budget.step(replacement.length * 2 + 1);
+        if (replacement.length > available)
+            throw new ProgramError("text buffer limit exceeded");
+        return replacement;
+    }
+    let out = "";
+    for (let index = 0; index < replacement.length; index++) {
+        budget.step();
+        const character = replacement[index];
+        let piece = character;
+        if (character === "&") {
+            budget.step();
+            piece = match.groups[0] ?? "";
+        }
+        else if (character === "\\" && index + 1 < replacement.length) {
+            budget.step();
+            const next = replacement[++index];
+            if (syntax === "awk") {
+                piece = next === "&" || next === "\\" ? next : `\\${next}`;
+            }
+            else if (next >= "0" && next <= "9") {
+                budget.step();
+                piece = match.groups[Number(next)] ?? "";
+            }
+            else {
+                piece = next === "n" ? "\n" : next === "t" ? "\t" : next;
+            }
+        }
+        if (piece.length > available - out.length)
+            throw new ProgramError("text buffer limit exceeded");
+        out += piece;
+    }
+    budget.step(out.length + 1);
+    return out;
+}
+export function trySubstituteSync(text, pattern, replacement, budget, global, occurrence = 1, syntax = "sed") {
+    if (pattern.canFindSync() && text.length <= 4096 && replacement.length <= 256) {
+        const check = (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
+        if (check)
+            return substitute(text, pattern, replacement, budget, global, occurrence, syntax);
+        let search = 0;
+        let consumed = 0;
+        let previousEnd = -1;
+        let encountered = 0;
+        let count = 0;
+        let out = "";
+        while (search <= text.length) {
+            budget.step();
+            const match = pattern.findSyncFast(text, budget, search);
+            if (!match)
+                break;
+            if (match.start === match.end && match.start === previousEnd) {
+                search = match.end + 1;
+                continue;
+            }
+            encountered++;
+            if (encountered >= occurrence) {
+                const prefixLen = match.start - consumed;
+                if (out.length + prefixLen > budget.maxBufferBytes) {
+                    throw new ProgramError("text buffer limit exceeded");
+                }
+                if (prefixLen > 0)
+                    out += text.slice(consumed, match.start);
+                const rep = expandReplacementSync(replacement, match, budget, budget.maxBufferBytes - out.length, syntax);
+                out += rep;
+                consumed = match.end;
+                count++;
+                if (!global)
+                    break;
+            }
+            previousEnd = match.end;
+            search = match.end === match.start ? match.end + 1 : match.end;
+        }
+        if (count > 0) {
+            const tailLen = text.length - consumed;
+            if (out.length + tailLen > budget.maxBufferBytes) {
+                throw new ProgramError("text buffer limit exceeded");
+            }
+            if (tailLen > 0)
+                out += text.slice(consumed);
+        }
+        else {
+            out = budget.check(text);
+        }
+        const postCheck = (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
+        if (postCheck)
+            return postCheck.then(() => ({ text: out, count }));
+        return { text: out, count };
+    }
+    if (!global && occurrence === 1 && !replacement.includes("&") && !replacement.includes("\\")) {
+        const check = (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
+        if (check)
+            return substitute(text, pattern, replacement, budget, global, occurrence, syntax);
+        budget.step();
+        const matchOrPromise = pattern.tryFindSync(text, budget, 0);
+        if (matchOrPromise instanceof Promise) {
+            return matchOrPromise.then(match => {
+                if (!match) {
+                    budget.step(0);
+                    return { text: budget.check(text), count: 0 };
+                }
+                const newLen = text.length - (match.end - match.start) + replacement.length;
+                if (newLen > budget.maxBufferBytes || match.start + replacement.length > budget.maxBufferBytes) {
+                    throw new ProgramError("text buffer limit exceeded");
+                }
+                budget.step(replacement.length * 2 + 1);
+                const out = (match.start === 0 ? "" : text.slice(0, match.start)) + replacement + (match.end === text.length ? "" : text.slice(match.end));
+                return { text: budget.check(out), count: 1 };
+            });
+        }
+        const match = matchOrPromise;
+        if (!match) {
+            budget.step(0);
+            return { text: budget.check(text), count: 0 };
+        }
+        const newLen = text.length - (match.end - match.start) + replacement.length;
+        if (newLen > budget.maxBufferBytes || match.start + replacement.length > budget.maxBufferBytes) {
+            throw new ProgramError("text buffer limit exceeded");
+        }
+        budget.step(replacement.length * 2 + 1);
+        const out = (match.start === 0 ? "" : text.slice(0, match.start)) + replacement + (match.end === text.length ? "" : text.slice(match.end));
+        return { text: budget.check(out), count: 1 };
+    }
+    return substitute(text, pattern, replacement, budget, global, occurrence, syntax);
+}
 export async function substitute(text, pattern, replacement, budget, global, occurrence = 1, syntax = "sed") {
+    if (!global && occurrence === 1 && !replacement.includes("&") && !replacement.includes("\\")) {
+        const check = (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
+        if (check)
+            await check;
+        budget.step();
+        const match = await pattern.find(text, budget, 0);
+        if (!match) {
+            budget.step(0);
+            return { text: budget.check(text), count: 0 };
+        }
+        const newLen = text.length - (match.end - match.start) + replacement.length;
+        if (newLen > budget.maxBufferBytes || match.start + replacement.length > budget.maxBufferBytes) {
+            throw new ProgramError("text buffer limit exceeded");
+        }
+        budget.step(replacement.length * 2 + 1);
+        const out = (match.start === 0 ? "" : text.slice(0, match.start)) + replacement + (match.end === text.length ? "" : text.slice(match.end));
+        return { text: budget.check(out), count: 1 };
+    }
     let search = 0;
     let consumed = 0;
     let previousEnd = -1;
@@ -837,7 +1325,7 @@ export async function substitute(text, pattern, replacement, budget, global, occ
     const result = new ReplacementBuffer(budget);
     try {
         while (search <= text.length) {
-            await budget.checkpoint();
+            await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
             budget.step();
             const match = await pattern.find(text, budget, search);
             if (!match)