hackmud-script-manager 0.19.1-bd545f5 → 0.19.1-c2f3057

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