@ykdz/template 0.0.35 → 0.0.37

package/node_modules/unbash/dist/parts.d.ts

@@ -0,0 +1,17 @@
+import type { Word, WordPart } from "./internal-types.ts";
+/**
+ * Compute the structural parts of a word by re-scanning the source.
+ * This is the "cold path" — only called when consumers actually need parts.
+ *
+ * Returns undefined for simple words (no quotes, expansions, or special structure).
+ */
+export declare function computeWordParts(source: string, word: Pick<Word, "pos" | "end">, depth?: number): WordPart[] | undefined;
+/** Compute structural parts for a word-like span that may contain shell operators or whitespace. */
+export declare function computeEmbeddedWordParts(source: string, word: Pick<Word, "pos" | "end">, depth?: number): WordPart[] | undefined;
+export declare function computeArrayElementParts(source: string, word: Word, depth?: number): WordPart[] | undefined;
+/**
+ * Compute parts for an unquoted heredoc body.
+ * Heredoc bodies use different scanning rules than shell words: newlines are
+ * literal and single/double quotes have no special meaning.
+ */
+export declare function computeHereDocBodyParts(source: string, word: Pick<Word, "pos" | "end">, depth?: number): WordPart[] | undefined;

package/node_modules/unbash/dist/parts.js

@@ -0,0 +1,82 @@
+import { hasEmbeddedWordStructure, Lexer, MAX_SYNTAX_NESTING } from "./lexer.js";
+import { parseRegion } from "./parser.js";
+/**
+ * Compute the structural parts of a word by re-scanning the source.
+ * This is the "cold path" — only called when consumers actually need parts.
+ *
+ * Returns undefined for simple words (no quotes, expansions, or special structure).
+ */
+export function computeWordParts(source, word, depth = 0) {
+    // Bound the re-lex to the word's span. A word inside a substitution script carries the
+    // whole original as its source, so an unbounded scan would overrun the word into an
+    // adjacent delimiter (e.g. a backtick or `)` immediately after it). For top-level words
+    // word.end is the natural boundary, so the bound is a no-op.
+    const lexer = new Lexer(source, word.pos, word.end);
+    lexer._nestingDepth = depth;
+    const parts = lexer.buildWordParts(word.pos);
+    if (!parts)
+        return undefined;
+    resolveCollected(lexer);
+    return parts;
+}
+/** Compute structural parts for a word-like span that may contain shell operators or whitespace. */
+export function computeEmbeddedWordParts(source, word, depth = 0) {
+    if (!hasEmbeddedWordStructure(source, word.pos, word.end))
+        return undefined;
+    const lexer = new Lexer(source, word.pos, word.end);
+    lexer._nestingDepth = depth;
+    const parts = lexer.buildEmbeddedWordParts(word.pos);
+    if (!parts)
+        return undefined;
+    resolveCollected(lexer);
+    return parts;
+}
+export function computeArrayElementParts(source, word, depth = 0) {
+    const lexer = new Lexer(source, word.pos, word.end);
+    lexer._nestingDepth = depth;
+    const parts = lexer.buildArrayElementParts(word.pos);
+    if (!parts)
+        return undefined;
+    resolveCollected(lexer);
+    return parts;
+}
+/**
+ * Compute parts for an unquoted heredoc body.
+ * Heredoc bodies use different scanning rules than shell words: newlines are
+ * literal and single/double quotes have no special meaning.
+ */
+export function computeHereDocBodyParts(source, word, depth = 0) {
+    const lexer = new Lexer(source, word.pos, word.end);
+    lexer._nestingDepth = depth;
+    const parts = lexer.buildHereDocParts(word.pos, word.end);
+    if (!parts)
+        return undefined;
+    resolveCollected(lexer);
+    return parts;
+}
+/**
+ * Resolve each collected substitution's inner script. The script is parsed *in place*
+ * against the original source over the window [innerStart, innerStart + inner.length),
+ * so every node is born with absolute pos/end — no slicing, no re-basing — and nested
+ * substitutions compose because deeper words re-lex the original on demand.
+ *
+ * Escaped backticks rebuild `inner` with the escapes removed, so it is no longer a verbatim
+ * substring of the source and carries no innerStart; those parse the rebuilt slice and stay
+ * relative to it — the single exception to absolute offsets. Only these scripts carry a
+ * `source` property holding the decoded string their positions index.
+ */
+function resolveCollected(lexer) {
+    const source = lexer.getSource();
+    for (const [part, innerDepth, inner, innerStart, parenBoundary] of lexer.getCollectedExpansions()) {
+        const depth = innerDepth + 1;
+        if (depth > MAX_SYNTAX_NESTING + 1)
+            continue;
+        if (innerStart !== undefined) {
+            part.script = parseRegion(source, innerStart, innerStart + inner.length, depth, parenBoundary);
+        }
+        else {
+            part.script = parseRegion(inner, 0, inner.length, depth);
+            part.script.source = inner;
+        }
+    }
+}

