@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.20

package/dist/src/vendor/unbash/parts.js

@@ -0,0 +1,57 @@
+import { hasEmbeddedWordStructure, Lexer } from "./lexer.js";
+import { createSubstitutionContext } from "./substitution-context.js";
+import { hasGlobCharacters, parseGlobParts } from "./glob.js";
+export const computeBareWordParts = (_source, word) => hasGlobCharacters(word.text) ? parseGlobParts(word.text, 0, word.text.length, undefined, word.pos) : undefined;
+export function wordPartsResolver(context) {
+    return (context.wordParts ?? (context.wordParts = (source, word, depth) => computeWordParts(source, word, depth, context)));
+}
+export function embeddedPartsResolver(context) {
+    return (context.embeddedParts ??
+        (context.embeddedParts = (source, word, depth) => computeEmbeddedWordParts(source, word, depth, context)));
+}
+export function arrayPartsResolver(context) {
+    return (context.arrayParts ??
+        (context.arrayParts = (source, word, depth) => computeArrayElementParts(source, word, depth, context)));
+}
+/**
+ * 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, context = createSubstitutionContext()) {
+    // 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, false, context);
+    lexer._nestingDepth = depth;
+    const parts = lexer.buildWordParts(word.pos);
+    return parts ?? undefined;
+}
+/** Compute structural parts for a word-like span that may contain shell operators or whitespace. */
+export function computeEmbeddedWordParts(source, word, depth = 0, context, arithmetic = false) {
+    if (!hasEmbeddedWordStructure(source, word.pos, word.end))
+        return undefined;
+    const lexer = new Lexer(source, word.pos, word.end, false, context);
+    lexer._nestingDepth = depth;
+    const parts = lexer.buildEmbeddedWordParts(word.pos, arithmetic);
+    return parts ?? undefined;
+}
+export function computeArrayElementParts(source, word, depth = 0, context) {
+    const lexer = new Lexer(source, word.pos, word.end, false, context);
+    lexer._nestingDepth = depth;
+    const parts = lexer.buildArrayElementParts(word.pos);
+    return parts ?? 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 function computeHereDocBodyParts(source, word, depth = 0, context) {
+    const lexer = new Lexer(source, word.pos, word.end, false, context);
+    lexer._nestingDepth = depth;
+    const parts = lexer.buildHereDocParts(word.pos, word.end);
+    return parts ?? undefined;
+}

package/dist/src/vendor/unbash/substitution-context.js

@@ -0,0 +1,8 @@
+// A nested script shares its parent's boundary cache, allocated on first use.
+export function createSubstitutionContext(parent) {
+    const boundaries = parent === undefined ? undefined : substitutionBoundaries(parent);
+    return { boundaries, wordParts: undefined, embeddedParts: undefined, arrayParts: undefined };
+}
+export function substitutionBoundaries(context) {
+    return context.boundaries ?? (context.boundaries = new Map());
+}

package/dist/src/vendor/unbash/traversal.js

@@ -0,0 +1,212 @@
+export function forEachChild(node, callback) {
+    switch (node.type) {
+        case "Script":
+        case "CompoundList":
+        case "AndOr":
+            for (const command of node.commands)
+                callback(command);
+            return;
+        case "Statement":
+            callback(node.command);
+            return;
+        case "Command":
+            for (const child of node.prefix)
+                callback(child);
+            if (node.name)
+                callback(node.name);
+            for (const child of node.suffix)
+                callback(child);
+            return;
+        case "Pipeline":
+            for (const prefix of node.prefixes)
+                callback(prefix);
+            for (const command of node.commands)
+                callback(command);
+            return;
+        case "Redirected":
+            callback(node.command);
+            for (const redirect of node.redirects)
+                callback(redirect);
+            return;
+        case "If":
+            callback(node.clause);
+            callback(node.then);
+            for (const branch of node.elif)
+                callback(branch);
+            if (node.else)
+                callback(node.else);
+            return;
+        case "Elif":
+            callback(node.clause);
+            callback(node.then);
+            return;
+        case "For":
+        case "Select":
+            callback(node.name);
+            if (node.wordlist)
+                for (const word of node.wordlist)
+                    callback(word);
+            callback(node.body);
+            return;
+        case "While":
+            callback(node.clause);
+            callback(node.body);
+            return;
+        case "Function":
+        case "Coproc":
+            if (node.name)
+                callback(node.name);
+            callback(node.body);
+            return;
+        case "Subshell":
+        case "BraceGroup":
+            callback(node.body);
+            return;
+        case "Case":
+            callback(node.word);
+            for (const item of node.items)
+                callback(item);
+            return;
+        case "CaseItem":
+            for (const pattern of node.pattern)
+                callback(pattern);
+            callback(node.body);
+            return;
+        case "ArithmeticFor": {
+            const initialize = node.initialize;
+            if (initialize)
+                callback(initialize);
+            const test = node.test;
+            if (test)
+                callback(test);
+            const update = node.update;
+            if (update)
+                callback(update);
+            callback(node.body);
+            return;
+        }
+        case "Word":
+        case "Glob":
+        case "ArithmeticWord":
+        case "HereDocBody":
+        case "BraceExpansion":
+        case "ExtendedGlob": {
+            const parts = node.parts;
+            if (parts)
+                for (const part of parts)
+                    callback(part);
+            return;
+        }
+        case "DoubleQuoted":
+        case "LocaleString":
+            for (const part of node.parts)
+                callback(part);
+            return;
+        case "ParameterExpansion":
+            if (node.index)
+                callback(node.index);
+            if (node.operation)
+                callback(node.operation);
+            return;
+        case "Default":
+        case "Remove":
+        case "Transform":
+            callback(node.operand);
+            return;
+        case "CaseModification":
+            if (node.operand)
+                callback(node.operand);
+            return;
+        case "Replace":
+            callback(node.pattern);
+            callback(node.replacement);
+            return;
+        case "Slice":
+            callback(node.offset);
+            if (node.length)
+                callback(node.length);
+            return;
+        case "Assignment": {
+            const index = node.index;
+            if (index)
+                callback(index);
+            callback(node.value);
+            return;
+        }
+        case "ArrayValue":
+            for (const element of node.elements)
+                callback(element);
+            return;
+        case "Redirect":
+        case "HereString":
+            if (node.descriptor)
+                callback(node.descriptor);
+            if (node.target)
+                callback(node.target);
+            return;
+        case "HereDoc":
+            if (node.descriptor)
+                callback(node.descriptor);
+            if (node.delimiter)
+                callback(node.delimiter);
+            callback(node.body);
+            return;
+        case "CommandExpansion":
+        case "ProcessSubstitution":
+        case "ArithmeticCommandExpansion": {
+            const script = node.script;
+            if (script)
+                callback(script);
+            return;
+        }
+        case "ArithmeticExpansion":
+        case "ArithmeticCommand":
+        case "ArithmeticGroup":
+        case "TestCommand":
+        case "TestGroup": {
+            const expression = node.expression;
+            if (expression)
+                callback(expression);
+            return;
+        }
+        case "ArithmeticBinary":
+        case "TestBinary":
+            callback(node.left);
+            callback(node.right);
+            return;
+        case "ArithmeticUnary":
+        case "TestUnary":
+            callback(node.operand);
+            return;
+        case "ArithmeticTernary":
+            callback(node.test);
+            callback(node.consequent);
+            callback(node.alternate);
+            return;
+        case "TestLogical":
+            for (const operand of node.operands)
+                callback(operand);
+            return;
+        case "TestNot":
+            for (const negation of node.negations)
+                callback(negation);
+            callback(node.operand);
+            return;
+        case "Literal":
+        case "SingleQuoted":
+        case "AnsiCQuoted":
+        case "SimpleExpansion":
+        case "Names":
+        case "Unknown":
+        case "FileDescriptor":
+        case "FileDescriptorVariable":
+        case "HereDocDelimiter":
+        case "Time":
+        case "Negation":
+            return;
+        default: {
+            const exhaustive = node;
+            throw new TypeError(`Unexpected syntax node: ${exhaustive}`);
+        }
+    }
+}

package/dist/src/vendor/unbash/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/vendor/unbash/word-value.js

@@ -0,0 +1,61 @@
+function dequoteValue(parts) {
+    let s = "";
+    for (const c of parts)
+        s += c.type === "Literal" ? c.value : c.text;
+    return s;
+}
+export function unescapeBareValue(text) {
+    const first = text.indexOf("\\");
+    if (first === -1)
+        return text;
+    let s = "";
+    let start = 0;
+    for (let i = first; i < text.length; i++) {
+        if (text.charCodeAt(i) !== 92)
+            continue;
+        s += text.slice(start, i);
+        i++;
+        if (i >= text.length) {
+            s += "\\";
+            start = i;
+            break;
+        }
+        if (text.charCodeAt(i) !== 10)
+            s += text[i];
+        start = i + 1;
+    }
+    return s + text.slice(start);
+}
+function continuedExpansionValue(text) {
+    let pos = 1;
+    while (text[pos] === "\\" && text[pos + 1] === "\n")
+        pos += 2;
+    return pos === 1 || text[pos] !== "(" ? text : text[0] + text.slice(pos);
+}
+export function wordPartsValue(parts) {
+    let value = "";
+    for (const part of parts) {
+        switch (part.type) {
+            case "Literal":
+            case "Glob":
+            case "SingleQuoted":
+            case "AnsiCQuoted":
+                value += part.value;
+                break;
+            case "DoubleQuoted":
+            case "LocaleString":
+                value += dequoteValue(part.parts);
+                break;
+            case "CommandExpansion":
+                value += part.text[0] === "$" ? continuedExpansionValue(part.text) : part.text;
+                break;
+            case "ExtendedGlob":
+                value += continuedExpansionValue(part.text);
+                break;
+            default:
+                value += part.text;
+                break;
+        }
+    }
+    return value;
+}

package/dist/src/vendor/unbash/word.js

@@ -0,0 +1,40 @@
+import { unescapeBareValue, wordPartsValue } from "./word-value.js";
+export class WordImpl {
+    type = "Word";
+    text;
+    pos;
+    end;
+    #source;
+    #resolver;
+    #depth;
+    #parts;
+    #value = null;
+    constructor(text, pos, end, source, resolver, depth = 0) {
+        this.text = text;
+        this.pos = pos;
+        this.end = end;
+        this.#source = source;
+        this.#resolver = resolver;
+        this.#depth = depth;
+        this.#parts = resolver === undefined ? undefined : null;
+    }
+    get value() {
+        if (this.#value === null) {
+            const parts = this.#source === undefined && this.#parts === null ? undefined : this.parts;
+            this.#value = parts ? wordPartsValue(parts) : unescapeBareValue(this.text);
+        }
+        return this.#value;
+    }
+    get parts() {
+        if (this.#parts === null) {
+            this.#parts = this.#resolver?.(this.#source ?? "", this, this.#depth) ?? undefined;
+        }
+        return this.#parts;
+    }
+    set parts(v) {
+        this.#parts = v ?? undefined;
+    }
+    toJSON() {
+        return { type: this.type, text: this.text, pos: this.pos, end: this.end, parts: this.parts, value: this.value };
+    }
+}