hackmud-script-manager 0.19.1-d57be2a → 0.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hackmud-script-manager",
-  "version": "0.19.1-d57be2a",
+  "version": "0.20.0",
   "description": "Script manager for game hackmud, with minification, TypeScript support, and player script type definition generation.",
   "keywords": [
     "api",
@@ -59,15 +59,18 @@
     "@rollup/plugin-commonjs": "^25.0.7",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^15.2.3",
-    "@samual/lib": "0.10.2-e64c5bc",
+    "@samual/lib": "0.11.0",
     "acorn": "^8.11.3",
     "chalk": "^5.3.0",
     "chokidar": "^3.6.0",
     "import-meta-resolve": "^4.0.0",
     "prettier": "^3.2.5",
     "proxy-polyfill": "^0.3.2",
-    "rollup": "^4.14.2",
-    "terser": "^5.30.3"
+    "rollup": "^4.16.4",
+    "terser": "^5.30.4"
+  },
+  "peerDependencies": {
+    "typescript": "5.4.5"
   },
   "type": "module",
   "exports": {

package/processScript/index.d.ts

@@ -5,7 +5,7 @@ export { preprocess } from "./preprocess";
 export { transform } from "./transform";
 export type ProcessOptions = LaxPartial<{
     /** whether to minify the given code */ minify: boolean;
-    /** 11 a-z 0-9 characters */ uniqueID: string;
+    /** 11 a-z 0-9 characters */ uniqueId: string;
     /** the user going to be hosting this script (or set to `true` if not yet known) */ scriptUser: string | true;
     filePath: string;
     /** whether to mangle function and class names (defaults to `false`) */ mangleNames: boolean;
@@ -22,7 +22,7 @@ export type ProcessOptions = LaxPartial<{
 /** Minifies a given script
   * @param code JavaScript or TypeScript code
   * @param options {@link ProcessOptions details} */
-export declare function processScript(code: string, { minify: shouldMinify, uniqueID, scriptUser, scriptName, filePath, mangleNames, forceQuineCheats }: ProcessOptions): Promise<{
+export declare function processScript(code: string, { minify: shouldMinify, uniqueId, scriptUser, scriptName, filePath, mangleNames, forceQuineCheats }: ProcessOptions): Promise<{
     script: string;
     warnings: {
         message: string;

package/processScript/index.js

@@ -44,7 +44,7 @@ async function processScript(
 	code,
 	{
 		minify: shouldMinify = !0,
-		uniqueID = Math.floor(Math.random() * 2 ** 52)
+		uniqueId = Math.floor(Math.random() * 2 ** 52)
 			.toString(36)
 			.padStart(11, "0"),
 		scriptUser,
@@ -54,7 +54,7 @@ async function processScript(
 		forceQuineCheats
 	}
 ) {
-	assert(/^\w{11}$/.exec(uniqueID), "src/processScript/index.ts:77:36")
+	assert(/^\w{11}$/.exec(uniqueId), "src/processScript/index.ts:77:36")
 	const sourceCode = code
 	let autocomplete, statedSeclevel
 	const autocompleteMatch = /^function\s*\(.+\/\/(?<autocomplete>.+)/.exec(code)
@@ -115,7 +115,7 @@ async function processScript(
 				}
 			}
 		}
-	assert(/^\w{11}$/.exec(uniqueID), "src/processScript/index.ts:158:36")
+	assert(/^\w{11}$/.exec(uniqueId), "src/processScript/index.ts:158:36")
 	const plugins = [
 		[babelPluginProposalDecorators.default, { decoratorsBeforeExport: !0 }],
 		[babelPluginTransformClassProperties.default],
@@ -170,7 +170,7 @@ async function processScript(
 			)
 		}
 	} else {
-		filePathResolved = uniqueID + ".ts"
+		filePathResolved = uniqueId + ".ts"
 		const [
 			babelPluginTransformTypescript,
 			babelPluginProposalDoExpressions,
@@ -207,7 +207,7 @@ async function processScript(
 				{
 					name: "hackmud-script-manager",
 					async transform(code, id) {
-						if (!id.includes("/node_modules/")) return (await preprocess(code, { uniqueID })).code
+						if (!id.includes("/node_modules/")) return (await preprocess(code, { uniqueId })).code
 						let program
 						traverse(parse(code, { sourceType: "module" }), {
 							Program(path) {
@@ -235,7 +235,7 @@ async function processScript(
 		seclevelNames = ["NULLSEC", "LOWSEC", "MIDSEC", "HIGHSEC", "FULLSEC"]
 	code = (await bundle.generate({})).output[0].code
 	const { file, seclevel } = transform(parse(code, { sourceType: "module" }), sourceCode, {
-		uniqueID,
+		uniqueId,
 		scriptUser,
 		scriptName
 	})
@@ -244,7 +244,7 @@ async function processScript(
 			`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 })
+	if (shouldMinify) code = await minify(file, { uniqueId, mangleNames, forceQuineCheats, autocomplete })
 	else {
 		traverse(file, {
 			MemberExpression({ node: memberExpression }) {
@@ -259,7 +259,7 @@ async function processScript(
 					} else if (includesIllegalString(memberExpression.property.name)) {
 						memberExpression.computed = !0
 						memberExpression.property = t.stringLiteral(
-							replaceUnsafeStrings(uniqueID, memberExpression.property.name)
+							replaceUnsafeStrings(uniqueId, memberExpression.property.name)
 						)
 					}
 				}
@@ -294,25 +294,25 @@ async function processScript(
 			},
 			ObjectProperty({ node: objectProperty }) {
 				if ("Identifier" == objectProperty.key.type && includesIllegalString(objectProperty.key.name)) {
-					objectProperty.key = t.stringLiteral(replaceUnsafeStrings(uniqueID, objectProperty.key.name))
+					objectProperty.key = t.stringLiteral(replaceUnsafeStrings(uniqueId, objectProperty.key.name))
 					objectProperty.shorthand = !1
 				}
 			},
 			StringLiteral({ node }) {
-				node.value = replaceUnsafeStrings(uniqueID, node.value)
+				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.cooked = replaceUnsafeStrings(uniqueId, templateElement.value.cooked)
 						templateElement.value.raw = templateElement.value.cooked
 							.replaceAll("\\", "\\\\")
 							.replaceAll("`", "\\`")
 							.replaceAll("${", "$\\{")
-					} else templateElement.value.raw = replaceUnsafeStrings(uniqueID, templateElement.value.raw)
+					} else templateElement.value.raw = replaceUnsafeStrings(uniqueId, templateElement.value.raw)
 			},
 			RegExpLiteral(path) {
-				path.node.pattern = replaceUnsafeStrings(uniqueID, path.node.pattern)
+				path.node.pattern = replaceUnsafeStrings(uniqueId, path.node.pattern)
 				delete path.node.extra
 			}
 		})
@@ -323,7 +323,7 @@ async function processScript(
 			trailingComma: "none"
 		})
 	}
-	code = postprocess(code, seclevel, uniqueID)
+	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'

package/processScript/minify.d.ts

@@ -1,7 +1,7 @@
 import type { File } from "@babel/types";
 import type { LaxPartial } from "@samual/lib";
 type MinifyOptions = LaxPartial<{
-    /** 11 a-z 0-9 characters */ uniqueID: string;
+    /** 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
       *
@@ -14,5 +14,5 @@ type MinifyOptions = LaxPartial<{
 }>;
 /** @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 declare function minify(file: File, { uniqueId, mangleNames, forceQuineCheats, autocomplete }?: MinifyOptions): Promise<string>;
 export {};

package/processScript/minify.js

@@ -11,8 +11,8 @@ const { default: generate } = babelGenerator,
 	{ default: traverse } = babelTraverse,
 	minifyNumber = async number =>
 		/\$\((?<number>.+)\)/.exec((await terser.minify(`$(${number})`, { ecma: 2015 })).code).groups.number
-async function minify(file, { uniqueID = "00000000000", mangleNames = !1, forceQuineCheats, autocomplete } = {}) {
-	assert(/^\w{11}$/.exec(uniqueID), "src/processScript/minify.ts:46:36")
+async function minify(file, { uniqueId = "00000000000", mangleNames = !1, forceQuineCheats, autocomplete } = {}) {
+	assert(/^\w{11}$/.exec(uniqueId), "src/processScript/minify.ts:46:36")
 	let program
 	traverse(file, {
 		Program(path) {
@@ -32,23 +32,23 @@ async function minify(file, { uniqueID = "00000000000", mangleNames = !1, forceQ
 		mainFunctionPath.node.params.pop()
 	}
 	for (const global in program.scope.globals) {
-		if ("arguments" == global || global.startsWith(`$${uniqueID}$`)) continue
+		if ("arguments" == global || global.startsWith(`$${uniqueId}$`)) continue
 		const referencePaths = getReferencePathsToGlobal(global, program)
 		if (!(5 + global.length + referencePaths.length >= global.length * referencePaths.length)) {
-			for (const path of referencePaths) path.replaceWith(t.identifier(`_${uniqueID}_GLOBAL_${global}_`))
+			for (const path of referencePaths) path.replaceWith(t.identifier(`_${uniqueId}_GLOBAL_${global}_`))
 			mainFunctionPath.node.body.body.unshift(
 				t.variableDeclaration("let", [
-					t.variableDeclarator(t.identifier(`_${uniqueID}_GLOBAL_${global}_`), t.identifier(global))
+					t.variableDeclarator(t.identifier(`_${uniqueId}_GLOBAL_${global}_`), t.identifier(global))
 				])
 			)
 		}
 	}
-	const hashGReferencePaths = getReferencePathsToGlobal(`$${uniqueID}$GLOBAL$`, program)
+	const hashGReferencePaths = getReferencePathsToGlobal(`$${uniqueId}$GLOBAL$`, program)
 	if (hashGReferencePaths.length > 3) {
-		for (const path of hashGReferencePaths) path.replaceWith(t.identifier(`_${uniqueID}_G_`))
+		for (const path of hashGReferencePaths) path.replaceWith(t.identifier(`_${uniqueId}_G_`))
 		mainFunctionPath.node.body.body.unshift(
 			t.variableDeclaration("let", [
-				t.variableDeclarator(t.identifier(`_${uniqueID}_G_`), t.identifier(`$${uniqueID}$GLOBAL$`))
+				t.variableDeclarator(t.identifier(`_${uniqueId}_G_`), t.identifier(`$${uniqueId}$GLOBAL$`))
 			])
 		)
 	}
@@ -64,39 +64,39 @@ async function minify(file, { uniqueID = "00000000000", mangleNames = !1, forceQ
 					assert("Identifier" == memberExpression.property.type, "src/processScript/minify.ts:127:60")
 					if ("prototype" == memberExpression.property.name) {
 						memberExpression.computed = !0
-						memberExpression.property = t.identifier(`_${uniqueID}_PROTOTYPE_PROPERTY_`)
+						memberExpression.property = t.identifier(`_${uniqueId}_PROTOTYPE_PROPERTY_`)
 					} else if ("__proto__" == memberExpression.property.name) {
 						memberExpression.computed = !0
-						memberExpression.property = t.identifier(`_${uniqueID}_PROTO_PROPERTY_`)
+						memberExpression.property = t.identifier(`_${uniqueId}_PROTO_PROPERTY_`)
 					} else if (includesIllegalString(memberExpression.property.name)) {
 						memberExpression.computed = !0
 						memberExpression.property = t.stringLiteral(
-							replaceUnsafeStrings(uniqueID, memberExpression.property.name)
+							replaceUnsafeStrings(uniqueId, memberExpression.property.name)
 						)
 					}
 				}
 			},
 			ObjectProperty({ node: objectProperty }) {
 				if ("Identifier" == objectProperty.key.type && includesIllegalString(objectProperty.key.name)) {
-					objectProperty.key = t.stringLiteral(replaceUnsafeStrings(uniqueID, objectProperty.key.name))
+					objectProperty.key = t.stringLiteral(replaceUnsafeStrings(uniqueId, objectProperty.key.name))
 					objectProperty.shorthand = !1
 				}
 			},
 			StringLiteral({ node }) {
-				node.value = replaceUnsafeStrings(uniqueID, node.value)
+				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.cooked = replaceUnsafeStrings(uniqueId, templateElement.value.cooked)
 						templateElement.value.raw = templateElement.value.cooked
 							.replaceAll("\\", "\\\\")
 							.replaceAll("`", "\\`")
 							.replaceAll("${", "$\\{")
-					} else templateElement.value.raw = replaceUnsafeStrings(uniqueID, templateElement.value.raw)
+					} else templateElement.value.raw = replaceUnsafeStrings(uniqueId, templateElement.value.raw)
 			},
 			RegExpLiteral(path) {
-				path.node.pattern = replaceUnsafeStrings(uniqueID, path.node.pattern)
+				path.node.pattern = replaceUnsafeStrings(uniqueId, path.node.pattern)
 				delete path.node.extra
 			}
 		})
@@ -120,8 +120,8 @@ async function minify(file, { uniqueID = "00000000000", mangleNames = !1, forceQ
 				keep_fnames: !mangleNames
 			})
 		).code
-			.replace(RegExp(`_${uniqueID}_PROTOTYPE_PROPERTY_`, "g"), '"prototype"')
-			.replace(RegExp(`_${uniqueID}_PROTO_PROPERTY_`, "g"), '"__proto__"')
+			.replace(RegExp(`_${uniqueId}_PROTOTYPE_PROPERTY_`, "g"), '"prototype"')
+			.replace(RegExp(`_${uniqueId}_PROTO_PROPERTY_`, "g"), '"__proto__"')
 		autocomplete &&
 			(scriptBeforeJSONValueReplacement = spliceString(
 				scriptBeforeJSONValueReplacement,
@@ -144,12 +144,12 @@ async function minify(file, { uniqueID = "00000000000", mangleNames = !1, forceQ
 					ObjectExpression(path) {
 						const o = {}
 						parseObjectExpression(path.node, o) &&
-							path.replaceWith(t.identifier(`_${uniqueID}_JSON_VALUE_${jsonValues.push(o) - 1}_`))
+							path.replaceWith(t.identifier(`_${uniqueId}_JSON_VALUE_${jsonValues.push(o) - 1}_`))
 					},
 					ArrayExpression(path) {
 						const o = []
 						parseArrayExpression(path.node, o) &&
-							path.replaceWith(t.identifier(`_${uniqueID}_JSON_VALUE_${jsonValues.push(o) - 1}_`))
+							path.replaceWith(t.identifier(`_${uniqueId}_JSON_VALUE_${jsonValues.push(o) - 1}_`))
 					}
 				})
 				path.traverse({
@@ -182,7 +182,7 @@ async function minify(file, { uniqueID = "00000000000", mangleNames = !1, forceQ
 					UnaryExpression(path) {
 						if ("void" == path.node.operator) {
 							if ("NumericLiteral" == path.node.argument.type && !path.node.argument.value) {
-								path.replaceWith(t.identifier(`_${uniqueID}_UNDEFINED_`))
+								path.replaceWith(t.identifier(`_${uniqueId}_UNDEFINED_`))
 								undefinedIsReferenced = !0
 							}
 						} else if ("-" == path.node.operator && "NumericLiteral" == path.node.argument.type) {
@@ -195,7 +195,7 @@ async function minify(file, { uniqueID = "00000000000", mangleNames = !1, forceQ
 										(path.parent.computed = !0)
 									let jsonValueIndex = jsonValues.indexOf(value)
 									;-1 == jsonValueIndex && (jsonValueIndex += jsonValues.push(value))
-									path.replaceWith(t.identifier(`_${uniqueID}_JSON_VALUE_${jsonValueIndex}_`))
+									path.replaceWith(t.identifier(`_${uniqueId}_JSON_VALUE_${jsonValueIndex}_`))
 								})()
 							)
 							path.skip()
@@ -204,7 +204,7 @@ async function minify(file, { uniqueID = "00000000000", mangleNames = !1, forceQ
 					NullLiteral(path) {
 						let jsonValueIndex = jsonValues.indexOf(null)
 						;-1 == jsonValueIndex && (jsonValueIndex += jsonValues.push(null))
-						path.replaceWith(t.identifier(`_${uniqueID}_JSON_VALUE_${jsonValueIndex}_`))
+						path.replaceWith(t.identifier(`_${uniqueId}_JSON_VALUE_${jsonValueIndex}_`))
 					},
 					NumericLiteral(path) {
 						promises.push(
@@ -215,27 +215,27 @@ async function minify(file, { uniqueID = "00000000000", mangleNames = !1, forceQ
 									(path.parent.computed = !0)
 								let jsonValueIndex = jsonValues.indexOf(path.node.value)
 								;-1 == jsonValueIndex && (jsonValueIndex += jsonValues.push(path.node.value))
-								path.replaceWith(t.identifier(`_${uniqueID}_JSON_VALUE_${jsonValueIndex}_`))
+								path.replaceWith(t.identifier(`_${uniqueId}_JSON_VALUE_${jsonValueIndex}_`))
 							})()
 						)
 					},
 					StringLiteral(path) {
-						path.node.value = replaceUnsafeStrings(uniqueID, path.node.value)
+						path.node.value = replaceUnsafeStrings(uniqueId, path.node.value)
 						if (JSON.stringify(path.node.value).includes("\\u00") || path.toString().length < 4) return
 						"key" == path.parentKey && "ObjectProperty" == path.parent.type && (path.parent.computed = !0)
 						let jsonValueIndex = jsonValues.indexOf(path.node.value)
 						;-1 == jsonValueIndex && (jsonValueIndex += jsonValues.push(path.node.value))
-						path.replaceWith(t.identifier(`_${uniqueID}_JSON_VALUE_${jsonValueIndex}_`))
+						path.replaceWith(t.identifier(`_${uniqueId}_JSON_VALUE_${jsonValueIndex}_`))
 					},
 					ObjectProperty({ node }) {
 						if (node.computed || "Identifier" != node.key.type || node.key.name.length < 4) return
 						let jsonValueIndex = jsonValues.indexOf(node.key.name)
 						;-1 == jsonValueIndex && (jsonValueIndex += jsonValues.push(node.key.name))
 						node.computed = !0
-						node.key = t.identifier(`_${uniqueID}_JSON_VALUE_${jsonValueIndex}_`)
+						node.key = t.identifier(`_${uniqueId}_JSON_VALUE_${jsonValueIndex}_`)
 					},
 					RegExpLiteral(path) {
-						path.node.pattern = replaceUnsafeStrings(uniqueID, path.node.pattern)
+						path.node.pattern = replaceUnsafeStrings(uniqueId, path.node.pattern)
 						delete path.node.extra
 					}
 				})
@@ -251,17 +251,17 @@ async function minify(file, { uniqueID = "00000000000", mangleNames = !1, forceQ
 				if ("string" != typeof jsonValues[0] || jsonValues[0].includes("\n") || jsonValues[0].includes("\t")) {
 					const variableDeclaration = t.variableDeclaration("let", [
 						t.variableDeclarator(
-							t.identifier(`_${uniqueID}_JSON_VALUE_0_`),
+							t.identifier(`_${uniqueId}_JSON_VALUE_0_`),
 							t.callExpression(t.memberExpression(t.identifier("JSON"), t.identifier("parse")), [
 								t.memberExpression(
 									t.taggedTemplateExpression(
 										t.memberExpression(
-											t.callExpression(t.identifier(`$${uniqueID}$SUBSCRIPT$scripts$quine$`), []),
+											t.callExpression(t.identifier(`$${uniqueId}$SUBSCRIPT$scripts$quine$`), []),
 											t.identifier("split")
 										),
 										t.templateLiteral([t.templateElement({ raw: "\t", cooked: "\t" }, !0)], [])
 									),
-									t.identifier(`$${uniqueID}$SPLIT_INDEX$`),
+									t.identifier(`$${uniqueId}$SPLIT_INDEX$`),
 									!0
 								)
 							])
@@ -269,30 +269,30 @@ async function minify(file, { uniqueID = "00000000000", mangleNames = !1, forceQ
 					])
 					undefinedIsReferenced &&
 						variableDeclaration.declarations.push(
-							t.variableDeclarator(t.identifier(`_${uniqueID}_UNDEFINED_`))
+							t.variableDeclarator(t.identifier(`_${uniqueId}_UNDEFINED_`))
 						)
 					functionDeclaration.body.body.unshift(variableDeclaration)
 					comment = JSON.stringify(jsonValues[0])
 				} else {
 					const variableDeclaration = t.variableDeclaration("let", [
 						t.variableDeclarator(
-							t.identifier(`_${uniqueID}_JSON_VALUE_0_`),
+							t.identifier(`_${uniqueId}_JSON_VALUE_0_`),
 							t.memberExpression(
 								t.taggedTemplateExpression(
 									t.memberExpression(
-										t.callExpression(t.identifier(`$${uniqueID}$SUBSCRIPT$scripts$quine$`), []),
+										t.callExpression(t.identifier(`$${uniqueId}$SUBSCRIPT$scripts$quine$`), []),
 										t.identifier("split")
 									),
 									t.templateLiteral([t.templateElement({ raw: "\t", cooked: "\t" }, !0)], [])
 								),
-								t.identifier(`$${uniqueID}$SPLIT_INDEX$`),
+								t.identifier(`$${uniqueId}$SPLIT_INDEX$`),
 								!0
 							)
 						)
 					])
 					undefinedIsReferenced &&
 						variableDeclaration.declarations.push(
-							t.variableDeclarator(t.identifier(`_${uniqueID}_UNDEFINED_`))
+							t.variableDeclarator(t.identifier(`_${uniqueId}_UNDEFINED_`))
 						)
 					functionDeclaration.body.body.unshift(variableDeclaration)
 					comment = jsonValues[0]
@@ -300,31 +300,31 @@ async function minify(file, { uniqueID = "00000000000", mangleNames = !1, forceQ
 			else {
 				const variableDeclaration = t.variableDeclaration("let", [
 					t.variableDeclarator(
-						t.arrayPattern(jsonValues.map((_, index) => t.identifier(`_${uniqueID}_JSON_VALUE_${index}_`))),
+						t.arrayPattern(jsonValues.map((_, index) => t.identifier(`_${uniqueId}_JSON_VALUE_${index}_`))),
 						t.callExpression(t.memberExpression(t.identifier("JSON"), t.identifier("parse")), [
 							t.memberExpression(
 								t.taggedTemplateExpression(
 									t.memberExpression(
-										t.callExpression(t.identifier(`$${uniqueID}$SUBSCRIPT$scripts$quine$`), []),
+										t.callExpression(t.identifier(`$${uniqueId}$SUBSCRIPT$scripts$quine$`), []),
 										t.identifier("split")
 									),
 									t.templateLiteral([t.templateElement({ raw: "\t", cooked: "\t" }, !0)], [])
 								),
-								t.identifier(`$${uniqueID}$SPLIT_INDEX$`),
+								t.identifier(`$${uniqueId}$SPLIT_INDEX$`),
 								!0
 							)
 						])
 					)
 				])
 				undefinedIsReferenced &&
-					variableDeclaration.declarations.push(t.variableDeclarator(t.identifier(`_${uniqueID}_UNDEFINED_`)))
+					variableDeclaration.declarations.push(t.variableDeclarator(t.identifier(`_${uniqueId}_UNDEFINED_`)))
 				functionDeclaration.body.body.unshift(variableDeclaration)
 				comment = JSON.stringify(jsonValues)
 			}
 		} else
 			undefinedIsReferenced &&
 				functionDeclaration.body.body.unshift(
-					t.variableDeclaration("let", [t.variableDeclarator(t.identifier(`_${uniqueID}_UNDEFINED_`))])
+					t.variableDeclaration("let", [t.variableDeclarator(t.identifier(`_${uniqueId}_UNDEFINED_`))])
 				)
 		code = generate(file).code
 	}
@@ -356,7 +356,7 @@ async function minify(file, { uniqueID = "00000000000", mangleNames = !1, forceQ
 			getFunctionBodyStart(code) + 1
 		)
 		code = code.replace(
-			`$${uniqueID}$SPLIT_INDEX$`,
+			`$${uniqueId}$SPLIT_INDEX$`,
 			await minifyNumber(code.split("\t").findIndex(part => part == comment))
 		)
 	}

package/processScript/postprocess.d.ts

@@ -1 +1 @@
-export declare const postprocess: (code: string, seclevel: number, uniqueID: string) => string;
+export declare const postprocess: (code: string, seclevel: number, uniqueId: string) => string;

package/processScript/postprocess.js

@@ -1,20 +1,20 @@
-const postprocess = (code, seclevel, uniqueID) =>
+const postprocess = (code, seclevel, uniqueId) =>
 	code
 		.replace(/^function\s*\w+\(/, "function(")
-		.replace(RegExp(`\\$${uniqueID}\\$\\\\(?:\\\\)?\\$SC_DOLLAR\\$`, "g"), "S\\C$")
-		.replace(RegExp(`\\$${uniqueID}\\$\\\\(?:\\\\)?\\$DB_DOLLAR\\$`, "g"), "D\\B$")
-		.replace(RegExp(`\\$${uniqueID}\\$\\\\(?:\\\\)?\\$D\\$`, "g"), "_\\_D_S")
-		.replace(RegExp(`\\$${uniqueID}\\$\\\\(?:\\\\)?\\$FMCL\\$`, "g"), "_\\_FMCL_")
-		.replace(RegExp(`\\$${uniqueID}\\$\\\\(?:\\\\)?\\$G\\$`, "g"), "_\\_G_")
-		.replace(RegExp(`\\$${uniqueID}\\$SUBSCRIPT\\$(\\w+)\\$(\\w+)\\$`, "g"), `#${"nlmhf"[seclevel]}s.$1.$2`)
-		.replace(RegExp(`\\$${uniqueID}\\$DEBUG\\$`, "g"), "#D")
-		.replace(RegExp(`\\$${uniqueID}\\$FMCL\\$`, "g"), "#FMCL")
-		.replace(RegExp(`\\$${uniqueID}\\$GLOBAL\\$`, "g"), "#G")
-		.replace(RegExp(`\\$${uniqueID}\\$DB\\$(\\w+)\\$`, "g"), "#db.$1")
-		.replace(RegExp(`\\$${uniqueID}\\$SLASH_SLASH\\$`, "g"), "/\\/")
-		.replace(RegExp(`\\$${uniqueID}\\$NOT_A_SUBSCRIPT\\$(#[\\w\\.]+)\\(\\$`, "g"), "$1\\(")
-		.replace(RegExp(`\\$${uniqueID}\\$NOT_A_DB_CALL\\$(\\w+)\\$`, "g"), "#db.$1\\(")
-		.replace(RegExp(`\\$${uniqueID}\\$NOT_A_DEBUG_CALL\\$`, "g"), "#D\\(")
-		.replace(RegExp(`\\$${uniqueID}\\$NOT_FMCL\\$`, "g"), "#\\FMCL")
-		.replace(RegExp(`\\$${uniqueID}\\$NOT_G\\$`, "g"), "#\\G")
+		.replace(RegExp(`\\$${uniqueId}\\$\\\\(?:\\\\)?\\$SC_DOLLAR\\$`, "g"), "S\\C$")
+		.replace(RegExp(`\\$${uniqueId}\\$\\\\(?:\\\\)?\\$DB_DOLLAR\\$`, "g"), "D\\B$")
+		.replace(RegExp(`\\$${uniqueId}\\$\\\\(?:\\\\)?\\$D\\$`, "g"), "_\\_D_S")
+		.replace(RegExp(`\\$${uniqueId}\\$\\\\(?:\\\\)?\\$FMCL\\$`, "g"), "_\\_FMCL_")
+		.replace(RegExp(`\\$${uniqueId}\\$\\\\(?:\\\\)?\\$G\\$`, "g"), "_\\_G_")
+		.replace(RegExp(`\\$${uniqueId}\\$SUBSCRIPT\\$(\\w+)\\$(\\w+)\\$`, "g"), `#${"nlmhf"[seclevel]}s.$1.$2`)
+		.replace(RegExp(`\\$${uniqueId}\\$DEBUG\\$`, "g"), "#D")
+		.replace(RegExp(`\\$${uniqueId}\\$FMCL\\$`, "g"), "#FMCL")
+		.replace(RegExp(`\\$${uniqueId}\\$GLOBAL\\$`, "g"), "#G")
+		.replace(RegExp(`\\$${uniqueId}\\$DB\\$(\\w+)\\$`, "g"), "#db.$1")
+		.replace(RegExp(`\\$${uniqueId}\\$SLASH_SLASH\\$`, "g"), "/\\/")
+		.replace(RegExp(`\\$${uniqueId}\\$NOT_A_SUBSCRIPT\\$(#[\\w\\.]+)\\(\\$`, "g"), "$1\\(")
+		.replace(RegExp(`\\$${uniqueId}\\$NOT_A_DB_CALL\\$(\\w+)\\$`, "g"), "#db.$1\\(")
+		.replace(RegExp(`\\$${uniqueId}\\$NOT_A_DEBUG_CALL\\$`, "g"), "#D\\(")
+		.replace(RegExp(`\\$${uniqueId}\\$NOT_FMCL\\$`, "g"), "#\\FMCL")
+		.replace(RegExp(`\\$${uniqueId}\\$NOT_G\\$`, "g"), "#\\G")
 export { postprocess }

package/processScript/preprocess.d.ts

@@ -1,9 +1,9 @@
 import type { LaxPartial } from "@samual/lib";
 export type PreprocessOptions = LaxPartial<{
-    uniqueID: string;
+    uniqueId: string;
 }>;
 /** @param code source code for preprocessing
   * @param options {@link PreprocessOptions details} */
-export declare function preprocess(code: string, { uniqueID }?: PreprocessOptions): Promise<{
+export declare function preprocess(code: string, { uniqueId }?: PreprocessOptions): Promise<{
     code: string;
 }>;

package/processScript/preprocess.js

@@ -7,8 +7,8 @@ import { spliceString } from "@samual/lib/spliceString"
 import { resolve } from "import-meta-resolve"
 const { default: traverse } = babelTraverse,
 	{ default: generate } = babelGenerator
-async function preprocess(code, { uniqueID = "00000000000" } = {}) {
-	assert(/^\w{11}$/.test(uniqueID), "src/processScript/preprocess.ts:22:36")
+async function preprocess(code, { uniqueId = "00000000000" } = {}) {
+	assert(/^\w{11}$/.test(uniqueId), "src/processScript/preprocess.ts:22:36")
 	const sourceCode = code
 	let lengthBefore, file, program
 	do {
@@ -61,9 +61,9 @@ async function preprocess(code, { uniqueID = "00000000000" } = {}) {
 		else if ((match = /^#[0-4fhmln]?s\./.exec(codeSlice))) code = spliceString(code, "$", error.pos, 1)
 		else if ((match = /^#D[^\w$]/.exec(codeSlice))) code = spliceString(code, "$", error.pos, 1)
 		else if ((match = /^#FMCL/.exec(codeSlice)))
-			code = spliceString(code, `$${uniqueID}$FMCL$`, error.pos, match[0].length)
+			code = spliceString(code, `$${uniqueId}$FMCL$`, error.pos, match[0].length)
 		else if ((match = /^#G/.exec(codeSlice)))
-			code = spliceString(code, `$${uniqueID}$GLOBAL$`, error.pos, match[0].length)
+			code = spliceString(code, `$${uniqueId}$GLOBAL$`, error.pos, match[0].length)
 		else {
 			if (!(match = /^#db\./.exec(codeSlice))) throw error
 			code = spliceString(code, "$", error.pos, 1)

package/processScript/shared.d.ts

@@ -2,4 +2,4 @@ import type { NodePath } from "@babel/traverse";
 import type { Identifier, Program } from "@babel/types";
 export declare function getReferencePathsToGlobal(name: string, program: NodePath<Program>): NodePath<Identifier>[];
 export declare const includesIllegalString: (toCheck: string) => boolean;
-export declare const replaceUnsafeStrings: (uniqueID: string, toReplace: string) => string;
+export declare const replaceUnsafeStrings: (uniqueId: string, toReplace: string) => string;

package/processScript/shared.js

@@ -16,17 +16,17 @@ const includesIllegalString = toCheck =>
 		toCheck.includes("__D_S") ||
 		toCheck.includes("__FMCL_") ||
 		toCheck.includes("__G_"),
-	replaceUnsafeStrings = (uniqueID, toReplace) =>
+	replaceUnsafeStrings = (uniqueId, toReplace) =>
 		toReplace
-			.replaceAll("SC$", `$${uniqueID}$\\$SC_DOLLAR$`)
-			.replaceAll("DB$", `$${uniqueID}$\\$DB_DOLLAR$`)
-			.replaceAll("__D_S", `$${uniqueID}$\\$D$`)
-			.replaceAll("__FMCL_", `$${uniqueID}$\\$FMCL$`)
-			.replaceAll("__G_", `$${uniqueID}$\\$G$`)
-			.replaceAll("//", `$${uniqueID}$SLASH_SLASH$`)
-			.replaceAll(/#[0-4fhmln]?s(?:\.[_a-z][\d_a-z]{0,24}){2}\(/g, `$${uniqueID}$NOT_A_SUBSCRIPT$$$&$`)
-			.replaceAll(/#db\.(?<methodName>[irfu]|u1|us|ObjectId)\(/g, `$${uniqueID}$NOT_A_DB_CALL$$$1$`)
-			.replaceAll("#D(", `$${uniqueID}$NOT_A_DEBUG_CALL$`)
-			.replaceAll("#FMCL", `$${uniqueID}$NOT_FMCL$`)
-			.replaceAll("#G", `$${uniqueID}$NOT_G$`)
+			.replaceAll("SC$", `$${uniqueId}$\\$SC_DOLLAR$`)
+			.replaceAll("DB$", `$${uniqueId}$\\$DB_DOLLAR$`)
+			.replaceAll("__D_S", `$${uniqueId}$\\$D$`)
+			.replaceAll("__FMCL_", `$${uniqueId}$\\$FMCL$`)
+			.replaceAll("__G_", `$${uniqueId}$\\$G$`)
+			.replaceAll("//", `$${uniqueId}$SLASH_SLASH$`)
+			.replaceAll(/#[0-4fhmln]?s(?:\.[_a-z][\d_a-z]{0,24}){2}\(/g, `$${uniqueId}$NOT_A_SUBSCRIPT$$$&$`)
+			.replaceAll(/#db\.(?<methodName>[irfu]|u1|us|ObjectId)\(/g, `$${uniqueId}$NOT_A_DB_CALL$$$1$`)
+			.replaceAll("#D(", `$${uniqueId}$NOT_A_DEBUG_CALL$`)
+			.replaceAll("#FMCL", `$${uniqueId}$NOT_FMCL$`)
+			.replaceAll("#G", `$${uniqueId}$NOT_G$`)
 export { getReferencePathsToGlobal, includesIllegalString, replaceUnsafeStrings }

package/processScript/transform.d.ts

@@ -1,7 +1,7 @@
 import type { File } from "@babel/types";
 import type { LaxPartial } from "@samual/lib";
 export type TransformOptions = LaxPartial<{
-    /** 11 a-z 0-9 characters */ uniqueID: string;
+    /** 11 a-z 0-9 characters */ uniqueId: string;
     /** the user going to be hosting this script (or set to `true` if not yet known) */ scriptUser: string | true;
     seclevel: number;
 }> & {
@@ -13,7 +13,7 @@ export type TransformOptions = LaxPartial<{
   * @param file babel ast node representing a file containing preprocessed code
   * @param sourceCode the original untouched source code
   * @param options {@link TransformOptions details} */
-export declare function transform(file: File, sourceCode: string, { uniqueID, scriptUser, scriptName, seclevel }: TransformOptions): {
+export declare function transform(file: File, sourceCode: string, { uniqueId, scriptUser, scriptName, seclevel }: TransformOptions): {
     file: File;
     seclevel: number;
 };