hackmud-script-manager 0.21.1-979c2a3 → 0.21.1-ae53eb7

package/README.md

@@ -1,6 +1,8 @@
 # Hackmud Script Manager
 Command made for [Hackmud Scripting Environment](https://github.com/samualtnorman/hackmud-environment), which is a scripting environment for hackmud with minification, autocompletes / intellisense, and TypeScript support.
 
+Join [our Discord server](https://discord.gg/RSa4Sc6pNA)!
+
 [![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/R6R0XN5CX)
 
 You can read about how HSM works [in my blog post](https://samual.uk/blog/js-code-transformation-niche-environment/).

package/bin/hsm.js

@@ -11,7 +11,6 @@ import { generateTypeDeclaration } from "../generateTypeDeclaration.js"
 import { pull } from "../pull.js"
 import { syncMacros } from "../syncMacros.js"
 import "@samual/lib/readDirectoryWithStats"
-import "path/posix"
 import "@samual/lib/copyFilePersistent"
 const formatOption = name => colourN(`-${1 == name.length ? "" : "-"}${name}`),
 	options = new Map(),
@@ -64,7 +63,7 @@ if (process.version.startsWith("v21.")) {
 	)
 }
 if ("v" == commands[0] || "version" == commands[0] || popOption("version", "v")?.value) {
-	console.log("0.21.1-979c2a3")
+	console.log("0.21.1-ae53eb7")
 	process.exit()
 }
 let warnedDeprecatedEmitDtsAlias = !1
@@ -412,7 +411,7 @@ function logHelp() {
 		default:
 			console.log(
 				colourS(
-					`${colourJ("Hackmud Script Manager")}\n${colourN("Version") + colourS(": ") + colourV("0.21.1-979c2a3")}\n\n${colourA("Commands:")}\n${colourL("push")}\n    ${pushCommandDescription}\n${colourL("minify")}\n    Minify a script file on the spot\n${colourL("emit-dts")}\n    Generate a type declaration file for a directory of scripts\n${colourL("sync-macros")}\n    Sync macros across all hackmud users\n${colourL("pull")}\n    Pull a script a from a hackmud user's script directory\n\n${colourA("Options:")}\n${colourN("--help")}\n    Can be used on any command e.g. ${colourC("hsm")} ${colourL("push")} ${colourN("--help")} to show helpful information`
+					`${colourJ("Hackmud Script Manager")}\n${colourN("Version") + colourS(": ") + colourV("0.21.1-ae53eb7")}\n\n${colourA("Commands:")}\n${colourL("push")}\n    ${pushCommandDescription}\n${colourL("minify")}\n    Minify a script file on the spot\n${colourL("emit-dts")}\n    Generate a type declaration file for a directory of scripts\n${colourL("sync-macros")}\n    Sync macros across all hackmud users\n${colourL("pull")}\n    Pull a script a from a hackmud user's script directory\n\n${colourA("Options:")}\n${colourN("--help")}\n    Can be used on any command e.g. ${colourC("hsm")} ${colourL("push")} ${colourN("--help")} to show helpful information`
 				)
 			)
 	}

package/env.d.ts

@@ -189,7 +189,7 @@ type Fullsec = Subscripts & PlayerFullsec & {
 
 			/** @returns A random element from `array`, selected with a random number generated using `rng`
 			  * (defaults to `Math.random`). */
-			sample: (array: any[], rng?: ()=>number) => any
+			sample: <T>(array: T[], rng?: ()=>number) => T
 
 			/** @returns Whether two MongoDB `ObjectId`s are equivalent. */ are_ids_eq: (id1: any, id2: any) => boolean
 			/** Convert a MongoDB `ObjectId` to a string. */ id_to_str: (id: string | {$oid: string}) => any
@@ -270,7 +270,7 @@ type Fullsec = Subscripts & PlayerFullsec & {
 			map: <T, U>(array: T[], callback: (index: number, value: T) => U) => U[]
 
 			/** @returns A new object derived from `obj` with only the keys specified in `keys`. */
-			pick: (obj: object, keys: string[]) => any
+			pick: <TObj extends object, TKeys extends keyof TObj>(obj: TObj, keys: TKeys[]) => { [K in TKeys]: TObj[K] }
 
 			/** @returns An array with the elements from `array` in a random order. */ shuffle: <T>(array: T[]) => T[]
 
@@ -298,7 +298,7 @@ type Fullsec = Subscripts & PlayerFullsec & {
 			security_level_names: [ "NULLSEC", "LOWSEC", "MIDSEC", "HIGHSEC", "FULLSEC" ]
 
 			/** @returns The string name of a numeric security level. */
-			get_security_level_name: (security_level: number) => any
+			get_security_level_name: (security_level: number) => string
 
 			/** @param result The return value of a call to `$db.i()` or `$db.r()`.
 			  * @param nModified The expected value of `result.nModified`.
@@ -699,7 +699,7 @@ type Nullsec = Lowsec & PlayerNullsec & {
 // database
 type MongoPrimitive = null | boolean | number | Date | string
 type MongoValue = MongoPrimitive | MongoValue[] | MongoObject
-type MongoObject = { [k: string]: MongoValue, [k: `$${string}`]: never }
+type MongoObject = { [k: string]: MongoValue }
 type MongoQueryValue = MongoPrimitive | MongoQueryValue[] | MongoQueryObject
 
 type MongoQueryObject =
@@ -710,7 +710,7 @@ type MongoTypeStringsToTypes = {
 	string: string
 	object: MongoObject
 	array: MongoValue[]
-	objectId: ObjectId
+	objectId: MongoObjectId
 	bool: boolean
 	date: Date
 	null: null
@@ -720,8 +720,8 @@ type MongoTypeStringsToTypes = {
 
 type MongoTypeString = keyof MongoTypeStringsToTypes
 type MongoTypeNumber = -1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 16 | 17 | 18 | 19 | 127
-type MongoId = Exclude<MongoPrimitive, null | false> | ObjectId | MongoObject
-type MongoQueryId = Exclude<MongoPrimitive, null | false> | ObjectId | MongoQueryObject
+type MongoId = Exclude<MongoPrimitive, null | false> | MongoObjectId | MongoObject
+type MongoQueryId = Exclude<MongoPrimitive, null | false> | MongoObjectId | MongoQueryObject
 type MongoDocument = MongoObject & { _id?: MongoId }
 
 type MongoQueryType<TQuery extends MongoQueryObject> = {
@@ -755,11 +755,16 @@ type MongoQuerySelector<T extends MongoValue> = Partial<
 
 type MongoQuery<T extends MongoObject> = { [K in keyof T]?: T[K] | MongoQuerySelector<T[K]> } & { _id?: MongoId }
 
-type MongoUpdateOperators<T extends MongoObject> = Partial<{
+type MongoUpdateArrayOperatorUniversalModifiers<T> = { $each?: T extends [] ? T : T[] }
+
+type MongoUpdateArrayOperatorModifiers<T> = MongoUpdateArrayOperatorUniversalModifiers<T> &
+	{ $position?: number, $slice?: number, $sort?: 1 | -1 }
+
+type MongoUpdateCommand<T extends MongoObject> = Partial<{
 	/* Universal operators */
-	$set: Partial<Record<string, MongoCommandValue> & T>
-	$setOnInsert: Partial<Record<string, MongoCommandValue> & T>
-	$unset: Partial<Record<string, ""> & T>
+	$set: Partial<Record<(string & {}) | keyof T, MongoCommandValue>>
+	$setOnInsert: Partial<Record<(string & {}) | keyof T, MongoCommandValue>>
+	$unset: Partial<Record<(string & {}) | keyof T, "">>
 
 	$rename: Partial<Record<string, string> & { [key in keyof T]: string }>
 
@@ -792,13 +797,6 @@ type MongoUpdateOperators<T extends MongoObject> = Partial<{
 	$pullAll: Record<string, MongoCommandValue> & { [K in keyof T as T[K] extends [] ? K : never]?: T[K] }
 }>
 
-type MongoUpdateArrayOperatorUniversalModifiers<T> = { $each?: T extends [] ? T : T[] }
-
-type MongoUpdateArrayOperatorModifiers<T> = MongoUpdateArrayOperatorUniversalModifiers<T> &
-	{ $position?: number, $slice?: number, $sort?: 1 | -1 }
-
-type MongoUpdateCommand<Schema extends MongoObject> = MongoUpdateOperators<Schema>
-
 type SortOrder = { [key: string]: 1 | -1 | SortOrder }
 
 type Cursor<T> = {
@@ -886,9 +884,9 @@ declare global {
 	type ScriptSuccess<T = unknown> = { ok: true } & T
 	type ScriptFailure = { ok: false, msg?: string }
 	type ScriptResponse<T = unknown> = ScriptSuccess<T> | ScriptFailure
-	type Scriptor<TArgs extends any[] = any[]> = { name: string, call: (...args: TArgs) => unknown }
+	type Scriptor<TArgs = any> = { name: string, call: (args: TArgs) => unknown }
 	type Context = CliContext | SubscriptContext | ScriptorContext | BrainContext
-	type ObjectId = { $oid: string }
+	type MongoObjectId = { $oid: string }
 
 	interface PlayerFullsec {}
 	interface PlayerHighsec {}
@@ -979,7 +977,7 @@ declare global {
 		us: <T extends MongoDocument>(query: MongoQuery<T> | MongoQuery<T>[], command: MongoUpdateCommand<T>) =>
 			{ n: number, ok: 0 | 1, opTime: { t: number }, nModified: number }[]
 
-		ObjectId: () => ObjectId
+		ObjectId: () => MongoObjectId
 	}
 
 	/** Debug Log.

package/generateTypeDeclaration.js

@@ -1,6 +1,5 @@
 import { readDirectoryWithStats } from "@samual/lib/readDirectoryWithStats"
 import { basename, resolve } from "path"
-import * as PathPosix from "path/posix"
 async function generateTypeDeclaration(sourceDirectory, hackmudPath) {
 	const users = new Set()
 	if (hackmudPath)
@@ -11,33 +10,35 @@ async function generateTypeDeclaration(sourceDirectory, hackmudPath) {
 		allScripts = {},
 		allAnyScripts = {}
 	await Promise.all(
-		(await readDirectoryWithStats(sourceDirectory)).map(async ({ stats, name }) => {
-			if (stats.isFile())
-				name.endsWith(".ts")
-					? name.endsWith(".d.ts") || wildScripts.push(basename(name, ".ts"))
-					: name.endsWith(".js") && wildAnyScripts.push(basename(name, ".js"))
-			else if (stats.isDirectory()) {
-				const scripts = [],
-					anyScripts = []
-				allScripts[name] = scripts
-				allAnyScripts[name] = anyScripts
-				users.add(name)
-				for (const child of await readDirectoryWithStats(resolve(sourceDirectory, name)))
-					child.stats.isFile() &&
-						(child.name.endsWith(".ts")
-							? name.endsWith(".d.ts") || scripts.push(basename(child.name, ".ts"))
-							: child.name.endsWith(".js") && anyScripts.push(basename(child.name, ".js")))
-			}
-		})
+		(await readDirectoryWithStats(sourceDirectory))
+			.filter(({ stats, name }) => !stats.isDirectory() || /^[a-z_][a-z\d_]{0,24}$/.test(name))
+			.map(async ({ stats, name }) => {
+				if (stats.isFile())
+					name.endsWith(".ts")
+						? name.endsWith(".d.ts") || wildScripts.push(basename(name, ".ts"))
+						: name.endsWith(".js") && wildAnyScripts.push(basename(name, ".js"))
+				else if (stats.isDirectory()) {
+					const scripts = [],
+						anyScripts = []
+					allScripts[name] = scripts
+					allAnyScripts[name] = anyScripts
+					users.add(name)
+					for (const child of await readDirectoryWithStats(resolve(sourceDirectory, name)))
+						child.stats.isFile() &&
+							(child.name.endsWith(".ts")
+								? name.endsWith(".d.ts") || scripts.push(basename(child.name, ".ts"))
+								: child.name.endsWith(".js") && anyScripts.push(basename(child.name, ".js")))
+				}
+			})
 	)
-	sourceDirectory = PathPosix.resolve(sourceDirectory)
 	let o = ""
-	for (const script of wildScripts) o += `type $${script}$ = typeof import("${sourceDirectory}/${script}").default\n`
+	for (const script of wildScripts)
+		o += `type $${script}$ = typeof import(${JSON.stringify(resolve(sourceDirectory, script))}).default\n`
 	o += "\n"
 	for (const user in allScripts) {
 		const scripts = allScripts[user]
 		for (const script of scripts)
-			o += `type $${user}$${script}$ = typeof import("${sourceDirectory}/${user}/${script}").default\n`
+			o += `type $${user}$${script}$ = typeof import(${JSON.stringify(resolve(sourceDirectory, user, script))}).default\n`
 	}
 	o +=
 		"\ntype ArrayRemoveFirst<A> = A extends [ infer FirstItem, ...infer Rest ] ? Rest : never\n\ntype Subscript<T extends (...args: any) => any> =\n\t(...args: ArrayRemoveFirst<Parameters<T>>) => ReturnType<T> | ScriptFailure\n\ntype WildFullsec = Record<string, () => ScriptFailure> & {\n"

package/index.js

@@ -7,7 +7,6 @@ export { syncMacros } from "./syncMacros.js"
 export { watch } from "./watch.js"
 import "@samual/lib/readDirectoryWithStats"
 import "path"
-import "path/posix"
 import "@babel/generator"
 import "@babel/parser"
 import "@babel/plugin-proposal-decorators"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hackmud-script-manager",
-  "version": "0.21.1-979c2a3",
+  "version": "0.21.1-ae53eb7",
   "description": "Script manager for game hackmud, with minification, TypeScript support, and player script type definition generation.",
   "keywords": [
     "api",
@@ -23,7 +23,9 @@
   "author": "Samual Norman <me@samual.uk> (https://samual.uk/)",
   "contributors": [
     "Daniel Swann (https://github.com/danswann)",
-    "Longboyy"
+    "Longboyy",
+    "Helloman892",
+    "Sarah Klocke (https://sarahisweird.dev/)"
   ],
   "main": "index.js",
   "repository": {

package/processScript/index.js

@@ -1,4 +1,4 @@
-import babelGenerator from "@babel/generator"
+import generate from "@babel/generator"
 import { parse } from "@babel/parser"
 import babelPluginProposalDecorators from "@babel/plugin-proposal-decorators"
 import babelPluginProposalDestructuringPrivate from "@babel/plugin-proposal-destructuring-private"
@@ -15,7 +15,7 @@ import babelPluginTransformOptionalCatchBinding from "@babel/plugin-transform-op
 import babelPluginTransformOptionalChaining from "@babel/plugin-transform-optional-chaining"
 import babelPluginTransformPrivatePropertyInObject from "@babel/plugin-transform-private-property-in-object"
 import babelPluginTransformUnicodeSetsRegex from "@babel/plugin-transform-unicode-sets-regex"
-import babelTraverse from "@babel/traverse"
+import traverse from "@babel/traverse"
 import t from "@babel/types"
 import rollupPluginAlias from "@rollup/plugin-alias"
 import { babel } from "@rollup/plugin-babel"
@@ -23,7 +23,7 @@ import rollupPluginCommonJS from "@rollup/plugin-commonjs"
 import rollupPluginJSON from "@rollup/plugin-json"
 import rollupPluginNodeResolve from "@rollup/plugin-node-resolve"
 import { assert } from "@samual/lib/assert"
-import { relative } from "path"
+import { relative, isAbsolute, sep } from "path"
 import prettier from "prettier"
 import { rollup } from "rollup"
 import { supportedExtensions } from "../constants.js"
@@ -38,9 +38,7 @@ import "acorn"
 import "terser"
 import "import-meta-resolve"
 import "@samual/lib/clearObject"
-const { format } = prettier,
-	{ default: generate } = babelGenerator,
-	{ default: traverse } = babelTraverse
+const { format } = prettier
 async function processScript(
 	code,
 	{
@@ -56,7 +54,7 @@ async function processScript(
 		rootFolderPath
 	}
 ) {
-	assert(/^\w{11}$/.exec(uniqueId), "src/processScript/index.ts:81:36")
+	assert(/^\w{11}$/.exec(uniqueId), "src/processScript/index.ts:78:36")
 	const sourceCode = code
 	let autocomplete, statedSeclevel
 	const autocompleteMatch = /^function\s*\(.+\/\/(?<autocomplete>.+)/.exec(code)
@@ -117,30 +115,30 @@ async function processScript(
 				}
 			}
 		}
-	assert(/^\w{11}$/.exec(uniqueId), "src/processScript/index.ts:162:36")
+	assert(/^\w{11}$/.exec(uniqueId), "src/processScript/index.ts:159: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]
+		[babelPluginProposalDecorators, { decoratorsBeforeExport: !0 }],
+		[babelPluginTransformClassProperties],
+		[babelPluginTransformClassStaticBlock],
+		[babelPluginTransformPrivatePropertyInObject],
+		[babelPluginTransformLogicalAssignmentOperators],
+		[babelPluginTransformNumericSeparator],
+		[babelPluginTransformNullishCoalescingOperator],
+		[babelPluginTransformOptionalChaining],
+		[babelPluginTransformOptionalCatchBinding],
+		[babelPluginTransformJsonStrings],
+		[babelPluginTransformObjectRestSpread],
+		[babelPluginTransformExponentiationOperator],
+		[babelPluginTransformUnicodeSetsRegex],
+		[babelPluginProposalDestructuringPrivate],
+		[babelPluginProposalExplicitResourceManagement]
 	]
 	let filePathResolved
 	if (filePath) {
 		filePathResolved = relative(".", filePath)
 		if (filePath.endsWith(".ts"))
 			plugins.push([
-				(await import("@babel/plugin-transform-typescript")).default,
+				await import("@babel/plugin-transform-typescript"),
 				{ allowDeclareFields: !0, optimizeConstEnums: !0 }
 			])
 		else {
@@ -162,13 +160,13 @@ async function processScript(
 				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 }]
+				[babelPluginProposalDoExpressions],
+				[babelPluginProposalFunctionBind],
+				[babelPluginProposalFunctionSent],
+				[babelPluginProposalPartialApplication],
+				[babelPluginProposalPipelineOperator, { proposal: "hack", topicToken: "%" }],
+				[babelPluginProposalThrowExpressions],
+				[babelPluginProposalRecordAndTuple, { syntaxType: "hash", importPolyfill: !0 }]
 			)
 		}
 	} else {
@@ -193,14 +191,14 @@ async function processScript(
 			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 }]
+			[babelPluginTransformTypescript, { allowDeclareFields: !0, optimizeConstEnums: !0 }],
+			[babelPluginProposalDoExpressions],
+			[babelPluginProposalFunctionBind],
+			[babelPluginProposalFunctionSent],
+			[babelPluginProposalPartialApplication],
+			[babelPluginProposalPipelineOperator, { proposal: "hack", topicToken: "%" }],
+			[babelPluginProposalThrowExpressions],
+			[babelPluginProposalRecordAndTuple, { syntaxType: "hash", importPolyfill: !0 }]
 		)
 	}
 	const bundle = await rollup({
@@ -210,7 +208,8 @@ async function processScript(
 				{
 					name: "hackmud-script-manager",
 					async transform(code, id) {
-						if (!id.includes("/node_modules/")) return (await preprocess(code, { uniqueId })).code
+						if (isAbsolute(id) && !id.includes(`${sep}node_modules${sep}`))
+							return (await preprocess(code, { uniqueId })).code
 						let program
 						traverse(parse(code, { sourceType: "module" }), {
 							Program(path) {
@@ -252,7 +251,7 @@ async function processScript(
 		traverse(file, {
 			MemberExpression({ node: memberExpression }) {
 				if (!memberExpression.computed) {
-					assert("Identifier" == memberExpression.property.type, "src/processScript/index.ts:326:60")
+					assert("Identifier" == memberExpression.property.type, "src/processScript/index.ts:323:60")
 					if ("prototype" == memberExpression.property.name) {
 						memberExpression.computed = !0
 						memberExpression.property = t.stringLiteral("prototype")
@@ -282,7 +281,7 @@ async function processScript(
 							break
 						case "ObjectPattern":
 							for (const property of lValue.properties) {
-								assert("ObjectProperty" == property.type, "src/processScript/index.ts:356:51")
+								assert("ObjectProperty" == property.type, "src/processScript/index.ts:353:51")
 								renameVariables(property.value)
 							}
 							break

package/processScript/minify.js

@@ -1,5 +1,5 @@
-import babelGenerator from "@babel/generator"
-import babelTraverse from "@babel/traverse"
+import generate from "@babel/generator"
+import traverse from "@babel/traverse"
 import t from "@babel/types"
 import { assert } from "@samual/lib/assert"
 import { countHackmudCharacters } from "@samual/lib/countHackmudCharacters"
@@ -7,12 +7,10 @@ import { spliceString } from "@samual/lib/spliceString"
 import { tokenizer, tokTypes } from "acorn"
 import * as terser from "terser"
 import { getReferencePathsToGlobal, includesIllegalString, replaceUnsafeStrings } from "./shared.js"
-const { default: generate } = babelGenerator,
-	{ default: traverse } = babelTraverse,
-	minifyNumber = async number =>
-		/\$\((?<number>.+)\)/.exec((await terser.minify(`$(${number})`, { ecma: 2015 })).code).groups.number
+const 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")
+	assert(/^\w{11}$/.exec(uniqueId), "src/processScript/minify.ts:41:36")
 	let program
 	traverse(file, {
 		Program(path) {
@@ -52,7 +50,7 @@ async function minify(file, { uniqueId = "00000000000", mangleNames = !1, forceQ
 		traverse(fileBeforeJSONValueReplacement, {
 			MemberExpression({ node: memberExpression }) {
 				if (!memberExpression.computed) {
-					assert("Identifier" == memberExpression.property.type, "src/processScript/minify.ts:115:60")
+					assert("Identifier" == memberExpression.property.type, "src/processScript/minify.ts:110:60")
 					if ("prototype" == memberExpression.property.name) {
 						memberExpression.computed = !0
 						memberExpression.property = t.identifier(`_${uniqueId}_PROTOTYPE_PROPERTY_`)
@@ -164,7 +162,7 @@ async function minify(file, { uniqueId = "00000000000", mangleNames = !1, forceQ
 					},
 					MemberExpression({ node: memberExpression }) {
 						if (!memberExpression.computed) {
-							assert("Identifier" == memberExpression.property.type, "src/processScript/minify.ts:249:62")
+							assert("Identifier" == memberExpression.property.type, "src/processScript/minify.ts:244:62")
 							if (!(memberExpression.property.name.length < 3)) {
 								memberExpression.computed = !0
 								memberExpression.property = t.stringLiteral(memberExpression.property.name)
@@ -238,7 +236,7 @@ async function minify(file, { uniqueId = "00000000000", mangleNames = !1, forceQ
 		})
 		await Promise.all(promises)
 		const functionDeclaration = file.program.body[0]
-		assert("FunctionDeclaration" == functionDeclaration.type, "src/processScript/minify.ts:354:61")
+		assert("FunctionDeclaration" == functionDeclaration.type, "src/processScript/minify.ts:349:61")
 		if (jsonValues.length) {
 			hasComment = !0
 			if (1 == jsonValues.length)
@@ -358,7 +356,7 @@ async function minify(file, { uniqueId = "00000000000", mangleNames = !1, forceQ
 		)
 	}
 	if (1 == forceQuineCheats) return code
-	assert(scriptBeforeJSONValueReplacement, "src/processScript/minify.ts:485:43")
+	assert(scriptBeforeJSONValueReplacement, "src/processScript/minify.ts:480:43")
 	return countHackmudCharacters(scriptBeforeJSONValueReplacement) <= countHackmudCharacters(code) + Number(hasComment)
 		? scriptBeforeJSONValueReplacement
 		: code
@@ -371,7 +369,7 @@ function parseObjectExpression(node, o) {
 			"Identifier" == property.key.type ||
 				"NumericLiteral" == property.key.type ||
 				"StringLiteral" == property.key.type,
-			"src/processScript/minify.ts:507:4"
+			"src/processScript/minify.ts:502:4"
 		)
 		if ("ArrayExpression" == property.value.type) {
 			const childArray = []

package/processScript/preprocess.js

@@ -1,14 +1,12 @@
-import babelGenerator from "@babel/generator"
+import generate from "@babel/generator"
 import { parse } from "@babel/parser"
-import babelTraverse from "@babel/traverse"
+import traverse from "@babel/traverse"
 import t from "@babel/types"
 import { assert } from "@samual/lib/assert"
 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:23:36")
+	assert(/^\w{11}$/.test(uniqueId), "src/processScript/preprocess.ts:18:36")
 	const sourceCode = code
 	let lengthBefore, file, program
 	do {
@@ -47,7 +45,7 @@ async function preprocess(code, { uniqueId = "00000000000" } = {}) {
 			})
 			break
 		} catch (error_) {
-			assert(error_ instanceof SyntaxError, "src/processScript/preprocess.ts:67:42")
+			assert(error_ instanceof SyntaxError, "src/processScript/preprocess.ts:62:42")
 			error = error_
 		}
 		if ("BABEL_PARSER_SYNTAX_ERROR" != error.code || "PrivateInExpectedIn" != error.reasonCode) {

package/processScript/transform.js

@@ -1,26 +1,25 @@
-import babelTraverse from "@babel/traverse"
+import traverse from "@babel/traverse"
 import t from "@babel/types"
 import { assert } from "@samual/lib/assert"
 import { clearObject } from "@samual/lib/clearObject"
 import { validDBMethods } from "../constants.js"
 import { getReferencePathsToGlobal } from "./shared.js"
-const { default: traverse } = babelTraverse,
-	globalFunctionsUnder7Characters = [
-		"Map",
-		"Set",
-		"Date",
-		"JSON",
-		"Math",
-		"Array",
-		"Error",
-		"isNaN",
-		"Number",
-		"Object",
-		"RegExp",
-		"String",
-		"Symbol",
-		"BigInt"
-	]
+const globalFunctionsUnder7Characters = [
+	"Map",
+	"Set",
+	"Date",
+	"JSON",
+	"Math",
+	"Array",
+	"Error",
+	"isNaN",
+	"Number",
+	"Object",
+	"RegExp",
+	"String",
+	"Symbol",
+	"BigInt"
+]
 function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scriptName, seclevel = 4 }) {
 	const warnings = [],
 		topFunctionName = `_${uniqueId}_SCRIPT_`
@@ -77,30 +76,30 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 			const referencePath = FunctionReferencePaths[0]
 			assert(
 				"MemberExpression" == referencePath.parent.type,
-				"src/processScript/transform.ts:111:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+				"src/processScript/transform.ts:108:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 			)
 			assert(
 				"Identifier" == referencePath.parent.property.type,
-				"src/processScript/transform.ts:116:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+				"src/processScript/transform.ts:113:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 			)
 			assert(
 				"prototype" == referencePath.parent.property.name,
-				"src/processScript/transform.ts:121:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+				"src/processScript/transform.ts:118: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,
-					"src/processScript/transform.ts:129:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+					"src/processScript/transform.ts:126:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 				)
 				assert(
 					"Identifier" == referencePath.parent.property.type,
-					"src/processScript/transform.ts:134:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+					"src/processScript/transform.ts:131:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 				)
 				assert(
 					"prototype" == referencePath.parent.property.name,
-					"src/processScript/transform.ts:139:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+					"src/processScript/transform.ts:136:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 				)
 				functionDotPrototypeIsReferencedMultipleTimes = !0
 				referencePath.parentPath.replaceWith(t.identifier(`_${uniqueId}_FUNCTION_DOT_PROTOTYPE_`))
@@ -141,12 +140,12 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 	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:199:69")
-			assert("Identifier" == referencePath.parentPath.node.property.type, "src/processScript/transform.ts:200:72")
+			assert("MemberExpression" == referencePath.parentPath.node.type, "src/processScript/transform.ts:196:69")
+			assert("Identifier" == referencePath.parentPath.node.property.type, "src/processScript/transform.ts:197:72")
 			const databaseOpMethodName = referencePath.parentPath.node.property.name
 			assert(
 				validDBMethods.includes(databaseOpMethodName),
-				`src/processScript/transform.ts:206:8 invalid db method "${databaseOpMethodName}", valid db methods are "${validDBMethods.join('", "')}"`
+				`src/processScript/transform.ts:203: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}$`))
@@ -181,7 +180,7 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 	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:256:64")
+				assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:253:64")
 				if ("getPrototypeOf" == referencePath.parent.property.name) {
 					referencePath.parentPath.replaceWith(t.identifier(`_${uniqueId}_GET_PROTOTYPE_OF_`))
 					needGetPrototypeOf = !0
@@ -194,7 +193,7 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 	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:274:64")
+				assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:271:64")
 				referencePath.parentPath.replaceWith(
 					t.identifier(`_${uniqueId}_CONSOLE_METHOD_${referencePath.parent.property.name}_`)
 				)
@@ -202,13 +201,13 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 			}
 	const lastStatement = program.node.body.at(-1)
 	let exportDefaultName
-	assert(lastStatement, "src/processScript/transform.ts:288:27 program is empty")
+	assert(lastStatement, "src/processScript/transform.ts:285: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:294:51 ${specifier.type} is currently unsupported`
+				`src/processScript/transform.ts:291:51 ${specifier.type} is currently unsupported`
 			)
 			if (
 				"default" !=
@@ -310,11 +309,11 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 		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:408:59")
+				assert(1 == globalBlockStatement.declarations.length, "src/processScript/transform.ts:405:59")
 				const declarator = globalBlockStatement.declarations[0]
 				assert(
 					"Identifier" == declarator.id.type,
-					`src/processScript/transform.ts:412:51 declarator.id.type was "${declarator.id.type}"`
+					`src/processScript/transform.ts:409:51 declarator.id.type was "${declarator.id.type}"`
 				)
 				program.scope.crawl()
 				if (program.scope.hasGlobal(declarator.id.name)) {
@@ -329,9 +328,9 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 						Object.keys(program.scope.globals).some(global => globalBlockVariables.has(global))
 					) {
 						const binding = program.scope.getBinding(declarator.id.name)
-						assert(binding, "src/processScript/transform.ts:431:23")
+						assert(binding, "src/processScript/transform.ts:428:23")
 						for (const referencePath of binding.referencePaths) {
-							assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:434:56")
+							assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:431:56")
 							referencePath.replaceWith(
 								t.memberExpression(
 									t.identifier(`_${uniqueId}_G_`),
@@ -379,16 +378,16 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 				} else globalBlockVariables.add(declarator.id.name)
 			} else if ("ClassDeclaration" == globalBlockStatement.type) {
 				program.scope.crawl()
-				assert(globalBlockStatement.id, "src/processScript/transform.ts:491:37")
+				assert(globalBlockStatement.id, "src/processScript/transform.ts:488: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:503:22")
+					assert(binding, "src/processScript/transform.ts:500:22")
 					for (const referencePath of binding.referencePaths) {
-						assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:506:55")
+						assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:503:55")
 						referencePath.replaceWith(
 							t.memberExpression(t.identifier(`_${uniqueId}_G_`), t.identifier(referencePath.node.name))
 						)
@@ -562,6 +561,65 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 				t.variableDeclarator(t.identifier(`_${uniqueId}_G_`), t.identifier(`$${uniqueId}$GLOBAL$`))
 			])
 		)
+	const replaceAllThisWith = (node, scope, thisId) => {
+			let thisIsReferenced = !1
+			traverse(
+				node,
+				{
+					ThisExpression(path) {
+						thisIsReferenced = !0
+						path.replaceWith(t.identifier(thisId))
+					},
+					Function(path) {
+						"ArrowFunctionExpression" != path.node.type && path.skip()
+					}
+				},
+				scope
+			)
+			return thisIsReferenced
+		},
+		replaceThisInObjectLikeDefinition = path => {
+			const { node: object, scope, parent } = path,
+				evenMoreUniqueId = Math.floor(Math.random() * 2 ** 52)
+					.toString(36)
+					.padStart(11, "0"),
+				reuseDeclaredName =
+					"VariableDeclarator" == parent.type &&
+					"VariableDeclaration" == path.parentPath?.parentPath?.node?.type &&
+					"const" == path.parentPath?.parentPath?.node?.kind &&
+					"Identifier" == parent.id.type
+			let thisId = reuseDeclaredName ? parent.id.name : `_${evenMoreUniqueId}_THIS_`,
+				thisIsReferenced = !1
+			if ("ObjectExpression" == object.type)
+				for (const property of object.properties)
+					"ObjectMethod" == property.type &&
+						(thisIsReferenced ||= replaceAllThisWith(property, scope, thisId))
+			else
+				for (const element of object.elements)
+					null != element && (thisIsReferenced ||= replaceAllThisWith(element, scope, thisId))
+			if (!thisIsReferenced) return
+			if (reuseDeclaredName) return
+			path.replaceWith(t.assignmentExpression("=", t.identifier(thisId), object))
+			const parentBlock = (path => {
+				let someBlock = null,
+					currentParent = path
+				for (; currentParent && currentParent && currentParent.node; ) {
+					if (t.isBlock(currentParent.node)) {
+						someBlock = currentParent.node
+						break
+					}
+					if (t.isArrowFunctionExpression(currentParent.parentPath?.node)) {
+						currentParent.replaceWith(t.blockStatement([t.returnStatement(currentParent.node)]))
+						someBlock = currentParent.node
+						break
+					}
+					currentParent = currentParent.parentPath
+				}
+				assert(null != someBlock, "src/processScript/transform.ts:705:29")
+				return someBlock
+			})(path)
+			parentBlock.body.unshift(t.variableDeclaration("let", [t.variableDeclarator(t.identifier(thisId), null)]))
+		}
 	traverse(file, {
 		BlockStatement({ node: blockStatement }) {
 			for (const [index, functionDeclaration] of blockStatement.body.entries())
@@ -581,8 +639,14 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 					)
 				}
 		},
+		ObjectExpression(path) {
+			replaceThisInObjectLikeDefinition(path)
+		},
+		ArrayExpression(path) {
+			replaceThisInObjectLikeDefinition(path)
+		},
 		ClassBody({ node: classBody, scope, parent }) {
-			assert(t.isClass(parent), "src/processScript/transform.ts:701:30")
+			assert(t.isClass(parent), "src/processScript/transform.ts:804:30")
 			let thisIsReferenced = !1
 			for (const classMethod of classBody.body) {
 				if ("ClassMethod" != classMethod.type) continue
@@ -595,7 +659,9 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 							thisIsReferenced = !0
 							path.replaceWith(t.identifier(`_${uniqueId}_THIS_`))
 						},
-						Function: path => path.skip()
+						Function(path) {
+							"ArrowFunctionExpression" != path.node.type && path.skip()
+						}
 					},
 					scope
 				)
@@ -682,23 +748,23 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 	}
 	function processFakeSubscriptObject(fakeSubscriptObjectName, seclevel) {
 		for (const referencePath of getReferencePathsToGlobal(fakeSubscriptObjectName, program)) {
-			assert("MemberExpression" == referencePath.parent.type, "src/processScript/transform.ts:807:60")
+			assert("MemberExpression" == referencePath.parent.type, "src/processScript/transform.ts:914:60")
 			assert("Identifier" == referencePath.parent.property.type)
 			assert(
 				"MemberExpression" == referencePath.parentPath.parentPath?.node.type,
-				"src/processScript/transform.ts:809:81"
+				"src/processScript/transform.ts:916:81"
 			)
 			assert(
 				"Identifier" == referencePath.parentPath.parentPath.node.property.type,
-				"src/processScript/transform.ts:810:83"
+				"src/processScript/transform.ts:917:83"
 			)
 			assert(
 				/^[_a-z][\d_a-z]{0,24}$/.test(referencePath.parent.property.name),
-				`src/processScript/transform.ts:814:8 invalid user "${referencePath.parent.property.name}" in subscript`
+				`src/processScript/transform.ts:921: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:819:8 invalid script name "${referencePath.parentPath.parentPath.node.property.name}" in subscript`
+				`src/processScript/transform.ts:926:8 invalid script name "${referencePath.parentPath.parentPath.node.property.name}" in subscript`
 			)
 			if ("CallExpression" == referencePath.parentPath.parentPath.parentPath?.type)
 				referencePath.parentPath.parentPath.replaceWith(

package/push.js

@@ -70,7 +70,9 @@ async function push(
 	])
 	if (sourceFolder instanceof Error) return sourceFolder
 	if (hackmudFolder instanceof Error) return hackmudFolder
-	const sourceFolderFolders = sourceFolder.filter(({ stats }) => stats.isDirectory()),
+	const sourceFolderFolders = sourceFolder.filter(
+			({ name, stats }) => stats.isDirectory() && /^[a-z_][a-z\d_]{0,24}$/.test(name)
+		),
 		allUsers = new Set([
 			...scripts
 				.map(scriptName => ensure(scriptName.split(".")[0], "src/push.ts:85:65"))

package/watch.js

@@ -9,7 +9,6 @@ import { extname, basename, resolve } from "path"
 import { supportedExtensions } from "./constants.js"
 import { generateTypeDeclaration } from "./generateTypeDeclaration.js"
 import { processScript } from "./processScript/index.js"
-import "path/posix"
 import "@babel/generator"
 import "@babel/parser"
 import "@babel/plugin-proposal-decorators"