hackmud-script-manager 0.11.0-2c5ee07 → 0.12.0-2ac9138

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "hackmud-script-manager",
-	"version": "0.11.0-2c5ee07",
+	"version": "0.12.0-2ac9138",
 	"description": "Script manager for game hackmud, with minification, TypeScript support, and player script type definition generation.",
 	"keywords": [
 		"api",
@@ -23,7 +23,7 @@
 	"author": "Samual Norman",
 	"files": [
 		"index.d.ts",
-		"lib.js"
+		"shared.js"
 	],
 	"main": "index.js",
 	"bin": {
@@ -34,24 +34,34 @@
 		"url": "https://github.com/samualtnorman/hackmud-script-manager.git"
 	},
 	"scripts": {
-		"build": "tsc",
-		"dev": "tsc --watch",
-		"test": "tsc --noEmit"
+		"build": "rollup -c",
+		"dev": "rollup -cw"
 	},
 	"dependencies": {
 		"acorn": "8.x",
 		"chalk": "4.x",
 		"chokidar": "3.x",
+		"escodegen": "^2.0.0",
+		"esprima": "^4.0.1",
+		"esquery": "^1.4.0",
 		"terser": "5.x",
 		"typescript": "^4.4.0-beta"
 	},
 	"devDependencies": {
+		"@rollup/plugin-typescript": "^8.2.5",
+		"@types/escodegen": "^0.0.7",
+		"@types/esprima": "^4.0.3",
+		"@types/esquery": "^1.0.2",
 		"@types/node": "12.x",
 		"@types/semver": "7.x",
-		"semver": "7.x"
+		"rollup": "^2.56.3",
+		"rollup-plugin-preserve-shebang": "^1.0.1",
+		"semver": "7.x",
+		"tslib": "^2.3.1"
 	},
 	"engines": {
 		"node": ">=12"
 	},
-	"types": "index.d.ts"
+	"types": "index.d.ts",
+	"type": "module"
 }

package/shared.js

