@poe-platform/safe-bash 0.1.78 → 0.1.80

package/dist/safe-bash/shell/runtime.js

@@ -10,6 +10,7 @@ import { evaluateArithmetic, prepareArithmetic } from "./arithmetic.js";
 import { defaultMaxParseUnits, ParseBudget } from "./parse-budget.js";
 import { evaluatePositionalArithmetic } from "./arithmetic-parameters.js";
 import { compilePattern, matchesPattern } from "./pattern.js";
+import { nextCodePointOffset, previousCodePointOffset, scanString, stringCheckpoint } from "./string-operations.js";
 import { byteLocale } from "./locale.js";
 import { functionDisplay } from "./display.js";
 import { ConditionalUnsupported, evaluateConditional } from "./conditional.js";
@@ -4939,7 +4940,15 @@ export class Runtime {
             holding?.release();
         }
     }
+    parameterOperandIO(word, state, io) {
+        this.signal.throwIfAborted();
+        const parameterDepth = (io.parameterDepth ?? 0) + 1;
+        if (state.depth + parameterDepth > 64)
+            throw new ShellSyntaxError("Syntax nesting exceeds 64", word.offset);
+        return { ...io, parameterDepth };
+    }
     async partValue(part, state, io, hereString) {
+        this.signal.throwIfAborted();
         if (part.kind === "failed-substitution") {
             if (state.depth >= this.budget.limits.maxSubstitutionDepth)
                 this.budget.fail("maxSubstitutionDepth");
@@ -4966,6 +4975,9 @@ export class Runtime {
         if (part.kind === "substitution") {
             if (state.depth >= this.budget.limits.maxSubstitutionDepth)
                 this.budget.fail("maxSubstitutionDepth");
+            const parameterDepth = io.parameterDepth ?? 0;
+            if (parameterDepth > 0 && state.depth + parameterDepth + 1 > 64)
+                throw new ShellSyntaxError("Syntax nesting exceeds 64", 0);
             const capture = new Capture();
             const child = await cloneState(state, this.signal);
             child.isolated = true;
@@ -5022,7 +5034,7 @@ export class Runtime {
                     throw new ArrayFailure("index outside 0..2147483647");
                 const value = binding ? binding.get(index) : index === 0 ? state.variables[part.name] : undefined;
                 this.requireParameter(value, `${part.name}[${selector.index}]`, state, io, part.line);
-                return part.length ? String(Array.from(value ?? "").length) : value ?? "";
+                return part.length ? this.parameterLength(value ?? "") : value ?? "";
             }
             if (part.length)
                 return String(binding?.values.size ?? (state.variables[part.name] === undefined ? 0 : 1));
@@ -5060,17 +5072,18 @@ export class Runtime {
             const missing = value === undefined || (part.operator.startsWith(":") && value === "");
             const operator = part.operator.at(-1);
             if ((operator === "+" && !missing) || (operator !== "+" && missing)) {
+                const operandIO = this.parameterOperandIO(part.alternate, state, io);
                 let alternate;
                 if (operator === "=" && arrayStore(state)?.get(part.name)) {
                     alternate = "";
                     await this.arrayZero(state, part.name, async () => {
-                        alternate = await this.arrayJoin(requireArrays(state).owner, await this.word(part.alternate, state, io, false, false, hereString), "");
+                        alternate = await this.arrayJoin(requireArrays(state).owner, await this.word(part.alternate, state, operandIO, false, false, hereString), "");
                         return alternate;
                     });
                     value = alternate;
-                    return part.length ? String(Array.from(value).length) : value;
+                    return part.length ? this.parameterLength(value) : value;
                 }
-                retained = concatShellValues(await this.valueWord(part.alternate, state, io, false, false, hereString), io[valueScope]);
+                retained = concatShellValues(await this.valueWord(part.alternate, state, operandIO, false, false, hereString), io[valueScope]);
                 alternate = shellValueText(retained);
                 if (operator === "?")
                     throw new ParameterExpansionFailure(`${part.name}: ${alternate || (part.operator.startsWith(":") ? "parameter null or not set" : "parameter not set")}`, io.diagnosticLine ?? part.line);
@@ -5088,7 +5101,15 @@ export class Runtime {
         }
         else
             this.requireParameter(value, part.name, state, io, part.line);
-        return part.length ? String(Array.from(value ?? "").length) : retained ?? "";
+        return part.length ? this.parameterLength(value ?? "") : retained ?? "";
+    }
+    async parameterLength(value) {
+        const limit = this.budget.limits.maxExpansionBytes;
+        const work = { remaining: Math.min(Number.MAX_SAFE_INTEGER, limit * 4 + 1024), signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
+        const scanned = await scanString(value, work);
+        if (scanned.bytes > limit)
+            this.budget.fail("maxExpansionBytes");
+        return String(scanned.count);
     }
     async substring(part, value, state, io) {
         const owner = arrayStore(state)?.get(part.name) ? requireArrays(state).owner : undefined;
@@ -5101,170 +5122,226 @@ export class Runtime {
         const limit = this.budget.limits.maxExpansionBytes;
         if (Buffer.byteLength(value) > limit)
             this.budget.fail("maxExpansionBytes");
-        const variables = new Proxy(this.arithmeticVariables(state, line), { get: (target, key) => {
-                this.signal.throwIfAborted();
-                const value = Reflect.get(target, key);
-                if (typeof value === "string" && Buffer.byteLength(value) > limit)
-                    this.budget.fail("maxExpansionBytes");
-                return value;
-            } });
-        const arithmetic = async (word) => {
-            let source = "";
-            let bytes = 0;
-            for (const entry of word.parts) {
+        const scratch = this.budget.values.scope();
+        const work = { remaining: Math.min(Number.MAX_SAFE_INTEGER, limit * 4 + 1024), signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
+        try {
+            const variables = new Proxy(this.arithmeticVariables(state, line), { get: (target, key) => {
+                    this.signal.throwIfAborted();
+                    const value = Reflect.get(target, key);
+                    if (typeof value === "string" && Buffer.byteLength(value) > limit)
+                        this.budget.fail("maxExpansionBytes");
+                    return value;
+                } });
+            const arithmetic = async (word) => {
+                const operandIO = this.parameterOperandIO(word, state, io);
+                let source = "";
+                let bytes = 0;
+                let retained;
+                for (const entry of word.parts) {
+                    this.signal.throwIfAborted();
+                    const text = entry.kind === "text" ? entry.value : await this.part(entry, state, operandIO);
+                    bytes += Buffer.byteLength(text);
+                    if (bytes > limit)
+                        this.budget.fail("maxExpansionBytes");
+                    owner?.reserve({ metadata: 32, payload: bytes, work: text.length + 4 });
+                    const pending = stringCheckpoint(work, text.length + 1);
+                    if (pending)
+                        await pending;
+                    const next = scratch.reserve((source.length + text.length) * 2, 0);
+                    source += text;
+                    retained?.release();
+                    retained = next;
+                }
                 this.signal.throwIfAborted();
-                const text = entry.kind === "text" ? entry.value : await this.part(entry, state, io);
-                bytes += Buffer.byteLength(text);
-                if (bytes > limit)
-                    this.budget.fail("maxExpansionBytes");
-                owner?.reserve({ metadata: 32, payload: bytes, work: text.length + 4 });
-                source += text;
+                try {
+                    return { value: evaluateArithmetic(prepareArithmetic(source, this.budget.parsing), variables, this.budget.parsing), source };
+                }
+                catch (error) {
+                    this.rethrowArithmeticControl(error);
+                    throw new ExpansionFailure(`${part.name}: ${message(error)}`, line);
+                }
+                finally {
+                    retained?.release();
+                }
+            };
+            const offsetExpression = await arithmetic(expression.offset);
+            let bytes;
+            if (byteLocale(state.variables)) {
+                scratch.reserve(Buffer.byteLength(value), 0);
+                bytes = Buffer.from(value);
+            }
+            const size = BigInt(bytes?.byteLength ?? (await scanString(value, work)).count);
+            const offset = offsetExpression.value < 0n ? size + offsetExpression.value : offsetExpression.value;
+            if (offset < 0n || offset > size)
+                return "";
+            let end = size;
+            if (expression.length) {
+                const length = await arithmetic(expression.length);
+                end = length.value < 0n ? size + length.value : offset + length.value;
+                if (end < offset)
+                    throw new ExpansionFailure(`${length.source}: substring expression < 0`, line);
+                if (end > size)
+                    end = size;
             }
             this.signal.throwIfAborted();
+            if (!bytes) {
+                const start = (await scanString(value, work, 0, value.length, Number(offset))).end;
+                const finish = (await scanString(value, work, start, value.length, Number(end - offset))).end;
+                if (finish > start)
+                    scratch.reserve((finish - start) * 2, 0);
+                return value.slice(start, finish);
+            }
+            scratch.reserve(Number(end - offset) * 2, 0);
             try {
-                return { value: evaluateArithmetic(prepareArithmetic(source, this.budget.parsing), variables, this.budget.parsing), source };
+                return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes.subarray(Number(offset), Number(end)));
             }
-            catch (error) {
-                this.rethrowArithmeticControl(error);
-                throw new ExpansionFailure(`${part.name}: ${message(error)}`, line);
+            catch {
+                throw new ExpansionFailure("substring expansion splits a UTF-8 character in a byte locale", line);
             }
-        };
-        const offsetExpression = await arithmetic(expression.offset);
-        owner?.reserve({ metadata: 128 + value.length * 64, payload: Buffer.byteLength(value), allocatedSlots: value.length, work: value.length + 8 });
-        const characters = byteLocale(state.variables) ? undefined : Array.from(value);
-        const bytes = characters ? undefined : Buffer.from(value);
-        const size = BigInt(characters?.length ?? bytes.byteLength);
-        const offset = offsetExpression.value < 0n ? size + offsetExpression.value : offsetExpression.value;
-        if (offset < 0n || offset > size)
-            return "";
-        let end = size;
-        if (expression.length) {
-            const length = await arithmetic(expression.length);
-            end = length.value < 0n ? size + length.value : offset + length.value;
-            if (end < offset)
-                throw new ExpansionFailure(`${length.source}: substring expression < 0`, line);
-            if (end > size)
-                end = size;
         }
-        this.signal.throwIfAborted();
-        owner?.reserve({ metadata: 96 + value.length * 32, payload: Buffer.byteLength(value) * 3, allocatedSlots: value.length, work: value.length + 7 });
-        if (characters)
-            return characters.slice(Number(offset), Number(end)).join("");
-        try {
-            return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes.subarray(Number(offset), Number(end)));
-        }
-        catch {
-            throw new ExpansionFailure("substring expansion splits a UTF-8 character in a byte locale", line);
+        finally {
+            scratch.close();
         }
     }
     async parameterPattern(part, text, state, io, hereString) {
-        const owner = arrayStore(state)?.get(part.name) ? requireArrays(state).owner : undefined;
         const limit = this.budget.limits.maxExpansionBytes;
         if (Buffer.byteLength(text) > limit)
             this.budget.fail("maxExpansionBytes");
-        const patternFields = await this.word(part.alternate, state, io, false, true, hereString);
-        const pattern = owner ? await this.arrayJoin(owner, patternFields, "") : patternFields.join("");
-        owner?.reserve({ metadata: 128 + text.length * 64, payload: Buffer.byteLength(text), allocatedSlots: text.length, work: text.length + 8 });
-        const characters = Array.from(text);
-        const slice = (start, end = characters.length) => {
-            owner?.reserve({ metadata: 96 + (end - start) * 32, payload: (end - start) * 4, allocatedSlots: end - start, work: end - start + 7 });
-            return characters.slice(start, end).join("");
-        };
-        const work = { remaining: Math.min(Number.MAX_SAFE_INTEGER, limit * 4 + 1024), signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
-        const matches = await compilePattern(pattern, work);
-        let attempts = 0;
-        const match = async (start, end) => {
-            work.remaining -= end - start + 1;
-            if (work.remaining < 0)
-                work.exhausted();
-            if (++attempts % 256 === 0)
-                await yieldTurn(this.signal);
-            this.signal.throwIfAborted();
-            if (owner)
-                await owner.ledger.checkpoint(this.signal, end - start + 1);
-            return matches(slice(start, end));
-        };
-        const operator = part.operator;
-        if (!operator.startsWith("/")) {
-            const longest = operator.length === 2;
-            for (let length = longest ? characters.length : 0; longest ? length >= 0 : length <= characters.length; length += longest ? -1 : 1) {
+        const scratch = this.budget.values.scope();
+        const work = { remaining: Math.min(Number.MAX_SAFE_INTEGER, limit * 4 + 1024), signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes"), allocation: scratch };
+        try {
+            const patternFields = await this.word(part.alternate, state, this.parameterOperandIO(part.alternate, state, io), false, true, hereString);
+            let patternUnits = 0;
+            for (const field of patternFields) {
+                const pending = stringCheckpoint(work, field.length + 1);
+                if (pending)
+                    await pending;
+                patternUnits += field.length;
+            }
+            scratch.reserve(patternUnits * 2, 0);
+            const pattern = patternFields.join("");
+            const size = (await scanString(text, work)).count;
+            const matches = await compilePattern(pattern, work);
+            const match = async (start, end, length) => {
+                const pending = stringCheckpoint(work, length + 1);
+                if (pending)
+                    await pending;
+                return matches(text, start, end);
+            };
+            const operator = part.operator;
+            if (!operator.startsWith("/")) {
+                const longest = operator.length === 2;
                 const prefix = operator.startsWith("#");
-                if (await match(prefix ? 0 : characters.length - length, prefix ? length : characters.length))
-                    return prefix ? slice(length) : slice(0, characters.length - length);
-            }
-            return text;
-        }
-        const replacements = [];
-        owner?.reserve({ metadata: 64, work: 3 });
-        let replacementBytes = 0;
-        for (const [index, entry] of (part.replacement?.parts ?? []).entries()) {
-            let value = entry.kind === "text" ? entry.value : await this.part(entry, state, io, hereString);
-            if (index === 0 && !entry.quoted && /^~(?:\/|$)/u.test(value))
-                value = (state.variables.HOME ?? "~") + value.slice(1);
-            replacementBytes += Buffer.byteLength(value);
-            if (replacementBytes > limit)
-                this.budget.fail("maxExpansionBytes");
-            owner?.reserve({ metadata: 64, payload: Buffer.byteLength(value), allocatedSlots: 1, work: 5 });
-            replacements.push({ value, quoted: entry.quoted });
-        }
-        if (!pattern && operator !== "/#" && operator !== "/%")
-            return text;
-        let result = "";
-        let resultBytes = 0;
-        const append = (value) => {
-            resultBytes += Buffer.byteLength(value);
-            if (resultBytes > limit)
-                this.budget.fail("maxExpansionBytes");
-            owner?.reserve({ metadata: 32, payload: resultBytes, work: value.length + 4 });
-            result += value;
-        };
-        let position = 0;
-        while (position <= characters.length) {
-            let found = false;
-            for (let start = position; start <= characters.length; start++) {
-                if (operator === "/#" && start !== 0)
-                    break;
-                for (let end = characters.length; end >= start; end--) {
-                    if (operator === "/%" && end !== characters.length)
+                let boundary = longest === prefix ? text.length : 0;
+                for (let length = longest ? size : 0; longest ? length >= 0 : length <= size; length += longest ? -1 : 1) {
+                    if (await match(prefix ? 0 : boundary, prefix ? boundary : text.length, length)) {
+                        const start = prefix ? boundary : 0;
+                        const end = prefix ? text.length : boundary;
+                        scratch.reserve((end - start) * 2, 0);
+                        return text.slice(start, end);
+                    }
+                    boundary = longest === prefix ? previousCodePointOffset(text, boundary) : nextCodePointOffset(text, boundary);
+                }
+                return text;
+            }
+            scratch.reserve(64, 0);
+            const replacements = [];
+            let replacementBytes = 0;
+            const replacementIO = part.replacement ? this.parameterOperandIO(part.replacement, state, io) : io;
+            for (const [index, entry] of (part.replacement?.parts ?? []).entries()) {
+                let value = entry.kind === "text" ? entry.value : await this.part(entry, state, replacementIO, hereString);
+                if (index === 0 && !entry.quoted && /^~(?:\/|$)/u.test(value)) {
+                    const home = state.variables.HOME ?? "~";
+                    scratch.reserve((home.length + value.length - 1) * 2, 0);
+                    value = home + value.slice(1);
+                }
+                replacementBytes += Buffer.byteLength(value);
+                if (replacementBytes > limit)
+                    this.budget.fail("maxExpansionBytes");
+                const pending = stringCheckpoint(work, value.length + 1);
+                if (pending)
+                    await pending;
+                scratch.reserve(64 + value.length * 2, 0);
+                replacements.push({ value, quoted: entry.quoted });
+            }
+            if (!pattern && operator !== "/#" && operator !== "/%")
+                return text;
+            let result = "";
+            let resultBytes = 0;
+            let retained;
+            const append = async (value, start = 0, end = value.length) => {
+                resultBytes += (await scanString(value, work, start, end)).bytes;
+                if (resultBytes > limit)
+                    this.budget.fail("maxExpansionBytes");
+                if (start === end)
+                    return;
+                const fragment = scratch.reserve((end - start) * 2, 0);
+                const next = scratch.reserve((result.length + end - start) * 2, 0);
+                result += value.slice(start, end);
+                fragment.release();
+                retained?.release();
+                retained = next;
+            };
+            let position = 0;
+            let positionIndex = 0;
+            while (positionIndex <= size) {
+                let found = false;
+                for (let start = position, startIndex = positionIndex; startIndex <= size; startIndex++, start = nextCodePointOffset(text, start)) {
+                    if (operator === "/#" && start !== 0)
                         break;
-                    if (!await match(start, end))
-                        continue;
-                    append(slice(position, start));
-                    const matched = slice(start, end);
-                    for (const replacement of replacements) {
-                        if (replacement.quoted)
-                            append(replacement.value);
-                        else {
-                            owner?.reserve({ metadata: 64 + replacement.value.length * 64, payload: Buffer.byteLength(replacement.value), allocatedSlots: replacement.value.length, work: replacement.value.length + 4 });
-                            const pieces = replacement.value.split("&");
-                            for (const [index, piece] of pieces.entries()) {
-                                if (index)
-                                    append(matched);
-                                append(piece);
+                    for (let end = text.length, endIndex = size; endIndex >= startIndex; endIndex--, end = previousCodePointOffset(text, end)) {
+                        if (operator === "/%" && end !== text.length)
+                            break;
+                        if (!await match(start, end, endIndex - startIndex))
+                            continue;
+                        await append(text, position, start);
+                        for (const replacement of replacements) {
+                            if (replacement.quoted)
+                                await append(replacement.value);
+                            else {
+                                let fragment = 0;
+                                for (let cursor = 0; cursor < replacement.value.length; cursor++) {
+                                    const pending = stringCheckpoint(work);
+                                    if (pending)
+                                        await pending;
+                                    if (replacement.value[cursor] !== "&")
+                                        continue;
+                                    await append(replacement.value, fragment, cursor);
+                                    await append(text, start, end);
+                                    fragment = cursor + 1;
+                                }
+                                await append(replacement.value, fragment);
                             }
                         }
+                        position = end;
+                        positionIndex = endIndex;
+                        found = true;
+                        if (operator !== "//" || end === text.length) {
+                            await append(text, end);
+                            return result;
+                        }
+                        if (end === start) {
+                            position = nextCodePointOffset(text, end);
+                            positionIndex++;
+                            await append(text, end, position);
+                        }
+                        break;
                     }
-                    position = end;
-                    found = true;
-                    if (operator !== "//" || end === characters.length) {
-                        append(slice(end));
-                        return result;
-                    }
-                    if (end === start) {
-                        append(characters[position]);
-                        position++;
-                    }
-                    break;
+                    if (found)
+                        break;
                 }
-                if (found)
+                if (!found) {
+                    if (positionIndex === 0)
+                        return text;
+                    await append(text, position);
                     break;
+                }
             }
-            if (!found) {
-                append(slice(position));
-                break;
-            }
+            return result;
+        }
+        finally {
+            scratch.close();
         }
-        return result;
     }
     async word(word, state, io, split = true, pattern = false, hereString = false, conditionalPattern = false, regexAppend) {
         return (await this.valueWord(word, state, io, split, pattern, hereString, conditionalPattern, regexAppend)).map(shellValueText);
@@ -5349,16 +5426,17 @@ export class Runtime {
                 if (boundary)
                     addField();
             };
-            const parts = word.parts.map((part) => ({ part, splitText: false }));
+            const parts = word.parts.map((part) => ({ part, splitText: false, io }));
             for (let index = 0; index < parts.length; index++) {
-                const { part, splitText } = parts[index];
+                const { part, splitText, io: partIO } = parts[index];
                 const quotedPresence = part.quoted && !(arrayOwned && isQuoteMarker(part));
                 if (part.kind === "variable" && ["-", "+", ":-", ":+"].includes(part.operator ?? "") && /^[a-zA-Z_][a-zA-Z_0-9]*$/u.test(part.name)) {
                     const value = this.variable(state, part.name);
                     const missing = value === undefined || (part.operator.startsWith(":") && value === "");
                     if (part.operator.endsWith("+") ? !missing : missing) {
+                        const operandIO = this.parameterOperandIO(part.alternate, state, partIO);
                         scratch?.reserve(part.alternate.parts.length * 32, 0);
-                        const alternate = part.alternate.parts.map((entry) => ({ part: copyArraySelector(entry, { ...entry, quoted: entry.quoted || part.quoted }), splitText: true }));
+                        const alternate = part.alternate.parts.map((entry) => ({ part: copyArraySelector(entry, { ...entry, quoted: entry.quoted || part.quoted }), splitText: true, io: operandIO }));
                         if (!alternate.length && part.quoted)
                             append("", false, true);
                         parts.splice(index + 1, 0, ...alternate);
@@ -5394,7 +5472,7 @@ export class Runtime {
                         fields[0].present = false;
                 }
                 else {
-                    const value = part.kind === "text" ? part.byteValue ?? part.value : await this.valuePart(part, state, io, hereString);
+                    const value = part.kind === "text" ? part.byteValue ?? part.value : await this.valuePart(part, state, partIO, hereString);
                     if (part.quoted || !split || state.variables.IFS === "")
                         append(value, !part.quoted, quotedPresence || !split || shellValueByteLength(value) > 0);
                     else