// ==UserScript==
// @name Plugins in Old Taiko Web
// @namespace plugins-in-old-taiko-web
// @icon https://gitlab.com/uploads/-/system/project/avatar/36006078/taiko-web-plugins.png?width=64
// @version 2023.1.20
// @author Katie Frogs
// @description Implements the plugin interface in older versions of taiko-web
// @homepage https://github.com/KatieFrogs/taiko-web-plugins
// @supportURL https://github.com/KatieFrogs/taiko-web-plugins/issues
// @match https://*.lv5.ac/
// @grant none
// @run-at document-start
// ==/UserScript==

var pluginsTranslations = {
	title: {
		ja: "プラグイン",
		en: "Plugins",
		ko: "플러그인"
	},
	unloadAll: {
		ja: "すべて無効にする",
		en: "Unload All",
		ko: "모두 해제"
	},
	warning: {
		ja: "%sを読み込もうとしています。プラグインは信頼できる場合のみ読み込むようにしてください。続行しますか？",
		en: "You are about to load %s. Plugins should only be loaded if you trust them. Continue?",
		ko: "%s을 로드하려고 합니다. 신뢰할 수 있는 플러그인만 로드하시기 바랍니다. 계속할까요?"
	},
	plugin: {
		ja: {
			one: "%sつのプラグイン",
			other: "%sつのプラグイン"
		},
		en: {
			one: "%s plugin",
			other: "%s plugins"
		},
		ko: {
			one: "%s 플러그인",
			other: "%s 플러그인들"
		}
	},
	author: {
		ja: "作成者：%s",
		en: "By %s",
		ko: "제작자:%s"
	},
	version: {
		ja: "Ver. %s",
		en: "Version %s",
		ko: "버전 %s"
	},
	browse: {
		ja: "参照する…",
		en: "Browse...",
		cn: "浏览…",
		tw: "開啟檔案…",
		ko: "찾아보기…"
	},
	noPlugins: {
		ja: null,
		en: "No .taikoweb.js plugin files have been found in the provided file list.",
		ko: "주어진 파일 리스트에서 .taikoweb.js 플러그인 파일들을 발견할 수 없습니다."
	}
}
var pluginsStrings = {}
var languageList = ["ja", "en", "cn", "tw", "ko"]
function separateStrings(){
	for(var j in languageList){
		var lang = languageList[j]
		pluginsStrings[lang] = {
			id: lang
		}
		var str = pluginsStrings[lang]
		var translateObj = function(obj, name, str){
			if("en" in obj){
				for(var i in obj){
					str[name] = obj[lang] || obj.en
				}
			}else if(obj){
				str[name] = {}
				for(var i in obj){
					translateObj(obj[i], i, str[name])
				}
			}
		}
		for(var i in pluginsTranslations){
			translateObj(pluginsTranslations[i], i, str)
		}
	}
}
separateStrings()
function pluginsStr(lang){
	if(!lang){
		lang = strings.id
	}
	return pluginsStrings[lang] || allStrings[lang].plugins || pluginsStrings.en
}

class Plugins{
	constructor(...args){
		this.init(...args)
	}
	init(){
		this.allPlugins = []
		this.pluginMap = {}
		this.hashes = []
		this.startOrder = []
	}
	add(script, options){
		options = options || {}
		var hash = md5.base64(script.toString())
		var isUrl = typeof script === "string" && !options.raw
		if(isUrl){
			hash = "url " + hash
		}else if(typeof script !== "string"){
			hash = "class " + hash
		}
		var name = options.name
		if(!name && isUrl){
			name = script
			var index = name.lastIndexOf("?")
			if(index !== -1){
				name = name.slice(0, index)
			}
			var index = name.lastIndexOf("/")
			if(index !== -1){
				name = name.slice(index + 1)
			}
			if(name.endsWith(".taikoweb.js")){
				name = name.slice(0, -".taikoweb.js".length)
			}else if(name.endsWith(".js")){
				name = name.slice(0, -".js".length)
			}
		}
		name = name || "plugin"
		if(this.hashes.indexOf(hash) !== -1){
			console.warn("Skip adding an already addded plugin: " + name)
			return
		}
		var baseName = name
		for(var i = 2; name in this.pluginMap; i++){
			name = baseName + i.toString()
		}
		var plugin = new PluginLoader(script, name, hash, options.raw)
		plugin.hide = !!options.hide
		this.allPlugins.push({
			name: name,
			plugin: plugin
		})
		this.pluginMap[name] = plugin
		this.hashes.push(hash)
		return plugin
	}
	remove(name){
		if(name in this.pluginMap){
			var hash = this.pluginMap[name].hash
			if(hash){
				var index = this.hashes.indexOf(hash)
				if(index !== -1){
					this.hashes.splice(index, 1)
				}
			}
			this.unload(name)
		}
		var index = this.allPlugins.findIndex(obj => obj.name === name)
		if(index !== -1){
			this.allPlugins.splice(index, 1)
		}
		var index = this.startOrder.indexOf(name)
		if(index !== -1){
			this.startOrder.splice(index, 1)
		}
		delete this.pluginMap[name]
	}
	load(name){
		return this.pluginMap[name].load()
	}
	loadAll(){
		for(var i = 0; i < this.allPlugins.length; i++){
			this.allPlugins[i].plugin.load()
		}
	}
	start(name){
		return this.pluginMap[name].start()
	}
	startAll(){
		for(var i = 0; i < this.allPlugins.length; i++){
			this.allPlugins[i].plugin.start()
		}
	}
	stop(name){
		return this.pluginMap[name].stop()
	}
	stopAll(){
		for(var i = this.startOrder.length; i--;){
			this.pluginMap[this.startOrder[i]].stop()
		}
	}
	unload(name){
		return this.pluginMap[name].unload()
	}
	unloadAll(){
		for(var i = this.startOrder.length; i--;){
			this.pluginMap[this.startOrder[i]].unload()
		}
		for(var i = this.allPlugins.length; i--;){
			this.allPlugins[i].plugin.unload()
		}
	}
	unloadImported(){
		for(var i = this.startOrder.length; i--;){
			var plugin = this.pluginMap[this.startOrder[i]]
			if(plugin.imported){
				plugin.unload()
			}
		}
		for(var i = this.allPlugins.length; i--;){
			var obj = this.allPlugins[i]
			if(obj.plugin.imported){
				obj.plugin.unload()
			}
		}
	}

