@taliesinb/mash 0.0.0-stage → 0.1.0

package/dist/src/vm/expand.js

@@ -0,0 +1,744 @@
+/**
+ * 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 { ArithError } from "./arith.js";
+import { CommandError, DiscardError, FatalError } from "./proc.js";
+import { globPaths, hasGlobChars, matchPattern, quotePattern, removePrefix, removeSuffix, replacePattern, unescapePattern } from "./pattern.js";
+import { dashFlags } from "./state.js";
+const BRK = { brk: true };
+function isBrk(p) {
+    return 'brk' in p;
+}
+function toAtoms(parts) {
+    const atoms = [];
+    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, like) {
+    const parts = [];
+    let lit = '';
+    const flush = () => {
+        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) {
+    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 = [];
+        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 = [];
+        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) {
+    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 = [];
+        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;
+        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.ch).join(''));
+            if (!seq)
+                continue;
+            alternatives = seq.map((s) => [...s].map((ch) => ({ ch })));
+        }
+        const out = [];
+        for (const alt of alternatives)
+            for (const suf of suffixes)
+                out.push([...prefix, ...alt, ...suf]);
+        return out;
+    }
+    return [atoms];
+}
+export function braceExpand(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) }));
+}
+export class Expander {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    /** Expand words into fields (full expansion, for argv and `for` lists). */
+    async expandFields(words, proc, opts = {}) {
+        const out = [];
+        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.
+     */
+    async replacement(word, proc) {
+        if (!proc.state.shopts.has('patsub_replacement'))
+            return this.expandString(word, proc);
+        const pieces = [];
+        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, proc, opts = {}) {
+        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, proc) {
+        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, proc) {
+        const pieces = await this.expandParts(word.parts, proc, true, false);
+        return this.joinPieces(pieces);
+    }
+    joinPieces(pieces) {
+        let s = '';
+        for (const p of pieces)
+            s += isBrk(p) ? ' ' : p.text;
+        return s;
+    }
+    ifs(proc) {
+        const v = proc.state.getString('IFS');
+        return v === undefined ? ' \t\n' : v;
+    }
+    ifsFirst(proc) {
+        const v = proc.state.getString('IFS');
+        return v === undefined ? ' ' : v.slice(0, 1);
+    }
+    async expandParts(parts, proc, quoted, tilde, tildeAssign = false) {
+        const out = [];
+        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;
+                    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;
+    }
+    tilde(text, proc, atStart, assign) {
+        if (!text.includes('~'))
+            return null;
+        const home = proc.state.getString('HOME') ?? os.homedir();
+        const expandOne = (prefix) => {
+            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 = [];
+        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, proc) {
+        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;
+            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 };
+    }
+    async simpleParamValue(name, _index, proc) {
+        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);
+    }
+    arrayValues(name, proc) {
+        if (name === 'FUNCNAME')
+            return proc.state.funcStack.length > 0 ? [...proc.state.funcStack, 'main'] : [];
+        const v = proc.state.lookup(name);
+        return varElements(v);
+    }
+    arrayKeys(name, proc) {
+        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()];
+    }
+    elementValue(name, key, proc) {
+        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);
+    }
+    async expandParam(p, proc, quoted) {
+        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 = 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) => (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 = [];
+                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 = [];
+            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 }];
+    }
+    async arithSafe(e, proc) {
+        try {
+            return await this.host.arith(e, proc);
+        }
+        catch (err) {
+            if (err instanceof ArithError)
+                throw new DiscardError(err.message);
+            throw err;
+        }
+    }
+    async expandOpWord(word, proc, quoted) {
+        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. */
+    split(pieces, proc) {
+        const ifs = this.ifs(proc);
+        const ws = (c) => (c === ' ' || c === '\t' || c === '\n') && ifs.includes(c);
+        const fields = [];
+        let value = '';
+        let pattern = '';
+        let globbable = false;
+        let started = false;
+        let afterWs = false;
+        const push = () => {
+            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;
+    }
+    glob(field, proc, opts) {
+        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) {
+    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) {
+    if (w.parts.length === 1 && w.parts[0].type === 'Lit')
+        return w.parts[0].value;
+    return null;
+}
+function isAllIndex(w) {
+    const l = literalIndex(w);
+    return l === '@' || l === '*';
+}
+/** Elements of a variable in index order. */
+export function varElements(v) {
+    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) {
+    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) {
+    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 = { '\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, op, name, variable) {
+    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) => ({ n: '\n', t: '\t', r: '\r', e: '\x1b', E: '\x1b', '\\': '\\', "'": "'", '"': '"', a: '\x07', b: '\b', f: '\f', v: '\v' }[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`);
+    }
+}
+//# sourceMappingURL=expand.js.map