@poe-platform/safe-bash 0.1.800 → 0.1.802

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",
@@ -1728,138 +1704,7 @@ async function executeSortGeneral(context, preReadChunks) {
     }
     if (checking)
         return { exitCode };
-    let ordered;
-    if (!parsed.flags.has("m") &&
-        !parsed.flags.has("u") &&
-        records.length >= 2 &&
-        records.length <= 65536 &&
-        (canMultiKeyFast || isSingleLexKeyFast)) {
-        const count = records.length;
-        const keySpecs = keys.map(k => {
-            const f = k.flags.size ? k.flags : parsed.flags;
-            const numeric = f.has("n") || f.has("h");
-            const human = f.has("h");
-            const blanks = f.has("b");
-            const revScale = f.has("r") ? -1 : 1;
-            if (numeric) {
-                const fastNums = new Float64Array(count);
-                const numVals = new Array(count);
-                return { numeric: true, human, blanks, revScale, key: k, fastNums, numVals };
-            }
-            const slices = new Array(count);
-            return { numeric: false, blanks, revScale, key: k, slices };
-        });
-        for (let i = 0; i < count; i++) {
-            const rec = records[i];
-            for (let ki = 0; ki < keySpecs.length; ki++) {
-                const ks = keySpecs[ki];
-                const sliceOrPromise = keyBytesSync(rec, ks.key, separator, ks.blanks, work);
-                const slice = sliceOrPromise instanceof Promise ? await sliceOrPromise : sliceOrPromise;
-                if (ks.numeric) {
-                    const parsedOrPromise = parseNumeric(slice, work, ks.human);
-                    const nv = parsedOrPromise instanceof Promise ? await parsedOrPromise : parsedOrPromise;
-                    ks.numVals[i] = nv;
-                    if (!ks.human && nv.fraction.length === 0 && nv.whole.length <= 15) {
-                        const mag = nv.whole.length === 0 ? 0 : Number(nv.whole);
-                        ks.fastNums[i] = nv.negative ? (mag === 0 ? 0 : -mag) : mag;
-                    }
-                    else {
-                        ks.fastNums[i] = Number.NaN;
-                    }
-                }
-                else {
-                    ks.slices[i] = slice;
-                }
-            }
-        }
-        let srcIdx = new Int32Array(count);
-        let dstIdx = new Int32Array(count);
-        for (let i = 0; i < count; i++)
-            srcIdx[i] = i;
-        for (let width = 1; width < count; width *= 2) {
-            for (let begin = 0; begin < count; begin += width * 2) {
-                const middle = Math.min(begin + width, count);
-                const end = Math.min(begin + width * 2, count);
-                let left = begin;
-                let right = middle;
-                for (let index = begin; index < end; index++) {
-                    const cp = work.charge(2);
-                    if (cp)
-                        await cp;
-                    if (left < middle) {
-                        if (right === end) {
-                            dstIdx[index] = srcIdx[left++];
-                            continue;
-                        }
-                        const a = srcIdx[left];
-                        const b = srcIdx[right];
-                        let cmp = 0;
-                        for (let ki = 0; ki < keySpecs.length; ki++) {
-                            const ks = keySpecs[ki];
-                            if (ks.numeric) {
-                                const fa = ks.fastNums[a];
-                                const fb = ks.fastNums[b];
-                                if (fa === fa && fb === fb) {
-                                    cmp = fa === fb ? 0 : (fa < fb ? -ks.revScale : ks.revScale);
-                                }
-                                else {
-                                    const r = compareNumericValues(ks.numVals[a], ks.numVals[b], work);
-                                    const resolved = typeof r === "number" ? r : await r;
-                                    cmp = resolved * ks.revScale;
-                                }
-                            }
-                            else {
-                                const sa = ks.slices[a];
-                                const sb = ks.slices[b];
-                                const lenA = sa.length;
-                                const lenB = sb.length;
-                                const minL = lenA < lenB ? lenA : lenB;
-                                let d = 0;
-                                for (let p = 0; p < minL; p++) {
-                                    d = sa[p] - sb[p];
-                                    if (d !== 0)
-                                        break;
-                                }
-                                if (d === 0)
-                                    d = lenA - lenB;
-                                cmp = d * ks.revScale;
-                            }
-                            if (cmp !== 0)
-                                break;
-                        }
-                        if (cmp === 0 && !skipTieFallback) {
-                            const ra = records[a];
-                            const rb = records[b];
-                            const minL = ra.length < rb.length ? ra.length : rb.length;
-                            let d = 0;
-                            for (let p = 0; p < minL; p++) {
-                                d = ra[p] - rb[p];
-                                if (d !== 0)
-                                    break;
-                            }
-                            if (d === 0)
-                                d = ra.length - rb.length;
-                            cmp = d * direction;
-                        }
-                        if (cmp <= 0) {
-                            dstIdx[index] = srcIdx[left++];
-                            continue;
-                        }
-                    }
-                    dstIdx[index] = srcIdx[right++];
-                }
-            }
-            const tmp = srcIdx;
-            srcIdx = dstIdx;
-            dstIdx = tmp;
-        }
-        ordered = new Array(count);
-        for (let i = 0; i < count; i++)
-            ordered[i] = records[srcIdx[i]];
-    }
-    else {
-        ordered = parsed.flags.has("m") ? await mergeSortRuns(runs, compare, work) : await sortRecords(records, compare, work);
-    }
+    const ordered = parsed.flags.has("m") ? await mergeSortRuns(runs, compare, work) : await sortRecords(records, compare, work);
     let estBytes = 0;
     let allCounted = true;
     for (let i = 0; i < ordered.length; i++) {
@@ -1953,317 +1798,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 + (outputDelimiter !== undefined ? Math.max(0, ranges.length - 1) * outDelimLen : 0) + 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;
-                            }
-                        }
-                        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;
+                                start = boundary + separator.length;
+                                const bn = cutFieldBoundary(record, separator, start, work);
+                                boundary = typeof bn === "number" ? bn : await bn;
                             }
                         }
-                        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);
-                                }
-                                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;
+                        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;
                                 }
-                            }
-                        }
-                        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;
-                                }
-                                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;
-                                    }
+                                const range = selected(++index);
+                                if (range !== previousRange && start >= 0) {
+                                    await writer.text(text.slice(start, position));
+                                    start = -1;
                                 }
-                                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 +2363,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 +2390,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 +2434,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 +2444,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 +2459,10 @@ export function textCommands() {
                             return diagnostic(context, error).then(RETURN_EXIT_TWO);
                         }
                         finally {
-                            if (usedSortInScratch)
+                            if (usedSortInScratch) {
+                                sharedSortInScratch.fill(0);
                                 sharedSortInUse = false;
+                            }
                         }
                     }
                 }
@@ -2715,7 +2523,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 +2727,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 +2748,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 +2765,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 +2815,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 +2924,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 +3076,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