@@ -0,0 +1,901 @@
+import { tokenizer, tokTypes } from 'acorn';
+import { watch as watch$1 } from 'chokidar';
+import { generate } from 'escodegen';
+import { parseScript } from 'esprima';
+import query from 'esquery';
+import fs from 'fs';
+import { dirname, resolve, extname, basename } from 'path';
+import { minify } from 'terser';
+import typescript from 'typescript';
+
+const { writeFile: writeFile$1, mkdir: makeDirectory, copyFile } = fs.promises;
+function writeFilePersist(path, data, options) {
+    return writeFile$1(path, data, options).catch(async (error) => {
+        if (error.code != "ENOENT")
+            throw error;
+        await makeDirectory(dirname(path), { recursive: true });
+        await writeFile$1(path, data, options);
+    });
+}
+function copyFilePersist(src, dest, flags) {
+    return copyFile(src, dest, flags).catch(async (error) => {
+        if (error.code != "ENOENT")
+            throw error;
+        await makeDirectory(dirname(dest), { recursive: true });
+        await copyFile(src, dest, flags);
+    });
+}
+function hackmudLength(script) {
+    return script.replace(/\/\/.*/g, "").replace(/[ \t\n\r\u00a0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000]/g, "").length;
+}
+function positionToLineNumber(position, script) {
+    let totalCharacters = 0;
+    for (const [lineNumber, line] of script.split("\n").entries()) {
+        totalCharacters += line.length + 1;
+        if (position < totalCharacters)
+            return lineNumber;
+    }
+    throw new Error("unreachable");
+}
+function stringSplice(original, replacement, start, end = start) {
+    return original.slice(0, start) + replacement + original.slice(end);
+}
+class DynamicMap extends Map {
+    constructor(fallbackHandler) {
+        super();
+        this.fallbackHandler = fallbackHandler;
+    }
+    get(key) {
+        if (super.has(key))
+            return super.get(key);
+        const value = this.fallbackHandler(key);
+        super.set(key, value);
+        return value;
+    }
+}
+function clearObject(object) {
+    for (const propertyName of Object.getOwnPropertyNames(object)) {
+        // @ts-ignore
+        delete object[propertyName];
+    }
+    for (const propertySymbol of Object.getOwnPropertySymbols(object)) {
+        // @ts-ignore
+        delete object[propertyName];
+    }
+    return object;
+}
+
+const { readFile: readFile, readdir: readDirectory, stat: getFileStatus, writeFile: writeFile } = fs.promises;
+const supportedExtensions = [".js", ".ts"];
+// TODO `clean()` function that delete all scripts in hackmud directory #70
+// TODO optional argument (defaults to false) for `clean()` that makes it only remove scripts without a source file #70
+/**
+ * Push a specific or all scripts to a specific or all users.
+ * In source directory, scripts in folders will override scripts with same name for user with folder name.
+ *
+ * e.g. foo/bar.js overrides other bar.js script just for user foo.
+ *
+ * @param srcDir path to folder containing source files
+ * @param hackmudDir path to hackmud directory
+ * @param users users to push to (pushes to all if empty)
+ * @param scripts scripts to push from (pushes from all if empty)
+ * @param onPush function that's called when a script has been pushed
+ */
+function push(srcDir, hackmudDir, users, scripts, onPush) {
+    return new Promise(async (resolve$1) => {
+        const infoAll = [];
+        const files = await readDirectory(srcDir, { withFileTypes: true });
+        const skips = new Map();
+        const promises = [];
+        for (const dir of files) {
+            const user = dir.name;
+            if (dir.isDirectory() && (!users.length || users.includes(user))) {
+                promises.push(readDirectory(resolve(srcDir, user), { withFileTypes: true }).then(files => {
+                    for (const file of files) {
+                        const extension = extname(file.name);
+                        const name = basename(file.name, extension);
+                        if (supportedExtensions.includes(extension) && file.isFile() && (!scripts.length || scripts.includes(name))) {
+                            let skip = skips.get(name);
+                            if (skip)
+                                skip.push(user);
+                            else
+                                skips.set(name, [user]);
+                            readFile(resolve(srcDir, user, file.name), { encoding: "utf-8" }).then(async (code) => {
+                                let error = null;
+                                const { srcLength, script: minCode } = await processScript(code).catch(reason => {
+                                    error = reason;
+                                    return {
+                                        srcLength: 0,
+                                        script: ""
+                                    };
+                                });
+                                const info = {
+                                    file: `${user}/${file.name}`,
+                                    users: [user],
+                                    minLength: 0,
+                                    error,
+                                    srcLength
+                                };
+                                infoAll.push(info);
+                                if (!error) {
+                                    if (minCode) {
+                                        info.minLength = hackmudLength(minCode);
+                                        await writeFilePersist(resolve(hackmudDir, user, "scripts", `${name}.js`), minCode);
+                                    }
+                                    else
+                                        info.error = new Error("processed script was empty");
+                                }
+                                onPush === null || onPush === void 0 ? void 0 : onPush(info);
+                            });
+                        }
+                    }
+                }));
+            }
+        }
+        if (!users.length) {
+            users = (await readDirectory(hackmudDir, { withFileTypes: true }))
+                .filter(a => a.isFile() && extname(a.name) == ".key")
+                .map(a => basename(a.name, ".key"));
+        }
+        Promise.all(promises).then(() => {
+            const promises = [];
+            for (const file of files) {
+                if (file.isFile()) {
+                    const extension = extname(file.name);
+                    if (supportedExtensions.includes(extension)) {
+                        const name = basename(file.name, extension);
+                        if (!scripts.length || scripts.includes(name)) {
+                            promises.push(readFile(resolve(srcDir, file.name), { encoding: "utf-8" }).then(async (code) => {
+                                let error = null;
+                                const { script: minCode, srcLength } = await processScript(code).catch(reason => {
+                                    error = reason;
+                                    return {
+                                        script: "",
+                                        srcLength: 0
+                                    };
+                                });
+                                const info = {
+                                    file: file.name,
+                                    users: [],
+                                    minLength: 0,
+                                    error,
+                                    srcLength
+                                };
+                                infoAll.push(info);
+                                if (!error) {
+                                    if (minCode) {
+                                        info.minLength = hackmudLength(minCode);
+                                        const skip = skips.get(name) || [];
+                                        const promises = [];
+                                        for (const user of users) {
+                                            if (!skip.includes(user)) {
+                                                info.users.push(user);
+                                                promises.push(writeFilePersist(resolve(hackmudDir, user, "scripts", `${name}.js`), minCode));
+                                            }
+                                        }
+                                    }
+                                    else
+                                        info.error = new Error("processed script was empty");
+                                }
+                                if (onPush)
+                                    Promise.all(promises).then(() => onPush(info));
+                            }));
+                        }
+                    }
+                }
+            }
+            Promise.all(promises).then(() => resolve$1(infoAll));
+        });
+    });
+}
+/**
+ * Watches target file or folder for updates and builds and pushes updated file.
+ *
+ * @param srcDir path to folder containing source files
+ * @param hackmudDir path to hackmud directory
+ * @param users users to push to (pushes to all if empty)
+ * @param scripts scripts to push from (pushes from all if empty)
+ * @param onPush function that's called after each script has been built and written
+ */
+function watch(srcDir, hackmudDir, users, scripts, onPush, { genTypes } = {}) {
+    const watcher = watch$1("", { depth: 1, cwd: srcDir, awaitWriteFinish: { stabilityThreshold: 100 } }).on("change", async (path) => {
+        const extension = extname(path);
+        if (supportedExtensions.includes(extension)) {
+            const name = basename(path, extension);
+            const fileName = basename(path);
+            if (path == fileName) {
+                if (!scripts.length || scripts.includes(name)) {
+                    const sourceCode = await readFile(resolve(srcDir, path), { encoding: "utf-8" });
+                    const skips = new Map();
+                    const promisesSkips = [];
+                    for (const dir of await readDirectory(srcDir, { withFileTypes: true })) {
+                        if (!dir.isDirectory())
+                            continue;
+                        promisesSkips.push(readDirectory(resolve(srcDir, dir.name), { withFileTypes: true }).then(files => {
+                            for (const file of files) {
+                                if (!file.isFile())
+                                    continue;
+                                const fileExtension = extname(file.name);
+                                if (!supportedExtensions.includes(fileExtension))
+                                    continue;
+                                const name = basename(file.name, fileExtension);
+                                const skip = skips.get(name);
+                                if (skip)
+                                    skip.push(dir.name);
+                                else
+                                    skips.set(name, [dir.name]);
+                            }
+                        }));
+                    }
+                    await Promise.all(promisesSkips);
+                    let error = null;
+                    const { script, srcLength } = await processScript(sourceCode).catch(reason => {
+                        error = reason;
+                        return {
+                            script: "",
+                            srcLength: 0
+                        };
+                    });
+                    const info = {
+                        file: path,
+                        users: [],
+                        minLength: 0,
+                        error,
+                        srcLength
+                    };
+                    const promises = [];
+                    if (!error) {
+                        if (script) {
+                            const skip = skips.get(name) || [];
+                            info.minLength = hackmudLength(script);
+                            if (!users.length) {
+                                users = (await readDirectory(hackmudDir, { withFileTypes: true }))
+                                    .filter(a => a.isFile() && extname(a.name) == ".key")
+                                    .map(a => basename(a.name, ".key"));
+                            }
+                            for (const user of users) {
+                                if (skip.includes(user))
+                                    continue;
+                                info.users.push(user);
+                                promises.push(writeFilePersist(resolve(hackmudDir, user, "scripts", `${name}.js`), script));
+                            }
+                        }
+                        else
+                            info.error = new Error("processed script was empty");
+                    }
+                    if (onPush) {
+                        await Promise.all(promises);
+                        onPush(info);
+                    }
+                }
+            }
+            else {
+                const user = basename(resolve(path, ".."));
+                if ((!users.length || users.includes(user)) && (!scripts.length || scripts.includes(name))) {
+                    const sourceCode = await readFile(resolve(srcDir, path), { encoding: "utf-8" });
+                    let error = null;
+                    const { script, srcLength } = await processScript(sourceCode).catch(reason => {
+                        error = reason;
+                        return {
+                            script: "",
+                            srcLength: 0
+                        };
+                    });
+                    const info = {
+                        file: path,
+                        users: [user],
+                        minLength: 0,
+                        error,
+                        srcLength
+                    };
+                    if (!error) {
+                        if (script) {
+                            info.minLength = hackmudLength(script);
+                            await writeFilePersist(resolve(hackmudDir, user, "scripts", `${name}.js`), script);
+                        }
+                        else
+                            info.error = new Error("processed script was empty");
+                    }
+                    onPush === null || onPush === void 0 ? void 0 : onPush(info);
+                }
+            }
+        }
+    });
+    if (genTypes) {
+        generateTypings(srcDir, resolve(srcDir, genTypes), hackmudDir);
+        watcher.on("add", () => generateTypings(srcDir, resolve(srcDir, genTypes), hackmudDir));
+        watcher.on("unlink", () => generateTypings(srcDir, resolve(srcDir, genTypes), hackmudDir));
+    }
+}
+/**
+ * Copies script from hackmud to local source folder.
+ *
+ * @param sourceFolderPath path to folder containing source files
+ * @param hackmudPath path to hackmud directory
+ * @param script script to pull in `user.name` format
+ */
+async function pull(sourceFolderPath, hackmudPath, script) {
+    const [user, name] = script.split(".");
+    await copyFilePersist(resolve(hackmudPath, user, "scripts", `${name}.js`), resolve(sourceFolderPath, user, `${name}.js`));
+}
+async function syncMacros(hackmudPath) {
+    const files = await readDirectory(hackmudPath, { withFileTypes: true });
+    const macros = new Map();
+    const users = [];
+    for (const file of files) {
+        if (!file.isFile())
+            continue;
+        switch (extname(file.name)) {
+            case ".macros":
+                {
+                    const lines = (await readFile(resolve(hackmudPath, file.name), { encoding: "utf-8" })).split("\n");
+                    const date = (await getFileStatus(resolve(hackmudPath, file.name))).mtime;
+                    for (let i = 0; i < lines.length / 2 - 1; i++) {
+                        const macroName = lines[i * 2];
+                        const curMacro = macros.get(macroName);
+                        if (!curMacro || date > curMacro.date)
+                            macros.set(macroName, { date, macro: lines[i * 2 + 1] });
+                    }
+                }
+                break;
+            case ".key":
+                {
+                    users.push(basename(file.name, ".key"));
+                }
+                break;
+        }
+    }
+    let macroFile = "";
+    let macrosSynced = 0;
+    for (const [name, { macro }] of [...macros].sort(([a], [b]) => (a > b) - (a < b))) {
+        if (macro[0] != macro[0].toLowerCase())
+            continue;
+        macroFile += `${name}\n${macro}\n`;
+        macrosSynced++;
+    }
+    for (const user of users)
+        writeFile(resolve(hackmudPath, user + ".macros"), macroFile);
+    return { macrosSynced, usersSynced: users.length };
+}
+async function test(srcPath) {
+    const promises = [];
+    const errors = [];
+    for (const dirent of await readDirectory(srcPath, { withFileTypes: true })) {
+        if (dirent.isDirectory()) {
+            promises.push(readDirectory(resolve(srcPath, dirent.name), { withFileTypes: true }).then(files => {
+                const promises = [];
+                for (const file of files) {
+                    if (!file.isFile() || !supportedExtensions.includes(extname(file.name)))
+                        continue;
+                    promises.push(readFile(resolve(srcPath, dirent.name, file.name), { encoding: "utf-8" })
+                        .then(processScript)
+                        .then(({ warnings }) => errors.push(...warnings.map(({ message, line }) => ({
+                        file: `${dirent.name}/${file.name}`,
+                        message, line
+                    })))));
+                }
+                return Promise.all(promises);
+            }));
+        }
+        else if (dirent.isFile() && supportedExtensions.includes(extname(dirent.name))) {
+            promises.push(readFile(resolve(srcPath, dirent.name), { encoding: "utf-8" })
+                .then(processScript)
+                .then(({ warnings }) => errors.push(...warnings.map(({ message, line }) => ({
+                file: dirent.name,
+                message, line
+            })))));
+        }
+    }
+    await Promise.all(promises);
+    return errors;
+}
+async function generateTypings(srcDir, target, hackmudPath) {
+    const users = new Set();
+    if (hackmudPath) {
+        for (const dirent of await readDirectory(hackmudPath, { withFileTypes: true })) {
+            if (dirent.isFile() && extname(dirent.name) == ".key")
+                users.add(basename(dirent.name, ".key"));
+        }
+    }
+    const wildScripts = [];
+    const wildAnyScripts = [];
+    const allScripts = {};
+    const allAnyScripts = {};
+    for (const dirent of await readDirectory(srcDir, { withFileTypes: true })) {
+        if (dirent.isFile()) {
+            if (extname(dirent.name) == ".ts")
+                wildScripts.push(basename(dirent.name, ".ts"));
+            else if (extname(dirent.name) == ".js")
+                wildAnyScripts.push(basename(dirent.name, ".js"));
+        }
+        else if (dirent.isDirectory()) {
+            const scripts = allScripts[dirent.name] = [];
+            const anyScripts = allAnyScripts[dirent.name] = [];
+            users.add(dirent.name);
+            for (const file of await readDirectory(resolve(srcDir, dirent.name), { withFileTypes: true })) {
+                if (file.isFile()) {
+                    if (extname(file.name) == ".ts")
+                        scripts.push(basename(file.name, ".ts"));
+                    else if (extname(file.name) == ".js")
+                        anyScripts.push(basename(file.name, ".js"));
+                }
+            }
+        }
+    }
+    let o = "";
+    for (const script of wildScripts)
+        o += `import { script as $${script}$ } from "./src/${script}"\n`;
+    o += "\n";
+    for (const user in allScripts) {
+        const scripts = allScripts[user];
+        for (const script of scripts)
+            o += `import { script as $${user}$${script}$ } from "./src/${user}/${script}"\n`;
+    }
+    // TODO detect security level and generate apropriate code
+    // TODO accurate function signatures
+    // currently I lose the generic-ness of my functions when I wrap them
+    // just regexing isn't enough and it looks like I'm going to need to parse the files in TypeScript to extract the signature
+    o += `
+type ArrayRemoveFirst<A> = A extends [ infer FirstItem, ...infer Rest ] ? Rest : never
+
+type Subscript<T extends (...args: any) => any> =
+	(...args: ArrayRemoveFirst<Parameters<T>>) => ReturnType<T> | ScriptFailure
+
+type WildFullsec = Record<string, () => ScriptFailure> & {
+`;
+    for (const script of wildScripts)
+        o += `\t${script}: Subscript<typeof $${script}$>\n`;
+    for (const script of wildAnyScripts)
+        o += `\t${script}: (...args: any) => any\n`;
+    o += "}\n\ndeclare global {\n\tinterface PlayerFullsec {";
+    let lastWasMultiLine = true;
+    for (const user of users) {
+        const scripts = allScripts[user];
+        const anyScripts = allAnyScripts[user];
+        if ((scripts && scripts.length) || (anyScripts && anyScripts.length)) {
+            lastWasMultiLine = true;
+            o += `\n\t\t${user}: WildFullsec & {\n`;
+            for (const script of scripts)
+                o += `\t\t\t${script}: Subscript<typeof $${user}$${script}$>\n`;
+            for (const script of anyScripts)
+                o += `\t\t\t${script}: (...args: any) => any\n`;
+            o += "\t\t}";
+        }
+        else {
+            if (lastWasMultiLine) {
+                o += "\n";
+                lastWasMultiLine = false;
+            }
+            o += `\t\t${user}: WildFullsec`;
+        }
+        o += "\n";
+    }
+    o += "\t}\n}\n";
+    await writeFile(target, o);
+}
+/**
+ * Minifies a given script
+ *
+ * @param script JavaScript or TypeScript code
+ */
+async function processScript(script) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    let preScriptComments;
+    let autocomplete;
+    [, preScriptComments, script, autocomplete] = script.match(/((?:^\s*\/\/.*\n)*)\s*((?:.+?\/\/\s*(.+?)\s*$)?[^]*)/m);
+    if (!script)
+        throw new Error("script was empty");
+    if (script.match(/(?:SC|DB)\$/))
+        throw new Error("SC$ and DB$ are protected and cannot appear in a script");
+    let seclevel;
+    for (const line of preScriptComments.split("\n")) {
+        let [, autocompleteMatch, seclevelMatch] = (line.match(/^\s*\/\/\s*(?:@autocomplete\s*([^\s].*?)|@seclevel\s*([^\s].*?))\s*$/) || []);
+        if (autocompleteMatch)
+            autocomplete = autocompleteMatch;
+        else if (seclevelMatch) {
+            if (seclevelMatch.match(/^(?:fullsec|f|4|fs|full)$/i))
+                seclevel = 4;
+            else if (seclevelMatch.match(/^(?:highsec|h|3|hs|high)$/i))
+                seclevel = 3;
+            else if (seclevelMatch.match(/^(?:midsec|m|2|ms|mid)$/i))
+                seclevel = 2;
+            else if (seclevelMatch.match(/^(?:lowsec|l|1|ls|low)$/i))
+                seclevel = 1;
+            else if (seclevelMatch.match(/^(?:nullsec|n|0|ns|null)$/i))
+                seclevel = 0;
+        }
+    }
+    let detectedSeclevel;
+    if (script.match(/[#$][n0]s\.[a-z_][a-z_0-9]{0,24}\.[a-z_][a-z_0-9]{0,24}\(/))
+        detectedSeclevel = 0;
+    else if (script.match(/[#$][l1]s\.[a-z_][a-z_0-9]{0,24}\.[a-z_][a-z_0-9]{0,24}\(/))
+        detectedSeclevel = 1;
+    else if (script.match(/[#$][m2]s\.[a-z_][a-z_0-9]{0,24}\.[a-z_][a-z_0-9]{0,24}\(/))
+        detectedSeclevel = 2;
+    else if (script.match(/[#$][h3]s\.[a-z_][a-z_0-9]{0,24}\.[a-z_][a-z_0-9]{0,24}\(/))
+        detectedSeclevel = 3;
+    else if (script.match(/[#$][f4]s\.[a-z_][a-z_0-9]{0,24}\.[a-z_][a-z_0-9]{0,24}\(/))
+        detectedSeclevel = 4;
+    const seclevelNames = ["NULLSEC", "LOWSEC", "MIDSEC", "HIGHSEC", "FULLSEC"];
+    if (seclevel == undefined)
+        seclevel = (_a = seclevel !== null && seclevel !== void 0 ? seclevel : detectedSeclevel) !== null && _a !== void 0 ? _a : 0;
+    else if (detectedSeclevel != undefined && seclevel > detectedSeclevel)
+        throw new Error(`detected seclevel of ${seclevelNames[detectedSeclevel]} is lower than the provided seclevel of ${seclevelNames[seclevel]}`);
+    const semicolons = (_c = (_b = script.match(/;/g)) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0;
+    script = script
+        .replace(/#[fhmln43210]s\.scripts\.quine\(\)/g, JSON.stringify(script))
+        .replace(/[#$][fhmln43210]?s\.([a-z_][a-z_0-9]{0,24})\.([a-z_][a-z_0-9]{0,24})\(/g, "SC$$$1$$$2(")
+        .replace(/^function\s*\(/, "function script(")
+        .replace(/#D\(/g, "$D(")
+        .replace(/#FMCL/g, "$FMCL")
+        .replace(/#G/g, "$G")
+        .replace(/[#$]db\./g, "DB$");
+    // typescript compilation, this runs on regular javascript too to convert
+    // any post es2015 syntax into es2015 syntax
+    const { outputText, diagnostics = [] } = typescript.transpileModule(script, {
+        compilerOptions: { target: typescript.ScriptTarget.ES2015 },
+        reportDiagnostics: true
+    });
+    const warnings = diagnostics.map(({ messageText, start }) => ({
+        message: typeof messageText == "string" ? messageText : messageText.messageText,
+        line: positionToLineNumber(start, script)
+    }));
+    script = outputText.replace(/^export /, "");
+    const ast = parseScript(script);
+    for (const node of query(ast, "ClassBody > MethodDefinition[kind=constructor] > FunctionExpression > BlockStatement")) {
+        node.body.unshift({
+            type: "VariableDeclaration",
+            declarations: [
+                {
+                    type: "VariableDeclarator",
+                    id: {
+                        type: "Identifier",
+                        name: "__THIS__"
+                    }
+                }
+            ],
+            kind: "let"
+        });
+    }
+    for (const node of query(ast, "ClassBody > MethodDefinition[kind=constructor] > FunctionExpression > BlockStatement !CallExpression > Super")) {
+        const newNode = {
+            type: "AssignmentExpression",
+            operator: "=",
+            left: {
+                type: "Identifier",
+                name: "__THIS__"
+            },
+            right: { ...node }
+        };
+        Object.assign(clearObject(node), newNode);
+    }
+    for (const node of query(ast, "ClassBody > MethodDefinition > FunctionExpression > BlockStatement !ThisExpression")) {
+        const newNode = {
+            type: "Identifier",
+            name: "__THIS__"
+        };
+        Object.assign(clearObject(node), newNode);
+    }
+    for (const node of query(ast, "ClassBody > MethodDefinition[kind=method] > FunctionExpression > BlockStatement")) {
+        node.body.unshift({
+            type: "VariableDeclaration",
+            declarations: [{
+                    type: "VariableDeclarator",
+                    id: {
+                        type: "Identifier",
+                        name: "__THIS__"
+                    },
+                    init: {
+                        type: "CallExpression",
+                        callee: {
+                            type: "MemberExpression",
+                            computed: false,
+                            object: {
+                                type: "Super"
+                            },
+                            property: {
+                                type: "Identifier",
+                                name: "valueOf"
+                            },
+                            optional: false
+                        },
+                        arguments: [],
+                        optional: false
+                    }
+                }],
+            "kind": "let"
+        });
+    }
+    script = generate(ast);
+    // the typescript inserts semicolons where they weren't already so we take
+    // all semicolons out of the count and add the number of semicolons in the
+    // source to make things fair
+    let srcLength = hackmudLength(script.replace(/^function\s*\w+\(/, "function("))
+        - ((_e = (_d = script.match(/;/g)) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0)
+        + semicolons
+        + ((_g = (_f = script.match(/SC\$[a-zA-Z_][a-zA-Z0-9_]*\$[a-zA-Z_][a-zA-Z0-9_]*\(/g)) === null || _f === void 0 ? void 0 : _f.length) !== null && _g !== void 0 ? _g : 0)
+        + ((_j = (_h = script.match(/DB\$/g)) === null || _h === void 0 ? void 0 : _h.length) !== null && _j !== void 0 ? _j : 0);
+    // remove dead code (so we don't waste chracters quine cheating strings
+    // that aren't even used)
+    script = (await minify(script, {
+        ecma: 2015,
+        parse: { bare_returns: true },
+        compress: { booleans: false }
+    })).code || "";
+    let blockStatementIndex;
+    if (script.startsWith("function "))
+        blockStatementIndex = getFunctionBodyStart(script);
+    else {
+        script = `function script(context, args) {\n${script}\n}`;
+        blockStatementIndex = 31;
+        srcLength += 24;
+    }
+    let scriptBeforeJSONValueReplacement = (await minify(script, {
+        ecma: 2015,
+        compress: {
+            passes: Infinity,
+            unsafe: true,
+            unsafe_arrows: true,
+            unsafe_comps: true,
+            unsafe_symbols: true,
+            unsafe_methods: true,
+            unsafe_proto: true,
+            unsafe_regexp: true,
+            unsafe_undefined: true
+        },
+        format: { semicolons: false }
+    })).code || "";
+    {
+        const tokens = [...tokenizer(scriptBeforeJSONValueReplacement, { ecmaVersion: 2015 })].reverse().values();
+        for (const token of tokens) {
+            // we can't replace any tokens before the block statement or we'll break stuff
+            if (token.start < blockStatementIndex)
+                break;
+            switch (token.type) {
+                case tokTypes.name:
+                    {
+                        if (token.value != "prototype" && token.value != "__proto__")
+                            break;
+                        const tokenBefore = tokens.next().value;
+                        if (tokenBefore.type != tokTypes.dot)
+                            break;
+                        srcLength += 3;
+                        scriptBeforeJSONValueReplacement = stringSplice(scriptBeforeJSONValueReplacement, `["${token.value}"]`, tokenBefore.start, token.end);
+                    }
+                    break;
+                case tokTypes._const:
+                    {
+                        scriptBeforeJSONValueReplacement = stringSplice(scriptBeforeJSONValueReplacement, "let", token.start, token.end);
+                    }
+                    break;
+                case tokTypes._this:
+                    throw new Error('"this" keyword is not supported in hackmud');
+            }
+        }
+    }
+    const jsonValues = [];
+    let undefinedIsReferenced = false;
+    // we iterate through the tokens backwards so that substring replacements
+    // don't affect future replacements since a part of the string could be
+    // replaced with a string of a different length which messes up indexes
+    const tokens = [...tokenizer(script, { ecmaVersion: 2015 })].reverse().values();
+    let templateToRightOfPlaceholder = false;
+    for (const token of tokens) {
+        // we can't replace any tokens before the block statement or we'll break stuff
+        if (token.start < blockStatementIndex)
+            break;
+        switch (token.type) {
+            case tokTypes.backQuote:
+                {
+                    const templateToken = tokens.next().value;
+                    if (tokens.next().value.type == tokTypes.backQuote)
+                        throw new Error("tagged templates not supported yet");
+                    // no point in concatenating an empty string
+                    if (templateToken.value == "") {
+                        script = stringSplice(script, "))", templateToken.start - 1, token.end);
+                        break;
+                    }
+                    let jsonValueIndex = jsonValues.indexOf(templateToken.value);
+                    if (jsonValueIndex == -1)
+                        jsonValueIndex += jsonValues.push(templateToken.value);
+                    script = stringSplice(script, `)+_JSON_VALUE_${jsonValueIndex}_)`, templateToken.start - 1, token.end);
+                }
+                break;
+            case tokTypes.template:
+                {
+                    if (tokens.next().value.type == tokTypes.backQuote) {
+                        if (tokens.next().value.type == tokTypes.name)
+                            throw new Error("tagged templates not supported yet");
+                        // there *is* a point in concatenating an empty string at the
+                        // start because foo + bar is not the same thing as "" + foo + bar
+                        // ...but foo + "<template>" + bar *is* the same thing as "" + foo + "<template>" + bar
+                        // so we just need to check if there's a template to the right of the placeholder and skip that case
+                        if (token.value == "" && templateToRightOfPlaceholder) {
+                            templateToRightOfPlaceholder = false;
+                            script = stringSplice(script, "((", token.start - 1, token.end + 2);
+                            break;
+                        }
+                        templateToRightOfPlaceholder = false;
+                        let jsonValueIndex = jsonValues.indexOf(token.value);
+                        if (jsonValueIndex == -1)
+                            jsonValueIndex += jsonValues.push(token.value);
+                        script = stringSplice(script, `(_JSON_VALUE_${jsonValueIndex}_+(`, token.start - 1, token.end + 2);
+                        break;
+                    }
+                    // no point in concatenating an empty string
+                    if (token.value == "") {
+                        templateToRightOfPlaceholder = false;
+                        script = stringSplice(script, ")+(", token.start - 1, token.end + 2);
+                        break;
+                    }
+                    templateToRightOfPlaceholder = true;
+                    let jsonValueIndex = jsonValues.indexOf(token.value);
+                    if (jsonValueIndex == -1)
+                        jsonValueIndex += jsonValues.push(token.value);
+                    script = stringSplice(script, `)+_JSON_VALUE_${jsonValueIndex}_+(`, token.start - 1, token.end + 2);
+                }
+                break;
+            case tokTypes.name:
+                {
+                    if (token.value.length < 3)
+                        break;
+                    const tokenBefore = tokens.next().value;
+                    if (tokenBefore.type == tokTypes.dot) {
+                        let jsonValueIndex = jsonValues.indexOf(token.value);
+                        if (jsonValueIndex == -1)
+                            jsonValueIndex += jsonValues.push(token.value);
+                        script = stringSplice(script, `[_JSON_VALUE_${jsonValueIndex}_]`, tokenBefore.start, token.end);
+                        break;
+                    }
+                    if (token.value == "undefined") {
+                        script = stringSplice(script, " _UNDEFINED_ ", token.start, token.end);
+                        undefinedIsReferenced = true;
+                    }
+                }
+                break;
+            case tokTypes._null:
+                {
+                    let jsonValueIndex = jsonValues.indexOf(null);
+                    if (jsonValueIndex == -1)
+                        jsonValueIndex += jsonValues.push(null);
+                    script = stringSplice(script, ` _JSON_VALUE_${jsonValueIndex}_ `, token.start, token.end);
+                }
+                break;
+            case tokTypes._true:
+                {
+                    let jsonValueIndex = jsonValues.indexOf(true);
+                    if (jsonValueIndex == -1)
+                        jsonValueIndex += jsonValues.push(true);
+                    script = stringSplice(script, ` _JSON_VALUE_${jsonValueIndex}_ `, token.start, token.end);
+                }
+                break;
+            case tokTypes._false:
+                {
+                    let jsonValueIndex = jsonValues.indexOf(false);
+                    if (jsonValueIndex == -1)
+                        jsonValueIndex += jsonValues.push(false);
+                    script = stringSplice(script, ` _JSON_VALUE_${jsonValueIndex}_ `, token.start, token.end);
+                }
+                break;
+            case tokTypes.num:
+                {
+                    if (token.value == 0) {
+                        const tokenBefore = tokens.next().value;
+                        if (tokenBefore.type == tokTypes._void) {
+                            script = stringSplice(script, " _UNDEFINED_ ", tokenBefore.start, token.end);
+                            undefinedIsReferenced = true;
+                        }
+                        // may as well break here since we're gonna break anyway
+                        break;
+                    }
+                    if (token.value < 10)
+                        break;
+                    let jsonValueIndex = jsonValues.indexOf(token.value);
+                    if (jsonValueIndex == -1)
+                        jsonValueIndex += jsonValues.push(token.value);
+                    script = stringSplice(script, ` _JSON_VALUE_${jsonValueIndex}_ `, token.start, token.end);
+                }
+                break;
+            case tokTypes.string:
+                {
+                    if (token.value.includes("\u0000"))
+                        break;
+                    let jsonValueIndex = jsonValues.indexOf(token.value);
+                    if (jsonValueIndex == -1)
+                        jsonValueIndex += jsonValues.push(token.value);
+                    script = stringSplice(script, ` _JSON_VALUE_${jsonValueIndex}_ `, token.start, token.end);
+                }
+                break;
+            case tokTypes._const:
+                {
+                    script = stringSplice(script, "let", token.start, token.end);
+                }
+                break;
+            case tokTypes._this:
+                throw new Error('"this" keyword is not supported in hackmud');
+        }
+    }
+    let comment = null;
+    let hasComment = false;
+    if (jsonValues.length) {
+        hasComment = true;
+        if (jsonValues.length == 1) {
+            if (typeof jsonValues[0] == "string" && !jsonValues[0].includes("\n") && !jsonValues[0].includes("\t")) {
+                script = stringSplice(script, `\nlet _JSON_VALUE_0_ = SC$scripts$quine().split\`\t\`[_SPLIT_INDEX_]${undefinedIsReferenced ? ", _UNDEFINED_" : ""}\n`, blockStatementIndex + 1);
+                comment = jsonValues[0];
+            }
+            else {
+                script = stringSplice(script, `\nlet _JSON_VALUE_0_ = JSON.parse(SC$scripts$quine().split\`\t\`[_SPLIT_INDEX_])${undefinedIsReferenced ? ", _UNDEFINED_" : ""}\n`, blockStatementIndex + 1);
+                comment = JSON.stringify(jsonValues[0]);
+            }
+        }
+        else {
+            script = stringSplice(script, `\nlet [ ${jsonValues.map((_, i) => `_JSON_VALUE_${i}_`).join(", ")} ] = JSON.parse(SC$scripts$quine().split\`\t\`[_SPLIT_INDEX_])${undefinedIsReferenced ? ", _UNDEFINED_" : ""}\n`, blockStatementIndex + 1);
+            comment = JSON.stringify(jsonValues);
+        }
+    }
+    else
+        script = script.replace(/_UNDEFINED_/g, "void 0");
+    script = (await minify(script, {
+        ecma: 2015,
+        compress: {
+            passes: Infinity,
+            unsafe: true,
+            unsafe_arrows: true,
+            unsafe_comps: true,
+            unsafe_symbols: true,
+            unsafe_methods: true,
+            unsafe_proto: true,
+            unsafe_regexp: true,
+            unsafe_undefined: true
+        },
+        format: { semicolons: false }
+    })).code || "";
+    // this step affects the chracter count and can't be done after the count comparison
+    if (comment != null) {
+        script = stringSplice(script, `${autocomplete ? `//${autocomplete}\n` : ""}\n//\t${comment}\t\n`, getFunctionBodyStart(script) + 1);
+        for (const [i, part] of script.split("\t").entries()) {
+            if (part != comment)
+                continue;
+            script = script.replace("_SPLIT_INDEX_", (await minify(`$(${i})`, { ecma: 2015 })).code.match(/\$\((.+)\)/)[1]);
+            break;
+        }
+    }
+    // if the script has a comment, it's gonna contain `SC$scripts$quine()`
+    // which is gonna eventually compile to `#fs.scripts.quine()` which contains
+    // an extra character so we have to account for that
+    if (hackmudLength(scriptBeforeJSONValueReplacement) <= (hackmudLength(script) + Number(hasComment))) {
+        script = scriptBeforeJSONValueReplacement;
+        if (autocomplete)
+            script = stringSplice(script, `//${autocomplete}\n`, getFunctionBodyStart(script) + 1);
+    }
+    script = script
+        .replace(/^function\s*\w+\(/, "function(")
+        .replace(/SC\$([a-zA-Z_][a-zA-Z0-9_]*)\$([a-zA-Z_][a-zA-Z0-9_]*)\(/g, `#${"nlmhf"[seclevel]}s.$1.$2(`)
+        .replace(/\$D\(/g, "#D(")
+        .replace(/\$FMCL/g, "#FMCL")
+        .replace(/\$G/g, "#G")
+        .replace(/DB\$/g, "#db.");
+    return {
+        srcLength,
+        script,
+        warnings
+    };
+}
+function getFunctionBodyStart(code) {
+    const tokens = tokenizer(code, { ecmaVersion: 2015 });
+    tokens.getToken(); // function
+    tokens.getToken(); // name
+    tokens.getToken(); // (
+    let nests = 1;
+    while (nests) {
+        const token = tokens.getToken();
+        if (token.type == tokTypes.parenL)
+            nests++;
+        else if (token.type == tokTypes.parenR)
+            nests--;
+    }
+    return tokens.getToken().start; // {
+}
+
+export { DynamicMap as D, syncMacros as a, pull as b, watch as c, push as d, getFunctionBodyStart as e, generateTypings as g, hackmudLength as h, processScript as p, supportedExtensions as s, test as t, writeFilePersist as w };