@poe-platform/safe-bash 0.1.801 → 0.1.803

package/dist/safe-bash/commands/split/index.browser.js

@@ -0,0 +1,14 @@
+import {
+  createSplitCommand,
+  createSplitCommands,
+  evalSyncSplit,
+  splitCommands
+} from "../../chunks/chunk-7ZBU7KYV.js";
+import "../../chunks/chunk-IWDICZVK.js";
+import "../../chunks/chunk-B7TAL7S5.js";
+export {
+  createSplitCommand,
+  createSplitCommands,
+  evalSyncSplit,
+  splitCommands
+};

package/dist/safe-bash/commands/stat/index.browser.js

@@ -0,0 +1,13 @@
+import {
+  init_platform
+} from "../../chunks/chunk-B7TAL7S5.js";
+
+// packages/safe-bash/src/commands/stat/index.ts
+init_platform();
+import { createStatCommand, createStatCommands, evalSyncStat, statCommands } from "../../../safe-bash-command-stat/index.js";
+export {
+  createStatCommand,
+  createStatCommands,
+  evalSyncStat,
+  statCommands
+};

package/dist/safe-bash/commands/stat/index.d.ts

@@ -0,0 +1,2 @@
+export * from "../../../safe-bash-command-stat/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/safe-bash/commands/stat/index.js

@@ -0,0 +1,2 @@
+export * from "../../../safe-bash-command-stat/index.js";
+//# sourceMappingURL=index.js.map

package/dist/safe-bash/commands/stream-format/index.browser.js

@@ -0,0 +1,11 @@
+import {
+  createStreamFormatCommands,
+  streamFormatCommands
+} from "../../chunks/chunk-R3NAKOED.js";
+import "../../chunks/chunk-E7OYNDGL.js";
+import "../../chunks/chunk-IWDICZVK.js";
+import "../../chunks/chunk-B7TAL7S5.js";
+export {
+  createStreamFormatCommands,
+  streamFormatCommands
+};

package/dist/safe-bash/commands/stream-inspection/index.browser.js

@@ -0,0 +1,11 @@
+import {
+  createStreamInspectionCommands,
+  streamInspectionCommands
+} from "../../chunks/chunk-HBCN24ZA.js";
+import "../../chunks/chunk-E7OYNDGL.js";
+import "../../chunks/chunk-IWDICZVK.js";
+import "../../chunks/chunk-B7TAL7S5.js";
+export {
+  createStreamInspectionCommands,
+  streamInspectionCommands
+};

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

@@ -450,14 +450,14 @@ async function suffix(context, source, count, bytes, omit, delimiter) {
                     const needed = line.bytes.length + (line.terminated ? 1 : 0);
                     if (needed > batch.length) {
                         if (batchUsed > 0) {
-                            await output(context, batch.subarray(0, batchUsed));
+                            await outputRange(context, batch, batchUsed);
                             batchUsed = 0;
                         }
                         await output(context, line.terminated ? concatenate([line.bytes, delimiterByte]) : line.bytes);
                         continue;
                     }
                     if (batchUsed + needed > batch.length) {
-                        await output(context, batch.subarray(0, batchUsed));
+                        await outputRange(context, batch, batchUsed);
                         batchUsed = 0;
                     }
                     batch.set(line.bytes, batchUsed);
@@ -466,7 +466,7 @@ async function suffix(context, source, count, bytes, omit, delimiter) {
                         batch[batchUsed++] = delimiter;
                 }
                 if (batchUsed > 0) {
-                    await output(context, batch.subarray(0, batchUsed));
+                    await outputRange(context, batch, batchUsed);
                 }
             }
             return;
