hackmud-script-manager 0.13.0-a60a7a2 → 0.13.0-c461329

package/src/processScript/minify.ts

@@ -0,0 +1,529 @@
+import babelGenerator from "@babel/generator"
+import { parse } from "@babel/parser"
+import babelTraverse from "@babel/traverse"
+import t, { Expression } from "@babel/types"
+import { assert, countHackmudCharacters, spliceString } from "@samual/lib"
+import { tokenizer as tokenize, tokTypes as tokenTypes } from "acorn"
+import * as terser from "terser"
+
+const { default: generate } = babelGenerator as any as typeof import("@babel/generator")
+const { default: traverse } = babelTraverse as any as typeof import("@babel/traverse")
+
+type MinifyOptions = {
+	/** 11 a-z 0-9 characters */
+	uniqueID: string
+
+	/** whether to mangle function and class names (defaults to `false`) */
+	mangleNames: boolean
+}
+
+// TODO when there are more than 3 references to `$G`, place a `let _GLOBAL_0_ = $G` at the top and replace references with `_GLOBAL_0_`
+// TODO move autocomplete stuff outside this function
+// TODO allow not mangling class and function names
+
+/**
+ * @param code compiled code and/or hackmud compatible code
+ * @param autocomplete the comment inserted after the function signature
+ * @param options {@link MinifyOptions details}
+ */
+export async function minify(code: string, autocomplete: string, {
+	uniqueID = "00000000000",
+	mangleNames = false
+}: Partial<MinifyOptions> = {}) {
+	assert(uniqueID.match(/^\w{11}$/))
+
+	const jsonValues: any[] = []
+	let undefinedIsReferenced = false
+
+	// remove dead code (so we don't waste chracters quine cheating strings
+	// that aren't even used)
+	code = (await terser.minify(code, {
+		ecma: 2015,
+		parse: { bare_returns: true },
+		compress: {
+			passes: Infinity,
+			unsafe: true,
+			booleans: false,
+			sequences: false
+		},
+		keep_classnames: !mangleNames,
+		keep_fnames: !mangleNames
+	})).code || ""
+
+	let scriptBeforeJSONValueReplacement
+
+	{
+		// BUG when this script is used, the source char count is off
+
+		const file = await parse(code)
+
+		traverse(file, {
+			MemberExpression({ node: memberExpression }) {
+				if (memberExpression.computed)
+					return
+
+				assert(memberExpression.property.type == "Identifier")
+
+				if (memberExpression.property.name == "prototype") {
+					memberExpression.computed = true
+					memberExpression.property = t.identifier(`_PROTOTYPE_PROPERTY_${uniqueID}_`)
+				} else if (memberExpression.property.name == "__proto__") {
+					memberExpression.computed = true
+					memberExpression.property = t.identifier(`_PROTO_PROPERTY_${uniqueID}_`)
+				}
+			}
+		})
+
+		scriptBeforeJSONValueReplacement = (await terser.minify(generate(file!).code, {
+			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,
+				sequences: false
+			},
+			format: { semicolons: false },
+			keep_classnames: !mangleNames,
+			keep_fnames: !mangleNames
+		})).code!
+			.replace(new RegExp(`_PROTOTYPE_PROPERTY_${uniqueID}_`, "g"), `"prototype"`)
+			.replace(new RegExp(`_PROTO_PROPERTY_${uniqueID}_`, "g"), `"__proto__"`)
+	}
+
+	let comment: string | null = null
+	let hasComment = false
+
+	{
+		const file = await parse(code)
+		const promises: Promise<any>[] = []
+
+		traverse(file, {
+			FunctionDeclaration(path) {
+				path.traverse({
+					Function(path) {
+						if (path.parent.type != "CallExpression" && path.parentKey != "callee")
+							path.skip()
+					},
+
+					Loop(path) {
+						path.skip()
+					},
+
+					ObjectExpression(path) {
+						const o: Record<string, unknown> = {}
+
+						if (parseObjectExpression(path.node, o))
+							path.replaceWith(t.identifier(`_JSON_VALUE_${jsonValues.push(o) - 1}_${uniqueID}_`))
+					},
+
+					ArrayExpression(path) {
+						const o: unknown[] = []
+
+						if (parseArrayExpression(path.node, o))
+							path.replaceWith(t.identifier(`_JSON_VALUE_${jsonValues.push(o) - 1}_${uniqueID}_`))
+					}
+				})
+
+				path.traverse({
+					TemplateLiteral(path) {
+						const templateLiteral = path.node
+						let replacement: babel.Node = t.stringLiteral(templateLiteral.quasis[0].value.cooked!)
+
+						for (let i = 0; i < templateLiteral.expressions.length; i++) {
+							const expression = templateLiteral.expressions[i] as Expression
+							const templateElement = templateLiteral.quasis[i + 1]
+
+							replacement = t.binaryExpression(
+								"+",
+								replacement,
+								expression
+							)
+
+							if (!templateElement.value.cooked)
+								continue
+
+							replacement = t.binaryExpression(
+								"+",
+								replacement,
+								t.stringLiteral(templateElement.value.cooked!)
+							)
+						}
+
+						path.replaceWith(replacement)
+					},
+
+					MemberExpression({ node: memberExpression }) {
+						if (memberExpression.computed)
+							return
+
+						assert(memberExpression.property.type == "Identifier")
+
+						if (memberExpression.property.name.length < 3)
+							return
+
+						memberExpression.computed = true
+						memberExpression.property = t.stringLiteral(memberExpression.property.name)
+					},
+
+					UnaryExpression(path) {
+						if (path.node.operator == "void") {
+							if (path.node.argument.type == "NumericLiteral" && !path.node.argument.value) {
+								path.replaceWith(t.identifier(`_UNDEFINED_${uniqueID}_`))
+								undefinedIsReferenced = true
+							}
+						} else if (path.node.operator == "-" && path.node.argument.type == "NumericLiteral") {
+							const value = -path.node.argument.value
+
+							promises.push((async () => {
+								if ((await minifyNumber(value)).length <= 3)
+									return
+
+								if (path.parentKey == "key" && path.parent.type == "ObjectProperty")
+									path.parent.computed = true
+
+								let jsonValueIndex = jsonValues.indexOf(value)
+
+								if (jsonValueIndex == -1)
+									jsonValueIndex += jsonValues.push(value)
+
+								path.replaceWith(t.identifier(`_JSON_VALUE_${jsonValueIndex}_${uniqueID}_`))
+							})())
+
+							path.skip()
+						}
+					},
+
+					NullLiteral(path) {
+						let jsonValueIndex = jsonValues.indexOf(null)
+
+						if (jsonValueIndex == -1)
+							jsonValueIndex += jsonValues.push(null)
+
+						path.replaceWith(t.identifier(`_JSON_VALUE_${jsonValueIndex}_${uniqueID}_`))
+					},
+
+					BooleanLiteral(path) {
+						let jsonValueIndex = jsonValues.indexOf(path.node.value)
+
+						if (jsonValueIndex == -1)
+							jsonValueIndex += jsonValues.push(path.node.value)
+
+						path.replaceWith(t.identifier(`_JSON_VALUE_${jsonValueIndex}_${uniqueID}_`))
+					},
+
+					NumericLiteral(path) {
+						promises.push((async () => {
+							if ((await minifyNumber(path.node.value)).length <= 3)
+								return
+
+							if (path.parentKey == "key" && path.parent.type == "ObjectProperty")
+								path.parent.computed = true
+
+							let jsonValueIndex = jsonValues.indexOf(path.node.value)
+
+							if (jsonValueIndex == -1)
+								jsonValueIndex += jsonValues.push(path.node.value)
+
+							path.replaceWith(t.identifier(`_JSON_VALUE_${jsonValueIndex}_${uniqueID}_`))
+						})())
+					},
+
+					StringLiteral(path) {
+						if (path.node.value.includes("\u0000") || path.toString().length < 4)
+							return
+
+						if (path.parentKey == "key" && path.parent.type == "ObjectProperty")
+							path.parent.computed = true
+
+						let jsonValueIndex = jsonValues.indexOf(path.node.value)
+
+						if (jsonValueIndex == -1)
+							jsonValueIndex += jsonValues.push(path.node.value)
+
+						path.replaceWith(t.identifier(`_JSON_VALUE_${jsonValueIndex}_${uniqueID}_`))
+					},
+
+					ObjectProperty({ node }) {
+						if (node.computed || node.key.type != "Identifier" || node.key.name.length < 4)
+							return
+
+						let jsonValueIndex = jsonValues.indexOf(node.key.name)
+
+						if (jsonValueIndex == -1)
+							jsonValueIndex += jsonValues.push(node.key.name)
+
+						node.computed = true
+						node.key = t.identifier(`_JSON_VALUE_${jsonValueIndex}_${uniqueID}_`)
+					}
+				})
+
+				path.skip()
+			}
+		})
+
+		await Promise.all(promises)
+
+		const [ functionDeclaration ] = file.program.body
+
+		assert(functionDeclaration.type == "FunctionDeclaration")
+
+		if (jsonValues.length) {
+			hasComment = true
+
+			if (jsonValues.length == 1) {
+				if (typeof jsonValues[0] == "string" && !jsonValues[0].includes("\n") && !jsonValues[0].includes("\t")) {
+					const variableDeclaration = t.variableDeclaration(
+						"let",
+						[
+							t.variableDeclarator(
+								t.identifier(`_JSON_VALUE_0_${uniqueID}_`),
+								t.memberExpression(
+									t.taggedTemplateExpression(
+										t.memberExpression(
+											t.callExpression(t.identifier(`$${uniqueID}$SUBSCRIPT$scripts$quine`), []),
+											t.identifier("split")
+										),
+										t.templateLiteral([ t.templateElement({ raw: "\t", cooked: "\t" }, true) ], [])
+									),
+									t.identifier(`$${uniqueID}$SPLIT_INDEX`),
+									true
+								)
+							)
+						]
+					)
+
+					if (undefinedIsReferenced)
+						variableDeclaration.declarations.push(t.variableDeclarator(t.identifier(`_UNDEFINED_${uniqueID}_`)))
+
+					functionDeclaration.body.body.unshift(variableDeclaration)
+
+					comment = jsonValues[0]
+				} else {
+					const variableDeclaration = t.variableDeclaration(
+						"let",
+						[
+							t.variableDeclarator(
+								t.identifier(`_JSON_VALUE_0_${uniqueID}_`),
+								t.callExpression(
+									t.memberExpression(
+										t.identifier("JSON"),
+										t.identifier("parse")
+									),
+									[
+										t.memberExpression(
+											t.taggedTemplateExpression(
+												t.memberExpression(
+													t.callExpression(t.identifier(`$${uniqueID}$SUBSCRIPT$scripts$quine`), []),
+													t.identifier("split")
+												),
+												t.templateLiteral([ t.templateElement({ raw: "\t", cooked: "\t" }, true) ], [])
+											),
+											t.identifier(`$${uniqueID}$SPLIT_INDEX`),
+											true
+										)
+									]
+								)
+							)
+						]
+					)
+
+					if (undefinedIsReferenced)
+						variableDeclaration.declarations.push(t.variableDeclarator(t.identifier(`_UNDEFINED_${uniqueID}_`)))
+
+					functionDeclaration.body.body.unshift(variableDeclaration)
+
+					comment = JSON.stringify(jsonValues[0])
+				}
+			} else {
+				const variableDeclaration = t.variableDeclaration(
+					"let",
+					[
+						t.variableDeclarator(
+							t.arrayPattern(jsonValues.map((_, i) => t.identifier(`_JSON_VALUE_${i}_${uniqueID}_`))),
+							t.callExpression(
+								t.memberExpression(
+									t.identifier("JSON"),
+									t.identifier("parse")
+								),
+								[
+									t.memberExpression(
+										t.taggedTemplateExpression(
+											t.memberExpression(
+												t.callExpression(t.identifier(`$${uniqueID}$SUBSCRIPT$scripts$quine`), []),
+												t.identifier("split")
+											),
+											t.templateLiteral([ t.templateElement({ raw: "\t", cooked: "\t" }, true) ], [])
+										),
+										t.identifier(`$${uniqueID}$SPLIT_INDEX`),
+										true
+									)
+								]
+							)
+						)
+					]
+				)
+
+				if (undefinedIsReferenced)
+					variableDeclaration.declarations.push(t.variableDeclarator(t.identifier(`_UNDEFINED_${uniqueID}_`)))
+
+				functionDeclaration.body.body.unshift(variableDeclaration)
+
+				comment = JSON.stringify(jsonValues)
+			}
+		} else if (undefinedIsReferenced) {
+			functionDeclaration.body.body.unshift(
+				t.variableDeclaration(
+					"let",
+					[ t.variableDeclarator(t.identifier(`_UNDEFINED_${uniqueID}_`)) ]
+				)
+			)
+		}
+
+		code = generate(file!).code
+	}
+
+	code = (await terser.minify(code, {
+		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,
+			sequences: false
+		},
+		format: { semicolons: false },
+		keep_classnames: !mangleNames,
+		keep_fnames: !mangleNames
+	})).code || ""
+
+
+	// this step affects the character count and can't be done after the count comparison
+	if (comment != null) {
+		code = spliceString(code, `${autocomplete ? `//${autocomplete}\n` : ""}\n//\t${comment}\t\n`, getFunctionBodyStart(code) + 1)
+
+		for (const [ i, part ] of code.split("\t").entries()) {
+			if (part == comment) {
+				code = code.replace(`$${uniqueID}$SPLIT_INDEX`, await minifyNumber(i))
+				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 (countHackmudCharacters(scriptBeforeJSONValueReplacement) <= (countHackmudCharacters(code) + Number(hasComment))) {
+		code = scriptBeforeJSONValueReplacement
+
+		if (autocomplete)
+			code = spliceString(code, `//${autocomplete}\n`, getFunctionBodyStart(code) + 1)
+	}
+
+	return code
+}
+
+export default minify
+
+function parseObjectExpression(node: babel.types.ObjectExpression, o: Record<string, unknown>) {
+	if (!node.properties.length)
+		return false
+
+	for (const property of node.properties) {
+		if (property.type != "ObjectProperty" || property.computed)
+			return false
+
+		assert(property.key.type == "Identifier" || property.key.type == "NumericLiteral" || property.key.type == "StringLiteral")
+
+		if (property.value.type == "ArrayExpression") {
+			const childArray: unknown[] = []
+
+			if (parseArrayExpression(property.value, childArray))
+				o[property.key.type == "Identifier" ? property.key.name : property.key.value] = childArray
+			else
+				return false
+		} else if (property.value.type == "ObjectExpression") {
+			const childObject: Record<string, unknown> = {}
+
+			if (parseObjectExpression(property.value, childObject))
+				o[property.key.type == "Identifier" ? property.key.name : property.key.value] = childObject
+			else
+				return false
+		} else if (property.value.type == "NullLiteral")
+			o[property.key.type == "Identifier" ? property.key.name : property.key.value] = null
+		else if (property.value.type == "BooleanLiteral" || property.value.type == "NumericLiteral" || property.value.type == "StringLiteral")
+			o[property.key.type == "Identifier" ? property.key.name : property.key.value] = property.value.value
+		else
+			return false
+	}
+
+	return true
+}
+
+function parseArrayExpression(node: babel.types.ArrayExpression, o: unknown[]) {
+	if (!node.elements.length)
+		return false
+
+	for (const element of node.elements) {
+		if (!element)
+			return false
+
+		if (element.type == "ArrayExpression") {
+			const childArray: unknown[] = []
+
+			if (parseArrayExpression(element, childArray))
+				childArray.push(childArray)
+			else
+				return false
+		} else if (element.type == "ObjectExpression") {
+			const childObject: Record<string, unknown> = {}
+
+			if (parseObjectExpression(element, childObject))
+				o.push(childObject)
+			else
+				return false
+		} else if (element.type == "NullLiteral")
+			o.push(null)
+		else if (element.type == "BooleanLiteral" || element.type == "NumericLiteral" || element.type == "StringLiteral")
+			o.push(element.value)
+		else
+			return false
+	}
+
+	return true
+}
+
+async function minifyNumber(number: number) {
+	return (await terser.minify(`$(${number})`, { ecma: 2015 })).code!.match(/\$\((.+)\)/)![1]
+}
+
+function getFunctionBodyStart(code: string) {
+	const tokens = tokenize(code, { ecmaVersion: 2015 })
+
+	tokens.getToken() // function
+	tokens.getToken() // name
+	tokens.getToken() // (
+
+	let nests = 1
+
+	while (nests) {
+		const token = tokens.getToken()
+
+		if (token.type == tokenTypes.parenL)
+			nests++
+		else if (token.type == tokenTypes.parenR)
+			nests--
+	}
+
+	return tokens.getToken().start // {
+}

package/src/processScript/postprocess.ts

@@ -0,0 +1,38 @@
+import { findMatches, spliceString } from "@samual/lib"
+
+export function postprocess(code: string, seclevel: number, uniqueID: string) {
+	code = code.replace(/^function\s*\w+\(/, "function(")
+
+	for (const { index, match } of [ ...findMatches(new RegExp(`\\$${uniqueID}\\$[\\w$]+`, "g"), code) ].reverse()) {
+		const [ type, ...args ] = match.slice(13).split("$")
+
+		switch (type) {
+			case "SUBSCRIPT": {
+				code = spliceString(code, `#${"nlmhf"[seclevel]}s.${args[0]}.${args[1]}`, index, match.length)
+			} break
+
+			case "DEBUG": {
+				code = spliceString(code, `#D`, index, match.length)
+			} break
+
+			case "FMCL": {
+				code = spliceString(code, `#FMCL`, index, match.length)
+			} break
+
+			case "GLOBAL": {
+				code = spliceString(code, `#G`, index, match.length)
+			} break
+
+			case "DB": {
+				code = spliceString(code, `#db.${args[0]}`, index, match.length)
+			} break
+
+			default:
+				throw new Error(`unknown preprocessor directive type "${type}"`)
+		}
+	}
+
+	return code
+}
+
+export default postprocess

package/src/processScript/preprocess.ts

@@ -0,0 +1,146 @@
+import { parse } from "@babel/parser"
+import { assert, spliceString } from "@samual/lib"
+
+export type PreprocessOptions = {
+	/** 11 a-z 0-9 characters */
+	uniqueID: string
+}
+
+/**
+ * @param code source code to be preprocessed
+ * @param options {@link PreprocessOptions details}
+ */
+export function preprocess(code: string, { uniqueID = "00000000000" }: Partial<PreprocessOptions> = {}) {
+	assert(uniqueID.match(/^\w{11}$/))
+
+	let preScriptComments: string | undefined
+	let autocomplete: string | undefined
+
+	[ , preScriptComments, code, autocomplete ] = code.match(/((?:^\s*\/\/.*\n)*)\s*((?:.+?\/\/\s*(.+?)\s*$)?[^]*)/m)!
+
+	if (code.match(/(?:SC|DB)\$/))
+		throw new Error("SC$ and DB$ are protected and cannot appear in a script")
+
+	let seclevel: number | undefined
+
+	for (const line of preScriptComments.split("\n")) {
+		let [ , autocompleteMatch, seclevelMatch ] = (line.match(/^\s*\/\/\s*(?:@autocomplete\s*([^\s].*?)|@seclevel\s*([^\s].*?))\s*$/) || []) as [ never, string | undefined, string | undefined ]
+
+		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
+		}
+	}
+
+	// TODO move this over to using the new system for finding subscripts
+
+	let detectedSeclevel = 4
+
+	if (code.match(/[#$][n0]s\.[a-z_][a-z_0-9]{0,24}\.[a-z_][a-z_0-9]{0,24}\(/))
+		detectedSeclevel = 0
+	else if (code.match(/[#$][l1]s\.[a-z_][a-z_0-9]{0,24}\.[a-z_][a-z_0-9]{0,24}\(/))
+		detectedSeclevel = 1
+	else if (code.match(/[#$][m2]s\.[a-z_][a-z_0-9]{0,24}\.[a-z_][a-z_0-9]{0,24}\(/))
+		detectedSeclevel = 2
+	else if (code.match(/[#$][h3]s\.[a-z_][a-z_0-9]{0,24}\.[a-z_][a-z_0-9]{0,24}\(/))
+		detectedSeclevel = 3
+
+	const seclevelNames = [ "NULLSEC", "LOWSEC", "MIDSEC", "HIGHSEC", "FULLSEC" ]
+
+	if (seclevel == undefined)
+		seclevel = detectedSeclevel
+	else if (detectedSeclevel < seclevel)
+		// TODO replace with a warning and build script anyway
+		throw new Error(`detected seclevel ${seclevelNames[detectedSeclevel]} is lower than stated seclevel ${seclevelNames[seclevel]}`)
+
+	const semicolons = code.match(/;/g)?.length ?? 0
+	const sourceCode = code
+
+	code = code.replace(/^function\s*\(/, "export default function (")
+
+	// TODO I'm not actually doing anything with this yet
+	let file
+
+	while (true) {
+		let error
+
+		try {
+			file = parse(code, {
+				plugins: [
+					"typescript",
+					[ "decorators", { decoratorsBeforeExport: true } ],
+					"doExpressions",
+					"functionBind",
+					"functionSent",
+					"partialApplication",
+					[ "pipelineOperator", { proposal: "hack", topicToken: "%" } ],
+					"throwExpressions",
+					[ "recordAndTuple", { syntaxType: "hash" } ],
+					"classProperties",
+					"classPrivateProperties",
+					"classPrivateMethods",
+					"logicalAssignment",
+					"numericSeparator",
+					"nullishCoalescingOperator",
+					"optionalChaining",
+					"optionalCatchBinding",
+					"objectRestSpread"
+				],
+				sourceType: "module"
+			})
+			break
+		} catch (error_) {
+			assert(error_ instanceof SyntaxError)
+
+			error = error_ as SyntaxError & {
+				pos: number
+				code: string
+				reasonCode: String
+			}
+		}
+
+		if (error.code != "BABEL_PARSER_SYNTAX_ERROR" || error.reasonCode != "PrivateInExpectedIn") {
+			console.log(code.slice(error.pos).match(/.+/)?.[0])
+			throw error
+		}
+
+		const codeSlice = code.slice(error.pos)
+
+		let match
+
+		// TODO detect typos and warn e.g. we throw on `#db.ObjectID(` and it makes it look like we don't support it
+		if (match = codeSlice.match(/^#[fhmln43210]s\.scripts\.quine\(\)/))
+			code = spliceString(code, JSON.stringify(sourceCode), error.pos, match[0].length)
+		else if (match = codeSlice.match(/^#[fhmln43210]?s\.([a-z_][a-z_0-9]{0,24})\.([a-z_][a-z_0-9]{0,24})\(/))
+			code = spliceString(code, `$${uniqueID}$SUBSCRIPT$${match[1]}$${match[2]}(`, error.pos, match[0].length)
+		else if (match = codeSlice.match(/^#D\(/))
+			code = spliceString(code, `$${uniqueID}$DEBUG(`, error.pos, match[0].length)
+		else if (match = codeSlice.match(/^#FMCL/))
+			code = spliceString(code, `$${uniqueID}$FMCL`, error.pos, match[0].length)
+		else if (match = codeSlice.match(/^#G/))
+			code = spliceString(code, `$${uniqueID}$GLOBAL`, error.pos, match[0].length)
+		else if (match = codeSlice.match(/^#db\.(i|r|f|u|u1|us|ObjectId)\(/))
+			code = spliceString(code, `$${uniqueID}$DB$${match[1]}(`, error.pos, match[0].length)
+		else
+			throw error
+	}
+
+	return {
+		semicolons,
+		autocomplete,
+		seclevel,
+		code
+	}
+}
+
+export default preprocess