	strFromFunc(func){
		var output = func.toString()
		return output.slice(output.indexOf("{") + 1, output.lastIndexOf("}"))
	}
	argsFromFunc(func){
		var output = func.toString()
		output = output.slice(0, output.indexOf("{"))
		output = output.slice(output.indexOf("(") + 1, output.lastIndexOf(")"))
		return output.split(",").map(str => str.trim()).filter(Boolean)
	}
	insertBefore(input, insertedText, searchString){
		var index = input.indexOf(searchString)
		if(index === -1){
			throw new Error("searchString not found: " + searchString)
		}
		return input.slice(0, index) + insertedText + input.slice(index)
	}
	insertAfter(input, searchString, insertedText){
		var index = input.indexOf(searchString)
		if(index === -1){
			throw new Error("searchString not found: " + searchString)
		}
		var length = searchString.length
		return input.slice(0, index + length) + insertedText + input.slice(index + length)
	}
	strReplace(input, searchString, insertedText, repeat=1){
		var position = 0
		for(var i = 0; i < repeat; i++){
			var index = input.indexOf(searchString, position)
			if(index === -1){
				if(repeat === Infinity){
					break
				}else{
					throw new Error("searchString not found: " + searchString)
				}
			}
			input = input.slice(0, index) + insertedText + input.slice(index + searchString.length)
			position = index + insertedText.length
		}
		return input
	}
	isObject(input){
		return input && typeof input === "object" && input.constructor === Object
	}
	deepMerge(target, ...sources){
		sources.forEach(source => {
			if(this.isObject(target) && this.isObject(source)){
				for(var i in source){
					if(this.isObject(source[i])){
						if(!target[i]){
							target[i] = {}
						}
						this.deepMerge(target[i], source[i])
					}else if(source[i]){
						target[i] = source[i]
					}
				}
			}
		})
		return target
	}
	arrayDel(array, item){
		var index = array.indexOf(item)
		if(index !== -1){
			array.splice(index, 1)
			return true
		}
		return false
	}

	hasSettings(){
		for(var i = 0; i < this.allPlugins.length; i++){
			var plugin = this.allPlugins[i].plugin
			if(plugin.loaded && (!plugin.hide || plugin.settings())){
				return true
			}
		}
		return false
	}
	getSettings(){
		var items = []
		for(var i = 0; i < this.allPlugins.length; i++){
			var obj = this.allPlugins[i]
			let plugin = obj.plugin
			if(!plugin.loaded){
				continue
			}
			if(!plugin.hide){
				let description
				let description_lang
				var module = plugin.module
				if(module){
					description = [
						module.description,
						module.author ? pluginsStr().author.replace("%s", module.author) : null,
						module.version ? pluginsStr().version.replace("%s", module.version) : null
					].filter(Boolean).join("\n")
					description_lang = {}
					languageList.forEach(lang => {
						description_lang[lang] = [
							this.getLocalTitle(module.description, module.description_lang, lang),
							module.author ? pluginsStr(lang).author.replace("%s", module.author) : null,
							module.version ? pluginsStr(lang).version.replace("%s", module.version) : null
						].filter(Boolean).join("\n")
					})
				}
				var name = module && module.name || obj.name
				var name_lang = module && module.name_lang
				items.push({
					name: name,
					name_lang: name_lang,
					description: description,
					description_lang: description_lang,
					type: "toggle",
					default: true,
					getItem: () => plugin.started,
					setItem: value => {
						if(plugin.name in this.pluginMap){
							if(plugin.started && !value){
								this.stop(plugin.name)
							}else if(!plugin.started && value){
								this.start(plugin.name)
							}
						}
					}
				})
			}
			var settings = plugin.settings()
			if(settings){
				settings.forEach(setting => {
					if(!setting.name){
						setting.name = name
						if(!setting.name_lang){
							setting.name_lang = name_lang
						}
					}
					if(typeof setting.getItem !== "function"){
						setting.getItem = () => {}
					}
					if(typeof setting.setItem !== "function"){
						setting.setItem = () => {}
					}
					if(!("indent" in setting) && !plugin.hide){
						setting.indent = 1
					}
					items.push(setting)
				})
			}
		}
		return items
	}
	getLocalTitle(title, titleLang, lang){
		if(titleLang){
			for(var id in titleLang){
				if(id === (lang || strings.id) && titleLang[id]){
					return titleLang[id]
				}
			}
		}
		return title
	}
}

class PluginLoader{
	constructor(...args){
		this.init(...args)
	}
	init(script, name, hash, raw){
		this.name = name
		this.hash = hash
		if(typeof script === "string"){
			if(raw){
				this.url = URL.createObjectURL(new Blob([script], {
					type: "application/javascript"
				}))
			}else{
				this.url = script
			}
		}else{
			this.class = script
		}
	}
	load(loadErrors){
		if(this.loaded){
			return Promise.resolve()
		}else if(!this.url && !this.class){
			if(loadErrors){
				return Promise.reject()
			}else{
				return Promise.resolve()
			}
		}else{
			return (this.url ? import(this.url) : Promise.resolve({
				default: this.class
			})).then(module => {
				if(this.url){
					URL.revokeObjectURL(this.url)
					delete this.url
				}else{
					delete this.class
				}
				this.loaded = true
				try{
					this.module = new module.default()
				}catch(e){
					this.error()
					var error = new Error()
					error.stack = "Error initializing plugin: " + this.name + "\n" + e.stack
					if(loadErrors){
						return Promise.reject(error)
					}else{
						console.error(error)
						return Promise.resolve()
					}
				}
				var output
				try{
					if(this.module.beforeLoad){
						this.module.beforeLoad(this)
					}
					if(this.module.load){
						output = this.module.load(this)
					}
				}catch(e){
					this.error()
					var error = new Error()
					error.stack = "Error in plugin load: " + this.name + "\n" + e.stack
					if(loadErrors){
						return Promise.reject(error)
					}else{
						console.error(error)
						return Promise.resolve()
					}
				}
				if(typeof output === "object" && output.constructor === Promise){
					return output.catch(e => {
						this.error()
						var error = new Error()
						error.stack = "Error in plugin load promise: " + this.name + (e ? "\n" + e.stack : "")
						if(loadErrors){
							return Promise.reject(error)
						}else{
							console.error(error)
							return Promise.resolve()
						}
					})
				}
			}, e => {
				this.error()
				plugins.remove(this.name)
				if(e.name === "SyntaxError"){
					var error = new SyntaxError()
					error.stack = "Error in plugin syntax: " + this.name + "\n" + e.stack
				}else{
					var error = e
				}
				if(loadErrors){
					return Promise.reject(error)
				}else{
					console.error(error)
					return Promise.resolve()
				}
			})
		}
	}
	start(orderChange, startErrors){
		if(!orderChange){
			plugins.startOrder.push(this.name)
		}
		return this.load().then(() => {
			if(!this.started && this.module){
				this.started = true
				try{
					if(this.module.beforeStart){
						this.module.beforeStart()
					}
					if(this.module.start){
						this.module.start()
					}
				}catch(e){
					this.error()
					var error = new Error()
					error.stack = "Error in plugin start: " + this.name + "\n" + e.stack
					if(startErrors){
						return Promise.reject(error)
					}else{
						console.error(error)
						return Promise.resolve()
					}
				}
			}
		})
	}
	stop(orderChange, noError){
		if(this.loaded && this.started){
			if(!orderChange){
				var stopIndex = plugins.startOrder.indexOf(this.name)
				if(stopIndex !== -1){
					plugins.startOrder.splice(stopIndex, 1)
					for(var i = plugins.startOrder.length; i-- > stopIndex;){
						plugins.pluginMap[plugins.startOrder[i]].stop(true)
					}
				}
			}

			this.started = false
			try{
				if(this.module.beforeStop){
					this.module.beforeStop()
				}
				if(this.module.stop){
					this.module.stop()
				}
			}catch(e){
				var error = new Error()
				error.stack = "Error in plugin stop: " + this.name + "\n" + e.stack
				console.error(error)
				if(!noError){
					this.error()
				}
			}

			if(!orderChange && stopIndex !== -1){
				for(var i = stopIndex; i < plugins.startOrder.length; i++){
					plugins.pluginMap[plugins.startOrder[i]].start(true)
				}
			}
		}
	}
	unload(error){
		if(this.loaded){
			if(this.started){
				this.stop(false, error)
			}
			this.loaded = false
			plugins.remove(this.name)
			if(this.module){
				try{
					if(this.module.beforeUnload){
						this.module.beforeUnload()
					}
					if(this.module.unload){
						this.module.unload()
					}
				}catch(e){
					var error = new Error()
					error.stack = "Error in plugin unload: " + this.name + "\n" + e.stack
					console.error(error)
				}
				delete this.module
			}
		}
	}
	error(){
		if(this.module && this.module.error){
			try{
				this.module.error()
			}catch(e){
				var error = new Error()
				error.stack = "Error in plugin error: " + this.name + "\n" + e.stack
				console.error(error)
			}
		}
		this.unload(true)
	}
	settings(){
		if(this.module && this.module.settings){
			try{
				var settings = this.module.settings()
			}catch(e){
				console.error(e)
				this.error()
				return
			}
			if(Array.isArray(settings)){
				return settings
			}
		}
	}
}

