@poe-platform/safe-bash 0.1.726 → 0.1.727

package/dist/safe-bash/chunks/{chunk-TIHMU25L.js → chunk-PQ37GDJF.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-RA4KWAKW.js";
 import {
   writeDiagnostic
-} from "./chunk-WTZZX4LV.js";
+} from "./chunk-A4MB2KXV.js";
 import {
   PublicDiagnostic,
   publicDiagnosticMessage
@@ -13,7 +13,7 @@ import {
 } from "./chunk-LV3A66Y2.js";
 import {
   yieldTurn
-} from "./chunk-B6YFFKYG.js";
+} from "./chunk-X4I3RHTC.js";
 import {
   getCommandArguments,
   shellValueBytes
@@ -1858,4 +1858,4 @@ export {
   createPrCommands,
   prCommands
 };
-//# sourceMappingURL=chunk-TIHMU25L.js.map
+//# sourceMappingURL=chunk-PQ37GDJF.js.map

package/dist/safe-bash/chunks/{chunk-OTM5RCWZ.js → chunk-QNEDWYC2.js}

@@ -1,6 +1,6 @@
 import {
   writeDiagnostic
-} from "./chunk-ZZ7JQBPX.js";
+} from "./chunk-4A2OLEML.js";
 import {
   PublicDiagnostic,
   publicDiagnosticMessage
@@ -79,12 +79,18 @@ var RecordBuffer = class {
     }
   }
   finish(admit, bytes, start = 0, end = bytes?.length ?? 0) {
-    this.#admit(end - start);
-    const size = this.#size + end - start;
+    const tailLength = end - start;
+    this.#admit(tailLength);
+    const size = this.#size + tailLength;
     admit?.(size);
     if (size > this.finalizationCapacity - this.#allocated) {
       throw new contracts_exports.FsError("EFBIG", { message: "line finalization buffer limit exceeded" });
     }
+    if (this.#size === 0) {
+      const result2 = new Uint8Array(tailLength);
+      if (bytes && tailLength > 0) result2.set(bytes.subarray(start, end));
+      return result2;
+    }
     const result = new Uint8Array(size);
     let offset = 0;
     for (const segment of this.#segments) {
@@ -92,12 +98,12 @@ var RecordBuffer = class {
       result.set(segment.subarray(0, length), offset);
       offset += length;
     }
-    if (bytes && end > start) result.set(bytes.subarray(start, end), offset);
+    if (bytes && tailLength > 0) result.set(bytes.subarray(start, end), offset);
     this.clear();
     return result;
   }
   clear() {
-    this.#segments = [];
+    if (this.#segments.length) this.#segments.length = 0;
     this.#size = 0;
     this.#allocated = 0;
   }
@@ -389,8 +395,9 @@ async function* lines(source, separator = 10, admit) {
   try {
     for await (const chunk of source) {
       let start = 0;
-      for (let offset = 0; offset < chunk.length; offset++) {
-        if (chunk[offset] !== separator) continue;
+      while (start < chunk.length) {
+        const offset = chunk.indexOf(separator, start);
+        if (offset < 0) break;
         yield { bytes: pending.finish(admit, chunk, start, offset), terminated: true };
         start = offset + 1;
       }
@@ -571,4 +578,4 @@ export {
   replaceArgument,
   escapeBytes
 };
-//# sourceMappingURL=chunk-OTM5RCWZ.js.map
+//# sourceMappingURL=chunk-QNEDWYC2.js.map

package/dist/safe-bash/chunks/chunk-QNEDWYC2.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/commands/internal.ts", "../../src/commands/portable-requirements.ts", "../../src/commands/record-buffer.ts", "../../src/commands/gnu-information.ts"],
+  "sourcesContent": ["import { PublicDiagnostic, publicDiagnosticMessage } from \"../diagnostics.js\";\nimport { assertCommandRequirements } from \"../contracts/command-requirements.js\";\nimport { writeDiagnostic } from \"../escaping.js\";\nimport { inputRequirements } from \"./portable-requirements.js\";\nimport { RecordBuffer } from \"./record-buffer.js\";\nimport { gnuInformation } from \"./gnu-information.js\";\nimport {\n  FsError, isAbsolutePath, readBytes, toByteSource, validatePath, writeBytes,\n  type ByteSource, type CommandContext, type CommandDefinition, type CommandHandler,\n} from \"../contracts/index.js\";\n\nexport const encoder = new TextEncoder();\nexport const decoder = new TextDecoder();\nexport const bufferLimit = 32 * 1024 * 1024;\n\nexport class UsageError extends PublicDiagnostic {}\n\nexport interface ParsedOptions {\n  readonly flags: Set<string>;\n  readonly values: Map<string, string[]>;\n  readonly operands: string[];\n}\n\nexport function options(\n  args: readonly string[], short: string, long: Readonly<Record<string, string | false>> = {},\n  stopAtOperand = false, onOperand?: (index: number) => void,\n  onValue?: (key: string, index: number, offset: number) => void,\n  onOption?: (key: string, value: string | undefined) => void,\n): ParsedOptions {\n  const flags = new Set<string>();\n  const values = new Map<string, string[]>();\n  const operands: string[] = [];\n  const specifications = new Map<string, boolean>();\n  for (let index = 0; index < short.length; index++) {\n    const key = short[index]!;\n    specifications.set(key, short[index + 1] === \":\");\n    if (short[index + 1] === \":\") index++;\n  }\n  let ended = false;\n  for (let index = 0; index < args.length; index++) {\n    const argument = args[index]!;\n    if (ended || argument === \"-\" || !argument.startsWith(\"-\")) {\n      operands.push(argument);\n      onOperand?.(index);\n      if (stopAtOperand) ended = true;\n      continue;\n    }\n    if (argument === \"--\") { ended = true; continue; }\n    if (argument.startsWith(\"--\")) {\n      const equals = argument.indexOf(\"=\");\n      const name = argument.slice(2, equals < 0 ? undefined : equals);\n      const alias = long[name];\n      const longValue = typeof alias === \"string\" && alias.endsWith(\":\");\n      const key = alias === false ? name : longValue ? alias.slice(0, -1) : alias;\n      if (!key || (alias !== false && !longValue && !specifications.has(key))) throw new UsageError(`unrecognized option '${argument}'`);\n      if (longValue || specifications.get(key)) {\n        const value = equals >= 0 ? argument.slice(equals + 1) : args[++index];\n        if (value === undefined) throw new UsageError(`option '--${name}' requires an argument`);\n        onValue?.(key, index, equals >= 0 ? equals + 1 : 0);\n        values.set(key, [...values.get(key) ?? [], value]);\n      } else if (equals >= 0) throw new UsageError(`option '--${name}' does not take an argument`);\n      flags.add(key);\n      onOption?.(key, values.get(key)?.at(-1));\n      continue;\n    }\n    for (let offset = 1; offset < argument.length; offset++) {\n      const key = argument[offset]!;\n      if (!specifications.has(key)) throw new UsageError(`invalid option -- '${key}'`);\n      if (specifications.get(key)) {\n        const value = argument.slice(offset + 1) || args[++index];\n        if (value === undefined) throw new UsageError(`option requires an argument -- '${key}'`);\n        onValue?.(key, index, offset + 1 < argument.length ? offset + 1 : 0);\n        values.set(key, [...values.get(key) ?? [], value]);\n        offset = argument.length;\n      }\n      flags.add(key);\n      onOption?.(key, values.get(key)?.at(-1));\n    }\n  }\n  return { flags, values, operands };\n}\n\nexport function value(parsed: ParsedOptions, key: string): string | undefined {\n  return parsed.values.get(key)?.at(-1);\n}\n\nexport function integer(text: string, minimum = 0): number {\n  if (!/^[+]?[0-9]+$/u.test(text)) throw new UsageError(`invalid number '${text}'`);\n  const number = Number(text);\n  if (!Number.isSafeInteger(number) || number < minimum) throw new UsageError(`invalid number '${text}'`);\n  return number;\n}\n\nexport function requireOperands(operands: readonly string[], minimum = 1, maximum = Infinity): void {\n  if (operands.length < minimum) throw new UsageError(\"missing operand\");\n  if (operands.length > maximum) throw new UsageError(`extra operand '${operands[maximum]}'`);\n}\n\nexport function pathOf(context: Pick<CommandContext, \"cwd\">, path: string): string {\n  if (!path) throw new FsError(\"ENOENT\", { path });\n  validatePath(path);\n  validatePath(context.cwd);\n  if (!isAbsolutePath(context.cwd)) throw new FsError(\"EINVAL\", { path: context.cwd, message: \"cwd must be absolute\" });\n  return isAbsolutePath(path) ? path : `${context.cwd.replace(/\\/$/u, \"\")}/${path}`;\n}\n\nexport function codeOf(error: unknown): string | undefined {\n  return error instanceof Error && \"code\" in error ? String(error.code) : undefined;\n}\n\nexport async function output(context: CommandContext, text: string | Uint8Array): Promise<void> {\n  context.signal.throwIfAborted();\n  await writeBytes(context.stdout, typeof text === \"string\" ? encoder.encode(text) : text, context.signal);\n}\n\nexport async function diagnostic(context: CommandContext, error: unknown): Promise<void> {\n  context.signal.throwIfAborted();\n  await writeDiagnostic(context.stderr, `${context.command}: ${publicDiagnosticMessage(error, context.onInternalError)}\\n`, context.signal);\n}\n\nexport function define(name: string, handler: CommandHandler, failureCode = 1): CommandDefinition {\n  return {\n    name,\n    async execute(context) {\n      context.signal.throwIfAborted();\n      try { return await gnuInformation(name, context) ?? await handler(context); }\n      catch (error) {\n        context.signal.throwIfAborted();\n        await diagnostic(context, error);\n        return { exitCode: error instanceof UsageError ? 2 : failureCode };\n      }\n    },\n  };\n}\n\nexport async function eachOperand(\n  context: CommandContext, operands: readonly string[], operation: (operand: string) => Promise<void>,\n): Promise<{ exitCode: number }> {\n  let exitCode = 0;\n  for (const operand of operands) {\n    context.signal.throwIfAborted();\n    try { await operation(operand); }\n    catch (error) { await diagnostic(context, error); exitCode = 1; }\n  }\n  return { exitCode };\n}\n\nexport async function* input(context: CommandContext, name = \"-\"): ByteSource {\n  context.signal.throwIfAborted();\n  if (name === \"-\") {\n    yield* readBytes(context.stdin, context.signal);\n  } else {\n    await assertInputRequirements(context, [name]);\n    const path = pathOf(context, name);\n    const capabilities = await context.fs.capabilitiesFor?.(path, { signal: context.signal }) ?? context.fs.capabilities;\n    if (context.fs.readStream && capabilities.streamingRead !== false) {\n      let emitted = false;\n      let reading = true;\n      try {\n        for await (const chunk of readBytes(context.fs.readStream(path, { signal: context.signal }), context.signal)) {\n          reading = false;\n          if (chunk.byteLength) emitted = true;\n          yield chunk;\n          reading = true;\n        }\n        return;\n      } catch (error) {\n        context.signal.throwIfAborted();\n        if (!reading || emitted || !(error instanceof FsError) || error.code !== \"ENOTSUP\") throw error;\n      }\n    }\n    if (capabilities.read === false) throw new FsError(\"ENOTSUP\", { syscall: \"readFile\", path });\n    yield* readBytes({\n      async *[Symbol.asyncIterator]() {\n        const bytes = await context.fs.readFile(path, { signal: context.signal, maxBytes: bufferLimit });\n        context.signal.throwIfAborted();\n        if (bytes.byteLength > bufferLimit) throw new FsError(\"EFBIG\", { syscall: \"readFile\", path });\n        yield bytes;\n      },\n    }, context.signal);\n  }\n}\n\nexport async function assertInputRequirements(context: CommandContext, names: readonly string[]): Promise<void> {\n  const files = names.filter(name => name !== \"-\");\n  assertCommandRequirements(context, inputRequirements, [files.length ? \"file\" : \"stdin\"]);\n  if (!context.fs.capabilitiesFor) return;\n  for (const name of files) {\n    try {\n      const capabilities = await context.fs.capabilitiesFor(pathOf(context, name), { signal: context.signal });\n      assertCommandRequirements(context, inputRequirements, [\"file\"], capabilities);\n    } catch (error) {\n      context.signal.throwIfAborted();\n      if (codeOf(error) === \"ENOTSUP\" || codeOf(error) === \"EROFS\") throw error;\n    }\n  }\n}\n\nexport function concatenate(chunks: readonly Uint8Array[], size = chunks.reduce((sum, chunk) => sum + chunk.length, 0)): Uint8Array {\n  const result = new Uint8Array(size);\n  let offset = 0;\n  for (const chunk of chunks) { result.set(chunk, offset); offset += chunk.length; }\n  return result;\n}\n\nexport async function collect(source: ByteSource, signal: AbortSignal, limit = bufferLimit): Promise<Uint8Array> {\n  const chunks: Uint8Array[] = [];\n  let size = 0;\n  for await (const chunk of source) {\n    signal.throwIfAborted();\n    size += chunk.length;\n    if (size > limit) throw new FsError(\"EFBIG\", { message: `buffer limit exceeded (${limit} bytes)` });\n    chunks.push(new Uint8Array(chunk));\n  }\n  return concatenate(chunks, size);\n}\n\nexport interface Line { readonly bytes: Uint8Array; readonly terminated: boolean }\n\nexport async function* lines(source: ByteSource, separator = 10, admit?: (size: number) => void): AsyncGenerator<Line> {\n  const pending = new RecordBuffer(bufferLimit);\n  try {\n    for await (const chunk of source) {\n      let start = 0;\n      while (start < chunk.length) {\n        const offset = chunk.indexOf(separator, start);\n        if (offset < 0) break;\n        yield { bytes: pending.finish(admit, chunk, start, offset), terminated: true };\n        start = offset + 1;\n      }\n      pending.append(chunk, start);\n    }\n    if (pending.size) yield { bytes: pending.finish(admit), terminated: false };\n  } finally { pending.clear(); }\n}\n\nexport function emptyInput(): ByteSource { return toByteSource(\"\"); }\n\nexport function replaceArgument(source: string | Uint8Array, pattern: string, replacement: string): string | Uint8Array {\n  if (typeof source === \"string\") return source.split(pattern).join(replacement);\n  const needle = encoder.encode(pattern);\n  if (!needle.length) throw new UsageError(\"replacement string cannot be empty\");\n  const substituted = encoder.encode(replacement);\n  const chunks: Uint8Array[] = [];\n  let start = 0;\n  for (let offset = 0; offset <= source.length - needle.length;) {\n    if (needle.every((byte, index) => source[offset + index] === byte)) {\n      chunks.push(source.subarray(start, offset), substituted);\n      offset += needle.length;\n      start = offset;\n    } else offset++;\n  }\n  chunks.push(source.subarray(start));\n  return concatenate(chunks);\n}\n\nexport function escapeBytes(text: string | Uint8Array, zeroOctal = false, bareOctal = false,\n  unicode?: { utf8: boolean; missingDigit: (escape: string) => void }): { bytes: Uint8Array; stop: boolean } {\n  if (unicode && typeof text === \"string\") text = encoder.encode(text);\n  if (typeof text === \"string\") {\n    const chunks: Uint8Array[] = [];\n    const control: Record<string, number> = { a: 7, b: 8, e: 27, E: 27, f: 12, n: 10, r: 13, t: 9, v: 11, \"\\\\\": 92 };\n    for (let index = 0; index < text.length;) {\n      if (text[index] !== \"\\\\\" || index + 1 === text.length) {\n        const character = String.fromCodePoint(text.codePointAt(index)!);\n        chunks.push(encoder.encode(character)); index += character.length; continue;\n      }\n      const next = text[index + 1]!;\n      if (next === \"c\") return { bytes: concatenate(chunks), stop: true };\n      if (control[next] !== undefined) { chunks.push(Uint8Array.of(control[next])); index += 2; continue; }\n      const rest = text.slice(index + 1);\n      const octal = zeroOctal ? (bareOctal ? /^(?:0([0-7]{0,3})|([1-7][0-7]{0,2}))/u : /^0([0-7]{0,3})/u).exec(rest) : /^([0-7]{1,3})/u.exec(rest);\n      if (octal) { chunks.push(Uint8Array.of(parseInt(octal[1] || octal[2] || \"0\", 8) & 255)); index += 1 + octal[0].length; continue; }\n      const hexadecimal = /^x([0-9a-fA-F]{1,2})/u.exec(rest);\n      if (hexadecimal) { chunks.push(Uint8Array.of(parseInt(hexadecimal[1]!, 16))); index += 1 + hexadecimal[0].length; continue; }\n      chunks.push(encoder.encode(`\\\\${next}`)); index += 2;\n    }\n    return { bytes: concatenate(chunks), stop: false };\n  }\n  const source = text;\n  // C-locale fallback normalizes short escapes to four/eight uppercase digits.\n  const bytes = new Uint8Array(source.length * (unicode && !unicode.utf8 ? 3 : 1));\n  const control: Record<number, number> = { 97: 7, 98: 8, 101: 27, 69: 27, 102: 12, 110: 10, 114: 13, 116: 9, 118: 11, 92: 92 };\n  let size = 0;\n  for (let index = 0; index < source.length;) {\n    if (source[index] !== 92 || index + 1 === source.length) { bytes[size++] = source[index++]!; continue; }\n    const next = source[index + 1]!;\n    if (next === 99) return { bytes: bytes.subarray(0, size), stop: true };\n    if (control[next] !== undefined) { bytes[size++] = control[next]; index += 2; continue; }\n    if (zeroOctal ? next === 48 || bareOctal && next >= 49 && next <= 55 : next >= 48 && next <= 55) {\n      let offset = index + (zeroOctal && next === 48 ? 2 : 1);\n      const end = Math.min(source.length, offset + 3);\n      let value = 0;\n      while (offset < end && source[offset]! >= 48 && source[offset]! <= 55) value = value * 8 + source[offset++]! - 48;\n      bytes[size++] = value & 255;\n      index = offset;\n      continue;\n    }\n    if (unicode && (next === 117 || next === 85)) {\n      const digits = next === 117 ? 4 : 8;\n      let offset = index + 2;\n      const end = Math.min(source.length, offset + digits);\n      let value = 0;\n      while (offset < end) {\n        const digit = source[offset]!;\n        const number = digit >= 48 && digit <= 57 ? digit - 48 : digit >= 65 && digit <= 70 ? digit - 55 : digit >= 97 && digit <= 102 ? digit - 87 : -1;\n        if (number < 0) break;\n        value = value * 16 + number;\n        offset++;\n      }\n      if (offset === index + 2) unicode.missingDigit(String.fromCharCode(next));\n      else {\n        // Bash discards values outside its signed 32-bit wide-character range.\n        if (value < 0x80000000) {\n          if (!unicode.utf8 && value > 127) {\n            const literal = encoder.encode(`\\\\${value <= 0xffff ? \"u\" : \"U\"}${value.toString(16).toUpperCase().padStart(value <= 0xffff ? 4 : 8, \"0\")}`);\n            bytes.set(literal, size);\n            size += literal.length;\n          } else if (value < 128) bytes[size++] = value;\n          else {\n            // Match Bash's byte encoding, including surrogate and extended values.\n            const length = value < 0x800 ? 2 : value < 0x10000 ? 3 : value < 0x200000 ? 4 : value < 0x4000000 ? 5 : 6;\n            for (let position = length - 1; position > 0; position--) {\n              bytes[size + position] = 0x80 | value & 0x3f;\n              value = Math.floor(value / 64);\n            }\n            bytes[size] = (0xff << (8 - length) & 0xff) | value;\n            size += length;\n          }\n        }\n        index = offset;\n        continue;\n      }\n    }\n    if (next === 120) {\n      let offset = index + 2;\n      const end = Math.min(source.length, offset + 2);\n      let value = 0;\n      while (offset < end) {\n        const digit = source[offset]!;\n        const number = digit >= 48 && digit <= 57 ? digit - 48 : digit >= 65 && digit <= 70 ? digit - 55 : digit >= 97 && digit <= 102 ? digit - 87 : -1;\n        if (number < 0) break;\n        value = value * 16 + number;\n        offset++;\n      }\n      if (offset > index + 2) { bytes[size++] = value; index = offset; continue; }\n      unicode?.missingDigit(\"x\");\n    }\n    bytes[size++] = 92;\n    bytes[size++] = next;\n    index += 2;\n  }\n  return { bytes: bytes.subarray(0, size), stop: false };\n}\n", "import type { CommandFileSystemRequirement } from \"../contracts/command-requirements.js\";\n\nexport const inputRequirements: readonly CommandFileSystemRequirement[] = [\n  { id: \"stdin\", description: \"Read standard input\", capabilities: [] },\n  { id: \"file\", description: \"Read file operands\", capabilities: [], anyOf: [[\"streamingRead\"], [\"read\"]] },\n];\n\nexport const textOutputRequirements: readonly CommandFileSystemRequirement[] = [\n  ...inputRequirements,\n  { id: \"output\", description: \"Write or truncate an output file\", capabilities: [], anyOf: [[\"streamingWrite\"], [\"write\"]], mutates: true },\n];\n\nexport const pwdRequirements: readonly CommandFileSystemRequirement[] = [\n  { id: \"logical\", description: \"Print the logical working directory\", capabilities: [] },\n  { id: \"physical\", description: \"Resolve the physical working directory (-P)\", capabilities: [\"realpath\"] },\n];\n\nexport const predicateRequirements: readonly CommandFileSystemRequirement[] = [\n  { id: \"expression\", description: \"Evaluate strings and integers\", capabilities: [] },\n  { id: \"metadata\", description: \"Inspect file metadata\", capabilities: [\"stat\"] },\n  { id: \"access\", description: \"Inspect path access permissions\", capabilities: [\"access\"] },\n];\n", "import { FsError } from \"../contracts/index.js\";\n\nconst segmentSize = 4096;\n\nexport class RecordBuffer {\n  #segments: Uint8Array[] = [];\n  #size = 0;\n  #allocated = 0;\n\n  constructor(readonly capacity: number, readonly finalizationCapacity = capacity * 2) {}\n\n  get size(): number { return this.#size; }\n\n  #admit(length: number): void {\n    if (length > this.capacity - this.#size) {\n      throw new FsError(\"EFBIG\", { message: \"line buffer limit exceeded\" });\n    }\n  }\n\n  append(bytes: Uint8Array, start = 0, end = bytes.length): void {\n    this.#admit(end - start);\n    let offset = start;\n    while (offset < end) {\n      let segment = this.#segments.at(-1);\n      const used = this.#size % segmentSize;\n      if (!segment || used === 0) {\n        segment = new Uint8Array(Math.min(segmentSize, this.capacity - this.#allocated));\n        this.#segments.push(segment);\n        this.#allocated += segment.length;\n      }\n      const length = Math.min(end - offset, segment.length - used);\n      segment.set(bytes.subarray(offset, offset + length), used);\n      this.#size += length;\n      offset += length;\n    }\n  }\n\n  finish(admit?: (size: number) => void, bytes?: Uint8Array, start = 0, end = bytes?.length ?? 0): Uint8Array {\n    const tailLength = end - start;\n    this.#admit(tailLength);\n    const size = this.#size + tailLength;\n    admit?.(size);\n    if (size > this.finalizationCapacity - this.#allocated) {\n      throw new FsError(\"EFBIG\", { message: \"line finalization buffer limit exceeded\" });\n    }\n    if (this.#size === 0) {\n      const result = new Uint8Array(tailLength);\n      if (bytes && tailLength > 0) result.set(bytes.subarray(start, end));\n      return result;\n    }\n    const result = new Uint8Array(size);\n    let offset = 0;\n    for (const segment of this.#segments) {\n      const length = Math.min(segment.length, this.#size - offset);\n      result.set(segment.subarray(0, length), offset);\n      offset += length;\n    }\n    if (bytes && tailLength > 0) result.set(bytes.subarray(start, end), offset);\n    this.clear();\n    return result;\n  }\n\n  clear(): void {\n    if (this.#segments.length) this.#segments.length = 0;\n    this.#size = 0;\n    this.#allocated = 0;\n  }\n}\n", "import { writeBytes, type CommandContext, type CommandResult } from \"../contracts/index.js\";\n\ninterface Information {\n  readonly usage: string;\n  readonly description: string;\n  readonly options: readonly string[];\n  readonly stopAtOperand?: boolean;\n  readonly versionOnly?: boolean;\n}\n\n// These describe the virtual implementations, not the complete GNU option set.\nconst information: Readonly<Record<string, Information>> = {\n  cat: { usage: \"[OPTION]... [FILE]...\", description: \"Concatenate input files.\", options: [\"-n, --number\", \"-b, --number-nonblank\", \"-s, --squeeze-blank\", \"-E, --show-ends\", \"-T, --show-tabs\", \"-v, --show-nonprinting\", \"-A, --show-all\"], versionOnly: true },\n  du: { usage: \"[OPTION]... [FILE]...\", description: \"Report virtual file allocation.\", options: [\"-a, --all\", \"-s, --summarize\", \"-c, --total\", \"-h, --human-readable\", \"-B, --block-size=SIZE\", \"-b, --bytes\", \"--apparent-size\", \"-d, --max-depth=NUM\", \"-X, --exclude-from=FILE\", \"--exclude=PATTERN\", \"-t, --threshold=SIZE\"], versionOnly: true },\n  base32: { usage: \"[OPTION]... [FILE]\", description: \"Encode or decode Base32 data.\", options: [\"-d, --decode\", \"-i, --ignore-garbage\", \"-w, --wrap=COLS\"] },\n  base64: { usage: \"[OPTION]... [FILE]\", description: \"Encode or decode Base64 data.\", options: [\"-d, --decode\", \"-i, --ignore-garbage\", \"-w, --wrap=COLS\"] },\n  basename: { usage: \"[OPTION]... NAME... [SUFFIX]\", description: \"Remove directory components and an optional suffix from names.\", options: [\"-a, --multiple\", \"-s, --suffix=SUFFIX\", \"-z, --zero\"] },\n  dirname: { usage: \"[OPTION]... NAME...\", description: \"Print the directory component of each name.\", options: [\"-z, --zero\"] },\n  chmod: { usage: \"[OPTION]... MODE FILE...\", description: \"Change virtual file permissions, subject to filesystem capabilities.\", options: [\"-R, --recursive\", \"-v, --verbose\", \"-c, --changes\", \"-f, --silent, --quiet\", \"--reference=FILE\"] },\n  cksum: { usage: \"[OPTION]... [FILE]...\", description: \"Compute checksums of files or standard input.\", options: [\"-a, --algorithm=TYPE\", \"-b, --binary\", \"-z, --zero\", \"--tag\", \"--untagged\", \"--raw\", \"--base64\"] },\n  comm: { usage: \"[OPTION]... FILE1 FILE2\", description: \"Compare sorted files in the C/POSIX byte locale.\", options: [\"-1\", \"-2\", \"-3\", \"--output-delimiter=STR\", \"--check-order\", \"--nocheck-order\"] },\n  cp: { usage: \"[OPTION]... SOURCE... DEST\", description: \"Copy virtual files, subject to filesystem capabilities.\", options: [\"-a, --archive\", \"-r, -R, --recursive\", \"-f, --force\", \"-i, --interactive\", \"-n, --no-clobber\", \"-v, --verbose\", \"-t, --target-directory=DIR\", \"-T, --no-target-directory\", \"-S, --suffix=SUFFIX\"] },\n  cut: { usage: \"[OPTION]... [FILE]...\", description: \"Select bytes, characters or fields from each input line.\", options: [\"-b, --bytes=LIST\", \"-c, --characters=LIST\", \"-f, --fields=LIST\", \"-d, --delimiter=CHAR\", \"-s, --only-delimited\", \"-z, --zero-terminated\", \"--output-delimiter=STR\", \"--complement\"] },\n  env: { usage: \"[OPTION]... [NAME=VALUE]... [COMMAND [ARG]...]\", description: \"Print the environment or run a registered command with a modified environment.\", options: [\"-i, --ignore-environment\", \"-u, --unset=NAME\", \"-C, --chdir=DIR\", \"-S, --split-string=STR\", \"-0, --null\"], stopAtOperand: true },\n  expand: { usage: \"[OPTION]... [FILE]...\", description: \"Convert tabs to spaces.\", options: [\"-i, --initial\", \"-t, --tabs=LIST\"] },\n  fold: { usage: \"[OPTION]... [FILE]...\", description: \"Wrap input lines to a selected width.\", options: [\"-b, --bytes\", \"-s, --spaces\", \"-w, --width=COLS\"] },\n  head: { usage: \"[OPTION]... [FILE]...\", description: \"Print the first ten lines by default, or a selected line/byte count.\", options: [\"-n, --lines=NUM\", \"-c, --bytes=NUM\", \"-q, --quiet, --silent\", \"-v, --verbose\", \"-z, --zero-terminated\"] },\n  tail: { usage: \"[OPTION]... [FILE]...\", description: \"Print the last ten lines by default, or a selected line/byte count.\", options: [\"-n, --lines=NUM\", \"-c, --bytes=NUM\", \"-q, --quiet, --silent\", \"-v, --verbose\", \"-z, --zero-terminated\"] },\n  join: { usage: \"[OPTION]... FILE1 FILE2\", description: \"Join sorted files on a common field in the C/POSIX byte locale.\", options: [\"-1=FIELD\", \"-2=FIELD\", \"-j=FIELD\", \"-t=CHAR\", \"-a=FILENUM\", \"-v=FILENUM\", \"-e=STR\", \"-o=FORMAT\", \"-i\", \"--check-order\", \"--nocheck-order\"] },\n  ln: { usage: \"[OPTION]... TARGET... LINK_NAME\", description: \"Create virtual hard or symbolic links when supported by the filesystem.\", options: [\"-s, --symbolic\", \"-r, --relative\", \"-f, --force\", \"-i, --interactive\", \"-n, --no-dereference\", \"-v, --verbose\", \"-t, --target-directory=DIR\", \"-T, --no-target-directory\", \"-S, --suffix=SUFFIX\"] },\n  ls: { usage: \"[OPTION]... [FILE]...\", description: \"List virtual directory entries.\", options: [\"-a, --all\", \"-A, --almost-all\", \"-l\", \"-1\", \"-d, --directory\", \"-F, --classify\", \"-r, --reverse\", \"-R, --recursive\", \"-L, --dereference\", \"-h, --human-readable\"] },\n  mkdir: { usage: \"[OPTION]... DIRECTORY...\", description: \"Create virtual directories.\", options: [\"-p, --parents\", \"-m, --mode=MODE\", \"-v, --verbose\"] },\n  mktemp: { usage: \"[OPTION]... [TEMPLATE]\", description: \"Create a temporary virtual file or directory.\", options: [\"-d, --directory\", \"-q, --quiet\", \"-u, --dry-run\", \"-p=DIR\", \"--tmpdir[=DIR]\", \"--suffix=SUFFIX\"] },\n  mv: { usage: \"[OPTION]... SOURCE... DEST\", description: \"Move virtual files, subject to filesystem capabilities.\", options: [\"-f, --force\", \"-i, --interactive\", \"-n, --no-clobber\", \"-u, --update\", \"-v, --verbose\", \"-t, --target-directory=DIR\", \"-T, --no-target-directory\", \"-S, --suffix=SUFFIX\"] },\n  nl: { usage: \"[OPTION]... [FILE]...\", description: \"Number input lines by section and numbering style.\", options: [\"-b, --body-numbering=STYLE\", \"-h, --header-numbering=STYLE\", \"-f, --footer-numbering=STYLE\", \"-v, --starting-line-number=NUM\", \"-i, --line-increment=NUM\", \"-s, --number-separator=STR\", \"-w, --number-width=NUM\", \"-n, --number-format=FORMAT\", \"-d, --section-delimiter=STR\", \"-l, --join-blank-lines=NUM\", \"-p, --no-renumber\"] },\n  od: { usage: \"[OPTION]... [FILE]...\", description: \"Print input bytes in selected numeric formats.\", options: [\"-A, --address-radix=RADIX\", \"-j, --skip-bytes=NUM\", \"-N, --read-bytes=NUM\", \"-t, --format=TYPE, --type=TYPE\", \"-w, --width=NUM\", \"--endian=ORDER\", \"-v, --output-duplicates\"] },\n  paste: { usage: \"[OPTION]... [FILE]...\", description: \"Merge corresponding or serial input lines.\", options: [\"-s, --serial\", \"-d, --delimiters=LIST\", \"-z, --zero-terminated\"] },\n  readlink: { usage: \"[OPTION]... FILE...\", description: \"Print symbolic link targets or canonical virtual paths.\", options: [\"-f, --canonicalize\", \"-e, --canonicalize-existing\", \"-m, --canonicalize-missing\", \"-n, --no-newline\", \"-z, --zero\"] },\n  realpath: { usage: \"[OPTION]... FILE...\", description: \"Print canonical virtual paths.\", options: [\"-e, --canonicalize-existing\", \"-m, --canonicalize-missing\", \"-s, --strip, --no-symlinks\", \"-z, --zero\"] },\n  rm: { usage: \"[OPTION]... FILE...\", description: \"Remove virtual files and directories.\", options: [\"-r, -R, --recursive\", \"-f, --force\", \"-d, --dir\", \"-v, --verbose\", \"-i\", \"-I\"] },\n  rmdir: { usage: \"[OPTION]... DIRECTORY...\", description: \"Remove empty virtual directories.\", options: [\"-p, --parents\", \"-v, --verbose\", \"--ignore-fail-on-non-empty\"] },\n  seq: { usage: \"[OPTION]... [FIRST [INCREMENT]] LAST\", description: \"Print a numeric sequence.\", options: [\"-s, --separator=STR\", \"-f, --format=FORMAT\", \"-w, --equal-width\"] },\n  sort: { usage: \"[OPTION]... [FILE]...\", description: \"Sort input records using the supported byte-oriented ordering modes.\", options: [\"-n, --numeric-sort\", \"-g, --general-numeric-sort\", \"-h, --human-numeric-sort\", \"-V, --version-sort\", \"-r, --reverse\", \"-f, --ignore-case\", \"-u, --unique\", \"-s, --stable\", \"-m, --merge\", \"-k, --key=KEY\", \"-t, --field-separator=CHAR\", \"-o, --output=FILE\", \"--sort=MODE\", \"-z, --zero-terminated\"] },\n  split: { usage: \"[OPTION]... [FILE [PREFIX]]\", description: \"Split input into virtual output files.\", options: [\"-l, --lines=NUM\", \"-b, --bytes=SIZE\", \"-C, --line-bytes=SIZE\", \"-a, --suffix-length=NUM\", \"--additional-suffix=SUFFIX\"] },\n  stat: { usage: \"[OPTION]... FILE...\", description: \"Display virtual file metadata supplied by the filesystem.\", options: [\"-L, --dereference\", \"-c, --format=FORMAT\", \"--printf=FORMAT\", \"-t, --terse\"] },\n  tac: { usage: \"[OPTION]... [FILE]...\", description: \"Print input records in reverse order.\", options: [\"-b, --before\", \"-r, --regex\", \"-s, --separator=STR\"] },\n  tee: { usage: \"[OPTION]... [FILE]...\", description: \"Copy standard input to standard output and virtual files.\", options: [\"-a, --append\", \"-i, --ignore-interrupts\", \"--output-error=MODE\"] },\n  touch: { usage: \"[OPTION]... FILE...\", description: \"Update virtual file timestamps, creating missing files by default.\", options: [\"-a\", \"-m\", \"-c, --no-create\", \"-h, --no-dereference\", \"-r, --reference=FILE\", \"-d, --date=STR\", \"-t=STAMP\"] },\n  tr: { usage: \"[OPTION]... STRING1 [STRING2]\", description: \"Translate, delete or squeeze input bytes.\", options: [\"-d, --delete\", \"-s, --squeeze-repeats\", \"-c, -C, --complement\", \"-t, --truncate-set1\"] },\n  unexpand: { usage: \"[OPTION]... [FILE]...\", description: \"Convert spaces to tabs.\", options: [\"-a, --all\", \"-t, --tabs=LIST\", \"--first-only\"] },\n  uniq: { usage: \"[OPTION]... [INPUT [OUTPUT]]\", description: \"Filter adjacent repeated input records.\", options: [\"-c, --count\", \"-d, --repeated\", \"-u, --unique\", \"-i, --ignore-case\", \"-f, --skip-fields=NUM\", \"-s, --skip-chars=NUM\", \"-w, --check-chars=NUM\", \"-z, --zero-terminated\"] },\n  wc: { usage: \"[OPTION]... [FILE]...\", description: \"Count input lines, words, bytes, characters or display width.\", options: [\"-l, --lines\", \"-w, --words\", \"-c, --bytes\", \"-m, --chars\", \"-L, --max-line-length\"] },\n};\n\nconst checksumInformation: Information = {\n  usage: \"[OPTION]... [FILE]...\", description: \"Compute or verify file digests.\",\n  options: [\"-b, --binary\", \"-c, --check\", \"-t, --text\", \"-z, --zero\", \"--tag\", \"--quiet\", \"--status\", \"--strict\", \"--warn\", \"--ignore-missing\"],\n};\n\nexport async function gnuInformation(name: string, context: CommandContext): Promise<CommandResult | undefined> {\n  if (!context.args.includes(\"--help\") && !context.args.includes(\"--version\")) return undefined;\n  const info = information[name] ?? ([\"md5sum\", \"sha1sum\", \"sha224sum\", \"sha256sum\", \"sha384sum\", \"sha512sum\"].includes(name) ? checksumInformation : undefined);\n  if (!info) return undefined;\n  const flags = new Map<string, \"none\" | \"required\" | \"optional\">();\n  for (const option of info.options) {\n    const takesValue = option.includes(\"[=\") ? \"optional\" : option.includes(\"=\") ? \"required\" : \"none\";\n    for (const spelling of option.split(\", \")) flags.set(spelling.split(\"=\")[0]!.split(\"[\")[0]!, takesValue);\n  }\n  for (let index = 0; index < context.args.length; index++) {\n    const arg = context.args[index]!;\n    if (arg === \"--\") break;\n    if (arg === \"--help\" || arg === \"--version\") {\n      if (arg === \"--help\" && info.versionOnly) return undefined;\n      const text = arg === \"--version\"\n        ? `${name} (safe-bash virtual implementation)\\n`\n        : `Usage: ${name} ${info.usage}\\n${info.description}\\n\\nCommon supported options (additional behavior is documented in the package):\\n${info.options.map(option => `  ${option.split(\", \").map(spelling => spelling.startsWith(\"--\") ? spelling : spelling.replace(\"=\", \" \")).join(\", \")}`).join(\"\\n\")}\\n  --help     display this help and exit\\n  --version  display implementation information and exit\\n\\nThis is the safe-bash virtual implementation; filesystem operations require backend capabilities.\\n`;\n      await writeBytes(context.stdout, new TextEncoder().encode(text), context.signal);\n      return { exitCode: 0 };\n    }\n    if (!arg.startsWith(\"-\") || arg === \"-\") {\n      if (info.stopAtOperand) break;\n      continue;\n    }\n    if (arg.startsWith(\"--\")) {\n      const equal = arg.indexOf(\"=\");\n      const spelling = equal < 0 ? arg : arg.slice(0, equal);\n      if (!flags.has(spelling)) return undefined;\n      if (flags.get(spelling) === \"required\" && equal < 0) index++;\n      else if (flags.get(spelling) === \"none\" && equal >= 0) return undefined;\n    } else {\n      for (let offset = 1; offset < arg.length; offset++) {\n        const spelling = `-${arg[offset]}`;\n        if (!flags.has(spelling)) return undefined;\n        if (flags.get(spelling) === \"required\") {\n          if (offset + 1 === arg.length) index++;\n          break;\n        }\n      }\n    }\n  }\n  return undefined;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;;;ACAA;AAEO,IAAM,oBAA6D;AAAA,EACxE,EAAE,IAAI,SAAS,aAAa,uBAAuB,cAAc,CAAC,EAAE;AAAA,EACpE,EAAE,IAAI,QAAQ,aAAa,sBAAsB,cAAc,CAAC,GAAG,OAAO,CAAC,CAAC,eAAe,GAAG,CAAC,MAAM,CAAC,EAAE;AAC1G;AAEO,IAAM,yBAAkE;AAAA,EAC7E,GAAG;AAAA,EACH,EAAE,IAAI,UAAU,aAAa,oCAAoC,cAAc,CAAC,GAAG,OAAO,CAAC,CAAC,gBAAgB,GAAG,CAAC,OAAO,CAAC,GAAG,SAAS,KAAK;AAC3I;AAEO,IAAM,kBAA2D;AAAA,EACtE,EAAE,IAAI,WAAW,aAAa,uCAAuC,cAAc,CAAC,EAAE;AAAA,EACtF,EAAE,IAAI,YAAY,aAAa,+CAA+C,cAAc,CAAC,UAAU,EAAE;AAC3G;AAEO,IAAM,wBAAiE;AAAA,EAC5E,EAAE,IAAI,cAAc,aAAa,iCAAiC,cAAc,CAAC,EAAE;AAAA,EACnF,EAAE,IAAI,YAAY,aAAa,yBAAyB,cAAc,CAAC,MAAM,EAAE;AAAA,EAC/E,EAAE,IAAI,UAAU,aAAa,mCAAmC,cAAc,CAAC,QAAQ,EAAE;AAC3F;;;ACrBA;AAEA,IAAM,cAAc;AAEb,IAAM,eAAN,MAAmB;AAAA,EAKxB,YAAqB,UAA2B,uBAAuB,WAAW,GAAG;AAAhE;AAA2B;AAAA,EAAsC;AAAA,EAAjE;AAAA,EAA2B;AAAA,EAJhD,YAA0B,CAAC;AAAA,EAC3B,QAAQ;AAAA,EACR,aAAa;AAAA,EAIb,IAAI,OAAe;AAAE,WAAO,KAAK;AAAA,EAAO;AAAA,EAExC,OAAO,QAAsB;AAC3B,QAAI,SAAS,KAAK,WAAW,KAAK,OAAO;AACvC,YAAM,IAAI,0BAAQ,SAAS,EAAE,SAAS,6BAA6B,CAAC;AAAA,IACtE;AAAA,EACF;AAAA,EAEA,OAAO,OAAmB,QAAQ,GAAG,MAAM,MAAM,QAAc;AAC7D,SAAK,OAAO,MAAM,KAAK;AACvB,QAAI,SAAS;AACb,WAAO,SAAS,KAAK;AACnB,UAAI,UAAU,KAAK,UAAU,GAAG,EAAE;AAClC,YAAM,OAAO,KAAK,QAAQ;AAC1B,UAAI,CAAC,WAAW,SAAS,GAAG;AAC1B,kBAAU,IAAI,WAAW,KAAK,IAAI,aAAa,KAAK,WAAW,KAAK,UAAU,CAAC;AAC/E,aAAK,UAAU,KAAK,OAAO;AAC3B,aAAK,cAAc,QAAQ;AAAA,MAC7B;AACA,YAAM,SAAS,KAAK,IAAI,MAAM,QAAQ,QAAQ,SAAS,IAAI;AAC3D,cAAQ,IAAI,MAAM,SAAS,QAAQ,SAAS,MAAM,GAAG,IAAI;AACzD,WAAK,SAAS;AACd,gBAAU;AAAA,IACZ;AAAA,EACF;AAAA,EAEA,OAAO,OAAgC,OAAoB,QAAQ,GAAG,MAAM,OAAO,UAAU,GAAe;AAC1G,UAAM,aAAa,MAAM;AACzB,SAAK,OAAO,UAAU;AACtB,UAAM,OAAO,KAAK,QAAQ;AAC1B,YAAQ,IAAI;AACZ,QAAI,OAAO,KAAK,uBAAuB,KAAK,YAAY;AACtD,YAAM,IAAI,0BAAQ,SAAS,EAAE,SAAS,0CAA0C,CAAC;AAAA,IACnF;AACA,QAAI,KAAK,UAAU,GAAG;AACpB,YAAMA,UAAS,IAAI,WAAW,UAAU;AACxC,UAAI,SAAS,aAAa,EAAG,CAAAA,QAAO,IAAI,MAAM,SAAS,OAAO,GAAG,CAAC;AAClE,aAAOA;AAAA,IACT;AACA,UAAM,SAAS,IAAI,WAAW,IAAI;AAClC,QAAI,SAAS;AACb,eAAW,WAAW,KAAK,WAAW;AACpC,YAAM,SAAS,KAAK,IAAI,QAAQ,QAAQ,KAAK,QAAQ,MAAM;AAC3D,aAAO,IAAI,QAAQ,SAAS,GAAG,MAAM,GAAG,MAAM;AAC9C,gBAAU;AAAA,IACZ;AACA,QAAI,SAAS,aAAa,EAAG,QAAO,IAAI,MAAM,SAAS,OAAO,GAAG,GAAG,MAAM;AAC1E,SAAK,MAAM;AACX,WAAO;AAAA,EACT;AAAA,EAEA,QAAc;AACZ,QAAI,KAAK,UAAU,OAAQ,MAAK,UAAU,SAAS;AACnD,SAAK,QAAQ;AACb,SAAK,aAAa;AAAA,EACpB;AACF;;;ACnEA;AAWA,IAAM,cAAqD;AAAA,EACzD,KAAK,EAAE,OAAO,yBAAyB,aAAa,4BAA4B,SAAS,CAAC,gBAAgB,yBAAyB,uBAAuB,mBAAmB,mBAAmB,0BAA0B,gBAAgB,GAAG,aAAa,KAAK;AAAA,EAC/P,IAAI,EAAE,OAAO,yBAAyB,aAAa,mCAAmC,SAAS,CAAC,aAAa,mBAAmB,eAAe,wBAAwB,yBAAyB,eAAe,mBAAmB,uBAAuB,2BAA2B,qBAAqB,sBAAsB,GAAG,aAAa,KAAK;AAAA,EACpV,QAAQ,EAAE,OAAO,sBAAsB,aAAa,iCAAiC,SAAS,CAAC,gBAAgB,wBAAwB,iBAAiB,EAAE;AAAA,EAC1J,QAAQ,EAAE,OAAO,sBAAsB,aAAa,iCAAiC,SAAS,CAAC,gBAAgB,wBAAwB,iBAAiB,EAAE;AAAA,EAC1J,UAAU,EAAE,OAAO,gCAAgC,aAAa,kEAAkE,SAAS,CAAC,kBAAkB,uBAAuB,YAAY,EAAE;AAAA,EACnM,SAAS,EAAE,OAAO,uBAAuB,aAAa,+CAA+C,SAAS,CAAC,YAAY,EAAE;AAAA,EAC7H,OAAO,EAAE,OAAO,4BAA4B,aAAa,wEAAwE,SAAS,CAAC,mBAAmB,iBAAiB,iBAAiB,yBAAyB,kBAAkB,EAAE;AAAA,EAC7O,OAAO,EAAE,OAAO,yBAAyB,aAAa,iDAAiD,SAAS,CAAC,wBAAwB,gBAAgB,cAAc,SAAS,cAAc,SAAS,UAAU,EAAE;AAAA,EACnN,MAAM,EAAE,OAAO,2BAA2B,aAAa,oDAAoD,SAAS,CAAC,MAAM,MAAM,MAAM,0BAA0B,iBAAiB,iBAAiB,EAAE;AAAA,EACrM,IAAI,EAAE,OAAO,8BAA8B,aAAa,2DAA2D,SAAS,CAAC,iBAAiB,uBAAuB,eAAe,qBAAqB,oBAAoB,iBAAiB,8BAA8B,6BAA6B,qBAAqB,EAAE;AAAA,EAChU,KAAK,EAAE,OAAO,yBAAyB,aAAa,4DAA4D,SAAS,CAAC,oBAAoB,yBAAyB,qBAAqB,wBAAwB,wBAAwB,yBAAyB,0BAA0B,cAAc,EAAE;AAAA,EAC/S,KAAK,EAAE,OAAO,kDAAkD,aAAa,kFAAkF,SAAS,CAAC,4BAA4B,oBAAoB,mBAAmB,0BAA0B,YAAY,GAAG,eAAe,KAAK;AAAA,EACzS,QAAQ,EAAE,OAAO,yBAAyB,aAAa,2BAA2B,SAAS,CAAC,iBAAiB,iBAAiB,EAAE;AAAA,EAChI,MAAM,EAAE,OAAO,yBAAyB,aAAa,yCAAyC,SAAS,CAAC,eAAe,gBAAgB,kBAAkB,EAAE;AAAA,EAC3J,MAAM,EAAE,OAAO,yBAAyB,aAAa,wEAAwE,SAAS,CAAC,mBAAmB,mBAAmB,yBAAyB,iBAAiB,uBAAuB,EAAE;AAAA,EAChP,MAAM,EAAE,OAAO,yBAAyB,aAAa,uEAAuE,SAAS,CAAC,mBAAmB,mBAAmB,yBAAyB,iBAAiB,uBAAuB,EAAE;AAAA,EAC/O,MAAM,EAAE,OAAO,2BAA2B,aAAa,mEAAmE,SAAS,CAAC,YAAY,YAAY,YAAY,WAAW,cAAc,cAAc,UAAU,aAAa,MAAM,iBAAiB,iBAAiB,EAAE;AAAA,EAChR,IAAI,EAAE,OAAO,mCAAmC,aAAa,2EAA2E,SAAS,CAAC,kBAAkB,kBAAkB,eAAe,qBAAqB,wBAAwB,iBAAiB,8BAA8B,6BAA6B,qBAAqB,EAAE;AAAA,EACrV,IAAI,EAAE,OAAO,yBAAyB,aAAa,mCAAmC,SAAS,CAAC,aAAa,oBAAoB,MAAM,MAAM,mBAAmB,kBAAkB,iBAAiB,mBAAmB,qBAAqB,sBAAsB,EAAE;AAAA,EACnQ,OAAO,EAAE,OAAO,4BAA4B,aAAa,+BAA+B,SAAS,CAAC,iBAAiB,mBAAmB,eAAe,EAAE;AAAA,EACvJ,QAAQ,EAAE,OAAO,0BAA0B,aAAa,iDAAiD,SAAS,CAAC,mBAAmB,eAAe,iBAAiB,UAAU,kBAAkB,iBAAiB,EAAE;AAAA,EACrN,IAAI,EAAE,OAAO,8BAA8B,aAAa,2DAA2D,SAAS,CAAC,eAAe,qBAAqB,oBAAoB,gBAAgB,iBAAiB,8BAA8B,6BAA6B,qBAAqB,EAAE;AAAA,EACxS,IAAI,EAAE,OAAO,yBAAyB,aAAa,sDAAsD,SAAS,CAAC,8BAA8B,gCAAgC,gCAAgC,kCAAkC,4BAA4B,8BAA8B,0BAA0B,8BAA8B,+BAA+B,8BAA8B,mBAAmB,EAAE;AAAA,EACvb,IAAI,EAAE,OAAO,yBAAyB,aAAa,kDAAkD,SAAS,CAAC,6BAA6B,wBAAwB,wBAAwB,kCAAkC,mBAAmB,kBAAkB,yBAAyB,EAAE;AAAA,EAC9R,OAAO,EAAE,OAAO,yBAAyB,aAAa,8CAA8C,SAAS,CAAC,gBAAgB,yBAAyB,uBAAuB,EAAE;AAAA,EAChL,UAAU,EAAE,OAAO,uBAAuB,aAAa,2DAA2D,SAAS,CAAC,sBAAsB,+BAA+B,8BAA8B,oBAAoB,YAAY,EAAE;AAAA,EACjP,UAAU,EAAE,OAAO,uBAAuB,aAAa,kCAAkC,SAAS,CAAC,+BAA+B,8BAA8B,8BAA8B,YAAY,EAAE;AAAA,EAC5M,IAAI,EAAE,OAAO,uBAAuB,aAAa,yCAAyC,SAAS,CAAC,uBAAuB,eAAe,aAAa,iBAAiB,MAAM,IAAI,EAAE;AAAA,EACpL,OAAO,EAAE,OAAO,4BAA4B,aAAa,qCAAqC,SAAS,CAAC,iBAAiB,iBAAiB,4BAA4B,EAAE;AAAA,EACxK,KAAK,EAAE,OAAO,wCAAwC,aAAa,6BAA6B,SAAS,CAAC,uBAAuB,uBAAuB,mBAAmB,EAAE;AAAA,EAC7K,MAAM,EAAE,OAAO,yBAAyB,aAAa,wEAAwE,SAAS,CAAC,sBAAsB,8BAA8B,4BAA4B,sBAAsB,iBAAiB,qBAAqB,gBAAgB,gBAAgB,eAAe,iBAAiB,8BAA8B,qBAAqB,eAAe,uBAAuB,EAAE;AAAA,EAC9a,OAAO,EAAE,OAAO,+BAA+B,aAAa,0CAA0C,SAAS,CAAC,mBAAmB,oBAAoB,yBAAyB,2BAA2B,4BAA4B,EAAE;AAAA,EACzO,MAAM,EAAE,OAAO,uBAAuB,aAAa,6DAA6D,SAAS,CAAC,qBAAqB,uBAAuB,mBAAmB,aAAa,EAAE;AAAA,EACxM,KAAK,EAAE,OAAO,yBAAyB,aAAa,yCAAyC,SAAS,CAAC,gBAAgB,eAAe,qBAAqB,EAAE;AAAA,EAC7J,KAAK,EAAE,OAAO,yBAAyB,aAAa,6DAA6D,SAAS,CAAC,gBAAgB,2BAA2B,qBAAqB,EAAE;AAAA,EAC7L,OAAO,EAAE,OAAO,uBAAuB,aAAa,sEAAsE,SAAS,CAAC,MAAM,MAAM,mBAAmB,wBAAwB,wBAAwB,kBAAkB,UAAU,EAAE;AAAA,EACjP,IAAI,EAAE,OAAO,iCAAiC,aAAa,6CAA6C,SAAS,CAAC,gBAAgB,yBAAyB,wBAAwB,qBAAqB,EAAE;AAAA,EAC1M,UAAU,EAAE,OAAO,yBAAyB,aAAa,2BAA2B,SAAS,CAAC,aAAa,mBAAmB,cAAc,EAAE;AAAA,EAC9I,MAAM,EAAE,OAAO,gCAAgC,aAAa,2CAA2C,SAAS,CAAC,eAAe,kBAAkB,gBAAgB,qBAAqB,yBAAyB,wBAAwB,yBAAyB,uBAAuB,EAAE;AAAA,EAC1R,IAAI,EAAE,OAAO,yBAAyB,aAAa,iEAAiE,SAAS,CAAC,eAAe,eAAe,eAAe,eAAe,uBAAuB,EAAE;AACrN;AAEA,IAAM,sBAAmC;AAAA,EACvC,OAAO;AAAA,EAAyB,aAAa;AAAA,EAC7C,SAAS,CAAC,gBAAgB,eAAe,cAAc,cAAc,SAAS,WAAW,YAAY,YAAY,UAAU,kBAAkB;AAC/I;AAEA,eAAsB,eAAe,MAAc,SAA6D;AAC9G,MAAI,CAAC,QAAQ,KAAK,SAAS,QAAQ,KAAK,CAAC,QAAQ,KAAK,SAAS,WAAW,EAAG,QAAO;AACpF,QAAM,OAAO,YAAY,IAAI,MAAM,CAAC,UAAU,WAAW,aAAa,aAAa,aAAa,WAAW,EAAE,SAAS,IAAI,IAAI,sBAAsB;AACpJ,MAAI,CAAC,KAAM,QAAO;AAClB,QAAM,QAAQ,oBAAI,IAA8C;AAChE,aAAW,UAAU,KAAK,SAAS;AACjC,UAAM,aAAa,OAAO,SAAS,IAAI,IAAI,aAAa,OAAO,SAAS,GAAG,IAAI,aAAa;AAC5F,eAAW,YAAY,OAAO,MAAM,IAAI,EAAG,OAAM,IAAI,SAAS,MAAM,GAAG,EAAE,CAAC,EAAG,MAAM,GAAG,EAAE,CAAC,GAAI,UAAU;AAAA,EACzG;AACA,WAAS,QAAQ,GAAG,QAAQ,QAAQ,KAAK,QAAQ,SAAS;AACxD,UAAM,MAAM,QAAQ,KAAK,KAAK;AAC9B,QAAI,QAAQ,KAAM;AAClB,QAAI,QAAQ,YAAY,QAAQ,aAAa;AAC3C,UAAI,QAAQ,YAAY,KAAK,YAAa,QAAO;AACjD,YAAM,OAAO,QAAQ,cACjB,GAAG,IAAI;AAAA,IACP,UAAU,IAAI,IAAI,KAAK,KAAK;AAAA,EAAK,KAAK,WAAW;AAAA;AAAA;AAAA,EAAqF,KAAK,QAAQ,IAAI,YAAU,KAAK,OAAO,MAAM,IAAI,EAAE,IAAI,cAAY,SAAS,WAAW,IAAI,IAAI,WAAW,SAAS,QAAQ,KAAK,GAAG,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,EAAE,KAAK,IAAI,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AACxS,gBAAM,8BAAW,QAAQ,QAAQ,IAAI,YAAY,EAAE,OAAO,IAAI,GAAG,QAAQ,MAAM;AAC/E,aAAO,EAAE,UAAU,EAAE;AAAA,IACvB;AACA,QAAI,CAAC,IAAI,WAAW,GAAG,KAAK,QAAQ,KAAK;AACvC,UAAI,KAAK,cAAe;AACxB;AAAA,IACF;AACA,QAAI,IAAI,WAAW,IAAI,GAAG;AACxB,YAAM,QAAQ,IAAI,QAAQ,GAAG;AAC7B,YAAM,WAAW,QAAQ,IAAI,MAAM,IAAI,MAAM,GAAG,KAAK;AACrD,UAAI,CAAC,MAAM,IAAI,QAAQ,EAAG,QAAO;AACjC,UAAI,MAAM,IAAI,QAAQ,MAAM,cAAc,QAAQ,EAAG;AAAA,eAC5C,MAAM,IAAI,QAAQ,MAAM,UAAU,SAAS,EAAG,QAAO;AAAA,IAChE,OAAO;AACL,eAAS,SAAS,GAAG,SAAS,IAAI,QAAQ,UAAU;AAClD,cAAM,WAAW,IAAI,IAAI,MAAM,CAAC;AAChC,YAAI,CAAC,MAAM,IAAI,QAAQ,EAAG,QAAO;AACjC,YAAI,MAAM,IAAI,QAAQ,MAAM,YAAY;AACtC,cAAI,SAAS,MAAM,IAAI,OAAQ;AAC/B;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;;;AH1FO,IAAM,UAAU,IAAI,YAAY;AAChC,IAAM,UAAU,IAAI,YAAY;AAChC,IAAM,cAAc,KAAK,OAAO;AAEhC,IAAM,aAAN,cAAyB,iBAAiB;AAAC;AAQ3C,SAAS,QACd,MAAyB,OAAe,OAAiD,CAAC,GAC1F,gBAAgB,OAAO,WACvB,SACA,UACe;AACf,QAAM,QAAQ,oBAAI,IAAY;AAC9B,QAAM,SAAS,oBAAI,IAAsB;AACzC,QAAM,WAAqB,CAAC;AAC5B,QAAM,iBAAiB,oBAAI,IAAqB;AAChD,WAAS,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS;AACjD,UAAM,MAAM,MAAM,KAAK;AACvB,mBAAe,IAAI,KAAK,MAAM,QAAQ,CAAC,MAAM,GAAG;AAChD,QAAI,MAAM,QAAQ,CAAC,MAAM,IAAK;AAAA,EAChC;AACA,MAAI,QAAQ;AACZ,WAAS,QAAQ,GAAG,QAAQ,KAAK,QAAQ,SAAS;AAChD,UAAM,WAAW,KAAK,KAAK;AAC3B,QAAI,SAAS,aAAa,OAAO,CAAC,SAAS,WAAW,GAAG,GAAG;AAC1D,eAAS,KAAK,QAAQ;AACtB,kBAAY,KAAK;AACjB,UAAI,cAAe,SAAQ;AAC3B;AAAA,IACF;AACA,QAAI,aAAa,MAAM;AAAE,cAAQ;AAAM;AAAA,IAAU;AACjD,QAAI,SAAS,WAAW,IAAI,GAAG;AAC7B,YAAM,SAAS,SAAS,QAAQ,GAAG;AACnC,YAAM,OAAO,SAAS,MAAM,GAAG,SAAS,IAAI,SAAY,MAAM;AAC9D,YAAM,QAAQ,KAAK,IAAI;AACvB,YAAM,YAAY,OAAO,UAAU,YAAY,MAAM,SAAS,GAAG;AACjE,YAAM,MAAM,UAAU,QAAQ,OAAO,YAAY,MAAM,MAAM,GAAG,EAAE,IAAI;AACtE,UAAI,CAAC,OAAQ,UAAU,SAAS,CAAC,aAAa,CAAC,eAAe,IAAI,GAAG,EAAI,OAAM,IAAI,WAAW,wBAAwB,QAAQ,GAAG;AACjI,UAAI,aAAa,eAAe,IAAI,GAAG,GAAG;AACxC,cAAMC,SAAQ,UAAU,IAAI,SAAS,MAAM,SAAS,CAAC,IAAI,KAAK,EAAE,KAAK;AACrE,YAAIA,WAAU,OAAW,OAAM,IAAI,WAAW,aAAa,IAAI,wBAAwB;AACvF,kBAAU,KAAK,OAAO,UAAU,IAAI,SAAS,IAAI,CAAC;AAClD,eAAO,IAAI,KAAK,CAAC,GAAG,OAAO,IAAI,GAAG,KAAK,CAAC,GAAGA,MAAK,CAAC;AAAA,MACnD,WAAW,UAAU,EAAG,OAAM,IAAI,WAAW,aAAa,IAAI,6BAA6B;AAC3F,YAAM,IAAI,GAAG;AACb,iBAAW,KAAK,OAAO,IAAI,GAAG,GAAG,GAAG,EAAE,CAAC;AACvC;AAAA,IACF;AACA,aAAS,SAAS,GAAG,SAAS,SAAS,QAAQ,UAAU;AACvD,YAAM,MAAM,SAAS,MAAM;AAC3B,UAAI,CAAC,eAAe,IAAI,GAAG,EAAG,OAAM,IAAI,WAAW,sBAAsB,GAAG,GAAG;AAC/E,UAAI,eAAe,IAAI,GAAG,GAAG;AAC3B,cAAMA,SAAQ,SAAS,MAAM,SAAS,CAAC,KAAK,KAAK,EAAE,KAAK;AACxD,YAAIA,WAAU,OAAW,OAAM,IAAI,WAAW,mCAAmC,GAAG,GAAG;AACvF,kBAAU,KAAK,OAAO,SAAS,IAAI,SAAS,SAAS,SAAS,IAAI,CAAC;AACnE,eAAO,IAAI,KAAK,CAAC,GAAG,OAAO,IAAI,GAAG,KAAK,CAAC,GAAGA,MAAK,CAAC;AACjD,iBAAS,SAAS;AAAA,MACpB;AACA,YAAM,IAAI,GAAG;AACb,iBAAW,KAAK,OAAO,IAAI,GAAG,GAAG,GAAG,EAAE,CAAC;AAAA,IACzC;AAAA,EACF;AACA,SAAO,EAAE,OAAO,QAAQ,SAAS;AACnC;AAEO,SAAS,MAAM,QAAuB,KAAiC;AAC5E,SAAO,OAAO,OAAO,IAAI,GAAG,GAAG,GAAG,EAAE;AACtC;AAEO,SAAS,QAAQ,MAAc,UAAU,GAAW;AACzD,MAAI,CAAC,gBAAgB,KAAK,IAAI,EAAG,OAAM,IAAI,WAAW,mBAAmB,IAAI,GAAG;AAChF,QAAM,SAAS,OAAO,IAAI;AAC1B,MAAI,CAAC,OAAO,cAAc,MAAM,KAAK,SAAS,QAAS,OAAM,IAAI,WAAW,mBAAmB,IAAI,GAAG;AACtG,SAAO;AACT;AAEO,SAAS,gBAAgB,UAA6B,UAAU,GAAG,UAAU,UAAgB;AAClG,MAAI,SAAS,SAAS,QAAS,OAAM,IAAI,WAAW,iBAAiB;AACrE,MAAI,SAAS,SAAS,QAAS,OAAM,IAAI,WAAW,kBAAkB,SAAS,OAAO,CAAC,GAAG;AAC5F;AAEO,SAAS,OAAO,SAAsC,MAAsB;AACjF,MAAI,CAAC,KAAM,OAAM,IAAI,0BAAQ,UAAU,EAAE,KAAK,CAAC;AAC/C,eAAa,IAAI;AACjB,eAAa,QAAQ,GAAG;AACxB,MAAI,CAAC,eAAe,QAAQ,GAAG,EAAG,OAAM,IAAI,0BAAQ,UAAU,EAAE,MAAM,QAAQ,KAAK,SAAS,uBAAuB,CAAC;AACpH,SAAO,eAAe,IAAI,IAAI,OAAO,GAAG,QAAQ,IAAI,QAAQ,QAAQ,EAAE,CAAC,IAAI,IAAI;AACjF;AAEO,SAAS,OAAO,OAAoC;AACzD,SAAO,iBAAiB,SAAS,UAAU,QAAQ,OAAO,MAAM,IAAI,IAAI;AAC1E;AAEA,eAAsB,OAAO,SAAyB,MAA0C;AAC9F,UAAQ,OAAO,eAAe;AAC9B,YAAM,8BAAW,QAAQ,QAAQ,OAAO,SAAS,WAAW,QAAQ,OAAO,IAAI,IAAI,MAAM,QAAQ,MAAM;AACzG;AAEA,eAAsB,WAAW,SAAyB,OAA+B;AACvF,UAAQ,OAAO,eAAe;AAC9B,QAAM,gBAAgB,QAAQ,QAAQ,GAAG,QAAQ,OAAO,KAAK,wBAAwB,OAAO,QAAQ,eAAe,CAAC;AAAA,GAAM,QAAQ,MAAM;AAC1I;AAEO,SAAS,OAAO,MAAc,SAAyB,cAAc,GAAsB;AAChG,SAAO;AAAA,IACL;AAAA,IACA,MAAM,QAAQ,SAAS;AACrB,cAAQ,OAAO,eAAe;AAC9B,UAAI;AAAE,eAAO,MAAM,eAAe,MAAM,OAAO,KAAK,MAAM,QAAQ,OAAO;AAAA,MAAG,SACrE,OAAO;AACZ,gBAAQ,OAAO,eAAe;AAC9B,cAAM,WAAW,SAAS,KAAK;AAC/B,eAAO,EAAE,UAAU,iBAAiB,aAAa,IAAI,YAAY;AAAA,MACnE;AAAA,IACF;AAAA,EACF;AACF;AAEA,eAAsB,YACpB,SAAyB,UAA6B,WACvB;AAC/B,MAAI,WAAW;AACf,aAAW,WAAW,UAAU;AAC9B,YAAQ,OAAO,eAAe;AAC9B,QAAI;AAAE,YAAM,UAAU,OAAO;AAAA,IAAG,SACzB,OAAO;AAAE,YAAM,WAAW,SAAS,KAAK;AAAG,iBAAW;AAAA,IAAG;AAAA,EAClE;AACA,SAAO,EAAE,SAAS;AACpB;AAEA,gBAAuB,MAAM,SAAyB,OAAO,KAAiB;AAC5E,UAAQ,OAAO,eAAe;AAC9B,MAAI,SAAS,KAAK;AAChB,eAAO,6BAAU,QAAQ,OAAO,QAAQ,MAAM;AAAA,EAChD,OAAO;AACL,UAAM,wBAAwB,SAAS,CAAC,IAAI,CAAC;AAC7C,UAAM,OAAO,OAAO,SAAS,IAAI;AACjC,UAAM,eAAe,MAAM,QAAQ,GAAG,kBAAkB,MAAM,EAAE,QAAQ,QAAQ,OAAO,CAAC,KAAK,QAAQ,GAAG;AACxG,QAAI,QAAQ,GAAG,cAAc,aAAa,kBAAkB,OAAO;AACjE,UAAI,UAAU;AACd,UAAI,UAAU;AACd,UAAI;AACF,yBAAiB,aAAS,6BAAU,QAAQ,GAAG,WAAW,MAAM,EAAE,QAAQ,QAAQ,OAAO,CAAC,GAAG,QAAQ,MAAM,GAAG;AAC5G,oBAAU;AACV,cAAI,MAAM,WAAY,WAAU;AAChC,gBAAM;AACN,oBAAU;AAAA,QACZ;AACA;AAAA,MACF,SAAS,OAAO;AACd,gBAAQ,OAAO,eAAe;AAC9B,YAAI,CAAC,WAAW,WAAW,EAAE,iBAAiB,8BAAY,MAAM,SAAS,UAAW,OAAM;AAAA,MAC5F;AAAA,IACF;AACA,QAAI,aAAa,SAAS,MAAO,OAAM,IAAI,0BAAQ,WAAW,EAAE,SAAS,YAAY,KAAK,CAAC;AAC3F,eAAO,6BAAU;AAAA,MACf,QAAQ,OAAO,aAAa,IAAI;AAC9B,cAAM,QAAQ,MAAM,QAAQ,GAAG,SAAS,MAAM,EAAE,QAAQ,QAAQ,QAAQ,UAAU,YAAY,CAAC;AAC/F,gBAAQ,OAAO,eAAe;AAC9B,YAAI,MAAM,aAAa,YAAa,OAAM,IAAI,0BAAQ,SAAS,EAAE,SAAS,YAAY,KAAK,CAAC;AAC5F,cAAM;AAAA,MACR;AAAA,IACF,GAAG,QAAQ,MAAM;AAAA,EACnB;AACF;AAEA,eAAsB,wBAAwB,SAAyB,OAAyC;AAC9G,QAAM,QAAQ,MAAM,OAAO,UAAQ,SAAS,GAAG;AAC/C,8DAA0B,SAAS,mBAAmB,CAAC,MAAM,SAAS,SAAS,OAAO,CAAC;AACvF,MAAI,CAAC,QAAQ,GAAG,gBAAiB;AACjC,aAAW,QAAQ,OAAO;AACxB,QAAI;AACF,YAAM,eAAe,MAAM,QAAQ,GAAG,gBAAgB,OAAO,SAAS,IAAI,GAAG,EAAE,QAAQ,QAAQ,OAAO,CAAC;AACvG,kEAA0B,SAAS,mBAAmB,CAAC,MAAM,GAAG,YAAY;AAAA,IAC9E,SAAS,OAAO;AACd,cAAQ,OAAO,eAAe;AAC9B,UAAI,OAAO,KAAK,MAAM,aAAa,OAAO,KAAK,MAAM,QAAS,OAAM;AAAA,IACtE;AAAA,EACF;AACF;AAEO,SAAS,YAAY,QAA+B,OAAO,OAAO,OAAO,CAAC,KAAK,UAAU,MAAM,MAAM,QAAQ,CAAC,GAAe;AAClI,QAAM,SAAS,IAAI,WAAW,IAAI;AAClC,MAAI,SAAS;AACb,aAAW,SAAS,QAAQ;AAAE,WAAO,IAAI,OAAO,MAAM;AAAG,cAAU,MAAM;AAAA,EAAQ;AACjF,SAAO;AACT;AAgBA,gBAAuB,MAAM,QAAoB,YAAY,IAAI,OAAsD;AACrH,QAAM,UAAU,IAAI,aAAa,WAAW;AAC5C,MAAI;AACF,qBAAiB,SAAS,QAAQ;AAChC,UAAI,QAAQ;AACZ,aAAO,QAAQ,MAAM,QAAQ;AAC3B,cAAM,SAAS,MAAM,QAAQ,WAAW,KAAK;AAC7C,YAAI,SAAS,EAAG;AAChB,cAAM,EAAE,OAAO,QAAQ,OAAO,OAAO,OAAO,OAAO,MAAM,GAAG,YAAY,KAAK;AAC7E,gBAAQ,SAAS;AAAA,MACnB;AACA,cAAQ,OAAO,OAAO,KAAK;AAAA,IAC7B;AACA,QAAI,QAAQ,KAAM,OAAM,EAAE,OAAO,QAAQ,OAAO,KAAK,GAAG,YAAY,MAAM;AAAA,EAC5E,UAAE;AAAU,YAAQ,MAAM;AAAA,EAAG;AAC/B;AAEO,SAAS,aAAyB;AAAE,aAAO,gCAAa,EAAE;AAAG;AAE7D,SAAS,gBAAgB,QAA6B,SAAiB,aAA0C;AACtH,MAAI,OAAO,WAAW,SAAU,QAAO,OAAO,MAAM,OAAO,EAAE,KAAK,WAAW;AAC7E,QAAM,SAAS,QAAQ,OAAO,OAAO;AACrC,MAAI,CAAC,OAAO,OAAQ,OAAM,IAAI,WAAW,oCAAoC;AAC7E,QAAM,cAAc,QAAQ,OAAO,WAAW;AAC9C,QAAM,SAAuB,CAAC;AAC9B,MAAI,QAAQ;AACZ,WAAS,SAAS,GAAG,UAAU,OAAO,SAAS,OAAO,UAAS;AAC7D,QAAI,OAAO,MAAM,CAAC,MAAM,UAAU,OAAO,SAAS,KAAK,MAAM,IAAI,GAAG;AAClE,aAAO,KAAK,OAAO,SAAS,OAAO,MAAM,GAAG,WAAW;AACvD,gBAAU,OAAO;AACjB,cAAQ;AAAA,IACV,MAAO;AAAA,EACT;AACA,SAAO,KAAK,OAAO,SAAS,KAAK,CAAC;AAClC,SAAO,YAAY,MAAM;AAC3B;AAEO,SAAS,YAAY,MAA2B,YAAY,OAAO,YAAY,OACpF,SAA2G;AAC3G,MAAI,WAAW,OAAO,SAAS,SAAU,QAAO,QAAQ,OAAO,IAAI;AACnE,MAAI,OAAO,SAAS,UAAU;AAC5B,UAAM,SAAuB,CAAC;AAC9B,UAAMC,WAAkC,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,MAAM,GAAG;AAC/G,aAAS,QAAQ,GAAG,QAAQ,KAAK,UAAS;AACxC,UAAI,KAAK,KAAK,MAAM,QAAQ,QAAQ,MAAM,KAAK,QAAQ;AACrD,cAAM,YAAY,OAAO,cAAc,KAAK,YAAY,KAAK,CAAE;AAC/D,eAAO,KAAK,QAAQ,OAAO,SAAS,CAAC;AAAG,iBAAS,UAAU;AAAQ;AAAA,MACrE;AACA,YAAM,OAAO,KAAK,QAAQ,CAAC;AAC3B,UAAI,SAAS,IAAK,QAAO,EAAE,OAAO,YAAY,MAAM,GAAG,MAAM,KAAK;AAClE,UAAIA,SAAQ,IAAI,MAAM,QAAW;AAAE,eAAO,KAAK,WAAW,GAAGA,SAAQ,IAAI,CAAC,CAAC;AAAG,iBAAS;AAAG;AAAA,MAAU;AACpG,YAAM,OAAO,KAAK,MAAM,QAAQ,CAAC;AACjC,YAAM,QAAQ,aAAa,YAAY,0CAA0C,mBAAmB,KAAK,IAAI,IAAI,iBAAiB,KAAK,IAAI;AAC3I,UAAI,OAAO;AAAE,eAAO,KAAK,WAAW,GAAG,SAAS,MAAM,CAAC,KAAK,MAAM,CAAC,KAAK,KAAK,CAAC,IAAI,GAAG,CAAC;AAAG,iBAAS,IAAI,MAAM,CAAC,EAAE;AAAQ;AAAA,MAAU;AACjI,YAAM,cAAc,wBAAwB,KAAK,IAAI;AACrD,UAAI,aAAa;AAAE,eAAO,KAAK,WAAW,GAAG,SAAS,YAAY,CAAC,GAAI,EAAE,CAAC,CAAC;AAAG,iBAAS,IAAI,YAAY,CAAC,EAAE;AAAQ;AAAA,MAAU;AAC5H,aAAO,KAAK,QAAQ,OAAO,KAAK,IAAI,EAAE,CAAC;AAAG,eAAS;AAAA,IACrD;AACA,WAAO,EAAE,OAAO,YAAY,MAAM,GAAG,MAAM,MAAM;AAAA,EACnD;AACA,QAAM,SAAS;AAEf,QAAM,QAAQ,IAAI,WAAW,OAAO,UAAU,WAAW,CAAC,QAAQ,OAAO,IAAI,EAAE;AAC/E,QAAM,UAAkC,EAAE,IAAI,GAAG,IAAI,GAAG,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK,GAAG,KAAK,IAAI,IAAI,GAAG;AAC5H,MAAI,OAAO;AACX,WAAS,QAAQ,GAAG,QAAQ,OAAO,UAAS;AAC1C,QAAI,OAAO,KAAK,MAAM,MAAM,QAAQ,MAAM,OAAO,QAAQ;AAAE,YAAM,MAAM,IAAI,OAAO,OAAO;AAAI;AAAA,IAAU;AACvG,UAAM,OAAO,OAAO,QAAQ,CAAC;AAC7B,QAAI,SAAS,GAAI,QAAO,EAAE,OAAO,MAAM,SAAS,GAAG,IAAI,GAAG,MAAM,KAAK;AACrE,QAAI,QAAQ,IAAI,MAAM,QAAW;AAAE,YAAM,MAAM,IAAI,QAAQ,IAAI;AAAG,eAAS;AAAG;AAAA,IAAU;AACxF,QAAI,YAAY,SAAS,MAAM,aAAa,QAAQ,MAAM,QAAQ,KAAK,QAAQ,MAAM,QAAQ,IAAI;AAC/F,UAAI,SAAS,SAAS,aAAa,SAAS,KAAK,IAAI;AACrD,YAAM,MAAM,KAAK,IAAI,OAAO,QAAQ,SAAS,CAAC;AAC9C,UAAIC,SAAQ;AACZ,aAAO,SAAS,OAAO,OAAO,MAAM,KAAM,MAAM,OAAO,MAAM,KAAM,GAAI,CAAAA,SAAQA,SAAQ,IAAI,OAAO,QAAQ,IAAK;AAC/G,YAAM,MAAM,IAAIA,SAAQ;AACxB,cAAQ;AACR;AAAA,IACF;AACA,QAAI,YAAY,SAAS,OAAO,SAAS,KAAK;AAC5C,YAAM,SAAS,SAAS,MAAM,IAAI;AAClC,UAAI,SAAS,QAAQ;AACrB,YAAM,MAAM,KAAK,IAAI,OAAO,QAAQ,SAAS,MAAM;AACnD,UAAIA,SAAQ;AACZ,aAAO,SAAS,KAAK;AACnB,cAAM,QAAQ,OAAO,MAAM;AAC3B,cAAM,SAAS,SAAS,MAAM,SAAS,KAAK,QAAQ,KAAK,SAAS,MAAM,SAAS,KAAK,QAAQ,KAAK,SAAS,MAAM,SAAS,MAAM,QAAQ,KAAK;AAC9I,YAAI,SAAS,EAAG;AAChB,QAAAA,SAAQA,SAAQ,KAAK;AACrB;AAAA,MACF;AACA,UAAI,WAAW,QAAQ,EAAG,SAAQ,aAAa,OAAO,aAAa,IAAI,CAAC;AAAA,WACnE;AAEH,YAAIA,SAAQ,YAAY;AACtB,cAAI,CAAC,QAAQ,QAAQA,SAAQ,KAAK;AAChC,kBAAM,UAAU,QAAQ,OAAO,KAAKA,UAAS,QAAS,MAAM,GAAG,GAAGA,OAAM,SAAS,EAAE,EAAE,YAAY,EAAE,SAASA,UAAS,QAAS,IAAI,GAAG,GAAG,CAAC,EAAE;AAC3I,kBAAM,IAAI,SAAS,IAAI;AACvB,oBAAQ,QAAQ;AAAA,UAClB,WAAWA,SAAQ,IAAK,OAAM,MAAM,IAAIA;AAAA,eACnC;AAEH,kBAAM,SAASA,SAAQ,OAAQ,IAAIA,SAAQ,QAAU,IAAIA,SAAQ,UAAW,IAAIA,SAAQ,WAAY,IAAI;AACxG,qBAAS,WAAW,SAAS,GAAG,WAAW,GAAG,YAAY;AACxD,oBAAM,OAAO,QAAQ,IAAI,MAAOA,SAAQ;AACxC,cAAAA,SAAQ,KAAK,MAAMA,SAAQ,EAAE;AAAA,YAC/B;AACA,kBAAM,IAAI,IAAK,OAAS,IAAI,SAAU,MAAQA;AAC9C,oBAAQ;AAAA,UACV;AAAA,QACF;AACA,gBAAQ;AACR;AAAA,MACF;AAAA,IACF;AACA,QAAI,SAAS,KAAK;AAChB,UAAI,SAAS,QAAQ;AACrB,YAAM,MAAM,KAAK,IAAI,OAAO,QAAQ,SAAS,CAAC;AAC9C,UAAIA,SAAQ;AACZ,aAAO,SAAS,KAAK;AACnB,cAAM,QAAQ,OAAO,MAAM;AAC3B,cAAM,SAAS,SAAS,MAAM,SAAS,KAAK,QAAQ,KAAK,SAAS,MAAM,SAAS,KAAK,QAAQ,KAAK,SAAS,MAAM,SAAS,MAAM,QAAQ,KAAK;AAC9I,YAAI,SAAS,EAAG;AAChB,QAAAA,SAAQA,SAAQ,KAAK;AACrB;AAAA,MACF;AACA,UAAI,SAAS,QAAQ,GAAG;AAAE,cAAM,MAAM,IAAIA;AAAO,gBAAQ;AAAQ;AAAA,MAAU;AAC3E,eAAS,aAAa,GAAG;AAAA,IAC3B;AACA,UAAM,MAAM,IAAI;AAChB,UAAM,MAAM,IAAI;AAChB,aAAS;AAAA,EACX;AACA,SAAO,EAAE,OAAO,MAAM,SAAS,GAAG,IAAI,GAAG,MAAM,MAAM;AACvD;",
+  "names": ["result", "value", "control", "value"]
+}

package/dist/safe-bash/chunks/{chunk-LZ7FUN6K.js → chunk-RHHDOA67.js}

@@ -14,20 +14,20 @@ import {
   parse,
   put,
   wellFormed
-} from "./chunk-VV24PRPB.js";
+} from "./chunk-AZQOEGP3.js";
 import {
   shellValueByteLength,
   value_exports
 } from "./chunk-ZY243FWG.js";
 import {
   pathOf
-} from "./chunk-OTM5RCWZ.js";
+} from "./chunk-QNEDWYC2.js";
 import {
   escapeText
-} from "./chunk-ZZ7JQBPX.js";
+} from "./chunk-4A2OLEML.js";
 import {
   yieldTurn
-} from "./chunk-YOK5UHA7.js";
+} from "./chunk-XKXFX3RH.js";
 import {
   contracts_exports
 } from "./chunk-J2E3MV3E.js";
@@ -3417,4 +3417,4 @@ export {
   createYqCommands,
   yqCommands
 };
-//# sourceMappingURL=chunk-LZ7FUN6K.js.map
+//# sourceMappingURL=chunk-RHHDOA67.js.map

package/dist/safe-bash/chunks/{chunk-DSCL3VA2.js → chunk-SJ3B26XV.js}

@@ -1,16 +1,16 @@
 import {
   pathOf
-} from "./chunk-VGJIDLZM.js";
+} from "./chunk-KS5VSJYM.js";
 import {
   writeDiagnostic
-} from "./chunk-WTZZX4LV.js";
+} from "./chunk-A4MB2KXV.js";
 import {
   createOutputOperation
 } from "./chunk-LV3A66Y2.js";
 import {
   inheritYieldCheckpoint,
   yieldTurn
-} from "./chunk-B6YFFKYG.js";
+} from "./chunk-X4I3RHTC.js";
 import {
   getCommandArguments
 } from "./chunk-P7NFUYPJ.js";
