@poe-platform/safe-bash 0.1.72 → 0.1.74

package/dist/safe-bash/browser.js

@@ -18713,7 +18713,7 @@ function descriptor(value2, limits) {
   for (const flag of flags) if (typeof value2[flag] !== "boolean") fail("protocol", `invalid ${flag} flag`);
   if (kind.value === "rg" && !["sensitive", "insensitive", "smart"].includes(value2.case)) fail("protocol", "invalid case flag");
   if (value2.word || kind.value === "grep" && value2.insensitive || kind.value === "rg" && value2.case !== "sensitive") fail("unsupported", "only case-sensitive, non-word selection is supported");
-  if (kind.value === "rg" && !value2.fixed) fail("unsupported", "rg regex and Unicode modes are unsupported; use fixed ASCII patterns");
+  if (kind.value === "rg" && !value2.fixed) fail("unsupported", "rg regex modes are unsupported; use fixed UTF-8 patterns");
   array(value2.patterns, limits.maxPatterns, "pattern");
   let bytes2 = 0;
   for (let index = 0; index < value2.patterns.length; index++) {
@@ -18741,7 +18741,7 @@ function admit(input3, limits, signal) {
     bytes2 += length;
   }
   const ledger = new EreLedger({ maxExpansionBytes: 1048576, maxExpansionFields: 8192 }, {
-    patternBytes: limits.maxPatternBytes + 4,
+    patternBytes: limits.maxPatternBytes + (selected.fixed ? 0 : 4),
     subjectBytes: limits.maxInputBytes,
     work: limits.maxWork,
     allocationUnits: limits.maxAllocationUnits,
@@ -18787,8 +18787,116 @@ async function admitBre(pattern, ledger, signal) {
     }
   }
 }
+async function validateUtf8(input3, ledger, signal) {
+  for (let index = 0; index < input3.length; ) {
+    const first = typeof input3 === "string" ? input3.charCodeAt(index) : input3[index];
+    const width = first < 128 ? 1 : first >= 194 && first <= 223 ? 2 : first >= 224 && first <= 239 ? 3 : first >= 240 && first <= 244 ? 4 : 0;
+    ledger.charge("work", Math.max(width, 1), signal);
+    if (first === 0 || width === 0 || width > input3.length - index) fail("unsupported", "literal patterns and subjects require valid non-NUL UTF-8 bytes");
+    for (let continuation = 1; continuation < width; continuation++) {
+      const byte = typeof input3 === "string" ? input3.charCodeAt(index + continuation) : input3[index + continuation];
+      if (byte < 128 || byte > 191 || continuation === 1 && (first === 224 && byte < 160 || first === 237 && byte > 159 || first === 240 && byte < 144 || first === 244 && byte > 143)) fail("unsupported", "literal patterns and subjects require valid non-NUL UTF-8 bytes");
+    }
+    index += width;
+    await ledger.checkpoint(signal);
+  }
+}
+async function literalBytes(pattern, selected, ledger, signal) {
+  const { kind } = selected;
+  let length = 0;
+  if (kind === "grep") {
+    await validateUtf8(pattern, ledger, signal);
+    length = pattern.length;
+  } else {
+    for (let index = 0; index < pattern.length; ) {
+      const scalar = pattern.codePointAt(index);
+      const units = scalar > 65535 ? 2 : 1;
+      ledger.charge("work", units, signal);
+      if (scalar === 0 || scalar >= 55296 && scalar <= 57343) fail("unsupported", "rg literal patterns require non-NUL Unicode scalars for UTF-8");
+      if (scalar === 10 && selected.kind === "rg" && !selected.nullData) fail("unsupported", "rg multiline matching is unsupported");
+      length += scalar < 128 ? 1 : scalar < 2048 ? 2 : scalar < 65536 ? 3 : 4;
+      index += units;
+      await ledger.checkpoint(signal);
+    }
+  }
+  ledger.charge("patternBytes", length, signal);
+  ledger.charge("allocationUnits", length + 1, signal);
+  const bytes2 = new Uint8Array(length);
+  let offset = 0;
+  for (let index = 0; index < pattern.length; ) {
+    const scalar = kind === "grep" ? pattern.charCodeAt(index) : pattern.codePointAt(index);
+    const width = kind === "grep" || scalar < 128 ? 1 : scalar < 2048 ? 2 : scalar < 65536 ? 3 : 4;
+    ledger.charge("work", width, signal);
+    if (width === 1) bytes2[offset++] = scalar;
+    else {
+      bytes2[offset++] = width === 2 ? 192 | scalar >> 6 : width === 3 ? 224 | scalar >> 12 : 240 | scalar >> 18;
+      if (width === 4) bytes2[offset++] = 128 | scalar >> 12 & 63;
+      if (width >= 3) bytes2[offset++] = 128 | scalar >> 6 & 63;
+      bytes2[offset++] = 128 | scalar & 63;
+    }
+    index += kind === "rg" && scalar > 65535 ? 2 : 1;
+    await ledger.checkpoint(signal);
+  }
+  return bytes2;
+}
+async function compileLiteral(bytes2, ledger, signal) {
+  ledger.charge("states", bytes2.length, signal);
+  ledger.charge("allocationUnits", bytes2.length * 4 + 3, signal);
+  const fallback = new Uint32Array(bytes2.length);
+  for (let index = 1, prefix2 = 0; index < bytes2.length; ) {
+    ledger.charge("work", 1, signal);
+    if (bytes2[index] === bytes2[prefix2]) fallback[index++] = ++prefix2;
+    else if (prefix2 > 0) prefix2 = fallback[prefix2 - 1];
+    else index++;
+    await ledger.checkpoint(signal);
+  }
+  return { bytes: bytes2, fallback };
+}
+async function literalStart(program, subject, whole, ledger, signal) {
+  const { bytes: bytes2, fallback } = program;
+  ledger.charge("work", 1, signal);
+  await ledger.checkpoint(signal);
+  if (whole && bytes2.length !== subject.length || bytes2.length > subject.length) return -1;
+  if (bytes2.length === 0) return 0;
+  for (let index = 0, prefix2 = 0; index < subject.length; ) {
+    ledger.charge("work", 1, signal);
+    if (subject[index] === bytes2[prefix2]) {
+      index++;
+      if (++prefix2 === bytes2.length) return index - prefix2;
+    } else if (prefix2 > 0) prefix2 = fallback[prefix2 - 1];
+    else index++;
+    await ledger.checkpoint(signal);
+  }
+  return -1;
+}
+async function executeLiteral(input3, signal) {
+  const { descriptor: selected, rows, ledger } = input3;
+  const programs2 = [];
+  for (const pattern of selected.patterns) {
+    programs2.push(await compileLiteral(await literalBytes(pattern, selected, ledger, signal), ledger, signal));
+  }
+  const results = [];
+  for (const row of rows) {
+    await validateUtf8(row.bytes, ledger, signal);
+    let start = -1;
+    let end = -1;
+    for (const program of programs2) {
+      const candidate = await literalStart(program, row.bytes, selected.whole, ledger, signal);
+      if (candidate < 0) continue;
+      if (start < 0 || candidate < start) {
+        start = candidate;
+        end = start + program.bytes.length;
+      }
+      if (selected.kind === "grep") break;
+    }
+    signal.throwIfAborted();
+    results.push(start < 0 ? new Float64Array() : new Float64Array([start, end]));
+  }
+  return { id: input3.id, results };
+}
 async function execute2(input3, signal) {
   const { descriptor: selected, rows, ledger } = input3;
+  if (selected.fixed) return executeLiteral(input3, signal);
   const programs2 = [];
   for (const pattern of selected.patterns) {
     if (selected.kind === "grep" && !selected.fixed && !selected.extended) await admitBre(pattern, ledger, signal);