@taliesinb/mash 0.0.0-stage → 0.1.0

package/src/vm/expand.ts

@@ -0,0 +1,721 @@
+/**
+ * Word expansion, in bash order: brace expansion, tilde expansion, parameter
+ * / arithmetic / command substitution (left to right), field splitting,
+ * pathname expansion, quote removal.
+ */
+
+import * as os from 'node:os'
+import type * as A from '../parser/ast.ts'
+import { ArithError } from './arith.ts'
+import type { Proc } from './proc.ts'
+import { CommandError, DiscardError, FatalError } from './proc.ts'
+import { globPaths, hasGlobChars, matchPattern, quotePattern, removePrefix, removeSuffix, replacePattern, unescapePattern } from './pattern.ts'
+import { dashFlags, type Variable } from './state.ts'
+
+export interface ExpandHost {
+  commandSubst(node: A.CmdSubst, proc: Proc): Promise<string>
+  processSubst(node: A.ProcSubst, proc: Proc): Promise<string>
+  arith(expr: A.ArithExpr | null, proc: Proc): Promise<bigint>
+  /** Assign a scalar (for `${x:=v}`). */
+  assign(proc: Proc, name: string, value: string): void
+  /** Value of dynamic variables (RANDOM, SECONDS, BASHPID, ...), or undefined. */
+  dynamic(proc: Proc, name: string): string | undefined
+  shellPid: number
+}
+
+/** A piece of expanded text. `split`: subject to field splitting; `quoted`: protected from globbing. */
+interface Seg {
+  text: string
+  quoted: boolean
+  split: boolean
+}
+type Piece = Seg | { brk: true }
+
+const BRK: Piece = { brk: true }
+
+function isBrk(p: Piece): p is { brk: true } {
+  return 'brk' in p
+}
+
+// ---------------------------------------------------------------------------
+// Brace expansion (on the part list, before anything else)
+// ---------------------------------------------------------------------------
+
+type Atom = { ch: string } | { part: A.WordPart }
+
+function toAtoms(parts: A.WordPart[]): Atom[] {
+  const atoms: Atom[] = []
+  for (const p of parts) {
+    if (p.type === 'Lit') for (const ch of p.value) atoms.push({ ch })
+    else atoms.push({ part: p })
+  }
+  return atoms
+}
+
+function fromAtoms(atoms: Atom[], like: A.Word): A.WordPart[] {
+  const parts: A.WordPart[] = []
+  let lit = ''
+  const flush = (): void => {
+    if (lit !== '') parts.push({ type: 'Lit', value: lit, id: like.id, span: like.span })
+    lit = ''
+  }
+  for (const a of atoms) {
+    if ('ch' in a) lit += a.ch
+    else {
+      flush()
+      parts.push(a.part)
+    }
+  }
+  flush()
+  return parts
+}
+
+function seqExpansion(body: string): string[] | null {
+  let m = /^(-?\d+)\.\.(-?\d+)(?:\.\.(-?\d+))?$/.exec(body)
+  if (m) {
+    const a = Number(m[1])
+    const b = Number(m[2])
+    let step = m[3] ? Math.abs(Number(m[3])) : 1
+    if (step === 0) step = 1
+    const width = (m[1].replace('-', '').startsWith('0') && m[1].length > 1) || (m[2].replace('-', '').startsWith('0') && m[2].length > 1)
+      ? Math.max(m[1].length, m[2].length) : 0
+    const out: string[] = []
+    if (Math.abs(b - a) / step > 100000) return null
+    for (let i = a; a <= b ? i <= b : i >= b; i += a <= b ? step : -step) {
+      let s = String(Math.abs(i))
+      if (width) s = s.padStart(width - (i < 0 ? 1 : 0), '0')
+      out.push((i < 0 ? '-' : '') + s)
+    }
+    return out
+  }
+  m = /^([a-zA-Z])\.\.([a-zA-Z])(?:\.\.(-?\d+))?$/.exec(body)
+  if (m) {
+    const a = m[1].charCodeAt(0)
+    const b = m[2].charCodeAt(0)
+    const step = m[3] ? Math.abs(Number(m[3])) || 1 : 1
+    const out: string[] = []
+    for (let i = a; a <= b ? i <= b : i >= b; i += a <= b ? step : -step) out.push(String.fromCharCode(i))
+    return out
+  }
+  return null
+}
+
+function braceExpandAtoms(atoms: Atom[]): Atom[][] {
+  for (let i = 0; i < atoms.length; i++) {
+    const a = atoms[i]
+    if (!('ch' in a) || a.ch !== '{') continue
+    // find matching close and top-level commas
+    let depth = 0
+    const commas: number[] = []
+    let close = -1
+    for (let j = i + 1; j < atoms.length; j++) {
+      const b = atoms[j]
+      if (!('ch' in b)) continue
+      if (b.ch === '{') depth++
+      else if (b.ch === '}') {
+        if (depth === 0) {
+          close = j
+          break
+        }
+        depth--
+      } else if (b.ch === ',' && depth === 0) commas.push(j)
+    }
+    if (close === -1) continue
+    const prefix = atoms.slice(0, i)
+    const suffixes = braceExpandAtoms(atoms.slice(close + 1))
+    let alternatives: Atom[][]
+    if (commas.length > 0) {
+      alternatives = []
+      let start = i + 1
+      for (const c of [...commas, close]) {
+        alternatives.push(...braceExpandAtoms(atoms.slice(start, c)))
+        start = c + 1
+      }
+    } else {
+      const inner = atoms.slice(i + 1, close)
+      if (!inner.every((x) => 'ch' in x)) continue
+      const seq = seqExpansion(inner.map((x) => (x as { ch: string }).ch).join(''))
+      if (!seq) continue
+      alternatives = seq.map((s) => [...s].map((ch) => ({ ch })))
+    }
+    const out: Atom[][] = []
+    for (const alt of alternatives) for (const suf of suffixes) out.push([...prefix, ...alt, ...suf])
+    return out
+  }
+  return [atoms]
+}
+
+export function braceExpand(word: A.Word): A.Word[] {
+  if (!word.parts.some((p) => p.type === 'Lit' && p.value.includes('{'))) return [word]
+  const results = braceExpandAtoms(toAtoms(word.parts))
+  if (results.length === 1) return [word]
+  return results.map((atoms) => ({ ...word, parts: fromAtoms(atoms, word) }))
+}
+
+// ---------------------------------------------------------------------------
+// Expander
+// ---------------------------------------------------------------------------
+
+export interface FieldOptions {
+  /** Skip pathname expansion. */
+  noGlob?: boolean
+}
+
+export class Expander {
+  private readonly host: ExpandHost
+
+  constructor(host: ExpandHost) {
+    this.host = host
+  }
+
+  /** Expand words into fields (full expansion, for argv and `for` lists). */
+  async expandFields(words: A.Word[], proc: Proc, opts: FieldOptions = {}): Promise<string[]> {
+    const out: string[] = []
+    for (const w of words) {
+      for (const bw of braceExpand(w)) {
+        const pieces = await this.expandParts(bw.parts, proc, false, true)
+        for (const field of this.split(pieces, proc)) {
+          out.push(...this.glob(field, proc, opts))
+        }
+      }
+    }
+    return out
+  }
+
+  /** Expand without splitting or globbing (assignments, redirect targets, case word, [[ ]] operands). */
+  /**
+   * The replacement of `${x/pat/rep}`. With `patsub_replacement` (on by
+   * default, as in bash 5.2) every `&` in an unquoted part, including the
+   * value of an unquoted `$var`, stands for the matched text; quoted parts and
+   * `\&` are literal.
+   */
+  private async replacement(word: A.Word, proc: Proc): Promise<string | ((match: string) => string)> {
+    if (!proc.state.shopts.has('patsub_replacement')) return this.expandString(word, proc)
+    const pieces: (string | null)[] = []
+    for (const [i, part] of word.parts.entries()) {
+      const text = await this.expandString({ ...word, parts: i === 0 ? word.parts.slice(0, 1) : [part] }, proc)
+      if (part.type === 'SglQuoted' || part.type === 'DblQuoted' || part.type === 'Escaped') pieces.push(text)
+      else text.split('&').forEach((t, j) => (j > 0 ? pieces.push(null, t) : pieces.push(t)))
+    }
+    if (!pieces.includes(null)) return pieces.join('')
+    return (match) => pieces.map((p) => (p === null ? match : p)).join('')
+  }
+
+  async expandString(word: A.Word, proc: Proc, opts: { tildeAssign?: boolean } = {}): Promise<string> {
+    const pieces = await this.expandParts(word.parts, proc, false, true, opts.tildeAssign)
+    return this.joinPieces(pieces)
+  }
+
+  /** Expand to a pattern: quoted text is escaped, unquoted expansions stay pattern-active. */
+  async expandPattern(word: A.Word, proc: Proc): Promise<string> {
+    const pieces = await this.expandParts(word.parts, proc, false, true)
+    let s = ''
+    for (const p of pieces) {
+      if (isBrk(p)) {
+        s += ' '
+        continue
+      }
+      s += p.quoted ? quotePattern(p.text) : p.text
+    }
+    return s
+  }
+
+  /** Expand a here-doc body (parameter/command/arith expansion only). */
+  async expandHeredoc(word: A.Word, proc: Proc): Promise<string> {
+    const pieces = await this.expandParts(word.parts, proc, true, false)
+    return this.joinPieces(pieces)
+  }
+
+  private joinPieces(pieces: Piece[]): string {
+    let s = ''
+    for (const p of pieces) s += isBrk(p) ? ' ' : p.text
+    return s
+  }
+
+  private ifs(proc: Proc): string {
+    const v = proc.state.getString('IFS')
+    return v === undefined ? ' \t\n' : v
+  }
+
+  private ifsFirst(proc: Proc): string {
+    const v = proc.state.getString('IFS')
+    return v === undefined ? ' ' : v.slice(0, 1)
+  }
+
+  private async expandParts(parts: A.WordPart[], proc: Proc, quoted: boolean, tilde: boolean, tildeAssign = false): Promise<Piece[]> {
+    const out: Piece[] = []
+    for (let i = 0; i < parts.length; i++) {
+      const p = parts[i]
+      switch (p.type) {
+        case 'Lit': {
+          if (!quoted && tilde && (i === 0 || tildeAssign)) {
+            const t = this.tilde(p.value, proc, i === 0, tildeAssign)
+            if (t !== null) {
+              out.push(...t)
+              break
+            }
+          }
+          out.push({ text: p.value, quoted, split: false })
+          break
+        }
+        case 'SglQuoted':
+        case 'Escaped':
+          out.push({ text: p.value, quoted: true, split: false })
+          break
+        case 'DblQuoted': {
+          const inner = await this.expandParts(p.parts, proc, true, false)
+          const onlyAtExpansions = p.parts.length > 0 && p.parts.every((q) => q.type === 'ParamExp' && isAtExpansion(q))
+          if (inner.length === 0 && !onlyAtExpansions) out.push({ text: '', quoted: true, split: false })
+          else out.push(...inner)
+          break
+        }
+        case 'ParamExp':
+          out.push(...(await this.expandParam(p, proc, quoted)))
+          break
+        case 'CmdSubst': {
+          const text = await this.host.commandSubst(p, proc)
+          out.push({ text, quoted, split: !quoted })
+          break
+        }
+        case 'ArithExp': {
+          let v: bigint
+          try {
+            v = await this.host.arith(p.expr, proc)
+          } catch (e) {
+            if (e instanceof ArithError) throw new DiscardError(e.message)
+            throw e
+          }
+          out.push({ text: String(v), quoted, split: !quoted })
+          break
+        }
+        case 'ProcSubst': {
+          const path = await this.host.processSubst(p, proc)
+          out.push({ text: path, quoted: true, split: false })
+          break
+        }
+      }
+    }
+    return out
+  }
+
+  private tilde(text: string, proc: Proc, atStart: boolean, assign: boolean): Piece[] | null {
+    if (!text.includes('~')) return null
+    const home = proc.state.getString('HOME') ?? os.homedir()
+    const expandOne = (prefix: string): string | null => {
+      if (prefix === '') return home
+      if (prefix === '+') return proc.state.getString('PWD') ?? proc.state.cwd
+      if (prefix === '-') return proc.state.getString('OLDPWD') ?? null
+      if (prefix === os.userInfo().username) return os.homedir()
+      return null
+    }
+    if (!assign) {
+      if (!atStart || !text.startsWith('~')) return null
+      const slash = text.indexOf('/')
+      const prefix = slash === -1 ? text.slice(1) : text.slice(1, slash)
+      const h = expandOne(prefix)
+      if (h === null) return null
+      return [{ text: h, quoted: true, split: false }, { text: slash === -1 ? '' : text.slice(slash), quoted: false, split: false }]
+    }
+    // assignment: after = (start of value) and after each unquoted ':'
+    const pieces: Piece[] = []
+    const chunks = text.split(':')
+    chunks.forEach((chunk, idx) => {
+      if (idx > 0) pieces.push({ text: ':', quoted: false, split: false })
+      if (chunk.startsWith('~') && (idx > 0 || atStart)) {
+        const slash = chunk.indexOf('/')
+        const prefix = slash === -1 ? chunk.slice(1) : chunk.slice(1, slash)
+        const h = expandOne(prefix)
+        if (h !== null) {
+          pieces.push({ text: h, quoted: true, split: false })
+          pieces.push({ text: slash === -1 ? '' : chunk.slice(slash), quoted: false, split: false })
+          return
+        }
+      }
+      pieces.push({ text: chunk, quoted: false, split: false })
+    })
+    return pieces
+  }
+
+  // -------------------------------------------------------------------------
+  // Parameters
+  // -------------------------------------------------------------------------
+
+  /** Raw value: a string, an array of fields (`$@`, `${a[@]}`), or undefined (unset). */
+  async paramValue(p: A.ParamExp, proc: Proc): Promise<{ value: string | string[] | undefined; star: boolean }> {
+    const st = proc.state
+    let name = p.name
+    if (p.indirect && !(p.index && isAllIndex(p.index))) {
+      const target = await this.simpleParamValue(name, null, proc)
+      if (target === undefined || target === '') {
+        throw new FatalError(`${name}: invalid indirect expansion`)
+      }
+      const m = /^([A-Za-z_][A-Za-z0-9_]*|[0-9]+|[@*#?$!-])(?:\[(.*)\])?$/s.exec(target)
+      if (!m) throw new FatalError(`${target}: invalid variable name`)
+      name = m[1]
+      if (m[2] !== undefined) {
+        if (m[2] === '@' || m[2] === '*') return { value: this.arrayValues(name, proc), star: m[2] === '*' }
+        return { value: this.elementValue(name, m[2], proc), star: false }
+      }
+      return this.paramValue({ ...p, name, indirect: false, index: p.index }, proc)
+    }
+    if (p.prefixNames) {
+      return { value: st.visibleNames().filter((n) => n.startsWith(name) && st.isSet(n)), star: p.prefixNames === '*' }
+    }
+    if (name === '@' || name === '*') return { value: [...st.positional], star: name === '*' }
+    if (p.index) {
+      if (isAllIndex(p.index)) {
+        const star = literalIndex(p.index) === '*'
+        if (p.indirect) return { value: this.arrayKeys(name, proc), star }
+        return { value: this.arrayValues(name, proc), star }
+      }
+      const v = st.lookup(name)
+      let key: string
+      if (v?.value?.kind === 'assoc' || v?.declaredKind === 'assoc') key = await this.expandString(p.index, proc)
+      else {
+        const idxText = await this.expandString(p.index, proc)
+        key = String(await this.host.arith(parseIndexExpr(idxText), proc))
+      }
+      return { value: this.elementValue(name, key, proc), star: false }
+    }
+    return { value: await this.simpleParamValue(name, null, proc), star: false }
+  }
+
+  private async simpleParamValue(name: string, _index: null, proc: Proc): Promise<string | undefined> {
+    const st = proc.state
+    switch (name) {
+      case '#': return String(st.positional.length)
+      case '?': return String(st.lastStatus)
+      case '-': return dashFlags(st)
+      case '$': return String(this.host.shellPid)
+      case '!': return st.lastBgPid === null ? undefined : String(st.lastBgPid)
+      case '0': return st.arg0
+      case '@': case '*': return st.positional.join(this.ifsFirst(proc))
+    }
+    if (/^[0-9]+$/.test(name)) return st.positional[Number(name) - 1]
+    const dyn = this.host.dynamic(proc, name)
+    if (dyn !== undefined) return dyn
+    return st.getString(name)
+  }
+
+  private arrayValues(name: string, proc: Proc): string[] {
+    if (name === 'FUNCNAME') return proc.state.funcStack.length > 0 ? [...proc.state.funcStack, 'main'] : []
+    const v = proc.state.lookup(name)
+    return varElements(v)
+  }
+
+  private arrayKeys(name: string, proc: Proc): string[] {
+    const v = proc.state.lookup(name)
+    if (!v || v.value === null) return []
+    if (v.value.kind === 'string') return ['0']
+    if (v.value.kind === 'indexed') return [...v.value.values.keys()].sort((a, b) => a - b).map(String)
+    return [...v.value.values.keys()]
+  }
+
+  private elementValue(name: string, key: string, proc: Proc): string | undefined {
+    if (name === 'FUNCNAME') return proc.state.funcStack.length > 0 ? [...proc.state.funcStack, 'main'][Number(key)] : undefined
+    const v = proc.state.lookup(name)
+    if (!v || v.value === null) return undefined
+    if (v.value.kind === 'string') return key === '0' ? v.value.value : undefined
+    if (v.value.kind === 'indexed') {
+      let k = Number(key)
+      if (k < 0) {
+        const keys = [...v.value.values.keys()]
+        const max = keys.length === 0 ? -1 : Math.max(...keys)
+        k = max + 1 + k
+      }
+      return v.value.values.get(k)
+    }
+    return v.value.values.get(key)
+  }
+
+  private async expandParam(p: A.ParamExp, proc: Proc, quoted: boolean): Promise<Piece[]> {
+    const st = proc.state
+    const { value: raw, star } = await this.paramValue(p, proc)
+    const isList = Array.isArray(raw)
+    const op = p.op
+
+    // ${#x}
+    if (p.length) {
+      if (isList) return [{ text: String(raw.length), quoted, split: !quoted }]
+      if (raw === undefined && st.options.nounset && !(p.name === '@' || p.name === '*')) throw new FatalError(`${p.name}: unbound variable`, 127)
+      return [{ text: String([...(raw ?? '')].length), quoted, split: !quoted }]
+    }
+
+    const isUnset = raw === undefined || (isList && raw.length === 0 && (p.name === '@' || p.name === '*' || (p.index !== null)))
+    const isNull = isUnset || raw === '' || (isList && (raw.length === 0 || (raw.length === 1 && raw[0] === '')))
+
+    if (op && (op.kind === 'default' || op.kind === 'assign' || op.kind === 'error' || op.kind === 'alternative')) {
+      const missing = op.colon ? isNull : isUnset
+      if (op.kind === 'alternative') {
+        if (missing) return []
+        return op.word ? this.expandOpWord(op.word, proc, quoted) : []
+      }
+      if (missing) {
+        if (op.kind === 'default') return op.word ? this.expandOpWord(op.word, proc, quoted) : [{ text: '', quoted, split: false }]
+        if (op.kind === 'assign') {
+          const v = op.word ? await this.expandString(op.word, proc) : ''
+          this.host.assign(proc, p.name, v)
+          return [{ text: v, quoted, split: !quoted }]
+        }
+        const msg = op.word ? await this.expandString(op.word, proc) : (op.colon ? 'parameter null or not set' : 'parameter not set')
+        throw new FatalError(`${p.name}: ${msg}`, 127)
+      }
+      // present: fall through to the plain value
+    } else if (raw === undefined && st.options.nounset && !(p.name === '@' || p.name === '*') && !p.prefixNames && !(p.index && isAllIndex(p.index))) {
+      throw new FatalError(`${p.index ? `${p.name}[${literalIndex(p.index) ?? '…'}]` : p.name}: unbound variable`, 127)
+    }
+
+    let values: string[] = isList ? raw : raw === undefined ? [] : [raw]
+    const scalarUnset = !isList && raw === undefined
+
+    if (op) {
+      switch (op.kind) {
+        case 'removePrefix':
+        case 'removeSuffix': {
+          const pat = await this.expandPattern(op.pattern, proc)
+          values = values.map((v) => (op.kind === 'removePrefix' ? removePrefix(v, pat, op.longest) : removeSuffix(v, pat, op.longest)))
+          break
+        }
+        case 'replace': {
+          const pat = await this.expandPattern(op.pattern, proc)
+          const rep = op.replacement ? await this.replacement(op.replacement, proc) : ''
+          values = values.map((v) => replacePattern(v, pat, rep, op.mode))
+          break
+        }
+        case 'case': {
+          const pat = op.pattern ? await this.expandPattern(op.pattern, proc) : null
+          const conv = (ch: string): string => (pat === null || matchPattern(ch, pat) ? (op.upper ? ch.toUpperCase() : ch.toLowerCase()) : ch)
+          values = values.map((v) => {
+            if (op.all) return [...v].map(conv).join('')
+            return v === '' ? v : conv(v[0]) + v.slice(1)
+          })
+          break
+        }
+        case 'substring': {
+          const off = Number(await this.arithSafe(op.offset, proc))
+          const len = op.length === null ? null : Number(await this.arithSafe(op.length, proc))
+          if (isList) {
+            // positional slicing includes $0 at offset 0
+            let list = values
+            if (p.name === '@' || p.name === '*') list = [st.arg0, ...values]
+            let start = off < 0 ? list.length + off : off
+            if (p.name !== '@' && p.name !== '*' && off >= 0) start = off
+            if (start < 0) {
+              values = []
+              break
+            }
+            const end = len === null ? list.length : len < 0 ? list.length + len : start + len
+            values = list.slice(start, Math.max(start, end))
+            if ((p.name === '@' || p.name === '*') && off === 0 && false) values = list
+          } else {
+            values = values.map((v) => {
+              const chars = [...v]
+              let start = off < 0 ? chars.length + off : off
+              if (start < 0) return ''
+              if (start > chars.length) start = chars.length
+              let end = len === null ? chars.length : len < 0 ? chars.length + len : start + len
+              if (len !== null && len < 0 && end < start) throw new FatalError(`${len}: substring expression < 0`)
+              end = Math.min(end, chars.length)
+              return chars.slice(start, end).join('')
+            })
+          }
+          break
+        }
+        case 'transform': {
+          values = values.map((v) => transform(v, op.operator, p.name, st.lookup(p.name)))
+          break
+        }
+        default:
+          break
+      }
+    }
+
+    if (scalarUnset && values.length === 0) return []
+    if (isList) {
+      if (quoted && !star) {
+        const out: Piece[] = []
+        values.forEach((v, i) => {
+          if (i > 0) out.push(BRK)
+          out.push({ text: v, quoted: true, split: false })
+        })
+        return out
+      }
+      if (quoted && star) return [{ text: values.join(this.ifsFirst(proc)), quoted: true, split: false }]
+      // unquoted: each element split separately
+      const out: Piece[] = []
+      values.forEach((v, i) => {
+        if (i > 0) out.push(BRK)
+        out.push({ text: v, quoted: false, split: true })
+      })
+      return out
+    }
+    return [{ text: values[0] ?? '', quoted, split: !quoted }]
+  }
+
+  private async arithSafe(e: A.ArithExpr, proc: Proc): Promise<bigint> {
+    try {
+      return await this.host.arith(e, proc)
+    } catch (err) {
+      if (err instanceof ArithError) throw new DiscardError(err.message)
+      throw err
+    }
+  }
+
+  private async expandOpWord(word: A.Word, proc: Proc, quoted: boolean): Promise<Piece[]> {
+    const pieces = await this.expandParts(word.parts, proc, quoted, !quoted)
+    if (quoted) return pieces
+    // unquoted ${v:-a  b}: the operand's unquoted text is subject to word splitting
+    return pieces.map((p) => (isBrk(p) || p.quoted ? p : { ...p, split: true }))
+  }
+
+  // -------------------------------------------------------------------------
+  // Field splitting and globbing
+  // -------------------------------------------------------------------------
+
+  /** Split pieces into fields; each field keeps its value and its glob pattern. */
+  private split(pieces: Piece[], proc: Proc): { value: string; pattern: string; globbable: boolean }[] {
+    const ifs = this.ifs(proc)
+    const ws = (c: string): boolean => (c === ' ' || c === '\t' || c === '\n') && ifs.includes(c)
+    const fields: { value: string; pattern: string; globbable: boolean }[] = []
+    let value = ''
+    let pattern = ''
+    let globbable = false
+    let started = false
+    let afterWs = false
+    const push = (): void => {
+      fields.push({ value, pattern, globbable })
+      value = ''
+      pattern = ''
+      globbable = false
+      started = false
+    }
+    for (const p of pieces) {
+      if (isBrk(p)) {
+        push()
+        afterWs = false
+        continue
+      }
+      if (!p.split || ifs === '') {
+        if (p.quoted) {
+          value += p.text
+          pattern += quotePattern(p.text)
+          started = true
+        } else {
+          value += p.text
+          pattern += p.text
+          if (hasGlobChars(p.text)) globbable = true
+          if (p.text !== '') started = true
+        }
+        if (p.text !== '' || p.quoted) afterWs = false
+        continue
+      }
+      for (const ch of p.text) {
+        if (!ifs.includes(ch)) {
+          value += ch
+          pattern += ch === '\\' ? '\\\\' : ch
+          if (ch === '*' || ch === '?' || ch === '[') globbable = true
+          started = true
+          afterWs = false
+          continue
+        }
+        if (ws(ch)) {
+          if (started) {
+            push()
+            afterWs = true
+          }
+        } else if (started) {
+          push()
+          afterWs = false
+        } else if (afterWs) {
+          afterWs = false
+        } else {
+          push()
+        }
+      }
+    }
+    if (started) push()
+    return fields
+  }
+
+  private glob(field: { value: string; pattern: string; globbable: boolean }, proc: Proc, opts: FieldOptions): string[] {
+    const st = proc.state
+    if (!field.globbable || opts.noGlob || st.options.noglob || !hasGlobChars(field.pattern)) return [field.value]
+    const matches = globPaths(field.pattern, {
+      cwd: st.cwd,
+      dotglob: st.shopts.has('dotglob'),
+      globstar: st.shopts.has('globstar'),
+      nocase: st.shopts.has('nocaseglob'),
+    })
+    if (matches.length > 0) return matches
+    if (st.shopts.has('failglob')) throw new CommandError(`no match: ${field.value}`)
+    if (st.shopts.has('nullglob')) return []
+    return [unescapePattern(field.pattern) === field.value ? field.value : field.value]
+  }
+}
+
+function isAtExpansion(p: A.ParamExp): boolean {
+  if (p.length) return false
+  if ((p.name === '@') && !p.index) return p.op === null || p.op.kind !== 'default'
+  return p.index !== null && literalIndex(p.index) === '@'
+}
+
+function literalIndex(w: A.Word): string | null {
+  if (w.parts.length === 1 && w.parts[0].type === 'Lit') return w.parts[0].value
+  return null
+}
+
+function isAllIndex(w: A.Word): boolean {
+  const l = literalIndex(w)
+  return l === '@' || l === '*'
+}
+
+/** Elements of a variable in index order. */
+export function varElements(v: Variable | undefined): string[] {
+  if (!v || v.value === null) return []
+  if (v.value.kind === 'string') return [v.value.value]
+  if (v.value.kind === 'indexed') return [...v.value.values.entries()].sort((a, b) => a[0] - b[0]).map((e) => e[1])
+  return [...v.value.values.values()]
+}
+
+/** Subscript text → an arithmetic expression node (parsed lazily by the host). */
+function parseIndexExpr(text: string): A.ArithExpr {
+  return { type: 'ArithWord', id: 0, span: { start: 0, end: 0 }, word: { type: 'Word', id: 0, span: { start: 0, end: 0 }, parts: [{ type: 'SglQuoted', value: text, ansi: false, id: 0, span: { start: 0, end: 0 } }] } }
+}
+
+export function shellQuote(s: string): string {
+  if (s === '') return "''"
+  if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(s)) return s
+  if (/[\x00-\x1f\x7f]/.test(s)) {
+    return "$'" + s.replace(/[\\']/g, (c) => '\\' + c).replace(/[\x00-\x1f\x7f]/g, (c) => {
+      const map: Record<string, string> = { '\n': '\\n', '\t': '\\t', '\r': '\\r', '\x1b': '\\E' }
+      return map[c] ?? '\\' + c.charCodeAt(0).toString(8).padStart(3, '0')
+    }) + "'"
+  }
+  return "'" + s.replace(/'/g, "'\\''") + "'"
+}
+
+function transform(v: string, op: string, name: string, variable: Variable | undefined): string {
+  switch (op) {
+    case 'Q': return shellQuote(v)
+    case 'U': return v.toUpperCase()
+    case 'u': return v === '' ? v : v[0].toUpperCase() + v.slice(1)
+    case 'L': return v.toLowerCase()
+    case 'E': return v.replace(/\\(n|t|r|e|E|\\|'|"|a|b|f|v)/g, (_, c: string) => ({ n: '\n', t: '\t', r: '\r', e: '\x1b', E: '\x1b', '\\': '\\', "'": "'", '"': '"', a: '\x07', b: '\b', f: '\f', v: '\v' } as Record<string, string>)[c])
+    case 'A': return `${name}=${shellQuote(v)}`
+    case 'a': {
+      if (!variable) return ''
+      let s = ''
+      if (variable.value?.kind === 'indexed' || variable.declaredKind === 'indexed') s += 'a'
+      if (variable.value?.kind === 'assoc' || variable.declaredKind === 'assoc') s += 'A'
+      if (variable.integer) s += 'i'
+      if (variable.lower) s += 'l'
+      if (variable.readonly) s += 'r'
+      if (variable.upper) s += 'u'
+      if (variable.exported) s += 'x'
+      return s
+    }
+    case 'P': return v
+    case 'K': return shellQuote(v)
+    default: throw new FatalError(`${op}: bad substitution`)
+  }
+}