@poe-platform/safe-bash 0.1.66 → 0.1.67

package/dist/safe-bash/browser.js

@@ -4586,6 +4586,68 @@ function streamCommands() {
 
 // packages/safe-bash/src/commands/text.ts
 init_platform();
+var SortWork = class {
+  constructor(signal) {
+    this.signal = signal;
+  }
+  signal;
+  #pending = 0;
+  charge(units = 1) {
+    this.signal.throwIfAborted();
+    this.#pending += units;
+    if (this.#pending >= 4096) return this.#checkpoint();
+  }
+  async #checkpoint() {
+    while (this.#pending >= 4096) {
+      this.#pending -= 4096;
+      await yieldTurn(this.signal);
+      this.signal.throwIfAborted();
+    }
+  }
+};
+async function sortRecords(records, compare, work) {
+  if (records.length < 2) return records;
+  let source = records;
+  let target = new Array(records.length);
+  for (let width = 1; width < records.length; width *= 2) {
+    for (let begin = 0; begin < records.length; begin += width * 2) {
+      const middle = Math.min(begin + width, records.length);
+      const end = Math.min(begin + width * 2, records.length);
+      let left = begin;
+      let right = middle;
+      for (let index = begin; index < end; index++) {
+        const checkpoint = work.charge();
+        if (checkpoint) await checkpoint;
+        if (left < middle && (right === end || await compare(source[left], source[right]) <= 0)) target[index] = source[left++];
+        else target[index] = source[right++];
+      }
+    }
+    [source, target] = [target, source];
+  }
+  return source;
+}
+async function compareSortBytes(left, right, work) {
+  const length = Math.min(left.length, right.length);
+  for (let offset = 0; offset < length; offset += 1024) {
+    const end = Math.min(offset + 1024, length);
+    await work.charge(2 * (end - offset));
+    const compared = import_buffer.Buffer.compare(left.subarray(offset, end), right.subarray(offset, end));
+    if (compared) return compared;
+  }
+  return left.length - right.length;
+}
+async function foldSortBytes(bytes2, work) {
+  const folded = new Uint8Array(bytes2.length);
+  for (let offset = 0; offset < bytes2.length; offset += 1024) {
+    const end = Math.min(offset + 1024, bytes2.length);
+    await work.charge(end - offset);
+    for (let index = offset; index < end; index++) {
+      const byte = bytes2[index];
+      folded[index] = byte >= 97 && byte <= 122 ? byte - 32 : byte;
+    }
+  }
+  return folded;
+}
 async function admitTextOutput(context, destination) {
   if (destination === void 0) return;
   assertCommandRequirements(context, textOutputRequirements, ["output"]);
@@ -4602,27 +4664,37 @@ function compareBytes(left, right) {
 function fold(bytes2) {
   return bytes2.map((byte) => byte >= 97 && byte <= 122 ? byte - 32 : byte);
 }
-function parseNumeric(bytes2) {
+async function parseNumeric(bytes2, work) {
+  await work.charge(bytes2.length);
   const match = /^[ \t]*(-?)([0-9]*)(?:\.([0-9]*))?/u.exec(import_buffer.Buffer.from(bytes2).toString("latin1"));
   const whole = (match[2] ?? "").replace(/^0+/u, "") || "0";
   const fraction = (match[3] ?? "").replace(/0+$/u, "");
   return { whole, fraction, negative: match[1] === "-" && (whole !== "0" || fraction !== "") };
 }
-function compareNumericValues(first, second) {
+async function compareNumericValues(first, second, work) {
   if (first.negative !== second.negative) return first.negative ? -1 : 1;
   let compared = first.whole.length - second.whole.length;
-  if (!compared) compared = first.whole < second.whole ? -1 : first.whole > second.whole ? 1 : 0;
+  if (!compared) {
+    for (let offset = 0; offset < first.whole.length && !compared; offset += 1024) {
+      const end = Math.min(offset + 1024, first.whole.length);
+      await work.charge(2 * (end - offset));
+      const firstWhole = first.whole.slice(offset, end);
+      const secondWhole = second.whole.slice(offset, end);
+      compared = firstWhole < secondWhole ? -1 : firstWhole > secondWhole ? 1 : 0;
+    }
+  }
   if (!compared) {
     const width = Math.max(first.fraction.length, second.fraction.length);
-    const firstFraction = first.fraction.padEnd(width, "0");
-    const secondFraction = second.fraction.padEnd(width, "0");
-    compared = firstFraction < secondFraction ? -1 : firstFraction > secondFraction ? 1 : 0;
+    for (let offset = 0; offset < width && !compared; offset += 1024) {
+      const end = Math.min(offset + 1024, width);
+      await work.charge(2 * (end - offset));
+      const firstFraction = first.fraction.slice(offset, end).padEnd(end - offset, "0");
+      const secondFraction = second.fraction.slice(offset, end).padEnd(end - offset, "0");
+      compared = firstFraction < secondFraction ? -1 : firstFraction > secondFraction ? 1 : 0;
+    }
   }
   return first.negative ? -compared : compared;
 }
-function numericCompare(left, right) {
-  return compareNumericValues(parseNumeric(left), parseNumeric(right));
-}
 function sortKey(specification) {
   const match = /^([0-9]+)(?:\.([0-9]+))?([bfnr]*)(?:,([0-9]+)(?:\.([0-9]+))?([bfnr]*))?$/u.exec(specification);
   if (!match) throw new UsageError(`invalid key '${specification}'`);
@@ -4634,25 +4706,33 @@ function sortKey(specification) {
     flags: new Set((match[3] ?? "") + (match[6] ?? ""))
   };
 }
-function keyBytes(line, key, separator, blanks) {
+async function keyBytes(line, key, separator, blanks, work) {
   const fields = [];
   if (separator !== void 0) {
     let start2 = 0;
-    for (let offset = 0; offset <= line.length; offset++) if (offset === line.length || line[offset] === separator) {
-      fields.push({ start: start2, end: offset });
-      start2 = offset + 1;
+    for (let offset = 0; offset <= line.length; offset++) {
+      if (offset > 0 && offset % 1024 === 0) await work.charge(1024);
+      if (offset === line.length || line[offset] === separator) {
+        fields.push({ start: start2, end: offset });
+        start2 = offset + 1;
+      }
     }
   } else {
     let offset = 0;
     while (offset < line.length) {
       const leading = offset;
-      while (offset < line.length && (line[offset] === 32 || line[offset] === 9)) offset++;
+      while (offset < line.length && (line[offset] === 32 || line[offset] === 9)) {
+        if (++offset % 1024 === 0) await work.charge(1024);
+      }
       const start2 = blanks ? offset : leading;
       if (offset === line.length) break;
-      while (offset < line.length && line[offset] !== 32 && line[offset] !== 9) offset++;
+      while (offset < line.length && line[offset] !== 32 && line[offset] !== 9) {
+        if (++offset % 1024 === 0) await work.charge(1024);
+      }
       fields.push({ start: start2, end: offset });
     }
   }
+  await work.charge(line.length % 1024);
   const start = (fields[key.start - 1]?.start ?? line.length) + key.startCharacter - 1;
   const last = key.end === void 0 ? void 0 : fields[key.end - 1];
   const end = key.end === void 0 ? line.length : last === void 0 ? line.length : key.endCharacter === void 0 ? last.end : Math.min(last.end, last.start + key.endCharacter);
@@ -4715,42 +4795,50 @@ function textCommands() {
       const keys = (parsed.values.get("k") ?? []).map(sortKey);
       const simple = !keys.length && !["b", "f", "n"].some((flag) => parsed.flags.has(flag));
       const direction = parsed.flags.has("r") ? -1 : 1;
-      let compareNumeric = numericCompare;
+      const work = new SortWork(context.signal);
+      let compareNumeric = async (left, right) => compareNumericValues(await parseNumeric(left, work), await parseNumeric(right, work), work);
       if (!keys.length && parsed.flags.has("n") && !["b", "f", "c"].some((flag) => parsed.flags.has(flag))) {
         const numericValues = /* @__PURE__ */ new Map();
         let retainedBytes = 0;
-        const numericValue = (bytes2) => {
+        const numericValue = async (bytes2) => {
           const cached = numericValues.get(bytes2);
           if (cached !== void 0) return cached;
           context.signal.throwIfAborted();
           const charge2 = 6 * bytes2.length + 2;
-          if (numericValues.size >= 16384 || charge2 > 1048576 - retainedBytes) return parseNumeric(bytes2);
-          const parsedValue = parseNumeric(bytes2);
+          if (numericValues.size >= 16384 || charge2 > 1048576 - retainedBytes) return parseNumeric(bytes2, work);
+          const parsedValue = await parseNumeric(bytes2, work);
           numericValues.set(bytes2, parsedValue);
           retainedBytes += charge2;
           return parsedValue;
         };
-        compareNumeric = (left, right) => compareNumericValues(numericValue(left), numericValue(right));
+        compareNumeric = async (left, right) => compareNumericValues(await numericValue(left), await numericValue(right), work);
       }
-      let keyCompare = simple ? (left, right) => compareBytes(left, right) * direction : (left, right) => {
+      let keyCompare = async (left, right) => {
+        const checkpoint = work.charge();
+        if (checkpoint) await checkpoint;
+        if (simple) return await compareSortBytes(left, right, work) * direction;
         for (const key of keys.length ? keys : [void 0]) {
+          await work.charge();
           const flags = key?.flags.size ? key.flags : parsed.flags;
-          let first = key ? keyBytes(left, key, separator, flags.has("b")) : left;
-          let second = key ? keyBytes(right, key, separator, flags.has("b")) : right;
+          let first = key ? await keyBytes(left, key, separator, flags.has("b"), work) : left;
+          let second = key ? await keyBytes(right, key, separator, flags.has("b"), work) : right;
           if (!key && flags.has("b")) {
-            const trim = (bytes2) => {
+            const trim = async (bytes2) => {
               let offset = 0;
-              while (bytes2[offset] === 9 || bytes2[offset] === 32) offset++;
+              while (bytes2[offset] === 9 || bytes2[offset] === 32) {
+                if (++offset % 1024 === 0) await work.charge(1024);
+              }
+              await work.charge(offset % 1024);
               return bytes2.subarray(offset);
             };
-            first = trim(first);
-            second = trim(second);
+            first = await trim(first);
+            second = await trim(second);
           }
           if (flags.has("f")) {
-            first = fold(first);
-            second = fold(second);
+            first = await foldSortBytes(first, work);
+            second = await foldSortBytes(second, work);
           }
-          let result = flags.has("n") ? compareNumeric(first, second) : compareBytes(first, second);
+          let result = flags.has("n") ? await compareNumeric(first, second) : await compareSortBytes(first, second, work);
           if (flags.has("r")) result = -result;
           if (result) return result;
         }
@@ -4761,24 +4849,29 @@ function textCommands() {
       if (numericKey && numericKeyFlags.has("n") && !["b", "f"].some((flag) => numericKeyFlags.has(flag)) && !parsed.flags.has("c")) {
         const keyedNumericValues = /* @__PURE__ */ new Map();
         let retainedKeyBytes = 0;
-        const keyedNumericValue = (record4) => {
+        const keyedNumericValue = async (record4) => {
           const cached = keyedNumericValues.get(record4);
           if (cached !== void 0) return cached;
           context.signal.throwIfAborted();
-          const bytes2 = keyBytes(record4, numericKey, separator, false);
+          const bytes2 = await keyBytes(record4, numericKey, separator, false, work);
           const charge2 = 6 * bytes2.length + 2;
-          if (keyedNumericValues.size >= 16384 || charge2 > 1048576 - retainedKeyBytes) return parseNumeric(bytes2);
-          const parsedValue = parseNumeric(bytes2);
+          if (keyedNumericValues.size >= 16384 || charge2 > 1048576 - retainedKeyBytes) return parseNumeric(bytes2, work);
+          const parsedValue = await parseNumeric(bytes2, work);
           keyedNumericValues.set(record4, parsedValue);
           retainedKeyBytes += charge2;
           return parsedValue;
         };
-        keyCompare = (left, right) => {
-          const result = compareNumericValues(keyedNumericValue(left), keyedNumericValue(right));
+        keyCompare = async (left, right) => {
+          const checkpoint = work.charge();
+          if (checkpoint) await checkpoint;
+          const result = await compareNumericValues(await keyedNumericValue(left), await keyedNumericValue(right), work);
           return numericKeyFlags.has("r") ? -result : result;
         };
       }
-      const compare = simple ? keyCompare : (left, right) => keyCompare(left, right) || (parsed.flags.has("s") || parsed.flags.has("u") ? 0 : compareBytes(left, right) * (parsed.flags.has("r") ? -1 : 1));
+      const compare = async (left, right) => {
+        const result = await keyCompare(left, right);
+        return result || (simple || parsed.flags.has("s") || parsed.flags.has("u") ? 0 : await compareSortBytes(left, right, work) * direction);
+      };
       const records = [];
       let size = 0;
       const exitCode = 0;
@@ -4798,7 +4891,7 @@ function textCommands() {
             context.signal.throwIfAborted();
             size += line.bytes.length + 1;
             if (size > bufferLimit) throw new FsError("EFBIG", { message: "sort buffer limit exceeded" });
-            if (parsed.flags.has("c") && records.length && (compare(records.at(-1), line.bytes) > 0 || parsed.flags.has("u") && keyCompare(records.at(-1), line.bytes) === 0)) {
+            if (parsed.flags.has("c") && records.length && (await compare(records.at(-1), line.bytes) > 0 || parsed.flags.has("u") && await keyCompare(records.at(-1), line.bytes) === 0)) {
               await diagnostic(context, new Error(`disorder at record ${records.length + 1}`));
               return { exitCode: 1 };
             }
@@ -4810,14 +4903,14 @@ function textCommands() {
         }
       }
       if (parsed.flags.has("c")) return { exitCode };
-      records.sort(compare);
+      const ordered = await sortRecords(records, compare, work);
       const sorted = (async function* () {
         let previous;
         let buffer = new Uint8Array(64 * 1024);
         let used = 0;
-        for (const record4 of records) {
+        for (const record4 of ordered) {
           context.signal.throwIfAborted();
-          if (parsed.flags.has("u") && previous !== void 0 && keyCompare(previous, record4) === 0) continue;
+          if (parsed.flags.has("u") && previous !== void 0 && await keyCompare(previous, record4) === 0) continue;
           let offset = 0;
           while (offset < record4.length) {
             const length = Math.min(record4.length - offset, buffer.length - used);