@@ -293,4 +293,4 @@ export {
   createLlmCommands,
   llmCommands
 };
-//# sourceMappingURL=chunk-DSCL3VA2.js.map
+//# sourceMappingURL=chunk-SJ3B26XV.js.map

package/dist/safe-bash/chunks/{chunk-6JBTVWHH.js → chunk-SWACYEIT.js}

@@ -14,22 +14,22 @@ import {
   parse,
   put,
   wellFormed
-} from "./chunk-RP5IZOOR.js";
+} from "./chunk-BJYV5J65.js";
 import {
   shellValueByteLength
 } from "./chunk-RA4KWAKW.js";
 import {
   pathOf
-} from "./chunk-VGJIDLZM.js";
+} from "./chunk-KS5VSJYM.js";
 import {
   escapeText
-} from "./chunk-WTZZX4LV.js";
+} from "./chunk-A4MB2KXV.js";
 import {
   createOutputOperation
 } from "./chunk-LV3A66Y2.js";
 import {
   yieldTurn
-} from "./chunk-B6YFFKYG.js";
+} from "./chunk-X4I3RHTC.js";
 import {
   commandRuntimeIdentity,
   getCommandArguments
@@ -3424,4 +3424,4 @@ export {
   createYqCommands,
   yqCommands
 };
-//# sourceMappingURL=chunk-6JBTVWHH.js.map
+//# sourceMappingURL=chunk-SWACYEIT.js.map

package/dist/safe-bash/chunks/{chunk-7UJW7TYR.js → chunk-TD6NWAUK.js}

@@ -10,8 +10,9 @@ import {
   publicDiagnosticMessage
 } from "./chunk-ITX6SBN6.js";
 import {
+  hasYieldCheckpoint,
   yieldTurn
-} from "./chunk-YOK5UHA7.js";
+} from "./chunk-XKXFX3RH.js";
 import {
   contracts_exports
 } from "./chunk-J2E3MV3E.js";
