hackmud-script-manager 0.19.1-64ab3ba → 0.19.1-8719c7d

Sign up to get free protection for your applications and to get access to all the features.
Files changed (27) hide show
  1. package/README.md +1 -1
  2. package/bin/hsm.d.ts +0 -0
  3. package/bin/hsm.js +126 -283
  4. package/generateTypeDeclaration.d.ts +1 -2
  5. package/generateTypeDeclaration.js +2 -2
  6. package/package.json +6 -7
  7. package/processScript/index.d.ts +15 -25
  8. package/processScript/index.js +257 -257
  9. package/processScript/minify.d.ts +13 -19
  10. package/processScript/minify.js +381 -395
  11. package/processScript/postprocess.d.ts +0 -1
  12. package/processScript/postprocess.js +1 -1
  13. package/processScript/preprocess.d.ts +4 -8
  14. package/processScript/preprocess.js +94 -94
  15. package/processScript/shared.d.ts +1 -1
  16. package/processScript/shared.js +11 -11
  17. package/processScript/transform.d.ts +11 -17
  18. package/processScript/transform.js +594 -560
  19. package/pull.d.ts +5 -9
  20. package/pull.js +2 -2
  21. package/push.d.ts +22 -31
  22. package/push.js +3 -3
  23. package/syncMacros.d.ts +1 -2
  24. package/syncMacros.js +2 -2
  25. package/watch.d.ts +8 -14
  26. package/watch.js +12 -12
  27. package/tsconfig.tsbuildinfo +0 -1
package/processScript/transform.js CHANGED
@@ -20,388 +20,321 @@ const { default: traverse } = babelTraverse,
20
20
  "String",
21
21
  "Symbol",
22
22
  "BigInt"
