@poe-platform/safe-bash 0.1.800 → 0.1.801

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

@@ -1,4 +1,4 @@
-import { compareByteArrays, decodeBytes, encodeBytes, equalBytes, indexOfBytes } from "../byte-encoding.js";
+import { compareByteArrays, decodeBytes, encodeBytes, indexOfBytes } from "../byte-encoding.js";
 import { PublicDiagnostic } from "../diagnostics.js";
 import { createBufferedOutput, FsError } from "../contracts/index.js";
 import { RETURN_EXIT_ONE, RETURN_EXIT_TWO, RETURN_EXIT_ZERO, assertInputRequirements, bufferLimit, codeOf, concatenate, define, diagnostic, encoder, input, integer, lines, options, output, outputRange, pathOf, requireOperands, RESOLVED_EXIT_ZERO, UsageError, value } from "./internal.js";
@@ -135,9 +135,6 @@ async function cutRanges(list, work) {
     }
     return normalized;
 }
-const sharedCutOutBuffer = new Uint8Array(64 * 1024);
-let sharedCutOutInUse = false;
-const sharedUniqOutBuffer = new Uint8Array(128 * 1024);
 function writeUniqCountBytes(writeByte, count) {
     const digits = String(count);
     const pad = 7 - digits.length;
@@ -151,20 +148,11 @@ class CutOutput {
     context;
     work;
     #buffer;
-    #ownsShared;
     #used = 0;
     constructor(context, work) {
         this.context = context;
         this.work = work;
-        if (!sharedCutOutInUse) {
-            sharedCutOutInUse = true;
-            this.#buffer = sharedCutOutBuffer;
-            this.#ownsShared = true;
-        }
-        else {
-            this.#buffer = new Uint8Array(64 * 1024);
-            this.#ownsShared = false;
-        }
+        this.#buffer = new Uint8Array(64 * 1024);
     }
     get remaining() {
         return this.#buffer.length - this.#used;
@@ -239,10 +227,6 @@ class CutOutput {
         this.#used = 0;
         await output(this.context, bytes);
     }
-    release() {
-        if (this.#ownsShared)
-            sharedCutOutInUse = false;
-    }
 }
 function cutFieldBoundary(record, separator, start, work) {
     if (record.length - start <= 4096) {
@@ -764,14 +748,6 @@ const sharedSortIndices = new Int32Array(4096);
 const sharedSortScratchIndices = new Int32Array(4096);
 const sharedSortInScratch = new Uint8Array(65536);
 let sharedSortInUse = false;
-const sharedSortOutScratch = new Uint8Array(65536);
-let lastSort;
-const cachedCutOutBuffer = new Uint8Array(32768);
-let lastCutInBuf;
-let lastCutSep = -1;
-let lastCutField = -1;
-let lastCutMaxLineLen = 0;
-let lastCutOutUsed = -1;
 const SORT_LONG_OPTIONS = Object.freeze({
     "human-numeric-sort": "h",
     "numeric-sort": "n",
@@ -1953,317 +1929,312 @@ async function executeCutGeneral(context) {
     const outputDelimiterBytes = outputDelimiter === undefined ? separator : outputDelimiter.length === 0 ? Uint8Array.of(0) : encoder.encode(outputDelimiter);
     const writer = new CutOutput(context, work);
     let exitCode = 0;
-    try {
-        for (const name of parsed.operands.length ? parsed.operands : ["-"]) {
+    for (const name of parsed.operands.length ? parsed.operands : ["-"]) {
+        try {
             try {
-                try {
-                    const onlyDelimited = parsed.flags.has("s");
-                    const fastSingleByteField = mode === "f" && separator.length === 1;
-                    const sepByte = separator[0];
-                    const outDelimLen = outputDelimiterBytes.length;
-                    const processFastFieldRangeSlow = async (buf, lineStart, lineEnd) => {
-                        context.signal.throwIfAborted();
-                        let boundary = buf.indexOf(sepByte, lineStart);
-                        if (boundary >= lineEnd)
-                            boundary = -1;
-                        const c0 = work.charge(boundary < 0 ? lineEnd - lineStart : boundary - lineStart + 1);
-                        if (c0)
-                            await c0;
+                const onlyDelimited = parsed.flags.has("s");
+                const fastSingleByteField = mode === "f" && separator.length === 1;
+                const sepByte = separator[0];
+                const outDelimLen = outputDelimiterBytes.length;
+                const processFastFieldRangeSlow = async (buf, lineStart, lineEnd) => {
+                    context.signal.throwIfAborted();
+                    let boundary = buf.indexOf(sepByte, lineStart);
+                    if (boundary >= lineEnd)
+                        boundary = -1;
+                    const c0 = work.charge(boundary < 0 ? lineEnd - lineStart : boundary - lineStart + 1);
+                    if (c0)
+                        await c0;
+                    if (boundary < 0) {
+                        if (onlyDelimited)
+                            return;
+                        const w = writer.writeRange(buf, lineStart, lineEnd);
+                        if (w)
+                            await w;
+                    }
+                    else {
+                        let cursor = 0;
+                        let field = 1;
+                        let start = lineStart;
+                        let emitted = false;
+                        while (true) {
+                            const cp = work.charge();
+                            if (cp)
+                                await cp;
+                            while (cursor < ranges.length && field > ranges[cursor].end)
+                                cursor++;
+                            const included = cursor < ranges.length && field >= ranges[cursor].start;
+                            if (included !== complement) {
+                                if (emitted) {
+                                    const w1 = writer.write(outputDelimiterBytes);
+                                    if (w1)
+                                        await w1;
+                                }
+                                const w2 = writer.writeRange(buf, start, boundary < 0 ? lineEnd : boundary);
+                                if (w2)
+                                    await w2;
+                                emitted = true;
+                            }
+                            field++;
+                            if (boundary < 0 || (!complement && cursor >= ranges.length))
+                                break;
+                            start = boundary + 1;
+                            boundary = start <= lineEnd ? buf.indexOf(sepByte, start) : -1;
+                            if (boundary >= lineEnd)
+                                boundary = -1;
+                            const cn = work.charge(boundary < 0 ? lineEnd - start : boundary - start + 1);
+                            if (cn)
+                                await cn;
+                        }
+                    }
+                    const wd = writer.writeByte(recordDelimiter);
+                    if (wd)
+                        await wd;
+                };
+                const processFastFieldRange = (buf, lineStart, lineEnd) => {
+                    const lineLen = lineEnd - lineStart;
+                    if (writer.remaining <= lineLen * (outDelimLen > 1 ? outDelimLen : 1) + 1) {
+                        return processFastFieldRangeSlow(buf, lineStart, lineEnd);
+                    }
+                    context.signal.throwIfAborted();
+                    let boundary = buf.indexOf(sepByte, lineStart);
+                    if (boundary >= lineEnd)
+                        boundary = -1;
+                    let totalCharge = boundary < 0 ? lineLen : boundary - lineStart + 1;
+                    if (boundary < 0) {
+                        if (onlyDelimited)
+                            return work.charge(totalCharge);
+                        totalCharge += writer.writeRangeUncharged(buf, lineStart, lineEnd);
+                    }
+                    else {
+                        let cursor = 0;
+                        let field = 1;
+                        let start = lineStart;
+                        let emitted = false;
+                        while (true) {
+                            totalCharge += 1;
+                            while (cursor < ranges.length && field > ranges[cursor].end)
+                                cursor++;
+                            const included = cursor < ranges.length && field >= ranges[cursor].start;
+                            if (included !== complement) {
+                                if (emitted) {
+                                    totalCharge += writer.writeRangeUncharged(outputDelimiterBytes, 0, outDelimLen);
+                                }
+                                totalCharge += writer.writeRangeUncharged(buf, start, boundary < 0 ? lineEnd : boundary);
+                                emitted = true;
+                            }
+                            field++;
+                            if (boundary < 0 || (!complement && cursor >= ranges.length))
+                                break;
+                            start = boundary + 1;
+                            boundary = start <= lineEnd ? buf.indexOf(sepByte, start) : -1;
+                            if (boundary >= lineEnd)
+                                boundary = -1;
+                            totalCharge += boundary < 0 ? lineEnd - start : boundary - start + 1;
+                        }
+                    }
+                    writer.writeByteUncharged(recordDelimiter);
+                    totalCharge += 1;
+                    return work.charge(totalCharge);
+                };
+                const sharedUtf8Decoder = new TextDecoder("utf-8", { ignoreBOM: true });
+                const canFastSliceCut = (byteSelection || mode === "c") && !complement && ranges.length <= 16;
+                const processFastSliceRange = (buf, lineStart, lineEnd) => {
+                    const lineLen = lineEnd - lineStart;
+                    if (writer.remaining <= lineLen * (outDelimLen > 1 ? outDelimLen : 1) + 1) {
+                        return null;
+                    }
+                    if (!byteSelection) {
+                        for (let i = lineStart; i < lineEnd; i++) {
+                            if (buf[i] >= 0x80)
+                                return null;
+                        }
+                    }
+                    context.signal.throwIfAborted();
+                    let totalCharge = lineLen + 1;
+                    let emitted = false;
+                    for (let rIdx = 0; rIdx < ranges.length; rIdx++) {
+                        const r = ranges[rIdx];
+                        const s = lineStart + r.start - 1;
+                        if (s >= lineEnd)
+                            break;
+                        const e = Math.min(lineEnd, lineStart + r.end);
+                        if (e > s) {
+                            if (emitted && outputDelimiter !== undefined) {
+                                totalCharge += writer.writeRangeUncharged(outputDelimiterBytes, 0, outDelimLen);
+                            }
+                            totalCharge += writer.writeRangeUncharged(buf, s, e);
+                            emitted = true;
+                        }
+                    }
+                    writer.writeByteUncharged(recordDelimiter);
+                    return work.charge(totalCharge);
+                };
+                const processLineBytes = async (lineBytes) => {
+                    context.signal.throwIfAborted();
+                    let cursor = 0;
+                    const selected = (position) => {
+                        while (cursor < ranges.length && position > ranges[cursor].end)
+                            cursor++;
+                        const included = cursor < ranges.length && position >= ranges[cursor].start;
+                        return included !== complement ? cursor : -1;
+                    };
+                    if (mode === "f") {
+                        const record = encodeBytes(lineBytes.buffer, lineBytes.byteOffset, lineBytes.byteLength);
+                        const b0 = cutFieldBoundary(record, separator, 0, work);
+                        let boundary = typeof b0 === "number" ? b0 : await b0;
                         if (boundary < 0) {
                             if (onlyDelimited)
                                 return;
-                            const w = writer.writeRange(buf, lineStart, lineEnd);
+                            const w = writer.write(lineBytes);
                             if (w)
                                 await w;
                         }
                         else {
-                            let cursor = 0;
                             let field = 1;
-                            let start = lineStart;
+                            let start = 0;
                             let emitted = false;
                             while (true) {
-                                const cp = work.charge();
-                                if (cp)
-                                    await cp;
-                                while (cursor < ranges.length && field > ranges[cursor].end)
-                                    cursor++;
-                                const included = cursor < ranges.length && field >= ranges[cursor].start;
-                                if (included !== complement) {
+                                const checkpoint = work.charge();
+                                if (checkpoint)
+                                    await checkpoint;
+                                if (selected(field++) >= 0) {
                                     if (emitted) {
                                         const w1 = writer.write(outputDelimiterBytes);
                                         if (w1)
                                             await w1;
                                     }
-                                    const w2 = writer.writeRange(buf, start, boundary < 0 ? lineEnd : boundary);
+                                    const w2 = writer.write(record.subarray(start, boundary < 0 ? record.length : boundary));
                                     if (w2)
                                         await w2;
                                     emitted = true;
                                 }
-                                field++;
-                                if (boundary < 0 || (!complement && cursor >= ranges.length))
-                                    break;
-                                start = boundary + 1;
-                                boundary = start <= lineEnd ? buf.indexOf(sepByte, start) : -1;
-                                if (boundary >= lineEnd)
-                                    boundary = -1;
-                                const cn = work.charge(boundary < 0 ? lineEnd - start : boundary - start + 1);
-                                if (cn)
-                                    await cn;
-                            }
-                        }
-                        const wd = writer.writeByte(recordDelimiter);
-                        if (wd)
-                            await wd;
-                    };
-                    const processFastFieldRange = (buf, lineStart, lineEnd) => {
-                        const lineLen = lineEnd - lineStart;
-                        if (writer.remaining <= lineLen * (outDelimLen > 1 ? outDelimLen : 1) + 1) {
-                            return processFastFieldRangeSlow(buf, lineStart, lineEnd);
-                        }
-                        context.signal.throwIfAborted();
-                        let boundary = buf.indexOf(sepByte, lineStart);
-                        if (boundary >= lineEnd)
-                            boundary = -1;
-                        let totalCharge = boundary < 0 ? lineLen : boundary - lineStart + 1;
-                        if (boundary < 0) {
-                            if (onlyDelimited)
-                                return work.charge(totalCharge);
-                            totalCharge += writer.writeRangeUncharged(buf, lineStart, lineEnd);
-                        }
-                        else {
-                            let cursor = 0;
-                            let field = 1;
-                            let start = lineStart;
-                            let emitted = false;
-                            while (true) {
-                                totalCharge += 1;
-                                while (cursor < ranges.length && field > ranges[cursor].end)
-                                    cursor++;
-                                const included = cursor < ranges.length && field >= ranges[cursor].start;
-                                if (included !== complement) {
-                                    if (emitted) {
-                                        totalCharge += writer.writeRangeUncharged(outputDelimiterBytes, 0, outDelimLen);
-                                    }
-                                    totalCharge += writer.writeRangeUncharged(buf, start, boundary < 0 ? lineEnd : boundary);
-                                    emitted = true;
-                                }
-                                field++;
                                 if (boundary < 0 || (!complement && cursor >= ranges.length))
                                     break;
-                                start = boundary + 1;
-                                boundary = start <= lineEnd ? buf.indexOf(sepByte, start) : -1;
-                                if (boundary >= lineEnd)
-                                    boundary = -1;
-                                totalCharge += boundary < 0 ? lineEnd - start : boundary - start + 1;
+                                start = boundary + separator.length;
+                                const bn = cutFieldBoundary(record, separator, start, work);
+                                boundary = typeof bn === "number" ? bn : await bn;
                             }
                         }
-                        writer.writeByteUncharged(recordDelimiter);
-                        totalCharge += 1;
-                        return work.charge(totalCharge);
-                    };
-                    const sharedUtf8Decoder = new TextDecoder("utf-8", { ignoreBOM: true });
-                    const canFastSliceCut = (byteSelection || mode === "c") && !complement && ranges.length <= 16;
-                    const processFastSliceRange = (buf, lineStart, lineEnd) => {
-                        const lineLen = lineEnd - lineStart;
-                        if (writer.remaining <= lineLen * (outDelimLen > 1 ? outDelimLen : 1) + 1) {
-                            return null;
-                        }
-                        if (!byteSelection) {
-                            for (let i = lineStart; i < lineEnd; i++) {
-                                if (buf[i] >= 0x80)
-                                    return null;
-                            }
-                        }
-                        context.signal.throwIfAborted();
-                        let totalCharge = lineLen + 1;
+                    }
+                    else if (byteSelection) {
                         let emitted = false;
-                        for (let rIdx = 0; rIdx < ranges.length; rIdx++) {
-                            const r = ranges[rIdx];
-                            const s = lineStart + r.start - 1;
-                            if (s >= lineEnd)
-                                break;
-                            const e = Math.min(lineEnd, lineStart + r.end);
-                            if (e > s) {
-                                if (emitted && outputDelimiter !== undefined) {
-                                    totalCharge += writer.writeRangeUncharged(outputDelimiterBytes, 0, outDelimLen);
+                        let previousRange = -1;
+                        for (let offset = 0; offset < lineBytes.length; offset += 4096) {
+                            const end = Math.min(lineBytes.length, offset + 4096);
+                            const checkpoint = work.charge(end - offset);
+                            if (checkpoint)
+                                await checkpoint;
+                            let start = -1;
+                            for (let index = offset; index < end; index++) {
+                                const range = selected(index + 1);
+                                if (range !== previousRange && start >= 0) {
+                                    await writer.write(lineBytes.subarray(start, index));
+                                    start = -1;
                                 }
-                                totalCharge += writer.writeRangeUncharged(buf, s, e);
-                                emitted = true;
-                            }
-                        }
-                        writer.writeByteUncharged(recordDelimiter);
-                        return work.charge(totalCharge);
-                    };
-                    const processLineBytes = async (lineBytes) => {
-                        context.signal.throwIfAborted();
-                        let cursor = 0;
-                        const selected = (position) => {
-                            while (cursor < ranges.length && position > ranges[cursor].end)
-                                cursor++;
-                            const included = cursor < ranges.length && position >= ranges[cursor].start;
-                            return included !== complement ? cursor : -1;
-                        };
-                        if (mode === "f") {
-                            const record = encodeBytes(lineBytes.buffer, lineBytes.byteOffset, lineBytes.byteLength);
-                            const b0 = cutFieldBoundary(record, separator, 0, work);
-                            let boundary = typeof b0 === "number" ? b0 : await b0;
-                            if (boundary < 0) {
-                                if (onlyDelimited)
-                                    return;
-                                const w = writer.write(lineBytes);
-                                if (w)
-                                    await w;
-                            }
-                            else {
-                                let field = 1;
-                                let start = 0;
-                                let emitted = false;
-                                while (true) {
-                                    const checkpoint = work.charge();
-                                    if (checkpoint)
-                                        await checkpoint;
-                                    if (selected(field++) >= 0) {
-                                        if (emitted) {
-                                            const w1 = writer.write(outputDelimiterBytes);
-                                            if (w1)
-                                                await w1;
-                                        }
-                                        const w2 = writer.write(record.subarray(start, boundary < 0 ? record.length : boundary));
-                                        if (w2)
-                                            await w2;
-                                        emitted = true;
-                                    }
-                                    if (boundary < 0 || (!complement && cursor >= ranges.length))
-                                        break;
-                                    start = boundary + separator.length;
-                                    const bn = cutFieldBoundary(record, separator, start, work);
-                                    boundary = typeof bn === "number" ? bn : await bn;
-                                }
-                            }
-                        }
-                        else if (byteSelection) {
-                            let emitted = false;
-                            let previousRange = -1;
-                            for (let offset = 0; offset < lineBytes.length; offset += 4096) {
-                                const end = Math.min(lineBytes.length, offset + 4096);
-                                const checkpoint = work.charge(end - offset);
-                                if (checkpoint)
-                                    await checkpoint;
-                                let start = -1;
-                                for (let index = offset; index < end; index++) {
-                                    const range = selected(index + 1);
-                                    if (range !== previousRange && start >= 0) {
-                                        await writer.write(lineBytes.subarray(start, index));
-                                        start = -1;
-                                    }
-                                    if (range >= 0 && start < 0) {
-                                        if (range !== previousRange && emitted && outputDelimiter !== undefined)
-                                            await writer.write(outputDelimiterBytes);
-                                        start = index;
-                                        emitted = true;
-                                    }
-                                    previousRange = range;
+                                if (range >= 0 && start < 0) {
+                                    if (range !== previousRange && emitted && outputDelimiter !== undefined)
+                                        await writer.write(outputDelimiterBytes);
+                                    start = index;
+                                    emitted = true;
                                 }
-                                if (start >= 0)
-                                    await writer.write(lineBytes.subarray(start, end));
+                                previousRange = range;
                             }
+                            if (start >= 0)
+                                await writer.write(lineBytes.subarray(start, end));
                         }
-                        else {
-                            const decoder = sharedUtf8Decoder;
-                            let index = 0;
-                            let emitted = false;
-                            let previousRange = -1;
-                            for (let offset = 0; offset < lineBytes.length; offset += 4096) {
-                                const end = Math.min(lineBytes.length, offset + 4096);
-                                const checkpoint = work.charge(end - offset);
+                    }
+                    else {
+                        const decoder = sharedUtf8Decoder;
+                        let index = 0;
+                        let emitted = false;
+                        let previousRange = -1;
+                        for (let offset = 0; offset < lineBytes.length; offset += 4096) {
+                            const end = Math.min(lineBytes.length, offset + 4096);
+                            const checkpoint = work.charge(end - offset);
+                            if (checkpoint)
+                                await checkpoint;
+                            const text = decoder.decode(lineBytes.subarray(offset, end), { stream: end < lineBytes.length });
+                            let start = -1;
+                            let position = 0;
+                            for (const character of text) {
+                                const checkpoint = work.charge();
                                 if (checkpoint)
                                     await checkpoint;
-                                const text = decoder.decode(lineBytes.subarray(offset, end), { stream: end < lineBytes.length });
-                                let start = -1;
-                                let position = 0;
-                                for (const character of text) {
-                                    const checkpoint = work.charge();
-                                    if (checkpoint)
-                                        await checkpoint;
-                                    const range = selected(++index);
-                                    if (range !== previousRange && start >= 0) {
-                                        await writer.text(text.slice(start, position));
-                                        start = -1;
-                                    }
-                                    if (range >= 0 && start < 0) {
-                                        if (range !== previousRange && emitted && outputDelimiter !== undefined)
-                                            await writer.write(outputDelimiterBytes);
-                                        start = position;
-                                        emitted = true;
-                                    }
-                                    position += character.length;
-                                    previousRange = range;
-                                }
-                                if (start >= 0)
-                                    await writer.text(text.slice(start));
-                            }
-                        }
-                        const wd = writer.writeByte(recordDelimiter);
-                        if (wd)
-                            await wd;
-                    };
-                    const pending = new RecordBuffer(bufferLimit);
-                    try {
-                        for await (const chunk of input(context, name)) {
-                            let start = 0;
-                            while (start < chunk.length) {
-                                const offset = chunk.indexOf(recordDelimiter, start);
-                                if (offset < 0)
-                                    break;
-                                if (fastSingleByteField && pending.size === 0 && offset - start <= 4096) {
-                                    const p = processFastFieldRange(chunk, start, offset);
-                                    if (p)
-                                        await p;
+                                const range = selected(++index);
+                                if (range !== previousRange && start >= 0) {
+                                    await writer.text(text.slice(start, position));
+                                    start = -1;
                                 }
-                                else if (canFastSliceCut && pending.size === 0 && offset - start <= 4096) {
-                                    const p = processFastSliceRange(chunk, start, offset);
-                                    if (p === null) {
-                                        await processLineBytes(chunk.subarray(start, offset));
-                                    }
-                                    else if (p) {
-                                        await p;
-                                    }
-                                }
-                                else {
-                                    await processLineBytes(pending.finish(undefined, chunk, start, offset));
+                                if (range >= 0 && start < 0) {
+                                    if (range !== previousRange && emitted && outputDelimiter !== undefined)
+                                        await writer.write(outputDelimiterBytes);
+                                    start = position;
+                                    emitted = true;
                                 }
-                                start = offset + 1;
+                                position += character.length;
+                                previousRange = range;
                             }
-                            pending.append(chunk, start);
+                            if (start >= 0)
+                                await writer.text(text.slice(start));
                         }
-                        if (pending.size) {
-                            const finalBytes = pending.finish();
-                            if (fastSingleByteField && finalBytes.length <= 4096) {
-                                const p = processFastFieldRange(finalBytes, 0, finalBytes.length);
+                    }
+                    const wd = writer.writeByte(recordDelimiter);
+                    if (wd)
+                        await wd;
+                };
+                const pending = new RecordBuffer(bufferLimit);
+                try {
+                    for await (const chunk of input(context, name)) {
+                        let start = 0;
+                        while (start < chunk.length) {
+                            const offset = chunk.indexOf(recordDelimiter, start);
+                            if (offset < 0)
+                                break;
+                            if (fastSingleByteField && pending.size === 0 && offset - start <= 4096) {
+                                const p = processFastFieldRange(chunk, start, offset);
                                 if (p)
                                     await p;
                             }
+                            else if (canFastSliceCut && pending.size === 0 && offset - start <= 4096) {
+                                const p = processFastSliceRange(chunk, start, offset);
+                                if (p === null) {
+                                    await processLineBytes(chunk.subarray(start, offset));
+                                }
+                                else if (p) {
+                                    await p;
+                                }
+                            }
                             else {
-                                await processLineBytes(finalBytes);
+                                await processLineBytes(pending.finish(undefined, chunk, start, offset));
                             }
+                            start = offset + 1;
                         }
+                        pending.append(chunk, start);
                     }
-                    finally {
-                        pending.clear();
+                    if (pending.size) {
+                        const finalBytes = pending.finish();
+                        if (fastSingleByteField && finalBytes.length <= 4096) {
+                            const p = processFastFieldRange(finalBytes, 0, finalBytes.length);
+                            if (p)
+                                await p;
+                        }
+                        else {
+                            await processLineBytes(finalBytes);
+                        }
                     }
                 }
                 finally {
-                    await writer.flush();
+                    pending.clear();
                 }
             }
-            catch (error) {
-                await diagnostic(context, error);
-                exitCode = 1;
+            finally {
+                await writer.flush();
             }
         }
-    }
-    finally {
-        writer.release();
+        catch (error) {
+            await diagnostic(context, error);
+            exitCode = 1;
+        }
     }
     return { exitCode };
 }
@@ -2523,29 +2494,6 @@ export function textCommands() {
                         catch (error) {
                             return diagnostic(context, error).then(RETURN_EXIT_TWO);
                         }
-                        const cached = lastSort;
-                        if (cached !== undefined &&
-                            firstChunkLen >= 256 &&
-                            firstChunkLen === cached.input.byteLength &&
-                            direction === cached.direction &&
-                            cached.maxLineLength <= bufferLimit &&
-                            equalBytes(cached.input, rawFirst)) {
-                            let res2Fast;
-                            try {
-                                res2Fast = srcIter.tryNextSync();
-                            }
-                            catch (error) {
-                                return diagnostic(context, error).then(RETURN_EXIT_TWO);
-                            }
-                            if (res2Fast !== undefined && res2Fast.done) {
-                                context.signal.throwIfAborted();
-                                const p = outputRange(context, cached.output, cached.output.length);
-                                if (isSyncResolved(p))
-                                    return RESOLVED_EXIT_ZERO;
-                                return p.then(RETURN_EXIT_ZERO);
-                            }
-                            return executeSortFastContinueAsync(context, direction, srcIter, cached.input, res2Fast);
-                        }
                         let firstChunk;
                         let usedSortInScratch = false;
                         try {
@@ -2573,12 +2521,9 @@ export function textCommands() {
                                 let start = 0;
                                 let count = 0;
                                 let validLines = true;
-                                let maxSortLine = 0;
                                 while (start < firstChunkLen) {
                                     const offset = firstChunk.indexOf(10, start);
                                     const lLen = offset - start;
-                                    if (lLen > maxSortLine)
-                                        maxSortLine = lLen;
                                     if (offset < 0 || offset >= firstChunkLen || count >= 4096 || lLen > bufferLimit) {
                                         validLines = false;
                                         break;
@@ -2620,7 +2565,7 @@ export function textCommands() {
                                         src = dst;
                                         dst = tmp;
                                     }
-                                    const outBuf = sharedSortOutScratch;
+                                    const outBuf = new Uint8Array(65536);
                                     let used = 0;
                                     for (let i = 0; i < count; i++) {
                                         const idx = src[i];
@@ -2630,14 +2575,6 @@ export function textCommands() {
                                             outBuf[used++] = firstChunk[p];
                                         outBuf[used++] = 10;
                                     }
-                                    if (firstChunkLen >= 256 && used <= 32768) {
-                                        lastSort = {
-                                            input: encodeBytes(firstChunk.subarray(0, firstChunkLen)),
-                                            output: outBuf.slice(0, used),
-                                            direction,
-                                            maxLineLength: maxSortLine,
-                                        };
-                                    }
                                     const p = outputRange(context, outBuf, used);
                                     if (isSyncResolved(p))
                                         return RESOLVED_EXIT_ZERO;
@@ -2653,8 +2590,10 @@ export function textCommands() {
                             return diagnostic(context, error).then(RETURN_EXIT_TWO);
                         }
                         finally {
-                            if (usedSortInScratch)
+                            if (usedSortInScratch) {
+                                sharedSortInScratch.fill(0);
                                 sharedSortInUse = false;
+                            }
                         }
                     }
                 }
@@ -2715,7 +2654,7 @@ export function textCommands() {
                                 return diagnostic(context, error).then(RETURN_EXIT_ONE);
                             }
                             if (res2 !== undefined && res2.done && chunk.length <= 65536) {
-                                const outBuf = sharedUniqOutBuffer;
+                                const outBuf = new Uint8Array(128 * 1024);
                                 let outUsed = 0;
                                 let prevStart = -1;
                                 let prevEnd = -1;
@@ -2919,7 +2858,7 @@ export function textCommands() {
                 }
                 if (canFast && (targetField >= 1 || (fieldMask !== 0 && typeof context.stdin.tryReadAllSync === "function"))) {
                     const req = assertInputRequirements(context, operand !== undefined ? [operand] : EMPTY_OPERANDS);
-                    if (!req && operand === undefined && !sharedCutOutInUse) {
+                    if (!req && operand === undefined) {
                         const srcIter = input(context, "-")[Symbol.asyncIterator]();
                         if (typeof srcIter.tryNextSync === "function") {
                             let res1;
@@ -2940,28 +2879,10 @@ export function textCommands() {
                                 catch (error) {
                                     return diagnostic(context, error).then(RETURN_EXIT_ONE);
                                 }
-                                if (res2 !== undefined && res2.done && chunk.length < sharedCutOutBuffer.length) {
-                                    if (fieldMask === 0 &&
-                                        lastCutOutUsed >= 0 &&
-                                        chunk.length >= 256 &&
-                                        lastCutInBuf !== undefined &&
-                                        chunk.length === lastCutInBuf.byteLength &&
-                                        sepByte === lastCutSep &&
-                                        targetField === lastCutField &&
-                                        lastCutMaxLineLen <= bufferLimit &&
-                                        equalBytes(lastCutInBuf, chunk)) {
-                                        context.signal.throwIfAborted();
-                                        if (lastCutOutUsed === 0)
-                                            return RESOLVED_EXIT_ZERO;
-                                        const p = outputRange(context, cachedCutOutBuffer, lastCutOutUsed);
-                                        if (isSyncResolved(p))
-                                            return RESOLVED_EXIT_ZERO;
-                                        return p.then(RETURN_EXIT_ZERO);
-                                    }
-                                    const outBuf = sharedCutOutBuffer;
+                                if (res2 !== undefined && res2.done && chunk.length < 65536) {
+                                    const outBuf = new Uint8Array(65536);
                                     let outUsed = 0;
                                     let start = 0;
-                                    let maxCutLine = 0;
                                     while (start < chunk.length) {
                                         let offset = chunk.indexOf(10, start);
                                         const hasNewline = offset >= 0;
@@ -2975,8 +2896,6 @@ export function textCommands() {
                                         let boundary = chunk.indexOf(sepByte, start);
                                         if (boundary >= offset)
                                             boundary = -1;
-                                        if (offset - start > maxCutLine)
-                                            maxCutLine = offset - start;
                                         if (fieldMask !== 0 && boundary >= 0) {
                                             let f = 1;
                                             let curStart = start;
@@ -3027,14 +2946,6 @@ export function textCommands() {
                                         }
                                         start = offset + 1;
                                     }
-                                    if (fieldMask === 0 && chunk.length >= 256 && outUsed <= 32768) {
-                                        lastCutInBuf = encodeBytes(chunk);
-                                        lastCutSep = sepByte;
-                                        lastCutField = targetField;
-                                        lastCutMaxLineLen = maxCutLine;
-                                        lastCutOutUsed = outUsed;
-                                        cachedCutOutBuffer.set(outBuf.subarray(0, outUsed));
-                                    }
                                     if (outUsed === 0)
                                         return RESOLVED_EXIT_ZERO;
                                     const p = outputRange(context, outBuf, outUsed);
@@ -3144,10 +3055,7 @@ async function executeSortFastContinueAsync(context, direction, srcIter, initial
 async function executeCutFastAsync(context, operand, sepByte, targetField, req, existingIter, initialFirstChunk, initialSecondRes) {
     if (req)
         await req;
-    const ownsShared = !sharedCutOutInUse;
-    if (ownsShared)
-        sharedCutOutInUse = true;
-    const outBuf = ownsShared ? sharedCutOutBuffer : new Uint8Array(65536);
+    const outBuf = new Uint8Array(65536);
     let outUsed = 0;
     const isPipeStage = Boolean(context.stdout.isPipeStage);
     const syncSink = !isPipeStage
@@ -3299,9 +3207,5 @@ async function executeCutFastAsync(context, operand, sepByte, targetField, req,
         await diagnostic(context, error);
         return { exitCode: 1 };
     }
-    finally {
-        if (ownsShared)
-            sharedCutOutInUse = false;
-    }
 }
 //# sourceMappingURL=text.js.map