class EditValue{
	constructor(...args){
		this.init(...args)
	}
	init(parent, name){
		if(name){
			if(!parent){
				throw new Error("Parent is not defined")
			}
			this.name = [parent, name]
			this.delete = !(name in parent)
		}else{
			this.original = parent
		}
	}
	load(callback){
		this.loadCallback = callback
		return this
	}
	start(){
		if(this.name){
			this.original = this.name[0][this.name[1]]
		}
		try{
			var output = this.loadCallback(this.original)
		}catch(e){
			console.error(this.loadCallback)
			var error = new Error()
			error.stack = "Error editing the value of " + this.getName() + "\n" + e.stack
			throw error
		}
		if(typeof output === "undefined"){
			console.error(this.loadCallback)
			throw new Error("Error editing the value of " + this.getName() + ": A value is expected to be returned")
		}
		if(this.name){
			this.name[0][this.name[1]] = output
		}
		return output
	}
	stop(){
		if(this.name){
			if(this.delete){
				delete this.name[0][this.name[1]]
			}else{
				this.name[0][this.name[1]] = this.original
			}
		}
		return this.original
	}
	getName(){
		var name = "unknown"
		try{
			if(this.name){
				var name = (
					typeof this.name[0] === "function" && this.name[0].name
					|| (
						typeof this.name[0] === "object" && typeof this.name[0].constructor === "function" && (
							this.name[0] instanceof this.name[0].constructor ? (() => {
								var consName = this.name[0].constructor.name || ""
								return consName.slice(0, 1).toLowerCase() + consName.slice(1)
							})() : this.name[0].constructor.name + ".prototype"
						)
					) || name
				) + (this.name[1] ? "." + this.name[1] : "")
			}
		}catch(e){
			name = "error"
		}
		return name
	}
	unload(){
		delete this.name
		delete this.original
		delete this.loadCallback
	}
}

class EditFunction extends EditValue{
	start(){
		if(this.name){
			this.original = this.name[0][this.name[1]]
		}
		if(typeof this.original !== "function"){
			console.error(this.loadCallback)
			var error = new Error()
			error.stack = "Error editing the function value of " + this.getName() + ": Original value is not a function"
			throw error
		}
		var args = plugins.argsFromFunc(this.original)
		try{
			var output = this.loadCallback(plugins.strFromFunc(this.original), args)
		}catch(e){
			console.error(this.loadCallback)
			var error = new Error()
			error.stack = "Error editing the function value of " + this.getName() + "\n" + e.stack
			throw error
		}
		if(typeof output === "undefined"){
			console.error(this.loadCallback)
			throw new Error("Error editing the function value of " + this.getName() + ": A value is expected to be returned")
		}
		try{
			var output = Function(...args, output)
		}catch(e){
			console.error(this.loadCallback)
			var error = new SyntaxError()
			var blob = new Blob([output], {
				type: "application/javascript"
			})
			var url = URL.createObjectURL(blob)
			error.stack = "Error editing the function value of " + this.getName() + ": Could not evaluate string, check the full string for errors: " + url + "\n" + e.stack
			setTimeout(() => {
				URL.revokeObjectURL(url)
			}, 5 * 60 * 1000)
			throw error
		}
		if(this.name){
			this.name[0][this.name[1]] = output
		}
		return output
	}
}

class Patch{
	constructor(...args){
		this.init(...args)
	}
	init(){
		this.edits = []
		this.addedLanguages = []
	}
	addEdits(...args){
		args.forEach(arg => this.edits.push(arg))
	}
	addLanguage(lang, forceSet, fallback="en"){
		if(fallback){
			lang = plugins.deepMerge({}, allStrings[fallback], lang)
		}
		this.addedLanguages.push({
			lang: lang,
			forceSet: forceSet
		})
	}
	beforeStart(){
		this.edits.forEach(edit => edit.start())
		this.addedLanguages.forEach(obj => {
			settings.addLang(obj.lang, obj.forceSet)
		})
	}
	beforeStop(){
		for(var i = this.edits.length; i--;){
			this.edits[i].stop()
		}
		for(var i = this.addedLanguages.length; i--;){
			settings.removeLang(this.addedLanguages[i].lang)
		}
	}
	beforeUnload(){
		this.edits.forEach(edit => edit.unload())
	}
	log(...args){
		var name = this.name || "Plugin"
		console.log(
			"%c[" + name + "]",
			"font-weight: bold;",
			...args
		)
	}
}

function readFile(file, arrayBuffer, encoding){
	var reader = new FileReader()
	var promise = pageEvents.load(reader).then(event => event.target.result)
	reader[arrayBuffer ? "readAsArrayBuffer" : "readAsText"](file, encoding)
	return promise
}

