@poe-platform/safe-bash 0.1.799 → 0.1.800

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

@@ -0,0 +1,220 @@
+import {
+  colorText,
+  expandTabs
+} from "./chunk-6F4XCVON.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-diff/src/diff-format.ts
+init_buffer();
+function range(start, count) {
+  return count === 0 ? `${start}` : count === 1 ? `${start + 1}` : `${start + 1},${start + count}`;
+}
+function outputLine(prefix, line, options, color) {
+  if (options?.initialTab) prefix = (prefix.length === 2 ? prefix.slice(0, -1) : prefix.trimEnd()) + "	";
+  if (options?.expand) line = expandTabs(line);
+  const text = `${prefix}${line.endsWith("\n") ? line : line + "\n"}`;
+  return (color === void 0 ? text : colorText(text, color, options)) + (line.endsWith("\n") ? "" : "\\n");
+}
+async function normal(changes, budget, append, options) {
+  let scan = 0;
+  let oldPosition = 0;
+  let newPosition = 0;
+  while (scan < changes.length) {
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    if (changes[scan].kind === " ") {
+      oldPosition++;
+      newPosition++;
+      scan++;
+      continue;
+    }
+    const start = scan;
+    let oldCount = 0;
+    let newCount = 0;
+    while (scan < changes.length && changes[scan].kind !== " ") {
+      if (changes[scan++].kind === "-") oldCount++;
+      else newCount++;
+      budget.step();
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+    }
+    budget.hunk();
+    if (changes[start].ignored) {
+      oldPosition += oldCount;
+      newPosition += newCount;
+      continue;
+    }
+    append(colorText(`${range(oldPosition, oldCount)}${oldCount === 0 ? "a" : newCount === 0 ? "d" : "c"}${range(newPosition, newCount)}
+`, 36, options));
+    for (const kind of ["-", "+"]) {
+      if (kind === "+" && oldCount && newCount) append("---\n");
+      for (let index = start; index < scan; index++) {
+        const edit = changes[index];
+        if (edit.kind === kind) append(outputLine(kind === "-" ? "< " : "> ", edit.line, options, kind === "-" ? 31 : 32));
+        budget.step();
+        {
+          const c = budget.checkpoint();
+          if (c) await c;
+        }
+      }
+    }
+    oldPosition += oldCount;
+    newPosition += newCount;
+  }
+}
+function unifiedRange(start, count) {
+  return count === 0 ? `${start},0` : count === 1 ? `${start + 1}` : `${start + 1},${count}`;
+}
+async function contextSide(changes, start, end, kind, budget, append, options) {
+  let scan = start;
+  while (scan < end) {
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    if (changes[scan].kind === " ") {
+      const edit = changes[scan++];
+      append(outputLine("  ", kind === "+" ? edit.newLine ?? edit.line : edit.line, options, kind === "-" ? 31 : 32));
+      continue;
+    }
+    let groupEnd = scan;
+    let removed = false;
+    let added = false;
+    while (groupEnd < end && changes[groupEnd].kind !== " ") {
+      if (changes[groupEnd++].kind === "-") removed = true;
+      else added = true;
+      budget.step();
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+    }
+    while (scan < groupEnd) {
+      const edit = changes[scan++];
+      if (edit.kind === kind) append(outputLine(removed && added ? "! " : `${kind} `, edit.line, options, kind === "-" ? 31 : 32));
+      budget.step();
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+    }
+  }
+}
+async function contextual(changes, format, oldLabel, newLabel, context, budget, append, options, heading) {
+  context = Math.min(context, changes.length);
+  append(colorText(`${format === "unified" ? "---" : "***"} ${oldLabel}
+`, 1, options));
+  append(colorText(`${format === "unified" ? "+++" : "---"} ${newLabel}
+`, 1, options));
+  let scan = 0;
+  let oldPosition = 0;
+  let newPosition = 0;
+  while (scan < changes.length) {
+    let changed = scan;
+    while (changed < changes.length && changes[changed].kind === " ") {
+      changed++;
+      budget.step();
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+    }
+    if (changed === changes.length) break;
+    const start = Math.max(0, changed - context);
+    let lastChange = changed;
+    let end = changed + 1;
+    while (end < changes.length && end - lastChange - 1 <= 2 * context) {
+      if (changes[end].kind !== " ") {
+        if (changes[end].ignored && end - lastChange - 1 >= context) break;
+        lastChange = end;
+      }
+      end++;
+      budget.step();
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+    }
+    end = Math.min(changes.length, lastChange + context + 1);
+    while (scan > start) {
+      const edit = changes[--scan];
+      if (edit.kind !== "+") oldPosition--;
+      if (edit.kind !== "-") newPosition--;
+      budget.step();
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+    }
+    while (scan < start) {
+      if (changes[scan].kind !== "+") oldPosition++;
+      if (changes[scan++].kind !== "-") newPosition++;
+      budget.step();
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+    }
+    let oldCount = 0;
+    let newCount = 0;
+    let removed = false;
+    let added = false;
+    for (let index = start; index < end; index++) {
+      const kind = changes[index].kind;
+      if (kind !== "+") oldCount++;
+      if (kind !== "-") newCount++;
+      if (kind === "-") removed = true;
+      if (kind === "+") added = true;
+      budget.step();
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+    }
+    if (!changes.slice(start, end).some((edit) => edit.kind !== " " && !edit.ignored)) {
+      oldPosition += oldCount;
+      newPosition += newCount;
+      scan = end;
+      continue;
+    }
+    budget.hunk();
+    const functionLine = heading ? await heading(oldPosition) : "";
+    if (format === "unified") {
+      append(colorText(`@@ -${unifiedRange(oldPosition, oldCount)} +${unifiedRange(newPosition, newCount)} @@`, 36, options) + `${functionLine ? ` ${functionLine}` : ""}
+`);
+      for (let index = start; index < end; index++) {
+        const edit = changes[index];
+        append(outputLine(edit.kind, edit.line, options, edit.kind === " " ? void 0 : edit.kind === "-" ? 31 : 32));
+        budget.step();
+        {
+          const c = budget.checkpoint();
+          if (c) await c;
+        }
+      }
+    } else {
+      append(`***************${functionLine ? ` ${functionLine}` : ""}
+` + colorText(`*** ${range(oldPosition, oldCount)} ****
+`, 36, options));
+      if (removed) await contextSide(changes, start, end, "-", budget, append, options);
+      append(colorText(`--- ${range(newPosition, newCount)} ----
+`, 36, options));
+      if (added) await contextSide(changes, start, end, "+", budget, append, options);
+    }
+    scan = end;
+    oldPosition += oldCount;
+    newPosition += newCount;
+  }
+}
+
+export {
+  normal,
+  contextual
+};