@@ -1100,7 +1100,7 @@ async function executeTrAsync(context, iter, deleting, squeezing, mapping, remov
             if (!deleting && !squeezing) {
                 for (let index = 0; index < chunk.length; index++)
                     buf[index] = mapping[chunk[index]];
-                const p = output(context, useShared ? buf.subarray(0, chunk.length) : buf);
+                const p = useShared ? outputRange(context, buf, chunk.length) : output(context, buf);
                 if (!isSyncResolved(p))
                     await p;
                 continue;
@@ -1117,7 +1117,7 @@ async function executeTrAsync(context, iter, deleting, squeezing, mapping, remov
                 previous = translated;
             }
             if (count) {
-                const p = output(context, buf.subarray(0, count));
+                const p = outputRange(context, buf, count);
                 if (!isSyncResolved(p))
                     await p;
             }

package/dist/safe-bash/commands/table-text/index.browser.js

@@ -0,0 +1,11 @@
+import {
+  createTableTextCommands,
+  tableTextCommands
+} from "../../chunks/chunk-4D4N7IU2.js";
+import "../../chunks/chunk-E7OYNDGL.js";
+import "../../chunks/chunk-IWDICZVK.js";
+import "../../chunks/chunk-B7TAL7S5.js";
+export {
+  createTableTextCommands,
+  tableTextCommands
+};

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

@@ -8,6 +8,20 @@ import { hasYieldCheckpoint, yieldTurn } from "../contracts/yield.js";
 import { RecordBuffer } from "./record-buffer.js";
 import { SortRecordBudget } from "./sort-admission.js";
 import { compareObservedEntries } from "./copy-identity.js";
+function sortCollator(env) {
+    const locale = env.LC_ALL || env.LC_COLLATE || env.LANG || "C";
+    if (["C", "POSIX", "C.UTF-8", "C.utf8"].includes(locale))
+        return undefined;
+    const language = locale.split(".")[0].split("_").join("-");
+    try {
+        if (!Intl.Collator.supportedLocalesOf([language]).length || locale.includes("@"))
+            throw new RangeError();
+        return new Intl.Collator(language, { usage: "sort", sensitivity: "variant", caseFirst: "lower" });
+    }
+    catch {
+        throw new UsageError(`unsupported collation locale '${locale}'`);
+    }
+}
 class SortWork {
     signal;
     #pending = 0;
@@ -1093,7 +1107,7 @@ async function collectSortRecords(source, delimiter, budget, signal, accept) {
         pending.clear();
     }
 }
-async function executeSortGeneral(context, preReadChunks) {
+async function executeSortGeneral(context, preReadChunks, collator = sortCollator(context.env)) {
     let ended = false;
     let hasCheckLong = false;
     for (let i = 0; i < context.args.length; i++) {
@@ -1159,6 +1173,24 @@ async function executeSortGeneral(context, preReadChunks) {
     const simple = !keys.length && !["b", "f", "h", "n", "g", "M", "V", "d", "i"].some(flag => parsed.flags.has(flag));
     const direction = parsed.flags.has("r") ? -1 : 1;
     const work = new SortWork(context.signal);
+    const decoder = collator ? new TextDecoder("utf-8", { fatal: true }) : undefined;
+    const compareText = collator ? async (left, right, work) => {
+        await work.charge(left.length + right.length);
+        let first, second;
+        try {
+            first = decoder.decode(left);
+        }
+        catch { /* Invalid UTF-8 sorts after valid text. */ }
+        try {
+            second = decoder.decode(right);
+        }
+        catch { /* Keep invalid records byte-ordered. */ }
+        if (first === undefined)
+            return second === undefined ? compareSortBytes(left, right, work) : 1;
+        if (second === undefined)
+            return -1;
+        return collator.compare(first, second);
+    } : compareSortBytes;
     const numericKey = keys.length === 1 ? keys[0] : undefined;
     const numericKeyFlags = numericKey?.flags.size ? numericKey.flags : parsed.flags;
     const skipTieFallback = simple || parsed.flags.has("s") || parsed.flags.has("u");
@@ -1166,7 +1198,8 @@ async function executeSortGeneral(context, preReadChunks) {
     const exitCode = 0;
     const delimiter = parsed.flags.has("z") ? 0 : 10;
     const outPath = value(parsed, "o");
-    const canFastIndexSort = !preReadChunks &&
+    const canFastIndexSort = collator === undefined &&
+        !preReadChunks &&
         !checking &&
         !hasYieldCheckpoint(context.signal) &&
         !parsed.flags.has("m") &&
@@ -1395,7 +1428,7 @@ async function executeSortGeneral(context, preReadChunks) {
             else if (flags.has("V"))
                 result = await compareVersions(first, second, work);
             else
-                result = flags.has("n") || flags.has("h") ? await compareNumeric(first, second, flags.has("h")) : await compareSortBytes(first, second, work);
+                result = flags.has("n") || flags.has("h") ? await compareNumeric(first, second, flags.has("h")) : await compareText(first, second, work);
             if (flags.has("r"))
                 result = -result;
             if (result)
@@ -1405,7 +1438,7 @@ async function executeSortGeneral(context, preReadChunks) {
     };
     const keyCompareSimpleAsync = async (left, right, checkpoint) => {
         await checkpoint;
-        return (await compareSortBytes(left, right, work)) * direction;
+        return (await compareText(left, right, work)) * direction;
     };
     const compareUnkeyedNumericAsync = async (left, right, rightPending) => {
         const leftValue = await left;
@@ -1417,7 +1450,7 @@ async function executeSortGeneral(context, preReadChunks) {
         if (simple) {
             if (checkpoint)
                 return keyCompareSimpleAsync(left, right, checkpoint);
-            const cmp = compareSortBytes(left, right, work);
+            const cmp = compareText(left, right, work);
             return typeof cmp === "number" ? cmp * direction : resolveScaledAfterPromise(cmp, direction);
         }
         if (isUnkeyedNumericFast && checkpoint === undefined) {
@@ -1459,7 +1492,7 @@ async function executeSortGeneral(context, preReadChunks) {
                 await checkpoint;
             const first = await (firstPending ?? getKeyedLexSlice(left));
             const second = await (secondPending ?? getKeyedLexSlice(right));
-            return (await compareSortBytes(first, second, work)) * lexRev;
+            return (await compareText(first, second, work)) * lexRev;
         };
         keyCompare = (left, right) => {
             const checkpoint = work.charge();
@@ -1470,7 +1503,7 @@ async function executeSortGeneral(context, preReadChunks) {
                 if (!(first instanceof Promise)) {
                     second = getKeyedLexSlice(right);
                     if (!(second instanceof Promise)) {
-                        const cmp = compareSortBytes(first, second, work);
+                        const cmp = compareText(first, second, work);
                         if (typeof cmp === "number")
                             return cmp * lexRev;
                         return resolveScaledAfterPromise(cmp, lexRev);
@@ -1643,7 +1676,7 @@ async function executeSortGeneral(context, preReadChunks) {
                     const rs = ev.evalLexSync(right);
                     if (rs === undefined)
                         return keyCompareGeneralAsync(left, right, undefined);
-                    const cmp = compareSortBytes(ls, rs, work);
+                    const cmp = compareText(ls, rs, work);
                     if (typeof cmp !== "number")
                         return keyCompareGeneralAsync(left, right, undefined);
                     if (cmp !== 0)
@@ -1657,14 +1690,14 @@ async function executeSortGeneral(context, preReadChunks) {
         const resolved = await resultPromise;
         if (resolved !== 0 || skipTieFallback)
             return resolved;
-        return (await compareSortBytes(left, right, work)) * direction;
+        return (await compareText(left, right, work)) * direction;
     };
     const compare = (left, right) => {
         const result = keyCompare(left, right);
         if (typeof result === "number") {
             if (result !== 0 || skipTieFallback)
                 return result;
-            const fallback = compareSortBytes(left, right, work);
+            const fallback = compareText(left, right, work);
             return typeof fallback === "number" ? fallback * direction : resolveScaledAfterPromise(fallback, direction);
         }
         return compareSlowAsync(result, left, right);
@@ -1704,138 +1737,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++) {
@@ -2040,7 +1942,7 @@ async function executeCutGeneral(context) {
                 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) {
+                    if (writer.remaining <= lineLen + (outputDelimiter !== undefined ? Math.max(0, ranges.length - 1) * outDelimLen : 0) + 1) {
                         return null;
                     }
                     if (!byteSelection) {
@@ -2465,6 +2367,9 @@ async function executeUniqGeneral(context, preReadSource) {
 export function textCommands() {
     return [
         define("sort", context => {
+            const collator = sortCollator(context.env);
+            if (collator)
+                return executeSortGeneral(context, undefined, collator);
             if ((context.args.length === 0 || (context.args.length === 1 && context.args[0] === "-r")) &&
                 !hasYieldCheckpoint(context.signal) &&
                 SortRecordBudget.prototype.admit === defaultSortAdmit &&

package/dist/safe-bash/commands/time-env/index.browser.js

@@ -0,0 +1,15 @@
+import {
+  createTimeEnvCommands,
+  evalSyncDate,
+  evalSyncPrintenv,
+  timeEnvCommands
+} from "../../chunks/chunk-ZVD5IS4V.js";
+import "../../chunks/chunk-E7OYNDGL.js";
+import "../../chunks/chunk-IWDICZVK.js";
+import "../../chunks/chunk-B7TAL7S5.js";
+export {
+  createTimeEnvCommands,
+  evalSyncDate,
+  evalSyncPrintenv,
+  timeEnvCommands
+};

package/dist/safe-bash/commands/tree/index.browser.js

@@ -0,0 +1,14 @@
+import {
+  createTreeCommand,
+  createTreeCommands,
+  evalSyncTree,
+  treeCommands
+} from "../../chunks/chunk-55YJASTN.js";
+import "../../chunks/chunk-IWDICZVK.js";
+import "../../chunks/chunk-B7TAL7S5.js";
+export {
+  createTreeCommand,
+  createTreeCommands,
+  evalSyncTree,
+  treeCommands
+};