buninu-linux 0.8.56 → 0.9.56

package/initramfs/buninu/apps/bunmsh/src/diff.js

@@ -0,0 +1,222 @@
+/*
+Adapted from jsmdcui/src/index.js diffgutter (Myers bisect and merge cleanup).
+
+MIT License
+
+Copyright (c) 2016-2020: Zachary Yedidia, et al.
+Copyright (c) 2026 Dr. John (醫者小智)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+const _DIFF_DELETE = -1, _DIFF_INSERT = 1, _DIFF_EQUAL = 0;
+
+function _arrEq(a, b) { if (a.length !== b.length) return false; for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false; return true; }
+function _commonPrefix(a, b) { const n = Math.min(a.length, b.length); let i = 0; while (i < n && a[i] === b[i]) i++; return i; }
+function _commonSuffix(a, b) { const n = Math.min(a.length, b.length); let i = 0; while (i < n && a[a.length-1-i] === b[b.length-1-i]) i++; return i; }
+function _indexOfSub(longArr, shortArr) { const L = longArr.length, S = shortArr.length; if (S === 0) return 0; outer: for (let i = 0; i + S <= L; i++) { for (let j = 0; j < S; j++) if (longArr[i+j] !== shortArr[j]) continue outer; return i; } return -1; }
+function _hasSuffix(seq, suf) { if (suf.length > seq.length) return false; for (let i = 0; i < suf.length; i++) if (seq[seq.length-suf.length+i] !== suf[i]) return false; return true; }
+function _hasPrefix(seq, pre) { if (pre.length > seq.length) return false; for (let i = 0; i < pre.length; i++) if (seq[i] !== pre[i]) return false; return true; }
+
+function _diffMain(a, b) {
+  if (_arrEq(a, b)) return a.length ? [{ op: _DIFF_EQUAL, seq: a.slice() }] : [];
+  const pre = _commonPrefix(a, b);
+  const commonprefix = a.slice(0, pre);
+  a = a.slice(pre); b = b.slice(pre);
+  const suf = _commonSuffix(a, b);
+  const commonsuffix = a.slice(a.length - suf);
+  a = a.slice(0, a.length - suf); b = b.slice(0, b.length - suf);
+  const diffs = _diffCompute(a, b);
+  if (commonprefix.length) diffs.unshift({ op: _DIFF_EQUAL, seq: commonprefix });
+  if (commonsuffix.length) diffs.push({ op: _DIFF_EQUAL, seq: commonsuffix });
+  return _diffCleanupMerge(diffs);
+}
+
+function _diffCompute(a, b) {
+  if (a.length === 0) return [{ op: _DIFF_INSERT, seq: b.slice() }];
+  if (b.length === 0) return [{ op: _DIFF_DELETE, seq: a.slice() }];
+  const aLonger = a.length > b.length;
+  const long = aLonger ? a : b, short = aLonger ? b : a;
+  const idx = _indexOfSub(long, short);
+  if (idx !== -1) {
+    const op = aLonger ? _DIFF_DELETE : _DIFF_INSERT;
+    return [
+      { op, seq: long.slice(0, idx) },
+      { op: _DIFF_EQUAL, seq: short.slice() },
+      { op, seq: long.slice(idx + short.length) },
+    ];
+  }
+  if (short.length === 1) return [{ op: _DIFF_DELETE, seq: a.slice() }, { op: _DIFF_INSERT, seq: b.slice() }];
+  return _diffBisect(a, b);
+}
+
+function _diffBisect(a, b) {
+  const n = a.length, m = b.length;
+  const maxD = Math.ceil((n + m) / 2);
+  const vOffset = maxD, vLength = 2 * maxD;
+  const v1 = new Int32Array(vLength).fill(-1);
+  const v2 = new Int32Array(vLength).fill(-1);
+  v1[vOffset + 1] = 0; v2[vOffset + 1] = 0;
+  const delta = n - m;
+  const front = (delta % 2 !== 0);
+  let k1start = 0, k1end = 0, k2start = 0, k2end = 0;
+  for (let d = 0; d < maxD; d++) {
+    for (let k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {
+      const k1Offset = vOffset + k1;
+      let x1;
+      if (k1 === -d || (k1 !== d && v1[k1Offset-1] < v1[k1Offset+1])) x1 = v1[k1Offset+1];
+      else x1 = v1[k1Offset-1] + 1;
+      let y1 = x1 - k1;
+      while (x1 < n && y1 < m && a[x1] === b[y1]) { x1++; y1++; }
+      v1[k1Offset] = x1;
+      if (x1 > n) k1end += 2;
+      else if (y1 > m) k1start += 2;
+      else if (front) {
+        const k2Offset = vOffset + delta - k1;
+        if (k2Offset >= 0 && k2Offset < vLength && v2[k2Offset] !== -1) {
+          const x2 = n - v2[k2Offset];
+          if (x1 >= x2) return _diffBisectSplit(a, b, x1, y1);
+        }
+      }
+    }
+    for (let k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {
+      const k2Offset = vOffset + k2;
+      let x2;
+      if (k2 === -d || (k2 !== d && v2[k2Offset-1] < v2[k2Offset+1])) x2 = v2[k2Offset+1];
+      else x2 = v2[k2Offset-1] + 1;
+      let y2 = x2 - k2;
+      while (x2 < n && y2 < m && a[n-x2-1] === b[m-y2-1]) { x2++; y2++; }
+      v2[k2Offset] = x2;
+      if (x2 > n) k2end += 2;
+      else if (y2 > m) k2start += 2;
+      else if (!front) {
+        const k1Offset = vOffset + delta - k2;
+        if (k1Offset >= 0 && k1Offset < vLength && v1[k1Offset] !== -1) {
+          const x1 = v1[k1Offset];
+          const y1 = vOffset + x1 - k1Offset;
+          const x2real = n - x2;
+          if (x1 >= x2real) return _diffBisectSplit(a, b, x1, y1);
+        }
+      }
+    }
+  }
+  return [{ op: _DIFF_DELETE, seq: a.slice() }, { op: _DIFF_INSERT, seq: b.slice() }];
+}
+
+function _diffBisectSplit(a, b, x, y) {
+  return _diffMain(a.slice(0, x), b.slice(0, y)).concat(_diffMain(a.slice(x), b.slice(y)));
+}
+
+function _diffCleanupMerge(diffs) {
+  diffs.push({ op: _DIFF_EQUAL, seq: [] });
+  let pointer = 0, countDelete = 0, countInsert = 0, textDelete = [], textInsert = [];
+  while (pointer < diffs.length) {
+    const d = diffs[pointer];
+    if (d.op === _DIFF_INSERT) { countInsert++; textInsert = textInsert.concat(d.seq); pointer++; }
+    else if (d.op === _DIFF_DELETE) { countDelete++; textDelete = textDelete.concat(d.seq); pointer++; }
+    else {
+      if (countDelete + countInsert > 1) {
+        if (countDelete !== 0 && countInsert !== 0) {
+          let cl = _commonPrefix(textInsert, textDelete);
+          if (cl !== 0) {
+            const x = pointer - countDelete - countInsert;
+            if (x > 0 && diffs[x-1].op === _DIFF_EQUAL) diffs[x-1].seq = diffs[x-1].seq.concat(textInsert.slice(0, cl));
+            else { diffs.unshift({ op: _DIFF_EQUAL, seq: textInsert.slice(0, cl) }); pointer++; }
+            textInsert = textInsert.slice(cl); textDelete = textDelete.slice(cl);
+          }
+          cl = _commonSuffix(textInsert, textDelete);
+          if (cl !== 0) {
+            const insIdx = textInsert.length - cl;
+            diffs[pointer].seq = textInsert.slice(insIdx).concat(diffs[pointer].seq);
+            textInsert = textInsert.slice(0, insIdx); textDelete = textDelete.slice(0, textDelete.length - cl);
+          }
+        }
+        const repl = [];
+        if (textDelete.length) repl.push({ op: _DIFF_DELETE, seq: textDelete });
+        if (textInsert.length) repl.push({ op: _DIFF_INSERT, seq: textInsert });
+        const start = pointer - countDelete - countInsert;
+        diffs.splice(start, countDelete + countInsert, ...repl);
+        pointer = start + repl.length + 1;
+      } else if (pointer !== 0 && diffs[pointer-1].op === _DIFF_EQUAL) {
+        diffs[pointer-1].seq = diffs[pointer-1].seq.concat(d.seq);
+        diffs.splice(pointer, 1);
+      } else pointer++;
+      countInsert = 0; countDelete = 0; textDelete = []; textInsert = [];
+    }
+  }
+  if (diffs[diffs.length-1].seq.length === 0) diffs.pop();
+
+  // Second pass: shift a single edit sandwiched between two equalities sideways.
+  let changes = false;
+  pointer = 1;
+  while (pointer < diffs.length - 1) {
+    const prev = diffs[pointer-1], cur = diffs[pointer], next = diffs[pointer+1];
+    if (prev.op === _DIFF_EQUAL && next.op === _DIFF_EQUAL) {
+      if (_hasSuffix(cur.seq, prev.seq)) {
+        if (prev.seq.length) {
+          cur.seq = prev.seq.concat(cur.seq.slice(0, cur.seq.length - prev.seq.length));
+          next.seq = prev.seq.concat(next.seq);
+        }
+        diffs.splice(pointer-1, 1); changes = true;
+      } else if (_hasPrefix(cur.seq, next.seq)) {
+        prev.seq = prev.seq.concat(next.seq);
+        cur.seq = cur.seq.slice(next.seq.length).concat(next.seq);
+        diffs.splice(pointer+1, 1); changes = true;
+      }
+    }
+    pointer++;
+  }
+  if (changes) return _diffCleanupMerge(diffs);
+  return diffs;
+}
+
+export function normalFileDiff(left, right) {
+  // Keep the terminator as part of line identity, including a missing final LF.
+  const lines = text => text.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+  const a = lines(left), b = lines(right);
+  const operations = _diffMain(a, b);
+  const range = (first, last) => first === last ? String(first) : `${first},${last}`;
+  const render = (values, prefix) => values.map(line =>
+    `${prefix} ${line}${line.endsWith("\n") ? "" : "\n\\n"}`
+  ).join("");
+  let oldLine = 0, newLine = 0, output = "";
+  for (let i = 0; i < operations.length;) {
+    if (operations[i].op === _DIFF_EQUAL) {
+      oldLine += operations[i].seq.length;
+      newLine += operations[i++].seq.length;
+      continue;
+    }
+    const oldStart = oldLine, newStart = newLine;
+    let removed = [], added = [];
+    while (i < operations.length && operations[i].op !== _DIFF_EQUAL) {
+      const change = operations[i++];
+      if (change.op === _DIFF_DELETE) {
+        removed = removed.concat(change.seq);
+        oldLine += change.seq.length;
+      } else {
+        added = added.concat(change.seq);
+        newLine += change.seq.length;
+      }
+    }
+    if (!removed.length) output += `${oldStart}a${range(newStart + 1, newLine)}\n${render(added, ">")}`;
+    else if (!added.length) output += `${range(oldStart + 1, oldLine)}d${newStart}\n${render(removed, "<")}`;
+    else output += `${range(oldStart + 1, oldLine)}c${range(newStart + 1, newLine)}\n${render(removed, "<")}---\n${render(added, ">")}`;
+  }
+  return output;
+}

package/initramfs/buninu/apps/bunmsh/src/fancy-ls.js

@@ -43,8 +43,8 @@ function classifySuffix(stats) {
 }
 
 function displayEntry(entry, options) {
-  const suffix = options.classify ? classifySuffix(entry.stats) : entry.stats.isDirectory() ? "/" : "";
-  return `${iconFor(entry.name, entry.stats, entry.path)} ${entry.name}${suffix}`;
+  const suffix = options.classify ? classifySuffix(entry.stats) : !options.plain && entry.stats.isDirectory() ? "/" : "";
+  return `${options.inode ? `${entry.stats.ino} ` : ""}${options.plain ? "" : `${iconFor(entry.name, entry.stats, entry.path)} `}${entry.name}${suffix}`;
 }
 
 function columns(items, width) {
@@ -98,7 +98,7 @@ function listDirectory(path, options) {
     .filter((entry) => options.all || options.almostAll || !entry.name.startsWith("."))
     .map((entry) => {
       const entryPath = resolve(path, entry.name);
-      return { name: entry.name, stats: lstatSync(entryPath), path: entryPath };
+      return { name: entry.name, stats: options.dereference ? statSync(entryPath) : lstatSync(entryPath), path: entryPath };
     });
   if (options.all) entries = [
     { name: ".", stats: lstatSync(path), path },
@@ -116,6 +116,7 @@ function listDirectory(path, options) {
 
 export function fancyLs(argv, state, terminal = Boolean(process.stdout.isTTY)) {
   const options = {
+    plain: argv[0] === "ls" && Boolean(state.shellOptions?.posix),
     all: false, almostAll: false, directory: false, long: false, human: false,
     recursive: false, time: false, reverse: false, size: false, one: false, classify: false,
   };
@@ -128,6 +129,8 @@ export function fancyLs(argv, state, terminal = Boolean(process.stdout.isTTY)) {
       for (const flag of argument.slice(1)) {
         if (flag === "a") options.all = true;
         else if (flag === "A") options.almostAll = true;
+        else if (flag === "L") options.dereference = true;
+        else if (flag === "i") options.inode = true;
         else if (flag === "d") options.directory = true;
         else if (flag === "l") options.long = true;
         else if (flag === "h") options.human = true;
@@ -148,7 +151,7 @@ export function fancyLs(argv, state, terminal = Boolean(process.stdout.isTTY)) {
   const show = (operand, heading = operands.length > 1, separate = true) => {
     const path = isAbsolute(operand) ? operand : resolve(state.cwd, operand);
     try {
-      const stats = lstatSync(path);
+      const stats = options.dereference ? statSync(path) : lstatSync(path);
       let listingDirectory = stats.isDirectory() && !options.directory;
       // GNU/POSIX-style ls follows a command-line symlink to a directory for
       // an ordinary listing and for -R. -d, -l, and -F request information
@@ -196,6 +199,14 @@ export function fancyLs(argv, state, terminal = Boolean(process.stdout.isTTY)) {
       stderr += `bunmsh: ${argv[0]}: ${operand}: ${error.message}\n`;
     }
   };
+  if (options.time || options.size) operands.sort((a,b) => {
+    try {
+      const stat = options.dereference ? statSync : lstatSync;
+      const left=stat(resolve(state.cwd,a)), right=stat(resolve(state.cwd,b));
+      const order=(options.size ? right.size-left.size : right.mtimeMs-left.mtimeMs) || a.localeCompare(b);
+      return options.reverse ? -order : order;
+    } catch { return 0; }
+  });
   for (const operand of operands) show(operand);
   return { status, stdout, stderr };
 }

package/initramfs/buninu/apps/bunmsh/src/main.js

@@ -6,6 +6,7 @@ import {
   createState,
   execute,
   executeArgv,
+  finishShell,
   executeBunShellFallback,
   isJavaScriptMode,
   needsMoreInput,
@@ -440,6 +441,10 @@ async function interactive(state) {
     }
   };
   const interrupt = () => {
+    if (Object.hasOwn(state.traps,"SIGINT")) {
+      if (state.traps.SIGINT && !state.pendingTraps.includes("SIGINT")) state.pendingTraps.push("SIGINT");
+      return;
+    }
     state.lastStatus = 130;
     if (foregroundCommand || promptAbort?.signal.aborted) return;
     process.stdout.write("\n");
@@ -456,6 +461,7 @@ async function interactive(state) {
   // periodic autosave.
   const SIGNAL_EXIT_STATUS = { SIGHUP: 129, SIGTERM: 143 };
   const terminate = (signal) => {
+    if (Object.hasOwn(state.traps,signal)) return;
     state.exitRequested = true;
     state.exitStatus = SIGNAL_EXIT_STATUS[signal] ?? state.exitStatus;
     if (foregroundCommand) {
@@ -725,7 +731,7 @@ async function interactive(state) {
     process.off("SIGHUP", terminate);
     readline.close();
   }
-  return state.exitRequested ? state.exitStatus : state.lastStatus;
+  return (await finishShell(state,state.exitRequested ? state.exitStatus : state.lastStatus)).status;
 }
 
 async function main(argv) {
@@ -736,6 +742,7 @@ async function main(argv) {
   let forceInteractive = false;
   let forceMouse = false;
   let builtinOnly = false;
+  const shellOptions = {};
   let i = 0;
   for (; i < argv.length; i++) {
     const arg = argv[i];
@@ -785,6 +792,10 @@ async function main(argv) {
       await printChangelog();
       return 0;
     }
+    if (/^-[eufxv]+$/.test(arg)) {
+      for (const key of arg.slice(1)) shellOptions[key]=true;
+      continue;
+    }
     if (arg.startsWith("-")) {
       console.error(`bunmsh: ${arg}: unknown option`);
       return 2;
@@ -801,7 +812,7 @@ async function main(argv) {
     if (forceMouse) state.mouseTracking = true;
     if (builtinOnly) state.pathSearch = false;
     const result = await executeArgv(forwardedArgv, state);
-    return state.exitRequested ? state.exitStatus : result.status;
+    return (await finishShell(state,state.exitRequested ? state.exitStatus : result.status)).status;
   }
 
   if (command !== null) {
@@ -813,8 +824,10 @@ async function main(argv) {
           mouseTracking: forceMouse || undefined,
           pathSearch: builtinOnly ? false : undefined,
         });
+    Object.assign(state.shellOptions,shellOptions);
+    if (state.shellOptions.v) console.error(command);
     const result = await execute(command, state);
-    return state.exitRequested ? state.exitStatus : result.status;
+    return (await finishShell(state,state.exitRequested ? state.exitStatus : result.status)).status;
   }
 
   if (i < argv.length) {
@@ -826,9 +839,11 @@ async function main(argv) {
         mouseTracking: forceMouse || undefined,
         pathSearch: builtinOnly ? false : undefined,
       });
+      Object.assign(state.shellOptions,shellOptions);
+      if (state.shellOptions.v) console.error(source);
       const result = await execute(source, state);
       if (forceInteractive && !state.exitRequested) return interactive(state);
-      return state.exitRequested ? state.exitStatus : result.status;
+      return (await finishShell(state,state.exitRequested ? state.exitStatus : result.status)).status;
     } catch (error) {
       console.error(`bunmsh: ${script}: ${error.message}`);
       return 1;
@@ -839,10 +854,11 @@ async function main(argv) {
     mouseTracking: forceMouse || undefined,
     pathSearch: builtinOnly ? false : undefined,
   });
+  Object.assign(state.shellOptions,shellOptions);
   if (forceInteractive || process.stdin.isTTY) return interactive(state);
   const source = await Bun.stdin.text();
   const result = await execute(source, state);
-  return state.exitRequested ? state.exitStatus : result.status;
+  return (await finishShell(state,state.exitRequested ? state.exitStatus : result.status)).status;
 }
 
 // Lets --define process.env.SERVE_AUTO_OPEN=/index.html, =off, or =yes

package/initramfs/buninu/apps/bunmsh/src/sed.js

@@ -0,0 +1,159 @@
+// The fallback operates on pattern/hold spaces, with a program counter for
+// branches. Parsing delimiters before command separators preserves s/;/x/.
+export function compileSed(script, regexSource) {
+  let i = 0, lastPattern = null;
+  const commands = [], groups = [], labels = new Map();
+  const space = () => { while (/[ \t\r]/.test(script[i] ?? "") && i < script.length) i++; };
+  const field = delimiter => {
+    let value = "";
+    for (; i < script.length; i++) {
+      const ch = script[i];
+      if (ch === delimiter) { i++; return value; }
+      if (ch === "\\" && i + 1 < script.length) {
+        const next = script[++i];
+        value += next === delimiter && !'.*[]^$\\'.includes(next) ? next : `\\${next}`;
+      } else value += ch;
+    }
+    throw new Error("unterminated sed field");
+  };
+  const regex = pattern => {
+    if (pattern) lastPattern = pattern;
+    if (lastPattern === null) throw new Error("no previous regular expression");
+    return regexSource(lastPattern);
+  };
+  const address = () => {
+    if (script[i] === "$") { i++; return {last:true}; }
+    if (/\d/.test(script[i] ?? "")) { const match = /^\d+/.exec(script.slice(i))[0]; i += match.length; return {line:Number(match)}; }
+    if (script[i] === "/") { i++; return {regex:new RegExp(regex(field("/")))}; }
+    return null;
+  };
+  while (i < script.length) {
+    space();
+    if (";\n".includes(script[i])) { i++; continue; }
+    if (script[i] === "#") { while (i < script.length && script[i] !== "\n") i++; continue; }
+    if (i >= script.length) break;
+    const first = address(); space();
+    let second = null;
+    if (script[i] === ",") { i++; space(); second = address(); if (!second) throw new Error("missing range address"); }
+    space(); const invert = script[i] === "!"; if (invert) { i++; space(); }
+    const op = script[i++], command = {op, first, second, invert};
+    const index = commands.length;
+    if (op === "{") groups.push(index);
+    else if (op === "}") { const open = groups.pop(); if (open === undefined) throw new Error("unexpected }"); commands[open].end = index; }
+    else if (op === "s" || op === "y") {
+      const delimiter = script[i++];
+      const pattern = field(delimiter), replacement = field(delimiter);
+      if (op === "y") {
+        const unescape = s => s.replace(/\\n/g,"\n").replace(/\\(.)/g,"$1");
+        command.from = unescape(pattern); command.to = unescape(replacement);
+        if (command.from.length !== command.to.length) throw new Error("unequal y strings");
+      } else {
+        const flags = /^[gp0-9]*/.exec(script.slice(i))[0]; i += flags.length;
+        command.regex = new RegExp(regex(pattern), "g");
+        command.replacement = replacement;
+        command.global = flags.includes("g"); command.print = flags.includes("p");
+        command.occurrence = Number(/\d+/.exec(flags)?.[0] ?? 1);
+      }
+    } else if ([":","b","t","T"].includes(op)) {
+      space(); const start = i; while (i < script.length && !";\n}".includes(script[i])) i++;
+      command.label = script.slice(start,i).trim();
+      if (op === ":") labels.set(command.label,index);
+    } else if (op === "r") {
+      space(); const start=i; while (i<script.length && script[i]!=="\n") i++;
+      command.file=script.slice(start,i);
+      if (!command.file) throw new Error("r requires a filename");
+    } else if (["a","i","c"].includes(op)) {
+      space(); if (script[i] === "\\") { i++; if (script[i] === "\n") i++; }
+      let text = "";
+      while (i < script.length && script[i] !== "\n") {
+        if (script[i] === "\\" && script[i+1] === "\n") { text += "\n"; i+=2; }
+        else text += script[i++];
+      }
+      command.text = text;
+    } else if (!"pPdDqnhHgGxN=".includes(op ?? "")) throw new Error(`unsupported sed command: ${op}`);
+    commands.push(command);
+  }
+  if (groups.length) throw new Error("unclosed sed group");
+  for (const command of commands) if (["b","t","T"].includes(command.op)) {
+    command.target = command.label ? labels.get(command.label) : commands.length;
+    if (command.target === undefined) throw new Error(`undefined sed label: ${command.label}`);
+  }
+  return commands;
+}
+
+function replacementText(template, args) {
+  let output = "";
+  for (let i = 0; i < template.length; i++) {
+    if (template[i] === "&") output += args[0];
+    else if (template[i] === "\\" && i + 1 < template.length) {
+      const ch = template[++i];
+      output += /[1-9]/.test(ch) ? (args[Number(ch)] ?? "") : ch === "n" ? "\n" : ch;
+    } else output += template[i];
+  }
+  return output;
+}
+
+export function applySed(text, commands, quiet, readFile = () => "") {
+  if (!text) return "";
+  const trailing = text.endsWith("\n"), lines = text.split("\n");
+  if (trailing) lines.pop();
+  const active = new Set(), output = [];
+  let hold = "";
+  for (let index = 0; index < lines.length; index++) {
+    let pattern = lines[index], deleted = false, changed = false, quit = false;
+    const appended = [];
+    const emit = value => output.push(value + (index < lines.length-1 || trailing ? "\n" : ""));
+    const matches = a => a.last ? index === lines.length-1 : a.line !== undefined ? index+1 === a.line : a.regex.test(pattern);
+    for (let pc = 0; pc < commands.length; pc++) {
+      const c = commands[pc];
+      let selected = !c.first || matches(c.first);
+      if (c.second) {
+        const wasActive = active.has(pc);
+        selected ||= wasActive;
+        if (selected) {
+          active.add(pc);
+          if ((wasActive || !c.second.regex) && (c.second.line !== undefined ? index+1 >= c.second.line : matches(c.second))) active.delete(pc);
+        }
+      }
+      if (c.invert) selected = !selected;
+      if (!selected) { if (c.op === "{") pc = c.end; continue; }
+      if (c.op === "s") {
+        let count = 0, replaced = false;
+        pattern = pattern.replace(c.regex,(...args) => {
+          count++;
+          if (count !== c.occurrence && !(c.global && count >= c.occurrence)) return args[0];
+          replaced = true; return replacementText(c.replacement,args);
+        });
+        changed ||= replaced;
+        if (replaced && c.print) emit(pattern);
+      } else if (c.op === "y") pattern = [...pattern].map(ch => { const at=c.from.indexOf(ch); return at<0 ? ch : c.to[at]; }).join("");
+      else if (c.op === "p") emit(pattern);
+      else if (c.op === "P") emit(pattern.split("\n")[0]);
+      else if (c.op === "=") emit(String(index+1));
+      else if (c.op === "h") hold = pattern;
+      else if (c.op === "H") hold += "\n" + pattern;
+      else if (c.op === "g") pattern = hold;
+      else if (c.op === "G") pattern += "\n" + hold;
+      else if (c.op === "x") [pattern,hold] = [hold,pattern];
+      else if (c.op === "d") { deleted=true; break; }
+      else if (c.op === "D") { const nl=pattern.indexOf("\n"); if (nl<0) { deleted=true; break; } pattern=pattern.slice(nl+1); pc=-1; }
+      else if (c.op === "q") { quit=true; break; }
+      else if (c.op === "n" || c.op === "N") {
+        if (c.op === "n" && !quiet) emit(pattern);
+        if (index+1 >= lines.length) { deleted = c.op === "n"; quit=true; break; }
+        pattern = (c.op === "N" ? pattern + "\n" : "") + lines[++index]; changed=false;
+      } else if (["b","t","T"].includes(c.op)) {
+        const take = c.op === "b" || (c.op === "t" ? changed : !changed);
+        if (c.op !== "b") changed=false;
+        if (take) pc=c.target-1;
+      } else if (c.op === "r") appended.push(readFile(c.file));
+      else if (c.op === "a") appended.push(c.text+"\n");
+      else if (c.op === "i") output.push(c.text+"\n");
+      else if (c.op === "c") { if (!c.second || !active.has(pc)) output.push(c.text+"\n"); deleted=true; break; }
+    }
+    if (!quiet && !deleted) emit(pattern);
+    output.push(...appended);
+    if (quit) break;
+  }
+  return output.join("");
+}