@poe-platform/safe-bash 0.1.799 → 0.1.800

package/dist/safe-bash/command-chunks/chunk-WB5SVIG7.js

@@ -0,0 +1,1034 @@
+import {
+  parseSelection,
+  resolveSelection
+} from "./chunk-LCF3OB7P.js";
+import {
+  checkedAdd,
+  inferDelimiter,
+  unsigned
+} from "./chunk-QI7LGHJJ.js";
+import {
+  boundedSort
+} from "./chunk-HEYKESED.js";
+import {
+  Scanner
+} from "./chunk-QUENU6GM.js";
+import {
+  XanError
+} from "./chunk-QOKBZFFD.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-xan/src/commands.ts
+init_buffer();
+
+// packages/safe-bash-command-xan/src/condition.ts
+init_buffer();
+async function condition(expression, headers, noHeaders, budget, scope) {
+  if (expression === void 0) return void 0;
+  budget.bound("maxSelectorBytes", await budget.textSize(expression));
+  let split = -1;
+  let operator = "";
+  for (let offset = 0; offset < expression.length; offset++) {
+    budget.work();
+    if (["=", "!", "<", ">"].includes(expression[offset])) {
+      split = offset;
+      operator = expression[offset];
+      if (expression[offset + 1] === "=") operator += "=";
+      break;
+    }
+  }
+  if (split < 0 || !["==", "!=", "<", "<=", ">", ">="].includes(operator)) throw new XanError("unsupported condition: expected COLUMN comparison LITERAL");
+  const name = expression.slice(0, split).trim();
+  const literal = expression.slice(split + operator.length).trim();
+  if (noHeaders) throw new XanError("named conditions require headers");
+  const nameBytes = await budget.encode(name);
+  let position = -1;
+  try {
+    for (let index = 0; index < (headers?.cells.length ?? 0); index++) {
+      const bytes = headers.cells[index].decoded.view();
+      if (bytes.length !== nameBytes.length) continue;
+      let same = true;
+      for (let offset = 0; offset < bytes.length; offset++) {
+        budget.work();
+        if (bytes[offset] !== nameBytes[offset]) same = false;
+      }
+      if (same) {
+        position = index;
+        break;
+      }
+    }
+  } finally {
+    budget.release(nameBytes.length);
+  }
+  if (position < 0) throw new XanError(`unknown condition column: ${name}`);
+  let text;
+  let numeric = false;
+  if (literal.startsWith('"')) {
+    try {
+      const value = JSON.parse(literal);
+      if (typeof value !== "string") throw new Error();
+      text = value;
+    } catch {
+      throw new XanError("invalid condition string literal");
+    }
+  } else if (literal.startsWith("'") && literal.endsWith("'") && literal.length >= 2) text = literal.slice(1, -1);
+  else {
+    if (!literal || !Number.isFinite(Number(literal))) throw new XanError("unsupported condition literal");
+    text = literal;
+    numeric = true;
+  }
+  const right = await budget.encode(text);
+  scope.own(() => budget.release(right.length));
+  return async (row) => {
+    const left = row.cells[position].decoded.view();
+    let order = 0;
+    if (numeric) {
+      budget.hold(left.length * 2);
+      try {
+        let value = "";
+        for (let offset = 0; offset < left.length; offset++) {
+          budget.work();
+          value += String.fromCharCode(left[offset]);
+          if ((offset & 1023) === 0) {
+            const c = budget.checkpoint();
+            if (c) await c;
+          }
+        }
+        const number = Number(value);
+        if (!value.trim() || !Number.isFinite(number)) throw new XanError("condition requires a numeric cell");
+        order = number < Number(text) ? -1 : number > Number(text) ? 1 : 0;
+      } finally {
+        budget.release(left.length * 2);
+      }
+    } else {
+      for (let offset = 0; offset < Math.min(left.length, right.length); offset++) {
+        budget.work();
+        if (left[offset] !== right[offset]) {
+          order = left[offset] < right[offset] ? -1 : 1;
+          break;
+        }
+        if ((offset & 1023) === 0) {
+          const c = budget.checkpoint();
+          if (c) await c;
+        }
+      }
+      if (!order) order = left.length < right.length ? -1 : left.length > right.length ? 1 : 0;
+    }
+    return operator === "==" ? order === 0 : operator === "!=" ? order !== 0 : operator === "<" ? order < 0 : operator === "<=" ? order <= 0 : operator === ">" ? order > 0 : order >= 0;
+  };
+}
+
+// packages/safe-bash-command-xan/src/transform.ts
+init_buffer();
+
+// packages/safe-bash-command-xan/src/cells.ts
+init_buffer();
+async function* emitted(bytes, budget) {
+  try {
+    yield bytes;
+  } finally {
+    budget.release(bytes.length);
+  }
+}
+async function* textRow(values, writer, budget) {
+  const owned = [];
+  budget.hold(values.length * 32);
+  try {
+    const cells = [];
+    for (const value of values) {
+      if (typeof value === "string") {
+        const bytes = await budget.encode(value);
+        owned.push(bytes);
+        cells.push(bytes);
+      } else cells.push(value);
+    }
+    yield* emitted(await writer.values(cells), budget);
+  } finally {
+    for (const bytes of owned) budget.release(bytes.length);
+    budget.release(values.length * 32);
+  }
+}
+async function compareBytes(left, right, budget) {
+  for (let i = 0; i < Math.min(left.length, right.length); i++) {
+    budget.work();
+    if (left[i] !== right[i]) return left[i] < right[i] ? -1 : 1;
+    if ((i & 1023) === 0) {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+  }
+  return Math.sign(left.length - right.length);
+}
+function cellText(bytes, budget) {
+  budget.work(bytes.length);
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new XanError("cell is not valid UTF-8");
+  }
+}
+function decimalNumber(text, budget) {
+  let offset = text[0] === "+" || text[0] === "-" ? 1 : 0;
+  let digits = 0;
+  while (offset < text.length && text[offset] >= "0" && text[offset] <= "9") {
+    offset++;
+    digits++;
+    budget.work();
+  }
+  if (text[offset] === ".") {
+    offset++;
+    while (offset < text.length && text[offset] >= "0" && text[offset] <= "9") {
+      offset++;
+      digits++;
+      budget.work();
+    }
+  }
+  if (!digits) return void 0;
+  if (text[offset] === "e" || text[offset] === "E") {
+    offset++;
+    if (text[offset] === "+" || text[offset] === "-") offset++;
+    const start = offset;
+    while (offset < text.length && text[offset] >= "0" && text[offset] <= "9") {
+      offset++;
+      budget.work();
+    }
+    if (offset === start) return void 0;
+  }
+  if (offset !== text.length) return void 0;
+  const value = Number(text);
+  return Number.isFinite(value) ? value : void 0;
+}
+
+// packages/safe-bash-command-xan/src/summary.ts
+init_buffer();
+async function* summarize(args, rows2, first, selected, budget, writer) {
+  const options = args.options;
+  let held = selected.length * 256;
+  budget.hold(held);
+  const hold = (size) => {
+    budget.hold(size);
+    held += size;
+  };
+  const states = selected.map(() => ({
+    count: 0,
+    empty: 0,
+    numeric: 0,
+    sum: 0,
+    mean: 0,
+    m2: 0,
+    min: Infinity,
+    max: -Infinity,
+    minLength: Infinity,
+    maxLength: 0,
+    first: void 0,
+    last: void 0,
+    types: /* @__PURE__ */ new Set(),
+    frequencies: /* @__PURE__ */ new Map()
+  }));
+  try {
+    for await (const row of rows2) {
+      try {
+        for (let j = 0; j < selected.length; j++) {
+          budget.work();
+          const state = states[j], bytes = row.cells[selected[j]].decoded.view();
+          state.minLength = Math.min(state.minLength, bytes.length);
+          state.maxLength = Math.max(state.maxLength, bytes.length);
+          if (args.command === "freq") {
+            if (!bytes.length && options.has("no-extra")) continue;
+            hold(bytes.length * 4 + 64);
+            let key = "";
+            for (let i = 0; i < bytes.length; i++) {
+              budget.work();
+              key += String.fromCharCode(bytes[i]);
+              if ((i & 1023) === 0) {
+                const c = budget.checkpoint();
+                if (c) await c;
+              }
+            }
+            const existing = state.frequencies.get(key);
+            if (existing) {
+              existing.count++;
+              budget.release(bytes.length * 4 + 64);
+              held -= bytes.length * 4 + 64;
+            } else state.frequencies.set(key, { bytes: bytes.slice(), count: 1 });
+            continue;
+          }
+          if (!bytes.length) {
+            state.empty++;
+            state.types.add("empty");
+          } else {
+            state.count++;
+            if (!state.first || await compareBytes(bytes, state.first, budget) < 0) {
+              hold(bytes.length);
+              if (state.first) {
+                held -= state.first.length;
+                budget.release(state.first.length);
+              }
+              state.first = bytes.slice();
+            }
+            if (!state.last || await compareBytes(bytes, state.last, budget) > 0) {
+              hold(bytes.length);
+              if (state.last) {
+                held -= state.last.length;
+                budget.release(state.last.length);
+              }
+              state.last = bytes.slice();
+            }
+          }
+          budget.hold(bytes.length * 4);
+          try {
+            const text = cellText(bytes, budget), parsed = decimalNumber(text, budget);
+            const numeric = parsed !== void 0, value = parsed ?? 0;
+            if (numeric) {
+              state.types.add(Number.isInteger(value) && !text.includes(".") && !text.toLowerCase().includes("e") ? "int" : "float");
+              state.sum += value;
+              state.min = Math.min(state.min, value);
+              state.max = Math.max(state.max, value);
+            } else if (text) state.types.add("string");
+            if (numeric || !bytes.length && options.has("nulls")) {
+              state.numeric++;
+              const delta = value - state.mean;
+              state.mean += delta / state.numeric;
+              state.m2 += delta * (value - state.mean);
+            }
+          } finally {
+            budget.release(bytes.length * 4);
+          }
+        }
+      } finally {
+        row.free();
+      }
+    }
+    if (args.command === "freq") {
+      yield* textRow(["field", "value", "count"], writer, budget);
+      const limit = options.has("all") ? 0n : await unsigned(options.get("limit") ?? "10", "--limit", budget);
+      for (let j = 0; j < selected.length; j++) {
+        const state = states[j];
+        budget.hold(state.frequencies.size * 32);
+        try {
+          const entries = [...state.frequencies.values()];
+          await boundedSort(entries, 32, budget, async (a, b) => b.count - a.count || await compareBytes(a.bytes, b.bytes, budget));
+          const name = args.noHeaders ? String(selected[j]) : first.cells[selected[j]].decoded.view();
+          let remaining = 0;
+          for (let i = 0; i < entries.length; i++) {
+            budget.work();
+            const entry = entries[i];
+            if (limit && BigInt(i) >= limit) {
+              remaining += entry.count;
+              continue;
+            }
+            yield* textRow([name, entry.bytes.length ? entry.bytes : "<empty>", String(entry.count)], writer, budget);
+          }
+          if (remaining && !options.has("no-extra")) yield* textRow([name, "<rest>", String(remaining)], writer, budget);
+        } finally {
+          budget.release(state.frequencies.size * 32);
+        }
+      }
+    } else {
+      yield* textRow(["field", "count", "count_empty", "type", "types", "sum", "mean", "variance", "stddev", "min", "max", "lex_first", "lex_last", "min_length", "max_length"], writer, budget);
+      for (let j = 0; j < selected.length; j++) {
+        const state = states[j], types = ["string", "float", "int", "empty"].filter((type2) => state.types.has(type2));
+        const type = state.types.has("string") ? state.types.has("int") || state.types.has("float") ? "mixed" : "string" : state.types.has("float") ? "float" : state.types.has("int") ? "int" : state.types.has("empty") ? "empty" : "";
+        const variance = state.numeric ? Math.max(0, state.m2 / state.numeric) : 0;
+        const number = (value) => state.numeric ? String(value) : "";
+        yield* textRow([
+          args.noHeaders ? String(selected[j]) : first.cells[selected[j]].decoded.view(),
+          String(state.count),
+          String(state.empty),
+          type,
+          types.join("|"),
+          String(state.sum),
+          number(state.mean),
+          number(variance),
+          number(Math.sqrt(variance)),
+          Number.isFinite(state.min) ? String(state.min) : "",
+          Number.isFinite(state.max) ? String(state.max) : "",
+          state.first ?? "",
+          state.last ?? "",
+          Number.isFinite(state.minLength) ? String(state.minLength) : "",
+          state.count + state.empty ? String(state.maxLength) : ""
+        ], writer, budget);
+      }
+    }
+  } finally {
+    budget.release(held);
+  }
+}
+
+// packages/safe-bash-command-xan/src/transform.ts
+function numericCell(bytes, budget) {
+  budget.hold(bytes.length * 4);
+  try {
+    const value = decimalNumber(cellText(bytes, budget), budget);
+    if (value === void 0) throw new XanError("could not parse cell as number");
+    return value;
+  } finally {
+    budget.release(bytes.length * 4);
+  }
+}
+async function positions(selection, first, args, budget) {
+  budget.hold((first?.width ?? 0) * 32);
+  try {
+    return await resolveSelection(await parseSelection(selection, budget), first?.cells.map((cell) => cell.decoded.view()) ?? [], args.noHeaders, budget);
+  } finally {
+    budget.release((first?.width ?? 0) * 32);
+  }
+}
+async function* data(scanner, first, noHeaders) {
+  let row = noHeaders ? first : await scanner.next();
+  try {
+    while (row) {
+      if (row.width !== first?.width) throw new XanError(`CSV error: record ${row.number}: inconsistent field count`);
+      yield row;
+      row = await scanner.next();
+    }
+  } finally {
+    row?.free();
+  }
+}
+async function contains(bytes, pattern, exact, budget) {
+  if (exact && bytes.length !== pattern.length) return false;
+  for (let start = 0; start <= bytes.length - pattern.length; start++) {
+    let same = true;
+    for (let i = 0; i < pattern.length; i++) {
+      budget.work();
+      if (bytes[start + i] !== pattern[i]) {
+        same = false;
+        break;
+      }
+      if ((i & 1023) === 0) {
+        const c2 = budget.checkpoint();
+        if (c2) await c2;
+      }
+    }
+    if (same) return true;
+    budget.work();
+    const c = budget.checkpoint();
+    if (c) await c;
+  }
+  return false;
+}
+async function* transformRows(args, scope, budget, writer) {
+  const options = args.options;
+  const scanner = scope.open(args.inputs[0], args);
+  const first = await scanner.next();
+  if (first) scope.own(first.free);
+  const selected = await positions(args.selection, first, args, budget);
+  const source = data(scanner, first, args.noHeaders);
+  const retained = [];
+  const cleanup = () => {
+    for (const row of retained) {
+      row.free();
+      budget.release(32);
+    }
+    retained.length = 0;
+  };
+  scope.own(cleanup);
+  try {
+    if (args.command === "join") {
+      yield* join(args, source, first, selected, scope, budget, writer);
+      return;
+    }
+    if (args.command === "freq" || args.command === "stats") {
+      yield* summarize(args, source, first, selected, budget, writer);
+      return;
+    }
+    if (args.command === "rename") {
+      const bytes = await budget.encode(args.operand);
+      const names = new Scanner({ async *[Symbol.asyncIterator]() {
+        yield bytes;
+      } }, 44, "rename", budget);
+      let replacement;
+      try {
+        replacement = await names.next();
+        const extra = await names.next();
+        if (extra) extra.free();
+        if (replacement?.width !== selected.length || extra) throw new XanError("replacement names must match selected columns");
+        budget.hold(selected.length * 32 + (first?.width ?? 0) * 32);
+        try {
+          const replacements = new Map(selected.map((column, index) => [column, replacement.cells[index].decoded.view()]));
+          if (replacements.size !== selected.length) throw new XanError("rename selection contains duplicate columns");
+          yield* textRow(first?.cells.map((cell, i) => replacements.get(i) ?? (args.noHeaders ? String(i) : cell.decoded.view())) ?? [], writer, budget);
+        } finally {
+          budget.release(selected.length * 32 + (first?.width ?? 0) * 32);
+        }
+      } finally {
+        replacement?.free();
+        await names.close();
+        budget.release(bytes.length);
+      }
+    } else if (!args.noHeaders && first) yield* emitted(await writer.row(first.cells), budget);
+    const predicate = args.command === "filter" ? await condition(args.operand, first, args.noHeaders, budget, scope) : void 0;
+    const pattern = args.command === "search" ? await budget.encode(options.has("ignore-case") ? args.operand.toLowerCase() : args.operand) : void 0;
+    if (pattern) scope.own(() => budget.release(pattern.length));
+    const limit = options.has("limit") ? await unsigned(options.get("limit"), "--limit", budget) : void 0;
+    let matches = 0n;
+    for await (const row of source) {
+      let held = false;
+      try {
+        if (args.command === "sort" || args.command === "reverse") {
+          if (options.has("numeric")) for (const position of selected) numericCell(row.cells[position].decoded.view(), budget);
+          budget.hold(32);
+          retained.push(row);
+          held = true;
+          continue;
+        }
+        let match = predicate ? await predicate(row) : true;
+        if (pattern) {
+          match = options.has("every-column");
+          for (const position of selected) {
+            let bytes = row.cells[position].decoded.view();
+            let folded;
+            try {
+              if (options.has("ignore-case")) {
+                const size = bytes.length * 8;
+                budget.hold(size);
+                try {
+                  folded = await budget.encode(cellText(bytes, budget).toLowerCase());
+                } finally {
+                  budget.release(size);
+                }
+                bytes = folded;
+              }
+              const found = await contains(bytes, pattern, options.has("exact"), budget);
+              if (options.has("every-column") ? !found : found) {
+                match = found;
+                break;
+              }
+            } finally {
+              if (folded) budget.release(folded.length);
+            }
+          }
+        }
+        if (options.has("invert-match")) match = !match;
+        if (match) {
+          if (limit !== void 0 && matches >= limit) break;
+          yield* emitted(await writer.row(row.cells), budget);
+          matches++;
+          if (limit !== void 0 && matches >= limit) break;
+        }
+      } finally {
+        if (!held) row.free();
+      }
+    }
+    const compare = async (left, right) => {
+      for (const position of selected) {
+        const a = left.cells[position].decoded.view(), b = right.cells[position].decoded.view();
+        let order;
+        if (options.has("numeric")) {
+          order = Math.sign(numericCell(a, budget) - numericCell(b, budget));
+        } else order = await compareBytes(a, b, budget);
+        if (order) return options.has("reverse") ? -order : order;
+      }
+      return 0;
+    };
+    if (args.command === "sort") await boundedSort(retained, 32, budget, compare);
+    for (let i = 0; i < retained.length; i++) {
+      budget.work();
+      const c = budget.checkpoint();
+      if (c) await c;
+      const row = retained[args.command === "reverse" ? retained.length - i - 1 : i];
+      if (options.has("uniq") && i && await compare(retained[i - 1], row) === 0) continue;
+      yield* emitted(await writer.row(row.cells), budget);
+    }
+  } finally {
+    await source.return(void 0);
+    cleanup();
+    first?.free();
+    await scanner.close();
+  }
+}
+async function* join(args, left, first, leftKeys, scope, budget, writer) {
+  const options = args.options;
+  const scanner = scope.open(args.inputs[1], args);
+  const rightFirst = await scanner.next();
+  if (rightFirst) scope.own(rightFirst.free);
+  const rightKeys = await positions(args.rightSelection ?? "", rightFirst, args, budget);
+  if (!options.has("cross") && leftKeys.length !== rightKeys.length) throw new XanError("join key selections have different widths");
+  let drop = options.get("drop-key") ?? "none";
+  if (!options.has("drop-key") && !args.noHeaders && !options.has("ignore-case") && !options.has("full") && !options.has("cross") && !options.has("semi") && !options.has("anti")) {
+    let same = true;
+    for (let i = 0; i < leftKeys.length; i++) if (await compareBytes(first.cells[leftKeys[i]].decoded.view(), rightFirst.cells[rightKeys[i]].decoded.view(), budget)) same = false;
+    if (same) drop = options.has("right") ? "left" : "right";
+  }
+  const lcols = await positions("", first, args, budget), rcols = await positions("", rightFirst, args, budget);
+  budget.hold((lcols.length + rcols.length + leftKeys.length + rightKeys.length) * 64);
+  const leftSet = new Set(leftKeys), rightSet = new Set(rightKeys);
+  budget.work(leftKeys.length + rightKeys.length);
+  const keepLeft = [], keepRight = [];
+  for (const i of lcols) {
+    budget.work();
+    if (!["left", "both"].includes(drop) || !leftSet.has(i)) keepLeft.push(i);
+    const c = budget.checkpoint();
+    if (c) await c;
+  }
+  for (const i of rcols) {
+    budget.work();
+    if (!["right", "both"].includes(drop) || !rightSet.has(i)) keepRight.push(i);
+    const c = budget.checkpoint();
+    if (c) await c;
+  }
+  const semi = options.has("semi") || options.has("anti");
+  const index = /* @__PURE__ */ new Map(), rows2 = [], matched = /* @__PURE__ */ new Set();
+  let held = 0;
+  const hold = (bytes) => {
+    budget.hold(bytes);
+    held += bytes;
+  };
+  const key = async (row, columns) => {
+    let result = "", nonempty = false;
+    for (const i of columns) {
+      const bytes = row.cells[i].decoded.view();
+      nonempty ||= bytes.length > 0;
+      let value = "";
+      if (options.has("ignore-case")) value = cellText(bytes, budget).toLowerCase();
+      else for (let j = 0; j < bytes.length; j++) {
+        budget.work();
+        value += String.fromCharCode(bytes[j]);
+        if ((j & 1023) === 0) {
+          const c = budget.checkpoint();
+          if (c) await c;
+        }
+      }
+      result += `${value.length}:${value}`;
+    }
+    return nonempty || options.has("nulls") ? result : void 0;
+  };
+  const output = async function* (a, b) {
+    budget.hold((keepLeft.length + keepRight.length) * 32);
+    try {
+      yield* textRow([...keepLeft.map((i) => a?.cells[i]?.decoded.view() ?? ""), ...semi ? [] : keepRight.map((i) => b?.cells[i]?.decoded.view() ?? "")], writer, budget);
+    } finally {
+      budget.release((keepLeft.length + keepRight.length) * 32);
+    }
+  };
+  try {
+    if (!args.noHeaders) yield* output(first, rightFirst);
+    for await (const row of data(scanner, rightFirst, args.noHeaders)) {
+      let retained = false;
+      try {
+        hold(row.cells.reduce((n, cell) => n + cell.decoded.length * 8 + 64, 128));
+        rows2.push(row);
+        retained = true;
+        const value = await key(row, rightKeys);
+        if (value !== void 0) {
+          const group = index.get(value);
+          if (group) group.push(row);
+          else index.set(value, [row]);
+        }
+      } finally {
+        if (!retained) row.free();
+      }
+    }
+    for await (const row of left) {
+      try {
+        budget.hold(row.cells.reduce((n, cell) => n + cell.decoded.length * 8 + 64, 0));
+        let value;
+        try {
+          value = await key(row, leftKeys);
+          const matches = options.has("cross") ? rows2 : value === void 0 ? [] : index.get(value) ?? [];
+          if (semi) {
+            if (options.has("anti") ? !matches.length : matches.length) yield* output(row, void 0);
+          } else if (matches.length) for (const other of matches) {
+            budget.work();
+            matched.add(other);
+            yield* output(row, other);
+          }
+          else if (options.has("left") || options.has("full")) yield* output(row, void 0);
+        } finally {
+          budget.release(row.cells.reduce((n, cell) => n + cell.decoded.length * 8 + 64, 0));
+        }
+      } finally {
+        row.free();
+      }
+    }
+    if (options.has("right") || options.has("full")) {
+      for (const row of rows2) if (!matched.has(row)) yield* output(void 0, row);
+    }
+  } finally {
+    for (const row of rows2) row.free();
+    rightFirst?.free();
+    budget.release(held);
+    await scanner.close();
+  }
+}
+
+// packages/safe-bash-command-xan/src/commands.ts
+async function* emitted2(bytes, budget) {
+  try {
+    if (bytes.length) yield bytes;
+  } finally {
+    budget.release(bytes.length);
+  }
+}
+function width(row, expected) {
+  if (row.width !== expected) throw new XanError(`CSV error: record ${row.number} (byte: ${row.offset}): found record with ${row.width} fields, but the previous record has ${expected} fields`);
+}
+async function prepareRows(args, selection, scope, budget, writer) {
+  if (args.help) return emitted2(await writer.text("xan: CSV tools for virtual files and byte streams\nCommands: headers (h), count, select, slice, head, tail, sort, search,\n          filter, reverse, rename, drop, stats, freq (frequency), join\nCommon: -h --help, -d --delimiter BYTE, -o --output PATH\nheaders: -j --just-names, --csv, -s --start N, --color auto|never\ncount/select/slice: -n --no-headers\ncount: -H/--human-readable, -c/--check-alignment, -a/--approx, -p/--parallel, -t/--threads N\nselect: literal selection or -e/--evaluate COLUMN, -f/--evaluate-file PATH;\nslice: -s/--start, --skip, -e/--end, -l/--len, -i/--index, -I/--indices, -L/--last\nslice bytes: -B/--byte-offset N, --end-byte N, --raw\nslice conditions: -S/--start-condition EXPR, -E/--end-condition EXPR\nConditions: named column comparisons with string/number literals.\nhead/tail: -l/--limit N (default 10)\nsort: -s/--select COLUMNS, -N/--numeric, -R/--reverse, -u/--uniq\nsearch: PATTERN; -s/--select, -e/--exact, -i/--ignore-case, -v/--invert-match\nfilter: COLUMN comparison LITERAL; -v/--invert-match\nrename: NAMES; -s/--select COLUMNS; drop: SELECTION\nstats/freq: -s/--select COLUMNS; freq: -l/--limit N, -A/--all, -N/--no-extra\njoin: COLUMNS LEFT [RIGHT_COLUMNS] RIGHT; --left/--right/--full/--semi/--anti/--cross\n      --drop-key none|left|right|both, --nulls, -i/--ignore-case\nSearch uses literal substrings; filter supports the comparisons above.\nAdvanced expressions, formats and forced color are unsupported.\nCount execution options use exact sequential counting.\n"), budget);
+  if (!["headers", "count", "select", "drop", "slice"].includes(args.command)) return transformRows(args, scope, budget, writer);
+  if (args.command === "headers") return prepareHeaders(args, scope, budget, writer);
+  if (args.command === "slice" && !args.raw && args.noHeaders && args.last === 0) return emitted2(new Uint8Array(0), budget);
+  let scanner = scope.open(args.inputs[0], args);
+  if (args.command === "count") {
+    let count = 0;
+    let expected;
+    while (true) {
+      const row = await scanner.next();
+      if (!row) break;
+      try {
+        expected ??= row.width;
+        if (args.checkAlignment) width(row, expected);
+        count++;
+      } finally {
+        row.free();
+      }
+    }
+    await scanner.close();
+    count = Math.max(0, count - (args.noHeaders ? 0 : 1));
+    let text = String(count);
+    if (args.humanReadable && !args.parallel) {
+      text = count.toLocaleString("en-US");
+      if (count >= 1e4) {
+        const scale = count >= 1e6 ? 1e6 : 1e3;
+        const rounded = Math.round(count / scale * 10) / 10;
+        text += ` (${rounded}${scale === 1e3 ? "k" : "M"})`;
+      }
+    }
+    return emitted2(await writer.text(`${text}
+`), budget);
+  }
+  const first = args.raw && args.noHeaders ? void 0 : await scanner.next();
+  if (first) scope.own(first.free);
+  let positions2;
+  try {
+    if (selection && (first || !args.noHeaders)) {
+      const metadata = (first?.width ?? 0) * 32;
+      budget.hold(metadata);
+      try {
+        positions2 = await resolveSelection(selection, first?.cells.map((cell) => cell.decoded.view()) ?? [], args.noHeaders, budget);
+      } finally {
+        budget.release(metadata);
+      }
+    }
+  } catch (error) {
+    first?.free();
+    throw error;
+  }
+  const startCondition = args.raw || args.last !== void 0 ? void 0 : await condition(args.startCondition, first, args.noHeaders, budget, scope);
+  const endCondition = args.raw || args.last !== void 0 ? void 0 : await condition(args.endCondition, first, args.noHeaders, budget, scope);
+  if (args.byteOffset !== void 0 && (args.raw || args.last === void 0)) {
+    await scanner.close();
+    scanner = scope.open(args.inputs[0], args);
+    await scanner.position(args.byteOffset, args.endByte);
+  }
+  if (args.raw) return (async function* () {
+    try {
+      if (!args.noHeaders) yield* emitted2(await writer.row(first?.cells ?? []), budget);
+      first?.free();
+      yield* scanner.raw();
+    } finally {
+      first?.free();
+      await scanner.close();
+    }
+  })();
+  return rows(args, scanner, first, positions2, budget, writer, startCondition, endCondition);
+}
+async function* rows(args, scanner, first, positions2, budget, writer, startCondition, endCondition) {
+  const expected = first?.width ?? 0;
+  const ring = [];
+  let ringCursor = 0;
+  let current = first;
+  if (args.byteOffset !== void 0 && args.last === void 0) current = void 0;
+  let started = !startCondition;
+  const raw = (args.command === "select" || args.command === "drop") && !args.evaluate && !args.evaluateFile && (args.delimiter ?? inferDelimiter(args.inputs[0])) === 44 && writer.delimiter === 44;
+  try {
+    if (!args.noHeaders) {
+      yield* emitted2(await writer.row(first?.cells ?? [], positions2), budget);
+      first?.free();
+      current = void 0;
+    }
+    if (args.byteOffset !== void 0 && args.noHeaders && args.last === void 0) first?.free();
+    if (args.last === 0) return;
+    if (!first) return;
+    let index = 0n;
+    let wanted = 0;
+    while (true) {
+      current ??= await scanner.next();
+      if (!current) break;
+      width(current, expected);
+      if (!started) {
+        started = await startCondition(current);
+        if (!started) {
+          current.free();
+          current = void 0;
+          continue;
+        }
+      }
+      if (endCondition && await endCondition(current)) break;
+      if (args.command === "select" || args.command === "drop") yield* emitted2(await writer.row(current.cells, positions2, raw), budget);
+      else if (args.last !== void 0) {
+        if (ring.length < args.last) {
+          budget.hold(32);
+          ring.push(current);
+        } else {
+          ring[ringCursor].free();
+          ring[ringCursor] = current;
+          ringCursor = (ringCursor + 1) % args.last;
+        }
+        current = void 0;
+      } else if (args.indices) {
+        if (args.indices[wanted] === index) {
+          yield* emitted2(await writer.row(current.cells), budget);
+          wanted++;
+        }
+      } else if (index >= args.start) yield* emitted2(await writer.row(current.cells), budget);
+      current?.free();
+      current = void 0;
+      index++;
+      if (args.command === "slice" && args.last === void 0) {
+        if (args.indices && wanted === args.indices.length) break;
+        if (!args.indices && args.end !== void 0 && index === args.end && index > args.start) break;
+      }
+    }
+    for (let offset = 0; offset < ring.length; offset++) {
+      const row = ring[(ringCursor + offset) % ring.length];
+      yield* emitted2(await writer.row(row.cells), budget);
+    }
+  } finally {
+    current?.free();
+    first?.free();
+    for (const row of ring) {
+      row.free();
+      budget.release(32);
+    }
+    if (positions2) budget.release(positions2.length * 8);
+    await scanner.close();
+  }
+}
+var whitespace = (code) => code >= 9 && code <= 13 || code === 32 || code === 133 || code === 160 || code === 5760 || code >= 8192 && code <= 8202 || code === 8232 || code === 8233 || code === 8239 || code === 8287 || code === 12288;
+async function sanitize(text, budget) {
+  const parts = [];
+  let normalizedLength = 0;
+  let segment = "";
+  for (let offset = 0; offset < text.length; offset++) {
+    const code = text.charCodeAt(offset);
+    const part = code === 173 || code < 32 && !whitespace(code) ? "" : code === 10 ? "\\n" : code === 13 ? "\\r" : code === 9 ? "\\t" : code === 12 ? "\\f" : text[offset];
+    budget.hold(part.length * 2);
+    budget.work(part.length);
+    segment += part;
+    normalizedLength += part.length;
+    if (segment.length >= 4096) {
+      budget.hold(32);
+      parts.push(segment);
+      segment = "";
+    }
+    if ((offset & 1023) === 0) {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+  }
+  if (segment) {
+    budget.hold(32);
+    parts.push(segment);
+  }
+  budget.hold(normalizedLength * 2);
+  for (let offset = 0; offset < normalizedLength; offset += 4096) {
+    budget.work(Math.min(4096, normalizedLength - offset));
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+  }
+  text = parts.join("");
+  budget.release(normalizedLength * 2 + parts.length * 32);
+  parts.length = 0;
+  let start = 0;
+  let end = text.length;
+  while (start < end && whitespace(text.charCodeAt(start))) {
+    budget.work();
+    start++;
+  }
+  while (end > start && whitespace(text.charCodeAt(end - 1))) {
+    budget.work();
+    end--;
+  }
+  let result = "";
+  for (let offset = 0; offset < text.length; offset++) {
+    const code = text.charCodeAt(offset);
+    let part;
+    if (offset < start || offset >= end) part = "\xB7".repeat(code < 128 ? 1 : code < 2048 ? 2 : 3);
+    else part = text[offset];
+    budget.hold(part.length * 2);
+    budget.work(part.length);
+    result += part;
+    if ((offset & 1023) === 0) {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+  }
+  budget.release(normalizedLength * 2);
+  return result;
+}
+async function decodeHeader(bytes, field, budget) {
+  for (let offset = 0; offset < bytes.length; ) {
+    const first = bytes[offset];
+    budget.work();
+    let width2 = first < 128 ? 1 : first >= 194 && first <= 223 ? 2 : first >= 224 && first <= 239 ? 3 : first >= 240 && first <= 244 ? 4 : 0;
+    if (offset + width2 > bytes.length) width2 = 0;
+    for (let index = 1; index < width2; index++) {
+      budget.work();
+      const byte = bytes[offset + index];
+      if (byte < 128 || byte > 191 || index === 1 && (first === 224 && byte < 160 || first === 237 && byte > 159 || first === 240 && byte < 144 || first === 244 && byte > 143)) {
+        width2 = 0;
+        break;
+      }
+    }
+    if (!width2) throw new XanError(`CSV parse error: record 0 (line 1, field: ${field}, byte: 0): invalid utf-8: invalid UTF-8 in field ${field} near byte index ${offset}`);
+    offset += width2;
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+  }
+  const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+  const metadata = Math.ceil(bytes.length / 4096) * 32;
+  budget.hold(bytes.length * 2 + metadata);
+  const parts = [];
+  let length = 0;
+  try {
+    for (let offset = 0; offset < bytes.length; offset += 4096) {
+      const fragment = bytes.subarray(offset, offset + 4096);
+      budget.work(fragment.length);
+      const part = decoder.decode(fragment, { stream: offset + 4096 < bytes.length });
+      parts.push(part);
+      length += part.length;
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+    }
+    budget.hold(length * 2);
+    for (let offset = 0; offset < length; offset += 2048) {
+      budget.work(Math.min(2048, length - offset) * 2);
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+    }
+    return parts.join("");
+  } finally {
+    budget.release(bytes.length * 2 + metadata);
+  }
+}
+async function prepareHeaders(args, scope, budget, writer) {
+  const headers = [];
+  try {
+    for (const path of args.inputs) {
+      const scanner = scope.open(path, args);
+      const row = await scanner.next();
+      if (row) scope.own(row.free);
+      const header = { ...row ? { row } : {}, names: [], display: [] };
+      budget.hold(32);
+      headers.push(header);
+      for (let index = 0; index < (row?.cells.length ?? 0); index++) {
+        const bytes = row.cells[index].decoded.view();
+        budget.hold(32);
+        const name = await decodeHeader(bytes, index, budget);
+        header.names.push(name);
+        header.display.push(args.csv ? "" : await sanitize(name, budget));
+      }
+      if (!args.csv && header.names.length) checkedAdd(args.start, BigInt(header.names.length - 1));
+      await scanner.close();
+    }
+    return headerOutput(args, headers, budget, writer);
+  } catch (error) {
+    for (const header of headers) header.row?.free();
+    throw error;
+  }
+}
+async function* headerOutput(args, headers, budget, writer) {
+  try {
+    const maximum = Math.max(0, ...headers.map((header) => header.names.length));
+    if (args.csv) {
+      const paths = [];
+      try {
+        for (const path of args.inputs) paths.push(await budget.encode(path === "-" ? "<stdin>" : path));
+        yield* emitted2(await writer.values(paths), budget);
+      } finally {
+        for (const path of paths) budget.release(path.length);
+      }
+      for (let index = 0; index < maximum; index++) {
+        budget.hold(headers.length * 32);
+        try {
+          yield* emitted2(await writer.values(headers.map((header) => header.row?.cells[index]?.decoded.view() ?? new Uint8Array(0))), budget);
+        } finally {
+          budget.release(headers.length * 32);
+        }
+      }
+      return;
+    }
+    const counts = /* @__PURE__ */ new Map();
+    for (let file = 0; file < headers.length; file++) {
+      const header = headers[file];
+      if (headers.length > 1) yield* emitted2(await writer.text(`${file ? "\n" : ""}${args.inputs[file] === "-" ? "<stdin>" : args.inputs[file]}
+`), budget);
+      for (let index = 0; index < header.names.length; index++) {
+        const name = header.names[index];
+        if (headers.length > 1) {
+          const previous = counts.get(name);
+          if (previous) {
+            if (previous.lastFile !== file) {
+              previous.count++;
+              previous.lastFile = file;
+            }
+          } else {
+            budget.hold(32);
+            counts.set(name, { count: 1, lastFile: file, bytes: header.row.cells[index].decoded.view(), display: header.display[index] });
+          }
+        }
+        const prefix = args.justNames ? "" : `${checkedAdd(args.start, BigInt(index))} `;
+        yield* emitted2(await writer.text(`${prefix}${header.display[index]}
+`), budget);
+      }
+    }
+    if (headers.length > 1) {
+      const same = [...counts.values()].every((value) => value.count === headers.length);
+      if (same) yield* emitted2(await writer.text("\nAll files have the same headers!\n"), budget);
+      else {
+        budget.hold(counts.size * 32);
+        const divergent = [...counts.values()].filter((value) => value.count < headers.length);
+        await boundedSort(divergent, 32, budget, async (left, right) => {
+          for (let offset = 0; offset < Math.min(left.bytes.length, right.bytes.length); offset++) {
+            budget.work();
+            const difference = left.bytes[offset] - right.bytes[offset];
+            if (difference) return difference;
+            if ((offset & 1023) === 0) {
+              const c = budget.checkpoint();
+              if (c) await c;
+            }
+          }
+          return left.bytes.length - right.bytes.length;
+        });
+        yield* emitted2(await writer.text("\nAll files don't have the same headers!\nDiverging headers: "), budget);
+        for (let index = 0; index < divergent.length; index++) yield* emitted2(await writer.text(`${index ? ", " : ""}${divergent[index].display}`), budget);
+        yield* emitted2(await writer.text("\n"), budget);
+        budget.release(counts.size * 32);
+      }
+    }
+    budget.release(counts.size * 32);
+  } finally {
+    for (const header of headers) {
+      header.row?.free();
+      budget.release(32);
+      for (const name of header.names) budget.release(name.length * 2 + 32);
+      for (const display of header.display) budget.release(display.length * 2);
+    }
+  }
+}
+
+export {
+  prepareRows
+};