intelligent-system-design-language 0.3.13

package/out/cli/components/method-generator.js

@@ -0,0 +1,1812 @@
+import { isRollParam, isTypeParam, } from '../../language/generated/ast.js';
+import { isReturnExpression, isAssignment, isBinaryExpression, isGroup, isVariableExpression, isLiteral, isRef, isNegExpression, isAccess, isMethodBlock, isIfStatement, isJS, isChatCard, isFleetingAccess, isHtmlExp, isRoll, isDamageRoll, isParentAccess, isParentAssignment, isVariableAssignment, isWhenExpressions, isShorthandComparisonExpression, isItemAccess, isExpression, isResourceExp, isBooleanExp, isSelfMethod, isAttributeExp, isArrayExpression, isEach, isParameter, isPrompt, isLabelParam, isNumberExp, isStringExp, isTargetParam, IntelligentSystemDesignLanguageTerminals, isMathExpression, isMathEmptyExpression, isMathSingleExpression, isMathParamExpression, isInitiativeProperty, isStatusProperty, isUpdate, isUpdateParent, isUpdateSelf, isParentTypeCheckExpression, isParentPropertyRefExp, isSelfPropertyRefExp, isLogExpression, isTrackerExp, isVisibilityValue, isFunctionCall, isAction, isIncrementDecrementAssignment, isQuickModifyAssignment, isVariableIncrementDecrementAssignment, isVariableQuickModifyAssignment, isParentIncrementDecrementAssignment, isParentQuickModifyAssignment, isLocationParam, isWidthParam, isHeightParam, isNumberRange, isTargetTypeCheckExpression, isTargetAccess, isTargetIncrementDecrementAssignment, isTargetQuickModifyAssignment, isTargetAssignment, isWait, isPlayAudio, isPlayAudioFile, isPlayAudioVolume, isDieField, isTimeLimitParam, isCombatMethods, isCombatProperty, isUserProperty, isMacroExecute, isMeasuredTemplateField, isStringChoiceField, isDiceField, isDieChoicesParam, isDocumentChoicesExp, isDocumentChoiceExp } from "../../language/generated/ast.js";
+import { expandToNode, joinToNode } from 'langium/generate';
+import { getParentDocument, getSystemPath, getTargetDocument, toMachineIdentifier } from './utils.js';
+import { AstUtils } from 'langium';
+export function translateExpression(entry, id, expression, preDerived = false, generatingProperty = undefined) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
+    function humanize(string) {
+        if (string == undefined) {
+            return "";
+        }
+        // Turn TitleCase into Title Case
+        // Ensure first letter of the string is capitalized
+        string = string.charAt(0).toUpperCase() + string.slice(1);
+        return string.replace(/([a-z])([A-Z])/g, '$1 $2');
+    }
+    //console.log(preDerived, generatingProperty);
+    function translateMethodExpression(expression) {
+        //console.log("Translating Method Expression: " + expression.name);
+        return expandToNode `
+            ${expression.type == "fleeting" ? "let" : "const"} ${expression.name} = ${translateExpression(entry, id, expression.value, preDerived, generatingProperty)};
+        `;
+    }
+    function translateReturnExpression(expression) {
+        //console.log("Translating Return Expression: " + expression.value);
+        return expandToNode `
+            return ${translateExpression(entry, id, expression.value, preDerived, generatingProperty)};
+        `;
+    }
+    function translateAssignmentExpression(expression) {
+        //console.log("Translating Assignment Expression: " + expression.property.ref?.name);
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
+        let systemPath = getSystemPath((_a = expression.property) === null || _a === void 0 ? void 0 : _a.ref, expression.subProperties, (_b = expression.propertyLookup) === null || _b === void 0 ? void 0 : _b.ref, false);
+        // Special case: For dice .die subproperty increment/decrement, use die choice navigation instead of numeric increment
+        if (isDiceField((_c = expression.property) === null || _c === void 0 ? void 0 : _c.ref) && expression.subProperties && expression.subProperties.length > 0 &&
+            expression.subProperties[0].toLowerCase() === "die" && isIncrementDecrementAssignment(expression)) {
+            const fieldName = (_e = (_d = expression.property) === null || _d === void 0 ? void 0 : _d.ref) === null || _e === void 0 ? void 0 : _e.name.toLowerCase();
+            const modifier = expression.term == "++" ? "+ 1" : "- 1";
+            const readPath = getSystemPath((_f = expression.property) === null || _f === void 0 ? void 0 : _f.ref, expression.subProperties, (_g = expression.propertyLookup) === null || _g === void 0 ? void 0 : _g.ref);
+            return expandToNode `
+                const ${fieldName}DieChoices = ["d4","d6","d8","d10","d12","d20"];
+                const ${fieldName}CurrentDieIndex = ${fieldName}DieChoices.indexOf(context.object.${readPath});
+                if (${fieldName}CurrentDieIndex === -1) {
+                    console.error("Invalid die size: " + context.object.${readPath});
+                    update["${systemPath}"] = 'd4';
+                    return;
+                }
+                let ${fieldName}NewDieIndex = ${fieldName}CurrentDieIndex;
+                ${fieldName}NewDieIndex = Math.max(0, Math.min(${fieldName}DieChoices.length - 1, ${fieldName}CurrentDieIndex ${modifier}));
+                update["${systemPath}"] = ${fieldName}DieChoices[${fieldName}NewDieIndex];
+            `;
+        }
+        if ((isResourceExp((_h = expression.property) === null || _h === void 0 ? void 0 : _h.ref) || isTrackerExp((_j = expression.property) === null || _j === void 0 ? void 0 : _j.ref)) && (expression.subProperties == undefined || expression.subProperties.length == 0 || expression.subProperties[0] == "temp")) {
+            // We need to check for temp first when decrementing
+            const tempPath = `system.${(_l = (_k = expression.property) === null || _k === void 0 ? void 0 : _k.ref) === null || _l === void 0 ? void 0 : _l.name.toLowerCase()}.temp`;
+            if (isIncrementDecrementAssignment(expression) && expression.term == "--") {
+                return expandToNode `
+                    if ( context.object.${tempPath} > 0 ) {
+                        update["${tempPath}"] = context.object.${tempPath} - 1;
+                    }
+                    else {
+                        update["${systemPath}"] = context.object.${systemPath} - 1;
+                    }
+                `;
+            }
+            if (isQuickModifyAssignment(expression) && expression.term == "-=") {
+                return expandToNode `
+                    if ( context.object.${tempPath} > 0 ) {
+                        update["${tempPath}"] = context.object.${tempPath} - ${translateExpression(entry, id, expression.exp, preDerived, generatingProperty)};
+
+                        if ( update["${tempPath}"] < 0 ) {
+                            // Apply the remainder to the system property
+                            update["${systemPath}"] = context.object.${systemPath} + update["${tempPath}"];
+                            update["${tempPath}"] = 0;
+                        }
+                    }
+                    else {
+                        update["${systemPath}"] = context.object.${systemPath} - ${translateExpression(entry, id, expression.exp, preDerived, generatingProperty)};
+                    }
+                `;
+            }
+        }
+        if (isDieField((_m = expression.property) === null || _m === void 0 ? void 0 : _m.ref)) {
+            // Die sizes are stored as strings such as "d6", "d8", etc. but when increments / decrements are applied, we want to treat them as numbers. d6++ should become d8, and so on based on the `choices`
+            const dieChoicesParam = (_o = expression.property) === null || _o === void 0 ? void 0 : _o.ref.params.find(isDieChoicesParam);
+            const dieChoices = (_p = dieChoicesParam === null || dieChoicesParam === void 0 ? void 0 : dieChoicesParam.choices) !== null && _p !== void 0 ? _p : ["d4", "d6", "d8", "d10", "d12", "d20"];
+            const propertyName = (_s = (_r = (_q = expression.property) === null || _q === void 0 ? void 0 : _q.ref.name) === null || _r === void 0 ? void 0 : _r.toLowerCase()) !== null && _s !== void 0 ? _s : "die";
+            function generateModification() {
+                if (isIncrementDecrementAssignment(expression)) {
+                    const modifier = expression.term == "++" ? "+" : "-";
+                    return expandToNode `
+                        ${propertyName}NewDieIndex = Math.max(0, Math.min(${propertyName}DieChoices.length - 1, ${propertyName}CurrentDieIndex ${modifier} 1));
+                    `;
+                }
+                if (isQuickModifyAssignment(expression)) {
+                    let modifier = "+";
+                    switch (expression.term) {
+                        case "+=":
+                            modifier = "+";
+                            break;
+                        case "-=":
+                            modifier = "-";
+                            break;
+                        case "*=":
+                            modifier = "*";
+                            break;
+                        case "/=":
+                            modifier = "/";
+                            break;
+                        default:
+                            modifier = "+";
+                            break;
+                    }
+                    return expandToNode `
+                        ${propertyName}NewDieIndex = Math.max(0, Math.min(${propertyName}DieChoices.length - 1, ${propertyName}CurrentDieIndex ${modifier} ${translateExpression(entry, id, expression.exp, preDerived, generatingProperty)}));
+                    `;
+                }
+                return expandToNode `
+                    ${propertyName}NewDieIndex = Math.max(0, Math.min(${propertyName}DieChoices.length - 1, ${translateExpression(entry, id, expression.exp, preDerived, generatingProperty)}));
+                `;
+            }
+            return expandToNode `
+                const ${propertyName}DieChoices = ${JSON.stringify(dieChoices)};
+                const ${propertyName}CurrentDieIndex = ${propertyName}DieChoices.indexOf(context.object.${systemPath});
+                if (${propertyName}CurrentDieIndex === -1) {
+                    console.error("Invalid die size: " + context.object.${systemPath});
+                    update["${systemPath}"] = '${dieChoices[0]}';
+                    return;
+                }
+                let ${propertyName}NewDieIndex = ${propertyName}CurrentDieIndex;
+                ${generateModification()}
+                update["${systemPath}"] = ${propertyName}DieChoices[${propertyName}NewDieIndex];
+            `;
+        }
+        // Special case for dice fields with .die subproperty - use die choice navigation
+        if (isDiceField((_t = expression.property) === null || _t === void 0 ? void 0 : _t.ref) && expression.subProperties && expression.subProperties.length > 0 &&
+            expression.subProperties[0].toLowerCase() === "die" && isIncrementDecrementAssignment(expression)) {
+            const fieldName = (_v = (_u = expression.property) === null || _u === void 0 ? void 0 : _u.ref) === null || _v === void 0 ? void 0 : _v.name.toLowerCase();
+            const modifier = expression.term == "++" ? "+ 1" : "- 1";
+            const readPath = getSystemPath((_w = expression.property) === null || _w === void 0 ? void 0 : _w.ref, expression.subProperties, (_x = expression.propertyLookup) === null || _x === void 0 ? void 0 : _x.ref);
+            return expandToNode `
+                const ${fieldName}DieChoices = ["d4","d6","d8","d10","d12","d20"];
+                const ${fieldName}CurrentDieIndex = ${fieldName}DieChoices.indexOf(context.object.${readPath});
+                if (${fieldName}CurrentDieIndex === -1) {
+                    console.error("Invalid die size: " + context.object.${readPath});
+                    update["${systemPath}"] = 'd4';
+                    return;
+                }
+                let ${fieldName}NewDieIndex = ${fieldName}CurrentDieIndex;
+                ${fieldName}NewDieIndex = Math.max(0, Math.min(${fieldName}DieChoices.length - 1, ${fieldName}CurrentDieIndex ${modifier}));
+                update["${systemPath}"] = ${fieldName}DieChoices[${fieldName}NewDieIndex];
+            `;
+        }
+        if (isIncrementDecrementAssignment(expression)) {
+            const modifier = expression.term == "++" ? "+" : "-";
+            return expandToNode `
+                update["${systemPath}"] = context.object.${systemPath} ${modifier} 1;
+            `;
+        }
+        if (isQuickModifyAssignment(expression)) {
+            let modifier = "+";
+            switch (expression.term) {
+                case "+=":
+                    modifier = "+";
+                    break;
+                case "-=":
+                    modifier = "-";
+                    break;
+                case "*=":
+                    modifier = "*";
+                    break;
+                case "/=":
+                    modifier = "/";
+                    break;
+                default:
+                    modifier = "+";
+                    break;
+            }
+            return expandToNode `
+                update["${systemPath}"] = context.object.${systemPath} ${modifier} ${translateExpression(entry, id, expression.exp, preDerived, generatingProperty)};
+            `;
+        }
+        return expandToNode `
+            update["${systemPath}"] = ${translateExpression(entry, id, expression.exp, preDerived, generatingProperty)};
+        `;
+    }
+    function translateVariableAssignment(expression) {
+        var _a, _b;
+        let name = (_a = expression.variable.ref) === null || _a === void 0 ? void 0 : _a.name;
+        for (const subProperty of (_b = expression.subProperties) !== null && _b !== void 0 ? _b : []) {
+            name = `${name}.${subProperty}`;
+        }
+        // ++ or --
+        if (isVariableIncrementDecrementAssignment(expression)) {
+            return expandToNode `
+                ${name}${expression.term};
+            `;
+        }
+        // +=, -=, *=, /=
+        if (isVariableQuickModifyAssignment(expression)) {
+            return expandToNode `
+                ${name} ${expression.term} ${translateExpression(entry, id, expression.exp, preDerived, generatingProperty)};
+            `;
+        }
+        return expandToNode `
+            ${name} = ${translateExpression(entry, id, expression.exp, preDerived, generatingProperty)};
+        `;
+    }
+    function translateParentAssignmentExpression(expression) {
+        //console.log("Translating Assignment Expression: " + expression.property.ref?.name);
+        var _a, _b;
+        let systemPath = getSystemPath((_a = expression.property) === null || _a === void 0 ? void 0 : _a.ref, expression.subProperties, (_b = expression.propertyLookup) === null || _b === void 0 ? void 0 : _b.ref, false);
+        if (isParentIncrementDecrementAssignment(expression)) {
+            const modifier = expression.term == "++" ? "+" : "-";
+            return expandToNode `
+                parentUpdate["${systemPath}"] = context.object.parent.${systemPath} ${modifier} 1;
+            `;
+        }
+        if (isParentQuickModifyAssignment(expression)) {
+            let modifier = "+";
+            switch (expression.term) {
+                case "+=":
+                    modifier = "+";
+                    break;
+                case "-=":
+                    modifier = "-";
+                    break;
+                case "*=":
+                    modifier = "*";
+                    break;
+                case "/=":
+                    modifier = "/";
+                    break;
+                default:
+                    modifier = "+";
+                    break;
+            }
+            return expandToNode `
+                parentUpdate["${systemPath}"] = context.object.parent.${systemPath} ${modifier} ${translateExpression(entry, id, expression.exp, preDerived, generatingProperty)};
+            `;
+        }
+        return expandToNode `
+            parentUpdate["${systemPath}"] = ${translateExpression(entry, id, expression.exp, preDerived, generatingProperty)};
+        `;
+    }
+    function translateTargetAssignmentExpression(expression) {
+        var _a;
+        let systemPath = getSystemPath((_a = expression.property) === null || _a === void 0 ? void 0 : _a.ref, expression.subProperties, undefined, false);
+        if (isTargetIncrementDecrementAssignment(expression)) {
+            const modifier = expression.term == "++" ? "+" : "-";
+            return expandToNode `
+                targetUpdate["${systemPath}"] = context.target.${systemPath} ${modifier} 1;
+            `;
+        }
+        if (isTargetQuickModifyAssignment(expression)) {
+            let modifier = "+";
+            switch (expression.term) {
+                case "+=":
+                    modifier = "+";
+                    break;
+                case "-=":
+                    modifier = "-";
+                    break;
+                case "*=":
+                    modifier = "*";
+                    break;
+                case "/=":
+                    modifier = "/";
+                    break;
+                default:
+                    modifier = "+";
+                    break;
+            }
+            return expandToNode `
+                targetUpdate["${systemPath}"] = context.target.${systemPath} ${modifier} ${translateExpression(entry, id, expression.exp, preDerived, generatingProperty)};
+            `;
+        }
+        return expandToNode `
+            targetUpdate["${systemPath}"] = ${translateExpression(entry, id, expression.exp, preDerived, generatingProperty)};
+        `;
+    }
+    function translateBinaryExpression(expression) {
+        console.log("Translating Binary Expression: ", expression.e1.$type, expression.op, expression.e2.$type);
+        let a = translateExpression(entry, id, expression.e1, preDerived, generatingProperty);
+        let b = translateExpression(entry, id, expression.e2, preDerived, generatingProperty);
+        let op = `${expression.op}`;
+        // If the term is "equals" or "==", we need to translate it to "===" in JavaScript
+        if (op == "equals" || op == "==") {
+            op = "===";
+        }
+        // !equals
+        if (op == "!equals" || op == "!=") {
+            op = "!==";
+        }
+        // Or
+        if (op == "or") {
+            op = "||";
+        }
+        // And
+        if (op == "and") {
+            op = "&&";
+        }
+        return expandToNode `${a} ${op} ${b}`;
+    }
+    function translateLiteralExpression(expression) {
+        console.log("Translating Literal Expression: " + expression.val);
+        if (typeof expression.val == "string") {
+            if (expression.val == "nothing") {
+                return expandToNode `
+                    null
+                `;
+            }
+            else if (expression.val == "true" || expression.val == "false") {
+                return expandToNode `
+                    ${expression.val}
+                `;
+            }
+            if (isInitiativeProperty(generatingProperty)) {
+                return expandToNode `
+                    ${expression.val}
+                `;
+            }
+            return expandToNode `
+             "${expression.val}"
+            `;
+        }
+        return expandToNode `
+            ${expression.val}
+        `;
+    }
+    function translateReferenceExpression(expression) {
+        var _a, _b, _c, _d, _e, _f;
+        let accessPath = (_b = (_a = expression.val.ref) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : expression.val.$refText;
+        if (!accessPath) {
+            console.log(expression);
+            throw new Error("Reference expression has no reference");
+        }
+        console.log("Translating Reference Expression: " + accessPath);
+        // Check if we are in an each loop
+        const eachExp = AstUtils.getContainerOfType(expression.$container, isEach);
+        if (eachExp != undefined) {
+            if (isAccess(eachExp.collection) || isParentAccess(eachExp.collection) || isTargetAccess(eachExp.collection)) {
+                accessPath = `${accessPath}.system`;
+            }
+        }
+        for (const subProperty of (_c = expression.subProperties) !== null && _c !== void 0 ? _c : []) {
+            if (subProperty.toLowerCase() == "name") {
+                accessPath = `${(_d = expression.val.ref) === null || _d === void 0 ? void 0 : _d.name}.name`;
+            }
+            else {
+                accessPath = `${accessPath}.${subProperty.toLowerCase()}`;
+            }
+        }
+        // A bare reference to a roll variable (e.g. `fleeting r = roll(d20 + 1)`
+        // used as `r >= 20` or `r + 5`) should use the roll's numeric total, not
+        // the Roll object. In expression contexts the reference parses as a Ref
+        // (Ref precedes FleetingAccess in PrimitiveExpression), so this is the
+        // path that needs it. Skip when the user already accessed a subproperty
+        // (r.total, r.dice) or when the ref is a Parameter rather than a variable.
+        // Chat-card rendering keeps the Roll object via a separate path.
+        const refTarget = expression.val.ref;
+        if (((_f = (_e = expression.subProperties) === null || _e === void 0 ? void 0 : _e.length) !== null && _f !== void 0 ? _f : 0) === 0
+            && isVariableExpression(refTarget)
+            && (isRoll(refTarget.value) || isDamageRoll(refTarget.value))) {
+            accessPath = `${accessPath}.total`;
+        }
+        console.log("Access Path: ", accessPath);
+        return expandToNode `
+            ${accessPath}
+        `;
+    }
+    function translateGroupedExpression(expression) {
+        //console.log("Translating Grouped Expression: " + expression.ge);
+        return expandToNode `
+            (${translateExpression(entry, id, expression.ge, preDerived, generatingProperty)})
+        `;
+    }
+    function translateNegatedExpression(expression) {
+        //console.log("Translating Negated Expression: " + expression.ne);
+        var _a;
+        // If this is a boolean, we need to negate it differently
+        if (isAccess(expression.ne) && isBooleanExp((_a = expression.ne.property) === null || _a === void 0 ? void 0 : _a.ref)) {
+            return expandToNode `
+                !${translateExpression(entry, id, expression.ne, preDerived, generatingProperty)}
+            `;
+        }
+        return expandToNode `
+            -(${translateExpression(entry, id, expression.ne, preDerived, generatingProperty)})
+        `;
+    }
+    function translateAccessExpression(expression, generatingProperty = undefined) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        // If we are accessing special values, we need to handle them differently
+        if (expression.access != undefined) {
+            let accessName = expression.access.toString();
+            switch (accessName) {
+                case "DocumentType":
+                    accessName = "type";
+                    break;
+                case "EditMode":
+                    return expandToNode `context.object.getFlag('${id}', 'editMode') ?? true`;
+                default:
+                    accessName = accessName.toLowerCase();
+                    break;
+            }
+            console.log("Access Name: ", accessName);
+            return expandToNode `
+                context.object.${accessName}
+            `;
+        }
+        if (((_a = expression.property) === null || _a === void 0 ? void 0 : _a.ref) == undefined) {
+            return;
+        }
+        console.log("Translating Access Expression: " + ((_b = expression.property.ref) === null || _b === void 0 ? void 0 : _b.name));
+        // Determine if the property reference is the same as the object we are working with
+        if (generatingProperty && ((_c = expression.property) === null || _c === void 0 ? void 0 : _c.ref) == generatingProperty) {
+            console.log("Generating self referencing Property Access: ", (_d = expression.property.ref) === null || _d === void 0 ? void 0 : _d.name);
+            if (isInitiativeProperty(generatingProperty)) {
+                return expandToNode `
+                    @system.${(_e = expression.property.ref) === null || _e === void 0 ? void 0 : _e.name.toLowerCase()}
+                `;
+            }
+            // Special case: For attribute self-references, use .value instead of .mod to avoid recursion
+            if (isAttributeExp(generatingProperty)) {
+                const systemPath = `system.${(_f = expression.property.ref) === null || _f === void 0 ? void 0 : _f.name.toLowerCase()}.value`;
+                return expandToNode `
+                    ${systemPath}
+                `;
+            }
+            const systemPath = getSystemPath((_g = expression.property) === null || _g === void 0 ? void 0 : _g.ref, expression.subProperties, generatingProperty);
+            return expandToNode `
+                ${systemPath}
+            `;
+        }
+        let systemPath = getSystemPath((_h = expression.property) === null || _h === void 0 ? void 0 : _h.ref, expression.subProperties, expression);
+        if (isStatusProperty(generatingProperty)) {
+            console.log("This is a status property, swapping to self-access");
+            systemPath = systemPath.replace("system.", "this.");
+        }
+        console.log("System Path: ", systemPath);
+        if (isInitiativeProperty(generatingProperty)) {
+            return expandToNode `
+                @${systemPath}
+            `;
+        }
+        if (isAction(generatingProperty)) {
+            return expandToNode `
+                context.object.${systemPath}
+            `;
+        }
+        // If accessing a property on a document choice, wrap with ?? 0 to handle missing documents
+        const needsNullCoalescing = isDocumentChoiceExp((_j = expression.property) === null || _j === void 0 ? void 0 : _j.ref) && expression.subProperties && expression.subProperties.length > 0;
+        if (needsNullCoalescing) {
+            return expandToNode `
+                (${systemPath} ?? 0)
+            `;
+        }
+        return expandToNode `
+            ${systemPath}
+        `;
+    }
+    // function translateResourceAccessExpression(expression: ResourceAccess): CompositeGeneratorNode | undefined {
+    //     console.log("Translating Resource Access Expression: " + expression.property?.ref?.name);
+    //     let systemPath = getSystemPath(expression.property?.ref, expression.subProperties, expression.propertyLookup?.ref);
+    //     if (isStatusProperty(generatingProperty)) {
+    //         console.log("This is a status property, swapping to self-access");
+    //         systemPath = systemPath.replace("system.", "this.");
+    //     }
+    //     console.log("System Path: ", systemPath);
+    //     return expandToNode`
+    //         ${systemPath}
+    //     `;
+    // }
+    function translateIfStatement(expression) {
+        //console.log("Translating If Statement: ");
+        var _a;
+        function translateElseIfStatement(elif) {
+            return expandToNode `
+                else if (${translateExpression(entry, id, elif.expression, preDerived, generatingProperty)}) {
+                    ${translateBodyExpressionToJavascript(entry, id, elif.method.body, preDerived, generatingProperty)}
+                }
+            `;
+        }
+        return expandToNode `
+            if (${translateExpression(entry, id, expression.expression, preDerived, generatingProperty)}) {
+                ${translateBodyExpressionToJavascript(entry, id, expression.method.body, preDerived, generatingProperty)}
+            }
+            ${joinToNode(expression.elseIfs, translateElseIfStatement, { appendNewLineIfNotEmpty: true })}
+            ${expression.elseMethod != undefined ? expandToNode `
+                else {
+                    ${translateBodyExpressionToJavascript(entry, id, (_a = expression.elseMethod) === null || _a === void 0 ? void 0 : _a.body, preDerived, generatingProperty)}
+                }
+            `.appendNewLineIfNotEmpty() : ""}
+        `;
+    }
+    function translateComparisonExpression(expression) {
+        var _a, _b, _c, _d, _e, _f;
+        console.log("Translating Comparison Expression: ");
+        if (isParentTypeCheckExpression(expression)) {
+            return expandToNode `
+                context.object.parent && context.object.parent.type == "${(_b = (_a = expression.document.ref) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.toLowerCase()}"
+            `;
+        }
+        if (isTargetTypeCheckExpression(expression)) {
+            return expandToNode `
+                context.target && context.target.type == "${(_d = (_c = expression.document.ref) === null || _c === void 0 ? void 0 : _c.name) === null || _d === void 0 ? void 0 : _d.toLowerCase()}"
+            `;
+        }
+        // If the term is "equals" or "==", we need to translate it to "===" in JavaScript
+        let term = (_f = (_e = expression.term) === null || _e === void 0 ? void 0 : _e.toString()) !== null && _f !== void 0 ? _f : "";
+        if (term == "equals" || term == "==") {
+            term = "===";
+        }
+        if (isShorthandComparisonExpression(expression)) {
+            console.log("Shorthand Comparison Expression: ", term);
+            if (term == "exists") {
+                return expandToNode `
+                    ${translateExpression(entry, id, expression.e1, preDerived, generatingProperty)} != undefined
+                `;
+            }
+            else if (term == "!exists") {
+                return expandToNode `
+                    ${translateExpression(entry, id, expression.e1, preDerived, generatingProperty)} == undefined
+                `;
+            }
+            else if (term == "isEmpty") {
+                return expandToNode `
+                    (${translateExpression(entry, id, expression.e1, preDerived, generatingProperty)})?.length === 0
+                `;
+            }
+            else if (term == "isNotEmpty") {
+                return expandToNode `
+                    (${translateExpression(entry, id, expression.e1, preDerived, generatingProperty)})?.length > 0
+                `;
+            }
+            return expandToNode `
+                ${translateExpression(entry, id, expression.e1, preDerived, generatingProperty)} ${term}
+            `;
+        }
+        console.log("Comparison Expression: ", expression.e1.$type, term, expression.e2.$type);
+        if (term == "has") {
+            return expandToNode `
+                (${translateExpression(entry, id, expression.e1, preDerived, generatingProperty)})?.includes(${translateExpression(entry, id, expression.e2, preDerived, generatingProperty)})
+            `;
+        }
+        if (term == "excludes") {
+            return expandToNode `
+                !(${translateExpression(entry, id, expression.e1, preDerived, generatingProperty)})?.includes(${translateExpression(entry, id, expression.e2, preDerived, generatingProperty)})
+            `;
+        }
+        if (term == "startsWith") {
+            return expandToNode `
+                (${translateExpression(entry, id, expression.e1, preDerived, generatingProperty)})?.startsWith(${translateExpression(entry, id, expression.e2, preDerived, generatingProperty)})
+            `;
+        }
+        if (term == "endsWith") {
+            return expandToNode `
+                (${translateExpression(entry, id, expression.e1, preDerived, generatingProperty)})?.endsWith(${translateExpression(entry, id, expression.e2, preDerived, generatingProperty)})
+            `;
+        }
+        return expandToNode `
+            ${translateExpression(entry, id, expression.e1, preDerived, generatingProperty)} ${term} ${translateExpression(entry, id, expression.e2, preDerived, generatingProperty)}
+        `;
+    }
+    if (expression == undefined) {
+        return;
+    }
+    if (typeof expression == "string" && expression == "nothing") {
+        return expandToNode `
+            null
+        `;
+    }
+    if (typeof expression == "string") {
+        return expandToNode `
+            "${expression}"
+        `;
+    }
+    if (typeof expression == "number") {
+        return expandToNode `
+            ${expression}
+        `;
+    }
+    if (isMethodBlock(expression)) {
+        //console.log("Translating Method Block: ");
+        return translateBodyExpressionToJavascript(entry, id, expression.body, preDerived, generatingProperty);
+    }
+    if (isVariableExpression(expression)) {
+        return translateMethodExpression(expression);
+    }
+    if (isReturnExpression(expression)) {
+        return translateReturnExpression(expression);
+    }
+    if (isAssignment(expression)) {
+        return translateAssignmentExpression(expression);
+    }
+    if (isVariableAssignment(expression)) {
+        return translateVariableAssignment(expression);
+    }
+    if (isParentAssignment(expression)) {
+        return translateParentAssignmentExpression(expression);
+    }
+    if (isTargetAssignment(expression)) {
+        return translateTargetAssignmentExpression(expression);
+    }
+    if (isBinaryExpression(expression)) {
+        return translateBinaryExpression(expression);
+    }
+    if (isLiteral(expression)) {
+        return translateLiteralExpression(expression);
+    }
+    if (isRef(expression)) {
+        return translateReferenceExpression(expression);
+    }
+    if (isGroup(expression)) {
+        return translateGroupedExpression(expression);
+    }
+    if (isNegExpression(expression)) {
+        return translateNegatedExpression(expression);
+    }
+    // if (isResourceAccess(expression)) {
+    //     return translateResourceAccessExpression(expression as ResourceAccess);
+    // }
+    if (isAccess(expression)) {
+        return translateAccessExpression(expression, generatingProperty);
+    }
+    if (isParentAccess(expression)) {
+        let path = "context.object.parent";
+        let systemPath = getSystemPath((_a = expression.property) === null || _a === void 0 ? void 0 : _a.ref, expression.subProperties, expression, true);
+        path = `${path}?.${systemPath}`;
+        console.log("Translating Parent Access Expression: ", path);
+        return expandToNode `
+            ${path} ?? 0
+        `;
+    }
+    if (isTargetAccess(expression)) {
+        let path = "context.target";
+        let systemPath = getSystemPath((_b = expression.property) === null || _b === void 0 ? void 0 : _b.ref, expression.subProperties, undefined, true);
+        path = `${path}?.${systemPath}`;
+        console.log("Translating Target Access Expression: ", path);
+        return expandToNode `
+            ${path}
+        `;
+    }
+    if (isItemAccess(expression)) {
+        let path = `item.system.${(_c = expression.property) === null || _c === void 0 ? void 0 : _c.toLowerCase()}`;
+        if (expression.subProperty != undefined) {
+            path = `${path}.${expression.subProperty}`;
+        }
+        return expandToNode `
+            ${path}
+        `;
+    }
+    if (isIfStatement(expression)) {
+        return translateIfStatement(expression);
+    }
+    if (isWhenExpressions(expression)) {
+        return translateComparisonExpression(expression);
+    }
+    if (isFleetingAccess(expression)) {
+        let accessPath = (_d = expression.variable.ref) === null || _d === void 0 ? void 0 : _d.name;
+        if (expression.subProperty != undefined) {
+            accessPath = `${accessPath}.${expression.subProperty}`;
+        }
+        else if (expression.arrayAccess != undefined) {
+            accessPath = `${accessPath}[${translateExpression(entry, id, expression.arrayAccess, preDerived, generatingProperty)}]`;
+        }
+        else if (isRoll((_e = expression.variable.ref) === null || _e === void 0 ? void 0 : _e.value) || isDamageRoll((_f = expression.variable.ref) === null || _f === void 0 ? void 0 : _f.value)) {
+            // A bare reference to a roll variable used in a general expression
+            // (comparison, arithmetic, assignment, return, function arg) should
+            // use the roll's numeric total rather than the Roll object itself.
+            // Chat-card rendering uses a separate path that keeps the Roll object
+            // for dice display, so this does not affect "chat { roll1 }".
+            accessPath = `${accessPath}.total`;
+        }
+        return expandToNode `
+            ${accessPath}
+        `;
+    }
+    if (isParameter(expression)) {
+        return expandToNode `
+            ${expression.name}
+        `;
+    }
+    if (isJS(expression)) {
+        // Remove the last "}" from the JS expression
+        return expandToNode `
+            ${expression.js.replace("@js{", "").slice(0, -1)}
+        `;
+    }
+    if (isChatCard(expression)) {
+        function translateChatBodyExpression(expression) {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10;
+            if (expression.type == "flavor") {
+                return undefined;
+            }
+            if (isAccess(expression)) {
+                let systemPath = getSystemPath((_a = expression.property) === null || _a === void 0 ? void 0 : _a.ref, expression.subProperties, (_b = expression.propertyLookup) === null || _b === void 0 ? void 0 : _b.ref);
+                const wide = (isHtmlExp((_c = expression.property) === null || _c === void 0 ? void 0 : _c.ref) || expression.type == "wide") ? true : false;
+                if (expression.access != undefined) {
+                    switch (expression.access) {
+                        case "Effects":
+                            return undefined; // Renders in a different way
+                        case "DocumentType":
+                            return expandToNode `
+                                { isRoll: false, label: "Type", value: context.object.type, wide: ${wide}, hasValue: context.object.type != "" },
+                            `;
+                        case "EditMode":
+                            return expandToNode `
+                                { isRoll: false, label: "Edit Mode", value: context.object.getFlag('${id}', 'editMode') ?? true, wide: ${wide}, hasValue: context.object.getFlag('${id}', 'editMode') != undefined },
+                            `;
+                        // Properties on the document
+                        default:
+                            return expandToNode `
+                                { isRoll: false, label: "${expression.access.toString()}", value: context.object.${expression.access.toString().toLowerCase()}, wide: ${wide}, hasValue: context.object.${expression.access.toString().toLowerCase()} != "" },
+                            `;
+                    }
+                }
+                if (isMeasuredTemplateField((_d = expression.property) === null || _d === void 0 ? void 0 : _d.ref)) {
+                    return expandToNode `
+                        { isRoll: false, isMeasuredTemplate: true, label: "${humanize((_g = (_f = (_e = expression.property) === null || _e === void 0 ? void 0 : _e.ref) === null || _f === void 0 ? void 0 : _f.name) !== null && _g !== void 0 ? _g : "")}", value: context.object.${systemPath}?.summary, wide: true, hasValue: context.object.${systemPath} != undefined, object: context.object.${systemPath} },
+                    `;
+                }
+                if (isParentPropertyRefExp((_h = expression.property) === null || _h === void 0 ? void 0 : _h.ref)) {
+                    return expandToNode `
+                        { isRoll: false, label: "${humanize((_l = (_k = (_j = expression.property) === null || _j === void 0 ? void 0 : _j.ref) === null || _k === void 0 ? void 0 : _k.name) !== null && _l !== void 0 ? _l : "")}", value: context.object.${systemPath}.replace("system", "").replaceAll(".", "").titleCase(), wide: ${wide}, hasValue: context.object.${systemPath} != "" },
+                    `;
+                }
+                if (isSelfPropertyRefExp((_m = expression.property) === null || _m === void 0 ? void 0 : _m.ref)) {
+                    return expandToNode `
+                        { isRoll: false, label: "${humanize((_q = (_p = (_o = expression.property) === null || _o === void 0 ? void 0 : _o.ref) === null || _p === void 0 ? void 0 : _p.name) !== null && _q !== void 0 ? _q : "")}", value: foundry.utils.getProperty(context.object, context.object.${systemPath}).replace("system", "").replaceAll(".", "").titleCase(), wide: ${wide}, hasValue: context.object.${systemPath} != "" },
+                    `;
+                }
+                return expandToNode `
+                    { isRoll: false, label: "${humanize((_t = (_s = (_r = expression.property) === null || _r === void 0 ? void 0 : _r.ref) === null || _s === void 0 ? void 0 : _s.name) !== null && _t !== void 0 ? _t : "")}", value: context.object.${systemPath}, wide: ${wide}, hasValue: context.object.${systemPath} != "" },
+                `;
+            }
+            if (isFleetingAccess(expression)) {
+                let accessPath = (_u = expression.variable.ref) === null || _u === void 0 ? void 0 : _u.name;
+                if (expression.subProperty != undefined) {
+                    accessPath = `${accessPath}.${expression.subProperty}`;
+                }
+                let roll = false;
+                let wide = expression.type == "wide" ? true : false;
+                //console.log(expression.variable.ref?.value);
+                // Check if this is a damage roll first (before regular roll check)
+                if (isDamageRoll((_v = expression.variable.ref) === null || _v === void 0 ? void 0 : _v.value)) {
+                    roll = true;
+                    wide = true;
+                    return expandToNode `
+                        { 
+                            isRoll: ${roll}, 
+                            isDamageRoll: true,
+                            label: "${humanize((_x = (_w = expression.variable.ref) === null || _w === void 0 ? void 0 : _w.name) !== null && _x !== void 0 ? _x : "")}", 
+                            value: ${accessPath}, 
+                            wide: ${wide}, 
+                            tooltip: await ${accessPath}.getTooltip(),
+                            damageType: ${accessPath}.options.type.value,
+                            damageIcon: ${accessPath}.options.type.icon,
+                            damageColor: ${accessPath}.options.type.color,
+                            damageMetadata: ${accessPath}.options.type
+                        },
+                    `;
+                }
+                if (isRoll((_y = expression.variable.ref) === null || _y === void 0 ? void 0 : _y.value)) {
+                    roll = true;
+                    wide = true;
+                    return expandToNode `
+                        { isRoll: ${roll}, label: "${humanize((_0 = (_z = expression.variable.ref) === null || _z === void 0 ? void 0 : _z.name) !== null && _0 !== void 0 ? _0 : "")}", value: ${accessPath}, wide: ${wide}, tooltip: await ${accessPath}.getTooltip() },
+                    `;
+                }
+                return expandToNode `
+                    { isRoll: ${roll}, label: "${humanize((_2 = (_1 = expression.variable.ref) === null || _1 === void 0 ? void 0 : _1.name) !== null && _2 !== void 0 ? _2 : "")}", value: ${accessPath}, wide: ${wide}, hasValue: ${accessPath} != "" },
+                `;
+            }
+            if (isParentAccess(expression)) {
+                let systemPath = getSystemPath((_3 = expression.property) === null || _3 === void 0 ? void 0 : _3.ref, expression.subProperties, undefined, true);
+                const wide = expression.type == "wide" ? true : false;
+                return expandToNode `
+                    { isRoll: false, label: "${humanize((_6 = (_5 = (_4 = expression.property) === null || _4 === void 0 ? void 0 : _4.ref) === null || _5 === void 0 ? void 0 : _5.name) !== null && _6 !== void 0 ? _6 : "")}", value: context.object.parent?.${systemPath}, wide: ${wide}, hasValue: context.object.parent?.${systemPath} != "" },
+                `;
+            }
+            if (isTargetAccess(expression)) {
+                let systemPath = getSystemPath((_7 = expression.property) === null || _7 === void 0 ? void 0 : _7.ref, expression.subProperties, undefined, true);
+                const wide = expression.type == "wide" ? true : false;
+                return expandToNode `
+                    { isRoll: false, label: "${humanize((_10 = (_9 = (_8 = expression.property) === null || _8 === void 0 ? void 0 : _8.ref) === null || _9 === void 0 ? void 0 : _9.name) !== null && _10 !== void 0 ? _10 : "")}", value: context.target?.${systemPath}, wide: ${wide}, hasValue: context.target?.${systemPath} != "" },
+                `;
+            }
+            if (isExpression(expression)) {
+                return expandToNode `
+                    { isParagraph: true, value: ${translateExpression(entry, id, expression, preDerived, generatingProperty)} },
+                `;
+            }
+            return;
+        }
+        function translateChatBodyExpressionForFlavor(expression) {
+            var _a, _b, _c;
+            if (isAccess(expression)) {
+                let systemPath = getSystemPath((_a = expression.property) === null || _a === void 0 ? void 0 : _a.ref, expression.subProperties, (_b = expression.propertyLookup) === null || _b === void 0 ? void 0 : _b.ref);
+                return expandToNode `
+                    context.object.${systemPath}
+                `;
+            }
+            if (isFleetingAccess(expression)) {
+                let accessPath = (_c = expression.variable.ref) === null || _c === void 0 ? void 0 : _c.name;
+                if (expression.subProperty != undefined) {
+                    accessPath = `${accessPath}.${expression.subProperty}`;
+                }
+                return expandToNode `
+                    ${accessPath}
+                `;
+            }
+            if (isExpression(expression)) {
+                return expandToNode `
+                    ${translateExpression(entry, id, expression, preDerived, generatingProperty)}
+                `;
+            }
+            return;
+        }
+        const flavorTag = expression.body.chatExp.find(x => x.type == "flavor");
+        const shouldShowEffects = expression.body.chatExp.some(x => isAccess(x) && x.access === "Effects");
+        return expandToNode `
+            // Create the chat message
+            const ${expression.name}Description = context.object.description ?? context.object.system.description;
+            const ${expression.name}Context = { 
+                cssClass: "${id} ${toMachineIdentifier(expression.name)}",
+                document: context.object,
+                description: ${expression.name}Description,
+                hasDescription: ${expression.name}Description!= "",
+                hasEffects: ${shouldShowEffects},
+                parts: [
+                    ${joinToNode(expression.body.chatExp.filter(x => x.type != "tag"), (expression) => translateChatBodyExpression(expression), { appendNewLineIfNotEmpty: true })}
+                ],
+                tags: [
+                    ${joinToNode(expression.body.chatExp.filter(x => x.type == "tag"), (expression) => translateChatBodyExpression(expression), { appendNewLineIfNotEmpty: true })}
+                ]
+            };
+            const ${expression.name}Content = await renderTemplate("systems/${id}/system/templates/chat/standard-card.hbs", ${expression.name}Context);
+            const ${expression.name}ChatFlavor = (system) => {
+                return ${flavorTag != undefined ? translateChatBodyExpressionForFlavor(flavorTag) : `""`}
+            }
+            await ChatMessage.create({
+                user: game.user._id,
+                speaker: ChatMessage.getSpeaker(),
+                content: ${expression.name}Content,
+                flavor: ${expression.name}ChatFlavor(context.object.system),
+                type: ${expression.name}Context.parts.find(x => x.isRoll) ? null : CONST.CHAT_MESSAGE_STYLES.IC,
+                rolls: Array.from(${expression.name}Context.parts.filter(x => x.isRoll).map(x => x.value)),
+            });
+        `;
+    }
+    if (isRoll(expression) || isDamageRoll(expression)) {
+        console.log("Translating Roll Expression");
+        function translateDiceParts(expression, noLabels = false) {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32;
+            console.log("Translating Dice Part: ", expression.$type);
+            if (isLiteral(expression)) {
+                if (typeof expression.val == "string") {
+                    return expandToNode `
+                        "${expression.val}"
+                    `;
+                }
+                return expandToNode `
+                    "${expression.val}"
+                `;
+            }
+            if (isRef(expression)) {
+                // If string or number, return the value
+                if (typeof expression.val == "string" || typeof expression.val == "number") {
+                    return expandToNode `
+                        "${expression.val}"
+                    `;
+                }
+                if (expression.val.ref == undefined) {
+                    return;
+                }
+                if (expression.subProperties != undefined && expression.subProperties.length > 0) {
+                    const subLabel = noLabels ? "" : `[${humanize(expression.subProperties[0])}]`;
+                    return expandToNode `
+                        "@${(_a = expression.val.ref) === null || _a === void 0 ? void 0 : _a.name}${expression.subProperties[0].toLowerCase()}${subLabel}"
+                    `;
+                }
+                console.log("Ref:", `${expression.val.$refText}`);
+                if (IntelligentSystemDesignLanguageTerminals.DICE.test(`${expression.val}`)) {
+                    return expandToNode `
+                        "${expression.val}"
+                    `;
+                }
+                const refLabel = noLabels ? "" : `[${humanize((_c = (_b = expression.val.ref) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : expression.val.$refText)}]`;
+                return expandToNode `
+                    "@${(_f = (_e = (_d = expression.val.ref) === null || _d === void 0 ? void 0 : _d.name) === null || _e === void 0 ? void 0 : _e.toLowerCase()) !== null && _f !== void 0 ? _f : expression.val.$refText}${refLabel}"
+                `;
+            }
+            if (isParentAccess(expression)) {
+                let path = (_j = (_h = (_g = expression.property) === null || _g === void 0 ? void 0 : _g.ref) === null || _h === void 0 ? void 0 : _h.name) !== null && _j !== void 0 ? _j : "";
+                let label = humanize((_m = (_l = (_k = expression.property) === null || _k === void 0 ? void 0 : _k.ref) === null || _l === void 0 ? void 0 : _l.name) !== null && _m !== void 0 ? _m : "");
+                const document = getParentDocument(expression);
+                if (document != undefined) {
+                    path = `${document.name.toLowerCase()}${path}`;
+                    label = `${humanize(document.name)} ${label}`;
+                }
+                // else if ( expression.propertyLookup != undefined ) {
+                //     path = `${path}${expression.propertyLookup.ref?.name.toLowerCase()}`;
+                //     label = `${label} \${context.object.system.${expression.propertyLookup.ref?.name.toLowerCase()}\}`;
+                // }
+                else {
+                    path = `${path}${(_p = (_o = expression.property) === null || _o === void 0 ? void 0 : _o.ref) === null || _p === void 0 ? void 0 : _p.name.toLowerCase()}`;
+                    label = `${label} ${humanize((_s = (_r = (_q = expression.property) === null || _q === void 0 ? void 0 : _q.ref) === null || _r === void 0 ? void 0 : _r.name) !== null && _s !== void 0 ? _s : "")}`;
+                }
+                for (const subProperty of (_t = expression.subProperties) !== null && _t !== void 0 ? _t : []) {
+                    path = `${path}${subProperty}`;
+                    label = `${label} ${humanize(subProperty)}`;
+                }
+                label = label.trim();
+                const parentLabelSuffix = noLabels ? "" : `[${label}]`;
+                return expandToNode `
+                    \`@${path.replaceAll(".", "").toLowerCase()}${parentLabelSuffix}\`
+                `;
+            }
+            if (isTargetAccess(expression)) {
+                let path = (_w = (_v = (_u = expression.property) === null || _u === void 0 ? void 0 : _u.ref) === null || _v === void 0 ? void 0 : _v.name) !== null && _w !== void 0 ? _w : "";
+                let label = humanize((_z = (_y = (_x = expression.property) === null || _x === void 0 ? void 0 : _x.ref) === null || _y === void 0 ? void 0 : _y.name) !== null && _z !== void 0 ? _z : "");
+                const document = getTargetDocument(expression);
+                if (document != undefined) {
+                    path = `${document.name.toLowerCase()}${path}`;
+                    label = `${humanize(document.name)} ${label}`;
+                }
+                // else if ( expression.propertyLookup != undefined ) {
+                //     path = `${path}${expression.propertyLookup.ref?.name.toLowerCase()}`;
+                //     label = `${label} \${context.object.system.${expression.propertyLookup.ref?.name.toLowerCase()}\}`;
+                // }
+                else {
+                    path = `${path}${(_1 = (_0 = expression.property) === null || _0 === void 0 ? void 0 : _0.ref) === null || _1 === void 0 ? void 0 : _1.name.toLowerCase()}`;
+                    label = `${label} ${humanize((_4 = (_3 = (_2 = expression.property) === null || _2 === void 0 ? void 0 : _2.ref) === null || _3 === void 0 ? void 0 : _3.name) !== null && _4 !== void 0 ? _4 : "")}`;
+                }
+                for (const subProperty of (_5 = expression.subProperties) !== null && _5 !== void 0 ? _5 : []) {
+                    path = `${path}${subProperty}`;
+                    label = `${label} ${humanize(subProperty)}`;
+                }
+                label = label.trim();
+                const targetLabelSuffix = noLabels ? "" : `[${label}]`;
+                return expandToNode `
+                    \`@${path.replaceAll(".", "").toLowerCase()}${targetLabelSuffix}\`
+                `;
+            }
+            if (isAccess(expression)) {
+                let path = (_13 = (_9 = (_8 = (_7 = (_6 = expression.property) === null || _6 === void 0 ? void 0 : _6.ref) === null || _7 === void 0 ? void 0 : _7.name) === null || _8 === void 0 ? void 0 : _8.toLowerCase()) !== null && _9 !== void 0 ? _9 : (_12 = (_11 = (_10 = expression.propertyLookup) === null || _10 === void 0 ? void 0 : _10.ref) === null || _11 === void 0 ? void 0 : _11.name) === null || _12 === void 0 ? void 0 : _12.toLowerCase()) !== null && _13 !== void 0 ? _13 : "";
+                let label = humanize((_19 = (_16 = (_15 = (_14 = expression.property) === null || _14 === void 0 ? void 0 : _14.ref) === null || _15 === void 0 ? void 0 : _15.name) !== null && _16 !== void 0 ? _16 : (_18 = (_17 = expression.propertyLookup) === null || _17 === void 0 ? void 0 : _17.ref) === null || _18 === void 0 ? void 0 : _18.name) !== null && _19 !== void 0 ? _19 : "");
+                // if (isDieField(expression.property?.ref)) {
+                //     return expandToNode`
+                //         \'@${path.replaceAll(".", "")}\'
+                //     `;
+                // }
+                // Special handling for document choices - expand into individual terms
+                if (expression.property && isDocumentChoicesExp(expression.property.ref) && expression.subProperties && expression.subProperties.length > 0) {
+                    const choicesFieldName = expression.property.ref.name.toLowerCase();
+                    const subPropertyName = expression.subProperties[0].toLowerCase();
+                    const subPropertyLabel = humanize(expression.subProperties[0]);
+                    // Generate dynamic expansion for each document in the choices array
+                    return expandToNode `
+                        context.object.system.${choicesFieldName}.map((doc, index) => {
+                            if (!doc || !doc.system) return '';
+                            return '@' + doc.uuid.replace(/[^a-zA-Z0-9]/g, '').toLowerCase() + '${subPropertyName}[' + doc.name + ' ${subPropertyLabel}]';
+                        }).filter(Boolean).join(' + ')
+                    `;
+                }
+                if (isParentPropertyRefExp((_20 = expression.property) === null || _20 === void 0 ? void 0 : _20.ref)) {
+                    label = `${label} - \${context.object.system.${(_22 = (_21 = expression.property) === null || _21 === void 0 ? void 0 : _21.ref) === null || _22 === void 0 ? void 0 : _22.name.toLowerCase()}.replace("system.", "").replaceAll(".", " ").titleCase()\}`;
+                }
+                else if (isSelfPropertyRefExp((_23 = expression.property) === null || _23 === void 0 ? void 0 : _23.ref)) {
+                    label = `${label} - \${context.object.system.${(_25 = (_24 = expression.property) === null || _24 === void 0 ? void 0 : _24.ref) === null || _25 === void 0 ? void 0 : _25.name.toLowerCase()}.replace("system.", "").replaceAll(".", " ").titleCase()\}`;
+                }
+                else {
+                    for (const subProperty of (_26 = expression.subProperties) !== null && _26 !== void 0 ? _26 : []) {
+                        path = `${path}.${subProperty}`;
+                        label = `${label} ${humanize(subProperty)}`;
+                    }
+                }
+                console.log("Access:", path, label);
+                const accessLabelSuffix = noLabels ? "" : `[${label}]`;
+                return expandToNode `
+                    \`@${path.replaceAll(".", "").toLowerCase()}${accessLabelSuffix}\`
+                `;
+            }
+            if (isFleetingAccess(expression)) {
+                // If this is a roll expression, just output it directly
+                if (isRoll((_27 = expression.variable.ref) === null || _27 === void 0 ? void 0 : _27.value)) {
+                    return expandToNode `
+                        ${(_28 = expression.variable.ref) === null || _28 === void 0 ? void 0 : _28.name}
+                    `;
+                }
+                let path = (_30 = (_29 = expression.variable.ref) === null || _29 === void 0 ? void 0 : _29.name) !== null && _30 !== void 0 ? _30 : "";
+                let label = humanize((_32 = (_31 = expression.variable.ref) === null || _31 === void 0 ? void 0 : _31.name) !== null && _32 !== void 0 ? _32 : "");
+                if (expression.subProperty != undefined) {
+                    path = `${path}.${expression.subProperty}`;
+                    label = `${label} ${humanize(expression.subProperty)}`;
+                }
+                const fleetingLabelSuffix = noLabels ? "" : `[${label}]`;
+                return expandToNode `
+                    \`@${path.replaceAll(".", "").toLowerCase()}${fleetingLabelSuffix}\`
+                `;
+            }
+            if (isBinaryExpression(expression)) {
+                return expandToNode `
+                    ${translateDiceParts(expression.e1, noLabels)} + "${expression.op}" + ${translateDiceParts(expression.e2, noLabels)}
+                `;
+            }
+            if (isGroup(expression)) {
+                return expandToNode `
+                    "(" + ${translateDiceParts(expression.ge, noLabels)} + ")"
+                `;
+            }
+            return;
+        }
+        function translateDisplayFormula(expression) {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+            if (isLiteral(expression)) {
+                return `${expression.val}`;
+            }
+            if (isGroup(expression)) {
+                const inner = translateDisplayFormula(expression.ge);
+                return inner != null ? `(${inner})` : undefined;
+            }
+            if (isBinaryExpression(expression)) {
+                const left = translateDisplayFormula(expression.e1);
+                const right = translateDisplayFormula(expression.e2);
+                return left != null && right != null ? `${left} ${expression.op} ${right}` : undefined;
+            }
+            if (isAccess(expression)) {
+                if (isParentPropertyRefExp((_a = expression.property) === null || _a === void 0 ? void 0 : _a.ref) || isSelfPropertyRefExp((_b = expression.property) === null || _b === void 0 ? void 0 : _b.ref)) {
+                    return undefined;
+                }
+                let label = humanize((_h = (_e = (_d = (_c = expression.property) === null || _c === void 0 ? void 0 : _c.ref) === null || _d === void 0 ? void 0 : _d.name) !== null && _e !== void 0 ? _e : (_g = (_f = expression.propertyLookup) === null || _f === void 0 ? void 0 : _f.ref) === null || _g === void 0 ? void 0 : _g.name) !== null && _h !== void 0 ? _h : "");
+                for (const sub of (_j = expression.subProperties) !== null && _j !== void 0 ? _j : []) {
+                    label += ` ${humanize(sub)}`;
+                }
+                return label.trim();
+            }
+            if (isParentAccess(expression)) {
+                return humanize((_m = (_l = (_k = expression.property) === null || _k === void 0 ? void 0 : _k.ref) === null || _l === void 0 ? void 0 : _l.name) !== null && _m !== void 0 ? _m : "");
+            }
+            if (isTargetAccess(expression)) {
+                return humanize((_q = (_p = (_o = expression.property) === null || _o === void 0 ? void 0 : _o.ref) === null || _p === void 0 ? void 0 : _p.name) !== null && _q !== void 0 ? _q : "");
+            }
+            if (isFleetingAccess(expression)) {
+                return humanize((_s = (_r = expression.variable.ref) === null || _r === void 0 ? void 0 : _r.name) !== null && _s !== void 0 ? _s : "");
+            }
+            return undefined;
+        }
+        function translateDiceData(expression) {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52;
+            console.log("Translating Dice Data: ", expression.$type);
+            if (isParentAccess(expression)) {
+                let path = "context.object.parent.system";
+                let label = (_c = (_b = (_a = expression.property) === null || _a === void 0 ? void 0 : _a.ref) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : "";
+                console.log("Parent Access:", (_e = (_d = expression.property) === null || _d === void 0 ? void 0 : _d.ref) === null || _e === void 0 ? void 0 : _e.name);
+                const document = getParentDocument(expression);
+                if (document != undefined) {
+                    path = `${path}.${(_h = (_g = (_f = expression.property) === null || _f === void 0 ? void 0 : _f.ref) === null || _g === void 0 ? void 0 : _g.name) === null || _h === void 0 ? void 0 : _h.toLowerCase()}`;
+                    label = `${humanize(document.name)}.${label}`;
+                }
+                else {
+                    path = `${path}.${(_l = (_k = (_j = expression.property) === null || _j === void 0 ? void 0 : _j.ref) === null || _k === void 0 ? void 0 : _k.name) === null || _l === void 0 ? void 0 : _l.toLowerCase()}`;
+                    label = `${label}.${expression.property}`;
+                }
+                for (const subProperty of (_m = expression.subProperties) !== null && _m !== void 0 ? _m : []) {
+                    path = `${path}.${subProperty}`;
+                    label = `${label}.${subProperty}`;
+                }
+                return expandToNode `
+                    "${label.replaceAll(".", "").toLowerCase()}": ${path}
+                `;
+            }
+            if (isTargetAccess(expression)) {
+                let path = "context.target.system";
+                let label = (_q = (_p = (_o = expression.property) === null || _o === void 0 ? void 0 : _o.ref) === null || _p === void 0 ? void 0 : _p.name) !== null && _q !== void 0 ? _q : "";
+                console.log("Target Access:", (_s = (_r = expression.property) === null || _r === void 0 ? void 0 : _r.ref) === null || _s === void 0 ? void 0 : _s.name);
+                const document = getTargetDocument(expression);
+                if (document != undefined) {
+                    path = `${path}.${(_v = (_u = (_t = expression.property) === null || _t === void 0 ? void 0 : _t.ref) === null || _u === void 0 ? void 0 : _u.name) === null || _v === void 0 ? void 0 : _v.toLowerCase()}`;
+                    label = `${humanize(document.name)}.${label}`;
+                }
+                else {
+                    path = `${path}.${(_y = (_x = (_w = expression.property) === null || _w === void 0 ? void 0 : _w.ref) === null || _x === void 0 ? void 0 : _x.name) === null || _y === void 0 ? void 0 : _y.toLowerCase()}`;
+                    label = `${label}.${expression.property}`;
+                }
+                for (const subProperty of (_z = expression.subProperties) !== null && _z !== void 0 ? _z : []) {
+                    path = `${path}.${subProperty}`;
+                    label = `${label}.${subProperty}`;
+                }
+                return expandToNode `
+                    "${label.replaceAll(".", "").toLowerCase()}": ${path}
+                `;
+            }
+            if (isAccess(expression)) {
+                let path = "context.object.system";
+                let label = "";
+                console.log("Access:", (_1 = (_0 = expression.property) === null || _0 === void 0 ? void 0 : _0.ref) === null || _1 === void 0 ? void 0 : _1.name, (_3 = (_2 = expression.propertyLookup) === null || _2 === void 0 ? void 0 : _2.ref) === null || _3 === void 0 ? void 0 : _3.name);
+                if (expression.propertyLookup != undefined) {
+                    path = `${path}[context.object.${getSystemPath(expression.propertyLookup.ref)}.toLowerCase()]`;
+                    label = `${(_4 = expression.propertyLookup.ref) === null || _4 === void 0 ? void 0 : _4.name}`;
+                }
+                else if (isParentPropertyRefExp((_5 = expression.property) === null || _5 === void 0 ? void 0 : _5.ref)) {
+                    path = `${path}.${(_7 = (_6 = expression.property) === null || _6 === void 0 ? void 0 : _6.ref) === null || _7 === void 0 ? void 0 : _7.name.toLowerCase()}`;
+                    label = `${(_9 = (_8 = expression.property) === null || _8 === void 0 ? void 0 : _8.ref) === null || _9 === void 0 ? void 0 : _9.name}`;
+                    let subProperty = "";
+                    if (((_10 = expression.property) === null || _10 === void 0 ? void 0 : _10.ref.propertyType) == "resource" || ((_11 = expression.property) === null || _11 === void 0 ? void 0 : _11.ref.propertyType) == "tracker" || ((_12 = expression.property) === null || _12 === void 0 ? void 0 : _12.ref.propertyType) == "choice"
+                        && (expression.subProperties == undefined || expression.subProperties.length == 0 || expression.subProperties[0] !== "value")) {
+                        subProperty = "?.value";
+                    }
+                    if (((_13 = expression.property) === null || _13 === void 0 ? void 0 : _13.ref.propertyType) == "attribute" && (expression.subProperties == undefined || expression.subProperties.length == 0 || expression.subProperties[0] !== "mod")) {
+                        subProperty = "?.mod";
+                    }
+                    console.log(label, path);
+                    return expandToNode `
+                        "${label.replaceAll(".", "").replaceAll(" ", "").toLowerCase()}": foundry.utils.getProperty(context.object.parent, ${path}.toLowerCase())${subProperty}
+                    `;
+                }
+                else if (isSelfPropertyRefExp((_14 = expression.property) === null || _14 === void 0 ? void 0 : _14.ref)) {
+                    // For self property references, we dynamically resolve the property path
+                    let selfPropertyPath = `context.object.system.${(_16 = (_15 = expression.property) === null || _15 === void 0 ? void 0 : _15.ref) === null || _16 === void 0 ? void 0 : _16.name.toLowerCase()}`;
+                    let subProperty = "";
+                    label = `${(_18 = (_17 = expression.property) === null || _17 === void 0 ? void 0 : _17.ref) === null || _18 === void 0 ? void 0 : _18.name}`;
+                    if (((_19 = expression.property) === null || _19 === void 0 ? void 0 : _19.ref.propertyType) == "resource" || ((_20 = expression.property) === null || _20 === void 0 ? void 0 : _20.ref.propertyType) == "tracker" || ((_21 = expression.property) === null || _21 === void 0 ? void 0 : _21.ref.propertyType) == "choice"
+                        && (expression.subProperties == undefined || expression.subProperties.length == 0 || expression.subProperties[0] !== "value")) {
+                        subProperty = "?.value";
+                    }
+                    if (((_22 = expression.property) === null || _22 === void 0 ? void 0 : _22.ref.propertyType) == "attribute" && (expression.subProperties == undefined || expression.subProperties.length == 0 || expression.subProperties[0] !== "mod")) {
+                        subProperty = "?.mod";
+                    }
+                    console.log(label, selfPropertyPath);
+                    return expandToNode `
+                        "${label.replaceAll(".", "").replaceAll(" ", "").toLowerCase()}": foundry.utils.getProperty(context.object, "system." + ${selfPropertyPath}.toLowerCase())${subProperty}
+                    `;
+                }
+                else {
+                    // Special handling for document choices - expand into individual data entries
+                    if (expression.property && isDocumentChoicesExp(expression.property.ref) && expression.subProperties && expression.subProperties.length > 0) {
+                        const choicesFieldName = expression.property.ref.name.toLowerCase();
+                        const subPropertyName = expression.subProperties[0].toLowerCase();
+                        // Generate data for each document in the choices array
+                        return expandToNode `
+                            ...Object.fromEntries(context.object.system.${choicesFieldName}.map((doc, index) => {
+                                if (!doc || !doc.system) return null;
+                                
+                                // Determine the accessor based on property type
+                                let accessor = '.${subPropertyName}';
+                                ${isResourceExp((_23 = expression.property) === null || _23 === void 0 ? void 0 : _23.ref) || isTrackerExp((_24 = expression.property) === null || _24 === void 0 ? void 0 : _24.ref) ? `
+                                if (doc.system.${subPropertyName} && typeof doc.system.${subPropertyName} === 'object' && 'value' in doc.system.${subPropertyName}) {
+                                    accessor = '.${subPropertyName}.value';
+                                }` : ''}
+                                ${isAttributeExp((_25 = expression.property) === null || _25 === void 0 ? void 0 : _25.ref) ? `
+                                if (doc.system.${subPropertyName} && typeof doc.system.${subPropertyName} === 'object' && 'mod' in doc.system.${subPropertyName}) {
+                                    accessor = '.${subPropertyName}.mod';
+                                }` : ''}
+                                
+                                const key = doc.uuid.replace(/[^a-zA-Z0-9]/g, '').toLowerCase() + '${subPropertyName}';
+                                const value = foundry.utils.getProperty(doc, 'system' + accessor) ?? 0;
+                                return [key, value];
+                            }).filter(Boolean))
+                        `;
+                    }
+                    path = `${path}.${(_27 = (_26 = expression.property) === null || _26 === void 0 ? void 0 : _26.ref) === null || _27 === void 0 ? void 0 : _27.name.toLowerCase()}`;
+                    label = `${(_29 = (_28 = expression.property) === null || _28 === void 0 ? void 0 : _28.ref) === null || _29 === void 0 ? void 0 : _29.name}`;
+                    if ((isResourceExp((_30 = expression.property) === null || _30 === void 0 ? void 0 : _30.ref) || isTrackerExp((_31 = expression.property) === null || _31 === void 0 ? void 0 : _31.ref) || isStringChoiceField((_32 = expression.property) === null || _32 === void 0 ? void 0 : _32.ref))
+                        && (expression.subProperties == undefined || expression.subProperties.length == 0 || expression.subProperties[0] == "value")) {
+                        path = `${path}.value`;
+                    }
+                    if (isDiceField((_33 = expression.property) === null || _33 === void 0 ? void 0 : _33.ref) && (expression.subProperties == undefined || expression.subProperties.length == 0)) {
+                        // For dice fields without subproperties, use the dice value
+                        path = `${path}.value`;
+                    }
+                    if (isDieField((_34 = expression.property) === null || _34 === void 0 ? void 0 : _34.ref)) {
+                        // For die fields, the value is just the die size (e.g., "d6"), we want to use the field name as label
+                        // Don't change the path, just ensure the label is the field name
+                    }
+                    if (isAttributeExp((_35 = expression.property) === null || _35 === void 0 ? void 0 : _35.ref) && (expression.subProperties == undefined || expression.subProperties.length == 0 || expression.subProperties[0] !== "mod")) {
+                        path = `${path}.mod`;
+                    }
+                }
+                for (const subProperty of (_36 = expression.subProperties) !== null && _36 !== void 0 ? _36 : []) {
+                    path = `${path}.${subProperty}`;
+                    label = `${label} ${humanize(subProperty)}`;
+                }
+                console.log(label, path);
+                return expandToNode `
+                    "${label.replaceAll(".", "").replaceAll(" ", "").toLowerCase()}": ${path} ?? 0
+                `;
+            }
+            if (isFleetingAccess(expression)) {
+                console.log("Fleeting Access:", (_37 = expression.variable.ref) === null || _37 === void 0 ? void 0 : _37.name);
+                // If this is a roll expression, just skip it
+                if (isRoll((_38 = expression.variable.ref) === null || _38 === void 0 ? void 0 : _38.value)) {
+                    return;
+                }
+                let path = (_39 = expression.variable.ref) === null || _39 === void 0 ? void 0 : _39.name;
+                if (expression.subProperty != undefined) {
+                    path = `${path}.${expression.subProperty}`;
+                }
+                if (expression.arrayAccess != undefined) {
+                    console.log("Array Access:", expression.arrayAccess.$type);
+                    let accessExp = translateExpression(entry, id, expression.arrayAccess, preDerived, generatingProperty);
+                    path = `${path}[${(_40 = accessExp === null || accessExp === void 0 ? void 0 : accessExp.contents) === null || _40 === void 0 ? void 0 : _40.toString()}]`;
+                }
+                const label = (_42 = (_41 = expression.variable.ref) === null || _41 === void 0 ? void 0 : _41.name.toLowerCase()) !== null && _42 !== void 0 ? _42 : "";
+                console.log(label, path);
+                return expandToNode `
+                    "${label}": ${path} ?? 0
+                `;
+            }
+            // if (isVariableAccess(expression)) {
+            //     console.log("Variable Access:", expression.name);
+            //     if (isParameter(expression)) {
+            //         console.log("Parameter:", expression.name);
+            //         return expandToNode`
+            //             "${expression.name}": ${expression.name}
+            //         `;
+            //     }
+            //     if (isVariableExpression(expression)) {
+            //         console.log("Variable Expression:", expression.name);
+            //         if (isExpression(expression.value)) {
+            //             console.log("Expression:", expression.name);
+            //             return translateDiceData(expression.value);
+            //         }
+            //         if (isPrompt(expression.value)) {
+            //             console.log("Prompt:", expression.name);
+            //             return expandToNode`
+            //                 "${expression.name}": ${expression.name}
+            //             `;
+            //         }
+            //     }
+            //     throw new Error("Variable Access not implemented");
+            // }
+            if (isRef(expression)) {
+                console.log("Ref:", (_43 = expression.val.ref) === null || _43 === void 0 ? void 0 : _43.name);
+                // If string or number, return the value
+                if (typeof expression.val == "string" || typeof expression.val == "number") {
+                    console.log(expression.val);
+                    return expandToNode `
+                        "${expression.val}": ${expression.val}
+                    `;
+                }
+                if (expression.val.ref == undefined) {
+                    return;
+                }
+                if (expression.subProperties != undefined && expression.subProperties.length > 0) {
+                    return expandToNode `
+                        "${(_44 = expression.val.ref) === null || _44 === void 0 ? void 0 : _44.name.toLowerCase()}${expression.subProperties[0].toLowerCase()}": ${(_45 = expression.val.ref) === null || _45 === void 0 ? void 0 : _45.name}.${expression.subProperties[0].toLowerCase()} ?? 0
+                    `;
+                }
+                console.log((_46 = expression.val.ref) === null || _46 === void 0 ? void 0 : _46.name, (_47 = expression.val.ref) === null || _47 === void 0 ? void 0 : _47.$type);
+                return expandToNode `
+                    "${(_50 = (_49 = (_48 = expression.val.ref) === null || _48 === void 0 ? void 0 : _48.name) === null || _49 === void 0 ? void 0 : _49.toLowerCase()) !== null && _50 !== void 0 ? _50 : expression.val.$refText}": ${(_52 = (_51 = expression.val.ref) === null || _51 === void 0 ? void 0 : _51.name) !== null && _52 !== void 0 ? _52 : expression.val.$refText} ?? 0
+                `;
+            }
+            if (isBinaryExpression(expression)) {
+                const expressions = [expression.e1, expression.e2];
+                return expandToNode `
+                    ${joinToNode(expressions, e => translateDiceData(e), { separator: ", " })}
+                `;
+            }
+            if (isGroup(expression)) {
+                return expandToNode `
+                    ${translateDiceData(expression.ge)}
+                `;
+            }
+            return undefined;
+        }
+        if (isDamageRoll(expression)) {
+            const rollParam = expression.params.find(isRollParam);
+            const rollExpression = rollParam.value;
+            const typeParam = expression.params.find(isTypeParam);
+            let damageTypeDataAccess = '';
+            if (isAccess(typeParam.value)) {
+                damageTypeDataAccess = `context.object.system.${(_j = (_h = (_g = typeParam.value) === null || _g === void 0 ? void 0 : _g.property) === null || _h === void 0 ? void 0 : _h.ref) === null || _j === void 0 ? void 0 : _j.name.toLowerCase()}`;
+            }
+            else if (isParentAccess(typeParam.value)) {
+                // Handle parent.SomeDamageType
+                const parentPath = (_o = (_m = (_l = (_k = typeParam.value.property) === null || _k === void 0 ? void 0 : _k.ref) === null || _l === void 0 ? void 0 : _l.name) === null || _m === void 0 ? void 0 : _m.toLowerCase()) !== null && _o !== void 0 ? _o : '';
+                damageTypeDataAccess = `context.object.parent?.system.${parentPath}`;
+            }
+            return expandToNode `
+                await new ${entry.config.name}DamageRoll(
+                    ${joinToNode(rollExpression.parts, e => translateDiceParts(e), { separator: " + " })},
+                     {${joinToNode(rollExpression.parts, e => translateDiceData(e), { separator: ", " })}, 
+                     actor: context.actor},
+                     { type: ${damageTypeDataAccess} }
+                ).roll()
+            `;
+        }
+        const rollParts = expression.parts;
+        const displayFormulaParts = rollParts.map(e => translateDisplayFormula(e));
+        const displayFormula = displayFormulaParts.every(p => p != null)
+            ? displayFormulaParts.join("")
+            : undefined;
+        return expandToNode `
+            Object.assign(await new ${entry.config.name}Roll(${joinToNode(rollParts, (e, idx) => {
+            const nextPart = rollParts[idx + 1];
+            const nextIsDice = nextPart != null && isLiteral(nextPart) && typeof nextPart.val === 'string' && IntelligentSystemDesignLanguageTerminals.DICE.test(nextPart.val);
+            return translateDiceParts(e, nextIsDice);
+        }, { separator: " + " })}, {${joinToNode(rollParts, e => translateDiceData(e), { separator: ", " })}}).roll(), ${displayFormula != null ? `{_displayFormula: "${displayFormula}"}` : '{}'})
+        `;
+    }
+    if (isSelfMethod(expression)) {
+        switch (expression.method) {
+            case "delete()": {
+                return expandToNode `
+                    await document.delete();
+                    selfDeleted = true;
+                `;
+            }
+            case "update()": {
+                return expandToNode `
+                    if (selfDeleted) {
+                        ui.notifications.error("Cannot update a deleted document");
+                    }
+                    else if (Object.keys(update).length > 0) {
+                        await document.update(update);
+                        context.object.system = document.system;
+                    }
+                    update = {};
+                `.appendNewLine();
+            }
+            default: {
+                throw new Error("Unknown method called on self");
+            }
+        }
+    }
+    if (isArrayExpression(expression)) {
+        return expandToNode `
+            [${joinToNode(expression.items, e => translateExpression(entry, id, e, preDerived, generatingProperty), { separator: ", " })}]
+        `;
+    }
+    if (isEach(expression)) {
+        //const expressionCollection = expression.collection;
+        const eachExpression = expression;
+        const collection = translateExpression(entry, id, expression.collection, preDerived, generatingProperty);
+        if (isNumberRange(expression.collection)) {
+            return expandToNode `
+            for (const ${translateExpression(entry, id, expression.var, preDerived, generatingProperty)} of ${collection} ?? []) {
+                ${translateBodyExpressionToJavascript(entry, id, expression.method.body, preDerived, generatingProperty)}
+            }
+            `;
+        }
+        let updateExpression;
+        // If the body expression had a variable assignment against the collection, we need to update the collection
+        if (expression.method.body.some(x => {
+            return isVariableAssignment(x) && x.variable.ref == eachExpression.var;
+        })) {
+            if (isParentAccess(expression.collection)) {
+                updateExpression = expandToNode `
+            parentEmbeddedUpdate["${getSystemPath((_p = expression.collection.property) === null || _p === void 0 ? void 0 : _p.ref, [], undefined, false)}"] = ${collection};
+            `;
+            }
+            else if (isTargetAccess(expression.collection)) {
+                updateExpression = expandToNode `
+            targetEmbeddedUpdate["${getSystemPath((_q = expression.collection.property) === null || _q === void 0 ? void 0 : _q.ref, [], undefined, false)}"] = ${collection};
+            `;
+            }
+            else {
+                updateExpression = expandToNode `
+            embeddedUpdate["${collection}"] = ${collection};
+            `;
+            }
+        }
+        return expandToNode `
+            for (const ${translateExpression(entry, id, expression.var, preDerived, generatingProperty)} of ${collection} ?? []) {
+            ${translateBodyExpressionToJavascript(entry, id, expression.method.body, preDerived, generatingProperty)}
+            }
+            ${updateExpression}
+        `;
+    }
+    if (isPrompt(expression)) {
+        const labelParam = expression.params.find(x => isLabelParam(x));
+        const title = (_r = labelParam === null || labelParam === void 0 ? void 0 : labelParam.value) !== null && _r !== void 0 ? _r : "Prompt";
+        const targetParam = expression.params.find(x => isTargetParam(x));
+        const target = (_s = targetParam === null || targetParam === void 0 ? void 0 : targetParam.value) !== null && _s !== void 0 ? _s : "self";
+        const locationParam = expression.params.find(x => isLocationParam(x));
+        const widthParam = expression.params.find(x => isWidthParam(x));
+        const heightParam = expression.params.find(x => isHeightParam(x));
+        const timeLimitParam = expression.params.find(x => isTimeLimitParam(x));
+        // const iconParam = expression.params.find(x => isIconParam(x));
+        // const icon = iconParam?.value ?? "fa-solid fa-comment-dots";
+        function translateDialogBody(expression) {
+            if (isNumberExp(expression)) {
+                return expandToNode `
+                    <div class="form-group">
+                        <label>${humanize(expression.name)}</label>
+                        <input type="number" name="${expression.name.toLowerCase()}" value="0" />
+                    </div>
+                `;
+            }
+            if (isBooleanExp(expression)) {
+                return expandToNode `
+                    <div class="form-group">
+                        <label>${humanize(expression.name)}</label>
+                        <input type="checkbox" name="${expression.name.toLowerCase()}" />
+                    </div>
+                `;
+            }
+            if (isStringExp(expression)) {
+                return expandToNode `
+                    <div class="form-group">
+                        <label>${humanize(expression.name)}</label>
+                        <input type="text" name="${expression.name.toLowerCase()}" />
+                    </div>
+                `;
+            }
+            return undefined;
+        }
+        let durationExpression;
+        if (timeLimitParam != undefined) {
+            let durationMod = "";
+            const duration = translateExpression(entry, id, timeLimitParam.value, preDerived, generatingProperty);
+            let units = (_t = timeLimitParam.unit) !== null && _t !== void 0 ? _t : "ms";
+            if (units === "seconds") {
+                durationMod = ` * 1000`;
+            }
+            else if (units === "minutes") {
+                durationMod = ` * 60 * 1000`;
+            }
+            durationExpression = expandToNode `
+                ${duration}${durationMod}
+            `;
+        }
+        if (target == "gm") {
+            return expandToNode `
+                await new Promise((resolve, reject) => {
+
+                    const firstGm = game.users.find(u => u.isGM && u.active);
+                    const uuid = foundry.utils.randomID();
+
+                    // Setup a listener that will wait for this response
+                    game.socket.on("system.${id}", (data) => {
+                        if (data.type != "promptResponse" || data.uuid != uuid) return;
+
+                        // Resolve the promise with the data
+                        resolve(data.data);
+                    });
+
+                    game.socket.emit("system.${id}", {
+                        uuid: uuid,
+                        type: "prompt",
+                        userId: game.user.id,
+                        ${widthParam ? `width: ${widthParam.value},` : ""}
+                        ${heightParam ? `height: ${heightParam.value},` : ""}
+                        ${locationParam ? expandToNode `left: ${translateExpression(entry, id, locationParam.x, false, generatingProperty)},
+                        top: ${translateExpression(entry, id, locationParam.y, false, generatingProperty)},` : ""}
+                        ${timeLimitParam ? expandToNode `timeLimit: ${durationExpression},` : ""}
+                        title: "${title}",
+                        content: \`<form>${joinToNode(expression.body, translateDialogBody)}</form>\`,
+                    }, {recipients: [firstGm.id]});
+                });
+            `;
+        }
+        if (target == "target") {
+            return expandToNode `
+                await new Promise((resolve, reject) => {
+                    // Try to find a non-GM owner
+                    let owner = game.users.find(u => u.active && !u.isGM && u.id != game.user.id && context.target.testUserPermission(u, CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER));
+                    
+                    // If no owner is found, use the first active user
+                    if (!owner) {
+                        owner = game.users.find(u => u.active && u.id != game.user.id && context.target.testUserPermission(u, CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER));
+                    }
+                    
+                    // If still no owner is found, default to the current user
+                    if (!owner) {
+                        owner = game.user.id;
+                    }
+                    let ownerId = owner.id;
+                    const uuid = foundry.utils.randomID();
+
+                    // Setup a listener that will wait for this response
+                    game.socket.on("system.${id}", (data) => {
+                        if (data.type != "promptResponse" || data.uuid != uuid) return;
+
+                        // Resolve the promise with the data
+                        resolve(data.data);
+                    });
+
+                    game.socket.emit("system.${id}", {
+                        uuid: uuid,
+                        type: "prompt",
+                        userId: game.user.id,
+                        ${widthParam ? `width: ${widthParam.value},` : ""}
+                        ${heightParam ? `height: ${heightParam.value},` : ""}
+                        ${locationParam ? expandToNode `left: ${translateExpression(entry, id, locationParam.x, false, generatingProperty)},
+                        top: ${translateExpression(entry, id, locationParam.y, false, generatingProperty)},` : ""}
+                        ${timeLimitParam ? expandToNode `timeLimit: ${durationExpression},` : ""}
+                        title: "${title}",
+                        content: \`<form>${joinToNode(expression.body, translateDialogBody)}</form>\`,
+                    }, {recipients: [ownerId]});
+                });
+            `;
+        }
+        if (target == "user") {
+            return expandToNode `
+            await new Promise(async (resolve, reject) => {
+
+                const allActiveUsers = game.users.filter(u => u.active && u.id != game.user.id);
+                const targetedUser = await Dialog.prompt({
+                    title: "Select User",
+                    content: \`<form>
+                        <div class="form-group">
+                            <label>\${game.i18n.localize("User")}</label>
+                            <select name="user">
+                                \${allActiveUsers.map(u => \`<option value="\${u.id}">\${u.name}</option>\`).join("")}
+                            </select>
+                        </div>
+                    </form>\`,
+                    callback: (html, event) => {
+                        const formData = new FormDataExtended(html[0].querySelector("form"));
+                        return formData.get("user");
+                    },
+                    options: {
+                        classes: ["${id}", "dialog"],
+                    }
+                });
+                const uuid = foundry.utils.randomID();
+
+                // Setup a listener that will wait for this response
+                game.socket.on("system.${id}", (data) => {
+                    if (data.type != "promptResponse" || data.uuid != uuid) return;
+
+                    // Resolve the promise with the data
+                    resolve(data.data);
+                });
+
+                game.socket.emit("system.${id}", {
+                    uuid: uuid,
+                    type: "prompt",
+                    userId: game.user.id,
+                    title: "${title}",
+                    content: \`<form>${joinToNode(expression.body, translateDialogBody)}</form>\`,
+                    ${widthParam ? expandToNode `width: ${widthParam.value},` : ""}
+                    ${heightParam ? expandToNode `height: ${heightParam.value},` : ""}
+                    ${locationParam ? expandToNode `left: ${translateExpression(entry, id, locationParam.x, false, generatingProperty)},
+                    top: ${translateExpression(entry, id, locationParam.y, false, generatingProperty)},` : ""}
+                    ${timeLimitParam ? expandToNode `timeLimit: ${durationExpression},` : ""}
+                }, {recipients: [targetedUser]});
+            });
+        `;
+        }
+        return expandToNode `
+            await new Promise(async (resolve, reject) => {
+                let uuid = foundry.utils.randomID();
+                ${timeLimitParam ? expandToNode `
+                    setTimeout(() => {
+                        console.warn("Prompt timed out:", uuid);
+                        // Find the window from ui.windows with the uuid
+                        const dialog = Object.values(ui.windows).find(w => w.options.classes.includes("dialog") && w.options.classes.includes("prompt") && w.options.classes.includes(uuid));
+                        if (dialog) {
+                            dialog.close();
+                        }
+                        resolve({});
+                    }, ${durationExpression});
+                }
+                ` : ""}
+
+                Dialog.prompt({
+                    title: "${title}",
+                    content: \`<form>${joinToNode(expression.body, translateDialogBody)}</form>\`,
+                    callback: (html, event) => {
+                        // Grab the form data
+                        const formData = new FormDataExtended(html[0].querySelector("form"));
+                        const data = { system: {} };
+                        for (const [key, value] of formData.entries()) {
+                            // Translate values to more helpful ones, such as booleans and numbers
+                            if (value === "true") {
+                                data[key] = true;
+                                data.system[key] = true;
+                            }
+                            else if (value === "false") {
+                                data[key] = false;
+                                data.system[key] = false;
+                            }
+                            else if (!isNaN(value)) {
+                                data[key] = parseInt(value);
+                                data.system[key] = parseInt(value);
+                            }
+                            else {
+                                data[key] = value;
+                                data.system[key] = value;
+                            }
+                        }
+                        resolve(data);
+                        return data;
+                    },
+                    options: {
+                        classes: ["${id}", "dialog", "prompt", uuid],
+                        ${widthParam ? `width: ${widthParam.value},` : ""}
+                        ${heightParam ? `height: ${heightParam.value},` : ""}
+                        ${locationParam ? expandToNode `left: ${translateExpression(entry, id, locationParam.x, false, generatingProperty)},
+                        top: ${translateExpression(entry, id, locationParam.y, false, generatingProperty)},` : ""}
+                    }
+                });
+            });
+        `;
+    }
+    if (isMathExpression(expression)) {
+        expression = expression;
+        console.log("Translating Math Expression: ", expression.operation);
+        if (isMathEmptyExpression(expression)) {
+            return expandToNode `
+                Math.${expression.operation}()
+            `;
+        }
+        if (isMathSingleExpression(expression)) {
+            return expandToNode `
+                Math.${expression.operation}(${translateExpression(entry, id, expression.exp, preDerived, generatingProperty)})
+            `;
+        }
+        if (isMathParamExpression(expression)) {
+            return expandToNode `
+                Math.${expression.operation}(${joinToNode(expression.params, x => translateExpression(entry, id, x, preDerived, generatingProperty), { separator: ", " })})
+            `;
+        }
+        throw new Error("Unknown Math Expression type encountered while translating to JavaScript ");
+    }
+    if (isLogExpression(expression)) {
+        console.log("Translating Log Expression: ");
+        return expandToNode `
+            console.log(${joinToNode(expression.params, x => translateExpression(entry, id, x, preDerived, generatingProperty), { separator: ", " })})
+        `;
+    }
+    if (isUpdate(expression)) {
+        console.log("Translating Update Expression:");
+        let systemPath = getSystemPath((_u = expression.property) === null || _u === void 0 ? void 0 : _u.ref, expression.subProperties, (_v = expression.propertyLookup) === null || _v === void 0 ? void 0 : _v.ref, false);
+        if (isUpdateParent(expression)) {
+            return expandToNode `
+                parentUpdate["${systemPath}"] = foundry.utils.getProperty(context.object.parent, "system.${systemPath}");
+            `;
+        }
+        else if (isUpdateSelf(expression)) {
+            return expandToNode `
+                update["system.${systemPath}"] = system.${systemPath};
+            `;
+        }
+    }
+    if (isVisibilityValue(expression)) {
+        console.log("Translating Visibility Value Expression: ", expression.visibility);
+        return expandToNode `
+            "${expression.visibility}"
+        `;
+    }
+    if (isFunctionCall(expression)) {
+        console.log("Translating Function Call Expression: ");
+        // If this is a function call, we need to translate it to a JavaScript function call
+        const args = joinToNode(expression.params, (arg) => {
+            console.log("Translating Function Call Argument: ", arg.$type, generatingProperty === null || generatingProperty === void 0 ? void 0 : generatingProperty.$type);
+            return translateExpression(entry, id, arg, preDerived, generatingProperty);
+        }, { separator: ", " });
+        let accessPath = "this";
+        if (isTrackerExp(generatingProperty)) {
+            accessPath = "document.sheet";
+        }
+        return expandToNode `
+            await ${accessPath}.function_${(_w = expression.method.ref) === null || _w === void 0 ? void 0 : _w.name}(context, update, embeddedUpdate, parentUpdate, parentEmbeddedUpdate, targetUpdate, targetEmbeddedUpdate, ${args})
+        `;
+    }
+    if (isNumberRange(expression)) {
+        const from = translateExpression(entry, id, expression.start, preDerived, generatingProperty);
+        const to = translateExpression(entry, id, expression.end, preDerived, generatingProperty);
+        console.log("Translating Number Range Expression: ", from, to);
+        // Make a JS array of numbers from from to to
+        return expandToNode `
+            Array.from({length: ${to} - ${from} + 1}, (_, i) => ${from} + i)
+        `;
+    }
+    if (isWait(expression)) {
+        console.log("Translating Wait Expression: ", expression.duration);
+        const duration = translateExpression(entry, id, expression.duration, preDerived, generatingProperty);
+        const units = expression.unit;
+        let durationMod = "";
+        if (units === "seconds") {
+            durationMod = ` * 1000`;
+        }
+        else if (units === "minutes") {
+            durationMod = ` * 60 * 1000`;
+        }
+        return expandToNode `
+            await new Promise(resolve => setTimeout(resolve, ${duration}${durationMod})); // Wait for ${expression.duration} ${units}
+        `;
+    }
+    if (isPlayAudio(expression)) {
+        const fileParam = expression.params.find(x => isPlayAudioFile(x));
+        if (!fileParam)
+            return undefined;
+        const volumeParam = expression.params.find(x => isPlayAudioVolume(x));
+        const volume = (_x = volumeParam === null || volumeParam === void 0 ? void 0 : volumeParam.value) !== null && _x !== void 0 ? _x : 0.5;
+        return expandToNode `
+            await game.system.utils.playSfx(${translateExpression(entry, id, fileParam.value, false, generatingProperty)}, ${translateExpression(entry, id, volume, false, generatingProperty)});
+        `;
+    }
+    if (isCombatMethods(expression)) {
+        const method = expression.method;
+        return expandToNode `
+            if (!game.combat) {
+                return;
+            }
+            if (game.combat.testUserPermission(game.user, CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER)) {
+                ${method == "nextTurn" ? expandToNode `game.combat.nextTurn();` : ""}
+                ${method == "end" ? expandToNode `game.combat.endCombat();` : ""}
+            }
+            else {
+                await new Promise((resolve, reject) => {
+                    const firstGm = game.users.find(u => u.isGM && u.active);
+                    if (!firstGm) {
+                        ui.notifications.error("No active GM found to handle combat method request");
+                        return;
+                    }
+                    const uuid = foundry.utils.randomID();
+
+                    // Setup a listener that will wait for this response
+                    game.socket.on("system.${id}", (data) => {
+                        if (data.type != "combatResponse" || data.uuid != uuid) return;
+
+                        resolve();
+                    });
+
+                    game.socket.emit("system.${id}", {
+                        uuid: uuid,
+                        type: "combat",
+                        userId: game.user.id,
+                        method: "${method}",
+                    }, {recipients: [firstGm.id]});
+                });
+            }
+        `;
+    }
+    if (isCombatProperty(expression)) {
+        const property = expression.property;
+        if (property == "isMyTurn") {
+            return expandToNode `game.combat && game.combat.combatant?.actor?.uuid == context.actor?.uuid`;
+        }
+        else if (property == "isNotMyTurn") {
+            return expandToNode `game.combat && game.combat.combatant?.actor?.uuid != context.actor?.uuid`;
+        }
+    }
+    if (isUserProperty(expression)) {
+        const property = expression.property;
+        if (property == "isGM") {
+            return expandToNode `game.user.isGM`;
+        }
+        if (property == "name") {
+            return expandToNode `game.user.name`;
+        }
+    }
+    if (isMacroExecute(expression)) {
+        const systemPath = getSystemPath(expression.macro.ref, [], undefined, false);
+        return expandToNode `
+            await context.object.${systemPath}?.execute();
+        `;
+    }
+    console.log(expression.$type);
+    throw new Error("Unknown expression type encountered while translating to JavaScript ");
+}
+export function translateBodyExpressionToJavascript(entry, id, body, preDerived = false, generatingProperty = undefined, isVue = false) {
+    //     /**
+    //      * A method body consists of a list of Expressions that ultimately return a value.
+    //      * We need to translate this into a function that will return the value of the last expression.
+    //      *
+    //      * Example:
+    //      * {
+    //      *       return (self.Strength - 10) / 2
+    //      * }
+    //      *
+    //      * Translates to:
+    //      * (self) => {
+    //      *     return (self.system.strength - 10) / 2;
+    //      * }
+    //      *
+    //      * There might be variables. Example:
+    //      * {
+    //      *     fleeting mod = (self.system.strength - 10) / 2;
+    //      *     return mod;
+    //      * }
+    //      *
+    //      * Translates to:
+    //      * (self) => {
+    //      *    let mod = (self.system.strength - 10) / 2;
+    //      *    return mod;
+    //      * }
+    //      *
+    //      * Variables might self-modify. Example:
+    //      * {
+    //      *     fleeting mod = self.system.strength - 10;
+    //      *     mod = mod / 2;
+    //      *     return mod;
+    //      * }
+    //      *
+    //      * Translates to:
+    //      * (self) => {
+    //      *    let mod = self.system.strength - 10;
+    //      *    mod = mod / 2;
+    //      *    return mod;
+    //      * }
+    //      *
+    //      * Expressions that need to be translated:
+    //      * - MethodExpression: fleeting level = 1
+    //      * - ReturnExpression: return level
+    //      * - AssignmentExpression: level = level + 1 or level += 1 or level++
+    //      * - BinaryExpression: level + 1
+    //      * - LiteralExpression: 1
+    //      * - ReferenceExpression: level
+    //      * - GroupedExpression: (level + 1)
+    //      * - NegatedExpression: -1
+    //      */
+    return joinToNode(body, (expression) => translateExpression(entry, id, expression, preDerived, generatingProperty), { appendNewLineIfNotEmpty: true });
+}
+//# sourceMappingURL=method-generator.js.map