lcclaude 1.0.0

package/dist/src/utils/bash/bashParser.js

@@ -0,0 +1,3625 @@
+const PARSE_TIMEOUT_MS = 50;
+const MAX_NODES = 50000;
+const MODULE = { parse: parseSource };
+const READY = Promise.resolve();
+export function ensureParserInitialized() {
+  return READY;
+}
+export function getParserModule() {
+  return MODULE;
+}
+const SPECIAL_VARS = new Set(["?", "$", "@", "*", "#", "-", "!", "_"]);
+const DECL_KEYWORDS = new Set([
+  "export",
+  "declare",
+  "typeset",
+  "readonly",
+  "local"
+]);
+export const SHELL_KEYWORDS = new Set([
+  "if",
+  "then",
+  "elif",
+  "else",
+  "fi",
+  "while",
+  "until",
+  "for",
+  "in",
+  "do",
+  "done",
+  "case",
+  "esac",
+  "function",
+  "select"
+]);
+function makeLexer(src) {
+  return {
+    src,
+    len: src.length,
+    i: 0,
+    b: 0,
+    heredocs: [],
+    byteTable: null
+  };
+}
+function advance(L) {
+  const c = L.src.charCodeAt(L.i);
+  L.i++;
+  if (c < 128) {
+    L.b++;
+  } else if (c < 2048) {
+    L.b += 2;
+  } else if (c >= 55296 && c <= 56319) {
+    L.b += 4;
+    L.i++;
+  } else {
+    L.b += 3;
+  }
+}
+function peek(L, off = 0) {
+  return L.i + off < L.len ? L.src[L.i + off] : "";
+}
+function byteAt(L, charIdx) {
+  if (L.byteTable)
+    return L.byteTable[charIdx];
+  const t = new Uint32Array(L.len + 1);
+  let b = 0;
+  let i = 0;
+  while (i < L.len) {
+    t[i] = b;
+    const c = L.src.charCodeAt(i);
+    if (c < 128) {
+      b++;
+      i++;
+    } else if (c < 2048) {
+      b += 2;
+      i++;
+    } else if (c >= 55296 && c <= 56319) {
+      t[i + 1] = b + 2;
+      b += 4;
+      i += 2;
+    } else {
+      b += 3;
+      i++;
+    }
+  }
+  t[L.len] = b;
+  L.byteTable = t;
+  return t[charIdx];
+}
+function isWordChar(c) {
+  return c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c >= "0" && c <= "9" || c === "_" || c === "/" || c === "." || c === "-" || c === "+" || c === ":" || c === "@" || c === "%" || c === "," || c === "~" || c === "^" || c === "?" || c === "*" || c === "!" || c === "=" || c === "[" || c === "]";
+}
+function isWordStart(c) {
+  return isWordChar(c) || c === "\\";
+}
+function isIdentStart(c) {
+  return c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c === "_";
+}
+function isIdentChar(c) {
+  return isIdentStart(c) || c >= "0" && c <= "9";
+}
+function isDigit(c) {
+  return c >= "0" && c <= "9";
+}
+function isHexDigit(c) {
+  return isDigit(c) || c >= "a" && c <= "f" || c >= "A" && c <= "F";
+}
+function isBaseDigit(c) {
+  return isIdentChar(c) || c === "@";
+}
+function isHeredocDelimChar(c) {
+  return c !== "" && c !== " " && c !== "\t" && c !== `
+` && c !== "<" && c !== ">" && c !== "|" && c !== "&" && c !== ";" && c !== "(" && c !== ")" && c !== "'" && c !== '"' && c !== "`" && c !== "\\";
+}
+function skipBlanks(L) {
+  while (L.i < L.len) {
+    const c = L.src[L.i];
+    if (c === " " || c === "\t" || c === "\r") {
+      advance(L);
+    } else if (c === "\\") {
+      const nx = L.src[L.i + 1];
+      if (nx === `
+` || nx === "\r" && L.src[L.i + 2] === `
+`) {
+        advance(L);
+        advance(L);
+        if (nx === "\r")
+          advance(L);
+      } else if (nx === " " || nx === "\t") {
+        advance(L);
+        advance(L);
+      } else {
+        break;
+      }
+    } else {
+      break;
+    }
+  }
+}
+function nextToken(L, ctx = "arg") {
+  skipBlanks(L);
+  const start = L.b;
+  if (L.i >= L.len)
+    return { type: "EOF", value: "", start, end: start };
+  const c = L.src[L.i];
+  const c1 = peek(L, 1);
+  const c2 = peek(L, 2);
+  if (c === `
+`) {
+    advance(L);
+    return { type: "NEWLINE", value: `
+`, start, end: L.b };
+  }
+  if (c === "#") {
+    const si = L.i;
+    while (L.i < L.len && L.src[L.i] !== `
+`)
+      advance(L);
+    return {
+      type: "COMMENT",
+      value: L.src.slice(si, L.i),
+      start,
+      end: L.b
+    };
+  }
+  if (c === "&" && c1 === "&") {
+    advance(L);
+    advance(L);
+    return { type: "OP", value: "&&", start, end: L.b };
+  }
+  if (c === "|" && c1 === "|") {
+    advance(L);
+    advance(L);
+    return { type: "OP", value: "||", start, end: L.b };
+  }
+  if (c === "|" && c1 === "&") {
+    advance(L);
+    advance(L);
+    return { type: "OP", value: "|&", start, end: L.b };
+  }
+  if (c === ";" && c1 === ";" && c2 === "&") {
+    advance(L);
+    advance(L);
+    advance(L);
+    return { type: "OP", value: ";;&", start, end: L.b };
+  }
+  if (c === ";" && c1 === ";") {
+    advance(L);
+    advance(L);
+    return { type: "OP", value: ";;", start, end: L.b };
+  }
+  if (c === ";" && c1 === "&") {
+    advance(L);
+    advance(L);
+    return { type: "OP", value: ";&", start, end: L.b };
+  }
+  if (c === ">" && c1 === ">") {
+    advance(L);
+    advance(L);
+    return { type: "OP", value: ">>", start, end: L.b };
+  }
+  if (c === ">" && c1 === "&" && c2 === "-") {
+    advance(L);
+    advance(L);
+    advance(L);
+    return { type: "OP", value: ">&-", start, end: L.b };
+  }
+  if (c === ">" && c1 === "&") {
+    advance(L);
+    advance(L);
+    return { type: "OP", value: ">&", start, end: L.b };
+  }
+  if (c === ">" && c1 === "|") {
+    advance(L);
+    advance(L);
+    return { type: "OP", value: ">|", start, end: L.b };
+  }
+  if (c === "&" && c1 === ">" && c2 === ">") {
+    advance(L);
+    advance(L);
+    advance(L);
+    return { type: "OP", value: "&>>", start, end: L.b };
+  }
+  if (c === "&" && c1 === ">") {
+    advance(L);
+    advance(L);
+    return { type: "OP", value: "&>", start, end: L.b };
+  }
+  if (c === "<" && c1 === "<" && c2 === "<") {
+    advance(L);
+    advance(L);
+    advance(L);
+    return { type: "OP", value: "<<<", start, end: L.b };
+  }
+  if (c === "<" && c1 === "<" && c2 === "-") {
+    advance(L);
+    advance(L);
+    advance(L);
+    return { type: "OP", value: "<<-", start, end: L.b };
+  }
+  if (c === "<" && c1 === "<") {
+    advance(L);
+    advance(L);
+    return { type: "OP", value: "<<", start, end: L.b };
+  }
+  if (c === "<" && c1 === "&" && c2 === "-") {
+    advance(L);
+    advance(L);
+    advance(L);
+    return { type: "OP", value: "<&-", start, end: L.b };
+  }
+  if (c === "<" && c1 === "&") {
+    advance(L);
+    advance(L);
+    return { type: "OP", value: "<&", start, end: L.b };
+  }
+  if (c === "<" && c1 === "(") {
+    advance(L);
+    advance(L);
+    return { type: "LT_PAREN", value: "<(", start, end: L.b };
+  }
+  if (c === ">" && c1 === "(") {
+    advance(L);
+    advance(L);
+    return { type: "GT_PAREN", value: ">(", start, end: L.b };
+  }
+  if (c === "(" && c1 === "(") {
+    advance(L);
+    advance(L);
+    return { type: "OP", value: "((", start, end: L.b };
+  }
+  if (c === ")" && c1 === ")") {
+    advance(L);
+    advance(L);
+    return { type: "OP", value: "))", start, end: L.b };
+  }
+  if (c === "|" || c === "&" || c === ";" || c === ">" || c === "<") {
+    advance(L);
+    return { type: "OP", value: c, start, end: L.b };
+  }
+  if (c === "(" || c === ")") {
+    advance(L);
+    return { type: "OP", value: c, start, end: L.b };
+  }
+  if (ctx === "cmd") {
+    if (c === "[" && c1 === "[") {
+      advance(L);
+      advance(L);
+      return { type: "OP", value: "[[", start, end: L.b };
+    }
+    if (c === "[") {
+      advance(L);
+      return { type: "OP", value: "[", start, end: L.b };
+    }
+    if (c === "{" && (c1 === " " || c1 === "\t" || c1 === `
+`)) {
+      advance(L);
+      return { type: "OP", value: "{", start, end: L.b };
+    }
+    if (c === "}") {
+      advance(L);
+      return { type: "OP", value: "}", start, end: L.b };
+    }
+    if (c === "!" && (c1 === " " || c1 === "\t")) {
+      advance(L);
+      return { type: "OP", value: "!", start, end: L.b };
+    }
+  }
+  if (c === '"') {
+    advance(L);
+    return { type: "DQUOTE", value: '"', start, end: L.b };
+  }
+  if (c === "'") {
+    const si = L.i;
+    advance(L);
+    while (L.i < L.len && L.src[L.i] !== "'")
+      advance(L);
+    if (L.i < L.len)
+      advance(L);
+    return {
+      type: "SQUOTE",
+      value: L.src.slice(si, L.i),
+      start,
+      end: L.b
+    };
+  }
+  if (c === "$") {
+    if (c1 === "(" && c2 === "(") {
+      advance(L);
+      advance(L);
+      advance(L);
+      return { type: "DOLLAR_DPAREN", value: "$((", start, end: L.b };
+    }
+    if (c1 === "(") {
+      advance(L);
+      advance(L);
+      return { type: "DOLLAR_PAREN", value: "$(", start, end: L.b };
+    }
+    if (c1 === "{") {
+      advance(L);
+      advance(L);
+      return { type: "DOLLAR_BRACE", value: "${", start, end: L.b };
+    }
+    if (c1 === "'") {
+      const si = L.i;
+      advance(L);
+      advance(L);
+      while (L.i < L.len && L.src[L.i] !== "'") {
+        if (L.src[L.i] === "\\" && L.i + 1 < L.len)
+          advance(L);
+        advance(L);
+      }
+      if (L.i < L.len)
+        advance(L);
+      return {
+        type: "ANSI_C",
+        value: L.src.slice(si, L.i),
+        start,
+        end: L.b
+      };
+    }
+    advance(L);
+    return { type: "DOLLAR", value: "$", start, end: L.b };
+  }
+  if (c === "`") {
+    advance(L);
+    return { type: "BACKTICK", value: "`", start, end: L.b };
+  }
+  if (isDigit(c)) {
+    let j = L.i;
+    while (j < L.len && isDigit(L.src[j]))
+      j++;
+    const after = j < L.len ? L.src[j] : "";
+    if (after === ">" || after === "<") {
+      const si = L.i;
+      while (L.i < j)
+        advance(L);
+      return {
+        type: "WORD",
+        value: L.src.slice(si, L.i),
+        start,
+        end: L.b
+      };
+    }
+  }
+  if (isWordStart(c) || c === "{" || c === "}") {
+    const si = L.i;
+    while (L.i < L.len) {
+      const ch = L.src[L.i];
+      if (ch === "\\") {
+        if (L.i + 1 >= L.len) {
+          break;
+        }
+        if (L.src[L.i + 1] === `
+`) {
+          advance(L);
+          advance(L);
+          continue;
+        }
+        advance(L);
+        advance(L);
+        continue;
+      }
+      if (!isWordChar(ch) && ch !== "{" && ch !== "}") {
+        break;
+      }
+      advance(L);
+    }
+    if (L.i > si) {
+      const v = L.src.slice(si, L.i);
+      if (/^-?\d+$/.test(v)) {
+        return { type: "NUMBER", value: v, start, end: L.b };
+      }
+      return { type: "WORD", value: v, start, end: L.b };
+    }
+  }
+  advance(L);
+  return { type: "WORD", value: c, start, end: L.b };
+}
+function parseSource(source, timeoutMs) {
+  const L = makeLexer(source);
+  const srcBytes = byteLengthUtf8(source);
+  const P = {
+    L,
+    src: source,
+    srcBytes,
+    isAscii: srcBytes === source.length,
+    nodeCount: 0,
+    deadline: performance.now() + (timeoutMs ?? PARSE_TIMEOUT_MS),
+    aborted: false,
+    inBacktick: 0,
+    stopToken: null
+  };
+  try {
+    const program = parseProgram(P);
+    if (P.aborted)
+      return null;
+    return program;
+  } catch {
+    return null;
+  }
+}
+function byteLengthUtf8(s) {
+  let b = 0;
+  for (let i = 0;i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 128)
+      b++;
+    else if (c < 2048)
+      b += 2;
+    else if (c >= 55296 && c <= 56319) {
+      b += 4;
+      i++;
+    } else
+      b += 3;
+  }
+  return b;
+}
+function checkBudget(P) {
+  P.nodeCount++;
+  if (P.nodeCount > MAX_NODES) {
+    P.aborted = true;
+    throw new Error("budget");
+  }
+  if ((P.nodeCount & 127) === 0 && performance.now() > P.deadline) {
+    P.aborted = true;
+    throw new Error("timeout");
+  }
+}
+function mk(P, type, start, end, children) {
+  checkBudget(P);
+  return {
+    type,
+    text: sliceBytes(P, start, end),
+    startIndex: start,
+    endIndex: end,
+    children
+  };
+}
+function sliceBytes(P, startByte, endByte) {
+  if (P.isAscii)
+    return P.src.slice(startByte, endByte);
+  const L = P.L;
+  if (!L.byteTable)
+    byteAt(L, 0);
+  const t = L.byteTable;
+  let lo = 0;
+  let hi = P.src.length;
+  while (lo < hi) {
+    const m = lo + hi >>> 1;
+    if (t[m] < startByte)
+      lo = m + 1;
+    else
+      hi = m;
+  }
+  const sc = lo;
+  lo = sc;
+  hi = P.src.length;
+  while (lo < hi) {
+    const m = lo + hi >>> 1;
+    if (t[m] < endByte)
+      lo = m + 1;
+    else
+      hi = m;
+  }
+  return P.src.slice(sc, lo);
+}
+function leaf(P, type, tok) {
+  return mk(P, type, tok.start, tok.end, []);
+}
+function parseProgram(P) {
+  const children = [];
+  skipBlanks(P.L);
+  while (true) {
+    const save = saveLex(P.L);
+    const t = nextToken(P.L, "cmd");
+    if (t.type === "NEWLINE") {
+      skipBlanks(P.L);
+      continue;
+    }
+    restoreLex(P.L, save);
+    break;
+  }
+  const progStart = P.L.b;
+  while (P.L.i < P.L.len) {
+    const save = saveLex(P.L);
+    const t = nextToken(P.L, "cmd");
+    if (t.type === "EOF")
+      break;
+    if (t.type === "NEWLINE")
+      continue;
+    if (t.type === "COMMENT") {
+      children.push(leaf(P, "comment", t));
+      continue;
+    }
+    restoreLex(P.L, save);
+    const stmts = parseStatements(P, null);
+    for (const s of stmts)
+      children.push(s);
+    if (stmts.length === 0) {
+      const errTok = nextToken(P.L, "cmd");
+      if (errTok.type === "EOF")
+        break;
+      if (errTok.type === "OP" && errTok.value === ";;" && children.length > 0) {
+        continue;
+      }
+      children.push(mk(P, "ERROR", errTok.start, errTok.end, []));
+    }
+  }
+  const progEnd = children.length > 0 ? P.srcBytes : progStart;
+  return mk(P, "program", progStart, progEnd, children);
+}
+function saveLex(L) {
+  return L.b * 65536 + L.i;
+}
+function restoreLex(L, s) {
+  L.i = s & 65535;
+  L.b = s >>> 16;
+}
+function parseStatements(P, terminator) {
+  const out = [];
+  while (true) {
+    skipBlanks(P.L);
+    const save = saveLex(P.L);
+    const t = nextToken(P.L, "cmd");
+    if (t.type === "EOF") {
+      restoreLex(P.L, save);
+      break;
+    }
+    if (t.type === "NEWLINE") {
+      if (P.L.heredocs.length > 0) {
+        scanHeredocBodies(P);
+      }
+      continue;
+    }
+    if (t.type === "COMMENT") {
+      out.push(leaf(P, "comment", t));
+      continue;
+    }
+    if (terminator && t.type === "OP" && t.value === terminator) {
+      restoreLex(P.L, save);
+      break;
+    }
+    if (t.type === "OP" && (t.value === ")" || t.value === "}" || t.value === ";;" || t.value === ";&" || t.value === ";;&" || t.value === "))" || t.value === "]]" || t.value === "]")) {
+      restoreLex(P.L, save);
+      break;
+    }
+    if (t.type === "BACKTICK" && P.inBacktick > 0) {
+      restoreLex(P.L, save);
+      break;
+    }
+    if (t.type === "WORD" && (t.value === "then" || t.value === "elif" || t.value === "else" || t.value === "fi" || t.value === "do" || t.value === "done" || t.value === "esac")) {
+      restoreLex(P.L, save);
+      break;
+    }
+    restoreLex(P.L, save);
+    const stmt = parseAndOr(P);
+    if (!stmt)
+      break;
+    out.push(stmt);
+    skipBlanks(P.L);
+    const save2 = saveLex(P.L);
+    const sep = nextToken(P.L, "cmd");
+    if (sep.type === "OP" && (sep.value === ";" || sep.value === "&")) {
+      const save3 = saveLex(P.L);
+      const after = nextToken(P.L, "cmd");
+      restoreLex(P.L, save3);
+      out.push(leaf(P, sep.value, sep));
+      if (after.type === "EOF" || after.type === "OP" && (after.value === ")" || after.value === "}" || after.value === ";;" || after.value === ";&" || after.value === ";;&") || after.type === "WORD" && (after.value === "then" || after.value === "elif" || after.value === "else" || after.value === "fi" || after.value === "do" || after.value === "done" || after.value === "esac")) {
+        continue;
+      }
+    } else if (sep.type === "NEWLINE") {
+      if (P.L.heredocs.length > 0) {
+        scanHeredocBodies(P);
+      }
+      continue;
+    } else {
+      restoreLex(P.L, save2);
+    }
+  }
+  return out;
+}
+function parseAndOr(P) {
+  let left = parsePipeline(P);
+  if (!left)
+    return null;
+  while (true) {
+    const save = saveLex(P.L);
+    const t = nextToken(P.L, "cmd");
+    if (t.type === "OP" && (t.value === "&&" || t.value === "||")) {
+      const op = leaf(P, t.value, t);
+      skipNewlines(P);
+      const right = parsePipeline(P);
+      if (!right) {
+        left = mk(P, "list", left.startIndex, op.endIndex, [left, op]);
+        break;
+      }
+      if (right.type === "redirected_statement" && right.children.length >= 2) {
+        const inner = right.children[0];
+        const redirs = right.children.slice(1);
+        const listNode = mk(P, "list", left.startIndex, inner.endIndex, [
+          left,
+          op,
+          inner
+        ]);
+        const lastR = redirs[redirs.length - 1];
+        left = mk(P, "redirected_statement", listNode.startIndex, lastR.endIndex, [listNode, ...redirs]);
+      } else {
+        left = mk(P, "list", left.startIndex, right.endIndex, [left, op, right]);
+      }
+    } else {
+      restoreLex(P.L, save);
+      break;
+    }
+  }
+  return left;
+}
+function skipNewlines(P) {
+  while (true) {
+    const save = saveLex(P.L);
+    const t = nextToken(P.L, "cmd");
+    if (t.type !== "NEWLINE") {
+      restoreLex(P.L, save);
+      break;
+    }
+  }
+}
+function parsePipeline(P) {
+  let first = parseCommand(P);
+  if (!first)
+    return null;
+  const parts = [first];
+  while (true) {
+    const save = saveLex(P.L);
+    const t = nextToken(P.L, "cmd");
+    if (t.type === "OP" && (t.value === "|" || t.value === "|&")) {
+      const op = leaf(P, t.value, t);
+      skipNewlines(P);
+      const next = parseCommand(P);
+      if (!next) {
+        parts.push(op);
+        break;
+      }
+      if (next.type === "redirected_statement" && next.children.length >= 2 && parts.length >= 1) {
+        const inner = next.children[0];
+        const redirs = next.children.slice(1);
+        const pipeKids = [...parts, op, inner];
+        const pipeNode = mk(P, "pipeline", pipeKids[0].startIndex, inner.endIndex, pipeKids);
+        const lastR = redirs[redirs.length - 1];
+        const wrapped = mk(P, "redirected_statement", pipeNode.startIndex, lastR.endIndex, [pipeNode, ...redirs]);
+        parts.length = 0;
+        parts.push(wrapped);
+        first = wrapped;
+        continue;
+      }
+      parts.push(op, next);
+    } else {
+      restoreLex(P.L, save);
+      break;
+    }
+  }
+  if (parts.length === 1)
+    return parts[0];
+  const last = parts[parts.length - 1];
+  return mk(P, "pipeline", parts[0].startIndex, last.endIndex, parts);
+}
+function parseCommand(P) {
+  skipBlanks(P.L);
+  const save = saveLex(P.L);
+  const t = nextToken(P.L, "cmd");
+  if (t.type === "EOF") {
+    restoreLex(P.L, save);
+    return null;
+  }
+  if (t.type === "OP" && t.value === "!") {
+    const bang = leaf(P, "!", t);
+    const inner = parseCommand(P);
+    if (!inner) {
+      restoreLex(P.L, save);
+      return null;
+    }
+    if (inner.type === "redirected_statement" && inner.children.length >= 2) {
+      const cmd = inner.children[0];
+      const redirs = inner.children.slice(1);
+      const neg = mk(P, "negated_command", bang.startIndex, cmd.endIndex, [
+        bang,
+        cmd
+      ]);
+      const lastR = redirs[redirs.length - 1];
+      return mk(P, "redirected_statement", neg.startIndex, lastR.endIndex, [
+        neg,
+        ...redirs
+      ]);
+    }
+    return mk(P, "negated_command", bang.startIndex, inner.endIndex, [
+      bang,
+      inner
+    ]);
+  }
+  if (t.type === "OP" && t.value === "(") {
+    const open = leaf(P, "(", t);
+    const body = parseStatements(P, ")");
+    const closeTok = nextToken(P.L, "cmd");
+    const close = closeTok.type === "OP" && closeTok.value === ")" ? leaf(P, ")", closeTok) : mk(P, ")", open.endIndex, open.endIndex, []);
+    const node = mk(P, "subshell", open.startIndex, close.endIndex, [
+      open,
+      ...body,
+      close
+    ]);
+    return maybeRedirect(P, node);
+  }
+  if (t.type === "OP" && t.value === "((") {
+    const open = leaf(P, "((", t);
+    const exprs = parseArithCommaList(P, "))", "var");
+    const closeTok = nextToken(P.L, "cmd");
+    const close = closeTok.value === "))" ? leaf(P, "))", closeTok) : mk(P, "))", open.endIndex, open.endIndex, []);
+    return mk(P, "compound_statement", open.startIndex, close.endIndex, [
+      open,
+      ...exprs,
+      close
+    ]);
+  }
+  if (t.type === "OP" && t.value === "{") {
+    const open = leaf(P, "{", t);
+    const body = parseStatements(P, "}");
+    const closeTok = nextToken(P.L, "cmd");
+    const close = closeTok.type === "OP" && closeTok.value === "}" ? leaf(P, "}", closeTok) : mk(P, "}", open.endIndex, open.endIndex, []);
+    const node = mk(P, "compound_statement", open.startIndex, close.endIndex, [
+      open,
+      ...body,
+      close
+    ]);
+    return maybeRedirect(P, node);
+  }
+  if (t.type === "OP" && (t.value === "[" || t.value === "[[")) {
+    const open = leaf(P, t.value, t);
+    const closer = t.value === "[" ? "]" : "]]";
+    const exprSave = saveLex(P.L);
+    let expr = parseTestExpr(P, closer);
+    skipBlanks(P.L);
+    if (t.value === "[" && peek(P.L) !== "]") {
+      restoreLex(P.L, exprSave);
+      const prevStop = P.stopToken;
+      P.stopToken = "]";
+      const rstmt = parseCommand(P);
+      P.stopToken = prevStop;
+      if (rstmt && rstmt.type === "redirected_statement") {
+        expr = rstmt;
+      } else {
+        restoreLex(P.L, exprSave);
+        expr = parseTestExpr(P, closer);
+      }
+      skipBlanks(P.L);
+    }
+    const closeTok = nextToken(P.L, "arg");
+    let close;
+    if (closeTok.value === closer) {
+      close = leaf(P, closer, closeTok);
+    } else {
+      close = mk(P, closer, open.endIndex, open.endIndex, []);
+    }
+    const kids = expr ? [open, expr, close] : [open, close];
+    return mk(P, "test_command", open.startIndex, close.endIndex, kids);
+  }
+  if (t.type === "WORD") {
+    if (t.value === "if")
+      return maybeRedirect(P, parseIf(P, t), true);
+    if (t.value === "while" || t.value === "until")
+      return maybeRedirect(P, parseWhile(P, t), true);
+    if (t.value === "for")
+      return maybeRedirect(P, parseFor(P, t), true);
+    if (t.value === "select")
+      return maybeRedirect(P, parseFor(P, t), true);
+    if (t.value === "case")
+      return maybeRedirect(P, parseCase(P, t), true);
+    if (t.value === "function")
+      return parseFunction(P, t);
+    if (DECL_KEYWORDS.has(t.value))
+      return maybeRedirect(P, parseDeclaration(P, t));
+    if (t.value === "unset" || t.value === "unsetenv") {
+      return maybeRedirect(P, parseUnset(P, t));
+    }
+  }
+  restoreLex(P.L, save);
+  return parseSimpleCommand(P);
+}
+function parseSimpleCommand(P) {
+  const start = P.L.b;
+  const assignments = [];
+  const preRedirects = [];
+  while (true) {
+    skipBlanks(P.L);
+    const a = tryParseAssignment(P);
+    if (a) {
+      assignments.push(a);
+      continue;
+    }
+    const r = tryParseRedirect(P);
+    if (r) {
+      preRedirects.push(r);
+      continue;
+    }
+    break;
+  }
+  skipBlanks(P.L);
+  const save = saveLex(P.L);
+  const nameTok = nextToken(P.L, "cmd");
+  if (nameTok.type === "EOF" || nameTok.type === "NEWLINE" || nameTok.type === "COMMENT" || nameTok.type === "OP" && nameTok.value !== "{" && nameTok.value !== "[" && nameTok.value !== "[[" || nameTok.type === "WORD" && SHELL_KEYWORDS.has(nameTok.value) && nameTok.value !== "in") {
+    restoreLex(P.L, save);
+    if (assignments.length === 1 && preRedirects.length === 0) {
+      return assignments[0];
+    }
+    if (preRedirects.length > 0 && assignments.length === 0) {
+      const last = preRedirects[preRedirects.length - 1];
+      return mk(P, "redirected_statement", preRedirects[0].startIndex, last.endIndex, preRedirects);
+    }
+    if (assignments.length > 1 && preRedirects.length === 0) {
+      const last = assignments[assignments.length - 1];
+      return mk(P, "variable_assignments", assignments[0].startIndex, last.endIndex, assignments);
+    }
+    if (assignments.length > 0 || preRedirects.length > 0) {
+      const all = [...assignments, ...preRedirects];
+      const last = all[all.length - 1];
+      return mk(P, "command", start, last.endIndex, all);
+    }
+    return null;
+  }
+  restoreLex(P.L, save);
+  const fnSave = saveLex(P.L);
+  const nm = parseWord(P, "cmd");
+  if (nm && nm.type === "word") {
+    skipBlanks(P.L);
+    if (peek(P.L) === "(" && peek(P.L, 1) === ")") {
+      const oTok = nextToken(P.L, "cmd");
+      const cTok = nextToken(P.L, "cmd");
+      const oParen = leaf(P, "(", oTok);
+      const cParen = leaf(P, ")", cTok);
+      skipBlanks(P.L);
+      skipNewlines(P);
+      const body = parseCommand(P);
+      if (body) {
+        let bodyKids = [body];
+        if (body.type === "redirected_statement" && body.children.length >= 2 && body.children[0].type === "compound_statement") {
+          bodyKids = body.children;
+        }
+        const last = bodyKids[bodyKids.length - 1];
+        return mk(P, "function_definition", nm.startIndex, last.endIndex, [
+          nm,
+          oParen,
+          cParen,
+          ...bodyKids
+        ]);
+      }
+    }
+  }
+  restoreLex(P.L, fnSave);
+  const nameArg = parseWord(P, "cmd");
+  if (!nameArg) {
+    if (assignments.length === 1)
+      return assignments[0];
+    return null;
+  }
+  const cmdName = mk(P, "command_name", nameArg.startIndex, nameArg.endIndex, [
+    nameArg
+  ]);
+  const args = [];
+  const redirects = [];
+  let heredocRedirect = null;
+  while (true) {
+    skipBlanks(P.L);
+    const r = tryParseRedirect(P, true);
+    if (r) {
+      if (r.type === "heredoc_redirect") {
+        heredocRedirect = r;
+      } else if (r.type === "herestring_redirect") {
+        args.push(r);
+      } else {
+        redirects.push(r);
+      }
+      continue;
+    }
+    if (redirects.length > 0)
+      break;
+    if (P.stopToken === "]" && peek(P.L) === "]")
+      break;
+    const save2 = saveLex(P.L);
+    const pk = nextToken(P.L, "arg");
+    if (pk.type === "EOF" || pk.type === "NEWLINE" || pk.type === "COMMENT" || pk.type === "OP" && (pk.value === "|" || pk.value === "|&" || pk.value === "&&" || pk.value === "||" || pk.value === ";" || pk.value === ";;" || pk.value === ";&" || pk.value === ";;&" || pk.value === "&" || pk.value === ")" || pk.value === "}" || pk.value === "))")) {
+      restoreLex(P.L, save2);
+      break;
+    }
+    restoreLex(P.L, save2);
+    const arg = parseWord(P, "arg");
+    if (!arg) {
+      if (peek(P.L) === "(") {
+        const oTok = nextToken(P.L, "cmd");
+        const open = leaf(P, "(", oTok);
+        const body = parseStatements(P, ")");
+        const cTok = nextToken(P.L, "cmd");
+        const close = cTok.type === "OP" && cTok.value === ")" ? leaf(P, ")", cTok) : mk(P, ")", open.endIndex, open.endIndex, []);
+        args.push(mk(P, "subshell", open.startIndex, close.endIndex, [
+          open,
+          ...body,
+          close
+        ]));
+        continue;
+      }
+      break;
+    }
+    if (arg.type === "word" && arg.text === "=") {
+      args.push(mk(P, "ERROR", arg.startIndex, arg.endIndex, [arg]));
+      continue;
+    }
+    if ((arg.type === "word" || arg.type === "concatenation") && peek(P.L) === "(" && P.L.b === arg.endIndex) {
+      args.push(mk(P, "ERROR", arg.startIndex, arg.endIndex, [arg]));
+      continue;
+    }
+    args.push(arg);
+  }
+  const cmdChildren = [...assignments, ...preRedirects, cmdName, ...args];
+  const cmdEnd = cmdChildren.length > 0 ? cmdChildren[cmdChildren.length - 1].endIndex : cmdName.endIndex;
+  const cmdStart = cmdChildren[0].startIndex;
+  const cmd = mk(P, "command", cmdStart, cmdEnd, cmdChildren);
+  if (heredocRedirect) {
+    scanHeredocBodies(P);
+    const hd = P.L.heredocs.shift();
+    if (hd && heredocRedirect.children.length >= 2) {
+      const bodyNode = mk(P, "heredoc_body", hd.bodyStart, hd.bodyEnd, hd.quoted ? [] : parseHeredocBodyContent(P, hd.bodyStart, hd.bodyEnd));
+      const endNode = mk(P, "heredoc_end", hd.endStart, hd.endEnd, []);
+      heredocRedirect.children.push(bodyNode, endNode);
+      heredocRedirect.endIndex = hd.endEnd;
+      heredocRedirect.text = sliceBytes(P, heredocRedirect.startIndex, hd.endEnd);
+    }
+    const allR = [...preRedirects, heredocRedirect, ...redirects];
+    const rStart = preRedirects.length > 0 ? Math.min(cmd.startIndex, preRedirects[0].startIndex) : cmd.startIndex;
+    return mk(P, "redirected_statement", rStart, heredocRedirect.endIndex, [
+      cmd,
+      ...allR
+    ]);
+  }
+  if (redirects.length > 0) {
+    const last = redirects[redirects.length - 1];
+    return mk(P, "redirected_statement", cmd.startIndex, last.endIndex, [
+      cmd,
+      ...redirects
+    ]);
+  }
+  return cmd;
+}
+function maybeRedirect(P, node, allowHerestring = false) {
+  const redirects = [];
+  while (true) {
+    skipBlanks(P.L);
+    const save = saveLex(P.L);
+    const r = tryParseRedirect(P);
+    if (!r)
+      break;
+    if (r.type === "herestring_redirect" && !allowHerestring) {
+      restoreLex(P.L, save);
+      break;
+    }
+    redirects.push(r);
+  }
+  if (redirects.length === 0)
+    return node;
+  const last = redirects[redirects.length - 1];
+  return mk(P, "redirected_statement", node.startIndex, last.endIndex, [
+    node,
+    ...redirects
+  ]);
+}
+function tryParseAssignment(P) {
+  const save = saveLex(P.L);
+  skipBlanks(P.L);
+  const startB = P.L.b;
+  if (!isIdentStart(peek(P.L))) {
+    restoreLex(P.L, save);
+    return null;
+  }
+  while (isIdentChar(peek(P.L)))
+    advance(P.L);
+  const nameEnd = P.L.b;
+  let subEnd = nameEnd;
+  if (peek(P.L) === "[") {
+    advance(P.L);
+    let depth = 1;
+    while (P.L.i < P.L.len && depth > 0) {
+      const c = peek(P.L);
+      if (c === "[")
+        depth++;
+      else if (c === "]")
+        depth--;
+      advance(P.L);
+    }
+    subEnd = P.L.b;
+  }
+  const c = peek(P.L);
+  const c1 = peek(P.L, 1);
+  let op;
+  if (c === "=" && c1 !== "=") {
+    op = "=";
+  } else if (c === "+" && c1 === "=") {
+    op = "+=";
+  } else {
+    restoreLex(P.L, save);
+    return null;
+  }
+  const nameNode = mk(P, "variable_name", startB, nameEnd, []);
+  let lhs = nameNode;
+  if (subEnd > nameEnd) {
+    const brOpen = mk(P, "[", nameEnd, nameEnd + 1, []);
+    const idx = parseSubscriptIndex(P, nameEnd + 1, subEnd - 1);
+    const brClose = mk(P, "]", subEnd - 1, subEnd, []);
+    lhs = mk(P, "subscript", startB, subEnd, [nameNode, brOpen, idx, brClose]);
+  }
+  const opStart = P.L.b;
+  advance(P.L);
+  if (op === "+=")
+    advance(P.L);
+  const opEnd = P.L.b;
+  const opNode = mk(P, op, opStart, opEnd, []);
+  let val = null;
+  if (peek(P.L) === "(") {
+    const aoTok = nextToken(P.L, "cmd");
+    const aOpen = leaf(P, "(", aoTok);
+    const elems = [aOpen];
+    while (true) {
+      skipBlanks(P.L);
+      if (peek(P.L) === ")")
+        break;
+      const e = parseWord(P, "arg");
+      if (!e)
+        break;
+      elems.push(e);
+    }
+    const acTok = nextToken(P.L, "cmd");
+    const aClose = acTok.value === ")" ? leaf(P, ")", acTok) : mk(P, ")", aOpen.endIndex, aOpen.endIndex, []);
+    elems.push(aClose);
+    val = mk(P, "array", aOpen.startIndex, aClose.endIndex, elems);
+  } else {
+    const c2 = peek(P.L);
+    if (c2 && c2 !== " " && c2 !== "\t" && c2 !== `
+` && c2 !== ";" && c2 !== "&" && c2 !== "|" && c2 !== ")" && c2 !== "}") {
+      val = parseWord(P, "arg");
+    }
+  }
+  const kids = val ? [lhs, opNode, val] : [lhs, opNode];
+  const end = val ? val.endIndex : opEnd;
+  return mk(P, "variable_assignment", startB, end, kids);
+}
+function parseSubscriptIndexInline(P) {
+  skipBlanks(P.L);
+  const c = peek(P.L);
+  if ((c === "@" || c === "*") && peek(P.L, 1) === "]") {
+    const s = P.L.b;
+    advance(P.L);
+    return mk(P, "word", s, P.L.b, []);
+  }
+  if (c === "(" && peek(P.L, 1) === "(") {
+    const oStart = P.L.b;
+    advance(P.L);
+    advance(P.L);
+    const open = mk(P, "((", oStart, P.L.b, []);
+    const inner = parseArithExpr(P, "))", "var");
+    skipBlanks(P.L);
+    let close;
+    if (peek(P.L) === ")" && peek(P.L, 1) === ")") {
+      const cs = P.L.b;
+      advance(P.L);
+      advance(P.L);
+      close = mk(P, "))", cs, P.L.b, []);
+    } else {
+      close = mk(P, "))", P.L.b, P.L.b, []);
+    }
+    const kids = inner ? [open, inner, close] : [open, close];
+    return mk(P, "compound_statement", open.startIndex, close.endIndex, kids);
+  }
+  return parseArithExpr(P, "]", "word");
+}
+function parseSubscriptIndex(P, startB, endB) {
+  const text = sliceBytes(P, startB, endB);
+  if (/^\d+$/.test(text))
+    return mk(P, "number", startB, endB, []);
+  const m = /^\$([a-zA-Z_]\w*)$/.exec(text);
+  if (m) {
+    const dollar = mk(P, "$", startB, startB + 1, []);
+    const vn = mk(P, "variable_name", startB + 1, endB, []);
+    return mk(P, "simple_expansion", startB, endB, [dollar, vn]);
+  }
+  if (text.length === 2 && text[0] === "$" && SPECIAL_VARS.has(text[1])) {
+    const dollar = mk(P, "$", startB, startB + 1, []);
+    const vn = mk(P, "special_variable_name", startB + 1, endB, []);
+    return mk(P, "simple_expansion", startB, endB, [dollar, vn]);
+  }
+  return mk(P, "word", startB, endB, []);
+}
+function isRedirectLiteralStart(P) {
+  const c = peek(P.L);
+  if (c === "" || c === `
+`)
+    return false;
+  if (c === "|" || c === "&" || c === ";" || c === "(" || c === ")")
+    return false;
+  if (c === "<" || c === ">") {
+    return peek(P.L, 1) === "(";
+  }
+  if (isDigit(c)) {
+    let j = P.L.i;
+    while (j < P.L.len && isDigit(P.L.src[j]))
+      j++;
+    const after = j < P.L.len ? P.L.src[j] : "";
+    if (after === ">" || after === "<")
+      return false;
+  }
+  if (c === "}")
+    return false;
+  if (P.stopToken === "]" && c === "]")
+    return false;
+  return true;
+}
+function tryParseRedirect(P, greedy = false) {
+  const save = saveLex(P.L);
+  skipBlanks(P.L);
+  let fd = null;
+  if (isDigit(peek(P.L))) {
+    const startB = P.L.b;
+    let j = P.L.i;
+    while (j < P.L.len && isDigit(P.L.src[j]))
+      j++;
+    const after = j < P.L.len ? P.L.src[j] : "";
+    if (after === ">" || after === "<") {
+      while (P.L.i < j)
+        advance(P.L);
+      fd = mk(P, "file_descriptor", startB, P.L.b, []);
+    }
+  }
+  const t = nextToken(P.L, "arg");
+  if (t.type !== "OP") {
+    restoreLex(P.L, save);
+    return null;
+  }
+  const v = t.value;
+  if (v === "<<<") {
+    const op = leaf(P, "<<<", t);
+    skipBlanks(P.L);
+    const target = parseWord(P, "arg");
+    const end = target ? target.endIndex : op.endIndex;
+    const kids = target ? [op, target] : [op];
+    return mk(P, "herestring_redirect", fd ? fd.startIndex : op.startIndex, end, fd ? [fd, ...kids] : kids);
+  }
+  if (v === "<<" || v === "<<-") {
+    const op = leaf(P, v, t);
+    skipBlanks(P.L);
+    const dStart = P.L.b;
+    let quoted = false;
+    let delim = "";
+    const dc = peek(P.L);
+    if (dc === "'" || dc === '"') {
+      quoted = true;
+      advance(P.L);
+      while (P.L.i < P.L.len && peek(P.L) !== dc) {
+        delim += peek(P.L);
+        advance(P.L);
+      }
+      if (P.L.i < P.L.len)
+        advance(P.L);
+    } else if (dc === "\\") {
+      quoted = true;
+      advance(P.L);
+      if (P.L.i < P.L.len && peek(P.L) !== `
+`) {
+        delim += peek(P.L);
+        advance(P.L);
+      }
+      while (P.L.i < P.L.len && isIdentChar(peek(P.L))) {
+        delim += peek(P.L);
+        advance(P.L);
+      }
+    } else {
+      while (P.L.i < P.L.len && isHeredocDelimChar(peek(P.L))) {
+        delim += peek(P.L);
+        advance(P.L);
+      }
+    }
+    const dEnd = P.L.b;
+    const startNode = mk(P, "heredoc_start", dStart, dEnd, []);
+    P.L.heredocs.push({
+      delim,
+      stripTabs: v === "<<-",
+      quoted,
+      bodyStart: 0,
+      bodyEnd: 0,
+      endStart: 0,
+      endEnd: 0
+    });
+    const kids = fd ? [fd, op, startNode] : [op, startNode];
+    const startIdx = fd ? fd.startIndex : op.startIndex;
+    while (true) {
+      skipBlanks(P.L);
+      const tc = peek(P.L);
+      if (tc === `
+` || tc === "" || P.L.i >= P.L.len)
+        break;
+      if (tc === ">" || tc === "<" || isDigit(tc)) {
+        const rSave = saveLex(P.L);
+        const r = tryParseRedirect(P);
+        if (r && r.type === "file_redirect") {
+          kids.push(r);
+          continue;
+        }
+        restoreLex(P.L, rSave);
+      }
+      if (tc === "|" && peek(P.L, 1) !== "|") {
+        advance(P.L);
+        skipBlanks(P.L);
+        const pipeCmds = [];
+        while (true) {
+          const cmd = parseCommand(P);
+          if (!cmd)
+            break;
+          pipeCmds.push(cmd);
+          skipBlanks(P.L);
+          if (peek(P.L) === "|" && peek(P.L, 1) !== "|") {
+            const ps = P.L.b;
+            advance(P.L);
+            pipeCmds.push(mk(P, "|", ps, P.L.b, []));
+            skipBlanks(P.L);
+            continue;
+          }
+          break;
+        }
+        if (pipeCmds.length > 0) {
+          const pl = pipeCmds[pipeCmds.length - 1];
+          kids.push(mk(P, "pipeline", pipeCmds[0].startIndex, pl.endIndex, pipeCmds));
+        }
+        continue;
+      }
+      if (tc === "&" && peek(P.L, 1) === "&" || tc === "|" && peek(P.L, 1) === "|") {
+        advance(P.L);
+        advance(P.L);
+        skipBlanks(P.L);
+        const rhs = parseCommand(P);
+        if (rhs)
+          kids.push(rhs);
+        continue;
+      }
+      if (tc === "&" || tc === ";" || tc === "(" || tc === ")") {
+        const eStart = P.L.b;
+        while (P.L.i < P.L.len && peek(P.L) !== `
+`)
+          advance(P.L);
+        kids.push(mk(P, "ERROR", eStart, P.L.b, []));
+        break;
+      }
+      const w = parseWord(P, "arg");
+      if (w) {
+        kids.push(w);
+        continue;
+      }
+      const eStart = P.L.b;
+      while (P.L.i < P.L.len && peek(P.L) !== `
+`)
+        advance(P.L);
+      if (P.L.b > eStart)
+        kids.push(mk(P, "ERROR", eStart, P.L.b, []));
+      break;
+    }
+    return mk(P, "heredoc_redirect", startIdx, P.L.b, kids);
+  }
+  if (v === "<&-" || v === ">&-") {
+    const op = leaf(P, v, t);
+    const kids = [];
+    if (fd)
+      kids.push(fd);
+    kids.push(op);
+    skipBlanks(P.L);
+    const dSave = saveLex(P.L);
+    const dest = isRedirectLiteralStart(P) ? parseWord(P, "arg") : null;
+    if (dest) {
+      kids.push(dest);
+    } else {
+      restoreLex(P.L, dSave);
+    }
+    const startIdx = fd ? fd.startIndex : op.startIndex;
+    const end = dest ? dest.endIndex : op.endIndex;
+    return mk(P, "file_redirect", startIdx, end, kids);
+  }
+  if (v === ">" || v === ">>" || v === ">&" || v === ">|" || v === "&>" || v === "&>>" || v === "<" || v === "<&") {
+    const op = leaf(P, v, t);
+    const kids = [];
+    if (fd)
+      kids.push(fd);
+    kids.push(op);
+    let end = op.endIndex;
+    let taken = 0;
+    while (true) {
+      skipBlanks(P.L);
+      if (!isRedirectLiteralStart(P))
+        break;
+      if (!greedy && taken >= 1)
+        break;
+      const tc = peek(P.L);
+      const tc1 = peek(P.L, 1);
+      let target = null;
+      if ((tc === "<" || tc === ">") && tc1 === "(") {
+        target = parseProcessSub(P);
+      } else {
+        target = parseWord(P, "arg");
+      }
+      if (!target)
+        break;
+      kids.push(target);
+      end = target.endIndex;
+      taken++;
+    }
+    const startIdx = fd ? fd.startIndex : op.startIndex;
+    return mk(P, "file_redirect", startIdx, end, kids);
+  }
+  restoreLex(P.L, save);
+  return null;
+}
+function parseProcessSub(P) {
+  const c = peek(P.L);
+  if (c !== "<" && c !== ">" || peek(P.L, 1) !== "(")
+    return null;
+  const start = P.L.b;
+  advance(P.L);
+  advance(P.L);
+  const open = mk(P, c + "(", start, P.L.b, []);
+  const body = parseStatements(P, ")");
+  skipBlanks(P.L);
+  let close;
+  if (peek(P.L) === ")") {
+    const cs = P.L.b;
+    advance(P.L);
+    close = mk(P, ")", cs, P.L.b, []);
+  } else {
+    close = mk(P, ")", P.L.b, P.L.b, []);
+  }
+  return mk(P, "process_substitution", start, close.endIndex, [
+    open,
+    ...body,
+    close
+  ]);
+}
+function scanHeredocBodies(P) {
+  while (P.L.i < P.L.len && P.L.src[P.L.i] !== `
+`)
+    advance(P.L);
+  if (P.L.i < P.L.len)
+    advance(P.L);
+  for (const hd of P.L.heredocs) {
+    hd.bodyStart = P.L.b;
+    const delimLen = hd.delim.length;
+    while (P.L.i < P.L.len) {
+      const lineStart = P.L.i;
+      const lineStartB = P.L.b;
+      let checkI = lineStart;
+      if (hd.stripTabs) {
+        while (checkI < P.L.len && P.L.src[checkI] === "\t")
+          checkI++;
+      }
+      if (P.L.src.startsWith(hd.delim, checkI) && (checkI + delimLen >= P.L.len || P.L.src[checkI + delimLen] === `
+` || P.L.src[checkI + delimLen] === "\r")) {
+        hd.bodyEnd = lineStartB;
+        while (P.L.i < checkI)
+          advance(P.L);
+        hd.endStart = P.L.b;
+        for (let k = 0;k < delimLen; k++)
+          advance(P.L);
+        hd.endEnd = P.L.b;
+        if (P.L.i < P.L.len && P.L.src[P.L.i] === `
+`)
+          advance(P.L);
+        return;
+      }
+      while (P.L.i < P.L.len && P.L.src[P.L.i] !== `
+`)
+        advance(P.L);
+      if (P.L.i < P.L.len)
+        advance(P.L);
+    }
+    hd.bodyEnd = P.L.b;
+    hd.endStart = P.L.b;
+    hd.endEnd = P.L.b;
+  }
+}
+function parseHeredocBodyContent(P, start, end) {
+  const saved = saveLex(P.L);
+  restoreLexToByte(P, start);
+  const out = [];
+  let contentStart = P.L.b;
+  let sawExpansion = false;
+  while (P.L.b < end) {
+    const c = peek(P.L);
+    if (c === "\\") {
+      const nxt = peek(P.L, 1);
+      if (nxt === "$" || nxt === "`" || nxt === "\\") {
+        advance(P.L);
+        advance(P.L);
+        continue;
+      }
+      advance(P.L);
+      continue;
+    }
+    if (c === "$" || c === "`") {
+      const preB = P.L.b;
+      const exp = parseDollarLike(P);
+      if (exp && (exp.type === "simple_expansion" || exp.type === "expansion" || exp.type === "command_substitution" || exp.type === "arithmetic_expansion")) {
+        if (sawExpansion && preB > contentStart) {
+          out.push(mk(P, "heredoc_content", contentStart, preB, []));
+        }
+        out.push(exp);
+        contentStart = P.L.b;
+        sawExpansion = true;
+      }
+      continue;
+    }
+    advance(P.L);
+  }
+  if (sawExpansion) {
+    out.push(mk(P, "heredoc_content", contentStart, end, []));
+  }
+  restoreLex(P.L, saved);
+  return out;
+}
+function restoreLexToByte(P, targetByte) {
+  if (!P.L.byteTable)
+    byteAt(P.L, 0);
+  const t = P.L.byteTable;
+  let lo = 0;
+  let hi = P.src.length;
+  while (lo < hi) {
+    const m = lo + hi >>> 1;
+    if (t[m] < targetByte)
+      lo = m + 1;
+    else
+      hi = m;
+  }
+  P.L.i = lo;
+  P.L.b = targetByte;
+}
+function parseWord(P, _ctx) {
+  skipBlanks(P.L);
+  const parts = [];
+  while (P.L.i < P.L.len) {
+    const c = peek(P.L);
+    if (c === " " || c === "\t" || c === `
+` || c === "\r" || c === "" || c === "|" || c === "&" || c === ";" || c === "(" || c === ")") {
+      break;
+    }
+    if (c === "<" || c === ">") {
+      if (peek(P.L, 1) === "(") {
+        const ps = parseProcessSub(P);
+        if (ps)
+          parts.push(ps);
+        continue;
+      }
+      break;
+    }
+    if (c === '"') {
+      parts.push(parseDoubleQuoted(P));
+      continue;
+    }
+    if (c === "'") {
+      const tok = nextToken(P.L, "arg");
+      parts.push(leaf(P, "raw_string", tok));
+      continue;
+    }
+    if (c === "$") {
+      const c1 = peek(P.L, 1);
+      if (c1 === "'") {
+        const tok = nextToken(P.L, "arg");
+        parts.push(leaf(P, "ansi_c_string", tok));
+        continue;
+      }
+      if (c1 === '"') {
+        const dTok = {
+          type: "DOLLAR",
+          value: "$",
+          start: P.L.b,
+          end: P.L.b + 1
+        };
+        advance(P.L);
+        parts.push(leaf(P, "$", dTok));
+        parts.push(parseDoubleQuoted(P));
+        continue;
+      }
+      if (c1 === "`") {
+        advance(P.L);
+        continue;
+      }
+      const exp = parseDollarLike(P);
+      if (exp)
+        parts.push(exp);
+      continue;
+    }
+    if (c === "`") {
+      if (P.inBacktick > 0)
+        break;
+      const bt = parseBacktick(P);
+      if (bt)
+        parts.push(bt);
+      continue;
+    }
+    if (c === "{") {
+      const be = tryParseBraceExpr(P);
+      if (be) {
+        parts.push(be);
+        continue;
+      }
+      const nc = peek(P.L, 1);
+      if (nc === ";" || nc === "|" || nc === "&" || nc === `
+` || nc === "" || nc === ")" || nc === " " || nc === "\t") {
+        const bStart = P.L.b;
+        advance(P.L);
+        parts.push(mk(P, "word", bStart, P.L.b, []));
+        continue;
+      }
+      const cat = tryParseBraceLikeCat(P);
+      if (cat) {
+        for (const p of cat)
+          parts.push(p);
+        continue;
+      }
+    }
+    if (c === "}") {
+      const bStart = P.L.b;
+      advance(P.L);
+      parts.push(mk(P, "word", bStart, P.L.b, []));
+      continue;
+    }
+    if (c === "[" || c === "]") {
+      const bStart = P.L.b;
+      advance(P.L);
+      parts.push(mk(P, "word", bStart, P.L.b, []));
+      continue;
+    }
+    const frag = parseBareWord(P);
+    if (!frag)
+      break;
+    if (frag.type === "word" && /^-?(0x)?[0-9]+#$/.test(frag.text) && peek(P.L) === "$" && (peek(P.L, 1) === "{" || peek(P.L, 1) === "(")) {
+      const exp = parseDollarLike(P);
+      if (exp) {
+        parts.push(mk(P, "number", frag.startIndex, exp.endIndex, [exp]));
+        continue;
+      }
+    }
+    parts.push(frag);
+  }
+  if (parts.length === 0)
+    return null;
+  if (parts.length === 1)
+    return parts[0];
+  const first = parts[0];
+  const last = parts[parts.length - 1];
+  return mk(P, "concatenation", first.startIndex, last.endIndex, parts);
+}
+function parseBareWord(P) {
+  const start = P.L.b;
+  const startI = P.L.i;
+  while (P.L.i < P.L.len) {
+    const c = peek(P.L);
+    if (c === "\\") {
+      if (P.L.i + 1 >= P.L.len) {
+        break;
+      }
+      const nx = P.L.src[P.L.i + 1];
+      if (nx === `
+` || nx === "\r" && P.L.src[P.L.i + 2] === `
+`) {
+        break;
+      }
+      advance(P.L);
+      advance(P.L);
+      continue;
+    }
+    if (c === " " || c === "\t" || c === `
+` || c === "\r" || c === "" || c === "|" || c === "&" || c === ";" || c === "(" || c === ")" || c === "<" || c === ">" || c === '"' || c === "'" || c === "$" || c === "`" || c === "{" || c === "}" || c === "[" || c === "]") {
+      break;
+    }
+    advance(P.L);
+  }
+  if (P.L.b === start)
+    return null;
+  const text = P.src.slice(startI, P.L.i);
+  const type = /^-?\d+$/.test(text) ? "number" : "word";
+  return mk(P, type, start, P.L.b, []);
+}
+function tryParseBraceExpr(P) {
+  const save = saveLex(P.L);
+  if (peek(P.L) !== "{")
+    return null;
+  const oStart = P.L.b;
+  advance(P.L);
+  const oEnd = P.L.b;
+  const p1Start = P.L.b;
+  while (isDigit(peek(P.L)) || isIdentStart(peek(P.L)))
+    advance(P.L);
+  const p1End = P.L.b;
+  if (p1End === p1Start || peek(P.L) !== "." || peek(P.L, 1) !== ".") {
+    restoreLex(P.L, save);
+    return null;
+  }
+  const dotStart = P.L.b;
+  advance(P.L);
+  advance(P.L);
+  const dotEnd = P.L.b;
+  const p2Start = P.L.b;
+  while (isDigit(peek(P.L)) || isIdentStart(peek(P.L)))
+    advance(P.L);
+  const p2End = P.L.b;
+  if (p2End === p2Start || peek(P.L) !== "}") {
+    restoreLex(P.L, save);
+    return null;
+  }
+  const cStart = P.L.b;
+  advance(P.L);
+  const cEnd = P.L.b;
+  const p1Text = sliceBytes(P, p1Start, p1End);
+  const p2Text = sliceBytes(P, p2Start, p2End);
+  const p1IsNum = /^\d+$/.test(p1Text);
+  const p2IsNum = /^\d+$/.test(p2Text);
+  if (p1IsNum !== p2IsNum) {
+    restoreLex(P.L, save);
+    return null;
+  }
+  if (!p1IsNum && (p1Text.length !== 1 || p2Text.length !== 1)) {
+    restoreLex(P.L, save);
+    return null;
+  }
+  const p1Type = p1IsNum ? "number" : "word";
+  const p2Type = p2IsNum ? "number" : "word";
+  return mk(P, "brace_expression", oStart, cEnd, [
+    mk(P, "{", oStart, oEnd, []),
+    mk(P, p1Type, p1Start, p1End, []),
+    mk(P, "..", dotStart, dotEnd, []),
+    mk(P, p2Type, p2Start, p2End, []),
+    mk(P, "}", cStart, cEnd, [])
+  ]);
+}
+function tryParseBraceLikeCat(P) {
+  if (peek(P.L) !== "{")
+    return null;
+  const oStart = P.L.b;
+  advance(P.L);
+  const oEnd = P.L.b;
+  const inner = [mk(P, "word", oStart, oEnd, [])];
+  while (P.L.i < P.L.len) {
+    const bc = peek(P.L);
+    if (bc === "}" || bc === `
+` || bc === ";" || bc === "|" || bc === "&" || bc === " " || bc === "\t" || bc === "<" || bc === ">" || bc === "(" || bc === ")") {
+      break;
+    }
+    if (bc === "[" || bc === "]") {
+      const bStart = P.L.b;
+      advance(P.L);
+      inner.push(mk(P, "word", bStart, P.L.b, []));
+      continue;
+    }
+    const midStart = P.L.b;
+    while (P.L.i < P.L.len) {
+      const mc = peek(P.L);
+      if (mc === "}" || mc === `
+` || mc === ";" || mc === "|" || mc === "&" || mc === " " || mc === "\t" || mc === "<" || mc === ">" || mc === "(" || mc === ")" || mc === "[" || mc === "]") {
+        break;
+      }
+      advance(P.L);
+    }
+    const midEnd = P.L.b;
+    if (midEnd > midStart) {
+      const midText = sliceBytes(P, midStart, midEnd);
+      const midType = /^-?\d+$/.test(midText) ? "number" : "word";
+      inner.push(mk(P, midType, midStart, midEnd, []));
+    } else {
+      break;
+    }
+  }
+  if (peek(P.L) === "}") {
+    const cStart = P.L.b;
+    advance(P.L);
+    inner.push(mk(P, "word", cStart, P.L.b, []));
+  }
+  return inner;
+}
+function parseDoubleQuoted(P) {
+  const qStart = P.L.b;
+  advance(P.L);
+  const qEnd = P.L.b;
+  const openQ = mk(P, '"', qStart, qEnd, []);
+  const parts = [openQ];
+  let contentStart = P.L.b;
+  let contentStartI = P.L.i;
+  const flushContent = () => {
+    if (P.L.b > contentStart) {
+      const txt = P.src.slice(contentStartI, P.L.i);
+      if (!/^[ \t]+$/.test(txt)) {
+        parts.push(mk(P, "string_content", contentStart, P.L.b, []));
+      }
+    }
+  };
+  while (P.L.i < P.L.len) {
+    const c = peek(P.L);
+    if (c === '"')
+      break;
+    if (c === "\\" && P.L.i + 1 < P.L.len) {
+      advance(P.L);
+      advance(P.L);
+      continue;
+    }
+    if (c === `
+`) {
+      flushContent();
+      advance(P.L);
+      contentStart = P.L.b;
+      contentStartI = P.L.i;
+      continue;
+    }
+    if (c === "$") {
+      const c1 = peek(P.L, 1);
+      if (c1 === "(" || c1 === "{" || isIdentStart(c1) || SPECIAL_VARS.has(c1) || isDigit(c1)) {
+        flushContent();
+        const exp = parseDollarLike(P);
+        if (exp)
+          parts.push(exp);
+        contentStart = P.L.b;
+        contentStartI = P.L.i;
+        continue;
+      }
+      if (c1 !== '"' && c1 !== "") {
+        flushContent();
+        const dS = P.L.b;
+        advance(P.L);
+        parts.push(mk(P, "$", dS, P.L.b, []));
+        contentStart = P.L.b;
+        contentStartI = P.L.i;
+        continue;
+      }
+    }
+    if (c === "`") {
+      flushContent();
+      const bt = parseBacktick(P);
+      if (bt)
+        parts.push(bt);
+      contentStart = P.L.b;
+      contentStartI = P.L.i;
+      continue;
+    }
+    advance(P.L);
+  }
+  flushContent();
+  let close;
+  if (peek(P.L) === '"') {
+    const cStart = P.L.b;
+    advance(P.L);
+    close = mk(P, '"', cStart, P.L.b, []);
+  } else {
+    close = mk(P, '"', P.L.b, P.L.b, []);
+  }
+  parts.push(close);
+  return mk(P, "string", qStart, close.endIndex, parts);
+}
+function parseDollarLike(P) {
+  const c1 = peek(P.L, 1);
+  const dStart = P.L.b;
+  if (c1 === "(" && peek(P.L, 2) === "(") {
+    advance(P.L);
+    advance(P.L);
+    advance(P.L);
+    const open = mk(P, "$((", dStart, P.L.b, []);
+    const exprs = parseArithCommaList(P, "))", "var");
+    skipBlanks(P.L);
+    let close;
+    if (peek(P.L) === ")" && peek(P.L, 1) === ")") {
+      const cStart = P.L.b;
+      advance(P.L);
+      advance(P.L);
+      close = mk(P, "))", cStart, P.L.b, []);
+    } else {
+      close = mk(P, "))", P.L.b, P.L.b, []);
+    }
+    return mk(P, "arithmetic_expansion", dStart, close.endIndex, [
+      open,
+      ...exprs,
+      close
+    ]);
+  }
+  if (c1 === "[") {
+    advance(P.L);
+    advance(P.L);
+    const open = mk(P, "$[", dStart, P.L.b, []);
+    const exprs = parseArithCommaList(P, "]", "var");
+    skipBlanks(P.L);
+    let close;
+    if (peek(P.L) === "]") {
+      const cStart = P.L.b;
+      advance(P.L);
+      close = mk(P, "]", cStart, P.L.b, []);
+    } else {
+      close = mk(P, "]", P.L.b, P.L.b, []);
+    }
+    return mk(P, "arithmetic_expansion", dStart, close.endIndex, [
+      open,
+      ...exprs,
+      close
+    ]);
+  }
+  if (c1 === "(") {
+    advance(P.L);
+    advance(P.L);
+    const open = mk(P, "$(", dStart, P.L.b, []);
+    let body = parseStatements(P, ")");
+    skipBlanks(P.L);
+    let close;
+    if (peek(P.L) === ")") {
+      const cStart = P.L.b;
+      advance(P.L);
+      close = mk(P, ")", cStart, P.L.b, []);
+    } else {
+      close = mk(P, ")", P.L.b, P.L.b, []);
+    }
+    if (body.length === 1 && body[0].type === "redirected_statement" && body[0].children.length === 1 && body[0].children[0].type === "file_redirect") {
+      body = body[0].children;
+    }
+    return mk(P, "command_substitution", dStart, close.endIndex, [
+      open,
+      ...body,
+      close
+    ]);
+  }
+  if (c1 === "{") {
+    advance(P.L);
+    advance(P.L);
+    const open = mk(P, "${", dStart, P.L.b, []);
+    const inner = parseExpansionBody(P);
+    let close;
+    if (peek(P.L) === "}") {
+      const cStart = P.L.b;
+      advance(P.L);
+      close = mk(P, "}", cStart, P.L.b, []);
+    } else {
+      close = mk(P, "}", P.L.b, P.L.b, []);
+    }
+    return mk(P, "expansion", dStart, close.endIndex, [open, ...inner, close]);
+  }
+  advance(P.L);
+  const dEnd = P.L.b;
+  const dollar = mk(P, "$", dStart, dEnd, []);
+  const nc = peek(P.L);
+  if (nc === "_" && !isIdentChar(peek(P.L, 1))) {
+    const vStart = P.L.b;
+    advance(P.L);
+    const vn = mk(P, "special_variable_name", vStart, P.L.b, []);
+    return mk(P, "simple_expansion", dStart, P.L.b, [dollar, vn]);
+  }
+  if (isIdentStart(nc)) {
+    const vStart = P.L.b;
+    while (isIdentChar(peek(P.L)))
+      advance(P.L);
+    const vn = mk(P, "variable_name", vStart, P.L.b, []);
+    return mk(P, "simple_expansion", dStart, P.L.b, [dollar, vn]);
+  }
+  if (isDigit(nc)) {
+    const vStart = P.L.b;
+    advance(P.L);
+    const vn = mk(P, "variable_name", vStart, P.L.b, []);
+    return mk(P, "simple_expansion", dStart, P.L.b, [dollar, vn]);
+  }
+  if (SPECIAL_VARS.has(nc)) {
+    const vStart = P.L.b;
+    advance(P.L);
+    const vn = mk(P, "special_variable_name", vStart, P.L.b, []);
+    return mk(P, "simple_expansion", dStart, P.L.b, [dollar, vn]);
+  }
+  return dollar;
+}
+function parseExpansionBody(P) {
+  const out = [];
+  skipBlanks(P.L);
+  {
+    const c0 = peek(P.L);
+    const c1 = peek(P.L, 1);
+    if (c0 === "#" && c1 === "!" && peek(P.L, 2) === "}") {
+      advance(P.L);
+      advance(P.L);
+      return out;
+    }
+    if (c0 === "!" && c1 === "#") {
+      let j = 2;
+      if (peek(P.L, j) === "#")
+        j++;
+      if (peek(P.L, j) === " ")
+        j++;
+      if (peek(P.L, j) === "}") {
+        while (j-- > 0)
+          advance(P.L);
+        return out;
+      }
+    }
+  }
+  if (peek(P.L) === "#") {
+    const s = P.L.b;
+    advance(P.L);
+    out.push(mk(P, "#", s, P.L.b, []));
+  }
+  const pc = peek(P.L);
+  if ((pc === "!" || pc === "=" || pc === "~") && (isIdentStart(peek(P.L, 1)) || isDigit(peek(P.L, 1)))) {
+    const s = P.L.b;
+    advance(P.L);
+    out.push(mk(P, pc, s, P.L.b, []));
+  }
+  skipBlanks(P.L);
+  if (isIdentStart(peek(P.L))) {
+    const s = P.L.b;
+    while (isIdentChar(peek(P.L)))
+      advance(P.L);
+    out.push(mk(P, "variable_name", s, P.L.b, []));
+  } else if (isDigit(peek(P.L))) {
+    const s = P.L.b;
+    while (isDigit(peek(P.L)))
+      advance(P.L);
+    out.push(mk(P, "variable_name", s, P.L.b, []));
+  } else if (SPECIAL_VARS.has(peek(P.L))) {
+    const s = P.L.b;
+    advance(P.L);
+    out.push(mk(P, "special_variable_name", s, P.L.b, []));
+  }
+  if (peek(P.L) === "[") {
+    const varNode = out[out.length - 1];
+    const brOpen = P.L.b;
+    advance(P.L);
+    const brOpenNode = mk(P, "[", brOpen, P.L.b, []);
+    const idx = parseSubscriptIndexInline(P);
+    skipBlanks(P.L);
+    const brClose = P.L.b;
+    if (peek(P.L) === "]")
+      advance(P.L);
+    const brCloseNode = mk(P, "]", brClose, P.L.b, []);
+    if (varNode) {
+      const kids = idx ? [varNode, brOpenNode, idx, brCloseNode] : [varNode, brOpenNode, brCloseNode];
+      out[out.length - 1] = mk(P, "subscript", varNode.startIndex, P.L.b, kids);
+    }
+  }
+  skipBlanks(P.L);
+  const tc = peek(P.L);
+  if ((tc === "*" || tc === "@") && peek(P.L, 1) === "}") {
+    const s = P.L.b;
+    advance(P.L);
+    out.push(mk(P, tc, s, P.L.b, []));
+    return out;
+  }
+  if (tc === "@" && isIdentStart(peek(P.L, 1))) {
+    const s = P.L.b;
+    advance(P.L);
+    out.push(mk(P, "@", s, P.L.b, []));
+    while (isIdentChar(peek(P.L)))
+      advance(P.L);
+    return out;
+  }
+  const c = peek(P.L);
+  if (c === ":") {
+    const c1 = peek(P.L, 1);
+    if (c1 === `
+` || c1 === "}") {
+      advance(P.L);
+      while (peek(P.L) === `
+`)
+        advance(P.L);
+      return out;
+    }
+    if (c1 !== "-" && c1 !== "=" && c1 !== "?" && c1 !== "+") {
+      advance(P.L);
+      skipBlanks(P.L);
+      const offC = peek(P.L);
+      let off;
+      if (offC === "-" && isDigit(peek(P.L, 1))) {
+        const ns = P.L.b;
+        advance(P.L);
+        while (isDigit(peek(P.L)))
+          advance(P.L);
+        off = mk(P, "number", ns, P.L.b, []);
+      } else {
+        off = parseArithExpr(P, ":}", "var");
+      }
+      if (off)
+        out.push(off);
+      skipBlanks(P.L);
+      if (peek(P.L) === ":") {
+        advance(P.L);
+        skipBlanks(P.L);
+        const lenC = peek(P.L);
+        let len;
+        if (lenC === "-" && isDigit(peek(P.L, 1))) {
+          const ns = P.L.b;
+          advance(P.L);
+          while (isDigit(peek(P.L)))
+            advance(P.L);
+          len = mk(P, "number", ns, P.L.b, []);
+        } else {
+          len = parseArithExpr(P, "}", "var");
+        }
+        if (len)
+          out.push(len);
+      }
+      return out;
+    }
+  }
+  if (c === ":" || c === "#" || c === "%" || c === "/" || c === "^" || c === "," || c === "-" || c === "=" || c === "?" || c === "+") {
+    const s = P.L.b;
+    const c1 = peek(P.L, 1);
+    let op = c;
+    if (c === ":" && (c1 === "-" || c1 === "=" || c1 === "?" || c1 === "+")) {
+      advance(P.L);
+      advance(P.L);
+      op = c + c1;
+    } else if ((c === "#" || c === "%" || c === "/" || c === "^" || c === ",") && c1 === c) {
+      advance(P.L);
+      advance(P.L);
+      op = c + c;
+    } else {
+      advance(P.L);
+    }
+    out.push(mk(P, op, s, P.L.b, []));
+    const isPattern = op === "#" || op === "##" || op === "%" || op === "%%" || op === "/" || op === "//" || op === "^" || op === "^^" || op === "," || op === ",,";
+    if (op === "/" || op === "//") {
+      const ac = peek(P.L);
+      if (ac === "#" || ac === "%") {
+        const aStart = P.L.b;
+        advance(P.L);
+        out.push(mk(P, ac, aStart, P.L.b, []));
+      }
+      if (peek(P.L) === '"') {
+        out.push(parseDoubleQuoted(P));
+        const tail = parseExpansionRest(P, "regex", true);
+        if (tail)
+          out.push(tail);
+      } else {
+        const regex = parseExpansionRest(P, "regex", true);
+        if (regex)
+          out.push(regex);
+      }
+      if (peek(P.L) === "/") {
+        const sepStart = P.L.b;
+        advance(P.L);
+        out.push(mk(P, "/", sepStart, P.L.b, []));
+        const repl = parseExpansionRest(P, "replword", false);
+        if (repl) {
+          if (repl.type === "concatenation" && repl.children.length === 2 && repl.children[0].type === "command_substitution") {
+            out.push(repl.children[0]);
+            out.push(repl.children[1]);
+          } else {
+            out.push(repl);
+          }
+        }
+      }
+    } else if (op === "#" || op === "##" || op === "%" || op === "%%") {
+      for (const p of parseExpansionRegexSegmented(P))
+        out.push(p);
+    } else {
+      const rest = parseExpansionRest(P, isPattern ? "regex" : "word", false);
+      if (rest)
+        out.push(rest);
+    }
+  }
+  return out;
+}
+function parseExpansionRest(P, nodeType, stopAtSlash) {
+  const start = P.L.b;
+  if (nodeType === "word" && peek(P.L) === "(") {
+    advance(P.L);
+    const open = mk(P, "(", start, P.L.b, []);
+    const elems = [open];
+    while (P.L.i < P.L.len) {
+      skipBlanks(P.L);
+      const c = peek(P.L);
+      if (c === ")" || c === "}" || c === `
+` || c === "")
+        break;
+      const wStart = P.L.b;
+      while (P.L.i < P.L.len) {
+        const wc = peek(P.L);
+        if (wc === ")" || wc === "}" || wc === " " || wc === "\t" || wc === `
+` || wc === "") {
+          break;
+        }
+        advance(P.L);
+      }
+      if (P.L.b > wStart)
+        elems.push(mk(P, "word", wStart, P.L.b, []));
+      else
+        break;
+    }
+    if (peek(P.L) === ")") {
+      const cStart = P.L.b;
+      advance(P.L);
+      elems.push(mk(P, ")", cStart, P.L.b, []));
+    }
+    while (peek(P.L) === `
+`)
+      advance(P.L);
+    return mk(P, "array", start, P.L.b, elems);
+  }
+  if (nodeType === "regex") {
+    let braceDepth = 0;
+    while (P.L.i < P.L.len) {
+      const c = peek(P.L);
+      if (c === `
+`)
+        break;
+      if (braceDepth === 0) {
+        if (c === "}")
+          break;
+        if (stopAtSlash && c === "/")
+          break;
+      }
+      if (c === "\\" && P.L.i + 1 < P.L.len) {
+        advance(P.L);
+        advance(P.L);
+        continue;
+      }
+      if (c === '"' || c === "'") {
+        advance(P.L);
+        while (P.L.i < P.L.len && peek(P.L) !== c) {
+          if (peek(P.L) === "\\" && P.L.i + 1 < P.L.len)
+            advance(P.L);
+          advance(P.L);
+        }
+        if (peek(P.L) === c)
+          advance(P.L);
+        continue;
+      }
+      if (c === "$") {
+        const c1 = peek(P.L, 1);
+        if (c1 === "{") {
+          let d = 0;
+          advance(P.L);
+          advance(P.L);
+          d++;
+          while (P.L.i < P.L.len && d > 0) {
+            const nc = peek(P.L);
+            if (nc === "{")
+              d++;
+            else if (nc === "}")
+              d--;
+            advance(P.L);
+          }
+          continue;
+        }
+        if (c1 === "(") {
+          let d = 0;
+          advance(P.L);
+          advance(P.L);
+          d++;
+          while (P.L.i < P.L.len && d > 0) {
+            const nc = peek(P.L);
+            if (nc === "(")
+              d++;
+            else if (nc === ")")
+              d--;
+            advance(P.L);
+          }
+          continue;
+        }
+      }
+      if (c === "{")
+        braceDepth++;
+      else if (c === "}" && braceDepth > 0)
+        braceDepth--;
+      advance(P.L);
+    }
+    const end = P.L.b;
+    while (peek(P.L) === `
+`)
+      advance(P.L);
+    if (end === start)
+      return null;
+    return mk(P, "regex", start, end, []);
+  }
+  const parts = [];
+  let segStart = P.L.b;
+  let braceDepth = 0;
+  const flushSeg = () => {
+    if (P.L.b > segStart) {
+      parts.push(mk(P, "word", segStart, P.L.b, []));
+    }
+  };
+  while (P.L.i < P.L.len) {
+    const c = peek(P.L);
+    if (c === `
+`)
+      break;
+    if (braceDepth === 0) {
+      if (c === "}")
+        break;
+      if (stopAtSlash && c === "/")
+        break;
+    }
+    if (c === "\\" && P.L.i + 1 < P.L.len) {
+      advance(P.L);
+      advance(P.L);
+      continue;
+    }
+    const c1 = peek(P.L, 1);
+    if (c === "$") {
+      if (c1 === "{" || c1 === "(" || c1 === "[") {
+        flushSeg();
+        const exp = parseDollarLike(P);
+        if (exp)
+          parts.push(exp);
+        segStart = P.L.b;
+        continue;
+      }
+      if (c1 === "'") {
+        flushSeg();
+        const aStart = P.L.b;
+        advance(P.L);
+        advance(P.L);
+        while (P.L.i < P.L.len && peek(P.L) !== "'") {
+          if (peek(P.L) === "\\" && P.L.i + 1 < P.L.len)
+            advance(P.L);
+          advance(P.L);
+        }
+        if (peek(P.L) === "'")
+          advance(P.L);
+        parts.push(mk(P, "ansi_c_string", aStart, P.L.b, []));
+        segStart = P.L.b;
+        continue;
+      }
+      if (isIdentStart(c1) || isDigit(c1) || SPECIAL_VARS.has(c1)) {
+        flushSeg();
+        const exp = parseDollarLike(P);
+        if (exp)
+          parts.push(exp);
+        segStart = P.L.b;
+        continue;
+      }
+    }
+    if (c === '"') {
+      flushSeg();
+      parts.push(parseDoubleQuoted(P));
+      segStart = P.L.b;
+      continue;
+    }
+    if (c === "'") {
+      flushSeg();
+      const rStart = P.L.b;
+      advance(P.L);
+      while (P.L.i < P.L.len && peek(P.L) !== "'")
+        advance(P.L);
+      if (peek(P.L) === "'")
+        advance(P.L);
+      parts.push(mk(P, "raw_string", rStart, P.L.b, []));
+      segStart = P.L.b;
+      continue;
+    }
+    if ((c === "<" || c === ">") && c1 === "(") {
+      flushSeg();
+      const ps = parseProcessSub(P);
+      if (ps)
+        parts.push(ps);
+      segStart = P.L.b;
+      continue;
+    }
+    if (c === "`") {
+      flushSeg();
+      const bt = parseBacktick(P);
+      if (bt)
+        parts.push(bt);
+      segStart = P.L.b;
+      continue;
+    }
+    if (c === "{")
+      braceDepth++;
+    else if (c === "}" && braceDepth > 0)
+      braceDepth--;
+    advance(P.L);
+  }
+  flushSeg();
+  while (peek(P.L) === `
+`)
+    advance(P.L);
+  if (parts.length > 1 && parts[0].type === "word" && /^[ \t]+$/.test(parts[0].text)) {
+    parts.shift();
+  }
+  if (parts.length === 0)
+    return null;
+  if (parts.length === 1)
+    return parts[0];
+  const last = parts[parts.length - 1];
+  return mk(P, "concatenation", parts[0].startIndex, last.endIndex, parts);
+}
+function parseExpansionRegexSegmented(P) {
+  const out = [];
+  let segStart = P.L.b;
+  const flushRegex = () => {
+    if (P.L.b > segStart)
+      out.push(mk(P, "regex", segStart, P.L.b, []));
+  };
+  while (P.L.i < P.L.len) {
+    const c = peek(P.L);
+    if (c === "}" || c === `
+`)
+      break;
+    if (c === "\\" && P.L.i + 1 < P.L.len) {
+      advance(P.L);
+      advance(P.L);
+      continue;
+    }
+    if (c === '"') {
+      flushRegex();
+      out.push(parseDoubleQuoted(P));
+      segStart = P.L.b;
+      continue;
+    }
+    if (c === "'") {
+      flushRegex();
+      const rStart = P.L.b;
+      advance(P.L);
+      while (P.L.i < P.L.len && peek(P.L) !== "'")
+        advance(P.L);
+      if (peek(P.L) === "'")
+        advance(P.L);
+      out.push(mk(P, "raw_string", rStart, P.L.b, []));
+      segStart = P.L.b;
+      continue;
+    }
+    if (c === "$") {
+      const c1 = peek(P.L, 1);
+      if (c1 === "{") {
+        let d = 1;
+        advance(P.L);
+        advance(P.L);
+        while (P.L.i < P.L.len && d > 0) {
+          const nc = peek(P.L);
+          if (nc === "{")
+            d++;
+          else if (nc === "}")
+            d--;
+          advance(P.L);
+        }
+        continue;
+      }
+      if (c1 === "(") {
+        let d = 1;
+        advance(P.L);
+        advance(P.L);
+        while (P.L.i < P.L.len && d > 0) {
+          const nc = peek(P.L);
+          if (nc === "(")
+            d++;
+          else if (nc === ")")
+            d--;
+          advance(P.L);
+        }
+        continue;
+      }
+    }
+    advance(P.L);
+  }
+  flushRegex();
+  while (peek(P.L) === `
+`)
+    advance(P.L);
+  return out;
+}
+function parseBacktick(P) {
+  const start = P.L.b;
+  advance(P.L);
+  const open = mk(P, "`", start, P.L.b, []);
+  P.inBacktick++;
+  const body = [];
+  while (true) {
+    skipBlanks(P.L);
+    if (peek(P.L) === "`" || peek(P.L) === "")
+      break;
+    const save = saveLex(P.L);
+    const t = nextToken(P.L, "cmd");
+    if (t.type === "EOF" || t.type === "BACKTICK") {
+      restoreLex(P.L, save);
+      break;
+    }
+    if (t.type === "NEWLINE")
+      continue;
+    restoreLex(P.L, save);
+    const stmt = parseAndOr(P);
+    if (!stmt)
+      break;
+    body.push(stmt);
+    skipBlanks(P.L);
+    if (peek(P.L) === "`")
+      break;
+    const save2 = saveLex(P.L);
+    const sep = nextToken(P.L, "cmd");
+    if (sep.type === "OP" && (sep.value === ";" || sep.value === "&")) {
+      body.push(leaf(P, sep.value, sep));
+    } else if (sep.type !== "NEWLINE") {
+      restoreLex(P.L, save2);
+    }
+  }
+  P.inBacktick--;
+  let close;
+  if (peek(P.L) === "`") {
+    const cStart = P.L.b;
+    advance(P.L);
+    close = mk(P, "`", cStart, P.L.b, []);
+  } else {
+    close = mk(P, "`", P.L.b, P.L.b, []);
+  }
+  if (body.length === 0)
+    return null;
+  return mk(P, "command_substitution", start, close.endIndex, [
+    open,
+    ...body,
+    close
+  ]);
+}
+function parseIf(P, ifTok) {
+  const ifKw = leaf(P, "if", ifTok);
+  const kids = [ifKw];
+  const cond = parseStatements(P, null);
+  kids.push(...cond);
+  consumeKeyword(P, "then", kids);
+  const body = parseStatements(P, null);
+  kids.push(...body);
+  while (true) {
+    const save = saveLex(P.L);
+    const t = nextToken(P.L, "cmd");
+    if (t.type === "WORD" && t.value === "elif") {
+      const eKw = leaf(P, "elif", t);
+      const eCond = parseStatements(P, null);
+      const eKids = [eKw, ...eCond];
+      consumeKeyword(P, "then", eKids);
+      const eBody = parseStatements(P, null);
+      eKids.push(...eBody);
+      const last = eKids[eKids.length - 1];
+      kids.push(mk(P, "elif_clause", eKw.startIndex, last.endIndex, eKids));
+    } else if (t.type === "WORD" && t.value === "else") {
+      const elKw = leaf(P, "else", t);
+      const elBody = parseStatements(P, null);
+      const last = elBody.length > 0 ? elBody[elBody.length - 1] : elKw;
+      kids.push(mk(P, "else_clause", elKw.startIndex, last.endIndex, [elKw, ...elBody]));
+    } else {
+      restoreLex(P.L, save);
+      break;
+    }
+  }
+  consumeKeyword(P, "fi", kids);
+  const last = kids[kids.length - 1];
+  return mk(P, "if_statement", ifKw.startIndex, last.endIndex, kids);
+}
+function parseWhile(P, kwTok) {
+  const kw = leaf(P, kwTok.value, kwTok);
+  const kids = [kw];
+  const cond = parseStatements(P, null);
+  kids.push(...cond);
+  const dg = parseDoGroup(P);
+  if (dg)
+    kids.push(dg);
+  const last = kids[kids.length - 1];
+  return mk(P, "while_statement", kw.startIndex, last.endIndex, kids);
+}
+function parseFor(P, forTok) {
+  const forKw = leaf(P, forTok.value, forTok);
+  skipBlanks(P.L);
+  if (forTok.value === "for" && peek(P.L) === "(" && peek(P.L, 1) === "(") {
+    const oStart = P.L.b;
+    advance(P.L);
+    advance(P.L);
+    const open = mk(P, "((", oStart, P.L.b, []);
+    const kids = [forKw, open];
+    for (let k = 0;k < 3; k++) {
+      skipBlanks(P.L);
+      const es = parseArithCommaList(P, k < 2 ? ";" : "))", "assign");
+      kids.push(...es);
+      if (k < 2) {
+        if (peek(P.L) === ";") {
+          const s = P.L.b;
+          advance(P.L);
+          kids.push(mk(P, ";", s, P.L.b, []));
+        }
+      }
+    }
+    skipBlanks(P.L);
+    if (peek(P.L) === ")" && peek(P.L, 1) === ")") {
+      const cStart = P.L.b;
+      advance(P.L);
+      advance(P.L);
+      kids.push(mk(P, "))", cStart, P.L.b, []));
+    }
+    const save = saveLex(P.L);
+    const sep = nextToken(P.L, "cmd");
+    if (sep.type === "OP" && sep.value === ";") {
+      kids.push(leaf(P, ";", sep));
+    } else if (sep.type !== "NEWLINE") {
+      restoreLex(P.L, save);
+    }
+    const dg = parseDoGroup(P);
+    if (dg) {
+      kids.push(dg);
+    } else {
+      skipNewlines(P);
+      skipBlanks(P.L);
+      if (peek(P.L) === "{") {
+        const bOpen = P.L.b;
+        advance(P.L);
+        const brace = mk(P, "{", bOpen, P.L.b, []);
+        const body = parseStatements(P, "}");
+        let bClose;
+        if (peek(P.L) === "}") {
+          const cs = P.L.b;
+          advance(P.L);
+          bClose = mk(P, "}", cs, P.L.b, []);
+        } else {
+          bClose = mk(P, "}", P.L.b, P.L.b, []);
+        }
+        kids.push(mk(P, "compound_statement", brace.startIndex, bClose.endIndex, [
+          brace,
+          ...body,
+          bClose
+        ]));
+      }
+    }
+    const last = kids[kids.length - 1];
+    return mk(P, "c_style_for_statement", forKw.startIndex, last.endIndex, kids);
+  }
+  const kids = [forKw];
+  const varTok = nextToken(P.L, "arg");
+  kids.push(mk(P, "variable_name", varTok.start, varTok.end, []));
+  skipBlanks(P.L);
+  const save = saveLex(P.L);
+  const inTok = nextToken(P.L, "arg");
+  if (inTok.type === "WORD" && inTok.value === "in") {
+    kids.push(leaf(P, "in", inTok));
+    while (true) {
+      skipBlanks(P.L);
+      const c = peek(P.L);
+      if (c === ";" || c === `
+` || c === "")
+        break;
+      const w = parseWord(P, "arg");
+      if (!w)
+        break;
+      kids.push(w);
+    }
+  } else {
+    restoreLex(P.L, save);
+  }
+  const save2 = saveLex(P.L);
+  const sep = nextToken(P.L, "cmd");
+  if (sep.type === "OP" && sep.value === ";") {
+    kids.push(leaf(P, ";", sep));
+  } else if (sep.type !== "NEWLINE") {
+    restoreLex(P.L, save2);
+  }
+  const dg = parseDoGroup(P);
+  if (dg)
+    kids.push(dg);
+  const last = kids[kids.length - 1];
+  return mk(P, "for_statement", forKw.startIndex, last.endIndex, kids);
+}
+function parseDoGroup(P) {
+  skipNewlines(P);
+  const save = saveLex(P.L);
+  const doTok = nextToken(P.L, "cmd");
+  if (doTok.type !== "WORD" || doTok.value !== "do") {
+    restoreLex(P.L, save);
+    return null;
+  }
+  const doKw = leaf(P, "do", doTok);
+  const body = parseStatements(P, null);
+  const kids = [doKw, ...body];
+  consumeKeyword(P, "done", kids);
+  const last = kids[kids.length - 1];
+  return mk(P, "do_group", doKw.startIndex, last.endIndex, kids);
+}
+function parseCase(P, caseTok) {
+  const caseKw = leaf(P, "case", caseTok);
+  const kids = [caseKw];
+  skipBlanks(P.L);
+  const word = parseWord(P, "arg");
+  if (word)
+    kids.push(word);
+  skipBlanks(P.L);
+  consumeKeyword(P, "in", kids);
+  skipNewlines(P);
+  while (true) {
+    skipBlanks(P.L);
+    skipNewlines(P);
+    const save = saveLex(P.L);
+    const t = nextToken(P.L, "arg");
+    if (t.type === "WORD" && t.value === "esac") {
+      kids.push(leaf(P, "esac", t));
+      break;
+    }
+    if (t.type === "EOF")
+      break;
+    restoreLex(P.L, save);
+    const item = parseCaseItem(P);
+    if (!item)
+      break;
+    kids.push(item);
+  }
+  const last = kids[kids.length - 1];
+  return mk(P, "case_statement", caseKw.startIndex, last.endIndex, kids);
+}
+function parseCaseItem(P) {
+  skipBlanks(P.L);
+  const start = P.L.b;
+  const kids = [];
+  if (peek(P.L) === "(") {
+    const s = P.L.b;
+    advance(P.L);
+    kids.push(mk(P, "(", s, P.L.b, []));
+  }
+  let isFirstAlt = true;
+  while (true) {
+    skipBlanks(P.L);
+    const c = peek(P.L);
+    if (c === ")" || c === "")
+      break;
+    const pats = parseCasePattern(P);
+    if (pats.length === 0)
+      break;
+    if (!isFirstAlt && pats.length > 1) {
+      const rewritten = pats.map((p) => p.type === "extglob_pattern" ? mk(P, "word", p.startIndex, p.endIndex, []) : p);
+      const first = rewritten[0];
+      const last = rewritten[rewritten.length - 1];
+      kids.push(mk(P, "concatenation", first.startIndex, last.endIndex, rewritten));
+    } else {
+      kids.push(...pats);
+    }
+    isFirstAlt = false;
+    skipBlanks(P.L);
+    if (peek(P.L) === "\\" && peek(P.L, 1) === `
+`) {
+      advance(P.L);
+      advance(P.L);
+      skipBlanks(P.L);
+    }
+    if (peek(P.L) === "|") {
+      const s = P.L.b;
+      advance(P.L);
+      kids.push(mk(P, "|", s, P.L.b, []));
+      if (peek(P.L) === "\\" && peek(P.L, 1) === `
+`) {
+        advance(P.L);
+        advance(P.L);
+      }
+    } else {
+      break;
+    }
+  }
+  if (peek(P.L) === ")") {
+    const s = P.L.b;
+    advance(P.L);
+    kids.push(mk(P, ")", s, P.L.b, []));
+  }
+  const body = parseStatements(P, null);
+  kids.push(...body);
+  const save = saveLex(P.L);
+  const term = nextToken(P.L, "cmd");
+  if (term.type === "OP" && (term.value === ";;" || term.value === ";&" || term.value === ";;&")) {
+    kids.push(leaf(P, term.value, term));
+  } else {
+    restoreLex(P.L, save);
+  }
+  if (kids.length === 0)
+    return null;
+  if (body.length === 0) {
+    for (let i = 0;i < kids.length; i++) {
+      const k = kids[i];
+      if (k.type !== "extglob_pattern")
+        continue;
+      const text = sliceBytes(P, k.startIndex, k.endIndex);
+      if (/^[-+?*@!][a-zA-Z]/.test(text) && !/[*?(]/.test(text)) {
+        kids[i] = mk(P, "word", k.startIndex, k.endIndex, []);
+      }
+    }
+  }
+  const last = kids[kids.length - 1];
+  return mk(P, "case_item", start, last.endIndex, kids);
+}
+function parseCasePattern(P) {
+  skipBlanks(P.L);
+  const save = saveLex(P.L);
+  const start = P.L.b;
+  const startI = P.L.i;
+  let parenDepth = 0;
+  let hasDollar = false;
+  let hasBracketOutsideParen = false;
+  let hasQuote = false;
+  while (P.L.i < P.L.len) {
+    const c = peek(P.L);
+    if (c === "\\" && P.L.i + 1 < P.L.len) {
+      advance(P.L);
+      advance(P.L);
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      hasQuote = true;
+      advance(P.L);
+      while (P.L.i < P.L.len && peek(P.L) !== c) {
+        if (peek(P.L) === "\\" && P.L.i + 1 < P.L.len)
+          advance(P.L);
+        advance(P.L);
+      }
+      if (peek(P.L) === c)
+        advance(P.L);
+      continue;
+    }
+    if (c === "(") {
+      parenDepth++;
+      advance(P.L);
+      continue;
+    }
+    if (parenDepth > 0) {
+      if (c === ")") {
+        parenDepth--;
+        advance(P.L);
+        continue;
+      }
+      if (c === `
+`)
+        break;
+      advance(P.L);
+      continue;
+    }
+    if (c === ")" || c === "|" || c === " " || c === "\t" || c === `
+`)
+      break;
+    if (c === "$")
+      hasDollar = true;
+    if (c === "[")
+      hasBracketOutsideParen = true;
+    advance(P.L);
+  }
+  if (P.L.b === start)
+    return [];
+  const text = P.src.slice(startI, P.L.i);
+  const hasExtglobParen = /[*?+@!]\(/.test(text);
+  if (hasQuote && !hasExtglobParen) {
+    restoreLex(P.L, save);
+    return parseCasePatternSegmented(P);
+  }
+  if (!hasExtglobParen && (hasDollar || hasBracketOutsideParen)) {
+    restoreLex(P.L, save);
+    const w = parseWord(P, "arg");
+    return w ? [w] : [];
+  }
+  const type = hasExtglobParen || /[*?]/.test(text) || /^[-+?*@!][a-zA-Z]/.test(text) ? "extglob_pattern" : "word";
+  return [mk(P, type, start, P.L.b, [])];
+}
+function parseCasePatternSegmented(P) {
+  const parts = [];
+  let segStart = P.L.b;
+  let segStartI = P.L.i;
+  const flushSeg = () => {
+    if (P.L.i > segStartI) {
+      const t = P.src.slice(segStartI, P.L.i);
+      const type = /[*?]/.test(t) ? "extglob_pattern" : "word";
+      parts.push(mk(P, type, segStart, P.L.b, []));
+    }
+  };
+  while (P.L.i < P.L.len) {
+    const c = peek(P.L);
+    if (c === "\\" && P.L.i + 1 < P.L.len) {
+      advance(P.L);
+      advance(P.L);
+      continue;
+    }
+    if (c === '"') {
+      flushSeg();
+      parts.push(parseDoubleQuoted(P));
+      segStart = P.L.b;
+      segStartI = P.L.i;
+      continue;
+    }
+    if (c === "'") {
+      flushSeg();
+      const tok = nextToken(P.L, "arg");
+      parts.push(leaf(P, "raw_string", tok));
+      segStart = P.L.b;
+      segStartI = P.L.i;
+      continue;
+    }
+    if (c === ")" || c === "|" || c === " " || c === "\t" || c === `
+`)
+      break;
+    advance(P.L);
+  }
+  flushSeg();
+  return parts;
+}
+function parseFunction(P, fnTok) {
+  const fnKw = leaf(P, "function", fnTok);
+  skipBlanks(P.L);
+  const nameTok = nextToken(P.L, "arg");
+  const name = mk(P, "word", nameTok.start, nameTok.end, []);
+  const kids = [fnKw, name];
+  skipBlanks(P.L);
+  if (peek(P.L) === "(" && peek(P.L, 1) === ")") {
+    const o = nextToken(P.L, "cmd");
+    const c = nextToken(P.L, "cmd");
+    kids.push(leaf(P, "(", o));
+    kids.push(leaf(P, ")", c));
+  }
+  skipBlanks(P.L);
+  skipNewlines(P);
+  const body = parseCommand(P);
+  if (body) {
+    if (body.type === "redirected_statement" && body.children.length >= 2 && body.children[0].type === "compound_statement") {
+      kids.push(...body.children);
+    } else {
+      kids.push(body);
+    }
+  }
+  const last = kids[kids.length - 1];
+  return mk(P, "function_definition", fnKw.startIndex, last.endIndex, kids);
+}
+function parseDeclaration(P, kwTok) {
+  const kw = leaf(P, kwTok.value, kwTok);
+  const kids = [kw];
+  while (true) {
+    skipBlanks(P.L);
+    const c = peek(P.L);
+    if (c === "" || c === `
+` || c === ";" || c === "&" || c === "|" || c === ")" || c === "<" || c === ">") {
+      break;
+    }
+    const a = tryParseAssignment(P);
+    if (a) {
+      kids.push(a);
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "$") {
+      const w = parseWord(P, "arg");
+      if (w) {
+        kids.push(w);
+        continue;
+      }
+      break;
+    }
+    const save = saveLex(P.L);
+    const tok = nextToken(P.L, "arg");
+    if (tok.type === "WORD" || tok.type === "NUMBER") {
+      if (tok.value.startsWith("-")) {
+        kids.push(leaf(P, "word", tok));
+      } else if (isIdentStart(tok.value[0] ?? "")) {
+        kids.push(mk(P, "variable_name", tok.start, tok.end, []));
+      } else {
+        kids.push(leaf(P, "word", tok));
+      }
+    } else {
+      restoreLex(P.L, save);
+      break;
+    }
+  }
+  const last = kids[kids.length - 1];
+  return mk(P, "declaration_command", kw.startIndex, last.endIndex, kids);
+}
+function parseUnset(P, kwTok) {
+  const kw = leaf(P, "unset", kwTok);
+  const kids = [kw];
+  while (true) {
+    skipBlanks(P.L);
+    const c = peek(P.L);
+    if (c === "" || c === `
+` || c === ";" || c === "&" || c === "|" || c === ")" || c === "<" || c === ">") {
+      break;
+    }
+    const arg = parseWord(P, "arg");
+    if (!arg)
+      break;
+    if (arg.type === "word") {
+      if (arg.text.startsWith("-")) {
+        kids.push(arg);
+      } else {
+        kids.push(mk(P, "variable_name", arg.startIndex, arg.endIndex, []));
+      }
+    } else {
+      kids.push(arg);
+    }
+  }
+  const last = kids[kids.length - 1];
+  return mk(P, "unset_command", kw.startIndex, last.endIndex, kids);
+}
+function consumeKeyword(P, name, kids) {
+  skipNewlines(P);
+  const save = saveLex(P.L);
+  const t = nextToken(P.L, "cmd");
+  if (t.type === "WORD" && t.value === name) {
+    kids.push(leaf(P, name, t));
+  } else {
+    restoreLex(P.L, save);
+  }
+}
+function parseTestExpr(P, closer) {
+  return parseTestOr(P, closer);
+}
+function parseTestOr(P, closer) {
+  let left = parseTestAnd(P, closer);
+  if (!left)
+    return null;
+  while (true) {
+    skipBlanks(P.L);
+    const save = saveLex(P.L);
+    if (peek(P.L) === "|" && peek(P.L, 1) === "|") {
+      const s = P.L.b;
+      advance(P.L);
+      advance(P.L);
+      const op = mk(P, "||", s, P.L.b, []);
+      const right = parseTestAnd(P, closer);
+      if (!right) {
+        restoreLex(P.L, save);
+        break;
+      }
+      left = mk(P, "binary_expression", left.startIndex, right.endIndex, [
+        left,
+        op,
+        right
+      ]);
+    } else {
+      break;
+    }
+  }
+  return left;
+}
+function parseTestAnd(P, closer) {
+  let left = parseTestUnary(P, closer);
+  if (!left)
+    return null;
+  while (true) {
+    skipBlanks(P.L);
+    if (peek(P.L) === "&" && peek(P.L, 1) === "&") {
+      const s = P.L.b;
+      advance(P.L);
+      advance(P.L);
+      const op = mk(P, "&&", s, P.L.b, []);
+      const right = parseTestUnary(P, closer);
+      if (!right)
+        break;
+      left = mk(P, "binary_expression", left.startIndex, right.endIndex, [
+        left,
+        op,
+        right
+      ]);
+    } else {
+      break;
+    }
+  }
+  return left;
+}
+function parseTestUnary(P, closer) {
+  skipBlanks(P.L);
+  const c = peek(P.L);
+  if (c === "(") {
+    const s = P.L.b;
+    advance(P.L);
+    const open = mk(P, "(", s, P.L.b, []);
+    const inner = parseTestOr(P, closer);
+    skipBlanks(P.L);
+    let close;
+    if (peek(P.L) === ")") {
+      const cs = P.L.b;
+      advance(P.L);
+      close = mk(P, ")", cs, P.L.b, []);
+    } else {
+      close = mk(P, ")", P.L.b, P.L.b, []);
+    }
+    const kids = inner ? [open, inner, close] : [open, close];
+    return mk(P, "parenthesized_expression", open.startIndex, close.endIndex, kids);
+  }
+  return parseTestBinary(P, closer);
+}
+function parseTestNegatablePrimary(P, closer) {
+  skipBlanks(P.L);
+  const c = peek(P.L);
+  if (c === "!") {
+    const s = P.L.b;
+    advance(P.L);
+    const bang = mk(P, "!", s, P.L.b, []);
+    const inner = parseTestNegatablePrimary(P, closer);
+    if (!inner)
+      return bang;
+    return mk(P, "unary_expression", bang.startIndex, inner.endIndex, [
+      bang,
+      inner
+    ]);
+  }
+  if (c === "-" && isIdentStart(peek(P.L, 1))) {
+    const s = P.L.b;
+    advance(P.L);
+    while (isIdentChar(peek(P.L)))
+      advance(P.L);
+    const op = mk(P, "test_operator", s, P.L.b, []);
+    skipBlanks(P.L);
+    const arg = parseTestPrimary(P, closer);
+    if (!arg)
+      return op;
+    return mk(P, "unary_expression", op.startIndex, arg.endIndex, [op, arg]);
+  }
+  return parseTestPrimary(P, closer);
+}
+function parseTestBinary(P, closer) {
+  skipBlanks(P.L);
+  const left = parseTestNegatablePrimary(P, closer);
+  if (!left)
+    return null;
+  skipBlanks(P.L);
+  const c = peek(P.L);
+  const c1 = peek(P.L, 1);
+  let op = null;
+  const os = P.L.b;
+  if (c === "=" && c1 === "=") {
+    advance(P.L);
+    advance(P.L);
+    op = mk(P, "==", os, P.L.b, []);
+  } else if (c === "!" && c1 === "=") {
+    advance(P.L);
+    advance(P.L);
+    op = mk(P, "!=", os, P.L.b, []);
+  } else if (c === "=" && c1 === "~") {
+    advance(P.L);
+    advance(P.L);
+    op = mk(P, "=~", os, P.L.b, []);
+  } else if (c === "=" && c1 !== "=") {
+    advance(P.L);
+    op = mk(P, "=", os, P.L.b, []);
+  } else if (c === "<" && c1 !== "<") {
+    advance(P.L);
+    op = mk(P, "<", os, P.L.b, []);
+  } else if (c === ">" && c1 !== ">") {
+    advance(P.L);
+    op = mk(P, ">", os, P.L.b, []);
+  } else if (c === "-" && isIdentStart(c1)) {
+    advance(P.L);
+    while (isIdentChar(peek(P.L)))
+      advance(P.L);
+    op = mk(P, "test_operator", os, P.L.b, []);
+  }
+  if (!op)
+    return left;
+  skipBlanks(P.L);
+  if (closer === "]]") {
+    const opText = op.type;
+    if (opText === "=~") {
+      skipBlanks(P.L);
+      const rc = peek(P.L);
+      let rhs = null;
+      if (rc === '"' || rc === "'") {
+        const save = saveLex(P.L);
+        const quoted = rc === '"' ? parseDoubleQuoted(P) : leaf(P, "raw_string", nextToken(P.L, "arg"));
+        let j = P.L.i;
+        while (j < P.L.len && (P.src[j] === " " || P.src[j] === "\t"))
+          j++;
+        const nc = P.src[j] ?? "";
+        const nc1 = P.src[j + 1] ?? "";
+        if (nc === "]" && nc1 === "]" || nc === "&" && nc1 === "&" || nc === "|" && nc1 === "|" || nc === `
+` || nc === "") {
+          rhs = quoted;
+        } else {
+          restoreLex(P.L, save);
+        }
+      }
+      if (!rhs)
+        rhs = parseTestRegexRhs(P);
+      if (!rhs)
+        return left;
+      return mk(P, "binary_expression", left.startIndex, rhs.endIndex, [
+        left,
+        op,
+        rhs
+      ]);
+    }
+    if (opText === "=") {
+      const rhs = parseTestRegexRhs(P);
+      if (!rhs)
+        return left;
+      return mk(P, "binary_expression", left.startIndex, rhs.endIndex, [
+        left,
+        op,
+        rhs
+      ]);
+    }
+    if (opText === "==" || opText === "!=") {
+      const parts = parseTestExtglobRhs(P);
+      if (parts.length === 0)
+        return left;
+      const last = parts[parts.length - 1];
+      return mk(P, "binary_expression", left.startIndex, last.endIndex, [
+        left,
+        op,
+        ...parts
+      ]);
+    }
+  }
+  const right = parseTestPrimary(P, closer);
+  if (!right)
+    return left;
+  return mk(P, "binary_expression", left.startIndex, right.endIndex, [
+    left,
+    op,
+    right
+  ]);
+}
+function parseTestRegexRhs(P) {
+  skipBlanks(P.L);
+  const start = P.L.b;
+  let parenDepth = 0;
+  let bracketDepth = 0;
+  while (P.L.i < P.L.len) {
+    const c = peek(P.L);
+    if (c === "\\" && P.L.i + 1 < P.L.len) {
+      advance(P.L);
+      advance(P.L);
+      continue;
+    }
+    if (c === `
+`)
+      break;
+    if (parenDepth === 0 && bracketDepth === 0) {
+      if (c === "]" && peek(P.L, 1) === "]")
+        break;
+      if (c === " " || c === "\t") {
+        let j = P.L.i;
+        while (j < P.L.len && (P.L.src[j] === " " || P.L.src[j] === "\t"))
+          j++;
+        const nc = P.L.src[j] ?? "";
+        const nc1 = P.L.src[j + 1] ?? "";
+        if (nc === "]" && nc1 === "]" || nc === "&" && nc1 === "&" || nc === "|" && nc1 === "|") {
+          break;
+        }
+        advance(P.L);
+        continue;
+      }
+    }
+    if (c === "(")
+      parenDepth++;
+    else if (c === ")" && parenDepth > 0)
+      parenDepth--;
+    else if (c === "[")
+      bracketDepth++;
+    else if (c === "]" && bracketDepth > 0)
+      bracketDepth--;
+    advance(P.L);
+  }
+  if (P.L.b === start)
+    return null;
+  return mk(P, "regex", start, P.L.b, []);
+}
+function parseTestExtglobRhs(P) {
+  skipBlanks(P.L);
+  const parts = [];
+  let segStart = P.L.b;
+  let segStartI = P.L.i;
+  let parenDepth = 0;
+  const flushSeg = () => {
+    if (P.L.i > segStartI) {
+      const text = P.src.slice(segStartI, P.L.i);
+      const type = /^\d+$/.test(text) ? "number" : "extglob_pattern";
+      parts.push(mk(P, type, segStart, P.L.b, []));
+    }
+  };
+  while (P.L.i < P.L.len) {
+    const c = peek(P.L);
+    if (c === "\\" && P.L.i + 1 < P.L.len) {
+      advance(P.L);
+      advance(P.L);
+      continue;
+    }
+    if (c === `
+`)
+      break;
+    if (parenDepth === 0) {
+      if (c === "]" && peek(P.L, 1) === "]")
+        break;
+      if (c === " " || c === "\t") {
+        let j = P.L.i;
+        while (j < P.L.len && (P.L.src[j] === " " || P.L.src[j] === "\t"))
+          j++;
+        const nc = P.L.src[j] ?? "";
+        const nc1 = P.L.src[j + 1] ?? "";
+        if (nc === "]" && nc1 === "]" || nc === "&" && nc1 === "&" || nc === "|" && nc1 === "|") {
+          break;
+        }
+        advance(P.L);
+        continue;
+      }
+    }
+    if (c === "$") {
+      const c1 = peek(P.L, 1);
+      if (c1 === "(" || c1 === "{" || isIdentStart(c1) || SPECIAL_VARS.has(c1)) {
+        flushSeg();
+        const exp = parseDollarLike(P);
+        if (exp)
+          parts.push(exp);
+        segStart = P.L.b;
+        segStartI = P.L.i;
+        continue;
+      }
+    }
+    if (c === '"') {
+      flushSeg();
+      parts.push(parseDoubleQuoted(P));
+      segStart = P.L.b;
+      segStartI = P.L.i;
+      continue;
+    }
+    if (c === "'") {
+      flushSeg();
+      const tok = nextToken(P.L, "arg");
+      parts.push(leaf(P, "raw_string", tok));
+      segStart = P.L.b;
+      segStartI = P.L.i;
+      continue;
+    }
+    if (c === "(")
+      parenDepth++;
+    else if (c === ")" && parenDepth > 0)
+      parenDepth--;
+    advance(P.L);
+  }
+  flushSeg();
+  return parts;
+}
+function parseTestPrimary(P, closer) {
+  skipBlanks(P.L);
+  if (closer === "]" && peek(P.L) === "]")
+    return null;
+  if (closer === "]]" && peek(P.L) === "]" && peek(P.L, 1) === "]")
+    return null;
+  return parseWord(P, "arg");
+}
+const ARITH_PREC = {
+  "=": 2,
+  "+=": 2,
+  "-=": 2,
+  "*=": 2,
+  "/=": 2,
+  "%=": 2,
+  "<<=": 2,
+  ">>=": 2,
+  "&=": 2,
+  "^=": 2,
+  "|=": 2,
+  "||": 4,
+  "&&": 5,
+  "|": 6,
+  "^": 7,
+  "&": 8,
+  "==": 9,
+  "!=": 9,
+  "<": 10,
+  ">": 10,
+  "<=": 10,
+  ">=": 10,
+  "<<": 11,
+  ">>": 11,
+  "+": 12,
+  "-": 12,
+  "*": 13,
+  "/": 13,
+  "%": 13,
+  "**": 14
+};
+const ARITH_RIGHT_ASSOC = new Set([
+  "=",
+  "+=",
+  "-=",
+  "*=",
+  "/=",
+  "%=",
+  "<<=",
+  ">>=",
+  "&=",
+  "^=",
+  "|=",
+  "**"
+]);
+function parseArithExpr(P, stop, mode = "var") {
+  return parseArithTernary(P, stop, mode);
+}
+function parseArithCommaList(P, stop, mode = "var") {
+  const out = [];
+  while (true) {
+    const e = parseArithTernary(P, stop, mode);
+    if (e)
+      out.push(e);
+    skipBlanks(P.L);
+    if (peek(P.L) === "," && !isArithStop(P, stop)) {
+      advance(P.L);
+      continue;
+    }
+    break;
+  }
+  return out;
+}
+function parseArithTernary(P, stop, mode) {
+  const cond = parseArithBinary(P, stop, 0, mode);
+  if (!cond)
+    return null;
+  skipBlanks(P.L);
+  if (peek(P.L) === "?") {
+    const qs = P.L.b;
+    advance(P.L);
+    const q = mk(P, "?", qs, P.L.b, []);
+    const t = parseArithBinary(P, ":", 0, mode);
+    skipBlanks(P.L);
+    let colon;
+    if (peek(P.L) === ":") {
+      const cs = P.L.b;
+      advance(P.L);
+      colon = mk(P, ":", cs, P.L.b, []);
+    } else {
+      colon = mk(P, ":", P.L.b, P.L.b, []);
+    }
+    const f = parseArithTernary(P, stop, mode);
+    const last = f ?? colon;
+    const kids = [cond, q];
+    if (t)
+      kids.push(t);
+    kids.push(colon);
+    if (f)
+      kids.push(f);
+    return mk(P, "ternary_expression", cond.startIndex, last.endIndex, kids);
+  }
+  return cond;
+}
+function scanArithOp(P) {
+  const c = peek(P.L);
+  const c1 = peek(P.L, 1);
+  const c2 = peek(P.L, 2);
+  if (c === "<" && c1 === "<" && c2 === "=")
+    return ["<<=", 3];
+  if (c === ">" && c1 === ">" && c2 === "=")
+    return [">>=", 3];
+  if (c === "*" && c1 === "*")
+    return ["**", 2];
+  if (c === "<" && c1 === "<")
+    return ["<<", 2];
+  if (c === ">" && c1 === ">")
+    return [">>", 2];
+  if (c === "=" && c1 === "=")
+    return ["==", 2];
+  if (c === "!" && c1 === "=")
+    return ["!=", 2];
+  if (c === "<" && c1 === "=")
+    return ["<=", 2];
+  if (c === ">" && c1 === "=")
+    return [">=", 2];
+  if (c === "&" && c1 === "&")
+    return ["&&", 2];
+  if (c === "|" && c1 === "|")
+    return ["||", 2];
+  if (c === "+" && c1 === "=")
+    return ["+=", 2];
+  if (c === "-" && c1 === "=")
+    return ["-=", 2];
+  if (c === "*" && c1 === "=")
+    return ["*=", 2];
+  if (c === "/" && c1 === "=")
+    return ["/=", 2];
+  if (c === "%" && c1 === "=")
+    return ["%=", 2];
+  if (c === "&" && c1 === "=")
+    return ["&=", 2];
+  if (c === "^" && c1 === "=")
+    return ["^=", 2];
+  if (c === "|" && c1 === "=")
+    return ["|=", 2];
+  if (c === "+" && c1 !== "+")
+    return ["+", 1];
+  if (c === "-" && c1 !== "-")
+    return ["-", 1];
+  if (c === "*")
+    return ["*", 1];
+  if (c === "/")
+    return ["/", 1];
+  if (c === "%")
+    return ["%", 1];
+  if (c === "<")
+    return ["<", 1];
+  if (c === ">")
+    return [">", 1];
+  if (c === "&")
+    return ["&", 1];
+  if (c === "|")
+    return ["|", 1];
+  if (c === "^")
+    return ["^", 1];
+  if (c === "=")
+    return ["=", 1];
+  return null;
+}
+function parseArithBinary(P, stop, minPrec, mode) {
+  let left = parseArithUnary(P, stop, mode);
+  if (!left)
+    return null;
+  while (true) {
+    skipBlanks(P.L);
+    if (isArithStop(P, stop))
+      break;
+    if (peek(P.L) === ",")
+      break;
+    const opInfo = scanArithOp(P);
+    if (!opInfo)
+      break;
+    const [opText, opLen] = opInfo;
+    const prec = ARITH_PREC[opText];
+    if (prec === undefined || prec < minPrec)
+      break;
+    const os = P.L.b;
+    for (let k = 0;k < opLen; k++)
+      advance(P.L);
+    const op = mk(P, opText, os, P.L.b, []);
+    const nextMin = ARITH_RIGHT_ASSOC.has(opText) ? prec : prec + 1;
+    const right = parseArithBinary(P, stop, nextMin, mode);
+    if (!right)
+      break;
+    left = mk(P, "binary_expression", left.startIndex, right.endIndex, [
+      left,
+      op,
+      right
+    ]);
+  }
+  return left;
+}
+function parseArithUnary(P, stop, mode) {
+  skipBlanks(P.L);
+  if (isArithStop(P, stop))
+    return null;
+  const c = peek(P.L);
+  const c1 = peek(P.L, 1);
+  if (c === "+" && c1 === "+" || c === "-" && c1 === "-") {
+    const s = P.L.b;
+    advance(P.L);
+    advance(P.L);
+    const op = mk(P, c + c1, s, P.L.b, []);
+    const inner = parseArithUnary(P, stop, mode);
+    if (!inner)
+      return op;
+    return mk(P, "unary_expression", op.startIndex, inner.endIndex, [op, inner]);
+  }
+  if (c === "-" || c === "+" || c === "!" || c === "~") {
+    if (mode !== "var" && c === "-" && isDigit(c1)) {
+      const s = P.L.b;
+      advance(P.L);
+      while (isDigit(peek(P.L)))
+        advance(P.L);
+      return mk(P, "number", s, P.L.b, []);
+    }
+    const s = P.L.b;
+    advance(P.L);
+    const op = mk(P, c, s, P.L.b, []);
+    const inner = parseArithUnary(P, stop, mode);
+    if (!inner)
+      return op;
+    return mk(P, "unary_expression", op.startIndex, inner.endIndex, [op, inner]);
+  }
+  return parseArithPostfix(P, stop, mode);
+}
+function parseArithPostfix(P, stop, mode) {
+  const prim = parseArithPrimary(P, stop, mode);
+  if (!prim)
+    return null;
+  const c = peek(P.L);
+  const c1 = peek(P.L, 1);
+  if (c === "+" && c1 === "+" || c === "-" && c1 === "-") {
+    const s = P.L.b;
+    advance(P.L);
+    advance(P.L);
+    const op = mk(P, c + c1, s, P.L.b, []);
+    return mk(P, "postfix_expression", prim.startIndex, op.endIndex, [prim, op]);
+  }
+  return prim;
+}
+function parseArithPrimary(P, stop, mode) {
+  skipBlanks(P.L);
+  if (isArithStop(P, stop))
+    return null;
+  const c = peek(P.L);
+  if (c === "(") {
+    const s = P.L.b;
+    advance(P.L);
+    const open = mk(P, "(", s, P.L.b, []);
+    const inners = parseArithCommaList(P, ")", mode);
+    skipBlanks(P.L);
+    let close;
+    if (peek(P.L) === ")") {
+      const cs = P.L.b;
+      advance(P.L);
+      close = mk(P, ")", cs, P.L.b, []);
+    } else {
+      close = mk(P, ")", P.L.b, P.L.b, []);
+    }
+    return mk(P, "parenthesized_expression", open.startIndex, close.endIndex, [
+      open,
+      ...inners,
+      close
+    ]);
+  }
+  if (c === '"') {
+    return parseDoubleQuoted(P);
+  }
+  if (c === "$") {
+    return parseDollarLike(P);
+  }
+  if (isDigit(c)) {
+    const s = P.L.b;
+    while (isDigit(peek(P.L)))
+      advance(P.L);
+    if (P.L.b - s === 1 && c === "0" && (peek(P.L) === "x" || peek(P.L) === "X")) {
+      advance(P.L);
+      while (isHexDigit(peek(P.L)))
+        advance(P.L);
+    } else if (peek(P.L) === "#") {
+      advance(P.L);
+      while (isBaseDigit(peek(P.L)))
+        advance(P.L);
+    }
+    return mk(P, "number", s, P.L.b, []);
+  }
+  if (isIdentStart(c)) {
+    const s = P.L.b;
+    while (isIdentChar(peek(P.L)))
+      advance(P.L);
+    const nc = peek(P.L);
+    if (mode === "assign") {
+      skipBlanks(P.L);
+      const ac = peek(P.L);
+      const ac1 = peek(P.L, 1);
+      if (ac === "=" && ac1 !== "=") {
+        const vn = mk(P, "variable_name", s, P.L.b, []);
+        const es = P.L.b;
+        advance(P.L);
+        const eq = mk(P, "=", es, P.L.b, []);
+        const val = parseArithTernary(P, stop, mode);
+        const end = val ? val.endIndex : eq.endIndex;
+        const kids = val ? [vn, eq, val] : [vn, eq];
+        return mk(P, "variable_assignment", s, end, kids);
+      }
+    }
+    if (nc === "[") {
+      const vn = mk(P, "variable_name", s, P.L.b, []);
+      const brS = P.L.b;
+      advance(P.L);
+      const brOpen = mk(P, "[", brS, P.L.b, []);
+      const idx = parseArithTernary(P, "]", "var") ?? parseDollarLike(P);
+      skipBlanks(P.L);
+      let brClose;
+      if (peek(P.L) === "]") {
+        const cs = P.L.b;
+        advance(P.L);
+        brClose = mk(P, "]", cs, P.L.b, []);
+      } else {
+        brClose = mk(P, "]", P.L.b, P.L.b, []);
+      }
+      const kids = idx ? [vn, brOpen, idx, brClose] : [vn, brOpen, brClose];
+      return mk(P, "subscript", s, brClose.endIndex, kids);
+    }
+    const identType = mode === "var" ? "variable_name" : "word";
+    return mk(P, identType, s, P.L.b, []);
+  }
+  return null;
+}
+function isArithStop(P, stop) {
+  const c = peek(P.L);
+  if (stop === "))")
+    return c === ")" && peek(P.L, 1) === ")";
+  if (stop === ")")
+    return c === ")";
+  if (stop === ";")
+    return c === ";";
+  if (stop === ":")
+    return c === ":";
+  if (stop === "]")
+    return c === "]";
+  if (stop === "}")
+    return c === "}";
+  if (stop === ":}")
+    return c === ":" || c === "}";
+  return c === "" || c === `
+`;
+}