class RemoteFile{
	constructor(...args){
		this.init(...args)
	}
	init(url){
		this.url = url
		try{
			this.path = new URL(url).pathname
		}catch(e){
			this.path = url
		}
		if(this.path.startsWith("/")){
			this.path = this.path.slice(1)
		}
		if(this.url.startsWith("data:")){
			this.name = "datauri"
			if(this.url.startsWith("data:audio/ogg")){
				this.name += ".ogg"
			}
		}else{
			this.name = this.path
			var index = this.name.lastIndexOf("/")
			if(index !== -1){
				this.name = this.name.slice(index + 1)
			}
		}
	}
	arrayBuffer(){
		return loader.ajax(this.url, request => {
			request.responseType = "arraybuffer"
		})
	}
	read(encoding){
		if(encoding){
			return this.blob().then(blob => readFile(blob, false, encoding))
		}else{
			return loader.ajax(this.url)
		}
	}
	blob(){
		return loader.ajax(this.url, request => {
			request.responseType = "blob"
		})
	}
}

class LocalFile{
	constructor(...args){
		this.init(...args)
	}
	init(file, path){
		this.file = file
		this.path = path || file.webkitRelativePath || file.name
		this.webkitRelativePath = this.path
		this.url = this.path
		this.name = file.name
	}
	arrayBuffer(){
		return readFile(this.file, true)
	}
	read(encoding){
		return readFile(this.file, false, encoding)
	}
	blob(){
		return Promise.resolve(this.file)
	}
}

class CustomSongs2{
	constructor(...args){
		this.init(...args)
	}
	init(touchEnabled, noPage){
		this.loaderDiv = document.createElement("div")
		this.loaderDiv.innerHTML = assets.pages["loadsong"]
		var loadingText = this.loaderDiv.querySelector("#loading-text")
		this.setAltText(loadingText, strings.loading)
		this.locked = false
		this.mode = "main"
	}
	setAltText(element, text){
		element.innerText = text
		element.setAttribute("alt", text)
	}
	importLocal(files){
		if(!files.length){
			return Promise.reject("cancel")
		}
		this.locked = true
		this.loading(true)

		var importSongs = new ImportSongs()
		return importSongs.load(files).then(this.songsLoaded.bind(this), e => {
			this.locked = false
			this.loading(false)
			if(e === "nosongs"){
				this.showError(strings.customSongs.noSongs, "nosongs")
			}else if(e !== "cancel"){
				return Promise.reject(e)
			}
			return false
		})
	}
	loading(show){
		if(show){
			loader.screen.appendChild(this.loaderDiv)
		}else if(this.loaderDiv.parentNode){
			this.loaderDiv.parentNode.removeChild(this.loaderDiv)
		}
	}
	songsLoaded(songs){
		if(songs){
			var length = songs.length
			assets.songs = songs
			assets.customSongs = true
			assets.customSelected = +localStorage.getItem("customSelected")
		}
		pageEvents.send("import-songs", length)
		this.clean()
		return songs && songs.length
	}
	showError(text, errorName){
		this.locked = false
		this.loading(false)
		var error = new Error(text)
		error.name = errorName
		throw error
	}
	hideError(confirm){
		if(this.mode !== "error"){
			return
		}
		this.mode = "main"
		this.errorDiv.style.display = ""
		assets.sounds[confirm ? "se_don" : "se_cancel"].play()
	}
	clean(){
		delete this.loaderDiv
	}
}

class Search{
	onClick(){
		var songId = parseInt(songEl.dataset.songId)
	}
	keyPress(){
		this.proceed(parseInt(this.results[this.active].dataset.songId))
	}
}

