hackmud-script-manager 0.19.1-27bbd7d → 0.19.1-29fcf72

package/processScript/transform.js

@@ -20,406 +20,294 @@ const { default: traverse } = babelTraverse,
 		"String",
 		"Symbol",
 		"BigInt"
-	],
-	transform = (
-		file,
-		sourceCode,
-		{ uniqueID = "00000000000", scriptUser = "UNKNOWN", scriptName = "UNKNOWN", seclevel = 4 } = {}
-	) => {
-		const topFunctionName = `_${uniqueID}_SCRIPT_`,
-			exports = new Map(),
-			liveExports = new Map()
-		let program
-		traverse(file, {
-			Program(path) {
-				program = path
-				path.skip()
-			}
-		})
-		if (program.scope.hasGlobal("_SOURCE"))
-			for (const referencePath of getReferencePathsToGlobal("_SOURCE", program))
-				referencePath.replaceWith(t.stringLiteral(sourceCode))
-		if (program.scope.hasGlobal("_BUILD_DATE"))
-			for (const referencePath of getReferencePathsToGlobal("_BUILD_DATE", program))
-				referencePath.replaceWith(t.numericLiteral(Date.now()))
-		if (program.scope.hasGlobal("_SCRIPT_USER"))
-			for (const referencePath of getReferencePathsToGlobal("_SCRIPT_USER", program))
-				1 == scriptUser ?
-					referencePath.replaceWith(t.stringLiteral(`$${uniqueID}$SCRIPT_USER$`))
-				:	referencePath.replaceWith(t.stringLiteral(scriptUser))
-		if (program.scope.hasGlobal("_SCRIPT_NAME"))
-			for (const referencePath of getReferencePathsToGlobal("_SCRIPT_NAME", program))
-				1 == scriptName ?
-					referencePath.replaceWith(t.stringLiteral(`$${uniqueID}$SCRIPT_NAME$`))
-				:	referencePath.replaceWith(t.stringLiteral(scriptName))
-		if (program.scope.hasGlobal("_FULL_SCRIPT_NAME"))
-			for (const referencePath of getReferencePathsToGlobal("_FULL_SCRIPT_NAME", program))
-				1 == scriptUser || 1 == scriptName ?
-					referencePath.replaceWith(t.stringLiteral(`$${uniqueID}$FULL_SCRIPT_NAME$`))
-				:	referencePath.replaceWith(t.stringLiteral(`${scriptUser}.${scriptName}`))
-		let functionDotPrototypeIsReferencedMultipleTimes = !1
-		const createGetFunctionPrototypeNode = () => {
-			for (const globalFunction of globalFunctionsUnder7Characters)
-				if (!program.scope.hasOwnBinding(globalFunction))
-					return t.memberExpression(
-						t.memberExpression(t.identifier(globalFunction), t.identifier("constructor")),
-						t.identifier("prototype")
-					)
-			return t.memberExpression(
-				t.memberExpression(
-					t.arrowFunctionExpression([t.identifier("_")], t.identifier("_")),
-					t.identifier("constructor")
-				),
-				t.identifier("prototype")
-			)
+	]
+function transform(
+	file,
+	sourceCode,
+	{ uniqueID = "00000000000", scriptUser = "UNKNOWN", scriptName = "UNKNOWN", seclevel = 4 } = {}
+) {
+	const topFunctionName = `_${uniqueID}_SCRIPT_`,
+		exports = new Map(),
+		liveExports = new Map()
+	let program
+	traverse(file, {
+		Program(path) {
+			program = path
+			path.skip()
 		}
-		if (program.scope.hasGlobal("Function")) {
-			const FunctionReferencePaths = getReferencePathsToGlobal("Function", program)
-			if (1 == FunctionReferencePaths.length) {
-				const referencePath = FunctionReferencePaths[0]
+	})
+	if (program.scope.hasGlobal("_SOURCE"))
+		for (const referencePath of getReferencePathsToGlobal("_SOURCE", program))
+			referencePath.replaceWith(t.stringLiteral(sourceCode))
+	if (program.scope.hasGlobal("_BUILD_DATE"))
+		for (const referencePath of getReferencePathsToGlobal("_BUILD_DATE", program))
+			referencePath.replaceWith(t.numericLiteral(Date.now()))
+	if (program.scope.hasGlobal("_SCRIPT_USER"))
+		for (const referencePath of getReferencePathsToGlobal("_SCRIPT_USER", program))
+			referencePath.replaceWith(t.stringLiteral(1 == scriptUser ? `$${uniqueID}$SCRIPT_USER$` : scriptUser))
+	if (program.scope.hasGlobal("_SCRIPT_NAME"))
+		for (const referencePath of getReferencePathsToGlobal("_SCRIPT_NAME", program))
+			referencePath.replaceWith(t.stringLiteral(1 == scriptName ? `$${uniqueID}$SCRIPT_NAME$` : scriptName))
+	if (program.scope.hasGlobal("_FULL_SCRIPT_NAME"))
+		for (const referencePath of getReferencePathsToGlobal("_FULL_SCRIPT_NAME", program))
+			referencePath.replaceWith(
+				t.stringLiteral(
+					1 == scriptUser || 1 == scriptName ?
+						`$${uniqueID}$FULL_SCRIPT_NAME$`
+					:	`${scriptUser}.${scriptName}`
+				)
+			)
+	let functionDotPrototypeIsReferencedMultipleTimes = !1
+	if (program.scope.hasGlobal("Function")) {
+		const FunctionReferencePaths = getReferencePathsToGlobal("Function", program)
+		if (1 == FunctionReferencePaths.length) {
+			const referencePath = FunctionReferencePaths[0]
+			assert(
+				"MemberExpression" == referencePath.parent.type,
+				"src/processScript/transform.ts:89:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+			)
+			assert(
+				"Identifier" == referencePath.parent.property.type,
+				"src/processScript/transform.ts:94:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+			)
+			assert(
+				"prototype" == referencePath.parent.property.name,
+				"src/processScript/transform.ts:99:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+			)
+			referencePath.parentPath.replaceWith(createGetFunctionPrototypeNode())
+		} else {
+			for (const referencePath of FunctionReferencePaths) {
 				assert(
 					"MemberExpression" == referencePath.parent.type,
-					"`Function` isn't available in hackmud, only `Function.prototype` is accessible"
+					"src/processScript/transform.ts:107:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 				)
 				assert(
 					"Identifier" == referencePath.parent.property.type,
-					"`Function` isn't available in hackmud, only `Function.prototype` is accessible"
+					"src/processScript/transform.ts:112:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 				)
 				assert(
 					"prototype" == referencePath.parent.property.name,
-					"`Function` isn't available in hackmud, only `Function.prototype` is accessible"
+					"src/processScript/transform.ts:117:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 				)
-				referencePath.parentPath.replaceWith(createGetFunctionPrototypeNode())
-			} else {
-				for (const referencePath of FunctionReferencePaths) {
-					assert(
-						"MemberExpression" == referencePath.parent.type,
-						"`Function` isn't available in hackmud, only `Function.prototype` is accessible"
-					)
-					assert(
-						"Identifier" == referencePath.parent.property.type,
-						"`Function` isn't available in hackmud, only `Function.prototype` is accessible"
-					)
-					assert(
-						"prototype" == referencePath.parent.property.name,
-						"`Function` isn't available in hackmud, only `Function.prototype` is accessible"
-					)
-					functionDotPrototypeIsReferencedMultipleTimes = !0
-					referencePath.parentPath.replaceWith(t.identifier(`_${uniqueID}_FUNCTION_DOT_PROTOTYPE_`))
-				}
 				functionDotPrototypeIsReferencedMultipleTimes = !0
+				referencePath.parentPath.replaceWith(t.identifier(`_${uniqueID}_FUNCTION_DOT_PROTOTYPE_`))
 			}
+			functionDotPrototypeIsReferencedMultipleTimes = !0
 		}
-		let detectedSeclevel = 4
-		const processFakeSubscriptObject = fakeSubscriptObjectName => {
-			for (const referencePath of getReferencePathsToGlobal(fakeSubscriptObjectName, program)) {
-				assert("MemberExpression" == referencePath.parent.type)
-				assert("Identifier" == referencePath.parent.property.type)
-				assert("MemberExpression" == referencePath.parentPath.parentPath?.node.type)
-				assert("Identifier" == referencePath.parentPath.parentPath.node.property.type)
-				assert(
-					/^[_a-z][\d_a-z]{0,24}$/.test(referencePath.parent.property.name),
-					`invalid user "${referencePath.parent.property.name}" in subscript`
-				)
-				assert(
-					/^[_a-z][\d_a-z]{0,24}$/.test(referencePath.parentPath.parentPath.node.property.name),
-					`invalid script name "${referencePath.parentPath.parentPath.node.property.name}" in subscript`
+	}
+	const neededSubscriptLets = new Set()
+	let detectedSeclevel = 4
+	for (const fakeSubscriptObjectName of ["$fs", "$4s", "$s"])
+		program.scope.hasGlobal(fakeSubscriptObjectName) && processFakeSubscriptObject(fakeSubscriptObjectName)
+	for (const fakeSubscriptObjectName of ["$hs", "$3s"])
+		if (program.scope.hasGlobal(fakeSubscriptObjectName)) {
+			detectedSeclevel = 3
+			processFakeSubscriptObject(fakeSubscriptObjectName)
+		}
+	for (const fakeSubscriptObjectName of ["$ms", "$2s"])
+		if (program.scope.hasGlobal(fakeSubscriptObjectName)) {
+			detectedSeclevel = 2
+			processFakeSubscriptObject(fakeSubscriptObjectName)
+		}
+	for (const fakeSubscriptObjectName of ["$ls", "$1s"])
+		if (program.scope.hasGlobal(fakeSubscriptObjectName)) {
+			detectedSeclevel = 1
+			processFakeSubscriptObject(fakeSubscriptObjectName)
+		}
+	for (const fakeSubscriptObjectName of ["$ns", "$0s"])
+		if (program.scope.hasGlobal(fakeSubscriptObjectName)) {
+			detectedSeclevel = 0
+			processFakeSubscriptObject(fakeSubscriptObjectName)
+		}
+	seclevel = Math.min(seclevel, detectedSeclevel)
+	const neededDbMethodLets = new Set()
+	if (program.scope.hasGlobal("$db"))
+		for (const referencePath of getReferencePathsToGlobal("$db", program)) {
+			assert("MemberExpression" == referencePath.parentPath.node.type, "src/processScript/transform.ts:171:69")
+			assert("Identifier" == referencePath.parentPath.node.property.type, "src/processScript/transform.ts:172:72")
+			const databaseOpMethodName = referencePath.parentPath.node.property.name
+			assert(
+				validDBMethods.includes(databaseOpMethodName),
+				`src/processScript/transform.ts:178:8 invalid db method "${databaseOpMethodName}", valid db methods are "${validDBMethods.join('", "')}"`
+			)
+			if ("CallExpression" == referencePath.parentPath.parentPath?.type)
+				referencePath.parentPath.replaceWith(t.identifier(`$${uniqueID}$DB$${databaseOpMethodName}$`))
+			else {
+				referencePath.parentPath.replaceWith(
+					t.identifier(`_${uniqueID}_CONSOLE_METHOD_${databaseOpMethodName}_`)
 				)
-				"CallExpression" == referencePath.parentPath.parentPath.parentPath?.type ?
-					referencePath.parentPath.parentPath.replaceWith(
-						t.identifier(
-							`$${uniqueID}$SUBSCRIPT$${referencePath.parent.property.name}$${referencePath.parentPath.parentPath.node.property.name}$`
-						)
-					)
-				:	referencePath.parentPath.parentPath.replaceWith(
-						t.arrowFunctionExpression(
-							[t.restElement(t.identifier("args"))],
-							t.callExpression(
-								t.identifier(
-									`$${uniqueID}$SUBSCRIPT$${referencePath.parent.property.name}$${referencePath.parentPath.parentPath.node.property.name}$`
-								),
-								[t.spreadElement(t.identifier("args"))]
-							)
-						)
-					)
+				neededDbMethodLets.add(databaseOpMethodName)
 			}
 		}
-		for (const fakeSubscriptObjectName of ["$fs", "$4s", "$s"])
-			program.scope.hasGlobal(fakeSubscriptObjectName) && processFakeSubscriptObject(fakeSubscriptObjectName)
-		for (const fakeSubscriptObjectName of ["$hs", "$3s"])
-			if (program.scope.hasGlobal(fakeSubscriptObjectName)) {
-				detectedSeclevel = 3
-				processFakeSubscriptObject(fakeSubscriptObjectName)
-			}
-		for (const fakeSubscriptObjectName of ["$ms", "$2s"])
-			if (program.scope.hasGlobal(fakeSubscriptObjectName)) {
-				detectedSeclevel = 2
-				processFakeSubscriptObject(fakeSubscriptObjectName)
-			}
-		for (const fakeSubscriptObjectName of ["$ls", "$1s"])
-			if (program.scope.hasGlobal(fakeSubscriptObjectName)) {
-				detectedSeclevel = 1
-				processFakeSubscriptObject(fakeSubscriptObjectName)
+	let needDebugLet = !1
+	if (program.scope.hasGlobal("$D"))
+		for (const referencePath of getReferencePathsToGlobal("$D", program))
+			if ("CallExpression" == referencePath.parentPath.type)
+				referencePath.replaceWith(t.identifier(`$${uniqueID}$DEBUG$`))
+			else {
+				referencePath.replaceWith(t.identifier(`_${uniqueID}_DEBUG_`))
+				needDebugLet = !0
 			}
-		for (const fakeSubscriptObjectName of ["$ns", "$0s"])
-			if (program.scope.hasGlobal(fakeSubscriptObjectName)) {
-				detectedSeclevel = 0
-				processFakeSubscriptObject(fakeSubscriptObjectName)
+	if (program.scope.hasGlobal("$FMCL"))
+		for (const referencePath of getReferencePathsToGlobal("$FMCL", program))
+			referencePath.replaceWith(t.identifier(`$${uniqueID}$FMCL$`))
+	if (program.scope.hasGlobal("$G"))
+		for (const referencePath of getReferencePathsToGlobal("$G", program))
+			referencePath.replaceWith(t.identifier(`$${uniqueID}$GLOBAL$`))
+	if (program.scope.hasGlobal("_SECLEVEL"))
+		for (const referencePath of getReferencePathsToGlobal("_SECLEVEL", program))
+			referencePath.replaceWith(t.numericLiteral(seclevel))
+	let needGetPrototypeOf = !1
+	if (program.scope.hasGlobal("Object"))
+		for (const referencePath of getReferencePathsToGlobal("Object", program))
+			if ("MemberExpression" == referencePath.parent.type && !referencePath.parent.computed) {
+				assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:225:64")
+				if ("getPrototypeOf" == referencePath.parent.property.name) {
+					referencePath.parentPath.replaceWith(t.identifier(`_${uniqueID}_GET_PROTOTYPE_OF_`))
+					needGetPrototypeOf = !0
+				}
 			}
-		seclevel = Math.min(seclevel, detectedSeclevel)
-		if (program.scope.hasGlobal("$db"))
-			for (const referencePath of getReferencePathsToGlobal("$db", program)) {
-				assert("MemberExpression" == referencePath.parentPath.node.type)
-				assert("Identifier" == referencePath.parentPath.node.property.type)
-				const databaseOpMethodName = referencePath.parentPath.node.property.name
-				assert(
-					validDBMethods.includes(databaseOpMethodName),
-					`invalid db method "${databaseOpMethodName}", valid db methods are "${validDBMethods.join('", "')}"`
+	const consoleMethodsReferenced = new Set()
+	if (program.scope.hasGlobal("console"))
+		for (const referencePath of getReferencePathsToGlobal("console", program))
+			if ("MemberExpression" == referencePath.parent.type && !referencePath.parent.computed) {
+				assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:240:64")
+				referencePath.parentPath.replaceWith(
+					t.identifier(`_${uniqueID}_CONSOLE_METHOD_${referencePath.parent.property.name}_`)
 				)
-				"CallExpression" == referencePath.parentPath.parentPath?.type ?
-					referencePath.parentPath.replaceWith(t.identifier(`$${uniqueID}$DB$${databaseOpMethodName}$`))
-				: "ObjectId" == databaseOpMethodName ?
-					referencePath.parentPath.replaceWith(
-						t.arrowFunctionExpression(
-							[],
-							t.callExpression(t.identifier(`$${uniqueID}$DB$${databaseOpMethodName}$`), [])
-						)
-					)
-				: "i" == databaseOpMethodName || "r" == databaseOpMethodName ?
-					referencePath.parentPath.replaceWith(
-						t.arrowFunctionExpression(
-							[t.identifier("a")],
-							t.callExpression(t.identifier(`$${uniqueID}$DB$${databaseOpMethodName}$`), [
-								t.identifier("a")
-							])
-						)
-					)
-				:	referencePath.parentPath.replaceWith(
-						t.arrowFunctionExpression(
-							[t.identifier("a"), t.identifier("b")],
-							t.callExpression(t.identifier(`$${uniqueID}$DB$${databaseOpMethodName}$`), [
-								t.identifier("a"),
-								t.identifier("b")
-							])
-						)
-					)
-			}
-		if (program.scope.hasGlobal("$D"))
-			for (const referencePath of getReferencePathsToGlobal("$D", program))
-				"CallExpression" == referencePath.parentPath.type ?
-					referencePath.replaceWith(t.identifier(`$${uniqueID}$DEBUG$`))
-				:	referencePath.replaceWith(
-						t.arrowFunctionExpression(
-							[t.identifier("a")],
-							t.callExpression(t.identifier(`$${uniqueID}$DEBUG$`), [t.identifier("a")])
-						)
-					)
-		if (program.scope.hasGlobal("$FMCL"))
-			for (const referencePath of getReferencePathsToGlobal("$FMCL", program))
-				referencePath.replaceWith(t.identifier(`$${uniqueID}$FMCL$`))
-		if (program.scope.hasGlobal("$G"))
-			for (const referencePath of getReferencePathsToGlobal("$G", program))
-				referencePath.replaceWith(t.identifier(`$${uniqueID}$GLOBAL$`))
-		if (program.scope.hasGlobal("_SECLEVEL"))
-			for (const referencePath of getReferencePathsToGlobal("_SECLEVEL", program))
-				referencePath.replaceWith(t.numericLiteral(seclevel))
-		let needGetPrototypeOf = !1,
-			needSetPrototypeOf = !1
-		if (program.scope.hasGlobal("Object"))
-			for (const referencePath of getReferencePathsToGlobal("Object", program))
-				if ("MemberExpression" == referencePath.parent.type && !referencePath.parent.computed) {
-					assert("Identifier" == referencePath.parent.property.type)
-					if ("getPrototypeOf" == referencePath.parent.property.name) {
-						referencePath.parentPath.replaceWith(t.identifier(`_${uniqueID}_GET_PROTOTYPE_OF_`))
-						needGetPrototypeOf = !0
-					} else if ("setPrototypeOf" == referencePath.parent.property.name) {
-						referencePath.parentPath.replaceWith(t.identifier(`_${uniqueID}_SET_PROTOTYPE_OF_`))
-						needSetPrototypeOf = !0
-					}
-				}
-		const lastStatement = program.node.body.at(-1)
-		let exportDefaultName
-		assert(lastStatement, "program is empty")
-		if ("ExportNamedDeclaration" == lastStatement.type) {
-			program.node.body.pop()
-			for (const specifier of lastStatement.specifiers) {
-				assert("ExportSpecifier" == specifier.type, specifier.type + " is currently unsupported")
-				const exportedName =
-					"Identifier" == specifier.exported.type ? specifier.exported.name : specifier.exported.value
-				"default" == exportedName ?
-					(exportDefaultName = specifier.local.name)
-				:	exports.set(specifier.local.name, exportedName)
+				consoleMethodsReferenced.add(referencePath.parent.property.name)
 			}
+	const lastStatement = program.node.body.at(-1)
+	let exportDefaultName
+	assert(lastStatement, "src/processScript/transform.ts:254:27 program is empty")
+	if ("ExportNamedDeclaration" == lastStatement.type) {
+		program.node.body.pop()
+		for (const specifier of lastStatement.specifiers) {
+			assert(
+				"ExportSpecifier" == specifier.type,
+				`src/processScript/transform.ts:260:51 ${specifier.type} is currently unsupported`
+			)
+			const exportedName =
+				"Identifier" == specifier.exported.type ? specifier.exported.name : specifier.exported.value
+			"default" == exportedName ?
+				(exportDefaultName = specifier.local.name)
+			:	exports.set(specifier.local.name, exportedName)
 		}
-		const globalBlock = t.blockStatement([])
-		let mainFunction
-		for (const statement of program.node.body)
-			if ("VariableDeclaration" == statement.type)
-				for (const declarator of statement.declarations)
-					if (
-						"Identifier" != declarator.id.type ||
-						declarator.id.name != exportDefaultName ||
-						!declarator.init ||
-						("FunctionExpression" != declarator.init.type &&
-							"ArrowFunctionExpression" != declarator.init.type) ||
-						declarator.init.async ||
-						declarator.init.generator
-					) {
-						for (const identifierName in t.getBindingIdentifiers(declarator.id)) {
-							identifierName == exportDefaultName &&
-								(mainFunction = t.functionDeclaration(
-									t.identifier(topFunctionName),
-									[t.identifier("context"), t.identifier("args")],
-									t.blockStatement([
-										t.returnStatement(t.callExpression(t.identifier(exportDefaultName), []))
-									])
-								))
-							if ("const" != statement.kind && exports.has(identifierName)) {
-								liveExports.set(identifierName, exports.get(identifierName))
-								exports.delete(identifierName)
-							}
-							globalBlock.body.push(
-								t.variableDeclaration("let", [t.variableDeclarator(t.identifier(identifierName))])
-							)
+	}
+	const globalBlock = t.blockStatement([])
+	let mainFunction
+	for (const statement of program.node.body)
+		if ("VariableDeclaration" == statement.type)
+			for (const declarator of statement.declarations)
+				if (
+					"Identifier" != declarator.id.type ||
+					declarator.id.name != exportDefaultName ||
+					!declarator.init ||
+					("FunctionExpression" != declarator.init.type &&
+						"ArrowFunctionExpression" != declarator.init.type) ||
+					declarator.init.async ||
+					declarator.init.generator
+				) {
+					for (const identifierName in t.getBindingIdentifiers(declarator.id)) {
+						identifierName == exportDefaultName &&
+							(mainFunction = t.functionDeclaration(
+								t.identifier(topFunctionName),
+								[t.identifier("context"), t.identifier("args")],
+								t.blockStatement([
+									t.returnStatement(t.callExpression(t.identifier(exportDefaultName), []))
+								])
+							))
+						if ("const" != statement.kind && exports.has(identifierName)) {
+							liveExports.set(identifierName, exports.get(identifierName))
+							exports.delete(identifierName)
 						}
-						declarator.init &&
-							globalBlock.body.push(
-								t.expressionStatement(t.assignmentExpression("=", declarator.id, declarator.init))
-							)
-					} else
-						mainFunction = t.functionDeclaration(
-							t.identifier(topFunctionName),
-							declarator.init.params,
-							"BlockStatement" == declarator.init.body.type ?
-								declarator.init.body
-							:	t.blockStatement([t.returnStatement(declarator.init.body)])
+						globalBlock.body.push(
+							t.variableDeclaration("let", [t.variableDeclarator(t.identifier(identifierName))])
 						)
-			else
-				"FunctionDeclaration" == statement.type ?
-					statement.id.name == exportDefaultName ?
-						(mainFunction = statement)
-					:	globalBlock.body.push(
-							t.variableDeclaration("let", [
-								t.variableDeclarator(
-									statement.id,
-									t.functionExpression(
-										void 0,
-										statement.params,
-										statement.body,
-										statement.generator,
-										statement.async
-									)
-								)
-							])
+					}
+					declarator.init &&
+						globalBlock.body.push(
+							t.expressionStatement(t.assignmentExpression("=", declarator.id, declarator.init))
 						)
-				:	globalBlock.body.push(statement)
-		mainFunction ||= t.functionDeclaration(
-			t.identifier(topFunctionName),
-			[t.identifier("context"), t.identifier("args")],
-			t.blockStatement([])
-		)
-		program.node.body = [mainFunction]
-		if (globalBlock.body.length) {
-			;(exports.size || liveExports.size) &&
-				mainFunction.body.body.push(
-					t.returnStatement(
-						t.objectExpression([
-							...[...exports].map(([local, exported]) =>
-								t.objectProperty(t.identifier(exported), t.identifier(local))
-							),
-							...[...liveExports].map(([local, exported]) =>
-								t.objectMethod(
-									"get",
-									t.identifier(exported),
-									[],
-									t.blockStatement([t.returnStatement(t.identifier(local))])
+				} else
+					mainFunction = t.functionDeclaration(
+						t.identifier(topFunctionName),
+						declarator.init.params,
+						"BlockStatement" == declarator.init.body.type ?
+							declarator.init.body
+						:	t.blockStatement([t.returnStatement(declarator.init.body)])
+					)
+		else
+			"FunctionDeclaration" == statement.type ?
+				statement.id.name == exportDefaultName ?
+					(mainFunction = statement)
+				:	globalBlock.body.push(
+						t.variableDeclaration("let", [
+							t.variableDeclarator(
+								statement.id,
+								t.functionExpression(
+									void 0,
+									statement.params,
+									statement.body,
+									statement.generator,
+									statement.async
 								)
 							)
 						])
 					)
+			:	globalBlock.body.push(statement)
+	mainFunction ||= t.functionDeclaration(
+		t.identifier(topFunctionName),
+		[t.identifier("context"), t.identifier("args")],
+		t.blockStatement([])
+	)
+	program.node.body = [mainFunction]
+	if (globalBlock.body.length) {
+		;(exports.size || liveExports.size) &&
+			mainFunction.body.body.push(
+				t.returnStatement(
+					t.objectExpression([
+						...[...exports].map(([local, exported]) =>
+							t.objectProperty(t.identifier(exported), t.identifier(local))
+						),
+						...[...liveExports].map(([local, exported]) =>
+							t.objectMethod(
+								"get",
+								t.identifier(exported),
+								[],
+								t.blockStatement([t.returnStatement(t.identifier(local))])
+							)
+						)
+					])
 				)
-			program.scope.crawl()
-			const globalBlockVariables = new Set()
-			let hoistedGlobalBlockFunctions = 0
-			for (const [globalBlockIndex, globalBlockStatement] of [...globalBlock.body.entries()].reverse())
-				if ("VariableDeclaration" == globalBlockStatement.type) {
-					assert(1 == globalBlockStatement.declarations.length)
-					const declarator = globalBlockStatement.declarations[0]
-					assert("Identifier" == declarator.id.type, `declarator.id.type was "${declarator.id.type}"`)
-					program.scope.crawl()
-					if (program.scope.hasGlobal(declarator.id.name)) {
-						globalBlock.body.splice(globalBlockIndex, 1)
-						const [globalBlockPath] = program.unshiftContainer("body", globalBlock),
-							[globalBlockStatementPath] = program.unshiftContainer("body", globalBlockStatement)
-						program.scope.crawl()
-						if (
-							!declarator.init ||
-							("FunctionExpression" != declarator.init.type &&
-								"ArrowFunctionExpression" != declarator.init.type) ||
-							Object.keys(program.scope.globals).some(global => globalBlockVariables.has(global))
-						) {
-							const binding = program.scope.getBinding(declarator.id.name)
-							assert(binding)
-							for (const referencePath of binding.referencePaths) {
-								assert("Identifier" == referencePath.node.type)
-								referencePath.replaceWith(
-									t.memberExpression(
-										t.identifier(`$${uniqueID}$GLOBAL$`),
-										t.identifier(referencePath.node.name)
-									)
-								)
-							}
-							for (const referencePath of binding.constantViolations)
-								if ("AssignmentExpression" == referencePath.node.type)
-									for (const [name, node] of Object.entries(
-										t.getBindingIdentifiers(referencePath.node)
-									))
-										if (name == declarator.id.name) {
-											clearObject(node)
-											Object.assign(
-												node,
-												t.memberExpression(
-													t.identifier(`$${uniqueID}$GLOBAL$`),
-													t.identifier(name)
-												)
-											)
-										}
-							globalBlockPath.remove()
-							globalBlockStatementPath.remove()
-							declarator.init &&
-								globalBlock.body.splice(
-									globalBlockIndex,
-									0,
-									t.expressionStatement(
-										t.assignmentExpression(
-											"=",
-											t.memberExpression(
-												t.identifier(`$${uniqueID}$GLOBAL$`),
-												t.identifier(declarator.id.name)
-											),
-											declarator.init
-										)
-									)
-								)
-						} else {
-							globalBlockPath.remove()
-							globalBlockStatementPath.remove()
-							mainFunction.body.body.unshift(globalBlockStatement)
-							hoistedGlobalBlockFunctions++
-						}
-					} else globalBlockVariables.add(declarator.id.name)
-				} else if ("ClassDeclaration" == globalBlockStatement.type) {
+			)
+		program.scope.crawl()
+		const globalBlockVariables = new Set()
+		let hoistedGlobalBlockFunctions = 0
+		for (const [globalBlockIndex, globalBlockStatement] of [...globalBlock.body.entries()].reverse())
+			if ("VariableDeclaration" == globalBlockStatement.type) {
+				assert(1 == globalBlockStatement.declarations.length, "src/processScript/transform.ts:370:59")
+				const declarator = globalBlockStatement.declarations[0]
+				assert(
+					"Identifier" == declarator.id.type,
+					`src/processScript/transform.ts:374:51 declarator.id.type was "${declarator.id.type}"`
+				)
+				program.scope.crawl()
+				if (program.scope.hasGlobal(declarator.id.name)) {
+					globalBlock.body.splice(globalBlockIndex, 1)
+					const [globalBlockPath] = program.unshiftContainer("body", globalBlock),
+						[globalBlockStatementPath] = program.unshiftContainer("body", globalBlockStatement)
 					program.scope.crawl()
-					assert(globalBlockStatement.id, "src/processScript/transform.ts:564:37")
-					if (program.scope.hasGlobal(globalBlockStatement.id.name)) {
-						globalBlock.body.splice(globalBlockIndex, 1)
-						const [globalBlockPath] = program.unshiftContainer("body", globalBlock),
-							[globalBlockStatementPath] = program.unshiftContainer("body", globalBlockStatement)
-						program.scope.crawl()
-						const binding = program.scope.getBinding(globalBlockStatement.id.name)
-						assert(binding)
+					if (
+						!declarator.init ||
+						("FunctionExpression" != declarator.init.type &&
+							"ArrowFunctionExpression" != declarator.init.type) ||
+						Object.keys(program.scope.globals).some(global => globalBlockVariables.has(global))
+					) {
+						const binding = program.scope.getBinding(declarator.id.name)
+						assert(binding, "src/processScript/transform.ts:393:23")
 						for (const referencePath of binding.referencePaths) {
-							assert("Identifier" == referencePath.node.type)
+							assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:396:56")
 							referencePath.replaceWith(
 								t.memberExpression(
 									t.identifier(`$${uniqueID}$GLOBAL$`),
@@ -427,223 +315,354 @@ const { default: traverse } = babelTraverse,
 								)
 							)
 						}
+						for (const referencePath of binding.constantViolations)
+							if ("AssignmentExpression" == referencePath.node.type)
+								for (const [name, node] of Object.entries(t.getBindingIdentifiers(referencePath.node)))
+									if (name == declarator.id.name) {
+										clearObject(node)
+										Object.assign(
+											node,
+											t.memberExpression(t.identifier(`$${uniqueID}$GLOBAL$`), t.identifier(name))
+										)
+									}
 						globalBlockPath.remove()
 						globalBlockStatementPath.remove()
-						globalBlock.body.splice(
-							globalBlockIndex,
-							0,
-							t.expressionStatement(
-								t.assignmentExpression(
-									"=",
-									t.memberExpression(
-										t.identifier(`$${uniqueID}$GLOBAL$`),
-										t.identifier(globalBlockStatement.id.name)
-									),
-									t.classExpression(
-										void 0,
-										globalBlockStatement.superClass,
-										globalBlockStatement.body,
-										globalBlockStatement.decorators
+						declarator.init &&
+							globalBlock.body.splice(
+								globalBlockIndex,
+								0,
+								t.expressionStatement(
+									t.assignmentExpression(
+										"=",
+										t.memberExpression(
+											t.identifier(`$${uniqueID}$GLOBAL$`),
+											t.identifier(declarator.id.name)
+										),
+										declarator.init
 									)
 								)
 							)
+					} else {
+						globalBlockPath.remove()
+						globalBlockStatementPath.remove()
+						mainFunction.body.body.unshift(globalBlockStatement)
+						hoistedGlobalBlockFunctions++
+					}
+				} else globalBlockVariables.add(declarator.id.name)
+			} else if ("ClassDeclaration" == globalBlockStatement.type) {
+				program.scope.crawl()
+				assert(globalBlockStatement.id, "src/processScript/transform.ts:447:37")
+				if (program.scope.hasGlobal(globalBlockStatement.id.name)) {
+					globalBlock.body.splice(globalBlockIndex, 1)
+					const [globalBlockPath] = program.unshiftContainer("body", globalBlock),
+						[globalBlockStatementPath] = program.unshiftContainer("body", globalBlockStatement)
+					program.scope.crawl()
+					const binding = program.scope.getBinding(globalBlockStatement.id.name)
+					assert(binding, "src/processScript/transform.ts:459:22")
+					for (const referencePath of binding.referencePaths) {
+						assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:462:55")
+						referencePath.replaceWith(
+							t.memberExpression(
+								t.identifier(`$${uniqueID}$GLOBAL$`),
+								t.identifier(referencePath.node.name)
+							)
 						)
 					}
-				}
-			if (program.scope.hasGlobal("_EXPORTS"))
-				for (const referencePath of getReferencePathsToGlobal("_EXPORTS", program))
-					referencePath.replaceWith(
-						t.arrayExpression([...exports.keys(), ...liveExports.keys()].map(name => t.stringLiteral(name)))
+					globalBlockPath.remove()
+					globalBlockStatementPath.remove()
+					globalBlock.body.splice(
+						globalBlockIndex,
+						0,
+						t.expressionStatement(
+							t.assignmentExpression(
+								"=",
+								t.memberExpression(
+									t.identifier(`$${uniqueID}$GLOBAL$`),
+									t.identifier(globalBlockStatement.id.name)
+								),
+								t.classExpression(
+									void 0,
+									globalBlockStatement.superClass,
+									globalBlockStatement.body,
+									globalBlockStatement.decorators
+								)
+							)
+						)
 					)
-			globalBlock.body.length &&
-				mainFunction.body.body.splice(
-					hoistedGlobalBlockFunctions,
-					0,
-					t.ifStatement(t.unaryExpression("!", t.identifier(`$${uniqueID}$FMCL$`)), globalBlock)
+				}
+			}
+		if (program.scope.hasGlobal("_EXPORTS"))
+			for (const referencePath of getReferencePathsToGlobal("_EXPORTS", program))
+				referencePath.replaceWith(
+					t.arrayExpression([...exports.keys(), ...liveExports.keys()].map(name => t.stringLiteral(name)))
 				)
-		}
-		functionDotPrototypeIsReferencedMultipleTimes &&
-			mainFunction.body.body.unshift(
-				t.variableDeclaration("let", [
-					t.variableDeclarator(
-						t.identifier(`_${uniqueID}_FUNCTION_DOT_PROTOTYPE_`),
-						createGetFunctionPrototypeNode()
-					)
-				])
+		globalBlock.body.length &&
+			mainFunction.body.body.splice(
+				hoistedGlobalBlockFunctions,
+				0,
+				t.ifStatement(t.unaryExpression("!", t.identifier(`$${uniqueID}$FMCL$`)), globalBlock)
 			)
-		needSetPrototypeOf &&
-			mainFunction.body.body.unshift(
-				t.variableDeclaration("let", [
-					t.variableDeclarator(
-						t.identifier(`_${uniqueID}_SET_PROTOTYPE_OF_`),
-						t.callExpression(
+	}
+	functionDotPrototypeIsReferencedMultipleTimes &&
+		mainFunction.body.body.unshift(
+			t.variableDeclaration("let", [
+				t.variableDeclarator(
+					t.identifier(`_${uniqueID}_FUNCTION_DOT_PROTOTYPE_`),
+					createGetFunctionPrototypeNode()
+				)
+			])
+		)
+	needGetPrototypeOf &&
+		mainFunction.body.body.unshift(
+			t.variableDeclaration("let", [
+				t.variableDeclarator(
+					t.objectPattern([
+						t.objectProperty(t.identifier("get"), t.identifier(`_${uniqueID}_DUNDER_PROTO_GETTER_`))
+					]),
+					t.callExpression(
+						t.memberExpression(t.identifier("Object"), t.identifier("getOwnPropertyDescriptor")),
+						[
+							t.memberExpression(t.identifier("Object"), t.identifier("prototype")),
+							t.stringLiteral("__proto__")
+						]
+					)
+				),
+				t.variableDeclarator(
+					t.identifier(`_${uniqueID}_GET_PROTOTYPE_OF_`),
+					t.callExpression(
+						t.memberExpression(
 							t.memberExpression(
-								t.memberExpression(t.identifier("Object"), t.identifier("call")),
-								t.identifier("bind")
+								t.identifier(
+									globalFunctionsUnder7Characters.find(name => !program.scope.hasOwnBinding(name))
+								),
+								t.identifier("call")
 							),
-							[t.identifier(`_${uniqueID}_DUNDER_PROTO_SETTER_`)]
+							t.identifier("bind")
+						),
+						[t.identifier(`_${uniqueID}_DUNDER_PROTO_GETTER_`)]
+					)
+				)
+			])
+		)
+	consoleMethodsReferenced.size &&
+		mainFunction.body.body.unshift(
+			t.variableDeclaration(
+				"let",
+				[...consoleMethodsReferenced].map(name =>
+					t.variableDeclarator(
+						t.identifier(`_${uniqueID}_CONSOLE_METHOD_${name}_`),
+						t.arrowFunctionExpression(
+							[t.restElement(t.identifier("args"))],
+							t.unaryExpression(
+								"void",
+								t.callExpression(t.identifier(`$${uniqueID}$DEBUG$`), [t.identifier("args")])
+							)
 						)
 					)
-				])
+				)
 			)
-		needGetPrototypeOf &&
-			mainFunction.body.body.unshift(
-				t.variableDeclaration("let", [
-					t.variableDeclarator(
-						t.identifier(`_${uniqueID}_GET_PROTOTYPE_OF_`),
-						t.callExpression(
-							t.memberExpression(
-								t.memberExpression(t.identifier("Object"), t.identifier("call")),
-								t.identifier("bind")
-							),
-							[t.identifier(`_${uniqueID}_DUNDER_PROTO_GETTER_`)]
+		)
+	neededDbMethodLets.size &&
+		mainFunction.body.body.unshift(
+			t.variableDeclaration(
+				"let",
+				[...neededDbMethodLets].map(name => {
+					const getArgs = () =>
+						"ObjectId" == name ? []
+						: "i" == name || "r" == name ? [t.identifier("a")]
+						: [t.identifier("a"), t.identifier("b")]
+					return t.variableDeclarator(
+						t.identifier(`_${uniqueID}_CONSOLE_METHOD_${name}_`),
+						t.arrowFunctionExpression(
+							getArgs(),
+							t.callExpression(t.identifier(`$${uniqueID}$DB$${name}$`), getArgs())
 						)
 					)
-				])
+				})
 			)
-		;(needGetPrototypeOf || needSetPrototypeOf) &&
-			mainFunction.body.body.unshift(
-				t.variableDeclaration("let", [
+		)
+	needDebugLet &&
+		mainFunction.body.body.unshift(
+			t.variableDeclaration("let", [
+				t.variableDeclarator(
+					t.identifier(`_${uniqueID}_DEBUG_`),
+					t.callExpression(t.identifier(`$${uniqueID}$DEBUG$`), [t.identifier("a")])
+				)
+			])
+		)
+	neededSubscriptLets.size &&
+		mainFunction.body.body.unshift(
+			t.variableDeclaration(
+				"let",
+				[...neededSubscriptLets].map(name =>
 					t.variableDeclarator(
-						t.objectPattern(
-							needGetPrototypeOf ?
-								needSetPrototypeOf ?
-									[
-										t.objectProperty(
-											t.identifier("get"),
-											t.identifier(`_${uniqueID}_DUNDER_PROTO_GETTER_`)
-										),
-										t.objectProperty(
-											t.identifier("set"),
-											t.identifier(`_${uniqueID}_DUNDER_PROTO_SETTER_`)
-										)
-									]
-								:	[
-										t.objectProperty(
-											t.identifier("get"),
-											t.identifier(`_${uniqueID}_DUNDER_PROTO_GETTER_`)
-										)
-									]
-							:	[t.objectProperty(t.identifier("set"), t.identifier(`_${uniqueID}_DUNDER_PROTO_SETTER_`))]
-						),
-						t.callExpression(
-							t.memberExpression(t.identifier("Object"), t.identifier("getOwnPropertyDescriptor")),
-							[
-								t.memberExpression(t.identifier("Object"), t.identifier("prototype")),
-								t.stringLiteral("__proto__")
-							]
+						t.identifier(`_${uniqueID}_SUBSCRIPT_${name}_`),
+						t.arrowFunctionExpression(
+							[t.restElement(t.identifier("args"))],
+							t.callExpression(t.identifier(`$${uniqueID}$SUBSCRIPT$${name}$`), [
+								t.spreadElement(t.identifier("args"))
+							])
 						)
 					)
-				])
+				)
 			)
-		traverse(file, {
-			BlockStatement({ node: blockStatement }) {
-				for (const [index, functionDeclaration] of blockStatement.body.entries())
-					if ("FunctionDeclaration" == functionDeclaration.type && !functionDeclaration.generator) {
-						blockStatement.body.splice(index, 1)
-						blockStatement.body.unshift(
+		)
+	traverse(file, {
+		BlockStatement({ node: blockStatement }) {
+			for (const [index, functionDeclaration] of blockStatement.body.entries())
+				if ("FunctionDeclaration" == functionDeclaration.type && !functionDeclaration.generator) {
+					blockStatement.body.splice(index, 1)
+					blockStatement.body.unshift(
+						t.variableDeclaration("let", [
+							t.variableDeclarator(
+								functionDeclaration.id,
+								t.arrowFunctionExpression(
+									functionDeclaration.params,
+									functionDeclaration.body,
+									functionDeclaration.async
+								)
+							)
+						])
+					)
+				}
+		},
+		ClassBody({ node: classBody, scope, parent }) {
+			assert(t.isClass(parent), "src/processScript/transform.ts:629:30")
+			let thisIsReferenced = !1
+			for (const classMethod of classBody.body) {
+				if ("ClassMethod" != classMethod.type) continue
+				let methodReferencesThis = !1
+				traverse(
+					classMethod.body,
+					{
+						ThisExpression(path) {
+							methodReferencesThis = !0
+							thisIsReferenced = !0
+							path.replaceWith(t.identifier(`_${uniqueID}_THIS_`))
+						},
+						Function: path => path.skip()
+					},
+					scope
+				)
+				if (methodReferencesThis)
+					if ("constructor" != classMethod.kind)
+						classMethod.body.body.unshift(
 							t.variableDeclaration("let", [
 								t.variableDeclarator(
-									functionDeclaration.id,
-									t.arrowFunctionExpression(
-										functionDeclaration.params,
-										functionDeclaration.body,
-										functionDeclaration.async
-									)
+									t.identifier(`_${uniqueID}_THIS_`),
+									t.callExpression(t.memberExpression(t.super(), t.identifier("valueOf")), [])
 								)
 							])
 						)
-					}
-			},
-			ClassBody({ node: classBody, scope, parent }) {
-				assert(t.isClass(parent))
-				let thisIsReferenced = !1
-				for (const classMethod of classBody.body) {
-					if ("ClassMethod" != classMethod.type) continue
-					let methodReferencesThis = !1
-					traverse(
-						classMethod.body,
-						{
-							ThisExpression(path) {
-								methodReferencesThis = !0
-								thisIsReferenced = !0
-								path.replaceWith(t.identifier(`_${uniqueID}_THIS_`))
+					else {
+						const superCalls = []
+						traverse(
+							classMethod.body,
+							{
+								CallExpression(path) {
+									"Super" == path.node.callee.type && superCalls.push(path)
+								}
 							},
-							Function(path) {
-								path.skip()
+							scope
+						)
+						if (superCalls.length)
+							if (
+								1 == superCalls.length &&
+								"ExpressionStatement" == superCalls[0].parent.type &&
+								superCalls[0].parentPath.parentPath.parent == classMethod
+							)
+								superCalls[0].parentPath.replaceWith(
+									t.variableDeclaration("let", [
+										t.variableDeclarator(t.identifier(`_${uniqueID}_THIS_`), superCalls[0].node)
+									])
+								)
+							else {
+								for (const path of superCalls)
+									path.replaceWith(
+										t.assignmentExpression("=", t.identifier(`_${uniqueID}_THIS_`), path.node)
+									)
+								classMethod.body.body.unshift(
+									t.variableDeclaration("let", [
+										t.variableDeclarator(t.identifier(`_${uniqueID}_THIS_`))
+									])
+								)
 							}
-						},
-						scope
-					)
-					if (methodReferencesThis)
-						if ("constructor" != classMethod.kind)
+						else
 							classMethod.body.body.unshift(
 								t.variableDeclaration("let", [
 									t.variableDeclarator(
 										t.identifier(`_${uniqueID}_THIS_`),
-										t.callExpression(t.memberExpression(t.super(), t.identifier("valueOf")), [])
+										t.callExpression(t.super(), [])
 									)
 								])
 							)
-						else {
-							const superCalls = []
-							traverse(
-								classMethod.body,
-								{
-									CallExpression(path) {
-										"Super" == path.node.callee.type && superCalls.push(path)
-									}
-								},
-								scope
-							)
-							if (superCalls.length)
-								if (
-									1 == superCalls.length &&
-									"ExpressionStatement" == superCalls[0].parent.type &&
-									superCalls[0].parentPath.parentPath.parent == classMethod
-								)
-									superCalls[0].parentPath.replaceWith(
-										t.variableDeclaration("let", [
-											t.variableDeclarator(t.identifier(`_${uniqueID}_THIS_`), superCalls[0].node)
-										])
-									)
-								else {
-									for (const path of superCalls)
-										path.replaceWith(
-											t.assignmentExpression("=", t.identifier(`_${uniqueID}_THIS_`), path.node)
-										)
-									classMethod.body.body.unshift(
-										t.variableDeclaration("let", [
-											t.variableDeclarator(t.identifier(`_${uniqueID}_THIS_`))
-										])
-									)
-								}
-							else
-								classMethod.body.body.unshift(
-									t.variableDeclaration("let", [
-										t.variableDeclarator(
-											t.identifier(`_${uniqueID}_THIS_`),
-											t.callExpression(t.super(), [])
-										)
-									])
-								)
-						}
-				}
-				!parent.superClass && thisIsReferenced && (parent.superClass = t.identifier("Object"))
-			},
-			VariableDeclaration({ node: variableDeclaration }) {
-				"const" == variableDeclaration.kind && (variableDeclaration.kind = "let")
-			},
-			ThisExpression(path) {
-				path.replaceWith(t.identifier("undefined"))
-			},
-			BigIntLiteral(path) {
-				const bigIntAsNumber = Number(path.node.value)
-				BigInt(bigIntAsNumber) == BigInt(path.node.value) ?
-					path.replaceWith(t.callExpression(t.identifier("BigInt"), [t.numericLiteral(bigIntAsNumber)]))
-				:	path.replaceWith(t.callExpression(t.identifier("BigInt"), [t.stringLiteral(path.node.value)]))
+					}
 			}
-		})
-		return { file, seclevel }
+			!parent.superClass && thisIsReferenced && (parent.superClass = t.identifier("Object"))
+		},
+		VariableDeclaration({ node: variableDeclaration }) {
+			"const" == variableDeclaration.kind && (variableDeclaration.kind = "let")
+		},
+		ThisExpression: path => path.replaceWith(t.identifier("undefined")),
+		BigIntLiteral(path) {
+			const bigIntAsNumber = Number(path.node.value)
+			path.replaceWith(
+				t.callExpression(t.identifier("BigInt"), [
+					BigInt(bigIntAsNumber) == BigInt(path.node.value) ?
+						t.numericLiteral(bigIntAsNumber)
+					:	t.stringLiteral(path.node.value)
+				])
+			)
+		}
+	})
+	return { file, seclevel }
+	function createGetFunctionPrototypeNode() {
+		for (const globalFunction of globalFunctionsUnder7Characters)
+			if (!program.scope.hasOwnBinding(globalFunction))
+				return t.memberExpression(
+					t.memberExpression(t.identifier(globalFunction), t.identifier("constructor")),
+					t.identifier("prototype")
+				)
+		return t.memberExpression(
+			t.memberExpression(
+				t.arrowFunctionExpression([t.identifier("_")], t.identifier("_")),
+				t.identifier("constructor")
+			),
+			t.identifier("prototype")
+		)
+	}
+	function processFakeSubscriptObject(fakeSubscriptObjectName) {
+		for (const referencePath of getReferencePathsToGlobal(fakeSubscriptObjectName, program)) {
+			assert("MemberExpression" == referencePath.parent.type, "src/processScript/transform.ts:743:60")
+			assert("Identifier" == referencePath.parent.property.type)
+			assert(
+				"MemberExpression" == referencePath.parentPath.parentPath?.node.type,
+				"src/processScript/transform.ts:745:81"
+			)
+			assert(
+				"Identifier" == referencePath.parentPath.parentPath.node.property.type,
+				"src/processScript/transform.ts:746:83"
+			)
+			assert(
+				/^[_a-z][\d_a-z]{0,24}$/.test(referencePath.parent.property.name),
+				`src/processScript/transform.ts:750:8 invalid user "${referencePath.parent.property.name}" in subscript`
+			)
+			assert(
+				/^[_a-z][\d_a-z]{0,24}$/.test(referencePath.parentPath.parentPath.node.property.name),
+				`src/processScript/transform.ts:755:8 invalid script name "${referencePath.parentPath.parentPath.node.property.name}" in subscript`
+			)
+			if ("CallExpression" == referencePath.parentPath.parentPath.parentPath?.type)
+				referencePath.parentPath.parentPath.replaceWith(
+					t.identifier(
+						`$${uniqueID}$SUBSCRIPT$${referencePath.parent.property.name}$${referencePath.parentPath.parentPath.node.property.name}$`
+					)
+				)
+			else {
+				const name = `${referencePath.parent.property.name}$${referencePath.parentPath.parentPath.node.property.name}`
+				referencePath.parentPath.parentPath.replaceWith(t.identifier(`_${uniqueID}_SUBSCRIPT_${name}_`))
+				neededSubscriptLets.add(name)
+			}
+		}
 	}
+}
 export { transform as default, transform }