@vune-ui/compiler 0.1.0

package/dist/ast.d.ts

@@ -0,0 +1,85 @@
+/** Half-open offsets in the original Vune source. */
+export interface VuneSourceRange {
+    readonly start: number;
+    readonly end: number;
+}
+export interface VuneRawExpression {
+    readonly kind: "raw";
+    readonly source: string;
+    readonly range: VuneSourceRange;
+}
+export interface VuneClosureExpression {
+    readonly kind: "closure";
+    readonly parameter?: string;
+    readonly bodySource: string;
+    readonly body: VuneBuilderProgram;
+    readonly range: VuneSourceRange;
+}
+export interface VuneArgument {
+    readonly label?: string;
+    readonly value: VuneRawExpression | VuneClosureExpression;
+    readonly range: VuneSourceRange;
+}
+export interface VuneCallExpression {
+    readonly kind: "call";
+    readonly callee: string;
+    readonly arguments: readonly VuneArgument[];
+    readonly trailing?: VuneClosureExpression;
+    readonly range: VuneSourceRange;
+}
+export interface VuneConditionalExpression {
+    readonly kind: "conditional";
+    readonly condition: VuneRawExpression;
+    readonly then: VuneBuilderProgram;
+    readonly otherwise?: VuneBuilderProgram | VuneConditionalExpression;
+    readonly range: VuneSourceRange;
+}
+export type VuneBuilderNode = VuneRawExpression | VuneCallExpression | VuneConditionalExpression;
+export interface VuneBuilderProgram {
+    readonly kind: "program";
+    readonly source: string;
+    readonly range: VuneSourceRange;
+    readonly statements: readonly VuneBuilderNode[];
+}
+export declare function parseVuneBuilder(source: string, baseOffset?: number): VuneBuilderProgram;
+export interface VuneStructDeclaration {
+    readonly kind: "struct";
+    readonly name: string;
+    readonly genericParameters?: string;
+    readonly source: string;
+    readonly bodySource: string;
+    readonly bodyExpressionSource: string;
+    readonly range: VuneSourceRange;
+    readonly bodyRange: VuneSourceRange;
+    readonly bodyExpressionRange: VuneSourceRange;
+    readonly fields: readonly VuneStructField[];
+    readonly initializers: readonly VuneStructInitializer[];
+    readonly nested?: readonly VuneStructDeclaration[];
+}
+export interface VuneStructField {
+    readonly name: string;
+    readonly kind: "stored" | "state" | "binding";
+    readonly type?: string;
+    readonly initializer?: string;
+    readonly range: VuneSourceRange;
+}
+export interface VuneStructInitializer {
+    readonly parametersSource: string;
+    readonly bodySource: string;
+    readonly range: VuneSourceRange;
+    readonly parametersRange: VuneSourceRange;
+    readonly bodyRange: VuneSourceRange;
+}
+export declare function parseVuneStructs(source: string, baseOffset?: number): readonly VuneStructDeclaration[];
+export interface VuneAstLowering {
+    readonly transformRaw: (source: string) => string;
+    readonly transformArgument?: (source: string, call: VuneCallExpression, argumentIndex: number, label?: string) => string;
+    readonly closure: (bodySource: string, parameter?: string, role?: "value" | "viewBuilder" | "action") => string;
+    readonly closureRole?: (call: VuneCallExpression, context: {
+        readonly position: "argument" | "trailing";
+        readonly argumentIndex?: number;
+        readonly label?: string;
+    }) => "value" | "viewBuilder" | "action" | undefined;
+}
+export declare function lowerVuneBuilderAst(program: VuneBuilderProgram, lowering: VuneAstLowering): string[];
+//# sourceMappingURL=ast.d.ts.map

package/dist/ast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.d.ts","sourceRoot":"","sources":["../src/ast.ts"],"names":[],"mappings":"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"}

package/dist/ast.js