package/dist/safe-bash/command-chunks/{chunk-5ZSM4UFN.js → chunk-YGC6OS5O.js}

@@ -8,10 +8,9 @@ import {
   objectSize,
   put,
   scalarJson
-} from "./chunk-VVI4Z73I.js";
+} from "./chunk-QP4R6GLA.js";
 import {
   byteString,
-  compareBytes,
   encoder,
   latin1Bytes,
   utf8ByteLength
@@ -154,6 +153,7 @@ var JsonParser = class {
   reusableInUse = false;
   releaseReusable() {
     invalidateCachedValueMetrics(this.reusableObj);
+    invalidateCachedValueMetrics(this.reusableArr);
     this.reusableInUse = false;
   }
   isQuotedUnescaped() {
@@ -872,23 +872,7 @@ function stepFlatSelectProjectLine(rawChunk, pos, len, plan, outBuf, outPos) {
   LINE_STEP_OUT[2] = 1;
   return true;
 }
-var lastSpPlan;
-var lastSpInBuf;
-var lastSpSourceRefs = /* @__PURE__ */ new WeakSet();
-var lastSpB0 = 0;
-var lastSpBMid = 0;
-var lastSpBEnd = 0;
-var lastSpSavedOutBuf;
-var lastSpDirectOutBuf;
-var lastSpOutBufIntact = false;
-var lastSpOutPos = 0;
-var lastSpLineCount = 0;
-var lastSpResultCount = 0;
-var lastSpSteps = 0;
-function getLastFastSelectProjectSavedOutBuf(len) {
-  return lastSpOutBufIntact && lastSpSavedOutBuf !== void 0 && lastSpSavedOutBuf.byteLength === len ? lastSpSavedOutBuf : void 0;
-}
-function tryProcessFlatSelectProjectChunkSync(rawChunk, budget, condKey, outKeys, srcKeys, outBuf, planHolder, sourceRef) {
+function tryProcessFlatSelectProjectChunkSync(rawChunk, budget, condKey, outKeys, srcKeys, outBuf, planHolder, _sourceRef) {
   if (sharedFlatParserInUse || budget.tickSync()) return -1;
   const len = rawChunk.byteLength;
   if (len === 0) return 0;
@@ -903,26 +887,6 @@ function tryProcessFlatSelectProjectChunkSync(rawChunk, budget, condKey, outKeys
     if (!plan) return -1;
     if (planHolder) planHolder.cachedSchemaPlan = plan;
   }
-  if (plan === lastSpPlan && lastSpInBuf !== void 0 && lastSpInBuf.byteLength === len && rawChunk[0] === lastSpB0 && rawChunk[len >> 1] === lastSpBMid && rawChunk[len - 1] === lastSpBEnd && outBuf.byteLength >= lastSpOutPos && (sourceRef !== void 0 && lastSpSourceRefs.has(sourceRef) && sourceRef[0] === lastSpB0 && sourceRef[len >> 1] === lastSpBMid && sourceRef[len - 1] === lastSpBEnd || compareBytes(lastSpInBuf, rawChunk) === 0)) {
-    if (sourceRef !== void 0) lastSpSourceRefs.add(sourceRef);
-    budget.step(lastSpSteps);
-    if (budget.tickSync() || budget.needsYield()) return -1;
-    if (lastSpResultCount > budget.maxResultsSmi && lastSpResultCount > budget.limits.maxResults) return -1;
-    if (lastSpOutPos > budget.maxOutputBytesSmi && lastSpOutPos > budget.limits.maxOutputBytes) return -1;
-    if (!(lastSpOutBufIntact && lastSpDirectOutBuf === outBuf)) {
-      if (!lastSpSavedOutBuf) return -1;
-      outBuf.set(lastSpSavedOutBuf, 0);
-      lastSpDirectOutBuf = outBuf;
-      lastSpOutBufIntact = true;
-    }
-    budget.inputBytes = totalAfter;
-    budget.inputLocation.line = lastSpLineCount;
-    budget.inputLocation.complete = true;
-    budget.results = lastSpResultCount;
-    budget.outputBytes = lastSpOutPos;
-    return lastSpOutPos;
-  }
-  lastSpOutBufIntact = false;
   let pos = 0;
   let outPos = 0;
   let lineCount = 0;
@@ -939,22 +903,6 @@ function tryProcessFlatSelectProjectChunkSync(rawChunk, budget, condKey, outKeys
   if (budget.tickSync() || budget.needsYield()) return -1;
   if (resultCount > budget.maxResultsSmi && resultCount > budget.limits.maxResults) return -1;
   if (outPos > budget.maxOutputBytesSmi && outPos > budget.limits.maxOutputBytes) return -1;
-  if (len >= 512 && len <= 262144 && outPos <= 65536) {
-    lastSpPlan = plan;
-    lastSpInBuf = new Uint8Array(rawChunk);
-    lastSpSourceRefs = /* @__PURE__ */ new WeakSet();
-    if (sourceRef !== void 0) lastSpSourceRefs.add(sourceRef);
-    lastSpB0 = rawChunk[0];
-    lastSpBMid = rawChunk[len >> 1];
-    lastSpBEnd = rawChunk[len - 1];
-    lastSpSavedOutBuf = new Uint8Array(outBuf.subarray(0, outPos));
-    lastSpDirectOutBuf = outBuf;
-    lastSpOutBufIntact = true;
-    lastSpOutPos = outPos;
-    lastSpLineCount = lineCount;
-    lastSpResultCount = resultCount;
-    lastSpSteps = steps;
-  }
   budget.inputBytes = totalAfter;
   budget.inputLocation.line = lineCount;
   budget.inputLocation.complete = true;
@@ -1651,7 +1599,6 @@ export {
   decodeUtf8,
   parseJson,
   readChunks,
-  getLastFastSelectProjectSavedOutBuf,
   tryProcessFlatSelectProjectChunkSync,
   tryProcessFlatJsonChunkSync,
   jsonValues,

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

@@ -0,0 +1,262 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-diff-engine/src/shared.ts
+init_buffer();
+import {
+  collectBytes,
+  isFsError,
+  readBytes
+} from "../../safe-bash-contracts/index.js";
+import { PublicDiagnostic, publicDiagnosticMessage } from "../../safe-bash-contracts/diagnostics.js";
+import { writeDiagnostic } from "../../safe-bash-contracts/escaping.js";
+import { yieldTurn } from "../../safe-bash-contracts/yield.js";
+import { byteLength, concatBytes, decodeBytes, encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+import { pathOf } from "../../safe-bash-io-engine/internal.js";
+var ToolError = class extends PublicDiagnostic {
+  constructor(message, exitCode = 2) {
+    super(message);
+    this.exitCode = exitCode;
+  }
+  exitCode;
+};
+var Budget = class _Budget {
+  constructor(context, options) {
+    this.context = context;
+    this.signalAborted = context.signal.aborted;
+    this.pollSignal = Object.prototype.hasOwnProperty.call(context.signal, "aborted");
+    if (!this.signalAborted && !this.pollSignal) {
+      context.signal.addEventListener("abort", () => {
+        this.signalAborted = true;
+      }, { once: true });
+    }
+    this.limits = {
+      maxInputBytes: options.maxInputBytes ?? Infinity,
+      maxOutputBytes: options.maxOutputBytes ?? Infinity,
+      maxLines: options.maxLines ?? Infinity,
+      maxWork: options.maxWork ?? Infinity,
+      maxMatrixCells: options.maxMatrixCells ?? Infinity,
+      maxFiles: options.maxFiles ?? Infinity,
+      maxHunks: options.maxHunks ?? Infinity,
+      maxExcludePatterns: options.maxExcludePatterns ?? Infinity,
+      maxExcludePatternBytes: options.maxExcludePatternBytes ?? Infinity
+    };
+    for (const [name, value] of Object.entries(options).filter(([name2]) => name2 !== "replace")) {
+      if (value !== void 0 && value !== Infinity && (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1)) throw new ToolError(`${name} must be a positive safe integer or Infinity`);
+    }
+  }
+  context;
+  limits;
+  inspected = /* @__PURE__ */ new Map();
+  inputBytes = 0;
+  outputBytes = 0;
+  lines = 0;
+  work = 0;
+  nextYield = 4096;
+  files = 0;
+  hunks = 0;
+  signalAborted;
+  pollSignal;
+  get maxBufferBytes() {
+    return this.limits.maxInputBytes;
+  }
+  get remainingWork() {
+    return this.limits.maxWork - this.work;
+  }
+  get remainingFiles() {
+    return this.limits.maxFiles - this.files;
+  }
+  step(amount = 1) {
+    if (this.pollSignal ? this.context.signal.aborted : this.signalAborted) this.context.signal.throwIfAborted();
+    this.work += amount;
+    if (this.work > this.limits.maxWork) throw new ToolError("work limit exceeded");
+  }
+  checkpoint() {
+    if (this.pollSignal ? this.context.signal.aborted : this.signalAborted) this.context.signal.throwIfAborted();
+    if (this.work >= this.nextYield) {
+      this.nextYield = this.work + 4096;
+      return yieldTurn(this.context.signal);
+    }
+  }
+  file() {
+    this.step();
+    if (++this.files > this.limits.maxFiles) throw new ToolError("file/entry limit exceeded");
+  }
+  hunk() {
+    this.step();
+    if (++this.hunks > this.limits.maxHunks) throw new ToolError("hunk limit exceeded");
+  }
+  static utf8Decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+  text(bytes) {
+    if (bytes.includes(0)) throw new ToolError("binary input is unsupported (NUL byte)");
+    try {
+      return _Budget.utf8Decoder.decode(bytes);
+    } catch {
+      throw new ToolError("binary input is unsupported (invalid UTF-8)");
+    }
+  }
+  split(text) {
+    const result = [];
+    let start = 0;
+    while (start < text.length) {
+      if (++this.lines > this.limits.maxLines) throw new ToolError("line limit exceeded");
+      const newline = text.indexOf("\n", start);
+      const end = newline < 0 ? text.length : newline + 1;
+      result.push(text.slice(start, end));
+      start = end;
+    }
+    return result;
+  }
+  async read(path, encoding = "utf8") {
+    this.context.signal.throwIfAborted();
+    const remaining = this.limits.maxInputBytes - this.inputBytes;
+    const capabilities = path === "-" ? void 0 : await host(this.context, async () => await this.context.fs.capabilitiesFor?.(path, { signal: this.context.signal }) ?? this.context.fs.capabilities);
+    const bytes = path === "-" ? await collectBytes(this.chunks(this.context.stdin), { signal: this.context.signal, ...Number.isFinite(remaining) ? { maxBytes: remaining } : {} }) : this.context.fs.readStream && capabilities?.streamingRead !== false ? await collectBytes(this.chunks(this.context.fs.readStream(path, { signal: this.context.signal })), { signal: this.context.signal, ...Number.isFinite(remaining) ? { maxBytes: remaining } : {} }) : await host(this.context, () => this.context.fs.readFile(path, { signal: this.context.signal, ...Number.isFinite(remaining) ? { maxBytes: remaining } : {} }));
+    this.inputBytes += bytes.byteLength;
+    if (this.inputBytes > this.limits.maxInputBytes) throw new ToolError("input byte limit exceeded");
+    return encoding === "latin1" ? decodeBytes(encodeBytes(bytes), "latin1") : this.text(bytes);
+  }
+  async readDiff(path, encoding = "utf8") {
+    const { fs, signal } = this.context;
+    const expected = this.inspected.get(path);
+    const verifyAncestors = async () => {
+      const parts = path.split("/").filter(Boolean);
+      let current = "";
+      for (let index = -1; index < parts.length - 1; index++) {
+        if (index >= 0) current += `/${parts[index]}`;
+        const ancestor = current || "/";
+        const wanted = this.inspected.get(ancestor);
+        const actual = await fs.stat(ancestor, { signal });
+        if (!wanted || !sameIdentity(actual, wanted)) throw new ToolError("diff input ancestry changed");
+      }
+    };
+    const capabilities = await fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities;
+    if (!expected || !sameIdentity(expected, expected) || capabilities.retainedRead !== true || !fs.openReadFile)
+      throw new ToolError("diff input requires identity-checked retained reads");
+    await verifyAncestors();
+    const handle = await fs.openReadFile(path, { signal });
+    try {
+      const stat = await handle.stat({ signal });
+      if (!sameIdentity(stat, expected) || stat.size !== expected.size || stat.revision !== expected.revision)
+        throw new ToolError("diff input changed while opening");
+      await verifyAncestors();
+      const remaining = this.limits.maxInputBytes - this.inputBytes;
+      if (stat.size > remaining) throw new ToolError("input byte limit exceeded");
+      const chunks = [];
+      let position = 0;
+      while (position < stat.size) {
+        this.step();
+        {
+          const c = this.checkpoint();
+          if (c) await c;
+        }
+        const size = Math.min(65536, stat.size - position);
+        const chunk = await handle.read(position, size, { signal });
+        if (!chunk.length || chunk.length > size) throw new ToolError("diff input changed while reading");
+        chunks.push(chunk);
+        position += chunk.length;
+      }
+      const after = await handle.stat({ signal });
+      if (!sameIdentity(after, stat) || after.size !== stat.size || after.revision !== stat.revision)
+        throw new ToolError("diff input changed while reading");
+      const bytes = concatBytes(chunks, position);
+      this.inputBytes += position;
+      return encoding === "latin1" ? decodeBytes(bytes, "latin1") : this.text(bytes);
+    } finally {
+      await handle.close();
+    }
+  }
+  async *chunks(source) {
+    for await (const chunk of readBytes(source, this.context.signal)) {
+      this.step();
+      {
+        const c = this.checkpoint();
+        if (c) await c;
+      }
+      yield chunk;
+    }
+  }
+  output(text, encoding = "utf8") {
+    this.outputBytes += byteLength(text, encoding);
+    if (this.outputBytes > this.limits.maxOutputBytes) throw new ToolError("output byte limit exceeded");
+  }
+  equal(left, right) {
+    this.step(1 + Math.max(left?.length ?? 0, right?.length ?? 0));
+    return left === right;
+  }
+};
+async function host(context, operation) {
+  context.signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const abort = () => reject(context.signal.reason);
+    context.signal.addEventListener("abort", abort, { once: true });
+    Promise.resolve().then(() => {
+      context.signal.throwIfAborted();
+      return operation();
+    }).then(resolve, reject).finally(() => context.signal.removeEventListener("abort", abort));
+  });
+}
+function sameIdentity(actual, wanted) {
+  return wanted.identityScope !== void 0 && wanted.dev !== void 0 && wanted.ino !== void 0 && actual.identityScope === wanted.identityScope && actual.dev === wanted.dev && actual.ino === wanted.ino && actual.type === wanted.type;
+}
+async function inspect(budget, path, symlinks = "reject") {
+  const context = budget.context;
+  const absolute = pathOf(context, path);
+  const parts = absolute.split("/").filter(Boolean);
+  let current = "";
+  for (let index = -1; index < parts.length; index++) {
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    if (index >= 0) current += `/${parts[index]}`;
+    let stat;
+    try {
+      stat = await host(context, () => context.fs.lstat(current || "/", { signal: context.signal }));
+    } catch (error) {
+      if (isFsError(error, "ENOENT")) return void 0;
+      throw error;
+    }
+    if (stat.type === "symlink") {
+      if (symlinks === "reject") throw new ToolError(`symlink paths are unsupported: ${current}`);
+      if (symlinks === "follow" || index < parts.length - 1) stat = await host(context, () => context.fs.stat(current || "/", { signal: context.signal }));
+    }
+    budget.inspected.set(current || "/", stat);
+    if (index < parts.length - 1 && stat.type !== "directory") throw new ToolError(`not a directory: ${current}`);
+    if (index === parts.length - 1) return stat;
+  }
+  return void 0;
+}
+function integer(value, name) {
+  if (!/^\d+$/u.test(value) || !Number.isSafeInteger(Number(value))) throw new ToolError(`invalid ${name}: ${value}`);
+  return Number(value);
+}
+function definition(name, options, run) {
+  return {
+    name,
+    async execute(context) {
+      context.signal.throwIfAborted();
+      try {
+        return { exitCode: await run(context, new Budget(context, options)) };
+      } catch (error) {
+        context.signal.throwIfAborted();
+        const message = publicDiagnosticMessage(error, context.onInternalError);
+        await writeDiagnostic(context.stderr, `${name}: ${message.slice(0, 1e3)}${message.length > 1e3 ? "\u2026" : ""}
+`, context.signal);
+        return { exitCode: error instanceof ToolError ? error.exitCode : 2 };
+      }
+    }
+  };
+}
+
+export {
+  ToolError,
+  Budget,
+  host,
+  sameIdentity,
+  inspect,
+  integer,
+  definition
+};

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

@@ -0,0 +1,80 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-tar/src/transform.ts
+init_buffer();
+import { checkPath, fail } from "../../safe-bash-io-engine/commands/archive/internal.js";
+import { Budget } from "../../safe-bash-io-engine/commands/text-programs/shared.js";
+import { Pattern, substitute } from "../../safe-bash-regex-engine/text/regex.js";
+function parseTransform(source) {
+  const transforms = [];
+  let offset = 0;
+  while (offset < source.length) {
+    if (source[offset++] !== "s") fail("only substitution transforms are supported");
+    const delimiter = source[offset++];
+    if (!delimiter || delimiter === "\\" || delimiter === "\n") fail("invalid transform delimiter");
+    const field = () => {
+      let value = "";
+      while (offset < source.length) {
+        const character = source[offset++];
+        if (character === delimiter) return value;
+        if (character === "\\") {
+          const next = source[offset++];
+          if (next === void 0) break;
+          value += `\\${next}`;
+        } else value += character;
+      }
+      return fail("unterminated transform expression");
+    };
+    const patternSource = field();
+    if (!patternSource) fail("empty transform pattern is unsupported");
+    const replacement = field();
+    let global = false;
+    let ignoreCase = false;
+    let extended = false;
+    while (offset < source.length && source[offset] !== ";") {
+      const flag = source[offset++];
+      if (flag === "g") global = true;
+      else if (flag === "i") ignoreCase = true;
+      else if (flag === "x") extended = true;
+      else fail(`unsupported transform flag: ${flag}`);
+    }
+    const pattern = new Pattern(patternSource, extended, ignoreCase);
+    for (let index = 0; index < replacement.length; index++) {
+      if (replacement[index] !== "\\") continue;
+      const next = replacement[++index];
+      if (next && "uUlLE".includes(next)) fail("transform replacement case conversion is unsupported");
+      if (next && next >= "1" && next <= "9" && Number(next) > pattern.groupCount) fail("transform references an undefined capture group");
+    }
+    transforms.push({ pattern, replacement, global });
+    if (source[offset] === ";") offset++;
+  }
+  if (!transforms.length) fail("empty transform expression");
+  return transforms;
+}
+var TransformedNames = class {
+  constructor(context, transforms, limits) {
+    this.transforms = transforms;
+    this.limits = limits;
+    this.budget = new Budget(context, {
+      ...Number.isFinite(limits.maxPatternSteps) ? { maxSteps: limits.maxPatternSteps } : {},
+      ...Number.isFinite(limits.maxPathBytes) ? { maxBufferBytes: limits.maxPathBytes } : {}
+    });
+  }
+  transforms;
+  limits;
+  budget;
+  async apply(name) {
+    for (const transform of this.transforms) {
+      name = (await substitute(name, transform.pattern, transform.replacement, this.budget, transform.global)).text;
+      checkPath(name, this.limits);
+    }
+    return name;
+  }
+};
+
+export {
+  parseTransform,
+  TransformedNames
+};