crankscript 0.9.2 → 0.9.3
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/package.json
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"sources":["../../../../../../../libs/cli/src/commands/TranspileCommand/components/Transpile.tsx"],"sourcesContent":["import { join } from 'node:path';\nimport React from 'react';\nimport { useMemo } from 'react';\nimport * as tstl from 'typescript-to-lua';\nimport { LuaTarget } from 'typescript-to-lua';\nimport { CheckList } from '@/cli/components/CheckList/index.js';\nimport { RootFolder } from '@/cli/constants.js';\nimport { CheckListItem } from '@/cli/types.js';\n\nconst transpile = (path: string) => {\n tstl.transpileProject(join(path, 'tsconfig.json'), {\n luaTarget: LuaTarget.Lua54,\n outDir: join(path, 'Source'),\n luaBundle: 'main.lua',\n luaBundleEntry: join(path, 'src', 'index.ts'),\n luaPlugins: [\n {\n name: join(
|
|
1
|
+
{"version":3,"sources":["../../../../../../../libs/cli/src/commands/TranspileCommand/components/Transpile.tsx"],"sourcesContent":["import { join } from 'node:path';\nimport React from 'react';\nimport { useMemo } from 'react';\nimport * as tstl from 'typescript-to-lua';\nimport { LuaTarget } from 'typescript-to-lua';\nimport { CheckList } from '@/cli/components/CheckList/index.js';\nimport { RootFolder } from '@/cli/constants.js';\nimport { CheckListItem } from '@/cli/types.js';\n\nconst transpile = (path: string) => {\n tstl.transpileProject(join(path, 'tsconfig.json'), {\n luaTarget: LuaTarget.Lua54,\n outDir: join(path, 'Source'),\n luaBundle: 'main.lua',\n luaBundleEntry: join(path, 'src', 'index.ts'),\n luaPlugins: [\n {\n name: join(RootFolder, 'assets', 'plugin.ts'),\n },\n ],\n });\n};\n\nexport const Transpile = ({ path }: { path: string }) => {\n const items = useMemo(\n () => [\n {\n waitingDescription: 'Waiting to transpile code...',\n errorDescription: 'Could not transpile code',\n runningDescription: 'Transpiling code...',\n finishedDescription: () => 'Code transpiled',\n runner: async () => {\n transpile(path);\n },\n ready: true,\n },\n ],\n []\n ) as CheckListItem<unknown>[];\n\n return <CheckList items={items} onFinish={process.exit} />;\n};\n"],"names":["join","React","useMemo","tstl","LuaTarget","CheckList","RootFolder","transpile","path","transpileProject","luaTarget","Lua54","outDir","luaBundle","luaBundleEntry","luaPlugins","name","Transpile","items","waitingDescription","errorDescription","runningDescription","finishedDescription","runner","ready","onFinish","process","exit"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,IAAI,QAAQ,YAAY;AACjC,OAAOC,WAAW,QAAQ;AAC1B,SAASC,OAAO,QAAQ,QAAQ;AAChC,YAAYC,UAAU,oBAAoB;AAC1C,SAASC,SAAS,QAAQ,oBAAoB;AAC9C,SAASC,SAAS,QAAQ,sCAAsC;AAChE,SAASC,UAAU,QAAQ,qBAAqB;AAGhD,MAAMC,YAAY,CAACC;IACfL,KAAKM,gBAAgB,CAACT,KAAKQ,MAAM,kBAAkB;QAC/CE,WAAWN,UAAUO,KAAK;QAC1BC,QAAQZ,KAAKQ,MAAM;QACnBK,WAAW;QACXC,gBAAgBd,KAAKQ,MAAM,OAAO;QAClCO,YAAY;YACR;gBACIC,MAAMhB,KAAKM,YAAY,UAAU;YACrC;SACH;IACL;AACJ;AAEA,OAAO,MAAMW,YAAY,CAAC,EAAET,IAAI,EAAoB;IAChD,MAAMU,QAAQhB,QACV,IAAM;YACF;gBACIiB,oBAAoB;gBACpBC,kBAAkB;gBAClBC,oBAAoB;gBACpBC,qBAAqB,IAAM;gBAC3BC,QAAQ;oBACJhB,UAAUC;gBACd;gBACAgB,OAAO;YACX;SACH,EACD,EAAE;IAGN,qBAAO,oBAACnB;QAAUa,OAAOA;QAAOO,UAAUC,QAAQC,IAAI;;AAC1D,EAAE"}
|
|
@@ -1,168 +0,0 @@
|
|
|
1
|
-
import * as ts from 'typescript';
|
|
2
|
-
import * as tstl from 'typescript-to-lua';
|
|
3
|
-
import * as lua from 'typescript-to-lua/dist/LuaAST';
|
|
4
|
-
import { ScopeType } from 'typescript-to-lua/dist/transformation/utils/scope';
|
|
5
|
-
import { transformCallAndArguments } from 'typescript-to-lua/dist/transformation/visitors/call';
|
|
6
|
-
import { transformClassInstanceFields } from 'typescript-to-lua/dist/transformation/visitors/class/members/fields';
|
|
7
|
-
import { getExtendedNode, isStaticNode } from 'typescript-to-lua/dist/transformation/visitors/class/utils';
|
|
8
|
-
import { transformFunctionBodyContent, transformFunctionToExpression, transformParameters } from 'typescript-to-lua/dist/transformation/visitors/function';
|
|
9
|
-
function createClassCall(context, className, extendsNode) {
|
|
10
|
-
// class('X')
|
|
11
|
-
const classCall = tstl.createCallExpression(tstl.createIdentifier('class'), [
|
|
12
|
-
tstl.createStringLiteral(className.text)
|
|
13
|
-
]);
|
|
14
|
-
let classCreationExpression;
|
|
15
|
-
if (extendsNode) {
|
|
16
|
-
// class('X').extends(Blah)
|
|
17
|
-
classCreationExpression = tstl.createCallExpression(tstl.createTableIndexExpression(classCall, tstl.createStringLiteral('extends')), [
|
|
18
|
-
context.transformExpression(extendsNode.expression)
|
|
19
|
-
]);
|
|
20
|
-
} else {
|
|
21
|
-
classCreationExpression = tstl.createCallExpression(tstl.createTableIndexExpression(classCall, tstl.createStringLiteral('extends')), [
|
|
22
|
-
tstl.createIdentifier('Object')
|
|
23
|
-
]);
|
|
24
|
-
}
|
|
25
|
-
return tstl.createExpressionStatement(classCreationExpression);
|
|
26
|
-
}
|
|
27
|
-
export function transformPropertyName(context, node) {
|
|
28
|
-
if (ts.isComputedPropertyName(node)) {
|
|
29
|
-
return context.transformExpression(node.expression);
|
|
30
|
-
} else if (ts.isIdentifier(node)) {
|
|
31
|
-
return tstl.createStringLiteral(node.text);
|
|
32
|
-
} else if (ts.isPrivateIdentifier(node)) {
|
|
33
|
-
throw new Error('PrivateIdentifier is not supported');
|
|
34
|
-
} else {
|
|
35
|
-
return context.transformExpression(node);
|
|
36
|
-
}
|
|
37
|
-
}
|
|
38
|
-
function transformConstructor(context, className, instanceFields, constructor) {
|
|
39
|
-
const methodName = 'init';
|
|
40
|
-
context.pushScope(ScopeType.Function);
|
|
41
|
-
const bodyStatements = [];
|
|
42
|
-
let params;
|
|
43
|
-
if (constructor) {
|
|
44
|
-
[params] = transformParameters(context, constructor == null ? void 0 : constructor.parameters, tstl.createIdentifier('self'));
|
|
45
|
-
} else {
|
|
46
|
-
params = [
|
|
47
|
-
tstl.createIdentifier('self')
|
|
48
|
-
];
|
|
49
|
-
}
|
|
50
|
-
bodyStatements.push(tstl.createExpressionStatement(tstl.createCallExpression(tstl.createTableIndexExpression(tstl.createTableIndexExpression(className, tstl.createStringLiteral('super')), tstl.createStringLiteral('init')), params)));
|
|
51
|
-
const classInstanceFields = transformClassInstanceFields(context, instanceFields);
|
|
52
|
-
// initializers have to come before any body of the constructor
|
|
53
|
-
bodyStatements.push(...classInstanceFields);
|
|
54
|
-
if (constructor == null ? void 0 : constructor.body) {
|
|
55
|
-
const body = transformFunctionBodyContent(context, constructor.body);
|
|
56
|
-
// if the first expression in the body is a super call, ignore it, because we have
|
|
57
|
-
// constructed our own super call.
|
|
58
|
-
// if it's not, make sure to include the entire body.
|
|
59
|
-
const firstStatement = constructor.body.statements[0];
|
|
60
|
-
if (firstStatement && ts.isExpressionStatement(firstStatement) && ts.isCallExpression(firstStatement.expression) && firstStatement.expression.expression.kind === ts.SyntaxKind.SuperKeyword) {
|
|
61
|
-
bodyStatements.push(...body.slice(1));
|
|
62
|
-
} else {
|
|
63
|
-
bodyStatements.push(...body);
|
|
64
|
-
}
|
|
65
|
-
}
|
|
66
|
-
context.popScope();
|
|
67
|
-
return tstl.createAssignmentStatement(tstl.createTableIndexExpression(className, tstl.createStringLiteral(methodName)), tstl.createFunctionExpression(tstl.createBlock(bodyStatements), params));
|
|
68
|
-
}
|
|
69
|
-
function transformMethodDeclaration(context, node, className) {
|
|
70
|
-
const [functionExpression] = transformFunctionToExpression(context, node);
|
|
71
|
-
return tstl.createAssignmentStatement(tstl.createTableIndexExpression(className, transformPropertyName(context, node.name)), functionExpression);
|
|
72
|
-
}
|
|
73
|
-
export const transformClassDeclaration = (declaration, context)=>{
|
|
74
|
-
let className;
|
|
75
|
-
if (declaration.name) {
|
|
76
|
-
className = tstl.createIdentifier(declaration.name.text);
|
|
77
|
-
} else {
|
|
78
|
-
className = tstl.createIdentifier(context.createTempName('class'), declaration);
|
|
79
|
-
}
|
|
80
|
-
const extension = getExtendedNode(declaration);
|
|
81
|
-
if (context.classSuperInfos) {
|
|
82
|
-
context.classSuperInfos.push({
|
|
83
|
-
className,
|
|
84
|
-
extendedTypeNode: extension
|
|
85
|
-
});
|
|
86
|
-
} else {
|
|
87
|
-
context.classSuperInfos = [
|
|
88
|
-
{
|
|
89
|
-
className,
|
|
90
|
-
extendedTypeNode: extension
|
|
91
|
-
}
|
|
92
|
-
];
|
|
93
|
-
}
|
|
94
|
-
// Get all properties with value
|
|
95
|
-
const properties = declaration.members.filter(ts.isPropertyDeclaration).filter((member)=>member.initializer);
|
|
96
|
-
// Divide properties into static and non-static
|
|
97
|
-
const instanceFields = properties.filter((prop)=>!isStaticNode(prop));
|
|
98
|
-
const statements = [];
|
|
99
|
-
// class('X')
|
|
100
|
-
statements.push(createClassCall(context, className, extension));
|
|
101
|
-
// function X:init()
|
|
102
|
-
// X.super.init(self)
|
|
103
|
-
// end
|
|
104
|
-
const constructor = declaration.members.find((n)=>ts.isConstructorDeclaration(n) && n.body !== undefined);
|
|
105
|
-
const transformedConstructor = transformConstructor(context, className, instanceFields, constructor);
|
|
106
|
-
if (transformedConstructor) {
|
|
107
|
-
statements.push(transformedConstructor);
|
|
108
|
-
}
|
|
109
|
-
const methods = declaration.members.filter(ts.isMethodDeclaration).map((method)=>transformMethodDeclaration(context, method, className)).filter((method)=>method !== undefined);
|
|
110
|
-
statements.push(...methods);
|
|
111
|
-
return statements;
|
|
112
|
-
};
|
|
113
|
-
const transformNewExpression = (node, context)=>{
|
|
114
|
-
const signature = context.checker.getResolvedSignature(node);
|
|
115
|
-
var _node_arguments;
|
|
116
|
-
const [name, params] = transformCallAndArguments(context, node.expression, (_node_arguments = node.arguments) != null ? _node_arguments : [
|
|
117
|
-
ts.factory.createTrue()
|
|
118
|
-
], signature);
|
|
119
|
-
return tstl.createCallExpression(name, params);
|
|
120
|
-
};
|
|
121
|
-
export const transformSuperExpression = (expression, context)=>{
|
|
122
|
-
const superInfos = context.classSuperInfos;
|
|
123
|
-
let superInfo = undefined;
|
|
124
|
-
if (superInfos) {
|
|
125
|
-
superInfo = superInfos[superInfos.length - 1];
|
|
126
|
-
}
|
|
127
|
-
if (!superInfo) return lua.createAnonymousIdentifier(expression);
|
|
128
|
-
const { className } = superInfo;
|
|
129
|
-
// Using `super` without extended type node is a TypeScript error
|
|
130
|
-
// const extendsExpression = extendedTypeNode?.expression;
|
|
131
|
-
// let baseClassName: lua.AssignmentLeftHandSideExpression | undefined;
|
|
132
|
-
// if (extendsExpression && ts.isIdentifier(extendsExpression)) {
|
|
133
|
-
// const symbol = context.checker.getSymbolAtLocation(extendsExpression);
|
|
134
|
-
// if (symbol && !isSymbolExported(context, symbol)) {
|
|
135
|
-
// // Use "baseClassName" if base is a simple identifier
|
|
136
|
-
// baseClassName = transformIdentifier(context, extendsExpression);
|
|
137
|
-
// }
|
|
138
|
-
// }
|
|
139
|
-
// if (!baseClassName) {
|
|
140
|
-
// // Use "className.____super" if the base is not a simple identifier
|
|
141
|
-
// baseClassName = lua.createTableIndexExpression(
|
|
142
|
-
// className,
|
|
143
|
-
// lua.createStringLiteral('____super'),
|
|
144
|
-
// expression
|
|
145
|
-
// );
|
|
146
|
-
// }
|
|
147
|
-
return lua.createTableIndexExpression(className, lua.createStringLiteral('super'));
|
|
148
|
-
};
|
|
149
|
-
const plugin = {
|
|
150
|
-
visitors: {
|
|
151
|
-
[ts.SyntaxKind.ClassDeclaration]: transformClassDeclaration,
|
|
152
|
-
[ts.SyntaxKind.SuperKeyword]: transformSuperExpression,
|
|
153
|
-
[ts.SyntaxKind.NewExpression]: transformNewExpression,
|
|
154
|
-
[ts.SyntaxKind.CallExpression]: (node, context)=>{
|
|
155
|
-
if (ts.isIdentifier(node.expression) && node.expression.escapedText === 'require') {
|
|
156
|
-
const normalNode = context.superTransformExpression(node);
|
|
157
|
-
normalNode.expression.text = 'import';
|
|
158
|
-
normalNode.expression.originalName = 'import';
|
|
159
|
-
return normalNode;
|
|
160
|
-
} else {
|
|
161
|
-
return context.superTransformExpression(node);
|
|
162
|
-
}
|
|
163
|
-
}
|
|
164
|
-
}
|
|
165
|
-
};
|
|
166
|
-
export default plugin;
|
|
167
|
-
|
|
168
|
-
//# sourceMappingURL=plugin.js.map
|
|
@@ -1 +0,0 @@
|
|
|
1
|
-
{"version":3,"sources":["../../../../../../libs/cli/src/commands/TranspileCommand/plugin.cts"],"sourcesContent":["import * as ts from 'typescript';\nimport * as tstl from 'typescript-to-lua';\nimport { FunctionVisitor, TransformationContext } from 'typescript-to-lua';\nimport * as lua from 'typescript-to-lua/dist/LuaAST';\nimport { ScopeType } from 'typescript-to-lua/dist/transformation/utils/scope';\nimport { transformCallAndArguments } from 'typescript-to-lua/dist/transformation/visitors/call';\nimport { transformClassInstanceFields } from 'typescript-to-lua/dist/transformation/visitors/class/members/fields';\nimport {\n getExtendedNode,\n isStaticNode,\n} from 'typescript-to-lua/dist/transformation/visitors/class/utils';\nimport {\n transformFunctionBodyContent,\n transformFunctionToExpression,\n transformParameters,\n} from 'typescript-to-lua/dist/transformation/visitors/function';\n\nfunction createClassCall(\n context: tstl.TransformationContext,\n className: tstl.Identifier,\n extendsNode?: ts.ExpressionWithTypeArguments\n): tstl.Statement {\n // class('X')\n const classCall = tstl.createCallExpression(\n tstl.createIdentifier('class'),\n [tstl.createStringLiteral(className.text)]\n );\n let classCreationExpression: tstl.Expression;\n if (extendsNode) {\n // class('X').extends(Blah)\n classCreationExpression = tstl.createCallExpression(\n tstl.createTableIndexExpression(\n classCall,\n tstl.createStringLiteral('extends')\n ),\n [context.transformExpression(extendsNode.expression)]\n );\n } else {\n classCreationExpression = tstl.createCallExpression(\n tstl.createTableIndexExpression(\n classCall,\n tstl.createStringLiteral('extends')\n ),\n [tstl.createIdentifier('Object')]\n );\n }\n return tstl.createExpressionStatement(classCreationExpression);\n}\n\nexport function transformPropertyName(\n context: TransformationContext,\n node: ts.PropertyName\n): tstl.Expression {\n if (ts.isComputedPropertyName(node)) {\n return context.transformExpression(node.expression);\n } else if (ts.isIdentifier(node)) {\n return tstl.createStringLiteral(node.text);\n } else if (ts.isPrivateIdentifier(node)) {\n throw new Error('PrivateIdentifier is not supported');\n } else {\n return context.transformExpression(node);\n }\n}\n\nfunction transformConstructor(\n context: TransformationContext,\n className: tstl.Identifier,\n instanceFields: ts.PropertyDeclaration[],\n constructor?: ts.ConstructorDeclaration\n): tstl.Statement | undefined {\n const methodName = 'init';\n context.pushScope(ScopeType.Function);\n const bodyStatements: tstl.Statement[] = [];\n let params: tstl.Identifier[];\n if (constructor) {\n [params] = transformParameters(\n context,\n constructor?.parameters,\n tstl.createIdentifier('self')\n );\n } else {\n params = [tstl.createIdentifier('self')];\n }\n bodyStatements.push(\n tstl.createExpressionStatement(\n tstl.createCallExpression(\n tstl.createTableIndexExpression(\n tstl.createTableIndexExpression(\n className,\n tstl.createStringLiteral('super')\n ),\n tstl.createStringLiteral('init')\n ),\n params\n )\n )\n );\n const classInstanceFields = transformClassInstanceFields(\n context,\n instanceFields\n );\n // initializers have to come before any body of the constructor\n bodyStatements.push(...classInstanceFields);\n if (constructor?.body) {\n const body = transformFunctionBodyContent(context, constructor.body);\n // if the first expression in the body is a super call, ignore it, because we have\n // constructed our own super call.\n // if it's not, make sure to include the entire body.\n const firstStatement = constructor.body.statements[0];\n if (\n firstStatement &&\n ts.isExpressionStatement(firstStatement) &&\n ts.isCallExpression(firstStatement.expression) &&\n firstStatement.expression.expression.kind ===\n ts.SyntaxKind.SuperKeyword\n ) {\n bodyStatements.push(...body.slice(1));\n } else {\n bodyStatements.push(...body);\n }\n }\n context.popScope();\n return tstl.createAssignmentStatement(\n tstl.createTableIndexExpression(\n className,\n tstl.createStringLiteral(methodName)\n ),\n tstl.createFunctionExpression(tstl.createBlock(bodyStatements), params)\n );\n}\n\nfunction transformMethodDeclaration(\n context: TransformationContext,\n node: ts.MethodDeclaration,\n className: tstl.Identifier\n): tstl.Statement | undefined {\n const [functionExpression] = transformFunctionToExpression(context, node);\n return tstl.createAssignmentStatement(\n tstl.createTableIndexExpression(\n className,\n transformPropertyName(context, node.name)\n ),\n functionExpression\n );\n}\ninterface ClassSuperInfo {\n className: lua.Identifier;\n extendedTypeNode?: ts.ExpressionWithTypeArguments;\n}\n\nexport const transformClassDeclaration: FunctionVisitor<\n ts.ClassLikeDeclaration\n> = (\n declaration,\n context: TransformationContext & { classSuperInfos?: [ClassSuperInfo] }\n) => {\n let className: tstl.Identifier;\n if (declaration.name) {\n className = tstl.createIdentifier(declaration.name.text);\n } else {\n className = tstl.createIdentifier(\n context.createTempName('class'),\n declaration\n );\n }\n\n const extension = getExtendedNode(declaration);\n if (context.classSuperInfos) {\n context.classSuperInfos.push({\n className,\n extendedTypeNode: extension,\n });\n } else {\n context.classSuperInfos = [{ className, extendedTypeNode: extension }];\n }\n\n // Get all properties with value\n const properties = declaration.members\n .filter(ts.isPropertyDeclaration)\n .filter((member) => member.initializer);\n\n // Divide properties into static and non-static\n const instanceFields = properties.filter((prop) => !isStaticNode(prop));\n\n const statements: tstl.Statement[] = [];\n\n // class('X')\n statements.push(createClassCall(context, className, extension));\n\n // function X:init()\n // X.super.init(self)\n // end\n const constructor = declaration.members.find(\n (n): n is ts.ConstructorDeclaration =>\n ts.isConstructorDeclaration(n) && n.body !== undefined\n );\n const transformedConstructor = transformConstructor(\n context,\n className,\n instanceFields,\n constructor\n );\n if (transformedConstructor) {\n statements.push(transformedConstructor);\n }\n\n const methods = declaration.members\n .filter(ts.isMethodDeclaration)\n .map((method) => transformMethodDeclaration(context, method, className))\n .filter((method): method is tstl.Statement => method !== undefined);\n statements.push(...methods);\n\n return statements;\n};\n\nconst transformNewExpression: FunctionVisitor<ts.NewExpression> = (\n node,\n context\n) => {\n const signature = context.checker.getResolvedSignature(node);\n const [name, params] = transformCallAndArguments(\n context,\n node.expression,\n node.arguments ?? [ts.factory.createTrue()],\n signature\n );\n return tstl.createCallExpression(name, params);\n};\n\nexport const transformSuperExpression: FunctionVisitor<ts.SuperExpression> = (\n expression,\n context: TransformationContext & { classSuperInfos?: ClassSuperInfo[] }\n) => {\n const superInfos = context.classSuperInfos;\n let superInfo: ClassSuperInfo | undefined = undefined;\n if (superInfos) {\n superInfo = superInfos[superInfos.length - 1];\n }\n if (!superInfo) return lua.createAnonymousIdentifier(expression);\n const { className } = superInfo;\n\n // Using `super` without extended type node is a TypeScript error\n // const extendsExpression = extendedTypeNode?.expression;\n // let baseClassName: lua.AssignmentLeftHandSideExpression | undefined;\n\n // if (extendsExpression && ts.isIdentifier(extendsExpression)) {\n // const symbol = context.checker.getSymbolAtLocation(extendsExpression);\n // if (symbol && !isSymbolExported(context, symbol)) {\n // // Use \"baseClassName\" if base is a simple identifier\n // baseClassName = transformIdentifier(context, extendsExpression);\n // }\n // }\n\n // if (!baseClassName) {\n // // Use \"className.____super\" if the base is not a simple identifier\n // baseClassName = lua.createTableIndexExpression(\n // className,\n // lua.createStringLiteral('____super'),\n // expression\n // );\n // }\n\n return lua.createTableIndexExpression(\n className,\n lua.createStringLiteral('super')\n );\n};\n\nconst plugin = {\n visitors: {\n [ts.SyntaxKind.ClassDeclaration]: transformClassDeclaration,\n [ts.SyntaxKind.SuperKeyword]: transformSuperExpression,\n [ts.SyntaxKind.NewExpression]: transformNewExpression,\n [ts.SyntaxKind.CallExpression]: (node, context) => {\n if (\n ts.isIdentifier(node.expression) &&\n node.expression.escapedText === 'require'\n ) {\n const normalNode = context.superTransformExpression(\n node\n ) as unknown as {\n expression: { text: string; originalName: string };\n };\n\n normalNode.expression.text = 'import';\n normalNode.expression.originalName = 'import';\n\n return normalNode as unknown as lua.Expression;\n } else {\n return context.superTransformExpression(node);\n }\n },\n },\n} satisfies tstl.Plugin;\n\nexport default plugin;\n"],"names":["ts","tstl","lua","ScopeType","transformCallAndArguments","transformClassInstanceFields","getExtendedNode","isStaticNode","transformFunctionBodyContent","transformFunctionToExpression","transformParameters","createClassCall","context","className","extendsNode","classCall","createCallExpression","createIdentifier","createStringLiteral","text","classCreationExpression","createTableIndexExpression","transformExpression","expression","createExpressionStatement","transformPropertyName","node","isComputedPropertyName","isIdentifier","isPrivateIdentifier","Error","transformConstructor","instanceFields","constructor","methodName","pushScope","Function","bodyStatements","params","parameters","push","classInstanceFields","body","firstStatement","statements","isExpressionStatement","isCallExpression","kind","SyntaxKind","SuperKeyword","slice","popScope","createAssignmentStatement","createFunctionExpression","createBlock","transformMethodDeclaration","functionExpression","name","transformClassDeclaration","declaration","createTempName","extension","classSuperInfos","extendedTypeNode","properties","members","filter","isPropertyDeclaration","member","initializer","prop","find","n","isConstructorDeclaration","undefined","transformedConstructor","methods","isMethodDeclaration","map","method","transformNewExpression","signature","checker","getResolvedSignature","arguments","factory","createTrue","transformSuperExpression","superInfos","superInfo","length","createAnonymousIdentifier","plugin","visitors","ClassDeclaration","NewExpression","CallExpression","escapedText","normalNode","superTransformExpression","originalName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
|