class PluginsInOld extends Patch{
	name = "Plugins in Old Taiko Web"
	load(){
		this.style = document.createElement("style")
		this.style.appendChild(document.createTextNode(`
		.plugin-browse-button{
			position: relative;
			overflow: hidden;
		}
		#plugin-browse{
			position: absolute;
			font-size: inherit;
			top: -0.1em;
			left: -0.1em;
			right: -0.1em;
			bottom: -0.1em;
			border-radius: 0.5em;
			opacity: 0;
			cursor: pointer;
		}
		#plugin-browse::-webkit-file-upload-button{
			cursor: pointer;
		}
		.setting-value{
			position: relative;
		}`))
		this.addEdits(
			new EditValue(allStrings.ja, "intl").load(() => "ja"),
			new EditValue(allStrings.en, "intl").load(() => "en-GB"),
			new EditValue(allStrings.cn, "intl").load(() => "zh-Hans"),
			new EditValue(allStrings.tw, "intl").load(() => "zh-Hant"),
			new EditValue(allStrings.ko, "intl").load(() => "ko"),
			new EditValue(strings, "plural").load(() => new Intl.PluralRules(strings.intl)),
			new EditFunction(settings, "setLang").load(str => {
				return plugins.insertBefore(str,
				`strings.plural = new Intl.PluralRules(lang.intl)
				`, 'if(!noEvent){')
			}),
			new EditValue(settings, "addLang").load(() => this.addLang),
			new EditValue(settings, "removeLang").load(() => this.removeLang),
			new EditValue(SettingsView.prototype, "pluginsStr").load(() => pluginsStr),
			new EditFunction(SettingsView.prototype, "init").load((str, args) => {
				args.push("settingsItems", "noSoundStart")
				str = plugins.insertAfter(str, 'this.songId = songId', `
				this.customSettings = !!settingsItems
				this.settingsItems = settingsItems || settings.items
				this.locked = false`)
				str = plugins.insertBefore(str,
				`if(!noSoundStart)
					`, 'assets.sounds["bgm_settings"].playLoop')
				str = plugins.insertBefore(str,
				`if(this.customSettings){
					pageEvents.add(window, "language-change", event => this.setLang(), this.windowSymbol)
				}
				`, 'var gamepadEnabled = false')
				str = plugins.strReplace(str, 'for(let i in settings.items){\n\t\t\tvar current = settings.items[i]',
				`for(let i in this.settingsItems){
					var current = this.settingsItems[i]`)
				str = plugins.insertAfter(str, 'settingBox.classList.add("setting-box")', `
				if(current.indent){
					settingBox.style.marginLeft = (2 * current.indent || 0).toString() + "em"
				}`)
				str = plugins.strReplace(str, 'var name = strings.settings[i].name\n\t\t\tthis.setAltText(nameDiv, name)',
				`if(current.name || current.name_lang){
					var name = this.getLocalTitle(current.name, current.name_lang)
				}else{
					var name = strings.settings[i].name
				}
				this.setAltText(nameDiv, name)
				if(current.description || current.description_lang){
					settingBox.title = this.getLocalTitle(current.description, current.description_lang) || ""
				}`)
				str = plugins.strReplace(str, 'this.getValue(i, valueDiv)',
				`let outputObject = {
					id: i,
					settingBox: settingBox,
					nameDiv: nameDiv,
					valueDiv: valueDiv,
					name: current.name,
					name_lang: current.name_lang,
					description: current.description,
					description_lang: current.description_lang
				}
				if(current.type === "number"){
					["min", "max", "fixedPoint", "step", "sign", "format", "format_lang"].forEach(opt => {
						if(opt in current){
							outputObject[opt] = current[opt]
						}
					})
					outputObject.valueText = document.createTextNode("")
					valueDiv.appendChild(outputObject.valueText)
					var buttons = document.createElement("div")
					buttons.classList.add("latency-buttons")
					buttons.title = ""
					var buttonMinus = document.createElement("span")
					buttonMinus.innerText = "-"
					buttons.appendChild(buttonMinus)
					this.addTouchRepeat(buttonMinus, event => {
						this.numberAdjust(outputObject, -1)
					})
					var buttonPlus = document.createElement("span")
					buttonPlus.innerText = "+"
					buttons.appendChild(buttonPlus)
					this.addTouchRepeat(buttonPlus, event => {
						this.numberAdjust(outputObject, 1)
					})
					valueDiv.appendChild(buttons)
					this.addTouch(settingBox, event => {
						if(event.target.tagName !== "SPAN"){
							this.setValue(i)
						}
					}, true)
				}else{
					this.addTouchEnd(settingBox, event => this.setValue(i))
				}`)
				str = plugins.strReplace(str, 'this.addTouchEnd(settingBox, event => this.setValue(i))\n\t\t\tthis.items.push({\n\t\t\t\tid: i,\n\t\t\t\tsettingBox: settingBox,\n\t\t\t\tnameDiv: nameDiv,\n\t\t\t\tvalueDiv: valueDiv\n\t\t\t})\n\t\t}\n\t\tthis.items.push({\n\t\t\tid: "default",\n\t\t\tsettingBox: this.defaultButton\n\t\t})\n\t\tthis.addTouch(this.defaultButton, this.defaultSettings.bind(this))',
				`	this.items.push(outputObject)
					this.getValue(i, valueDiv)
				}
				var selectBack = this.items.length === 0
				if(this.customSettings){
					var form = document.createElement("form")
					this.browse = document.createElement("input")
					this.browse.id = "plugin-browse"
					this.browse.type = "file"
					this.browse.multiple = true
					this.browse.accept = ".taikoweb.js"
					pageEvents.add(this.browse, "change", this.browseChange.bind(this))
					form.appendChild(this.browse)
					this.browseButton = document.createElement("div")
					this.browseButton.classList.add("taibtn", "stroke-sub", "plugin-browse-button")
					this.browseText = document.createTextNode("")
					this.browseButton.appendChild(this.browseText)
					this.browseButton.appendChild(form)
					this.defaultButton.parentNode.insertBefore(this.browseButton, this.defaultButton)
					this.items.push({
						id: "browse",
						settingBox: this.browseButton
					})
				}
				this.showDefault = !this.customSettings || plugins.allPlugins.filter(obj => obj.plugin.imported).length
				if(this.showDefault){
					this.items.push({
						id: "default",
						settingBox: this.defaultButton
					})
					this.addTouch(this.defaultButton, this.defaultSettings.bind(this))
				}else{
					this.defaultButton.parentNode.removeChild(this.defaultButton)
				}`)
				str = plugins.insertAfter(str, 'this.addTouch(this.endButton, this.onEnd.bind(this))', `
				if(selectBack){
					this.selected = this.items.length - 1
					this.endButton.classList.add("selected")
				}
				if(!this.customSettings){`)
				str = plugins.strReplace(str, 'this.latencySetValue(current, event.type === "touchstart")', `this.latencySetValue(current, event.type === "touchend")`)
				str = plugins.insertBefore(str, `, true`, ')\n\t\t\tif(current !== "calibration"){')
				str = plugins.insertBefore(str,
				`}
				`, 'this.setStrings()')
				return plugins.strReplace(str, 'pageEvents.send("settings")',
				`if(this.customSettings){
					pageEvents.send("plugins")
				}else{
					pageEvents.send("settings")
				}`)
			}),
			new EditFunction(SettingsView.prototype, "addTouch").load(str => {
				return plugins.insertBefore(str,
				`if(event.cancelable)
					`, 'event.preventDefault()')
			}),
			new EditFunction(SettingsView.prototype, "getValue").load(str => {
				str = plugins.strReplace(str,
				'var current = settings.items[name]\n\t\tvar value = settings.getItem(name)',
				`if(!this.items){
					return
				}
				var current = this.settingsItems[name]
				if(current.getItem){
					var value = current.getItem()
				}else{
					var value = settings.getItem(name)
				}`)
				str = plugins.strReplace(str,
				'value = strings.settings[name][value]',
				`if(current.options_lang && current.options_lang[value]){
					value = this.getLocalTitle(value, current.options_lang[value])
				}else if(!current.getItem){
					value = strings.settings[name][value]
				}`)
				str = plugins.insertBefore(str,
				`else if(current.type === "number"){
					var mul = Math.pow(10, current.fixedPoint || 0)
					this.items[name].value = value * mul
					value = Intl.NumberFormat(strings.intl, current.sign ? {
						signDisplay: "always"
					} : undefined).format(value)
					if(current.format || current.format_lang){
						value = this.getLocalTitle(current.format, current.format_lang).replace("%s", value)
					}
					this.items[name].valueText.data = value
					return
				}
				`, 'valueDiv.innerText = value')
				return str
			}),
			new EditFunction(SettingsView.prototype, "setValue").load(str => {
				str = plugins.strReplace(str,
				'var current = settings.items[name]\n\t\tvar value = settings.getItem(name)',
				`if(this.locked){
					return
				}
				var promise
				var current = this.settingsItems[name]
				if(current.getItem){
					var value = current.getItem()
				}else{
					var value = settings.getItem(name)
				}`)
				str = plugins.insertBefore(str,
				`if(this.mode === "number"){
					return this.numberBack(this.items[this.selected])
				}
				`, 'if(this.selected === selectedIndex){')
				str = plugins.strReplace(str, 'settings.setItem(name, value)',
				`else if(current.type === "number"){
					this.mode = "number"
					selected.settingBox.style.animation = "none"
					selected.valueDiv.classList.add("selected")
					this.playSound("se_don")
					return
				}
				if(current.setItem){
					promise = current.setItem(value)
				}else{
					settings.setItem(name, value)
				}
				(promise || Promise.resolve()).then(() => {`)
				return plugins.insertAfter(str, 'this.setLang(allStrings[value])\n\t\t}', `
				})`)
			}),
			new EditFunction(SettingsView.prototype, "keyPressed").load(str => {
				str = plugins.insertBefore(str,
				`if(this.locked){
					return
				}
				`, 'if(pressed){')
				str = plugins.insertAfter(str, 'this.defaultSettings()', `
				}else if(selected.id === "browse"){
					if(event){
						this.playSound("se_don")
						this.browse.click()
					}`)
				str = plugins.strReplace(str,
				'}while(this.items[this.selected].id === "default" && name !== "left")',
				`}while((this.items[this.selected].id === "default" || this.items[this.selected].id === "browse") && name !== "left")`)
				return plugins.insertAfter(str,
				'this.latencySetAdjust(latencySelected, (name === "up" || name === "right") ? 1 : -1)', `
						if(event){
							event.preventDefault()
						}
					}
				}else if(this.mode === "number"){
					if(name === "confirm" || name === "back"){
						this.numberBack(selected)
						this.playSound(name === "confirm" ? "se_don" : "se_cancel")
					}else if(name === "up" || name === "right" || name === "down" || name === "left"){
						this.numberAdjust(selected, (name === "up" || name === "right") ? 1 : -1)
						if(event){
							event.preventDefault()
						}`)
			}),
			new EditFunction(SettingsView.prototype, "keyboardSet").load(str => {
				return plugins.strReplace(str, 'settings.items', `this.settingsItems`)
			}),
			new EditFunction(SettingsView.prototype, "gamepadSet").load(str => {
				return plugins.strReplace(str, 'settings.items', `this.settingsItems`)
			}),
			new EditFunction(SettingsView.prototype, "gamepadBack").load(str => {
				return plugins.strReplace(str, 'settings.items', `this.settingsItems`)
			}),
			new EditFunction(SettingsView.prototype, "latencySet").load(str => {
				return plugins.strReplace(str, 'settings.items', `this.settingsItems`)
			}),
			new EditFunction(SettingsView.prototype, "latencyBack").load(str => {
				return plugins.strReplace(str, 'settings.items', `this.settingsItems`)
			}),
			new EditValue(SettingsView.prototype, "numberAdjust").load(() => this.numberAdjust),
			new EditValue(SettingsView.prototype, "numberBack").load(() => this.numberBack),
			new EditFunction(SettingsView.prototype, "defaultSettings").load(str => {
				str = plugins.insertBefore(str,
				`if(this.customSettings){
					plugins.unloadImported()
					this.clean(true)
					this.playSound("se_don")
					return setTimeout(() => this.restart(), 500)
				}
				`, 'if(this.mode === "keyboard"){')
				return plugins.strReplace(str, 'settings.items', `this.settingsItems`)
			}),
			new EditValue(SettingsView.prototype, "browseChange").load(() => this.browseChange),
			new EditFunction(SettingsView.prototype, "onEnd").load(str => {
				str = plugins.insertBefore(str,
				`if(this.mode === "number"){
					this.numberBack(this.items[this.selected])
				}
				`, 'this.clean()')
				return plugins.strReplace(str, '"settings"', `this.customSettings ? "plugins" : "settings"`)
			}),
			new EditValue(SettingsView.prototype, "restart").load(() => this.restart),
			new EditValue(SettingsView.prototype, "getLocalTitle").load(() => this.getLocalTitle),
			new EditFunction(SettingsView.prototype, "setLang").load(str => {
				str = plugins.insertBefore(str,
				`if(lang)
					`, 'settings.setLang(lang)')
				return plugins.strReplace(str, 'var name = strings.settings[item.id].name\n\t\t\t\tthis.setAltText(item.nameDiv, name)',
				`if(item.name || item.name_lang){
					var name = this.getLocalTitle(item.name, item.name_lang)
				}else{
					var name = strings.settings[item.id].name
				}
				this.setAltText(item.nameDiv, name)
				if(item.description || item.description_lang){
					item.settingBox.title = this.getLocalTitle(item.description, item.description_lang) || ""
				}`)
			}),
			new EditFunction(SettingsView.prototype, "setStrings").load(str => {
				str = plugins.insertBefore(str, `this.customSettings ? this.pluginsStr().title : `, 'strings.gameSettings')
				str = plugins.insertAfter(str, 'this.setAltText(this.endButton, strings.settings.ok)', `
				if(this.customSettings){
					this.browseText.data = this.pluginsStr().browse
					this.browseButton.setAttribute("alt", this.pluginsStr().browse)
				}else{`)
				return plugins.strReplace(str,
				'this.setAltText(this.defaultButton, strings.settings.default)',
				`}
				if(this.showDefault){
					this.setAltText(this.defaultButton, this.customSettings ? this.pluginsStr().unloadAll : strings.settings.default)
				}`)
			}),
			new EditFunction(SettingsView.prototype, "clean").load((str, args) => {
				args.push("noSoundStop")
				str = plugins.insertBefore(str,
				`if(this.customSettings){
					pageEvents.remove(window, "language-change", this.windowSymbol)
				}
				if(!noSoundStop)
					`, 'assets.sounds["bgm_settings"].stop()')
				str = plugins.insertBefore(str,
				`if(this.customSettings){
					pageEvents.remove(this.browse, "change")
					delete this.browse
					delete this.browseButton
					delete this.browseText
				}else{
					`, 'this.removeTouch(this.gamepadSettings)')
				str = plugins.insertAfter(str, 'this.removeTouch(this.latencyEndButton)', `
				}`)
				return plugins.strReplace(str,
				'){\n\t\t\t\t\tURL.revokeObjectURL(assets.image[i].src)',
				` || i.startsWith("results_")){
					var img = assets.image[i]
					URL.revokeObjectURL(img.src)
					if(img.parentNode){
						img.parentNode.removeChild(img)
					}`)
			}),
			new EditValue(SongSelect.prototype, "pluginsStr").load(() => pluginsStr),
			new EditFunction(SongSelect.prototype, "init").load(str => {
				str = plugins.insertBefore(str,
				`"plugins": {
					sort: 0,
					background: "#f6bba1",
					border: ["#fde9df", "#ce7553"],
					outline: "#ce7553"
				}, `, '"default": {')
				str = plugins.insertAfter(str, 'music: song.music,', `
				chart: song.chart,
				lyricsFile: song.lyricsFile,`)
				str = plugins.insertAfter(str, 'action: "browse",\n\t\t\t\tcategory: strings.random\n\t\t\t})\n\t\t}',
				`this.songs.push({
					title: this.pluginsStr().title,
					skin: this.songSkin.plugins,
					action: "plugins",
					category: strings.random
				})`)
				return plugins.strReplace(str, 'speed: 800', `speed: 400 * 2`)
			}),
			new EditFunction(SongSelect.prototype, "toSelectDifficulty").load(str => {
				return plugins.insertAfter(str,
				'this.toBrowse()', `
				}else if(currentSong.action === "plugins"){
					this.toPlugins()`)
			}),
			new EditValue(SongSelect.prototype, "toPlugins").load(() => this.toPlugins),
			new EditValue(ImportSongs.prototype, "pluginsStr").load(() => pluginsStr),
			new EditFunction(SongSelect.prototype, "diffSelMouse").load(str => {
				return plugins.strReplace(str,
				'if(223 < x && x < 367 && 132 < y && y < 436){\n\t\t\t\treturn Math.floor((x - 223) / ((367 - 223) / 2))',
				`if(223 < x && x < 223 + 72 * this.diffOptions.length && 132 < y && y < 436){
					return Math.floor((x - 223) / 72)`)
			}),
			new EditFunction(SongSelect.prototype, "redraw").load(str => {
				return plugins.strReplace(str,
				'ms >= this.pressedKeys[key] + 50',
				`ms >= this.pressedKeys[key] + (this.state.screen === "song" && (key === "right" || key === "left") ? 20 : 50)`)
			}),
			new EditFunction(ImportSongs.prototype, "init").load((str, args) => {
				args.push("otherFiles")
				str = plugins.insertBefore(str,
				`if(!songSelect && !otherFiles){
					return
				}
				if(songSelect){
				`, 'this.songSelect = songSelect')
				str = plugins.insertBefore(str,
				`}else{
					var files = otherFiles
				}
				this.pluginFiles = []
				this.plugins = []
				`, 'this.tjaFiles = []')
				str = plugins.insertBefore(str,
				`if(name.endsWith(".taikoweb.js")){
					this.pluginFiles.push({
						file: file,
						index: i
					})
				}else `, 'if(name.endsWith(".tja")){')
				str = plugins.insertBefore(str,
				`this.pluginAmount = 0
				if(this.pluginFiles.length){
					var pluginPromises = []
					this.pluginFiles.forEach(fileObj => {
						pluginPromises.push(this.addPlugin(fileObj).catch(e => console.warn(e)))
					})
					return Promise.all(pluginPromises).then(() => {
						var startPromises = []
						if(this.plugins.length && confirm(this.pluginsStr().warning.replace("%s",
							this.pluginsStr().plugin[strings.plural.select(this.plugins.length)].replace("%s",
								this.plugins.length.toString()
							)
						))){
							this.plugins.forEach(obj => {
								var plugin = plugins.add(obj.data, {
									name: obj.name,
									raw: true
								})
								if(plugin){
									this.pluginAmount++
									plugin.imported = true
									startPromises.push(plugin.start())
								}
							})
						}
						return Promise.all(startPromises).then(this.loaded.bind(this))
					})
				}
				`, 'var metaPromises = []')
				str = plugins.insertBefore(str, `return `, 'Promise.all(metaPromises)')
				return plugins.insertBefore(str, `return `, 'Promise.all(songPromises)')
			}),
			new EditValue(ImportSongs.prototype, "load").load(() => this.importSongsLoad),
			new EditValue(ImportSongs.prototype, "addPlugin").load(() => this.addPlugin),
			new EditFunction(ImportSongs.prototype, "loaded").load(str => {
				return plugins.insertBefore(str,
				`if(!this.songSelect){
					if(this.songs.length){
						return Promise.resolve(this.songs)
					}else{
						if(this.pluginAmount || Object.keys(this.assetFiles).length){
							return Promise.resolve()
						}else{
							return Promise.reject("nosongs")
						}
					}
					return this.clean()
				}
				`, 'if(this.stylesheet.length){')
			}),
			new EditValue(loader, "cssRuleset").load(() => this.cssRuleset),
			new EditValue(p2, "disabled").load(() => 0),
			new EditFunction(p2, "open").load(str => {
				return plugins.insertBefore(str,
				`if(!this.closed || this.disabled){
					return
				}
				`, 'this.closed = false')
			}),
			new EditValue(p2, "enable").load(() => this.p2enable),
			new EditValue(p2, "disable").load(() => this.p2disable),
			new EditFunction(snd.sfxGain.soundBuffer, "load").load(str => {
				return plugins.insertBefore(str,
				`if(typeof url.arrayBuffer === "function"){
					var loadPromise = url.arrayBuffer()
				}else `, 'if(local){')
			}),
			new EditFunction(SongSelect.prototype, "getLocalTitle").load(str => {
				return plugins.strReplace(str,
				'if(id === strings.id && titleLang[id]){',
				`if(id === "en" && strings.preferEn && !(strings.id in titleLang) && titleLang.en || id === strings.id && titleLang[id]){`)
			}),
			new EditFunction(Account.prototype, "accountForm").load(str => {
				return plugins.insertAfter(str,
				'this.redrawRunning = true', `
				this.redrawPaused = 'matchMedia("(prefers-reduced-motion: reduce)").matches' === 'true'`)
			}),
			new EditFunction(Account.prototype, "customdonRedraw").load(str => {
				return plugins.insertAfter(str,
				'var frame = ', `this.redrawPaused ? 0 : `)
			}),
			new EditFunction(LoadSong.prototype, "run").load(str => {
				str = plugins.strReplace(str,
				'if(songObj.chart){',
				`if(songObj.chart && !songObj.chart.separateDiff && !(songObj.chart instanceof RemoteFile)){`)
				return plugins.strReplace(str,
				'if(songObj.music){',
				`if(songObj.music && !(songObj.chart instanceof RemoteFile)){`)
			}),
			new EditFunction(Controller.prototype, "restartSong").load(str => {
				str = plugins.strReplace(str,
				'if(songObj.chart &&',
				`if(songObj.chart && !songObj.chart.separateDiff && !(songObj.chart instanceof RemoteFile) &&`)
				return plugins.strReplace(str,
				'if(songObj.lyricsFile){',
				`if(songObj.lyricsFile && !(songObj.lyricsFile instanceof RemoteFile)){`)
			}),
		)
	}
	start(){
		document.head.appendChild(this.style)
		if(assets && assets.songsDefault){
			assets.songsDefault.forEach(song => {
				var directory = gameConfig.songs_baseurl + song.id + "/"
				var songExt = song.music_type ? song.music_type : "mp3"
				song.music = new RemoteFile(directory + "main." + songExt)
				if(song.type === "tja"){
					song.chart = new RemoteFile(directory + "main.tja")
				}else{
					song.chart = {separateDiff: true}
					for(var diff in song.courses){
						if(song.courses[diff]){
							song.chart[diff] = new RemoteFile(directory + diff + ".osu")
						}
					}
				}
				if(song.lyrics){
					song.lyricsFile = new RemoteFile(directory + "main.vtt")
				}
			})
		}
	}
	stop(){
		if(this.style.parentNode){
			this.style.parentNode.removeChild(this.style)
		}
		if(assets && assets.songsDefault){
			assets.songsDefault.forEach(song => {
				if(song.music instanceof RemoteFile){
					delete song.music
				}
				delete song.chart
				delete song.lyricsFile
			})
		}
	}
	addLang(lang, forceSet){
		allStrings[lang.id] = lang
		if(lang.categories){
			assets.categories.forEach(category => {
				if("title_lang" in category && lang.categories[category.title_lang.en]){
					category.title_lang[lang.id] = lang.categories[category.title_lang.en]
				}
			})
		}
		languageList.push(lang.id)
		this.allLanguages.push(lang.id)
		this.items.language.default = this.getLang()
		if(forceSet){
			this.storage.language = lang.id
		}else{
			try{
				this.storage.language = localStorage.getItem("lang")
			}catch(e){}
			if(this.items.language.options.indexOf(this.storage.language) === -1){
				this.storage.language = null
			}
		}
		if(settings.getItem("language") === lang.id){
			settings.setLang(lang)
		}
	}
	removeLang(lang){
		delete allStrings[lang.id]
		assets.categories.forEach(category => {
			if("title_lang" in category){
				delete category.title_lang[lang.id]
			}
		})
		var index = languageList.indexOf(lang.id)
		if(index !== -1){
			languageList.splice(index, 1)
		}
		var index = this.allLanguages.indexOf(lang.id)
		if(index !== -1){
			this.allLanguages.splice(index, 1)
		}
		this.items.language.default = this.getLang()
		try{
			this.storage.language = localStorage.getItem("lang")
		}catch(e){}
		if(this.items.language.options.indexOf(this.storage.language) === -1){
			this.storage.language = null
		}
		if(lang.id === strings.id){
			settings.setLang(allStrings[this.getItem("language")])
		}
	}
	numberAdjust(selected, add){
		var selectedItem = this.items[this.selected]
		var mul = Math.pow(10, selected.fixedPoint || 0)
		selectedItem.value += add * ("step" in selected ? selected.step : 1)
		if("max" in selected && selectedItem.value > selected.max * mul){
			selectedItem.value = selected.max * mul
		}else if("min" in selected && selectedItem.value < selected.min * mul){
			selectedItem.value = selected.min * mul
		}else{
			this.playSound("se_ka")
		}
		var valueText = Intl.NumberFormat(strings.intl, selected.sign ? {
			signDisplay: "always"
		} : undefined).format(selectedItem.value / mul)
		if(selected.format || selected.format_lang){
			valueText = this.getLocalTitle(selected.format, selected.format_lang).replace("%s", valueText)
		}
		selectedItem.valueText.data = valueText
	}
	numberBack(selected){
		this.mode = "settings"
		selected.settingBox.style.animation = ""
		selected.valueDiv.classList.remove("selected")
		var current = this.settingsItems[selected.id]
		var promise
		var mul = Math.pow(10, selected.fixedPoint || 0)
		var value = selected.value / mul
		if(current.setItem){
			promise = current.setItem(value)
		}else{
			settings.setItem(selected.id, value)
		}
		(promise || Promise.resolve()).then(() => {
			this.getValue(selected.id, selected.valueText)
		})
	}
	browseChange(event){
		this.locked = true
		var files = []
		for(var i = 0; i < event.target.files.length; i++){
			files.push(new LocalFile(event.target.files[i]))
		}
		var customSongs = new CustomSongs(this.touchEnabled, true)
		customSongs.importLocal(files).then(() => {
			this.clean(true)
			return this.restart()
		}).catch(e => {
			if(e){
				var message = e.message
				if(e.name === "nosongs"){
					message = this.pluginsStr().noPlugins
				}
				if(message){
					alert(message)
				}
			}
			this.locked = false
			this.browse.form.reset()
			return Promise.resolve()
		})
	}
	restart(){
		if(this.mode === "number"){
			this.numberBack(this.items[this.selected])
		}
		return new SettingsView(this.touchEnabled, this.tutorial, this.songId, undefined, this.customSettings ? plugins.getSettings() : undefined, true)
	}
	getLocalTitle(title, titleLang){
		if(titleLang){
			for(var id in titleLang){
				if(id === strings.id && titleLang[id]){
					return titleLang[id]
				}
			}
		}
		return title
	}
	toPlugins(){
		this.playSound("se_don")
		this.clean()
		setTimeout(() => {
			new SettingsView(this.touchEnabled, false, undefined, undefined, plugins.getSettings())
		}, 500)
	}
	importSongsLoad(files){
		return this.init(null, null, files)
	}
	addPlugin(fileObj){
		var file = fileObj.file
		var filePromise = file.read()
		return filePromise.then(dataRaw => {
			var name = file.name.slice(0, file.name.lastIndexOf(".taikoweb.js"))
			this.plugins.push({
				name: name,
				data: dataRaw
			})
		})
	}
	cssRuleset(rulesets){
		var css = []
		for(var selector in rulesets){
			var declarationsObj = rulesets[selector]
			var declarations = []
			for(var property in declarationsObj){
				var value = declarationsObj[property]
				declarations.push("\t" + property + ": " + value + ";")
			}
			css.push(selector + "{\n" + declarations.join("\n") + "\n}")
		}
		return css.join("\n")
	}
	p2enable(){
		this.disabled = Math.max(0, this.disabled - 1)
		setTimeout(this.open.bind(this), 100)
	}
	p2disable(){
		this.disabled++
		this.close()
	}
}