23
- ],
24
- transform = (
25
- file,
26
- sourceCode,
27
- { uniqueID = "00000000000", scriptUser = "UNKNOWN", scriptName = "UNKNOWN", seclevel = 4 } = {}
28
- ) => {
29
- const topFunctionName = `_${uniqueID}_SCRIPT_`,
30
- exports = new Map(),
31
- liveExports = new Map()
32
- let program
33
- traverse(file, {
34
- Program(path) {
35
- program = path
36
- path.skip()
37
- }
38
- })
39
- if (program.scope.hasGlobal("_SOURCE"))
40
- for (const referencePath of getReferencePathsToGlobal("_SOURCE", program))
41
- referencePath.replaceWith(t.stringLiteral(sourceCode))
42
- if (program.scope.hasGlobal("_BUILD_DATE"))
43
- for (const referencePath of getReferencePathsToGlobal("_BUILD_DATE", program))
44
- referencePath.replaceWith(t.numericLiteral(Date.now()))
45
- if (program.scope.hasGlobal("_SCRIPT_USER"))
46
- for (const referencePath of getReferencePathsToGlobal("_SCRIPT_USER", program))
47
- 1 == scriptUser ?
48
- referencePath.replaceWith(t.stringLiteral(`$${uniqueID}$SCRIPT_USER$`))
49
- : referencePath.replaceWith(t.stringLiteral(scriptUser))
50
- if (program.scope.hasGlobal("_SCRIPT_NAME"))
51
- for (const referencePath of getReferencePathsToGlobal("_SCRIPT_NAME", program))
52
- 1 == scriptName ?
53
- referencePath.replaceWith(t.stringLiteral(`$${uniqueID}$SCRIPT_NAME$`))
54
- : referencePath.replaceWith(t.stringLiteral(scriptName))
55
- if (program.scope.hasGlobal("_FULL_SCRIPT_NAME"))
56
- for (const referencePath of getReferencePathsToGlobal("_FULL_SCRIPT_NAME", program))
57
- 1 == scriptUser || 1 == scriptName ?
58
- referencePath.replaceWith(t.stringLiteral(`$${uniqueID}$FULL_SCRIPT_NAME$`))
59
- : referencePath.replaceWith(t.stringLiteral(`${scriptUser}.${scriptName}`))
60
- let functionDotPrototypeIsReferencedMultipleTimes = !1
61
- const createGetFunctionPrototypeNode = () => {
62
- for (const globalFunction of globalFunctionsUnder7Characters)
63
- if (!program.scope.hasOwnBinding(globalFunction))
64
- return t.memberExpression(
65
- t.memberExpression(t.identifier(globalFunction), t.identifier("constructor")),
66
- t.identifier("prototype")
67
- )
68
- return t.memberExpression(
69
- t.memberExpression(
70
- t.arrowFunctionExpression([t.identifier("_")], t.identifier("_")),
71
- t.identifier("constructor")
72
- ),
73
- t.identifier("prototype")
74
- )
23
+ ]
24
+ function transform(
25
+ file,
26
+ sourceCode,
27
+ { uniqueID = "00000000000", scriptUser, scriptName = "UNKNOWN", seclevel = 4 } = {}
28
+ ) {
29
+ const topFunctionName = `_${uniqueID}_SCRIPT_`,
30
+ exports = new Map(),
31
+ liveExports = new Map()
32
+ let program
33
+ traverse(file, {
34
+ Program(path) {
35
+ program = path
36
+ path.skip()
75
37
  }
76
- if (program.scope.hasGlobal("Function")) {
77
- const FunctionReferencePaths = getReferencePathsToGlobal("Function", program)
78
- if (1 == FunctionReferencePaths.length) {
79
- const referencePath = FunctionReferencePaths[0]
38
+ })
39
+ if (program.scope.hasGlobal("_SOURCE"))
40
+ for (const referencePath of getReferencePathsToGlobal("_SOURCE", program))
41
+ referencePath.replaceWith(t.stringLiteral(sourceCode))
42
+ if (program.scope.hasGlobal("_BUILD_DATE"))
43
+ for (const referencePath of getReferencePathsToGlobal("_BUILD_DATE", program))
44
+ referencePath.replaceWith(t.numericLiteral(Date.now()))
45
+ let uniqueIdScriptUserNeeded = !1
46
+ if (program.scope.hasGlobal("_SCRIPT_USER"))
47
+ for (const referencePath of getReferencePathsToGlobal("_SCRIPT_USER", program))
48
+ if (null == scriptUser) {
49
+ uniqueIdScriptUserNeeded = !0
50
+ referencePath.replaceWith(t.identifier(`_${uniqueID}_SCRIPT_USER_`))
51
+ } else
52
+ referencePath.replaceWith(t.stringLiteral(1 == scriptUser ? `$${uniqueID}$SCRIPT_USER$` : scriptUser))
53
+ if (program.scope.hasGlobal("_SCRIPT_NAME"))
54
+ for (const referencePath of getReferencePathsToGlobal("_SCRIPT_NAME", program))
55
+ referencePath.replaceWith(t.stringLiteral(1 == scriptName ? `$${uniqueID}$SCRIPT_NAME$` : scriptName))
56
+ if (program.scope.hasGlobal("_FULL_SCRIPT_NAME"))
57
+ for (const referencePath of getReferencePathsToGlobal("_FULL_SCRIPT_NAME", program))
58
+ referencePath.replaceWith(
59
+ t.stringLiteral(
60
+ 1 == scriptUser || 1 == scriptName ?
61
+ `$${uniqueID}$FULL_SCRIPT_NAME$`
62
+ : `${scriptUser}.${scriptName}`
63
+ )
64
+ )
65
+ let functionDotPrototypeIsReferencedMultipleTimes = !1
66
+ if (program.scope.hasGlobal("Function")) {
67
+ const FunctionReferencePaths = getReferencePathsToGlobal("Function", program)
68
+ if (1 == FunctionReferencePaths.length) {
69
+ const referencePath = FunctionReferencePaths[0]
70
+ assert(
71
+ "MemberExpression" == referencePath.parent.type,
72
+ "src/processScript/transform.ts:99:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
73
+ )
74
+ assert(
75
+ "Identifier" == referencePath.parent.property.type,
76
+ "src/processScript/transform.ts:104:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
77
+ )
78
+ assert(
79
+ "prototype" == referencePath.parent.property.name,
80
+ "src/processScript/transform.ts:109:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
81
+ )
82
+ referencePath.parentPath.replaceWith(createGetFunctionPrototypeNode())
83
+ } else {
84
+ for (const referencePath of FunctionReferencePaths) {
80
85
  assert(
81
86
  "MemberExpression" == referencePath.parent.type,
82
- "`Function` isn't available in hackmud, only `Function.prototype` is accessible"
87
+ "src/processScript/transform.ts:117:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
83
88
  )
84
89
  assert(
85
90
  "Identifier" == referencePath.parent.property.type,
86
- "`Function` isn't available in hackmud, only `Function.prototype` is accessible"
91
+ "src/processScript/transform.ts:122:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
87
92
  )
88
93
  assert(
89
94
  "prototype" == referencePath.parent.property.name,
90
- "`Function` isn't available in hackmud, only `Function.prototype` is accessible"
95
+ "src/processScript/transform.ts:127:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
91
96
  )
92
- referencePath.parentPath.replaceWith(createGetFunctionPrototypeNode())
93
- } else {
94
- for (const referencePath of FunctionReferencePaths) {
95
- assert(
96
- "MemberExpression" == referencePath.parent.type,
97
- "`Function` isn't available in hackmud, only `Function.prototype` is accessible"
98
- )
99
- assert(
100
- "Identifier" == referencePath.parent.property.type,
101
- "`Function` isn't available in hackmud, only `Function.prototype` is accessible"
102
- )
103
- assert(
104
- "prototype" == referencePath.parent.property.name,
105
- "`Function` isn't available in hackmud, only `Function.prototype` is accessible"
106
- )
107
- functionDotPrototypeIsReferencedMultipleTimes = !0
108
- referencePath.parentPath.replaceWith(t.identifier(`_${uniqueID}_FUNCTION_DOT_PROTOTYPE_`))
109
- }
110
97
  functionDotPrototypeIsReferencedMultipleTimes = !0
98
+ referencePath.parentPath.replaceWith(t.identifier(`_${uniqueID}_FUNCTION_DOT_PROTOTYPE_`))
111
99
  }
100
+ functionDotPrototypeIsReferencedMultipleTimes = !0
112
101
  }
113
- let detectedSeclevel = 4
114
- const neededSubscriptLets = new Set(),
115
- processFakeSubscriptObject = fakeSubscriptObjectName => {
116
- for (const referencePath of getReferencePathsToGlobal(fakeSubscriptObjectName, program)) {
117
- assert("MemberExpression" == referencePath.parent.type)
118
- assert("Identifier" == referencePath.parent.property.type)
119
- assert("MemberExpression" == referencePath.parentPath.parentPath?.node.type)
120
- assert("Identifier" == referencePath.parentPath.parentPath.node.property.type)
121
- assert(
122
- /^[_a-z][\d_a-z]{0,24}$/.test(referencePath.parent.property.name),
123
- `invalid user "${referencePath.parent.property.name}" in subscript`
124
- )
125
- assert(
126
- /^[_a-z][\d_a-z]{0,24}$/.test(referencePath.parentPath.parentPath.node.property.name),
127
- `invalid script name "${referencePath.parentPath.parentPath.node.property.name}" in subscript`
128
- )
129
- if ("CallExpression" == referencePath.parentPath.parentPath.parentPath?.type)
130
- referencePath.parentPath.parentPath.replaceWith(
131
- t.identifier(
132
- `$${uniqueID}$SUBSCRIPT$${referencePath.parent.property.name}$${referencePath.parentPath.parentPath.node.property.name}$`
133
- )
134
- )
135
- else {
136
- const name = `${referencePath.parent.property.name}$${referencePath.parentPath.parentPath.node.property.name}`
137
- referencePath.parentPath.parentPath.replaceWith(t.identifier(`_${uniqueID}_SUBSCRIPT_${name}_`))
138
- neededSubscriptLets.add(name)
139
- }
140
- }
141
- }
142
- for (const fakeSubscriptObjectName of ["$fs", "$4s", "$s"])
143
- program.scope.hasGlobal(fakeSubscriptObjectName) && processFakeSubscriptObject(fakeSubscriptObjectName)
144
- for (const fakeSubscriptObjectName of ["$hs", "$3s"])
145
- if (program.scope.hasGlobal(fakeSubscriptObjectName)) {
146
- detectedSeclevel = 3
147
- processFakeSubscriptObject(fakeSubscriptObjectName)
148
- }
149
- for (const fakeSubscriptObjectName of ["$ms", "$2s"])
150
- if (program.scope.hasGlobal(fakeSubscriptObjectName)) {
151
- detectedSeclevel = 2
152
- processFakeSubscriptObject(fakeSubscriptObjectName)
153
- }
154
- for (const fakeSubscriptObjectName of ["$ls", "$1s"])
155
- if (program.scope.hasGlobal(fakeSubscriptObjectName)) {
156
- detectedSeclevel = 1
157
- processFakeSubscriptObject(fakeSubscriptObjectName)
102
+ }
103
+ const neededSubscriptLets = new Set()
104
+ let detectedSeclevel = 4
105
+ for (const fakeSubscriptObjectName of ["$fs", "$4s", "$s"])
106
+ program.scope.hasGlobal(fakeSubscriptObjectName) && processFakeSubscriptObject(fakeSubscriptObjectName)
107
+ for (const fakeSubscriptObjectName of ["$hs", "$3s"])
108
+ if (program.scope.hasGlobal(fakeSubscriptObjectName)) {
109
+ detectedSeclevel = 3
110
+ processFakeSubscriptObject(fakeSubscriptObjectName)
111
+ }
112
+ for (const fakeSubscriptObjectName of ["$ms", "$2s"])
113
+ if (program.scope.hasGlobal(fakeSubscriptObjectName)) {
114
+ detectedSeclevel = 2
115
+ processFakeSubscriptObject(fakeSubscriptObjectName)
116
+ }
117
+ for (const fakeSubscriptObjectName of ["$ls", "$1s"])
118
+ if (program.scope.hasGlobal(fakeSubscriptObjectName)) {
119
+ detectedSeclevel = 1
120
+ processFakeSubscriptObject(fakeSubscriptObjectName)
121
+ }
122
+ for (const fakeSubscriptObjectName of ["$ns", "$0s"])
123
+ if (program.scope.hasGlobal(fakeSubscriptObjectName)) {
124
+ detectedSeclevel = 0
125
+ processFakeSubscriptObject(fakeSubscriptObjectName)
126
+ }
127
+ seclevel = Math.min(seclevel, detectedSeclevel)
128
+ const neededDbMethodLets = new Set()
129
+ if (program.scope.hasGlobal("$db"))
130
+ for (const referencePath of getReferencePathsToGlobal("$db", program)) {
131
+ assert("MemberExpression" == referencePath.parentPath.node.type, "src/processScript/transform.ts:181:69")
132
+ assert("Identifier" == referencePath.parentPath.node.property.type, "src/processScript/transform.ts:182:72")
133
+ const databaseOpMethodName = referencePath.parentPath.node.property.name
134
+ assert(
135
+ validDBMethods.includes(databaseOpMethodName),
136
+ `src/processScript/transform.ts:188:8 invalid db method "${databaseOpMethodName}", valid db methods are "${validDBMethods.join('", "')}"`
137
+ )
138
+ if ("CallExpression" == referencePath.parentPath.parentPath?.type)
139
+ referencePath.parentPath.replaceWith(t.identifier(`$${uniqueID}$DB$${databaseOpMethodName}$`))
140
+ else {
141
+ referencePath.parentPath.replaceWith(
142
+ t.identifier(`_${uniqueID}_CONSOLE_METHOD_${databaseOpMethodName}_`)
143
+ )
144
+ neededDbMethodLets.add(databaseOpMethodName)
158
145
  }
159
- for (const fakeSubscriptObjectName of ["$ns", "$0s"])
160
- if (program.scope.hasGlobal(fakeSubscriptObjectName)) {
161
- detectedSeclevel = 0
162
- processFakeSubscriptObject(fakeSubscriptObjectName)
146
+ }
147
+ let needDebugLet = !1
148
+ if (program.scope.hasGlobal("$D"))
149
+ for (const referencePath of getReferencePathsToGlobal("$D", program))
150
+ if ("CallExpression" == referencePath.parentPath.type)
151
+ referencePath.replaceWith(t.identifier(`$${uniqueID}$DEBUG$`))
152
+ else {
153
+ referencePath.replaceWith(t.identifier(`_${uniqueID}_DEBUG_`))
154
+ needDebugLet = !0
163
155
  }
164
- seclevel = Math.min(seclevel, detectedSeclevel)
165
- const neededDbMethodLets = new Set()
166
- if (program.scope.hasGlobal("$db"))
167
- for (const referencePath of getReferencePathsToGlobal("$db", program)) {
168
- assert("MemberExpression" == referencePath.parentPath.node.type)
169
- assert("Identifier" == referencePath.parentPath.node.property.type)
170
- const databaseOpMethodName = referencePath.parentPath.node.property.name
171
- assert(
172
- validDBMethods.includes(databaseOpMethodName),
173
- `invalid db method "${databaseOpMethodName}", valid db methods are "${validDBMethods.join('", "')}"`
174
- )
175
- if ("CallExpression" == referencePath.parentPath.parentPath?.type)
176
- referencePath.parentPath.replaceWith(t.identifier(`$${uniqueID}$DB$${databaseOpMethodName}$`))
177
- else {
178
- referencePath.parentPath.replaceWith(
179
- t.identifier(`_${uniqueID}_CONSOLE_METHOD_${databaseOpMethodName}_`)
180
- )
181
- neededDbMethodLets.add(databaseOpMethodName)
156
+ if (program.scope.hasGlobal("$FMCL"))
157
+ for (const referencePath of getReferencePathsToGlobal("$FMCL", program))
158
+ referencePath.replaceWith(t.identifier(`$${uniqueID}$FMCL$`))
159
+ if (program.scope.hasGlobal("$G"))
160
+ for (const referencePath of getReferencePathsToGlobal("$G", program))
161
+ referencePath.replaceWith(t.identifier(`$${uniqueID}$GLOBAL$`))
162
+ if (program.scope.hasGlobal("_SECLEVEL"))
163
+ for (const referencePath of getReferencePathsToGlobal("_SECLEVEL", program))
164
+ referencePath.replaceWith(t.numericLiteral(seclevel))
165
+ let needGetPrototypeOf = !1
166
+ if (program.scope.hasGlobal("Object"))
167
+ for (const referencePath of getReferencePathsToGlobal("Object", program))
168
+ if ("MemberExpression" == referencePath.parent.type && !referencePath.parent.computed) {
169
+ assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:235:64")
170
+ if ("getPrototypeOf" == referencePath.parent.property.name) {
171
+ referencePath.parentPath.replaceWith(t.identifier(`_${uniqueID}_GET_PROTOTYPE_OF_`))
172
+ needGetPrototypeOf = !0
182
173
  }
183
174
  }
184
- let needDebugLet = !1
185
- if (program.scope.hasGlobal("$D"))
186
- for (const referencePath of getReferencePathsToGlobal("$D", program))
187
- if ("CallExpression" == referencePath.parentPath.type)
188
- referencePath.replaceWith(t.identifier(`$${uniqueID}$DEBUG$`))
189
- else {
190
- referencePath.replaceWith(t.identifier(`_${uniqueID}_DEBUG_`))
191
- needDebugLet = !0
192
- }
193
- if (program.scope.hasGlobal("$FMCL"))
194
- for (const referencePath of getReferencePathsToGlobal("$FMCL", program))
195
- referencePath.replaceWith(t.identifier(`$${uniqueID}$FMCL$`))
196
- if (program.scope.hasGlobal("$G"))
197
- for (const referencePath of getReferencePathsToGlobal("$G", program))
198
- referencePath.replaceWith(t.identifier(`$${uniqueID}$GLOBAL$`))
199
- if (program.scope.hasGlobal("_SECLEVEL"))
200
- for (const referencePath of getReferencePathsToGlobal("_SECLEVEL", program))
201
- referencePath.replaceWith(t.numericLiteral(seclevel))
202
- let needGetPrototypeOf = !1
203
- if (program.scope.hasGlobal("Object"))
204
- for (const referencePath of getReferencePathsToGlobal("Object", program))
205
- if ("MemberExpression" == referencePath.parent.type && !referencePath.parent.computed) {
206
- assert("Identifier" == referencePath.parent.property.type)
207
- if ("getPrototypeOf" == referencePath.parent.property.name) {
208
- referencePath.parentPath.replaceWith(t.identifier(`_${uniqueID}_GET_PROTOTYPE_OF_`))
209
- needGetPrototypeOf = !0
210
- }
211
- }
212
- const consoleMethodsReferenced = new Set()
213
- if (program.scope.hasGlobal("console"))
214
- for (const referencePath of getReferencePathsToGlobal("console", program))
215
- if ("MemberExpression" == referencePath.parent.type && !referencePath.parent.computed) {
216
- assert("Identifier" == referencePath.parent.property.type)
217
- referencePath.parentPath.replaceWith(
218
- t.identifier(`_${uniqueID}_CONSOLE_METHOD_${referencePath.parent.property.name}_`)
219
- )
220
- consoleMethodsReferenced.add(referencePath.parent.property.name)
221
- }
222
- const lastStatement = program.node.body.at(-1)
223
- let exportDefaultName
224
- assert(lastStatement, "program is empty")
225
- if ("ExportNamedDeclaration" == lastStatement.type) {
226
- program.node.body.pop()
227
- for (const specifier of lastStatement.specifiers) {
228
- assert("ExportSpecifier" == specifier.type, specifier.type + " is currently unsupported")
229
- const exportedName =
230
- "Identifier" == specifier.exported.type ? specifier.exported.name : specifier.exported.value
231
- "default" == exportedName ?
232
- (exportDefaultName = specifier.local.name)
233
- : exports.set(specifier.local.name, exportedName)
175
+ const consoleMethodsReferenced = new Set()
176
+ if (program.scope.hasGlobal("console"))
177
+ for (const referencePath of getReferencePathsToGlobal("console", program))
178
+ if ("MemberExpression" == referencePath.parent.type && !referencePath.parent.computed) {
179
+ assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:250:64")
180
+ referencePath.parentPath.replaceWith(
181
+ t.identifier(`_${uniqueID}_CONSOLE_METHOD_${referencePath.parent.property.name}_`)
182
+ )
183
+ consoleMethodsReferenced.add(referencePath.parent.property.name)
234
184
  }
185
+ const lastStatement = program.node.body.at(-1)
186
+ let exportDefaultName
187
+ assert(lastStatement, "src/processScript/transform.ts:264:27 program is empty")
188
+ if ("ExportNamedDeclaration" == lastStatement.type) {
189
+ program.node.body.pop()
190
+ for (const specifier of lastStatement.specifiers) {
191
+ assert(
192
+ "ExportSpecifier" == specifier.type,
193
+ `src/processScript/transform.ts:270:51 ${specifier.type} is currently unsupported`
194
+ )
195
+ const exportedName =
196
+ "Identifier" == specifier.exported.type ? specifier.exported.name : specifier.exported.value
197
+ "default" == exportedName ?
198
+ (exportDefaultName = specifier.local.name)
199
+ : exports.set(specifier.local.name, exportedName)
235
200
  }
236
- const globalBlock = t.blockStatement([])
237
- let mainFunction
238
- for (const statement of program.node.body)
239
- if ("VariableDeclaration" == statement.type)
240
- for (const declarator of statement.declarations)
241
- if (
242
- "Identifier" != declarator.id.type ||
243
- declarator.id.name != exportDefaultName ||
244
- !declarator.init ||
245
- ("FunctionExpression" != declarator.init.type &&
246
- "ArrowFunctionExpression" != declarator.init.type) ||
247
- declarator.init.async ||
248
- declarator.init.generator
249
- ) {
250
- for (const identifierName in t.getBindingIdentifiers(declarator.id)) {
251
- identifierName == exportDefaultName &&
252
- (mainFunction = t.functionDeclaration(
253
- t.identifier(topFunctionName),
254
- [t.identifier("context"), t.identifier("args")],
255
- t.blockStatement([
256
- t.returnStatement(t.callExpression(t.identifier(exportDefaultName), []))
257
- ])
258
- ))
259
- if ("const" != statement.kind && exports.has(identifierName)) {
260
- liveExports.set(identifierName, exports.get(identifierName))
261
- exports.delete(identifierName)
262
- }
263
- globalBlock.body.push(
264
- t.variableDeclaration("let", [t.variableDeclarator(t.identifier(identifierName))])
265
- )
201
+ }
202
+ const globalBlock = t.blockStatement([])
203
+ let mainFunction
204
+ for (const statement of program.node.body)
205
+ if ("VariableDeclaration" == statement.type)
206
+ for (const declarator of statement.declarations)
207
+ if (
208
+ "Identifier" != declarator.id.type ||
209
+ declarator.id.name != exportDefaultName ||
210
+ !declarator.init ||
211
+ ("FunctionExpression" != declarator.init.type &&
212
+ "ArrowFunctionExpression" != declarator.init.type) ||
213
+ declarator.init.async ||
214
+ declarator.init.generator
215
+ ) {
216
+ for (const identifierName in t.getBindingIdentifiers(declarator.id)) {
217
+ identifierName == exportDefaultName &&
218
+ (mainFunction = t.functionDeclaration(
219
+ t.identifier(topFunctionName),
220
+ [t.identifier("context"), t.identifier("args")],
221
+ t.blockStatement([
222
+ t.returnStatement(t.callExpression(t.identifier(exportDefaultName), []))
223
+ ])
224
+ ))
225
+ if ("const" != statement.kind && exports.has(identifierName)) {
226
+ liveExports.set(identifierName, exports.get(identifierName))
227
+ exports.delete(identifierName)
266
228
  }
267
- declarator.init &&
268
- globalBlock.body.push(
269
- t.expressionStatement(t.assignmentExpression("=", declarator.id, declarator.init))
270
- )
271
- } else
272
- mainFunction = t.functionDeclaration(
273
- t.identifier(topFunctionName),
274
- declarator.init.params,
275
- "BlockStatement" == declarator.init.body.type ?
276
- declarator.init.body
277
- : t.blockStatement([t.returnStatement(declarator.init.body)])
229
+ globalBlock.body.push(
230
+ t.variableDeclaration("let", [t.variableDeclarator(t.identifier(identifierName))])
278
231
  )
279
- else
280
- "FunctionDeclaration" == statement.type ?
281
- statement.id.name == exportDefaultName ?
282
- (mainFunction = statement)
283
- : globalBlock.body.push(
284
- t.variableDeclaration("let", [
285
- t.variableDeclarator(
286
- statement.id,
287
- t.functionExpression(
288
- void 0,
289
- statement.params,
290
- statement.body,
291
- statement.generator,
292
- statement.async
293
- )
294
- )
295
- ])
232
+ }
233
+ declarator.init &&
234
+ globalBlock.body.push(
235
+ t.expressionStatement(t.assignmentExpression("=", declarator.id, declarator.init))
296
236
  )
297
- : globalBlock.body.push(statement)
298
- mainFunction ||= t.functionDeclaration(
299
- t.identifier(topFunctionName),
300
- [t.identifier("context"), t.identifier("args")],
301
- t.blockStatement([])
302
- )
303
- program.node.body = [mainFunction]
304
- if (globalBlock.body.length) {
305
- ;(exports.size || liveExports.size) &&
306
- mainFunction.body.body.push(
307
- t.returnStatement(
308
- t.objectExpression([
309
- ...[...exports].map(([local, exported]) =>
310
- t.objectProperty(t.identifier(exported), t.identifier(local))
311
- ),
312
- ...[...liveExports].map(([local, exported]) =>
313
- t.objectMethod(
314
- "get",
315
- t.identifier(exported),
316
- [],
317
- t.blockStatement([t.returnStatement(t.identifier(local))])
237
+ } else
238
+ mainFunction = t.functionDeclaration(
239
+ t.identifier(topFunctionName),
240
+ declarator.init.params,
241
+ "BlockStatement" == declarator.init.body.type ?
242
+ declarator.init.body
243
+ : t.blockStatement([t.returnStatement(declarator.init.body)])
244
+ )
245
+ else
246
+ "FunctionDeclaration" == statement.type ?
247
+ statement.id.name == exportDefaultName ?
248
+ (mainFunction = statement)
249
+ : globalBlock.body.push(
250
+ t.variableDeclaration("let", [
251
+ t.variableDeclarator(
252
+ statement.id,
253
+ t.functionExpression(
254
+ void 0,
255
+ statement.params,
256
+ statement.body,
257
+ statement.generator,
258
+ statement.async
318
259
  )
319
260
  )
320
261
  ])
321
262
  )
263
+ : globalBlock.body.push(statement)
264
+ mainFunction ||= t.functionDeclaration(
265
+ t.identifier(topFunctionName),
266
+ [t.identifier("context"), t.identifier("args")],
267
+ t.blockStatement([])
268
+ )
269
+ if (uniqueIdScriptUserNeeded) {
270
+ const mainFunctionParams = mainFunction.params
271
+ mainFunction.params = [t.restElement(t.identifier(`_${uniqueID}_PARAMS_`))]
272
+ mainFunction.body.body.unshift(
273
+ t.variableDeclaration("let", [
274
+ t.variableDeclarator(t.arrayPattern(mainFunctionParams), t.identifier(`_${uniqueID}_PARAMS_`)),
275
+ t.variableDeclarator(
276
+ t.arrayPattern([t.identifier(`_${uniqueID}_SCRIPT_USER_`)]),
277
+ t.callExpression(
278
+ t.memberExpression(
279
+ t.memberExpression(
280
+ t.memberExpression(t.identifier(`_${uniqueID}_PARAMS_`), t.numericLiteral(0), !0),
281
+ t.identifier("this_script")
282
+ ),
283
+ t.identifier("split")
284
+ ),
285
+ [t.stringLiteral(".")]
286
+ )
322
287
  )
323
- program.scope.crawl()
324
- const globalBlockVariables = new Set()
325
- let hoistedGlobalBlockFunctions = 0
326
- for (const [globalBlockIndex, globalBlockStatement] of [...globalBlock.body.entries()].reverse())
327
- if ("VariableDeclaration" == globalBlockStatement.type) {
328
- assert(1 == globalBlockStatement.declarations.length)
329
- const declarator = globalBlockStatement.declarations[0]
330
- assert("Identifier" == declarator.id.type, `declarator.id.type was "${declarator.id.type}"`)
331
- program.scope.crawl()
332
- if (program.scope.hasGlobal(declarator.id.name)) {
333
- globalBlock.body.splice(globalBlockIndex, 1)
334
- const [globalBlockPath] = program.unshiftContainer("body", globalBlock),
335
- [globalBlockStatementPath] = program.unshiftContainer("body", globalBlockStatement)
336
- program.scope.crawl()
337
- if (
338
- !declarator.init ||
339
- ("FunctionExpression" != declarator.init.type &&
340
- "ArrowFunctionExpression" != declarator.init.type) ||
341
- Object.keys(program.scope.globals).some(global => globalBlockVariables.has(global))
342
- ) {
343
- const binding = program.scope.getBinding(declarator.id.name)
344
- assert(binding)
345
- for (const referencePath of binding.referencePaths) {
346
- assert("Identifier" == referencePath.node.type)
347
- referencePath.replaceWith(
348
- t.memberExpression(
349
- t.identifier(`$${uniqueID}$GLOBAL$`),
350
- t.identifier(referencePath.node.name)
351
- )
352
- )
353
- }
354
- for (const referencePath of binding.constantViolations)
355
- if ("AssignmentExpression" == referencePath.node.type)
356
- for (const [name, node] of Object.entries(
357
- t.getBindingIdentifiers(referencePath.node)
358
- ))
359
- if (name == declarator.id.name) {
360
- clearObject(node)
361
- Object.assign(
362
- node,
363
- t.memberExpression(
364
- t.identifier(`$${uniqueID}$GLOBAL$`),
365
- t.identifier(name)
366
- )
367
- )
368
- }
369
- globalBlockPath.remove()
370
- globalBlockStatementPath.remove()
371
- declarator.init &&
372
- globalBlock.body.splice(
373
- globalBlockIndex,
374
- 0,
375
- t.expressionStatement(
376
- t.assignmentExpression(
377
- "=",
378
- t.memberExpression(
379
- t.identifier(`$${uniqueID}$GLOBAL$`),
380
- t.identifier(declarator.id.name)
381
- ),
382
- declarator.init
383
- )
384
- )
385
- )
386
- } else {
387
- globalBlockPath.remove()
388
- globalBlockStatementPath.remove()
389
- mainFunction.body.body.unshift(globalBlockStatement)
390
- hoistedGlobalBlockFunctions++
391
- }
392
- } else globalBlockVariables.add(declarator.id.name)
393
- } else if ("ClassDeclaration" == globalBlockStatement.type) {
288
+ ])
289
+ )
290
+ }
291
+ program.node.body = [mainFunction]
292
+ if (globalBlock.body.length) {
293
+ ;(exports.size || liveExports.size) &&
294
+ mainFunction.body.body.push(
295
+ t.returnStatement(
296
+ t.objectExpression([
297
+ ...[...exports].map(([local, exported]) =>
298
+ t.objectProperty(t.identifier(exported), t.identifier(local))
299
+ ),
300
+ ...[...liveExports].map(([local, exported]) =>
301
+ t.objectMethod(
302
+ "get",
303
+ t.identifier(exported),
304
+ [],
305
+ t.blockStatement([t.returnStatement(t.identifier(local))])
306
+ )
307
+ )
308
+ ])
309
+ )
310
+ )
311
+ program.scope.crawl()
312
+ const globalBlockVariables = new Set()
313
+ let hoistedGlobalBlockFunctions = 0
314
+ for (const [globalBlockIndex, globalBlockStatement] of [...globalBlock.body.entries()].reverse())
315
+ if ("VariableDeclaration" == globalBlockStatement.type) {
316
+ assert(1 == globalBlockStatement.declarations.length, "src/processScript/transform.ts:404:59")
317
+ const declarator = globalBlockStatement.declarations[0]
318
+ assert(
319
+ "Identifier" == declarator.id.type,
320
+ `src/processScript/transform.ts:408:51 declarator.id.type was "${declarator.id.type}"`
321
+ )
322
+ program.scope.crawl()
323
+ if (program.scope.hasGlobal(declarator.id.name)) {
324
+ globalBlock.body.splice(globalBlockIndex, 1)
325
+ const [globalBlockPath] = program.unshiftContainer("body", globalBlock),
326
+ [globalBlockStatementPath] = program.unshiftContainer("body", globalBlockStatement)
394
327
  program.scope.crawl()
395
- assert(globalBlockStatement.id, "src/processScript/transform.ts:544:37")
396
- if (program.scope.hasGlobal(globalBlockStatement.id.name)) {
397
- globalBlock.body.splice(globalBlockIndex, 1)
398
- const [globalBlockPath] = program.unshiftContainer("body", globalBlock),
399
- [globalBlockStatementPath] = program.unshiftContainer("body", globalBlockStatement)
400
- program.scope.crawl()
401
- const binding = program.scope.getBinding(globalBlockStatement.id.name)
402
- assert(binding)
328
+ if (
329
+ !declarator.init ||
330
+ ("FunctionExpression" != declarator.init.type &&
331
+ "ArrowFunctionExpression" != declarator.init.type) ||
332
+ Object.keys(program.scope.globals).some(global => globalBlockVariables.has(global))
333
+ ) {
334
+ const binding = program.scope.getBinding(declarator.id.name)
335
+ assert(binding, "src/processScript/transform.ts:427:23")
403
336
  for (const referencePath of binding.referencePaths) {
404
- assert("Identifier" == referencePath.node.type)
337
+ assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:430:56")
405
338
  referencePath.replaceWith(
406
339
  t.memberExpression(
407
340
  t.identifier(`$${uniqueID}$GLOBAL$`),
@@ -409,253 +342,354 @@ const { default: traverse } = babelTraverse,
409
342
  )
410
343
  )
411
344
  }
345
+ for (const referencePath of binding.constantViolations)
346
+ if ("AssignmentExpression" == referencePath.node.type)
347
+ for (const [name, node] of Object.entries(t.getBindingIdentifiers(referencePath.node)))
348
+ if (name == declarator.id.name) {
349
+ clearObject(node)
350
+ Object.assign(
351
+ node,
352
+ t.memberExpression(t.identifier(`$${uniqueID}$GLOBAL$`), t.identifier(name))
353
+ )
354
+ }
412
355
  globalBlockPath.remove()
413
356
  globalBlockStatementPath.remove()
414
- globalBlock.body.splice(
415
- globalBlockIndex,
416
- 0,
417
- t.expressionStatement(
418
- t.assignmentExpression(
419
- "=",
420
- t.memberExpression(
421
- t.identifier(`$${uniqueID}$GLOBAL$`),
422
- t.identifier(globalBlockStatement.id.name)
423
- ),
424
- t.classExpression(
425
- void 0,
426
- globalBlockStatement.superClass,
427
- globalBlockStatement.body,
428
- globalBlockStatement.decorators
357
+ declarator.init &&
358
+ globalBlock.body.splice(
359
+ globalBlockIndex,
360
+ 0,
361
+ t.expressionStatement(
362
+ t.assignmentExpression(
363
+ "=",
364
+ t.memberExpression(
365
+ t.identifier(`$${uniqueID}$GLOBAL$`),
366
+ t.identifier(declarator.id.name)
367
+ ),
368
+ declarator.init
429
369
  )
430
370
  )
431
371
  )
372
+ } else {
373
+ globalBlockPath.remove()
374
+ globalBlockStatementPath.remove()
375
+ mainFunction.body.body.unshift(globalBlockStatement)
376
+ hoistedGlobalBlockFunctions++
377
+ }
378
+ } else globalBlockVariables.add(declarator.id.name)
379
+ } else if ("ClassDeclaration" == globalBlockStatement.type) {
380
+ program.scope.crawl()
381
+ assert(globalBlockStatement.id, "src/processScript/transform.ts:481:37")
382
+ if (program.scope.hasGlobal(globalBlockStatement.id.name)) {
383
+ globalBlock.body.splice(globalBlockIndex, 1)
384
+ const [globalBlockPath] = program.unshiftContainer("body", globalBlock),
385
+ [globalBlockStatementPath] = program.unshiftContainer("body", globalBlockStatement)
386
+ program.scope.crawl()
387
+ const binding = program.scope.getBinding(globalBlockStatement.id.name)
388
+ assert(binding, "src/processScript/transform.ts:493:22")
389
+ for (const referencePath of binding.referencePaths) {
390
+ assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:496:55")
391
+ referencePath.replaceWith(
392
+ t.memberExpression(
393
+ t.identifier(`$${uniqueID}$GLOBAL$`),
394
+ t.identifier(referencePath.node.name)
395
+ )
432
396
  )
433
397
  }
434
- }
435
- if (program.scope.hasGlobal("_EXPORTS"))
436
- for (const referencePath of getReferencePathsToGlobal("_EXPORTS", program))
437
- referencePath.replaceWith(
438
- t.arrayExpression([...exports.keys(), ...liveExports.keys()].map(name => t.stringLiteral(name)))
398
+ globalBlockPath.remove()
399
+ globalBlockStatementPath.remove()
400
+ globalBlock.body.splice(
401
+ globalBlockIndex,
402
+ 0,
403
+ t.expressionStatement(
404
+ t.assignmentExpression(
405
+ "=",
406
+ t.memberExpression(
407
+ t.identifier(`$${uniqueID}$GLOBAL$`),
408
+ t.identifier(globalBlockStatement.id.name)
409
+ ),
410
+ t.classExpression(
411
+ void 0,
412
+ globalBlockStatement.superClass,
413
+ globalBlockStatement.body,
414
+ globalBlockStatement.decorators
415
+ )
416
+ )
417
+ )
439
418
  )
440
- globalBlock.body.length &&
441
- mainFunction.body.body.splice(
442
- hoistedGlobalBlockFunctions,
443
- 0,
444
- t.ifStatement(t.unaryExpression("!", t.identifier(`$${uniqueID}$FMCL$`)), globalBlock)
419
+ }
420
+ }
421
+ if (program.scope.hasGlobal("_EXPORTS"))
422
+ for (const referencePath of getReferencePathsToGlobal("_EXPORTS", program))
423
+ referencePath.replaceWith(
424
+ t.arrayExpression([...exports.keys(), ...liveExports.keys()].map(name => t.stringLiteral(name)))
445
425
  )
446
- }
447
- functionDotPrototypeIsReferencedMultipleTimes &&
448
- mainFunction.body.body.unshift(
449
- t.variableDeclaration("let", [
450
- t.variableDeclarator(
451
- t.identifier(`_${uniqueID}_FUNCTION_DOT_PROTOTYPE_`),
452
- createGetFunctionPrototypeNode()
453
- )
454
- ])
426
+ globalBlock.body.length &&
427
+ mainFunction.body.body.splice(
428
+ hoistedGlobalBlockFunctions,
429
+ 0,
430
+ t.ifStatement(t.unaryExpression("!", t.identifier(`$${uniqueID}$FMCL$`)), globalBlock)
455
431
  )
456
- needGetPrototypeOf &&
457
- mainFunction.body.body.unshift(
458
- t.variableDeclaration("let", [
459
- t.variableDeclarator(
460
- t.objectPattern([
461
- t.objectProperty(t.identifier("get"), t.identifier(`_${uniqueID}_DUNDER_PROTO_GETTER_`))
462
- ]),
463
- t.callExpression(
464
- t.memberExpression(t.identifier("Object"), t.identifier("getOwnPropertyDescriptor")),
465
- [
466
- t.memberExpression(t.identifier("Object"), t.identifier("prototype")),
467
- t.stringLiteral("__proto__")
468
- ]
469
- )
470
- ),
471
- t.variableDeclarator(
472
- t.identifier(`_${uniqueID}_GET_PROTOTYPE_OF_`),
473
- t.callExpression(
432
+ }
433
+ functionDotPrototypeIsReferencedMultipleTimes &&
434
+ mainFunction.body.body.unshift(
435
+ t.variableDeclaration("let", [
436
+ t.variableDeclarator(
437
+ t.identifier(`_${uniqueID}_FUNCTION_DOT_PROTOTYPE_`),
438
+ createGetFunctionPrototypeNode()
439
+ )
440
+ ])
441
+ )
442
+ needGetPrototypeOf &&
443
+ mainFunction.body.body.unshift(
444
+ t.variableDeclaration("let", [
445
+ t.variableDeclarator(
446
+ t.objectPattern([
447
+ t.objectProperty(t.identifier("get"), t.identifier(`_${uniqueID}_DUNDER_PROTO_GETTER_`))
448
+ ]),
449
+ t.callExpression(
450
+ t.memberExpression(t.identifier("Object"), t.identifier("getOwnPropertyDescriptor")),
451
+ [
452
+ t.memberExpression(t.identifier("Object"), t.identifier("prototype")),
453
+ t.stringLiteral("__proto__")
454
+ ]
455
+ )
456
+ ),
457
+ t.variableDeclarator(
458
+ t.identifier(`_${uniqueID}_GET_PROTOTYPE_OF_`),
459
+ t.callExpression(
460
+ t.memberExpression(
474
461
  t.memberExpression(
475
- t.memberExpression(
476
- t.identifier(
477
- globalFunctionsUnder7Characters.find(name => !program.scope.hasOwnBinding(name))
478
- ),
479
- t.identifier("call")
462
+ t.identifier(
463
+ globalFunctionsUnder7Characters.find(name => !program.scope.hasOwnBinding(name))
480
464
  ),
481
- t.identifier("bind")
465
+ t.identifier("call")
482
466
  ),
483
- [t.identifier(`_${uniqueID}_DUNDER_PROTO_GETTER_`)]
484
- )
467
+ t.identifier("bind")
468
+ ),
469
+ [t.identifier(`_${uniqueID}_DUNDER_PROTO_GETTER_`)]
485
470
  )
486
- ])
487
- )
488
- consoleMethodsReferenced.size &&
489
- mainFunction.body.body.unshift(
490
- t.variableDeclaration(
491
- "let",
492
- [...consoleMethodsReferenced].map(name =>
493
- t.variableDeclarator(
494
- t.identifier(`_${uniqueID}_CONSOLE_METHOD_${name}_`),
495
- t.arrowFunctionExpression(
496
- [t.restElement(t.identifier("args"))],
497
- t.unaryExpression(
498
- "void",
499
- t.callExpression(t.identifier(`$${uniqueID}$DEBUG$`), [t.identifier("args")])
500
- )
471
+ )
472
+ ])
473
+ )
474
+ consoleMethodsReferenced.size &&
475
+ mainFunction.body.body.unshift(
476
+ t.variableDeclaration(
477
+ "let",
478
+ [...consoleMethodsReferenced].map(name =>
479
+ t.variableDeclarator(
480
+ t.identifier(`_${uniqueID}_CONSOLE_METHOD_${name}_`),
481
+ t.arrowFunctionExpression(
482
+ [t.restElement(t.identifier("args"))],
483
+ t.unaryExpression(
484
+ "void",
485
+ t.callExpression(t.identifier(`$${uniqueID}$DEBUG$`), [t.identifier("args")])
501
486
  )
502
487
  )
503
488
  )
504
489
  )
505
490
  )
506
- neededDbMethodLets.size &&
507
- mainFunction.body.body.unshift(
508
- t.variableDeclaration(
509
- "let",
510
- [...neededDbMethodLets].map(name => {
511
- const getArgs = () =>
512
- "ObjectId" == name ? []
513
- : "i" == name || "r" == name ? [t.identifier("a")]
514
- : [t.identifier("a"), t.identifier("b")]
515
- return t.variableDeclarator(
516
- t.identifier(`_${uniqueID}_CONSOLE_METHOD_${name}_`),
517
- t.arrowFunctionExpression(
518
- getArgs(),
519
- t.callExpression(t.identifier(`$${uniqueID}$DB$${name}$`), getArgs())
520
- )
491
+ )
492
+ neededDbMethodLets.size &&
493
+ mainFunction.body.body.unshift(
494
+ t.variableDeclaration(
495
+ "let",
496
+ [...neededDbMethodLets].map(name => {
497
+ const getArgs = () =>
498
+ "ObjectId" == name ? []
499
+ : "i" == name || "r" == name ? [t.identifier("a")]
500
+ : [t.identifier("a"), t.identifier("b")]
501
+ return t.variableDeclarator(
502
+ t.identifier(`_${uniqueID}_CONSOLE_METHOD_${name}_`),
503
+ t.arrowFunctionExpression(
504
+ getArgs(),
505
+ t.callExpression(t.identifier(`$${uniqueID}$DB$${name}$`), getArgs())
521
506
  )
522
- })
523
- )
507
+ )
508
+ })
524
509
  )
525
- needDebugLet &&
526
- mainFunction.body.body.unshift(
527
- t.variableDeclaration("let", [
510
+ )
511
+ needDebugLet &&
512
+ mainFunction.body.body.unshift(
513
+ t.variableDeclaration("let", [
514
+ t.variableDeclarator(
515
+ t.identifier(`_${uniqueID}_DEBUG_`),
516
+ t.callExpression(t.identifier(`$${uniqueID}$DEBUG$`), [t.identifier("a")])
517
+ )
518
+ ])
519
+ )
520
+ neededSubscriptLets.size &&
521
+ mainFunction.body.body.unshift(
522
+ t.variableDeclaration(
523
+ "let",
524
+ [...neededSubscriptLets].map(name =>
528
525
  t.variableDeclarator(
529
- t.identifier(`_${uniqueID}_DEBUG_`),
530
- t.callExpression(t.identifier(`$${uniqueID}$DEBUG$`), [t.identifier("a")])
526
+ t.identifier(`_${uniqueID}_SUBSCRIPT_${name}_`),
527
+ t.arrowFunctionExpression(
528
+ [t.restElement(t.identifier("args"))],
529
+ t.callExpression(t.identifier(`$${uniqueID}$SUBSCRIPT$${name}$`), [
530
+ t.spreadElement(t.identifier("args"))
531
+ ])
532
+ )
531
533
  )
532
- ])
534
+ )
533
535
  )
534
- neededSubscriptLets.size &&
535
- mainFunction.body.body.unshift(
536
- t.variableDeclaration(
537
- "let",
538
- [...neededSubscriptLets].map(name =>
539
- t.variableDeclarator(
540
- t.identifier(`_${uniqueID}_SUBSCRIPT_${name}_`),
541
- t.arrowFunctionExpression(
542
- [t.restElement(t.identifier("args"))],
543
- t.callExpression(t.identifier(`$${uniqueID}$SUBSCRIPT$${name}$`), [
544
- t.spreadElement(t.identifier("args"))
545
- ])
536
+ )
537
+ traverse(file, {
538
+ BlockStatement({ node: blockStatement }) {
539
+ for (const [index, functionDeclaration] of blockStatement.body.entries())
540
+ if ("FunctionDeclaration" == functionDeclaration.type && !functionDeclaration.generator) {
541
+ blockStatement.body.splice(index, 1)
542
+ blockStatement.body.unshift(
543
+ t.variableDeclaration("let", [
544
+ t.variableDeclarator(
545
+ functionDeclaration.id,
546
+ t.arrowFunctionExpression(
547
+ functionDeclaration.params,
548
+ functionDeclaration.body,
549
+ functionDeclaration.async
550
+ )
546
551
  )
547
- )
552
+ ])
548
553
  )
554
+ }
555
+ },
556
+ ClassBody({ node: classBody, scope, parent }) {
557
+ assert(t.isClass(parent), "src/processScript/transform.ts:663:30")
558
+ let thisIsReferenced = !1
559
+ for (const classMethod of classBody.body) {
560
+ if ("ClassMethod" != classMethod.type) continue
561
+ let methodReferencesThis = !1
562
+ traverse(
563
+ classMethod.body,
564
+ {
565
+ ThisExpression(path) {
566
+ methodReferencesThis = !0
567
+ thisIsReferenced = !0
568
+ path.replaceWith(t.identifier(`_${uniqueID}_THIS_`))
569
+ },
570
+ Function: path => path.skip()
571
+ },
572
+ scope
549
573
  )
550
- )
551
- traverse(file, {
552
- BlockStatement({ node: blockStatement }) {
553
- for (const [index, functionDeclaration] of blockStatement.body.entries())
554
- if ("FunctionDeclaration" == functionDeclaration.type && !functionDeclaration.generator) {
555
- blockStatement.body.splice(index, 1)
556
- blockStatement.body.unshift(
574
+ if (methodReferencesThis)
575
+ if ("constructor" != classMethod.kind)
576
+ classMethod.body.body.unshift(
557
577
  t.variableDeclaration("let", [
558
578
  t.variableDeclarator(
559
- functionDeclaration.id,
560
- t.arrowFunctionExpression(
561
- functionDeclaration.params,
562
- functionDeclaration.body,
563
- functionDeclaration.async
564
- )
579
+ t.identifier(`_${uniqueID}_THIS_`),
580
+ t.callExpression(t.memberExpression(t.super(), t.identifier("valueOf")), [])
565
581
  )
566
582
  ])
567
583
  )
568
- }
569
- },
570
- ClassBody({ node: classBody, scope, parent }) {
571
- assert(t.isClass(parent))
572
- let thisIsReferenced = !1
573
- for (const classMethod of classBody.body) {
574
- if ("ClassMethod" != classMethod.type) continue
575
- let methodReferencesThis = !1
576
- traverse(
577
- classMethod.body,
578
- {
579
- ThisExpression(path) {
580
- methodReferencesThis = !0
581
- thisIsReferenced = !0
582
- path.replaceWith(t.identifier(`_${uniqueID}_THIS_`))
584
+ else {
585
+ const superCalls = []
586
+ traverse(
587
+ classMethod.body,
588
+ {
589
+ CallExpression(path) {
590
+ "Super" == path.node.callee.type && superCalls.push(path)
591
+ }
583
592
  },
584
- Function(path) {
585
- path.skip()
593
+ scope
594
+ )
595
+ if (superCalls.length)
596
+ if (
597
+ 1 == superCalls.length &&
598
+ "ExpressionStatement" == superCalls[0].parent.type &&
599
+ superCalls[0].parentPath.parentPath.parent == classMethod
600
+ )
601
+ superCalls[0].parentPath.replaceWith(
602
+ t.variableDeclaration("let", [
603
+ t.variableDeclarator(t.identifier(`_${uniqueID}_THIS_`), superCalls[0].node)
604
+ ])
605
+ )
606
+ else {
607
+ for (const path of superCalls)
608
+ path.replaceWith(
609
+ t.assignmentExpression("=", t.identifier(`_${uniqueID}_THIS_`), path.node)
610
+ )
611
+ classMethod.body.body.unshift(
612
+ t.variableDeclaration("let", [
613
+ t.variableDeclarator(t.identifier(`_${uniqueID}_THIS_`))
614
+ ])
615
+ )
586
616
  }
587
- },
588
- scope
589
- )
590
- if (methodReferencesThis)
591
- if ("constructor" != classMethod.kind)
617
+ else
592
618
  classMethod.body.body.unshift(
593
619
  t.variableDeclaration("let", [
594
620
  t.variableDeclarator(
595
621
  t.identifier(`_${uniqueID}_THIS_`),
596
- t.callExpression(t.memberExpression(t.super(), t.identifier("valueOf")), [])
622
+ t.callExpression(t.super(), [])
597
623
  )
598
624
  ])
599
625
  )
600
- else {
601
- const superCalls = []
602
- traverse(
603
- classMethod.body,
604
- {
605
- CallExpression(path) {
606
- "Super" == path.node.callee.type && superCalls.push(path)
607
- }
608
- },
609
- scope
610
- )
611
- if (superCalls.length)
612
- if (
613
- 1 == superCalls.length &&
614
- "ExpressionStatement" == superCalls[0].parent.type &&
615
- superCalls[0].parentPath.parentPath.parent == classMethod
616
- )
617
- superCalls[0].parentPath.replaceWith(
618
- t.variableDeclaration("let", [
619
- t.variableDeclarator(t.identifier(`_${uniqueID}_THIS_`), superCalls[0].node)
620
- ])
621
- )
622
- else {
623
- for (const path of superCalls)
624
- path.replaceWith(
625
- t.assignmentExpression("=", t.identifier(`_${uniqueID}_THIS_`), path.node)
626
- )
627
- classMethod.body.body.unshift(
628
- t.variableDeclaration("let", [
629
- t.variableDeclarator(t.identifier(`_${uniqueID}_THIS_`))
630
- ])
631
- )
632
- }
633
- else
634
- classMethod.body.body.unshift(
635
- t.variableDeclaration("let", [
636
- t.variableDeclarator(
637
- t.identifier(`_${uniqueID}_THIS_`),
638
- t.callExpression(t.super(), [])
639
- )
640
- ])
641
- )
642
- }
643
- }
644
- !parent.superClass && thisIsReferenced && (parent.superClass = t.identifier("Object"))
645
- },
646
- VariableDeclaration({ node: variableDeclaration }) {
647
- "const" == variableDeclaration.kind && (variableDeclaration.kind = "let")
648
- },
649
- ThisExpression(path) {
650
- path.replaceWith(t.identifier("undefined"))
651
- },
652
- BigIntLiteral(path) {
653
- const bigIntAsNumber = Number(path.node.value)
654
- BigInt(bigIntAsNumber) == BigInt(path.node.value) ?
655
- path.replaceWith(t.callExpression(t.identifier("BigInt"), [t.numericLiteral(bigIntAsNumber)]))
656
- : path.replaceWith(t.callExpression(t.identifier("BigInt"), [t.stringLiteral(path.node.value)]))
626
+ }
657
627
  }
658
- })
659
- return { file, seclevel }
628
+ !parent.superClass && thisIsReferenced && (parent.superClass = t.identifier("Object"))
629
+ },
630
+ VariableDeclaration({ node: variableDeclaration }) {
631
+ "const" == variableDeclaration.kind && (variableDeclaration.kind = "let")
632
+ },
633
+ ThisExpression: path => path.replaceWith(t.identifier("undefined")),
634
+ BigIntLiteral(path) {
635
+ const bigIntAsNumber = Number(path.node.value)
636
+ path.replaceWith(
637
+ t.callExpression(t.identifier("BigInt"), [
638
+ BigInt(bigIntAsNumber) == BigInt(path.node.value) ?
639
+ t.numericLiteral(bigIntAsNumber)
640
+ : t.stringLiteral(path.node.value)
641
+ ])
642
+ )
643
+ }
644
+ })
645
+ return { file, seclevel }
646
+ function createGetFunctionPrototypeNode() {
647
+ for (const globalFunction of globalFunctionsUnder7Characters)
648
+ if (!program.scope.hasOwnBinding(globalFunction))
649
+ return t.memberExpression(
650
+ t.memberExpression(t.identifier(globalFunction), t.identifier("constructor")),
651
+ t.identifier("prototype")
652
+ )
653
+ return t.memberExpression(
654
+ t.memberExpression(
655
+ t.arrowFunctionExpression([t.identifier("_")], t.identifier("_")),
656
+ t.identifier("constructor")
657
+ ),
658
+ t.identifier("prototype")
659
+ )
660
+ }
661
+ function processFakeSubscriptObject(fakeSubscriptObjectName) {
662
+ for (const referencePath of getReferencePathsToGlobal(fakeSubscriptObjectName, program)) {
663
+ assert("MemberExpression" == referencePath.parent.type, "src/processScript/transform.ts:777:60")
664
+ assert("Identifier" == referencePath.parent.property.type)
665
+ assert(
666
+ "MemberExpression" == referencePath.parentPath.parentPath?.node.type,
667
+ "src/processScript/transform.ts:779:81"
668
+ )
669
+ assert(
670
+ "Identifier" == referencePath.parentPath.parentPath.node.property.type,
671
+ "src/processScript/transform.ts:780:83"
672
+ )
673
+ assert(
674
+ /^[_a-z][\d_a-z]{0,24}$/.test(referencePath.parent.property.name),
675
+ `src/processScript/transform.ts:784:8 invalid user "${referencePath.parent.property.name}" in subscript`
676
+ )
677
+ assert(
678
+ /^[_a-z][\d_a-z]{0,24}$/.test(referencePath.parentPath.parentPath.node.property.name),
679
+ `src/processScript/transform.ts:789:8 invalid script name "${referencePath.parentPath.parentPath.node.property.name}" in subscript`
680
+ )
681
+ if ("CallExpression" == referencePath.parentPath.parentPath.parentPath?.type)
682
+ referencePath.parentPath.parentPath.replaceWith(
683
+ t.identifier(
684
+ `$${uniqueID}$SUBSCRIPT$${referencePath.parent.property.name}$${referencePath.parentPath.parentPath.node.property.name}$`
685
+ )
686
+ )
687
+ else {
688
+ const name = `${referencePath.parent.property.name}$${referencePath.parentPath.parentPath.node.property.name}`
689
+ referencePath.parentPath.parentPath.replaceWith(t.identifier(`_${uniqueID}_SUBSCRIPT_${name}_`))
690
+ neededSubscriptLets.add(name)
691
+ }
692
+ }
660
693
  }
661
- export { transform as default, transform }
694
+ }
695
+ export { transform }