hackmud-script-manager 0.21.1-e0cdb53 → 0.21.1-e3e8246

package/processScript/transform.js

@@ -1,10 +1,10 @@
-import x7nkcgsxzau27g4gq6kmxlmn from "@babel/traverse"
+import kwmn7lp0r5s0ul58gd0l3ldw 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 traverse = x7nkcgsxzau27g4gq6kmxlmn.default,
+const traverse = kwmn7lp0r5s0ul58gd0l3ldw.default,
 	globalFunctionsUnder7Characters = [
 		"Map",
 		"Set",
@@ -77,30 +77,30 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 			const referencePath = FunctionReferencePaths[0]
 			assert(
 				"MemberExpression" == referencePath.parent.type,
-				"src/processScript/transform.ts:108:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+				"src/processScript/transform.ts:111:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 			)
 			assert(
 				"Identifier" == referencePath.parent.property.type,
-				"src/processScript/transform.ts:113:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+				"src/processScript/transform.ts:116:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 			)
 			assert(
 				"prototype" == referencePath.parent.property.name,
-				"src/processScript/transform.ts:118:8 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+				"src/processScript/transform.ts:121: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:126:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+					"src/processScript/transform.ts:129:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 				)
 				assert(
 					"Identifier" == referencePath.parent.property.type,
-					"src/processScript/transform.ts:131:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+					"src/processScript/transform.ts:134:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
 				)
 				assert(
 					"prototype" == referencePath.parent.property.name,
-					"src/processScript/transform.ts:136:9 `Function` isn't available in hackmud, only `Function.prototype` is accessible"
+					"src/processScript/transform.ts:139: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 +141,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:196:69")
-			assert("Identifier" == referencePath.parentPath.node.property.type, "src/processScript/transform.ts:197:72")
+			assert("MemberExpression" == referencePath.parentPath.node.type, "src/processScript/transform.ts:198:69")
+			assert("Identifier" == referencePath.parentPath.node.property.type, "src/processScript/transform.ts:199:72")
 			const databaseOpMethodName = referencePath.parentPath.node.property.name
 			assert(
 				validDBMethods.includes(databaseOpMethodName),
-				`src/processScript/transform.ts:203:8 invalid db method "${databaseOpMethodName}", valid db methods are "${validDBMethods.join('", "')}"`
+				`src/processScript/transform.ts:205: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 +181,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:253:64")
+				assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:255:64")
 				if ("getPrototypeOf" == referencePath.parent.property.name) {
 					referencePath.parentPath.replaceWith(t.identifier(`_${uniqueId}_GET_PROTOTYPE_OF_`))
 					needGetPrototypeOf = !0
@@ -194,7 +194,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:271:64")
+				assert("Identifier" == referencePath.parent.property.type, "src/processScript/transform.ts:273:64")
 				referencePath.parentPath.replaceWith(
 					t.identifier(`_${uniqueId}_CONSOLE_METHOD_${referencePath.parent.property.name}_`)
 				)
@@ -202,13 +202,13 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 			}
 	const lastStatement = program.node.body.at(-1)
 	let exportDefaultName
-	assert(lastStatement, "src/processScript/transform.ts:285:27 program is empty")
+	assert(lastStatement, "src/processScript/transform.ts:287: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:291:51 ${specifier.type} is currently unsupported`
+				`src/processScript/transform.ts:293:51 ${specifier.type} is currently unsupported`
 			)
 			if (
 				"default" !=
@@ -310,11 +310,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:405:59")
+				assert(1 == globalBlockStatement.declarations.length, "src/processScript/transform.ts:406:59")
 				const declarator = globalBlockStatement.declarations[0]
 				assert(
 					"Identifier" == declarator.id.type,
-					`src/processScript/transform.ts:409:51 declarator.id.type was "${declarator.id.type}"`
+					`src/processScript/transform.ts:410:51 declarator.id.type was "${declarator.id.type}"`
 				)
 				program.scope.crawl()
 				if (program.scope.hasGlobal(declarator.id.name)) {
@@ -329,9 +329,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:428:23")
+						assert(binding, "src/processScript/transform.ts:429:23")
 						for (const referencePath of binding.referencePaths) {
-							assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:431:56")
+							assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:432:56")
 							referencePath.replaceWith(
 								t.memberExpression(
 									t.identifier(`_${uniqueId}_G_`),
@@ -379,16 +379,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:488:37")
+				assert(globalBlockStatement.id, "src/processScript/transform.ts:489: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:500:22")
+					assert(binding, "src/processScript/transform.ts:501:22")
 					for (const referencePath of binding.referencePaths) {
-						assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:503:55")
+						assert("Identifier" == referencePath.node.type, "src/processScript/transform.ts:504:55")
 						referencePath.replaceWith(
 							t.memberExpression(t.identifier(`_${uniqueId}_G_`), t.identifier(referencePath.node.name))
 						)
@@ -588,9 +588,9 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 					"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
+					"Identifier" == parent.id.type,
+				thisId = reuseDeclaredName ? parent.id.name : `_${evenMoreUniqueId}_THIS_`
+			let thisIsReferenced = !1
 			if ("ObjectExpression" == object.type)
 				for (const property of object.properties)
 					"ObjectMethod" == property.type &&
@@ -616,7 +616,7 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 					}
 					currentParent = currentParent.parentPath
 				}
-				assert(null != someBlock, "src/processScript/transform.ts:705:29")
+				assert(null != someBlock, "src/processScript/transform.ts:709:29")
 				return someBlock
 			})(path)
 			parentBlock.body.unshift(t.variableDeclaration("let", [t.variableDeclarator(t.identifier(thisId), null)]))
@@ -647,7 +647,7 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 			replaceThisInObjectLikeDefinition(path)
 		},
 		ClassBody({ node: classBody, scope, parent }) {
-			assert(t.isClass(parent), "src/processScript/transform.ts:804:30")
+			assert(t.isClass(parent), "src/processScript/transform.ts:814:30")
 			let thisIsReferenced = !1
 			for (const classMethod of classBody.body) {
 				if ("ClassMethod" != classMethod.type) continue
@@ -723,7 +723,17 @@ function transform(file, sourceCode, { uniqueId = "00000000000", scriptUser, scr
 			!parent.superClass && thisIsReferenced && (parent.superClass = t.identifier("Object"))
 		},
 		VariableDeclaration({ node: variableDeclaration }) {
-			"const" == variableDeclaration.kind && (variableDeclaration.kind = "let")
+			if ("const" == variableDeclaration.kind) {
+				variableDeclaration.kind = "let"
+				variableDeclaration.extra = { ...variableDeclaration.extra, usedToBeConst: !0 }
+			}
+		},
+		AssignmentExpression({ node: assignment, scope }) {
+			const lhs = assignment.left
+			if ("Identifier" != lhs.type) return
+			const binding = scope.getBinding(lhs.name)
+			if (binding?.path?.parentPath?.node?.extra?.usedToBeConst)
+				throw Error(`Reassignment to const variable ${lhs.name} is not allowed!`)
 		},
 		ThisExpression: path => {
 			path.replaceWith(t.identifier("undefined"))
@@ -749,23 +759,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:914:60")
+			assert("MemberExpression" == referencePath.parent.type, "src/processScript/transform.ts:937:60")
 			assert("Identifier" == referencePath.parent.property.type)
 			assert(
 				"MemberExpression" == referencePath.parentPath.parentPath?.node.type,
-				"src/processScript/transform.ts:916:81"
+				"src/processScript/transform.ts:939:81"
 			)
 			assert(
 				"Identifier" == referencePath.parentPath.parentPath.node.property.type,
-				"src/processScript/transform.ts:917:83"
+				"src/processScript/transform.ts:940:83"
 			)
 			assert(
 				/^[_a-z][\d_a-z]{0,24}$/.test(referencePath.parent.property.name),
-				`src/processScript/transform.ts:921:8 invalid user "${referencePath.parent.property.name}" in subscript`
+				`src/processScript/transform.ts:944: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:926:8 invalid script name "${referencePath.parentPath.parentPath.node.property.name}" in subscript`
+				`src/processScript/transform.ts:949:8 invalid script name "${referencePath.parentPath.parentPath.node.property.name}" in subscript`
 			)
 			if ("CallExpression" == referencePath.parentPath.parentPath.parentPath?.type)
 				referencePath.parentPath.parentPath.replaceWith(

package/pull.d.ts

@@ -1,5 +1,7 @@
-/** Copies script from hackmud to local source folder.
-  * @param sourceFolderPath path to folder containing source files
-  * @param hackmudPath path to hackmud directory
-  * @param script to pull in `user.name` format */
+/**
+ * Copies script from hackmud to local source folder.
+ * @param sourceFolderPath path to folder containing source files
+ * @param hackmudPath path to hackmud directory
+ * @param script to pull in `user.name` format
+ */
 export declare function pull(sourceFolderPath: string, hackmudPath: string, script: string): Promise<void>;

package/pull.js

@@ -1,5 +1,5 @@
-import { copyFilePersistent } from "@samual/lib/copyFilePersistent"
 import { resolve } from "path"
+import { copyFilePersistent } from "@samual/lib/copyFilePersistent"
 async function pull(sourceFolderPath, hackmudPath, script) {
 	const [user, name] = script.split(".")
 	if (!user || !name) throw Error('`script` argument must be in "user.name" format')

package/push.d.ts

@@ -3,19 +3,22 @@ import type { Info } from ".";
 export type PushOptions = LaxPartial<{
     /** whether to do the minify step (defaults to `true`) */ minify: boolean;
     /** whether to mangle function and class names (defaults to `false`) */ mangleNames: boolean;
-    /** array of scripts in the format `foo.bar`
-      *
-      * also accepts wild card (`*`) e.g. `*.bar` or `foo.*`
-      *
-      * pushes everything by default (`*.*`) */
+    /**
+     * array of scripts in the format `foo.bar`
+     *
+     * also accepts wild card (`*`) e.g. `*.bar` or `foo.*`
+     *
+     * pushes everything by default (`*.*`)
+     */
     scripts: string[];
     /** callback called on script push */ onPush: (info: Info) => void;
-    /** 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
-      */
+    /**
+     * 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;
     rootFolderPath: string;
 }>;
@@ -27,11 +30,13 @@ export declare class NoUsersError extends Error {
 }
 export declare class NoScriptsError extends Error {
 }
-/** Push scripts from a source directory to the hackmud directory.
-  *
-  * Pushes files directly in the source folder to all users
-  * @param sourcePath directory containing source code
-  * @param hackmudPath directory created by hackmud containing user data including scripts
-  * @param options {@link PushOptions details}
-  * @returns array of info on pushed scripts */
+/**
+ * Push scripts from a source directory to the hackmud directory.
+ *
+ * Pushes files directly in the source folder to all users
+ * @param sourcePath directory containing source code
+ * @param hackmudPath directory created by hackmud containing user data including scripts
+ * @param options {@link PushOptions details}
+ * @returns array of info on pushed scripts
+ */
 export declare function push(sourcePath: string, hackmudPath: string, { scripts, onPush, minify, mangleNames, forceQuineCheats, rootFolderPath }?: PushOptions): Promise<MissingSourceFolderError | MissingHackmudFolderError | NoUsersError | NoScriptsError | Info[]>;

package/push.js

@@ -1,10 +1,10 @@
-import { AutoMap } from "@samual/lib/AutoMap"
+import { readFile } from "fs/promises"
+import { basename, resolve } from "path"
 import { ensure, assert } from "@samual/lib/assert"
+import { AutoMap } from "@samual/lib/AutoMap"
 import { countHackmudCharacters } from "@samual/lib/countHackmudCharacters"
 import { readDirectoryWithStats } from "@samual/lib/readDirectoryWithStats"
 import { writeFilePersistent } from "@samual/lib/writeFilePersistent"
-import { readFile } from "fs/promises"
-import { basename, resolve } from "path"
 import { processScript } from "./processScript/index.js"
 import "@babel/generator"
 import "@babel/parser"
@@ -75,7 +75,7 @@ async function push(
 		),
 		allUsers = new Set([
 			...scripts
-				.map(scriptName => ensure(scriptName.split(".")[0], "src/push.ts:85:65"))
+				.map(scriptName => ensure(scriptName.split(".")[0], "src/push.ts:94:65"))
 				.filter(name => "*" != name),
 			...sourceFolderFolders.map(({ name }) => name),
 			...hackmudFolder.filter(({ stats }) => stats.isDirectory()).map(({ name }) => name),
@@ -91,8 +91,8 @@ async function push(
 		scriptNamesToUsers = new AutoMap(_scriptName => new Set())
 	for (const script of scripts) {
 		const [user, scriptName] = script.split(".")
-		assert(user, "src/push.ts:108:16")
-		assert(scriptName, "src/push.ts:109:22")
+		assert(user, "src/push.ts:117:16")
+		assert(scriptName, "src/push.ts:118:22")
 		"*" == user ? scriptNamesToUsers.set(scriptName, allUsers) : scriptNamesToUsers.get(scriptName).add(user)
 	}
 	const sourceFolderFiles = sourceFolder.filter(({ stats }) => stats.isFile()),

package/syncMacros.js

@@ -1,6 +1,6 @@
-import { readDirectoryWithStats } from "@samual/lib/readDirectoryWithStats"
 import { readFile, stat, writeFile } from "fs/promises"
 import { extname, basename, resolve } from "path"
+import { readDirectoryWithStats } from "@samual/lib/readDirectoryWithStats"
 async function syncMacros(hackmudPath) {
 	const files = await readDirectoryWithStats(hackmudPath),
 		macros = new Map(),
@@ -9,22 +9,21 @@ async function syncMacros(hackmudPath) {
 		files.map(async file => {
 			if (file.stats.isFile())
 				switch (extname(file.name)) {
-					case ".macros":
-						{
-							const [lines, date] = await Promise.all([
-								readFile(resolve(hackmudPath, file.name), { encoding: "utf8" }).then(file =>
-									file.split("\n")
-								),
-								stat(resolve(hackmudPath, file.name)).then(({ mtime }) => mtime)
-							])
-							for (let index = 0; index < lines.length / 2 - 1; index++) {
-								const macroName = lines[2 * index],
-									currentMacro = macros.get(macroName)
-								;(!currentMacro || date > currentMacro.date) &&
-									macros.set(macroName, { date, macro: lines[2 * index + 1] })
-							}
+					case ".macros": {
+						const [lines, date] = await Promise.all([
+							readFile(resolve(hackmudPath, file.name), { encoding: "utf8" }).then(file =>
+								file.split("\n")
+							),
+							stat(resolve(hackmudPath, file.name)).then(({ mtime }) => mtime)
+						])
+						for (let index = 0; index < lines.length / 2 - 1; index++) {
+							const macroName = lines[2 * index],
+								currentMacro = macros.get(macroName)
+							;(!currentMacro || date > currentMacro.date) &&
+								macros.set(macroName, { date, macro: lines[2 * index + 1] })
 						}
 						break
+					}
 					case ".key":
 						users.push(basename(file.name, ".key"))
 				}

package/watch.d.ts

@@ -1,15 +1,19 @@
 import type { LaxPartial } from "@samual/lib";
 import type { PushOptions } from "./push";
 export type WatchOptions = PushOptions & LaxPartial<{
-    /** if provided, will write typescript type declarations for all the scripts on every change detected
-      *
-      * writing the type declarations enables interscript type checking and autocompletetes for the args */
+    /**
+     * if provided, will write typescript type declarations for all the scripts on every change detected
+     *
+     * writing the type declarations enables interscript type checking and autocompletetes for the args
+     */
     typeDeclarationPath: string;
     onReady: () => void;
     rootFolderPath: string;
 }>;
-/** Watches target file or folder for updates and builds and pushes updated file.
-  * @param sourceDirectory path to folder containing source files
-  * @param hackmudDirectory path to hackmud directory
-  * @param options {@link WatchOptions details} and {@link PushOptions more details} */
+/**
+ * Watches target file or folder for updates and builds and pushes updated file.
+ * @param sourceDirectory path to folder containing source files
+ * @param hackmudDirectory path to hackmud directory
+ * @param options {@link WatchOptions details} and {@link PushOptions more details}
+ */
 export declare function watch(sourceDirectory: string, hackmudDirectory: string, { scripts, onPush, minify, mangleNames, typeDeclarationPath: typeDeclarationPath_, onReady, forceQuineCheats, rootFolderPath }?: WatchOptions): Promise<void>;

package/watch.js

@@ -1,11 +1,11 @@
-import { AutoMap } from "@samual/lib/AutoMap"
+import { stat, readFile, writeFile } from "fs/promises"
+import { extname, basename, resolve } from "path"
 import { assert } from "@samual/lib/assert"
+import { AutoMap } from "@samual/lib/AutoMap"
 import { countHackmudCharacters } from "@samual/lib/countHackmudCharacters"
 import { readDirectoryWithStats } from "@samual/lib/readDirectoryWithStats"
 import { writeFilePersistent } from "@samual/lib/writeFilePersistent"
 import { watch as watch$1 } from "chokidar"
-import { stat, readFile, writeFile } from "fs/promises"
-import { extname, basename, resolve } from "path"
 import { supportedExtensions } from "./constants.js"
 import { generateTypeDeclaration } from "./generateTypeDeclaration.js"
 import { processScript } from "./processScript/index.js"
@@ -144,7 +144,7 @@ async function watch(
 					}
 				))
 			} catch (error) {
-				assert(error instanceof Error, "src/watch.ts:160:36")
+				assert(error instanceof Error, "src/watch.ts:165:36")
 				onPush?.({ path, users: [], characterCount: 0, error, warnings: [] })
 				return
 			}
@@ -192,7 +192,7 @@ async function watch(
 				rootFolderPath
 			}))
 		} catch (error) {
-			assert(error instanceof Error, "src/watch.ts:207:35")
+			assert(error instanceof Error, "src/watch.ts:212:35")
 			onPush?.({ path, users: [], characterCount: 0, error, warnings: [] })
 			return
 		}
@@ -207,7 +207,7 @@ async function watch(
 		try {
 			await writeFile(typeDeclarationPath, typeDeclaration)
 		} catch (error) {
-			assert(error instanceof Error, "src/watch.ts:240:35")
+			assert(error instanceof Error, "src/watch.ts:245:35")
 			if ("EISDIR" != error.code) throw error
 			typeDeclarationPath = resolve(typeDeclarationPath, "player.d.ts")
 			await writeFile(typeDeclarationPath, typeDeclaration)