@@ -0,0 +1,531 @@
+const closing = { "(": ")", "{": "}", "[": "]" };
+function syntaxError(message, offset) {
+    const error = new SyntaxError(message);
+    error.offset = offset;
+    return error;
+}
+function identifierPart(value) {
+    return !!value && /[A-Za-z0-9_$]/.test(value);
+}
+function skipQuoted(source, index) {
+    const quote = source[index];
+    for (let cursor = index + 1; cursor < source.length; cursor += 1) {
+        if (source[cursor] === "\\") {
+            cursor += 1;
+            continue;
+        }
+        if (source[cursor] === quote)
+            return cursor + 1;
+    }
+    throw syntaxError(`Unclosed ${quote} string in Vune source`, index);
+}
+function skipTemplate(source, index) {
+    for (let cursor = index + 1; cursor < source.length; cursor += 1) {
+        if (source[cursor] === "\\") {
+            cursor += 1;
+            continue;
+        }
+        if (source[cursor] === "`")
+            return cursor + 1;
+        if (source[cursor] !== "$" || source[cursor + 1] !== "{")
+            continue;
+        const close = findMatching(source, cursor + 1, "{");
+        cursor = close;
+    }
+    throw syntaxError("Unclosed template literal in Vune source", index);
+}
+function skipTrivia(source, index) {
+    let cursor = index;
+    while (cursor < source.length) {
+        if (/\s/.test(source[cursor])) {
+            cursor += 1;
+            continue;
+        }
+        if (source.startsWith("//", cursor) || source.startsWith("/*", cursor)) {
+            cursor = skipComment(source, cursor);
+            continue;
+        }
+        break;
+    }
+    return cursor;
+}
+function skipComment(source, index) {
+    if (source.startsWith("//", index)) {
+        const end = source.indexOf("\n", index + 2);
+        return end < 0 ? source.length : end;
+    }
+    const end = source.indexOf("*/", index + 2);
+    if (end < 0)
+        throw syntaxError("Unclosed block comment in Vune source", index);
+    return end + 2;
+}
+function regexCanStart(source, index) {
+    for (let cursor = index - 1; cursor >= 0; cursor -= 1) {
+        if (/\s/.test(source[cursor]))
+            continue;
+        return "([{=,:;!?&|+-*%^~<>".includes(source[cursor]);
+    }
+    return true;
+}
+function skipRegex(source, index) {
+    let inClass = false;
+    for (let cursor = index + 1; cursor < source.length; cursor += 1) {
+        if (source[cursor] === "\\") {
+            cursor += 1;
+            continue;
+        }
+        if (source[cursor] === "[")
+            inClass = true;
+        if (source[cursor] === "]")
+            inClass = false;
+        if (source[cursor] === "/" && !inClass) {
+            cursor += 1;
+            while (/[A-Za-z]/.test(source[cursor] ?? ""))
+                cursor += 1;
+            return cursor;
+        }
+        if (source[cursor] === "\n")
+            return index + 1;
+    }
+    return index + 1;
+}
+function findMatching(source, openIndex, open) {
+    const stack = [open];
+    for (let cursor = openIndex + 1; cursor < source.length; cursor += 1) {
+        const character = source[cursor];
+        const next = source[cursor + 1];
+        if (character === "\"" || character === "'") {
+            cursor = skipQuoted(source, cursor) - 1;
+            continue;
+        }
+        if (character === "`") {
+            cursor = skipTemplate(source, cursor) - 1;
+            continue;
+        }
+        if (character === "/" && (next === "/" || next === "*")) {
+            cursor = skipComment(source, cursor) - 1;
+            continue;
+        }
+        if (character === "/" && regexCanStart(source, cursor)) {
+            cursor = skipRegex(source, cursor) - 1;
+            continue;
+        }
+        if (character === "(" || character === "{" || character === "[") {
+            stack.push(character);
+            continue;
+        }
+        if (character === ")" || character === "}" || character === "]") {
+            const expected = closing[stack[stack.length - 1]];
+            if (character !== expected)
+                throw syntaxError(`Unexpected ${character} in Vune source`, cursor);
+            stack.pop();
+            if (stack.length === 0)
+                return cursor;
+        }
+    }
+    throw syntaxError(`Unclosed ${open} block in Vune source`, openIndex);
+}
+function lineBreakBoundary(source, index) {
+    const previous = source.slice(0, index).trimEnd().at(-1);
+    const nextIndex = skipTrivia(source, index + 1);
+    const next = source[nextIndex];
+    if (!previous || !next)
+        return true;
+    if (source.slice(nextIndex, nextIndex + 4) === "else")
+        return false;
+    if (",([{.=:+-*/%!&|?<>".includes(previous))
+        return false;
+    if (".),]}:;".includes(next))
+        return false;
+    return true;
+}
+function splitTopLevel(source, separators, baseOffset) {
+    const parts = [];
+    let start = 0;
+    const stack = [];
+    for (let cursor = 0; cursor < source.length; cursor += 1) {
+        const character = source[cursor];
+        const next = source[cursor + 1];
+        if (character === "\"" || character === "'") {
+            cursor = skipQuoted(source, cursor) - 1;
+            continue;
+        }
+        if (character === "`") {
+            cursor = skipTemplate(source, cursor) - 1;
+            continue;
+        }
+        if (character === "/" && (next === "/" || next === "*")) {
+            cursor = skipComment(source, cursor) - 1;
+            continue;
+        }
+        if (character === "/" && regexCanStart(source, cursor)) {
+            cursor = skipRegex(source, cursor) - 1;
+            continue;
+        }
+        if (character === "(" || character === "{" || character === "[")
+            stack.push(character);
+        else if (character === ")" || character === "}" || character === "]")
+            stack.pop();
+        const boundary = stack.length === 0 && (separators.includes(character) || (character === "\n" && lineBreakBoundary(source, cursor)));
+        if (boundary) {
+            parts.push({ source: source.slice(start, cursor), start: baseOffset + start, end: baseOffset + cursor });
+            start = cursor + 1;
+        }
+    }
+    parts.push({ source: source.slice(start), start: baseOffset + start, end: baseOffset + source.length });
+    return parts.filter(part => part.source.trim().length > 0);
+}
+function trimSlice(slice) {
+    const leading = slice.source.search(/\S|$/);
+    const trimmed = slice.source.trimEnd();
+    return { source: trimmed.slice(leading), start: slice.start + leading, end: slice.start + trimmed.length };
+}
+function raw(slice) {
+    const value = trimSlice(slice);
+    return { kind: "raw", source: value.source, range: { start: value.start, end: value.end } };
+}
+function parseClosure(slice) {
+    const value = trimSlice(slice);
+    if (value.source[0] !== "{")
+        return undefined;
+    const close = findMatching(value.source, 0, "{");
+    if (close !== value.source.length - 1)
+        return undefined;
+    const inner = value.source.slice(1, close);
+    const parameter = /^\s*([A-Za-z_$][A-Za-z0-9_$]*)\s+in\s+/.exec(inner);
+    // A direct object argument is not a Vune closure. Check the first member
+    // rather than any colon: closure bodies legitimately contain ternaries.
+    if (!parameter && /^(?:\s*(?:[A-Za-z_$][A-Za-z0-9_$]*|["'][^"']*["']|-?\d+(?:\.\d+)?)\s*:)/.test(inner))
+        return undefined;
+    const bodySource = parameter ? inner.slice(parameter[0].length) : inner;
+    const bodyOffset = value.start + 1 + (parameter ? parameter[0].length : 0);
+    return {
+        kind: "closure",
+        parameter: parameter?.[1],
+        bodySource,
+        body: parseVuneBuilder(bodySource, bodyOffset),
+        range: { start: value.start, end: value.end },
+    };
+}
+function topLevelColon(source) {
+    const slices = splitTopLevel(source, ":", 0);
+    return slices.length > 1 ? slices[0].source.length : -1;
+}
+function parseArgument(slice) {
+    const value = trimSlice(slice);
+    const colon = topLevelColon(value.source);
+    const labelStart = skipTrivia(value.source, 0);
+    const label = colon < 0 ? undefined : value.source.slice(labelStart, colon).trim();
+    if (label && !/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(label))
+        return { value: raw(value), range: { start: value.start, end: value.end } };
+    const valueSlice = colon < 0
+        ? value
+        : { source: value.source.slice(colon + 1), start: value.start + colon + 1, end: value.end };
+    return { label, value: parseClosure(valueSlice) ?? raw(valueSlice), range: { start: value.start, end: value.end } };
+}
+function parseCall(slice) {
+    const value = trimSlice(slice);
+    const identifier = /^([A-Za-z_$][A-Za-z0-9_$]*)/.exec(value.source);
+    if (!identifier)
+        return undefined;
+    const open = skipTrivia(value.source, identifier[0].length);
+    if (value.source[open] !== "(")
+        return undefined;
+    const close = findMatching(value.source, open, "(");
+    const afterClose = skipTrivia(value.source, close + 1);
+    let trailing;
+    let end = close + 1;
+    if (value.source[afterClose] === "{") {
+        const trailingClose = findMatching(value.source, afterClose, "{");
+        if (skipTrivia(value.source, trailingClose + 1) !== value.source.length)
+            return undefined;
+        trailing = parseClosure({ source: value.source.slice(afterClose, trailingClose + 1), start: value.start + afterClose, end: value.start + trailingClose + 1 });
+        end = trailingClose + 1;
+    }
+    if (skipTrivia(value.source, end) !== value.source.length)
+        return undefined;
+    return {
+        kind: "call",
+        callee: identifier[1],
+        arguments: splitTopLevel(value.source.slice(open + 1, close), ",", value.start + open + 1).map(parseArgument),
+        trailing,
+        range: { start: value.start, end: value.end },
+    };
+}
+function parseConditional(slice) {
+    const value = trimSlice(slice);
+    if (!/^if\b/.test(value.source))
+        return undefined;
+    const open = value.source.indexOf("(");
+    if (open < 0)
+        return undefined;
+    const close = findMatching(value.source, open, "(");
+    const thenOpen = skipTrivia(value.source, close + 1);
+    if (value.source[thenOpen] !== "{")
+        return undefined;
+    const thenClose = findMatching(value.source, thenOpen, "{");
+    const afterThen = skipTrivia(value.source, thenClose + 1);
+    const condition = raw({ source: value.source.slice(open + 1, close), start: value.start + open + 1, end: value.start + close });
+    let otherwise;
+    if (value.source.slice(afterThen, afterThen + 4) === "else") {
+        const elseStart = skipTrivia(value.source, afterThen + 4);
+        const rest = { source: value.source.slice(elseStart), start: value.start + elseStart, end: value.end };
+        if (/^if\b/.test(rest.source))
+            otherwise = parseConditional(rest);
+        else if (rest.source[0] === "{") {
+            const elseClose = findMatching(rest.source, 0, "{");
+            if (skipTrivia(rest.source, elseClose + 1) !== rest.source.length)
+                return undefined;
+            otherwise = parseVuneBuilder(rest.source.slice(1, elseClose), rest.start + 1);
+        }
+    }
+    return {
+        kind: "conditional",
+        condition,
+        then: parseVuneBuilder(value.source.slice(thenOpen + 1, thenClose), value.start + thenOpen + 1),
+        otherwise,
+        range: { start: value.start, end: value.end },
+    };
+}
+function parseNode(slice) {
+    return parseConditional(slice) ?? parseCall(slice) ?? raw(slice);
+}
+export function parseVuneBuilder(source, baseOffset = 0) {
+    return { kind: "program", source, range: { start: baseOffset, end: baseOffset + source.length }, statements: splitTopLevel(source, ",;", baseOffset).map(parseNode) };
+}
+function findStructs(source, start) {
+    for (let cursor = start; cursor < source.length; cursor += 1) {
+        const character = source[cursor];
+        const next = source[cursor + 1];
+        if (character === "\"" || character === "'") {
+            cursor = skipQuoted(source, cursor) - 1;
+            continue;
+        }
+        if (character === "`") {
+            cursor = skipTemplate(source, cursor) - 1;
+            continue;
+        }
+        if (character === "/" && (next === "/" || next === "*")) {
+            cursor = skipComment(source, cursor) - 1;
+            continue;
+        }
+        if (character === "/" && regexCanStart(source, cursor)) {
+            cursor = skipRegex(source, cursor) - 1;
+            continue;
+        }
+        if (!source.startsWith("struct", cursor))
+            continue;
+        if (identifierPart(source[cursor - 1]) || identifierPart(source[cursor + 6]))
+            continue;
+        return cursor;
+    }
+    return -1;
+}
+function findTopLevelBodyExpression(source) {
+    let braces = 0;
+    for (let cursor = 0; cursor < source.length; cursor += 1) {
+        const character = source[cursor];
+        const next = source[cursor + 1];
+        if (character === "\"" || character === "'") {
+            cursor = skipQuoted(source, cursor) - 1;
+            continue;
+        }
+        if (character === "`") {
+            cursor = skipTemplate(source, cursor) - 1;
+            continue;
+        }
+        if (character === "/" && (next === "/" || next === "*")) {
+            cursor = skipComment(source, cursor) - 1;
+            continue;
+        }
+        if (character === "/" && regexCanStart(source, cursor)) {
+            cursor = skipRegex(source, cursor) - 1;
+            continue;
+        }
+        if (braces === 0 && source.startsWith("var", cursor) && !identifierPart(source[cursor - 1]) && !identifierPart(source[cursor + 3])) {
+            const match = /^var\s+body\s*:[^{]*\{/.exec(source.slice(cursor));
+            if (match) {
+                const open = cursor + match[0].lastIndexOf("{");
+                return { declarationStart: cursor, open, close: findMatching(source, open, "{") };
+            }
+        }
+        if (character === "{")
+            braces += 1;
+        else if (character === "}")
+            braces -= 1;
+    }
+    return undefined;
+}
+function maskNestedStructs(source) {
+    const characters = [...source];
+    let cursor = 0;
+    while (cursor < source.length) {
+        const index = findStructs(source, cursor);
+        if (index < 0)
+            break;
+        const header = /^struct\s+([A-Za-z_$][A-Za-z0-9_$]*)(?:\s*<([^>{}]*)>)?\s*:\s*View\b/.exec(source.slice(index));
+        if (!header) {
+            cursor = index + 6;
+            continue;
+        }
+        const brace = source.indexOf("{", index + header[0].length);
+        if (brace < 0)
+            break;
+        const close = findMatching(source, brace, "{");
+        for (let position = index; position <= close; position += 1) {
+            if (characters[position] !== "\n" && characters[position] !== "\r")
+                characters[position] = " ";
+        }
+        cursor = close + 1;
+    }
+    return characters.join("");
+}
+function maskInitializerBodies(source) {
+    const masked = [...source];
+    let cursor = 0;
+    while (true) {
+        const initializer = findInitializer(source, cursor);
+        if (initializer < 0)
+            break;
+        const open = skipTrivia(source, initializer + 4);
+        const close = findMatching(source, open, "(");
+        const blockOpen = skipTrivia(source, close + 1);
+        if (source[blockOpen] !== "{") {
+            cursor = initializer + 4;
+            continue;
+        }
+        const blockClose = findMatching(source, blockOpen, "{");
+        for (let index = initializer; index <= blockClose; index += 1) {
+            if (masked[index] !== "\n" && masked[index] !== "\r")
+                masked[index] = " ";
+        }
+        cursor = blockClose + 1;
+    }
+    return masked.join("");
+}
+function findInitializer(source, start) {
+    for (let cursor = start; cursor < source.length; cursor += 1) {
+        const character = source[cursor];
+        const next = source[cursor + 1];
+        if (character === "\"" || character === "'") {
+            cursor = skipQuoted(source, cursor) - 1;
+            continue;
+        }
+        if (character === "`") {
+            cursor = skipTemplate(source, cursor) - 1;
+            continue;
+        }
+        if (character === "/" && (next === "/" || next === "*")) {
+            cursor = skipComment(source, cursor) - 1;
+            continue;
+        }
+        if (character === "/" && regexCanStart(source, cursor)) {
+            cursor = skipRegex(source, cursor) - 1;
+            continue;
+        }
+        if (!source.startsWith("init", cursor) || identifierPart(source[cursor - 1]) || identifierPart(source[cursor + 4]))
+            continue;
+        if (source[skipTrivia(source, cursor + 4)] === "(")
+            return cursor;
+    }
+    return -1;
+}
+function parseStructMembers(body, baseOffset) {
+    const fields = [];
+    const initializers = [];
+    const nestedMaskedBody = maskNestedStructs(body);
+    const maskedBody = maskInitializerBodies(nestedMaskedBody);
+    const fieldPattern = /(?:^|[;\n])\s*(?:(@State|@Binding)\s+)?(?:let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)(?:\s*:\s*([^=\n;]+))?(?:\s*=\s*([^\n;]+))?/g;
+    for (const match of maskedBody.matchAll(fieldPattern)) {
+        if (match[2] === "body")
+            continue;
+        const start = baseOffset + (match.index ?? 0) + match[0].indexOf(match[2]);
+        fields.push({ name: match[2], kind: match[1] === "@State" ? "state" : match[1] === "@Binding" ? "binding" : "stored", type: match[3]?.trim(), initializer: match[4]?.trim(), range: { start, end: start + match[2].length } });
+    }
+    let cursor = 0;
+    while (true) {
+        const initializer = findInitializer(nestedMaskedBody, cursor);
+        if (initializer < 0)
+            break;
+        const open = skipTrivia(nestedMaskedBody, initializer + 4);
+        const close = findMatching(nestedMaskedBody, open, "(");
+        const blockOpen = skipTrivia(nestedMaskedBody, close + 1);
+        if (nestedMaskedBody[blockOpen] !== "{") {
+            cursor = initializer + 4;
+            continue;
+        }
+        const blockClose = findMatching(nestedMaskedBody, blockOpen, "{");
+        initializers.push({
+            parametersSource: body.slice(open + 1, close),
+            bodySource: body.slice(blockOpen + 1, blockClose),
+            range: { start: baseOffset + initializer, end: baseOffset + blockClose + 1 },
+            parametersRange: { start: baseOffset + open + 1, end: baseOffset + close },
+            bodyRange: { start: baseOffset + blockOpen + 1, end: baseOffset + blockClose },
+        });
+        cursor = blockClose + 1;
+    }
+    return { fields, initializers };
+}
+export function parseVuneStructs(source, baseOffset = 0) {
+    const declarations = [];
+    let cursor = 0;
+    while (cursor < source.length) {
+        const index = findStructs(source, cursor);
+        if (index < 0)
+            break;
+        const header = /^struct\s+([A-Za-z_$][A-Za-z0-9_$]*)(?:\s*<([^>{}]*)>)?\s*:\s*View\b/.exec(source.slice(index));
+        if (!header) {
+            cursor = index + 6;
+            continue;
+        }
+        const brace = source.indexOf("{", index + header[0].length);
+        if (brace < 0)
+            throw syntaxError(`Missing body for struct ${header[1]}`, baseOffset + index);
+        const close = findMatching(source, brace, "{");
+        const bodySource = source.slice(brace + 1, close);
+        const bodyExpression = findTopLevelBodyExpression(bodySource);
+        if (!bodyExpression)
+            throw syntaxError(`struct ${header[1]} must declare var body`, baseOffset + index);
+        const members = parseStructMembers(bodySource.slice(0, bodyExpression.declarationStart), baseOffset + brace + 1);
+        const nested = parseVuneStructs(bodySource, baseOffset + brace + 1);
+        declarations.push({
+            kind: "struct",
+            name: header[1],
+            genericParameters: header[2]?.trim(),
+            source: source.slice(index, close + 1),
+            bodySource,
+            bodyExpressionSource: bodySource.slice(bodyExpression.open + 1, bodyExpression.close),
+            range: { start: baseOffset + index, end: baseOffset + close + 1 },
+            bodyRange: { start: baseOffset + brace + 1, end: baseOffset + close },
+            bodyExpressionRange: { start: baseOffset + brace + 1 + bodyExpression.open + 1, end: baseOffset + brace + 1 + bodyExpression.close },
+            fields: members.fields,
+            initializers: members.initializers,
+            nested,
+        });
+        cursor = close + 1;
+    }
+    return declarations;
+}
+function lowerProgram(program, lowering) {
+    return program.statements.map(node => {
+        if (node.kind === "raw")
+            return lowering.transformRaw(node.source);
+        if (node.kind === "call") {
+            const positional = node.arguments.filter(argument => !argument.label).map((argument, argumentIndex) => argument.value.kind === "closure"
+                ? lowering.closure(argument.value.bodySource, argument.value.parameter, lowering.closureRole?.(node, { position: "argument", argumentIndex, label: argument.label }))
+                : lowering.transformArgument?.(argument.value.source, node, argumentIndex, argument.label) ?? lowering.transformRaw(argument.value.source));
+            const named = node.arguments.filter(argument => argument.label).map((argument, argumentIndex) => `${argument.label}: ${argument.value.kind === "closure"
+                ? lowering.closure(argument.value.bodySource, argument.value.parameter, lowering.closureRole?.(node, { position: "argument", argumentIndex, label: argument.label }))
+                : lowering.transformArgument?.(argument.value.source, node, argumentIndex, argument.label) ?? lowering.transformRaw(argument.value.source)}`);
+            const args = [...positional, ...(named.length ? [`namedArguments({ ${named.join(", ")} })`] : []), ...(node.trailing ? [lowering.closure(node.trailing.bodySource, node.trailing.parameter, lowering.closureRole?.(node, { position: "trailing" }))] : [])];
+            return `${node.callee}(${args.join(", ")})`;
+        }
+        const thenBranch = lowerProgram(node.then, lowering).join(", ");
+        const otherwise = !node.otherwise ? "[]" : node.otherwise.kind === "conditional" ? lowerProgram({ ...node.otherwise.then, statements: [node.otherwise] }, lowering)[0] : `[${lowerProgram(node.otherwise, lowering).join(", ")}]`;
+        return `(${lowering.transformRaw(node.condition.source)} ? [${thenBranch}] : ${otherwise})`;
+    });
+}
+export function lowerVuneBuilderAst(program, lowering) {
+    return lowerProgram(program, lowering);
+}
+//# sourceMappingURL=ast.js.map