hackmud-script-manager 0.19.1-98e81f8 → 0.19.1-b040eb5

package/processScript/index.js

@@ -29,7 +29,7 @@ import { supportedExtensions } from "../constants.js"
 import { minify } from "./minify.js"
 import { postprocess } from "./postprocess.js"
 import { preprocess } from "./preprocess.js"
-import { includesIllegalString, replaceUnsafeStrings } from "./shared.js"
+import { getReferencePathsToGlobal, includesIllegalString, replaceUnsafeStrings } from "./shared.js"
 import { transform } from "./transform.js"
 import "@samual/lib/countHackmudCharacters"
 import "@samual/lib/spliceString"
@@ -39,140 +39,110 @@ import "import-meta-resolve"
 import "@samual/lib/clearObject"
 const { format } = prettier,
 	{ default: generate } = babelGenerator,
-	{ default: traverse } = babelTraverse,
-	processScript = async (
-		code,
-		{
-			minify: shouldMinify = !0,
-			uniqueID = Math.floor(Math.random() * 2 ** 52)
-				.toString(36)
-				.padStart(11, "0"),
-			scriptUser = "UNKNOWN",
-			scriptName = "UNKNOWN",
-			filePath,
-			mangleNames = !1,
-			forceQuineCheats
-		} = {}
-	) => {
-		assert(/^\w{11}$/.exec(uniqueID))
-		const sourceCode = code
-		let autocomplete, statedSeclevel
-		const autocompleteMatch = /^function\s*\(.+\/\/(?<autocomplete>.+)/.exec(code)
-		if (autocompleteMatch) {
-			code = "export default " + code
-			;({ autocomplete } = autocompleteMatch.groups)
-		} else
-			for (const line of code.split("\n")) {
-				const comment = /^\s*\/\/(?<commentContent>.+)/.exec(line)
-				if (!comment) break
-				const commentContent = comment.groups.commentContent.trim()
-				if (commentContent.startsWith("@autocomplete ")) autocomplete = commentContent.slice(14).trimStart()
-				else if (commentContent.startsWith("@seclevel ")) {
-					const seclevelString = commentContent.slice(10).trimStart().toLowerCase()
-					switch (seclevelString) {
-						case "fullsec":
-						case "full":
-						case "fs":
-						case "4s":
-						case "f":
-						case "4":
-							statedSeclevel = 4
-							break
-						case "highsec":
-						case "high":
-						case "hs":
-						case "3s":
-						case "h":
-						case "3":
-							statedSeclevel = 3
-							break
-						case "midsec":
-						case "mid":
-						case "ms":
-						case "2s":
-						case "m":
-						case "2":
-							statedSeclevel = 2
-							break
-						case "lowsec":
-						case "low":
-						case "ls":
-						case "1s":
-						case "l":
-						case "1":
-							statedSeclevel = 1
-							break
-						case "nullsec":
-						case "null":
-						case "ns":
-						case "0s":
-						case "n":
-						case "0":
-							statedSeclevel = 0
-							break
-						default:
-							throw Error(`unrecognised seclevel "${seclevelString}"`)
-					}
+	{ default: traverse } = babelTraverse
+async function processScript(
+	code,
+	{
+		minify: shouldMinify = !0,
+		uniqueID = Math.floor(Math.random() * 2 ** 52)
+			.toString(36)
+			.padStart(11, "0"),
+		scriptUser,
+		scriptName,
+		filePath,
+		mangleNames = !1,
+		forceQuineCheats
+	}
+) {
+	assert(/^\w{11}$/.exec(uniqueID), "src/processScript/index.ts:77:36")
+	const sourceCode = code
+	let autocomplete, statedSeclevel
+	const autocompleteMatch = /^function\s*\(.+\/\/(?<autocomplete>.+)/.exec(code)
+	if (autocompleteMatch) {
+		code = "export default " + code
+		;({ autocomplete } = autocompleteMatch.groups)
+	} else
+		for (const line of code.split("\n")) {
+			const comment = /^\s*\/\/(?<commentContent>.+)/.exec(line)
+			if (!comment) break
+			const commentContent = comment.groups.commentContent.trim()
+			if (commentContent.startsWith("@autocomplete ")) autocomplete = commentContent.slice(14).trimStart()
+			else if (commentContent.startsWith("@seclevel ")) {
+				const seclevelString = commentContent.slice(10).trimStart().toLowerCase()
+				switch (seclevelString) {
+					case "fullsec":
+					case "full":
+					case "fs":
+					case "4s":
+					case "f":
+					case "4":
+						statedSeclevel = 4
+						break
+					case "highsec":
+					case "high":
+					case "hs":
+					case "3s":
+					case "h":
+					case "3":
+						statedSeclevel = 3
+						break
+					case "midsec":
+					case "mid":
+					case "ms":
+					case "2s":
+					case "m":
+					case "2":
+						statedSeclevel = 2
+						break
+					case "lowsec":
+					case "low":
+					case "ls":
+					case "1s":
+					case "l":
+					case "1":
+						statedSeclevel = 1
+						break
+					case "nullsec":
+					case "null":
+					case "ns":
+					case "0s":
+					case "n":
+					case "0":
+						statedSeclevel = 0
+						break
+					default:
+						throw Error(`unrecognised seclevel "${seclevelString}"`)
 				}
 			}
-		assert(/^\w{11}$/.exec(uniqueID))
-		const plugins = [
-			[babelPluginProposalDecorators.default, { decoratorsBeforeExport: !0 }],
-			[babelPluginTransformClassProperties.default],
-			[babelPluginTransformClassStaticBlock.default],
-			[babelPluginTransformPrivatePropertyInObject.default],
-			[babelPluginTransformLogicalAssignmentOperators.default],
-			[babelPluginTransformNumericSeparator.default],
-			[babelPluginTransformNullishCoalescingOperator.default],
-			[babelPluginTransformOptionalChaining.default],
-			[babelPluginTransformOptionalCatchBinding.default],
-			[babelPluginTransformJsonStrings.default],
-			[babelPluginTransformObjectRestSpread.default],
-			[babelPluginTransformExponentiationOperator.default],
-			[babelPluginTransformUnicodeSetsRegex.default],
-			[babelPluginProposalDestructuringPrivate.default],
-			[babelPluginProposalExplicitResourceManagement.default]
-		]
-		let filePathResolved
-		if (filePath) {
-			filePathResolved = resolve(filePath)
-			if (filePath.endsWith(".ts"))
-				plugins.push([
-					(await import("@babel/plugin-transform-typescript")).default,
-					{ allowDeclareFields: !0, optimizeConstEnums: !0 }
-				])
-			else {
-				const [
-					babelPluginProposalDoExpressions,
-					babelPluginProposalFunctionBind,
-					babelPluginProposalFunctionSent,
-					babelPluginProposalPartialApplication,
-					babelPluginProposalPipelineOperator,
-					babelPluginProposalThrowExpressions,
-					babelPluginProposalRecordAndTuple
-				] = await Promise.all([
-					import("@babel/plugin-proposal-do-expressions"),
-					import("@babel/plugin-proposal-function-bind"),
-					import("@babel/plugin-proposal-function-sent"),
-					import("@babel/plugin-proposal-partial-application"),
-					import("@babel/plugin-proposal-pipeline-operator"),
-					import("@babel/plugin-proposal-throw-expressions"),
-					import("@babel/plugin-proposal-record-and-tuple")
-				])
-				plugins.push(
-					[babelPluginProposalDoExpressions.default],
-					[babelPluginProposalFunctionBind.default],
-					[babelPluginProposalFunctionSent.default],
-					[babelPluginProposalPartialApplication.default],
-					[babelPluginProposalPipelineOperator.default, { proposal: "hack", topicToken: "%" }],
-					[babelPluginProposalThrowExpressions.default],
-					[babelPluginProposalRecordAndTuple.default, { syntaxType: "hash", importPolyfill: !0 }]
-				)
-			}
-		} else {
-			filePathResolved = uniqueID + ".ts"
+		}
+	assert(/^\w{11}$/.exec(uniqueID), "src/processScript/index.ts:158:36")
+	const plugins = [
+		[babelPluginProposalDecorators.default, { decoratorsBeforeExport: !0 }],
+		[babelPluginTransformClassProperties.default],
+		[babelPluginTransformClassStaticBlock.default],
+		[babelPluginTransformPrivatePropertyInObject.default],
+		[babelPluginTransformLogicalAssignmentOperators.default],
+		[babelPluginTransformNumericSeparator.default],
+		[babelPluginTransformNullishCoalescingOperator.default],
+		[babelPluginTransformOptionalChaining.default],
+		[babelPluginTransformOptionalCatchBinding.default],
+		[babelPluginTransformJsonStrings.default],
+		[babelPluginTransformObjectRestSpread.default],
+		[babelPluginTransformExponentiationOperator.default],
+		[babelPluginTransformUnicodeSetsRegex.default],
+		[babelPluginProposalDestructuringPrivate.default],
+		[babelPluginProposalExplicitResourceManagement.default]
+	]
+	let filePathResolved
+	if (filePath) {
+		filePathResolved = resolve(filePath)
+		if (filePath.endsWith(".ts"))
+			plugins.push([
+				(await import("@babel/plugin-transform-typescript")).default,
+				{ allowDeclareFields: !0, optimizeConstEnums: !0 }
+			])
+		else {
 			const [
-				babelPluginTransformTypescript,
 				babelPluginProposalDoExpressions,
 				babelPluginProposalFunctionBind,
 				babelPluginProposalFunctionSent,
@@ -181,7 +151,6 @@ const { format } = prettier,
 				babelPluginProposalThrowExpressions,
 				babelPluginProposalRecordAndTuple
 			] = await Promise.all([
-				import("@babel/plugin-transform-typescript"),
 				import("@babel/plugin-proposal-do-expressions"),
 				import("@babel/plugin-proposal-function-bind"),
 				import("@babel/plugin-proposal-function-sent"),
@@ -191,7 +160,6 @@ const { format } = prettier,
 				import("@babel/plugin-proposal-record-and-tuple")
 			])
 			plugins.push(
-				[babelPluginTransformTypescript.default, { allowDeclareFields: !0, optimizeConstEnums: !0 }],
 				[babelPluginProposalDoExpressions.default],
 				[babelPluginProposalFunctionBind.default],
 				[babelPluginProposalFunctionSent.default],
@@ -201,116 +169,165 @@ const { format } = prettier,
 				[babelPluginProposalRecordAndTuple.default, { syntaxType: "hash", importPolyfill: !0 }]
 			)
 		}
-		const bundle = await rollup({
-				input: filePathResolved,
-				plugins: [
-					{
-						name: "hackmud-script-manager",
-						transform: async code => (await preprocess(code, { uniqueID })).code
-					},
-					babel({ babelHelpers: "bundled", plugins, configFile: !1, extensions: supportedExtensions }),
-					rollupPluginCommonJS(),
-					rollupPluginNodeResolve({ extensions: supportedExtensions }),
-					rollupPluginJSON()
-				],
-				treeshake: { moduleSideEffects: !1 }
-			}),
-			seclevelNames = ["NULLSEC", "LOWSEC", "MIDSEC", "HIGHSEC", "FULLSEC"]
-		code = (await bundle.generate({})).output[0].code
-		const { file, seclevel } = transform(parse(code, { sourceType: "module" }), sourceCode, {
-			uniqueID,
-			scriptUser,
-			scriptName
-		})
-		if (null != statedSeclevel && seclevel < statedSeclevel)
-			throw Error(
-				`detected seclevel ${seclevelNames[seclevel]} is lower than stated seclevel ${seclevelNames[statedSeclevel]}`
-			)
-		code = generate(file).code
-		if (shouldMinify) code = await minify(file, { uniqueID, mangleNames, forceQuineCheats, autocomplete })
-		else {
-			traverse(file, {
-				MemberExpression({ node: memberExpression }) {
-					if (!memberExpression.computed) {
-						assert("Identifier" == memberExpression.property.type)
-						if ("prototype" == memberExpression.property.name) {
-							memberExpression.computed = !0
-							memberExpression.property = t.stringLiteral("prototype")
-						} else if ("__proto__" == memberExpression.property.name) {
-							memberExpression.computed = !0
-							memberExpression.property = t.stringLiteral("__proto__")
-						} else if (includesIllegalString(memberExpression.property.name)) {
-							memberExpression.computed = !0
-							memberExpression.property = t.stringLiteral(
-								replaceUnsafeStrings(uniqueID, memberExpression.property.name)
-							)
-						}
+	} else {
+		filePathResolved = uniqueID + ".ts"
+		const [
+			babelPluginTransformTypescript,
+			babelPluginProposalDoExpressions,
+			babelPluginProposalFunctionBind,
+			babelPluginProposalFunctionSent,
+			babelPluginProposalPartialApplication,
+			babelPluginProposalPipelineOperator,
+			babelPluginProposalThrowExpressions,
+			babelPluginProposalRecordAndTuple
+		] = await Promise.all([
+			import("@babel/plugin-transform-typescript"),
+			import("@babel/plugin-proposal-do-expressions"),
+			import("@babel/plugin-proposal-function-bind"),
+			import("@babel/plugin-proposal-function-sent"),
+			import("@babel/plugin-proposal-partial-application"),
+			import("@babel/plugin-proposal-pipeline-operator"),
+			import("@babel/plugin-proposal-throw-expressions"),
+			import("@babel/plugin-proposal-record-and-tuple")
+		])
+		plugins.push(
+			[babelPluginTransformTypescript.default, { allowDeclareFields: !0, optimizeConstEnums: !0 }],
+			[babelPluginProposalDoExpressions.default],
+			[babelPluginProposalFunctionBind.default],
+			[babelPluginProposalFunctionSent.default],
+			[babelPluginProposalPartialApplication.default],
+			[babelPluginProposalPipelineOperator.default, { proposal: "hack", topicToken: "%" }],
+			[babelPluginProposalThrowExpressions.default],
+			[babelPluginProposalRecordAndTuple.default, { syntaxType: "hash", importPolyfill: !0 }]
+		)
+	}
+	const bundle = await rollup({
+			input: filePathResolved,
+			plugins: [
+				{
+					name: "hackmud-script-manager",
+					async transform(code, id) {
+						if (!id.includes("/node_modules/")) return (await preprocess(code, { uniqueID })).code
+						let program
+						traverse(parse(code, { sourceType: "module" }), {
+							Program(path) {
+								program = path
+								path.skip()
+							}
+						})
+						for (const referencePath of getReferencePathsToGlobal("JSON", program))
+							"MemberExpression" == referencePath.parentPath.node.type &&
+								"Identifier" == referencePath.parentPath.node.property.type &&
+								("parse" == referencePath.parentPath.node.property.name ?
+									(referencePath.parentPath.node.property.name = "oparse")
+								:	"stringify" == referencePath.parentPath.node.property.name &&
+									(referencePath.parentPath.node.property.name = "ostringify"))
+						return generate(program.node).code
 					}
 				},
-				VariableDeclarator(path) {
-					const renameVariables = lValue => {
-						switch (lValue.type) {
-							case "Identifier":
-								includesIllegalString(lValue.name) &&
-									path.scope.rename(
-										lValue.name,
-										"$" +
-											Math.floor(Math.random() * 2 ** 52)
-												.toString(36)
-												.padStart(11, "0")
-									)
-								break
-							case "ObjectPattern":
-								for (const property of lValue.properties) {
-									assert("ObjectProperty" == property.type)
-									renameVariables(property.value)
-								}
-								break
-							case "ArrayPattern":
-								for (const element of lValue.elements) element && renameVariables(element)
-								break
-							default:
-								throw Error(`unknown lValue type "${lValue.type}"`)
-						}
+				babel({ babelHelpers: "bundled", plugins, configFile: !1, extensions: supportedExtensions }),
+				rollupPluginCommonJS(),
+				rollupPluginNodeResolve({ extensions: supportedExtensions }),
+				rollupPluginJSON()
+			],
+			treeshake: { moduleSideEffects: !1 }
+		}),
+		seclevelNames = ["NULLSEC", "LOWSEC", "MIDSEC", "HIGHSEC", "FULLSEC"]
+	code = (await bundle.generate({})).output[0].code
+	const { file, seclevel } = transform(parse(code, { sourceType: "module" }), sourceCode, {
+		uniqueID,
+		scriptUser,
+		scriptName
+	})
+	if (null != statedSeclevel && seclevel < statedSeclevel)
+		throw Error(
+			`detected seclevel ${seclevelNames[seclevel]} is lower than stated seclevel ${seclevelNames[statedSeclevel]}`
+		)
+	code = generate(file).code
+	if (shouldMinify) code = await minify(file, { uniqueID, mangleNames, forceQuineCheats, autocomplete })
+	else {
+		traverse(file, {
+			MemberExpression({ node: memberExpression }) {
+				if (!memberExpression.computed) {
+					assert("Identifier" == memberExpression.property.type, "src/processScript/index.ts:321:60")
+					if ("prototype" == memberExpression.property.name) {
+						memberExpression.computed = !0
+						memberExpression.property = t.stringLiteral("prototype")
+					} else if ("__proto__" == memberExpression.property.name) {
+						memberExpression.computed = !0
+						memberExpression.property = t.stringLiteral("__proto__")
+					} else if (includesIllegalString(memberExpression.property.name)) {
+						memberExpression.computed = !0
+						memberExpression.property = t.stringLiteral(
+							replaceUnsafeStrings(uniqueID, memberExpression.property.name)
+						)
 					}
-					renameVariables(path.node.id)
-				},
-				ObjectProperty({ node: objectProperty }) {
-					if ("Identifier" == objectProperty.key.type && includesIllegalString(objectProperty.key.name)) {
-						objectProperty.key = t.stringLiteral(replaceUnsafeStrings(uniqueID, objectProperty.key.name))
-						objectProperty.shorthand = !1
+				}
+			},
+			VariableDeclarator(path) {
+				const renameVariables = lValue => {
+					switch (lValue.type) {
+						case "Identifier":
+							includesIllegalString(lValue.name) &&
+								path.scope.rename(
+									lValue.name,
+									"$" +
+										Math.floor(Math.random() * 2 ** 52)
+											.toString(36)
+											.padStart(11, "0")
+								)
+							break
+						case "ObjectPattern":
+							for (const property of lValue.properties) {
+								assert("ObjectProperty" == property.type, "src/processScript/index.ts:351:51")
+								renameVariables(property.value)
+							}
+							break
+						case "ArrayPattern":
+							for (const element of lValue.elements) element && renameVariables(element)
+							break
+						default:
+							throw Error(`unknown lValue type "${lValue.type}"`)
 					}
-				},
-				StringLiteral({ node }) {
-					node.value = replaceUnsafeStrings(uniqueID, node.value)
-				},
-				TemplateLiteral({ node }) {
-					for (const templateElement of node.quasis)
-						if (templateElement.value.cooked) {
-							templateElement.value.cooked = replaceUnsafeStrings(uniqueID, templateElement.value.cooked)
-							templateElement.value.raw = templateElement.value.cooked
-								.replaceAll("\\", "\\\\")
-								.replaceAll("`", "\\`")
-								.replaceAll("${", "$\\{")
-						} else templateElement.value.raw = replaceUnsafeStrings(uniqueID, templateElement.value.raw)
-				},
-				RegExpLiteral(path) {
-					path.node.pattern = replaceUnsafeStrings(uniqueID, path.node.pattern)
-					delete path.node.extra
 				}
-			})
-			code = await format(generate(file, { comments: !1 }).code, {
-				parser: "babel",
-				arrowParens: "avoid",
-				semi: !1,
-				trailingComma: "none"
-			})
-		}
-		code = postprocess(code, seclevel, uniqueID)
-		if (includesIllegalString(code))
-			throw Error(
-				'you found a weird edge case where I wasn\'t able to replace illegal strings like "SC$", please report thx'
-			)
-		return { script: code, warnings: [] }
+				renameVariables(path.node.id)
+			},
+			ObjectProperty({ node: objectProperty }) {
+				if ("Identifier" == objectProperty.key.type && includesIllegalString(objectProperty.key.name)) {
+					objectProperty.key = t.stringLiteral(replaceUnsafeStrings(uniqueID, objectProperty.key.name))
+					objectProperty.shorthand = !1
+				}
+			},
+			StringLiteral({ node }) {
+				node.value = replaceUnsafeStrings(uniqueID, node.value)
+			},
+			TemplateLiteral({ node }) {
+				for (const templateElement of node.quasis)
+					if (templateElement.value.cooked) {
+						templateElement.value.cooked = replaceUnsafeStrings(uniqueID, templateElement.value.cooked)
+						templateElement.value.raw = templateElement.value.cooked
+							.replaceAll("\\", "\\\\")
+							.replaceAll("`", "\\`")
+							.replaceAll("${", "$\\{")
+					} else templateElement.value.raw = replaceUnsafeStrings(uniqueID, templateElement.value.raw)
+			},
+			RegExpLiteral(path) {
+				path.node.pattern = replaceUnsafeStrings(uniqueID, path.node.pattern)
+				delete path.node.extra
+			}
+		})
+		code = await format(generate(file, { comments: !1 }).code, {
+			parser: "babel",
+			arrowParens: "avoid",
+			semi: !1,
+			trailingComma: "none"
+		})
 	}
-export { processScript as default, minify, postprocess, preprocess, processScript, transform }
+	code = postprocess(code, seclevel, uniqueID)
+	if (includesIllegalString(code))
+		throw Error(
+			'you found a weird edge case where I wasn\'t able to replace illegal strings like "SC$", please report thx'
+		)
+	return { script: code, warnings: [] }
+}
+export { minify, postprocess, preprocess, processScript, transform }

package/processScript/minify.d.ts

@@ -1,24 +1,18 @@
 import type { File } from "@babel/types";
 import type { LaxPartial } from "@samual/lib";
-type MinifyOptions = {
-    /** 11 a-z 0-9 characters */
-    uniqueID: string;
-    /** whether to mangle function and class names (defaults to `false`) */
-    mangleNames: boolean;
-    /**
-     * when set to `true` forces use of quine cheats
-     *
-     * when set to `false` forces quine cheats not to be used
-     *
-     * when left unset or set to `undefined`, automatically uses or doesn't use quine cheats based on character count
-     */
+type MinifyOptions = LaxPartial<{
+    /** 11 a-z 0-9 characters */ uniqueID: string;
+    /** whether to mangle function and class names (defaults to `false`) */ mangleNames: boolean;
+    /** when set to `true` forces use of quine cheats
+      *
+      * when set to `false` forces quine cheats not to be used
+      *
+      * when left unset or set to `undefined`, automatically uses or doesn't use quine cheats based on character count
+      */
     forceQuineCheats: boolean;
-    /** the comment inserted after the function signature */
-    autocomplete: string;
-};
-/**
- * @param file babel ast node representing a file containing transformed code
- * @param options {@link MinifyOptions details}
- */
-export declare const minify: (file: File, { uniqueID, mangleNames, forceQuineCheats, autocomplete }?: LaxPartial<MinifyOptions>) => Promise<string>;
-export default minify;
+    /** the comment inserted after the function signature */ autocomplete: string;
+}>;
+/** @param file babel ast node representing a file containing transformed code
+  * @param options {@link MinifyOptions details} */
+export declare function minify(file: File, { uniqueID, mangleNames, forceQuineCheats, autocomplete }?: MinifyOptions): Promise<string>;
+export {};