@ykdz/template 0.0.42 → 0.1.0-experimental.0

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

@@ -1,17 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

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

package/node_modules/unbash/dist/printer.js

@@ -1,536 +0,0 @@
-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;
-}