function ready(){
	if(typeof CustomSongs !== "undefined"){
		console.error("[Plugins in Old Taiko Web] Cannot run on new taiko-web")
		return
	}
	window.Plugins = Plugins
	window.PluginLoader = PluginLoader
	window.EditValue = EditValue
	window.EditFunction = EditFunction
	window.Patch = Patch
	window.readFile = readFile
	window.RemoteFile = RemoteFile
	window.LocalFile = LocalFile
	window.CustomSongs = CustomSongs2
	window.Search = Search
	var classes = [
		About, Account, Settings, SongSelect, AutoScore, CanvasAsset, CanvasCache, CanvasDraw, CanvasTest, Circle, Controller, Debug, InputSlider,
		Game, GameInput, Gamepad, GameRules, ImportSongs, Keyboard, LoadSong, Logo, Lyrics, Mekadon, P2Connection, ParseOsu, ParseTja, Scoresheet,
		ScoreStorage, Session, Settings, SettingsView, SongSelect, SoundBuffer, SoundGain, Sound, Titlescreen, Tutorial, View, ViewAssets
	]
	classes.forEach(cls => {
		var str = cls.toString()
		var needle1 = "class "
		var index1 = str.indexOf(needle1)
		if(index1 !== -1){
			var pos = index1 + needle1.length
			var needle2 = "{"
			var index2 = str.indexOf(needle2, pos)
			if(index2 !== -1){
				var name = str.slice(pos, index2).trim()
				if(name){
					pos = index2 + needle2.length
					var needle3 = "constructor"
					var index3 = str.indexOf(needle3, pos)
					if(index3 !== -1){
						var str = name + " = " + str.slice(0, index3 + needle3.length) + "(...args){\n\t\tthis.init(...args)\n\t}\n\tinit" + str.slice(index3 + needle3.length)
						return window.eval(str)
					}
				}
			}
		}
		throw new Error("Error attempting to fix class:", cls)
	})
	window.plugins = new Plugins()
	var plugin = plugins.add(PluginsInOld, {
		name: PluginsInOld.name,
		hide: true
	})
	plugin?.start()
}

if(typeof perf !== "undefined" && perf.allImg){
	ready()
}else{
	addEventListener("ready", ready, {once: true})
}