@@ -63,6 +64,8 @@ var RegexExecutionError = class extends PublicDiagnostic {
 };
 var matchRangeLimits = Object.freeze({ perRow: Infinity, perReply: Infinity });
 var trustedWorkerRequests = /* @__PURE__ */ new WeakSet();
+var trustedWorkerReplies = /* @__PURE__ */ new WeakSet();
+var trustedInputRows = /* @__PURE__ */ new WeakSet();
 var exprMatchCeilings = Object.freeze({
   maxPatternBytes: Infinity,
   maxSubjectBytes: Infinity,
@@ -225,6 +228,30 @@ function validateReply(value, id, rows, signal) {
     throw new RegexExecutionError("MATCH", reply.error);
   }
   if (!("results" in reply) || !Array.isArray(reply.results) || reply.results.length !== rows.length) throw new RegexExecutionError("PROTOCOL", "invalid reply rows");
+  if (trustedWorkerReplies.has(reply)) {
+    const resultCount2 = reply.results.length;
+    const results2 = new Array(resultCount2);
+    let total2 = 0;
+    for (let index = 0; index < resultCount2; index++) {
+      const ranges = reply.results[index];
+      const length = ranges.length;
+      if (length === 0) {
+        results2[index] = emptyMatches;
+        continue;
+      }
+      const count = length >> 1;
+      if (count > matchRangeLimits.perRow || count > matchRangeLimits.perReply - total2) {
+        throw new RegexExecutionError("PROTOCOL", "match range limit exceeded");
+      }
+      total2 += count;
+      const result = new Array(count);
+      for (let offset = 0, out = 0; offset < length; offset += 2, out++) {
+        result[out] = { start: ranges[offset], end: ranges[offset + 1] };
+      }
+      results2[index] = result;
+    }
+    return results2;
+  }
   let total = 0;
   const resultCount = reply.results.length;
   const lengths = new Array(resultCount);
@@ -8438,9 +8465,10 @@ var EreLedger = class {
     }
     this.#usage.work += amount;
   }
-  workAllowanceUntilCheckpoint() {
+  workAllowanceUntilCheckpoint(signal) {
     const untilLimit = this.limits.work - this.#usage.work;
-    const untilYield = 256 - (this.#usage.work - this.#lastYield);
+    const interval = hasYieldCheckpoint(signal) ? 256 : 16384;
+    const untilYield = interval - (this.#usage.work - this.#lastYield);
     const min = untilLimit < untilYield ? untilLimit : untilYield;
     return min > 0 ? min : 0;
   }
@@ -8452,7 +8480,8 @@ var EreLedger = class {
   }
   checkpoint(signal) {
     this.check(signal);
-    if (this.#usage.work - this.#lastYield >= 256) {
+    const interval = hasYieldCheckpoint(signal) ? 256 : 16384;
+    if (this.#usage.work - this.#lastYield >= interval) {
       this.#lastYield = this.#usage.work;
       return yieldTurn(signal).then(() => {
         this.check(signal);
@@ -8747,10 +8776,34 @@ init_platform();
 function invalidUtf8() {
   throw new PublicDiagnostic("bounded regex unsupported: literal patterns and subjects require valid non-NUL UTF-8 bytes");
 }
-async function validateUtf8(input, ledger, signal) {
+function validateUtf8(input, ledger, signal) {
+  if (typeof input !== "string") {
+    const len = input.length;
+    if (len === 0) {
+      ledger.check(signal);
+      return void 0;
+    }
+    if (ledger.workAllowanceUntilCheckpoint(signal) >= len) {
+      let ascii = true;
+      for (let i = 0; i < len; i++) {
+        const b = input[i];
+        if (b === 0 || b >= 128) {
+          ascii = false;
+          break;
+        }
+      }
+      if (ascii) {
+        ledger.chargeWork(len, signal);
+        return ledger.checkpoint(signal);
+      }
+    }
+  }
+  return validateUtf8Async(input, ledger, signal);
+}
+async function validateUtf8Async(input, ledger, signal) {
   for (let index = 0; index < input.length; ) {
     if (typeof input !== "string") {
-      const allowance = ledger.workAllowanceUntilCheckpoint();
+      const allowance = ledger.workAllowanceUntilCheckpoint(signal);
       if (allowance > 1) {
         const maxRun = Math.min(input.length, index + allowance);
         let scan = index;
@@ -9293,7 +9346,20 @@ function options(input) {
   }
   return Object.freeze(result);
 }
-function descriptor(value, limits) {
+function descriptor(value, limits, trusted = false) {
+  if (trusted && value !== null && typeof value === "object") {
+    const d = value;
+    if (d.kind === "rg" || d.kind === "grep") {
+      if (d.patterns.length > limits.maxPatterns) fail("limit", "pattern count limit exceeded");
+      let bytes3 = 0;
+      for (let index = 0; index < d.patterns.length; index++) {
+        const pattern = d.patterns[index];
+        if (pattern.length > limits.maxPatternBytes - bytes3) fail("limit", "aggregate pattern byte limit exceeded");
+        bytes3 += pattern.length;
+      }
+      return d;
+    }
+  }
   if (value === null || typeof value !== "object") fail("protocol", "invalid descriptor");
   const kind = Object.getOwnPropertyDescriptor(value, "kind");
   if (!kind || !("value" in kind)) fail("protocol", "invalid descriptor kind");
@@ -9332,7 +9398,7 @@ function descriptor(value, limits) {
 function admit(input, limits, signal) {
   const trusted = trustedWorkerRequests.has(input);
   if (!trusted) record(input, ["id", "descriptor", "rows"]);
-  const selected = descriptor(input.descriptor, limits);
+  const selected = descriptor(input.descriptor, limits, trusted);
   if (trusted && Array.isArray(input.rows)) {
     if (input.rows.length > limits.maxRows) fail("limit", "row count limit exceeded");
   } else {
@@ -9551,7 +9617,43 @@ async function compileLiteral(bytes2, ledger, signal, insensitive2 = false) {
   }
   return { bytes: bytes2, fallback, insensitive: insensitive2 };
 }
-async function literalStart(program, subject, whole, word, ledger, signal, from = 0) {
+function literalStart(program, subject, whole, word, ledger, signal, from = 0) {
+  const { bytes: bytes2, fallback } = program;
+  const patLen = bytes2.length;
+  const subLen = subject.length;
+  if (!program.insensitive && patLen > 0 && ledger.workAllowanceUntilCheckpoint(signal) >= (subLen - from) * 2 + 2) {
+    ledger.chargeWork(1, signal);
+    if (whole && (from !== 0 || patLen !== subLen) || patLen > subLen - from) return -1;
+    const firstByte = bytes2[0];
+    for (let index = from, prefix = 0; index < subLen; ) {
+      if (prefix === 0) {
+        let scan = index;
+        while (scan < subLen && subject[scan] !== firstByte) scan++;
+        if (scan > index) {
+          ledger.chargeWork(scan - index, signal);
+          index = scan;
+          if (index >= subLen) break;
+        }
+      }
+      ledger.chargeWork(1, signal);
+      if (subject[index] === bytes2[prefix]) {
+        index++;
+        if (++prefix === patLen) {
+          const start = index - prefix;
+          if (!word || !isAsciiWord(subject[start - 1] ?? -1) && !isAsciiWord(subject[index] ?? -1)) return start;
+          prefix = fallback[prefix - 1];
+        }
+      } else if (prefix > 0) {
+        prefix = fallback[prefix - 1];
+      } else {
+        index++;
+      }
+    }
+    return -1;
+  }
+  return literalStartAsync(program, subject, whole, word, ledger, signal, from);
+}
+async function literalStartAsync(program, subject, whole, word, ledger, signal, from = 0) {
   const { bytes: bytes2, fallback } = program;
   ledger.charge("work", 1, signal);
   await ledger.checkpoint(signal);
@@ -9566,7 +9668,7 @@ async function literalStart(program, subject, whole, word, ledger, signal, from
   }
   for (let index = from, prefix = 0; index < subject.length; ) {
     if (prefix === 0 && !program.insensitive) {
-      const allowance = ledger.workAllowanceUntilCheckpoint();
+      const allowance = ledger.workAllowanceUntilCheckpoint(signal);
       if (allowance > 1) {
         const firstByte = bytes2[0];
         const maxRun = Math.min(subject.length, index + allowance);
@@ -9655,8 +9757,12 @@ async function executeLiteral(input, signal, fold) {
   const results = [];
   const usage = { count: 0 };
   for (const row of rows) {
-    if (selected.kind === "rg") await validateUtf8(row.bytes, ledger, signal);
-    else {
+    if (selected.kind === "rg") {
+      const pendingUtf8 = validateUtf8(row.bytes, ledger, signal);
+      if (pendingUtf8) await pendingUtf8;
+    } else if (ledger.workAllowanceUntilCheckpoint(signal) >= row.bytes.length) {
+      ledger.charge("work", row.bytes.length, signal);
+    } else {
       for (let index = 0; index < row.bytes.length; index++) {
         ledger.charge("work", 1, signal);
         await ledger.checkpoint(signal);
@@ -9677,7 +9783,8 @@ async function executeLiteral(input, signal, fold) {
     let start = -1;
     let end = -1;
     for (const program of programs2) {
-      const candidate = await literalStart(program, row.bytes, selected.whole, selected.word, ledger, signal);
+      const candidateOrPromise = literalStart(program, row.bytes, selected.whole, selected.word, ledger, signal);
+      const candidate = typeof candidateOrPromise === "number" ? candidateOrPromise : await candidateOrPromise;
       if (candidate < 0) continue;
       if (start < 0 || candidate < start) {
         start = candidate;
@@ -9822,6 +9929,9 @@ var CooperativeWorker = class {
       try {
         this.#controller.signal.throwIfAborted();
         reply = owned ? "subject" in owned ? await executeExpr(owned, this.#controller.signal) : owned.descriptor.kind === "glob" ? await executeBoundedGlobs(owned, this.#controller.signal) : await execute(owned, this.#controller.signal) : { id, error: failure };
+        if (owned && !("subject" in owned) && !("error" in reply)) {
+          trustedWorkerReplies.add(reply);
+        }
       } catch (error) {
         if (!(error instanceof ExprMatchError || error instanceof PublicDiagnostic || error instanceof EreSyntaxError || error instanceof EreUnsupportedError || error instanceof EreProfileLimitError || error instanceof EreUsageUnknownError)) {
           owned = void 0;
@@ -10041,7 +10151,7 @@ var RegexExecutor = class {
       });
       Object.assign(ownedDescriptor, { globOptions });
     }
-    const ownedRows = rows.map((row) => {
+    const ownedRows = trustedInputRows.has(rows) ? rows : rows.map((row) => {
       signal.throwIfAborted();
       return { ...row, bytes: new Uint8Array(row.bytes) };
     });
@@ -10192,48 +10302,6 @@ var RegexSession = class {
     });
   }
 };
-var AvailableRecords = class {
-  constructor(delimiter, maxLineBytes, extraDelimiter = -1) {
-    this.delimiter = delimiter;
-    this.maxLineBytes = maxLineBytes;
-    this.extraDelimiter = extraDelimiter;
-  }
-  delimiter;
-  maxLineBytes;
-  extraDelimiter;
-  chunk = new Uint8Array(0);
-  offset = 0;
-  async *source(source) {
-    for await (const chunk of source) {
-      this.chunk = Uint8Array.from(chunk);
-      this.offset = 0;
-      yield this.chunk;
-    }
-  }
-  end() {
-    for (let offset = this.offset; offset < this.chunk.length; offset++) {
-      if (this.chunk[offset] === this.delimiter || this.chunk[offset] === this.extraDelimiter) return offset;
-    }
-    return -1;
-  }
-  async *batches(source, size, maxRecords = () => 128) {
-    let batch = [];
-    let bytes2 = 0;
-    for await (const line of source) {
-      const end = this.end();
-      this.offset = end < 0 ? this.chunk.length : end + 1;
-      batch.push(line);
-      bytes2 += size(line);
-      const next = this.end();
-      if (batch.length >= maxRecords() || bytes2 >= 64 * 1024 || next < 0 || bytes2 + next - this.offset > 64 * 1024 || next - this.offset > this.maxLineBytes) {
-        yield batch;
-        batch = [];
-        bytes2 = 0;
-      }
-    }
-    if (batch.length) yield batch;
-  }
-};
 
 // packages/safe-bash/src/commands/csplit/command.ts
 init_platform();
@@ -12487,12 +12555,12 @@ function csplitCommands(options2 = {}) {
 
 export {
   RegexExecutionError,
+  trustedInputRows,
   exprMatchCeilings,
   ExprMatchError,
   withRegexSession,
   RegexExecutor,
   RegexSession,
-  AvailableRecords,
   reverseEmacsSteps,
   EreSyntaxError,
   EreUnsupportedError,
@@ -12507,4 +12575,4 @@ export {
   createCsplitCommands,
   csplitCommands
 };
-//# sourceMappingURL=chunk-7UJW7TYR.js.map
+//# sourceMappingURL=chunk-TD6NWAUK.js.map