@poe-platform/safe-bash 0.1.80 → 0.1.82

package/dist/safe-bash/browser.js

@@ -4653,6 +4653,23 @@ function streamCommands() {
 
 // packages/safe-bash/src/commands/text.ts
 init_platform();
+
+// packages/safe-bash/src/commands/sort-admission.ts
+init_platform();
+var SortRecordBudget = class {
+  #records = 0;
+  #bytes = 0;
+  admit(byteLength2) {
+    const bytes2 = byteLength2 + 1;
+    if (this.#records >= 1e5 || bytes2 > bufferLimit - this.#bytes) {
+      throw new FsError("EFBIG", { message: "sort buffer limit exceeded" });
+    }
+    this.#records++;
+    this.#bytes += bytes2;
+  }
+};
+
+// packages/safe-bash/src/commands/text.ts
 var SortWork = class {
   constructor(signal) {
     this.signal = signal;
@@ -4921,20 +4938,25 @@ async function emitRecords(context, records, destination) {
     await context.fs.writeFile(pathOf(context, destination), concatenate(chunks, size), { signal: context.signal });
   }
 }
-async function collectSortRecords(source, delimiter, accept) {
+async function collectSortRecords(source, delimiter, budget, signal, accept) {
   let pending = [];
   let size = 0;
   for await (const chunk of source) {
     let start = 0;
     for (let offset = 0; offset < chunk.length; offset++) {
       if (chunk[offset] !== delimiter) continue;
-      const part = chunk.subarray(start, offset);
-      size += part.length;
+      size += offset - start;
       if (size > bufferLimit) throw new FsError("EFBIG", { message: "line buffer limit exceeded" });
+      signal.throwIfAborted();
+      budget.admit(size);
+      const part = chunk.subarray(start, offset);
+      let record4;
       if (pending.length) {
         pending.push(part);
-        accept(concatenate(pending, size));
-      } else accept(new Uint8Array(part));
+        record4 = concatenate(pending, size);
+      } else record4 = new Uint8Array(part);
+      const accepted = accept(record4);
+      if ((accepted instanceof Promise ? await accepted : accepted) === false) return false;
       pending = [];
       size = 0;
       start = offset + 1;
@@ -4945,7 +4967,12 @@ async function collectSortRecords(source, delimiter, accept) {
       if (size > bufferLimit) throw new FsError("EFBIG", { message: "line buffer limit exceeded" });
     }
   }
-  if (size) accept(concatenate(pending, size));
+  if (size) {
+    signal.throwIfAborted();
+    budget.admit(size);
+    return await accept(concatenate(pending, size)) !== false;
+  }
+  return true;
 }
 function textCommands() {
   return [
@@ -5037,30 +5064,26 @@ function textCommands() {
         return result || (simple || parsed.flags.has("s") || parsed.flags.has("u") ? 0 : await compareSortBytes(left, right, work) * direction);
       };
       const records = [];
-      let size = 0;
+      const recordBudget = new SortRecordBudget();
       const exitCode = 0;
       const delimiter = parsed.flags.has("z") ? 0 : 10;
       for (const name2 of parsed.operands.length ? parsed.operands : ["-"]) {
         try {
-          if (!parsed.flags.has("c")) {
-            await collectSortRecords(input(context, name2), delimiter, (bytes2) => {
-              context.signal.throwIfAborted();
-              size += bytes2.length + 1;
-              if (size > bufferLimit) throw new FsError("EFBIG", { message: "sort buffer limit exceeded" });
-              records.push(bytes2);
-            });
-            continue;
-          }
-          for await (const line of lines(input(context, name2), delimiter)) {
+          const complete2 = await collectSortRecords(input(context, name2), delimiter, recordBudget, context.signal, (bytes2) => {
             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 && (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 };
+            if (!parsed.flags.has("c")) {
+              records.push(bytes2);
+              return;
             }
-            records.push(line.bytes);
-          }
+            return (async () => {
+              if (records.length && (await compare(records.at(-1), bytes2) > 0 || parsed.flags.has("u") && await keyCompare(records.at(-1), bytes2) === 0)) {
+                await diagnostic(context, new Error(`disorder at record ${records.length + 1}`));
+                return false;
+              }
+              records.push(bytes2);
+            })();
+          });
+          if (!complete2) return { exitCode: 1 };
         } catch (error) {
           await diagnostic(context, error);
           return { exitCode: 2 };
@@ -16368,19 +16391,31 @@ function createFetchTransport(options3 = {}) {
 
 // packages/safe-bash/src/commands/network/authorizer.ts
 init_platform();
+function privateIPv4(first, second) {
+  return first === 10 || first === 127 || first === 0 || first === 169 && second === 254 || first === 192 && second === 168 || first === 172 && second >= 16 && second <= 31;
+}
 function privateHostname(input3) {
   const hostname = input3.toLowerCase().replace(/\.$/u, "").replace(/^\[|\]$/gu, "");
   if (hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "::1") return true;
   if (hostname.includes(":")) {
-    const first2 = hostname.split(":", 1)[0] ?? "";
-    return first2.startsWith("fc") || first2.startsWith("fd") || ["fe8", "fe9", "fea", "feb"].some((prefix2) => first2.startsWith(prefix2));
+    const [prefix2, suffix2] = hostname.split("::");
+    const leading = prefix2 ? prefix2.split(":") : [];
+    const trailing = suffix2 ? suffix2.split(":") : [];
+    const hextets = new Array(8).fill(0);
+    for (let index = 0; index < leading.length; index++) hextets[index] = Number.parseInt(leading[index], 16);
+    for (let index = 0; index < trailing.length; index++) hextets[8 - trailing.length + index] = Number.parseInt(trailing[index], 16);
+    if (hextets.every((value2) => value2 === 0)) return true;
+    if (hextets.slice(0, 5).every((value2) => value2 === 0) && hextets[5] === 65535) {
+      return privateIPv4(hextets[6] >>> 8, hextets[6] & 255);
+    }
+    return (hextets[0] & 65024) === 64512 || (hextets[0] & 65472) === 65152;
   }
   const parts = hostname.split(".");
   if (parts.length !== 4 || parts.some((part) => !part || Array.from(part).some((character) => character < "0" || character > "9"))) return false;
   const octets = parts.map(Number);
   if (octets.some((value2) => value2 < 0 || value2 > 255)) return false;
   const [first, second] = octets;
-  return first === 10 || first === 127 || first === 0 || first === 169 && second === 254 || first === 192 && second === 168 || first === 172 && second >= 16 && second <= 31;
+  return privateIPv4(first, second);
 }
 function createOriginAuthorizer(allowlist = "*", options3 = {}) {
   const origins = /* @__PURE__ */ new Set();