package/node_modules/unbash/dist/printer.d.ts

@@ -0,0 +1,2 @@
+import type { Script } from "./types.ts";
+export declare function print(script: Script): string;

package/node_modules/unbash/dist/printer.js

@@ -0,0 +1,536 @@
+import { requiresFunctionKeyword } from "./lexer.js";
+export function print(script) {
+    // Saved and restored, not cleared: a lazy getter can re-enter print(), and clearing would
+    // drop the outer call's pending heredocs.
+    const outerQueued = heredocQueue.length;
+    try {
+        let out = "";
+        if (script.shebang)
+            out += script.shebang + "\n\n";
+        out += stmts(script.commands, 0);
+        return out;
+    }
+    finally {
+        heredocQueue.length = outerQueued;
+    }
+}
+function isFunc(s) {
+    return s.command.type === "Function";
+}
+function stmts(list, indent) {
+    let out = "";
+    for (let i = 0; i < list.length; i++) {
+        if (i > 0)
+            out += isFunc(list[i - 1]) || isFunc(list[i]) ? "\n\n" : "\n";
+        out += stmt(list[i], indent);
+    }
+    return out;
+}
+function stmt(s, indent) {
+    const pad = "  ".repeat(indent);
+    const queued = heredocQueue.length;
+    let out = pad + printNode(s.command, indent);
+    if (s.background)
+        out += " &";
+    return heredocQueue.length === queued ? out : flushHeredocs(out, queued);
+}
+// Heredoc marks identify the line after which to emit queued bodies. Prefix redirects defer
+// their marks past multiline command words, so each body follows the complete header.
+const HEREDOC_MARK = "\u0000";
+const heredocQueue = [];
+function flushHeredocs(text, queued) {
+    if (heredocQueue.length === queued)
+        return text;
+    const pending = heredocQueue.splice(queued);
+    if (pending.length === 1 && text.endsWith(HEREDOC_MARK)) {
+        return text.slice(0, -1) + "\n" + heredocBody(pending[0]);
+    }
+    let out = "";
+    let copied = 0;
+    let next = 0;
+    let mark = text.indexOf(HEREDOC_MARK);
+    while (mark !== -1) {
+        let lineEnd = text.indexOf("\n", mark);
+        if (lineEnd === -1)
+            lineEnd = text.length;
+        let marks = 0;
+        while (mark !== -1 && mark < lineEnd) {
+            out += text.slice(copied, mark);
+            copied = mark + 1;
+            marks++;
+            mark = text.indexOf(HEREDOC_MARK, copied);
+        }
+        out += text.slice(copied, lineEnd);
+        copied = lineEnd;
+        for (; marks > 0 && next < pending.length; marks--, next++) {
+            out += "\n" + heredocBody(pending[next]);
+        }
+    }
+    return out + text.slice(copied);
+}
+function heredocBody(r) {
+    const content = r.body.text;
+    const delimiter = r.delimiter?.value ?? "";
+    const hasNewline = content.endsWith("\n");
+    let separator = content.length > 0 && !hasNewline ? "\n" : "";
+    if (!r.delimiter?.quoted) {
+        const end = content.length - (hasNewline ? 1 : 0);
+        let backslashes = end;
+        while (backslashes > 0 && content.charCodeAt(backslashes - 1) === 92)
+            backslashes--;
+        if ((end - backslashes) % 2 === 1)
+            separator += "\n";
+    }
+    return content + separator + delimiter + (delimiter ? "" : "\n");
+}
+function printNode(n, indent) {
+    switch (n.type) {
+        case "Command":
+            return cmd(n);
+        case "Redirected":
+            return appendRedirects(printNode(n.command, indent), n.redirects);
+        case "Pipeline":
+            return pipe(n, indent);
+        case "Time":
+        case "Negation":
+            return pipelinePrefix(n, indent);
+        case "AndOr":
+            return andOr(n, indent);
+        case "If":
+            return ifNode(n, indent, false);
+        case "For":
+            return forNode(n, indent);
+        case "While":
+            return whileNode(n, indent);
+        case "Case":
+            return caseNode(n, indent);
+        case "Function":
+            return funcNode(n, indent);
+        case "Subshell":
+            return subshell(n, indent);
+        case "BraceGroup":
+            return braceGroup(n, indent);
+        case "TestCommand":
+            return testCmd(n);
+        case "ArithmeticCommand":
+            return arithCmd(n);
+        case "Select":
+            return selectNode(n, indent);
+        case "ArithmeticFor":
+            return arithFor(n, indent);
+        case "Coproc":
+            return coprocNode(n, indent);
+    }
+}
+function wd(w) {
+    return w.text;
+}
+function assign(a) {
+    let out = a.name;
+    if (a.index)
+        out += "[" + a.index.text + "]";
+    out += a.append ? "+=" : "=";
+    const value = a.value;
+    if (value.type === "ArrayValue") {
+        out += "(" + value.elements.map((w) => wd(w)).join(" ") + ")";
+    }
+    else {
+        out += wd(value);
+    }
+    return out;
+}
+function cmd(c) {
+    let out = "";
+    let separator = "";
+    let heredocMarks = "";
+    for (const item of c.prefix) {
+        const text = item.type === "Assignment" ? assign(item) : redir(item);
+        if (text.endsWith(HEREDOC_MARK)) {
+            out += separator + text.slice(0, -1);
+            heredocMarks += HEREDOC_MARK;
+        }
+        else {
+            out += separator + text;
+        }
+        separator = " ";
+    }
+    if (c.name) {
+        out += separator + wd(c.name);
+        separator = " ";
+    }
+    for (const item of c.suffix) {
+        const text = item.type === "Word" ? wd(item) : item.type === "Assignment" ? assign(item) : redir(item);
+        if (text.endsWith(HEREDOC_MARK)) {
+            out += separator + text.slice(0, -1);
+            heredocMarks += HEREDOC_MARK;
+        }
+        else {
+            out += separator + text;
+        }
+        separator = " ";
+    }
+    return out + heredocMarks;
+}
+function appendRedirects(command, redirects) {
+    let out = command;
+    let marks = "";
+    for (const redirect of redirects) {
+        const text = redir(redirect);
+        if (text.endsWith(HEREDOC_MARK)) {
+            out += " " + text.slice(0, -1);
+            marks += HEREDOC_MARK;
+        }
+        else {
+            out += " " + text;
+        }
+    }
+    return out + marks;
+}
+function pipe(p, indent) {
+    let out = "";
+    for (let i = 0; i < p.commands.length; i++) {
+        if (i > 0)
+            out += " " + p.operators[i - 1] + " ";
+        out += printNode(p.commands[i], indent);
+    }
+    return out;
+}
+function pipelinePrefix(prefix, indent) {
+    let out = "";
+    let node = prefix;
+    while (node?.type === "Time" || node?.type === "Negation") {
+        if (node.type === "Time") {
+            out += "time";
+            if (node.posix)
+                out += " -p";
+            if (node.endOfOptions)
+                out += " --";
+        }
+        else
+            out += "!";
+        node = node.command;
+        if (node)
+            out += " ";
+    }
+    return node ? out + printNode(node, indent) : out;
+}
+function andOr(a, indent) {
+    let out = "";
+    for (let i = 0; i < a.commands.length; i++) {
+        if (i > 0)
+            out += " " + a.operators[i - 1] + " ";
+        out += printNode(a.commands[i], indent);
+    }
+    return out;
+}
+function ifNode(n, indent, isElif) {
+    const pad = "  ".repeat(indent);
+    const kw = isElif ? "elif" : "if";
+    let out = kw + " " + inlineClause(n.clause, "then") + "\n";
+    out += stmts(n.then.commands, indent + 1);
+    if (n.else) {
+        out += "\n";
+        if (n.else.type === "If") {
+            out += pad + ifNode(n.else, indent, true);
+        }
+        else {
+            out += pad + "else\n";
+            out += stmts(n.else.commands, indent + 1) + "\n";
+            out += pad + "fi";
+        }
+    }
+    else {
+        out += "\n" + pad + "fi";
+    }
+    return out;
+}
+function forNode(n, indent) {
+    const pad = "  ".repeat(indent);
+    let out = "for " + wd(n.name);
+    if (n.wordlist) {
+        out += " in";
+        for (const w of n.wordlist)
+            out += " " + wd(w);
+    }
+    out += "; do\n";
+    out += stmts(n.body.commands, indent + 1) + "\n";
+    out += pad + "done";
+    return out;
+}
+function whileNode(n, indent) {
+    const pad = "  ".repeat(indent);
+    let out = n.kind + " " + inlineClause(n.clause, "do") + "\n";
+    out += stmts(n.body.commands, indent + 1) + "\n";
+    out += pad + "done";
+    return out;
+}
+function caseNode(n, indent) {
+    const pad = "  ".repeat(indent);
+    const iPad = "  ".repeat(indent + 1);
+    const bPad = "  ".repeat(indent + 2);
+    let out = "case " + wd(n.word) + " in\n";
+    for (const item of n.items) {
+        // A leading `esac` closes the case unless the optional `(` precedes the pattern list.
+        const open = item.pattern.length > 0 && wd(item.pattern[0]) === "esac" ? "(" : "";
+        out += iPad + open + item.pattern.map((p) => wd(p)).join(" | ") + ")\n";
+        if (item.body.commands.length > 0) {
+            out += stmts(item.body.commands, indent + 2) + "\n";
+        }
+        out += bPad + (item.terminator ?? ";;") + "\n";
+    }
+    out += pad + "esac";
+    return out;
+}
+function funcNode(n, indent) {
+    const pad = "  ".repeat(indent);
+    const name = wd(n.name);
+    const body = n.body.type === "Redirected" ? n.body.command : n.body;
+    let out = (requiresFunctionKeyword(name) ? "function " + name + " {" : name + "() {") + "\n";
+    if (body.type === "BraceGroup") {
+        out += stmts(body.body.commands, indent + 1) + "\n";
+    }
+    else if (body.type === "CompoundList") {
+        out += stmts(body.commands, indent + 1) + "\n";
+    }
+    else {
+        out += "  ".repeat(indent + 1) + printNode(body, indent + 1) + "\n";
+    }
+    out += pad + "}";
+    return n.body.type === "Redirected" ? appendRedirects(out, n.body.redirects) : out;
+}
+function subshell(n, indent) {
+    const pad = "  ".repeat(indent);
+    if (n.body.commands.length <= 1) {
+        const body = inlineList(n.body);
+        return "(" + (body.startsWith("(") ? " " : "") + body + ")";
+    }
+    let out = "(\n";
+    out += stmts(n.body.commands, indent + 1) + "\n";
+    out += pad + ")";
+    return out;
+}
+function braceGroup(n, indent) {
+    const pad = "  ".repeat(indent);
+    let out = "{\n";
+    out += stmts(n.body.commands, indent + 1) + "\n";
+    out += pad + "}";
+    return out;
+}
+function testCmd(n) {
+    return "[[ " + testExpr(n.expression) + " ]]";
+}
+function testExpr(e) {
+    switch (e.type) {
+        case "TestUnary":
+            return e.operand.text === "" ? e.operator : e.operator + " " + wd(e.operand);
+        case "TestBinary":
+            return wd(e.left) + " " + e.operator + " " + wd(e.right);
+        case "TestLogical":
+            return testExpr(e.left) + " " + e.operator + " " + testExpr(e.right);
+        case "TestNot":
+            return "! " + testExpr(e.operand);
+        case "TestGroup":
+            return "( " + testExpr(e.expression) + " )";
+    }
+}
+function arithCmd(n) {
+    if (n.expression)
+        return "(( " + arithExpr(n.expression) + " ))";
+    return "((" + n.body + "))";
+}
+function arithFor(n, indent) {
+    const pad = "  ".repeat(indent);
+    const init = n.initialize ? arithExpr(n.initialize) : "";
+    const test = n.test ? arithExpr(n.test) : "";
+    const update = n.update ? arithExpr(n.update) : "";
+    let out = "for (( " + init + "; " + test + "; " + update + " )); do\n";
+    out += stmts(n.body.commands, indent + 1) + "\n";
+    out += pad + "done";
+    return out;
+}
+function coprocNode(n, indent) {
+    let out = "coproc";
+    if (n.name)
+        out += " " + wd(n.name);
+    if (n.body.type !== "CompoundList")
+        return out + " " + printNode(n.body, indent);
+    // A list body is recovery from a missing or invalid body; the keyword takes the first statement's indent.
+    const pad = "  ".repeat(indent);
+    const body = stmts(n.body.commands, indent).slice(pad.length);
+    return body === "" ? out : out + " " + body;
+}
+function arithExpr(e) {
+    switch (e.type) {
+        case "ArithmeticWord":
+            return e.value;
+        case "ArithmeticGroup":
+            return "(" + arithExpr(e.expression) + ")";
+        case "ArithmeticUnary":
+            if (e.prefix)
+                return (e.operator === "!" ? "! " : e.operator) + arithExpr(e.operand);
+            return arithExpr(e.operand) + e.operator;
+        case "ArithmeticTernary":
+            return arithExpr(e.test) + " ? " + arithExpr(e.consequent) + " : " + arithExpr(e.alternate);
+        case "ArithmeticBinary": {
+            const prec = arithPrec(e.operator);
+            const ra = arithRightAssoc(e.operator);
+            let left = arithExpr(e.left);
+            let right = arithExpr(e.right);
+            if (arithNeedsParens(e.left, prec, ra ? false : true))
+                left = "(" + left + ")";
+            if (arithNeedsParens(e.right, prec, ra ? true : false))
+                right = "(" + right + ")";
+            return left + " " + e.operator + " " + right;
+        }
+        case "ArithmeticCommandExpansion":
+            return e.text; // preserve original text for roundtrip
+    }
+}
+function arithPrec(op) {
+    switch (op) {
+        case ",":
+            return 1;
+        case "=":
+        case "+=":
+        case "-=":
+        case "*=":
+        case "/=":
+        case "%=":
+        case "<<=":
+        case ">>=":
+        case "&=":
+        case "|=":
+        case "^=":
+            return 2;
+        case "||":
+            return 4;
+        case "&&":
+            return 5;
+        case "|":
+            return 6;
+        case "^":
+            return 7;
+        case "&":
+            return 8;
+        case "==":
+        case "!=":
+            return 9;
+        case "<":
+        case "<=":
+        case ">":
+        case ">=":
+            return 10;
+        case "<<":
+        case ">>":
+            return 11;
+        case "+":
+        case "-":
+            return 12;
+        case "*":
+        case "/":
+        case "%":
+            return 13;
+        case "**":
+            return 14;
+        default:
+            return 0;
+    }
+}
+function arithRightAssoc(op) {
+    switch (op) {
+        case "=":
+        case "+=":
+        case "-=":
+        case "*=":
+        case "/=":
+        case "%=":
+        case "<<=":
+        case ">>=":
+        case "&=":
+        case "|=":
+        case "^=":
+        case "**":
+            return true;
+        default:
+            return false;
+    }
+}
+function arithNeedsParens(child, parentPrec, isSafe) {
+    if (child.type === "ArithmeticBinary") {
+        const cp = arithPrec(child.operator);
+        return cp < parentPrec || (cp === parentPrec && !isSafe);
+    }
+    if (child.type === "ArithmeticTernary")
+        return 3 < parentPrec;
+    return false;
+}
+function selectNode(n, indent) {
+    const pad = "  ".repeat(indent);
+    let out = "select " + wd(n.name);
+    if (n.wordlist) {
+        out += " in";
+        for (const w of n.wordlist)
+            out += " " + wd(w);
+    }
+    out += "; do\n";
+    out += stmts(n.body.commands, indent + 1) + "\n";
+    out += pad + "done";
+    return out;
+}
+// Partless targets with tokenization-breaking characters must be quoted from
+// their value. Glob and expansion characters stay verbatim — quoting them would
+// change meaning.
+const UNSAFE_TARGET = /[\s"'\\|&;<>()]/;
+function singleQuote(value) {
+    return "'" + value.split("'").join("'\\''") + "'";
+}
+function redirectTarget(r) {
+    const w = r.target;
+    if (!UNSAFE_TARGET.test(w.text))
+        return w.text;
+    if (w.parts)
+        return w.text;
+    return singleQuote(w.value);
+}
+function redir(r) {
+    let out = "";
+    if (r.descriptor?.type === "FileDescriptor")
+        out += r.descriptor.value;
+    else if (r.descriptor)
+        out += "{" + r.descriptor.name + "}";
+    out += r.operator;
+    if (r.type === "HereDoc") {
+        if (r.delimiter) {
+            out += " " + (r.delimiter.quoted ? singleQuote(r.delimiter.value) : r.delimiter.text);
+            heredocQueue.push(r);
+            out += HEREDOC_MARK;
+        }
+        return out;
+    }
+    if (r.target) {
+        if (r.operator !== "<&" && r.operator !== ">&")
+            out += " ";
+        out += redirectTarget(r);
+    }
+    return out;
+}
+function inlineList(cl) {
+    let out = "";
+    for (let i = 0; i < cl.commands.length; i++) {
+        if (i > 0)
+            out += cl.commands[i - 1].background ? " " : "; ";
+        out += inlineStmt(cl.commands[i]);
+    }
+    return out;
+}
+// A background statement is already terminated by its `&`; `&;` is a syntax error.
+function inlineClause(cl, keyword) {
+    const last = cl.commands[cl.commands.length - 1];
+    return inlineList(cl) + (last?.background ? " " : "; ") + keyword;
+}
+function inlineStmt(s) {
+    let out = printNode(s.command, 0);
+    if (s.background)
+        out += " &";
+    return out;
+}