diff --git a/.gitignore b/.gitignore
index 928ab591..cd2cdffd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,7 +1,7 @@
 .vscode
-*ce5eec52_2fa1_447b_8dad_764e267a7fab*
 
 .DS_Store
+MTBuilder.app
 
 # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm
 # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
diff --git a/API列表.txt b/API列表.txt
new file mode 100644
index 00000000..8233a735
--- /dev/null
+++ b/API列表.txt
@@ -0,0 +1,2144 @@
+附录：API列表（V2.6版）
+
+这里将列出所有被转发到core的API，没有被转发的函数此处不会列出，请自行在代码中查看。
+
+本文档较大，如有什么需求请自行Ctrl+F进行搜索。
+
+如有任何疑问，请联系小艾寻求帮助。
+
+------------------------------------ [core.js] ------------------------------------
+
+core.js中只有很少的几个函数，主要是游戏开始前的初始化等。
+但是，core中定义了很多游戏运行时的状态，这些状态很多都会被使用到。
+
+
+
+
+core.__SIZE__, core.__PIXELS__
+游戏窗口大小；对于13x13的游戏而言这两个值分别是13和416，15x15来说分别是15和480。
+
+
+core.material
+游戏中的所有资源列表，具体分为如下内容：
+core.material.animates  （动画）
+core.material.bgms    （背景音乐）
+core.material.enemys    （怪物信息，来自于 project/enemys.js）
+core.material.icons    （图标信息，来自于 project/icons.js）
+core.material.images    （图片素材，存放了各项素材图片如items.png等）
+    core.material.images.autotile    （所有的自动元件图片）
+    core.material.images.tilesets    （所有的额外素材图片）
+    core.material.images.images    （用户引入的其他图片）
+core.material.items    （道具信息）
+core.material.sounds    （音效）
+
+
+core.animateFrame
+主要是记录和requestAnimationFrame相关的一些数据，常用的如下：
+core.animateFrame.totalTime    （游戏总的运行时时间）
+core.animateFrame.weather    （当前的天气信息）
+core.animateFrame.asyncId    （当前的异步处理事件的内容）
+
+
+core.musicStatus
+主要是记录和音效相关的内容，常用的如下：
+core.musicStatus.bgmStatus    （音乐开启状态）
+core.musicStatus.soundStatus    （音效开启状态）
+core.musicStatus.playingBgm    （当前正在播放的BGM）
+core.musicStatus.lastBgm    （最近一次尝试播放的BGM）
+core.musicStatus.volume    （当前的音量）
+core.musicStatus.cachedBgms    （背景音乐的缓存内容）
+core.musicStatus.cacheBgmCount    （背景音乐的缓存数量，默认值是4）
+
+
+core.platform
+游戏平台相关信息，常见的几个如下：
+core.platform.isPC    （是否是电脑端）
+core.platform.isAndroid    （是否是安卓端）
+core.platform.isIOS    （是否是iOS端）
+core.platform.useLocalForage    （是否开启了新版存档）
+core.platform.extendKeyBoard    （是否开启了拓展键盘）
+
+
+core.domStyle
+游戏的界面信息，包含如下几个：
+core.domStyle.scale    （当前的放缩比）
+core.domStyle.isVertical    （当前是否是竖屏状态）
+core.domStyle.showStatusBar    （当前是否显示状态栏）
+core.domStyle.toolbarBtn    （当前是否显示工具栏）
+
+
+core.bigmap
+当前的地图的尺寸信息，主要包含如下几个
+core.bigmap.width    （当前地图的宽度）
+core.bigmap.height    （当前地图的高度）
+core.bigmap.offsetX    （当前地图针对窗口左上角的偏移像素x）
+core.bigmap.offsetX    （当前地图针对窗口左上角的偏移像素y）
+core.bigmap.tempCanvas    （一个临时画布，可以用来临时绘制很多东西）
+
+
+core.saves
+和存档相关的信息，包含如下几个：
+core.saves.saveIndex    （上次保存或读取的存档编号）
+core.saves.ids    （当前存在存档的编号列表）
+core.saves.autosave    （自动存档的信息）
+core.saves.favorite    （收藏的存档）
+core.saves.favoriteNames    （自定义存档的名称）
+
+
+core.status
+游戏的状态相关，是整个游戏中最重要的东西，其核心是如下几条：
+请注意，每次重新开始、存档或读档时，core.status都会重新初始化。
+core.status.played    （当前是否在游戏中）
+core.status.gameOver    （当前是否已经游戏结束，即win或lose）
+core.status.hero    （勇士信息；此项和全塔属性中的hero大体是对应的）
+    core.status.hero.name    勇士名
+    core.status.hero.lv      当前等级
+    core.status.hero.hpmax   当前生命上限
+    core.status.hero.hp      当前生命值
+    core.status.hero.manamax   当前魔力上限
+    core.status.hero.mana    当前魔力值
+    core.status.hero.atk     当前攻击力
+    core.status.hero.def     当前防御力
+    core.status.hero.mdef    当前魔防值
+    core.status.hero.money   当前金币值
+    core.status.hero.experience    当前经验值
+    core.status.hero.loc     当前的位置信息
+    core.status.hero.equipment     当前装上的装备
+    core.status.hero.items   当前拥有的道具信息
+    core.status.hero.flags   当前的各项flag信息
+    core.status.hero.step    当前的步数值
+    core.status.hero.statistics    当前的统计信息
+core.status.floorId    （当前所在的楼层）
+core.status.maps    （所有的地图信息）
+core.status.thisMap    （当前的地图信息，等价于core.status.maps[core.status.floorId]）
+core.status.bgmaps   （所有背景层的信息）
+core.status.fgmaps    （所有的前景层的信息）
+core.status.checkBlock    （地图上的阻激夹域信息，也作为光环的缓存）
+core.status.lockControl    （当前是否是控制锁定状态）
+core.status.automaticRoute    （当前的自动寻路信息）
+core.status.route    （当前记录的录像）
+core.status.replay    （录像回放时要用到的信息）
+core.status.shops    （所有全局商店信息）
+core.status.textAttribute    （当前的文字属性，如颜色、背景等信息，和setText事件对应）
+core.status.globalAttribute    （当前的全局属性，如边框色、装备栏等）
+core.status.curtainColor    （当前色调层的颜色）
+core.status.globalAnimateObjs    （当前的全局帧动画效果）
+core.status.floorAnimateObjs    （当前的楼层贴图帧动画效果）
+core.status.boxAnimateObjs    （当前的盒子帧动画效果，例如怪物手册中的怪物）
+core.status.autotileAnimateObjs    （当前楼层的自动元件动画效果）
+core.status.globalAnimateStatus    （当前的帧动画的状态）
+core.status.animateObjs    （当前的播放动画信息）
+
+
+core.floorIds
+一个数组，表示所有的楼层ID，和全塔属性中的floorIds一致。
+
+
+core.floors
+从楼层文件中读取全部的地图数据。
+和core.status.maps不同的是，后者在每次重新开始和读档时都会重置，也允许被修改（会存入存档）。
+而core.floors全程唯一，不允许被修改。
+
+
+core.statusBar
+状态栏信息，例如状态栏图片，图标，以及各个内容的DOM定义等。
+core.statusBar.images    （所有的系统图标，和icons.png对应）
+core.statusBar.icons    （状态栏中绘制的图标内容）
+
+
+core.values
+所有的全局数值信息，和全塔属性中的values一致。
+此项允许被直接修改，会存入存档。
+
+
+core.flags
+所有的全塔开关，和全塔属性中的flags一致。
+此项不允许被直接修改，如有需要请使用“设置系统开关”事件，或者调用core.setGlobalFlag这个API。
+
+
+core.plugin
+定义的插件函数。
+
+
+core.doFunc(func, _this)
+执行一个函数，func为函数体或者插件中的函数名，_this为使用的this。
+如果func为一个字符串，则视为插件中的函数名，同时_this将被设置成core.plugin。
+此函数剩余参数将作为参数被传入func。
+
+
+
+
+------------------------------------ [actions.js] ------------------------------------
+
+actions.js主要是处理一些和用户交互相关的内容。
+
+
+
+
+core.registerAction(action, name, func, priority)
+注册一个用户交互行为。
+action：要注册的交互类型，如 ondown, onclick, keyDown 等等。
+name：你的自定义名称，可被注销使用；同名重复注册将后者覆盖前者。
+func：执行函数；可以是一个具体的函数体，或者是一个插件中的函数名。
+priority：优先级；优先级高的被注册项将会被执行。此项可不填，默认为0。
+返回：如果func返回true，则不会再继续执行其他的交互函数；否则会继续执行其他的交互函数。
+
+
+core.unregisterAction(action, name)
+注销一个用户交互行为。
+
+
+core.doRegisteredAction(action)
+执行一个用户交互行为。
+此函数将在该交互行为所注册的所有函数中，按照优先级从高到底依次执行。
+此函数剩余的参数将会作为参数传入该执行函数中。
+当某个执行函数返回true时将终止这一过程。
+
+
+core.onkeyDown(e)
+当按下某个键时的操作，e为KeyboardEvent。
+请勿直接覆盖或调用此函数，如有需要请注册一个"onkeyDown"的交互函数。
+
+
+core.onkeyUp(e)
+当放开某个键时的操作，e为KeyboardEvent。
+请勿直接覆盖或调用此函数，如有需要请注册一个"onkeyUp"的交互函数。
+
+
+core.pressKey(keyCode)
+当按住某个键不动时的操作，目前只对方向键有效。
+如果需要添加对于其他键的长按，请复写_sys_onkeyDown和_sys_onkeyUp。
+请勿直接覆盖或调用此函数，如有需要请注册一个"pressKey"的交互函数。
+
+
+core.keyDown(keyCode)
+当按下某个键时的操作，参数为该键的keyCode值。
+请勿直接覆盖或调用此函数，如有需要请注册一个"keyDown"的交互函数。
+
+
+core.keyUp(keyCode, altKey, fromReplay)
+当按下某个键时的操作，参数为该键的keyCode值。
+altKey标志了Alt键是否同时被按下，fromReplay表示是否是从录像回放中调用的。
+请勿直接覆盖或调用此函数，如有需要请注册一个"keyUp"的交互函数。
+
+
+core.ondown(loc)
+当点击屏幕时的操作。loc为点击的信息。
+请勿直接覆盖或调用此函数，如有需要请注册一个"ondown"的交互函数。
+注册的ondown交互函数需要接受x, y, px, py四个参数，代表点击的位置和像素坐标。
+
+
+core.onmove(loc)
+当在屏幕上滑动时的操作。loc为当前的坐标信息。
+请勿直接覆盖或调用此函数，如有需要请注册一个"onmove"的交互函数。
+注册的onmove交互函数需要接受x, y, px, py四个参数，代表当前的的位置和像素坐标。
+
+
+core.onup()
+当从屏幕上离开时的操作。请注意此函数是没有参数的。
+请勿直接覆盖或调用此函数，如有需要请注册一个"onup"的交互函数。
+
+
+core.onclick(x, y)
+当点击屏幕上的某点位置时执行的操作，请注意这里的x和y是位置坐标。
+一般而言，一个完整的ondown到onup将触发一个onclick事件。
+请勿直接覆盖或调用此函数，如有需要请注册一个"onclick"的交互函数。
+
+
+core.onmousewheel(direct)
+当滚动鼠标滑轮时执行的操作。direct为滑轮方向，上为1，下为-1。
+请勿直接覆盖或调用此函数，如有需要请注册一个"onmousewheel"的交互函数。
+
+
+core.keyDownCtrl()
+当长按Ctrl键不动时执行的操作。
+请勿直接覆盖或调用此函数，如有需要请注册一个"keyDownCtrl"的交互函数。
+
+
+core.longClick()
+当长按住屏幕时执行的操作。
+请勿直接覆盖或调用此函数，如有需要请注册一个"keyDownCtrl"的交互函数。
+注册的交互函数如果某一项返回true，则之后仍然会继续触发该长按，
+如果全部返回false则将停止本次长按行为，直到手指离开屏幕并重新进行长按为止。
+
+
+
+
+------------------------------------ [control.js] ------------------------------------
+
+control.js将负责整个游戏的核心控制系统，分为如下几个部分：
+- requestAnimationFrame相关
+- 标题界面，开始和重新开始游戏
+- 自动寻路和人物行走相关
+- 画布、位置、阻激夹域、显伤等相关
+- 录像的回放相关
+- 存读档，自动存档，同步存档等相关
+- 人物属性和状态、位置、变量等相关
+- 天气、色调、音乐和音效的播放
+- 状态栏和工具栏相关
+- 界面resize相关
+
+
+
+
+// ------ requestAnimationFrame 相关 ------ //
+
+core.registerAnimationFrame(name, needPlaying, func)
+注册一个animationFrame。它将在每次浏览器的帧刷新时（约16.6ms）被执行。
+name：你的自定义名称，可被注销使用；同名重复注册将后者覆盖前者。
+needPlaying：如果此项为true，则仅在游戏开始后才会被执行（标题界面不执行）
+func：执行函数；可以是一个具体的函数体，或者是一个插件中的函数名。
+func可以接受一个timestamp作为参数，表示从整个页面加载完毕到当前时刻所经过的毫秒数。
+如果func执行报错，将在控制台打出一条信息，并自动进行注销。
+
+
+core.unregisterAnimationFrame(name)
+注销一个animationFrame，参数是你的上面的自定义名称。
+
+// ------ 开始界面相关 ------ //
+
+core.showStartAnimate(noAnimate, callback)
+重置所有内容并显示游戏标题界面。
+noAnimate如果为true则不会有淡入动画，callback为执行完毕的回调。
+
+
+core.hideStartAnimate(callback)
+淡出隐藏游戏标题界面，callback为执行完毕的回调。
+
+
+core.isPlaying()
+当前是否正在游戏中。
+
+
+core.clearStatus()
+清除所有的游戏状态和数据，包括状态栏的显示。
+
+// ------ 自动寻路、人物行走 ------ //
+
+core.stopAutomaticRoute()
+停止自动寻路的操作
+
+
+core.saveAndStopAutomaticRoute()
+保存剩下的寻路路线并停止自动寻路操作。主要用于打怪开门后继续寻路使用。
+
+
+core.continueAutomaticRoute()
+继续剩下的自动寻路操作。主要用于打怪开门后继续寻路使用。
+
+
+core.clearContinueAutomaticRoute()
+清空剩下的自动寻路操作。
+
+
+core.setAutomaticRoute(destX, destY, stepPostfix)
+尝试开始进行一个自动寻路。stepPostfix是鼠标拖动的路径。
+此函数将检测是否在寻路中（在则停止或双击瞬移），检测是否点击自己（转身或轻按），
+检测是否能单击瞬移，最后找寻自动寻路路线并开始寻路。
+
+
+core.setAutoHeroMove(steps)
+设置勇士的自动行走路线，并立刻开始行走。
+
+
+core.setHeroMoveInterval(callback)
+设置勇士行走动画。callback是每一步行走完毕后的回调。
+
+
+core.moveOneStep(x, y)
+每走完一步后执行的操作，被转发到了脚本编辑中。
+
+
+core.moveAction(callback)
+尝试执行单步行走。callback是执行完毕的回调。
+如果勇士面对的方向是noPass的，将直接触发事件并执行回调。
+
+
+core.moveHero(direction, callback)
+令勇士朝一个方向行走。如果设置了callback，则只会行走一步，并执行回调。
+否则，将一直朝该方向行走，直到core.status.heroStop为true为止。
+
+
+core.isMoving()
+当前是否正在处于行走状态
+
+
+core.waitHeroToStop(callback)
+停止勇士的行走，等待行动结束后，再异步执行回调。
+
+
+core.turnHero(direction)
+转向。如果设置了direction则会转到该方向，否则会右转。该函数会自动计入录像。
+
+
+core.moveDirectly(destX, destY)
+尝试瞬间移动到某点，被转发到了脚本编辑中。
+此函数返回非负值代表成功进行瞬移，返回值是省略的步数；如果返回-1则代表没有成功瞬移。
+
+
+core.tryMoveDirectly(destX, destY)
+尝试单击瞬移到某点。
+如果该点可被直接瞬间移动到，则直接瞬移到该点；否则尝试瞬移到相邻的上下左右点并行走一步。
+
+
+core.drawHero(status, offset)
+绘制勇士。
+status可选，为'stop','leftFoot'和'rightFoot'之一，不填或null默认是'stop'。
+offset可选，表示具体当前格子的偏移量。不填默认为0。
+此函数将重新计算地图的偏移量，调整窗口位置，绘制勇士和跟随者信息。
+
+// ------ 画布、位置、阻激夹域、显伤 ------ //
+
+core.setGameCanvasTranslate(canvas, x, y)
+设置某个画布的偏移量
+
+
+core.addGameCanvasTranslate(x, y)
+加减所有系统画布（ui和data除外）的偏移量。主要是被“画面震动”所使用。
+
+
+core.updateViewport()
+根据大地图的偏移量来更新窗口的视野范围。
+
+
+core.nextX(n) / core.nextY(n)
+获得勇士面对的第n个位置的横纵坐标。n可不填，默认为1。
+
+
+core.nearHero(x, y, n)
+判定某个点是否和勇士的距离不大于n。n可不填，默认为1。
+
+
+core.gatherFollowers()
+聚集所有的跟随者到勇士的位置。
+
+
+core.updateFollowers()
+更新跟随者们的坐标。
+
+
+core.updateCheckBlock(floorId)
+更新阻激夹域的信息，被转发到了脚本编辑中。
+
+
+core.checkBlock()
+检查勇士坐标点的阻激夹域信息。
+
+
+core.updateDamage(floorId, ctx)
+更新全地图的显伤。floorId可选，默认为当前楼层。
+ctx可选，为画布；如果不为空，则将会绘制到该画布上而不是damage层上。
+
+// ------ 录像相关 ------ //
+
+core.chooseReplayFile()
+弹出选择文件窗口，让用户选择录像文件。
+
+
+core.startReplay(list)
+开始播放一段录像。list为录像的操作数组。
+
+
+core.triggerReplay()
+播放或暂停录像，实际上是pauseReplay或resumeReplay之一。
+
+
+core.pauseReplay() / core.resumeReplay()
+暂停和继续录像播放。
+
+
+core.speedUpReplay() / core.speedDownReplay()
+加速和减速录像播放。
+
+
+core.setReplaySpeed(speed)
+直接设置录像回放速度。
+
+
+core.stopReplay(force)
+停止录像回放。如果force为true则强制停止。
+
+
+core.rewindReplay()
+回退一个录像节点。
+
+
+core.saveReplay() / core.bookReplay() / core.viewMapReplay()
+回放录像时的存档、查看怪物手册、浏览地图操作。
+
+
+core.isReplaying()
+当前是否正在录像播放中。
+
+
+core.registerReplayAction(name, func)
+注册一个自定义的录像行为。
+name：自定义名称，可用户注销使用。
+func：具体执行录像的函数，是一个函数体或者插件中的函数名。
+func需要接受action参数，代表录像回放时的当前操作行为。
+如果func返回true，则代表成功处理了此次操作，返回false代表没有进行处理。
+自己添加的录像项只能由数字、大小写、下划线线、冒号等符号组成，否则无法正常压缩和解压缩。
+对于自定义内容（比如中文文本或数组）请使用JSON.stringify再core.encodeBase64处理。
+请注意回放录像时的二次记录问题（即回放时录像会重新记录路线）。
+
+
+core.unregisterReplayAction(name)
+注销一个录像行为。此函数一般不应当被使用。
+
+// ------ 存读档相关 ------ //
+
+core.autosave(remoreLast)
+进行一个自动存档，实际上是加入到缓存之中。
+removeLast如果为true则会从路线中删除最后一项再存（打怪开门前的状态）。
+在事件处理中不允许调用本函数，如有需要请呼出存档页面。
+
+
+core.checkAutosave()
+将缓存的自动存档写入存储中。平均每五秒钟，或在窗口失去焦点时被执行。
+
+
+core.doSL(id, type)
+实际执行一个存读档事件。id为存档编号，自动存档为'autoSave'。
+type只能为'save', 'load', 'replayLoad'之一，代表存档、读档和从存档回放录像。
+
+
+core.syncSave(type) / core.syncLoad()
+向服务器同步存档，从服务器加载存档。type如果为'all'则会向服务器同步所有存档。
+
+
+core.saveData()
+获得要存档的内容，实际转发到了脚本编辑中。
+
+
+core.loadData(data, callback)
+实际执行一次读档行为，data为读取到的数据，callback为执行完毕的回调。
+实际转发到了脚本编辑中。
+
+
+core.getSave(index, callback)
+获得某个存档位的存档。index为存档编号，0代表自动存档。
+
+
+core.getSaves(ids, callback)
+获得若干个存档位的存档。ids为一个存档编号数组，0代表自动存档。
+
+
+core.getAllSaves(callback)
+获得全部的存档内容。目前仅被同步全部存档和下载全部存档所调用。
+
+
+core.getSaveIndexes(callback)
+刷新全部的存档信息，将哪些档位有存档的记录到core.saves.ids中。
+
+
+core.hasSave(index)
+判定某个存档位是否存在存档。index为存档编号，0代表自动存档。
+
+
+core.removeSave(index)
+删除某个存档。index为存档编号，0代表自动存档。
+
+
+// ------ 属性、状态、位置、变量等 ------ //
+
+core.setStatus(name, value)
+设置勇士当前的某个属性。
+
+
+core.addStatus(name, value)
+加减勇士当前的某个属性。等价于 core.setStatus(name, core.getStatus(name) + value)
+
+
+core.getStatus(name)
+获得勇士的某个原始属性值。
+
+
+core.getStatusOrDefault(status, name)
+尝试从status中获得某个原始属性值；如果status为null或不存在对应属性值则从勇士属性中获取。
+此项在伤害计算函数中使用较多，例如传递新的攻击和防御来计算临界和1防减伤。
+
+
+core.getRealStatus(name)
+获得勇士的某个计算属性值。该属性值是在加成buff之后得到的。
+该函数等价于 core.getStatus(name) * core.getBuff(name)
+
+
+core.getRealStatusOrDefault(status, name)
+尝试从status中获得某个原始属性值再进行增幅，如果不存在则获取勇士本身的计算属性值。
+
+
+core.setBuff(name, value)
+设置勇士的某个属性的增幅值。value为1代表无增幅。
+
+
+core.addBuff(name, value)
+增减勇士的某个属性的增幅值。等价于 core.setBuff(name, core.getBuff(name) + value)
+
+
+core.getBuff(name)
+获得勇士的某个属性的增幅值。默认值是1。
+
+
+core.setHeroLoc(name, value, noGather)
+设置勇士位置属性。name只能为'x', 'y'和'direction'之一。
+如果noGather为true，则不会聚集所有的跟随者。
+
+
+core.getHeroLoc(name)
+获得勇士的某个位置属性。如果name为null则直接返回core.status.hero.loc。
+
+
+core.getLvName(lv)
+获得某个等级对应的名称，其在全塔属性的levelUp中定义。如果不存在则返回原始数值。
+
+
+core.setFlag(name, value)
+设置某个自定义变量或flag。如果value为null则会调用core.removeFlag进行删除。
+
+
+core.addFlag(name, value)
+加减某个自定义的变量或flag。等价于 core.setFlag(name, core.getFlag(name, 0) + value)
+
+
+core.getFlag(name, defaultValue)
+获得某个自定义的变量或flag。如果该flag不存在（从未赋值过），则返回defaultValue值。
+
+
+core.hasFlag(name)
+判定是否拥有某个自定义变量或flag。等价于 !!core.getFlag(name, 0)
+
+
+core.removeFlag(name)
+删除一个自定义变量或flag。
+
+
+core.lockControl() / core.unlockControl()
+锁定和解锁控制。常常应用于事件处理。
+
+
+core.debug()
+开启调试模式。此模式下可以按住Ctrl进行穿墙。
+
+// ------ 天气，色调，音乐和音效 ------ //
+
+core.setWeather(type, level)
+设置当前的天气。type只能为'rain', 'snow'或'fog'，level为1-10之间代表强度信息。
+
+
+core.setCurtain(color, time, callback)
+更改画面色调。color为更改到的色调，是个三元或四元组；time为渐变时间，0代表立刻切换。
+
+
+core.screenFlash(color, time, times, callback)
+画面闪烁。color为色调，三元或四元组；time为单次闪烁时间，times为总闪烁次数。
+
+
+core.playBgm(bgm, startTime)
+播放一个bgm。startTime可以控制开始时间，不填默认为0。
+如果bgm不存在、不被支持，或当前不允许播放背景音乐，则会跳过。
+
+
+core.pauseBgm() / core.resumeBgm()
+暂停和恢复当前bgm的播放。
+
+
+core.triggerBgm()
+更改当前bgm的播放状态。
+
+
+core.playSound(sound) / core.stopSound()
+播放一个音效，停止全部音效。
+如果sound不存在、不被支持，或当前不允许播放音效，则会忽略。
+
+
+core.checkBgm()
+检查bgm的状态。
+有的时候，刚打开页面时，浏览器是不允许自动播放标题界面bgm的，一定要经过一次用户操作行为。
+这时候我们可以给开始按钮增加core.checkBgm()，如果之前没有成功播放则重新播放。
+
+// ------ 状态栏和工具栏相关 ------ //
+
+core.clearStatusBar()
+清空状态栏的数据。
+
+
+core.updateStatusBar()
+更新状态栏，被转发到了脚本编辑中。此函数还会根据是否在回放来设置工具栏的图标。
+
+
+core.showStatusBar() / core.hideStatusBar(showToolbox)
+显示和隐藏状态栏。
+如果showToolbox为true，则在竖屏模式下不隐藏工具栏，方便手机存读档操作。
+
+
+core.updateHeroIcon()
+更新状态栏上的勇士图标。
+
+
+core.updateGlobalAttribute()
+更新全局属性，例如状态栏的背景图等。
+
+
+core.setToolbarButton(useButtom)
+设置工具栏是否是拓展键盘。
+
+// ------ resize 相关 ------ //
+
+core.registerResize(name, func)
+注册一个resize函数。
+name为自定义名称，可供注销使用。
+func可以是一个函数，或插件中的函数名，可以接受一个obj作为参数。
+具体详见resize函数。
+
+
+core.unregisterResize(name)
+注销一个resize函数。
+
+
+core.resize()
+屏幕分辨率改变后的重新自适应。
+此函数将根据当前的屏幕分辨率信息，生成一个obj，并传入各个注册好的resize函数中执行。
+
+
+
+
+------------------------------------ [enemys.js] ------------------------------------
+
+enemys.js中定义了一系列和怪物相关的API函数。
+
+
+
+
+core.hasSpecial(special, test)
+判断是否含有某个特殊属性。test为要检查的特殊属性编号。
+special为要测试的内容，允许接收如下类型参数：
+ - 一个数字：将直接和test进行判等。
+ - 一个数组：将检查test是否在该数组之中存在。
+ - 一个怪物信息：将检查test是否在该怪物的特殊属性中存在
+ - 一个字符串：视为怪物ID，将检查该怪物的特殊属性
+
+
+core.getSpecials()
+获得所有特殊属性的列表。实际上被转发到了脚本编辑中。
+
+
+core.getSpecialText(enemy)
+获得某个怪物的全部特殊属性名称。enemy可以是怪物信息或怪物ID。
+将返回一个数组，每一项是该怪物所拥有的一个特殊属性的名称。
+
+
+core.getSpecialHint(enemy, special)
+获得怪物的某个特殊属性的描述。enemy可以是怪物信息或怪物ID，special为该特殊属性编号。
+
+
+core.canBattle(enemy, x, y, floorId)
+判定当前能否战胜某个怪物。
+enemy可以是怪物信息或怪物ID，x,y,floorId为当前坐标和楼层。（下同）
+能战胜返回true，不能战胜返回false。
+
+
+core.getDamage(enemy, x, y, floorId)
+获得某个怪物的全部伤害值。
+如果没有破防或无法战斗则返回null，否则返回具体的伤害值。
+
+
+core.getExtraDamage(enemy, x, y, floorId)
+获得某个怪物的额外伤害值（不可被魔防减伤）。
+目前暂时只包含了仇恨和固伤两者，如有需要可复写该函数。
+
+
+core.getDamageString(enemy, x, y, floorId)
+获得某个怪物伤害字符串和颜色信息，以便于在地图上绘制显伤。
+
+
+core.nextCriticals(enemy, number, x, y, floorId)
+获得接下来的N个临界值和临界减伤。enemy可以是怪物信息或怪物ID，x,y,floorId为当前坐标和楼层。
+number为要计算的临界值数量，不填默认为1。
+如果全塔属性中的useLoop开关被开启，则将使用循环法或二分法计算临界，否则使用回合法计算临界。
+返回一个二维数组 [[x1,y1],[x2,y2],...] 表示接下来的每个临界值和减伤值。
+
+
+core.getDefDamage(enemy, k, x, y, floorId)
+获得某个怪物的k防减伤值。k可不填默认为1。
+
+
+core.getEnemyInfo(enemy, hero, x, y, floorId)
+获得某个怪物的实际计算时的属性。该函数实际被转发到了脚本编辑中。
+hero可为null或一个对象，具体将使用core.getRealStatusOrDefault(hero, "atk")来获得攻击力数值。
+该函数应当返回一个对象，记录了怪物的实际计算时的属性。
+
+
+core.getDamageInfo(enemy, hero, x, y, floorId)
+获得某个怪物的战斗信息。该函数实际被转发到了脚本编辑中。
+hero可为null或一个对象，具体将使用core.getRealStatusOrDefault(hero, "atk")来获得攻击力数值。
+如果该函数返回null，则代表不可战斗（如没有破防，或无敌等）。
+否则，该函数应该返回一个对象，记录了战斗伤害信息，如战斗回合数等。
+从V2.5.5开始，该函数也允许直接返回一个数字，代表战斗伤害值，此时回合数将视为0。
+
+
+core.updateEnemys()
+更新怪物数据。该函数实际被转发到了脚本编辑中。详见文档-事件-更新怪物数据。
+
+
+core.getCurrentEnemys(floorId)
+获得某个楼层不重复的怪物信息，floorId不填默认为当前楼层。该函数会被怪物手册所调用。
+该函数将返回一个列表，每一项都是一个不同的怪物，按照伤害值从小到大排序。
+另外值得注意的是，如果设置了某个怪物的displayIdInBook，则会返回对应的怪物。
+
+
+core.hasEnemyLeft(enemyId, floorId)
+检查某个楼层是否还有剩余的（指定）怪物。
+floorId为楼层ID，可忽略表示当前楼层。也可以传数组如["MT0","MT1"]同时检测多个楼层。
+enemyId如果不填或null则检查是否剩余任何怪物，否则只检查是否剩余指定的某类怪物。
+
+
+
+
+------------------------------------ [events.js] ------------------------------------
+
+events.js将处理所有和事件相关的操作，主要分为五个部分：
+- 游戏的开始和结束
+- 系统事件的处理
+- 自定义事件的处理
+- 点击状态栏图标所进行的操作
+- 一些具体事件的执行内容
+
+
+
+
+// ------ 游戏的开始和结束 ------ //
+
+core.resetGame(hero, hard, floorId, maps, values)
+重置整个游戏。该函数实际被转发到了脚本编辑中。
+
+
+core.startGame(hard, seed, route, callback)
+开始新游戏。
+hard为难度字符串，会被设置为core.status.hard。
+seed为开始时要设置的的种子，route为要开始播放的录像，callback为回调函数。
+该函数将重置整个游戏，调用setInitData，执行startText事件，上传游戏人数统计信息等。
+
+
+core.setInitData()
+根据难度分歧来初始化难度，包括设置flag:hard，设置初始属性等。
+该函数实际被转发到了脚本编辑中。
+
+
+core.win(reason, norank)
+游戏胜利，reason为结局名，norank如果为真则该结局不计入榜单。
+该函数实际被转发到了脚本编辑中。
+
+
+core.lose(reason)
+游戏失败，reason为结局名。该函数实际被转发到了脚本编辑中。
+
+
+core.gameOver(ending, fromReplay, norank)
+游戏结束。ending为获胜结局名，null代表失败；fromReplay标识是否是录像触发的。
+此函数将询问是否上传成绩（如果ending不是null），是否下载录像等，并重新开始。
+
+
+core.restart()
+重新开始游戏。本质上就是播放标题界面的BGM并调用showStartAnimate。
+
+
+core.confirmRestart()
+确认用户是否需要重新开始。
+
+// ------ 系统事件处理 ------ //
+
+core.registerSystemEvent(type, func)
+注册一个系统事件，即通过图块的默认触发器所触发的事件。
+type为一个要注册的事件类型，func为要执行的函数体或插件中的函数名。
+func需要接受(data, callback)作为参数，分别是触发点的图块信息，和执行完毕时的回调。
+如果注册一个已经存在的系统事件，比如openDoor，则会覆盖系统的默认函数。
+
+
+core.unregisterSystemEvent(type)
+注销一个系统事件。type是上面你注册的事件类型。
+
+
+core.doSystemEvent(type, data, callback)
+执行一个系统事件。type为事件类型，data为该事件点的图块信息，callback为执行完毕的回调。
+
+
+core.battle(id, x, y, force, callback)
+和怪物进行战斗。
+id为怪物的ID，x和y为怪物坐标，force如果为真将强制战斗，callback为执行完毕的回调。
+如果填写了怪物坐标，则会删除对应点的图块并执行该点战后事件。
+如果是在事件流的执行过程中调用此函数，则不会进行自动存档，且会强制战斗。
+
+
+core.beforeBattle(enemyId, x, y)
+战前事件。实际被转发到了脚本编辑中，可以在这里加上一些战前特效。
+此函数在“检测能否战斗和自动存档”【之后】执行。
+如果需要更早的战前事件，请在插件中覆重写 core.events.doSystemEvent 函数。
+此函数返回true则将继续本次战斗，返回false将不再战斗。
+
+
+core.afterBattle(enemyId, x, y, callback)
+战后事件，将执行扣血、加金币经验、特殊属性处理、战后事件处理等操作。
+实际被转发到了脚本编辑中。
+
+
+core.openDoor(x, y, needKey, callback)
+尝试开一个门。x和y为门的坐标，needKey表示是否需要钥匙，callback为执行完毕的回调。
+如果不是一个有效的门，需要钥匙且未持有等，均会忽略此事件并直接执行callback。
+
+
+core.afterOpenDoor(doorId, x, y, callback)
+开完一个门后执行的事件，实际被转发到了脚本编辑中。
+
+
+core.getItem(id, num, x, y, callback)
+获得若干个道具。itemId为道具ID，itemNum为获得的道具个数，不填默认为1。
+x和y为道具点的坐标，如果设置则会擦除地图上的该点。
+
+
+core.afterGetItem(id, x, y, callback)
+获得一个道具后执行的事件，实际被转发到了脚本编辑中。
+
+
+core.getNextItem(noRoute)
+轻按，即获得面对的道具。如果noRoute为真则这个轻按行为不会计入录像。
+
+
+core.changeFloor(floorId, stair, heroLoc, time, callback, fromLoad)
+楼层切换。floorId为目标楼层ID，stair为是什么楼梯，heroLoc为目标点坐标。
+time为切换时间，callback为切换完毕的回调，fromLoad标志是否是从读档造成的切换。
+floorId也可以填":before"和":next"表示前一层和后一层。
+heroLoc为{"x": 0, "y": 0, "direction": "up"}的形式。不存在则从勇士位置取。
+如果stair不为null，则会在该楼层中找对应的图块作为目标点的坐标并覆盖heroLoc。
+一般设置的是"upFloor"和"downFloor"，但也可以用任何其他的图块ID。
+
+
+core.changingFloor(floorId, heroLoc, fromLoad)
+正在执行楼层切换中执行的操作，实际被转发到了脚本编辑中。
+
+
+core.hasVisitedFloor(floorId)
+是否曾经到达过某一层。
+
+
+core.visitFloor(floorId)
+标记曾经到达了某一层。
+
+
+core.passNet(data)
+执行一个路障处理。这里只有毒衰咒网的处理，血网被移动到了updateCheckBlock中。
+
+
+core.pushBox(data)
+执行一个推箱子事件。
+
+
+core.afterPushBox()
+推箱子之后触发的事件，实际被转发到了脚本编辑中。
+
+
+core.changeLight(id, x, y)
+踩灯后的事件。
+
+// ------ 自定义事件的处理 ------ //
+
+core.registerEvent(type, func)
+注册一个自定义事件。type为事件名，func为执行事件的函数体或插件中的函数名。
+func可以接受(data, x, y, prefix)参数，其中data为事件内容，x和y为该点坐标，prefix为该点前缀。
+同名注册的事件将进行覆盖。
+请记得在自定义处理事件完毕后调用core.doAction()再继续执行下一个事件！
+
+
+core.unregisterEvent(type)
+注销一个自定义事件。
+
+
+core.doEvent(data, x, y, prefix)
+执行一个自定义事件。data为事件内容，将根据data.type去注册的事件列表中查找对应的执行函数。
+x和y为该点坐标，prefix为该点前缀。执行事件时也会把(data, x, y, prefix)传入执行函数。
+
+
+core.setEvents(list, x, y, callback)
+设置自定义事件的执行列表，坐标和回调函数。
+
+
+core.startEvents(list, x, y, callback)
+开始执行一系列的自定义事件。list为事件列表，x和y为事件坐标，callback为执行完毕的回调。
+此函数将调用core.setEvents，然后停止勇士，再执行core.doAction()。
+
+
+core.doAction()
+执行下一个自定义事件。
+此函数将检测事件列表是否全部执行完毕，如果是则执行回调函数。
+否则，将从事件列表中弹出下一个事件，并调用core.doEvent进行执行。
+
+
+core.insertAction(action, x, y, callback, addToLast)
+向当前的事件列表中插入一个或多个事件并执行。
+如果当前并不是在事件执行流中，则会调用core.startEvents()开始执行事件，否则仅仅执行插入操作。
+action为要插入的事件，可以是一个单独的事件，或者是一个事件列表。
+x,y,callback如果设置了且不为null，则会覆盖当前的坐标和回调函数。
+addToLast如果为真，则会插入到事件执行列表的尾部，否则是插入到执行列表的头部。
+
+
+core.getCommonEvent(name)
+根据名称获得某个公共事件内容。
+
+
+core.recoverEvents(data)
+恢复事件现场。一般用于呼出怪物手册、呼出存读档页面等时，恢复事件执行流。
+
+// ------ 点击状态栏图标时执行的一些操作 ------ //
+
+core.openBook(fromUserAction)
+尝试打开怪物手册。fromUserAction标志是否是从用户的行为触发，如按键或点击状态栏。（下同）
+不建议复写此函数，否则【呼出怪物手册】事件会出问题。
+
+
+core.useFly(fromUserAction)
+尝试使用楼传器。可以安全的复写此函数，参见文档-个性化-覆盖楼传事件。
+
+
+core.flyTo(toId, callback)
+尝试飞行到某个楼层，被转发到了脚本编辑中。
+如果此函数返回true代表成功进行了飞行，false代表不能进行飞行。
+
+
+core.openEquipbox(fromUserAction) / core.openToolbox(fromUserAction)
+尝试打开道具栏和装备栏。可以安全复写这两个函数。
+
+
+core.openQuickShop(fromUserAction) / core.openKeyBoard(fromUserAction)
+尝试打开快捷商店和虚拟键盘。可以安全复写这两个函数。
+
+
+core.save(fromUserAction) / core.load(fromUserAction)
+尝试打开存读档页面。
+不建议复写这两个函数，否则【呼出存读档页面】事件会出问题。
+
+
+core.openSettings(fromUserAction)
+尝试打开系统菜单。不建议复写此函数。
+
+
+// ------ 一些具体事件的执行内容 ------ //
+
+core.hasAsync()
+当前是否存在未执行完毕的异步事件。请注意正在播放的动画也算异步事件。
+
+
+core.follow(name) / core.unfollow(name)
+跟随勇士/取消跟随。name为行走图名称。
+在取消跟随时如果指定了name，则会从跟随列表中选取一个该行走图取消，否则取消所有跟随。
+跟随和取消跟随都会调用core.gatherFollowers()来聚集所有的跟随者。
+
+
+core.setValue(name, value, prefix) / core.addValue(name, value, prefix)
+设置/增减某个数值。name可以是status:xxx，item:xxx或flag:xxx。
+value可以是一个表达式，将调用core.calValue()计算。prefix为前缀，独立开关使用。
+
+
+core.doEffect(effect, need, times)
+执行一个effect操作。该函数目前仅被全局商店的status:xxx+=yyy所调用。
+
+
+core.setFloorInfo(name, values, floorId, prefix)
+设置某层楼的楼层属性。
+
+
+core.setGlobalAttribute(name, value)
+设置一个全局属性，如边框颜色等。
+
+
+core.setGlobalFlag(name, value)
+设置一个全局开关，如enableXXX等。
+如果需要设置一个全局数值如红宝石数值，可以直接简单的修改core.values，因此没有单独列出函数。
+
+
+core.closeDoor(x, y, id, callback)
+执行一个关门事件。如果不是一个合法的门，或者该点不为空地，则会忽略本事件。
+
+
+core.showImage(code, image, sloc, loc, opacityVal, time, callback)
+显示一张图片。code为图片编号，image为图片内容或图片名。
+sloc为[x,y,w,h]形式，表示在原始图片上裁剪的区域，也可直接设为null表示整张图片。
+loc为[x,y,w,h]形式，表示在界面上绘制的位置和大小，w和h可忽略表示使用绘制大小。
+opacityVal为绘制的不透明度，time为淡入时间。
+此函数将创建一个画布，其z-index是100+code，即图片编号为1则是101，编号50则是150。
+请注意，curtain层的z-index是125，UI层的z-index是140；因此可以通过图片编号来调整覆盖关系。
+
+
+core.hideImage(code, time, callback)
+隐藏一张图片。code为图片编号，time为淡出时间。
+
+
+core.moveImage(code, to, opacityVal, time, callback)
+移动一张图片。code为图片编号，to为[x,y]表示目标位置，opacityVal目标不透明度，time为移动时间。
+
+
+core.showGif(name, x, y)
+绘制一张gif图片或取消所有绘制内容。如果name不设置则视为取消。x和y为左上角像素坐标。
+
+
+core.setVolume(value, time, callback)
+设置音量。value为目标音量大小，在0到1之间。time为音量渐变的时间。
+
+
+core.vibrate(time, callback)
+画面震动。time为震动时间。
+请注意，画面震动时间必须是500的倍数，系统也会自动把time调整为上整的500倍数值。
+
+
+core.eventMoveHero(steps, time, callback)
+使用事件移动勇士。time为每步的移动时间。
+steps为移动数组，可以接受'up','down','left','right','forward'和'backward'项。
+使用事件移动勇士将不会触发任何地图上的事件。
+
+
+core.jumpHero(ex, ey, time, callback)
+跳跃勇士。ex和ey为目标点的坐标，可以为null表示原地跳跃。time为总跳跃时间。
+
+
+core.openShop(shopId, needVisited)
+打开一个全局商店。needVisited表示是否需要该商店原本就是启用状态。
+如果该商店对应的实际上是一个全局事件，则会直接插入并执行。
+
+
+core.disableQuickShop(shopId)
+禁用一个全局商店，即把一个商店从启用变成禁用状态。
+
+
+core.canUseQuickShop(shopId)
+当前能否使用某个全局商店，实际被转发到了脚本编辑中。
+如果此函数返回null则表示可以使用，返回一个字符串表示不可以，该字符串表示不可以的原因。
+
+
+core.setHeroIcon(name, noDraw)
+设置勇士的行走图。
+name为行走图名称，noDraw如果为真则不会调用core.drawHero()函数进行刷新。
+
+
+core.checkLvUp()
+检查升级事件。该函数将判定当前是否升级（或连续升级），然后执行升级事件。
+
+
+core.tryUseItem(itemId)
+尝试使用一个道具。
+对于怪物手册和楼传器，将分别调用core.openBook()和core.useFly()函数。
+对于中心对称飞行器，则会调用core.drawCenterFly()函数。
+对于其他的道具，将检查是否拥有，能否使用，并且进行使用。
+
+
+core.afterUseBomb()
+使用炸弹或圣锤后的事件。实际被转发到了脚本编辑中。
+
+
+
+
+------------------------------------ [icons.js] ------------------------------------
+
+icons.js主要是负责素材相关信息，比如某个素材在对应的图片上的位置。
+
+
+
+
+core.getClsFromId(id)
+根据某个素材的ID获得该素材的cls
+
+
+core.getTilesetOffset(id)
+根据某个素材来获得对应的tileset和坐标信息。
+如果该素材不是tileset，则返回null。
+
+
+
+
+------------------------------------ [items.js] ------------------------------------
+
+items.js主要负责一切和道具相关的内容。
+
+
+
+
+core.getItemEffect(itemId, itemNum)
+即捡即用类的道具获得时的效果。实际对应道具图块属性中的itemEffect框。
+
+
+core.getItemEffectTip(itemId)
+即捡即用类的道具获得时的额外提示，比如“，攻击+100”。
+实际对应道具图块属性中的itemEffectTip框。
+
+
+core.useItem(itemId, noRoute, callback)
+尝试使用一个道具。实际对应道具图块属性中的useItemEffect框。
+此函数也会调用一遍core.canUseItem()，如果无法使用将直接返回。
+noRoute如果为真，则这次使用道具的过程不会被计入录像。
+使用道具完毕后，对于消耗道具将自动扣除，永久道具不会扣除。
+
+
+core.canUseItem(itemId)
+当前能否使用某个道具。
+有些系统道具如破炸和上下楼器等，会在计算出目标点的坐标后存入core.status.event.ui。
+使用道具时将直接从core.status.event.ui调用，不会重新计算。
+
+
+core.itemCount(itemId)
+获得某个道具的个数。
+
+
+core.hasItem(itemId)
+当前是否拥有某个道具。等价于 core.itemCount(itemId) > 0
+请注意，装备上的装备不视为拥有该道具，即core.hasEquip()和core.hasItem()是完全不同的。
+
+
+core.hasEquip(itemId)
+当前是否装备上某个装备。
+请注意，装备上的装备不视为拥有该道具，即core.hasEquip()和core.hasItem()是完全不同的。
+
+
+core.getEquip(equipType)
+获得某个装备位的当前装备。equipType为装备类型，从0开始。
+如果该装备位没有装备则返回null，否则返回当前装备的ID。
+
+
+core.setItem(itemId, itemNum)
+设置某个道具的个数。
+
+
+core.addItem(itemId, itemNum)
+增减某个道具的个数，itemNum可不填默认为1。
+
+
+core.getEquipTypeByName(name)
+根据装备位名称来找到一个空的装备孔，适用于多重装备。
+如果没有一个装备孔是该装备名称，则返回-1。
+
+
+core.getEquipTypeById(equipId)
+获得某个装备的装备类型。
+如果其type写的是装备名（多重装备），则调用core.getEquipTypeByName()函数。
+
+
+core.canEquip(equipId, hint)
+当前能否穿上某个装备。如果hint为真，则不可装备时会气泡提示原因。
+
+
+core.loadEquip(equipId, callback)
+穿上某个装备。
+
+
+core.unloadEquip(equipType, callback)
+脱下某个装备孔的装备。
+
+
+core.compareEquipment(compareEquipId, beComparedEquipId)
+比较两个套装的差异。
+此函数将对所有的勇士属性包括生命魔力攻防魔防金币等进行比较。
+如果存在差异的，将作为一个对象返回其差异内容。
+
+
+core.quickSaveEquip(index)
+保存当前套装。index为保存的套装编号。
+
+
+core.quickLoadEquip()
+读取当前套装。index为读取的套装编号。
+```
+
+## loader.js
+
+loader.js主要负责资源加载相关的内容。
+
+```text
+core.loadImage(imgName, callback)
+从 project/images/ 中加载一张图片。imgName为图片名。
+callback为执行完毕的回调函数，接收(imgName, image)即图片名和图片内容作为参数。
+如果图片不存在或加载失败则会在控制台打出一条错误日志，不会执行回调。
+
+
+core.loadImages(names, toSave, callback)
+从 project/images/ 中加载若干张图片。
+names为一个图片名的列表，toSave为加载并存到的对象。
+callback为全部加载完毕执行的回调。
+
+
+core.loadOneMusic(name)
+从 project/sounds/ 或第三方中加载一个音乐，并存入core.material.bgms中。name为音乐名。
+
+
+core.loadOneSound(name)
+从 project/sounds/ 中加载一个音效，并存入core.material.sounds中。name为音效名。
+
+
+core.loadBgm(name)
+预加载一个bgm并加入缓存列表core.musicStatus.cachedBgms。
+此函数将会检查bgm的缓存，预加载和静音播放。
+如果缓存列表溢出(core.musicStatus.cacheBgmCount)则通过LRU算法选择一个bgm并调用core.freeBgm()。
+
+
+core.freeBgm(name)
+释放一个bgm的内存并移出缓存列表。如果该bgm正在播放则也会立刻停止。
+
+
+
+
+------------------------------------ [maps.js] ------------------------------------
+
+maps.js负责一切和地图相关的处理内容，包括如下几个方面：
+- 地图的初始化，保存和读取，地图数组的生成
+- 是否可移动或瞬间移动的判定
+- 地图的绘制
+- 获得某个点的图块信息
+- 启用和禁用图块，改变图块
+- 移动/跳跃图块，淡入淡出图块
+- 全局动画控制，动画的绘制
+
+
+
+
+// ------ 地图的初始化，保存和读取，地图数组的生成 ------ //
+
+core.loadFloor(floorId, map)
+从楼层或者存档中生成core.status.maps的内容。
+map为存档信息，如果某项在map中不存在则会从core.floors中读取。
+
+
+core.getNumberById(id)
+给定一个图块ID，找到对应的数字。
+
+
+core.initBlock(x, y, id, addInfo, eventFloor)
+给定一个数字，初始化一个图块信息。
+x和y为坐标，id为数字或者可以:t或:f结尾表示初始是启用还是禁用状态。
+addInfo如果为true则会填充上图块的默认信息，比如给怪物添加battle触发器。
+eventFloor如果设置为某个楼层信息，则会填充上该点的自定义或楼层切换事件。
+
+
+core.compressMap(mapArr, floorId)
+压缩地图。mapArr为要压缩的二维数组，floorId为对应的楼层。
+此函数将把mapArr和对应的楼层中的数组进行比较，并只取差异值进行存储。
+通过这种压缩地图的方式，不仅节省了存档空间，还支持了任意修改地图的接档。
+
+
+core.decompressMap(mapArr, floorId)
+解压缩地图。mapArr为压缩后的地图，floorId为对应的楼层。
+此函数返回解压后的二维数组。
+
+
+core.saveMap(floorId)
+将某层楼的数据生成存档所保存的内容。在core.saveData()中被调用。
+
+
+core.loadMap(data, floorId)
+从data中读取楼层数据，并调用core.loadFloor()进行初始化。
+
+
+core.resizeMap(floorId)
+根据某层楼的地图大小来调整大地图的画布大小。floorId可为null表示当前层。
+
+
+core.getMapArray(floorId, showDisable)
+生成某层楼的二维数组。floorId可不填代表当前楼层。
+showDisable若为真，则对于禁用的点会加上:f表示，否则视为0。
+
+
+core.getMapBlocksObj(floorId, showDisable)
+以x,y的形式返回每个点的图块信息。floorId可不填表示当前楼层。
+此函数将返回 {"0,0": {...}, "0,1": {...}} 这样的结构，其中内部为对应点的block信息。
+
+
+core.getBgMapArray(floorId, noCache)
+获得某层楼的背景层的二维数组。floorId可不填表示当前楼层。
+如果noCache为真则重新从剧本中读取而不使用缓存数据。
+
+
+core.getFgMapArray(floorId, noCache)
+获得某层楼的前景层的二维数组。floorId可不填表示当前楼层。
+如果noCache为真则重新从剧本中读取而不使用缓存数据。
+
+
+core.getBgNumber(x, y, floorId, noCache)
+获得某层楼的背景层中某个点的数字。floorId可不填表示当前楼层。
+如果noCache为真则重新从剧本中读取而不使用缓存数据。
+本函数实际等价于 core.getBgMapArray(floorId, noCache)[y][x]
+
+
+core.getBgNumber(x, y, floorId, noCache)
+获得某层楼的前景层中某个点的数字。参数和方法同上。
+
+// ------ 是否可移动或瞬间移动的判定 ------ //
+
+core.generateMovableArray(floorId, x, y, direction)
+生成全图或某个点的可通行方向数组。floorId为楼层Id，可不填默认为当前点。
+这里的可通行方向数组，指的是["up","down","left","right"]中的一个或多个组成的数组。
+ - 如果不设置x和y，则会返回一个三维数组，其中每个点都是一个该点可通行方向的数组。
+ - 如果设置了x和y但没有设置direction，则只会返回该点的可通行方向数组，
+ - 如果设置了x和y以及direction，则会判定direction是否在该点可通行方向数组中，并返回true或false。
+可以使用core.inArray()来判定某个方向是否在可通行方向数组中。
+
+
+core.canMoveHero(x, y, direction, floorId)
+某个点是否可朝某个方向移动。x和y可选，不填或为null则默认为勇士当前点。
+direction可选，不填或为null则默认勇士当前朝向。floorId不填则默认为当前楼层。
+此函数将直接调用 core.generateMovableArray() 进行判定。
+
+
+core.canMoveDirectly(destX, destY)
+当前能否瞬间移动到某个点。
+如果可以瞬移则返回非负数，其值为该次瞬移所少走的步数；如果不能瞬移则返回-1。
+
+
+core.automaticRoute(destX, destY)
+找寻到目标点的一条自动寻路路径。
+
+// ------ 绘制地图相关 ------ //
+
+core.drawBlock(block, animate)
+重新绘制一个图块，block为图块信息。
+如果animate不为null则代表是通过全局动画的绘制，其值为当前的帧数。
+
+
+core.generateGroundPattern(floorId)
+生成某个楼层的地板信息。floorId不填默认为当前楼层。
+该函数可被怪物手册、对话框帧动画等地方使用。
+
+
+core.drawMap(floorId, callback)
+绘制某层楼的地图。floorId为目标楼层ID，可不填表示当前楼层。
+此函数会将core.status.floorId设置为floorId，并设置core.status.thisMap。
+将依次调用core.drawBg(), core.drawEvents()和core.drawFg()函数，最后绘制勇士和更新地图显伤。
+
+
+core.drawBg(floorId, ctx)
+绘制背景层。floorId为目标楼层ID，可不填表示当前楼层。
+如果ctx不为null，则背景层将绘制在该画布上而不是bg层上（drawThumbnail使用）。
+可以通过复写该函数，调整_drawFloorImages和_drawBgFgMap的顺序来调整背景图块和贴图的遮挡顺序。
+
+
+core.drawEvents(floorId, blocks, ctx)
+绘制事件层。floorId为目标楼层ID，可不填表示当前楼层。
+block表示要绘制的图块列表，可不填使用当前楼层的图块列表。
+如果ctx不为null，则背景层将绘制在该画布上而不是event层上（drawThumbnail使用）。
+
+
+core.drawFg(floorId, ctx)
+绘制前景层。floorId为目标楼层ID，可不填表示当前楼层。
+如果ctx不为null，则背景层将绘制在该画布上而不是fg层上（drawThumbnail使用）。
+可以通过复写该函数，调整_drawFloorImages和_drawBgFgMap的顺序来调整前景图块和贴图的遮挡顺序。
+
+
+core.drawThumbnail(floorId, blocks, options, toDraw)
+绘制一个楼层的缩略图。floorId为目标楼层ID，可不填表示当前楼层。
+block表示要绘制的图块列表，可不填使用当前楼层的图块列表。
+options为绘制选项（可为null），包括：
+    heroLoc: 勇士位置；heroIcon：勇士图标（默认当前勇士）；damage：是否绘制显伤；
+    flags：当前的flags（在存读档时使用）
+toDraw为要绘制到的信息（可为null，或为一个画布名），包括：
+    ctx：要绘制到的画布（名）；x,y：起点横纵坐标（默认0）；size：绘制大小（默认416/480）；
+    all：是否绘制全图（默认false）；centerX,centerY：截取中心（默认为地图正中心）
+
+// ------ 获得某个点的图块信息 ------ //
+
+core.noPass(x, y, floorId)
+判定某个点是否有noPass的图块。
+
+
+core.npcExists(x, y, floorId)
+判定某个点是否有NPC的存在。
+
+
+core.terrainExists(x, y, id, floorId)
+判定某个点是否有（指定的）地形存在。
+如果id为null，则只要存在terrains即为真，否则还会判定对应点的ID。
+
+
+core.stairExists(x, y, floorId)
+判定某个点是否存在楼梯。
+
+
+core.nearStair()
+判定当前勇士是否在楼梯上或旁边（距离不超过1）。
+
+
+core.enemyExists(x, y, id, floorId)
+判定某个点是否有（指定的）怪物存在。
+如果id为null，则只要存在怪物即为真，否则还会判定对应点的怪物ID。
+请注意，如果需要判定某个楼层是否存在怪物请使用core.hasEnemyLeft()函数。
+
+
+core.getBlock(x, y, floorId, showDisable)
+获得某个点的当前图块信息。x和y为坐标；floorId为楼层ID，可忽略或null表示当前楼层。
+showDisable如果为true，则对于禁用的点和事件也会进行返回。
+如果该点不存在图块，则返回null。
+否则，返回值如下： {"index": xxx, "block": xxx}
+其中index为该点在该楼层blocks数组中的索引，block为该图块实际内容。
+
+
+core.getBlockId(x, y, floorId, showDisable)
+获得某个点的图块ID。如果该点不存在图块则返回null。
+
+
+core.getBlockCls(x, y, floorId, showDisable)
+获得某个点的图块类型。如果该点不存在图块则返回null。
+
+
+core.getBlockInfo(block)
+根据某个的图块信息获得其详细的素材信息。
+如果参数block为字符串，则视为图块ID；如果参数为数字，则视为图块的数字。
+此函数将返回一个非常详尽的素材信息，目前包括如下几项：
+number：素材数字；id：素材id；cls：素材类型；image：素材所在的素材图片；animate：素材的帧数。
+posX, posY：素材在该素材图片上的位置；height：素材的高度；faceIds：NPC朝向记录。
+
+
+core.searchBlock(id, floorId, showDisable)
+搜索一个图块出现过的所有位置。id为图块ID，也可以传入图块的数字。
+id支持通配符搜索，比如"*Door"可以搜索所有的门，"unknownEvent*"可以所有所有的unknownEvent。
+floorId为要搜索的楼层，可以是一个楼层ID，或者一个楼层数组。如果floorId不填则只搜索当前楼层。
+showDisable如果为真，则对于禁用的图块也会返回。
+此函数将返回一个数组，每一项为一个搜索到的结果：
+{"floorId": ..., "index": ..., "block": {...}, "x": ..., "y": ...}
+即包含该图块所在的楼层ID，在该楼层的blocks数组的索引，图块内容，和横纵坐标。
+
+
+// ------ 启用和禁用图块，改变图块 ------ //
+
+core.showBlock(x, y, floorId)
+将某个点从禁用变成启用状态。floorId可不填或null表示当前楼层。
+
+
+core.hideBlock(x, y, floorId)
+将某个点从启用变成禁用状态，但不会对其进行删除。floorId可不填或null表示当前楼层。
+此函数不会实际将该块从地图中进行删除，而是将该点设置为禁用，以供以后可能的启用事件。
+
+
+core.removeBlock(x, y, floorId)
+将从启用变成禁用状态，并尽可能将其从地图上删除。
+和hideBlock相比，如果该点不存在自定义事件（比如门或普通的怪物），则将直接从地图中删除。
+如果存在自定义事件，则简单的禁用它，以供以后可能的启用事件。
+
+
+core.removeBlockById(index, floorId)
+根据索引从地图的block数组中尽可能删除一个图块。floorId可不填或null表示当前楼层。
+
+
+core.removeBlockByIds(floorId, ids)
+根据索引数组从地图的block数组中尽可能删除一系列图块。floorId可不填或null表示当前楼层。
+
+
+core.canRemoveBlock(block, floorId)
+判定当前能否完全删除某个图块。floorId可不填或null表示当前楼层。
+如果该点存在自定义事件，或者是重生怪，则不可进行删除。
+
+
+core.showBgFgMap(name, loc, floorId, callback)
+显示某层楼中某个背景/前景层的图块。name只能为'bg'或'fg'表示背景或前景层。
+loc为该点坐标，floorId可不填默认为当前楼层。callback为执行完毕的回调。
+
+
+core.hideBgFgMap(name, loc, floorId, callback)
+隐藏某层楼中某个背景/前景层的图块。name只能为'bg'或'fg'表示背景或前景层。
+loc为该点坐标，floorId可不填默认为当前楼层。callback为执行完毕的回调。
+
+
+core.showFloorImage(loc, floorId, callback)
+显示某层楼中的某个楼层贴图。loc为该贴图的左上角坐标。floorId可省略表示当前楼层。
+
+
+core.hideFloorImage(loc, floorId, callback)
+隐藏某层楼中的某个楼层贴图。loc为该贴图的左上角坐标。floorId可省略表示当前楼层。
+
+
+core.setBlock(number, x, y, floorId)
+改变某个楼层的某个图块。
+number为要改变到的数字，也可以传入图块id（将调用core.getNumberById()来获得数字）。
+x,y和floorId为目标点坐标和楼层，可忽略为当前点和当前楼层。
+
+
+core.replaceBlock(fromNumber, toNumber, floorId)
+将某个或某些楼层中的所有某个图块替换成另一个图块
+fromNumber和toNumber为要被替换和替换到的数字。
+floorId可为某个楼层ID，或者一个楼层数组；如果不填只视为当前楼层。
+值得注意的是，使用此函数转了的点上的自定义事件可能无法被执行。
+如有需要，再对那些存在事件的点执行core.setBlock()即可
+
+
+core.setBgFgBlock(name, number, x, y, floorId)
+设置前景/背景层的某个图块。name只能为'bg'或'fg'表示前景或背景层。
+number为要设置到的图块数字，x,y和floorId为目标点坐标和楼层，可忽略为当前点和当前楼层。
+
+
+core.resetMap(floorId)
+重置某层或若干层的地图和楼层属性。
+floorId可为某个楼层ID，或者一个楼层数组（同时重置若干层）；如果不填则只重置当前楼层。
+
+// ------ 移动/跳跃图块，淡入淡出图块 ------ //
+
+core.moveBlock(x, y, steps, time, keep, callback)
+移动一个图块，x和y为图块的坐标。
+steps为移动的数组，每一项只能是"up","down","left","right"之一。
+time为每一步的移动时间，不填默认为500ms。
+如果keep为真，则在移动完毕后将自动调用一个setBlock事件，改变目标点的图块（即不消失），
+否则会按照time时间来淡出消失。callback会执行完毕后的回调。
+
+
+core.jumpBlock(sx, sy, ex, ey, time, keep, callback)
+跳跃一个图块，sx和sy为图块的坐标，ex和ey为目标坐标。time为整个跳跃过程中的全程用时，不填默认500。
+如果keep为真，则在移动完毕后将自动调用一个setBlock事件，改变目标点的图块（即不消失），
+否则会按照time时间来淡出消失。callback会执行完毕后的回调。
+
+
+core.animateBlock(loc, type, time, callback)
+淡入/淡出一个或多个图块。
+loc为一个图块坐标，或者一个二维数组表示一系列图块坐标（将同时显示和隐藏）。
+type只能为'show'或'hide'表示是淡入但是淡出。time为动画时间，callback为执行完毕的回调。
+
+// ------ 全局动画控制，动画的绘制 ------ //
+
+core.addGlobalAnimate(block)
+添加一个全局帧动画。
+
+
+core.removeGlobalAnimate(x, y, name)
+删除一个或全部的全局帧动画。name可为'bg',null或'fg'表示某个图层。
+x和y如果为null，则会删除全部的全局帧动画，否则只会删除该点的该层的帧动画。
+
+
+core.drawBoxAnimate()
+绘制UI层的box动画，如怪物手册和对话框中的帧动画等。
+
+
+core.drawAnimate(name, x, y, callback)
+绘制一个动画。name为动画名，x和y为绘制的基准坐标，callback为绘制完毕的回调函数。
+此函数将播放动画音效，并异步开始绘制该动画。
+此函数会返回一个动画id，可以通过core.stopAnimate()立刻停止该动画的播放。
+
+
+core.stopAnimate(id, doCallback)
+立刻停止某个动画的播放。id为上面core.drawAnimate的返回值。
+如果doCallback为真，则会执行该动画所对应的回调函数。
+
+
+
+
+------------------------------------ [ui.js] ------------------------------------
+
+ui.js负责一切UI界面的绘制。主要包括三个部分：
+- 设置某个画布的属性的相关API
+- 具体的某个UI界面的绘制
+- 动态创建画布相关的API
+
+
+
+
+// ------ 设置某个画布的属性的相关API ------//
+这系列函数的name一般都是画布名，可以是系统画布或动态创建的画布。
+但也同时也允许直接传画布的context本身，将返回自身。
+
+
+core.getContextByName(name)
+根据画布名找到一个画布的context；支持系统画布和自定义画布。
+如果不存在画布此函数返回null。
+该参数也可以直接传画布的context自身，则返回自己。
+
+
+core.clearMap(name)
+清空某个画布图层。
+该函数的name也可以是'all'，若为'all'则为清空所有系统画布。
+
+
+core.fillText(name, text, x, y, style, font)
+在某个画布上绘制一段文字。
+text为要绘制的文本，x,y为要绘制的坐标，style可选为绘制的样式，font可选为绘制的字体。（下同）
+请注意textAlign和textBaseline将决定绘制的左右对齐和上下对齐方式。
+具体可详见core.setTextAlign()和core.setTextBaseline()函数。
+
+
+core.fillBoldText(name, text, x, y, style, font)
+在某个画布上绘制一个描黑边的文字。
+
+
+core.fillRect(name, x, y, width, height, style)
+绘制一个矩形。style可选为绘制样式。如果设置将调用core.setFillStyle()。（下同）
+
+
+core.strokeRect(name, x, y, width, height, style, lineWidth)
+绘制一个矩形的边框。style可选为绘制样式，如果设置将调用core.setStrokeStyle()。
+lineWidth如果设置将调用core.setLineWidth()。（下同）
+
+
+core.drawLine(name, x1, y1, x2, y2, style, lineWidth)
+绘制一条线。
+
+
+core.drawArrow(name, x1, y1, x2, y2, style, lineWidth)
+绘制一个箭头。
+
+
+core.setFont(name, font) / core.setLineWidth(name, lineWidth)
+设置一个画布的字体/线宽。
+
+
+core.setAlpha(name, font) / core.setOpacity(name, font)
+设置一个画布的绘制不透明度和画布本身的不透明度。
+两者区别如下：
+  - setAlpha是设置"接下来绘制的内容的不透明度"，不会对已经绘制的内容产生影响。
+    > 比如setAlpha('ui', 0.5)则会在接下来的绘制中使用0.5的不透明度。
+  - setOpacity是设置"画布本身的不透明度"，已经绘制的内容也会产生影响。
+    > 比如我已经在UI层绘制了一段文字，再setOpacity则也会让已经绘制的文字变得透明。
+尽量不要对系统画布使用setOpacity（因为会对已经绘制的内容产生影响），自定义创建的画布则不受此限制。
+
+
+core.setFillStyle(name, style) / core.setStrokeStyle(name, style)
+设置一个画布的填充样式/描边样式。
+
+
+core.setTextAlign(name, align)
+设置一个画布的文字横向对齐模式，这里的align只能为'left', 'right'和'center'。
+默认为'left'。
+
+
+core.setTextBaseline(name, baseline)
+设置一个画布的纵向对齐模式。有关textBaseline的说明可参见如下资料：
+http://www.runoob.com/tags/canvas-textbaseline.html
+默认值是'alphabetic'。
+请注意，系统画布在绘制前都是没有设置过textBaseline的，都是按照alphabetic进行坐标绘制。
+因此，如果你修改了系统画布的textBaseline来绘图，记得再绘制完毕后修改回来。
+
+
+core.calWidth(name, text, font)
+计算一段文字在某个画布上的绘制宽度，此函数其实是ctx.measureText()的包装。
+font可选，如果存在则会先设置该画布上的字体。
+此函数不会对文字进行换行，如需换行版本请使用core.splitLines()函数。
+
+
+core.splitLines(name, text, maxWidth, font)
+计算一段文字在某画布上换行分割的结果。
+text为文字内容，maxWidth为最大宽度，可为null表示不自动换行。
+font可选，如果存在则会先设置该画布上的字体。
+此函数将返回一个换行完毕的文本列表。
+
+
+core.drawImage(name, image, x, y, w, h, x1, y1, w1, h1)
+在一张画布上绘制一张图片，此函数其实是ctx.drawImage()的包装。
+可以查看下面的文档以了解各项参数的信息：
+http://www.w3school.com.cn/html5/canvas_drawimage.asp
+这里的image允许传一个图片，画布。也允许传递图片名，将从你导入的图片中获取图片内容。
+
+// ------ 具体的某个UI界面的绘制 ------ //
+core.closePanel()
+结束一切事件和UI绘制，关闭UI窗口，返回游戏。
+此函数将以此调用core.clearUI()，core.unlockControl()，并清空core.status.event里面的内容。
+
+
+core.clearUI()
+重置UI窗口。此函数将清掉所有的UI帧动画和光标，清空UI画布，并将alpha设为1。
+
+
+core.drawTip(text, id)
+在左上角以气泡的形式绘制一段提示。
+text为文字内容，仅支持${}的表达式计算，不支持换行和变色。
+id可选，为同时绘制的图标ID，如果不为null则会同时绘制该图标（仅对32x32的素材有效）。
+也可以使用状态栏的图标ID，例如lv, hp, up, save, settings等。
+
+
+core.drawText(content, callback)
+绘制一段文字。contents为一个字符串或一个字符串数组，callback为全部绘制完毕的回调。
+支持所有的文字效果（如\n，${}，\r，\\i等），也支持\t和\b的语法。
+如果当前在事件处理中或录像回放中，则会自动转成core.insertAction处理。
+不建议使用该函数，如有绘制文字的需求请尽量使用core.insertAction()插入剧情文本事件。
+
+
+core.drawWindowSelector(background, x, y, w, h)
+绘制一个WindowSkin的闪烁光标。background可为winskin的图片名或图片本身。
+x,y,w,h为绘制的左上角位置和宽高，都是像素为单位。
+
+
+core.drawWindowSkin(background, ctx, x, y, w, h, direction, px, py)
+绘制一个WindowSkin。background可为winskin的图片名或图片本身。
+ctx为画布名或画布本身，x,y,w,h为左上角位置和宽高，都是像素为单位。
+direction, px, py可选，如果设置则会绘制一个对话框箭头。
+
+
+core.drawBackground(left, top, right, bottom, posInfo)
+绘制一个背景图。此函数将使用你在【剧情文本设置】中设置的背景，即用纯色或WindowSkin来绘制。
+left, top, right, bottom为你要绘制的左上角和右下角的坐标。
+posInfo如果不为null则是一个含position, px和py的对象，表示一个对话框箭头的绘制。
+
+
+core.drawTextContent(ctx, content, config)
+根据配置在某个画布上绘制一段文字。此函数会被core.drawTextBox()所调用。
+ctx为画布名或画布本身，如果不设置则会忽略该函数。
+content为要绘制的文字内容，支持所有的文字效果（如\n，${}，\r，\\i等），但不支持支持\t和\b的语法。
+config为绘制的配置项，目前可以包括如下几项：
+ - left, top：在该画布上绘制的左上角像素位置，不设置默认为(0,0)。
+   > 该函数绘制时会将textBaseline设置为'top'，因此只需要考虑第一个字的左上角位置。
+ - maxWidth：单行最大宽度，超过此宽度将自动换行，不设置不会自动换行。
+ - color：默认颜色，为#XXXXXX形式。如果不设置则使用剧情文本设置中的正文颜色。
+ - bold：是否粗体。如果不设置默认为false。
+ - align：文字对齐方式，仅在maxWidth设置时有效，默认为'left'。
+ - fontSize：字体大小，如果不设置则使用剧情文本设置中的正文字体大小。
+ - lineHeight：绘制的行距值，如果不设置则使用fontSize*1.3（即1.3被行距）。
+ - time：打字机效果。若不为0，则会逐个字进行绘制，并设置core.status.event.interval定时器。
+
+
+core.drawTextBox(content, showAll)
+绘制一个对话框。content为一个字符串或一个字符串数组。
+支持所有的文字效果（如\n，${}，\r，\\i等），也支持\t和\b的语法。
+该函数将使用用户在剧情文本设置中的配置项进行绘制。
+实际执行时，会计算文本框宽度并绘制背景，绘制标题和头像，再调用core.drawTextContent()绘制正文内容。
+showAll可选，如果为true则不会使用打字机效果而全部显示，主要用于打字机效果的点击显示全部。
+
+
+core.drawScrollText(content, time, lineHeight, callback)
+绘制一个滚动字幕。content为绘制内容，time为总时间（默认为5000），lineHeight为行距比例（默认为1.4）。
+滚动字幕将绘制在UI上，支持所有的文字效果（如\n，${}，\r，\\i等），但不支持\t和\b效果。
+可以通过剧情文本设置中的align控制是否居中绘制，offset控制其距离左边的偏移量。
+
+
+core.textImage(content, lineHeight)
+将文本图片化。content为绘制内容，lineHeight为行距比例（默认为1.4）。
+可以通过剧情文本设置中的align控制是否居中绘制。
+此函数将返回一个临时画布的canvas，供转绘到其他画布上使用。
+
+
+core.drawChoices(content, choices)
+绘制一个选项框。
+content可选，为选项上方的提示文字，支持所有的文字效果（如\n，${}，\r，\\i等），也支持\t效果。
+choices必选，为要绘制的选项内容，是一个列表。其中的每一项：
+ - 可以是一个字符串，表示选项文字，将使用剧情文本设置中的正文颜色来绘制，仅支持${}表达式计算。
+ - 或者是一个包含text, color和icon的对象。
+   > text必选，为要绘制的文字内容，仅支持${}的表达式计算，
+   > color为要绘制的选项颜色，可以是#XXXXXX的格式或RGBA数组。不设置则使用正文颜色。
+   > icon为要绘制的图标ID，支持使用素材的ID，或者系统图标。
+
+
+core.drawConfirmBox(text, yesCallback, noCallback)
+绘制一个确认框。text为确认文字，支持\n换行（但不支持自动换行）和${}表达式计算。
+yesCallback和noCallback分别为确定和取消的回调函数。
+可以在调用此函数前设置core.status.event.selection来控制默认的选中项（0确定1取消）。
+此函数和core.myconfirm的区别主要在于：
+ - 此函数会清掉UI层原有的绘制信息，core.myconfirm不会清除。
+ - 此函数可以用键盘进行操作，core.myconfirm必须用鼠标点击。
+另外请注意：本函数和事件流的执行不兼容，选择也不会进录像。
+如果需要在事件流中调用请使用提供选择项。
+
+
+core.drawWaiting(text)
+绘制一个等待界面，一般用于同步存档之类的操作。
+调用此函数后，需要再调用core.closePanel()才会恢复游戏。
+
+
+core.drawPagination(page, totalPage, y)
+绘制一个分页。y如果不设置则绘制在最后一行。
+
+
+core.drawBook(index) / core.drawBookDetail(index)
+绘制怪物手册，绘制怪物的详细信息。
+
+
+core.drawFly(page) / core.drawCenterFly() / core.drawShop(shopId)
+绘制楼传页面，中心对称飞行器，绘制商店
+
+
+core.drawToolbox(index) / core.drawEquipbox(index) / core.drawKeyBoard()
+绘制道具栏，绘制装备栏，绘制虚拟键盘。
+
+
+core.drawMaps(index, x, y) / core.drawSLPanel(index, refresh)
+绘制浏览地图，绘制存读档界面。
+
+
+core.drawStatusBar()
+自定义绘制状态栏，仅在状态栏canvas化开启时有效，实际被转发到了脚本编辑中。
+
+
+core.drawStatistics()
+绘制数据统计。将从脚本编辑中获得要统计的数据列表，再遍历所有地图进行统计。
+
+
+core.drawAbout() / core.drawPaint() / core.drawHelp()
+绘制关于界面，绘图模式，帮助界面。
+
+// ------ 动态创建画布相关的API ------ //
+
+
+core.ui.createCanvas(name, x, y, width, height, z)
+动态创建一个自定义画布。name为要创建的画布名，如果已存在则会直接取用当前存在的。
+x,y为创建的画布相对窗口左上角的像素坐标，width,height为创建的长宽。
+z值为创建的纵向高度（关系到画布之间的覆盖），z值高的将覆盖z值低的；系统画布的z值可在个性化中查看。
+返回创建的画布的context，也可以通过core.dymCanvas[name]或core.getContextByName获得。
+
+
+core.ui.relocateCanvas(name, x, y)
+重新定位一个自定义画布。x和y为画布的左上角坐标。
+
+
+core.ui.resizeCanvas(name, width, height)
+重新设置一个自定义画布的大小。width和height为新设置的宽高。此操作会清空画布。
+
+
+core.ui.deleteCanvas(name)
+删除一个自定义画布。
+
+
+core.ui.deleteAllCanvas()
+删除所有的自定义画布。
+
+
+
+
+------------------------------------ [utils.js] ------------------------------------
+
+utils.js是一个工具函数库，里面有各个样板中使用到的工具函数。
+
+
+
+
+core.replayText(text, need, times)
+将一段文字中的${}（表达式）进行替换。need和time一般可以直接忽略。
+
+
+core.calValue(value, prefix, need, time)
+计算一个表达式的值，支持status:xxx等的计算。
+prefix为前缀（switch:xxx的独立开关使用），need和time一般可以直接忽略。
+
+
+core.unshift(a, b) / core.push(a, b)
+将b插入到列表a之前或之后。b可以是一个元素或者一个数组。
+
+
+core.decompress(value)
+解压缩一个字符串并进行JSON解析。value可能会被LZString或LZW算法进行压缩。
+返回解压后的JSON格式内容，如果无法解压则返回null。
+
+
+core.setLocalStorage(key, value)
+将一个键值对存入localStorage中，会立刻返回结果。
+此函数会自动给key加上它的name作为前缀，以便于不同塔之间的区分。
+value为要存储的内容，存储前会被JSON转成字符串形式，并LZW算法进行压缩。
+如果value为null，则实际会调用core.removeLocalStorage()函数清除该key。
+localStorage为浏览器的默认存储，和存档无关，只有5M的空间大小。
+此函数立刻返回true或false，如果为false则代表存储失败，一般指的是空间满了。
+
+
+core.getLocalStorage(key, defaultValue)
+从localStorage中获得一个键的值，会立刻返回结果。
+此函数会自动给key加上它的name作为前缀，以便于不同塔之间的区分。
+如果对应的键值不存在或为null，则会返回defaultValue。
+返回的结果会被调用core.decompress进行解压缩和JSON解析。
+
+
+core.removeLocalStorage(key)
+从localStorage中删除一个键的值，会立刻返回。
+此函数会自动给key加上它的name作为前缀，以便于不同塔之间的区分。
+
+
+core.setLocalForage(key, value, successCallback, errorCallback)
+将一个键值对存入localForage中，异步返回结果。
+如果用户没有开启【新版存档】开关，则仍然会使用core.setLocalStorage()。
+localForage为一个开源库，项目地址 https://github.com/localForage/localForage
+一般存入的是indexedDB，这是一个浏览器的自带数据库，没有空间限制。
+successCallback和errorCallback均可选，表示该次存储成功或失败的回调，
+此函数为异步的，只能通过回调函数来获得存储的成功或失败信息。
+
+
+core.getLocalForage(key, defaultValue, successCallback, errorCallback)
+从localForage中获得一个键的值，异步返回结果。
+如果对应的键值不存在，则会使用defaultValue。
+如果获得成功，则会将core.decompress后的结果传入successCallback回调函数执行。
+errorCallback可选，如果失败，则会将错误信息传入errorCallback()。
+此函数是异步的，只能通过回调函数来获得读取的结果或错误信息。
+
+
+core.setGlobal(key, value)
+设置一个全局存储，适用于global:xxx。
+录像播放时将忽略此函数，否则直接调用core.setLocalStorage。
+
+
+core.getGlobal(key, value)
+获得一个全局存储，适用于global:xxx，支持录像。
+正常游戏时将使用core.getLocalStorage获得具体的数据，并将结果存放到录像中。
+录像播放时会直接从录像中获得对应的数据。
+
+
+core.clone(data, filter, recursion)
+深拷贝一个对象。有关浅拷贝，深拷贝，基本类型和引用类型等相关知识可参见：
+https://zhuanlan.zhihu.com/p/26282765
+filter为过滤函数，如果设置且不为null则需传递一个可接受(name, value)的函数，
+并返回true或false，表示该项是否应该被深拷贝。
+recursion表示该filter是否应递归向下传递，如果为true则递归函数也将传该filter。
+例如：
+core.clone(core.status.hero, function(name, value) {
+    return name == 'items' || typeof value == 'number';
+}, false);
+这个例子将会深拷贝勇士的属性和道具。
+
+
+core.splitImage(image, width, height)
+等比例切分一张图片。width和height为每张子图片的宽高。
+请确保原始图片的宽度和高度都是是width和height的倍数。
+此函数将返回一个一维数组，每一项都是一张切分好的图片，横向再纵向排列。
+例如4x3的图片按1x1切分得到一个长度为12的数组，按如下方式进行排列：
+0   1   2   3
+4   5   6   7
+8   9  10  11
+可以将很多需要的图片拼在一张大图上，然后在插件的_afterLoadResources中切分。
+切分好的图片再存入core.material.images.images中，这样可以少很多IO请求。
+
+
+core.formatDate(date) / core.formatDate2(date) / core.formatTime(time)
+格式化日期和时间。
+
+
+core.setTwoDigits(x)
+将x变成两位数。其实就是 parseInt(x) < 10 ? "0" + x : x
+
+
+core.formatBigNumber(x, onMap)
+大数据格式化。x为要格式化的内容，如果不合法会返回???。
+onMap标记是否在地图上调用，如果为真则尝试格式化成六位，否则五位。
+
+
+core.arrayToRGB(color) / core.arrayToRGBA(color)
+将一个颜色数组，例如[255,0,0,1]转成#FF0000或rgba(255,0,0,1)的形式。
+
+
+core.encodeRoute(route)
+录像压缩和解压缩。route为要压缩的路线数组。
+此函数将尽可能对录像进行压缩。对于无法识别的项目（比如自己添加的），将不压缩而原样放入。
+例如，["up","up","left","move:3:5","test:2333","getNext","item:bomb","down"]
+将被压缩成"U2LM3:5(test:2333)GIbomb:D"。
+自己添加的录像项只能由数字、大小写、下划线线、冒号等符号组成，否则无法正常压缩和解压缩。
+对于自定义内容（比如中文文本或数组）请使用JSON.stringify再core.encodeBase64处理。
+压缩的结果将再次进行LZString.compressToBase64()的压缩以进一步节省空间。
+
+
+core.decodeRoute(route)
+解压缩一个录像，返回解压完毕的路线数组。
+
+
+core.isset(v)
+判定v是不是null, undefined或NaN。
+请尽量避免使用此函数，而是直接判定 v == null （请注意 null==undefined ！）
+
+
+core.subarray(a, b)
+判定数组b是不是数组a的一个前缀子数组。
+如果是，则返回a中除去b后的剩余数组，否则返回null。
+
+
+core.inArray(array, element)
+判定array是不是一个数组，以及element是否在该数组中。
+
+
+core.clamp(x, a, b)
+将x限定在[a,b]区间内。
+
+
+core.getCookie(name)
+获得一个cookie值，如果不存在该cookie则返回null。
+
+
+core.setStatusBarInnerHTML(name, value, css)
+设置一个状态栏的innerHTML。此函数会自动设置状态栏的文字放缩和斜体等效果。
+name为状态栏的名称，如atk, def等。需要是core.statusBar中的一个合法项。
+value为要设置到的数值，如果是数字则会先core.formatBigNumber()进行格式化。
+css可选，为增添的额外css内容，比如可以设定颜色等。
+
+
+core.strlen(str)
+计算某个字符串的实际长度。每个字符的长度，ASCII码视为1，中文等视为2。
+
+
+core.reverseDirection(direction)
+翻转方向，即"up"转成"down", "left"转成"right"等。
+
+
+core.matchWildcard(pattern, string)
+进行通配符的匹配判定，目前仅支持*（可匹配0或任意个字符）。比如"a*b*c"可以匹配"aa012bc"。
+
+
+core.encodeBase64(str) / core.decodeBase64(str)
+将字符串进行base64加密或解密。
+
+
+core.convertBase(str, fromBase, toBase)
+任意进制转换。此函数可能执行的非常慢，慎用。
+
+
+core.rand(num)
+使用伪种子生成伪随机数。该随机函数能被录像支持。
+num如果设置大于0，则生成一个[0, num-1]之间的数；否则生成一个0到1之间的浮点数。
+此函数为伪随机算法，SL大法无效。（即多次SL后调用的该函数返回的值都是相同的。）
+
+
+core.rand2(num)
+使用系统的随机数算法得到的随机数。该随机函数能被录像支持。
+num如果设置大于0，则生成一个[0, num-1]之间的数；否则生成一个0到2147483647之间的整数。
+此函数使用了系统的Math.random()函数，支持SL大法。
+但是，此函数会将生成的随机数值存入录像，因此如果调用次数太多则会导致录像文件过大。
+对于需要大量生成随机数，但又想使用真随机支持SL大法的（例如随机生成地图等），可以采用如下方式：
+  var x = core.rand2(100); for (var i = 0; i < x; i++) core.rand()
+即先生成一个真随机数，根据该数来推进伪随机的种子，这样就可以放心调用core.rand()啦。
+
+
+core.readFile(success, error)
+读取一个本地文件内容。success和error分别为读取成功或失败的回调函数。
+iOS平台暂不支持读取文件操作。
+
+
+core.readFileContent(content)
+读取到的文件内容。此函数会被APP等调用，来传递文件的具体内容。
+
+
+core.download(filename, content)
+生成一个文件并下载。filename为文件名，content为具体的文件内容。
+iOS平台暂不支持下载文件操作。
+
+
+core.copy(data)
+将一段内容拷贝到剪切板。
+
+
+core.myconfirm(hint, yesCallback, noCallback)
+弹窗绘制一段提示信息并让用户确认。hint为提示信息。
+yesCallback和noCallback分别为确定和取消的回调函数。
+此函数和core.drawConfirmBox的区别主要在于：
+ - drawConfirmBox会清掉UI层原有的绘制信息，此函数不会清除。
+ - drawConfirmBox可以用键盘进行操作，此函数必须用鼠标点击。
+另外请注意：本函数的选择也不会进录像，一般用于全局的提示。
+如果需要在事件流中调用请使用显示确认框或显示选择项。
+
+
+core.myprompt(hint, value, callback)
+弹窗让用户输入一段内容。hint为提示信息，value为框内的默认填写内容。
+callback为用户点击确认或取消后的回调。
+如果用户点击了确认，则会把框内的内容（可能是空串）传递给callback，否则把null传递给callback。
+
+
+core.showWithAnimate(obj, speed, callback) / core.hideWithAnimate(obj, speed, callback)
+动画淡入或淡出一个对象。
+
+
+core.consoleOpened()
+检测当前的控制台是否处于开启状态。仅在全塔属性中的检查控制台开关开启时有效。
+此函数有可能会存在误伤行为，即没开过控制台仍认为开启过。
+
+
+core.hashCode(obj)
+计算一个对象的哈希值。
+
+
+core.same(a, b)
+判定a和b是否相同，包括类型相同和值相同。
+如果a和b都是数组，则会递归依次比较数组中的值；如果都是对象亦然。
+
+
+core.utils.http(type, url, formData, success, error, mimeType, responseType)
+发送一个异步HTTP请求。
+type为'GET'或者'POST'；url为目标地址；formData如果是POST请求则为表单数据。
+success为成功后的回调，error为失败后的回调。
+mimeType和responseType如果设置将会覆盖默认值。
+
+
+lzw_encode(s) / lzw_decode(s)
+LZW压缩算法，来自https://gist.github.com/revolunet/843889
diff --git a/B站视频教程.url b/B站视频教程.url
new file mode 100644
index 00000000..036a8a64
--- /dev/null
+++ b/B站视频教程.url
@@ -0,0 +1,5 @@
+[{000214A0-0000-0000-C000-000000000046}]
+Prop3=19,2
+[InternetShortcut]
+IDList=
+URL=https://www.bilibili.com/video/av32781473/
\ No newline at end of file
diff --git a/HTML5魔塔样板使用指南.url b/HTML5魔塔样板使用说明文档.url
similarity index 64%
rename from HTML5魔塔样板使用指南.url
rename to HTML5魔塔样板使用说明文档.url
index 823d8f8d..021c516b 100644
--- a/HTML5魔塔样板使用指南.url
+++ b/HTML5魔塔样板使用说明文档.url
@@ -2,4 +2,4 @@
 Prop3=19,2
 [InternetShortcut]
 IDList=
-URL=https://ckcz123.github.io/mota-js/
+URL=https://h5mota.com/games/template/docs/
\ No newline at end of file
diff --git a/README.md b/README.md
index 055ec27a..7e331545 100644
--- a/README.md
+++ b/README.md
@@ -8,9 +8,9 @@ HTML5 canvas制作的魔塔样板，支持全平台游戏！
 * [List / HTML5魔塔游戏列表](https://h5mota.com/)
 * [Demo / 样板效果](https://ckcz123.com/games/template/)
 * [Docs / 使用文档说明](https://ckcz123.github.io/mota-js/)
-* [Video / 视频教程](http://www.bilibili.com/video/av17608025/)
+* [Video / 视频教程](https://www.bilibili.com/video/av32781473/)
 
-![样板](./docs/img/sample0.png)
+![样板](./_docs/img/sample0.png)
 
 ## 目录结构
 
@@ -25,8 +25,8 @@ HTML5 canvas制作的魔塔样板，支持全平台游戏！
 │ ├─ data.js         # 记录了一些初始化信息
 │ ├─ enemys.js       # 记录了怪物的信息，包括特殊属性、伤害计算公式、临界值计算等。
 │ ├─ events.js       # 处理事件的文件，所有自定义事件都会在此文件中进行处理
-│ ├─ icons.js        # 记录了图标信息
-│ ├─ items.js        # 道具的使用
+│ ├─ icons.js        # 图标信息，会被转发到project下
+│ ├─ items.js        # 道具信息，会被转发到project下
 │ ├─ loader.js       # 动态加载JS代码、图片、音效等
 │ ├─ maps.js         # 记录了地图信息，和地图绘制等操作
 │ ├─ ui.js           # UI绘制信息，主要负责绘制各个UI窗口。
@@ -38,27 +38,240 @@ HTML5 canvas制作的魔塔样板，支持全平台游戏！
 │ ├─ /sounds/        # 音效目录
 │ ├─ data.js         # 全局变量信息
 │ ├─ enemys.js       # 怪物属性数据
+│ ├─ events.js       # 公共事件
 │ ├─ functions.js    # 可能会被修改的脚本代码
 │ ├─ icons.js        # 素材和ID的对应关系定义
 │ ├─ items.js        # 道具的定义，获得道具的效果
-│ └─ maps.js         # 地图和数字的对应关系
-├── /常用工具/        # 一些常用工具，可以辅助造塔  
-│ ├─ RM动画导出器.exe      # 能从RMXP中导出动画，以供H5使用。 http://github.com/ckcz123/animate_export/
-│ ├─ JS代码压缩工具.exe    # 能对Javascript代码进行压缩和整合，从而减少IO请求量。 http://github.com/ckcz123/JSCompressor/
-│ ├─ 便捷PS工具.exe        # 能只用复制和粘贴来快速对素材进行PS操作。  http://github.com/ckcz123/ps/
-│ ├─ 地图生成器.exe        # 能从一张截图识别出来具体的数字数组，方便复刻已有的塔。 http://github.com/ckcz123/map_generator/
-│ └─ 伤害和临界值计算器.exe       # 一个能帮助计算怪物的伤害和临界值的小工具。 http://github.com/ckcz123/magic-tower-calculator/
-├── /启动服务(mac版).app/        # 启动服务的mac版本。  
+│ ├─ maps.js         # 地图和数字的对应关系
+│ └─ plugins.js      # 自定义插件
+├── /常用工具/        # 一些常用工具，可以辅助造塔；具体可参见下面的【相关工具】
 ├── editor.html      # 可视化地图编辑工具
 ├── editor-mobile.html      # 可视化地图编辑工具（手机版）
 ├── index.html       # 主程序，游戏的入口
 ├── main.js          # JS程序的入口，将动态对所需JS进行加载
 ├── style.css        # 游戏所需要用到的样式表
-└── 启动服务.exe      # 一个本地的HTTP服务器，也能支撑前端的一些POST请求从而能拓展JS的IO功能。 http://github.com/ckcz123/mota-js-server/
+└── 启动服务.exe      # 一个本地的HTTP服务器，也能支撑前端的一些POST请求从而能拓展JS的IO功能。
 ```
 
 ## 更新说明
 
+### 2019.5.2 V2.6.1
+
+* [x] 区域优化的录像播放功能，R键使用
+* [x] 强制战斗可以指定怪物坐标，将自动隐藏并执行该点战后事件
+* [x] flag:xxx也支持中文，例如 flag:2楼机关门
+* [x] 增加文件名映射，可以用中文映射到某个图片或bgm文件并使用
+* [x] 勇士宽度可以超过32（例如48x48的勇士行走图）
+* [x] 现在允许修改floorId和图块ID了（在表格下方）
+* [x] 增加事件：自动存档，返回标题界面；部分事件优化
+* [x] 商店长按空格可以连续加点
+* [x] 增设global:xxx使用全局存储，可被录像支持
+* [x] 支持\b[hero]和\b[null,x,y]来自动调整上下方向
+* [x] 支持\t[yellowKey]等只显示图标而没有标题
+* [x] 编辑器中前景层对于有事件的点半透明显示
+* [x] 存档改成1000页，长按上下页可快速翻页
+* [x] 录像播放初始默认暂停，N键可以单步执行
+* [x] 增设本地API文档，部分API和事件的优化
+* [x] 所有已知的bug修复，大量细节优化
+
+### 2019.4.13 V2.6
+
+* [x] 拆分整个项目，大幅重构代码，新增大量API
+* [x] 重写文档，尤其是脚本和API列表
+* [x] 现在可以对编辑器的表格的结构进行配置
+* [x] 可以收藏和高亮存档
+* [x] 独立出来的插件编写
+* [x] 新增事件：关门、显示确认框、后置循环处理
+* [x] 剧情文本的绘制可以设置居中选项
+* [x] 选项框的绘制可以增加图标
+* [x] 增加公共事件版的全局商店
+* [x] 公共事件现在可以传入参数
+* [x] 重写滑冰事件，现在滑冰在背景层了
+* [x] 将输入框改成自定义实现，避免部分设备不支持
+* [x] 状态栏文字可以自动放缩
+* [x] 显示图片和对话框立绘可以裁剪图片
+* [x] 修复所有已知bug，大量细节优化
+
+### 2019.2.19 V2.5.5
+
+* [x] 现在编辑器修改地图后可以直接读档生效，无需再重置地图或回放录像
+* [x] 存档方式优化，大幅降低单个存档的占用空间
+* [x] 脚本编辑器增加代码格式化的选项
+* [x] 事件和脚本编辑器中Ctrl+S可以进行保存
+* [x] 显示选择项提供颜色控制
+* [x] 事件的移动勇士增加前进和后退两个操作
+* [x] 事件编辑器的下拉框增加滚动条
+* [x] 通关后将询问是否进行评分
+* [x] 录像播放失败后可以回退到上个节点
+* [x] 修复已知的所有Bug，大量细节优化
+
+### 2019.2.4 V2.5.4
+
+* [x] 发布15x15的版本
+* [x] 独立出来的公共事件
+* [x] 支持多重装备（一个装备可以装到多个孔上）
+* [x] 工具栏按钮增添至8个，快捷商店和虚拟键盘同时显示
+* [x] 点击状态栏的金币图标也可以打开快捷商店
+* [x] 等待事件提供flag:px和flag:py在0~415之间
+* [x] 事件：呼出存读档界面；呼出怪物手册
+* [x] 事件：使用道具，暂停背景音乐，暂停所有音效
+* [x] type:trigger可以触发系统事件
+* [x] 独立开关
+* [x] 贴图也可以支持帧动画了
+* [x] 图块内置颜色选择器
+* [x] 标题界面增加音乐按钮
+* [x] 等待事件可被Ctrl（长按）跳过
+* [x] 部分Bug修复，大量细节优化，性能进一步得到提升
+
+### 2018.12.22 V2.5.3
+
+* [x] 标题界面事件化；现在可以用事件流来处理标题界面了
+* [x] 动态canvas管理；无限图层，可以任意创建图层并使用
+* [x] 状态栏canvas化，可以自行对状态栏进行绘制
+* [x] 手机端新增1-7按钮，可点工具栏进行切换
+* [x] 事件编辑器可以查看最近使用图块和搜索图块
+* [x] 事件编辑器中增加增加颜色选择器
+* [x] 对话框里`\f`可以自带立绘效果
+* [x] 图片相关事件全部修改为动态canvas实现
+* [x] 新增事件：滚动字幕
+* [x] 新增事件：等待所有异步事件执行完毕
+* [x] 新增事件：画面闪烁
+* [x] BGM缓存管理；新增事件：预加载BGM
+* [x] 新增天气：雾
+* [x] 每次到达楼层执行的事件`eachArrive`
+* [x] 可以控制某些图块无全局动画效果
+* [x] 背景/前景层的素材可以全局动画/动态Autotile效果
+* [x] 可以为每个装备单独设置是否按比例增加
+* [x] 地图编辑器中选中点高亮；双击选中素材；WASD平移大地图
+* [x] 修复所有Bug，部分代码重构，大量细节优化
+
+### 2018.11.30 V2.5.2
+
+* [x] 怪物和NPC的行走图和朝向问题
+* [x] 可以引入WindowSkin作为对话框的背景素材
+* [x] 允许使用\t[标题,1.png]来绘制大头像图
+* [x] 对话框的宽度可以根据文本长度自动调整
+* [x] \r[red]可以动态调整剧情文本的颜色
+* [x] 升级事件改用事件编辑器完成
+* [x] 每层楼都增添该层的并行事件处理
+* [x] 新增快捷键：N返回标题；P游戏主页；O打开工程
+* [x] 新增事件：设置全局属性或全局数值
+* [x] 新增事件：隐藏/显示状态栏
+* [x] 道具可以设置是否在回放时绘制道具栏或直接使用
+* [x] 可以同时异步移动/跳跃勇士和多个NPC
+* [x] 可以同时异步移动两张或以上的图片了
+* [x] 追加素材一次可以追加多个
+* [x] 菜单栏中新增虚拟键盘的弹出
+* [x] 修复所有已知Bug；部分细节优化
+
+### 2018.11.21 V2.5.1
+
+* [x] 新增事件type:insert，可以插入另一个地点的事件执行（公共事件）
+* [x] 可以使用\r来控制剧情文本部分文字的颜色
+* [x] 新增事件type:switch，多重分歧
+* [x] 绘制前景/背景层时淡化其他图层
+* [x] 追加素材的自动调整（如白底、不规范的素材）
+* [x] 浏览地图时：左上角/V开启显伤；右上角/Z查看当前层大地图
+* [x] 允许在受到领域夹击等伤害后禁用快捷商店
+* [x] 升级的扣除模式，即不显示经验值，只显示升级的所需剩余值
+* [x] 装备增加可装备条件判定
+* [x] 选项界面可以使用1-9快速选择
+* [x] 未开启状态的快捷商店用灰色显示
+* [x] 修复不能在背景/前景层绘图的Bug
+* [x] 手机端的地图编辑器也能有报错信息了
+* [x] 部分其他细节优化
+
+### 2018.10.31 V2.5
+
+* [x] 添加绘图模式支持；可以用户手动绘图和保存
+* [x] 内置主动技能：二倍斩的支持，可以仿照制作其他主动技能
+* [x] 将按键处理移动到脚本编辑中
+* [x] Alt+0\~9保存和读取当前套装
+* [x] 图块属性的cannotOut和cannotIn控制可通行方向（来造成悬崖效果）
+* [x] 支持动态Autotile自动元件（仅在事件层有效）
+* [x] 允许快捷商店使用共用的times
+* [x] 未启用的快捷商店可以隐藏或预览
+* [x] 开始剧情startText可以执行任意事件
+* [x] 对话窗口可以任意调节位置（上中下、距离顶部/底部的像素值）
+* [x] 楼层转换界面可以设置背景图片文字颜色等
+* [x] 数据统计进行分段描写，剑盾显示数值
+* [x] 现在可以在事件编辑器中注释内容了
+* [x] 存读档界面显示该存档的属性
+* [x] F7键可以开启debug模式
+* [x] R键可以从本地选取录像文件从头播放
+* [x] 吸血属性的显伤增加^；仇恨怪显示仇恨伤害
+* [x] 4键默认使用破冰稿或冰冻徽章或地震卷轴或上下楼器（依次判断是否存在）
+* [x] 血瓶的道具化选项；黄宝石增加加点选项
+* [x] 破炸飞增加默认音效
+* [x] 修复单击瞬移的拖动打怪问题
+* [x] 其他细节优化
+
+### 2018.10.27 V2.4.4
+
+* [x] tilesets可以设置图块属性（如可通行状态）
+* [x] 追加素材时可以更改图片色调
+* [x] 防作弊手段的进一步加强：打开控制台则禁止上传成绩
+* [x] 图块属性增加“是否可被破震”的选项
+* [x] 模仿怪物内置模仿临界计算器
+* [x] 部分其他细节优化
+
+### 2018.10.14 V2.4.3
+
+* [x] 并行事件处理
+* [x] 事件：设置楼层属性
+* [x] 增加光环属性，还可以制作区域光环效果
+* [x] 将部分代码移动到脚本编辑中
+* [x] 事件改变天气或画面色调，读档后仍有效
+* [x] Autotile自动元件的新增和注册
+* [x] 状态栏可以显示角色名字
+* [x] 浏览地图可以显伤
+* [x] 图片淡入淡出和移动图片可以将其保留
+* [x] 双击道具栏图标直接进入装备栏
+* [x] 可以设置剧情文本的字体大小
+* [x] 录像播放可以最高24倍速
+* [x] 1-6键快速设置录像播放速度；滚轮加减速
+* [x] 修复大地图的夹击Bug
+* [x] 部分其他细节优化
+
+### 2018.9.28 V2.4.2
+
+* [x] 允许导入tilesets直接使用，无需PS和注册
+* [x] tilesets的素材允许以矩形方式整体绘制
+* [x] Alt+0\~9保存素材，Ctrl+0\~9快速选中
+* [x] 增加了透明块的支持
+* [x] 装备允许按照百分比增加属性
+* [x] 多动画的同时播放
+* [x] 修复了打开存读档页面时闪屏的问题
+* [x] 修复了cannotMove仍然能轻按和瞬移的问题
+* [x] 所有已知Bug修复，部分代码重构和细节优化
+
+### 2018.9.18 V2.4.1
+
+* [x] 增加背景层和前景层的图块绘制，多层图块可叠加
+* [x] 背景层/前景层图块的显示、隐藏、修改等事件
+* [x] 专门的装备页面（Q键开启）；装备系统大改造
+* [x] 灯光和漆黑层效果，通过插件函数方式给出
+* [x] 将状态栏更新和阻激夹域的计算移动到脚本编辑中
+* [x] 增加控制免疫阻激夹域的flag:no_zone等
+* [x] 打字机效果时点击显示全部文字
+* [x] 修复更改画面色调的Bug
+* [x] 修复更改剧情文本属性后读档恢复原样的问题
+* [x] 部分细节优化
+
+### 2018.8.28 V2.4
+
+* [x] 大地图的支持
+* [x] 突破了5M的存档空间大小限制
+* [x] 事件：隐藏/显示贴图
+* [x] 事件：接收用户文本输入
+* [x] 同点多事件的颜色块绘制
+* [x] 录像播放时可以按PgUp/PgDn浏览地图
+* [x] 录像播放时对于瞬间移动绘制箭头
+* [x] 增加激光属性
+* [x] 可以在读档时E键直接指定编号
+* [x] 破炸飞可以在状态栏显示个数
+* [x] 部分细节优化，所有已知Bug修复
+
 ### 2018.7.21 V2.3.3
 
 * [x] 将怪物特殊属性定义和伤害计算函数移动到脚本编辑中
@@ -279,6 +492,16 @@ HTML5 canvas制作的魔塔样板，支持全平台游戏！
 
 * [x] 发布初版HTML5魔塔样板
 
+## 相关工具
+
+- [启动服务](http://github.com/ckcz123/mota-js-server/)： 一个本地的HTTP服务器，也能支撑前端的一些POST请求从而能拓展JS的IO功能。 
+- [RM动画导出器](http://github.com/ckcz123/animate_export/)：能从RMXP中导出动画，以供H5使用。
+- [JS代码压缩工具](http://github.com/ckcz123/JSCompressor/)：能对Javascript代码进行压缩和整合，从而减少IO请求量。 
+- [便捷PS工具](http://github.com/ckcz123/ps/)：能只用复制和粘贴来快速对素材进行PS操作。  
+- [地图生成器](http://github.com/ckcz123/map_generator/)：能从一张截图识别出来具体的数字数组，方便复刻已有的塔。 
+- [怪物数据导出器](http://github.com/ckcz123/enemy_export/)：能从RMXP中导出怪物数据，以供H5使用。
+- [伤害和临界值计算器](http://github.com/ckcz123/magic-tower-calculator/)：一个能帮助计算怪物的伤害和临界值的小工具。 
+
 ## 联系我们
 
 本样板主要由 [`ckcz123`](https://github.com/ckcz123) （百度ID `艾之葵`）编写。
@@ -302,6 +525,8 @@ HTML5魔塔交流群群号： `539113091`
 
 [@wadxm](https://github.com/wadxm) iOS平台的APP（因为苹果政策无法上架）和启动服务mac版的开发者。我们现在能在mac上制作魔塔得归功于他。
 
-[@fux4](https://github.com/fux4) 打通了RM和H5之间的障壁（从而使RM动画导出器和怪物数据导出器成为可能），同时也是部分新功能（如跳跃、跟随、画面震动）等的编写者。
+[@fux4](https://github.com/fux4) 打通了RM和H5之间的障壁（从而使RM动画导出器和怪物数据导出器成为可能），同时也是大地图和部分新功能（如跳跃、跟随、画面震动）等的编写者。
+
+[@tocque](https://github.com/tocque) 装备栏、动态创建图层等的编写者。
 
 以及[百度贴吧魔塔吧](https://tieba.baidu.com/f?kw=%E9%AD%94%E5%A1%94)和H5魔塔交流群`539113091`内的诸位魔塔爱好者们对本样板的大力支持！
diff --git a/V2.0版本简易造塔流程（For新人）.txt b/V2.0版本简易造塔流程（For新人）.txt
deleted file mode 100644
index 042e6517..00000000
--- a/V2.0版本简易造塔流程（For新人）.txt
+++ /dev/null
@@ -1,78 +0,0 @@
-这只是一个最简单的造塔流程，更为详细的还是请参见视频或教程文档。
-
-1. 打开启动服务，地图编辑器。
-
-2. 切换到MT0层，然后开始绘制地图。可以在上面放置墙、门、道具或怪物等。
-如果提示“该素材未被定义”，请参见第7点。
-如果要从RMXP中复刻已有的塔的地图，请参见第11点。
-
-3. 切换到楼层属性，一项一项仔细进行楼层属性的编辑，如楼层名，firstArrive等等。
-将鼠标移动到表格的中间可以查看详细信息。
-firstArrive为初次到达楼层的事件，可以双击进行事件的编辑。有关事件请详见文档。
-
-3. 输入怪物数据：点击右边怪物，然后左边写怪物的攻防血等数值。
-将鼠标移动到表格的中间可以查看详细信息。
-如果是特殊属性怪物直接写特殊编号，多个特殊属性可以用 [1,2] 来表示。
-
-4. 在中间的下拉框切换全塔属性，一项一项仔细进行根据需求编辑。
-请注意"name"一项必须修改为“字母、数字、下划线组成的字符串”，否则会出现串档问题。
-startText（初始剧情）、shops（全局商店）、levelUp（升级）等都是可以双击方框进行编辑的。
-有关全局商店和升级等信息详见 教程文档 - 事件
-
-5. 给地图添加事件；可以给地图上的NPC增加事件，或者战斗/开门事件等。
-点击地图上的某个点，在左边进行编辑。
-event -- 该点的自定义事件（例如NPC，商店，等等）
-changeFloor -- 该点的楼层传送事件（楼梯/传送门）
-afterBattle -- 该点战斗后触发的战后事件
-afterOpenDoor -- 该点开门后触发的事件
-afterGetItem -- 该点获得道具后触发的事件
-等等。
-有关事件详细内容请参见 文档 - 事件。
-
-6. 新建楼层：切换到地图编辑，然后在框内输入新楼层的floorId，点击新建地图即可保存。
-创建的floorId必须是字母、数字和下划线组成，且不能以数字开头。
-不能为空白，不能和任何已有楼层的floorId重复。
-保存成功后刷新页面。
-
-删除楼层同理，不过请注意删除的会是当前的楼层而不是框中的内容。
-
-7. 关于素材未被定义的问题：如果点击某个怪物或NPC提示该素材未被定义，请在左边进行素材的注册。
-输入该素材的唯一ID（不能和其他素材的ID重复），和素材的唯一数字（1000以内，不能和其他的数字重复），
-保存并刷新，即注册成功。
-
-8. 添加新素材：请打开启动服务的便捷PS工具，然后左边读取你要添加到的图片（比如怪物是enemys.png，道具是items.png），
-右边读取你要导入的怪物素材，通过复制粘贴进行导入，再保存，刷新页面后按照第7点来进行素材的注册。
-
-9. 道具的自定义效果：如果需要自定义道具效果，请仿照其他的几个道具来写，更多信息详见文档。
-
-10. 报错处理：有时候刷新后可能页面变成空白，即无法正确加载。
-出现这种问题的原因往往是手动错误编辑了文件、新建楼层使用了不合法的floorId（比如中文或数字）、楼层floorId定义重复，等等。
-
-出现这种问题，（在Chrome浏览器中）请按Ctrl+Shift+I打开控制台，找到Console查看报错。
-一般都会具体到哪个楼层文件出错。
-
-解决方式：哪个楼层文件出错，请使用VSCode等打开project目录下的data.js文件，并将出错的那个楼层定义删除。
-
-举例，比如我在新建地图中写了 “水潭边” 这样一个楼层名（中文），然后新建并保存，刷新会出错。
-此时，打开控制台（Ctrl+Shift+I的Console），并查看报错，发现是该楼层错误。
-那么打开data.js文件，并将 "floorIds": [..., "水潭边"] 这里对它的楼层定义删除，再刷新即可。
-
-11. 从RMXP中导入已有的塔的地图。
-如果你想复刻老塔，则需使用启动服务的地图生成器。
-请确保老地图中的所有使用素材（地面/墙壁/门/道具/怪物等等）都已经被注册过（参见第7点）。
-
-打开windows自带的截图工具，并对地图进行截图。
-截图时请注意：必须截刚好13x13范围大小的地图，尽量对其边缘进行截取。
-如果不是13x13的范围大小，可能会导致地图生成器无响应。
-截图完毕后，请复制到剪切板，然后在地图生成器中点加载图片。等1-2秒，就可以看到截图被识别。
-点“复制地图”，然后在地图编辑器中切换到“地图编辑”，并粘贴到左边的框内，即可。
-如果存在个别识别问题，可以对这个别素材再进行重新绘制。
-
-如果出现大量识别问题，比如基本全是错的，则代表你的截图方式有问题。
-由于地图生成器的识别以左上角的图块为基准来找寻截图偏移量，请确保左上角一定要是一个能被很好识别的图块。
-建议：在RM的图层第三层，左上角放一个岩浆，再进行截图（保证截图的13x13的左上角是岩浆，从而可以确保定位），
-识别后再复制到地图编辑器中进行绘制。
-
---------------------------------
-
-HTML5魔塔交流群：539113091，如果有问题请加群提问。
diff --git a/docs/V2.0.md b/_docs/V2.0.md
similarity index 98%
rename from docs/V2.0.md
rename to _docs/V2.0.md
index 558eb1d1..0b8bd92a 100644
--- a/docs/V2.0.md
+++ b/_docs/V2.0.md
@@ -1,6 +1,6 @@
 # V2.0版本介绍
 
-?> 目前版本**v2.3.3**，上次更新时间：* {docsify-updated} *
+?> 目前版本**v2.6.1**，上次更新时间：* {docsify-updated} *
 
 目前样板已经更新到V2.0版本以上，本章将对V2.0的一些内容进行介绍。
 
diff --git a/docs/api.md b/_docs/_api.md
similarity index 62%
rename from docs/api.md
rename to _docs/_api.md
index f28da96b..64362e3b 100644
--- a/docs/api.md
+++ b/_docs/_api.md
@@ -1,6 +1,6 @@
 # 附录: API列表
 
-?> 目前版本**v2.3.3**，上次更新时间：* {docsify-updated} *
+?> 目前版本**v2.6**，上次更新时间：* {docsify-updated} *
 
 **这里只列出所有可能会被造塔者用到的常用API，更多的有关内容请在代码内进行查询。**
 
@@ -72,8 +72,17 @@ core.setItem('pickaxe', 10)
 将破墙镐个数设置为10个。这里可以写任何道具的ID。
 
 
+core.addItem('pickaxe', 2)
+将破墙镐的个数增加2个，无任何特效。这里可以写任何道具的ID。
+
+
 core.getItem('pickaxe', 4)
-另勇士获得四个破墙镐。这里可以写任何道具的ID。
+令勇士获得4个破墙镐。这里可以写任何道具的ID。
+和addItem相比，使用getItem会播放获得道具的音效，也会在左上角绘制获得提示。
+
+
+core.removeItem('pickaxe', 3)
+删除3个破墙镐。第二项可忽略，默认值为1。
 
 
 core.itemCount('pickaxe')
@@ -84,6 +93,15 @@ core.hasItem('pickaxe')
 返回当前是否存在某个道具。等价于 core.itemCount('pickaxe')>0 。
 
 
+core.getEquip(0)
+获得0号装备类型（武器）的当前装备的itemId。如果不存在则返回null。
+这里可以写任意装备类型，从0开始和全塔属性中的equipName一一对应。
+
+
+core.hasEquip('sword1')
+获得当前某个具体的装备是否处于正在被装备状态。
+
+
 core.setFlag('xyz', 2)
 设置某个flag/变量的值为2。这里可以写任何的flag变量名。
 
@@ -97,11 +115,18 @@ core.hasFlag('xyz')
 返回是否存在某个变量且不为0。等价于 core.getFlag('xyz', 0)!=0 。
 
 
+core.removeFlag('xyz')
+删除某个flag/变量。
+
+
 core.insertAction(list, x, y, callback)
 插入并执行一段自定义事件。在这里你可以写任意的自定义事件列表，有关详细写法请参见文档-事件。
 x和y如果设置则覆盖"当前事件点"的坐标，callback如果设置则覆盖事件执行完毕后的回调函数。
 例如： core.insertAction(["楼层切换", {"type":"changeFloor", "floorId": "MT3"}])
 将依次显示剧情文本，并执行一个楼层切换的自定义事件。
+--------
+从V2.5.4开始提出了“公共事件”的说法，这里也可以插入一个公共事件名。
+例如：core.insertAction("毒衰咒处理") 将插入公共事件“毒衰咒处理”。
 
 
 core.changeFloor(floorId, stair, heroLoc, time, callback)    [异步]
@@ -113,21 +138,18 @@ core.changeFloor('MT5', null, {'x': 3, 'y': 6}, 0) 无动画切换到MT5层的(3
 
 
 core.resetMap()
-重置当前楼层地图。
-当我们修改某一层地图后，进游戏读档，会发现修改的内容并没有被更新上去。
-这是因为，H5的存档是会存下来每一个楼层的地图的，读档会从档里面获得地图信息。
-此时，如果我们在某一层地图执行 core.resetMap() ，则可以立刻从剧本中读取并重置当前楼层地图。
-已经被修改过的内容也会相应出现。
-
+重置当前楼层地图和楼层属性。
+此函数参数有三种形式：
+ - 不加任何参数，表示重置当前层：core.resetMap()
+ - 加上一个floorId，表示重置某一层：core.resetMap("MT1")
+ - 使用一个数组，表示重置若干层：core.resetMap(["MT1", "MT2", "MT3"])
+---------------------------
+** 说明：从V2.5.5开始存档方式发生了改变，在编辑器修改了地图后现在将直接生效，无需再重置地图。
 
 R
 录像回放的快捷键；这不是一个控制台命令，但是也把它放在这里供使用。
 录像回放在修改地图或新增数据后会很有用。
 
-
-localStorage
-获得所有的存档数据。可以用 core.getLocalStorage('save1') 来具体获得某个存档。
-
 ```
 
 !> 一些相对高级的命令，针对有一定脚本经验的人
@@ -146,13 +168,20 @@ core.nextY(n)
 获得勇士面向的第n个位置的y坐标，n可以省略默认为1（即正前方）
 
 
+core.nearHero(x, y)
+判断某个点是否和勇士的距离不超过1。
+
+
 core.openDoor(id, x, y, needKey, callback)    [异步]
 尝试开门操作。id为目标点的ID，x和y为坐标，needKey表示是否需要使用钥匙，callback为开门完毕后的回调函数。
+id可为null代表使用地图上的值。
 例如：core.openDoor('yellowDoor', 10, 3, false, function() {console.log("1")})
+此函数返回true代表成功开门，并将执行callback回调；返回false代表无法开门，且不会执行回调函数。
 
 
 core.battle(id, x, y, force, callback)    [异步]
 执行战斗事件。id为怪物的id，x和y为坐标，force为bool值表示是否是强制战斗，callback为战斗完毕后的回调函数。
+id可为null代表使用地图上的值。
 例如：core.battle('greenSlime', null, null, true)
 
 
@@ -160,10 +189,8 @@ core.trigger(x, y)    [异步]
 触发某个地点的事件。
 
 
-core.clearMap(mapName)
-清空某个画布图层。
-mapName可为'bg', 'event', 'fg', 'event2', 'hero', 'animate', 'weather', 'ui', 'data', 'all'之一。
-如果mapName为'all'，则为清空所有画布；否则只清空对应的画布。
+core.isReplaying()
+当前是否正在录像播放中
 
 
 core.drawBlock(block)
@@ -211,30 +238,36 @@ core.showBlock(x, y, floorId)
 将某个点从禁用变成启用状态。
 
 
+core.hideBlock(x, y, floorId)
+将某个点从启用变成禁用状态，但不会对其进行删除。
+此函数不会实际将该块从地图中进行删除，而是将该点设置为禁用，以供以后可能的启用事件。
+
+
 core.removeBlock(x, y, floorId)
-将某个点删除或从启用变成禁用状态。
-如果该点不存在自定义事件（比如普通的怪物），则将直接从地图中删除。
-否则将该点设置为禁用，以供以后可能的启用事件。
+将从启用变成禁用状态，并尽可能将其从地图上删除。
+和hideBlock相比，如果该点不存在自定义事件（比如门或普通的怪物），则将直接从地图中删除。
+如果存在自定义事件，则简单的禁用它，以供以后可能的启用事件。
 
 
 core.setBlock(number, x, y, floorId)
 改变图块。number为要改变到的图块数字，x和y为坐标，floorId为楼层ID，可忽略表示当前楼层。
 
 
-core.useItem(itemId, callback)
-尝试使用某个道具。itemId为道具ID，callback为成功或失败后的回调。
+core.useItem(itemId, noRoute, callback)
+尝试使用某个道具。itemId为道具ID，noRoute如果为真则该道具的使用不计入录像。
+callback为成功或失败后的回调。
 
 
 core.canUseItem(itemId)
 返回当前能否使用某个道具。
 
 
-core.addItem(itemId, number)
-将某个道具增加number个。
+core.loadEquip(itemId, callback)
+装备上某个装备。itemId为装备的ID，callback为成功或失败后的回调。
 
 
-core.removeItem(itemId)
-将某个道具个数-1；如果道具个数归0则从道具列表删除。
+core.unloadEquip(equipType, callback)
+卸下某个部位的装备。equipType为装备类型，从0开始；callback为成功或失败后的回调。
 
 
 core.getNextItem()
@@ -258,7 +291,7 @@ core.replaceText(text)
 将一段文字中的${}进行计算并替换。
 
 
-core.calValue(value)
+core.calValue(value, prefix, need, times)
 计算表达式的实际值。这个函数可以传入status:atk等这样的参数。
 
 
@@ -266,6 +299,16 @@ core.getLocalStorage(key, defaultValue)
 从localStorage中获得某个数据（已被parse）；如果对应的key不存在则返回defaultValue。
 
 
+core.getLocalForage(key, defaultValue, successCallback, errorCallback)
+从localForage中获得某个数据（已被parse），如果对应的key不存在则返回defaultValue。
+如果成功则通过successCallback回调，失败则通过errorCallback回调。
+
+
+core.hasSave(index)
+判定当前某个存档位是否存在存档，返回true/false。
+index为存档编号，0代表自动存档，大于0则为正常的存档位。
+
+
 core.clone(data)
 深拷贝某个对象。
 
@@ -299,6 +342,21 @@ actions.js主要用来进行用户交互行为的处理。
 ========== core.control.XXX 和游戏控制相关的函数 ==========
 control.js主要用来进行游戏控制，比如行走控制、自动寻路、存读档等等游戏核心内容。
 
+core.control.setGameCanvasTranslate(canvasId, x, y)
+设置大地图的偏移量
+
+
+core.control.updateViewport()
+更新大地图的可见区域
+
+
+core.control.gatherFollowers()
+立刻聚集所有的跟随者
+
+
+core.control.replay()
+回放下一个操作
+
 
 ========== core.enemys.XXX 和怪物相关的函数 ==========
 enemys.js主要用来进行怪物相关的内容，比如怪物的特殊属性，伤害和临界计算等。
@@ -317,34 +375,36 @@ core.enemys.getSpecialHint(enemy, special)
 获得怪物某个（或全部）特殊属性的文字说明。
 
 
-core.enemys.canBattle(enemyId)
+core.enemys.canBattle(enemyId, x, y, floorId)
 返回当前能否战胜某个怪物。
+后面三个参数是怪物坐标和楼层。
 
 
-core.enemys.getDamage(enemyId)
+core.enemys.getDamage(enemyId, x, y, floorId)
 返回当前对某个怪物的战斗伤害。如果无法战斗，返回null。
+后面三个参数是怪物坐标和楼层。
 
 
 core.enemys.getExtraDamage(enemyId)
 返回某个怪物会对勇士造成的额外伤害（不可被魔防抵消），例如仇恨、固伤等等。
 
 
-core.enemys.nextCriticals(enemyId, number)
+core.enemys.nextCriticals(enemyId, number, x, y, floorId)
 返回一个列表，为接下来number（可忽略，默认为1）个该怪物的临界值和临界减伤。
 列表每一项类似 [x,y] 表示临界值为x，且临界减伤为y。
 如果无临界值，则返回空列表。
 
 
-core.enemys.getDefDamage(enemyId, k)
+core.enemys.getDefDamage(enemyId, k, x, y, floorId)
 获得k（可忽略，默认为1）防减伤值。
 
 
-core.enemys.getDamageInfo(enemy, hero_hp, hero_atk, hero_def, hero_mdef)
+core.enemys.getDamageInfo(enemy, hero_hp, hero_atk, hero_def, hero_mdef, x, y, floorId)
 获得实际战斗信息，比如伤害，回合数，每回合伤害等等。
 此函数是实际战斗过程的计算。
 
 
-core.enemys.calDamage(enemy, hero_hp, hero_atk, hero_def, hero_mdef)
+core.enemys.calDamage(enemy, hero_hp, hero_atk, hero_def, hero_mdef, x, y, floorId)
 获得在某个勇士属性下怪物伤害；实际返回的是上面getDamageInfo中伤害的数值。
 
 
@@ -371,6 +431,10 @@ core.events.doAction()
 执行下一个事件。此函数中将对所有自定义事件类型分别处理。
 
 
+core.events.getCommonEvent(name)
+根据名称获得一个公共事件；如果不存在对应的公共事件则返回null。
+
+
 core.events.openShop(shopId, needVisited)    [异步]
 打开一个全局商店。needVisited表示是否需要该商店已被打开过。
 
@@ -391,6 +455,10 @@ core.events.setHeroIcon(name)
 items.js将处理和道具相关的内容，比如道具的使用，获取和删除等等。
 
 
+core.items.compareEquipment(equipId1, equipId2)
+比较两个装备的属性变化值
+
+
 ========== core.loader.XXX 和游戏加载相关的函数 ==========
 loader.js将主要用来进行资源的加载，比如加载音乐、图片、动画等等。
 
@@ -399,6 +467,10 @@ loader.js将主要用来进行资源的加载，比如加载音乐、图片、
 maps.js主要用来进行地图相关的的操作。包括绘制地图，获取地图上的点等等。
 
 
+core.maps.getNumberById(id)
+根据ID来获得对应的数字。如果该ID不存在对应的数字则返回0。
+
+
 core.maps.canMoveHero(x,y,direction,floorId)
 判断能否前往某个方向。x,y为坐标，可忽略为当前点；direction为方向，可忽略为当前方向。
 floorId为楼层ID，可忽略为当前楼层。
@@ -417,10 +489,113 @@ core.maps.removeBlockByIds(floorId, ids)
 根据索引删除或禁用若干块。
 
 
+core.maps.drawAnimate(name, x, y, callback)
+播放一段动画，name为动画名（需在全塔属性注册），x和y为坐标（0-12之间），callback可选，为播放完毕的回调函数。
+播放过程是异步的，如需等待播放完毕请使用insertAction插入一条type:waitAsync事件。
+此函数将随机返回一个数字id，为此异步动画的唯一标识符。
+
+
+core.maps.stopAnimate(id, doCallback)
+立刻停止一个异步动画。
+id为该动画的唯一标识符（由drawAnimate函数返回），doCallback可选，若为true则会执行该动画所绑定的回调函数。
+
+
 ========== core.ui.XXX 和对话框绘制相关的函数 ==========
 ui.js主要用来进行UI窗口的绘制，比如对话框、怪物手册、楼传器、存读档界面等等。
 
 
+core.ui.getContextByName(canvas)
+根据画布名找到一个画布的context；支持系统画布和自定义画布。如果不存在画布返回null。
+也可以传画布的context自身，则返回自己。
+
+
+core.clearMap(name)
+清空某个画布图层。
+name为画布名，可以是系统画布之一，也可以是任意自定义动态创建的画布名；还可以直接传画布的context本身。（下同）
+如果name也可以是'all'，若为all则为清空所有系统画布。
+
+
+core.ui.fillText(name, text, x, y, style, font)
+在某个画布上绘制一段文字。
+text为要绘制的文本，x,y为要绘制的坐标，style可选为绘制的样式，font可选为绘制的字体。（下同）
+
+
+core.ui.fillBoldText(name, text, x, y, style, font)
+在某个画布上绘制一个描黑边的文字。
+
+
+core.ui.fillRect(name, x, y, width, height, style)
+绘制一个矩形。style可选为绘制样式。
+
+
+core.ui.strokeRect(name, x, y, width, height, style)
+绘制一个矩形的边框。
+
+
+core.ui.drawLine(name, x1, y1, x2, y2, style, lineWidth)
+绘制一条线。lineWidth可选为线宽。
+
+
+core.ui.drawArrow(name, x1, y1, x2, y2, style, lineWidth)
+绘制一个箭头。
+
+
+core.ui.setFont(name, font) / core.ui.setLineWidth(name, lineWidth)
+设置一个画布的字体/线宽。
+
+
+core.ui.setAlpha(name, font) / core.ui.setOpacity(name, font)
+设置一个画布的绘制不透明度和画布本身的不透明度。
+两者区别如下：
+ - setAlpha是设置"接下来绘制的内容的不透明度"，不会对已经绘制的内容产生影响。比如setAlpha('ui', 0.5)则会在接下来的绘制中使用0.5的不透明度。
+ - setOpacity是设置"画布本身的不透明度"，已经绘制的内容也会产生影响。比如我已经在UI层绘制了一段文字，再setOpacity则也会看起来变得透明。
+尽量不要对系统画布使用setOpacity（因为会对已经绘制的内容产生影响），自定义创建的画布则不受此限制。
+
+
+core.ui.setFillStyle(name, style) / core.ui.setStrokeStyle(name, style)
+设置一个画布的填充样式/描边样式。
+
+
+core.ui.setTextAlign(name, align)
+设置一个画布的文字对齐模式。
+
+
+core.ui.calWidth(name, text, font)
+计算一段文字在画布上的绘制宽度
+font可选，如果存在则会先设置该画布上的字体。
+
+
+core.ui.drawImage(name, image, x, y, w, h, x1, y1, w1, h1)
+在一个画布上绘制图片。
+name为画布名，可以是系统画布之一，也可以是任意自定义动态创建的画布名；还可以直接传画布的context本身。
+image为要绘制的图片，可以是一个全塔属性中定义的图片名（会从images中去获取），图片本身，或者一个画布。
+后面的8个坐标参数与canvas的drawImage的八个参数完全相同。
+请查看 http://www.w3school.com.cn/html5/canvas_drawimage.asp 了解更多。
+
+
+core.ui.createCanvas(name, x, y, width, height, zIndex)
+动态创建一个画布。name为要创建的画布名，如果已存在则会直接取用当前存在的。
+x,y为创建的画布相对窗口左上角的像素坐标，width,height为创建的长宽。
+zIndex为创建的纵向高度（关系到画布之间的覆盖），z值高的将覆盖z值低的；系统画布的z值可在个性化中查看。
+返回创建的画布的context，也可以通过core.dymCanvas[name]调用。
+
+
+core.ui.relocateCanvas(name, x, y)
+重新定位一个自定义画布。
+
+
+core.ui.resizeCanvas(name, x, y)
+重新设置一个自定义画布的大小。
+
+
+core.ui.deleteCanvas(name)
+删除一个自定义画布。
+
+
+core.ui.deleteAllCanvas()
+清空所有的自定义画布。
+
+
 core.ui.drawThumbnail(floorId, canvas, blocks, x, y, size, heroLoc, heroIcon)
 绘制一个缩略图，比如楼传器界面，存读档界面等情况。
 floorId为目标楼层ID，canvas为要绘制到的图层，blocks为要绘制的所有图块。
@@ -440,6 +615,10 @@ core.utils.cropImage(image, size)
 纵向对图片进行切分（裁剪）。
 
 
+core.utils.push(a,b)
+向某个数组后插入另一个数组或元素
+
+
 core.utils.unshift(a, b)
 向某个数组前插入另一个数组或元素
 
@@ -452,14 +631,31 @@ core.utils.decodeBase64(str)
 Base64解密字符串
 
 
-core.utils.formatBigNumber(x)
+core.utils.formatBigNumber(x, onMap)
 大数据的格式化
 
 
+core.utils.subarray(a, b)
+检查b是否是a的从头开始子串。
+如果是，则返回a删去b的一段；否则返回null。
+
+
+core.utils.same(a, b)
+比较a和b两个对象是否相同
+
+
+core.utils.clamp(x, a, b)
+将x限制在[a,b]之间的范围内
+
+
 core.utils.arrayToRGB(color)
 将形如[255,0,0]之类的数组转成#FF0000这样的RGB形式。
 
 
+core.utils.arrayToRGBA(color)
+将形如[255,0,0,1]之类的数组转成rgba(255,0,0,1)这样的RGBA形式。
+
+
 core.utils.encodeRoute(list)
 压缩加密路线。可以使用core.encodeRoute(core.status.route)来压缩当前路线。
 
diff --git a/docs/_sidebar.md b/_docs/_sidebar.md
similarity index 82%
rename from docs/_sidebar.md
rename to _docs/_sidebar.md
index a7960592..914ee883 100644
--- a/docs/_sidebar.md
+++ b/_docs/_sidebar.md
@@ -3,5 +3,5 @@
 - [元件说明](element)
 - [事件](event)
 - [个性化](personalization)
-- [V2.0版本介绍](V2.0)
+- [脚本](script)
 - [附录：API列表](api)
diff --git a/_docs/api.md b/_docs/api.md
new file mode 100644
index 00000000..c1c65a3d
--- /dev/null
+++ b/_docs/api.md
@@ -0,0 +1,2111 @@
+# 附录：API列表
+
+?> 目前版本**v2.6.1**，上次更新时间：* {docsify-updated} *
+
+这里将列出所有被转发到core的API，没有被转发的函数此处不会列出，请自行在代码中查看。
+
+本附录量较大，如有什么需求请自行Ctrl+F进行搜索。
+
+如有任何疑问，请联系小艾寻求帮助。
+
+## core.js
+
+core.js中只有很少的几个函数，主要是游戏开始前的初始化等。
+
+但是，core中定义了很多游戏运行时的状态，这些状态很多都会被使用到。
+
+``` text
+core.__SIZE__, core.__PIXELS__
+游戏窗口大小；对于13x13的游戏而言这两个值分别是13和416，15x15来说分别是15和480。
+
+
+core.material
+游戏中的所有资源列表，具体分为如下内容：
+core.material.animates  （动画）
+core.material.bgms    （背景音乐）
+core.material.enemys    （怪物信息，来自于 project/enemys.js）
+core.material.icons    （图标信息，来自于 project/icons.js）
+core.material.images    （图片素材，存放了各项素材图片如items.png等）
+    core.material.images.autotile    （所有的自动元件图片）
+    core.material.images.tilesets    （所有的额外素材图片）
+    core.material.images.images    （用户引入的其他图片）
+core.material.items    （道具信息）
+core.material.sounds    （音效）
+
+
+core.animateFrame
+主要是记录和requestAnimationFrame相关的一些数据，常用的如下：
+core.animateFrame.totalTime    （游戏总的运行时时间）
+core.animateFrame.weather    （当前的天气信息）
+core.animateFrame.asyncId    （当前的异步处理事件的内容）
+
+
+core.musicStatus
+主要是记录和音效相关的内容，常用的如下：
+core.musicStatus.bgmStatus    （音乐开启状态）
+core.musicStatus.soundStatus    （音效开启状态）
+core.musicStatus.playingBgm    （当前正在播放的BGM）
+core.musicStatus.lastBgm    （最近一次尝试播放的BGM）
+core.musicStatus.volume    （当前的音量）
+core.musicStatus.cachedBgms    （背景音乐的缓存内容）
+core.musicStatus.cacheBgmCount    （背景音乐的缓存数量，默认值是4）
+
+
+core.platform
+游戏平台相关信息，常见的几个如下：
+core.platform.isPC    （是否是电脑端）
+core.platform.isAndroid    （是否是安卓端）
+core.platform.isIOS    （是否是iOS端）
+core.platform.useLocalForage    （是否开启了新版存档）
+core.platform.extendKeyBoard    （是否开启了拓展键盘）
+
+
+core.domStyle
+游戏的界面信息，包含如下几个：
+core.domStyle.scale    （当前的放缩比）
+core.domStyle.isVertical    （当前是否是竖屏状态）
+core.domStyle.showStatusBar    （当前是否显示状态栏）
+core.domStyle.toolbarBtn    （当前是否显示工具栏）
+
+
+core.bigmap
+当前的地图的尺寸信息，主要包含如下几个
+core.bigmap.width    （当前地图的宽度）
+core.bigmap.height    （当前地图的高度）
+core.bigmap.offsetX    （当前地图针对窗口左上角的偏移像素x）
+core.bigmap.offsetX    （当前地图针对窗口左上角的偏移像素y）
+core.bigmap.tempCanvas    （一个临时画布，可以用来临时绘制很多东西）
+
+
+core.saves
+和存档相关的信息，包含如下几个：
+core.saves.saveIndex    （上次保存或读取的存档编号）
+core.saves.ids    （当前存在存档的编号列表）
+core.saves.autosave    （自动存档的信息）
+core.saves.favorite    （收藏的存档）
+core.saves.favoriteNames    （自定义存档的名称）
+
+
+core.status
+游戏的状态相关，是整个游戏中最重要的东西，其核心是如下几条：
+请注意，每次重新开始、存档或读档时，core.status都会重新初始化。
+core.status.played    （当前是否在游戏中）
+core.status.gameOver    （当前是否已经游戏结束，即win或lose）
+core.status.hero    （勇士信息；此项和全塔属性中的hero大体是对应的）
+    core.status.hero.name    勇士名
+    core.status.hero.lv      当前等级
+    core.status.hero.hpmax   当前生命上限
+    core.status.hero.hp      当前生命值
+    core.status.hero.manamax   当前魔力上限
+    core.status.hero.mana    当前魔力值
+    core.status.hero.atk     当前攻击力
+    core.status.hero.def     当前防御力
+    core.status.hero.mdef    当前魔防值
+    core.status.hero.money   当前金币值
+    core.status.hero.experience    当前经验值
+    core.status.hero.loc     当前的位置信息
+    core.status.hero.equipment     当前装上的装备
+    core.status.hero.items   当前拥有的道具信息
+    core.status.hero.flags   当前的各项flag信息
+    core.status.hero.step    当前的步数值
+    core.status.hero.statistics    当前的统计信息
+core.status.floorId    （当前所在的楼层）    
+core.status.maps    （所有的地图信息）
+core.status.thisMap    （当前的地图信息，等价于core.status.maps[core.status.floorId]）
+core.status.bgmaps   （所有背景层的信息）
+core.status.fgmaps    （所有的前景层的信息）
+core.status.checkBlock    （地图上的阻激夹域信息，也作为光环的缓存）
+core.status.lockControl    （当前是否是控制锁定状态）
+core.status.automaticRoute    （当前的自动寻路信息）
+core.status.route    （当前记录的录像）
+core.status.replay    （录像回放时要用到的信息）
+core.status.shops    （所有全局商店信息）
+core.status.textAttribute    （当前的文字属性，如颜色、背景等信息，和setText事件对应）
+core.status.globalAttribute    （当前的全局属性，如边框色、装备栏等）
+core.status.curtainColor    （当前色调层的颜色）
+core.status.globalAnimateObjs    （当前的全局帧动画效果）
+core.status.floorAnimateObjs    （当前的楼层贴图帧动画效果）
+core.status.boxAnimateObjs    （当前的盒子帧动画效果，例如怪物手册中的怪物）
+core.status.autotileAnimateObjs    （当前楼层的自动元件动画效果）
+core.status.globalAnimateStatus    （当前的帧动画的状态）
+core.status.animateObjs    （当前的播放动画信息）
+
+
+core.floorIds
+一个数组，表示所有的楼层ID，和全塔属性中的floorIds一致。
+
+
+core.floors
+从楼层文件中读取全部的地图数据。
+和core.status.maps不同的是，后者在每次重新开始和读档时都会重置，也允许被修改（会存入存档）。
+而core.floors全程唯一，不允许被修改。
+
+
+core.statusBar
+状态栏信息，例如状态栏图片，图标，以及各个内容的DOM定义等。
+core.statusBar.images    （所有的系统图标，和icons.png对应）
+core.statusBar.icons    （状态栏中绘制的图标内容）
+
+
+core.values
+所有的全局数值信息，和全塔属性中的values一致。
+此项允许被直接修改，会存入存档。
+
+
+core.flags
+所有的全塔开关，和全塔属性中的flags一致。
+此项不允许被直接修改，如有需要请使用“设置系统开关”事件，或者调用core.setGlobalFlag这个API。
+
+
+core.plugin
+定义的插件函数。
+
+
+core.doFunc(func, _this)
+执行一个函数，func为函数体或者插件中的函数名，_this为使用的this。
+如果func为一个字符串，则视为插件中的函数名，同时_this将被设置成core.plugin。
+此函数剩余参数将作为参数被传入func。
+```
+
+## actions.js
+
+actions.js主要是处理一些和用户交互相关的内容。
+
+```text
+core.registerAction(action, name, func, priority)
+注册一个用户交互行为。
+action：要注册的交互类型，如 ondown, onclick, keyDown 等等。
+name：你的自定义名称，可被注销使用；同名重复注册将后者覆盖前者。
+func：执行函数；可以是一个具体的函数体，或者是一个插件中的函数名。
+priority：优先级；优先级高的被注册项将会被执行。此项可不填，默认为0。
+返回：如果func返回true，则不会再继续执行其他的交互函数；否则会继续执行其他的交互函数。
+
+
+core.unregisterAction(action, name)
+注销一个用户交互行为。
+
+
+core.doRegisteredAction(action)
+执行一个用户交互行为。
+此函数将在该交互行为所注册的所有函数中，按照优先级从高到底依次执行。
+此函数剩余的参数将会作为参数传入该执行函数中。
+当某个执行函数返回true时将终止这一过程。
+
+
+core.onkeyDown(e)
+当按下某个键时的操作，e为KeyboardEvent。
+请勿直接覆盖或调用此函数，如有需要请注册一个"onkeyDown"的交互函数。
+
+
+core.onkeyUp(e)
+当放开某个键时的操作，e为KeyboardEvent。
+请勿直接覆盖或调用此函数，如有需要请注册一个"onkeyUp"的交互函数。
+
+
+core.pressKey(keyCode)
+当按住某个键不动时的操作，目前只对方向键有效。
+如果需要添加对于其他键的长按，请复写_sys_onkeyDown和_sys_onkeyUp。
+请勿直接覆盖或调用此函数，如有需要请注册一个"pressKey"的交互函数。
+
+
+core.keyDown(keyCode)
+当按下某个键时的操作，参数为该键的keyCode值。
+请勿直接覆盖或调用此函数，如有需要请注册一个"keyDown"的交互函数。
+
+
+core.keyUp(keyCode, altKey, fromReplay)
+当按下某个键时的操作，参数为该键的keyCode值。
+altKey标志了Alt键是否同时被按下，fromReplay表示是否是从录像回放中调用的。
+请勿直接覆盖或调用此函数，如有需要请注册一个"keyUp"的交互函数。
+
+
+core.ondown(loc)
+当点击屏幕时的操作。loc为点击的信息。
+请勿直接覆盖或调用此函数，如有需要请注册一个"ondown"的交互函数。
+注册的ondown交互函数需要接受x, y, px, py四个参数，代表点击的位置和像素坐标。
+
+
+core.onmove(loc)
+当在屏幕上滑动时的操作。loc为当前的坐标信息。
+请勿直接覆盖或调用此函数，如有需要请注册一个"onmove"的交互函数。
+注册的onmove交互函数需要接受x, y, px, py四个参数，代表当前的的位置和像素坐标。
+
+
+core.onup()
+当从屏幕上离开时的操作。请注意此函数是没有参数的。
+请勿直接覆盖或调用此函数，如有需要请注册一个"onup"的交互函数。
+
+
+core.onclick(x, y)
+当点击屏幕上的某点位置时执行的操作，请注意这里的x和y是位置坐标。
+一般而言，一个完整的ondown到onup将触发一个onclick事件。
+请勿直接覆盖或调用此函数，如有需要请注册一个"onclick"的交互函数。
+
+
+core.onmousewheel(direct)
+当滚动鼠标滑轮时执行的操作。direct为滑轮方向，上为1，下为-1。
+请勿直接覆盖或调用此函数，如有需要请注册一个"onmousewheel"的交互函数。
+
+
+core.keyDownCtrl()
+当长按Ctrl键不动时执行的操作。
+请勿直接覆盖或调用此函数，如有需要请注册一个"keyDownCtrl"的交互函数。
+
+
+core.longClick()
+当长按住屏幕时执行的操作。
+请勿直接覆盖或调用此函数，如有需要请注册一个"keyDownCtrl"的交互函数。
+注册的交互函数如果某一项返回true，则之后仍然会继续触发该长按，
+如果全部返回false则将停止本次长按行为，直到手指离开屏幕并重新进行长按为止。
+```
+
+## control.js
+
+control.js将负责整个游戏的核心控制系统，分为如下几个部分：
+- requestAnimationFrame相关
+- 标题界面，开始和重新开始游戏
+- 自动寻路和人物行走相关
+- 画布、位置、阻激夹域、显伤等相关
+- 录像的回放相关
+- 存读档，自动存档，同步存档等相关
+- 人物属性和状态、位置、变量等相关
+- 天气、色调、音乐和音效的播放
+- 状态栏和工具栏相关
+- 界面resize相关
+
+```text
+// ------ requestAnimationFrame 相关 ------ //
+
+core.registerAnimationFrame(name, needPlaying, func)
+注册一个animationFrame。它将在每次浏览器的帧刷新时（约16.6ms）被执行。
+name：你的自定义名称，可被注销使用；同名重复注册将后者覆盖前者。
+needPlaying：如果此项为true，则仅在游戏开始后才会被执行（标题界面不执行）
+func：执行函数；可以是一个具体的函数体，或者是一个插件中的函数名。
+func可以接受一个timestamp作为参数，表示从整个页面加载完毕到当前时刻所经过的毫秒数。
+如果func执行报错，将在控制台打出一条信息，并自动进行注销。
+
+
+core.unregisterAnimationFrame(name)
+注销一个animationFrame，参数是你的上面的自定义名称。
+
+// ------ 开始界面相关 ------ //
+
+core.showStartAnimate(noAnimate, callback)
+重置所有内容并显示游戏标题界面。
+noAnimate如果为true则不会有淡入动画，callback为执行完毕的回调。
+
+
+core.hideStartAnimate(callback)
+淡出隐藏游戏标题界面，callback为执行完毕的回调。
+
+
+core.isPlaying()
+当前是否正在游戏中。
+
+
+core.clearStatus()
+清除所有的游戏状态和数据，包括状态栏的显示。
+
+// ------ 自动寻路、人物行走 ------ //
+
+core.stopAutomaticRoute()
+停止自动寻路的操作
+
+
+core.saveAndStopAutomaticRoute()
+保存剩下的寻路路线并停止自动寻路操作。主要用于打怪开门后继续寻路使用。
+
+
+core.continueAutomaticRoute()
+继续剩下的自动寻路操作。主要用于打怪开门后继续寻路使用。
+
+
+core.clearContinueAutomaticRoute()
+清空剩下的自动寻路操作。
+
+
+core.setAutomaticRoute(destX, destY, stepPostfix)
+尝试开始进行一个自动寻路。stepPostfix是鼠标拖动的路径。
+此函数将检测是否在寻路中（在则停止或双击瞬移），检测是否点击自己（转身或轻按），
+检测是否能单击瞬移，最后找寻自动寻路路线并开始寻路。
+
+
+core.setAutoHeroMove(steps)
+设置勇士的自动行走路线，并立刻开始行走。
+
+
+core.setHeroMoveInterval(callback)
+设置勇士行走动画。callback是每一步行走完毕后的回调。
+
+
+core.moveOneStep(x, y)
+每走完一步后执行的操作，被转发到了脚本编辑中。
+
+
+core.moveAction(callback)
+尝试执行单步行走。callback是执行完毕的回调。
+如果勇士面对的方向是noPass的，将直接触发事件并执行回调。
+
+
+core.moveHero(direction, callback)
+令勇士朝一个方向行走。如果设置了callback，则只会行走一步，并执行回调。
+否则，将一直朝该方向行走，直到core.status.heroStop为true为止。
+
+
+core.isMoving()
+当前是否正在处于行走状态
+
+
+core.waitHeroToStop(callback)
+停止勇士的行走，等待行动结束后，再异步执行回调。
+
+
+core.turnHero(direction)
+转向。如果设置了direction则会转到该方向，否则会右转。该函数会自动计入录像。
+
+
+core.moveDirectly(destX, destY)
+尝试瞬间移动到某点，被转发到了脚本编辑中。
+此函数返回非负值代表成功进行瞬移，返回值是省略的步数；如果返回-1则代表没有成功瞬移。
+
+
+core.tryMoveDirectly(destX, destY)
+尝试单击瞬移到某点。
+如果该点可被直接瞬间移动到，则直接瞬移到该点；否则尝试瞬移到相邻的上下左右点并行走一步。
+
+
+core.drawHero(status, offset)
+绘制勇士。
+status可选，为'stop','leftFoot'和'rightFoot'之一，不填或null默认是'stop'。
+offset可选，表示具体当前格子的偏移量。不填默认为0。
+此函数将重新计算地图的偏移量，调整窗口位置，绘制勇士和跟随者信息。
+
+// ------ 画布、位置、阻激夹域、显伤 ------ //
+
+core.setGameCanvasTranslate(canvas, x, y)
+设置某个画布的偏移量
+
+
+core.addGameCanvasTranslate(x, y)
+加减所有系统画布（ui和data除外）的偏移量。主要是被“画面震动”所使用。
+
+
+core.updateViewport()
+根据大地图的偏移量来更新窗口的视野范围。
+
+
+core.nextX(n) / core.nextY(n)
+获得勇士面对的第n个位置的横纵坐标。n可不填，默认为1。
+
+
+core.nearHero(x, y, n)
+判定某个点是否和勇士的距离不大于n。n可不填，默认为1。
+
+
+core.gatherFollowers()
+聚集所有的跟随者到勇士的位置。
+
+
+core.updateFollowers()
+更新跟随者们的坐标。
+
+
+core.updateCheckBlock(floorId)
+更新阻激夹域的信息，被转发到了脚本编辑中。
+
+
+core.checkBlock()
+检查勇士坐标点的阻激夹域信息。
+
+
+core.updateDamage(floorId, ctx)
+更新全地图的显伤。floorId可选，默认为当前楼层。
+ctx可选，为画布；如果不为空，则将会绘制到该画布上而不是damage层上。
+
+// ------ 录像相关 ------ //
+
+core.chooseReplayFile()
+弹出选择文件窗口，让用户选择录像文件。
+
+
+core.startReplay(list)
+开始播放一段录像。list为录像的操作数组。
+
+
+core.triggerReplay()
+播放或暂停录像，实际上是pauseReplay或resumeReplay之一。
+
+
+core.pauseReplay() / core.resumeReplay()
+暂停和继续录像播放。
+
+
+core.speedUpReplay() / core.speedDownReplay()
+加速和减速录像播放。
+
+
+core.setReplaySpeed(speed)
+直接设置录像回放速度。
+
+
+core.stopReplay(force)
+停止录像回放。如果force为true则强制停止。
+
+
+core.rewindReplay()
+回退一个录像节点。
+
+
+core.saveReplay() / core.bookReplay() / core.viewMapReplay()
+回放录像时的存档、查看怪物手册、浏览地图操作。
+
+
+core.isReplaying()
+当前是否正在录像播放中。
+
+
+core.registerReplayAction(name, func)
+注册一个自定义的录像行为。
+name：自定义名称，可用户注销使用。
+func：具体执行录像的函数，是一个函数体或者插件中的函数名。
+func需要接受action参数，代表录像回放时的当前操作行为。
+如果func返回true，则代表成功处理了此次操作，返回false代表没有进行处理。
+自己添加的录像项只能由数字、大小写、下划线线、冒号等符号组成，否则无法正常压缩和解压缩。
+对于自定义内容（比如中文文本或数组）请使用JSON.stringify再core.encodeBase64处理。
+请注意回放录像时的二次记录问题（即回放时录像会重新记录路线）。
+
+
+core.unregisterReplayAction(name)
+注销一个录像行为。此函数一般不应当被使用。
+
+// ------ 存读档相关 ------ //
+
+core.autosave(remoreLast)
+进行一个自动存档，实际上是加入到缓存之中。
+removeLast如果为true则会从路线中删除最后一项再存（打怪开门前的状态）。
+在事件处理中不允许调用本函数，如有需要请呼出存档页面。
+
+
+core.checkAutosave()
+将缓存的自动存档写入存储中。平均每五秒钟，或在窗口失去焦点时被执行。
+
+
+core.doSL(id, type)
+实际执行一个存读档事件。id为存档编号，自动存档为'autoSave'。
+type只能为'save', 'load', 'replayLoad'之一，代表存档、读档和从存档回放录像。
+
+
+core.syncSave(type) / core.syncLoad()
+向服务器同步存档，从服务器加载存档。type如果为'all'则会向服务器同步所有存档。
+
+
+core.saveData()
+获得要存档的内容，实际转发到了脚本编辑中。
+
+
+core.loadData(data, callback)
+实际执行一次读档行为，data为读取到的数据，callback为执行完毕的回调。
+实际转发到了脚本编辑中。
+
+
+core.getSave(index, callback)
+获得某个存档位的存档。index为存档编号，0代表自动存档。
+
+
+core.getSaves(ids, callback)
+获得若干个存档位的存档。ids为一个存档编号数组，0代表自动存档。
+
+
+core.getAllSaves(callback)
+获得全部的存档内容。目前仅被同步全部存档和下载全部存档所调用。
+
+
+core.getSaveIndexes(callback)
+刷新全部的存档信息，将哪些档位有存档的记录到core.saves.ids中。
+
+
+core.hasSave(index)
+判定某个存档位是否存在存档。index为存档编号，0代表自动存档。
+
+
+core.removeSave(index)
+删除某个存档。index为存档编号，0代表自动存档。
+
+
+// ------ 属性、状态、位置、变量等 ------ //
+
+core.setStatus(name, value)
+设置勇士当前的某个属性。
+
+
+core.addStatus(name, value)
+加减勇士当前的某个属性。等价于 core.setStatus(name, core.getStatus(name) + value)
+
+
+core.getStatus(name)
+获得勇士的某个原始属性值。
+
+
+core.getStatusOrDefault(status, name)
+尝试从status中获得某个原始属性值；如果status为null或不存在对应属性值则从勇士属性中获取。
+此项在伤害计算函数中使用较多，例如传递新的攻击和防御来计算临界和1防减伤。
+
+
+core.getRealStatus(name)
+获得勇士的某个计算属性值。该属性值是在加成buff之后得到的。
+该函数等价于 core.getStatus(name) * core.getBuff(name)
+
+
+core.getRealStatusOrDefault(status, name)
+尝试从status中获得某个原始属性值再进行增幅，如果不存在则获取勇士本身的计算属性值。
+
+
+core.setBuff(name, value)
+设置勇士的某个属性的增幅值。value为1代表无增幅。
+
+
+core.addBuff(name, value)
+增减勇士的某个属性的增幅值。等价于 core.setBuff(name, core.getBuff(name) + value)
+
+
+core.getBuff(name)
+获得勇士的某个属性的增幅值。默认值是1。
+
+
+core.setHeroLoc(name, value, noGather)
+设置勇士位置属性。name只能为'x', 'y'和'direction'之一。
+如果noGather为true，则不会聚集所有的跟随者。
+
+
+core.getHeroLoc(name)
+获得勇士的某个位置属性。如果name为null则直接返回core.status.hero.loc。
+
+
+core.getLvName(lv)
+获得某个等级对应的名称，其在全塔属性的levelUp中定义。如果不存在则返回原始数值。
+
+
+core.setFlag(name, value)
+设置某个自定义变量或flag。如果value为null则会调用core.removeFlag进行删除。
+
+
+core.addFlag(name, value)
+加减某个自定义的变量或flag。等价于 core.setFlag(name, core.getFlag(name, 0) + value)
+
+
+core.getFlag(name, defaultValue)
+获得某个自定义的变量或flag。如果该flag不存在（从未赋值过），则返回defaultValue值。
+
+
+core.hasFlag(name)
+判定是否拥有某个自定义变量或flag。等价于 !!core.getFlag(name, 0)
+
+
+core.removeFlag(name)
+删除一个自定义变量或flag。
+
+
+core.lockControl() / core.unlockControl()
+锁定和解锁控制。常常应用于事件处理。
+
+
+core.debug()
+开启调试模式。此模式下可以按住Ctrl进行穿墙。
+
+// ------ 天气，色调，音乐和音效 ------ // 
+
+core.setWeather(type, level)
+设置当前的天气。type只能为'rain', 'snow'或'fog'，level为1-10之间代表强度信息。
+
+
+core.setCurtain(color, time, callback)
+更改画面色调。color为更改到的色调，是个三元或四元组；time为渐变时间，0代表立刻切换。
+
+
+core.screenFlash(color, time, times, callback)
+画面闪烁。color为色调，三元或四元组；time为单次闪烁时间，times为总闪烁次数。
+
+
+core.playBgm(bgm, startTime)
+播放一个bgm。startTime可以控制开始时间，不填默认为0。
+如果bgm不存在、不被支持，或当前不允许播放背景音乐，则会跳过。
+
+
+core.pauseBgm() / core.resumeBgm()
+暂停和恢复当前bgm的播放。
+
+
+core.triggerBgm()
+更改当前bgm的播放状态。
+
+
+core.playSound(sound) / core.stopSound()
+播放一个音效，停止全部音效。
+如果sound不存在、不被支持，或当前不允许播放音效，则会忽略。
+
+
+core.checkBgm()
+检查bgm的状态。
+有的时候，刚打开页面时，浏览器是不允许自动播放标题界面bgm的，一定要经过一次用户操作行为。
+这时候我们可以给开始按钮增加core.checkBgm()，如果之前没有成功播放则重新播放。
+
+// ------ 状态栏和工具栏相关 ------ //
+
+core.clearStatusBar()
+清空状态栏的数据。
+
+
+core.updateStatusBar()
+更新状态栏，被转发到了脚本编辑中。此函数还会根据是否在回放来设置工具栏的图标。
+
+
+core.showStatusBar() / core.hideStatusBar(showToolbox)
+显示和隐藏状态栏。
+如果showToolbox为true，则在竖屏模式下不隐藏工具栏，方便手机存读档操作。
+
+
+core.updateHeroIcon()
+更新状态栏上的勇士图标。
+
+
+core.updateGlobalAttribute()
+更新全局属性，例如状态栏的背景图等。
+
+
+core.setToolbarButton(useButtom)
+设置工具栏是否是拓展键盘。
+
+// ------ resize 相关 ------ //
+
+core.registerResize(name, func)
+注册一个resize函数。
+name为自定义名称，可供注销使用。
+func可以是一个函数，或插件中的函数名，可以接受一个obj作为参数。
+具体详见resize函数。
+
+
+core.unregisterResize(name)
+注销一个resize函数。
+
+
+core.resize()
+屏幕分辨率改变后的重新自适应。
+此函数将根据当前的屏幕分辨率信息，生成一个obj，并传入各个注册好的resize函数中执行。
+```
+
+## enemys.js
+
+enemys.js中定义了一系列和怪物相关的API函数。
+
+```text
+core.hasSpecial(special, test)
+判断是否含有某个特殊属性。test为要检查的特殊属性编号。
+special为要测试的内容，允许接收如下类型参数：
+ - 一个数字：将直接和test进行判等。
+ - 一个数组：将检查test是否在该数组之中存在。
+ - 一个怪物信息：将检查test是否在该怪物的特殊属性中存在
+ - 一个字符串：视为怪物ID，将检查该怪物的特殊属性
+
+
+core.getSpecials()
+获得所有特殊属性的列表。实际上被转发到了脚本编辑中。
+
+
+core.getSpecialText(enemy)
+获得某个怪物的全部特殊属性名称。enemy可以是怪物信息或怪物ID。
+将返回一个数组，每一项是该怪物所拥有的一个特殊属性的名称。
+
+
+core.getSpecialHint(enemy, special)
+获得怪物的某个特殊属性的描述。enemy可以是怪物信息或怪物ID，special为该特殊属性编号。
+
+
+core.canBattle(enemy, x, y, floorId)
+判定当前能否战胜某个怪物。
+enemy可以是怪物信息或怪物ID，x,y,floorId为当前坐标和楼层。（下同）
+能战胜返回true，不能战胜返回false。
+
+
+core.getDamage(enemy, x, y, floorId)
+获得某个怪物的全部伤害值。
+如果没有破防或无法战斗则返回null，否则返回具体的伤害值。
+
+
+core.getExtraDamage(enemy, x, y, floorId)
+获得某个怪物的额外伤害值（不可被魔防减伤）。
+目前暂时只包含了仇恨和固伤两者，如有需要可复写该函数。
+
+
+core.getDamageString(enemy, x, y, floorId)
+获得某个怪物伤害字符串和颜色信息，以便于在地图上绘制显伤。
+
+
+core.nextCriticals(enemy, number, x, y, floorId)
+获得接下来的N个临界值和临界减伤。enemy可以是怪物信息或怪物ID，x,y,floorId为当前坐标和楼层。
+number为要计算的临界值数量，不填默认为1。
+如果全塔属性中的useLoop开关被开启，则将使用循环法或二分法计算临界，否则使用回合法计算临界。
+返回一个二维数组 [[x1,y1],[x2,y2],...] 表示接下来的每个临界值和减伤值。
+
+
+core.getDefDamage(enemy, k, x, y, floorId)
+获得某个怪物的k防减伤值。k可不填默认为1。
+
+
+core.getEnemyInfo(enemy, hero, x, y, floorId)
+获得某个怪物的实际计算时的属性。该函数实际被转发到了脚本编辑中。
+hero可为null或一个对象，具体将使用core.getRealStatusOrDefault(hero, "atk")来获得攻击力数值。
+该函数应当返回一个对象，记录了怪物的实际计算时的属性。
+
+
+core.getDamageInfo(enemy, hero, x, y, floorId)
+获得某个怪物的战斗信息。该函数实际被转发到了脚本编辑中。
+hero可为null或一个对象，具体将使用core.getRealStatusOrDefault(hero, "atk")来获得攻击力数值。
+如果该函数返回null，则代表不可战斗（如没有破防，或无敌等）。
+否则，该函数应该返回一个对象，记录了战斗伤害信息，如战斗回合数等。
+从V2.5.5开始，该函数也允许直接返回一个数字，代表战斗伤害值，此时回合数将视为0。
+
+
+core.updateEnemys()
+更新怪物数据。该函数实际被转发到了脚本编辑中。详见文档-事件-更新怪物数据。
+
+
+core.getCurrentEnemys(floorId)
+获得某个楼层不重复的怪物信息，floorId不填默认为当前楼层。该函数会被怪物手册所调用。
+该函数将返回一个列表，每一项都是一个不同的怪物，按照伤害值从小到大排序。
+另外值得注意的是，如果设置了某个怪物的displayIdInBook，则会返回对应的怪物。
+
+
+core.hasEnemyLeft(enemyId, floorId)
+检查某个楼层是否还有剩余的（指定）怪物。
+floorId为楼层ID，可忽略表示当前楼层。也可以传数组如["MT0","MT1"]同时检测多个楼层。
+enemyId如果不填或null则检查是否剩余任何怪物，否则只检查是否剩余指定的某类怪物。
+```
+
+## events.js
+
+events.js将处理所有和事件相关的操作，主要分为五个部分：
+- 游戏的开始和结束
+- 系统事件的处理
+- 自定义事件的处理
+- 点击状态栏图标所进行的操作
+- 一些具体事件的执行内容
+
+
+```text
+// ------ 游戏的开始和结束 ------ //
+
+core.resetGame(hero, hard, floorId, maps, values)
+重置整个游戏。该函数实际被转发到了脚本编辑中。
+
+
+core.startGame(hard, seed, route, callback)
+开始新游戏。
+hard为难度字符串，会被设置为core.status.hard。
+seed为开始时要设置的的种子，route为要开始播放的录像，callback为回调函数。
+该函数将重置整个游戏，调用setInitData，执行startText事件，上传游戏人数统计信息等。
+
+
+core.setInitData()
+根据难度分歧来初始化难度，包括设置flag:hard，设置初始属性等。
+该函数实际被转发到了脚本编辑中。
+
+
+core.win(reason, norank)
+游戏胜利，reason为结局名，norank如果为真则该结局不计入榜单。
+该函数实际被转发到了脚本编辑中。
+
+
+core.lose(reason)
+游戏失败，reason为结局名。该函数实际被转发到了脚本编辑中。
+
+
+core.gameOver(ending, fromReplay, norank)
+游戏结束。ending为获胜结局名，null代表失败；fromReplay标识是否是录像触发的。
+此函数将询问是否上传成绩（如果ending不是null），是否下载录像等，并重新开始。
+
+
+core.restart()
+重新开始游戏。本质上就是播放标题界面的BGM并调用showStartAnimate。
+
+
+core.confirmRestart()
+确认用户是否需要重新开始。
+
+// ------ 系统事件处理 ------ //
+
+core.registerSystemEvent(type, func)
+注册一个系统事件，即通过图块的默认触发器所触发的事件。
+type为一个要注册的事件类型，func为要执行的函数体或插件中的函数名。
+func需要接受(data, callback)作为参数，分别是触发点的图块信息，和执行完毕时的回调。
+如果注册一个已经存在的系统事件，比如openDoor，则会覆盖系统的默认函数。
+
+
+core.unregisterSystemEvent(type)
+注销一个系统事件。type是上面你注册的事件类型。
+
+
+core.doSystemEvent(type, data, callback)
+执行一个系统事件。type为事件类型，data为该事件点的图块信息，callback为执行完毕的回调。
+
+
+core.battle(id, x, y, force, callback)
+和怪物进行战斗。
+id为怪物的ID，x和y为怪物坐标，force如果为真将强制战斗，callback为执行完毕的回调。
+如果填写了怪物坐标，则会删除对应点的图块并执行该点战后事件。
+如果是在事件流的执行过程中调用此函数，则不会进行自动存档，且会强制战斗。
+
+
+core.beforeBattle(enemyId, x, y)
+战前事件。实际被转发到了脚本编辑中，可以在这里加上一些战前特效。
+此函数在“检测能否战斗和自动存档”【之后】执行。
+如果需要更早的战前事件，请在插件中覆重写 core.events.doSystemEvent 函数。
+此函数返回true则将继续本次战斗，返回false将不再战斗。
+
+
+core.afterBattle(enemyId, x, y, callback)
+战后事件，将执行扣血、加金币经验、特殊属性处理、战后事件处理等操作。
+实际被转发到了脚本编辑中。
+
+
+core.openDoor(x, y, needKey, callback)
+尝试开一个门。x和y为门的坐标，needKey表示是否需要钥匙，callback为执行完毕的回调。
+如果不是一个有效的门，需要钥匙且未持有等，均会忽略此事件并直接执行callback。
+
+
+core.afterOpenDoor(doorId, x, y, callback)
+开完一个门后执行的事件，实际被转发到了脚本编辑中。
+
+
+core.getItem(id, num, x, y, callback)
+获得若干个道具。itemId为道具ID，itemNum为获得的道具个数，不填默认为1。
+x和y为道具点的坐标，如果设置则会擦除地图上的该点。
+
+
+core.afterGetItem(id, x, y, callback)
+获得一个道具后执行的事件，实际被转发到了脚本编辑中。
+
+
+core.getNextItem(noRoute)
+轻按，即获得面对的道具。如果noRoute为真则这个轻按行为不会计入录像。
+
+
+core.changeFloor(floorId, stair, heroLoc, time, callback, fromLoad)
+楼层切换。floorId为目标楼层ID，stair为是什么楼梯，heroLoc为目标点坐标。
+time为切换时间，callback为切换完毕的回调，fromLoad标志是否是从读档造成的切换。
+floorId也可以填":before"和":next"表示前一层和后一层。
+heroLoc为{"x": 0, "y": 0, "direction": "up"}的形式。不存在则从勇士位置取。
+如果stair不为null，则会在该楼层中找对应的图块作为目标点的坐标并覆盖heroLoc。
+一般设置的是"upFloor"和"downFloor"，但也可以用任何其他的图块ID。
+
+
+core.changingFloor(floorId, heroLoc, fromLoad)
+正在执行楼层切换中执行的操作，实际被转发到了脚本编辑中。
+
+
+core.hasVisitedFloor(floorId)
+是否曾经到达过某一层。
+
+
+core.visitFloor(floorId)
+标记曾经到达了某一层。
+
+
+core.passNet(data)
+执行一个路障处理。这里只有毒衰咒网的处理，血网被移动到了updateCheckBlock中。
+
+
+core.pushBox(data)
+执行一个推箱子事件。
+
+
+core.afterPushBox()
+推箱子之后触发的事件，实际被转发到了脚本编辑中。
+
+
+core.changeLight(id, x, y)
+踩灯后的事件。
+
+// ------ 自定义事件的处理 ------ //
+
+core.registerEvent(type, func)
+注册一个自定义事件。type为事件名，func为执行事件的函数体或插件中的函数名。
+func可以接受(data, x, y, prefix)参数，其中data为事件内容，x和y为该点坐标，prefix为该点前缀。
+同名注册的事件将进行覆盖。
+请记得在自定义处理事件完毕后调用core.doAction()再继续执行下一个事件！
+
+
+core.unregisterEvent(type)
+注销一个自定义事件。
+
+
+core.doEvent(data, x, y, prefix)
+执行一个自定义事件。data为事件内容，将根据data.type去注册的事件列表中查找对应的执行函数。
+x和y为该点坐标，prefix为该点前缀。执行事件时也会把(data, x, y, prefix)传入执行函数。
+
+
+core.setEvents(list, x, y, callback)
+设置自定义事件的执行列表，坐标和回调函数。
+
+
+core.startEvents(list, x, y, callback)
+开始执行一系列的自定义事件。list为事件列表，x和y为事件坐标，callback为执行完毕的回调。
+此函数将调用core.setEvents，然后停止勇士，再执行core.doAction()。
+
+
+core.doAction()
+执行下一个自定义事件。
+此函数将检测事件列表是否全部执行完毕，如果是则执行回调函数。
+否则，将从事件列表中弹出下一个事件，并调用core.doEvent进行执行。
+
+
+core.insertAction(action, x, y, callback, addToLast)
+向当前的事件列表中插入一个或多个事件并执行。
+如果当前并不是在事件执行流中，则会调用core.startEvents()开始执行事件，否则仅仅执行插入操作。
+action为要插入的事件，可以是一个单独的事件，或者是一个事件列表。
+x,y,callback如果设置了且不为null，则会覆盖当前的坐标和回调函数。
+addToLast如果为真，则会插入到事件执行列表的尾部，否则是插入到执行列表的头部。
+
+
+core.getCommonEvent(name)
+根据名称获得某个公共事件内容。
+
+
+core.recoverEvents(data)
+恢复事件现场。一般用于呼出怪物手册、呼出存读档页面等时，恢复事件执行流。
+
+// ------ 点击状态栏图标时执行的一些操作 ------ //
+
+core.openBook(fromUserAction)
+尝试打开怪物手册。fromUserAction标志是否是从用户的行为触发，如按键或点击状态栏。（下同）
+不建议复写此函数，否则【呼出怪物手册】事件会出问题。
+
+
+core.useFly(fromUserAction)
+尝试使用楼传器。可以安全的复写此函数，参见文档-个性化-覆盖楼传事件。
+
+
+core.flyTo(toId, callback)
+尝试飞行到某个楼层，被转发到了脚本编辑中。
+如果此函数返回true代表成功进行了飞行，false代表不能进行飞行。
+
+
+core.openEquipbox(fromUserAction) / core.openToolbox(fromUserAction)
+尝试打开道具栏和装备栏。可以安全复写这两个函数。
+
+
+core.openQuickShop(fromUserAction) / core.openKeyBoard(fromUserAction)
+尝试打开快捷商店和虚拟键盘。可以安全复写这两个函数。
+
+
+core.save(fromUserAction) / core.load(fromUserAction)
+尝试打开存读档页面。
+不建议复写这两个函数，否则【呼出存读档页面】事件会出问题。
+
+
+core.openSettings(fromUserAction)
+尝试打开系统菜单。不建议复写此函数。
+
+
+// ------ 一些具体事件的执行内容 ------ //
+
+core.hasAsync()
+当前是否存在未执行完毕的异步事件。请注意正在播放的动画也算异步事件。
+
+
+core.follow(name) / core.unfollow(name)
+跟随勇士/取消跟随。name为行走图名称。
+在取消跟随时如果指定了name，则会从跟随列表中选取一个该行走图取消，否则取消所有跟随。
+跟随和取消跟随都会调用core.gatherFollowers()来聚集所有的跟随者。
+
+
+core.setValue(name, value, prefix) / core.addValue(name, value, prefix)
+设置/增减某个数值。name可以是status:xxx，item:xxx或flag:xxx。
+value可以是一个表达式，将调用core.calValue()计算。prefix为前缀，独立开关使用。
+
+
+core.doEffect(effect, need, times)
+执行一个effect操作。该函数目前仅被全局商店的status:xxx+=yyy所调用。
+
+
+core.setFloorInfo(name, values, floorId, prefix)
+设置某层楼的楼层属性。
+
+
+core.setGlobalAttribute(name, value)
+设置一个全局属性，如边框颜色等。
+
+
+core.setGlobalFlag(name, value)
+设置一个全局开关，如enableXXX等。
+如果需要设置一个全局数值如红宝石数值，可以直接简单的修改core.values，因此没有单独列出函数。
+
+
+core.closeDoor(x, y, id, callback)
+执行一个关门事件。如果不是一个合法的门，或者该点不为空地，则会忽略本事件。
+
+
+core.showImage(code, image, sloc, loc, opacityVal, time, callback)
+显示一张图片。code为图片编号，image为图片内容或图片名。
+sloc为[x,y,w,h]形式，表示在原始图片上裁剪的区域，也可直接设为null表示整张图片。
+loc为[x,y,w,h]形式，表示在界面上绘制的位置和大小，w和h可忽略表示使用绘制大小。
+opacityVal为绘制的不透明度，time为淡入时间。
+此函数将创建一个画布，其z-index是100+code，即图片编号为1则是101，编号50则是150。
+请注意，curtain层的z-index是125，UI层的z-index是140；因此可以通过图片编号来调整覆盖关系。
+
+
+core.hideImage(code, time, callback)
+隐藏一张图片。code为图片编号，time为淡出时间。
+
+
+core.moveImage(code, to, opacityVal, time, callback)
+移动一张图片。code为图片编号，to为[x,y]表示目标位置，opacityVal目标不透明度，time为移动时间。
+
+
+core.showGif(name, x, y)
+绘制一张gif图片或取消所有绘制内容。如果name不设置则视为取消。x和y为左上角像素坐标。
+
+
+core.setVolume(value, time, callback)
+设置音量。value为目标音量大小，在0到1之间。time为音量渐变的时间。
+
+
+core.vibrate(time, callback)
+画面震动。time为震动时间。
+请注意，画面震动时间必须是500的倍数，系统也会自动把time调整为上整的500倍数值。
+
+
+core.eventMoveHero(steps, time, callback)
+使用事件移动勇士。time为每步的移动时间。
+steps为移动数组，可以接受'up','down','left','right','forward'和'backward'项。
+使用事件移动勇士将不会触发任何地图上的事件。
+
+
+core.jumpHero(ex, ey, time, callback)
+跳跃勇士。ex和ey为目标点的坐标，可以为null表示原地跳跃。time为总跳跃时间。
+
+
+core.openShop(shopId, needVisited)
+打开一个全局商店。needVisited表示是否需要该商店原本就是启用状态。
+如果该商店对应的实际上是一个全局事件，则会直接插入并执行。
+
+
+core.disableQuickShop(shopId)
+禁用一个全局商店，即把一个商店从启用变成禁用状态。
+
+
+core.canUseQuickShop(shopId)
+当前能否使用某个全局商店，实际被转发到了脚本编辑中。
+如果此函数返回null则表示可以使用，返回一个字符串表示不可以，该字符串表示不可以的原因。
+
+
+core.setHeroIcon(name, noDraw)
+设置勇士的行走图。
+name为行走图名称，noDraw如果为真则不会调用core.drawHero()函数进行刷新。
+
+
+core.checkLvUp()
+检查升级事件。该函数将判定当前是否升级（或连续升级），然后执行升级事件。
+
+
+core.tryUseItem(itemId)
+尝试使用一个道具。
+对于怪物手册和楼传器，将分别调用core.openBook()和core.useFly()函数。
+对于中心对称飞行器，则会调用core.drawCenterFly()函数。
+对于其他的道具，将检查是否拥有，能否使用，并且进行使用。
+
+
+core.afterUseBomb()
+使用炸弹或圣锤后的事件。实际被转发到了脚本编辑中。
+```
+
+## icons.js
+
+icons.js主要是负责素材相关信息，比如某个素材在对应的图片上的位置。
+
+```text
+core.getClsFromId(id)
+根据某个素材的ID获得该素材的cls
+
+
+core.getTilesetOffset(id)
+根据某个素材来获得对应的tileset和坐标信息。
+如果该素材不是tileset，则返回null。
+```
+
+## items.js
+
+items.js主要负责一切和道具相关的内容。
+
+```text
+core.getItemEffect(itemId, itemNum)
+即捡即用类的道具获得时的效果。实际对应道具图块属性中的itemEffect框。
+
+
+core.getItemEffectTip(itemId)
+即捡即用类的道具获得时的额外提示，比如“，攻击+100”。
+实际对应道具图块属性中的itemEffectTip框。
+
+
+core.useItem(itemId, noRoute, callback)
+尝试使用一个道具。实际对应道具图块属性中的useItemEffect框。
+此函数也会调用一遍core.canUseItem()，如果无法使用将直接返回。
+noRoute如果为真，则这次使用道具的过程不会被计入录像。
+使用道具完毕后，对于消耗道具将自动扣除，永久道具不会扣除。
+
+
+core.canUseItem(itemId)
+当前能否使用某个道具。
+有些系统道具如破炸和上下楼器等，会在计算出目标点的坐标后存入core.status.event.ui。
+使用道具时将直接从core.status.event.ui调用，不会重新计算。
+
+
+core.itemCount(itemId)
+获得某个道具的个数。
+
+
+core.hasItem(itemId)
+当前是否拥有某个道具。等价于 core.itemCount(itemId) > 0
+请注意，装备上的装备不视为拥有该道具，即core.hasEquip()和core.hasItem()是完全不同的。
+
+
+core.hasEquip(itemId)
+当前是否装备上某个装备。
+请注意，装备上的装备不视为拥有该道具，即core.hasEquip()和core.hasItem()是完全不同的。
+
+
+core.getEquip(equipType)
+获得某个装备位的当前装备。equipType为装备类型，从0开始。
+如果该装备位没有装备则返回null，否则返回当前装备的ID。
+
+
+core.setItem(itemId, itemNum)
+设置某个道具的个数。
+
+
+core.addItem(itemId, itemNum)
+增减某个道具的个数，itemNum可不填默认为1。
+
+
+core.getEquipTypeByName(name)
+根据装备位名称来找到一个空的装备孔，适用于多重装备。
+如果没有一个装备孔是该装备名称，则返回-1。
+
+
+core.getEquipTypeById(equipId)
+获得某个装备的装备类型。
+如果其type写的是装备名（多重装备），则调用core.getEquipTypeByName()函数。
+
+
+core.canEquip(equipId, hint)
+当前能否穿上某个装备。如果hint为真，则不可装备时会气泡提示原因。
+
+
+core.loadEquip(equipId, callback)
+穿上某个装备。
+
+
+core.unloadEquip(equipType, callback)
+脱下某个装备孔的装备。
+
+
+core.compareEquipment(compareEquipId, beComparedEquipId)
+比较两个套装的差异。
+此函数将对所有的勇士属性包括生命魔力攻防魔防金币等进行比较。
+如果存在差异的，将作为一个对象返回其差异内容。
+
+
+core.quickSaveEquip(index)
+保存当前套装。index为保存的套装编号。
+
+
+core.quickLoadEquip()
+读取当前套装。index为读取的套装编号。
+```
+
+## loader.js
+
+loader.js主要负责资源加载相关的内容。
+
+```text
+core.loadImage(imgName, callback)
+从 project/images/ 中加载一张图片。imgName为图片名。
+callback为执行完毕的回调函数，接收(imgName, image)即图片名和图片内容作为参数。
+如果图片不存在或加载失败则会在控制台打出一条错误日志，不会执行回调。
+
+
+core.loadImages(names, toSave, callback)
+从 project/images/ 中加载若干张图片。
+names为一个图片名的列表，toSave为加载并存到的对象。
+callback为全部加载完毕执行的回调。
+
+
+core.loadOneMusic(name)
+从 project/sounds/ 或第三方中加载一个音乐，并存入core.material.bgms中。name为音乐名。
+
+
+core.loadOneSound(name)
+从 project/sounds/ 中加载一个音效，并存入core.material.sounds中。name为音效名。
+
+
+core.loadBgm(name)
+预加载一个bgm并加入缓存列表core.musicStatus.cachedBgms。
+此函数将会检查bgm的缓存，预加载和静音播放。
+如果缓存列表溢出(core.musicStatus.cacheBgmCount)则通过LRU算法选择一个bgm并调用core.freeBgm()。
+
+
+core.freeBgm(name)
+释放一个bgm的内存并移出缓存列表。如果该bgm正在播放则也会立刻停止。
+```
+
+## map.js
+
+maps.js负责一切和地图相关的处理内容，包括如下几个方面：
+- 地图的初始化，保存和读取，地图数组的生成
+- 是否可移动或瞬间移动的判定
+- 地图的绘制
+- 获得某个点的图块信息
+- 启用和禁用图块，改变图块
+- 移动/跳跃图块，淡入淡出图块
+- 全局动画控制，动画的绘制
+
+```text
+// ------ 地图的初始化，保存和读取，地图数组的生成 ------ //
+
+core.loadFloor(floorId, map)
+从楼层或者存档中生成core.status.maps的内容。
+map为存档信息，如果某项在map中不存在则会从core.floors中读取。
+
+
+core.getNumberById(id)
+给定一个图块ID，找到对应的数字。
+
+
+core.initBlock(x, y, id, addInfo, eventFloor)
+给定一个数字，初始化一个图块信息。
+x和y为坐标，id为数字或者可以:t或:f结尾表示初始是启用还是禁用状态。
+addInfo如果为true则会填充上图块的默认信息，比如给怪物添加battle触发器。
+eventFloor如果设置为某个楼层信息，则会填充上该点的自定义或楼层切换事件。
+
+
+core.compressMap(mapArr, floorId)
+压缩地图。mapArr为要压缩的二维数组，floorId为对应的楼层。
+此函数将把mapArr和对应的楼层中的数组进行比较，并只取差异值进行存储。
+通过这种压缩地图的方式，不仅节省了存档空间，还支持了任意修改地图的接档。
+
+
+core.decompressMap(mapArr, floorId)
+解压缩地图。mapArr为压缩后的地图，floorId为对应的楼层。
+此函数返回解压后的二维数组。
+
+
+core.saveMap(floorId)
+将某层楼的数据生成存档所保存的内容。在core.saveData()中被调用。
+
+
+core.loadMap(data, floorId)
+从data中读取楼层数据，并调用core.loadFloor()进行初始化。
+
+
+core.resizeMap(floorId)
+根据某层楼的地图大小来调整大地图的画布大小。floorId可为null表示当前层。
+
+
+core.getMapArray(floorId, showDisable)
+生成某层楼的二维数组。floorId可不填代表当前楼层。
+showDisable若为真，则对于禁用的点会加上:f表示，否则视为0。
+
+
+core.getMapBlocksObj(floorId, showDisable)
+以x,y的形式返回每个点的图块信息。floorId可不填表示当前楼层。
+此函数将返回 {"0,0": {...}, "0,1": {...}} 这样的结构，其中内部为对应点的block信息。
+
+
+core.getBgMapArray(floorId, noCache)
+获得某层楼的背景层的二维数组。floorId可不填表示当前楼层。
+如果noCache为真则重新从剧本中读取而不使用缓存数据。
+
+
+core.getFgMapArray(floorId, noCache)
+获得某层楼的前景层的二维数组。floorId可不填表示当前楼层。
+如果noCache为真则重新从剧本中读取而不使用缓存数据。
+
+
+core.getBgNumber(x, y, floorId, noCache)
+获得某层楼的背景层中某个点的数字。floorId可不填表示当前楼层。
+如果noCache为真则重新从剧本中读取而不使用缓存数据。
+本函数实际等价于 core.getBgMapArray(floorId, noCache)[y][x]
+
+
+core.getBgNumber(x, y, floorId, noCache)
+获得某层楼的前景层中某个点的数字。参数和方法同上。
+
+// ------ 是否可移动或瞬间移动的判定 ------ //
+
+core.generateMovableArray(floorId, x, y, direction)
+生成全图或某个点的可通行方向数组。floorId为楼层Id，可不填默认为当前点。
+这里的可通行方向数组，指的是["up","down","left","right"]中的一个或多个组成的数组。
+ - 如果不设置x和y，则会返回一个三维数组，其中每个点都是一个该点可通行方向的数组。
+ - 如果设置了x和y但没有设置direction，则只会返回该点的可通行方向数组，
+ - 如果设置了x和y以及direction，则会判定direction是否在该点可通行方向数组中，并返回true或false。
+可以使用core.inArray()来判定某个方向是否在可通行方向数组中。
+
+
+core.canMoveHero(x, y, direction, floorId)
+某个点是否可朝某个方向移动。x和y可选，不填或为null则默认为勇士当前点。
+direction可选，不填或为null则默认勇士当前朝向。floorId不填则默认为当前楼层。
+此函数将直接调用 core.generateMovableArray() 进行判定。
+
+
+core.canMoveDirectly(destX, destY)
+当前能否瞬间移动到某个点。
+如果可以瞬移则返回非负数，其值为该次瞬移所少走的步数；如果不能瞬移则返回-1。
+
+
+core.automaticRoute(destX, destY)
+找寻到目标点的一条自动寻路路径。
+
+// ------ 绘制地图相关 ------ //
+
+core.drawBlock(block, animate)
+重新绘制一个图块，block为图块信息。
+如果animate不为null则代表是通过全局动画的绘制，其值为当前的帧数。
+
+
+core.generateGroundPattern(floorId)
+生成某个楼层的地板信息。floorId不填默认为当前楼层。
+该函数可被怪物手册、对话框帧动画等地方使用。
+
+
+core.drawMap(floorId, callback)
+绘制某层楼的地图。floorId为目标楼层ID，可不填表示当前楼层。
+此函数会将core.status.floorId设置为floorId，并设置core.status.thisMap。
+将依次调用core.drawBg(), core.drawEvents()和core.drawFg()函数，最后绘制勇士和更新地图显伤。
+
+
+core.drawBg(floorId, ctx)
+绘制背景层。floorId为目标楼层ID，可不填表示当前楼层。
+如果ctx不为null，则背景层将绘制在该画布上而不是bg层上（drawThumbnail使用）。
+可以通过复写该函数，调整_drawFloorImages和_drawBgFgMap的顺序来调整背景图块和贴图的遮挡顺序。
+
+
+core.drawEvents(floorId, blocks, ctx)
+绘制事件层。floorId为目标楼层ID，可不填表示当前楼层。
+block表示要绘制的图块列表，可不填使用当前楼层的图块列表。
+如果ctx不为null，则背景层将绘制在该画布上而不是event层上（drawThumbnail使用）。
+
+
+core.drawFg(floorId, ctx)
+绘制前景层。floorId为目标楼层ID，可不填表示当前楼层。
+如果ctx不为null，则背景层将绘制在该画布上而不是fg层上（drawThumbnail使用）。
+可以通过复写该函数，调整_drawFloorImages和_drawBgFgMap的顺序来调整前景图块和贴图的遮挡顺序。
+
+
+core.drawThumbnail(floorId, blocks, options, toDraw)
+绘制一个楼层的缩略图。floorId为目标楼层ID，可不填表示当前楼层。
+block表示要绘制的图块列表，可不填使用当前楼层的图块列表。
+options为绘制选项（可为null），包括：
+    heroLoc: 勇士位置；heroIcon：勇士图标（默认当前勇士）；damage：是否绘制显伤；
+    flags：当前的flags（在存读档时使用）
+toDraw为要绘制到的信息（可为null，或为一个画布名），包括：
+    ctx：要绘制到的画布（名）；x,y：起点横纵坐标（默认0）；size：绘制大小（默认416/480）；
+    all：是否绘制全图（默认false）；centerX,centerY：截取中心（默认为地图正中心）
+
+// ------ 获得某个点的图块信息 ------ //
+
+core.noPass(x, y, floorId)
+判定某个点是否有noPass的图块。
+
+
+core.npcExists(x, y, floorId)
+判定某个点是否有NPC的存在。
+
+
+core.terrainExists(x, y, id, floorId)
+判定某个点是否有（指定的）地形存在。
+如果id为null，则只要存在terrains即为真，否则还会判定对应点的ID。
+
+
+core.stairExists(x, y, floorId)
+判定某个点是否存在楼梯。
+
+
+core.nearStair()
+判定当前勇士是否在楼梯上或旁边（距离不超过1）。
+
+
+core.enemyExists(x, y, id, floorId)
+判定某个点是否有（指定的）怪物存在。
+如果id为null，则只要存在怪物即为真，否则还会判定对应点的怪物ID。
+请注意，如果需要判定某个楼层是否存在怪物请使用core.hasEnemyLeft()函数。
+
+
+core.getBlock(x, y, floorId, showDisable)
+获得某个点的当前图块信息。x和y为坐标；floorId为楼层ID，可忽略或null表示当前楼层。
+showDisable如果为true，则对于禁用的点和事件也会进行返回。
+如果该点不存在图块，则返回null。
+否则，返回值如下： {"index": xxx, "block": xxx}
+其中index为该点在该楼层blocks数组中的索引，block为该图块实际内容。
+
+
+core.getBlockId(x, y, floorId, showDisable)
+获得某个点的图块ID。如果该点不存在图块则返回null。
+
+
+core.getBlockCls(x, y, floorId, showDisable)
+获得某个点的图块类型。如果该点不存在图块则返回null。
+
+
+core.getBlockInfo(block)
+根据某个的图块信息获得其详细的素材信息。
+如果参数block为字符串，则视为图块ID；如果参数为数字，则视为图块的数字。
+此函数将返回一个非常详尽的素材信息，目前包括如下几项：
+number：素材数字；id：素材id；cls：素材类型；image：素材所在的素材图片；animate：素材的帧数。
+posX, posY：素材在该素材图片上的位置；height：素材的高度；faceIds：NPC朝向记录。
+
+
+core.searchBlock(id, floorId, showDisable)
+搜索一个图块出现过的所有位置。id为图块ID，也可以传入图块的数字。
+id支持通配符搜索，比如"*Door"可以搜索所有的门，"unknownEvent*"可以所有所有的unknownEvent。
+floorId为要搜索的楼层，可以是一个楼层ID，或者一个楼层数组。如果floorId不填则只搜索当前楼层。
+showDisable如果为真，则对于禁用的图块也会返回。
+此函数将返回一个数组，每一项为一个搜索到的结果：
+{"floorId": ..., "index": ..., "block": {...}, "x": ..., "y": ...}
+即包含该图块所在的楼层ID，在该楼层的blocks数组的索引，图块内容，和横纵坐标。
+
+
+// ------ 启用和禁用图块，改变图块 ------ //
+
+core.showBlock(x, y, floorId)
+将某个点从禁用变成启用状态。floorId可不填或null表示当前楼层。
+
+
+core.hideBlock(x, y, floorId)
+将某个点从启用变成禁用状态，但不会对其进行删除。floorId可不填或null表示当前楼层。
+此函数不会实际将该块从地图中进行删除，而是将该点设置为禁用，以供以后可能的启用事件。
+
+
+core.removeBlock(x, y, floorId)
+将从启用变成禁用状态，并尽可能将其从地图上删除。
+和hideBlock相比，如果该点不存在自定义事件（比如门或普通的怪物），则将直接从地图中删除。
+如果存在自定义事件，则简单的禁用它，以供以后可能的启用事件。
+
+
+core.removeBlockById(index, floorId)
+根据索引从地图的block数组中尽可能删除一个图块。floorId可不填或null表示当前楼层。
+
+
+core.removeBlockByIds(floorId, ids)
+根据索引数组从地图的block数组中尽可能删除一系列图块。floorId可不填或null表示当前楼层。
+
+
+core.canRemoveBlock(block, floorId)
+判定当前能否完全删除某个图块。floorId可不填或null表示当前楼层。
+如果该点存在自定义事件，或者是重生怪，则不可进行删除。
+
+
+core.showBgFgMap(name, loc, floorId, callback)
+显示某层楼中某个背景/前景层的图块。name只能为'bg'或'fg'表示背景或前景层。
+loc为该点坐标，floorId可不填默认为当前楼层。callback为执行完毕的回调。
+
+
+core.hideBgFgMap(name, loc, floorId, callback)
+隐藏某层楼中某个背景/前景层的图块。name只能为'bg'或'fg'表示背景或前景层。
+loc为该点坐标，floorId可不填默认为当前楼层。callback为执行完毕的回调。
+
+
+core.showFloorImage(loc, floorId, callback)
+显示某层楼中的某个楼层贴图。loc为该贴图的左上角坐标。floorId可省略表示当前楼层。
+
+
+core.hideFloorImage(loc, floorId, callback)
+隐藏某层楼中的某个楼层贴图。loc为该贴图的左上角坐标。floorId可省略表示当前楼层。
+
+
+core.setBlock(number, x, y, floorId)
+改变某个楼层的某个图块。
+number为要改变到的数字，也可以传入图块id（将调用core.getNumberById()来获得数字）。
+x,y和floorId为目标点坐标和楼层，可忽略为当前点和当前楼层。
+
+
+core.replaceBlock(fromNumber, toNumber, floorId)
+将某个或某些楼层中的所有某个图块替换成另一个图块
+fromNumber和toNumber为要被替换和替换到的数字。
+floorId可为某个楼层ID，或者一个楼层数组；如果不填只视为当前楼层。
+值得注意的是，使用此函数转了的点上的自定义事件可能无法被执行。
+如有需要，再对那些存在事件的点执行core.setBlock()即可
+
+
+core.setBgFgBlock(name, number, x, y, floorId)
+设置前景/背景层的某个图块。name只能为'bg'或'fg'表示前景或背景层。
+number为要设置到的图块数字，x,y和floorId为目标点坐标和楼层，可忽略为当前点和当前楼层。
+
+
+core.resetMap(floorId)
+重置某层或若干层的地图和楼层属性。
+floorId可为某个楼层ID，或者一个楼层数组（同时重置若干层）；如果不填则只重置当前楼层。
+
+// ------ 移动/跳跃图块，淡入淡出图块 ------ //
+
+core.moveBlock(x, y, steps, time, keep, callback)
+移动一个图块，x和y为图块的坐标。
+steps为移动的数组，每一项只能是"up","down","left","right"之一。
+time为每一步的移动时间，不填默认为500ms。
+如果keep为真，则在移动完毕后将自动调用一个setBlock事件，改变目标点的图块（即不消失），
+否则会按照time时间来淡出消失。callback会执行完毕后的回调。
+
+
+core.jumpBlock(sx, sy, ex, ey, time, keep, callback)
+跳跃一个图块，sx和sy为图块的坐标，ex和ey为目标坐标。time为整个跳跃过程中的全程用时，不填默认500。
+如果keep为真，则在移动完毕后将自动调用一个setBlock事件，改变目标点的图块（即不消失），
+否则会按照time时间来淡出消失。callback会执行完毕后的回调。
+
+
+core.animateBlock(loc, type, time, callback)
+淡入/淡出一个或多个图块。
+loc为一个图块坐标，或者一个二维数组表示一系列图块坐标（将同时显示和隐藏）。
+type只能为'show'或'hide'表示是淡入但是淡出。time为动画时间，callback为执行完毕的回调。
+
+// ------ 全局动画控制，动画的绘制 ------ //
+
+core.addGlobalAnimate(block)
+添加一个全局帧动画。
+
+
+core.removeGlobalAnimate(x, y, name)
+删除一个或全部的全局帧动画。name可为'bg',null或'fg'表示某个图层。
+x和y如果为null，则会删除全部的全局帧动画，否则只会删除该点的该层的帧动画。
+
+
+core.drawBoxAnimate()
+绘制UI层的box动画，如怪物手册和对话框中的帧动画等。
+
+
+core.drawAnimate(name, x, y, callback)
+绘制一个动画。name为动画名，x和y为绘制的基准坐标，callback为绘制完毕的回调函数。
+此函数将播放动画音效，并异步开始绘制该动画。
+此函数会返回一个动画id，可以通过core.stopAnimate()立刻停止该动画的播放。
+
+
+core.stopAnimate(id, doCallback)
+立刻停止某个动画的播放。id为上面core.drawAnimate的返回值。
+如果doCallback为真，则会执行该动画所对应的回调函数。
+```
+
+## ui.js
+
+ui.js负责一切UI界面的绘制。主要包括三个部分：
+- 设置某个画布的属性的相关API
+- 具体的某个UI界面的绘制
+- 动态创建画布相关的API
+
+```text
+// ------ 设置某个画布的属性的相关API ------//
+这系列函数的name一般都是画布名，可以是系统画布或动态创建的画布。
+但也同时也允许直接传画布的context本身，将返回自身。
+
+
+core.getContextByName(name)
+根据画布名找到一个画布的context；支持系统画布和自定义画布。
+如果不存在画布此函数返回null。
+该参数也可以直接传画布的context自身，则返回自己。
+
+
+core.clearMap(name)
+清空某个画布图层。
+该函数的name也可以是'all'，若为'all'则为清空所有系统画布。
+
+
+core.fillText(name, text, x, y, style, font)
+在某个画布上绘制一段文字。
+text为要绘制的文本，x,y为要绘制的坐标，style可选为绘制的样式，font可选为绘制的字体。（下同）
+请注意textAlign和textBaseline将决定绘制的左右对齐和上下对齐方式。
+具体可详见core.setTextAlign()和core.setTextBaseline()函数。
+
+
+core.fillBoldText(name, text, x, y, style, font)
+在某个画布上绘制一个描黑边的文字。
+
+
+core.fillRect(name, x, y, width, height, style)
+绘制一个矩形。style可选为绘制样式。如果设置将调用core.setFillStyle()。（下同）
+
+
+core.strokeRect(name, x, y, width, height, style, lineWidth)
+绘制一个矩形的边框。style可选为绘制样式，如果设置将调用core.setStrokeStyle()。
+lineWidth如果设置将调用core.setLineWidth()。（下同）
+
+
+core.drawLine(name, x1, y1, x2, y2, style, lineWidth)
+绘制一条线。
+
+
+core.drawArrow(name, x1, y1, x2, y2, style, lineWidth)
+绘制一个箭头。
+
+
+core.setFont(name, font) / core.setLineWidth(name, lineWidth)
+设置一个画布的字体/线宽。
+
+
+core.setAlpha(name, font) / core.setOpacity(name, font)
+设置一个画布的绘制不透明度和画布本身的不透明度。
+两者区别如下：
+  - setAlpha是设置"接下来绘制的内容的不透明度"，不会对已经绘制的内容产生影响。
+    > 比如setAlpha('ui', 0.5)则会在接下来的绘制中使用0.5的不透明度。
+  - setOpacity是设置"画布本身的不透明度"，已经绘制的内容也会产生影响。
+    > 比如我已经在UI层绘制了一段文字，再setOpacity则也会让已经绘制的文字变得透明。
+尽量不要对系统画布使用setOpacity（因为会对已经绘制的内容产生影响），自定义创建的画布则不受此限制。
+
+
+core.setFillStyle(name, style) / core.setStrokeStyle(name, style)
+设置一个画布的填充样式/描边样式。
+
+
+core.setTextAlign(name, align)
+设置一个画布的文字横向对齐模式，这里的align只能为'left', 'right'和'center'。
+默认为'left'。
+
+
+core.setTextBaseline(name, baseline)
+设置一个画布的纵向对齐模式。有关textBaseline的说明可参见如下资料：
+http://www.runoob.com/tags/canvas-textbaseline.html
+默认值是'alphabetic'。
+请注意，系统画布在绘制前都是没有设置过textBaseline的，都是按照alphabetic进行坐标绘制。
+因此，如果你修改了系统画布的textBaseline来绘图，记得再绘制完毕后修改回来。
+
+
+core.calWidth(name, text, font)
+计算一段文字在某个画布上的绘制宽度，此函数其实是ctx.measureText()的包装。
+font可选，如果存在则会先设置该画布上的字体。
+此函数不会对文字进行换行，如需换行版本请使用core.splitLines()函数。
+
+
+core.splitLines(name, text, maxWidth, font)
+计算一段文字在某画布上换行分割的结果。
+text为文字内容，maxWidth为最大宽度，可为null表示不自动换行。
+font可选，如果存在则会先设置该画布上的字体。
+此函数将返回一个换行完毕的文本列表。
+
+
+core.drawImage(name, image, x, y, w, h, x1, y1, w1, h1)
+在一张画布上绘制一张图片，此函数其实是ctx.drawImage()的包装。
+可以查看下面的文档以了解各项参数的信息：
+http://www.w3school.com.cn/html5/canvas_drawimage.asp
+这里的image允许传一个图片，画布。也允许传递图片名，将从你导入的图片中获取图片内容。
+
+// ------ 具体的某个UI界面的绘制 ------ //
+core.closePanel()
+结束一切事件和UI绘制，关闭UI窗口，返回游戏。
+此函数将以此调用core.clearUI()，core.unlockControl()，并清空core.status.event里面的内容。
+
+
+core.clearUI()
+重置UI窗口。此函数将清掉所有的UI帧动画和光标，清空UI画布，并将alpha设为1。
+
+
+core.drawTip(text, id)
+在左上角以气泡的形式绘制一段提示。
+text为文字内容，仅支持${}的表达式计算，不支持换行和变色。
+id可选，为同时绘制的图标ID，如果不为null则会同时绘制该图标（仅对32x32的素材有效）。
+也可以使用状态栏的图标ID，例如lv, hp, up, save, settings等。
+
+
+core.drawText(content, callback)
+绘制一段文字。contents为一个字符串或一个字符串数组，callback为全部绘制完毕的回调。
+支持所有的文字效果（如\n，${}，\r，\\i等），也支持\t和\b的语法。
+如果当前在事件处理中或录像回放中，则会自动转成core.insertAction处理。
+不建议使用该函数，如有绘制文字的需求请尽量使用core.insertAction()插入剧情文本事件。
+
+
+core.drawWindowSelector(background, x, y, w, h)
+绘制一个WindowSkin的闪烁光标。background可为winskin的图片名或图片本身。
+x,y,w,h为绘制的左上角位置和宽高，都是像素为单位。
+
+
+core.drawWindowSkin(background, ctx, x, y, w, h, direction, px, py)
+绘制一个WindowSkin。background可为winskin的图片名或图片本身。
+ctx为画布名或画布本身，x,y,w,h为左上角位置和宽高，都是像素为单位。
+direction, px, py可选，如果设置则会绘制一个对话框箭头。
+
+
+core.drawBackground(left, top, right, bottom, posInfo)
+绘制一个背景图。此函数将使用你在【剧情文本设置】中设置的背景，即用纯色或WindowSkin来绘制。
+left, top, right, bottom为你要绘制的左上角和右下角的坐标。
+posInfo如果不为null则是一个含position, px和py的对象，表示一个对话框箭头的绘制。
+
+
+core.drawTextContent(ctx, content, config)
+根据配置在某个画布上绘制一段文字。此函数会被core.drawTextBox()所调用。
+ctx为画布名或画布本身，如果不设置则会忽略该函数。
+content为要绘制的文字内容，支持所有的文字效果（如\n，${}，\r，\\i等），但不支持支持\t和\b的语法。
+config为绘制的配置项，目前可以包括如下几项：
+ - left, top：在该画布上绘制的左上角像素位置，不设置默认为(0,0)。
+   > 该函数绘制时会将textBaseline设置为'top'，因此只需要考虑第一个字的左上角位置。
+ - maxWidth：单行最大宽度，超过此宽度将自动换行，不设置不会自动换行。
+ - color：默认颜色，为#XXXXXX形式。如果不设置则使用剧情文本设置中的正文颜色。
+ - bold：是否粗体。如果不设置默认为false。
+ - align：文字对齐方式，仅在maxWidth设置时有效，默认为'left'。
+ - fontSize：字体大小，如果不设置则使用剧情文本设置中的正文字体大小。
+ - lineHeight：绘制的行距值，如果不设置则使用fontSize*1.3（即1.3被行距）。
+ - time：打字机效果。若不为0，则会逐个字进行绘制，并设置core.status.event.interval定时器。
+
+
+core.drawTextBox(content, showAll)
+绘制一个对话框。content为一个字符串或一个字符串数组。
+支持所有的文字效果（如\n，${}，\r，\\i等），也支持\t和\b的语法。
+该函数将使用用户在剧情文本设置中的配置项进行绘制。
+实际执行时，会计算文本框宽度并绘制背景，绘制标题和头像，再调用core.drawTextContent()绘制正文内容。
+showAll可选，如果为true则不会使用打字机效果而全部显示，主要用于打字机效果的点击显示全部。
+
+
+core.drawScrollText(content, time, lineHeight, callback)
+绘制一个滚动字幕。content为绘制内容，time为总时间（默认为5000），lineHeight为行距比例（默认为1.4）。
+滚动字幕将绘制在UI上，支持所有的文字效果（如\n，${}，\r，\\i等），但不支持\t和\b效果。
+可以通过剧情文本设置中的align控制是否居中绘制，offset控制其距离左边的偏移量。
+
+
+core.textImage(content, lineHeight)
+将文本图片化。content为绘制内容，lineHeight为行距比例（默认为1.4）。
+可以通过剧情文本设置中的align控制是否居中绘制。
+此函数将返回一个临时画布的canvas，供转绘到其他画布上使用。
+
+
+core.drawChoices(content, choices)
+绘制一个选项框。
+content可选，为选项上方的提示文字，支持所有的文字效果（如\n，${}，\r，\\i等），也支持\t效果。
+choices必选，为要绘制的选项内容，是一个列表。其中的每一项：
+ - 可以是一个字符串，表示选项文字，将使用剧情文本设置中的正文颜色来绘制，仅支持${}表达式计算。
+ - 或者是一个包含text, color和icon的对象。
+   > text必选，为要绘制的文字内容，仅支持${}的表达式计算，
+   > color为要绘制的选项颜色，可以是#XXXXXX的格式或RGBA数组。不设置则使用正文颜色。
+   > icon为要绘制的图标ID，支持使用素材的ID，或者系统图标。
+
+
+core.drawConfirmBox(text, yesCallback, noCallback)
+绘制一个确认框。text为确认文字，支持\n换行（但不支持自动换行）和${}表达式计算。
+yesCallback和noCallback分别为确定和取消的回调函数。
+可以在调用此函数前设置core.status.event.selection来控制默认的选中项（0确定1取消）。
+此函数和core.myconfirm的区别主要在于：
+ - 此函数会清掉UI层原有的绘制信息，core.myconfirm不会清除。
+ - 此函数可以用键盘进行操作，core.myconfirm必须用鼠标点击。
+另外请注意：本函数和事件流的执行不兼容，选择也不会进录像。
+如果需要在事件流中调用请使用提供选择项。
+
+
+core.drawWaiting(text)
+绘制一个等待界面，一般用于同步存档之类的操作。
+调用此函数后，需要再调用core.closePanel()才会恢复游戏。
+
+
+core.drawPagination(page, totalPage, y)
+绘制一个分页。y如果不设置则绘制在最后一行。
+
+
+core.drawBook(index) / core.drawBookDetail(index)
+绘制怪物手册，绘制怪物的详细信息。
+
+
+core.drawFly(page) / core.drawCenterFly() / core.drawShop(shopId)
+绘制楼传页面，中心对称飞行器，绘制商店
+ 
+ 
+core.drawToolbox(index) / core.drawEquipbox(index) / core.drawKeyBoard()
+绘制道具栏，绘制装备栏，绘制虚拟键盘。
+ 
+ 
+core.drawMaps(index, x, y) / core.drawSLPanel(index, refresh) 
+绘制浏览地图，绘制存读档界面。
+
+
+core.drawStatusBar()
+自定义绘制状态栏，仅在状态栏canvas化开启时有效，实际被转发到了脚本编辑中。
+
+
+core.drawStatistics()
+绘制数据统计。将从脚本编辑中获得要统计的数据列表，再遍历所有地图进行统计。
+
+
+core.drawAbout() / core.drawPaint() / core.drawHelp()
+绘制关于界面，绘图模式，帮助界面。
+
+// ------ 动态创建画布相关的API ------ //
+
+
+core.ui.createCanvas(name, x, y, width, height, z)
+动态创建一个自定义画布。name为要创建的画布名，如果已存在则会直接取用当前存在的。
+x,y为创建的画布相对窗口左上角的像素坐标，width,height为创建的长宽。
+z值为创建的纵向高度（关系到画布之间的覆盖），z值高的将覆盖z值低的；系统画布的z值可在个性化中查看。
+返回创建的画布的context，也可以通过core.dymCanvas[name]或core.getContextByName获得。
+
+
+core.ui.relocateCanvas(name, x, y)
+重新定位一个自定义画布。x和y为画布的左上角坐标。
+
+
+core.ui.resizeCanvas(name, width, height)
+重新设置一个自定义画布的大小。width和height为新设置的宽高。此操作会清空画布。
+
+
+core.ui.deleteCanvas(name)
+删除一个自定义画布。
+
+
+core.ui.deleteAllCanvas()
+删除所有的自定义画布。
+```
+
+## utils.js
+
+utils.js是一个工具函数库，里面有各个样板中使用到的工具函数。
+
+```text
+core.replayText(text, need, times)
+将一段文字中的${}（表达式）进行替换。need和time一般可以直接忽略。
+
+
+core.calValue(value, prefix, need, time)
+计算一个表达式的值，支持status:xxx等的计算。
+prefix为前缀（switch:xxx的独立开关使用），need和time一般可以直接忽略。
+
+
+core.unshift(a, b) / core.push(a, b)
+将b插入到列表a之前或之后。b可以是一个元素或者一个数组。
+
+
+core.decompress(value)
+解压缩一个字符串并进行JSON解析。value可能会被LZString或LZW算法进行压缩。
+返回解压后的JSON格式内容，如果无法解压则返回null。
+
+
+core.setLocalStorage(key, value)
+将一个键值对存入localStorage中，会立刻返回结果。
+此函数会自动给key加上它的name作为前缀，以便于不同塔之间的区分。
+value为要存储的内容，存储前会被JSON转成字符串形式，并LZW算法进行压缩。
+如果value为null，则实际会调用core.removeLocalStorage()函数清除该key。
+localStorage为浏览器的默认存储，和存档无关，只有5M的空间大小。
+此函数立刻返回true或false，如果为false则代表存储失败，一般指的是空间满了。
+
+
+core.getLocalStorage(key, defaultValue)
+从localStorage中获得一个键的值，会立刻返回结果。
+此函数会自动给key加上它的name作为前缀，以便于不同塔之间的区分。
+如果对应的键值不存在或为null，则会返回defaultValue。
+返回的结果会被调用core.decompress进行解压缩和JSON解析。
+
+
+core.removeLocalStorage(key)
+从localStorage中删除一个键的值，会立刻返回。
+此函数会自动给key加上它的name作为前缀，以便于不同塔之间的区分。
+
+
+core.setLocalForage(key, value, successCallback, errorCallback)
+将一个键值对存入localForage中，异步返回结果。
+如果用户没有开启【新版存档】开关，则仍然会使用core.setLocalStorage()。
+localForage为一个开源库，项目地址 https://github.com/localForage/localForage
+一般存入的是indexedDB，这是一个浏览器的自带数据库，没有空间限制。
+successCallback和errorCallback均可选，表示该次存储成功或失败的回调，
+此函数为异步的，只能通过回调函数来获得存储的成功或失败信息。
+
+
+core.getLocalForage(key, defaultValue, successCallback, errorCallback)
+从localForage中获得一个键的值，异步返回结果。
+如果对应的键值不存在，则会使用defaultValue。
+如果获得成功，则会将core.decompress后的结果传入successCallback回调函数执行。
+errorCallback可选，如果失败，则会将错误信息传入errorCallback()。
+此函数是异步的，只能通过回调函数来获得读取的结果或错误信息。
+
+
+core.setGlobal(key, value)
+设置一个全局存储，适用于global:xxx。
+录像播放时将忽略此函数，否则直接调用core.setLocalStorage。
+
+
+core.getGlobal(key, value)
+获得一个全局存储，适用于global:xxx，支持录像。
+正常游戏时将使用core.getLocalStorage获得具体的数据，并将结果存放到录像中。
+录像播放时会直接从录像中获得对应的数据。
+
+
+core.clone(data, filter, recursion)
+深拷贝一个对象。有关浅拷贝，深拷贝，基本类型和引用类型等相关知识可参见：
+https://zhuanlan.zhihu.com/p/26282765
+filter为过滤函数，如果设置且不为null则需传递一个可接受(name, value)的函数，
+并返回true或false，表示该项是否应该被深拷贝。
+recursion表示该filter是否应递归向下传递，如果为true则递归函数也将传该filter。
+例如：
+core.clone(core.status.hero, function(name, value) {
+    return name == 'items' || typeof value == 'number';
+}, false);
+这个例子将会深拷贝勇士的属性和道具。
+
+
+core.splitImage(image, width, height)
+等比例切分一张图片。width和height为每张子图片的宽高。
+请确保原始图片的宽度和高度都是是width和height的倍数。
+此函数将返回一个一维数组，每一项都是一张切分好的图片，横向再纵向排列。
+例如4x3的图片按1x1切分得到一个长度为12的数组，按如下方式进行排列：
+0   1   2   3
+4   5   6   7
+8   9  10  11
+可以将很多需要的图片拼在一张大图上，然后在插件的_afterLoadResources中切分。
+切分好的图片再存入core.material.images.images中，这样可以少很多IO请求。
+
+
+core.formatDate(date) / core.formatDate2(date) / core.formatTime(time)
+格式化日期和时间。
+
+
+core.setTwoDigits(x)
+将x变成两位数。其实就是 parseInt(x) < 10 ? "0" + x : x
+
+
+core.formatBigNumber(x, onMap)
+大数据格式化。x为要格式化的内容，如果不合法会返回???。
+onMap标记是否在地图上调用，如果为真则尝试格式化成六位，否则五位。
+
+
+core.arrayToRGB(color) / core.arrayToRGBA(color)
+将一个颜色数组，例如[255,0,0,1]转成#FF0000或rgba(255,0,0,1)的形式。
+
+
+core.encodeRoute(route)
+录像压缩和解压缩。route为要压缩的路线数组。
+此函数将尽可能对录像进行压缩。对于无法识别的项目（比如自己添加的），将不压缩而原样放入。
+例如，["up","up","left","move:3:5","test:2333","getNext","item:bomb","down"]
+将被压缩成"U2LM3:5(test:2333)GIbomb:D"。
+自己添加的录像项只能由数字、大小写、下划线线、冒号等符号组成，否则无法正常压缩和解压缩。
+对于自定义内容（比如中文文本或数组）请使用JSON.stringify再core.encodeBase64处理。
+压缩的结果将再次进行LZString.compressToBase64()的压缩以进一步节省空间。
+
+
+core.decodeRoute(route)
+解压缩一个录像，返回解压完毕的路线数组。
+
+
+core.isset(v)
+判定v是不是null, undefined或NaN。
+请尽量避免使用此函数，而是直接判定 v == null （请注意 null==undefined ！）
+
+
+core.subarray(a, b)
+判定数组b是不是数组a的一个前缀子数组。
+如果是，则返回a中除去b后的剩余数组，否则返回null。
+
+
+core.inArray(array, element)
+判定array是不是一个数组，以及element是否在该数组中。
+
+
+core.clamp(x, a, b)
+将x限定在[a,b]区间内。
+
+
+core.getCookie(name)
+获得一个cookie值，如果不存在该cookie则返回null。
+
+
+core.setStatusBarInnerHTML(name, value, css)
+设置一个状态栏的innerHTML。此函数会自动设置状态栏的文字放缩和斜体等效果。
+name为状态栏的名称，如atk, def等。需要是core.statusBar中的一个合法项。
+value为要设置到的数值，如果是数字则会先core.formatBigNumber()进行格式化。
+css可选，为增添的额外css内容，比如可以设定颜色等。
+
+
+core.strlen(str)
+计算某个字符串的实际长度。每个字符的长度，ASCII码视为1，中文等视为2。
+
+
+core.reverseDirection(direction)
+翻转方向，即"up"转成"down", "left"转成"right"等。
+
+
+core.matchWildcard(pattern, string)
+进行通配符的匹配判定，目前仅支持*（可匹配0或任意个字符）。比如"a*b*c"可以匹配"aa012bc"。
+
+
+core.encodeBase64(str) / core.decodeBase64(str)
+将字符串进行base64加密或解密。
+
+
+core.convertBase(str, fromBase, toBase)
+任意进制转换。此函数可能执行的非常慢，慎用。
+
+
+core.rand(num)
+使用伪种子生成伪随机数。该随机函数能被录像支持。
+num如果设置大于0，则生成一个[0, num-1]之间的数；否则生成一个0到1之间的浮点数。
+此函数为伪随机算法，SL大法无效。（即多次SL后调用的该函数返回的值都是相同的。）
+
+
+core.rand2(num)
+使用系统的随机数算法得到的随机数。该随机函数能被录像支持。
+num如果设置大于0，则生成一个[0, num-1]之间的数；否则生成一个0到2147483647之间的整数。
+此函数使用了系统的Math.random()函数，支持SL大法。
+但是，此函数会将生成的随机数值存入录像，因此如果调用次数太多则会导致录像文件过大。
+对于需要大量生成随机数，但又想使用真随机支持SL大法的（例如随机生成地图等），可以采用如下方式：
+  var x = core.rand2(100); for (var i = 0; i < x; i++) core.rand()
+即先生成一个真随机数，根据该数来推进伪随机的种子，这样就可以放心调用core.rand()啦。
+
+
+core.readFile(success, error)
+读取一个本地文件内容。success和error分别为读取成功或失败的回调函数。
+iOS平台暂不支持读取文件操作。
+
+
+core.readFileContent(content)
+读取到的文件内容。此函数会被APP等调用，来传递文件的具体内容。
+
+
+core.download(filename, content)
+生成一个文件并下载。filename为文件名，content为具体的文件内容。
+iOS平台暂不支持下载文件操作。
+
+
+core.copy(data)
+将一段内容拷贝到剪切板。
+
+
+core.myconfirm(hint, yesCallback, noCallback)
+弹窗绘制一段提示信息并让用户确认。hint为提示信息。
+yesCallback和noCallback分别为确定和取消的回调函数。
+此函数和core.drawConfirmBox的区别主要在于：
+ - drawConfirmBox会清掉UI层原有的绘制信息，此函数不会清除。
+ - drawConfirmBox可以用键盘进行操作，此函数必须用鼠标点击。
+另外请注意：本函数的选择也不会进录像，一般用于全局的提示。
+如果需要在事件流中调用请使用显示确认框或显示选择项。
+
+
+core.myprompt(hint, value, callback)
+弹窗让用户输入一段内容。hint为提示信息，value为框内的默认填写内容。
+callback为用户点击确认或取消后的回调。
+如果用户点击了确认，则会把框内的内容（可能是空串）传递给callback，否则把null传递给callback。
+
+
+core.showWithAnimate(obj, speed, callback) / core.hideWithAnimate(obj, speed, callback)
+动画淡入或淡出一个对象。
+
+
+core.consoleOpened()
+检测当前的控制台是否处于开启状态。仅在全塔属性中的检查控制台开关开启时有效。
+此函数有可能会存在误伤行为，即没开过控制台仍认为开启过。
+
+
+core.hashCode(obj)
+计算一个对象的哈希值。
+
+
+core.same(a, b)
+判定a和b是否相同，包括类型相同和值相同。
+如果a和b都是数组，则会递归依次比较数组中的值；如果都是对象亦然。
+
+
+core.utils.http(type, url, formData, success, error, mimeType, responseType)
+发送一个异步HTTP请求。
+type为'GET'或者'POST'；url为目标地址；formData如果是POST请求则为表单数据。
+success为成功后的回调，error为失败后的回调。
+mimeType和responseType如果设置将会覆盖默认值。
+
+
+lzw_encode(s) / lzw_decode(s)
+LZW压缩算法，来自https://gist.github.com/revolunet/843889
+```
diff --git a/_docs/element.md b/_docs/element.md
new file mode 100644
index 00000000..a6fbcc9f
--- /dev/null
+++ b/_docs/element.md
@@ -0,0 +1,484 @@
+# 元件说明
+
+?> 目前版本**v2.6.1**，上次更新时间：* {docsify-updated} *
+
+在本章中，将对样板里的各个元件进行说明。各个元件主要包括道具、门、怪物、楼梯等等。
+
+请打开样板0层 `sample0.js` 进行参照对比。
+
+![生成地图](./img/sample0.png)
+
+## 道具
+
+本塔目前支持的所有道具列表在样板0层中已全部给出。当你在样板0层中拿到某个宝物时会有提示，这里不再赘述，详见拿到该道具的说明。
+
+大多数宝物都有默认的效果，屠龙匕首暂未定义，如有自己的需求可参见[自定义道具效果](personalization#自定义道具效果)。
+
+拿到道具后将触发`afterGetItem`事件，有关事件的详细介绍请参见[事件](event)。
+
+如需修改某个道具的效果，在不同区域宝石数据发生变化等问题，请参见[自定义道具效果](personalization#自定义道具效果)的说明。
+
+**有关轻按，在data.js的系统变量中有定义。如果`enableGentleClick`为true，则鼠标（触摸屏）通过双击勇士，键盘通过空格可达到轻按效果，即不向前移动而获得前方物品。**
+
+## 装备
+
+如果需要让剑盾等变成装备，可以直接在`data.js`中设置`'equipment': true`即可。
+
+从V2.4.1开始，HTML5魔塔样板终于拥有了属于自己的装备页面。
+
+### 装备栏的设置，装备类型
+
+在全塔属性中，有一个`equipName`项，其定义了本塔的所有可装备的装备栏。
+
+其需要是一个不小于1且不大于6的数组，其中每一项为装备栏的名称，**建议是两个汉字**。
+
+例如下面这种写法就是定义了四个装备孔，名称分别为武器、防御、首饰和魔杖。
+
+``` js
+"equipName": ["武器","防具","首饰","魔杖"]
+```
+
+这么定义好后，装备类型即为每个装备孔的索引（从0开始）。
+
+即，武器的装备类型是0，防御的装备类型是1，首饰的装备类型是2，魔杖的装备类型是3。
+
+### 设置每个装备的属性
+
+如果要将一个道具设置为装备，首先需要将其`cls`设为`equips`。
+
+然后在图块属性的`equip`一项中设置装备的具体属性。该项写法如下:
+
+``` js
+{"type": 0, "atk": 0, "def": 0, "mdef"：0, "animate": "hand", "percentage": true}
+```
+
+type为该装备的类型，必填，和上面装备栏一一对应。例如，0就是武器，2就是首饰等等。
+
+atk/def/mdef为该装备分别增加的攻防魔防数值（支持负数）；如果不加也可省略不写。
+
+从V2.6开始，可以拓展到任何勇士的属性，如hpmax, atk, def, mdef, experience等等；自行添加的属性包括攻速speed也能使用。
+
+animate为该装备的攻击动画，仅对type为0时有效。具体可参见[动画和天气系统](#动画和天气系统)。
+
+percentage为该装备是否按比例增加属性。
+
+下面是几个写法例子。
+
+``` js
+{"type": 0, "atk": 10} // 装备类型是武器，效果是攻击+10，使用默认的攻击动画
+{"type": 0, "atk": 40, "animate": "sword"} // 装备类型为武器，效果是攻击+10，攻击动画是sword
+{"type": 1, "def": 40, "percentage": true} // 装备类型是防具，效果是防御提升40%
+{"type": 1, "def": 100, "mdef": 100} // 装备类型是防具，效果是防御和魔防各+100
+{"type": 3, "atk": -20, "def": 50, "mdef": 50} // 装备类型是魔杖，效果是攻击-20，防御和魔防各+50
+{"type": 2, "atk": -20, "def": 50, "mdef": 50, "percentage": true} // 装备类型是魔杖，效果是攻击下降20%，防御和魔防各提升50%
+```
+
+所有取值全部向下取整。
+
+值得注意的是，如果多个装备同时按比例增加属性，使用加法计算。比如武器增加30%攻击，防具增加10%攻击，最终合起来增加的是40%而不是43%的属性。
+
+### 检测是否存在装备
+
+可以使用`core.hasEquip(itemId)`来检测是否装上某个装备。
+
+使用`core.hasItem(itemId)`来检测是否存在一个未装上的装备。
+
+使用`core.getEquip(equipType)`来获得某个装备类型的当前装备。
+
+更多相关API详见[附录：API列表](api)。
+
+### 多重装备
+
+从V2.5.4开始，允许支持多重装备，即有若干的装备可共用若干的格子（例如永不复还那样）。
+
+要实现这一点，上面的写法有所改变。
+
+在全塔属性中的`equipName`项写法不变，不过可以写重复的装备孔名称。（但仍然最多只能写6个）
+
+``` js
+"equipName": ["武器", "武器", "武器", "防具", "防具", "首饰"] 
+```
+
+然后对于某个装备，将其`type`（装备类型）写对应的装备孔名称即可。
+
+``` js
+{"type": "武器", "atk": 20, "def": 0, ...}
+```
+
+这样写的话，则所有该名称的装备孔均可装上此装备。
+
+当尝试装上此装备时，会取最小的一个空的装备孔进行装备。如果没有空闲的装备孔，则会提示“请先卸下装备”。
+
+装备动画仍然会取第一个（装备类型为0）的装备的`animate`项，即使装备了多个有动画的武器。
+
+## 门
+
+本塔支持6种门，黄蓝红绿铁花。前五种门需要有对应的钥匙打开，花门只能通过调用`openDoor`事件进行打开。
+
+开门后可触发该层的`afterOpenDoor`事件，有关事件的详细介绍请参见[事件](event)。
+
+如果要新增自己的门，请参见[新增门和对应的钥匙](personalization#新增门和对应的钥匙)。
+
+## 暗墙
+
+本塔支持暗墙。
+
+要制作一个暗墙非常简单：在该点直接放一个普通墙壁，然后事件写“开门”，坐标为该点就行。
+
+``` js
+// 该点画一个普通的墙壁，比如`yellowWall`
+
+// 在该点的事件events中:
+"x,y": [
+    {"type": "openDoor"} // 直接使用开门事件，坐标可忽略表示当前点
+]
+```
+
+系统会自动调用animates中的开暗墙动画。
+
+目前只有如下ID支持以这种方式开门：
+
+``` text
+yellowDoor, blueDoor, redDoor, greenDoor, specialDoor, steelDoor,
+yellowWall, blueWall, whiteWall
+```
+
+## 怪物
+
+本塔支持的怪物列表参见`project/enemys.js`。其与images目录下的`enemys.png`素材按顺序一一对应。
+
+如有自己的怪物素材需求请参见[自定义素材](personalization#自定义素材)的内容。
+
+怪物可以有特殊属性，每个怪物可以有多个自定义属性。
+
+怪物的特殊属性所对应的数字（special）在脚本编辑中的`getSpecials`中定义，请勿对已有的属性进行修改。
+
+多属性可采用数组的写法，比如`'special': [1,3]`视为同时拥有先攻和坚固属性；`'special': [5,10,14,18]`视为拥有3连击、魔防、诅咒、阻击四个属性。
+
+怪物可以负伤，在全塔属性的全局变量`enableNegativeDamage`中指定。
+
+打败怪物后可以进行加点操作。有关加点塔的制作可参见[加点事件](event#加点事件)。
+
+如果全塔属性中的enableExperience为false，即不启用经验的话，怪物手册里将不显示怪物的经验值，打败怪物也不获得任何经验。
+
+拿到幸运金币后，打怪获得的金币将翻倍。
+
+如果怪物有`"notBomb": true`，则该系列诖怪物均不可被炸。
+
+N连击怪物的special是6，且我们可以为它定义n代表实际连击数。参见样板中剑王的写法。
+
+吸血怪需要给怪物设置value，代表吸血的比例。
+
+可以给吸血怪添加`'add': true`来将吸血的数值加到自身上。
+
+中毒怪让勇士中毒后，每步扣减的生命值由`data.js`中的values定义。
+
+衰弱怪让勇士衰弱后，攻防会下降一定比例或固定数值（直到衰弱状态解除恢复）；其在`data.js`中的values定义。
+
+诅咒怪将让勇士陷入诅咒状态，诅咒状态下杀怪不获得金币和经验值。
+
+领域怪需要在怪物后添加value，代表领域伤害的数值。如果勇士生命值扣减到0，则直接死亡触发lose事件。
+
+领域是十字伤害还是九宫格伤害由`zoneSquare`设定，如设置为true则为九宫格伤害，不指定或为false则为十字伤害。
+
+领域怪还可以设置`range`选项代表该领域怪的范围，不写则默认为1。
+
+**将`flag:no_zone`设置为true可以取消领域效果。**
+
+阻击怪同样需要设置value，代表阻击伤害的数值。如果勇士生命值扣减到0，则直接死亡触发lose事件。
+
+**将`flag:no_snipe`设置为true可以取消阻击效果。**
+
+!> 阻击怪后退的地点不能有任何事件存在，即使是已经被禁用的自定义事件！
+
+激光怪同样需要设置value，代表激光伤害的数值。
+
+请注意如果吸血、领域、阻击中任何两个同时存在，则value会冲突。**因此请勿将吸血、领域、阻击或激光放置在同一个怪物身上。**
+
+**将`flag:no_laser`设置为true可以免疫激光效果。**
+
+退化怪需要设置'atkValue'和'defValue'表示退化的数值；也可以不设置默认为0。
+
+夹击可以通过全塔属性中的`betweenAttackCeil`设为true可以将伤害向上取整。
+
+**将`flag:no_betweenAttack`设置为true可以免疫夹击效果。**
+
+固伤怪则需要设置`damage`选项，代表战前扣血数值。
+
+如有额外需求，可参见[自定义怪物属性](personalization#自定义自定义怪物属性)，里面讲了如何设置一个新的怪物属性。
+
+## 怪物和NPC的朝向问题
+
+从V2.5.2开始，对于人形怪物和NPC的朝向问题已经有着比较好的解决方式。
+
+首先明确一点的是，和RM不同，H5中即使是对同一个怪物/NPC的不同朝向，也需要分别将其各个朝向素材追加对应的图片上，并进行注册。
+
+### 怪物的朝向问题
+
+对于同一个怪物的不同朝向，需要对每个朝向创建一个怪物（属性完全相同），这样就可以在地图上绘制不同朝向的怪物。
+
+但是这样会存在一个问题，就是怪物手册中怪物的每个朝向都会显示成一个单独的怪物。
+
+为了避免这种情况的发生，在怪物的属性中存在一个`displayIdInBook`项，**我们可以指定该项来控制每个怪物在怪物手册中中显示成的怪物。**
+
+举个例子，假设我现在有个怪物，其向下的行走图ID是`E300`，其向左的行走图ID是`E301`，向右的行走图ID是`E302`。分别对这几个怪物填写完全相同的怪物属性。
+
+如果我在地图上同时绘制向下、向左和向右的该怪物，则确实能在地图上显示出来不同的朝向，但是在怪物手册中会同时显示这三种类型的怪物，观感较差。
+
+我们可以给`E301`和`E302`怪物属性中的`displayIdInBook`项填写为`"E300"`。
+
+这样的话，在怪物手册中，所有的E301和E302均会被视为E300并进行合并。即使只有一只朝向左的怪物（E301），怪物手册仍然会按E300进行显示。
+
+从而完美解决了同种怪物不同朝向在怪物手册的显示问题。
+
+### NPC的朝向问题
+
+和怪物不同的是，NPC朝向问题更复杂一点。
+
+在NPC的图块属性中，存在一个`faceIds`的项目，可以用其来绑定一个图块所对应的其他朝向的图块ID。
+
+举个例子，假设我存在一个NPC，其向上的图块ID是N333，向下的图块ID是N334，向左的图块ID是N335，不存在向右的图块ID。
+
+则可以在这几个图块属性中的`faceIds`中写：`{"up": "N333", "down": "N334", "left": "N335"}`。
+
+当勇士从左边撞上此怪物后，将从该图块的图块属性中的faceIds中寻求`left`所对应的ID。
+如果存在定义（如N335），则会在触发对话事件前改变当前图块为N335，看起来就是在对话前进行了转向，面向勇士。
+
+!> 请注意，在对话结束后朝向不会切换回来，因此如果有必要切换朝向请在事件结束前调用转变图块事件。
+
+同理，使用移动事件让NPC在行走时，不同朝向的行走会自动调用`faceIds`中不同朝向的ID所对应的行走图，看起来就是在行走时也可以不断转向了。
+
+从而，完美解决了NPC的朝向问题（碰触时面向勇士、行走时改变朝向）。
+
+## 路障，楼梯，传送门
+
+血网的伤害数值、中毒后每步伤害数值、衰弱时暂时攻防下降的数值，都在全塔属性的values内定义。
+
+路障同样会尽量被自动寻路绕过。
+
+有关楼梯和传送门，必须在该层样板的changeFloor里指定传送点的目标。
+
+floorId指定的是目标楼层的唯一标识符（ID）。
+
+也可以写`"floorId": ":before"`和`"floorId": ":next"`表示上一楼和下一楼。
+
+后面可以写stair到upFloor或downFloor，表示将前往目标楼层的上楼梯/下楼梯位置。你也可以写loc然后指定目标点的坐标。
+
+请注意的是，如果目标楼层有多个楼梯，写stair可能会导致到达的楼梯不确定，这时候请使用loc方式来指定具体的点位置。
+
+可以指定direction为up/left/right/down，指定后勇士将面向该方向。
+
+可以指定time，指定后切换动画时长为指定的数值。
+
+**从2.1.1开始，楼层属性中提供了`upFloor`和`downFloor`两项。如果设置此项（比如`"upFloor": [2,3]`），则写stair:upFloor或者楼传器的落点将用此点来替换楼梯位置（即类似于RM中的上箭头）。**
+
+## 剧情文本控制与对话框效果
+
+在写剧情文本时，可以：
+
+- 使用`\t[...]`来给文字加上标题和图标。如`\t[老人,man]`。
+- 使用`\b[...]`来制作对话框效果，如`\b[up,3,2]`。
+- 使用`\r[...]`来动态修改局部文本的颜色，如`\r[red]`。
+- 使用`${}`来计算一个表达式的值，如`${status:atk+status:def}`。
+- 使用`\f[...]`来同时插入一张立绘图，如`\f[1.png,100,200]`。
+- 使用`\\i[...]`来在对话框中绘制一个图标，如`\\i[fly]`。
+
+从V2.5.2开始，也允许绘制一张头像图在对话框中，只要通过`\t[1.png]`或`\t[标题,1.png]`的写法。
+
+**使用`\\i[...]`绘制图标请注意：在事件块中，允许只写一个反斜杠`\i`，系统会自动转义成`\\i`；但是在脚本中必须两个反斜杠都写上！**
+
+详细信息请参见[剧情文本控制](event#text：显示一段文字（剧情）)中的说明。
+
+从V2.5.2开始，可以用一张WindowSkin图片作为对话框的背景皮肤。
+
+使用时，需要将图片放在images目录下，并在全塔属性中予以注册。
+
+可以使用[设置剧情文本的属性](setText：设置剧情文本的属性)事件将对话框背景设置为需要的皮肤。
+
+!> 关于对话框效果请注意，现在是采用WindowSkin的右下角两个32x32的图片作为对话框尖角进行绘制。因此请尽量使用群文件或网盘的常用素材中给出的WindowSkin素材（均已进行对话框适配）。如需使用来自第三方的WindowSkin素材，请自行注意对话框的尖角问题，或弃用`\b`效果。
+
+另外一点是，V2.5.2以后，对话框`\b`可以根据文字长度来自动控制文本框宽度，其基本控制原理如下：
+
+- 如果用户存在手动换行`\n`，则选取**最长的一段话**作为文本框宽度。
+- 如果用户不存在手动换行，则会将文本框宽度调整为X行半的最佳宽度。
+- 文本框宽度存在上下界，最终宽度一定会控制在该范围内。
+
+该自动调整仅对`\b`的对话框效果有效。非对话框仍然会绘制整个界面的宽度。
+
+## 大地图
+
+从V2.4开始，H5魔塔开始支持大地图。
+
+大地图在创建时可以指定宽高，要求**宽和高都不得小于13（15x15版本则是不小于15），且宽高之积不超过1000**。
+
+大地图一旦创建成功则不得修改宽高数值。
+
+## 动画和天气系统
+
+现在我们的H5魔塔支持播放动画，也支持天气系统了。
+
+要播放动画，你需要先使用“RM动画导出器”将动画导出，放在animates目录下，然后在全塔属性的animates中定义。
+
+``` js
+// 在此存放所有可能使用的动画，必须是animate格式，在这里不写后缀名
+// 动画必须放在animates目录下；文件名不能使用中文，不能带空格或特殊字符
+"animates": ["hand", "sword", "zone", "yongchang", "thunder"]
+```
+
+!> 动画必须是animate格式，名称不能使用中文，不能带空格或特殊字符。
+
+导出动画时可能会进行一些压缩以节省流量，因此清晰度可能不如原版。
+
+从2.3.2开始，动画可以同时导出所用的音效。**如果导出音效，请确保将所用到的音效复制到了`sounds`目录下，并且在全塔属性中注册过。**
+
+动画播放时，是按照每秒20帧的速度（即50ms/帧）。
+
+定义完毕后，我们可以调用`animate`事件来播放该动画，有关事件的详细介绍请参见[事件](event)。
+
+!> 播放录像时，将默认忽略所有动画。
+
+目前天气系统支持雨和雪和雾两种天气。
+
+在每层楼的楼层属性中存在一个weather选项，表示该层楼的默认天气。
+
+``` js
+// 该层的默认天气。本项可忽略表示晴天，如果写则第一项为"rain"，"snow"或"fog"代表雨雪雾，第二项为1-10之间的数代表强度。
+"weather": ["snow",5] 
+```
+
+我们也可以使用`setWeather`事件来设置当前天气，有关事件的详细介绍请参见[事件](event)。
+
+## 背景音乐
+
+本塔支持BGM和SE的播放。
+
+要播放音乐和音效，你需要将对应的文件放在sounds目录下，然后在全塔属性中进行定义
+
+``` js
+// 在此存放所有的bgm，和文件名一致。
+// 音频名不能使用中文，不能带空格或特殊字符；可以直接改名拼音就好
+"bgms": ["bgm.mp3"]
+
+// 在此存放所有的SE，和文件名一致
+"sounds": ["floor.mp3", "attack.mp3", "door.mp3", "item.mp3", "zone.mp3"]
+```
+
+!> 音频名不能使用中文，不能带空格或特殊字符。
+
+目前BGM支持主流的音乐格式，如mp3, ogg等。不支持mid格式的播放。
+
+定义完毕后，我们可以调用`playBgm`/`playSound`事件来播放对应的音乐/音效，有关事件的详细介绍请参见[事件](event)。
+
+**另外，考虑到用户的流量问题，将遵循如下规则：**
+
+- **如果用户当前使用的电脑，则默认开启音乐效果，并播放默认BGM**
+- **如果用户当前使用的手机，且处于Wifi状态，则默认开启音乐效果，并播放默认BGM**
+- **其他情况，将默认关闭音乐效果，只有在用户在菜单栏中点击“音乐开关”后才会播放音乐**
+
+!> iOS平台以及部分浏览器不支持获得当前网络状态，此时即使在使用Wifi也必须要用户点击“音乐开关”才能播放音乐。
+
+从V2.5.3开始，可以使用`loadBgm`事件来预加载一个bgm，这样到播放时无需等待，直接播放。
+
+同时BGM将使用LRU算法增加缓存机制。默认最多缓存4个BGM（在core.js的musicStatus.cachedBgmCount控制）。
+
+系统会自动释放最久未使用的BGM。
+
+也可以使用`freeBgm`事件来手动释放一个无需再用的bgm。
+
+## 录像
+
+HTML5魔塔一大亮点就是存在录像系统，可以很方便进行录像回放。
+
+当你在游戏的过程中，随着你的操作，录像也会被依次记录。游戏结束后将提示是否下载录像，上传成绩时也会上传你的录像信息。
+
+在菜单栏-同步存档中，可以直接对当前录像进行下载。
+
+!> 录像记录的是你当前的路线（本质上是模拟键盘操作），是一个纯文本文件，占用空间很小！
+
+录像的回放主要有两种方式：
+
+1. 保存成的录像文件(.h5route文件)：在标题界面点录像回放，再选择文件即可。
+2. 游戏过程中时的当前录像：随时按R可以进行回放；手机端则可调出虚拟键盘，再按R。
+
+录像播放过程中，可以进行如下操作：
+
+- **暂停/播放：** 按空格可以随时暂停或播放录像。
+- **加速：** 按X可以加速录像播放，最高可达6倍速。
+- **减速：** 按Z可以减速录像播放，最低可达0.3倍速。
+- **停止：** 按ESC可以立刻停止录像播放，并返回正常游戏。
+- **回退：** 按A可以回退到上一个录像节点（录像播放过程中每50步存一个录像节点）。
+- **存档：** 按S可以在录像播放过程中进行存档。
+- **查看手册：** 按C可以在录像播放过程中查看怪物手册。
+- **浏览地图：** 按PgUp/PgDn可以在录像播放过程中浏览地图。
+
+如果录像出现问题，请加群539113091找小艾反馈Bug。
+
+## 绘图模式
+
+从V2.5开始，样板提供了绘图模式，可以让玩家在画布上任意进行绘制，标记等。
+
+使用M键，或在菜单栏中可以进入绘图模式。
+
+**绘图的内容会自动保存，且以页面为生命周期，和存读档无关，返回标题并重新开始游戏后绘制的内容仍有效，但刷新页面就会消失。**
+
+你可以将绘制内容保存到文件，也可以从文件读取保存的绘制内容。
+
+绘图模式下，状态栏的图标也会相应改变，铅笔为绘制模式，橡皮为擦除模式，存读档为保存和读取绘图文件，退出为返回默认值。
+
+在浏览地图页面中也可以按楼传按钮或M键来开启/关闭该层的绘图显示。
+
+## 操作说明
+
+![](img/keyboard.png)
+
+<!--
+本塔主要支持鼠标（触摸屏）操作和键盘操作。
+
+鼠标（触摸屏）操作说明如下：
+
+- **点状态栏中图标：** 进行对应的操作
+- **点任意块：** 寻路并移动
+- **点任意块并拖动：** 指定寻路路线
+- **单击勇士：** 转向
+- **双击勇士：** 轻按（仅在轻按开关打开时有效）
+- **长按任意位置：** 打开虚拟键盘
+
+键盘操作快捷键如下：
+
+- **[CTRL]** 跳过对话
+- **[Z]** 转向
+- **[X]** 打开/关闭怪物手册
+- **[G]** 打开/关闭楼层传送器
+- **[A]** 读取自动存档
+- **[S/D]** 打开/关闭存/读档页面
+- **[V]** 打开/关闭快捷商店选择列表
+- **[T]** 打开/关闭工具栏
+- **[Q]** 打开/关闭装备栏
+- **[ESC]** 打开/关闭系统菜单
+- **[B]** 打开数据统计
+- **[H]** 打开帮助页面
+- **[R]** 回放录像
+- **[E]** 显示光标
+- **[SPACE]** 轻按（仅在轻按开关打开时有效）
+- **[M]** 绘图模式
+- **[PgUp/PgDn]** 浏览地图
+- **[1]** 快捷使用破墙镐
+- **[2]** 快捷使用炸弹/圣锤
+- **[3]** 快捷使用中心对称飞行器
+- **[4]** 快捷使用其他道具
+- **[Alt+0~9]** 快捷换装
+
+以上快捷键也能在游戏菜单中的操作说明中看到。
+-->
+
+&nbsp;
+
+&nbsp;
+
+上面就是整个样板中的各个元件说明。通过这种方式，你就已经可以做出一部没有任何事件的塔了。
+
+尝试着做一个两到三层的塔吧！
+
+==========================================================================================
+
+[继续阅读下一章：事件](event)
diff --git a/docs/event.md b/_docs/event.md
similarity index 50%
rename from docs/event.md
rename to _docs/event.md
index 04e68bc7..34fff45b 100644
--- a/docs/event.md
+++ b/_docs/event.md
@@ -1,6 +1,6 @@
 # 事件
 
-?> 目前版本**v2.3.3**，上次更新时间：* {docsify-updated} *
+?> 目前版本**v2.6.1**，上次更新时间：* {docsify-updated} *
 
 本章内将对样板所支持的事件进行介绍。
 
@@ -10,8 +10,6 @@
 
 上述这些默认的事件已经存在处理机制，不需要我们操心。我们真正所需要关心的，其实只是一个自定义的事件。
 
-**本塔中的所有自定义事件能且只能被其他事件触发。不存在RMXP里面那种，设置了某个变量为true后，一个事件被自动执行的问题。这点和RMXP的区别非常大，请务必注意。**
-
 所有事件都存在两种状态：启用和禁用。  
 - 启用状态下，该事件才处于可见状态，可被触发、交互与处理。  
 - 禁用状态下该事件相当于不存在，不可见、不可被触发、不可交互。
@@ -22,11 +20,13 @@
 
 ## 关于V2.0的重要说明
 
-在V2.0版本中，所有事件均可以使用blockly来进行块的可视化编辑。
+在V2.0以后版本中，所有事件均可以使用blockly来进行块的可视化编辑。
 
 它能通过拖动、复制粘贴等方式帮助你快速生成事件列表，而不用手动打大量字符。
 
-但是，仍然强烈建议要对每个事件的写法进行了解，因为在脚本编辑，`insertAction`等地方需要插入自定义事件时，还是很有必要的。
+下述所说的都是在事件编辑器右边所展示的，该事件的代码化写法。
+
+强烈建议要对每个事件的写法进行了解，因为在脚本编辑，`insertAction`等地方需要插入自定义事件时，还是很有必要的。
 
 ## 自定义事件
 
@@ -35,22 +35,18 @@
 所有自定义的事件都是如下的写法：
 
 ``` js
-"events": { // 该楼的所有可能事件列表
-    "x,y": {
-        "trigger": "action", // 触发的trigger, action代表自定义事件
-        "enable": true, // 该事件初始状态下是否处于启用状态
-        "noPass": true, // 该点是否不可通行。true代表不可通行，false代表可通行。
-        "data": [ // 实际执行的事件列表
-            // 事件1
-            // 事件2
-            // ...
-        ]
-    }
+{
+    "trigger": "action", // 触发的trigger, action代表自定义事件
+    "enable": true, // 该事件初始状态下是否处于启用状态
+    "noPass": true, // 该点是否不可通行。true代表不可通行，false代表可通行。
+    "data": [ // 实际执行的事件列表
+        // 事件1
+        // 事件2
+        // ...
+    ]
 }
 ```
 
-这里的`"x,y"`代表该点的横坐标为`x`，纵坐标为`y`；即从左到右第`x`列，从上到下的第`y`行（从0开始计算）。
-
 我们上面提到，有很多系统已经默认的事件（例如开门、打怪等，相当于公共事件）。如果我们需要自定义一个事件，则需要`"trigger": "action"`，它表示该点是一个自定义事件。
 
 !> **如果系统本身存在事件（如一个怪物），且你指定了`"trigger": "action"`，则原事件会被覆盖。**
@@ -60,17 +56,15 @@
 如果该点本身不存在系统事件，则`"trigger":"action"`可被省略不写：
 
 ``` js
-"events": { // 该楼的所有可能事件列表
-    "x,y": {
-        // 除非你要覆盖该点已存在的系统默认事件，否则"trigger": "action"可以省略
-        "enable": true, // 该事件初始状态下是否处于启用状态
-        "noPass": true, // 该点是否不可通行。true代表不可通行，false代表可通行。
-        "data": [ // 实际执行的事件列表
-            // 事件1
-            // 事件2
-            // ...
-        ]
-    }
+{
+    // 除非你要覆盖该点已存在的系统默认事件，否则"trigger": "action"可以省略
+    "enable": true, // 该事件初始状态下是否处于启用状态
+    "noPass": true, // 该点是否不可通行。true代表不可通行，false代表可通行。
+    "data": [ // 实际执行的事件列表
+        // 事件1
+        // 事件2
+        // ...
+    ]
 }
 ```
 
@@ -79,17 +73,15 @@
 默认情况下`enable`是`true`，所以如果`enable`为`true`，该项也可以省略不写：
 
 ``` js
-"events": { // 该楼的所有可能事件列表
-    "x,y": {
-        // 除非你要覆盖该点已存在的系统默认事件，否则"trigger": "action"可以省略
-        // 该事件初始状态下是启用状态，则可以省略"enable": true；如果是禁用状态则必须加上"enable": false
-        "noPass": true, // 该点是否不可通行。true代表不可通行，false代表可通行。
-        "data": [ // 实际执行的事件列表
-            // 事件1
-            // 事件2
-            // ...
-        ]
-    }
+{
+    // 除非你要覆盖该点已存在的系统默认事件，否则"trigger": "action"可以省略
+    // 该事件初始状态下是启用状态，则可以省略"enable": true；如果是禁用状态则必须加上"enable": false
+    "noPass": true, // 该点是否不可通行。true代表不可通行，false代表可通行。
+    "data": [ // 实际执行的事件列表
+        // 事件1
+        // 事件2
+        // ...
+    ]
 }
 ```
 
@@ -100,17 +92,15 @@
 因此，除非你想覆盖默认的可通行选项（比如将一个空地设为不可通行），否则该项可以忽略。
 
 ``` js
-"events": { // 该楼的所有可能事件列表
-    "x,y": {
-        // 除非你要覆盖该点已存在的系统默认事件，否则"trigger": "action"可以省略
-        // 该事件初始状态下是启用状态，则可以省略"enable": true；如果是禁用状态则必须加上"enable": false
-        // 除非你想覆盖系统默认的可通行状态，否则"noPass"项可以忽略
-        "data": [ // 实际执行的事件列表
-            // 事件1
-            // 事件2
-            // ...
-        ]
-    }
+{
+    // 除非你要覆盖该点已存在的系统默认事件，否则"trigger": "action"可以省略
+    // 该事件初始状态下是启用状态，则可以省略"enable": true；如果是禁用状态则必须加上"enable": false
+    // 除非你想覆盖系统默认的可通行状态，否则"noPass"项可以忽略
+    "data": [ // 实际执行的事件列表
+        // 事件1
+        // 事件2
+        // ...
+    ]
 }
 ```
 
@@ -119,14 +109,12 @@
 如果大括号里只有`"data"`，则可以省略大括号和`"data"`，直接写中括号数组，换句话说，上面和下面这种写法也是等价的，可以进行一下比较：
 
 ``` js
-"events": { // 该楼的所有可能事件列表
-    // 如果大括号里只有"data"项(没有"action", "enable"或"noPass")，则可以省略到只剩下中括号
-    "x,y": [ // 实际执行的事件列表
-        // 事件1
-        // 事件2
-        // ...
-    ]
-}
+// 如果大括号里只有"data"项(没有"action", "enable"或"noPass")，则可以省略到只剩下中括号
+[
+    // 事件1
+    // 事件2
+    // ...
+]
 ```
 
 这种简写方式可以极大方便地造塔者进行造塔。
@@ -138,15 +126,13 @@
 `"data"`中，是由一系列的自定义事件类型组成。每个元素类似于：
 
 ``` js
-"events": { // 该楼的所有可能事件列表
-    // 如果大括号里只有"data"项(没有"action"或"enable")，则可以省略到只剩下中括号
-    "x,y": [ // 实际执行的事件列表
-        {"type": "xxx", ...}, // 事件1
-        {"type": "xxx", ...}, // 事件2
-        // ...
-        // 按顺序写事件，直到结束
-    ]
-}
+// 如果大括号里只有"data"项(没有"action"或"enable")，则可以省略到只剩下中括号
+[
+    {"type": "xxx", ...}, // 事件1
+    {"type": "xxx", ...}, // 事件2
+    // ...
+    // 按顺序写事件，直到结束
+]
 ```
 
 `"type"`为该自定义事件的类型；而后面的`...`则为具体的一些事件参数。
@@ -160,29 +146,23 @@
 使用`{"type": "text"}`可以显示一段文字。后面`"text"`可以指定文字内容。
 
 ``` js
-"events": { // 该楼的所有可能事件列表
-    // 如果大括号里只有"data"项(没有"action"或"enable")，则可以省略到只剩下中括号
-    "x,y": [ // 实际执行的事件列表
-        {"type": "text", "text": "在界面上的一段文字"}, // 显示文字事件
-        {"type": "text", "text": "这是第二段文字"}, // 显示第二个文字事件
-        // ...
-        // 按顺序写事件，直到结束
-    ]
-}
+[
+    {"type": "text", "text": "在界面上的一段文字"}, // 显示文字事件
+    {"type": "text", "text": "这是第二段文字"}, // 显示第二个文字事件
+    // ...
+    // 按顺序写事件，直到结束
+]
 ```
 
 该项可以简写成直接的字符串的形式，即下面这种方式也是可以的：
 
 ``` js
-"events": { // 该楼的所有可能事件列表
-    // 如果大括号里只有"data"项(没有"action"或"enable")，则可以省略到只剩下中括号
-    "x,y": [ // 实际执行的事件列表
-        "在界面上的一段文字",// 直接简写，和下面写法完全等价
-        {"type": "text", "text": "这是第二段文字"}, // 显示第二个文字事件
-        // ...
-        // 按顺序写事件，直到结束
-    ]
-}
+[
+    "在界面上的一段文字",// 直接简写，和下面写法完全等价
+    {"type": "text", "text": "这是第二段文字"}, // 显示第二个文字事件
+    // ...
+    // 按顺序写事件，直到结束
+]
 ```
 
 所有文字事件均可以进行简写，系统会自动转成`{"type": "text"}`的形式。
@@ -190,15 +170,12 @@
 值得注意的是，系统会自动对文字进行换行；不过我们也可以手动加入`\n`来换行。
 
 ``` js
-"events": { // 该楼的所有可能事件列表
-  // 如果大括号里只有"data"项(没有"action"或"enable")，则可以省略到只剩下中括号
-  "x,y": [ // 实际执行的事件列表
+[
     "这一段文字特别特别长，但是系统可以对它进行自动换行，因此我们无需手动换行",
     "这是第一行\n这是第二行\n这是第三行",
     // ...
     // 按顺序写事件，直到结束
-  ]
-}
+]
 ```
 
 我们可以给文字加上标题或图标，只要以`\t[...]`开头就可以。
@@ -209,8 +186,12 @@
 
 对于hero和怪物，也可以不写名字代表使用默认值。
 
+从V2.5.2以后，新增了绘制大头像的功能。绘制大头像图的基本写法是`\t[1.png]`或者`\t[标题,1.png]`。
+
+从V2.6开始，所有图块都允许只写ID，对于非怪物则没有标题。
+
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     "一段普通文字",
     "\t[勇士,hero]这是一段勇士说的话",
     "\t[hero]如果使用勇士默认名称也可以直接简写hero",
@@ -218,63 +199,117 @@
     "\t[blackMagician]如果使用怪物的默认名称也可以简写怪物id",
     "\t[小妖精,fairy]这是一段小妖精说的话，使用仙子(fairy)的图标",
     "\t[你赢了]直接显示标题为【你赢了】",
+    "\t[1.png]绘制1.png这个头像图",
+    "\t[标题,1.png]同时绘制标题和1.png这个头像图",
+    "\t[sword1]获得铁剑，没有标题",
+    "\t[man]没有标题的npc动画"
 ]
 ```
 
+!> 大头像的头像图需要在全塔属性中注册，且必须是png格式，不可以用jpg或者其他格式，请自行转换。
+
 除此以外，我们还能实现“对话框效果”，只要有`\b[...]`就可以。
 
 - `\b[up]` 直接显示在当前点上方。同样把这里的up换成down则为下方。
-  - 如果不存在当前点（如在firstArrive中调用），则显示在屏幕最上方（最下方）
+  - 如果不存在当前点（如在firstArrive或eachArrive中调用），则显示在屏幕最上方（最下方）
 - `\b[up,hero]` 显示在勇士上方。同样把这里的up换成down则为下方。
-- `\b[up,x,y]` 显示在(x,y)点的上方（下方）；x和y都为整数且在0到12之间。
+  - 从V2.6开始，也允许写`\b[hero]`来根据勇士位置自动决定上方还是下方
+- `\b[up,x,y]` 显示在(x,y)点的上方（下方）；x和y都为整数且在0到12之间
+  - 从V2.6开始，也允许写`\b[null,x,y]`来根据(x,y)位置自动决定上方还是下方
+- `\b[up,x]` 显示在勇士的第x个跟随的行走图的上方（下方）；也允许把up换成null来自动适配
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     "\b[up]这段文字显示在当前点上方",
     "\b[down]这段文字显示在当前点上方",
     "\t[hero]\b[up,hero]这是一段勇士说的话，会显示在勇士上方",
+    "\t[hero]\b[hero]这是一段勇士说的话，根据勇士位置自动适配上下",
     "\t[小妖精,fairy]\b[down,2,2]这是一段小妖精说的话，会显示在(2,2)点下方",
+    "\t[null,1,3]根据坐标位置自动适配上下",
+    "\t[up,1]"显示在勇士第一个跟随的行走图上方",
+    "\t[null,2]显示在勇士第二个跟随的行走图，自动适配上下",
 ]
 ```
 
+从V2.6开始，`\b`提供了更多功能，包括：
+
+- `\b[hero]`
+
 !> `\t[...]`必须在`\b[...]`前面！不然两者都无法正常显示。
 
+还可以使用`\r[...]`来调整剧情文本的颜色。
+
+``` js
+[
+    "这句话是默认颜色，\r[red]将颜色变成红色，\r[blue]将颜色变成蓝色",
+    "\r[#FF00FF]还可以使用RGB值来控制颜色，\r如果不加中括号则回到默认颜色",
+    "\t[hero]\b[up,hero]啊啊啊，别过来，\r[red]别过来！！！\n\r你到底是什么东西！"
+]
+```
+
+从V2.5.3以后，也可以使用`\f[...]`来同时绘制一张图片。
+
+其基本写法是`\f[img,x,y]`，或者`\f[img,x,y,w,h]`，或者`\f[img,sx,sy,sw,sh,x,y,w,h]`。
+
+需要注意的是，这个图片是绘制在UI层上的，下一个事件执行时即会擦除；同时如果使用了\t的图标动画效果，重叠的地方也会被图标动画给覆盖掉。
+
+``` js
+[
+    "\t[勇士]\b[up,hero]\f[1.png,100,100]以(100,100)为左上角绘制1.png图片",
+    "\t[hero]\f[1.png,100,100]\f[2.png,300,300]同时绘制了两张图片",
+    "\f[1.png,100,100,300,300]也可以填写宽高，这样会把图片强制进行放缩到指定的宽高值",
+    "\f[1.png,64,64,128,128,100,100,128,128]裁剪1.png上以(64,64)开始的128x128图片，并绘制到画布的(100,100)处"
+]
+```
+
+从V2.5.5以后，也可以使用`\\i[...]`来在对话框中绘制一个图标。
+
+这里可以使用一个合法ID（32x48图块除外），或使用一个系统图标（`core.statusBar.icons`中的内容）。
+
+``` js
+[
+    "\t[勇士]\b[up,hero]这是一个飞行器\\i[fly]，这是一个破墙镐\\i[pickaxe]",
+    "\t[hero]也可以使用系统图标，比如这是存档\\i[save]，这是工具栏\\i[toolbox]",
+]
+```
+
+**可以在控制台中输入`core.statusBar.icons`以查看所有的系统图标定义。**
+
+!> 注意，在事件块中，允许只写一个反斜杠`\i`，系统会自动转义成`\\i`；但是在脚本中必须两个反斜杠都写上！
 
 另外值得一提的是，我们是可以在文字中计算一个表达式的值的。只需要将表达式用 `${ }`整个括起来就可以。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     "1+2=${1+2}, 4*5+6=${4*5+6}", // 显示"1+2=3, 4*5+6=26"
 ]
 ```
 
 我们可以使用 `status:xxx` 代表勇士的一个属性值；`item:xxx` 代表某个道具的个数；`flag:xxx` 代表某个自定义的变量或flag值。
 
+从V2.6开始，也可以使用`global:xxx`代表全局存储（和存档无关的存储）。
+
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     "你当前的攻击力是${status:atk}, 防御是${status:def}，坐标是(${status:x},${status:y})",
     "你的攻防和的十倍是${10*(status:atk+status:def)}",
     "你的红黄蓝钥匙总数为${item:yellowKey+item:blueKey+item:redKey}",
     "你访问某个老人的次数为${flag:man_times}",
+    "当前的存档编号是${global:saveIndex}",
 ]
 ```
 
 - `status:xxx` 获取勇士属性时只能使用如下几个：hp（生命值），atk（攻击力），def（防御力），mdef（魔防值），money（金币），experience（经验），x（勇士的横坐标），y（勇士的纵坐标），direction（勇士的方向）。
 - `item:xxx` 中的xxx为道具ID。所有道具的ID定义在items.js中，请自行查看。例如，`item:centerFly` 代表中心对称飞行器的个数。
-- `flag:xxx` 中的xxx为一个自定义的变量/Flag；如果没有对其进行赋值则默认值为false。
-
-另外，有个小`trick`。是否想立刻知道显示效果？
-
-你可以用Chrome浏览器打开游戏，按Ctrl+Shift+I打开开发者工具，找到Console（控制台），并中输入`core.drawText("...")` 即可立刻看到文字显示的效果。适当调整文字，使得显示效果满意后，再复制粘贴到你的剧情文本中。
-
-![调试](./img/eventdebug.png)
+- `flag:xxx` 中的xxx为一个自定义的变量/Flag（支持中文）；如果没有对其进行赋值则默认值为0。
+- `global:xxx` 中的xxx为一个全局存储的名称（支持中文）；如果没有对其进行赋值则默认值为0。
 
 ### autoText：自动剧情文本
 
 使用`{"type": "autoText"}`可以使用剧情文本。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type": "autoText", "text": "一段自动显示的剧情文字", "time": 5000}
 ]
 ```
@@ -289,15 +324,38 @@ time为可选项，代表该自动文本的时间。可以不指定，不指定
 
 !> 由于用户无法跳过自动剧情文本，因此对于大段剧情文本请自行添加“是否跳过剧情”的提示，否则可能会非常不友好。
 
+### scrollText：滚动剧情文本
+
+使用`{"type": "scrollText"}`可以使用滚动剧情文本，即将一段文字从屏幕最下方滚动到屏幕最上方。
+
+``` js
+[
+    {"type": "scrollText", "text": "第一排\n第二牌\n\n空行后的一排", "time": 5000, "lineHeight": 1.4, "async": true},
+]
+```
+
+text为正文文本内容。可以使用`${ }`来计算表达式的值，且使用`\n`手动换行。系统不会对滚动剧情文本进行自动换行。
+
+time为可选项，代表总的滚动时间。默认为5000毫秒。
+
+lineHeight为可选项，代表行距。默认为1.4。
+
+async可选，如果为true则会异步执行（即不等待当前事件执行完毕，立刻执行下一个事件）。
+
+可以使用下面的[设置剧情文本的属性](event#setText：设置剧情文本的属性)来对文字颜色、文字大小、粗体、距离左边的偏移量进行设置。
+
+!> 滚动剧情文本会绘制在UI层（和对话框冲突）！如果是异步处理请注意不要和对话框混用。
+
 ### setText：设置剧情文本的属性
 
 使用`{"type": "setText"}`可以设置剧情文本的各项属性。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
-    {"type": "setText", "title": [255,0,0], "text": [255,255,0], "background": [0,0,255,0.3]},
-    {"type": "setText", "position": "up", "bold": true, "time": 70},
-    "这段话将显示在上方，标题为红色，正文为黄色粗体，背景为透明度0.3的蓝色，70毫秒速度打字机效果"
+[
+    {"type": "setText", "title": [255,0,0], "text": [255,255,0], "background": [0,0,255,0.3], "time": 70},
+    {"type": "setText", "position": "up", "offset": 15, "bold": true, "titlefont": 26, "textfont": 17},
+    "这段话将显示在上方（距离顶端15像素），标题为红色，正文为黄色粗体，背景为透明度0.3的蓝色，标题26px，正文17px，70毫秒速度打字机效果",
+    {"type": "setText", "background": "winskin.png"} // 还可以一张使用WindowSkin作为皮肤。
 ]
 ```
 
@@ -305,12 +363,20 @@ title为可选项，如果设置则为一个RGB三元组或RGBA四元组，表
 
 text为可选项，如果设置则为一个RGB三元组或RGBA四元组，表示正文颜色。 默认值：`[255,255,255,1]`
 
-background为可选项，如果设置则为一个RGB三元组或RGBA四元组，表示背景色。 默认值：`[0,0,0,0.85]`
+background为可选项，如果设置可为一个RGB三元组或RGBA四元组，表示背景色。 默认值：`[0,0,0,0.85]`
+
+V2.5.2以后，background也可以为一个WindowSkin的文件名。详见[剧情文本控制与界面皮肤](element#剧情文本控制与界面皮肤)。
 
 position为可选项，表示设置文字显示位置。只能为up（上），center（中）和down（下）三者。 默认值： `center`
 
+offset为可选项，如果设置则为代表距离如果显示位置是上/下的话，距离顶端/底端的像素值。也作为滚动剧情文本时距离左边的像素值。
+
 bold为可选项，如果设置则为true或false，表示正文是否使用粗体。 默认值：`false`
 
+titlefont为可选项，表示标题字体大小（px为单位）。默认值：`22`
+
+textfont为可选项，表示正文字体大小（px为单位）。默认值：`16`
+
 time为可选项，表示文字添加的速度。若此项设置为0将直接全部显示，若大于0则会设置为相邻字符依次显示的时间间隔。 默认值：`0`
 
 ### tip：显示一段提示文字
@@ -318,12 +384,26 @@ time为可选项，表示文字添加的速度。若此项设置为0将直接全
 `{"type": "tip"}`可以在左上角显示一段提示文字。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
-    {"type": "tip", "text": "这段话将在左上角以气泡形式显示"}
+[
+    {"type": "tip", "text": "这段话将在左上角以气泡形式显示", "icon": "book"}
 ]
 ```
 
-值得注意的是，提示的text内容也是可以使用`${ }`来计算表达式的值的。
+text必填，为显示的内容，支持`${}`的表达式计算。
+
+icon是可选的，如果设置则会绘制图标，其可以是一个有效的ID，或者`core.statusBar.icons`中的系统图标。
+
+### comment：添加注释
+
+使用`{"type": "comment"}`可以添加一段注释
+
+``` js
+[
+    {"type": "comment", "text": "这是一段会被跳过的注释内容"}
+]
+```
+
+这个事件将在运行时被游戏跳过。
 
 ### setValue：设置勇士的某个属性、道具个数，或某个变量/Flag的值
 
@@ -332,7 +412,7 @@ time为可选项，表示文字添加的速度。若此项设置为0将直接全
 其大致写法如下：
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type": "setValue", "name": "...", "value": "..."}, // 设置一个属性、道具或自定义Flag
 ]
 ```
@@ -341,10 +421,10 @@ time为可选项，表示文字添加的速度。若此项设置为0将直接全
 
 name为你要修改的属性/道具/Flag，每次只能修改一个值。写法和上面完全相同，`status:xxx` 表示勇士一个属性，`item:xxx` 表示某个道具个数，`flag:xxx` 表示某个变量或flag值。参见上面的介绍。
 
-value是一个表达式，将通过这个表达式计算出的结果赋值给name。该表达式同样可以使用`status:xxx`, `item:xxx`, `flag:xxx`的写法表示勇士当前属性，道具个数和某个变量/Flag值。
+value是一个表达式，将通过这个表达式计算出的结果赋值给name。该表达式同样可以使用`status:xxx`, `item:xxx`, `flag:xxx`, `global:xxx`的写法表示勇士当前属性，道具个数，某个变量/Flag值和某个全局存储值。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type": "setValue", "name": "status:atk", "value": "status:atk+10" } // 攻击提高10点
     {"type": "setValue", "name": "status:money", "value": "1000" } // 将金币数设为1000（不是+1000）
     {"type": "setValue", "name": "status:hp", "value": "status:hp*2" } // 生命值翻倍
@@ -352,11 +432,95 @@ value是一个表达式，将通过这个表达式计算出的结果赋值给nam
     {"type": "setValue", "name": "item:bomb", "value": "item:bomb+10" } // 炸弹个数+10
     {"type": "setValue", "name": "flag:man_times", "value": "0" } // 将变量man_times设为0
     {"type": "setValue", "name": "flag:man_times", "value": "flag:man_times+2*status:atk" } // 将变量man_times的值加上勇士的攻击数值的两倍
+    {"type": "setValue", "name": "global:123", "value": "4"} // 设置全局存储233为4（任何存档都可以读取它）
 ]
 ```
 
 另外注意一点的是，如果hp被设置成了0或以下，将触发lose事件，直接死亡。
 
+### addValue：增减勇士的某个属性、道具个数，或某个变量/Flag的值
+
+和`{"type": "setValue"}`的写法完全相同，不过此项是可以直接将值加减到原始数值上。
+
+即下面的写法是等价的：
+
+``` js
+[
+    {"type": "setValue", "name": "status:atk", "value": "status:atk+10" } // 攻击提高10点
+    {"type": "addVakue", "name": "status:atk", "value": "10" } // 和上面写法等价
+    {"type": "setValue", "name": "item:yellowKey", "value": "item:yellowKey-3" } // 黄钥匙个数-3
+    {"type": "addValue", "name": "item:yellowKey", "value": "-3" } // 和上面写法等价
+    {"type": "setValue", "name": "flag:door2", "value": "flag:door2+1" } // 将变量door值+1
+    {"type": "addValue", "name": "flag:door2", "value": "01" } // 和上面写法等价
+]
+```
+
+### setFloor：设置楼层属性
+
+使用`{"type":"setFloor"}`可以设置某层楼的楼层属性。
+
+``` js
+[
+    {"type": "setFloor", "name": "title", "value": "'主塔 0 层'" } // 设置当前楼层的中文名为主塔0层
+    {"type": "setFloor", "name": "canFlyTo", "floorId": "MT2", "value": "false" } // 设置MT2层不可飞行
+    {"type": "setFloor", "name": "cannotViewMap", "floorId": "MT0", "value": "true" } // 设置MT0层不可被浏览地图
+    {"type": "setFloor", "name": "item_ratio", "value": "5" } // 设置当前楼层的宝石血瓶属性加成为5
+    {"type": "setFloor", "name": "images", "value": "[[0,0,'tree.png',2]]" } // 设置当前楼层的楼层贴图
+    {"type": "setFloor", "name": "upFloor", "value": "[2,3]" } // 设置当前楼层的上楼梯
+    {"type": "setFloor", "name": "bgm", "floorId": "MT10", "value": "'233.mp3'" } // 设置当前楼层的背景音乐
+]
+```
+
+name为必填项，代表要修改的楼层属性，和楼层属性中的一一对应。
+
+floorId为可选项，代表要修改的楼层ID；可以省略代表当前楼层。
+
+value为必填项，代表要修改到的数值。其应该和楼层属性中的对应数值类型完全一致，对于字符串需要加单引号，其他类型（数字、true/false、数组）等则不需要引号。
+
+!> 如果修改到的是字符串类型，比如楼层中文名、状态栏名称、地面素材ID、背景音乐等，必须加引号，否则会报错。
+
+### setGlobalAttribute：设置一个全局属性
+
+使用`{"type":"setGlobalAttribute"}`可以设置一个全局属性。
+
+``` js
+[
+    {"type": "setGlobalAttribute", "name": "font", "value": "Verdana"}, // 设置字体为Verdana
+]
+```
+
+name必填项，代表要修改的全局属性。
+
+value为必填项，代表要修改到的结果。此项无需再手动加单引号。
+
+### setGlobalValue：设置一个全局数值
+
+使用`{"type":"setGlobalValue"}`可以设置一个全局数值。
+
+``` js
+[
+  {"type": "setGlobalValue", "name": "lavaDamage", "value": 200}, // 设置血网伤害为200
+]
+```
+
+name必填项，代表要修改的全局数值，其和全塔属性中的values一一对应。
+
+value为必填项，代表要修改到的结果。该项必须是个数值。
+
+### setGlobalFlag：设置一个系统开关
+
+使用`{"type":"setGlobalFlag"}`可以设置一个系统开关。
+
+``` js
+[
+  {"type": "setGlobalFlag", "name": "enableMDef", "value": false}, // 不在状态栏显示魔防值
+]
+```
+
+name必填项，代表要修改的系统开关，其是全塔属性中的flags中的一部分。
+
+value为必填项，只能为true或false，代表要修改到的结果。
+
 ### show：将一个禁用事件启用
 
 我们上面提到了，所有事件都必须靠其他事件驱动来完成，不存在当某个flag为true时自动执行的说法。那么，我们自然要有启用事件的写法。
@@ -364,11 +528,12 @@ value是一个表达式，将通过这个表达式计算出的结果赋值给nam
 使用`{"type":"show"}`可以将一个本身禁用的事件启用。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
   {"type": "show", "loc": [3,6], "floorId": "MT1", "time": 500}, // 启用MT1层[3,6]位置事件，动画500ms
   {"type": "show", "loc": [3,6], "time": 500}, // 如果启用目标是当前层，则可以省略floorId项
   {"type": "show", "loc": [3,6]}, // 如果不指定动画时间，则立刻显示，否则动画效果逐渐显示，time为动画时间
-  {"type": "show", "loc": [[3,6],[2,9],[1,2]], "time": 500} // 我们也可以同时动画显示多个点。
+  {"type": "show", "loc": [[3,6],[2,9],[1,2]], "time": 500}, // 我们也可以同时动画显示多个点。
+  {"type": "show", "loc": [3,6], "time": 500, "async": true} // 可以使用异步动画效果
 ]
 ```
 
@@ -380,13 +545,15 @@ floorId为目标点的楼层，如果不是该楼层的事件（比如4楼小偷
 
 time为动画效果时间，如果指定了某个大于0的数，则会以动画效果慢慢从无到有显示，动画时间为该数值；如果不指定该选项则无动画直接立刻显示。
 
+async可选，如果为true则会异步执行（即不等待当前事件执行完毕，立刻执行下一个事件）。
+
 !> **要注意的是，调用show事件后只是让该事件从禁用状态变成启用，从不可见不可交互变成可见可交互，但本身不会去执行该点的事件。**
 
 ### hide：将一个启用事件禁用
 
 `{"type":"hide"}`和show刚好相反，它会让一个已经启用的事件被禁用。
 
-其参数和show也完全相同，loc指定事件的位置，floorId为楼层（同层可忽略），time指定的话事件会以动画效果从有到无慢慢消失。
+其参数和show也完全相同，loc指定事件的位置，floorId为楼层（同层可忽略），time指定的话事件会以动画效果从有到无慢慢消失，async代表是否是异步效果。
 
 loc同样可以简单的写[x,y]表示单个点，或二维数组[[x1,y1],[x2,y2],...]表示多个点。
 
@@ -397,14 +564,14 @@ loc同样可以简单的写[x,y]表示单个点，或二维数组[[x1,y1],[x2,y2
 NPC对话事件结束后如果需要NPC消失也需要调用 `{"type": "hide"}`，可以不写loc选项代表当前事件，可以指定time使NPC动画消失。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type": "hide", "loc": [3,6], "floorId": "MT1", "time": 500}, // 禁用MT1层[3,6]位置事件，动画500ms
     {"type": "hide", "loc": [3,6], "time": 500}, // 如果启用目标是当前层，则可以省略floorId项
     {"type": "hide", "loc": [3,6]}, // 如果不指定动画时间，则立刻消失，否则动画效果逐渐消失，time为动画时间
     {"type": "hide", "loc": [[3,6],[2,9],[1,2]], "time": 500}, // 也可以同时指定多个点消失
     {"type": "hide", "time": 500}, // 如果不指定loc选项则默认为当前点， 例如这个就是500ms消失当前对话的NPC
     {"type": "hide"}, // 无动画将当前事件禁用，常常适用于某个空地点（触发陷阱事件、触发机关门这种）
-    
+    {"type": "hide", "loc": [3,6], "time": 500, "async": true} // 可以使用异步动画效果
 ]
 ```
 
@@ -412,30 +579,73 @@ NPC对话事件结束后如果需要NPC消失也需要调用 `{"type": "hide"}`
 
 `{"type":"trigger"}` 会立刻触发当层另一个地点的自定义事件。
 
-上面我们说到，show事件会让一个禁用事件启用且可被交互；但是如果我想立刻让它执行应该怎么办呢？使用trigger就行。
-
 其基本写法如下：
 
 ``` js
-"x,y": [ // 实际执行的事件列表
-    {"type": "trigger", "loc": [3, 6]}, // 立即触发loc位置的事件，当前剩下的事件全部不再执行
-    "执行trigger后，这段文字将不会再被显示"
+[
+    {"type": "trigger", "loc": [3,6]}, // 立即触发loc位置的事件，当前剩下的事件全部不再执行
+    {"type": "trigger", "loc": [3,6], "keep": true}, // 触发loc位置的事件，不结束当前事件
 ]
 ```
 
 其后面带有loc选项，代表另一个地点的坐标。
 
-执行trigger事件后，当前事件将立刻被结束，剩下所有内容被忽略；然后重新启动另一个地点的action事件。
+keep可选，如果此项为true则不会结束当前的事件列表，否则会中断当前的事件流。
 
-例如上面这个例子，下面的文字将不会再被显示，而是直接跳转到`"3,6"`对应的事件列表从头执行。
+从V2.5.4开始允许执行另一个点的系统事件，如打怪开门拾取道具等等，对应点的战后等事件也会被插入执行。
+
+值得注意的是，此事件会**改变当前点坐标**为目标点。
+
+### insert：插入公共事件或另一个地点的事件并执行
+
+`{"type":"insert"}` 会插入公共事件或另一个地点的事件并执行。
+
+其基本写法如下：
+
+``` js
+[
+    {"type": "insert", "name": "加点事件", "args": [10] }, // 插入公共事件：加点事件，传入参数10
+    {"type": "insert", "name": "毒衰咒处理", "args": [0]}, // 插入公共事件：毒衰咒处理，传入参数0
+    {"type": "insert", "loc": [3,6]}, // 插入[3,6]点的事件并执行
+    {"type": "insert", "loc": [10,10], "floorId": "MT1"}, // 插入MT1层[10,10]点的事件并执行
+    {"type": "insert", "loc": [2,2], "args": [1,"flag:abc","status:atk+status:def"]}, // 传入三个参数
+    "上面的插入事件执行完毕后会接着继续执行后面的事件"
+]
+```
+
+`insert`的写法有两种，可以写`name`，或者`loc`。
+
+- 如果写了`"name": "xxx"`，则会去公共事件列表中找寻对应的事件，并执行。
+  - name为公共事件的名称，如果对应公共事件不存在则跳过。
+- 否则，如果写了`"loc": [x,y]`，则会插入另一个地点的事件
+  - loc为另一个地点的坐标
+  - floorId可选，代表另一个地点所在的楼层；如果不写则默认为当前层。
+  - 从V2.6开始，还可以传可选的which，可以为`afterBattle`/`afterGetItem`/`afterOpenDoor`，代表插入该点的战后/获得道具后/开门后事件。
+
+和`type:trigger`不同点如下：
+- `type:trigger`只能指定当前楼层且会改变当前点坐标，`type:insert`可以跨楼层且不会改变当前点坐标。
+- `type:trigger`如果不设置`keep:true`则还会结束当前事件，`type:insert`而是将另一个点的事件插入到当前事件列表中执行。
+- `type:trigger`可以触发系统事件，`type:insert`只能触发该点的自定义事件或战后事件等。
+
+插入的事件执行完毕后，会继续执行接下来的内容。
+
+从V2.6开始，插入事件允许传参。如果需要传参，则需要增加一个`args`数组。
+
+例如： `"args": [1,"flag:abc","status:atk+status:def"]` 传入了三个参数。
+
+系统会自动把`flag:arg1`设置为第一个参数数值，`flag:arg2`设置为第二个参数数值，等等。
+
+（`flag:arg0`则会被置为公共事件名称，或者插入的点的坐标）
+
+即可在事件中直接取用`flag:arg1`等等来获得各项参数值！。
 
 ### revisit：立即重启当前事件
 
 revisit和trigger完全相同，只不过是立刻触发的还是本地点的事件
 
 ``` js
-"x,y": [ // 实际执行的事件列表
-    {"type": "revisit"}, // 立即触发本事件，等价于{"type": "trigger", "loc": [x,y]}
+[
+    {"type": "revisit"}, // 立即触发本事件，等价于 {"type": "trigger", "loc": [x,y]}
     "执行revisit后，这段文字将不会再被显示"
 ]
 ```
@@ -453,7 +663,7 @@ revisit常常使用在一些商人之类的地方，当用户购买物品后不
 例如玩家点击商人的"离开"选项，则可以调用exit返回游戏。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type": "exit" }, // 立即结束事件并恢复游戏，一切列表中的事件都将不再被执行
     "执行exit后，这段文字将不会再被显示"
 ]
@@ -464,10 +674,11 @@ revisit常常使用在一些商人之类的地方，当用户购买物品后不
 我们可以采用 `{"type": "setBlock"}` 来改变某个地图块。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type": "setBlock", "floorId": "MT1", "loc": [3,3], "number": 233}, // 将MT1层的(3,3)点变成数字233
-    {"type": "setBlock", "loc": [2,1], "number": 121}, // 省略floorId则默认为本层
+    {"type": "setBlock", "loc": [2,1],setVa "number": 121}, // 省略floorId则默认为本层
     {"type": "setBlock", "number": 57}, // loc也可省略，默认为当前点
+    {"type": "setBlock", "number": "yellowDoor"}, // 从V2.6开始也允许写图块ID
 ]
 ```
 
@@ -477,6 +688,8 @@ loc为可选的，表示要更改地图块的坐标。如果忽略此项，则
 
 number为**要更改到的数字**，有关“数字”的定义详见参见[素材的机制](personalization#素材的机制)。
 
+从V2.6开始，number也允许写图块的ID，将自动转成对应的数字。
+
 图块更改后：
 
  - 其启用/禁用状态不会发生任何改变。原来是启用还是启用，原来是禁用还是禁用。
@@ -485,12 +698,96 @@ number为**要更改到的数字**，有关“数字”的定义详见参见[素
 
 图块更改往往与[同一个点的多事件处理](#同一个点的多事件处理)相关。
 
+### hideFloorImg：隐藏楼层贴图
+
+使用`{"type":"hideFloorImg"}`可以隐藏某个楼层的贴图。
+
+有关贴图说明请参见[使用自己的图片作为某层楼的背景/前景素材](personalization#使用自己的图片作为某层楼的背景前景素材)。
+
+``` js
+[
+  {"type": "hideFloorImg", "loc": [3,6], "floorId": "MT1"}, // 隐藏[3,6]的贴图
+  {"type": "hideFloorImg", "loc": [3,6]}, // 如果是当前层，则可以省略floorId项
+  {"type": "hideFloorImg", "loc": [[3,6],[2,9],[1,2]]} // 我们也可以同时隐藏多个贴图。
+]
+```
+
+loc为要隐藏的贴图的左上角坐标，可以简单的写[x,y]代表一个点，也可以写个二维数组[[x1,y1],[x2,y2],...]来同时显示多个点。
+
+如果同时存在若干个贴图都是是该坐标为左上角，则这些贴图全部会被隐藏。
+
+floorId为目标点的楼层，如果是当前楼层可以忽略不写。
+
+### showFloorImg：显示楼层贴图
+
+使用`{"type":"showFloorImg"}`可以显示某个楼层的贴图。
+
+其做法和参数，和隐藏贴图是完全一致的。
+
+``` js
+[
+  {"type": "showFloorImg", "loc": [3,6], "floorId": "MT1"}, // 显示[3,6]的贴图
+]
+```
+
+### hideBgFgMap：隐藏楼层的某些背景或前景图块
+
+使用`{"type":"hideBgFgMap"}`可以隐藏某个楼层的背景或前景图块。
+
+从V2.4.1开始，允许绘制三层图层（背景层，事件层和前景层）。使用`hideBgFgMap`可以隐藏背景或前景层中的图块。
+
+``` js
+[
+  {"type": "hideBgFgMap", "name": "bg", "loc": [3,6], "floorId": "MT1"}, // 隐藏MT1层[3,6]的背景层图块
+  {"type": "hideBgFgMap", "name": "bg", "loc": [3,6]}, // 如果是当前层，则可以省略floorId项
+  {"type": "hideBgFgMap", "name": "fg", "loc": [[3,6],[2,9],[1,2]]} // 我们也可以同时隐藏多个贴图。
+]
+```
+
+name为必选的，且只能是`bg`和`fg`之一，分别代表背景图层和前景图层。
+
+loc为要隐藏的贴图的左上角坐标，可以简单的写[x,y]代表一个点，也可以写个二维数组[[x1,y1],[x2,y2],...]来同时显示多个点。
+
+floorId为目标点的楼层，如果是当前楼层可以忽略不写。
+
+### showBgFgMap：显示楼层贴图
+
+使用`{"type":"showFloorImg"}`可以显示某个楼层的贴图。
+
+其做法和参数，和隐藏贴图是完全一致的。
+
+``` js
+[
+  {"type": "showBgFgMap", "name": "bg", "loc": [3,6], "floorId": "MT1"}, // 显示MT1层[3,6]的前景层图块
+]
+```
+
+### setBgFgBlock：设置某个背景或前景层图块
+
+我们可以采用 `{"type": "setBgFgBlock"}` 来改变某个背景或前景层地图块。
+
+``` js
+[
+    {"type": "setBgFgBlock", "name": "bg", "floorId": "MT1", "loc": [3,3], "number": 233}, // 将MT1层背景层的(3,3)点变成数字233
+    {"type": "setBgFgBlock", "name": "bg", "loc": [2,1], "number": 121}, // 省略floorId则默认为本层
+    {"type": "setBgFgBlock", "name": "fg", "number": 57}, // loc也可省略，默认为当前点
+]
+```
+
+name为必选的，且只能是`bg`和`fg`之一，分别代表背景层和前景层。
+
+floorId为可选的，表示要更改的目标楼层。如果忽略此项，则默认为当前楼层。
+
+loc为可选的，表示要更改地图块的坐标。如果忽略此项，则默认为当前事件点。
+
+图块更改后，其隐藏/显示状态不会发生任何改变，即原来是隐藏还是会不显示。可以使用`showBgFgMap`事件将其显示出来。
+
 ### setHeroIcon：更改角色行走图
 
 使用`{"type": "setHeroIcon"}`可以更改角色行走图。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type": "setHeroIcon", "name": "hero2.png"}, // 将勇士行走图改成hero2.png；必须在全塔属性的images中被定义过。
     {"type": "setHeroIcon"}, // 如果不加name则恢复最初默认状态
     {"type": "setValue", "name": "status:name", "value": "'可绒'"}, // 修改勇士名；请注意value必须加单引号。
@@ -509,6 +806,16 @@ name是可选的，代表目标行走图的文件名。
 
 如果你需要刷新状态栏和地图显伤，只需要简单地调用 `{"type": "update"}` 即可。
 
+### hideStatusBar：隐藏状态栏
+
+使用`{"type": "hideStatusBar"}`可以隐藏状态栏。读档或重新开始游戏时，状态栏会重新显示。
+
+可以添加`"toolbox": true`来不隐藏竖屏模式下的工具栏。
+
+### showStatusBar：显示状态栏
+
+使用`{"type": "showStatusBar"}`会重新显示状态栏。
+
 ### updateEnemys：更新怪物数据
 
 使用 `{"type": "updateEnemys"}` 可以动态修改怪物数据。
@@ -522,51 +829,45 @@ name是可选的，代表目标行走图的文件名。
 基本写法：`{"type": "sleep", "time": xxx}` ，其中xxx为指定的毫秒数。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type": "sleep", "time": 1000}, // 等待1000ms
-    "等待1000ms后才开始执行这个事件"
+    "等待1000ms后才开始执行这个事件",
+    {"type": "sleep", "time": 2000, "noSkip": true}, // 等待2000毫秒，且不可被跳过
 ]
 ```
 
+默认的等待事件可以被Ctrl跳过，下面两种情况下不可呗跳过：
+ - 加上`"noSkip": true`后
+ - 当前存在尚未执行完毕的异步事件。
+
 ### battle：强制战斗
 
 调用battle可强制与某怪物进行战斗（而无需去触碰到它）。
 
-例如，《宿命的旋律》中，一区有个骷髅队长，当你拿了它周围三个物品时，就会立刻触发强制战斗事件。这时候就可以用`{"type": "battle"}` 实现。
-
-其基本写法是： `{"type": "battle", "id": xxx}`，其中xxx为怪物ID。
-
 ``` js
-"10,4": [ // 开门后走进去的事件：强制战斗
-    "\t[blackKing]你终于还是来了。",
-    "\t[hero]放开我们的公主！",
-    "\t[blackKing]如果我不愿意呢？",
-    "\t[hero]无需多说，拔剑吧！",
-    {"type": "battle", "id": "blackKing"}, // 强制战斗
-    // 如果战斗失败直接死亡，不会继续触发接下来的剧情。
-    {"type": "hide", "loc": [10,2]}, // 战斗后需要手动使怪物消失；战斗后不会引发afterBattle事件。
-    {"type": "openDoor", "loc": [8,7]}, // 开门口的机关门
-    "\t[blackKing]没想到你已经变得这么强大了... 算你厉害。\n公主就交给你了，请好好对她。",
-    {"type": "hide"} // 隐藏本事件
+[
+    {"type": "battle", "id": "blackKing"}, // 强制战斗黑衣魔王
+    {"type": "battle", "loc": [2,3]}, // 强制战斗(2,3)点的怪物
 ],
 ```
 
-上面就是样板层中右上角的强制战斗例子。
+从V2.6开始，有两种写法：
+- 写id，则视为和空降怪物进行强制战斗，不会执行一些战后事件，也不会隐藏任何点。
+- 写loc（可选，不填默认当前点），则视为和某点怪物进行强制战斗，会隐藏该点并且插入该点战后事件执行。
 
-如果强制战斗失败，则会立刻生命归0并死亡，调用lose函数，接下来的事件不会再被执行。
+强制战斗不会自动存档，如果战斗失败则立刻死亡。
 
-打败怪物后可以进行加点操作。有关加点塔的制作可参见[加点事件](#加点事件)。
-
-强制战斗没有指定loc的选项，因此战斗后需要调用hide使怪物消失（如果有必要）。
+值得注意的是，如果是和某个点的怪物强制战斗，并且该点存在战后事件，执行时会**修改当前点坐标**为目标点。
 
 ### openDoor：开门
 
 调用`{"type":"openDoor"}`可以打开一扇门。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type": "openDoor", "loc": [3,6], "floorId": "MT1"}, // 打开MT1层的[3,6]位置的门
     {"type": "openDoor", "loc": [3,6]}, // 如果是本层则可省略floorId
+    {"type": "openDoor", "loc": [3,6], "needKey": true, "async": true} // 打开此门需要钥匙，异步执行
 ]
 ```
 
@@ -576,6 +877,40 @@ loc指定门的坐标，floorId指定门所在的楼层ID。如果是当前层
 
 如果loc所在的点既不是门也不是墙壁，则忽略本事件。
 
+needKey是可选的，如果设置为true则需要钥匙才能打开此门。如果没有钥匙则跳过此事件。
+
+async可选，如果为true则会异步执行（即不等待当前事件执行完毕，立刻执行下一个事件）。
+
+!> needKey仅对当前楼层开门有效！跨楼层的门仍然不需要钥匙即可打开，如有需求请自行判定。
+
+值得注意的是，如果该点存在开门事件，执行时会**修改当前点坐标**为目标点。
+
+### closeDoor：关门
+
+从V2.6开始提供了关门事件`{"type": "closeDoor"}`，拥有关门动画和对应的音效。
+
+``` js
+[
+    {"type": "closeDoor", "id": "yellowDoor", "loc": [3,6]}, // 给(3,6)点关上黄门
+    {"type": "closeDoor", "id": "specialDoor"}, // 不写loc则视为当前点
+]
+```
+
+id为你要关门的ID，需要是一个合法的门，系统默认只支持如下几种：
+
+```
+yellowDoor, blueDoor, redDoor, greenDoor, specialDoor, steelDoor,
+yellowWall, blueWall, whiteWall
+```
+
+如果需要自己添加门，请参考[新增门和对应的钥匙](personalization#新增门和对应的钥匙)。
+
+loc可选，为要关的位置，不填默认为当前点。
+
+async可选，如果为true则会异步执行（即不等待当前事件执行完毕，立刻执行下一个事件）。
+
+关门事件需要保证该点是空地，否则将无视此事件。
+
 ### changeFloor：楼层切换
 
 在事件中也可以对楼层进行切换。一个比较典型的例子就是TSW中，勇士在三楼的陷阱被扔到了二楼，就是一个楼层切换事件。
@@ -583,7 +918,7 @@ loc指定门的坐标，floorId指定门所在的楼层ID。如果是当前层
 changeFloor的事件写法大致如下。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type": "changeFloor", "floorId": "sample0"，"loc": [10, 10], "direction": "left", "time": 1000 },
     //后面几项依次为楼层id，楼层位置（这两项为必填）；勇士方向可选，切换时间也是可选。
 ]
@@ -599,22 +934,38 @@ time为可选的，指定的话将作为楼层切换动画的时间。
 
 **如果time指定为小于100，则视为没有楼层切换动画。**
 
-!> **changeFloor到达一个新的楼层，将不会执行firstArrive事件！如有需求请在到达点设置自定义事件，然后使用type: trigger立刻调用之。**
-
-### changePos：当前位置切换/勇士转向
+### changePos：当前位置切换/set勇士转向
 
 有时候我们不想要楼层切换的动画效果，而是直接让勇士从A点到B点。
 
 这时候可以用changePos。其参数和changeFloor类似，但少了floorId和time两个选项。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type": "changePos", "loc": [10,10], "direction": "left"}, // 直接切换勇士的坐标，loc为目标地点，后面勇士换位后方向
     {"type": "changePos", "loc", [10,10]}, // 如无需指定方向则direction可省略
     {"type": "changePos", "direction": "left"} // loc也可省略，只指定direction；此时等价于当前勇士转向到某个方向。
 ]
 ```
 
+### useItem：使用道具
+
+调用`{"type": "useItem"}`可以使用一个道具。
+
+``` js
+[
+    {"type": "changePos", "id": "pickaxe"}, // 尝试使用破
+    {"type": "changePos", "id": "bomb"}, // 尝试使用炸
+    {"type": "changePos", "id": "centerFly"} // 尝试使用飞
+]
+```
+
+使用道具事件会消耗对应的道具。
+
+如果当前不可使用该道具（如没有，或者达不到使用条件），则会进行提示并跳过本事件。
+
+不可使用“怪物手册”（请使用【呼出怪物手册】事件）或楼层传送器（如果[覆盖楼传事件](personalization#覆盖楼传事件)则可忽视本项）。
+
 ### openShop：打开一个全局商店
 
 使用openShop可以打开一个全局商店。有关全局商店的说明可参见[全局商店](#全局商店)。
@@ -628,7 +979,7 @@ time为可选的，指定的话将作为楼层切换动画的时间。
 使用 `{"type": "follow"}` 可以让一个npc加入跟随。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type": "follow", "name": "npc.png"}, // 将 npc.png 这个行走图加入跟随
     {"type": "follow", "name": "hero.png"}, // 再将另一个行走图加入跟随
 ]
@@ -643,7 +994,7 @@ name所指定的图片必须存在，在全塔属性中的images中被定义过
 使用 `{"type": "unfollow"}` 来取消一个跟随。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type": "unfollow", "name": "npc.png"}, // 将 npc.png 这个行走图取消跟随
     {"type": "follow"}, // 取消所有跟随
 ]
@@ -655,9 +1006,13 @@ name为可选的，是要取消跟随的行走图文件名。
 
 如果name省略，则会取消所有的跟随效果。
 
-### viberate：画面震动
+### vibrate：画面震动
 
-使用 `{"type": "viberate", "time": 2000}` 可以造成画面震动效果，后面time可以指定震动时间。
+使用 `{"type": "vibrate", "time": 2000, "async": true}` 可以造成画面震动效果。
+
+time可以指定震动时间，默认是2000毫秒。
+
+async可选，如果为true则会异步执行（即不等待当前事件执行完毕，立刻执行下一个事件）。
 
 ### animate：显示动画
 
@@ -666,80 +1021,106 @@ name为可选的，是要取消跟随的行走图文件名。
 有关动画的详细介绍可参见[动画和天气系统](element#动画和天气系统)。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type": "animate", "name": "yongchang", "loc": [1,3]}, // 在(1,3)显示“咏唱魔法”动画
     {"type": "animate", "name": "zone", "loc": "hero"}, // 在勇士位置显示“领域”动画
-    {"type": "animate", "name": "hand"} // 可以不指定loc，则默认为当前事件点
+    {"type": "animate", "name": "hand"}, // 可以不指定loc，则默认为当前事件点
+    {"type": "animate", "async": true}, // 异步，不等待动画绘制完毕
 ]
 ```
 
-name为动画名，**请确保动画在main.js中的this.animates中被定义过。**
+name为动画名，**请确保动画在全塔属性中的animates中被定义过。**
 
 loc为动画的位置，可以是`[x,y]`表示在(x,y)点显示，也可以是字符串`"hero"`表示在勇士点显示。
 
 loc可忽略，如果忽略则显示为事件当前点。
 
-在动画播放结束后才会继续执行下一个事件。
+如果async指定为true，则不会等待动画绘制完毕，立刻执行下个事件。
+
+否则，在动画播放结束后才会继续执行下一个事件。
 
 ### showImage：显示图片
 
 我们可以使用 `{"type": "showImage"}` 来显示一张图片。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
-    {"type": "showImage", "name": "bg.jpg", "loc": [231,297]}, // 在(231,297)显示bg.jpg
-    {"type": "showImage", "name": "1.png", "loc": [109,167]}, // 在(109,167)显示1.png
-    {"type": "showImage"} // 如果不指定name则清除所有图片。
+[
+    {"type": "showImage", "code": 1, "image": "bg.jpg", "loc": [231,297], "opacity": 1, "time" : 0}, // 在(231,297)显示bg.jpg
+    {"type": "showImage", "code": 12, "image": "1.png", "loc": [209,267],  "opacity": 0.5, "time" : 1000}, // 在(209,267)渐变显示1.png，渐变时间为1000毫秒，完成时不透明度为0.5，这张图片将遮盖上一张
+    {"type": "showImage", "code": 8, "image": "hero.png", "loc": [349,367],  "opacity": 1, "time" : 500, "async": true}, // 在(209,267)渐变显示hero.png，渐变时间为500毫秒，异步执行；这张图片将被上一张遮盖
+    {"type": "showImage", "code": 10, "image": "hero.png", "sloc": [100,100,100,100], "loc": [0,0,100,100], "opacity": 1, "time": 0} // 截取原图的一部分绘制到画布上的一部分。
 ]
 ```
 
-name为图片名。**请确保图片在data.js中的images中被定义过。**
+code为图片编号，如果两张图片重叠，编号较大会覆盖编号较小的。该值需要在1~50之间。
 
-loc为图片左上角坐标，以像素为单位进行计算。
+image为图片名。**请确保图片在全塔属性中的images中被定义过。**
 
-如果不指定name则清除所有显示的图片。
+sloc为可选项；如果设置了则是个2或4元组，代表裁剪原始图片的左上角像素位置和宽高。
 
-调用show/hide/move/animate等几个事件同样会清除所有显示的图片。
+loc为2或4元组，代表要绘制的画布上的左上角像素位置和宽高。
 
-### animateImage：图片淡入淡出
+opacity为图片不透明度，在0~1之间，默认值为1，即不透明。
 
-我们还可以使用 `{"type": "animateImage"}` 来造成显示图片的淡入淡出效果。
+time为渐变时间，默认值为0，即不渐变直接显示。
+
+async可选，如果为true则会异步执行（即不等待当前事件执行完毕，立刻执行下一个事件）。
+
+### showTextImage：显示文本化图片
+
+我们可以使用 `{"type": "showTextImage"}` 以图片的方式显示文本。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
-    {"type": "animateImage", "action": "show", "name": "bg.jpg", "loc": [231,297], "time": 500}, // 在(231,297)淡入bg.jpg，动画时间500ms
-    {"type": "animateImage", "action": "hide", "name": "1.png", "loc": [109,167], "time": 300}, // 在(109,167)淡出1.png，动画时间300ms
+[
+    {"type": "showTextImage", "code": 1, "text": "第一排\n第二排\n\n空行后的一排", "loc": [231,297], "opacity": 1, "time" : 0}, // 在(231,297)显示"第一排\n第二排\n\n空行后的一排"
 ]
 ```
 
-action为淡入还是淡出，`show`为淡入，`hide`会淡出。
+code为图片编号，如果两张图片重叠，编号较大会覆盖编号较小的。该值需要在1~50之间。
 
-name为图片名。**请确保图片在data.js中的images中被定义过。**
+text为要显示的文本。默认行宽为416。
 
 loc为图片左上角坐标，以像素为单位进行计算。
 
-time为淡入淡出的时间，如果是0则忽略此项。
+opacity为图片不透明度，在0~1之间，默认值为1，即不透明。
 
-!> 淡入淡出图片只是会在顶层绘制“淡入”和“淡出”效果，动画结束即消失，并不会实际对图片的显示造成影响。请与showImage事件合用。
+lineHeight为可选项，代表行距。默认为1.4。
 
-如果多张图片的淡入淡出可以采用以下方式（仅供参考）：
+time为渐变时间，默认值为0，即不渐变直接显示。
 
-假设我现在已经有了`1.jpg`显示在屏幕上：
-- 淡入显示`2.png`：调用`animateImage`淡入图片，然后立刻调用`showImage`显示图片。
-- 淡出`1.png`：清除所有图片，`showImage`显示`2.png`，然后调用`animateImage`淡出`1.jpg`
+async可选，如果为true则会异步执行（即不等待当前事件执行完毕，立刻执行下一个事件）。
+
+文本通过图片的方式显示后，即视为一张正常图片，可以被清除或者移动。
+
+### hideImage：清除图片
+
+我们可以使用 `{"type": "hideImage"}` 来清除一张图片。
+
+``` js
+[
+    {"type": "hideImage", "code": 1, "time" : 0}, // 使1号图片消失
+    {"type": "hideImage", "code": 12, "time" : 1000}, // 使12号图片渐变消失，时间为1000毫秒
+]
+```
+
+time为渐变时间，默认值为0，即不渐变直接消除。
+
+code为显示图片时输入的图片编号。
+
+async可选，如果为true则会异步执行（即不等待当前事件执行完毕，立刻执行下一个事件）。
 
 ### showGif：显示动图
 
 我们可以使用 `{"type": "showGif"}` 来显示一张图片。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type": "showGif", "name": "timg.gif", "loc": [231,297]}, // 在(231,297)显示一张动图
     {"type": "showGif"} // 如果不指定name则清除所有动图。
 ]
 ```
 
-name为图片名。**请确保图片在data.js中的images中被定义过。**
+name为图片名。**请确保图片在全塔属性中的images中被定义过。**
 
 loc为动图左上角坐标，以像素为单位进行计算。
 
@@ -747,33 +1128,35 @@ loc为动图左上角坐标，以像素为单位进行计算。
 
 ### moveImage：图片移动
 
-我们可以使用 `{"type": "moveImage"}` 来造成图片移动效果。
+我们可以使用 `{"type": "moveImage"}` 来造成图片移动，淡入淡出等效果。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
-    {"type": "moveImage", "name": "bg.jpg", "from": [231,297], "to": [22,333], "time": 500},
+[
+    {"type": "moveImage", "code": 1, "to": [22,333], "opacity": 1, "time": 1000}, // 将1号图片移动到(22,333)，动画时间为1000ms
+    {"type": "moveImage", "code": 12, "opacity": 0.5, "time": 500}, // 将二号图片的透明度变为0.5，动画时间500ms
+    {"type": "moveImage", "code": 1, "to": [109,167], "opacity": 0, "time": 300, "async": true}, // 将1号图片移动到(109,167)，透明度设为0（不可见），动画时间300ms，异步执行
 ]
 ```
 
-name为图片名。**请确保图片在data.js中的images中被定义过。**
+code为图片编号。该值需要在1~50之间。
 
-from为起点图片左上角坐标，以像素为单位进行计算。
+to为终点图片左上角坐标，以像素为单位进行计算，不填写则视为当前图片位置。
 
-to为终点图片左上角坐标，以像素为单位进行计算。
+opacity为完成时图片不透明度，移动过程中逐渐变化。在0~1之间。
 
 time为总移动的时间。
 
-!> 移动图片只是会在顶层绘制“移动”效果，动画结束即消失，并不会实际对图片的显示造成影响。请与showImage事件合用。
+async可选，如果为true则会异步执行（即不等待当前事件执行完毕，立刻执行下一个事件）。
 
-### setFg：更改画面色调
+### setCurtain：更改画面色调
 
-我们可以使用 `{"type": "setFg"}` 来更改画面色调。
+我们可以使用 `{"type": "setCurtain"}` 来更改画面色调。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
-    {"type": "setFg", "color": [255,255,255,0.6], "time": 1000}, // 更改画面色调为纯白，不透明度0.6，动画时间1000毫秒
-    {"type": "setFg", "color": [0,0,0]}, // 更改画面色调为纯黑，不透明度1，不指定动画时间（使用默认时间）
-    {"type": "setFg"} // 如果不指定color则恢复原样。
+[
+    {"type": "setCurtain", "color": [255,255,255,0.6], "time": 1000}, // 更改画面色调为纯白，不透明度0.6，动画时间1000毫秒
+    {"type": "setCurtain", "color": [0,0,0], "async": true}, // 更改画面色调为纯黑，不透明度1，不指定动画时间（使用默认时间），且异步执行
+    {"type": "setCurtain"} // 如果不指定color则恢复原样。
 ]
 ```
 
@@ -785,12 +1168,35 @@ color为需要更改画面色调的颜色。它是一个数组，分别指定目
 
 time为可选的，如果指定，则会作为更改画面色调的时间。
 
+async可选，如果为true则会异步执行（即不等待当前事件执行完毕，立刻执行下一个事件）。
+
+### screenFlash：画面闪烁
+
+我们可以使用 `{"type": "screenFlash"}` 来进行画面闪烁。
+
+``` js
+[
+    {"type": "screenFlash", "color": [255,255,255,0.6], "time": 500, "times": 1}, // 闪光为白色，不透明度0.6，动画时间1000毫秒
+    {"type": "screenFlash", "color": [255,0,0,1], "time": 100, "times": 2, "async": true}, // 闪光为红色，强度最大，动画时间100毫秒，闪烁两次且异步执行
+]
+```
+
+color为闪光的颜色。它是一个数组，分别指定目标颜色的R,G,B,A值。
+- 常见RGB颜色： 纯黑[0,0,0]，纯白[255,255,255]，纯红[255,0,0]，等等。
+A即闪光的不透明度，为一个0到1之间的数，值越高闪烁效果越强。默认为1
+
+time为闪烁时间，默认值为500
+
+times为闪烁次数，两次闪烁会连续进行，默认值为1
+
+async可选，如果为true则会异步执行（即不等待当前事件执行完毕，立刻执行下一个事件）。
+
 ### setWeather：更改天气
 
 我们可以使用 `{"type": "setWeather"}` 来更改天气。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type": "setWeather", "name": "rain", "level": 6}, // 更改为雨天，强度为6级
     {"type": "setWeather", "name": "snow", "level": 3}, // 更改为雪天，强度为3级
     {"type": "setWeather"} // 更改回晴天
@@ -799,6 +1205,8 @@ time为可选的，如果指定，则会作为更改画面色调的时间。
 
 name为天气选项。目前只支持`rain`和`snow`，即雨天和雪天。
 
+从V2.5.3开始，也支持雾天`fog`。
+
 level为天气的强度等级，在1-10之间。1级为最弱，10级为最强。
 
 如果想改回晴天则直接不加任何参数。
@@ -812,11 +1220,10 @@ level为天气的强度等级，在1-10之间。1级为最弱，10级为最强
 下面是该事件常见的写法：
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type": "move", "time": 750, "loc": [x,y], "steps": [// 动画效果，time为移动速度(比如这里每750ms一步)，loc为位置可选，steps为移动数组
-        {"direction": "right", "value": 2},// 这里steps 的效果为向右移动2步，在向下移动一步并消失
-        "down" // 如果该方向上只移动一步则可以这样简写，效果等价于上面value为1
-    ], "keep": true }, // keep可选，如果为true则不消失，否则渐变消失
+        "right", "right", "down" // 向右两格，向下一格
+    ], "keep": true, "async":true }, // keep可选，如果为true则不消失，否则渐变消失；async可选，如果为true则异步执行。
 ]
 ```
 
@@ -824,9 +1231,7 @@ time选项必须指定，为每移动一步所需要用到的时间。
 
 loc为需要移动的事件位置。可以省略，如果省略则移动本事件。
 
-steps为一个数组，其每一项为一个 `{"direction" : xxx, "value": n}`，表示该步是向xxx方向移动n步。
-
-如果只移动一步可以直接简单的写方向字符串（`up/left/down/right`）。
+steps为一个数组，其每一项是`up, down, left, right`之一，表示这一步应该朝哪个方向走。
 
 keep为一个可选项，代表该事件移动完毕后是否消失。如果该项指定了并为true，则移动完毕后将不消失，否则以动画效果消失。
 
@@ -841,7 +1246,7 @@ keep为一个可选项，代表该事件移动完毕后是否消失。如果该
 ``` js
 "4,3": [ // [4,3]是一个NPC，比如小偷
     {"type": "move", "time": 750, "steps": [ // 向上移动两格，每步750毫秒
-        {"direction": "up", "value": 2},
+        "up", "up"
     ], "keep": true}, // 移动完毕后不消失
 ],
 "4,1": { // [4,1]为目标地点
@@ -852,7 +1257,9 @@ keep为一个可选项，代表该事件移动完毕后是否消失。如果该
 }
 ```
 
-即，在移动的到达点指定一个初始禁用的相同NPC，然后move事件中指定immediateHide使立刻消失，并show该到达点坐标使其立刻显示（看起来就像没有消失），然后就可以触发目标点的事件了。
+即，在移动的到达点指定一个事件，然后move事件中指定"keep":true，然后就可以触发目标点的事件了。
+
+async可选，如果为true则会异步执行（即不等待当前事件执行完毕，立刻执行下一个事件）。
 
 ### moveHero：移动勇士
 
@@ -862,17 +1269,20 @@ keep为一个可选项，代表该事件移动完毕后是否消失。如果该
 
 ``` js
 "x,y": [ // 实际执行的事件列表
-    {"type": "moveHero", "time": 750, "steps": [// 动画效果，time为移动速度(比如这里每750ms一步)，steps为移动数组
-        {"direction": "right", "value": 2},// 这里steps 的效果为向右移动2步，在向下移动一步并消失
-        "down" // 如果该方向上只移动一步则可以这样简写，效果等价于上面value为1
+    {"type": "moveHero", "time": 750, "async": true, "steps": [// 动画效果，time为移动速度(比如这里每750ms一步)，steps为移动数组
+        "down", "right", "forward", "backward" // 向下、右、前、后各走一步
     ]},
 ]
 ```
 
-可以看到，和上面的move事件几乎完全相同，除了不能指定loc，且少了immediateHide选项。
+可以看到，和上面的move事件几乎完全相同，除了不能指定loc，且少了keep选项。
+
+勇士的steps也允许`forward`和`backward`，即前进和后退。
 
 不过值得注意的是，用这种方式移动勇士的过程中将无视一切地形，无视一切事件，中毒状态也不会扣血。
 
+async可选，如果为true则会异步执行（即不等待当前事件执行完毕，立刻执行下一个事件）。
+
 ### jump：让某个NPC/怪物跳跃
 
 如果我们需要移动某个NPC或怪物，可以使用`{"type": "jump"}`。
@@ -880,8 +1290,8 @@ keep为一个可选项，代表该事件移动完毕后是否消失。如果该
 下面是该事件常见的写法：
 
 ``` js
-"x,y": [ // 实际执行的事件列表
-    {"type": "jump", "from": [3,6], "to": [2,1], "time": 750, "keep": true},
+[
+    {"type": "jump", "from": [3,6], "to": [2,1], "time": 750, "keep": true, "async": true},
 ]
 ```
 
@@ -895,6 +1305,8 @@ keep为一个可选项，同上代表该跳跃完毕后是否不消失。如果
 
 如果指定了`"keep": true`，则相当于会在目标地点触发一个`setBlock`事件；如需能继续对话交互请在目标地点再写事件。
 
+async可选，如果为true则会异步执行（即不等待当前事件执行完毕，立刻执行下一个事件）。
+
 ### jumpHero：跳跃勇士
 
 如果我们需要跳跃勇士，可以使用`{"type": "jumpHero"}`。
@@ -902,8 +1314,8 @@ keep为一个可选项，同上代表该跳跃完毕后是否不消失。如果
 下面是该事件常见的写法：
 
 ``` js
-"x,y": [ // 实际执行的事件列表
-    {"type": "jump", "loc": [3,6], "time": 750},
+[
+    {"type": "jump", "loc": [3,6], "time": 750, "async": true},
 ]
 ```
 
@@ -911,6 +1323,8 @@ loc为目标坐标，可以忽略表示原地跳跃（请注意是原地跳跃
 
 time选项为该跳跃所需要用到的时间。
 
+async可选，如果为true则会异步执行（即不等待当前事件执行完毕，立刻执行下一个事件）。
+
 ### playBgm：播放背景音乐
 
 使用playBgm可以播放一个背景音乐。
@@ -919,7 +1333,7 @@ time选项为该跳跃所需要用到的时间。
 
 值得注意的是，额外添加进文件的背景音乐，需在main.js中this.bgms里加载它。
 
-目前支持mp3/ogg/wav/mid等多种格式的音乐播放。
+目前支持mp3/ogg/wav等多种格式的音乐播放。
 
 有关BGM播放的详细说明参见[背景音乐](element#背景音乐)
 
@@ -931,6 +1345,20 @@ time选项为该跳跃所需要用到的时间。
 
 使用`{"type": "resumeBgm"}`可以恢复背景音乐的播放。
 
+### loadBgm：预加载一个背景音乐
+
+使用loadBgm可以预加载一个背景音乐。
+
+使用方法：`{"type": "loadBgm", "name": "bgm.mp3"}`
+
+有关BGM播放的详细说明参见[背景音乐](element#背景音乐)
+
+### freeBgm：释放一个背景音乐的缓存
+
+使用freeBgm可以预加载一个背景音乐。
+
+使用方法：`{"type": "freeBgm", "name": "bgm.mp3"}`
+
 ### playSound：播放音效
 
 使用playSound可以立刻播放一个音效。
@@ -939,22 +1367,34 @@ time选项为该跳跃所需要用到的时间。
 
 值得注意的是，如果是额外添加进文件的音效，则需在main.js中this.sounds里加载它。
 
+从V2.6开始，也可以加`"stop": true`来停止之前正在播放的音效。
+
+### stopSound：停止所有音效
+
+使用`{"type": "stopSound"}`可以停止所有音效。
+
+这在人物对话音效时很有用。
+
 ### setVolume：设置音量
 
 使用setVolume可以设置音量大小。
 
-使用方法： `{"type": "setVolume", "value": 90, "time": 500}`
+使用方法： `{"type": "setVolume", "value": 90, "time": 500, "async": true}`
 
-value为音量大小，在0到100之间，默认为100。设置后，BGM和SE都将使用该音量进行播放。
+value为音量大小，在0到100之间，默认为100。设置后，BGM将使用该音量进行播放。SE的音量大小不会发生改变。
 
 可以设置time为音量渐变时间。
 
+async可选，如果为true则会异步执行（即不等待当前事件执行完毕，立刻执行下一个事件）。
+
 ### win：获得胜利
 
 `{"type": "win", "reason": "xxx"}` 将会直接调用events.js中的win函数，并将reason作为结局传入。
 
 该事件会显示获胜页面，并重新游戏。
 
+可以增加`"norank": 1`来表示该结局不计入榜单。
+
 !> 如果`reason`不为空，则会以reason作为获胜的结局!
 
 ### lose：游戏失败
@@ -963,13 +1403,39 @@ value为音量大小，在0到100之间，默认为100。设置后，BGM和SE都
 
 该事件会显示失败页面，并重新开始游戏。
 
-### input：接受用户输入
+### restart：直接回到标题界面
 
-使用`{"type": "input"}`可以接受用户的输入。
+`{"type": "restart"}` 会中断一切执行的事件，并直接直接返回标题界面。
+
+### callBook：呼出怪物手册
+
+`{"type": "callBook"}` 可以呼出怪物手册，玩家可以自由查看当前楼层怪物数据和详细信息。
+
+返回游戏后将继续执行后面的事件。没有怪物手册或在录像播放中，则会跳过本事件。
+
+### callSave：呼出存档界面
+
+`{"type": "callSave"}` 可以呼出存档页面并允许玩家存一次档。
+
+在玩家进行一次存档，或者直接点返回游戏后，将接着执行后面的事件。录像播放将会跳过本事件。
+
+### autoSave：自动存档
+
+`{"type": "autoSave"}` 可以立刻进行一次自动存档。录像播放不会跳过本事件。
+
+### callLoad：呼出读档界面
+
+`{"type": "callLoad"}` 可以呼出读档页面并允许玩家进行读档。
+
+如果玩家没有进行读档而是直接返回游戏，则会继续执行后面的事件。录像播放将会跳过本事件。
+
+### input：接受用户输入数字
+
+使用`{"type": "input"}`可以接受用户的输入的数字。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
-    {"type": "input", "text": "请输入一个数"}, // 显示一个弹窗让用户输入内容
+[
+    {"type": "input", "text": "请输入一个数"}, // 显示一个弹窗让用户输入数字
     "你刚刚输入的数是${flag:input}" // 输入结果将被赋值为flag:input
 ]
 ```
@@ -982,6 +1448,25 @@ text为提示文字，可以在这里给输入提示文字。这里同样可以
 
 输入得到的结果将被赋值给flag:input，可以供后续if来进行判断。
 
+### input2：接受用户输入文本
+
+类似于input事件，使用`{"type": "input2"}`可以接受用户的输入的文本。
+
+``` js
+[
+    {"type": "input2", "text": "请输入你的ID"}, // 显示一个弹窗让用户输入文本
+    "你好，${flag:input}，欢迎来到本塔" // 输入结果将被赋值为flag:input
+]
+```
+
+text为提示文字，可以在这里给输入提示文字。这里同样可以使用${ }来计算表达式的值。
+
+当执行input2事件时，将显示一个弹窗，并提示用户输入一个内容。
+
+该事件可以接收任何形式的文本输入，包括中文，空格，标点符号等等。如果用户点击取消按钮，则视为空字符串。
+
+输入得到的结果也将被赋值给flag:input，可以供后续使用。
+
 ### if：条件判断
 
 使用`{"type": "if"}`可以对条件进行判断，根据判断结果将会选择不同的分支执行。
@@ -989,7 +1474,7 @@ text为提示文字，可以在这里给输入提示文字。这里同样可以
 其大致写法如下：
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type": "if", "condition": "...", // 测试某个条件
         "true": [ // 条件成立则执行true里面的事件
             
@@ -1010,7 +1495,7 @@ text为提示文字，可以在这里给输入提示文字。这里同样可以
 例如下面这个例子，每次将检查你的攻击力是否大于500，不是的场合将给你的攻击力加100点。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type": "if", "condition": "status:atk>500", // 判断攻击力是否大于500
         "true": [ // 条件成立则执行true里面的事件
             "你的攻击力已经大于500了！",
@@ -1018,7 +1503,7 @@ text为提示文字，可以在这里给输入提示文字。这里同样可以
         ],
         "false": [ // 条件不成立则执行false里的事件
             "你当前攻击力为${status:atk}, 不足500！\n给你增加100点攻击力！",
-            {"type": "setValue", "name": "status:atk", "value": "status:atk+100"}, // 攻击力加100， 接着会执行revisit事件
+            {"type": "addValue", "name": "status:atk", "value": "100"}, // 攻击力加100， 接着会执行revisit事件
         ]
     },
     {"type", "revisit"}, // 立刻重启本事件， 直到攻击力大于500后结束
@@ -1028,11 +1513,97 @@ text为提示文字，可以在这里给输入提示文字。这里同样可以
 需要额外注意的几点：
 
 - 给定的表达式（condition）一般需要返回true或false。
-- `flag:xxx` 可取用一个自定义变量或flag。如果从未设置过该flag，则其值默认为false。而JS中，`false==0`这个判断是成立的，因此我们可以简单使用 `"flag:npc_times==0"` 来判断某个NPC是否被访问过。
+- `flag:xxx` 可取用一个自定义变量或flag。如果从未设置过该flag，则其值默认为0。
 - 即使成功失败的场合不执行事件，对应的true或false数组也需要存在，不过简单的留空就好。
 - if可以不断进行嵌套，一层套一层；如成立的场合再进行另一个if判断等。
 - if语句内的内容执行完毕后将接着其后面的语句继续执行。
 
+
+### switch：多重条件分歧
+
+使用`{"type": "switch"}`可以比较判别值和不同分支的条件，根据判断结果选择不同的分支执行。
+
+其大致写法如下：
+
+``` js
+[
+    {"type": "switch", "condition": "...", // 计算某个表达式
+        "caseList": [
+            {"case": "a", "action": [// 若表达式的值等于a则执行该处事件
+            
+            ],
+            {"case": "b", "nobreak": true, "action": [// 若表达式的值等于b则执行该处事件，不跳出
+            
+            ],
+            {"case": "default", "action": [ // 没有条件成立则执行该处里的事件
+
+            ]
+        ]
+    },
+]
+```
+
+我们可以在condition中给出一个表达式（能将`status:xxx`, `item:xxx`, `flag:xxx`来作为参数），并计算它的值
+
+如果某条件中的值与其相等，则将执行其对应的列表事件内容。
+
+如果没有符合的值，则将执行`default`中的列表事件内容。
+
+nobreak是可选的，如果设置，则在当前条件满足并插入事件后，不跳出多重分歧，而是继续判定下一个条件。
+
+例如下面这个例子，将检查当前游戏难度并赠送不同属性。
+
+``` js
+[
+    {"type": "switch", "condition": "flag:hard", // 判断当前游戏难度
+         "caseList": [
+            {"case": "0", "action": [// 若表达式的值等于0则执行该处事件
+                "当前为简单难度，赠送100点攻防！",
+                {"type": "setValue", "name": "status:atk", "value": "status:atk+100"},
+                {"type": "setValue", "name": "status:def", "value": "status:def+100"},
+            ],
+            {"case": "1", "action": [// 若表达式的值等于1则执行该处事件
+                "当前为普通难度，赠送50点攻防！",
+                {"type": "setValue", "name": "status:atk", "value": "status:atk+50"},
+                {"type": "setValue", "name": "status:def", "value": "status:def+50"},
+            ],
+            {"case": "default", "action": [ // 其他难度下不赠送属性
+
+            ]
+        ]
+    },
+]
+```
+
+需要额外注意的几点：
+
+- 各个条件分支的判断是顺序执行的，因此若多个分支的条件都满足，将只执行最靠前的分支。
+  - 同理，请不要在`default`分支后添加分支，这些分支将不可能被执行。
+- `default`分支并不是必要的，如果删除，则在没有满足条件的分支时将不执行任何事件。
+- 即使某个场合不执行事件，对应的action数组也需要存在，不过简单的留空就好。
+- switch语句内的内容执行完毕后将接着其后面的语句继续执行。
+
+另外由于`case`中的内容是会被计算的，因此如下写法也是合法的
+
+```js
+[
+    {"type": "switch", "condition": "true", // 条件：某一项为真时
+         "caseList": [
+            {"case": "flag:a==1", "action": [ // 如果 flag:a == 1
+                "走进了 flag:a==1 分支！"
+            ],
+            {"case": "flag:b>=3", "action": [ // 如果 flag:b >= 3
+                "走进了 flag:b>=3 分支！"
+            ],
+            {"case": "default", "action": [ // 上述两条均布成立
+                "上述两条均不成立"
+            ]
+        ]
+    },
+]
+```
+
+
 ### choices：给用户提供选项
 
 choices是一个很麻烦的事件，它将弹出一个列表供用户进行选择。
@@ -1044,16 +1615,16 @@ choices是一个很麻烦的事件，它将弹出一个列表供用户进行选
 其大致写法如下：
 
 ``` js
-"x,y": [ // 实际执行的事件列表
-    {"type": "choices", "text": "...", // 提示文字
+[
+    {"type": "choices", "text": "...",  // 提示文字
         "choices": [
             {"text": "选项1文字", "action": [
                     // 选项1执行的事件
             ]},
-            {"text": "选项2文字", "action": [
+            {"text": "选项2文字", "color": [255,0,0,1], "action": [
                     // 选项2执行的事件
             ]},
-            {"text": "选项3文字", "action": [
+            {"text": "选项3文字", "icon": "fly", "action": [
                     // 选项3执行的事件
             ]},
         ]
@@ -1061,81 +1632,54 @@ choices是一个很麻烦的事件，它将弹出一个列表供用户进行选
 ]
 ```
 
-其中最外面的"text"为提示文本。同上面的`"type":"text"`一样，支持`${}`表达式的计算，和\t显示名称、图标。text可省略，如果省略将不显示任何提示文字。
+其中最外面的"text"为提示文本。同上面的`"type":"text"`一样，支持`${}`表达式的计算，和\t显示名称、图标，\r更改颜色。text可省略，如果省略将不显示任何提示文字。
 
 choices为一个数组，其中每一项都是一个选项列表。
 
-每一项的text为显示在屏幕上的选项名，也支持${}的表达式计算，但不支持`\t[]`的显示。action为当用户选择了该选项时将执行的事件。
+每一项的text为显示在屏幕上的选项名，也支持${}的表达式计算，但不支持`\t[]`的显示。
+
+action为当用户选择了该选项时将执行的事件。
+
+color为可选的，可以是一个字符串（#FF0000），或者一个RGBA数组（[255,0,0,1]）。
+
+icon是可选的，如果设置则会在选项前绘制图标，其可以是一个有效的ID，或者`core.statusBar.icons`中的系统图标。
 
 选项可以有任意多个，但一般不要超过6个，否则屏幕可能塞不下。
 
-下面是一个卖钥匙的事件，是一个比较复杂却也较为典型的if和choices合并使用的样例。
+### confirm：显示确认框
 
-``` js
-"10,11": [ // 商人事件，if语句和choices语句的写法
-    // 这部分逻辑相对比较长，细心看，很容易看懂的。
-    {"type": "if", "condition": "flag:woman_times==0", // 条件判断：是否从未访问过此商人。
-        "true": [ // 如果从未访问过该商人，显示一段文字
-            "\t[老人,woman]这是个很复杂的例子，它将教会你如何使用if 语句进行条件判断，以及 choices 提供选项来供用户进行选择。",
-            "\t[老人,woman]第一次访问我将显示这段文字；从第二次开始将会向你出售钥匙。\n钥匙价格将随着访问次数递增。\n当合计出售了七把钥匙后，将送你一把大黄门钥匙，并消失不再出现。",
-            "\t[老人,woman]这部分的逻辑比较长，请细心看样板的写法，是很容易看懂并理解的。"
-            // 第一次访问结束
+`{"type": "confirm"}`将提供一个确认框供用户选择，其基本写法如下：
+
+```js
+[
+    {"type": "confirm", "text": "...",  // 提示文字
+        "default": false, // 是否默认选中【确定】
+        "yes": [
+            // 点击确定时执行的事件
         ],
-        "false": [ // 如果已经访问过该商人
-            {"type": "if", "condition": "flag:woman_times==8", // 条件判断：是否已经出售七把钥匙
-                "true": [ // 如果已经出售过七把钥匙，则直接结束
-                    "\t[老人,woman]你购买的钥匙已经够多了，再继续卖给你的话我会有危险的。",
-                    "\t[老人,woman]看在你贡献给我这么多钱的份上，送你一把大黄门钥匙吧，希望你能好好用它。",
-                    {"type": "setValue", "name": "item:bigKey", "value": "item:bigKey+1"}, // 获得一把大黄门钥匙
-                    "\t[老人,woman]我先走了，拜拜~",
-                    {"type":"hide", "time": 500}, // 消失
-                    {"type":"exit"} // 立刻结束当前事件。下面的 setValue 和 revisit 都不会再执行。
-                ],
-                "false": [ // 否则，显示选择页面
-                    {"type": "choices", "text": "\t[老人,woman]少年，你需要钥匙吗？\n我这里有大把的！", // 显示一个卖钥匙的选择页面
-                        "choices": [ // 提供四个选项：黄钥匙、蓝钥匙、红钥匙、离开。前三个选项显示需要的金额
-                            {"text": "黄钥匙（${9+flag:woman_times}金币）", "action": [ // 第一个选项，黄钥匙
-                                // 选择该选项的执行内容
-                                {"type": "if", "condition": "status:money>=9+flag:woman_times", // 条件判断：钱够不够
-                                    "true": [
-                                        {"type": "setValue", "name": "status:money", "value": "status:money-(9+flag:woman_times)"}, // 扣减金钱
-                                        {"type": "setValue", "name": "item:yellowKey", "value": "item:yellowKey+1"}, // 增加黄钥匙
-                                        // 然后会继续执行下面的setValue来增加商人访问次数
-                                    ],
-                                    "false": [
-                                        "\t[老人,woman]你的金钱不足！",
-                                        {"type": "revisit"} // 直接重新访问；不执行下面的setValue来增加访问次数
-                                    ]
-                                }
-                            ]},
-                            {"text": "蓝钥匙（${18+2*flag:woman_times}金币）", "action": [ // 第二个选项：蓝钥匙
-                                // 逻辑和上面黄钥匙完全相同，略
-                            ]},
-                            {"text": "红钥匙（${36+4*flag:woman_times}金币）", "action": [ // 第三个选项：红钥匙
-                                // 逻辑和上面黄钥匙完全相同，略
-                            ]},
-                            {"text": "离开", "action": [ // 第四个选项：离开
-                                {"type": "exit"} // 立刻结束当前事件
-                            ]}
-                        ]
-                    }
-                ]
-            }
+        "no": [
+            // 点击取消时执行的事件
         ]
     },
-    {"type": "setValue", "name": "flag:woman_times", "value": "flag:woman_times+1"}, // 增加该商人的访问次数。
-    {"type": "revisit"} // 立即重新开始这个事件
-],
+]
 ```
 
-### while：循环处理
+text为必填项，代表提示的文字，支持${}的表达式计算和\n的手动换行。
+
+text暂时不支持自动换行、变色\r、图标绘制\i等效果。如有需求请使用choices事件。
+
+default可选，如果为true则显示选择项时默认选中【确定】，否则默认选中【取消】。
+
+yes和no均为必填项，即用户点击确认或取消后执行的事件。
+
+### while：前置条件循环
 
 从2.2.1样板开始，我们提供了循环处理（while事件）。
 
 其大致写法如下：
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type": "while", "condition": "...", // 循环测试某个条件
         "data": [ // 条件成立则执行data里面的事件
             
@@ -1153,10 +1697,10 @@ choices为一个数组，其中每一项都是一个选项列表。
 下面是一个输出1到10之间的数字，每隔1秒显示一个的例子。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type":"while", "condition": "flag:i<=10", // 循环处理；注意flag未设置则默认为0
         "data":[
-            {"type": "setValue", "name": "flag:i", "value": "flag:i+1"}, // 递增i
+            {"type": "addValue", "name": "flag:i", "value": "1"}, // 递增i
             "${flag:i}", // 输出i
             {"type": "sleep","time":1000}, // 等待1秒
         ]
@@ -1164,6 +1708,12 @@ choices为一个数组，其中每一项都是一个选项列表。
 ]
 ```
 
+### dowhile：后置条件循环
+
+`type:dowhile`可以制作一个后置条件循环。
+
+其写法与参数和`type:while`完全一致，不过与其不同的是，会先执行一次事件列表，再对条件进行判定，就和C/C++中的 `do {...} while (...);` 语法一样。
+
 ### break：跳出循环
 
 使用 `{"type": "break"}` 可以跳出当前循环。
@@ -1177,10 +1727,10 @@ choices为一个数组，其中每一项都是一个选项列表。
 上面的输出例子也可以这么写：
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type":"while", "condition": "true", // 循环处理；永远为真
         "data":[
-            {"type": "setValue", "name": "flag:i", "value": "flag:i+1"}, // 递增i
+            {"type": "addValue", "name": "flag:i", "value": "1"}, // 递增i
             "${flag:i}", // 输出i
             {"type": "sleep","time":1000}, // 等待1秒
             {"type": "if", "condition": "flag:i<10", // 测试i是否小于10
@@ -1200,15 +1750,14 @@ choices为一个数组，其中每一项都是一个选项列表。
 使用 `{"type": "wait"}` 可以等待用户进行操作（如点击、按键等）。
 
 当用户执行操作后：
-- 如果是键盘的按键操作，则会将flag:type置为0，并且把flag:keycode置为刚刚按键的keycode。
-- 如果是屏幕的点击操作，则会将flag:type置为1，并且设置flag:x和flag:y为刚刚的点击坐标。
+- 如果是键盘的按键操作，则会将flag:type置为0，并且把flag:keycode置为按键的keycode。
+- 如果是屏幕的点击操作，则会将flag:type置为1，并且设置flag:x和flag:y为点击的位置坐标，flag:px和flag:py为点击的像素坐标。
 
 下面是一个while事件和wait合并使用的例子，这个例子将不断接收用户的点击或按键行为，并输出该信息。
 如果用户按下了ESC或者点击了屏幕正中心，则退出循环。
 
-
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type": "while", "condition": "true", // 永久循环
         "data": [
             {"type": "wait"}, // 等待用户操作
@@ -1221,7 +1770,7 @@ choices为一个数组，其中每一项都是一个选项列表。
                     }
                 ],
                 "false": [ // flag:type==1，鼠标点击
-                    "你当前点击屏幕了，坐标是[${flag:x},${flag:y}]",
+                    "你当前点击屏幕了，位置坐标是[${flag:x},${flag:y}]，像素坐标是[${flag:px},${flag:py}]",
                     {"type": "if", "condition": "flag:x==6 && flag:y==6", // 点击(6,6)
                         "true": [{"type": "break"}], // 跳出循环
                         "false": []
@@ -1231,15 +1780,27 @@ choices为一个数组，其中每一项都是一个选项列表。
         ]
     }
 ]
-
 ```
 
+### waitAsync：等待所有异步事件执行完毕
+
+上面有很多很多的异步事件（也就是执行时不等待执行完毕）。
+
+由于录像是加速播放，且会跳过`{"type":"sleep"}`（等待X毫秒）事件；因此异步行为很有可能导致录像播放出错。
+
+例如，异步移动一个NPC去某格，然后等待X毫秒，再勇士走过去对话；
+但是录像播放中，等待X毫秒的行为会被跳过，因此勇士可能走过去时异步还未执行完成，导致录像出错。
+
+我们可以使用`{"type":"waitAsync"}`来等待所有异步事件执行完毕。
+
+该事件会进行等待，直到所有可能的异步事件（异步动画除外）执行完毕。
+
 ### function: 自定义JS脚本
 
 上述给出了这么多事件，但有时候往往不能满足需求，这时候就需要执行自定义脚本了。
 
 ``` js
-"x,y": [ // 实际执行的事件列表
+[
     {"type": "function", "function": function(){ // 执行一段js脚本
         // 这里写js代码
         alert(core.getStatus("atk")); // 弹窗显示勇士的攻击力
@@ -1249,11 +1810,11 @@ choices为一个数组，其中每一项都是一个选项列表。
 
 `{"type":"function"}`需要有一个`"function"`参数，它是一个JS函数，里面可以写任何自定义的JS脚本；系统将会执行它。
 
-系统常见可能会被造塔所用到的的API都在[附录：API列表](api)中给出，请进行参照。
+系统常见可能会被造塔所用到的的API都在[API列表](api)中给出，请进行参照。
 
 **警告：自定义脚本中只能执行同步代码，不可执行任何异步代码，比如直接调用core.changeFloor(...)之类都是不行的。**
 
-[附录：API列表](api)中的所有异步API都进行了标记；如果你不确定一个函数是同步的还是异步的，请向小艾咨询。
+[API列表](api)中的所有异步API都进行了标记；如果你不确定一个函数是同步的还是异步的，请向小艾咨询。
 
 如果需要异步的代码都需要用事件（insertAction）来执行，这样事件处理过程和录像回放才不会出错。
 
@@ -1268,6 +1829,23 @@ core.insertAction([
 // 请勿直接调用 core.changeFloor(toFloor, ...)，这个代码是异步的，会导致事件处理和录像出问题！
 ```
 
+!> 从V2.5.3开始，提供了一个"不自动执行下一个事件"的选项（`"async": true`）。如果设置了此项，那么在该部分代码执行完毕后，不会立刻执行下一个事件。你需要在脚本中手动调用`core.events.doAction()`来执行下一个事件。可以通过此项来实现一些异步的代码，即在异步函数的回调中再执行下一个事件。使用此选项请谨慎，最好向开发者寻求咨询。
+
+## 独立开关
+
+从V2.5.3开始，针对每个事件都提供了独立开关。
+
+独立开关的写法是`switch:A`, `switch:A`直到`switch:Z`，共计26个；不过样板中的值块默认只提供前6个。
+
+独立开关算是特殊的flag，它在事件中使用时会和事件的楼层及坐标进行绑定；换句话说每个事件对应的`switch:A`都是不同的。
+
+事实上，在某个楼层某个点的事件的独立开关A对应的系统flag为`floorId@x@y@A`，
+比如在`MT0`层的`[2,5]`点事件，对应的`switch:B`独立开关，实际会被映射到`flag:MT0@2@5@B`。
+
+如果在事件外想访问某个事件的独立开关也需要通过上面这个方式。
+
+通过独立开关的方式，我们无需对某些NPC的对话都设立单独的互不重复flag，只需要关注该事件自身的逻辑即可。
+
 ## 同一个点的多事件处理
 
 我们可以发现，就目前而且，每个点的事件是和该点进行绑定，并以该点坐标作为唯一索引来查询。
@@ -1339,7 +1917,6 @@ core.insertAction([
 }
 ```
 
-
 总之，记住如下两点：
 
  - 可以使用setBlock来更改一个图块。
@@ -1349,6 +1926,72 @@ core.insertAction([
    - 如果弄不清楚系统trigger和自定义事件等的区别，也可以全部覆盖为自定义事件，然后通过type:battle，type:openDoor等来具体进行控制。
  - 多事件处理时请不要使用`changeFloor`那一项，而是使用`events`或者`afterXXX`来处理。
 
+## 并行事件处理
+
+从V2.4.3后，H5样板开始支持并行事件处理。
+
+在脚本编辑里面提供了一个parallelDo函数，这个函数可以用来做并行处理内容。
+
+从V2.5.2开始，每层楼的楼层属性中也增加了一个parallelDo选项，可以在里面写任何脚本代码。该部分代码仅在人物在该楼层时才会被反复执行。
+
+``` js
+"parallelDo": function (timestamp) {
+	// 并行事件处理，可以在这里写任何需要并行处理的脚本或事件
+	// 该函数将被系统反复执行，每次执行间隔视浏览器或设备性能而定，一般约为16.6ms一次
+	// 参数timestamp为“从游戏资源加载完毕到当前函数执行时”的时间差，以毫秒为单位
+
+	// 检查当前是否处于游戏开始状态
+	if (!core.isPlaying()) return;
+
+	// 执行当前楼层的并行事件处理
+	if (core.isset(core.status.floorId)) {
+		try {
+			eval(core.floors[core.status.floorId].parallelDo);
+		} catch (e) {
+			main.log(e);
+		}
+	}
+	
+	// 下面是一个并行事件开门的样例
+	/*
+	// 如果某个flag为真
+	if (core.hasFlag("xxx")) {
+		// 千万别忘了将该flag清空！否则下次仍然会执行这段代码。
+		core.removeFlag("xxx");
+		// 使用insertAction来插入若干自定义事件执行
+		core.insertAction([
+			{"type":"openDoor", "loc":[0,0], "floorId": "MT0"}
+		])
+		// 也可以写任意其他的脚本代码
+	}
+	 */
+}
+```
+
+该函数将被系统反复执行，执行间隔试浏览器或设备性能而定，一般约为16.6ms一次。
+
+此函数有个参数timestamp，为**从游戏资源加载完毕到当前函数执行时**的时间差，以毫秒为单位。可以使用此参数来制作一些时间相关内容或者特效等。
+
+如果要执行并行的自定义事件，请使用if+flag判断的形式，然后insertAction将自定义事件插入到事件列表中。
+
+!> 判定flag后千万别忘了将该flag清空！否则下次仍然会执行这段代码。
+
+每层楼的并行事件处理类似，只有角色在当前楼层时才会反复执行当前楼层中parallelDo部分的代码。
+
+下面是一个打怪开门的样例：（假设每打一个怪的战后事件把`flag:door`+1）
+
+``` js
+// 每层楼的并行事件处理代码样例
+if (core.getFlag("door",0)==2) {
+    // 将该flag清空
+    core.removeFlag("door");
+    // 开门，如果是当前层则无需写floorId
+    core.insertAction([
+        {"type":"openDoor", "loc":[0,0]}
+    ]);
+}
+```
+
 ## 加点事件
 
 打败怪物后可以进行加点。
@@ -1357,31 +2000,13 @@ core.insertAction([
 
 如果要对某个怪物进行加点操作，则首先需要修改该怪物的`point`数值，代表怪物本身的加点数值。
 
-然后在脚本编辑中找到加点事件，双击进行修改。它将返回一个choices事件。修改此函数为我们需要的加点项即可。
+从V2.5.5开始，加点事件移动到了[公共事件](personalization#公共事件)之中，会通过传参的形式来传递怪物的加点值。
 
-``` js
-////// 加点事件 //////
-"addPoint" : function (enemy) {
-    // 加点事件
-    var point = enemy.point;
-    if (!core.flags.enableAddPoint || !core.isset(point) || point<=0) return [];
-
-    // 加点，返回一个choices事件
-    return [
-        {"type": "choices",
-            "choices": [ // 提供三个选项：对于每一点，攻击+1/防御+2/生命+200
-                {"text": "攻击+"+(1*point), "action": [
-                    {"type": "setValue", "name": "status:atk", "value": "status:atk+"+(1*point)}
-                ]},
-                {"text": "防御+"+(2*point), "action": [
-                    {"type": "setValue", "name": "status:def", "value": "status:def+"+(2*point)}
-                ]},
-                {"text": "生命+"+(200*point), "action": [
-                    {"type": "setValue", "name": "status:hp", "value": "status:hp+"+(200*point)}
-                ]},
-            ]
-        }
-    ];
+```js
+// 如果有加点
+var point = core.material.enemys[enemyId].point;
+if (core.flags.enableAddPoint && point > 0) {
+    core.push(todo, [{ "type": "insert", "name": "加点事件", "args": [point] }]);
 }
 ```
 
@@ -1403,41 +2028,15 @@ core.insertAction([
         "icon": "blueShop", // 商店图标，blueShop为蓝色商店，pinkShop为粉色商店
         "textInList": "1F金币商店", // 在快捷商店栏中显示的名称
         "use": "money", // 商店所要使用的。只能是"money"或"experience"。
-        "need": "20+10*times*(times+1)",  // 商店需要的金币/经验数值；可以是一个表达式，以times作为参数计算。
-        // 这里用到的times为该商店的已经的访问次数。首次访问该商店时times的值为0。
-        // 上面的例子是50层商店的计算公式。你也可以写任意其他的计算公式，只要以times作为参数即可。
-        // 例如： "need": "25" 就是恒定需要25金币的商店； "need": "20+2*times" 就是第一次访问要20金币，以后每次递增2金币的商店。
-        // 如果是对于每个选项有不同的计算公式，写 "need": "-1" 即可。可参见下面的经验商店。
-        "text": "勇敢的武士啊，给我${need}金币就可以：", // 显示的文字，需手动加换行符。可以使用${need}表示上面的need值。
+        "commonTimes": true, // 是否使用全局次数
+        "mustEnable": false, // 如果未开启则不显示在状态栏中
+        "need": "20+10*times*(times+1)",  // 商店需要的金币/经验数值；可以是一个表达式，以times（访问次数）作为参数计算。
+        "text": "勇敢的武士啊，给我${need}金币就可以：", // 显示的文字。可以使用${need}表示上面的need值。
         "choices": [ // 商店的选项
-            {"text": "生命+800", "effect": "status:hp+=800"},
-            // 如果有多个effect以分号分开，参见下面的经验商店
-            {"text": "攻击+4", "effect": "status:atk+=4"},
-            {"text": "防御+4", "effect": "status:def+=4"},
-            {"text": "魔防+10", "effect": "status:mdef+=10"}
-            // effect只能对status和item进行操作，不能修改flag值。
-            // 必须是X+=Y的形式，其中Y可以是一个表达式，以status:xxx或item:xxx为参数
-            // 其他effect样例：
-            // "item:yellowKey+=1" 黄钥匙+1
-            // "item:pickaxe+=3" 破墙镐+3
-            // "status:hp+=2*(status:atk+status:def)" 将生命提升攻防和的数值的两倍
-        ]
-    },
-    {
-        "id": "expShop1", // 商店唯一ID
-        "name": "经验之神",
-        "icon": "pinkShop",
-        "textInList": "1F经验商店",
-        "use": "experience", // 该商店使用的是经验进行计算
-        "need": "-1", // 如果是对于每个选项所需要的数值不同，这里直接写-1，然后下面选项里给定具体数值
-        "text": "勇敢的武士啊，给我若干经验就可以：",
-        "choices": [
-            // 在choices中写need，可以针对每个选项都有不同的需求。
-            // 这里的need同样可以以times作为参数，比如 "need": "100+20*times"
-            {"text": "等级+1", "need": "100", "effect": "status:lv+=1;status:hp+=1000;status:atk+=7;status:def+=7"},
-            // 多个effect直接以分号分开即可。如上面的意思是生命+1000，攻击+7，防御+7。
-            {"text": "攻击+5", "need": "30", "effect": "status:atk+=5"},
-            {"text": "防御+5", "need": "30", "effect": "status:def+=5"},
+            // effect可以对status，item和flag进行操作；必须是X+=Y的形式，其中Y可以是一个表达式
+            {"text": "生命+800", "effect": "status:hp+=800"}, // 生命+800
+            {"text": "攻击+4", "need": 30, "effect": "status:atk+=4"}, // 规定具体的数值
+            {"text": "防御+2，魔防+4", "effect": "status:def+=2;status:mdef+=4"}, // 多个效果用分号分开
         ]
     }
 ],
@@ -1450,21 +2049,24 @@ core.insertAction([
 - icon 为商店的图标，在icons.js的npcs中定义。如woman可代表一个商人。
 - textInList 为其在快捷商店栏中显示的名称，如"3楼金币商店"等
 - use 为消耗的类型，是金币（money）还是经验（experience）。
+- commonTimes 是否使用全局次数；如果为true则可以多个快捷商店共享相同的次数
+- mustEnable 是否必须是只在开启状态才在列表显示；如果此项为true则未开启的快捷商店不予显示
 - need 是一个表达式，计算商店所需要用到的数值。
   - 可以将times作为参数，times为该商店已经访问过的次数，第一次访问时times是0。
   - 如果对于每个选项都需要不同的数值，这里设为"-1"；可参见下面经验商店的例子。
 - text 为商店所说的话。可以用${need}表示需要的数值。
 - choices 为商店的各个选项，是一个list，每一项是一个选项
   - text为显示文字。请注意这里不支持 ${} 的表达式计算。
-  - effect 为该选项的效果；effect只能对status或items进行操作，且必须是 `status:xxx+=yyy` 或 `item:xxx+=yyy`的形式。即中间必须是+=符号。
-  - 如有多个effect（例如升级全属性提升），使用分号分开，参见经验商店的写法。
+  - effect 为该选项的效果；effect必须是 `status:xxx+=yyy`, `item:xxx+=yyy`或`flag:xxx+=yyy`的形式。即中间必须是+=符号。
+  - 如有多个effect（例如升级全属性提升），使用分号分开。
 
 像这样定义了全局商店后，即可在快捷栏中看到。
 
 请注意，快捷商店默认是不可被使用的。直到至少调用一次自定义事件中的 `{"type": "openShop"}` 打开商店后，才能真正在快捷栏中被使用。
 
 ``` js
-"1,0": [ // 金币商店
+// 事件列表
+[
     // 打开商店前，你也可以添加自己的剧情
     // 例如，通过if来事件来判断是不是第一次访问商店，是的则显示一段文字（类似宿命的华音那样）
     {"type": "openShop", "id": "moneyShop1"}, // 这里的id要和data.js中你定义的商店ID完全一致
@@ -1481,6 +2083,27 @@ core.insertAction([
 
 另外需要注意的一点就是，每层楼都有一个 canUseQuickShop 选项。如果该选项置为false则无法在该层使用快捷商店。
 
+**从V2.6开始，也提出了“公共事件化的全局商店”，即打开使用全局商店实际上是执行一个公共事件。**
+
+```js
+"shops": [
+    // 定义公共事件化的全局商店
+    {
+        "id": "keyShop1", // 商店唯一ID
+        "textInList": "回收钥匙商店", // 在快捷商店栏中显示的名称
+        "mustEnable": false, // 如果未开启则不显示在状态栏中
+        "commonEvent": "回收钥匙商店", // 公共事件名
+        "args": [], // 向该公共事件传递的参数
+    }
+]
+```
+
+`id`, `textInList`, `mustEnable`和上述完全相同。
+
+`commonEvent`为公共事件名，即选择此项时要执行的公共事件。
+
+`args`为向该公共事件传递的参数，参见[type:insert](#insert：插入公共事件或另一个地点的事件并执行)的说明。
+
 ## 系统引发的自定义事件
 
 我们知道，所有自定义事件都是需要定义在`"x,y"`处，并且得让用户经过或撞上才能触发的。
@@ -1519,17 +2142,13 @@ core.insertAction([
 
 !> 多个机关门请分别设置开门变量如door1, door2等等。请勿存在两个机关门用相同的变量！
 
-同样，为了实现类似于RMXP中，到达某一层后自动触发某段事件的效果，样板中还存在`firstArrive`事件。
-
-当且仅当勇士第一次到达某层时，将会触发此事件。可以利用此事件来显示一些剧情，或再让它调用 `{"type": "trigger"}` 来继续调用其他的事件。
+除此以外，每层楼还提供了`firstArrive`和`eachArrive`事件，分别为首次到达该楼层和每次到达该楼层时执行的事件。
 
 ## 使用炸弹后的事件
 
 上面的afterBattle事件只对和怪物进行战斗后才有会被处理。
 
-如果我们想在使用炸弹后也能触发一些事件（如开门），则可以在`functions.js`里面的`afterUseBomb`函数进行处理：
-
-!> V2.0版本可以直接在“脚本编辑 - 使用炸弹后的事件”中双击进行修改！
+如果我们想在使用炸弹后也能触发一些事件（如开门），则可以在脚本编辑里面的`afterUseBomb`函数进行处理：
 
 ``` js
 ////// 使用炸弹/圣锤后的事件 //////
@@ -1545,47 +2164,42 @@ core.insertAction([
 }
 ```
 
-## 滑冰和推箱子事件
+## 滑冰事件
 
-最新的样板还支持滑冰和推箱子事件。
+从V2.6开始，滑冰事件被重写。现在的滑冰由公共事件执行。
 
-滑冰事件的数字是167，trigger为ski。
+在新版本中，冰面应该放在背景层上，上面可以放置道具、怪物、门等图块。
 
-当角色走上冰面时，将触发ski事件，并会一直向前滑行，直到撞上不可通行的块会触发事件（比如撞上怪物会触发battle，撞上门会触发openDoor等等），或者离开冰面为止。
+角色走上冰面后，将一直向前滑行，直到撞上不可通行的图块，或触发事件为止。
 
-!> 由于H5魔塔只有事件一层，因此滑冰的冰面上将无法摆放任何东西（如道具）。
+如果撞上怪物将自动进行战斗，此战斗是强制的，打不过将直接死亡。
 
-!> 撞上怪物将触发battle进行战斗，此战斗的触发和直接撞上怪物相同（战斗前自动存档，打不过则无法战斗）；如需不自动存档的强制战斗请使用自定义事件覆盖。开门同理。
+默认情况下，拾取冰面上道具后将停止滑冰行为。如果要继续滑冰，请在`afterGetItem`中插入公共事件：滑冰事件。打怪和开门同理。
+
+!> 滑冰图块的数字是167，请勿修改此数字！
+
+## 推箱子事件
 
 关于推箱子，存在三种状态：花（168），箱子（169）和已经推到花的箱子（170）。
 
 !> 推箱子的前方不允许存在任何事件（花除外），包括已经禁用的自定义事件。
 
-推完箱子后将触发functions.js中的afterPushBox事件，你可以在这里进行开门判断。
+推完箱子后将触发脚本编辑中的afterPushBox函数，你可以在这里进行开门判断。
 
 ``` js
 ////// 推箱子后的事件 //////
 "afterPushBox" = function () {
-
-    var noBoxLeft = function () {
-        // 地图上是否还存在未推到的箱子，如果不存在则返回true，存在则返回false
-        for (var i=0;i<core.status.thisMap.blocks.length;i++) {
-            var block=core.status.thisMap.blocks[i];
-            if (core.isset(block.event) && block.event.id=='box') return false;
-        }
-        return true;
-    }
-
-    if (noBoxLeft()) {
-        // 可以通过if语句来进行开门操作
-        /*
-        if (core.status.floorId=='xxx') { // 在某个楼层
-            core.insertAction([ // 插入一条事件
-                {"type": "openDoor", "loc": [x,y]} // 开门
-            ])
-        }
-        */
-    }
+    // 推箱子后的事件
+	if (core.searchBlock('box').length == 0) {
+		// 可以通过if语句来进行开门操作
+		/*
+		if (core.status.floorId=='xxx') { // 在某个楼层
+			core.insertAction([ // 插入一条事件
+				{"type": "openDoor", "loc": [x,y]} // 开门
+			])
+		}
+		*/
+	}
 }
 ```
 
@@ -1598,7 +2212,6 @@ core.insertAction([
 我们可以在脚本编辑中的`updateEnemys`进行处理。
 
 ``` js
-////// 读档事件后，载入事件前，可以执行的操作 //////
 "updateEnemys" : function () {
 	// 更新怪物数据，可以在这里对怪物属性和数据进行动态更新，详见文档——事件——怪物数据的动态修改
 	// 比如下面这个例子，如果flag:xxx为真，则将绿头怪的攻击设为100，红头怪的金币设为20
@@ -1618,13 +2231,15 @@ core.insertAction([
 
 ``` js
 // 调用`updateEnemys`（更新怪物数据）事件就可以触发了
-"x,y": [
+[
     "将flag:xxx置为真，就可以让怪物数据发生改变！",
     {"type": "setValue", "name": "flag:xxx", "value": "true"}, // 将flag:xxx置为真
     {"type": "updateEnemys"} // 更新怪物数据；此时绿头怪攻击就会变成100了
 ]
 ```
 
+事实上，除了动态修改怪物属性外，也可以在这里动态修改道具的类型、使用效果等等。都是一样的。
+
 ## 战前剧情
 
 有时候光战后事件`afterBattle`是不够的，我们可能还需要战前剧情，例如Boss战之前和Boss进行一段对话。
@@ -1634,9 +2249,8 @@ core.insertAction([
 值得注意的是，使用这种自定义事件来覆盖系统的默认战斗事件时，可以增加`displayDamage`代表该点是否需要显伤。此项可省略，默认为有显伤。
 
 ``` js
-"x,y": { // (x,y)为该怪物坐标
-    "trigger": "action", // 覆盖该点本身默认事件，变成自定义事件
-    "displayDamage": true, // 覆盖后，该点是否有显伤；此项可忽略，默认为有。
+{
+    "trigger": "action", // 覆盖该点触发器，变成自定义事件
     "data": [ // 该点的自定义事件列表
         // ... 战前剧情
         {"type": "battle", "id": "xxx"}, // 强制战斗
@@ -1645,53 +2259,52 @@ core.insertAction([
 }
 ```
 
+另外，从V2.6开始，脚本编辑中提供了战前事件`beforeBattle`，这里不再详细展开，如有需求可自行前往研究。
+
 ## 经验升级（进阶/境界塔）
 
 本塔也支持经验升级，即用户杀怪获得经验后，可以到达某些数值自动进阶，全面提升属性。
 
 要经验升级，你需要先在`data.js`中的全局变量中启用。你需要将`enableExperience`启用经验，且`enableLevelUp`启用进阶。同时你也可以将`enableLv`置为true以在状态栏中显示当前等级（境界）。
 
-同时，你还需要在`data.js`中的`levelUp`来定义每一个进阶所需要的生命值，以及进阶时的效果。
+同时，你还需要在`data.js`中的`levelUp`来定义每一个进阶所需要的经验值，以及进阶时的效果。
 
 ``` js
 "levelUp": [ // 经验升级所需要的数值，是一个数组
-    {}, // 第一项为初始等级，可以简单留空，也可以写name
-
-    // 每一个里面可以含有三个参数 need, name, effect
-    // need为所需要的经验数值，是一个正整数。请确保need所需的依次递增
-    // name为该等级的名称，也可以省略代表使用系统默认值；本项将显示在状态栏中
-    // effect为本次升级所执行的操作，可由若干项组成，由分号分开
-    // 其中每一项写法和上面的商店完全相同，同样必须是X+=Y的形式，Y是一个表达式，同样可以使用status:xxx或item:xxx代表勇士的某项数值/道具个数
-    {"need": 20, "name": "第二级", "effect": "status:hp+=2*(status:atk+status:def);status:atk+=10;status:def+=10"}, // 先将生命提升攻防和的2倍；再将攻击+10，防御+10
-
-    // effect也允许写一个function，代表本次升级将会执行的操作，比如可以显示一段提示文字，或者触发一个事件
-    {"need": 40, "effect": function () {
-        core.drawTip("恭喜升级！");
-        core.status.hero.hp *= 2;
-        core.status.hero.atk += 100;
-        core.status.hero.def += 100;
-    }},
-
+    {"need": "0", "title": "", "action": []}, // 第一项为初始等级，仅title生效
+    // 每一个里面可以含有四个参数 need, title, clear, action
+    // need为所需要的经验数值，可以是个表达式。请确保need依次递增
+    // title为该等级的名称，也可以省略代表使用系统默认值；本项将显示在状态栏中
+    // clear如果为true则自动扣除经验
+    // action为本次升级所执行的事件列表
+    {"need": "20", "title": "第二级", "clear": true, "action": [ // 加上clear则自动扣除经验
+		{"type": "setValue","name": "status:atk","value": "status:atk+10"}, // 攻击+10
+        {"type": "setValue","name": "status:def","value": "status:def+10"}  // 防御+10
+    ]},
+    {"need": "40", "effect": [
+        {"type": "tip", "text": "恭喜升级"}, 
+    ]},
     // 依次往下写需要的数值即可
 ]
 ```
 
-`levelUp`是一个数组，里面分别定义了每个等级的信息。里面每一项是一个object，主要有三个参数`need`, `name`, `effect`
-- `need` 该等级所需要的经验值，是一个正整数。请确保数组中的need依次递增。
-- `name` 该等级的名称，比如“佣兵下级”等。该项可以忽略，以使用系统默认的等级。该项将显示在状态栏中。
-- `effect` 为本次等级执行的操作。它有两种写法：字符串，或函数。
-  - 如果`effect`为字符串，则和上面的全局商店的写法完全相同。可由分号分开，每一项为X+=Y的形式，X为你要修改的勇士属性/道具个数，Y为一个表达式。
-  - 如果`effect`为函数，则也允许写一个`function`，来代表本次升级将会执行的操作。
+`levelUp`是一个数组，里面分别定义了每个等级的信息。里面每一项有三个参数`need`, `title`, `effect`
+- `need` 该等级所需要的经验值，可以是个表达式。请确保数组中的need依次递增。
+- `title` 该等级的名称，比如“佣兵下级”等。该项可以忽略，以使用系统默认的等级。该项将显示在状态栏中。
+- `clear` 是否扣除经验。如果此项为true，则升级时自动扣除经验。
+- `action` 为本次等级要执行的事件流。
 
-## 开始，难度分歧，获胜与失败，多结局
+## 开始游戏与难度分歧
 
 游戏开始时将调用`events.js`中的`startGame`函数。
 
-它将显示`data.js`中的startText内容（可以修改成自己的），提供战斗动画开启选择，设置初始福利，并正式开始游戏。
+它将显示全塔属性中的startText内容（可以修改成自己的），提供战斗动画开启选择，设置初始福利，并正式开始游戏。
 
-我们可以修改`setInitData`函数来对于不同难度分别设置初始属性。
+我们可以修改脚本编辑`setInitData`函数来对于不同难度分别设置初始属性。
 
-其参数hard为以下三个字符串之一：`"Easy"`, `"Normal"`, `"Hard"`，分别对应三个难度。针对不同的难度，我们可以设置一些难度分歧。
+其参数hard分为对应全塔属性中levelChooseButtons中的第二项，分别对应不同的难度，并会在游戏中传输，在状态栏显示。
+
+针对不同的难度，我们可以设置一些难度分歧。
 
 ``` js
 ////// 不同难度分别设置初始属性 //////
@@ -1699,9 +2312,9 @@ core.insertAction([
     if (hard=='Easy') { // 简单难度
         core.setFlag('hard', 1); // 可以用flag:hard来获得当前难度
         // 可以在此设置一些初始福利，比如设置初始生命值可以调用：
-        // core.setStatus("hp", 10000);
+        // core.setStatus('hp', 10000);
         // 赠送一把黄钥匙可以调用
-        // core.setItem("yellowKey", 1);
+        // core.setItem('yellowKey', 1);
     }
     if (hard=='Normal') { // 普通难度
         core.setFlag('hard', 2); // 可以用flag:hard来获得当前难度
@@ -1716,50 +2329,18 @@ core.insertAction([
 
 请不要在任何事件中修改对`flag:hard`进行任何赋值（修改它），不然可能会造成一些不可知的后果。
 
-当获胜`{"type": "win"}`事件发生时，将调用`events.js`中的win事件。其显示一段恭喜文字，并重新开始游戏。
+如果是在游戏中根据不同的难度分析来控制地图，比如简单难度删除绿钥匙，则可以在该楼层的`firstArrive`（首次到达楼层）中进行条件判定。
 
-``` js
-////// 游戏获胜事件 //////
-"win": function(reason) {
-    core.ui.closePanel();
-    var replaying = core.status.replay.replaying;
-    core.stopReplay();
-    core.waitHeroToStop(function() {
-        core.removeGlobalAnimate(0,0,true);
-        core.clearMap('all'); // 清空全地图
-        core.drawText([
-            "\t[恭喜通关]你的分数是${status:hp}。"
-        ], function () {
-            core.events.gameOver(reason||'', replaying);
-        })
-    });
-}
+```js
+// 该楼层的firstArrive
+[
+    {"type": "if", "condition": "flag:hard==1", // 条件判定flag:hard是否为1
+        "true": [{"type":"hide","loc":[0,0]}], // 如果是，则隐藏某点事件
+        "false": []
+    }
+]
 ```
 
-其参数reason为获胜原因（即type:win事件里面的reason参数）。
-
-!> 如果reason不为空，则将会作为结局名！
-
-当失败（`{"type": "lose"}`，或者被怪强制战斗打死、被领域怪扣血死、中毒导致扣血死，路障导致扣血死等等）事件发生时，将调用`events.js`中的`lose`事件。其直接显示一段文字，并重新开始游戏。
-
-``` js
-////// 游戏失败事件 //////
-"lose": function(reason) {
-    core.ui.closePanel();
-    var replaying = core.status.replay.replaying;
-    core.stopReplay();
-    core.waitHeroToStop(function() {
-        core.drawText([
-            "\t[结局1]你死了。\n如题。"
-        ], function () {
-            core.events.gameOver(null, replaying);
-        });
-    })
-}
-```
-
-其参数reason为失败原因。你可以在这里修改失败界面时显示的文字。
-
 ==========================================================================================
 
 [继续阅读下一章：个性化](personalization)
diff --git a/docs/img/blood.png b/_docs/img/blood.png
similarity index 100%
rename from docs/img/blood.png
rename to _docs/img/blood.png
diff --git a/docs/img/changefloor.png b/_docs/img/changefloor.png
similarity index 100%
rename from docs/img/changefloor.png
rename to _docs/img/changefloor.png
diff --git a/docs/img/checkblock.png b/_docs/img/checkblock.png
similarity index 100%
rename from docs/img/checkblock.png
rename to _docs/img/checkblock.png
diff --git a/docs/img/chrome.png b/_docs/img/chrome.png
similarity index 100%
rename from docs/img/chrome.png
rename to _docs/img/chrome.png
diff --git a/_docs/img/commonEvent.png b/_docs/img/commonEvent.png
new file mode 100644
index 00000000..d6358b89
Binary files /dev/null and b/_docs/img/commonEvent.png differ
diff --git a/_docs/img/console.jpg b/_docs/img/console.jpg
new file mode 100644
index 00000000..76d59378
Binary files /dev/null and b/_docs/img/console.jpg differ
diff --git a/docs/img/console.png b/_docs/img/console.png
similarity index 100%
rename from docs/img/console.png
rename to _docs/img/console.png
diff --git a/_docs/img/console1.jpg b/_docs/img/console1.jpg
new file mode 100644
index 00000000..46d1f5ba
Binary files /dev/null and b/_docs/img/console1.jpg differ
diff --git a/docs/img/debuff.png b/_docs/img/debuff.png
similarity index 100%
rename from docs/img/debuff.png
rename to _docs/img/debuff.png
diff --git a/docs/img/drawmap.jpg b/_docs/img/drawmap.jpg
similarity index 100%
rename from docs/img/drawmap.jpg
rename to _docs/img/drawmap.jpg
diff --git a/_docs/img/elements.jpg b/_docs/img/elements.jpg
new file mode 100644
index 00000000..d32ebaf2
Binary files /dev/null and b/_docs/img/elements.jpg differ
diff --git a/docs/img/enemy.png b/_docs/img/enemy.png
similarity index 100%
rename from docs/img/enemy.png
rename to _docs/img/enemy.png
diff --git a/docs/img/enemyarray.png b/_docs/img/enemyarray.png
similarity index 100%
rename from docs/img/enemyarray.png
rename to _docs/img/enemyarray.png
diff --git a/docs/img/eventdebug.png b/_docs/img/eventdebug.png
similarity index 100%
rename from docs/img/eventdebug.png
rename to _docs/img/eventdebug.png
diff --git a/docs/img/flag.png b/_docs/img/flag.png
similarity index 100%
rename from docs/img/flag.png
rename to _docs/img/flag.png
diff --git a/docs/img/floor.png b/_docs/img/floor.png
similarity index 100%
rename from docs/img/floor.png
rename to _docs/img/floor.png
diff --git a/docs/img/floordata.png b/_docs/img/floordata.png
similarity index 100%
rename from docs/img/floordata.png
rename to _docs/img/floordata.png
diff --git a/docs/img/floorid.png b/_docs/img/floorid.png
similarity index 100%
rename from docs/img/floorid.png
rename to _docs/img/floorid.png
diff --git a/docs/img/floorset.png b/_docs/img/floorset.png
similarity index 100%
rename from docs/img/floorset.png
rename to _docs/img/floorset.png
diff --git a/docs/img/getspecialtext.png b/_docs/img/getspecialtext.png
similarity index 100%
rename from docs/img/getspecialtext.png
rename to _docs/img/getspecialtext.png
diff --git a/docs/img/imginfo.png b/_docs/img/imginfo.png
similarity index 100%
rename from docs/img/imginfo.png
rename to _docs/img/imginfo.png
diff --git a/docs/img/init.png b/_docs/img/init.png
similarity index 100%
rename from docs/img/init.png
rename to _docs/img/init.png
diff --git a/_docs/img/keyboard.png b/_docs/img/keyboard.png
new file mode 100644
index 00000000..c2b9d241
Binary files /dev/null and b/_docs/img/keyboard.png differ
diff --git a/docs/img/logo.png b/_docs/img/logo.png
similarity index 100%
rename from docs/img/logo.png
rename to _docs/img/logo.png
diff --git a/docs/img/map1.png b/_docs/img/map1.png
similarity index 100%
rename from docs/img/map1.png
rename to _docs/img/map1.png
diff --git a/docs/img/maparray.png b/_docs/img/maparray.png
similarity index 100%
rename from docs/img/maparray.png
rename to _docs/img/maparray.png
diff --git a/docs/img/mapgui.png b/_docs/img/mapgui.png
similarity index 100%
rename from docs/img/mapgui.png
rename to _docs/img/mapgui.png
diff --git a/docs/img/mapmean.png b/_docs/img/mapmean.png
similarity index 100%
rename from docs/img/mapmean.png
rename to _docs/img/mapmean.png
diff --git a/docs/img/moddata.png b/_docs/img/moddata.png
similarity index 100%
rename from docs/img/moddata.png
rename to _docs/img/moddata.png
diff --git a/docs/img/nattack.png b/_docs/img/nattack.png
similarity index 100%
rename from docs/img/nattack.png
rename to _docs/img/nattack.png
diff --git a/_docs/img/plugin.jpg b/_docs/img/plugin.jpg
new file mode 100644
index 00000000..d0d69bef
Binary files /dev/null and b/_docs/img/plugin.jpg differ
diff --git a/_docs/img/plugin.png b/_docs/img/plugin.png
new file mode 100644
index 00000000..5c65cd4d
Binary files /dev/null and b/_docs/img/plugin.png differ
diff --git a/docs/img/point.png b/_docs/img/point.png
similarity index 100%
rename from docs/img/point.png
rename to _docs/img/point.png
diff --git a/docs/img/ps.png b/_docs/img/ps.png
similarity index 100%
rename from docs/img/ps.png
rename to _docs/img/ps.png
diff --git a/docs/img/register.png b/_docs/img/register.png
similarity index 100%
rename from docs/img/register.png
rename to _docs/img/register.png
diff --git a/docs/img/rmxp1.png b/_docs/img/rmxp1.png
similarity index 100%
rename from docs/img/rmxp1.png
rename to _docs/img/rmxp1.png
diff --git a/docs/img/rmxp2.png b/_docs/img/rmxp2.png
similarity index 100%
rename from docs/img/rmxp2.png
rename to _docs/img/rmxp2.png
diff --git a/docs/img/rmxp3.png b/_docs/img/rmxp3.png
similarity index 100%
rename from docs/img/rmxp3.png
rename to _docs/img/rmxp3.png
diff --git a/docs/img/rmxp4.jpg b/_docs/img/rmxp4.jpg
similarity index 100%
rename from docs/img/rmxp4.jpg
rename to _docs/img/rmxp4.jpg
diff --git a/docs/img/sample0.png b/_docs/img/sample0.png
similarity index 100%
rename from docs/img/sample0.png
rename to _docs/img/sample0.png
diff --git a/docs/img/save.png b/_docs/img/save.png
similarity index 100%
rename from docs/img/save.png
rename to _docs/img/save.png
diff --git a/docs/img/script.png b/_docs/img/script.png
similarity index 100%
rename from docs/img/script.png
rename to _docs/img/script.png
diff --git a/docs/img/server.png b/_docs/img/server.png
similarity index 100%
rename from docs/img/server.png
rename to _docs/img/server.png
diff --git a/_docs/img/sources.jpg b/_docs/img/sources.jpg
new file mode 100644
index 00000000..7fce53b3
Binary files /dev/null and b/_docs/img/sources.jpg differ
diff --git a/docs/img/tuihua.png b/_docs/img/tuihua.png
similarity index 100%
rename from docs/img/tuihua.png
rename to _docs/img/tuihua.png
diff --git a/docs/img/zone.png b/_docs/img/zone.png
similarity index 100%
rename from docs/img/zone.png
rename to _docs/img/zone.png
diff --git a/_docs/index.html b/_docs/index.html
new file mode 100644
index 00000000..10679f3f
--- /dev/null
+++ b/_docs/index.html
@@ -0,0 +1,50 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>HTML5魔塔样板</title>
+  <link rel="shortcut icon" type="image/png" href="./img/logo.png">
+  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
+  <meta name="description" content="Description">
+  <meta http-equiv="pragma" content="no-cache">
+  <meta http-equiv="cache-control" content="no-cache">
+  <meta http-equiv="expires" content="0">
+  <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
+  <link href="https://cdn.bootcss.com/docsify/4.5.5/themes/vue.css" rel="stylesheet">
+</head>
+<body>
+  <div id="app"></div>
+  <script>
+    window.$docsify = {
+      homepage: 'index.md',
+      loadSidebar: true,
+      name: 'HTML5魔塔样板',
+      repo: 'https://github.com/ckcz123/mota-js',
+      // basepath: '../docs/',
+      
+        // Search Support
+      // search: {
+      //   maxAge: 43200000, // 过期时间，单位毫秒，默认一天
+      //   paths: 'auto',
+      //   placeholder: {
+      //     '/en/': 'Search',
+      //     '/': '搜索',
+      //   },
+      //   noData: {
+      //     '/en/': 'No Results',
+      //     '/': '找不到结果',
+      //   },
+      // },
+
+       // load sidebar from _sidebar.md
+      loadSidebar: '_sidebar',
+      subMaxLevel: 2,
+      autoHeader: true,
+      auto2top: true,
+      mergeNavbar: true,
+      formatUpdated: '{YYYY}-{MM}-{DD} {HH}:{mm}:{ss}',
+    }
+  </script>
+  <script src="https://cdn.bootcss.com/docsify/4.5.5/docsify.min.js"></script>
+</body>
+</html>
diff --git a/docs/index.md b/_docs/index.md
similarity index 74%
rename from docs/index.md
rename to _docs/index.md
index 0e744fb2..510bd14c 100644
--- a/docs/index.md
+++ b/_docs/index.md
@@ -1,11 +1,10 @@
 # HTML5 魔塔样板说明文档
 
-?> 目前版本**v2.3.3**，上次更新时间：* {docsify-updated} *
+?> 目前版本**v2.6.1**，上次更新时间：* {docsify-updated} *
 
 众所周知，魔塔的趋势是向移动端发展，贴吧中也常常能见到“求手机魔塔”的帖子。然而现有的工具中，NekoRPG有着比较大的局限性，游戏感较差，更是完全没法在iOS上运行。而一些APP的魔塔虽然可用，但是必须要下载安装，对于Android和iOS还必须开发不同的版本，非常麻烦。
 
 但是，现在我们有了HTML5。 HTML5的画布（canvas）以及它被Android/iOS内置浏览器所支持的特性，可以让我们做出真正意义上的全平台覆盖的魔塔。
-事实上，在贴吧的试水发布也证明了，H5魔塔确实是可以成功的。两部即使是复刻的魔塔也受到了不少人的追捧，其流畅的手感和全平台支持的特性，也让很多没办法打开电脑的人爱不释手。
 
 然而，一般而言使用非RMXP制作魔塔往往需要一定的编程技术，HTML5魔塔自然也不例外。但是，为了能让大家更加注重于“做塔”本身，而不用考虑做塔以外的各种脚本问题，我特意制作了这样一部HTML5的魔塔样板。
 
@@ -13,7 +12,7 @@
 
 继续查看文档的详细介绍，让你学会如何使用这一个样板来制作属于自己的HTML5魔塔。
 
-视频教程地址：[http://www.bilibili.com/video/av17608025/](http://www.bilibili.com/video/av17608025/) ，配合本教程观看效果更佳~
+本说明文档配有B站视频教程，对照查看效果更佳哦：[https://www.bilibili.com/video/av32781473/](https://www.bilibili.com/video/av32781473/)。
 
 ==========================================================================================
 
diff --git a/_docs/personalization.md b/_docs/personalization.md
new file mode 100644
index 00000000..72de08cd
--- /dev/null
+++ b/_docs/personalization.md
@@ -0,0 +1,717 @@
+# 个性化
+
+?> 目前版本**v2.6.1**，上次更新时间：* {docsify-updated} *
+
+有时候只靠样板本身可能是不够的。我们需要一些个性化、自定义的素材，道具效果，怪物属性，等等。
+
+## 图层的说明
+
+HTML5魔塔是使用画布（canvas）来绘制，存在若干个图层，它们之间有一个覆盖关系，后面的图层将覆盖前面的图层。
+
+所有图层从低往高依次如下：（加[B]的代表该层是大地图，[D]代表由系统按需动态创建，z-index代表该层的纵向高度）
+
+- bg**[B]**：背景层；绘制背景图层素材bgmap，和背景贴图 (z-index: 10)
+- event**[B]**：事件层；所有事件（道具、墙壁、NPC、怪物等）都绘制在这一层进行处理 (z-index: 30)
+- hero：勇士层；主要用来绘制勇士 (z-index: 40)
+- event2**[B]**：事件2层；本层主要用来绘制48x32的图片素材的上半部分（避免和勇士错位） (z-index: 50)
+- fg**[B]**：前景层；绘制前景图层素材fgmap，和前景贴图 (z-index: 60)
+- damage**[B]**：显伤层；主要用来绘制怪物显伤和领域显伤 (z-index: 65)
+- animate：动画层；主要用来绘制动画。 (z-index: 70)
+- weather**[D]**：天气层；主要用来绘制天气（雨/雪/雾） (z-index: 80)
+- route**[D]**：路线层；主要用来绘制勇士的行走路线图。 (z-index: 95)
+- paint**[D]**：绘图层；主要用来进行绘图模式。（z-index: 95)
+- curtain：色调层；用来控制当前楼层的画面色调 (z-index: 125)
+- image1\~50**[D]**：图片层；用来绘制图片等操作。（z-index: 100+code, 101~150）
+- ui：UI层；用来绘制一切UI窗口，如剧情文本、怪物手册、楼传器、系统菜单等等 (z-index: 140)
+- data：数据层；用来绘制一些顶层的或更新比较快的数据，如左上角的提示，战斗界面中数据的变化等等。 (z-index: 170)
+
+请注意：显示图片事件将自动创建一个图片层，z-index是100+图片编号。
+
+而，色调层的z-index是25，ui层的z-index是140；因此，图片编号在1~24的将被色调层遮挡，25~40的将被ui层遮挡，41~50的将遮挡UI层。
+
+### 动态创建canvas
+
+从V2.5.3开始，可以在H5样板中任意动态创建canvas并进行使用。
+
+使用`core.createCanvas(name, x, y, w, h, z)`来动态创建一个画布。
+
+其中name为动态canvas名称，x,y,w,h为创建的画布相对窗口左上角的像素坐标和长宽，z为画布的纵向高度。
+
+例如：`core.createCanvas('test', 10, 20, 100, 200, 74)` 创建了一个名为test的画布，其左上角相对窗口的像素坐标为(10,20)，宽100高200，纵向高度74（在动画层和天气层之间）。
+
+该函数会返回画布的context，也可以通过 `core.dymCanvas[name]` 来获得；例如 `core.dymCanvas.test` 就是我们上面创建的画布的context，然后进行操作。
+
+也可以简单的使用`core.fillText()`, `core.fillRect()`, `core.strokeRect()`等等对画布进行任意绘制。
+
+``` js
+core.fillText('test', '这是一段文字', 10, 30, '#FF0000', '16px Verdana'); // 绘制一段文本
+```
+
+使用 `core.deleteCanvas(name)` 删除一个动态创建的画布，例如 `core.deleteCanvas('test')`。
+
+`core.deleteAllCanvas()`可以删除所有动态创建的画布，`core.relocateCanvas(name, x, y)`和`core.resizeCanvas(name, x, y)`可以对画布的位置和大小进行改变。
+
+更多详细API请参见[API列表](api)。
+
+## 自定义素材
+
+所有素材的图片都在`images`目录下。
+- `animates.png` 为所有动画效果。主要是星空熔岩，开门，毒网，传送门之类的效果。为四帧。
+- `autotile*.png` 为Autotile块。
+- `enemys.png` 为所有怪物的图片。
+- `enemy48.png` 为所有48x32怪物的图片。
+- `heros.png` 为勇士行走图。
+- `items.png` 为所有道具的图标。
+- `npcs.png` 为所有NPC的图标。
+- `npc48.png` 为所有48x32的NPC图标。
+- `terrains.png` 为所有地形的图标。
+
+系统会读取`icon.js`文件，并获取每个ID对应的图标所在的位置。
+
+### 使用预定义的素材
+
+在images目录的“默认素材”下给定了若干预定义的自定义素材。
+
+如果你需要某个素材已经存在，则可以直接将其覆盖images目录下的同名文件，就能看到效果。
+
+### 背景和前景图层
+
+从V2.4.1开始，样板允许多个图层叠加，最多支持背景层、事件层和前景层三个图层。
+
+在地图编辑器中绘图时，下拉框选中“背景层”或“前景层”即可在对应的图层上绘图。
+
+其中背景层和前景层可以使用任何素材，以及使用自动元件（autotile）。
+
+可以使用`showBgFgMap`, `hideBgFgMap`, `setBgFgBlock`等事件对背景和前景图层进行操作。
+
+### 使用自己的图片作为某层楼的背景/前景素材
+
+由于HTML5功能（素材）有限，导致了对很多比较复杂的素材（比如房子内）等无法有着较好的绘图方式。
+
+为了解决这个问题，我们允许用户自己放置一张或多张图片作为某一层的背景/前景素材。
+
+要启用这个功能，我们首先需要在`data.js`中将可能的图片进行加载。
+
+``` js
+"images": [ // 在此存放所有可能使用的图片
+    // 图片可以被作为背景/前景图，也可以直接用自定义事件进行显示。
+    // 图片名不能使用中文，不能带空格或特殊字符；可以直接改名拼音就好
+    // 建议对于较大的图片，在网上使用在线的“图片压缩工具(http://compresspng.com/zh/)”来进行压缩，以节省流量
+    "bg.jpg", "house.png", "bed.png"// 依次向后添加
+];
+```
+
+!> 请使用网上的一些[在线图片压缩工具](http://compresspng.com/zh/)对图片进行压缩，以节省流量。
+
+之后，我们可以在每层剧本的`"images"`里来定义该层的默认背景/前景层的图片素材。
+
+从V2.5.4开始，贴图也允许进行帧动画，只要设置第五项的数值。
+
+``` js
+[[96,120,"bg.jpg",0]] // 背景图；你可以选择一张或多张图片来作为背景/前景素材。
+[] // 无任何背景图
+[[32,32,"house.png",0], [160,170,"bed.png",1]] // 在(32,32)放一个house.png在背景层，且(160,170)放bed.png在前景层
+[[96,120,"tree.png",2]] // 如果写2，则会自动调节遮挡效果
+[[64,0,"x.png",1,4]] // 这是一个前景层的4帧动画贴图
+```
+
+images为一个数组，代表当前层所有作为背景素材的图片信息。每一项为一个五元组，分别为该背景素材的x，y，图片名，遮挡方式和帧数。
+
+其中x和y分别为左上角的像素坐标；图片名则必须在全塔属性的images中定义过。
+
+第四项为遮挡方式，定义如下：
+
+- 0：该图片将全部画在背景层，被勇士所遮挡。举例：某些特殊地形等。
+- 1：该图片将全部画在前景层，可以遮挡勇士。举例：云彩等效果。
+- 2：该图片将上部分画在前景层，下部分画在背景层。从而可以达到一个“自动调节遮挡的效果”。举例：树、房子等等。
+
+!> 如果写2的话，最好让x，y和图片高度都是32的倍数！
+
+第五项为图片的帧数，可选。如果进行了设置，则会将该贴图视为帧动画，并切分成对应的帧数。
+
+例如，假设图片是100x100的，且帧数设为4，则视为四帧帧动画，每次绘制的图片大小实际上是25x100。
+
+关于楼层贴图和前景、背景层的层叠覆盖关系，默认是：**地板 - 背景贴图 - 背景图块 - 事件 - 勇士 - 前景贴图 - 前景图块**。
+
+可以通过修改`libs/maps.js`的`drawBg`和`drawFg`函数来改变其覆盖关系。
+
+``` js
+////// 绘制背景层 //////
+maps.prototype.drawBg = function (floorId, ctx) {
+    var onMap = ctx == null;
+    if (onMap) {
+        ctx = core.canvas.bg;
+        core.clearMap(ctx);
+    }
+    this._drawBg_drawBackground(floorId, ctx);
+    // ------ 调整这两行的顺序来控制是先绘制贴图还是先绘制背景图块；后绘制的覆盖先绘制的。
+    this._drawFloorImages(floorId, ctx, 'bg');
+    this._drawBgFgMap(floorId, ctx, 'bg', onMap);
+}
+```
+
+楼层贴图可以被事件隐藏和显示，详见[隐藏贴图](event#hideFloorImg：隐藏贴图)的写法。
+
+**如果要让贴图的某些点不可通行，则可以使用noPass或者空气墙。**
+
+!> 小技巧：可以使用帧动画贴图来贴一些大型怪物，比如魔龙、章鱼，或者《永不复还》中的恐怖利刃等等。如果使用帧贴图来贴怪物，则可以使用一个“透明的怪物”放置在对应位置并写上具体属性数值（这样就可以进行战斗和显伤了）；然后可以使用[displayIdInBook](element#怪物的朝向问题)在怪物手册中将该透明怪物映射到另一个有素材的怪物ID上。战斗完毕后使用[隐藏贴图](event#hideFloorImg：隐藏贴图)事件将贴图隐藏即可。
+
+### 使用便捷PS工具生成素材
+
+如果我们有更多的素材要求，我们可以使用“便捷PS工具”进行处理。
+
+![便捷PS工具](img/ps.png)
+
+我们可以打开有需求改变的素材，和我们需要被替换的素材，然后简单的Ctrl+C和Ctrl+V操作即可。
+
+便捷PS工具同样支持图片色相的修改，和RMXP几乎完全相同。
+
+用这种方式，我们能极快地替换或素材，包括需要新增的怪物。
+
+### 添加素材到游戏
+
+在使用地图编辑器编辑的过程中，我们有可能会出现“该数字和ID未被定义”的错误提示。
+
+这是因为，该素材没有被定义，无法被游戏所识别。
+
+!> 在V2.0中，我们可以简单的在地图编辑器中新增素材，以及定义新增素材的ID和数字，但是仍然**强烈建议**对素材的机制进行了解。
+
+#### 素材的机制
+
+本塔所有的素材都拥有三个属性：**ID**，**索引**，**数字**。
+- **ID** 为该素材的唯一标识符，任何两个素材的ID都不能相同。
+- **索引** 为该素材的在对应图片上的图标索引，即该素材是图片上的第几个。
+- **数字** 为该素材的对应数字，以方便地图的生成和存储。
+
+**`ID-索引` 对应关系定义在icons.js文件中。该文件将唯一确定一个ID在图片上所在的位置。**
+
+**`ID-数字` 对应关系定义在maps.js文件中。该文件将唯一确定一个ID对应的数字是多少。**
+
+在V2.0中，我们可以在地图编辑器中很方便查看每个图块的三个属性信息。
+
+#### 注册素材
+
+在V2.0的地图编辑器中，要注册新素材，我们只需要在图块属性一栏输入新素材的ID和数字。
+
+![素材注册](./img/register.png)
+
+ID必须由数字字母下划线组成，数字在1000以内，且均不能和已有的进行重复。
+
+之后刷新编辑器即可。
+
+我们也可以进行自动注册，只需要点击“自动注册”按钮，将对该栏下所有未注册的素材进行自动注册（自动分配ID和数字）。
+
+素材注册完毕后，即可在游戏中正常使用，也可以被地图生成器所识别（需要重开地图生成器）。
+
+#### Autotile自动元件的注册
+
+但是，通过上面这种方式，我们是没办法新增并注册Autotile的。
+
+除了替换样板现有的几个外，如果我们还需要新添加Autotile，则：
+
+1. 下拉框切到“追加素材”，导入文件到画板，然后导入一张Autotile自动元件图片。
+2. 下拉框选择autotile，然后点“追加”
+3. 看到成功的提示后刷新编辑器即可。
+
+### 额外素材
+
+从V2.4.2开始，HTML5魔塔样板开始支持额外素材。
+
+具体而言，通过上面的“素材导入”的方式，确实可以有效地添加素材到游戏。但是，如果想增加大量自定义素材，需要通过便捷PS工具将这些素材全部导入到`terrains.png`中，并且全部是单列，极度不友好。这也导致了野外风的制作相对变得很困难，增加了大量素材处理的工作量。
+
+额外素材就是为了解决这个问题而被提出。
+
+所谓`额外素材`，即用户可以自定导入任意张素材图片，无需PS，无需注册，即可直接在游戏中使用。这一点已经十分向RM靠拢了。
+
+要使用额外素材，请将你需要的素材图片放在`images`目录下，并在`全塔属性`的`tilesets`中定义图片名。
+
+**该素材的宽高必须都是32的倍数，且图片上的总图块数不超过1000（即最多有1000个32*32的图块在该图片上）。**
+
+```js
+// 在全塔属性中的tilesets导入素材
+"tilesets": ["1.png", "2.png"]    // 导入两个额外素材，文件名分别是1.png和2.png
+```
+
+刷新后，系统会自动加载该素材并添加到素材区。
+
+额外素材无需导入，无需注册。在`tilesets`中定义了图片后，即可直接使用绘图，无需再注册其数字和ID。其ID、索引和数字均为系统自动分配，且不允许修改。
+
+请注意，额外素材的ID、索引和数字，与该图片在tilesets数组中的index及该素材在图片上的位置都有关系。
+
+!> **因此如果对`tilesets`数组随意删除或修改顺序，可能会导致所有额外素材全部发生变化！这点请务必注意！！！**
+
+除此之外，额外素材在游戏中的使用和正式素材都是一致的，也能在前景或背景图层绘制。
+
+额外素材可以使用“tileset贴图”的方式进行绘制，一次绘制一个矩形区域。
+
+## 自定义道具效果
+
+本节中将继续介绍如何自己编辑一个道具的效果。
+
+道具效果的具体实现都在`items.js`中。
+
+### 即捡即用类道具（cls: items）
+
+对于即捡即用类道具，如宝石、血瓶、剑盾等，我们可以简单地修改`data.js`中的value一栏即可。
+
+如果你想要同种宝石在不同层效果不同的话，可以进行如下操作：
+
+1. 在楼层的item_ratio中定义宝石的比率（比如1-10的写1，11-20层写2等）
+2. 修改获得道具的itemEffect函数（编辑器中双击进行编辑）
+
+``` js
+// ratio为楼层的item_ratio值，可以进行翻倍宝石属性
+core.status.hero.atk += core.values.redJewel * ratio
+```
+
+这里我们可以直接写ratio来取用该楼层中定义的`item_ratio`的值。
+
+如果不是倍数增加（比如线性增加）也可以类似来写
+
+``` js
+// 一个二倍线性增加的例子
+core.status.hero.atk += core.values.redJewel + 2*ratio
+```
+
+### 消耗类道具（cls: tools）；永久类道具（cls: constants）
+
+如果要自己实现消耗类道具或永久类道具的使用效果，则需修改`items.js`中的canUseItem和useItem两个函数。
+
+具体过程比较复杂，需要一定的JS能力，在这里就不多说了，有需求可以找`艾之葵`进行了解。
+
+### 实战！拿到神圣盾后免疫吸血、领域、夹击效果
+
+1. 在itemEffect中修改拿到神圣盾时的效果，标记一个自定义Flag。
+``` js
+core.status.hero.def += core.values.shield5 * ratio;
+core.setFlag("shield5", true); // 增加一个自定义Flag：已经拿到神圣盾
+```
+2. 免疫吸血效果：在脚本编辑的getDamageInfo中，编辑成如果存在神圣盾标记，吸血伤害为0。
+``` js
+function (enemy, hero_hp, hero_atk, hero_def, hero_mdef, x, y, floorId) {
+// ... 上略
+    // 吸血
+    if (this.hasSpecial(mon_special, 11)) {
+        var vampireDamage = hero_hp * enemy.value;
+
+        // 如果有神圣盾免疫吸血等可以在这里写
+        // 也可以用hasItem或hasEquip来判断装备
+        if (core.hasFlag("shield5")) vampireDamage = 0; // 存在神圣盾，吸血伤害为0
+
+        vampireDamage = Math.floor(vampireDamage) || 0;
+        // 加到自身
+        if (enemy.add) // 如果加到自身
+            mon_hp += vampireDamage;
+
+        initDamage += vampireDamage;
+    }
+// ... 下略
+```
+3. 免疫领域、夹击、阻击效果：在2.4.1之后，可以直接将flag:no_zone设为true来免疫领域效果，其他几个同理。
+``` js
+// 写在获得道具后事件
+[
+    // 设置不同的flag可以分别无视对应的阻激夹域效果
+    {"type": "setValue", "name": "flag:no_zone", "value": "true"}, // 免疫领域
+    {"type": "setValue", "name": "flag:no_snipe", "value": "true"}, // 免疫阻击
+    {"type": "setValue", "name": "flag:no_laser", "value": "true"}, // 免疫激光
+    {"type": "setValue", "name": "flag:no_betweenAttack", "value": "true"}, // 免疫夹击
+]
+```
+4. 如果有更高的需求，例如想让吸血效果变成一半，则还是在上面这些地方进行对应的修改即可。
+
+## 新增门和对应的钥匙
+
+如果要新增一个门和对应的钥匙，需要进行如下几步：
+
+1. 在terrains.png中添加新的门的素材，并在地图编辑器中注册门的ID。该ID必须是以`Door`结尾，例如`abcDoor`。
+2. 在animates.png中添加开门的四格动画，然后直接打开icons.js文件，在animates下直接添加ID和索引信息，例如`'abcDoor': 34`。
+3. 在items.png中添加钥匙的素材，并在地图编辑器中注册钥匙的ID。该ID必须是和门对应且以`Key`结尾，例如`abcKey`。
+4. 该道具的cls应为`tools`，可以自行写道具描述，最下面几项均留`null`即可。
+
+!> **请勿在animates中对门的动画素材进行注册！而是请直接打开icons.js文件并添加ID和索引信息！！！**
+
+!> terrains和animates的门ID必须完全一致，且以`Door`结尾；所对应的钥匙ID应当是把`Door`换成`Key`，这样才能对应的上！
+
+## 覆盖楼传事件
+
+对于特殊的塔，我们可以考虑修改楼传事件来完成一些特殊的要求，比如镜子可以按楼传来切换表里。
+
+要修改楼传事件，需要进行如下两步：
+
+1. 重写楼传的点击事件。在插件中对`core.control.useFly进行重写`。详细代码参见[重写点击楼传事件](script#重写点击楼传事件)。
+2. 修改楼传的使用事件。和其他永久道具一样，在地图编辑器的图块属性中修改楼传的useItemEffect和canUseItemEffect两个内容。例如：
+``` js
+"useItemEffect": "core.insertAction([...])" // 执行某段自定义事件，或者其他脚本
+"canUseItemEffect": "true" // 任何时候可用
+```
+
+除了覆盖楼传事件外，对于快捷商店、虚拟键盘等等也可以进行覆盖，只不过是仿照上述代码重写对应的函数（`openQuickShop`,`openKeyBoard`）即可。
+
+## 自定义怪物属性
+
+如果你对现有的怪物不满意，想自行添加怪物属性也是可以的。具体参见脚本编辑的getSpecials。
+
+你需自己指定一个special数字，修改属性名和属性提示文字。后两者可以直接写字符串，或写个函数传入怪物。
+
+如果要修改伤害计算公式，请修改下面的getDamageInfo函数。请注意，如果无法战斗，该函数必须返回`null`。
+
+!> 如果改动了伤害计算公式，可能导致临界计算崩掉，因此建议将全塔属性中的`useLoop`置为true。
+
+对于毒衰弱怪物的战斗后结算在脚本编辑中的afterBattle函数中。
+
+对于领域、夹击、阻击怪物的检查在`control.js`中的checkBlock函数中。
+
+## 自定义快捷键
+
+如果需要绑定某个快捷键为处理一段事件，也是可行的。
+
+要修改按键，我们可以在脚本编辑的`onKeyUp`进行处理：
+
+比如，我们设置一个快捷键进行绑定，比如`Y`，其keycode是89。（有关每个键的keycode搜一下就能得到）
+
+然后在脚本编辑的`onKeyUp`函数的`switch`中进行处理。
+
+``` js
+case 89: // 使用该按键的keyCode，比如Y键就是89
+    // 还可以再判定altKey是否被按下，即 if (altKey) { ...
+
+    // ... 在这里写你要执行脚本
+    // **强烈建议所有新增的自定义快捷键均能给个对应的道具可点击，以方便手机端的行为**
+    if (core.hasItem('...')) {
+        core.status.route.push("key:0"); // 记录按键到录像中
+        core.useItem('...', true); // 第二个参数true代表该次使用道具是被按键触发的，使用过程不计入录像
+    }
+
+    break;
+```
+
+强烈建议所有新增的自定义快捷键均给个对应的永久道具可点击，以方便手机端的行为。
+
+使用`core.status.route.push("key:"+keyCode)`可以将这次按键记录在录像中。
+
+!> 如果记录了按键，且使用道具的话，需要将useItem的第二个参数设为true，避免重复记录！
+
+可以使用altKey来判断Alt键是否被同时按下。
+
+## 公共事件
+
+从V2.5.4开始，样板提供了“公共事件”下拉框，我们可以在里面用事件编辑器进行编辑，并通过`{"type":"insert"}`进行调用。
+
+![公共事件](./img/commonEvent.png)
+
+具体详见[插入公共事件或另一个地点的事件并执行](event#insert：插入公共事件或另一个地点的事件并执行)。
+
+当然，继续使用**插件**的写法也是可以的。
+
+## 插件系统
+
+在H5中，提供了“插件”系统。在V2.6中提供了一个插件下拉框，用户可以自行创建和写插件。
+
+在插件编写的过程中，我们可以使用任何[常见API](api)里面的代码调用；也可以通过`core.insertAction`来插入自定义事件执行。
+
+下面是一个很简单的例子，我编写一个插件函数，其效果是让勇士生命值变成原来的x倍，并令面前的图块消失。
+
+``` js
+this.myfunc = function(x) {
+    core.status.hero.hp *= x; // 勇士生命翻若干倍
+    core.insertAction([ // 自定义事件：令面前的图块消失。
+        {"type": "setValue", "name": "flag:x", "value": "core.nextX()"},
+        {"type": "setValue", "name": "flag:y", "value": "core.nextY()"},
+        {"type": "hide", "loc": ["flag:x", "flag:y"]}
+    ]);
+}
+```
+
+然后比如我们在某个道具的使用效果 `useItemEffect` 中写 `core.plugin.myfunc(2)` 即可调用此插件函数。也可以在战后事件或自定义脚本等位置来写。
+
+网站上也提供了一个[插件库](https://h5mota.com/plugins/)，欢迎大家把自己写的插件进行共享。
+
+从V2.6开始，在插件中用`this.xxx`定义的函数将会被转发到core中。例如上述的`myfunc`除了`core.plugin.myfunc`外也可以直接`core.myfunc`调用。
+
+详见[函数的转发](script#函数的转发)。
+
+## 标题界面事件化
+
+从V2.5.3开始，我们可以将标题界面的绘制和游戏开始用事件来完成。可以通过绘制画布、全塔属性，flags中的startUsingCanvas可以决定是否开启标题界面事件化。
+
+然后就可以使用“事件流”的形式来绘制标题界面、提供选项等等。
+
+在这里可以调用任意事件。例如，可以贴若干个图，可以事件切换楼层到某个剧情层再执行若干事件，等等。
+
+关于选项，样板默认给出的是最简单的choices事件；你也可以使用贴按钮图，循环处理+等待操作来定制自己的按钮点击效果。
+
+!> 开始游戏、读取存档、录像回放的效果已经默认给出，请不要修改或删减这些内容，以免出现问题。
+
+标题界面事件全部处理完后，将再继续执行startText事件。
+
+## 手机端按键模式
+
+从V2.5.3以后，我们可以给手机端增加按键了，这样将非常有利于技能的释放。
+
+用户在菜单栏打开“拓展键盘”后，在竖屏模式下点击工具栏，就会在工具栏按钮和快捷键模式之间进行切换。
+
+切换到快捷键模式后，可以点1-8，分别等价于在电脑端按键1-8。
+
+可以在脚本编辑的onKeyUp中定义每个快捷键的使用效果，比如使用道具或释放技能等。
+
+默认值下，1使用破，2使用炸，3使用飞，4使用其他存在的道具，5-8未定义。可以相应修改成自己的效果。
+
+也可以替换icons.png中的对应图标，以及修改main.js中`main.statusBar.image.btn1~8`中的onclick事件来自定义按钮和对应按键。
+
+非竖屏模式下、回放录像中、隐藏状态栏中，将不允许进行切换。
+
+## 自绘状态栏
+
+从V2.5.3开始允许自绘状态栏。要自绘状态栏，则应该打开全塔属性中的`statusCanvas`开关。
+
+自绘模式下，全塔属性中的`statusCanvasRowsOnMobile`将控制竖屏模式下的状态栏行数。
+
+开启自绘模式后，可以在脚本编辑的`drawStatusBar`中自行进行绘制。
+
+横屏模式下的状态栏为`129x416`（15x15则是`149x480`）；竖屏模式下的状态栏为`416*(32*rows+9)`（15x15是480）。
+
+具体可详见脚本编辑的`drawStatusBar`函数。
+
+## 自定义状态栏的显示项
+
+在V2.2以后，我们可以自定义状态栏背景图（全塔属性 - statusLeftBackground）等等。
+
+但是，如果我们还想新增其他项目的显示，比如攻速或者暴击，该怎么办？
+
+我们可以[自绘状态栏](#自绘状态栏)，或者采用下面两个方式之一来新增。
+
+### 利用已有项目
+
+一个最为简单的方式是，直接利用已有项目。
+
+例如，如果本塔中没有技能栏，则可以使用技能栏所对应的显示项。
+
+1. 覆盖project/icons.png中技能的图标
+2. 打开全塔属性的enableSkill开关
+3. 在脚本编辑-updateStatusBar中可以直接替换技能栏的显示内容
+
+```
+	// 设置技能栏
+	if (core.flags.enableSkill) {
+		// 替换成你想显示的内容，比如你定义的一个flag:abc。
+		core.setStatusBarInnerHTML('skill', core.getFlag("abc", 0));
+	}
+```
+
+### 额外新增新项目
+
+如果是在需要给状态栏新定义项目，则需要进行如下几个操作：
+
+1. 定义ID；比如攻速我就定义speed，暴击可以简单的定义baoji；你也可以定义其他的ID，但是不能和已有的重复。这里以speed为例。
+2. 在index.html的statusBar中（46行起），进行该状态栏项的定义。仿照其他几项，插在其应当显示的位置，注意替换掉相应的ID。
+``` html
+<div class="status" id="speedCol">
+    <img id="img-speed">
+    <p class='statusLabel' id='speed'></p>
+</div>
+```
+3. 在editor.html中的statusBar（383行起），仿照第二点同样添加；这一项如果不进行则会地图编辑器报错。editor-mobile.html同理。
+4. 使用便捷PS工具，打开project/icons.png，新增一行并将魔力的图标P上去；记下其索引比如37（从0开始数）。
+5. 在main.js的this.statusBar中增加图片、图标和内容的定义。
+``` js
+this.statusBar = {
+    'images': {
+        // ...其他略
+        'speed': document.getElementById("img-speed"), // 图片的定义
+    },
+    'icons': {
+        // ...其他略
+        'speed': 37, // 图标的定义，这里对应的是icons.png中的索引
+    },
+    // ...其他略
+    'speed': document.getElementById('speed'), // 显示内容（数据）的定义
+}
+```
+6. 显示内容的设置。在脚本编辑的updateStatusBar函数，可以对该状态栏显示内容进行设置，下面是几个例子。
+``` js
+// 设置其显示内容为status:speed值；需要在project/data.js中firstData的hero那里新增初始值`"speed": 0`。
+core.statusBar.speed.innerHTML = core.getStatus('speed');
+// 设置其显示内容为flag:speed值，无需额外进行定义。
+core.statusBar.speed.innerHTML = core.getFlag('speed', 0);
+```
+
+## 技能塔的支持
+
+要支持技能塔，可能需要如下几个方面：
+
+从V2.5开始，内置了"二倍斩"技能，可以仿照其制作自己的技能。
+
+- 魔力（和上限）的添加；技能的定义
+- 状态栏的显示
+- 技能的触发（按键与录像问题）
+- 技能的效果
+
+### 魔力的定义添加；技能的定义
+
+从V2.5开始，提供了status:mana选项，可以直接代表当前魔力值。
+
+如果要启用，需要开启全塔属性的enableMana选项。
+
+如果需要魔力上限，则可以使用flag:manaMax来表示当前的魔力最大值。
+
+同时，我们可以使用flag:skill表示当前开启的技能编号，flag:skillName表示当前开启的技能名称。
+
+如果flag:skill不为0，则代表当前处于某个技能开启状态，且状态栏显示flag:skillName值。伤害计算函数中只需要对flag:skill进行处理即可。
+
+!> 关于魔力上限：样板中默认没有提供status:manamax
+
+### 状态栏的显示
+
+从V2.5开始，魔力值和技能名的状态栏项目已经被添加，可以直接使用。
+
+在脚本编辑-updateStatusBar中，可以对状态栏显示内容进行修改。
+
+``` js
+// 设置魔力值
+if (core.flags.enableMana) {
+    // status:manamax 只有在非负时才生效。
+    if (core.status.hero.manamax != null && core.status.hero.manamax >= 0) {
+        core.status.hero.mana = Math.min(core.status.hero.mana, core.status.hero.manamax);
+        core.setStatusBarInnerHTML('mana', core.status.hero.mana + "/" + core.status.hero.manamax);
+    }
+    else {
+        core.setStatusBarInnerHTML("mana", core.status.hero.mana);
+    }
+}
+// 设置技能栏
+if (core.flags.enableSkill) {
+    // 可以用flag:skill表示当前开启的技能类型，flag:skillName显示技能名
+    core.statusBar.skill.innerHTML = core.getFlag('skillName', '无');
+}
+```
+
+### 技能的触发
+
+#### 使用道具作为技能
+
+由于手机端按键十分不方便，虚拟键盘不好用，因此强烈推荐**给每个技能设置一个道具图标，在道具栏点击使用！**
+
+下面是个很简单的例子，要制作一个技能"二倍斩"。
+
+我们可以设置一个道具，其cls是`constants`（永久道具），ID比如是`skill1`。
+
+该道具的使用判定`canUseItemEffect`是`true`（表示任意时候都可使用），使用效果`useItemEffect`是：
+
+``` js
+if (core.getFlag('skill', 0)==0) { // 判断当前是否已经开了技能
+    if (core.getStatus('mana')>=5) { // 这里要写当前能否开技能的条件判断，比如魔力值至少要多少
+        core.setFlag('skill', 1); // 开技能1
+        core.setFlag('skillName', '二倍斩'); // 设置技能名
+    }
+    else {
+        core.drawTip("魔力不足，无法开技能");
+    }
+}
+else { // 关闭技能
+    core.setFlag('skill', 0); // 关闭技能状态
+    core.setFlag('skillName', '无');
+}
+```
+
+简单的说，用flag:skill判断当前开启的技能，flag:skillName表示该技能名。（可在状态栏显示）
+
+该（技能）道具任何时候都可被使用；使用时，判断当前是否开启了技能，如果开启则关闭，没开则再判断是否允许开启（魔力值够不够等）。
+
+#### 快捷键触发技能
+
+在PC端，我们还可以按键触发技能。
+
+在技能的道具定义完毕后，再将该道具绑定到一个快捷键上。有关绑定按键请参见[自定义快捷键](#自定义快捷键)。
+
+下面是一个很简单的例子，当勇士按下W后，触发我们上面定义的二倍斩技能。
+
+``` js
+case 87: // W：开启技能“二倍斩”
+    // 检测技能栏是否开启，是否拥有“二倍斩”这个技能道具
+    if (core.flags.enableSkill && core.hasItem('skill1')) {
+        core.status.route.push("key:87");
+        core.useItem('skill1', true);
+    }
+    break;
+```
+
+在勇士处于停止的条件下，按下W键时，判断技能的道具是否存在，如果存在再使用它。
+
+!> 由于现在手机端存在拓展键盘，也强烈建议直接覆盖1-8的使用效果，这样手机端使用也非常方便。
+
+### 技能的效果
+
+最后一点就是技能的效果；其实到了这里就和RM差不多了。
+
+技能的效果要分的话有地图类技能，战斗效果类技能，后续影响类技能什么的，这里只介绍最简单的战斗效果类技能。
+
+其他的几类技能根据需求可能更为麻烦，有兴趣可自行进行研究。
+
+战斗效果内技能要改两个地方：战斗伤害计算，战后扣除魔力值。
+
+战斗伤害计算在脚本编辑的`getDamageInfo`函数，有需求直接修改这个函数即可。
+
+战后扣除魔力值则在脚本编辑的`afterBattle`中进行编辑即可。
+
+举个例子，我设置一个勇士的技能：二倍斩，开启技能消耗5点魔力，下一场战斗攻击力翻倍。
+
+那么，直接在脚本编辑的`getDamageInfo`中进行判断：
+
+``` js
+if (core.getFlag('skill', 0)==1) { // 开启了技能1
+    hero_atk *= 2; // 计算时攻击力翻倍
+}
+```
+
+然后在脚本编辑的`afterBattle`中进行魔力值的扣除：
+
+``` js
+// 战后的技能处理，比如扣除魔力值
+if (core.flags.enableSkill) {
+    // 检测当前开启的技能类型
+    var skill = core.getFlag('skill', 0);
+    if (skill==1) { // 技能1：二倍斩
+        core.status.hero.mana-=5; // 扣除5点魔力值
+    }
+    // 关闭技能
+    core.setFlag('skill', 0);
+    core.setFlag('skillName', '无');
+}
+```
+
+!> 开启技能后，建议将全塔属性的useLoop置为true，即改用循环计算临界值，这样临界计算才不会出问题！
+
+&nbsp;
+
+通过上述这几种方式，我们就能成功的让H5支持技能啦！
+
+## 系统使用的flag变量
+
+众所周知，自定义flag变量都可以任意定义并取用（未定义直接取用的flag默认值为0）。
+
+下面是一些可能会被系统设置或取用的flag变量：
+
+- **`flag:hard`**: 当前的难度标志；此flag变量在setInitData中被定义，可以直接取用来判定当前难度分歧。上传成绩时将根据此flag来对不同难度进行排序。
+- **`flag:posion`**, **`flag:weak`**, **`flag:curse`**: 中毒、衰弱、诅咒状态。
+- **`flag:no_zone`**, **`flag:no_snipe`**, **`flag:no_laser`**, **`flag:no_betweenAttack`**: 是否分别免疫领域、阻击、激光、夹击效果。
+- **`flag:hatred`**: 当前的仇恨数值。
+- **`flag:commonTimes`**: 全局商店共用次数时的访问次数。
+- **`flag:input`**: 接受用户输入的事件后，存放用户输入的结果。
+- **`flag:type`**, **`flag:keycode`**, **`flag:x`**, **`flag:y`**, **`flag:px`**, **`flag:py`**: 等待用户操作后，用户的操作类型，按键keycode或点击/像素坐标。
+- **`flag:skill`**, **`flag:skillName`**: 开启的技能编号和技能名。
+- **`flag:heroIcon`**: 当前的勇士行走图名称。
+- **`flag:saveEquips`**: 快速换装时保存的套装。
+- **`flag:__visited__`**: 当前访问过的楼层。
+- **`flag:__atk_buff__`**, **`flag:__def_buff__`**, **`flag:__mdef_buff__`**: 当前攻防魔防的实际计算比例加成。
+- **`flag:__color__`**, **`flag:__weather__`**, **`flag:__volume__`**: 当前的画面色调、天气和音量。
+- **`flag:__events__`**: 当前保存的事件列表，读档时会恢复（适用于在事件中存档）
+- **`flag:textAttribute`**, **`flag:globalAttribute`**, **`flag:globalFlags`**: 当前的剧情文本属性，当前的全局属性，当前的全局开关。
+- **`flag:cannotMoveDirectly`**, **`flag:__noClickMove__`**: 当前是否不允许瞬间移动，当前用户是否开启了单击瞬移。
+- **`flag:hideStatusBar`**, **`flag:showToolbox`**: 是否隐藏状态栏，是否显示工具栏。
+- **`flag:debug`**, **`flag:__consoleOpened__`**: 当前是否开启了调试模式，是否开启了控制台。
+- **`flag:__seed__`**, **`flag:__rand__`**: 伪随机数生成种子和当前的状态
+
+==========================================================================================
+
+[继续阅读脚本](script)
diff --git a/_docs/script.md b/_docs/script.md
new file mode 100644
index 00000000..c6d0aeff
--- /dev/null
+++ b/_docs/script.md
@@ -0,0 +1,354 @@
+# 脚本
+
+?> 目前版本**v2.6.1**，上次更新时间：* {docsify-updated} *
+
+在V2.6版本中，基本对整个项目代码进行了重写，更加方便造塔者的使用和复写函数。
+
+## 控制台的使用
+
+在Chrome浏览器中，按（Ctrl+Shift+I）可打开控制台。
+
+![](img/console.jpg)
+
+控制台中有很多的标签，最常用的是`Console`, `Sources`和`Elements`。
+
+有关更详尽的控制台使用可自行搜索[Chrome开发者工具](https://www.baidu.com/s?wd=chrome%20%E5%BC%80%E5%8F%91%E8%80%85%E5%B7%A5%E5%85%B7)了解更多。
+
+### Console：命令行
+
+Console页为命令行。可以在这里输入一些命令进行调试。
+
+比如，进入游戏后，输入`core.status.hero.atk`即可获得勇士的当前攻击力数值。`core.status.hero.atk=100`可以设置攻击力为100。
+
+更多的API可参见[附录：API列表](#附录：API列表)。
+
+除此以外，游戏中的报错等信息也是可以在Console中进行查看的。
+
+![](img/console1.jpg)
+
+### Sources：断点调试
+
+Sources页可以查看JS源代码，并进行断点调试等。
+
+例如，如果相对脚本编辑中的伤害计算函数进行断点调试：
+1. 在左边找到`project/functions.js`，单击打开文件
+2. 并找到对应的行（可以Ctrl+F搜索），比如搜索`getDamageInfo`
+3. 在行号上点一下打断点，会出现一个蓝色标签
+
+之后，当代码运行到你的断点处时，将自动停止运行。
+
+![](img/sources.jpg)
+
+可以将鼠标移动到变量上，将弹窗形式显示这个变量的各项数值，从而查看变量值是否符合预期。
+
+图中红色框内有几个按钮，从左到右分别是：**继续执行**，**执行到下一行**，**进入当前函数**，**跳出当前函数**，**单步执行**。
+
+通过这几个按钮，可以一行一行的对代码进行执行，执行过程中能不断查看各个变量的数值变化，从而定位问题所在。
+
+红圈下方是Call Stack，即当前的函数调用链（从哪些地方调用过来的）。
+
+Sources还有更多有趣的功能，在此不做介绍，有兴趣的可自行网上搜索了解。
+
+### Elements：网页元素查看
+
+Elements页可以查看网页的源代码，调整css布局等。
+
+![](img/elements.jpg)
+
+不过对魔塔样板来说，最重要的是红圈中的按钮。点击此按钮可以进入**手机模式**。
+
+手机模式下，左边可以对屏幕分辨率进行调整和模拟。
+
+这可以很有效的帮我们进行测试样板在手机端的表现。
+
+## 整体项目架构
+
+``` text
+├── /_server/        # 为可视化地图编辑器提供一些支持的目录
+├── /libs/           # ---- 系统库目录 ----
+│ ├─ /thirdparty/    # 游戏所用到的第三方库文件
+│ ├─ actions.js      # 用户交互处理
+│ ├─ core.js         # 系统核心文件（游戏入口，接口&转发）
+│ ├─ control.js      # 游戏逻辑控制
+│ ├─ data.js         # 全塔属性等
+│ ├─ enemys.js       # 怪物相关处理
+│ ├─ events.js       # 各个事件的执行
+│ ├─ icons.js        # 图标和素材
+│ ├─ items.js        # 道具效果
+│ ├─ loader.js       # 各个资源加载
+│ ├─ maps.js         # 地图数据和绘制
+│ ├─ ui.js           # UI窗口绘制
+│ └─ utils.js        # 工具类函数
+├── /project/        # ---- 项目目录 ----
+│ ├─ /animates/      # 动画目录
+│ ├─ /floors/        # 楼层文件
+│ ├─ /images/        # 图片素材
+│ ├─ /sounds/        # bgm和音效
+│ ├─ data.js         # 全塔属性
+│ ├─ enemys.js       # 怪物属性
+│ ├─ events.js       # 公共事件
+│ ├─ functions.js    # 脚本编辑
+│ ├─ icons.js        # 素材和ID的对应关系定义
+│ ├─ items.js        # 道具的定义和效果
+│ ├─ maps.js         # 地图和数字的对应关系
+│ └─ plugins.js      # 自定义插件
+├── /常用工具/        # 辅助造塔的小工具
+├── editor.html      # 地图编辑器
+├── editor-mobile.html      # 手机版的地图编辑器
+├── index.html       # 主程序，游戏的入口
+├── main.js          # JS程序的入口，将动态对所需JS进行加载
+├── style.css        # 游戏所需要用到的样式表
+└── 启动服务.exe      # 一个本地的HTTP服务器，通过它来运行游戏
+```
+
+`_server`为**地图编辑器目录**，里面存放了地图编辑器相关的各项内容。
+
+`libs`为**系统库目录**，里面存放了各个系统核心函数。
+
+从V2.6开始，请勿直接修改libs下的代码，如有需要修改系统库函数请尝试在插件中[复写函数](#复写函数)。
+
+`project`为**项目目录**，你所造的塔的数据全部存放在project下。在不同样板之间接档也是直接迁移project目录即可。
+
+## 函数的转发
+
+在本样板中，`core.js`里面基本是没有定义什么函数的，所有的游戏内函数都在其他几个文件中实现。
+
+例如，常见的获得某个变量值`getFlag`是定义在`control.js`中的：
+
+```js
+////// 获得某个自定义变量或flag //////
+control.prototype.getFlag = function(name, defaultValue) {
+    if (!core.status.hero) return defaultValue;
+    var value = core.status.hero.flags[name];
+    return value != null ? value : defaultValue;
+}
+```
+
+也就是，我们可以通过`core.control.getFlag(name, value)`来调用此函数。
+
+但是这样会十分不便，我们希望能直接调用`core.getFlag(name, value)`，而不需要中间的control。
+
+为了达到这个目的，样板设置了**函数转发**，即**将其他文件中定义的函数，转发到core中执行**。
+
+上述`getFlag`代码的转发实际上是增加了如下函数：
+
+```js
+////// getFlag函数的转发 //////
+core.getFlag = function (name, defaultValue) {
+    return core.control.getFlag(name, defaultValue);
+}
+// 转发后，即可通过 core.getFlag() 来实际调用 core.control.getFlag()
+```
+
+转发是自动完成的，其满足如下两条规则：
+- **在libs中其他文件定义的函数，如果不以下划线`_`开头，就会进行转发。**
+- **如果core中已经存在同名函数，则会在控制台中打出一条报错信息，并不转发该函数。**
+
+具体函数的转发实现代码可参见`core.js`的`_forwardFunc`函数。
+
+!> 除此以外，插件中以`this.xxx`来定义的函数也会被转发！
+
+例如，你可以直接调用`core.drawLight()`来实际调用插件中的`core.plugin.drawLight`。
+
+## 插件编写
+
+插件编写是H5魔塔的一个重大特点，从V2.0.1引入，并逐渐发扬光大。
+
+对于有一定脚本经验的人来说，可以编写插件来实现各种各样的功能，包括且不仅限于拓展功能的实现，系统代码的复写等等。
+
+在V2.5.5以前，插件位置都在脚本编辑中；从V2.6开始则迁移到了新的下拉框中，并进行了切分。
+
+你也可以创建自己的插件。
+
+![](img/plugin.jpg)
+
+新的插件切分和原来的单插件使用方法完全一致，单纯进行了切分而已。可参见已有的`init`和`drawLight`的样例。
+
+拆分的意义主要是将各个可能的功能独立出来，避免单个框内内容太长，过大和混杂等。
+
+在V2.6中，应当每个独立的额外功能实现都新建一个自己的插件，这样也方便进行拓展，例如打包迁移到别的塔上，或发布在网页插件库中。
+
+另外一点需要注意的是，所有插件的初始化都会在系统资源加载之前，此时图片等资源尚未进行加载。
+
+在所有资源加载完毕时，将会执行init插件中的_afterLoadResources函数，可以在这里对资源进行一些操作，比如切分图片等。
+
+```js
+function () {
+	console.log("插件编写测试");
+
+	// 可以写一些直接执行的代码
+	// 在这里写的代码将会在【资源加载前】被执行，此时图片等资源尚未被加载。
+	// 请勿在这里对包括bgm，图片等资源进行操作。
+
+
+	this._afterLoadResources = function () {
+		// 本函数将在所有资源加载完毕后，游戏开启前被执行
+		// 可以在这个函数里面对资源进行一些操作，比如切分图片等。
+
+		// 这是一个将assets.png拆分成若干个32x32像素的小图片并保存的样例。
+		// var arr = core.splitImage("assets.png", 32, 32);
+		// for (var i = 0; i < arr.length; i++) {
+		//     core.material.images.images["asset"+i+".png"] = arr[i];
+		// }
+
+	}
+
+	// 可以在任何地方（如afterXXX或自定义脚本事件）调用函数，方法为 core.plugin.xxx();
+	// 从V2.6开始，插件中用this.XXX方式定义的函数也会被转发到core中，详见文档-脚本-函数的转发。
+}
+```
+
+网站上提供了一个插件库，[https://h5mota.com/plugins/](https://h5mota.com/plugins/)，上面有一些大家分享的插件，可供使用。
+
+可以查看附录中的[API列表](api)来查看所有的系统API内容。
+
+## 复写函数
+
+样板的功能毕竟是写死的，有时候我们也需要修改样板的一些行为。
+
+在V2.6以前，需要直接打开libs目录下的对应文件并进行修改。但是开libs下的文件就会出现各种问题：
+
+- 不容易记得自己修改过什么，而且如果改错了很麻烦
+  - 例如，直接修改了某函数加了新功能，结果过段时间发现不需要，想删掉，但是这时候已经很难找到自己改过了什么了。
+  - 或者，如果代码改错了，不断往上面打补丁，也只会使得libs越来越乱，最后连自己做过什么都不记得。
+- 不容易随着新样板接档进行迁移
+- 不方便能整理成新的插件在别的塔使用（总不能让别的塔也去修改libs吧）
+- ……
+
+好消息的是，从V2.6开始，我们再也不需要开文件了，而是可以直接在插件中对原始函数进行复写。
+
+函数复写的好处如下：
+
+- 不会影响系统原有代码。
+  - 即使写错了或不需要了，也只用把插件中的函数注释或删除即可，不会对原来的系统代码产生任何影响。
+- 清晰明了。很容易方便知道自己修改过什么，尤其是可以和系统原有代码进行对比。
+- 方便整理成新的插件，给其他的塔使用。
+
+一般而言，复写规则如下：
+
+**对xxx文件中的yyy函数进行复写，规则是`core.xxx.yyy = function (参数列表) { ... }`。**
+
+但是，对于`registerXXX`所注册的函数是无效的，例如直接复写`core.control._animationFrame_globalAnimate`函数是没有效果的。对于这种情况引入的函数，需要注册同名函数，可参见最下面的样例。
+
+下面是几个例子，从简单到复杂。
+
+### 重写怪物手册的背景图绘制，使用winskin而不是默认的黑色
+
+直接重写怪物手册的背景图绘制，使用`core.drawBackground`来用winskin绘制一个背景图。
+
+```js
+// 重写ui.js中的_drawBook_drawBackground函数
+core.ui._drawBook_drawBackground = function () {
+    // core.__PIXELS__为定义的一个宏，对于13x13的值是416，对于15x15的值是480
+    core.drawBackground(0, 0, core.__PIXELS__, core.__PIXELS__);
+}
+```
+
+### 重写点击楼传事件
+
+重写点击楼传事件，使得点击楼传按钮时能使用一个道具（比如item:fly）。
+
+```js
+// 重写events.js的useFly函数，即点击楼传按钮时的事件
+core.events.useFly = function (fromUserAction) {
+    if (core.isMoving()) {
+        core.drawTip("请先停止勇士行动");
+        return;
+    }
+    if (core.status.lockControl || core.status.event.id != null) return;
+    
+    if (core.canUseItem('fly')) core.useItem('fly');
+    else core.drawTip("当前无法使用"+core.material.items.fly.name);
+}
+```
+
+其他的几个按钮，如快捷商店`openQuickShop`，虚拟键盘`openKeyBoard`的重写也几乎完全一样。
+
+### 楼层切换时根据flag来播放不同的音效
+
+整体复制并重写整个楼传切换前的函数，将`core.playSound('floor.mp3')`替换成根据flag来判定。
+
+```js
+// 复制重写events.js中的_changeFloor_beforeChange，修改音效
+core.events._changeFloor_beforeChange = function (info, callback) {
+    // 直接替换原始函数中的 core.playSound('floor.mp3'); 
+    if (core.getFlag("floorSound") == 0) core.playSound('floor0.mp3');
+    if (core.getFlag("floorSound") == 1) core.playSound('floor1.mp3');
+    if (core.getFlag("floorSound") == 2) core.playSound('floor2.mp3');
+    // ...
+    
+    // 下面是原始函数中的剩余代码，保持不变
+    window.setTimeout(function () {
+        if (info.time == 0)
+            core.events._changeFloor_changing(info, callback);
+        else
+            core.showWithAnimate(core.dom.floorMsgGroup, info.time / 2, function () {
+                core.events._changeFloor_changing(info, callback);
+            });
+    }, 25)
+}
+```
+
+### 每次打开全局商店时播放一个音效
+
+打开全局商店是在`events.js`中的`openShop`函数，因此需要对其进行重写。
+
+然而，我们只需要在这个函数执行之前插一句音效播放，所以并不需要重写整个函数，而是直接插入一行就行。
+
+```js
+var openShop = core.events.openShop; // 先把原始函数用一个变量记录下来
+core.events.openShop = function (shopId, needVisited) {
+    core.playSound("shop.mp3"); // 播放一个音效
+    return openShop(shopId, needVisited); // 直接调用原始函数
+}
+```
+
+### 每次绘制地图前在控制台打出一条信息 
+
+绘制地图在`maps.js`的`drawMap`函数，因此需要对其进行重写。
+
+由于只需要额外在函数执行前增加一句控制台输出，所以直接插入一行即可。
+
+但是需要注意的是，`drawMap`中使用了`this._drawMap_drawAll()`，因此使用函数时需要用`call`或者`apply`来告知this是什么。
+
+```js
+var drawMap = core.maps.drawMap; // 先把原始函数用一个变量记录下来
+core.maps.drawMap = function (floorId, callback) {
+    console.log("drawMap..."); // 控制台打出一条信息
+    return drawMap.call(core.maps, floorId, callback); // 需要使用`call`来告知this是core.maps
+}
+```
+
+详见[call和apply的用法](https://www.jianshu.com/p/80ea0d1c04f8)。
+
+### 复写全局动画绘制函数
+
+全局动画绘制在`control.js`的`_animationFrame_globalAnimate`函数。
+
+注意到此函数是由`registerAnimationFrame`注册的，因此直接复写是无效的。
+
+其在control.js的注册的定义如下：
+
+```js
+// 注册全局动画函数
+this.registerAnimationFrame("globalAnimate", true, this._animationFrame_globalAnimate);
+```
+
+因此，可以在插件中自行注册一个**同名**的函数来覆盖原始的内容。
+
+```js
+// 插件中复写全局动画绘制函数
+this.myGlobalAnimate = function (timestamp) {
+    // ...... 实际复写的函数内容
+}
+
+// 注册同名（globalAnimate）函数来覆盖系统原始内容
+core.registerAnimationFrame("globalAnimate", true, "myGlobalAnimate");
+```
+
+
+==========================================================================================
+
+[继续阅读下一章：API列表](api)
+
+
diff --git a/docs/start.md b/_docs/start.md
similarity index 82%
rename from docs/start.md
rename to _docs/start.md
index 6ab94659..87319f4c 100644
--- a/docs/start.md
+++ b/_docs/start.md
@@ -1,6 +1,6 @@
 # 快速上手
 
-?> 目前版本**v2.3.3**，上次更新时间：* {docsify-updated} *
+?> 目前版本**v2.6.1**，上次更新时间：* {docsify-updated} *
 
 在这一节中，将详细介绍做一部塔的流程。现在，让我们来做一部单层塔！
 
@@ -10,6 +10,7 @@
 
 - Windows 8以上操作系统；Windows 7需要安装.Net Framework 4.0。（能打开同目录下的“启动服务.exe”即可）
   - Mac系统则需OS X 10.7及以上，能正确打开启动服务(Mac版).app即可。
+  - 安卓手机端需要下载最新版的HTML5安卓造塔器。
 - Chrome浏览器。其他浏览器可能会导致本地服务器产生闪退等现象。
 - 强烈推荐安装一个很好的文本编辑器：VSCode。在某些需要直接修改文件的场合，可能会非常重要。
 
@@ -19,7 +20,7 @@
 
 ## 启动HTTP服务
 
-在根目录下有一个“启动服务.exe”，运行之。（Mac版本则双击运行“启动服务(Mac版).app”）
+在根目录下有一个“启动服务.exe”，运行之。（Mac版本则双击运行“启动服务(Mac版).app”，手机端则使用造塔APP。）
 
 ![启动服务](img/server.png)
 
@@ -27,6 +28,7 @@
 * “地图编辑器”允许你以可视化的方式进行编辑地图。
 * “便捷PS工具”能让你很方便的对自定义素材进行添加。参见[自定义素材](personalization#自定义素材)。
 * “地图生成器”能让你从已有的截图（如RMXP项目）中立刻生成可被本样板识别的地图数据。
+* “怪物数据导出”能让你从RMXP中导出怪物数据而被H5魔塔使用。
 * “RM动画导出器”能让你从RMXP中导出动画而被H5魔塔使用。
 * “JS代码压缩工具”能对JS代码进行压缩，从而减少IO请求数和文件大小。
 * “伤害和临界值计算器”是一个很便捷的小工具，能对怪物的伤害和临界值进行计算。
@@ -49,19 +51,25 @@
 
 绘制地图时可以右键弹出菜单，移动图块和事件。
 
+从V2.4.2开始，可以使用`Alt+0~9`对一个图块素材快速保存，`Ctrl+0~9`来快速选用。
+
 ### 从RMXP导入已有的地图
 
+!> 注：现在已经不推荐此方法，如需从RM刻塔请使用 [RM转H5刻塔器使用教程](https://www.bilibili.com/video/av43125840) 进行操作。
+
 如果我们想复刻一个现有的，已经被RMXP所制作的塔，也有很便捷的方式，那就是用到我们的“地图生成器”。
 
 首先，我们打开RMXP和对应的项目，可以看到它的地图。
 
 ![绘制地图](./img/rmxp2.png)
 
-我们打开Windows自带的“截图工具”，并将整个地图有效区域截图下来，并将其复制到剪切板。
+我们打开地图编辑器，创建一个地图，宽高需要和RM中的地图一致。
+
+之后，我们打开Windows自带的“截图工具”，并将整个地图有效区域截图下来，并将其复制到剪切板。
 
 ![绘制地图](./img/rmxp3.png)
 
-截图时请注意：**只截取有效游戏空间内数据，并且有效空间内的范围必须是13x13。（如果地图小于13*13，请用星空或墙壁填充到13x13）。**
+截图时请注意：**只截取有效游戏空间内数据，并且有效空间内的范围必须是创建的地图的大小（至少为13x13）。**
 
 确认地图的图片文件已经复制到剪切板后，我们打开“地图生成器”，并点“加载图片”。大约1-2秒后，可以得到地图的数据。
 
@@ -71,7 +79,9 @@
 
 !> **地图生成器默认只支持已被定义的素材。如果有自定义素材需求（例如原版的1层小塔那种素材），请先[导入并注册素材](#素材注册)后再进行操作。**  
 
-!> **请确保截图范围刚好为13x13，并且保证每个位置的像素都是32x32。**
+!> **请确保截图范围为你创建的地图大小，并且保证每个位置的像素都是32x32。**
+
+!> **如果宽度超过13，地图生成器将无法显示完全，但是仍然可以粘贴到地图编辑器中进行修改。**
 
 !> **地图生成器靠左上角来确定偏移量，如果左上角是全黑或者星空之类的素材可能导致识别不准，此时请在左上角放置一个岩浆后再进行截图识别。**
 
@@ -169,10 +179,20 @@
 
 之后刷新编辑器即可。
 
-对于怪物和道具，我们也可以进行自动注册，只需要点击“自动注册”按钮，将对该栏下所有未注册的素材进行自动注册（自动分配ID和数字）。
+也可以进行自动注册，只需要点击“自动注册”按钮，将对该栏下所有未注册的素材进行自动注册（自动分配ID和数字）。
 
 素材注册完毕后，即可在游戏中正常使用，也可以被地图生成器所识别（需要重开地图生成器）。
 
+### 额外素材
+
+从2.4.2开始，H5魔塔样板支持额外素材，你可以导入任意个类似RM中的tilesets文件，且无需注册即可使用。
+
+要使用额外素材，请在`全塔属性`中的`tilesets`项，添加额外素材的图片名称，刷新后即可在地图编辑器中使用。
+
+额外素材不可注册，其数字、ID和索引都是和该图块在图片上的位置相关，不可编辑。
+
+有关额外素材的更多说明参见[额外素材](personalization#额外素材)
+
 ## 控制台调试
 
 HTML5的塔都是可以进行控制台调试的。
@@ -197,20 +217,34 @@ HTML5的塔都是可以进行控制台调试的。
 - `core.getItem('pickaxe', 2)` 令勇士获得两个破墙镐。
 - `core.itemCount('pickaxe')` 返回勇士某个道具的个数。
 - `core.hasItem('pickaxe')` 返回勇士是否拥有某个道具。等价于`core.itemCount('pickaxe')!=0`。
+- `core.getEquip(0)` 返回0号装备类型（武器）的当前装备的itemId，不存在则返回null
+- `core.hasEquip('sword1')` 返回某个装备当前是否处于被装备状态
 - `core.setFlag('xxx', 1)` 设置某个flag/自定义变量的值。
 - `core.getFlag('xxx', 10)` 获得某个flag/自定义变量的值；如果该项不存在（未被定义），则返回第二个参数的值。
 - `core.hasFlag('xxx')` 返回是否存在某个变量且不为0。等价于`core.getFlag('xxx', 0)!=0`。
+- `core.removeFlag('xxx')` 删除某个flag/自定义变量
 - `core.insertAction(list)` 执行一段自定义事件。比如 `core.insertAction(["剧情文本"])` 将执行一个剧情文本显示事件。
 - `core.changeFloor('MT2', 'downFloor')` 立刻执行楼层切换到MT2层的下楼点位置。
 - `core.changeFloor('MT5', null, {'x': 4, 'y': 7})` 立刻切换楼层到MT5层的(4,7)点。
 - `core.getBlock(3, 5, 'MT1')` 获得当前地图上某一个块的信息。第三个参数为floorId，可省略表示当前楼层。
 - `core.getBlockId(3, 5, 'MT1')` 获得当前地图上某一个点的图块ID。第三个参数为floorId，可省略表示当前楼层。
-- `core.resetMap()` 重置当前层地图。**当修改地图后再读档，修改的地图不会立刻生效，此时可以使用resetMap来重置当前楼层的地图。**
-- `localStorage` 获得所有的存档数据。可以用 `core.getLocalStorage('save1')` 来具体获得某个存档。
+- `core.resetMap()` 重置当前层地图。
 - ……
 
 更多API和详细参数介绍可参见[API列表](api)。
 
+## 编辑器的基本操作
+
+- **Alt+0~9, Ctrl+0~9** 保存和读取当前选中图块
+- **W/A/S/D** 移动大地图
+- **Ctrl+Z** 撤销上次绘图
+- **Ctrl+Y** 重做上次绘图
+- **PgUp/PgDn** 切换楼层
+- **Ctrl+S** 保存事件编辑器/脚本编辑器
+- **地图上单击** 选中该点
+- **地图上双击** 选中该点图块
+- **地图上右键** 弹出菜单栏，包括选中、复制、清除等操作
+- **事件编辑器中Ctrl+C, Ctrl+X, 右键等** 执行相应操作
 
 ## 报错处理
 
diff --git a/_server/CodeMirror/LICENSE b/_server/CodeMirror/LICENSE
index ff7db4b9..a139012a 100644
--- a/_server/CodeMirror/LICENSE
+++ b/_server/CodeMirror/LICENSE
@@ -19,3 +19,16 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
+
+----------------------------------------------------------------
+
+The MIT License (MIT)
+
+Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
diff --git a/_server/CodeMirror/beautify.min.js b/_server/CodeMirror/beautify.min.js
new file mode 100644
index 00000000..d57943a9
--- /dev/null
+++ b/_server/CodeMirror/beautify.min.js
@@ -0,0 +1 @@
+!function(){var t=function(u){var i={};function n(t){if(i[t])return i[t].exports;var e=i[t]={i:t,l:!1,exports:{}};return u[t].call(e.exports,e,e.exports,n),e.l=!0,e.exports}return n.m=u,n.c=i,n.d=function(t,e,u){n.o(t,e)||Object.defineProperty(t,e,{enumerable:!0,get:u})},n.r=function(t){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})},n.t=function(e,t){if(1&t&&(e=n(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var u=Object.create(null);if(n.r(u),Object.defineProperty(u,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var i in e)n.d(u,i,function(t){return e[t]}.bind(null,i));return u},n.n=function(t){var e=t&&t.__esModule?function(){return t.default}:function(){return t};return n.d(e,"a",e),e},n.o=function(t,e){return Object.prototype.hasOwnProperty.call(t,e)},n.p="",n(n.s=0)}([function(t,e,u){"use strict";var i=u(1).Beautifier,n=u(5).Options;t.exports=function(t,e){return new i(t,e).beautify()},t.exports.defaultOptions=function(){return new n}},function(t,e,u){"use strict";var i=u(2).Output,n=u(3).Token,o=u(4),_=u(5).Options,s=u(7).Tokenizer,p=u(7).line_starters,l=u(7).positionable_operators,f=u(7).TOKEN;function c(t,e){return-1!==e.indexOf(t)}function a(t,e){return t&&t.type===f.RESERVED&&t.text===e}function d(t,e){return t&&t.type===f.RESERVED&&c(t.text,e)}var b=["case","return","do","if","throw","else","await","break","continue","async"],g=function(t){for(var e={},u=0;u<t.length;u++)e[t[u].replace(/-/g,"_")]=t[u];return e}(["before-newline","after-newline","preserve-newline"]),k=[g.before_newline,g.preserve_newline],m="BlockStatement",w="Statement",r="ObjectLiteral",h="ArrayLiteral",y="ForInitializer",x="Conditional",v="Expression";function E(t,e){e.multiline_frame||e.mode===y||e.mode===x||t.remove_indent(e.start_line_index)}function R(t){return t===h}function O(t){return c(t,[v,y,x])}function T(t,e){e=e||{},this._source_text=t||"",this._output=null,this._tokens=null,this._last_last_text=null,this._flags=null,this._previous_flags=null,this._flag_store=null,this._options=new _(e)}T.prototype.create_flags=function(t,e){var u=0;return t&&(u=t.indentation_level,!this._output.just_added_newline()&&t.line_indent_level>u&&(u=t.line_indent_level)),{mode:e,parent:t,last_token:t?t.last_token:new n(f.START_BLOCK,""),last_word:t?t.last_word:"",declaration_statement:!1,declaration_assignment:!1,multiline_frame:!1,inline_frame:!1,if_block:!1,else_block:!1,do_block:!1,do_while:!1,import_block:!1,in_case_statement:!1,in_case:!1,case_body:!1,indentation_level:u,alignment:0,line_indent_level:t?t.line_indent_level:u,start_line_index:this._output.get_line_number(),ternary_depth:0}},T.prototype._reset=function(t){var e=t.match(/^[\t ]*/)[0];this._last_last_text="",this._output=new i(this._options,e),this._output.raw=this._options.test_output_raw,this._flag_store=[],this.set_mode(m);var u=new s(t,this._options);return this._tokens=u.tokenize(),t},T.prototype.beautify=function(){if(this._options.disabled)return this._source_text;var t=this._reset(this._source_text),e=this._options.eol;"auto"===this._options.eol&&(e="\n",t&&o.lineBreak.test(t||"")&&(e=t.match(o.lineBreak)[0]));for(var u=this._tokens.next();u;)this.handle_token(u),this._last_last_text=this._flags.last_token.text,this._flags.last_token=u,u=this._tokens.next();return this._output.get_code(e)},T.prototype.handle_token=function(t,e){t.type===f.START_EXPR?this.handle_start_expr(t):t.type===f.END_EXPR?this.handle_end_expr(t):t.type===f.START_BLOCK?this.handle_start_block(t):t.type===f.END_BLOCK?this.handle_end_block(t):t.type===f.WORD?this.handle_word(t):t.type===f.RESERVED?this.handle_word(t):t.type===f.SEMICOLON?this.handle_semicolon(t):t.type===f.STRING?this.handle_string(t):t.type===f.EQUALS?this.handle_equals(t):t.type===f.OPERATOR?this.handle_operator(t):t.type===f.COMMA?this.handle_comma(t):t.type===f.BLOCK_COMMENT?this.handle_block_comment(t,e):t.type===f.COMMENT?this.handle_comment(t,e):t.type===f.DOT?this.handle_dot(t):t.type===f.EOF?this.handle_eof(t):(t.type,f.UNKNOWN,this.handle_unknown(t,e))},T.prototype.handle_whitespace_and_comments=function(t,e){var u=t.newlines,i=this._options.keep_array_indentation&&R(this._flags.mode);if(t.comments_before)for(var n=t.comments_before.next();n;)this.handle_whitespace_and_comments(n,e),this.handle_token(n,e),n=t.comments_before.next();if(i)for(var _=0;_<u;_+=1)this.print_newline(0<_,e);else if(this._options.max_preserve_newlines&&u>this._options.max_preserve_newlines&&(u=this._options.max_preserve_newlines),this._options.preserve_newlines&&1<u){this.print_newline(!1,e);for(var s=1;s<u;s+=1)this.print_newline(!0,e)}};var A=["async","break","continue","return","throw","yield"];T.prototype.allow_wrap_or_preserved_newline=function(t,e){if(e=void 0!==e&&e,!this._output.just_added_newline()){var u=this._options.preserve_newlines&&t.newlines||e;if(c(this._flags.last_token.text,l)||c(t.text,l)){var i=c(this._flags.last_token.text,l)&&c(this._options.operator_position,k)||c(t.text,l);u=u&&i}if(u)this.print_newline(!1,!0);else if(this._options.wrap_line_length){if(d(this._flags.last_token,A))return;this._output.set_wrap_point()}}},T.prototype.print_newline=function(t,e){if(!e&&";"!==this._flags.last_token.text&&","!==this._flags.last_token.text&&"="!==this._flags.last_token.text&&(this._flags.last_token.type!==f.OPERATOR||"--"===this._flags.last_token.text||"++"===this._flags.last_token.text))for(var u=this._tokens.peek();!(this._flags.mode!==w||this._flags.if_block&&a(u,"else")||this._flags.do_block);)this.restore_mode();this._output.add_new_line(t)&&(this._flags.multiline_frame=!0)},T.prototype.print_token_line_indentation=function(t){this._output.just_added_newline()&&(this._options.keep_array_indentation&&t.newlines&&("["===t.text||R(this._flags.mode))?(this._output.current_line.set_indent(-1),this._output.current_line.push(t.whitespace_before),this._output.space_before_token=!1):this._output.set_indent(this._flags.indentation_level,this._flags.alignment)&&(this._flags.line_indent_level=this._flags.indentation_level))},T.prototype.print_token=function(t,e){if(this._output.raw)this._output.add_raw_token(t);else{if(this._options.comma_first&&t.previous&&t.previous.type===f.COMMA&&this._output.just_added_newline()&&","===this._output.previous_line.last()){var u=this._output.previous_line.pop();this._output.previous_line.is_empty()&&(this._output.previous_line.push(u),this._output.trim(!0),this._output.current_line.pop(),this._output.trim()),this.print_token_line_indentation(t),this._output.add_token(","),this._output.space_before_token=!0}e=e||t.text,this.print_token_line_indentation(t),this._output.non_breaking_space=!0,this._output.add_token(e),this._output.previous_token_wrapped&&(this._flags.multiline_frame=!0)}},T.prototype.indent=function(){this._flags.indentation_level+=1,this._output.set_indent(this._flags.indentation_level,this._flags.alignment)},T.prototype.deindent=function(){0<this._flags.indentation_level&&(!this._flags.parent||this._flags.indentation_level>this._flags.parent.indentation_level)&&(this._flags.indentation_level-=1,this._output.set_indent(this._flags.indentation_level,this._flags.alignment))},T.prototype.set_mode=function(t){this._flags?(this._flag_store.push(this._flags),this._previous_flags=this._flags):this._previous_flags=this.create_flags(null,t),this._flags=this.create_flags(this._previous_flags,t),this._output.set_indent(this._flags.indentation_level,this._flags.alignment)},T.prototype.restore_mode=function(){0<this._flag_store.length&&(this._previous_flags=this._flags,this._flags=this._flag_store.pop(),this._previous_flags.mode===w&&E(this._output,this._previous_flags),this._output.set_indent(this._flags.indentation_level,this._flags.alignment))},T.prototype.start_of_object_property=function(){return this._flags.parent.mode===r&&this._flags.mode===w&&(":"===this._flags.last_token.text&&0===this._flags.ternary_depth||d(this._flags.last_token,["get","set"]))},T.prototype.start_of_statement=function(t){var e=!1;return!!(e=(e=(e=(e=(e=(e=(e=e||d(this._flags.last_token,["var","let","const"])&&t.type===f.WORD)||a(this._flags.last_token,"do"))||!(this._flags.parent.mode===r&&this._flags.mode===w)&&d(this._flags.last_token,A)&&!t.newlines)||a(this._flags.last_token,"else")&&!(a(t,"if")&&!t.comments_before))||this._flags.last_token.type===f.END_EXPR&&(this._previous_flags.mode===y||this._previous_flags.mode===x))||this._flags.last_token.type===f.WORD&&this._flags.mode===m&&!this._flags.in_case&&!("--"===t.text||"++"===t.text)&&"function"!==this._last_last_text&&t.type!==f.WORD&&t.type!==f.RESERVED)||this._flags.mode===r&&(":"===this._flags.last_token.text&&0===this._flags.ternary_depth||d(this._flags.last_token,["get","set"])))&&(this.set_mode(w),this.indent(),this.handle_whitespace_and_comments(t,!0),this.start_of_object_property()||this.allow_wrap_or_preserved_newline(t,d(t,["do","for","if","while"])),!0)},T.prototype.handle_start_expr=function(t){this.start_of_statement(t)||this.handle_whitespace_and_comments(t);var e=v;if("["===t.text){if(this._flags.last_token.type===f.WORD||")"===this._flags.last_token.text)return d(this._flags.last_token,p)&&(this._output.space_before_token=!0),this.print_token(t),this.set_mode(e),this.indent(),void(this._options.space_in_paren&&(this._output.space_before_token=!0));e=h,R(this._flags.mode)&&("["!==this._flags.last_token.text&&(","!==this._flags.last_token.text||"]"!==this._last_last_text&&"}"!==this._last_last_text)||this._options.keep_array_indentation||this.print_newline()),c(this._flags.last_token.type,[f.START_EXPR,f.END_EXPR,f.WORD,f.OPERATOR])||(this._output.space_before_token=!0)}else{if(this._flags.last_token.type===f.RESERVED)"for"===this._flags.last_token.text?(this._output.space_before_token=this._options.space_before_conditional,e=y):c(this._flags.last_token.text,["if","while"])?(this._output.space_before_token=this._options.space_before_conditional,e=x):c(this._flags.last_word,["await","async"])?this._output.space_before_token=!0:"import"===this._flags.last_token.text&&""===t.whitespace_before?this._output.space_before_token=!1:(c(this._flags.last_token.text,p)||"catch"===this._flags.last_token.text)&&(this._output.space_before_token=!0);else if(this._flags.last_token.type===f.EQUALS||this._flags.last_token.type===f.OPERATOR)this.start_of_object_property()||this.allow_wrap_or_preserved_newline(t);else if(this._flags.last_token.type===f.WORD){this._output.space_before_token=!1;var u=this._tokens.peek(-3);if(this._options.space_after_named_function&&u){var i=this._tokens.peek(-4);d(u,["async","function"])||"*"===u.text&&d(i,["async","function"])?this._output.space_before_token=!0:this._flags.mode===r&&("{"!==u.text&&","!==u.text&&("*"!==u.text||"{"!==i.text&&","!==i.text)||(this._output.space_before_token=!0))}}else this.allow_wrap_or_preserved_newline(t);(this._flags.last_token.type===f.RESERVED&&("function"===this._flags.last_word||"typeof"===this._flags.last_word)||"*"===this._flags.last_token.text&&(c(this._last_last_text,["function","yield"])||this._flags.mode===r&&c(this._last_last_text,["{",","])))&&(this._output.space_before_token=this._options.space_after_anon_function)}";"===this._flags.last_token.text||this._flags.last_token.type===f.START_BLOCK?this.print_newline():this._flags.last_token.type!==f.END_EXPR&&this._flags.last_token.type!==f.START_EXPR&&this._flags.last_token.type!==f.END_BLOCK&&"."!==this._flags.last_token.text&&this._flags.last_token.type!==f.COMMA||this.allow_wrap_or_preserved_newline(t,t.newlines),this.print_token(t),this.set_mode(e),this._options.space_in_paren&&(this._output.space_before_token=!0),this.indent()},T.prototype.handle_end_expr=function(t){for(;this._flags.mode===w;)this.restore_mode();this.handle_whitespace_and_comments(t),this._flags.multiline_frame&&this.allow_wrap_or_preserved_newline(t,"]"===t.text&&R(this._flags.mode)&&!this._options.keep_array_indentation),this._options.space_in_paren&&(this._flags.last_token.type!==f.START_EXPR||this._options.space_in_empty_paren?this._output.space_before_token=!0:(this._output.trim(),this._output.space_before_token=!1)),this.deindent(),this.print_token(t),this.restore_mode(),E(this._output,this._previous_flags),this._flags.do_while&&this._previous_flags.mode===x&&(this._previous_flags.mode=v,this._flags.do_block=!1,this._flags.do_while=!1)},T.prototype.handle_start_block=function(t){this.handle_whitespace_and_comments(t);var e=this._tokens.peek(),u=this._tokens.peek(1);"switch"===this._flags.last_word&&this._flags.last_token.type===f.END_EXPR?(this.set_mode(m),this._flags.in_case_statement=!0):u&&(c(u.text,[":",","])&&c(e.type,[f.STRING,f.WORD,f.RESERVED])||c(e.text,["get","set","..."])&&c(u.type,[f.WORD,f.RESERVED]))?c(this._last_last_text,["class","interface"])?this.set_mode(m):this.set_mode(r):this._flags.last_token.type===f.OPERATOR&&"=>"===this._flags.last_token.text?this.set_mode(m):c(this._flags.last_token.type,[f.EQUALS,f.START_EXPR,f.COMMA,f.OPERATOR])||d(this._flags.last_token,["return","throw","import","default"])?this.set_mode(r):this.set_mode(m);var i=!e.comments_before&&"}"===e.text,n=i&&"function"===this._flags.last_word&&this._flags.last_token.type===f.END_EXPR;if(this._options.brace_preserve_inline){var _=0,s=null;this._flags.inline_frame=!0;do{if(_+=1,(s=this._tokens.peek(_-1)).newlines){this._flags.inline_frame=!1;break}}while(s.type!==f.EOF&&(s.type!==f.END_BLOCK||s.opened!==t))}("expand"===this._options.brace_style||"none"===this._options.brace_style&&t.newlines)&&!this._flags.inline_frame?this._flags.last_token.type!==f.OPERATOR&&(n||this._flags.last_token.type===f.EQUALS||d(this._flags.last_token,b)&&"else"!==this._flags.last_token.text)?this._output.space_before_token=!0:this.print_newline(!1,!0):(!R(this._previous_flags.mode)||this._flags.last_token.type!==f.START_EXPR&&this._flags.last_token.type!==f.COMMA||((this._flags.last_token.type===f.COMMA||this._options.space_in_paren)&&(this._output.space_before_token=!0),(this._flags.last_token.type===f.COMMA||this._flags.last_token.type===f.START_EXPR&&this._flags.inline_frame)&&(this.allow_wrap_or_preserved_newline(t),this._previous_flags.multiline_frame=this._previous_flags.multiline_frame||this._flags.multiline_frame,this._flags.multiline_frame=!1)),this._flags.last_token.type!==f.OPERATOR&&this._flags.last_token.type!==f.START_EXPR&&(this._flags.last_token.type!==f.START_BLOCK||this._flags.inline_frame?this._output.space_before_token=!0:this.print_newline())),this.print_token(t),this.indent(),i||this._options.brace_preserve_inline&&this._flags.inline_frame||this.print_newline()},T.prototype.handle_end_block=function(t){for(this.handle_whitespace_and_comments(t);this._flags.mode===w;)this.restore_mode();var e=this._flags.last_token.type===f.START_BLOCK;this._flags.inline_frame&&!e?this._output.space_before_token=!0:"expand"===this._options.brace_style?e||this.print_newline():e||(R(this._flags.mode)&&this._options.keep_array_indentation?(this._options.keep_array_indentation=!1,this.print_newline(),this._options.keep_array_indentation=!0):this.print_newline()),this.restore_mode(),this.print_token(t)},T.prototype.handle_word=function(t){if(t.type===f.RESERVED)if(c(t.text,["set","get"])&&this._flags.mode!==r)t.type=f.WORD;else if("import"===t.text&&"("===this._tokens.peek().text)t.type=f.WORD;else if(c(t.text,["as","from"])&&!this._flags.import_block)t.type=f.WORD;else if(this._flags.mode===r){":"===this._tokens.peek().text&&(t.type=f.WORD)}if(this.start_of_statement(t)?d(this._flags.last_token,["var","let","const"])&&t.type===f.WORD&&(this._flags.declaration_statement=!0):!t.newlines||O(this._flags.mode)||this._flags.last_token.type===f.OPERATOR&&"--"!==this._flags.last_token.text&&"++"!==this._flags.last_token.text||this._flags.last_token.type===f.EQUALS||!this._options.preserve_newlines&&d(this._flags.last_token,["var","let","const","set","get"])?this.handle_whitespace_and_comments(t):(this.handle_whitespace_and_comments(t),this.print_newline()),this._flags.do_block&&!this._flags.do_while){if(a(t,"while"))return this._output.space_before_token=!0,this.print_token(t),this._output.space_before_token=!0,void(this._flags.do_while=!0);this.print_newline(),this._flags.do_block=!1}if(this._flags.if_block)if(!this._flags.else_block&&a(t,"else"))this._flags.else_block=!0;else{for(;this._flags.mode===w;)this.restore_mode();this._flags.if_block=!1,this._flags.else_block=!1}if(this._flags.in_case_statement&&d(t,["case","default"]))return this.print_newline(),(this._flags.case_body||this._options.jslint_happy)&&(this.deindent(),this._flags.case_body=!1),this.print_token(t),void(this._flags.in_case=!0);if(this._flags.last_token.type!==f.COMMA&&this._flags.last_token.type!==f.START_EXPR&&this._flags.last_token.type!==f.EQUALS&&this._flags.last_token.type!==f.OPERATOR||this.start_of_object_property()||this.allow_wrap_or_preserved_newline(t),a(t,"function"))return(c(this._flags.last_token.text,["}",";"])||this._output.just_added_newline()&&!c(this._flags.last_token.text,["(","[","{",":","=",","])&&this._flags.last_token.type!==f.OPERATOR)&&(this._output.just_added_blankline()||t.comments_before||(this.print_newline(),this.print_newline(!0))),this._flags.last_token.type===f.RESERVED||this._flags.last_token.type===f.WORD?d(this._flags.last_token,["get","set","new","export"])||d(this._flags.last_token,A)?this._output.space_before_token=!0:a(this._flags.last_token,"default")&&"export"===this._last_last_text?this._output.space_before_token=!0:"declare"===this._flags.last_token.text?this._output.space_before_token=!0:this.print_newline():this._flags.last_token.type===f.OPERATOR||"="===this._flags.last_token.text?this._output.space_before_token=!0:(this._flags.multiline_frame||!O(this._flags.mode)&&!R(this._flags.mode))&&this.print_newline(),this.print_token(t),void(this._flags.last_word=t.text);var e="NONE";(this._flags.last_token.type===f.END_BLOCK?this._previous_flags.inline_frame?e="SPACE":d(t,["else","catch","finally","from"])?"expand"===this._options.brace_style||"end-expand"===this._options.brace_style||"none"===this._options.brace_style&&t.newlines?e="NEWLINE":(e="SPACE",this._output.space_before_token=!0):e="NEWLINE":this._flags.last_token.type===f.SEMICOLON&&this._flags.mode===m?e="NEWLINE":this._flags.last_token.type===f.SEMICOLON&&O(this._flags.mode)?e="SPACE":this._flags.last_token.type===f.STRING?e="NEWLINE":this._flags.last_token.type===f.RESERVED||this._flags.last_token.type===f.WORD||"*"===this._flags.last_token.text&&(c(this._last_last_text,["function","yield"])||this._flags.mode===r&&c(this._last_last_text,["{",","]))?e="SPACE":this._flags.last_token.type===f.START_BLOCK?e=this._flags.inline_frame?"SPACE":"NEWLINE":this._flags.last_token.type===f.END_EXPR&&(this._output.space_before_token=!0,e="NEWLINE"),d(t,p)&&")"!==this._flags.last_token.text&&(e=this._flags.inline_frame||"else"===this._flags.last_token.text||"export"===this._flags.last_token.text?"SPACE":"NEWLINE"),d(t,["else","catch","finally"]))?(this._flags.last_token.type!==f.END_BLOCK||this._previous_flags.mode!==m||"expand"===this._options.brace_style||"end-expand"===this._options.brace_style||"none"===this._options.brace_style&&t.newlines)&&!this._flags.inline_frame?this.print_newline():(this._output.trim(!0),"}"!==this._output.current_line.last()&&this.print_newline(),this._output.space_before_token=!0):"NEWLINE"===e?d(this._flags.last_token,b)?this._output.space_before_token=!0:"declare"===this._flags.last_token.text&&d(t,["var","let","const"])?this._output.space_before_token=!0:this._flags.last_token.type!==f.END_EXPR?this._flags.last_token.type===f.START_EXPR&&d(t,["var","let","const"])||":"===this._flags.last_token.text||(a(t,"if")&&a(t.previous,"else")?this._output.space_before_token=!0:this.print_newline()):d(t,p)&&")"!==this._flags.last_token.text&&this.print_newline():this._flags.multiline_frame&&R(this._flags.mode)&&","===this._flags.last_token.text&&"}"===this._last_last_text?this.print_newline():"SPACE"===e&&(this._output.space_before_token=!0);!t.previous||t.previous.type!==f.WORD&&t.previous.type!==f.RESERVED||(this._output.space_before_token=!0),this.print_token(t),this._flags.last_word=t.text,t.type===f.RESERVED&&("do"===t.text?this._flags.do_block=!0:"if"===t.text?this._flags.if_block=!0:"import"===t.text?this._flags.import_block=!0:this._flags.import_block&&a(t,"from")&&(this._flags.import_block=!1))},T.prototype.handle_semicolon=function(t){this.start_of_statement(t)?this._output.space_before_token=!1:this.handle_whitespace_and_comments(t);for(var e=this._tokens.peek();!(this._flags.mode!==w||this._flags.if_block&&a(e,"else")||this._flags.do_block);)this.restore_mode();this._flags.import_block&&(this._flags.import_block=!1),this.print_token(t)},T.prototype.handle_string=function(t){this.start_of_statement(t)?this._output.space_before_token=!0:(this.handle_whitespace_and_comments(t),this._flags.last_token.type===f.RESERVED||this._flags.last_token.type===f.WORD||this._flags.inline_frame?this._output.space_before_token=!0:this._flags.last_token.type===f.COMMA||this._flags.last_token.type===f.START_EXPR||this._flags.last_token.type===f.EQUALS||this._flags.last_token.type===f.OPERATOR?this.start_of_object_property()||this.allow_wrap_or_preserved_newline(t):this.print_newline()),this.print_token(t)},T.prototype.handle_equals=function(t){this.start_of_statement(t)||this.handle_whitespace_and_comments(t),this._flags.declaration_statement&&(this._flags.declaration_assignment=!0),this._output.space_before_token=!0,this.print_token(t),this._output.space_before_token=!0},T.prototype.handle_comma=function(t){this.handle_whitespace_and_comments(t,!0),this.print_token(t),this._output.space_before_token=!0,this._flags.declaration_statement?(O(this._flags.parent.mode)&&(this._flags.declaration_assignment=!1),this._flags.declaration_assignment?(this._flags.declaration_assignment=!1,this.print_newline(!1,!0)):this._options.comma_first&&this.allow_wrap_or_preserved_newline(t)):this._flags.mode===r||this._flags.mode===w&&this._flags.parent.mode===r?(this._flags.mode===w&&this.restore_mode(),this._flags.inline_frame||this.print_newline()):this._options.comma_first&&this.allow_wrap_or_preserved_newline(t)},T.prototype.handle_operator=function(t){var e="*"===t.text&&(d(this._flags.last_token,["function","yield"])||c(this._flags.last_token.type,[f.START_BLOCK,f.COMMA,f.END_BLOCK,f.SEMICOLON])),u=c(t.text,["-","+"])&&(c(this._flags.last_token.type,[f.START_BLOCK,f.START_EXPR,f.EQUALS,f.OPERATOR])||c(this._flags.last_token.text,p)||","===this._flags.last_token.text);if(this.start_of_statement(t));else{var i=!e;this.handle_whitespace_and_comments(t,i)}if(d(this._flags.last_token,b))return this._output.space_before_token=!0,void this.print_token(t);if("*"!==t.text||this._flags.last_token.type!==f.DOT)if("::"!==t.text){if(this._flags.last_token.type===f.OPERATOR&&c(this._options.operator_position,k)&&this.allow_wrap_or_preserved_newline(t),":"===t.text&&this._flags.in_case)return this._flags.case_body=!0,this.indent(),this.print_token(t),this.print_newline(),void(this._flags.in_case=!1);var n=!0,_=!0,s=!1;if(":"===t.text?0===this._flags.ternary_depth?n=!1:(this._flags.ternary_depth-=1,s=!0):"?"===t.text&&(this._flags.ternary_depth+=1),!u&&!e&&this._options.preserve_newlines&&c(t.text,l)){var a=":"===t.text,o=a&&s,r=a&&!s;switch(this._options.operator_position){case g.before_newline:return this._output.space_before_token=!r,this.print_token(t),a&&!o||this.allow_wrap_or_preserved_newline(t),void(this._output.space_before_token=!0);case g.after_newline:return this._output.space_before_token=!0,!a||o?this._tokens.peek().newlines?this.print_newline(!1,!0):this.allow_wrap_or_preserved_newline(t):this._output.space_before_token=!1,this.print_token(t),void(this._output.space_before_token=!0);case g.preserve_newline:return r||this.allow_wrap_or_preserved_newline(t),n=!(this._output.just_added_newline()||r),this._output.space_before_token=n,this.print_token(t),void(this._output.space_before_token=!0)}}if(e){this.allow_wrap_or_preserved_newline(t),n=!1;var h=this._tokens.peek();_=h&&c(h.type,[f.WORD,f.RESERVED])}else"..."===t.text?(this.allow_wrap_or_preserved_newline(t),n=this._flags.last_token.type===f.START_BLOCK,_=!1):(c(t.text,["--","++","!","~"])||u)&&(this._flags.last_token.type!==f.COMMA&&this._flags.last_token.type!==f.START_EXPR||this.allow_wrap_or_preserved_newline(t),_=n=!1,!t.newlines||"--"!==t.text&&"++"!==t.text||this.print_newline(!1,!0),";"===this._flags.last_token.text&&O(this._flags.mode)&&(n=!0),this._flags.last_token.type===f.RESERVED?n=!0:this._flags.last_token.type===f.END_EXPR?n=!("]"===this._flags.last_token.text&&("--"===t.text||"++"===t.text)):this._flags.last_token.type===f.OPERATOR&&(n=c(t.text,["--","-","++","+"])&&c(this._flags.last_token.text,["--","-","++","+"]),c(t.text,["+","-"])&&c(this._flags.last_token.text,["--","++"])&&(_=!0)),(this._flags.mode!==m||this._flags.inline_frame)&&this._flags.mode!==w||"{"!==this._flags.last_token.text&&";"!==this._flags.last_token.text||this.print_newline());this._output.space_before_token=this._output.space_before_token||n,this.print_token(t),this._output.space_before_token=_}else this.print_token(t);else this.print_token(t)},T.prototype.handle_block_comment=function(t,e){if(this._output.raw)return this._output.add_raw_token(t),void(t.directives&&"end"===t.directives.preserve&&(this._output.raw=this._options.test_output_raw));if(t.directives)return this.print_newline(!1,e),this.print_token(t),"start"===t.directives.preserve&&(this._output.raw=!0),void this.print_newline(!1,!0);if(!o.newline.test(t.text)&&!t.newlines)return this._output.space_before_token=!0,this.print_token(t),void(this._output.space_before_token=!0);var u,i=function(t){for(var e=[],u=(t=t.replace(o.allLineBreaks,"\n")).indexOf("\n");-1!==u;)e.push(t.substring(0,u)),u=(t=t.substring(u+1)).indexOf("\n");return t.length&&e.push(t),e}(t.text),n=!1,_=!1,s=t.whitespace_before,a=s.length;if(this.print_newline(!1,e),this.print_token(t,i[0]),this.print_newline(!1,e),1<i.length){for(n=function(t,e){for(var u=0;u<t.length;u++)if(t[u].trim().charAt(0)!==e)return!1;return!0}(i=i.slice(1),"*"),_=function(t,e){for(var u,i=0,n=t.length;i<n;i++)if((u=t[i])&&0!==u.indexOf(e))return!1;return!0}(i,s),n&&(this._flags.alignment=1),u=0;u<i.length;u++)n?this.print_token(t,i[u].replace(/^\s+/g,"")):_&&i[u]?this.print_token(t,i[u].substring(a)):(this._output.current_line.set_indent(-1),this._output.add_token(i[u])),this.print_newline(!1,e);this._flags.alignment=0}},T.prototype.handle_comment=function(t,e){t.newlines?this.print_newline(!1,e):this._output.trim(!0),this._output.space_before_token=!0,this.print_token(t),this.print_newline(!1,e)},T.prototype.handle_dot=function(t){this.start_of_statement(t)||this.handle_whitespace_and_comments(t,!0),d(this._flags.last_token,b)?this._output.space_before_token=!1:this.allow_wrap_or_preserved_newline(t,")"===this._flags.last_token.text&&this._options.break_chained_methods),this._options.unindent_chained_methods&&this._output.just_added_newline()&&this.deindent(),this.print_token(t)},T.prototype.handle_unknown=function(t,e){this.print_token(t),"\n"===t.text[t.text.length-1]&&this.print_newline(!1,e)},T.prototype.handle_eof=function(t){for(;this._flags.mode===w;)this.restore_mode();this.handle_whitespace_and_comments(t)},t.exports.Beautifier=T},function(t,e,u){"use strict";function n(t){this.__parent=t,this.__character_count=0,this.__indent_count=-1,this.__alignment_count=0,this.__wrap_point_index=0,this.__wrap_point_character_count=0,this.__wrap_point_indent_count=-1,this.__wrap_point_alignment_count=0,this.__items=[]}function i(t,e){this.__cache=[""],this.__indent_size=t.indent_size,this.__indent_string=t.indent_char,t.indent_with_tabs||(this.__indent_string=new Array(t.indent_size+1).join(t.indent_char)),e=e||"",0<t.indent_level&&(e=new Array(t.indent_level+1).join(this.__indent_string)),this.__base_string=e,this.__base_string_length=e.length}function _(t,e){this.__indent_cache=new i(t,e),this.raw=!1,this._end_with_newline=t.end_with_newline,this.indent_size=t.indent_size,this.wrap_line_length=t.wrap_line_length,this.__lines=[],this.previous_line=null,this.current_line=null,this.next_line=new n(this),this.space_before_token=!1,this.non_breaking_space=!1,this.previous_token_wrapped=!1,this.__add_outputline()}n.prototype.clone_empty=function(){var t=new n(this.__parent);return t.set_indent(this.__indent_count,this.__alignment_count),t},n.prototype.item=function(t){return t<0?this.__items[this.__items.length+t]:this.__items[t]},n.prototype.has_match=function(t){for(var e=this.__items.length-1;0<=e;e--)if(this.__items[e].match(t))return!0;return!1},n.prototype.set_indent=function(t,e){this.is_empty()&&(this.__indent_count=t||0,this.__alignment_count=e||0,this.__character_count=this.__parent.get_indent_size(this.__indent_count,this.__alignment_count))},n.prototype._set_wrap_point=function(){this.__parent.wrap_line_length&&(this.__wrap_point_index=this.__items.length,this.__wrap_point_character_count=this.__character_count,this.__wrap_point_indent_count=this.__parent.next_line.__indent_count,this.__wrap_point_alignment_count=this.__parent.next_line.__alignment_count)},n.prototype._should_wrap=function(){return this.__wrap_point_index&&this.__character_count>this.__parent.wrap_line_length&&this.__wrap_point_character_count>this.__parent.next_line.__character_count},n.prototype._allow_wrap=function(){if(this._should_wrap()){this.__parent.add_new_line();var t=this.__parent.current_line;return t.set_indent(this.__wrap_point_indent_count,this.__wrap_point_alignment_count),t.__items=this.__items.slice(this.__wrap_point_index),this.__items=this.__items.slice(0,this.__wrap_point_index),t.__character_count+=this.__character_count-this.__wrap_point_character_count,this.__character_count=this.__wrap_point_character_count," "===t.__items[0]&&(t.__items.splice(0,1),t.__character_count-=1),!0}return!1},n.prototype.is_empty=function(){return 0===this.__items.length},n.prototype.last=function(){return this.is_empty()?null:this.__items[this.__items.length-1]},n.prototype.push=function(t){this.__items.push(t);var e=t.lastIndexOf("\n");-1!==e?this.__character_count=t.length-e:this.__character_count+=t.length},n.prototype.pop=function(){var t=null;return this.is_empty()||(t=this.__items.pop(),this.__character_count-=t.length),t},n.prototype._remove_indent=function(){0<this.__indent_count&&(this.__indent_count-=1,this.__character_count-=this.__parent.indent_size)},n.prototype._remove_wrap_indent=function(){0<this.__wrap_point_indent_count&&(this.__wrap_point_indent_count-=1)},n.prototype.trim=function(){for(;" "===this.last();)this.__items.pop(),this.__character_count-=1},n.prototype.toString=function(){var t="";return this.is_empty()||(t=this.__parent.get_indent_string(this.__indent_count,this.__alignment_count),t+=this.__items.join("")),t},i.prototype.get_indent_size=function(t,e){var u=this.__base_string_length;return e=e||0,t<0&&(u=0),u+=t*this.__indent_size,u+=e},i.prototype.get_indent_string=function(t,e){var u=this.__base_string;return e=e||0,t<0&&(t=0,u=""),e+=t*this.__indent_size,this.__ensure_cache(e),u+=this.__cache[e]},i.prototype.__ensure_cache=function(t){for(;t>=this.__cache.length;)this.__add_column()},i.prototype.__add_column=function(){var t=this.__cache.length,e=0,u="";this.__indent_size&&t>=this.__indent_size&&(t-=(e=Math.floor(t/this.__indent_size))*this.__indent_size,u=new Array(e+1).join(this.__indent_string)),t&&(u+=new Array(t+1).join(" ")),this.__cache.push(u)},_.prototype.__add_outputline=function(){this.previous_line=this.current_line,this.current_line=this.next_line.clone_empty(),this.__lines.push(this.current_line)},_.prototype.get_line_number=function(){return this.__lines.length},_.prototype.get_indent_string=function(t,e){return this.__indent_cache.get_indent_string(t,e)},_.prototype.get_indent_size=function(t,e){return this.__indent_cache.get_indent_size(t,e)},_.prototype.is_empty=function(){return!this.previous_line&&this.current_line.is_empty()},_.prototype.add_new_line=function(t){return!(this.is_empty()||!t&&this.just_added_newline())&&(this.raw||this.__add_outputline(),!0)},_.prototype.get_code=function(t){this.trim(!0);var e=this.current_line.pop();e&&("\n"===e[e.length-1]&&(e=e.replace(/\n+$/g,"")),this.current_line.push(e)),this._end_with_newline&&this.__add_outputline();var u=this.__lines.join("\n");return"\n"!==t&&(u=u.replace(/[\n]/g,t)),u},_.prototype.set_wrap_point=function(){this.current_line._set_wrap_point()},_.prototype.set_indent=function(t,e){return t=t||0,e=e||0,this.next_line.set_indent(t,e),1<this.__lines.length?(this.current_line.set_indent(t,e),!0):(this.current_line.set_indent(),!1)},_.prototype.add_raw_token=function(t){for(var e=0;e<t.newlines;e++)this.__add_outputline();this.current_line.set_indent(-1),this.current_line.push(t.whitespace_before),this.current_line.push(t.text),this.space_before_token=!1,this.non_breaking_space=!1,this.previous_token_wrapped=!1},_.prototype.add_token=function(t){this.__add_space_before_token(),this.current_line.push(t),this.space_before_token=!1,this.non_breaking_space=!1,this.previous_token_wrapped=this.current_line._allow_wrap()},_.prototype.__add_space_before_token=function(){this.space_before_token&&!this.just_added_newline()&&(this.non_breaking_space||this.set_wrap_point(),this.current_line.push(" "))},_.prototype.remove_indent=function(t){for(var e=this.__lines.length;t<e;)this.__lines[t]._remove_indent(),t++;this.current_line._remove_wrap_indent()},_.prototype.trim=function(t){for(t=void 0!==t&&t,this.current_line.trim();t&&1<this.__lines.length&&this.current_line.is_empty();)this.__lines.pop(),this.current_line=this.__lines[this.__lines.length-1],this.current_line.trim();this.previous_line=1<this.__lines.length?this.__lines[this.__lines.length-2]:null},_.prototype.just_added_newline=function(){return this.current_line.is_empty()},_.prototype.just_added_blankline=function(){return this.is_empty()||this.current_line.is_empty()&&this.previous_line.is_empty()},_.prototype.ensure_empty_line_above=function(t,e){for(var u=this.__lines.length-2;0<=u;){var i=this.__lines[u];if(i.is_empty())break;if(0!==i.item(0).indexOf(t)&&i.item(-1)!==e){this.__lines.splice(u+1,0,new n(this)),this.previous_line=this.__lines[this.__lines.length-2];break}u--}},t.exports.Output=_},function(t,e,u){"use strict";t.exports.Token=function(t,e,u,i){this.type=t,this.text=e,this.comments_before=null,this.newlines=u||0,this.whitespace_before=i||"",this.parent=null,this.next=null,this.previous=null,this.opened=null,this.closed=null,this.directives=null}},function(t,e,u){"use strict";var i="\\x24\\x30-\\x39\\x41-\\x5a\\x5f\\x61-\\x7a",n="\\xaa\\xb5\\xba\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u02c1\\u02c6-\\u02d1\\u02e0-\\u02e4\\u02ec\\u02ee\\u0370-\\u0374\\u0376\\u0377\\u037a-\\u037d\\u0386\\u0388-\\u038a\\u038c\\u038e-\\u03a1\\u03a3-\\u03f5\\u03f7-\\u0481\\u048a-\\u0527\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05d0-\\u05ea\\u05f0-\\u05f2\\u0620-\\u064a\\u066e\\u066f\\u0671-\\u06d3\\u06d5\\u06e5\\u06e6\\u06ee\\u06ef\\u06fa-\\u06fc\\u06ff\\u0710\\u0712-\\u072f\\u074d-\\u07a5\\u07b1\\u07ca-\\u07ea\\u07f4\\u07f5\\u07fa\\u0800-\\u0815\\u081a\\u0824\\u0828\\u0840-\\u0858\\u08a0\\u08a2-\\u08ac\\u0904-\\u0939\\u093d\\u0950\\u0958-\\u0961\\u0971-\\u0977\\u0979-\\u097f\\u0985-\\u098c\\u098f\\u0990\\u0993-\\u09a8\\u09aa-\\u09b0\\u09b2\\u09b6-\\u09b9\\u09bd\\u09ce\\u09dc\\u09dd\\u09df-\\u09e1\\u09f0\\u09f1\\u0a05-\\u0a0a\\u0a0f\\u0a10\\u0a13-\\u0a28\\u0a2a-\\u0a30\\u0a32\\u0a33\\u0a35\\u0a36\\u0a38\\u0a39\\u0a59-\\u0a5c\\u0a5e\\u0a72-\\u0a74\\u0a85-\\u0a8d\\u0a8f-\\u0a91\\u0a93-\\u0aa8\\u0aaa-\\u0ab0\\u0ab2\\u0ab3\\u0ab5-\\u0ab9\\u0abd\\u0ad0\\u0ae0\\u0ae1\\u0b05-\\u0b0c\\u0b0f\\u0b10\\u0b13-\\u0b28\\u0b2a-\\u0b30\\u0b32\\u0b33\\u0b35-\\u0b39\\u0b3d\\u0b5c\\u0b5d\\u0b5f-\\u0b61\\u0b71\\u0b83\\u0b85-\\u0b8a\\u0b8e-\\u0b90\\u0b92-\\u0b95\\u0b99\\u0b9a\\u0b9c\\u0b9e\\u0b9f\\u0ba3\\u0ba4\\u0ba8-\\u0baa\\u0bae-\\u0bb9\\u0bd0\\u0c05-\\u0c0c\\u0c0e-\\u0c10\\u0c12-\\u0c28\\u0c2a-\\u0c33\\u0c35-\\u0c39\\u0c3d\\u0c58\\u0c59\\u0c60\\u0c61\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbd\\u0cde\\u0ce0\\u0ce1\\u0cf1\\u0cf2\\u0d05-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d3a\\u0d3d\\u0d4e\\u0d60\\u0d61\\u0d7a-\\u0d7f\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0e01-\\u0e30\\u0e32\\u0e33\\u0e40-\\u0e46\\u0e81\\u0e82\\u0e84\\u0e87\\u0e88\\u0e8a\\u0e8d\\u0e94-\\u0e97\\u0e99-\\u0e9f\\u0ea1-\\u0ea3\\u0ea5\\u0ea7\\u0eaa\\u0eab\\u0ead-\\u0eb0\\u0eb2\\u0eb3\\u0ebd\\u0ec0-\\u0ec4\\u0ec6\\u0edc-\\u0edf\\u0f00\\u0f40-\\u0f47\\u0f49-\\u0f6c\\u0f88-\\u0f8c\\u1000-\\u102a\\u103f\\u1050-\\u1055\\u105a-\\u105d\\u1061\\u1065\\u1066\\u106e-\\u1070\\u1075-\\u1081\\u108e\\u10a0-\\u10c5\\u10c7\\u10cd\\u10d0-\\u10fa\\u10fc-\\u1248\\u124a-\\u124d\\u1250-\\u1256\\u1258\\u125a-\\u125d\\u1260-\\u1288\\u128a-\\u128d\\u1290-\\u12b0\\u12b2-\\u12b5\\u12b8-\\u12be\\u12c0\\u12c2-\\u12c5\\u12c8-\\u12d6\\u12d8-\\u1310\\u1312-\\u1315\\u1318-\\u135a\\u1380-\\u138f\\u13a0-\\u13f4\\u1401-\\u166c\\u166f-\\u167f\\u1681-\\u169a\\u16a0-\\u16ea\\u16ee-\\u16f0\\u1700-\\u170c\\u170e-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176c\\u176e-\\u1770\\u1780-\\u17b3\\u17d7\\u17dc\\u1820-\\u1877\\u1880-\\u18a8\\u18aa\\u18b0-\\u18f5\\u1900-\\u191c\\u1950-\\u196d\\u1970-\\u1974\\u1980-\\u19ab\\u19c1-\\u19c7\\u1a00-\\u1a16\\u1a20-\\u1a54\\u1aa7\\u1b05-\\u1b33\\u1b45-\\u1b4b\\u1b83-\\u1ba0\\u1bae\\u1baf\\u1bba-\\u1be5\\u1c00-\\u1c23\\u1c4d-\\u1c4f\\u1c5a-\\u1c7d\\u1ce9-\\u1cec\\u1cee-\\u1cf1\\u1cf5\\u1cf6\\u1d00-\\u1dbf\\u1e00-\\u1f15\\u1f18-\\u1f1d\\u1f20-\\u1f45\\u1f48-\\u1f4d\\u1f50-\\u1f57\\u1f59\\u1f5b\\u1f5d\\u1f5f-\\u1f7d\\u1f80-\\u1fb4\\u1fb6-\\u1fbc\\u1fbe\\u1fc2-\\u1fc4\\u1fc6-\\u1fcc\\u1fd0-\\u1fd3\\u1fd6-\\u1fdb\\u1fe0-\\u1fec\\u1ff2-\\u1ff4\\u1ff6-\\u1ffc\\u2071\\u207f\\u2090-\\u209c\\u2102\\u2107\\u210a-\\u2113\\u2115\\u2119-\\u211d\\u2124\\u2126\\u2128\\u212a-\\u212d\\u212f-\\u2139\\u213c-\\u213f\\u2145-\\u2149\\u214e\\u2160-\\u2188\\u2c00-\\u2c2e\\u2c30-\\u2c5e\\u2c60-\\u2ce4\\u2ceb-\\u2cee\\u2cf2\\u2cf3\\u2d00-\\u2d25\\u2d27\\u2d2d\\u2d30-\\u2d67\\u2d6f\\u2d80-\\u2d96\\u2da0-\\u2da6\\u2da8-\\u2dae\\u2db0-\\u2db6\\u2db8-\\u2dbe\\u2dc0-\\u2dc6\\u2dc8-\\u2dce\\u2dd0-\\u2dd6\\u2dd8-\\u2dde\\u2e2f\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303c\\u3041-\\u3096\\u309d-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312d\\u3131-\\u318e\\u31a0-\\u31ba\\u31f0-\\u31ff\\u3400-\\u4db5\\u4e00-\\u9fcc\\ua000-\\ua48c\\ua4d0-\\ua4fd\\ua500-\\ua60c\\ua610-\\ua61f\\ua62a\\ua62b\\ua640-\\ua66e\\ua67f-\\ua697\\ua6a0-\\ua6ef\\ua717-\\ua71f\\ua722-\\ua788\\ua78b-\\ua78e\\ua790-\\ua793\\ua7a0-\\ua7aa\\ua7f8-\\ua801\\ua803-\\ua805\\ua807-\\ua80a\\ua80c-\\ua822\\ua840-\\ua873\\ua882-\\ua8b3\\ua8f2-\\ua8f7\\ua8fb\\ua90a-\\ua925\\ua930-\\ua946\\ua960-\\ua97c\\ua984-\\ua9b2\\ua9cf\\uaa00-\\uaa28\\uaa40-\\uaa42\\uaa44-\\uaa4b\\uaa60-\\uaa76\\uaa7a\\uaa80-\\uaaaf\\uaab1\\uaab5\\uaab6\\uaab9-\\uaabd\\uaac0\\uaac2\\uaadb-\\uaadd\\uaae0-\\uaaea\\uaaf2-\\uaaf4\\uab01-\\uab06\\uab09-\\uab0e\\uab11-\\uab16\\uab20-\\uab26\\uab28-\\uab2e\\uabc0-\\uabe2\\uac00-\\ud7a3\\ud7b0-\\ud7c6\\ud7cb-\\ud7fb\\uf900-\\ufa6d\\ufa70-\\ufad9\\ufb00-\\ufb06\\ufb13-\\ufb17\\ufb1d\\ufb1f-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40\\ufb41\\ufb43\\ufb44\\ufb46-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb\\ufe70-\\ufe74\\ufe76-\\ufefc\\uff21-\\uff3a\\uff41-\\uff5a\\uff66-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc",_="\\u0300-\\u036f\\u0483-\\u0487\\u0591-\\u05bd\\u05bf\\u05c1\\u05c2\\u05c4\\u05c5\\u05c7\\u0610-\\u061a\\u0620-\\u0649\\u0672-\\u06d3\\u06e7-\\u06e8\\u06fb-\\u06fc\\u0730-\\u074a\\u0800-\\u0814\\u081b-\\u0823\\u0825-\\u0827\\u0829-\\u082d\\u0840-\\u0857\\u08e4-\\u08fe\\u0900-\\u0903\\u093a-\\u093c\\u093e-\\u094f\\u0951-\\u0957\\u0962-\\u0963\\u0966-\\u096f\\u0981-\\u0983\\u09bc\\u09be-\\u09c4\\u09c7\\u09c8\\u09d7\\u09df-\\u09e0\\u0a01-\\u0a03\\u0a3c\\u0a3e-\\u0a42\\u0a47\\u0a48\\u0a4b-\\u0a4d\\u0a51\\u0a66-\\u0a71\\u0a75\\u0a81-\\u0a83\\u0abc\\u0abe-\\u0ac5\\u0ac7-\\u0ac9\\u0acb-\\u0acd\\u0ae2-\\u0ae3\\u0ae6-\\u0aef\\u0b01-\\u0b03\\u0b3c\\u0b3e-\\u0b44\\u0b47\\u0b48\\u0b4b-\\u0b4d\\u0b56\\u0b57\\u0b5f-\\u0b60\\u0b66-\\u0b6f\\u0b82\\u0bbe-\\u0bc2\\u0bc6-\\u0bc8\\u0bca-\\u0bcd\\u0bd7\\u0be6-\\u0bef\\u0c01-\\u0c03\\u0c46-\\u0c48\\u0c4a-\\u0c4d\\u0c55\\u0c56\\u0c62-\\u0c63\\u0c66-\\u0c6f\\u0c82\\u0c83\\u0cbc\\u0cbe-\\u0cc4\\u0cc6-\\u0cc8\\u0cca-\\u0ccd\\u0cd5\\u0cd6\\u0ce2-\\u0ce3\\u0ce6-\\u0cef\\u0d02\\u0d03\\u0d46-\\u0d48\\u0d57\\u0d62-\\u0d63\\u0d66-\\u0d6f\\u0d82\\u0d83\\u0dca\\u0dcf-\\u0dd4\\u0dd6\\u0dd8-\\u0ddf\\u0df2\\u0df3\\u0e34-\\u0e3a\\u0e40-\\u0e45\\u0e50-\\u0e59\\u0eb4-\\u0eb9\\u0ec8-\\u0ecd\\u0ed0-\\u0ed9\\u0f18\\u0f19\\u0f20-\\u0f29\\u0f35\\u0f37\\u0f39\\u0f41-\\u0f47\\u0f71-\\u0f84\\u0f86-\\u0f87\\u0f8d-\\u0f97\\u0f99-\\u0fbc\\u0fc6\\u1000-\\u1029\\u1040-\\u1049\\u1067-\\u106d\\u1071-\\u1074\\u1082-\\u108d\\u108f-\\u109d\\u135d-\\u135f\\u170e-\\u1710\\u1720-\\u1730\\u1740-\\u1750\\u1772\\u1773\\u1780-\\u17b2\\u17dd\\u17e0-\\u17e9\\u180b-\\u180d\\u1810-\\u1819\\u1920-\\u192b\\u1930-\\u193b\\u1951-\\u196d\\u19b0-\\u19c0\\u19c8-\\u19c9\\u19d0-\\u19d9\\u1a00-\\u1a15\\u1a20-\\u1a53\\u1a60-\\u1a7c\\u1a7f-\\u1a89\\u1a90-\\u1a99\\u1b46-\\u1b4b\\u1b50-\\u1b59\\u1b6b-\\u1b73\\u1bb0-\\u1bb9\\u1be6-\\u1bf3\\u1c00-\\u1c22\\u1c40-\\u1c49\\u1c5b-\\u1c7d\\u1cd0-\\u1cd2\\u1d00-\\u1dbe\\u1e01-\\u1f15\\u200c\\u200d\\u203f\\u2040\\u2054\\u20d0-\\u20dc\\u20e1\\u20e5-\\u20f0\\u2d81-\\u2d96\\u2de0-\\u2dff\\u3021-\\u3028\\u3099\\u309a\\ua640-\\ua66d\\ua674-\\ua67d\\ua69f\\ua6f0-\\ua6f1\\ua7f8-\\ua800\\ua806\\ua80b\\ua823-\\ua827\\ua880-\\ua881\\ua8b4-\\ua8c4\\ua8d0-\\ua8d9\\ua8f3-\\ua8f7\\ua900-\\ua909\\ua926-\\ua92d\\ua930-\\ua945\\ua980-\\ua983\\ua9b3-\\ua9c0\\uaa00-\\uaa27\\uaa40-\\uaa41\\uaa4c-\\uaa4d\\uaa50-\\uaa59\\uaa7b\\uaae0-\\uaae9\\uaaf2-\\uaaf3\\uabc0-\\uabe1\\uabec\\uabed\\uabf0-\\uabf9\\ufb20-\\ufb28\\ufe00-\\ufe0f\\ufe20-\\ufe26\\ufe33\\ufe34\\ufe4d-\\ufe4f\\uff10-\\uff19\\uff3f",s="(?:\\\\u[0-9a-fA-F]{4}|[\\x24\\x40\\x41-\\x5a\\x5f\\x61-\\x7a"+n+"])";e.identifier=new RegExp(s+"(?:\\\\u[0-9a-fA-F]{4}|[\\x24\\x30-\\x39\\x41-\\x5a\\x5f\\x61-\\x7a\\xaa\\xb5\\xba\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u02c1\\u02c6-\\u02d1\\u02e0-\\u02e4\\u02ec\\u02ee\\u0370-\\u0374\\u0376\\u0377\\u037a-\\u037d\\u0386\\u0388-\\u038a\\u038c\\u038e-\\u03a1\\u03a3-\\u03f5\\u03f7-\\u0481\\u048a-\\u0527\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05d0-\\u05ea\\u05f0-\\u05f2\\u0620-\\u064a\\u066e\\u066f\\u0671-\\u06d3\\u06d5\\u06e5\\u06e6\\u06ee\\u06ef\\u06fa-\\u06fc\\u06ff\\u0710\\u0712-\\u072f\\u074d-\\u07a5\\u07b1\\u07ca-\\u07ea\\u07f4\\u07f5\\u07fa\\u0800-\\u0815\\u081a\\u0824\\u0828\\u0840-\\u0858\\u08a0\\u08a2-\\u08ac\\u0904-\\u0939\\u093d\\u0950\\u0958-\\u0961\\u0971-\\u0977\\u0979-\\u097f\\u0985-\\u098c\\u098f\\u0990\\u0993-\\u09a8\\u09aa-\\u09b0\\u09b2\\u09b6-\\u09b9\\u09bd\\u09ce\\u09dc\\u09dd\\u09df-\\u09e1\\u09f0\\u09f1\\u0a05-\\u0a0a\\u0a0f\\u0a10\\u0a13-\\u0a28\\u0a2a-\\u0a30\\u0a32\\u0a33\\u0a35\\u0a36\\u0a38\\u0a39\\u0a59-\\u0a5c\\u0a5e\\u0a72-\\u0a74\\u0a85-\\u0a8d\\u0a8f-\\u0a91\\u0a93-\\u0aa8\\u0aaa-\\u0ab0\\u0ab2\\u0ab3\\u0ab5-\\u0ab9\\u0abd\\u0ad0\\u0ae0\\u0ae1\\u0b05-\\u0b0c\\u0b0f\\u0b10\\u0b13-\\u0b28\\u0b2a-\\u0b30\\u0b32\\u0b33\\u0b35-\\u0b39\\u0b3d\\u0b5c\\u0b5d\\u0b5f-\\u0b61\\u0b71\\u0b83\\u0b85-\\u0b8a\\u0b8e-\\u0b90\\u0b92-\\u0b95\\u0b99\\u0b9a\\u0b9c\\u0b9e\\u0b9f\\u0ba3\\u0ba4\\u0ba8-\\u0baa\\u0bae-\\u0bb9\\u0bd0\\u0c05-\\u0c0c\\u0c0e-\\u0c10\\u0c12-\\u0c28\\u0c2a-\\u0c33\\u0c35-\\u0c39\\u0c3d\\u0c58\\u0c59\\u0c60\\u0c61\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbd\\u0cde\\u0ce0\\u0ce1\\u0cf1\\u0cf2\\u0d05-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d3a\\u0d3d\\u0d4e\\u0d60\\u0d61\\u0d7a-\\u0d7f\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0e01-\\u0e30\\u0e32\\u0e33\\u0e40-\\u0e46\\u0e81\\u0e82\\u0e84\\u0e87\\u0e88\\u0e8a\\u0e8d\\u0e94-\\u0e97\\u0e99-\\u0e9f\\u0ea1-\\u0ea3\\u0ea5\\u0ea7\\u0eaa\\u0eab\\u0ead-\\u0eb0\\u0eb2\\u0eb3\\u0ebd\\u0ec0-\\u0ec4\\u0ec6\\u0edc-\\u0edf\\u0f00\\u0f40-\\u0f47\\u0f49-\\u0f6c\\u0f88-\\u0f8c\\u1000-\\u102a\\u103f\\u1050-\\u1055\\u105a-\\u105d\\u1061\\u1065\\u1066\\u106e-\\u1070\\u1075-\\u1081\\u108e\\u10a0-\\u10c5\\u10c7\\u10cd\\u10d0-\\u10fa\\u10fc-\\u1248\\u124a-\\u124d\\u1250-\\u1256\\u1258\\u125a-\\u125d\\u1260-\\u1288\\u128a-\\u128d\\u1290-\\u12b0\\u12b2-\\u12b5\\u12b8-\\u12be\\u12c0\\u12c2-\\u12c5\\u12c8-\\u12d6\\u12d8-\\u1310\\u1312-\\u1315\\u1318-\\u135a\\u1380-\\u138f\\u13a0-\\u13f4\\u1401-\\u166c\\u166f-\\u167f\\u1681-\\u169a\\u16a0-\\u16ea\\u16ee-\\u16f0\\u1700-\\u170c\\u170e-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176c\\u176e-\\u1770\\u1780-\\u17b3\\u17d7\\u17dc\\u1820-\\u1877\\u1880-\\u18a8\\u18aa\\u18b0-\\u18f5\\u1900-\\u191c\\u1950-\\u196d\\u1970-\\u1974\\u1980-\\u19ab\\u19c1-\\u19c7\\u1a00-\\u1a16\\u1a20-\\u1a54\\u1aa7\\u1b05-\\u1b33\\u1b45-\\u1b4b\\u1b83-\\u1ba0\\u1bae\\u1baf\\u1bba-\\u1be5\\u1c00-\\u1c23\\u1c4d-\\u1c4f\\u1c5a-\\u1c7d\\u1ce9-\\u1cec\\u1cee-\\u1cf1\\u1cf5\\u1cf6\\u1d00-\\u1dbf\\u1e00-\\u1f15\\u1f18-\\u1f1d\\u1f20-\\u1f45\\u1f48-\\u1f4d\\u1f50-\\u1f57\\u1f59\\u1f5b\\u1f5d\\u1f5f-\\u1f7d\\u1f80-\\u1fb4\\u1fb6-\\u1fbc\\u1fbe\\u1fc2-\\u1fc4\\u1fc6-\\u1fcc\\u1fd0-\\u1fd3\\u1fd6-\\u1fdb\\u1fe0-\\u1fec\\u1ff2-\\u1ff4\\u1ff6-\\u1ffc\\u2071\\u207f\\u2090-\\u209c\\u2102\\u2107\\u210a-\\u2113\\u2115\\u2119-\\u211d\\u2124\\u2126\\u2128\\u212a-\\u212d\\u212f-\\u2139\\u213c-\\u213f\\u2145-\\u2149\\u214e\\u2160-\\u2188\\u2c00-\\u2c2e\\u2c30-\\u2c5e\\u2c60-\\u2ce4\\u2ceb-\\u2cee\\u2cf2\\u2cf3\\u2d00-\\u2d25\\u2d27\\u2d2d\\u2d30-\\u2d67\\u2d6f\\u2d80-\\u2d96\\u2da0-\\u2da6\\u2da8-\\u2dae\\u2db0-\\u2db6\\u2db8-\\u2dbe\\u2dc0-\\u2dc6\\u2dc8-\\u2dce\\u2dd0-\\u2dd6\\u2dd8-\\u2dde\\u2e2f\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303c\\u3041-\\u3096\\u309d-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312d\\u3131-\\u318e\\u31a0-\\u31ba\\u31f0-\\u31ff\\u3400-\\u4db5\\u4e00-\\u9fcc\\ua000-\\ua48c\\ua4d0-\\ua4fd\\ua500-\\ua60c\\ua610-\\ua61f\\ua62a\\ua62b\\ua640-\\ua66e\\ua67f-\\ua697\\ua6a0-\\ua6ef\\ua717-\\ua71f\\ua722-\\ua788\\ua78b-\\ua78e\\ua790-\\ua793\\ua7a0-\\ua7aa\\ua7f8-\\ua801\\ua803-\\ua805\\ua807-\\ua80a\\ua80c-\\ua822\\ua840-\\ua873\\ua882-\\ua8b3\\ua8f2-\\ua8f7\\ua8fb\\ua90a-\\ua925\\ua930-\\ua946\\ua960-\\ua97c\\ua984-\\ua9b2\\ua9cf\\uaa00-\\uaa28\\uaa40-\\uaa42\\uaa44-\\uaa4b\\uaa60-\\uaa76\\uaa7a\\uaa80-\\uaaaf\\uaab1\\uaab5\\uaab6\\uaab9-\\uaabd\\uaac0\\uaac2\\uaadb-\\uaadd\\uaae0-\\uaaea\\uaaf2-\\uaaf4\\uab01-\\uab06\\uab09-\\uab0e\\uab11-\\uab16\\uab20-\\uab26\\uab28-\\uab2e\\uabc0-\\uabe2\\uac00-\\ud7a3\\ud7b0-\\ud7c6\\ud7cb-\\ud7fb\\uf900-\\ufa6d\\ufa70-\\ufad9\\ufb00-\\ufb06\\ufb13-\\ufb17\\ufb1d\\ufb1f-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40\\ufb41\\ufb43\\ufb44\\ufb46-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb\\ufe70-\\ufe74\\ufe76-\\ufefc\\uff21-\\uff3a\\uff41-\\uff5a\\uff66-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc\\u0300-\\u036f\\u0483-\\u0487\\u0591-\\u05bd\\u05bf\\u05c1\\u05c2\\u05c4\\u05c5\\u05c7\\u0610-\\u061a\\u0620-\\u0649\\u0672-\\u06d3\\u06e7-\\u06e8\\u06fb-\\u06fc\\u0730-\\u074a\\u0800-\\u0814\\u081b-\\u0823\\u0825-\\u0827\\u0829-\\u082d\\u0840-\\u0857\\u08e4-\\u08fe\\u0900-\\u0903\\u093a-\\u093c\\u093e-\\u094f\\u0951-\\u0957\\u0962-\\u0963\\u0966-\\u096f\\u0981-\\u0983\\u09bc\\u09be-\\u09c4\\u09c7\\u09c8\\u09d7\\u09df-\\u09e0\\u0a01-\\u0a03\\u0a3c\\u0a3e-\\u0a42\\u0a47\\u0a48\\u0a4b-\\u0a4d\\u0a51\\u0a66-\\u0a71\\u0a75\\u0a81-\\u0a83\\u0abc\\u0abe-\\u0ac5\\u0ac7-\\u0ac9\\u0acb-\\u0acd\\u0ae2-\\u0ae3\\u0ae6-\\u0aef\\u0b01-\\u0b03\\u0b3c\\u0b3e-\\u0b44\\u0b47\\u0b48\\u0b4b-\\u0b4d\\u0b56\\u0b57\\u0b5f-\\u0b60\\u0b66-\\u0b6f\\u0b82\\u0bbe-\\u0bc2\\u0bc6-\\u0bc8\\u0bca-\\u0bcd\\u0bd7\\u0be6-\\u0bef\\u0c01-\\u0c03\\u0c46-\\u0c48\\u0c4a-\\u0c4d\\u0c55\\u0c56\\u0c62-\\u0c63\\u0c66-\\u0c6f\\u0c82\\u0c83\\u0cbc\\u0cbe-\\u0cc4\\u0cc6-\\u0cc8\\u0cca-\\u0ccd\\u0cd5\\u0cd6\\u0ce2-\\u0ce3\\u0ce6-\\u0cef\\u0d02\\u0d03\\u0d46-\\u0d48\\u0d57\\u0d62-\\u0d63\\u0d66-\\u0d6f\\u0d82\\u0d83\\u0dca\\u0dcf-\\u0dd4\\u0dd6\\u0dd8-\\u0ddf\\u0df2\\u0df3\\u0e34-\\u0e3a\\u0e40-\\u0e45\\u0e50-\\u0e59\\u0eb4-\\u0eb9\\u0ec8-\\u0ecd\\u0ed0-\\u0ed9\\u0f18\\u0f19\\u0f20-\\u0f29\\u0f35\\u0f37\\u0f39\\u0f41-\\u0f47\\u0f71-\\u0f84\\u0f86-\\u0f87\\u0f8d-\\u0f97\\u0f99-\\u0fbc\\u0fc6\\u1000-\\u1029\\u1040-\\u1049\\u1067-\\u106d\\u1071-\\u1074\\u1082-\\u108d\\u108f-\\u109d\\u135d-\\u135f\\u170e-\\u1710\\u1720-\\u1730\\u1740-\\u1750\\u1772\\u1773\\u1780-\\u17b2\\u17dd\\u17e0-\\u17e9\\u180b-\\u180d\\u1810-\\u1819\\u1920-\\u192b\\u1930-\\u193b\\u1951-\\u196d\\u19b0-\\u19c0\\u19c8-\\u19c9\\u19d0-\\u19d9\\u1a00-\\u1a15\\u1a20-\\u1a53\\u1a60-\\u1a7c\\u1a7f-\\u1a89\\u1a90-\\u1a99\\u1b46-\\u1b4b\\u1b50-\\u1b59\\u1b6b-\\u1b73\\u1bb0-\\u1bb9\\u1be6-\\u1bf3\\u1c00-\\u1c22\\u1c40-\\u1c49\\u1c5b-\\u1c7d\\u1cd0-\\u1cd2\\u1d00-\\u1dbe\\u1e01-\\u1f15\\u200c\\u200d\\u203f\\u2040\\u2054\\u20d0-\\u20dc\\u20e1\\u20e5-\\u20f0\\u2d81-\\u2d96\\u2de0-\\u2dff\\u3021-\\u3028\\u3099\\u309a\\ua640-\\ua66d\\ua674-\\ua67d\\ua69f\\ua6f0-\\ua6f1\\ua7f8-\\ua800\\ua806\\ua80b\\ua823-\\ua827\\ua880-\\ua881\\ua8b4-\\ua8c4\\ua8d0-\\ua8d9\\ua8f3-\\ua8f7\\ua900-\\ua909\\ua926-\\ua92d\\ua930-\\ua945\\ua980-\\ua983\\ua9b3-\\ua9c0\\uaa00-\\uaa27\\uaa40-\\uaa41\\uaa4c-\\uaa4d\\uaa50-\\uaa59\\uaa7b\\uaae0-\\uaae9\\uaaf2-\\uaaf3\\uabc0-\\uabe1\\uabec\\uabed\\uabf0-\\uabf9\\ufb20-\\ufb28\\ufe00-\\ufe0f\\ufe20-\\ufe26\\ufe33\\ufe34\\ufe4d-\\ufe4f\\uff10-\\uff19\\uff3f])*","g"),e.identifierStart=new RegExp(s),e.identifierMatch=new RegExp("(?:\\\\u[0-9a-fA-F]{4}|["+i+n+_+"])+");e.newline=/[\n\r\u2028\u2029]/,e.lineBreak=new RegExp("\r\n|"+e.newline.source),e.allLineBreaks=new RegExp(e.lineBreak.source,"g")},function(t,e,u){"use strict";var n=u(6).Options,_=["before-newline","after-newline","preserve-newline"];function i(t){n.call(this,t,"js");var e=this.raw_options.brace_style||null;"expand-strict"===e?this.raw_options.brace_style="expand":"collapse-preserve-inline"===e?this.raw_options.brace_style="collapse,preserve-inline":void 0!==this.raw_options.braces_on_own_line&&(this.raw_options.brace_style=this.raw_options.braces_on_own_line?"expand":"collapse");var u=this._get_selection_list("brace_style",["collapse","expand","end-expand","none","preserve-inline"]);this.brace_preserve_inline=!1,this.brace_style="collapse";for(var i=0;i<u.length;i++)"preserve-inline"===u[i]?this.brace_preserve_inline=!0:this.brace_style=u[i];this.unindent_chained_methods=this._get_boolean("unindent_chained_methods"),this.break_chained_methods=this._get_boolean("break_chained_methods"),this.space_in_paren=this._get_boolean("space_in_paren"),this.space_in_empty_paren=this._get_boolean("space_in_empty_paren"),this.jslint_happy=this._get_boolean("jslint_happy"),this.space_after_anon_function=this._get_boolean("space_after_anon_function"),this.space_after_named_function=this._get_boolean("space_after_named_function"),this.keep_array_indentation=this._get_boolean("keep_array_indentation"),this.space_before_conditional=this._get_boolean("space_before_conditional",!0),this.unescape_strings=this._get_boolean("unescape_strings"),this.e4x=this._get_boolean("e4x"),this.comma_first=this._get_boolean("comma_first"),this.operator_position=this._get_selection("operator_position",_),this.test_output_raw=this._get_boolean("test_output_raw"),this.jslint_happy&&(this.space_after_anon_function=!0)}i.prototype=new n,t.exports.Options=i},function(t,e,u){"use strict";function i(t,e){this.raw_options=n(t,e),this.disabled=this._get_boolean("disabled"),this.eol=this._get_characters("eol","auto"),this.end_with_newline=this._get_boolean("end_with_newline"),this.indent_size=this._get_number("indent_size",4),this.indent_char=this._get_characters("indent_char"," "),this.indent_level=this._get_number("indent_level"),this.preserve_newlines=this._get_boolean("preserve_newlines",!0),this.max_preserve_newlines=this._get_number("max_preserve_newlines",32786),this.preserve_newlines||(this.max_preserve_newlines=0),this.indent_with_tabs=this._get_boolean("indent_with_tabs","\t"===this.indent_char),this.indent_with_tabs&&(this.indent_char="\t",1===this.indent_size&&(this.indent_size=4)),this.wrap_line_length=this._get_number("wrap_line_length",this._get_number("max_char"))}function n(t,e){var u,i={};for(u in t=_(t))u!==e&&(i[u]=t[u]);if(e&&t[e])for(u in t[e])i[u]=t[e][u];return i}function _(t){var e,u={};for(e in t){u[e.replace(/-/g,"_")]=t[e]}return u}i.prototype._get_array=function(t,e){var u=this.raw_options[t],i=e||[];return"object"==typeof u?null!==u&&"function"==typeof u.concat&&(i=u.concat()):"string"==typeof u&&(i=u.split(/[^a-zA-Z0-9_\/\-]+/)),i},i.prototype._get_boolean=function(t,e){var u=this.raw_options[t];return void 0===u?!!e:!!u},i.prototype._get_characters=function(t,e){var u=this.raw_options[t],i=e||"";return"string"==typeof u&&(i=u.replace(/\\r/,"\r").replace(/\\n/,"\n").replace(/\\t/,"\t")),i},i.prototype._get_number=function(t,e){var u=this.raw_options[t];e=parseInt(e,10),isNaN(e)&&(e=0);var i=parseInt(u,10);return isNaN(i)&&(i=e),i},i.prototype._get_selection=function(t,e,u){var i=this._get_selection_list(t,e,u);if(1!==i.length)throw new Error("Invalid Option Value: The option '"+t+"' can only be one of the following values:\n"+e+"\nYou passed in: '"+this.raw_options[t]+"'");return i[0]},i.prototype._get_selection_list=function(t,e,u){if(!e||0===e.length)throw new Error("Selection list cannot be empty.");if(u=u||[e[0]],!this._is_valid_selection(u,e))throw new Error("Invalid Default Value!");var i=this._get_array(t,u);if(!this._is_valid_selection(i,e))throw new Error("Invalid Option Value: The option '"+t+"' can contain only the following values:\n"+e+"\nYou passed in: '"+this.raw_options[t]+"'");return i},i.prototype._is_valid_selection=function(t,e){return t.length&&e.length&&!t.some(function(t){return-1===e.indexOf(t)})},t.exports.Options=i,t.exports.normalizeOpts=_,t.exports.mergeOpts=n},function(t,e,u){"use strict";var _=u(8).InputScanner,n=u(9).Tokenizer,i=u(9).TOKEN,s=u(13).Directives,r=u(4),a=u(12).Pattern,o=u(14).TemplatablePattern;function h(t,e){return-1!==e.indexOf(t)}var p={START_EXPR:"TK_START_EXPR",END_EXPR:"TK_END_EXPR",START_BLOCK:"TK_START_BLOCK",END_BLOCK:"TK_END_BLOCK",WORD:"TK_WORD",RESERVED:"TK_RESERVED",SEMICOLON:"TK_SEMICOLON",STRING:"TK_STRING",EQUALS:"TK_EQUALS",OPERATOR:"TK_OPERATOR",COMMA:"TK_COMMA",BLOCK_COMMENT:"TK_BLOCK_COMMENT",COMMENT:"TK_COMMENT",DOT:"TK_DOT",UNKNOWN:"TK_UNKNOWN",START:i.START,RAW:i.RAW,EOF:i.EOF},l=new s(/\/\*/,/\*\//),f=/0[xX][0123456789abcdefABCDEF]*|0[oO][01234567]*|0[bB][01]*|\d+n|(?:\.\d+|\d+\.?\d*)(?:[eE][+-]?\d+)?/,c=/[0-9]/,d=/[^\d\.]/,b=">>> === !== << && >= ** != == <= >> || < / - + > : & % ? ^ | *".split(" "),g=">>>= ... >>= <<= === >>> !== **= => ^= :: /= << <= == && -= >= >> != -- += ** || ++ %= &= *= |= = ! ? > < : / ^ - + * & % ~ |";g=(g=g.replace(/[-[\]{}()*+?.,\\^$|#]/g,"\\$&")).replace(/ /g,"|");var k,m=new RegExp(g),w="continue,try,throw,return,var,let,const,if,switch,case,default,for,while,break,function,import,export".split(","),y=w.concat(["do","in","of","else","get","set","new","catch","finally","typeof","yield","async","await","from","as"]),x=new RegExp("^(?:"+y.join("|")+")$"),v=function(t,e){n.call(this,t,e),this._patterns.whitespace=this._patterns.whitespace.matching(/\u00A0\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff/.source,/\u2028\u2029/.source);var u=new a(this._input),i=new o(this._input);i=(i=i.disable("handlebars")).disable("django"),this.__patterns={template:i,identifier:i.starting_with(r.identifier).matching(r.identifierMatch),number:u.matching(f),punct:u.matching(m),comment:u.starting_with(/\/\//).until(/[\n\r\u2028\u2029]/),block_comment:u.starting_with(/\/\*/).until_after(/\*\//),html_comment_start:u.matching(/<!--/),html_comment_end:u.matching(/-->/),include:u.starting_with(/#include/).until_after(r.lineBreak),shebang:u.starting_with(/#!/).until_after(r.lineBreak),xml:u.matching(/[\s\S]*?<(\/?)([-a-zA-Z:0-9_.]+|{[\s\S]+?}|!\[CDATA\[[\s\S]*?\]\])(\s+{[\s\S]+?}|\s+[-a-zA-Z:0-9_.]+|\s+[-a-zA-Z:0-9_.]+\s*=\s*('[^']*'|"[^"]*"|{[\s\S]+?}))*\s*(\/?)\s*>/),single_quote:i.until(/['\\\n\r\u2028\u2029]/),double_quote:i.until(/["\\\n\r\u2028\u2029]/),template_text:i.until(/[`\\$]/),template_expression:i.until(/[`}\\]/)}};(v.prototype=new n)._is_comment=function(t){return t.type===p.COMMENT||t.type===p.BLOCK_COMMENT||t.type===p.UNKNOWN},v.prototype._is_opening=function(t){return t.type===p.START_BLOCK||t.type===p.START_EXPR},v.prototype._is_closing=function(t,e){return(t.type===p.END_BLOCK||t.type===p.END_EXPR)&&e&&("]"===t.text&&"["===e.text||")"===t.text&&"("===e.text||"}"===t.text&&"{"===e.text)},v.prototype._reset=function(){k=!1},v.prototype._get_next_token=function(t,e){var u=null;this._readWhitespace();var i=this._input.peek();return null===i?this._create_token(p.EOF,""):u=(u=(u=(u=(u=(u=(u=(u=(u=u||this._read_string(i))||this._read_word(t))||this._read_singles(i))||this._read_comment(i))||this._read_regexp(i,t))||this._read_xml(i,t))||this._read_non_javascript(i))||this._read_punctuation())||this._create_token(p.UNKNOWN,this._input.next())},v.prototype._read_word=function(t){var e;return""!==(e=this.__patterns.identifier.read())?(e=e.replace(r.allLineBreaks,"\n"),t.type!==p.DOT&&(t.type!==p.RESERVED||"set"!==t.text&&"get"!==t.text)&&x.test(e)?"in"===e||"of"===e?this._create_token(p.OPERATOR,e):this._create_token(p.RESERVED,e):this._create_token(p.WORD,e)):""!==(e=this.__patterns.number.read())?this._create_token(p.WORD,e):void 0},v.prototype._read_singles=function(t){var e=null;return"("===t||"["===t?e=this._create_token(p.START_EXPR,t):")"===t||"]"===t?e=this._create_token(p.END_EXPR,t):"{"===t?e=this._create_token(p.START_BLOCK,t):"}"===t?e=this._create_token(p.END_BLOCK,t):";"===t?e=this._create_token(p.SEMICOLON,t):"."===t&&d.test(this._input.peek(1))?e=this._create_token(p.DOT,t):","===t&&(e=this._create_token(p.COMMA,t)),e&&this._input.next(),e},v.prototype._read_punctuation=function(){var t=this.__patterns.punct.read();if(""!==t)return"="===t?this._create_token(p.EQUALS,t):this._create_token(p.OPERATOR,t)},v.prototype._read_non_javascript=function(t){var e="";if("#"===t){if(this._is_first_token()&&(e=this.__patterns.shebang.read()))return this._create_token(p.UNKNOWN,e.trim()+"\n");if(e=this.__patterns.include.read())return this._create_token(p.UNKNOWN,e.trim()+"\n");t=this._input.next();var u="#";if(this._input.hasNext()&&this._input.testChar(c)){for(;u+=t=this._input.next(),this._input.hasNext()&&"#"!==t&&"="!==t;);return"#"===t||("["===this._input.peek()&&"]"===this._input.peek(1)?(u+="[]",this._input.next(),this._input.next()):"{"===this._input.peek()&&"}"===this._input.peek(1)&&(u+="{}",this._input.next(),this._input.next())),this._create_token(p.WORD,u)}this._input.back()}else if("<"===t){if(e=this.__patterns.html_comment_start.read()){for(;this._input.hasNext()&&!this._input.testChar(r.newline);)e+=this._input.next();return k=!0,this._create_token(p.COMMENT,e)}}else if(k&&"-"===t&&(e=this.__patterns.html_comment_end.read()))return k=!1,this._create_token(p.COMMENT,e);return null},v.prototype._read_comment=function(t){var e=null;if("/"===t){var u="";if("*"===this._input.peek(1)){u=this.__patterns.block_comment.read();var i=l.get_directives(u);i&&"start"===i.ignore&&(u+=l.readIgnored(this._input)),u=u.replace(r.allLineBreaks,"\n"),(e=this._create_token(p.BLOCK_COMMENT,u)).directives=i}else"/"===this._input.peek(1)&&(u=this.__patterns.comment.read(),e=this._create_token(p.COMMENT,u))}return e},v.prototype._read_string=function(t){if("`"!==t&&"'"!==t&&'"'!==t)return null;var e=this._input.next();return this.has_char_escapes=!1,e+="`"===t?this._read_string_recursive("`",!0,"${"):this._read_string_recursive(t),this.has_char_escapes&&this._options.unescape_strings&&(e=function(t){var e="",u=0,i=new _(t),n=null;for(;i.hasNext();)if((n=i.match(/([\s]|[^\\]|\\\\)+/g))&&(e+=n[0]),"\\"===i.peek()){if(i.next(),"x"===i.peek())n=i.match(/x([0-9A-Fa-f]{2})/g);else{if("u"!==i.peek()){e+="\\",i.hasNext()&&(e+=i.next());continue}n=i.match(/u([0-9A-Fa-f]{4})/g)}if(!n)return t;if(126<(u=parseInt(n[1],16))&&u<=255&&0===n[0].indexOf("x"))return t;if(0<=u&&u<32){e+="\\"+n[0];continue}e+=34===u||39===u||92===u?"\\"+String.fromCharCode(u):String.fromCharCode(u)}return e}(e)),this._input.peek()===t&&(e+=this._input.next()),e=e.replace(r.allLineBreaks,"\n"),this._create_token(p.STRING,e)},v.prototype._allow_regexp_or_xml=function(t){return t.type===p.RESERVED&&h(t.text,["return","case","throw","else","do","typeof","yield"])||t.type===p.END_EXPR&&")"===t.text&&t.opened.previous.type===p.RESERVED&&h(t.opened.previous.text,["if","while","for"])||h(t.type,[p.COMMENT,p.START_EXPR,p.START_BLOCK,p.START,p.END_BLOCK,p.OPERATOR,p.EQUALS,p.EOF,p.SEMICOLON,p.COMMA])},v.prototype._read_regexp=function(t,e){if("/"===t&&this._allow_regexp_or_xml(e)){for(var u=this._input.next(),i=!1,n=!1;this._input.hasNext()&&(i||n||this._input.peek()!==t)&&!this._input.testChar(r.newline);)u+=this._input.peek(),i?i=!1:(i="\\"===this._input.peek(),"["===this._input.peek()?n=!0:"]"===this._input.peek()&&(n=!1)),this._input.next();return this._input.peek()===t&&(u+=this._input.next(),u+=this._input.read(r.identifier)),this._create_token(p.STRING,u)}return null},v.prototype._read_xml=function(t,e){if(this._options.e4x&&"<"===t&&this._allow_regexp_or_xml(e)){var u="",i=this.__patterns.xml.read_match();if(i){for(var n=i[2].replace(/^{\s+/,"{").replace(/\s+}$/,"}"),_=0===n.indexOf("{"),s=0;i;){var a=!!i[1],o=i[2];if(!(!!i[i.length-1]||"![CDATA["===o.slice(0,8))&&(o===n||_&&o.replace(/^{\s+/,"{").replace(/\s+}$/,"}"))&&(a?--s:++s),u+=i[0],s<=0)break;i=this.__patterns.xml.read_match()}return i||(u+=this._input.match(/[\s\S]*/g)[0]),u=u.replace(r.allLineBreaks,"\n"),this._create_token(p.STRING,u)}}return null},v.prototype._read_string_recursive=function(t,e,u){var i,n;"'"===t?n=this.__patterns.single_quote:'"'===t?n=this.__patterns.double_quote:"`"===t?n=this.__patterns.template_text:"}"===t&&(n=this.__patterns.template_expression);for(var _=n.read(),s="";this._input.hasNext();){if((s=this._input.next())===t||!e&&r.newline.test(s)){this._input.back();break}"\\"===s&&this._input.hasNext()?("x"===(i=this._input.peek())||"u"===i?this.has_char_escapes=!0:"\r"===i&&"\n"===this._input.peek(1)&&this._input.next(),s+=this._input.next()):u&&("${"===u&&"$"===s&&"{"===this._input.peek()&&(s+=this._input.next()),u===s&&(s+="`"===t?this._read_string_recursive("}",e,"`"):this._read_string_recursive("`",e,"${"),this._input.hasNext()&&(s+=this._input.next()))),_+=s+=n.read()}return _},t.exports.Tokenizer=v,t.exports.TOKEN=p,t.exports.positionable_operators=b.slice(),t.exports.line_starters=w.slice()},function(t,e,u){"use strict";var n=RegExp.prototype.hasOwnProperty("sticky");function i(t){this.__input=t||"",this.__input_length=this.__input.length,this.__position=0}i.prototype.restart=function(){this.__position=0},i.prototype.back=function(){0<this.__position&&(this.__position-=1)},i.prototype.hasNext=function(){return this.__position<this.__input_length},i.prototype.next=function(){var t=null;return this.hasNext()&&(t=this.__input.charAt(this.__position),this.__position+=1),t},i.prototype.peek=function(t){var e=null;return t=t||0,0<=(t+=this.__position)&&t<this.__input_length&&(e=this.__input.charAt(t)),e},i.prototype.__match=function(t,e){t.lastIndex=e;var u=t.exec(this.__input);return!u||n&&t.sticky||u.index!==e&&(u=null),u},i.prototype.test=function(t,e){return e=e||0,0<=(e+=this.__position)&&e<this.__input_length&&!!this.__match(t,e)},i.prototype.testChar=function(t,e){var u=this.peek(e);return t.lastIndex=0,null!==u&&t.test(u)},i.prototype.match=function(t){var e=this.__match(t,this.__position);return e?this.__position+=e[0].length:e=null,e},i.prototype.read=function(t,e,u){var i,n="";return t&&(i=this.match(t))&&(n+=i[0]),!e||!i&&t||(n+=this.readUntil(e,u)),n},i.prototype.readUntil=function(t,e){var u,i=this.__position;t.lastIndex=this.__position;var n=t.exec(this.__input);return n?(i=n.index,e&&(i+=n[0].length)):i=this.__input_length,u=this.__input.substring(this.__position,i),this.__position=i,u},i.prototype.readUntilAfter=function(t){return this.readUntil(t,!0)},i.prototype.get_regexp=function(t,e){var u=null,i="g";return e&&n&&(i="y"),"string"==typeof t&&""!==t?u=new RegExp(t,i):t&&(u=new RegExp(t.source,i)),u},i.prototype.get_literal_regexp=function(t){return RegExp(t.replace(/[-\/\\^$*+?.()|[\]{}]/g,"\\$&"))},i.prototype.peekUntilAfter=function(t){var e=this.__position,u=this.readUntilAfter(t);return this.__position=e,u},i.prototype.lookBack=function(t){var e=this.__position-1;return e>=t.length&&this.__input.substring(e-t.length,e).toLowerCase()===t},t.exports.InputScanner=i},function(t,e,u){"use strict";var i=u(8).InputScanner,_=u(3).Token,s=u(10).TokenStream,n=u(11).WhitespacePattern,a={START:"TK_START",RAW:"TK_RAW",EOF:"TK_EOF"},o=function(t,e){this._input=new i(t),this._options=e||{},this.__tokens=null,this._patterns={},this._patterns.whitespace=new n(this._input)};o.prototype.tokenize=function(){var t;this._input.restart(),this.__tokens=new s,this._reset();for(var e=new _(a.START,""),u=null,i=[],n=new s;e.type!==a.EOF;){for(t=this._get_next_token(e,u);this._is_comment(t);)n.add(t),t=this._get_next_token(e,u);n.isEmpty()||(t.comments_before=n,n=new s),t.parent=u,this._is_opening(t)?(i.push(u),u=t):u&&this._is_closing(t,u)&&((t.opened=u).closed=t,u=i.pop(),t.parent=u),(t.previous=e).next=t,this.__tokens.add(t),e=t}return this.__tokens},o.prototype._is_first_token=function(){return this.__tokens.isEmpty()},o.prototype._reset=function(){},o.prototype._get_next_token=function(t,e){this._readWhitespace();var u=this._input.read(/.+/g);return u?this._create_token(a.RAW,u):this._create_token(a.EOF,"")},o.prototype._is_comment=function(t){return!1},o.prototype._is_opening=function(t){return!1},o.prototype._is_closing=function(t,e){return!1},o.prototype._create_token=function(t,e){return new _(t,e,this._patterns.whitespace.newline_count,this._patterns.whitespace.whitespace_before_token)},o.prototype._readWhitespace=function(){return this._patterns.whitespace.read()},t.exports.Tokenizer=o,t.exports.TOKEN=a},function(t,e,u){"use strict";function i(t){this.__tokens=[],this.__tokens_length=this.__tokens.length,this.__position=0,this.__parent_token=t}i.prototype.restart=function(){this.__position=0},i.prototype.isEmpty=function(){return 0===this.__tokens_length},i.prototype.hasNext=function(){return this.__position<this.__tokens_length},i.prototype.next=function(){var t=null;return this.hasNext()&&(t=this.__tokens[this.__position],this.__position+=1),t},i.prototype.peek=function(t){var e=null;return t=t||0,0<=(t+=this.__position)&&t<this.__tokens_length&&(e=this.__tokens[t]),e},i.prototype.add=function(t){this.__parent_token&&(t.parent=this.__parent_token),this.__tokens.push(t),this.__tokens_length+=1},t.exports.TokenStream=i},function(t,e,u){"use strict";var i=u(12).Pattern;function n(t,e){i.call(this,t,e),e?this._line_regexp=this._input.get_regexp(e._line_regexp):this.__set_whitespace_patterns("",""),this.newline_count=0,this.whitespace_before_token=""}(n.prototype=new i).__set_whitespace_patterns=function(t,e){t+="\\t ",e+="\\n\\r",this._match_pattern=this._input.get_regexp("["+t+e+"]+",!0),this._newline_regexp=this._input.get_regexp("\\r\\n|["+e+"]")},n.prototype.read=function(){this.newline_count=0,this.whitespace_before_token="";var t=this._input.read(this._match_pattern);if(" "===t)this.whitespace_before_token=" ";else if(t){var e=this.__split(this._newline_regexp,t);this.newline_count=e.length-1,this.whitespace_before_token=e[this.newline_count]}return t},n.prototype.matching=function(t,e){var u=this._create();return u.__set_whitespace_patterns(t,e),u._update(),u},n.prototype._create=function(){return new n(this._input,this)},n.prototype.__split=function(t,e){for(var u=t.lastIndex=0,i=[],n=t.exec(e);n;)i.push(e.substring(u,n.index)),u=n.index+n[0].length,n=t.exec(e);return u<e.length?i.push(e.substring(u,e.length)):i.push(""),i},t.exports.WhitespacePattern=n},function(t,e,u){"use strict";function i(t,e){this._input=t,this._starting_pattern=null,this._match_pattern=null,this._until_pattern=null,this._until_after=!1,e&&(this._starting_pattern=this._input.get_regexp(e._starting_pattern,!0),this._match_pattern=this._input.get_regexp(e._match_pattern,!0),this._until_pattern=this._input.get_regexp(e._until_pattern),this._until_after=e._until_after)}i.prototype.read=function(){var t=this._input.read(this._starting_pattern);return this._starting_pattern&&!t||(t+=this._input.read(this._match_pattern,this._until_pattern,this._until_after)),t},i.prototype.read_match=function(){return this._input.match(this._match_pattern)},i.prototype.until_after=function(t){var e=this._create();return e._until_after=!0,e._until_pattern=this._input.get_regexp(t),e._update(),e},i.prototype.until=function(t){var e=this._create();return e._until_after=!1,e._until_pattern=this._input.get_regexp(t),e._update(),e},i.prototype.starting_with=function(t){var e=this._create();return e._starting_pattern=this._input.get_regexp(t,!0),e._update(),e},i.prototype.matching=function(t){var e=this._create();return e._match_pattern=this._input.get_regexp(t,!0),e._update(),e},i.prototype._create=function(){return new i(this._input,this)},i.prototype._update=function(){},t.exports.Pattern=i},function(t,e,u){"use strict";function i(t,e){t="string"==typeof t?t:t.source,e="string"==typeof e?e:e.source,this.__directives_block_pattern=new RegExp(t+/ beautify( \w+[:]\w+)+ /.source+e,"g"),this.__directive_pattern=/ (\w+)[:](\w+)/g,this.__directives_end_ignore_pattern=new RegExp(t+/\sbeautify\signore:end\s/.source+e,"g")}i.prototype.get_directives=function(t){if(!t.match(this.__directives_block_pattern))return null;var e={};this.__directive_pattern.lastIndex=0;for(var u=this.__directive_pattern.exec(t);u;)e[u[1]]=u[2],u=this.__directive_pattern.exec(t);return e},i.prototype.readIgnored=function(t){return t.readUntilAfter(this.__directives_end_ignore_pattern)},t.exports.Directives=i},function(t,e,u){"use strict";var i=u(12).Pattern,n={django:!1,erb:!1,handlebars:!1,php:!1};function _(t,e){i.call(this,t,e),this.__template_pattern=null,this._disabled=Object.assign({},n),this._excluded=Object.assign({},n),e&&(this.__template_pattern=this._input.get_regexp(e.__template_pattern),this._excluded=Object.assign(this._excluded,e._excluded),this._disabled=Object.assign(this._disabled,e._disabled));var u=new i(t);this.__patterns={handlebars_comment:u.starting_with(/{{!--/).until_after(/--}}/),handlebars:u.starting_with(/{{/).until_after(/}}/),php:u.starting_with(/<\?(?:[=]|php)/).until_after(/\?>/),erb:u.starting_with(/<%[^%]/).until_after(/[^%]%>/),django:u.starting_with(/{%/).until_after(/%}/),django_value:u.starting_with(/{{/).until_after(/}}/),django_comment:u.starting_with(/{#/).until_after(/#}/)}}(_.prototype=new i)._create=function(){return new _(this._input,this)},_.prototype._update=function(){this.__set_templated_pattern()},_.prototype.disable=function(t){var e=this._create();return e._disabled[t]=!0,e._update(),e},_.prototype.exclude=function(t){var e=this._create();return e._excluded[t]=!0,e._update(),e},_.prototype.read=function(){var t="";t=this._match_pattern?this._input.read(this._starting_pattern):this._input.read(this._starting_pattern,this.__template_pattern);for(var e=this._read_template();e;)this._match_pattern?e+=this._input.read(this._match_pattern):e+=this._input.readUntil(this.__template_pattern),t+=e,e=this._read_template();return this._until_after&&(t+=this._input.readUntilAfter(this._until_pattern)),t},_.prototype.__set_templated_pattern=function(){var t=[];this._disabled.php||t.push(this.__patterns.php._starting_pattern.source),this._disabled.handlebars||t.push(this.__patterns.handlebars._starting_pattern.source),this._disabled.erb||t.push(this.__patterns.erb._starting_pattern.source),this._disabled.django||(t.push(this.__patterns.django._starting_pattern.source),t.push(this.__patterns.django_value._starting_pattern.source),t.push(this.__patterns.django_comment._starting_pattern.source)),this._until_pattern&&t.push(this._until_pattern.source),this.__template_pattern=this._input.get_regexp("(?:"+t.join("|")+")")},_.prototype._read_template=function(){var t="",e=this._input.peek();if("<"===e){var u=this._input.peek(1);this._disabled.php||this._excluded.php||"?"!==u||(t=t||this.__patterns.php.read()),this._disabled.erb||this._excluded.erb||"%"!==u||(t=t||this.__patterns.erb.read())}else"{"===e&&(this._disabled.handlebars||this._excluded.handlebars||(t=(t=t||this.__patterns.handlebars_comment.read())||this.__patterns.handlebars.read()),this._disabled.django||(this._excluded.django||this._excluded.handlebars||(t=t||this.__patterns.django_value.read()),this._excluded.django||(t=(t=t||this.__patterns.django_comment.read())||this.__patterns.django.read())));return t},t.exports.TemplatablePattern=_}]);"function"==typeof define&&define.amd?define([],function(){return{js_beautify:t}}):"undefined"!=typeof exports?exports.js_beautify=t:"undefined"!=typeof window?window.js_beautify=t:"undefined"!=typeof global&&(global.js_beautify=t)}();
\ No newline at end of file
diff --git a/_server/MotaAction.g4 b/_server/MotaAction.g4
new file mode 100644
index 00000000..d8593e39
--- /dev/null
+++ b/_server/MotaAction.g4
@@ -0,0 +1,2944 @@
+grammar MotaAction;
+
+//===============parser===============
+//===blockly语句===
+
+//事件 事件编辑器入口之一
+event_m
+    :   '事件' BGNL? Newline '覆盖触发器' Bool '启用' Bool '通行状态' B_0_List '显伤' Bool BGNL? Newline action+ BEND
+    
+
+/* event_m
+tooltip : 编辑魔塔的事件
+helpUrl : https://h5mota.com/games/template/docs/#/event
+default : [false,null,null,null,null]
+B_0_List_0=eval(B_0_List_0);
+var code = {
+    'trigger': Bool_0?'action':null,
+    'enable': Bool_1,
+    'noPass': B_0_List_0,
+    'displayDamage': Bool_2,
+    'data': 'data_asdfefw'
+}
+if (!Bool_0 && Bool_1 && (B_0_List_0===null) && Bool_2) code = 'data_asdfefw';
+code=JSON.stringify(code,null,2).split('"data_asdfefw"').join('[\n'+action_0+']\n');
+return code;
+*/;
+
+
+//升级 事件编辑器入口之一
+level_m
+    :   '等级提升' BGNL? Newline levelCase+ BEND
+    
+
+/* level_m
+tooltip : 升级事件
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=%e7%bb%8f%e9%aa%8c%e5%8d%87%e7%ba%a7%ef%bc%88%e8%bf%9b%e9%98%b6%2f%e5%a2%83%e7%95%8c%e5%a1%94%ef%bc%89
+var code = '[\n'+levelCase_0+']\n';
+return code;
+*/;
+
+levelCase
+    :   '需求' expression '称号' EvalString? '是否扣除经验' Bool BGNL? Newline action+
+
+
+/* levelCase
+tooltip : 升级设定
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=%e7%bb%8f%e9%aa%8c%e5%8d%87%e7%ba%a7%ef%bc%88%e8%bf%9b%e9%98%b6%2f%e5%a2%83%e7%95%8c%e5%a1%94%ef%bc%89
+default : [0,"",false,null]
+colour : this.subColor
+Bool_0 = Bool_0?', "clear": true':'';
+var code = '{"need": "'+expression_0+'", "title": "'+EvalString_0+'"'+Bool_0+', "action": [\n'+action_0+']},\n';
+return code;
+*/;
+
+//商店 事件编辑器入口之一
+shop_m
+    :   '全局商店列表' BGNL? Newline shoplist+
+    
+/* shop_m
+tooltip : 全局商店列表
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=%e5%85%a8%e5%b1%80%e5%95%86%e5%ba%97
+var code = '['+shoplist_0+']\n';
+return code;
+*/;
+
+shoplist
+    :   shopsub
+    |   shopcommonevent
+    |   emptyshop
+    ;
+
+emptyshop
+    :   Newline
+    
+
+/* emptyshop
+var code = ' \n';
+return code;
+*/;
+
+shopcommonevent
+    :   '商店 id' IdString '快捷商店栏中名称' EvalString BGNL? '未开启状态则不显示在列表中' Bool BGNL? '执行的公共事件 id' EvalString '参数列表' EvalString?
+    
+/* shopcommonevent
+tooltip : 全局商店, 执行一个公共事件
+helpUrl : https://h5mota.com/games/template/docs/#/
+default : ["shop1","回收钥匙商店",false,"回收钥匙商店",""]
+if (EvalString_2) {
+    if (EvalString_2.indexOf('"')>=0)
+        throw new Error('请勿在此处使用双引号！尝试使用单引号吧~');
+    // 检查是不是数组
+    try {
+        EvalString_2 = JSON.parse(EvalString_2.replace(/'/g, '"'));
+        if (!(EvalString_2 instanceof Array)) throw new Error();
+    }
+    catch (e) {
+        throw new Error('参数列表必须是个有效的数组！');
+    }
+}
+var code = {
+    'id': IdString_0,
+    'textInList': EvalString_0,
+    'mustEnable': Bool_0,
+    'commonEvent': EvalString_1
+}
+if (EvalString_2) code.args = EvalString_2;
+code=JSON.stringify(code,null,2)+',\n';
+return code;
+*/;
+
+shopsub
+    :   '商店 id' IdString '标题' EvalString '图标' IdString BGNL? Newline '快捷商店栏中名称' EvalString '共用times' Bool BGNL? Newline '未开启状态则不显示在列表中' Bool BGNL? NewLine '使用' ShopUse_List '消耗' EvalString BGNL? Newline '显示文字' EvalString BGNL? Newline shopChoices+ BEND
+    
+
+/* shopsub
+tooltip : 全局商店,消耗填-1表示每个选项的消耗不同,正数表示消耗数值
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=%e5%85%a8%e5%b1%80%e5%95%86%e5%ba%97
+default : ["shop1","贪婪之神","blueShop","1F金币商店",false,false,null,"20+10*times*(times+1)","勇敢的武士啊, 给我${need}金币就可以："]
+var code = {
+    'id': IdString_0,
+    'name': EvalString_0,
+    'icon': IdString_1,
+    'textInList': EvalString_1,
+    'commonTimes': Bool_0,
+    'mustEnable': Bool_1,
+    'use': ShopUse_List_0,
+    'need': EvalString_2,
+    'text': EvalString_3,
+    'choices': 'choices_asdfefw'
+}
+code=JSON.stringify(code,null,2).split('"choices_asdfefw"').join('[\n'+shopChoices_0+']\n')+',\n';
+return code;
+*/;
+
+shopChoices
+    :   '商店选项' EvalString '消耗' EvalString? BGNL? Newline shopEffect+
+    
+
+/* shopChoices
+tooltip : 商店选项,商店消耗是-1时,这里的消耗对应各自选项的消耗,商店消耗不是-1时这里的消耗不填
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=%e5%85%a8%e5%b1%80%e5%95%86%e5%ba%97
+default : ["攻击+1",""]
+colour : this.subColor
+EvalString_1 = EvalString_1 && (', "need": "'+EvalString_1+'"');
+var code = '{"text": "'+EvalString_0+'"'+EvalString_1+', "effect": "'+shopEffect_0.slice(2,-1)+'"},\n';
+return code;
+*/;
+
+shopEffect
+    :   idString_e '+=' expression
+    
+
+/* shopEffect
+colour : this.subColor
+var code = idString_e_0+'+='+expression_0+';'
+return code;
+*/;
+
+//afterBattle 事件编辑器入口之一
+afterBattle_m
+    :   '战斗结束后' BGNL? Newline action+ BEND
+    
+
+/* afterBattle_m
+tooltip : 系统引发的自定义事件
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=%e7%b3%bb%e7%bb%9f%e5%bc%95%e5%8f%91%e7%9a%84%e8%87%aa%e5%ae%9a%e4%b9%89%e4%ba%8b%e4%bb%b6
+var code = '[\n'+action_0+']\n';
+return code;
+*/;
+
+//afterGetItem 事件编辑器入口之一
+afterGetItem_m
+    :   '获取道具后' BGNL? Newline action+ BEND
+    
+
+/* afterGetItem_m
+tooltip : 系统引发的自定义事件
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=%e7%b3%bb%e7%bb%9f%e5%bc%95%e5%8f%91%e7%9a%84%e8%87%aa%e5%ae%9a%e4%b9%89%e4%ba%8b%e4%bb%b6
+var code = '[\n'+action_0+']\n';
+return code;
+*/;
+
+//afterOpenDoor 事件编辑器入口之一
+afterOpenDoor_m
+    :   '打开门后' BGNL? Newline action+ BEND
+    
+
+/* afterOpenDoor_m
+tooltip : 系统引发的自定义事件
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=%e7%b3%bb%e7%bb%9f%e5%bc%95%e5%8f%91%e7%9a%84%e8%87%aa%e5%ae%9a%e4%b9%89%e4%ba%8b%e4%bb%b6
+var code = '[\n'+action_0+']\n';
+return code;
+*/;
+
+//firstArrive 事件编辑器入口之一
+firstArrive_m
+    :   '首次到达楼层' BGNL? Newline action+ BEND
+    
+
+/* firstArrive_m
+tooltip : 首次到达楼层
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=%e7%b3%bb%e7%bb%9f%e5%bc%95%e5%8f%91%e7%9a%84%e8%87%aa%e5%ae%9a%e4%b9%89%e4%ba%8b%e4%bb%b6
+var code = '[\n'+action_0+']\n';
+return code;
+*/;
+
+//eachArrive 事件编辑器入口之一
+eachArrive_m
+    :   '每次到达楼层' BGNL? Newline action+ BEND
+
+
+/* eachArrive_m
+tooltip : 每次到达楼层
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=%e7%b3%bb%e7%bb%9f%e5%bc%95%e5%8f%91%e7%9a%84%e8%87%aa%e5%ae%9a%e4%b9%89%e4%ba%8b%e4%bb%b6
+var code = '[\n'+action_0+']\n';
+return code;
+*/;
+
+//changeFloor 事件编辑器入口之一
+changeFloor_m
+    :   '楼梯, 传送门' BGNL? Newline Floor_List IdString? Stair_List 'x' Number ',' 'y' Number '朝向' DirectionEx_List '动画时间' Int? '允许穿透' Bool BEND
+    
+
+/* changeFloor_m
+tooltip : 楼梯, 传送门, 如果目标楼层有多个楼梯, 写upFloor或downFloor可能会导致到达的楼梯不确定, 这时候请使用loc方式来指定具体的点位置
+helpUrl : https://h5mota.com/games/template/docs/#/element?id=%e8%b7%af%e9%9a%9c%ef%bc%8c%e6%a5%bc%e6%a2%af%ef%bc%8c%e4%bc%a0%e9%80%81%e9%97%a8
+default : [null,"MT1",null,0,0,null,500,null]
+var toFloorId = IdString_0;
+if (Floor_List_0!='floorId') toFloorId = Floor_List_0;
+var loc = ', "loc": ['+Number_0+', '+Number_1+']';
+if (Stair_List_0==='now')loc = '';
+else if (Stair_List_0!=='loc')loc = ', "stair": "'+Stair_List_0+'"';
+DirectionEx_List_0 = DirectionEx_List_0 && (', "direction": "'+DirectionEx_List_0+'"');
+Int_0 = (Int_0!=='')  ?(', "time": '+Int_0):'';
+Bool_0 = Bool_0 ?'':(', "ignoreChangeFloor": false');
+var code = '{"floorId": "'+toFloorId+'"'+loc+DirectionEx_List_0+Int_0+Bool_0+' }\n';
+return code;
+*/;
+
+//commonEvent 事件编辑器入口之一
+commonEvent_m
+    :   '公共事件' BGNL? Newline action+ BEND
+
+
+/* commonEvent_m
+tooltip : 公共事件
+helpUrl : https://h5mota.com/games/template/docs/#/event
+var code = '[\n'+action_0+']\n';
+return code;
+*/;
+
+//为了避免关键字冲突,全部加了_s
+//动作
+action
+    :   text_0_s
+    |   text_1_s
+    |   comment_s
+    |   autoText_s
+    |   scrollText_s
+    |   setText_s
+    |   tip_s
+    |   setValue_s
+    |   addValue_s
+    |   setFloor_s
+    |   setGlobalAttribute_s
+    |   setGlobalValue_s
+    |   setGlobalFlag_s
+    |   show_s
+    |   hide_s
+    |   trigger_s
+    |   insert_1_s
+    |   insert_2_s
+    |   revisit_s
+    |   exit_s
+    |   setBlock_s
+    |   showFloorImg_s
+    |   hideFloorImg_s
+    |   showBgFgMap_s
+    |   hideBgFgMap_s
+    |   setBgFgBlock_s
+    |   setHeroIcon_s
+    |   update_s
+    |   showStatusBar_s
+    |   hideStatusBar_s
+    |   updateEnemys_s
+    |   sleep_s
+    |   wait_s
+    |   waitAsync_s
+    |   battle_s
+    |   battle_1_s
+    |   openDoor_s
+    |   closeDoor_s
+    |   changeFloor_s
+    |   changePos_0_s
+    |   changePos_1_s
+    |   useItem_s
+    |   openShop_s
+    |   disableShop_s
+    |   follow_s
+    |   unfollow_s
+    |   animate_s
+    |   vibrate_s
+    |   showImage_s
+    |   showImage_1_s
+    |   hideImage_s
+    |   showTextImage_s
+    |   moveImage_s
+    |   showGif_0_s
+    |   showGif_1_s
+    |   setCurtain_0_s
+    |   setCurtain_1_s
+    |   screenFlash_s
+    |   setWeather_s
+    |   move_s
+    |   moveHero_s
+    |   jump_s
+    |   jumpHero_s
+    |   playBgm_s
+    |   pauseBgm_s
+    |   resumeBgm_s
+    |   loadBgm_s
+    |   freeBgm_s
+    |   playSound_s
+    |   stopSound_s
+    |   setVolume_s
+    |   win_s
+    |   lose_s
+    |   restart_s
+    |   if_s
+    |   if_1_s
+    |   switch_s
+    |   while_s
+    |   dowhile_s
+    |   break_s
+    |   continue_s
+    |   input_s
+    |   input2_s
+    |   choices_s
+    |   confirm_s
+    |   callBook_s
+    |   callSave_s
+    |   autoSave_s
+    |   callLoad_s
+    |   unknown_s
+    |   function_s
+    |   pass_s
+    ;
+
+text_0_s
+    :   '显示文章' ':' EvalString Newline
+    
+
+/* text_0_s
+tooltip : text：显示一段文字（剧情）
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=text%EF%BC%9A%E6%98%BE%E7%A4%BA%E4%B8%80%E6%AE%B5%E6%96%87%E5%AD%97%EF%BC%88%E5%89%A7%E6%83%85%EF%BC%89
+default : ["欢迎使用事件编辑器(双击方块进入多行编辑)"]
+var code = '"'+EvalString_0+'",\n';
+return code;
+*/;
+
+text_1_s
+    :   '标题' EvalString? '图像' IdString? '对话框效果' EvalString? ':' EvalString Newline
+    
+
+/* text_1_s
+tooltip : text：显示一段文字（剧情）,选项较多请右键点击帮助
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=text%EF%BC%9A%E6%98%BE%E7%A4%BA%E4%B8%80%E6%AE%B5%E6%96%87%E5%AD%97%EF%BC%88%E5%89%A7%E6%83%85%EF%BC%89
+default : ["小妖精","fairy","","欢迎使用事件编辑器(双击方块进入多行编辑)"]
+var title='';
+if (EvalString_0==''){
+    if (IdString_0=='')title='';
+    else title='\\t['+IdString_0+']';
+} else {
+    if (IdString_0=='')title='\\t['+EvalString_0+']';
+    else title='\\t['+EvalString_0+','+IdString_0+']';
+}
+if(EvalString_1 && !(/^(up|down)(,hero)?(,([+-]?\d+),([+-]?\d+))?$/.test(EvalString_1))) {
+  throw new Error('对话框效果的用法请右键点击帮助');
+}
+EvalString_1 = EvalString_1 && ('\\b['+EvalString_1+']');
+var code =  '"'+title+EvalString_1+EvalString_2+'",\n';
+return code;
+*/;
+
+comment_s
+    :   '添加注释' ':' EvalString Newline
+
+
+/* comment_s
+tooltip : comment：添加一段会被游戏跳过的注释内容
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=comment%ef%bc%9a%e6%b7%bb%e5%8a%a0%e6%b3%a8%e9%87%8a
+default : ["可以在这里写添加任何注释内容"]
+colour : this.commentColor
+var code = '{"type": "comment", "text": "'+EvalString_0+'"},\n';
+return code;
+*/;
+
+autoText_s
+    :   '自动剧情文本: 标题' EvalString? '图像' IdString? '对话框效果' EvalString? '时间' Int BGNL? EvalString Newline
+    
+
+/* autoText_s
+tooltip : autoText：自动剧情文本,用户无法跳过自动剧情文本,大段剧情文本请添加“是否跳过剧情”的提示
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=autotext%EF%BC%9A%E8%87%AA%E5%8A%A8%E5%89%A7%E6%83%85%E6%96%87%E6%9C%AC
+default : ["小妖精","fairy","",3000,"用户无法跳过自动剧情文本，大段剧情文本请添加“是否跳过剧情”的提示"]
+var title='';
+if (EvalString_0==''){
+    if (IdString_0=='')title='';
+    else title='\\t['+IdString_0+']';
+} else {
+    if (IdString_0=='')title='\\t['+EvalString_0+']';
+    else title='\\t['+EvalString_0+','+IdString_0+']';
+}
+if(EvalString_1 && !(/^(up|down)(,hero)?(,([+-]?\d+),([+-]?\d+))?$/.test(EvalString_1))) {
+  throw new Error('对话框效果的用法请右键点击帮助');
+}
+EvalString_1 = EvalString_1 && ('\\b['+EvalString_1+']');
+var code =  '{"type": "autoText", "text": "'+title+EvalString_1+EvalString_2+'", "time" :'+Int_0+'},\n';
+return code;
+*/;
+
+scrollText_s
+    :   '滚动剧情文本:' '时间' Int '行距' Number '不等待执行完毕' Bool? BGNL? EvalString Newline
+
+
+/* scrollText_s
+tooltip : scrollText：滚动剧情文本，将从下到上进行滚动显示。
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=scrollText%ef%bc%9a%e6%bb%9a%e5%8a%a8%e5%89%a7%e6%83%85%e6%96%87%e6%9c%ac
+default : [5000,1.4,false,"时间是总时间，可以使用setText事件来控制字体、颜色、大小、偏移量等"]
+Bool_0 = Bool_0?', "async": true':'';
+var code =  '{"type": "scrollText", "text": "'+EvalString_0+'"'+Bool_0+', "time" :'+Int_0+', "lineHeight": '+Number_0+'},\n';
+return code;
+*/;
+
+setText_s
+    :   '设置剧情文本的属性' '位置' SetTextPosition_List '偏移像素' EvalString? '对齐' SetTextAlign_List? BGNL? '标题颜色' EvalString? Colour '正文颜色' EvalString? Colour '背景色' EvalString? Colour BGNL? '粗体' B_1_List '标题字体大小' EvalString? '正文字体大小' EvalString? '打字间隔' EvalString? Newline
+    
+
+/* setText_s
+tooltip : setText：设置剧情文本的属性,颜色为RGB三元组或RGBA四元组,打字间隔为剧情文字添加的时间间隔,为整数或不填
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=settext%EF%BC%9A%E8%AE%BE%E7%BD%AE%E5%89%A7%E6%83%85%E6%96%87%E6%9C%AC%E7%9A%84%E5%B1%9E%E6%80%A7
+default : [null,"",null,"",'rgba(255,255,255,1)',"",'rgba(255,255,255,1)',"",'rgba(255,255,255,1)',null,"","",""]
+SetTextPosition_List_0 =SetTextPosition_List_0==='null'?'': ', "position": "'+SetTextPosition_List_0+'"';
+SetTextAlign_List_0 =SetTextAlign_List_0==='null'?'': ', "align": "'+SetTextAlign_List_0+'"';
+var colorRe = MotaActionFunctions.pattern.colorRe;
+if (EvalString_0) {
+  if (!/^\d+$/.test(EvalString_0))throw new Error('像素偏移量必须是整数或不填');
+  EvalString_0 = ', "offset": '+EvalString_0;
+}
+if (EvalString_1) {
+  if (!colorRe.test(EvalString_1))throw new Error('颜色格式错误,形如:0~255,0~255,0~255,0~1');
+  EvalString_1 = ', "title": ['+EvalString_1+']';
+}
+if (EvalString_2) {
+  if (!colorRe.test(EvalString_2))throw new Error('颜色格式错误,形如:0~255,0~255,0~255,0~1');
+  EvalString_2 = ', "text": ['+EvalString_2+']';
+}
+if (EvalString_3) {
+  if (colorRe.test(EvalString_3)) {
+    EvalString_3 = ', "background": ['+EvalString_3+']';
+  }
+  else if (/^\w+\.png$/.test(EvalString_3)) {
+    EvalString_3 = ', "background": "'+EvalString_3+'"';
+  }
+  else {
+    throw new Error('背景格式错误,必须是形如0~255,0~255,0~255,0~1的颜色，或一个WindowSkin的png图片名称');
+  }
+}
+if (EvalString_4) {
+  if (!/^\d+$/.test(EvalString_4))throw new Error('字体大小必须是整数或不填');
+  EvalString_4 = ', "titlefont": '+EvalString_4;
+}
+if (EvalString_5) {
+  if (!/^\d+$/.test(EvalString_5))throw new Error('字体大小必须是整数或不填');
+  EvalString_5 = ', "textfont": '+EvalString_5;
+}
+if (EvalString_6) {
+  if (!/^\d+$/.test(EvalString_6))throw new Error('打字时间间隔必须是整数或不填');
+  EvalString_6 = ', "time": '+EvalString_6;
+}
+B_1_List_0 = B_1_List_0==='null'?'':', "bold": '+B_1_List_0;
+var code = '{"type": "setText"'+SetTextPosition_List_0+EvalString_0+SetTextAlign_List_0+EvalString_1+EvalString_2+B_1_List_0+EvalString_3+EvalString_4+EvalString_5+EvalString_6+'},\n';
+return code;
+*/;
+
+tip_s
+    :   '显示提示' ':' EvalString '图标ID' IdString? Newline
+    
+
+/* tip_s
+tooltip : tip：显示一段提示文字
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=tip%EF%BC%9A%E6%98%BE%E7%A4%BA%E4%B8%80%E6%AE%B5%E6%8F%90%E7%A4%BA%E6%96%87%E5%AD%97
+default : ["这段话将在左上角以气泡形式显示",""]
+IdString_0 = IdString_0 && (', "icon": "' + IdString_0 + '"');
+var code = '{"type": "tip", "text": "'+EvalString_0+'"'+IdString_0+'},\n';
+return code;
+*/;
+
+setValue_s
+    :   '数值操作' ':' '名称' idString_e '值' expression Newline
+    
+
+/* setValue_s
+tooltip : setValue：设置勇士的某个属性、道具个数, 或某个变量/Flag的值
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=setvalue%EF%BC%9A%E8%AE%BE%E7%BD%AE%E5%8B%87%E5%A3%AB%E7%9A%84%E6%9F%90%E4%B8%AA%E5%B1%9E%E6%80%A7%E3%80%81%E9%81%93%E5%85%B7%E4%B8%AA%E6%95%B0%EF%BC%8C%E6%88%96%E6%9F%90%E4%B8%AA%E5%8F%98%E9%87%8Fflag%E7%9A%84%E5%80%BC
+colour : this.dataColor
+var code = '{"type": "setValue", "name": "'+idString_e_0+'", "value": "'+expression_0+'"},\n';
+return code;
+*/;
+
+addValue_s
+    :   '数值增减' ':' '名称' idString_e '+=' expression Newline
+
+
+/* addValue_s
+tooltip : addValue：增减勇士的某个属性、道具个数, 或某个变量/Flag的值
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=addValue%ef%bc%9a%e5%a2%9e%e5%87%8f%e5%8b%87%e5%a3%ab%e7%9a%84%e6%9f%90%e4%b8%aa%e5%b1%9e%e6%80%a7%e3%80%81%e9%81%93%e5%85%b7%e4%b8%aa%e6%95%b0%ef%bc%8c%e6%88%96%e6%9f%90%e4%b8%aa%e5%8f%98%e9%87%8f%2fFlag%e7%9a%84%e5%80%bc
+colour : this.dataColor
+var code = '{"type": "addValue", "name": "'+idString_e_0+'", "value": "'+expression_0+'"},\n';
+return code;
+*/;
+
+setFloor_s
+    :   '设置楼层属性' ':' Floor_Meta_List '楼层名' IdString? '值' EvalString Newline
+
+
+/* setFloor_s
+tooltip : setFloor：设置楼层属性；该楼层属性和编辑器中的楼层属性一一对应
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=setFloor%ef%bc%9a%e8%ae%be%e7%bd%ae%e6%a5%bc%e5%b1%82%e5%b1%9e%e6%80%a7
+default : ["title","","'字符串类型的值要加引号，其他类型则不用'"]
+colour : this.dataColor
+IdString_0 = IdString_0 && (', "floorId": "'+IdString_0+'"');
+var code = '{"type": "setFloor", "name": "'+Floor_Meta_List_0+'"'+IdString_0+', "value": "'+EvalString_0+'"},\n';
+return code;
+*/;
+
+
+setGlobalAttribute_s
+    :   '设置全局属性' ':' Global_Attribute_List '值' EvalString Newline
+
+
+/* setGlobalAttribute_s
+tooltip : setGlobalAttribute：设置全局属性
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=setGlobalAttribute%ef%bc%9a%e8%ae%be%e7%bd%ae%e4%b8%80%e4%b8%aa%e5%85%a8%e5%b1%80%e5%b1%9e%e6%80%a7
+default : ["font","Verdana"]
+colour : this.dataColor
+var code = '{"type": "setGlobalAttribute", "name": "'+Global_Attribute_List_0+'", "value": "'+EvalString_0+'"},\n';
+return code;
+*/;
+
+
+setGlobalValue_s
+    :   '设置全局数值' ':' Global_Value_List '值' EvalString Newline
+
+
+/* setGlobalValue_s
+tooltip : setGlobalValue：设置全局属性
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=setGlobalValue%ef%bc%9a%e8%ae%be%e7%bd%ae%e4%b8%80%e4%b8%aa%e5%85%a8%e5%b1%80%e6%95%b0%e5%80%bc
+default : ["lavaDamage","100"]
+colour : this.dataColor
+var code = '{"type": "setGlobalValue", "name": "'+Global_Value_List_0+'", "value": '+EvalString_0+'},\n';
+return code;
+*/;
+
+
+setGlobalFlag_s
+    :   '设置系统开关' ':' Global_Flag_List Bool Newline
+
+
+/* setGlobalFlag_s
+tooltip : setGlobalFlag：设置系统开关
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=setGlobalFlag%ef%bc%9a%e8%ae%be%e7%bd%ae%e4%b8%80%e4%b8%aa%e7%b3%bb%e7%bb%9f%e5%bc%80%e5%85%b3
+default : ["enableFloor","true"]
+colour : this.dataColor
+var code = '{"type": "setGlobalFlag", "name": "'+Global_Flag_List_0+'", "value": '+Bool_0+'},\n';
+return code;
+*/;
+
+
+show_s
+    :   '显示事件' 'x' EvalString? ',' 'y' EvalString? '楼层' IdString? '动画时间' Int? '不等待执行完毕' Bool? Newline
+    
+
+/* show_s
+tooltip : show: 将禁用事件启用,楼层和动画时间可不填,xy可用逗号分隔表示多个点
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=show%EF%BC%9A%E5%B0%86%E4%B8%80%E4%B8%AA%E7%A6%81%E7%94%A8%E4%BA%8B%E4%BB%B6%E5%90%AF%E7%94%A8
+default : ["","","",500,false]
+colour : this.mapColor
+var floorstr = '';
+if (EvalString_0 && EvalString_1) {
+  var pattern1 = MotaActionFunctions.pattern.id;
+  if(pattern1.test(EvalString_0) || pattern1.test(EvalString_1)){
+    EvalString_0=MotaActionFunctions.PosString_pre(EvalString_0);
+    EvalString_1=MotaActionFunctions.PosString_pre(EvalString_1);
+    EvalString_0=[EvalString_0,EvalString_1]
+  } else {
+    var pattern2 = /^([+-]?\d+)(,[+-]?\d+)*$/;
+    if(!pattern2.test(EvalString_0) || !pattern2.test(EvalString_1))throw new Error('坐标格式错误,请右键点击帮助查看格式');
+    EvalString_0=EvalString_0.split(',');
+    EvalString_1=EvalString_1.split(',');
+    if(EvalString_0.length!==EvalString_1.length)throw new Error('坐标格式错误,请右键点击帮助查看格式');
+    for(var ii=0;ii<EvalString_0.length;ii++)EvalString_0[ii]='['+EvalString_0[ii]+','+EvalString_1[ii]+']';
+  }
+  floorstr = ', "loc": ['+EvalString_0.join(',')+']';
+}
+IdString_0 = IdString_0 && (', "floorId": "'+IdString_0+'"');
+Int_0 = Int_0!=='' ?(', "time": '+Int_0):'';
+Bool_0 = Bool_0 ?', "async": true':'';
+var code = '{"type": "show"'+floorstr+IdString_0+''+Int_0+Bool_0+'},\n';
+return code;
+*/;
+
+hide_s
+    :   '隐藏事件' 'x' EvalString? ',' 'y' EvalString? '楼层' IdString? '动画时间' Int? '不等待执行完毕' Bool? Newline
+    
+
+/* hide_s
+tooltip : hide: 将一个启用事件禁用,所有参数均可不填,代表禁用事件自身,xy可用逗号分隔表示多个点
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=hide%EF%BC%9A%E5%B0%86%E4%B8%80%E4%B8%AA%E5%90%AF%E7%94%A8%E4%BA%8B%E4%BB%B6%E7%A6%81%E7%94%A8
+default : ["","","",500,false]
+colour : this.mapColor
+var floorstr = '';
+if (EvalString_0 && EvalString_1) {
+  var pattern1 = MotaActionFunctions.pattern.id;
+  if(pattern1.test(EvalString_0) || pattern1.test(EvalString_1)){
+    EvalString_0=MotaActionFunctions.PosString_pre(EvalString_0);
+    EvalString_1=MotaActionFunctions.PosString_pre(EvalString_1);
+    EvalString_0=[EvalString_0,EvalString_1]
+  } else {
+    var pattern2 = /^([+-]?\d+)(,[+-]?\d+)*$/;
+    if(!pattern2.test(EvalString_0) || !pattern2.test(EvalString_1))throw new Error('坐标格式错误,请右键点击帮助查看格式');
+    EvalString_0=EvalString_0.split(',');
+    EvalString_1=EvalString_1.split(',');
+    if(EvalString_0.length!==EvalString_1.length)throw new Error('坐标格式错误,请右键点击帮助查看格式');
+    for(var ii=0;ii<EvalString_0.length;ii++)EvalString_0[ii]='['+EvalString_0[ii]+','+EvalString_1[ii]+']';
+  }
+  floorstr = ', "loc": ['+EvalString_0.join(',')+']';
+}
+IdString_0 = IdString_0 && (', "floorId": "'+IdString_0+'"');
+Int_0 = Int_0!=='' ?(', "time": '+Int_0):'';
+Bool_0 = Bool_0 ?', "async": true':'';
+var code = '{"type": "hide"'+floorstr+IdString_0+''+Int_0+Bool_0+'},\n';
+return code;
+*/;
+
+trigger_s
+    :   '触发事件' 'x' PosString ',' 'y' PosString '不结束当前事件' Bool Newline
+    
+
+/* trigger_s
+tooltip : trigger: 立即触发另一个地点的事件
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=trigger%EF%BC%9A%E7%AB%8B%E5%8D%B3%E8%A7%A6%E5%8F%91%E5%8F%A6%E4%B8%80%E4%B8%AA%E5%9C%B0%E7%82%B9%E7%9A%84%E4%BA%8B%E4%BB%B6
+default : ["0","0",false]
+colour : this.eventColor
+Bool_0 = Bool_0 ?', "keep": true':'';
+var code = '{"type": "trigger", "loc": ['+PosString_0+','+PosString_1+']'+Bool_0+'},\n';
+return code;
+*/;
+
+insert_1_s
+    :   '插入公共事件' EvalString '参数列表' EvalString? Newline
+
+
+/* insert_1_s
+tooltip : insert: 插入公共事件并执行
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=insert%ef%bc%9a%e6%8f%92%e5%85%a5%e5%85%ac%e5%85%b1%e4%ba%8b%e4%bb%b6%e6%88%96%e5%8f%a6%e4%b8%80%e4%b8%aa%e5%9c%b0%e7%82%b9%e7%9a%84%e4%ba%8b%e4%bb%b6%e5%b9%b6%e6%89%a7%e8%a1%8c
+default : ["加点事件", ""]
+colour : this.eventColor
+if (EvalString_1) {
+    if (EvalString_1.indexOf('"')>=0)
+        throw new Error('请勿在此处使用双引号！尝试使用单引号吧~');
+    // 检查是不是数组
+    try {
+        if (!(JSON.parse(EvalString_1.replace(/'/g, '"')) instanceof Array)) throw new Error();
+    }
+    catch (e) {
+        throw new Error('参数列表必须是个有效的数组！');
+    }
+    EvalString_1 = ', "args": ' +EvalString_1;
+}
+var code = '{"type": "insert", "name": "'+EvalString_0+'"'+EvalString_1+'},\n';
+return code;
+*/;
+
+insert_2_s
+    :   '插入事件' 'x' PosString ',' 'y' PosString Event_List? '楼层' IdString? '参数列表' EvalString? ENewline
+
+
+/* insert_2_s
+tooltip : insert: 立即插入另一个地点的事件执行，当前事件不会中断，事件坐标不会改变
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=insert%ef%bc%9a%e6%8f%92%e5%85%a5%e5%85%ac%e5%85%b1%e4%ba%8b%e4%bb%b6%e6%88%96%e5%8f%a6%e4%b8%80%e4%b8%aa%e5%9c%b0%e7%82%b9%e7%9a%84%e4%ba%8b%e4%bb%b6%e5%b9%b6%e6%89%a7%e8%a1%8c
+default : ["0","0",null,"",""]
+colour : this.eventColor
+IdString_0 = IdString_0 && (', "floorId": "'+IdString_0+'"');
+if (EvalString_0) {
+    if (EvalString_0.indexOf('"')>=0)
+        throw new Error('请勿在此处使用双引号！尝试使用单引号吧~');
+    try {
+        if (!(JSON.parse(EvalString_0.replace(/'/g, '"')) instanceof Array)) throw new Error();
+    }
+    catch (e) {
+        throw new Error('参数列表必须是个有效的数组！');
+    }
+    EvalString_0 = ', "args": ' +EvalString_0;
+}
+if (Event_List_0 && Event_List_0 !=='null')
+    Event_List_0 = ', "which": "'+Event_List_0+'"';
+else Event_List_0 = '';
+var code = '{"type": "insert", "loc": ['+PosString_0+','+PosString_1+']'+Event_List_0+IdString_0+EvalString_0+'},\n';
+return code;
+*/;
+
+revisit_s
+    :   '重启当前事件' Newline
+    
+
+/* revisit_s
+tooltip : revisit: 立即重启当前事件
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=revisit%EF%BC%9A%E7%AB%8B%E5%8D%B3%E9%87%8D%E5%90%AF%E5%BD%93%E5%89%8D%E4%BA%8B%E4%BB%B6
+colour : this.eventColor
+var code = '{"type": "revisit"},\n';
+return code;
+*/;
+
+exit_s
+    :   '立刻结束当前事件' Newline
+    
+
+/* exit_s
+tooltip : exit: 立刻结束当前事件
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=exit%EF%BC%9A%E7%AB%8B%E5%88%BB%E7%BB%93%E6%9D%9F%E5%BD%93%E5%89%8D%E4%BA%8B%E4%BB%B6
+colour : this.eventColor
+var code = '{"type": "exit"},\n';
+return code;
+*/;
+
+setBlock_s
+    :   '转变图块为' EvalString 'x' PosString? ',' 'y' PosString? '楼层' IdString? Newline
+    
+
+/* setBlock_s
+tooltip : setBlock：设置某个图块,忽略坐标楼层则为当前事件
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=setblock%EF%BC%9A%E8%AE%BE%E7%BD%AE%E6%9F%90%E4%B8%AA%E5%9B%BE%E5%9D%97
+colour : this.mapColor
+default : ["yellowDoor","","",""]
+var floorstr = '';
+if (PosString_0 && PosString_1) {
+    floorstr = ', "loc": ['+PosString_0+','+PosString_1+']';
+}
+IdString_0 = IdString_0 && (', "floorId": "'+IdString_0+'"');
+var code = '{"type": "setBlock", "number": "'+EvalString_0+'"'+floorstr+IdString_0+'},\n';
+return code;
+*/;
+
+showFloorImg_s
+    :   '显示贴图' 'x' EvalString? ',' 'y' EvalString? '楼层' IdString? Newline
+
+
+/* showFloorImg_s
+tooltip : showFloorImg: 显示一个贴图，xy为左上角坐标，可用逗号分隔表示多个点
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=showFloorImg%ef%bc%9a%e6%98%be%e7%a4%ba%e8%b4%b4%e5%9b%be
+default : ["","",""]
+colour : this.mapColor
+var floorstr = '';
+if (EvalString_0 && EvalString_1) {
+  var pattern1 = MotaActionFunctions.pattern.id;
+  if(pattern1.test(EvalString_0) || pattern1.test(EvalString_1)){
+    EvalString_0=MotaActionFunctions.PosString_pre(EvalString_0);
+    EvalString_1=MotaActionFunctions.PosString_pre(EvalString_1);
+    EvalString_0=[EvalString_0,EvalString_1]
+  } else {
+    var pattern2 = /^([+-]?\d+)(,[+-]?\d+)*$/;
+    if(!pattern2.test(EvalString_0) || !pattern2.test(EvalString_1))throw new Error('坐标格式错误,请右键点击帮助查看格式');
+    EvalString_0=EvalString_0.split(',');
+    EvalString_1=EvalString_1.split(',');
+    if(EvalString_0.length!==EvalString_1.length)throw new Error('坐标格式错误,请右键点击帮助查看格式');
+    for(var ii=0;ii<EvalString_0.length;ii++)EvalString_0[ii]='['+EvalString_0[ii]+','+EvalString_1[ii]+']';
+  }
+  floorstr = ', "loc": ['+EvalString_0.join(',')+']';
+}
+IdString_0 = IdString_0 && (', "floorId": "'+IdString_0+'"');
+var code = '{"type": "showFloorImg"'+floorstr+IdString_0+'},\n';
+return code;
+*/;
+
+hideFloorImg_s
+    :   '隐藏贴图' 'x' EvalString? ',' 'y' EvalString? '楼层' IdString? Newline
+
+
+/* hideFloorImg_s
+tooltip : hideFloorImg: 隐藏一个贴图，xy为左上角坐标，可用逗号分隔表示多个点
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=hideFloorImg%ef%bc%9a%e9%9a%90%e8%97%8f%e8%b4%b4%e5%9b%be
+default : ["","",""]
+colour : this.mapColor
+var floorstr = '';
+if (EvalString_0 && EvalString_1) {
+  var pattern1 = MotaActionFunctions.pattern.id;
+  if(pattern1.test(EvalString_0) || pattern1.test(EvalString_1)){
+    EvalString_0=MotaActionFunctions.PosString_pre(EvalString_0);
+    EvalString_1=MotaActionFunctions.PosString_pre(EvalString_1);
+    EvalString_0=[EvalString_0,EvalString_1]
+  } else {
+    var pattern2 = /^([+-]?\d+)(,[+-]?\d+)*$/;
+    if(!pattern2.test(EvalString_0) || !pattern2.test(EvalString_1))throw new Error('坐标格式错误,请右键点击帮助查看格式');
+    EvalString_0=EvalString_0.split(',');
+    EvalString_1=EvalString_1.split(',');
+    if(EvalString_0.length!==EvalString_1.length)throw new Error('坐标格式错误,请右键点击帮助查看格式');
+    for(var ii=0;ii<EvalString_0.length;ii++)EvalString_0[ii]='['+EvalString_0[ii]+','+EvalString_1[ii]+']';
+  }
+  floorstr = ', "loc": ['+EvalString_0.join(',')+']';
+}
+IdString_0 = IdString_0 && (', "floorId": "'+IdString_0+'"');
+var code = '{"type": "hideFloorImg"'+floorstr+IdString_0+'},\n';
+return code;
+*/;
+
+showBgFgMap_s
+    :   '显示图层块' Bg_Fg_List 'x' EvalString? ',' 'y' EvalString? '楼层' IdString? Newline
+
+
+/* showBgFgMap_s
+tooltip : showBgFgMap: 显示图层块，即背景图层/前景图层的某些图块，xy为左上角坐标，可用逗号分隔表示多个点
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=showFloorImg%ef%bc%9a%e6%98%be%e7%a4%ba%e8%b4%b4%e5%9b%be
+default : ["bg","","",""]
+colour : this.mapColor
+var floorstr = '';
+if (EvalString_0 && EvalString_1) {
+  var pattern1 = MotaActionFunctions.pattern.id;
+  if(pattern1.test(EvalString_0) || pattern1.test(EvalString_1)){
+    EvalString_0=MotaActionFunctions.PosString_pre(EvalString_0);
+    EvalString_1=MotaActionFunctions.PosString_pre(EvalString_1);
+    EvalString_0=[EvalString_0,EvalString_1]
+  } else {
+    var pattern2 = /^([+-]?\d+)(,[+-]?\d+)*$/;
+    if(!pattern2.test(EvalString_0) || !pattern2.test(EvalString_1))throw new Error('坐标格式错误,请右键点击帮助查看格式');
+    EvalString_0=EvalString_0.split(',');
+    EvalString_1=EvalString_1.split(',');
+    if(EvalString_0.length!==EvalString_1.length)throw new Error('坐标格式错误,请右键点击帮助查看格式');
+    for(var ii=0;ii<EvalString_0.length;ii++)EvalString_0[ii]='['+EvalString_0[ii]+','+EvalString_1[ii]+']';
+  }
+  floorstr = ', "loc": ['+EvalString_0.join(',')+']';
+}
+IdString_0 = IdString_0 && (', "floorId": "'+IdString_0+'"');
+var code = '{"type": "showBgFgMap", "name": "' + Bg_Fg_List_0 + '"' +floorstr+IdString_0+'},\n';
+return code;
+*/;
+
+hideBgFgMap_s
+    :   '隐藏图层块' Bg_Fg_List 'x' EvalString? ',' 'y' EvalString? '楼层' IdString? Newline
+
+
+/* hideBgFgMap_s
+tooltip : hideBgFgMap: 隐藏图层块，即背景图层/前景图层的某些图块，xy为左上角坐标，可用逗号分隔表示多个点
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=hideFloorImg%ef%bc%9a%e9%9a%90%e8%97%8f%e8%b4%b4%e5%9b%be
+default : ["bg","","",""]
+colour : this.mapColor
+var floorstr = '';
+if (EvalString_0 && EvalString_1) {
+  var pattern1 = MotaActionFunctions.pattern.id;
+  if(pattern1.test(EvalString_0) || pattern1.test(EvalString_1)){
+    EvalString_0=MotaActionFunctions.PosString_pre(EvalString_0);
+    EvalString_1=MotaActionFunctions.PosString_pre(EvalString_1);
+    EvalString_0=[EvalString_0,EvalString_1]
+  } else {
+    var pattern2 = /^([+-]?\d+)(,[+-]?\d+)*$/;
+    if(!pattern2.test(EvalString_0) || !pattern2.test(EvalString_1))throw new Error('坐标格式错误,请右键点击帮助查看格式');
+    EvalString_0=EvalString_0.split(',');
+    EvalString_1=EvalString_1.split(',');
+    if(EvalString_0.length!==EvalString_1.length)throw new Error('坐标格式错误,请右键点击帮助查看格式');
+    for(var ii=0;ii<EvalString_0.length;ii++)EvalString_0[ii]='['+EvalString_0[ii]+','+EvalString_1[ii]+']';
+  }
+  floorstr = ', "loc": ['+EvalString_0.join(',')+']';
+}
+IdString_0 = IdString_0 && (', "floorId": "'+IdString_0+'"');
+var code = '{"type": "hideBgFgMap", "name": "' + Bg_Fg_List_0 + '"' +floorstr+IdString_0+'},\n';
+return code;
+*/;
+
+setBgFgBlock_s
+    :   '转变图层块' Bg_Fg_List '为' EvalString 'x' PosString? ',' 'y' PosString? '楼层' IdString? Newline
+
+
+/* setBgFgBlock_s
+tooltip : setBgFgBlock：设置某个图层块,忽略坐标楼层则为当前点
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=setblock%EF%BC%9A%E8%AE%BE%E7%BD%AE%E6%9F%90%E4%B8%AA%E5%9B%BE%E5%9D%97
+colour : this.mapColor
+default : ["bg","yellowDoor","","",""]
+var floorstr = '';
+if (PosString_0 && PosString_1) {
+    floorstr = ', "loc": ['+PosString_0+','+PosString_1+']';
+}
+IdString_0 = IdString_0 && (', "floorId": "'+IdString_0+'"');
+var code = '{"type": "setBgFgBlock", "name": "' + Bg_Fg_List_0 + '", "number": "'+EvalString_0+'"'+floorstr+IdString_0+'},\n';
+return code;
+*/;
+
+setHeroIcon_s
+    :   '更改角色行走图' EvalString? Newline
+    
+
+/* setHeroIcon_s
+tooltip : setHeroIcon：更改角色行走图
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=setheroicon%EF%BC%9A%E6%9B%B4%E6%94%B9%E8%A7%92%E8%89%B2%E8%A1%8C%E8%B5%B0%E5%9B%BE
+colour : this.dataColor
+default : ["hero.png"]
+EvalString_0 = EvalString_0 && (', "name": "'+EvalString_0+'"');
+var code = '{"type": "setHeroIcon"'+EvalString_0+'},\n';
+return code;
+*/;
+
+update_s
+    :   '更新状态栏和地图显伤' Newline
+    
+
+/* update_s
+tooltip : update: 立刻更新状态栏和地图显伤
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=update%EF%BC%9A%E7%AB%8B%E5%88%BB%E6%9B%B4%E6%96%B0%E7%8A%B6%E6%80%81%E6%A0%8F%E5%92%8C%E5%9C%B0%E5%9B%BE%E6%98%BE%E4%BC%A4
+colour : this.dataColor
+var code = '{"type": "update"},\n';
+return code;
+*/;
+
+showStatusBar_s
+    :   '显示状态栏' Newline
+
+
+/* showStatusBar_s
+tooltip : showStatusBar: 显示状态栏
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=showStatusBar%ef%bc%9a%e6%98%be%e7%a4%ba%e7%8a%b6%e6%80%81%e6%a0%8f
+colour : this.soundColor
+var code = '{"type": "showStatusBar"},\n';
+return code;
+*/;
+
+hideStatusBar_s
+    :   '隐藏状态栏' '不隐藏竖屏工具栏' Bool Newline
+
+
+/* hideStatusBar_s
+tooltip : hideStatusBar: 隐藏状态栏
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=hideStatusBar%ef%bc%9a%e9%9a%90%e8%97%8f%e7%8a%b6%e6%80%81%e6%a0%8f
+colour : this.soundColor
+default : [false]
+Bool_0 = Bool_0?', "toolbox": true':'';
+var code = '{"type": "hideStatusBar"'+Bool_0+'},\n';
+return code;
+*/;
+
+updateEnemys_s
+    :   '更新怪物数据' Newline
+
+
+/* updateEnemys_s
+tooltip : updateEnemys: 立刻更新怪物数据
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=updateEnemys%ef%bc%9a%e6%9b%b4%e6%96%b0%e6%80%aa%e7%89%a9%e6%95%b0%e6%8d%ae
+colour : this.dataColor
+var code = '{"type": "updateEnemys"},\n';
+return code;
+*/;
+
+sleep_s
+    :   '等待' Int '毫秒' '不可被Ctrl跳过' Bool Newline
+    
+
+/* sleep_s
+tooltip : sleep: 等待多少毫秒
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=sleep%EF%BC%9A%E7%AD%89%E5%BE%85%E5%A4%9A%E5%B0%91%E6%AF%AB%E7%A7%92
+default : [500, false]
+colour : this.soundColor
+Bool_0 = Bool_0?', "noSkip": true':'';
+var code = '{"type": "sleep", "time": '+Int_0+Bool_0+'},\n';
+return code;
+*/;
+
+
+battle_s
+    :   '强制战斗' IdString Newline
+    
+
+/* battle_s
+tooltip : battle: 强制战斗
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=battle%EF%BC%9A%E5%BC%BA%E5%88%B6%E6%88%98%E6%96%97
+default : ["greenSlime"]
+colour : this.dataColor
+var code = '{"type": "battle", "id": "'+IdString_0+'"},\n';
+return code;
+*/;
+
+
+battle_1_s
+    :   '强制战斗' 'x' PosString? ',' 'y' PosString? Newline
+
+
+/* battle_1_s
+tooltip : battle: 强制战斗
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=battle%EF%BC%9A%E5%BC%BA%E5%88%B6%E6%88%98%E6%96%97
+default : ["","",""]
+colour : this.mapColor
+var floorstr = '';
+if (PosString_0 && PosString_1) {
+    floorstr = ', "loc": ['+PosString_0+','+PosString_1+']';
+}
+var code = '{"type": "battle"'+floorstr+'},\n';
+return code;
+*/;
+
+openDoor_s
+    :   '开门' 'x' PosString? ',' 'y' PosString? '楼层' IdString? '需要钥匙' Bool? '不等待执行完毕' Bool Newline
+    
+
+/* openDoor_s
+tooltip : openDoor: 开门,楼层可不填表示当前层
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=opendoor%EF%BC%9A%E5%BC%80%E9%97%A8
+default : ["","","",false,false]
+colour : this.mapColor
+IdString_0 = IdString_0 && (', "floorId": "'+IdString_0+'"');
+var floorstr = '';
+if (PosString_0 && PosString_1) {
+    floorstr = ', "loc": ['+PosString_0+','+PosString_1+']';
+}
+Bool_0 = Bool_0 ? ', "needKey": true' : '';
+Bool_1 = Bool_1 ? ', "async": true' : '';
+var code = '{"type": "openDoor"'+floorstr+IdString_0+Bool_0+Bool_1+'},\n';
+return code;
+*/;
+
+closeDoor_s
+    :   '关门' 'x' PosString? ',' 'y' PosString? 'ID' IdString '不等待执行完毕' Bool Newline
+
+
+/* closeDoor_s
+tooltip : closeDoor: 关门事件，需要该点本身无事件
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=opendoor%EF%BC%9A%E5%BC%80%E9%97%A8
+default : ["","","yellowDoor",false]
+colour : this.mapColor
+var floorstr = '';
+if (PosString_0 && PosString_1) {
+    floorstr = ', "loc": ['+PosString_0+','+PosString_1+']';
+}
+Bool_0 = Bool_0 ? ', "async": true' : '';
+var code = '{"type": "closeDoor", "id": "'+IdString_0+'"'+floorstr+Bool_0+'},\n';
+return code;
+*/;
+
+changeFloor_s
+    :   '楼层切换' IdString? 'x' PosString? ',' 'y' PosString? '朝向' DirectionEx_List '动画时间' Int? Newline
+    
+
+/* changeFloor_s
+tooltip : changeFloor: 楼层切换,动画时间可不填
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=changefloor%EF%BC%9A%E6%A5%BC%E5%B1%82%E5%88%87%E6%8D%A2
+default : ["MT1","0","0",null,500]
+colour : this.dataColor
+DirectionEx_List_0 = DirectionEx_List_0 && (', "direction": "'+DirectionEx_List_0+'"');
+Int_0 = (Int_0!=='')  ?(', "time": '+Int_0):'';
+var floorstr = '';
+if (PosString_0 && PosString_1) {
+    floorstr = ', "loc": ['+PosString_0+','+PosString_1+']';
+}
+var code = '{"type": "changeFloor", "floorId": "'+IdString_0+'"'+floorstr+DirectionEx_List_0+Int_0+' },\n';
+return code;
+*/;
+
+changePos_0_s
+    :   '位置切换' 'x' PosString ',' 'y' PosString '朝向' DirectionEx_List Newline
+    
+
+/* changePos_0_s
+tooltip : changePos: 当前位置切换
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=changepos%EF%BC%9A%E5%BD%93%E5%89%8D%E4%BD%8D%E7%BD%AE%E5%88%87%E6%8D%A2%E5%8B%87%E5%A3%AB%E8%BD%AC%E5%90%91
+default : ["","",null]
+colour : this.dataColor
+DirectionEx_List_0 = DirectionEx_List_0 && (', "direction": "'+DirectionEx_List_0+'"');
+var code = '{"type": "changePos", "loc": ['+PosString_0+','+PosString_1+']'+DirectionEx_List_0+'},\n';
+return code;
+*/;
+
+changePos_1_s
+    :   '勇士转向' Direction_List Newline
+    
+
+/* changePos_1_s
+tooltip : changePos: 勇士转向
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=changepos%EF%BC%9A%E5%BD%93%E5%89%8D%E4%BD%8D%E7%BD%AE%E5%88%87%E6%8D%A2%E5%8B%87%E5%A3%AB%E8%BD%AC%E5%90%91
+colour : this.dataColor
+default : [null]
+var code = '{"type": "changePos", "direction": "'+Direction_List_0+'"},\n';
+return code;
+*/;
+
+useItem_s
+    :   '使用道具' IdString Newline
+
+
+/* useItem_s
+tooltip : useItem: 使用道具
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=useItem%ef%bc%9a%e4%bd%bf%e7%94%a8%e9%81%93%e5%85%b7
+colour : this.dataColor
+default : ["pickaxe"]
+var code = '{"type": "useItem", "id": "'+IdString_0+'"},\n';
+return code;
+*/;
+
+openShop_s
+    :   '打开全局商店' IdString Newline
+    
+
+/* openShop_s
+tooltip : 全局商店
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=openshop%EF%BC%9A%E6%89%93%E5%BC%80%E4%B8%80%E4%B8%AA%E5%85%A8%E5%B1%80%E5%95%86%E5%BA%97
+colour : this.dataColor
+default : ["shop1"]
+var code = '{"type": "openShop", "id": "'+IdString_0+'"},\n';
+return code;
+*/;
+
+disableShop_s
+    :   '禁用全局商店' IdString Newline
+    
+
+/* disableShop_s
+tooltip : 全局商店
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=disableshop%EF%BC%9A%E7%A6%81%E7%94%A8%E4%B8%80%E4%B8%AA%E5%85%A8%E5%B1%80%E5%95%86%E5%BA%97
+default : ["shop1"]
+colour : this.dataColor
+var code = '{"type": "disableShop", "id": "'+IdString_0+'"},\n';
+return code;
+*/;
+
+follow_s
+    :   '跟随勇士' '行走图' EvalString Newline
+
+
+/* follow_s
+tooltip : follow: 跟随勇士
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=follow%ef%bc%9a%e8%b7%9f%e9%9a%8f%e5%8b%87%e5%a3%ab
+default : ["npc.png"]
+colour : this.dataColor
+var code = '{"type": "follow", "name": "'+EvalString_0+'"},\n';
+return code;
+*/;
+
+unfollow_s
+    :   '取消跟随' '行走图' EvalString? Newline
+
+
+/* unfollow_s
+tooltip : unfollow: 取消跟随
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=unfollow%ef%bc%9a%e5%8f%96%e6%b6%88%e8%b7%9f%e9%9a%8f
+default : [""]
+colour : this.dataColor
+EvalString_0 = EvalString_0 ? (', "name": "' + EvalString_0 + '"') : "";
+var code = '{"type": "unfollow"' + EvalString_0 + '},\n';
+return code;
+*/;
+
+vibrate_s
+    :   '画面震动' '时间' Int '不等待执行完毕' Bool Newline
+
+
+/* vibrate_s
+tooltip : vibrate: 画面震动
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=vibrate%ef%bc%9a%e7%94%bb%e9%9d%a2%e9%9c%87%e5%8a%a8
+default : [2000,false]
+colour : this.soundColor
+Int_0 = Int_0 ?(', "time": '+Int_0):'';
+var async = Bool_0?', "async": true':''
+var code = '{"type": "vibrate"' + Int_0 + async + '},\n';
+return code;
+*/;
+
+animate_s
+    :   '显示动画' IdString '位置' EvalString? '不等待执行完毕' Bool Newline
+    
+
+/* animate_s
+tooltip : animate：显示动画,位置填hero或者1,2形式的位置,或者不填代表当前事件点
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=animate%EF%BC%9A%E6%98%BE%E7%A4%BA%E5%8A%A8%E7%94%BB
+default : ["zone","hero",false]
+colour : this.soundColor
+if (EvalString_0) {
+  if(MotaActionFunctions.pattern.id2.test(EvalString_0)) {
+    EvalString_0=', "loc": ["'+EvalString_0.split(',').join('","')+'"]';
+  } else if (/hero|([+-]?\d+),([+-]?\d+)/.test(EvalString_0)) {
+    if(EvalString_0.indexOf(',')!==-1)EvalString_0='['+EvalString_0+']';
+    else EvalString_0='"'+EvalString_0+'"';
+    EvalString_0 = ', "loc": '+EvalString_0;
+  } else {
+    throw new Error('此处只能填hero或者1,2形式的位置,或者不填代表当前事件点');
+  }
+}
+var async = Bool_0?', "async": true':'';
+var code = '{"type": "animate", "name": "'+IdString_0+'"'+EvalString_0+async+'},\n';
+return code;
+*/;
+
+showImage_s
+    :   '显示图片' '图片编号' Int '图片' EvalString BGNL?
+        '绘制的起点像素' 'x' PosString 'y' PosString '不透明度' Number '时间' Int '不等待执行完毕' Bool Newline
+    
+
+/* showImage_s
+tooltip : showImage：显示图片
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=showImage%ef%bc%9a%e6%98%be%e7%a4%ba%e5%9b%be%e7%89%87
+default : [1,"bg.jpg","0","0",1,0,false]
+colour : this.printColor
+if(Int_0<=0 || Int_0>50) throw new Error('图片编号在1~50之间');
+var async = Bool_0?', "async": true':'';
+var code = '{"type": "showImage", "code": '+Int_0+', "image": "'+EvalString_0+'", "loc": ['+PosString_0+','+PosString_1+'], "opacity": '+Number_0+', "time": '+Int_1+async+'},\n';
+return code;
+*/;
+
+showImage_1_s
+    :   '显示图片' '图片编号' Int '图片' EvalString BGNL?
+        '裁剪的起点像素' 'x' PosString 'y' PosString '宽' PosString? '高' PosString? '不透明度' Number BGNL?
+        '绘制的起点像素' 'x' PosString 'y' PosString '宽' PosString? '高' PosString? '时间' Int '不等待执行完毕' Bool Newline
+
+
+/* showImage_1_s
+tooltip : showImage_1：显示图片
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=showImage%ef%bc%9a%e6%98%be%e7%a4%ba%e5%9b%be%e7%89%87
+default : [1,"bg.jpg","0","0","","",1,"0","0","","",0,false]
+colour : this.printColor
+if(Int_0<=0 || Int_0>50) throw new Error('图片编号在1~50之间');
+var async = Bool_0?', "async": true':'';
+var code = '{"type": "showImage", "code": '+Int_0+', "image": "'+EvalString_0+'", '+
+           '"sloc": ['+PosString_0+','+PosString_1+','+PosString_2+','+PosString_3+'], '+
+           '"loc": ['+PosString_4+','+PosString_5+','+PosString_6+','+PosString_7+'], '+
+           '"opacity": '+Number_0+', "time": '+Int_1+async+'},\n';
+return code;
+*/;
+
+showTextImage_s
+    :   '显示图片化文本' '文本内容' EvalString BGNL?
+        '图片编号' Int '起点像素' 'x' PosString 'y' PosString '行距' Number '不透明度' Number '时间' Int '不等待执行完毕' Bool Newline
+    
+
+/* showTextImage_s
+tooltip : showTextImage：显示图片化文本
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=showTextImage%ef%bc%9a%e6%98%be%e7%a4%ba%e6%96%87%e6%9c%ac%e5%8c%96%e5%9b%be%e7%89%87
+colour : this.printColor
+default : ["可以使用setText事件来控制字体、颜色、大小、偏移量等",1,"0","0",1.4,1,0,false]
+if(Int_0<=0 || Int_0>50) throw new Error('图片编号在1~50之间');
+var async = Bool_0?', "async": true':'';
+var code = '{"type": "showTextImage", "code": '+Int_0+', "text": "'+EvalString_0+'", "loc": ['+PosString_0+','+PosString_1+'], "lineHeight": '+Number_0+', "opacity": '+Number_1+', "time": '+Int_1+async+'},\n';
+return code;
+*/;
+
+hideImage_s
+    :   '清除图片' '图片编号' Int '时间' Int '不等待执行完毕' Bool Newline
+    
+
+/* hideImage_s
+tooltip : hideImage：清除图片
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=hideImage%ef%bc%9a%e6%b8%85%e9%99%a4%e5%9b%be%e7%89%87
+colour : this.printColor
+default : [1,0,false]
+if(Int_0<=0 || Int_0>50) throw new Error('图片编号在1~50之间');
+var async = Bool_0?', "async": true':'';
+var code = '{"type": "hideImage", "code": '+Int_0+', "time": '+Int_1+async+'},\n';
+return code;
+*/;
+
+showGif_0_s
+    :   '显示动图' EvalString '起点像素位置' 'x' PosString 'y' PosString Newline
+    
+
+/* showGif_0_s
+tooltip : showGif：显示动图
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=showgif%EF%BC%9A%E6%98%BE%E7%A4%BA%E5%8A%A8%E5%9B%BE
+default : ["bg.gif","0","0"]
+colour : this.printColor
+var code = '{"type": "showGif", "name": "'+EvalString_0+'", "loc": ['+PosString_0+','+PosString_1+']},\n';
+return code;
+*/;
+
+showGif_1_s
+    :   '清除所有动图' Newline
+    
+
+/* showGif_1_s
+tooltip : showGif：清除所有显示的动图
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=showgif%EF%BC%9A%E6%98%BE%E7%A4%BA%E5%8A%A8%E5%9B%BE
+colour : this.printColor
+var code = '{"type": "showGif"},\n';
+return code;
+*/;
+
+moveImage_s
+    :   '图片移动' '图片编号' Int '终点像素位置' 'x' PosString? 'y' PosString? BGNL?
+        '不透明度' EvalString? '移动时间' Int '不等待执行完毕' Bool Newline
+    
+
+/* moveImage_s
+tooltip : moveImage：图片移动
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=moveImage%ef%bc%9a%e5%9b%be%e7%89%87%e7%a7%bb%e5%8a%a8
+default : [1,'','','',500,false]
+colour : this.printColor
+if(Int_0<=0 || Int_0>50) throw new Error('图片编号在1~50之间');
+var toloc = '';
+if (PosString_0 && PosString_1)
+  toloc = ', "to": ['+PosString_0+','+PosString_1+']';
+EvalString_0 = (EvalString_0!=='') ? (', "opacity": '+EvalString_0):'';
+var async = Bool_0?', "async": true':'';
+var code = '{"type": "moveImage", "code": '+Int_0+toloc+EvalString_0+',"time": '+Int_1+async+'},\n';
+return code;
+*/;
+
+setCurtain_0_s
+    :   '更改画面色调' EvalString Colour '动画时间' Int? '不等待执行完毕' Bool Newline
+    
+
+/* setCurtain_0_s
+tooltip : setCurtain: 更改画面色调,动画时间可不填
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=setcurtain%EF%BC%9A%E6%9B%B4%E6%94%B9%E7%94%BB%E9%9D%A2%E8%89%B2%E8%B0%83
+default : ["255,255,255,1",'rgba(255,255,255,1)',500,false]
+colour : this.soundColor
+var colorRe = MotaActionFunctions.pattern.colorRe;
+if (!colorRe.test(EvalString_0))throw new Error('颜色格式错误,形如:0~255,0~255,0~255,0~1');
+Int_0 = Int_0!=='' ?(', "time": '+Int_0):'';
+var async = Bool_0?', "async": true':'';
+var code = '{"type": "setCurtain", "color": ['+EvalString_0+']'+Int_0 +async+'},\n';
+return code;
+*/;
+
+setCurtain_1_s
+    :   '恢复画面色调' '动画时间' Int? '不等待执行完毕' Bool Newline
+    
+
+/* setCurtain_1_s
+tooltip : setCurtain: 恢复画面色调,动画时间可不填
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=setcurtain%EF%BC%9A%E6%9B%B4%E6%94%B9%E7%94%BB%E9%9D%A2%E8%89%B2%E8%B0%83
+default : [500,false]
+colour : this.soundColor
+Int_0 = Int_0!=='' ?(', "time": '+Int_0):'';
+var async = Bool_0?', "async": true':'';
+var code = '{"type": "setCurtain"'+Int_0 +async+'},\n';
+return code;
+*/;
+
+screenFlash_s
+    :   '画面闪烁' EvalString Colour '单次时间' Int '执行次数' Int? '不等待执行完毕' Bool Newline
+
+/* screenFlash_s
+tooltip : screenFlash: 画面闪烁,动画时间可不填
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=screenFlash%EF%BC%9A%E7%94%BB%E9%9D%A2%E9%97%AA%E7%83%81
+default : ["255,255,255,1",'rgba(255,255,255,1)',500,1,false]
+colour : this.soundColor
+var colorRe = MotaActionFunctions.pattern.colorRe;
+if (!colorRe.test(EvalString_0))throw new Error('颜色格式错误,形如:0~255,0~255,0~255,0~1');
+Int_1 = Int_1!=='' ?(', "times": '+Int_1):'';
+var async = Bool_0?', "async": true':'';
+var code = '{"type": "screenFlash", "color": ['+EvalString_0+'], "time": '+Int_0 +Int_1+async+'},\n';
+return code;
+*/;
+
+setWeather_s
+    :   '更改天气' Weather_List '强度' Int Newline
+    
+
+/* setWeather_s
+tooltip : setWeather：更改天气
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=setweather%EF%BC%9A%E6%9B%B4%E6%94%B9%E5%A4%A9%E6%B0%94
+default : [null,1]
+colour : this.soundColor
+if(Int_0<1 || Int_0>10) throw new Error('天气的强度等级, 在1-10之间');
+var code = '{"type": "setWeather", "name": "'+Weather_List_0+'", "level": '+Int_0+'},\n';
+if(Weather_List_0===''||Weather_List_0==='null'||Weather_List_0==null)code = '{"type": "setWeather"},\n';
+return code;
+*/;
+
+move_s
+    :   '移动事件' 'x' PosString? ',' 'y' PosString? '动画时间' Int? '不消失' Bool '不等待执行完毕' Bool BGNL? StepString Newline
+    
+
+/* move_s
+tooltip : move: 让某个NPC/怪物移动,位置可不填代表当前事件
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=move%EF%BC%9A%E8%AE%A9%E6%9F%90%E4%B8%AAnpc%E6%80%AA%E7%89%A9%E7%A7%BB%E5%8A%A8
+default : ["","",500,false,false,"上右3下2后4左前2"]
+colour : this.mapColor
+var floorstr = '';
+if (PosString_0 && PosString_1) {
+    floorstr = ', "loc": ['+PosString_0+','+PosString_1+']';
+}
+Int_0 = Int_0!=='' ?(', "time": '+Int_0):'';
+Bool_0 = Bool_0?', "keep": true':'';
+Bool_1 = Bool_1?', "async": true':'';
+var code = '{"type": "move"'+floorstr+Int_0+Bool_0+Bool_1+', "steps": '+JSON.stringify(StepString_0)+'},\n';
+return code;
+*/;
+
+moveHero_s
+    :   '移动勇士' '动画时间' Int? '不等待执行完毕' Bool BGNL? StepString Newline
+    
+
+/* moveHero_s
+tooltip : moveHero：移动勇士,用这种方式移动勇士的过程中将无视一切地形, 无视一切事件, 中毒状态也不会扣血
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=movehero%EF%BC%9A%E7%A7%BB%E5%8A%A8%E5%8B%87%E5%A3%AB
+default : [500,false,"上右3下2后4左前2"]
+colour : this.dataColor
+Int_0 = Int_0!=='' ?(', "time": '+Int_0):'';
+Bool_0 = Bool_0?', "async": true':'';
+var code = '{"type": "moveHero"'+Int_0+Bool_0+', "steps": '+JSON.stringify(StepString_0)+'},\n';
+return code;
+*/;
+
+jump_s
+    :   '跳跃事件' '起始 x' PosString? ',' 'y' PosString? '终止 x' PosString? ',' 'y' PosString? '动画时间' Int? '不消失' Bool '不等待执行完毕' Bool Newline
+
+
+/* jump_s
+tooltip : jump: 让某个NPC/怪物跳跃
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=jump%EF%BC%9A%E8%AE%A9%E6%9F%90%E4%B8%AANPC%2F%E6%80%AA%E7%89%A9%E8%B7%B3%E8%B7%83
+default : ["","","","",500,true,false]
+colour : this.mapColor
+var floorstr = '';
+if (PosString_0 && PosString_1) {
+    floorstr += ', "from": ['+PosString_0+','+PosString_1+']';
+}
+if (PosString_2 && PosString_3) {
+    floorstr += ', "to": ['+PosString_2+','+PosString_3+']';
+}
+Int_0 = Int_0!=='' ?(', "time": '+Int_0):'';
+Bool_0 = Bool_0?', "keep": true':'';
+Bool_1 = Bool_1?', "async": true':'';
+var code = '{"type": "jump"'+floorstr+''+Int_0+Bool_0+Bool_1+'},\n';
+return code;
+*/;
+
+jumpHero_s
+    :   '跳跃勇士' 'x' PosString? ',' 'y' PosString? '动画时间' Int? '不等待执行完毕' Bool Newline
+
+
+/* jumpHero_s
+tooltip : jumpHero: 跳跃勇士
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=jumpHero%EF%BC%9A%E8%B7%B3%E8%B7%83%E5%8B%87%E5%A3%AB
+default : ["","",500,false]
+colour : this.dataColor
+var floorstr = '';
+if (PosString_0 && PosString_1) {
+    floorstr = ', "loc": ['+PosString_0+','+PosString_1+']';
+}
+Int_0 = Int_0!=='' ?(', "time": '+Int_0):'';
+Bool_0 = Bool_0?', "async": true':'';
+var code = '{"type": "jumpHero"'+floorstr+Int_0+Bool_0+'},\n';
+return code;
+*/;
+
+playBgm_s
+    :   '播放背景音乐' EvalString Newline
+    
+
+/* playBgm_s
+tooltip : playBgm: 播放背景音乐
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=playbgm%EF%BC%9A%E6%92%AD%E6%94%BE%E8%83%8C%E6%99%AF%E9%9F%B3%E4%B9%90
+default : ["bgm.mp3"]
+colour : this.soundColor
+var code = '{"type": "playBgm", "name": "'+EvalString_0+'"},\n';
+return code;
+*/;
+
+pauseBgm_s
+    :   '暂停背景音乐' Newline
+    
+
+/* pauseBgm_s
+tooltip : pauseBgm: 暂停背景音乐
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=pausebgm%EF%BC%9A%E6%9A%82%E5%81%9C%E8%83%8C%E6%99%AF%E9%9F%B3%E4%B9%90
+colour : this.soundColor
+var code = '{"type": "pauseBgm"},\n';
+return code;
+*/;
+
+resumeBgm_s
+    :   '恢复背景音乐' Newline
+    
+
+/* resumeBgm_s
+tooltip : resumeBgm: 恢复背景音乐
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=resumebgm%EF%BC%9A%E6%81%A2%E5%A4%8D%E8%83%8C%E6%99%AF%E9%9F%B3%E4%B9%90
+colour : this.soundColor
+var code = '{"type": "resumeBgm"},\n';
+return code;
+*/;
+
+loadBgm_s
+    :   '预加载背景音乐' EvalString Newline
+
+
+/* loadBgm_s
+tooltip : loadBgm: 预加载某个背景音乐，之后可以直接播放
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=loadBgm%ef%bc%9a%e9%a2%84%e5%8a%a0%e8%bd%bd%e4%b8%80%e4%b8%aa%e8%83%8c%e6%99%af%e9%9f%b3%e4%b9%90
+default : ["bgm.mp3"]
+colour : this.soundColor
+var code = '{"type": "loadBgm", "name": "'+EvalString_0+'"},\n';
+return code;
+*/;
+
+freeBgm_s
+    :   '释放背景音乐的缓存' EvalString Newline
+
+
+/* freeBgm_s
+tooltip : freeBgm: 释放背景音乐的缓存
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=freeBgm%ef%bc%9a%e9%87%8a%e6%94%be%e4%b8%80%e4%b8%aa%e8%83%8c%e6%99%af%e9%9f%b3%e4%b9%90%e7%9a%84%e7%bc%93%e5%ad%98
+default : ["bgm.mp3"]
+colour : this.soundColor
+var code = '{"type": "freeBgm", "name": "'+EvalString_0+'"},\n';
+return code;
+*/;
+
+playSound_s
+    :   '播放音效' EvalString '停止之前音效' Bool? Newline
+    
+
+/* playSound_s
+tooltip : playSound: 播放音效
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=playsound%EF%BC%9A%E6%92%AD%E6%94%BE%E9%9F%B3%E6%95%88
+default : ["item.mp3",false]
+colour : this.soundColor
+Bool_0 = Bool_0 ? ', "stop": true' : '';
+var code = '{"type": "playSound", "name": "'+EvalString_0+'"'+Bool_0+'},\n';
+return code;
+*/;
+
+stopSound_s
+    :   '停止所有音效' Newline
+
+
+/* stopSound_s
+tooltip : stopSound: 停止所有音效
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=stopSound%ef%bc%9a%e5%81%9c%e6%ad%a2%e6%89%80%e6%9c%89%e9%9f%b3%e6%95%88
+colour : this.soundColor
+var code = '{"type": "stopSound"},\n';
+return code;
+*/;
+
+setVolume_s
+    :   '设置音量' Int '渐变时间' Int? '不等待执行完毕' Bool Newline
+    
+
+/* setVolume_s
+tooltip : setVolume: 设置音量
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=setvolume%EF%BC%9A%E8%AE%BE%E7%BD%AE%E9%9F%B3%E9%87%8F
+default : [90, 500, false]
+colour : this.soundColor
+Int_1 = Int_1!==''?(', "time": '+Int_1):""
+var async = Bool_0?', "async": true':'';
+var code = '{"type": "setVolume", "value": '+Int_0+Int_1+async+'},\n';
+return code;
+*/;
+
+win_s
+    :   '游戏胜利,结局' ':' EvalString? '不计入榜单' Bool Newline
+    
+
+/* win_s
+tooltip : win: 获得胜利, 该事件会显示获胜页面, 并重新游戏
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=win%EF%BC%9A%E8%8E%B7%E5%BE%97%E8%83%9C%E5%88%A9
+default : ["",false]
+Bool_0 = Bool_0?', "norank": 1':'';
+var code = '{"type": "win", "reason": "'+EvalString_0+'"'+Bool_0+'},\n';
+return code;
+*/;
+
+lose_s
+    :   '游戏失败,结局' ':' EvalString? Newline
+    
+
+/* lose_s
+tooltip : lose: 游戏失败, 该事件会显示失败页面, 并重新开始游戏
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=lose%EF%BC%9A%E6%B8%B8%E6%88%8F%E5%A4%B1%E8%B4%A5
+default : [""]
+var code = '{"type": "lose", "reason": "'+EvalString_0+'"},\n';
+return code;
+*/;
+
+restart_s
+    :   '直接回到标题界面' Newline
+
+
+/* restart_s
+tooltip : restart: 直接回到标题界面
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=restart%ef%bc%9a%e7%9b%b4%e6%8e%a5%e5%9b%9e%e5%88%b0%e6%a0%87%e9%a2%98%e7%95%8c%e9%9d%a2
+var code = '{"type": "restart"},\n';
+return code;
+*/;
+
+input_s
+    :   '接受用户输入数字,提示' ':' EvalString Newline
+    
+
+/* input_s
+tooltip : input：接受用户输入数字, 事件只能接受非负整数输入, 所有非法的输入将全部变成0
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=input%ef%bc%9a%e6%8e%a5%e5%8f%97%e7%94%a8%e6%88%b7%e8%be%93%e5%85%a5%e6%95%b0%e5%ad%97
+default : ["请输入一个数"]
+colour : this.dataColor
+var code = '{"type": "input", "text": "'+EvalString_0+'"},\n';
+return code;
+*/;
+
+input2_s
+    :   '接受用户输入文本,提示' ':' EvalString Newline
+
+
+/* input2_s
+tooltip : input2：接受用户输入文本, 允许用户输入任何形式的文本
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=input2%ef%bc%9a%e6%8e%a5%e5%8f%97%e7%94%a8%e6%88%b7%e8%be%93%e5%85%a5%e6%96%87%e6%9c%ac
+default : ["请输入文本"]
+colour : this.dataColor
+var code = '{"type": "input2", "text": "'+EvalString_0+'"},\n';
+return code;
+*/;
+
+if_s
+    :   '如果' ':' expression BGNL? Newline action+ '否则' ':' BGNL? Newline action+ BEND Newline
+    
+
+/* if_s
+tooltip : if: 条件判断
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=if%EF%BC%9A%E6%9D%A1%E4%BB%B6%E5%88%A4%E6%96%AD
+colour : this.eventColor
+var code = ['{"type": "if", "condition": "',expression_0,'",\n',
+    '"true": [\n',action_0,'],\n',
+    '"false": [\n',action_1,']\n',
+'},\n'].join('');
+return code;
+*/;
+
+if_1_s
+    :   '如果' ':' expression BGNL? Newline action+  BEND Newline
+
+
+/* if_1_s
+tooltip : if: 条件判断
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=if%EF%BC%9A%E6%9D%A1%E4%BB%B6%E5%88%A4%E6%96%AD
+colour : this.eventColor
+var code = ['{"type": "if", "condition": "',expression_0,'",\n',
+    '"true": [\n',action_0,'],\n',
+'},\n'].join('');
+return code;
+*/;
+
+switch_s
+    :   '多重分歧 条件判定' ':' expression BGNL? Newline switchCase+ BEND Newline
+
+
+/* switch_s
+tooltip : switch: 多重条件分歧
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=switch%EF%BC%9A%E5%A4%9A%E9%87%8D%E6%9D%A1%E4%BB%B6%E5%88%86%E6%AD%A7
+default : ["判别值"]
+colour : this.eventColor
+var code = ['{"type": "switch", "condition": "',expression_0,'", "caseList": [\n',
+    switchCase_0,
+'], },\n'].join('');
+return code;
+*/;
+
+switchCase
+    :   '如果是' expression '的场合' '不跳出' Bool BGNL? Newline action+
+
+
+/* switchCase
+tooltip : 选项的选择
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=switch%EF%BC%9A%E5%A4%9A%E9%87%8D%E6%9D%A1%E4%BB%B6%E5%88%86%E6%AD%A7
+default : ["", false]
+colour : this.subColor
+Bool_0 = Bool_0?', "nobreak": true':'';
+var code = '{"case": "'+expression_0+'"'+Bool_0+', "action": [\n'+action_0+']},\n';
+return code;
+*/;
+
+choices_s
+    :   '选项' ':' EvalString? BGNL? '标题' EvalString? '图像' IdString? BGNL? Newline choicesContext+ BEND Newline
+
+
+/* choices_s
+tooltip : choices: 给用户提供选项
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=choices%EF%BC%9A%E7%BB%99%E7%94%A8%E6%88%B7%E6%8F%90%E4%BE%9B%E9%80%89%E9%A1%B9
+default : ["","流浪者","woman"]
+var title='';
+if (EvalString_1==''){
+    if (IdString_0=='')title='';
+    else title='\\t['+IdString_0+']';
+} else {
+    if (IdString_0=='')title='\\t['+EvalString_1+']';
+    else title='\\t['+EvalString_1+','+IdString_0+']';
+}
+EvalString_0 = title+EvalString_0;
+EvalString_0 = EvalString_0 ?(', "text": "'+EvalString_0+'"'):'';
+var code = ['{"type": "choices"',EvalString_0,', "choices": [\n',
+    choicesContext_0,
+']},\n'].join('');
+return code;
+*/;
+
+choicesContext
+    :   '子选项' EvalString '图标' IdString? '颜色' EvalString? Colour BGNL? Newline action+
+
+
+/* choicesContext
+tooltip : 选项的选择
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=choices%EF%BC%9A%E7%BB%99%E7%94%A8%E6%88%B7%E6%8F%90%E4%BE%9B%E9%80%89%E9%A1%B9
+default : ["提示文字:红钥匙","",""]
+colour : this.subColor
+if (EvalString_1) {
+  var colorRe = MotaActionFunctions.pattern.colorRe;
+  if (colorRe.test(EvalString_1))
+      EvalString_1 = ', "color": ['+EvalString_1+']';
+  else
+      EvalString_1 = ', "color": "'+EvalString_1+'"';
+}
+IdString_0 = IdString_0?(', "icon": "'+IdString_0+'"'):'';
+var code = '{"text": "'+EvalString_0+'"'+IdString_0+EvalString_1+', "action": [\n'+action_0+']},\n';
+return code;
+*/;
+
+confirm_s
+    :   '显示确认框' ':' EvalString BGNL? '确定的场合' ':' '（默认选中' Bool '）' BGNL? Newline action+ '取消的场合' ':' BGNL? Newline action+ BEND Newline
+
+/* confirm_s
+tooltip : 弹出确认框
+helpUrl : https://h5mota.com/games/template/docs/#/
+default : ["确认要xxx吗?",false]
+Bool_0 = Bool_0?', "default": true':''
+var code = ['{"type": "confirm"'+Bool_0+', "text": "',EvalString_0,'",\n',
+    '"yes": [\n',action_0,'],\n',
+    '"no": [\n',action_1,']\n',
+'},\n'].join('');
+return code;
+*/;
+
+while_s
+    :   '前置条件循环' '：' '当' expression '时' BGNL? Newline action+ BEND Newline
+
+/* while_s
+tooltip : while：前置条件循环
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=while%ef%bc%9a%e5%89%8d%e7%bd%ae%e6%9d%a1%e4%bb%b6%e5%be%aa%e7%8e%af
+colour : this.eventColor
+var code = ['{"type": "while", "condition": "',expression_0,'",\n',
+    '"data": [\n',action_0,'],\n',
+'},\n'].join('');
+return code;
+*/;
+
+dowhile_s
+    :   '后置条件循环' '：'  BGNL? Newline action+ BEND '当' expression '时' Newline
+
+/* dowhile_s
+tooltip : dowhile：后置条件循环
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=dowhile%ef%bc%9a%e5%90%8e%e7%bd%ae%e6%9d%a1%e4%bb%b6%e5%be%aa%e7%8e%af
+colour : this.eventColor
+var code = ['{"type": "dowhile", "condition": "',expression_0,'",\n',
+    '"data": [\n',action_0,'],\n',
+'},\n'].join('');
+return code;
+*/;
+
+break_s
+    :   '跳出当前循环或公共事件' Newline
+
+/* break_s
+tooltip : break：跳出循环, 如果break事件不在任何循环中被执行，则和exit等价，即会立刻结束当前事件！
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=break%EF%BC%9A%E8%B7%B3%E5%87%BA%E5%BE%AA%E7%8E%AF
+colour : this.eventColor
+var code = '{"type": "break"},\n';
+return code;
+*/;
+
+continue_s
+    :   '继续当前循环' Newline
+
+/* continue_s
+tooltip : continue：继续执行当前循环的下一轮, 如果continue事件不在任何循环中被执行，则和exit等价，即会立刻结束当前事件！
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=continue%EF%BC%9A%E7%BB%A7%E7%BB%AD%E6%89%A7%E8%A1%8C%E5%BD%93%E5%89%8D%E5%BE%AA%E7%8E%AF
+colour : this.eventColor
+var code = '{"type": "continue"},\n';
+return code;
+*/;
+
+
+wait_s
+    :   '等待用户操作并获得按键或点击信息'
+
+
+/* wait_s
+tooltip : wait: 等待用户操作并获得按键或点击信息（具体用法看文档）
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=wait%EF%BC%9A%E7%AD%89%E5%BE%85%E7%94%A8%E6%88%B7%E6%93%8D%E4%BD%9C
+colour : this.soundColor
+var code = '{"type": "wait"},\n';
+return code;
+*/;
+
+
+waitAsync_s
+    :   '等待所有异步事件执行完毕'
+
+
+/* waitAsync_s
+tooltip : waitAsync: 等待所有异步事件执行完毕
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=waitAsync%ef%bc%9a%e7%ad%89%e5%be%85%e6%89%80%e6%9c%89%e5%bc%82%e6%ad%a5%e4%ba%8b%e4%bb%b6%e6%89%a7%e8%a1%8c%e5%ae%8c%e6%af%95
+colour : this.soundColor
+var code = '{"type": "waitAsync"},\n';
+return code;
+*/;
+
+
+callBook_s
+    :   '呼出怪物手册'
+
+
+/* callBook_s
+tooltip : callBook: 呼出怪物手册；返回游戏后将继续执行后面的事件
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=callBook%ef%bc%9a%e5%91%bc%e5%87%ba%e6%80%aa%e7%89%a9%e6%89%8b%e5%86%8c
+colour : this.soundColor
+var code = '{"type": "callBook"},\n';
+return code;
+*/;
+
+
+callSave_s
+    :   '呼出存档页面'
+
+
+/* callSave_s
+tooltip : callSave: 呼出存档页面
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=callSave%ef%bc%9a%e5%91%bc%e5%87%ba%e5%ad%98%e6%a1%a3%e7%95%8c%e9%9d%a2
+colour : this.soundColor
+var code = '{"type": "callSave"},\n';
+return code;
+*/;
+
+
+autoSave_s
+    :   '自动存档'
+
+
+/* autoSave_s
+tooltip : autoSave: 自动存档
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=autoSave%ef%bc%9a%e8%87%aa%e5%8a%a8%e5%ad%98%e6%a1%a3
+colour : this.soundColor
+var code = '{"type": "autoSave"},\n';
+return code;
+*/;
+
+
+callLoad_s
+    :   '呼出读档页面'
+
+
+/* callLoad_s
+tooltip : callLoad: 呼出存档页面；返回游戏后将继续执行后面的事件
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=callLoad%ef%bc%9a%e5%91%bc%e5%87%ba%e8%af%bb%e6%a1%a3%e7%95%8c%e9%9d%a2
+colour : this.soundColor
+var code = '{"type": "callLoad"},\n';
+return code;
+*/;
+
+unknown_s
+    :   '自定义事件' BGNL? RawEvalString
+
+/* unknown_s
+tooltip : 通过脚本自定义的事件类型, 以及编辑器不识别的事件类型
+helpUrl : https://h5mota.com/games/template/docs/#/
+default : ['{"type":"test", "data": "这是自定义的参数"}']
+colour : this.dataColor
+try {
+    var tempobj = JSON.parse(RawEvalString_0);
+} catch (e) {throw new Error("不合法的JSON格式！");}
+if (!tempobj.type) throw new Error("自定义事件需要一个type:xxx");
+var code = JSON.stringify(tempobj) +',\n';
+return code;
+*/;
+
+function_s
+    :   '自定义JS脚本' '不自动执行下一个事件' Bool BGNL? Newline RawEvalString Newline BEND Newline
+    
+
+/* function_s
+tooltip : 可双击多行编辑，请勿使用异步代码。常见API参见文档附录。
+helpUrl : https://h5mota.com/games/template/docs/#/event?id=function%EF%BC%9A%E8%87%AA%E5%AE%9A%E4%B9%89js%E8%84%9A%E6%9C%AC
+default : [false,"alert(core.getStatus(\"atk\"));"]
+colour : this.dataColor
+Bool_0 = Bool_0?', "async": true':'';
+var code = '{"type": "function"'+Bool_0+', "function": "function(){\\n'+JSON.stringify(RawEvalString_0).slice(1,-1).split('\\\\n').join('\\n')+'\\n}"},\n';
+return code;
+*/;
+
+pass_s
+    :   Newline
+    
+
+/* pass_s
+var code = ' \n';
+return code;
+*/;
+
+statExprSplit : '=== statement ^ === expression v ===' ;
+//===blockly表达式===
+
+expression
+    :   expression Arithmetic_List expression
+    |   negate_e
+    |   bool_e
+    |   idString_e
+    |   evFlag_e
+    |   evalString_e
+    
+
+/* expression_arithmetic_0
+//todo 修改recieveOrder,根据Arithmetic_List_0不同的值设定不同的recieveOrder
+var code = expression_0 + Arithmetic_List_0 + expression_1;
+var ops = {
+    '^': 'Math.pow('+expression_0+','+expression_1+')',
+    '和': expression_0+' && '+expression_1,
+    '或': expression_0+' || '+expression_1,
+}
+if (ops[Arithmetic_List_0])code = ops[Arithmetic_List_0];
+var orders = {
+    '+': Blockly.JavaScript.ORDER_ADDITION,
+    '-': Blockly.JavaScript.ORDER_SUBTRACTION,
+    '*': Blockly.JavaScript.ORDER_MULTIPLICATION,
+    '/': Blockly.JavaScript.ORDER_DIVISION,
+    '^': Blockly.JavaScript.ORDER_MEMBER, //recieveOrder : ORDER_COMMA
+    '==': Blockly.JavaScript.ORDER_EQUALITY,
+    '!=': Blockly.JavaScript.ORDER_EQUALITY,
+    '>': Blockly.JavaScript.ORDER_RELATIONAL,
+    '<': Blockly.JavaScript.ORDER_RELATIONAL,
+    '>=': Blockly.JavaScript.ORDER_RELATIONAL,
+    '<=': Blockly.JavaScript.ORDER_RELATIONAL,
+    '和': Blockly.JavaScript.ORDER_LOGICAL_AND,
+    '或': Blockly.JavaScript.ORDER_LOGICAL_OR
+}
+return [code, orders[Arithmetic_List_0]];
+*/;
+
+negate_e
+    :   '非' expression
+    
+
+/* negate_e
+//todo 修改recieveOrder : ORDER_LOGICAL_NOT 修改 inputsInline
+var code = '!'+expression_0;
+return [code, Blockly.JavaScript.ORDER_LOGICAL_NOT];
+*/;
+
+bool_e
+    :   Bool
+    
+
+/* bool_e
+var code = Bool_0;
+return [code, Blockly.JavaScript.ORDER_ATOMIC];
+*/;
+
+
+idString_e
+    :   IdString
+    
+
+/* idString_e
+colour : this.idstring_eColor
+default : ["status:hp"]
+var code = IdString_0;
+return [code, Blockly.JavaScript.ORDER_ATOMIC];
+*/;
+
+//这一条不会被antlr识别,总是会被归到idString_e
+idString_1_e
+    :   Id_List ':' IdText
+    
+
+/* idString_1_e
+colour : this.idstring_eColor
+default : [null,"自定义flag"]
+//todo 将其output改成'idString_e'
+var code = Id_List_0+':'+IdText_0;
+return [code, Blockly.JavaScript.ORDER_ATOMIC];
+*/;
+
+//这一条不会被antlr识别,总是会被归到idString_e
+idString_2_e
+    :   FixedId_List
+    
+
+/* idString_2_e
+colour : this.idstring_eColor
+//todo 将其output改成'idString_e'
+var code = FixedId_List_0;
+return [code, Blockly.JavaScript.ORDER_ATOMIC];
+*/;
+
+
+evFlag_e
+    :   '独立开关' Letter_List
+
+
+/* evFlag_e
+colour : this.idstring_eColor
+default : ["A"]
+var code = "switch:"+Letter_List_0;
+return [code, Blockly.JavaScript.ORDER_ATOMIC];
+*/;
+
+
+evalString_e
+    :   EvalString
+    
+
+/* evalString_e
+default : ["值"]
+var code = EvalString_0;
+return [code, Blockly.JavaScript.ORDER_ATOMIC];
+*/;
+
+//===============lexer===============
+
+IdText
+    :   'sdeirughvuiyasdeb'+ //为了被识别为复杂词法规则
+    ;
+
+RawEvalString
+    :   'sdeirughvuiyasdbe'+ //为了被识别为复杂词法规则
+    ;
+
+PosString
+    :   'sdeirughvuiyasbde'+ //为了被识别为复杂词法规则
+    ;
+
+Floor_List
+    :   '楼层ID'|'前一楼'|'后一楼'
+    /*Floor_List ['floorId',':before',':next']*/;
+
+Stair_List
+    :   '坐标'|'上楼梯'|'下楼梯'|'保持不变'
+    /*Stair_List ['loc','upFloor','downFloor','now']*/;
+
+SetTextPosition_List
+    :   '不改变'|'距离顶部'|'居中'|'距离底部'
+    /*SetTextPosition_List ['null','up','center','down']*/;
+
+SetTextAlign_List
+    :   '不改变'|'左对齐'|'左右居中'|'右对齐'
+    /*SetTextAlign_List ['null','left','center','right']*/;
+
+ShopUse_List
+    :   '金币' | '经验'
+    /*ShopUse_List ['money','experience']*/;
+
+Arithmetic_List
+    :   '+'|'-'|'*'|'/'|'^'|'=='|'!='|'>'|'<'|'>='|'<='|'和'|'或'
+    ;
+
+Weather_List
+    :   '无'|'雨'|'雪'|'雾'
+    /*Weather_List ['null','rain','snow','fog']*/;
+
+B_0_List
+    :   '不改变'|'不可通行'|'可以通行'
+    /*B_0_List ['null','true','false']*/;
+
+B_1_List
+    :   '不改变'|'设为粗体'|'取消粗体'
+    /*B_1_List ['null','true','false']*/;
+
+Bg_Fg_List
+    :   '背景层'|'前景层'
+    /*Bg_Fg_List ['bg','fg']*/;
+
+Event_List
+    :   '事件'|'战后事件'|'道具后事件'|'开门后事件'
+    /*Event_List ['null','afterBattle','afterGetItem','afterOpenDoor']*/;
+
+Floor_Meta_List
+    :   '楼层中文名'|'状态栏名称'|'能否使用楼传'|'能否打开快捷商店'|'是否不可浏览地图'|'是否不可瞬间移动'|'默认地面ID'|'楼层贴图'|'宝石血瓶效果'|'上楼点坐标'|'下楼点坐标'|'背景音乐'|'画面色调'|'天气和强度'|'是否地下层'
+    /*Floor_Meta_List ['title','name','canFlyTo', 'canUseQuickShop', 'cannotViewMap', 'cannotMoveDirectly', 'defaultGround', 'images', 'item_ratio', 'upFloor', 'downFloor', 'bgm', 'color', 'weather', 'underGround']*/;
+
+Global_Attribute_List
+    :   '全局字体'|'横屏左侧状态栏背景'|'竖屏上方状态栏背景'|'竖屏下方道具栏背景'|'边框颜色'|'状态栏文字色'|'难度显示文字色'|'楼层转换背景'|'楼层转换文字色'|'装备列表'
+    /*Global_Attribute_List ['font','statusLeftBackground','statusTopBackground', 'toolsBackground', 'borderColor', 'statusBarColor', 'hardLabelColor', 'floorChangingBackground', 'floorChangingTextColor', 'equipName']*/;
+
+Global_Value_List
+    :   '血网伤害'|'中毒伤害'|'衰弱效果'|'红宝石效果'|'蓝宝石效果'|'绿宝石效果'|'红血瓶效果'|'蓝血瓶效果'|'黄血瓶效果'|'绿血瓶效果'|'破甲比例'|'反击比例'|'净化比例'|'仇恨增加值'|'行走速度'|'动画时间'|'楼层切换时间'
+    /*Global_Value_List ['lavaDamage','poisonDamage','weakValue', 'redJewel', 'blueJewel', 'greenJewel', 'redPotion', 'bluePotion', 'yellowPotion', 'greenPotion', 'breakArmor', 'counterAttack', 'purify', 'hatred', 'moveSpeed', 'animateSpeed', 'floorChangeTime']*/;
+
+
+Global_Flag_List
+    :   '显示当前楼层'|'显示勇士图标'|'显示当前等级'|'启用生命上限'|'显示魔力值'|'显示魔防值'|'显示金币值'|'显示经验值'|'允许等级提升'|'升级扣除模式'|'显示钥匙数量'|'显示破炸飞'|'显示毒衰咒'|'显示当前技能'|'楼梯边才能楼传'|'破墙镐四方向'|'炸弹四方向'|'冰冻徽章四方向'|'铁门不需要钥匙'|'开启加点'|'开启负伤'|'仇恨怪战后扣减一半'|'夹击是否上整'|'夹击不超伤害值'|'循环计算临界'|'允许轻按'|'寻路算法不绕血瓶'|'允许走到将死领域'|'允许瞬间移动'|'允许查看禁用商店'|'阻激夹域后禁用快捷商店'|'检查控制台'
+    /*Global_Flag_List ['enableFloor','enableName','enableLv', 'enableHPMax', 'enableMana', 'enableMDef', 'enableMoney', 'enableExperience', 'enableLevelUp', 'levelUpLeftMode', 'enableKeys', 'enablePZF', 'enableDebuff', 'enableSkill', 'flyNearStair', 'pickaxeFourDirections', 'bombFourDirections', 'snowFourDirections', 'steelDoorWithoutKey', 'enableAddPoint', 'enableNegativeDamage', 'hatredDecrease', 'betweenAttackCeil', 'betweenAttackMax', 'useLoop', 'enableGentleClick', 'potionWhileRouting', 'canGoDeadZone', 'enableMoveDirectly', 'enableDisabledShop', 'disableShopOnDamage', 'checkConsole']*/;
+
+Colour
+    :   'sdeirughvuiyasdeb'+ //为了被识别为复杂词法规则
+    ;
+
+Angle
+    :   'sdeirughvuiyasdeb'+ //为了被识别为复杂词法规则
+    ;
+
+Bool:   'TRUE' 
+    |   'FALSE'
+    ;
+
+Int :   '0' | [1-9][0-9]* ; // no leading zeros
+
+Letter_List
+    :  'A'|'B'|'C'|'D'|'E'|'F'
+    /*Letter_List ['A','B','C','D','E','F']*/;
+
+
+Number
+    :   '-'? Int '.' Int EXP?   // 1.35, 1.35E-9, 0.3, -4.5
+    |   '-'? Int EXP            // 1e10 -3e4
+    |   '-'? Int                // -3, 45
+    ;
+fragment EXP : [Ee] [+\-]? Int ; // \- since - means "range" inside [...]
+
+Direction_List
+    :   '上'|'下'|'左'|'右'
+    /*Direction_List ['up','down','left','right']*/;
+
+DirectionEx_List
+    :   '不变'|'上'|'下'|'左'|'右'
+    /*DirectionEx_List ['','up','down','left','right']*/;
+
+StepString
+    :   (Direction_List Int?)+
+    ;
+
+IdString
+    :   [0-9a-zA-Z_][0-9a-zA-Z_:]*
+    ;
+
+FixedId_List
+    :   '生命'|'攻击'|'防御'|'魔防'|'黄钥匙'|'蓝钥匙'|'红钥匙'|'金币'|'经验'
+    /*FixedId_List ['status:hp','status:atk','status:def','status:mdef','item:yellowKey','item:blueKey','item:redKey','status:money','status:experience']*/;
+
+Id_List
+    :   '变量' | '状态' | '物品' | '独立开关' | '全局存储'
+    /*Id_List ['flag','status','item', 'switch', 'global']*/;
+
+//转blockly后不保留需要加"
+EvalString
+    :   Equote_double (ESC_double | ~["\\])* Equote_double
+    ;
+
+fragment ESC_double :   '\\' (["\\/bfnrt] | UNICODE) ;
+fragment UNICODE : 'u' HEX HEX HEX HEX ;
+fragment HEX : [0-9a-fA-F] ;
+
+BGNL
+    :   'BGNLaergayergfuybgv'
+    ;
+
+MeaningfulSplit : '=== meaningful ^ ===' ;
+
+fragment Equote_double : '"' ;
+
+BSTART
+    :   '开始'
+    ;
+
+BEND:   '结束'
+    ;
+
+Newline
+    :   ('\r' '\n'?| '\n')// -> skip
+    ;
+
+WhiteSpace
+    :   [ \t]+ -> skip
+    ;
+
+BlockComment
+    :   '/*' .*? '*/' -> skip
+    ;
+
+LineComment
+    :   '//' ~[\r\n]* -> skip
+    ;
+
+/* Function_0
+//this.evisitor.recieveOrder='ORDER_NONE';
+this.evisitor.valueColor=330;
+this.evisitor.statementColor=70;
+this.evisitor.entryColor=250;
+
+this.evisitor.idstring_eColor=310;
+this.evisitor.subColor=190;
+this.evisitor.printColor=70;
+this.evisitor.dataColor=130;
+this.evisitor.eventColor=220;
+this.evisitor.soundColor=20;
+this.evisitor.commentColor=285;
+this.evisitor.mapColor=175;
+*/
+
+/* Function_1
+delete(this.block('negate_e').inputsInline);
+this.block('idString_1_e').output='idString_e';
+this.block('idString_2_e').output='idString_e';
+this.block('evFlag_e').output='idString_e';
+*/
+
+/* Functions
+
+function ActionParser(){
+}
+
+ActionParser.prototype.parse = function (obj,type) {
+  switch (type) {
+    case 'event':
+      if(!obj)obj={};
+      if(typeof(obj)===typeof('')) obj={'data':[obj]};
+      if(obj instanceof Array) obj={'data':obj};
+      return MotaActionBlocks['event_m'].xmlText([
+        obj.trigger==='action',obj.enable,obj.noPass,obj.displayDamage,this.parseList(obj.data)
+      ]);
+    
+    case 'changeFloor':
+      if(!obj)obj={};
+      if(!this.isset(obj.loc)) {
+        obj.loc=[0,0];
+        if (!this.isset(obj.stair)) obj.stair='now';
+      }
+      if (obj.floorId==':before'||obj.floorId==':next') {
+        obj.floorType=obj.floorId;
+        delete obj.floorId;
+      }
+      if (!this.isset(obj.time)) obj.time=500;
+      return MotaActionBlocks['changeFloor_m'].xmlText([
+        obj.floorType||'floorId',obj.floorId,obj.stair||'loc',obj.loc[0],obj.loc[1],obj.direction,
+        obj.time,!this.isset(obj.ignoreChangeFloor)
+      ]);
+
+    case 'level':
+      if(!obj)obj={};
+      var text_choices = null;
+      for(var ii=obj.length-1,choice;choice=obj[ii];ii--) {
+        text_choices=MotaActionBlocks['levelCase'].xmlText([
+          MotaActionBlocks['evalString_e'].xmlText([choice.need]),choice.title,choice.clear||false,this.parseList(choice.action),text_choices]);
+      }
+      return MotaActionBlocks['level_m'].xmlText([text_choices]);
+
+    case 'shop':
+      var buildsub = function(obj,parser,next){
+        var text_choices = null;
+        for(var ii=obj.choices.length-1,choice;choice=obj.choices[ii];ii--) {
+          var text_effect = null;
+          var effectList = choice.effect.split(';');
+          for(var jj=effectList.length-1,effect;effect=effectList[jj];jj--) {
+            if(effect.split('+=').length!==2){
+              throw new Error('一个商店效果中必须包含恰好一个"+="');
+            }
+            text_effect=MotaActionBlocks['shopEffect'].xmlText([
+              MotaActionBlocks['idString_e'].xmlText([effect.split('+=')[0]]),
+              MotaActionBlocks['evalString_e'].xmlText([effect.split('+=')[1]]),
+              text_effect]);
+          }
+          text_choices=MotaActionBlocks['shopChoices'].xmlText([
+            choice.text,choice.need||'',text_effect,text_choices]);
+        }
+        return MotaActionBlocks['shopsub'].xmlText([
+          obj.id,obj.name,obj.icon,obj.textInList,obj.commonTimes,obj.mustEnable,obj.use,obj.need,parser.EvalString(obj.text),text_choices,next
+        ]);
+      }
+      var buildcommentevent = function(obj,parser,next){
+        if (obj.args instanceof Array) {
+          try { obj.args = JSON.stringify(obj.args).replace(/"/g, "'"); }
+          catch (e) {obj.args = '';}
+        }
+        else obj.args = null;
+        return MotaActionBlocks['shopcommonevent'].xmlText([
+          obj.id,parser.EvalString(obj.textInList),obj.mustEnable,parser.EvalString(obj.commonEvent),obj.args,next
+        ]);
+      }
+      var next=null;
+      if(!obj)obj=[];
+      while(obj.length){
+        var shopobj=obj.pop()
+        if(shopobj.choices)
+          next=buildsub(shopobj,this,next);
+        else if(shopobj.commonEvent)
+          next=buildcommentevent(shopobj,this,next);
+        else
+          throw new Error("[警告]出错啦！\n"+shopobj.id+" 无效的商店");
+      }
+      return MotaActionBlocks['shop_m'].xmlText([next]);
+    
+    default:
+      return MotaActionBlocks[type+'_m'].xmlText([this.parseList(obj)]);
+  }
+}
+
+////// 开始解析一系列自定义事件 //////
+ActionParser.prototype.parseList = function (list) {
+  if (!this.isset(list)) return MotaActionBlocks['pass_s'].xmlText([],true);
+  if (!(list instanceof Array)) {
+    list = [list];
+  }
+  if (list.length===0) return MotaActionBlocks['pass_s'].xmlText([],true);
+  this.event = {'id': 'action', 'data': {
+    'list': list
+  }}
+  this.next = null;
+  this.result = null;
+  this.parseAction();
+  return this.result;
+}
+
+////// 解析当前自定义事件列表中的最后一个事件 //////
+ActionParser.prototype.parseAction = function() {
+
+  // 事件处理完毕
+  if (this.event.data.list.length==0) {
+    this.result = this.next;
+    this.next = null;
+    return;
+  }
+
+  var data = this.event.data.list.pop();
+  this.event.data.current = data;
+
+  // 不同种类的事件
+
+  // 如果是文字：显示
+  if (typeof data == "string") {
+      data={"type": "text", "text": data}
+  }
+  this.event.data.type=data.type;
+  switch (data.type) {
+    case "_next":
+      this.result = this.next;
+      this.next = data.next;
+      return;
+    case "text": // 文字/对话
+      this.next = MotaActionBlocks['text_0_s'].xmlText([
+        this.EvalString(data.text),this.next]);
+      break;
+    case "autoText": // 自动剧情文本
+      this.next = MotaActionBlocks['autoText_s'].xmlText([
+        '','','',data.time,this.EvalString(data.text),this.next]);
+      break;
+    case "scrollText":
+      this.next = MotaActionBlocks['scrollText_s'].xmlText([
+        data.time, data.lineHeight||1.4, data.async||false, this.EvalString(data.text), this.next]);
+        break;
+    case "comment": // 注释
+      this.next = MotaActionBlocks['comment_s'].xmlText([this.EvalString(data.text),this.next],null,data.text);
+      break;
+    case "setText": // 设置剧情文本的属性
+      var setTextfunc = function(a){return a?JSON.stringify(a).slice(1,-1):null;}
+      data.title=setTextfunc(data.title);
+      data.text=setTextfunc(data.text);
+      if (!/^\w+\.png$/.test(data.background))
+        data.background=setTextfunc(data.background);
+      this.next = MotaActionBlocks['setText_s'].xmlText([
+        data.position,data.offset,data.align,data.title,'rgba('+data.title+')',
+        data.text,'rgba('+data.text+')',data.background,'rgba('+data.background+')',
+        data.bold,data.titlefont,data.textfont,data.time,this.next]);
+      break;
+    case "tip":
+      this.next = MotaActionBlocks['tip_s'].xmlText([
+        data.text,data.icon||"",this.next]);
+      break;
+    case "show": // 显示
+      data.loc=data.loc||[];
+      if (!(data.loc[0] instanceof Array))
+        data.loc = [data.loc];
+      var x_str=[],y_str=[];
+      data.loc.forEach(function (t) {
+        x_str.push(t[0]);
+        y_str.push(t[1]);
+      })
+      this.next = MotaActionBlocks['show_s'].xmlText([
+        x_str.join(','),y_str.join(','),data.floorId||'',data.time||0,data.async||false,this.next]);
+      break;
+    case "hide": // 消失
+      data.loc=data.loc||[];
+      if (!(data.loc[0] instanceof Array))
+        data.loc = [data.loc];
+      var x_str=[],y_str=[];
+      data.loc.forEach(function (t) {
+        x_str.push(t[0]);
+        y_str.push(t[1]);
+      })
+      this.next = MotaActionBlocks['hide_s'].xmlText([
+        x_str.join(','),y_str.join(','),data.floorId||'',data.time||0,data.async||false,this.next]);
+      break;
+    case "setBlock": // 设置图块
+      data.loc=data.loc||['',''];
+      this.next = MotaActionBlocks['setBlock_s'].xmlText([
+        data.number||0,data.loc[0],data.loc[1],data.floorId||'',this.next]);
+      break;
+    case "showFloorImg": // 显示贴图
+      data.loc=data.loc||[];
+      if (!(data.loc[0] instanceof Array))
+        data.loc = [data.loc];
+      var x_str=[],y_str=[];
+      data.loc.forEach(function (t) {
+        x_str.push(t[0]);
+        y_str.push(t[1]);
+      })
+      this.next = MotaActionBlocks['showFloorImg_s'].xmlText([
+        x_str.join(','),y_str.join(','),data.floorId||'',this.next]);
+      break;
+    case "hideFloorImg": // 隐藏贴图
+      data.loc=data.loc||[];
+      if (!(data.loc[0] instanceof Array))
+        data.loc = [data.loc];
+      var x_str=[],y_str=[];
+      data.loc.forEach(function (t) {
+        x_str.push(t[0]);
+        y_str.push(t[1]);
+      })
+      this.next = MotaActionBlocks['hideFloorImg_s'].xmlText([
+        x_str.join(','),y_str.join(','),data.floorId||'',this.next]);
+      break;
+    case "showBgFgMap": // 显示图层块
+      data.loc=data.loc||[];
+      if (!(data.loc[0] instanceof Array))
+        data.loc = [data.loc];
+      var x_str=[],y_str=[];
+      data.loc.forEach(function (t) {
+        x_str.push(t[0]);
+        y_str.push(t[1]);
+      })
+      this.next = MotaActionBlocks['showBgFgMap_s'].xmlText([
+        data.name||'bg', x_str.join(','),y_str.join(','),data.floorId||'',this.next]);
+      break;
+    case "hideBgFgMap": // 隐藏图层块
+      data.loc=data.loc||[];
+      if (!(data.loc[0] instanceof Array))
+        data.loc = [data.loc];
+      var x_str=[],y_str=[];
+      data.loc.forEach(function (t) {
+        x_str.push(t[0]);
+        y_str.push(t[1]);
+      })
+      this.next = MotaActionBlocks['hideBgFgMap_s'].xmlText([
+        data.name||'bg', x_str.join(','),y_str.join(','),data.floorId||'',this.next]);
+      break;
+    case "setBgFgBlock": // 设置图块
+      data.loc=data.loc||['',''];
+      this.next = MotaActionBlocks['setBgFgBlock_s'].xmlText([
+        data.name||"bg", data.number||0,data.loc[0],data.loc[1],data.floorId||'',this.next]);
+      break;
+    case "setHeroIcon": // 改变勇士
+      this.next = MotaActionBlocks['setHeroIcon_s'].xmlText([
+        data.name||"",this.next]);
+      break;
+    case "move": // 移动事件
+      data.loc=data.loc||['',''];
+      this.next = MotaActionBlocks['move_s'].xmlText([
+        data.loc[0],data.loc[1],data.time||0,data.keep||false,data.async||false,this.StepString(data.steps),this.next]);
+      break;
+    case "moveHero":
+      this.next = MotaActionBlocks['moveHero_s'].xmlText([
+        data.time||0,data.async||false,this.StepString(data.steps),this.next]);
+      break;
+    case "jump": // 跳跃事件
+      data.from=data.from||['',''];
+      data.to=data.to||['',''];
+      this.next = MotaActionBlocks['jump_s'].xmlText([
+        data.from[0],data.from[1],data.to[0],data.to[1],data.time||0,data.keep||false,data.async||false,this.next]);
+      break;
+    case "jumpHero": // 跳跃勇士
+      data.loc=data.loc||['','']
+      this.next = MotaActionBlocks['jumpHero_s'].xmlText([
+        data.loc[0],data.loc[1],data.time||0,data.async||false,this.next]);
+      break;
+    case "changeFloor": // 楼层转换
+      data.loc=data.loc||['','']
+      this.next = MotaActionBlocks['changeFloor_s'].xmlText([
+        data.floorId,data.loc[0],data.loc[1],data.direction,data.time||0,this.next]);
+      break;
+    case "changePos": // 直接更换勇士位置, 不切换楼层
+      if(this.isset(data.loc)){
+        this.next = MotaActionBlocks['changePos_0_s'].xmlText([
+          data.loc[0],data.loc[1],data.direction,this.next]);
+      } else {
+        this.next = MotaActionBlocks['changePos_1_s'].xmlText([
+          data.direction,this.next]);
+      }
+      break;
+    case "follow": // 跟随勇士
+      this.next = MotaActionBlocks['follow_s'].xmlText([data.name||"", this.next]);
+      break;
+    case "unfollow": // 取消跟随
+      this.next = MotaActionBlocks['unfollow_s'].xmlText([data.name||"", this.next]);
+      break;
+    case "animate": // 显示动画
+      var animate_loc = data.loc||'';
+      if(animate_loc && animate_loc!=='hero')animate_loc = animate_loc[0]+','+animate_loc[1];
+      this.next = MotaActionBlocks['animate_s'].xmlText([
+        data.name,animate_loc,data.async||false,this.next]);
+      break;
+    case "vibrate": // 画面震动
+      this.next = MotaActionBlocks['vibrate_s'].xmlText([data.time||0, data.async||false, this.next]);
+      break;
+    case "showImage": // 显示图片
+      data.loc=data.loc||['','']
+      if (data.sloc) {
+        this.next = MotaActionBlocks['showImage_1_s'].xmlText([
+            data.code,data.image||data.name,data.sloc[0],data.sloc[1],data.sloc[2],data.sloc[3],data.opacity,
+            data.loc[0],data.loc[1],data.loc[2],data.loc[3],data.time||0,data.async||false,this.next
+        ]);
+      }
+      else {
+        this.next = MotaActionBlocks['showImage_s'].xmlText([
+              data.code,data.image||data.name,data.loc[0],data.loc[1],data.opacity,data.time||0,data.async||false,this.next]);
+      }
+      break;
+    case "hideImage": // 清除图片
+      this.next = MotaActionBlocks['hideImage_s'].xmlText([
+        data.code,data.time||0,data.async||false,this.next]);
+      break;
+    case "showTextImage": // 显示图片化文本
+      data.loc=data.loc||['','']
+      this.next = MotaActionBlocks['showTextImage_s'].xmlText([
+        this.EvalString(data.text),data.code,data.loc[0],data.loc[1],data.lineHeight||1.4,data.opacity,data.time||0,data.async||false,this.next]);
+      break;
+    case "moveImage": // 移动图片
+      data.to=data.to||['','']
+      this.next = MotaActionBlocks['moveImage_s'].xmlText([
+        data.code, data.to[0], data.to[1], data.opacity, data.time||0, data.async||false, this.next]);
+      break;
+    case "showGif": // 显示动图
+      if(this.isset(data.name)){
+        this.next = MotaActionBlocks['showGif_0_s'].xmlText([
+          data.name,data.loc[0],data.loc[1],this.next]);
+        } else {
+          this.next = MotaActionBlocks['showGif_1_s'].xmlText([
+            this.next]);
+        }
+        break;
+    case "setFg": // 颜色渐变
+    case "setCurtain":
+      if(this.isset(data.color)){
+        this.next = MotaActionBlocks['setCurtain_0_s'].xmlText([
+          data.color,'rgba('+data.color+')',data.time||0,data.async||false,this.next]);
+      } else {
+        this.next = MotaActionBlocks['setCurtain_1_s'].xmlText([
+          data.time||0,data.async||false,this.next]);
+      }
+      break;
+    case "screenFlash": // 画面闪烁
+        this.next = MotaActionBlocks['screenFlash_s'].xmlText([
+          data.color,'rgba('+data.color+')',data.time||500,data.times||1,data.async||false,this.next]);
+      break;
+    case "setWeather": // 更改天气
+      this.next = MotaActionBlocks['setWeather_s'].xmlText([
+        data.name,data.level||1,this.next]);
+      break;
+    case "openDoor": // 开一个门, 包括暗墙
+      data.loc=data.loc||['','']
+      this.next = MotaActionBlocks['openDoor_s'].xmlText([
+        data.loc[0],data.loc[1],data.floorId||'',data.needKey||false,data.async||false,this.next]);
+      break;
+    case "closeDoor": // 关一个门，需要该点无事件
+      data.loc=data.loc||['','']
+      this.next = MotaActionBlocks['closeDoor_s'].xmlText([
+        data.loc[0],data.loc[1],data.id,data.async||false,this.next]);
+      break;
+    case "useItem": // 使用道具
+      this.next = MotaActionBlocks['useItem_s'].xmlText([
+        data.id,this.next]);
+      break;
+    case "openShop": // 打开一个全局商店
+      this.next = MotaActionBlocks['openShop_s'].xmlText([
+        data.id,this.next]);
+      break;
+    case "disableShop": // 禁用一个全局商店
+      this.next = MotaActionBlocks['disableShop_s'].xmlText([
+        data.id,this.next]);
+      break;
+    case "battle": // 强制战斗
+      if (data.id) {
+        this.next = MotaActionBlocks['battle_s'].xmlText([
+          data.id,this.next]);
+      }
+      else {
+        data.loc = data.loc || [];
+        this.next = MotaActionBlocks['battle_1_s'].xmlText([
+          data.loc[0],data.loc[1],this.next]);
+      }
+      break;
+    case "trigger": // 触发另一个事件；当前事件会被立刻结束。需要另一个地点的事件是有效的
+      this.next = MotaActionBlocks['trigger_s'].xmlText([
+        data.loc[0],data.loc[1],data.keep,this.next]);
+      break;
+    case "insert": // 强制插入另一个点的事件在当前事件列表执行，当前坐标和楼层不会改变
+      if (data.args instanceof Array) {
+        try { data.args = JSON.stringify(data.args).replace(/"/g, "'"); }
+        catch (e) {data.args = '';}
+      }
+      else data.args = null;
+      if (this.isset(data.name)) {
+        this.next = MotaActionBlocks['insert_1_s'].xmlText([
+          data.name, data.args||"", this.next]);
+      }
+      else {
+        this.next = MotaActionBlocks['insert_2_s'].xmlText([
+          data.loc[0],data.loc[1],data.which,data.floorId||'',data.args||"",this.next]);
+      }
+      break;
+    case "playSound":
+      this.next = MotaActionBlocks['playSound_s'].xmlText([
+        data.name,data.stop,this.next]);
+      break;
+    case "playBgm":
+      this.next = MotaActionBlocks['playBgm_s'].xmlText([
+        data.name,this.next]);
+      break
+    case "pauseBgm":
+      this.next = MotaActionBlocks['pauseBgm_s'].xmlText([
+        this.next]);
+      break
+    case "resumeBgm":
+      this.next = MotaActionBlocks['resumeBgm_s'].xmlText([
+        this.next]);
+      break
+    case "loadBgm":
+      this.next = MotaActionBlocks['loadBgm_s'].xmlText([
+        data.name,this.next]);
+      break
+    case "freeBgm":
+      this.next = MotaActionBlocks['freeBgm_s'].xmlText([
+        data.name,this.next]);
+      break
+    case "stopSound":
+      this.next = MotaActionBlocks['stopSound_s'].xmlText([
+        this.next]);
+      break
+    case "setVolume":
+      this.next = MotaActionBlocks['setVolume_s'].xmlText([
+        data.value, data.time||0, data.async||false, this.next]);
+      break
+    case "setValue":
+      this.next = MotaActionBlocks['setValue_s'].xmlText([
+        this.tryToUseEvFlag_e('idString_e', [data.name]),
+        MotaActionBlocks['evalString_e'].xmlText([data.value]),
+        this.next]);
+      break;
+    case "setValue2":
+    case "addValue":
+      this.next = MotaActionBlocks['addValue_s'].xmlText([
+        this.tryToUseEvFlag_e('idString_e', [data.name]),
+        MotaActionBlocks['evalString_e'].xmlText([data.value]),
+        this.next]);
+      break;
+    case "setFloor":
+      this.next = MotaActionBlocks['setFloor_s'].xmlText([
+        data.name, data.floorId||null, data.value, this.next]);
+      break;
+    case "setGlobalAttribute":
+      this.next = MotaActionBlocks['setGlobalAttribute_s'].xmlText([
+        data.name, data.value, this.next]);
+      break;
+    case "setGlobalValue":
+      this.next = MotaActionBlocks['setGlobalValue_s'].xmlText([
+        data.name, data.value, this.next]);
+      break;
+    case "setGlobalFlag":
+      this.next = MotaActionBlocks['setGlobalFlag_s'].xmlText([
+        data.name, data.value, this.next]);
+      break;
+    case "input":
+      this.next = MotaActionBlocks['input_s'].xmlText([
+        data.text,this.next]);
+      break;
+    case "input2":
+      this.next = MotaActionBlocks['input2_s'].xmlText([
+        data.text,this.next]);
+      break;
+    case "if": // 条件判断
+      if (data["false"]) {
+        this.next = MotaActionBlocks['if_s'].xmlText([
+          this.tryToUseEvFlag_e('evalString_e', [data.condition]),
+          this.insertActionList(data["true"]),
+          this.insertActionList(data["false"]),
+          this.next]);
+      }
+      else {
+        this.next = MotaActionBlocks['if_1_s'].xmlText([
+          this.tryToUseEvFlag_e('evalString_e', [data.condition]),
+          this.insertActionList(data["true"]),
+          this.next]);
+      }
+      break;
+    case "confirm": // 显示确认框
+      this.next = MotaActionBlocks['confirm_s'].xmlText([
+        this.EvalString(data.text), data["default"],
+        this.insertActionList(data["yes"]),
+        this.insertActionList(data["no"]),
+        this.next]);
+      break;
+    case "switch": // 多重条件分歧
+      var case_caseList = null;
+      for(var ii=data.caseList.length-1,caseNow;caseNow=data.caseList[ii];ii--) {
+        case_caseList=MotaActionBlocks['switchCase'].xmlText([
+          this.isset(caseNow.case)?MotaActionBlocks['evalString_e'].xmlText([caseNow.case]):"值",caseNow.nobreak,this.insertActionList(caseNow.action),case_caseList]);
+      }
+      this.next = MotaActionBlocks['switch_s'].xmlText([
+        // MotaActionBlocks['evalString_e'].xmlText([data.condition]),
+        this.tryToUseEvFlag_e('evalString_e', [data.condition]),
+        case_caseList,this.next]);
+      break;
+    case "choices": // 提供选项
+      var text_choices = null;
+      for(var ii=data.choices.length-1,choice;choice=data.choices[ii];ii--) {
+        text_choices=MotaActionBlocks['choicesContext'].xmlText([
+          choice.text,choice.icon,choice.color,'rgba('+choice.color+')',this.insertActionList(choice.action),text_choices]);
+      }
+      this.next = MotaActionBlocks['choices_s'].xmlText([
+        this.isset(data.text)?this.EvalString(data.text):null,'','',text_choices,this.next]);
+      break;
+    case "while": // 前置条件循环处理
+      this.next = MotaActionBlocks['while_s'].xmlText([
+        // MotaActionBlocks['evalString_e'].xmlText([data.condition]),
+        this.tryToUseEvFlag_e('evalString_e', [data.condition]),
+        this.insertActionList(data["data"]),
+        this.next]);
+      break;
+    case "dowhile": // 后置条件循环处理
+      this.next = MotaActionBlocks['dowhile_s'].xmlText([
+        this.insertActionList(data["data"]),
+        // MotaActionBlocks['evalString_e'].xmlText([data.condition]),
+        this.tryToUseEvFlag_e('evalString_e', [data.condition]),
+        this.next]);
+      break;
+    case "break": // 跳出循环
+      this.next = MotaActionBlocks['break_s'].xmlText([
+        this.next]);
+      break;
+    case "continue": // 继续执行当前循环
+      this.next = MotaActionBlocks['continue_s'].xmlText([
+        this.next]);
+      break;
+    case "win":
+      this.next = MotaActionBlocks['win_s'].xmlText([
+        data.reason,data.norank?true:false,this.next]);
+      break;
+    case "lose":
+      this.next = MotaActionBlocks['lose_s'].xmlText([
+        data.reason,this.next]);
+      break;
+    case "restart":
+      this.next = MotaActionBlocks['restart_s'].xmlText([
+        this.next]);
+      break;
+    case "function":
+      var func = data["function"];
+      func=func.split('{').slice(1).join('{').split('}').slice(0,-1).join('}').trim().split('\n').join('\\n');
+      this.next = MotaActionBlocks['function_s'].xmlText([
+        data.async||false,func,this.next]);
+      break;
+    case "update":
+      this.next = MotaActionBlocks['update_s'].xmlText([
+        this.next]);
+      break;
+    case "showStatusBar":
+      this.next = MotaActionBlocks['showStatusBar_s'].xmlText([
+        this.next]);
+      break;
+    case "hideStatusBar":
+      this.next = MotaActionBlocks['hideStatusBar_s'].xmlText([
+        data.toolbox||false,this.next]);
+      break;
+    case "updateEnemys":
+      this.next = MotaActionBlocks['updateEnemys_s'].xmlText([
+        this.next]);
+      break;
+    case "sleep": // 等待多少毫秒
+      this.next = MotaActionBlocks['sleep_s'].xmlText([
+        data.time||0,data.noSkip||false,this.next]);
+      break;
+    case "wait": // 等待用户操作
+      this.next = MotaActionBlocks['wait_s'].xmlText([
+        this.next]);
+      break;
+    case "waitAsync": // 等待所有异步事件执行完毕
+      this.next = MotaActionBlocks['waitAsync_s'].xmlText([
+        this.next]);
+      break;
+    case "revisit": // 立刻重新执行该事件
+      this.next = MotaActionBlocks['revisit_s'].xmlText([
+        this.next]);
+      break;
+    case "callBook": // 呼出怪物手册
+      this.next = MotaActionBlocks['callBook_s'].xmlText([
+        this.next]);
+      break;
+    case "callSave": // 呼出存档界面
+      this.next = MotaActionBlocks['callSave_s'].xmlText([
+        this.next]);
+      break;
+    case "autoSave": // 自动存档
+      this.next = MotaActionBlocks['autoSave_s'].xmlText([
+        this.next]);
+      break;
+    case "callLoad": // 呼出读档界面
+      this.next = MotaActionBlocks['callLoad_s'].xmlText([
+        this.next]);
+      break;
+    case "exit": // 立刻结束事件
+      this.next = MotaActionBlocks['exit_s'].xmlText([
+        this.next]);
+      break;
+    case "animateImage":  // 兼容 animateImage
+      break;
+    default:
+      this.next = MotaActionBlocks['unknown_s'].xmlText([
+        JSON.stringify(data),this.next]);
+  }
+  this.parseAction();
+  return;
+}
+
+////// 往当前事件列表之后添加一个事件组 //////
+ActionParser.prototype.insertActionList = function (actionList) {
+  if (actionList.length===0) return null;
+  this.event.data.list.push({"type": "_next", "next": this.next});
+  this.event.data.list=this.event.data.list.concat(actionList);
+  this.next = null;
+  this.parseAction();
+  return this.result;
+}
+
+////// 判断某对象是否不为undefined也不会null //////
+ActionParser.prototype.isset = function (val) {
+    if (val === undefined || val === null) {
+        return false;
+    }
+    return true
+}
+
+ActionParser.prototype.StepString = function(steplist) {
+  var stepchar = {
+    'up': '上',
+    'down': '下',
+    'left': '左',
+    'right': '右',
+    'forward': '前',
+    'backward': '后'
+  }
+  var StepString = [];
+  for(var ii=0,obj;obj=steplist[ii];ii++) {
+    if(typeof(obj)===typeof('')) {
+      StepString.push(stepchar[obj]);
+    } else {
+      StepString.push(stepchar[obj['direction']]);
+      StepString.push(obj['value']);
+    }
+  }
+  return StepString.join('');
+}
+
+ActionParser.prototype.EvalString = function(EvalString) {
+  return EvalString.split('\b').join('\\b').split('\t').join('\\t').split('\n').join('\\n');
+}
+
+ActionParser.prototype.tryToUseEvFlag_e = function(defaultType, args, isShadow, comment) {
+  var match=/^switch:([A-F])$/.exec(args[0])
+  if(match){
+    args[0]=match[1]
+    return MotaActionBlocks['evFlag_e'].xmlText(args, isShadow, comment);
+  }
+  return MotaActionBlocks[defaultType||'evalString_e'].xmlText(args, isShadow, comment);
+}
+
+MotaActionFunctions.actionParser = new ActionParser();
+
+MotaActionFunctions.workspace = function(){return workspace}
+
+MotaActionFunctions.parse = function(obj,type) {
+  MotaActionFunctions.workspace().clear();
+  xml_text = MotaActionFunctions.actionParser.parse(obj,type||'event');
+  xml = Blockly.Xml.textToDom('<xml>'+xml_text+'</xml>');
+  Blockly.Xml.domToWorkspace(xml, MotaActionFunctions.workspace());
+}
+
+MotaActionFunctions.EvalString_pre = function(EvalString){
+  if (EvalString.indexOf('__door__')!==-1) throw new Error('请修改开门变量__door__，如door1，door2，door3等依次向后。请勿存在两个门使用相同的开门变量。');
+  return EvalString.replace(/([^\\])"/g,'$1\\"').replace(/^"/g,'\\"').replace(/""/g,'"\\"');
+}
+
+MotaActionFunctions.IdString_pre = function(IdString){
+  if (IdString.indexOf('__door__')!==-1) throw new Error('请修改开门变量__door__，如door1，door2，door3等依次向后。请勿存在两个门使用相同的开门变量。');
+  if (IdString && !(MotaActionFunctions.pattern.id.test(IdString)) && !(MotaActionFunctions.pattern.idWithoutFlag.test(IdString)))
+      throw new Error('id: '+IdString+'中包含了0-9 a-z A-Z _ - :之外的字符');
+  return IdString;
+}
+
+MotaActionFunctions.PosString_pre = function(PosString){
+  if (!PosString || /^-?\d+$/.test(PosString)) return PosString;
+  if (!(MotaActionFunctions.pattern.id.test(PosString)))throw new Error(PosString+'中包含了0-9 a-z A-Z _ 和中文之外的字符,或者是没有以flag: 开头');
+  return '"'+PosString+'"';
+}
+
+MotaActionFunctions.StepString_pre = function(StepString){
+  //StepString='上右3下2左上左2'
+  var route = StepString.replace(/上/g,'U').replace(/下/g,'D').replace(/左/g,'L').replace(/右/g,'R').replace(/前/g,'F').replace(/后/g,'B');
+
+  //copyed from core.js
+  var ans=[], index=0;
+
+  var isset = function(a) {
+    if (a == undefined || a == null) {
+      return false;
+    }
+    return true;
+  }
+  var getNumber = function (noparse) {
+    var num="";
+    while (index<route.length && !isNaN(route.charAt(index))) {
+      num+=route.charAt(index++);
+    }
+    if (num.length==0) num="1";
+    return isset(noparse)?num:parseInt(num);
+  }
+
+  while (index<route.length) {
+    var c=route.charAt(index++);
+    var number=getNumber();
+
+    switch (c) {
+      case "U": for (var i=0;i<number;i++) ans.push("up"); break;
+      case "D": for (var i=0;i<number;i++) ans.push("down"); break;
+      case "L": for (var i=0;i<number;i++) ans.push("left"); break;
+      case "R": for (var i=0;i<number;i++) ans.push("right"); break;
+      case "F": for (var i=0;i<number;i++) ans.push("forward"); break;
+      case "B": for (var i=0;i<number;i++) ans.push("backward"); break;
+    }
+  }
+  return ans;
+}
+
+MotaActionFunctions.pattern=MotaActionFunctions.pattern||{};
+MotaActionFunctions.pattern.id=/^flag:([a-zA-Z0-9_\u4E00-\u9FCC]+)$/;
+MotaActionFunctions.pattern.id2=/^flag:([a-zA-Z0-9_\u4E00-\u9FCC]+),flag:([a-zA-Z0-9_\u4E00-\u9FCC]+)$/;
+MotaActionFunctions.pattern.idWithoutFlag=/^[0-9a-zA-Z_][0-9a-zA-Z_\-:]*$/;
+MotaActionFunctions.pattern.colorRe=/^(25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d),(25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d),(25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(,0(\.\d+)?|,1)?$/;
+
+*/
\ No newline at end of file
diff --git a/_server/README.md b/_server/README.md
index 2d6a8d08..e6a12c67 100644
--- a/_server/README.md
+++ b/_server/README.md
@@ -1,5 +1,9 @@
 # editor
 
+[重构](refactoring.md)
+
+>! 以下均是v2.0时的说明, 未及时改动
+
 本目录下所有文件,以及`../editor.html`和`../启动服务.exe`([源码](http://github.com/ckcz123/mota-js-server/))是地图编辑器的所有组件.
 
 `editor.js`,`editor_file.js`和`editor_mode.js`耦合较强,`editor_blockly.js`和`editor_multi.js`和`fs.js`基本可以独立使用.
@@ -29,7 +33,7 @@
 ``` js
 editor.mapInit();//清空地图
 editor.changeFloor('MT2')//切换地图
-editor.guid()//产生一个可以作为id的长随机字符串
+editor.util.guid()//产生一个可以作为id的长随机字符串
 ```
 
 `editor.updateMap`中画未定义快的报错
@@ -38,8 +42,6 @@ editor.guid()//产生一个可以作为id的长随机字符串
 
 提供了以下函数进行楼层`map`数组相关的操作
 ```javascript
-editor.file.getFloorFileList
-editor.file.loadFloorFile
 editor.file.saveFloorFile
 editor.file.saveFloorFileAs
 ```
@@ -70,7 +72,7 @@ editor.file.editFunctions(["change","['events']['afterChangeLight']","function(x
 生成表格并绑定事件的函数
 ```javascript
 editor.mode.loc();
-editor.mode.emenyitem();
+editor.mode.enemyitem();
 editor.mode.floor();
 editor.mode.tower();
 editor.mode.functions();
@@ -83,7 +85,7 @@ editor.mode.onmode('save');//保存
 editor.mode.onmode('nextChange');//下次onmode时前端进行切换
 
 editor.mode.onmode('loc');
-editor.mode.onmode('emenyitem');
+editor.mode.onmode('enemyitem');
 editor.mode.onmode('floor');
 editor.mode.onmode('tower');
 editor.mode.onmode('functions');
@@ -103,23 +105,6 @@ editor_mode.onmode(editor_mode._ids[node.getAttribute('id')]);
 
 `editor.mode.listen`中提供了追加素材的支持.
 
-处理注释的特殊指令
-```
-$range(evalstr:thiseval)$end
-  限制取值范围,要求修改后的eval(evalstr)为true
-$leaf(evalstr:thiseval)$end
-  强制指定为叶节点,如果eval(evalstr)为true
-
-//以下几个中选一个 [
-$select(evalstr)$end
-  渲染成<select>,选项为数组eval(evalstr)['values']
-$input(evalstr)$end
-  渲染成<input>
-$textarea(evalstr)$end
-  渲染成<textarea>
-默认选项为$textarea()$end
-// ]
-```
 
 ### editor_blockly.js
 
@@ -177,9 +162,3 @@ fs.readdir(path, callback)
 //所有参数不允许缺省
 ```
 
-## z-index
-
-目前主体部分使用了 0-15,75,100
-
-blockly使用 200,201  
-多行文本编辑器使用 300
\ No newline at end of file
diff --git a/_server/blockly/Converter.bundle.min.js b/_server/blockly/Converter.bundle.min.js
index 9e6cb177..fa99a635 100644
--- a/_server/blockly/Converter.bundle.min.js
+++ b/_server/blockly/Converter.bundle.min.js
@@ -1 +1 @@
-!function(t){var e={};function n(r){if(e[r])return e[r].exports;var i=e[r]={i:r,l:!1,exports:{}};return t[r].call(i.exports,i,i.exports,n),i.l=!0,i.exports}n.m=t,n.c=e,n.d=function(t,e,r){n.o(t,e)||Object.defineProperty(t,e,{configurable:!1,enumerable:!0,get:r})},n.n=function(t){var e=t&&t.__esModule?function(){return t.default}:function(){return t};return n.d(e,"a",e),e},n.o=function(t,e){return Object.prototype.hasOwnProperty.call(t,e)},n.p="",n(n.s=32)}([function(t,e){function n(t){return"["+t.join(", ")+"]"}function r(t,e){return t.equals(e)}function i(t){return t.hashCode()}function o(t,e){return this.data={},this.hashFunction=t||i,this.equalsFunction=e||r,this}function s(){return this.data=[],this}function a(t,e){return this.data={},this.hashFunction=t||i,this.equalsFunction=e||r,this}function l(){return this.data={},this}function u(){return this}function c(){return this.count=0,this.hash=0,this}String.prototype.seed=String.prototype.seed||Math.round(Math.random()*Math.pow(2,32)),String.prototype.hashCode=function(){var t,e,n,r,i,o,s,a,l=this.toString();for(t=3&l.length,e=l.length-t,n=String.prototype.seed,i=3432918353,o=461845907,a=0;a<e;)s=255&l.charCodeAt(a)|(255&l.charCodeAt(++a))<<8|(255&l.charCodeAt(++a))<<16|(255&l.charCodeAt(++a))<<24,++a,n=27492+(65535&(r=5*(65535&(n=(n^=s=(65535&(s=(s=(65535&s)*i+(((s>>>16)*i&65535)<<16)&4294967295)<<15|s>>>17))*o+(((s>>>16)*o&65535)<<16)&4294967295)<<13|n>>>19))+((5*(n>>>16)&65535)<<16)&4294967295))+((58964+(r>>>16)&65535)<<16);switch(s=0,t){case 3:s^=(255&l.charCodeAt(a+2))<<16;case 2:s^=(255&l.charCodeAt(a+1))<<8;case 1:n^=s=(65535&(s=(s=(65535&(s^=255&l.charCodeAt(a)))*i+(((s>>>16)*i&65535)<<16)&4294967295)<<15|s>>>17))*o+(((s>>>16)*o&65535)<<16)&4294967295}return n^=l.length,n=2246822507*(65535&(n^=n>>>16))+((2246822507*(n>>>16)&65535)<<16)&4294967295,n=3266489909*(65535&(n^=n>>>13))+((3266489909*(n>>>16)&65535)<<16)&4294967295,(n^=n>>>16)>>>0},Object.defineProperty(o.prototype,"length",{get:function(){var t=0;for(var e in this.data)0===e.indexOf("hash_")&&(t+=this.data[e].length);return t}}),o.prototype.add=function(t){var e="hash_"+this.hashFunction(t);if(e in this.data){for(var n=this.data[e],r=0;r<n.length;r++)if(this.equalsFunction(t,n[r]))return n[r];return n.push(t),t}return this.data[e]=[t],t},o.prototype.contains=function(t){return null!=this.get(t)},o.prototype.get=function(t){var e="hash_"+this.hashFunction(t);if(e in this.data)for(var n=this.data[e],r=0;r<n.length;r++)if(this.equalsFunction(t,n[r]))return n[r];return null},o.prototype.values=function(){var t=[];for(var e in this.data)0===e.indexOf("hash_")&&(t=t.concat(this.data[e]));return t},o.prototype.toString=function(){return n(this.values())},s.prototype.add=function(t){this.data[t]=!0},s.prototype.or=function(t){var e=this;Object.keys(t.data).map(function(t){e.add(t)})},s.prototype.remove=function(t){delete this.data[t]},s.prototype.contains=function(t){return!0===this.data[t]},s.prototype.values=function(){return Object.keys(this.data)},s.prototype.minValue=function(){return Math.min.apply(null,this.values())},s.prototype.hashCode=function(){var t=new c;return t.update(this.values()),t.finish()},s.prototype.equals=function(t){return t instanceof s&&this.hashCode()===t.hashCode()},Object.defineProperty(s.prototype,"length",{get:function(){return this.values().length}}),s.prototype.toString=function(){return"{"+this.values().join(", ")+"}"},Object.defineProperty(a.prototype,"length",{get:function(){var t=0;for(var e in this.data)0===e.indexOf("hash_")&&(t+=this.data[e].length);return t}}),a.prototype.put=function(t,e){var n="hash_"+this.hashFunction(t);if(n in this.data){for(var r=this.data[n],i=0;i<r.length;i++){var o=r[i];if(this.equalsFunction(t,o.key)){var s=o.value;return o.value=e,s}}return r.push({key:t,value:e}),e}return this.data[n]=[{key:t,value:e}],e},a.prototype.containsKey=function(t){var e="hash_"+this.hashFunction(t);if(e in this.data)for(var n=this.data[e],r=0;r<n.length;r++){var i=n[r];if(this.equalsFunction(t,i.key))return!0}return!1},a.prototype.get=function(t){var e="hash_"+this.hashFunction(t);if(e in this.data)for(var n=this.data[e],r=0;r<n.length;r++){var i=n[r];if(this.equalsFunction(t,i.key))return i.value}return null},a.prototype.entries=function(){var t=[];for(var e in this.data)0===e.indexOf("hash_")&&(t=t.concat(this.data[e]));return t},a.prototype.getKeys=function(){return this.entries().map(function(t){return t.key})},a.prototype.getValues=function(){return this.entries().map(function(t){return t.value})},a.prototype.toString=function(){return"["+this.entries().map(function(t){return"{"+t.key+":"+t.value+"}"}).join(", ")+"]"},l.prototype.get=function(t){return(t="k-"+t)in this.data?this.data[t]:null},l.prototype.put=function(t,e){t="k-"+t,this.data[t]=e},l.prototype.values=function(){var t=this.data;return Object.keys(this.data).map(function(e){return t[e]})},c.prototype.update=function(){for(var t=0;t<arguments.length;t++){var e=arguments[t];if(null!=e)if(Array.isArray(e))this.update.apply(e);else{var n=0;switch(typeof e){case"undefined":case"function":continue;case"number":case"boolean":n=e;break;case"string":n=e.hashCode();break;default:e.updateHashCode(this);continue}n=(n*=3432918353)<<15|n>>>17,n*=461845907,this.count=this.count+1;var r=this.hash^n;r=5*(r=r<<13|r>>>19)+3864292196,this.hash=r}}},c.prototype.finish=function(){var t=this.hash^4*this.count;return t^=t>>>16,t*=2246822507,t^=t>>>13,t*=3266489909,t^=t>>>16},u.prototype.get=function(t,e){var n=this[t]||null;return null===n?null:n[e]||null},u.prototype.set=function(t,e,n){var r=this[t]||null;null===r&&(r={},this[t]=r),r[e]=n},e.Hash=c,e.Set=o,e.Map=a,e.BitSet=s,e.AltDict=l,e.DoubleDict=u,e.hashStuff=function(){var t=new c;return t.update.apply(arguments),t.finish()},e.escapeWhitespace=function(t,e){return t=(t=(t=t.replace("\t","\\t")).replace("\n","\\n")).replace("\r","\\r"),e&&(t=t.replace(" ","·")),t},e.arrayToString=n,e.titleCase=function(t){return t.replace(/\w\S*/g,function(t){return t.charAt(0).toUpperCase()+t.substr(1)})},e.equalArrays=function(t,e){if(!Array.isArray(t)||!Array.isArray(e))return!1;if(t==e)return!0;if(t.length!=e.length)return!1;for(var n=0;n<t.length;n++)if(t[n]!=e[n]&&!t[n].equals(e[n]))return!1;return!0}},function(t,e){function n(){return this.source=null,this.type=null,this.channel=null,this.start=null,this.stop=null,this.tokenIndex=null,this.line=null,this.column=null,this._text=null,this}function r(t,e,i,o,s){return n.call(this),this.source=void 0!==t?t:r.EMPTY_SOURCE,this.type=void 0!==e?e:null,this.channel=void 0!==i?i:n.DEFAULT_CHANNEL,this.start=void 0!==o?o:-1,this.stop=void 0!==s?s:-1,this.tokenIndex=-1,null!==this.source[0]?(this.line=t[0].line,this.column=t[0].column):this.column=-1,this}n.INVALID_TYPE=0,n.EPSILON=-2,n.MIN_USER_TOKEN_TYPE=1,n.EOF=-1,n.DEFAULT_CHANNEL=0,n.HIDDEN_CHANNEL=1,Object.defineProperty(n.prototype,"text",{get:function(){return this._text},set:function(t){this._text=t}}),n.prototype.getTokenSource=function(){return this.source[0]},n.prototype.getInputStream=function(){return this.source[1]},r.prototype=Object.create(n.prototype),r.prototype.constructor=r,r.EMPTY_SOURCE=[null,null],r.prototype.clone=function(){var t=new r(this.source,this.type,this.channel,this.start,this.stop);return t.tokenIndex=this.tokenIndex,t.line=this.line,t.column=this.column,t.text=this.text,t},Object.defineProperty(r.prototype,"text",{get:function(){if(null!==this._text)return this._text;var t=this.getInputStream();if(null===t)return null;var e=t.size;return this.start<e&&this.stop<e?t.getText(this.start,this.stop):"<EOF>"},set:function(t){this._text=t}}),r.prototype.toString=function(){var t=this.text;return t=null!==t?t.replace(/\n/g,"\\n").replace(/\r/g,"\\r").replace(/\t/g,"\\t"):"<no text>","[@"+this.tokenIndex+","+this.start+":"+this.stop+"='"+t+"',<"+this.type+">"+(this.channel>0?",channel="+this.channel:"")+","+this.line+":"+this.column+"]"},e.Token=n,e.CommonToken=r},function(t,e,n){var r=n(1).Token;function i(t,e){return this.start=t,this.stop=e,this}function o(){this.intervals=null,this.readOnly=!1}i.prototype.contains=function(t){return t>=this.start&&t<this.stop},i.prototype.toString=function(){return this.start===this.stop-1?this.start.toString():this.start.toString()+".."+(this.stop-1).toString()},Object.defineProperty(i.prototype,"length",{get:function(){return this.stop-this.start}}),o.prototype.first=function(t){return null===this.intervals||0===this.intervals.length?r.INVALID_TYPE:this.intervals[0].start},o.prototype.addOne=function(t){this.addInterval(new i(t,t+1))},o.prototype.addRange=function(t,e){this.addInterval(new i(t,e+1))},o.prototype.addInterval=function(t){if(null===this.intervals)this.intervals=[],this.intervals.push(t);else{for(var e=0;e<this.intervals.length;e++){var n=this.intervals[e];if(t.stop<n.start)return void this.intervals.splice(e,0,t);if(t.stop===n.start)return void(this.intervals[e].start=t.start);if(t.start<=n.stop)return this.intervals[e]=new i(Math.min(n.start,t.start),Math.max(n.stop,t.stop)),void this.reduce(e)}this.intervals.push(t)}},o.prototype.addSet=function(t){if(null!==t.intervals)for(var e=0;e<t.intervals.length;e++){var n=t.intervals[e];this.addInterval(new i(n.start,n.stop))}return this},o.prototype.reduce=function(t){if(t<this.intervalslength-1){var e=this.intervals[t],n=this.intervals[t+1];e.stop>=n.stop?(this.intervals.pop(t+1),this.reduce(t)):e.stop>=n.start&&(this.intervals[t]=new i(e.start,n.stop),this.intervals.pop(t+1))}},o.prototype.complement=function(t,e){var n=new o;n.addInterval(new i(t,e+1));for(var r=0;r<this.intervals.length;r++)n.removeRange(this.intervals[r]);return n},o.prototype.contains=function(t){if(null===this.intervals)return!1;for(var e=0;e<this.intervals.length;e++)if(this.intervals[e].contains(t))return!0;return!1},Object.defineProperty(o.prototype,"length",{get:function(){var t=0;return this.intervals.map(function(e){t+=e.length}),t}}),o.prototype.removeRange=function(t){if(t.start===t.stop-1)this.removeOne(t.start);else if(null!==this.intervals)for(var e=0,n=0;n<this.intervals.length;n++){var r=this.intervals[e];if(t.stop<=r.start)return;if(t.start>r.start&&t.stop<r.stop){this.intervals[e]=new i(r.start,t.start);var o=new i(t.stop,r.stop);return void this.intervals.splice(e,0,o)}t.start<=r.start&&t.stop>=r.stop?(this.intervals.splice(e,1),e-=1):t.start<r.stop?this.intervals[e]=new i(r.start,t.start):t.stop<r.stop&&(this.intervals[e]=new i(t.stop,r.stop)),e+=1}},o.prototype.removeOne=function(t){if(null!==this.intervals)for(var e=0;e<this.intervals.length;e++){var n=this.intervals[e];if(t<n.start)return;if(t===n.start&&t===n.stop-1)return void this.intervals.splice(e,1);if(t===n.start)return void(this.intervals[e]=new i(n.start+1,n.stop));if(t===n.stop-1)return void(this.intervals[e]=new i(n.start,n.stop-1));if(t<n.stop-1){var r=new i(n.start,t);return n.start=t+1,void this.intervals.splice(e,0,r)}}},o.prototype.toString=function(t,e,n){return t=t||null,e=e||null,n=n||!1,null===this.intervals?"{}":null!==t||null!==e?this.toTokenString(t,e):n?this.toCharString():this.toIndexString()},o.prototype.toCharString=function(){for(var t=[],e=0;e<this.intervals.length;e++){var n=this.intervals[e];n.stop===n.start+1?n.start===r.EOF?t.push("<EOF>"):t.push("'"+String.fromCharCode(n.start)+"'"):t.push("'"+String.fromCharCode(n.start)+"'..'"+String.fromCharCode(n.stop-1)+"'")}return t.length>1?"{"+t.join(", ")+"}":t[0]},o.prototype.toIndexString=function(){for(var t=[],e=0;e<this.intervals.length;e++){var n=this.intervals[e];n.stop===n.start+1?n.start===r.EOF?t.push("<EOF>"):t.push(n.start.toString()):t.push(n.start.toString()+".."+(n.stop-1).toString())}return t.length>1?"{"+t.join(", ")+"}":t[0]},o.prototype.toTokenString=function(t,e){for(var n=[],r=0;r<this.intervals.length;r++)for(var i=this.intervals[r],o=i.start;o<i.stop;o++)n.push(this.elementName(t,e,o));return n.length>1?"{"+n.join(", ")+"}":n[0]},o.prototype.elementName=function(t,e,n){return n===r.EOF?"<EOF>":n===r.EPSILON?"<EPSILON>":t[n]||e[n]},e.Interval=i,e.IntervalSet=o},function(t,e){function n(){return this.atn=null,this.stateNumber=n.INVALID_STATE_NUMBER,this.stateType=null,this.ruleIndex=0,this.epsilonOnlyTransitions=!1,this.transitions=[],this.nextTokenWithinRule=null,this}function r(){return n.call(this),this.stateType=n.BASIC,this}function i(){return n.call(this),this.decision=-1,this.nonGreedy=!1,this}function o(){return i.call(this),this.endState=null,this}function s(){return o.call(this),this.stateType=n.BLOCK_START,this}function a(){return n.call(this),this.stateType=n.BLOCK_END,this.startState=null,this}function l(){return n.call(this),this.stateType=n.RULE_STOP,this}function u(){return n.call(this),this.stateType=n.RULE_START,this.stopState=null,this.isPrecedenceRule=!1,this}function c(){return i.call(this),this.stateType=n.PLUS_LOOP_BACK,this}function h(){return o.call(this),this.stateType=n.PLUS_BLOCK_START,this.loopBackState=null,this}function p(){return o.call(this),this.stateType=n.STAR_BLOCK_START,this}function f(){return n.call(this),this.stateType=n.STAR_LOOP_BACK,this}function d(){return i.call(this),this.stateType=n.STAR_LOOP_ENTRY,this.loopBackState=null,this.isPrecedenceDecision=null,this}function y(){return n.call(this),this.stateType=n.LOOP_END,this.loopBackState=null,this}function g(){return i.call(this),this.stateType=n.TOKEN_START,this}n.INVALID_TYPE=0,n.BASIC=1,n.RULE_START=2,n.BLOCK_START=3,n.PLUS_BLOCK_START=4,n.STAR_BLOCK_START=5,n.TOKEN_START=6,n.RULE_STOP=7,n.BLOCK_END=8,n.STAR_LOOP_BACK=9,n.STAR_LOOP_ENTRY=10,n.PLUS_LOOP_BACK=11,n.LOOP_END=12,n.serializationNames=["INVALID","BASIC","RULE_START","BLOCK_START","PLUS_BLOCK_START","STAR_BLOCK_START","TOKEN_START","RULE_STOP","BLOCK_END","STAR_LOOP_BACK","STAR_LOOP_ENTRY","PLUS_LOOP_BACK","LOOP_END"],n.INVALID_STATE_NUMBER=-1,n.prototype.toString=function(){return this.stateNumber},n.prototype.equals=function(t){return t instanceof n&&this.stateNumber===t.stateNumber},n.prototype.isNonGreedyExitState=function(){return!1},n.prototype.addTransition=function(t,e){void 0===e&&(e=-1),0===this.transitions.length?this.epsilonOnlyTransitions=t.isEpsilon:this.epsilonOnlyTransitions!==t.isEpsilon&&(this.epsilonOnlyTransitions=!1),-1===e?this.transitions.push(t):this.transitions.splice(e,1,t)},r.prototype=Object.create(n.prototype),r.prototype.constructor=r,i.prototype=Object.create(n.prototype),i.prototype.constructor=i,o.prototype=Object.create(i.prototype),o.prototype.constructor=o,s.prototype=Object.create(o.prototype),s.prototype.constructor=s,a.prototype=Object.create(n.prototype),a.prototype.constructor=a,l.prototype=Object.create(n.prototype),l.prototype.constructor=l,u.prototype=Object.create(n.prototype),u.prototype.constructor=u,c.prototype=Object.create(i.prototype),c.prototype.constructor=c,h.prototype=Object.create(o.prototype),h.prototype.constructor=h,p.prototype=Object.create(o.prototype),p.prototype.constructor=p,f.prototype=Object.create(n.prototype),f.prototype.constructor=f,d.prototype=Object.create(i.prototype),d.prototype.constructor=d,y.prototype=Object.create(n.prototype),y.prototype.constructor=y,g.prototype=Object.create(i.prototype),g.prototype.constructor=g,e.ATNState=n,e.BasicState=r,e.DecisionState=i,e.BlockStartState=o,e.BlockEndState=a,e.LoopEndState=y,e.RuleStartState=u,e.RuleStopState=l,e.TokensStartState=g,e.PlusLoopbackState=c,e.StarLoopbackState=f,e.StarLoopEntryState=d,e.PlusBlockStartState=h,e.StarBlockStartState=p,e.BasicBlockStartState=s},function(t,e,n){var r=n(1).Token,i=n(2).Interval,o=new i(-1,-2);n(0);function s(){return this}function a(){return s.call(this),this}function l(){return a.call(this),this}function u(){return l.call(this),this}function c(){return l.call(this),this}function h(){return c.call(this),this}function p(){return this}function f(){return this}function d(t){return c.call(this),this.parentCtx=null,this.symbol=t,this}function y(t){return d.call(this,t),this}function g(){return this}a.prototype=Object.create(s.prototype),a.prototype.constructor=a,l.prototype=Object.create(a.prototype),l.prototype.constructor=l,u.prototype=Object.create(l.prototype),u.prototype.constructor=u,c.prototype=Object.create(l.prototype),c.prototype.constructor=c,h.prototype=Object.create(c.prototype),h.prototype.constructor=h,p.prototype.visit=function(t){return Array.isArray(t)?t.map(function(t){return t.accept(this)},this):t.accept(this)},p.prototype.visitChildren=function(t){return this.visit(t.children)},p.prototype.visitTerminal=function(t){},p.prototype.visitErrorNode=function(t){},f.prototype.visitTerminal=function(t){},f.prototype.visitErrorNode=function(t){},f.prototype.enterEveryRule=function(t){},f.prototype.exitEveryRule=function(t){},d.prototype=Object.create(c.prototype),d.prototype.constructor=d,d.prototype.getChild=function(t){return null},d.prototype.getSymbol=function(){return this.symbol},d.prototype.getParent=function(){return this.parentCtx},d.prototype.getPayload=function(){return this.symbol},d.prototype.getSourceInterval=function(){if(null===this.symbol)return o;var t=this.symbol.tokenIndex;return new i(t,t)},d.prototype.getChildCount=function(){return 0},d.prototype.accept=function(t){return t.visitTerminal(this)},d.prototype.getText=function(){return this.symbol.text},d.prototype.toString=function(){return this.symbol.type===r.EOF?"<EOF>":this.symbol.text},y.prototype=Object.create(d.prototype),y.prototype.constructor=y,y.prototype.isErrorNode=function(){return!0},y.prototype.accept=function(t){return t.visitErrorNode(this)},g.prototype.walk=function(t,e){if(e instanceof h||void 0!==e.isErrorNode&&e.isErrorNode())t.visitErrorNode(e);else if(e instanceof c)t.visitTerminal(e);else{this.enterRule(t,e);for(var n=0;n<e.getChildCount();n++){var r=e.getChild(n);this.walk(t,r)}this.exitRule(t,e)}},g.prototype.enterRule=function(t,e){var n=e.getRuleContext();t.enterEveryRule(n),n.enterRule(t)},g.prototype.exitRule=function(t,e){var n=e.getRuleContext();n.exitRule(t),t.exitEveryRule(n)},g.DEFAULT=new g,e.RuleNode=u,e.ErrorNode=h,e.TerminalNode=c,e.ErrorNodeImpl=y,e.TerminalNodeImpl=d,e.ParseTreeListener=f,e.ParseTreeVisitor=p,e.ParseTreeWalker=g,e.INVALID_INTERVAL=o},function(t,e,n){var r=n(8).PredicateTransition;function i(t){if(Error.call(this),Error.captureStackTrace)Error.captureStackTrace(this,i);else(new Error).stack;return this.message=t.message,this.recognizer=t.recognizer,this.input=t.input,this.ctx=t.ctx,this.offendingToken=null,this.offendingState=-1,null!==this.recognizer&&(this.offendingState=this.recognizer.state),this}function o(t,e,n,r){return i.call(this,{message:"",recognizer:t,input:e,ctx:null}),this.startIndex=n,this.deadEndConfigs=r,this}function s(t,e,n,r,o,s){s=s||t._ctx,r=r||t.getCurrentToken(),n=n||t.getCurrentToken(),e=e||t.getInputStream(),i.call(this,{message:"",recognizer:t,input:e,ctx:s}),this.deadEndConfigs=o,this.startToken=n,this.offendingToken=r}function a(t){i.call(this,{message:"",recognizer:t,input:t.getInputStream(),ctx:t._ctx}),this.offendingToken=t.getCurrentToken()}function l(t,e,n){i.call(this,{message:this.formatMessage(e,n||null),recognizer:t,input:t.getInputStream(),ctx:t._ctx});var o=t._interp.atn.states[t.state].transitions[0];return o instanceof r?(this.ruleIndex=o.ruleIndex,this.predicateIndex=o.predIndex):(this.ruleIndex=0,this.predicateIndex=0),this.predicate=e,this.offendingToken=t.getCurrentToken(),this}function u(){return Error.call(this),Error.captureStackTrace(this,u),this}i.prototype=Object.create(Error.prototype),i.prototype.constructor=i,i.prototype.getExpectedTokens=function(){return null!==this.recognizer?this.recognizer.atn.getExpectedTokens(this.offendingState,this.ctx):null},i.prototype.toString=function(){return this.message},o.prototype=Object.create(i.prototype),o.prototype.constructor=o,o.prototype.toString=function(){var t="";return this.startIndex>=0&&this.startIndex<this.input.size&&(t=this.input.getText((this.startIndex,this.startIndex))),"LexerNoViableAltException"+t},s.prototype=Object.create(i.prototype),s.prototype.constructor=s,a.prototype=Object.create(i.prototype),a.prototype.constructor=a,l.prototype=Object.create(i.prototype),l.prototype.constructor=l,l.prototype.formatMessage=function(t,e){return null!==e?e:"failed predicate: {"+t+"}?"},u.prototype=Object.create(Error.prototype),u.prototype.constructor=u,e.RecognitionException=i,e.NoViableAltException=s,e.LexerNoViableAltException=o,e.InputMismatchException=a,e.FailedPredicateException=l,e.ParseCancellationException=u},function(t,e,n){var r=n(14).RuleContext,i=n(0).Hash;function o(t){this.cachedHashCode=t}function s(){return this.cache={},this}function a(t,e){var n=0;if(null!==t){var r=new i;r.update(t,e),n=r.finish()}o.call(this,n),this.parentCtx=t,this.returnState=e}function l(){return a.call(this,null,o.EMPTY_RETURN_STATE),this}function u(t,e){var n=new i;n.update(t,e);var r=n.finish();return o.call(this,r),this.parents=t,this.returnStates=e,this}function c(t,e,n,r){if(t===e)return t;if(t instanceof a&&e instanceof a)return function(t,e,n,r){if(null!==r){var i=r.get(t,e);if(null!==i)return i;if(null!==(i=r.get(e,t)))return i}var s=function(t,e,n){if(n){if(t===o.EMPTY)return o.EMPTY;if(e===o.EMPTY)return o.EMPTY}else{if(t===o.EMPTY&&e===o.EMPTY)return o.EMPTY;if(t===o.EMPTY){var r=[e.returnState,o.EMPTY_RETURN_STATE],i=[e.parentCtx,null];return new u(i,r)}if(e===o.EMPTY){var r=[t.returnState,o.EMPTY_RETURN_STATE],i=[t.parentCtx,null];return new u(i,r)}}return null}(t,e,n);if(null!==s)return null!==r&&r.set(t,e,s),s;if(t.returnState===e.returnState){var l=c(t.parentCtx,e.parentCtx,n,r);if(l===t.parentCtx)return t;if(l===e.parentCtx)return e;var h=a.create(l,t.returnState);return null!==r&&r.set(t,e,h),h}var p=null;if((t===e||null!==t.parentCtx&&t.parentCtx===e.parentCtx)&&(p=t.parentCtx),null!==p){var f=[t.returnState,e.returnState];t.returnState>e.returnState&&(f[0]=e.returnState,f[1]=t.returnState);var d=[p,p],y=new u(d,f);return null!==r&&r.set(t,e,y),y}var f=[t.returnState,e.returnState],d=[t.parentCtx,e.parentCtx];t.returnState>e.returnState&&(f[0]=e.returnState,f[1]=t.returnState,d=[e.parentCtx,t.parentCtx]);var g=new u(d,f);return null!==r&&r.set(t,e,g),g}(t,e,n,r);if(n){if(t instanceof l)return t;if(e instanceof l)return e}return t instanceof a&&(t=new u([t.getParent()],[t.returnState])),e instanceof a&&(e=new u([e.getParent()],[e.returnState])),function(t,e,n,r){if(null!==r){var i=r.get(t,e);if(null!==i)return i;if(null!==(i=r.get(e,t)))return i}var s=0,l=0,h=0,p=[],f=[];for(;s<t.returnStates.length&&l<e.returnStates.length;){var d=t.parents[s],y=e.parents[l];if(t.returnStates[s]===e.returnStates[l]){var g=t.returnStates[s],v=g===o.EMPTY_RETURN_STATE&&null===d&&null===y,x=null!==d&&null!==y&&d===y;if(v||x)f[h]=d,p[h]=g;else{var m=c(d,y,n,r);f[h]=m,p[h]=g}s+=1,l+=1}else t.returnStates[s]<e.returnStates[l]?(f[h]=d,p[h]=t.returnStates[s],s+=1):(f[h]=y,p[h]=e.returnStates[l],l+=1);h+=1}if(s<t.returnStates.length)for(var _=s;_<t.returnStates.length;_++)f[h]=t.parents[_],p[h]=t.returnStates[_],h+=1;else for(var _=l;_<e.returnStates.length;_++)f[h]=e.parents[_],p[h]=e.returnStates[_],h+=1;if(h<f.length){if(1===h){var T=a.create(f[0],p[0]);return null!==r&&r.set(t,e,T),T}f=f.slice(0,h),p=p.slice(0,h)}var S=new u(f,p);if(S===t)return null!==r&&r.set(t,e,t),t;if(S===e)return null!==r&&r.set(t,e,e),e;(function(t){for(var e={},n=0;n<t.length;n++){var r=t[n];r in e||(e[r]=r)}for(var i=0;i<t.length;i++)t[i]=e[t[i]]})(f),null!==r&&r.set(t,e,S);return S}(t,e,n,r)}o.EMPTY=null,o.EMPTY_RETURN_STATE=2147483647,o.globalNodeCount=1,o.id=o.globalNodeCount,o.prototype.isEmpty=function(){return this===o.EMPTY},o.prototype.hasEmptyPath=function(){return this.getReturnState(this.length-1)===o.EMPTY_RETURN_STATE},o.prototype.hashCode=function(){return this.cachedHashCode},o.prototype.updateHashCode=function(t){t.update(this.cachedHashCode)},s.prototype.add=function(t){if(t===o.EMPTY)return o.EMPTY;var e=this.cache[t]||null;return null!==e?e:(this.cache[t]=t,t)},s.prototype.get=function(t){return this.cache[t]||null},Object.defineProperty(s.prototype,"length",{get:function(){return this.cache.length}}),a.prototype=Object.create(o.prototype),a.prototype.contructor=a,a.create=function(t,e){return e===o.EMPTY_RETURN_STATE&&null===t?o.EMPTY:new a(t,e)},Object.defineProperty(a.prototype,"length",{get:function(){return 1}}),a.prototype.getParent=function(t){return this.parentCtx},a.prototype.getReturnState=function(t){return this.returnState},a.prototype.equals=function(t){return this===t||t instanceof a&&(this.hashCode()===t.hashCode()&&(this.returnState===t.returnState&&(null==this.parentCtx?null==t.parentCtx:this.parentCtx.equals(t.parentCtx))))},a.prototype.toString=function(){var t=null===this.parentCtx?"":this.parentCtx.toString();return 0===t.length?this.returnState===o.EMPTY_RETURN_STATE?"$":""+this.returnState:this.returnState+" "+t},l.prototype=Object.create(a.prototype),l.prototype.constructor=l,l.prototype.isEmpty=function(){return!0},l.prototype.getParent=function(t){return null},l.prototype.getReturnState=function(t){return this.returnState},l.prototype.equals=function(t){return this===t},l.prototype.toString=function(){return"$"},o.EMPTY=new l,u.prototype=Object.create(o.prototype),u.prototype.constructor=u,u.prototype.isEmpty=function(){return this.returnStates[0]===o.EMPTY_RETURN_STATE},Object.defineProperty(u.prototype,"length",{get:function(){return this.returnStates.length}}),u.prototype.getParent=function(t){return this.parents[t]},u.prototype.getReturnState=function(t){return this.returnStates[t]},u.prototype.equals=function(t){return this===t||t instanceof u&&(this.hashCode()===t.hashCode()&&(this.returnStates===t.returnStates&&this.parents===t.parents))},u.prototype.toString=function(){if(this.isEmpty())return"[]";for(var t="[",e=0;e<this.returnStates.length;e++)e>0&&(t+=", "),this.returnStates[e]!==o.EMPTY_RETURN_STATE?(t+=this.returnStates[e],null!==this.parents[e]?t=t+" "+this.parents[e]:t+="null"):t+="$";return t+"]"},e.merge=c,e.PredictionContext=o,e.PredictionContextCache=s,e.SingletonPredictionContext=a,e.predictionContextFromRuleContext=function t(e,n){if(void 0!==n&&null!==n||(n=r.EMPTY),null===n.parentCtx||n===r.EMPTY)return o.EMPTY;var i=t(e,n.parentCtx),s=e.states[n.invokingState].transitions[0];return a.create(i,s.followState.stateNumber)},e.getCachedPredictionContext=function t(e,n,r){if(e.isEmpty())return e;var i=r[e]||null;if(null!==i)return i;if(null!==(i=n.get(e)))return r[e]=i,i;for(var s=!1,l=[],c=0;c<l.length;c++){var h=t(e.getParent(c),n,r);if(s||h!==e.getParent(c)){if(!s){l=[];for(var p=0;p<e.length;p++)l[p]=e.getParent(p);s=!0}l[c]=h}}if(!s)return n.add(e),r[e]=e,e;var f=null;return f=0===l.length?o.EMPTY:1===l.length?a.create(l[0],e.getReturnState(0)):new u(l,e.returnStates),n.add(f),r[f]=f,r[e]=f,f}},function(t,e,n){var r=n(35).LL1Analyzer,i=n(2).IntervalSet;function o(t,e){return this.grammarType=t,this.maxTokenType=e,this.states=[],this.decisionToState=[],this.ruleToStartState=[],this.ruleToStopState=null,this.modeNameToStartState={},this.ruleToTokenType=null,this.lexerActions=null,this.modeToStartState=[],this}o.prototype.nextTokensInContext=function(t,e){return new r(this).LOOK(t,null,e)},o.prototype.nextTokensNoContext=function(t){return null!==t.nextTokenWithinRule?t.nextTokenWithinRule:(t.nextTokenWithinRule=this.nextTokensInContext(t,null),t.nextTokenWithinRule.readOnly=!0,t.nextTokenWithinRule)},o.prototype.nextTokens=function(t,e){return void 0===e?this.nextTokensNoContext(t):this.nextTokensInContext(t,e)},o.prototype.addState=function(t){null!==t&&(t.atn=this,t.stateNumber=this.states.length),this.states.push(t)},o.prototype.removeState=function(t){this.states[t.stateNumber]=null},o.prototype.defineDecisionState=function(t){return this.decisionToState.push(t),t.decision=this.decisionToState.length-1,t.decision},o.prototype.getDecisionState=function(t){return 0===this.decisionToState.length?null:this.decisionToState[t]};var s=n(1).Token;o.prototype.getExpectedTokens=function(t,e){if(t<0||t>=this.states.length)throw"Invalid state number.";var n=this.states[t],r=this.nextTokens(n);if(!r.contains(s.EPSILON))return r;var o=new i;for(o.addSet(r),o.removeOne(s.EPSILON);null!==e&&e.invokingState>=0&&r.contains(s.EPSILON);){var a=this.states[e.invokingState].transitions[0];r=this.nextTokens(a.followState),o.addSet(r),o.removeOne(s.EPSILON),e=e.parentCtx}return r.contains(s.EPSILON)&&o.addOne(s.EOF),o},o.INVALID_ALT_NUMBER=0,e.ATN=o},function(t,e,n){var r=n(1).Token,i=(n(2).Interval,n(2).IntervalSet),o=n(10).Predicate,s=n(10).PrecedencePredicate;function a(t){if(void 0===t||null===t)throw"target cannot be null.";return this.target=t,this.isEpsilon=!1,this.label=null,this}function l(t,e){return a.call(this,t),this.label_=e,this.label=this.makeLabel(),this.serializationType=a.ATOM,this}function u(t,e,n,r){return a.call(this,t),this.ruleIndex=e,this.precedence=n,this.followState=r,this.serializationType=a.RULE,this.isEpsilon=!0,this}function c(t,e){return a.call(this,t),this.serializationType=a.EPSILON,this.isEpsilon=!0,this.outermostPrecedenceReturn=e,this}function h(t,e,n){return a.call(this,t),this.serializationType=a.RANGE,this.start=e,this.stop=n,this.label=this.makeLabel(),this}function p(t){return a.call(this,t),this}function f(t,e,n,r){return p.call(this,t),this.serializationType=a.PREDICATE,this.ruleIndex=e,this.predIndex=n,this.isCtxDependent=r,this.isEpsilon=!0,this}function d(t,e,n,r){return a.call(this,t),this.serializationType=a.ACTION,this.ruleIndex=e,this.actionIndex=void 0===n?-1:n,this.isCtxDependent=void 0!==r&&r,this.isEpsilon=!0,this}function y(t,e){return a.call(this,t),this.serializationType=a.SET,void 0!==e&&null!==e?this.label=e:(this.label=new i,this.label.addOne(r.INVALID_TYPE)),this}function g(t,e){return y.call(this,t,e),this.serializationType=a.NOT_SET,this}function v(t){return a.call(this,t),this.serializationType=a.WILDCARD,this}function x(t,e){return p.call(this,t),this.serializationType=a.PRECEDENCE,this.precedence=e,this.isEpsilon=!0,this}a.EPSILON=1,a.RANGE=2,a.RULE=3,a.PREDICATE=4,a.ATOM=5,a.ACTION=6,a.SET=7,a.NOT_SET=8,a.WILDCARD=9,a.PRECEDENCE=10,a.serializationNames=["INVALID","EPSILON","RANGE","RULE","PREDICATE","ATOM","ACTION","SET","NOT_SET","WILDCARD","PRECEDENCE"],a.serializationTypes={EpsilonTransition:a.EPSILON,RangeTransition:a.RANGE,RuleTransition:a.RULE,PredicateTransition:a.PREDICATE,AtomTransition:a.ATOM,ActionTransition:a.ACTION,SetTransition:a.SET,NotSetTransition:a.NOT_SET,WildcardTransition:a.WILDCARD,PrecedencePredicateTransition:a.PRECEDENCE},l.prototype=Object.create(a.prototype),l.prototype.constructor=l,l.prototype.makeLabel=function(){var t=new i;return t.addOne(this.label_),t},l.prototype.matches=function(t,e,n){return this.label_===t},l.prototype.toString=function(){return this.label_},u.prototype=Object.create(a.prototype),u.prototype.constructor=u,u.prototype.matches=function(t,e,n){return!1},c.prototype=Object.create(a.prototype),c.prototype.constructor=c,c.prototype.matches=function(t,e,n){return!1},c.prototype.toString=function(){return"epsilon"},h.prototype=Object.create(a.prototype),h.prototype.constructor=h,h.prototype.makeLabel=function(){var t=new i;return t.addRange(this.start,this.stop),t},h.prototype.matches=function(t,e,n){return t>=this.start&&t<=this.stop},h.prototype.toString=function(){return"'"+String.fromCharCode(this.start)+"'..'"+String.fromCharCode(this.stop)+"'"},p.prototype=Object.create(a.prototype),p.prototype.constructor=p,f.prototype=Object.create(p.prototype),f.prototype.constructor=f,f.prototype.matches=function(t,e,n){return!1},f.prototype.getPredicate=function(){return new o(this.ruleIndex,this.predIndex,this.isCtxDependent)},f.prototype.toString=function(){return"pred_"+this.ruleIndex+":"+this.predIndex},d.prototype=Object.create(a.prototype),d.prototype.constructor=d,d.prototype.matches=function(t,e,n){return!1},d.prototype.toString=function(){return"action_"+this.ruleIndex+":"+this.actionIndex},y.prototype=Object.create(a.prototype),y.prototype.constructor=y,y.prototype.matches=function(t,e,n){return this.label.contains(t)},y.prototype.toString=function(){return this.label.toString()},g.prototype=Object.create(y.prototype),g.prototype.constructor=g,g.prototype.matches=function(t,e,n){return t>=e&&t<=n&&!y.prototype.matches.call(this,t,e,n)},g.prototype.toString=function(){return"~"+y.prototype.toString.call(this)},v.prototype=Object.create(a.prototype),v.prototype.constructor=v,v.prototype.matches=function(t,e,n){return t>=e&&t<=n},v.prototype.toString=function(){return"."},x.prototype=Object.create(p.prototype),x.prototype.constructor=x,x.prototype.matches=function(t,e,n){return!1},x.prototype.getPredicate=function(){return new s(this.precedence)},x.prototype.toString=function(){return this.precedence+" >= _p"},e.Transition=a,e.AtomTransition=l,e.SetTransition=y,e.NotSetTransition=g,e.RuleTransition=u,e.ActionTransition=d,e.EpsilonTransition=c,e.RangeTransition=h,e.WildcardTransition=v,e.PredicateTransition=f,e.PrecedencePredicateTransition=x,e.AbstractPredicateTransition=p},function(t,e,n){var r=n(7).ATN,i=n(0),o=i.Hash,s=i.Set,a=n(10).SemanticContext,l=n(6).merge;function u(t){return t.hashCodeForConfigSet()}function c(t,e){return t===e||null!==t&&null!==e&&t.equalsForConfigSet(e)}function h(t){return this.configLookup=new s(u,c),this.fullCtx=void 0===t||t,this.readOnly=!1,this.configs=[],this.uniqueAlt=0,this.conflictingAlts=null,this.hasSemanticContext=!1,this.dipsIntoOuterContext=!1,this.cachedHashCode=-1,this}function p(){return h.call(this),this.configLookup=new s,this}h.prototype.add=function(t,e){if(void 0===e&&(e=null),this.readOnly)throw"This set is readonly";t.semanticContext!==a.NONE&&(this.hasSemanticContext=!0),t.reachesIntoOuterContext>0&&(this.dipsIntoOuterContext=!0);var n=this.configLookup.add(t);if(n===t)return this.cachedHashCode=-1,this.configs.push(t),!0;var r=!this.fullCtx,i=l(n.context,t.context,r,e);return n.reachesIntoOuterContext=Math.max(n.reachesIntoOuterContext,t.reachesIntoOuterContext),t.precedenceFilterSuppressed&&(n.precedenceFilterSuppressed=!0),n.context=i,!0},h.prototype.getStates=function(){for(var t=new s,e=0;e<this.configs.length;e++)t.add(this.configs[e].state);return t},h.prototype.getPredicates=function(){for(var t=[],e=0;e<this.configs.length;e++){var n=this.configs[e].semanticContext;n!==a.NONE&&t.push(n.semanticContext)}return t},Object.defineProperty(h.prototype,"items",{get:function(){return this.configs}}),h.prototype.optimizeConfigs=function(t){if(this.readOnly)throw"This set is readonly";if(0!==this.configLookup.length)for(var e=0;e<this.configs.length;e++){var n=this.configs[e];n.context=t.getCachedContext(n.context)}},h.prototype.addAll=function(t){for(var e=0;e<t.length;e++)this.add(t[e]);return!1},h.prototype.equals=function(t){return this===t||t instanceof h&&i.equalArrays(this.configs,t.configs)&&this.fullCtx===t.fullCtx&&this.uniqueAlt===t.uniqueAlt&&this.conflictingAlts===t.conflictingAlts&&this.hasSemanticContext===t.hasSemanticContext&&this.dipsIntoOuterContext===t.dipsIntoOuterContext},h.prototype.hashCode=function(){var t=new o;return this.updateHashCode(t),t.finish()},h.prototype.updateHashCode=function(t){if(this.readOnly){if(-1===this.cachedHashCode)(t=new o).update(this.configs),this.cachedHashCode=t.finish();t.update(this.cachedHashCode)}else t.update(this.configs)},Object.defineProperty(h.prototype,"length",{get:function(){return this.configs.length}}),h.prototype.isEmpty=function(){return 0===this.configs.length},h.prototype.contains=function(t){if(null===this.configLookup)throw"This method is not implemented for readonly sets.";return this.configLookup.contains(t)},h.prototype.containsFast=function(t){if(null===this.configLookup)throw"This method is not implemented for readonly sets.";return this.configLookup.containsFast(t)},h.prototype.clear=function(){if(this.readOnly)throw"This set is readonly";this.configs=[],this.cachedHashCode=-1,this.configLookup=new s},h.prototype.setReadonly=function(t){this.readOnly=t,t&&(this.configLookup=null)},h.prototype.toString=function(){return i.arrayToString(this.configs)+(this.hasSemanticContext?",hasSemanticContext="+this.hasSemanticContext:"")+(this.uniqueAlt!==r.INVALID_ALT_NUMBER?",uniqueAlt="+this.uniqueAlt:"")+(null!==this.conflictingAlts?",conflictingAlts="+this.conflictingAlts:"")+(this.dipsIntoOuterContext?",dipsIntoOuterContext":"")},p.prototype=Object.create(h.prototype),p.prototype.constructor=p,e.ATNConfigSet=h,e.OrderedATNConfigSet=p},function(t,e,n){var r=n(0).Set,i=n(0).Hash;function o(){return this}function s(t,e,n){return o.call(this),this.ruleIndex=void 0===t?-1:t,this.predIndex=void 0===e?-1:e,this.isCtxDependent=void 0!==n&&n,this}function a(t){o.call(this),this.precedence=void 0===t?0:t}function l(t,e){o.call(this);var n=new r;t instanceof l?t.opnds.map(function(t){n.add(t)}):n.add(t),e instanceof l?e.opnds.map(function(t){n.add(t)}):n.add(e);var i=a.filterPrecedencePredicates(n);if(i.length>0){var s=null;i.map(function(t){(null===s||t.precedence<s.precedence)&&(s=t)}),n.add(s)}return this.opnds=n.values(),this}function u(t,e){o.call(this);var n=new r;t instanceof u?t.opnds.map(function(t){n.add(t)}):n.add(t),e instanceof u?e.opnds.map(function(t){n.add(t)}):n.add(e);var i=a.filterPrecedencePredicates(n);if(i.length>0){var s=i.sort(function(t,e){return t.compareTo(e)}),l=s[s.length-1];n.add(l)}return this.opnds=n.values(),this}o.prototype.hashCode=function(){var t=new i;return this.updateHashCode(t),t.finish()},o.prototype.evaluate=function(t,e){},o.prototype.evalPrecedence=function(t,e){return this},o.andContext=function(t,e){if(null===t||t===o.NONE)return e;if(null===e||e===o.NONE)return t;var n=new l(t,e);return 1===n.opnds.length?n.opnds[0]:n},o.orContext=function(t,e){if(null===t)return e;if(null===e)return t;if(t===o.NONE||e===o.NONE)return o.NONE;var n=new u(t,e);return 1===n.opnds.length?n.opnds[0]:n},s.prototype=Object.create(o.prototype),s.prototype.constructor=s,o.NONE=new s,s.prototype.evaluate=function(t,e){var n=this.isCtxDependent?e:null;return t.sempred(n,this.ruleIndex,this.predIndex)},s.prototype.updateHashCode=function(t){t.update(this.ruleIndex,this.predIndex,this.isCtxDependent)},s.prototype.equals=function(t){return this===t||t instanceof s&&(this.ruleIndex===t.ruleIndex&&this.predIndex===t.predIndex&&this.isCtxDependent===t.isCtxDependent)},s.prototype.toString=function(){return"{"+this.ruleIndex+":"+this.predIndex+"}?"},a.prototype=Object.create(o.prototype),a.prototype.constructor=a,a.prototype.evaluate=function(t,e){return t.precpred(e,this.precedence)},a.prototype.evalPrecedence=function(t,e){return t.precpred(e,this.precedence)?o.NONE:null},a.prototype.compareTo=function(t){return this.precedence-t.precedence},a.prototype.updateHashCode=function(t){t.update(31)},a.prototype.equals=function(t){return this===t||t instanceof a&&this.precedence===t.precedence},a.prototype.toString=function(){return"{"+this.precedence+">=prec}?"},a.filterPrecedencePredicates=function(t){var e=[];return t.values().map(function(t){t instanceof a&&e.push(t)}),e},l.prototype=Object.create(o.prototype),l.prototype.constructor=l,l.prototype.equals=function(t){return this===t||t instanceof l&&this.opnds===t.opnds},l.prototype.updateHashCode=function(t){t.update(this.opnds,"AND")},l.prototype.evaluate=function(t,e){for(var n=0;n<this.opnds.length;n++)if(!this.opnds[n].evaluate(t,e))return!1;return!0},l.prototype.evalPrecedence=function(t,e){for(var n=!1,r=[],i=0;i<this.opnds.length;i++){var s=this.opnds[i],a=s.evalPrecedence(t,e);if(n|=a!==s,null===a)return null;a!==o.NONE&&r.push(a)}if(!n)return this;if(0===r.length)return o.NONE;var l=null;return r.map(function(t){l=null===l?t:o.andContext(l,t)}),l},l.prototype.toString=function(){var t="";return this.opnds.map(function(e){t+="&& "+e.toString()}),t.length>3?t.slice(3):t},u.prototype=Object.create(o.prototype),u.prototype.constructor=u,u.prototype.constructor=function(t){return this===t||t instanceof u&&this.opnds===t.opnds},u.prototype.updateHashCode=function(t){t.update(this.opnds,"OR")},u.prototype.evaluate=function(t,e){for(var n=0;n<this.opnds.length;n++)if(this.opnds[n].evaluate(t,e))return!0;return!1},u.prototype.evalPrecedence=function(t,e){for(var n=!1,r=[],i=0;i<this.opnds.length;i++){var s=this.opnds[i],a=s.evalPrecedence(t,e);if(n|=a!==s,a===o.NONE)return o.NONE;null!==a&&r.push(a)}if(!n)return this;if(0===r.length)return null;return r.map(function(t){return t}),null},u.prototype.toString=function(){var t="";return this.opnds.map(function(e){t+="|| "+e.toString()}),t.length>3?t.slice(3):t},e.SemanticContext=o,e.PrecedencePredicate=a,e.Predicate=s},function(t,e,n){var r=n(9).ATNConfigSet,i=n(0),o=i.Hash,s=i.Set;function a(t,e){return this.alt=e,this.pred=t,this}function l(t,e){return null===t&&(t=-1),null===e&&(e=new r),this.stateNumber=t,this.configs=e,this.edges=null,this.isAcceptState=!1,this.prediction=0,this.lexerActionExecutor=null,this.requiresFullContext=!1,this.predicates=null,this}a.prototype.toString=function(){return"("+this.pred+", "+this.alt+")"},l.prototype.getAltSet=function(){var t=new s;if(null!==this.configs)for(var e=0;e<this.configs.length;e++){var n=this.configs[e];t.add(n.alt)}return 0===t.length?null:t},l.prototype.equals=function(t){return this===t||t instanceof l&&this.configs.equals(t.configs)},l.prototype.toString=function(){var t=this.stateNumber+":"+this.configs;return this.isAcceptState&&(t+="=>",null!==this.predicates?t+=this.predicates:t+=this.prediction),t},l.prototype.hashCode=function(){var t=new o;return t.update(this.configs),this.isAcceptState&&(null!==this.predicates?t.update(this.predicates):t.update(this.prediction)),t.finish()},e.DFAState=l,e.PredPrediction=a},function(t,e,n){e.atn=n(34),e.codepointat=n(28),e.dfa=n(41),e.fromcodepoint=n(29),e.tree=n(43),e.error=n(44),e.Token=n(1).Token,e.CharStreams=n(46).CharStreams,e.CommonToken=n(1).CommonToken,e.InputStream=n(19).InputStream,e.FileStream=n(47).FileStream,e.CommonTokenStream=n(48).CommonTokenStream,e.Lexer=n(15).Lexer,e.Parser=n(50).Parser;var r=n(6);e.PredictionContextCache=r.PredictionContextCache,e.ParserRuleContext=n(18).ParserRuleContext,e.Interval=n(2).Interval,e.Utils=n(0)},function(t,e,n){var r=n(3).DecisionState,i=n(10).SemanticContext,o=n(0).Hash;function s(t,e){if(null===t){var n={state:null,alt:null,context:null,semanticContext:null};return e&&(n.reachesIntoOuterContext=0),n}var r={};return r.state=t.state||null,r.alt=void 0===t.alt?null:t.alt,r.context=t.context||null,r.semanticContext=t.semanticContext||null,e&&(r.reachesIntoOuterContext=t.reachesIntoOuterContext||0,r.precedenceFilterSuppressed=t.precedenceFilterSuppressed||!1),r}function a(t,e){return this.checkContext(t,e),t=s(t),e=s(e,!0),this.state=null!==t.state?t.state:e.state,this.alt=null!==t.alt?t.alt:e.alt,this.context=null!==t.context?t.context:e.context,this.semanticContext=null!==t.semanticContext?t.semanticContext:null!==e.semanticContext?e.semanticContext:i.NONE,this.reachesIntoOuterContext=e.reachesIntoOuterContext,this.precedenceFilterSuppressed=e.precedenceFilterSuppressed,this}function l(t,e){a.call(this,t,e);var n=t.lexerActionExecutor||null;return this.lexerActionExecutor=n||(null!==e?e.lexerActionExecutor:null),this.passedThroughNonGreedyDecision=null!==e&&this.checkNonGreedyDecision(e,this.state),this}a.prototype.checkContext=function(t,e){null!==t.context&&void 0!==t.context||null!==e&&null!==e.context&&void 0!==e.context||(this.context=null)},a.prototype.hashCode=function(){var t=new o;return this.updateHashCode(t),t.finish()},a.prototype.updateHashCode=function(t){t.update(this.state.stateNumber,this.alt,this.context,this.semanticContext)},a.prototype.equals=function(t){return this===t||t instanceof a&&(this.state.stateNumber===t.state.stateNumber&&this.alt===t.alt&&(null===this.context?null===t.context:this.context.equals(t.context))&&this.semanticContext.equals(t.semanticContext)&&this.precedenceFilterSuppressed===t.precedenceFilterSuppressed)},a.prototype.hashCodeForConfigSet=function(){var t=new o;return t.update(this.state.stateNumber,this.alt,this.semanticContext),t.finish()},a.prototype.equalsForConfigSet=function(t){return this===t||t instanceof a&&(this.state.stateNumber===t.state.stateNumber&&this.alt===t.alt&&this.semanticContext.equals(t.semanticContext))},a.prototype.toString=function(){return"("+this.state+","+this.alt+(null!==this.context?",["+this.context.toString()+"]":"")+(this.semanticContext!==i.NONE?","+this.semanticContext.toString():"")+(this.reachesIntoOuterContext>0?",up="+this.reachesIntoOuterContext:"")+")"},l.prototype=Object.create(a.prototype),l.prototype.constructor=l,l.prototype.updateHashCode=function(t){t.update(this.state.stateNumber,this.alt,this.context,this.semanticContext,this.passedThroughNonGreedyDecision,this.lexerActionExecutor)},l.prototype.equals=function(t){return this===t||t instanceof l&&this.passedThroughNonGreedyDecision==t.passedThroughNonGreedyDecision&&(this.lexerActionExecutor?this.lexerActionExecutor.equals(t.lexerActionExecutor):!t.lexerActionExecutor)&&a.prototype.equals.call(this,t)},l.prototype.hashCodeForConfigSet=l.prototype.hashCode,l.prototype.equalsForConfigSet=l.prototype.equals,l.prototype.checkNonGreedyDecision=function(t,e){return t.passedThroughNonGreedyDecision||e instanceof r&&e.nonGreedy},e.ATNConfig=a,e.LexerATNConfig=l},function(t,e,n){var r=n(4).RuleNode,i=n(4).INVALID_INTERVAL,o=n(7).INVALID_ALT_NUMBER;function s(t,e){return r.call(this),this.parentCtx=t||null,this.invokingState=e||-1,this}s.prototype=Object.create(r.prototype),s.prototype.constructor=s,s.prototype.depth=function(){for(var t=0,e=this;null!==e;)e=e.parentCtx,t+=1;return t},s.prototype.isEmpty=function(){return-1===this.invokingState},s.prototype.getSourceInterval=function(){return i},s.prototype.getRuleContext=function(){return this},s.prototype.getPayload=function(){return this},s.prototype.getText=function(){return 0===this.getChildCount()?"":this.children.map(function(t){return t.getText()}).join("")},s.prototype.getAltNumber=function(){return o},s.prototype.setAltNumber=function(t){},s.prototype.getChild=function(t){return null},s.prototype.getChildCount=function(){return 0},s.prototype.accept=function(t){return t.visitChildren(this)},e.RuleContext=s;var a=n(21).Trees;s.prototype.toStringTree=function(t,e){return a.toStringTree(this,t,e)},s.prototype.toString=function(t,e){t=t||null,e=e||null;for(var n=this,r="[";null!==n&&n!==e;){if(null===t)n.isEmpty()||(r+=n.invokingState);else{var i=n.ruleIndex;r+=i>=0&&i<t.length?t[i]:""+i}null===n.parentCtx||null===t&&n.parentCtx.isEmpty()||(r+=" "),n=n.parentCtx}return r+="]"}},function(t,e,n){var r=n(1).Token,i=n(25).Recognizer,o=n(38).CommonTokenFactory,s=n(5).RecognitionException,a=n(5).LexerNoViableAltException;function l(t){return i.call(this),this._input=t,this._factory=o.DEFAULT,this._tokenFactorySourcePair=[this,t],this._interp=null,this._token=null,this._tokenStartCharIndex=-1,this._tokenStartLine=-1,this._tokenStartColumn=-1,this._hitEOF=!1,this._channel=r.DEFAULT_CHANNEL,this._type=r.INVALID_TYPE,this._modeStack=[],this._mode=l.DEFAULT_MODE,this._text=null,this}l.prototype=Object.create(i.prototype),l.prototype.constructor=l,l.DEFAULT_MODE=0,l.MORE=-2,l.SKIP=-3,l.DEFAULT_TOKEN_CHANNEL=r.DEFAULT_CHANNEL,l.HIDDEN=r.HIDDEN_CHANNEL,l.MIN_CHAR_VALUE=0,l.MAX_CHAR_VALUE=1114111,l.prototype.reset=function(){null!==this._input&&this._input.seek(0),this._token=null,this._type=r.INVALID_TYPE,this._channel=r.DEFAULT_CHANNEL,this._tokenStartCharIndex=-1,this._tokenStartColumn=-1,this._tokenStartLine=-1,this._text=null,this._hitEOF=!1,this._mode=l.DEFAULT_MODE,this._modeStack=[],this._interp.reset()},l.prototype.nextToken=function(){if(null===this._input)throw"nextToken requires a non-null input stream.";var t=this._input.mark();try{for(;;){if(this._hitEOF)return this.emitEOF(),this._token;this._token=null,this._channel=r.DEFAULT_CHANNEL,this._tokenStartCharIndex=this._input.index,this._tokenStartColumn=this._interp.column,this._tokenStartLine=this._interp.line,this._text=null;for(var e=!1;;){this._type=r.INVALID_TYPE;var n=l.SKIP;try{n=this._interp.match(this._input,this._mode)}catch(t){if(!(t instanceof s))throw console.log(t.stack),t;this.notifyListeners(t),this.recover(t)}if(this._input.LA(1)===r.EOF&&(this._hitEOF=!0),this._type===r.INVALID_TYPE&&(this._type=n),this._type===l.SKIP){e=!0;break}if(this._type!==l.MORE)break}if(!e)return null===this._token&&this.emit(),this._token}}finally{this._input.release(t)}},l.prototype.skip=function(){this._type=l.SKIP},l.prototype.more=function(){this._type=l.MORE},l.prototype.mode=function(t){this._mode=t},l.prototype.pushMode=function(t){this._interp.debug&&console.log("pushMode "+t),this._modeStack.push(this._mode),this.mode(t)},l.prototype.popMode=function(){if(0===this._modeStack.length)throw"Empty Stack";return this._interp.debug&&console.log("popMode back to "+this._modeStack.slice(0,-1)),this.mode(this._modeStack.pop()),this._mode},Object.defineProperty(l.prototype,"inputStream",{get:function(){return this._input},set:function(t){this._input=null,this._tokenFactorySourcePair=[this,this._input],this.reset(),this._input=t,this._tokenFactorySourcePair=[this,this._input]}}),Object.defineProperty(l.prototype,"sourceName",{get:function(){return this._input.sourceName}}),l.prototype.emitToken=function(t){this._token=t},l.prototype.emit=function(){var t=this._factory.create(this._tokenFactorySourcePair,this._type,this._text,this._channel,this._tokenStartCharIndex,this.getCharIndex()-1,this._tokenStartLine,this._tokenStartColumn);return this.emitToken(t),t},l.prototype.emitEOF=function(){var t=this.column,e=this.line,n=this._factory.create(this._tokenFactorySourcePair,r.EOF,null,r.DEFAULT_CHANNEL,this._input.index,this._input.index-1,e,t);return this.emitToken(n),n},Object.defineProperty(l.prototype,"type",{get:function(){return this.type},set:function(t){this._type=t}}),Object.defineProperty(l.prototype,"line",{get:function(){return this._interp.line},set:function(t){this._interp.line=t}}),Object.defineProperty(l.prototype,"column",{get:function(){return this._interp.column},set:function(t){this._interp.column=t}}),l.prototype.getCharIndex=function(){return this._input.index},Object.defineProperty(l.prototype,"text",{get:function(){return null!==this._text?this._text:this._interp.getText(this._input)},set:function(t){this._text=t}}),l.prototype.getAllTokens=function(){for(var t=[],e=this.nextToken();e.type!==r.EOF;)t.push(e),e=this.nextToken();return t},l.prototype.notifyListeners=function(t){var e=this._tokenStartCharIndex,n=this._input.index,r=this._input.getText(e,n),i="token recognition error at: '"+this.getErrorDisplay(r)+"'";this.getErrorListenerDispatch().syntaxError(this,null,this._tokenStartLine,this._tokenStartColumn,i,t)},l.prototype.getErrorDisplay=function(t){for(var e=[],n=0;n<t.length;n++)e.push(t[n]);return e.join("")},l.prototype.getErrorDisplayForChar=function(t){return t.charCodeAt(0)===r.EOF?"<EOF>":"\n"===t?"\\n":"\t"===t?"\\t":"\r"===t?"\\r":t},l.prototype.getCharErrorDisplay=function(t){return"'"+this.getErrorDisplayForChar(t)+"'"},l.prototype.recover=function(t){this._input.LA(1)!==r.EOF&&(t instanceof a?this._interp.consume(this._input):this._input.consume())},e.Lexer=l},function(t,e){function n(){return this}function r(){return n.call(this),this}function i(t){if(n.call(this),null===t)throw"delegates";return this.delegates=t,this}n.prototype.syntaxError=function(t,e,n,r,i,o){},n.prototype.reportAmbiguity=function(t,e,n,r,i,o,s){},n.prototype.reportAttemptingFullContext=function(t,e,n,r,i,o){},n.prototype.reportContextSensitivity=function(t,e,n,r,i,o){},r.prototype=Object.create(n.prototype),r.prototype.constructor=r,r.INSTANCE=new r,r.prototype.syntaxError=function(t,e,n,r,i,o){console.error("line "+n+":"+r+" "+i)},i.prototype=Object.create(n.prototype),i.prototype.constructor=i,i.prototype.syntaxError=function(t,e,n,r,i,o){this.delegates.map(function(s){s.syntaxError(t,e,n,r,i,o)})},i.prototype.reportAmbiguity=function(t,e,n,r,i,o,s){this.delegates.map(function(a){a.reportAmbiguity(t,e,n,r,i,o,s)})},i.prototype.reportAttemptingFullContext=function(t,e,n,r,i,o){this.delegates.map(function(s){s.reportAttemptingFullContext(t,e,n,r,i,o)})},i.prototype.reportContextSensitivity=function(t,e,n,r,i,o){this.delegates.map(function(s){s.reportContextSensitivity(t,e,n,r,i,o)})},e.ErrorListener=n,e.ConsoleErrorListener=r,e.ProxyErrorListener=i},function(t,e){function n(t,e,n){return this.dfa=t,this.literalNames=e||[],this.symbolicNames=n||[],this}function r(t){return n.call(this,t,null),this}n.prototype.toString=function(){if(null===this.dfa.s0)return null;for(var t="",e=this.dfa.sortedStates(),n=0;n<e.length;n++){var r=e[n];if(null!==r.edges)for(var i=r.edges.length,o=0;o<i;o++){var s=r.edges[o]||null;null!==s&&2147483647!==s.stateNumber&&(t=(t=(t=(t=(t=(t=t.concat(this.getStateString(r))).concat("-")).concat(this.getEdgeLabel(o))).concat("->")).concat(this.getStateString(s))).concat("\n"))}}return 0===t.length?null:t},n.prototype.getEdgeLabel=function(t){return 0===t?"EOF":null!==this.literalNames||null!==this.symbolicNames?this.literalNames[t-1]||this.symbolicNames[t-1]:String.fromCharCode(t-1)},n.prototype.getStateString=function(t){var e=(t.isAcceptState?":":"")+"s"+t.stateNumber+(t.requiresFullContext?"^":"");return t.isAcceptState?null!==t.predicates?e+"=>"+t.predicates.toString():e+"=>"+t.prediction.toString():e},r.prototype=Object.create(n.prototype),r.prototype.constructor=r,r.prototype.getEdgeLabel=function(t){return"'"+String.fromCharCode(t)+"'"},e.DFASerializer=n,e.LexerDFASerializer=r},function(t,e,n){var r=n(14).RuleContext,i=n(4),o=i.INVALID_INTERVAL,s=i.TerminalNode,a=i.TerminalNodeImpl,l=i.ErrorNodeImpl,u=n(2).Interval;function c(t,e){t=t||null,e=e||null,r.call(this,t,e),this.ruleIndex=-1,this.children=null,this.start=null,this.stop=null,this.exception=null}function h(t,e,n){return c.call(t,e),this.ruleIndex=n,this}c.prototype=Object.create(r.prototype),c.prototype.constructor=c,c.prototype.copyFrom=function(t){this.parentCtx=t.parentCtx,this.invokingState=t.invokingState,this.children=null,this.start=t.start,this.stop=t.stop,t.children&&(this.children=[],t.children.map(function(t){t instanceof l&&(this.children.push(t),t.parentCtx=this)},this))},c.prototype.enterRule=function(t){},c.prototype.exitRule=function(t){},c.prototype.addChild=function(t){return null===this.children&&(this.children=[]),this.children.push(t),t},c.prototype.removeLastChild=function(){null!==this.children&&this.children.pop()},c.prototype.addTokenNode=function(t){var e=new a(t);return this.addChild(e),e.parentCtx=this,e},c.prototype.addErrorNode=function(t){var e=new l(t);return this.addChild(e),e.parentCtx=this,e},c.prototype.getChild=function(t,e){if(e=e||null,null===this.children||t<0||t>=this.children.length)return null;if(null===e)return this.children[t];for(var n=0;n<this.children.length;n++){var r=this.children[n];if(r instanceof e){if(0===t)return r;t-=1}}return null},c.prototype.getToken=function(t,e){if(null===this.children||e<0||e>=this.children.length)return null;for(var n=0;n<this.children.length;n++){var r=this.children[n];if(r instanceof s&&r.symbol.type===t){if(0===e)return r;e-=1}}return null},c.prototype.getTokens=function(t){if(null===this.children)return[];for(var e=[],n=0;n<this.children.length;n++){var r=this.children[n];r instanceof s&&r.symbol.type===t&&e.push(r)}return e},c.prototype.getTypedRuleContext=function(t,e){return this.getChild(e,t)},c.prototype.getTypedRuleContexts=function(t){if(null===this.children)return[];for(var e=[],n=0;n<this.children.length;n++){var r=this.children[n];r instanceof t&&e.push(r)}return e},c.prototype.getChildCount=function(){return null===this.children?0:this.children.length},c.prototype.getSourceInterval=function(){return null===this.start||null===this.stop?o:new u(this.start.tokenIndex,this.stop.tokenIndex)},r.EMPTY=new c,h.prototype=Object.create(c.prototype),h.prototype.constructor=h,e.ParserRuleContext=c},function(t,e,n){var r=n(1).Token;function i(t,e){return this.name="<empty>",this.strdata=t,this.decodeToUnicodeCodePoints=e||!1,function(t,e){if(t._index=0,t.data=[],t.decodeToUnicodeCodePoints)for(var n=0;n<t.strdata.length;){var r=t.strdata.codePointAt(n);t.data.push(r),n+=r<=65535?1:2}else for(n=0;n<t.strdata.length;n++){var i=t.strdata.charCodeAt(n);t.data.push(i)}t._size=t.data.length}(this),this}n(28),n(29),Object.defineProperty(i.prototype,"index",{get:function(){return this._index}}),Object.defineProperty(i.prototype,"size",{get:function(){return this._size}}),i.prototype.reset=function(){this._index=0},i.prototype.consume=function(){if(this._index>=this._size)throw"cannot consume EOF";this._index+=1},i.prototype.LA=function(t){if(0===t)return 0;t<0&&(t+=1);var e=this._index+t-1;return e<0||e>=this._size?r.EOF:this.data[e]},i.prototype.LT=function(t){return this.LA(t)},i.prototype.mark=function(){return-1},i.prototype.release=function(t){},i.prototype.seek=function(t){t<=this._index?this._index=t:this._index=Math.min(t,this._size)},i.prototype.getText=function(t,e){if(e>=this._size&&(e=this._size-1),t>=this._size)return"";if(this.decodeToUnicodeCodePoints){for(var n="",r=t;r<=e;r++)n+=String.fromCodePoint(this.data[r]);return n}return this.strdata.slice(t,e+1)},i.prototype.toString=function(){return this.strdata},e.InputStream=i},function(t,e,n){var r=n(12);function i(){return r.tree.ParseTreeVisitor.call(this),this}i.prototype=Object.create(r.tree.ParseTreeVisitor.prototype),i.prototype.constructor=i,i.prototype.visitGrammarFile=function(t){return this.visitChildren(t)},i.prototype.visitGrammerDecl=function(t){return this.visitChildren(t)},i.prototype.visitStatExprSplit=function(t){return this.visitChildren(t)},i.prototype.visitStatList=function(t){return this.visitChildren(t)},i.prototype.visitStatValue=function(t){return this.visitChildren(t)},i.prototype.visitExprExpression=function(t){return this.visitChildren(t)},i.prototype.visitExprValue=function(t){return this.visitChildren(t)},i.prototype.visitArithmeticRuleCollection=function(t){return this.visitChildren(t)},i.prototype.visitParserAtomExpr=function(t){return this.visitChildren(t)},i.prototype.visitParserAtomParserId=function(t){return this.visitChildren(t)},i.prototype.visitParserAtomLexerId=function(t){return this.visitChildren(t)},i.prototype.visitParserAtomStr=function(t){return this.visitChildren(t)},i.prototype.visitLexerRuleCollection=function(t){return this.visitChildren(t)},i.prototype.visitMeaningfulSplit=function(t){return this.visitChildren(t)},i.prototype.visitLexerRuleStrings=function(t){return this.visitChildren(t)},i.prototype.visitLexerRuleList=function(t){return this.visitChildren(t)},i.prototype.visitLexerRuleComplex=function(t){return this.visitChildren(t)},i.prototype.visitStrings=function(t){return this.visitChildren(t)},i.prototype.visitLexerRuleExpr=function(t){return this.visitChildren(t)},e.BlocklyGrammerVisitor=i},function(t,e,n){var r=n(0),i=n(1).Token,o=(n(4).RuleNode,n(4).ErrorNode),s=n(4).TerminalNode,a=n(18).ParserRuleContext,l=n(14).RuleContext,u=n(7).INVALID_ALT_NUMBER;function c(){}c.toStringTree=function(t,e,n){e=e||null,null!==(n=n||null)&&(e=n.ruleNames);var i=c.getNodeText(t,e);i=r.escapeWhitespace(i,!1);var o=t.getChildCount();if(0===o)return i;var s="("+i+" ";o>0&&(i=c.toStringTree(t.getChild(0),e),s=s.concat(i));for(var a=1;a<o;a++)i=c.toStringTree(t.getChild(a),e),s=s.concat(" "+i);return s=s.concat(")")},c.getNodeText=function(t,e,n){if(e=e||null,null!==(n=n||null)&&(e=n.ruleNames),null!==e){if(t instanceof l){var r=t.getAltNumber();return r!=u?e[t.ruleIndex]+":"+r:e[t.ruleIndex]}if(t instanceof o)return t.toString();if(t instanceof s&&null!==t.symbol)return t.symbol.text}var a=t.getPayload();return a instanceof i?a.text:t.getPayload().toString()},c.getChildren=function(t){for(var e=[],n=0;n<t.getChildCount();n++)e.push(t.getChild(n));return e},c.getAncestors=function(t){var e=[];for(t=t.getParent();null!==t;)e=[t].concat(e),t=t.getParent();return e},c.findAllTokenNodes=function(t,e){return c.findAllNodes(t,e,!0)},c.findAllRuleNodes=function(t,e){return c.findAllNodes(t,e,!1)},c.findAllNodes=function(t,e,n){var r=[];return c._findAllNodes(t,e,n,r),r},c._findAllNodes=function(t,e,n,r){n&&t instanceof s?t.symbol.type===e&&r.push(t):!n&&t instanceof a&&t.ruleIndex===e&&r.push(t);for(var i=0;i<t.getChildCount();i++)c._findAllNodes(t.getChild(i),e,n,r)},c.descendants=function(t){for(var e=[t],n=0;n<t.getChildCount();n++)e=e.concat(c.descendants(t.getChild(n)));return e},e.Trees=c},function(t,e,n){var r=n(1).Token,i=n(7).ATN,o=n(36).ATNType,s=n(3),a=s.ATNState,l=s.BasicState,u=s.DecisionState,c=s.BlockStartState,h=s.BlockEndState,p=s.LoopEndState,f=s.RuleStartState,d=s.RuleStopState,y=s.TokensStartState,g=s.PlusLoopbackState,v=s.StarLoopbackState,x=s.StarLoopEntryState,m=s.PlusBlockStartState,_=s.StarBlockStartState,T=s.BasicBlockStartState,S=n(8),E=S.Transition,C=S.AtomTransition,A=S.SetTransition,b=S.NotSetTransition,k=S.RuleTransition,R=S.RangeTransition,L=S.ActionTransition,I=S.EpsilonTransition,N=S.WildcardTransition,O=S.PredicateTransition,P=S.PrecedencePredicateTransition,w=n(2).IntervalSet,F=(n(2).Interval,n(23).ATNDeserializationOptions),D=n(24),j=D.LexerActionType,M=D.LexerSkipAction,B=D.LexerChannelAction,U=D.LexerCustomAction,V=D.LexerMoreAction,H=D.LexerTypeAction,z=D.LexerPushModeAction,q=D.LexerPopModeAction,G=D.LexerModeAction,Y="59627784-3BE5-417A-B9EB-8131A7286089",K=["AADB8D7E-AEEF-4415-AD2B-8204D6CF042E",Y];function $(t,e){var n=[];return n[t-1]=e,n.map(function(t){return e})}function W(t){return void 0!==t&&null!==t||(t=F.defaultOptions),this.deserializationOptions=t,this.stateFactories=null,this.actionFactories=null,this}W.prototype.isFeatureSupported=function(t,e){var n=K.indexOf(t);return!(n<0)&&K.indexOf(e)>=n},W.prototype.deserialize=function(t){this.reset(t),this.checkVersion(),this.checkUUID();var e=this.readATN();this.readStates(e),this.readRules(e),this.readModes(e);var n=[];return this.readSets(e,n,this.readInt.bind(this)),this.isFeatureSupported(Y,this.uuid)&&this.readSets(e,n,this.readInt32.bind(this)),this.readEdges(e,n),this.readDecisions(e),this.readLexerActions(e),this.markPrecedenceDecisions(e),this.verifyATN(e),this.deserializationOptions.generateRuleBypassTransitions&&e.grammarType===o.PARSER&&(this.generateRuleBypassTransitions(e),this.verifyATN(e)),e},W.prototype.reset=function(t){var e=t.split("").map(function(t){var e=t.charCodeAt(0);return e>1?e-2:-1});e[0]=t.charCodeAt(0),this.data=e,this.pos=0},W.prototype.checkVersion=function(){var t=this.readInt();if(3!==t)throw"Could not deserialize ATN with version "+t+" (expected 3)."},W.prototype.checkUUID=function(){var t=this.readUUID();if(K.indexOf(t)<0)throw"59627784-3BE5-417A-B9EB-8131A7286089";this.uuid=t},W.prototype.readATN=function(){var t=this.readInt(),e=this.readInt();return new i(t,e)},W.prototype.readStates=function(t){for(var e,n,r,i=[],o=[],s=this.readInt(),l=0;l<s;l++){var u=this.readInt();if(u!==a.INVALID_TYPE){var h=this.readInt();65535===h&&(h=-1);var p=this.stateFactory(u,h);if(u===a.LOOP_END){var f=this.readInt();i.push([p,f])}else if(p instanceof c){var d=this.readInt();o.push([p,d])}t.addState(p)}else t.addState(null)}for(e=0;e<i.length;e++)(n=i[e])[0].loopBackState=t.states[n[1]];for(e=0;e<o.length;e++)(n=o[e])[0].endState=t.states[n[1]];var y=this.readInt();for(e=0;e<y;e++)r=this.readInt(),t.states[r].nonGreedy=!0;var g=this.readInt();for(e=0;e<g;e++)r=this.readInt(),t.states[r].isPrecedenceRule=!0},W.prototype.readRules=function(t){var e,n=this.readInt();for(t.grammarType===o.LEXER&&(t.ruleToTokenType=$(n,0)),t.ruleToStartState=$(n,0),e=0;e<n;e++){var i=this.readInt(),s=t.states[i];if(t.ruleToStartState[e]=s,t.grammarType===o.LEXER){var a=this.readInt();65535===a&&(a=r.EOF),t.ruleToTokenType[e]=a}}for(t.ruleToStopState=$(n,0),e=0;e<t.states.length;e++){var l=t.states[e];l instanceof d&&(t.ruleToStopState[l.ruleIndex]=l,t.ruleToStartState[l.ruleIndex].stopState=l)}},W.prototype.readModes=function(t){for(var e=this.readInt(),n=0;n<e;n++){var r=this.readInt();t.modeToStartState.push(t.states[r])}},W.prototype.readSets=function(t,e,n){for(var r=this.readInt(),i=0;i<r;i++){var o=new w;e.push(o);var s=this.readInt();0!==this.readInt()&&o.addOne(-1);for(var a=0;a<s;a++){var l=n(),u=n();o.addRange(l,u)}}},W.prototype.readEdges=function(t,e){var n,r,i,o,s,a=this.readInt();for(n=0;n<a;n++){var l=this.readInt(),u=this.readInt(),h=this.readInt(),p=this.readInt(),f=this.readInt(),d=this.readInt();o=this.edgeFactory(t,h,l,u,p,f,d,e),t.states[l].addTransition(o)}for(n=0;n<t.states.length;n++)for(i=t.states[n],r=0;r<i.transitions.length;r++){var y=i.transitions[r];if(y instanceof k){var _=-1;t.ruleToStartState[y.target.ruleIndex].isPrecedenceRule&&0===y.precedence&&(_=y.target.ruleIndex),o=new I(y.followState,_),t.ruleToStopState[y.target.ruleIndex].addTransition(o)}}for(n=0;n<t.states.length;n++){if((i=t.states[n])instanceof c){if(null===i.endState)throw"IllegalState";if(null!==i.endState.startState)throw"IllegalState";i.endState.startState=i}if(i instanceof g)for(r=0;r<i.transitions.length;r++)(s=i.transitions[r].target)instanceof m&&(s.loopBackState=i);else if(i instanceof v)for(r=0;r<i.transitions.length;r++)(s=i.transitions[r].target)instanceof x&&(s.loopBackState=i)}},W.prototype.readDecisions=function(t){for(var e=this.readInt(),n=0;n<e;n++){var r=this.readInt(),i=t.states[r];t.decisionToState.push(i),i.decision=n}},W.prototype.readLexerActions=function(t){if(t.grammarType===o.LEXER){var e=this.readInt();t.lexerActions=$(e,null);for(var n=0;n<e;n++){var r=this.readInt(),i=this.readInt();65535===i&&(i=-1);var s=this.readInt();65535===s&&(s=-1);var a=this.lexerActionFactory(r,i,s);t.lexerActions[n]=a}}},W.prototype.generateRuleBypassTransitions=function(t){var e,n=t.ruleToStartState.length;for(e=0;e<n;e++)t.ruleToTokenType[e]=t.maxTokenType+e+1;for(e=0;e<n;e++)this.generateRuleBypassTransition(t,e)},W.prototype.generateRuleBypassTransition=function(t,e){var n,r,i=new T;i.ruleIndex=e,t.addState(i);var o=new h;o.ruleIndex=e,t.addState(o),i.endState=o,t.defineDecisionState(i),o.startState=i;var s=null,a=null;if(t.ruleToStartState[e].isPrecedenceRule){for(a=null,n=0;n<t.states.length;n++)if(r=t.states[n],this.stateIsEndStateFor(r,e)){a=r,s=r.loopBackState.transitions[0];break}if(null===s)throw"Couldn't identify final state of the precedence rule prefix section."}else a=t.ruleToStopState[e];for(n=0;n<t.states.length;n++){r=t.states[n];for(var u=0;u<r.transitions.length;u++){var c=r.transitions[u];c!==s&&(c.target===a&&(c.target=o))}}for(var p=t.ruleToStartState[e],f=p.transitions.length;f>0;)i.addTransition(p.transitions[f-1]),p.transitions=p.transitions.slice(-1);t.ruleToStartState[e].addTransition(new I(i)),o.addTransition(new I(a));var d=new l;t.addState(d),d.addTransition(new C(o,t.ruleToTokenType[e])),i.addTransition(new I(d))},W.prototype.stateIsEndStateFor=function(t,e){if(t.ruleIndex!==e)return null;if(!(t instanceof x))return null;var n=t.transitions[t.transitions.length-1].target;return n instanceof p&&n.epsilonOnlyTransitions&&n.transitions[0].target instanceof d?t:null},W.prototype.markPrecedenceDecisions=function(t){for(var e=0;e<t.states.length;e++){var n=t.states[e];if(n instanceof x&&t.ruleToStartState[n.ruleIndex].isPrecedenceRule){var r=n.transitions[n.transitions.length-1].target;r instanceof p&&r.epsilonOnlyTransitions&&r.transitions[0].target instanceof d&&(n.isPrecedenceDecision=!0)}}},W.prototype.verifyATN=function(t){if(this.deserializationOptions.verifyATN)for(var e=0;e<t.states.length;e++){var n=t.states[e];if(null!==n)if(this.checkCondition(n.epsilonOnlyTransitions||n.transitions.length<=1),n instanceof m)this.checkCondition(null!==n.loopBackState);else if(n instanceof x)if(this.checkCondition(null!==n.loopBackState),this.checkCondition(2===n.transitions.length),n.transitions[0].target instanceof _)this.checkCondition(n.transitions[1].target instanceof p),this.checkCondition(!n.nonGreedy);else{if(!(n.transitions[0].target instanceof p))throw"IllegalState";this.checkCondition(n.transitions[1].target instanceof _),this.checkCondition(n.nonGreedy)}else n instanceof v?(this.checkCondition(1===n.transitions.length),this.checkCondition(n.transitions[0].target instanceof x)):n instanceof p?this.checkCondition(null!==n.loopBackState):n instanceof f?this.checkCondition(null!==n.stopState):n instanceof c?this.checkCondition(null!==n.endState):n instanceof h?this.checkCondition(null!==n.startState):n instanceof u?this.checkCondition(n.transitions.length<=1||n.decision>=0):this.checkCondition(n.transitions.length<=1||n instanceof d)}},W.prototype.checkCondition=function(t,e){if(!t)throw void 0!==e&&null!==e||(e="IllegalState"),e},W.prototype.readInt=function(){return this.data[this.pos++]},W.prototype.readInt32=function(){return this.readInt()|this.readInt()<<16},W.prototype.readLong=function(){return 4294967295&this.readInt32()|this.readInt32()<<32};var X=function(){for(var t=[],e=0;e<256;e++)t[e]=(e+256).toString(16).substr(1).toUpperCase();return t}();W.prototype.readUUID=function(){for(var t=[],e=7;e>=0;e--){var n=this.readInt();t[2*e+1]=255&n,t[2*e]=n>>8&255}return X[t[0]]+X[t[1]]+X[t[2]]+X[t[3]]+"-"+X[t[4]]+X[t[5]]+"-"+X[t[6]]+X[t[7]]+"-"+X[t[8]]+X[t[9]]+"-"+X[t[10]]+X[t[11]]+X[t[12]]+X[t[13]]+X[t[14]]+X[t[15]]},W.prototype.edgeFactory=function(t,e,n,i,o,s,a,l){var u=t.states[i];switch(e){case E.EPSILON:return new I(u);case E.RANGE:return new R(u,0!==a?r.EOF:o,s);case E.RULE:return new k(t.states[o],s,a,u);case E.PREDICATE:return new O(u,o,s,0!==a);case E.PRECEDENCE:return new P(u,o);case E.ATOM:return new C(u,0!==a?r.EOF:o);case E.ACTION:return new L(u,o,s,0!==a);case E.SET:return new A(u,l[o]);case E.NOT_SET:return new b(u,l[o]);case E.WILDCARD:return new N(u);default:throw"The specified transition type: "+e+" is not valid."}},W.prototype.stateFactory=function(t,e){if(null===this.stateFactories){var n=[];n[a.INVALID_TYPE]=null,n[a.BASIC]=function(){return new l},n[a.RULE_START]=function(){return new f},n[a.BLOCK_START]=function(){return new T},n[a.PLUS_BLOCK_START]=function(){return new m},n[a.STAR_BLOCK_START]=function(){return new _},n[a.TOKEN_START]=function(){return new y},n[a.RULE_STOP]=function(){return new d},n[a.BLOCK_END]=function(){return new h},n[a.STAR_LOOP_BACK]=function(){return new v},n[a.STAR_LOOP_ENTRY]=function(){return new x},n[a.PLUS_LOOP_BACK]=function(){return new g},n[a.LOOP_END]=function(){return new p},this.stateFactories=n}if(t>this.stateFactories.length||null===this.stateFactories[t])throw"The specified state type "+t+" is not valid.";var r=this.stateFactories[t]();if(null!==r)return r.ruleIndex=e,r},W.prototype.lexerActionFactory=function(t,e,n){if(null===this.actionFactories){var r=[];r[j.CHANNEL]=function(t,e){return new B(t)},r[j.CUSTOM]=function(t,e){return new U(t,e)},r[j.MODE]=function(t,e){return new G(t)},r[j.MORE]=function(t,e){return V.INSTANCE},r[j.POP_MODE]=function(t,e){return q.INSTANCE},r[j.PUSH_MODE]=function(t,e){return new z(t)},r[j.SKIP]=function(t,e){return M.INSTANCE},r[j.TYPE]=function(t,e){return new H(t)},this.actionFactories=r}if(t>this.actionFactories.length||null===this.actionFactories[t])throw"The specified lexer action type "+t+" is not valid.";return this.actionFactories[t](e,n)},e.ATNDeserializer=W},function(t,e){function n(t){return void 0===t&&(t=null),this.readOnly=!1,this.verifyATN=null===t||t.verifyATN,this.generateRuleBypassTransitions=null!==t&&t.generateRuleBypassTransitions,this}n.defaultOptions=new n,n.defaultOptions.readOnly=!0,e.ATNDeserializationOptions=n},function(t,e){function n(){}function r(t){return this.actionType=t,this.isPositionDependent=!1,this}function i(){return r.call(this,n.SKIP),this}function o(t){return r.call(this,n.TYPE),this.type=t,this}function s(t){return r.call(this,n.PUSH_MODE),this.mode=t,this}function a(){return r.call(this,n.POP_MODE),this}function l(){return r.call(this,n.MORE),this}function u(t){return r.call(this,n.MODE),this.mode=t,this}function c(t,e){return r.call(this,n.CUSTOM),this.ruleIndex=t,this.actionIndex=e,this.isPositionDependent=!0,this}function h(t){return r.call(this,n.CHANNEL),this.channel=t,this}function p(t,e){return r.call(this,e.actionType),this.offset=t,this.action=e,this.isPositionDependent=!0,this}n.CHANNEL=0,n.CUSTOM=1,n.MODE=2,n.MORE=3,n.POP_MODE=4,n.PUSH_MODE=5,n.SKIP=6,n.TYPE=7,r.prototype.hashCode=function(){var t=new Hash;return this.updateHashCode(t),t.finish()},r.prototype.updateHashCode=function(t){t.update(this.actionType)},r.prototype.equals=function(t){return this===t},i.prototype=Object.create(r.prototype),i.prototype.constructor=i,i.INSTANCE=new i,i.prototype.execute=function(t){t.skip()},i.prototype.toString=function(){return"skip"},o.prototype=Object.create(r.prototype),o.prototype.constructor=o,o.prototype.execute=function(t){t.type=this.type},o.prototype.updateHashCode=function(t){t.update(this.actionType,this.type)},o.prototype.equals=function(t){return this===t||t instanceof o&&this.type===t.type},o.prototype.toString=function(){return"type("+this.type+")"},s.prototype=Object.create(r.prototype),s.prototype.constructor=s,s.prototype.execute=function(t){t.pushMode(this.mode)},s.prototype.updateHashCode=function(t){t.update(this.actionType,this.mode)},s.prototype.equals=function(t){return this===t||t instanceof s&&this.mode===t.mode},s.prototype.toString=function(){return"pushMode("+this.mode+")"},a.prototype=Object.create(r.prototype),a.prototype.constructor=a,a.INSTANCE=new a,a.prototype.execute=function(t){t.popMode()},a.prototype.toString=function(){return"popMode"},l.prototype=Object.create(r.prototype),l.prototype.constructor=l,l.INSTANCE=new l,l.prototype.execute=function(t){t.more()},l.prototype.toString=function(){return"more"},u.prototype=Object.create(r.prototype),u.prototype.constructor=u,u.prototype.execute=function(t){t.mode(this.mode)},u.prototype.updateHashCode=function(t){t.update(this.actionType,this.mode)},u.prototype.equals=function(t){return this===t||t instanceof u&&this.mode===t.mode},u.prototype.toString=function(){return"mode("+this.mode+")"},c.prototype=Object.create(r.prototype),c.prototype.constructor=c,c.prototype.execute=function(t){t.action(null,this.ruleIndex,this.actionIndex)},c.prototype.updateHashCode=function(t){t.update(this.actionType,this.ruleIndex,this.actionIndex)},c.prototype.equals=function(t){return this===t||t instanceof c&&(this.ruleIndex===t.ruleIndex&&this.actionIndex===t.actionIndex)},h.prototype=Object.create(r.prototype),h.prototype.constructor=h,h.prototype.execute=function(t){t._channel=this.channel},h.prototype.updateHashCode=function(t){t.update(this.actionType,this.channel)},h.prototype.equals=function(t){return this===t||t instanceof h&&this.channel===t.channel},h.prototype.toString=function(){return"channel("+this.channel+")"},p.prototype=Object.create(r.prototype),p.prototype.constructor=p,p.prototype.execute=function(t){this.action.execute(t)},p.prototype.updateHashCode=function(t){t.update(this.actionType,this.offset,this.action)},p.prototype.equals=function(t){return this===t||t instanceof p&&(this.offset===t.offset&&this.action===t.action)},e.LexerActionType=n,e.LexerSkipAction=i,e.LexerChannelAction=h,e.LexerCustomAction=c,e.LexerIndexedCustomAction=p,e.LexerMoreAction=l,e.LexerTypeAction=o,e.LexerPushModeAction=s,e.LexerPopModeAction=a,e.LexerModeAction=u},function(t,e,n){var r=n(1).Token,i=n(16).ConsoleErrorListener,o=n(16).ProxyErrorListener;function s(){return this._listeners=[i.INSTANCE],this._interp=null,this._stateNumber=-1,this}s.tokenTypeMapCache={},s.ruleIndexMapCache={},s.prototype.checkVersion=function(t){"4.7"!==t&&console.log("ANTLR runtime and generated code versions disagree: 4.7!="+t)},s.prototype.addErrorListener=function(t){this._listeners.push(t)},s.prototype.removeErrorListeners=function(){this._listeners=[]},s.prototype.getTokenTypeMap=function(){var t=this.getTokenNames();if(null===t)throw"The current recognizer does not provide a list of token names.";var e=this.tokenTypeMapCache[t];return void 0===e&&((e=t.reduce(function(t,e,n){t[e]=n})).EOF=r.EOF,this.tokenTypeMapCache[t]=e),e},s.prototype.getRuleIndexMap=function(){var t=this.ruleNames;if(null===t)throw"The current recognizer does not provide a list of rule names.";var e=this.ruleIndexMapCache[t];return void 0===e&&(e=t.reduce(function(t,e,n){t[e]=n}),this.ruleIndexMapCache[t]=e),e},s.prototype.getTokenType=function(t){var e=this.getTokenTypeMap()[t];return void 0!==e?e:r.INVALID_TYPE},s.prototype.getErrorHeader=function(t){return"line "+t.getOffendingToken().line+":"+t.getOffendingToken().column},s.prototype.getTokenErrorDisplay=function(t){if(null===t)return"<no token>";var e=t.text;return null===e&&(e=t.type===r.EOF?"<EOF>":"<"+t.type+">"),"'"+(e=e.replace("\n","\\n").replace("\r","\\r").replace("\t","\\t"))+"'"},s.prototype.getErrorListenerDispatch=function(){return new o(this._listeners)},s.prototype.sempred=function(t,e,n){return!0},s.prototype.precpred=function(t,e){return!0},Object.defineProperty(s.prototype,"state",{get:function(){return this._stateNumber},set:function(t){this._stateNumber=t}}),e.Recognizer=s},function(t,e,n){var r=n(11).DFAState,i=n(9).ATNConfigSet,o=n(6).getCachedPredictionContext;function s(t,e){return this.atn=t,this.sharedContextCache=e,this}s.ERROR=new r(2147483647,new i),s.prototype.getCachedContext=function(t){if(null===this.sharedContextCache)return t;return o(t,this.sharedContextCache,{})},e.ATNSimulator=s},function(t,e,n){n(0).Set;var r=n(0).Map,i=n(0).BitSet,o=n(0).AltDict,s=n(7).ATN,a=n(3).RuleStopState,l=n(9).ATNConfigSet,u=n(13).ATNConfig,c=n(10).SemanticContext,h=(n(0).Hash,n(0).hashStuff);n(0).equalArrays;function p(){return this}p.SLL=0,p.LL=1,p.LL_EXACT_AMBIG_DETECTION=2,p.hasSLLConflictTerminatingPrediction=function(t,e){if(p.allConfigsInRuleStopStates(e))return!0;if(t===p.SLL&&e.hasSemanticContext){for(var n=new l,r=0;r<e.items.length;r++){var i=e.items[r];i=new u({semanticContext:c.NONE},i),n.add(i)}e=n}var o=p.getConflictingAltSubsets(e);return p.hasConflictingAltSet(o)&&!p.hasStateAssociatedWithOneAlt(e)},p.hasConfigInRuleStopState=function(t){for(var e=0;e<t.items.length;e++){if(t.items[e].state instanceof a)return!0}return!1},p.allConfigsInRuleStopStates=function(t){for(var e=0;e<t.items.length;e++){if(!(t.items[e].state instanceof a))return!1}return!0},p.resolvesToJustOneViableAlt=function(t){return p.getSingleViableAlt(t)},p.allSubsetsConflict=function(t){return!p.hasNonConflictingAltSet(t)},p.hasNonConflictingAltSet=function(t){for(var e=0;e<t.length;e++){if(1===t[e].length)return!0}return!1},p.hasConflictingAltSet=function(t){for(var e=0;e<t.length;e++){if(t[e].length>1)return!0}return!1},p.allSubsetsEqual=function(t){for(var e=null,n=0;n<t.length;n++){var r=t[n];if(null===e)e=r;else if(r!==e)return!1}return!0},p.getUniqueAlt=function(t){var e=p.getAlts(t);return 1===e.length?e.minValue():s.INVALID_ALT_NUMBER},p.getAlts=function(t){var e=new i;return t.map(function(t){e.or(t)}),e},p.getConflictingAltSubsets=function(t){var e=new r;return e.hashFunction=function(t){h(t.state.stateNumber,t.context)},e.equalsFunction=function(t,e){return t.state.stateNumber==e.state.stateNumber&&t.context.equals(e.context)},t.items.map(function(t){var n=e.get(t);null===n&&(n=new i,e.put(t,n)),n.add(t.alt)}),e.getValues()},p.getStateToAltMap=function(t){var e=new o;return t.items.map(function(t){var n=e.get(t.state);null===n&&(n=new i,e.put(t.state,n)),n.add(t.alt)}),e},p.hasStateAssociatedWithOneAlt=function(t){for(var e=p.getStateToAltMap(t).values(),n=0;n<e.length;n++)if(1===e[n].length)return!0;return!1},p.getSingleViableAlt=function(t){for(var e=null,n=0;n<t.length;n++){var r=t[n].minValue();if(null===e)e=r;else if(e!==r)return s.INVALID_ALT_NUMBER}return e},e.PredictionMode=p},function(t,e){String.prototype.codePointAt||function(){"use strict";var t=function(){try{var t={},e=Object.defineProperty,n=e(t,t,t)&&e}catch(t){}return n}(),e=function(t){if(null==this)throw TypeError();var e=String(this),n=e.length,r=t?Number(t):0;if(r!=r&&(r=0),!(r<0||r>=n)){var i,o=e.charCodeAt(r);return o>=55296&&o<=56319&&n>r+1&&(i=e.charCodeAt(r+1))>=56320&&i<=57343?1024*(o-55296)+i-56320+65536:o}};t?t(String.prototype,"codePointAt",{value:e,configurable:!0,writable:!0}):String.prototype.codePointAt=e}()},function(t,e){var n,r,i,o;String.fromCodePoint||(n=function(){try{var t={},e=Object.defineProperty,n=e(t,t,t)&&e}catch(t){}return n}(),r=String.fromCharCode,i=Math.floor,o=function(t){var e,n,o=[],s=-1,a=arguments.length;if(!a)return"";for(var l="";++s<a;){var u=Number(arguments[s]);if(!isFinite(u)||u<0||u>1114111||i(u)!=u)throw RangeError("Invalid code point: "+u);u<=65535?o.push(u):(e=55296+((u-=65536)>>10),n=u%1024+56320,o.push(e,n)),(s+1==a||o.length>16384)&&(l+=r.apply(null,o),o.length=0)}return l},n?n(String,"fromCodePoint",{value:o,configurable:!0,writable:!0}):String.fromCodePoint=o)},function(t,e,n){var r=n(1).Token,i=n(5),o=i.NoViableAltException,s=i.InputMismatchException,a=i.FailedPredicateException,l=i.ParseCancellationException,u=n(3).ATNState,c=n(2).Interval,h=n(2).IntervalSet;function p(){}function f(){return p.call(this),this.errorRecoveryMode=!1,this.lastErrorIndex=-1,this.lastErrorStates=null,this}function d(){return f.call(this),this}p.prototype.reset=function(t){},p.prototype.recoverInline=function(t){},p.prototype.recover=function(t,e){},p.prototype.sync=function(t){},p.prototype.inErrorRecoveryMode=function(t){},p.prototype.reportError=function(t){},f.prototype=Object.create(p.prototype),f.prototype.constructor=f,f.prototype.reset=function(t){this.endErrorCondition(t)},f.prototype.beginErrorCondition=function(t){this.errorRecoveryMode=!0},f.prototype.inErrorRecoveryMode=function(t){return this.errorRecoveryMode},f.prototype.endErrorCondition=function(t){this.errorRecoveryMode=!1,this.lastErrorStates=null,this.lastErrorIndex=-1},f.prototype.reportMatch=function(t){this.endErrorCondition(t)},f.prototype.reportError=function(t,e){this.inErrorRecoveryMode(t)||(this.beginErrorCondition(t),e instanceof o?this.reportNoViableAlternative(t,e):e instanceof s?this.reportInputMismatch(t,e):e instanceof a?this.reportFailedPredicate(t,e):(console.log("unknown recognition error type: "+e.constructor.name),console.log(e.stack),t.notifyErrorListeners(e.getOffendingToken(),e.getMessage(),e)))},f.prototype.recover=function(t,e){this.lastErrorIndex===t.getInputStream().index&&null!==this.lastErrorStates&&this.lastErrorStates.indexOf(t.state)>=0&&t.consume(),this.lastErrorIndex=t._input.index,null===this.lastErrorStates&&(this.lastErrorStates=[]),this.lastErrorStates.push(t.state);var n=this.getErrorRecoverySet(t);this.consumeUntil(t,n)},f.prototype.sync=function(t){if(!this.inErrorRecoveryMode(t)){var e=t._interp.atn.states[t.state],n=t.getTokenStream().LA(1),i=t.atn.nextTokens(e);if(!i.contains(r.EPSILON)&&!i.contains(n))switch(e.stateType){case u.BLOCK_START:case u.STAR_BLOCK_START:case u.PLUS_BLOCK_START:case u.STAR_LOOP_ENTRY:if(null!==this.singleTokenDeletion(t))return;throw new s(t);case u.PLUS_LOOP_BACK:case u.STAR_LOOP_BACK:this.reportUnwantedToken(t);var o=new h;o.addSet(t.getExpectedTokens());var a=o.addSet(this.getErrorRecoverySet(t));this.consumeUntil(t,a)}}},f.prototype.reportNoViableAlternative=function(t,e){var n,i=t.getTokenStream();n=null!==i?e.startToken.type===r.EOF?"<EOF>":i.getText(new c(e.startToken,e.offendingToken)):"<unknown input>";var o="no viable alternative at input "+this.escapeWSAndQuote(n);t.notifyErrorListeners(o,e.offendingToken,e)},f.prototype.reportInputMismatch=function(t,e){var n="mismatched input "+this.getTokenErrorDisplay(e.offendingToken)+" expecting "+e.getExpectedTokens().toString(t.literalNames,t.symbolicNames);t.notifyErrorListeners(n,e.offendingToken,e)},f.prototype.reportFailedPredicate=function(t,e){var n="rule "+t.ruleNames[t._ctx.ruleIndex]+" "+e.message;t.notifyErrorListeners(n,e.offendingToken,e)},f.prototype.reportUnwantedToken=function(t){if(!this.inErrorRecoveryMode(t)){this.beginErrorCondition(t);var e=t.getCurrentToken(),n="extraneous input "+this.getTokenErrorDisplay(e)+" expecting "+this.getExpectedTokens(t).toString(t.literalNames,t.symbolicNames);t.notifyErrorListeners(n,e,null)}},f.prototype.reportMissingToken=function(t){if(!this.inErrorRecoveryMode(t)){this.beginErrorCondition(t);var e=t.getCurrentToken(),n="missing "+this.getExpectedTokens(t).toString(t.literalNames,t.symbolicNames)+" at "+this.getTokenErrorDisplay(e);t.notifyErrorListeners(n,e,null)}},f.prototype.recoverInline=function(t){var e=this.singleTokenDeletion(t);if(null!==e)return t.consume(),e;if(this.singleTokenInsertion(t))return this.getMissingSymbol(t);throw new s(t)},f.prototype.singleTokenInsertion=function(t){var e=t.getTokenStream().LA(1),n=t._interp.atn,r=n.states[t.state].transitions[0].target;return!!n.nextTokens(r,t._ctx).contains(e)&&(this.reportMissingToken(t),!0)},f.prototype.singleTokenDeletion=function(t){var e=t.getTokenStream().LA(2);if(this.getExpectedTokens(t).contains(e)){this.reportUnwantedToken(t),t.consume();var n=t.getCurrentToken();return this.reportMatch(t),n}return null},f.prototype.getMissingSymbol=function(t){var e,n=t.getCurrentToken(),i=this.getExpectedTokens(t).first();e=i===r.EOF?"<missing EOF>":"<missing "+t.literalNames[i]+">";var o=n,s=t.getTokenStream().LT(-1);return o.type===r.EOF&&null!==s&&(o=s),t.getTokenFactory().create(o.source,i,e,r.DEFAULT_CHANNEL,-1,-1,o.line,o.column)},f.prototype.getExpectedTokens=function(t){return t.getExpectedTokens()},f.prototype.getTokenErrorDisplay=function(t){if(null===t)return"<no token>";var e=t.text;return null===e&&(e=t.type===r.EOF?"<EOF>":"<"+t.type+">"),this.escapeWSAndQuote(e)},f.prototype.escapeWSAndQuote=function(t){return"'"+(t=(t=(t=t.replace(/\n/g,"\\n")).replace(/\r/g,"\\r")).replace(/\t/g,"\\t"))+"'"},f.prototype.getErrorRecoverySet=function(t){for(var e=t._interp.atn,n=t._ctx,i=new h;null!==n&&n.invokingState>=0;){var o=e.states[n.invokingState].transitions[0],s=e.nextTokens(o.followState);i.addSet(s),n=n.parentCtx}return i.removeOne(r.EPSILON),i},f.prototype.consumeUntil=function(t,e){for(var n=t.getTokenStream().LA(1);n!==r.EOF&&!e.contains(n);)t.consume(),n=t.getTokenStream().LA(1)},d.prototype=Object.create(f.prototype),d.prototype.constructor=d,d.prototype.recover=function(t,e){for(var n=t._ctx;null!==n;)n.exception=e,n=n.parentCtx;throw new l(e)},d.prototype.recoverInline=function(t){this.recover(t,new s(t))},d.prototype.sync=function(t){},e.BailErrorStrategy=d,e.DefaultErrorStrategy=f},function(t,e){},function(t,e,n){Converter=n(33).Converter},function(module,exports,__webpack_require__){antlr4=__webpack_require__(12);var BlocklyGrammerVisitor=__webpack_require__(20).BlocklyGrammerVisitor,BlocklyGrammerLexer=__webpack_require__(51).BlocklyGrammerLexer,BlocklyGrammerParser=__webpack_require__(52).BlocklyGrammerParser,Visitors=__webpack_require__(53),SymbolVisitor=Visitors.SymbolVisitor,EvalVisitor=Visitors.EvalVisitor,tpl=__webpack_require__(54);function Converter(){return this}Converter.prototype.constructor=Converter,Converter.prototype.init=function(){return this.toolboxGap=5,this.toolboxId="toolbox",this.blocklyDivId="blocklyDiv",this.workSpaceName="workspace",this.codeAreaId="codeArea",this},Converter.prototype.main=function(t,e,n){return this.init(),this.generBlocks(t,e),this.renderGrammerName(),this.generToolbox(),this.generMainFile(),this.writeMainFile(n),this},Converter.prototype.generBlocks=function(grammerFile,functions){functions||(functions=[]);var temp_consoleError=console.error;console.error=function(t){throw new Error(t)};var chars=new antlr4.InputStream(grammerFile),lexer=new BlocklyGrammerLexer(chars),tokens=new antlr4.CommonTokenStream(lexer),parser=new BlocklyGrammerParser(tokens);parser.buildParseTrees=!0;var tree=parser.grammarFile();console.error=temp_consoleError;var svisitor=(new SymbolVisitor).init();this.svisitor=svisitor,svisitor.visit(tree),console.log(svisitor),svisitor.checkSymbol();var evisitor=(new EvalVisitor).init(svisitor,grammerFile);return this.evisitor=evisitor,eval(this.evisitor.matchInject("Function_0")),functions[0]&&functions[0].call(this),evisitor.visit(tree),eval(this.evisitor.matchInject("Function_1")),functions[1]&&functions[1].call(this),evisitor.generBlocks(),console.log(evisitor),this.blocks=evisitor.blocks,eval(this.evisitor.matchInject("Function_2")),functions[2]&&functions[2].call(this),this},Converter.prototype.renderGrammerName=function(){this.grammerName=this.svisitor.grammerName,this.generLanguage=this.evisitor.generLanguage;var t=this.grammerName,e=this.generLanguage;return this.OmitedError=tpl.OmitedError(),this.Functions_pre=tpl.Functions_pre(t),this.Functions_xmlText=tpl.Functions_xmlText(t),this.Functions_blocksIniter=tpl.Functions_blocksIniter(t,e),this.mainFileTPL=tpl.mainFileTPL,this},Converter.prototype.generToolbox=function(){eval(this.grammerName+"Functions={};"),eval(this.Functions_xmlText),eval(this.blocks),eval("var blocksobj = "+this.grammerName+"Blocks;"),console.log(blocksobj);var text=[];for(var key in text.push('<xml id="'+this.toolboxId+'" style="display:none">'),text.push('<category name="statement">'),blocksobj){var value=blocksobj[key];value instanceof Array||"value"!==value.type&&(text.push(value.xmlText()),text.push('<sep gap="'+this.toolboxGap+'"></sep>'))}for(var key in text.pop(),text.push("</category>"),text.push('<sep gap="'+3*this.toolboxGap+'"></sep>'),text.push('<category name="value">'),blocksobj){var value=blocksobj[key];value instanceof Array||"statement"!==value.type&&(text.push(value.xmlText()),text.push('<sep gap="'+this.toolboxGap+'"></sep>'))}return text.pop(),text.push("</category>"),text.push("</xml>"),this.toolbox=this.textToPrettyText(text.join("")),this},Converter.prototype.generMainFile=function(){var t=[],e=this.grammerName;t.push(this.blocks),t.push("\n\n"),t.push(this.OmitedError),t.push("\n\n"),t.push(e+"Functions={}\n\n"),t.push(this.evisitor.matchInject("Functions")),t.push("\n\n"),t.push(this.Functions_pre),t.push("\n\n"),t.push(this.Functions_xmlText),t.push("\n\n"),t.push(this.Functions_blocksIniter),t.push("\n\n"),t.push(e+"Functions.blocksIniter();\n\n"),this.mainFile=this.mainFileTPL(e,this.generLanguage,this.blocklyDivId,this.codeAreaId,this.toolbox,this.workSpaceName,this.toolboxId,t.join(""))},Converter.prototype.writeMainFile=function(t){t||(t=this.grammerName+"index.html"),this.createAndDownloadFile(this.mainFile.join(""),t,"html")},Converter.prototype.block=function(t){var e=this.evisitor.expressionRules[t];return e||(e=this.evisitor.statementRules[t]),e&&1!==e.checklength?e.blockjs:null},Converter.prototype.textToPrettyText=function(t){for(var e=t.split("<"),n="",r=1;r<e.length;r++){var i=e[r];"/"==i[0]&&(n=n.substring(2)),e[r]=n+"<"+i,"/"!=i[0]&&"/>"!=i.slice(-2)&&(n+="  ")}var o=e.join("\n");return(o=o.replace(/(<(\w+)\b[^>]*>[^\n]*)\n *<\/\2>/g,"$1</$2>")).replace(/^\n/,"")},Converter.prototype.createAndDownloadFile=function(t,e,n){var r=new Blob([t],{type:"text/"+n}),i=new MouseEvent("click",{view:window,bubbles:!0,cancelable:!1}),o=document.createElement("a");o.href=window.URL.createObjectURL(r),o.download=e,o.textContent="Download file!",o.dispatchEvent(i)},exports.Converter=Converter},function(t,e,n){e.ATN=n(7).ATN,e.ATNDeserializer=n(22).ATNDeserializer,e.LexerATNSimulator=n(37).LexerATNSimulator,e.ParserATNSimulator=n(40).ParserATNSimulator,e.PredictionMode=n(27).PredictionMode},function(t,e,n){var r=n(0).Set,i=n(0).BitSet,o=n(1).Token,s=n(13).ATNConfig,a=(n(2).Interval,n(2).IntervalSet),l=n(3).RuleStopState,u=n(8).RuleTransition,c=n(8).NotSetTransition,h=n(8).WildcardTransition,p=n(8).AbstractPredicateTransition,f=n(6),d=f.predictionContextFromRuleContext,y=f.PredictionContext,g=f.SingletonPredictionContext;function v(t){this.atn=t}v.HIT_PRED=o.INVALID_TYPE,v.prototype.getDecisionLookahead=function(t){if(null===t)return null;for(var e=t.transitions.length,n=[],o=0;o<e;o++){n[o]=new a;var s=new r;this._LOOK(t.transition(o).target,null,y.EMPTY,n[o],s,new i,!1,!1),(0===n[o].length||n[o].contains(v.HIT_PRED))&&(n[o]=null)}return n},v.prototype.LOOK=function(t,e,n){var o=new a,s=null!==(n=n||null)?d(t.atn,n):null;return this._LOOK(t,e,s,o,new r,new i,!0,!0),o},v.prototype._LOOK=function(t,e,n,r,i,a,f,d){var x=new s({state:t,alt:0,context:n},null);if(!i.contains(x)){if(i.add(x),t===e){if(null===n)return void r.addOne(o.EPSILON);if(n.isEmpty()&&d)return void r.addOne(o.EOF)}if(t instanceof l){if(null===n)return void r.addOne(o.EPSILON);if(n.isEmpty()&&d)return void r.addOne(o.EOF);if(n!==y.EMPTY){for(var m=0;m<n.length;m++){var _=this.atn.states[n.getReturnState(m)],T=a.contains(_.ruleIndex);try{a.remove(_.ruleIndex),this._LOOK(_,e,n.getParent(m),r,i,a,f,d)}finally{T&&a.add(_.ruleIndex)}}return}}for(var S=0;S<t.transitions.length;S++){var E=t.transitions[S];if(E.constructor===u){if(a.contains(E.target.ruleIndex))continue;var C=g.create(n,E.followState.stateNumber);try{a.add(E.target.ruleIndex),this._LOOK(E.target,e,C,r,i,a,f,d)}finally{a.remove(E.target.ruleIndex)}}else if(E instanceof p)f?this._LOOK(E.target,e,n,r,i,a,f,d):r.addOne(v.HIT_PRED);else if(E.isEpsilon)this._LOOK(E.target,e,n,r,i,a,f,d);else if(E.constructor===h)r.addRange(o.MIN_USER_TOKEN_TYPE,this.atn.maxTokenType);else{var A=E.label;null!==A&&(E instanceof c&&(A=A.complement(o.MIN_USER_TOKEN_TYPE,this.atn.maxTokenType)),r.addSet(A))}}}},e.LL1Analyzer=v},function(t,e){function n(){}n.LEXER=0,n.PARSER=1,e.ATNType=n},function(t,e,n){var r=n(1).Token,i=n(15).Lexer,o=n(7).ATN,s=n(26).ATNSimulator,a=n(11).DFAState,l=(n(9).ATNConfigSet,n(9).OrderedATNConfigSet),u=n(6).PredictionContext,c=n(6).SingletonPredictionContext,h=n(3).RuleStopState,p=n(13).LexerATNConfig,f=n(8).Transition,d=n(39).LexerActionExecutor,y=n(5).LexerNoViableAltException;function g(t){t.index=-1,t.line=0,t.column=-1,t.dfaState=null}function v(){return g(this),this}function x(t,e,n,r){return s.call(this,e,r),this.decisionToDFA=n,this.recog=t,this.startIndex=-1,this.line=1,this.column=0,this.mode=i.DEFAULT_MODE,this.prevAccept=new v,this}v.prototype.reset=function(){g(this)},x.prototype=Object.create(s.prototype),x.prototype.constructor=x,x.debug=!1,x.dfa_debug=!1,x.MIN_DFA_EDGE=0,x.MAX_DFA_EDGE=127,x.match_calls=0,x.prototype.copyState=function(t){this.column=t.column,this.line=t.line,this.mode=t.mode,this.startIndex=t.startIndex},x.prototype.match=function(t,e){this.match_calls+=1,this.mode=e;var n=t.mark();try{this.startIndex=t.index,this.prevAccept.reset();var r=this.decisionToDFA[e];return null===r.s0?this.matchATN(t):this.execATN(t,r.s0)}finally{t.release(n)}},x.prototype.reset=function(){this.prevAccept.reset(),this.startIndex=-1,this.line=1,this.column=0,this.mode=i.DEFAULT_MODE},x.prototype.matchATN=function(t){var e=this.atn.modeToStartState[this.mode];x.debug&&console.log("matchATN mode "+this.mode+" start: "+e);var n=this.mode,r=this.computeStartState(t,e),i=r.hasSemanticContext;r.hasSemanticContext=!1;var o=this.addDFAState(r);i||(this.decisionToDFA[this.mode].s0=o);var s=this.execATN(t,o);return x.debug&&console.log("DFA after matchATN: "+this.decisionToDFA[n].toLexerString()),s},x.prototype.execATN=function(t,e){x.debug&&console.log("start state closure="+e.configs),e.isAcceptState&&this.captureSimState(this.prevAccept,t,e);for(var n=t.LA(1),i=e;;){x.debug&&console.log("execATN loop starting closure: "+i.configs);var o=this.getExistingTargetState(i,n);if(null===o&&(o=this.computeTargetState(t,i,n)),o===s.ERROR)break;if(n!==r.EOF&&this.consume(t),o.isAcceptState&&(this.captureSimState(this.prevAccept,t,o),n===r.EOF))break;n=t.LA(1),i=o}return this.failOrAccept(this.prevAccept,t,i.configs,n)},x.prototype.getExistingTargetState=function(t,e){if(null===t.edges||e<x.MIN_DFA_EDGE||e>x.MAX_DFA_EDGE)return null;var n=t.edges[e-x.MIN_DFA_EDGE];return void 0===n&&(n=null),x.debug&&null!==n&&console.log("reuse state "+t.stateNumber+" edge to "+n.stateNumber),n},x.prototype.computeTargetState=function(t,e,n){var r=new l;return this.getReachableConfigSet(t,e.configs,r,n),0===r.items.length?(r.hasSemanticContext||this.addDFAEdge(e,n,s.ERROR),s.ERROR):this.addDFAEdge(e,n,null,r)},x.prototype.failOrAccept=function(t,e,n,i){if(null!==this.prevAccept.dfaState){var o=t.dfaState.lexerActionExecutor;return this.accept(e,o,this.startIndex,t.index,t.line,t.column),t.dfaState.prediction}if(i===r.EOF&&e.index===this.startIndex)return r.EOF;throw new y(this.recog,e,this.startIndex,n)},x.prototype.getReachableConfigSet=function(t,e,n,i){for(var s=o.INVALID_ALT_NUMBER,a=0;a<e.items.length;a++){var l=e.items[a],u=l.alt===s;if(!u||!l.passedThroughNonGreedyDecision){x.debug&&console.log("testing %s at %s\n",this.getTokenName(i),l.toString(this.recog,!0));for(var c=0;c<l.state.transitions.length;c++){var h=l.state.transitions[c],f=this.getReachableTarget(h,i);if(null!==f){var d=l.lexerActionExecutor;null!==d&&(d=d.fixOffsetBeforeMatch(t.index-this.startIndex));var y=i===r.EOF,g=new p({state:f,lexerActionExecutor:d},l);this.closure(t,g,n,u,!0,y)&&(s=l.alt)}}}}},x.prototype.accept=function(t,e,n,r,i,o){x.debug&&console.log("ACTION %s\n",e),t.seek(r),this.line=i,this.column=o,null!==e&&null!==this.recog&&e.execute(this.recog,t,n)},x.prototype.getReachableTarget=function(t,e){return t.matches(e,0,i.MAX_CHAR_VALUE)?t.target:null},x.prototype.computeStartState=function(t,e){for(var n=u.EMPTY,r=new l,i=0;i<e.transitions.length;i++){var o=e.transitions[i].target,s=new p({state:o,alt:i+1,context:n},null);this.closure(t,s,r,!1,!1,!1)}return r},x.prototype.closure=function(t,e,n,r,i,o){var s=null;if(x.debug&&console.log("closure("+e.toString(this.recog,!0)+")"),e.state instanceof h){if(x.debug&&(null!==this.recog?console.log("closure at %s rule stop %s\n",this.recog.ruleNames[e.state.ruleIndex],e):console.log("closure at rule stop %s\n",e)),null===e.context||e.context.hasEmptyPath()){if(null===e.context||e.context.isEmpty())return n.add(e),!0;n.add(new p({state:e.state,context:u.EMPTY},e)),r=!0}if(null!==e.context&&!e.context.isEmpty())for(var a=0;a<e.context.length;a++)if(e.context.getReturnState(a)!==u.EMPTY_RETURN_STATE){var l=e.context.getParent(a),c=this.atn.states[e.context.getReturnState(a)];s=new p({state:c,context:l},e),r=this.closure(t,s,n,r,i,o)}return r}e.state.epsilonOnlyTransitions||r&&e.passedThroughNonGreedyDecision||n.add(e);for(var f=0;f<e.state.transitions.length;f++){var d=e.state.transitions[f];null!==(s=this.getEpsilonTarget(t,e,d,n,i,o))&&(r=this.closure(t,s,n,r,i,o))}return r},x.prototype.getEpsilonTarget=function(t,e,n,o,s,a){var l=null;if(n.serializationType===f.RULE){var u=c.create(e.context,n.followState.stateNumber);l=new p({state:n.target,context:u},e)}else{if(n.serializationType===f.PRECEDENCE)throw"Precedence predicates are not supported in lexers.";if(n.serializationType===f.PREDICATE)x.debug&&console.log("EVAL rule "+n.ruleIndex+":"+n.predIndex),o.hasSemanticContext=!0,this.evaluatePredicate(t,n.ruleIndex,n.predIndex,s)&&(l=new p({state:n.target},e));else if(n.serializationType===f.ACTION)if(null===e.context||e.context.hasEmptyPath()){var h=d.append(e.lexerActionExecutor,this.atn.lexerActions[n.actionIndex]);l=new p({state:n.target,lexerActionExecutor:h},e)}else l=new p({state:n.target},e);else n.serializationType===f.EPSILON?l=new p({state:n.target},e):n.serializationType!==f.ATOM&&n.serializationType!==f.RANGE&&n.serializationType!==f.SET||a&&n.matches(r.EOF,0,i.MAX_CHAR_VALUE)&&(l=new p({state:n.target},e))}return l},x.prototype.evaluatePredicate=function(t,e,n,r){if(null===this.recog)return!0;if(!r)return this.recog.sempred(null,e,n);var i=this.column,o=this.line,s=t.index,a=t.mark();try{return this.consume(t),this.recog.sempred(null,e,n)}finally{this.column=i,this.line=o,t.seek(s),t.release(a)}},x.prototype.captureSimState=function(t,e,n){t.index=e.index,t.line=this.line,t.column=this.column,t.dfaState=n},x.prototype.addDFAEdge=function(t,e,n,r){if(void 0===n&&(n=null),void 0===r&&(r=null),null===n&&null!==r){var i=r.hasSemanticContext;if(r.hasSemanticContext=!1,n=this.addDFAState(r),i)return n}return e<x.MIN_DFA_EDGE||e>x.MAX_DFA_EDGE?n:(x.debug&&console.log("EDGE "+t+" -> "+n+" upon "+e),null===t.edges&&(t.edges=[]),t.edges[e-x.MIN_DFA_EDGE]=n,n)},x.prototype.addDFAState=function(t){for(var e=new a(null,t),n=null,r=0;r<t.items.length;r++){var i=t.items[r];if(i.state instanceof h){n=i;break}}null!==n&&(e.isAcceptState=!0,e.lexerActionExecutor=n.lexerActionExecutor,e.prediction=this.atn.ruleToTokenType[n.state.ruleIndex]);var o=this.decisionToDFA[this.mode],s=o.states.get(e);if(null!==s)return s;var l=e;return l.stateNumber=o.states.length,t.setReadonly(!0),l.configs=t,o.states.add(l),l},x.prototype.getDFA=function(t){return this.decisionToDFA[t]},x.prototype.getText=function(t){return t.getText(this.startIndex,t.index-1)},x.prototype.consume=function(t){t.LA(1)==="\n".charCodeAt(0)?(this.line+=1,this.column=0):this.column+=1,t.consume()},x.prototype.getTokenName=function(t){return-1===t?"EOF":"'"+String.fromCharCode(t)+"'"},e.LexerATNSimulator=x},function(t,e,n){var r=n(1).CommonToken;function i(){return this}function o(t){return i.call(this),this.copyText=void 0!==t&&t,this}o.prototype=Object.create(i.prototype),o.prototype.constructor=o,o.DEFAULT=new o,o.prototype.create=function(t,e,n,i,o,s,a,l){var u=new r(t,e,i,o,s);return u.line=a,u.column=l,null!==n?u.text=n:this.copyText&&null!==t[1]&&(u.text=t[1].getText(o,s)),u},o.prototype.createThin=function(t,e){var n=new r(null,t);return n.text=e,n},e.CommonTokenFactory=o},function(t,e,n){var r=n(0).hashStuff,i=n(24).LexerIndexedCustomAction;function o(t){return this.lexerActions=null===t?[]:t,this.cachedHashCode=r(t),this}o.append=function(t,e){return new o(null===t?[e]:t.lexerActions.concat([e]))},o.prototype.fixOffsetBeforeMatch=function(t){for(var e=null,n=0;n<this.lexerActions.length;n++)!this.lexerActions[n].isPositionDependent||this.lexerActions[n]instanceof i||(null===e&&(e=this.lexerActions.concat([])),e[n]=new i(t,this.lexerActions[n]));return null===e?this:new o(e)},o.prototype.execute=function(t,e,n){var r=!1,o=e.index;try{for(var s=0;s<this.lexerActions.length;s++){var a=this.lexerActions[s];if(a instanceof i){var l=a.offset;e.seek(n+l),a=a.action,r=n+l!==o}else a.isPositionDependent&&(e.seek(o),r=!1);a.execute(t)}}finally{r&&e.seek(o)}},o.prototype.hashCode=function(){return this.cachedHashCode},o.prototype.updateHashCode=function(t){t.update(this.cachedHashCode)},o.prototype.equals=function(t){if(this===t)return!0;if(t instanceof o){if(this.cachedHashCode!=t.cachedHashCode)return!1;if(this.lexerActions.length!=t.lexerActions.length)return!1;for(var e=this.lexerActions.length,n=0;n<e;++n)if(!this.lexerActions[n].equals(t.lexerActions[n]))return!1;return!0}return!1},e.LexerActionExecutor=o},function(t,e,n){var r=n(0),i=r.Set,o=r.BitSet,s=r.DoubleDict,a=n(7).ATN,l=n(3).ATNState,u=n(13).ATNConfig,c=n(9).ATNConfigSet,h=n(1).Token,p=n(11).DFAState,f=n(11).PredPrediction,d=n(26).ATNSimulator,y=n(27).PredictionMode,g=n(14).RuleContext,v=(n(18).ParserRuleContext,n(10).SemanticContext),x=(n(3).StarLoopEntryState,n(3).RuleStopState),m=n(6).PredictionContext,_=n(2).Interval,T=n(8),S=T.Transition,E=T.SetTransition,C=T.NotSetTransition,A=T.RuleTransition,b=T.ActionTransition,k=n(5).NoViableAltException,R=n(6).SingletonPredictionContext,L=n(6).predictionContextFromRuleContext;function I(t,e,n,r){return d.call(this,e,r),this.parser=t,this.decisionToDFA=n,this.predictionMode=y.LL,this._input=null,this._startIndex=0,this._outerContext=null,this._dfa=null,this.mergeCache=null,this}I.prototype=Object.create(d.prototype),I.prototype.constructor=I,I.prototype.debug=!1,I.prototype.debug_closure=!1,I.prototype.debug_add=!1,I.prototype.debug_list_atn_decisions=!1,I.prototype.dfa_debug=!1,I.prototype.retry_debug=!1,I.prototype.reset=function(){},I.prototype.adaptivePredict=function(t,e,n){(this.debug||this.debug_list_atn_decisions)&&console.log("adaptivePredict decision "+e+" exec LA(1)=="+this.getLookaheadName(t)+" line "+t.LT(1).line+":"+t.LT(1).column),this._input=t,this._startIndex=t.index,this._outerContext=n;var r=this.decisionToDFA[e];this._dfa=r;var i=t.mark(),o=t.index;try{var s;if(null===(s=r.precedenceDfa?r.getPrecedenceStartState(this.parser.getPrecedence()):r.s0)){null===n&&(n=g.EMPTY),(this.debug||this.debug_list_atn_decisions)&&console.log("predictATN decision "+r.decision+" exec LA(1)=="+this.getLookaheadName(t)+", outerContext="+n.toString(this.parser.ruleNames));var a=this.computeStartState(r.atnStartState,g.EMPTY,!1);r.precedenceDfa?(r.s0.configs=a,a=this.applyPrecedenceFilter(a),s=this.addDFAState(r,new p(null,a)),r.setPrecedenceStartState(this.parser.getPrecedence(),s)):(s=this.addDFAState(r,new p(null,a)),r.s0=s)}var l=this.execATN(r,s,t,o,n);return this.debug&&console.log("DFA after predictATN: "+r.toString(this.parser.literalNames)),l}finally{this._dfa=null,this.mergeCache=null,t.seek(o),t.release(i)}},I.prototype.execATN=function(t,e,n,r,i){var o;(this.debug||this.debug_list_atn_decisions)&&console.log("execATN decision "+t.decision+" exec LA(1)=="+this.getLookaheadName(n)+" line "+n.LT(1).line+":"+n.LT(1).column);var s=e;this.debug&&console.log("s0 = "+e);for(var l=n.LA(1);;){var u=this.getExistingTargetState(s,l);if(null===u&&(u=this.computeTargetState(t,s,l)),u===d.ERROR){var c=this.noViableAlt(n,i,s.configs,r);if(n.seek(r),(o=this.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(s.configs,i))!==a.INVALID_ALT_NUMBER)return o;throw c}if(u.requiresFullContext&&this.predictionMode!==y.SLL){var p=null;if(null!==u.predicates){this.debug&&console.log("DFA state has preds in DFA sim LL failover");var f=n.index;if(f!==r&&n.seek(r),1===(p=this.evalSemanticContext(u.predicates,i,!0)).length)return this.debug&&console.log("Full LL avoided"),p.minValue();f!==r&&n.seek(f)}this.dfa_debug&&console.log("ctx sensitive state "+i+" in "+u);var g=this.computeStartState(t.atnStartState,i,!0);return this.reportAttemptingFullContext(t,p,u.configs,r,n.index),o=this.execATNWithFullContext(t,u,g,n,r,i)}if(u.isAcceptState){if(null===u.predicates)return u.prediction;var v=n.index;n.seek(r);var x=this.evalSemanticContext(u.predicates,i,!0);if(0===x.length)throw this.noViableAlt(n,i,u.configs,r);return 1===x.length?x.minValue():(this.reportAmbiguity(t,u,r,v,!1,x,u.configs),x.minValue())}s=u,l!==h.EOF&&(n.consume(),l=n.LA(1))}},I.prototype.getExistingTargetState=function(t,e){var n=t.edges;return null===n?null:n[e+1]||null},I.prototype.computeTargetState=function(t,e,n){var i=this.computeReachSet(e.configs,n,!1);if(null===i)return this.addDFAEdge(t,e,n,d.ERROR),d.ERROR;var o=new p(null,i),s=this.getUniqueAlt(i);if(this.debug){var l=y.getConflictingAltSubsets(i);console.log("SLL altSubSets="+r.arrayToString(l)+", previous="+e.configs+", configs="+i+", predict="+s+", allSubsetsConflict="+y.allSubsetsConflict(l)+", conflictingAlts="+this.getConflictingAlts(i))}return s!==a.INVALID_ALT_NUMBER?(o.isAcceptState=!0,o.configs.uniqueAlt=s,o.prediction=s):y.hasSLLConflictTerminatingPrediction(this.predictionMode,i)&&(o.configs.conflictingAlts=this.getConflictingAlts(i),o.requiresFullContext=!0,o.isAcceptState=!0,o.prediction=o.configs.conflictingAlts.minValue()),o.isAcceptState&&o.configs.hasSemanticContext&&(this.predicateDFAState(o,this.atn.getDecisionState(t.decision)),null!==o.predicates&&(o.prediction=a.INVALID_ALT_NUMBER)),o=this.addDFAEdge(t,e,n,o)},I.prototype.predicateDFAState=function(t,e){var n=e.transitions.length,r=this.getConflictingAltsOrUniqueAlt(t.configs),i=this.getPredsForAmbigAlts(r,t.configs,n);null!==i?(t.predicates=this.getPredicatePredictions(r,i),t.prediction=a.INVALID_ALT_NUMBER):t.prediction=r.minValue()},I.prototype.execATNWithFullContext=function(t,e,n,r,i,o){(this.debug||this.debug_list_atn_decisions)&&console.log("execATNWithFullContext "+n);var s=!1,l=null,u=n;r.seek(i);for(var c=r.LA(1),p=-1;;){if(null===(l=this.computeReachSet(u,c,!0))){var f=this.noViableAlt(r,o,u,i);r.seek(i);var d=this.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(u,o);if(d!==a.INVALID_ALT_NUMBER)return d;throw f}var g=y.getConflictingAltSubsets(l);if(this.debug&&console.log("LL altSubSets="+g+", predict="+y.getUniqueAlt(g)+", resolvesToJustOneViableAlt="+y.resolvesToJustOneViableAlt(g)),l.uniqueAlt=this.getUniqueAlt(l),l.uniqueAlt!==a.INVALID_ALT_NUMBER){p=l.uniqueAlt;break}if(this.predictionMode!==y.LL_EXACT_AMBIG_DETECTION){if((p=y.resolvesToJustOneViableAlt(g))!==a.INVALID_ALT_NUMBER)break}else if(y.allSubsetsConflict(g)&&y.allSubsetsEqual(g)){s=!0,p=y.getSingleViableAlt(g);break}u=l,c!==h.EOF&&(r.consume(),c=r.LA(1))}return l.uniqueAlt!==a.INVALID_ALT_NUMBER?(this.reportContextSensitivity(t,p,l,i,r.index),p):(this.reportAmbiguity(t,e,i,r.index,s,null,l),p)},I.prototype.computeReachSet=function(t,e,n){this.debug&&console.log("in computeReachSet, starting closure: "+t),null===this.mergeCache&&(this.mergeCache=new s);for(var r=new c(n),o=null,l=0;l<t.items.length;l++){var p=t.items[l];if(this.debug_add&&console.log("testing "+this.getTokenName(e)+" at "+p),p.state instanceof x)(n||e===h.EOF)&&(null===o&&(o=[]),o.push(p),this.debug_add&&console.log("added "+p+" to skippedStopStates"));else for(var f=0;f<p.state.transitions.length;f++){var d=p.state.transitions[f],g=this.getReachableTarget(d,e);if(null!==g){var v=new u({state:g},p);r.add(v,this.mergeCache),this.debug_add&&console.log("added "+v+" to intermediate")}}}var m=null;if(null===o&&e!==h.EOF&&(1===r.items.length?m=r:this.getUniqueAlt(r)!==a.INVALID_ALT_NUMBER&&(m=r)),null===m){m=new c(n);for(var _=new i,T=e===h.EOF,S=0;S<r.items.length;S++)this.closure(r.items[S],m,_,!1,n,T)}if(e===h.EOF&&(m=this.removeAllConfigsNotInRuleStopState(m,m===r)),!(null===o||n&&y.hasConfigInRuleStopState(m)))for(var E=0;E<o.length;E++)m.add(o[E],this.mergeCache);return 0===m.items.length?null:m},I.prototype.removeAllConfigsNotInRuleStopState=function(t,e){if(y.allConfigsInRuleStopStates(t))return t;for(var n=new c(t.fullCtx),r=0;r<t.items.length;r++){var i=t.items[r];if(i.state instanceof x)n.add(i,this.mergeCache);else if(e&&i.state.epsilonOnlyTransitions)if(this.atn.nextTokens(i.state).contains(h.EPSILON)){var o=this.atn.ruleToStopState[i.state.ruleIndex];n.add(new u({state:o},i),this.mergeCache)}}return n},I.prototype.computeStartState=function(t,e,n){for(var r=L(this.atn,e),o=new c(n),s=0;s<t.transitions.length;s++){var a=t.transitions[s].target,l=new u({state:a,alt:s+1,context:r},null),h=new i;this.closure(l,o,h,!0,n,!1)}return o},I.prototype.applyPrecedenceFilter=function(t){for(var e,n=[],r=new c(t.fullCtx),i=0;i<t.items.length;i++)if(1===(e=t.items[i]).alt){var o=e.semanticContext.evalPrecedence(this.parser,this._outerContext);null!==o&&(n[e.state.stateNumber]=e.context,o!==e.semanticContext?r.add(new u({semanticContext:o},e),this.mergeCache):r.add(e,this.mergeCache))}for(i=0;i<t.items.length;i++)if(1!==(e=t.items[i]).alt){if(!e.precedenceFilterSuppressed){var s=n[e.state.stateNumber]||null;if(null!==s&&s.equals(e.context))continue}r.add(e,this.mergeCache)}return r},I.prototype.getReachableTarget=function(t,e){return t.matches(e,0,this.atn.maxTokenType)?t.target:null},I.prototype.getPredsForAmbigAlts=function(t,e,n){for(var i=[],o=0;o<e.items.length;o++){var s=e.items[o];t.contains(s.alt)&&(i[s.alt]=v.orContext(i[s.alt]||null,s.semanticContext))}var a=0;for(o=1;o<n+1;o++){var l=i[o]||null;null===l?i[o]=v.NONE:l!==v.NONE&&(a+=1)}return 0===a&&(i=null),this.debug&&console.log("getPredsForAmbigAlts result "+r.arrayToString(i)),i},I.prototype.getPredicatePredictions=function(t,e){for(var n=[],r=!1,i=1;i<e.length;i++){var o=e[i];null!==t&&t.contains(i)&&n.push(new f(o,i)),o!==v.NONE&&(r=!0)}return r?n:null},I.prototype.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule=function(t,e){var n=this.splitAccordingToSemanticValidity(t,e),r=n[0],i=n[1],o=this.getAltThatFinishedDecisionEntryRule(r);return o!==a.INVALID_ALT_NUMBER?o:i.items.length>0&&(o=this.getAltThatFinishedDecisionEntryRule(i))!==a.INVALID_ALT_NUMBER?o:a.INVALID_ALT_NUMBER},I.prototype.getAltThatFinishedDecisionEntryRule=function(t){for(var e=[],n=0;n<t.items.length;n++){var r=t.items[n];(r.reachesIntoOuterContext>0||r.state instanceof x&&r.context.hasEmptyPath())&&e.indexOf(r.alt)<0&&e.push(r.alt)}return 0===e.length?a.INVALID_ALT_NUMBER:Math.min.apply(null,e)},I.prototype.splitAccordingToSemanticValidity=function(t,e){for(var n=new c(t.fullCtx),r=new c(t.fullCtx),i=0;i<t.items.length;i++){var o=t.items[i];if(o.semanticContext!==v.NONE)o.semanticContext.evaluate(this.parser,e)?n.add(o):r.add(o);else n.add(o)}return[n,r]},I.prototype.evalSemanticContext=function(t,e,n){for(var r=new o,i=0;i<t.length;i++){var s=t[i];if(s.pred!==v.NONE){var a=s.pred.evaluate(this.parser,e);if((this.debug||this.dfa_debug)&&console.log("eval pred "+s+"="+a),a&&((this.debug||this.dfa_debug)&&console.log("PREDICT "+s.alt),r.add(s.alt),!n))break}else if(r.add(s.alt),!n)break}return r},I.prototype.closure=function(t,e,n,r,i,o){this.closureCheckingStopState(t,e,n,r,i,0,o)},I.prototype.closureCheckingStopState=function(t,e,n,r,i,o,s){if((this.debug||this.debug_closure)&&(console.log("closure("+t.toString(this.parser,!0)+")"),t.reachesIntoOuterContext>50))throw"problem";if(t.state instanceof x){if(!t.context.isEmpty()){for(var a=0;a<t.context.length;a++)if(t.context.getReturnState(a)!==m.EMPTY_RETURN_STATE){var l=this.atn.states[t.context.getReturnState(a)],c=t.context.getParent(a),h={state:l,alt:t.alt,context:c,semanticContext:t.semanticContext},p=new u(h,null);p.reachesIntoOuterContext=t.reachesIntoOuterContext,this.closureCheckingStopState(p,e,n,r,i,o-1,s)}else{if(i){e.add(new u({state:t.state,context:m.EMPTY},t),this.mergeCache);continue}this.debug&&console.log("FALLING off rule "+this.getRuleName(t.state.ruleIndex)),this.closure_(t,e,n,r,i,o,s)}return}if(i)return void e.add(t,this.mergeCache);this.debug&&console.log("FALLING off rule "+this.getRuleName(t.state.ruleIndex))}this.closure_(t,e,n,r,i,o,s)},I.prototype.closure_=function(t,e,n,r,i,o,s){var a=t.state;a.epsilonOnlyTransitions||e.add(t,this.mergeCache);for(var l=0;l<a.transitions.length;l++)if(0!=l||!this.canDropLoopEntryEdgeInLeftRecursiveRule(t)){var u=a.transitions[l],c=r&&!(u instanceof b),h=this.getEpsilonTarget(t,u,c,0===o,i,s);if(null!==h){if(!u.isEpsilon&&n.add(h)!==h)continue;var p=o;if(t.state instanceof x){if(n.add(h)!==h)continue;null!==this._dfa&&this._dfa.precedenceDfa&&u.outermostPrecedenceReturn===this._dfa.atnStartState.ruleIndex&&(h.precedenceFilterSuppressed=!0),h.reachesIntoOuterContext+=1,e.dipsIntoOuterContext=!0,p-=1,this.debug&&console.log("dips into outer ctx: "+h)}else u instanceof A&&p>=0&&(p+=1);this.closureCheckingStopState(h,e,n,c,i,p,s)}}},I.prototype.canDropLoopEntryEdgeInLeftRecursiveRule=function(t){var e=t.state;if(e.stateType!=l.STAR_LOOP_ENTRY)return!1;if(e.stateType!=l.STAR_LOOP_ENTRY||!e.isPrecedenceDecision||t.context.isEmpty()||t.context.hasEmptyPath())return!1;for(var n=t.context.length,r=0;r<n;r++){if((s=this.atn.states[t.context.getReturnState(r)]).ruleIndex!=e.ruleIndex)return!1}var i=e.transitions[0].target.endState.stateNumber,o=this.atn.states[i];for(r=0;r<n;r++){var s,a=t.context.getReturnState(r);if(1!=(s=this.atn.states[a]).transitions.length||!s.transitions[0].isEpsilon)return!1;var u=s.transitions[0].target;if((s.stateType!=l.BLOCK_END||u!=e)&&(s!=o&&u!=o&&(u.stateType!=l.BLOCK_END||1!=u.transitions.length||!u.transitions[0].isEpsilon||u.transitions[0].target!=e)))return!1}return!0},I.prototype.getRuleName=function(t){return null!==this.parser&&t>=0?this.parser.ruleNames[t]:"<rule "+t+">"},I.prototype.getEpsilonTarget=function(t,e,n,r,i,o){switch(e.serializationType){case S.RULE:return this.ruleTransition(t,e);case S.PRECEDENCE:return this.precedenceTransition(t,e,n,r,i);case S.PREDICATE:return this.predTransition(t,e,n,r,i);case S.ACTION:return this.actionTransition(t,e);case S.EPSILON:return new u({state:e.target},t);case S.ATOM:case S.RANGE:case S.SET:return o&&e.matches(h.EOF,0,1)?new u({state:e.target},t):null;default:return null}},I.prototype.actionTransition=function(t,e){if(this.debug){var n=-1==e.actionIndex?65535:e.actionIndex;console.log("ACTION edge "+e.ruleIndex+":"+n)}return new u({state:e.target},t)},I.prototype.precedenceTransition=function(t,e,n,i,o){this.debug&&(console.log("PRED (collectPredicates="+n+") "+e.precedence+">=_p, ctx dependent=true"),null!==this.parser&&console.log("context surrounding pred is "+r.arrayToString(this.parser.getRuleInvocationStack())));var s=null;if(n&&i)if(o){var a=this._input.index;this._input.seek(this._startIndex);var l=e.getPredicate().evaluate(this.parser,this._outerContext);this._input.seek(a),l&&(s=new u({state:e.target},t))}else{var c=v.andContext(t.semanticContext,e.getPredicate());s=new u({state:e.target,semanticContext:c},t)}else s=new u({state:e.target},t);return this.debug&&console.log("config from pred transition="+s),s},I.prototype.predTransition=function(t,e,n,i,o){this.debug&&(console.log("PRED (collectPredicates="+n+") "+e.ruleIndex+":"+e.predIndex+", ctx dependent="+e.isCtxDependent),null!==this.parser&&console.log("context surrounding pred is "+r.arrayToString(this.parser.getRuleInvocationStack())));var s=null;if(n&&(e.isCtxDependent&&i||!e.isCtxDependent))if(o){var a=this._input.index;this._input.seek(this._startIndex);var l=e.getPredicate().evaluate(this.parser,this._outerContext);this._input.seek(a),l&&(s=new u({state:e.target},t))}else{var c=v.andContext(t.semanticContext,e.getPredicate());s=new u({state:e.target,semanticContext:c},t)}else s=new u({state:e.target},t);return this.debug&&console.log("config from pred transition="+s),s},I.prototype.ruleTransition=function(t,e){this.debug&&console.log("CALL rule "+this.getRuleName(e.target.ruleIndex)+", ctx="+t.context);var n=e.followState,r=R.create(t.context,n.stateNumber);return new u({state:e.target,context:r},t)},I.prototype.getConflictingAlts=function(t){var e=y.getConflictingAltSubsets(t);return y.getAlts(e)},I.prototype.getConflictingAltsOrUniqueAlt=function(t){var e=null;return t.uniqueAlt!==a.INVALID_ALT_NUMBER?(e=new o).add(t.uniqueAlt):e=t.conflictingAlts,e},I.prototype.getTokenName=function(t){if(t===h.EOF)return"EOF";if(null!==this.parser&&null!==this.parser.literalNames){if(!(t>=this.parser.literalNames.length&&t>=this.parser.symbolicNames.length))return(this.parser.literalNames[t]||this.parser.symbolicNames[t])+"<"+t+">";console.log(t+" ttype out of range: "+this.parser.literalNames),console.log(""+this.parser.getInputStream().getTokens())}return""+t},I.prototype.getLookaheadName=function(t){return this.getTokenName(t.LA(1))},I.prototype.dumpDeadEndConfigs=function(t){console.log("dead end configs: ");for(var e=t.getDeadEndConfigs(),n=0;n<e.length;n++){var r=e[n],i="no edges";if(r.state.transitions.length>0){var o=r.state.transitions[0];if(o instanceof AtomTransition)i="Atom "+this.getTokenName(o.label);else if(o instanceof E){i=(o instanceof C?"~":"")+"Set "+o.set}}console.error(r.toString(this.parser,!0)+":"+i)}},I.prototype.noViableAlt=function(t,e,n,r){return new k(this.parser,t,t.get(r),t.LT(1),n,e)},I.prototype.getUniqueAlt=function(t){for(var e=a.INVALID_ALT_NUMBER,n=0;n<t.items.length;n++){var r=t.items[n];if(e===a.INVALID_ALT_NUMBER)e=r.alt;else if(r.alt!==e)return a.INVALID_ALT_NUMBER}return e},I.prototype.addDFAEdge=function(t,e,n,r){if(this.debug&&console.log("EDGE "+e+" -> "+r+" upon "+this.getTokenName(n)),null===r)return null;if(r=this.addDFAState(t,r),null===e||n<-1||n>this.atn.maxTokenType)return r;if(null===e.edges&&(e.edges=[]),e.edges[n+1]=r,this.debug){var i=null===this.parser?null:this.parser.literalNames,o=null===this.parser?null:this.parser.symbolicNames;console.log("DFA=\n"+t.toString(i,o))}return r},I.prototype.addDFAState=function(t,e){if(e==d.ERROR)return e;var n=t.states.get(e);return null!==n?n:(e.stateNumber=t.states.length,e.configs.readOnly||(e.configs.optimizeConfigs(this),e.configs.setReadonly(!0)),t.states.add(e),this.debug&&console.log("adding new DFA state: "+e),e)},I.prototype.reportAttemptingFullContext=function(t,e,n,r,i){if(this.debug||this.retry_debug){var o=new _(r,i+1);console.log("reportAttemptingFullContext decision="+t.decision+":"+n+", input="+this.parser.getTokenStream().getText(o))}null!==this.parser&&this.parser.getErrorListenerDispatch().reportAttemptingFullContext(this.parser,t,r,i,e,n)},I.prototype.reportContextSensitivity=function(t,e,n,r,i){if(this.debug||this.retry_debug){var o=new _(r,i+1);console.log("reportContextSensitivity decision="+t.decision+":"+n+", input="+this.parser.getTokenStream().getText(o))}null!==this.parser&&this.parser.getErrorListenerDispatch().reportContextSensitivity(this.parser,t,r,i,e,n)},I.prototype.reportAmbiguity=function(t,e,n,r,i,o,s){if(this.debug||this.retry_debug){var a=new _(n,r+1);console.log("reportAmbiguity "+o+":"+s+", input="+this.parser.getTokenStream().getText(a))}null!==this.parser&&this.parser.getErrorListenerDispatch().reportAmbiguity(this.parser,t,n,r,i,o,s)},e.ParserATNSimulator=I},function(t,e,n){e.DFA=n(42).DFA,e.DFASerializer=n(17).DFASerializer,e.LexerDFASerializer=n(17).LexerDFASerializer,e.PredPrediction=n(11).PredPrediction},function(t,e,n){var r=n(0).Set,i=n(11).DFAState,o=n(3).StarLoopEntryState,s=n(9).ATNConfigSet,a=n(17).DFASerializer,l=n(17).LexerDFASerializer;function u(t,e){if(void 0===e&&(e=0),this.atnStartState=t,this.decision=e,this._states=new r,this.s0=null,this.precedenceDfa=!1,t instanceof o&&t.isPrecedenceDecision){this.precedenceDfa=!0;var n=new i(null,new s);n.edges=[],n.isAcceptState=!1,n.requiresFullContext=!1,this.s0=n}return this}u.prototype.getPrecedenceStartState=function(t){if(!this.precedenceDfa)throw"Only precedence DFAs may contain a precedence start state.";return t<0||t>=this.s0.edges.length?null:this.s0.edges[t]||null},u.prototype.setPrecedenceStartState=function(t,e){if(!this.precedenceDfa)throw"Only precedence DFAs may contain a precedence start state.";t<0||(this.s0.edges[t]=e)},u.prototype.setPrecedenceDfa=function(t){if(this.precedenceDfa!==t){if(this._states=new DFAStatesSet,t){var e=new i(null,new s);e.edges=[],e.isAcceptState=!1,e.requiresFullContext=!1,this.s0=e}else this.s0=null;this.precedenceDfa=t}},Object.defineProperty(u.prototype,"states",{get:function(){return this._states}}),u.prototype.sortedStates=function(){return this._states.values().sort(function(t,e){return t.stateNumber-e.stateNumber})},u.prototype.toString=function(t,e){return t=t||null,e=e||null,null===this.s0?"":new a(this,t,e).toString()},u.prototype.toLexerString=function(){return null===this.s0?"":new l(this).toString()},e.DFA=u},function(t,e,n){var r=n(4);e.Trees=n(21).Trees,e.RuleNode=r.RuleNode,e.ParseTreeListener=r.ParseTreeListener,e.ParseTreeVisitor=r.ParseTreeVisitor,e.ParseTreeWalker=r.ParseTreeWalker},function(t,e,n){e.RecognitionException=n(5).RecognitionException,e.NoViableAltException=n(5).NoViableAltException,e.LexerNoViableAltException=n(5).LexerNoViableAltException,e.InputMismatchException=n(5).InputMismatchException,e.FailedPredicateException=n(5).FailedPredicateException,e.DiagnosticErrorListener=n(45).DiagnosticErrorListener,e.BailErrorStrategy=n(30).BailErrorStrategy,e.ErrorListener=n(16).ErrorListener},function(t,e,n){var r=n(0).BitSet,i=n(16).ErrorListener,o=n(2).Interval;function s(t){return i.call(this),t=t||!0,this.exactOnly=t,this}s.prototype=Object.create(i.prototype),s.prototype.constructor=s,s.prototype.reportAmbiguity=function(t,e,n,r,i,s,a){if(!this.exactOnly||i){var l="reportAmbiguity d="+this.getDecisionDescription(t,e)+": ambigAlts="+this.getConflictingAlts(s,a)+", input='"+t.getTokenStream().getText(new o(n,r))+"'";t.notifyErrorListeners(l)}},s.prototype.reportAttemptingFullContext=function(t,e,n,r,i,s){var a="reportAttemptingFullContext d="+this.getDecisionDescription(t,e)+", input='"+t.getTokenStream().getText(new o(n,r))+"'";t.notifyErrorListeners(a)},s.prototype.reportContextSensitivity=function(t,e,n,r,i,s){var a="reportContextSensitivity d="+this.getDecisionDescription(t,e)+", input='"+t.getTokenStream().getText(new o(n,r))+"'";t.notifyErrorListeners(a)},s.prototype.getDecisionDescription=function(t,e){var n=e.decision,r=e.atnStartState.ruleIndex,i=t.ruleNames;if(r<0||r>=i.length)return""+n;var o=i[r]||null;return null===o||0===o.length?""+n:n+" ("+o+")"},s.prototype.getConflictingAlts=function(t,e){if(null!==t)return t;for(var n=new r,i=0;i<e.items.length;i++)n.add(e.items[i].alt);return"{"+n.values().join(", ")+"}"},e.DiagnosticErrorListener=s},function(t,e,n){var r=n(19).InputStream,i="undefined"==typeof window&&"undefined"==typeof importScripts?n(31):null,o={fromString:function(t){return new r(t,!0)},fromBlob:function(t,e,n,i){var o=FileReader();o.onload=function(t){var e=new r(t.target.result,!0);n(e)},o.onerror=i,o.readAsText(t,e)},fromBuffer:function(t,e){return new r(t.toString(e),!0)},fromPath:function(t,e,n){i.readFile(t,e,function(t,e){var i=null;null!==e&&(i=new r(e,!0)),n(t,i)})},fromPathSync:function(t,e){var n=i.readFileSync(t,e);return new r(n,!0)}};e.CharStreams=o},function(t,e,n){var r=n(19).InputStream,i="undefined"==typeof window&&"undefined"==typeof importScripts?n(31):null;function o(t,e){var n=i.readFileSync(t,"utf8");return r.call(this,n,e),this.fileName=t,this}o.prototype=Object.create(r.prototype),o.prototype.constructor=o,e.FileStream=o},function(t,e,n){var r=n(1).Token,i=n(49).BufferedTokenStream;function o(t,e){return i.call(this,t),this.channel=void 0===e?r.DEFAULT_CHANNEL:e,this}o.prototype=Object.create(i.prototype),o.prototype.constructor=o,o.prototype.adjustSeekIndex=function(t){return this.nextTokenOnChannel(t,this.channel)},o.prototype.LB=function(t){if(0===t||this.index-t<0)return null;for(var e=this.index,n=1;n<=t;)e=this.previousTokenOnChannel(e-1,this.channel),n+=1;return e<0?null:this.tokens[e]},o.prototype.LT=function(t){if(this.lazyInit(),0===t)return null;if(t<0)return this.LB(-t);for(var e=this.index,n=1;n<t;)this.sync(e+1)&&(e=this.nextTokenOnChannel(e+1,this.channel)),n+=1;return this.tokens[e]},o.prototype.getNumberOfOnChannelTokens=function(){var t=0;this.fill();for(var e=0;e<this.tokens.length;e++){var n=this.tokens[e];if(n.channel===this.channel&&(t+=1),n.type===r.EOF)break}return t},e.CommonTokenStream=o},function(t,e,n){var r=n(1).Token,i=n(15).Lexer,o=n(2).Interval;function s(){return this}function a(t){return s.call(this),this.tokenSource=t,this.tokens=[],this.index=-1,this.fetchedEOF=!1,this}a.prototype=Object.create(s.prototype),a.prototype.constructor=a,a.prototype.mark=function(){return 0},a.prototype.release=function(t){},a.prototype.reset=function(){this.seek(0)},a.prototype.seek=function(t){this.lazyInit(),this.index=this.adjustSeekIndex(t)},a.prototype.get=function(t){return this.lazyInit(),this.tokens[t]},a.prototype.consume=function(){if(!(this.index>=0&&(this.fetchedEOF?this.index<this.tokens.length-1:this.index<this.tokens.length))&&this.LA(1)===r.EOF)throw"cannot consume EOF";this.sync(this.index+1)&&(this.index=this.adjustSeekIndex(this.index+1))},a.prototype.sync=function(t){var e=t-this.tokens.length+1;return!(e>0)||this.fetch(e)>=e},a.prototype.fetch=function(t){if(this.fetchedEOF)return 0;for(var e=0;e<t;e++){var n=this.tokenSource.nextToken();if(n.tokenIndex=this.tokens.length,this.tokens.push(n),n.type===r.EOF)return this.fetchedEOF=!0,e+1}return t},a.prototype.getTokens=function(t,e,n){if(void 0===n&&(n=null),t<0||e<0)return null;this.lazyInit();var i=[];e>=this.tokens.length&&(e=this.tokens.length-1);for(var o=t;o<e;o++){var s=this.tokens[o];if(s.type===r.EOF)break;(null===n||n.contains(s.type))&&i.push(s)}return i},a.prototype.LA=function(t){return this.LT(t).type},a.prototype.LB=function(t){return this.index-t<0?null:this.tokens[this.index-t]},a.prototype.LT=function(t){if(this.lazyInit(),0===t)return null;if(t<0)return this.LB(-t);var e=this.index+t-1;return this.sync(e),e>=this.tokens.length?this.tokens[this.tokens.length-1]:this.tokens[e]},a.prototype.adjustSeekIndex=function(t){return t},a.prototype.lazyInit=function(){-1===this.index&&this.setup()},a.prototype.setup=function(){this.sync(0),this.index=this.adjustSeekIndex(0)},a.prototype.setTokenSource=function(t){this.tokenSource=t,this.tokens=[],this.index=-1,this.fetchedEOF=!1},a.prototype.nextTokenOnChannel=function(t,e){if(this.sync(t),t>=this.tokens.length)return-1;for(var n=this.tokens[t];n.channel!==this.channel;){if(n.type===r.EOF)return-1;t+=1,this.sync(t),n=this.tokens[t]}return t},a.prototype.previousTokenOnChannel=function(t,e){for(;t>=0&&this.tokens[t].channel!==e;)t-=1;return t},a.prototype.getHiddenTokensToRight=function(t,e){if(void 0===e&&(e=-1),this.lazyInit(),t<0||t>=this.tokens.length)throw t+" not in 0.."+this.tokens.length-1;var n=this.nextTokenOnChannel(t+1,i.DEFAULT_TOKEN_CHANNEL),r=t+1,o=-1===n?this.tokens.length-1:n;return this.filterForChannel(r,o,e)},a.prototype.getHiddenTokensToLeft=function(t,e){if(void 0===e&&(e=-1),this.lazyInit(),t<0||t>=this.tokens.length)throw t+" not in 0.."+this.tokens.length-1;var n=this.previousTokenOnChannel(t-1,i.DEFAULT_TOKEN_CHANNEL);if(n===t-1)return null;var r=n+1,o=t-1;return this.filterForChannel(r,o,e)},a.prototype.filterForChannel=function(t,e,n){for(var r=[],o=t;o<e+1;o++){var s=this.tokens[o];-1===n?s.channel!==i.DEFAULT_TOKEN_CHANNEL&&r.push(s):s.channel===n&&r.push(s)}return 0===r.length?null:r},a.prototype.getSourceName=function(){return this.tokenSource.getSourceName()},a.prototype.getText=function(t){this.lazyInit(),this.fill(),void 0!==t&&null!==t||(t=new o(0,this.tokens.length-1));var e=t.start;e instanceof r&&(e=e.tokenIndex);var n=t.stop;if(n instanceof r&&(n=n.tokenIndex),null===e||null===n||e<0||n<0)return"";n>=this.tokens.length&&(n=this.tokens.length-1);for(var i="",s=e;s<n+1;s++){var a=this.tokens[s];if(a.type===r.EOF)break;i+=a.text}return i},a.prototype.fill=function(){for(this.lazyInit();1e3===this.fetch(1e3););},e.BufferedTokenStream=a},function(t,e,n){var r=n(1).Token,i=n(4).ParseTreeListener,o=n(25).Recognizer,s=n(30).DefaultErrorStrategy,a=n(22).ATNDeserializer,l=n(23).ATNDeserializationOptions,u=n(4).TerminalNode,c=n(4).ErrorNode;function h(t){return i.call(this),this.parser=t,this}function p(t){return o.call(this),this._input=null,this._errHandler=new s,this._precedenceStack=[],this._precedenceStack.push(0),this._ctx=null,this.buildParseTrees=!0,this._tracer=null,this._parseListeners=null,this._syntaxErrors=0,this.setInputStream(t),this}h.prototype=Object.create(i.prototype),h.prototype.constructor=h,h.prototype.enterEveryRule=function(t){console.log("enter   "+this.parser.ruleNames[t.ruleIndex]+", LT(1)="+this.parser._input.LT(1).text)},h.prototype.visitTerminal=function(t){console.log("consume "+t.symbol+" rule "+this.parser.ruleNames[this.parser._ctx.ruleIndex])},h.prototype.exitEveryRule=function(t){console.log("exit    "+this.parser.ruleNames[t.ruleIndex]+", LT(1)="+this.parser._input.LT(1).text)},p.prototype=Object.create(o.prototype),p.prototype.contructor=p,p.bypassAltsAtnCache={},p.prototype.reset=function(){null!==this._input&&this._input.seek(0),this._errHandler.reset(this),this._ctx=null,this._syntaxErrors=0,this.setTrace(!1),this._precedenceStack=[],this._precedenceStack.push(0),null!==this._interp&&this._interp.reset()},p.prototype.match=function(t){var e=this.getCurrentToken();return e.type===t?(this._errHandler.reportMatch(this),this.consume()):(e=this._errHandler.recoverInline(this),this.buildParseTrees&&-1===e.tokenIndex&&this._ctx.addErrorNode(e)),e},p.prototype.matchWildcard=function(){var t=this.getCurrentToken();return t.type>0?(this._errHandler.reportMatch(this),this.consume()):(t=this._errHandler.recoverInline(this),this._buildParseTrees&&-1===t.tokenIndex&&this._ctx.addErrorNode(t)),t},p.prototype.getParseListeners=function(){return this._parseListeners||[]},p.prototype.addParseListener=function(t){if(null===t)throw"listener";null===this._parseListeners&&(this._parseListeners=[]),this._parseListeners.push(t)},p.prototype.removeParseListener=function(t){if(null!==this._parseListeners){var e=this._parseListeners.indexOf(t);e>=0&&this._parseListeners.splice(e,1),0===this._parseListeners.length&&(this._parseListeners=null)}},p.prototype.removeParseListeners=function(){this._parseListeners=null},p.prototype.triggerEnterRuleEvent=function(){if(null!==this._parseListeners){var t=this._ctx;this._parseListeners.map(function(e){e.enterEveryRule(t),t.enterRule(e)})}},p.prototype.triggerExitRuleEvent=function(){if(null!==this._parseListeners){var t=this._ctx;this._parseListeners.slice(0).reverse().map(function(e){t.exitRule(e),e.exitEveryRule(t)})}},p.prototype.getTokenFactory=function(){return this._input.tokenSource._factory},p.prototype.setTokenFactory=function(t){this._input.tokenSource._factory=t},p.prototype.getATNWithBypassAlts=function(){var t=this.getSerializedATN();if(null===t)throw"The current parser does not support an ATN with bypass alternatives.";var e=this.bypassAltsAtnCache[t];if(null===e){var n=new l;n.generateRuleBypassTransitions=!0,e=new a(n).deserialize(t),this.bypassAltsAtnCache[t]=e}return e};var f=n(15).Lexer;p.prototype.compileParseTreePattern=function(t,e,n){if(null===(n=n||null)&&null!==this.getTokenStream()){var r=this.getTokenStream().tokenSource;r instanceof f&&(n=r)}if(null===n)throw"Parser can't discover a lexer to use";return new ParseTreePatternMatcher(n,this).compile(t,e)},p.prototype.getInputStream=function(){return this.getTokenStream()},p.prototype.setInputStream=function(t){this.setTokenStream(t)},p.prototype.getTokenStream=function(){return this._input},p.prototype.setTokenStream=function(t){this._input=null,this.reset(),this._input=t},p.prototype.getCurrentToken=function(){return this._input.LT(1)},p.prototype.notifyErrorListeners=function(t,e,n){e=e||null,n=n||null,null===e&&(e=this.getCurrentToken()),this._syntaxErrors+=1;var r=e.line,i=e.column;this.getErrorListenerDispatch().syntaxError(this,e,r,i,t,n)},p.prototype.consume=function(){var t=this.getCurrentToken();t.type!==r.EOF&&this.getInputStream().consume();var e,n=null!==this._parseListeners&&this._parseListeners.length>0;(this.buildParseTrees||n)&&((e=this._errHandler.inErrorRecoveryMode(this)?this._ctx.addErrorNode(t):this._ctx.addTokenNode(t)).invokingState=this.state,n&&this._parseListeners.map(function(t){e instanceof c||void 0!==e.isErrorNode&&e.isErrorNode()?t.visitErrorNode(e):e instanceof u&&t.visitTerminal(e)}));return t},p.prototype.addContextToParseTree=function(){null!==this._ctx.parentCtx&&this._ctx.parentCtx.addChild(this._ctx)},p.prototype.enterRule=function(t,e,n){this.state=e,this._ctx=t,this._ctx.start=this._input.LT(1),this.buildParseTrees&&this.addContextToParseTree(),null!==this._parseListeners&&this.triggerEnterRuleEvent()},p.prototype.exitRule=function(){this._ctx.stop=this._input.LT(-1),null!==this._parseListeners&&this.triggerExitRuleEvent(),this.state=this._ctx.invokingState,this._ctx=this._ctx.parentCtx},p.prototype.enterOuterAlt=function(t,e){t.setAltNumber(e),this.buildParseTrees&&this._ctx!==t&&null!==this._ctx.parentCtx&&(this._ctx.parentCtx.removeLastChild(),this._ctx.parentCtx.addChild(t)),this._ctx=t},p.prototype.getPrecedence=function(){return 0===this._precedenceStack.length?-1:this._precedenceStack[this._precedenceStack.length-1]},p.prototype.enterRecursionRule=function(t,e,n,r){this.state=e,this._precedenceStack.push(r),this._ctx=t,this._ctx.start=this._input.LT(1),null!==this._parseListeners&&this.triggerEnterRuleEvent()},p.prototype.pushNewRecursionContext=function(t,e,n){var r=this._ctx;r.parentCtx=t,r.invokingState=e,r.stop=this._input.LT(-1),this._ctx=t,this._ctx.start=r.start,this.buildParseTrees&&this._ctx.addChild(r),null!==this._parseListeners&&this.triggerEnterRuleEvent()},p.prototype.unrollRecursionContexts=function(t){this._precedenceStack.pop(),this._ctx.stop=this._input.LT(-1);var e=this._ctx;if(null!==this._parseListeners)for(;this._ctx!==t;)this.triggerExitRuleEvent(),this._ctx=this._ctx.parentCtx;else this._ctx=t;e.parentCtx=t,this.buildParseTrees&&null!==t&&t.addChild(e)},p.prototype.getInvokingContext=function(t){for(var e=this._ctx;null!==e;){if(e.ruleIndex===t)return e;e=e.parentCtx}return null},p.prototype.precpred=function(t,e){return e>=this._precedenceStack[this._precedenceStack.length-1]},p.prototype.inContext=function(t){return!1},p.prototype.isExpectedToken=function(t){var e=this._interp.atn,n=this._ctx,i=e.states[this.state],o=e.nextTokens(i);if(o.contains(t))return!0;if(!o.contains(r.EPSILON))return!1;for(;null!==n&&n.invokingState>=0&&o.contains(r.EPSILON);){var s=e.states[n.invokingState].transitions[0];if((o=e.nextTokens(s.followState)).contains(t))return!0;n=n.parentCtx}return!(!o.contains(r.EPSILON)||t!==r.EOF)},p.prototype.getExpectedTokens=function(){return this._interp.atn.getExpectedTokens(this.state,this._ctx)},p.prototype.getExpectedTokensWithinCurrentRule=function(){var t=this._interp.atn,e=t.states[this.state];return t.nextTokens(e)},p.prototype.getRuleIndex=function(t){var e=this.getRuleIndexMap()[t];return null!==e?e:-1},p.prototype.getRuleInvocationStack=function(t){null===(t=t||null)&&(t=this._ctx);for(var e=[];null!==t;){var n=t.ruleIndex;n<0?e.push("n/a"):e.push(this.ruleNames[n]),t=t.parentCtx}return e},p.prototype.getDFAStrings=function(){return this._interp.decisionToDFA.toString()},p.prototype.dumpDFA=function(){for(var t=!1,e=0;e<this._interp.decisionToDFA.length;e++){var n=this._interp.decisionToDFA[e];n.states.length>0&&(t&&console.log(),this.printer.println("Decision "+n.decision+":"),this.printer.print(n.toString(this.literalNames,this.symbolicNames)),t=!0)}},p.prototype.getSourceName=function(){return this._input.sourceName},p.prototype.setTrace=function(t){t?(null!==this._tracer&&this.removeParseListener(this._tracer),this._tracer=new h(this),this.addParseListener(this._tracer)):(this.removeParseListener(this._tracer),this._tracer=null)},e.Parser=p},function(t,e,n){var r=n(12),i=["悋Ꜫ脳맭䅼㯧瞆奤","ŝ\b
\t\t","\t\t\t\t","\b\t\b\t\t\t\n\t\n\v\t\v","\f\t\f\r\t\r\t\t","\t\t\t\t","\t\t\t","\t\t\t\t","\t\t\t","\t\t \t ","","","","","","","","","","","","","","\b\b\t\t\n\n","\v\v\v\v\v\v","\v\v\v\v\v\v","\v\v\v\v\v\v","\v\v\v\v\v\v","\v\v\v\v\v\v","\v\v\v\v\v\v","\v\v\v\v\v\v","\v\f\f\r\r","","Ó\n\fÖ","\v","Ü\n\fß\v","ã\n\fæ\v","ê\n","ï\n\fò","\v","ù\n","þ\n\fā\v","Ĉ\n","","","ę\n","Ĝ\n","ġ\n\rĢ","","ī\n\fĮ\v","","","Ŀ\n\fł","\v","Ō\n\f","ŏ\v ","    ŗ\n \f  Ś\v  "," ÔĬŀ!","\t\v\r\b\t\n\v\f\r","!#%","')+-/13579",";=?__C\\","2;C\\aac|c|$$^^\n$$11^^dd","hhppttvv))^^\n))11^^ddhhppttvv2;CHch",'\v\v""\f\f==~~',"ũ","\t","\v\r","","","","","!","#%","35","79;","=?","AI","K\t„","\v†\rˆ","“•","—™","ÄÆ","ÈÊ","Ì!Ù","#à%é'ë",")õ+ú","-Ą/ĉ","1ď3đ","5ě7Ġ","9Ħ;Ĵ=Ň","?ŒABi","BCtCDcDEo","EFoFGcGHtH","IJ=J","KLuLMvMNc","NOvOPGPQzQR","rRStSTUTUr","UVnVWkWXv",'XY"YZ<Z["[\\',")\\]?]^?^_",'?_`"`auabv',"bcccdvdeg","efofggghphi",'vij"jk`kl"',"lm?mn?no?",'op"pqgqrzrs',"rstttuguvu","vwuwxkxyq",'yzpz{"{|x|}','"}~?~?',"€?€)‚",'"‚ƒ=ƒ\b',"„…<…\n","†‡~‡\f","ˆ‰g‰ŠzŠ","‹r‹ŒtŒ","gŽuŽ","uk‘q","‘’p’","“”A”","•–-–","—˜,˜","™šOš›g","›œcœp","žkžŸpŸ ","i ¡h¡¢","w¢£n£¤U","¤¥r¥¦n","¦§k§¨v¨",'©"©ª<ª«','"«¬)¬­',"?­®?®¯?",'¯°"°±o',"±²g²³c³","´p´µkµ¶","p¶·i·¸","h¸¹w¹ºn",'º»"»¼`','¼½"½¾?¾',"¿?¿À?ÀÁ",')ÁÂ"ÂÃ',"=ÃÄÅ","*ÅÆÇ","+ÇÈÉ","€ÉÊË","0ËÌÔ","]ÍÎ^ÎÓ^","ÏÐ^ÐÓ_","ÑÓ\nÒÍ","ÒÏÒÑ","ÓÖÔÕ","ÔÒÕ×","ÖÔ×Ø_","Ø ÙÝ\tÚ","Ü\tÛÚÜ","ßÝÛÝ",'ÞÞ"ß',"Ýàä\tá","ã\tâáã","æäâä","åå$æ","äçê+è","ê'éçé","èê&ë","ð$ìï)íï","\nîìîí","ïòðî","ðññó","òðóô","$ô(õø","^öù\t÷ù/","øöø÷","ù*úÿ)","ûþ-üþ\n\býû","ýüþā","ÿýÿĀ","ĀĂāÿ","Ăă)ă,","Ąć^ąĈ\t\t","ĆĈ/ćą","ćĆĈ.","ĉĊwĊċ1","ċČ1Čč1č","Ď1Ď0ďĐ","\t\nĐ2đĒ%","Ēē!ēĔ","Ĕĕ\bĕ4","ĖĘėę\f","ĘėĘę","ęĜĚĜ\f","ěĖěĚ","ĜĝĝĞ\b","Ğ6ğġ\t\vĠ","ğġĢĢ","ĠĢģģ","ĤĤĥ\bĥ","8Ħħ1ħĨ",",ĨĬĩī","\vĪĩīĮ","ĬĭĬĪ","ĭįĮĬ","įİ,İı","1ıIJIJij","\bij:Ĵĵ","hĵĶtĶķc","ķĸiĸĹo","ĹĺgĺĻpĻ","ļvļŀĽ","Ŀ\vľĽĿ","łŀŁŀ","ľŁŃł","ŀŃń=ń","ŅŅņ\bņ","<Ňň1ňʼn","1ʼnōŊŌ","\n\fŋŊŌŏ","ōŋōŎ","ŎŐŏō","Őő\bő>","Œœ/œŔ@","ŔŘŕŗ\n\r","ŖŕŗŚ","ŘŖŘř","řśŚŘ","śŜ\b Ŝ@","ÒÔÝäéîðøýÿćĘ","ěĢĬŀōŘ\b"].join(""),o=(new r.atn.ATNDeserializer).deserialize(i),s=o.decisionToState.map(function(t,e){return new r.dfa.DFA(t,e)});function a(t){return r.Lexer.call(this,t),this._interp=new r.atn.LexerATNSimulator(this,o,s,new r.PredictionContextCache),this}a.prototype=Object.create(r.Lexer.prototype),a.prototype.constructor=a,a.EOF=r.Token.EOF,a.T__0=1,a.T__1=2,a.T__2=3,a.T__3=4,a.T__4=5,a.T__5=6,a.T__6=7,a.T__7=8,a.T__8=9,a.T__9=10,a.T__10=11,a.T__11=12,a.T__12=13,a.T__13=14,a.Brackets=15,a.LexerIdentifier=16,a.ParserIdentifier=17,a.String=18,a.LabelForParserRule=19,a.Newline=20,a.WhiteSpace=21,a.BlockComment=22,a.FragmentComment=23,a.LineComment=24,a.ArrowComment=25,a.prototype.channelNames=["DEFAULT_TOKEN_CHANNEL","HIDDEN"],a.prototype.modeNames=["DEFAULT_MODE"],a.prototype.literalNames=[null,"'grammar'","';'","'statExprSplit : '=== statement ^ === expression v ===' ;'","':'","'|'","'expression'","'?'","'+'","'*'","'MeaningfulSplit : '=== meaningful ^ ===' ;'","'('","')'","'~'","'.'"],a.prototype.symbolicNames=[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"Brackets","LexerIdentifier","ParserIdentifier","String","LabelForParserRule","Newline","WhiteSpace","BlockComment","FragmentComment","LineComment","ArrowComment"],a.prototype.ruleNames=["T__0","T__1","T__2","T__3","T__4","T__5","T__6","T__7","T__8","T__9","T__10","T__11","T__12","T__13","Brackets","LexerIdentifier","ParserIdentifier","String","STRING_double","ESC_double","STRING_single","ESC_single","UNICODE","HEX","LabelForParserRule","Newline","WhiteSpace","BlockComment","FragmentComment","LineComment","ArrowComment"],a.prototype.grammarFileName="BlocklyGrammer.g4",e.BlocklyGrammerLexer=a},function(t,e,n){var r=n(12),i=n(20).BlocklyGrammerVisitor,o=["悋Ꜫ脳맭䅼㯧瞆奤","Õ\t\t","\t\t\t\t","\b\t\b\t\t\t\n\t\n\v\t\v\f\t\f","\r\t\r\n\f"," \v$\n","\f'\v","","","8\n\r9","@\n\fC\v","F\n","L\n","Q\nS\n\fV\v","\\","\n\f_\vb\n","f\n\f","i\v\b\b\b\bn\n\b\bp\n\b","\b\b\b\bu\n\b\bw\n\b\b\b\b","\b|\n\b\b~\n\b\b\b\b\bƒ\n\b","\b…\n\b\b‡\n\b\t\tŠ\n\t\f\t","\t\v\t\n\n\v\v\v","\v\v\v\v\v\v","\v\v›\n\v\r\v\vœ","\v\v\v\v\v\v","\v\v¦\n\v\f\f\f\f«","\n\f\f­\n\f\f¯\n\f\r\f\f°\r","\r\r\r\r\r\r\r\r\r","\r\r\r\r\r\rÂ\n\r\r\r","\r\r\r\r\r\r\r\r","\rÎ\n\r\rÐ\n\r\f\r\rÓ\v\r\r","%‹\b\n\f","\t\v","\n\vð,","0\bE","\na\fc†","‹Ž","¥®","Á","\b"," ","!"," !%",'"$\n#"$\'',"%&%#","&('%()","\t)*\n*+\t+",",--../","/01","12334","4756","687589","979::;",";F<==A",">@\b?>@","CA?AB","BDCADF","E2E<F\t","GH\bHK","IL\fJLKI","KJLTMP","NQ\fOQPN","POQS","RMSVTR","TUUWVT","WbXYY]","Z\\\b[Z","\\_][]^","^`_]`b","aGaX","b\vcg\bdf","\bedfige","ghh\r","igjo\bkm\t","ln\tmlmn","npokop","p‡qv","rt\tsu\tts","tuuwvr","vww‡x}","y{\tz|\t{z","{||~","}y}~~‡","„€‚\t","ƒ\t‚","‚ƒƒ…","„€„…","…‡†j","†q†x","†‡","ˆŠ\v‰ˆ","Š‹Œ","‹‰Œ","‹Ž\f","‘","‘’’“\f","“””¦","•––—","—š\f˜™","™›\fš˜","›œœš","œž","žŸŸ¦"," ¡¡¢","¢£\r£¤","¤¦¥","¥•¥ ","¦§¬","¨ª\t©«\t","ª©ª«","«­¬¨","¬­­¯","®§¯°","°®°±","±²³\b\r
³","´\r´µ\rµ¶","¶Â·¸","¸Â\r\b¹Â","º»»¼","¼½½Â","¾Â¿Â","ÀÂÁ²","Á·Á¹","ÁºÁ¾","Á¿ÁÀ","ÂÑÃÄ\f","\vÄÅÅÐ","\r\fÆÇ\f\nÇÐ\r\v","ÈÉ\f\rÉÐ\tÊË","\f\fËÍ\tÌÎ\t","ÍÌÍÎ","ÎÐÏÃ","ÏÆÏÈ","ÏÊÐÓ","ÑÏÑÒ","ÒÓÑ"," %9AEKPT]agmotv{}‚„†‹œ¥","ª¬°ÁÍÏÑ"].join(""),s=(new r.atn.ATNDeserializer).deserialize(o),a=s.decisionToState.map(function(t,e){return new r.dfa.DFA(t,e)}),l=new r.PredictionContextCache,u=[null,"'grammar'","';'","'statExprSplit : '=== statement ^ === expression v ===' ;'","':'","'|'","'expression'","'?'","'+'","'*'","'MeaningfulSplit : '=== meaningful ^ ===' ;'","'('","')'","'~'","'.'"],c=[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"Brackets","LexerIdentifier","ParserIdentifier","String","LabelForParserRule","Newline","WhiteSpace","BlockComment","FragmentComment","LineComment","ArrowComment"],h=["grammarFile","grammerDecl","statExprSplit","statementRule","expressionRule","arithmeticRuleCollection","parserRuleAtom","lexerRuleCollection","meaningfulSplit","lexerRule","strings","lexerRuleExpr"];function p(t){return r.Parser.call(this,t),this._interp=new r.atn.ParserATNSimulator(this,s,a,l),this.ruleNames=h,this.literalNames=u,this.symbolicNames=c,this}function f(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_grammarFile,this}function d(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_grammerDecl,this}function y(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_statExprSplit,this}function g(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_statementRule,this}function v(t,e){return g.call(this,t),g.prototype.copyFrom.call(this,e),this}function x(t,e){return g.call(this,t),g.prototype.copyFrom.call(this,e),this}function m(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_expressionRule,this}function _(t,e){return m.call(this,t),m.prototype.copyFrom.call(this,e),this}function T(t,e){return m.call(this,t),m.prototype.copyFrom.call(this,e),this}function S(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_arithmeticRuleCollection,this}function E(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_parserRuleAtom,this}function C(t,e){return E.call(this,t),E.prototype.copyFrom.call(this,e),this}function A(t,e){return E.call(this,t),E.prototype.copyFrom.call(this,e),this}function b(t,e){return E.call(this,t),E.prototype.copyFrom.call(this,e),this}function k(t,e){return E.call(this,t),E.prototype.copyFrom.call(this,e),this}function R(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_lexerRuleCollection,this}function L(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_meaningfulSplit,this}function I(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_lexerRule,this}function N(t,e){return I.call(this,t),I.prototype.copyFrom.call(this,e),this}function O(t,e){return I.call(this,t),I.prototype.copyFrom.call(this,e),this}function P(t,e){return I.call(this,t),I.prototype.copyFrom.call(this,e),this}function w(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_strings,this}function F(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_lexerRuleExpr,this}p.prototype=Object.create(r.Parser.prototype),p.prototype.constructor=p,Object.defineProperty(p.prototype,"atn",{get:function(){return s}}),p.EOF=r.Token.EOF,p.T__0=1,p.T__1=2,p.T__2=3,p.T__3=4,p.T__4=5,p.T__5=6,p.T__6=7,p.T__7=8,p.T__8=9,p.T__9=10,p.T__10=11,p.T__11=12,p.T__12=13,p.T__13=14,p.Brackets=15,p.LexerIdentifier=16,p.ParserIdentifier=17,p.String=18,p.LabelForParserRule=19,p.Newline=20,p.WhiteSpace=21,p.BlockComment=22,p.FragmentComment=23,p.LineComment=24,p.ArrowComment=25,p.RULE_grammarFile=0,p.RULE_grammerDecl=1,p.RULE_statExprSplit=2,p.RULE_statementRule=3,p.RULE_expressionRule=4,p.RULE_arithmeticRuleCollection=5,p.RULE_parserRuleAtom=6,p.RULE_lexerRuleCollection=7,p.RULE_meaningfulSplit=8,p.RULE_lexerRule=9,p.RULE_strings=10,p.RULE_lexerRuleExpr=11,f.prototype=Object.create(r.ParserRuleContext.prototype),f.prototype.constructor=f,f.prototype.grammerDecl=function(){return this.getTypedRuleContext(d,0)},f.prototype.statExprSplit=function(){return this.getTypedRuleContext(y,0)},f.prototype.lexerRuleCollection=function(t){return void 0===t&&(t=null),null===t?this.getTypedRuleContexts(R):this.getTypedRuleContext(R,t)},f.prototype.meaningfulSplit=function(){return this.getTypedRuleContext(L,0)},f.prototype.statementRule=function(t){return void 0===t&&(t=null),null===t?this.getTypedRuleContexts(g):this.getTypedRuleContext(g,t)},f.prototype.expressionRule=function(t){return void 0===t&&(t=null),null===t?this.getTypedRuleContexts(m):this.getTypedRuleContext(m,t)},f.prototype.accept=function(t){return t instanceof i?t.visitGrammarFile(this):t.visitChildren(this)},p.GrammarFileContext=f,p.prototype.grammarFile=function(){var t=new f(this,this._ctx,this.state);this.enterRule(t,0,p.RULE_grammarFile);try{this.enterOuterAlt(t,1),this.state=24,this.grammerDecl(),this.state=28,this._errHandler.sync(this);for(var e=this._interp.adaptivePredict(this._input,0,this._ctx);1!=e&&e!=r.atn.ATN.INVALID_ALT_NUMBER;)2===e&&(this.state=25,this.statementRule()),this.state=30,this._errHandler.sync(this),e=this._interp.adaptivePredict(this._input,0,this._ctx);this.state=31,this.statExprSplit(),this.state=35,this._errHandler.sync(this);for(e=this._interp.adaptivePredict(this._input,1,this._ctx);1!=e&&e!=r.atn.ATN.INVALID_ALT_NUMBER;)2===e&&(this.state=32,this.expressionRule()),this.state=37,this._errHandler.sync(this),e=this._interp.adaptivePredict(this._input,1,this._ctx);this.state=38,this.lexerRuleCollection(),this.state=39,this.meaningfulSplit(),this.state=40,this.lexerRuleCollection()}catch(e){if(!(e instanceof r.error.RecognitionException))throw e;t.exception=e,this._errHandler.reportError(this,e),this._errHandler.recover(this,e)}finally{this.exitRule()}return t},d.prototype=Object.create(r.ParserRuleContext.prototype),d.prototype.constructor=d,d.prototype.LexerIdentifier=function(){return this.getToken(p.LexerIdentifier,0)},d.prototype.accept=function(t){return t instanceof i?t.visitGrammerDecl(this):t.visitChildren(this)},p.GrammerDeclContext=d,p.prototype.grammerDecl=function(){var t=new d(this,this._ctx,this.state);this.enterRule(t,2,p.RULE_grammerDecl);try{this.enterOuterAlt(t,1),this.state=42,this.match(p.T__0),this.state=43,this.match(p.LexerIdentifier),this.state=44,this.match(p.T__1)}catch(e){if(!(e instanceof r.error.RecognitionException))throw e;t.exception=e,this._errHandler.reportError(this,e),this._errHandler.recover(this,e)}finally{this.exitRule()}return t},y.prototype=Object.create(r.ParserRuleContext.prototype),y.prototype.constructor=y,y.prototype.accept=function(t){return t instanceof i?t.visitStatExprSplit(this):t.visitChildren(this)},p.StatExprSplitContext=y,p.prototype.statExprSplit=function(){var t=new y(this,this._ctx,this.state);this.enterRule(t,4,p.RULE_statExprSplit);try{this.enterOuterAlt(t,1),this.state=46,this.match(p.T__2)}catch(e){if(!(e instanceof r.error.RecognitionException))throw e;t.exception=e,this._errHandler.reportError(this,e),this._errHandler.recover(this,e)}finally{this.exitRule()}return t},g.prototype=Object.create(r.ParserRuleContext.prototype),g.prototype.constructor=g,g.prototype.copyFrom=function(t){r.ParserRuleContext.prototype.copyFrom.call(this,t)},v.prototype=Object.create(g.prototype),v.prototype.constructor=v,p.StatValueContext=v,v.prototype.ParserIdentifier=function(){return this.getToken(p.ParserIdentifier,0)},v.prototype.parserRuleAtom=function(t){return void 0===t&&(t=null),null===t?this.getTypedRuleContexts(E):this.getTypedRuleContext(E,t)},v.prototype.accept=function(t){return t instanceof i?t.visitStatValue(this):t.visitChildren(this)},x.prototype=Object.create(g.prototype),x.prototype.constructor=x,p.StatListContext=x,x.prototype.ParserIdentifier=function(t){return void 0===t&&(t=null),null===t?this.getTokens(p.ParserIdentifier):this.getToken(p.ParserIdentifier,t)},x.prototype.accept=function(t){return t instanceof i?t.visitStatList(this):t.visitChildren(this)},p.StatementRuleContext=g,p.prototype.statementRule=function(){var t=new g(this,this._ctx,this.state);this.enterRule(t,6,p.RULE_statementRule);var e=0;try{switch(this.state=67,this._errHandler.sync(this),this._interp.adaptivePredict(this._input,4,this._ctx)){case 1:t=new x(this,t),this.enterOuterAlt(t,1),this.state=48,this.match(p.ParserIdentifier),this.state=49,this.match(p.T__3),this.state=50,this.match(p.ParserIdentifier),this.state=53,this._errHandler.sync(this),e=this._input.LA(1);do{this.state=51,this.match(p.T__4),this.state=52,this.match(p.ParserIdentifier),this.state=55,this._errHandler.sync(this),e=this._input.LA(1)}while(e===p.T__4);this.state=57,this.match(p.T__1);break;case 2:for(t=new v(this,t),this.enterOuterAlt(t,2),this.state=58,this.match(p.ParserIdentifier),this.state=59,this.match(p.T__3),this.state=63,this._errHandler.sync(this),e=this._input.LA(1);0==(-32&e)&&0!=(1<<e&(1<<p.T__5|1<<p.LexerIdentifier|1<<p.ParserIdentifier|1<<p.String));)this.state=60,this.parserRuleAtom(),this.state=65,this._errHandler.sync(this),e=this._input.LA(1);this.state=66,this.match(p.T__1)}}catch(e){if(!(e instanceof r.error.RecognitionException))throw e;t.exception=e,this._errHandler.reportError(this,e),this._errHandler.recover(this,e)}finally{this.exitRule()}return t},m.prototype=Object.create(r.ParserRuleContext.prototype),m.prototype.constructor=m,m.prototype.copyFrom=function(t){r.ParserRuleContext.prototype.copyFrom.call(this,t)},_.prototype=Object.create(m.prototype),_.prototype.constructor=_,p.ExprExpressionContext=_,_.prototype.arithmeticRuleCollection=function(t){return void 0===t&&(t=null),null===t?this.getTypedRuleContexts(S):this.getTypedRuleContext(S,t)},_.prototype.ParserIdentifier=function(t){return void 0===t&&(t=null),null===t?this.getTokens(p.ParserIdentifier):this.getToken(p.ParserIdentifier,t)},_.prototype.accept=function(t){return t instanceof i?t.visitExprExpression(this):t.visitChildren(this)},T.prototype=Object.create(m.prototype),T.prototype.constructor=T,p.ExprValueContext=T,T.prototype.ParserIdentifier=function(){return this.getToken(p.ParserIdentifier,0)},T.prototype.parserRuleAtom=function(t){return void 0===t&&(t=null),null===t?this.getTypedRuleContexts(E):this.getTypedRuleContext(E,t)},T.prototype.accept=function(t){return t instanceof i?t.visitExprValue(this):t.visitChildren(this)},p.ExpressionRuleContext=m,p.prototype.expressionRule=function(){var t=new m(this,this._ctx,this.state);this.enterRule(t,8,p.RULE_expressionRule);var e=0;try{switch(this.state=95,this._errHandler.sync(this),this._input.LA(1)){case p.T__5:switch(t=new _(this,t),this.enterOuterAlt(t,1),this.state=69,this.match(p.T__5),this.state=70,this.match(p.T__3),this.state=73,this._errHandler.sync(this),this._input.LA(1)){case p.T__5:this.state=71,this.arithmeticRuleCollection();break;case p.ParserIdentifier:this.state=72,this.match(p.ParserIdentifier);break;default:throw new r.error.NoViableAltException(this)}for(this.state=82,this._errHandler.sync(this),e=this._input.LA(1);e===p.T__4;){switch(this.state=75,this.match(p.T__4),this.state=78,this._errHandler.sync(this),this._input.LA(1)){case p.T__5:this.state=76,this.arithmeticRuleCollection();break;case p.ParserIdentifier:this.state=77,this.match(p.ParserIdentifier);break;default:throw new r.error.NoViableAltException(this)}this.state=84,this._errHandler.sync(this),e=this._input.LA(1)}this.state=85,this.match(p.T__1);break;case p.ParserIdentifier:for(t=new T(this,t),this.enterOuterAlt(t,2),this.state=86,this.match(p.ParserIdentifier),this.state=87,this.match(p.T__3),this.state=91,this._errHandler.sync(this),e=this._input.LA(1);0==(-32&e)&&0!=(1<<e&(1<<p.T__5|1<<p.LexerIdentifier|1<<p.ParserIdentifier|1<<p.String));)this.state=88,this.parserRuleAtom(),this.state=93,this._errHandler.sync(this),e=this._input.LA(1);this.state=94,this.match(p.T__1);break;default:throw new r.error.NoViableAltException(this)}}catch(e){if(!(e instanceof r.error.RecognitionException))throw e;t.exception=e,this._errHandler.reportError(this,e),this._errHandler.recover(this,e)}finally{this.exitRule()}return t},S.prototype=Object.create(r.ParserRuleContext.prototype),S.prototype.constructor=S,S.prototype.parserRuleAtom=function(t){return void 0===t&&(t=null),null===t?this.getTypedRuleContexts(E):this.getTypedRuleContext(E,t)},S.prototype.accept=function(t){return t instanceof i?t.visitArithmeticRuleCollection(this):t.visitChildren(this)},p.ArithmeticRuleCollectionContext=S,p.prototype.arithmeticRuleCollection=function(){var t=new S(this,this._ctx,this.state);this.enterRule(t,10,p.RULE_arithmeticRuleCollection);var e=0;try{for(this.enterOuterAlt(t,1),this.state=97,this.match(p.T__5),this.state=101,this._errHandler.sync(this),e=this._input.LA(1);0==(-32&e)&&0!=(1<<e&(1<<p.T__5|1<<p.LexerIdentifier|1<<p.ParserIdentifier|1<<p.String));)this.state=98,this.parserRuleAtom(),this.state=103,this._errHandler.sync(this),e=this._input.LA(1)}catch(e){if(!(e instanceof r.error.RecognitionException))throw e;t.exception=e,this._errHandler.reportError(this,e),this._errHandler.recover(this,e)}finally{this.exitRule()}return t},E.prototype=Object.create(r.ParserRuleContext.prototype),E.prototype.constructor=E,E.prototype.copyFrom=function(t){r.ParserRuleContext.prototype.copyFrom.call(this,t)},C.prototype=Object.create(E.prototype),C.prototype.constructor=C,p.ParserAtomExprContext=C,C.prototype.accept=function(t){return t instanceof i?t.visitParserAtomExpr(this):t.visitChildren(this)},A.prototype=Object.create(E.prototype),A.prototype.constructor=A,p.ParserAtomParserIdContext=A,A.prototype.ParserIdentifier=function(){return this.getToken(p.ParserIdentifier,0)},A.prototype.accept=function(t){return t instanceof i?t.visitParserAtomParserId(this):t.visitChildren(this)},b.prototype=Object.create(E.prototype),b.prototype.constructor=b,p.ParserAtomStrContext=b,b.prototype.String=function(){return this.getToken(p.String,0)},b.prototype.accept=function(t){return t instanceof i?t.visitParserAtomStr(this):t.visitChildren(this)},k.prototype=Object.create(E.prototype),k.prototype.constructor=k,p.ParserAtomLexerIdContext=k,k.prototype.LexerIdentifier=function(){return this.getToken(p.LexerIdentifier,0)},k.prototype.accept=function(t){return t instanceof i?t.visitParserAtomLexerId(this):t.visitChildren(this)},p.ParserRuleAtomContext=E,p.prototype.parserRuleAtom=function(){var t=new E(this,this._ctx,this.state);this.enterRule(t,12,p.RULE_parserRuleAtom);var e=0;try{switch(this.state=132,this._errHandler.sync(this),this._input.LA(1)){case p.T__5:t=new C(this,t),this.enterOuterAlt(t,1),this.state=104,this.match(p.T__5),this.state=109,this._errHandler.sync(this),(e=this._input.LA(1))===p.T__6&&(this.state=105,this.match(p.T__6),this.state=107,this._errHandler.sync(this),(e=this._input.LA(1))===p.T__6&&(this.state=106,this.match(p.T__6)));break;case p.ParserIdentifier:t=new A(this,t),this.enterOuterAlt(t,2),this.state=111,this.match(p.ParserIdentifier),this.state=116,this._errHandler.sync(this),0==(-32&(e=this._input.LA(1)))&&0!=(1<<e&(1<<p.T__6|1<<p.T__7|1<<p.T__8))&&(this.state=112,0!=(-32&(e=this._input.LA(1)))||0==(1<<e&(1<<p.T__6|1<<p.T__7|1<<p.T__8))?this._errHandler.recoverInline(this):(this._errHandler.reportMatch(this),this.consume()),this.state=114,this._errHandler.sync(this),(e=this._input.LA(1))===p.T__6&&(this.state=113,this.match(p.T__6)));break;case p.LexerIdentifier:t=new k(this,t),this.enterOuterAlt(t,3),this.state=118,this.match(p.LexerIdentifier),this.state=123,this._errHandler.sync(this),(e=this._input.LA(1))===p.T__6&&(this.state=119,this.match(p.T__6),this.state=121,this._errHandler.sync(this),(e=this._input.LA(1))===p.T__6&&(this.state=120,this.match(p.T__6)));break;case p.String:t=new b(this,t),this.enterOuterAlt(t,4),this.state=125,this.match(p.String),this.state=130,this._errHandler.sync(this),(e=this._input.LA(1))===p.T__6&&(this.state=126,this.match(p.T__6),this.state=128,this._errHandler.sync(this),(e=this._input.LA(1))===p.T__6&&(this.state=127,this.match(p.T__6)));break;default:throw new r.error.NoViableAltException(this)}}catch(e){if(!(e instanceof r.error.RecognitionException))throw e;t.exception=e,this._errHandler.reportError(this,e),this._errHandler.recover(this,e)}finally{this.exitRule()}return t},R.prototype=Object.create(r.ParserRuleContext.prototype),R.prototype.constructor=R,R.prototype.lexerRule=function(t){return void 0===t&&(t=null),null===t?this.getTypedRuleContexts(I):this.getTypedRuleContext(I,t)},R.prototype.accept=function(t){return t instanceof i?t.visitLexerRuleCollection(this):t.visitChildren(this)},p.LexerRuleCollectionContext=R,p.prototype.lexerRuleCollection=function(){var t=new R(this,this._ctx,this.state);this.enterRule(t,14,p.RULE_lexerRuleCollection);try{this.enterOuterAlt(t,1),this.state=137,this._errHandler.sync(this);for(var e=this._interp.adaptivePredict(this._input,20,this._ctx);1!=e&&e!=r.atn.ATN.INVALID_ALT_NUMBER;)2===e&&(this.state=134,this.lexerRule()),this.state=139,this._errHandler.sync(this),e=this._interp.adaptivePredict(this._input,20,this._ctx)}catch(e){if(!(e instanceof r.error.RecognitionException))throw e;t.exception=e,this._errHandler.reportError(this,e),this._errHandler.recover(this,e)}finally{this.exitRule()}return t},L.prototype=Object.create(r.ParserRuleContext.prototype),L.prototype.constructor=L,L.prototype.accept=function(t){return t instanceof i?t.visitMeaningfulSplit(this):t.visitChildren(this)},p.MeaningfulSplitContext=L,p.prototype.meaningfulSplit=function(){var t=new L(this,this._ctx,this.state);this.enterRule(t,16,p.RULE_meaningfulSplit);try{this.enterOuterAlt(t,1),this.state=140,this.match(p.T__9)}catch(e){if(!(e instanceof r.error.RecognitionException))throw e;t.exception=e,this._errHandler.reportError(this,e),this._errHandler.recover(this,e)}finally{this.exitRule()}return t},I.prototype=Object.create(r.ParserRuleContext.prototype),I.prototype.constructor=I,I.prototype.copyFrom=function(t){r.ParserRuleContext.prototype.copyFrom.call(this,t)},N.prototype=Object.create(I.prototype),N.prototype.constructor=N,p.LexerRuleStringsContext=N,N.prototype.LexerIdentifier=function(){return this.getToken(p.LexerIdentifier,0)},N.prototype.strings=function(){return this.getTypedRuleContext(w,0)},N.prototype.accept=function(t){return t instanceof i?t.visitLexerRuleStrings(this):t.visitChildren(this)},O.prototype=Object.create(I.prototype),O.prototype.constructor=O,p.LexerRuleComplexContext=O,O.prototype.LexerIdentifier=function(){return this.getToken(p.LexerIdentifier,0)},O.prototype.lexerRuleExpr=function(){return this.getTypedRuleContext(F,0)},O.prototype.accept=function(t){return t instanceof i?t.visitLexerRuleComplex(this):t.visitChildren(this)},P.prototype=Object.create(I.prototype),P.prototype.constructor=P,p.LexerRuleListContext=P,P.prototype.LexerIdentifier=function(){return this.getToken(p.LexerIdentifier,0)},P.prototype.strings=function(t){return void 0===t&&(t=null),null===t?this.getTypedRuleContexts(w):this.getTypedRuleContext(w,t)},P.prototype.accept=function(t){return t instanceof i?t.visitLexerRuleList(this):t.visitChildren(this)},p.LexerRuleContext=I,p.prototype.lexerRule=function(){var t=new I(this,this._ctx,this.state);this.enterRule(t,18,p.RULE_lexerRule);var e=0;try{switch(this.state=163,this._errHandler.sync(this),this._interp.adaptivePredict(this._input,22,this._ctx)){case 1:t=new N(this,t),this.enterOuterAlt(t,1),this.state=142,this.match(p.LexerIdentifier),this.state=143,this.match(p.T__3),this.state=144,this.strings(),this.state=145,this.match(p.T__1);break;case 2:t=new P(this,t),this.enterOuterAlt(t,2),this.state=147,this.match(p.LexerIdentifier),this.state=148,this.match(p.T__3),this.state=149,this.strings(),this.state=152,this._errHandler.sync(this),e=this._input.LA(1);do{this.state=150,this.match(p.T__4),this.state=151,this.strings(),this.state=154,this._errHandler.sync(this),e=this._input.LA(1)}while(e===p.T__4);this.state=156,this.match(p.T__1);break;case 3:t=new O(this,t),this.enterOuterAlt(t,3),this.state=158,this.match(p.LexerIdentifier),this.state=159,this.match(p.T__3),this.state=160,this.lexerRuleExpr(0),this.state=161,this.match(p.T__1)}}catch(e){if(!(e instanceof r.error.RecognitionException))throw e;t.exception=e,this._errHandler.reportError(this,e),this._errHandler.recover(this,e)}finally{this.exitRule()}return t},w.prototype=Object.create(r.ParserRuleContext.prototype),w.prototype.constructor=w,w.prototype.String=function(t){return void 0===t&&(t=null),null===t?this.getTokens(p.String):this.getToken(p.String,t)},w.prototype.accept=function(t){return t instanceof i?t.visitStrings(this):t.visitChildren(this)},p.StringsContext=w,p.prototype.strings=function(){var t=new w(this,this._ctx,this.state);this.enterRule(t,20,p.RULE_strings);var e=0;try{this.enterOuterAlt(t,1),this.state=172,this._errHandler.sync(this),e=this._input.LA(1);do{this.state=165,this.match(p.String),this.state=170,this._errHandler.sync(this),(e=this._input.LA(1))===p.T__6&&(this.state=166,this.match(p.T__6),this.state=168,this._errHandler.sync(this),(e=this._input.LA(1))===p.T__6&&(this.state=167,this.match(p.T__6))),this.state=174,this._errHandler.sync(this),e=this._input.LA(1)}while(e===p.String)}catch(e){if(!(e instanceof r.error.RecognitionException))throw e;t.exception=e,this._errHandler.reportError(this,e),this._errHandler.recover(this,e)}finally{this.exitRule()}return t},F.prototype=Object.create(r.ParserRuleContext.prototype),F.prototype.constructor=F,F.prototype.lexerRuleExpr=function(t){return void 0===t&&(t=null),null===t?this.getTypedRuleContexts(F):this.getTypedRuleContext(F,t)},F.prototype.LexerIdentifier=function(){return this.getToken(p.LexerIdentifier,0)},F.prototype.String=function(t){return void 0===t&&(t=null),null===t?this.getTokens(p.String):this.getToken(p.String,t)},F.prototype.Brackets=function(){return this.getToken(p.Brackets,0)},F.prototype.accept=function(t){return t instanceof i?t.visitLexerRuleExpr(this):t.visitChildren(this)},p.prototype.lexerRuleExpr=function(t){void 0===t&&(t=0);var e=this._ctx,n=this.state,i=new F(this,this._ctx,n);this.enterRecursionRule(i,22,p.RULE_lexerRuleExpr,t);var o=0;try{switch(this.enterOuterAlt(i,1),this.state=191,this._errHandler.sync(this),this._interp.adaptivePredict(this._input,26,this._ctx)){case 1:this.state=177,this.match(p.T__10),this.state=178,this.lexerRuleExpr(0),this.state=179,this.match(p.T__11);break;case 2:this.state=181,this.match(p.T__12),this.state=182,this.lexerRuleExpr(6);break;case 3:this.state=183,this.match(p.LexerIdentifier);break;case 4:this.state=184,this.match(p.String),this.state=185,this.match(p.T__13),this.state=186,this.match(p.T__13),this.state=187,this.match(p.String);break;case 5:this.state=188,this.match(p.String);break;case 6:this.state=189,this.match(p.T__13);break;case 7:this.state=190,this.match(p.Brackets)}this._ctx.stop=this._input.LT(-1),this.state=207,this._errHandler.sync(this);for(var s=this._interp.adaptivePredict(this._input,29,this._ctx);2!=s&&s!=r.atn.ATN.INVALID_ALT_NUMBER;){if(1===s)switch(null!==this._parseListeners&&this.triggerExitRuleEvent(),i,this.state=205,this._errHandler.sync(this),this._interp.adaptivePredict(this._input,28,this._ctx)){case 1:if(i=new F(this,e,n),this.pushNewRecursionContext(i,22,p.RULE_lexerRuleExpr),this.state=193,!this.precpred(this._ctx,9))throw new r.error.FailedPredicateException(this,"this.precpred(this._ctx, 9)");this.state=194,this.match(p.T__4),this.state=195,this.lexerRuleExpr(10);break;case 2:if(i=new F(this,e,n),this.pushNewRecursionContext(i,22,p.RULE_lexerRuleExpr),this.state=196,!this.precpred(this._ctx,8))throw new r.error.FailedPredicateException(this,"this.precpred(this._ctx, 8)");this.state=197,this.lexerRuleExpr(9);break;case 3:if(i=new F(this,e,n),this.pushNewRecursionContext(i,22,p.RULE_lexerRuleExpr),this.state=198,!this.precpred(this._ctx,11))throw new r.error.FailedPredicateException(this,"this.precpred(this._ctx, 11)");this.state=199,this.match(p.T__6);break;case 4:if(i=new F(this,e,n),this.pushNewRecursionContext(i,22,p.RULE_lexerRuleExpr),this.state=200,!this.precpred(this._ctx,10))throw new r.error.FailedPredicateException(this,"this.precpred(this._ctx, 10)");this.state=201,(o=this._input.LA(1))!==p.T__7&&o!==p.T__8?this._errHandler.recoverInline(this):(this._errHandler.reportMatch(this),this.consume()),this.state=203,this._errHandler.sync(this),1===this._interp.adaptivePredict(this._input,27,this._ctx)&&(this.state=202,this.match(p.T__6))}this.state=209,this._errHandler.sync(this),s=this._interp.adaptivePredict(this._input,29,this._ctx)}}catch(t){if(!(t instanceof r.error.RecognitionException))throw t;i.exception=t,this._errHandler.reportError(this,t),this._errHandler.recover(this,t)}finally{this.unrollRecursionContexts(e)}return i},p.prototype.sempred=function(t,e,n){switch(e){case 11:return this.lexerRuleExpr_sempred(t,n);default:throw"No predicate with index:"+e}},p.prototype.lexerRuleExpr_sempred=function(t,e){switch(e){case 0:return this.precpred(this._ctx,9);case 1:return this.precpred(this._ctx,8);case 2:return this.precpred(this._ctx,11);case 3:return this.precpred(this._ctx,10);default:throw"No predicate with index:"+e}},e.BlocklyGrammerParser=p},function(module,exports,__webpack_require__){var antlr4=__webpack_require__(12),BlocklyGrammerVisitor=__webpack_require__(20).BlocklyGrammerVisitor;function SymbolVisitor(){return BlocklyGrammerVisitor.call(this),this}function EvalVisitor(){return BlocklyGrammerVisitor.call(this),this}SymbolVisitor.prototype=Object.create(BlocklyGrammerVisitor.prototype),SymbolVisitor.prototype.constructor=SymbolVisitor,SymbolVisitor.prototype.init=function(){return this.statementRules=[],this.expressionRules=[],this.expression_arithmetic_num=0,this.lexerRules={},this.grammerName="",this},SymbolVisitor.prototype.error=function(t){throw new Error(t)},SymbolVisitor.prototype.checkSymbol=function(){for(var t,e={},n=function(t,e){for(var n,r=0;n=t[r];r++)if(n[0]===e)return n[1];return[]},r=0;t=this.statementRules[r];r++)if(t[1].length>1)for(var i,o=0;i=t[1][o];o++)e[i]&&this.error("语句 "+i+" 同时在两个语句集合 "+e[i]+" 和 "+t[0]+" 中出现了"),e[i]=t[0],n(this.statementRules,i).length>1&&this.error(t[0]+" 下的子规则 "+i+' 包含了"|"');var s;for(r=0;s=this.expressionRules[r];r++)s[1].length>1&&"expression"!==s[0]&&this.error("表达式 "+s[0]+' 包含了"|"')},SymbolVisitor.prototype.visitGrammarFile=function(t){return this.visit(t.grammerDecl()),this.visit(t.statementRule()),this.visit(t.expressionRule()),this.visit(t.lexerRuleCollection(0)),this},SymbolVisitor.prototype.visitGrammerDecl=function(t){this.grammerName=t.children[1].getText()},SymbolVisitor.prototype.visitStatList=function(t){for(var e,n=t.ParserIdentifier(),r=0;e=n[r];r++)n[r]=e.getText();var i=n.shift();this.statementRules.push([i,n])},SymbolVisitor.prototype.visitStatValue=function(t){var e=t.ParserIdentifier(0).getText();this.statementRules.push([e,[e]])},SymbolVisitor.prototype.visitExprExpression=function(t){var e=[];this.expression_arithmetic_num=t.arithmeticRuleCollection().length;for(var n=0;n<this.expression_arithmetic_num;n++){var r="expression_arithmetic_"+n;e.push(r),this.expressionRules.push([r,[r]])}var i,o=t.ParserIdentifier();for(n=0;i=o[n];n++)o[n]=i.getText();e=e.concat(o),this.expressionRules.push(["expression",e])},SymbolVisitor.prototype.visitExprValue=function(t){var e=t.ParserIdentifier(0).getText();this.expressionRules.push([e,[e]])},SymbolVisitor.prototype.visitLexerRuleCollection=function(t){for(var e,n=t.lexerRule()||[],r=0;e=n[r];r++){var i=e.LexerIdentifier(0).getText();this.lexerRules[i]=""}},EvalVisitor.prototype=Object.create(BlocklyGrammerVisitor.prototype),EvalVisitor.prototype.constructor=EvalVisitor,EvalVisitor.prototype.init=function(t,e){this.rawInput=e;var n=function(t){for(var e,n={},r=0;e=t[r];r++)n[e[0]]={check:e[1],user:{}};return n};return this.grammerName=t.grammerName,this.statementRules=n(t.statementRules),this.expressionRules=n(t.expressionRules),this.lexerRules=t.lexerRules,this.notEntry={},this.valueColor=330,this.statementColor=160,this.entryColor=260,this.generLanguage="JavaScript",this.recieveOrder="ORDER_ATOMIC",this.sendOrder="ORDER_NONE",this.varPrefix="",this.blocks="",this},EvalVisitor.prototype.error=function(t){throw new Error(t)},EvalVisitor.prototype.setRule=function(t,e,n){"lexer"===t&&(this.lexerRules[e]=n),"statement"===t&&(this.statementRules[e]=n),"value"===t&&(this.expressionRules[e]=n)},EvalVisitor.prototype.getRule=function(t,e){return"lexer"===t?this.lexerRules[e]:"statement"===t?this.statementRules[e]:"value"===t?this.expressionRules[e]:void 0},EvalVisitor.prototype.escapeString=function(string_){return eval(string_)},EvalVisitor.prototype.matchInject=function(t){var e=new RegExp("/\\*[^\\S\\r\\n]*"+t+"[\\r\\n]*([^]*?)[\\r\\n]*\\*/"),n=this.rawInput.match(e);return n?n[1]:""},EvalVisitor.prototype.inject=["colour","tooltip","helpUrl","default","override"],EvalVisitor.prototype.loadInject=function(injectStr){if(!injectStr)return{default:[]};for(var obj={},ii=0,inject;inject=this.inject[ii];ii++){var pattern=new RegExp("^\\s*"+inject+"\\s*:\\s*([^\\r\\n]*)\\s*?[\\r\\n]+","m"),value=injectStr.match(pattern);value&&(obj[inject]=value[1],injectStr=injectStr.slice(0,value.index)+injectStr.slice(value.index+value[0].length))}return obj.colour&&(obj.colour=eval(obj.colour)),obj.default?obj.default=eval(obj.default):obj.default=[],obj.generFunc=injectStr,obj},EvalVisitor.prototype.initAssemble=function(t){t.inject=this.loadInject(this.matchInject(t.name));var e=[];t.vars=[],t.fieldDefault=[];for(var n,r=!1,i=0,o=0,s={};n=t.args[o];o++){var a=JSON.parse(JSON.stringify(n.data)),l=null;if(n.id)if(s[n.id]=s[n.id]?s[n.id]:0,a.name=n.id+"_"+s[n.id],s[n.id]++,"field"!==n.blockType){var u=this.getRule(n.blockType,n.id),c=u.check;a.check=1===c.length?c[0]:c,u.user[t.name]=t.type,this.notEntry[n.id]=!0,this.setRule(n.blockType,n.id,u)}else{var h={field_input:"text",field_number:"value",field_dropdown:"options",field_checkbox:"checked"}[a.type];void 0===(l=t.inject.default[i])&&(l=null),"options"===h?null==l&&(l=a[h][0][1]):(null!==l&&(a[h]=l),l=a[h]),i++}a.name?t.vars.push(a.name):(t.vars.push(null),r=!0),t.fieldDefault.push(l),e.push(a)}var p={type:t.name,message0:t.message.join(" "),args0:e,inputsInline:!0,tooltip:t.inject.tooltip||"",helpUrl:t.inject.helpUrl||""};0===e.length&&delete p.args0,r&&delete p.inputsInline;var f=this.getRule(t.type,t.name);c=1===(c=f.check).length?c[0]:c,"value"===t.type?(p.colour=t.inject.colour||this.valueColor,p.output=c):(p.colour=t.inject.colour||this.statementColor,p.previousStatement=c,p.nextStatement=c),f.blockjs=p,f.blockobj=t,this.setRule(t.type,t.name,f)},EvalVisitor.prototype.assemble=function(){for(var t=Object.keys(this.statementRules),e=0;o=this.statementRules[t[e]];e++)if(o.check.length>1){this.notEntry[t[e]]=!0;for(var n,r=0;n=o.check[r];r++){var i=this.getRule("statement",n);i.blockjs.nextStatement=o.check,this.setRule("statement",n,i),this.notEntry[n]=!0}}for(e=0;o=this.statementRules[t[e]];e++)this.notEntry[t[e]]||(this.notEntry[t[e]]=!1,delete o.blockjs.previousStatement,delete o.blockjs.nextStatement,delete o.blockjs.inputsInline,o.blockjs.colour=this.entryColor);var o,s=[],a=[];for(e=0;o=this.statementRules[t[e]];e++)if(o.check.length>1)a.push([t[e],o]);else{s.push(o),o.type="statement";var l=[],u="",c=function(t){t>0&&(u+=Array(2*t+1).join(" ")),t<0&&(u=u.slice(0,2*t))},h="Blockly."+this.generLanguage+".";l.push(u+"function(block) {\n"),c(1);for(r=0;y=o.blockobj.args[r];r++){var p=this.varPrefix+o.blockobj.vars[r];if(y.id)"value"===y.blockType?(l.push(u+"var "+p+" = "+h+"valueToCode(block, '"),l.push(p+"', \n  "+u+h+this.recieveOrder+")")):"statement"===y.blockType?(l.push(u+"var "+p+" = "+h+"statementToCode(block, '"),l.push(p+"')")):(l.push(u+"var "+p+" = block.getFieldValue('"),l.push(p+"')")),"field_checkbox"===y.data.type&&l.push(" === 'TRUE'"),l.push(";\n"),y.multi,{field_checkbox:!0,field_dropdown:!0,field_number:!0}[y.data.type]||y.omitted||(l.push(u+"if ("+p+"==='') {\n"),c(1),l.push(u+"throw new OmitedError(block,'"+p+"','"),l.push(t[e]+"');\n"),c(-1),l.push(u+"}\n")),"field"===y.blockType&&(l.push(u+p+" = "+this.grammerName+"Functions.pre('"),l.push(y.id+"')("+p+");\n"))}o.blockobj.inject.generFunc?(o.blockobj.inject.override&&(c(-9999),(l=[]).push(u+"function(block) {\n"),c(1)),l.push(u+o.blockobj.inject.generFunc.split("\n").join("\n"+u)),l.push("\n")):(l.push(u+"var code = '1111111111;\\n';\n"),l.push(u+"return code;\n")),c(-1),l.push(u+"}"),o.generFunc=l.join("")}t=Object.keys(this.expressionRules);var f;for(e=0;f=this.expressionRules[t[e]];e++)if(f.check.length>1)a.push([t[e],f]);else{s.push(f),f.type="value";l=[],u="",c=function(t){t>0&&(u+=Array(2*t+1).join(" ")),t<0&&(u=u.slice(0,2*t))},h="Blockly."+this.generLanguage+".";l.push(u+"function(block) {\n"),c(1);for(r=0;y=f.blockobj.args[r];r++){p=this.varPrefix+f.blockobj.vars[r];if(y.id)"value"===y.blockType?(l.push(u+"var "+p+" = "+h+"valueToCode(block, '"),l.push(p+"', \n  "+u+h+this.recieveOrder+")")):"statement"===y.blockType?(l.push(u+"var "+p+" = "+h+"statementToCode(block, '"),l.push(p+"')")):(l.push(u+"var "+p+" = block.getFieldValue('"),l.push(p+"')")),"field_checkbox"===y.data.type&&l.push(" === 'TRUE'"),l.push(";\n"),y.multi,{field_checkbox:!0,field_dropdown:!0,field_number:!0}[y.data.type]||y.omitted||(l.push(u+"if ("+p+"==='') {\n"),c(1),l.push(u+"throw new OmitedError(block,'"+p+"','"),l.push(t[e]+"');\n"),c(-1),l.push(u+"}\n")),"field"===y.blockType&&(l.push(u+p+" = "+this.grammerName+"Functions.pre('"),l.push(y.id+"')("+p+");\n"))}f.blockobj.inject.generFunc?(f.blockobj.inject.override&&(c(-9999),(l=[]).push(u+"function(block) {\n"),c(1)),l.push(u+f.blockobj.inject.generFunc.split("\n").join("\n"+u)),l.push("\n")):(l.push(u+"var code = 0000000000;\n"),l.push(u+"return [code, "+h+this.sendOrder+"];\n")),c(-1),l.push(u+"}"),f.generFunc=l.join("")}var d;for(e=0;d=s[e];e++){d.args=[],d.argsType=[],d.fieldDefault=[];var y;for(r=0;y=d.blockobj.args[r];r++)y.id&&(d.args.push(d.blockobj.vars[r]),d.argsType.push(y.blockType),d.fieldDefault.push(d.blockobj.fieldDefault[r]));l=[],u="",c=function(t){t>0&&(u+=Array(2*t+1).join(" ")),t<0&&(u=u.slice(0,2*t))};var g=this.grammerName,v=d.check[0];l.push(u+"function (inputs,isShadow) {\n"),c(1),l.push(u+"return "+g+"Functions.xmlText('"),l.push(v+"',inputs,isShadow);\n"),c(-1),l.push(u+"}"),d.xmlText=l.join("")}this.temp_xml=s,this.temp_collection=a},EvalVisitor.prototype.generBlocks=function(){var t=[],e="",n=function(t){t>0&&(e+=Array(2*t+1).join(" ")),t<0&&(e=e.slice(0,2*t))};temp_xml=this.temp_xml,delete this.temp_xml,temp_collection=this.temp_collection,delete this.temp_collection,t.push(e+this.grammerName+"Blocks = {\n"),n(1);for(var r,i=0;r=temp_collection[i];i++)t.push(e+'"'+r[0]+'": '),t.push(JSON.stringify(r[1].check,null,2).split("\n").join("\n"+e)),t.push(",\n");function o(t,e,n){var r=e.blockjs,i=JSON.stringify(r).split("\n").join("\n"+n),o={};r=JSON.parse(i);for(var s,a=0;s=e.blockobj.args[a];a++)if(s.id){var l=t.getRule(s.blockType,s.id);l&&1!==l.check.length&&(r.args0[a].check="1_fry2_3_inrgv"+s.id,o['"1_fry2_3_inrgv'+s.id+'"']=t.grammerName+"Blocks."+s.id)}if(r.nextStatement)for(var u,c=0;u=temp_collection[c];c++)if(-1!==u[1].check.indexOf(r.type)){r.nextStatement="1_fry2_3_inrgv"+u[0],o['"1_fry2_3_inrgv'+u[0]+'"']=t.grammerName+"Blocks."+u[0];break}for(var h in i=JSON.stringify(r,null,2).split("\n").join("\n"+n),o)i=i.split(h).join(o[h]);return i}t.pop(),t.push("\n"),n(-1),t.push(e+"}\n"),t.push(e+this.grammerName+"Blocks = Object.assign("),t.push(this.grammerName+"Blocks,{\n"),n(1);var s;for(i=0;s=temp_xml[i];i++)t.push(e+'"'+s.check[0]+'": {\n'),n(1),t.push(e+'"type": "'+s.type+'",\n'),t.push(e+'"json": '),t.push(o(this,s,e)),t.push(",\n"),t.push(e+'"generFunc": '),t.push(s.generFunc.split("\n").join("\n"+e)),t.push(",\n"),t.push(e+'"args": '),t.push(JSON.stringify(s.args,null,2).split("\n").join("\n"+e)),t.push(",\n"),t.push(e+'"argsType": '),t.push(JSON.stringify(s.argsType,null,0)),t.push(",\n"),t.push(e+'"fieldDefault": '),t.push(JSON.stringify(s.fieldDefault,null,0)),t.push(",\n"),t.push(e+'"xmlText": '),t.push(s.xmlText.split("\n").join("\n"+e)),t.push("\n"),n(-1),t.push(e+"},\n");t.pop(),t.push(e+"}\n"),n(-1),t.push(e+"});\n"),this.blocks=t.join("")},EvalVisitor.prototype.SpeicalLexerRule=function(t){var e={};return"Bool"===t?(e={type:"field_checkbox",checked:!0},this.setRule("lexer",t,e),!0):"Int"===t?(e={type:"field_number",value:0,min:0,precision:1},this.setRule("lexer",t,e),!0):"Number"===t?(e={type:"field_number",value:0},this.setRule("lexer",t,e),!0):"BGNL"===t&&(e={type:"input_dummy"},this.setRule("lexer",t,e),!0)},EvalVisitor.prototype.visitGrammarFile=function(t){this.visit(t.lexerRuleCollection(0)),this.visit(t.statementRule()),this.expression_arithmetic_num=0,this.visit(t.expressionRule()),this.assemble()},EvalVisitor.prototype.visitStrings=function(t){for(var e,n=t.String(),r=0;e=n[r];r++)n[r]=this.escapeString(e.getText());return n.join(" ")},EvalVisitor.prototype.visitLexerRuleStrings=function(t){var e=t.LexerIdentifier(0).getText();if(!this.SpeicalLexerRule(e)){var n=this.visit(t.strings(0));this.setRule("lexer",e,n)}},EvalVisitor.prototype.visitLexerRuleList=function(ctx){var lexerId=ctx.LexerIdentifier(0).getText();if(!this.SpeicalLexerRule(lexerId))if("_List"===lexerId.slice(-5)){var strings=ctx.strings(),values=this.matchInject(lexerId);values=values?eval(values):[];for(var ii=0,value;value=strings[ii];ii++){var string_=this.visit(value);strings[ii]=[string_,null==values[ii]?string_:values[ii]]}var lexervalue={type:"field_dropdown",options:strings};this.setRule("lexer",lexerId,lexervalue)}else this.visitLexerRuleComplex(ctx)},EvalVisitor.prototype.visitLexerRuleComplex=function(t){var e=t.LexerIdentifier(0).getText();if(!this.SpeicalLexerRule(e)){var n={type:"field_input",text:e+"_default"};this.setRule("lexer",e,n)}},EvalVisitor.prototype.visitStatValue=function(t){this.status={name:t.ParserIdentifier(0).getText(),type:"statement",message:[],args:[]},this.visitChildren(t);var e=this.status;delete this.status,this.initAssemble(e)},BlocklyGrammerVisitor.prototype.visitArithmeticRuleCollection=function(t){this.status={name:"expression",type:"value",message:["%1"],args:[{id:"expression",blockType:"value",omitted:!1,data:{type:"input_value"}}]},this.visitChildren(t),this.status.name="expression_arithmetic_"+this.expression_arithmetic_num,this.expression_arithmetic_num++;var e=this.status;delete this.status,this.initAssemble(e)},BlocklyGrammerVisitor.prototype.visitExprValue=function(t){this.status={name:t.ParserIdentifier(0).getText(),type:"value",message:[],args:[]},this.visitChildren(t);var e=this.status;delete this.status,this.initAssemble(e)},EvalVisitor.prototype.visitParserAtomExpr=function(t){var e={id:"expression",blockType:"value",omitted:t.children.length>1,data:{type:"input_value"}};this.status.args.push(e),this.status.message.push("%"+this.status.args.length)},EvalVisitor.prototype.visitParserAtomParserId=function(t){var e=t.children[0].getText(),n=t.children.length>1&&t.children[1].getText()||"",r=this.getRule("value",e)?"value":"statement",i={id:e,blockType:r,omitted:"?"===n||"*"===n,multi:"+"===n||"*"===n,data:{type:"input_"+r}};"value"===r&&i.multi&&this.error(this.status.name+" 下出现了复数组合的表达式 "+e+n),this.status.args.push(i),this.status.message.push("%"+this.status.args.length)},EvalVisitor.prototype.visitParserAtomLexerId=function(t){var e=t.children[0].getText(),n=this.getRule("lexer",e);if(n){var r={id:e,blockType:"field",omitted:t.children.length>1,data:n};"BGNL"===e&&(r={data:n}),"string"!=typeof n?(this.status.args.push(r),this.status.message.push("%"+this.status.args.length)):this.status.message.push(n)}},EvalVisitor.prototype.visitParserAtomStr=function(t){var e=this.escapeString(t.String().getText());this.status.message.push(e)},exports.SymbolVisitor=SymbolVisitor,exports.EvalVisitor=EvalVisitor},function(t,e){e.OmitedError=function(){return"//生成代码中,当一个不允许省略的值或块省略时,会抛出这个错误\nfunction OmitedError(block, var_, rule, fileName, lineNumber) {\n  var message = 'no omitted '+var_+' at '+rule;\n  var instance = new Error(message, fileName, lineNumber);\n  instance.block = block;\n  instance.varName = var_;\n  instance.blockName = rule;\n  instance.name = 'OmitedError';\n  Object.setPrototypeOf(instance, Object.getPrototypeOf(this));\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(instance, OmitedError);\n  }\n  return instance;\n}\n\nOmitedError.prototype = Object.create(Error.prototype);\nOmitedError.prototype.constructor = OmitedError;\n//处理此错误的omitedcheckUpdateFunction定义在下面"},e.Functions_pre=function(t){return`${t}Functions.Int_pre = function(intstr) {\n  return parseInt(intstr);\n}\n\n${t}Functions.Number_pre = function(intstr) {\n  return parseFloat(intstr);\n}\n\n//返回各LexerRule文本域的预处理函数,方便用来统一转义等等\n${t}Functions.pre = function(LexerId) {\n  if (${t}Functions.hasOwnProperty(LexerId+'_pre')) {\n    return ${t}Functions[LexerId+'_pre'];\n  }\n  return function(obj){return obj}\n}`},e.Functions_xmlText=function(t){return`//构造这个方法是为了能够不借助workspace,从语法树直接构造图块结构\n//inputs的第i个元素是第i个args的xmlText,null或undefined表示空\n//inputs的第rule.args.length个元素是其下一个语句的xmlText\n${t}Functions.xmlText = function (ruleName,inputs,isShadow) {\n  var rule = ${t}Blocks[ruleName];\n  var blocktext = isShadow?'shadow':'block';\n  var xmlText = [];\n  xmlText.push('<'+blocktext+' type="'+ruleName+'">');\n  if(!inputs)inputs=[];\n  for (var ii=0,inputType;inputType=rule.argsType[ii];ii++) {\n    var input = inputs[ii];\n    var _input = '';\n    var noinput = (input===null || input===undefined);\n    if(noinput && inputType==='field') continue;\n    if(noinput) input = '';\n    if(inputType!=='field') {\n      var subList = false;\n      var subrulename = rule.args[ii];\n      subrulename=subrulename.split('_').slice(0,-1).join('_');\n      var subrule = ${t}Blocks[subrulename];\n      if (subrule instanceof Array) {\n        subrulename=subrule[subrule.length-1];\n        subrule = ${t}Blocks[subrulename];\n        subList = true;\n      }\n      _input = subrule.xmlText([],true);\n      if(noinput && !subList && !isShadow) {\n        //无输入的默认行为是: 如果语句块的备选方块只有一个,直接代入方块\n        input = subrule.xmlText();\n      }\n    }\n    xmlText.push('<'+inputType+' name="'+rule.args[ii]+'">');\n    xmlText.push(_input+input);\n    xmlText.push('</'+inputType+'>');\n  }\n  var next = inputs[rule.args.length];\n  if (next) {//next\n    xmlText.push('<next>');\n    xmlText.push(next);\n    xmlText.push('</next>');\n  }\n  xmlText.push('</'+blocktext+'>');\n  return xmlText.join('');\n}`},e.Functions_blocksIniter=function(t,e){return`//把各方块的信息注册到Blockly中\n${t}Functions.blocksIniter = function(){\n  var blocksobj = ${t}Blocks;\n  for(var key in blocksobj) {\n    var value = blocksobj[key];\n    if(value instanceof Array)continue;\n    (function(key,value){\n      Blockly.Blocks[key] = {\n        init: function() {this.jsonInit(value.json);}\n      }\n    })(key,value);\n    Blockly.${e}[key] = value.generFunc;\n  }\n}`},e.mainFileTPL=function(t,e,n,r,i,o,s,a){return[`<!doctype html>\n<head>\n<meta charset="utf-8">\n<title>${t} --antlr-blockly</title>`,'\n<script src="blockly_compressed.js"><\/script>\n<script src="blocks_compressed.js"><\/script>\n<script src="javascript_compressed.js"><\/script>\n<script src="zh-hans.js"><\/script>\n\x3c!-- <script src="en.js"><\/script> --\x3e',"\n</head>\n<body>",`\n\n<p>\n<button onclick="showXML()">Show XML</button>\n<button onclick="runCode()">console.log(obj=code)</button>\n</p>\n<div id="${n}" style="height: 480px; width: 940px;"></div>\n<pre id="${r}"></pre>\n${i}\n`,"\n<script>\n",`\n${a}\n`,`\nvar ${o} = Blockly.inject('${n}',{\n  media: 'media/',\n  toolbox: document.getElementById('${s}'),\n  zoom:{\n    controls: true,\n    wheel: true,//false\n    startScale: 1.0,\n    maxScale: 3,\n    minScale: 0.3,\n    scaleSpeed: 1.08\n  },\n  trashcan: false,\n});\n\nfunction omitedcheckUpdateFunction(event) {\n  console.log(event);\n  try {\n    var code = Blockly.${e}.workspaceToCode(${o});\n    document.getElementById('${r}').innerText = code;\n  } catch (error) {\n    document.getElementById('${r}').innerText = String(error);\n    if (error instanceof OmitedError){\n      var blockName = error.blockName;\n      var varName = error.varName;\n      var block = error.block;\n    }\n    console.log(error);\n  }\n}\n\n${o}.addChangeListener(omitedcheckUpdateFunction);\n\n${o}.addChangeListener(Blockly.Events.disableOrphans);\n//自动禁用任何未连接到根块的块\n`,`\n\nfunction showXML() {\n  xml = Blockly.Xml.workspaceToDom(${o});\n  xml_text = Blockly.Xml.domToPrettyText(xml);\n  console.log(xml_text);\n  xml_text = Blockly.Xml.domToText(xml);\n  console.log(xml_text);\n  console.log(xml);\n}\n\nfunction runCode() {\n  // Generate ${e} code and run it.\n  window.LoopTrap = 1000;\n  Blockly.${e}.INFINITE_LOOP_TRAP =\n    'if (--window.LoopTrap == 0) throw "Infinite loop.";\\n';\n  code = Blockly.${e}.workspaceToCode(${o});\n  Blockly.${e}.INFINITE_LOOP_TRAP = null;\n  try {\n    eval('obj=' + code);\n    console.log(obj);\n  } catch (e) {\n    alert(e);\n  }\n}\n`,"\n<\/script>\n\n","</body>\n</html>\n"]}}]);
\ No newline at end of file
+!function(t){var e={};function n(r){if(e[r])return e[r].exports;var i=e[r]={i:r,l:!1,exports:{}};return t[r].call(i.exports,i,i.exports,n),i.l=!0,i.exports}n.m=t,n.c=e,n.d=function(t,e,r){n.o(t,e)||Object.defineProperty(t,e,{configurable:!1,enumerable:!0,get:r})},n.n=function(t){var e=t&&t.__esModule?function(){return t.default}:function(){return t};return n.d(e,"a",e),e},n.o=function(t,e){return Object.prototype.hasOwnProperty.call(t,e)},n.p="",n(n.s=32)}([function(t,e){function n(t){return"["+t.join(", ")+"]"}function r(t,e){return t.equals(e)}function i(t){return t.hashCode()}function o(t,e){return this.data={},this.hashFunction=t||i,this.equalsFunction=e||r,this}function s(){return this.data=[],this}function a(t,e){return this.data={},this.hashFunction=t||i,this.equalsFunction=e||r,this}function l(){return this.data={},this}function u(){return this}function c(){return this.count=0,this.hash=0,this}String.prototype.seed=String.prototype.seed||Math.round(Math.random()*Math.pow(2,32)),String.prototype.hashCode=function(){var t,e,n,r,i,o,s,a,l=this.toString();for(t=3&l.length,e=l.length-t,n=String.prototype.seed,i=3432918353,o=461845907,a=0;a<e;)s=255&l.charCodeAt(a)|(255&l.charCodeAt(++a))<<8|(255&l.charCodeAt(++a))<<16|(255&l.charCodeAt(++a))<<24,++a,n=27492+(65535&(r=5*(65535&(n=(n^=s=(65535&(s=(s=(65535&s)*i+(((s>>>16)*i&65535)<<16)&4294967295)<<15|s>>>17))*o+(((s>>>16)*o&65535)<<16)&4294967295)<<13|n>>>19))+((5*(n>>>16)&65535)<<16)&4294967295))+((58964+(r>>>16)&65535)<<16);switch(s=0,t){case 3:s^=(255&l.charCodeAt(a+2))<<16;case 2:s^=(255&l.charCodeAt(a+1))<<8;case 1:n^=s=(65535&(s=(s=(65535&(s^=255&l.charCodeAt(a)))*i+(((s>>>16)*i&65535)<<16)&4294967295)<<15|s>>>17))*o+(((s>>>16)*o&65535)<<16)&4294967295}return n^=l.length,n=2246822507*(65535&(n^=n>>>16))+((2246822507*(n>>>16)&65535)<<16)&4294967295,n=3266489909*(65535&(n^=n>>>13))+((3266489909*(n>>>16)&65535)<<16)&4294967295,(n^=n>>>16)>>>0},Object.defineProperty(o.prototype,"length",{get:function(){var t=0;for(var e in this.data)0===e.indexOf("hash_")&&(t+=this.data[e].length);return t}}),o.prototype.add=function(t){var e="hash_"+this.hashFunction(t);if(e in this.data){for(var n=this.data[e],r=0;r<n.length;r++)if(this.equalsFunction(t,n[r]))return n[r];return n.push(t),t}return this.data[e]=[t],t},o.prototype.contains=function(t){return null!=this.get(t)},o.prototype.get=function(t){var e="hash_"+this.hashFunction(t);if(e in this.data)for(var n=this.data[e],r=0;r<n.length;r++)if(this.equalsFunction(t,n[r]))return n[r];return null},o.prototype.values=function(){var t=[];for(var e in this.data)0===e.indexOf("hash_")&&(t=t.concat(this.data[e]));return t},o.prototype.toString=function(){return n(this.values())},s.prototype.add=function(t){this.data[t]=!0},s.prototype.or=function(t){var e=this;Object.keys(t.data).map(function(t){e.add(t)})},s.prototype.remove=function(t){delete this.data[t]},s.prototype.contains=function(t){return!0===this.data[t]},s.prototype.values=function(){return Object.keys(this.data)},s.prototype.minValue=function(){return Math.min.apply(null,this.values())},s.prototype.hashCode=function(){var t=new c;return t.update(this.values()),t.finish()},s.prototype.equals=function(t){return t instanceof s&&this.hashCode()===t.hashCode()},Object.defineProperty(s.prototype,"length",{get:function(){return this.values().length}}),s.prototype.toString=function(){return"{"+this.values().join(", ")+"}"},Object.defineProperty(a.prototype,"length",{get:function(){var t=0;for(var e in this.data)0===e.indexOf("hash_")&&(t+=this.data[e].length);return t}}),a.prototype.put=function(t,e){var n="hash_"+this.hashFunction(t);if(n in this.data){for(var r=this.data[n],i=0;i<r.length;i++){var o=r[i];if(this.equalsFunction(t,o.key)){var s=o.value;return o.value=e,s}}return r.push({key:t,value:e}),e}return this.data[n]=[{key:t,value:e}],e},a.prototype.containsKey=function(t){var e="hash_"+this.hashFunction(t);if(e in this.data)for(var n=this.data[e],r=0;r<n.length;r++){var i=n[r];if(this.equalsFunction(t,i.key))return!0}return!1},a.prototype.get=function(t){var e="hash_"+this.hashFunction(t);if(e in this.data)for(var n=this.data[e],r=0;r<n.length;r++){var i=n[r];if(this.equalsFunction(t,i.key))return i.value}return null},a.prototype.entries=function(){var t=[];for(var e in this.data)0===e.indexOf("hash_")&&(t=t.concat(this.data[e]));return t},a.prototype.getKeys=function(){return this.entries().map(function(t){return t.key})},a.prototype.getValues=function(){return this.entries().map(function(t){return t.value})},a.prototype.toString=function(){return"["+this.entries().map(function(t){return"{"+t.key+":"+t.value+"}"}).join(", ")+"]"},l.prototype.get=function(t){return(t="k-"+t)in this.data?this.data[t]:null},l.prototype.put=function(t,e){t="k-"+t,this.data[t]=e},l.prototype.values=function(){var t=this.data;return Object.keys(this.data).map(function(e){return t[e]})},c.prototype.update=function(){for(var t=0;t<arguments.length;t++){var e=arguments[t];if(null!=e)if(Array.isArray(e))this.update.apply(e);else{var n=0;switch(typeof e){case"undefined":case"function":continue;case"number":case"boolean":n=e;break;case"string":n=e.hashCode();break;default:e.updateHashCode(this);continue}n=(n*=3432918353)<<15|n>>>17,n*=461845907,this.count=this.count+1;var r=this.hash^n;r=5*(r=r<<13|r>>>19)+3864292196,this.hash=r}}},c.prototype.finish=function(){var t=this.hash^4*this.count;return t^=t>>>16,t*=2246822507,t^=t>>>13,t*=3266489909,t^=t>>>16},u.prototype.get=function(t,e){var n=this[t]||null;return null===n?null:n[e]||null},u.prototype.set=function(t,e,n){var r=this[t]||null;null===r&&(r={},this[t]=r),r[e]=n},e.Hash=c,e.Set=o,e.Map=a,e.BitSet=s,e.AltDict=l,e.DoubleDict=u,e.hashStuff=function(){var t=new c;return t.update.apply(arguments),t.finish()},e.escapeWhitespace=function(t,e){return t=(t=(t=t.replace("\t","\\t")).replace("\n","\\n")).replace("\r","\\r"),e&&(t=t.replace(" ","·")),t},e.arrayToString=n,e.titleCase=function(t){return t.replace(/\w\S*/g,function(t){return t.charAt(0).toUpperCase()+t.substr(1)})},e.equalArrays=function(t,e){if(!Array.isArray(t)||!Array.isArray(e))return!1;if(t==e)return!0;if(t.length!=e.length)return!1;for(var n=0;n<t.length;n++)if(t[n]!=e[n]&&!t[n].equals(e[n]))return!1;return!0}},function(t,e){function n(){return this.source=null,this.type=null,this.channel=null,this.start=null,this.stop=null,this.tokenIndex=null,this.line=null,this.column=null,this._text=null,this}function r(t,e,i,o,s){return n.call(this),this.source=void 0!==t?t:r.EMPTY_SOURCE,this.type=void 0!==e?e:null,this.channel=void 0!==i?i:n.DEFAULT_CHANNEL,this.start=void 0!==o?o:-1,this.stop=void 0!==s?s:-1,this.tokenIndex=-1,null!==this.source[0]?(this.line=t[0].line,this.column=t[0].column):this.column=-1,this}n.INVALID_TYPE=0,n.EPSILON=-2,n.MIN_USER_TOKEN_TYPE=1,n.EOF=-1,n.DEFAULT_CHANNEL=0,n.HIDDEN_CHANNEL=1,Object.defineProperty(n.prototype,"text",{get:function(){return this._text},set:function(t){this._text=t}}),n.prototype.getTokenSource=function(){return this.source[0]},n.prototype.getInputStream=function(){return this.source[1]},r.prototype=Object.create(n.prototype),r.prototype.constructor=r,r.EMPTY_SOURCE=[null,null],r.prototype.clone=function(){var t=new r(this.source,this.type,this.channel,this.start,this.stop);return t.tokenIndex=this.tokenIndex,t.line=this.line,t.column=this.column,t.text=this.text,t},Object.defineProperty(r.prototype,"text",{get:function(){if(null!==this._text)return this._text;var t=this.getInputStream();if(null===t)return null;var e=t.size;return this.start<e&&this.stop<e?t.getText(this.start,this.stop):"<EOF>"},set:function(t){this._text=t}}),r.prototype.toString=function(){var t=this.text;return t=null!==t?t.replace(/\n/g,"\\n").replace(/\r/g,"\\r").replace(/\t/g,"\\t"):"<no text>","[@"+this.tokenIndex+","+this.start+":"+this.stop+"='"+t+"',<"+this.type+">"+(this.channel>0?",channel="+this.channel:"")+","+this.line+":"+this.column+"]"},e.Token=n,e.CommonToken=r},function(t,e,n){var r=n(1).Token;function i(t,e){return this.start=t,this.stop=e,this}function o(){this.intervals=null,this.readOnly=!1}i.prototype.contains=function(t){return t>=this.start&&t<this.stop},i.prototype.toString=function(){return this.start===this.stop-1?this.start.toString():this.start.toString()+".."+(this.stop-1).toString()},Object.defineProperty(i.prototype,"length",{get:function(){return this.stop-this.start}}),o.prototype.first=function(t){return null===this.intervals||0===this.intervals.length?r.INVALID_TYPE:this.intervals[0].start},o.prototype.addOne=function(t){this.addInterval(new i(t,t+1))},o.prototype.addRange=function(t,e){this.addInterval(new i(t,e+1))},o.prototype.addInterval=function(t){if(null===this.intervals)this.intervals=[],this.intervals.push(t);else{for(var e=0;e<this.intervals.length;e++){var n=this.intervals[e];if(t.stop<n.start)return void this.intervals.splice(e,0,t);if(t.stop===n.start)return void(this.intervals[e].start=t.start);if(t.start<=n.stop)return this.intervals[e]=new i(Math.min(n.start,t.start),Math.max(n.stop,t.stop)),void this.reduce(e)}this.intervals.push(t)}},o.prototype.addSet=function(t){if(null!==t.intervals)for(var e=0;e<t.intervals.length;e++){var n=t.intervals[e];this.addInterval(new i(n.start,n.stop))}return this},o.prototype.reduce=function(t){if(t<this.intervalslength-1){var e=this.intervals[t],n=this.intervals[t+1];e.stop>=n.stop?(this.intervals.pop(t+1),this.reduce(t)):e.stop>=n.start&&(this.intervals[t]=new i(e.start,n.stop),this.intervals.pop(t+1))}},o.prototype.complement=function(t,e){var n=new o;n.addInterval(new i(t,e+1));for(var r=0;r<this.intervals.length;r++)n.removeRange(this.intervals[r]);return n},o.prototype.contains=function(t){if(null===this.intervals)return!1;for(var e=0;e<this.intervals.length;e++)if(this.intervals[e].contains(t))return!0;return!1},Object.defineProperty(o.prototype,"length",{get:function(){var t=0;return this.intervals.map(function(e){t+=e.length}),t}}),o.prototype.removeRange=function(t){if(t.start===t.stop-1)this.removeOne(t.start);else if(null!==this.intervals)for(var e=0,n=0;n<this.intervals.length;n++){var r=this.intervals[e];if(t.stop<=r.start)return;if(t.start>r.start&&t.stop<r.stop){this.intervals[e]=new i(r.start,t.start);var o=new i(t.stop,r.stop);return void this.intervals.splice(e,0,o)}t.start<=r.start&&t.stop>=r.stop?(this.intervals.splice(e,1),e-=1):t.start<r.stop?this.intervals[e]=new i(r.start,t.start):t.stop<r.stop&&(this.intervals[e]=new i(t.stop,r.stop)),e+=1}},o.prototype.removeOne=function(t){if(null!==this.intervals)for(var e=0;e<this.intervals.length;e++){var n=this.intervals[e];if(t<n.start)return;if(t===n.start&&t===n.stop-1)return void this.intervals.splice(e,1);if(t===n.start)return void(this.intervals[e]=new i(n.start+1,n.stop));if(t===n.stop-1)return void(this.intervals[e]=new i(n.start,n.stop-1));if(t<n.stop-1){var r=new i(n.start,t);return n.start=t+1,void this.intervals.splice(e,0,r)}}},o.prototype.toString=function(t,e,n){return t=t||null,e=e||null,n=n||!1,null===this.intervals?"{}":null!==t||null!==e?this.toTokenString(t,e):n?this.toCharString():this.toIndexString()},o.prototype.toCharString=function(){for(var t=[],e=0;e<this.intervals.length;e++){var n=this.intervals[e];n.stop===n.start+1?n.start===r.EOF?t.push("<EOF>"):t.push("'"+String.fromCharCode(n.start)+"'"):t.push("'"+String.fromCharCode(n.start)+"'..'"+String.fromCharCode(n.stop-1)+"'")}return t.length>1?"{"+t.join(", ")+"}":t[0]},o.prototype.toIndexString=function(){for(var t=[],e=0;e<this.intervals.length;e++){var n=this.intervals[e];n.stop===n.start+1?n.start===r.EOF?t.push("<EOF>"):t.push(n.start.toString()):t.push(n.start.toString()+".."+(n.stop-1).toString())}return t.length>1?"{"+t.join(", ")+"}":t[0]},o.prototype.toTokenString=function(t,e){for(var n=[],r=0;r<this.intervals.length;r++)for(var i=this.intervals[r],o=i.start;o<i.stop;o++)n.push(this.elementName(t,e,o));return n.length>1?"{"+n.join(", ")+"}":n[0]},o.prototype.elementName=function(t,e,n){return n===r.EOF?"<EOF>":n===r.EPSILON?"<EPSILON>":t[n]||e[n]},e.Interval=i,e.IntervalSet=o},function(t,e){function n(){return this.atn=null,this.stateNumber=n.INVALID_STATE_NUMBER,this.stateType=null,this.ruleIndex=0,this.epsilonOnlyTransitions=!1,this.transitions=[],this.nextTokenWithinRule=null,this}function r(){return n.call(this),this.stateType=n.BASIC,this}function i(){return n.call(this),this.decision=-1,this.nonGreedy=!1,this}function o(){return i.call(this),this.endState=null,this}function s(){return o.call(this),this.stateType=n.BLOCK_START,this}function a(){return n.call(this),this.stateType=n.BLOCK_END,this.startState=null,this}function l(){return n.call(this),this.stateType=n.RULE_STOP,this}function u(){return n.call(this),this.stateType=n.RULE_START,this.stopState=null,this.isPrecedenceRule=!1,this}function c(){return i.call(this),this.stateType=n.PLUS_LOOP_BACK,this}function h(){return o.call(this),this.stateType=n.PLUS_BLOCK_START,this.loopBackState=null,this}function p(){return o.call(this),this.stateType=n.STAR_BLOCK_START,this}function f(){return n.call(this),this.stateType=n.STAR_LOOP_BACK,this}function d(){return i.call(this),this.stateType=n.STAR_LOOP_ENTRY,this.loopBackState=null,this.isPrecedenceDecision=null,this}function y(){return n.call(this),this.stateType=n.LOOP_END,this.loopBackState=null,this}function g(){return i.call(this),this.stateType=n.TOKEN_START,this}n.INVALID_TYPE=0,n.BASIC=1,n.RULE_START=2,n.BLOCK_START=3,n.PLUS_BLOCK_START=4,n.STAR_BLOCK_START=5,n.TOKEN_START=6,n.RULE_STOP=7,n.BLOCK_END=8,n.STAR_LOOP_BACK=9,n.STAR_LOOP_ENTRY=10,n.PLUS_LOOP_BACK=11,n.LOOP_END=12,n.serializationNames=["INVALID","BASIC","RULE_START","BLOCK_START","PLUS_BLOCK_START","STAR_BLOCK_START","TOKEN_START","RULE_STOP","BLOCK_END","STAR_LOOP_BACK","STAR_LOOP_ENTRY","PLUS_LOOP_BACK","LOOP_END"],n.INVALID_STATE_NUMBER=-1,n.prototype.toString=function(){return this.stateNumber},n.prototype.equals=function(t){return t instanceof n&&this.stateNumber===t.stateNumber},n.prototype.isNonGreedyExitState=function(){return!1},n.prototype.addTransition=function(t,e){void 0===e&&(e=-1),0===this.transitions.length?this.epsilonOnlyTransitions=t.isEpsilon:this.epsilonOnlyTransitions!==t.isEpsilon&&(this.epsilonOnlyTransitions=!1),-1===e?this.transitions.push(t):this.transitions.splice(e,1,t)},r.prototype=Object.create(n.prototype),r.prototype.constructor=r,i.prototype=Object.create(n.prototype),i.prototype.constructor=i,o.prototype=Object.create(i.prototype),o.prototype.constructor=o,s.prototype=Object.create(o.prototype),s.prototype.constructor=s,a.prototype=Object.create(n.prototype),a.prototype.constructor=a,l.prototype=Object.create(n.prototype),l.prototype.constructor=l,u.prototype=Object.create(n.prototype),u.prototype.constructor=u,c.prototype=Object.create(i.prototype),c.prototype.constructor=c,h.prototype=Object.create(o.prototype),h.prototype.constructor=h,p.prototype=Object.create(o.prototype),p.prototype.constructor=p,f.prototype=Object.create(n.prototype),f.prototype.constructor=f,d.prototype=Object.create(i.prototype),d.prototype.constructor=d,y.prototype=Object.create(n.prototype),y.prototype.constructor=y,g.prototype=Object.create(i.prototype),g.prototype.constructor=g,e.ATNState=n,e.BasicState=r,e.DecisionState=i,e.BlockStartState=o,e.BlockEndState=a,e.LoopEndState=y,e.RuleStartState=u,e.RuleStopState=l,e.TokensStartState=g,e.PlusLoopbackState=c,e.StarLoopbackState=f,e.StarLoopEntryState=d,e.PlusBlockStartState=h,e.StarBlockStartState=p,e.BasicBlockStartState=s},function(t,e,n){var r=n(1).Token,i=n(2).Interval,o=new i(-1,-2);n(0);function s(){return this}function a(){return s.call(this),this}function l(){return a.call(this),this}function u(){return l.call(this),this}function c(){return l.call(this),this}function h(){return c.call(this),this}function p(){return this}function f(){return this}function d(t){return c.call(this),this.parentCtx=null,this.symbol=t,this}function y(t){return d.call(this,t),this}function g(){return this}a.prototype=Object.create(s.prototype),a.prototype.constructor=a,l.prototype=Object.create(a.prototype),l.prototype.constructor=l,u.prototype=Object.create(l.prototype),u.prototype.constructor=u,c.prototype=Object.create(l.prototype),c.prototype.constructor=c,h.prototype=Object.create(c.prototype),h.prototype.constructor=h,p.prototype.visit=function(t){return Array.isArray(t)?t.map(function(t){return t.accept(this)},this):t.accept(this)},p.prototype.visitChildren=function(t){return this.visit(t.children)},p.prototype.visitTerminal=function(t){},p.prototype.visitErrorNode=function(t){},f.prototype.visitTerminal=function(t){},f.prototype.visitErrorNode=function(t){},f.prototype.enterEveryRule=function(t){},f.prototype.exitEveryRule=function(t){},d.prototype=Object.create(c.prototype),d.prototype.constructor=d,d.prototype.getChild=function(t){return null},d.prototype.getSymbol=function(){return this.symbol},d.prototype.getParent=function(){return this.parentCtx},d.prototype.getPayload=function(){return this.symbol},d.prototype.getSourceInterval=function(){if(null===this.symbol)return o;var t=this.symbol.tokenIndex;return new i(t,t)},d.prototype.getChildCount=function(){return 0},d.prototype.accept=function(t){return t.visitTerminal(this)},d.prototype.getText=function(){return this.symbol.text},d.prototype.toString=function(){return this.symbol.type===r.EOF?"<EOF>":this.symbol.text},y.prototype=Object.create(d.prototype),y.prototype.constructor=y,y.prototype.isErrorNode=function(){return!0},y.prototype.accept=function(t){return t.visitErrorNode(this)},g.prototype.walk=function(t,e){if(e instanceof h||void 0!==e.isErrorNode&&e.isErrorNode())t.visitErrorNode(e);else if(e instanceof c)t.visitTerminal(e);else{this.enterRule(t,e);for(var n=0;n<e.getChildCount();n++){var r=e.getChild(n);this.walk(t,r)}this.exitRule(t,e)}},g.prototype.enterRule=function(t,e){var n=e.getRuleContext();t.enterEveryRule(n),n.enterRule(t)},g.prototype.exitRule=function(t,e){var n=e.getRuleContext();n.exitRule(t),t.exitEveryRule(n)},g.DEFAULT=new g,e.RuleNode=u,e.ErrorNode=h,e.TerminalNode=c,e.ErrorNodeImpl=y,e.TerminalNodeImpl=d,e.ParseTreeListener=f,e.ParseTreeVisitor=p,e.ParseTreeWalker=g,e.INVALID_INTERVAL=o},function(t,e,n){var r=n(8).PredicateTransition;function i(t){if(Error.call(this),Error.captureStackTrace)Error.captureStackTrace(this,i);else(new Error).stack;return this.message=t.message,this.recognizer=t.recognizer,this.input=t.input,this.ctx=t.ctx,this.offendingToken=null,this.offendingState=-1,null!==this.recognizer&&(this.offendingState=this.recognizer.state),this}function o(t,e,n,r){return i.call(this,{message:"",recognizer:t,input:e,ctx:null}),this.startIndex=n,this.deadEndConfigs=r,this}function s(t,e,n,r,o,s){s=s||t._ctx,r=r||t.getCurrentToken(),n=n||t.getCurrentToken(),e=e||t.getInputStream(),i.call(this,{message:"",recognizer:t,input:e,ctx:s}),this.deadEndConfigs=o,this.startToken=n,this.offendingToken=r}function a(t){i.call(this,{message:"",recognizer:t,input:t.getInputStream(),ctx:t._ctx}),this.offendingToken=t.getCurrentToken()}function l(t,e,n){i.call(this,{message:this.formatMessage(e,n||null),recognizer:t,input:t.getInputStream(),ctx:t._ctx});var o=t._interp.atn.states[t.state].transitions[0];return o instanceof r?(this.ruleIndex=o.ruleIndex,this.predicateIndex=o.predIndex):(this.ruleIndex=0,this.predicateIndex=0),this.predicate=e,this.offendingToken=t.getCurrentToken(),this}function u(){return Error.call(this),Error.captureStackTrace(this,u),this}i.prototype=Object.create(Error.prototype),i.prototype.constructor=i,i.prototype.getExpectedTokens=function(){return null!==this.recognizer?this.recognizer.atn.getExpectedTokens(this.offendingState,this.ctx):null},i.prototype.toString=function(){return this.message},o.prototype=Object.create(i.prototype),o.prototype.constructor=o,o.prototype.toString=function(){var t="";return this.startIndex>=0&&this.startIndex<this.input.size&&(t=this.input.getText((this.startIndex,this.startIndex))),"LexerNoViableAltException"+t},s.prototype=Object.create(i.prototype),s.prototype.constructor=s,a.prototype=Object.create(i.prototype),a.prototype.constructor=a,l.prototype=Object.create(i.prototype),l.prototype.constructor=l,l.prototype.formatMessage=function(t,e){return null!==e?e:"failed predicate: {"+t+"}?"},u.prototype=Object.create(Error.prototype),u.prototype.constructor=u,e.RecognitionException=i,e.NoViableAltException=s,e.LexerNoViableAltException=o,e.InputMismatchException=a,e.FailedPredicateException=l,e.ParseCancellationException=u},function(t,e,n){var r=n(14).RuleContext,i=n(0).Hash;function o(t){this.cachedHashCode=t}function s(){return this.cache={},this}function a(t,e){var n=0;if(null!==t){var r=new i;r.update(t,e),n=r.finish()}o.call(this,n),this.parentCtx=t,this.returnState=e}function l(){return a.call(this,null,o.EMPTY_RETURN_STATE),this}function u(t,e){var n=new i;n.update(t,e);var r=n.finish();return o.call(this,r),this.parents=t,this.returnStates=e,this}function c(t,e,n,r){if(t===e)return t;if(t instanceof a&&e instanceof a)return function(t,e,n,r){if(null!==r){var i=r.get(t,e);if(null!==i)return i;if(null!==(i=r.get(e,t)))return i}var s=function(t,e,n){if(n){if(t===o.EMPTY)return o.EMPTY;if(e===o.EMPTY)return o.EMPTY}else{if(t===o.EMPTY&&e===o.EMPTY)return o.EMPTY;if(t===o.EMPTY){var r=[e.returnState,o.EMPTY_RETURN_STATE],i=[e.parentCtx,null];return new u(i,r)}if(e===o.EMPTY){var r=[t.returnState,o.EMPTY_RETURN_STATE],i=[t.parentCtx,null];return new u(i,r)}}return null}(t,e,n);if(null!==s)return null!==r&&r.set(t,e,s),s;if(t.returnState===e.returnState){var l=c(t.parentCtx,e.parentCtx,n,r);if(l===t.parentCtx)return t;if(l===e.parentCtx)return e;var h=a.create(l,t.returnState);return null!==r&&r.set(t,e,h),h}var p=null;if((t===e||null!==t.parentCtx&&t.parentCtx===e.parentCtx)&&(p=t.parentCtx),null!==p){var f=[t.returnState,e.returnState];t.returnState>e.returnState&&(f[0]=e.returnState,f[1]=t.returnState);var d=[p,p],y=new u(d,f);return null!==r&&r.set(t,e,y),y}var f=[t.returnState,e.returnState],d=[t.parentCtx,e.parentCtx];t.returnState>e.returnState&&(f[0]=e.returnState,f[1]=t.returnState,d=[e.parentCtx,t.parentCtx]);var g=new u(d,f);return null!==r&&r.set(t,e,g),g}(t,e,n,r);if(n){if(t instanceof l)return t;if(e instanceof l)return e}return t instanceof a&&(t=new u([t.getParent()],[t.returnState])),e instanceof a&&(e=new u([e.getParent()],[e.returnState])),function(t,e,n,r){if(null!==r){var i=r.get(t,e);if(null!==i)return i;if(null!==(i=r.get(e,t)))return i}var s=0,l=0,h=0,p=[],f=[];for(;s<t.returnStates.length&&l<e.returnStates.length;){var d=t.parents[s],y=e.parents[l];if(t.returnStates[s]===e.returnStates[l]){var g=t.returnStates[s],v=g===o.EMPTY_RETURN_STATE&&null===d&&null===y,x=null!==d&&null!==y&&d===y;if(v||x)f[h]=d,p[h]=g;else{var m=c(d,y,n,r);f[h]=m,p[h]=g}s+=1,l+=1}else t.returnStates[s]<e.returnStates[l]?(f[h]=d,p[h]=t.returnStates[s],s+=1):(f[h]=y,p[h]=e.returnStates[l],l+=1);h+=1}if(s<t.returnStates.length)for(var _=s;_<t.returnStates.length;_++)f[h]=t.parents[_],p[h]=t.returnStates[_],h+=1;else for(var _=l;_<e.returnStates.length;_++)f[h]=e.parents[_],p[h]=e.returnStates[_],h+=1;if(h<f.length){if(1===h){var T=a.create(f[0],p[0]);return null!==r&&r.set(t,e,T),T}f=f.slice(0,h),p=p.slice(0,h)}var S=new u(f,p);if(S===t)return null!==r&&r.set(t,e,t),t;if(S===e)return null!==r&&r.set(t,e,e),e;(function(t){for(var e={},n=0;n<t.length;n++){var r=t[n];r in e||(e[r]=r)}for(var i=0;i<t.length;i++)t[i]=e[t[i]]})(f),null!==r&&r.set(t,e,S);return S}(t,e,n,r)}o.EMPTY=null,o.EMPTY_RETURN_STATE=2147483647,o.globalNodeCount=1,o.id=o.globalNodeCount,o.prototype.isEmpty=function(){return this===o.EMPTY},o.prototype.hasEmptyPath=function(){return this.getReturnState(this.length-1)===o.EMPTY_RETURN_STATE},o.prototype.hashCode=function(){return this.cachedHashCode},o.prototype.updateHashCode=function(t){t.update(this.cachedHashCode)},s.prototype.add=function(t){if(t===o.EMPTY)return o.EMPTY;var e=this.cache[t]||null;return null!==e?e:(this.cache[t]=t,t)},s.prototype.get=function(t){return this.cache[t]||null},Object.defineProperty(s.prototype,"length",{get:function(){return this.cache.length}}),a.prototype=Object.create(o.prototype),a.prototype.contructor=a,a.create=function(t,e){return e===o.EMPTY_RETURN_STATE&&null===t?o.EMPTY:new a(t,e)},Object.defineProperty(a.prototype,"length",{get:function(){return 1}}),a.prototype.getParent=function(t){return this.parentCtx},a.prototype.getReturnState=function(t){return this.returnState},a.prototype.equals=function(t){return this===t||t instanceof a&&(this.hashCode()===t.hashCode()&&(this.returnState===t.returnState&&(null==this.parentCtx?null==t.parentCtx:this.parentCtx.equals(t.parentCtx))))},a.prototype.toString=function(){var t=null===this.parentCtx?"":this.parentCtx.toString();return 0===t.length?this.returnState===o.EMPTY_RETURN_STATE?"$":""+this.returnState:this.returnState+" "+t},l.prototype=Object.create(a.prototype),l.prototype.constructor=l,l.prototype.isEmpty=function(){return!0},l.prototype.getParent=function(t){return null},l.prototype.getReturnState=function(t){return this.returnState},l.prototype.equals=function(t){return this===t},l.prototype.toString=function(){return"$"},o.EMPTY=new l,u.prototype=Object.create(o.prototype),u.prototype.constructor=u,u.prototype.isEmpty=function(){return this.returnStates[0]===o.EMPTY_RETURN_STATE},Object.defineProperty(u.prototype,"length",{get:function(){return this.returnStates.length}}),u.prototype.getParent=function(t){return this.parents[t]},u.prototype.getReturnState=function(t){return this.returnStates[t]},u.prototype.equals=function(t){return this===t||t instanceof u&&(this.hashCode()===t.hashCode()&&(this.returnStates===t.returnStates&&this.parents===t.parents))},u.prototype.toString=function(){if(this.isEmpty())return"[]";for(var t="[",e=0;e<this.returnStates.length;e++)e>0&&(t+=", "),this.returnStates[e]!==o.EMPTY_RETURN_STATE?(t+=this.returnStates[e],null!==this.parents[e]?t=t+" "+this.parents[e]:t+="null"):t+="$";return t+"]"},e.merge=c,e.PredictionContext=o,e.PredictionContextCache=s,e.SingletonPredictionContext=a,e.predictionContextFromRuleContext=function t(e,n){if(void 0!==n&&null!==n||(n=r.EMPTY),null===n.parentCtx||n===r.EMPTY)return o.EMPTY;var i=t(e,n.parentCtx),s=e.states[n.invokingState].transitions[0];return a.create(i,s.followState.stateNumber)},e.getCachedPredictionContext=function t(e,n,r){if(e.isEmpty())return e;var i=r[e]||null;if(null!==i)return i;if(null!==(i=n.get(e)))return r[e]=i,i;for(var s=!1,l=[],c=0;c<l.length;c++){var h=t(e.getParent(c),n,r);if(s||h!==e.getParent(c)){if(!s){l=[];for(var p=0;p<e.length;p++)l[p]=e.getParent(p);s=!0}l[c]=h}}if(!s)return n.add(e),r[e]=e,e;var f=null;return f=0===l.length?o.EMPTY:1===l.length?a.create(l[0],e.getReturnState(0)):new u(l,e.returnStates),n.add(f),r[f]=f,r[e]=f,f}},function(t,e,n){var r=n(35).LL1Analyzer,i=n(2).IntervalSet;function o(t,e){return this.grammarType=t,this.maxTokenType=e,this.states=[],this.decisionToState=[],this.ruleToStartState=[],this.ruleToStopState=null,this.modeNameToStartState={},this.ruleToTokenType=null,this.lexerActions=null,this.modeToStartState=[],this}o.prototype.nextTokensInContext=function(t,e){return new r(this).LOOK(t,null,e)},o.prototype.nextTokensNoContext=function(t){return null!==t.nextTokenWithinRule?t.nextTokenWithinRule:(t.nextTokenWithinRule=this.nextTokensInContext(t,null),t.nextTokenWithinRule.readOnly=!0,t.nextTokenWithinRule)},o.prototype.nextTokens=function(t,e){return void 0===e?this.nextTokensNoContext(t):this.nextTokensInContext(t,e)},o.prototype.addState=function(t){null!==t&&(t.atn=this,t.stateNumber=this.states.length),this.states.push(t)},o.prototype.removeState=function(t){this.states[t.stateNumber]=null},o.prototype.defineDecisionState=function(t){return this.decisionToState.push(t),t.decision=this.decisionToState.length-1,t.decision},o.prototype.getDecisionState=function(t){return 0===this.decisionToState.length?null:this.decisionToState[t]};var s=n(1).Token;o.prototype.getExpectedTokens=function(t,e){if(t<0||t>=this.states.length)throw"Invalid state number.";var n=this.states[t],r=this.nextTokens(n);if(!r.contains(s.EPSILON))return r;var o=new i;for(o.addSet(r),o.removeOne(s.EPSILON);null!==e&&e.invokingState>=0&&r.contains(s.EPSILON);){var a=this.states[e.invokingState].transitions[0];r=this.nextTokens(a.followState),o.addSet(r),o.removeOne(s.EPSILON),e=e.parentCtx}return r.contains(s.EPSILON)&&o.addOne(s.EOF),o},o.INVALID_ALT_NUMBER=0,e.ATN=o},function(t,e,n){var r=n(1).Token,i=(n(2).Interval,n(2).IntervalSet),o=n(10).Predicate,s=n(10).PrecedencePredicate;function a(t){if(void 0===t||null===t)throw"target cannot be null.";return this.target=t,this.isEpsilon=!1,this.label=null,this}function l(t,e){return a.call(this,t),this.label_=e,this.label=this.makeLabel(),this.serializationType=a.ATOM,this}function u(t,e,n,r){return a.call(this,t),this.ruleIndex=e,this.precedence=n,this.followState=r,this.serializationType=a.RULE,this.isEpsilon=!0,this}function c(t,e){return a.call(this,t),this.serializationType=a.EPSILON,this.isEpsilon=!0,this.outermostPrecedenceReturn=e,this}function h(t,e,n){return a.call(this,t),this.serializationType=a.RANGE,this.start=e,this.stop=n,this.label=this.makeLabel(),this}function p(t){return a.call(this,t),this}function f(t,e,n,r){return p.call(this,t),this.serializationType=a.PREDICATE,this.ruleIndex=e,this.predIndex=n,this.isCtxDependent=r,this.isEpsilon=!0,this}function d(t,e,n,r){return a.call(this,t),this.serializationType=a.ACTION,this.ruleIndex=e,this.actionIndex=void 0===n?-1:n,this.isCtxDependent=void 0!==r&&r,this.isEpsilon=!0,this}function y(t,e){return a.call(this,t),this.serializationType=a.SET,void 0!==e&&null!==e?this.label=e:(this.label=new i,this.label.addOne(r.INVALID_TYPE)),this}function g(t,e){return y.call(this,t,e),this.serializationType=a.NOT_SET,this}function v(t){return a.call(this,t),this.serializationType=a.WILDCARD,this}function x(t,e){return p.call(this,t),this.serializationType=a.PRECEDENCE,this.precedence=e,this.isEpsilon=!0,this}a.EPSILON=1,a.RANGE=2,a.RULE=3,a.PREDICATE=4,a.ATOM=5,a.ACTION=6,a.SET=7,a.NOT_SET=8,a.WILDCARD=9,a.PRECEDENCE=10,a.serializationNames=["INVALID","EPSILON","RANGE","RULE","PREDICATE","ATOM","ACTION","SET","NOT_SET","WILDCARD","PRECEDENCE"],a.serializationTypes={EpsilonTransition:a.EPSILON,RangeTransition:a.RANGE,RuleTransition:a.RULE,PredicateTransition:a.PREDICATE,AtomTransition:a.ATOM,ActionTransition:a.ACTION,SetTransition:a.SET,NotSetTransition:a.NOT_SET,WildcardTransition:a.WILDCARD,PrecedencePredicateTransition:a.PRECEDENCE},l.prototype=Object.create(a.prototype),l.prototype.constructor=l,l.prototype.makeLabel=function(){var t=new i;return t.addOne(this.label_),t},l.prototype.matches=function(t,e,n){return this.label_===t},l.prototype.toString=function(){return this.label_},u.prototype=Object.create(a.prototype),u.prototype.constructor=u,u.prototype.matches=function(t,e,n){return!1},c.prototype=Object.create(a.prototype),c.prototype.constructor=c,c.prototype.matches=function(t,e,n){return!1},c.prototype.toString=function(){return"epsilon"},h.prototype=Object.create(a.prototype),h.prototype.constructor=h,h.prototype.makeLabel=function(){var t=new i;return t.addRange(this.start,this.stop),t},h.prototype.matches=function(t,e,n){return t>=this.start&&t<=this.stop},h.prototype.toString=function(){return"'"+String.fromCharCode(this.start)+"'..'"+String.fromCharCode(this.stop)+"'"},p.prototype=Object.create(a.prototype),p.prototype.constructor=p,f.prototype=Object.create(p.prototype),f.prototype.constructor=f,f.prototype.matches=function(t,e,n){return!1},f.prototype.getPredicate=function(){return new o(this.ruleIndex,this.predIndex,this.isCtxDependent)},f.prototype.toString=function(){return"pred_"+this.ruleIndex+":"+this.predIndex},d.prototype=Object.create(a.prototype),d.prototype.constructor=d,d.prototype.matches=function(t,e,n){return!1},d.prototype.toString=function(){return"action_"+this.ruleIndex+":"+this.actionIndex},y.prototype=Object.create(a.prototype),y.prototype.constructor=y,y.prototype.matches=function(t,e,n){return this.label.contains(t)},y.prototype.toString=function(){return this.label.toString()},g.prototype=Object.create(y.prototype),g.prototype.constructor=g,g.prototype.matches=function(t,e,n){return t>=e&&t<=n&&!y.prototype.matches.call(this,t,e,n)},g.prototype.toString=function(){return"~"+y.prototype.toString.call(this)},v.prototype=Object.create(a.prototype),v.prototype.constructor=v,v.prototype.matches=function(t,e,n){return t>=e&&t<=n},v.prototype.toString=function(){return"."},x.prototype=Object.create(p.prototype),x.prototype.constructor=x,x.prototype.matches=function(t,e,n){return!1},x.prototype.getPredicate=function(){return new s(this.precedence)},x.prototype.toString=function(){return this.precedence+" >= _p"},e.Transition=a,e.AtomTransition=l,e.SetTransition=y,e.NotSetTransition=g,e.RuleTransition=u,e.ActionTransition=d,e.EpsilonTransition=c,e.RangeTransition=h,e.WildcardTransition=v,e.PredicateTransition=f,e.PrecedencePredicateTransition=x,e.AbstractPredicateTransition=p},function(t,e,n){var r=n(7).ATN,i=n(0),o=i.Hash,s=i.Set,a=n(10).SemanticContext,l=n(6).merge;function u(t){return t.hashCodeForConfigSet()}function c(t,e){return t===e||null!==t&&null!==e&&t.equalsForConfigSet(e)}function h(t){return this.configLookup=new s(u,c),this.fullCtx=void 0===t||t,this.readOnly=!1,this.configs=[],this.uniqueAlt=0,this.conflictingAlts=null,this.hasSemanticContext=!1,this.dipsIntoOuterContext=!1,this.cachedHashCode=-1,this}function p(){return h.call(this),this.configLookup=new s,this}h.prototype.add=function(t,e){if(void 0===e&&(e=null),this.readOnly)throw"This set is readonly";t.semanticContext!==a.NONE&&(this.hasSemanticContext=!0),t.reachesIntoOuterContext>0&&(this.dipsIntoOuterContext=!0);var n=this.configLookup.add(t);if(n===t)return this.cachedHashCode=-1,this.configs.push(t),!0;var r=!this.fullCtx,i=l(n.context,t.context,r,e);return n.reachesIntoOuterContext=Math.max(n.reachesIntoOuterContext,t.reachesIntoOuterContext),t.precedenceFilterSuppressed&&(n.precedenceFilterSuppressed=!0),n.context=i,!0},h.prototype.getStates=function(){for(var t=new s,e=0;e<this.configs.length;e++)t.add(this.configs[e].state);return t},h.prototype.getPredicates=function(){for(var t=[],e=0;e<this.configs.length;e++){var n=this.configs[e].semanticContext;n!==a.NONE&&t.push(n.semanticContext)}return t},Object.defineProperty(h.prototype,"items",{get:function(){return this.configs}}),h.prototype.optimizeConfigs=function(t){if(this.readOnly)throw"This set is readonly";if(0!==this.configLookup.length)for(var e=0;e<this.configs.length;e++){var n=this.configs[e];n.context=t.getCachedContext(n.context)}},h.prototype.addAll=function(t){for(var e=0;e<t.length;e++)this.add(t[e]);return!1},h.prototype.equals=function(t){return this===t||t instanceof h&&i.equalArrays(this.configs,t.configs)&&this.fullCtx===t.fullCtx&&this.uniqueAlt===t.uniqueAlt&&this.conflictingAlts===t.conflictingAlts&&this.hasSemanticContext===t.hasSemanticContext&&this.dipsIntoOuterContext===t.dipsIntoOuterContext},h.prototype.hashCode=function(){var t=new o;return this.updateHashCode(t),t.finish()},h.prototype.updateHashCode=function(t){if(this.readOnly){if(-1===this.cachedHashCode)(t=new o).update(this.configs),this.cachedHashCode=t.finish();t.update(this.cachedHashCode)}else t.update(this.configs)},Object.defineProperty(h.prototype,"length",{get:function(){return this.configs.length}}),h.prototype.isEmpty=function(){return 0===this.configs.length},h.prototype.contains=function(t){if(null===this.configLookup)throw"This method is not implemented for readonly sets.";return this.configLookup.contains(t)},h.prototype.containsFast=function(t){if(null===this.configLookup)throw"This method is not implemented for readonly sets.";return this.configLookup.containsFast(t)},h.prototype.clear=function(){if(this.readOnly)throw"This set is readonly";this.configs=[],this.cachedHashCode=-1,this.configLookup=new s},h.prototype.setReadonly=function(t){this.readOnly=t,t&&(this.configLookup=null)},h.prototype.toString=function(){return i.arrayToString(this.configs)+(this.hasSemanticContext?",hasSemanticContext="+this.hasSemanticContext:"")+(this.uniqueAlt!==r.INVALID_ALT_NUMBER?",uniqueAlt="+this.uniqueAlt:"")+(null!==this.conflictingAlts?",conflictingAlts="+this.conflictingAlts:"")+(this.dipsIntoOuterContext?",dipsIntoOuterContext":"")},p.prototype=Object.create(h.prototype),p.prototype.constructor=p,e.ATNConfigSet=h,e.OrderedATNConfigSet=p},function(t,e,n){var r=n(0).Set,i=n(0).Hash;function o(){return this}function s(t,e,n){return o.call(this),this.ruleIndex=void 0===t?-1:t,this.predIndex=void 0===e?-1:e,this.isCtxDependent=void 0!==n&&n,this}function a(t){o.call(this),this.precedence=void 0===t?0:t}function l(t,e){o.call(this);var n=new r;t instanceof l?t.opnds.map(function(t){n.add(t)}):n.add(t),e instanceof l?e.opnds.map(function(t){n.add(t)}):n.add(e);var i=a.filterPrecedencePredicates(n);if(i.length>0){var s=null;i.map(function(t){(null===s||t.precedence<s.precedence)&&(s=t)}),n.add(s)}return this.opnds=n.values(),this}function u(t,e){o.call(this);var n=new r;t instanceof u?t.opnds.map(function(t){n.add(t)}):n.add(t),e instanceof u?e.opnds.map(function(t){n.add(t)}):n.add(e);var i=a.filterPrecedencePredicates(n);if(i.length>0){var s=i.sort(function(t,e){return t.compareTo(e)}),l=s[s.length-1];n.add(l)}return this.opnds=n.values(),this}o.prototype.hashCode=function(){var t=new i;return this.updateHashCode(t),t.finish()},o.prototype.evaluate=function(t,e){},o.prototype.evalPrecedence=function(t,e){return this},o.andContext=function(t,e){if(null===t||t===o.NONE)return e;if(null===e||e===o.NONE)return t;var n=new l(t,e);return 1===n.opnds.length?n.opnds[0]:n},o.orContext=function(t,e){if(null===t)return e;if(null===e)return t;if(t===o.NONE||e===o.NONE)return o.NONE;var n=new u(t,e);return 1===n.opnds.length?n.opnds[0]:n},s.prototype=Object.create(o.prototype),s.prototype.constructor=s,o.NONE=new s,s.prototype.evaluate=function(t,e){var n=this.isCtxDependent?e:null;return t.sempred(n,this.ruleIndex,this.predIndex)},s.prototype.updateHashCode=function(t){t.update(this.ruleIndex,this.predIndex,this.isCtxDependent)},s.prototype.equals=function(t){return this===t||t instanceof s&&(this.ruleIndex===t.ruleIndex&&this.predIndex===t.predIndex&&this.isCtxDependent===t.isCtxDependent)},s.prototype.toString=function(){return"{"+this.ruleIndex+":"+this.predIndex+"}?"},a.prototype=Object.create(o.prototype),a.prototype.constructor=a,a.prototype.evaluate=function(t,e){return t.precpred(e,this.precedence)},a.prototype.evalPrecedence=function(t,e){return t.precpred(e,this.precedence)?o.NONE:null},a.prototype.compareTo=function(t){return this.precedence-t.precedence},a.prototype.updateHashCode=function(t){t.update(31)},a.prototype.equals=function(t){return this===t||t instanceof a&&this.precedence===t.precedence},a.prototype.toString=function(){return"{"+this.precedence+">=prec}?"},a.filterPrecedencePredicates=function(t){var e=[];return t.values().map(function(t){t instanceof a&&e.push(t)}),e},l.prototype=Object.create(o.prototype),l.prototype.constructor=l,l.prototype.equals=function(t){return this===t||t instanceof l&&this.opnds===t.opnds},l.prototype.updateHashCode=function(t){t.update(this.opnds,"AND")},l.prototype.evaluate=function(t,e){for(var n=0;n<this.opnds.length;n++)if(!this.opnds[n].evaluate(t,e))return!1;return!0},l.prototype.evalPrecedence=function(t,e){for(var n=!1,r=[],i=0;i<this.opnds.length;i++){var s=this.opnds[i],a=s.evalPrecedence(t,e);if(n|=a!==s,null===a)return null;a!==o.NONE&&r.push(a)}if(!n)return this;if(0===r.length)return o.NONE;var l=null;return r.map(function(t){l=null===l?t:o.andContext(l,t)}),l},l.prototype.toString=function(){var t="";return this.opnds.map(function(e){t+="&& "+e.toString()}),t.length>3?t.slice(3):t},u.prototype=Object.create(o.prototype),u.prototype.constructor=u,u.prototype.constructor=function(t){return this===t||t instanceof u&&this.opnds===t.opnds},u.prototype.updateHashCode=function(t){t.update(this.opnds,"OR")},u.prototype.evaluate=function(t,e){for(var n=0;n<this.opnds.length;n++)if(this.opnds[n].evaluate(t,e))return!0;return!1},u.prototype.evalPrecedence=function(t,e){for(var n=!1,r=[],i=0;i<this.opnds.length;i++){var s=this.opnds[i],a=s.evalPrecedence(t,e);if(n|=a!==s,a===o.NONE)return o.NONE;null!==a&&r.push(a)}if(!n)return this;if(0===r.length)return null;return r.map(function(t){return t}),null},u.prototype.toString=function(){var t="";return this.opnds.map(function(e){t+="|| "+e.toString()}),t.length>3?t.slice(3):t},e.SemanticContext=o,e.PrecedencePredicate=a,e.Predicate=s},function(t,e,n){var r=n(9).ATNConfigSet,i=n(0),o=i.Hash,s=i.Set;function a(t,e){return this.alt=e,this.pred=t,this}function l(t,e){return null===t&&(t=-1),null===e&&(e=new r),this.stateNumber=t,this.configs=e,this.edges=null,this.isAcceptState=!1,this.prediction=0,this.lexerActionExecutor=null,this.requiresFullContext=!1,this.predicates=null,this}a.prototype.toString=function(){return"("+this.pred+", "+this.alt+")"},l.prototype.getAltSet=function(){var t=new s;if(null!==this.configs)for(var e=0;e<this.configs.length;e++){var n=this.configs[e];t.add(n.alt)}return 0===t.length?null:t},l.prototype.equals=function(t){return this===t||t instanceof l&&this.configs.equals(t.configs)},l.prototype.toString=function(){var t=this.stateNumber+":"+this.configs;return this.isAcceptState&&(t+="=>",null!==this.predicates?t+=this.predicates:t+=this.prediction),t},l.prototype.hashCode=function(){var t=new o;return t.update(this.configs),this.isAcceptState&&(null!==this.predicates?t.update(this.predicates):t.update(this.prediction)),t.finish()},e.DFAState=l,e.PredPrediction=a},function(t,e,n){e.atn=n(34),e.codepointat=n(28),e.dfa=n(41),e.fromcodepoint=n(29),e.tree=n(43),e.error=n(44),e.Token=n(1).Token,e.CharStreams=n(46).CharStreams,e.CommonToken=n(1).CommonToken,e.InputStream=n(19).InputStream,e.FileStream=n(47).FileStream,e.CommonTokenStream=n(48).CommonTokenStream,e.Lexer=n(15).Lexer,e.Parser=n(50).Parser;var r=n(6);e.PredictionContextCache=r.PredictionContextCache,e.ParserRuleContext=n(18).ParserRuleContext,e.Interval=n(2).Interval,e.Utils=n(0)},function(t,e,n){var r=n(3).DecisionState,i=n(10).SemanticContext,o=n(0).Hash;function s(t,e){if(null===t){var n={state:null,alt:null,context:null,semanticContext:null};return e&&(n.reachesIntoOuterContext=0),n}var r={};return r.state=t.state||null,r.alt=void 0===t.alt?null:t.alt,r.context=t.context||null,r.semanticContext=t.semanticContext||null,e&&(r.reachesIntoOuterContext=t.reachesIntoOuterContext||0,r.precedenceFilterSuppressed=t.precedenceFilterSuppressed||!1),r}function a(t,e){return this.checkContext(t,e),t=s(t),e=s(e,!0),this.state=null!==t.state?t.state:e.state,this.alt=null!==t.alt?t.alt:e.alt,this.context=null!==t.context?t.context:e.context,this.semanticContext=null!==t.semanticContext?t.semanticContext:null!==e.semanticContext?e.semanticContext:i.NONE,this.reachesIntoOuterContext=e.reachesIntoOuterContext,this.precedenceFilterSuppressed=e.precedenceFilterSuppressed,this}function l(t,e){a.call(this,t,e);var n=t.lexerActionExecutor||null;return this.lexerActionExecutor=n||(null!==e?e.lexerActionExecutor:null),this.passedThroughNonGreedyDecision=null!==e&&this.checkNonGreedyDecision(e,this.state),this}a.prototype.checkContext=function(t,e){null!==t.context&&void 0!==t.context||null!==e&&null!==e.context&&void 0!==e.context||(this.context=null)},a.prototype.hashCode=function(){var t=new o;return this.updateHashCode(t),t.finish()},a.prototype.updateHashCode=function(t){t.update(this.state.stateNumber,this.alt,this.context,this.semanticContext)},a.prototype.equals=function(t){return this===t||t instanceof a&&(this.state.stateNumber===t.state.stateNumber&&this.alt===t.alt&&(null===this.context?null===t.context:this.context.equals(t.context))&&this.semanticContext.equals(t.semanticContext)&&this.precedenceFilterSuppressed===t.precedenceFilterSuppressed)},a.prototype.hashCodeForConfigSet=function(){var t=new o;return t.update(this.state.stateNumber,this.alt,this.semanticContext),t.finish()},a.prototype.equalsForConfigSet=function(t){return this===t||t instanceof a&&(this.state.stateNumber===t.state.stateNumber&&this.alt===t.alt&&this.semanticContext.equals(t.semanticContext))},a.prototype.toString=function(){return"("+this.state+","+this.alt+(null!==this.context?",["+this.context.toString()+"]":"")+(this.semanticContext!==i.NONE?","+this.semanticContext.toString():"")+(this.reachesIntoOuterContext>0?",up="+this.reachesIntoOuterContext:"")+")"},l.prototype=Object.create(a.prototype),l.prototype.constructor=l,l.prototype.updateHashCode=function(t){t.update(this.state.stateNumber,this.alt,this.context,this.semanticContext,this.passedThroughNonGreedyDecision,this.lexerActionExecutor)},l.prototype.equals=function(t){return this===t||t instanceof l&&this.passedThroughNonGreedyDecision==t.passedThroughNonGreedyDecision&&(this.lexerActionExecutor?this.lexerActionExecutor.equals(t.lexerActionExecutor):!t.lexerActionExecutor)&&a.prototype.equals.call(this,t)},l.prototype.hashCodeForConfigSet=l.prototype.hashCode,l.prototype.equalsForConfigSet=l.prototype.equals,l.prototype.checkNonGreedyDecision=function(t,e){return t.passedThroughNonGreedyDecision||e instanceof r&&e.nonGreedy},e.ATNConfig=a,e.LexerATNConfig=l},function(t,e,n){var r=n(4).RuleNode,i=n(4).INVALID_INTERVAL,o=n(7).INVALID_ALT_NUMBER;function s(t,e){return r.call(this),this.parentCtx=t||null,this.invokingState=e||-1,this}s.prototype=Object.create(r.prototype),s.prototype.constructor=s,s.prototype.depth=function(){for(var t=0,e=this;null!==e;)e=e.parentCtx,t+=1;return t},s.prototype.isEmpty=function(){return-1===this.invokingState},s.prototype.getSourceInterval=function(){return i},s.prototype.getRuleContext=function(){return this},s.prototype.getPayload=function(){return this},s.prototype.getText=function(){return 0===this.getChildCount()?"":this.children.map(function(t){return t.getText()}).join("")},s.prototype.getAltNumber=function(){return o},s.prototype.setAltNumber=function(t){},s.prototype.getChild=function(t){return null},s.prototype.getChildCount=function(){return 0},s.prototype.accept=function(t){return t.visitChildren(this)},e.RuleContext=s;var a=n(21).Trees;s.prototype.toStringTree=function(t,e){return a.toStringTree(this,t,e)},s.prototype.toString=function(t,e){t=t||null,e=e||null;for(var n=this,r="[";null!==n&&n!==e;){if(null===t)n.isEmpty()||(r+=n.invokingState);else{var i=n.ruleIndex;r+=i>=0&&i<t.length?t[i]:""+i}null===n.parentCtx||null===t&&n.parentCtx.isEmpty()||(r+=" "),n=n.parentCtx}return r+="]"}},function(t,e,n){var r=n(1).Token,i=n(25).Recognizer,o=n(38).CommonTokenFactory,s=n(5).RecognitionException,a=n(5).LexerNoViableAltException;function l(t){return i.call(this),this._input=t,this._factory=o.DEFAULT,this._tokenFactorySourcePair=[this,t],this._interp=null,this._token=null,this._tokenStartCharIndex=-1,this._tokenStartLine=-1,this._tokenStartColumn=-1,this._hitEOF=!1,this._channel=r.DEFAULT_CHANNEL,this._type=r.INVALID_TYPE,this._modeStack=[],this._mode=l.DEFAULT_MODE,this._text=null,this}l.prototype=Object.create(i.prototype),l.prototype.constructor=l,l.DEFAULT_MODE=0,l.MORE=-2,l.SKIP=-3,l.DEFAULT_TOKEN_CHANNEL=r.DEFAULT_CHANNEL,l.HIDDEN=r.HIDDEN_CHANNEL,l.MIN_CHAR_VALUE=0,l.MAX_CHAR_VALUE=1114111,l.prototype.reset=function(){null!==this._input&&this._input.seek(0),this._token=null,this._type=r.INVALID_TYPE,this._channel=r.DEFAULT_CHANNEL,this._tokenStartCharIndex=-1,this._tokenStartColumn=-1,this._tokenStartLine=-1,this._text=null,this._hitEOF=!1,this._mode=l.DEFAULT_MODE,this._modeStack=[],this._interp.reset()},l.prototype.nextToken=function(){if(null===this._input)throw"nextToken requires a non-null input stream.";var t=this._input.mark();try{for(;;){if(this._hitEOF)return this.emitEOF(),this._token;this._token=null,this._channel=r.DEFAULT_CHANNEL,this._tokenStartCharIndex=this._input.index,this._tokenStartColumn=this._interp.column,this._tokenStartLine=this._interp.line,this._text=null;for(var e=!1;;){this._type=r.INVALID_TYPE;var n=l.SKIP;try{n=this._interp.match(this._input,this._mode)}catch(t){if(!(t instanceof s))throw console.log(t.stack),t;this.notifyListeners(t),this.recover(t)}if(this._input.LA(1)===r.EOF&&(this._hitEOF=!0),this._type===r.INVALID_TYPE&&(this._type=n),this._type===l.SKIP){e=!0;break}if(this._type!==l.MORE)break}if(!e)return null===this._token&&this.emit(),this._token}}finally{this._input.release(t)}},l.prototype.skip=function(){this._type=l.SKIP},l.prototype.more=function(){this._type=l.MORE},l.prototype.mode=function(t){this._mode=t},l.prototype.pushMode=function(t){this._interp.debug&&console.log("pushMode "+t),this._modeStack.push(this._mode),this.mode(t)},l.prototype.popMode=function(){if(0===this._modeStack.length)throw"Empty Stack";return this._interp.debug&&console.log("popMode back to "+this._modeStack.slice(0,-1)),this.mode(this._modeStack.pop()),this._mode},Object.defineProperty(l.prototype,"inputStream",{get:function(){return this._input},set:function(t){this._input=null,this._tokenFactorySourcePair=[this,this._input],this.reset(),this._input=t,this._tokenFactorySourcePair=[this,this._input]}}),Object.defineProperty(l.prototype,"sourceName",{get:function(){return this._input.sourceName}}),l.prototype.emitToken=function(t){this._token=t},l.prototype.emit=function(){var t=this._factory.create(this._tokenFactorySourcePair,this._type,this._text,this._channel,this._tokenStartCharIndex,this.getCharIndex()-1,this._tokenStartLine,this._tokenStartColumn);return this.emitToken(t),t},l.prototype.emitEOF=function(){var t=this.column,e=this.line,n=this._factory.create(this._tokenFactorySourcePair,r.EOF,null,r.DEFAULT_CHANNEL,this._input.index,this._input.index-1,e,t);return this.emitToken(n),n},Object.defineProperty(l.prototype,"type",{get:function(){return this.type},set:function(t){this._type=t}}),Object.defineProperty(l.prototype,"line",{get:function(){return this._interp.line},set:function(t){this._interp.line=t}}),Object.defineProperty(l.prototype,"column",{get:function(){return this._interp.column},set:function(t){this._interp.column=t}}),l.prototype.getCharIndex=function(){return this._input.index},Object.defineProperty(l.prototype,"text",{get:function(){return null!==this._text?this._text:this._interp.getText(this._input)},set:function(t){this._text=t}}),l.prototype.getAllTokens=function(){for(var t=[],e=this.nextToken();e.type!==r.EOF;)t.push(e),e=this.nextToken();return t},l.prototype.notifyListeners=function(t){var e=this._tokenStartCharIndex,n=this._input.index,r=this._input.getText(e,n),i="token recognition error at: '"+this.getErrorDisplay(r)+"'";this.getErrorListenerDispatch().syntaxError(this,null,this._tokenStartLine,this._tokenStartColumn,i,t)},l.prototype.getErrorDisplay=function(t){for(var e=[],n=0;n<t.length;n++)e.push(t[n]);return e.join("")},l.prototype.getErrorDisplayForChar=function(t){return t.charCodeAt(0)===r.EOF?"<EOF>":"\n"===t?"\\n":"\t"===t?"\\t":"\r"===t?"\\r":t},l.prototype.getCharErrorDisplay=function(t){return"'"+this.getErrorDisplayForChar(t)+"'"},l.prototype.recover=function(t){this._input.LA(1)!==r.EOF&&(t instanceof a?this._interp.consume(this._input):this._input.consume())},e.Lexer=l},function(t,e){function n(){return this}function r(){return n.call(this),this}function i(t){if(n.call(this),null===t)throw"delegates";return this.delegates=t,this}n.prototype.syntaxError=function(t,e,n,r,i,o){},n.prototype.reportAmbiguity=function(t,e,n,r,i,o,s){},n.prototype.reportAttemptingFullContext=function(t,e,n,r,i,o){},n.prototype.reportContextSensitivity=function(t,e,n,r,i,o){},r.prototype=Object.create(n.prototype),r.prototype.constructor=r,r.INSTANCE=new r,r.prototype.syntaxError=function(t,e,n,r,i,o){console.error("line "+n+":"+r+" "+i)},i.prototype=Object.create(n.prototype),i.prototype.constructor=i,i.prototype.syntaxError=function(t,e,n,r,i,o){this.delegates.map(function(s){s.syntaxError(t,e,n,r,i,o)})},i.prototype.reportAmbiguity=function(t,e,n,r,i,o,s){this.delegates.map(function(a){a.reportAmbiguity(t,e,n,r,i,o,s)})},i.prototype.reportAttemptingFullContext=function(t,e,n,r,i,o){this.delegates.map(function(s){s.reportAttemptingFullContext(t,e,n,r,i,o)})},i.prototype.reportContextSensitivity=function(t,e,n,r,i,o){this.delegates.map(function(s){s.reportContextSensitivity(t,e,n,r,i,o)})},e.ErrorListener=n,e.ConsoleErrorListener=r,e.ProxyErrorListener=i},function(t,e){function n(t,e,n){return this.dfa=t,this.literalNames=e||[],this.symbolicNames=n||[],this}function r(t){return n.call(this,t,null),this}n.prototype.toString=function(){if(null===this.dfa.s0)return null;for(var t="",e=this.dfa.sortedStates(),n=0;n<e.length;n++){var r=e[n];if(null!==r.edges)for(var i=r.edges.length,o=0;o<i;o++){var s=r.edges[o]||null;null!==s&&2147483647!==s.stateNumber&&(t=(t=(t=(t=(t=(t=t.concat(this.getStateString(r))).concat("-")).concat(this.getEdgeLabel(o))).concat("->")).concat(this.getStateString(s))).concat("\n"))}}return 0===t.length?null:t},n.prototype.getEdgeLabel=function(t){return 0===t?"EOF":null!==this.literalNames||null!==this.symbolicNames?this.literalNames[t-1]||this.symbolicNames[t-1]:String.fromCharCode(t-1)},n.prototype.getStateString=function(t){var e=(t.isAcceptState?":":"")+"s"+t.stateNumber+(t.requiresFullContext?"^":"");return t.isAcceptState?null!==t.predicates?e+"=>"+t.predicates.toString():e+"=>"+t.prediction.toString():e},r.prototype=Object.create(n.prototype),r.prototype.constructor=r,r.prototype.getEdgeLabel=function(t){return"'"+String.fromCharCode(t)+"'"},e.DFASerializer=n,e.LexerDFASerializer=r},function(t,e,n){var r=n(14).RuleContext,i=n(4),o=i.INVALID_INTERVAL,s=i.TerminalNode,a=i.TerminalNodeImpl,l=i.ErrorNodeImpl,u=n(2).Interval;function c(t,e){t=t||null,e=e||null,r.call(this,t,e),this.ruleIndex=-1,this.children=null,this.start=null,this.stop=null,this.exception=null}function h(t,e,n){return c.call(t,e),this.ruleIndex=n,this}c.prototype=Object.create(r.prototype),c.prototype.constructor=c,c.prototype.copyFrom=function(t){this.parentCtx=t.parentCtx,this.invokingState=t.invokingState,this.children=null,this.start=t.start,this.stop=t.stop,t.children&&(this.children=[],t.children.map(function(t){t instanceof l&&(this.children.push(t),t.parentCtx=this)},this))},c.prototype.enterRule=function(t){},c.prototype.exitRule=function(t){},c.prototype.addChild=function(t){return null===this.children&&(this.children=[]),this.children.push(t),t},c.prototype.removeLastChild=function(){null!==this.children&&this.children.pop()},c.prototype.addTokenNode=function(t){var e=new a(t);return this.addChild(e),e.parentCtx=this,e},c.prototype.addErrorNode=function(t){var e=new l(t);return this.addChild(e),e.parentCtx=this,e},c.prototype.getChild=function(t,e){if(e=e||null,null===this.children||t<0||t>=this.children.length)return null;if(null===e)return this.children[t];for(var n=0;n<this.children.length;n++){var r=this.children[n];if(r instanceof e){if(0===t)return r;t-=1}}return null},c.prototype.getToken=function(t,e){if(null===this.children||e<0||e>=this.children.length)return null;for(var n=0;n<this.children.length;n++){var r=this.children[n];if(r instanceof s&&r.symbol.type===t){if(0===e)return r;e-=1}}return null},c.prototype.getTokens=function(t){if(null===this.children)return[];for(var e=[],n=0;n<this.children.length;n++){var r=this.children[n];r instanceof s&&r.symbol.type===t&&e.push(r)}return e},c.prototype.getTypedRuleContext=function(t,e){return this.getChild(e,t)},c.prototype.getTypedRuleContexts=function(t){if(null===this.children)return[];for(var e=[],n=0;n<this.children.length;n++){var r=this.children[n];r instanceof t&&e.push(r)}return e},c.prototype.getChildCount=function(){return null===this.children?0:this.children.length},c.prototype.getSourceInterval=function(){return null===this.start||null===this.stop?o:new u(this.start.tokenIndex,this.stop.tokenIndex)},r.EMPTY=new c,h.prototype=Object.create(c.prototype),h.prototype.constructor=h,e.ParserRuleContext=c},function(t,e,n){var r=n(1).Token;function i(t,e){return this.name="<empty>",this.strdata=t,this.decodeToUnicodeCodePoints=e||!1,function(t,e){if(t._index=0,t.data=[],t.decodeToUnicodeCodePoints)for(var n=0;n<t.strdata.length;){var r=t.strdata.codePointAt(n);t.data.push(r),n+=r<=65535?1:2}else for(n=0;n<t.strdata.length;n++){var i=t.strdata.charCodeAt(n);t.data.push(i)}t._size=t.data.length}(this),this}n(28),n(29),Object.defineProperty(i.prototype,"index",{get:function(){return this._index}}),Object.defineProperty(i.prototype,"size",{get:function(){return this._size}}),i.prototype.reset=function(){this._index=0},i.prototype.consume=function(){if(this._index>=this._size)throw"cannot consume EOF";this._index+=1},i.prototype.LA=function(t){if(0===t)return 0;t<0&&(t+=1);var e=this._index+t-1;return e<0||e>=this._size?r.EOF:this.data[e]},i.prototype.LT=function(t){return this.LA(t)},i.prototype.mark=function(){return-1},i.prototype.release=function(t){},i.prototype.seek=function(t){t<=this._index?this._index=t:this._index=Math.min(t,this._size)},i.prototype.getText=function(t,e){if(e>=this._size&&(e=this._size-1),t>=this._size)return"";if(this.decodeToUnicodeCodePoints){for(var n="",r=t;r<=e;r++)n+=String.fromCodePoint(this.data[r]);return n}return this.strdata.slice(t,e+1)},i.prototype.toString=function(){return this.strdata},e.InputStream=i},function(t,e,n){var r=n(12);function i(){return r.tree.ParseTreeVisitor.call(this),this}i.prototype=Object.create(r.tree.ParseTreeVisitor.prototype),i.prototype.constructor=i,i.prototype.visitGrammarFile=function(t){return this.visitChildren(t)},i.prototype.visitGrammerDecl=function(t){return this.visitChildren(t)},i.prototype.visitStatExprSplit=function(t){return this.visitChildren(t)},i.prototype.visitStatList=function(t){return this.visitChildren(t)},i.prototype.visitStatValue=function(t){return this.visitChildren(t)},i.prototype.visitExprExpression=function(t){return this.visitChildren(t)},i.prototype.visitExprValue=function(t){return this.visitChildren(t)},i.prototype.visitArithmeticRuleCollection=function(t){return this.visitChildren(t)},i.prototype.visitParserAtomExpr=function(t){return this.visitChildren(t)},i.prototype.visitParserAtomParserId=function(t){return this.visitChildren(t)},i.prototype.visitParserAtomLexerId=function(t){return this.visitChildren(t)},i.prototype.visitParserAtomStr=function(t){return this.visitChildren(t)},i.prototype.visitLexerRuleCollection=function(t){return this.visitChildren(t)},i.prototype.visitMeaningfulSplit=function(t){return this.visitChildren(t)},i.prototype.visitLexerRuleStrings=function(t){return this.visitChildren(t)},i.prototype.visitLexerRuleList=function(t){return this.visitChildren(t)},i.prototype.visitLexerRuleComplex=function(t){return this.visitChildren(t)},i.prototype.visitStrings=function(t){return this.visitChildren(t)},i.prototype.visitLexerRuleExpr=function(t){return this.visitChildren(t)},e.BlocklyGrammerVisitor=i},function(t,e,n){var r=n(0),i=n(1).Token,o=(n(4).RuleNode,n(4).ErrorNode),s=n(4).TerminalNode,a=n(18).ParserRuleContext,l=n(14).RuleContext,u=n(7).INVALID_ALT_NUMBER;function c(){}c.toStringTree=function(t,e,n){e=e||null,null!==(n=n||null)&&(e=n.ruleNames);var i=c.getNodeText(t,e);i=r.escapeWhitespace(i,!1);var o=t.getChildCount();if(0===o)return i;var s="("+i+" ";o>0&&(i=c.toStringTree(t.getChild(0),e),s=s.concat(i));for(var a=1;a<o;a++)i=c.toStringTree(t.getChild(a),e),s=s.concat(" "+i);return s=s.concat(")")},c.getNodeText=function(t,e,n){if(e=e||null,null!==(n=n||null)&&(e=n.ruleNames),null!==e){if(t instanceof l){var r=t.getAltNumber();return r!=u?e[t.ruleIndex]+":"+r:e[t.ruleIndex]}if(t instanceof o)return t.toString();if(t instanceof s&&null!==t.symbol)return t.symbol.text}var a=t.getPayload();return a instanceof i?a.text:t.getPayload().toString()},c.getChildren=function(t){for(var e=[],n=0;n<t.getChildCount();n++)e.push(t.getChild(n));return e},c.getAncestors=function(t){var e=[];for(t=t.getParent();null!==t;)e=[t].concat(e),t=t.getParent();return e},c.findAllTokenNodes=function(t,e){return c.findAllNodes(t,e,!0)},c.findAllRuleNodes=function(t,e){return c.findAllNodes(t,e,!1)},c.findAllNodes=function(t,e,n){var r=[];return c._findAllNodes(t,e,n,r),r},c._findAllNodes=function(t,e,n,r){n&&t instanceof s?t.symbol.type===e&&r.push(t):!n&&t instanceof a&&t.ruleIndex===e&&r.push(t);for(var i=0;i<t.getChildCount();i++)c._findAllNodes(t.getChild(i),e,n,r)},c.descendants=function(t){for(var e=[t],n=0;n<t.getChildCount();n++)e=e.concat(c.descendants(t.getChild(n)));return e},e.Trees=c},function(t,e,n){var r=n(1).Token,i=n(7).ATN,o=n(36).ATNType,s=n(3),a=s.ATNState,l=s.BasicState,u=s.DecisionState,c=s.BlockStartState,h=s.BlockEndState,p=s.LoopEndState,f=s.RuleStartState,d=s.RuleStopState,y=s.TokensStartState,g=s.PlusLoopbackState,v=s.StarLoopbackState,x=s.StarLoopEntryState,m=s.PlusBlockStartState,_=s.StarBlockStartState,T=s.BasicBlockStartState,S=n(8),E=S.Transition,C=S.AtomTransition,A=S.SetTransition,b=S.NotSetTransition,k=S.RuleTransition,R=S.RangeTransition,L=S.ActionTransition,I=S.EpsilonTransition,N=S.WildcardTransition,O=S.PredicateTransition,P=S.PrecedencePredicateTransition,w=n(2).IntervalSet,F=(n(2).Interval,n(23).ATNDeserializationOptions),D=n(24),j=D.LexerActionType,M=D.LexerSkipAction,B=D.LexerChannelAction,U=D.LexerCustomAction,V=D.LexerMoreAction,H=D.LexerTypeAction,z=D.LexerPushModeAction,q=D.LexerPopModeAction,G=D.LexerModeAction,Y="59627784-3BE5-417A-B9EB-8131A7286089",K=["AADB8D7E-AEEF-4415-AD2B-8204D6CF042E",Y];function $(t,e){var n=[];return n[t-1]=e,n.map(function(t){return e})}function W(t){return void 0!==t&&null!==t||(t=F.defaultOptions),this.deserializationOptions=t,this.stateFactories=null,this.actionFactories=null,this}W.prototype.isFeatureSupported=function(t,e){var n=K.indexOf(t);return!(n<0)&&K.indexOf(e)>=n},W.prototype.deserialize=function(t){this.reset(t),this.checkVersion(),this.checkUUID();var e=this.readATN();this.readStates(e),this.readRules(e),this.readModes(e);var n=[];return this.readSets(e,n,this.readInt.bind(this)),this.isFeatureSupported(Y,this.uuid)&&this.readSets(e,n,this.readInt32.bind(this)),this.readEdges(e,n),this.readDecisions(e),this.readLexerActions(e),this.markPrecedenceDecisions(e),this.verifyATN(e),this.deserializationOptions.generateRuleBypassTransitions&&e.grammarType===o.PARSER&&(this.generateRuleBypassTransitions(e),this.verifyATN(e)),e},W.prototype.reset=function(t){var e=t.split("").map(function(t){var e=t.charCodeAt(0);return e>1?e-2:-1});e[0]=t.charCodeAt(0),this.data=e,this.pos=0},W.prototype.checkVersion=function(){var t=this.readInt();if(3!==t)throw"Could not deserialize ATN with version "+t+" (expected 3)."},W.prototype.checkUUID=function(){var t=this.readUUID();if(K.indexOf(t)<0)throw"59627784-3BE5-417A-B9EB-8131A7286089";this.uuid=t},W.prototype.readATN=function(){var t=this.readInt(),e=this.readInt();return new i(t,e)},W.prototype.readStates=function(t){for(var e,n,r,i=[],o=[],s=this.readInt(),l=0;l<s;l++){var u=this.readInt();if(u!==a.INVALID_TYPE){var h=this.readInt();65535===h&&(h=-1);var p=this.stateFactory(u,h);if(u===a.LOOP_END){var f=this.readInt();i.push([p,f])}else if(p instanceof c){var d=this.readInt();o.push([p,d])}t.addState(p)}else t.addState(null)}for(e=0;e<i.length;e++)(n=i[e])[0].loopBackState=t.states[n[1]];for(e=0;e<o.length;e++)(n=o[e])[0].endState=t.states[n[1]];var y=this.readInt();for(e=0;e<y;e++)r=this.readInt(),t.states[r].nonGreedy=!0;var g=this.readInt();for(e=0;e<g;e++)r=this.readInt(),t.states[r].isPrecedenceRule=!0},W.prototype.readRules=function(t){var e,n=this.readInt();for(t.grammarType===o.LEXER&&(t.ruleToTokenType=$(n,0)),t.ruleToStartState=$(n,0),e=0;e<n;e++){var i=this.readInt(),s=t.states[i];if(t.ruleToStartState[e]=s,t.grammarType===o.LEXER){var a=this.readInt();65535===a&&(a=r.EOF),t.ruleToTokenType[e]=a}}for(t.ruleToStopState=$(n,0),e=0;e<t.states.length;e++){var l=t.states[e];l instanceof d&&(t.ruleToStopState[l.ruleIndex]=l,t.ruleToStartState[l.ruleIndex].stopState=l)}},W.prototype.readModes=function(t){for(var e=this.readInt(),n=0;n<e;n++){var r=this.readInt();t.modeToStartState.push(t.states[r])}},W.prototype.readSets=function(t,e,n){for(var r=this.readInt(),i=0;i<r;i++){var o=new w;e.push(o);var s=this.readInt();0!==this.readInt()&&o.addOne(-1);for(var a=0;a<s;a++){var l=n(),u=n();o.addRange(l,u)}}},W.prototype.readEdges=function(t,e){var n,r,i,o,s,a=this.readInt();for(n=0;n<a;n++){var l=this.readInt(),u=this.readInt(),h=this.readInt(),p=this.readInt(),f=this.readInt(),d=this.readInt();o=this.edgeFactory(t,h,l,u,p,f,d,e),t.states[l].addTransition(o)}for(n=0;n<t.states.length;n++)for(i=t.states[n],r=0;r<i.transitions.length;r++){var y=i.transitions[r];if(y instanceof k){var _=-1;t.ruleToStartState[y.target.ruleIndex].isPrecedenceRule&&0===y.precedence&&(_=y.target.ruleIndex),o=new I(y.followState,_),t.ruleToStopState[y.target.ruleIndex].addTransition(o)}}for(n=0;n<t.states.length;n++){if((i=t.states[n])instanceof c){if(null===i.endState)throw"IllegalState";if(null!==i.endState.startState)throw"IllegalState";i.endState.startState=i}if(i instanceof g)for(r=0;r<i.transitions.length;r++)(s=i.transitions[r].target)instanceof m&&(s.loopBackState=i);else if(i instanceof v)for(r=0;r<i.transitions.length;r++)(s=i.transitions[r].target)instanceof x&&(s.loopBackState=i)}},W.prototype.readDecisions=function(t){for(var e=this.readInt(),n=0;n<e;n++){var r=this.readInt(),i=t.states[r];t.decisionToState.push(i),i.decision=n}},W.prototype.readLexerActions=function(t){if(t.grammarType===o.LEXER){var e=this.readInt();t.lexerActions=$(e,null);for(var n=0;n<e;n++){var r=this.readInt(),i=this.readInt();65535===i&&(i=-1);var s=this.readInt();65535===s&&(s=-1);var a=this.lexerActionFactory(r,i,s);t.lexerActions[n]=a}}},W.prototype.generateRuleBypassTransitions=function(t){var e,n=t.ruleToStartState.length;for(e=0;e<n;e++)t.ruleToTokenType[e]=t.maxTokenType+e+1;for(e=0;e<n;e++)this.generateRuleBypassTransition(t,e)},W.prototype.generateRuleBypassTransition=function(t,e){var n,r,i=new T;i.ruleIndex=e,t.addState(i);var o=new h;o.ruleIndex=e,t.addState(o),i.endState=o,t.defineDecisionState(i),o.startState=i;var s=null,a=null;if(t.ruleToStartState[e].isPrecedenceRule){for(a=null,n=0;n<t.states.length;n++)if(r=t.states[n],this.stateIsEndStateFor(r,e)){a=r,s=r.loopBackState.transitions[0];break}if(null===s)throw"Couldn't identify final state of the precedence rule prefix section."}else a=t.ruleToStopState[e];for(n=0;n<t.states.length;n++){r=t.states[n];for(var u=0;u<r.transitions.length;u++){var c=r.transitions[u];c!==s&&(c.target===a&&(c.target=o))}}for(var p=t.ruleToStartState[e],f=p.transitions.length;f>0;)i.addTransition(p.transitions[f-1]),p.transitions=p.transitions.slice(-1);t.ruleToStartState[e].addTransition(new I(i)),o.addTransition(new I(a));var d=new l;t.addState(d),d.addTransition(new C(o,t.ruleToTokenType[e])),i.addTransition(new I(d))},W.prototype.stateIsEndStateFor=function(t,e){if(t.ruleIndex!==e)return null;if(!(t instanceof x))return null;var n=t.transitions[t.transitions.length-1].target;return n instanceof p&&n.epsilonOnlyTransitions&&n.transitions[0].target instanceof d?t:null},W.prototype.markPrecedenceDecisions=function(t){for(var e=0;e<t.states.length;e++){var n=t.states[e];if(n instanceof x&&t.ruleToStartState[n.ruleIndex].isPrecedenceRule){var r=n.transitions[n.transitions.length-1].target;r instanceof p&&r.epsilonOnlyTransitions&&r.transitions[0].target instanceof d&&(n.isPrecedenceDecision=!0)}}},W.prototype.verifyATN=function(t){if(this.deserializationOptions.verifyATN)for(var e=0;e<t.states.length;e++){var n=t.states[e];if(null!==n)if(this.checkCondition(n.epsilonOnlyTransitions||n.transitions.length<=1),n instanceof m)this.checkCondition(null!==n.loopBackState);else if(n instanceof x)if(this.checkCondition(null!==n.loopBackState),this.checkCondition(2===n.transitions.length),n.transitions[0].target instanceof _)this.checkCondition(n.transitions[1].target instanceof p),this.checkCondition(!n.nonGreedy);else{if(!(n.transitions[0].target instanceof p))throw"IllegalState";this.checkCondition(n.transitions[1].target instanceof _),this.checkCondition(n.nonGreedy)}else n instanceof v?(this.checkCondition(1===n.transitions.length),this.checkCondition(n.transitions[0].target instanceof x)):n instanceof p?this.checkCondition(null!==n.loopBackState):n instanceof f?this.checkCondition(null!==n.stopState):n instanceof c?this.checkCondition(null!==n.endState):n instanceof h?this.checkCondition(null!==n.startState):n instanceof u?this.checkCondition(n.transitions.length<=1||n.decision>=0):this.checkCondition(n.transitions.length<=1||n instanceof d)}},W.prototype.checkCondition=function(t,e){if(!t)throw void 0!==e&&null!==e||(e="IllegalState"),e},W.prototype.readInt=function(){return this.data[this.pos++]},W.prototype.readInt32=function(){return this.readInt()|this.readInt()<<16},W.prototype.readLong=function(){return 4294967295&this.readInt32()|this.readInt32()<<32};var X=function(){for(var t=[],e=0;e<256;e++)t[e]=(e+256).toString(16).substr(1).toUpperCase();return t}();W.prototype.readUUID=function(){for(var t=[],e=7;e>=0;e--){var n=this.readInt();t[2*e+1]=255&n,t[2*e]=n>>8&255}return X[t[0]]+X[t[1]]+X[t[2]]+X[t[3]]+"-"+X[t[4]]+X[t[5]]+"-"+X[t[6]]+X[t[7]]+"-"+X[t[8]]+X[t[9]]+"-"+X[t[10]]+X[t[11]]+X[t[12]]+X[t[13]]+X[t[14]]+X[t[15]]},W.prototype.edgeFactory=function(t,e,n,i,o,s,a,l){var u=t.states[i];switch(e){case E.EPSILON:return new I(u);case E.RANGE:return new R(u,0!==a?r.EOF:o,s);case E.RULE:return new k(t.states[o],s,a,u);case E.PREDICATE:return new O(u,o,s,0!==a);case E.PRECEDENCE:return new P(u,o);case E.ATOM:return new C(u,0!==a?r.EOF:o);case E.ACTION:return new L(u,o,s,0!==a);case E.SET:return new A(u,l[o]);case E.NOT_SET:return new b(u,l[o]);case E.WILDCARD:return new N(u);default:throw"The specified transition type: "+e+" is not valid."}},W.prototype.stateFactory=function(t,e){if(null===this.stateFactories){var n=[];n[a.INVALID_TYPE]=null,n[a.BASIC]=function(){return new l},n[a.RULE_START]=function(){return new f},n[a.BLOCK_START]=function(){return new T},n[a.PLUS_BLOCK_START]=function(){return new m},n[a.STAR_BLOCK_START]=function(){return new _},n[a.TOKEN_START]=function(){return new y},n[a.RULE_STOP]=function(){return new d},n[a.BLOCK_END]=function(){return new h},n[a.STAR_LOOP_BACK]=function(){return new v},n[a.STAR_LOOP_ENTRY]=function(){return new x},n[a.PLUS_LOOP_BACK]=function(){return new g},n[a.LOOP_END]=function(){return new p},this.stateFactories=n}if(t>this.stateFactories.length||null===this.stateFactories[t])throw"The specified state type "+t+" is not valid.";var r=this.stateFactories[t]();if(null!==r)return r.ruleIndex=e,r},W.prototype.lexerActionFactory=function(t,e,n){if(null===this.actionFactories){var r=[];r[j.CHANNEL]=function(t,e){return new B(t)},r[j.CUSTOM]=function(t,e){return new U(t,e)},r[j.MODE]=function(t,e){return new G(t)},r[j.MORE]=function(t,e){return V.INSTANCE},r[j.POP_MODE]=function(t,e){return q.INSTANCE},r[j.PUSH_MODE]=function(t,e){return new z(t)},r[j.SKIP]=function(t,e){return M.INSTANCE},r[j.TYPE]=function(t,e){return new H(t)},this.actionFactories=r}if(t>this.actionFactories.length||null===this.actionFactories[t])throw"The specified lexer action type "+t+" is not valid.";return this.actionFactories[t](e,n)},e.ATNDeserializer=W},function(t,e){function n(t){return void 0===t&&(t=null),this.readOnly=!1,this.verifyATN=null===t||t.verifyATN,this.generateRuleBypassTransitions=null!==t&&t.generateRuleBypassTransitions,this}n.defaultOptions=new n,n.defaultOptions.readOnly=!0,e.ATNDeserializationOptions=n},function(t,e){function n(){}function r(t){return this.actionType=t,this.isPositionDependent=!1,this}function i(){return r.call(this,n.SKIP),this}function o(t){return r.call(this,n.TYPE),this.type=t,this}function s(t){return r.call(this,n.PUSH_MODE),this.mode=t,this}function a(){return r.call(this,n.POP_MODE),this}function l(){return r.call(this,n.MORE),this}function u(t){return r.call(this,n.MODE),this.mode=t,this}function c(t,e){return r.call(this,n.CUSTOM),this.ruleIndex=t,this.actionIndex=e,this.isPositionDependent=!0,this}function h(t){return r.call(this,n.CHANNEL),this.channel=t,this}function p(t,e){return r.call(this,e.actionType),this.offset=t,this.action=e,this.isPositionDependent=!0,this}n.CHANNEL=0,n.CUSTOM=1,n.MODE=2,n.MORE=3,n.POP_MODE=4,n.PUSH_MODE=5,n.SKIP=6,n.TYPE=7,r.prototype.hashCode=function(){var t=new Hash;return this.updateHashCode(t),t.finish()},r.prototype.updateHashCode=function(t){t.update(this.actionType)},r.prototype.equals=function(t){return this===t},i.prototype=Object.create(r.prototype),i.prototype.constructor=i,i.INSTANCE=new i,i.prototype.execute=function(t){t.skip()},i.prototype.toString=function(){return"skip"},o.prototype=Object.create(r.prototype),o.prototype.constructor=o,o.prototype.execute=function(t){t.type=this.type},o.prototype.updateHashCode=function(t){t.update(this.actionType,this.type)},o.prototype.equals=function(t){return this===t||t instanceof o&&this.type===t.type},o.prototype.toString=function(){return"type("+this.type+")"},s.prototype=Object.create(r.prototype),s.prototype.constructor=s,s.prototype.execute=function(t){t.pushMode(this.mode)},s.prototype.updateHashCode=function(t){t.update(this.actionType,this.mode)},s.prototype.equals=function(t){return this===t||t instanceof s&&this.mode===t.mode},s.prototype.toString=function(){return"pushMode("+this.mode+")"},a.prototype=Object.create(r.prototype),a.prototype.constructor=a,a.INSTANCE=new a,a.prototype.execute=function(t){t.popMode()},a.prototype.toString=function(){return"popMode"},l.prototype=Object.create(r.prototype),l.prototype.constructor=l,l.INSTANCE=new l,l.prototype.execute=function(t){t.more()},l.prototype.toString=function(){return"more"},u.prototype=Object.create(r.prototype),u.prototype.constructor=u,u.prototype.execute=function(t){t.mode(this.mode)},u.prototype.updateHashCode=function(t){t.update(this.actionType,this.mode)},u.prototype.equals=function(t){return this===t||t instanceof u&&this.mode===t.mode},u.prototype.toString=function(){return"mode("+this.mode+")"},c.prototype=Object.create(r.prototype),c.prototype.constructor=c,c.prototype.execute=function(t){t.action(null,this.ruleIndex,this.actionIndex)},c.prototype.updateHashCode=function(t){t.update(this.actionType,this.ruleIndex,this.actionIndex)},c.prototype.equals=function(t){return this===t||t instanceof c&&(this.ruleIndex===t.ruleIndex&&this.actionIndex===t.actionIndex)},h.prototype=Object.create(r.prototype),h.prototype.constructor=h,h.prototype.execute=function(t){t._channel=this.channel},h.prototype.updateHashCode=function(t){t.update(this.actionType,this.channel)},h.prototype.equals=function(t){return this===t||t instanceof h&&this.channel===t.channel},h.prototype.toString=function(){return"channel("+this.channel+")"},p.prototype=Object.create(r.prototype),p.prototype.constructor=p,p.prototype.execute=function(t){this.action.execute(t)},p.prototype.updateHashCode=function(t){t.update(this.actionType,this.offset,this.action)},p.prototype.equals=function(t){return this===t||t instanceof p&&(this.offset===t.offset&&this.action===t.action)},e.LexerActionType=n,e.LexerSkipAction=i,e.LexerChannelAction=h,e.LexerCustomAction=c,e.LexerIndexedCustomAction=p,e.LexerMoreAction=l,e.LexerTypeAction=o,e.LexerPushModeAction=s,e.LexerPopModeAction=a,e.LexerModeAction=u},function(t,e,n){var r=n(1).Token,i=n(16).ConsoleErrorListener,o=n(16).ProxyErrorListener;function s(){return this._listeners=[i.INSTANCE],this._interp=null,this._stateNumber=-1,this}s.tokenTypeMapCache={},s.ruleIndexMapCache={},s.prototype.checkVersion=function(t){"4.7"!==t&&console.log("ANTLR runtime and generated code versions disagree: 4.7!="+t)},s.prototype.addErrorListener=function(t){this._listeners.push(t)},s.prototype.removeErrorListeners=function(){this._listeners=[]},s.prototype.getTokenTypeMap=function(){var t=this.getTokenNames();if(null===t)throw"The current recognizer does not provide a list of token names.";var e=this.tokenTypeMapCache[t];return void 0===e&&((e=t.reduce(function(t,e,n){t[e]=n})).EOF=r.EOF,this.tokenTypeMapCache[t]=e),e},s.prototype.getRuleIndexMap=function(){var t=this.ruleNames;if(null===t)throw"The current recognizer does not provide a list of rule names.";var e=this.ruleIndexMapCache[t];return void 0===e&&(e=t.reduce(function(t,e,n){t[e]=n}),this.ruleIndexMapCache[t]=e),e},s.prototype.getTokenType=function(t){var e=this.getTokenTypeMap()[t];return void 0!==e?e:r.INVALID_TYPE},s.prototype.getErrorHeader=function(t){return"line "+t.getOffendingToken().line+":"+t.getOffendingToken().column},s.prototype.getTokenErrorDisplay=function(t){if(null===t)return"<no token>";var e=t.text;return null===e&&(e=t.type===r.EOF?"<EOF>":"<"+t.type+">"),"'"+(e=e.replace("\n","\\n").replace("\r","\\r").replace("\t","\\t"))+"'"},s.prototype.getErrorListenerDispatch=function(){return new o(this._listeners)},s.prototype.sempred=function(t,e,n){return!0},s.prototype.precpred=function(t,e){return!0},Object.defineProperty(s.prototype,"state",{get:function(){return this._stateNumber},set:function(t){this._stateNumber=t}}),e.Recognizer=s},function(t,e,n){var r=n(11).DFAState,i=n(9).ATNConfigSet,o=n(6).getCachedPredictionContext;function s(t,e){return this.atn=t,this.sharedContextCache=e,this}s.ERROR=new r(2147483647,new i),s.prototype.getCachedContext=function(t){if(null===this.sharedContextCache)return t;return o(t,this.sharedContextCache,{})},e.ATNSimulator=s},function(t,e,n){n(0).Set;var r=n(0).Map,i=n(0).BitSet,o=n(0).AltDict,s=n(7).ATN,a=n(3).RuleStopState,l=n(9).ATNConfigSet,u=n(13).ATNConfig,c=n(10).SemanticContext,h=(n(0).Hash,n(0).hashStuff);n(0).equalArrays;function p(){return this}p.SLL=0,p.LL=1,p.LL_EXACT_AMBIG_DETECTION=2,p.hasSLLConflictTerminatingPrediction=function(t,e){if(p.allConfigsInRuleStopStates(e))return!0;if(t===p.SLL&&e.hasSemanticContext){for(var n=new l,r=0;r<e.items.length;r++){var i=e.items[r];i=new u({semanticContext:c.NONE},i),n.add(i)}e=n}var o=p.getConflictingAltSubsets(e);return p.hasConflictingAltSet(o)&&!p.hasStateAssociatedWithOneAlt(e)},p.hasConfigInRuleStopState=function(t){for(var e=0;e<t.items.length;e++){if(t.items[e].state instanceof a)return!0}return!1},p.allConfigsInRuleStopStates=function(t){for(var e=0;e<t.items.length;e++){if(!(t.items[e].state instanceof a))return!1}return!0},p.resolvesToJustOneViableAlt=function(t){return p.getSingleViableAlt(t)},p.allSubsetsConflict=function(t){return!p.hasNonConflictingAltSet(t)},p.hasNonConflictingAltSet=function(t){for(var e=0;e<t.length;e++){if(1===t[e].length)return!0}return!1},p.hasConflictingAltSet=function(t){for(var e=0;e<t.length;e++){if(t[e].length>1)return!0}return!1},p.allSubsetsEqual=function(t){for(var e=null,n=0;n<t.length;n++){var r=t[n];if(null===e)e=r;else if(r!==e)return!1}return!0},p.getUniqueAlt=function(t){var e=p.getAlts(t);return 1===e.length?e.minValue():s.INVALID_ALT_NUMBER},p.getAlts=function(t){var e=new i;return t.map(function(t){e.or(t)}),e},p.getConflictingAltSubsets=function(t){var e=new r;return e.hashFunction=function(t){h(t.state.stateNumber,t.context)},e.equalsFunction=function(t,e){return t.state.stateNumber==e.state.stateNumber&&t.context.equals(e.context)},t.items.map(function(t){var n=e.get(t);null===n&&(n=new i,e.put(t,n)),n.add(t.alt)}),e.getValues()},p.getStateToAltMap=function(t){var e=new o;return t.items.map(function(t){var n=e.get(t.state);null===n&&(n=new i,e.put(t.state,n)),n.add(t.alt)}),e},p.hasStateAssociatedWithOneAlt=function(t){for(var e=p.getStateToAltMap(t).values(),n=0;n<e.length;n++)if(1===e[n].length)return!0;return!1},p.getSingleViableAlt=function(t){for(var e=null,n=0;n<t.length;n++){var r=t[n].minValue();if(null===e)e=r;else if(e!==r)return s.INVALID_ALT_NUMBER}return e},e.PredictionMode=p},function(t,e){String.prototype.codePointAt||function(){"use strict";var t=function(){try{var t={},e=Object.defineProperty,n=e(t,t,t)&&e}catch(t){}return n}(),e=function(t){if(null==this)throw TypeError();var e=String(this),n=e.length,r=t?Number(t):0;if(r!=r&&(r=0),!(r<0||r>=n)){var i,o=e.charCodeAt(r);return o>=55296&&o<=56319&&n>r+1&&(i=e.charCodeAt(r+1))>=56320&&i<=57343?1024*(o-55296)+i-56320+65536:o}};t?t(String.prototype,"codePointAt",{value:e,configurable:!0,writable:!0}):String.prototype.codePointAt=e}()},function(t,e){var n,r,i,o;String.fromCodePoint||(n=function(){try{var t={},e=Object.defineProperty,n=e(t,t,t)&&e}catch(t){}return n}(),r=String.fromCharCode,i=Math.floor,o=function(t){var e,n,o=[],s=-1,a=arguments.length;if(!a)return"";for(var l="";++s<a;){var u=Number(arguments[s]);if(!isFinite(u)||u<0||u>1114111||i(u)!=u)throw RangeError("Invalid code point: "+u);u<=65535?o.push(u):(e=55296+((u-=65536)>>10),n=u%1024+56320,o.push(e,n)),(s+1==a||o.length>16384)&&(l+=r.apply(null,o),o.length=0)}return l},n?n(String,"fromCodePoint",{value:o,configurable:!0,writable:!0}):String.fromCodePoint=o)},function(t,e,n){var r=n(1).Token,i=n(5),o=i.NoViableAltException,s=i.InputMismatchException,a=i.FailedPredicateException,l=i.ParseCancellationException,u=n(3).ATNState,c=n(2).Interval,h=n(2).IntervalSet;function p(){}function f(){return p.call(this),this.errorRecoveryMode=!1,this.lastErrorIndex=-1,this.lastErrorStates=null,this}function d(){return f.call(this),this}p.prototype.reset=function(t){},p.prototype.recoverInline=function(t){},p.prototype.recover=function(t,e){},p.prototype.sync=function(t){},p.prototype.inErrorRecoveryMode=function(t){},p.prototype.reportError=function(t){},f.prototype=Object.create(p.prototype),f.prototype.constructor=f,f.prototype.reset=function(t){this.endErrorCondition(t)},f.prototype.beginErrorCondition=function(t){this.errorRecoveryMode=!0},f.prototype.inErrorRecoveryMode=function(t){return this.errorRecoveryMode},f.prototype.endErrorCondition=function(t){this.errorRecoveryMode=!1,this.lastErrorStates=null,this.lastErrorIndex=-1},f.prototype.reportMatch=function(t){this.endErrorCondition(t)},f.prototype.reportError=function(t,e){this.inErrorRecoveryMode(t)||(this.beginErrorCondition(t),e instanceof o?this.reportNoViableAlternative(t,e):e instanceof s?this.reportInputMismatch(t,e):e instanceof a?this.reportFailedPredicate(t,e):(console.log("unknown recognition error type: "+e.constructor.name),console.log(e.stack),t.notifyErrorListeners(e.getOffendingToken(),e.getMessage(),e)))},f.prototype.recover=function(t,e){this.lastErrorIndex===t.getInputStream().index&&null!==this.lastErrorStates&&this.lastErrorStates.indexOf(t.state)>=0&&t.consume(),this.lastErrorIndex=t._input.index,null===this.lastErrorStates&&(this.lastErrorStates=[]),this.lastErrorStates.push(t.state);var n=this.getErrorRecoverySet(t);this.consumeUntil(t,n)},f.prototype.sync=function(t){if(!this.inErrorRecoveryMode(t)){var e=t._interp.atn.states[t.state],n=t.getTokenStream().LA(1),i=t.atn.nextTokens(e);if(!i.contains(r.EPSILON)&&!i.contains(n))switch(e.stateType){case u.BLOCK_START:case u.STAR_BLOCK_START:case u.PLUS_BLOCK_START:case u.STAR_LOOP_ENTRY:if(null!==this.singleTokenDeletion(t))return;throw new s(t);case u.PLUS_LOOP_BACK:case u.STAR_LOOP_BACK:this.reportUnwantedToken(t);var o=new h;o.addSet(t.getExpectedTokens());var a=o.addSet(this.getErrorRecoverySet(t));this.consumeUntil(t,a)}}},f.prototype.reportNoViableAlternative=function(t,e){var n,i=t.getTokenStream();n=null!==i?e.startToken.type===r.EOF?"<EOF>":i.getText(new c(e.startToken,e.offendingToken)):"<unknown input>";var o="no viable alternative at input "+this.escapeWSAndQuote(n);t.notifyErrorListeners(o,e.offendingToken,e)},f.prototype.reportInputMismatch=function(t,e){var n="mismatched input "+this.getTokenErrorDisplay(e.offendingToken)+" expecting "+e.getExpectedTokens().toString(t.literalNames,t.symbolicNames);t.notifyErrorListeners(n,e.offendingToken,e)},f.prototype.reportFailedPredicate=function(t,e){var n="rule "+t.ruleNames[t._ctx.ruleIndex]+" "+e.message;t.notifyErrorListeners(n,e.offendingToken,e)},f.prototype.reportUnwantedToken=function(t){if(!this.inErrorRecoveryMode(t)){this.beginErrorCondition(t);var e=t.getCurrentToken(),n="extraneous input "+this.getTokenErrorDisplay(e)+" expecting "+this.getExpectedTokens(t).toString(t.literalNames,t.symbolicNames);t.notifyErrorListeners(n,e,null)}},f.prototype.reportMissingToken=function(t){if(!this.inErrorRecoveryMode(t)){this.beginErrorCondition(t);var e=t.getCurrentToken(),n="missing "+this.getExpectedTokens(t).toString(t.literalNames,t.symbolicNames)+" at "+this.getTokenErrorDisplay(e);t.notifyErrorListeners(n,e,null)}},f.prototype.recoverInline=function(t){var e=this.singleTokenDeletion(t);if(null!==e)return t.consume(),e;if(this.singleTokenInsertion(t))return this.getMissingSymbol(t);throw new s(t)},f.prototype.singleTokenInsertion=function(t){var e=t.getTokenStream().LA(1),n=t._interp.atn,r=n.states[t.state].transitions[0].target;return!!n.nextTokens(r,t._ctx).contains(e)&&(this.reportMissingToken(t),!0)},f.prototype.singleTokenDeletion=function(t){var e=t.getTokenStream().LA(2);if(this.getExpectedTokens(t).contains(e)){this.reportUnwantedToken(t),t.consume();var n=t.getCurrentToken();return this.reportMatch(t),n}return null},f.prototype.getMissingSymbol=function(t){var e,n=t.getCurrentToken(),i=this.getExpectedTokens(t).first();e=i===r.EOF?"<missing EOF>":"<missing "+t.literalNames[i]+">";var o=n,s=t.getTokenStream().LT(-1);return o.type===r.EOF&&null!==s&&(o=s),t.getTokenFactory().create(o.source,i,e,r.DEFAULT_CHANNEL,-1,-1,o.line,o.column)},f.prototype.getExpectedTokens=function(t){return t.getExpectedTokens()},f.prototype.getTokenErrorDisplay=function(t){if(null===t)return"<no token>";var e=t.text;return null===e&&(e=t.type===r.EOF?"<EOF>":"<"+t.type+">"),this.escapeWSAndQuote(e)},f.prototype.escapeWSAndQuote=function(t){return"'"+(t=(t=(t=t.replace(/\n/g,"\\n")).replace(/\r/g,"\\r")).replace(/\t/g,"\\t"))+"'"},f.prototype.getErrorRecoverySet=function(t){for(var e=t._interp.atn,n=t._ctx,i=new h;null!==n&&n.invokingState>=0;){var o=e.states[n.invokingState].transitions[0],s=e.nextTokens(o.followState);i.addSet(s),n=n.parentCtx}return i.removeOne(r.EPSILON),i},f.prototype.consumeUntil=function(t,e){for(var n=t.getTokenStream().LA(1);n!==r.EOF&&!e.contains(n);)t.consume(),n=t.getTokenStream().LA(1)},d.prototype=Object.create(f.prototype),d.prototype.constructor=d,d.prototype.recover=function(t,e){for(var n=t._ctx;null!==n;)n.exception=e,n=n.parentCtx;throw new l(e)},d.prototype.recoverInline=function(t){this.recover(t,new s(t))},d.prototype.sync=function(t){},e.BailErrorStrategy=d,e.DefaultErrorStrategy=f},function(t,e){},function(t,e,n){Converter=n(33).Converter},function(module,exports,__webpack_require__){antlr4=__webpack_require__(12);var BlocklyGrammerVisitor=__webpack_require__(20).BlocklyGrammerVisitor,BlocklyGrammerLexer=__webpack_require__(51).BlocklyGrammerLexer,BlocklyGrammerParser=__webpack_require__(52).BlocklyGrammerParser,Visitors=__webpack_require__(53),SymbolVisitor=Visitors.SymbolVisitor,EvalVisitor=Visitors.EvalVisitor,tpl=__webpack_require__(54);function Converter(){return this}Converter.prototype.constructor=Converter,Converter.prototype.init=function(){return this.toolboxGap=5,this.toolboxId="toolbox",this.blocklyDivId="blocklyDiv",this.workSpaceName="workspace",this.codeAreaId="codeArea",this},Converter.prototype.main=function(t,e,n){return this.init(),this.generBlocks(t,e),this.renderGrammerName(),this.generToolbox(),this.generMainFile(),this.writeMainFile(n),this},Converter.prototype.generBlocks=function(grammerFile,functions){functions||(functions=[]);var temp_consoleError=console.error;console.error=function(t){throw new Error(t)};var chars=new antlr4.InputStream(grammerFile),lexer=new BlocklyGrammerLexer(chars),tokens=new antlr4.CommonTokenStream(lexer),parser=new BlocklyGrammerParser(tokens);parser.buildParseTrees=!0;var tree=parser.grammarFile();console.error=temp_consoleError;var svisitor=(new SymbolVisitor).init();this.svisitor=svisitor,svisitor.visit(tree),console.log(svisitor),svisitor.checkSymbol();var evisitor=(new EvalVisitor).init(svisitor,grammerFile);return this.evisitor=evisitor,eval(this.evisitor.matchInject("Function_0")),functions[0]&&functions[0].call(this),evisitor.visit(tree),eval(this.evisitor.matchInject("Function_1")),functions[1]&&functions[1].call(this),evisitor.generBlocks(),console.log(evisitor),this.blocks=evisitor.blocks,eval(this.evisitor.matchInject("Function_2")),functions[2]&&functions[2].call(this),this},Converter.prototype.renderGrammerName=function(){this.grammerName=this.svisitor.grammerName,this.generLanguage=this.evisitor.generLanguage;var t=this.grammerName,e=this.generLanguage;return this.OmitedError=tpl.OmitedError(),this.Functions_pre=tpl.Functions_pre(t),this.Functions_xmlText=tpl.Functions_xmlText(t),this.Functions_blocksIniter=tpl.Functions_blocksIniter(t,e),this.mainFileTPL=tpl.mainFileTPL,this},Converter.prototype.generToolbox=function(){eval(this.grammerName+"Functions={};"),eval(this.Functions_xmlText),eval(this.blocks),eval("var blocksobj = "+this.grammerName+"Blocks;"),console.log(blocksobj);var text=[];for(var key in text.push('<xml id="'+this.toolboxId+'" style="display:none">'),text.push('<category name="statement">'),blocksobj){var value=blocksobj[key];value instanceof Array||"value"!==value.type&&(text.push(value.xmlText()),text.push('<sep gap="'+this.toolboxGap+'"></sep>'))}for(var key in text.pop(),text.push("</category>"),text.push('<sep gap="'+3*this.toolboxGap+'"></sep>'),text.push('<category name="value">'),blocksobj){var value=blocksobj[key];value instanceof Array||"statement"!==value.type&&(text.push(value.xmlText()),text.push('<sep gap="'+this.toolboxGap+'"></sep>'))}return text.pop(),text.push("</category>"),text.push("</xml>"),this.toolbox=this.textToPrettyText(text.join("")),this},Converter.prototype.generMainFile=function(){var t=[],e=this.grammerName;t.push(this.blocks),t.push("\n\n"),t.push(this.OmitedError),t.push("\n\n"),t.push(e+"Functions={}\n\n"),t.push(this.evisitor.matchInject("Functions")),t.push("\n\n"),t.push(this.Functions_pre),t.push("\n\n"),t.push(this.Functions_xmlText),t.push("\n\n"),t.push(this.Functions_blocksIniter),t.push("\n\n"),t.push(e+"Functions.blocksIniter();\n\n"),this.mainFile=this.mainFileTPL(e,this.generLanguage,this.blocklyDivId,this.codeAreaId,this.toolbox,this.workSpaceName,this.toolboxId,t.join(""))},Converter.prototype.writeMainFile=function(t){t||(t=this.grammerName+"index.html"),this.createAndDownloadFile(this.mainFile.join(""),t,"html")},Converter.prototype.block=function(t){var e=this.evisitor.expressionRules[t];return e||(e=this.evisitor.statementRules[t]),e&&1!==e.checklength?e.blockjs:null},Converter.prototype.textToPrettyText=function(t){for(var e=t.split("<"),n="",r=1;r<e.length;r++){var i=e[r];"/"==i[0]&&(n=n.substring(2)),e[r]=n+"<"+i,"/"!=i[0]&&"/>"!=i.slice(-2)&&(n+="  ")}var o=e.join("\n");return(o=o.replace(/(<(\w+)\b[^>]*>[^\n]*)\n *<\/\2>/g,"$1</$2>")).replace(/^\n/,"")},Converter.prototype.createAndDownloadFile=function(t,e,n){var r=new Blob([t],{type:"text/"+n}),i=new MouseEvent("click",{view:window,bubbles:!0,cancelable:!1}),o=document.createElement("a");o.href=window.URL.createObjectURL(r),o.download=e,o.textContent="Download file!",o.dispatchEvent(i)},exports.Converter=Converter},function(t,e,n){e.ATN=n(7).ATN,e.ATNDeserializer=n(22).ATNDeserializer,e.LexerATNSimulator=n(37).LexerATNSimulator,e.ParserATNSimulator=n(40).ParserATNSimulator,e.PredictionMode=n(27).PredictionMode},function(t,e,n){var r=n(0).Set,i=n(0).BitSet,o=n(1).Token,s=n(13).ATNConfig,a=(n(2).Interval,n(2).IntervalSet),l=n(3).RuleStopState,u=n(8).RuleTransition,c=n(8).NotSetTransition,h=n(8).WildcardTransition,p=n(8).AbstractPredicateTransition,f=n(6),d=f.predictionContextFromRuleContext,y=f.PredictionContext,g=f.SingletonPredictionContext;function v(t){this.atn=t}v.HIT_PRED=o.INVALID_TYPE,v.prototype.getDecisionLookahead=function(t){if(null===t)return null;for(var e=t.transitions.length,n=[],o=0;o<e;o++){n[o]=new a;var s=new r;this._LOOK(t.transition(o).target,null,y.EMPTY,n[o],s,new i,!1,!1),(0===n[o].length||n[o].contains(v.HIT_PRED))&&(n[o]=null)}return n},v.prototype.LOOK=function(t,e,n){var o=new a,s=null!==(n=n||null)?d(t.atn,n):null;return this._LOOK(t,e,s,o,new r,new i,!0,!0),o},v.prototype._LOOK=function(t,e,n,r,i,a,f,d){var x=new s({state:t,alt:0,context:n},null);if(!i.contains(x)){if(i.add(x),t===e){if(null===n)return void r.addOne(o.EPSILON);if(n.isEmpty()&&d)return void r.addOne(o.EOF)}if(t instanceof l){if(null===n)return void r.addOne(o.EPSILON);if(n.isEmpty()&&d)return void r.addOne(o.EOF);if(n!==y.EMPTY){for(var m=0;m<n.length;m++){var _=this.atn.states[n.getReturnState(m)],T=a.contains(_.ruleIndex);try{a.remove(_.ruleIndex),this._LOOK(_,e,n.getParent(m),r,i,a,f,d)}finally{T&&a.add(_.ruleIndex)}}return}}for(var S=0;S<t.transitions.length;S++){var E=t.transitions[S];if(E.constructor===u){if(a.contains(E.target.ruleIndex))continue;var C=g.create(n,E.followState.stateNumber);try{a.add(E.target.ruleIndex),this._LOOK(E.target,e,C,r,i,a,f,d)}finally{a.remove(E.target.ruleIndex)}}else if(E instanceof p)f?this._LOOK(E.target,e,n,r,i,a,f,d):r.addOne(v.HIT_PRED);else if(E.isEpsilon)this._LOOK(E.target,e,n,r,i,a,f,d);else if(E.constructor===h)r.addRange(o.MIN_USER_TOKEN_TYPE,this.atn.maxTokenType);else{var A=E.label;null!==A&&(E instanceof c&&(A=A.complement(o.MIN_USER_TOKEN_TYPE,this.atn.maxTokenType)),r.addSet(A))}}}},e.LL1Analyzer=v},function(t,e){function n(){}n.LEXER=0,n.PARSER=1,e.ATNType=n},function(t,e,n){var r=n(1).Token,i=n(15).Lexer,o=n(7).ATN,s=n(26).ATNSimulator,a=n(11).DFAState,l=(n(9).ATNConfigSet,n(9).OrderedATNConfigSet),u=n(6).PredictionContext,c=n(6).SingletonPredictionContext,h=n(3).RuleStopState,p=n(13).LexerATNConfig,f=n(8).Transition,d=n(39).LexerActionExecutor,y=n(5).LexerNoViableAltException;function g(t){t.index=-1,t.line=0,t.column=-1,t.dfaState=null}function v(){return g(this),this}function x(t,e,n,r){return s.call(this,e,r),this.decisionToDFA=n,this.recog=t,this.startIndex=-1,this.line=1,this.column=0,this.mode=i.DEFAULT_MODE,this.prevAccept=new v,this}v.prototype.reset=function(){g(this)},x.prototype=Object.create(s.prototype),x.prototype.constructor=x,x.debug=!1,x.dfa_debug=!1,x.MIN_DFA_EDGE=0,x.MAX_DFA_EDGE=127,x.match_calls=0,x.prototype.copyState=function(t){this.column=t.column,this.line=t.line,this.mode=t.mode,this.startIndex=t.startIndex},x.prototype.match=function(t,e){this.match_calls+=1,this.mode=e;var n=t.mark();try{this.startIndex=t.index,this.prevAccept.reset();var r=this.decisionToDFA[e];return null===r.s0?this.matchATN(t):this.execATN(t,r.s0)}finally{t.release(n)}},x.prototype.reset=function(){this.prevAccept.reset(),this.startIndex=-1,this.line=1,this.column=0,this.mode=i.DEFAULT_MODE},x.prototype.matchATN=function(t){var e=this.atn.modeToStartState[this.mode];x.debug&&console.log("matchATN mode "+this.mode+" start: "+e);var n=this.mode,r=this.computeStartState(t,e),i=r.hasSemanticContext;r.hasSemanticContext=!1;var o=this.addDFAState(r);i||(this.decisionToDFA[this.mode].s0=o);var s=this.execATN(t,o);return x.debug&&console.log("DFA after matchATN: "+this.decisionToDFA[n].toLexerString()),s},x.prototype.execATN=function(t,e){x.debug&&console.log("start state closure="+e.configs),e.isAcceptState&&this.captureSimState(this.prevAccept,t,e);for(var n=t.LA(1),i=e;;){x.debug&&console.log("execATN loop starting closure: "+i.configs);var o=this.getExistingTargetState(i,n);if(null===o&&(o=this.computeTargetState(t,i,n)),o===s.ERROR)break;if(n!==r.EOF&&this.consume(t),o.isAcceptState&&(this.captureSimState(this.prevAccept,t,o),n===r.EOF))break;n=t.LA(1),i=o}return this.failOrAccept(this.prevAccept,t,i.configs,n)},x.prototype.getExistingTargetState=function(t,e){if(null===t.edges||e<x.MIN_DFA_EDGE||e>x.MAX_DFA_EDGE)return null;var n=t.edges[e-x.MIN_DFA_EDGE];return void 0===n&&(n=null),x.debug&&null!==n&&console.log("reuse state "+t.stateNumber+" edge to "+n.stateNumber),n},x.prototype.computeTargetState=function(t,e,n){var r=new l;return this.getReachableConfigSet(t,e.configs,r,n),0===r.items.length?(r.hasSemanticContext||this.addDFAEdge(e,n,s.ERROR),s.ERROR):this.addDFAEdge(e,n,null,r)},x.prototype.failOrAccept=function(t,e,n,i){if(null!==this.prevAccept.dfaState){var o=t.dfaState.lexerActionExecutor;return this.accept(e,o,this.startIndex,t.index,t.line,t.column),t.dfaState.prediction}if(i===r.EOF&&e.index===this.startIndex)return r.EOF;throw new y(this.recog,e,this.startIndex,n)},x.prototype.getReachableConfigSet=function(t,e,n,i){for(var s=o.INVALID_ALT_NUMBER,a=0;a<e.items.length;a++){var l=e.items[a],u=l.alt===s;if(!u||!l.passedThroughNonGreedyDecision){x.debug&&console.log("testing %s at %s\n",this.getTokenName(i),l.toString(this.recog,!0));for(var c=0;c<l.state.transitions.length;c++){var h=l.state.transitions[c],f=this.getReachableTarget(h,i);if(null!==f){var d=l.lexerActionExecutor;null!==d&&(d=d.fixOffsetBeforeMatch(t.index-this.startIndex));var y=i===r.EOF,g=new p({state:f,lexerActionExecutor:d},l);this.closure(t,g,n,u,!0,y)&&(s=l.alt)}}}}},x.prototype.accept=function(t,e,n,r,i,o){x.debug&&console.log("ACTION %s\n",e),t.seek(r),this.line=i,this.column=o,null!==e&&null!==this.recog&&e.execute(this.recog,t,n)},x.prototype.getReachableTarget=function(t,e){return t.matches(e,0,i.MAX_CHAR_VALUE)?t.target:null},x.prototype.computeStartState=function(t,e){for(var n=u.EMPTY,r=new l,i=0;i<e.transitions.length;i++){var o=e.transitions[i].target,s=new p({state:o,alt:i+1,context:n},null);this.closure(t,s,r,!1,!1,!1)}return r},x.prototype.closure=function(t,e,n,r,i,o){var s=null;if(x.debug&&console.log("closure("+e.toString(this.recog,!0)+")"),e.state instanceof h){if(x.debug&&(null!==this.recog?console.log("closure at %s rule stop %s\n",this.recog.ruleNames[e.state.ruleIndex],e):console.log("closure at rule stop %s\n",e)),null===e.context||e.context.hasEmptyPath()){if(null===e.context||e.context.isEmpty())return n.add(e),!0;n.add(new p({state:e.state,context:u.EMPTY},e)),r=!0}if(null!==e.context&&!e.context.isEmpty())for(var a=0;a<e.context.length;a++)if(e.context.getReturnState(a)!==u.EMPTY_RETURN_STATE){var l=e.context.getParent(a),c=this.atn.states[e.context.getReturnState(a)];s=new p({state:c,context:l},e),r=this.closure(t,s,n,r,i,o)}return r}e.state.epsilonOnlyTransitions||r&&e.passedThroughNonGreedyDecision||n.add(e);for(var f=0;f<e.state.transitions.length;f++){var d=e.state.transitions[f];null!==(s=this.getEpsilonTarget(t,e,d,n,i,o))&&(r=this.closure(t,s,n,r,i,o))}return r},x.prototype.getEpsilonTarget=function(t,e,n,o,s,a){var l=null;if(n.serializationType===f.RULE){var u=c.create(e.context,n.followState.stateNumber);l=new p({state:n.target,context:u},e)}else{if(n.serializationType===f.PRECEDENCE)throw"Precedence predicates are not supported in lexers.";if(n.serializationType===f.PREDICATE)x.debug&&console.log("EVAL rule "+n.ruleIndex+":"+n.predIndex),o.hasSemanticContext=!0,this.evaluatePredicate(t,n.ruleIndex,n.predIndex,s)&&(l=new p({state:n.target},e));else if(n.serializationType===f.ACTION)if(null===e.context||e.context.hasEmptyPath()){var h=d.append(e.lexerActionExecutor,this.atn.lexerActions[n.actionIndex]);l=new p({state:n.target,lexerActionExecutor:h},e)}else l=new p({state:n.target},e);else n.serializationType===f.EPSILON?l=new p({state:n.target},e):n.serializationType!==f.ATOM&&n.serializationType!==f.RANGE&&n.serializationType!==f.SET||a&&n.matches(r.EOF,0,i.MAX_CHAR_VALUE)&&(l=new p({state:n.target},e))}return l},x.prototype.evaluatePredicate=function(t,e,n,r){if(null===this.recog)return!0;if(!r)return this.recog.sempred(null,e,n);var i=this.column,o=this.line,s=t.index,a=t.mark();try{return this.consume(t),this.recog.sempred(null,e,n)}finally{this.column=i,this.line=o,t.seek(s),t.release(a)}},x.prototype.captureSimState=function(t,e,n){t.index=e.index,t.line=this.line,t.column=this.column,t.dfaState=n},x.prototype.addDFAEdge=function(t,e,n,r){if(void 0===n&&(n=null),void 0===r&&(r=null),null===n&&null!==r){var i=r.hasSemanticContext;if(r.hasSemanticContext=!1,n=this.addDFAState(r),i)return n}return e<x.MIN_DFA_EDGE||e>x.MAX_DFA_EDGE?n:(x.debug&&console.log("EDGE "+t+" -> "+n+" upon "+e),null===t.edges&&(t.edges=[]),t.edges[e-x.MIN_DFA_EDGE]=n,n)},x.prototype.addDFAState=function(t){for(var e=new a(null,t),n=null,r=0;r<t.items.length;r++){var i=t.items[r];if(i.state instanceof h){n=i;break}}null!==n&&(e.isAcceptState=!0,e.lexerActionExecutor=n.lexerActionExecutor,e.prediction=this.atn.ruleToTokenType[n.state.ruleIndex]);var o=this.decisionToDFA[this.mode],s=o.states.get(e);if(null!==s)return s;var l=e;return l.stateNumber=o.states.length,t.setReadonly(!0),l.configs=t,o.states.add(l),l},x.prototype.getDFA=function(t){return this.decisionToDFA[t]},x.prototype.getText=function(t){return t.getText(this.startIndex,t.index-1)},x.prototype.consume=function(t){t.LA(1)==="\n".charCodeAt(0)?(this.line+=1,this.column=0):this.column+=1,t.consume()},x.prototype.getTokenName=function(t){return-1===t?"EOF":"'"+String.fromCharCode(t)+"'"},e.LexerATNSimulator=x},function(t,e,n){var r=n(1).CommonToken;function i(){return this}function o(t){return i.call(this),this.copyText=void 0!==t&&t,this}o.prototype=Object.create(i.prototype),o.prototype.constructor=o,o.DEFAULT=new o,o.prototype.create=function(t,e,n,i,o,s,a,l){var u=new r(t,e,i,o,s);return u.line=a,u.column=l,null!==n?u.text=n:this.copyText&&null!==t[1]&&(u.text=t[1].getText(o,s)),u},o.prototype.createThin=function(t,e){var n=new r(null,t);return n.text=e,n},e.CommonTokenFactory=o},function(t,e,n){var r=n(0).hashStuff,i=n(24).LexerIndexedCustomAction;function o(t){return this.lexerActions=null===t?[]:t,this.cachedHashCode=r(t),this}o.append=function(t,e){return new o(null===t?[e]:t.lexerActions.concat([e]))},o.prototype.fixOffsetBeforeMatch=function(t){for(var e=null,n=0;n<this.lexerActions.length;n++)!this.lexerActions[n].isPositionDependent||this.lexerActions[n]instanceof i||(null===e&&(e=this.lexerActions.concat([])),e[n]=new i(t,this.lexerActions[n]));return null===e?this:new o(e)},o.prototype.execute=function(t,e,n){var r=!1,o=e.index;try{for(var s=0;s<this.lexerActions.length;s++){var a=this.lexerActions[s];if(a instanceof i){var l=a.offset;e.seek(n+l),a=a.action,r=n+l!==o}else a.isPositionDependent&&(e.seek(o),r=!1);a.execute(t)}}finally{r&&e.seek(o)}},o.prototype.hashCode=function(){return this.cachedHashCode},o.prototype.updateHashCode=function(t){t.update(this.cachedHashCode)},o.prototype.equals=function(t){if(this===t)return!0;if(t instanceof o){if(this.cachedHashCode!=t.cachedHashCode)return!1;if(this.lexerActions.length!=t.lexerActions.length)return!1;for(var e=this.lexerActions.length,n=0;n<e;++n)if(!this.lexerActions[n].equals(t.lexerActions[n]))return!1;return!0}return!1},e.LexerActionExecutor=o},function(t,e,n){var r=n(0),i=r.Set,o=r.BitSet,s=r.DoubleDict,a=n(7).ATN,l=n(3).ATNState,u=n(13).ATNConfig,c=n(9).ATNConfigSet,h=n(1).Token,p=n(11).DFAState,f=n(11).PredPrediction,d=n(26).ATNSimulator,y=n(27).PredictionMode,g=n(14).RuleContext,v=(n(18).ParserRuleContext,n(10).SemanticContext),x=(n(3).StarLoopEntryState,n(3).RuleStopState),m=n(6).PredictionContext,_=n(2).Interval,T=n(8),S=T.Transition,E=T.SetTransition,C=T.NotSetTransition,A=T.RuleTransition,b=T.ActionTransition,k=n(5).NoViableAltException,R=n(6).SingletonPredictionContext,L=n(6).predictionContextFromRuleContext;function I(t,e,n,r){return d.call(this,e,r),this.parser=t,this.decisionToDFA=n,this.predictionMode=y.LL,this._input=null,this._startIndex=0,this._outerContext=null,this._dfa=null,this.mergeCache=null,this}I.prototype=Object.create(d.prototype),I.prototype.constructor=I,I.prototype.debug=!1,I.prototype.debug_closure=!1,I.prototype.debug_add=!1,I.prototype.debug_list_atn_decisions=!1,I.prototype.dfa_debug=!1,I.prototype.retry_debug=!1,I.prototype.reset=function(){},I.prototype.adaptivePredict=function(t,e,n){(this.debug||this.debug_list_atn_decisions)&&console.log("adaptivePredict decision "+e+" exec LA(1)=="+this.getLookaheadName(t)+" line "+t.LT(1).line+":"+t.LT(1).column),this._input=t,this._startIndex=t.index,this._outerContext=n;var r=this.decisionToDFA[e];this._dfa=r;var i=t.mark(),o=t.index;try{var s;if(null===(s=r.precedenceDfa?r.getPrecedenceStartState(this.parser.getPrecedence()):r.s0)){null===n&&(n=g.EMPTY),(this.debug||this.debug_list_atn_decisions)&&console.log("predictATN decision "+r.decision+" exec LA(1)=="+this.getLookaheadName(t)+", outerContext="+n.toString(this.parser.ruleNames));var a=this.computeStartState(r.atnStartState,g.EMPTY,!1);r.precedenceDfa?(r.s0.configs=a,a=this.applyPrecedenceFilter(a),s=this.addDFAState(r,new p(null,a)),r.setPrecedenceStartState(this.parser.getPrecedence(),s)):(s=this.addDFAState(r,new p(null,a)),r.s0=s)}var l=this.execATN(r,s,t,o,n);return this.debug&&console.log("DFA after predictATN: "+r.toString(this.parser.literalNames)),l}finally{this._dfa=null,this.mergeCache=null,t.seek(o),t.release(i)}},I.prototype.execATN=function(t,e,n,r,i){var o;(this.debug||this.debug_list_atn_decisions)&&console.log("execATN decision "+t.decision+" exec LA(1)=="+this.getLookaheadName(n)+" line "+n.LT(1).line+":"+n.LT(1).column);var s=e;this.debug&&console.log("s0 = "+e);for(var l=n.LA(1);;){var u=this.getExistingTargetState(s,l);if(null===u&&(u=this.computeTargetState(t,s,l)),u===d.ERROR){var c=this.noViableAlt(n,i,s.configs,r);if(n.seek(r),(o=this.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(s.configs,i))!==a.INVALID_ALT_NUMBER)return o;throw c}if(u.requiresFullContext&&this.predictionMode!==y.SLL){var p=null;if(null!==u.predicates){this.debug&&console.log("DFA state has preds in DFA sim LL failover");var f=n.index;if(f!==r&&n.seek(r),1===(p=this.evalSemanticContext(u.predicates,i,!0)).length)return this.debug&&console.log("Full LL avoided"),p.minValue();f!==r&&n.seek(f)}this.dfa_debug&&console.log("ctx sensitive state "+i+" in "+u);var g=this.computeStartState(t.atnStartState,i,!0);return this.reportAttemptingFullContext(t,p,u.configs,r,n.index),o=this.execATNWithFullContext(t,u,g,n,r,i)}if(u.isAcceptState){if(null===u.predicates)return u.prediction;var v=n.index;n.seek(r);var x=this.evalSemanticContext(u.predicates,i,!0);if(0===x.length)throw this.noViableAlt(n,i,u.configs,r);return 1===x.length?x.minValue():(this.reportAmbiguity(t,u,r,v,!1,x,u.configs),x.minValue())}s=u,l!==h.EOF&&(n.consume(),l=n.LA(1))}},I.prototype.getExistingTargetState=function(t,e){var n=t.edges;return null===n?null:n[e+1]||null},I.prototype.computeTargetState=function(t,e,n){var i=this.computeReachSet(e.configs,n,!1);if(null===i)return this.addDFAEdge(t,e,n,d.ERROR),d.ERROR;var o=new p(null,i),s=this.getUniqueAlt(i);if(this.debug){var l=y.getConflictingAltSubsets(i);console.log("SLL altSubSets="+r.arrayToString(l)+", previous="+e.configs+", configs="+i+", predict="+s+", allSubsetsConflict="+y.allSubsetsConflict(l)+", conflictingAlts="+this.getConflictingAlts(i))}return s!==a.INVALID_ALT_NUMBER?(o.isAcceptState=!0,o.configs.uniqueAlt=s,o.prediction=s):y.hasSLLConflictTerminatingPrediction(this.predictionMode,i)&&(o.configs.conflictingAlts=this.getConflictingAlts(i),o.requiresFullContext=!0,o.isAcceptState=!0,o.prediction=o.configs.conflictingAlts.minValue()),o.isAcceptState&&o.configs.hasSemanticContext&&(this.predicateDFAState(o,this.atn.getDecisionState(t.decision)),null!==o.predicates&&(o.prediction=a.INVALID_ALT_NUMBER)),o=this.addDFAEdge(t,e,n,o)},I.prototype.predicateDFAState=function(t,e){var n=e.transitions.length,r=this.getConflictingAltsOrUniqueAlt(t.configs),i=this.getPredsForAmbigAlts(r,t.configs,n);null!==i?(t.predicates=this.getPredicatePredictions(r,i),t.prediction=a.INVALID_ALT_NUMBER):t.prediction=r.minValue()},I.prototype.execATNWithFullContext=function(t,e,n,r,i,o){(this.debug||this.debug_list_atn_decisions)&&console.log("execATNWithFullContext "+n);var s=!1,l=null,u=n;r.seek(i);for(var c=r.LA(1),p=-1;;){if(null===(l=this.computeReachSet(u,c,!0))){var f=this.noViableAlt(r,o,u,i);r.seek(i);var d=this.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(u,o);if(d!==a.INVALID_ALT_NUMBER)return d;throw f}var g=y.getConflictingAltSubsets(l);if(this.debug&&console.log("LL altSubSets="+g+", predict="+y.getUniqueAlt(g)+", resolvesToJustOneViableAlt="+y.resolvesToJustOneViableAlt(g)),l.uniqueAlt=this.getUniqueAlt(l),l.uniqueAlt!==a.INVALID_ALT_NUMBER){p=l.uniqueAlt;break}if(this.predictionMode!==y.LL_EXACT_AMBIG_DETECTION){if((p=y.resolvesToJustOneViableAlt(g))!==a.INVALID_ALT_NUMBER)break}else if(y.allSubsetsConflict(g)&&y.allSubsetsEqual(g)){s=!0,p=y.getSingleViableAlt(g);break}u=l,c!==h.EOF&&(r.consume(),c=r.LA(1))}return l.uniqueAlt!==a.INVALID_ALT_NUMBER?(this.reportContextSensitivity(t,p,l,i,r.index),p):(this.reportAmbiguity(t,e,i,r.index,s,null,l),p)},I.prototype.computeReachSet=function(t,e,n){this.debug&&console.log("in computeReachSet, starting closure: "+t),null===this.mergeCache&&(this.mergeCache=new s);for(var r=new c(n),o=null,l=0;l<t.items.length;l++){var p=t.items[l];if(this.debug_add&&console.log("testing "+this.getTokenName(e)+" at "+p),p.state instanceof x)(n||e===h.EOF)&&(null===o&&(o=[]),o.push(p),this.debug_add&&console.log("added "+p+" to skippedStopStates"));else for(var f=0;f<p.state.transitions.length;f++){var d=p.state.transitions[f],g=this.getReachableTarget(d,e);if(null!==g){var v=new u({state:g},p);r.add(v,this.mergeCache),this.debug_add&&console.log("added "+v+" to intermediate")}}}var m=null;if(null===o&&e!==h.EOF&&(1===r.items.length?m=r:this.getUniqueAlt(r)!==a.INVALID_ALT_NUMBER&&(m=r)),null===m){m=new c(n);for(var _=new i,T=e===h.EOF,S=0;S<r.items.length;S++)this.closure(r.items[S],m,_,!1,n,T)}if(e===h.EOF&&(m=this.removeAllConfigsNotInRuleStopState(m,m===r)),!(null===o||n&&y.hasConfigInRuleStopState(m)))for(var E=0;E<o.length;E++)m.add(o[E],this.mergeCache);return 0===m.items.length?null:m},I.prototype.removeAllConfigsNotInRuleStopState=function(t,e){if(y.allConfigsInRuleStopStates(t))return t;for(var n=new c(t.fullCtx),r=0;r<t.items.length;r++){var i=t.items[r];if(i.state instanceof x)n.add(i,this.mergeCache);else if(e&&i.state.epsilonOnlyTransitions)if(this.atn.nextTokens(i.state).contains(h.EPSILON)){var o=this.atn.ruleToStopState[i.state.ruleIndex];n.add(new u({state:o},i),this.mergeCache)}}return n},I.prototype.computeStartState=function(t,e,n){for(var r=L(this.atn,e),o=new c(n),s=0;s<t.transitions.length;s++){var a=t.transitions[s].target,l=new u({state:a,alt:s+1,context:r},null),h=new i;this.closure(l,o,h,!0,n,!1)}return o},I.prototype.applyPrecedenceFilter=function(t){for(var e,n=[],r=new c(t.fullCtx),i=0;i<t.items.length;i++)if(1===(e=t.items[i]).alt){var o=e.semanticContext.evalPrecedence(this.parser,this._outerContext);null!==o&&(n[e.state.stateNumber]=e.context,o!==e.semanticContext?r.add(new u({semanticContext:o},e),this.mergeCache):r.add(e,this.mergeCache))}for(i=0;i<t.items.length;i++)if(1!==(e=t.items[i]).alt){if(!e.precedenceFilterSuppressed){var s=n[e.state.stateNumber]||null;if(null!==s&&s.equals(e.context))continue}r.add(e,this.mergeCache)}return r},I.prototype.getReachableTarget=function(t,e){return t.matches(e,0,this.atn.maxTokenType)?t.target:null},I.prototype.getPredsForAmbigAlts=function(t,e,n){for(var i=[],o=0;o<e.items.length;o++){var s=e.items[o];t.contains(s.alt)&&(i[s.alt]=v.orContext(i[s.alt]||null,s.semanticContext))}var a=0;for(o=1;o<n+1;o++){var l=i[o]||null;null===l?i[o]=v.NONE:l!==v.NONE&&(a+=1)}return 0===a&&(i=null),this.debug&&console.log("getPredsForAmbigAlts result "+r.arrayToString(i)),i},I.prototype.getPredicatePredictions=function(t,e){for(var n=[],r=!1,i=1;i<e.length;i++){var o=e[i];null!==t&&t.contains(i)&&n.push(new f(o,i)),o!==v.NONE&&(r=!0)}return r?n:null},I.prototype.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule=function(t,e){var n=this.splitAccordingToSemanticValidity(t,e),r=n[0],i=n[1],o=this.getAltThatFinishedDecisionEntryRule(r);return o!==a.INVALID_ALT_NUMBER?o:i.items.length>0&&(o=this.getAltThatFinishedDecisionEntryRule(i))!==a.INVALID_ALT_NUMBER?o:a.INVALID_ALT_NUMBER},I.prototype.getAltThatFinishedDecisionEntryRule=function(t){for(var e=[],n=0;n<t.items.length;n++){var r=t.items[n];(r.reachesIntoOuterContext>0||r.state instanceof x&&r.context.hasEmptyPath())&&e.indexOf(r.alt)<0&&e.push(r.alt)}return 0===e.length?a.INVALID_ALT_NUMBER:Math.min.apply(null,e)},I.prototype.splitAccordingToSemanticValidity=function(t,e){for(var n=new c(t.fullCtx),r=new c(t.fullCtx),i=0;i<t.items.length;i++){var o=t.items[i];if(o.semanticContext!==v.NONE)o.semanticContext.evaluate(this.parser,e)?n.add(o):r.add(o);else n.add(o)}return[n,r]},I.prototype.evalSemanticContext=function(t,e,n){for(var r=new o,i=0;i<t.length;i++){var s=t[i];if(s.pred!==v.NONE){var a=s.pred.evaluate(this.parser,e);if((this.debug||this.dfa_debug)&&console.log("eval pred "+s+"="+a),a&&((this.debug||this.dfa_debug)&&console.log("PREDICT "+s.alt),r.add(s.alt),!n))break}else if(r.add(s.alt),!n)break}return r},I.prototype.closure=function(t,e,n,r,i,o){this.closureCheckingStopState(t,e,n,r,i,0,o)},I.prototype.closureCheckingStopState=function(t,e,n,r,i,o,s){if((this.debug||this.debug_closure)&&(console.log("closure("+t.toString(this.parser,!0)+")"),t.reachesIntoOuterContext>50))throw"problem";if(t.state instanceof x){if(!t.context.isEmpty()){for(var a=0;a<t.context.length;a++)if(t.context.getReturnState(a)!==m.EMPTY_RETURN_STATE){var l=this.atn.states[t.context.getReturnState(a)],c=t.context.getParent(a),h={state:l,alt:t.alt,context:c,semanticContext:t.semanticContext},p=new u(h,null);p.reachesIntoOuterContext=t.reachesIntoOuterContext,this.closureCheckingStopState(p,e,n,r,i,o-1,s)}else{if(i){e.add(new u({state:t.state,context:m.EMPTY},t),this.mergeCache);continue}this.debug&&console.log("FALLING off rule "+this.getRuleName(t.state.ruleIndex)),this.closure_(t,e,n,r,i,o,s)}return}if(i)return void e.add(t,this.mergeCache);this.debug&&console.log("FALLING off rule "+this.getRuleName(t.state.ruleIndex))}this.closure_(t,e,n,r,i,o,s)},I.prototype.closure_=function(t,e,n,r,i,o,s){var a=t.state;a.epsilonOnlyTransitions||e.add(t,this.mergeCache);for(var l=0;l<a.transitions.length;l++)if(0!=l||!this.canDropLoopEntryEdgeInLeftRecursiveRule(t)){var u=a.transitions[l],c=r&&!(u instanceof b),h=this.getEpsilonTarget(t,u,c,0===o,i,s);if(null!==h){if(!u.isEpsilon&&n.add(h)!==h)continue;var p=o;if(t.state instanceof x){if(n.add(h)!==h)continue;null!==this._dfa&&this._dfa.precedenceDfa&&u.outermostPrecedenceReturn===this._dfa.atnStartState.ruleIndex&&(h.precedenceFilterSuppressed=!0),h.reachesIntoOuterContext+=1,e.dipsIntoOuterContext=!0,p-=1,this.debug&&console.log("dips into outer ctx: "+h)}else u instanceof A&&p>=0&&(p+=1);this.closureCheckingStopState(h,e,n,c,i,p,s)}}},I.prototype.canDropLoopEntryEdgeInLeftRecursiveRule=function(t){var e=t.state;if(e.stateType!=l.STAR_LOOP_ENTRY)return!1;if(e.stateType!=l.STAR_LOOP_ENTRY||!e.isPrecedenceDecision||t.context.isEmpty()||t.context.hasEmptyPath())return!1;for(var n=t.context.length,r=0;r<n;r++){if((s=this.atn.states[t.context.getReturnState(r)]).ruleIndex!=e.ruleIndex)return!1}var i=e.transitions[0].target.endState.stateNumber,o=this.atn.states[i];for(r=0;r<n;r++){var s,a=t.context.getReturnState(r);if(1!=(s=this.atn.states[a]).transitions.length||!s.transitions[0].isEpsilon)return!1;var u=s.transitions[0].target;if((s.stateType!=l.BLOCK_END||u!=e)&&(s!=o&&u!=o&&(u.stateType!=l.BLOCK_END||1!=u.transitions.length||!u.transitions[0].isEpsilon||u.transitions[0].target!=e)))return!1}return!0},I.prototype.getRuleName=function(t){return null!==this.parser&&t>=0?this.parser.ruleNames[t]:"<rule "+t+">"},I.prototype.getEpsilonTarget=function(t,e,n,r,i,o){switch(e.serializationType){case S.RULE:return this.ruleTransition(t,e);case S.PRECEDENCE:return this.precedenceTransition(t,e,n,r,i);case S.PREDICATE:return this.predTransition(t,e,n,r,i);case S.ACTION:return this.actionTransition(t,e);case S.EPSILON:return new u({state:e.target},t);case S.ATOM:case S.RANGE:case S.SET:return o&&e.matches(h.EOF,0,1)?new u({state:e.target},t):null;default:return null}},I.prototype.actionTransition=function(t,e){if(this.debug){var n=-1==e.actionIndex?65535:e.actionIndex;console.log("ACTION edge "+e.ruleIndex+":"+n)}return new u({state:e.target},t)},I.prototype.precedenceTransition=function(t,e,n,i,o){this.debug&&(console.log("PRED (collectPredicates="+n+") "+e.precedence+">=_p, ctx dependent=true"),null!==this.parser&&console.log("context surrounding pred is "+r.arrayToString(this.parser.getRuleInvocationStack())));var s=null;if(n&&i)if(o){var a=this._input.index;this._input.seek(this._startIndex);var l=e.getPredicate().evaluate(this.parser,this._outerContext);this._input.seek(a),l&&(s=new u({state:e.target},t))}else{var c=v.andContext(t.semanticContext,e.getPredicate());s=new u({state:e.target,semanticContext:c},t)}else s=new u({state:e.target},t);return this.debug&&console.log("config from pred transition="+s),s},I.prototype.predTransition=function(t,e,n,i,o){this.debug&&(console.log("PRED (collectPredicates="+n+") "+e.ruleIndex+":"+e.predIndex+", ctx dependent="+e.isCtxDependent),null!==this.parser&&console.log("context surrounding pred is "+r.arrayToString(this.parser.getRuleInvocationStack())));var s=null;if(n&&(e.isCtxDependent&&i||!e.isCtxDependent))if(o){var a=this._input.index;this._input.seek(this._startIndex);var l=e.getPredicate().evaluate(this.parser,this._outerContext);this._input.seek(a),l&&(s=new u({state:e.target},t))}else{var c=v.andContext(t.semanticContext,e.getPredicate());s=new u({state:e.target,semanticContext:c},t)}else s=new u({state:e.target},t);return this.debug&&console.log("config from pred transition="+s),s},I.prototype.ruleTransition=function(t,e){this.debug&&console.log("CALL rule "+this.getRuleName(e.target.ruleIndex)+", ctx="+t.context);var n=e.followState,r=R.create(t.context,n.stateNumber);return new u({state:e.target,context:r},t)},I.prototype.getConflictingAlts=function(t){var e=y.getConflictingAltSubsets(t);return y.getAlts(e)},I.prototype.getConflictingAltsOrUniqueAlt=function(t){var e=null;return t.uniqueAlt!==a.INVALID_ALT_NUMBER?(e=new o).add(t.uniqueAlt):e=t.conflictingAlts,e},I.prototype.getTokenName=function(t){if(t===h.EOF)return"EOF";if(null!==this.parser&&null!==this.parser.literalNames){if(!(t>=this.parser.literalNames.length&&t>=this.parser.symbolicNames.length))return(this.parser.literalNames[t]||this.parser.symbolicNames[t])+"<"+t+">";console.log(t+" ttype out of range: "+this.parser.literalNames),console.log(""+this.parser.getInputStream().getTokens())}return""+t},I.prototype.getLookaheadName=function(t){return this.getTokenName(t.LA(1))},I.prototype.dumpDeadEndConfigs=function(t){console.log("dead end configs: ");for(var e=t.getDeadEndConfigs(),n=0;n<e.length;n++){var r=e[n],i="no edges";if(r.state.transitions.length>0){var o=r.state.transitions[0];if(o instanceof AtomTransition)i="Atom "+this.getTokenName(o.label);else if(o instanceof E){i=(o instanceof C?"~":"")+"Set "+o.set}}console.error(r.toString(this.parser,!0)+":"+i)}},I.prototype.noViableAlt=function(t,e,n,r){return new k(this.parser,t,t.get(r),t.LT(1),n,e)},I.prototype.getUniqueAlt=function(t){for(var e=a.INVALID_ALT_NUMBER,n=0;n<t.items.length;n++){var r=t.items[n];if(e===a.INVALID_ALT_NUMBER)e=r.alt;else if(r.alt!==e)return a.INVALID_ALT_NUMBER}return e},I.prototype.addDFAEdge=function(t,e,n,r){if(this.debug&&console.log("EDGE "+e+" -> "+r+" upon "+this.getTokenName(n)),null===r)return null;if(r=this.addDFAState(t,r),null===e||n<-1||n>this.atn.maxTokenType)return r;if(null===e.edges&&(e.edges=[]),e.edges[n+1]=r,this.debug){var i=null===this.parser?null:this.parser.literalNames,o=null===this.parser?null:this.parser.symbolicNames;console.log("DFA=\n"+t.toString(i,o))}return r},I.prototype.addDFAState=function(t,e){if(e==d.ERROR)return e;var n=t.states.get(e);return null!==n?n:(e.stateNumber=t.states.length,e.configs.readOnly||(e.configs.optimizeConfigs(this),e.configs.setReadonly(!0)),t.states.add(e),this.debug&&console.log("adding new DFA state: "+e),e)},I.prototype.reportAttemptingFullContext=function(t,e,n,r,i){if(this.debug||this.retry_debug){var o=new _(r,i+1);console.log("reportAttemptingFullContext decision="+t.decision+":"+n+", input="+this.parser.getTokenStream().getText(o))}null!==this.parser&&this.parser.getErrorListenerDispatch().reportAttemptingFullContext(this.parser,t,r,i,e,n)},I.prototype.reportContextSensitivity=function(t,e,n,r,i){if(this.debug||this.retry_debug){var o=new _(r,i+1);console.log("reportContextSensitivity decision="+t.decision+":"+n+", input="+this.parser.getTokenStream().getText(o))}null!==this.parser&&this.parser.getErrorListenerDispatch().reportContextSensitivity(this.parser,t,r,i,e,n)},I.prototype.reportAmbiguity=function(t,e,n,r,i,o,s){if(this.debug||this.retry_debug){var a=new _(n,r+1);console.log("reportAmbiguity "+o+":"+s+", input="+this.parser.getTokenStream().getText(a))}null!==this.parser&&this.parser.getErrorListenerDispatch().reportAmbiguity(this.parser,t,n,r,i,o,s)},e.ParserATNSimulator=I},function(t,e,n){e.DFA=n(42).DFA,e.DFASerializer=n(17).DFASerializer,e.LexerDFASerializer=n(17).LexerDFASerializer,e.PredPrediction=n(11).PredPrediction},function(t,e,n){var r=n(0).Set,i=n(11).DFAState,o=n(3).StarLoopEntryState,s=n(9).ATNConfigSet,a=n(17).DFASerializer,l=n(17).LexerDFASerializer;function u(t,e){if(void 0===e&&(e=0),this.atnStartState=t,this.decision=e,this._states=new r,this.s0=null,this.precedenceDfa=!1,t instanceof o&&t.isPrecedenceDecision){this.precedenceDfa=!0;var n=new i(null,new s);n.edges=[],n.isAcceptState=!1,n.requiresFullContext=!1,this.s0=n}return this}u.prototype.getPrecedenceStartState=function(t){if(!this.precedenceDfa)throw"Only precedence DFAs may contain a precedence start state.";return t<0||t>=this.s0.edges.length?null:this.s0.edges[t]||null},u.prototype.setPrecedenceStartState=function(t,e){if(!this.precedenceDfa)throw"Only precedence DFAs may contain a precedence start state.";t<0||(this.s0.edges[t]=e)},u.prototype.setPrecedenceDfa=function(t){if(this.precedenceDfa!==t){if(this._states=new DFAStatesSet,t){var e=new i(null,new s);e.edges=[],e.isAcceptState=!1,e.requiresFullContext=!1,this.s0=e}else this.s0=null;this.precedenceDfa=t}},Object.defineProperty(u.prototype,"states",{get:function(){return this._states}}),u.prototype.sortedStates=function(){return this._states.values().sort(function(t,e){return t.stateNumber-e.stateNumber})},u.prototype.toString=function(t,e){return t=t||null,e=e||null,null===this.s0?"":new a(this,t,e).toString()},u.prototype.toLexerString=function(){return null===this.s0?"":new l(this).toString()},e.DFA=u},function(t,e,n){var r=n(4);e.Trees=n(21).Trees,e.RuleNode=r.RuleNode,e.ParseTreeListener=r.ParseTreeListener,e.ParseTreeVisitor=r.ParseTreeVisitor,e.ParseTreeWalker=r.ParseTreeWalker},function(t,e,n){e.RecognitionException=n(5).RecognitionException,e.NoViableAltException=n(5).NoViableAltException,e.LexerNoViableAltException=n(5).LexerNoViableAltException,e.InputMismatchException=n(5).InputMismatchException,e.FailedPredicateException=n(5).FailedPredicateException,e.DiagnosticErrorListener=n(45).DiagnosticErrorListener,e.BailErrorStrategy=n(30).BailErrorStrategy,e.ErrorListener=n(16).ErrorListener},function(t,e,n){var r=n(0).BitSet,i=n(16).ErrorListener,o=n(2).Interval;function s(t){return i.call(this),t=t||!0,this.exactOnly=t,this}s.prototype=Object.create(i.prototype),s.prototype.constructor=s,s.prototype.reportAmbiguity=function(t,e,n,r,i,s,a){if(!this.exactOnly||i){var l="reportAmbiguity d="+this.getDecisionDescription(t,e)+": ambigAlts="+this.getConflictingAlts(s,a)+", input='"+t.getTokenStream().getText(new o(n,r))+"'";t.notifyErrorListeners(l)}},s.prototype.reportAttemptingFullContext=function(t,e,n,r,i,s){var a="reportAttemptingFullContext d="+this.getDecisionDescription(t,e)+", input='"+t.getTokenStream().getText(new o(n,r))+"'";t.notifyErrorListeners(a)},s.prototype.reportContextSensitivity=function(t,e,n,r,i,s){var a="reportContextSensitivity d="+this.getDecisionDescription(t,e)+", input='"+t.getTokenStream().getText(new o(n,r))+"'";t.notifyErrorListeners(a)},s.prototype.getDecisionDescription=function(t,e){var n=e.decision,r=e.atnStartState.ruleIndex,i=t.ruleNames;if(r<0||r>=i.length)return""+n;var o=i[r]||null;return null===o||0===o.length?""+n:n+" ("+o+")"},s.prototype.getConflictingAlts=function(t,e){if(null!==t)return t;for(var n=new r,i=0;i<e.items.length;i++)n.add(e.items[i].alt);return"{"+n.values().join(", ")+"}"},e.DiagnosticErrorListener=s},function(t,e,n){var r=n(19).InputStream,i="undefined"==typeof window&&"undefined"==typeof importScripts?n(31):null,o={fromString:function(t){return new r(t,!0)},fromBlob:function(t,e,n,i){var o=FileReader();o.onload=function(t){var e=new r(t.target.result,!0);n(e)},o.onerror=i,o.readAsText(t,e)},fromBuffer:function(t,e){return new r(t.toString(e),!0)},fromPath:function(t,e,n){i.readFile(t,e,function(t,e){var i=null;null!==e&&(i=new r(e,!0)),n(t,i)})},fromPathSync:function(t,e){var n=i.readFileSync(t,e);return new r(n,!0)}};e.CharStreams=o},function(t,e,n){var r=n(19).InputStream,i="undefined"==typeof window&&"undefined"==typeof importScripts?n(31):null;function o(t,e){var n=i.readFileSync(t,"utf8");return r.call(this,n,e),this.fileName=t,this}o.prototype=Object.create(r.prototype),o.prototype.constructor=o,e.FileStream=o},function(t,e,n){var r=n(1).Token,i=n(49).BufferedTokenStream;function o(t,e){return i.call(this,t),this.channel=void 0===e?r.DEFAULT_CHANNEL:e,this}o.prototype=Object.create(i.prototype),o.prototype.constructor=o,o.prototype.adjustSeekIndex=function(t){return this.nextTokenOnChannel(t,this.channel)},o.prototype.LB=function(t){if(0===t||this.index-t<0)return null;for(var e=this.index,n=1;n<=t;)e=this.previousTokenOnChannel(e-1,this.channel),n+=1;return e<0?null:this.tokens[e]},o.prototype.LT=function(t){if(this.lazyInit(),0===t)return null;if(t<0)return this.LB(-t);for(var e=this.index,n=1;n<t;)this.sync(e+1)&&(e=this.nextTokenOnChannel(e+1,this.channel)),n+=1;return this.tokens[e]},o.prototype.getNumberOfOnChannelTokens=function(){var t=0;this.fill();for(var e=0;e<this.tokens.length;e++){var n=this.tokens[e];if(n.channel===this.channel&&(t+=1),n.type===r.EOF)break}return t},e.CommonTokenStream=o},function(t,e,n){var r=n(1).Token,i=n(15).Lexer,o=n(2).Interval;function s(){return this}function a(t){return s.call(this),this.tokenSource=t,this.tokens=[],this.index=-1,this.fetchedEOF=!1,this}a.prototype=Object.create(s.prototype),a.prototype.constructor=a,a.prototype.mark=function(){return 0},a.prototype.release=function(t){},a.prototype.reset=function(){this.seek(0)},a.prototype.seek=function(t){this.lazyInit(),this.index=this.adjustSeekIndex(t)},a.prototype.get=function(t){return this.lazyInit(),this.tokens[t]},a.prototype.consume=function(){if(!(this.index>=0&&(this.fetchedEOF?this.index<this.tokens.length-1:this.index<this.tokens.length))&&this.LA(1)===r.EOF)throw"cannot consume EOF";this.sync(this.index+1)&&(this.index=this.adjustSeekIndex(this.index+1))},a.prototype.sync=function(t){var e=t-this.tokens.length+1;return!(e>0)||this.fetch(e)>=e},a.prototype.fetch=function(t){if(this.fetchedEOF)return 0;for(var e=0;e<t;e++){var n=this.tokenSource.nextToken();if(n.tokenIndex=this.tokens.length,this.tokens.push(n),n.type===r.EOF)return this.fetchedEOF=!0,e+1}return t},a.prototype.getTokens=function(t,e,n){if(void 0===n&&(n=null),t<0||e<0)return null;this.lazyInit();var i=[];e>=this.tokens.length&&(e=this.tokens.length-1);for(var o=t;o<e;o++){var s=this.tokens[o];if(s.type===r.EOF)break;(null===n||n.contains(s.type))&&i.push(s)}return i},a.prototype.LA=function(t){return this.LT(t).type},a.prototype.LB=function(t){return this.index-t<0?null:this.tokens[this.index-t]},a.prototype.LT=function(t){if(this.lazyInit(),0===t)return null;if(t<0)return this.LB(-t);var e=this.index+t-1;return this.sync(e),e>=this.tokens.length?this.tokens[this.tokens.length-1]:this.tokens[e]},a.prototype.adjustSeekIndex=function(t){return t},a.prototype.lazyInit=function(){-1===this.index&&this.setup()},a.prototype.setup=function(){this.sync(0),this.index=this.adjustSeekIndex(0)},a.prototype.setTokenSource=function(t){this.tokenSource=t,this.tokens=[],this.index=-1,this.fetchedEOF=!1},a.prototype.nextTokenOnChannel=function(t,e){if(this.sync(t),t>=this.tokens.length)return-1;for(var n=this.tokens[t];n.channel!==this.channel;){if(n.type===r.EOF)return-1;t+=1,this.sync(t),n=this.tokens[t]}return t},a.prototype.previousTokenOnChannel=function(t,e){for(;t>=0&&this.tokens[t].channel!==e;)t-=1;return t},a.prototype.getHiddenTokensToRight=function(t,e){if(void 0===e&&(e=-1),this.lazyInit(),t<0||t>=this.tokens.length)throw t+" not in 0.."+this.tokens.length-1;var n=this.nextTokenOnChannel(t+1,i.DEFAULT_TOKEN_CHANNEL),r=t+1,o=-1===n?this.tokens.length-1:n;return this.filterForChannel(r,o,e)},a.prototype.getHiddenTokensToLeft=function(t,e){if(void 0===e&&(e=-1),this.lazyInit(),t<0||t>=this.tokens.length)throw t+" not in 0.."+this.tokens.length-1;var n=this.previousTokenOnChannel(t-1,i.DEFAULT_TOKEN_CHANNEL);if(n===t-1)return null;var r=n+1,o=t-1;return this.filterForChannel(r,o,e)},a.prototype.filterForChannel=function(t,e,n){for(var r=[],o=t;o<e+1;o++){var s=this.tokens[o];-1===n?s.channel!==i.DEFAULT_TOKEN_CHANNEL&&r.push(s):s.channel===n&&r.push(s)}return 0===r.length?null:r},a.prototype.getSourceName=function(){return this.tokenSource.getSourceName()},a.prototype.getText=function(t){this.lazyInit(),this.fill(),void 0!==t&&null!==t||(t=new o(0,this.tokens.length-1));var e=t.start;e instanceof r&&(e=e.tokenIndex);var n=t.stop;if(n instanceof r&&(n=n.tokenIndex),null===e||null===n||e<0||n<0)return"";n>=this.tokens.length&&(n=this.tokens.length-1);for(var i="",s=e;s<n+1;s++){var a=this.tokens[s];if(a.type===r.EOF)break;i+=a.text}return i},a.prototype.fill=function(){for(this.lazyInit();1e3===this.fetch(1e3););},e.BufferedTokenStream=a},function(t,e,n){var r=n(1).Token,i=n(4).ParseTreeListener,o=n(25).Recognizer,s=n(30).DefaultErrorStrategy,a=n(22).ATNDeserializer,l=n(23).ATNDeserializationOptions,u=n(4).TerminalNode,c=n(4).ErrorNode;function h(t){return i.call(this),this.parser=t,this}function p(t){return o.call(this),this._input=null,this._errHandler=new s,this._precedenceStack=[],this._precedenceStack.push(0),this._ctx=null,this.buildParseTrees=!0,this._tracer=null,this._parseListeners=null,this._syntaxErrors=0,this.setInputStream(t),this}h.prototype=Object.create(i.prototype),h.prototype.constructor=h,h.prototype.enterEveryRule=function(t){console.log("enter   "+this.parser.ruleNames[t.ruleIndex]+", LT(1)="+this.parser._input.LT(1).text)},h.prototype.visitTerminal=function(t){console.log("consume "+t.symbol+" rule "+this.parser.ruleNames[this.parser._ctx.ruleIndex])},h.prototype.exitEveryRule=function(t){console.log("exit    "+this.parser.ruleNames[t.ruleIndex]+", LT(1)="+this.parser._input.LT(1).text)},p.prototype=Object.create(o.prototype),p.prototype.contructor=p,p.bypassAltsAtnCache={},p.prototype.reset=function(){null!==this._input&&this._input.seek(0),this._errHandler.reset(this),this._ctx=null,this._syntaxErrors=0,this.setTrace(!1),this._precedenceStack=[],this._precedenceStack.push(0),null!==this._interp&&this._interp.reset()},p.prototype.match=function(t){var e=this.getCurrentToken();return e.type===t?(this._errHandler.reportMatch(this),this.consume()):(e=this._errHandler.recoverInline(this),this.buildParseTrees&&-1===e.tokenIndex&&this._ctx.addErrorNode(e)),e},p.prototype.matchWildcard=function(){var t=this.getCurrentToken();return t.type>0?(this._errHandler.reportMatch(this),this.consume()):(t=this._errHandler.recoverInline(this),this._buildParseTrees&&-1===t.tokenIndex&&this._ctx.addErrorNode(t)),t},p.prototype.getParseListeners=function(){return this._parseListeners||[]},p.prototype.addParseListener=function(t){if(null===t)throw"listener";null===this._parseListeners&&(this._parseListeners=[]),this._parseListeners.push(t)},p.prototype.removeParseListener=function(t){if(null!==this._parseListeners){var e=this._parseListeners.indexOf(t);e>=0&&this._parseListeners.splice(e,1),0===this._parseListeners.length&&(this._parseListeners=null)}},p.prototype.removeParseListeners=function(){this._parseListeners=null},p.prototype.triggerEnterRuleEvent=function(){if(null!==this._parseListeners){var t=this._ctx;this._parseListeners.map(function(e){e.enterEveryRule(t),t.enterRule(e)})}},p.prototype.triggerExitRuleEvent=function(){if(null!==this._parseListeners){var t=this._ctx;this._parseListeners.slice(0).reverse().map(function(e){t.exitRule(e),e.exitEveryRule(t)})}},p.prototype.getTokenFactory=function(){return this._input.tokenSource._factory},p.prototype.setTokenFactory=function(t){this._input.tokenSource._factory=t},p.prototype.getATNWithBypassAlts=function(){var t=this.getSerializedATN();if(null===t)throw"The current parser does not support an ATN with bypass alternatives.";var e=this.bypassAltsAtnCache[t];if(null===e){var n=new l;n.generateRuleBypassTransitions=!0,e=new a(n).deserialize(t),this.bypassAltsAtnCache[t]=e}return e};var f=n(15).Lexer;p.prototype.compileParseTreePattern=function(t,e,n){if(null===(n=n||null)&&null!==this.getTokenStream()){var r=this.getTokenStream().tokenSource;r instanceof f&&(n=r)}if(null===n)throw"Parser can't discover a lexer to use";return new ParseTreePatternMatcher(n,this).compile(t,e)},p.prototype.getInputStream=function(){return this.getTokenStream()},p.prototype.setInputStream=function(t){this.setTokenStream(t)},p.prototype.getTokenStream=function(){return this._input},p.prototype.setTokenStream=function(t){this._input=null,this.reset(),this._input=t},p.prototype.getCurrentToken=function(){return this._input.LT(1)},p.prototype.notifyErrorListeners=function(t,e,n){e=e||null,n=n||null,null===e&&(e=this.getCurrentToken()),this._syntaxErrors+=1;var r=e.line,i=e.column;this.getErrorListenerDispatch().syntaxError(this,e,r,i,t,n)},p.prototype.consume=function(){var t=this.getCurrentToken();t.type!==r.EOF&&this.getInputStream().consume();var e,n=null!==this._parseListeners&&this._parseListeners.length>0;(this.buildParseTrees||n)&&((e=this._errHandler.inErrorRecoveryMode(this)?this._ctx.addErrorNode(t):this._ctx.addTokenNode(t)).invokingState=this.state,n&&this._parseListeners.map(function(t){e instanceof c||void 0!==e.isErrorNode&&e.isErrorNode()?t.visitErrorNode(e):e instanceof u&&t.visitTerminal(e)}));return t},p.prototype.addContextToParseTree=function(){null!==this._ctx.parentCtx&&this._ctx.parentCtx.addChild(this._ctx)},p.prototype.enterRule=function(t,e,n){this.state=e,this._ctx=t,this._ctx.start=this._input.LT(1),this.buildParseTrees&&this.addContextToParseTree(),null!==this._parseListeners&&this.triggerEnterRuleEvent()},p.prototype.exitRule=function(){this._ctx.stop=this._input.LT(-1),null!==this._parseListeners&&this.triggerExitRuleEvent(),this.state=this._ctx.invokingState,this._ctx=this._ctx.parentCtx},p.prototype.enterOuterAlt=function(t,e){t.setAltNumber(e),this.buildParseTrees&&this._ctx!==t&&null!==this._ctx.parentCtx&&(this._ctx.parentCtx.removeLastChild(),this._ctx.parentCtx.addChild(t)),this._ctx=t},p.prototype.getPrecedence=function(){return 0===this._precedenceStack.length?-1:this._precedenceStack[this._precedenceStack.length-1]},p.prototype.enterRecursionRule=function(t,e,n,r){this.state=e,this._precedenceStack.push(r),this._ctx=t,this._ctx.start=this._input.LT(1),null!==this._parseListeners&&this.triggerEnterRuleEvent()},p.prototype.pushNewRecursionContext=function(t,e,n){var r=this._ctx;r.parentCtx=t,r.invokingState=e,r.stop=this._input.LT(-1),this._ctx=t,this._ctx.start=r.start,this.buildParseTrees&&this._ctx.addChild(r),null!==this._parseListeners&&this.triggerEnterRuleEvent()},p.prototype.unrollRecursionContexts=function(t){this._precedenceStack.pop(),this._ctx.stop=this._input.LT(-1);var e=this._ctx;if(null!==this._parseListeners)for(;this._ctx!==t;)this.triggerExitRuleEvent(),this._ctx=this._ctx.parentCtx;else this._ctx=t;e.parentCtx=t,this.buildParseTrees&&null!==t&&t.addChild(e)},p.prototype.getInvokingContext=function(t){for(var e=this._ctx;null!==e;){if(e.ruleIndex===t)return e;e=e.parentCtx}return null},p.prototype.precpred=function(t,e){return e>=this._precedenceStack[this._precedenceStack.length-1]},p.prototype.inContext=function(t){return!1},p.prototype.isExpectedToken=function(t){var e=this._interp.atn,n=this._ctx,i=e.states[this.state],o=e.nextTokens(i);if(o.contains(t))return!0;if(!o.contains(r.EPSILON))return!1;for(;null!==n&&n.invokingState>=0&&o.contains(r.EPSILON);){var s=e.states[n.invokingState].transitions[0];if((o=e.nextTokens(s.followState)).contains(t))return!0;n=n.parentCtx}return!(!o.contains(r.EPSILON)||t!==r.EOF)},p.prototype.getExpectedTokens=function(){return this._interp.atn.getExpectedTokens(this.state,this._ctx)},p.prototype.getExpectedTokensWithinCurrentRule=function(){var t=this._interp.atn,e=t.states[this.state];return t.nextTokens(e)},p.prototype.getRuleIndex=function(t){var e=this.getRuleIndexMap()[t];return null!==e?e:-1},p.prototype.getRuleInvocationStack=function(t){null===(t=t||null)&&(t=this._ctx);for(var e=[];null!==t;){var n=t.ruleIndex;n<0?e.push("n/a"):e.push(this.ruleNames[n]),t=t.parentCtx}return e},p.prototype.getDFAStrings=function(){return this._interp.decisionToDFA.toString()},p.prototype.dumpDFA=function(){for(var t=!1,e=0;e<this._interp.decisionToDFA.length;e++){var n=this._interp.decisionToDFA[e];n.states.length>0&&(t&&console.log(),this.printer.println("Decision "+n.decision+":"),this.printer.print(n.toString(this.literalNames,this.symbolicNames)),t=!0)}},p.prototype.getSourceName=function(){return this._input.sourceName},p.prototype.setTrace=function(t){t?(null!==this._tracer&&this.removeParseListener(this._tracer),this._tracer=new h(this),this.addParseListener(this._tracer)):(this.removeParseListener(this._tracer),this._tracer=null)},e.Parser=p},function(t,e,n){var r=n(12),i=["悋Ꜫ脳맭䅼㯧瞆奤","ŝ\b
\t\t","\t\t\t\t","\b\t\b\t\t\t\n\t\n\v\t\v","\f\t\f\r\t\r\t\t","\t\t\t\t","\t\t\t","\t\t\t\t","\t\t\t","\t\t \t ","","","","","","","","","","","","","","\b\b\t\t\n\n","\v\v\v\v\v\v","\v\v\v\v\v\v","\v\v\v\v\v\v","\v\v\v\v\v\v","\v\v\v\v\v\v","\v\v\v\v\v\v","\v\v\v\v\v\v","\v\f\f\r\r","","Ó\n\fÖ","\v","Ü\n\fß\v","ã\n\fæ\v","ê\n","ï\n\fò","\v","ù\n","þ\n\fā\v","Ĉ\n","","","ę\n","Ĝ\n","ġ\n\rĢ","","ī\n\fĮ\v","","","Ŀ\n\fł","\v","Ō\n\f","ŏ\v ","    ŗ\n \f  Ś\v  "," ÔĬŀ!","\t\v\r\b\t\n\v\f\r","!#%","')+-/13579",";=?__C\\","2;C\\aac|c|$$^^\n$$11^^dd","hhppttvv))^^\n))11^^ddhhppttvv2;CHch",'\v\v""\f\f==~~',"ũ","\t","\v\r","","","","","!","#%","35","79;","=?","AI","K\t„","\v†\rˆ","“•","—™","ÄÆ","ÈÊ","Ì!Ù","#à%é'ë",")õ+ú","-Ą/ĉ","1ď3đ","5ě7Ġ","9Ħ;Ĵ=Ň","?ŒABi","BCtCDcDEo","EFoFGcGHtH","IJ=J","KLuLMvMNc","NOvOPGPQzQR","rRStSTUTUr","UVnVWkWXv",'XY"YZ<Z["[\\',")\\]?]^?^_",'?_`"`auabv',"bcccdvdeg","efofggghphi",'vij"jk`kl"',"lm?mn?no?",'op"pqgqrzrs',"rstttuguvu","vwuwxkxyq",'yzpz{"{|x|}','"}~?~?',"€?€)‚",'"‚ƒ=ƒ\b',"„…<…\n","†‡~‡\f","ˆ‰g‰ŠzŠ","‹r‹ŒtŒ","gŽuŽ","uk‘q","‘’p’","“”A”","•–-–","—˜,˜","™šOš›g","›œcœp","žkžŸpŸ ","i ¡h¡¢","w¢£n£¤U","¤¥r¥¦n","¦§k§¨v¨",'©"©ª<ª«','"«¬)¬­',"?­®?®¯?",'¯°"°±o',"±²g²³c³","´p´µkµ¶","p¶·i·¸","h¸¹w¹ºn",'º»"»¼`','¼½"½¾?¾',"¿?¿À?ÀÁ",')ÁÂ"ÂÃ',"=ÃÄÅ","*ÅÆÇ","+ÇÈÉ","€ÉÊË","0ËÌÔ","]ÍÎ^ÎÓ^","ÏÐ^ÐÓ_","ÑÓ\nÒÍ","ÒÏÒÑ","ÓÖÔÕ","ÔÒÕ×","ÖÔ×Ø_","Ø ÙÝ\tÚ","Ü\tÛÚÜ","ßÝÛÝ",'ÞÞ"ß',"Ýàä\tá","ã\tâáã","æäâä","åå$æ","äçê+è","ê'éçé","èê&ë","ð$ìï)íï","\nîìîí","ïòðî","ðññó","òðóô","$ô(õø","^öù\t÷ù/","øöø÷","ù*úÿ)","ûþ-üþ\n\býû","ýüþā","ÿýÿĀ","ĀĂāÿ","Ăă)ă,","Ąć^ąĈ\t\t","ĆĈ/ćą","ćĆĈ.","ĉĊwĊċ1","ċČ1Čč1č","Ď1Ď0ďĐ","\t\nĐ2đĒ%","Ēē!ēĔ","Ĕĕ\bĕ4","ĖĘėę\f","ĘėĘę","ęĜĚĜ\f","ěĖěĚ","ĜĝĝĞ\b","Ğ6ğġ\t\vĠ","ğġĢĢ","ĠĢģģ","ĤĤĥ\bĥ","8Ħħ1ħĨ",",ĨĬĩī","\vĪĩīĮ","ĬĭĬĪ","ĭįĮĬ","įİ,İı","1ıIJIJij","\bij:Ĵĵ","hĵĶtĶķc","ķĸiĸĹo","ĹĺgĺĻpĻ","ļvļŀĽ","Ŀ\vľĽĿ","łŀŁŀ","ľŁŃł","ŀŃń=ń","ŅŅņ\bņ","<Ňň1ňʼn","1ʼnōŊŌ","\n\fŋŊŌŏ","ōŋōŎ","ŎŐŏō","Őő\bő>","Œœ/œŔ@","ŔŘŕŗ\n\r","ŖŕŗŚ","ŘŖŘř","řśŚŘ","śŜ\b Ŝ@","ÒÔÝäéîðøýÿćĘ","ěĢĬŀōŘ\b"].join(""),o=(new r.atn.ATNDeserializer).deserialize(i),s=o.decisionToState.map(function(t,e){return new r.dfa.DFA(t,e)});function a(t){return r.Lexer.call(this,t),this._interp=new r.atn.LexerATNSimulator(this,o,s,new r.PredictionContextCache),this}a.prototype=Object.create(r.Lexer.prototype),a.prototype.constructor=a,a.EOF=r.Token.EOF,a.T__0=1,a.T__1=2,a.T__2=3,a.T__3=4,a.T__4=5,a.T__5=6,a.T__6=7,a.T__7=8,a.T__8=9,a.T__9=10,a.T__10=11,a.T__11=12,a.T__12=13,a.T__13=14,a.Brackets=15,a.LexerIdentifier=16,a.ParserIdentifier=17,a.String=18,a.LabelForParserRule=19,a.Newline=20,a.WhiteSpace=21,a.BlockComment=22,a.FragmentComment=23,a.LineComment=24,a.ArrowComment=25,a.prototype.channelNames=["DEFAULT_TOKEN_CHANNEL","HIDDEN"],a.prototype.modeNames=["DEFAULT_MODE"],a.prototype.literalNames=[null,"'grammar'","';'","'statExprSplit : '=== statement ^ === expression v ===' ;'","':'","'|'","'expression'","'?'","'+'","'*'","'MeaningfulSplit : '=== meaningful ^ ===' ;'","'('","')'","'~'","'.'"],a.prototype.symbolicNames=[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"Brackets","LexerIdentifier","ParserIdentifier","String","LabelForParserRule","Newline","WhiteSpace","BlockComment","FragmentComment","LineComment","ArrowComment"],a.prototype.ruleNames=["T__0","T__1","T__2","T__3","T__4","T__5","T__6","T__7","T__8","T__9","T__10","T__11","T__12","T__13","Brackets","LexerIdentifier","ParserIdentifier","String","STRING_double","ESC_double","STRING_single","ESC_single","UNICODE","HEX","LabelForParserRule","Newline","WhiteSpace","BlockComment","FragmentComment","LineComment","ArrowComment"],a.prototype.grammarFileName="BlocklyGrammer.g4",e.BlocklyGrammerLexer=a},function(t,e,n){var r=n(12),i=n(20).BlocklyGrammerVisitor,o=["悋Ꜫ脳맭䅼㯧瞆奤","Õ\t\t","\t\t\t\t","\b\t\b\t\t\t\n\t\n\v\t\v\f\t\f","\r\t\r\n\f"," \v$\n","\f'\v","","","8\n\r9","@\n\fC\v","F\n","L\n","Q\nS\n\fV\v","\\","\n\f_\vb\n","f\n\f","i\v\b\b\b\bn\n\b\bp\n\b","\b\b\b\bu\n\b\bw\n\b\b\b\b","\b|\n\b\b~\n\b\b\b\b\bƒ\n\b","\b…\n\b\b‡\n\b\t\tŠ\n\t\f\t","\t\v\t\n\n\v\v\v","\v\v\v\v\v\v","\v\v›\n\v\r\v\vœ","\v\v\v\v\v\v","\v\v¦\n\v\f\f\f\f«","\n\f\f­\n\f\f¯\n\f\r\f\f°\r","\r\r\r\r\r\r\r\r\r","\r\r\r\r\r\rÂ\n\r\r\r","\r\r\r\r\r\r\r\r","\rÎ\n\r\rÐ\n\r\f\r\rÓ\v\r\r","%‹\b\n\f","\t\v","\n\vð,","0\bE","\na\fc†","‹Ž","¥®","Á","\b"," ","!"," !%",'"$\n#"$\'',"%&%#","&('%()","\t)*\n*+\t+",",--../","/01","12334","4756","687589","979::;",";F<==A",">@\b?>@","CA?AB","BDCADF","E2E<F\t","GH\bHK","IL\fJLKI","KJLTMP","NQ\fOQPN","POQS","RMSVTR","TUUWVT","WbXYY]","Z\\\b[Z","\\_][]^","^`_]`b","aGaX","b\vcg\bdf","\bedfige","ghh\r","igjo\bkm\t","ln\tmlmn","npokop","p‡qv","rt\tsu\tts","tuuwvr","vww‡x}","y{\tz|\t{z","{||~","}y}~~‡","„€‚\t","ƒ\t‚","‚ƒƒ…","„€„…","…‡†j","†q†x","†‡","ˆŠ\v‰ˆ","Š‹Œ","‹‰Œ","‹Ž\f","‘","‘’’“\f","“””¦","•––—","—š\f˜™","™›\fš˜","›œœš","œž","žŸŸ¦"," ¡¡¢","¢£\r£¤","¤¦¥","¥•¥ ","¦§¬","¨ª\t©«\t","ª©ª«","«­¬¨","¬­­¯","®§¯°","°®°±","±²³\b\r
³","´\r´µ\rµ¶","¶Â·¸","¸Â\r\b¹Â","º»»¼","¼½½Â","¾Â¿Â","ÀÂÁ²","Á·Á¹","ÁºÁ¾","Á¿ÁÀ","ÂÑÃÄ\f","\vÄÅÅÐ","\r\fÆÇ\f\nÇÐ\r\v","ÈÉ\f\rÉÐ\tÊË","\f\fËÍ\tÌÎ\t","ÍÌÍÎ","ÎÐÏÃ","ÏÆÏÈ","ÏÊÐÓ","ÑÏÑÒ","ÒÓÑ"," %9AEKPT]agmotv{}‚„†‹œ¥","ª¬°ÁÍÏÑ"].join(""),s=(new r.atn.ATNDeserializer).deserialize(o),a=s.decisionToState.map(function(t,e){return new r.dfa.DFA(t,e)}),l=new r.PredictionContextCache,u=[null,"'grammar'","';'","'statExprSplit : '=== statement ^ === expression v ===' ;'","':'","'|'","'expression'","'?'","'+'","'*'","'MeaningfulSplit : '=== meaningful ^ ===' ;'","'('","')'","'~'","'.'"],c=[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"Brackets","LexerIdentifier","ParserIdentifier","String","LabelForParserRule","Newline","WhiteSpace","BlockComment","FragmentComment","LineComment","ArrowComment"],h=["grammarFile","grammerDecl","statExprSplit","statementRule","expressionRule","arithmeticRuleCollection","parserRuleAtom","lexerRuleCollection","meaningfulSplit","lexerRule","strings","lexerRuleExpr"];function p(t){return r.Parser.call(this,t),this._interp=new r.atn.ParserATNSimulator(this,s,a,l),this.ruleNames=h,this.literalNames=u,this.symbolicNames=c,this}function f(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_grammarFile,this}function d(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_grammerDecl,this}function y(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_statExprSplit,this}function g(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_statementRule,this}function v(t,e){return g.call(this,t),g.prototype.copyFrom.call(this,e),this}function x(t,e){return g.call(this,t),g.prototype.copyFrom.call(this,e),this}function m(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_expressionRule,this}function _(t,e){return m.call(this,t),m.prototype.copyFrom.call(this,e),this}function T(t,e){return m.call(this,t),m.prototype.copyFrom.call(this,e),this}function S(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_arithmeticRuleCollection,this}function E(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_parserRuleAtom,this}function C(t,e){return E.call(this,t),E.prototype.copyFrom.call(this,e),this}function A(t,e){return E.call(this,t),E.prototype.copyFrom.call(this,e),this}function b(t,e){return E.call(this,t),E.prototype.copyFrom.call(this,e),this}function k(t,e){return E.call(this,t),E.prototype.copyFrom.call(this,e),this}function R(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_lexerRuleCollection,this}function L(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_meaningfulSplit,this}function I(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_lexerRule,this}function N(t,e){return I.call(this,t),I.prototype.copyFrom.call(this,e),this}function O(t,e){return I.call(this,t),I.prototype.copyFrom.call(this,e),this}function P(t,e){return I.call(this,t),I.prototype.copyFrom.call(this,e),this}function w(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_strings,this}function F(t,e,n){return void 0===e&&(e=null),void 0!==n&&null!==n||(n=-1),r.ParserRuleContext.call(this,e,n),this.parser=t,this.ruleIndex=p.RULE_lexerRuleExpr,this}p.prototype=Object.create(r.Parser.prototype),p.prototype.constructor=p,Object.defineProperty(p.prototype,"atn",{get:function(){return s}}),p.EOF=r.Token.EOF,p.T__0=1,p.T__1=2,p.T__2=3,p.T__3=4,p.T__4=5,p.T__5=6,p.T__6=7,p.T__7=8,p.T__8=9,p.T__9=10,p.T__10=11,p.T__11=12,p.T__12=13,p.T__13=14,p.Brackets=15,p.LexerIdentifier=16,p.ParserIdentifier=17,p.String=18,p.LabelForParserRule=19,p.Newline=20,p.WhiteSpace=21,p.BlockComment=22,p.FragmentComment=23,p.LineComment=24,p.ArrowComment=25,p.RULE_grammarFile=0,p.RULE_grammerDecl=1,p.RULE_statExprSplit=2,p.RULE_statementRule=3,p.RULE_expressionRule=4,p.RULE_arithmeticRuleCollection=5,p.RULE_parserRuleAtom=6,p.RULE_lexerRuleCollection=7,p.RULE_meaningfulSplit=8,p.RULE_lexerRule=9,p.RULE_strings=10,p.RULE_lexerRuleExpr=11,f.prototype=Object.create(r.ParserRuleContext.prototype),f.prototype.constructor=f,f.prototype.grammerDecl=function(){return this.getTypedRuleContext(d,0)},f.prototype.statExprSplit=function(){return this.getTypedRuleContext(y,0)},f.prototype.lexerRuleCollection=function(t){return void 0===t&&(t=null),null===t?this.getTypedRuleContexts(R):this.getTypedRuleContext(R,t)},f.prototype.meaningfulSplit=function(){return this.getTypedRuleContext(L,0)},f.prototype.statementRule=function(t){return void 0===t&&(t=null),null===t?this.getTypedRuleContexts(g):this.getTypedRuleContext(g,t)},f.prototype.expressionRule=function(t){return void 0===t&&(t=null),null===t?this.getTypedRuleContexts(m):this.getTypedRuleContext(m,t)},f.prototype.accept=function(t){return t instanceof i?t.visitGrammarFile(this):t.visitChildren(this)},p.GrammarFileContext=f,p.prototype.grammarFile=function(){var t=new f(this,this._ctx,this.state);this.enterRule(t,0,p.RULE_grammarFile);try{this.enterOuterAlt(t,1),this.state=24,this.grammerDecl(),this.state=28,this._errHandler.sync(this);for(var e=this._interp.adaptivePredict(this._input,0,this._ctx);1!=e&&e!=r.atn.ATN.INVALID_ALT_NUMBER;)2===e&&(this.state=25,this.statementRule()),this.state=30,this._errHandler.sync(this),e=this._interp.adaptivePredict(this._input,0,this._ctx);this.state=31,this.statExprSplit(),this.state=35,this._errHandler.sync(this);for(e=this._interp.adaptivePredict(this._input,1,this._ctx);1!=e&&e!=r.atn.ATN.INVALID_ALT_NUMBER;)2===e&&(this.state=32,this.expressionRule()),this.state=37,this._errHandler.sync(this),e=this._interp.adaptivePredict(this._input,1,this._ctx);this.state=38,this.lexerRuleCollection(),this.state=39,this.meaningfulSplit(),this.state=40,this.lexerRuleCollection()}catch(e){if(!(e instanceof r.error.RecognitionException))throw e;t.exception=e,this._errHandler.reportError(this,e),this._errHandler.recover(this,e)}finally{this.exitRule()}return t},d.prototype=Object.create(r.ParserRuleContext.prototype),d.prototype.constructor=d,d.prototype.LexerIdentifier=function(){return this.getToken(p.LexerIdentifier,0)},d.prototype.accept=function(t){return t instanceof i?t.visitGrammerDecl(this):t.visitChildren(this)},p.GrammerDeclContext=d,p.prototype.grammerDecl=function(){var t=new d(this,this._ctx,this.state);this.enterRule(t,2,p.RULE_grammerDecl);try{this.enterOuterAlt(t,1),this.state=42,this.match(p.T__0),this.state=43,this.match(p.LexerIdentifier),this.state=44,this.match(p.T__1)}catch(e){if(!(e instanceof r.error.RecognitionException))throw e;t.exception=e,this._errHandler.reportError(this,e),this._errHandler.recover(this,e)}finally{this.exitRule()}return t},y.prototype=Object.create(r.ParserRuleContext.prototype),y.prototype.constructor=y,y.prototype.accept=function(t){return t instanceof i?t.visitStatExprSplit(this):t.visitChildren(this)},p.StatExprSplitContext=y,p.prototype.statExprSplit=function(){var t=new y(this,this._ctx,this.state);this.enterRule(t,4,p.RULE_statExprSplit);try{this.enterOuterAlt(t,1),this.state=46,this.match(p.T__2)}catch(e){if(!(e instanceof r.error.RecognitionException))throw e;t.exception=e,this._errHandler.reportError(this,e),this._errHandler.recover(this,e)}finally{this.exitRule()}return t},g.prototype=Object.create(r.ParserRuleContext.prototype),g.prototype.constructor=g,g.prototype.copyFrom=function(t){r.ParserRuleContext.prototype.copyFrom.call(this,t)},v.prototype=Object.create(g.prototype),v.prototype.constructor=v,p.StatValueContext=v,v.prototype.ParserIdentifier=function(){return this.getToken(p.ParserIdentifier,0)},v.prototype.parserRuleAtom=function(t){return void 0===t&&(t=null),null===t?this.getTypedRuleContexts(E):this.getTypedRuleContext(E,t)},v.prototype.accept=function(t){return t instanceof i?t.visitStatValue(this):t.visitChildren(this)},x.prototype=Object.create(g.prototype),x.prototype.constructor=x,p.StatListContext=x,x.prototype.ParserIdentifier=function(t){return void 0===t&&(t=null),null===t?this.getTokens(p.ParserIdentifier):this.getToken(p.ParserIdentifier,t)},x.prototype.accept=function(t){return t instanceof i?t.visitStatList(this):t.visitChildren(this)},p.StatementRuleContext=g,p.prototype.statementRule=function(){var t=new g(this,this._ctx,this.state);this.enterRule(t,6,p.RULE_statementRule);var e=0;try{switch(this.state=67,this._errHandler.sync(this),this._interp.adaptivePredict(this._input,4,this._ctx)){case 1:t=new x(this,t),this.enterOuterAlt(t,1),this.state=48,this.match(p.ParserIdentifier),this.state=49,this.match(p.T__3),this.state=50,this.match(p.ParserIdentifier),this.state=53,this._errHandler.sync(this),e=this._input.LA(1);do{this.state=51,this.match(p.T__4),this.state=52,this.match(p.ParserIdentifier),this.state=55,this._errHandler.sync(this),e=this._input.LA(1)}while(e===p.T__4);this.state=57,this.match(p.T__1);break;case 2:for(t=new v(this,t),this.enterOuterAlt(t,2),this.state=58,this.match(p.ParserIdentifier),this.state=59,this.match(p.T__3),this.state=63,this._errHandler.sync(this),e=this._input.LA(1);0==(-32&e)&&0!=(1<<e&(1<<p.T__5|1<<p.LexerIdentifier|1<<p.ParserIdentifier|1<<p.String));)this.state=60,this.parserRuleAtom(),this.state=65,this._errHandler.sync(this),e=this._input.LA(1);this.state=66,this.match(p.T__1)}}catch(e){if(!(e instanceof r.error.RecognitionException))throw e;t.exception=e,this._errHandler.reportError(this,e),this._errHandler.recover(this,e)}finally{this.exitRule()}return t},m.prototype=Object.create(r.ParserRuleContext.prototype),m.prototype.constructor=m,m.prototype.copyFrom=function(t){r.ParserRuleContext.prototype.copyFrom.call(this,t)},_.prototype=Object.create(m.prototype),_.prototype.constructor=_,p.ExprExpressionContext=_,_.prototype.arithmeticRuleCollection=function(t){return void 0===t&&(t=null),null===t?this.getTypedRuleContexts(S):this.getTypedRuleContext(S,t)},_.prototype.ParserIdentifier=function(t){return void 0===t&&(t=null),null===t?this.getTokens(p.ParserIdentifier):this.getToken(p.ParserIdentifier,t)},_.prototype.accept=function(t){return t instanceof i?t.visitExprExpression(this):t.visitChildren(this)},T.prototype=Object.create(m.prototype),T.prototype.constructor=T,p.ExprValueContext=T,T.prototype.ParserIdentifier=function(){return this.getToken(p.ParserIdentifier,0)},T.prototype.parserRuleAtom=function(t){return void 0===t&&(t=null),null===t?this.getTypedRuleContexts(E):this.getTypedRuleContext(E,t)},T.prototype.accept=function(t){return t instanceof i?t.visitExprValue(this):t.visitChildren(this)},p.ExpressionRuleContext=m,p.prototype.expressionRule=function(){var t=new m(this,this._ctx,this.state);this.enterRule(t,8,p.RULE_expressionRule);var e=0;try{switch(this.state=95,this._errHandler.sync(this),this._input.LA(1)){case p.T__5:switch(t=new _(this,t),this.enterOuterAlt(t,1),this.state=69,this.match(p.T__5),this.state=70,this.match(p.T__3),this.state=73,this._errHandler.sync(this),this._input.LA(1)){case p.T__5:this.state=71,this.arithmeticRuleCollection();break;case p.ParserIdentifier:this.state=72,this.match(p.ParserIdentifier);break;default:throw new r.error.NoViableAltException(this)}for(this.state=82,this._errHandler.sync(this),e=this._input.LA(1);e===p.T__4;){switch(this.state=75,this.match(p.T__4),this.state=78,this._errHandler.sync(this),this._input.LA(1)){case p.T__5:this.state=76,this.arithmeticRuleCollection();break;case p.ParserIdentifier:this.state=77,this.match(p.ParserIdentifier);break;default:throw new r.error.NoViableAltException(this)}this.state=84,this._errHandler.sync(this),e=this._input.LA(1)}this.state=85,this.match(p.T__1);break;case p.ParserIdentifier:for(t=new T(this,t),this.enterOuterAlt(t,2),this.state=86,this.match(p.ParserIdentifier),this.state=87,this.match(p.T__3),this.state=91,this._errHandler.sync(this),e=this._input.LA(1);0==(-32&e)&&0!=(1<<e&(1<<p.T__5|1<<p.LexerIdentifier|1<<p.ParserIdentifier|1<<p.String));)this.state=88,this.parserRuleAtom(),this.state=93,this._errHandler.sync(this),e=this._input.LA(1);this.state=94,this.match(p.T__1);break;default:throw new r.error.NoViableAltException(this)}}catch(e){if(!(e instanceof r.error.RecognitionException))throw e;t.exception=e,this._errHandler.reportError(this,e),this._errHandler.recover(this,e)}finally{this.exitRule()}return t},S.prototype=Object.create(r.ParserRuleContext.prototype),S.prototype.constructor=S,S.prototype.parserRuleAtom=function(t){return void 0===t&&(t=null),null===t?this.getTypedRuleContexts(E):this.getTypedRuleContext(E,t)},S.prototype.accept=function(t){return t instanceof i?t.visitArithmeticRuleCollection(this):t.visitChildren(this)},p.ArithmeticRuleCollectionContext=S,p.prototype.arithmeticRuleCollection=function(){var t=new S(this,this._ctx,this.state);this.enterRule(t,10,p.RULE_arithmeticRuleCollection);var e=0;try{for(this.enterOuterAlt(t,1),this.state=97,this.match(p.T__5),this.state=101,this._errHandler.sync(this),e=this._input.LA(1);0==(-32&e)&&0!=(1<<e&(1<<p.T__5|1<<p.LexerIdentifier|1<<p.ParserIdentifier|1<<p.String));)this.state=98,this.parserRuleAtom(),this.state=103,this._errHandler.sync(this),e=this._input.LA(1)}catch(e){if(!(e instanceof r.error.RecognitionException))throw e;t.exception=e,this._errHandler.reportError(this,e),this._errHandler.recover(this,e)}finally{this.exitRule()}return t},E.prototype=Object.create(r.ParserRuleContext.prototype),E.prototype.constructor=E,E.prototype.copyFrom=function(t){r.ParserRuleContext.prototype.copyFrom.call(this,t)},C.prototype=Object.create(E.prototype),C.prototype.constructor=C,p.ParserAtomExprContext=C,C.prototype.accept=function(t){return t instanceof i?t.visitParserAtomExpr(this):t.visitChildren(this)},A.prototype=Object.create(E.prototype),A.prototype.constructor=A,p.ParserAtomParserIdContext=A,A.prototype.ParserIdentifier=function(){return this.getToken(p.ParserIdentifier,0)},A.prototype.accept=function(t){return t instanceof i?t.visitParserAtomParserId(this):t.visitChildren(this)},b.prototype=Object.create(E.prototype),b.prototype.constructor=b,p.ParserAtomStrContext=b,b.prototype.String=function(){return this.getToken(p.String,0)},b.prototype.accept=function(t){return t instanceof i?t.visitParserAtomStr(this):t.visitChildren(this)},k.prototype=Object.create(E.prototype),k.prototype.constructor=k,p.ParserAtomLexerIdContext=k,k.prototype.LexerIdentifier=function(){return this.getToken(p.LexerIdentifier,0)},k.prototype.accept=function(t){return t instanceof i?t.visitParserAtomLexerId(this):t.visitChildren(this)},p.ParserRuleAtomContext=E,p.prototype.parserRuleAtom=function(){var t=new E(this,this._ctx,this.state);this.enterRule(t,12,p.RULE_parserRuleAtom);var e=0;try{switch(this.state=132,this._errHandler.sync(this),this._input.LA(1)){case p.T__5:t=new C(this,t),this.enterOuterAlt(t,1),this.state=104,this.match(p.T__5),this.state=109,this._errHandler.sync(this),(e=this._input.LA(1))===p.T__6&&(this.state=105,this.match(p.T__6),this.state=107,this._errHandler.sync(this),(e=this._input.LA(1))===p.T__6&&(this.state=106,this.match(p.T__6)));break;case p.ParserIdentifier:t=new A(this,t),this.enterOuterAlt(t,2),this.state=111,this.match(p.ParserIdentifier),this.state=116,this._errHandler.sync(this),0==(-32&(e=this._input.LA(1)))&&0!=(1<<e&(1<<p.T__6|1<<p.T__7|1<<p.T__8))&&(this.state=112,0!=(-32&(e=this._input.LA(1)))||0==(1<<e&(1<<p.T__6|1<<p.T__7|1<<p.T__8))?this._errHandler.recoverInline(this):(this._errHandler.reportMatch(this),this.consume()),this.state=114,this._errHandler.sync(this),(e=this._input.LA(1))===p.T__6&&(this.state=113,this.match(p.T__6)));break;case p.LexerIdentifier:t=new k(this,t),this.enterOuterAlt(t,3),this.state=118,this.match(p.LexerIdentifier),this.state=123,this._errHandler.sync(this),(e=this._input.LA(1))===p.T__6&&(this.state=119,this.match(p.T__6),this.state=121,this._errHandler.sync(this),(e=this._input.LA(1))===p.T__6&&(this.state=120,this.match(p.T__6)));break;case p.String:t=new b(this,t),this.enterOuterAlt(t,4),this.state=125,this.match(p.String),this.state=130,this._errHandler.sync(this),(e=this._input.LA(1))===p.T__6&&(this.state=126,this.match(p.T__6),this.state=128,this._errHandler.sync(this),(e=this._input.LA(1))===p.T__6&&(this.state=127,this.match(p.T__6)));break;default:throw new r.error.NoViableAltException(this)}}catch(e){if(!(e instanceof r.error.RecognitionException))throw e;t.exception=e,this._errHandler.reportError(this,e),this._errHandler.recover(this,e)}finally{this.exitRule()}return t},R.prototype=Object.create(r.ParserRuleContext.prototype),R.prototype.constructor=R,R.prototype.lexerRule=function(t){return void 0===t&&(t=null),null===t?this.getTypedRuleContexts(I):this.getTypedRuleContext(I,t)},R.prototype.accept=function(t){return t instanceof i?t.visitLexerRuleCollection(this):t.visitChildren(this)},p.LexerRuleCollectionContext=R,p.prototype.lexerRuleCollection=function(){var t=new R(this,this._ctx,this.state);this.enterRule(t,14,p.RULE_lexerRuleCollection);try{this.enterOuterAlt(t,1),this.state=137,this._errHandler.sync(this);for(var e=this._interp.adaptivePredict(this._input,20,this._ctx);1!=e&&e!=r.atn.ATN.INVALID_ALT_NUMBER;)2===e&&(this.state=134,this.lexerRule()),this.state=139,this._errHandler.sync(this),e=this._interp.adaptivePredict(this._input,20,this._ctx)}catch(e){if(!(e instanceof r.error.RecognitionException))throw e;t.exception=e,this._errHandler.reportError(this,e),this._errHandler.recover(this,e)}finally{this.exitRule()}return t},L.prototype=Object.create(r.ParserRuleContext.prototype),L.prototype.constructor=L,L.prototype.accept=function(t){return t instanceof i?t.visitMeaningfulSplit(this):t.visitChildren(this)},p.MeaningfulSplitContext=L,p.prototype.meaningfulSplit=function(){var t=new L(this,this._ctx,this.state);this.enterRule(t,16,p.RULE_meaningfulSplit);try{this.enterOuterAlt(t,1),this.state=140,this.match(p.T__9)}catch(e){if(!(e instanceof r.error.RecognitionException))throw e;t.exception=e,this._errHandler.reportError(this,e),this._errHandler.recover(this,e)}finally{this.exitRule()}return t},I.prototype=Object.create(r.ParserRuleContext.prototype),I.prototype.constructor=I,I.prototype.copyFrom=function(t){r.ParserRuleContext.prototype.copyFrom.call(this,t)},N.prototype=Object.create(I.prototype),N.prototype.constructor=N,p.LexerRuleStringsContext=N,N.prototype.LexerIdentifier=function(){return this.getToken(p.LexerIdentifier,0)},N.prototype.strings=function(){return this.getTypedRuleContext(w,0)},N.prototype.accept=function(t){return t instanceof i?t.visitLexerRuleStrings(this):t.visitChildren(this)},O.prototype=Object.create(I.prototype),O.prototype.constructor=O,p.LexerRuleComplexContext=O,O.prototype.LexerIdentifier=function(){return this.getToken(p.LexerIdentifier,0)},O.prototype.lexerRuleExpr=function(){return this.getTypedRuleContext(F,0)},O.prototype.accept=function(t){return t instanceof i?t.visitLexerRuleComplex(this):t.visitChildren(this)},P.prototype=Object.create(I.prototype),P.prototype.constructor=P,p.LexerRuleListContext=P,P.prototype.LexerIdentifier=function(){return this.getToken(p.LexerIdentifier,0)},P.prototype.strings=function(t){return void 0===t&&(t=null),null===t?this.getTypedRuleContexts(w):this.getTypedRuleContext(w,t)},P.prototype.accept=function(t){return t instanceof i?t.visitLexerRuleList(this):t.visitChildren(this)},p.LexerRuleContext=I,p.prototype.lexerRule=function(){var t=new I(this,this._ctx,this.state);this.enterRule(t,18,p.RULE_lexerRule);var e=0;try{switch(this.state=163,this._errHandler.sync(this),this._interp.adaptivePredict(this._input,22,this._ctx)){case 1:t=new N(this,t),this.enterOuterAlt(t,1),this.state=142,this.match(p.LexerIdentifier),this.state=143,this.match(p.T__3),this.state=144,this.strings(),this.state=145,this.match(p.T__1);break;case 2:t=new P(this,t),this.enterOuterAlt(t,2),this.state=147,this.match(p.LexerIdentifier),this.state=148,this.match(p.T__3),this.state=149,this.strings(),this.state=152,this._errHandler.sync(this),e=this._input.LA(1);do{this.state=150,this.match(p.T__4),this.state=151,this.strings(),this.state=154,this._errHandler.sync(this),e=this._input.LA(1)}while(e===p.T__4);this.state=156,this.match(p.T__1);break;case 3:t=new O(this,t),this.enterOuterAlt(t,3),this.state=158,this.match(p.LexerIdentifier),this.state=159,this.match(p.T__3),this.state=160,this.lexerRuleExpr(0),this.state=161,this.match(p.T__1)}}catch(e){if(!(e instanceof r.error.RecognitionException))throw e;t.exception=e,this._errHandler.reportError(this,e),this._errHandler.recover(this,e)}finally{this.exitRule()}return t},w.prototype=Object.create(r.ParserRuleContext.prototype),w.prototype.constructor=w,w.prototype.String=function(t){return void 0===t&&(t=null),null===t?this.getTokens(p.String):this.getToken(p.String,t)},w.prototype.accept=function(t){return t instanceof i?t.visitStrings(this):t.visitChildren(this)},p.StringsContext=w,p.prototype.strings=function(){var t=new w(this,this._ctx,this.state);this.enterRule(t,20,p.RULE_strings);var e=0;try{this.enterOuterAlt(t,1),this.state=172,this._errHandler.sync(this),e=this._input.LA(1);do{this.state=165,this.match(p.String),this.state=170,this._errHandler.sync(this),(e=this._input.LA(1))===p.T__6&&(this.state=166,this.match(p.T__6),this.state=168,this._errHandler.sync(this),(e=this._input.LA(1))===p.T__6&&(this.state=167,this.match(p.T__6))),this.state=174,this._errHandler.sync(this),e=this._input.LA(1)}while(e===p.String)}catch(e){if(!(e instanceof r.error.RecognitionException))throw e;t.exception=e,this._errHandler.reportError(this,e),this._errHandler.recover(this,e)}finally{this.exitRule()}return t},F.prototype=Object.create(r.ParserRuleContext.prototype),F.prototype.constructor=F,F.prototype.lexerRuleExpr=function(t){return void 0===t&&(t=null),null===t?this.getTypedRuleContexts(F):this.getTypedRuleContext(F,t)},F.prototype.LexerIdentifier=function(){return this.getToken(p.LexerIdentifier,0)},F.prototype.String=function(t){return void 0===t&&(t=null),null===t?this.getTokens(p.String):this.getToken(p.String,t)},F.prototype.Brackets=function(){return this.getToken(p.Brackets,0)},F.prototype.accept=function(t){return t instanceof i?t.visitLexerRuleExpr(this):t.visitChildren(this)},p.prototype.lexerRuleExpr=function(t){void 0===t&&(t=0);var e=this._ctx,n=this.state,i=new F(this,this._ctx,n);this.enterRecursionRule(i,22,p.RULE_lexerRuleExpr,t);var o=0;try{switch(this.enterOuterAlt(i,1),this.state=191,this._errHandler.sync(this),this._interp.adaptivePredict(this._input,26,this._ctx)){case 1:this.state=177,this.match(p.T__10),this.state=178,this.lexerRuleExpr(0),this.state=179,this.match(p.T__11);break;case 2:this.state=181,this.match(p.T__12),this.state=182,this.lexerRuleExpr(6);break;case 3:this.state=183,this.match(p.LexerIdentifier);break;case 4:this.state=184,this.match(p.String),this.state=185,this.match(p.T__13),this.state=186,this.match(p.T__13),this.state=187,this.match(p.String);break;case 5:this.state=188,this.match(p.String);break;case 6:this.state=189,this.match(p.T__13);break;case 7:this.state=190,this.match(p.Brackets)}this._ctx.stop=this._input.LT(-1),this.state=207,this._errHandler.sync(this);for(var s=this._interp.adaptivePredict(this._input,29,this._ctx);2!=s&&s!=r.atn.ATN.INVALID_ALT_NUMBER;){if(1===s)switch(null!==this._parseListeners&&this.triggerExitRuleEvent(),i,this.state=205,this._errHandler.sync(this),this._interp.adaptivePredict(this._input,28,this._ctx)){case 1:if(i=new F(this,e,n),this.pushNewRecursionContext(i,22,p.RULE_lexerRuleExpr),this.state=193,!this.precpred(this._ctx,9))throw new r.error.FailedPredicateException(this,"this.precpred(this._ctx, 9)");this.state=194,this.match(p.T__4),this.state=195,this.lexerRuleExpr(10);break;case 2:if(i=new F(this,e,n),this.pushNewRecursionContext(i,22,p.RULE_lexerRuleExpr),this.state=196,!this.precpred(this._ctx,8))throw new r.error.FailedPredicateException(this,"this.precpred(this._ctx, 8)");this.state=197,this.lexerRuleExpr(9);break;case 3:if(i=new F(this,e,n),this.pushNewRecursionContext(i,22,p.RULE_lexerRuleExpr),this.state=198,!this.precpred(this._ctx,11))throw new r.error.FailedPredicateException(this,"this.precpred(this._ctx, 11)");this.state=199,this.match(p.T__6);break;case 4:if(i=new F(this,e,n),this.pushNewRecursionContext(i,22,p.RULE_lexerRuleExpr),this.state=200,!this.precpred(this._ctx,10))throw new r.error.FailedPredicateException(this,"this.precpred(this._ctx, 10)");this.state=201,(o=this._input.LA(1))!==p.T__7&&o!==p.T__8?this._errHandler.recoverInline(this):(this._errHandler.reportMatch(this),this.consume()),this.state=203,this._errHandler.sync(this),1===this._interp.adaptivePredict(this._input,27,this._ctx)&&(this.state=202,this.match(p.T__6))}this.state=209,this._errHandler.sync(this),s=this._interp.adaptivePredict(this._input,29,this._ctx)}}catch(t){if(!(t instanceof r.error.RecognitionException))throw t;i.exception=t,this._errHandler.reportError(this,t),this._errHandler.recover(this,t)}finally{this.unrollRecursionContexts(e)}return i},p.prototype.sempred=function(t,e,n){switch(e){case 11:return this.lexerRuleExpr_sempred(t,n);default:throw"No predicate with index:"+e}},p.prototype.lexerRuleExpr_sempred=function(t,e){switch(e){case 0:return this.precpred(this._ctx,9);case 1:return this.precpred(this._ctx,8);case 2:return this.precpred(this._ctx,11);case 3:return this.precpred(this._ctx,10);default:throw"No predicate with index:"+e}},e.BlocklyGrammerParser=p},function(module,exports,__webpack_require__){var antlr4=__webpack_require__(12),BlocklyGrammerVisitor=__webpack_require__(20).BlocklyGrammerVisitor;function SymbolVisitor(){return BlocklyGrammerVisitor.call(this),this}function EvalVisitor(){return BlocklyGrammerVisitor.call(this),this}SymbolVisitor.prototype=Object.create(BlocklyGrammerVisitor.prototype),SymbolVisitor.prototype.constructor=SymbolVisitor,SymbolVisitor.prototype.init=function(){return this.statementRules=[],this.expressionRules=[],this.expression_arithmetic_num=0,this.lexerRules={},this.grammerName="",this},SymbolVisitor.prototype.error=function(t){throw new Error(t)},SymbolVisitor.prototype.checkSymbol=function(){for(var t,e={},n=function(t,e){for(var n,r=0;n=t[r];r++)if(n[0]===e)return n[1];return[]},r=0;t=this.statementRules[r];r++)if(t[1].length>1)for(var i,o=0;i=t[1][o];o++)e[i]&&this.error("语句 "+i+" 同时在两个语句集合 "+e[i]+" 和 "+t[0]+" 中出现了"),e[i]=t[0],n(this.statementRules,i).length>1&&this.error(t[0]+" 下的子规则 "+i+' 包含了"|"');var s;for(r=0;s=this.expressionRules[r];r++)s[1].length>1&&"expression"!==s[0]&&this.error("表达式 "+s[0]+' 包含了"|"')},SymbolVisitor.prototype.visitGrammarFile=function(t){return this.visit(t.grammerDecl()),this.visit(t.statementRule()),this.visit(t.expressionRule()),this.visit(t.lexerRuleCollection(0)),this},SymbolVisitor.prototype.visitGrammerDecl=function(t){this.grammerName=t.children[1].getText()},SymbolVisitor.prototype.visitStatList=function(t){for(var e,n=t.ParserIdentifier(),r=0;e=n[r];r++)n[r]=e.getText();var i=n.shift();this.statementRules.push([i,n])},SymbolVisitor.prototype.visitStatValue=function(t){var e=t.ParserIdentifier(0).getText();this.statementRules.push([e,[e]])},SymbolVisitor.prototype.visitExprExpression=function(t){var e=[];this.expression_arithmetic_num=t.arithmeticRuleCollection().length;for(var n=0;n<this.expression_arithmetic_num;n++){var r="expression_arithmetic_"+n;e.push(r),this.expressionRules.push([r,[r]])}var i,o=t.ParserIdentifier();for(n=0;i=o[n];n++)o[n]=i.getText();e=e.concat(o),this.expressionRules.push(["expression",e])},SymbolVisitor.prototype.visitExprValue=function(t){var e=t.ParserIdentifier(0).getText();this.expressionRules.push([e,[e]])},SymbolVisitor.prototype.visitLexerRuleCollection=function(t){for(var e,n=t.lexerRule()||[],r=0;e=n[r];r++){var i=e.LexerIdentifier(0).getText();this.lexerRules[i]=""}},EvalVisitor.prototype=Object.create(BlocklyGrammerVisitor.prototype),EvalVisitor.prototype.constructor=EvalVisitor,EvalVisitor.prototype.init=function(t,e){this.rawInput=e;var n=function(t){for(var e,n={},r=0;e=t[r];r++)n[e[0]]={check:e[1],user:{}};return n};return this.grammerName=t.grammerName,this.statementRules=n(t.statementRules),this.expressionRules=n(t.expressionRules),this.lexerRules=t.lexerRules,this.notEntry={},this.valueColor=330,this.statementColor=160,this.entryColor=260,this.generLanguage="JavaScript",this.recieveOrder="ORDER_ATOMIC",this.sendOrder="ORDER_NONE",this.varPrefix="",this.blocks="",this},EvalVisitor.prototype.error=function(t){throw new Error(t)},EvalVisitor.prototype.setRule=function(t,e,n){"lexer"===t&&(this.lexerRules[e]=n),"statement"===t&&(this.statementRules[e]=n),"value"===t&&(this.expressionRules[e]=n)},EvalVisitor.prototype.getRule=function(t,e){return"lexer"===t?this.lexerRules[e]:"statement"===t?this.statementRules[e]:"value"===t?this.expressionRules[e]:void 0},EvalVisitor.prototype.escapeString=function(string_){return eval(string_)},EvalVisitor.prototype.matchInject=function(t){var e=new RegExp("/\\*[^\\S\\r\\n]*"+t+"[\\r\\n]*([^]*?)[\\r\\n]*\\*/"),n=this.rawInput.match(e);return n?n[1]:""},EvalVisitor.prototype.inject=["colour","tooltip","helpUrl","default","override"],EvalVisitor.prototype.loadInject=function(injectStr){if(!injectStr)return{default:[]};for(var obj={},ii=0,inject;inject=this.inject[ii];ii++){var pattern=new RegExp("^\\s*"+inject+"\\s*:\\s*([^\\r\\n]*)\\s*?[\\r\\n]+","m"),value=injectStr.match(pattern);value&&(obj[inject]=value[1],injectStr=injectStr.slice(0,value.index)+injectStr.slice(value.index+value[0].length))}return obj.colour&&(obj.colour=eval(obj.colour)),obj.default?obj.default=eval(obj.default):obj.default=[],obj.generFunc=injectStr,obj},EvalVisitor.prototype.initAssemble=function(t){t.inject=this.loadInject(this.matchInject(t.name));var e=[];t.vars=[],t.fieldDefault=[];for(var n,r=!1,i=0,o=0,s={};n=t.args[o];o++){var a=JSON.parse(JSON.stringify(n.data)),l=null;if(n.id)if(s[n.id]=s[n.id]?s[n.id]:0,a.name=n.id+"_"+s[n.id],s[n.id]++,"field"!==n.blockType){var u=this.getRule(n.blockType,n.id),c=u.check;a.check=1===c.length?c[0]:c,u.user[t.name]=t.type,this.notEntry[n.id]=!0,this.setRule(n.blockType,n.id,u)}else{var h={field_input:"text",field_number:"value",field_dropdown:"options",field_checkbox:"checked",field_colour:"colour",field_angle:"angle",field_image:"src"}[a.type];void 0===(l=t.inject.default[i])&&(l=null),"options"===h?null==l&&(l=a[h][0][1]):(null!==l&&(a[h]=l),l=a[h]),i++}a.name?t.vars.push(a.name):(t.vars.push(null),r=!0),t.fieldDefault.push(l),e.push(a)}var p={type:t.name,message0:t.message.join(" "),args0:e,inputsInline:!0,tooltip:t.inject.tooltip||"",helpUrl:t.inject.helpUrl||""};0===e.length&&delete p.args0,r&&delete p.inputsInline;var f=this.getRule(t.type,t.name);c=1===(c=f.check).length?c[0]:c,"value"===t.type?(p.colour=t.inject.colour||this.valueColor,p.output=c):(p.colour=t.inject.colour||this.statementColor,p.previousStatement=c,p.nextStatement=c),f.blockjs=p,f.blockobj=t,this.setRule(t.type,t.name,f)},EvalVisitor.prototype.assemble=function(){for(var t=Object.keys(this.statementRules),e=0;o=this.statementRules[t[e]];e++)if(o.check.length>1){this.notEntry[t[e]]=!0;for(var n,r=0;n=o.check[r];r++){var i=this.getRule("statement",n);i.blockjs.nextStatement=o.check,this.setRule("statement",n,i),this.notEntry[n]=!0}}for(e=0;o=this.statementRules[t[e]];e++)this.notEntry[t[e]]||(this.notEntry[t[e]]=!1,delete o.blockjs.previousStatement,delete o.blockjs.nextStatement,delete o.blockjs.inputsInline,o.blockjs.colour=this.entryColor);var o,s=[],a=[];for(e=0;o=this.statementRules[t[e]];e++)if(o.check.length>1)a.push([t[e],o]);else{s.push(o),o.type="statement";var l=[],u="",c=function(t){t>0&&(u+=Array(2*t+1).join(" ")),t<0&&(u=u.slice(0,2*t))},h="Blockly."+this.generLanguage+".";l.push(u+"function(block) {\n"),c(1);for(r=0;y=o.blockobj.args[r];r++){var p=this.varPrefix+o.blockobj.vars[r];if(y.id)"value"===y.blockType?(l.push(u+"var "+p+" = "+h+"valueToCode(block, '"),l.push(p+"', \n  "+u+h+this.recieveOrder+")")):"statement"===y.blockType?(l.push(u+"var "+p+" = "+h+"statementToCode(block, '"),l.push(p+"')")):(l.push(u+"var "+p+" = block.getFieldValue('"),l.push(p+"')")),"field_checkbox"===y.data.type&&l.push(" === 'TRUE'"),l.push(";\n"),y.multi,{field_checkbox:!0,field_dropdown:!0,field_number:!0,field_colour:!0,field_angle:!0,field_image:!0}[y.data.type]||y.omitted||(l.push(u+"if ("+p+"==='') {\n"),c(1),l.push(u+"throw new OmitedError(block,'"+p+"','"),l.push(t[e]+"');\n"),c(-1),l.push(u+"}\n")),"field"===y.blockType&&(l.push(u+p+" = "+this.grammerName+"Functions.pre('"),l.push(y.id+"')("+p+");\n"))}o.blockobj.inject.generFunc?(o.blockobj.inject.override&&(c(-9999),(l=[]).push(u+"function(block) {\n"),c(1)),l.push(u+o.blockobj.inject.generFunc.split("\n").join("\n"+u)),l.push("\n")):(l.push(u+"var code = '1111111111;\\n';\n"),l.push(u+"return code;\n")),c(-1),l.push(u+"}"),o.generFunc=l.join("")}t=Object.keys(this.expressionRules);var f;for(e=0;f=this.expressionRules[t[e]];e++)if(f.check.length>1)a.push([t[e],f]);else{s.push(f),f.type="value";l=[],u="",c=function(t){t>0&&(u+=Array(2*t+1).join(" ")),t<0&&(u=u.slice(0,2*t))},h="Blockly."+this.generLanguage+".";l.push(u+"function(block) {\n"),c(1);for(r=0;y=f.blockobj.args[r];r++){p=this.varPrefix+f.blockobj.vars[r];if(y.id)"value"===y.blockType?(l.push(u+"var "+p+" = "+h+"valueToCode(block, '"),l.push(p+"', \n  "+u+h+this.recieveOrder+")")):"statement"===y.blockType?(l.push(u+"var "+p+" = "+h+"statementToCode(block, '"),l.push(p+"')")):(l.push(u+"var "+p+" = block.getFieldValue('"),l.push(p+"')")),"field_checkbox"===y.data.type&&l.push(" === 'TRUE'"),l.push(";\n"),y.multi,{field_checkbox:!0,field_dropdown:!0,field_number:!0,field_colour:!0,field_angle:!0,field_image:!0}[y.data.type]||y.omitted||(l.push(u+"if ("+p+"==='') {\n"),c(1),l.push(u+"throw new OmitedError(block,'"+p+"','"),l.push(t[e]+"');\n"),c(-1),l.push(u+"}\n")),"field"===y.blockType&&(l.push(u+p+" = "+this.grammerName+"Functions.pre('"),l.push(y.id+"')("+p+");\n"))}f.blockobj.inject.generFunc?(f.blockobj.inject.override&&(c(-9999),(l=[]).push(u+"function(block) {\n"),c(1)),l.push(u+f.blockobj.inject.generFunc.split("\n").join("\n"+u)),l.push("\n")):(l.push(u+"var code = 0000000000;\n"),l.push(u+"return [code, "+h+this.sendOrder+"];\n")),c(-1),l.push(u+"}"),f.generFunc=l.join("")}var d;for(e=0;d=s[e];e++){d.args=[],d.argsType=[],d.fieldDefault=[];var y;for(r=0;y=d.blockobj.args[r];r++)y.id&&(d.args.push(d.blockobj.vars[r]),d.argsType.push(y.blockType),d.fieldDefault.push(d.blockobj.fieldDefault[r]));l=[],u="",c=function(t){t>0&&(u+=Array(2*t+1).join(" ")),t<0&&(u=u.slice(0,2*t))};var g=this.grammerName,v=d.check[0];l.push(u+"function (inputs,isShadow,comment) {\n"),c(1),l.push(u+"return "+g+"Functions.xmlText('"),l.push(v+"',inputs,isShadow,comment);\n"),c(-1),l.push(u+"}"),d.xmlText=l.join("")}this.temp_xml=s,this.temp_collection=a},EvalVisitor.prototype.generBlocks=function(){var t=[],e="",n=function(t){t>0&&(e+=Array(2*t+1).join(" ")),t<0&&(e=e.slice(0,2*t))};temp_xml=this.temp_xml,delete this.temp_xml,temp_collection=this.temp_collection,delete this.temp_collection,t.push(e+this.grammerName+"Blocks = {\n"),n(1);for(var r,i=0;r=temp_collection[i];i++)t.push(e+'"'+r[0]+'": '),t.push(JSON.stringify(r[1].check,null,2).split("\n").join("\n"+e)),t.push(",\n");function o(t,e,n){var r=e.blockjs,i=JSON.stringify(r).split("\n").join("\n"+n),o={};r=JSON.parse(i);for(var s,a=0;s=e.blockobj.args[a];a++)if(s.id){var l=t.getRule(s.blockType,s.id);l&&1!==l.check.length&&(r.args0[a].check="1_fry2_3_inrgv"+s.id,o['"1_fry2_3_inrgv'+s.id+'"']=t.grammerName+"Blocks."+s.id)}if(r.nextStatement)for(var u,c=0;u=temp_collection[c];c++)if(-1!==u[1].check.indexOf(r.type)){r.nextStatement="1_fry2_3_inrgv"+u[0],o['"1_fry2_3_inrgv'+u[0]+'"']=t.grammerName+"Blocks."+u[0];break}for(var h in i=JSON.stringify(r,null,2).split("\n").join("\n"+n),o)i=i.split(h).join(o[h]);return i}t.pop(),t.push("\n"),n(-1),t.push(e+"}\n"),t.push(e+this.grammerName+"Blocks = Object.assign("),t.push(this.grammerName+"Blocks,{\n"),n(1);var s;for(i=0;s=temp_xml[i];i++)t.push(e+'"'+s.check[0]+'": {\n'),n(1),t.push(e+'"type": "'+s.type+'",\n'),t.push(e+'"json": '),t.push(o(this,s,e)),t.push(",\n"),t.push(e+'"generFunc": '),t.push(s.generFunc.split("\n").join("\n"+e)),t.push(",\n"),t.push(e+'"args": '),t.push(JSON.stringify(s.args,null,2).split("\n").join("\n"+e)),t.push(",\n"),t.push(e+'"argsType": '),t.push(JSON.stringify(s.argsType,null,0)),t.push(",\n"),t.push(e+'"fieldDefault": '),t.push(JSON.stringify(s.fieldDefault,null,0)),t.push(",\n"),t.push(e+'"xmlText": '),t.push(s.xmlText.split("\n").join("\n"+e)),t.push("\n"),n(-1),t.push(e+"},\n");t.pop(),t.push(e+"}\n"),n(-1),t.push(e+"});\n"),this.blocks=t.join("")},EvalVisitor.prototype.SpeicalLexerRule=function(t){var e={};return"Bool"===t?(e={type:"field_checkbox",checked:!0},this.setRule("lexer",t,e),!0):"Int"===t?(e={type:"field_number",value:0,min:0,precision:1},this.setRule("lexer",t,e),!0):"Number"===t?(e={type:"field_number",value:0},this.setRule("lexer",t,e),!0):"Colour"===t?(e={type:"field_colour",colour:"#ffffff"},this.setRule("lexer",t,e),!0):"Angle"===t?(e={type:"field_angle",angle:90},this.setRule("lexer",t,e),!0):"BGNL"===t&&(e={type:"input_dummy"},this.setRule("lexer",t,e),!0)},EvalVisitor.prototype.visitGrammarFile=function(t){this.visit(t.lexerRuleCollection(0)),this.visit(t.statementRule()),this.expression_arithmetic_num=0,this.visit(t.expressionRule()),this.assemble()},EvalVisitor.prototype.visitStrings=function(t){for(var e,n=t.String(),r=0;e=n[r];r++)n[r]=this.escapeString(e.getText());return n.join(" ")},EvalVisitor.prototype.visitLexerRuleStrings=function(t){var e=t.LexerIdentifier(0).getText();if(!this.SpeicalLexerRule(e)){var n=this.visit(t.strings(0));this.setRule("lexer",e,n)}},EvalVisitor.prototype.visitLexerRuleList=function(ctx){var lexerId=ctx.LexerIdentifier(0).getText();if(!this.SpeicalLexerRule(lexerId))if("_List"===lexerId.slice(-5)||"_Img"===lexerId.slice(-4)){var strings=ctx.strings(),values=this.matchInject(lexerId);values=values?eval(values):[];for(var ii=0,value;value=strings[ii];ii++){var string_=this.visit(value);strings[ii]=[string_,null==values[ii]?string_:values[ii]]}if("_List"===lexerId.slice(-5))var lexervalue={type:"field_dropdown",options:strings};else var lexervalue={type:"field_image",src:strings[0][0],width:strings[1]&&strings[1][0]||0,height:strings[2]&&strings[2][0]||0,alt:"*"};this.setRule("lexer",lexerId,lexervalue)}else this.visitLexerRuleComplex(ctx)},EvalVisitor.prototype.visitLexerRuleComplex=function(t){var e=t.LexerIdentifier(0).getText();if(!this.SpeicalLexerRule(e)){var n={type:"field_input",text:e+"_default"};this.setRule("lexer",e,n)}},EvalVisitor.prototype.visitStatValue=function(t){this.status={name:t.ParserIdentifier(0).getText(),type:"statement",message:[],args:[]},this.visitChildren(t);var e=this.status;delete this.status,this.initAssemble(e)},BlocklyGrammerVisitor.prototype.visitArithmeticRuleCollection=function(t){this.status={name:"expression",type:"value",message:["%1"],args:[{id:"expression",blockType:"value",omitted:!1,data:{type:"input_value"}}]},this.visitChildren(t),this.status.name="expression_arithmetic_"+this.expression_arithmetic_num,this.expression_arithmetic_num++;var e=this.status;delete this.status,this.initAssemble(e)},BlocklyGrammerVisitor.prototype.visitExprValue=function(t){this.status={name:t.ParserIdentifier(0).getText(),type:"value",message:[],args:[]},this.visitChildren(t);var e=this.status;delete this.status,this.initAssemble(e)},EvalVisitor.prototype.visitParserAtomExpr=function(t){var e={id:"expression",blockType:"value",omitted:t.children.length>1,data:{type:"input_value"}};this.status.args.push(e),this.status.message.push("%"+this.status.args.length)},EvalVisitor.prototype.visitParserAtomParserId=function(t){var e=t.children[0].getText(),n=t.children.length>1&&t.children[1].getText()||"",r=this.getRule("value",e)?"value":"statement",i={id:e,blockType:r,omitted:"?"===n||"*"===n,multi:"+"===n||"*"===n,data:{type:"input_"+r}};"value"===r&&i.multi&&this.error(this.status.name+" 下出现了复数组合的表达式 "+e+n),this.status.args.push(i),this.status.message.push("%"+this.status.args.length)},EvalVisitor.prototype.visitParserAtomLexerId=function(t){var e=t.children[0].getText(),n=this.getRule("lexer",e);if(n){var r={id:e,blockType:"field",omitted:t.children.length>1,data:n};"BGNL"===e&&(r={data:n}),"string"!=typeof n?(this.status.args.push(r),this.status.message.push("%"+this.status.args.length)):this.status.message.push(n)}},EvalVisitor.prototype.visitParserAtomStr=function(t){var e=this.escapeString(t.String().getText());this.status.message.push(e)},exports.SymbolVisitor=SymbolVisitor,exports.EvalVisitor=EvalVisitor},function(t,e){e.OmitedError=function(){return"//生成代码中,当一个不允许省略的值或块省略时,会抛出这个错误\nfunction OmitedError(block, var_, rule, fileName, lineNumber) {\n  var message = 'no omitted '+var_+' at '+rule;\n  var instance = new Error(message, fileName, lineNumber);\n  instance.block = block;\n  instance.varName = var_;\n  instance.blockName = rule;\n  instance.name = 'OmitedError';\n  Object.setPrototypeOf(instance, Object.getPrototypeOf(this));\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(instance, OmitedError);\n  }\n  return instance;\n}\n\nOmitedError.prototype = Object.create(Error.prototype);\nOmitedError.prototype.constructor = OmitedError;\n//处理此错误的omitedcheckUpdateFunction定义在下面"},e.Functions_pre=function(t){return`${t}Functions.Int_pre = function(intstr) {\n  return parseInt(intstr);\n}\n\n${t}Functions.Number_pre = function(intstr) {\n  return parseFloat(intstr);\n}\n\n//返回各LexerRule文本域的预处理函数,方便用来统一转义等等\n${t}Functions.pre = function(LexerId) {\n  if (${t}Functions.hasOwnProperty(LexerId+'_pre')) {\n    return ${t}Functions[LexerId+'_pre'];\n  }\n  return function(obj){return obj}\n}`},e.Functions_xmlText=function(t){return`//构造这个方法是为了能够不借助workspace,从语法树直接构造图块结构\n//inputs的第i个元素是第i个args的xmlText,null或undefined表示空\n//inputs的第rule.args.length个元素是其下一个语句的xmlText\n${t}Functions.xmlText = function (ruleName,inputs,isShadow,comment) {\n  var rule = ${t}Blocks[ruleName];\n  var blocktext = isShadow?'shadow':'block';\n  var xmlText = [];\n  xmlText.push('<'+blocktext+' type="'+ruleName+'">');\n  if(!inputs)inputs=[];\n  for (var ii=0,inputType;inputType=rule.argsType[ii];ii++) {\n    var input = inputs[ii];\n    var _input = '';\n    var noinput = (input===null || input===undefined);\n    if(noinput && inputType==='field') continue;\n    if(noinput) input = '';\n    if(inputType!=='field') {\n      var subList = false;\n      var subrulename = rule.args[ii];\n      subrulename=subrulename.split('_').slice(0,-1).join('_');\n      var subrule = ${t}Blocks[subrulename];\n      if (subrule instanceof Array) {\n        subrulename=subrule[subrule.length-1];\n        subrule = ${t}Blocks[subrulename];\n        subList = true;\n      }\n      _input = subrule.xmlText([],true);\n      if(noinput && !subList && !isShadow) {\n        //无输入的默认行为是: 如果语句块的备选方块只有一个,直接代入方块\n        input = subrule.xmlText();\n      }\n    }\n    xmlText.push('<'+inputType+' name="'+rule.args[ii]+'">');\n    xmlText.push(_input+input);\n    xmlText.push('</'+inputType+'>');\n  }\n  if(comment){\n    xmlText.push('<comment><![CDATA[');\n    xmlText.push(comment.replace(/]]>/g,'] ] >'));\n    xmlText.push(']]></comment>');\n  }\n  var next = inputs[rule.args.length];\n  if (next) {//next\n    xmlText.push('<next>');\n    xmlText.push(next);\n    xmlText.push('</next>');\n  }\n  xmlText.push('</'+blocktext+'>');\n  return xmlText.join('');\n}`},e.Functions_blocksIniter=function(t,e){return`//把各方块的信息注册到Blockly中\n${t}Functions.blocksIniter = function(){\n  var blocksobj = ${t}Blocks;\n  for(var key in blocksobj) {\n    var value = blocksobj[key];\n    if(value instanceof Array)continue;\n    (function(key,value){\n      Blockly.Blocks[key] = {\n        init: function() {this.jsonInit(value.json);}\n      }\n    })(key,value);\n    Blockly.${e}[key] = value.generFunc;\n  }\n}`},e.mainFileTPL=function(t,e,n,r,i,o,s,a){return[`<!doctype html>\n<head>\n<meta charset="utf-8">\n<title>${t} --antlr-blockly</title>`,'\n<script src="blockly_compressed.js"><\/script>\n<script src="blocks_compressed.js"><\/script>\n<script src="javascript_compressed.js"><\/script>\n<script src="zh-hans.js"><\/script>\n\x3c!-- <script src="en.js"><\/script> --\x3e',"\n</head>\n<body>",`\n\n<p>\n<button onclick="showXML()">Show XML</button>\n<button onclick="runCode()">console.log(obj=code)</button>\n</p>\n<div id="${n}" style="height: 480px; width: 940px;"></div>\n<pre id="${r}"></pre>\n${i}\n`,"\n<script>\n",`\n${a}\n`,`\nvar ${o} = Blockly.inject('${n}',{\n  media: 'media/',\n  toolbox: document.getElementById('${s}'),\n  zoom:{\n    controls: true,\n    wheel: true,//false\n    startScale: 1.0,\n    maxScale: 3,\n    minScale: 0.3,\n    scaleSpeed: 1.08\n  },\n  trashcan: false,\n});\n\nfunction omitedcheckUpdateFunction(event) {\n  console.log(event);\n  try {\n    var code = Blockly.${e}.workspaceToCode(${o});\n    document.getElementById('${r}').innerText = code;\n  } catch (error) {\n    document.getElementById('${r}').innerText = String(error);\n    if (error instanceof OmitedError){\n      var blockName = error.blockName;\n      var varName = error.varName;\n      var block = error.block;\n    }\n    console.log(error);\n  }\n}\n\n${o}.addChangeListener(omitedcheckUpdateFunction);\n\n${o}.addChangeListener(Blockly.Events.disableOrphans);\n//自动禁用任何未连接到根块的块\n`,`\n\nfunction showXML() {\n  xml = Blockly.Xml.workspaceToDom(${o});\n  xml_text = Blockly.Xml.domToPrettyText(xml);\n  console.log(xml_text);\n  xml_text = Blockly.Xml.domToText(xml);\n  console.log(xml_text);\n  console.log(xml);\n}\n\nfunction runCode() {\n  // Generate ${e} code and run it.\n  window.LoopTrap = 1000;\n  Blockly.${e}.INFINITE_LOOP_TRAP =\n    'if (--window.LoopTrap == 0) throw "Infinite loop.";\\n';\n  code = Blockly.${e}.workspaceToCode(${o});\n  Blockly.${e}.INFINITE_LOOP_TRAP = null;\n  try {\n    eval('obj=' + code);\n    console.log(obj);\n  } catch (e) {\n    alert(e);\n  }\n}\n`,"\n<\/script>\n\n","</body>\n</html>\n"]}}]);
\ No newline at end of file
diff --git a/_server/blockly/MotaAction.g4 b/_server/blockly/MotaAction.g4
deleted file mode 100644
index 917ed6e8..00000000
--- a/_server/blockly/MotaAction.g4
+++ /dev/null
@@ -1,1868 +0,0 @@
-grammar MotaAction;
-
-//===============parser===============
-//===blockly语句===
-
-//事件 事件编辑器入口之一
-event_m
-    :   '事件' BGNL? Newline '覆盖触发器' Bool '启用' Bool '通行状态' B_0_List '显伤' Bool BGNL? Newline action+ BEND
-    
-
-/* event_m
-tooltip : 编辑魔塔的事件
-helpUrl : https://ckcz123.github.io/mota-js/#/event
-default : [false,null,null,null]
-B_0_List_0=eval(B_0_List_0);
-var code = {
-    'trigger': Bool_0?'action':null,
-    'enable': Bool_1,
-    'noPass': B_0_List_0,
-    'displayDamage': Bool_2,
-    'data': 'data_asdfefw'
-}
-if (!Bool_0 && Bool_1 && (B_0_List_0===null) && Bool_2) code = 'data_asdfefw';
-code=JSON.stringify(code,null,2).split('"data_asdfefw"').join('[\n'+action_0+']\n');
-return code;
-*/;
-
-//加点 事件编辑器入口之一
-point_m
-    :   '加点' BGNL? Newline choicesContext+ BEND
-    
-
-/* point_m
-tooltip : 加点事件
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=%e5%8a%a0%e7%82%b9%e4%ba%8b%e4%bb%b6
-var code = '{"type": "choices", "choices": [\n'+choicesContext_0+']}\n';
-return code;
-*/;
-
-//商店 事件编辑器入口之一
-shop_m
-    :   '全局商店列表' BGNL? Newline shoplist+
-    
-/* shop_m
-tooltip : 全局商店列表
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=%e5%85%a8%e5%b1%80%e5%95%86%e5%ba%97
-var code = '['+shoplist_0+']\n';
-return code;
-*/;
-
-shoplist
-    :   shopsub
-    |   emptyshop
-    ;
-
-emptyshop
-    :   Newline
-    
-
-/* emptyshop
-var code = ' \n';
-return code;
-*/;
-
-shopsub
-    :   '商店 id' IdString '标题' EvalString '图标' IdString BGNL? Newline '快捷商店栏中名称' EvalString BGNL? Newline '使用' ShopUse_List '消耗' EvalString BGNL? Newline '显示文字' EvalString BGNL? Newline shopChoices+ BEND
-    
-
-/* shopsub
-tooltip : 全局商店,消耗填-1表示每个选项的消耗不同,正数表示消耗数值
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=%e5%85%a8%e5%b1%80%e5%95%86%e5%ba%97
-default : ["shop1","贪婪之神","blueShop","1F金币商店",null,"20+10*times*(times+1)","勇敢的武士啊, 给我${need}金币就可以："]
-var code = {
-    'id': IdString_0,
-    'name': EvalString_0,
-    'icon': IdString_1,
-    'textInList': EvalString_1,
-    'use': ShopUse_List_0,
-    'need': EvalString_2,
-    'text': EvalString_3,
-    'choices': 'choices_asdfefw'
-}
-code=JSON.stringify(code,null,2).split('"choices_asdfefw"').join('[\n'+shopChoices_0+']\n')+',\n';
-return code;
-*/;
-
-shopChoices
-    :   '商店选项' EvalString '消耗' EvalString? BGNL? Newline shopEffect+
-    
-
-/* shopChoices
-tooltip : 商店选项,商店消耗是-1时,这里的消耗对应各自选项的消耗,商店消耗不是-1时这里的消耗不填
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=%e5%85%a8%e5%b1%80%e5%95%86%e5%ba%97
-default : ["攻击+1",""]
-colour : this.subColor
-EvalString_1 = EvalString_1 && (', "need": "'+EvalString_1+'"');
-var code = '{"text": "'+EvalString_0+'"'+EvalString_1+', "effect": "'+shopEffect_0.slice(2,-1)+'"},\n';
-return code;
-*/;
-
-shopEffect
-    :   idString_e '+=' expression
-    
-
-/* shopEffect
-colour : this.subColor
-var code = idString_e_0+'+='+expression_0+';'
-return code;
-*/;
-
-//afterBattle 事件编辑器入口之一
-afterBattle_m
-    :   '战斗结束后' BGNL? Newline action+ BEND
-    
-
-/* afterBattle_m
-tooltip : 系统引发的自定义事件
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=%e7%b3%bb%e7%bb%9f%e5%bc%95%e5%8f%91%e7%9a%84%e8%87%aa%e5%ae%9a%e4%b9%89%e4%ba%8b%e4%bb%b6
-var code = '[\n'+action_0+']\n';
-return code;
-*/;
-
-//afterGetItem 事件编辑器入口之一
-afterGetItem_m
-    :   '获取道具后' BGNL? Newline action+ BEND
-    
-
-/* afterGetItem_m
-tooltip : 系统引发的自定义事件
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=%e7%b3%bb%e7%bb%9f%e5%bc%95%e5%8f%91%e7%9a%84%e8%87%aa%e5%ae%9a%e4%b9%89%e4%ba%8b%e4%bb%b6
-var code = '[\n'+action_0+']\n';
-return code;
-*/;
-
-//afterOpenDoor 事件编辑器入口之一
-afterOpenDoor_m
-    :   '打开门后' BGNL? Newline action+ BEND
-    
-
-/* afterOpenDoor_m
-tooltip : 系统引发的自定义事件
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=%e7%b3%bb%e7%bb%9f%e5%bc%95%e5%8f%91%e7%9a%84%e8%87%aa%e5%ae%9a%e4%b9%89%e4%ba%8b%e4%bb%b6
-var code = '[\n'+action_0+']\n';
-return code;
-*/;
-
-//firstArrive 事件编辑器入口之一
-firstArrive_m
-    :   '首次到达楼层' BGNL? Newline action+ BEND
-    
-
-/* firstArrive_m
-tooltip : 首次到达楼层
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=%e7%b3%bb%e7%bb%9f%e5%bc%95%e5%8f%91%e7%9a%84%e8%87%aa%e5%ae%9a%e4%b9%89%e4%ba%8b%e4%bb%b6
-var code = '[\n'+action_0+']\n';
-return code;
-*/;
-
-//changeFloor 事件编辑器入口之一
-changeFloor_m
-    :   '楼梯, 传送门' BGNL? Newline Floor_List IdString? Stair_List 'x' Number ',' 'y' Number '朝向' DirectionEx_List '动画时间' Int? '允许穿透' Bool BEND
-    
-
-/* changeFloor_m
-tooltip : 楼梯, 传送门, 如果目标楼层有多个楼梯, 写upFloor或downFloor可能会导致到达的楼梯不确定, 这时候请使用loc方式来指定具体的点位置
-helpUrl : https://ckcz123.github.io/mota-js/#/element?id=%e8%b7%af%e9%9a%9c%ef%bc%8c%e6%a5%bc%e6%a2%af%ef%bc%8c%e4%bc%a0%e9%80%81%e9%97%a8
-default : [null,"MT1",null,0,0,null,500,null]
-var toFloorId = IdString_0;
-if (Floor_List_0!='floorId') toFloorId = Floor_List_0;
-var loc = ', "loc": ['+Number_0+', '+Number_1+']';
-if (Stair_List_0!=='loc')loc = ', "stair": "'+Stair_List_0+'"';
-DirectionEx_List_0 = DirectionEx_List_0 && (', "direction": "'+DirectionEx_List_0+'"');
-Int_0 = Int_0 ?(', "time": '+Int_0):'';
-Bool_0 = Bool_0 ?'':(', "portalWithoutTrigger": false');
-var code = '{"floorId": "'+toFloorId+'"'+loc+DirectionEx_List_0+Int_0+Bool_0+' }\n';
-return code;
-*/;
-
-//为了避免关键字冲突,全部加了_s
-//动作
-action
-    :   text_0_s
-    |   text_1_s
-    |   autoText_s
-    |   setText_s
-    |   tip_s
-    |   setValue_s
-    |   show_s
-    |   hide_s
-    |   trigger_s
-    |   revisit_s
-    |   exit_s
-    |   setBlock_s
-    |   setHeroIcon_s
-    |   update_s
-    |   updateEnemys_s
-    |   sleep_s
-    |   wait_s
-    |   battle_s
-    |   openDoor_s
-    |   changeFloor_s
-    |   changePos_0_s
-    |   changePos_1_s
-    |   openShop_s
-    |   disableShop_s
-    |   follow_s
-    |   unfollow_s
-    |   animate_s
-    |   viberate_s
-    |   showImage_0_s
-    |   showImage_1_s
-    |   animateImage_0_s
-    |   animateImage_1_s
-    |   showGif_0_s
-    |   showGif_1_s
-    |   moveImage_0_s
-    |   setFg_0_s
-    |   setFg_1_s
-    |   setWeather_s
-    |   move_s
-    |   moveHero_s
-    |   jump_s
-    |   jumpHero_s
-    |   playBgm_s
-    |   pauseBgm_s
-    |   resumeBgm_s
-    |   playSound_s
-    |   setVolume_s
-    |   win_s
-    |   lose_s
-    |   if_s
-    |   while_s
-    |   break_s
-    |   continue_s
-    |   input_s
-    |   choices_s
-    |   function_s
-    |   pass_s
-    ;
-
-text_0_s
-    :   '显示文章' ':' EvalString Newline
-    
-
-/* text_0_s
-tooltip : text：显示一段文字（剧情）
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=text%EF%BC%9A%E6%98%BE%E7%A4%BA%E4%B8%80%E6%AE%B5%E6%96%87%E5%AD%97%EF%BC%88%E5%89%A7%E6%83%85%EF%BC%89
-default : ["欢迎使用事件编辑器(双击方块进入多行编辑)"]
-var code = '"'+EvalString_0+'",\n';
-return code;
-*/;
-
-text_1_s
-    :   '标题' EvalString? '图像' IdString? '对话框效果' EvalString? ':' EvalString Newline
-    
-
-/* text_1_s
-tooltip : text：显示一段文字（剧情）,选项较多请右键点击帮助
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=text%EF%BC%9A%E6%98%BE%E7%A4%BA%E4%B8%80%E6%AE%B5%E6%96%87%E5%AD%97%EF%BC%88%E5%89%A7%E6%83%85%EF%BC%89
-default : ["小妖精","fairy","","欢迎使用事件编辑器(双击方块进入多行编辑)"]
-var title='';
-if (EvalString_0==''){
-    if (IdString_0=='')title='';
-    else title='\\t['+IdString_0+']';
-} else {
-    if (IdString_0=='')title='\\t['+EvalString_0+']';
-    else title='\\t['+EvalString_0+','+IdString_0+']';
-}
-if(EvalString_1 && !(/^(up|down)(,hero)?(,([+-]?\d+),([+-]?\d+))?$/.test(EvalString_1))) {
-  throw new Error('对话框效果的用法请右键点击帮助');
-}
-EvalString_1 = EvalString_1 && ('\\b['+EvalString_1+']');
-var code =  '"'+title+EvalString_1+EvalString_2+'",\n';
-return code;
-*/;
-
-autoText_s
-    :   '自动剧情文本: 标题' EvalString? '图像' IdString? '对话框效果' EvalString? '时间' Int BGNL? EvalString Newline
-    
-
-/* autoText_s
-tooltip : autoText：自动剧情文本,用户无法跳过自动剧情文本,大段剧情文本请添加“是否跳过剧情”的提示
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=autotext%EF%BC%9A%E8%87%AA%E5%8A%A8%E5%89%A7%E6%83%85%E6%96%87%E6%9C%AC
-default : ["小妖精","fairy","",3000,"双击方块进入多行编辑\\n自动剧情文本\\n自动剧情文本\\n自动剧情文本"]
-var title='';
-if (EvalString_0==''){
-    if (IdString_0=='')title='';
-    else title='\\t['+IdString_0+']';
-} else {
-    if (IdString_0=='')title='\\t['+EvalString_0+']';
-    else title='\\t['+EvalString_0+','+IdString_0+']';
-}
-if(EvalString_1 && !(/^(up|down)(,hero)?(,([+-]?\d+),([+-]?\d+))?$/.test(EvalString_1))) {
-  throw new Error('对话框效果的用法请右键点击帮助');
-}
-EvalString_1 = EvalString_1 && ('\\b['+EvalString_1+']');
-var code =  '{"type": "autoText", "text": "'+title+EvalString_1+EvalString_2+'", "time" :'+Int_0+'},\n';
-return code;
-*/;
-
-setText_s
-    :   '设置剧情文本的属性' '位置' SetTextPosition_List BGNL? '标题颜色' EvalString? '正文颜色' EvalString? '背景色' EvalString? BGNL? '粗体' B_1_List '打字间隔' EvalString? Newline
-    
-
-/* setText_s
-tooltip : setText：设置剧情文本的属性,颜色为RGB三元组或RGBA四元组,打字间隔为剧情文字添加的时间间隔,为整数或不填
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=settext%EF%BC%9A%E8%AE%BE%E7%BD%AE%E5%89%A7%E6%83%85%E6%96%87%E6%9C%AC%E7%9A%84%E5%B1%9E%E6%80%A7
-default : [null,"","","",null,'']
-SetTextPosition_List_0 =SetTextPosition_List_0==='null'?'': ', "position": "'+SetTextPosition_List_0+'"';
-var colorRe = /^(25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d),(25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d),(25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(,0(\.\d+)?|,1)?$/;
-if (EvalString_0) {
-  if (!colorRe.test(EvalString_0))throw new Error('颜色格式错误,形如:0~255,0~255,0~255,0~1');
-  EvalString_0 = ', "title": ['+EvalString_0+']';
-}
-if (EvalString_1) {
-  if (!colorRe.test(EvalString_1))throw new Error('颜色格式错误,形如:0~255,0~255,0~255,0~1');
-  EvalString_1 = ', "text": ['+EvalString_1+']';
-}
-if (EvalString_2) {
-  if (!colorRe.test(EvalString_2))throw new Error('颜色格式错误,形如:0~255,0~255,0~255,0~1');
-  EvalString_2 = ', "background": ['+EvalString_2+']';
-}
-if (EvalString_3) {
-  if (!/^\d+$/.test(EvalString_3))throw new Error('打字时间间隔必须是整数或不填');
-  EvalString_3 = ', "time": '+EvalString_3;
-}
-B_1_List_0 = ', "bold": '+B_1_List_0;
-var code = '{"type": "setText"'+SetTextPosition_List_0+EvalString_0+EvalString_1+EvalString_2+B_1_List_0+EvalString_3+'},\n';
-return code;
-*/;
-
-tip_s
-    :   '显示提示' ':' EvalString Newline
-    
-
-/* tip_s
-tooltip : tip：显示一段提示文字
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=tip%EF%BC%9A%E6%98%BE%E7%A4%BA%E4%B8%80%E6%AE%B5%E6%8F%90%E7%A4%BA%E6%96%87%E5%AD%97
-default : ["这段话将在左上角以气泡形式显示"]
-var code = '{"type": "tip", "text": "'+EvalString_0+'"},\n';
-return code;
-*/;
-
-setValue_s
-    :   '数值操作' ':' '名称' idString_e '值' expression Newline
-    
-
-/* setValue_s
-tooltip : setValue：设置勇士的某个属性、道具个数, 或某个变量/Flag的值
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=setvalue%EF%BC%9A%E8%AE%BE%E7%BD%AE%E5%8B%87%E5%A3%AB%E7%9A%84%E6%9F%90%E4%B8%AA%E5%B1%9E%E6%80%A7%E3%80%81%E9%81%93%E5%85%B7%E4%B8%AA%E6%95%B0%EF%BC%8C%E6%88%96%E6%9F%90%E4%B8%AA%E5%8F%98%E9%87%8Fflag%E7%9A%84%E5%80%BC
-colour : this.dataColor
-var code = '{"type": "setValue", "name": "'+idString_e_0+'", "value": "'+expression_0+'"},\n';
-return code;
-*/;
-
-show_s
-    :   '显示事件' 'x' EvalString? ',' 'y' EvalString? '楼层' IdString? '动画时间' Int? Newline
-    
-
-/* show_s
-tooltip : show: 将禁用事件启用,楼层和动画时间可不填,xy可用逗号分隔表示多个点
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=show%EF%BC%9A%E5%B0%86%E4%B8%80%E4%B8%AA%E7%A6%81%E7%94%A8%E4%BA%8B%E4%BB%B6%E5%90%AF%E7%94%A8
-default : ["","","",500]
-colour : this.eventColor
-var floorstr = '';
-if (EvalString_0 && EvalString_1) {
-  var pattern1 = /^flag:[0-9a-zA-Z_][0-9a-zA-Z_\-:]*$/;
-  if(pattern1.test(EvalString_0) || pattern1.test(EvalString_1)){
-    EvalString_0=MotaActionFunctions.PosString_pre(EvalString_0);
-    EvalString_1=MotaActionFunctions.PosString_pre(EvalString_1);
-    EvalString_0=[EvalString_0,EvalString_1]
-  } else {
-    var pattern2 = /^([+-]?\d+)(,[+-]?\d+)*$/;
-    if(!pattern2.test(EvalString_0) || !pattern2.test(EvalString_1))throw new Error('坐标格式错误,请右键点击帮助查看格式');
-    EvalString_0=EvalString_0.split(',');
-    EvalString_1=EvalString_1.split(',');
-    if(EvalString_0.length!==EvalString_1.length)throw new Error('坐标格式错误,请右键点击帮助查看格式');
-    for(var ii=0;ii<EvalString_0.length;ii++)EvalString_0[ii]='['+EvalString_0[ii]+','+EvalString_1[ii]+']';
-  }
-  floorstr = ', "loc": ['+EvalString_0.join(',')+']';
-}
-IdString_0 = IdString_0 && (', "floorId": "'+IdString_0+'"');
-Int_0 = Int_0 ?(', "time": '+Int_0):'';
-var code = '{"type": "show"'+floorstr+IdString_0+''+Int_0+'},\n';
-return code;
-*/;
-
-hide_s
-    :   '隐藏事件' 'x' EvalString? ',' 'y' EvalString? '楼层' IdString? '动画时间' Int? Newline
-    
-
-/* hide_s
-tooltip : hide: 将一个启用事件禁用,所有参数均可不填,代表禁用事件自身,xy可用逗号分隔表示多个点
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=hide%EF%BC%9A%E5%B0%86%E4%B8%80%E4%B8%AA%E5%90%AF%E7%94%A8%E4%BA%8B%E4%BB%B6%E7%A6%81%E7%94%A8
-default : ["","","",500]
-colour : this.eventColor
-var floorstr = '';
-if (EvalString_0 && EvalString_1) {
-  var pattern1 = /^flag:[0-9a-zA-Z_][0-9a-zA-Z_\-:]*$/;
-  if(pattern1.test(EvalString_0) || pattern1.test(EvalString_1)){
-    EvalString_0=MotaActionFunctions.PosString_pre(EvalString_0);
-    EvalString_1=MotaActionFunctions.PosString_pre(EvalString_1);
-    EvalString_0=[EvalString_0,EvalString_1]
-  } else {
-    var pattern2 = /^([+-]?\d+)(,[+-]?\d+)*$/;
-    if(!pattern2.test(EvalString_0) || !pattern2.test(EvalString_1))throw new Error('坐标格式错误,请右键点击帮助查看格式');
-    EvalString_0=EvalString_0.split(',');
-    EvalString_1=EvalString_1.split(',');
-    if(EvalString_0.length!==EvalString_1.length)throw new Error('坐标格式错误,请右键点击帮助查看格式');
-    for(var ii=0;ii<EvalString_0.length;ii++)EvalString_0[ii]='['+EvalString_0[ii]+','+EvalString_1[ii]+']';
-  }
-  floorstr = ', "loc": ['+EvalString_0.join(',')+']';
-}
-IdString_0 = IdString_0 && (', "floorId": "'+IdString_0+'"');
-Int_0 = Int_0 ?(', "time": '+Int_0):'';
-var code = '{"type": "hide"'+floorstr+IdString_0+''+Int_0+'},\n';
-return code;
-*/;
-
-trigger_s
-    :   '触发事件' 'x' PosString ',' 'y' PosString Newline
-    
-
-/* trigger_s
-tooltip : trigger: 立即触发另一个地点的事件
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=trigger%EF%BC%9A%E7%AB%8B%E5%8D%B3%E8%A7%A6%E5%8F%91%E5%8F%A6%E4%B8%80%E4%B8%AA%E5%9C%B0%E7%82%B9%E7%9A%84%E4%BA%8B%E4%BB%B6
-default : ["0","0"]
-colour : this.eventColor
-var code = '{"type": "trigger", "loc": ['+PosString_0+','+PosString_1+']},\n';
-return code;
-*/;
-
-revisit_s
-    :   '重启当前事件' Newline
-    
-
-/* revisit_s
-tooltip : revisit: 立即重启当前事件
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=revisit%EF%BC%9A%E7%AB%8B%E5%8D%B3%E9%87%8D%E5%90%AF%E5%BD%93%E5%89%8D%E4%BA%8B%E4%BB%B6
-colour : this.eventColor
-var code = '{"type": "revisit"},\n';
-return code;
-*/;
-
-exit_s
-    :   '立刻结束当前事件' Newline
-    
-
-/* exit_s
-tooltip : exit: 立刻结束当前事件
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=exit%EF%BC%9A%E7%AB%8B%E5%88%BB%E7%BB%93%E6%9D%9F%E5%BD%93%E5%89%8D%E4%BA%8B%E4%BB%B6
-colour : this.eventColor
-var code = '{"type": "exit"},\n';
-return code;
-*/;
-
-setBlock_s
-    :   '转变图块为' Int 'x' PosString? ',' 'y' PosString? '楼层' IdString? Newline
-    
-
-/* setBlock_s
-tooltip : setBlock：设置某个图块,忽略坐标楼层则为当前事件
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=setblock%EF%BC%9A%E8%AE%BE%E7%BD%AE%E6%9F%90%E4%B8%AA%E5%9B%BE%E5%9D%97
-colour : this.dataColor
-default : [0,"","",""]
-var floorstr = '';
-if (PosString_0 && PosString_1) {
-    floorstr = ', "loc": ['+PosString_0+','+PosString_1+']';
-}
-IdString_0 = IdString_0 && (', "floorId": "'+IdString_0+'"');
-var code = '{"type": "setBlock", "number":'+Int_0+floorstr+IdString_0+'},\n';
-return code;
-*/;
-
-setHeroIcon_s
-    :   '更改角色行走图' EvalString? Newline
-    
-
-/* setHeroIcon_s
-tooltip : setHeroIcon：更改角色行走图
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=setheroicon%EF%BC%9A%E6%9B%B4%E6%94%B9%E8%A7%92%E8%89%B2%E8%A1%8C%E8%B5%B0%E5%9B%BE
-colour : this.dataColor
-default : ["hero.png"]
-EvalString_0 = EvalString_0 && (', "name": "'+EvalString_0+'"');
-var code = '{"type": "setHeroIcon"'+EvalString_0+'},\n';
-return code;
-*/;
-
-update_s
-    :   '更新状态栏和地图显伤' Newline
-    
-
-/* update_s
-tooltip : update: 立刻更新状态栏和地图显伤
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=update%EF%BC%9A%E7%AB%8B%E5%88%BB%E6%9B%B4%E6%96%B0%E7%8A%B6%E6%80%81%E6%A0%8F%E5%92%8C%E5%9C%B0%E5%9B%BE%E6%98%BE%E4%BC%A4
-colour : this.dataColor
-var code = '{"type": "update"},\n';
-return code;
-*/;
-
-updateEnemys_s
-    :   '更新怪物数据' Newline
-
-
-/* updateEnemys_s
-tooltip : updateEnemys: 立刻更新怪物数据
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=updateEnemys%ef%bc%9a%e6%9b%b4%e6%96%b0%e6%80%aa%e7%89%a9%e6%95%b0%e6%8d%ae
-colour : this.dataColor
-var code = '{"type": "updateEnemys"},\n';
-return code;
-*/;
-
-sleep_s
-    :   '等待' Int '毫秒' Newline
-    
-
-/* sleep_s
-tooltip : sleep: 等待多少毫秒
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=sleep%EF%BC%9A%E7%AD%89%E5%BE%85%E5%A4%9A%E5%B0%91%E6%AF%AB%E7%A7%92
-default : [500]
-colour : this.soundColor
-var code = '{"type": "sleep", "time": '+Int_0+'},\n';
-return code;
-*/;
-
-battle_s
-    :   '强制战斗' IdString Newline
-    
-
-/* battle_s
-tooltip : battle: 强制战斗
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=battle%EF%BC%9A%E5%BC%BA%E5%88%B6%E6%88%98%E6%96%97
-default : ["greenSlime"]
-colour : this.dataColor
-var code = '{"type": "battle", "id": "'+IdString_0+'"},\n';
-return code;
-*/;
-
-openDoor_s
-    :   '开门' 'x' PosString? ',' 'y' PosString? '楼层' IdString? Newline
-    
-
-/* openDoor_s
-tooltip : openDoor: 开门,楼层可不填表示当前层
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=opendoor%EF%BC%9A%E5%BC%80%E9%97%A8
-default : ["","",""]
-colour : this.dataColor
-IdString_0 = IdString_0 && (', "floorId": "'+IdString_0+'"');
-var floorstr = '';
-if (PosString_0 && PosString_1) {
-    floorstr = ', "loc": ['+PosString_0+','+PosString_1+']';
-}
-var code = '{"type": "openDoor"'+floorstr+IdString_0+'},\n';
-return code;
-*/;
-
-changeFloor_s
-    :   '楼层切换' IdString? 'x' PosString? ',' 'y' PosString? '朝向' DirectionEx_List '动画时间' Int? Newline
-    
-
-/* changeFloor_s
-tooltip : changeFloor: 楼层切换,动画时间可不填
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=changefloor%EF%BC%9A%E6%A5%BC%E5%B1%82%E5%88%87%E6%8D%A2
-default : ["MT1","0","0",null,500]
-colour : this.dataColor
-DirectionEx_List_0 = DirectionEx_List_0 && (', "direction": "'+DirectionEx_List_0+'"');
-Int_0 = Int_0 ?(', "time": '+Int_0):'';
-var floorstr = '';
-if (PosString_0 && PosString_1) {
-    floorstr = ', "loc": ['+PosString_0+','+PosString_1+']';
-}
-var code = '{"type": "changeFloor", "floorId": "'+IdString_0+'"'+floorstr+DirectionEx_List_0+Int_0+' },\n';
-return code;
-*/;
-
-changePos_0_s
-    :   '位置切换' 'x' PosString ',' 'y' PosString '朝向' DirectionEx_List Newline
-    
-
-/* changePos_0_s
-tooltip : changePos: 当前位置切换
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=changepos%EF%BC%9A%E5%BD%93%E5%89%8D%E4%BD%8D%E7%BD%AE%E5%88%87%E6%8D%A2%E5%8B%87%E5%A3%AB%E8%BD%AC%E5%90%91
-default : ["","",null]
-colour : this.dataColor
-DirectionEx_List_0 = DirectionEx_List_0 && (', "direction": "'+DirectionEx_List_0+'"');
-var code = '{"type": "changePos", "loc": ['+PosString_0+','+PosString_1+']'+DirectionEx_List_0+'},\n';
-return code;
-*/;
-
-changePos_1_s
-    :   '勇士转向' Direction_List Newline
-    
-
-/* changePos_1_s
-tooltip : changePos: 勇士转向
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=changepos%EF%BC%9A%E5%BD%93%E5%89%8D%E4%BD%8D%E7%BD%AE%E5%88%87%E6%8D%A2%E5%8B%87%E5%A3%AB%E8%BD%AC%E5%90%91
-colour : this.dataColor
-default : [null]
-var code = '{"type": "changePos", "direction": "'+Direction_List_0+'"},\n';
-return code;
-*/;
-
-openShop_s
-    :   '打开全局商店' IdString Newline
-    
-
-/* openShop_s
-tooltip : 全局商店
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=openshop%EF%BC%9A%E6%89%93%E5%BC%80%E4%B8%80%E4%B8%AA%E5%85%A8%E5%B1%80%E5%95%86%E5%BA%97
-colour : this.dataColor
-default : ["shop1"]
-var code = '{"type": "openShop", "id": "'+IdString_0+'"},\n';
-return code;
-*/;
-
-disableShop_s
-    :   '禁用全局商店' IdString Newline
-    
-
-/* disableShop_s
-tooltip : 全局商店
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=disableshop%EF%BC%9A%E7%A6%81%E7%94%A8%E4%B8%80%E4%B8%AA%E5%85%A8%E5%B1%80%E5%95%86%E5%BA%97
-default : ["shop1"]
-colour : this.eventColor
-var code = '{"type": "disableShop", "id": "'+IdString_0+'"},\n';
-return code;
-*/;
-
-follow_s
-    :   '跟随勇士' '行走图' EvalString Newline
-
-
-/* follow_s
-tooltip : follow: 跟随勇士
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=follow%ef%bc%9a%e8%b7%9f%e9%9a%8f%e5%8b%87%e5%a3%ab
-default : ["npc.png"]
-colour : this.dataColor
-var code = '{"type": "follow", "name": "'+EvalString_0+'"},\n';
-return code;
-*/;
-
-unfollow_s
-    :   '取消跟随' '行走图' EvalString? Newline
-
-
-/* unfollow_s
-tooltip : unfollow: 取消跟随
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=unfollow%ef%bc%9a%e5%8f%96%e6%b6%88%e8%b7%9f%e9%9a%8f
-default : [""]
-colour : this.dataColor
-EvalString_0 = EvalString_0 ? (', "name": "' + EvalString_0 + '"') : "";
-var code = '{"type": "unfollow"' + EvalString_0 + '},\n';
-return code;
-*/;
-
-viberate_s
-    :   '画面震动' '时间' Int Newline
-
-
-/* viberate_s
-tooltip : viberate: 画面震动
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=viberate%ef%bc%9a%e7%94%bb%e9%9d%a2%e9%9c%87%e5%8a%a8
-default : [2000]
-colour : this.soundColor
-Int_0 = Int_0 ?(', "time": '+Int_0):'';
-var code = '{"type": "viberate"' + Int_0 + '},\n';
-return code;
-*/;
-
-animate_s
-    :   '显示动画' IdString '位置' EvalString? Newline
-    
-
-/* animate_s
-tooltip : animate：显示动画,位置填hero或者1,2形式的位置,或者不填代表当前事件点
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=animate%EF%BC%9A%E6%98%BE%E7%A4%BA%E5%8A%A8%E7%94%BB
-default : ["zone","hero"]
-colour : this.soundColor
-if (EvalString_0) {
-  if(/^flag:[0-9a-zA-Z_][0-9a-zA-Z_\-]*,flag:[0-9a-zA-Z_][0-9a-zA-Z_\-]*$/.test(EvalString_0)) {
-    EvalString_0=', "loc": ["'+EvalString_0.split(',').join('","')+'"]';
-  } else if (/hero|([+-]?\d+),([+-]?\d+)/.test(EvalString_0)) {
-    if(EvalString_0.indexOf(',')!==-1)EvalString_0='['+EvalString_0+']';
-    else EvalString_0='"'+EvalString_0+'"';
-    EvalString_0 = ', "loc": '+EvalString_0;
-  } else {
-    throw new Error('此处只能填hero或者1,2形式的位置,或者不填代表当前事件点');
-  }
-}
-var code = '{"type": "animate", "name": "'+IdString_0+'"'+EvalString_0+'},\n';
-return code;
-*/;
-
-showImage_0_s
-    :   '显示图片' EvalString '起点像素位置' 'x' PosString 'y' PosString Newline
-    
-
-/* showImage_0_s
-tooltip : showImage：显示图片
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=showimage%EF%BC%9A%E6%98%BE%E7%A4%BA%E5%9B%BE%E7%89%87
-default : ["bg.jpg","0","0"]
-colour : this.printColor
-var code = '{"type": "showImage", "name": "'+EvalString_0+'", "loc": ['+PosString_0+','+PosString_1+']},\n';
-return code;
-*/;
-
-showImage_1_s
-    :   '清除所有图片' Newline
-    
-
-/* showImage_1_s
-tooltip : showImage：清除所有显示的图片
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=showimage%EF%BC%9A%E6%98%BE%E7%A4%BA%E5%9B%BE%E7%89%87
-colour : this.printColor
-var code = '{"type": "showImage"},\n';
-return code;
-*/;
-
-animateImage_0_s
-    : '图片淡入' EvalString '起点像素位置' 'x' PosString 'y' PosString '动画时间' Int Newline
-    
-
-/* animateImage_0_s
-tooltip : animageImage：图片淡入
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=animateimage%EF%BC%9A%E5%9B%BE%E7%89%87%E6%B7%A1%E5%85%A5%E6%B7%A1%E5%87%BA
-default : ["bg.jpg","0","0",500]
-colour : this.printColor
-var code = '{"type": "animateImage", "action": "show", "name": "'+EvalString_0+'", "loc": ['+PosString_0+','+PosString_1+'], "time": '+Int_0+'},\n';
-return code;
-*/;
-
-animateImage_1_s
-    : '图片淡出' EvalString '起点像素位置' 'x' PosString 'y' PosString '动画时间' Int Newline
-    
-
-/* animateImage_1_s
-tooltip : animageImage：图片淡出
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=animateimage%EF%BC%9A%E5%9B%BE%E7%89%87%E6%B7%A1%E5%85%A5%E6%B7%A1%E5%87%BA
-default : ["bg.jpg","0","0",500]
-colour : this.printColor
-var code = '{"type": "animateImage", "action": "hide", "name": "'+EvalString_0+'", "loc": ['+PosString_0+','+PosString_1+'], "time": '+Int_0+'},\n';
-return code;
-*/;
-
-showGif_0_s
-    :   '显示动图' EvalString '起点像素位置' 'x' PosString 'y' PosString Newline
-    
-
-/* showGif_0_s
-tooltip : showGif：显示动图
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=showgif%EF%BC%9A%E6%98%BE%E7%A4%BA%E5%8A%A8%E5%9B%BE
-default : ["bg.gif","0","0"]
-colour : this.printColor
-var code = '{"type": "showGif", "name": "'+EvalString_0+'", "loc": ['+PosString_0+','+PosString_1+']},\n';
-return code;
-*/;
-
-showGif_1_s
-    :   '清除所有动图' Newline
-    
-
-/* showGif_1_s
-tooltip : showGif：清除所有显示的动图
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=showgif%EF%BC%9A%E6%98%BE%E7%A4%BA%E5%8A%A8%E5%9B%BE
-colour : this.printColor
-var code = '{"type": "showGif"},\n';
-return code;
-*/;
-
-moveImage_0_s
-    :   '图片移动' EvalString '起点像素位置' 'x' PosString 'y' PosString BGNL
-        '终点像素位置' 'x' PosString 'y' PosString '移动时间' Int Newline
-    
-
-/* moveImage_0_s
-tooltip : moveImage：图片移动
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=moveimage%EF%BC%9A%E5%9B%BE%E7%89%87%E7%A7%BB%E5%8A%A8
-default : ["bg.jpg","0","0","0","0",500]
-colour : this.printColor
-var code = '{"type": "moveImage", "name": "'+EvalString_0+'", "from": ['+PosString_0+','+PosString_1+'], "to": ['+PosString_2+','+PosString_3+'], "time": '+Int_0+'},\n';
-return code;
-*/;
-
-setFg_0_s
-    :   '更改画面色调' Number ',' Number ',' Number ',' Number '动画时间' Int? Newline
-    
-
-/* setFg_0_s
-tooltip : setFg: 更改画面色调,动画时间可不填
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=setfg%EF%BC%9A%E6%9B%B4%E6%94%B9%E7%94%BB%E9%9D%A2%E8%89%B2%E8%B0%83
-default : [255,255,255,1,500]
-colour : this.soundColor
-var limit = function(v,min,max) {
-    if(v>max) return max;
-    if(v<min) return min;
-    return v;
-}
-Number_0 = limit(Number_0,0,255);
-Number_1 = limit(Number_1,0,255);
-Number_2 = limit(Number_2,0,255);
-Number_3 = limit(Number_3,0,1);
-Int_0 = Int_0 ?(', "time": '+Int_0):'';
-var code = '{"type": "setFg", "color": ['+Number_0+','+Number_1+','+Number_2+','+Number_3+']'+Int_0 +'},\n';
-return code;
-*/;
-
-setFg_1_s
-    :   '恢复画面色调' '动画时间' Int? Newline
-    
-
-/* setFg_1_s
-tooltip : setFg: 恢复画面色调,动画时间可不填
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=setfg%EF%BC%9A%E6%9B%B4%E6%94%B9%E7%94%BB%E9%9D%A2%E8%89%B2%E8%B0%83
-default : [500]
-colour : this.soundColor
-Int_0 = Int_0 ?(', "time": '+Int_0):'';
-var code = '{"type": "setFg"'+Int_0 +'},\n';
-return code;
-*/;
-
-setWeather_s
-    :   '更改天气' Weather_List '强度' Int Newline
-    
-
-/* setWeather_s
-tooltip : setWeather：更改天气
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=setweather%EF%BC%9A%E6%9B%B4%E6%94%B9%E5%A4%A9%E6%B0%94
-default : [null,1]
-colour : this.soundColor
-if(Int_0<1 || Int_0>10) throw new Error('天气的强度等级, 在1-10之间');
-var code = '{"type": "setWeather", "name": "'+Weather_List_0+'", "level": '+Int_0+'},\n';
-if(Weather_List_0==='')code = '{"type": "setWeather"},\n';
-return code;
-*/;
-
-move_s
-    :   '移动事件' 'x' PosString? ',' 'y' PosString? '动画时间' Int? '不消失' Bool BGNL? StepString Newline
-    
-
-/* move_s
-tooltip : move: 让某个NPC/怪物移动,位置可不填代表当前事件
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=move%EF%BC%9A%E8%AE%A9%E6%9F%90%E4%B8%AAnpc%E6%80%AA%E7%89%A9%E7%A7%BB%E5%8A%A8
-default : ["","",500,false,"上右3下2左上左2"]
-colour : this.eventColor
-var floorstr = '';
-if (PosString_0 && PosString_1) {
-    floorstr = ', "loc": ['+PosString_0+','+PosString_1+']';
-}
-Int_0 = Int_0 ?(', "time": '+Int_0):'';
-var code = '{"type": "move"'+floorstr+''+Int_0+', "steps": '+JSON.stringify(StepString_0)+', "keep": '+Bool_0+'},\n';
-return code;
-*/;
-
-moveHero_s
-    :   '移动勇士' '动画时间' Int? BGNL? StepString Newline
-    
-
-/* moveHero_s
-tooltip : moveHero：移动勇士,用这种方式移动勇士的过程中将无视一切地形, 无视一切事件, 中毒状态也不会扣血
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=movehero%EF%BC%9A%E7%A7%BB%E5%8A%A8%E5%8B%87%E5%A3%AB
-default : [500,"上右3下2左上左2"]
-colour : this.dataColor
-Int_0 = Int_0 ?(', "time": '+Int_0):'';
-var code = '{"type": "moveHero"'+Int_0+', "steps": '+JSON.stringify(StepString_0)+'},\n';
-return code;
-*/;
-
-jump_s
-    :   '跳跃事件' '起始 x' PosString? ',' 'y' PosString? '终止 x' PosString? ',' 'y' PosString? '动画时间' Int? '不消失' Bool Newline
-
-
-/* jump_s
-tooltip : jump: 让某个NPC/怪物跳跃
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=jump%EF%BC%9A%E8%AE%A9%E6%9F%90%E4%B8%AANPC%2F%E6%80%AA%E7%89%A9%E8%B7%B3%E8%B7%83
-default : ["","","","",500,true]
-colour : this.eventColor
-var floorstr = '';
-if (PosString_0 && PosString_1) {
-    floorstr += ', "from": ['+PosString_0+','+PosString_1+']';
-}
-if (PosString_2 && PosString_3) {
-    floorstr += ', "to": ['+PosString_2+','+PosString_3+']';
-}
-Int_0 = Int_0 ?(', "time": '+Int_0):'';
-var code = '{"type": "jump"'+floorstr+''+Int_0+', "keep": '+Bool_0+'},\n';
-return code;
-*/;
-
-jumpHero_s
-    :   '跳跃勇士' 'x' PosString? ',' 'y' PosString? '动画时间' Int? Newline
-
-
-/* jumpHero_s
-tooltip : jumpHero: 跳跃勇士
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=jumpHero%EF%BC%9A%E8%B7%B3%E8%B7%83%E5%8B%87%E5%A3%AB
-default : ["","",500]
-colour : this.dataColor
-var floorstr = '';
-if (PosString_0 && PosString_1) {
-    floorstr = ', "loc": ['+PosString_0+','+PosString_1+']';
-}
-Int_0 = Int_0 ?(', "time": '+Int_0):'';
-var code = '{"type": "jumpHero"'+floorstr+Int_0+'},\n';
-return code;
-*/;
-
-playBgm_s
-    :   '播放背景音乐' EvalString Newline
-    
-
-/* playBgm_s
-tooltip : playBgm: 播放背景音乐
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=playbgm%EF%BC%9A%E6%92%AD%E6%94%BE%E8%83%8C%E6%99%AF%E9%9F%B3%E4%B9%90
-default : ["bgm.mp3"]
-colour : this.soundColor
-var code = '{"type": "playBgm", "name": "'+EvalString_0+'"},\n';
-return code;
-*/;
-
-pauseBgm_s
-    :   '暂停背景音乐' Newline
-    
-
-/* pauseBgm_s
-tooltip : pauseBgm: 暂停背景音乐
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=pausebgm%EF%BC%9A%E6%9A%82%E5%81%9C%E8%83%8C%E6%99%AF%E9%9F%B3%E4%B9%90
-colour : this.soundColor
-var code = '{"type": "pauseBgm"},\n';
-return code;
-*/;
-
-resumeBgm_s
-    :   '恢复背景音乐' Newline
-    
-
-/* resumeBgm_s
-tooltip : resumeBgm: 恢复背景音乐
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=resumebgm%EF%BC%9A%E6%81%A2%E5%A4%8D%E8%83%8C%E6%99%AF%E9%9F%B3%E4%B9%90
-colour : this.soundColor
-var code = '{"type": "resumeBgm"},\n';
-return code;
-*/;
-
-playSound_s
-    :   '播放音效' EvalString Newline
-    
-
-/* playSound_s
-tooltip : playSound: 播放音效
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=playsound%EF%BC%9A%E6%92%AD%E6%94%BE%E9%9F%B3%E6%95%88
-default : ["item.mp3"]
-colour : this.soundColor
-var code = '{"type": "playSound", "name": "'+EvalString_0+'"},\n';
-return code;
-*/;
-
-setVolume_s
-    :   '设置音量' Int '渐变时间' Int? Newline
-    
-
-/* setVolume_s
-tooltip : setVolume: 设置音量
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=setvolume%EF%BC%9A%E8%AE%BE%E7%BD%AE%E9%9F%B3%E9%87%8F
-default : [90, 500]
-colour : this.soundColor
-Int_1 = Int_1?(', "time": '+Int_1):""
-var code = '{"type": "setVolume", "value": '+Int_0+Int_1+'},\n';
-return code;
-*/;
-
-win_s
-    :   '游戏胜利,结局' ':' EvalString? '不计入榜单' Bool Newline
-    
-
-/* win_s
-tooltip : win: 获得胜利, 该事件会显示获胜页面, 并重新游戏
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=win%EF%BC%9A%E8%8E%B7%E5%BE%97%E8%83%9C%E5%88%A9
-default : ["",false]
-var code = '{"type": "win", "reason": "'+EvalString_0+'", "norank": '+(Bool_0?1:0)+'},\n';
-return code;
-*/;
-
-lose_s
-    :   '游戏失败,结局' ':' EvalString? Newline
-    
-
-/* lose_s
-tooltip : lose: 游戏失败, 该事件会显示失败页面, 并重新开始游戏
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=lose%EF%BC%9A%E6%B8%B8%E6%88%8F%E5%A4%B1%E8%B4%A5
-default : [""]
-var code = '{"type": "lose", "reason": "'+EvalString_0+'"},\n';
-return code;
-*/;
-
-input_s
-    :   '接受用户输入,提示' ':' EvalString Newline
-    
-
-/* input_s
-tooltip : input：接受用户输入, 事件只能接受非负整数输入, 所有非法的输入将全部变成0
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=input%EF%BC%9A%E6%8E%A5%E5%8F%97%E7%94%A8%E6%88%B7%E8%BE%93%E5%85%A5
-default : ["请输入一个数"]
-colour : this.dataColor
-var code = '{"type": "input", "text": "'+EvalString_0+'"},\n';
-return code;
-*/;
-
-if_s
-    :   '如果' ':' expression BGNL? Newline action+ '否则' ':' BGNL? Newline action+ BEND Newline
-    
-
-/* if_s
-tooltip : if: 条件判断
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=if%EF%BC%9A%E6%9D%A1%E4%BB%B6%E5%88%A4%E6%96%AD
-colour : this.eventColor
-var code = ['{"type": "if", "condition": "',expression_0,'",\n',
-    '"true": [\n',action_0,'],\n',
-    '"false": [\n',action_1,']\n',
-'},\n'].join('');
-return code;
-*/;
-
-choices_s
-    :   '选项' ':' EvalString? BGNL? '标题' EvalString? '图像' IdString? BGNL? Newline choicesContext+ BEND Newline
-
-
-/* choices_s
-tooltip : choices: 给用户提供选项
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=choices%EF%BC%9A%E7%BB%99%E7%94%A8%E6%88%B7%E6%8F%90%E4%BE%9B%E9%80%89%E9%A1%B9
-default : ["","流浪者","woman"]
-var title='';
-if (EvalString_1==''){
-    if (IdString_0=='')title='';
-    else title='\\t['+IdString_0+']';
-} else {
-    if (IdString_0=='')title='\\t['+EvalString_1+']';
-    else title='\\t['+EvalString_1+','+IdString_0+']';
-}
-EvalString_0 = title+EvalString_0;
-EvalString_0 = EvalString_0 ?(', "text": "'+EvalString_0+'"'):'';
-var code = ['{"type": "choices"',EvalString_0,', "choices": [\n',
-    choicesContext_0,
-']},\n'].join('');
-return code;
-*/;
-
-choicesContext
-    :   '子选项' EvalString BGNL? Newline action+
-
-
-/* choicesContext
-tooltip : 选项的选择
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=choices%EF%BC%9A%E7%BB%99%E7%94%A8%E6%88%B7%E6%8F%90%E4%BE%9B%E9%80%89%E9%A1%B9
-default : ["提示文字:红钥匙"]
-colour : this.subColor
-var code = '{"text": "'+EvalString_0+'", "action": [\n'+action_0+']},\n';
-return code;
-*/;
-
-while_s
-    :   '循环处理' '：' '当' expression '时' BGNL? Newline action+ BEND Newline
-
-/* while_s
-tooltip : while：循环处理
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=while%EF%BC%9A%E5%BE%AA%E7%8E%AF%E5%A4%84%E7%90%86
-colour : this.eventColor
-var code = ['{"type": "while", "condition": "',expression_0,'",\n',
-    '"data": [\n',action_0,'],\n',
-'},\n'].join('');
-return code;
-*/;
-
-break_s
-    :   '跳出循环' Newline
-
-/* break_s
-tooltip : break：跳出循环, 如果break事件不在任何循环中被执行，则和exit等价，即会立刻结束当前事件！
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=break%EF%BC%9A%E8%B7%B3%E5%87%BA%E5%BE%AA%E7%8E%AF
-colour : this.eventColor
-var code = '{"type": "break"},\n';
-return code;
-*/;
-
-continue_s
-    :   '继续当前循环' Newline
-
-/* continue_s
-tooltip : continue：继续执行当前循环的下一轮, 如果continue事件不在任何循环中被执行，则和exit等价，即会立刻结束当前事件！
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=continue%EF%BC%9A%E7%BB%A7%E7%BB%AD%E6%89%A7%E8%A1%8C%E5%BD%93%E5%89%8D%E5%BE%AA%E7%8E%AF
-colour : this.eventColor
-var code = '{"type": "continue"},\n';
-return code;
-*/;
-
-
-wait_s
-    :   '等待用户操作并获得按键或点击信息'
-
-
-/* wait_s
-tooltip : wait: 等待用户操作并获得按键或点击信息（具体用法看文档）
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=wait%EF%BC%9A%E7%AD%89%E5%BE%85%E7%94%A8%E6%88%B7%E6%93%8D%E4%BD%9C
-colour : this.soundColor
-var code = '{"type": "wait"},\n';
-return code;
-*/;
-
-function_s
-    :   '自定义JS脚本' BGNL? Newline RawEvalString Newline BEND Newline
-    
-
-/* function_s
-tooltip : 可双击多行编辑，请勿使用异步代码。常见API参见文档附录。
-helpUrl : https://ckcz123.github.io/mota-js/#/event?id=function%EF%BC%9A%E8%87%AA%E5%AE%9A%E4%B9%89js%E8%84%9A%E6%9C%AC
-default : ["alert(core.getStatus(\"atk\"));"]
-colour : this.dataColor
-var code = '{"type": "function", "function": "function(){\\n'+JSON.stringify(RawEvalString_0).slice(1,-1).split('\\\\n').join('\\n')+'\\n}"},\n';
-return code;
-*/;
-
-pass_s
-    :   Newline
-    
-
-/* pass_s
-var code = ' \n';
-return code;
-*/;
-
-statExprSplit : '=== statement ^ === expression v ===' ;
-//===blockly表达式===
-
-expression
-    :   expression Arithmetic_List expression
-    |   negate_e
-    |   bool_e
-    |   idString_e
-    |   evalString_e
-    
-
-/* expression_arithmetic_0
-//todo 修改recieveOrder,根据Arithmetic_List_0不同的值设定不同的recieveOrder
-var code = expression_0 + Arithmetic_List_0 + expression_1;
-var ops = {
-    '^': 'Math.pow('+expression_0+','+expression_1+')',
-    '和': expression_0+' && '+expression_1,
-    '或': expression_0+' || '+expression_1,
-}
-if (ops[Arithmetic_List_0])code = ops[Arithmetic_List_0];
-var orders = {
-    '+': Blockly.JavaScript.ORDER_ADDITION,
-    '-': Blockly.JavaScript.ORDER_SUBTRACTION,
-    '*': Blockly.JavaScript.ORDER_MULTIPLICATION,
-    '/': Blockly.JavaScript.ORDER_DIVISION,
-    '^': Blockly.JavaScript.ORDER_MEMBER, //recieveOrder : ORDER_COMMA
-    '==': Blockly.JavaScript.ORDER_EQUALITY,
-    '!=': Blockly.JavaScript.ORDER_EQUALITY,
-    '>': Blockly.JavaScript.ORDER_RELATIONAL,
-    '<': Blockly.JavaScript.ORDER_RELATIONAL,
-    '>=': Blockly.JavaScript.ORDER_RELATIONAL,
-    '<=': Blockly.JavaScript.ORDER_RELATIONAL,
-    '和': Blockly.JavaScript.ORDER_LOGICAL_AND,
-    '或': Blockly.JavaScript.ORDER_LOGICAL_OR
-}
-return [code, orders[Arithmetic_List_0]];
-*/;
-
-negate_e
-    :   '非' expression
-    
-
-/* negate_e
-//todo 修改recieveOrder : ORDER_LOGICAL_NOT 修改 inputsInline
-var code = '!'+expression_0;
-return [code, Blockly.JavaScript.ORDER_LOGICAL_NOT];
-*/;
-
-bool_e
-    :   Bool
-    
-
-/* bool_e
-var code = Bool_0;
-return [code, Blockly.JavaScript.ORDER_ATOMIC];
-*/;
-
-
-idString_e
-    :   IdString
-    
-
-/* idString_e
-colour : this.idstring_eColor
-default : ["status:hp"]
-var code = IdString_0;
-return [code, Blockly.JavaScript.ORDER_ATOMIC];
-*/;
-
-//这一条不会被antlr识别,总是会被归到idString_e
-idString_1_e
-    :   Id_List ':' IdText
-    
-
-/* idString_1_e
-colour : this.idstring_eColor
-default : [null,"自定义flag"]
-//todo 将其output改成'idString_e'
-var code = Id_List_0+':'+IdText_0;
-return [code, Blockly.JavaScript.ORDER_ATOMIC];
-*/;
-
-//这一条不会被antlr识别,总是会被归到idString_e
-idString_2_e
-    :   FixedId_List
-    
-
-/* idString_2_e
-colour : this.idstring_eColor
-//todo 将其output改成'idString_e'
-var code = FixedId_List_0;
-return [code, Blockly.JavaScript.ORDER_ATOMIC];
-*/;
-
-evalString_e
-    :   EvalString
-    
-
-/* evalString_e
-default : ["值"]
-var code = EvalString_0;
-return [code, Blockly.JavaScript.ORDER_ATOMIC];
-*/;
-
-//===============lexer===============
-
-IdText
-    :   'sdeirughvuiyasdeb'+ //为了被识别为复杂词法规则
-    ;
-
-RawEvalString
-    :   'sdeirughvuiyasdbe'+ //为了被识别为复杂词法规则
-    ;
-
-PosString
-    :   'sdeirughvuiyasbde'+ //为了被识别为复杂词法规则
-    ;
-
-Floor_List
-    :   '楼层ID'|'前一楼'|'后一楼'
-    /*Floor_List ['floorId',':before',':next']*/;
-
-Stair_List
-    :   '坐标'|'上楼梯'|'下楼梯'
-    /*Stair_List ['loc','upFloor','downFloor']*/;
-
-SetTextPosition_List
-    :   '不改变'|'上'|'中'|'下'
-    /*SetTextPosition_List ['null','up','center','down']*/;
-
-ShopUse_List
-    :   '金币' | '经验'
-    /*ShopUse_List ['money','experience']*/;
-
-Arithmetic_List
-    :   '+'|'-'|'*'|'/'|'^'|'=='|'!='|'>'|'<'|'>='|'<='|'和'|'或'
-    ;
-
-Weather_List
-    :   '无'|'雨'|'雪'
-    /*Weather_List ['','rain','snow']*/;
-
-B_0_List
-    :   '不改变'|'不可通行'|'可以通行'
-    /*B_0_List ['null','true','false']*/;
-
-B_1_List
-    :   '不改变'|'设为粗体'|'取消粗体'
-    /*B_1_List ['null','true','false']*/;
-
-Bool:   'TRUE' 
-    |   'FALSE'
-    ;
-
-Int :   '0' | [1-9][0-9]* ; // no leading zeros
-
-Number
-    :   '-'? Int '.' Int EXP?   // 1.35, 1.35E-9, 0.3, -4.5
-    |   '-'? Int EXP            // 1e10 -3e4
-    |   '-'? Int                // -3, 45
-    ;
-fragment EXP : [Ee] [+\-]? Int ; // \- since - means "range" inside [...]
-
-Direction_List
-    :   '上'|'下'|'左'|'右'
-    /*Direction_List ['up','down','left','right']*/;
-
-DirectionEx_List
-    :   '不变'|'上'|'下'|'左'|'右'
-    /*DirectionEx_List ['','up','down','left','right']*/;
-
-StepString
-    :   (Direction_List Int?)+
-    ;
-
-IdString
-    :   [0-9a-zA-Z_][0-9a-zA-Z_:]*
-    ;
-
-FixedId_List
-    :   '生命'|'攻击'|'防御'|'魔防'|'黄钥匙'|'蓝钥匙'|'红钥匙'|'金币'|'经验'
-    /*FixedId_List ['status:hp','status:atk','status:def','status:mdef','item:yellowKey','item:blueKey','item:redKey','status:money','status:experience']*/;
-
-Id_List
-    :   '变量' | '状态' | '物品'
-    /*Id_List ['flag','status','item']*/;
-
-//转blockly后不保留需要加"
-EvalString
-    :   Equote_double (ESC_double | ~["\\])* Equote_double
-    ;
-
-fragment ESC_double :   '\\' (["\\/bfnrt] | UNICODE) ;
-fragment UNICODE : 'u' HEX HEX HEX HEX ;
-fragment HEX : [0-9a-fA-F] ;
-
-BGNL
-    :   'BGNLaergayergfuybgv'
-    ;
-
-MeaningfulSplit : '=== meaningful ^ ===' ;
-
-fragment Equote_double : '"' ;
-
-BSTART
-    :   '开始'
-    ;
-
-BEND:   '结束'
-    ;
-
-Newline
-    :   ('\r' '\n'?| '\n')// -> skip
-    ;
-
-WhiteSpace
-    :   [ \t]+ -> skip
-    ;
-
-BlockComment
-    :   '/*' .*? '*/' -> skip
-    ;
-
-LineComment
-    :   '//' ~[\r\n]* -> skip
-    ;
-
-/* Function_0
-//this.evisitor.recieveOrder='ORDER_NONE';
-this.evisitor.valueColor=330;
-this.evisitor.statementColor=70;
-this.evisitor.entryColor=250;
-
-this.evisitor.idstring_eColor=310;
-this.evisitor.subColor=190;
-this.evisitor.printColor=70;
-this.evisitor.dataColor=130;
-this.evisitor.eventColor=220;
-this.evisitor.soundColor=20;
-*/
-
-/* Function_1
-delete(this.block('negate_e').inputsInline);
-this.block('idString_1_e').output='idString_e';
-this.block('idString_2_e').output='idString_e';
-*/
-
-/* Functions
-
-function ActionParser(){
-}
-
-ActionParser.prototype.parse = function (obj,type) {
-  switch (type) {
-    case 'event':
-      if(!obj)obj={};
-      if(typeof(obj)===typeof('')) obj={'data':[obj]};
-      if(obj instanceof Array) obj={'data':obj};
-      return MotaActionBlocks['event_m'].xmlText([
-        obj.trigger==='action',obj.enable,obj.noPass,obj.displayDamage,this.parseList(obj.data)
-      ]);
-    
-    case 'changeFloor':
-      if(!obj)obj={};
-      if(!this.isset(obj.loc))obj.loc=[0,0];
-      if (obj.floorId==':before'||obj.floorId==':next') {
-        obj.floorType=obj.floorId;
-        delete obj.floorId;
-      }
-      return MotaActionBlocks['changeFloor_m'].xmlText([
-        obj.floorType||'floorId',obj.floorId,obj.stair||'loc',obj.loc[0],obj.loc[1],obj.direction,obj.time||0,!this.isset(obj.portalWithoutTrigger)
-      ]);
-
-    case 'point':
-      if(!obj)obj={};
-      var text_choices = null;
-      for(var ii=obj.choices.length-1,choice;choice=obj.choices[ii];ii--) {
-        text_choices=MotaActionBlocks['choicesContext'].xmlText([
-          choice.text,this.parseList(choice.action),text_choices]);
-      }
-      return MotaActionBlocks['point_m'].xmlText([text_choices]);
-
-    case 'shop':
-      var buildsub = function(obj,parser,next){
-        var text_choices = null;
-        for(var ii=obj.choices.length-1,choice;choice=obj.choices[ii];ii--) {
-          var text_effect = null;
-          var effectList = choice.effect.split(';');
-          for(var jj=effectList.length-1,effect;effect=effectList[jj];jj--) {
-            if(effect.split('+=').length!==2){
-              throw new Error('一个商店效果中必须包含恰好一个"+="');
-            }
-            text_effect=MotaActionBlocks['shopEffect'].xmlText([
-              MotaActionBlocks['idString_e'].xmlText([effect.split('+=')[0]]),
-              MotaActionBlocks['evalString_e'].xmlText([effect.split('+=')[1]]),
-              text_effect]);
-          }
-          text_choices=MotaActionBlocks['shopChoices'].xmlText([
-            choice.text,choice.need||'',text_effect,text_choices]);
-        }
-        return MotaActionBlocks['shopsub'].xmlText([
-          obj.id,obj.name,obj.icon,obj.textInList,obj.use,obj.need,parser.EvalString(obj.text),text_choices,next
-        ]);
-      }
-      var next=null;
-      if(!obj)obj=[];
-      while(obj.length){
-        next=buildsub(obj.pop(),this,next);
-      }
-      return MotaActionBlocks['shop_m'].xmlText([next]);
-    
-    default:
-      return MotaActionBlocks[type+'_m'].xmlText([this.parseList(obj)]);
-  }
-}
-
-////// 开始解析一系列自定义事件 //////
-ActionParser.prototype.parseList = function (list) {
-  if (!this.isset(list)) return MotaActionBlocks['pass_s'].xmlText([],true);
-  if (!(list instanceof Array)) {
-    list = [list];
-  }
-  if (list.length===0) return MotaActionBlocks['pass_s'].xmlText([],true);
-  this.event = {'id': 'action', 'data': {
-    'list': list
-  }}
-  this.next = null;
-  this.result = null;
-  this.parseAction();
-  return this.result;
-}
-
-////// 解析当前自定义事件列表中的最后一个事件 //////
-ActionParser.prototype.parseAction = function() {
-
-  // 事件处理完毕
-  if (this.event.data.list.length==0) {
-    this.result = this.next;
-    this.next = null;
-    return;
-  }
-
-  var data = this.event.data.list.pop();
-  this.event.data.current = data;
-
-  // 不同种类的事件
-
-  // 如果是文字：显示
-  if (typeof data == "string") {
-      data={"type": "text", "text": data}
-  }
-  this.event.data.type=data.type;
-  switch (data.type) {
-    case "_next":
-      this.result = this.next;
-      this.next = data.next;
-      return;
-    case "text": // 文字/对话
-      this.next = MotaActionBlocks['text_0_s'].xmlText([
-        this.EvalString(data.text),this.next]);
-      break;
-    case "autoText": // 自动剧情文本
-      data.time=this.isset(data.time)?data.time:MotaActionBlocks['autoText_s'].fieldDefault[3];
-      this.next = MotaActionBlocks['autoText_s'].xmlText([
-        '','','',data.time,this.EvalString(data.text),this.next]);
-      break;
-    case "setText": // 设置剧情文本的属性
-      var setTextfunc = function(a){return a?JSON.stringify(a).slice(1,-1):null;}
-      data.title=setTextfunc(data.title);
-      data.text=setTextfunc(data.text);
-      data.background=setTextfunc(data.background);
-      this.next = MotaActionBlocks['setText_s'].xmlText([
-        data.position,data.title,data.text,data.background,data.bold,data.time,this.next]);
-      break;
-    case "tip":
-      this.next = MotaActionBlocks['tip_s'].xmlText([
-        data.text,this.next]);
-      break;
-    case "show": // 显示
-      data.loc=data.loc||[];
-      if (!(data.loc[0] instanceof Array))
-        data.loc = [data.loc];
-      var x_str=[],y_str=[];
-      data.loc.forEach(function (t) {
-        x_str.push(t[0]);
-        y_str.push(t[1]);
-      })
-      this.next = MotaActionBlocks['show_s'].xmlText([
-        x_str.join(','),y_str.join(','),data.floorId||'',data.time||0,this.next]);
-      break;
-    case "hide": // 消失
-      data.loc=data.loc||[];
-      if (!(data.loc[0] instanceof Array))
-        data.loc = [data.loc];
-      var x_str=[],y_str=[];
-      data.loc.forEach(function (t) {
-        x_str.push(t[0]);
-        y_str.push(t[1]);
-      })
-      this.next = MotaActionBlocks['hide_s'].xmlText([
-        x_str.join(','),y_str.join(','),data.floorId||'',data.time||0,this.next]);
-      break;
-    case "setBlock": // 设置图块
-      data.loc=data.loc||['',''];
-      this.next = MotaActionBlocks['setBlock_s'].xmlText([
-        data.number||0,data.loc[0],data.loc[1],data.floorId||'',this.next]);
-      break;
-    case "setHeroIcon": // 改变勇士
-      this.next = MotaActionBlocks['setHeroIcon_s'].xmlText([
-        data.name||"",this.next]);
-      break;
-    case "move": // 移动事件
-      data.loc=data.loc||['',''];
-      this.next = MotaActionBlocks['move_s'].xmlText([
-        data.loc[0],data.loc[1],data.time||0,data.keep,this.StepString(data.steps),this.next]);
-      break;
-    case "moveHero":
-      this.next = MotaActionBlocks['moveHero_s'].xmlText([
-        data.time||0,this.StepString(data.steps),this.next]);
-      break;
-    case "jump": // 跳跃事件
-      data.from=data.from||['',''];
-      data.to=data.to||['',''];
-      this.next = MotaActionBlocks['jump_s'].xmlText([
-        data.from[0],data.from[1],data.to[0],data.to[1],data.time||0,data.keep,this.next]);
-      break;
-    case "jumpHero": // 跳跃勇士
-      data.loc=data.loc||['','']
-      this.next = MotaActionBlocks['jumpHero_s'].xmlText([
-        data.loc[0],data.loc[1],data.time||0,this.next]);
-      break;
-    case "changeFloor": // 楼层转换
-      data.loc=data.loc||['','']
-      this.next = MotaActionBlocks['changeFloor_s'].xmlText([
-        data.floorId,data.loc[0],data.loc[1],data.direction,this.time||0,this.next]);
-      break;
-    case "changePos": // 直接更换勇士位置, 不切换楼层
-      if(this.isset(data.loc)){
-        this.next = MotaActionBlocks['changePos_0_s'].xmlText([
-          data.loc[0],data.loc[1],data.direction,this.next]);
-      } else {
-        this.next = MotaActionBlocks['changePos_1_s'].xmlText([
-          data.direction,this.next]);
-      }
-      break;
-    case "follow": // 跟随勇士
-      this.next = MotaActionBlocks['follow_s'].xmlText([data.name||"", this.next]);
-      break;
-    case "unfollow": // 取消跟随
-      this.next = MotaActionBlocks['unfollow_s'].xmlText([data.name||"", this.next]);
-      break;
-    case "animate": // 显示动画
-      var animate_loc = data.loc||'';
-      if(animate_loc && animate_loc!=='hero')animate_loc = animate_loc[0]+','+animate_loc[1];
-      this.next = MotaActionBlocks['animate_s'].xmlText([
-        data.name,animate_loc,this.next]);
-      break;
-    case "viberate": // 画面震动
-      this.next = MotaActionBlocks['viberate_s'].xmlText([data.time||0, this.next]);
-      break;
-    case "showImage": // 显示图片
-      if(this.isset(data.name)){
-        this.next = MotaActionBlocks['showImage_0_s'].xmlText([
-          data.name,data.loc[0],data.loc[1],this.next]);
-      } else {
-        this.next = MotaActionBlocks['showImage_1_s'].xmlText([
-          this.next]);
-      }
-      break;
-    case "animateImage": // 显示图片
-      if(data.action == 'show'){
-        this.next = MotaActionBlocks['animateImage_0_s'].xmlText([
-          data.name,data.loc[0],data.loc[1],data.time,this.next]);
-      } else if (data.action == 'hide') {
-        this.next = MotaActionBlocks['animateImage_1_s'].xmlText([
-          data.name,data.loc[0],data.loc[1],data.time,this.next]);
-      }
-      break;
-    case "showGif": // 显示动图
-      if(this.isset(data.name)){
-        this.next = MotaActionBlocks['showGif_0_s'].xmlText([
-          data.name,data.loc[0],data.loc[1],this.next]);
-        } else {
-          this.next = MotaActionBlocks['showGif_1_s'].xmlText([
-            this.next]);
-        }
-        break;
-    case "moveImage": // 移动图片
-      this.next = MotaActionBlocks['moveImage_0_s'].xmlText([
-        data.name, data.from[0], data.from[1], data.to[0], data.to[1], data.time, this.next
-      ]);
-      break;
-    case "setFg": // 颜色渐变
-      if(this.isset(data.color)){
-        var alpha = data.color[3];
-        if (alpha==undefined || alpha==null) alpha=1;
-        this.next = MotaActionBlocks['setFg_0_s'].xmlText([
-          data.color[0],data.color[1],data.color[2],alpha,data.time||0,this.next]);
-      } else {
-        this.next = MotaActionBlocks['setFg_1_s'].xmlText([
-          data.time||0,this.next]);
-      }
-      break;
-    case "setWeather": // 更改天气
-      this.next = MotaActionBlocks['setWeather_s'].xmlText([
-        data.name||'无',data.level||1,this.next]);
-      break;
-    case "openDoor": // 开一个门, 包括暗墙
-      data.loc=data.loc||['','']
-      this.next = MotaActionBlocks['openDoor_s'].xmlText([
-        data.loc[0],data.loc[1],data.floorId||'',this.next]);
-      break;
-    case "openShop": // 打开一个全局商店
-      this.next = MotaActionBlocks['openShop_s'].xmlText([
-        data.id,this.next]);
-      break;
-    case "disableShop": // 禁用一个全局商店
-      this.next = MotaActionBlocks['disableShop_s'].xmlText([
-        data.id,this.next]);
-      break;
-    case "battle": // 强制战斗
-      this.next = MotaActionBlocks['battle_s'].xmlText([
-        data.id,this.next]);
-      break;
-    case "trigger": // 触发另一个事件；当前事件会被立刻结束。需要另一个地点的事件是有效的
-      this.next = MotaActionBlocks['trigger_s'].xmlText([
-        data.loc[0],data.loc[1],this.next]);
-      break;
-    case "playSound":
-      this.next = MotaActionBlocks['playSound_s'].xmlText([
-        data.name,this.next]);
-      break;
-    case "playBgm":
-      this.next = MotaActionBlocks['playBgm_s'].xmlText([
-        data.name,this.next]);
-      break
-    case "pauseBgm":
-      this.next = MotaActionBlocks['pauseBgm_s'].xmlText([
-        this.next]);
-      break
-    case "resumeBgm":
-      this.next = MotaActionBlocks['resumeBgm_s'].xmlText([
-        this.next]);
-      break
-    case "setVolume":
-      this.next = MotaActionBlocks['setVolume_s'].xmlText([
-        data.value, data.time, this.next]);
-      break
-    case "setValue":
-      this.next = MotaActionBlocks['setValue_s'].xmlText([
-        MotaActionBlocks['idString_e'].xmlText([data.name]),
-        MotaActionBlocks['evalString_e'].xmlText([data.value]),
-        this.next]);
-      break;
-    case "input":
-      this.next = MotaActionBlocks['input_s'].xmlText([
-        data.text,this.next]);
-      break;
-    case "if": // 条件判断
-      this.next = MotaActionBlocks['if_s'].xmlText([
-        MotaActionBlocks['evalString_e'].xmlText([data.condition]),
-        this.insertActionList(data["true"]),
-        this.insertActionList(data["false"]),
-        this.next]);
-      break;
-    case "choices": // 提供选项
-      var text_choices = null;
-      for(var ii=data.choices.length-1,choice;choice=data.choices[ii];ii--) {
-        text_choices=MotaActionBlocks['choicesContext'].xmlText([
-          choice.text,this.insertActionList(choice.action),text_choices]);
-      }
-      this.next = MotaActionBlocks['choices_s'].xmlText([
-        this.isset(data.text)?this.EvalString(data.text):null,'','',text_choices,this.next]);
-      break;
-    case "while": // 循环处理
-      this.next = MotaActionBlocks['while_s'].xmlText([
-        MotaActionBlocks['evalString_e'].xmlText([data.condition]),
-        this.insertActionList(data["data"]),
-        this.next]);
-      break;
-    case "break": // 跳出循环
-      this.next = MotaActionBlocks['break_s'].xmlText([
-        this.next]);
-      break;
-    case "continue": // 继续执行当前循环
-      this.next = MotaActionBlocks['continue_s'].xmlText([
-        this.next]);
-      break;
-    case "win":
-      this.next = MotaActionBlocks['win_s'].xmlText([
-        data.reason,data.norank?true:false,this.next]);
-      break;
-    case "lose":
-      this.next = MotaActionBlocks['lose_s'].xmlText([
-        data.reason,this.next]);
-      break;
-    case "function":
-      var func = data["function"];
-      func=func.split('{').slice(1).join('{').split('}').slice(0,-1).join('}').trim().split('\n').join('\\n');
-      this.next = MotaActionBlocks['function_s'].xmlText([
-        func,this.next]);
-      break;
-    case "update":
-      this.next = MotaActionBlocks['update_s'].xmlText([
-        this.next]);
-      break;
-    case "updateEnemys":
-      this.next = MotaActionBlocks['updateEnemys_s'].xmlText([
-        this.next]);
-      break;
-    case "sleep": // 等待多少毫秒
-      this.next = MotaActionBlocks['sleep_s'].xmlText([
-        data.time,this.next]);
-      break;
-    case "wait": // 等待用户操作
-      this.next = MotaActionBlocks['wait_s'].xmlText([
-        this.next]);
-      break;
-    case "revisit": // 立刻重新执行该事件
-      this.next = MotaActionBlocks['revisit_s'].xmlText([
-        this.next]);
-      break;
-    case "exit": // 立刻结束事件
-      this.next = MotaActionBlocks['exit_s'].xmlText([
-        this.next]);
-      break;
-    default:
-      throw new Error("[警告]出错啦！\n"+data.type+" 事件不被支持...");
-  }
-  this.parseAction();
-  return;
-}
-
-////// 往当前事件列表之后添加一个事件组 //////
-ActionParser.prototype.insertActionList = function (actionList) {
-  if (actionList.length===0) return null;
-  this.event.data.list.push({"type": "_next", "next": this.next});
-  this.event.data.list=this.event.data.list.concat(actionList);
-  this.next = null;
-  this.parseAction();
-  return this.result;
-}
-
-////// 判断某对象是否不为undefined也不会null //////
-ActionParser.prototype.isset = function (val) {
-    if (val === undefined || val === null) {
-        return false;
-    }
-    return true
-}
-
-ActionParser.prototype.StepString = function(steplist) {
-  var stepchar = {
-    'up': '上',
-    'down': '下',
-    'left': '左',
-    'right': '右'
-  }
-  var StepString = [];
-  for(var ii=0,obj;obj=steplist[ii];ii++) {
-    if(typeof(obj)===typeof('')) {
-      StepString.push(stepchar[obj]);
-    } else {
-      StepString.push(stepchar[obj['direction']]);
-      StepString.push(obj['value']);
-    }
-  }
-  return StepString.join('');
-}
-
-ActionParser.prototype.EvalString = function(EvalString) {
-  return EvalString.split('\b').join('\\b').split('\t').join('\\t').split('\n').join('\\n');
-}
-
-MotaActionFunctions.actionParser = new ActionParser();
-
-MotaActionFunctions.workspace = function(){return workspace}
-
-MotaActionFunctions.parse = function(obj,type) {
-  MotaActionFunctions.workspace().clear();
-  xml_text = MotaActionFunctions.actionParser.parse(obj,type||'event');
-  xml = Blockly.Xml.textToDom('<xml>'+xml_text+'</xml>');
-  Blockly.Xml.domToWorkspace(xml, MotaActionFunctions.workspace());
-}
-
-MotaActionFunctions.EvalString_pre = function(EvalString){
-  if (EvalString.indexOf('__door__')!==-1) throw new Error('请修改开门变量__door__，如door1，door2，door3等依次向后。请勿存在两个门使用相同的开门变量。');
-  return EvalString.replace(/([^\\])"/g,'$1\\"').replace(/^"/g,'\\"').replace(/""/g,'"\\"');
-}
-
-MotaActionFunctions.IdString_pre = function(IdString){
-  if (IdString.indexOf('__door__')!==-1) throw new Error('请修改开门变量__door__，如door1，door2，door3等依次向后。请勿存在两个门使用相同的开门变量。');
-  if (IdString && !(/^[0-9a-zA-Z_][0-9a-zA-Z_\-:]*$/.test(IdString)))throw new Error('id: '+IdString+'中包含了0-9 a-z A-Z _ - :之外的字符');
-  return IdString;
-}
-
-MotaActionFunctions.PosString_pre = function(PosString){
-  if (!PosString || /^-?\d+$/.test(PosString)) return PosString;
-  if (!(/^flag:[0-9a-zA-Z_][0-9a-zA-Z_\-:]*$/.test(PosString)))throw new Error(PosString+'中包含了0-9 a-z A-Z _ - :之外的字符,或者是没有以flag: 开头');
-  return '"'+PosString+'"';
-}
-
-MotaActionFunctions.StepString_pre = function(StepString){
-  //StepString='上右3下2左上左2'
-  var route = StepString.replace(/上/g,'U').replace(/下/g,'D').replace(/左/g,'L').replace(/右/g,'R');
-
-  //copyed from core.js
-  var ans=[], index=0;
-
-  var isset = function(a) {
-    if (a == undefined || a == null) {
-      return false;
-    }
-    return true;
-  }
-  var getNumber = function (noparse) {
-    var num="";
-    while (index<route.length && !isNaN(route.charAt(index))) {
-      num+=route.charAt(index++);
-    }
-    if (num.length==0) num="1";
-    return isset(noparse)?num:parseInt(num);
-  }
-
-  while (index<route.length) {
-    var c=route.charAt(index++);
-    var number=getNumber();
-
-    switch (c) {
-      case "U": for (var i=0;i<number;i++) ans.push("up"); break;
-      case "D": for (var i=0;i<number;i++) ans.push("down"); break;
-      case "L": for (var i=0;i<number;i++) ans.push("left"); break;
-      case "R": for (var i=0;i<number;i++) ans.push("right"); break;
-    }
-  }
-  return ans;
-}
-
-*/
\ No newline at end of file
diff --git a/_server/blockly/NOTICE.md b/_server/blockly/NOTICE.md
index d485ba50..cfb13aef 100644
--- a/_server/blockly/NOTICE.md
+++ b/_server/blockly/NOTICE.md
@@ -8,14 +8,6 @@ files
 copyed from  
 https://github.com/google/blockly.git
 
-
-### diff in blockly code
-blocks_compressed.js  
-line 44 ~ 48
-```javascript
-// change by zhaouv @ logic_compare output : "Boolean" -> null
-colour:"%{BKY_LOGIC_HUE}",tooltip:"%{BKYCONTROLS_IF_TOOLTIP_2}",helpUrl:"%{BKY_CONTROLS_IF_HELPURL}",extensions:["controls_if_tooltip"]},{type:"logic_compare",message0:"%1 %2 %3",args0:[{type:"input_value",name:"A"},{type:"field_dropdown",name:"OP",options:[["=","EQ"],["\u2260","NEQ"],["<","LT"],["\u2264","LTE"],[">","GT"],["\u2265","GTE"]]},{type:"input_value",name:"B"}],inputsInline:!0,output:null,colour:"%{BKY_LOGIC_HUE}",helpUrl:"%{BKY_LOGIC_COMPARE_HELPURL}",extensions:["logic_compare",
-// change by zhaouv @ logic_operation output,check : "Boolean" -> null
-// change by zhaouv @ logic_negate output,check : "Boolean" -> null
-"logic_op_tooltip"]},{type:"logic_operation",message0:"%1 %2 %3",args0:[{type:"input_value",name:"A",check:null},{type:"field_dropdown",name:"OP",options:[["%{BKY_LOGIC_OPERATION_AND}","AND"],["%{BKY_LOGIC_OPERATION_OR}","OR"]]},{type:"input_value",name:"B",check:null}],inputsInline:!0,output:null,colour:"%{BKY_LOGIC_HUE}",helpUrl:"%{BKY_LOGIC_OPERATION_HELPURL}",extensions:["logic_op_tooltip"]},{type:"logic_negate",message0:"%{BKY_LOGIC_NEGATE_TITLE}",args0:[{type:"input_value",name:"BOOL",
-```
\ No newline at end of file
+`Converter.bundle.min.js`  
+copyed from  
+https://github.com/zhaouv/antlr-blockly.git
\ No newline at end of file
diff --git a/_server/blockly/blockly_compressed.js b/_server/blockly/blockly_compressed.js
new file mode 100644
index 00000000..bfbb77fc
--- /dev/null
+++ b/_server/blockly/blockly_compressed.js
@@ -0,0 +1,1775 @@
+// Do not edit this file; automatically generated by build.py.
+'use strict';
+
+var $jscomp=$jscomp||{};$jscomp.scope={};var COMPILED=!0,goog=goog||{};goog.global=this;goog.isDef=function(a){return void 0!==a};goog.isString=function(a){return"string"==typeof a};goog.isBoolean=function(a){return"boolean"==typeof a};goog.isNumber=function(a){return"number"==typeof a};
+goog.exportPath_=function(a,b,c){a=a.split(".");c=c||goog.global;a[0]in c||"undefined"==typeof c.execScript||c.execScript("var "+a[0]);for(var d;a.length&&(d=a.shift());)!a.length&&goog.isDef(b)?c[d]=b:c=c[d]&&c[d]!==Object.prototype[d]?c[d]:c[d]={}};
+goog.define=function(a,b){var c=b;if(!COMPILED){var d=goog.global.CLOSURE_UNCOMPILED_DEFINES,e=goog.global.CLOSURE_DEFINES;d&&void 0===d.nodeType&&Object.prototype.hasOwnProperty.call(d,a)?c=d[a]:e&&void 0===e.nodeType&&Object.prototype.hasOwnProperty.call(e,a)&&(c=e[a])}goog.exportPath_(a,c)};goog.DEBUG=!1;goog.LOCALE="en";goog.TRUSTED_SITE=!0;goog.STRICT_MODE_COMPATIBLE=!1;goog.DISALLOW_TEST_ONLY_CODE=COMPILED&&!goog.DEBUG;goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING=!1;
+goog.provide=function(a){if(goog.isInModuleLoader_())throw Error("goog.provide cannot be used within a module.");if(!COMPILED&&goog.isProvided_(a))throw Error('Namespace "'+a+'" already declared.');goog.constructNamespace_(a)};goog.constructNamespace_=function(a,b){if(!COMPILED){delete goog.implicitNamespaces_[a];for(var c=a;(c=c.substring(0,c.lastIndexOf(".")))&&!goog.getObjectByName(c);)goog.implicitNamespaces_[c]=!0}goog.exportPath_(a,b)};
+goog.getScriptNonce=function(a){if(a&&a!=goog.global)return goog.getScriptNonce_(a.document);null===goog.cspNonce_&&(goog.cspNonce_=goog.getScriptNonce_(goog.global.document));return goog.cspNonce_};goog.NONCE_PATTERN_=/^[\w+/_-]+[=]{0,2}$/;goog.cspNonce_=null;goog.getScriptNonce_=function(a){return(a=a.querySelector&&a.querySelector("script[nonce]"))&&(a=a.nonce||a.getAttribute("nonce"))&&goog.NONCE_PATTERN_.test(a)?a:""};goog.VALID_MODULE_RE_=/^[a-zA-Z_$][a-zA-Z0-9._$]*$/;
+goog.module=function(a){if(!goog.isString(a)||!a||-1==a.search(goog.VALID_MODULE_RE_))throw Error("Invalid module identifier");if(!goog.isInGoogModuleLoader_())throw Error("Module "+a+" has been loaded incorrectly. Note, modules cannot be loaded as normal scripts. They require some kind of pre-processing step. You're likely trying to load a module via a script tag or as a part of a concatenated bundle without rewriting the module. For more info see: https://github.com/google/closure-library/wiki/goog.module:-an-ES6-module-like-alternative-to-goog.provide.");
+if(goog.moduleLoaderState_.moduleName)throw Error("goog.module may only be called once per module.");goog.moduleLoaderState_.moduleName=a;if(!COMPILED){if(goog.isProvided_(a))throw Error('Namespace "'+a+'" already declared.');delete goog.implicitNamespaces_[a]}};goog.module.get=function(a){return goog.module.getInternal_(a)};
+goog.module.getInternal_=function(a){if(!COMPILED){if(a in goog.loadedModules_)return goog.loadedModules_[a].exports;if(!goog.implicitNamespaces_[a])return a=goog.getObjectByName(a),null!=a?a:null}return null};goog.ModuleType={ES6:"es6",GOOG:"goog"};goog.moduleLoaderState_=null;goog.isInModuleLoader_=function(){return goog.isInGoogModuleLoader_()||goog.isInEs6ModuleLoader_()};goog.isInGoogModuleLoader_=function(){return!!goog.moduleLoaderState_&&goog.moduleLoaderState_.type==goog.ModuleType.GOOG};
+goog.isInEs6ModuleLoader_=function(){if(goog.moduleLoaderState_&&goog.moduleLoaderState_.type==goog.ModuleType.ES6)return!0;var a=goog.global.$jscomp;return a?"function"!=typeof a.getCurrentModulePath?!1:!!a.getCurrentModulePath():!1};
+goog.module.declareLegacyNamespace=function(){if(!COMPILED&&!goog.isInGoogModuleLoader_())throw Error("goog.module.declareLegacyNamespace must be called from within a goog.module");if(!COMPILED&&!goog.moduleLoaderState_.moduleName)throw Error("goog.module must be called prior to goog.module.declareLegacyNamespace.");goog.moduleLoaderState_.declareLegacyNamespace=!0};
+goog.declareModuleId=function(a){if(!COMPILED){if(!goog.isInEs6ModuleLoader_())throw Error("goog.declareModuleId may only be called from within an ES6 module");if(goog.moduleLoaderState_&&goog.moduleLoaderState_.moduleName)throw Error("goog.declareModuleId may only be called once per module.");if(a in goog.loadedModules_)throw Error('Module with namespace "'+a+'" already exists.');}if(goog.moduleLoaderState_)goog.moduleLoaderState_.moduleName=a;else{var b=goog.global.$jscomp;if(!b||"function"!=typeof b.getCurrentModulePath)throw Error('Module with namespace "'+
+a+'" has been loaded incorrectly.');b=b.require(b.getCurrentModulePath());goog.loadedModules_[a]={exports:b,type:goog.ModuleType.ES6,moduleId:a}}};goog.module.declareNamespace=goog.declareModuleId;goog.setTestOnly=function(a){if(goog.DISALLOW_TEST_ONLY_CODE)throw a=a||"",Error("Importing test-only code into non-debug environment"+(a?": "+a:"."));};goog.forwardDeclare=function(a){};
+COMPILED||(goog.isProvided_=function(a){return a in goog.loadedModules_||!goog.implicitNamespaces_[a]&&goog.isDefAndNotNull(goog.getObjectByName(a))},goog.implicitNamespaces_={"goog.module":!0});goog.getObjectByName=function(a,b){for(var c=a.split("."),d=b||goog.global,e=0;e<c.length;e++)if(d=d[c[e]],!goog.isDefAndNotNull(d))return null;return d};goog.globalize=function(a,b){var c=b||goog.global,d;for(d in a)c[d]=a[d]};
+goog.addDependency=function(a,b,c,d){!COMPILED&&goog.DEPENDENCIES_ENABLED&&goog.debugLoader_.addDependency(a,b,c,d)};goog.ENABLE_DEBUG_LOADER=!0;goog.logToConsole_=function(a){goog.global.console&&goog.global.console.error(a)};
+goog.require=function(a){if(!COMPILED){goog.ENABLE_DEBUG_LOADER&&goog.debugLoader_.requested(a);if(goog.isProvided_(a)){if(goog.isInModuleLoader_())return goog.module.getInternal_(a)}else if(goog.ENABLE_DEBUG_LOADER){var b=goog.moduleLoaderState_;goog.moduleLoaderState_=null;try{goog.debugLoader_.load_(a)}finally{goog.moduleLoaderState_=b}}return null}};goog.requireType=function(a){return{}};goog.basePath="";goog.nullFunction=function(){};
+goog.abstractMethod=function(){throw Error("unimplemented abstract method");};goog.addSingletonGetter=function(a){a.instance_=void 0;a.getInstance=function(){if(a.instance_)return a.instance_;goog.DEBUG&&(goog.instantiatedSingletons_[goog.instantiatedSingletons_.length]=a);return a.instance_=new a}};goog.instantiatedSingletons_=[];goog.LOAD_MODULE_USING_EVAL=!0;goog.SEAL_MODULE_EXPORTS=goog.DEBUG;goog.loadedModules_={};goog.DEPENDENCIES_ENABLED=!COMPILED&&goog.ENABLE_DEBUG_LOADER;goog.TRANSPILE="detect";
+goog.ASSUME_ES_MODULES_TRANSPILED=!1;goog.TRANSPILE_TO_LANGUAGE="";goog.TRANSPILER="transpile.js";goog.hasBadLetScoping=null;goog.useSafari10Workaround=function(){if(null==goog.hasBadLetScoping){try{var a=!eval('"use strict";let x = 1; function f() { return typeof x; };f() == "number";')}catch(b){a=!1}goog.hasBadLetScoping=a}return goog.hasBadLetScoping};goog.workaroundSafari10EvalBug=function(a){return"(function(){"+a+"\n;})();\n"};
+goog.loadModule=function(a){var b=goog.moduleLoaderState_;try{goog.moduleLoaderState_={moduleName:"",declareLegacyNamespace:!1,type:goog.ModuleType.GOOG};if(goog.isFunction(a))var c=a.call(void 0,{});else if(goog.isString(a))goog.useSafari10Workaround()&&(a=goog.workaroundSafari10EvalBug(a)),c=goog.loadModuleFromSource_.call(void 0,a);else throw Error("Invalid module definition");var d=goog.moduleLoaderState_.moduleName;if(goog.isString(d)&&d)goog.moduleLoaderState_.declareLegacyNamespace?goog.constructNamespace_(d,
+c):goog.SEAL_MODULE_EXPORTS&&Object.seal&&"object"==typeof c&&null!=c&&Object.seal(c),goog.loadedModules_[d]={exports:c,type:goog.ModuleType.GOOG,moduleId:goog.moduleLoaderState_.moduleName};else throw Error('Invalid module name "'+d+'"');}finally{goog.moduleLoaderState_=b}};goog.loadModuleFromSource_=function(a){eval(a);return{}};goog.normalizePath_=function(a){a=a.split("/");for(var b=0;b<a.length;)"."==a[b]?a.splice(b,1):b&&".."==a[b]&&a[b-1]&&".."!=a[b-1]?a.splice(--b,2):b++;return a.join("/")};
+goog.loadFileSync_=function(a){if(goog.global.CLOSURE_LOAD_FILE_SYNC)return goog.global.CLOSURE_LOAD_FILE_SYNC(a);try{var b=new goog.global.XMLHttpRequest;b.open("get",a,!1);b.send();return 0==b.status||200==b.status?b.responseText:null}catch(c){return null}};
+goog.transpile_=function(a,b,c){var d=goog.global.$jscomp;d||(goog.global.$jscomp=d={});var e=d.transpile;if(!e){var f=goog.basePath+goog.TRANSPILER,g=goog.loadFileSync_(f);if(g){(function(){eval(g+"\n//# sourceURL="+f)}).call(goog.global);if(goog.global.$gwtExport&&goog.global.$gwtExport.$jscomp&&!goog.global.$gwtExport.$jscomp.transpile)throw Error('The transpiler did not properly export the "transpile" method. $gwtExport: '+JSON.stringify(goog.global.$gwtExport));goog.global.$jscomp.transpile=
+goog.global.$gwtExport.$jscomp.transpile;d=goog.global.$jscomp;e=d.transpile}}e||(e=d.transpile=function(a,b){goog.logToConsole_(b+" requires transpilation but no transpiler was found.");return a});return e(a,b,c)};
+goog.typeOf=function(a){var b=typeof a;if("object"==b)if(a){if(a instanceof Array)return"array";if(a instanceof Object)return b;var c=Object.prototype.toString.call(a);if("[object Window]"==c)return"object";if("[object Array]"==c||"number"==typeof a.length&&"undefined"!=typeof a.splice&&"undefined"!=typeof a.propertyIsEnumerable&&!a.propertyIsEnumerable("splice"))return"array";if("[object Function]"==c||"undefined"!=typeof a.call&&"undefined"!=typeof a.propertyIsEnumerable&&!a.propertyIsEnumerable("call"))return"function"}else return"null";
+else if("function"==b&&"undefined"==typeof a.call)return"object";return b};goog.isNull=function(a){return null===a};goog.isDefAndNotNull=function(a){return null!=a};goog.isArray=function(a){return"array"==goog.typeOf(a)};goog.isArrayLike=function(a){var b=goog.typeOf(a);return"array"==b||"object"==b&&"number"==typeof a.length};goog.isDateLike=function(a){return goog.isObject(a)&&"function"==typeof a.getFullYear};goog.isFunction=function(a){return"function"==goog.typeOf(a)};
+goog.isObject=function(a){var b=typeof a;return"object"==b&&null!=a||"function"==b};goog.getUid=function(a){return a[goog.UID_PROPERTY_]||(a[goog.UID_PROPERTY_]=++goog.uidCounter_)};goog.hasUid=function(a){return!!a[goog.UID_PROPERTY_]};goog.removeUid=function(a){null!==a&&"removeAttribute"in a&&a.removeAttribute(goog.UID_PROPERTY_);try{delete a[goog.UID_PROPERTY_]}catch(b){}};goog.UID_PROPERTY_="closure_uid_"+(1E9*Math.random()>>>0);goog.uidCounter_=0;goog.getHashCode=goog.getUid;
+goog.removeHashCode=goog.removeUid;goog.cloneObject=function(a){var b=goog.typeOf(a);if("object"==b||"array"==b){if("function"===typeof a.clone)return a.clone();b="array"==b?[]:{};for(var c in a)b[c]=goog.cloneObject(a[c]);return b}return a};goog.bindNative_=function(a,b,c){return a.call.apply(a.bind,arguments)};
+goog.bindJs_=function(a,b,c){if(!a)throw Error();if(2<arguments.length){var d=Array.prototype.slice.call(arguments,2);return function(){var c=Array.prototype.slice.call(arguments);Array.prototype.unshift.apply(c,d);return a.apply(b,c)}}return function(){return a.apply(b,arguments)}};goog.bind=function(a,b,c){Function.prototype.bind&&-1!=Function.prototype.bind.toString().indexOf("native code")?goog.bind=goog.bindNative_:goog.bind=goog.bindJs_;return goog.bind.apply(null,arguments)};
+goog.partial=function(a,b){var c=Array.prototype.slice.call(arguments,1);return function(){var b=c.slice();b.push.apply(b,arguments);return a.apply(this,b)}};goog.mixin=function(a,b){for(var c in b)a[c]=b[c]};goog.now=goog.TRUSTED_SITE&&Date.now||function(){return+new Date};
+goog.globalEval=function(a){if(goog.global.execScript)goog.global.execScript(a,"JavaScript");else if(goog.global.eval){if(null==goog.evalWorksForGlobals_){try{goog.global.eval("var _evalTest_ = 1;")}catch(d){}if("undefined"!=typeof goog.global._evalTest_){try{delete goog.global._evalTest_}catch(d){}goog.evalWorksForGlobals_=!0}else goog.evalWorksForGlobals_=!1}if(goog.evalWorksForGlobals_)goog.global.eval(a);else{var b=goog.global.document,c=b.createElement("SCRIPT");c.type="text/javascript";c.defer=
+!1;c.appendChild(b.createTextNode(a));b.head.appendChild(c);b.head.removeChild(c)}}else throw Error("goog.globalEval not available");};goog.evalWorksForGlobals_=null;
+goog.getCssName=function(a,b){if("."==String(a).charAt(0))throw Error('className passed in goog.getCssName must not start with ".". You passed: '+a);var c=function(a){return goog.cssNameMapping_[a]||a},d=function(a){a=a.split("-");for(var b=[],d=0;d<a.length;d++)b.push(c(a[d]));return b.join("-")};d=goog.cssNameMapping_?"BY_WHOLE"==goog.cssNameMappingStyle_?c:d:function(a){return a};d=b?a+"-"+d(b):d(a);return goog.global.CLOSURE_CSS_NAME_MAP_FN?goog.global.CLOSURE_CSS_NAME_MAP_FN(d):d};
+goog.setCssNameMapping=function(a,b){goog.cssNameMapping_=a;goog.cssNameMappingStyle_=b};!COMPILED&&goog.global.CLOSURE_CSS_NAME_MAPPING&&(goog.cssNameMapping_=goog.global.CLOSURE_CSS_NAME_MAPPING);goog.getMsg=function(a,b){b&&(a=a.replace(/\{\$([^}]+)}/g,function(a,d){return null!=b&&d in b?b[d]:a}));return a};goog.getMsgWithFallback=function(a,b){return a};goog.exportSymbol=function(a,b,c){goog.exportPath_(a,b,c)};goog.exportProperty=function(a,b,c){a[b]=c};
+goog.inherits=function(a,b){function c(){}c.prototype=b.prototype;a.superClass_=b.prototype;a.prototype=new c;a.prototype.constructor=a;a.base=function(a,c,f){for(var d=Array(arguments.length-2),e=2;e<arguments.length;e++)d[e-2]=arguments[e];return b.prototype[c].apply(a,d)}};
+goog.base=function(a,b,c){var d=arguments.callee.caller;if(goog.STRICT_MODE_COMPATIBLE||goog.DEBUG&&!d)throw Error("arguments.caller not defined.  goog.base() cannot be used with strict mode code. See http://www.ecma-international.org/ecma-262/5.1/#sec-C");if("undefined"!==typeof d.superClass_){for(var e=Array(arguments.length-1),f=1;f<arguments.length;f++)e[f-1]=arguments[f];return d.superClass_.constructor.apply(a,e)}if("string"!=typeof b&&"symbol"!=typeof b)throw Error("method names provided to goog.base must be a string or a symbol");
+e=Array(arguments.length-2);for(f=2;f<arguments.length;f++)e[f-2]=arguments[f];f=!1;for(var g=a.constructor;g;g=g.superClass_&&g.superClass_.constructor)if(g.prototype[b]===d)f=!0;else if(f)return g.prototype[b].apply(a,e);if(a[b]===d)return a.constructor.prototype[b].apply(a,e);throw Error("goog.base called from a method of one name to a method of a different name");};goog.scope=function(a){if(goog.isInModuleLoader_())throw Error("goog.scope is not supported within a module.");a.call(goog.global)};
+COMPILED||(goog.global.COMPILED=COMPILED);goog.defineClass=function(a,b){var c=b.constructor,d=b.statics;c&&c!=Object.prototype.constructor||(c=function(){throw Error("cannot instantiate an interface (no constructor defined).");});c=goog.defineClass.createSealingConstructor_(c,a);a&&goog.inherits(c,a);delete b.constructor;delete b.statics;goog.defineClass.applyProperties_(c.prototype,b);null!=d&&(d instanceof Function?d(c):goog.defineClass.applyProperties_(c,d));return c};
+goog.defineClass.SEAL_CLASS_INSTANCES=goog.DEBUG;goog.defineClass.createSealingConstructor_=function(a,b){if(!goog.defineClass.SEAL_CLASS_INSTANCES)return a;var c=!goog.defineClass.isUnsealable_(b),d=function(){var b=a.apply(this,arguments)||this;b[goog.UID_PROPERTY_]=b[goog.UID_PROPERTY_];this.constructor===d&&c&&Object.seal instanceof Function&&Object.seal(b);return b};return d};goog.defineClass.isUnsealable_=function(a){return a&&a.prototype&&a.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_]};
+goog.defineClass.OBJECT_PROTOTYPE_FIELDS_="constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf".split(" ");goog.defineClass.applyProperties_=function(a,b){for(var c in b)Object.prototype.hasOwnProperty.call(b,c)&&(a[c]=b[c]);for(var d=0;d<goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length;d++)c=goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[d],Object.prototype.hasOwnProperty.call(b,c)&&(a[c]=b[c])};
+goog.tagUnsealableClass=function(a){!COMPILED&&goog.defineClass.SEAL_CLASS_INSTANCES&&(a.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_]=!0)};goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_="goog_defineClass_legacy_unsealable";
+!COMPILED&&goog.DEPENDENCIES_ENABLED&&(goog.inHtmlDocument_=function(){var a=goog.global.document;return null!=a&&"write"in a},goog.isDocumentLoading_=function(){var a=goog.global.document;return a.attachEvent?"complete"!=a.readyState:"loading"==a.readyState},goog.findBasePath_=function(){if(goog.isDef(goog.global.CLOSURE_BASE_PATH)&&goog.isString(goog.global.CLOSURE_BASE_PATH))goog.basePath=goog.global.CLOSURE_BASE_PATH;else if(goog.inHtmlDocument_()){var a=goog.global.document,b=a.currentScript;
+a=b?[b]:a.getElementsByTagName("SCRIPT");for(b=a.length-1;0<=b;--b){var c=a[b].src,d=c.lastIndexOf("?");d=-1==d?c.length:d;if("base.js"==c.substr(d-7,7)){goog.basePath=c.substr(0,d-7);break}}}},goog.findBasePath_(),goog.Transpiler=function(){this.requiresTranspilation_=null;this.transpilationTarget_=goog.TRANSPILE_TO_LANGUAGE},goog.Transpiler.prototype.createRequiresTranspilation_=function(){function a(a,b){e?d[a]=!0:b()?(c=a,d[a]=!1):e=d[a]=!0}function b(a){try{return!!eval(a)}catch(h){return!1}}
+var c="es3",d={es3:!1},e=!1,f=goog.global.navigator&&goog.global.navigator.userAgent?goog.global.navigator.userAgent:"";a("es5",function(){return b("[1,].length==1")});a("es6",function(){return f.match(/Edge\/(\d+)(\.\d)*/i)?!1:b('(()=>{"use strict";class X{constructor(){if(new.target!=String)throw 1;this.x=42}}let q=Reflect.construct(X,[],String);if(q.x!=42||!(q instanceof String))throw 1;for(const a of[2,3]){if(a==2)continue;function f(z={a}){let a=0;return z.a}{function f(){return 0;}}return f()==3}})()')});
+a("es6-impl",function(){return!0});a("es7",function(){return b("2 ** 2 == 4")});a("es8",function(){return b("async () => 1, true")});a("es9",function(){return b("({...rest} = {}), true")});a("es_next",function(){return!1});return{target:c,map:d}},goog.Transpiler.prototype.needsTranspile=function(a,b){if("always"==goog.TRANSPILE)return!0;if("never"==goog.TRANSPILE)return!1;if(!this.requiresTranspilation_){var c=this.createRequiresTranspilation_();this.requiresTranspilation_=c.map;this.transpilationTarget_=
+this.transpilationTarget_||c.target}if(a in this.requiresTranspilation_)return this.requiresTranspilation_[a]?!0:!goog.inHtmlDocument_()||"es6"!=b||"noModule"in goog.global.document.createElement("script")?!1:!0;throw Error("Unknown language mode: "+a);},goog.Transpiler.prototype.transpile=function(a,b){return goog.transpile_(a,b,this.transpilationTarget_)},goog.transpiler_=new goog.Transpiler,goog.protectScriptTag_=function(a){return a.replace(/<\/(SCRIPT)/ig,"\\x3c/$1")},goog.DebugLoader_=function(){this.dependencies_=
+{};this.idToPath_={};this.written_={};this.loadingDeps_=[];this.depsToLoad_=[];this.paused_=!1;this.factory_=new goog.DependencyFactory(goog.transpiler_);this.deferredCallbacks_={};this.deferredQueue_=[]},goog.DebugLoader_.prototype.bootstrap=function(a,b){function c(){d&&(goog.global.setTimeout(d,0),d=null)}var d=b;if(a.length){for(var e=[],f=0;f<a.length;f++){var g=this.getPathFromDeps_(a[f]);if(!g)throw Error("Unregonized namespace: "+a[f]);e.push(this.dependencies_[g])}g=goog.require;var h=0;
+for(f=0;f<a.length;f++)g(a[f]),e[f].onLoad(function(){++h==a.length&&c()})}else c()},goog.DebugLoader_.prototype.loadClosureDeps=function(){this.depsToLoad_.push(this.factory_.createDependency(goog.normalizePath_(goog.basePath+"deps.js"),"deps.js",[],[],{},!1));this.loadDeps_()},goog.DebugLoader_.prototype.requested=function(a,b){var c=this.getPathFromDeps_(a);if(c&&(b||this.areDepsLoaded_(this.dependencies_[c].requires))){var d=this.deferredCallbacks_[c];d&&(delete this.deferredCallbacks_[c],d())}},
+goog.DebugLoader_.prototype.setDependencyFactory=function(a){this.factory_=a},goog.DebugLoader_.prototype.load_=function(a){if(this.getPathFromDeps_(a)){var b=this,c=[],d=function(a){var e=b.getPathFromDeps_(a);if(!e)throw Error("Bad dependency path or symbol: "+a);if(!b.written_[e]){b.written_[e]=!0;a=b.dependencies_[e];for(e=0;e<a.requires.length;e++)goog.isProvided_(a.requires[e])||d(a.requires[e]);c.push(a)}};d(a);a=!!this.depsToLoad_.length;this.depsToLoad_=this.depsToLoad_.concat(c);this.paused_||
+a||this.loadDeps_()}else throw a="goog.require could not find: "+a,goog.logToConsole_(a),Error(a);},goog.DebugLoader_.prototype.loadDeps_=function(){for(var a=this,b=this.paused_;this.depsToLoad_.length&&!b;)(function(){var c=!1,d=a.depsToLoad_.shift(),e=!1;a.loading_(d);var f={pause:function(){if(c)throw Error("Cannot call pause after the call to load.");b=!0},resume:function(){c?a.resume_():b=!1},loaded:function(){if(e)throw Error("Double call to loaded.");e=!0;a.loaded_(d)},pending:function(){for(var b=
+[],c=0;c<a.loadingDeps_.length;c++)b.push(a.loadingDeps_[c]);return b},setModuleState:function(a){goog.moduleLoaderState_={type:a,moduleName:"",declareLegacyNamespace:!1}},registerEs6ModuleExports:function(a,b,c){c&&(goog.loadedModules_[c]={exports:b,type:goog.ModuleType.ES6,moduleId:c||""})},registerGoogModuleExports:function(a,b){goog.loadedModules_[a]={exports:b,type:goog.ModuleType.GOOG,moduleId:a}},clearModuleState:function(){goog.moduleLoaderState_=null},defer:function(b){if(c)throw Error("Cannot register with defer after the call to load.");
+a.defer_(d,b)},areDepsLoaded:function(){return a.areDepsLoaded_(d.requires)}};try{d.load(f)}finally{c=!0}})();b&&this.pause_()},goog.DebugLoader_.prototype.pause_=function(){this.paused_=!0},goog.DebugLoader_.prototype.resume_=function(){this.paused_&&(this.paused_=!1,this.loadDeps_())},goog.DebugLoader_.prototype.loading_=function(a){this.loadingDeps_.push(a)},goog.DebugLoader_.prototype.loaded_=function(a){for(var b=0;b<this.loadingDeps_.length;b++)if(this.loadingDeps_[b]==a){this.loadingDeps_.splice(b,
+1);break}for(b=0;b<this.deferredQueue_.length;b++)if(this.deferredQueue_[b]==a.path){this.deferredQueue_.splice(b,1);break}if(this.loadingDeps_.length==this.deferredQueue_.length&&!this.depsToLoad_.length)for(;this.deferredQueue_.length;)this.requested(this.deferredQueue_.shift(),!0);a.loaded()},goog.DebugLoader_.prototype.areDepsLoaded_=function(a){for(var b=0;b<a.length;b++){var c=this.getPathFromDeps_(a[b]);if(!c||!(c in this.deferredCallbacks_||goog.isProvided_(a[b])))return!1}return!0},goog.DebugLoader_.prototype.getPathFromDeps_=
+function(a){return a in this.idToPath_?this.idToPath_[a]:a in this.dependencies_?a:null},goog.DebugLoader_.prototype.defer_=function(a,b){this.deferredCallbacks_[a.path]=b;this.deferredQueue_.push(a.path)},goog.LoadController=function(){},goog.LoadController.prototype.pause=function(){},goog.LoadController.prototype.resume=function(){},goog.LoadController.prototype.loaded=function(){},goog.LoadController.prototype.pending=function(){},goog.LoadController.prototype.registerEs6ModuleExports=function(a,
+b,c){},goog.LoadController.prototype.setModuleState=function(a){},goog.LoadController.prototype.clearModuleState=function(){},goog.LoadController.prototype.defer=function(a){},goog.LoadController.prototype.areDepsLoaded=function(){},goog.Dependency=function(a,b,c,d,e){this.path=a;this.relativePath=b;this.provides=c;this.requires=d;this.loadFlags=e;this.loaded_=!1;this.loadCallbacks_=[]},goog.Dependency.prototype.getPathName=function(){var a=this.path,b=a.indexOf("://");0<=b&&(a=a.substring(b+3),b=
+a.indexOf("/"),0<=b&&(a=a.substring(b+1)));return a},goog.Dependency.prototype.onLoad=function(a){this.loaded_?a():this.loadCallbacks_.push(a)},goog.Dependency.prototype.loaded=function(){this.loaded_=!0;var a=this.loadCallbacks_;this.loadCallbacks_=[];for(var b=0;b<a.length;b++)a[b]()},goog.Dependency.defer_=!1,goog.Dependency.callbackMap_={},goog.Dependency.registerCallback_=function(a){var b=Math.random().toString(32);goog.Dependency.callbackMap_[b]=a;return b},goog.Dependency.unregisterCallback_=
+function(a){delete goog.Dependency.callbackMap_[a]},goog.Dependency.callback_=function(a,b){if(a in goog.Dependency.callbackMap_){for(var c=goog.Dependency.callbackMap_[a],d=[],e=1;e<arguments.length;e++)d.push(arguments[e]);c.apply(void 0,d)}else throw Error("Callback key "+a+" does not exist (was base.js loaded more than once?).");},goog.Dependency.prototype.load=function(a){if(goog.global.CLOSURE_IMPORT_SCRIPT)goog.global.CLOSURE_IMPORT_SCRIPT(this.path)?a.loaded():a.pause();else if(goog.inHtmlDocument_()){var b=
+goog.global.document;if("complete"==b.readyState&&!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING){if(/\bdeps.js$/.test(this.path)){a.loaded();return}throw Error('Cannot write "'+this.path+'" after document load');}if(!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING&&goog.isDocumentLoading_()){var c=goog.Dependency.registerCallback_(function(b){goog.DebugLoader_.IS_OLD_IE_&&"complete"!=b.readyState||(goog.Dependency.unregisterCallback_(c),a.loaded())}),d=!goog.DebugLoader_.IS_OLD_IE_&&goog.getScriptNonce()?
+' nonce="'+goog.getScriptNonce()+'"':"";b.write('<script src="'+this.path+'" '+(goog.DebugLoader_.IS_OLD_IE_?"onreadystatechange":"onload")+"=\"goog.Dependency.callback_('"+c+'\', this)" type="text/javascript" '+(goog.Dependency.defer_?"defer":"")+d+">\x3c/script>")}else{var e=b.createElement("script");e.defer=goog.Dependency.defer_;e.async=!1;e.type="text/javascript";(d=goog.getScriptNonce())&&e.setAttribute("nonce",d);goog.DebugLoader_.IS_OLD_IE_?(a.pause(),e.onreadystatechange=function(){if("loaded"==
+e.readyState||"complete"==e.readyState)a.loaded(),a.resume()}):e.onload=function(){e.onload=null;a.loaded()};e.src=this.path;b.head.appendChild(e)}}else goog.logToConsole_("Cannot use default debug loader outside of HTML documents."),"deps.js"==this.relativePath?(goog.logToConsole_("Consider setting CLOSURE_IMPORT_SCRIPT before loading base.js, or setting CLOSURE_NO_DEPS to true."),a.loaded()):a.pause()},goog.Es6ModuleDependency=function(a,b,c,d,e){goog.Dependency.call(this,a,b,c,d,e)},goog.inherits(goog.Es6ModuleDependency,
+goog.Dependency),goog.Es6ModuleDependency.prototype.load=function(a){function b(a,b){b?d.write('<script type="module" crossorigin>'+b+"\x3c/script>"):d.write('<script type="module" crossorigin src="'+a+'">\x3c/script>')}function c(a,b){var c=d.createElement("script");c.defer=!0;c.async=!1;c.type="module";c.setAttribute("crossorigin",!0);var e=goog.getScriptNonce();e&&c.setAttribute("nonce",e);b?c.textContent=b:c.src=a;d.head.appendChild(c)}if(goog.global.CLOSURE_IMPORT_SCRIPT)goog.global.CLOSURE_IMPORT_SCRIPT(this.path)?
+a.loaded():a.pause();else if(goog.inHtmlDocument_()){var d=goog.global.document,e=this;if(goog.isDocumentLoading_()){var f=b;goog.Dependency.defer_=!0}else f=c;var g=goog.Dependency.registerCallback_(function(){goog.Dependency.unregisterCallback_(g);a.setModuleState(goog.ModuleType.ES6)});f(void 0,'goog.Dependency.callback_("'+g+'")');f(this.path,void 0);var h=goog.Dependency.registerCallback_(function(b){goog.Dependency.unregisterCallback_(h);a.registerEs6ModuleExports(e.path,b,goog.moduleLoaderState_.moduleName)});
+f(void 0,'import * as m from "'+this.path+'"; goog.Dependency.callback_("'+h+'", m)');var k=goog.Dependency.registerCallback_(function(){goog.Dependency.unregisterCallback_(k);a.clearModuleState();a.loaded()});f(void 0,'goog.Dependency.callback_("'+k+'")')}else goog.logToConsole_("Cannot use default debug loader outside of HTML documents."),a.pause()},goog.TransformedDependency=function(a,b,c,d,e){goog.Dependency.call(this,a,b,c,d,e);this.contents_=null;this.lazyFetch_=!goog.inHtmlDocument_()||!("noModule"in
+goog.global.document.createElement("script"))},goog.inherits(goog.TransformedDependency,goog.Dependency),goog.TransformedDependency.prototype.load=function(a){function b(){e.contents_=goog.loadFileSync_(e.path);e.contents_&&(e.contents_=e.transform(e.contents_),e.contents_&&(e.contents_+="\n//# sourceURL="+e.path))}function c(){e.lazyFetch_&&b();if(e.contents_){f&&a.setModuleState(goog.ModuleType.ES6);try{var c=e.contents_;e.contents_=null;goog.globalEval(c);if(f)var d=goog.moduleLoaderState_.moduleName}finally{f&&
+a.clearModuleState()}f&&goog.global.$jscomp.require.ensure([e.getPathName()],function(){a.registerEs6ModuleExports(e.path,goog.global.$jscomp.require(e.getPathName()),d)});a.loaded()}}function d(){var a=goog.global.document,b=goog.Dependency.registerCallback_(function(){goog.Dependency.unregisterCallback_(b);c()});a.write('<script type="text/javascript">'+goog.protectScriptTag_('goog.Dependency.callback_("'+b+'");')+"\x3c/script>")}var e=this;if(goog.global.CLOSURE_IMPORT_SCRIPT)b(),this.contents_&&
+goog.global.CLOSURE_IMPORT_SCRIPT("",this.contents_)?(this.contents_=null,a.loaded()):a.pause();else{var f=this.loadFlags.module==goog.ModuleType.ES6;this.lazyFetch_||b();var g=1<a.pending().length,h=g&&goog.DebugLoader_.IS_OLD_IE_;g=goog.Dependency.defer_&&(g||goog.isDocumentLoading_());if(h||g)a.defer(function(){c()});else{var k=goog.global.document;h=goog.inHtmlDocument_()&&"ActiveXObject"in goog.global;if(f&&goog.inHtmlDocument_()&&goog.isDocumentLoading_()&&!h){goog.Dependency.defer_=!0;a.pause();
+var l=k.onreadystatechange;k.onreadystatechange=function(){"interactive"==k.readyState&&(k.onreadystatechange=l,c(),a.resume());goog.isFunction(l)&&l.apply(void 0,arguments)}}else!goog.DebugLoader_.IS_OLD_IE_&&goog.inHtmlDocument_()&&goog.isDocumentLoading_()?d():c()}}},goog.TransformedDependency.prototype.transform=function(a){},goog.TranspiledDependency=function(a,b,c,d,e,f){goog.TransformedDependency.call(this,a,b,c,d,e);this.transpiler=f},goog.inherits(goog.TranspiledDependency,goog.TransformedDependency),
+goog.TranspiledDependency.prototype.transform=function(a){return this.transpiler.transpile(a,this.getPathName())},goog.PreTranspiledEs6ModuleDependency=function(a,b,c,d,e){goog.TransformedDependency.call(this,a,b,c,d,e)},goog.inherits(goog.PreTranspiledEs6ModuleDependency,goog.TransformedDependency),goog.PreTranspiledEs6ModuleDependency.prototype.transform=function(a){return a},goog.GoogModuleDependency=function(a,b,c,d,e,f,g){goog.TransformedDependency.call(this,a,b,c,d,e);this.needsTranspile_=f;
+this.transpiler_=g},goog.inherits(goog.GoogModuleDependency,goog.TransformedDependency),goog.GoogModuleDependency.prototype.transform=function(a){this.needsTranspile_&&(a=this.transpiler_.transpile(a,this.getPathName()));return goog.LOAD_MODULE_USING_EVAL&&goog.isDef(goog.global.JSON)?"goog.loadModule("+goog.global.JSON.stringify(a+"\n//# sourceURL="+this.path+"\n")+");":'goog.loadModule(function(exports) {"use strict";'+a+"\n;return exports});\n//# sourceURL="+this.path+"\n"},goog.DebugLoader_.IS_OLD_IE_=
+!(goog.global.atob||!goog.global.document||!goog.global.document.all),goog.DebugLoader_.prototype.addDependency=function(a,b,c,d){b=b||[];a=a.replace(/\\/g,"/");var e=goog.normalizePath_(goog.basePath+a);d&&"boolean"!==typeof d||(d=d?{module:goog.ModuleType.GOOG}:{});c=this.factory_.createDependency(e,a,b,c,d,goog.transpiler_.needsTranspile(d.lang||"es3",d.module));this.dependencies_[e]=c;for(c=0;c<b.length;c++)this.idToPath_[b[c]]=e;this.idToPath_[a]=e},goog.DependencyFactory=function(a){this.transpiler=
+a},goog.DependencyFactory.prototype.createDependency=function(a,b,c,d,e,f){return e.module==goog.ModuleType.GOOG?new goog.GoogModuleDependency(a,b,c,d,e,f,this.transpiler):f?new goog.TranspiledDependency(a,b,c,d,e,this.transpiler):e.module==goog.ModuleType.ES6?"never"==goog.TRANSPILE&&goog.ASSUME_ES_MODULES_TRANSPILED?new goog.PreTranspiledEs6ModuleDependency(a,b,c,d,e):new goog.Es6ModuleDependency(a,b,c,d,e):new goog.Dependency(a,b,c,d,e)},goog.debugLoader_=new goog.DebugLoader_,goog.loadClosureDeps=
+function(){goog.debugLoader_.loadClosureDeps()},goog.setDependencyFactory=function(a){goog.debugLoader_.setDependencyFactory(a)},goog.global.CLOSURE_NO_DEPS||goog.debugLoader_.loadClosureDeps(),goog.bootstrap=function(a,b){goog.debugLoader_.bootstrap(a,b)});goog.debug={};goog.debug.Error=function(a){if(Error.captureStackTrace)Error.captureStackTrace(this,goog.debug.Error);else{var b=Error().stack;b&&(this.stack=b)}a&&(this.message=String(a));this.reportErrorToServer=!0};goog.inherits(goog.debug.Error,Error);goog.debug.Error.prototype.name="CustomError";goog.dom={};goog.dom.NodeType={ELEMENT:1,ATTRIBUTE:2,TEXT:3,CDATA_SECTION:4,ENTITY_REFERENCE:5,ENTITY:6,PROCESSING_INSTRUCTION:7,COMMENT:8,DOCUMENT:9,DOCUMENT_TYPE:10,DOCUMENT_FRAGMENT:11,NOTATION:12};goog.asserts={};goog.asserts.ENABLE_ASSERTS=goog.DEBUG;goog.asserts.AssertionError=function(a,b){goog.debug.Error.call(this,goog.asserts.subs_(a,b));this.messagePattern=a};goog.inherits(goog.asserts.AssertionError,goog.debug.Error);goog.asserts.AssertionError.prototype.name="AssertionError";goog.asserts.DEFAULT_ERROR_HANDLER=function(a){throw a;};goog.asserts.errorHandler_=goog.asserts.DEFAULT_ERROR_HANDLER;
+goog.asserts.subs_=function(a,b){for(var c=a.split("%s"),d="",e=c.length-1,f=0;f<e;f++)d+=c[f]+(f<b.length?b[f]:"%s");return d+c[e]};goog.asserts.doAssertFailure_=function(a,b,c,d){var e="Assertion failed";if(c){e+=": "+c;var f=d}else a&&(e+=": "+a,f=b);a=new goog.asserts.AssertionError(""+e,f||[]);goog.asserts.errorHandler_(a)};goog.asserts.setErrorHandler=function(a){goog.asserts.ENABLE_ASSERTS&&(goog.asserts.errorHandler_=a)};
+goog.asserts.assert=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!a&&goog.asserts.doAssertFailure_("",null,b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.fail=function(a,b){goog.asserts.ENABLE_ASSERTS&&goog.asserts.errorHandler_(new goog.asserts.AssertionError("Failure"+(a?": "+a:""),Array.prototype.slice.call(arguments,1)))};
+goog.asserts.assertNumber=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!goog.isNumber(a)&&goog.asserts.doAssertFailure_("Expected number but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.assertString=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!goog.isString(a)&&goog.asserts.doAssertFailure_("Expected string but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};
+goog.asserts.assertFunction=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!goog.isFunction(a)&&goog.asserts.doAssertFailure_("Expected function but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.assertObject=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!goog.isObject(a)&&goog.asserts.doAssertFailure_("Expected object but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};
+goog.asserts.assertArray=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!goog.isArray(a)&&goog.asserts.doAssertFailure_("Expected array but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.assertBoolean=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!goog.isBoolean(a)&&goog.asserts.doAssertFailure_("Expected boolean but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};
+goog.asserts.assertElement=function(a,b,c){!goog.asserts.ENABLE_ASSERTS||goog.isObject(a)&&a.nodeType==goog.dom.NodeType.ELEMENT||goog.asserts.doAssertFailure_("Expected Element but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};
+goog.asserts.assertInstanceof=function(a,b,c,d){!goog.asserts.ENABLE_ASSERTS||a instanceof b||goog.asserts.doAssertFailure_("Expected instanceof %s but got %s.",[goog.asserts.getType_(b),goog.asserts.getType_(a)],c,Array.prototype.slice.call(arguments,3));return a};goog.asserts.assertFinite=function(a,b,c){!goog.asserts.ENABLE_ASSERTS||"number"==typeof a&&isFinite(a)||goog.asserts.doAssertFailure_("Expected %s to be a finite number but it is not.",[a],b,Array.prototype.slice.call(arguments,2));return a};
+goog.asserts.assertObjectPrototypeIsIntact=function(){for(var a in Object.prototype)goog.asserts.fail(a+" should not be enumerable in Object.prototype.")};goog.asserts.getType_=function(a){return a instanceof Function?a.displayName||a.name||"unknown type name":a instanceof Object?a.constructor.displayName||a.constructor.name||Object.prototype.toString.call(a):null===a?"null":typeof a};goog.array={};goog.NATIVE_ARRAY_PROTOTYPES=goog.TRUSTED_SITE;goog.array.ASSUME_NATIVE_FUNCTIONS=!1;goog.array.peek=function(a){return a[a.length-1]};goog.array.last=goog.array.peek;
+goog.array.indexOf=goog.NATIVE_ARRAY_PROTOTYPES&&(goog.array.ASSUME_NATIVE_FUNCTIONS||Array.prototype.indexOf)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.indexOf.call(a,b,c)}:function(a,b,c){c=null==c?0:0>c?Math.max(0,a.length+c):c;if(goog.isString(a))return goog.isString(b)&&1==b.length?a.indexOf(b,c):-1;for(;c<a.length;c++)if(c in a&&a[c]===b)return c;return-1};
+goog.array.lastIndexOf=goog.NATIVE_ARRAY_PROTOTYPES&&(goog.array.ASSUME_NATIVE_FUNCTIONS||Array.prototype.lastIndexOf)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.lastIndexOf.call(a,b,null==c?a.length-1:c)}:function(a,b,c){c=null==c?a.length-1:c;0>c&&(c=Math.max(0,a.length+c));if(goog.isString(a))return goog.isString(b)&&1==b.length?a.lastIndexOf(b,c):-1;for(;0<=c;c--)if(c in a&&a[c]===b)return c;return-1};
+goog.array.forEach=goog.NATIVE_ARRAY_PROTOTYPES&&(goog.array.ASSUME_NATIVE_FUNCTIONS||Array.prototype.forEach)?function(a,b,c){goog.asserts.assert(null!=a.length);Array.prototype.forEach.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=goog.isString(a)?a.split(""):a,f=0;f<d;f++)f in e&&b.call(c,e[f],f,a)};goog.array.forEachRight=function(a,b,c){var d=a.length,e=goog.isString(a)?a.split(""):a;for(--d;0<=d;--d)d in e&&b.call(c,e[d],d,a)};
+goog.array.filter=goog.NATIVE_ARRAY_PROTOTYPES&&(goog.array.ASSUME_NATIVE_FUNCTIONS||Array.prototype.filter)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.filter.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=[],f=0,g=goog.isString(a)?a.split(""):a,h=0;h<d;h++)if(h in g){var k=g[h];b.call(c,k,h,a)&&(e[f++]=k)}return e};
+goog.array.map=goog.NATIVE_ARRAY_PROTOTYPES&&(goog.array.ASSUME_NATIVE_FUNCTIONS||Array.prototype.map)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.map.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=Array(d),f=goog.isString(a)?a.split(""):a,g=0;g<d;g++)g in f&&(e[g]=b.call(c,f[g],g,a));return e};
+goog.array.reduce=goog.NATIVE_ARRAY_PROTOTYPES&&(goog.array.ASSUME_NATIVE_FUNCTIONS||Array.prototype.reduce)?function(a,b,c,d){goog.asserts.assert(null!=a.length);d&&(b=goog.bind(b,d));return Array.prototype.reduce.call(a,b,c)}:function(a,b,c,d){var e=c;goog.array.forEach(a,function(c,g){e=b.call(d,e,c,g,a)});return e};
+goog.array.reduceRight=goog.NATIVE_ARRAY_PROTOTYPES&&(goog.array.ASSUME_NATIVE_FUNCTIONS||Array.prototype.reduceRight)?function(a,b,c,d){goog.asserts.assert(null!=a.length);goog.asserts.assert(null!=b);d&&(b=goog.bind(b,d));return Array.prototype.reduceRight.call(a,b,c)}:function(a,b,c,d){var e=c;goog.array.forEachRight(a,function(c,g){e=b.call(d,e,c,g,a)});return e};
+goog.array.some=goog.NATIVE_ARRAY_PROTOTYPES&&(goog.array.ASSUME_NATIVE_FUNCTIONS||Array.prototype.some)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.some.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=goog.isString(a)?a.split(""):a,f=0;f<d;f++)if(f in e&&b.call(c,e[f],f,a))return!0;return!1};
+goog.array.every=goog.NATIVE_ARRAY_PROTOTYPES&&(goog.array.ASSUME_NATIVE_FUNCTIONS||Array.prototype.every)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.every.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=goog.isString(a)?a.split(""):a,f=0;f<d;f++)if(f in e&&!b.call(c,e[f],f,a))return!1;return!0};goog.array.count=function(a,b,c){var d=0;goog.array.forEach(a,function(a,f,g){b.call(c,a,f,g)&&++d},c);return d};
+goog.array.find=function(a,b,c){b=goog.array.findIndex(a,b,c);return 0>b?null:goog.isString(a)?a.charAt(b):a[b]};goog.array.findIndex=function(a,b,c){for(var d=a.length,e=goog.isString(a)?a.split(""):a,f=0;f<d;f++)if(f in e&&b.call(c,e[f],f,a))return f;return-1};goog.array.findRight=function(a,b,c){b=goog.array.findIndexRight(a,b,c);return 0>b?null:goog.isString(a)?a.charAt(b):a[b]};
+goog.array.findIndexRight=function(a,b,c){var d=a.length,e=goog.isString(a)?a.split(""):a;for(--d;0<=d;d--)if(d in e&&b.call(c,e[d],d,a))return d;return-1};goog.array.contains=function(a,b){return 0<=goog.array.indexOf(a,b)};goog.array.isEmpty=function(a){return 0==a.length};goog.array.clear=function(a){if(!goog.isArray(a))for(var b=a.length-1;0<=b;b--)delete a[b];a.length=0};goog.array.insert=function(a,b){goog.array.contains(a,b)||a.push(b)};
+goog.array.insertAt=function(a,b,c){goog.array.splice(a,c,0,b)};goog.array.insertArrayAt=function(a,b,c){goog.partial(goog.array.splice,a,c,0).apply(null,b)};goog.array.insertBefore=function(a,b,c){var d;2==arguments.length||0>(d=goog.array.indexOf(a,c))?a.push(b):goog.array.insertAt(a,b,d)};goog.array.remove=function(a,b){var c=goog.array.indexOf(a,b),d;(d=0<=c)&&goog.array.removeAt(a,c);return d};
+goog.array.removeLast=function(a,b){var c=goog.array.lastIndexOf(a,b);return 0<=c?(goog.array.removeAt(a,c),!0):!1};goog.array.removeAt=function(a,b){goog.asserts.assert(null!=a.length);return 1==Array.prototype.splice.call(a,b,1).length};goog.array.removeIf=function(a,b,c){b=goog.array.findIndex(a,b,c);return 0<=b?(goog.array.removeAt(a,b),!0):!1};goog.array.removeAllIf=function(a,b,c){var d=0;goog.array.forEachRight(a,function(e,f){b.call(c,e,f,a)&&goog.array.removeAt(a,f)&&d++});return d};
+goog.array.concat=function(a){return Array.prototype.concat.apply([],arguments)};goog.array.join=function(a){return Array.prototype.concat.apply([],arguments)};goog.array.toArray=function(a){var b=a.length;if(0<b){for(var c=Array(b),d=0;d<b;d++)c[d]=a[d];return c}return[]};goog.array.clone=goog.array.toArray;goog.array.extend=function(a,b){for(var c=1;c<arguments.length;c++){var d=arguments[c];if(goog.isArrayLike(d)){var e=a.length||0,f=d.length||0;a.length=e+f;for(var g=0;g<f;g++)a[e+g]=d[g]}else a.push(d)}};
+goog.array.splice=function(a,b,c,d){goog.asserts.assert(null!=a.length);return Array.prototype.splice.apply(a,goog.array.slice(arguments,1))};goog.array.slice=function(a,b,c){goog.asserts.assert(null!=a.length);return 2>=arguments.length?Array.prototype.slice.call(a,b):Array.prototype.slice.call(a,b,c)};
+goog.array.removeDuplicates=function(a,b,c){b=b||a;var d=function(a){return goog.isObject(a)?"o"+goog.getUid(a):(typeof a).charAt(0)+a};c=c||d;d={};for(var e=0,f=0;f<a.length;){var g=a[f++],h=c(g);Object.prototype.hasOwnProperty.call(d,h)||(d[h]=!0,b[e++]=g)}b.length=e};goog.array.binarySearch=function(a,b,c){return goog.array.binarySearch_(a,c||goog.array.defaultCompare,!1,b)};goog.array.binarySelect=function(a,b,c){return goog.array.binarySearch_(a,b,!0,void 0,c)};
+goog.array.binarySearch_=function(a,b,c,d,e){for(var f=0,g=a.length,h;f<g;){var k=f+g>>1;var l=c?b.call(e,a[k],k,a):b(d,a[k]);0<l?f=k+1:(g=k,h=!l)}return h?f:~f};goog.array.sort=function(a,b){a.sort(b||goog.array.defaultCompare)};goog.array.stableSort=function(a,b){for(var c=Array(a.length),d=0;d<a.length;d++)c[d]={index:d,value:a[d]};var e=b||goog.array.defaultCompare;goog.array.sort(c,function(a,b){return e(a.value,b.value)||a.index-b.index});for(d=0;d<a.length;d++)a[d]=c[d].value};
+goog.array.sortByKey=function(a,b,c){var d=c||goog.array.defaultCompare;goog.array.sort(a,function(a,c){return d(b(a),b(c))})};goog.array.sortObjectsByKey=function(a,b,c){goog.array.sortByKey(a,function(a){return a[b]},c)};goog.array.isSorted=function(a,b,c){b=b||goog.array.defaultCompare;for(var d=1;d<a.length;d++){var e=b(a[d-1],a[d]);if(0<e||0==e&&c)return!1}return!0};
+goog.array.equals=function(a,b,c){if(!goog.isArrayLike(a)||!goog.isArrayLike(b)||a.length!=b.length)return!1;var d=a.length;c=c||goog.array.defaultCompareEquality;for(var e=0;e<d;e++)if(!c(a[e],b[e]))return!1;return!0};goog.array.compare3=function(a,b,c){c=c||goog.array.defaultCompare;for(var d=Math.min(a.length,b.length),e=0;e<d;e++){var f=c(a[e],b[e]);if(0!=f)return f}return goog.array.defaultCompare(a.length,b.length)};goog.array.defaultCompare=function(a,b){return a>b?1:a<b?-1:0};
+goog.array.inverseDefaultCompare=function(a,b){return-goog.array.defaultCompare(a,b)};goog.array.defaultCompareEquality=function(a,b){return a===b};goog.array.binaryInsert=function(a,b,c){c=goog.array.binarySearch(a,b,c);return 0>c?(goog.array.insertAt(a,b,-(c+1)),!0):!1};goog.array.binaryRemove=function(a,b,c){b=goog.array.binarySearch(a,b,c);return 0<=b?goog.array.removeAt(a,b):!1};
+goog.array.bucket=function(a,b,c){for(var d={},e=0;e<a.length;e++){var f=a[e],g=b.call(c,f,e,a);goog.isDef(g)&&(d[g]||(d[g]=[])).push(f)}return d};goog.array.toObject=function(a,b,c){var d={};goog.array.forEach(a,function(e,f){d[b.call(c,e,f,a)]=e});return d};goog.array.range=function(a,b,c){var d=[],e=0,f=a;c=c||1;void 0!==b&&(e=a,f=b);if(0>c*(f-e))return[];if(0<c)for(a=e;a<f;a+=c)d.push(a);else for(a=e;a>f;a+=c)d.push(a);return d};
+goog.array.repeat=function(a,b){for(var c=[],d=0;d<b;d++)c[d]=a;return c};goog.array.flatten=function(a){for(var b=[],c=0;c<arguments.length;c++){var d=arguments[c];if(goog.isArray(d))for(var e=0;e<d.length;e+=8192){var f=goog.array.slice(d,e,e+8192);f=goog.array.flatten.apply(null,f);for(var g=0;g<f.length;g++)b.push(f[g])}else b.push(d)}return b};
+goog.array.rotate=function(a,b){goog.asserts.assert(null!=a.length);a.length&&(b%=a.length,0<b?Array.prototype.unshift.apply(a,a.splice(-b,b)):0>b&&Array.prototype.push.apply(a,a.splice(0,-b)));return a};goog.array.moveItem=function(a,b,c){goog.asserts.assert(0<=b&&b<a.length);goog.asserts.assert(0<=c&&c<a.length);b=Array.prototype.splice.call(a,b,1);Array.prototype.splice.call(a,c,0,b[0])};
+goog.array.zip=function(a){if(!arguments.length)return[];for(var b=[],c=arguments[0].length,d=1;d<arguments.length;d++)arguments[d].length<c&&(c=arguments[d].length);for(d=0;d<c;d++){for(var e=[],f=0;f<arguments.length;f++)e.push(arguments[f][d]);b.push(e)}return b};goog.array.shuffle=function(a,b){for(var c=b||Math.random,d=a.length-1;0<d;d--){var e=Math.floor(c()*(d+1)),f=a[d];a[d]=a[e];a[e]=f}};goog.array.copyByIndex=function(a,b){var c=[];goog.array.forEach(b,function(b){c.push(a[b])});return c};
+goog.array.concatMap=function(a,b,c){return goog.array.concat.apply([],goog.array.map(a,b,c))};goog.math={};goog.math.randomInt=function(a){return Math.floor(Math.random()*a)};goog.math.uniformRandom=function(a,b){return a+Math.random()*(b-a)};goog.math.clamp=function(a,b,c){return Math.min(Math.max(a,b),c)};goog.math.modulo=function(a,b){var c=a%b;return 0>c*b?c+b:c};goog.math.lerp=function(a,b,c){return a+c*(b-a)};goog.math.nearlyEquals=function(a,b,c){return Math.abs(a-b)<=(c||1E-6)};goog.math.standardAngle=function(a){return goog.math.modulo(a,360)};
+goog.math.standardAngleInRadians=function(a){return goog.math.modulo(a,2*Math.PI)};goog.math.toRadians=function(a){return a*Math.PI/180};goog.math.toDegrees=function(a){return 180*a/Math.PI};goog.math.angleDx=function(a,b){return b*Math.cos(goog.math.toRadians(a))};goog.math.angleDy=function(a,b){return b*Math.sin(goog.math.toRadians(a))};goog.math.angle=function(a,b,c,d){return goog.math.standardAngle(goog.math.toDegrees(Math.atan2(d-b,c-a)))};
+goog.math.angleDifference=function(a,b){var c=goog.math.standardAngle(b)-goog.math.standardAngle(a);180<c?c-=360:-180>=c&&(c=360+c);return c};goog.math.sign=function(a){return 0<a?1:0>a?-1:a};
+goog.math.longestCommonSubsequence=function(a,b,c,d){c=c||function(a,b){return a==b};d=d||function(b,c){return a[b]};for(var e=a.length,f=b.length,g=[],h=0;h<e+1;h++)g[h]=[],g[h][0]=0;for(var k=0;k<f+1;k++)g[0][k]=0;for(h=1;h<=e;h++)for(k=1;k<=f;k++)c(a[h-1],b[k-1])?g[h][k]=g[h-1][k-1]+1:g[h][k]=Math.max(g[h-1][k],g[h][k-1]);var l=[];h=e;for(k=f;0<h&&0<k;)c(a[h-1],b[k-1])?(l.unshift(d(h-1,k-1)),h--,k--):g[h-1][k]>g[h][k-1]?h--:k--;return l};
+goog.math.sum=function(a){return goog.array.reduce(arguments,function(a,c){return a+c},0)};goog.math.average=function(a){return goog.math.sum.apply(null,arguments)/arguments.length};goog.math.sampleVariance=function(a){var b=arguments.length;if(2>b)return 0;var c=goog.math.average.apply(null,arguments);return goog.math.sum.apply(null,goog.array.map(arguments,function(a){return Math.pow(a-c,2)}))/(b-1)};goog.math.standardDeviation=function(a){return Math.sqrt(goog.math.sampleVariance.apply(null,arguments))};
+goog.math.isInt=function(a){return isFinite(a)&&0==a%1};goog.math.isFiniteNumber=function(a){return isFinite(a)};goog.math.isNegativeZero=function(a){return 0==a&&0>1/a};goog.math.log10Floor=function(a){if(0<a){var b=Math.round(Math.log(a)*Math.LOG10E);return b-(parseFloat("1e"+b)>a?1:0)}return 0==a?-Infinity:NaN};goog.math.safeFloor=function(a,b){goog.asserts.assert(!goog.isDef(b)||0<b);return Math.floor(a+(b||2E-15))};
+goog.math.safeCeil=function(a,b){goog.asserts.assert(!goog.isDef(b)||0<b);return Math.ceil(a-(b||2E-15))};goog.math.Coordinate=function(a,b){this.x=goog.isDef(a)?a:0;this.y=goog.isDef(b)?b:0};goog.math.Coordinate.prototype.clone=function(){return new goog.math.Coordinate(this.x,this.y)};goog.DEBUG&&(goog.math.Coordinate.prototype.toString=function(){return"("+this.x+", "+this.y+")"});goog.math.Coordinate.prototype.equals=function(a){return a instanceof goog.math.Coordinate&&goog.math.Coordinate.equals(this,a)};goog.math.Coordinate.equals=function(a,b){return a==b?!0:a&&b?a.x==b.x&&a.y==b.y:!1};
+goog.math.Coordinate.distance=function(a,b){var c=a.x-b.x,d=a.y-b.y;return Math.sqrt(c*c+d*d)};goog.math.Coordinate.magnitude=function(a){return Math.sqrt(a.x*a.x+a.y*a.y)};goog.math.Coordinate.azimuth=function(a){return goog.math.angle(0,0,a.x,a.y)};goog.math.Coordinate.squaredDistance=function(a,b){var c=a.x-b.x,d=a.y-b.y;return c*c+d*d};goog.math.Coordinate.difference=function(a,b){return new goog.math.Coordinate(a.x-b.x,a.y-b.y)};
+goog.math.Coordinate.sum=function(a,b){return new goog.math.Coordinate(a.x+b.x,a.y+b.y)};goog.math.Coordinate.prototype.ceil=function(){this.x=Math.ceil(this.x);this.y=Math.ceil(this.y);return this};goog.math.Coordinate.prototype.floor=function(){this.x=Math.floor(this.x);this.y=Math.floor(this.y);return this};goog.math.Coordinate.prototype.round=function(){this.x=Math.round(this.x);this.y=Math.round(this.y);return this};
+goog.math.Coordinate.prototype.translate=function(a,b){a instanceof goog.math.Coordinate?(this.x+=a.x,this.y+=a.y):(this.x+=Number(a),goog.isNumber(b)&&(this.y+=b));return this};goog.math.Coordinate.prototype.scale=function(a,b){var c=goog.isNumber(b)?b:a;this.x*=a;this.y*=c;return this};goog.math.Coordinate.prototype.rotateRadians=function(a,b){var c=b||new goog.math.Coordinate(0,0),d=this.x,e=this.y,f=Math.cos(a),g=Math.sin(a);this.x=(d-c.x)*f-(e-c.y)*g+c.x;this.y=(d-c.x)*g+(e-c.y)*f+c.y};
+goog.math.Coordinate.prototype.rotateDegrees=function(a,b){this.rotateRadians(goog.math.toRadians(a),b)};goog.color={};
+goog.color.names={aliceblue:"#f0f8ff",antiquewhite:"#faebd7",aqua:"#00ffff",aquamarine:"#7fffd4",azure:"#f0ffff",beige:"#f5f5dc",bisque:"#ffe4c4",black:"#000000",blanchedalmond:"#ffebcd",blue:"#0000ff",blueviolet:"#8a2be2",brown:"#a52a2a",burlywood:"#deb887",cadetblue:"#5f9ea0",chartreuse:"#7fff00",chocolate:"#d2691e",coral:"#ff7f50",cornflowerblue:"#6495ed",cornsilk:"#fff8dc",crimson:"#dc143c",cyan:"#00ffff",darkblue:"#00008b",darkcyan:"#008b8b",darkgoldenrod:"#b8860b",darkgray:"#a9a9a9",darkgreen:"#006400",
+darkgrey:"#a9a9a9",darkkhaki:"#bdb76b",darkmagenta:"#8b008b",darkolivegreen:"#556b2f",darkorange:"#ff8c00",darkorchid:"#9932cc",darkred:"#8b0000",darksalmon:"#e9967a",darkseagreen:"#8fbc8f",darkslateblue:"#483d8b",darkslategray:"#2f4f4f",darkslategrey:"#2f4f4f",darkturquoise:"#00ced1",darkviolet:"#9400d3",deeppink:"#ff1493",deepskyblue:"#00bfff",dimgray:"#696969",dimgrey:"#696969",dodgerblue:"#1e90ff",firebrick:"#b22222",floralwhite:"#fffaf0",forestgreen:"#228b22",fuchsia:"#ff00ff",gainsboro:"#dcdcdc",
+ghostwhite:"#f8f8ff",gold:"#ffd700",goldenrod:"#daa520",gray:"#808080",green:"#008000",greenyellow:"#adff2f",grey:"#808080",honeydew:"#f0fff0",hotpink:"#ff69b4",indianred:"#cd5c5c",indigo:"#4b0082",ivory:"#fffff0",khaki:"#f0e68c",lavender:"#e6e6fa",lavenderblush:"#fff0f5",lawngreen:"#7cfc00",lemonchiffon:"#fffacd",lightblue:"#add8e6",lightcoral:"#f08080",lightcyan:"#e0ffff",lightgoldenrodyellow:"#fafad2",lightgray:"#d3d3d3",lightgreen:"#90ee90",lightgrey:"#d3d3d3",lightpink:"#ffb6c1",lightsalmon:"#ffa07a",
+lightseagreen:"#20b2aa",lightskyblue:"#87cefa",lightslategray:"#778899",lightslategrey:"#778899",lightsteelblue:"#b0c4de",lightyellow:"#ffffe0",lime:"#00ff00",limegreen:"#32cd32",linen:"#faf0e6",magenta:"#ff00ff",maroon:"#800000",mediumaquamarine:"#66cdaa",mediumblue:"#0000cd",mediumorchid:"#ba55d3",mediumpurple:"#9370db",mediumseagreen:"#3cb371",mediumslateblue:"#7b68ee",mediumspringgreen:"#00fa9a",mediumturquoise:"#48d1cc",mediumvioletred:"#c71585",midnightblue:"#191970",mintcream:"#f5fffa",mistyrose:"#ffe4e1",
+moccasin:"#ffe4b5",navajowhite:"#ffdead",navy:"#000080",oldlace:"#fdf5e6",olive:"#808000",olivedrab:"#6b8e23",orange:"#ffa500",orangered:"#ff4500",orchid:"#da70d6",palegoldenrod:"#eee8aa",palegreen:"#98fb98",paleturquoise:"#afeeee",palevioletred:"#db7093",papayawhip:"#ffefd5",peachpuff:"#ffdab9",peru:"#cd853f",pink:"#ffc0cb",plum:"#dda0dd",powderblue:"#b0e0e6",purple:"#800080",red:"#ff0000",rosybrown:"#bc8f8f",royalblue:"#4169e1",saddlebrown:"#8b4513",salmon:"#fa8072",sandybrown:"#f4a460",seagreen:"#2e8b57",
+seashell:"#fff5ee",sienna:"#a0522d",silver:"#c0c0c0",skyblue:"#87ceeb",slateblue:"#6a5acd",slategray:"#708090",slategrey:"#708090",snow:"#fffafa",springgreen:"#00ff7f",steelblue:"#4682b4",tan:"#d2b48c",teal:"#008080",thistle:"#d8bfd8",tomato:"#ff6347",turquoise:"#40e0d0",violet:"#ee82ee",wheat:"#f5deb3",white:"#ffffff",whitesmoke:"#f5f5f5",yellow:"#ffff00",yellowgreen:"#9acd32"};goog.color.parse=function(a){var b={};a=String(a);var c=goog.color.prependHashIfNecessaryHelper(a);if(goog.color.isValidHexColor_(c))return b.hex=goog.color.normalizeHex(c),b.type="hex",b;c=goog.color.isValidRgbColor_(a);if(c.length)return b.hex=goog.color.rgbArrayToHex(c),b.type="rgb",b;if(goog.color.names&&(c=goog.color.names[a.toLowerCase()]))return b.hex=c,b.type="named",b;throw Error(a+" is not a valid color string");};
+goog.color.isValidColor=function(a){var b=goog.color.prependHashIfNecessaryHelper(a);return!!(goog.color.isValidHexColor_(b)||goog.color.isValidRgbColor_(a).length||goog.color.names&&goog.color.names[a.toLowerCase()])};goog.color.parseRgb=function(a){var b=goog.color.isValidRgbColor_(a);if(!b.length)throw Error(a+" is not a valid RGB color");return b};goog.color.hexToRgbStyle=function(a){return goog.color.rgbStyle_(goog.color.hexToRgb(a))};goog.color.hexTripletRe_=/#(.)(.)(.)/;
+goog.color.normalizeHex=function(a){if(!goog.color.isValidHexColor_(a))throw Error("'"+a+"' is not a valid hex color");4==a.length&&(a=a.replace(goog.color.hexTripletRe_,"#$1$1$2$2$3$3"));return a.toLowerCase()};goog.color.hexToRgb=function(a){a=goog.color.normalizeHex(a);a=parseInt(a.substr(1),16);return[a>>16,a>>8&255,a&255]};
+goog.color.rgbToHex=function(a,b,c){a=Number(a);b=Number(b);c=Number(c);if(a!=(a&255)||b!=(b&255)||c!=(c&255))throw Error('"('+a+","+b+","+c+'") is not a valid RGB color');b=a<<16|b<<8|c;return 16>a?"#"+(16777216|b).toString(16).substr(1):"#"+b.toString(16)};goog.color.rgbArrayToHex=function(a){return goog.color.rgbToHex(a[0],a[1],a[2])};
+goog.color.rgbToHsl=function(a,b,c){a/=255;b/=255;c/=255;var d=Math.max(a,b,c),e=Math.min(a,b,c),f=0,g=0,h=.5*(d+e);d!=e&&(d==a?f=60*(b-c)/(d-e):d==b?f=60*(c-a)/(d-e)+120:d==c&&(f=60*(a-b)/(d-e)+240),g=0<h&&.5>=h?(d-e)/(2*h):(d-e)/(2-2*h));return[Math.round(f+360)%360,g,h]};goog.color.rgbArrayToHsl=function(a){return goog.color.rgbToHsl(a[0],a[1],a[2])};goog.color.hueToRgb_=function(a,b,c){0>c?c+=1:1<c&&--c;return 1>6*c?a+6*(b-a)*c:1>2*c?b:2>3*c?a+(b-a)*(2/3-c)*6:a};
+goog.color.hslToRgb=function(a,b,c){a/=360;if(0==b)c=b=a=255*c;else{var d=.5>c?c*(1+b):c+b-b*c;var e=2*c-d;c=255*goog.color.hueToRgb_(e,d,a+1/3);b=255*goog.color.hueToRgb_(e,d,a);a=255*goog.color.hueToRgb_(e,d,a-1/3)}return[Math.round(c),Math.round(b),Math.round(a)]};goog.color.hslArrayToRgb=function(a){return goog.color.hslToRgb(a[0],a[1],a[2])};goog.color.validHexColorRe_=/^#(?:[0-9a-f]{3}){1,2}$/i;goog.color.isValidHexColor_=function(a){return goog.color.validHexColorRe_.test(a)};
+goog.color.rgbColorRe_=/^(?:rgb)?\((0|[1-9]\d{0,2}),\s?(0|[1-9]\d{0,2}),\s?(0|[1-9]\d{0,2})\)$/i;goog.color.isValidRgbColor_=function(a){var b=a.match(goog.color.rgbColorRe_);if(b){a=Number(b[1]);var c=Number(b[2]);b=Number(b[3]);if(0<=a&&255>=a&&0<=c&&255>=c&&0<=b&&255>=b)return[a,c,b]}return[]};goog.color.prependZeroIfNecessaryHelper=function(a){return 1==a.length?"0"+a:a};goog.color.prependHashIfNecessaryHelper=function(a){return"#"==a.charAt(0)?a:"#"+a};
+goog.color.rgbStyle_=function(a){return"rgb("+a.join(",")+")"};goog.color.hsvToRgb=function(a,b,c){var d=0,e=0,f=0;if(0==b)f=e=d=c;else{var g=Math.floor(a/60),h=a/60-g;a=c*(1-b);var k=c*(1-b*h);b=c*(1-b*(1-h));switch(g){case 1:d=k;e=c;f=a;break;case 2:d=a;e=c;f=b;break;case 3:d=a;e=k;f=c;break;case 4:d=b;e=a;f=c;break;case 5:d=c;e=a;f=k;break;case 6:case 0:d=c,e=b,f=a}}return[Math.floor(d),Math.floor(e),Math.floor(f)]};
+goog.color.rgbToHsv=function(a,b,c){var d=Math.max(Math.max(a,b),c),e=Math.min(Math.min(a,b),c);if(e==d)e=a=0;else{var f=d-e;e=f/d;a=60*(a==d?(b-c)/f:b==d?2+(c-a)/f:4+(a-b)/f);0>a&&(a+=360);360<a&&(a-=360)}return[a,e,d]};goog.color.rgbArrayToHsv=function(a){return goog.color.rgbToHsv(a[0],a[1],a[2])};goog.color.hsvArrayToRgb=function(a){return goog.color.hsvToRgb(a[0],a[1],a[2])};goog.color.hexToHsl=function(a){a=goog.color.hexToRgb(a);return goog.color.rgbToHsl(a[0],a[1],a[2])};
+goog.color.hslToHex=function(a,b,c){return goog.color.rgbArrayToHex(goog.color.hslToRgb(a,b,c))};goog.color.hslArrayToHex=function(a){return goog.color.rgbArrayToHex(goog.color.hslToRgb(a[0],a[1],a[2]))};goog.color.hexToHsv=function(a){return goog.color.rgbArrayToHsv(goog.color.hexToRgb(a))};goog.color.hsvToHex=function(a,b,c){return goog.color.rgbArrayToHex(goog.color.hsvToRgb(a,b,c))};goog.color.hsvArrayToHex=function(a){return goog.color.hsvToHex(a[0],a[1],a[2])};
+goog.color.hslDistance=function(a,b){var c=.5>=a[2]?a[1]*a[2]:a[1]*(1-a[2]);var d=.5>=b[2]?b[1]*b[2]:b[1]*(1-b[2]);return(a[2]-b[2])*(a[2]-b[2])+c*c+d*d-2*c*d*Math.cos(2*(a[0]/360-b[0]/360)*Math.PI)};goog.color.blend=function(a,b,c){c=goog.math.clamp(c,0,1);return[Math.round(b[0]+c*(a[0]-b[0])),Math.round(b[1]+c*(a[1]-b[1])),Math.round(b[2]+c*(a[2]-b[2]))]};goog.color.darken=function(a,b){return goog.color.blend([0,0,0],a,b)};
+goog.color.lighten=function(a,b){return goog.color.blend([255,255,255],a,b)};goog.color.highContrast=function(a,b){for(var c=[],d=0;d<b.length;d++)c.push({color:b[d],diff:goog.color.yiqBrightnessDiff_(b[d],a)+goog.color.colorDiff_(b[d],a)});c.sort(function(a,b){return b.diff-a.diff});return c[0].color};goog.color.yiqBrightness_=function(a){return Math.round((299*a[0]+587*a[1]+114*a[2])/1E3)};goog.color.yiqBrightnessDiff_=function(a,b){return Math.abs(goog.color.yiqBrightness_(a)-goog.color.yiqBrightness_(b))};
+goog.color.colorDiff_=function(a,b){return Math.abs(a[0]-b[0])+Math.abs(a[1]-b[1])+Math.abs(a[2]-b[2])};goog.string={};goog.string.DETECT_DOUBLE_ESCAPING=!1;goog.string.FORCE_NON_DOM_HTML_UNESCAPING=!1;goog.string.Unicode={NBSP:"\u00a0"};goog.string.startsWith=function(a,b){return 0==a.lastIndexOf(b,0)};goog.string.endsWith=function(a,b){var c=a.length-b.length;return 0<=c&&a.indexOf(b,c)==c};goog.string.caseInsensitiveStartsWith=function(a,b){return 0==goog.string.caseInsensitiveCompare(b,a.substr(0,b.length))};
+goog.string.caseInsensitiveEndsWith=function(a,b){return 0==goog.string.caseInsensitiveCompare(b,a.substr(a.length-b.length,b.length))};goog.string.caseInsensitiveEquals=function(a,b){return a.toLowerCase()==b.toLowerCase()};goog.string.subs=function(a,b){for(var c=a.split("%s"),d="",e=Array.prototype.slice.call(arguments,1);e.length&&1<c.length;)d+=c.shift()+e.shift();return d+c.join("%s")};goog.string.collapseWhitespace=function(a){return a.replace(/[\s\xa0]+/g," ").replace(/^\s+|\s+$/g,"")};
+goog.string.isEmptyOrWhitespace=function(a){return/^[\s\xa0]*$/.test(a)};goog.string.isEmptyString=function(a){return 0==a.length};goog.string.isEmpty=goog.string.isEmptyOrWhitespace;goog.string.isEmptyOrWhitespaceSafe=function(a){return goog.string.isEmptyOrWhitespace(goog.string.makeSafe(a))};goog.string.isEmptySafe=goog.string.isEmptyOrWhitespaceSafe;goog.string.isBreakingWhitespace=function(a){return!/[^\t\n\r ]/.test(a)};goog.string.isAlpha=function(a){return!/[^a-zA-Z]/.test(a)};
+goog.string.isNumeric=function(a){return!/[^0-9]/.test(a)};goog.string.isAlphaNumeric=function(a){return!/[^a-zA-Z0-9]/.test(a)};goog.string.isSpace=function(a){return" "==a};goog.string.isUnicodeChar=function(a){return 1==a.length&&" "<=a&&"~">=a||"\u0080"<=a&&"\ufffd">=a};goog.string.stripNewlines=function(a){return a.replace(/(\r\n|\r|\n)+/g," ")};goog.string.canonicalizeNewlines=function(a){return a.replace(/(\r\n|\r|\n)/g,"\n")};
+goog.string.normalizeWhitespace=function(a){return a.replace(/\xa0|\s/g," ")};goog.string.normalizeSpaces=function(a){return a.replace(/\xa0|[ \t]+/g," ")};goog.string.collapseBreakingSpaces=function(a){return a.replace(/[\t\r\n ]+/g," ").replace(/^[\t\r\n ]+|[\t\r\n ]+$/g,"")};goog.string.trim=goog.TRUSTED_SITE&&String.prototype.trim?function(a){return a.trim()}:function(a){return/^[\s\xa0]*([\s\S]*?)[\s\xa0]*$/.exec(a)[1]};goog.string.trimLeft=function(a){return a.replace(/^[\s\xa0]+/,"")};
+goog.string.trimRight=function(a){return a.replace(/[\s\xa0]+$/,"")};goog.string.caseInsensitiveCompare=function(a,b){var c=String(a).toLowerCase(),d=String(b).toLowerCase();return c<d?-1:c==d?0:1};
+goog.string.numberAwareCompare_=function(a,b,c){if(a==b)return 0;if(!a)return-1;if(!b)return 1;for(var d=a.toLowerCase().match(c),e=b.toLowerCase().match(c),f=Math.min(d.length,e.length),g=0;g<f;g++){c=d[g];var h=e[g];if(c!=h)return a=parseInt(c,10),!isNaN(a)&&(b=parseInt(h,10),!isNaN(b)&&a-b)?a-b:c<h?-1:1}return d.length!=e.length?d.length-e.length:a<b?-1:1};goog.string.intAwareCompare=function(a,b){return goog.string.numberAwareCompare_(a,b,/\d+|\D+/g)};
+goog.string.floatAwareCompare=function(a,b){return goog.string.numberAwareCompare_(a,b,/\d+|\.\d+|\D+/g)};goog.string.numerateCompare=goog.string.floatAwareCompare;goog.string.urlEncode=function(a){return encodeURIComponent(String(a))};goog.string.urlDecode=function(a){return decodeURIComponent(a.replace(/\+/g," "))};goog.string.newLineToBr=function(a,b){return a.replace(/(\r\n|\r|\n)/g,b?"<br />":"<br>")};
+goog.string.htmlEscape=function(a,b){if(b)a=a.replace(goog.string.AMP_RE_,"&amp;").replace(goog.string.LT_RE_,"&lt;").replace(goog.string.GT_RE_,"&gt;").replace(goog.string.QUOT_RE_,"&quot;").replace(goog.string.SINGLE_QUOTE_RE_,"&#39;").replace(goog.string.NULL_RE_,"&#0;"),goog.string.DETECT_DOUBLE_ESCAPING&&(a=a.replace(goog.string.E_RE_,"&#101;"));else{if(!goog.string.ALL_RE_.test(a))return a;-1!=a.indexOf("&")&&(a=a.replace(goog.string.AMP_RE_,"&amp;"));-1!=a.indexOf("<")&&(a=a.replace(goog.string.LT_RE_,
+"&lt;"));-1!=a.indexOf(">")&&(a=a.replace(goog.string.GT_RE_,"&gt;"));-1!=a.indexOf('"')&&(a=a.replace(goog.string.QUOT_RE_,"&quot;"));-1!=a.indexOf("'")&&(a=a.replace(goog.string.SINGLE_QUOTE_RE_,"&#39;"));-1!=a.indexOf("\x00")&&(a=a.replace(goog.string.NULL_RE_,"&#0;"));goog.string.DETECT_DOUBLE_ESCAPING&&-1!=a.indexOf("e")&&(a=a.replace(goog.string.E_RE_,"&#101;"))}return a};goog.string.AMP_RE_=/&/g;goog.string.LT_RE_=/</g;goog.string.GT_RE_=/>/g;goog.string.QUOT_RE_=/"/g;
+goog.string.SINGLE_QUOTE_RE_=/'/g;goog.string.NULL_RE_=/\x00/g;goog.string.E_RE_=/e/g;goog.string.ALL_RE_=goog.string.DETECT_DOUBLE_ESCAPING?/[\x00&<>"'e]/:/[\x00&<>"']/;goog.string.unescapeEntities=function(a){return goog.string.contains(a,"&")?!goog.string.FORCE_NON_DOM_HTML_UNESCAPING&&"document"in goog.global?goog.string.unescapeEntitiesUsingDom_(a):goog.string.unescapePureXmlEntities_(a):a};
+goog.string.unescapeEntitiesWithDocument=function(a,b){return goog.string.contains(a,"&")?goog.string.unescapeEntitiesUsingDom_(a,b):a};
+goog.string.unescapeEntitiesUsingDom_=function(a,b){var c={"&amp;":"&","&lt;":"<","&gt;":">","&quot;":'"'};var d=b?b.createElement("div"):goog.global.document.createElement("div");return a.replace(goog.string.HTML_ENTITY_PATTERN_,function(a,b){var e=c[a];if(e)return e;if("#"==b.charAt(0)){var f=Number("0"+b.substr(1));isNaN(f)||(e=String.fromCharCode(f))}e||(d.innerHTML=a+" ",e=d.firstChild.nodeValue.slice(0,-1));return c[a]=e})};
+goog.string.unescapePureXmlEntities_=function(a){return a.replace(/&([^;]+);/g,function(a,c){switch(c){case "amp":return"&";case "lt":return"<";case "gt":return">";case "quot":return'"';default:if("#"==c.charAt(0)){var b=Number("0"+c.substr(1));if(!isNaN(b))return String.fromCharCode(b)}return a}})};goog.string.HTML_ENTITY_PATTERN_=/&([^;\s<&]+);?/g;goog.string.whitespaceEscape=function(a,b){return goog.string.newLineToBr(a.replace(/  /g," &#160;"),b)};
+goog.string.preserveSpaces=function(a){return a.replace(/(^|[\n ]) /g,"$1"+goog.string.Unicode.NBSP)};goog.string.stripQuotes=function(a,b){for(var c=b.length,d=0;d<c;d++){var e=1==c?b:b.charAt(d);if(a.charAt(0)==e&&a.charAt(a.length-1)==e)return a.substring(1,a.length-1)}return a};goog.string.truncate=function(a,b,c){c&&(a=goog.string.unescapeEntities(a));a.length>b&&(a=a.substring(0,b-3)+"...");c&&(a=goog.string.htmlEscape(a));return a};
+goog.string.truncateMiddle=function(a,b,c,d){c&&(a=goog.string.unescapeEntities(a));if(d&&a.length>b){d>b&&(d=b);var e=a.length-d;a=a.substring(0,b-d)+"..."+a.substring(e)}else a.length>b&&(d=Math.floor(b/2),e=a.length-d,a=a.substring(0,d+b%2)+"..."+a.substring(e));c&&(a=goog.string.htmlEscape(a));return a};goog.string.specialEscapeChars_={"\x00":"\\0","\b":"\\b","\f":"\\f","\n":"\\n","\r":"\\r","\t":"\\t","\x0B":"\\x0B",'"':'\\"',"\\":"\\\\","<":"<"};goog.string.jsEscapeCache_={"'":"\\'"};
+goog.string.quote=function(a){a=String(a);for(var b=['"'],c=0;c<a.length;c++){var d=a.charAt(c),e=d.charCodeAt(0);b[c+1]=goog.string.specialEscapeChars_[d]||(31<e&&127>e?d:goog.string.escapeChar(d))}b.push('"');return b.join("")};goog.string.escapeString=function(a){for(var b=[],c=0;c<a.length;c++)b[c]=goog.string.escapeChar(a.charAt(c));return b.join("")};
+goog.string.escapeChar=function(a){if(a in goog.string.jsEscapeCache_)return goog.string.jsEscapeCache_[a];if(a in goog.string.specialEscapeChars_)return goog.string.jsEscapeCache_[a]=goog.string.specialEscapeChars_[a];var b=a.charCodeAt(0);if(31<b&&127>b)var c=a;else{if(256>b){if(c="\\x",16>b||256<b)c+="0"}else c="\\u",4096>b&&(c+="0");c+=b.toString(16).toUpperCase()}return goog.string.jsEscapeCache_[a]=c};goog.string.contains=function(a,b){return-1!=a.indexOf(b)};
+goog.string.caseInsensitiveContains=function(a,b){return goog.string.contains(a.toLowerCase(),b.toLowerCase())};goog.string.countOf=function(a,b){return a&&b?a.split(b).length-1:0};goog.string.removeAt=function(a,b,c){var d=a;0<=b&&b<a.length&&0<c&&(d=a.substr(0,b)+a.substr(b+c,a.length-b-c));return d};goog.string.remove=function(a,b){return a.replace(b,"")};goog.string.removeAll=function(a,b){var c=new RegExp(goog.string.regExpEscape(b),"g");return a.replace(c,"")};
+goog.string.replaceAll=function(a,b,c){b=new RegExp(goog.string.regExpEscape(b),"g");return a.replace(b,c.replace(/\$/g,"$$$$"))};goog.string.regExpEscape=function(a){return String(a).replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g,"\\$1").replace(/\x08/g,"\\x08")};goog.string.repeat=String.prototype.repeat?function(a,b){return a.repeat(b)}:function(a,b){return Array(b+1).join(a)};
+goog.string.padNumber=function(a,b,c){a=goog.isDef(c)?a.toFixed(c):String(a);c=a.indexOf(".");-1==c&&(c=a.length);return goog.string.repeat("0",Math.max(0,b-c))+a};goog.string.makeSafe=function(a){return null==a?"":String(a)};goog.string.buildString=function(a){return Array.prototype.join.call(arguments,"")};goog.string.getRandomString=function(){return Math.floor(2147483648*Math.random()).toString(36)+Math.abs(Math.floor(2147483648*Math.random())^goog.now()).toString(36)};
+goog.string.compareVersions=function(a,b){for(var c=0,d=goog.string.trim(String(a)).split("."),e=goog.string.trim(String(b)).split("."),f=Math.max(d.length,e.length),g=0;0==c&&g<f;g++){var h=d[g]||"",k=e[g]||"";do{h=/(\d*)(\D*)(.*)/.exec(h)||["","","",""];k=/(\d*)(\D*)(.*)/.exec(k)||["","","",""];if(0==h[0].length&&0==k[0].length)break;c=0==h[1].length?0:parseInt(h[1],10);var l=0==k[1].length?0:parseInt(k[1],10);c=goog.string.compareElements_(c,l)||goog.string.compareElements_(0==h[2].length,0==k[2].length)||
+goog.string.compareElements_(h[2],k[2]);h=h[3];k=k[3]}while(0==c)}return c};goog.string.compareElements_=function(a,b){return a<b?-1:a>b?1:0};goog.string.hashCode=function(a){for(var b=0,c=0;c<a.length;++c)b=31*b+a.charCodeAt(c)>>>0;return b};goog.string.uniqueStringCounter_=2147483648*Math.random()|0;goog.string.createUniqueString=function(){return"goog_"+goog.string.uniqueStringCounter_++};goog.string.toNumber=function(a){var b=Number(a);return 0==b&&goog.string.isEmptyOrWhitespace(a)?NaN:b};
+goog.string.isLowerCamelCase=function(a){return/^[a-z]+([A-Z][a-z]*)*$/.test(a)};goog.string.isUpperCamelCase=function(a){return/^([A-Z][a-z]*)+$/.test(a)};goog.string.toCamelCase=function(a){return String(a).replace(/\-([a-z])/g,function(a,c){return c.toUpperCase()})};goog.string.toSelectorCase=function(a){return String(a).replace(/([A-Z])/g,"-$1").toLowerCase()};
+goog.string.toTitleCase=function(a,b){var c=goog.isString(b)?goog.string.regExpEscape(b):"\\s";return a.replace(new RegExp("(^"+(c?"|["+c+"]+":"")+")([a-z])","g"),function(a,b,c){return b+c.toUpperCase()})};goog.string.capitalize=function(a){return String(a.charAt(0)).toUpperCase()+String(a.substr(1)).toLowerCase()};goog.string.parseInt=function(a){isFinite(a)&&(a=String(a));return goog.isString(a)?/^\s*-?0x/i.test(a)?parseInt(a,16):parseInt(a,10):NaN};
+goog.string.splitLimit=function(a,b,c){a=a.split(b);for(var d=[];0<c&&a.length;)d.push(a.shift()),c--;a.length&&d.push(a.join(b));return d};goog.string.lastComponent=function(a,b){if(b)"string"==typeof b&&(b=[b]);else return a;for(var c=-1,d=0;d<b.length;d++)if(""!=b[d]){var e=a.lastIndexOf(b[d]);e>c&&(c=e)}return-1==c?a:a.slice(c+1)};
+goog.string.editDistance=function(a,b){var c=[],d=[];if(a==b)return 0;if(!a.length||!b.length)return Math.max(a.length,b.length);for(var e=0;e<b.length+1;e++)c[e]=e;for(e=0;e<a.length;e++){d[0]=e+1;for(var f=0;f<b.length;f++)d[f+1]=Math.min(d[f]+1,c[f+1]+1,c[f]+Number(a[e]!=b[f]));for(f=0;f<c.length;f++)c[f]=d[f]}return d[b.length]};goog.labs={};goog.labs.userAgent={};goog.labs.userAgent.util={};goog.labs.userAgent.util.getNativeUserAgentString_=function(){var a=goog.labs.userAgent.util.getNavigator_();return a&&(a=a.userAgent)?a:""};goog.labs.userAgent.util.getNavigator_=function(){return goog.global.navigator};goog.labs.userAgent.util.userAgent_=goog.labs.userAgent.util.getNativeUserAgentString_();goog.labs.userAgent.util.setUserAgent=function(a){goog.labs.userAgent.util.userAgent_=a||goog.labs.userAgent.util.getNativeUserAgentString_()};
+goog.labs.userAgent.util.getUserAgent=function(){return goog.labs.userAgent.util.userAgent_};goog.labs.userAgent.util.matchUserAgent=function(a){var b=goog.labs.userAgent.util.getUserAgent();return goog.string.contains(b,a)};goog.labs.userAgent.util.matchUserAgentIgnoreCase=function(a){var b=goog.labs.userAgent.util.getUserAgent();return goog.string.caseInsensitiveContains(b,a)};
+goog.labs.userAgent.util.extractVersionTuples=function(a){for(var b=RegExp("(\\w[\\w ]+)/([^\\s]+)\\s*(?:\\((.*?)\\))?","g"),c=[],d;d=b.exec(a);)c.push([d[1],d[2],d[3]||void 0]);return c};goog.object={};goog.object.is=function(a,b){return a===b?0!==a||1/a===1/b:a!==a&&b!==b};goog.object.forEach=function(a,b,c){for(var d in a)b.call(c,a[d],d,a)};goog.object.filter=function(a,b,c){var d={},e;for(e in a)b.call(c,a[e],e,a)&&(d[e]=a[e]);return d};goog.object.map=function(a,b,c){var d={},e;for(e in a)d[e]=b.call(c,a[e],e,a);return d};goog.object.some=function(a,b,c){for(var d in a)if(b.call(c,a[d],d,a))return!0;return!1};
+goog.object.every=function(a,b,c){for(var d in a)if(!b.call(c,a[d],d,a))return!1;return!0};goog.object.getCount=function(a){var b=0,c;for(c in a)b++;return b};goog.object.getAnyKey=function(a){for(var b in a)return b};goog.object.getAnyValue=function(a){for(var b in a)return a[b]};goog.object.contains=function(a,b){return goog.object.containsValue(a,b)};goog.object.getValues=function(a){var b=[],c=0,d;for(d in a)b[c++]=a[d];return b};
+goog.object.getKeys=function(a){var b=[],c=0,d;for(d in a)b[c++]=d;return b};goog.object.getValueByKeys=function(a,b){var c=goog.isArrayLike(b),d=c?b:arguments;for(c=c?0:1;c<d.length;c++){if(null==a)return;a=a[d[c]]}return a};goog.object.containsKey=function(a,b){return null!==a&&b in a};goog.object.containsValue=function(a,b){for(var c in a)if(a[c]==b)return!0;return!1};goog.object.findKey=function(a,b,c){for(var d in a)if(b.call(c,a[d],d,a))return d};
+goog.object.findValue=function(a,b,c){return(b=goog.object.findKey(a,b,c))&&a[b]};goog.object.isEmpty=function(a){for(var b in a)return!1;return!0};goog.object.clear=function(a){for(var b in a)delete a[b]};goog.object.remove=function(a,b){var c;(c=b in a)&&delete a[b];return c};goog.object.add=function(a,b,c){if(null!==a&&b in a)throw Error('The object already contains the key "'+b+'"');goog.object.set(a,b,c)};goog.object.get=function(a,b,c){return null!==a&&b in a?a[b]:c};
+goog.object.set=function(a,b,c){a[b]=c};goog.object.setIfUndefined=function(a,b,c){return b in a?a[b]:a[b]=c};goog.object.setWithReturnValueIfNotSet=function(a,b,c){if(b in a)return a[b];c=c();return a[b]=c};goog.object.equals=function(a,b){for(var c in a)if(!(c in b)||a[c]!==b[c])return!1;for(c in b)if(!(c in a))return!1;return!0};goog.object.clone=function(a){var b={},c;for(c in a)b[c]=a[c];return b};
+goog.object.unsafeClone=function(a){var b=goog.typeOf(a);if("object"==b||"array"==b){if(goog.isFunction(a.clone))return a.clone();b="array"==b?[]:{};for(var c in a)b[c]=goog.object.unsafeClone(a[c]);return b}return a};goog.object.transpose=function(a){var b={},c;for(c in a)b[a[c]]=c;return b};goog.object.PROTOTYPE_FIELDS_="constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf".split(" ");
+goog.object.extend=function(a,b){for(var c,d,e=1;e<arguments.length;e++){d=arguments[e];for(c in d)a[c]=d[c];for(var f=0;f<goog.object.PROTOTYPE_FIELDS_.length;f++)c=goog.object.PROTOTYPE_FIELDS_[f],Object.prototype.hasOwnProperty.call(d,c)&&(a[c]=d[c])}};
+goog.object.create=function(a){var b=arguments.length;if(1==b&&goog.isArray(arguments[0]))return goog.object.create.apply(null,arguments[0]);if(b%2)throw Error("Uneven number of arguments");for(var c={},d=0;d<b;d+=2)c[arguments[d]]=arguments[d+1];return c};goog.object.createSet=function(a){var b=arguments.length;if(1==b&&goog.isArray(arguments[0]))return goog.object.createSet.apply(null,arguments[0]);for(var c={},d=0;d<b;d++)c[arguments[d]]=!0;return c};
+goog.object.createImmutableView=function(a){var b=a;Object.isFrozen&&!Object.isFrozen(a)&&(b=Object.create(a),Object.freeze(b));return b};goog.object.isImmutableView=function(a){return!!Object.isFrozen&&Object.isFrozen(a)};
+goog.object.getAllPropertyNames=function(a,b,c){if(!a)return[];if(!Object.getOwnPropertyNames||!Object.getPrototypeOf)return goog.object.getKeys(a);for(var d={};a&&(a!==Object.prototype||b)&&(a!==Function.prototype||c);){for(var e=Object.getOwnPropertyNames(a),f=0;f<e.length;f++)d[e[f]]=!0;a=Object.getPrototypeOf(a)}return goog.object.getKeys(d)};goog.labs.userAgent.browser={};goog.labs.userAgent.browser.matchOpera_=function(){return goog.labs.userAgent.util.matchUserAgent("Opera")};goog.labs.userAgent.browser.matchIE_=function(){return goog.labs.userAgent.util.matchUserAgent("Trident")||goog.labs.userAgent.util.matchUserAgent("MSIE")};goog.labs.userAgent.browser.matchEdge_=function(){return goog.labs.userAgent.util.matchUserAgent("Edge")};
+goog.labs.userAgent.browser.matchFirefox_=function(){return goog.labs.userAgent.util.matchUserAgent("Firefox")||goog.labs.userAgent.util.matchUserAgent("FxiOS")};
+goog.labs.userAgent.browser.matchSafari_=function(){return goog.labs.userAgent.util.matchUserAgent("Safari")&&!(goog.labs.userAgent.browser.matchChrome_()||goog.labs.userAgent.browser.matchCoast_()||goog.labs.userAgent.browser.matchOpera_()||goog.labs.userAgent.browser.matchEdge_()||goog.labs.userAgent.browser.matchFirefox_()||goog.labs.userAgent.browser.isSilk()||goog.labs.userAgent.util.matchUserAgent("Android"))};goog.labs.userAgent.browser.matchCoast_=function(){return goog.labs.userAgent.util.matchUserAgent("Coast")};
+goog.labs.userAgent.browser.matchIosWebview_=function(){return(goog.labs.userAgent.util.matchUserAgent("iPad")||goog.labs.userAgent.util.matchUserAgent("iPhone"))&&!goog.labs.userAgent.browser.matchSafari_()&&!goog.labs.userAgent.browser.matchChrome_()&&!goog.labs.userAgent.browser.matchCoast_()&&!goog.labs.userAgent.browser.matchFirefox_()&&goog.labs.userAgent.util.matchUserAgent("AppleWebKit")};
+goog.labs.userAgent.browser.matchChrome_=function(){return(goog.labs.userAgent.util.matchUserAgent("Chrome")||goog.labs.userAgent.util.matchUserAgent("CriOS"))&&!goog.labs.userAgent.browser.matchEdge_()};goog.labs.userAgent.browser.matchAndroidBrowser_=function(){return goog.labs.userAgent.util.matchUserAgent("Android")&&!(goog.labs.userAgent.browser.isChrome()||goog.labs.userAgent.browser.isFirefox()||goog.labs.userAgent.browser.isOpera()||goog.labs.userAgent.browser.isSilk())};
+goog.labs.userAgent.browser.isOpera=goog.labs.userAgent.browser.matchOpera_;goog.labs.userAgent.browser.isIE=goog.labs.userAgent.browser.matchIE_;goog.labs.userAgent.browser.isEdge=goog.labs.userAgent.browser.matchEdge_;goog.labs.userAgent.browser.isFirefox=goog.labs.userAgent.browser.matchFirefox_;goog.labs.userAgent.browser.isSafari=goog.labs.userAgent.browser.matchSafari_;goog.labs.userAgent.browser.isCoast=goog.labs.userAgent.browser.matchCoast_;goog.labs.userAgent.browser.isIosWebview=goog.labs.userAgent.browser.matchIosWebview_;
+goog.labs.userAgent.browser.isChrome=goog.labs.userAgent.browser.matchChrome_;goog.labs.userAgent.browser.isAndroidBrowser=goog.labs.userAgent.browser.matchAndroidBrowser_;goog.labs.userAgent.browser.isSilk=function(){return goog.labs.userAgent.util.matchUserAgent("Silk")};
+goog.labs.userAgent.browser.getVersion=function(){function a(a){a=goog.array.find(a,d);return c[a]||""}var b=goog.labs.userAgent.util.getUserAgent();if(goog.labs.userAgent.browser.isIE())return goog.labs.userAgent.browser.getIEVersion_(b);b=goog.labs.userAgent.util.extractVersionTuples(b);var c={};goog.array.forEach(b,function(a){c[a[0]]=a[1]});var d=goog.partial(goog.object.containsKey,c);return goog.labs.userAgent.browser.isOpera()?a(["Version","Opera"]):goog.labs.userAgent.browser.isEdge()?a(["Edge"]):
+goog.labs.userAgent.browser.isChrome()?a(["Chrome","CriOS"]):(b=b[2])&&b[1]||""};goog.labs.userAgent.browser.isVersionOrHigher=function(a){return 0<=goog.string.compareVersions(goog.labs.userAgent.browser.getVersion(),a)};
+goog.labs.userAgent.browser.getIEVersion_=function(a){var b=/rv: *([\d\.]*)/.exec(a);if(b&&b[1])return b[1];b="";var c=/MSIE +([\d\.]+)/.exec(a);if(c&&c[1])if(a=/Trident\/(\d.\d)/.exec(a),"7.0"==c[1])if(a&&a[1])switch(a[1]){case "4.0":b="8.0";break;case "5.0":b="9.0";break;case "6.0":b="10.0";break;case "7.0":b="11.0"}else b="7.0";else b=c[1];return b};goog.labs.userAgent.engine={};goog.labs.userAgent.engine.isPresto=function(){return goog.labs.userAgent.util.matchUserAgent("Presto")};goog.labs.userAgent.engine.isTrident=function(){return goog.labs.userAgent.util.matchUserAgent("Trident")||goog.labs.userAgent.util.matchUserAgent("MSIE")};goog.labs.userAgent.engine.isEdge=function(){return goog.labs.userAgent.util.matchUserAgent("Edge")};
+goog.labs.userAgent.engine.isWebKit=function(){return goog.labs.userAgent.util.matchUserAgentIgnoreCase("WebKit")&&!goog.labs.userAgent.engine.isEdge()};goog.labs.userAgent.engine.isGecko=function(){return goog.labs.userAgent.util.matchUserAgent("Gecko")&&!goog.labs.userAgent.engine.isWebKit()&&!goog.labs.userAgent.engine.isTrident()&&!goog.labs.userAgent.engine.isEdge()};
+goog.labs.userAgent.engine.getVersion=function(){var a=goog.labs.userAgent.util.getUserAgent();if(a){a=goog.labs.userAgent.util.extractVersionTuples(a);var b=goog.labs.userAgent.engine.getEngineTuple_(a);if(b)return"Gecko"==b[0]?goog.labs.userAgent.engine.getVersionForKey_(a,"Firefox"):b[1];a=a[0];var c;if(a&&(c=a[2])&&(c=/Trident\/([^\s;]+)/.exec(c)))return c[1]}return""};
+goog.labs.userAgent.engine.getEngineTuple_=function(a){if(!goog.labs.userAgent.engine.isEdge())return a[1];for(var b=0;b<a.length;b++){var c=a[b];if("Edge"==c[0])return c}};goog.labs.userAgent.engine.isVersionOrHigher=function(a){return 0<=goog.string.compareVersions(goog.labs.userAgent.engine.getVersion(),a)};goog.labs.userAgent.engine.getVersionForKey_=function(a,b){var c=goog.array.find(a,function(a){return b==a[0]});return c&&c[1]||""};goog.labs.userAgent.platform={};goog.labs.userAgent.platform.isAndroid=function(){return goog.labs.userAgent.util.matchUserAgent("Android")};goog.labs.userAgent.platform.isIpod=function(){return goog.labs.userAgent.util.matchUserAgent("iPod")};goog.labs.userAgent.platform.isIphone=function(){return goog.labs.userAgent.util.matchUserAgent("iPhone")&&!goog.labs.userAgent.util.matchUserAgent("iPod")&&!goog.labs.userAgent.util.matchUserAgent("iPad")};goog.labs.userAgent.platform.isIpad=function(){return goog.labs.userAgent.util.matchUserAgent("iPad")};
+goog.labs.userAgent.platform.isIos=function(){return goog.labs.userAgent.platform.isIphone()||goog.labs.userAgent.platform.isIpad()||goog.labs.userAgent.platform.isIpod()};goog.labs.userAgent.platform.isMacintosh=function(){return goog.labs.userAgent.util.matchUserAgent("Macintosh")};goog.labs.userAgent.platform.isLinux=function(){return goog.labs.userAgent.util.matchUserAgent("Linux")};goog.labs.userAgent.platform.isWindows=function(){return goog.labs.userAgent.util.matchUserAgent("Windows")};
+goog.labs.userAgent.platform.isChromeOS=function(){return goog.labs.userAgent.util.matchUserAgent("CrOS")};goog.labs.userAgent.platform.isChromecast=function(){return goog.labs.userAgent.util.matchUserAgent("CrKey")};goog.labs.userAgent.platform.isKaiOS=function(){return goog.labs.userAgent.util.matchUserAgentIgnoreCase("KaiOS")};
+goog.labs.userAgent.platform.getVersion=function(){var a=goog.labs.userAgent.util.getUserAgent(),b="";goog.labs.userAgent.platform.isWindows()?(b=/Windows (?:NT|Phone) ([0-9.]+)/,b=(a=b.exec(a))?a[1]:"0.0"):goog.labs.userAgent.platform.isIos()?(b=/(?:iPhone|iPod|iPad|CPU)\s+OS\s+(\S+)/,b=(a=b.exec(a))&&a[1].replace(/_/g,".")):goog.labs.userAgent.platform.isMacintosh()?(b=/Mac OS X ([0-9_.]+)/,b=(a=b.exec(a))?a[1].replace(/_/g,"."):"10"):goog.labs.userAgent.platform.isAndroid()?(b=/Android\s+([^\);]+)(\)|;)/,
+b=(a=b.exec(a))&&a[1]):goog.labs.userAgent.platform.isChromeOS()&&(b=/(?:CrOS\s+(?:i686|x86_64)\s+([0-9.]+))/,b=(a=b.exec(a))&&a[1]);return b||""};goog.labs.userAgent.platform.isVersionOrHigher=function(a){return 0<=goog.string.compareVersions(goog.labs.userAgent.platform.getVersion(),a)};goog.reflect={};goog.reflect.object=function(a,b){return b};goog.reflect.objectProperty=function(a,b){return a};goog.reflect.sinkValue=function(a){goog.reflect.sinkValue[" "](a);return a};goog.reflect.sinkValue[" "]=goog.nullFunction;goog.reflect.canAccessProperty=function(a,b){try{return goog.reflect.sinkValue(a[b]),!0}catch(c){}return!1};goog.reflect.cache=function(a,b,c,d){d=d?d(b):b;return Object.prototype.hasOwnProperty.call(a,d)?a[d]:a[d]=c(b)};goog.userAgent={};goog.userAgent.ASSUME_IE=!1;goog.userAgent.ASSUME_EDGE=!1;goog.userAgent.ASSUME_GECKO=!1;goog.userAgent.ASSUME_WEBKIT=!1;goog.userAgent.ASSUME_MOBILE_WEBKIT=!1;goog.userAgent.ASSUME_OPERA=!1;goog.userAgent.ASSUME_ANY_VERSION=!1;goog.userAgent.BROWSER_KNOWN_=goog.userAgent.ASSUME_IE||goog.userAgent.ASSUME_EDGE||goog.userAgent.ASSUME_GECKO||goog.userAgent.ASSUME_MOBILE_WEBKIT||goog.userAgent.ASSUME_WEBKIT||goog.userAgent.ASSUME_OPERA;goog.userAgent.getUserAgentString=function(){return goog.labs.userAgent.util.getUserAgent()};
+goog.userAgent.getNavigatorTyped=function(){return goog.global.navigator||null};goog.userAgent.getNavigator=function(){return goog.userAgent.getNavigatorTyped()};goog.userAgent.OPERA=goog.userAgent.BROWSER_KNOWN_?goog.userAgent.ASSUME_OPERA:goog.labs.userAgent.browser.isOpera();goog.userAgent.IE=goog.userAgent.BROWSER_KNOWN_?goog.userAgent.ASSUME_IE:goog.labs.userAgent.browser.isIE();goog.userAgent.EDGE=goog.userAgent.BROWSER_KNOWN_?goog.userAgent.ASSUME_EDGE:goog.labs.userAgent.engine.isEdge();
+goog.userAgent.EDGE_OR_IE=goog.userAgent.EDGE||goog.userAgent.IE;goog.userAgent.GECKO=goog.userAgent.BROWSER_KNOWN_?goog.userAgent.ASSUME_GECKO:goog.labs.userAgent.engine.isGecko();goog.userAgent.WEBKIT=goog.userAgent.BROWSER_KNOWN_?goog.userAgent.ASSUME_WEBKIT||goog.userAgent.ASSUME_MOBILE_WEBKIT:goog.labs.userAgent.engine.isWebKit();goog.userAgent.isMobile_=function(){return goog.userAgent.WEBKIT&&goog.labs.userAgent.util.matchUserAgent("Mobile")};
+goog.userAgent.MOBILE=goog.userAgent.ASSUME_MOBILE_WEBKIT||goog.userAgent.isMobile_();goog.userAgent.SAFARI=goog.userAgent.WEBKIT;goog.userAgent.determinePlatform_=function(){var a=goog.userAgent.getNavigatorTyped();return a&&a.platform||""};goog.userAgent.PLATFORM=goog.userAgent.determinePlatform_();goog.userAgent.ASSUME_MAC=!1;goog.userAgent.ASSUME_WINDOWS=!1;goog.userAgent.ASSUME_LINUX=!1;goog.userAgent.ASSUME_X11=!1;goog.userAgent.ASSUME_ANDROID=!1;goog.userAgent.ASSUME_IPHONE=!1;
+goog.userAgent.ASSUME_IPAD=!1;goog.userAgent.ASSUME_IPOD=!1;goog.userAgent.ASSUME_KAIOS=!1;goog.userAgent.PLATFORM_KNOWN_=goog.userAgent.ASSUME_MAC||goog.userAgent.ASSUME_WINDOWS||goog.userAgent.ASSUME_LINUX||goog.userAgent.ASSUME_X11||goog.userAgent.ASSUME_ANDROID||goog.userAgent.ASSUME_IPHONE||goog.userAgent.ASSUME_IPAD||goog.userAgent.ASSUME_IPOD;goog.userAgent.MAC=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_MAC:goog.labs.userAgent.platform.isMacintosh();
+goog.userAgent.WINDOWS=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_WINDOWS:goog.labs.userAgent.platform.isWindows();goog.userAgent.isLegacyLinux_=function(){return goog.labs.userAgent.platform.isLinux()||goog.labs.userAgent.platform.isChromeOS()};goog.userAgent.LINUX=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_LINUX:goog.userAgent.isLegacyLinux_();goog.userAgent.isX11_=function(){var a=goog.userAgent.getNavigatorTyped();return!!a&&goog.string.contains(a.appVersion||"","X11")};
+goog.userAgent.X11=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_X11:goog.userAgent.isX11_();goog.userAgent.ANDROID=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_ANDROID:goog.labs.userAgent.platform.isAndroid();goog.userAgent.IPHONE=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_IPHONE:goog.labs.userAgent.platform.isIphone();goog.userAgent.IPAD=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_IPAD:goog.labs.userAgent.platform.isIpad();
+goog.userAgent.IPOD=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_IPOD:goog.labs.userAgent.platform.isIpod();goog.userAgent.IOS=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_IPHONE||goog.userAgent.ASSUME_IPAD||goog.userAgent.ASSUME_IPOD:goog.labs.userAgent.platform.isIos();goog.userAgent.KAIOS=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_KAIOS:goog.labs.userAgent.platform.isKaiOS();
+goog.userAgent.determineVersion_=function(){var a="",b=goog.userAgent.getVersionRegexResult_();b&&(a=b?b[1]:"");return goog.userAgent.IE&&(b=goog.userAgent.getDocumentMode_(),null!=b&&b>parseFloat(a))?String(b):a};
+goog.userAgent.getVersionRegexResult_=function(){var a=goog.userAgent.getUserAgentString();if(goog.userAgent.GECKO)return/rv:([^\);]+)(\)|;)/.exec(a);if(goog.userAgent.EDGE)return/Edge\/([\d\.]+)/.exec(a);if(goog.userAgent.IE)return/\b(?:MSIE|rv)[: ]([^\);]+)(\)|;)/.exec(a);if(goog.userAgent.WEBKIT)return/WebKit\/(\S+)/.exec(a);if(goog.userAgent.OPERA)return/(?:Version)[ \/]?(\S+)/.exec(a)};goog.userAgent.getDocumentMode_=function(){var a=goog.global.document;return a?a.documentMode:void 0};
+goog.userAgent.VERSION=goog.userAgent.determineVersion_();goog.userAgent.compare=function(a,b){return goog.string.compareVersions(a,b)};goog.userAgent.isVersionOrHigherCache_={};goog.userAgent.isVersionOrHigher=function(a){return goog.userAgent.ASSUME_ANY_VERSION||goog.reflect.cache(goog.userAgent.isVersionOrHigherCache_,a,function(){return 0<=goog.string.compareVersions(goog.userAgent.VERSION,a)})};goog.userAgent.isVersion=goog.userAgent.isVersionOrHigher;
+goog.userAgent.isDocumentModeOrHigher=function(a){return Number(goog.userAgent.DOCUMENT_MODE)>=a};goog.userAgent.isDocumentMode=goog.userAgent.isDocumentModeOrHigher;goog.userAgent.DOCUMENT_MODE=function(){var a=goog.global.document,b=goog.userAgent.getDocumentMode_();if(a&&goog.userAgent.IE)return b||("CSS1Compat"==a.compatMode?parseInt(goog.userAgent.VERSION,10):5)}();goog.debug.entryPointRegistry={};goog.debug.EntryPointMonitor=function(){};goog.debug.entryPointRegistry.refList_=[];goog.debug.entryPointRegistry.monitors_=[];goog.debug.entryPointRegistry.monitorsMayExist_=!1;goog.debug.entryPointRegistry.register=function(a){goog.debug.entryPointRegistry.refList_[goog.debug.entryPointRegistry.refList_.length]=a;if(goog.debug.entryPointRegistry.monitorsMayExist_)for(var b=goog.debug.entryPointRegistry.monitors_,c=0;c<b.length;c++)a(goog.bind(b[c].wrap,b[c]))};
+goog.debug.entryPointRegistry.monitorAll=function(a){goog.debug.entryPointRegistry.monitorsMayExist_=!0;for(var b=goog.bind(a.wrap,a),c=0;c<goog.debug.entryPointRegistry.refList_.length;c++)goog.debug.entryPointRegistry.refList_[c](b);goog.debug.entryPointRegistry.monitors_.push(a)};
+goog.debug.entryPointRegistry.unmonitorAllIfPossible=function(a){var b=goog.debug.entryPointRegistry.monitors_;goog.asserts.assert(a==b[b.length-1],"Only the most recent monitor can be unwrapped.");a=goog.bind(a.unwrap,a);for(var c=0;c<goog.debug.entryPointRegistry.refList_.length;c++)goog.debug.entryPointRegistry.refList_[c](a);b.length--};goog.debug.errorcontext={};goog.debug.errorcontext.addErrorContext=function(a,b,c){a[goog.debug.errorcontext.CONTEXT_KEY_]||(a[goog.debug.errorcontext.CONTEXT_KEY_]={});a[goog.debug.errorcontext.CONTEXT_KEY_][b]=c};goog.debug.errorcontext.getErrorContext=function(a){return a[goog.debug.errorcontext.CONTEXT_KEY_]||{}};goog.debug.errorcontext.CONTEXT_KEY_="__closure__error__context__984382";goog.debug.LOGGING_ENABLED=goog.DEBUG;goog.debug.FORCE_SLOPPY_STACKS=!1;goog.debug.catchErrors=function(a,b,c){c=c||goog.global;var d=c.onerror,e=!!b;goog.userAgent.WEBKIT&&!goog.userAgent.isVersionOrHigher("535.3")&&(e=!e);c.onerror=function(b,c,h,k,l){d&&d(b,c,h,k,l);a({message:b,fileName:c,line:h,lineNumber:h,col:k,error:l});return e}};
+goog.debug.expose=function(a,b){if("undefined"==typeof a)return"undefined";if(null==a)return"NULL";var c=[],d;for(d in a)if(b||!goog.isFunction(a[d])){var e=d+" = ";try{e+=a[d]}catch(f){e+="*** "+f+" ***"}c.push(e)}return c.join("\n")};
+goog.debug.deepExpose=function(a,b){var c=[],d=[],e={},f=function(a,g){var h=g+"  ";try{if(goog.isDef(a))if(goog.isNull(a))c.push("NULL");else if(goog.isString(a))c.push('"'+a.replace(/\n/g,"\n"+g)+'"');else if(goog.isFunction(a))c.push(String(a).replace(/\n/g,"\n"+g));else if(goog.isObject(a)){goog.hasUid(a)||d.push(a);var k=goog.getUid(a);if(e[k])c.push("*** reference loop detected (id="+k+") ***");else{e[k]=!0;c.push("{");for(var m in a)if(b||!goog.isFunction(a[m]))c.push("\n"),c.push(h),c.push(m+
+" = "),f(a[m],h);c.push("\n"+g+"}");delete e[k]}}else c.push(a);else c.push("undefined")}catch(p){c.push("*** "+p+" ***")}};f(a,"");for(var g=0;g<d.length;g++)goog.removeUid(d[g]);return c.join("")};goog.debug.exposeArray=function(a){for(var b=[],c=0;c<a.length;c++)goog.isArray(a[c])?b.push(goog.debug.exposeArray(a[c])):b.push(a[c]);return"[ "+b.join(", ")+" ]"};
+goog.debug.normalizeErrorObject=function(a){var b=goog.getObjectByName("window.location.href");null==a&&(a='Unknown Error of type "null/undefined"');if(goog.isString(a))return{message:a,name:"Unknown error",lineNumber:"Not available",fileName:b,stack:"Not available"};var c=!1;try{var d=a.lineNumber||a.line||"Not available"}catch(f){d="Not available",c=!0}try{var e=a.fileName||a.filename||a.sourceURL||goog.global.$googDebugFname||b}catch(f){e="Not available",c=!0}return!c&&a.lineNumber&&a.fileName&&
+a.stack&&a.message&&a.name?a:(b=a.message,null==b&&(b=a.constructor&&a.constructor instanceof Function?'Unknown Error of type "'+(a.constructor.name?a.constructor.name:goog.debug.getFunctionName(a.constructor))+'"':"Unknown Error of unknown type"),{message:b,name:a.name||"UnknownError",lineNumber:d,fileName:e,stack:a.stack||"Not available"})};
+goog.debug.enhanceError=function(a,b){if(a instanceof Error)var c=a;else c=Error(a),Error.captureStackTrace&&Error.captureStackTrace(c,goog.debug.enhanceError);c.stack||(c.stack=goog.debug.getStacktrace(goog.debug.enhanceError));if(b){for(var d=0;c["message"+d];)++d;c["message"+d]=String(b)}return c};goog.debug.enhanceErrorWithContext=function(a,b){var c=goog.debug.enhanceError(a);if(b)for(var d in b)goog.debug.errorcontext.addErrorContext(c,d,b[d]);return c};
+goog.debug.getStacktraceSimple=function(a){if(!goog.debug.FORCE_SLOPPY_STACKS){var b=goog.debug.getNativeStackTrace_(goog.debug.getStacktraceSimple);if(b)return b}b=[];for(var c=arguments.callee.caller,d=0;c&&(!a||d<a);){b.push(goog.debug.getFunctionName(c));b.push("()\n");try{c=c.caller}catch(e){b.push("[exception trying to get caller]\n");break}d++;if(d>=goog.debug.MAX_STACK_DEPTH){b.push("[...long stack...]");break}}a&&d>=a?b.push("[...reached max depth limit...]"):b.push("[end]");return b.join("")};
+goog.debug.MAX_STACK_DEPTH=50;goog.debug.getNativeStackTrace_=function(a){var b=Error();if(Error.captureStackTrace)return Error.captureStackTrace(b,a),String(b.stack);try{throw b;}catch(c){b=c}return(a=b.stack)?String(a):null};goog.debug.getStacktrace=function(a){var b;goog.debug.FORCE_SLOPPY_STACKS||(b=goog.debug.getNativeStackTrace_(a||goog.debug.getStacktrace));b||(b=goog.debug.getStacktraceHelper_(a||arguments.callee.caller,[]));return b};
+goog.debug.getStacktraceHelper_=function(a,b){var c=[];if(goog.array.contains(b,a))c.push("[...circular reference...]");else if(a&&b.length<goog.debug.MAX_STACK_DEPTH){c.push(goog.debug.getFunctionName(a)+"(");for(var d=a.arguments,e=0;d&&e<d.length;e++){0<e&&c.push(", ");var f=d[e];switch(typeof f){case "object":f=f?"object":"null";break;case "string":break;case "number":f=String(f);break;case "boolean":f=f?"true":"false";break;case "function":f=(f=goog.debug.getFunctionName(f))?f:"[fn]";break;default:f=
+typeof f}40<f.length&&(f=f.substr(0,40)+"...");c.push(f)}b.push(a);c.push(")\n");try{c.push(goog.debug.getStacktraceHelper_(a.caller,b))}catch(g){c.push("[exception trying to get caller]\n")}}else a?c.push("[...long stack...]"):c.push("[end]");return c.join("")};goog.debug.getFunctionName=function(a){if(goog.debug.fnNameCache_[a])return goog.debug.fnNameCache_[a];a=String(a);if(!goog.debug.fnNameCache_[a]){var b=/function\s+([^\(]+)/m.exec(a);goog.debug.fnNameCache_[a]=b?b[1]:"[Anonymous]"}return goog.debug.fnNameCache_[a]};
+goog.debug.makeWhitespaceVisible=function(a){return a.replace(/ /g,"[_]").replace(/\f/g,"[f]").replace(/\n/g,"[n]\n").replace(/\r/g,"[r]").replace(/\t/g,"[t]")};goog.debug.runtimeType=function(a){return a instanceof Function?a.displayName||a.name||"unknown type name":a instanceof Object?a.constructor.displayName||a.constructor.name||Object.prototype.toString.call(a):null===a?"null":typeof a};goog.debug.fnNameCache_={};goog.debug.freezeInternal_=goog.DEBUG&&Object.freeze||function(a){return a};
+goog.debug.freeze=function(a){return goog.debug.freezeInternal_(a)};goog.events={};$jscomp.scope.purify=function(a){return{valueOf:a}.valueOf()};
+goog.events.BrowserFeature={HAS_W3C_BUTTON:!goog.userAgent.IE||goog.userAgent.isDocumentModeOrHigher(9),HAS_W3C_EVENT_SUPPORT:!goog.userAgent.IE||goog.userAgent.isDocumentModeOrHigher(9),SET_KEY_CODE_TO_PREVENT_DEFAULT:goog.userAgent.IE&&!goog.userAgent.isVersionOrHigher("9"),HAS_NAVIGATOR_ONLINE_PROPERTY:!goog.userAgent.WEBKIT||goog.userAgent.isVersionOrHigher("528"),HAS_HTML5_NETWORK_EVENT_SUPPORT:goog.userAgent.GECKO&&goog.userAgent.isVersionOrHigher("1.9b")||goog.userAgent.IE&&goog.userAgent.isVersionOrHigher("8")||
+goog.userAgent.OPERA&&goog.userAgent.isVersionOrHigher("9.5")||goog.userAgent.WEBKIT&&goog.userAgent.isVersionOrHigher("528"),HTML5_NETWORK_EVENTS_FIRE_ON_BODY:goog.userAgent.GECKO&&!goog.userAgent.isVersionOrHigher("8")||goog.userAgent.IE&&!goog.userAgent.isVersionOrHigher("9"),TOUCH_ENABLED:"ontouchstart"in goog.global||!!(goog.global.document&&document.documentElement&&"ontouchstart"in document.documentElement)||!(!goog.global.navigator||!goog.global.navigator.maxTouchPoints&&!goog.global.navigator.msMaxTouchPoints),
+POINTER_EVENTS:"PointerEvent"in goog.global,MSPOINTER_EVENTS:"MSPointerEvent"in goog.global&&!(!goog.global.navigator||!goog.global.navigator.msPointerEnabled),PASSIVE_EVENTS:(0,$jscomp.scope.purify)(function(){if(!goog.global.addEventListener||!Object.defineProperty)return!1;var a=!1,b=Object.defineProperty({},"passive",{get:function(){a=!0}});try{goog.global.addEventListener("test",goog.nullFunction,b),goog.global.removeEventListener("test",goog.nullFunction,b)}catch(c){}return a})};goog.disposable={};goog.disposable.IDisposable=function(){};goog.disposable.IDisposable.prototype.dispose=goog.abstractMethod;goog.disposable.IDisposable.prototype.isDisposed=goog.abstractMethod;goog.Disposable=function(){goog.Disposable.MONITORING_MODE!=goog.Disposable.MonitoringMode.OFF&&(goog.Disposable.INCLUDE_STACK_ON_CREATION&&(this.creationStack=Error().stack),goog.Disposable.instances_[goog.getUid(this)]=this);this.disposed_=this.disposed_;this.onDisposeCallbacks_=this.onDisposeCallbacks_};goog.Disposable.MonitoringMode={OFF:0,PERMANENT:1,INTERACTIVE:2};goog.Disposable.MONITORING_MODE=0;goog.Disposable.INCLUDE_STACK_ON_CREATION=!0;goog.Disposable.instances_={};
+goog.Disposable.getUndisposedObjects=function(){var a=[],b;for(b in goog.Disposable.instances_)goog.Disposable.instances_.hasOwnProperty(b)&&a.push(goog.Disposable.instances_[Number(b)]);return a};goog.Disposable.clearUndisposedObjects=function(){goog.Disposable.instances_={}};goog.Disposable.prototype.disposed_=!1;goog.Disposable.prototype.isDisposed=function(){return this.disposed_};goog.Disposable.prototype.getDisposed=goog.Disposable.prototype.isDisposed;
+goog.Disposable.prototype.dispose=function(){if(!this.disposed_&&(this.disposed_=!0,this.disposeInternal(),goog.Disposable.MONITORING_MODE!=goog.Disposable.MonitoringMode.OFF)){var a=goog.getUid(this);if(goog.Disposable.MONITORING_MODE==goog.Disposable.MonitoringMode.PERMANENT&&!goog.Disposable.instances_.hasOwnProperty(a))throw Error(this+" did not call the goog.Disposable base constructor or was disposed of after a clearUndisposedObjects call");if(goog.Disposable.MONITORING_MODE!=goog.Disposable.MonitoringMode.OFF&&
+this.onDisposeCallbacks_&&0<this.onDisposeCallbacks_.length)throw Error(this+" did not empty its onDisposeCallbacks queue. This probably means it overrode dispose() or disposeInternal() without calling the superclass' method.");delete goog.Disposable.instances_[a]}};goog.Disposable.prototype.registerDisposable=function(a){this.addOnDisposeCallback(goog.partial(goog.dispose,a))};
+goog.Disposable.prototype.addOnDisposeCallback=function(a,b){this.disposed_?goog.isDef(b)?a.call(b):a():(this.onDisposeCallbacks_||(this.onDisposeCallbacks_=[]),this.onDisposeCallbacks_.push(goog.isDef(b)?goog.bind(a,b):a))};goog.Disposable.prototype.disposeInternal=function(){if(this.onDisposeCallbacks_)for(;this.onDisposeCallbacks_.length;)this.onDisposeCallbacks_.shift()()};goog.Disposable.isDisposed=function(a){return a&&"function"==typeof a.isDisposed?a.isDisposed():!1};
+goog.dispose=function(a){a&&"function"==typeof a.dispose&&a.dispose()};goog.disposeAll=function(a){for(var b=0,c=arguments.length;b<c;++b){var d=arguments[b];goog.isArrayLike(d)?goog.disposeAll.apply(null,d):goog.dispose(d)}};goog.events.EventId=function(a){this.id=a};goog.events.EventId.prototype.toString=function(){return this.id};goog.events.Event=function(a,b){this.type=a instanceof goog.events.EventId?String(a):a;this.currentTarget=this.target=b;this.defaultPrevented=this.propagationStopped_=!1;this.returnValue_=!0};goog.events.Event.prototype.stopPropagation=function(){this.propagationStopped_=!0};goog.events.Event.prototype.preventDefault=function(){this.defaultPrevented=!0;this.returnValue_=!1};goog.events.Event.stopPropagation=function(a){a.stopPropagation()};goog.events.Event.preventDefault=function(a){a.preventDefault()};goog.events.getVendorPrefixedName_=function(a){return goog.userAgent.WEBKIT?"webkit"+a:goog.userAgent.OPERA?"o"+a.toLowerCase():a.toLowerCase()};
+goog.events.EventType={CLICK:"click",RIGHTCLICK:"rightclick",DBLCLICK:"dblclick",MOUSEDOWN:"mousedown",MOUSEUP:"mouseup",MOUSEOVER:"mouseover",MOUSEOUT:"mouseout",MOUSEMOVE:"mousemove",MOUSEENTER:"mouseenter",MOUSELEAVE:"mouseleave",MOUSECANCEL:"mousecancel",SELECTIONCHANGE:"selectionchange",SELECTSTART:"selectstart",WHEEL:"wheel",KEYPRESS:"keypress",KEYDOWN:"keydown",KEYUP:"keyup",BLUR:"blur",FOCUS:"focus",DEACTIVATE:"deactivate",FOCUSIN:"focusin",FOCUSOUT:"focusout",CHANGE:"change",RESET:"reset",
+SELECT:"select",SUBMIT:"submit",INPUT:"input",PROPERTYCHANGE:"propertychange",DRAGSTART:"dragstart",DRAG:"drag",DRAGENTER:"dragenter",DRAGOVER:"dragover",DRAGLEAVE:"dragleave",DROP:"drop",DRAGEND:"dragend",TOUCHSTART:"touchstart",TOUCHMOVE:"touchmove",TOUCHEND:"touchend",TOUCHCANCEL:"touchcancel",BEFOREUNLOAD:"beforeunload",CONSOLEMESSAGE:"consolemessage",CONTEXTMENU:"contextmenu",DEVICECHANGE:"devicechange",DEVICEMOTION:"devicemotion",DEVICEORIENTATION:"deviceorientation",DOMCONTENTLOADED:"DOMContentLoaded",
+ERROR:"error",HELP:"help",LOAD:"load",LOSECAPTURE:"losecapture",ORIENTATIONCHANGE:"orientationchange",READYSTATECHANGE:"readystatechange",RESIZE:"resize",SCROLL:"scroll",UNLOAD:"unload",CANPLAY:"canplay",CANPLAYTHROUGH:"canplaythrough",DURATIONCHANGE:"durationchange",EMPTIED:"emptied",ENDED:"ended",LOADEDDATA:"loadeddata",LOADEDMETADATA:"loadedmetadata",PAUSE:"pause",PLAY:"play",PLAYING:"playing",RATECHANGE:"ratechange",SEEKED:"seeked",SEEKING:"seeking",STALLED:"stalled",SUSPEND:"suspend",TIMEUPDATE:"timeupdate",
+VOLUMECHANGE:"volumechange",WAITING:"waiting",SOURCEOPEN:"sourceopen",SOURCEENDED:"sourceended",SOURCECLOSED:"sourceclosed",ABORT:"abort",UPDATE:"update",UPDATESTART:"updatestart",UPDATEEND:"updateend",HASHCHANGE:"hashchange",PAGEHIDE:"pagehide",PAGESHOW:"pageshow",POPSTATE:"popstate",COPY:"copy",PASTE:"paste",CUT:"cut",BEFORECOPY:"beforecopy",BEFORECUT:"beforecut",BEFOREPASTE:"beforepaste",ONLINE:"online",OFFLINE:"offline",MESSAGE:"message",CONNECT:"connect",INSTALL:"install",ACTIVATE:"activate",
+FETCH:"fetch",FOREIGNFETCH:"foreignfetch",MESSAGEERROR:"messageerror",STATECHANGE:"statechange",UPDATEFOUND:"updatefound",CONTROLLERCHANGE:"controllerchange",ANIMATIONSTART:goog.events.getVendorPrefixedName_("AnimationStart"),ANIMATIONEND:goog.events.getVendorPrefixedName_("AnimationEnd"),ANIMATIONITERATION:goog.events.getVendorPrefixedName_("AnimationIteration"),TRANSITIONEND:goog.events.getVendorPrefixedName_("TransitionEnd"),POINTERDOWN:"pointerdown",POINTERUP:"pointerup",POINTERCANCEL:"pointercancel",
+POINTERMOVE:"pointermove",POINTEROVER:"pointerover",POINTEROUT:"pointerout",POINTERENTER:"pointerenter",POINTERLEAVE:"pointerleave",GOTPOINTERCAPTURE:"gotpointercapture",LOSTPOINTERCAPTURE:"lostpointercapture",MSGESTURECHANGE:"MSGestureChange",MSGESTUREEND:"MSGestureEnd",MSGESTUREHOLD:"MSGestureHold",MSGESTURESTART:"MSGestureStart",MSGESTURETAP:"MSGestureTap",MSGOTPOINTERCAPTURE:"MSGotPointerCapture",MSINERTIASTART:"MSInertiaStart",MSLOSTPOINTERCAPTURE:"MSLostPointerCapture",MSPOINTERCANCEL:"MSPointerCancel",
+MSPOINTERDOWN:"MSPointerDown",MSPOINTERENTER:"MSPointerEnter",MSPOINTERHOVER:"MSPointerHover",MSPOINTERLEAVE:"MSPointerLeave",MSPOINTERMOVE:"MSPointerMove",MSPOINTEROUT:"MSPointerOut",MSPOINTEROVER:"MSPointerOver",MSPOINTERUP:"MSPointerUp",TEXT:"text",TEXTINPUT:goog.userAgent.IE?"textinput":"textInput",COMPOSITIONSTART:"compositionstart",COMPOSITIONUPDATE:"compositionupdate",COMPOSITIONEND:"compositionend",BEFOREINPUT:"beforeinput",EXIT:"exit",LOADABORT:"loadabort",LOADCOMMIT:"loadcommit",LOADREDIRECT:"loadredirect",
+LOADSTART:"loadstart",LOADSTOP:"loadstop",RESPONSIVE:"responsive",SIZECHANGED:"sizechanged",UNRESPONSIVE:"unresponsive",VISIBILITYCHANGE:"visibilitychange",STORAGE:"storage",DOMSUBTREEMODIFIED:"DOMSubtreeModified",DOMNODEINSERTED:"DOMNodeInserted",DOMNODEREMOVED:"DOMNodeRemoved",DOMNODEREMOVEDFROMDOCUMENT:"DOMNodeRemovedFromDocument",DOMNODEINSERTEDINTODOCUMENT:"DOMNodeInsertedIntoDocument",DOMATTRMODIFIED:"DOMAttrModified",DOMCHARACTERDATAMODIFIED:"DOMCharacterDataModified",BEFOREPRINT:"beforeprint",
+AFTERPRINT:"afterprint",BEFOREINSTALLPROMPT:"beforeinstallprompt",APPINSTALLED:"appinstalled"};goog.events.getPointerFallbackEventName_=function(a,b,c){return goog.events.BrowserFeature.POINTER_EVENTS?a:goog.events.BrowserFeature.MSPOINTER_EVENTS?b:c};
+goog.events.PointerFallbackEventType={POINTERDOWN:goog.events.getPointerFallbackEventName_(goog.events.EventType.POINTERDOWN,goog.events.EventType.MSPOINTERDOWN,goog.events.EventType.MOUSEDOWN),POINTERUP:goog.events.getPointerFallbackEventName_(goog.events.EventType.POINTERUP,goog.events.EventType.MSPOINTERUP,goog.events.EventType.MOUSEUP),POINTERCANCEL:goog.events.getPointerFallbackEventName_(goog.events.EventType.POINTERCANCEL,goog.events.EventType.MSPOINTERCANCEL,goog.events.EventType.MOUSECANCEL),
+POINTERMOVE:goog.events.getPointerFallbackEventName_(goog.events.EventType.POINTERMOVE,goog.events.EventType.MSPOINTERMOVE,goog.events.EventType.MOUSEMOVE),POINTEROVER:goog.events.getPointerFallbackEventName_(goog.events.EventType.POINTEROVER,goog.events.EventType.MSPOINTEROVER,goog.events.EventType.MOUSEOVER),POINTEROUT:goog.events.getPointerFallbackEventName_(goog.events.EventType.POINTEROUT,goog.events.EventType.MSPOINTEROUT,goog.events.EventType.MOUSEOUT),POINTERENTER:goog.events.getPointerFallbackEventName_(goog.events.EventType.POINTERENTER,
+goog.events.EventType.MSPOINTERENTER,goog.events.EventType.MOUSEENTER),POINTERLEAVE:goog.events.getPointerFallbackEventName_(goog.events.EventType.POINTERLEAVE,goog.events.EventType.MSPOINTERLEAVE,goog.events.EventType.MOUSELEAVE)};
+goog.events.PointerTouchFallbackEventType={POINTERDOWN:goog.events.getPointerFallbackEventName_(goog.events.EventType.POINTERDOWN,goog.events.EventType.MSPOINTERDOWN,goog.events.EventType.TOUCHSTART),POINTERUP:goog.events.getPointerFallbackEventName_(goog.events.EventType.POINTERUP,goog.events.EventType.MSPOINTERUP,goog.events.EventType.TOUCHEND),POINTERCANCEL:goog.events.getPointerFallbackEventName_(goog.events.EventType.POINTERCANCEL,goog.events.EventType.MSPOINTERCANCEL,goog.events.EventType.TOUCHCANCEL),
+POINTERMOVE:goog.events.getPointerFallbackEventName_(goog.events.EventType.POINTERMOVE,goog.events.EventType.MSPOINTERMOVE,goog.events.EventType.TOUCHMOVE)};
+goog.events.PointerAsMouseEventType={MOUSEDOWN:goog.events.PointerFallbackEventType.POINTERDOWN,MOUSEUP:goog.events.PointerFallbackEventType.POINTERUP,MOUSECANCEL:goog.events.PointerFallbackEventType.POINTERCANCEL,MOUSEMOVE:goog.events.PointerFallbackEventType.POINTERMOVE,MOUSEOVER:goog.events.PointerFallbackEventType.POINTEROVER,MOUSEOUT:goog.events.PointerFallbackEventType.POINTEROUT,MOUSEENTER:goog.events.PointerFallbackEventType.POINTERENTER,MOUSELEAVE:goog.events.PointerFallbackEventType.POINTERLEAVE};
+goog.events.MouseAsMouseEventType={MOUSEDOWN:goog.events.EventType.MOUSEDOWN,MOUSEUP:goog.events.EventType.MOUSEUP,MOUSECANCEL:goog.events.EventType.MOUSECANCEL,MOUSEMOVE:goog.events.EventType.MOUSEMOVE,MOUSEOVER:goog.events.EventType.MOUSEOVER,MOUSEOUT:goog.events.EventType.MOUSEOUT,MOUSEENTER:goog.events.EventType.MOUSEENTER,MOUSELEAVE:goog.events.EventType.MOUSELEAVE};
+goog.events.PointerAsTouchEventType={TOUCHCANCEL:goog.events.PointerTouchFallbackEventType.POINTERCANCEL,TOUCHEND:goog.events.PointerTouchFallbackEventType.POINTERUP,TOUCHMOVE:goog.events.PointerTouchFallbackEventType.POINTERMOVE,TOUCHSTART:goog.events.PointerTouchFallbackEventType.POINTERDOWN};goog.events.USE_LAYER_XY_AS_OFFSET_XY=!1;goog.events.BrowserEvent=function(a,b){goog.events.Event.call(this,a?a.type:"");this.relatedTarget=this.currentTarget=this.target=null;this.button=this.screenY=this.screenX=this.clientY=this.clientX=this.offsetY=this.offsetX=0;this.key="";this.charCode=this.keyCode=0;this.metaKey=this.shiftKey=this.altKey=this.ctrlKey=!1;this.state=null;this.platformModifierKey=!1;this.pointerId=0;this.pointerType="";this.event_=null;a&&this.init(a,b)};
+goog.inherits(goog.events.BrowserEvent,goog.events.Event);goog.events.BrowserEvent.MouseButton={LEFT:0,MIDDLE:1,RIGHT:2};goog.events.BrowserEvent.PointerType={MOUSE:"mouse",PEN:"pen",TOUCH:"touch"};goog.events.BrowserEvent.IEButtonMap=goog.debug.freeze([1,4,2]);goog.events.BrowserEvent.IE_BUTTON_MAP=goog.events.BrowserEvent.IEButtonMap;goog.events.BrowserEvent.IE_POINTER_TYPE_MAP=goog.debug.freeze({2:goog.events.BrowserEvent.PointerType.TOUCH,3:goog.events.BrowserEvent.PointerType.PEN,4:goog.events.BrowserEvent.PointerType.MOUSE});
+goog.events.BrowserEvent.prototype.init=function(a,b){var c=this.type=a.type,d=a.changedTouches&&a.changedTouches.length?a.changedTouches[0]:null;this.target=a.target||a.srcElement;this.currentTarget=b;var e=a.relatedTarget;e?goog.userAgent.GECKO&&(goog.reflect.canAccessProperty(e,"nodeName")||(e=null)):c==goog.events.EventType.MOUSEOVER?e=a.fromElement:c==goog.events.EventType.MOUSEOUT&&(e=a.toElement);this.relatedTarget=e;d?(this.clientX=void 0!==d.clientX?d.clientX:d.pageX,this.clientY=void 0!==
+d.clientY?d.clientY:d.pageY,this.screenX=d.screenX||0,this.screenY=d.screenY||0):(goog.events.USE_LAYER_XY_AS_OFFSET_XY?(this.offsetX=void 0!==a.layerX?a.layerX:a.offsetX,this.offsetY=void 0!==a.layerY?a.layerY:a.offsetY):(this.offsetX=goog.userAgent.WEBKIT||void 0!==a.offsetX?a.offsetX:a.layerX,this.offsetY=goog.userAgent.WEBKIT||void 0!==a.offsetY?a.offsetY:a.layerY),this.clientX=void 0!==a.clientX?a.clientX:a.pageX,this.clientY=void 0!==a.clientY?a.clientY:a.pageY,this.screenX=a.screenX||0,this.screenY=
+a.screenY||0);this.button=a.button;this.keyCode=a.keyCode||0;this.key=a.key||"";this.charCode=a.charCode||("keypress"==c?a.keyCode:0);this.ctrlKey=a.ctrlKey;this.altKey=a.altKey;this.shiftKey=a.shiftKey;this.metaKey=a.metaKey;this.platformModifierKey=goog.userAgent.MAC?a.metaKey:a.ctrlKey;this.pointerId=a.pointerId||0;this.pointerType=goog.events.BrowserEvent.getPointerType_(a);this.state=a.state;this.event_=a;a.defaultPrevented&&this.preventDefault()};
+goog.events.BrowserEvent.prototype.isButton=function(a){return goog.events.BrowserFeature.HAS_W3C_BUTTON?this.event_.button==a:"click"==this.type?a==goog.events.BrowserEvent.MouseButton.LEFT:!!(this.event_.button&goog.events.BrowserEvent.IE_BUTTON_MAP[a])};goog.events.BrowserEvent.prototype.isMouseActionButton=function(){return this.isButton(goog.events.BrowserEvent.MouseButton.LEFT)&&!(goog.userAgent.WEBKIT&&goog.userAgent.MAC&&this.ctrlKey)};
+goog.events.BrowserEvent.prototype.stopPropagation=function(){goog.events.BrowserEvent.superClass_.stopPropagation.call(this);this.event_.stopPropagation?this.event_.stopPropagation():this.event_.cancelBubble=!0};
+goog.events.BrowserEvent.prototype.preventDefault=function(){goog.events.BrowserEvent.superClass_.preventDefault.call(this);var a=this.event_;if(a.preventDefault)a.preventDefault();else if(a.returnValue=!1,goog.events.BrowserFeature.SET_KEY_CODE_TO_PREVENT_DEFAULT)try{if(a.ctrlKey||112<=a.keyCode&&123>=a.keyCode)a.keyCode=-1}catch(b){}};goog.events.BrowserEvent.prototype.getBrowserEvent=function(){return this.event_};
+goog.events.BrowserEvent.getPointerType_=function(a){return goog.isString(a.pointerType)?a.pointerType:goog.events.BrowserEvent.IE_POINTER_TYPE_MAP[a.pointerType]||""};goog.events.Listenable=function(){};goog.events.Listenable.IMPLEMENTED_BY_PROP="closure_listenable_"+(1E6*Math.random()|0);goog.events.Listenable.addImplementation=function(a){a.prototype[goog.events.Listenable.IMPLEMENTED_BY_PROP]=!0};goog.events.Listenable.isImplementedBy=function(a){return!(!a||!a[goog.events.Listenable.IMPLEMENTED_BY_PROP])};goog.events.ListenableKey=function(){};goog.events.ListenableKey.counter_=0;goog.events.ListenableKey.reserveKey=function(){return++goog.events.ListenableKey.counter_};goog.events.Listener=function(a,b,c,d,e,f){goog.events.Listener.ENABLE_MONITORING&&(this.creationStack=Error().stack);this.listener=a;this.proxy=b;this.src=c;this.type=d;this.capture=!!e;this.handler=f;this.key=goog.events.ListenableKey.reserveKey();this.removed=this.callOnce=!1};goog.events.Listener.ENABLE_MONITORING=!1;goog.events.Listener.prototype.markAsRemoved=function(){this.removed=!0;this.handler=this.src=this.proxy=this.listener=null};goog.events.ListenerMap=function(a){this.src=a;this.listeners={};this.typeCount_=0};goog.events.ListenerMap.prototype.getTypeCount=function(){return this.typeCount_};goog.events.ListenerMap.prototype.getListenerCount=function(){var a=0,b;for(b in this.listeners)a+=this.listeners[b].length;return a};
+goog.events.ListenerMap.prototype.add=function(a,b,c,d,e){var f=a.toString();a=this.listeners[f];a||(a=this.listeners[f]=[],this.typeCount_++);var g=goog.events.ListenerMap.findListenerIndex_(a,b,d,e);-1<g?(b=a[g],c||(b.callOnce=!1)):(b=new goog.events.Listener(b,null,this.src,f,!!d,e),b.callOnce=c,a.push(b));return b};
+goog.events.ListenerMap.prototype.remove=function(a,b,c,d){a=a.toString();if(!(a in this.listeners))return!1;var e=this.listeners[a];b=goog.events.ListenerMap.findListenerIndex_(e,b,c,d);return-1<b?(e[b].markAsRemoved(),goog.array.removeAt(e,b),0==e.length&&(delete this.listeners[a],this.typeCount_--),!0):!1};
+goog.events.ListenerMap.prototype.removeByKey=function(a){var b=a.type;if(!(b in this.listeners))return!1;var c=goog.array.remove(this.listeners[b],a);c&&(a.markAsRemoved(),0==this.listeners[b].length&&(delete this.listeners[b],this.typeCount_--));return c};goog.events.ListenerMap.prototype.removeAll=function(a){a=a&&a.toString();var b=0,c;for(c in this.listeners)if(!a||c==a){for(var d=this.listeners[c],e=0;e<d.length;e++)++b,d[e].markAsRemoved();delete this.listeners[c];this.typeCount_--}return b};
+goog.events.ListenerMap.prototype.getListeners=function(a,b){var c=this.listeners[a.toString()],d=[];if(c)for(var e=0;e<c.length;++e){var f=c[e];f.capture==b&&d.push(f)}return d};goog.events.ListenerMap.prototype.getListener=function(a,b,c,d){a=this.listeners[a.toString()];var e=-1;a&&(e=goog.events.ListenerMap.findListenerIndex_(a,b,c,d));return-1<e?a[e]:null};
+goog.events.ListenerMap.prototype.hasListener=function(a,b){var c=goog.isDef(a),d=c?a.toString():"",e=goog.isDef(b);return goog.object.some(this.listeners,function(a,g){for(var f=0;f<a.length;++f)if(!(c&&a[f].type!=d||e&&a[f].capture!=b))return!0;return!1})};goog.events.ListenerMap.findListenerIndex_=function(a,b,c,d){for(var e=0;e<a.length;++e){var f=a[e];if(!f.removed&&f.listener==b&&f.capture==!!c&&f.handler==d)return e}return-1};goog.events.LISTENER_MAP_PROP_="closure_lm_"+(1E6*Math.random()|0);goog.events.onString_="on";goog.events.onStringMap_={};goog.events.CaptureSimulationMode={OFF_AND_FAIL:0,OFF_AND_SILENT:1,ON:2};goog.events.CAPTURE_SIMULATION_MODE=2;goog.events.listenerCountEstimate_=0;
+goog.events.listen=function(a,b,c,d,e){if(d&&d.once)return goog.events.listenOnce(a,b,c,d,e);if(goog.isArray(b)){for(var f=0;f<b.length;f++)goog.events.listen(a,b[f],c,d,e);return null}c=goog.events.wrapListener(c);return goog.events.Listenable.isImplementedBy(a)?(d=goog.isObject(d)?!!d.capture:!!d,a.listen(b,c,d,e)):goog.events.listen_(a,b,c,!1,d,e)};
+goog.events.listen_=function(a,b,c,d,e,f){if(!b)throw Error("Invalid event type");var g=goog.isObject(e)?!!e.capture:!!e;if(g&&!goog.events.BrowserFeature.HAS_W3C_EVENT_SUPPORT){if(goog.events.CAPTURE_SIMULATION_MODE==goog.events.CaptureSimulationMode.OFF_AND_FAIL)return goog.asserts.fail("Can not register capture listener in IE8-."),null;if(goog.events.CAPTURE_SIMULATION_MODE==goog.events.CaptureSimulationMode.OFF_AND_SILENT)return null}var h=goog.events.getListenerMap_(a);h||(a[goog.events.LISTENER_MAP_PROP_]=
+h=new goog.events.ListenerMap(a));c=h.add(b,c,d,g,f);if(c.proxy)return c;d=goog.events.getProxy();c.proxy=d;d.src=a;d.listener=c;if(a.addEventListener)goog.events.BrowserFeature.PASSIVE_EVENTS||(e=g),void 0===e&&(e=!1),a.addEventListener(b.toString(),d,e);else if(a.attachEvent)a.attachEvent(goog.events.getOnString_(b.toString()),d);else if(a.addListener&&a.removeListener)goog.asserts.assert("change"===b,"MediaQueryList only has a change event"),a.addListener(d);else throw Error("addEventListener and attachEvent are unavailable.");
+goog.events.listenerCountEstimate_++;return c};goog.events.getProxy=function(){var a=goog.events.handleBrowserEvent_,b=goog.events.BrowserFeature.HAS_W3C_EVENT_SUPPORT?function(c){return a.call(b.src,b.listener,c)}:function(c){c=a.call(b.src,b.listener,c);if(!c)return c};return b};
+goog.events.listenOnce=function(a,b,c,d,e){if(goog.isArray(b)){for(var f=0;f<b.length;f++)goog.events.listenOnce(a,b[f],c,d,e);return null}c=goog.events.wrapListener(c);return goog.events.Listenable.isImplementedBy(a)?(d=goog.isObject(d)?!!d.capture:!!d,a.listenOnce(b,c,d,e)):goog.events.listen_(a,b,c,!0,d,e)};goog.events.listenWithWrapper=function(a,b,c,d,e){b.listen(a,c,d,e)};
+goog.events.unlisten=function(a,b,c,d,e){if(goog.isArray(b)){for(var f=0;f<b.length;f++)goog.events.unlisten(a,b[f],c,d,e);return null}d=goog.isObject(d)?!!d.capture:!!d;c=goog.events.wrapListener(c);if(goog.events.Listenable.isImplementedBy(a))return a.unlisten(b,c,d,e);if(!a)return!1;if(a=goog.events.getListenerMap_(a))if(b=a.getListener(b,c,d,e))return goog.events.unlistenByKey(b);return!1};
+goog.events.unlistenByKey=function(a){if(goog.isNumber(a)||!a||a.removed)return!1;var b=a.src;if(goog.events.Listenable.isImplementedBy(b))return b.unlistenByKey(a);var c=a.type,d=a.proxy;b.removeEventListener?b.removeEventListener(c,d,a.capture):b.detachEvent?b.detachEvent(goog.events.getOnString_(c),d):b.addListener&&b.removeListener&&b.removeListener(d);goog.events.listenerCountEstimate_--;(c=goog.events.getListenerMap_(b))?(c.removeByKey(a),0==c.getTypeCount()&&(c.src=null,b[goog.events.LISTENER_MAP_PROP_]=
+null)):a.markAsRemoved();return!0};goog.events.unlistenWithWrapper=function(a,b,c,d,e){b.unlisten(a,c,d,e)};goog.events.removeAll=function(a,b){if(!a)return 0;if(goog.events.Listenable.isImplementedBy(a))return a.removeAllListeners(b);var c=goog.events.getListenerMap_(a);if(!c)return 0;var d=0,e=b&&b.toString(),f;for(f in c.listeners)if(!e||f==e)for(var g=c.listeners[f].concat(),h=0;h<g.length;++h)goog.events.unlistenByKey(g[h])&&++d;return d};
+goog.events.getListeners=function(a,b,c){return goog.events.Listenable.isImplementedBy(a)?a.getListeners(b,c):a?(a=goog.events.getListenerMap_(a))?a.getListeners(b,c):[]:[]};goog.events.getListener=function(a,b,c,d,e){c=goog.events.wrapListener(c);d=!!d;return goog.events.Listenable.isImplementedBy(a)?a.getListener(b,c,d,e):a?(a=goog.events.getListenerMap_(a))?a.getListener(b,c,d,e):null:null};
+goog.events.hasListener=function(a,b,c){if(goog.events.Listenable.isImplementedBy(a))return a.hasListener(b,c);a=goog.events.getListenerMap_(a);return!!a&&a.hasListener(b,c)};goog.events.expose=function(a){var b=[],c;for(c in a)a[c]&&a[c].id?b.push(c+" = "+a[c]+" ("+a[c].id+")"):b.push(c+" = "+a[c]);return b.join("\n")};goog.events.getOnString_=function(a){return a in goog.events.onStringMap_?goog.events.onStringMap_[a]:goog.events.onStringMap_[a]=goog.events.onString_+a};
+goog.events.fireListeners=function(a,b,c,d){return goog.events.Listenable.isImplementedBy(a)?a.fireListeners(b,c,d):goog.events.fireListeners_(a,b,c,d)};goog.events.fireListeners_=function(a,b,c,d){var e=!0;if(a=goog.events.getListenerMap_(a))if(b=a.listeners[b.toString()])for(b=b.concat(),a=0;a<b.length;a++){var f=b[a];f&&f.capture==c&&!f.removed&&(f=goog.events.fireListener(f,d),e=e&&!1!==f)}return e};
+goog.events.fireListener=function(a,b){var c=a.listener,d=a.handler||a.src;a.callOnce&&goog.events.unlistenByKey(a);return c.call(d,b)};goog.events.getTotalListenerCount=function(){return goog.events.listenerCountEstimate_};goog.events.dispatchEvent=function(a,b){goog.asserts.assert(goog.events.Listenable.isImplementedBy(a),"Can not use goog.events.dispatchEvent with non-goog.events.Listenable instance.");return a.dispatchEvent(b)};
+goog.events.protectBrowserEventEntryPoint=function(a){goog.events.handleBrowserEvent_=a.protectEntryPoint(goog.events.handleBrowserEvent_)};
+goog.events.handleBrowserEvent_=function(a,b){if(a.removed)return!0;if(!goog.events.BrowserFeature.HAS_W3C_EVENT_SUPPORT){var c=b||goog.getObjectByName("window.event"),d=new goog.events.BrowserEvent(c,this),e=!0;if(goog.events.CAPTURE_SIMULATION_MODE==goog.events.CaptureSimulationMode.ON){if(!goog.events.isMarkedIeEvent_(c)){goog.events.markIeEvent_(c);c=[];for(var f=d.currentTarget;f;f=f.parentNode)c.push(f);f=a.type;for(var g=c.length-1;!d.propagationStopped_&&0<=g;g--){d.currentTarget=c[g];var h=
+goog.events.fireListeners_(c[g],f,!0,d);e=e&&h}for(g=0;!d.propagationStopped_&&g<c.length;g++)d.currentTarget=c[g],h=goog.events.fireListeners_(c[g],f,!1,d),e=e&&h}}else e=goog.events.fireListener(a,d);return e}return goog.events.fireListener(a,new goog.events.BrowserEvent(b,this))};goog.events.markIeEvent_=function(a){var b=!1;if(0==a.keyCode)try{a.keyCode=-1;return}catch(c){b=!0}if(b||void 0==a.returnValue)a.returnValue=!0};goog.events.isMarkedIeEvent_=function(a){return 0>a.keyCode||void 0!=a.returnValue};
+goog.events.uniqueIdCounter_=0;goog.events.getUniqueId=function(a){return a+"_"+goog.events.uniqueIdCounter_++};goog.events.getListenerMap_=function(a){a=a[goog.events.LISTENER_MAP_PROP_];return a instanceof goog.events.ListenerMap?a:null};goog.events.LISTENER_WRAPPER_PROP_="__closure_events_fn_"+(1E9*Math.random()>>>0);
+goog.events.wrapListener=function(a){goog.asserts.assert(a,"Listener can not be null.");if(goog.isFunction(a))return a;goog.asserts.assert(a.handleEvent,"An object listener must have handleEvent method.");a[goog.events.LISTENER_WRAPPER_PROP_]||(a[goog.events.LISTENER_WRAPPER_PROP_]=function(b){return a.handleEvent(b)});return a[goog.events.LISTENER_WRAPPER_PROP_]};goog.debug.entryPointRegistry.register(function(a){goog.events.handleBrowserEvent_=a(goog.events.handleBrowserEvent_)});goog.dom.HtmlElement=function(){};goog.dom.TagName=function(a){this.tagName_=a};goog.dom.TagName.prototype.toString=function(){return this.tagName_};goog.dom.TagName.A=new goog.dom.TagName("A");goog.dom.TagName.ABBR=new goog.dom.TagName("ABBR");goog.dom.TagName.ACRONYM=new goog.dom.TagName("ACRONYM");goog.dom.TagName.ADDRESS=new goog.dom.TagName("ADDRESS");goog.dom.TagName.APPLET=new goog.dom.TagName("APPLET");goog.dom.TagName.AREA=new goog.dom.TagName("AREA");goog.dom.TagName.ARTICLE=new goog.dom.TagName("ARTICLE");
+goog.dom.TagName.ASIDE=new goog.dom.TagName("ASIDE");goog.dom.TagName.AUDIO=new goog.dom.TagName("AUDIO");goog.dom.TagName.B=new goog.dom.TagName("B");goog.dom.TagName.BASE=new goog.dom.TagName("BASE");goog.dom.TagName.BASEFONT=new goog.dom.TagName("BASEFONT");goog.dom.TagName.BDI=new goog.dom.TagName("BDI");goog.dom.TagName.BDO=new goog.dom.TagName("BDO");goog.dom.TagName.BIG=new goog.dom.TagName("BIG");goog.dom.TagName.BLOCKQUOTE=new goog.dom.TagName("BLOCKQUOTE");goog.dom.TagName.BODY=new goog.dom.TagName("BODY");
+goog.dom.TagName.BR=new goog.dom.TagName("BR");goog.dom.TagName.BUTTON=new goog.dom.TagName("BUTTON");goog.dom.TagName.CANVAS=new goog.dom.TagName("CANVAS");goog.dom.TagName.CAPTION=new goog.dom.TagName("CAPTION");goog.dom.TagName.CENTER=new goog.dom.TagName("CENTER");goog.dom.TagName.CITE=new goog.dom.TagName("CITE");goog.dom.TagName.CODE=new goog.dom.TagName("CODE");goog.dom.TagName.COL=new goog.dom.TagName("COL");goog.dom.TagName.COLGROUP=new goog.dom.TagName("COLGROUP");
+goog.dom.TagName.COMMAND=new goog.dom.TagName("COMMAND");goog.dom.TagName.DATA=new goog.dom.TagName("DATA");goog.dom.TagName.DATALIST=new goog.dom.TagName("DATALIST");goog.dom.TagName.DD=new goog.dom.TagName("DD");goog.dom.TagName.DEL=new goog.dom.TagName("DEL");goog.dom.TagName.DETAILS=new goog.dom.TagName("DETAILS");goog.dom.TagName.DFN=new goog.dom.TagName("DFN");goog.dom.TagName.DIALOG=new goog.dom.TagName("DIALOG");goog.dom.TagName.DIR=new goog.dom.TagName("DIR");goog.dom.TagName.DIV=new goog.dom.TagName("DIV");
+goog.dom.TagName.DL=new goog.dom.TagName("DL");goog.dom.TagName.DT=new goog.dom.TagName("DT");goog.dom.TagName.EM=new goog.dom.TagName("EM");goog.dom.TagName.EMBED=new goog.dom.TagName("EMBED");goog.dom.TagName.FIELDSET=new goog.dom.TagName("FIELDSET");goog.dom.TagName.FIGCAPTION=new goog.dom.TagName("FIGCAPTION");goog.dom.TagName.FIGURE=new goog.dom.TagName("FIGURE");goog.dom.TagName.FONT=new goog.dom.TagName("FONT");goog.dom.TagName.FOOTER=new goog.dom.TagName("FOOTER");goog.dom.TagName.FORM=new goog.dom.TagName("FORM");
+goog.dom.TagName.FRAME=new goog.dom.TagName("FRAME");goog.dom.TagName.FRAMESET=new goog.dom.TagName("FRAMESET");goog.dom.TagName.H1=new goog.dom.TagName("H1");goog.dom.TagName.H2=new goog.dom.TagName("H2");goog.dom.TagName.H3=new goog.dom.TagName("H3");goog.dom.TagName.H4=new goog.dom.TagName("H4");goog.dom.TagName.H5=new goog.dom.TagName("H5");goog.dom.TagName.H6=new goog.dom.TagName("H6");goog.dom.TagName.HEAD=new goog.dom.TagName("HEAD");goog.dom.TagName.HEADER=new goog.dom.TagName("HEADER");
+goog.dom.TagName.HGROUP=new goog.dom.TagName("HGROUP");goog.dom.TagName.HR=new goog.dom.TagName("HR");goog.dom.TagName.HTML=new goog.dom.TagName("HTML");goog.dom.TagName.I=new goog.dom.TagName("I");goog.dom.TagName.IFRAME=new goog.dom.TagName("IFRAME");goog.dom.TagName.IMG=new goog.dom.TagName("IMG");goog.dom.TagName.INPUT=new goog.dom.TagName("INPUT");goog.dom.TagName.INS=new goog.dom.TagName("INS");goog.dom.TagName.ISINDEX=new goog.dom.TagName("ISINDEX");goog.dom.TagName.KBD=new goog.dom.TagName("KBD");
+goog.dom.TagName.KEYGEN=new goog.dom.TagName("KEYGEN");goog.dom.TagName.LABEL=new goog.dom.TagName("LABEL");goog.dom.TagName.LEGEND=new goog.dom.TagName("LEGEND");goog.dom.TagName.LI=new goog.dom.TagName("LI");goog.dom.TagName.LINK=new goog.dom.TagName("LINK");goog.dom.TagName.MAIN=new goog.dom.TagName("MAIN");goog.dom.TagName.MAP=new goog.dom.TagName("MAP");goog.dom.TagName.MARK=new goog.dom.TagName("MARK");goog.dom.TagName.MATH=new goog.dom.TagName("MATH");goog.dom.TagName.MENU=new goog.dom.TagName("MENU");
+goog.dom.TagName.MENUITEM=new goog.dom.TagName("MENUITEM");goog.dom.TagName.META=new goog.dom.TagName("META");goog.dom.TagName.METER=new goog.dom.TagName("METER");goog.dom.TagName.NAV=new goog.dom.TagName("NAV");goog.dom.TagName.NOFRAMES=new goog.dom.TagName("NOFRAMES");goog.dom.TagName.NOSCRIPT=new goog.dom.TagName("NOSCRIPT");goog.dom.TagName.OBJECT=new goog.dom.TagName("OBJECT");goog.dom.TagName.OL=new goog.dom.TagName("OL");goog.dom.TagName.OPTGROUP=new goog.dom.TagName("OPTGROUP");
+goog.dom.TagName.OPTION=new goog.dom.TagName("OPTION");goog.dom.TagName.OUTPUT=new goog.dom.TagName("OUTPUT");goog.dom.TagName.P=new goog.dom.TagName("P");goog.dom.TagName.PARAM=new goog.dom.TagName("PARAM");goog.dom.TagName.PICTURE=new goog.dom.TagName("PICTURE");goog.dom.TagName.PRE=new goog.dom.TagName("PRE");goog.dom.TagName.PROGRESS=new goog.dom.TagName("PROGRESS");goog.dom.TagName.Q=new goog.dom.TagName("Q");goog.dom.TagName.RP=new goog.dom.TagName("RP");goog.dom.TagName.RT=new goog.dom.TagName("RT");
+goog.dom.TagName.RTC=new goog.dom.TagName("RTC");goog.dom.TagName.RUBY=new goog.dom.TagName("RUBY");goog.dom.TagName.S=new goog.dom.TagName("S");goog.dom.TagName.SAMP=new goog.dom.TagName("SAMP");goog.dom.TagName.SCRIPT=new goog.dom.TagName("SCRIPT");goog.dom.TagName.SECTION=new goog.dom.TagName("SECTION");goog.dom.TagName.SELECT=new goog.dom.TagName("SELECT");goog.dom.TagName.SMALL=new goog.dom.TagName("SMALL");goog.dom.TagName.SOURCE=new goog.dom.TagName("SOURCE");goog.dom.TagName.SPAN=new goog.dom.TagName("SPAN");
+goog.dom.TagName.STRIKE=new goog.dom.TagName("STRIKE");goog.dom.TagName.STRONG=new goog.dom.TagName("STRONG");goog.dom.TagName.STYLE=new goog.dom.TagName("STYLE");goog.dom.TagName.SUB=new goog.dom.TagName("SUB");goog.dom.TagName.SUMMARY=new goog.dom.TagName("SUMMARY");goog.dom.TagName.SUP=new goog.dom.TagName("SUP");goog.dom.TagName.SVG=new goog.dom.TagName("SVG");goog.dom.TagName.TABLE=new goog.dom.TagName("TABLE");goog.dom.TagName.TBODY=new goog.dom.TagName("TBODY");goog.dom.TagName.TD=new goog.dom.TagName("TD");
+goog.dom.TagName.TEMPLATE=new goog.dom.TagName("TEMPLATE");goog.dom.TagName.TEXTAREA=new goog.dom.TagName("TEXTAREA");goog.dom.TagName.TFOOT=new goog.dom.TagName("TFOOT");goog.dom.TagName.TH=new goog.dom.TagName("TH");goog.dom.TagName.THEAD=new goog.dom.TagName("THEAD");goog.dom.TagName.TIME=new goog.dom.TagName("TIME");goog.dom.TagName.TITLE=new goog.dom.TagName("TITLE");goog.dom.TagName.TR=new goog.dom.TagName("TR");goog.dom.TagName.TRACK=new goog.dom.TagName("TRACK");goog.dom.TagName.TT=new goog.dom.TagName("TT");
+goog.dom.TagName.U=new goog.dom.TagName("U");goog.dom.TagName.UL=new goog.dom.TagName("UL");goog.dom.TagName.VAR=new goog.dom.TagName("VAR");goog.dom.TagName.VIDEO=new goog.dom.TagName("VIDEO");goog.dom.TagName.WBR=new goog.dom.TagName("WBR");goog.dom.BrowserFeature={CAN_ADD_NAME_OR_TYPE_ATTRIBUTES:!goog.userAgent.IE||goog.userAgent.isDocumentModeOrHigher(9),CAN_USE_CHILDREN_ATTRIBUTE:!goog.userAgent.GECKO&&!goog.userAgent.IE||goog.userAgent.IE&&goog.userAgent.isDocumentModeOrHigher(9)||goog.userAgent.GECKO&&goog.userAgent.isVersionOrHigher("1.9.1"),CAN_USE_INNER_TEXT:goog.userAgent.IE&&!goog.userAgent.isVersionOrHigher("9"),CAN_USE_PARENT_ELEMENT_PROPERTY:goog.userAgent.IE||goog.userAgent.OPERA||goog.userAgent.WEBKIT,INNER_HTML_NEEDS_SCOPED_ELEMENT:goog.userAgent.IE,
+LEGACY_IE_RANGES:goog.userAgent.IE&&!goog.userAgent.isDocumentModeOrHigher(9)};goog.dom.asserts={};goog.dom.asserts.assertIsLocation=function(a){if(goog.asserts.ENABLE_ASSERTS){var b=goog.dom.asserts.getWindow_(a);"undefined"!=typeof b.Location&&"undefined"!=typeof b.Element&&goog.asserts.assert(a&&(a instanceof b.Location||!(a instanceof b.Element)),"Argument is not a Location (or a non-Element mock); got: %s",goog.dom.asserts.debugStringForType_(a))}return a};
+goog.dom.asserts.assertIsElementType_=function(a,b){if(goog.asserts.ENABLE_ASSERTS){var c=goog.dom.asserts.getWindow_(a);"undefined"!=typeof c[b]&&"undefined"!=typeof c.Location&&"undefined"!=typeof c.Element&&goog.asserts.assert(a&&(a instanceof c[b]||!(a instanceof c.Location||a instanceof c.Element)),"Argument is not a %s (or a non-Element, non-Location mock); got: %s",b,goog.dom.asserts.debugStringForType_(a))}return a};
+goog.dom.asserts.assertIsHTMLAnchorElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLAnchorElement")};goog.dom.asserts.assertIsHTMLButtonElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLButtonElement")};goog.dom.asserts.assertIsHTMLLinkElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLLinkElement")};goog.dom.asserts.assertIsHTMLImageElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLImageElement")};
+goog.dom.asserts.assertIsHTMLAudioElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLAudioElement")};goog.dom.asserts.assertIsHTMLVideoElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLVideoElement")};goog.dom.asserts.assertIsHTMLInputElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLInputElement")};goog.dom.asserts.assertIsHTMLTextAreaElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLTextAreaElement")};
+goog.dom.asserts.assertIsHTMLCanvasElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLCanvasElement")};goog.dom.asserts.assertIsHTMLEmbedElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLEmbedElement")};goog.dom.asserts.assertIsHTMLFormElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLFormElement")};goog.dom.asserts.assertIsHTMLFrameElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLFrameElement")};
+goog.dom.asserts.assertIsHTMLIFrameElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLIFrameElement")};goog.dom.asserts.assertIsHTMLObjectElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLObjectElement")};goog.dom.asserts.assertIsHTMLScriptElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLScriptElement")};
+goog.dom.asserts.debugStringForType_=function(a){return goog.isObject(a)?a.constructor.displayName||a.constructor.name||Object.prototype.toString.call(a):void 0===a?"undefined":null===a?"null":typeof a};goog.dom.asserts.getWindow_=function(a){return(a=a&&a.ownerDocument)&&(a.defaultView||a.parentWindow)||goog.global};goog.functions={};goog.functions.constant=function(a){return function(){return a}};goog.functions.FALSE=function(){return!1};goog.functions.TRUE=function(){return!0};goog.functions.NULL=function(){return null};goog.functions.identity=function(a,b){return a};goog.functions.error=function(a){return function(){throw Error(a);}};goog.functions.fail=function(a){return function(){throw a;}};
+goog.functions.lock=function(a,b){b=b||0;return function(){return a.apply(this,Array.prototype.slice.call(arguments,0,b))}};goog.functions.nth=function(a){return function(){return arguments[a]}};goog.functions.partialRight=function(a,b){var c=Array.prototype.slice.call(arguments,1);return function(){var b=Array.prototype.slice.call(arguments);b.push.apply(b,c);return a.apply(this,b)}};goog.functions.withReturnValue=function(a,b){return goog.functions.sequence(a,goog.functions.constant(b))};
+goog.functions.equalTo=function(a,b){return function(c){return b?a==c:a===c}};goog.functions.compose=function(a,b){var c=arguments,d=c.length;return function(){var a;d&&(a=c[d-1].apply(this,arguments));for(var b=d-2;0<=b;b--)a=c[b].call(this,a);return a}};goog.functions.sequence=function(a){var b=arguments,c=b.length;return function(){for(var a,e=0;e<c;e++)a=b[e].apply(this,arguments);return a}};
+goog.functions.and=function(a){var b=arguments,c=b.length;return function(){for(var a=0;a<c;a++)if(!b[a].apply(this,arguments))return!1;return!0}};goog.functions.or=function(a){var b=arguments,c=b.length;return function(){for(var a=0;a<c;a++)if(b[a].apply(this,arguments))return!0;return!1}};goog.functions.not=function(a){return function(){return!a.apply(this,arguments)}};
+goog.functions.create=function(a,b){var c=function(){};c.prototype=a.prototype;c=new c;a.apply(c,Array.prototype.slice.call(arguments,1));return c};goog.functions.CACHE_RETURN_VALUE=!0;goog.functions.cacheReturnValue=function(a){var b=!1,c;return function(){if(!goog.functions.CACHE_RETURN_VALUE)return a();b||(c=a(),b=!0);return c}};goog.functions.once=function(a){var b=a;return function(){if(b){var a=b;b=null;a()}}};
+goog.functions.debounce=function(a,b,c){var d=0;return function(e){goog.global.clearTimeout(d);var f=arguments;d=goog.global.setTimeout(function(){a.apply(c,f)},b)}};goog.functions.throttle=function(a,b,c){var d=0,e=!1,f=[],g=function(){d=0;e&&(e=!1,h())},h=function(){d=goog.global.setTimeout(g,b);a.apply(c,f)};return function(a){f=arguments;d?e=!0:h()}};goog.functions.rateLimit=function(a,b,c){var d=0,e=function(){d=0};return function(f){d||(d=goog.global.setTimeout(e,b),a.apply(c,arguments))}};goog.dom.tags={};goog.dom.tags.VOID_TAGS_={area:!0,base:!0,br:!0,col:!0,command:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0};goog.dom.tags.isVoidTag=function(a){return!0===goog.dom.tags.VOID_TAGS_[a]};goog.string.TypedString=function(){};goog.string.Const=function(a,b){this.stringConstValueWithSecurityContract__googStringSecurityPrivate_=a===goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_&&b||"";this.STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_=goog.string.Const.TYPE_MARKER_};goog.string.Const.prototype.implementsGoogStringTypedString=!0;goog.string.Const.prototype.getTypedStringValue=function(){return this.stringConstValueWithSecurityContract__googStringSecurityPrivate_};
+goog.string.Const.prototype.toString=function(){return"Const{"+this.stringConstValueWithSecurityContract__googStringSecurityPrivate_+"}"};goog.string.Const.unwrap=function(a){if(a instanceof goog.string.Const&&a.constructor===goog.string.Const&&a.STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_===goog.string.Const.TYPE_MARKER_)return a.stringConstValueWithSecurityContract__googStringSecurityPrivate_;goog.asserts.fail("expected object of type Const, got '"+a+"'");return"type_error:Const"};
+goog.string.Const.from=function(a){return new goog.string.Const(goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_,a)};goog.string.Const.TYPE_MARKER_={};goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_={};goog.string.Const.EMPTY=goog.string.Const.from("");goog.html={};goog.html.SafeScript=function(){this.privateDoNotAccessOrElseSafeScriptWrappedValue_="";this.SAFE_SCRIPT_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_=goog.html.SafeScript.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_};goog.html.SafeScript.prototype.implementsGoogStringTypedString=!0;goog.html.SafeScript.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_={};goog.html.SafeScript.fromConstant=function(a){a=goog.string.Const.unwrap(a);return 0===a.length?goog.html.SafeScript.EMPTY:goog.html.SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(a)};
+goog.html.SafeScript.fromConstantAndArgs=function(a,b){for(var c=[],d=1;d<arguments.length;d++)c.push(goog.html.SafeScript.stringify_(arguments[d]));return goog.html.SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse("("+goog.string.Const.unwrap(a)+")("+c.join(", ")+");")};goog.html.SafeScript.fromJson=function(a){return goog.html.SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(goog.html.SafeScript.stringify_(a))};goog.html.SafeScript.prototype.getTypedStringValue=function(){return this.privateDoNotAccessOrElseSafeScriptWrappedValue_};
+goog.DEBUG&&(goog.html.SafeScript.prototype.toString=function(){return"SafeScript{"+this.privateDoNotAccessOrElseSafeScriptWrappedValue_+"}"});
+goog.html.SafeScript.unwrap=function(a){if(a instanceof goog.html.SafeScript&&a.constructor===goog.html.SafeScript&&a.SAFE_SCRIPT_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_===goog.html.SafeScript.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_)return a.privateDoNotAccessOrElseSafeScriptWrappedValue_;goog.asserts.fail("expected object of type SafeScript, got '"+a+"' of type "+goog.typeOf(a));return"type_error:SafeScript"};goog.html.SafeScript.stringify_=function(a){return JSON.stringify(a).replace(/</g,"\\x3c")};
+goog.html.SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse=function(a){return(new goog.html.SafeScript).initSecurityPrivateDoNotAccessOrElse_(a)};goog.html.SafeScript.prototype.initSecurityPrivateDoNotAccessOrElse_=function(a){this.privateDoNotAccessOrElseSafeScriptWrappedValue_=a;return this};goog.html.SafeScript.EMPTY=goog.html.SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse("");goog.fs={};goog.fs.url={};goog.fs.url.createObjectUrl=function(a){return goog.fs.url.getUrlObject_().createObjectURL(a)};goog.fs.url.revokeObjectUrl=function(a){goog.fs.url.getUrlObject_().revokeObjectURL(a)};goog.fs.url.getUrlObject_=function(){var a=goog.fs.url.findUrlObject_();if(null!=a)return a;throw Error("This browser doesn't seem to support blob URLs");};
+goog.fs.url.findUrlObject_=function(){return goog.isDef(goog.global.URL)&&goog.isDef(goog.global.URL.createObjectURL)?goog.global.URL:goog.isDef(goog.global.webkitURL)&&goog.isDef(goog.global.webkitURL.createObjectURL)?goog.global.webkitURL:goog.isDef(goog.global.createObjectURL)?goog.global:null};goog.fs.url.browserSupportsObjectUrls=function(){return null!=goog.fs.url.findUrlObject_()};goog.i18n={};goog.i18n.bidi={};goog.i18n.bidi.FORCE_RTL=!1;
+goog.i18n.bidi.IS_RTL=goog.i18n.bidi.FORCE_RTL||("ar"==goog.LOCALE.substring(0,2).toLowerCase()||"fa"==goog.LOCALE.substring(0,2).toLowerCase()||"he"==goog.LOCALE.substring(0,2).toLowerCase()||"iw"==goog.LOCALE.substring(0,2).toLowerCase()||"ps"==goog.LOCALE.substring(0,2).toLowerCase()||"sd"==goog.LOCALE.substring(0,2).toLowerCase()||"ug"==goog.LOCALE.substring(0,2).toLowerCase()||"ur"==goog.LOCALE.substring(0,2).toLowerCase()||"yi"==goog.LOCALE.substring(0,2).toLowerCase())&&(2==goog.LOCALE.length||
+"-"==goog.LOCALE.substring(2,3)||"_"==goog.LOCALE.substring(2,3))||3<=goog.LOCALE.length&&"ckb"==goog.LOCALE.substring(0,3).toLowerCase()&&(3==goog.LOCALE.length||"-"==goog.LOCALE.substring(3,4)||"_"==goog.LOCALE.substring(3,4))||7<=goog.LOCALE.length&&("-"==goog.LOCALE.substring(2,3)||"_"==goog.LOCALE.substring(2,3))&&("adlm"==goog.LOCALE.substring(3,7).toLowerCase()||"arab"==goog.LOCALE.substring(3,7).toLowerCase()||"hebr"==goog.LOCALE.substring(3,7).toLowerCase()||"nkoo"==goog.LOCALE.substring(3,
+7).toLowerCase()||"rohg"==goog.LOCALE.substring(3,7).toLowerCase()||"thaa"==goog.LOCALE.substring(3,7).toLowerCase())||8<=goog.LOCALE.length&&("-"==goog.LOCALE.substring(3,4)||"_"==goog.LOCALE.substring(3,4))&&("adlm"==goog.LOCALE.substring(4,8).toLowerCase()||"arab"==goog.LOCALE.substring(4,8).toLowerCase()||"hebr"==goog.LOCALE.substring(4,8).toLowerCase()||"nkoo"==goog.LOCALE.substring(4,8).toLowerCase()||"rohg"==goog.LOCALE.substring(4,8).toLowerCase()||"thaa"==goog.LOCALE.substring(4,8).toLowerCase());
+goog.i18n.bidi.Format={LRE:"\u202a",RLE:"\u202b",PDF:"\u202c",LRM:"\u200e",RLM:"\u200f"};goog.i18n.bidi.Dir={LTR:1,RTL:-1,NEUTRAL:0};goog.i18n.bidi.RIGHT="right";goog.i18n.bidi.LEFT="left";goog.i18n.bidi.I18N_RIGHT=goog.i18n.bidi.IS_RTL?goog.i18n.bidi.LEFT:goog.i18n.bidi.RIGHT;goog.i18n.bidi.I18N_LEFT=goog.i18n.bidi.IS_RTL?goog.i18n.bidi.RIGHT:goog.i18n.bidi.LEFT;
+goog.i18n.bidi.toDir=function(a,b){return"number"==typeof a?0<a?goog.i18n.bidi.Dir.LTR:0>a?goog.i18n.bidi.Dir.RTL:b?null:goog.i18n.bidi.Dir.NEUTRAL:null==a?null:a?goog.i18n.bidi.Dir.RTL:goog.i18n.bidi.Dir.LTR};goog.i18n.bidi.ltrChars_="A-Za-z\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u02b8\u0300-\u0590\u0900-\u1fff\u200e\u2c00-\ud801\ud804-\ud839\ud83c-\udbff\uf900-\ufb1c\ufe00-\ufe6f\ufefd-\uffff";goog.i18n.bidi.rtlChars_="\u0591-\u06ef\u06fa-\u08ff\u200f\ud802-\ud803\ud83a-\ud83b\ufb1d-\ufdff\ufe70-\ufefc";
+goog.i18n.bidi.htmlSkipReg_=/<[^>]*>|&[^;]+;/g;goog.i18n.bidi.stripHtmlIfNeeded_=function(a,b){return b?a.replace(goog.i18n.bidi.htmlSkipReg_,""):a};goog.i18n.bidi.rtlCharReg_=new RegExp("["+goog.i18n.bidi.rtlChars_+"]");goog.i18n.bidi.ltrCharReg_=new RegExp("["+goog.i18n.bidi.ltrChars_+"]");goog.i18n.bidi.hasAnyRtl=function(a,b){return goog.i18n.bidi.rtlCharReg_.test(goog.i18n.bidi.stripHtmlIfNeeded_(a,b))};goog.i18n.bidi.hasRtlChar=goog.i18n.bidi.hasAnyRtl;
+goog.i18n.bidi.hasAnyLtr=function(a,b){return goog.i18n.bidi.ltrCharReg_.test(goog.i18n.bidi.stripHtmlIfNeeded_(a,b))};goog.i18n.bidi.ltrRe_=new RegExp("^["+goog.i18n.bidi.ltrChars_+"]");goog.i18n.bidi.rtlRe_=new RegExp("^["+goog.i18n.bidi.rtlChars_+"]");goog.i18n.bidi.isRtlChar=function(a){return goog.i18n.bidi.rtlRe_.test(a)};goog.i18n.bidi.isLtrChar=function(a){return goog.i18n.bidi.ltrRe_.test(a)};goog.i18n.bidi.isNeutralChar=function(a){return!goog.i18n.bidi.isLtrChar(a)&&!goog.i18n.bidi.isRtlChar(a)};
+goog.i18n.bidi.ltrDirCheckRe_=new RegExp("^[^"+goog.i18n.bidi.rtlChars_+"]*["+goog.i18n.bidi.ltrChars_+"]");goog.i18n.bidi.rtlDirCheckRe_=new RegExp("^[^"+goog.i18n.bidi.ltrChars_+"]*["+goog.i18n.bidi.rtlChars_+"]");goog.i18n.bidi.startsWithRtl=function(a,b){return goog.i18n.bidi.rtlDirCheckRe_.test(goog.i18n.bidi.stripHtmlIfNeeded_(a,b))};goog.i18n.bidi.isRtlText=goog.i18n.bidi.startsWithRtl;
+goog.i18n.bidi.startsWithLtr=function(a,b){return goog.i18n.bidi.ltrDirCheckRe_.test(goog.i18n.bidi.stripHtmlIfNeeded_(a,b))};goog.i18n.bidi.isLtrText=goog.i18n.bidi.startsWithLtr;goog.i18n.bidi.isRequiredLtrRe_=/^http:\/\/.*/;goog.i18n.bidi.isNeutralText=function(a,b){a=goog.i18n.bidi.stripHtmlIfNeeded_(a,b);return goog.i18n.bidi.isRequiredLtrRe_.test(a)||!goog.i18n.bidi.hasAnyLtr(a)&&!goog.i18n.bidi.hasAnyRtl(a)};
+goog.i18n.bidi.ltrExitDirCheckRe_=new RegExp("["+goog.i18n.bidi.ltrChars_+"][^"+goog.i18n.bidi.rtlChars_+"]*$");goog.i18n.bidi.rtlExitDirCheckRe_=new RegExp("["+goog.i18n.bidi.rtlChars_+"][^"+goog.i18n.bidi.ltrChars_+"]*$");goog.i18n.bidi.endsWithLtr=function(a,b){return goog.i18n.bidi.ltrExitDirCheckRe_.test(goog.i18n.bidi.stripHtmlIfNeeded_(a,b))};goog.i18n.bidi.isLtrExitText=goog.i18n.bidi.endsWithLtr;
+goog.i18n.bidi.endsWithRtl=function(a,b){return goog.i18n.bidi.rtlExitDirCheckRe_.test(goog.i18n.bidi.stripHtmlIfNeeded_(a,b))};goog.i18n.bidi.isRtlExitText=goog.i18n.bidi.endsWithRtl;goog.i18n.bidi.rtlLocalesRe_=/^(ar|ckb|dv|he|iw|fa|nqo|ps|sd|ug|ur|yi|.*[-_](Adlm|Arab|Hebr|Nkoo|Rohg|Thaa))(?!.*[-_](Latn|Cyrl)($|-|_))($|-|_)/i;goog.i18n.bidi.isRtlLanguage=function(a){return goog.i18n.bidi.rtlLocalesRe_.test(a)};goog.i18n.bidi.bracketGuardTextRe_=/(\(.*?\)+)|(\[.*?\]+)|(\{.*?\}+)|(<.*?>+)/g;
+goog.i18n.bidi.guardBracketInText=function(a,b){var c=(void 0===b?goog.i18n.bidi.hasAnyRtl(a):b)?goog.i18n.bidi.Format.RLM:goog.i18n.bidi.Format.LRM;return a.replace(goog.i18n.bidi.bracketGuardTextRe_,c+"$&"+c)};goog.i18n.bidi.enforceRtlInHtml=function(a){return"<"==a.charAt(0)?a.replace(/<\w+/,"$& dir=rtl"):"\n<span dir=rtl>"+a+"</span>"};goog.i18n.bidi.enforceRtlInText=function(a){return goog.i18n.bidi.Format.RLE+a+goog.i18n.bidi.Format.PDF};
+goog.i18n.bidi.enforceLtrInHtml=function(a){return"<"==a.charAt(0)?a.replace(/<\w+/,"$& dir=ltr"):"\n<span dir=ltr>"+a+"</span>"};goog.i18n.bidi.enforceLtrInText=function(a){return goog.i18n.bidi.Format.LRE+a+goog.i18n.bidi.Format.PDF};goog.i18n.bidi.dimensionsRe_=/:\s*([.\d][.\w]*)\s+([.\d][.\w]*)\s+([.\d][.\w]*)\s+([.\d][.\w]*)/g;goog.i18n.bidi.leftRe_=/left/gi;goog.i18n.bidi.rightRe_=/right/gi;goog.i18n.bidi.tempRe_=/%%%%/g;
+goog.i18n.bidi.mirrorCSS=function(a){return a.replace(goog.i18n.bidi.dimensionsRe_,":$1 $4 $3 $2").replace(goog.i18n.bidi.leftRe_,"%%%%").replace(goog.i18n.bidi.rightRe_,goog.i18n.bidi.LEFT).replace(goog.i18n.bidi.tempRe_,goog.i18n.bidi.RIGHT)};goog.i18n.bidi.doubleQuoteSubstituteRe_=/([\u0591-\u05f2])"/g;goog.i18n.bidi.singleQuoteSubstituteRe_=/([\u0591-\u05f2])'/g;
+goog.i18n.bidi.normalizeHebrewQuote=function(a){return a.replace(goog.i18n.bidi.doubleQuoteSubstituteRe_,"$1\u05f4").replace(goog.i18n.bidi.singleQuoteSubstituteRe_,"$1\u05f3")};goog.i18n.bidi.wordSeparatorRe_=/\s+/;goog.i18n.bidi.hasNumeralsRe_=/[\d\u06f0-\u06f9]/;goog.i18n.bidi.rtlDetectionThreshold_=.4;
+goog.i18n.bidi.estimateDirection=function(a,b){for(var c=0,d=0,e=!1,f=goog.i18n.bidi.stripHtmlIfNeeded_(a,b).split(goog.i18n.bidi.wordSeparatorRe_),g=0;g<f.length;g++){var h=f[g];goog.i18n.bidi.startsWithRtl(h)?(c++,d++):goog.i18n.bidi.isRequiredLtrRe_.test(h)?e=!0:goog.i18n.bidi.hasAnyLtr(h)?d++:goog.i18n.bidi.hasNumeralsRe_.test(h)&&(e=!0)}return 0==d?e?goog.i18n.bidi.Dir.LTR:goog.i18n.bidi.Dir.NEUTRAL:c/d>goog.i18n.bidi.rtlDetectionThreshold_?goog.i18n.bidi.Dir.RTL:goog.i18n.bidi.Dir.LTR};
+goog.i18n.bidi.detectRtlDirectionality=function(a,b){return goog.i18n.bidi.estimateDirection(a,b)==goog.i18n.bidi.Dir.RTL};goog.i18n.bidi.setElementDirAndAlign=function(a,b){a&&(b=goog.i18n.bidi.toDir(b))&&(a.style.textAlign=b==goog.i18n.bidi.Dir.RTL?goog.i18n.bidi.RIGHT:goog.i18n.bidi.LEFT,a.dir=b==goog.i18n.bidi.Dir.RTL?"rtl":"ltr")};
+goog.i18n.bidi.setElementDirByTextDirectionality=function(a,b){switch(goog.i18n.bidi.estimateDirection(b)){case goog.i18n.bidi.Dir.LTR:a.dir="ltr";break;case goog.i18n.bidi.Dir.RTL:a.dir="rtl";break;default:a.removeAttribute("dir")}};goog.i18n.bidi.DirectionalString=function(){};goog.html.TrustedResourceUrl=function(){this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_="";this.TRUSTED_RESOURCE_URL_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_=goog.html.TrustedResourceUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_};goog.html.TrustedResourceUrl.prototype.implementsGoogStringTypedString=!0;goog.html.TrustedResourceUrl.prototype.getTypedStringValue=function(){return this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_};
+goog.html.TrustedResourceUrl.prototype.implementsGoogI18nBidiDirectionalString=!0;goog.html.TrustedResourceUrl.prototype.getDirection=function(){return goog.i18n.bidi.Dir.LTR};
+goog.html.TrustedResourceUrl.prototype.cloneWithParams=function(a,b){var c=goog.html.TrustedResourceUrl.unwrap(this);c=goog.html.TrustedResourceUrl.URL_PARAM_PARSER_.exec(c);var d=c[3]||"";return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(c[1]+goog.html.TrustedResourceUrl.stringifyParams_("?",c[2]||"",a)+goog.html.TrustedResourceUrl.stringifyParams_("#",d,b))};
+goog.DEBUG&&(goog.html.TrustedResourceUrl.prototype.toString=function(){return"TrustedResourceUrl{"+this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_+"}"});
+goog.html.TrustedResourceUrl.unwrap=function(a){if(a instanceof goog.html.TrustedResourceUrl&&a.constructor===goog.html.TrustedResourceUrl&&a.TRUSTED_RESOURCE_URL_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_===goog.html.TrustedResourceUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_)return a.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_;goog.asserts.fail("expected object of type TrustedResourceUrl, got '"+a+"' of type "+goog.typeOf(a));return"type_error:TrustedResourceUrl"};
+goog.html.TrustedResourceUrl.format=function(a,b){var c=goog.string.Const.unwrap(a);if(!goog.html.TrustedResourceUrl.BASE_URL_.test(c))throw Error("Invalid TrustedResourceUrl format: "+c);var d=c.replace(goog.html.TrustedResourceUrl.FORMAT_MARKER_,function(a,d){if(!Object.prototype.hasOwnProperty.call(b,d))throw Error('Found marker, "'+d+'", in format string, "'+c+'", but no valid label mapping found in args: '+JSON.stringify(b));var e=b[d];return e instanceof goog.string.Const?goog.string.Const.unwrap(e):
+encodeURIComponent(String(e))});return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(d)};goog.html.TrustedResourceUrl.FORMAT_MARKER_=/%{(\w+)}/g;goog.html.TrustedResourceUrl.BASE_URL_=/^((https:)?\/\/[0-9a-z.:[\]-]+\/|\/[^/\\]|[^:/\\%]+\/|[^:/\\%]*[?#]|about:blank#)/i;goog.html.TrustedResourceUrl.URL_PARAM_PARSER_=/^([^?#]*)(\?[^#]*)?(#[\s\S]*)?/;
+goog.html.TrustedResourceUrl.formatWithParams=function(a,b,c,d){return goog.html.TrustedResourceUrl.format(a,b).cloneWithParams(c,d)};goog.html.TrustedResourceUrl.fromConstant=function(a){return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(goog.string.Const.unwrap(a))};goog.html.TrustedResourceUrl.fromConstants=function(a){for(var b="",c=0;c<a.length;c++)b+=goog.string.Const.unwrap(a[c]);return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(b)};
+goog.html.TrustedResourceUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_={};goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse=function(a){var b=new goog.html.TrustedResourceUrl;b.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_=a;return b};
+goog.html.TrustedResourceUrl.stringifyParams_=function(a,b,c){if(null==c)return b;if(goog.isString(c))return c?a+encodeURIComponent(c):"";for(var d in c){var e=c[d];e=goog.isArray(e)?e:[e];for(var f=0;f<e.length;f++){var g=e[f];null!=g&&(b||(b=a),b+=(b.length>a.length?"&":"")+encodeURIComponent(d)+"="+encodeURIComponent(String(g)))}}return b};goog.html.SafeUrl=function(){this.privateDoNotAccessOrElseSafeUrlWrappedValue_="";this.SAFE_URL_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_=goog.html.SafeUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_};goog.html.SafeUrl.INNOCUOUS_STRING="about:invalid#zClosurez";goog.html.SafeUrl.prototype.implementsGoogStringTypedString=!0;goog.html.SafeUrl.prototype.getTypedStringValue=function(){return this.privateDoNotAccessOrElseSafeUrlWrappedValue_};
+goog.html.SafeUrl.prototype.implementsGoogI18nBidiDirectionalString=!0;goog.html.SafeUrl.prototype.getDirection=function(){return goog.i18n.bidi.Dir.LTR};goog.DEBUG&&(goog.html.SafeUrl.prototype.toString=function(){return"SafeUrl{"+this.privateDoNotAccessOrElseSafeUrlWrappedValue_+"}"});
+goog.html.SafeUrl.unwrap=function(a){if(a instanceof goog.html.SafeUrl&&a.constructor===goog.html.SafeUrl&&a.SAFE_URL_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_===goog.html.SafeUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_)return a.privateDoNotAccessOrElseSafeUrlWrappedValue_;goog.asserts.fail("expected object of type SafeUrl, got '"+a+"' of type "+goog.typeOf(a));return"type_error:SafeUrl"};goog.html.SafeUrl.fromConstant=function(a){return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(goog.string.Const.unwrap(a))};
+goog.html.SAFE_MIME_TYPE_PATTERN_=/^(?:audio\/(?:3gpp2|3gpp|aac|L16|midi|mp3|mp4|mpeg|oga|ogg|opus|x-m4a|x-wav|wav|webm)|image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|text\/csv|video\/(?:mpeg|mp4|ogg|webm|quicktime))$/i;goog.html.SafeUrl.fromBlob=function(a){a=goog.html.SAFE_MIME_TYPE_PATTERN_.test(a.type)?goog.fs.url.createObjectUrl(a):goog.html.SafeUrl.INNOCUOUS_STRING;return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.DATA_URL_PATTERN_=/^data:([^;,]*);base64,[a-z0-9+\/]+=*$/i;
+goog.html.SafeUrl.fromDataUrl=function(a){a=a.replace(/(%0A|%0D)/g,"");var b=a.match(goog.html.DATA_URL_PATTERN_);b=b&&goog.html.SAFE_MIME_TYPE_PATTERN_.test(b[1]);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(b?a:goog.html.SafeUrl.INNOCUOUS_STRING)};goog.html.SafeUrl.fromTelUrl=function(a){goog.string.caseInsensitiveStartsWith(a,"tel:")||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};
+goog.html.SIP_URL_PATTERN_=/^sip[s]?:[+a-z0-9_.!$%&'*\/=^`{|}~-]+@([a-z0-9-]+\.)+[a-z0-9]{2,63}$/i;goog.html.SafeUrl.fromSipUrl=function(a){goog.html.SIP_URL_PATTERN_.test(decodeURIComponent(a))||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.SafeUrl.fromFacebookMessengerUrl=function(a){goog.string.caseInsensitiveStartsWith(a,"fb-messenger://share")||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};
+goog.html.SafeUrl.fromSmsUrl=function(a){goog.string.caseInsensitiveStartsWith(a,"sms:")&&goog.html.SafeUrl.isSmsUrlBodyValid_(a)||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.SafeUrl.isSmsUrlBodyValid_=function(a){var b=a.indexOf("#");0<b&&(a=a.substring(0,b));b=a.match(/[?&]body=/gi);if(!b)return!0;if(1<b.length)return!1;a=a.match(/[?&]body=([^&]*)/)[1];if(!a)return!0;try{decodeURIComponent(a)}catch(c){return!1}return/^(?:[a-z0-9\-_.~]|%[0-9a-f]{2})+$/i.test(a)};
+goog.html.SafeUrl.sanitizeChromeExtensionUrl=function(a,b){return goog.html.SafeUrl.sanitizeExtensionUrl_(/^chrome-extension:\/\/([^\/]+)\//,a,b)};goog.html.SafeUrl.sanitizeFirefoxExtensionUrl=function(a,b){return goog.html.SafeUrl.sanitizeExtensionUrl_(/^moz-extension:\/\/([^\/]+)\//,a,b)};goog.html.SafeUrl.sanitizeEdgeExtensionUrl=function(a,b){return goog.html.SafeUrl.sanitizeExtensionUrl_(/^ms-browser-extension:\/\/([^\/]+)\//,a,b)};
+goog.html.SafeUrl.sanitizeExtensionUrl_=function(a,b,c){(a=a.exec(b))?(a=a[1],-1==(c instanceof goog.string.Const?[goog.string.Const.unwrap(c)]:c.map(function(a){return goog.string.Const.unwrap(a)})).indexOf(a)&&(b=goog.html.SafeUrl.INNOCUOUS_STRING)):b=goog.html.SafeUrl.INNOCUOUS_STRING;return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(b)};goog.html.SafeUrl.fromTrustedResourceUrl=function(a){return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(goog.html.TrustedResourceUrl.unwrap(a))};
+goog.html.SAFE_URL_PATTERN_=/^(?:(?:https?|mailto|ftp):|[^:/?#]*(?:[/?#]|$))/i;goog.html.SafeUrl.SAFE_URL_PATTERN=goog.html.SAFE_URL_PATTERN_;goog.html.SafeUrl.sanitize=function(a){if(a instanceof goog.html.SafeUrl)return a;a="object"==typeof a&&a.implementsGoogStringTypedString?a.getTypedStringValue():String(a);goog.html.SAFE_URL_PATTERN_.test(a)||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};
+goog.html.SafeUrl.sanitizeAssertUnchanged=function(a){if(a instanceof goog.html.SafeUrl)return a;a="object"==typeof a&&a.implementsGoogStringTypedString?a.getTypedStringValue():String(a);goog.asserts.assert(goog.html.SAFE_URL_PATTERN_.test(a),"%s does not match the safe URL pattern",a)||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.SafeUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_={};
+goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse=function(a){var b=new goog.html.SafeUrl;b.privateDoNotAccessOrElseSafeUrlWrappedValue_=a;return b};goog.html.SafeUrl.ABOUT_BLANK=goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse("about:blank");goog.html.SafeStyle=function(){this.privateDoNotAccessOrElseSafeStyleWrappedValue_="";this.SAFE_STYLE_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_=goog.html.SafeStyle.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_};goog.html.SafeStyle.prototype.implementsGoogStringTypedString=!0;goog.html.SafeStyle.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_={};
+goog.html.SafeStyle.fromConstant=function(a){a=goog.string.Const.unwrap(a);if(0===a.length)return goog.html.SafeStyle.EMPTY;goog.html.SafeStyle.checkStyle_(a);goog.asserts.assert(goog.string.endsWith(a,";"),"Last character of style string is not ';': "+a);goog.asserts.assert(goog.string.contains(a,":"),"Style string must contain at least one ':', to specify a \"name: value\" pair: "+a);return goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(a)};
+goog.html.SafeStyle.checkStyle_=function(a){goog.asserts.assert(!/[<>]/.test(a),"Forbidden characters in style string: "+a)};goog.html.SafeStyle.prototype.getTypedStringValue=function(){return this.privateDoNotAccessOrElseSafeStyleWrappedValue_};goog.DEBUG&&(goog.html.SafeStyle.prototype.toString=function(){return"SafeStyle{"+this.privateDoNotAccessOrElseSafeStyleWrappedValue_+"}"});
+goog.html.SafeStyle.unwrap=function(a){if(a instanceof goog.html.SafeStyle&&a.constructor===goog.html.SafeStyle&&a.SAFE_STYLE_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_===goog.html.SafeStyle.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_)return a.privateDoNotAccessOrElseSafeStyleWrappedValue_;goog.asserts.fail("expected object of type SafeStyle, got '"+a+"' of type "+goog.typeOf(a));return"type_error:SafeStyle"};goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse=function(a){return(new goog.html.SafeStyle).initSecurityPrivateDoNotAccessOrElse_(a)};
+goog.html.SafeStyle.prototype.initSecurityPrivateDoNotAccessOrElse_=function(a){this.privateDoNotAccessOrElseSafeStyleWrappedValue_=a;return this};goog.html.SafeStyle.EMPTY=goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse("");goog.html.SafeStyle.INNOCUOUS_STRING="zClosurez";
+goog.html.SafeStyle.create=function(a){var b="",c;for(c in a){if(!/^[-_a-zA-Z0-9]+$/.test(c))throw Error("Name allows only [-_a-zA-Z0-9], got: "+c);var d=a[c];null!=d&&(d=goog.isArray(d)?goog.array.map(d,goog.html.SafeStyle.sanitizePropertyValue_).join(" "):goog.html.SafeStyle.sanitizePropertyValue_(d),b+=c+":"+d+";")}if(!b)return goog.html.SafeStyle.EMPTY;goog.html.SafeStyle.checkStyle_(b);return goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(b)};
+goog.html.SafeStyle.sanitizePropertyValue_=function(a){if(a instanceof goog.html.SafeUrl)return'url("'+goog.html.SafeUrl.unwrap(a).replace(/</g,"%3c").replace(/[\\"]/g,"\\$&")+'")';a=a instanceof goog.string.Const?goog.string.Const.unwrap(a):goog.html.SafeStyle.sanitizePropertyValueString_(String(a));goog.asserts.assert(!/[{;}]/.test(a),"Value does not allow [{;}].");return a};
+goog.html.SafeStyle.sanitizePropertyValueString_=function(a){var b=a.replace(goog.html.SafeStyle.FUNCTIONS_RE_,"$1").replace(goog.html.SafeStyle.FUNCTIONS_RE_,"$1").replace(goog.html.SafeStyle.URL_RE_,"url");if(goog.html.SafeStyle.VALUE_RE_.test(b)){if(goog.html.SafeStyle.COMMENT_RE_.test(a))return goog.asserts.fail("String value disallows comments, got: "+a),goog.html.SafeStyle.INNOCUOUS_STRING;if(!goog.html.SafeStyle.hasBalancedQuotes_(a))return goog.asserts.fail("String value requires balanced quotes, got: "+
+a),goog.html.SafeStyle.INNOCUOUS_STRING;if(!goog.html.SafeStyle.hasBalancedSquareBrackets_(a))return goog.asserts.fail("String value requires balanced square brackets and one identifier per pair of brackets, got: "+a),goog.html.SafeStyle.INNOCUOUS_STRING}else return goog.asserts.fail("String value allows only "+goog.html.SafeStyle.VALUE_ALLOWED_CHARS_+" and simple functions, got: "+a),goog.html.SafeStyle.INNOCUOUS_STRING;return goog.html.SafeStyle.sanitizeUrl_(a)};
+goog.html.SafeStyle.hasBalancedQuotes_=function(a){for(var b=!0,c=!0,d=0;d<a.length;d++){var e=a.charAt(d);"'"==e&&c?b=!b:'"'==e&&b&&(c=!c)}return b&&c};goog.html.SafeStyle.hasBalancedSquareBrackets_=function(a){for(var b=!0,c=/^[-_a-zA-Z0-9]$/,d=0;d<a.length;d++){var e=a.charAt(d);if("]"==e){if(b)return!1;b=!0}else if("["==e){if(!b)return!1;b=!1}else if(!b&&!c.test(e))return!1}return b};goog.html.SafeStyle.VALUE_ALLOWED_CHARS_="[-,.\"'%_!# a-zA-Z0-9\\[\\]]";
+goog.html.SafeStyle.VALUE_RE_=new RegExp("^"+goog.html.SafeStyle.VALUE_ALLOWED_CHARS_+"+$");goog.html.SafeStyle.URL_RE_=RegExp("\\b(url\\([ \t\n]*)('[ -&(-\\[\\]-~]*'|\"[ !#-\\[\\]-~]*\"|[!#-&*-\\[\\]-~]*)([ \t\n]*\\))","g");goog.html.SafeStyle.FUNCTIONS_RE_=RegExp("\\b(hsl|hsla|rgb|rgba|matrix|calc|minmax|fit-content|repeat|(rotate|scale|translate)(X|Y|Z|3d)?)\\([-+*/0-9a-z.%\\[\\], ]+\\)","g");goog.html.SafeStyle.COMMENT_RE_=/\/\*/;
+goog.html.SafeStyle.sanitizeUrl_=function(a){return a.replace(goog.html.SafeStyle.URL_RE_,function(a,c,d,e){var b="";d=d.replace(/^(['"])(.*)\1$/,function(a,c,d){b=c;return d});a=goog.html.SafeUrl.sanitize(d).getTypedStringValue();return c+b+a+b+e})};goog.html.SafeStyle.concat=function(a){var b="",c=function(a){goog.isArray(a)?goog.array.forEach(a,c):b+=goog.html.SafeStyle.unwrap(a)};goog.array.forEach(arguments,c);return b?goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(b):goog.html.SafeStyle.EMPTY};goog.html.SafeStyleSheet=function(){this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_="";this.SAFE_STYLE_SHEET_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_=goog.html.SafeStyleSheet.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_};goog.html.SafeStyleSheet.prototype.implementsGoogStringTypedString=!0;goog.html.SafeStyleSheet.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_={};
+goog.html.SafeStyleSheet.createRule=function(a,b){if(goog.string.contains(a,"<"))throw Error("Selector does not allow '<', got: "+a);var c=a.replace(/('|")((?!\1)[^\r\n\f\\]|\\[\s\S])*\1/g,"");if(!/^[-_a-zA-Z0-9#.:* ,>+~[\]()=^$|]+$/.test(c))throw Error("Selector allows only [-_a-zA-Z0-9#.:* ,>+~[\\]()=^$|] and strings, got: "+a);if(!goog.html.SafeStyleSheet.hasBalancedBrackets_(c))throw Error("() and [] in selector must be balanced, got: "+a);b instanceof goog.html.SafeStyle||(b=goog.html.SafeStyle.create(b));
+c=a+"{"+goog.html.SafeStyle.unwrap(b)+"}";return goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(c)};goog.html.SafeStyleSheet.hasBalancedBrackets_=function(a){for(var b={"(":")","[":"]"},c=[],d=0;d<a.length;d++){var e=a[d];if(b[e])c.push(b[e]);else if(goog.object.contains(b,e)&&c.pop()!=e)return!1}return 0==c.length};
+goog.html.SafeStyleSheet.concat=function(a){var b="",c=function(a){goog.isArray(a)?goog.array.forEach(a,c):b+=goog.html.SafeStyleSheet.unwrap(a)};goog.array.forEach(arguments,c);return goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(b)};
+goog.html.SafeStyleSheet.fromConstant=function(a){a=goog.string.Const.unwrap(a);if(0===a.length)return goog.html.SafeStyleSheet.EMPTY;goog.asserts.assert(!goog.string.contains(a,"<"),"Forbidden '<' character in style sheet string: "+a);return goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(a)};goog.html.SafeStyleSheet.prototype.getTypedStringValue=function(){return this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_};
+goog.DEBUG&&(goog.html.SafeStyleSheet.prototype.toString=function(){return"SafeStyleSheet{"+this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_+"}"});
+goog.html.SafeStyleSheet.unwrap=function(a){if(a instanceof goog.html.SafeStyleSheet&&a.constructor===goog.html.SafeStyleSheet&&a.SAFE_STYLE_SHEET_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_===goog.html.SafeStyleSheet.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_)return a.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_;goog.asserts.fail("expected object of type SafeStyleSheet, got '"+a+"' of type "+goog.typeOf(a));return"type_error:SafeStyleSheet"};
+goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse=function(a){return(new goog.html.SafeStyleSheet).initSecurityPrivateDoNotAccessOrElse_(a)};goog.html.SafeStyleSheet.prototype.initSecurityPrivateDoNotAccessOrElse_=function(a){this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_=a;return this};goog.html.SafeStyleSheet.EMPTY=goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse("");goog.html.SafeHtml=function(){this.privateDoNotAccessOrElseSafeHtmlWrappedValue_="";this.SAFE_HTML_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_=goog.html.SafeHtml.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_;this.dir_=null};goog.html.SafeHtml.prototype.implementsGoogI18nBidiDirectionalString=!0;goog.html.SafeHtml.prototype.getDirection=function(){return this.dir_};goog.html.SafeHtml.prototype.implementsGoogStringTypedString=!0;goog.html.SafeHtml.prototype.getTypedStringValue=function(){return this.privateDoNotAccessOrElseSafeHtmlWrappedValue_};
+goog.DEBUG&&(goog.html.SafeHtml.prototype.toString=function(){return"SafeHtml{"+this.privateDoNotAccessOrElseSafeHtmlWrappedValue_+"}"});
+goog.html.SafeHtml.unwrap=function(a){if(a instanceof goog.html.SafeHtml&&a.constructor===goog.html.SafeHtml&&a.SAFE_HTML_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_===goog.html.SafeHtml.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_)return a.privateDoNotAccessOrElseSafeHtmlWrappedValue_;goog.asserts.fail("expected object of type SafeHtml, got '"+a+"' of type "+goog.typeOf(a));return"type_error:SafeHtml"};
+goog.html.SafeHtml.htmlEscape=function(a){if(a instanceof goog.html.SafeHtml)return a;var b="object"==typeof a,c=null;b&&a.implementsGoogI18nBidiDirectionalString&&(c=a.getDirection());a=b&&a.implementsGoogStringTypedString?a.getTypedStringValue():String(a);return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(goog.string.htmlEscape(a),c)};
+goog.html.SafeHtml.htmlEscapePreservingNewlines=function(a){if(a instanceof goog.html.SafeHtml)return a;a=goog.html.SafeHtml.htmlEscape(a);return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(goog.string.newLineToBr(goog.html.SafeHtml.unwrap(a)),a.getDirection())};
+goog.html.SafeHtml.htmlEscapePreservingNewlinesAndSpaces=function(a){if(a instanceof goog.html.SafeHtml)return a;a=goog.html.SafeHtml.htmlEscape(a);return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(goog.string.whitespaceEscape(goog.html.SafeHtml.unwrap(a)),a.getDirection())};goog.html.SafeHtml.from=goog.html.SafeHtml.htmlEscape;goog.html.SafeHtml.VALID_NAMES_IN_TAG_=/^[a-zA-Z0-9-]+$/;
+goog.html.SafeHtml.URL_ATTRIBUTES_={action:!0,cite:!0,data:!0,formaction:!0,href:!0,manifest:!0,poster:!0,src:!0};goog.html.SafeHtml.NOT_ALLOWED_TAG_NAMES_={APPLET:!0,BASE:!0,EMBED:!0,IFRAME:!0,LINK:!0,MATH:!0,META:!0,OBJECT:!0,SCRIPT:!0,STYLE:!0,SVG:!0,TEMPLATE:!0};goog.html.SafeHtml.create=function(a,b,c){goog.html.SafeHtml.verifyTagName(String(a));return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(String(a),b,c)};
+goog.html.SafeHtml.verifyTagName=function(a){if(!goog.html.SafeHtml.VALID_NAMES_IN_TAG_.test(a))throw Error("Invalid tag name <"+a+">.");if(a.toUpperCase()in goog.html.SafeHtml.NOT_ALLOWED_TAG_NAMES_)throw Error("Tag name <"+a+"> is not allowed for SafeHtml.");};
+goog.html.SafeHtml.createIframe=function(a,b,c,d){a&&goog.html.TrustedResourceUrl.unwrap(a);var e={};e.src=a||null;e.srcdoc=b&&goog.html.SafeHtml.unwrap(b);a=goog.html.SafeHtml.combineAttributes(e,{sandbox:""},c);return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("iframe",a,d)};
+goog.html.SafeHtml.createSandboxIframe=function(a,b,c,d){if(!goog.html.SafeHtml.canUseSandboxIframe())throw Error("The browser does not support sandboxed iframes.");var e={};e.src=a?goog.html.SafeUrl.unwrap(goog.html.SafeUrl.sanitize(a)):null;e.srcdoc=b||null;e.sandbox="";a=goog.html.SafeHtml.combineAttributes(e,{},c);return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("iframe",a,d)};
+goog.html.SafeHtml.canUseSandboxIframe=function(){return goog.global.HTMLIFrameElement&&"sandbox"in goog.global.HTMLIFrameElement.prototype};goog.html.SafeHtml.createScriptSrc=function(a,b){goog.html.TrustedResourceUrl.unwrap(a);var c=goog.html.SafeHtml.combineAttributes({src:a},{},b);return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("script",c)};
+goog.html.SafeHtml.createScript=function(a,b){for(var c in b){var d=c.toLowerCase();if("language"==d||"src"==d||"text"==d||"type"==d)throw Error('Cannot set "'+d+'" attribute');}c="";a=goog.array.concat(a);for(d=0;d<a.length;d++)c+=goog.html.SafeScript.unwrap(a[d]);c=goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(c,goog.i18n.bidi.Dir.NEUTRAL);return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("script",b,c)};
+goog.html.SafeHtml.createStyle=function(a,b){var c=goog.html.SafeHtml.combineAttributes({type:"text/css"},{},b),d="";a=goog.array.concat(a);for(var e=0;e<a.length;e++)d+=goog.html.SafeStyleSheet.unwrap(a[e]);d=goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(d,goog.i18n.bidi.Dir.NEUTRAL);return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("style",c,d)};
+goog.html.SafeHtml.createMetaRefresh=function(a,b){var c=goog.html.SafeUrl.unwrap(goog.html.SafeUrl.sanitize(a));(goog.labs.userAgent.browser.isIE()||goog.labs.userAgent.browser.isEdge())&&goog.string.contains(c,";")&&(c="'"+c.replace(/'/g,"%27")+"'");return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("meta",{"http-equiv":"refresh",content:(b||0)+"; url="+c})};
+goog.html.SafeHtml.getAttrNameAndValue_=function(a,b,c){if(c instanceof goog.string.Const)c=goog.string.Const.unwrap(c);else if("style"==b.toLowerCase())c=goog.html.SafeHtml.getStyleValue_(c);else{if(/^on/i.test(b))throw Error('Attribute "'+b+'" requires goog.string.Const value, "'+c+'" given.');if(b.toLowerCase()in goog.html.SafeHtml.URL_ATTRIBUTES_)if(c instanceof goog.html.TrustedResourceUrl)c=goog.html.TrustedResourceUrl.unwrap(c);else if(c instanceof goog.html.SafeUrl)c=goog.html.SafeUrl.unwrap(c);
+else if(goog.isString(c))c=goog.html.SafeUrl.sanitize(c).getTypedStringValue();else throw Error('Attribute "'+b+'" on tag "'+a+'" requires goog.html.SafeUrl, goog.string.Const, or string, value "'+c+'" given.');}c.implementsGoogStringTypedString&&(c=c.getTypedStringValue());goog.asserts.assert(goog.isString(c)||goog.isNumber(c),"String or number value expected, got "+typeof c+" with value: "+c);return b+'="'+goog.string.htmlEscape(String(c))+'"'};
+goog.html.SafeHtml.getStyleValue_=function(a){if(!goog.isObject(a))throw Error('The "style" attribute requires goog.html.SafeStyle or map of style properties, '+typeof a+" given: "+a);a instanceof goog.html.SafeStyle||(a=goog.html.SafeStyle.create(a));return goog.html.SafeStyle.unwrap(a)};goog.html.SafeHtml.createWithDir=function(a,b,c,d){b=goog.html.SafeHtml.create(b,c,d);b.dir_=a;return b};
+goog.html.SafeHtml.concat=function(a){var b=goog.i18n.bidi.Dir.NEUTRAL,c="",d=function(a){goog.isArray(a)?goog.array.forEach(a,d):(a=goog.html.SafeHtml.htmlEscape(a),c+=goog.html.SafeHtml.unwrap(a),a=a.getDirection(),b==goog.i18n.bidi.Dir.NEUTRAL?b=a:a!=goog.i18n.bidi.Dir.NEUTRAL&&b!=a&&(b=null))};goog.array.forEach(arguments,d);return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(c,b)};
+goog.html.SafeHtml.concatWithDir=function(a,b){var c=goog.html.SafeHtml.concat(goog.array.slice(arguments,1));c.dir_=a;return c};goog.html.SafeHtml.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_={};goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse=function(a,b){return(new goog.html.SafeHtml).initSecurityPrivateDoNotAccessOrElse_(a,b)};goog.html.SafeHtml.prototype.initSecurityPrivateDoNotAccessOrElse_=function(a,b){this.privateDoNotAccessOrElseSafeHtmlWrappedValue_=a;this.dir_=b;return this};
+goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse=function(a,b,c){var d=null;var e="<"+a+goog.html.SafeHtml.stringifyAttributes(a,b);goog.isDefAndNotNull(c)?goog.isArray(c)||(c=[c]):c=[];goog.dom.tags.isVoidTag(a.toLowerCase())?(goog.asserts.assert(!c.length,"Void tag <"+a+"> does not allow content."),e+=">"):(d=goog.html.SafeHtml.concat(c),e+=">"+goog.html.SafeHtml.unwrap(d)+"</"+a+">",d=d.getDirection());(a=b&&b.dir)&&(d=/^(ltr|rtl|auto)$/i.test(a)?goog.i18n.bidi.Dir.NEUTRAL:
+null);return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(e,d)};goog.html.SafeHtml.stringifyAttributes=function(a,b){var c="";if(b)for(var d in b){if(!goog.html.SafeHtml.VALID_NAMES_IN_TAG_.test(d))throw Error('Invalid attribute name "'+d+'".');var e=b[d];goog.isDefAndNotNull(e)&&(c+=" "+goog.html.SafeHtml.getAttrNameAndValue_(a,d,e))}return c};
+goog.html.SafeHtml.combineAttributes=function(a,b,c){var d={},e;for(e in a)goog.asserts.assert(e.toLowerCase()==e,"Must be lower case"),d[e]=a[e];for(e in b)goog.asserts.assert(e.toLowerCase()==e,"Must be lower case"),d[e]=b[e];for(e in c){var f=e.toLowerCase();if(f in a)throw Error('Cannot override "'+f+'" attribute, got "'+e+'" with value "'+c[e]+'"');f in b&&delete d[f];d[e]=c[e]}return d};
+goog.html.SafeHtml.DOCTYPE_HTML=goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse("<!DOCTYPE html>",goog.i18n.bidi.Dir.NEUTRAL);goog.html.SafeHtml.EMPTY=goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse("",goog.i18n.bidi.Dir.NEUTRAL);goog.html.SafeHtml.BR=goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse("<br>",goog.i18n.bidi.Dir.NEUTRAL);goog.dom.safe={};goog.dom.safe.InsertAdjacentHtmlPosition={AFTERBEGIN:"afterbegin",AFTEREND:"afterend",BEFOREBEGIN:"beforebegin",BEFOREEND:"beforeend"};goog.dom.safe.insertAdjacentHtml=function(a,b,c){a.insertAdjacentHTML(b,goog.html.SafeHtml.unwrap(c))};goog.dom.safe.SET_INNER_HTML_DISALLOWED_TAGS_={MATH:!0,SCRIPT:!0,STYLE:!0,SVG:!0,TEMPLATE:!0};
+goog.dom.safe.isInnerHtmlCleanupRecursive_=goog.functions.cacheReturnValue(function(){if(goog.DEBUG&&"undefined"===typeof document)return!1;var a=document.createElement("div");a.innerHTML="<div><div></div></div>";if(goog.DEBUG&&!a.firstChild)return!1;var b=a.firstChild.firstChild;a.innerHTML="";return!b.parentElement});goog.dom.safe.unsafeSetInnerHtmlDoNotUseOrElse=function(a,b){if(goog.dom.safe.isInnerHtmlCleanupRecursive_())for(;a.lastChild;)a.removeChild(a.lastChild);a.innerHTML=b};
+goog.dom.safe.setInnerHtml=function(a,b){if(goog.asserts.ENABLE_ASSERTS){var c=a.tagName.toUpperCase();if(goog.dom.safe.SET_INNER_HTML_DISALLOWED_TAGS_[c])throw Error("goog.dom.safe.setInnerHtml cannot be used to set content of "+a.tagName+".");}goog.dom.safe.unsafeSetInnerHtmlDoNotUseOrElse(a,goog.html.SafeHtml.unwrap(b))};goog.dom.safe.setOuterHtml=function(a,b){a.outerHTML=goog.html.SafeHtml.unwrap(b)};
+goog.dom.safe.setFormElementAction=function(a,b){var c=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);goog.dom.asserts.assertIsHTMLFormElement(a).action=goog.html.SafeUrl.unwrap(c)};goog.dom.safe.setButtonFormAction=function(a,b){var c=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);goog.dom.asserts.assertIsHTMLButtonElement(a).formAction=goog.html.SafeUrl.unwrap(c)};
+goog.dom.safe.setInputFormAction=function(a,b){var c=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);goog.dom.asserts.assertIsHTMLInputElement(a).formAction=goog.html.SafeUrl.unwrap(c)};goog.dom.safe.setStyle=function(a,b){a.style.cssText=goog.html.SafeStyle.unwrap(b)};goog.dom.safe.documentWrite=function(a,b){a.write(goog.html.SafeHtml.unwrap(b))};
+goog.dom.safe.setAnchorHref=function(a,b){goog.dom.asserts.assertIsHTMLAnchorElement(a);var c=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.href=goog.html.SafeUrl.unwrap(c)};goog.dom.safe.setImageSrc=function(a,b){goog.dom.asserts.assertIsHTMLImageElement(a);var c=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.src=goog.html.SafeUrl.unwrap(c)};
+goog.dom.safe.setAudioSrc=function(a,b){goog.dom.asserts.assertIsHTMLAudioElement(a);var c=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.src=goog.html.SafeUrl.unwrap(c)};goog.dom.safe.setVideoSrc=function(a,b){goog.dom.asserts.assertIsHTMLVideoElement(a);var c=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.src=goog.html.SafeUrl.unwrap(c)};goog.dom.safe.setEmbedSrc=function(a,b){goog.dom.asserts.assertIsHTMLEmbedElement(a);a.src=goog.html.TrustedResourceUrl.unwrap(b)};
+goog.dom.safe.setFrameSrc=function(a,b){goog.dom.asserts.assertIsHTMLFrameElement(a);a.src=goog.html.TrustedResourceUrl.unwrap(b)};goog.dom.safe.setIframeSrc=function(a,b){goog.dom.asserts.assertIsHTMLIFrameElement(a);a.src=goog.html.TrustedResourceUrl.unwrap(b)};goog.dom.safe.setIframeSrcdoc=function(a,b){goog.dom.asserts.assertIsHTMLIFrameElement(a);a.srcdoc=goog.html.SafeHtml.unwrap(b)};
+goog.dom.safe.setLinkHrefAndRel=function(a,b,c){goog.dom.asserts.assertIsHTMLLinkElement(a);a.rel=c;goog.string.caseInsensitiveContains(c,"stylesheet")?(goog.asserts.assert(b instanceof goog.html.TrustedResourceUrl,'URL must be TrustedResourceUrl because "rel" contains "stylesheet"'),a.href=goog.html.TrustedResourceUrl.unwrap(b)):a.href=b instanceof goog.html.TrustedResourceUrl?goog.html.TrustedResourceUrl.unwrap(b):b instanceof goog.html.SafeUrl?goog.html.SafeUrl.unwrap(b):goog.html.SafeUrl.sanitizeAssertUnchanged(b).getTypedStringValue()};
+goog.dom.safe.setObjectData=function(a,b){goog.dom.asserts.assertIsHTMLObjectElement(a);a.data=goog.html.TrustedResourceUrl.unwrap(b)};goog.dom.safe.setScriptSrc=function(a,b){goog.dom.asserts.assertIsHTMLScriptElement(a);a.src=goog.html.TrustedResourceUrl.unwrap(b);var c=goog.getScriptNonce();c&&a.setAttribute("nonce",c)};
+goog.dom.safe.setScriptContent=function(a,b){goog.dom.asserts.assertIsHTMLScriptElement(a);a.text=goog.html.SafeScript.unwrap(b);var c=goog.getScriptNonce();c&&a.setAttribute("nonce",c)};goog.dom.safe.setLocationHref=function(a,b){goog.dom.asserts.assertIsLocation(a);var c=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.href=goog.html.SafeUrl.unwrap(c)};
+goog.dom.safe.assignLocation=function(a,b){goog.dom.asserts.assertIsLocation(a);var c=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.assign(goog.html.SafeUrl.unwrap(c))};goog.dom.safe.replaceLocation=function(a,b){goog.dom.asserts.assertIsLocation(a);var c=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.replace(goog.html.SafeUrl.unwrap(c))};
+goog.dom.safe.openInWindow=function(a,b,c,d,e){a=a instanceof goog.html.SafeUrl?a:goog.html.SafeUrl.sanitizeAssertUnchanged(a);return(b||window).open(goog.html.SafeUrl.unwrap(a),c?goog.string.Const.unwrap(c):"",d,e)};goog.dom.safe.parseFromStringHtml=function(a,b){return a.parseFromString(goog.html.SafeHtml.unwrap(b),"text/html")};
+goog.dom.safe.createImageFromBlob=function(a){if(!/^image\/.*/g.test(a.type))throw Error("goog.dom.safe.createImageFromBlob only accepts MIME type image/.*.");var b=window.URL.createObjectURL(a);a=new Image;a.onload=function(){window.URL.revokeObjectURL(b)};a.src=b;return a};goog.html.uncheckedconversions={};goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract=function(a,b,c){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(b,c||null)};
+goog.html.uncheckedconversions.safeScriptFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return goog.html.SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(b)};
+goog.html.uncheckedconversions.safeStyleFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(b)};
+goog.html.uncheckedconversions.safeStyleSheetFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(b)};
+goog.html.uncheckedconversions.safeUrlFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(b)};
+goog.html.uncheckedconversions.trustedResourceUrlFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(b)};goog.math.Size=function(a,b){this.width=a;this.height=b};goog.math.Size.equals=function(a,b){return a==b?!0:a&&b?a.width==b.width&&a.height==b.height:!1};goog.math.Size.prototype.clone=function(){return new goog.math.Size(this.width,this.height)};goog.DEBUG&&(goog.math.Size.prototype.toString=function(){return"("+this.width+" x "+this.height+")"});goog.math.Size.prototype.getLongest=function(){return Math.max(this.width,this.height)};
+goog.math.Size.prototype.getShortest=function(){return Math.min(this.width,this.height)};goog.math.Size.prototype.area=function(){return this.width*this.height};goog.math.Size.prototype.perimeter=function(){return 2*(this.width+this.height)};goog.math.Size.prototype.aspectRatio=function(){return this.width/this.height};goog.math.Size.prototype.isEmpty=function(){return!this.area()};goog.math.Size.prototype.ceil=function(){this.width=Math.ceil(this.width);this.height=Math.ceil(this.height);return this};
+goog.math.Size.prototype.fitsInside=function(a){return this.width<=a.width&&this.height<=a.height};goog.math.Size.prototype.floor=function(){this.width=Math.floor(this.width);this.height=Math.floor(this.height);return this};goog.math.Size.prototype.round=function(){this.width=Math.round(this.width);this.height=Math.round(this.height);return this};goog.math.Size.prototype.scale=function(a,b){var c=goog.isNumber(b)?b:a;this.width*=a;this.height*=c;return this};
+goog.math.Size.prototype.scaleToCover=function(a){a=this.aspectRatio()<=a.aspectRatio()?a.width/this.width:a.height/this.height;return this.scale(a)};goog.math.Size.prototype.scaleToFit=function(a){a=this.aspectRatio()>a.aspectRatio()?a.width/this.width:a.height/this.height;return this.scale(a)};goog.dom.ASSUME_QUIRKS_MODE=!1;goog.dom.ASSUME_STANDARDS_MODE=!1;goog.dom.COMPAT_MODE_KNOWN_=goog.dom.ASSUME_QUIRKS_MODE||goog.dom.ASSUME_STANDARDS_MODE;goog.dom.getDomHelper=function(a){return a?new goog.dom.DomHelper(goog.dom.getOwnerDocument(a)):goog.dom.defaultDomHelper_||(goog.dom.defaultDomHelper_=new goog.dom.DomHelper)};goog.dom.getDocument=function(){return document};goog.dom.getElement=function(a){return goog.dom.getElementHelper_(document,a)};
+goog.dom.getElementHelper_=function(a,b){return goog.isString(b)?a.getElementById(b):b};goog.dom.getRequiredElement=function(a){return goog.dom.getRequiredElementHelper_(document,a)};goog.dom.getRequiredElementHelper_=function(a,b){goog.asserts.assertString(b);var c=goog.dom.getElementHelper_(a,b);return c=goog.asserts.assertElement(c,"No element found with id: "+b)};goog.dom.$=goog.dom.getElement;goog.dom.getElementsByTagName=function(a,b){return(b||document).getElementsByTagName(String(a))};
+goog.dom.getElementsByTagNameAndClass=function(a,b,c){return goog.dom.getElementsByTagNameAndClass_(document,a,b,c)};goog.dom.getElementByTagNameAndClass=function(a,b,c){return goog.dom.getElementByTagNameAndClass_(document,a,b,c)};goog.dom.getElementsByClass=function(a,b){var c=b||document;return goog.dom.canUseQuerySelector_(c)?c.querySelectorAll("."+a):goog.dom.getElementsByTagNameAndClass_(document,"*",a,b)};
+goog.dom.getElementByClass=function(a,b){var c=b||document;return(c.getElementsByClassName?c.getElementsByClassName(a)[0]:goog.dom.getElementByTagNameAndClass_(document,"*",a,b))||null};goog.dom.getRequiredElementByClass=function(a,b){var c=goog.dom.getElementByClass(a,b);return goog.asserts.assert(c,"No element found with className: "+a)};goog.dom.canUseQuerySelector_=function(a){return!(!a.querySelectorAll||!a.querySelector)};
+goog.dom.getElementsByTagNameAndClass_=function(a,b,c,d){a=d||a;b=b&&"*"!=b?String(b).toUpperCase():"";if(goog.dom.canUseQuerySelector_(a)&&(b||c))return a.querySelectorAll(b+(c?"."+c:""));if(c&&a.getElementsByClassName){a=a.getElementsByClassName(c);if(b){d={};for(var e=0,f=0,g;g=a[f];f++)b==g.nodeName&&(d[e++]=g);d.length=e;return d}return a}a=a.getElementsByTagName(b||"*");if(c){d={};for(f=e=0;g=a[f];f++)b=g.className,"function"==typeof b.split&&goog.array.contains(b.split(/\s+/),c)&&(d[e++]=g);
+d.length=e;return d}return a};goog.dom.getElementByTagNameAndClass_=function(a,b,c,d){var e=d||a,f=b&&"*"!=b?String(b).toUpperCase():"";return goog.dom.canUseQuerySelector_(e)&&(f||c)?e.querySelector(f+(c?"."+c:"")):goog.dom.getElementsByTagNameAndClass_(a,b,c,d)[0]||null};goog.dom.$$=goog.dom.getElementsByTagNameAndClass;
+goog.dom.setProperties=function(a,b){goog.object.forEach(b,function(b,d){b&&"object"==typeof b&&b.implementsGoogStringTypedString&&(b=b.getTypedStringValue());"style"==d?a.style.cssText=b:"class"==d?a.className=b:"for"==d?a.htmlFor=b:goog.dom.DIRECT_ATTRIBUTE_MAP_.hasOwnProperty(d)?a.setAttribute(goog.dom.DIRECT_ATTRIBUTE_MAP_[d],b):goog.string.startsWith(d,"aria-")||goog.string.startsWith(d,"data-")?a.setAttribute(d,b):a[d]=b})};
+goog.dom.DIRECT_ATTRIBUTE_MAP_={cellpadding:"cellPadding",cellspacing:"cellSpacing",colspan:"colSpan",frameborder:"frameBorder",height:"height",maxlength:"maxLength",nonce:"nonce",role:"role",rowspan:"rowSpan",type:"type",usemap:"useMap",valign:"vAlign",width:"width"};goog.dom.getViewportSize=function(a){return goog.dom.getViewportSize_(a||window)};goog.dom.getViewportSize_=function(a){a=a.document;a=goog.dom.isCss1CompatMode_(a)?a.documentElement:a.body;return new goog.math.Size(a.clientWidth,a.clientHeight)};
+goog.dom.getDocumentHeight=function(){return goog.dom.getDocumentHeight_(window)};goog.dom.getDocumentHeightForWindow=function(a){return goog.dom.getDocumentHeight_(a)};
+goog.dom.getDocumentHeight_=function(a){var b=a.document,c=0;if(b){c=b.body;var d=b.documentElement;if(!d||!c)return 0;a=goog.dom.getViewportSize_(a).height;if(goog.dom.isCss1CompatMode_(b)&&d.scrollHeight)c=d.scrollHeight!=a?d.scrollHeight:d.offsetHeight;else{b=d.scrollHeight;var e=d.offsetHeight;d.clientHeight!=e&&(b=c.scrollHeight,e=c.offsetHeight);c=b>a?b>e?b:e:b<e?b:e}}return c};goog.dom.getPageScroll=function(a){return goog.dom.getDomHelper((a||goog.global||window).document).getDocumentScroll()};
+goog.dom.getDocumentScroll=function(){return goog.dom.getDocumentScroll_(document)};goog.dom.getDocumentScroll_=function(a){var b=goog.dom.getDocumentScrollElement_(a);a=goog.dom.getWindow_(a);return goog.userAgent.IE&&goog.userAgent.isVersionOrHigher("10")&&a.pageYOffset!=b.scrollTop?new goog.math.Coordinate(b.scrollLeft,b.scrollTop):new goog.math.Coordinate(a.pageXOffset||b.scrollLeft,a.pageYOffset||b.scrollTop)};goog.dom.getDocumentScrollElement=function(){return goog.dom.getDocumentScrollElement_(document)};
+goog.dom.getDocumentScrollElement_=function(a){return a.scrollingElement?a.scrollingElement:!goog.userAgent.WEBKIT&&goog.dom.isCss1CompatMode_(a)?a.documentElement:a.body||a.documentElement};goog.dom.getWindow=function(a){return a?goog.dom.getWindow_(a):window};goog.dom.getWindow_=function(a){return a.parentWindow||a.defaultView};goog.dom.createDom=function(a,b,c){return goog.dom.createDom_(document,arguments)};
+goog.dom.createDom_=function(a,b){var c=String(b[0]),d=b[1];if(!goog.dom.BrowserFeature.CAN_ADD_NAME_OR_TYPE_ATTRIBUTES&&d&&(d.name||d.type)){c=["<",c];d.name&&c.push(' name="',goog.string.htmlEscape(d.name),'"');if(d.type){c.push(' type="',goog.string.htmlEscape(d.type),'"');var e={};goog.object.extend(e,d);delete e.type;d=e}c.push(">");c=c.join("")}c=a.createElement(c);d&&(goog.isString(d)?c.className=d:goog.isArray(d)?c.className=d.join(" "):goog.dom.setProperties(c,d));2<b.length&&goog.dom.append_(a,
+c,b,2);return c};goog.dom.append_=function(a,b,c,d){function e(c){c&&b.appendChild(goog.isString(c)?a.createTextNode(c):c)}for(;d<c.length;d++){var f=c[d];goog.isArrayLike(f)&&!goog.dom.isNodeLike(f)?goog.array.forEach(goog.dom.isNodeList(f)?goog.array.toArray(f):f,e):e(f)}};goog.dom.$dom=goog.dom.createDom;goog.dom.createElement=function(a){return goog.dom.createElement_(document,a)};goog.dom.createElement_=function(a,b){return a.createElement(String(b))};goog.dom.createTextNode=function(a){return document.createTextNode(String(a))};
+goog.dom.createTable=function(a,b,c){return goog.dom.createTable_(document,a,b,!!c)};goog.dom.createTable_=function(a,b,c,d){for(var e=goog.dom.createElement_(a,"TABLE"),f=e.appendChild(goog.dom.createElement_(a,"TBODY")),g=0;g<b;g++){for(var h=goog.dom.createElement_(a,"TR"),k=0;k<c;k++){var l=goog.dom.createElement_(a,"TD");d&&goog.dom.setTextContent(l,goog.string.Unicode.NBSP);h.appendChild(l)}f.appendChild(h)}return e};
+goog.dom.constHtmlToNode=function(a){var b=goog.array.map(arguments,goog.string.Const.unwrap);b=goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract(goog.string.Const.from("Constant HTML string, that gets turned into a Node later, so it will be automatically balanced."),b.join(""));return goog.dom.safeHtmlToNode(b)};goog.dom.safeHtmlToNode=function(a){return goog.dom.safeHtmlToNode_(document,a)};
+goog.dom.safeHtmlToNode_=function(a,b){var c=goog.dom.createElement_(a,"DIV");goog.dom.BrowserFeature.INNER_HTML_NEEDS_SCOPED_ELEMENT?(goog.dom.safe.setInnerHtml(c,goog.html.SafeHtml.concat(goog.html.SafeHtml.BR,b)),c.removeChild(goog.asserts.assert(c.firstChild))):goog.dom.safe.setInnerHtml(c,b);return goog.dom.childrenToNode_(a,c)};
+goog.dom.childrenToNode_=function(a,b){if(1==b.childNodes.length)return b.removeChild(goog.asserts.assert(b.firstChild));for(var c=a.createDocumentFragment();b.firstChild;)c.appendChild(b.firstChild);return c};goog.dom.isCss1CompatMode=function(){return goog.dom.isCss1CompatMode_(document)};goog.dom.isCss1CompatMode_=function(a){return goog.dom.COMPAT_MODE_KNOWN_?goog.dom.ASSUME_STANDARDS_MODE:"CSS1Compat"==a.compatMode};
+goog.dom.canHaveChildren=function(a){if(a.nodeType!=goog.dom.NodeType.ELEMENT)return!1;switch(a.tagName){case "APPLET":case "AREA":case "BASE":case "BR":case "COL":case "COMMAND":case "EMBED":case "FRAME":case "HR":case "IMG":case "INPUT":case "IFRAME":case "ISINDEX":case "KEYGEN":case "LINK":case "NOFRAMES":case "NOSCRIPT":case "META":case "OBJECT":case "PARAM":case "SCRIPT":case "SOURCE":case "STYLE":case "TRACK":case "WBR":return!1}return!0};
+goog.dom.appendChild=function(a,b){goog.asserts.assert(null!=a&&null!=b,"goog.dom.appendChild expects non-null arguments");a.appendChild(b)};goog.dom.append=function(a,b){goog.dom.append_(goog.dom.getOwnerDocument(a),a,arguments,1)};goog.dom.removeChildren=function(a){for(var b;b=a.firstChild;)a.removeChild(b)};goog.dom.insertSiblingBefore=function(a,b){goog.asserts.assert(null!=a&&null!=b,"goog.dom.insertSiblingBefore expects non-null arguments");b.parentNode&&b.parentNode.insertBefore(a,b)};
+goog.dom.insertSiblingAfter=function(a,b){goog.asserts.assert(null!=a&&null!=b,"goog.dom.insertSiblingAfter expects non-null arguments");b.parentNode&&b.parentNode.insertBefore(a,b.nextSibling)};goog.dom.insertChildAt=function(a,b,c){goog.asserts.assert(null!=a,"goog.dom.insertChildAt expects a non-null parent");a.insertBefore(b,a.childNodes[c]||null)};goog.dom.removeNode=function(a){return a&&a.parentNode?a.parentNode.removeChild(a):null};
+goog.dom.replaceNode=function(a,b){goog.asserts.assert(null!=a&&null!=b,"goog.dom.replaceNode expects non-null arguments");var c=b.parentNode;c&&c.replaceChild(a,b)};goog.dom.flattenElement=function(a){var b,c=a.parentNode;if(c&&c.nodeType!=goog.dom.NodeType.DOCUMENT_FRAGMENT){if(a.removeNode)return a.removeNode(!1);for(;b=a.firstChild;)c.insertBefore(b,a);return goog.dom.removeNode(a)}};
+goog.dom.getChildren=function(a){return goog.dom.BrowserFeature.CAN_USE_CHILDREN_ATTRIBUTE&&void 0!=a.children?a.children:goog.array.filter(a.childNodes,function(a){return a.nodeType==goog.dom.NodeType.ELEMENT})};goog.dom.getFirstElementChild=function(a){return goog.isDef(a.firstElementChild)?a.firstElementChild:goog.dom.getNextElementNode_(a.firstChild,!0)};goog.dom.getLastElementChild=function(a){return goog.isDef(a.lastElementChild)?a.lastElementChild:goog.dom.getNextElementNode_(a.lastChild,!1)};
+goog.dom.getNextElementSibling=function(a){return goog.isDef(a.nextElementSibling)?a.nextElementSibling:goog.dom.getNextElementNode_(a.nextSibling,!0)};goog.dom.getPreviousElementSibling=function(a){return goog.isDef(a.previousElementSibling)?a.previousElementSibling:goog.dom.getNextElementNode_(a.previousSibling,!1)};goog.dom.getNextElementNode_=function(a,b){for(;a&&a.nodeType!=goog.dom.NodeType.ELEMENT;)a=b?a.nextSibling:a.previousSibling;return a};
+goog.dom.getNextNode=function(a){if(!a)return null;if(a.firstChild)return a.firstChild;for(;a&&!a.nextSibling;)a=a.parentNode;return a?a.nextSibling:null};goog.dom.getPreviousNode=function(a){if(!a)return null;if(!a.previousSibling)return a.parentNode;for(a=a.previousSibling;a&&a.lastChild;)a=a.lastChild;return a};goog.dom.isNodeLike=function(a){return goog.isObject(a)&&0<a.nodeType};goog.dom.isElement=function(a){return goog.isObject(a)&&a.nodeType==goog.dom.NodeType.ELEMENT};
+goog.dom.isWindow=function(a){return goog.isObject(a)&&a.window==a};goog.dom.getParentElement=function(a){var b;if(goog.dom.BrowserFeature.CAN_USE_PARENT_ELEMENT_PROPERTY&&!(goog.userAgent.IE&&goog.userAgent.isVersionOrHigher("9")&&!goog.userAgent.isVersionOrHigher("10")&&goog.global.SVGElement&&a instanceof goog.global.SVGElement)&&(b=a.parentElement))return b;b=a.parentNode;return goog.dom.isElement(b)?b:null};
+goog.dom.contains=function(a,b){if(!a||!b)return!1;if(a.contains&&b.nodeType==goog.dom.NodeType.ELEMENT)return a==b||a.contains(b);if("undefined"!=typeof a.compareDocumentPosition)return a==b||!!(a.compareDocumentPosition(b)&16);for(;b&&a!=b;)b=b.parentNode;return b==a};
+goog.dom.compareNodeOrder=function(a,b){if(a==b)return 0;if(a.compareDocumentPosition)return a.compareDocumentPosition(b)&2?1:-1;if(goog.userAgent.IE&&!goog.userAgent.isDocumentModeOrHigher(9)){if(a.nodeType==goog.dom.NodeType.DOCUMENT)return-1;if(b.nodeType==goog.dom.NodeType.DOCUMENT)return 1}if("sourceIndex"in a||a.parentNode&&"sourceIndex"in a.parentNode){var c=a.nodeType==goog.dom.NodeType.ELEMENT,d=b.nodeType==goog.dom.NodeType.ELEMENT;if(c&&d)return a.sourceIndex-b.sourceIndex;var e=a.parentNode,
+f=b.parentNode;return e==f?goog.dom.compareSiblingOrder_(a,b):!c&&goog.dom.contains(e,b)?-1*goog.dom.compareParentsDescendantNodeIe_(a,b):!d&&goog.dom.contains(f,a)?goog.dom.compareParentsDescendantNodeIe_(b,a):(c?a.sourceIndex:e.sourceIndex)-(d?b.sourceIndex:f.sourceIndex)}d=goog.dom.getOwnerDocument(a);c=d.createRange();c.selectNode(a);c.collapse(!0);d=d.createRange();d.selectNode(b);d.collapse(!0);return c.compareBoundaryPoints(goog.global.Range.START_TO_END,d)};
+goog.dom.compareParentsDescendantNodeIe_=function(a,b){var c=a.parentNode;if(c==b)return-1;for(var d=b;d.parentNode!=c;)d=d.parentNode;return goog.dom.compareSiblingOrder_(d,a)};goog.dom.compareSiblingOrder_=function(a,b){for(var c=b;c=c.previousSibling;)if(c==a)return-1;return 1};
+goog.dom.findCommonAncestor=function(a){var b,c=arguments.length;if(!c)return null;if(1==c)return arguments[0];var d=[],e=Infinity;for(b=0;b<c;b++){for(var f=[],g=arguments[b];g;)f.unshift(g),g=g.parentNode;d.push(f);e=Math.min(e,f.length)}f=null;for(b=0;b<e;b++){g=d[0][b];for(var h=1;h<c;h++)if(g!=d[h][b])return f;f=g}return f};goog.dom.getOwnerDocument=function(a){goog.asserts.assert(a,"Node cannot be null or undefined.");return a.nodeType==goog.dom.NodeType.DOCUMENT?a:a.ownerDocument||a.document};
+goog.dom.getFrameContentDocument=function(a){return a.contentDocument||a.contentWindow.document};goog.dom.getFrameContentWindow=function(a){try{return a.contentWindow||(a.contentDocument?goog.dom.getWindow(a.contentDocument):null)}catch(b){}return null};
+goog.dom.setTextContent=function(a,b){goog.asserts.assert(null!=a,"goog.dom.setTextContent expects a non-null value for node");if("textContent"in a)a.textContent=b;else if(a.nodeType==goog.dom.NodeType.TEXT)a.data=String(b);else if(a.firstChild&&a.firstChild.nodeType==goog.dom.NodeType.TEXT){for(;a.lastChild!=a.firstChild;)a.removeChild(goog.asserts.assert(a.lastChild));a.firstChild.data=String(b)}else{goog.dom.removeChildren(a);var c=goog.dom.getOwnerDocument(a);a.appendChild(c.createTextNode(String(b)))}};
+goog.dom.getOuterHtml=function(a){goog.asserts.assert(null!==a,"goog.dom.getOuterHtml expects a non-null value for element");if("outerHTML"in a)return a.outerHTML;var b=goog.dom.getOwnerDocument(a);b=goog.dom.createElement_(b,"DIV");b.appendChild(a.cloneNode(!0));return b.innerHTML};goog.dom.findNode=function(a,b){var c=[];return goog.dom.findNodes_(a,b,c,!0)?c[0]:void 0};goog.dom.findNodes=function(a,b){var c=[];goog.dom.findNodes_(a,b,c,!1);return c};
+goog.dom.findNodes_=function(a,b,c,d){if(null!=a)for(a=a.firstChild;a;){if(b(a)&&(c.push(a),d)||goog.dom.findNodes_(a,b,c,d))return!0;a=a.nextSibling}return!1};goog.dom.TAGS_TO_IGNORE_={SCRIPT:1,STYLE:1,HEAD:1,IFRAME:1,OBJECT:1};goog.dom.PREDEFINED_TAG_VALUES_={IMG:" ",BR:"\n"};goog.dom.isFocusableTabIndex=function(a){return goog.dom.hasSpecifiedTabIndex_(a)&&goog.dom.isTabIndexFocusable_(a)};goog.dom.setFocusableTabIndex=function(a,b){b?a.tabIndex=0:(a.tabIndex=-1,a.removeAttribute("tabIndex"))};
+goog.dom.isFocusable=function(a){var b;return(b=goog.dom.nativelySupportsFocus_(a)?!a.disabled&&(!goog.dom.hasSpecifiedTabIndex_(a)||goog.dom.isTabIndexFocusable_(a)):goog.dom.isFocusableTabIndex(a))&&goog.userAgent.IE?goog.dom.hasNonZeroBoundingRect_(a):b};goog.dom.hasSpecifiedTabIndex_=function(a){return goog.userAgent.IE&&!goog.userAgent.isVersionOrHigher("9")?(a=a.getAttributeNode("tabindex"),goog.isDefAndNotNull(a)&&a.specified):a.hasAttribute("tabindex")};
+goog.dom.isTabIndexFocusable_=function(a){a=a.tabIndex;return goog.isNumber(a)&&0<=a&&32768>a};goog.dom.nativelySupportsFocus_=function(a){return"A"==a.tagName||"INPUT"==a.tagName||"TEXTAREA"==a.tagName||"SELECT"==a.tagName||"BUTTON"==a.tagName};goog.dom.hasNonZeroBoundingRect_=function(a){a=!goog.isFunction(a.getBoundingClientRect)||goog.userAgent.IE&&null==a.parentElement?{height:a.offsetHeight,width:a.offsetWidth}:a.getBoundingClientRect();return goog.isDefAndNotNull(a)&&0<a.height&&0<a.width};
+goog.dom.getTextContent=function(a){if(goog.dom.BrowserFeature.CAN_USE_INNER_TEXT&&null!==a&&"innerText"in a)a=goog.string.canonicalizeNewlines(a.innerText);else{var b=[];goog.dom.getTextContent_(a,b,!0);a=b.join("")}a=a.replace(/ \xAD /g," ").replace(/\xAD/g,"");a=a.replace(/\u200B/g,"");goog.dom.BrowserFeature.CAN_USE_INNER_TEXT||(a=a.replace(/ +/g," "));" "!=a&&(a=a.replace(/^\s*/,""));return a};goog.dom.getRawTextContent=function(a){var b=[];goog.dom.getTextContent_(a,b,!1);return b.join("")};
+goog.dom.getTextContent_=function(a,b,c){if(!(a.nodeName in goog.dom.TAGS_TO_IGNORE_))if(a.nodeType==goog.dom.NodeType.TEXT)c?b.push(String(a.nodeValue).replace(/(\r\n|\r|\n)/g,"")):b.push(a.nodeValue);else if(a.nodeName in goog.dom.PREDEFINED_TAG_VALUES_)b.push(goog.dom.PREDEFINED_TAG_VALUES_[a.nodeName]);else for(a=a.firstChild;a;)goog.dom.getTextContent_(a,b,c),a=a.nextSibling};goog.dom.getNodeTextLength=function(a){return goog.dom.getTextContent(a).length};
+goog.dom.getNodeTextOffset=function(a,b){for(var c=b||goog.dom.getOwnerDocument(a).body,d=[];a&&a!=c;){for(var e=a;e=e.previousSibling;)d.unshift(goog.dom.getTextContent(e));a=a.parentNode}return goog.string.trimLeft(d.join("")).replace(/ +/g," ").length};
+goog.dom.getNodeAtOffset=function(a,b,c){a=[a];for(var d=0,e=null;0<a.length&&d<b;)if(e=a.pop(),!(e.nodeName in goog.dom.TAGS_TO_IGNORE_))if(e.nodeType==goog.dom.NodeType.TEXT){var f=e.nodeValue.replace(/(\r\n|\r|\n)/g,"").replace(/ +/g," ");d+=f.length}else if(e.nodeName in goog.dom.PREDEFINED_TAG_VALUES_)d+=goog.dom.PREDEFINED_TAG_VALUES_[e.nodeName].length;else for(f=e.childNodes.length-1;0<=f;f--)a.push(e.childNodes[f]);goog.isObject(c)&&(c.remainder=e?e.nodeValue.length+b-d-1:0,c.node=e);return e};
+goog.dom.isNodeList=function(a){if(a&&"number"==typeof a.length){if(goog.isObject(a))return"function"==typeof a.item||"string"==typeof a.item;if(goog.isFunction(a))return"function"==typeof a.item}return!1};goog.dom.getAncestorByTagNameAndClass=function(a,b,c,d){if(!b&&!c)return null;var e=b?String(b).toUpperCase():null;return goog.dom.getAncestor(a,function(a){return(!e||a.nodeName==e)&&(!c||goog.isString(a.className)&&goog.array.contains(a.className.split(/\s+/),c))},!0,d)};
+goog.dom.getAncestorByClass=function(a,b,c){return goog.dom.getAncestorByTagNameAndClass(a,null,b,c)};goog.dom.getAncestor=function(a,b,c,d){a&&!c&&(a=a.parentNode);for(c=0;a&&(null==d||c<=d);){goog.asserts.assert("parentNode"!=a.name);if(b(a))return a;a=a.parentNode;c++}return null};goog.dom.getActiveElement=function(a){try{var b=a&&a.activeElement;return b&&b.nodeName?b:null}catch(c){return null}};
+goog.dom.getPixelRatio=function(){var a=goog.dom.getWindow();return goog.isDef(a.devicePixelRatio)?a.devicePixelRatio:a.matchMedia?goog.dom.matchesPixelRatio_(3)||goog.dom.matchesPixelRatio_(2)||goog.dom.matchesPixelRatio_(1.5)||goog.dom.matchesPixelRatio_(1)||.75:1};goog.dom.matchesPixelRatio_=function(a){return goog.dom.getWindow().matchMedia("(min-resolution: "+a+"dppx),(min--moz-device-pixel-ratio: "+a+"),(min-resolution: "+96*a+"dpi)").matches?a:0};goog.dom.getCanvasContext2D=function(a){return a.getContext("2d")};
+goog.dom.DomHelper=function(a){this.document_=a||goog.global.document||document};goog.dom.DomHelper.prototype.getDomHelper=goog.dom.getDomHelper;goog.dom.DomHelper.prototype.setDocument=function(a){this.document_=a};goog.dom.DomHelper.prototype.getDocument=function(){return this.document_};goog.dom.DomHelper.prototype.getElement=function(a){return goog.dom.getElementHelper_(this.document_,a)};
+goog.dom.DomHelper.prototype.getRequiredElement=function(a){return goog.dom.getRequiredElementHelper_(this.document_,a)};goog.dom.DomHelper.prototype.$=goog.dom.DomHelper.prototype.getElement;goog.dom.DomHelper.prototype.getElementsByTagName=function(a,b){return(b||this.document_).getElementsByTagName(String(a))};goog.dom.DomHelper.prototype.getElementsByTagNameAndClass=function(a,b,c){return goog.dom.getElementsByTagNameAndClass_(this.document_,a,b,c)};
+goog.dom.DomHelper.prototype.getElementByTagNameAndClass=function(a,b,c){return goog.dom.getElementByTagNameAndClass_(this.document_,a,b,c)};goog.dom.DomHelper.prototype.getElementsByClass=function(a,b){return goog.dom.getElementsByClass(a,b||this.document_)};goog.dom.DomHelper.prototype.getElementByClass=function(a,b){return goog.dom.getElementByClass(a,b||this.document_)};goog.dom.DomHelper.prototype.getRequiredElementByClass=function(a,b){return goog.dom.getRequiredElementByClass(a,b||this.document_)};
+goog.dom.DomHelper.prototype.$$=goog.dom.DomHelper.prototype.getElementsByTagNameAndClass;goog.dom.DomHelper.prototype.setProperties=goog.dom.setProperties;goog.dom.DomHelper.prototype.getViewportSize=function(a){return goog.dom.getViewportSize(a||this.getWindow())};goog.dom.DomHelper.prototype.getDocumentHeight=function(){return goog.dom.getDocumentHeight_(this.getWindow())};goog.dom.DomHelper.prototype.createDom=function(a,b,c){return goog.dom.createDom_(this.document_,arguments)};
+goog.dom.DomHelper.prototype.$dom=goog.dom.DomHelper.prototype.createDom;goog.dom.DomHelper.prototype.createElement=function(a){return goog.dom.createElement_(this.document_,a)};goog.dom.DomHelper.prototype.createTextNode=function(a){return this.document_.createTextNode(String(a))};goog.dom.DomHelper.prototype.createTable=function(a,b,c){return goog.dom.createTable_(this.document_,a,b,!!c)};goog.dom.DomHelper.prototype.safeHtmlToNode=function(a){return goog.dom.safeHtmlToNode_(this.document_,a)};
+goog.dom.DomHelper.prototype.isCss1CompatMode=function(){return goog.dom.isCss1CompatMode_(this.document_)};goog.dom.DomHelper.prototype.getWindow=function(){return goog.dom.getWindow_(this.document_)};goog.dom.DomHelper.prototype.getDocumentScrollElement=function(){return goog.dom.getDocumentScrollElement_(this.document_)};goog.dom.DomHelper.prototype.getDocumentScroll=function(){return goog.dom.getDocumentScroll_(this.document_)};
+goog.dom.DomHelper.prototype.getActiveElement=function(a){return goog.dom.getActiveElement(a||this.document_)};goog.dom.DomHelper.prototype.appendChild=goog.dom.appendChild;goog.dom.DomHelper.prototype.append=goog.dom.append;goog.dom.DomHelper.prototype.canHaveChildren=goog.dom.canHaveChildren;goog.dom.DomHelper.prototype.removeChildren=goog.dom.removeChildren;goog.dom.DomHelper.prototype.insertSiblingBefore=goog.dom.insertSiblingBefore;goog.dom.DomHelper.prototype.insertSiblingAfter=goog.dom.insertSiblingAfter;
+goog.dom.DomHelper.prototype.insertChildAt=goog.dom.insertChildAt;goog.dom.DomHelper.prototype.removeNode=goog.dom.removeNode;goog.dom.DomHelper.prototype.replaceNode=goog.dom.replaceNode;goog.dom.DomHelper.prototype.flattenElement=goog.dom.flattenElement;goog.dom.DomHelper.prototype.getChildren=goog.dom.getChildren;goog.dom.DomHelper.prototype.getFirstElementChild=goog.dom.getFirstElementChild;goog.dom.DomHelper.prototype.getLastElementChild=goog.dom.getLastElementChild;
+goog.dom.DomHelper.prototype.getNextElementSibling=goog.dom.getNextElementSibling;goog.dom.DomHelper.prototype.getPreviousElementSibling=goog.dom.getPreviousElementSibling;goog.dom.DomHelper.prototype.getNextNode=goog.dom.getNextNode;goog.dom.DomHelper.prototype.getPreviousNode=goog.dom.getPreviousNode;goog.dom.DomHelper.prototype.isNodeLike=goog.dom.isNodeLike;goog.dom.DomHelper.prototype.isElement=goog.dom.isElement;goog.dom.DomHelper.prototype.isWindow=goog.dom.isWindow;
+goog.dom.DomHelper.prototype.getParentElement=goog.dom.getParentElement;goog.dom.DomHelper.prototype.contains=goog.dom.contains;goog.dom.DomHelper.prototype.compareNodeOrder=goog.dom.compareNodeOrder;goog.dom.DomHelper.prototype.findCommonAncestor=goog.dom.findCommonAncestor;goog.dom.DomHelper.prototype.getOwnerDocument=goog.dom.getOwnerDocument;goog.dom.DomHelper.prototype.getFrameContentDocument=goog.dom.getFrameContentDocument;goog.dom.DomHelper.prototype.getFrameContentWindow=goog.dom.getFrameContentWindow;
+goog.dom.DomHelper.prototype.setTextContent=goog.dom.setTextContent;goog.dom.DomHelper.prototype.getOuterHtml=goog.dom.getOuterHtml;goog.dom.DomHelper.prototype.findNode=goog.dom.findNode;goog.dom.DomHelper.prototype.findNodes=goog.dom.findNodes;goog.dom.DomHelper.prototype.isFocusableTabIndex=goog.dom.isFocusableTabIndex;goog.dom.DomHelper.prototype.setFocusableTabIndex=goog.dom.setFocusableTabIndex;goog.dom.DomHelper.prototype.isFocusable=goog.dom.isFocusable;
+goog.dom.DomHelper.prototype.getTextContent=goog.dom.getTextContent;goog.dom.DomHelper.prototype.getNodeTextLength=goog.dom.getNodeTextLength;goog.dom.DomHelper.prototype.getNodeTextOffset=goog.dom.getNodeTextOffset;goog.dom.DomHelper.prototype.getNodeAtOffset=goog.dom.getNodeAtOffset;goog.dom.DomHelper.prototype.isNodeList=goog.dom.isNodeList;goog.dom.DomHelper.prototype.getAncestorByTagNameAndClass=goog.dom.getAncestorByTagNameAndClass;goog.dom.DomHelper.prototype.getAncestorByClass=goog.dom.getAncestorByClass;
+goog.dom.DomHelper.prototype.getAncestor=goog.dom.getAncestor;goog.dom.DomHelper.prototype.getCanvasContext2D=goog.dom.getCanvasContext2D;goog.dom.vendor={};goog.dom.vendor.getVendorJsPrefix=function(){return goog.userAgent.WEBKIT?"Webkit":goog.userAgent.GECKO?"Moz":goog.userAgent.IE?"ms":goog.userAgent.OPERA?"O":null};goog.dom.vendor.getVendorPrefix=function(){return goog.userAgent.WEBKIT?"-webkit":goog.userAgent.GECKO?"-moz":goog.userAgent.IE?"-ms":goog.userAgent.OPERA?"-o":null};
+goog.dom.vendor.getPrefixedPropertyName=function(a,b){if(b&&a in b)return a;var c=goog.dom.vendor.getVendorJsPrefix();return c?(c=c.toLowerCase(),c+=goog.string.toTitleCase(a),!goog.isDef(b)||c in b?c:null):null};goog.dom.vendor.getPrefixedEventType=function(a){return((goog.dom.vendor.getVendorJsPrefix()||"")+a).toLowerCase()};goog.math.Box=function(a,b,c,d){this.top=a;this.right=b;this.bottom=c;this.left=d};goog.math.Box.boundingBox=function(a){for(var b=new goog.math.Box(arguments[0].y,arguments[0].x,arguments[0].y,arguments[0].x),c=1;c<arguments.length;c++)b.expandToIncludeCoordinate(arguments[c]);return b};goog.math.Box.prototype.getWidth=function(){return this.right-this.left};goog.math.Box.prototype.getHeight=function(){return this.bottom-this.top};
+goog.math.Box.prototype.clone=function(){return new goog.math.Box(this.top,this.right,this.bottom,this.left)};goog.DEBUG&&(goog.math.Box.prototype.toString=function(){return"("+this.top+"t, "+this.right+"r, "+this.bottom+"b, "+this.left+"l)"});goog.math.Box.prototype.contains=function(a){return goog.math.Box.contains(this,a)};
+goog.math.Box.prototype.expand=function(a,b,c,d){goog.isObject(a)?(this.top-=a.top,this.right+=a.right,this.bottom+=a.bottom,this.left-=a.left):(this.top-=a,this.right+=Number(b),this.bottom+=Number(c),this.left-=Number(d));return this};goog.math.Box.prototype.expandToInclude=function(a){this.left=Math.min(this.left,a.left);this.top=Math.min(this.top,a.top);this.right=Math.max(this.right,a.right);this.bottom=Math.max(this.bottom,a.bottom)};
+goog.math.Box.prototype.expandToIncludeCoordinate=function(a){this.top=Math.min(this.top,a.y);this.right=Math.max(this.right,a.x);this.bottom=Math.max(this.bottom,a.y);this.left=Math.min(this.left,a.x)};goog.math.Box.equals=function(a,b){return a==b?!0:a&&b?a.top==b.top&&a.right==b.right&&a.bottom==b.bottom&&a.left==b.left:!1};
+goog.math.Box.contains=function(a,b){return a&&b?b instanceof goog.math.Box?b.left>=a.left&&b.right<=a.right&&b.top>=a.top&&b.bottom<=a.bottom:b.x>=a.left&&b.x<=a.right&&b.y>=a.top&&b.y<=a.bottom:!1};goog.math.Box.relativePositionX=function(a,b){return b.x<a.left?b.x-a.left:b.x>a.right?b.x-a.right:0};goog.math.Box.relativePositionY=function(a,b){return b.y<a.top?b.y-a.top:b.y>a.bottom?b.y-a.bottom:0};
+goog.math.Box.distance=function(a,b){var c=goog.math.Box.relativePositionX(a,b),d=goog.math.Box.relativePositionY(a,b);return Math.sqrt(c*c+d*d)};goog.math.Box.intersects=function(a,b){return a.left<=b.right&&b.left<=a.right&&a.top<=b.bottom&&b.top<=a.bottom};goog.math.Box.intersectsWithPadding=function(a,b,c){return a.left<=b.right+c&&b.left<=a.right+c&&a.top<=b.bottom+c&&b.top<=a.bottom+c};
+goog.math.Box.prototype.ceil=function(){this.top=Math.ceil(this.top);this.right=Math.ceil(this.right);this.bottom=Math.ceil(this.bottom);this.left=Math.ceil(this.left);return this};goog.math.Box.prototype.floor=function(){this.top=Math.floor(this.top);this.right=Math.floor(this.right);this.bottom=Math.floor(this.bottom);this.left=Math.floor(this.left);return this};
+goog.math.Box.prototype.round=function(){this.top=Math.round(this.top);this.right=Math.round(this.right);this.bottom=Math.round(this.bottom);this.left=Math.round(this.left);return this};goog.math.Box.prototype.translate=function(a,b){a instanceof goog.math.Coordinate?(this.left+=a.x,this.right+=a.x,this.top+=a.y,this.bottom+=a.y):(goog.asserts.assertNumber(a),this.left+=a,this.right+=a,goog.isNumber(b)&&(this.top+=b,this.bottom+=b));return this};
+goog.math.Box.prototype.scale=function(a,b){var c=goog.isNumber(b)?b:a;this.left*=a;this.right*=a;this.top*=c;this.bottom*=c;return this};goog.math.IRect=function(){};goog.math.Rect=function(a,b,c,d){this.left=a;this.top=b;this.width=c;this.height=d};goog.math.Rect.prototype.clone=function(){return new goog.math.Rect(this.left,this.top,this.width,this.height)};goog.math.Rect.prototype.toBox=function(){return new goog.math.Box(this.top,this.left+this.width,this.top+this.height,this.left)};goog.math.Rect.createFromPositionAndSize=function(a,b){return new goog.math.Rect(a.x,a.y,b.width,b.height)};
+goog.math.Rect.createFromBox=function(a){return new goog.math.Rect(a.left,a.top,a.right-a.left,a.bottom-a.top)};goog.DEBUG&&(goog.math.Rect.prototype.toString=function(){return"("+this.left+", "+this.top+" - "+this.width+"w x "+this.height+"h)"});goog.math.Rect.equals=function(a,b){return a==b?!0:a&&b?a.left==b.left&&a.width==b.width&&a.top==b.top&&a.height==b.height:!1};
+goog.math.Rect.prototype.intersection=function(a){var b=Math.max(this.left,a.left),c=Math.min(this.left+this.width,a.left+a.width);if(b<=c){var d=Math.max(this.top,a.top);a=Math.min(this.top+this.height,a.top+a.height);if(d<=a)return this.left=b,this.top=d,this.width=c-b,this.height=a-d,!0}return!1};
+goog.math.Rect.intersection=function(a,b){var c=Math.max(a.left,b.left),d=Math.min(a.left+a.width,b.left+b.width);if(c<=d){var e=Math.max(a.top,b.top),f=Math.min(a.top+a.height,b.top+b.height);if(e<=f)return new goog.math.Rect(c,e,d-c,f-e)}return null};goog.math.Rect.intersects=function(a,b){return a.left<=b.left+b.width&&b.left<=a.left+a.width&&a.top<=b.top+b.height&&b.top<=a.top+a.height};goog.math.Rect.prototype.intersects=function(a){return goog.math.Rect.intersects(this,a)};
+goog.math.Rect.difference=function(a,b){var c=goog.math.Rect.intersection(a,b);if(!c||!c.height||!c.width)return[a.clone()];c=[];var d=a.top,e=a.height,f=a.left+a.width,g=a.top+a.height,h=b.left+b.width,k=b.top+b.height;b.top>a.top&&(c.push(new goog.math.Rect(a.left,a.top,a.width,b.top-a.top)),d=b.top,e-=b.top-a.top);k<g&&(c.push(new goog.math.Rect(a.left,k,a.width,g-k)),e=k-d);b.left>a.left&&c.push(new goog.math.Rect(a.left,d,b.left-a.left,e));h<f&&c.push(new goog.math.Rect(h,d,f-h,e));return c};
+goog.math.Rect.prototype.difference=function(a){return goog.math.Rect.difference(this,a)};goog.math.Rect.prototype.boundingRect=function(a){var b=Math.max(this.left+this.width,a.left+a.width),c=Math.max(this.top+this.height,a.top+a.height);this.left=Math.min(this.left,a.left);this.top=Math.min(this.top,a.top);this.width=b-this.left;this.height=c-this.top};goog.math.Rect.boundingRect=function(a,b){if(!a||!b)return null;var c=new goog.math.Rect(a.left,a.top,a.width,a.height);c.boundingRect(b);return c};
+goog.math.Rect.prototype.contains=function(a){return a instanceof goog.math.Coordinate?a.x>=this.left&&a.x<=this.left+this.width&&a.y>=this.top&&a.y<=this.top+this.height:this.left<=a.left&&this.left+this.width>=a.left+a.width&&this.top<=a.top&&this.top+this.height>=a.top+a.height};goog.math.Rect.prototype.squaredDistance=function(a){var b=a.x<this.left?this.left-a.x:Math.max(a.x-(this.left+this.width),0);a=a.y<this.top?this.top-a.y:Math.max(a.y-(this.top+this.height),0);return b*b+a*a};
+goog.math.Rect.prototype.distance=function(a){return Math.sqrt(this.squaredDistance(a))};goog.math.Rect.prototype.getSize=function(){return new goog.math.Size(this.width,this.height)};goog.math.Rect.prototype.getTopLeft=function(){return new goog.math.Coordinate(this.left,this.top)};goog.math.Rect.prototype.getCenter=function(){return new goog.math.Coordinate(this.left+this.width/2,this.top+this.height/2)};
+goog.math.Rect.prototype.getBottomRight=function(){return new goog.math.Coordinate(this.left+this.width,this.top+this.height)};goog.math.Rect.prototype.ceil=function(){this.left=Math.ceil(this.left);this.top=Math.ceil(this.top);this.width=Math.ceil(this.width);this.height=Math.ceil(this.height);return this};goog.math.Rect.prototype.floor=function(){this.left=Math.floor(this.left);this.top=Math.floor(this.top);this.width=Math.floor(this.width);this.height=Math.floor(this.height);return this};
+goog.math.Rect.prototype.round=function(){this.left=Math.round(this.left);this.top=Math.round(this.top);this.width=Math.round(this.width);this.height=Math.round(this.height);return this};goog.math.Rect.prototype.translate=function(a,b){a instanceof goog.math.Coordinate?(this.left+=a.x,this.top+=a.y):(this.left+=goog.asserts.assertNumber(a),goog.isNumber(b)&&(this.top+=b));return this};
+goog.math.Rect.prototype.scale=function(a,b){var c=goog.isNumber(b)?b:a;this.left*=a;this.width*=a;this.top*=c;this.height*=c;return this};goog.style={};goog.style.setStyle=function(a,b,c){if(goog.isString(b))goog.style.setStyle_(a,c,b);else for(var d in b)goog.style.setStyle_(a,b[d],d)};goog.style.setStyle_=function(a,b,c){(c=goog.style.getVendorJsStyleName_(a,c))&&(a.style[c]=b)};goog.style.styleNameCache_={};
+goog.style.getVendorJsStyleName_=function(a,b){var c=goog.style.styleNameCache_[b];if(!c){var d=goog.string.toCamelCase(b);c=d;void 0===a.style[d]&&(d=goog.dom.vendor.getVendorJsPrefix()+goog.string.toTitleCase(d),void 0!==a.style[d]&&(c=d));goog.style.styleNameCache_[b]=c}return c};
+goog.style.getVendorStyleName_=function(a,b){var c=goog.string.toCamelCase(b);return void 0===a.style[c]&&(c=goog.dom.vendor.getVendorJsPrefix()+goog.string.toTitleCase(c),void 0!==a.style[c])?goog.dom.vendor.getVendorPrefix()+"-"+b:b};goog.style.getStyle=function(a,b){var c=a.style[goog.string.toCamelCase(b)];return"undefined"!==typeof c?c:a.style[goog.style.getVendorJsStyleName_(a,b)]||""};
+goog.style.getComputedStyle=function(a,b){var c=goog.dom.getOwnerDocument(a);return c.defaultView&&c.defaultView.getComputedStyle&&(c=c.defaultView.getComputedStyle(a,null))?c[b]||c.getPropertyValue(b)||"":""};goog.style.getCascadedStyle=function(a,b){return a.currentStyle?a.currentStyle[b]:null};goog.style.getStyle_=function(a,b){return goog.style.getComputedStyle(a,b)||goog.style.getCascadedStyle(a,b)||a.style&&a.style[b]};
+goog.style.getComputedBoxSizing=function(a){return goog.style.getStyle_(a,"boxSizing")||goog.style.getStyle_(a,"MozBoxSizing")||goog.style.getStyle_(a,"WebkitBoxSizing")||null};goog.style.getComputedPosition=function(a){return goog.style.getStyle_(a,"position")};goog.style.getBackgroundColor=function(a){return goog.style.getStyle_(a,"backgroundColor")};goog.style.getComputedOverflowX=function(a){return goog.style.getStyle_(a,"overflowX")};
+goog.style.getComputedOverflowY=function(a){return goog.style.getStyle_(a,"overflowY")};goog.style.getComputedZIndex=function(a){return goog.style.getStyle_(a,"zIndex")};goog.style.getComputedTextAlign=function(a){return goog.style.getStyle_(a,"textAlign")};goog.style.getComputedCursor=function(a){return goog.style.getStyle_(a,"cursor")};goog.style.getComputedTransform=function(a){var b=goog.style.getVendorStyleName_(a,"transform");return goog.style.getStyle_(a,b)||goog.style.getStyle_(a,"transform")};
+goog.style.setPosition=function(a,b,c){if(b instanceof goog.math.Coordinate){var d=b.x;b=b.y}else d=b,b=c;a.style.left=goog.style.getPixelStyleValue_(d,!1);a.style.top=goog.style.getPixelStyleValue_(b,!1)};goog.style.getPosition=function(a){return new goog.math.Coordinate(a.offsetLeft,a.offsetTop)};
+goog.style.getClientViewportElement=function(a){a=a?goog.dom.getOwnerDocument(a):goog.dom.getDocument();return!goog.userAgent.IE||goog.userAgent.isDocumentModeOrHigher(9)||goog.dom.getDomHelper(a).isCss1CompatMode()?a.documentElement:a.body};goog.style.getViewportPageOffset=function(a){var b=a.body;a=a.documentElement;return new goog.math.Coordinate(b.scrollLeft||a.scrollLeft,b.scrollTop||a.scrollTop)};
+goog.style.getBoundingClientRect_=function(a){try{var b=a.getBoundingClientRect()}catch(c){return{left:0,top:0,right:0,bottom:0}}goog.userAgent.IE&&a.ownerDocument.body&&(a=a.ownerDocument,b.left-=a.documentElement.clientLeft+a.body.clientLeft,b.top-=a.documentElement.clientTop+a.body.clientTop);return b};
+goog.style.getOffsetParent=function(a){if(goog.userAgent.IE&&!goog.userAgent.isDocumentModeOrHigher(8))return goog.asserts.assert(a&&"offsetParent"in a),a.offsetParent;var b=goog.dom.getOwnerDocument(a),c=goog.style.getStyle_(a,"position"),d="fixed"==c||"absolute"==c;for(a=a.parentNode;a&&a!=b;a=a.parentNode)if(a.nodeType==goog.dom.NodeType.DOCUMENT_FRAGMENT&&a.host&&(a=a.host),c=goog.style.getStyle_(a,"position"),d=d&&"static"==c&&a!=b.documentElement&&a!=b.body,!d&&(a.scrollWidth>a.clientWidth||
+a.scrollHeight>a.clientHeight||"fixed"==c||"absolute"==c||"relative"==c))return a;return null};
+goog.style.getVisibleRectForElement=function(a){for(var b=new goog.math.Box(0,Infinity,Infinity,0),c=goog.dom.getDomHelper(a),d=c.getDocument().body,e=c.getDocument().documentElement,f=c.getDocumentScrollElement();a=goog.style.getOffsetParent(a);)if(!(goog.userAgent.IE&&0==a.clientWidth||goog.userAgent.WEBKIT&&0==a.clientHeight&&a==d)&&a!=d&&a!=e&&"visible"!=goog.style.getStyle_(a,"overflow")){var g=goog.style.getPageOffset(a),h=goog.style.getClientLeftTop(a);g.x+=h.x;g.y+=h.y;b.top=Math.max(b.top,
+g.y);b.right=Math.min(b.right,g.x+a.clientWidth);b.bottom=Math.min(b.bottom,g.y+a.clientHeight);b.left=Math.max(b.left,g.x)}d=f.scrollLeft;f=f.scrollTop;b.left=Math.max(b.left,d);b.top=Math.max(b.top,f);c=c.getViewportSize();b.right=Math.min(b.right,d+c.width);b.bottom=Math.min(b.bottom,f+c.height);return 0<=b.top&&0<=b.left&&b.bottom>b.top&&b.right>b.left?b:null};
+goog.style.getContainerOffsetToScrollInto=function(a,b,c){var d=b||goog.dom.getDocumentScrollElement(),e=goog.style.getPageOffset(a),f=goog.style.getPageOffset(d),g=goog.style.getBorderBox(d);d==goog.dom.getDocumentScrollElement()?(b=e.x-d.scrollLeft,e=e.y-d.scrollTop,goog.userAgent.IE&&!goog.userAgent.isDocumentModeOrHigher(10)&&(b+=g.left,e+=g.top)):(b=e.x-f.x-g.left,e=e.y-f.y-g.top);g=goog.style.getSizeWithDisplay_(a);a=d.clientWidth-g.width;g=d.clientHeight-g.height;f=d.scrollLeft;d=d.scrollTop;
+c?(f+=b-a/2,d+=e-g/2):(f+=Math.min(b,Math.max(b-a,0)),d+=Math.min(e,Math.max(e-g,0)));return new goog.math.Coordinate(f,d)};goog.style.scrollIntoContainerView=function(a,b,c){b=b||goog.dom.getDocumentScrollElement();a=goog.style.getContainerOffsetToScrollInto(a,b,c);b.scrollLeft=a.x;b.scrollTop=a.y};goog.style.getClientLeftTop=function(a){return new goog.math.Coordinate(a.clientLeft,a.clientTop)};
+goog.style.getPageOffset=function(a){var b=goog.dom.getOwnerDocument(a);goog.asserts.assertObject(a,"Parameter is required");var c=new goog.math.Coordinate(0,0),d=goog.style.getClientViewportElement(b);if(a==d)return c;a=goog.style.getBoundingClientRect_(a);b=goog.dom.getDomHelper(b).getDocumentScroll();c.x=a.left+b.x;c.y=a.top+b.y;return c};goog.style.getPageOffsetLeft=function(a){return goog.style.getPageOffset(a).x};goog.style.getPageOffsetTop=function(a){return goog.style.getPageOffset(a).y};
+goog.style.getFramedPageOffset=function(a,b){var c=new goog.math.Coordinate(0,0),d=goog.dom.getWindow(goog.dom.getOwnerDocument(a));if(!goog.reflect.canAccessProperty(d,"parent"))return c;var e=a;do{var f=d==b?goog.style.getPageOffset(e):goog.style.getClientPositionForElement_(goog.asserts.assert(e));c.x+=f.x;c.y+=f.y}while(d&&d!=b&&d!=d.parent&&(e=d.frameElement)&&(d=d.parent));return c};
+goog.style.translateRectForAnotherFrame=function(a,b,c){if(b.getDocument()!=c.getDocument()){var d=b.getDocument().body;c=goog.style.getFramedPageOffset(d,c.getWindow());c=goog.math.Coordinate.difference(c,goog.style.getPageOffset(d));!goog.userAgent.IE||goog.userAgent.isDocumentModeOrHigher(9)||b.isCss1CompatMode()||(c=goog.math.Coordinate.difference(c,b.getDocumentScroll()));a.left+=c.x;a.top+=c.y}};
+goog.style.getRelativePosition=function(a,b){var c=goog.style.getClientPosition(a),d=goog.style.getClientPosition(b);return new goog.math.Coordinate(c.x-d.x,c.y-d.y)};goog.style.getClientPositionForElement_=function(a){a=goog.style.getBoundingClientRect_(a);return new goog.math.Coordinate(a.left,a.top)};
+goog.style.getClientPosition=function(a){goog.asserts.assert(a);if(a.nodeType==goog.dom.NodeType.ELEMENT)return goog.style.getClientPositionForElement_(a);a=a.changedTouches?a.changedTouches[0]:a;return new goog.math.Coordinate(a.clientX,a.clientY)};goog.style.setPageOffset=function(a,b,c){var d=goog.style.getPageOffset(a);b instanceof goog.math.Coordinate&&(c=b.y,b=b.x);b=goog.asserts.assertNumber(b)-d.x;goog.style.setPosition(a,a.offsetLeft+b,a.offsetTop+(Number(c)-d.y))};
+goog.style.setSize=function(a,b,c){if(b instanceof goog.math.Size)c=b.height,b=b.width;else if(void 0==c)throw Error("missing height argument");goog.style.setWidth(a,b);goog.style.setHeight(a,c)};goog.style.getPixelStyleValue_=function(a,b){"number"==typeof a&&(a=(b?Math.round(a):a)+"px");return a};goog.style.setHeight=function(a,b){a.style.height=goog.style.getPixelStyleValue_(b,!0)};goog.style.setWidth=function(a,b){a.style.width=goog.style.getPixelStyleValue_(b,!0)};
+goog.style.getSize=function(a){return goog.style.evaluateWithTemporaryDisplay_(goog.style.getSizeWithDisplay_,a)};goog.style.evaluateWithTemporaryDisplay_=function(a,b){if("none"!=goog.style.getStyle_(b,"display"))return a(b);var c=b.style,d=c.display,e=c.visibility,f=c.position;c.visibility="hidden";c.position="absolute";c.display="inline";var g=a(b);c.display=d;c.position=f;c.visibility=e;return g};
+goog.style.getSizeWithDisplay_=function(a){var b=a.offsetWidth,c=a.offsetHeight,d=goog.userAgent.WEBKIT&&!b&&!c;return goog.isDef(b)&&!d||!a.getBoundingClientRect?new goog.math.Size(b,c):(a=goog.style.getBoundingClientRect_(a),new goog.math.Size(a.right-a.left,a.bottom-a.top))};goog.style.getTransformedSize=function(a){if(!a.getBoundingClientRect)return null;a=goog.style.evaluateWithTemporaryDisplay_(goog.style.getBoundingClientRect_,a);return new goog.math.Size(a.right-a.left,a.bottom-a.top)};
+goog.style.getBounds=function(a){var b=goog.style.getPageOffset(a);a=goog.style.getSize(a);return new goog.math.Rect(b.x,b.y,a.width,a.height)};goog.style.toCamelCase=function(a){return goog.string.toCamelCase(String(a))};goog.style.toSelectorCase=function(a){return goog.string.toSelectorCase(a)};
+goog.style.getOpacity=function(a){goog.asserts.assert(a);var b=a.style;a="";"opacity"in b?a=b.opacity:"MozOpacity"in b?a=b.MozOpacity:"filter"in b&&(b=b.filter.match(/alpha\(opacity=([\d.]+)\)/))&&(a=String(b[1]/100));return""==a?a:Number(a)};goog.style.setOpacity=function(a,b){goog.asserts.assert(a);var c=a.style;"opacity"in c?c.opacity=b:"MozOpacity"in c?c.MozOpacity=b:"filter"in c&&(c.filter=""===b?"":"alpha(opacity="+100*Number(b)+")")};
+goog.style.setTransparentBackgroundImage=function(a,b){var c=a.style;goog.userAgent.IE&&!goog.userAgent.isVersionOrHigher("8")?c.filter='progid:DXImageTransform.Microsoft.AlphaImageLoader(src="'+b+'", sizingMethod="crop")':(c.backgroundImage="url("+b+")",c.backgroundPosition="top left",c.backgroundRepeat="no-repeat")};goog.style.clearTransparentBackgroundImage=function(a){a=a.style;"filter"in a?a.filter="":a.backgroundImage="none"};
+goog.style.showElement=function(a,b){goog.style.setElementShown(a,b)};goog.style.setElementShown=function(a,b){a.style.display=b?"":"none"};goog.style.isElementShown=function(a){return"none"!=a.style.display};
+goog.style.installSafeStyleSheet=function(a,b){var c=goog.dom.getDomHelper(b),d=c.getDocument();if(goog.userAgent.IE&&d.createStyleSheet)return c=d.createStyleSheet(),goog.style.setSafeStyleSheet(c,a),c;d=c.getElementsByTagNameAndClass("HEAD")[0];if(!d){var e=c.getElementsByTagNameAndClass("BODY")[0];d=c.createDom("HEAD");e.parentNode.insertBefore(d,e)}e=c.createDom("STYLE");goog.style.setSafeStyleSheet(e,a);c.appendChild(d,e);return e};
+goog.style.uninstallStyles=function(a){goog.dom.removeNode(a.ownerNode||a.owningElement||a)};goog.style.setSafeStyleSheet=function(a,b){var c=goog.html.SafeStyleSheet.unwrap(b);goog.userAgent.IE&&goog.isDef(a.cssText)?a.cssText=c:a.innerHTML=c};goog.style.setPreWrap=function(a){a=a.style;goog.userAgent.IE&&!goog.userAgent.isVersionOrHigher("8")?(a.whiteSpace="pre",a.wordWrap="break-word"):a.whiteSpace=goog.userAgent.GECKO?"-moz-pre-wrap":"pre-wrap"};
+goog.style.setInlineBlock=function(a){a=a.style;a.position="relative";goog.userAgent.IE&&!goog.userAgent.isVersionOrHigher("8")?(a.zoom="1",a.display="inline"):a.display="inline-block"};goog.style.isRightToLeft=function(a){return"rtl"==goog.style.getStyle_(a,"direction")};goog.style.unselectableStyle_=goog.userAgent.GECKO?"MozUserSelect":goog.userAgent.WEBKIT||goog.userAgent.EDGE?"WebkitUserSelect":null;
+goog.style.isUnselectable=function(a){return goog.style.unselectableStyle_?"none"==a.style[goog.style.unselectableStyle_].toLowerCase():goog.userAgent.IE||goog.userAgent.OPERA?"on"==a.getAttribute("unselectable"):!1};
+goog.style.setUnselectable=function(a,b,c){c=c?null:a.getElementsByTagName("*");var d=goog.style.unselectableStyle_;if(d){if(b=b?"none":"",a.style&&(a.style[d]=b),c){a=0;for(var e;e=c[a];a++)e.style&&(e.style[d]=b)}}else if(goog.userAgent.IE||goog.userAgent.OPERA)if(b=b?"on":"",a.setAttribute("unselectable",b),c)for(a=0;e=c[a];a++)e.setAttribute("unselectable",b)};goog.style.getBorderBoxSize=function(a){return new goog.math.Size(a.offsetWidth,a.offsetHeight)};
+goog.style.setBorderBoxSize=function(a,b){var c=goog.dom.getOwnerDocument(a),d=goog.dom.getDomHelper(c).isCss1CompatMode();if(!goog.userAgent.IE||goog.userAgent.isVersionOrHigher("10")||d&&goog.userAgent.isVersionOrHigher("8"))goog.style.setBoxSizingSize_(a,b,"border-box");else if(c=a.style,d){d=goog.style.getPaddingBox(a);var e=goog.style.getBorderBox(a);c.pixelWidth=b.width-e.left-d.left-d.right-e.right;c.pixelHeight=b.height-e.top-d.top-d.bottom-e.bottom}else c.pixelWidth=b.width,c.pixelHeight=
+b.height};
+goog.style.getContentBoxSize=function(a){var b=goog.dom.getOwnerDocument(a),c=goog.userAgent.IE&&a.currentStyle;if(c&&goog.dom.getDomHelper(b).isCss1CompatMode()&&"auto"!=c.width&&"auto"!=c.height&&!c.boxSizing)return b=goog.style.getIePixelValue_(a,c.width,"width","pixelWidth"),a=goog.style.getIePixelValue_(a,c.height,"height","pixelHeight"),new goog.math.Size(b,a);c=goog.style.getBorderBoxSize(a);b=goog.style.getPaddingBox(a);a=goog.style.getBorderBox(a);return new goog.math.Size(c.width-a.left-
+b.left-b.right-a.right,c.height-a.top-b.top-b.bottom-a.bottom)};
+goog.style.setContentBoxSize=function(a,b){var c=goog.dom.getOwnerDocument(a),d=goog.dom.getDomHelper(c).isCss1CompatMode();if(!goog.userAgent.IE||goog.userAgent.isVersionOrHigher("10")||d&&goog.userAgent.isVersionOrHigher("8"))goog.style.setBoxSizingSize_(a,b,"content-box");else if(c=a.style,d)c.pixelWidth=b.width,c.pixelHeight=b.height;else{d=goog.style.getPaddingBox(a);var e=goog.style.getBorderBox(a);c.pixelWidth=b.width+e.left+d.left+d.right+e.right;c.pixelHeight=b.height+e.top+d.top+d.bottom+
+e.bottom}};goog.style.setBoxSizingSize_=function(a,b,c){a=a.style;goog.userAgent.GECKO?a.MozBoxSizing=c:goog.userAgent.WEBKIT?a.WebkitBoxSizing=c:a.boxSizing=c;a.width=Math.max(b.width,0)+"px";a.height=Math.max(b.height,0)+"px"};goog.style.getIePixelValue_=function(a,b,c,d){if(/^\d+px?$/.test(b))return parseInt(b,10);var e=a.style[c],f=a.runtimeStyle[c];a.runtimeStyle[c]=a.currentStyle[c];a.style[c]=b;b=a.style[d];a.style[c]=e;a.runtimeStyle[c]=f;return+b};
+goog.style.getIePixelDistance_=function(a,b){var c=goog.style.getCascadedStyle(a,b);return c?goog.style.getIePixelValue_(a,c,"left","pixelLeft"):0};
+goog.style.getBox_=function(a,b){if(goog.userAgent.IE){var c=goog.style.getIePixelDistance_(a,b+"Left"),d=goog.style.getIePixelDistance_(a,b+"Right"),e=goog.style.getIePixelDistance_(a,b+"Top"),f=goog.style.getIePixelDistance_(a,b+"Bottom");return new goog.math.Box(e,d,f,c)}c=goog.style.getComputedStyle(a,b+"Left");d=goog.style.getComputedStyle(a,b+"Right");e=goog.style.getComputedStyle(a,b+"Top");f=goog.style.getComputedStyle(a,b+"Bottom");return new goog.math.Box(parseFloat(e),parseFloat(d),parseFloat(f),
+parseFloat(c))};goog.style.getPaddingBox=function(a){return goog.style.getBox_(a,"padding")};goog.style.getMarginBox=function(a){return goog.style.getBox_(a,"margin")};goog.style.ieBorderWidthKeywords_={thin:2,medium:4,thick:6};
+goog.style.getIePixelBorder_=function(a,b){if("none"==goog.style.getCascadedStyle(a,b+"Style"))return 0;var c=goog.style.getCascadedStyle(a,b+"Width");return c in goog.style.ieBorderWidthKeywords_?goog.style.ieBorderWidthKeywords_[c]:goog.style.getIePixelValue_(a,c,"left","pixelLeft")};
+goog.style.getBorderBox=function(a){if(goog.userAgent.IE&&!goog.userAgent.isDocumentModeOrHigher(9)){var b=goog.style.getIePixelBorder_(a,"borderLeft"),c=goog.style.getIePixelBorder_(a,"borderRight"),d=goog.style.getIePixelBorder_(a,"borderTop");a=goog.style.getIePixelBorder_(a,"borderBottom");return new goog.math.Box(d,c,a,b)}b=goog.style.getComputedStyle(a,"borderLeftWidth");c=goog.style.getComputedStyle(a,"borderRightWidth");d=goog.style.getComputedStyle(a,"borderTopWidth");a=goog.style.getComputedStyle(a,
+"borderBottomWidth");return new goog.math.Box(parseFloat(d),parseFloat(c),parseFloat(a),parseFloat(b))};goog.style.getFontFamily=function(a){var b=goog.dom.getOwnerDocument(a),c="";if(b.body.createTextRange&&goog.dom.contains(b,a)){b=b.body.createTextRange();b.moveToElementText(a);try{c=b.queryCommandValue("FontName")}catch(d){c=""}}c||(c=goog.style.getStyle_(a,"fontFamily"));a=c.split(",");1<a.length&&(c=a[0]);return goog.string.stripQuotes(c,"\"'")};goog.style.lengthUnitRegex_=/[^\d]+$/;
+goog.style.getLengthUnits=function(a){return(a=a.match(goog.style.lengthUnitRegex_))&&a[0]||null};goog.style.ABSOLUTE_CSS_LENGTH_UNITS_={cm:1,"in":1,mm:1,pc:1,pt:1};goog.style.CONVERTIBLE_RELATIVE_CSS_UNITS_={em:1,ex:1};
+goog.style.getFontSize=function(a){var b=goog.style.getStyle_(a,"fontSize"),c=goog.style.getLengthUnits(b);if(b&&"px"==c)return parseInt(b,10);if(goog.userAgent.IE){if(String(c)in goog.style.ABSOLUTE_CSS_LENGTH_UNITS_)return goog.style.getIePixelValue_(a,b,"left","pixelLeft");if(a.parentNode&&a.parentNode.nodeType==goog.dom.NodeType.ELEMENT&&String(c)in goog.style.CONVERTIBLE_RELATIVE_CSS_UNITS_)return a=a.parentNode,c=goog.style.getStyle_(a,"fontSize"),goog.style.getIePixelValue_(a,b==c?"1em":b,
+"left","pixelLeft")}c=goog.dom.createDom("SPAN",{style:"visibility:hidden;position:absolute;line-height:0;padding:0;margin:0;border:0;height:1em;"});goog.dom.appendChild(a,c);b=c.offsetHeight;goog.dom.removeNode(c);return b};goog.style.parseStyleAttribute=function(a){var b={};goog.array.forEach(a.split(/\s*;\s*/),function(a){var c=a.match(/\s*([\w-]+)\s*:(.+)/);c&&(a=c[1],c=goog.string.trim(c[2]),b[goog.string.toCamelCase(a.toLowerCase())]=c)});return b};
+goog.style.toStyleAttribute=function(a){var b=[];goog.object.forEach(a,function(a,d){b.push(goog.string.toSelectorCase(d),":",a,";")});return b.join("")};goog.style.setFloat=function(a,b){a.style[goog.userAgent.IE?"styleFloat":"cssFloat"]=b};goog.style.getFloat=function(a){return a.style[goog.userAgent.IE?"styleFloat":"cssFloat"]||""};
+goog.style.getScrollbarWidth=function(a){var b=goog.dom.createElement("DIV");a&&(b.className=a);b.style.cssText="overflow:auto;position:absolute;top:0;width:100px;height:100px";a=goog.dom.createElement("DIV");goog.style.setSize(a,"200px","200px");b.appendChild(a);goog.dom.appendChild(goog.dom.getDocument().body,b);a=b.offsetWidth-b.clientWidth;goog.dom.removeNode(b);return a};goog.style.MATRIX_TRANSLATION_REGEX_=/matrix\([0-9\.\-]+, [0-9\.\-]+, [0-9\.\-]+, [0-9\.\-]+, ([0-9\.\-]+)p?x?, ([0-9\.\-]+)p?x?\)/;
+goog.style.getCssTranslation=function(a){a=goog.style.getComputedTransform(a);return a?(a=a.match(goog.style.MATRIX_TRANSLATION_REGEX_))?new goog.math.Coordinate(parseFloat(a[1]),parseFloat(a[2])):new goog.math.Coordinate(0,0):new goog.math.Coordinate(0,0)};goog.events.EventHandler=function(a){goog.Disposable.call(this);this.handler_=a;this.keys_={}};goog.inherits(goog.events.EventHandler,goog.Disposable);goog.events.EventHandler.typeArray_=[];goog.events.EventHandler.prototype.listen=function(a,b,c,d){return this.listen_(a,b,c,d)};goog.events.EventHandler.prototype.listenWithScope=function(a,b,c,d,e){return this.listen_(a,b,c,d,e)};
+goog.events.EventHandler.prototype.listen_=function(a,b,c,d,e){goog.isArray(b)||(b&&(goog.events.EventHandler.typeArray_[0]=b.toString()),b=goog.events.EventHandler.typeArray_);for(var f=0;f<b.length;f++){var g=goog.events.listen(a,b[f],c||this.handleEvent,d||!1,e||this.handler_||this);if(!g)break;this.keys_[g.key]=g}return this};goog.events.EventHandler.prototype.listenOnce=function(a,b,c,d){return this.listenOnce_(a,b,c,d)};
+goog.events.EventHandler.prototype.listenOnceWithScope=function(a,b,c,d,e){return this.listenOnce_(a,b,c,d,e)};goog.events.EventHandler.prototype.listenOnce_=function(a,b,c,d,e){if(goog.isArray(b))for(var f=0;f<b.length;f++)this.listenOnce_(a,b[f],c,d,e);else{a=goog.events.listenOnce(a,b,c||this.handleEvent,d,e||this.handler_||this);if(!a)return this;this.keys_[a.key]=a}return this};goog.events.EventHandler.prototype.listenWithWrapper=function(a,b,c,d){return this.listenWithWrapper_(a,b,c,d)};
+goog.events.EventHandler.prototype.listenWithWrapperAndScope=function(a,b,c,d,e){return this.listenWithWrapper_(a,b,c,d,e)};goog.events.EventHandler.prototype.listenWithWrapper_=function(a,b,c,d,e){b.listen(a,c,d,e||this.handler_||this,this);return this};goog.events.EventHandler.prototype.getListenerCount=function(){var a=0,b;for(b in this.keys_)Object.prototype.hasOwnProperty.call(this.keys_,b)&&a++;return a};
+goog.events.EventHandler.prototype.unlisten=function(a,b,c,d,e){if(goog.isArray(b))for(var f=0;f<b.length;f++)this.unlisten(a,b[f],c,d,e);else if(d=goog.isObject(d)?!!d.capture:!!d,a=goog.events.getListener(a,b,c||this.handleEvent,d,e||this.handler_||this))goog.events.unlistenByKey(a),delete this.keys_[a.key];return this};goog.events.EventHandler.prototype.unlistenWithWrapper=function(a,b,c,d,e){b.unlisten(a,c,d,e||this.handler_||this,this);return this};
+goog.events.EventHandler.prototype.removeAll=function(){goog.object.forEach(this.keys_,function(a,b){this.keys_.hasOwnProperty(b)&&goog.events.unlistenByKey(a)},this);this.keys_={}};goog.events.EventHandler.prototype.disposeInternal=function(){goog.events.EventHandler.superClass_.disposeInternal.call(this);this.removeAll()};goog.events.EventHandler.prototype.handleEvent=function(a){throw Error("EventHandler.handleEvent not implemented");};goog.events.EventTarget=function(){goog.Disposable.call(this);this.eventTargetListeners_=new goog.events.ListenerMap(this);this.actualEventTarget_=this;this.parentEventTarget_=null};goog.inherits(goog.events.EventTarget,goog.Disposable);goog.events.Listenable.addImplementation(goog.events.EventTarget);goog.events.EventTarget.MAX_ANCESTORS_=1E3;goog.events.EventTarget.prototype.getParentEventTarget=function(){return this.parentEventTarget_};
+goog.events.EventTarget.prototype.setParentEventTarget=function(a){this.parentEventTarget_=a};goog.events.EventTarget.prototype.addEventListener=function(a,b,c,d){goog.events.listen(this,a,b,c,d)};goog.events.EventTarget.prototype.removeEventListener=function(a,b,c,d){goog.events.unlisten(this,a,b,c,d)};
+goog.events.EventTarget.prototype.dispatchEvent=function(a){this.assertInitialized_();var b=this.getParentEventTarget();if(b){var c=[];for(var d=1;b;b=b.getParentEventTarget())c.push(b),goog.asserts.assert(++d<goog.events.EventTarget.MAX_ANCESTORS_,"infinite loop")}return goog.events.EventTarget.dispatchEventInternal_(this.actualEventTarget_,a,c)};
+goog.events.EventTarget.prototype.disposeInternal=function(){goog.events.EventTarget.superClass_.disposeInternal.call(this);this.removeAllListeners();this.parentEventTarget_=null};goog.events.EventTarget.prototype.listen=function(a,b,c,d){this.assertInitialized_();return this.eventTargetListeners_.add(String(a),b,!1,c,d)};goog.events.EventTarget.prototype.listenOnce=function(a,b,c,d){return this.eventTargetListeners_.add(String(a),b,!0,c,d)};
+goog.events.EventTarget.prototype.unlisten=function(a,b,c,d){return this.eventTargetListeners_.remove(String(a),b,c,d)};goog.events.EventTarget.prototype.unlistenByKey=function(a){return this.eventTargetListeners_.removeByKey(a)};goog.events.EventTarget.prototype.removeAllListeners=function(a){return this.eventTargetListeners_?this.eventTargetListeners_.removeAll(a):0};
+goog.events.EventTarget.prototype.fireListeners=function(a,b,c){a=this.eventTargetListeners_.listeners[String(a)];if(!a)return!0;a=a.concat();for(var d=!0,e=0;e<a.length;++e){var f=a[e];if(f&&!f.removed&&f.capture==b){var g=f.listener,h=f.handler||f.src;f.callOnce&&this.unlistenByKey(f);d=!1!==g.call(h,c)&&d}}return d&&0!=c.returnValue_};goog.events.EventTarget.prototype.getListeners=function(a,b){return this.eventTargetListeners_.getListeners(String(a),b)};
+goog.events.EventTarget.prototype.getListener=function(a,b,c,d){return this.eventTargetListeners_.getListener(String(a),b,c,d)};goog.events.EventTarget.prototype.hasListener=function(a,b){var c=goog.isDef(a)?String(a):void 0;return this.eventTargetListeners_.hasListener(c,b)};goog.events.EventTarget.prototype.setTargetForTesting=function(a){this.actualEventTarget_=a};goog.events.EventTarget.prototype.assertInitialized_=function(){goog.asserts.assert(this.eventTargetListeners_,"Event target is not initialized. Did you call the superclass (goog.events.EventTarget) constructor?")};
+goog.events.EventTarget.dispatchEventInternal_=function(a,b,c){var d=b.type||b;if(goog.isString(b))b=new goog.events.Event(b,a);else if(b instanceof goog.events.Event)b.target=b.target||a;else{var e=b;b=new goog.events.Event(d,a);goog.object.extend(b,e)}e=!0;if(c)for(var f=c.length-1;!b.propagationStopped_&&0<=f;f--){var g=b.currentTarget=c[f];e=g.fireListeners(d,!0,b)&&e}b.propagationStopped_||(g=b.currentTarget=a,e=g.fireListeners(d,!0,b)&&e,b.propagationStopped_||(e=g.fireListeners(d,!1,b)&&e));
+if(c)for(f=0;!b.propagationStopped_&&f<c.length;f++)g=b.currentTarget=c[f],e=g.fireListeners(d,!1,b)&&e;return e};goog.ui={};goog.ui.IdGenerator=function(){};goog.addSingletonGetter(goog.ui.IdGenerator);goog.ui.IdGenerator.prototype.nextId_=0;goog.ui.IdGenerator.prototype.idPrefix_="";goog.ui.IdGenerator.prototype.setIdPrefix=function(a){this.idPrefix_=a};goog.ui.IdGenerator.prototype.getNextUniqueId=function(){return this.idPrefix_+":"+(this.nextId_++).toString(36)};goog.ui.Component=function(a){goog.events.EventTarget.call(this);this.dom_=a||goog.dom.getDomHelper();this.rightToLeft_=goog.ui.Component.defaultRightToLeft_;this.id_=null;this.inDocument_=!1;this.element_=null;this.googUiComponentHandler_=void 0;this.childIndex_=this.children_=this.parent_=this.model_=null;this.pointerEventsEnabled_=this.wasDecorated_=!1};goog.inherits(goog.ui.Component,goog.events.EventTarget);goog.ui.Component.ALLOW_DETACHED_DECORATION=!1;
+goog.ui.Component.prototype.idGenerator_=goog.ui.IdGenerator.getInstance();goog.ui.Component.DEFAULT_BIDI_DIR=0;goog.ui.Component.defaultRightToLeft_=1==goog.ui.Component.DEFAULT_BIDI_DIR?!1:-1==goog.ui.Component.DEFAULT_BIDI_DIR?!0:null;
+goog.ui.Component.EventType={BEFORE_SHOW:"beforeshow",SHOW:"show",HIDE:"hide",DISABLE:"disable",ENABLE:"enable",HIGHLIGHT:"highlight",UNHIGHLIGHT:"unhighlight",ACTIVATE:"activate",DEACTIVATE:"deactivate",SELECT:"select",UNSELECT:"unselect",CHECK:"check",UNCHECK:"uncheck",FOCUS:"focus",BLUR:"blur",OPEN:"open",CLOSE:"close",ENTER:"enter",LEAVE:"leave",ACTION:"action",CHANGE:"change"};
+goog.ui.Component.Error={NOT_SUPPORTED:"Method not supported",DECORATE_INVALID:"Invalid element to decorate",ALREADY_RENDERED:"Component already rendered",PARENT_UNABLE_TO_BE_SET:"Unable to set parent component",CHILD_INDEX_OUT_OF_BOUNDS:"Child component index out of bounds",NOT_OUR_CHILD:"Child is not in parent component",NOT_IN_DOCUMENT:"Operation not supported while component is not in document",STATE_INVALID:"Invalid component state"};
+goog.ui.Component.State={ALL:255,DISABLED:1,HOVER:2,ACTIVE:4,SELECTED:8,CHECKED:16,FOCUSED:32,OPENED:64};
+goog.ui.Component.getStateTransitionEvent=function(a,b){switch(a){case goog.ui.Component.State.DISABLED:return b?goog.ui.Component.EventType.DISABLE:goog.ui.Component.EventType.ENABLE;case goog.ui.Component.State.HOVER:return b?goog.ui.Component.EventType.HIGHLIGHT:goog.ui.Component.EventType.UNHIGHLIGHT;case goog.ui.Component.State.ACTIVE:return b?goog.ui.Component.EventType.ACTIVATE:goog.ui.Component.EventType.DEACTIVATE;case goog.ui.Component.State.SELECTED:return b?goog.ui.Component.EventType.SELECT:
+goog.ui.Component.EventType.UNSELECT;case goog.ui.Component.State.CHECKED:return b?goog.ui.Component.EventType.CHECK:goog.ui.Component.EventType.UNCHECK;case goog.ui.Component.State.FOCUSED:return b?goog.ui.Component.EventType.FOCUS:goog.ui.Component.EventType.BLUR;case goog.ui.Component.State.OPENED:return b?goog.ui.Component.EventType.OPEN:goog.ui.Component.EventType.CLOSE}throw Error(goog.ui.Component.Error.STATE_INVALID);};
+goog.ui.Component.setDefaultRightToLeft=function(a){goog.ui.Component.defaultRightToLeft_=a};goog.ui.Component.prototype.getId=function(){return this.id_||(this.id_=this.idGenerator_.getNextUniqueId())};goog.ui.Component.prototype.setId=function(a){this.parent_&&this.parent_.childIndex_&&(goog.object.remove(this.parent_.childIndex_,this.id_),goog.object.add(this.parent_.childIndex_,a,this));this.id_=a};goog.ui.Component.prototype.getElement=function(){return this.element_};
+goog.ui.Component.prototype.getElementStrict=function(){var a=this.element_;goog.asserts.assert(a,"Can not call getElementStrict before rendering/decorating.");return a};goog.ui.Component.prototype.setElementInternal=function(a){this.element_=a};goog.ui.Component.prototype.getElementsByClass=function(a){return this.element_?this.dom_.getElementsByClass(a,this.element_):[]};goog.ui.Component.prototype.getElementByClass=function(a){return this.element_?this.dom_.getElementByClass(a,this.element_):null};
+goog.ui.Component.prototype.getRequiredElementByClass=function(a){var b=this.getElementByClass(a);goog.asserts.assert(b,"Expected element in component with class: %s",a);return b};goog.ui.Component.prototype.getHandler=function(){this.googUiComponentHandler_||(this.googUiComponentHandler_=new goog.events.EventHandler(this));return goog.asserts.assert(this.googUiComponentHandler_)};
+goog.ui.Component.prototype.setParent=function(a){if(this==a)throw Error(goog.ui.Component.Error.PARENT_UNABLE_TO_BE_SET);if(a&&this.parent_&&this.id_&&this.parent_.getChild(this.id_)&&this.parent_!=a)throw Error(goog.ui.Component.Error.PARENT_UNABLE_TO_BE_SET);this.parent_=a;goog.ui.Component.superClass_.setParentEventTarget.call(this,a)};goog.ui.Component.prototype.getParent=function(){return this.parent_};
+goog.ui.Component.prototype.setParentEventTarget=function(a){if(this.parent_&&this.parent_!=a)throw Error(goog.ui.Component.Error.NOT_SUPPORTED);goog.ui.Component.superClass_.setParentEventTarget.call(this,a)};goog.ui.Component.prototype.getDomHelper=function(){return this.dom_};goog.ui.Component.prototype.isInDocument=function(){return this.inDocument_};goog.ui.Component.prototype.createDom=function(){this.element_=this.dom_.createElement("DIV")};goog.ui.Component.prototype.render=function(a){this.render_(a)};
+goog.ui.Component.prototype.renderBefore=function(a){this.render_(a.parentNode,a)};goog.ui.Component.prototype.render_=function(a,b){if(this.inDocument_)throw Error(goog.ui.Component.Error.ALREADY_RENDERED);this.element_||this.createDom();a?a.insertBefore(this.element_,b||null):this.dom_.getDocument().body.appendChild(this.element_);this.parent_&&!this.parent_.isInDocument()||this.enterDocument()};
+goog.ui.Component.prototype.decorate=function(a){if(this.inDocument_)throw Error(goog.ui.Component.Error.ALREADY_RENDERED);if(a&&this.canDecorate(a)){this.wasDecorated_=!0;var b=goog.dom.getOwnerDocument(a);this.dom_&&this.dom_.getDocument()==b||(this.dom_=goog.dom.getDomHelper(a));this.decorateInternal(a);goog.ui.Component.ALLOW_DETACHED_DECORATION&&!goog.dom.contains(b,a)||this.enterDocument()}else throw Error(goog.ui.Component.Error.DECORATE_INVALID);};goog.ui.Component.prototype.canDecorate=function(a){return!0};
+goog.ui.Component.prototype.wasDecorated=function(){return this.wasDecorated_};goog.ui.Component.prototype.decorateInternal=function(a){this.element_=a};goog.ui.Component.prototype.enterDocument=function(){this.inDocument_=!0;this.forEachChild(function(a){!a.isInDocument()&&a.getElement()&&a.enterDocument()})};
+goog.ui.Component.prototype.exitDocument=function(){this.forEachChild(function(a){a.isInDocument()&&a.exitDocument()});this.googUiComponentHandler_&&this.googUiComponentHandler_.removeAll();this.inDocument_=!1};
+goog.ui.Component.prototype.disposeInternal=function(){this.inDocument_&&this.exitDocument();this.googUiComponentHandler_&&(this.googUiComponentHandler_.dispose(),delete this.googUiComponentHandler_);this.forEachChild(function(a){a.dispose()});!this.wasDecorated_&&this.element_&&goog.dom.removeNode(this.element_);this.parent_=this.model_=this.element_=this.childIndex_=this.children_=null;goog.ui.Component.superClass_.disposeInternal.call(this)};
+goog.ui.Component.prototype.makeId=function(a){return this.getId()+"."+a};goog.ui.Component.prototype.makeIds=function(a){var b={},c;for(c in a)b[c]=this.makeId(a[c]);return b};goog.ui.Component.prototype.getModel=function(){return this.model_};goog.ui.Component.prototype.setModel=function(a){this.model_=a};goog.ui.Component.prototype.getFragmentFromId=function(a){return a.substring(this.getId().length+1)};
+goog.ui.Component.prototype.getElementByFragment=function(a){if(!this.inDocument_)throw Error(goog.ui.Component.Error.NOT_IN_DOCUMENT);return this.dom_.getElement(this.makeId(a))};goog.ui.Component.prototype.addChild=function(a,b){this.addChildAt(a,this.getChildCount(),b)};
+goog.ui.Component.prototype.addChildAt=function(a,b,c){goog.asserts.assert(!!a,"Provided element must not be null.");if(a.inDocument_&&(c||!this.inDocument_))throw Error(goog.ui.Component.Error.ALREADY_RENDERED);if(0>b||b>this.getChildCount())throw Error(goog.ui.Component.Error.CHILD_INDEX_OUT_OF_BOUNDS);this.childIndex_&&this.children_||(this.childIndex_={},this.children_=[]);a.getParent()==this?(goog.object.set(this.childIndex_,a.getId(),a),goog.array.remove(this.children_,a)):goog.object.add(this.childIndex_,
+a.getId(),a);a.setParent(this);goog.array.insertAt(this.children_,a,b);a.inDocument_&&this.inDocument_&&a.getParent()==this?(c=this.getContentElement(),b=c.childNodes[b]||null,b!=a.getElement()&&c.insertBefore(a.getElement(),b)):c?(this.element_||this.createDom(),b=this.getChildAt(b+1),a.render_(this.getContentElement(),b?b.element_:null)):this.inDocument_&&!a.inDocument_&&a.element_&&a.element_.parentNode&&a.element_.parentNode.nodeType==goog.dom.NodeType.ELEMENT&&a.enterDocument()};
+goog.ui.Component.prototype.getContentElement=function(){return this.element_};goog.ui.Component.prototype.isRightToLeft=function(){null==this.rightToLeft_&&(this.rightToLeft_=goog.style.isRightToLeft(this.inDocument_?this.element_:this.dom_.getDocument().body));return this.rightToLeft_};goog.ui.Component.prototype.setRightToLeft=function(a){if(this.inDocument_)throw Error(goog.ui.Component.Error.ALREADY_RENDERED);this.rightToLeft_=a};
+goog.ui.Component.prototype.hasChildren=function(){return!!this.children_&&0!=this.children_.length};goog.ui.Component.prototype.getChildCount=function(){return this.children_?this.children_.length:0};goog.ui.Component.prototype.getChildIds=function(){var a=[];this.forEachChild(function(b){a.push(b.getId())});return a};goog.ui.Component.prototype.getChild=function(a){return this.childIndex_&&a?goog.object.get(this.childIndex_,a)||null:null};
+goog.ui.Component.prototype.getChildAt=function(a){return this.children_?this.children_[a]||null:null};goog.ui.Component.prototype.forEachChild=function(a,b){this.children_&&goog.array.forEach(this.children_,a,b)};goog.ui.Component.prototype.indexOfChild=function(a){return this.children_&&a?goog.array.indexOf(this.children_,a):-1};
+goog.ui.Component.prototype.removeChild=function(a,b){if(a){var c=goog.isString(a)?a:a.getId();a=this.getChild(c);c&&a&&(goog.object.remove(this.childIndex_,c),goog.array.remove(this.children_,a),b&&(a.exitDocument(),a.element_&&goog.dom.removeNode(a.element_)),a.setParent(null))}if(!a)throw Error(goog.ui.Component.Error.NOT_OUR_CHILD);return a};goog.ui.Component.prototype.removeChildAt=function(a,b){return this.removeChild(this.getChildAt(a),b)};
+goog.ui.Component.prototype.removeChildren=function(a){for(var b=[];this.hasChildren();)b.push(this.removeChildAt(0,a));return b};goog.ui.Component.prototype.pointerEventsEnabled=function(){return this.pointerEventsEnabled_};goog.ui.Component.prototype.setPointerEventsEnabled=function(a){if(this.inDocument_)throw Error(goog.ui.Component.Error.ALREADY_RENDERED);this.pointerEventsEnabled_=a};goog.a11y={};goog.a11y.aria={};
+goog.a11y.aria.Role={ALERT:"alert",ALERTDIALOG:"alertdialog",APPLICATION:"application",ARTICLE:"article",BANNER:"banner",BUTTON:"button",CHECKBOX:"checkbox",COLUMNHEADER:"columnheader",COMBOBOX:"combobox",COMPLEMENTARY:"complementary",CONTENTINFO:"contentinfo",DEFINITION:"definition",DIALOG:"dialog",DIRECTORY:"directory",DOCUMENT:"document",FORM:"form",GRID:"grid",GRIDCELL:"gridcell",GROUP:"group",HEADING:"heading",IMG:"img",LINK:"link",LIST:"list",LISTBOX:"listbox",LISTITEM:"listitem",LOG:"log",
+MAIN:"main",MARQUEE:"marquee",MATH:"math",MENU:"menu",MENUBAR:"menubar",MENU_ITEM:"menuitem",MENU_ITEM_CHECKBOX:"menuitemcheckbox",MENU_ITEM_RADIO:"menuitemradio",NAVIGATION:"navigation",NOTE:"note",OPTION:"option",PRESENTATION:"presentation",PROGRESSBAR:"progressbar",RADIO:"radio",RADIOGROUP:"radiogroup",REGION:"region",ROW:"row",ROWGROUP:"rowgroup",ROWHEADER:"rowheader",SCROLLBAR:"scrollbar",SEARCH:"search",SEPARATOR:"separator",SLIDER:"slider",SPINBUTTON:"spinbutton",STATUS:"status",TAB:"tab",
+TAB_LIST:"tablist",TAB_PANEL:"tabpanel",TEXTBOX:"textbox",TEXTINFO:"textinfo",TIMER:"timer",TOOLBAR:"toolbar",TOOLTIP:"tooltip",TREE:"tree",TREEGRID:"treegrid",TREEITEM:"treeitem"};goog.a11y.aria.State={ACTIVEDESCENDANT:"activedescendant",ATOMIC:"atomic",AUTOCOMPLETE:"autocomplete",BUSY:"busy",CHECKED:"checked",COLINDEX:"colindex",CONTROLS:"controls",DESCRIBEDBY:"describedby",DISABLED:"disabled",DROPEFFECT:"dropeffect",EXPANDED:"expanded",FLOWTO:"flowto",GRABBED:"grabbed",HASPOPUP:"haspopup",HIDDEN:"hidden",INVALID:"invalid",LABEL:"label",LABELLEDBY:"labelledby",LEVEL:"level",LIVE:"live",MULTILINE:"multiline",MULTISELECTABLE:"multiselectable",ORIENTATION:"orientation",OWNS:"owns",
+POSINSET:"posinset",PRESSED:"pressed",READONLY:"readonly",RELEVANT:"relevant",REQUIRED:"required",ROWINDEX:"rowindex",SELECTED:"selected",SETSIZE:"setsize",SORT:"sort",VALUEMAX:"valuemax",VALUEMIN:"valuemin",VALUENOW:"valuenow",VALUETEXT:"valuetext"};goog.a11y.aria.AutoCompleteValues={INLINE:"inline",LIST:"list",BOTH:"both",NONE:"none"};goog.a11y.aria.DropEffectValues={COPY:"copy",MOVE:"move",LINK:"link",EXECUTE:"execute",POPUP:"popup",NONE:"none"};
+goog.a11y.aria.LivePriority={OFF:"off",POLITE:"polite",ASSERTIVE:"assertive"};goog.a11y.aria.OrientationValues={VERTICAL:"vertical",HORIZONTAL:"horizontal"};goog.a11y.aria.RelevantValues={ADDITIONS:"additions",REMOVALS:"removals",TEXT:"text",ALL:"all"};goog.a11y.aria.SortValues={ASCENDING:"ascending",DESCENDING:"descending",NONE:"none",OTHER:"other"};goog.a11y.aria.CheckedValues={TRUE:"true",FALSE:"false",MIXED:"mixed",UNDEFINED:"undefined"};
+goog.a11y.aria.ExpandedValues={TRUE:"true",FALSE:"false",UNDEFINED:"undefined"};goog.a11y.aria.GrabbedValues={TRUE:"true",FALSE:"false",UNDEFINED:"undefined"};goog.a11y.aria.InvalidValues={FALSE:"false",TRUE:"true",GRAMMAR:"grammar",SPELLING:"spelling"};goog.a11y.aria.PressedValues={TRUE:"true",FALSE:"false",MIXED:"mixed",UNDEFINED:"undefined"};goog.a11y.aria.SelectedValues={TRUE:"true",FALSE:"false",UNDEFINED:"undefined"};goog.a11y.aria.datatables={};
+goog.a11y.aria.datatables.getDefaultValuesMap=function(){goog.a11y.aria.DefaultStateValueMap_||(goog.a11y.aria.DefaultStateValueMap_=goog.object.create(goog.a11y.aria.State.ATOMIC,!1,goog.a11y.aria.State.AUTOCOMPLETE,"none",goog.a11y.aria.State.DROPEFFECT,"none",goog.a11y.aria.State.HASPOPUP,!1,goog.a11y.aria.State.LIVE,"off",goog.a11y.aria.State.MULTILINE,!1,goog.a11y.aria.State.MULTISELECTABLE,!1,goog.a11y.aria.State.ORIENTATION,"vertical",goog.a11y.aria.State.READONLY,!1,goog.a11y.aria.State.RELEVANT,
+"additions text",goog.a11y.aria.State.REQUIRED,!1,goog.a11y.aria.State.SORT,"none",goog.a11y.aria.State.BUSY,!1,goog.a11y.aria.State.DISABLED,!1,goog.a11y.aria.State.HIDDEN,!1,goog.a11y.aria.State.INVALID,"false"));return goog.a11y.aria.DefaultStateValueMap_};goog.a11y.aria.ARIA_PREFIX_="aria-";goog.a11y.aria.ROLE_ATTRIBUTE_="role";goog.a11y.aria.TAGS_WITH_ASSUMED_ROLES_=goog.object.createSet("A AREA BUTTON HEAD INPUT LINK MENU META OPTGROUP OPTION PROGRESS STYLE SELECT SOURCE TEXTAREA TITLE TRACK".split(" "));
+goog.a11y.aria.CONTAINER_ROLES_=[goog.a11y.aria.Role.COMBOBOX,goog.a11y.aria.Role.GRID,goog.a11y.aria.Role.GROUP,goog.a11y.aria.Role.LISTBOX,goog.a11y.aria.Role.MENU,goog.a11y.aria.Role.MENUBAR,goog.a11y.aria.Role.RADIOGROUP,goog.a11y.aria.Role.ROW,goog.a11y.aria.Role.ROWGROUP,goog.a11y.aria.Role.TAB_LIST,goog.a11y.aria.Role.TEXTBOX,goog.a11y.aria.Role.TOOLBAR,goog.a11y.aria.Role.TREE,goog.a11y.aria.Role.TREEGRID];
+goog.a11y.aria.setRole=function(a,b){b?(goog.asserts.ENABLE_ASSERTS&&goog.asserts.assert(goog.object.containsValue(goog.a11y.aria.Role,b),"No such ARIA role "+b),a.setAttribute(goog.a11y.aria.ROLE_ATTRIBUTE_,b)):goog.a11y.aria.removeRole(a)};goog.a11y.aria.getRole=function(a){return a.getAttribute(goog.a11y.aria.ROLE_ATTRIBUTE_)||null};goog.a11y.aria.removeRole=function(a){a.removeAttribute(goog.a11y.aria.ROLE_ATTRIBUTE_)};
+goog.a11y.aria.setState=function(a,b,c){goog.isArray(c)&&(c=c.join(" "));var d=goog.a11y.aria.getAriaAttributeName_(b);""===c||void 0==c?(c=goog.a11y.aria.datatables.getDefaultValuesMap(),b in c?a.setAttribute(d,c[b]):a.removeAttribute(d)):a.setAttribute(d,c)};goog.a11y.aria.toggleState=function(a,b){var c=goog.a11y.aria.getState(a,b);goog.string.isEmptyOrWhitespace(goog.string.makeSafe(c))||"true"==c||"false"==c?goog.a11y.aria.setState(a,b,"true"==c?"false":"true"):goog.a11y.aria.removeState(a,b)};
+goog.a11y.aria.removeState=function(a,b){a.removeAttribute(goog.a11y.aria.getAriaAttributeName_(b))};goog.a11y.aria.getState=function(a,b){var c=a.getAttribute(goog.a11y.aria.getAriaAttributeName_(b));return null==c||void 0==c?"":String(c)};goog.a11y.aria.getActiveDescendant=function(a){var b=goog.a11y.aria.getState(a,goog.a11y.aria.State.ACTIVEDESCENDANT);return goog.dom.getOwnerDocument(a).getElementById(b)};
+goog.a11y.aria.setActiveDescendant=function(a,b){var c="";b&&(c=b.id,goog.asserts.assert(c,"The active element should have an id."));goog.a11y.aria.setState(a,goog.a11y.aria.State.ACTIVEDESCENDANT,c)};goog.a11y.aria.getLabel=function(a){return goog.a11y.aria.getState(a,goog.a11y.aria.State.LABEL)};goog.a11y.aria.setLabel=function(a,b){goog.a11y.aria.setState(a,goog.a11y.aria.State.LABEL,b)};
+goog.a11y.aria.assertRoleIsSetInternalUtil=function(a,b){if(!goog.a11y.aria.TAGS_WITH_ASSUMED_ROLES_[a.tagName]){var c=goog.a11y.aria.getRole(a);goog.asserts.assert(null!=c,"The element ARIA role cannot be null.");goog.asserts.assert(goog.array.contains(b,c),'Non existing or incorrect role set for element.The role set is "'+c+'". The role should be any of "'+b+'". Check the ARIA specification for more details http://www.w3.org/TR/wai-aria/roles.')}};
+goog.a11y.aria.getStateBoolean=function(a,b){var c=a.getAttribute(goog.a11y.aria.getAriaAttributeName_(b));goog.asserts.assert(goog.isBoolean(c)||null==c||"true"==c||"false"==c);return null==c?c:goog.isBoolean(c)?c:"true"==c};goog.a11y.aria.getStateNumber=function(a,b){var c=a.getAttribute(goog.a11y.aria.getAriaAttributeName_(b));goog.asserts.assert((null==c||!isNaN(Number(c)))&&!goog.isBoolean(c));return null==c?null:Number(c)};
+goog.a11y.aria.getStateString=function(a,b){var c=a.getAttribute(goog.a11y.aria.getAriaAttributeName_(b));goog.asserts.assert((null==c||goog.isString(c))&&(""==c||isNaN(Number(c)))&&"true"!=c&&"false"!=c);return null==c||""==c?null:c};goog.a11y.aria.getStringArrayStateInternalUtil=function(a,b){var c=a.getAttribute(goog.a11y.aria.getAriaAttributeName_(b));return goog.a11y.aria.splitStringOnWhitespace_(c)};goog.a11y.aria.hasState=function(a,b){return a.hasAttribute(goog.a11y.aria.getAriaAttributeName_(b))};
+goog.a11y.aria.isContainerRole=function(a){a=goog.a11y.aria.getRole(a);return goog.array.contains(goog.a11y.aria.CONTAINER_ROLES_,a)};goog.a11y.aria.splitStringOnWhitespace_=function(a){return a?a.split(/\s+/):[]};goog.a11y.aria.getAriaAttributeName_=function(a){goog.asserts.ENABLE_ASSERTS&&(goog.asserts.assert(a,"ARIA attribute cannot be empty."),goog.asserts.assert(goog.object.containsValue(goog.a11y.aria.State,a),"No such ARIA attribute "+a));return goog.a11y.aria.ARIA_PREFIX_+a};goog.events.KeyCodes={WIN_KEY_FF_LINUX:0,MAC_ENTER:3,BACKSPACE:8,TAB:9,NUM_CENTER:12,ENTER:13,SHIFT:16,CTRL:17,ALT:18,PAUSE:19,CAPS_LOCK:20,ESC:27,SPACE:32,PAGE_UP:33,PAGE_DOWN:34,END:35,HOME:36,LEFT:37,UP:38,RIGHT:39,DOWN:40,PLUS_SIGN:43,PRINT_SCREEN:44,INSERT:45,DELETE:46,ZERO:48,ONE:49,TWO:50,THREE:51,FOUR:52,FIVE:53,SIX:54,SEVEN:55,EIGHT:56,NINE:57,FF_SEMICOLON:59,FF_EQUALS:61,FF_DASH:173,FF_HASH:163,QUESTION_MARK:63,AT_SIGN:64,A:65,B:66,C:67,D:68,E:69,F:70,G:71,H:72,I:73,J:74,K:75,L:76,M:77,
+N:78,O:79,P:80,Q:81,R:82,S:83,T:84,U:85,V:86,W:87,X:88,Y:89,Z:90,META:91,WIN_KEY_RIGHT:92,CONTEXT_MENU:93,NUM_ZERO:96,NUM_ONE:97,NUM_TWO:98,NUM_THREE:99,NUM_FOUR:100,NUM_FIVE:101,NUM_SIX:102,NUM_SEVEN:103,NUM_EIGHT:104,NUM_NINE:105,NUM_MULTIPLY:106,NUM_PLUS:107,NUM_MINUS:109,NUM_PERIOD:110,NUM_DIVISION:111,F1:112,F2:113,F3:114,F4:115,F5:116,F6:117,F7:118,F8:119,F9:120,F10:121,F11:122,F12:123,NUMLOCK:144,SCROLL_LOCK:145,FIRST_MEDIA_KEY:166,LAST_MEDIA_KEY:183,SEMICOLON:186,DASH:189,EQUALS:187,COMMA:188,
+PERIOD:190,SLASH:191,APOSTROPHE:192,TILDE:192,SINGLE_QUOTE:222,OPEN_SQUARE_BRACKET:219,BACKSLASH:220,CLOSE_SQUARE_BRACKET:221,WIN_KEY:224,MAC_FF_META:224,MAC_WK_CMD_LEFT:91,MAC_WK_CMD_RIGHT:93,WIN_IME:229,VK_NONAME:252,PHANTOM:255};
+goog.events.KeyCodes.isTextModifyingKeyEvent=function(a){if(a.altKey&&!a.ctrlKey||a.metaKey||a.keyCode>=goog.events.KeyCodes.F1&&a.keyCode<=goog.events.KeyCodes.F12)return!1;switch(a.keyCode){case goog.events.KeyCodes.ALT:case goog.events.KeyCodes.CAPS_LOCK:case goog.events.KeyCodes.CONTEXT_MENU:case goog.events.KeyCodes.CTRL:case goog.events.KeyCodes.DOWN:case goog.events.KeyCodes.END:case goog.events.KeyCodes.ESC:case goog.events.KeyCodes.HOME:case goog.events.KeyCodes.INSERT:case goog.events.KeyCodes.LEFT:case goog.events.KeyCodes.MAC_FF_META:case goog.events.KeyCodes.META:case goog.events.KeyCodes.NUMLOCK:case goog.events.KeyCodes.NUM_CENTER:case goog.events.KeyCodes.PAGE_DOWN:case goog.events.KeyCodes.PAGE_UP:case goog.events.KeyCodes.PAUSE:case goog.events.KeyCodes.PHANTOM:case goog.events.KeyCodes.PRINT_SCREEN:case goog.events.KeyCodes.RIGHT:case goog.events.KeyCodes.SCROLL_LOCK:case goog.events.KeyCodes.SHIFT:case goog.events.KeyCodes.UP:case goog.events.KeyCodes.VK_NONAME:case goog.events.KeyCodes.WIN_KEY:case goog.events.KeyCodes.WIN_KEY_RIGHT:return!1;case goog.events.KeyCodes.WIN_KEY_FF_LINUX:return!goog.userAgent.GECKO;
+default:return a.keyCode<goog.events.KeyCodes.FIRST_MEDIA_KEY||a.keyCode>goog.events.KeyCodes.LAST_MEDIA_KEY}};
+goog.events.KeyCodes.firesKeyPressEvent=function(a,b,c,d,e,f){if(goog.userAgent.WEBKIT&&!goog.userAgent.isVersionOrHigher("525"))return!0;if(goog.userAgent.MAC&&e)return goog.events.KeyCodes.isCharacterKey(a);if(e&&!d)return!1;if(!goog.userAgent.GECKO){goog.isNumber(b)&&(b=goog.events.KeyCodes.normalizeKeyCode(b));var g=b==goog.events.KeyCodes.CTRL||b==goog.events.KeyCodes.ALT||goog.userAgent.MAC&&b==goog.events.KeyCodes.META,h=b==goog.events.KeyCodes.SHIFT&&(d||f);if((!c||goog.userAgent.MAC)&&g||
+goog.userAgent.MAC&&h)return!1}if((goog.userAgent.WEBKIT||goog.userAgent.EDGE)&&d&&c)switch(a){case goog.events.KeyCodes.BACKSLASH:case goog.events.KeyCodes.OPEN_SQUARE_BRACKET:case goog.events.KeyCodes.CLOSE_SQUARE_BRACKET:case goog.events.KeyCodes.TILDE:case goog.events.KeyCodes.SEMICOLON:case goog.events.KeyCodes.DASH:case goog.events.KeyCodes.EQUALS:case goog.events.KeyCodes.COMMA:case goog.events.KeyCodes.PERIOD:case goog.events.KeyCodes.SLASH:case goog.events.KeyCodes.APOSTROPHE:case goog.events.KeyCodes.SINGLE_QUOTE:return!1}if(goog.userAgent.IE&&
+d&&b==a)return!1;switch(a){case goog.events.KeyCodes.ENTER:return goog.userAgent.GECKO?f||e?!1:!(c&&d):!0;case goog.events.KeyCodes.ESC:return!(goog.userAgent.WEBKIT||goog.userAgent.EDGE||goog.userAgent.GECKO)}return goog.userAgent.GECKO&&(d||e||f)?!1:goog.events.KeyCodes.isCharacterKey(a)};
+goog.events.KeyCodes.isCharacterKey=function(a){if(a>=goog.events.KeyCodes.ZERO&&a<=goog.events.KeyCodes.NINE||a>=goog.events.KeyCodes.NUM_ZERO&&a<=goog.events.KeyCodes.NUM_MULTIPLY||a>=goog.events.KeyCodes.A&&a<=goog.events.KeyCodes.Z||(goog.userAgent.WEBKIT||goog.userAgent.EDGE)&&0==a)return!0;switch(a){case goog.events.KeyCodes.SPACE:case goog.events.KeyCodes.PLUS_SIGN:case goog.events.KeyCodes.QUESTION_MARK:case goog.events.KeyCodes.AT_SIGN:case goog.events.KeyCodes.NUM_PLUS:case goog.events.KeyCodes.NUM_MINUS:case goog.events.KeyCodes.NUM_PERIOD:case goog.events.KeyCodes.NUM_DIVISION:case goog.events.KeyCodes.SEMICOLON:case goog.events.KeyCodes.FF_SEMICOLON:case goog.events.KeyCodes.DASH:case goog.events.KeyCodes.EQUALS:case goog.events.KeyCodes.FF_EQUALS:case goog.events.KeyCodes.COMMA:case goog.events.KeyCodes.PERIOD:case goog.events.KeyCodes.SLASH:case goog.events.KeyCodes.APOSTROPHE:case goog.events.KeyCodes.SINGLE_QUOTE:case goog.events.KeyCodes.OPEN_SQUARE_BRACKET:case goog.events.KeyCodes.BACKSLASH:case goog.events.KeyCodes.CLOSE_SQUARE_BRACKET:case goog.events.KeyCodes.FF_HASH:return!0;
+default:return!1}};goog.events.KeyCodes.normalizeKeyCode=function(a){return goog.userAgent.GECKO?goog.events.KeyCodes.normalizeGeckoKeyCode(a):goog.userAgent.MAC&&goog.userAgent.WEBKIT?goog.events.KeyCodes.normalizeMacWebKitKeyCode(a):a};
+goog.events.KeyCodes.normalizeGeckoKeyCode=function(a){switch(a){case goog.events.KeyCodes.FF_EQUALS:return goog.events.KeyCodes.EQUALS;case goog.events.KeyCodes.FF_SEMICOLON:return goog.events.KeyCodes.SEMICOLON;case goog.events.KeyCodes.FF_DASH:return goog.events.KeyCodes.DASH;case goog.events.KeyCodes.MAC_FF_META:return goog.events.KeyCodes.META;case goog.events.KeyCodes.WIN_KEY_FF_LINUX:return goog.events.KeyCodes.WIN_KEY;default:return a}};
+goog.events.KeyCodes.normalizeMacWebKitKeyCode=function(a){switch(a){case goog.events.KeyCodes.MAC_WK_CMD_RIGHT:return goog.events.KeyCodes.META;default:return a}};goog.events.KeyHandler=function(a,b){goog.events.EventTarget.call(this);a&&this.attach(a,b)};goog.inherits(goog.events.KeyHandler,goog.events.EventTarget);goog.events.KeyHandler.prototype.element_=null;goog.events.KeyHandler.prototype.keyPressKey_=null;goog.events.KeyHandler.prototype.keyDownKey_=null;goog.events.KeyHandler.prototype.keyUpKey_=null;goog.events.KeyHandler.prototype.lastKey_=-1;goog.events.KeyHandler.prototype.keyCode_=-1;goog.events.KeyHandler.prototype.altKey_=!1;
+goog.events.KeyHandler.EventType={KEY:"key"};
+goog.events.KeyHandler.safariKey_={3:goog.events.KeyCodes.ENTER,12:goog.events.KeyCodes.NUMLOCK,63232:goog.events.KeyCodes.UP,63233:goog.events.KeyCodes.DOWN,63234:goog.events.KeyCodes.LEFT,63235:goog.events.KeyCodes.RIGHT,63236:goog.events.KeyCodes.F1,63237:goog.events.KeyCodes.F2,63238:goog.events.KeyCodes.F3,63239:goog.events.KeyCodes.F4,63240:goog.events.KeyCodes.F5,63241:goog.events.KeyCodes.F6,63242:goog.events.KeyCodes.F7,63243:goog.events.KeyCodes.F8,63244:goog.events.KeyCodes.F9,63245:goog.events.KeyCodes.F10,
+63246:goog.events.KeyCodes.F11,63247:goog.events.KeyCodes.F12,63248:goog.events.KeyCodes.PRINT_SCREEN,63272:goog.events.KeyCodes.DELETE,63273:goog.events.KeyCodes.HOME,63275:goog.events.KeyCodes.END,63276:goog.events.KeyCodes.PAGE_UP,63277:goog.events.KeyCodes.PAGE_DOWN,63289:goog.events.KeyCodes.NUMLOCK,63302:goog.events.KeyCodes.INSERT};
+goog.events.KeyHandler.keyIdentifier_={Up:goog.events.KeyCodes.UP,Down:goog.events.KeyCodes.DOWN,Left:goog.events.KeyCodes.LEFT,Right:goog.events.KeyCodes.RIGHT,Enter:goog.events.KeyCodes.ENTER,F1:goog.events.KeyCodes.F1,F2:goog.events.KeyCodes.F2,F3:goog.events.KeyCodes.F3,F4:goog.events.KeyCodes.F4,F5:goog.events.KeyCodes.F5,F6:goog.events.KeyCodes.F6,F7:goog.events.KeyCodes.F7,F8:goog.events.KeyCodes.F8,F9:goog.events.KeyCodes.F9,F10:goog.events.KeyCodes.F10,F11:goog.events.KeyCodes.F11,F12:goog.events.KeyCodes.F12,
+"U+007F":goog.events.KeyCodes.DELETE,Home:goog.events.KeyCodes.HOME,End:goog.events.KeyCodes.END,PageUp:goog.events.KeyCodes.PAGE_UP,PageDown:goog.events.KeyCodes.PAGE_DOWN,Insert:goog.events.KeyCodes.INSERT};goog.events.KeyHandler.USES_KEYDOWN_=!goog.userAgent.WEBKIT||goog.userAgent.isVersionOrHigher("525");goog.events.KeyHandler.SAVE_ALT_FOR_KEYPRESS_=goog.userAgent.MAC&&goog.userAgent.GECKO;
+goog.events.KeyHandler.prototype.handleKeyDown_=function(a){(goog.userAgent.WEBKIT||goog.userAgent.EDGE)&&(this.lastKey_==goog.events.KeyCodes.CTRL&&!a.ctrlKey||this.lastKey_==goog.events.KeyCodes.ALT&&!a.altKey||goog.userAgent.MAC&&this.lastKey_==goog.events.KeyCodes.META&&!a.metaKey)&&this.resetState();-1==this.lastKey_&&(a.ctrlKey&&a.keyCode!=goog.events.KeyCodes.CTRL?this.lastKey_=goog.events.KeyCodes.CTRL:a.altKey&&a.keyCode!=goog.events.KeyCodes.ALT?this.lastKey_=goog.events.KeyCodes.ALT:a.metaKey&&
+a.keyCode!=goog.events.KeyCodes.META&&(this.lastKey_=goog.events.KeyCodes.META));goog.events.KeyHandler.USES_KEYDOWN_&&!goog.events.KeyCodes.firesKeyPressEvent(a.keyCode,this.lastKey_,a.shiftKey,a.ctrlKey,a.altKey,a.metaKey)?this.handleEvent(a):(this.keyCode_=goog.events.KeyCodes.normalizeKeyCode(a.keyCode),goog.events.KeyHandler.SAVE_ALT_FOR_KEYPRESS_&&(this.altKey_=a.altKey))};goog.events.KeyHandler.prototype.resetState=function(){this.keyCode_=this.lastKey_=-1};
+goog.events.KeyHandler.prototype.handleKeyup_=function(a){this.resetState();this.altKey_=a.altKey};
+goog.events.KeyHandler.prototype.handleEvent=function(a){var b=a.getBrowserEvent(),c=b.altKey;if(goog.userAgent.IE&&a.type==goog.events.EventType.KEYPRESS){var d=this.keyCode_;var e=d!=goog.events.KeyCodes.ENTER&&d!=goog.events.KeyCodes.ESC?b.keyCode:0}else(goog.userAgent.WEBKIT||goog.userAgent.EDGE)&&a.type==goog.events.EventType.KEYPRESS?(d=this.keyCode_,e=0<=b.charCode&&63232>b.charCode&&goog.events.KeyCodes.isCharacterKey(d)?b.charCode:0):goog.userAgent.OPERA&&!goog.userAgent.WEBKIT?(d=this.keyCode_,
+e=goog.events.KeyCodes.isCharacterKey(d)?b.keyCode:0):(a.type==goog.events.EventType.KEYPRESS?(goog.events.KeyHandler.SAVE_ALT_FOR_KEYPRESS_&&(c=this.altKey_),b.keyCode==b.charCode?32>b.keyCode?(d=b.keyCode,e=0):(d=this.keyCode_,e=b.charCode):(d=b.keyCode||this.keyCode_,e=b.charCode||0)):(d=b.keyCode||this.keyCode_,e=b.charCode||0),goog.userAgent.MAC&&e==goog.events.KeyCodes.QUESTION_MARK&&d==goog.events.KeyCodes.WIN_KEY&&(d=goog.events.KeyCodes.SLASH));var f=d=goog.events.KeyCodes.normalizeKeyCode(d);
+d?63232<=d&&d in goog.events.KeyHandler.safariKey_?f=goog.events.KeyHandler.safariKey_[d]:25==d&&a.shiftKey&&(f=9):b.keyIdentifier&&b.keyIdentifier in goog.events.KeyHandler.keyIdentifier_&&(f=goog.events.KeyHandler.keyIdentifier_[b.keyIdentifier]);goog.userAgent.GECKO&&goog.events.KeyHandler.USES_KEYDOWN_&&a.type==goog.events.EventType.KEYPRESS&&!goog.events.KeyCodes.firesKeyPressEvent(f,this.lastKey_,a.shiftKey,a.ctrlKey,c,a.metaKey)||(a=f==this.lastKey_,this.lastKey_=f,b=new goog.events.KeyEvent(f,
+e,a,b),b.altKey=c,this.dispatchEvent(b))};goog.events.KeyHandler.prototype.getElement=function(){return this.element_};
+goog.events.KeyHandler.prototype.attach=function(a,b){this.keyUpKey_&&this.detach();this.element_=a;this.keyPressKey_=goog.events.listen(this.element_,goog.events.EventType.KEYPRESS,this,b);this.keyDownKey_=goog.events.listen(this.element_,goog.events.EventType.KEYDOWN,this.handleKeyDown_,b,this);this.keyUpKey_=goog.events.listen(this.element_,goog.events.EventType.KEYUP,this.handleKeyup_,b,this)};
+goog.events.KeyHandler.prototype.detach=function(){this.keyPressKey_&&(goog.events.unlistenByKey(this.keyPressKey_),goog.events.unlistenByKey(this.keyDownKey_),goog.events.unlistenByKey(this.keyUpKey_),this.keyUpKey_=this.keyDownKey_=this.keyPressKey_=null);this.element_=null;this.keyCode_=this.lastKey_=-1};goog.events.KeyHandler.prototype.disposeInternal=function(){goog.events.KeyHandler.superClass_.disposeInternal.call(this);this.detach()};
+goog.events.KeyEvent=function(a,b,c,d){goog.events.BrowserEvent.call(this,d);this.type=goog.events.KeyHandler.EventType.KEY;this.keyCode=a;this.charCode=b;this.repeat=c};goog.inherits(goog.events.KeyEvent,goog.events.BrowserEvent);goog.ui.ComponentUtil={};goog.ui.ComponentUtil.getMouseEventType=function(a){return a.pointerEventsEnabled()?goog.events.PointerAsMouseEventType:goog.events.MouseAsMouseEventType};goog.dom.classlist={};goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST=!1;goog.dom.classlist.get=function(a){if(goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST||a.classList)return a.classList;a=a.className;return goog.isString(a)&&a.match(/\S+/g)||[]};goog.dom.classlist.set=function(a,b){a.className=b};goog.dom.classlist.contains=function(a,b){return goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST||a.classList?a.classList.contains(b):goog.array.contains(goog.dom.classlist.get(a),b)};
+goog.dom.classlist.add=function(a,b){goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST||a.classList?a.classList.add(b):goog.dom.classlist.contains(a,b)||(a.className+=0<a.className.length?" "+b:b)};
+goog.dom.classlist.addAll=function(a,b){if(goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST||a.classList)goog.array.forEach(b,function(b){goog.dom.classlist.add(a,b)});else{var c={};goog.array.forEach(goog.dom.classlist.get(a),function(a){c[a]=!0});goog.array.forEach(b,function(a){c[a]=!0});a.className="";for(var d in c)a.className+=0<a.className.length?" "+d:d}};
+goog.dom.classlist.remove=function(a,b){goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST||a.classList?a.classList.remove(b):goog.dom.classlist.contains(a,b)&&(a.className=goog.array.filter(goog.dom.classlist.get(a),function(a){return a!=b}).join(" "))};
+goog.dom.classlist.removeAll=function(a,b){goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST||a.classList?goog.array.forEach(b,function(b){goog.dom.classlist.remove(a,b)}):a.className=goog.array.filter(goog.dom.classlist.get(a),function(a){return!goog.array.contains(b,a)}).join(" ")};goog.dom.classlist.enable=function(a,b,c){c?goog.dom.classlist.add(a,b):goog.dom.classlist.remove(a,b)};goog.dom.classlist.enableAll=function(a,b,c){(c?goog.dom.classlist.addAll:goog.dom.classlist.removeAll)(a,b)};
+goog.dom.classlist.swap=function(a,b,c){return goog.dom.classlist.contains(a,b)?(goog.dom.classlist.remove(a,b),goog.dom.classlist.add(a,c),!0):!1};goog.dom.classlist.toggle=function(a,b){var c=!goog.dom.classlist.contains(a,b);goog.dom.classlist.enable(a,b,c);return c};goog.dom.classlist.addRemove=function(a,b,c){goog.dom.classlist.remove(a,b);goog.dom.classlist.add(a,c)};goog.ui.registry={};goog.ui.registry.getDefaultRenderer=function(a){for(var b;a;){b=goog.getUid(a);if(b=goog.ui.registry.defaultRenderers_[b])break;a=a.superClass_?a.superClass_.constructor:null}return b?goog.isFunction(b.getInstance)?b.getInstance():new b:null};
+goog.ui.registry.setDefaultRenderer=function(a,b){if(!goog.isFunction(a))throw Error("Invalid component class "+a);if(!goog.isFunction(b))throw Error("Invalid renderer class "+b);var c=goog.getUid(a);goog.ui.registry.defaultRenderers_[c]=b};goog.ui.registry.getDecoratorByClassName=function(a){return a in goog.ui.registry.decoratorFunctions_?goog.ui.registry.decoratorFunctions_[a]():null};
+goog.ui.registry.setDecoratorByClassName=function(a,b){if(!a)throw Error("Invalid class name "+a);if(!goog.isFunction(b))throw Error("Invalid decorator function "+b);goog.ui.registry.decoratorFunctions_[a]=b};goog.ui.registry.getDecorator=function(a){goog.asserts.assert(a);for(var b=goog.dom.classlist.get(a),c=0,d=b.length;c<d;c++)if(a=goog.ui.registry.getDecoratorByClassName(b[c]))return a;return null};
+goog.ui.registry.reset=function(){goog.ui.registry.defaultRenderers_={};goog.ui.registry.decoratorFunctions_={}};goog.ui.registry.defaultRenderers_={};goog.ui.registry.decoratorFunctions_={};goog.ui.ContainerRenderer=function(a){this.ariaRole_=a};goog.addSingletonGetter(goog.ui.ContainerRenderer);goog.ui.ContainerRenderer.getCustomRenderer=function(a,b){var c=new a;c.getCssClass=function(){return b};return c};goog.ui.ContainerRenderer.CSS_CLASS="goog-container";goog.ui.ContainerRenderer.prototype.getAriaRole=function(){return this.ariaRole_};goog.ui.ContainerRenderer.prototype.enableTabIndex=function(a,b){a&&(a.tabIndex=b?0:-1)};
+goog.ui.ContainerRenderer.prototype.createDom=function(a){return a.getDomHelper().createDom("DIV",this.getClassNames(a).join(" "))};goog.ui.ContainerRenderer.prototype.getContentElement=function(a){return a};goog.ui.ContainerRenderer.prototype.canDecorate=function(a){return"DIV"==a.tagName};
+goog.ui.ContainerRenderer.prototype.decorate=function(a,b){b.id&&a.setId(b.id);var c=this.getCssClass(),d=!1,e=goog.dom.classlist.get(b);e&&goog.array.forEach(e,function(b){b==c?d=!0:b&&this.setStateFromClassName(a,b,c)},this);d||goog.dom.classlist.add(b,c);this.decorateChildren(a,this.getContentElement(b));return b};
+goog.ui.ContainerRenderer.prototype.setStateFromClassName=function(a,b,c){b==c+"-disabled"?a.setEnabled(!1):b==c+"-horizontal"?a.setOrientation(goog.ui.Container.Orientation.HORIZONTAL):b==c+"-vertical"&&a.setOrientation(goog.ui.Container.Orientation.VERTICAL)};
+goog.ui.ContainerRenderer.prototype.decorateChildren=function(a,b,c){if(b){c=c||b.firstChild;for(var d;c&&c.parentNode==b;){d=c.nextSibling;if(c.nodeType==goog.dom.NodeType.ELEMENT){var e=this.getDecoratorForChild(c);e&&(e.setElementInternal(c),a.isEnabled()||e.setEnabled(!1),a.addChild(e),e.decorate(c))}else c.nodeValue&&""!=goog.string.trim(c.nodeValue)||b.removeChild(c);c=d}}};goog.ui.ContainerRenderer.prototype.getDecoratorForChild=function(a){return goog.ui.registry.getDecorator(a)};
+goog.ui.ContainerRenderer.prototype.initializeDom=function(a){a=a.getElement();goog.asserts.assert(a,"The container DOM element cannot be null.");goog.style.setUnselectable(a,!0,goog.userAgent.GECKO);goog.userAgent.IE&&(a.hideFocus=!0);var b=this.getAriaRole();b&&goog.a11y.aria.setRole(a,b)};goog.ui.ContainerRenderer.prototype.getKeyEventTarget=function(a){return a.getElement()};goog.ui.ContainerRenderer.prototype.getCssClass=function(){return goog.ui.ContainerRenderer.CSS_CLASS};
+goog.ui.ContainerRenderer.prototype.getClassNames=function(a){var b=this.getCssClass(),c=a.getOrientation()==goog.ui.Container.Orientation.HORIZONTAL;c=[b,c?b+"-horizontal":b+"-vertical"];a.isEnabled()||c.push(b+"-disabled");return c};goog.ui.ContainerRenderer.prototype.getDefaultOrientation=function(){return goog.ui.Container.Orientation.VERTICAL};goog.ui.ControlRenderer=function(){};goog.addSingletonGetter(goog.ui.ControlRenderer);goog.tagUnsealableClass(goog.ui.ControlRenderer);goog.ui.ControlRenderer.getCustomRenderer=function(a,b){var c=new a;c.getCssClass=function(){return b};return c};goog.ui.ControlRenderer.CSS_CLASS="goog-control";goog.ui.ControlRenderer.IE6_CLASS_COMBINATIONS=[];
+goog.ui.ControlRenderer.TOGGLE_ARIA_STATE_MAP_=goog.object.create(goog.a11y.aria.Role.BUTTON,goog.a11y.aria.State.PRESSED,goog.a11y.aria.Role.CHECKBOX,goog.a11y.aria.State.CHECKED,goog.a11y.aria.Role.MENU_ITEM,goog.a11y.aria.State.SELECTED,goog.a11y.aria.Role.MENU_ITEM_CHECKBOX,goog.a11y.aria.State.CHECKED,goog.a11y.aria.Role.MENU_ITEM_RADIO,goog.a11y.aria.State.CHECKED,goog.a11y.aria.Role.RADIO,goog.a11y.aria.State.CHECKED,goog.a11y.aria.Role.TAB,goog.a11y.aria.State.SELECTED,goog.a11y.aria.Role.TREEITEM,
+goog.a11y.aria.State.SELECTED);goog.ui.ControlRenderer.prototype.getAriaRole=function(){};goog.ui.ControlRenderer.prototype.createDom=function(a){return a.getDomHelper().createDom("DIV",this.getClassNames(a).join(" "),a.getContent())};goog.ui.ControlRenderer.prototype.getContentElement=function(a){return a};
+goog.ui.ControlRenderer.prototype.enableClassName=function(a,b,c){if(a=a.getElement?a.getElement():a){var d=[b];goog.userAgent.IE&&!goog.userAgent.isVersionOrHigher("7")&&(d=this.getAppliedCombinedClassNames_(goog.dom.classlist.get(a),b),d.push(b));goog.dom.classlist.enableAll(a,d,c)}};goog.ui.ControlRenderer.prototype.enableExtraClassName=function(a,b,c){this.enableClassName(a,b,c)};goog.ui.ControlRenderer.prototype.canDecorate=function(a){return!0};
+goog.ui.ControlRenderer.prototype.decorate=function(a,b){b.id&&a.setId(b.id);var c=this.getContentElement(b);c&&c.firstChild?a.setContentInternal(c.firstChild.nextSibling?goog.array.clone(c.childNodes):c.firstChild):a.setContentInternal(null);var d=0,e=this.getCssClass(),f=this.getStructuralCssClass(),g=!1,h=!1,k=!1,l=goog.array.toArray(goog.dom.classlist.get(b));goog.array.forEach(l,function(a){g||a!=e?h||a!=f?d|=this.getStateFromClass(a):h=!0:(g=!0,f==e&&(h=!0));this.getStateFromClass(a)==goog.ui.Component.State.DISABLED&&
+(goog.asserts.assertElement(c),goog.dom.isFocusableTabIndex(c)&&goog.dom.setFocusableTabIndex(c,!1))},this);a.setStateInternal(d);g||(l.push(e),f==e&&(h=!0));h||l.push(f);var n=a.getExtraClassNames();n&&l.push.apply(l,n);if(goog.userAgent.IE&&!goog.userAgent.isVersionOrHigher("7")){var m=this.getAppliedCombinedClassNames_(l);0<m.length&&(l.push.apply(l,m),k=!0)}g&&h&&!n&&!k||goog.dom.classlist.set(b,l.join(" "));return b};
+goog.ui.ControlRenderer.prototype.initializeDom=function(a){a.isRightToLeft()&&this.setRightToLeft(a.getElement(),!0);a.isEnabled()&&this.setFocusable(a,a.isVisible())};goog.ui.ControlRenderer.prototype.setAriaRole=function(a,b){var c=b||this.getAriaRole();if(c){goog.asserts.assert(a,"The element passed as a first parameter cannot be null.");var d=goog.a11y.aria.getRole(a);c!=d&&goog.a11y.aria.setRole(a,c)}};
+goog.ui.ControlRenderer.prototype.setAriaStates=function(a,b){goog.asserts.assert(a);goog.asserts.assert(b);var c=a.getAriaLabel();goog.isDefAndNotNull(c)&&this.setAriaLabel(b,c);a.isVisible()||goog.a11y.aria.setState(b,goog.a11y.aria.State.HIDDEN,!a.isVisible());a.isEnabled()||this.updateAriaState(b,goog.ui.Component.State.DISABLED,!a.isEnabled());a.isSupportedState(goog.ui.Component.State.SELECTED)&&this.updateAriaState(b,goog.ui.Component.State.SELECTED,a.isSelected());a.isSupportedState(goog.ui.Component.State.CHECKED)&&
+this.updateAriaState(b,goog.ui.Component.State.CHECKED,a.isChecked());a.isSupportedState(goog.ui.Component.State.OPENED)&&this.updateAriaState(b,goog.ui.Component.State.OPENED,a.isOpen())};goog.ui.ControlRenderer.prototype.setAriaLabel=function(a,b){goog.a11y.aria.setLabel(a,b)};goog.ui.ControlRenderer.prototype.setAllowTextSelection=function(a,b){goog.style.setUnselectable(a,!b,!goog.userAgent.IE&&!goog.userAgent.OPERA)};
+goog.ui.ControlRenderer.prototype.setRightToLeft=function(a,b){this.enableClassName(a,this.getStructuralCssClass()+"-rtl",b)};goog.ui.ControlRenderer.prototype.isFocusable=function(a){var b;return a.isSupportedState(goog.ui.Component.State.FOCUSED)&&(b=a.getKeyEventTarget())?goog.dom.isFocusableTabIndex(b):!1};
+goog.ui.ControlRenderer.prototype.setFocusable=function(a,b){var c;if(a.isSupportedState(goog.ui.Component.State.FOCUSED)&&(c=a.getKeyEventTarget())){if(!b&&a.isFocused()){try{c.blur()}catch(d){}a.isFocused()&&a.handleBlur(null)}goog.dom.isFocusableTabIndex(c)!=b&&goog.dom.setFocusableTabIndex(c,b)}};goog.ui.ControlRenderer.prototype.setVisible=function(a,b){goog.style.setElementShown(a,b);a&&goog.a11y.aria.setState(a,goog.a11y.aria.State.HIDDEN,!b)};
+goog.ui.ControlRenderer.prototype.setState=function(a,b,c){var d=a.getElement();if(d){var e=this.getClassForState(b);e&&this.enableClassName(a,e,c);this.updateAriaState(d,b,c)}};
+goog.ui.ControlRenderer.prototype.updateAriaState=function(a,b,c){goog.ui.ControlRenderer.ariaAttributeMap_||(goog.ui.ControlRenderer.ariaAttributeMap_=goog.object.create(goog.ui.Component.State.DISABLED,goog.a11y.aria.State.DISABLED,goog.ui.Component.State.SELECTED,goog.a11y.aria.State.SELECTED,goog.ui.Component.State.CHECKED,goog.a11y.aria.State.CHECKED,goog.ui.Component.State.OPENED,goog.a11y.aria.State.EXPANDED));goog.asserts.assert(a,"The element passed as a first parameter cannot be null.");
+(b=goog.ui.ControlRenderer.getAriaStateForAriaRole_(a,goog.ui.ControlRenderer.ariaAttributeMap_[b]))&&goog.a11y.aria.setState(a,b,c)};goog.ui.ControlRenderer.getAriaStateForAriaRole_=function(a,b){var c=goog.a11y.aria.getRole(a);if(!c)return b;c=goog.ui.ControlRenderer.TOGGLE_ARIA_STATE_MAP_[c]||b;return goog.ui.ControlRenderer.isAriaState_(b)?c:b};goog.ui.ControlRenderer.isAriaState_=function(a){return a==goog.a11y.aria.State.CHECKED||a==goog.a11y.aria.State.SELECTED};
+goog.ui.ControlRenderer.prototype.setContent=function(a,b){var c=this.getContentElement(a);if(c&&(goog.dom.removeChildren(c),b))if(goog.isString(b))goog.dom.setTextContent(c,b);else{var d=function(a){if(a){var b=goog.dom.getOwnerDocument(c);c.appendChild(goog.isString(a)?b.createTextNode(a):a)}};goog.isArray(b)?goog.array.forEach(b,d):!goog.isArrayLike(b)||"nodeType"in b?d(b):goog.array.forEach(goog.array.clone(b),d)}};goog.ui.ControlRenderer.prototype.getKeyEventTarget=function(a){return a.getElement()};
+goog.ui.ControlRenderer.prototype.getCssClass=function(){return goog.ui.ControlRenderer.CSS_CLASS};goog.ui.ControlRenderer.prototype.getIe6ClassCombinations=function(){return[]};goog.ui.ControlRenderer.prototype.getStructuralCssClass=function(){return this.getCssClass()};
+goog.ui.ControlRenderer.prototype.getClassNames=function(a){var b=this.getCssClass(),c=[b],d=this.getStructuralCssClass();d!=b&&c.push(d);b=this.getClassNamesForState(a.getState());c.push.apply(c,b);(a=a.getExtraClassNames())&&c.push.apply(c,a);goog.userAgent.IE&&!goog.userAgent.isVersionOrHigher("7")&&c.push.apply(c,this.getAppliedCombinedClassNames_(c));return c};
+goog.ui.ControlRenderer.prototype.getAppliedCombinedClassNames_=function(a,b){var c=[];b&&(a=goog.array.concat(a,[b]));goog.array.forEach(this.getIe6ClassCombinations(),function(d){!goog.array.every(d,goog.partial(goog.array.contains,a))||b&&!goog.array.contains(d,b)||c.push(d.join("_"))});return c};goog.ui.ControlRenderer.prototype.getClassNamesForState=function(a){for(var b=[];a;){var c=a&-a;b.push(this.getClassForState(c));a&=~c}return b};
+goog.ui.ControlRenderer.prototype.getClassForState=function(a){this.classByState_||this.createClassByStateMap_();return this.classByState_[a]};goog.ui.ControlRenderer.prototype.getStateFromClass=function(a){this.stateByClass_||this.createStateByClassMap_();a=parseInt(this.stateByClass_[a],10);return isNaN(a)?0:a};
+goog.ui.ControlRenderer.prototype.createClassByStateMap_=function(){var a=this.getStructuralCssClass(),b=!goog.string.contains(goog.string.normalizeWhitespace(a)," ");goog.asserts.assert(b,"ControlRenderer has an invalid css class: '"+a+"'");this.classByState_=goog.object.create(goog.ui.Component.State.DISABLED,a+"-disabled",goog.ui.Component.State.HOVER,a+"-hover",goog.ui.Component.State.ACTIVE,a+"-active",goog.ui.Component.State.SELECTED,a+"-selected",goog.ui.Component.State.CHECKED,a+"-checked",
+goog.ui.Component.State.FOCUSED,a+"-focused",goog.ui.Component.State.OPENED,a+"-open")};goog.ui.ControlRenderer.prototype.createStateByClassMap_=function(){this.classByState_||this.createClassByStateMap_();this.stateByClass_=goog.object.transpose(this.classByState_)};goog.ui.Control=function(a,b,c){goog.ui.Component.call(this,c);this.renderer_=b||goog.ui.registry.getDefaultRenderer(this.constructor);this.setContentInternal(goog.isDef(a)?a:null);this.ariaLabel_=null};goog.inherits(goog.ui.Control,goog.ui.Component);goog.tagUnsealableClass(goog.ui.Control);goog.ui.Control.registerDecorator=goog.ui.registry.setDecoratorByClassName;goog.ui.Control.getDecorator=goog.ui.registry.getDecorator;goog.ui.Control.prototype.content_=null;goog.ui.Control.prototype.state_=0;
+goog.ui.Control.prototype.supportedStates_=goog.ui.Component.State.DISABLED|goog.ui.Component.State.HOVER|goog.ui.Component.State.ACTIVE|goog.ui.Component.State.FOCUSED;goog.ui.Control.prototype.autoStates_=goog.ui.Component.State.ALL;goog.ui.Control.prototype.statesWithTransitionEvents_=0;goog.ui.Control.prototype.visible_=!0;goog.ui.Control.prototype.extraClassNames_=null;goog.ui.Control.prototype.handleMouseEvents_=!0;goog.ui.Control.prototype.allowTextSelection_=!1;
+goog.ui.Control.prototype.preferredAriaRole_=null;goog.ui.Control.prototype.isHandleMouseEvents=function(){return this.handleMouseEvents_};goog.ui.Control.prototype.setHandleMouseEvents=function(a){this.isInDocument()&&a!=this.handleMouseEvents_&&this.enableMouseEventHandling_(a);this.handleMouseEvents_=a};goog.ui.Control.prototype.getKeyEventTarget=function(){return this.renderer_.getKeyEventTarget(this)};
+goog.ui.Control.prototype.getKeyHandler=function(){return this.keyHandler_||(this.keyHandler_=new goog.events.KeyHandler)};goog.ui.Control.prototype.getRenderer=function(){return this.renderer_};goog.ui.Control.prototype.setRenderer=function(a){if(this.isInDocument())throw Error(goog.ui.Component.Error.ALREADY_RENDERED);this.getElement()&&this.setElementInternal(null);this.renderer_=a};goog.ui.Control.prototype.getExtraClassNames=function(){return this.extraClassNames_};
+goog.ui.Control.prototype.addClassName=function(a){a&&(this.extraClassNames_?goog.array.contains(this.extraClassNames_,a)||this.extraClassNames_.push(a):this.extraClassNames_=[a],this.renderer_.enableExtraClassName(this,a,!0))};goog.ui.Control.prototype.removeClassName=function(a){a&&this.extraClassNames_&&goog.array.remove(this.extraClassNames_,a)&&(0==this.extraClassNames_.length&&(this.extraClassNames_=null),this.renderer_.enableExtraClassName(this,a,!1))};
+goog.ui.Control.prototype.enableClassName=function(a,b){b?this.addClassName(a):this.removeClassName(a)};goog.ui.Control.prototype.createDom=function(){var a=this.renderer_.createDom(this);this.setElementInternal(a);this.renderer_.setAriaRole(a,this.getPreferredAriaRole());this.isAllowTextSelection()||this.renderer_.setAllowTextSelection(a,!1);this.isVisible()||this.renderer_.setVisible(a,!1)};goog.ui.Control.prototype.getPreferredAriaRole=function(){return this.preferredAriaRole_};
+goog.ui.Control.prototype.setPreferredAriaRole=function(a){this.preferredAriaRole_=a};goog.ui.Control.prototype.getAriaLabel=function(){return this.ariaLabel_};goog.ui.Control.prototype.setAriaLabel=function(a){this.ariaLabel_=a;var b=this.getElement();b&&this.renderer_.setAriaLabel(b,a)};goog.ui.Control.prototype.getContentElement=function(){return this.renderer_.getContentElement(this.getElement())};goog.ui.Control.prototype.canDecorate=function(a){return this.renderer_.canDecorate(a)};
+goog.ui.Control.prototype.decorateInternal=function(a){a=this.renderer_.decorate(this,a);this.setElementInternal(a);this.renderer_.setAriaRole(a,this.getPreferredAriaRole());this.isAllowTextSelection()||this.renderer_.setAllowTextSelection(a,!1);this.visible_="none"!=a.style.display};
+goog.ui.Control.prototype.enterDocument=function(){goog.ui.Control.superClass_.enterDocument.call(this);this.renderer_.setAriaStates(this,this.getElementStrict());this.renderer_.initializeDom(this);if(this.supportedStates_&~goog.ui.Component.State.DISABLED&&(this.isHandleMouseEvents()&&this.enableMouseEventHandling_(!0),this.isSupportedState(goog.ui.Component.State.FOCUSED))){var a=this.getKeyEventTarget();if(a){var b=this.getKeyHandler();b.attach(a);this.getHandler().listen(b,goog.events.KeyHandler.EventType.KEY,
+this.handleKeyEvent).listen(a,goog.events.EventType.FOCUS,this.handleFocus).listen(a,goog.events.EventType.BLUR,this.handleBlur)}}};
+goog.ui.Control.prototype.enableMouseEventHandling_=function(a){var b=goog.ui.ComponentUtil.getMouseEventType(this),c=this.getHandler(),d=this.getElement();a?(c.listen(d,b.MOUSEDOWN,this.handleMouseDown).listen(d,[b.MOUSEUP,b.MOUSECANCEL],this.handleMouseUp).listen(d,goog.events.EventType.MOUSEOVER,this.handleMouseOver).listen(d,goog.events.EventType.MOUSEOUT,this.handleMouseOut),this.pointerEventsEnabled()&&c.listen(d,goog.events.EventType.GOTPOINTERCAPTURE,this.preventPointerCapture_),this.handleContextMenu!=
+goog.nullFunction&&c.listen(d,goog.events.EventType.CONTEXTMENU,this.handleContextMenu),goog.userAgent.IE&&(goog.userAgent.isVersionOrHigher(9)||c.listen(d,goog.events.EventType.DBLCLICK,this.handleDblClick),this.ieMouseEventSequenceSimulator_||(this.ieMouseEventSequenceSimulator_=new goog.ui.Control.IeMouseEventSequenceSimulator_(this),this.registerDisposable(this.ieMouseEventSequenceSimulator_)))):(c.unlisten(d,b.MOUSEDOWN,this.handleMouseDown).unlisten(d,[b.MOUSEUP,b.MOUSECANCEL],this.handleMouseUp).unlisten(d,
+goog.events.EventType.MOUSEOVER,this.handleMouseOver).unlisten(d,goog.events.EventType.MOUSEOUT,this.handleMouseOut),this.pointerEventsEnabled()&&c.unlisten(d,goog.events.EventType.GOTPOINTERCAPTURE,this.preventPointerCapture_),this.handleContextMenu!=goog.nullFunction&&c.unlisten(d,goog.events.EventType.CONTEXTMENU,this.handleContextMenu),goog.userAgent.IE&&(goog.userAgent.isVersionOrHigher(9)||c.unlisten(d,goog.events.EventType.DBLCLICK,this.handleDblClick),goog.dispose(this.ieMouseEventSequenceSimulator_),
+this.ieMouseEventSequenceSimulator_=null))};goog.ui.Control.prototype.exitDocument=function(){goog.ui.Control.superClass_.exitDocument.call(this);this.keyHandler_&&this.keyHandler_.detach();this.isVisible()&&this.isEnabled()&&this.renderer_.setFocusable(this,!1)};
+goog.ui.Control.prototype.disposeInternal=function(){goog.ui.Control.superClass_.disposeInternal.call(this);this.keyHandler_&&(this.keyHandler_.dispose(),delete this.keyHandler_);delete this.renderer_;this.ieMouseEventSequenceSimulator_=this.extraClassNames_=this.content_=null};goog.ui.Control.prototype.getContent=function(){return this.content_};goog.ui.Control.prototype.setContent=function(a){this.renderer_.setContent(this.getElement(),a);this.setContentInternal(a)};
+goog.ui.Control.prototype.setContentInternal=function(a){this.content_=a};goog.ui.Control.prototype.getCaption=function(){var a=this.getContent();if(!a)return"";a=goog.isString(a)?a:goog.isArray(a)?goog.array.map(a,goog.dom.getRawTextContent).join(""):goog.dom.getTextContent(a);return goog.string.collapseBreakingSpaces(a)};goog.ui.Control.prototype.setCaption=function(a){this.setContent(a)};
+goog.ui.Control.prototype.setRightToLeft=function(a){goog.ui.Control.superClass_.setRightToLeft.call(this,a);var b=this.getElement();b&&this.renderer_.setRightToLeft(b,a)};goog.ui.Control.prototype.isAllowTextSelection=function(){return this.allowTextSelection_};goog.ui.Control.prototype.setAllowTextSelection=function(a){this.allowTextSelection_=a;var b=this.getElement();b&&this.renderer_.setAllowTextSelection(b,a)};goog.ui.Control.prototype.isVisible=function(){return this.visible_};
+goog.ui.Control.prototype.setVisible=function(a,b){if(b||this.visible_!=a&&this.dispatchEvent(a?goog.ui.Component.EventType.SHOW:goog.ui.Component.EventType.HIDE)){var c=this.getElement();c&&this.renderer_.setVisible(c,a);this.isEnabled()&&this.renderer_.setFocusable(this,a);this.visible_=a;return!0}return!1};goog.ui.Control.prototype.isEnabled=function(){return!this.hasState(goog.ui.Component.State.DISABLED)};
+goog.ui.Control.prototype.isParentDisabled_=function(){var a=this.getParent();return!!a&&"function"==typeof a.isEnabled&&!a.isEnabled()};goog.ui.Control.prototype.setEnabled=function(a){!this.isParentDisabled_()&&this.isTransitionAllowed(goog.ui.Component.State.DISABLED,!a)&&(a||(this.setActive(!1),this.setHighlighted(!1)),this.isVisible()&&this.renderer_.setFocusable(this,a),this.setState(goog.ui.Component.State.DISABLED,!a,!0))};goog.ui.Control.prototype.isHighlighted=function(){return this.hasState(goog.ui.Component.State.HOVER)};
+goog.ui.Control.prototype.setHighlighted=function(a){this.isTransitionAllowed(goog.ui.Component.State.HOVER,a)&&this.setState(goog.ui.Component.State.HOVER,a)};goog.ui.Control.prototype.isActive=function(){return this.hasState(goog.ui.Component.State.ACTIVE)};goog.ui.Control.prototype.setActive=function(a){this.isTransitionAllowed(goog.ui.Component.State.ACTIVE,a)&&this.setState(goog.ui.Component.State.ACTIVE,a)};goog.ui.Control.prototype.isSelected=function(){return this.hasState(goog.ui.Component.State.SELECTED)};
+goog.ui.Control.prototype.setSelected=function(a){this.isTransitionAllowed(goog.ui.Component.State.SELECTED,a)&&this.setState(goog.ui.Component.State.SELECTED,a)};goog.ui.Control.prototype.isChecked=function(){return this.hasState(goog.ui.Component.State.CHECKED)};goog.ui.Control.prototype.setChecked=function(a){this.isTransitionAllowed(goog.ui.Component.State.CHECKED,a)&&this.setState(goog.ui.Component.State.CHECKED,a)};goog.ui.Control.prototype.isFocused=function(){return this.hasState(goog.ui.Component.State.FOCUSED)};
+goog.ui.Control.prototype.setFocused=function(a){this.isTransitionAllowed(goog.ui.Component.State.FOCUSED,a)&&this.setState(goog.ui.Component.State.FOCUSED,a)};goog.ui.Control.prototype.isOpen=function(){return this.hasState(goog.ui.Component.State.OPENED)};goog.ui.Control.prototype.setOpen=function(a){this.isTransitionAllowed(goog.ui.Component.State.OPENED,a)&&this.setState(goog.ui.Component.State.OPENED,a)};goog.ui.Control.prototype.getState=function(){return this.state_};
+goog.ui.Control.prototype.hasState=function(a){return!!(this.state_&a)};goog.ui.Control.prototype.setState=function(a,b,c){c||a!=goog.ui.Component.State.DISABLED?this.isSupportedState(a)&&b!=this.hasState(a)&&(this.renderer_.setState(this,a,b),this.state_=b?this.state_|a:this.state_&~a):this.setEnabled(!b)};goog.ui.Control.prototype.setStateInternal=function(a){this.state_=a};goog.ui.Control.prototype.isSupportedState=function(a){return!!(this.supportedStates_&a)};
+goog.ui.Control.prototype.setSupportedState=function(a,b){if(this.isInDocument()&&this.hasState(a)&&!b)throw Error(goog.ui.Component.Error.ALREADY_RENDERED);!b&&this.hasState(a)&&this.setState(a,!1);this.supportedStates_=b?this.supportedStates_|a:this.supportedStates_&~a};goog.ui.Control.prototype.isAutoState=function(a){return!!(this.autoStates_&a)&&this.isSupportedState(a)};goog.ui.Control.prototype.setAutoStates=function(a,b){this.autoStates_=b?this.autoStates_|a:this.autoStates_&~a};
+goog.ui.Control.prototype.isDispatchTransitionEvents=function(a){return!!(this.statesWithTransitionEvents_&a)&&this.isSupportedState(a)};goog.ui.Control.prototype.setDispatchTransitionEvents=function(a,b){this.statesWithTransitionEvents_=b?this.statesWithTransitionEvents_|a:this.statesWithTransitionEvents_&~a};
+goog.ui.Control.prototype.isTransitionAllowed=function(a,b){return this.isSupportedState(a)&&this.hasState(a)!=b&&(!(this.statesWithTransitionEvents_&a)||this.dispatchEvent(goog.ui.Component.getStateTransitionEvent(a,b)))&&!this.isDisposed()};goog.ui.Control.prototype.handleMouseOver=function(a){!goog.ui.Control.isMouseEventWithinElement_(a,this.getElement())&&this.dispatchEvent(goog.ui.Component.EventType.ENTER)&&this.isEnabled()&&this.isAutoState(goog.ui.Component.State.HOVER)&&this.setHighlighted(!0)};
+goog.ui.Control.prototype.handleMouseOut=function(a){!goog.ui.Control.isMouseEventWithinElement_(a,this.getElement())&&this.dispatchEvent(goog.ui.Component.EventType.LEAVE)&&(this.isAutoState(goog.ui.Component.State.ACTIVE)&&this.setActive(!1),this.isAutoState(goog.ui.Component.State.HOVER)&&this.setHighlighted(!1))};goog.ui.Control.prototype.preventPointerCapture_=function(a){var b=a.target;b.releasePointerCapture&&b.releasePointerCapture(a.pointerId)};
+goog.ui.Control.prototype.handleContextMenu=goog.nullFunction;goog.ui.Control.isMouseEventWithinElement_=function(a,b){return!!a.relatedTarget&&goog.dom.contains(b,a.relatedTarget)};
+goog.ui.Control.prototype.handleMouseDown=function(a){this.isEnabled()&&(this.isAutoState(goog.ui.Component.State.HOVER)&&this.setHighlighted(!0),a.isMouseActionButton()&&(this.isAutoState(goog.ui.Component.State.ACTIVE)&&this.setActive(!0),this.renderer_&&this.renderer_.isFocusable(this)&&this.getKeyEventTarget().focus()));!this.isAllowTextSelection()&&a.isMouseActionButton()&&a.preventDefault()};
+goog.ui.Control.prototype.handleMouseUp=function(a){this.isEnabled()&&(this.isAutoState(goog.ui.Component.State.HOVER)&&this.setHighlighted(!0),this.isActive()&&this.performActionInternal(a)&&this.isAutoState(goog.ui.Component.State.ACTIVE)&&this.setActive(!1))};goog.ui.Control.prototype.handleDblClick=function(a){this.isEnabled()&&this.performActionInternal(a)};
+goog.ui.Control.prototype.performActionInternal=function(a){this.isAutoState(goog.ui.Component.State.CHECKED)&&this.setChecked(!this.isChecked());this.isAutoState(goog.ui.Component.State.SELECTED)&&this.setSelected(!0);this.isAutoState(goog.ui.Component.State.OPENED)&&this.setOpen(!this.isOpen());var b=new goog.events.Event(goog.ui.Component.EventType.ACTION,this);a&&(b.altKey=a.altKey,b.ctrlKey=a.ctrlKey,b.metaKey=a.metaKey,b.shiftKey=a.shiftKey,b.platformModifierKey=a.platformModifierKey);return this.dispatchEvent(b)};
+goog.ui.Control.prototype.handleFocus=function(a){this.isAutoState(goog.ui.Component.State.FOCUSED)&&this.setFocused(!0)};goog.ui.Control.prototype.handleBlur=function(a){this.isAutoState(goog.ui.Component.State.ACTIVE)&&this.setActive(!1);this.isAutoState(goog.ui.Component.State.FOCUSED)&&this.setFocused(!1)};goog.ui.Control.prototype.handleKeyEvent=function(a){return this.isVisible()&&this.isEnabled()&&this.handleKeyEventInternal(a)?(a.preventDefault(),a.stopPropagation(),!0):!1};
+goog.ui.Control.prototype.handleKeyEventInternal=function(a){return a.keyCode==goog.events.KeyCodes.ENTER&&this.performActionInternal(a)};goog.ui.registry.setDefaultRenderer(goog.ui.Control,goog.ui.ControlRenderer);goog.ui.registry.setDecoratorByClassName(goog.ui.ControlRenderer.CSS_CLASS,function(){return new goog.ui.Control(null)});
+goog.ui.Control.IeMouseEventSequenceSimulator_=function(a){goog.Disposable.call(this);this.control_=a;this.clickExpected_=!1;this.handler_=new goog.events.EventHandler(this);this.registerDisposable(this.handler_);a=this.control_.getElementStrict();this.handler_.listen(a,goog.events.EventType.MOUSEDOWN,this.handleMouseDown_).listen(a,goog.events.EventType.MOUSEUP,this.handleMouseUp_).listen(a,goog.events.EventType.CLICK,this.handleClick_)};
+goog.inherits(goog.ui.Control.IeMouseEventSequenceSimulator_,goog.Disposable);goog.ui.Control.IeMouseEventSequenceSimulator_.SYNTHETIC_EVENTS_=!goog.userAgent.IE||goog.userAgent.isDocumentModeOrHigher(9);goog.ui.Control.IeMouseEventSequenceSimulator_.prototype.handleMouseDown_=function(){this.clickExpected_=!1};goog.ui.Control.IeMouseEventSequenceSimulator_.prototype.handleMouseUp_=function(){this.clickExpected_=!0};
+goog.ui.Control.IeMouseEventSequenceSimulator_.makeLeftMouseEvent_=function(a,b){if(!goog.ui.Control.IeMouseEventSequenceSimulator_.SYNTHETIC_EVENTS_)return a.button=goog.events.BrowserEvent.MouseButton.LEFT,a.type=b,a;var c=document.createEvent("MouseEvents");c.initMouseEvent(b,a.bubbles,a.cancelable,a.view||null,a.detail,a.screenX,a.screenY,a.clientX,a.clientY,a.ctrlKey,a.altKey,a.shiftKey,a.metaKey,goog.events.BrowserEvent.MouseButton.LEFT,a.relatedTarget||null);return c};
+goog.ui.Control.IeMouseEventSequenceSimulator_.prototype.handleClick_=function(a){if(this.clickExpected_)this.clickExpected_=!1;else{var b=a.getBrowserEvent(),c=b.button,d=b.type,e=goog.ui.Control.IeMouseEventSequenceSimulator_.makeLeftMouseEvent_(b,goog.events.EventType.MOUSEDOWN);this.control_.handleMouseDown(new goog.events.BrowserEvent(e,a.currentTarget));e=goog.ui.Control.IeMouseEventSequenceSimulator_.makeLeftMouseEvent_(b,goog.events.EventType.MOUSEUP);this.control_.handleMouseUp(new goog.events.BrowserEvent(e,
+a.currentTarget));goog.ui.Control.IeMouseEventSequenceSimulator_.SYNTHETIC_EVENTS_||(b.button=c,b.type=d)}};goog.ui.Control.IeMouseEventSequenceSimulator_.prototype.disposeInternal=function(){this.control_=null;goog.ui.Control.IeMouseEventSequenceSimulator_.superClass_.disposeInternal.call(this)};goog.ui.Container=function(a,b,c){goog.ui.Component.call(this,c);this.renderer_=b||goog.ui.ContainerRenderer.getInstance();this.orientation_=a||this.renderer_.getDefaultOrientation()};goog.inherits(goog.ui.Container,goog.ui.Component);goog.tagUnsealableClass(goog.ui.Container);goog.ui.Container.EventType={AFTER_SHOW:"aftershow",AFTER_HIDE:"afterhide"};goog.ui.Container.Orientation={HORIZONTAL:"horizontal",VERTICAL:"vertical"};goog.ui.Container.prototype.keyEventTarget_=null;
+goog.ui.Container.prototype.keyHandler_=null;goog.ui.Container.prototype.renderer_=null;goog.ui.Container.prototype.orientation_=null;goog.ui.Container.prototype.visible_=!0;goog.ui.Container.prototype.enabled_=!0;goog.ui.Container.prototype.focusable_=!0;goog.ui.Container.prototype.highlightedIndex_=-1;goog.ui.Container.prototype.openItem_=null;goog.ui.Container.prototype.mouseButtonPressed_=!1;goog.ui.Container.prototype.allowFocusableChildren_=!1;
+goog.ui.Container.prototype.openFollowsHighlight_=!0;goog.ui.Container.prototype.childElementIdMap_=null;goog.ui.Container.prototype.getKeyEventTarget=function(){return this.keyEventTarget_||this.renderer_.getKeyEventTarget(this)};
+goog.ui.Container.prototype.setKeyEventTarget=function(a){if(this.focusable_){var b=this.getKeyEventTarget(),c=this.isInDocument();this.keyEventTarget_=a;var d=this.getKeyEventTarget();c&&(this.keyEventTarget_=b,this.enableFocusHandling_(!1),this.keyEventTarget_=a,this.getKeyHandler().attach(d),this.enableFocusHandling_(!0))}else throw Error("Can't set key event target for container that doesn't support keyboard focus!");};
+goog.ui.Container.prototype.getKeyHandler=function(){return this.keyHandler_||(this.keyHandler_=new goog.events.KeyHandler(this.getKeyEventTarget()))};goog.ui.Container.prototype.getRenderer=function(){return this.renderer_};goog.ui.Container.prototype.setRenderer=function(a){if(this.getElement())throw Error(goog.ui.Component.Error.ALREADY_RENDERED);this.renderer_=a};goog.ui.Container.prototype.createDom=function(){this.setElementInternal(this.renderer_.createDom(this))};
+goog.ui.Container.prototype.getContentElement=function(){return this.renderer_.getContentElement(this.getElement())};goog.ui.Container.prototype.canDecorate=function(a){return this.renderer_.canDecorate(a)};goog.ui.Container.prototype.decorateInternal=function(a){this.setElementInternal(this.renderer_.decorate(this,a));"none"==a.style.display&&(this.visible_=!1)};
+goog.ui.Container.prototype.enterDocument=function(){goog.ui.Container.superClass_.enterDocument.call(this);this.forEachChild(function(a){a.isInDocument()&&this.registerChildId_(a)},this);var a=this.getElement();this.renderer_.initializeDom(this);this.setVisible(this.visible_,!0);var b=goog.ui.ComponentUtil.getMouseEventType(this);this.getHandler().listen(this,goog.ui.Component.EventType.ENTER,this.handleEnterItem).listen(this,goog.ui.Component.EventType.HIGHLIGHT,this.handleHighlightItem).listen(this,
+goog.ui.Component.EventType.UNHIGHLIGHT,this.handleUnHighlightItem).listen(this,goog.ui.Component.EventType.OPEN,this.handleOpenItem).listen(this,goog.ui.Component.EventType.CLOSE,this.handleCloseItem).listen(a,b.MOUSEDOWN,this.handleMouseDown).listen(goog.dom.getOwnerDocument(a),[b.MOUSEUP,b.MOUSECANCEL],this.handleDocumentMouseUp).listen(a,[b.MOUSEDOWN,b.MOUSEUP,b.MOUSECANCEL,goog.events.EventType.MOUSEOVER,goog.events.EventType.MOUSEOUT,goog.events.EventType.CONTEXTMENU],this.handleChildMouseEvents);
+this.pointerEventsEnabled()&&this.getHandler().listen(a,goog.events.EventType.GOTPOINTERCAPTURE,this.preventPointerCapture_);this.isFocusable()&&this.enableFocusHandling_(!0)};goog.ui.Container.prototype.preventPointerCapture_=function(a){var b=a.target;b.releasePointerCapture&&b.releasePointerCapture(a.pointerId)};
+goog.ui.Container.prototype.enableFocusHandling_=function(a){var b=this.getHandler(),c=this.getKeyEventTarget();a?b.listen(c,goog.events.EventType.FOCUS,this.handleFocus).listen(c,goog.events.EventType.BLUR,this.handleBlur).listen(this.getKeyHandler(),goog.events.KeyHandler.EventType.KEY,this.handleKeyEvent):b.unlisten(c,goog.events.EventType.FOCUS,this.handleFocus).unlisten(c,goog.events.EventType.BLUR,this.handleBlur).unlisten(this.getKeyHandler(),goog.events.KeyHandler.EventType.KEY,this.handleKeyEvent)};
+goog.ui.Container.prototype.exitDocument=function(){this.setHighlightedIndex(-1);this.openItem_&&this.openItem_.setOpen(!1);this.mouseButtonPressed_=!1;goog.ui.Container.superClass_.exitDocument.call(this)};goog.ui.Container.prototype.disposeInternal=function(){goog.ui.Container.superClass_.disposeInternal.call(this);this.keyHandler_&&(this.keyHandler_.dispose(),this.keyHandler_=null);this.renderer_=this.openItem_=this.childElementIdMap_=this.keyEventTarget_=null};
+goog.ui.Container.prototype.handleEnterItem=function(a){return!0};
+goog.ui.Container.prototype.handleHighlightItem=function(a){var b=this.indexOfChild(a.target);if(-1<b&&b!=this.highlightedIndex_){var c=this.getHighlighted();c&&c.setHighlighted(!1);this.highlightedIndex_=b;c=this.getHighlighted();this.isMouseButtonPressed()&&c.setActive(!0);this.openFollowsHighlight_&&this.openItem_&&c!=this.openItem_&&(c.isSupportedState(goog.ui.Component.State.OPENED)?c.setOpen(!0):this.openItem_.setOpen(!1))}b=this.getElement();goog.asserts.assert(b,"The DOM element for the container cannot be null.");
+null!=a.target.getElement()&&goog.a11y.aria.setState(b,goog.a11y.aria.State.ACTIVEDESCENDANT,a.target.getElement().id)};goog.ui.Container.prototype.handleUnHighlightItem=function(a){a.target==this.getHighlighted()&&(this.highlightedIndex_=-1);a=this.getElement();goog.asserts.assert(a,"The DOM element for the container cannot be null.");goog.a11y.aria.removeState(a,goog.a11y.aria.State.ACTIVEDESCENDANT)};
+goog.ui.Container.prototype.handleOpenItem=function(a){(a=a.target)&&a!=this.openItem_&&a.getParent()==this&&(this.openItem_&&this.openItem_.setOpen(!1),this.openItem_=a)};goog.ui.Container.prototype.handleCloseItem=function(a){a.target==this.openItem_&&(this.openItem_=null);var b=this.getElement(),c=a.target.getElement();b&&a.target.isHighlighted()&&c&&goog.a11y.aria.setActiveDescendant(b,c)};
+goog.ui.Container.prototype.handleMouseDown=function(a){this.enabled_&&this.setMouseButtonPressed(!0);var b=this.getKeyEventTarget();b&&goog.dom.isFocusableTabIndex(b)?b.focus():a.preventDefault()};goog.ui.Container.prototype.handleDocumentMouseUp=function(a){this.setMouseButtonPressed(!1)};
+goog.ui.Container.prototype.handleChildMouseEvents=function(a){var b=goog.ui.ComponentUtil.getMouseEventType(this),c=this.getOwnerControl(a.target);if(c)switch(a.type){case b.MOUSEDOWN:c.handleMouseDown(a);break;case b.MOUSEUP:case b.MOUSECANCEL:c.handleMouseUp(a);break;case goog.events.EventType.MOUSEOVER:c.handleMouseOver(a);break;case goog.events.EventType.MOUSEOUT:c.handleMouseOut(a);break;case goog.events.EventType.CONTEXTMENU:c.handleContextMenu(a)}};
+goog.ui.Container.prototype.getOwnerControl=function(a){if(this.childElementIdMap_)for(var b=this.getElement();a&&a!==b;){var c=a.id;if(c in this.childElementIdMap_)return this.childElementIdMap_[c];a=a.parentNode}return null};goog.ui.Container.prototype.handleFocus=function(a){};goog.ui.Container.prototype.handleBlur=function(a){this.setHighlightedIndex(-1);this.setMouseButtonPressed(!1);this.openItem_&&this.openItem_.setOpen(!1)};
+goog.ui.Container.prototype.handleKeyEvent=function(a){return this.isEnabled()&&this.isVisible()&&(0!=this.getChildCount()||this.keyEventTarget_)&&this.handleKeyEventInternal(a)?(a.preventDefault(),a.stopPropagation(),!0):!1};
+goog.ui.Container.prototype.handleKeyEventInternal=function(a){var b=this.getHighlighted();if(b&&"function"==typeof b.handleKeyEvent&&b.handleKeyEvent(a)||this.openItem_&&this.openItem_!=b&&"function"==typeof this.openItem_.handleKeyEvent&&this.openItem_.handleKeyEvent(a))return!0;if(a.shiftKey||a.ctrlKey||a.metaKey||a.altKey)return!1;switch(a.keyCode){case goog.events.KeyCodes.ESC:if(this.isFocusable())this.getKeyEventTarget().blur();else return!1;break;case goog.events.KeyCodes.HOME:this.highlightFirst();
+break;case goog.events.KeyCodes.END:this.highlightLast();break;case goog.events.KeyCodes.UP:if(this.orientation_==goog.ui.Container.Orientation.VERTICAL)this.highlightPrevious();else return!1;break;case goog.events.KeyCodes.LEFT:if(this.orientation_==goog.ui.Container.Orientation.HORIZONTAL)this.isRightToLeft()?this.highlightNext():this.highlightPrevious();else return!1;break;case goog.events.KeyCodes.DOWN:if(this.orientation_==goog.ui.Container.Orientation.VERTICAL)this.highlightNext();else return!1;
+break;case goog.events.KeyCodes.RIGHT:if(this.orientation_==goog.ui.Container.Orientation.HORIZONTAL)this.isRightToLeft()?this.highlightPrevious():this.highlightNext();else return!1;break;default:return!1}return!0};goog.ui.Container.prototype.registerChildId_=function(a){var b=a.getElement();b=b.id||(b.id=a.getId());this.childElementIdMap_||(this.childElementIdMap_={});this.childElementIdMap_[b]=a};
+goog.ui.Container.prototype.addChild=function(a,b){goog.asserts.assertInstanceof(a,goog.ui.Control,"The child of a container must be a control");goog.ui.Container.superClass_.addChild.call(this,a,b)};
+goog.ui.Container.prototype.addChildAt=function(a,b,c){goog.asserts.assertInstanceof(a,goog.ui.Control);a.setDispatchTransitionEvents(goog.ui.Component.State.HOVER,!0);a.setDispatchTransitionEvents(goog.ui.Component.State.OPENED,!0);!this.isFocusable()&&this.isFocusableChildrenAllowed()||a.setSupportedState(goog.ui.Component.State.FOCUSED,!1);a.setHandleMouseEvents(!1);var d=a.getParent()==this?this.indexOfChild(a):-1;goog.ui.Container.superClass_.addChildAt.call(this,a,b,c);a.isInDocument()&&this.isInDocument()&&
+this.registerChildId_(a);this.updateHighlightedIndex_(d,b)};goog.ui.Container.prototype.updateHighlightedIndex_=function(a,b){-1==a&&(a=this.getChildCount());a==this.highlightedIndex_?this.highlightedIndex_=Math.min(this.getChildCount()-1,b):a>this.highlightedIndex_&&b<=this.highlightedIndex_?this.highlightedIndex_++:a<this.highlightedIndex_&&b>this.highlightedIndex_&&this.highlightedIndex_--};
+goog.ui.Container.prototype.removeChild=function(a,b){a=goog.isString(a)?this.getChild(a):a;goog.asserts.assertInstanceof(a,goog.ui.Control);if(a){var c=this.indexOfChild(a);-1!=c&&(c==this.highlightedIndex_?(a.setHighlighted(!1),this.highlightedIndex_=-1):c<this.highlightedIndex_&&this.highlightedIndex_--);(c=a.getElement())&&c.id&&this.childElementIdMap_&&goog.object.remove(this.childElementIdMap_,c.id)}a=goog.ui.Container.superClass_.removeChild.call(this,a,b);a.setHandleMouseEvents(!0);return a};
+goog.ui.Container.prototype.getOrientation=function(){return this.orientation_};goog.ui.Container.prototype.setOrientation=function(a){if(this.getElement())throw Error(goog.ui.Component.Error.ALREADY_RENDERED);this.orientation_=a};goog.ui.Container.prototype.isVisible=function(){return this.visible_};
+goog.ui.Container.prototype.setVisible=function(a,b){if(b||this.visible_!=a&&this.dispatchEvent(a?goog.ui.Component.EventType.SHOW:goog.ui.Component.EventType.HIDE)){this.visible_=a;var c=this.getElement();c&&(goog.style.setElementShown(c,a),this.isFocusable()&&this.renderer_.enableTabIndex(this.getKeyEventTarget(),this.enabled_&&this.visible_),b||this.dispatchEvent(this.visible_?goog.ui.Container.EventType.AFTER_SHOW:goog.ui.Container.EventType.AFTER_HIDE));return!0}return!1};
+goog.ui.Container.prototype.isEnabled=function(){return this.enabled_};
+goog.ui.Container.prototype.setEnabled=function(a){this.enabled_!=a&&this.dispatchEvent(a?goog.ui.Component.EventType.ENABLE:goog.ui.Component.EventType.DISABLE)&&(a?(this.enabled_=!0,this.forEachChild(function(a){a.wasDisabled?delete a.wasDisabled:a.setEnabled(!0)})):(this.forEachChild(function(a){a.isEnabled()?a.setEnabled(!1):a.wasDisabled=!0}),this.enabled_=!1,this.setMouseButtonPressed(!1)),this.isFocusable()&&this.renderer_.enableTabIndex(this.getKeyEventTarget(),a&&this.visible_))};
+goog.ui.Container.prototype.isFocusable=function(){return this.focusable_};goog.ui.Container.prototype.setFocusable=function(a){a!=this.focusable_&&this.isInDocument()&&this.enableFocusHandling_(a);this.focusable_=a;this.enabled_&&this.visible_&&this.renderer_.enableTabIndex(this.getKeyEventTarget(),a)};goog.ui.Container.prototype.isFocusableChildrenAllowed=function(){return this.allowFocusableChildren_};
+goog.ui.Container.prototype.setFocusableChildrenAllowed=function(a){this.allowFocusableChildren_=a};goog.ui.Container.prototype.isOpenFollowsHighlight=function(){return this.openFollowsHighlight_};goog.ui.Container.prototype.setOpenFollowsHighlight=function(a){this.openFollowsHighlight_=a};goog.ui.Container.prototype.getHighlightedIndex=function(){return this.highlightedIndex_};
+goog.ui.Container.prototype.setHighlightedIndex=function(a){(a=this.getChildAt(a))?a.setHighlighted(!0):-1<this.highlightedIndex_&&this.getHighlighted().setHighlighted(!1)};goog.ui.Container.prototype.setHighlighted=function(a){this.setHighlightedIndex(this.indexOfChild(a))};goog.ui.Container.prototype.getHighlighted=function(){return this.getChildAt(this.highlightedIndex_)};
+goog.ui.Container.prototype.highlightFirst=function(){this.highlightHelper(function(a,b){return(a+1)%b},this.getChildCount()-1)};goog.ui.Container.prototype.highlightLast=function(){this.highlightHelper(function(a,b){a--;return 0>a?b-1:a},0)};goog.ui.Container.prototype.highlightNext=function(){this.highlightHelper(function(a,b){return(a+1)%b},this.highlightedIndex_)};goog.ui.Container.prototype.highlightPrevious=function(){this.highlightHelper(function(a,b){a--;return 0>a?b-1:a},this.highlightedIndex_)};
+goog.ui.Container.prototype.highlightHelper=function(a,b){var c=0>b?this.indexOfChild(this.openItem_):b,d=this.getChildCount();c=a.call(this,c,d);for(var e=0;e<=d;){var f=this.getChildAt(c);if(f&&this.canHighlightItem(f))return this.setHighlightedIndexFromKeyEvent(c),!0;e++;c=a.call(this,c,d)}return!1};goog.ui.Container.prototype.canHighlightItem=function(a){return a.isVisible()&&a.isEnabled()&&a.isSupportedState(goog.ui.Component.State.HOVER)};
+goog.ui.Container.prototype.setHighlightedIndexFromKeyEvent=function(a){this.setHighlightedIndex(a)};goog.ui.Container.prototype.getOpenItem=function(){return this.openItem_};goog.ui.Container.prototype.isMouseButtonPressed=function(){return this.mouseButtonPressed_};goog.ui.Container.prototype.setMouseButtonPressed=function(a){this.mouseButtonPressed_=a};goog.ui.MenuHeaderRenderer=function(){goog.ui.ControlRenderer.call(this)};goog.inherits(goog.ui.MenuHeaderRenderer,goog.ui.ControlRenderer);goog.addSingletonGetter(goog.ui.MenuHeaderRenderer);goog.ui.MenuHeaderRenderer.CSS_CLASS="goog-menuheader";goog.ui.MenuHeaderRenderer.prototype.getCssClass=function(){return goog.ui.MenuHeaderRenderer.CSS_CLASS};goog.ui.MenuHeader=function(a,b,c){goog.ui.Control.call(this,a,c||goog.ui.MenuHeaderRenderer.getInstance(),b);this.setSupportedState(goog.ui.Component.State.DISABLED,!1);this.setSupportedState(goog.ui.Component.State.HOVER,!1);this.setSupportedState(goog.ui.Component.State.ACTIVE,!1);this.setSupportedState(goog.ui.Component.State.FOCUSED,!1);this.setStateInternal(goog.ui.Component.State.DISABLED)};goog.inherits(goog.ui.MenuHeader,goog.ui.Control);
+goog.ui.registry.setDecoratorByClassName(goog.ui.MenuHeaderRenderer.CSS_CLASS,function(){return new goog.ui.MenuHeader(null)});goog.ui.MenuItemRenderer=function(){goog.ui.ControlRenderer.call(this);this.classNameCache_=[]};goog.inherits(goog.ui.MenuItemRenderer,goog.ui.ControlRenderer);goog.addSingletonGetter(goog.ui.MenuItemRenderer);goog.ui.MenuItemRenderer.CSS_CLASS="goog-menuitem";goog.ui.MenuItemRenderer.CompositeCssClassIndex_={HOVER:0,CHECKBOX:1,CONTENT:2};
+goog.ui.MenuItemRenderer.prototype.getCompositeCssClass_=function(a){var b=this.classNameCache_[a];if(!b){switch(a){case goog.ui.MenuItemRenderer.CompositeCssClassIndex_.HOVER:b=this.getStructuralCssClass()+"-highlight";break;case goog.ui.MenuItemRenderer.CompositeCssClassIndex_.CHECKBOX:b=this.getStructuralCssClass()+"-checkbox";break;case goog.ui.MenuItemRenderer.CompositeCssClassIndex_.CONTENT:b=this.getStructuralCssClass()+"-content"}this.classNameCache_[a]=b}return b};
+goog.ui.MenuItemRenderer.prototype.getAriaRole=function(){return goog.a11y.aria.Role.MENU_ITEM};goog.ui.MenuItemRenderer.prototype.createDom=function(a){var b=a.getDomHelper().createDom("DIV",this.getClassNames(a).join(" "),this.createContent(a.getContent(),a.getDomHelper()));this.setEnableCheckBoxStructure(a,b,a.isSupportedState(goog.ui.Component.State.SELECTED)||a.isSupportedState(goog.ui.Component.State.CHECKED));return b};
+goog.ui.MenuItemRenderer.prototype.getContentElement=function(a){return a&&a.firstChild};goog.ui.MenuItemRenderer.prototype.decorate=function(a,b){goog.asserts.assert(b);this.hasContentStructure(b)||b.appendChild(this.createContent(b.childNodes,a.getDomHelper()));goog.dom.classlist.contains(b,"goog-option")&&(a.setCheckable(!0),this.setCheckable(a,b,!0));return goog.ui.MenuItemRenderer.superClass_.decorate.call(this,a,b)};
+goog.ui.MenuItemRenderer.prototype.setContent=function(a,b){var c=this.getContentElement(a),d=this.hasCheckBoxStructure(a)?c.firstChild:null;goog.ui.MenuItemRenderer.superClass_.setContent.call(this,a,b);d&&!this.hasCheckBoxStructure(a)&&c.insertBefore(d,c.firstChild||null)};
+goog.ui.MenuItemRenderer.prototype.hasContentStructure=function(a){a=goog.dom.getFirstElementChild(a);var b=this.getCompositeCssClass_(goog.ui.MenuItemRenderer.CompositeCssClassIndex_.CONTENT);return!!a&&goog.dom.classlist.contains(a,b)};goog.ui.MenuItemRenderer.prototype.createContent=function(a,b){var c=this.getCompositeCssClass_(goog.ui.MenuItemRenderer.CompositeCssClassIndex_.CONTENT);return b.createDom("DIV",c,a)};
+goog.ui.MenuItemRenderer.prototype.setSelectable=function(a,b,c){a&&b&&this.setEnableCheckBoxStructure(a,b,c)};goog.ui.MenuItemRenderer.prototype.setCheckable=function(a,b,c){a&&b&&this.setEnableCheckBoxStructure(a,b,c)};goog.ui.MenuItemRenderer.prototype.hasCheckBoxStructure=function(a){if(a=this.getContentElement(a)){a=a.firstChild;var b=this.getCompositeCssClass_(goog.ui.MenuItemRenderer.CompositeCssClassIndex_.CHECKBOX);return!!a&&goog.dom.isElement(a)&&goog.dom.classlist.contains(a,b)}return!1};
+goog.ui.MenuItemRenderer.prototype.setEnableCheckBoxStructure=function(a,b,c){this.setAriaRole(b,a.getPreferredAriaRole());this.setAriaStates(a,b);c!=this.hasCheckBoxStructure(b)&&(goog.dom.classlist.enable(b,"goog-option",c),b=this.getContentElement(b),c?(c=this.getCompositeCssClass_(goog.ui.MenuItemRenderer.CompositeCssClassIndex_.CHECKBOX),b.insertBefore(a.getDomHelper().createDom("DIV",c),b.firstChild||null)):b.removeChild(b.firstChild))};
+goog.ui.MenuItemRenderer.prototype.getClassForState=function(a){switch(a){case goog.ui.Component.State.HOVER:return this.getCompositeCssClass_(goog.ui.MenuItemRenderer.CompositeCssClassIndex_.HOVER);case goog.ui.Component.State.CHECKED:case goog.ui.Component.State.SELECTED:return"goog-option-selected";default:return goog.ui.MenuItemRenderer.superClass_.getClassForState.call(this,a)}};
+goog.ui.MenuItemRenderer.prototype.getStateFromClass=function(a){var b=this.getCompositeCssClass_(goog.ui.MenuItemRenderer.CompositeCssClassIndex_.HOVER);switch(a){case "goog-option-selected":return goog.ui.Component.State.CHECKED;case b:return goog.ui.Component.State.HOVER;default:return goog.ui.MenuItemRenderer.superClass_.getStateFromClass.call(this,a)}};goog.ui.MenuItemRenderer.prototype.getCssClass=function(){return goog.ui.MenuItemRenderer.CSS_CLASS};goog.ui.MenuItem=function(a,b,c,d){goog.ui.Control.call(this,a,d||goog.ui.MenuItemRenderer.getInstance(),c);this.setValue(b)};goog.inherits(goog.ui.MenuItem,goog.ui.Control);goog.tagUnsealableClass(goog.ui.MenuItem);goog.ui.MenuItem.MNEMONIC_WRAPPER_CLASS_="goog-menuitem-mnemonic-separator";goog.ui.MenuItem.ACCELERATOR_CLASS="goog-menuitem-accel";goog.ui.MenuItem.prototype.getValue=function(){var a=this.getModel();return null!=a?a:this.getCaption()};goog.ui.MenuItem.prototype.setValue=function(a){this.setModel(a)};
+goog.ui.MenuItem.prototype.setSupportedState=function(a,b){goog.ui.MenuItem.superClass_.setSupportedState.call(this,a,b);switch(a){case goog.ui.Component.State.SELECTED:this.setSelectableInternal_(b);break;case goog.ui.Component.State.CHECKED:this.setCheckableInternal_(b)}};goog.ui.MenuItem.prototype.setSelectable=function(a){this.setSupportedState(goog.ui.Component.State.SELECTED,a)};
+goog.ui.MenuItem.prototype.setSelectableInternal_=function(a){this.isChecked()&&!a&&this.setChecked(!1);var b=this.getElement();b&&this.getRenderer().setSelectable(this,b,a)};goog.ui.MenuItem.prototype.setCheckable=function(a){this.setSupportedState(goog.ui.Component.State.CHECKED,a)};goog.ui.MenuItem.prototype.setCheckableInternal_=function(a){var b=this.getElement();b&&this.getRenderer().setCheckable(this,b,a)};
+goog.ui.MenuItem.prototype.getCaption=function(){var a=this.getContent();if(goog.isArray(a)){var b=goog.ui.MenuItem.ACCELERATOR_CLASS,c=goog.ui.MenuItem.MNEMONIC_WRAPPER_CLASS_;a=goog.array.map(a,function(a){return goog.dom.isElement(a)&&(goog.dom.classlist.contains(a,b)||goog.dom.classlist.contains(a,c))?"":goog.dom.getRawTextContent(a)}).join("");return goog.string.collapseBreakingSpaces(a)}return goog.ui.MenuItem.superClass_.getCaption.call(this)};
+goog.ui.MenuItem.prototype.getAccelerator=function(){var a=this.getDomHelper(),b=this.getContent();return goog.isArray(b)&&(b=goog.array.find(b,function(a){return goog.dom.classlist.contains(a,goog.ui.MenuItem.ACCELERATOR_CLASS)}))?a.getTextContent(b):null};
+goog.ui.MenuItem.prototype.handleMouseUp=function(a){var b=this.getParent();if(b){var c=b.openingCoords;b.openingCoords=null;if(c&&goog.isNumber(a.clientX)&&(b=new goog.math.Coordinate(a.clientX,a.clientY),goog.math.Coordinate.equals(c,b)))return}goog.ui.MenuItem.superClass_.handleMouseUp.call(this,a)};goog.ui.MenuItem.prototype.handleKeyEventInternal=function(a){return a.keyCode==this.getMnemonic()&&this.performActionInternal(a)?!0:goog.ui.MenuItem.superClass_.handleKeyEventInternal.call(this,a)};
+goog.ui.MenuItem.prototype.setMnemonic=function(a){this.mnemonicKey_=a};goog.ui.MenuItem.prototype.getMnemonic=function(){return this.mnemonicKey_};goog.ui.registry.setDecoratorByClassName(goog.ui.MenuItemRenderer.CSS_CLASS,function(){return new goog.ui.MenuItem(null)});
+goog.ui.MenuItem.prototype.getPreferredAriaRole=function(){return this.isSupportedState(goog.ui.Component.State.CHECKED)?goog.a11y.aria.Role.MENU_ITEM_CHECKBOX:this.isSupportedState(goog.ui.Component.State.SELECTED)?goog.a11y.aria.Role.MENU_ITEM_RADIO:goog.ui.MenuItem.superClass_.getPreferredAriaRole.call(this)};goog.ui.MenuItem.prototype.getParent=function(){return goog.ui.Control.prototype.getParent.call(this)};goog.ui.MenuItem.prototype.getParentEventTarget=function(){return goog.ui.Control.prototype.getParentEventTarget.call(this)};goog.ui.MenuSeparatorRenderer=function(){goog.ui.ControlRenderer.call(this)};goog.inherits(goog.ui.MenuSeparatorRenderer,goog.ui.ControlRenderer);goog.addSingletonGetter(goog.ui.MenuSeparatorRenderer);goog.ui.MenuSeparatorRenderer.CSS_CLASS="goog-menuseparator";goog.ui.MenuSeparatorRenderer.prototype.createDom=function(a){return a.getDomHelper().createDom("DIV",this.getCssClass())};
+goog.ui.MenuSeparatorRenderer.prototype.decorate=function(a,b){b.id&&a.setId(b.id);if("HR"==b.tagName){var c=b;b=this.createDom(a);goog.dom.insertSiblingBefore(b,c);goog.dom.removeNode(c)}else goog.dom.classlist.add(b,this.getCssClass());return b};goog.ui.MenuSeparatorRenderer.prototype.setContent=function(a,b){};goog.ui.MenuSeparatorRenderer.prototype.getCssClass=function(){return goog.ui.MenuSeparatorRenderer.CSS_CLASS};goog.ui.Separator=function(a,b){goog.ui.Control.call(this,null,a||goog.ui.MenuSeparatorRenderer.getInstance(),b);this.setSupportedState(goog.ui.Component.State.DISABLED,!1);this.setSupportedState(goog.ui.Component.State.HOVER,!1);this.setSupportedState(goog.ui.Component.State.ACTIVE,!1);this.setSupportedState(goog.ui.Component.State.FOCUSED,!1);this.setStateInternal(goog.ui.Component.State.DISABLED)};goog.inherits(goog.ui.Separator,goog.ui.Control);
+goog.ui.Separator.prototype.enterDocument=function(){goog.ui.Separator.superClass_.enterDocument.call(this);var a=this.getElement();goog.asserts.assert(a,"The DOM element for the separator cannot be null.");goog.a11y.aria.setRole(a,"separator")};goog.ui.registry.setDecoratorByClassName(goog.ui.MenuSeparatorRenderer.CSS_CLASS,function(){return new goog.ui.Separator});goog.ui.MenuRenderer=function(a){goog.ui.ContainerRenderer.call(this,a||goog.a11y.aria.Role.MENU)};goog.inherits(goog.ui.MenuRenderer,goog.ui.ContainerRenderer);goog.addSingletonGetter(goog.ui.MenuRenderer);goog.ui.MenuRenderer.CSS_CLASS="goog-menu";goog.ui.MenuRenderer.prototype.canDecorate=function(a){return"UL"==a.tagName||goog.ui.MenuRenderer.superClass_.canDecorate.call(this,a)};
+goog.ui.MenuRenderer.prototype.getDecoratorForChild=function(a){return"HR"==a.tagName?new goog.ui.Separator:goog.ui.MenuRenderer.superClass_.getDecoratorForChild.call(this,a)};goog.ui.MenuRenderer.prototype.containsElement=function(a,b){return goog.dom.contains(a.getElement(),b)};goog.ui.MenuRenderer.prototype.getCssClass=function(){return goog.ui.MenuRenderer.CSS_CLASS};
+goog.ui.MenuRenderer.prototype.initializeDom=function(a){goog.ui.MenuRenderer.superClass_.initializeDom.call(this,a);a=a.getElement();goog.asserts.assert(a,"The menu DOM element cannot be null.");goog.a11y.aria.setState(a,goog.a11y.aria.State.HASPOPUP,"true")};goog.ui.MenuSeparator=function(a){goog.ui.Separator.call(this,goog.ui.MenuSeparatorRenderer.getInstance(),a)};goog.inherits(goog.ui.MenuSeparator,goog.ui.Separator);goog.ui.registry.setDecoratorByClassName(goog.ui.MenuSeparatorRenderer.CSS_CLASS,function(){return new goog.ui.Separator});goog.ui.Menu=function(a,b){goog.ui.Container.call(this,goog.ui.Container.Orientation.VERTICAL,b||goog.ui.MenuRenderer.getInstance(),a);this.setFocusable(!1)};goog.inherits(goog.ui.Menu,goog.ui.Container);goog.tagUnsealableClass(goog.ui.Menu);goog.ui.Menu.EventType={BEFORE_SHOW:goog.ui.Component.EventType.BEFORE_SHOW,SHOW:goog.ui.Component.EventType.SHOW,BEFORE_HIDE:goog.ui.Component.EventType.HIDE,HIDE:goog.ui.Component.EventType.HIDE};goog.ui.Menu.CSS_CLASS=goog.ui.MenuRenderer.CSS_CLASS;
+goog.ui.Menu.prototype.allowAutoFocus_=!0;goog.ui.Menu.prototype.allowHighlightDisabled_=!1;goog.ui.Menu.prototype.getCssClass=function(){return this.getRenderer().getCssClass()};goog.ui.Menu.prototype.containsElement=function(a){if(this.getRenderer().containsElement(this,a))return!0;for(var b=0,c=this.getChildCount();b<c;b++){var d=this.getChildAt(b);if("function"==typeof d.containsElement&&d.containsElement(a))return!0}return!1};goog.ui.Menu.prototype.addItem=function(a){this.addChild(a,!0)};
+goog.ui.Menu.prototype.addItemAt=function(a,b){this.addChildAt(a,b,!0)};goog.ui.Menu.prototype.removeItem=function(a){(a=this.removeChild(a,!0))&&a.dispose()};goog.ui.Menu.prototype.removeItemAt=function(a){(a=this.removeChildAt(a,!0))&&a.dispose()};goog.ui.Menu.prototype.getItemAt=function(a){return this.getChildAt(a)};goog.ui.Menu.prototype.getItemCount=function(){return this.getChildCount()};goog.ui.Menu.prototype.getItems=function(){var a=[];this.forEachChild(function(b){a.push(b)});return a};
+goog.ui.Menu.prototype.setPosition=function(a,b){var c=this.isVisible();c||goog.style.setElementShown(this.getElement(),!0);goog.style.setPageOffset(this.getElement(),a,b);c||goog.style.setElementShown(this.getElement(),!1)};goog.ui.Menu.prototype.getPosition=function(){return this.isVisible()?goog.style.getPageOffset(this.getElement()):null};goog.ui.Menu.prototype.setAllowAutoFocus=function(a){(this.allowAutoFocus_=a)&&this.setFocusable(!0)};goog.ui.Menu.prototype.getAllowAutoFocus=function(){return this.allowAutoFocus_};
+goog.ui.Menu.prototype.setAllowHighlightDisabled=function(a){this.allowHighlightDisabled_=a};goog.ui.Menu.prototype.getAllowHighlightDisabled=function(){return this.allowHighlightDisabled_};goog.ui.Menu.prototype.setVisible=function(a,b,c){(b=goog.ui.Menu.superClass_.setVisible.call(this,a,b))&&a&&this.isInDocument()&&this.allowAutoFocus_&&this.getKeyEventTarget().focus();a&&c&&goog.isNumber(c.clientX)?this.openingCoords=new goog.math.Coordinate(c.clientX,c.clientY):this.openingCoords=null;return b};
+goog.ui.Menu.prototype.handleEnterItem=function(a){this.allowAutoFocus_&&this.getKeyEventTarget().focus();return goog.ui.Menu.superClass_.handleEnterItem.call(this,a)};goog.ui.Menu.prototype.highlightNextPrefix=function(a){var b=new RegExp("^"+goog.string.regExpEscape(a),"i");return this.highlightHelper(function(a,d){var c=0>a?0:a,f=!1;do{++a;a==d&&(a=0,f=!0);var g=this.getChildAt(a).getCaption();if(g&&g.match(b))return a}while(!f||a!=c);return this.getHighlightedIndex()},this.getHighlightedIndex())};
+goog.ui.Menu.prototype.canHighlightItem=function(a){return(this.allowHighlightDisabled_||a.isEnabled())&&a.isVisible()&&a.isSupportedState(goog.ui.Component.State.HOVER)};goog.ui.Menu.prototype.decorateInternal=function(a){this.decorateContent(a);goog.ui.Menu.superClass_.decorateInternal.call(this,a)};
+goog.ui.Menu.prototype.handleKeyEventInternal=function(a){var b=goog.ui.Menu.superClass_.handleKeyEventInternal.call(this,a);b||this.forEachChild(function(c){!b&&c.getMnemonic&&c.getMnemonic()==a.keyCode&&(this.isEnabled()&&this.setHighlighted(c),b=c.handleKeyEvent(a))},this);return b};goog.ui.Menu.prototype.setHighlightedIndex=function(a){goog.ui.Menu.superClass_.setHighlightedIndex.call(this,a);(a=this.getChildAt(a))&&goog.style.scrollIntoContainerView(a.getElement(),this.getElement())};
+goog.ui.Menu.prototype.decorateContent=function(a){var b=this.getRenderer();a=this.getDomHelper().getElementsByTagNameAndClass("DIV",b.getCssClass()+"-content",a);for(var c=a.length,d=0;d<c;d++)b.decorateChildren(this,a[d])};goog.events.FocusHandler=function(a){goog.events.EventTarget.call(this);this.element_=a;a=goog.userAgent.IE?"focusout":"blur";this.listenKeyIn_=goog.events.listen(this.element_,goog.userAgent.IE?"focusin":"focus",this,!goog.userAgent.IE);this.listenKeyOut_=goog.events.listen(this.element_,a,this,!goog.userAgent.IE)};goog.inherits(goog.events.FocusHandler,goog.events.EventTarget);goog.events.FocusHandler.EventType={FOCUSIN:"focusin",FOCUSOUT:"focusout"};
+goog.events.FocusHandler.prototype.handleEvent=function(a){var b=a.getBrowserEvent();b=new goog.events.BrowserEvent(b);b.type="focusin"==a.type||"focus"==a.type?goog.events.FocusHandler.EventType.FOCUSIN:goog.events.FocusHandler.EventType.FOCUSOUT;this.dispatchEvent(b)};goog.events.FocusHandler.prototype.disposeInternal=function(){goog.events.FocusHandler.superClass_.disposeInternal.call(this);goog.events.unlistenByKey(this.listenKeyIn_);goog.events.unlistenByKey(this.listenKeyOut_);delete this.element_};goog.debug.LogRecord=function(a,b,c,d,e){this.reset(a,b,c,d,e)};goog.debug.LogRecord.prototype.sequenceNumber_=0;goog.debug.LogRecord.prototype.exception_=null;goog.debug.LogRecord.ENABLE_SEQUENCE_NUMBERS=!0;goog.debug.LogRecord.nextSequenceNumber_=0;
+goog.debug.LogRecord.prototype.reset=function(a,b,c,d,e){goog.debug.LogRecord.ENABLE_SEQUENCE_NUMBERS&&(this.sequenceNumber_="number"==typeof e?e:goog.debug.LogRecord.nextSequenceNumber_++);this.time_=d||goog.now();this.level_=a;this.msg_=b;this.loggerName_=c;delete this.exception_};goog.debug.LogRecord.prototype.getLoggerName=function(){return this.loggerName_};goog.debug.LogRecord.prototype.getException=function(){return this.exception_};
+goog.debug.LogRecord.prototype.setException=function(a){this.exception_=a};goog.debug.LogRecord.prototype.setLoggerName=function(a){this.loggerName_=a};goog.debug.LogRecord.prototype.getLevel=function(){return this.level_};goog.debug.LogRecord.prototype.setLevel=function(a){this.level_=a};goog.debug.LogRecord.prototype.getMessage=function(){return this.msg_};goog.debug.LogRecord.prototype.setMessage=function(a){this.msg_=a};goog.debug.LogRecord.prototype.getMillis=function(){return this.time_};
+goog.debug.LogRecord.prototype.setMillis=function(a){this.time_=a};goog.debug.LogRecord.prototype.getSequenceNumber=function(){return this.sequenceNumber_};goog.debug.LogBuffer=function(){goog.asserts.assert(goog.debug.LogBuffer.isBufferingEnabled(),"Cannot use goog.debug.LogBuffer without defining goog.debug.LogBuffer.CAPACITY.");this.clear()};goog.debug.LogBuffer.getInstance=function(){goog.debug.LogBuffer.instance_||(goog.debug.LogBuffer.instance_=new goog.debug.LogBuffer);return goog.debug.LogBuffer.instance_};goog.debug.LogBuffer.CAPACITY=0;
+goog.debug.LogBuffer.prototype.addRecord=function(a,b,c){var d=(this.curIndex_+1)%goog.debug.LogBuffer.CAPACITY;this.curIndex_=d;if(this.isFull_)return d=this.buffer_[d],d.reset(a,b,c),d;this.isFull_=d==goog.debug.LogBuffer.CAPACITY-1;return this.buffer_[d]=new goog.debug.LogRecord(a,b,c)};goog.debug.LogBuffer.isBufferingEnabled=function(){return 0<goog.debug.LogBuffer.CAPACITY};
+goog.debug.LogBuffer.prototype.clear=function(){this.buffer_=Array(goog.debug.LogBuffer.CAPACITY);this.curIndex_=-1;this.isFull_=!1};goog.debug.LogBuffer.prototype.forEachRecord=function(a){var b=this.buffer_;if(b[0]){var c=this.curIndex_,d=this.isFull_?c:-1;do d=(d+1)%goog.debug.LogBuffer.CAPACITY,a(b[d]);while(d!=c)}};goog.debug.Logger=function(a){this.name_=a;this.handlers_=this.children_=this.level_=this.parent_=null};goog.debug.Logger.ROOT_LOGGER_NAME="";goog.debug.Logger.ENABLE_HIERARCHY=!0;goog.debug.Logger.ENABLE_PROFILER_LOGGING=!1;goog.debug.Logger.ENABLE_HIERARCHY||(goog.debug.Logger.rootHandlers_=[]);goog.debug.Logger.Level=function(a,b){this.name=a;this.value=b};goog.debug.Logger.Level.prototype.toString=function(){return this.name};goog.debug.Logger.Level.OFF=new goog.debug.Logger.Level("OFF",Infinity);
+goog.debug.Logger.Level.SHOUT=new goog.debug.Logger.Level("SHOUT",1200);goog.debug.Logger.Level.SEVERE=new goog.debug.Logger.Level("SEVERE",1E3);goog.debug.Logger.Level.WARNING=new goog.debug.Logger.Level("WARNING",900);goog.debug.Logger.Level.INFO=new goog.debug.Logger.Level("INFO",800);goog.debug.Logger.Level.CONFIG=new goog.debug.Logger.Level("CONFIG",700);goog.debug.Logger.Level.FINE=new goog.debug.Logger.Level("FINE",500);goog.debug.Logger.Level.FINER=new goog.debug.Logger.Level("FINER",400);
+goog.debug.Logger.Level.FINEST=new goog.debug.Logger.Level("FINEST",300);goog.debug.Logger.Level.ALL=new goog.debug.Logger.Level("ALL",0);goog.debug.Logger.Level.PREDEFINED_LEVELS=[goog.debug.Logger.Level.OFF,goog.debug.Logger.Level.SHOUT,goog.debug.Logger.Level.SEVERE,goog.debug.Logger.Level.WARNING,goog.debug.Logger.Level.INFO,goog.debug.Logger.Level.CONFIG,goog.debug.Logger.Level.FINE,goog.debug.Logger.Level.FINER,goog.debug.Logger.Level.FINEST,goog.debug.Logger.Level.ALL];
+goog.debug.Logger.Level.predefinedLevelsCache_=null;goog.debug.Logger.Level.createPredefinedLevelsCache_=function(){goog.debug.Logger.Level.predefinedLevelsCache_={};for(var a=0,b;b=goog.debug.Logger.Level.PREDEFINED_LEVELS[a];a++)goog.debug.Logger.Level.predefinedLevelsCache_[b.value]=b,goog.debug.Logger.Level.predefinedLevelsCache_[b.name]=b};
+goog.debug.Logger.Level.getPredefinedLevel=function(a){goog.debug.Logger.Level.predefinedLevelsCache_||goog.debug.Logger.Level.createPredefinedLevelsCache_();return goog.debug.Logger.Level.predefinedLevelsCache_[a]||null};
+goog.debug.Logger.Level.getPredefinedLevelByValue=function(a){goog.debug.Logger.Level.predefinedLevelsCache_||goog.debug.Logger.Level.createPredefinedLevelsCache_();if(a in goog.debug.Logger.Level.predefinedLevelsCache_)return goog.debug.Logger.Level.predefinedLevelsCache_[a];for(var b=0;b<goog.debug.Logger.Level.PREDEFINED_LEVELS.length;++b){var c=goog.debug.Logger.Level.PREDEFINED_LEVELS[b];if(c.value<=a)return c}return null};goog.debug.Logger.getLogger=function(a){return goog.debug.LogManager.getLogger(a)};
+goog.debug.Logger.logToProfilers=function(a){if(goog.debug.Logger.ENABLE_PROFILER_LOGGING){var b=goog.global.msWriteProfilerMark;b?b(a):(b=goog.global.console)&&b.timeStamp&&b.timeStamp(a)}};goog.debug.Logger.prototype.getName=function(){return this.name_};
+goog.debug.Logger.prototype.addHandler=function(a){goog.debug.LOGGING_ENABLED&&(goog.debug.Logger.ENABLE_HIERARCHY?(this.handlers_||(this.handlers_=[]),this.handlers_.push(a)):(goog.asserts.assert(!this.name_,"Cannot call addHandler on a non-root logger when goog.debug.Logger.ENABLE_HIERARCHY is false."),goog.debug.Logger.rootHandlers_.push(a)))};
+goog.debug.Logger.prototype.removeHandler=function(a){if(goog.debug.LOGGING_ENABLED){var b=goog.debug.Logger.ENABLE_HIERARCHY?this.handlers_:goog.debug.Logger.rootHandlers_;return!!b&&goog.array.remove(b,a)}return!1};goog.debug.Logger.prototype.getParent=function(){return this.parent_};goog.debug.Logger.prototype.getChildren=function(){this.children_||(this.children_={});return this.children_};
+goog.debug.Logger.prototype.setLevel=function(a){goog.debug.LOGGING_ENABLED&&(goog.debug.Logger.ENABLE_HIERARCHY?this.level_=a:(goog.asserts.assert(!this.name_,"Cannot call setLevel() on a non-root logger when goog.debug.Logger.ENABLE_HIERARCHY is false."),goog.debug.Logger.rootLevel_=a))};goog.debug.Logger.prototype.getLevel=function(){return goog.debug.LOGGING_ENABLED?this.level_:goog.debug.Logger.Level.OFF};
+goog.debug.Logger.prototype.getEffectiveLevel=function(){if(!goog.debug.LOGGING_ENABLED)return goog.debug.Logger.Level.OFF;if(!goog.debug.Logger.ENABLE_HIERARCHY)return goog.debug.Logger.rootLevel_;if(this.level_)return this.level_;if(this.parent_)return this.parent_.getEffectiveLevel();goog.asserts.fail("Root logger has no level set.");return null};goog.debug.Logger.prototype.isLoggable=function(a){return goog.debug.LOGGING_ENABLED&&a.value>=this.getEffectiveLevel().value};
+goog.debug.Logger.prototype.log=function(a,b,c){goog.debug.LOGGING_ENABLED&&this.isLoggable(a)&&(goog.isFunction(b)&&(b=b()),this.doLogRecord_(this.getLogRecord(a,b,c)))};goog.debug.Logger.prototype.getLogRecord=function(a,b,c){a=goog.debug.LogBuffer.isBufferingEnabled()?goog.debug.LogBuffer.getInstance().addRecord(a,b,this.name_):new goog.debug.LogRecord(a,String(b),this.name_);c&&a.setException(c);return a};
+goog.debug.Logger.prototype.shout=function(a,b){goog.debug.LOGGING_ENABLED&&this.log(goog.debug.Logger.Level.SHOUT,a,b)};goog.debug.Logger.prototype.severe=function(a,b){goog.debug.LOGGING_ENABLED&&this.log(goog.debug.Logger.Level.SEVERE,a,b)};goog.debug.Logger.prototype.warning=function(a,b){goog.debug.LOGGING_ENABLED&&this.log(goog.debug.Logger.Level.WARNING,a,b)};goog.debug.Logger.prototype.info=function(a,b){goog.debug.LOGGING_ENABLED&&this.log(goog.debug.Logger.Level.INFO,a,b)};
+goog.debug.Logger.prototype.config=function(a,b){goog.debug.LOGGING_ENABLED&&this.log(goog.debug.Logger.Level.CONFIG,a,b)};goog.debug.Logger.prototype.fine=function(a,b){goog.debug.LOGGING_ENABLED&&this.log(goog.debug.Logger.Level.FINE,a,b)};goog.debug.Logger.prototype.finer=function(a,b){goog.debug.LOGGING_ENABLED&&this.log(goog.debug.Logger.Level.FINER,a,b)};goog.debug.Logger.prototype.finest=function(a,b){goog.debug.LOGGING_ENABLED&&this.log(goog.debug.Logger.Level.FINEST,a,b)};
+goog.debug.Logger.prototype.logRecord=function(a){goog.debug.LOGGING_ENABLED&&this.isLoggable(a.getLevel())&&this.doLogRecord_(a)};goog.debug.Logger.prototype.doLogRecord_=function(a){goog.debug.Logger.ENABLE_PROFILER_LOGGING&&goog.debug.Logger.logToProfilers("log:"+a.getMessage());if(goog.debug.Logger.ENABLE_HIERARCHY)for(var b=this;b;)b.callPublish_(a),b=b.getParent();else{b=0;for(var c;c=goog.debug.Logger.rootHandlers_[b++];)c(a)}};
+goog.debug.Logger.prototype.callPublish_=function(a){if(this.handlers_)for(var b=0,c;c=this.handlers_[b];b++)c(a)};goog.debug.Logger.prototype.setParent_=function(a){this.parent_=a};goog.debug.Logger.prototype.addChild_=function(a,b){this.getChildren()[a]=b};goog.debug.LogManager={};goog.debug.LogManager.loggers_={};goog.debug.LogManager.rootLogger_=null;
+goog.debug.LogManager.initialize=function(){goog.debug.LogManager.rootLogger_||(goog.debug.LogManager.rootLogger_=new goog.debug.Logger(goog.debug.Logger.ROOT_LOGGER_NAME),goog.debug.LogManager.loggers_[goog.debug.Logger.ROOT_LOGGER_NAME]=goog.debug.LogManager.rootLogger_,goog.debug.LogManager.rootLogger_.setLevel(goog.debug.Logger.Level.CONFIG))};goog.debug.LogManager.getLoggers=function(){return goog.debug.LogManager.loggers_};
+goog.debug.LogManager.getRoot=function(){goog.debug.LogManager.initialize();return goog.debug.LogManager.rootLogger_};goog.debug.LogManager.getLogger=function(a){goog.debug.LogManager.initialize();return goog.debug.LogManager.loggers_[a]||goog.debug.LogManager.createLogger_(a)};goog.debug.LogManager.createFunctionForCatchErrors=function(a){return function(b){(a||goog.debug.LogManager.getRoot()).severe("Error: "+b.message+" ("+b.fileName+" @ Line: "+b.line+")")}};
+goog.debug.LogManager.createLogger_=function(a){var b=new goog.debug.Logger(a);if(goog.debug.Logger.ENABLE_HIERARCHY){var c=a.lastIndexOf("."),d=a.substr(0,c);c=a.substr(c+1);d=goog.debug.LogManager.getLogger(d);d.addChild_(c,b);b.setParent_(d)}return goog.debug.LogManager.loggers_[a]=b};goog.log={};goog.log.ENABLED=goog.debug.LOGGING_ENABLED;goog.log.ROOT_LOGGER_NAME=goog.debug.Logger.ROOT_LOGGER_NAME;goog.log.Logger=goog.debug.Logger;goog.log.Level=goog.debug.Logger.Level;goog.log.LogRecord=goog.debug.LogRecord;goog.log.getLogger=function(a,b){if(goog.log.ENABLED){var c=goog.debug.LogManager.getLogger(a);b&&c&&c.setLevel(b);return c}return null};goog.log.addHandler=function(a,b){goog.log.ENABLED&&a&&a.addHandler(b)};
+goog.log.removeHandler=function(a,b){return goog.log.ENABLED&&a?a.removeHandler(b):!1};goog.log.log=function(a,b,c,d){goog.log.ENABLED&&a&&a.log(b,c,d)};goog.log.error=function(a,b,c){goog.log.ENABLED&&a&&a.severe(b,c)};goog.log.warning=function(a,b,c){goog.log.ENABLED&&a&&a.warning(b,c)};goog.log.info=function(a,b,c){goog.log.ENABLED&&a&&a.info(b,c)};goog.log.fine=function(a,b,c){goog.log.ENABLED&&a&&a.fine(b,c)};goog.Thenable=function(){};goog.Thenable.prototype.then=function(a,b,c){};goog.Thenable.IMPLEMENTED_BY_PROP="$goog_Thenable";goog.Thenable.addImplementation=function(a){COMPILED?a.prototype[goog.Thenable.IMPLEMENTED_BY_PROP]=!0:a.prototype.$goog_Thenable=!0};goog.Thenable.isImplementedBy=function(a){if(!a)return!1;try{return COMPILED?!!a[goog.Thenable.IMPLEMENTED_BY_PROP]:!!a.$goog_Thenable}catch(b){return!1}};goog.async={};goog.async.FreeList=function(a,b,c){this.limit_=c;this.create_=a;this.reset_=b;this.occupants_=0;this.head_=null};goog.async.FreeList.prototype.get=function(){if(0<this.occupants_){this.occupants_--;var a=this.head_;this.head_=a.next;a.next=null}else a=this.create_();return a};goog.async.FreeList.prototype.put=function(a){this.reset_(a);this.occupants_<this.limit_&&(this.occupants_++,a.next=this.head_,this.head_=a)};goog.async.FreeList.prototype.occupants=function(){return this.occupants_};goog.async.WorkQueue=function(){this.workTail_=this.workHead_=null};goog.async.WorkQueue.DEFAULT_MAX_UNUSED=100;goog.async.WorkQueue.freelist_=new goog.async.FreeList(function(){return new goog.async.WorkItem},function(a){a.reset()},goog.async.WorkQueue.DEFAULT_MAX_UNUSED);goog.async.WorkQueue.prototype.add=function(a,b){var c=this.getUnusedItem_();c.set(a,b);this.workTail_?this.workTail_.next=c:(goog.asserts.assert(!this.workHead_),this.workHead_=c);this.workTail_=c};
+goog.async.WorkQueue.prototype.remove=function(){var a=null;this.workHead_&&(a=this.workHead_,this.workHead_=this.workHead_.next,this.workHead_||(this.workTail_=null),a.next=null);return a};goog.async.WorkQueue.prototype.returnUnused=function(a){goog.async.WorkQueue.freelist_.put(a)};goog.async.WorkQueue.prototype.getUnusedItem_=function(){return goog.async.WorkQueue.freelist_.get()};goog.async.WorkItem=function(){this.next=this.scope=this.fn=null};
+goog.async.WorkItem.prototype.set=function(a,b){this.fn=a;this.scope=b;this.next=null};goog.async.WorkItem.prototype.reset=function(){this.next=this.scope=this.fn=null};goog.async.throwException=function(a){goog.global.setTimeout(function(){throw a;},0)};goog.async.nextTick=function(a,b,c){var d=a;b&&(d=goog.bind(a,b));d=goog.async.nextTick.wrapCallback_(d);goog.isFunction(goog.global.setImmediate)&&(c||goog.async.nextTick.useSetImmediate_())?goog.global.setImmediate(d):(goog.async.nextTick.setImmediate_||(goog.async.nextTick.setImmediate_=goog.async.nextTick.getSetImmediateEmulator_()),goog.async.nextTick.setImmediate_(d))};
+goog.async.nextTick.useSetImmediate_=function(){return goog.global.Window&&goog.global.Window.prototype&&!goog.labs.userAgent.browser.isEdge()&&goog.global.Window.prototype.setImmediate==goog.global.setImmediate?!1:!0};
+goog.async.nextTick.getSetImmediateEmulator_=function(){var a=goog.global.MessageChannel;"undefined"===typeof a&&"undefined"!==typeof window&&window.postMessage&&window.addEventListener&&!goog.labs.userAgent.engine.isPresto()&&(a=function(){var a=document.createElement("IFRAME");a.style.display="none";a.src="";document.documentElement.appendChild(a);var b=a.contentWindow;a=b.document;a.open();a.write("");a.close();var c="callImmediate"+Math.random(),d="file:"==b.location.protocol?"*":b.location.protocol+
+"//"+b.location.host;a=goog.bind(function(a){if(("*"==d||a.origin==d)&&a.data==c)this.port1.onmessage()},this);b.addEventListener("message",a,!1);this.port1={};this.port2={postMessage:function(){b.postMessage(c,d)}}});if("undefined"!==typeof a&&!goog.labs.userAgent.browser.isIE()){var b=new a,c={},d=c;b.port1.onmessage=function(){if(goog.isDef(c.next)){c=c.next;var a=c.cb;c.cb=null;a()}};return function(a){d.next={cb:a};d=d.next;b.port2.postMessage(0)}}return"undefined"!==typeof document&&"onreadystatechange"in
+document.createElement("SCRIPT")?function(a){var b=document.createElement("SCRIPT");b.onreadystatechange=function(){b.onreadystatechange=null;b.parentNode.removeChild(b);b=null;a();a=null};document.documentElement.appendChild(b)}:function(a){goog.global.setTimeout(a,0)}};goog.async.nextTick.wrapCallback_=goog.functions.identity;goog.debug.entryPointRegistry.register(function(a){goog.async.nextTick.wrapCallback_=a});goog.ASSUME_NATIVE_PROMISE=!1;goog.async.run=function(a,b){goog.async.run.schedule_||goog.async.run.initializeRunner_();goog.async.run.workQueueScheduled_||(goog.async.run.schedule_(),goog.async.run.workQueueScheduled_=!0);goog.async.run.workQueue_.add(a,b)};
+goog.async.run.initializeRunner_=function(){if(goog.ASSUME_NATIVE_PROMISE||goog.global.Promise&&goog.global.Promise.resolve){var a=goog.global.Promise.resolve(void 0);goog.async.run.schedule_=function(){a.then(goog.async.run.processWorkQueue)}}else goog.async.run.schedule_=function(){goog.async.nextTick(goog.async.run.processWorkQueue)}};goog.async.run.forceNextTick=function(a){goog.async.run.schedule_=function(){goog.async.nextTick(goog.async.run.processWorkQueue);a&&a(goog.async.run.processWorkQueue)}};
+goog.async.run.workQueueScheduled_=!1;goog.async.run.workQueue_=new goog.async.WorkQueue;goog.DEBUG&&(goog.async.run.resetQueue=function(){goog.async.run.workQueueScheduled_=!1;goog.async.run.workQueue_=new goog.async.WorkQueue});goog.async.run.processWorkQueue=function(){for(var a;a=goog.async.run.workQueue_.remove();){try{a.fn.call(a.scope)}catch(b){goog.async.throwException(b)}goog.async.run.workQueue_.returnUnused(a)}goog.async.run.workQueueScheduled_=!1};goog.promise={};goog.promise.Resolver=function(){};goog.Promise=function(a,b){this.state_=goog.Promise.State_.PENDING;this.result_=void 0;this.callbackEntriesTail_=this.callbackEntries_=this.parent_=null;this.executing_=!1;0<goog.Promise.UNHANDLED_REJECTION_DELAY?this.unhandledRejectionId_=0:0==goog.Promise.UNHANDLED_REJECTION_DELAY&&(this.hadUnhandledRejection_=!1);goog.Promise.LONG_STACK_TRACES&&(this.stack_=[],this.addStackTrace_(Error("created")),this.currentStep_=0);if(a!=goog.nullFunction)try{var c=this;a.call(b,function(a){c.resolve_(goog.Promise.State_.FULFILLED,
+a)},function(a){if(goog.DEBUG&&!(a instanceof goog.Promise.CancellationError))try{if(a instanceof Error)throw a;throw Error("Promise rejected.");}catch(e){}c.resolve_(goog.Promise.State_.REJECTED,a)})}catch(d){this.resolve_(goog.Promise.State_.REJECTED,d)}};goog.Promise.LONG_STACK_TRACES=!1;goog.Promise.UNHANDLED_REJECTION_DELAY=0;goog.Promise.State_={PENDING:0,BLOCKED:1,FULFILLED:2,REJECTED:3};
+goog.Promise.CallbackEntry_=function(){this.next=this.context=this.onRejected=this.onFulfilled=this.child=null;this.always=!1};goog.Promise.CallbackEntry_.prototype.reset=function(){this.context=this.onRejected=this.onFulfilled=this.child=null;this.always=!1};goog.Promise.DEFAULT_MAX_UNUSED=100;goog.Promise.freelist_=new goog.async.FreeList(function(){return new goog.Promise.CallbackEntry_},function(a){a.reset()},goog.Promise.DEFAULT_MAX_UNUSED);
+goog.Promise.getCallbackEntry_=function(a,b,c){var d=goog.Promise.freelist_.get();d.onFulfilled=a;d.onRejected=b;d.context=c;return d};goog.Promise.returnEntry_=function(a){goog.Promise.freelist_.put(a)};goog.Promise.resolve=function(a){if(a instanceof goog.Promise)return a;var b=new goog.Promise(goog.nullFunction);b.resolve_(goog.Promise.State_.FULFILLED,a);return b};goog.Promise.reject=function(a){return new goog.Promise(function(b,c){c(a)})};
+goog.Promise.resolveThen_=function(a,b,c){goog.Promise.maybeThen_(a,b,c,null)||goog.async.run(goog.partial(b,a))};goog.Promise.race=function(a){return new goog.Promise(function(b,c){a.length||b(void 0);for(var d=0,e;d<a.length;d++)e=a[d],goog.Promise.resolveThen_(e,b,c)})};
+goog.Promise.all=function(a){return new goog.Promise(function(b,c){var d=a.length,e=[];if(d)for(var f=function(a,c){d--;e[a]=c;0==d&&b(e)},g=function(a){c(a)},h=0,k;h<a.length;h++)k=a[h],goog.Promise.resolveThen_(k,goog.partial(f,h),g);else b(e)})};
+goog.Promise.allSettled=function(a){return new goog.Promise(function(b,c){var d=a.length,e=[];if(d)for(var f=function(a,c,f){d--;e[a]=c?{fulfilled:!0,value:f}:{fulfilled:!1,reason:f};0==d&&b(e)},g=0,h;g<a.length;g++)h=a[g],goog.Promise.resolveThen_(h,goog.partial(f,g,!0),goog.partial(f,g,!1));else b(e)})};
+goog.Promise.firstFulfilled=function(a){return new goog.Promise(function(b,c){var d=a.length,e=[];if(d)for(var f=function(a){b(a)},g=function(a,b){d--;e[a]=b;0==d&&c(e)},h=0,k;h<a.length;h++)k=a[h],goog.Promise.resolveThen_(k,f,goog.partial(g,h));else b(void 0)})};goog.Promise.withResolver=function(){var a,b,c=new goog.Promise(function(c,e){a=c;b=e});return new goog.Promise.Resolver_(c,a,b)};
+goog.Promise.prototype.then=function(a,b,c){null!=a&&goog.asserts.assertFunction(a,"opt_onFulfilled should be a function.");null!=b&&goog.asserts.assertFunction(b,"opt_onRejected should be a function. Did you pass opt_context as the second argument instead of the third?");goog.Promise.LONG_STACK_TRACES&&this.addStackTrace_(Error("then"));return this.addChildPromise_(goog.isFunction(a)?a:null,goog.isFunction(b)?b:null,c)};goog.Thenable.addImplementation(goog.Promise);
+goog.Promise.prototype.thenVoid=function(a,b,c){null!=a&&goog.asserts.assertFunction(a,"opt_onFulfilled should be a function.");null!=b&&goog.asserts.assertFunction(b,"opt_onRejected should be a function. Did you pass opt_context as the second argument instead of the third?");goog.Promise.LONG_STACK_TRACES&&this.addStackTrace_(Error("then"));this.addCallbackEntry_(goog.Promise.getCallbackEntry_(a||goog.nullFunction,b||null,c))};
+goog.Promise.prototype.thenAlways=function(a,b){goog.Promise.LONG_STACK_TRACES&&this.addStackTrace_(Error("thenAlways"));var c=goog.Promise.getCallbackEntry_(a,a,b);c.always=!0;this.addCallbackEntry_(c);return this};goog.Promise.prototype.thenCatch=function(a,b){goog.Promise.LONG_STACK_TRACES&&this.addStackTrace_(Error("thenCatch"));return this.addChildPromise_(null,a,b)};
+goog.Promise.prototype.cancel=function(a){this.state_==goog.Promise.State_.PENDING&&goog.async.run(function(){var b=new goog.Promise.CancellationError(a);this.cancelInternal_(b)},this)};goog.Promise.prototype.cancelInternal_=function(a){this.state_==goog.Promise.State_.PENDING&&(this.parent_?(this.parent_.cancelChild_(this,a),this.parent_=null):this.resolve_(goog.Promise.State_.REJECTED,a))};
+goog.Promise.prototype.cancelChild_=function(a,b){if(this.callbackEntries_){for(var c=0,d=null,e=null,f=this.callbackEntries_;f&&(f.always||(c++,f.child==a&&(d=f),!(d&&1<c)));f=f.next)d||(e=f);d&&(this.state_==goog.Promise.State_.PENDING&&1==c?this.cancelInternal_(b):(e?this.removeEntryAfter_(e):this.popEntry_(),this.executeCallback_(d,goog.Promise.State_.REJECTED,b)))}};
+goog.Promise.prototype.addCallbackEntry_=function(a){this.hasEntry_()||this.state_!=goog.Promise.State_.FULFILLED&&this.state_!=goog.Promise.State_.REJECTED||this.scheduleCallbacks_();this.queueEntry_(a)};
+goog.Promise.prototype.addChildPromise_=function(a,b,c){var d=goog.Promise.getCallbackEntry_(null,null,null);d.child=new goog.Promise(function(e,f){d.onFulfilled=a?function(b){try{var d=a.call(c,b);e(d)}catch(k){f(k)}}:e;d.onRejected=b?function(a){try{var d=b.call(c,a);!goog.isDef(d)&&a instanceof goog.Promise.CancellationError?f(a):e(d)}catch(k){f(k)}}:f});d.child.parent_=this;this.addCallbackEntry_(d);return d.child};
+goog.Promise.prototype.unblockAndFulfill_=function(a){goog.asserts.assert(this.state_==goog.Promise.State_.BLOCKED);this.state_=goog.Promise.State_.PENDING;this.resolve_(goog.Promise.State_.FULFILLED,a)};goog.Promise.prototype.unblockAndReject_=function(a){goog.asserts.assert(this.state_==goog.Promise.State_.BLOCKED);this.state_=goog.Promise.State_.PENDING;this.resolve_(goog.Promise.State_.REJECTED,a)};
+goog.Promise.prototype.resolve_=function(a,b){this.state_==goog.Promise.State_.PENDING&&(this===b&&(a=goog.Promise.State_.REJECTED,b=new TypeError("Promise cannot resolve to itself")),this.state_=goog.Promise.State_.BLOCKED,goog.Promise.maybeThen_(b,this.unblockAndFulfill_,this.unblockAndReject_,this)||(this.result_=b,this.state_=a,this.parent_=null,this.scheduleCallbacks_(),a!=goog.Promise.State_.REJECTED||b instanceof goog.Promise.CancellationError||goog.Promise.addUnhandledRejection_(this,b)))};
+goog.Promise.maybeThen_=function(a,b,c,d){if(a instanceof goog.Promise)return a.thenVoid(b,c,d),!0;if(goog.Thenable.isImplementedBy(a))return a.then(b,c,d),!0;if(goog.isObject(a))try{var e=a.then;if(goog.isFunction(e))return goog.Promise.tryThen_(a,e,b,c,d),!0}catch(f){return c.call(d,f),!0}return!1};goog.Promise.tryThen_=function(a,b,c,d,e){var f=!1,g=function(a){f||(f=!0,c.call(e,a))},h=function(a){f||(f=!0,d.call(e,a))};try{b.call(a,g,h)}catch(k){h(k)}};
+goog.Promise.prototype.scheduleCallbacks_=function(){this.executing_||(this.executing_=!0,goog.async.run(this.executeCallbacks_,this))};goog.Promise.prototype.hasEntry_=function(){return!!this.callbackEntries_};goog.Promise.prototype.queueEntry_=function(a){goog.asserts.assert(null!=a.onFulfilled);this.callbackEntriesTail_?this.callbackEntriesTail_.next=a:this.callbackEntries_=a;this.callbackEntriesTail_=a};
+goog.Promise.prototype.popEntry_=function(){var a=null;this.callbackEntries_&&(a=this.callbackEntries_,this.callbackEntries_=a.next,a.next=null);this.callbackEntries_||(this.callbackEntriesTail_=null);null!=a&&goog.asserts.assert(null!=a.onFulfilled);return a};goog.Promise.prototype.removeEntryAfter_=function(a){goog.asserts.assert(this.callbackEntries_);goog.asserts.assert(null!=a);a.next==this.callbackEntriesTail_&&(this.callbackEntriesTail_=a);a.next=a.next.next};
+goog.Promise.prototype.executeCallbacks_=function(){for(var a;a=this.popEntry_();)goog.Promise.LONG_STACK_TRACES&&this.currentStep_++,this.executeCallback_(a,this.state_,this.result_);this.executing_=!1};
+goog.Promise.prototype.executeCallback_=function(a,b,c){b==goog.Promise.State_.REJECTED&&a.onRejected&&!a.always&&this.removeUnhandledRejection_();if(a.child)a.child.parent_=null,goog.Promise.invokeCallback_(a,b,c);else try{a.always?a.onFulfilled.call(a.context):goog.Promise.invokeCallback_(a,b,c)}catch(d){goog.Promise.handleRejection_.call(null,d)}goog.Promise.returnEntry_(a)};
+goog.Promise.invokeCallback_=function(a,b,c){b==goog.Promise.State_.FULFILLED?a.onFulfilled.call(a.context,c):a.onRejected&&a.onRejected.call(a.context,c)};goog.Promise.prototype.addStackTrace_=function(a){if(goog.Promise.LONG_STACK_TRACES&&goog.isString(a.stack)){var b=a.stack.split("\n",4)[3];a=a.message;a+=Array(11-a.length).join(" ");this.stack_.push(a+b)}};
+goog.Promise.prototype.appendLongStack_=function(a){if(goog.Promise.LONG_STACK_TRACES&&a&&goog.isString(a.stack)&&this.stack_.length){for(var b=["Promise trace:"],c=this;c;c=c.parent_){for(var d=this.currentStep_;0<=d;d--)b.push(c.stack_[d]);b.push("Value: ["+(c.state_==goog.Promise.State_.REJECTED?"REJECTED":"FULFILLED")+"] <"+String(c.result_)+">")}a.stack+="\n\n"+b.join("\n")}};
+goog.Promise.prototype.removeUnhandledRejection_=function(){if(0<goog.Promise.UNHANDLED_REJECTION_DELAY)for(var a=this;a&&a.unhandledRejectionId_;a=a.parent_)goog.global.clearTimeout(a.unhandledRejectionId_),a.unhandledRejectionId_=0;else if(0==goog.Promise.UNHANDLED_REJECTION_DELAY)for(a=this;a&&a.hadUnhandledRejection_;a=a.parent_)a.hadUnhandledRejection_=!1};
+goog.Promise.addUnhandledRejection_=function(a,b){0<goog.Promise.UNHANDLED_REJECTION_DELAY?a.unhandledRejectionId_=goog.global.setTimeout(function(){a.appendLongStack_(b);goog.Promise.handleRejection_.call(null,b)},goog.Promise.UNHANDLED_REJECTION_DELAY):0==goog.Promise.UNHANDLED_REJECTION_DELAY&&(a.hadUnhandledRejection_=!0,goog.async.run(function(){a.hadUnhandledRejection_&&(a.appendLongStack_(b),goog.Promise.handleRejection_.call(null,b))}))};goog.Promise.handleRejection_=goog.async.throwException;
+goog.Promise.setUnhandledRejectionHandler=function(a){goog.Promise.handleRejection_=a};goog.Promise.CancellationError=function(a){goog.debug.Error.call(this,a)};goog.inherits(goog.Promise.CancellationError,goog.debug.Error);goog.Promise.CancellationError.prototype.name="cancel";goog.Promise.Resolver_=function(a,b,c){this.promise=a;this.resolve=b;this.reject=c};goog.Timer=function(a,b){goog.events.EventTarget.call(this);this.interval_=a||1;this.timerObject_=b||goog.Timer.defaultTimerObject;this.boundTick_=goog.bind(this.tick_,this);this.last_=goog.now()};goog.inherits(goog.Timer,goog.events.EventTarget);goog.Timer.MAX_TIMEOUT_=2147483647;goog.Timer.INVALID_TIMEOUT_ID_=-1;goog.Timer.prototype.enabled=!1;goog.Timer.defaultTimerObject=goog.global;goog.Timer.intervalScale=.8;goog.Timer.prototype.timer_=null;goog.Timer.prototype.getInterval=function(){return this.interval_};
+goog.Timer.prototype.setInterval=function(a){this.interval_=a;this.timer_&&this.enabled?(this.stop(),this.start()):this.timer_&&this.stop()};goog.Timer.prototype.tick_=function(){if(this.enabled){var a=goog.now()-this.last_;0<a&&a<this.interval_*goog.Timer.intervalScale?this.timer_=this.timerObject_.setTimeout(this.boundTick_,this.interval_-a):(this.timer_&&(this.timerObject_.clearTimeout(this.timer_),this.timer_=null),this.dispatchTick(),this.enabled&&(this.stop(),this.start()))}};
+goog.Timer.prototype.dispatchTick=function(){this.dispatchEvent(goog.Timer.TICK)};goog.Timer.prototype.start=function(){this.enabled=!0;this.timer_||(this.timer_=this.timerObject_.setTimeout(this.boundTick_,this.interval_),this.last_=goog.now())};goog.Timer.prototype.stop=function(){this.enabled=!1;this.timer_&&(this.timerObject_.clearTimeout(this.timer_),this.timer_=null)};goog.Timer.prototype.disposeInternal=function(){goog.Timer.superClass_.disposeInternal.call(this);this.stop();delete this.timerObject_};
+goog.Timer.TICK="tick";goog.Timer.callOnce=function(a,b,c){if(goog.isFunction(a))c&&(a=goog.bind(a,c));else if(a&&"function"==typeof a.handleEvent)a=goog.bind(a.handleEvent,a);else throw Error("Invalid listener argument");return Number(b)>goog.Timer.MAX_TIMEOUT_?goog.Timer.INVALID_TIMEOUT_ID_:goog.Timer.defaultTimerObject.setTimeout(a,b||0)};goog.Timer.clear=function(a){goog.Timer.defaultTimerObject.clearTimeout(a)};
+goog.Timer.promise=function(a,b){var c=null;return(new goog.Promise(function(d,e){c=goog.Timer.callOnce(function(){d(b)},a);c==goog.Timer.INVALID_TIMEOUT_ID_&&e(Error("Failed to schedule timer."))})).thenCatch(function(a){goog.Timer.clear(c);throw a;})};goog.string.StringBuffer=function(a,b){null!=a&&this.append.apply(this,arguments)};goog.string.StringBuffer.prototype.buffer_="";goog.string.StringBuffer.prototype.set=function(a){this.buffer_=""+a};goog.string.StringBuffer.prototype.append=function(a,b,c){this.buffer_+=String(a);if(null!=b)for(var d=1;d<arguments.length;d++)this.buffer_+=arguments[d];return this};goog.string.StringBuffer.prototype.clear=function(){this.buffer_=""};goog.string.StringBuffer.prototype.getLength=function(){return this.buffer_.length};
+goog.string.StringBuffer.prototype.toString=function(){return this.buffer_};goog.ui.tree={};goog.ui.tree.BaseNode=function(a,b,c){goog.ui.Component.call(this,c);this.config_=b||goog.ui.tree.BaseNode.defaultConfig;this.html_=goog.html.SafeHtml.htmlEscapePreservingNewlines(a);this.expanded_=this.selected_=!1;this.toolTip_=null;this.afterLabelHtml_=goog.html.SafeHtml.EMPTY;this.isUserCollapsible_=!0;this.depth_=-1};goog.inherits(goog.ui.tree.BaseNode,goog.ui.Component);
+goog.ui.tree.BaseNode.EventType={BEFORE_EXPAND:"beforeexpand",EXPAND:"expand",BEFORE_COLLAPSE:"beforecollapse",COLLAPSE:"collapse"};goog.ui.tree.BaseNode.allNodes={};goog.ui.tree.BaseNode.prototype.disposeInternal=function(){goog.ui.tree.BaseNode.superClass_.disposeInternal.call(this);this.tree&&(this.tree.removeNode(this),this.tree=null);this.setElementInternal(null)};
+goog.ui.tree.BaseNode.prototype.initAccessibility=function(){var a=this.getElement();if(a){var b=this.getLabelElement();b&&!b.id&&(b.id=this.getId()+".label");goog.a11y.aria.setRole(a,"treeitem");goog.a11y.aria.setState(a,"selected",!1);goog.a11y.aria.setState(a,"level",this.getDepth());b&&goog.a11y.aria.setState(a,"labelledby",b.id);(b=this.getIconElement())&&goog.a11y.aria.setRole(b,"presentation");(b=this.getExpandIconElement())&&goog.a11y.aria.setRole(b,"presentation");if(b=this.getChildrenElement())if(goog.a11y.aria.setRole(b,
+"group"),b.hasChildNodes())for(goog.a11y.aria.setState(a,goog.a11y.aria.State.EXPANDED,!1),a=this.getChildCount(),b=1;b<=a;b++){var c=this.getChildAt(b-1).getElement();goog.asserts.assert(c,"The child element cannot be null");goog.a11y.aria.setState(c,"setsize",a);goog.a11y.aria.setState(c,"posinset",b)}}};goog.ui.tree.BaseNode.prototype.createDom=function(){var a=this.getDomHelper().safeHtmlToNode(this.toSafeHtml());this.setElementInternal(a)};
+goog.ui.tree.BaseNode.prototype.enterDocument=function(){goog.ui.tree.BaseNode.superClass_.enterDocument.call(this);goog.ui.tree.BaseNode.allNodes[this.getId()]=this;this.initAccessibility()};goog.ui.tree.BaseNode.prototype.exitDocument=function(){goog.ui.tree.BaseNode.superClass_.exitDocument.call(this);delete goog.ui.tree.BaseNode.allNodes[this.getId()]};
+goog.ui.tree.BaseNode.prototype.addChildAt=function(a,b,c){goog.asserts.assert(!a.getParent());goog.asserts.assertInstanceof(a,goog.ui.tree.BaseNode);c=this.getChildAt(b-1);var d=this.getChildAt(b);goog.ui.tree.BaseNode.superClass_.addChildAt.call(this,a,b);a.previousSibling_=c;a.nextSibling_=d;c?c.nextSibling_=a:this.firstChild_=a;d?d.previousSibling_=a:this.lastChild_=a;(b=this.getTree())&&a.setTreeInternal(b);a.setDepth_(this.getDepth()+1);if(b=this.getElement())if(this.updateExpandIcon(),goog.a11y.aria.setState(b,
+goog.a11y.aria.State.EXPANDED,this.getExpanded()),this.getExpanded()){b=this.getChildrenElement();a.getElement()||a.createDom();var e=a.getElement(),f=d&&d.getElement();b.insertBefore(e,f);this.isInDocument()&&a.enterDocument();d||(c?c.updateExpandIcon():(goog.style.setElementShown(b,!0),this.setExpanded(this.getExpanded())))}};
+goog.ui.tree.BaseNode.prototype.add=function(a,b){goog.asserts.assert(!b||b.getParent()==this,"Can only add nodes before siblings");a.getParent()&&a.getParent().removeChild(a);this.addChildAt(a,b?this.indexOfChild(b):this.getChildCount());return a};
+goog.ui.tree.BaseNode.prototype.removeChild=function(a,b){var c=this.getTree(),d=c?c.getSelectedItem():null;if(d==a||a.contains(d))c.hasFocus()?(this.select(),goog.Timer.callOnce(this.onTimeoutSelect_,10,this)):this.select();goog.ui.tree.BaseNode.superClass_.removeChild.call(this,a);this.lastChild_==a&&(this.lastChild_=a.previousSibling_);this.firstChild_==a&&(this.firstChild_=a.nextSibling_);a.previousSibling_&&(a.previousSibling_.nextSibling_=a.nextSibling_);a.nextSibling_&&(a.nextSibling_.previousSibling_=
+a.previousSibling_);d=a.isLastSibling();a.tree=null;a.depth_=-1;if(c&&(c.removeNode(a),this.isInDocument())){c=this.getChildrenElement();if(a.isInDocument()){var e=a.getElement();c.removeChild(e);a.exitDocument()}d&&(d=this.getLastChild())&&d.updateExpandIcon();this.hasChildren()||(c.style.display="none",this.updateExpandIcon(),this.updateIcon_(),(d=this.getElement())&&goog.a11y.aria.removeState(d,goog.a11y.aria.State.EXPANDED))}return a};goog.ui.tree.BaseNode.prototype.remove=goog.ui.tree.BaseNode.prototype.removeChild;
+goog.ui.tree.BaseNode.prototype.onTimeoutSelect_=function(){this.select()};goog.ui.tree.BaseNode.prototype.getTree=goog.abstractMethod;goog.ui.tree.BaseNode.prototype.getDepth=function(){var a=this.depth_;0>a&&(a=this.computeDepth_(),this.setDepth_(a));return a};goog.ui.tree.BaseNode.prototype.computeDepth_=function(){var a=this.getParent();return a?a.getDepth()+1:0};
+goog.ui.tree.BaseNode.prototype.setDepth_=function(a){if(a!=this.depth_){this.depth_=a;var b=this.getRowElement();if(b){var c=this.getPixelIndent_()+"px";this.isRightToLeft()?b.style.paddingRight=c:b.style.paddingLeft=c}this.forEachChild(function(b){b.setDepth_(a+1)})}};goog.ui.tree.BaseNode.prototype.contains=function(a){for(;a;){if(a==this)return!0;a=a.getParent()}return!1};goog.ui.tree.BaseNode.EMPTY_CHILDREN_=[];
+goog.ui.tree.BaseNode.prototype.getChildren=function(){var a=[];this.forEachChild(function(b){a.push(b)});return a};goog.ui.tree.BaseNode.prototype.getFirstChild=function(){return this.getChildAt(0)};goog.ui.tree.BaseNode.prototype.getLastChild=function(){return this.getChildAt(this.getChildCount()-1)};goog.ui.tree.BaseNode.prototype.getPreviousSibling=function(){return this.previousSibling_};goog.ui.tree.BaseNode.prototype.getNextSibling=function(){return this.nextSibling_};
+goog.ui.tree.BaseNode.prototype.isLastSibling=function(){return!this.nextSibling_};goog.ui.tree.BaseNode.prototype.isSelected=function(){return this.selected_};goog.ui.tree.BaseNode.prototype.select=function(){var a=this.getTree();a&&a.setSelectedItem(this)};goog.ui.tree.BaseNode.prototype.deselect=goog.nullFunction;
+goog.ui.tree.BaseNode.prototype.setSelectedInternal=function(a){if(this.selected_!=a){this.selected_=a;this.updateRow();var b=this.getElement();b&&(goog.a11y.aria.setState(b,"selected",a),a&&(a=this.getTree().getElement(),goog.asserts.assert(a,"The DOM element for the tree cannot be null"),goog.a11y.aria.setState(a,"activedescendant",this.getId())))}};goog.ui.tree.BaseNode.prototype.getExpanded=function(){return this.expanded_};
+goog.ui.tree.BaseNode.prototype.setExpandedInternal=function(a){this.expanded_=a};
+goog.ui.tree.BaseNode.prototype.setExpanded=function(a){var b=a!=this.expanded_;if(!b||this.dispatchEvent(a?goog.ui.tree.BaseNode.EventType.BEFORE_EXPAND:goog.ui.tree.BaseNode.EventType.BEFORE_COLLAPSE)){this.expanded_=a;var c=this.getTree();var d=this.getElement();if(this.hasChildren()){if(!a&&c&&this.contains(c.getSelectedItem())&&this.select(),d){if(c=this.getChildrenElement())if(goog.style.setElementShown(c,a),goog.a11y.aria.setState(d,goog.a11y.aria.State.EXPANDED,a),a&&this.isInDocument()&&
+!c.hasChildNodes()){var e=[];this.forEachChild(function(a){e.push(a.toSafeHtml())});goog.dom.safe.setInnerHtml(c,goog.html.SafeHtml.concat(e));this.forEachChild(function(a){a.enterDocument()})}this.updateExpandIcon()}}else(c=this.getChildrenElement())&&goog.style.setElementShown(c,!1);d&&this.updateIcon_();b&&this.dispatchEvent(a?goog.ui.tree.BaseNode.EventType.EXPAND:goog.ui.tree.BaseNode.EventType.COLLAPSE)}};goog.ui.tree.BaseNode.prototype.toggle=function(){this.setExpanded(!this.getExpanded())};
+goog.ui.tree.BaseNode.prototype.expand=function(){this.setExpanded(!0)};goog.ui.tree.BaseNode.prototype.collapse=function(){this.setExpanded(!1)};goog.ui.tree.BaseNode.prototype.collapseChildren=function(){this.forEachChild(function(a){a.collapseAll()})};goog.ui.tree.BaseNode.prototype.collapseAll=function(){this.collapseChildren();this.collapse()};goog.ui.tree.BaseNode.prototype.expandChildren=function(){this.forEachChild(function(a){a.expandAll()})};
+goog.ui.tree.BaseNode.prototype.expandAll=function(){this.expandChildren();this.expand()};goog.ui.tree.BaseNode.prototype.reveal=function(){var a=this.getParent();a&&(a.setExpanded(!0),a.reveal())};goog.ui.tree.BaseNode.prototype.setIsUserCollapsible=function(a){(this.isUserCollapsible_=a)||this.expand();this.getElement()&&this.updateExpandIcon()};goog.ui.tree.BaseNode.prototype.isUserCollapsible=function(){return this.isUserCollapsible_};
+goog.ui.tree.BaseNode.prototype.toSafeHtml=function(){var a=this.getTree(),b=!a.getShowLines()||a==this.getParent()&&!a.getShowRootLines()?this.config_.cssChildrenNoLines:this.config_.cssChildren;a=this.getExpanded()&&this.hasChildren();b={"class":b,style:this.getLineStyle()};var c=[];a&&this.forEachChild(function(a){c.push(a.toSafeHtml())});a=goog.html.SafeHtml.create("div",b,c);return goog.html.SafeHtml.create("div",{"class":this.config_.cssItem,id:this.getId()},[this.getRowSafeHtml(),a])};
+goog.ui.tree.BaseNode.prototype.getPixelIndent_=function(){return Math.max(0,(this.getDepth()-1)*this.config_.indentWidth)};goog.ui.tree.BaseNode.prototype.getRowSafeHtml=function(){var a={};a["padding-"+(this.isRightToLeft()?"right":"left")]=this.getPixelIndent_()+"px";a={"class":this.getRowClassName(),style:a};var b=[this.getExpandIconSafeHtml(),this.getIconSafeHtml(),this.getLabelSafeHtml()];return goog.html.SafeHtml.create("div",a,b)};
+goog.ui.tree.BaseNode.prototype.getRowClassName=function(){var a=this.isSelected()?" "+this.config_.cssSelectedRow:"";return this.config_.cssTreeRow+a};goog.ui.tree.BaseNode.prototype.getLabelSafeHtml=function(){var a=goog.html.SafeHtml.create("span",{"class":this.config_.cssItemLabel,title:this.getToolTip()||null},this.getSafeHtml());return goog.html.SafeHtml.concat(a,goog.html.SafeHtml.create("span",{},this.getAfterLabelSafeHtml()))};goog.ui.tree.BaseNode.prototype.getAfterLabelHtml=function(){return goog.html.SafeHtml.unwrap(this.getAfterLabelSafeHtml())};
+goog.ui.tree.BaseNode.prototype.getAfterLabelSafeHtml=function(){return this.afterLabelHtml_};goog.ui.tree.BaseNode.prototype.setAfterLabelSafeHtml=function(a){this.afterLabelHtml_=a;var b=this.getAfterLabelElement();b&&goog.dom.safe.setInnerHtml(b,a)};goog.ui.tree.BaseNode.prototype.getIconSafeHtml=function(){return goog.html.SafeHtml.create("span",{style:{display:"inline-block"},"class":this.getCalculatedIconClass()})};goog.ui.tree.BaseNode.prototype.getCalculatedIconClass=goog.abstractMethod;
+goog.ui.tree.BaseNode.prototype.getExpandIconSafeHtml=function(){return goog.html.SafeHtml.create("span",{type:"expand",style:{display:"inline-block"},"class":this.getExpandIconClass()})};
+goog.ui.tree.BaseNode.prototype.getExpandIconClass=function(){var a=this.getTree(),b=!a.getShowLines()||a==this.getParent()&&!a.getShowRootLines(),c=this.config_,d=new goog.string.StringBuffer;d.append(c.cssTreeIcon," ",c.cssExpandTreeIcon," ");if(this.hasChildren()){var e=0;a.getShowExpandIcons()&&this.isUserCollapsible_&&(e=this.getExpanded()?2:1);b||(e=this.isLastSibling()?e+4:e+8);switch(e){case 1:d.append(c.cssExpandTreeIconPlus);break;case 2:d.append(c.cssExpandTreeIconMinus);break;case 4:d.append(c.cssExpandTreeIconL);
+break;case 5:d.append(c.cssExpandTreeIconLPlus);break;case 6:d.append(c.cssExpandTreeIconLMinus);break;case 8:d.append(c.cssExpandTreeIconT);break;case 9:d.append(c.cssExpandTreeIconTPlus);break;case 10:d.append(c.cssExpandTreeIconTMinus);break;default:d.append(c.cssExpandTreeIconBlank)}}else b?d.append(c.cssExpandTreeIconBlank):this.isLastSibling()?d.append(c.cssExpandTreeIconL):d.append(c.cssExpandTreeIconT);return d.toString()};
+goog.ui.tree.BaseNode.prototype.getLineStyle=function(){var a=this.getExpanded()&&this.hasChildren();return goog.html.SafeStyle.create({"background-position":this.getBackgroundPosition(),display:a?null:"none"})};goog.ui.tree.BaseNode.prototype.getBackgroundPosition=function(){return(this.isLastSibling()?"-100":(this.getDepth()-1)*this.config_.indentWidth)+"px 0"};
+goog.ui.tree.BaseNode.prototype.getElement=function(){var a=goog.ui.tree.BaseNode.superClass_.getElement.call(this);a||(a=this.getDomHelper().getElement(this.getId()),this.setElementInternal(a));return a};goog.ui.tree.BaseNode.prototype.getRowElement=function(){var a=this.getElement();return a?a.firstChild:null};goog.ui.tree.BaseNode.prototype.getExpandIconElement=function(){var a=this.getRowElement();return a?a.firstChild:null};
+goog.ui.tree.BaseNode.prototype.getIconElement=function(){var a=this.getRowElement();return a?a.childNodes[1]:null};goog.ui.tree.BaseNode.prototype.getLabelElement=function(){var a=this.getRowElement();return a&&a.lastChild?a.lastChild.previousSibling:null};goog.ui.tree.BaseNode.prototype.getAfterLabelElement=function(){var a=this.getRowElement();return a?a.lastChild:null};goog.ui.tree.BaseNode.prototype.getChildrenElement=function(){var a=this.getElement();return a?a.lastChild:null};
+goog.ui.tree.BaseNode.prototype.setIconClass=function(a){this.iconClass_=a;this.isInDocument()&&this.updateIcon_()};goog.ui.tree.BaseNode.prototype.getIconClass=function(){return this.iconClass_};goog.ui.tree.BaseNode.prototype.setExpandedIconClass=function(a){this.expandedIconClass_=a;this.isInDocument()&&this.updateIcon_()};goog.ui.tree.BaseNode.prototype.getExpandedIconClass=function(){return this.expandedIconClass_};goog.ui.tree.BaseNode.prototype.setText=function(a){this.setSafeHtml(goog.html.SafeHtml.htmlEscape(a))};
+goog.ui.tree.BaseNode.prototype.getText=function(){return goog.string.unescapeEntities(goog.html.SafeHtml.unwrap(this.html_))};goog.ui.tree.BaseNode.prototype.setSafeHtml=function(a){this.html_=a;var b=this.getLabelElement();b&&goog.dom.safe.setInnerHtml(b,a);(a=this.getTree())&&a.setNode(this)};goog.ui.tree.BaseNode.prototype.getHtml=function(){return goog.html.SafeHtml.unwrap(this.getSafeHtml())};goog.ui.tree.BaseNode.prototype.getSafeHtml=function(){return this.html_};
+goog.ui.tree.BaseNode.prototype.setToolTip=function(a){this.toolTip_=a;var b=this.getLabelElement();b&&(b.title=a)};goog.ui.tree.BaseNode.prototype.getToolTip=function(){return this.toolTip_};goog.ui.tree.BaseNode.prototype.updateRow=function(){var a=this.getRowElement();a&&(a.className=this.getRowClassName())};
+goog.ui.tree.BaseNode.prototype.updateExpandIcon=function(){var a=this.getExpandIconElement();a&&(a.className=this.getExpandIconClass());if(a=this.getChildrenElement())a.style.backgroundPosition=this.getBackgroundPosition()};goog.ui.tree.BaseNode.prototype.updateIcon_=function(){this.getIconElement().className=this.getCalculatedIconClass()};
+goog.ui.tree.BaseNode.prototype.onMouseDown=function(a){"expand"==a.target.getAttribute("type")&&this.hasChildren()?this.isUserCollapsible_&&this.toggle():(this.select(),this.updateRow())};goog.ui.tree.BaseNode.prototype.onClick_=goog.events.Event.preventDefault;goog.ui.tree.BaseNode.prototype.onDoubleClick_=function(a){"expand"==a.target.getAttribute("type")&&this.hasChildren()||this.isUserCollapsible_&&this.toggle()};
+goog.ui.tree.BaseNode.prototype.onKeyDown=function(a){var b=!0;switch(a.keyCode){case goog.events.KeyCodes.RIGHT:if(a.altKey)break;this.hasChildren()&&(this.getExpanded()?this.getFirstChild().select():this.setExpanded(!0));break;case goog.events.KeyCodes.LEFT:if(a.altKey)break;if(this.hasChildren()&&this.getExpanded()&&this.isUserCollapsible_)this.setExpanded(!1);else{var c=this.getParent(),d=this.getTree();c&&(d.getShowRootNode()||c!=d)&&c.select()}break;case goog.events.KeyCodes.DOWN:(c=this.getNextShownNode())&&
+c.select();break;case goog.events.KeyCodes.UP:(c=this.getPreviousShownNode())&&c.select();break;default:b=!1}b&&(a.preventDefault(),(d=this.getTree())&&d.clearTypeAhead());return b};goog.ui.tree.BaseNode.prototype.getLastShownDescendant=function(){return this.getExpanded()&&this.hasChildren()?this.getLastChild().getLastShownDescendant():this};
+goog.ui.tree.BaseNode.prototype.getNextShownNode=function(){if(this.hasChildren()&&this.getExpanded())return this.getFirstChild();for(var a=this,b;a!=this.getTree();){b=a.getNextSibling();if(null!=b)return b;a=a.getParent()}return null};goog.ui.tree.BaseNode.prototype.getPreviousShownNode=function(){var a=this.getPreviousSibling();if(null!=a)return a.getLastShownDescendant();a=this.getParent();var b=this.getTree();return!b.getShowRootNode()&&a==b||this==b?null:a};
+goog.ui.tree.BaseNode.prototype.getClientData=goog.ui.tree.BaseNode.prototype.getModel;goog.ui.tree.BaseNode.prototype.setClientData=goog.ui.tree.BaseNode.prototype.setModel;goog.ui.tree.BaseNode.prototype.getConfig=function(){return this.config_};goog.ui.tree.BaseNode.prototype.setTreeInternal=function(a){this.tree!=a&&(this.tree=a,a.setNode(this),this.forEachChild(function(b){b.setTreeInternal(a)}))};
+goog.ui.tree.BaseNode.defaultConfig={indentWidth:19,cssRoot:"goog-tree-root goog-tree-item",cssHideRoot:"goog-tree-hide-root",cssItem:"goog-tree-item",cssChildren:"goog-tree-children",cssChildrenNoLines:"goog-tree-children-nolines",cssTreeRow:"goog-tree-row",cssItemLabel:"goog-tree-item-label",cssTreeIcon:"goog-tree-icon",cssExpandTreeIcon:"goog-tree-expand-icon",cssExpandTreeIconPlus:"goog-tree-expand-icon-plus",cssExpandTreeIconMinus:"goog-tree-expand-icon-minus",cssExpandTreeIconTPlus:"goog-tree-expand-icon-tplus",
+cssExpandTreeIconTMinus:"goog-tree-expand-icon-tminus",cssExpandTreeIconLPlus:"goog-tree-expand-icon-lplus",cssExpandTreeIconLMinus:"goog-tree-expand-icon-lminus",cssExpandTreeIconT:"goog-tree-expand-icon-t",cssExpandTreeIconL:"goog-tree-expand-icon-l",cssExpandTreeIconBlank:"goog-tree-expand-icon-blank",cssExpandedFolderIcon:"goog-tree-expanded-folder-icon",cssCollapsedFolderIcon:"goog-tree-collapsed-folder-icon",cssFileIcon:"goog-tree-file-icon",cssExpandedRootIcon:"goog-tree-expanded-folder-icon",
+cssCollapsedRootIcon:"goog-tree-collapsed-folder-icon",cssSelectedRow:"selected"};goog.ui.tree.TreeNode=function(a,b,c){goog.ui.tree.BaseNode.call(this,a,b,c)};goog.inherits(goog.ui.tree.TreeNode,goog.ui.tree.BaseNode);goog.ui.tree.TreeNode.prototype.getTree=function(){if(this.tree)return this.tree;var a=this.getParent();return a&&(a=a.getTree())?(this.setTreeInternal(a),a):null};
+goog.ui.tree.TreeNode.prototype.getCalculatedIconClass=function(){var a=this.getExpanded(),b=this.getExpandedIconClass();if(a&&b)return b;b=this.getIconClass();if(!a&&b)return b;b=this.getConfig();if(this.hasChildren()){if(a&&b.cssExpandedFolderIcon)return b.cssTreeIcon+" "+b.cssExpandedFolderIcon;if(!a&&b.cssCollapsedFolderIcon)return b.cssTreeIcon+" "+b.cssCollapsedFolderIcon}else if(b.cssFileIcon)return b.cssTreeIcon+" "+b.cssFileIcon;return""};goog.structs={};goog.structs.getCount=function(a){return a.getCount&&"function"==typeof a.getCount?a.getCount():goog.isArrayLike(a)||goog.isString(a)?a.length:goog.object.getCount(a)};goog.structs.getValues=function(a){if(a.getValues&&"function"==typeof a.getValues)return a.getValues();if(goog.isString(a))return a.split("");if(goog.isArrayLike(a)){for(var b=[],c=a.length,d=0;d<c;d++)b.push(a[d]);return b}return goog.object.getValues(a)};
+goog.structs.getKeys=function(a){if(a.getKeys&&"function"==typeof a.getKeys)return a.getKeys();if(!a.getValues||"function"!=typeof a.getValues){if(goog.isArrayLike(a)||goog.isString(a)){var b=[];a=a.length;for(var c=0;c<a;c++)b.push(c);return b}return goog.object.getKeys(a)}};
+goog.structs.contains=function(a,b){return a.contains&&"function"==typeof a.contains?a.contains(b):a.containsValue&&"function"==typeof a.containsValue?a.containsValue(b):goog.isArrayLike(a)||goog.isString(a)?goog.array.contains(a,b):goog.object.containsValue(a,b)};goog.structs.isEmpty=function(a){return a.isEmpty&&"function"==typeof a.isEmpty?a.isEmpty():goog.isArrayLike(a)||goog.isString(a)?goog.array.isEmpty(a):goog.object.isEmpty(a)};
+goog.structs.clear=function(a){a.clear&&"function"==typeof a.clear?a.clear():goog.isArrayLike(a)?goog.array.clear(a):goog.object.clear(a)};goog.structs.forEach=function(a,b,c){if(a.forEach&&"function"==typeof a.forEach)a.forEach(b,c);else if(goog.isArrayLike(a)||goog.isString(a))goog.array.forEach(a,b,c);else for(var d=goog.structs.getKeys(a),e=goog.structs.getValues(a),f=e.length,g=0;g<f;g++)b.call(c,e[g],d&&d[g],a)};
+goog.structs.filter=function(a,b,c){if("function"==typeof a.filter)return a.filter(b,c);if(goog.isArrayLike(a)||goog.isString(a))return goog.array.filter(a,b,c);var d=goog.structs.getKeys(a),e=goog.structs.getValues(a),f=e.length;if(d){var g={};for(var h=0;h<f;h++)b.call(c,e[h],d[h],a)&&(g[d[h]]=e[h])}else for(g=[],h=0;h<f;h++)b.call(c,e[h],void 0,a)&&g.push(e[h]);return g};
+goog.structs.map=function(a,b,c){if("function"==typeof a.map)return a.map(b,c);if(goog.isArrayLike(a)||goog.isString(a))return goog.array.map(a,b,c);var d=goog.structs.getKeys(a),e=goog.structs.getValues(a),f=e.length;if(d){var g={};for(var h=0;h<f;h++)g[d[h]]=b.call(c,e[h],d[h],a)}else for(g=[],h=0;h<f;h++)g[h]=b.call(c,e[h],void 0,a);return g};
+goog.structs.some=function(a,b,c){if("function"==typeof a.some)return a.some(b,c);if(goog.isArrayLike(a)||goog.isString(a))return goog.array.some(a,b,c);for(var d=goog.structs.getKeys(a),e=goog.structs.getValues(a),f=e.length,g=0;g<f;g++)if(b.call(c,e[g],d&&d[g],a))return!0;return!1};
+goog.structs.every=function(a,b,c){if("function"==typeof a.every)return a.every(b,c);if(goog.isArrayLike(a)||goog.isString(a))return goog.array.every(a,b,c);for(var d=goog.structs.getKeys(a),e=goog.structs.getValues(a),f=e.length,g=0;g<f;g++)if(!b.call(c,e[g],d&&d[g],a))return!1;return!0};goog.structs.Trie=function(a){this.value_=void 0;this.childNodes_={};a&&this.setAll(a)};goog.structs.Trie.prototype.set=function(a,b){this.setOrAdd_(a,b,!1)};goog.structs.Trie.prototype.add=function(a,b){this.setOrAdd_(a,b,!0)};
+goog.structs.Trie.prototype.setOrAdd_=function(a,b,c){for(var d=this,e=0;e<a.length;e++){var f=a.charAt(e);d.childNodes_[f]||(d.childNodes_[f]=new goog.structs.Trie);d=d.childNodes_[f]}if(c&&void 0!==d.value_)throw Error('The collection already contains the key "'+a+'"');d.value_=b};goog.structs.Trie.prototype.setAll=function(a){var b=goog.structs.getKeys(a);a=goog.structs.getValues(a);for(var c=0;c<b.length;c++)this.set(b[c],a[c])};
+goog.structs.Trie.prototype.getChildNode_=function(a){for(var b=this,c=0;c<a.length;c++){var d=a.charAt(c);b=b.childNodes_[d];if(!b)return}return b};goog.structs.Trie.prototype.get=function(a){return(a=this.getChildNode_(a))?a.value_:void 0};goog.structs.Trie.prototype.getKeyAndPrefixes=function(a,b){var c=this,d={},e=b||0;void 0!==c.value_&&(d[e]=c.value_);for(;e<a.length;e++){var f=a.charAt(e);if(!(f in c.childNodes_))break;c=c.childNodes_[f];void 0!==c.value_&&(d[e]=c.value_)}return d};
+goog.structs.Trie.prototype.getValues=function(){var a=[];this.getValuesInternal_(a);return a};goog.structs.Trie.prototype.getValuesInternal_=function(a){void 0!==this.value_&&a.push(this.value_);for(var b in this.childNodes_)this.childNodes_[b].getValuesInternal_(a)};goog.structs.Trie.prototype.getKeys=function(a){var b=[];if(a){for(var c=this,d=0;d<a.length;d++){var e=a.charAt(d);if(!c.childNodes_[e])return[];c=c.childNodes_[e]}c.getKeysInternal_(a,b)}else this.getKeysInternal_("",b);return b};
+goog.structs.Trie.prototype.getKeysInternal_=function(a,b){void 0!==this.value_&&b.push(a);for(var c in this.childNodes_)this.childNodes_[c].getKeysInternal_(a+c,b)};goog.structs.Trie.prototype.containsKey=function(a){return void 0!==this.get(a)};goog.structs.Trie.prototype.containsPrefix=function(a){return 0==a.length?!this.isEmpty():!!this.getChildNode_(a)};
+goog.structs.Trie.prototype.containsValue=function(a){if(this.value_===a)return!0;for(var b in this.childNodes_)if(this.childNodes_[b].containsValue(a))return!0;return!1};goog.structs.Trie.prototype.clear=function(){this.childNodes_={};this.value_=void 0};
+goog.structs.Trie.prototype.remove=function(a){for(var b=this,c=[],d=0;d<a.length;d++){var e=a.charAt(d);if(!b.childNodes_[e])throw Error('The collection does not have the key "'+a+'"');c.push([b,e]);b=b.childNodes_[e]}a=b.value_;for(delete b.value_;0<c.length;)if(e=c.pop(),b=e[0],e=e[1],b.childNodes_[e].isEmpty())delete b.childNodes_[e];else break;return a};goog.structs.Trie.prototype.clone=function(){return new goog.structs.Trie(this)};goog.structs.Trie.prototype.getCount=function(){return goog.structs.getCount(this.getValues())};
+goog.structs.Trie.prototype.isEmpty=function(){return void 0===this.value_&&goog.object.isEmpty(this.childNodes_)};goog.ui.tree.TypeAhead=function(){this.nodeMap_=new goog.structs.Trie;this.buffer_="";this.matchingNodes_=this.matchingLabels_=null;this.matchingNodeIndex_=this.matchingLabelIndex_=0};goog.ui.tree.TypeAhead.Offset={DOWN:1,UP:-1};
+goog.ui.tree.TypeAhead.prototype.handleNavigation=function(a){var b=!1;switch(a.keyCode){case goog.events.KeyCodes.DOWN:case goog.events.KeyCodes.UP:a.ctrlKey&&(this.jumpTo_(a.keyCode==goog.events.KeyCodes.DOWN?goog.ui.tree.TypeAhead.Offset.DOWN:goog.ui.tree.TypeAhead.Offset.UP),b=!0);break;case goog.events.KeyCodes.BACKSPACE:a=this.buffer_.length-1;b=!0;0<a?(this.buffer_=this.buffer_.substring(0,a),this.jumpToLabel_(this.buffer_)):0==a?this.buffer_="":b=!1;break;case goog.events.KeyCodes.ESC:this.buffer_=
+"",b=!0}return b};goog.ui.tree.TypeAhead.prototype.handleTypeAheadChar=function(a){var b=!1;a.ctrlKey||a.altKey||(a=String.fromCharCode(a.charCode||a.keyCode).toLowerCase(),goog.string.isUnicodeChar(a)&&(" "!=a||this.buffer_)&&(this.buffer_+=a,b=this.jumpToLabel_(this.buffer_)));return b};
+goog.ui.tree.TypeAhead.prototype.setNodeInMap=function(a){var b=a.getText();if(b&&!goog.string.isEmptyOrWhitespace(goog.string.makeSafe(b))){b=b.toLowerCase();var c=this.nodeMap_.get(b);c?c.push(a):this.nodeMap_.set(b,[a])}};
+goog.ui.tree.TypeAhead.prototype.removeNodeFromMap=function(a){var b=a.getText();if(b&&!goog.string.isEmptyOrWhitespace(goog.string.makeSafe(b))){b=b.toLowerCase();var c=this.nodeMap_.get(b);if(c){for(var d=a.getChildCount(),e=0;e<d;e++)this.removeNodeFromMap(a.getChildAt(e));goog.array.remove(c,a);c.length||this.nodeMap_.remove(b)}}};
+goog.ui.tree.TypeAhead.prototype.jumpToLabel_=function(a){var b=!1;(a=this.nodeMap_.getKeys(a))&&a.length&&(this.matchingLabelIndex_=this.matchingNodeIndex_=0,b=this.nodeMap_.get(a[0]),b=this.selectMatchingNode_(b))&&(this.matchingLabels_=a);return b};
+goog.ui.tree.TypeAhead.prototype.jumpTo_=function(a){var b=!1,c=this.matchingLabels_;if(c){b=null;var d=!1;if(this.matchingNodes_){var e=this.matchingNodeIndex_+a;0<=e&&e<this.matchingNodes_.length?(this.matchingNodeIndex_=e,b=this.matchingNodes_):d=!0}b||(e=this.matchingLabelIndex_+a,0<=e&&e<c.length&&(this.matchingLabelIndex_=e),c.length>this.matchingLabelIndex_&&(b=this.nodeMap_.get(c[this.matchingLabelIndex_])),b&&b.length&&d&&(this.matchingNodeIndex_=a==goog.ui.tree.TypeAhead.Offset.UP?b.length-
+1:0));if(b=this.selectMatchingNode_(b))this.matchingLabels_=c}return b};goog.ui.tree.TypeAhead.prototype.selectMatchingNode_=function(a){if(a){if(this.matchingNodeIndex_<a.length){var b=a[this.matchingNodeIndex_];this.matchingNodes_=a}b&&(b.reveal(),b.select())}return!!b};goog.ui.tree.TypeAhead.prototype.clear=function(){this.buffer_=""};goog.ui.tree.TreeControl=function(a,b,c){goog.ui.tree.BaseNode.call(this,a,b,c);this.setExpandedInternal(!0);this.setSelectedInternal(!0);this.selectedItem_=this;this.typeAhead_=new goog.ui.tree.TypeAhead;this.focusHandler_=this.keyHandler_=null;this.logger_=goog.log.getLogger("this");this.focused_=!1;this.focusedNode_=null;this.showRootLines_=this.showRootNode_=this.showExpandIcons_=this.showLines_=!0;if(goog.userAgent.IE)try{document.execCommand("BackgroundImageCache",!1,!0)}catch(d){goog.log.warning(this.logger_,
+"Failed to enable background image cache")}};goog.inherits(goog.ui.tree.TreeControl,goog.ui.tree.BaseNode);goog.ui.tree.TreeControl.prototype.getTree=function(){return this};goog.ui.tree.TreeControl.prototype.getDepth=function(){return 0};goog.ui.tree.TreeControl.prototype.reveal=function(){};goog.ui.tree.TreeControl.prototype.handleFocus_=function(a){this.focused_=!0;goog.dom.classlist.add(goog.asserts.assert(this.getElement()),"focused");this.selectedItem_&&this.selectedItem_.select()};
+goog.ui.tree.TreeControl.prototype.handleBlur_=function(a){this.focused_=!1;goog.dom.classlist.remove(goog.asserts.assert(this.getElement()),"focused")};goog.ui.tree.TreeControl.prototype.hasFocus=function(){return this.focused_};goog.ui.tree.TreeControl.prototype.getExpanded=function(){return!this.showRootNode_||goog.ui.tree.TreeControl.superClass_.getExpanded.call(this)};
+goog.ui.tree.TreeControl.prototype.setExpanded=function(a){this.showRootNode_?goog.ui.tree.TreeControl.superClass_.setExpanded.call(this,a):this.setExpandedInternal(a)};goog.ui.tree.TreeControl.prototype.getExpandIconSafeHtml=function(){return goog.html.SafeHtml.EMPTY};goog.ui.tree.TreeControl.prototype.getIconElement=function(){var a=this.getRowElement();return a?a.firstChild:null};goog.ui.tree.TreeControl.prototype.getExpandIconElement=function(){return null};
+goog.ui.tree.TreeControl.prototype.updateExpandIcon=function(){};goog.ui.tree.TreeControl.prototype.getRowClassName=function(){return goog.ui.tree.TreeControl.superClass_.getRowClassName.call(this)+(this.showRootNode_?"":" "+this.getConfig().cssHideRoot)};
+goog.ui.tree.TreeControl.prototype.getCalculatedIconClass=function(){var a=this.getExpanded(),b=this.getExpandedIconClass();if(a&&b)return b;b=this.getIconClass();if(!a&&b)return b;b=this.getConfig();return a&&b.cssExpandedRootIcon?b.cssTreeIcon+" "+b.cssExpandedRootIcon:!a&&b.cssCollapsedRootIcon?b.cssTreeIcon+" "+b.cssCollapsedRootIcon:""};
+goog.ui.tree.TreeControl.prototype.setSelectedItem=function(a){if(this.selectedItem_!=a){var b=!1;this.selectedItem_&&(b=this.selectedItem_==this.focusedNode_,this.selectedItem_.setSelectedInternal(!1));if(this.selectedItem_=a)a.setSelectedInternal(!0),b&&a.select();this.dispatchEvent(goog.events.EventType.CHANGE)}};goog.ui.tree.TreeControl.prototype.getSelectedItem=function(){return this.selectedItem_};
+goog.ui.tree.TreeControl.prototype.setShowLines=function(a){this.showLines_!=a&&(this.showLines_=a,this.isInDocument()&&this.updateLinesAndExpandIcons_())};goog.ui.tree.TreeControl.prototype.getShowLines=function(){return this.showLines_};
+goog.ui.tree.TreeControl.prototype.updateLinesAndExpandIcons_=function(){function a(e){var f=e.getChildrenElement();if(f){var g=!c||b==e.getParent()&&!d?e.getConfig().cssChildrenNoLines:e.getConfig().cssChildren;f.className=g;if(f=e.getExpandIconElement())f.className=e.getExpandIconClass()}e.forEachChild(a)}var b=this,c=b.getShowLines(),d=b.getShowRootLines();a(this)};
+goog.ui.tree.TreeControl.prototype.setShowRootLines=function(a){this.showRootLines_!=a&&(this.showRootLines_=a,this.isInDocument()&&this.updateLinesAndExpandIcons_())};goog.ui.tree.TreeControl.prototype.getShowRootLines=function(){return this.showRootLines_};goog.ui.tree.TreeControl.prototype.setShowExpandIcons=function(a){this.showExpandIcons_!=a&&(this.showExpandIcons_=a,this.isInDocument()&&this.updateLinesAndExpandIcons_())};goog.ui.tree.TreeControl.prototype.getShowExpandIcons=function(){return this.showExpandIcons_};
+goog.ui.tree.TreeControl.prototype.setShowRootNode=function(a){if(this.showRootNode_!=a){this.showRootNode_=a;if(this.isInDocument()){var b=this.getRowElement();b&&(b.className=this.getRowClassName())}!a&&this.getSelectedItem()==this&&this.getFirstChild()&&this.setSelectedItem(this.getFirstChild())}};goog.ui.tree.TreeControl.prototype.getShowRootNode=function(){return this.showRootNode_};
+goog.ui.tree.TreeControl.prototype.initAccessibility=function(){goog.ui.tree.TreeControl.superClass_.initAccessibility.call(this);var a=this.getElement();goog.asserts.assert(a,"The DOM element for the tree cannot be null.");goog.a11y.aria.setRole(a,"tree");goog.a11y.aria.setState(a,"labelledby",this.getLabelElement().id)};
+goog.ui.tree.TreeControl.prototype.enterDocument=function(){goog.ui.tree.TreeControl.superClass_.enterDocument.call(this);var a=this.getElement();a.className=this.getConfig().cssRoot;a.setAttribute("hideFocus","true");this.attachEvents_();this.initAccessibility()};goog.ui.tree.TreeControl.prototype.exitDocument=function(){goog.ui.tree.TreeControl.superClass_.exitDocument.call(this);this.detachEvents_()};
+goog.ui.tree.TreeControl.prototype.attachEvents_=function(){var a=this.getElement();a.tabIndex=0;var b=this.keyHandler_=new goog.events.KeyHandler(a),c=this.focusHandler_=new goog.events.FocusHandler(a);this.getHandler().listen(c,goog.events.FocusHandler.EventType.FOCUSOUT,this.handleBlur_).listen(c,goog.events.FocusHandler.EventType.FOCUSIN,this.handleFocus_).listen(b,goog.events.KeyHandler.EventType.KEY,this.handleKeyEvent).listen(a,goog.events.EventType.MOUSEDOWN,this.handleMouseEvent_).listen(a,
+goog.events.EventType.CLICK,this.handleMouseEvent_).listen(a,goog.events.EventType.DBLCLICK,this.handleMouseEvent_)};goog.ui.tree.TreeControl.prototype.detachEvents_=function(){this.keyHandler_.dispose();this.keyHandler_=null;this.focusHandler_.dispose();this.focusHandler_=null};
+goog.ui.tree.TreeControl.prototype.handleMouseEvent_=function(a){goog.log.fine(this.logger_,"Received event "+a.type);var b=this.getNodeFromEvent_(a);if(b)switch(a.type){case goog.events.EventType.MOUSEDOWN:b.onMouseDown(a);break;case goog.events.EventType.CLICK:b.onClick_(a);break;case goog.events.EventType.DBLCLICK:b.onDoubleClick_(a)}};
+goog.ui.tree.TreeControl.prototype.handleKeyEvent=function(a){var b;(b=this.typeAhead_.handleNavigation(a)||this.selectedItem_&&this.selectedItem_.onKeyDown(a)||this.typeAhead_.handleTypeAheadChar(a))&&a.preventDefault();return b};goog.ui.tree.TreeControl.prototype.getNodeFromEvent_=function(a){for(var b=a.target;null!=b;){if(a=goog.ui.tree.BaseNode.allNodes[b.id])return a;if(b==this.getElement())break;b=b.parentNode}return null};
+goog.ui.tree.TreeControl.prototype.createNode=function(a){return new goog.ui.tree.TreeNode(a||goog.html.SafeHtml.EMPTY,this.getConfig(),this.getDomHelper())};goog.ui.tree.TreeControl.prototype.setNode=function(a){this.typeAhead_.setNodeInMap(a)};goog.ui.tree.TreeControl.prototype.removeNode=function(a){this.typeAhead_.removeNodeFromMap(a)};goog.ui.tree.TreeControl.prototype.clearTypeAhead=function(){this.typeAhead_.clear()};goog.ui.tree.TreeControl.defaultConfig=goog.ui.tree.BaseNode.defaultConfig;
+var Blockly={};Blockly.Blocks=Object(null);
+Blockly.utils={};Blockly.utils.removeAttribute=function(a,b){goog.userAgent.IE&&goog.userAgent.isVersion("10.0")?a.setAttribute(b,null):a.removeAttribute(b)};Blockly.utils.addClass=function(a,b){var c=a.getAttribute("class")||"";if(-1!=(" "+c+" ").indexOf(" "+b+" "))return!1;c&&(c+=" ");a.setAttribute("class",c+b);return!0};
+Blockly.utils.removeClass=function(a,b){var c=a.getAttribute("class");if(-1==(" "+c+" ").indexOf(" "+b+" "))return!1;c=c.split(/\s+/);for(var d=0;d<c.length;d++)c[d]&&c[d]!=b||(c.splice(d,1),d--);c.length?a.setAttribute("class",c.join(" ")):Blockly.utils.removeAttribute(a,"class");return!0};Blockly.utils.hasClass=function(a,b){return-1!=(" "+a.getAttribute("class")+" ").indexOf(" "+b+" ")};Blockly.utils.removeNode=function(a){return a&&a.parentNode?a.parentNode.removeChild(a):null};
+Blockly.utils.noEvent=function(a){a.preventDefault();a.stopPropagation()};Blockly.utils.isTargetInput=function(a){return"textarea"==a.target.type||"text"==a.target.type||"number"==a.target.type||"email"==a.target.type||"password"==a.target.type||"search"==a.target.type||"tel"==a.target.type||"url"==a.target.type||a.target.isContentEditable};
+Blockly.utils.getRelativeXY=function(a){var b=new goog.math.Coordinate(0,0),c=a.getAttribute("x");c&&(b.x=parseInt(c,10));if(c=a.getAttribute("y"))b.y=parseInt(c,10);if(c=(c=a.getAttribute("transform"))&&c.match(Blockly.utils.getRelativeXY.XY_REGEX_))b.x+=parseFloat(c[1]),c[3]&&(b.y+=parseFloat(c[3]));(a=a.getAttribute("style"))&&-1<a.indexOf("translate")&&((c=a.match(Blockly.utils.getRelativeXY.XY_2D_REGEX_))||(c=a.match(Blockly.utils.getRelativeXY.XY_3D_REGEX_)),c&&(b.x+=parseFloat(c[1]),c[3]&&
+(b.y+=parseFloat(c[3]))));return b};Blockly.utils.getInjectionDivXY_=function(a){for(var b=0,c=0;a;){var d=Blockly.utils.getRelativeXY(a);b+=d.x;c+=d.y;if(-1!=(" "+(a.getAttribute("class")||"")+" ").indexOf(" injectionDiv "))break;a=a.parentNode}return new goog.math.Coordinate(b,c)};Blockly.utils.getRelativeXY.XY_REGEX_=/translate\(\s*([-+\d.e]+)([ ,]\s*([-+\d.e]+)\s*\))?/;Blockly.utils.getRelativeXY.XY_3D_REGEX_=/transform:\s*translate3d\(\s*([-+\d.e]+)px([ ,]\s*([-+\d.e]+)\s*)px([ ,]\s*([-+\d.e]+)\s*)px\)?/;
+Blockly.utils.getRelativeXY.XY_2D_REGEX_=/transform:\s*translate\(\s*([-+\d.e]+)px([ ,]\s*([-+\d.e]+)\s*)px\)?/;Blockly.utils.createSvgElement=function(a,b,c){a=document.createElementNS(Blockly.SVG_NS,a);for(var d in b)a.setAttribute(d,b[d]);document.body.runtimeStyle&&(a.runtimeStyle=a.currentStyle=a.style);c&&c.appendChild(a);return a};Blockly.utils.isRightButton=function(a){return a.ctrlKey&&goog.userAgent.MAC?!0:2==a.button};
+Blockly.utils.mouseToSvg=function(a,b,c){var d=b.createSVGPoint();d.x=a.clientX;d.y=a.clientY;c||(c=b.getScreenCTM().inverse());return d.matrixTransform(c)};Blockly.utils.shortestStringLength=function(a){return a.length?a.reduce(function(a,c){return a.length<c.length?a:c}).length:0};
+Blockly.utils.commonWordPrefix=function(a,b){if(!a.length)return 0;if(1==a.length)return a[0].length;for(var c=0,d=b||Blockly.utils.shortestStringLength(a),e=0;e<d;e++){for(var f=a[0][e],g=1;g<a.length;g++)if(f!=a[g][e])return c;" "==f&&(c=e+1)}for(g=1;g<a.length;g++)if((f=a[g][e])&&" "!=f)return c;return d};
+Blockly.utils.commonWordSuffix=function(a,b){if(!a.length)return 0;if(1==a.length)return a[0].length;for(var c=0,d=b||Blockly.utils.shortestStringLength(a),e=0;e<d;e++){for(var f=a[0].substr(-e-1,1),g=1;g<a.length;g++)if(f!=a[g].substr(-e-1,1))return c;" "==f&&(c=e+1)}for(g=1;g<a.length;g++)if((f=a[g].charAt(a[g].length-e-1))&&" "!=f)return c;return d};Blockly.utils.tokenizeInterpolation=function(a){return Blockly.utils.tokenizeInterpolation_(a,!0)};
+Blockly.utils.replaceMessageReferences=function(a){if("string"!=typeof a)return a;a=Blockly.utils.tokenizeInterpolation_(a,!1);return a.length?a[0]:""};
+Blockly.utils.checkMessageReferences=function(a){for(var b=!0,c=Blockly.Msg,d=/%{(BKY_[A-Z][A-Z0-9_]*)}/gi,e=d.exec(a);e;){var f=e[1];f=f.toUpperCase();"BKY_"!=f.substr(0,4)?(console.log("WARNING: Unsupported message table prefix in %{"+e[1]+"}."),b=!1):void 0==c[f.substr(4)]&&(console.log("WARNING: No message string for %{"+e[1]+"}."),b=!1);a=a.substring(e.index+f.length+1);e=d.exec(a)}return b};
+Blockly.utils.tokenizeInterpolation_=function(a,b){var c=[],d=a.split("");d.push("");for(var e=0,f=[],g=null,h=0;h<d.length;h++){var k=d[h];0==e?"%"==k?((k=f.join(""))&&c.push(k),f.length=0,e=1):f.push(k):1==e?"%"==k?(f.push(k),e=0):b&&"0"<=k&&"9">=k?(e=2,g=k,(k=f.join(""))&&c.push(k),f.length=0):"{"==k?e=3:(f.push("%",k),e=0):2==e?"0"<=k&&"9">=k?g+=k:(c.push(parseInt(g,10)),h--,e=0):3==e&&(""==k?(f.splice(0,0,"%{"),h--,e=0):"}"!=k?f.push(k):(e=f.join(""),/[a-zA-Z][a-zA-Z0-9_]*/.test(e)?(k=e.toUpperCase(),
+(k=Blockly.utils.startsWith(k,"BKY_")?k.substring(4):null)&&k in Blockly.Msg?(e=Blockly.Msg[k],"string"==typeof e?Array.prototype.push.apply(c,Blockly.utils.tokenizeInterpolation_(e,b)):b?c.push(String(e)):c.push(e)):c.push("%{"+e+"}")):c.push("%{"+e+"}"),e=f.length=0))}(k=f.join(""))&&c.push(k);d=[];for(h=f.length=0;h<c.length;++h)"string"==typeof c[h]?f.push(c[h]):((k=f.join(""))&&d.push(k),f.length=0,d.push(c[h]));(k=f.join(""))&&d.push(k);f.length=0;return d};
+Blockly.utils.genUid=function(){for(var a=Blockly.utils.genUid.soup_.length,b=[],c=0;20>c;c++)b[c]=Blockly.utils.genUid.soup_.charAt(Math.random()*a);return b.join("")};Blockly.utils.genUid.soup_="!#$%()*+,-./:;=?@[]^_`{|}~ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";Blockly.utils.wrap=function(a,b){for(var c=a.split("\n"),d=0;d<c.length;d++)c[d]=Blockly.utils.wrapLine_(c[d],b);return c.join("\n")};
+Blockly.utils.wrapLine_=function(a,b){if(a.length<=b)return a;for(var c=a.trim().split(/\s+/),d=0;d<c.length;d++)c[d].length>b&&(b=c[d].length);d=-Infinity;var e=1;do{var f=d;var g=a;var h=[],k=c.length/e,l=1;for(d=0;d<c.length-1;d++)l<(d+1.5)/k?(l++,h[d]=!0):h[d]=!1;h=Blockly.utils.wrapMutate_(c,h,b);d=Blockly.utils.wrapScore_(c,h,b);a=Blockly.utils.wrapToText_(c,h);e++}while(d>f);return g};
+Blockly.utils.wrapScore_=function(a,b,c){for(var d=[0],e=[],f=0;f<a.length;f++)d[d.length-1]+=a[f].length,!0===b[f]?(d.push(0),e.push(a[f].charAt(a[f].length-1))):!1===b[f]&&d[d.length-1]++;a=Math.max.apply(Math,d);for(f=b=0;f<d.length;f++)b-=2*Math.pow(Math.abs(c-d[f]),1.5),b-=Math.pow(a-d[f],1.5),-1!=".?!".indexOf(e[f])?b+=c/3:-1!=",;)]}".indexOf(e[f])&&(b+=c/4);1<d.length&&d[d.length-1]<=d[d.length-2]&&(b+=.5);return b};
+Blockly.utils.wrapMutate_=function(a,b,c){for(var d=Blockly.utils.wrapScore_(a,b,c),e,f=0;f<b.length-1;f++)if(b[f]!=b[f+1]){var g=[].concat(b);g[f]=!g[f];g[f+1]=!g[f+1];var h=Blockly.utils.wrapScore_(a,g,c);h>d&&(d=h,e=g)}return e?Blockly.utils.wrapMutate_(a,e,c):b};Blockly.utils.wrapToText_=function(a,b){for(var c=[],d=0;d<a.length;d++)c.push(a[d]),void 0!==b[d]&&c.push(b[d]?"\n":" ");return c.join("")};
+Blockly.utils.is3dSupported=function(){if(void 0!==Blockly.utils.is3dSupported.cached_)return Blockly.utils.is3dSupported.cached_;if(!goog.global.getComputedStyle)return!1;var a=document.createElement("p"),b="none",c={webkitTransform:"-webkit-transform",OTransform:"-o-transform",msTransform:"-ms-transform",MozTransform:"-moz-transform",transform:"transform"};document.body.insertBefore(a,null);for(var d in c)if(void 0!==a.style[d]){a.style[d]="translate3d(1px,1px,1px)";b=goog.global.getComputedStyle(a);
+if(!b)return document.body.removeChild(a),!1;b=b.getPropertyValue(c[d])}document.body.removeChild(a);Blockly.utils.is3dSupported.cached_="none"!==b;return Blockly.utils.is3dSupported.cached_};Blockly.utils.insertAfter=function(a,b){var c=b.nextSibling,d=b.parentNode;if(!d)throw Error("Reference node has no parent.");c?d.insertBefore(a,c):d.appendChild(a)};
+Blockly.utils.runAfterPageLoad=function(a){if("object"!=typeof document)throw Error("Blockly.utils.runAfterPageLoad() requires browser document.");if("complete"==document.readyState)a();else var b=setInterval(function(){"complete"==document.readyState&&(clearInterval(b),a())},10)};Blockly.utils.setCssTransform=function(a,b){a.style.transform=b;a.style["-webkit-transform"]=b};
+Blockly.utils.getViewportBBox=function(){var a=goog.dom.getViewportSize(),b=goog.style.getViewportPageOffset(document);return{right:a.width+b.x,bottom:a.height+b.y,top:b.y,left:b.x}};Blockly.utils.startsWith=function(a,b){return 0==a.lastIndexOf(b,0)};Blockly.utils.arrayRemove=function(a,b){var c=a.indexOf(b);if(-1==c)return!1;a.splice(c,1);return!0};Blockly.utils.toRadians=function(a){return a*Math.PI/180};Blockly.utils.toDegrees=function(a){return 180*a/Math.PI};
+Blockly.utils.containsNode=function(a,b){return!!(a.compareDocumentPosition(b)&Node.DOCUMENT_POSITION_CONTAINED_BY)};Blockly.utils.getBlockTypeCounts=function(a,b){var c=Object.create(null),d=a.getDescendants(!0);if(b){var e=a.getNextBlock();e&&(e=d.indexOf(e),d.splice(e,d.length-e))}e=0;for(var f;f=d[e];e++)c[f.type]?c[f.type]++:c[f.type]=1;return c};
+Blockly.Touch={};Blockly.Touch.touchIdentifier_=null;Blockly.Touch.TOUCH_MAP={};
+goog.global.PointerEvent?Blockly.Touch.TOUCH_MAP={mousedown:["pointerdown"],mouseenter:["pointerenter"],mouseleave:["pointerleave"],mousemove:["pointermove"],mouseout:["pointerout"],mouseover:["pointerover"],mouseup:["pointerup","pointercancel"],touchend:["pointerup"],touchcancel:["pointercancel"]}:goog.events.BrowserFeature.TOUCH_ENABLED&&(Blockly.Touch.TOUCH_MAP={mousedown:["touchstart"],mousemove:["touchmove"],mouseup:["touchend","touchcancel"]});Blockly.longPid_=0;
+Blockly.longStart_=function(a,b){Blockly.longStop_();a.changedTouches&&1!=a.changedTouches.length||(Blockly.longPid_=setTimeout(function(){a.changedTouches&&(a.button=2,a.clientX=a.changedTouches[0].clientX,a.clientY=a.changedTouches[0].clientY);b&&b.handleRightClick(a)},Blockly.LONGPRESS))};Blockly.longStop_=function(){Blockly.longPid_&&(clearTimeout(Blockly.longPid_),Blockly.longPid_=0)};Blockly.Touch.clearTouchIdentifier=function(){Blockly.Touch.touchIdentifier_=null};
+Blockly.Touch.shouldHandleEvent=function(a){return!Blockly.Touch.isMouseOrTouchEvent(a)||Blockly.Touch.checkTouchIdentifier(a)};Blockly.Touch.getTouchIdentifierFromEvent=function(a){return void 0!=a.pointerId?a.pointerId:a.changedTouches&&a.changedTouches[0]&&void 0!==a.changedTouches[0].identifier&&null!==a.changedTouches[0].identifier?a.changedTouches[0].identifier:"mouse"};
+Blockly.Touch.checkTouchIdentifier=function(a){var b=Blockly.Touch.getTouchIdentifierFromEvent(a);return void 0!==Blockly.Touch.touchIdentifier_&&null!==Blockly.Touch.touchIdentifier_?Blockly.Touch.touchIdentifier_==b:"mousedown"==a.type||"touchstart"==a.type||"pointerdown"==a.type?(Blockly.Touch.touchIdentifier_=b,!0):!1};Blockly.Touch.setClientFromTouch=function(a){if(Blockly.utils.startsWith(a.type,"touch")){var b=a.changedTouches[0];a.clientX=b.clientX;a.clientY=b.clientY}};
+Blockly.Touch.isMouseOrTouchEvent=function(a){return Blockly.utils.startsWith(a.type,"touch")||Blockly.utils.startsWith(a.type,"mouse")||Blockly.utils.startsWith(a.type,"pointer")};Blockly.Touch.isTouchEvent=function(a){return Blockly.utils.startsWith(a.type,"touch")||Blockly.utils.startsWith(a.type,"pointer")};
+Blockly.Touch.splitEventByTouches=function(a){var b=[];if(a.changedTouches)for(var c=0;c<a.changedTouches.length;c++)b[c]={type:a.type,changedTouches:[a.changedTouches[c]],target:a.target,stopPropagation:function(){a.stopPropagation()},preventDefault:function(){a.preventDefault()}};else b.push(a);return b};Blockly.Events={};Blockly.Events.group_="";Blockly.Events.recordUndo=!0;Blockly.Events.disabled_=0;Blockly.Events.CREATE="create";Blockly.Events.BLOCK_CREATE=Blockly.Events.CREATE;Blockly.Events.DELETE="delete";Blockly.Events.BLOCK_DELETE=Blockly.Events.DELETE;Blockly.Events.CHANGE="change";Blockly.Events.BLOCK_CHANGE=Blockly.Events.CHANGE;Blockly.Events.MOVE="move";Blockly.Events.BLOCK_MOVE=Blockly.Events.MOVE;Blockly.Events.VAR_CREATE="var_create";Blockly.Events.VAR_DELETE="var_delete";
+Blockly.Events.VAR_RENAME="var_rename";Blockly.Events.UI="ui";Blockly.Events.COMMENT_CREATE="comment_create";Blockly.Events.COMMENT_DELETE="comment_delete";Blockly.Events.COMMENT_CHANGE="comment_change";Blockly.Events.COMMENT_MOVE="comment_move";Blockly.Events.FINISHED_LOADING="finished_loading";Blockly.Events.FIRE_QUEUE_=[];Blockly.Events.fire=function(a){Blockly.Events.isEnabled()&&(Blockly.Events.FIRE_QUEUE_.length||setTimeout(Blockly.Events.fireNow_,0),Blockly.Events.FIRE_QUEUE_.push(a))};
+Blockly.Events.fireNow_=function(){for(var a=Blockly.Events.filter(Blockly.Events.FIRE_QUEUE_,!0),b=Blockly.Events.FIRE_QUEUE_.length=0,c;c=a[b];b++){var d=Blockly.Workspace.getById(c.workspaceId);d&&d.fireChangeListener(c)}};
+Blockly.Events.filter=function(a,b){var c=a.slice();b||c.reverse();for(var d=[],e=Object.create(null),f=0,g;g=c[f];f++)if(!g.isNull()){var h=[g.type,g.blockId,g.workspaceId].join(" "),k=e[h],l=k?k.event:null;k?g.type==Blockly.Events.MOVE&&k.index==f-1?(l.newParentId=g.newParentId,l.newInputName=g.newInputName,l.newCoordinate=g.newCoordinate,k.index=f):g.type==Blockly.Events.CHANGE&&g.element==l.element&&g.name==l.name?l.newValue=g.newValue:g.type!=Blockly.Events.UI||"click"!=g.element||"commentOpen"!=
+l.element&&"mutatorOpen"!=l.element&&"warningOpen"!=l.element?(e[h]={event:g,index:1},d.push(g)):l.newValue=g.newValue:(e[h]={event:g,index:f},d.push(g))}c=d.filter(function(a){return!a.isNull()});b||c.reverse();for(f=1;g=c[f];f++)g.type==Blockly.Events.CHANGE&&"mutation"==g.element&&c.unshift(c.splice(f,1)[0]);return c};Blockly.Events.clearPendingUndo=function(){for(var a=0,b;b=Blockly.Events.FIRE_QUEUE_[a];a++)b.recordUndo=!1};Blockly.Events.disable=function(){Blockly.Events.disabled_++};
+Blockly.Events.enable=function(){Blockly.Events.disabled_--};Blockly.Events.isEnabled=function(){return 0==Blockly.Events.disabled_};Blockly.Events.getGroup=function(){return Blockly.Events.group_};Blockly.Events.setGroup=function(a){Blockly.Events.group_="boolean"==typeof a?a?Blockly.utils.genUid():"":a};Blockly.Events.getDescendantIds_=function(a){var b=[];a=a.getDescendants(!1);for(var c=0,d;d=a[c];c++)b[c]=d.id;return b};
+Blockly.Events.fromJson=function(a,b){switch(a.type){case Blockly.Events.CREATE:var c=new Blockly.Events.Create(null);break;case Blockly.Events.DELETE:c=new Blockly.Events.Delete(null);break;case Blockly.Events.CHANGE:c=new Blockly.Events.Change(null,"","","","");break;case Blockly.Events.MOVE:c=new Blockly.Events.Move(null);break;case Blockly.Events.VAR_CREATE:c=new Blockly.Events.VarCreate(null);break;case Blockly.Events.VAR_DELETE:c=new Blockly.Events.VarDelete(null);break;case Blockly.Events.VAR_RENAME:c=
+new Blockly.Events.VarRename(null,"");break;case Blockly.Events.UI:c=new Blockly.Events.Ui(null);break;case Blockly.Events.COMMENT_CREATE:c=new Blockly.Events.CommentCreate(null);break;case Blockly.Events.COMMENT_CHANGE:c=new Blockly.Events.CommentChange(null);break;case Blockly.Events.COMMENT_MOVE:c=new Blockly.Events.CommentMove(null);break;case Blockly.Events.COMMENT_DELETE:c=new Blockly.Events.CommentDelete(null);break;default:throw Error("Unknown event type.");}c.fromJson(a);c.workspaceId=b.id;
+return c};Blockly.Events.disableOrphans=function(a){if(a.type==Blockly.Events.MOVE||a.type==Blockly.Events.CREATE){var b=Blockly.Workspace.getById(a.workspaceId);if(a=b.getBlockById(a.blockId))if(a.getParent()&&!a.getParent().disabled){b=a.getDescendants(!1);a=0;for(var c;c=b[a];a++)c.setDisabled(!1)}else if((a.outputConnection||a.previousConnection)&&!b.isDragging()){do a.setDisabled(!0),a=a.getNextBlock();while(a)}}};
+Blockly.Events.Abstract=function(){this.workspaceId=void 0;this.group=Blockly.Events.group_;this.recordUndo=Blockly.Events.recordUndo};Blockly.Events.Abstract.prototype.toJson=function(){var a={type:this.type};this.group&&(a.group=this.group);return a};Blockly.Events.Abstract.prototype.fromJson=function(a){this.group=a.group};Blockly.Events.Abstract.prototype.isNull=function(){return!1};Blockly.Events.Abstract.prototype.run=function(a){};
+Blockly.Events.Abstract.prototype.getEventWorkspace_=function(){var a=Blockly.Workspace.getById(this.workspaceId);if(!a)throw Error("Workspace is null. Event must have been generated from real Blockly events.");return a};Blockly.Events.VarBase=function(a){Blockly.Events.VarBase.superClass_.constructor.call(this);this.varId=a.getId();this.workspaceId=a.workspace.id};goog.inherits(Blockly.Events.VarBase,Blockly.Events.Abstract);Blockly.Events.VarBase.prototype.toJson=function(){var a=Blockly.Events.VarBase.superClass_.toJson.call(this);a.varId=this.varId;return a};Blockly.Events.VarBase.prototype.fromJson=function(a){Blockly.Events.VarBase.superClass_.toJson.call(this);this.varId=a.varId};
+Blockly.Events.VarCreate=function(a){a&&(Blockly.Events.VarCreate.superClass_.constructor.call(this,a),this.varType=a.type,this.varName=a.name)};goog.inherits(Blockly.Events.VarCreate,Blockly.Events.VarBase);Blockly.Events.VarCreate.prototype.type=Blockly.Events.VAR_CREATE;Blockly.Events.VarCreate.prototype.toJson=function(){var a=Blockly.Events.VarCreate.superClass_.toJson.call(this);a.varType=this.varType;a.varName=this.varName;return a};
+Blockly.Events.VarCreate.prototype.fromJson=function(a){Blockly.Events.VarCreate.superClass_.fromJson.call(this,a);this.varType=a.varType;this.varName=a.varName};Blockly.Events.VarCreate.prototype.run=function(a){var b=this.getEventWorkspace_();a?b.createVariable(this.varName,this.varType,this.varId):b.deleteVariableById(this.varId)};Blockly.Events.VarDelete=function(a){a&&(Blockly.Events.VarDelete.superClass_.constructor.call(this,a),this.varType=a.type,this.varName=a.name)};
+goog.inherits(Blockly.Events.VarDelete,Blockly.Events.VarBase);Blockly.Events.VarDelete.prototype.type=Blockly.Events.VAR_DELETE;Blockly.Events.VarDelete.prototype.toJson=function(){var a=Blockly.Events.VarDelete.superClass_.toJson.call(this);a.varType=this.varType;a.varName=this.varName;return a};Blockly.Events.VarDelete.prototype.fromJson=function(a){Blockly.Events.VarDelete.superClass_.fromJson.call(this,a);this.varType=a.varType;this.varName=a.varName};
+Blockly.Events.VarDelete.prototype.run=function(a){var b=this.getEventWorkspace_();a?b.deleteVariableById(this.varId):b.createVariable(this.varName,this.varType,this.varId)};Blockly.Events.VarRename=function(a,b){a&&(Blockly.Events.VarRename.superClass_.constructor.call(this,a),this.oldName=a.name,this.newName=b)};goog.inherits(Blockly.Events.VarRename,Blockly.Events.VarBase);Blockly.Events.VarRename.prototype.type=Blockly.Events.VAR_RENAME;
+Blockly.Events.VarRename.prototype.toJson=function(){var a=Blockly.Events.VarRename.superClass_.toJson.call(this);a.oldName=this.oldName;a.newName=this.newName;return a};Blockly.Events.VarRename.prototype.fromJson=function(a){Blockly.Events.VarRename.superClass_.fromJson.call(this,a);this.oldName=a.oldName;this.newName=a.newName};Blockly.Events.VarRename.prototype.run=function(a){var b=this.getEventWorkspace_();a?b.renameVariableById(this.varId,this.newName):b.renameVariableById(this.varId,this.oldName)};
+Blockly.VariableMap=function(a){this.variableMap_={};this.workspace=a};Blockly.VariableMap.prototype.clear=function(){this.variableMap_=Object(null)};Blockly.VariableMap.prototype.renameVariable=function(a,b){var c=this.getVariable(b,a.type),d=this.workspace.getAllBlocks(!1);Blockly.Events.setGroup(!0);try{c&&c.getId()!=a.getId()?this.renameVariableWithConflict_(a,b,c,d):this.renameVariableAndUses_(a,b,d)}finally{Blockly.Events.setGroup(!1)}};
+Blockly.VariableMap.prototype.renameVariableById=function(a,b){var c=this.getVariableById(a);if(!c)throw Error("Tried to rename a variable that didn't exist. ID: "+a);this.renameVariable(c,b)};Blockly.VariableMap.prototype.renameVariableAndUses_=function(a,b,c){Blockly.Events.fire(new Blockly.Events.VarRename(a,b));a.name=b;for(b=0;b<c.length;b++)c[b].updateVarName(a)};
+Blockly.VariableMap.prototype.renameVariableWithConflict_=function(a,b,c,d){var e=a.type;b!=c.name&&this.renameVariableAndUses_(c,b,d);for(b=0;b<d.length;b++)d[b].renameVarById(a.getId(),c.getId());Blockly.Events.fire(new Blockly.Events.VarDelete(a));a=this.getVariablesOfType(e).indexOf(a);this.variableMap_[e].splice(a,1)};
+Blockly.VariableMap.prototype.createVariable=function(a,b,c){var d=this.getVariable(a,b);if(d){if(c&&d.getId()!=c)throw Error('Variable "'+a+'" is already in use and its id is "'+d.getId()+'" which conflicts with the passed in id, "'+c+'".');return d}if(c&&this.getVariableById(c))throw Error('Variable id, "'+c+'", is already in use.');c=c||Blockly.utils.genUid();b=b||"";d=new Blockly.VariableModel(this.workspace,a,b,c);this.variableMap_[b]?this.variableMap_[b].push(d):this.variableMap_[b]=[d];return d};
+Blockly.VariableMap.prototype.deleteVariable=function(a){for(var b=this.variableMap_[a.type],c=0,d;d=b[c];c++)if(d.getId()==a.getId()){b.splice(c,1);Blockly.Events.fire(new Blockly.Events.VarDelete(a));break}};
+Blockly.VariableMap.prototype.deleteVariableById=function(a){var b=this.getVariableById(a);if(b){var c=b.name,d=this.getVariableUsesById(a);a=0;for(var e;e=d[a];a++)if("procedures_defnoreturn"==e.type||"procedures_defreturn"==e.type){a=e.getFieldValue("NAME");c=Blockly.Msg.CANNOT_DELETE_VARIABLE_PROCEDURE.replace("%1",c).replace("%2",a);Blockly.alert(c);return}var f=this;1<d.length?(c=Blockly.Msg.DELETE_VARIABLE_CONFIRMATION.replace("%1",String(d.length)).replace("%2",c),Blockly.confirm(c,function(a){a&&
+f.deleteVariableInternal_(b,d)})):f.deleteVariableInternal_(b,d)}else console.warn("Can't delete non-existent variable: "+a)};Blockly.VariableMap.prototype.deleteVariableInternal_=function(a,b){var c=Blockly.Events.getGroup();c||Blockly.Events.setGroup(!0);try{for(var d=0;d<b.length;d++)b[d].dispose(!0,!1);this.deleteVariable(a)}finally{c||Blockly.Events.setGroup(!1)}};
+Blockly.VariableMap.prototype.getVariable=function(a,b){var c=this.variableMap_[b||""];if(c)for(var d=0,e;e=c[d];d++)if(Blockly.Names.equals(e.name,a))return e;return null};Blockly.VariableMap.prototype.getVariableById=function(a){for(var b=Object.keys(this.variableMap_),c=0;c<b.length;c++)for(var d=b[c],e=0,f;f=this.variableMap_[d][e];e++)if(f.getId()==a)return f;return null};Blockly.VariableMap.prototype.getVariablesOfType=function(a){return(a=this.variableMap_[a||""])?a.slice():[]};
+Blockly.VariableMap.prototype.getVariableTypes=function(){for(var a=Object.keys(this.variableMap_),b=!1,c=0;c<a.length;c++)""==a[c]&&(b=!0);b||a.push("");return a};Blockly.VariableMap.prototype.getAllVariables=function(){for(var a=[],b=Object.keys(this.variableMap_),c=0;c<b.length;c++)a=a.concat(this.variableMap_[b[c]]);return a};
+Blockly.VariableMap.prototype.getVariableUsesById=function(a){for(var b=[],c=this.workspace.getAllBlocks(!1),d=0;d<c.length;d++){var e=c[d].getVarModels();if(e)for(var f=0;f<e.length;f++)e[f].getId()==a&&b.push(c[d])}return b};Blockly.Xml={};Blockly.Xml.utils={};Blockly.Xml.utils.createElement=function(a){return document.createElement(a)};Blockly.Xml.utils.createTextNode=function(a){return document.createTextNode(a)};Blockly.Xml.utils.textToDomDocument=function(a){return(new DOMParser).parseFromString(a,"text/xml")};Blockly.Xml.utils.domToText=function(a){return(new XMLSerializer).serializeToString(a)};Blockly.Events.BlockBase=function(a){Blockly.Events.BlockBase.superClass_.constructor.call(this);this.blockId=a.id;this.workspaceId=a.workspace.id};goog.inherits(Blockly.Events.BlockBase,Blockly.Events.Abstract);Blockly.Events.BlockBase.prototype.toJson=function(){var a=Blockly.Events.BlockBase.superClass_.toJson.call(this);a.blockId=this.blockId;return a};Blockly.Events.BlockBase.prototype.fromJson=function(a){Blockly.Events.BlockBase.superClass_.toJson.call(this);this.blockId=a.blockId};
+Blockly.Events.Change=function(a,b,c,d,e){a&&(Blockly.Events.Change.superClass_.constructor.call(this,a),this.element=b,this.name=c,this.oldValue=d,this.newValue=e)};goog.inherits(Blockly.Events.Change,Blockly.Events.BlockBase);Blockly.Events.BlockChange=Blockly.Events.Change;Blockly.Events.Change.prototype.type=Blockly.Events.CHANGE;
+Blockly.Events.Change.prototype.toJson=function(){var a=Blockly.Events.Change.superClass_.toJson.call(this);a.element=this.element;this.name&&(a.name=this.name);a.newValue=this.newValue;return a};Blockly.Events.Change.prototype.fromJson=function(a){Blockly.Events.Change.superClass_.fromJson.call(this,a);this.element=a.element;this.name=a.name;this.newValue=a.newValue};Blockly.Events.Change.prototype.isNull=function(){return this.oldValue==this.newValue};
+Blockly.Events.Change.prototype.run=function(a){var b=this.getEventWorkspace_().getBlockById(this.blockId);if(b)switch(b.mutator&&b.mutator.setVisible(!1),a=a?this.newValue:this.oldValue,this.element){case "field":(b=b.getField(this.name))?(b.callValidator(a),b.setValue(a)):console.warn("Can't set non-existent field: "+this.name);break;case "comment":b.setCommentText(a||null);break;case "collapsed":b.setCollapsed(a);break;case "disabled":b.setDisabled(a);break;case "inline":b.setInputsInline(a);break;
+case "mutation":var c="";b.mutationToDom&&(c=(c=b.mutationToDom())&&Blockly.Xml.domToText(c));if(b.domToMutation){a=a||"<mutation></mutation>";var d=Blockly.Xml.textToDom("<xml>"+a+"</xml>");b.domToMutation(d.firstChild)}Blockly.Events.fire(new Blockly.Events.Change(b,"mutation",null,c,a));break;default:console.warn("Unknown change type: "+this.element)}else console.warn("Can't change non-existent block: "+this.blockId)};
+Blockly.Events.Create=function(a){a&&(Blockly.Events.Create.superClass_.constructor.call(this,a),this.xml=a.workspace.rendered?Blockly.Xml.blockToDomWithXY(a):Blockly.Xml.blockToDom(a),this.ids=Blockly.Events.getDescendantIds_(a))};goog.inherits(Blockly.Events.Create,Blockly.Events.BlockBase);Blockly.Events.BlockCreate=Blockly.Events.Create;Blockly.Events.Create.prototype.type=Blockly.Events.CREATE;
+Blockly.Events.Create.prototype.toJson=function(){var a=Blockly.Events.Create.superClass_.toJson.call(this);a.xml=Blockly.Xml.domToText(this.xml);a.ids=this.ids;return a};Blockly.Events.Create.prototype.fromJson=function(a){Blockly.Events.Create.superClass_.fromJson.call(this,a);this.xml=Blockly.Xml.textToDom("<xml>"+a.xml+"</xml>").firstChild;this.ids=a.ids};
+Blockly.Events.Create.prototype.run=function(a){var b=this.getEventWorkspace_();if(a)a=Blockly.Xml.utils.createElement("xml"),a.appendChild(this.xml),Blockly.Xml.domToWorkspace(a,b);else{a=0;for(var c;c=this.ids[a];a++){var d=b.getBlockById(c);d?d.dispose(!1,!1):c==this.blockId&&console.warn("Can't uncreate non-existent block: "+c)}}};
+Blockly.Events.Delete=function(a){if(a){if(a.getParent())throw Error("Connected blocks cannot be deleted.");Blockly.Events.Delete.superClass_.constructor.call(this,a);this.oldXml=a.workspace.rendered?Blockly.Xml.blockToDomWithXY(a):Blockly.Xml.blockToDom(a);this.ids=Blockly.Events.getDescendantIds_(a)}};goog.inherits(Blockly.Events.Delete,Blockly.Events.BlockBase);Blockly.Events.BlockDelete=Blockly.Events.Delete;Blockly.Events.Delete.prototype.type=Blockly.Events.DELETE;
+Blockly.Events.Delete.prototype.toJson=function(){var a=Blockly.Events.Delete.superClass_.toJson.call(this);a.ids=this.ids;return a};Blockly.Events.Delete.prototype.fromJson=function(a){Blockly.Events.Delete.superClass_.fromJson.call(this,a);this.ids=a.ids};
+Blockly.Events.Delete.prototype.run=function(a){var b=this.getEventWorkspace_();if(a){a=0;for(var c;c=this.ids[a];a++){var d=b.getBlockById(c);d?d.dispose(!1,!1):c==this.blockId&&console.warn("Can't delete non-existent block: "+c)}}else a=Blockly.Xml.utils.createElement("xml"),a.appendChild(this.oldXml),Blockly.Xml.domToWorkspace(a,b)};
+Blockly.Events.Move=function(a){a&&(Blockly.Events.Move.superClass_.constructor.call(this,a),a=this.currentLocation_(),this.oldParentId=a.parentId,this.oldInputName=a.inputName,this.oldCoordinate=a.coordinate)};goog.inherits(Blockly.Events.Move,Blockly.Events.BlockBase);Blockly.Events.BlockMove=Blockly.Events.Move;Blockly.Events.Move.prototype.type=Blockly.Events.MOVE;
+Blockly.Events.Move.prototype.toJson=function(){var a=Blockly.Events.Move.superClass_.toJson.call(this);this.newParentId&&(a.newParentId=this.newParentId);this.newInputName&&(a.newInputName=this.newInputName);this.newCoordinate&&(a.newCoordinate=Math.round(this.newCoordinate.x)+","+Math.round(this.newCoordinate.y));return a};
+Blockly.Events.Move.prototype.fromJson=function(a){Blockly.Events.Move.superClass_.fromJson.call(this,a);this.newParentId=a.newParentId;this.newInputName=a.newInputName;a.newCoordinate&&(a=a.newCoordinate.split(","),this.newCoordinate=new goog.math.Coordinate(parseFloat(a[0]),parseFloat(a[1])))};Blockly.Events.Move.prototype.recordNew=function(){var a=this.currentLocation_();this.newParentId=a.parentId;this.newInputName=a.inputName;this.newCoordinate=a.coordinate};
+Blockly.Events.Move.prototype.currentLocation_=function(){var a=Blockly.Workspace.getById(this.workspaceId).getBlockById(this.blockId),b={},c=a.getParent();if(c){if(b.parentId=c.id,a=c.getInputWithBlock(a))b.inputName=a.name}else b.coordinate=a.getRelativeToSurfaceXY();return b};Blockly.Events.Move.prototype.isNull=function(){return this.oldParentId==this.newParentId&&this.oldInputName==this.newInputName&&goog.math.Coordinate.equals(this.oldCoordinate,this.newCoordinate)};
+Blockly.Events.Move.prototype.run=function(a){var b=this.getEventWorkspace_(),c=b.getBlockById(this.blockId);if(c){var d=a?this.newParentId:this.oldParentId,e=a?this.newInputName:this.oldInputName;a=a?this.newCoordinate:this.oldCoordinate;var f=null;if(d&&(f=b.getBlockById(d),!f)){console.warn("Can't connect to non-existent block: "+d);return}c.getParent()&&c.unplug();if(a)e=c.getRelativeToSurfaceXY(),c.moveBy(a.x-e.x,a.y-e.y);else{c=c.outputConnection||c.previousConnection;if(e){if(b=f.getInput(e))var g=
+b.connection}else c.type==Blockly.PREVIOUS_STATEMENT&&(g=f.nextConnection);g?c.connect(g):console.warn("Can't connect to non-existent input: "+e)}}else console.warn("Can't move non-existent block: "+this.blockId)};
+Blockly.Events.FinishedLoading=function(a){this.workspaceId=a.id;this.group=Blockly.Events.group_;this.recordUndo=!1};goog.inherits(Blockly.Events.FinishedLoading,Blockly.Events.Abstract);Blockly.Events.FinishedLoading.prototype.type=Blockly.Events.FINISHED_LOADING;Blockly.Events.FinishedLoading.prototype.toJson=function(){var a={type:this.type};this.group&&(a.group=this.group);this.workspaceId&&(a.workspaceId=this.workspaceId);return a};
+Blockly.Events.FinishedLoading.prototype.fromJson=function(a){this.workspaceId=a.workspaceId;this.group=a.group};Blockly.Xml.workspaceToDom=function(a,b){var c=Blockly.Xml.utils.createElement("xml"),d=Blockly.Xml.variablesToDom(Blockly.Variables.allUsedVarModels(a));d.hasChildNodes()&&c.appendChild(d);var e=a.getTopComments(!0);d=0;for(var f;f=e[d];d++)c.appendChild(f.toXmlWithXY(b));e=a.getTopBlocks(!0);for(d=0;f=e[d];d++)c.appendChild(Blockly.Xml.blockToDomWithXY(f,b));return c};
+Blockly.Xml.variablesToDom=function(a){for(var b=Blockly.Xml.utils.createElement("variables"),c=0,d;d=a[c];c++){var e=Blockly.Xml.utils.createElement("variable");e.appendChild(Blockly.Xml.utils.createTextNode(d.name));e.setAttribute("type",d.type);e.setAttribute("id",d.getId());b.appendChild(e)}return b};
+Blockly.Xml.blockToDomWithXY=function(a,b){var c;a.workspace.RTL&&(c=a.workspace.getWidth());var d=Blockly.Xml.blockToDom(a,b),e=a.getRelativeToSurfaceXY();d.setAttribute("x",Math.round(a.workspace.RTL?c-e.x:e.x));d.setAttribute("y",Math.round(e.y));return d};
+Blockly.Xml.fieldToDomVariable_=function(a){null==a.getValue()&&(a.initModel(),a.getValue());var b=a.getVariable();if(!b)throw Error("Tried to serialize a variable field with no variable.");var c=Blockly.Xml.utils.createElement("field");c.appendChild(Blockly.Xml.utils.createTextNode(b.name));c.setAttribute("name",a.name);c.setAttribute("id",b.getId());c.setAttribute("variabletype",b.type);return c};
+Blockly.Xml.fieldToDom_=function(a){if(a.name&&a.EDITABLE){if(a.referencesVariables())return Blockly.Xml.fieldToDomVariable_(a);var b=Blockly.Xml.utils.createElement("field");b.appendChild(Blockly.Xml.utils.createTextNode(a.getValue()));b.setAttribute("name",a.name);return b}return null};Blockly.Xml.allFieldsToDom_=function(a,b){for(var c=0,d;d=a.inputList[c];c++)for(var e=0,f;f=d.fieldRow[e];e++)(f=Blockly.Xml.fieldToDom_(f))&&b.appendChild(f)};
+Blockly.Xml.blockToDom=function(a,b){var c=Blockly.Xml.utils.createElement(a.isShadow()?"shadow":"block");c.setAttribute("type",a.type);b||c.setAttribute("id",a.id);if(a.mutationToDom){var d=a.mutationToDom();d&&(d.hasChildNodes()||d.hasAttributes())&&c.appendChild(d)}Blockly.Xml.allFieldsToDom_(a,c);var e=a.getCommentText();e&&(d=Blockly.Xml.utils.createElement("comment"),d.appendChild(Blockly.Xml.utils.createTextNode(e)),"object"==typeof a.comment&&(d.setAttribute("pinned",a.comment.isVisible()),
+e=a.comment.getBubbleSize(),d.setAttribute("h",e.height),d.setAttribute("w",e.width)),c.appendChild(d));a.data&&(d=Blockly.Xml.utils.createElement("data"),d.appendChild(Blockly.Xml.utils.createTextNode(a.data)),c.appendChild(d));e=0;for(var f;f=a.inputList[e];e++){var g,h=!0;if(f.type!=Blockly.DUMMY_INPUT){var k=f.connection.targetBlock();f.type==Blockly.INPUT_VALUE?g=Blockly.Xml.utils.createElement("value"):f.type==Blockly.NEXT_STATEMENT&&(g=Blockly.Xml.utils.createElement("statement"));d=f.connection.getShadowDom();
+!d||k&&k.isShadow()||g.appendChild(Blockly.Xml.cloneShadow_(d));k&&(g.appendChild(Blockly.Xml.blockToDom(k,b)),h=!1);g.setAttribute("name",f.name);h||c.appendChild(g)}}a.inputsInlineDefault!=a.inputsInline&&c.setAttribute("inline",a.inputsInline);a.isCollapsed()&&c.setAttribute("collapsed",!0);a.disabled&&c.setAttribute("disabled",!0);a.isDeletable()||a.isShadow()||c.setAttribute("deletable",!1);a.isMovable()||a.isShadow()||c.setAttribute("movable",!1);a.isEditable()||c.setAttribute("editable",!1);
+if(e=a.getNextBlock())g=Blockly.Xml.utils.createElement("next"),g.appendChild(Blockly.Xml.blockToDom(e,b)),c.appendChild(g);d=a.nextConnection&&a.nextConnection.getShadowDom();!d||e&&e.isShadow()||g.appendChild(Blockly.Xml.cloneShadow_(d));return c};
+Blockly.Xml.cloneShadow_=function(a){for(var b=a=a.cloneNode(!0),c;b;)if(b.firstChild)b=b.firstChild;else{for(;b&&!b.nextSibling;)c=b,b=b.parentNode,3==c.nodeType&&""==c.data.trim()&&b.firstChild!=c&&Blockly.utils.removeNode(c);b&&(c=b,b=b.nextSibling,3==c.nodeType&&""==c.data.trim()&&Blockly.utils.removeNode(c))}return a};Blockly.Xml.domToText=function(a){return Blockly.Xml.utils.domToText(a)};
+Blockly.Xml.domToPrettyText=function(a){a=Blockly.Xml.domToText(a).split("<");for(var b="",c=1;c<a.length;c++){var d=a[c];"/"==d[0]&&(b=b.substring(2));a[c]=b+"<"+d;"/"!=d[0]&&"/>"!=d.slice(-2)&&(b+="  ")}a=a.join("\n");a=a.replace(/(<(\w+)\b[^>]*>[^\n]*)\n *<\/\2>/g,"$1</$2>");return a.replace(/^\n/,"")};
+Blockly.Xml.textToDom=function(a){a=Blockly.Xml.utils.textToDomDocument(a);if(!a||!a.documentElement||"xml"!=a.documentElement.nodeName.toLowerCase())throw TypeError("Blockly.Xml.textToDom expected an <xml> document.");return a.documentElement};Blockly.Xml.clearWorkspaceAndLoadFromXml=function(a,b){b.setResizesEnabled(!1);b.clear();var c=Blockly.Xml.domToWorkspace(a,b);b.setResizesEnabled(!0);return c};
+Blockly.Xml.domToWorkspace=function(a,b){if(a instanceof Blockly.Workspace){var c=a;a=b;b=c;console.warn("Deprecated call to Blockly.Xml.domToWorkspace, swap the arguments.")}var d;b.RTL&&(d=b.getWidth());c=[];Blockly.Field.startCache();var e=a.childNodes.length,f=Blockly.Events.getGroup();f||Blockly.Events.setGroup(!0);b.setResizesEnabled&&b.setResizesEnabled(!1);var g=!0;try{for(var h=0;h<e;h++){var k=a.childNodes[h],l=k.nodeName.toLowerCase();if("block"==l||"shadow"==l&&!Blockly.Events.recordUndo){var n=
+Blockly.Xml.domToBlock(k,b);c.push(n.id);var m=k.hasAttribute("x")?parseInt(k.getAttribute("x"),10):10,p=k.hasAttribute("y")?parseInt(k.getAttribute("y"),10):10;isNaN(m)||isNaN(p)||n.moveBy(b.RTL?d-m:m,p);g=!1}else{if("shadow"==l)throw TypeError("Shadow block cannot be a top-level block.");if("comment"==l)b.rendered?Blockly.WorkspaceCommentSvg.fromXml(k,b,d):Blockly.WorkspaceComment.fromXml(k,b);else if("variables"==l){if(g)Blockly.Xml.domToVariables(k,b);else throw Error("'variables' tag must exist once before block and shadow tag elements in the workspace XML, but it was found in another location.");
+g=!1}}}}finally{f||Blockly.Events.setGroup(!1),Blockly.Field.stopCache()}b.setResizesEnabled&&b.setResizesEnabled(!0);Blockly.Events.fire(new Blockly.Events.FinishedLoading(b));return c};
+Blockly.Xml.appendDomToWorkspace=function(a,b){if(b.hasOwnProperty("scale")){var c=Blockly.BlockSvg.TAB_WIDTH;try{Blockly.BlockSvg.TAB_WIDTH=0;var d=b.getBlocksBoundingBox()}finally{Blockly.BlockSvg.TAB_WIDTH=c}}c=Blockly.Xml.domToWorkspace(a,b);if(d&&d.height){var e=d.y+d.height;var f=d.x;var g=Infinity,h=Infinity;for(d=0;d<c.length;d++){var k=b.getBlockById(c[d]).getRelativeToSurfaceXY();k.y<h&&(h=k.y);k.x<g&&(g=k.x)}e=e-h+Blockly.BlockSvg.SEP_SPACE_Y;f-=g;var l;b.RTL&&(l=b.getWidth());for(d=0;d<
+c.length;d++)b.getBlockById(c[d]).moveBy(b.RTL?l-f:f,e)}return c};
+Blockly.Xml.domToBlock=function(a,b){if(a instanceof Blockly.Workspace){var c=a;a=b;b=c;console.warn("Deprecated call to Blockly.Xml.domToBlock, swap the arguments.")}Blockly.Events.disable();c=b.getAllVariables();try{var d=Blockly.Xml.domToBlockHeadless_(a,b),e=d.getDescendants(!1);if(b.rendered){d.setConnectionsHidden(!0);for(var f=e.length-1;0<=f;f--)e[f].initSvg();for(f=e.length-1;0<=f;f--)e[f].render(!1);setTimeout(function(){d.workspace&&d.setConnectionsHidden(!1)},1);d.updateDisabled();b.resizeContents()}else for(f=
+e.length-1;0<=f;f--)e[f].initModel()}finally{Blockly.Events.enable()}if(Blockly.Events.isEnabled()){e=Blockly.Variables.getAddedVariables(b,c);for(f=0;f<e.length;f++)Blockly.Events.fire(new Blockly.Events.VarCreate(e[f]));Blockly.Events.fire(new Blockly.Events.BlockCreate(d))}return d};
+Blockly.Xml.domToVariables=function(a,b){for(var c=0,d;d=a.childNodes[c];c++)if(d.nodeType==Element.ELEMENT_NODE){var e=d.getAttribute("type"),f=d.getAttribute("id");d=d.textContent;if(null==e)throw Error("Variable with id, "+f+" is without a type");b.createVariable(d,e,f)}};
+Blockly.Xml.domToBlockHeadless_=function(a,b){var c=null,d=a.getAttribute("type");if(!d)throw TypeError("Block type unspecified: "+a.outerHTML);var e=a.getAttribute("id");c=b.newBlock(d,e);var f=null;e=0;for(var g;g=a.childNodes[e];e++)if(3!=g.nodeType){for(var h=f=null,k=0,l;l=g.childNodes[k];k++)1==l.nodeType&&("block"==l.nodeName.toLowerCase()?f=l:"shadow"==l.nodeName.toLowerCase()&&(h=l));!f&&h&&(f=h);k=g.getAttribute("name");switch(g.nodeName.toLowerCase()){case "mutation":c.domToMutation&&(c.domToMutation(g),
+c.initSvg&&c.initSvg());break;case "comment":c.setCommentText(g.textContent);var n=g.getAttribute("pinned");n&&!c.isInFlyout&&setTimeout(function(){c.comment&&c.comment.setVisible&&c.comment.setVisible("true"==n)},1);f=parseInt(g.getAttribute("w"),10);g=parseInt(g.getAttribute("h"),10);!isNaN(f)&&!isNaN(g)&&c.comment&&c.comment.setVisible&&c.comment.setBubbleSize(f,g);break;case "data":c.data=g.textContent;break;case "title":case "field":Blockly.Xml.domToField_(c,k,g);break;case "value":case "statement":g=
+c.getInput(k);if(!g){console.warn("Ignoring non-existent input "+k+" in block "+d);break}h&&g.connection.setShadowDom(h);if(f)if(f=Blockly.Xml.domToBlockHeadless_(f,b),f.outputConnection)g.connection.connect(f.outputConnection);else if(f.previousConnection)g.connection.connect(f.previousConnection);else throw TypeError("Child block does not have output or previous statement.");break;case "next":h&&c.nextConnection&&c.nextConnection.setShadowDom(h);if(f){if(!c.nextConnection)throw TypeError("Next statement does not exist.");
+if(c.nextConnection.isConnected())throw TypeError("Next statement is already connected.");f=Blockly.Xml.domToBlockHeadless_(f,b);if(!f.previousConnection)throw TypeError("Next block does not have previous statement.");c.nextConnection.connect(f.previousConnection)}break;default:console.warn("Ignoring unknown tag: "+g.nodeName)}}(e=a.getAttribute("inline"))&&c.setInputsInline("true"==e);(e=a.getAttribute("disabled"))&&c.setDisabled("true"==e||"disabled"==e);(e=a.getAttribute("deletable"))&&c.setDeletable("true"==
+e);(e=a.getAttribute("movable"))&&c.setMovable("true"==e);(e=a.getAttribute("editable"))&&c.setEditable("true"==e);(e=a.getAttribute("collapsed"))&&c.setCollapsed("true"==e);if("shadow"==a.nodeName.toLowerCase()){d=c.getChildren(!1);for(e=0;g=d[e];e++)if(!g.isShadow())throw TypeError("Shadow block not allowed non-shadow child.");if(c.getVarModels().length)throw TypeError("Shadow blocks cannot have variable references.");c.setShadow(!0)}return c};
+Blockly.Xml.domToFieldVariable_=function(a,b,c,d){var e=b.getAttribute("variabletype")||"";"''"==e&&(e="");a=Blockly.Variables.getOrCreateVariablePackage(a,b.id,c,e);if(null!=e&&e!==a.type)throw Error("Serialized variable type with id '"+a.getId()+"' had type "+a.type+", and does not match variable field that references it: "+Blockly.Xml.domToText(b)+".");d.setValue(a.getId())};
+Blockly.Xml.domToField_=function(a,b,c){var d=a.getField(b);d?(a=a.workspace,b=c.textContent,d.referencesVariables()?Blockly.Xml.domToFieldVariable_(a,c,b,d):d.setValue(b)):console.warn("Ignoring non-existent field "+b+" in block "+a.type)};Blockly.Xml.deleteNext=function(a){for(var b=0,c;c=a.childNodes[b];b++)if("next"==c.nodeName.toLowerCase()){a.removeChild(c);break}};goog.global.Blockly||(goog.global.Blockly={});goog.global.Blockly.Xml||(goog.global.Blockly.Xml={});
+goog.global.Blockly.Xml.domToText=Blockly.Xml.domToText;goog.global.Blockly.Xml.domToWorkspace=Blockly.Xml.domToWorkspace;goog.global.Blockly.Xml.textToDom=Blockly.Xml.textToDom;goog.global.Blockly.Xml.workspaceToDom=Blockly.Xml.workspaceToDom;Blockly.Events.CommentBase=function(a){this.commentId=a.id;this.workspaceId=a.workspace.id;this.group=Blockly.Events.group_;this.recordUndo=Blockly.Events.recordUndo};goog.inherits(Blockly.Events.CommentBase,Blockly.Events.Abstract);Blockly.Events.CommentBase.prototype.toJson=function(){var a={type:this.type};this.group&&(a.group=this.group);this.commentId&&(a.commentId=this.commentId);return a};Blockly.Events.CommentBase.prototype.fromJson=function(a){this.commentId=a.commentId;this.group=a.group};
+Blockly.Events.CommentChange=function(a,b,c){a&&(Blockly.Events.CommentChange.superClass_.constructor.call(this,a),this.oldContents_=b,this.newContents_=c)};goog.inherits(Blockly.Events.CommentChange,Blockly.Events.CommentBase);Blockly.Events.CommentChange.prototype.type=Blockly.Events.COMMENT_CHANGE;Blockly.Events.CommentChange.prototype.toJson=function(){var a=Blockly.Events.CommentChange.superClass_.toJson.call(this);a.newContents=this.newContents_;return a};
+Blockly.Events.CommentChange.prototype.fromJson=function(a){Blockly.Events.CommentChange.superClass_.fromJson.call(this,a);this.newContents_=a.newValue};Blockly.Events.CommentChange.prototype.isNull=function(){return this.oldContents_==this.newContents_};Blockly.Events.CommentChange.prototype.run=function(a){var b=this.getEventWorkspace_().getCommentById(this.commentId);b?b.setContent(a?this.newContents_:this.oldContents_):console.warn("Can't change non-existent comment: "+this.commentId)};
+Blockly.Events.CommentCreate=function(a){a&&(Blockly.Events.CommentCreate.superClass_.constructor.call(this,a),this.xml=a.toXmlWithXY())};goog.inherits(Blockly.Events.CommentCreate,Blockly.Events.CommentBase);Blockly.Events.CommentCreate.prototype.type=Blockly.Events.COMMENT_CREATE;Blockly.Events.CommentCreate.prototype.toJson=function(){var a=Blockly.Events.CommentCreate.superClass_.toJson.call(this);a.xml=Blockly.Xml.domToText(this.xml);return a};
+Blockly.Events.CommentCreate.prototype.fromJson=function(a){Blockly.Events.CommentCreate.superClass_.fromJson.call(this,a);this.xml=Blockly.Xml.textToDom("<xml>"+a.xml+"</xml>").firstChild};Blockly.Events.CommentCreate.prototype.run=function(a){Blockly.Events.CommentCreateDeleteHelper(this,a)};
+Blockly.Events.CommentCreateDeleteHelper=function(a,b){var c=a.getEventWorkspace_();if(b){var d=Blockly.Xml.utils.createElement("xml");d.appendChild(a.xml);Blockly.Xml.domToWorkspace(d,c)}else(c=c.getCommentById(a.commentId))?c.dispose(!1,!1):console.warn("Can't uncreate non-existent comment: "+a.commentId)};Blockly.Events.CommentDelete=function(a){a&&(Blockly.Events.CommentDelete.superClass_.constructor.call(this,a),this.xml=a.toXmlWithXY())};goog.inherits(Blockly.Events.CommentDelete,Blockly.Events.CommentBase);
+Blockly.Events.CommentDelete.prototype.type=Blockly.Events.COMMENT_DELETE;Blockly.Events.CommentDelete.prototype.toJson=function(){return Blockly.Events.CommentDelete.superClass_.toJson.call(this)};Blockly.Events.CommentDelete.prototype.fromJson=function(a){Blockly.Events.CommentDelete.superClass_.fromJson.call(this,a)};Blockly.Events.CommentDelete.prototype.run=function(a){Blockly.Events.CommentCreateDeleteHelper(this,!a)};
+Blockly.Events.CommentMove=function(a){a&&(Blockly.Events.CommentMove.superClass_.constructor.call(this,a),this.comment_=a,this.oldCoordinate_=a.getXY(),this.newCoordinate_=null)};goog.inherits(Blockly.Events.CommentMove,Blockly.Events.CommentBase);Blockly.Events.CommentMove.prototype.recordNew=function(){if(!this.comment_)throw Error("Tried to record the new position of a comment on the same event twice.");this.newCoordinate_=this.comment_.getXY();this.comment_=null};
+Blockly.Events.CommentMove.prototype.type=Blockly.Events.COMMENT_MOVE;Blockly.Events.CommentMove.prototype.setOldCoordinate=function(a){this.oldCoordinate_=a};Blockly.Events.CommentMove.prototype.toJson=function(){var a=Blockly.Events.CommentMove.superClass_.toJson.call(this);this.newCoordinate_&&(a.newCoordinate=Math.round(this.newCoordinate_.x)+","+Math.round(this.newCoordinate_.y));return a};
+Blockly.Events.CommentMove.prototype.fromJson=function(a){Blockly.Events.CommentMove.superClass_.fromJson.call(this,a);a.newCoordinate&&(a=a.newCoordinate.split(","),this.newCoordinate_=new goog.math.Coordinate(parseFloat(a[0]),parseFloat(a[1])))};Blockly.Events.CommentMove.prototype.isNull=function(){return goog.math.Coordinate.equals(this.oldCoordinate_,this.newCoordinate_)};
+Blockly.Events.CommentMove.prototype.run=function(a){var b=this.getEventWorkspace_().getCommentById(this.commentId);if(b){a=a?this.newCoordinate_:this.oldCoordinate_;var c=b.getXY();b.moveBy(a.x-c.x,a.y-c.y)}else console.warn("Can't move non-existent comment: "+this.commentId)};Blockly.WorkspaceComment=function(a,b,c,d,e){this.id=e&&!a.getCommentById(e)?e:Blockly.utils.genUid();a.addTopComment(this);this.xy_=new goog.math.Coordinate(0,0);this.height_=c;this.width_=d;this.workspace=a;this.RTL=a.RTL;this.movable_=this.deletable_=!0;this.content_=b;this.isComment=!0;Blockly.WorkspaceComment.fireCreateEvent(this)};
+Blockly.WorkspaceComment.prototype.dispose=function(){this.workspace&&(Blockly.Events.isEnabled()&&Blockly.Events.fire(new Blockly.Events.CommentDelete(this)),this.workspace.removeTopComment(this),this.workspace=null)};Blockly.WorkspaceComment.prototype.getHeight=function(){return this.height_};Blockly.WorkspaceComment.prototype.setHeight=function(a){this.height_=a};Blockly.WorkspaceComment.prototype.getWidth=function(){return this.width_};
+Blockly.WorkspaceComment.prototype.setWidth=function(a){this.width_=a};Blockly.WorkspaceComment.prototype.getXY=function(){return this.xy_.clone()};Blockly.WorkspaceComment.prototype.moveBy=function(a,b){var c=new Blockly.Events.CommentMove(this);this.xy_.translate(a,b);c.recordNew();Blockly.Events.fire(c)};Blockly.WorkspaceComment.prototype.isDeletable=function(){return this.deletable_&&!(this.workspace&&this.workspace.options.readOnly)};
+Blockly.WorkspaceComment.prototype.setDeletable=function(a){this.deletable_=a};Blockly.WorkspaceComment.prototype.isMovable=function(){return this.movable_&&!(this.workspace&&this.workspace.options.readOnly)};Blockly.WorkspaceComment.prototype.setMovable=function(a){this.movable_=a};Blockly.WorkspaceComment.prototype.getContent=function(){return this.content_};
+Blockly.WorkspaceComment.prototype.setContent=function(a){this.content_!=a&&(Blockly.Events.fire(new Blockly.Events.CommentChange(this,this.content_,a)),this.content_=a)};Blockly.WorkspaceComment.prototype.toXmlWithXY=function(a){a=this.toXml(a);a.setAttribute("x",Math.round(this.xy_.x));a.setAttribute("y",Math.round(this.xy_.y));a.setAttribute("h",this.height_);a.setAttribute("w",this.width_);return a};
+Blockly.WorkspaceComment.prototype.toXml=function(a){var b=Blockly.Xml.utils.createElement("comment");a||b.setAttribute("id",this.id);b.textContent=this.getContent();return b};Blockly.WorkspaceComment.fireCreateEvent=function(a){if(Blockly.Events.isEnabled()){var b=Blockly.Events.getGroup();b||Blockly.Events.setGroup(!0);try{Blockly.Events.fire(new Blockly.Events.CommentCreate(a))}finally{b||Blockly.Events.setGroup(!1)}}};
+Blockly.WorkspaceComment.fromXml=function(a,b){var c=Blockly.WorkspaceComment.parseAttributes(a);c=new Blockly.WorkspaceComment(b,c.content,c.h,c.w,c.id);var d=parseInt(a.getAttribute("x"),10),e=parseInt(a.getAttribute("y"),10);isNaN(d)||isNaN(e)||c.moveBy(d,e);Blockly.WorkspaceComment.fireCreateEvent(c);return c};
+Blockly.WorkspaceComment.parseAttributes=function(a){var b=a.getAttribute("h"),c=a.getAttribute("w");return{id:a.getAttribute("id"),h:b?parseInt(b,10):100,w:c?parseInt(c,10):100,x:parseInt(a.getAttribute("x"),10),y:parseInt(a.getAttribute("y"),10),content:a.textContent}};Blockly.Workspace=function(a){this.id=Blockly.utils.genUid();Blockly.Workspace.WorkspaceDB_[this.id]=this;this.options=a||{};this.RTL=!!this.options.RTL;this.horizontalLayout=!!this.options.horizontalLayout;this.toolboxPosition=this.options.toolboxPosition;this.topBlocks_=[];this.topComments_=[];this.commentDB_=Object.create(null);this.listeners_=[];this.undoStack_=[];this.redoStack_=[];this.blockDB_=Object.create(null);this.typedBlocksDB_=Object.create(null);this.variableMap_=new Blockly.VariableMap(this);
+this.potentialVariableMap_=null};Blockly.Workspace.prototype.rendered=!1;Blockly.Workspace.prototype.isClearing=!1;Blockly.Workspace.prototype.MAX_UNDO=1024;Blockly.Workspace.prototype.dispose=function(){this.listeners_.length=0;this.clear();delete Blockly.Workspace.WorkspaceDB_[this.id]};Blockly.Workspace.SCAN_ANGLE=3;
+Blockly.Workspace.prototype.sortObjects_=function(a,b){var c=a.getRelativeToSurfaceXY(),d=b.getRelativeToSurfaceXY();return c.y+Blockly.Workspace.prototype.sortObjects_.offset*c.x-(d.y+Blockly.Workspace.prototype.sortObjects_.offset*d.x)};Blockly.Workspace.prototype.addTopBlock=function(a){this.topBlocks_.push(a)};Blockly.Workspace.prototype.removeTopBlock=function(a){if(!Blockly.utils.arrayRemove(this.topBlocks_,a))throw Error("Block not present in workspace's list of top-most blocks.");};
+Blockly.Workspace.prototype.getTopBlocks=function(a){var b=[].concat(this.topBlocks_);a&&1<b.length&&(this.sortObjects_.offset=Math.sin(Blockly.utils.toRadians(Blockly.Workspace.SCAN_ANGLE)),this.RTL&&(this.sortObjects_.offset*=-1),b.sort(this.sortObjects_));return b};Blockly.Workspace.prototype.addTypedBlock=function(a){this.typedBlocksDB_[a.type]||(this.typedBlocksDB_[a.type]=[]);this.typedBlocksDB_[a.type].push(a)};
+Blockly.Workspace.prototype.removeTypedBlock=function(a){this.typedBlocksDB_[a.type].splice(this.typedBlocksDB_[a.type].indexOf(a),1);this.typedBlocksDB_[a.type].length||delete this.typedBlocksDB_[a.type]};
+Blockly.Workspace.prototype.getBlocksByType=function(a,b){if(!this.typedBlocksDB_[a])return[];var c=this.typedBlocksDB_[a].slice(0);b&&1<c.length&&(this.sortObjects_.offset=Math.sign(Blockly.utils.toRadians(Blockly.Workspace.SCAN_ANGLE)),this.RTL&&(this.sortObjects_.offset*=-1),c.sort(this.sortObjects_));return c};
+Blockly.Workspace.prototype.addTopComment=function(a){this.topComments_.push(a);this.commentDB_[a.id]&&console.warn('Overriding an existing comment on this workspace, with id "'+a.id+'"');this.commentDB_[a.id]=a};Blockly.Workspace.prototype.removeTopComment=function(a){if(!Blockly.utils.arrayRemove(this.topComments_,a))throw Error("Comment not present in workspace's list of top-most comments.");delete this.commentDB_[a.id]};
+Blockly.Workspace.prototype.getTopComments=function(a){var b=[].concat(this.topComments_);a&&1<b.length&&(this.sortObjects_.offset=Math.sin(Blockly.utils.toRadians(Blockly.Workspace.SCAN_ANGLE)),this.RTL&&(this.sortObjects_.offset*=-1),b.sort(this.sortObjects_));return b};
+Blockly.Workspace.prototype.getAllBlocks=function(a){if(a){a=this.getTopBlocks(!0);for(var b=[],c=0;c<a.length;c++)b.push.apply(b,a[c].getDescendants(!0))}else for(b=this.getTopBlocks(!1),c=0;c<b.length;c++)b.push.apply(b,b[c].getChildren(!1));return b.filter(function(a){return!a.isInsertionMarker()})};
+Blockly.Workspace.prototype.clear=function(){this.isClearing=!0;try{var a=Blockly.Events.getGroup();for(a||Blockly.Events.setGroup(!0);this.topBlocks_.length;)this.topBlocks_[0].dispose();for(;this.topComments_.length;)this.topComments_[this.topComments_.length-1].dispose();a||Blockly.Events.setGroup(!1);this.variableMap_.clear();this.potentialVariableMap_&&this.potentialVariableMap_.clear()}finally{this.isClearing=!1}};
+Blockly.Workspace.prototype.renameVariableById=function(a,b){this.variableMap_.renameVariableById(a,b)};Blockly.Workspace.prototype.createVariable=function(a,b,c){return this.variableMap_.createVariable(a,b,c)};Blockly.Workspace.prototype.getVariableUsesById=function(a){return this.variableMap_.getVariableUsesById(a)};Blockly.Workspace.prototype.deleteVariableById=function(a){this.variableMap_.deleteVariableById(a)};
+Blockly.Workspace.prototype.deleteVariableInternal_=function(a,b){this.variableMap_.deleteVariableInternal_(a,b)};Blockly.Workspace.prototype.variableIndexOf=function(a){console.warn("Deprecated call to Blockly.Workspace.prototype.variableIndexOf");return-1};Blockly.Workspace.prototype.getVariable=function(a,b){return this.variableMap_.getVariable(a,b)};Blockly.Workspace.prototype.getVariableById=function(a){return this.variableMap_.getVariableById(a)};
+Blockly.Workspace.prototype.getVariablesOfType=function(a){return this.variableMap_.getVariablesOfType(a)};Blockly.Workspace.prototype.getVariableTypes=function(){return this.variableMap_.getVariableTypes()};Blockly.Workspace.prototype.getAllVariables=function(){return this.variableMap_.getAllVariables()};Blockly.Workspace.prototype.getWidth=function(){return 0};Blockly.Workspace.prototype.newBlock=function(a,b){return new Blockly.Block(this,a,b)};
+Blockly.Workspace.prototype.remainingCapacity=function(){return isNaN(this.options.maxBlocks)?Infinity:this.options.maxBlocks-this.getAllBlocks().length};Blockly.Workspace.prototype.remainingCapacityOfType=function(a){return this.options.maxInstances?(this.options.maxInstances[a]||Infinity)-this.getBlocksByType(a).length:Infinity};
+Blockly.Workspace.prototype.isCapacityAvailable=function(a){if(!this.hasBlockLimits())return!0;var b=0,c;for(c in a){if(a[c]>this.remainingCapacityOfType(c))return!1;b+=a[c]}return b>this.remainingCapacity()?!1:!0};Blockly.Workspace.prototype.hasBlockLimits=function(){return Infinity!=this.options.maxBlocks||!!this.options.maxInstances};
+Blockly.Workspace.prototype.undo=function(a){var b=a?this.redoStack_:this.undoStack_,c=a?this.undoStack_:this.redoStack_,d=b.pop();if(d){for(var e=[d];b.length&&d.group&&d.group==b[b.length-1].group;)e.push(b.pop());for(b=0;d=e[b];b++)c.push(d);e=Blockly.Events.filter(e,a);Blockly.Events.recordUndo=!1;try{for(b=0;d=e[b];b++)d.run(a)}finally{Blockly.Events.recordUndo=!0}}};Blockly.Workspace.prototype.clearUndo=function(){this.undoStack_.length=0;this.redoStack_.length=0;Blockly.Events.clearPendingUndo()};
+Blockly.Workspace.prototype.addChangeListener=function(a){this.listeners_.push(a);return a};Blockly.Workspace.prototype.removeChangeListener=function(a){Blockly.utils.arrayRemove(this.listeners_,a)};Blockly.Workspace.prototype.fireChangeListener=function(a){if(a.recordUndo)for(this.undoStack_.push(a),this.redoStack_.length=0;this.undoStack_.length>this.MAX_UNDO&&0<=this.MAX_UNDO;)this.undoStack_.shift();for(var b=0,c;c=this.listeners_[b];b++)c(a)};
+Blockly.Workspace.prototype.getBlockById=function(a){return this.blockDB_[a]||null};Blockly.Workspace.prototype.getCommentById=function(a){return this.commentDB_[a]||null};Blockly.Workspace.prototype.allInputsFilled=function(a){for(var b=this.getTopBlocks(!1),c=0,d;d=b[c];c++)if(!d.allInputsFilled(a))return!1;return!0};Blockly.Workspace.prototype.getPotentialVariableMap=function(){return this.potentialVariableMap_};
+Blockly.Workspace.prototype.createPotentialVariableMap=function(){this.potentialVariableMap_=new Blockly.VariableMap(this)};Blockly.Workspace.prototype.getVariableMap=function(){return this.variableMap_};Blockly.Workspace.WorkspaceDB_=Object.create(null);Blockly.Workspace.getById=function(a){return Blockly.Workspace.WorkspaceDB_[a]||null};Blockly.Workspace.prototype.clear=Blockly.Workspace.prototype.clear;Blockly.Workspace.prototype.clearUndo=Blockly.Workspace.prototype.clearUndo;
+Blockly.Workspace.prototype.addChangeListener=Blockly.Workspace.prototype.addChangeListener;Blockly.Workspace.prototype.removeChangeListener=Blockly.Workspace.prototype.removeChangeListener;Blockly.Bubble=function(a,b,c,d,e,f){this.workspace_=a;this.content_=b;this.shape_=c;c=Blockly.Bubble.ARROW_ANGLE;this.workspace_.RTL&&(c=-c);this.arrow_radians_=Blockly.utils.toRadians(c);a.getBubbleCanvas().appendChild(this.createDom_(b,!(!e||!f)));this.setAnchorLocation(d);e&&f||(b=this.content_.getBBox(),e=b.width+2*Blockly.Bubble.BORDER_WIDTH,f=b.height+2*Blockly.Bubble.BORDER_WIDTH);this.setBubbleSize(e,f);this.positionBubble_();this.renderArrow_();this.rendered_=!0;a.options.readOnly||(Blockly.bindEventWithChecks_(this.bubbleBack_,
+"mousedown",this,this.bubbleMouseDown_),this.resizeGroup_&&Blockly.bindEventWithChecks_(this.resizeGroup_,"mousedown",this,this.resizeMouseDown_))};Blockly.Bubble.BORDER_WIDTH=6;Blockly.Bubble.ARROW_THICKNESS=5;Blockly.Bubble.ARROW_ANGLE=20;Blockly.Bubble.ARROW_BEND=4;Blockly.Bubble.ANCHOR_RADIUS=8;Blockly.Bubble.onMouseUpWrapper_=null;Blockly.Bubble.onMouseMoveWrapper_=null;Blockly.Bubble.prototype.resizeCallback_=null;
+Blockly.Bubble.unbindDragEvents_=function(){Blockly.Bubble.onMouseUpWrapper_&&(Blockly.unbindEvent_(Blockly.Bubble.onMouseUpWrapper_),Blockly.Bubble.onMouseUpWrapper_=null);Blockly.Bubble.onMouseMoveWrapper_&&(Blockly.unbindEvent_(Blockly.Bubble.onMouseMoveWrapper_),Blockly.Bubble.onMouseMoveWrapper_=null)};Blockly.Bubble.bubbleMouseUp_=function(){Blockly.Touch.clearTouchIdentifier();Blockly.Bubble.unbindDragEvents_()};Blockly.Bubble.prototype.rendered_=!1;Blockly.Bubble.prototype.anchorXY_=null;
+Blockly.Bubble.prototype.relativeLeft_=0;Blockly.Bubble.prototype.relativeTop_=0;Blockly.Bubble.prototype.width_=0;Blockly.Bubble.prototype.height_=0;Blockly.Bubble.prototype.autoLayout_=!0;
+Blockly.Bubble.prototype.createDom_=function(a,b){this.bubbleGroup_=Blockly.utils.createSvgElement("g",{},null);var c={filter:"url(#"+this.workspace_.options.embossFilterId+")"};-1!=goog.userAgent.getUserAgentString().indexOf("JavaFX")&&(c={});c=Blockly.utils.createSvgElement("g",c,this.bubbleGroup_);this.bubbleArrow_=Blockly.utils.createSvgElement("path",{},c);this.bubbleBack_=Blockly.utils.createSvgElement("rect",{"class":"blocklyDraggable",x:0,y:0,rx:Blockly.Bubble.BORDER_WIDTH,ry:Blockly.Bubble.BORDER_WIDTH},
+c);b?(this.resizeGroup_=Blockly.utils.createSvgElement("g",{"class":this.workspace_.RTL?"blocklyResizeSW":"blocklyResizeSE"},this.bubbleGroup_),c=2*Blockly.Bubble.BORDER_WIDTH,Blockly.utils.createSvgElement("polygon",{points:"0,x x,x x,0".replace(/x/g,c.toString())},this.resizeGroup_),Blockly.utils.createSvgElement("line",{"class":"blocklyResizeLine",x1:c/3,y1:c-1,x2:c-1,y2:c/3},this.resizeGroup_),Blockly.utils.createSvgElement("line",{"class":"blocklyResizeLine",x1:2*c/3,y1:c-1,x2:c-1,y2:2*c/3},
+this.resizeGroup_)):this.resizeGroup_=null;this.bubbleGroup_.appendChild(a);return this.bubbleGroup_};Blockly.Bubble.prototype.getSvgRoot=function(){return this.bubbleGroup_};Blockly.Bubble.prototype.setSvgId=function(a){this.bubbleGroup_.dataset&&(this.bubbleGroup_.dataset.blockId=a)};Blockly.Bubble.prototype.bubbleMouseDown_=function(a){var b=this.workspace_.getGesture(a);b&&b.handleBubbleStart(a,this)};Blockly.Bubble.prototype.showContextMenu_=function(a){};
+Blockly.Bubble.prototype.isDeletable=function(){return!1};
+Blockly.Bubble.prototype.resizeMouseDown_=function(a){this.promote_();Blockly.Bubble.unbindDragEvents_();Blockly.utils.isRightButton(a)||(this.workspace_.startDrag(a,new goog.math.Coordinate(this.workspace_.RTL?-this.width_:this.width_,this.height_)),Blockly.Bubble.onMouseUpWrapper_=Blockly.bindEventWithChecks_(document,"mouseup",this,Blockly.Bubble.bubbleMouseUp_),Blockly.Bubble.onMouseMoveWrapper_=Blockly.bindEventWithChecks_(document,"mousemove",this,this.resizeMouseMove_),Blockly.hideChaff());
+a.stopPropagation()};Blockly.Bubble.prototype.resizeMouseMove_=function(a){this.autoLayout_=!1;a=this.workspace_.moveDrag(a);this.setBubbleSize(this.workspace_.RTL?-a.x:a.x,a.y);this.workspace_.RTL&&this.positionBubble_()};Blockly.Bubble.prototype.registerResizeEvent=function(a){this.resizeCallback_=a};Blockly.Bubble.prototype.promote_=function(){var a=this.bubbleGroup_.parentNode;return a.lastChild!==this.bubbleGroup_?(a.appendChild(this.bubbleGroup_),!0):!1};
+Blockly.Bubble.prototype.setAnchorLocation=function(a){this.anchorXY_=a;this.rendered_&&this.positionBubble_()};
+Blockly.Bubble.prototype.layoutBubble_=function(){var a=this.workspace_.getMetrics();a.viewWidth/=this.workspace_.scale;a.viewLeft/=this.workspace_.scale;var b=this.getOptimalRelativeLeft_(a),c=this.getOptimalRelativeTop_(a),d=this.shape_.getBBox(),e={x:b,y:-this.height_-Blockly.BlockSvg.MIN_BLOCK_Y},f={x:-this.width_-30,y:c};c={x:d.width,y:c};var g={x:b,y:d.height};b=d.width<d.height?c:g;d=d.width<d.height?g:c;c=this.getOverlap_(e,a);g=this.getOverlap_(f,a);var h=this.getOverlap_(b,a);a=this.getOverlap_(d,
+a);a=Math.max(c,g,h,a);c==a?(this.relativeLeft_=e.x,this.relativeTop_=e.y):g==a?(this.relativeLeft_=f.x,this.relativeTop_=f.y):h==a?(this.relativeLeft_=b.x,this.relativeTop_=b.y):(this.relativeLeft_=d.x,this.relativeTop_=d.y)};
+Blockly.Bubble.prototype.getOverlap_=function(a,b){var c=a.x+(this.workspace_.RTL?b.viewWidth-this.anchorXY_.x:this.anchorXY_.x),d=a.y+this.anchorXY_.y,e=this.workspace_.RTL?-b.viewLeft:b.viewLeft,f=b.viewTop;return Math.max(0,Math.min(1,(Math.min(c+this.width_,e+b.viewWidth)-Math.max(c,e))*(Math.min(d+this.height_,f+b.viewHeight)-Math.max(d,f))/(this.width_*this.height_)))};
+Blockly.Bubble.prototype.getOptimalRelativeLeft_=function(a){var b=-this.width_/4;if(this.width_>a.viewWidth)return b;var c=this.anchorXY_.x;this.workspace_.RTL?c-a.viewLeft-b-this.width_<Blockly.Scrollbar.scrollbarThickness?b=c-a.viewLeft-this.width_-Blockly.Scrollbar.scrollbarThickness:c-a.viewLeft-b>a.viewWidth&&(b=c-a.viewLeft-a.viewWidth):c+b<a.viewLeft?b=a.viewLeft-c:a.viewLeft+a.viewWidth<c+b+this.width_+Blockly.BlockSvg.SEP_SPACE_X+Blockly.Scrollbar.scrollbarThickness&&(b=a.viewLeft+a.viewWidth-
+c-this.width_-Blockly.Scrollbar.scrollbarThickness);return b};Blockly.Bubble.prototype.getOptimalRelativeTop_=function(a){var b=-this.height_/4;if(this.height_>a.viewHeight)return b;var c=this.anchorXY_.y;c+b<a.viewTop?b=a.viewTop-c:a.viewTop+a.viewHeight<c+b+this.height_+Blockly.BlockSvg.SEP_SPACE_Y+Blockly.Scrollbar.scrollbarThickness&&(b=a.viewTop+a.viewHeight-c-this.height_-Blockly.Scrollbar.scrollbarThickness);return b};
+Blockly.Bubble.prototype.positionBubble_=function(){var a=this.anchorXY_.x;a=this.workspace_.RTL?a-(this.relativeLeft_+this.width_):a+this.relativeLeft_;this.moveTo(a,this.relativeTop_+this.anchorXY_.y)};Blockly.Bubble.prototype.moveTo=function(a,b){this.bubbleGroup_.setAttribute("transform","translate("+a+","+b+")")};Blockly.Bubble.prototype.getBubbleSize=function(){return{width:this.width_,height:this.height_}};
+Blockly.Bubble.prototype.setBubbleSize=function(a,b){var c=2*Blockly.Bubble.BORDER_WIDTH;a=Math.max(a,c+45);b=Math.max(b,c+20);this.width_=a;this.height_=b;this.bubbleBack_.setAttribute("width",a);this.bubbleBack_.setAttribute("height",b);this.resizeGroup_&&(this.workspace_.RTL?this.resizeGroup_.setAttribute("transform","translate("+2*Blockly.Bubble.BORDER_WIDTH+","+(b-c)+") scale(-1 1)"):this.resizeGroup_.setAttribute("transform","translate("+(a-c)+","+(b-c)+")"));this.rendered_&&(this.autoLayout_&&
+this.layoutBubble_(),this.positionBubble_(),this.renderArrow_());this.resizeCallback_&&this.resizeCallback_()};
+Blockly.Bubble.prototype.renderArrow_=function(){var a=[],b=this.width_/2,c=this.height_/2,d=-this.relativeLeft_,e=-this.relativeTop_;if(b==d&&c==e)a.push("M "+b+","+c);else{e-=c;d-=b;this.workspace_.RTL&&(d*=-1);var f=Math.sqrt(e*e+d*d),g=Math.acos(d/f);0>e&&(g=2*Math.PI-g);var h=g+Math.PI/2;h>2*Math.PI&&(h-=2*Math.PI);var k=Math.sin(h),l=Math.cos(h),n=this.getBubbleSize();h=(n.width+n.height)/Blockly.Bubble.ARROW_THICKNESS;h=Math.min(h,n.width,n.height)/4;n=1-Blockly.Bubble.ANCHOR_RADIUS/f;d=b+
+n*d;e=c+n*e;n=b+h*l;var m=c+h*k;b-=h*l;c-=h*k;k=g+this.arrow_radians_;k>2*Math.PI&&(k-=2*Math.PI);g=Math.sin(k)*f/Blockly.Bubble.ARROW_BEND;f=Math.cos(k)*f/Blockly.Bubble.ARROW_BEND;a.push("M"+n+","+m);a.push("C"+(n+f)+","+(m+g)+" "+d+","+e+" "+d+","+e);a.push("C"+d+","+e+" "+(b+f)+","+(c+g)+" "+b+","+c)}a.push("z");this.bubbleArrow_.setAttribute("d",a.join(" "))};Blockly.Bubble.prototype.setColour=function(a){this.bubbleBack_.setAttribute("fill",a);this.bubbleArrow_.setAttribute("fill",a)};
+Blockly.Bubble.prototype.dispose=function(){Blockly.Bubble.unbindDragEvents_();Blockly.utils.removeNode(this.bubbleGroup_);this.shape_=this.content_=this.workspace_=this.resizeGroup_=this.bubbleBack_=this.bubbleArrow_=this.bubbleGroup_=null};Blockly.Bubble.prototype.moveDuringDrag=function(a,b){a?a.translateSurface(b.x,b.y):this.moveTo(b.x,b.y);this.relativeLeft_=this.workspace_.RTL?this.anchorXY_.x-b.x-this.width_:b.x-this.anchorXY_.x;this.relativeTop_=b.y-this.anchorXY_.y;this.renderArrow_()};
+Blockly.Bubble.prototype.getRelativeToSurfaceXY=function(){return new goog.math.Coordinate(this.anchorXY_.x+this.relativeLeft_,this.anchorXY_.y+this.relativeTop_)};Blockly.Bubble.prototype.setAutoLayout=function(a){this.autoLayout_=a};Blockly.Events.Ui=function(a,b,c,d){Blockly.Events.Ui.superClass_.constructor.call(this);this.blockId=a?a.id:null;this.workspaceId=a?a.workspace.id:null;this.element=b;this.oldValue=c;this.newValue=d;this.recordUndo=!1};goog.inherits(Blockly.Events.Ui,Blockly.Events.Abstract);Blockly.Events.Ui.prototype.type=Blockly.Events.UI;
+Blockly.Events.Ui.prototype.toJson=function(){var a=Blockly.Events.Ui.superClass_.toJson.call(this);a.element=this.element;void 0!==this.newValue&&(a.newValue=this.newValue);this.blockId&&(a.blockId=this.blockId);return a};Blockly.Events.Ui.prototype.fromJson=function(a){Blockly.Events.Ui.superClass_.fromJson.call(this,a);this.element=a.element;this.newValue=a.newValue;this.blockId=a.blockId};Blockly.Icon=function(a){this.block_=a};Blockly.Icon.prototype.collapseHidden=!0;Blockly.Icon.prototype.SIZE=17;Blockly.Icon.prototype.bubble_=null;Blockly.Icon.prototype.iconXY_=null;
+Blockly.Icon.prototype.createIcon=function(){this.iconGroup_||(this.iconGroup_=Blockly.utils.createSvgElement("g",{"class":"blocklyIconGroup"},null),this.block_.isInFlyout&&Blockly.utils.addClass(this.iconGroup_,"blocklyIconGroupReadonly"),this.drawIcon_(this.iconGroup_),this.block_.getSvgRoot().appendChild(this.iconGroup_),Blockly.bindEventWithChecks_(this.iconGroup_,"mouseup",this,this.iconClick_),this.updateEditable())};
+Blockly.Icon.prototype.dispose=function(){Blockly.utils.removeNode(this.iconGroup_);this.iconGroup_=null;this.setVisible(!1);this.block_=null};Blockly.Icon.prototype.updateEditable=function(){};Blockly.Icon.prototype.isVisible=function(){return!!this.bubble_};Blockly.Icon.prototype.iconClick_=function(a){this.block_.workspace.isDragging()||this.block_.isInFlyout||Blockly.utils.isRightButton(a)||this.setVisible(!this.isVisible())};Blockly.Icon.prototype.updateColour=function(){this.isVisible()&&this.bubble_.setColour(this.block_.getColour())};
+Blockly.Icon.prototype.renderIcon=function(a){if(this.collapseHidden&&this.block_.isCollapsed()||this.block_.isInsertionMarker())return this.iconGroup_.setAttribute("display","none"),a;this.iconGroup_.setAttribute("display","block");var b=this.SIZE;this.block_.RTL&&(a-=b);this.iconGroup_.setAttribute("transform","translate("+a+",5)");this.computeIconLocation();return a=this.block_.RTL?a-Blockly.BlockSvg.SEP_SPACE_X:a+(b+Blockly.BlockSvg.SEP_SPACE_X)};
+Blockly.Icon.prototype.setIconLocation=function(a){this.iconXY_=a;this.isVisible()&&this.bubble_.setAnchorLocation(a)};Blockly.Icon.prototype.computeIconLocation=function(){var a=this.block_.getRelativeToSurfaceXY(),b=Blockly.utils.getRelativeXY(this.iconGroup_);a=new goog.math.Coordinate(a.x+b.x+this.SIZE/2,a.y+b.y+this.SIZE/2);goog.math.Coordinate.equals(this.getIconLocation(),a)||this.setIconLocation(a)};Blockly.Icon.prototype.getIconLocation=function(){return this.iconXY_};
+Blockly.Comment=function(a){Blockly.Comment.superClass_.constructor.call(this,a);this.createIcon()};goog.inherits(Blockly.Comment,Blockly.Icon);Blockly.Comment.prototype.text_="";Blockly.Comment.prototype.width_=160;Blockly.Comment.prototype.height_=80;
+Blockly.Comment.prototype.drawIcon_=function(a){Blockly.utils.createSvgElement("circle",{"class":"blocklyIconShape",r:"8",cx:"8",cy:"8"},a);Blockly.utils.createSvgElement("path",{"class":"blocklyIconSymbol",d:"m6.8,10h2c0.003,-0.617 0.271,-0.962 0.633,-1.266 2.875,-2.4050.607,-5.534 -3.765,-3.874v1.7c3.12,-1.657 3.698,0.118 2.336,1.25-1.201,0.998 -1.201,1.528 -1.204,2.19z"},a);Blockly.utils.createSvgElement("rect",{"class":"blocklyIconSymbol",x:"6.8",y:"10.78",height:"2",width:"2"},a)};
+Blockly.Comment.prototype.createEditor_=function(){this.foreignObject_=Blockly.utils.createSvgElement("foreignObject",{x:Blockly.Bubble.BORDER_WIDTH,y:Blockly.Bubble.BORDER_WIDTH},null);var a=document.createElementNS(Blockly.HTML_NS,"body");a.setAttribute("xmlns",Blockly.HTML_NS);a.className="blocklyMinimalBody";var b=document.createElementNS(Blockly.HTML_NS,"textarea");b.className="blocklyCommentTextarea";b.setAttribute("dir",this.block_.RTL?"RTL":"LTR");a.appendChild(b);this.textarea_=b;this.foreignObject_.appendChild(a);
+Blockly.bindEventWithChecks_(b,"mouseup",this,this.textareaFocus_,!0,!0);Blockly.bindEventWithChecks_(b,"wheel",this,function(a){a.stopPropagation()});Blockly.bindEventWithChecks_(b,"change",this,function(a){this.text_!=b.value&&(Blockly.Events.fire(new Blockly.Events.BlockChange(this.block_,"comment",null,this.text_,b.value)),this.text_=b.value)});setTimeout(function(){b.focus()},0);return this.foreignObject_};
+Blockly.Comment.prototype.updateEditable=function(){this.isVisible()&&(this.setVisible(!1),this.setVisible(!0));Blockly.Icon.prototype.updateEditable.call(this)};Blockly.Comment.prototype.resizeBubble_=function(){if(this.isVisible()){var a=this.bubble_.getBubbleSize(),b=2*Blockly.Bubble.BORDER_WIDTH;this.foreignObject_.setAttribute("width",a.width-b);this.foreignObject_.setAttribute("height",a.height-b);this.textarea_.style.width=a.width-b-4+"px";this.textarea_.style.height=a.height-b-4+"px"}};
+Blockly.Comment.prototype.setVisible=function(a){if(a!=this.isVisible())if(Blockly.Events.fire(new Blockly.Events.Ui(this.block_,"commentOpen",!a,a)),!this.block_.isEditable()&&!this.textarea_||goog.userAgent.IE)Blockly.Warning.prototype.setVisible.call(this,a);else{var b=this.getText(),c=this.getBubbleSize();a?(this.bubble_=new Blockly.Bubble(this.block_.workspace,this.createEditor_(),this.block_.svgPath_,this.iconXY_,this.width_,this.height_),this.bubble_.setSvgId(this.block_.id),this.bubble_.registerResizeEvent(this.resizeBubble_.bind(this)),
+this.updateColour()):(this.bubble_.dispose(),this.foreignObject_=this.textarea_=this.bubble_=null);this.setText(b);this.setBubbleSize(c.width,c.height)}};Blockly.Comment.prototype.textareaFocus_=function(a){this.bubble_.promote_()&&this.textarea_.focus()};Blockly.Comment.prototype.getBubbleSize=function(){return this.isVisible()?this.bubble_.getBubbleSize():{width:this.width_,height:this.height_}};
+Blockly.Comment.prototype.setBubbleSize=function(a,b){this.textarea_?this.bubble_.setBubbleSize(a,b):(this.width_=a,this.height_=b)};Blockly.Comment.prototype.getText=function(){return this.textarea_?this.textarea_.value:this.text_};Blockly.Comment.prototype.setText=function(a){this.text_!=a&&(Blockly.Events.fire(new Blockly.Events.BlockChange(this.block_,"comment",null,this.text_,a)),this.text_=a);this.textarea_&&(this.textarea_.value=a)};
+Blockly.Comment.prototype.dispose=function(){Blockly.Events.isEnabled()&&this.setText("");this.block_.comment=null;Blockly.Icon.prototype.dispose.call(this)};Blockly.Connection=function(a,b){this.sourceBlock_=a;this.type=b;a.workspace.connectionDBList&&(this.db_=a.workspace.connectionDBList[b],this.dbOpposite_=a.workspace.connectionDBList[Blockly.OPPOSITE_TYPE[b]],this.hidden_=!this.db_)};Blockly.Connection.CAN_CONNECT=0;Blockly.Connection.REASON_SELF_CONNECTION=1;Blockly.Connection.REASON_WRONG_TYPE=2;Blockly.Connection.REASON_TARGET_NULL=3;Blockly.Connection.REASON_CHECKS_FAILED=4;Blockly.Connection.REASON_DIFFERENT_WORKSPACES=5;
+Blockly.Connection.REASON_SHADOW_PARENT=6;Blockly.Connection.prototype.targetConnection=null;Blockly.Connection.prototype.check_=null;Blockly.Connection.prototype.shadowDom_=null;Blockly.Connection.prototype.x_=0;Blockly.Connection.prototype.y_=0;Blockly.Connection.prototype.inDB_=!1;Blockly.Connection.prototype.db_=null;Blockly.Connection.prototype.dbOpposite_=null;Blockly.Connection.prototype.hidden_=null;
+Blockly.Connection.prototype.connect_=function(a){var b=this,c=b.getSourceBlock(),d=a.getSourceBlock();a.isConnected()&&a.disconnect();if(b.isConnected()){var e=b.targetBlock(),f=b.getShadowDom();b.setShadowDom(null);if(e.isShadow())f=Blockly.Xml.blockToDom(e),e.dispose(),e=null;else if(b.type==Blockly.INPUT_VALUE){if(!e.outputConnection)throw Error("Orphan block does not have an output connection.");var g=Blockly.Connection.lastConnectionInRow_(d,e);g&&(e.outputConnection.connect(g),e=null)}else if(b.type==
+Blockly.NEXT_STATEMENT){if(!e.previousConnection)throw Error("Orphan block does not have a previous connection.");for(g=d;g.nextConnection;){var h=g.getNextBlock();if(h&&!h.isShadow())g=h;else{e.previousConnection.checkType_(g.nextConnection)&&(g.nextConnection.connect(e.previousConnection),e=null);break}}}if(e&&(b.disconnect(),Blockly.Events.recordUndo)){var k=Blockly.Events.getGroup();setTimeout(function(){e.workspace&&!e.getParent()&&(Blockly.Events.setGroup(k),e.outputConnection?e.outputConnection.bumpAwayFrom_(b):
+e.previousConnection&&e.previousConnection.bumpAwayFrom_(b),Blockly.Events.setGroup(!1))},Blockly.BUMP_DELAY)}b.setShadowDom(f)}var l;Blockly.Events.isEnabled()&&(l=new Blockly.Events.BlockMove(d));Blockly.Connection.connectReciprocally_(b,a);d.setParent(c);l&&(l.recordNew(),Blockly.Events.fire(l))};
+Blockly.Connection.prototype.dispose=function(){if(this.isConnected())throw Error("Disconnect connection before disposing of it.");this.inDB_&&this.db_.removeConnection_(this);this.dbOpposite_=this.db_=null};Blockly.Connection.prototype.getSourceBlock=function(){return this.sourceBlock_};Blockly.Connection.prototype.isSuperior=function(){return this.type==Blockly.INPUT_VALUE||this.type==Blockly.NEXT_STATEMENT};Blockly.Connection.prototype.isConnected=function(){return!!this.targetConnection};
+Blockly.Connection.prototype.canConnectWithReason_=function(a){if(!a)return Blockly.Connection.REASON_TARGET_NULL;if(this.isSuperior())var b=this.sourceBlock_,c=a.getSourceBlock();else c=this.sourceBlock_,b=a.getSourceBlock();return b&&b==c?Blockly.Connection.REASON_SELF_CONNECTION:a.type!=Blockly.OPPOSITE_TYPE[this.type]?Blockly.Connection.REASON_WRONG_TYPE:b&&c&&b.workspace!==c.workspace?Blockly.Connection.REASON_DIFFERENT_WORKSPACES:this.checkType_(a)?b.isShadow()&&!c.isShadow()?Blockly.Connection.REASON_SHADOW_PARENT:
+Blockly.Connection.CAN_CONNECT:Blockly.Connection.REASON_CHECKS_FAILED};
+Blockly.Connection.prototype.checkConnection_=function(a){switch(this.canConnectWithReason_(a)){case Blockly.Connection.CAN_CONNECT:break;case Blockly.Connection.REASON_SELF_CONNECTION:throw Error("Attempted to connect a block to itself.");case Blockly.Connection.REASON_DIFFERENT_WORKSPACES:throw Error("Blocks not on same workspace.");case Blockly.Connection.REASON_WRONG_TYPE:throw Error("Attempt to connect incompatible types.");case Blockly.Connection.REASON_TARGET_NULL:throw Error("Target connection is null.");
+case Blockly.Connection.REASON_CHECKS_FAILED:throw Error("Connection checks failed. "+(this+" expected "+this.check_+", found "+a.check_));case Blockly.Connection.REASON_SHADOW_PARENT:throw Error("Connecting non-shadow to shadow block.");default:throw Error("Unknown connection failure: this should never happen!");}};
+Blockly.Connection.prototype.canConnectToPrevious_=function(a){if(this.targetConnection||-1!=Blockly.draggingConnections_.indexOf(a))return!1;if(!a.targetConnection)return!0;a=a.targetBlock();return a.isInsertionMarker()?!a.getPreviousBlock():!1};
+Blockly.Connection.prototype.isConnectionAllowed=function(a){if(a.sourceBlock_.isInsertionMarker()||this.canConnectWithReason_(a)!=Blockly.Connection.CAN_CONNECT)return!1;switch(a.type){case Blockly.PREVIOUS_STATEMENT:return this.canConnectToPrevious_(a);case Blockly.OUTPUT_VALUE:if(a.isConnected()&&!a.targetBlock().isInsertionMarker()||this.isConnected())return!1;break;case Blockly.INPUT_VALUE:if(a.isConnected()&&!a.targetBlock().isMovable()&&!a.targetBlock().isShadow())return!1;break;case Blockly.NEXT_STATEMENT:if(a.isConnected()&&
+!this.sourceBlock_.nextConnection&&!a.targetBlock().isShadow()&&a.targetBlock().nextConnection)return!1;break;default:throw Error("Unknown connection type in isConnectionAllowed");}return-1!=Blockly.draggingConnections_.indexOf(a)?!1:!0};Blockly.Connection.prototype.connect=function(a){this.targetConnection!=a&&(this.checkConnection_(a),this.isSuperior()?this.connect_(a):a.connect_(this))};
+Blockly.Connection.connectReciprocally_=function(a,b){if(!a||!b)throw Error("Cannot connect null connections.");a.targetConnection=b;b.targetConnection=a};Blockly.Connection.singleConnection_=function(a,b){for(var c=!1,d=0;d<a.inputList.length;d++){var e=a.inputList[d].connection;if(e&&e.type==Blockly.INPUT_VALUE&&b.outputConnection.checkType_(e)){if(c)return null;c=e}}return c};
+Blockly.Connection.lastConnectionInRow_=function(a,b){for(var c=a,d;d=Blockly.Connection.singleConnection_(c,b);)if(c=d.targetBlock(),!c||c.isShadow())return d;return null};
+Blockly.Connection.prototype.disconnect=function(){var a=this.targetConnection;if(!a)throw Error("Source connection not connected.");if(a.targetConnection!=this)throw Error("Target connection not connected to source connection.");if(this.isSuperior()){var b=this.sourceBlock_;var c=a.getSourceBlock();a=this}else b=a.getSourceBlock(),c=this.sourceBlock_;this.disconnectInternal_(b,c);a.respawnShadow_()};
+Blockly.Connection.prototype.disconnectInternal_=function(a,b){var c;Blockly.Events.isEnabled()&&(c=new Blockly.Events.BlockMove(b));this.targetConnection=this.targetConnection.targetConnection=null;b.setParent(null);c&&(c.recordNew(),Blockly.Events.fire(c))};
+Blockly.Connection.prototype.respawnShadow_=function(){var a=this.getSourceBlock(),b=this.getShadowDom();if(a.workspace&&b&&Blockly.Events.recordUndo)if(a=Blockly.Xml.domToBlock(b,a.workspace),a.outputConnection)this.connect(a.outputConnection);else if(a.previousConnection)this.connect(a.previousConnection);else throw Error("Child block does not have output or previous statement.");};
+Blockly.Connection.prototype.targetBlock=function(){return this.isConnected()?this.targetConnection.getSourceBlock():null};Blockly.Connection.prototype.checkType_=function(a){if(!this.check_||!a.check_)return!0;for(var b=0;b<this.check_.length;b++)if(-1!=a.check_.indexOf(this.check_[b]))return!0;return!1};Blockly.Connection.prototype.onCheckChanged_=function(){this.isConnected()&&!this.checkType_(this.targetConnection)&&(this.isSuperior()?this.targetBlock():this.sourceBlock_).unplug()};
+Blockly.Connection.prototype.setCheck=function(a){a?(Array.isArray(a)||(a=[a]),this.check_=a,this.onCheckChanged_()):this.check_=null;return this};Blockly.Connection.prototype.getCheck=function(){return this.check_};Blockly.Connection.prototype.setShadowDom=function(a){this.shadowDom_=a};Blockly.Connection.prototype.getShadowDom=function(){return this.shadowDom_};Blockly.Connection.prototype.neighbours_=function(){return[]};
+Blockly.Connection.prototype.toString=function(){var a=this.sourceBlock_;if(a)if(a.outputConnection==this)var b="Output Connection of ";else if(a.previousConnection==this)b="Previous Connection of ";else if(a.nextConnection==this)b="Next Connection of ";else{b=null;for(var c=0,d;d=a.inputList[c];c++)if(d.connection==this){b=d;break}if(b)b='Input "'+b.name+'" connection on ';else return console.warn("Connection not actually connected to sourceBlock_"),"Orphan Connection"}else return"Orphan Connection";
+return b+a.toDevString()};Blockly.ConnectionDB=function(){this.connections_=[]};Blockly.ConnectionDB.prototype.addConnection=function(a){if(a.inDB_)throw Error("Connection already in database.");if(!a.getSourceBlock().isInFlyout){var b=this.findPositionForConnection_(a);this.connections_.splice(b,0,a);a.inDB_=!0}};
+Blockly.ConnectionDB.prototype.findConnection=function(a){if(!this.connections_.length)return-1;var b=this.findPositionForConnection_(a);if(b>=this.connections_.length)return-1;for(var c=a.y_,d=b;0<=d&&this.connections_[d].y_==c;){if(this.connections_[d]==a)return d;d--}for(;b<this.connections_.length&&this.connections_[b].y_==c;){if(this.connections_[b]==a)return b;b++}return-1};
+Blockly.ConnectionDB.prototype.findPositionForConnection_=function(a){if(!this.connections_.length)return 0;for(var b=0,c=this.connections_.length;b<c;){var d=Math.floor((b+c)/2);if(this.connections_[d].y_<a.y_)b=d+1;else if(this.connections_[d].y_>a.y_)c=d;else{b=d;break}}return b};
+Blockly.ConnectionDB.prototype.removeConnection_=function(a){if(!a.inDB_)throw Error("Connection not in database.");var b=this.findConnection(a);if(-1==b)throw Error("Unable to find connection in connectionDB.");a.inDB_=!1;this.connections_.splice(b,1)};
+Blockly.ConnectionDB.prototype.getNeighbours=function(a,b){function c(a){var c=e-d[a].x_,g=f-d[a].y_;Math.sqrt(c*c+g*g)<=b&&l.push(d[a]);return g<b}for(var d=this.connections_,e=a.x_,f=a.y_,g=0,h=d.length-2,k=h;g<k;)d[k].y_<f?g=k:h=k,k=Math.floor((g+h)/2);var l=[];h=g=k;if(d.length){for(;0<=g&&c(g);)g--;do h++;while(h<d.length&&c(h))}return l};Blockly.ConnectionDB.prototype.isInYRange_=function(a,b,c){return Math.abs(this.connections_[a].y_-b)<=c};
+Blockly.ConnectionDB.prototype.searchForClosest=function(a,b,c){if(!this.connections_.length)return{connection:null,radius:b};var d=a.y_,e=a.x_;a.x_=e+c.x;a.y_=d+c.y;var f=this.findPositionForConnection_(a);c=null;for(var g=b,h,k=f-1;0<=k&&this.isInYRange_(k,a.y_,b);)h=this.connections_[k],a.isConnectionAllowed(h,g)&&(c=h,g=h.distanceFrom(a)),k--;for(;f<this.connections_.length&&this.isInYRange_(f,a.y_,b);)h=this.connections_[f],a.isConnectionAllowed(h,g)&&(c=h,g=h.distanceFrom(a)),f++;a.x_=e;a.y_=
+d;return{connection:c,radius:g}};Blockly.ConnectionDB.init=function(a){var b=[];b[Blockly.INPUT_VALUE]=new Blockly.ConnectionDB;b[Blockly.OUTPUT_VALUE]=new Blockly.ConnectionDB;b[Blockly.NEXT_STATEMENT]=new Blockly.ConnectionDB;b[Blockly.PREVIOUS_STATEMENT]=new Blockly.ConnectionDB;a.connectionDBList=b};Blockly.constants={};Blockly.DRAG_RADIUS=5;Blockly.FLYOUT_DRAG_RADIUS=10;Blockly.SNAP_RADIUS=28;Blockly.CONNECTING_SNAP_RADIUS=Blockly.SNAP_RADIUS;Blockly.CURRENT_CONNECTION_PREFERENCE=8;Blockly.INSERTION_MARKER_COLOUR="#000000";Blockly.BUMP_DELAY=250;Blockly.BUMP_RANDOMNESS=10;Blockly.COLLAPSE_CHARS=30;Blockly.LONGPRESS=750;Blockly.SOUND_LIMIT=100;Blockly.DRAG_STACK=!0;Blockly.HSV_SATURATION=.45;Blockly.HSV_VALUE=.65;Blockly.SPRITE={width:96,height:124,url:"sprites.png"};Blockly.SVG_NS="http://www.w3.org/2000/svg";
+Blockly.HTML_NS="http://www.w3.org/1999/xhtml";Blockly.INPUT_VALUE=1;Blockly.OUTPUT_VALUE=2;Blockly.NEXT_STATEMENT=3;Blockly.PREVIOUS_STATEMENT=4;Blockly.DUMMY_INPUT=5;Blockly.ALIGN_LEFT=-1;Blockly.ALIGN_CENTRE=0;Blockly.ALIGN_RIGHT=1;Blockly.DRAG_NONE=0;Blockly.DRAG_STICKY=1;Blockly.DRAG_BEGIN=1;Blockly.DRAG_FREE=2;Blockly.OPPOSITE_TYPE=[];Blockly.OPPOSITE_TYPE[Blockly.INPUT_VALUE]=Blockly.OUTPUT_VALUE;Blockly.OPPOSITE_TYPE[Blockly.OUTPUT_VALUE]=Blockly.INPUT_VALUE;
+Blockly.OPPOSITE_TYPE[Blockly.NEXT_STATEMENT]=Blockly.PREVIOUS_STATEMENT;Blockly.OPPOSITE_TYPE[Blockly.PREVIOUS_STATEMENT]=Blockly.NEXT_STATEMENT;Blockly.TOOLBOX_AT_TOP=0;Blockly.TOOLBOX_AT_BOTTOM=1;Blockly.TOOLBOX_AT_LEFT=2;Blockly.TOOLBOX_AT_RIGHT=3;Blockly.DELETE_AREA_NONE=null;Blockly.DELETE_AREA_TRASH=1;Blockly.DELETE_AREA_TOOLBOX=2;Blockly.VARIABLE_CATEGORY_NAME="VARIABLE";Blockly.VARIABLE_DYNAMIC_CATEGORY_NAME="VARIABLE_DYNAMIC";Blockly.PROCEDURE_CATEGORY_NAME="PROCEDURE";
+Blockly.RENAME_VARIABLE_ID="RENAME_VARIABLE_ID";Blockly.DELETE_VARIABLE_ID="DELETE_VARIABLE_ID";Blockly.BlockAnimations={};Blockly.BlockAnimations.disconnectPid_=0;Blockly.BlockAnimations.disconnectGroup_=null;Blockly.BlockAnimations.disposeUiEffect=function(a){var b=a.workspace,c=a.getSvgRoot();b.getAudioManager().play("delete");a=b.getSvgXY(c);c=c.cloneNode(!0);c.translateX_=a.x;c.translateY_=a.y;c.setAttribute("transform","translate("+a.x+","+a.y+")");b.getParentSvg().appendChild(c);c.bBox_=c.getBBox();Blockly.BlockAnimations.disposeUiStep_(c,b.RTL,new Date,b.scale)};
+Blockly.BlockAnimations.disposeUiStep_=function(a,b,c,d){var e=(new Date-c)/150;1<e?Blockly.utils.removeNode(a):(a.setAttribute("transform","translate("+(a.translateX_+(b?-1:1)*a.bBox_.width*d/2*e)+","+(a.translateY_+a.bBox_.height*d*e)+") scale("+(1-e)*d+")"),setTimeout(Blockly.BlockAnimations.disposeUiStep_,10,a,b,c,d))};
+Blockly.BlockAnimations.connectionUiEffect=function(a){var b=a.workspace,c=b.scale;b.getAudioManager().play("click");if(!(1>c)){var d=b.getSvgXY(a.getSvgRoot());a.outputConnection?(d.x+=(a.RTL?3:-3)*c,d.y+=13*c):a.previousConnection&&(d.x+=(a.RTL?-23:23)*c,d.y+=3*c);a=Blockly.utils.createSvgElement("circle",{cx:d.x,cy:d.y,r:0,fill:"none",stroke:"#888","stroke-width":10},b.getParentSvg());Blockly.BlockAnimations.connectionUiStep_(a,new Date,c)}};
+Blockly.BlockAnimations.connectionUiStep_=function(a,b,c){var d=(new Date-b)/150;1<d?Blockly.utils.removeNode(a):(a.setAttribute("r",25*d*c),a.style.opacity=1-d,Blockly.BlockAnimations.disconnectPid_=setTimeout(Blockly.BlockAnimations.connectionUiStep_,10,a,b,c))};
+Blockly.BlockAnimations.disconnectUiEffect=function(a){a.workspace.getAudioManager().play("disconnect");if(!(1>a.workspace.scale)){var b=a.getHeightWidth().height;b=Math.atan(10/b)/Math.PI*180;a.RTL||(b*=-1);Blockly.BlockAnimations.disconnectUiStep_(a.getSvgRoot(),b,new Date)}};
+Blockly.BlockAnimations.disconnectUiStep_=function(a,b,c){var d=(new Date-c)/200;1<d?a.skew_="":(a.skew_="skewX("+Math.round(Math.sin(d*Math.PI*3)*(1-d)*b)+")",Blockly.BlockAnimations.disconnectGroup_=a,Blockly.BlockAnimations.disconnectPid_=setTimeout(Blockly.BlockAnimations.disconnectUiStep_,10,a,b,c));a.setAttribute("transform",a.translate_+a.skew_)};
+Blockly.BlockAnimations.disconnectUiStop=function(){if(Blockly.BlockAnimations.disconnectGroup_){clearTimeout(Blockly.BlockAnimations.disconnectPid_);var a=Blockly.BlockAnimations.disconnectGroup_;a.skew_="";a.setAttribute("transform",a.translate_);Blockly.BlockAnimations.disconnectGroup_=null}};Blockly.RenderedConnection=function(a,b){Blockly.RenderedConnection.superClass_.constructor.call(this,a,b);this.offsetInBlock_=new goog.math.Coordinate(0,0)};goog.inherits(Blockly.RenderedConnection,Blockly.Connection);Blockly.RenderedConnection.prototype.distanceFrom=function(a){var b=this.x_-a.x_;a=this.y_-a.y_;return Math.sqrt(b*b+a*a)};
+Blockly.RenderedConnection.prototype.bumpAwayFrom_=function(a){if(!this.sourceBlock_.workspace.isDragging()){var b=this.sourceBlock_.getRootBlock();if(!b.isInFlyout){var c=!1;if(!b.isMovable()){b=a.getSourceBlock().getRootBlock();if(!b.isMovable())return;a=this;c=!0}var d=Blockly.selected==b;d||b.addSelect();var e=a.x_+Blockly.SNAP_RADIUS+Math.floor(Math.random()*Blockly.BUMP_RANDOMNESS)-this.x_;a=a.y_+Blockly.SNAP_RADIUS+Math.floor(Math.random()*Blockly.BUMP_RANDOMNESS)-this.y_;c&&(a=-a);b.RTL&&
+(e=-e);b.moveBy(e,a);d||b.removeSelect()}}};Blockly.RenderedConnection.prototype.moveTo=function(a,b){this.inDB_&&this.db_.removeConnection_(this);this.x_=a;this.y_=b;this.hidden_||this.db_.addConnection(this)};Blockly.RenderedConnection.prototype.moveBy=function(a,b){this.moveTo(this.x_+a,this.y_+b)};Blockly.RenderedConnection.prototype.moveToOffset=function(a){this.moveTo(a.x+this.offsetInBlock_.x,a.y+this.offsetInBlock_.y)};
+Blockly.RenderedConnection.prototype.setOffsetInBlock=function(a,b){this.offsetInBlock_.x=a;this.offsetInBlock_.y=b};Blockly.RenderedConnection.prototype.tighten_=function(){var a=this.targetConnection.x_-this.x_,b=this.targetConnection.y_-this.y_;if(0!=a||0!=b){var c=this.targetBlock(),d=c.getSvgRoot();if(!d)throw Error("block is not rendered.");d=Blockly.utils.getRelativeXY(d);c.getSvgRoot().setAttribute("transform","translate("+(d.x-a)+","+(d.y-b)+")");c.moveConnections_(-a,-b)}};
+Blockly.RenderedConnection.prototype.closest=function(a,b){return this.dbOpposite_.searchForClosest(this,a,b)};
+Blockly.RenderedConnection.prototype.highlight=function(){var a=this.type==Blockly.INPUT_VALUE||this.type==Blockly.OUTPUT_VALUE?"m 0,0 "+Blockly.BlockSvg.TAB_PATH_DOWN+" v 5":"m -20,0 h 5 "+Blockly.BlockSvg.NOTCH_PATH_LEFT+" h 5";var b=this.sourceBlock_.getRelativeToSurfaceXY();Blockly.Connection.highlightedPath_=Blockly.utils.createSvgElement("path",{"class":"blocklyHighlightedConnectionPath",d:a,transform:"translate("+(this.x_-b.x)+","+(this.y_-b.y)+")"+(this.sourceBlock_.RTL?" scale(-1 1)":"")},
+this.sourceBlock_.getSvgRoot())};
+Blockly.RenderedConnection.prototype.unhideAll=function(){this.setHidden(!1);var a=[];if(this.type!=Blockly.INPUT_VALUE&&this.type!=Blockly.NEXT_STATEMENT)return a;var b=this.targetBlock();if(b){if(b.isCollapsed()){var c=[];b.outputConnection&&c.push(b.outputConnection);b.nextConnection&&c.push(b.nextConnection);b.previousConnection&&c.push(b.previousConnection)}else c=b.getConnections_(!0);for(var d=0;d<c.length;d++)a.push.apply(a,c[d].unhideAll());a.length||(a[0]=b)}return a};
+Blockly.RenderedConnection.prototype.unhighlight=function(){Blockly.utils.removeNode(Blockly.Connection.highlightedPath_);delete Blockly.Connection.highlightedPath_};Blockly.RenderedConnection.prototype.setHidden=function(a){(this.hidden_=a)&&this.inDB_?this.db_.removeConnection_(this):a||this.inDB_||this.db_.addConnection(this)};
+Blockly.RenderedConnection.prototype.hideAll=function(){this.setHidden(!0);if(this.targetConnection)for(var a=this.targetBlock().getDescendants(!1),b=0;b<a.length;b++){for(var c=a[b],d=c.getConnections_(!0),e=0;e<d.length;e++)d[e].setHidden(!0);c=c.getIcons();for(e=0;e<c.length;e++)c[e].setVisible(!1)}};Blockly.RenderedConnection.prototype.isConnectionAllowed=function(a,b){return this.distanceFrom(a)>b?!1:Blockly.RenderedConnection.superClass_.isConnectionAllowed.call(this,a)};
+Blockly.RenderedConnection.prototype.disconnectInternal_=function(a,b){Blockly.RenderedConnection.superClass_.disconnectInternal_.call(this,a,b);a.rendered&&a.render();b.rendered&&(b.updateDisabled(),b.render())};
+Blockly.RenderedConnection.prototype.respawnShadow_=function(){var a=this.getSourceBlock(),b=this.getShadowDom();if(a.workspace&&b&&Blockly.Events.recordUndo){Blockly.RenderedConnection.superClass_.respawnShadow_.call(this);b=this.targetBlock();if(!b)throw Error("Couldn't respawn the shadow block that should exist here.");b.initSvg();b.render(!1);a.rendered&&a.render()}};Blockly.RenderedConnection.prototype.neighbours_=function(a){return this.dbOpposite_.getNeighbours(this,a)};
+Blockly.RenderedConnection.prototype.connect_=function(a){Blockly.RenderedConnection.superClass_.connect_.call(this,a);var b=this.getSourceBlock();a=a.getSourceBlock();b.rendered&&b.updateDisabled();a.rendered&&a.updateDisabled();b.rendered&&a.rendered&&(this.type==Blockly.NEXT_STATEMENT||this.type==Blockly.PREVIOUS_STATEMENT?a.render():b.render())};
+Blockly.RenderedConnection.prototype.onCheckChanged_=function(){this.isConnected()&&!this.checkType_(this.targetConnection)&&((this.isSuperior()?this.targetBlock():this.sourceBlock_).unplug(),this.sourceBlock_.bumpNeighbours_())};Blockly.InsertionMarkerManager=function(a){this.topBlock_=Blockly.selected=a;this.workspace_=a.workspace;this.lastMarker_=this.lastOnStack_=null;this.firstMarker_=this.createMarkerBlock_(this.topBlock_);this.localConnection_=this.closestConnection_=null;this.wouldDeleteBlock_=!1;this.markerConnection_=null;this.highlightingBlock_=!1;this.highlightedBlock_=null;this.availableConnections_=this.initAvailableConnections_()};
+Blockly.InsertionMarkerManager.prototype.dispose=function(){this.workspace_=this.topBlock_=null;this.availableConnections_.length=0;this.localConnection_=this.closestConnection_=null;Blockly.Events.disable();try{this.firstMarker_&&(this.firstMarker_.dispose(),this.firstMarker_=null),this.lastMarker_&&(this.lastMarker_.dispose(),this.lastMarker_=null)}finally{Blockly.Events.enable()}this.highlightedBlock_=null};Blockly.InsertionMarkerManager.prototype.wouldDeleteBlock=function(){return this.wouldDeleteBlock_};
+Blockly.InsertionMarkerManager.prototype.wouldConnectBlock=function(){return!!this.closestConnection_};
+Blockly.InsertionMarkerManager.prototype.applyConnections=function(){if(this.closestConnection_&&(Blockly.Events.disable(),this.hidePreview_(),Blockly.Events.enable(),this.localConnection_.connect(this.closestConnection_),this.topBlock_.rendered)){var a=this.localConnection_.isSuperior()?this.closestConnection_:this.localConnection_;Blockly.BlockAnimations.connectionUiEffect(a.getSourceBlock());this.topBlock_.getRootBlock().bringToFront()}};
+Blockly.InsertionMarkerManager.prototype.update=function(a,b){var c=this.getCandidate_(a);if((this.wouldDeleteBlock_=this.shouldDelete_(c,b))||this.shouldUpdatePreviews_(c,a))Blockly.Events.disable(),this.maybeHidePreview_(c),this.maybeShowPreview_(c),Blockly.Events.enable()};
+Blockly.InsertionMarkerManager.prototype.createMarkerBlock_=function(a){var b=a.type;Blockly.Events.disable();try{var c=this.workspace_.newBlock(b);c.setInsertionMarker(!0,a.width);if(a.mutationToDom){var d=a.mutationToDom();d&&c.domToMutation(d)}for(b=0;b<a.inputList.length;b++){var e=a.inputList[b];for(d=0;d<e.fieldRow.length;d++){var f=e.fieldRow[d];c.setFieldValue(f.getValue(),f.name)}}c.initSvg();c.getSvgRoot().setAttribute("visibility","hidden")}finally{Blockly.Events.enable()}return c};
+Blockly.InsertionMarkerManager.prototype.initAvailableConnections_=function(){var a=this.topBlock_.getConnections_(!1),b=this.topBlock_.lastConnectionInStack();b&&b!=this.topBlock_.nextConnection&&(a.push(b),this.lastOnStack_=b,this.lastMarker_=this.createMarkerBlock_(b.sourceBlock_));return a};
+Blockly.InsertionMarkerManager.prototype.shouldUpdatePreviews_=function(a,b){var c=a.local,d=a.closest,e=a.radius;if(c&&d){if(this.localConnection_&&this.closestConnection_){if(this.closestConnection_==d&&this.localConnection_==c)return!1;c=this.localConnection_.x_+b.x-this.closestConnection_.x_;var f=this.localConnection_.y_+b.y-this.closestConnection_.y_;c=Math.sqrt(c*c+f*f);return!(d&&e>c-Blockly.CURRENT_CONNECTION_PREFERENCE)}if(this.localConnection_||this.closestConnection_)console.error("Only one of localConnection_ and closestConnection_ was set.");
+else return!0}else return!(!this.localConnection_||!this.closestConnection_);console.error("Returning true from shouldUpdatePreviews, but it's not clear why.");return!0};Blockly.InsertionMarkerManager.prototype.getCandidate_=function(a){for(var b=this.getStartRadius_(),c=null,d=null,e=0;e<this.availableConnections_.length;e++){var f=this.availableConnections_[e],g=f.closest(b,a);g.connection&&(c=g.connection,d=f,b=g.radius)}return{closest:c,local:d,radius:b}};
+Blockly.InsertionMarkerManager.prototype.getStartRadius_=function(){return this.closestConnection_&&this.localConnection_?Blockly.CONNECTING_SNAP_RADIUS:Blockly.SNAP_RADIUS};
+Blockly.InsertionMarkerManager.prototype.shouldReplace_=function(){var a=this.closestConnection_,b=this.localConnection_;return b.type==Blockly.OUTPUT_VALUE?!a.isConnected()||Blockly.Connection.lastConnectionInRow_(this.topBlock_,a.targetConnection.getSourceBlock())?!1:!0:b==b.sourceBlock_.getFirstStatementConnection()?!1:!this.topBlock_.nextConnection&&b.type==Blockly.PREVIOUS_STATEMENT&&a.isConnected()?!0:!1};
+Blockly.InsertionMarkerManager.prototype.shouldDelete_=function(a,b){var c=a&&!!a.closest&&b!=Blockly.DELETE_AREA_TOOLBOX;return!!b&&!this.topBlock_.getParent()&&this.topBlock_.isDeletable()&&!c};Blockly.InsertionMarkerManager.prototype.maybeShowPreview_=function(a){if(!this.wouldDeleteBlock_){var b=a.closest;a=a.local;b&&(b==this.closestConnection_||b.sourceBlock_.isInsertionMarker()?console.log("trying to connect to an insertion marker"):(this.closestConnection_=b,this.localConnection_=a,this.showPreview_()))}};
+Blockly.InsertionMarkerManager.prototype.showPreview_=function(){this.shouldReplace_()?this.highlightBlock_():this.connectMarker_();this.closestConnection_&&this.closestConnection_.highlight()};
+Blockly.InsertionMarkerManager.prototype.maybeHidePreview_=function(a){if(a.closest){var b=this.closestConnection_!=a.closest;a=this.localConnection_!=a.local;this.closestConnection_&&this.localConnection_&&(b||a||this.wouldDeleteBlock_)&&this.hidePreview_()}else this.hidePreview_();this.localConnection_=this.closestConnection_=this.markerConnection_=null};
+Blockly.InsertionMarkerManager.prototype.hidePreview_=function(){this.closestConnection_&&this.closestConnection_.unhighlight();this.highlightingBlock_?this.unhighlightBlock_():this.markerConnection_&&this.disconnectMarker_()};
+Blockly.InsertionMarkerManager.prototype.highlightBlock_=function(){var a=this.closestConnection_,b=this.localConnection_;a.targetBlock()?(this.highlightedBlock_=a.targetBlock(),a.targetBlock().highlightForReplacement(!0)):b.type==Blockly.OUTPUT_VALUE&&(this.highlightedBlock_=a.sourceBlock_,a.sourceBlock_.highlightShapeForInput(a,!0));this.highlightingBlock_=!0};
+Blockly.InsertionMarkerManager.prototype.unhighlightBlock_=function(){var a=this.closestConnection_;a.type!=Blockly.INPUT_VALUE||a.isConnected()?this.highlightedBlock_.highlightForReplacement(!1):this.highlightedBlock_.highlightShapeForInput(a,!1);this.highlightedBlock_=null;this.highlightingBlock_=!1};
+Blockly.InsertionMarkerManager.prototype.disconnectMarker_=function(){if(this.markerConnection_){var a=this.markerConnection_,b=a.sourceBlock_,c=b.nextConnection,d=b.previousConnection,e=b.outputConnection;e=a.type==Blockly.INPUT_VALUE&&!(e&&e.targetConnection);!(a!=c||d&&d.targetConnection)||e?a.targetBlock().unplug(!1):a.type==Blockly.NEXT_STATEMENT&&a!=c?(c=a.targetConnection,c.sourceBlock_.unplug(!1),d=d?d.targetConnection:null,b.unplug(!0),d&&d.connect(c)):b.unplug(!0);if(a.targetConnection)throw"markerConnection_ still connected at the end of disconnectInsertionMarker";
+this.markerConnection_=null;b.getSvgRoot().setAttribute("visibility","hidden")}else console.log("No insertion marker connection to disconnect")};
+Blockly.InsertionMarkerManager.prototype.connectMarker_=function(){var a=this.localConnection_,b=this.closestConnection_,c=this.lastOnStack_&&a==this.lastOnStack_?this.lastMarker_:this.firstMarker_;a=c.getMatchingConnection(a.sourceBlock_,a);goog.asserts.assert(a!=this.markerConnection_,"Made it to connectMarker_ even though the marker isn't changing");c.render();c.rendered=!0;c.getSvgRoot().setAttribute("visibility","visible");c.positionNewBlock(c,a,b);a.connect(b);this.markerConnection_=a};
+Blockly.InsertionMarkerManager.prototype.getInsertionMarkers=function(){var a=[];this.firstMarker_&&a.push(this.firstMarker_);this.lastMarker_&&a.push(this.lastMarker_);return a};Blockly.BlockDragger=function(a,b){this.draggingBlock_=a;this.workspace_=b;this.draggedConnectionManager_=new Blockly.InsertionMarkerManager(this.draggingBlock_);this.deleteArea_=null;this.wouldDeleteBlock_=!1;this.startXY_=this.draggingBlock_.getRelativeToSurfaceXY();this.dragIconData_=Blockly.BlockDragger.initIconData_(a)};
+Blockly.BlockDragger.prototype.dispose=function(){this.startWorkspace_=this.workspace_=this.draggingBlock_=null;this.dragIconData_.length=0;this.draggedConnectionManager_&&(this.draggedConnectionManager_.dispose(),this.draggedConnectionManager_=null)};Blockly.BlockDragger.initIconData_=function(a){var b=[];a=a.getDescendants(!1);for(var c=0,d;d=a[c];c++){d=d.getIcons();for(var e=0;e<d.length;e++){var f={location:d[e].getIconLocation(),icon:d[e]};b.push(f)}}return b};
+Blockly.BlockDragger.prototype.startBlockDrag=function(a,b){Blockly.Events.getGroup()||Blockly.Events.setGroup(!0);this.workspace_.isMutator&&this.draggingBlock_.bringToFront();Blockly.Field.startCache();this.workspace_.setResizesEnabled(!1);Blockly.BlockAnimations.disconnectUiStop();if(this.draggingBlock_.getParent()||b&&this.draggingBlock_.nextConnection&&this.draggingBlock_.nextConnection.targetBlock()){this.draggingBlock_.unplug(b);var c=this.pixelsToWorkspaceUnits_(a);c=goog.math.Coordinate.sum(this.startXY_,
+c);this.draggingBlock_.translate(c.x,c.y);Blockly.BlockAnimations.disconnectUiEffect(this.draggingBlock_)}this.draggingBlock_.setDragging(!0);this.draggingBlock_.moveToDragSurface_();if(c=this.workspace_.getToolbox()){var d=this.draggingBlock_.isDeletable()?"blocklyToolboxDelete":"blocklyToolboxGrab";c.addStyle(d)}};
+Blockly.BlockDragger.prototype.dragBlock=function(a,b){var c=this.pixelsToWorkspaceUnits_(b),d=goog.math.Coordinate.sum(this.startXY_,c);this.draggingBlock_.moveDuringDrag(d);this.dragIcons_(c);this.deleteArea_=this.workspace_.isDeleteArea(a);this.draggedConnectionManager_.update(c,this.deleteArea_);this.updateCursorDuringBlockDrag_()};
+Blockly.BlockDragger.prototype.endBlockDrag=function(a,b){this.dragBlock(a,b);this.dragIconData_=[];Blockly.Field.stopCache();Blockly.BlockAnimations.disconnectUiStop();var c=this.pixelsToWorkspaceUnits_(b),d=goog.math.Coordinate.sum(this.startXY_,c);this.draggingBlock_.moveOffDragSurface_(d);this.maybeDeleteBlock_()||(this.draggingBlock_.moveConnections_(c.x,c.y),this.draggingBlock_.setDragging(!1),this.fireMoveEvent_(),this.draggedConnectionManager_.wouldConnectBlock()?this.draggedConnectionManager_.applyConnections():
+this.draggingBlock_.render(),this.draggingBlock_.scheduleSnapAndBump());this.workspace_.setResizesEnabled(!0);if(c=this.workspace_.getToolbox())d=this.draggingBlock_.isDeletable()?"blocklyToolboxDelete":"blocklyToolboxGrab",c.removeStyle(d);Blockly.Events.setGroup(!1)};Blockly.BlockDragger.prototype.fireMoveEvent_=function(){var a=new Blockly.Events.BlockMove(this.draggingBlock_);a.oldCoordinate=this.startXY_;a.recordNew();Blockly.Events.fire(a)};
+Blockly.BlockDragger.prototype.maybeDeleteBlock_=function(){var a=this.workspace_.trashcan;this.wouldDeleteBlock_?(a&&setTimeout(a.close.bind(a),100),this.fireMoveEvent_(),this.draggingBlock_.dispose(!1,!0)):a&&a.close();return this.wouldDeleteBlock_};
+Blockly.BlockDragger.prototype.updateCursorDuringBlockDrag_=function(){this.wouldDeleteBlock_=this.draggedConnectionManager_.wouldDeleteBlock();var a=this.workspace_.trashcan;this.wouldDeleteBlock_?(this.draggingBlock_.setDeleteStyle(!0),this.deleteArea_==Blockly.DELETE_AREA_TRASH&&a&&a.setOpen_(!0)):(this.draggingBlock_.setDeleteStyle(!1),a&&a.setOpen_(!1))};
+Blockly.BlockDragger.prototype.pixelsToWorkspaceUnits_=function(a){a=new goog.math.Coordinate(a.x/this.workspace_.scale,a.y/this.workspace_.scale);this.workspace_.isMutator&&(a=a.scale(1/this.workspace_.options.parentWorkspace.scale));return a};Blockly.BlockDragger.prototype.dragIcons_=function(a){for(var b=0;b<this.dragIconData_.length;b++){var c=this.dragIconData_[b];c.icon.setIconLocation(goog.math.Coordinate.sum(c.location,a))}};
+Blockly.BlockDragger.prototype.getInsertionMarkers=function(){return this.draggedConnectionManager_&&this.draggedConnectionManager_.getInsertionMarkers?this.draggedConnectionManager_.getInsertionMarkers():[]};Blockly.WorkspaceCommentSvg=function(a,b,c,d,e){this.svgGroup_=Blockly.utils.createSvgElement("g",{"class":"blocklyComment"},null);this.svgGroup_.translate_="";this.svgRect_=Blockly.utils.createSvgElement("rect",{"class":"blocklyCommentRect",x:0,y:0,rx:Blockly.WorkspaceCommentSvg.BORDER_RADIUS,ry:Blockly.WorkspaceCommentSvg.BORDER_RADIUS});this.svgGroup_.appendChild(this.svgRect_);this.rendered_=!1;this.useDragSurface_=Blockly.utils.is3dSupported()&&!!a.blockDragSurface_;Blockly.WorkspaceCommentSvg.superClass_.constructor.call(this,
+a,b,c,d,e);this.render()};goog.inherits(Blockly.WorkspaceCommentSvg,Blockly.WorkspaceComment);Blockly.WorkspaceCommentSvg.DEFAULT_SIZE=100;
+Blockly.WorkspaceCommentSvg.prototype.dispose=function(){this.workspace&&(Blockly.selected==this&&(this.unselect(),this.workspace.cancelCurrentGesture()),Blockly.Events.isEnabled()&&Blockly.Events.fire(new Blockly.Events.CommentDelete(this)),Blockly.utils.removeNode(this.svgGroup_),this.svgRect_=this.svgGroup_=null,this.disposeInternal_(),Blockly.Events.disable(),Blockly.WorkspaceCommentSvg.superClass_.dispose.call(this),Blockly.Events.enable())};
+Blockly.WorkspaceCommentSvg.prototype.initSvg=function(){if(!this.workspace.rendered)throw TypeError("Workspace is headless.");this.workspace.options.readOnly||this.eventsInit_||(Blockly.bindEventWithChecks_(this.svgRectTarget_,"mousedown",this,this.pathMouseDown_),Blockly.bindEventWithChecks_(this.svgHandleTarget_,"mousedown",this,this.pathMouseDown_));this.eventsInit_=!0;this.updateMovable();this.getSvgRoot().parentNode||this.workspace.getBubbleCanvas().appendChild(this.getSvgRoot())};
+Blockly.WorkspaceCommentSvg.prototype.pathMouseDown_=function(a){var b=this.workspace.getGesture(a);b&&b.handleBubbleStart(a,this)};Blockly.WorkspaceCommentSvg.prototype.showContextMenu_=function(a){if(!this.workspace.options.readOnly){var b=[];this.isDeletable()&&this.isMovable()&&(b.push(Blockly.ContextMenu.commentDuplicateOption(this)),b.push(Blockly.ContextMenu.commentDeleteOption(this)));Blockly.ContextMenu.show(a,b,this.RTL)}};
+Blockly.WorkspaceCommentSvg.prototype.select=function(){if(Blockly.selected!=this){var a=null;if(Blockly.selected){a=Blockly.selected.id;Blockly.Events.disable();try{Blockly.selected.unselect()}finally{Blockly.Events.enable()}}a=new Blockly.Events.Ui(null,"selected",a,this.id);a.workspaceId=this.workspace.id;Blockly.Events.fire(a);Blockly.selected=this;this.addSelect()}};
+Blockly.WorkspaceCommentSvg.prototype.unselect=function(){if(Blockly.selected==this){var a=new Blockly.Events.Ui(null,"selected",this.id,null);a.workspaceId=this.workspace.id;Blockly.Events.fire(a);Blockly.selected=null;this.removeSelect();this.blurFocus()}};Blockly.WorkspaceCommentSvg.prototype.addSelect=function(){Blockly.utils.addClass(this.svgGroup_,"blocklySelected");this.setFocus()};
+Blockly.WorkspaceCommentSvg.prototype.removeSelect=function(){Blockly.utils.removeClass(this.svgGroup_,"blocklySelected");this.blurFocus()};Blockly.WorkspaceCommentSvg.prototype.addFocus=function(){Blockly.utils.addClass(this.svgGroup_,"blocklyFocused")};Blockly.WorkspaceCommentSvg.prototype.removeFocus=function(){Blockly.utils.removeClass(this.svgGroup_,"blocklyFocused")};
+Blockly.WorkspaceCommentSvg.prototype.getRelativeToSurfaceXY=function(){var a=0,b=0,c=this.useDragSurface_?this.workspace.blockDragSurface_.getGroup():null,d=this.getSvgRoot();if(d){do{var e=Blockly.utils.getRelativeXY(d);a+=e.x;b+=e.y;this.useDragSurface_&&this.workspace.blockDragSurface_.getCurrentBlock()==d&&(e=this.workspace.blockDragSurface_.getSurfaceTranslation(),a+=e.x,b+=e.y);d=d.parentNode}while(d&&d!=this.workspace.getBubbleCanvas()&&d!=c)}return this.xy_=new goog.math.Coordinate(a,b)};
+Blockly.WorkspaceCommentSvg.prototype.moveBy=function(a,b){var c=new Blockly.Events.CommentMove(this),d=this.getRelativeToSurfaceXY();this.translate(d.x+a,d.y+b);this.xy_=new goog.math.Coordinate(d.x+a,d.y+b);c.recordNew();Blockly.Events.fire(c);this.workspace.resizeContents()};Blockly.WorkspaceCommentSvg.prototype.translate=function(a,b){this.xy_=new goog.math.Coordinate(a,b);this.getSvgRoot().setAttribute("transform","translate("+a+","+b+")")};
+Blockly.WorkspaceCommentSvg.prototype.moveToDragSurface_=function(){if(this.useDragSurface_){var a=this.getRelativeToSurfaceXY();this.clearTransformAttributes_();this.workspace.blockDragSurface_.translateSurface(a.x,a.y);this.workspace.blockDragSurface_.setBlocksAndShow(this.getSvgRoot())}};Blockly.WorkspaceCommentSvg.prototype.moveOffDragSurface_=function(a){this.useDragSurface_&&(this.translate(a.x,a.y),this.workspace.blockDragSurface_.clearAndHide(this.workspace.getCanvas()))};
+Blockly.WorkspaceCommentSvg.prototype.moveDuringDrag=function(a,b){a?a.translateSurface(b.x,b.y):(this.svgGroup_.translate_="translate("+b.x+","+b.y+")",this.svgGroup_.setAttribute("transform",this.svgGroup_.translate_+this.svgGroup_.skew_))};Blockly.WorkspaceCommentSvg.prototype.moveTo=function(a,b){this.translate(a,b)};Blockly.WorkspaceCommentSvg.prototype.clearTransformAttributes_=function(){Blockly.utils.removeAttribute(this.getSvgRoot(),"transform")};
+Blockly.WorkspaceCommentSvg.prototype.getBoundingRectangle=function(){var a=this.getRelativeToSurfaceXY(),b=this.getHeightWidth();if(this.RTL){var c=new goog.math.Coordinate(a.x-b.width,a.y);a=new goog.math.Coordinate(a.x,a.y+b.height)}else c=new goog.math.Coordinate(a.x,a.y),a=new goog.math.Coordinate(a.x+b.width,a.y+b.height);return{topLeft:c,bottomRight:a}};
+Blockly.WorkspaceCommentSvg.prototype.updateMovable=function(){this.isMovable()?Blockly.utils.addClass(this.svgGroup_,"blocklyDraggable"):Blockly.utils.removeClass(this.svgGroup_,"blocklyDraggable")};Blockly.WorkspaceCommentSvg.prototype.setMovable=function(a){Blockly.WorkspaceCommentSvg.superClass_.setMovable.call(this,a);this.updateMovable()};
+Blockly.WorkspaceCommentSvg.prototype.setDragging=function(a){a?(a=this.getSvgRoot(),a.translate_="",a.skew_="",Blockly.utils.addClass(this.svgGroup_,"blocklyDragging")):Blockly.utils.removeClass(this.svgGroup_,"blocklyDragging")};Blockly.WorkspaceCommentSvg.prototype.getSvgRoot=function(){return this.svgGroup_};Blockly.WorkspaceCommentSvg.prototype.getContent=function(){return this.textarea_?this.textarea_.value:this.content_};
+Blockly.WorkspaceCommentSvg.prototype.setContent=function(a){Blockly.WorkspaceCommentSvg.superClass_.setContent.call(this,a);this.textarea_&&(this.textarea_.value=a)};Blockly.WorkspaceCommentSvg.prototype.setDeleteStyle=function(a){a?Blockly.utils.addClass(this.svgGroup_,"blocklyDraggingDelete"):Blockly.utils.removeClass(this.svgGroup_,"blocklyDraggingDelete")};Blockly.WorkspaceCommentSvg.prototype.setAutoLayout=function(){};
+Blockly.WorkspaceCommentSvg.fromXml=function(a,b,c){Blockly.Events.disable();try{var d=Blockly.WorkspaceComment.parseAttributes(a),e=new Blockly.WorkspaceCommentSvg(b,d.content,d.h,d.w,d.id);b.rendered&&(e.initSvg(),e.render(!1));if(!isNaN(d.x)&&!isNaN(d.y))if(b.RTL){var f=c||b.getWidth();e.moveBy(f-d.x,d.y)}else e.moveBy(d.x,d.y)}finally{Blockly.Events.enable()}Blockly.WorkspaceComment.fireCreateEvent(e);return e};
+Blockly.WorkspaceCommentSvg.prototype.toXmlWithXY=function(a){var b;this.workspace.RTL&&(b=this.workspace.getWidth());a=this.toXml(a);var c=this.getRelativeToSurfaceXY();a.setAttribute("x",Math.round(this.workspace.RTL?b-c.x:c.x));a.setAttribute("y",Math.round(c.y));a.setAttribute("h",this.getHeight());a.setAttribute("w",this.getWidth());return a};Blockly.BubbleDragger=function(a,b){this.draggingBubble_=a;this.workspace_=b;this.deleteArea_=null;this.wouldDeleteBubble_=!1;this.startXY_=this.draggingBubble_.getRelativeToSurfaceXY();this.dragSurface_=Blockly.utils.is3dSupported()&&b.getBlockDragSurface()?b.getBlockDragSurface():null};Blockly.BubbleDragger.prototype.dispose=function(){this.dragSurface_=this.workspace_=this.draggingBubble_=null};
+Blockly.BubbleDragger.prototype.startBubbleDrag=function(){Blockly.Events.getGroup()||Blockly.Events.setGroup(!0);this.workspace_.setResizesEnabled(!1);this.draggingBubble_.setAutoLayout(!1);this.dragSurface_&&this.moveToDragSurface_();this.draggingBubble_.setDragging&&this.draggingBubble_.setDragging(!0);var a=this.workspace_.getToolbox();if(a){var b=this.draggingBubble_.isDeletable()?"blocklyToolboxDelete":"blocklyToolboxGrab";a.addStyle(b)}};
+Blockly.BubbleDragger.prototype.dragBubble=function(a,b){var c=this.pixelsToWorkspaceUnits_(b);c=goog.math.Coordinate.sum(this.startXY_,c);this.draggingBubble_.moveDuringDrag(this.dragSurface_,c);this.draggingBubble_.isDeletable()&&(this.deleteArea_=this.workspace_.isDeleteArea(a),this.updateCursorDuringBubbleDrag_())};
+Blockly.BubbleDragger.prototype.maybeDeleteBubble_=function(){var a=this.workspace_.trashcan;this.wouldDeleteBubble_?(a&&setTimeout(a.close.bind(a),100),this.fireMoveEvent_(),this.draggingBubble_.dispose(!1,!0)):a&&a.close();return this.wouldDeleteBubble_};
+Blockly.BubbleDragger.prototype.updateCursorDuringBubbleDrag_=function(){this.wouldDeleteBubble_=this.deleteArea_!=Blockly.DELETE_AREA_NONE;var a=this.workspace_.trashcan;this.wouldDeleteBubble_?(this.draggingBubble_.setDeleteStyle(!0),this.deleteArea_==Blockly.DELETE_AREA_TRASH&&a&&a.setOpen_(!0)):(this.draggingBubble_.setDeleteStyle(!1),a&&a.setOpen_(!1))};
+Blockly.BubbleDragger.prototype.endBubbleDrag=function(a,b){this.dragBubble(a,b);var c=this.pixelsToWorkspaceUnits_(b);c=goog.math.Coordinate.sum(this.startXY_,c);this.draggingBubble_.moveTo(c.x,c.y);this.maybeDeleteBubble_()||(this.dragSurface_&&this.dragSurface_.clearAndHide(this.workspace_.getBubbleCanvas()),this.draggingBubble_.setDragging&&this.draggingBubble_.setDragging(!1),this.fireMoveEvent_());this.workspace_.setResizesEnabled(!0);this.workspace_.toolbox_&&(c=this.draggingBubble_.isDeletable()?
+"blocklyToolboxDelete":"blocklyToolboxGrab",this.workspace_.toolbox_.removeStyle(c));Blockly.Events.setGroup(!1)};Blockly.BubbleDragger.prototype.fireMoveEvent_=function(){if(this.draggingBubble_.isComment){var a=new Blockly.Events.CommentMove(this.draggingBubble_);a.setOldCoordinate(this.startXY_);a.recordNew();Blockly.Events.fire(a)}};
+Blockly.BubbleDragger.prototype.pixelsToWorkspaceUnits_=function(a){a=new goog.math.Coordinate(a.x/this.workspace_.scale,a.y/this.workspace_.scale);this.workspace_.isMutator&&(a=a.scale(1/this.workspace_.options.parentWorkspace.scale));return a};Blockly.BubbleDragger.prototype.moveToDragSurface_=function(){this.draggingBubble_.moveTo(0,0);this.dragSurface_.translateSurface(this.startXY_.x,this.startXY_.y);this.dragSurface_.setBlocksAndShow(this.draggingBubble_.getSvgRoot())};Blockly.WorkspaceDragger=function(a){this.workspace_=a;this.startDragMetrics_=a.getMetrics();this.startScrollXY_=new goog.math.Coordinate(a.scrollX,a.scrollY)};Blockly.WorkspaceDragger.prototype.dispose=function(){this.workspace_=null};Blockly.WorkspaceDragger.prototype.startDrag=function(){Blockly.selected&&Blockly.selected.unselect();this.workspace_.setupDragSurface()};Blockly.WorkspaceDragger.prototype.endDrag=function(a){this.drag(a);this.workspace_.resetDragSurface()};
+Blockly.WorkspaceDragger.prototype.drag=function(a){var b=this.startDragMetrics_,c=goog.math.Coordinate.sum(this.startScrollXY_,a);a=Math.min(c.x,-b.contentLeft);c=Math.min(c.y,-b.contentTop);a=Math.max(a,b.viewWidth-b.contentLeft-b.contentWidth);c=Math.max(c,b.viewHeight-b.contentTop-b.contentHeight);a=-a-b.contentLeft;c=-c-b.contentTop;this.updateScroll_(a,c)};Blockly.WorkspaceDragger.prototype.updateScroll_=function(a,b){this.workspace_.scrollbar.set(a,b)};Blockly.FlyoutDragger=function(a){Blockly.FlyoutDragger.superClass_.constructor.call(this,a.getWorkspace());this.scrollbar_=a.scrollbar_;this.horizontalLayout_=a.horizontalLayout_};goog.inherits(Blockly.FlyoutDragger,Blockly.WorkspaceDragger);Blockly.FlyoutDragger.prototype.updateScroll_=function(a,b){this.horizontalLayout_?this.scrollbar_.set(a):this.scrollbar_.set(b)};Blockly.Tooltip={};Blockly.Tooltip.visible=!1;Blockly.Tooltip.blocked_=!1;Blockly.Tooltip.LIMIT=50;Blockly.Tooltip.mouseOutPid_=0;Blockly.Tooltip.showPid_=0;Blockly.Tooltip.lastX_=0;Blockly.Tooltip.lastY_=0;Blockly.Tooltip.element_=null;Blockly.Tooltip.poisonedElement_=null;Blockly.Tooltip.OFFSET_X=0;Blockly.Tooltip.OFFSET_Y=10;Blockly.Tooltip.RADIUS_OK=10;Blockly.Tooltip.HOVER_MS=750;Blockly.Tooltip.MARGINS=5;Blockly.Tooltip.DIV=null;
+Blockly.Tooltip.createDom=function(){Blockly.Tooltip.DIV||(Blockly.Tooltip.DIV=document.createElement("div"),Blockly.Tooltip.DIV.className="blocklyTooltipDiv",document.body.appendChild(Blockly.Tooltip.DIV))};Blockly.Tooltip.bindMouseEvents=function(a){Blockly.bindEvent_(a,"mouseover",null,Blockly.Tooltip.onMouseOver_);Blockly.bindEvent_(a,"mouseout",null,Blockly.Tooltip.onMouseOut_);a.addEventListener("mousemove",Blockly.Tooltip.onMouseMove_,!1)};
+Blockly.Tooltip.onMouseOver_=function(a){if(!Blockly.Tooltip.blocked_){for(a=a.target;"string"!=typeof a.tooltip&&"function"!=typeof a.tooltip;)a=a.tooltip;Blockly.Tooltip.element_!=a&&(Blockly.Tooltip.hide(),Blockly.Tooltip.poisonedElement_=null,Blockly.Tooltip.element_=a);clearTimeout(Blockly.Tooltip.mouseOutPid_)}};
+Blockly.Tooltip.onMouseOut_=function(a){Blockly.Tooltip.blocked_||(Blockly.Tooltip.mouseOutPid_=setTimeout(function(){Blockly.Tooltip.element_=null;Blockly.Tooltip.poisonedElement_=null;Blockly.Tooltip.hide()},1),clearTimeout(Blockly.Tooltip.showPid_))};
+Blockly.Tooltip.onMouseMove_=function(a){if(Blockly.Tooltip.element_&&Blockly.Tooltip.element_.tooltip&&!Blockly.WidgetDiv.isVisible()&&!Blockly.Tooltip.blocked_)if(Blockly.Tooltip.visible){var b=Blockly.Tooltip.lastX_-a.pageX;a=Blockly.Tooltip.lastY_-a.pageY;Math.sqrt(b*b+a*a)>Blockly.Tooltip.RADIUS_OK&&Blockly.Tooltip.hide()}else Blockly.Tooltip.poisonedElement_!=Blockly.Tooltip.element_&&(clearTimeout(Blockly.Tooltip.showPid_),Blockly.Tooltip.lastX_=a.pageX,Blockly.Tooltip.lastY_=a.pageY,Blockly.Tooltip.showPid_=
+setTimeout(Blockly.Tooltip.show_,Blockly.Tooltip.HOVER_MS))};Blockly.Tooltip.hide=function(){Blockly.Tooltip.visible&&(Blockly.Tooltip.visible=!1,Blockly.Tooltip.DIV&&(Blockly.Tooltip.DIV.style.display="none"));Blockly.Tooltip.showPid_&&clearTimeout(Blockly.Tooltip.showPid_)};Blockly.Tooltip.block=function(){Blockly.Tooltip.hide();Blockly.Tooltip.blocked_=!0};Blockly.Tooltip.unblock=function(){Blockly.Tooltip.blocked_=!1};
+Blockly.Tooltip.show_=function(){if(!Blockly.Tooltip.blocked_&&(Blockly.Tooltip.poisonedElement_=Blockly.Tooltip.element_,Blockly.Tooltip.DIV)){Blockly.Tooltip.DIV.innerHTML="";for(var a=Blockly.Tooltip.element_.tooltip;"function"==typeof a;)a=a();a=Blockly.utils.wrap(a,Blockly.Tooltip.LIMIT);a=a.split("\n");for(var b=0;b<a.length;b++){var c=document.createElement("div");c.appendChild(document.createTextNode(a[b]));Blockly.Tooltip.DIV.appendChild(c)}a=Blockly.Tooltip.element_.RTL;b=goog.dom.getViewportSize();
+Blockly.Tooltip.DIV.style.direction=a?"rtl":"ltr";Blockly.Tooltip.DIV.style.display="block";Blockly.Tooltip.visible=!0;c=Blockly.Tooltip.lastX_;c=a?c-(Blockly.Tooltip.OFFSET_X+Blockly.Tooltip.DIV.offsetWidth):c+Blockly.Tooltip.OFFSET_X;var d=Blockly.Tooltip.lastY_+Blockly.Tooltip.OFFSET_Y;d+Blockly.Tooltip.DIV.offsetHeight>b.height+window.scrollY&&(d-=Blockly.Tooltip.DIV.offsetHeight+2*Blockly.Tooltip.OFFSET_Y);a?c=Math.max(Blockly.Tooltip.MARGINS-window.scrollX,c):c+Blockly.Tooltip.DIV.offsetWidth>
+b.width+window.scrollX-2*Blockly.Tooltip.MARGINS&&(c=b.width-Blockly.Tooltip.DIV.offsetWidth-2*Blockly.Tooltip.MARGINS);Blockly.Tooltip.DIV.style.top=d+"px";Blockly.Tooltip.DIV.style.left=c+"px"}};Blockly.Gesture=function(a,b){this.startWorkspace_=this.targetBlock_=this.startBlock_=this.startField_=this.startBubble_=this.currentDragDeltaXY_=this.mouseDownXY_=null;this.creatorWorkspace_=b;this.isDraggingBubble_=this.isDraggingBlock_=this.isDraggingWorkspace_=this.hasExceededDragRadius_=!1;this.mostRecentEvent_=a;this.flyout_=this.workspaceDragger_=this.blockDragger_=this.bubbleDragger_=this.onUpWrapper_=this.onMoveWrapper_=null;this.isEnding_=this.hasStarted_=this.calledUpdateIsDragging_=!1;
+this.healStack_=!Blockly.DRAG_STACK};
+Blockly.Gesture.prototype.dispose=function(){Blockly.Touch.clearTouchIdentifier();Blockly.Tooltip.unblock();this.creatorWorkspace_.clearGesture();this.onMoveWrapper_&&Blockly.unbindEvent_(this.onMoveWrapper_);this.onUpWrapper_&&Blockly.unbindEvent_(this.onUpWrapper_);this.flyout_=this.startWorkspace_=this.targetBlock_=this.startBlock_=this.startField_=null;this.blockDragger_&&(this.blockDragger_.dispose(),this.blockDragger_=null);this.workspaceDragger_&&(this.workspaceDragger_.dispose(),this.workspaceDragger_=
+null);this.bubbleDragger_&&(this.bubbleDragger_.dispose(),this.bubbleDragger_=null)};Blockly.Gesture.prototype.updateFromEvent_=function(a){var b=new goog.math.Coordinate(a.clientX,a.clientY);this.updateDragDelta_(b)&&(this.updateIsDragging_(),Blockly.longStop_());this.mostRecentEvent_=a};
+Blockly.Gesture.prototype.updateDragDelta_=function(a){this.currentDragDeltaXY_=goog.math.Coordinate.difference(a,this.mouseDownXY_);return this.hasExceededDragRadius_?!1:this.hasExceededDragRadius_=goog.math.Coordinate.magnitude(this.currentDragDeltaXY_)>(this.flyout_?Blockly.FLYOUT_DRAG_RADIUS:Blockly.DRAG_RADIUS)};
+Blockly.Gesture.prototype.updateIsDraggingFromFlyout_=function(){return this.flyout_.isBlockCreatable_(this.targetBlock_)?!this.flyout_.isScrollable()||this.flyout_.isDragTowardWorkspace(this.currentDragDeltaXY_)?(this.startWorkspace_=this.flyout_.targetWorkspace_,this.startWorkspace_.updateScreenCalculationsIfScrolled(),Blockly.Events.getGroup()||Blockly.Events.setGroup(!0),this.startBlock_=null,this.targetBlock_=this.flyout_.createBlock(this.targetBlock_),this.targetBlock_.select(),!0):!1:!1};
+Blockly.Gesture.prototype.updateIsDraggingBubble_=function(){if(!this.startBubble_)return!1;this.isDraggingBubble_=!0;this.startDraggingBubble_();return!0};Blockly.Gesture.prototype.updateIsDraggingBlock_=function(){if(!this.targetBlock_)return!1;this.flyout_?this.isDraggingBlock_=this.updateIsDraggingFromFlyout_():this.targetBlock_.isMovable()&&(this.isDraggingBlock_=!0);return this.isDraggingBlock_?(this.startDraggingBlock_(),!0):!1};
+Blockly.Gesture.prototype.updateIsDraggingWorkspace_=function(){if(this.flyout_?this.flyout_.isScrollable():this.startWorkspace_&&this.startWorkspace_.isDraggable())this.workspaceDragger_=this.flyout_?new Blockly.FlyoutDragger(this.flyout_):new Blockly.WorkspaceDragger(this.startWorkspace_),this.isDraggingWorkspace_=!0,this.workspaceDragger_.startDrag()};
+Blockly.Gesture.prototype.updateIsDragging_=function(){if(this.calledUpdateIsDragging_)throw Error("updateIsDragging_ should only be called once per gesture.");this.calledUpdateIsDragging_=!0;this.updateIsDraggingBubble_()||this.updateIsDraggingBlock_()||this.updateIsDraggingWorkspace_()};
+Blockly.Gesture.prototype.startDraggingBlock_=function(){this.blockDragger_=new Blockly.BlockDragger(this.targetBlock_,this.startWorkspace_);this.blockDragger_.startBlockDrag(this.currentDragDeltaXY_,this.healStack_);this.blockDragger_.dragBlock(this.mostRecentEvent_,this.currentDragDeltaXY_)};
+Blockly.Gesture.prototype.startDraggingBubble_=function(){this.bubbleDragger_=new Blockly.BubbleDragger(this.startBubble_,this.startWorkspace_);this.bubbleDragger_.startBubbleDrag();this.bubbleDragger_.dragBubble(this.mostRecentEvent_,this.currentDragDeltaXY_)};
+Blockly.Gesture.prototype.doStart=function(a){Blockly.utils.isTargetInput(a)?this.cancel():(this.hasStarted_=!0,Blockly.BlockAnimations.disconnectUiStop(),this.startWorkspace_.updateScreenCalculationsIfScrolled(),this.startWorkspace_.isMutator&&this.startWorkspace_.resize(),this.startWorkspace_.markFocused(),this.mostRecentEvent_=a,Blockly.hideChaff(!!this.flyout_),Blockly.Tooltip.block(),this.targetBlock_&&this.targetBlock_.select(),Blockly.utils.isRightButton(a)?this.handleRightClick(a):("touchstart"!=
+a.type.toLowerCase()&&"pointerdown"!=a.type.toLowerCase()||"mouse"==a.pointerType||Blockly.longStart_(a,this),this.mouseDownXY_=new goog.math.Coordinate(a.clientX,a.clientY),this.healStack_=a.altKey||a.ctrlKey||a.metaKey,this.bindMouseEvents(a)))};
+Blockly.Gesture.prototype.bindMouseEvents=function(a){this.onMoveWrapper_=Blockly.bindEventWithChecks_(document,"mousemove",null,this.handleMove.bind(this));this.onUpWrapper_=Blockly.bindEventWithChecks_(document,"mouseup",null,this.handleUp.bind(this));a.preventDefault();a.stopPropagation()};
+Blockly.Gesture.prototype.handleMove=function(a){this.updateFromEvent_(a);this.isDraggingWorkspace_?this.workspaceDragger_.drag(this.currentDragDeltaXY_):this.isDraggingBlock_?this.blockDragger_.dragBlock(this.mostRecentEvent_,this.currentDragDeltaXY_):this.isDraggingBubble_&&this.bubbleDragger_.dragBubble(this.mostRecentEvent_,this.currentDragDeltaXY_);a.preventDefault();a.stopPropagation()};
+Blockly.Gesture.prototype.handleUp=function(a){this.updateFromEvent_(a);Blockly.longStop_();this.isEnding_?console.log("Trying to end a gesture recursively."):(this.isEnding_=!0,this.isDraggingBubble_?this.bubbleDragger_.endBubbleDrag(a,this.currentDragDeltaXY_):this.isDraggingBlock_?this.blockDragger_.endBlockDrag(a,this.currentDragDeltaXY_):this.isDraggingWorkspace_?this.workspaceDragger_.endDrag(this.currentDragDeltaXY_):this.isBubbleClick_()?this.doBubbleClick_():this.isFieldClick_()?this.doFieldClick_():
+this.isBlockClick_()?this.doBlockClick_():this.isWorkspaceClick_()&&this.doWorkspaceClick_(),a.preventDefault(),a.stopPropagation(),this.dispose())};
+Blockly.Gesture.prototype.cancel=function(){this.isEnding_||(Blockly.longStop_(),this.isDraggingBubble_?this.bubbleDragger_.endBubbleDrag(this.mostRecentEvent_,this.currentDragDeltaXY_):this.isDraggingBlock_?this.blockDragger_.endBlockDrag(this.mostRecentEvent_,this.currentDragDeltaXY_):this.isDraggingWorkspace_&&this.workspaceDragger_.endDrag(this.currentDragDeltaXY_),this.dispose())};
+Blockly.Gesture.prototype.handleRightClick=function(a){this.targetBlock_?(this.bringBlockToFront_(),Blockly.hideChaff(this.flyout_),this.targetBlock_.showContextMenu_(a)):this.startBubble_?this.startBubble_.showContextMenu_(a):this.startWorkspace_&&!this.flyout_&&(Blockly.hideChaff(),this.startWorkspace_.showContextMenu_(a));a.preventDefault();a.stopPropagation();this.dispose()};
+Blockly.Gesture.prototype.handleWsStart=function(a,b){if(this.hasStarted_)throw Error("Tried to call gesture.handleWsStart, but the gesture had already been started.");this.setStartWorkspace_(b);this.mostRecentEvent_=a;this.doStart(a)};Blockly.Gesture.prototype.handleFlyoutStart=function(a,b){if(this.hasStarted_)throw Error("Tried to call gesture.handleFlyoutStart, but the gesture had already been started.");this.setStartFlyout_(b);this.handleWsStart(a,b.getWorkspace())};
+Blockly.Gesture.prototype.handleBlockStart=function(a,b){if(this.hasStarted_)throw Error("Tried to call gesture.handleBlockStart, but the gesture had already been started.");this.setStartBlock(b);this.mostRecentEvent_=a};Blockly.Gesture.prototype.handleBubbleStart=function(a,b){if(this.hasStarted_)throw Error("Tried to call gesture.handleBubbleStart, but the gesture had already been started.");this.setStartBubble(b);this.mostRecentEvent_=a};
+Blockly.Gesture.prototype.doBubbleClick_=function(){this.startBubble_.setFocus&&this.startBubble_.setFocus();this.startBubble_.select&&this.startBubble_.select()};Blockly.Gesture.prototype.doFieldClick_=function(){this.startField_.showEditor_();this.bringBlockToFront_()};
+Blockly.Gesture.prototype.doBlockClick_=function(){this.flyout_&&this.flyout_.autoClose?this.targetBlock_.disabled||(Blockly.Events.getGroup()||Blockly.Events.setGroup(!0),this.flyout_.createBlock(this.targetBlock_).scheduleSnapAndBump()):Blockly.Events.fire(new Blockly.Events.Ui(this.startBlock_,"click",void 0,void 0));this.bringBlockToFront_();Blockly.Events.setGroup(!1)};Blockly.Gesture.prototype.doWorkspaceClick_=function(){Blockly.selected&&Blockly.selected.unselect()};
+Blockly.Gesture.prototype.bringBlockToFront_=function(){this.targetBlock_&&!this.flyout_&&this.targetBlock_.bringToFront()};Blockly.Gesture.prototype.setStartField=function(a){if(this.hasStarted_)throw Error("Tried to call gesture.setStartField, but the gesture had already been started.");this.startField_||(this.startField_=a)};Blockly.Gesture.prototype.setStartBubble=function(a){this.startBubble_||(this.startBubble_=a)};
+Blockly.Gesture.prototype.setStartBlock=function(a){this.startBlock_||this.startBubble_||(this.startBlock_=a,a.isInFlyout&&a!=a.getRootBlock()?this.setTargetBlock_(a.getRootBlock()):this.setTargetBlock_(a))};Blockly.Gesture.prototype.setTargetBlock_=function(a){a.isShadow()?this.setTargetBlock_(a.getParent()):this.targetBlock_=a};Blockly.Gesture.prototype.setStartWorkspace_=function(a){this.startWorkspace_||(this.startWorkspace_=a)};
+Blockly.Gesture.prototype.setStartFlyout_=function(a){this.flyout_||(this.flyout_=a)};Blockly.Gesture.prototype.isBubbleClick_=function(){return!!this.startBubble_&&!this.hasExceededDragRadius_};Blockly.Gesture.prototype.isBlockClick_=function(){return!!this.startBlock_&&!this.hasExceededDragRadius_&&!this.isFieldClick_()};Blockly.Gesture.prototype.isFieldClick_=function(){return(this.startField_?this.startField_.isCurrentlyEditable():!1)&&!this.hasExceededDragRadius_&&(!this.flyout_||!this.flyout_.autoClose)};
+Blockly.Gesture.prototype.isWorkspaceClick_=function(){return!this.startBlock_&&!this.startBubble_&&!this.startField_&&!this.hasExceededDragRadius_};Blockly.Gesture.prototype.isDragging=function(){return this.isDraggingWorkspace_||this.isDraggingBlock_||this.isDraggingBubble_};Blockly.Gesture.prototype.hasStarted=function(){return this.hasStarted_};Blockly.Gesture.prototype.getInsertionMarkers=function(){return this.blockDragger_?this.blockDragger_.getInsertionMarkers():[]};Blockly.Grid=function(a,b){this.gridPattern_=a;this.spacing_=b.spacing;this.length_=b.length;this.line2_=(this.line1_=a.firstChild)&&this.line1_.nextSibling;this.snapToGrid_=b.snap};Blockly.Grid.prototype.scale_=1;Blockly.Grid.prototype.dispose=function(){this.gridPattern_=null};Blockly.Grid.prototype.shouldSnap=function(){return this.snapToGrid_};Blockly.Grid.prototype.getSpacing=function(){return this.spacing_};Blockly.Grid.prototype.getPatternId=function(){return this.gridPattern_.id};
+Blockly.Grid.prototype.update=function(a){this.scale_=a;var b=this.spacing_*a||100;this.gridPattern_.setAttribute("width",b);this.gridPattern_.setAttribute("height",b);b=Math.floor(this.spacing_/2)+.5;var c=b-this.length_/2,d=b+this.length_/2;b*=a;c*=a;d*=a;this.setLineAttributes_(this.line1_,a,c,d,b,b);this.setLineAttributes_(this.line2_,a,b,b,c,d)};
+Blockly.Grid.prototype.setLineAttributes_=function(a,b,c,d,e,f){a&&(a.setAttribute("stroke-width",b),a.setAttribute("x1",c),a.setAttribute("y1",e),a.setAttribute("x2",d),a.setAttribute("y2",f))};Blockly.Grid.prototype.moveTo=function(a,b){this.gridPattern_.setAttribute("x",a);this.gridPattern_.setAttribute("y",b);(goog.userAgent.IE||goog.userAgent.EDGE)&&this.update(this.scale_)};
+Blockly.Grid.createDom=function(a,b,c){a=Blockly.utils.createSvgElement("pattern",{id:"blocklyGridPattern"+a,patternUnits:"userSpaceOnUse"},c);0<b.length&&0<b.spacing?(Blockly.utils.createSvgElement("line",{stroke:b.colour},a),1<b.length&&Blockly.utils.createSvgElement("line",{stroke:b.colour},a)):Blockly.utils.createSvgElement("line",{},a);return a};Blockly.Theme=function(a,b){this.blockStyles_=a;this.categoryStyles_=b};Blockly.Theme.prototype.setAllBlockStyles=function(a){for(var b in a)this.setBlockStyle(b,a[b])};Blockly.Theme.prototype.getAllBlockStyles=function(){return this.blockStyles_};Blockly.Theme.prototype.getBlockStyle=function(a){return this.blockStyles_[a]};Blockly.Theme.prototype.setBlockStyle=function(a,b){this.blockStyles_[a]=b};Blockly.Theme.prototype.getCategoryStyle=function(a){return this.categoryStyles_[a]};
+Blockly.Theme.prototype.setCategoryStyle=function(a,b){this.categoryStyles_[a]=b};Blockly.Themes={};
+var defaultBlockStyles={colour_blocks:{colourPrimary:"20"},list_blocks:{colourPrimary:"260"},logic_blocks:{colourPrimary:"210"},loop_blocks:{colourPrimary:"120"},math_blocks:{colourPrimary:"230"},procedure_blocks:{colourPrimary:"290"},text_blocks:{colourPrimary:"160"},variable_blocks:{colourPrimary:"330"},variable_dynamic_blocks:{colourPrimary:"310"},hat_blocks:{colourPrimary:"330",hat:"cap"}},categoryStyles={colour_category:{colour:"20"},list_category:{colour:"260"},logic_category:{colour:"210"},loop_category:{colour:"120"},
+math_category:{colour:"230"},procedure_category:{colour:"290"},text_category:{colour:"160"},variable_category:{colour:"330"},variable_dynamic_category:{colour:"310"}};Blockly.Themes.Classic=new Blockly.Theme(defaultBlockStyles,categoryStyles);Blockly.Options=function(a){var b=!!a.readOnly;if(b)var c=null,d=!1,e=!1,f=!1,g=!1,h=!1,k=!1;else{c=Blockly.Options.parseToolboxTree(a.toolbox);d=!(!c||!c.getElementsByTagName("category").length);e=a.trashcan;void 0===e&&(e=d);var l=a.maxTrashcanContents;e?void 0===l&&(l=32):l=0;f=a.collapse;void 0===f&&(f=d);g=a.comments;void 0===g&&(g=d);h=a.disable;void 0===h&&(h=d);k=a.sounds;void 0===k&&(k=!0)}var n=!!a.rtl,m=a.horizontalLayout;void 0===m&&(m=!1);var p=a.toolboxPosition;p="end"===p?!1:!0;p=m?
+p?Blockly.TOOLBOX_AT_TOP:Blockly.TOOLBOX_AT_BOTTOM:p==n?Blockly.TOOLBOX_AT_RIGHT:Blockly.TOOLBOX_AT_LEFT;var q=a.scrollbars;void 0===q&&(q=d);var t=a.css;void 0===t&&(t=!0);var r="https://blockly-demo.appspot.com/static/media/";a.media?r=a.media:a.path&&(r=a.path+"media/");var u=void 0===a.oneBasedIndex?!0:!!a.oneBasedIndex,v=a.theme;void 0===v&&(v=Blockly.Themes.Classic);this.RTL=n;this.oneBasedIndex=u;this.collapse=f;this.comments=g;this.disable=h;this.readOnly=b;this.maxBlocks=a.maxBlocks||Infinity;
+this.maxInstances=a.maxInstances;this.pathToMedia=r;this.hasCategories=d;this.hasScrollbars=q;this.hasTrashcan=e;this.maxTrashcanContents=l;this.hasSounds=k;this.hasCss=t;this.horizontalLayout=m;this.languageTree=c;this.gridOptions=Blockly.Options.parseGridOptions_(a);this.zoomOptions=Blockly.Options.parseZoomOptions_(a);this.toolboxPosition=p;this.theme=v};Blockly.Options.prototype.parentWorkspace=null;Blockly.Options.prototype.setMetrics=null;Blockly.Options.prototype.getMetrics=null;
+Blockly.Options.parseZoomOptions_=function(a){a=a.zoom||{};var b={};b.controls=void 0===a.controls?!1:!!a.controls;b.wheel=void 0===a.wheel?!1:!!a.wheel;b.startScale=void 0===a.startScale?1:parseFloat(a.startScale);b.maxScale=void 0===a.maxScale?3:parseFloat(a.maxScale);b.minScale=void 0===a.minScale?.3:parseFloat(a.minScale);b.scaleSpeed=void 0===a.scaleSpeed?1.2:parseFloat(a.scaleSpeed);return b};
+Blockly.Options.parseGridOptions_=function(a){a=a.grid||{};var b={};b.spacing=parseFloat(a.spacing)||0;b.colour=a.colour||"#888";b.length=parseFloat(a.length)||1;b.snap=0<b.spacing&&!!a.snap;return b};Blockly.Options.parseToolboxTree=function(a){a?("string"!=typeof a&&("undefined"==typeof XSLTProcessor&&a.outerHTML?a=a.outerHTML:a instanceof Element||(a=null)),"string"==typeof a&&(a=Blockly.Xml.textToDom(a))):a=null;return a};Blockly.ScrollbarPair=function(a){this.workspace_=a;this.hScroll=new Blockly.Scrollbar(a,!0,!0,"blocklyMainWorkspaceScrollbar");this.vScroll=new Blockly.Scrollbar(a,!1,!0,"blocklyMainWorkspaceScrollbar");this.corner_=Blockly.utils.createSvgElement("rect",{height:Blockly.Scrollbar.scrollbarThickness,width:Blockly.Scrollbar.scrollbarThickness,"class":"blocklyScrollbarBackground"},null);Blockly.utils.insertAfter(this.corner_,a.getBubbleCanvas())};Blockly.ScrollbarPair.prototype.oldHostMetrics_=null;
+Blockly.ScrollbarPair.prototype.dispose=function(){Blockly.utils.removeNode(this.corner_);this.oldHostMetrics_=this.workspace_=this.corner_=null;this.hScroll.dispose();this.hScroll=null;this.vScroll.dispose();this.vScroll=null};
+Blockly.ScrollbarPair.prototype.resize=function(){var a=this.workspace_.getMetrics();if(a){var b=!1,c=!1;this.oldHostMetrics_&&this.oldHostMetrics_.viewWidth==a.viewWidth&&this.oldHostMetrics_.viewHeight==a.viewHeight&&this.oldHostMetrics_.absoluteTop==a.absoluteTop&&this.oldHostMetrics_.absoluteLeft==a.absoluteLeft?(this.oldHostMetrics_&&this.oldHostMetrics_.contentWidth==a.contentWidth&&this.oldHostMetrics_.viewLeft==a.viewLeft&&this.oldHostMetrics_.contentLeft==a.contentLeft||(b=!0),this.oldHostMetrics_&&
+this.oldHostMetrics_.contentHeight==a.contentHeight&&this.oldHostMetrics_.viewTop==a.viewTop&&this.oldHostMetrics_.contentTop==a.contentTop||(c=!0)):c=b=!0;b&&this.hScroll.resize(a);c&&this.vScroll.resize(a);this.oldHostMetrics_&&this.oldHostMetrics_.viewWidth==a.viewWidth&&this.oldHostMetrics_.absoluteLeft==a.absoluteLeft||this.corner_.setAttribute("x",this.vScroll.position_.x);this.oldHostMetrics_&&this.oldHostMetrics_.viewHeight==a.viewHeight&&this.oldHostMetrics_.absoluteTop==a.absoluteTop||this.corner_.setAttribute("y",
+this.hScroll.position_.y);this.oldHostMetrics_=a}};Blockly.ScrollbarPair.prototype.set=function(a,b){var c={},d=a*this.hScroll.ratio_,e=b*this.vScroll.ratio_,f=this.vScroll.scrollViewSize_;c.x=this.getRatio_(d,this.hScroll.scrollViewSize_);c.y=this.getRatio_(e,f);this.workspace_.setMetrics(c);this.hScroll.setHandlePosition(d);this.vScroll.setHandlePosition(e)};Blockly.ScrollbarPair.prototype.getRatio_=function(a,b){var c=a/b;return isNaN(c)?0:c};
+Blockly.Scrollbar=function(a,b,c,d){this.workspace_=a;this.pair_=c||!1;this.horizontal_=b;this.oldHostMetrics_=null;this.createDom_(d);this.position_=new goog.math.Coordinate(0,0);a=Blockly.Scrollbar.scrollbarThickness;b?(this.svgBackground_.setAttribute("height",a),this.outerSvg_.setAttribute("height",a),this.svgHandle_.setAttribute("height",a-5),this.svgHandle_.setAttribute("y",2.5),this.lengthAttribute_="width",this.positionAttribute_="x"):(this.svgBackground_.setAttribute("width",a),this.outerSvg_.setAttribute("width",
+a),this.svgHandle_.setAttribute("width",a-5),this.svgHandle_.setAttribute("x",2.5),this.lengthAttribute_="height",this.positionAttribute_="y");this.onMouseDownBarWrapper_=Blockly.bindEventWithChecks_(this.svgBackground_,"mousedown",this,this.onMouseDownBar_);this.onMouseDownHandleWrapper_=Blockly.bindEventWithChecks_(this.svgHandle_,"mousedown",this,this.onMouseDownHandle_)};Blockly.Scrollbar.prototype.origin_=new goog.math.Coordinate(0,0);Blockly.Scrollbar.prototype.startDragMouse_=0;
+Blockly.Scrollbar.prototype.scrollViewSize_=0;Blockly.Scrollbar.prototype.handleLength_=0;Blockly.Scrollbar.prototype.handlePosition_=0;Blockly.Scrollbar.prototype.isVisible_=!0;Blockly.Scrollbar.prototype.containerVisible_=!0;Blockly.Scrollbar.scrollbarThickness=15;goog.events.BrowserFeature.TOUCH_ENABLED&&(Blockly.Scrollbar.scrollbarThickness=25);
+Blockly.Scrollbar.metricsAreEquivalent_=function(a,b){return a&&b&&a.viewWidth==b.viewWidth&&a.viewHeight==b.viewHeight&&a.viewLeft==b.viewLeft&&a.viewTop==b.viewTop&&a.absoluteTop==b.absoluteTop&&a.absoluteLeft==b.absoluteLeft&&a.contentWidth==b.contentWidth&&a.contentHeight==b.contentHeight&&a.contentLeft==b.contentLeft&&a.contentTop==b.contentTop?!0:!1};
+Blockly.Scrollbar.prototype.dispose=function(){this.cleanUp_();Blockly.unbindEvent_(this.onMouseDownBarWrapper_);this.onMouseDownBarWrapper_=null;Blockly.unbindEvent_(this.onMouseDownHandleWrapper_);this.onMouseDownHandleWrapper_=null;Blockly.utils.removeNode(this.outerSvg_);this.workspace_=this.svgHandle_=this.svgBackground_=this.svgGroup_=this.outerSvg_=null};Blockly.Scrollbar.prototype.setHandleLength_=function(a){this.handleLength_=a;this.svgHandle_.setAttribute(this.lengthAttribute_,this.handleLength_)};
+Blockly.Scrollbar.prototype.setHandlePosition=function(a){this.handlePosition_=a;this.svgHandle_.setAttribute(this.positionAttribute_,this.handlePosition_)};Blockly.Scrollbar.prototype.setScrollViewSize_=function(a){this.scrollViewSize_=a;this.outerSvg_.setAttribute(this.lengthAttribute_,this.scrollViewSize_);this.svgBackground_.setAttribute(this.lengthAttribute_,this.scrollViewSize_)};Blockly.ScrollbarPair.prototype.setContainerVisible=function(a){this.hScroll.setContainerVisible(a);this.vScroll.setContainerVisible(a)};
+Blockly.Scrollbar.prototype.setPosition_=function(a,b){this.position_.x=a;this.position_.y=b;Blockly.utils.setCssTransform(this.outerSvg_,"translate("+(this.position_.x+this.origin_.x)+"px,"+(this.position_.y+this.origin_.y)+"px)")};Blockly.Scrollbar.prototype.resize=function(a){if(!a&&(a=this.workspace_.getMetrics(),!a))return;Blockly.Scrollbar.metricsAreEquivalent_(a,this.oldHostMetrics_)||(this.oldHostMetrics_=a,this.horizontal_?this.resizeHorizontal_(a):this.resizeVertical_(a),this.onScroll_())};
+Blockly.Scrollbar.prototype.resizeHorizontal_=function(a){this.resizeViewHorizontal(a)};Blockly.Scrollbar.prototype.resizeViewHorizontal=function(a){var b=a.viewWidth-1;this.pair_&&(b-=Blockly.Scrollbar.scrollbarThickness);this.setScrollViewSize_(Math.max(0,b));b=a.absoluteLeft+.5;this.pair_&&this.workspace_.RTL&&(b+=Blockly.Scrollbar.scrollbarThickness);this.setPosition_(b,a.absoluteTop+a.viewHeight-Blockly.Scrollbar.scrollbarThickness-.5);this.resizeContentHorizontal(a)};
+Blockly.Scrollbar.prototype.resizeContentHorizontal=function(a){this.pair_||this.setVisible(this.scrollViewSize_<a.contentWidth);this.ratio_=this.scrollViewSize_/a.contentWidth;if(-Infinity==this.ratio_||Infinity==this.ratio_||isNaN(this.ratio_))this.ratio_=0;this.setHandleLength_(Math.max(0,a.viewWidth*this.ratio_));this.setHandlePosition(this.constrainHandle_((a.viewLeft-a.contentLeft)*this.ratio_))};Blockly.Scrollbar.prototype.resizeVertical_=function(a){this.resizeViewVertical(a)};
+Blockly.Scrollbar.prototype.resizeViewVertical=function(a){var b=a.viewHeight-1;this.pair_&&(b-=Blockly.Scrollbar.scrollbarThickness);this.setScrollViewSize_(Math.max(0,b));b=a.absoluteLeft+.5;this.workspace_.RTL||(b+=a.viewWidth-Blockly.Scrollbar.scrollbarThickness-1);this.setPosition_(b,a.absoluteTop+.5);this.resizeContentVertical(a)};
+Blockly.Scrollbar.prototype.resizeContentVertical=function(a){this.pair_||this.setVisible(this.scrollViewSize_<a.contentHeight);this.ratio_=this.scrollViewSize_/a.contentHeight;if(-Infinity==this.ratio_||Infinity==this.ratio_||isNaN(this.ratio_))this.ratio_=0;this.setHandleLength_(Math.max(0,a.viewHeight*this.ratio_));this.setHandlePosition(this.constrainHandle_((a.viewTop-a.contentTop)*this.ratio_))};
+Blockly.Scrollbar.prototype.createDom_=function(a){var b="blocklyScrollbar"+(this.horizontal_?"Horizontal":"Vertical");a&&(b+=" "+a);this.outerSvg_=Blockly.utils.createSvgElement("svg",{"class":b},null);this.svgGroup_=Blockly.utils.createSvgElement("g",{},this.outerSvg_);this.svgBackground_=Blockly.utils.createSvgElement("rect",{"class":"blocklyScrollbarBackground"},this.svgGroup_);a=Math.floor((Blockly.Scrollbar.scrollbarThickness-5)/2);this.svgHandle_=Blockly.utils.createSvgElement("rect",{"class":"blocklyScrollbarHandle",
+rx:a,ry:a},this.svgGroup_);Blockly.utils.insertAfter(this.outerSvg_,this.workspace_.getParentSvg())};Blockly.Scrollbar.prototype.isVisible=function(){return this.isVisible_};Blockly.Scrollbar.prototype.setContainerVisible=function(a){var b=a!=this.containerVisible_;this.containerVisible_=a;b&&this.updateDisplay_()};Blockly.Scrollbar.prototype.setVisible=function(a){var b=a!=this.isVisible();if(this.pair_)throw Error("Unable to toggle visibility of paired scrollbars.");this.isVisible_=a;b&&this.updateDisplay_()};
+Blockly.Scrollbar.prototype.updateDisplay_=function(){this.containerVisible_&&this.isVisible()?this.outerSvg_.setAttribute("display","block"):this.outerSvg_.setAttribute("display","none")};
+Blockly.Scrollbar.prototype.onMouseDownBar_=function(a){this.workspace_.markFocused();Blockly.Touch.clearTouchIdentifier();this.cleanUp_();if(Blockly.utils.isRightButton(a))a.stopPropagation();else{var b=Blockly.utils.mouseToSvg(a,this.workspace_.getParentSvg(),this.workspace_.getInverseScreenCTM());b=this.horizontal_?b.x:b.y;var c=Blockly.utils.getInjectionDivXY_(this.svgHandle_);c=this.horizontal_?c.x:c.y;var d=this.handlePosition_,e=.95*this.handleLength_;b<=c?d-=e:b>=c+this.handleLength_&&(d+=
+e);this.setHandlePosition(this.constrainHandle_(d));this.onScroll_();a.stopPropagation();a.preventDefault()}};
+Blockly.Scrollbar.prototype.onMouseDownHandle_=function(a){this.workspace_.markFocused();this.cleanUp_();Blockly.utils.isRightButton(a)?a.stopPropagation():(this.startDragHandle=this.handlePosition_,this.workspace_.setupDragSurface(),this.startDragMouse_=this.horizontal_?a.clientX:a.clientY,Blockly.Scrollbar.onMouseUpWrapper_=Blockly.bindEventWithChecks_(document,"mouseup",this,this.onMouseUpHandle_),Blockly.Scrollbar.onMouseMoveWrapper_=Blockly.bindEventWithChecks_(document,"mousemove",this,this.onMouseMoveHandle_),
+a.stopPropagation(),a.preventDefault())};Blockly.Scrollbar.prototype.onMouseMoveHandle_=function(a){this.setHandlePosition(this.constrainHandle_(this.startDragHandle+((this.horizontal_?a.clientX:a.clientY)-this.startDragMouse_)));this.onScroll_()};Blockly.Scrollbar.prototype.onMouseUpHandle_=function(){this.workspace_.resetDragSurface();Blockly.Touch.clearTouchIdentifier();this.cleanUp_()};
+Blockly.Scrollbar.prototype.cleanUp_=function(){Blockly.hideChaff(!0);Blockly.Scrollbar.onMouseUpWrapper_&&(Blockly.unbindEvent_(Blockly.Scrollbar.onMouseUpWrapper_),Blockly.Scrollbar.onMouseUpWrapper_=null);Blockly.Scrollbar.onMouseMoveWrapper_&&(Blockly.unbindEvent_(Blockly.Scrollbar.onMouseMoveWrapper_),Blockly.Scrollbar.onMouseMoveWrapper_=null)};
+Blockly.Scrollbar.prototype.constrainHandle_=function(a){return a=0>=a||isNaN(a)||this.scrollViewSize_<this.handleLength_?0:Math.min(a,this.scrollViewSize_-this.handleLength_)};Blockly.Scrollbar.prototype.onScroll_=function(){var a=this.handlePosition_/this.scrollViewSize_;isNaN(a)&&(a=0);var b={};this.horizontal_?b.x=a:b.y=a;this.workspace_.setMetrics(b)};Blockly.Scrollbar.prototype.set=function(a){this.setHandlePosition(this.constrainHandle_(a*this.ratio_));this.onScroll_()};
+Blockly.Scrollbar.prototype.setOrigin=function(a,b){this.origin_=new goog.math.Coordinate(a,b)};Blockly.TouchGesture=function(a,b){Blockly.TouchGesture.superClass_.constructor.call(this,a,b);this.isMultiTouch_=!1;this.cachedPoints_={};this.startDistance_=this.previousScale_=0;this.onStartWrapper_=null};goog.inherits(Blockly.TouchGesture,Blockly.Gesture);Blockly.TouchGesture.ZOOM_IN_MULTIPLIER=5;Blockly.TouchGesture.ZOOM_OUT_MULTIPLIER=6;Blockly.TouchGesture.prototype.doStart=function(a){Blockly.TouchGesture.superClass_.doStart.call(this,a);!this.isEnding_&&Blockly.Touch.isTouchEvent(a)&&this.handleTouchStart(a)};
+Blockly.TouchGesture.prototype.bindMouseEvents=function(a){this.onStartWrapper_=Blockly.bindEventWithChecks_(document,"mousedown",null,this.handleStart.bind(this),!0);this.onMoveWrapper_=Blockly.bindEventWithChecks_(document,"mousemove",null,this.handleMove.bind(this),!0);this.onUpWrapper_=Blockly.bindEventWithChecks_(document,"mouseup",null,this.handleUp.bind(this),!0);a.preventDefault();a.stopPropagation()};
+Blockly.TouchGesture.prototype.handleStart=function(a){!this.isDragging()&&Blockly.Touch.isTouchEvent(a)&&(this.handleTouchStart(a),this.isMultiTouch()&&Blockly.longStop_())};Blockly.TouchGesture.prototype.handleMove=function(a){this.isDragging()?Blockly.Touch.shouldHandleEvent(a)&&Blockly.TouchGesture.superClass_.handleMove.call(this,a):this.isMultiTouch()?(Blockly.Touch.isTouchEvent(a)&&this.handleTouchMove(a),Blockly.longStop_()):Blockly.TouchGesture.superClass_.handleMove.call(this,a)};
+Blockly.TouchGesture.prototype.handleUp=function(a){Blockly.Touch.isTouchEvent(a)&&!this.isDragging()&&this.handleTouchEnd(a);!this.isMultiTouch()||this.isDragging()?Blockly.Touch.shouldHandleEvent(a)&&Blockly.TouchGesture.superClass_.handleUp.call(this,a):(a.preventDefault(),a.stopPropagation(),this.dispose())};Blockly.TouchGesture.prototype.isMultiTouch=function(){return this.isMultiTouch_};
+Blockly.TouchGesture.prototype.dispose=function(){Blockly.TouchGesture.superClass_.dispose.call(this);this.onStartWrapper_&&Blockly.unbindEvent_(this.onStartWrapper_)};Blockly.TouchGesture.prototype.handleTouchStart=function(a){var b=Blockly.Touch.getTouchIdentifierFromEvent(a);this.cachedPoints_[b]=this.getTouchPoint(a);b=Object.keys(this.cachedPoints_);2==b.length&&(this.startDistance_=goog.math.Coordinate.distance(this.cachedPoints_[b[0]],this.cachedPoints_[b[1]]),this.isMultiTouch_=!0,a.preventDefault())};
+Blockly.TouchGesture.prototype.handleTouchMove=function(a){var b=Blockly.Touch.getTouchIdentifierFromEvent(a);this.cachedPoints_[b]=this.getTouchPoint(a);b=Object.keys(this.cachedPoints_);if(2==b.length){b=this.touchScale_=goog.math.Coordinate.distance(this.cachedPoints_[b[0]],this.cachedPoints_[b[1]])/this.startDistance_;if(0<this.previousScale_&&Infinity>this.previousScale_){var c=b-this.previousScale_;c=0<c?c*Blockly.TouchGesture.ZOOM_IN_MULTIPLIER:c*Blockly.TouchGesture.ZOOM_OUT_MULTIPLIER;var d=
+this.startWorkspace_,e=Blockly.utils.mouseToSvg(a,d.getParentSvg(),d.getInverseScreenCTM());d.zoom(e.x,e.y,c)}this.previousScale_=b;a.preventDefault()}};Blockly.TouchGesture.prototype.handleTouchEnd=function(a){a=Blockly.Touch.getTouchIdentifierFromEvent(a);this.cachedPoints_[a]&&delete this.cachedPoints_[a];2>Object.keys(this.cachedPoints_).length&&(this.cachedPoints_={},this.previousScale_=0)};
+Blockly.TouchGesture.prototype.getTouchPoint=function(a){return this.startWorkspace_?new goog.math.Coordinate(a.pageX?a.pageX:a.changedTouches[0].pageX,a.pageY?a.pageY:a.changedTouches[0].pageY):null};Blockly.Trashcan=function(a){this.workspace_=a;this.hasBlocks_=!1;this.contents_=[];0>=this.workspace_.options.maxTrashcanContents||(a={scrollbars:!0,disabledPatternId:this.workspace_.options.disabledPatternId,parentWorkspace:this.workspace_,RTL:this.workspace_.RTL,oneBasedIndex:this.workspace_.options.oneBasedIndex},this.workspace_.horizontalLayout?(a.toolboxPosition=this.workspace_.toolboxPosition==Blockly.TOOLBOX_AT_TOP?Blockly.TOOLBOX_AT_BOTTOM:Blockly.TOOLBOX_AT_TOP,this.flyout_=new Blockly.HorizontalFlyout(a)):
+(a.toolboxPosition=this.workspace_.toolboxPosition==Blockly.TOOLBOX_AT_RIGHT?Blockly.TOOLBOX_AT_LEFT:Blockly.TOOLBOX_AT_RIGHT,this.flyout_=new Blockly.VerticalFlyout(a)),this.workspace_.addChangeListener(this.onDelete_()))};Blockly.Trashcan.prototype.WIDTH_=47;Blockly.Trashcan.prototype.BODY_HEIGHT_=44;Blockly.Trashcan.prototype.LID_HEIGHT_=16;Blockly.Trashcan.prototype.MARGIN_BOTTOM_=20;Blockly.Trashcan.prototype.MARGIN_SIDE_=20;Blockly.Trashcan.prototype.MARGIN_HOTSPOT_=10;
+Blockly.Trashcan.prototype.SPRITE_LEFT_=0;Blockly.Trashcan.prototype.SPRITE_TOP_=32;Blockly.Trashcan.prototype.HAS_BLOCKS_LID_ANGLE=.1;Blockly.Trashcan.prototype.isOpen=!1;Blockly.Trashcan.prototype.minOpenness_=0;Blockly.Trashcan.prototype.svgGroup_=null;Blockly.Trashcan.prototype.svgLid_=null;Blockly.Trashcan.prototype.lidTask_=0;Blockly.Trashcan.prototype.lidOpen_=0;Blockly.Trashcan.prototype.left_=0;Blockly.Trashcan.prototype.top_=0;
+Blockly.Trashcan.prototype.createDom=function(){this.svgGroup_=Blockly.utils.createSvgElement("g",{"class":"blocklyTrash"},null);var a=String(Math.random()).substring(2);var b=Blockly.utils.createSvgElement("clipPath",{id:"blocklyTrashBodyClipPath"+a},this.svgGroup_);Blockly.utils.createSvgElement("rect",{width:this.WIDTH_,height:this.BODY_HEIGHT_,y:this.LID_HEIGHT_},b);var c=Blockly.utils.createSvgElement("image",{width:Blockly.SPRITE.width,x:-this.SPRITE_LEFT_,height:Blockly.SPRITE.height,y:-this.SPRITE_TOP_,
+"clip-path":"url(#blocklyTrashBodyClipPath"+a+")"},this.svgGroup_);c.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",this.workspace_.options.pathToMedia+Blockly.SPRITE.url);b=Blockly.utils.createSvgElement("clipPath",{id:"blocklyTrashLidClipPath"+a},this.svgGroup_);Blockly.utils.createSvgElement("rect",{width:this.WIDTH_,height:this.LID_HEIGHT_},b);this.svgLid_=Blockly.utils.createSvgElement("image",{width:Blockly.SPRITE.width,x:-this.SPRITE_LEFT_,height:Blockly.SPRITE.height,y:-this.SPRITE_TOP_,
+"clip-path":"url(#blocklyTrashLidClipPath"+a+")"},this.svgGroup_);this.svgLid_.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",this.workspace_.options.pathToMedia+Blockly.SPRITE.url);Blockly.bindEventWithChecks_(this.svgGroup_,"mouseup",this,this.click);Blockly.bindEvent_(c,"mouseover",this,this.mouseOver_);Blockly.bindEvent_(c,"mouseout",this,this.mouseOut_);this.animateLid_();return this.svgGroup_};
+Blockly.Trashcan.prototype.init=function(a){0<this.workspace_.options.maxTrashcanContents&&(Blockly.utils.insertAfter(this.flyout_.createDom("svg"),this.workspace_.getParentSvg()),this.flyout_.init(this.workspace_),this.flyout_.isBlockCreatable_=function(){return!0});this.verticalSpacing_=this.MARGIN_BOTTOM_+a;this.setOpen_(!1);return this.verticalSpacing_+this.BODY_HEIGHT_+this.LID_HEIGHT_};
+Blockly.Trashcan.prototype.dispose=function(){this.svgGroup_&&(Blockly.utils.removeNode(this.svgGroup_),this.svgGroup_=null);this.workspace_=this.svgLid_=null;clearTimeout(this.lidTask_)};
+Blockly.Trashcan.prototype.position=function(){if(this.verticalSpacing_){var a=this.workspace_.getMetrics();a&&(this.left_=a.toolboxPosition==Blockly.TOOLBOX_AT_LEFT||this.workspace_.horizontalLayout&&!this.workspace_.RTL?a.viewWidth+a.absoluteLeft-this.WIDTH_-this.MARGIN_SIDE_-Blockly.Scrollbar.scrollbarThickness:this.MARGIN_SIDE_+Blockly.Scrollbar.scrollbarThickness,this.top_=a.toolboxPosition==Blockly.TOOLBOX_AT_BOTTOM?this.verticalSpacing_:a.viewHeight+a.absoluteTop-(this.BODY_HEIGHT_+this.LID_HEIGHT_)-
+this.verticalSpacing_,this.svgGroup_.setAttribute("transform","translate("+this.left_+","+this.top_+")"))}};Blockly.Trashcan.prototype.getClientRect=function(){if(!this.svgGroup_)return null;var a=this.svgGroup_.getBoundingClientRect();return new goog.math.Rect(a.left+this.SPRITE_LEFT_-this.MARGIN_HOTSPOT_,a.top+this.SPRITE_TOP_-this.MARGIN_HOTSPOT_,this.WIDTH_+2*this.MARGIN_HOTSPOT_,this.LID_HEIGHT_+this.BODY_HEIGHT_+2*this.MARGIN_HOTSPOT_)};
+Blockly.Trashcan.prototype.setOpen_=function(a){this.isOpen!=a&&(clearTimeout(this.lidTask_),this.isOpen=a,this.animateLid_())};Blockly.Trashcan.prototype.animateLid_=function(){this.lidOpen_+=this.isOpen?.2:-.2;this.lidOpen_=Math.min(Math.max(this.lidOpen_,this.minOpenness_),1);this.setLidAngle_(45*this.lidOpen_);this.svgGroup_.style.opacity=.4+.4*this.lidOpen_;this.lidOpen_>this.minOpenness_&&1>this.lidOpen_&&(this.lidTask_=setTimeout(this.animateLid_.bind(this),20))};
+Blockly.Trashcan.prototype.setLidAngle_=function(a){var b=this.workspace_.toolboxPosition==Blockly.TOOLBOX_AT_RIGHT||this.workspace_.horizontalLayout&&this.workspace_.RTL;this.svgLid_.setAttribute("transform","rotate("+(b?-a:a)+","+(b?4:this.WIDTH_-4)+","+(this.LID_HEIGHT_-2)+")")};Blockly.Trashcan.prototype.close=function(){this.setOpen_(!1)};Blockly.Trashcan.prototype.click=function(){if(this.hasBlocks_){for(var a=[],b=0,c;c=this.contents_[b];b++)a[b]=Blockly.Xml.textToDom(c).firstChild;this.flyout_.show(a)}};
+Blockly.Trashcan.prototype.mouseOver_=function(){this.hasBlocks_&&this.setOpen_(!0)};Blockly.Trashcan.prototype.mouseOut_=function(){this.setOpen_(!1)};
+Blockly.Trashcan.prototype.onDelete_=function(){var a=this;return function(b){0>=a.workspace_.options.maxTrashcanContents||b.type!=Blockly.Events.BLOCK_DELETE||(b=a.cleanBlockXML_(b.oldXml),-1==a.contents_.indexOf(b)&&(a.contents_.unshift(b),a.contents_.length>a.workspace_.options.maxTrashcanContents&&a.contents_.splice(a.workspace_.options.maxTrashcanContents,a.contents_.length-a.workspace_.options.maxTrashcanContents),a.hasBlocks_=!0,a.minOpenness_=a.HAS_BLOCKS_LID_ANGLE,a.setLidAngle_(45*a.minOpenness_)))}};
+Blockly.Trashcan.prototype.cleanBlockXML_=function(a){for(var b=a=a.cloneNode(!0);b;){b.removeAttribute&&(b.removeAttribute("x"),b.removeAttribute("y"),b.removeAttribute("id"));var c=b.firstChild||b.nextSibling;if(!c)for(c=b.parentNode;c;){if(c.nextSibling){c=c.nextSibling;break}c=c.parentNode}b=c}return"<xml>"+Blockly.Xml.domToText(a)+"</xml>"};Blockly.VariableModel=function(a,b,c,d){this.workspace=a;this.name=b;this.type=c||"";this.id_=d||Blockly.utils.genUid();Blockly.Events.fire(new Blockly.Events.VarCreate(this))};Blockly.VariableModel.prototype.getId=function(){return this.id_};Blockly.VariableModel.compareByName=function(a,b){var c=a.name.toLowerCase(),d=b.name.toLowerCase();return c<d?-1:c==d?0:1};Blockly.Variables={};Blockly.Variables.NAME_TYPE=Blockly.VARIABLE_CATEGORY_NAME;Blockly.Variables.allUsedVarModels=function(a){var b=a.getAllBlocks(!1);a=Object.create(null);for(var c=0;c<b.length;c++){var d=b[c].getVarModels();if(d)for(var e=0;e<d.length;e++){var f=d[e];f.getId()&&(a[f.getId()]=f)}}b=[];for(var g in a)b.push(a[g]);return b};Blockly.Variables.allUsedVariables=function(){console.warn("Deprecated call to Blockly.Variables.allUsedVariables. Use Blockly.Variables.allUsedVarModels instead.\nIf this is a major issue please file a bug on GitHub.")};
+Blockly.Variables.ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE_={};
+Blockly.Variables.allDeveloperVariables=function(a){var b=a.getAllBlocks(!1);a={};for(var c=0;c<b.length;c++){var d=b[c],e=d.getDeveloperVariables;!e&&d.getDeveloperVars&&(e=d.getDeveloperVars,Blockly.Variables.ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE_[d.type]||(console.warn("Function getDeveloperVars() deprecated. Use getDeveloperVariables() (block type '"+d.type+"')"),Blockly.Variables.ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE_[d.type]=!0));if(e)for(d=e(),e=0;e<d.length;e++)a[d[e]]=d[e]}b=[];for(var f in a)b.push(a[f]);
+return b};Blockly.Variables.flyoutCategory=function(a){var b=[],c=document.createElement("button");c.setAttribute("text","%{BKY_NEW_VARIABLE}");c.setAttribute("callbackKey","CREATE_VARIABLE");a.registerButtonCallback("CREATE_VARIABLE",function(a){Blockly.Variables.createVariableButtonHandler(a.getTargetWorkspace())});b.push(c);a=Blockly.Variables.flyoutCategoryBlocks(a);return b=b.concat(a)};
+Blockly.Variables.flyoutCategoryBlocks=function(a){a=a.getVariablesOfType("");a.sort(Blockly.VariableModel.compareByName);var b=[];if(0<a.length){var c=a[0];if(Blockly.Blocks.variables_set){var d=Blockly.Blocks.math_change?8:24;d='<xml><block type="variables_set" gap="'+d+'">'+Blockly.Variables.generateVariableFieldXmlString(c)+"</block></xml>";d=Blockly.Xml.textToDom(d).firstChild;b.push(d)}Blockly.Blocks.math_change&&(d=Blockly.Blocks.variables_get?20:8,d='<xml><block type="math_change" gap="'+
+d+'">'+Blockly.Variables.generateVariableFieldXmlString(c)+'<value name="DELTA"><shadow type="math_number"><field name="NUM">1</field></shadow></value></block></xml>',d=Blockly.Xml.textToDom(d).firstChild,b.push(d));for(c=0;d=a[c];c++)Blockly.Blocks.variables_get&&(d='<xml><block type="variables_get" gap="8">'+Blockly.Variables.generateVariableFieldXmlString(d)+"</block></xml>",d=Blockly.Xml.textToDom(d).firstChild,b.push(d))}return b};
+Blockly.Variables.generateUniqueName=function(a){a=a.getAllVariables();var b="";if(a.length)for(var c=1,d=0,e="ijkmnopqrstuvwxyzabcdefgh".charAt(d);!b;){for(var f=!1,g=0;g<a.length;g++)if(a[g].name.toLowerCase()==e){f=!0;break}f?(d++,25==d&&(d=0,c++),e="ijkmnopqrstuvwxyzabcdefgh".charAt(d),1<c&&(e+=c)):b=e}else b="i";return b};
+Blockly.Variables.createVariableButtonHandler=function(a,b,c){var d=c||"",e=function(c){Blockly.Variables.promptName(Blockly.Msg.NEW_VARIABLE_TITLE,c,function(c){if(c){var f=Blockly.Variables.nameUsedWithAnyType_(c,a);if(f){var g=c.toLowerCase();if(f.type==d)var l=Blockly.Msg.VARIABLE_ALREADY_EXISTS.replace("%1",g);else l=Blockly.Msg.VARIABLE_ALREADY_EXISTS_FOR_ANOTHER_TYPE,l=l.replace("%1",g).replace("%2",f.type);Blockly.alert(l,function(){e(c)})}else a.createVariable(c,d),b&&b(c)}else b&&b(null)})};
+e("")};goog.exportSymbol("Blockly.Variables.createVariableButtonHandler",Blockly.Variables.createVariableButtonHandler);Blockly.Variables.createVariable=Blockly.Variables.createVariableButtonHandler;goog.exportSymbol("Blockly.Variables.createVariable",Blockly.Variables.createVariable);
+Blockly.Variables.renameVariable=function(a,b,c){var d=function(e){var f=Blockly.Msg.RENAME_VARIABLE_TITLE.replace("%1",b.name);Blockly.Variables.promptName(f,e,function(e){if(e){var f=Blockly.Variables.nameUsedWithOtherType_(e,b.type,a);f?(f=Blockly.Msg.VARIABLE_ALREADY_EXISTS_FOR_ANOTHER_TYPE.replace("%1",e.toLowerCase()).replace("%2",f.type),Blockly.alert(f,function(){d(e)})):(a.renameVariableById(b.getId(),e),c&&c(e))}else c&&c(null)})};d("")};
+Blockly.Variables.promptName=function(a,b,c){Blockly.prompt(a,b,function(a){a&&(a=a.replace(/[\s\xa0]+/g," ").replace(/^ | $/g,""),a==Blockly.Msg.RENAME_VARIABLE||a==Blockly.Msg.NEW_VARIABLE)&&(a=null);c(a)})};Blockly.Variables.nameUsedWithOtherType_=function(a,b,c){c=c.getVariableMap().getAllVariables();a=a.toLowerCase();for(var d=0,e;e=c[d];d++)if(e.name.toLowerCase()==a&&e.type!=b)return e;return null};
+Blockly.Variables.nameUsedWithAnyType_=function(a,b){var c=b.getVariableMap().getAllVariables();a=a.toLowerCase();for(var d=0,e;e=c[d];d++)if(e.name.toLowerCase()==a)return e;return null};Blockly.Variables.generateVariableFieldXmlString=function(a){var b=a.type;""==b&&(b="''");return'<field name="VAR" id="'+a.getId()+'" variabletype="'+goog.string.htmlEscape(b)+'">'+goog.string.htmlEscape(a.name)+"</field>"};
+Blockly.Variables.generateVariableFieldDom=function(a){a=Blockly.Variables.generateVariableFieldXmlString(a);return Blockly.Xml.textToDom("<xml>"+a+"</xml>").firstChild};Blockly.Variables.getOrCreateVariablePackage=function(a,b,c,d){var e=Blockly.Variables.getVariable(a,b,c,d);e||(e=Blockly.Variables.createVariable_(a,b,c,d));return e};
+Blockly.Variables.getVariable=function(a,b,c,d){var e=a.getPotentialVariableMap();if(b){var f=a.getVariableById(b);!f&&e&&(f=e.getVariableById(b));if(f)return f}if(c){if(void 0==d)throw Error("Tried to look up a variable by name without a type");f=a.getVariable(c,d);!f&&e&&(f=e.getVariable(c,d))}return f};
+Blockly.Variables.createVariable_=function(a,b,c,d){var e=a.getPotentialVariableMap();c||(c=Blockly.Variables.generateUniqueName(a.isFlyout?a.targetWorkspace:a));return e?e.createVariable(c,d,b):a.createVariable(c,d,b)};Blockly.Variables.getAddedVariables=function(a,b){var c=a.getAllVariables(),d=[];if(b.length!=c.length)for(var e=0;e<c.length;e++){var f=c[e];-1==b.indexOf(f)&&d.push(f)}return d};Blockly.VariablesDynamic={};Blockly.VariablesDynamic.onCreateVariableButtonClick_String=function(a){Blockly.Variables.createVariableButtonHandler(a.getTargetWorkspace(),null,"String")};Blockly.VariablesDynamic.onCreateVariableButtonClick_Number=function(a){Blockly.Variables.createVariableButtonHandler(a.getTargetWorkspace(),null,"Number")};Blockly.VariablesDynamic.onCreateVariableButtonClick_Colour=function(a){Blockly.Variables.createVariableButtonHandler(a.getTargetWorkspace(),null,"Colour")};
+Blockly.VariablesDynamic.flyoutCategory=function(a){var b=[],c=document.createElement("button");c.setAttribute("text",Blockly.Msg.NEW_STRING_VARIABLE);c.setAttribute("callbackKey","CREATE_VARIABLE_STRING");b.push(c);c=document.createElement("button");c.setAttribute("text",Blockly.Msg.NEW_NUMBER_VARIABLE);c.setAttribute("callbackKey","CREATE_VARIABLE_NUMBER");b.push(c);c=document.createElement("button");c.setAttribute("text",Blockly.Msg.NEW_COLOUR_VARIABLE);c.setAttribute("callbackKey","CREATE_VARIABLE_COLOUR");
+b.push(c);a.registerButtonCallback("CREATE_VARIABLE_STRING",Blockly.VariablesDynamic.onCreateVariableButtonClick_String);a.registerButtonCallback("CREATE_VARIABLE_NUMBER",Blockly.VariablesDynamic.onCreateVariableButtonClick_Number);a.registerButtonCallback("CREATE_VARIABLE_COLOUR",Blockly.VariablesDynamic.onCreateVariableButtonClick_Colour);a=Blockly.VariablesDynamic.flyoutCategoryBlocks(a);return b=b.concat(a)};
+Blockly.VariablesDynamic.flyoutCategoryBlocks=function(a){a=a.getAllVariables();a.sort(Blockly.VariableModel.compareByName);var b=[];if(0<a.length){if(Blockly.Blocks.variables_set_dynamic){var c='<xml><block type="variables_set_dynamic" gap="24">'+Blockly.Variables.generateVariableFieldXmlString(a[0])+"</block></xml>";c=Blockly.Xml.textToDom(c).firstChild;b.push(c)}if(Blockly.Blocks.variables_get_dynamic)for(var d=0;c=a[d];d++)c='<xml><block type="variables_get_dynamic" gap="8">'+Blockly.Variables.generateVariableFieldXmlString(c)+
+"</block></xml>",c=Blockly.Xml.textToDom(c).firstChild,b.push(c)}return b};Blockly.WorkspaceAudio=function(a){this.parentWorkspace_=a;this.SOUNDS_=Object.create(null)};Blockly.WorkspaceAudio.prototype.lastSound_=null;Blockly.WorkspaceAudio.prototype.dispose=function(){this.SOUNDS_=this.parentWorkspace_=null};Blockly.WorkspaceAudio.prototype.load=function(a,b){if(a.length){try{var c=new window.Audio}catch(h){return}for(var d,e=0;e<a.length;e++){var f=a[e],g=f.match(/\.(\w+)$/);if(g&&c.canPlayType("audio/"+g[1])){d=new window.Audio(f);break}}d&&d.play&&(this.SOUNDS_[b]=d)}};
+Blockly.WorkspaceAudio.prototype.preload=function(){for(var a in this.SOUNDS_){var b=this.SOUNDS_[a];b.volume=.01;b.play()["catch"](function(){});b.pause();if(goog.userAgent.IPAD||goog.userAgent.IPHONE)break}};
+Blockly.WorkspaceAudio.prototype.play=function(a,b){var c=this.SOUNDS_[a];if(c){var d=new Date;null!=this.lastSound_&&d-this.lastSound_<Blockly.SOUND_LIMIT||(this.lastSound_=d,c=goog.userAgent.DOCUMENT_MODE&&9===goog.userAgent.DOCUMENT_MODE||goog.userAgent.IPAD||goog.userAgent.ANDROID?c:c.cloneNode(),c.volume=void 0===b?1:b,c.play())}else this.parentWorkspace_&&this.parentWorkspace_.getAudioManager().play(a,b)};Blockly.WorkspaceCommentSvg.render={};Blockly.WorkspaceCommentSvg.RESIZE_SIZE=8;Blockly.WorkspaceCommentSvg.BORDER_RADIUS=3;Blockly.WorkspaceCommentSvg.TEXTAREA_OFFSET=2;Blockly.WorkspaceCommentSvg.TOP_OFFSET=10;Blockly.WorkspaceCommentSvg.prototype.getHeightWidth=function(){return{width:this.getWidth(),height:this.getHeight()}};
+Blockly.WorkspaceCommentSvg.prototype.render=function(){if(!this.rendered_){var a=this.getHeightWidth();this.createEditor_();this.svgGroup_.appendChild(this.foreignObject_);this.svgHandleTarget_=Blockly.utils.createSvgElement("rect",{"class":"blocklyCommentHandleTarget",x:0,y:0});this.svgGroup_.appendChild(this.svgHandleTarget_);this.svgRectTarget_=Blockly.utils.createSvgElement("rect",{"class":"blocklyCommentTarget",x:0,y:0,rx:Blockly.WorkspaceCommentSvg.BORDER_RADIUS,ry:Blockly.WorkspaceCommentSvg.BORDER_RADIUS});
+this.svgGroup_.appendChild(this.svgRectTarget_);this.addResizeDom_();this.isDeletable()&&this.addDeleteDom_();this.setSize_(a.width,a.height);this.textarea_.value=this.content_;this.rendered_=!0;this.resizeGroup_&&Blockly.bindEventWithChecks_(this.resizeGroup_,"mousedown",this,this.resizeMouseDown_);this.isDeletable()&&(Blockly.bindEventWithChecks_(this.deleteGroup_,"mousedown",this,this.deleteMouseDown_),Blockly.bindEventWithChecks_(this.deleteGroup_,"mouseout",this,this.deleteMouseOut_),Blockly.bindEventWithChecks_(this.deleteGroup_,
+"mouseup",this,this.deleteMouseUp_))}};
+Blockly.WorkspaceCommentSvg.prototype.createEditor_=function(){this.foreignObject_=Blockly.utils.createSvgElement("foreignObject",{x:0,y:Blockly.WorkspaceCommentSvg.TOP_OFFSET,"class":"blocklyCommentForeignObject"},null);var a=document.createElementNS(Blockly.HTML_NS,"body");a.setAttribute("xmlns",Blockly.HTML_NS);a.className="blocklyMinimalBody";var b=document.createElementNS(Blockly.HTML_NS,"textarea");b.className="blocklyCommentTextarea";b.setAttribute("dir",this.RTL?"RTL":"LTR");a.appendChild(b);
+this.textarea_=b;this.foreignObject_.appendChild(a);Blockly.bindEventWithChecks_(b,"wheel",this,function(a){a.stopPropagation()});Blockly.bindEventWithChecks_(b,"change",this,function(a){this.setContent(b.value)});return this.foreignObject_};
+Blockly.WorkspaceCommentSvg.prototype.addResizeDom_=function(){this.resizeGroup_=Blockly.utils.createSvgElement("g",{"class":this.RTL?"blocklyResizeSW":"blocklyResizeSE"},this.svgGroup_);var a=Blockly.WorkspaceCommentSvg.RESIZE_SIZE;Blockly.utils.createSvgElement("polygon",{points:"0,x x,x x,0".replace(/x/g,a.toString())},this.resizeGroup_);Blockly.utils.createSvgElement("line",{"class":"blocklyResizeLine",x1:a/3,y1:a-1,x2:a-1,y2:a/3},this.resizeGroup_);Blockly.utils.createSvgElement("line",{"class":"blocklyResizeLine",
+x1:2*a/3,y1:a-1,x2:a-1,y2:2*a/3},this.resizeGroup_)};
+Blockly.WorkspaceCommentSvg.prototype.addDeleteDom_=function(){this.deleteGroup_=Blockly.utils.createSvgElement("g",{"class":"blocklyCommentDeleteIcon"},this.svgGroup_);this.deleteIconBorder_=Blockly.utils.createSvgElement("circle",{"class":"blocklyDeleteIconShape",r:"7",cx:"7.5",cy:"7.5"},this.deleteGroup_);Blockly.utils.createSvgElement("line",{x1:"5",y1:"10",x2:"10",y2:"5",stroke:"#fff","stroke-width":"2"},this.deleteGroup_);Blockly.utils.createSvgElement("line",{x1:"5",y1:"5",x2:"10",y2:"10",
+stroke:"#fff","stroke-width":"2"},this.deleteGroup_)};
+Blockly.WorkspaceCommentSvg.prototype.resizeMouseDown_=function(a){this.unbindDragEvents_();Blockly.utils.isRightButton(a)||(this.workspace.startDrag(a,new goog.math.Coordinate(this.workspace.RTL?-this.width_:this.width_,this.height_)),this.onMouseUpWrapper_=Blockly.bindEventWithChecks_(document,"mouseup",this,this.resizeMouseUp_),this.onMouseMoveWrapper_=Blockly.bindEventWithChecks_(document,"mousemove",this,this.resizeMouseMove_),Blockly.hideChaff());a.stopPropagation()};
+Blockly.WorkspaceCommentSvg.prototype.deleteMouseDown_=function(a){Blockly.utils.addClass(this.deleteIconBorder_,"blocklyDeleteIconHighlighted");a.stopPropagation()};Blockly.WorkspaceCommentSvg.prototype.deleteMouseOut_=function(){Blockly.utils.removeClass(this.deleteIconBorder_,"blocklyDeleteIconHighlighted")};Blockly.WorkspaceCommentSvg.prototype.deleteMouseUp_=function(a){this.dispose(!0,!0);a.stopPropagation()};
+Blockly.WorkspaceCommentSvg.prototype.unbindDragEvents_=function(){this.onMouseUpWrapper_&&(Blockly.unbindEvent_(this.onMouseUpWrapper_),this.onMouseUpWrapper_=null);this.onMouseMoveWrapper_&&(Blockly.unbindEvent_(this.onMouseMoveWrapper_),this.onMouseMoveWrapper_=null)};Blockly.WorkspaceCommentSvg.prototype.resizeMouseUp_=function(){Blockly.Touch.clearTouchIdentifier();this.unbindDragEvents_()};
+Blockly.WorkspaceCommentSvg.prototype.resizeMouseMove_=function(a){this.autoLayout_=!1;a=this.workspace.moveDrag(a);this.setSize_(this.RTL?-a.x:a.x,a.y)};
+Blockly.WorkspaceCommentSvg.prototype.resizeComment_=function(){var a=this.getHeightWidth(),b=Blockly.WorkspaceCommentSvg.TOP_OFFSET,c=2*Blockly.WorkspaceCommentSvg.TEXTAREA_OFFSET;this.foreignObject_.setAttribute("width",a.width);this.foreignObject_.setAttribute("height",a.height-b);this.RTL&&this.foreignObject_.setAttribute("x",-a.width);this.textarea_.style.width=a.width-c+"px";this.textarea_.style.height=a.height-c-b+"px"};
+Blockly.WorkspaceCommentSvg.prototype.setSize_=function(a,b){a=Math.max(a,45);b=Math.max(b,20+Blockly.WorkspaceCommentSvg.TOP_OFFSET);this.width_=a;this.height_=b;this.svgRect_.setAttribute("width",a);this.svgRect_.setAttribute("height",b);this.svgRectTarget_.setAttribute("width",a);this.svgRectTarget_.setAttribute("height",b);this.svgHandleTarget_.setAttribute("width",a);this.svgHandleTarget_.setAttribute("height",Blockly.WorkspaceCommentSvg.TOP_OFFSET);this.RTL&&(this.svgRect_.setAttribute("transform",
+"scale(-1 1)"),this.svgRectTarget_.setAttribute("transform","scale(-1 1)"));var c=Blockly.WorkspaceCommentSvg.RESIZE_SIZE;this.resizeGroup_&&(this.RTL?(this.resizeGroup_.setAttribute("transform","translate("+(-a+c)+","+(b-c)+") scale(-1 1)"),this.deleteGroup_.setAttribute("transform","translate("+(-a+c)+","+-c+") scale(-1 1)")):(this.resizeGroup_.setAttribute("transform","translate("+(a-c)+","+(b-c)+")"),this.deleteGroup_.setAttribute("transform","translate("+(a-c)+","+-c+")")));this.resizeComment_()};
+Blockly.WorkspaceCommentSvg.prototype.disposeInternal_=function(){this.svgHandleTarget_=this.svgRectTarget_=this.foreignObject_=this.textarea_=null;this.disposed_=!0};Blockly.WorkspaceCommentSvg.prototype.setFocus=function(){var a=this;this.focused_=!0;setTimeout(function(){a.disposed_||(a.textarea_.focus(),a.addFocus(),Blockly.utils.addClass(a.svgRectTarget_,"blocklyCommentTargetFocused"),Blockly.utils.addClass(a.svgHandleTarget_,"blocklyCommentHandleTargetFocused"))},0)};
+Blockly.WorkspaceCommentSvg.prototype.blurFocus=function(){var a=this;this.focused_=!1;setTimeout(function(){a.disposed_||(a.textarea_.blur(),a.removeFocus(),Blockly.utils.removeClass(a.svgRectTarget_,"blocklyCommentTargetFocused"),Blockly.utils.removeClass(a.svgHandleTarget_,"blocklyCommentHandleTargetFocused"))},0)};Blockly.WorkspaceDragSurfaceSvg=function(a){this.container_=a;this.createDom()};Blockly.WorkspaceDragSurfaceSvg.prototype.SVG_=null;Blockly.WorkspaceDragSurfaceSvg.prototype.dragGroup_=null;Blockly.WorkspaceDragSurfaceSvg.prototype.container_=null;
+Blockly.WorkspaceDragSurfaceSvg.prototype.createDom=function(){this.SVG_||(this.SVG_=Blockly.utils.createSvgElement("svg",{xmlns:Blockly.SVG_NS,"xmlns:html":Blockly.HTML_NS,"xmlns:xlink":"http://www.w3.org/1999/xlink",version:"1.1","class":"blocklyWsDragSurface blocklyOverflowVisible"},null),this.container_.appendChild(this.SVG_))};
+Blockly.WorkspaceDragSurfaceSvg.prototype.translateSurface=function(a,b){var c=a.toFixed(0),d=b.toFixed(0);this.SVG_.style.display="block";Blockly.utils.setCssTransform(this.SVG_,"translate3d("+c+"px, "+d+"px, 0px)")};Blockly.WorkspaceDragSurfaceSvg.prototype.getSurfaceTranslation=function(){return Blockly.utils.getRelativeXY(this.SVG_)};
+Blockly.WorkspaceDragSurfaceSvg.prototype.clearAndHide=function(a){if(!a)throw Error("Couldn't clear and hide the drag surface: missing new surface.");var b=this.SVG_.childNodes[0],c=this.SVG_.childNodes[1];if(!(b&&c&&Blockly.utils.hasClass(b,"blocklyBlockCanvas")&&Blockly.utils.hasClass(c,"blocklyBubbleCanvas")))throw Error("Couldn't clear and hide the drag surface. A node was missing.");null!=this.previousSibling_?Blockly.utils.insertAfter(b,this.previousSibling_):a.insertBefore(b,a.firstChild);
+Blockly.utils.insertAfter(c,b);this.SVG_.style.display="none";if(this.SVG_.childNodes.length)throw Error("Drag surface was not cleared.");Blockly.utils.setCssTransform(this.SVG_,"");this.previousSibling_=null};
+Blockly.WorkspaceDragSurfaceSvg.prototype.setContentsAndShow=function(a,b,c,d,e,f){if(this.SVG_.childNodes.length)throw Error("Already dragging a block.");this.previousSibling_=c;a.setAttribute("transform","translate(0, 0) scale("+f+")");b.setAttribute("transform","translate(0, 0) scale("+f+")");this.SVG_.setAttribute("width",d);this.SVG_.setAttribute("height",e);this.SVG_.appendChild(a);this.SVG_.appendChild(b);this.SVG_.style.display="block"};
+Blockly.ZoomControls=function(a){this.workspace_=a};Blockly.ZoomControls.prototype.WIDTH_=32;Blockly.ZoomControls.prototype.HEIGHT_=110;Blockly.ZoomControls.prototype.MARGIN_BOTTOM_=20;Blockly.ZoomControls.prototype.MARGIN_SIDE_=20;Blockly.ZoomControls.prototype.svgGroup_=null;Blockly.ZoomControls.prototype.left_=0;Blockly.ZoomControls.prototype.top_=0;
+Blockly.ZoomControls.prototype.createDom=function(){this.svgGroup_=Blockly.utils.createSvgElement("g",{},null);var a=String(Math.random()).substring(2);this.createZoomOutSvg_(a);this.createZoomInSvg_(a);this.createZoomResetSvg_(a);return this.svgGroup_};Blockly.ZoomControls.prototype.init=function(a){this.verticalSpacing_=this.MARGIN_BOTTOM_+a;return this.verticalSpacing_+this.HEIGHT_};
+Blockly.ZoomControls.prototype.dispose=function(){this.svgGroup_&&(Blockly.utils.removeNode(this.svgGroup_),this.svgGroup_=null);this.workspace_=null};
+Blockly.ZoomControls.prototype.position=function(){if(this.verticalSpacing_){var a=this.workspace_.getMetrics();a&&(this.left_=a.toolboxPosition==Blockly.TOOLBOX_AT_LEFT||this.workspace_.horizontalLayout&&!this.workspace_.RTL?a.viewWidth+a.absoluteLeft-this.WIDTH_-this.MARGIN_SIDE_-Blockly.Scrollbar.scrollbarThickness:this.MARGIN_SIDE_+Blockly.Scrollbar.scrollbarThickness,a.toolboxPosition==Blockly.TOOLBOX_AT_BOTTOM?(this.top_=this.verticalSpacing_,this.zoomInGroup_.setAttribute("transform","translate(0, 34)"),
+this.zoomResetGroup_.setAttribute("transform","translate(0, 77)")):(this.top_=a.viewHeight+a.absoluteTop-this.HEIGHT_-this.verticalSpacing_,this.zoomInGroup_.setAttribute("transform","translate(0, 43)"),this.zoomOutGroup_.setAttribute("transform","translate(0, 77)")),this.svgGroup_.setAttribute("transform","translate("+this.left_+","+this.top_+")"))}};
+Blockly.ZoomControls.prototype.createZoomOutSvg_=function(a){var b=this.workspace_;this.zoomOutGroup_=Blockly.utils.createSvgElement("g",{"class":"blocklyZoom"},this.svgGroup_);var c=Blockly.utils.createSvgElement("clipPath",{id:"blocklyZoomoutClipPath"+a},this.zoomOutGroup_);Blockly.utils.createSvgElement("rect",{width:32,height:32},c);a=Blockly.utils.createSvgElement("image",{width:Blockly.SPRITE.width,height:Blockly.SPRITE.height,x:-64,y:-92,"clip-path":"url(#blocklyZoomoutClipPath"+a+")"},this.zoomOutGroup_);
+a.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",b.options.pathToMedia+Blockly.SPRITE.url);Blockly.bindEventWithChecks_(a,"mousedown",null,function(a){b.markFocused();b.zoomCenter(-1);Blockly.Touch.clearTouchIdentifier();a.stopPropagation();a.preventDefault()})};
+Blockly.ZoomControls.prototype.createZoomInSvg_=function(a){var b=this.workspace_;this.zoomInGroup_=Blockly.utils.createSvgElement("g",{"class":"blocklyZoom"},this.svgGroup_);var c=Blockly.utils.createSvgElement("clipPath",{id:"blocklyZoominClipPath"+a},this.zoomInGroup_);Blockly.utils.createSvgElement("rect",{width:32,height:32},c);a=Blockly.utils.createSvgElement("image",{width:Blockly.SPRITE.width,height:Blockly.SPRITE.height,x:-32,y:-92,"clip-path":"url(#blocklyZoominClipPath"+a+")"},this.zoomInGroup_);
+a.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",b.options.pathToMedia+Blockly.SPRITE.url);Blockly.bindEventWithChecks_(a,"mousedown",null,function(a){b.markFocused();b.zoomCenter(1);Blockly.Touch.clearTouchIdentifier();a.stopPropagation();a.preventDefault()})};
+Blockly.ZoomControls.prototype.createZoomResetSvg_=function(a){var b=this.workspace_;this.zoomResetGroup_=Blockly.utils.createSvgElement("g",{"class":"blocklyZoom"},this.svgGroup_);var c=Blockly.utils.createSvgElement("clipPath",{id:"blocklyZoomresetClipPath"+a},this.zoomResetGroup_);Blockly.utils.createSvgElement("rect",{width:32,height:32},c);a=Blockly.utils.createSvgElement("image",{width:Blockly.SPRITE.width,height:Blockly.SPRITE.height,y:-92,"clip-path":"url(#blocklyZoomresetClipPath"+a+")"},
+this.zoomResetGroup_);a.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",b.options.pathToMedia+Blockly.SPRITE.url);Blockly.bindEventWithChecks_(a,"mousedown",null,function(a){b.markFocused();b.setScale(b.options.zoomOptions.startScale);b.beginCanvasTransition();b.scrollCenter();setTimeout(function(){b.endCanvasTransition()},500);Blockly.Touch.clearTouchIdentifier();a.stopPropagation();a.preventDefault()})};
+Blockly.WorkspaceSvg=function(a,b,c){Blockly.WorkspaceSvg.superClass_.constructor.call(this,a);this.getMetrics=a.getMetrics||Blockly.WorkspaceSvg.getTopLevelWorkspaceMetrics_;this.setMetrics=a.setMetrics||Blockly.WorkspaceSvg.setTopLevelWorkspaceMetrics_;Blockly.ConnectionDB.init(this);b&&(this.blockDragSurface_=b);c&&(this.workspaceDragSurface_=c);this.useWorkspaceDragSurface_=this.workspaceDragSurface_&&Blockly.utils.is3dSupported();this.highlightedBlocks_=[];this.audioManager_=new Blockly.WorkspaceAudio(a.parentWorkspace);
+this.grid_=this.options.gridPattern?new Blockly.Grid(a.gridPattern,a.gridOptions):null;Blockly.Variables&&Blockly.Variables.flyoutCategory&&this.registerToolboxCategoryCallback(Blockly.VARIABLE_CATEGORY_NAME,Blockly.Variables.flyoutCategory);Blockly.VariablesDynamic&&Blockly.VariablesDynamic.flyoutCategory&&this.registerToolboxCategoryCallback(Blockly.VARIABLE_DYNAMIC_CATEGORY_NAME,Blockly.VariablesDynamic.flyoutCategory);Blockly.Procedures&&Blockly.Procedures.flyoutCategory&&this.registerToolboxCategoryCallback(Blockly.PROCEDURE_CATEGORY_NAME,
+Blockly.Procedures.flyoutCategory)};goog.inherits(Blockly.WorkspaceSvg,Blockly.Workspace);Blockly.WorkspaceSvg.prototype.resizeHandlerWrapper_=null;Blockly.WorkspaceSvg.prototype.rendered=!0;Blockly.WorkspaceSvg.prototype.isVisible_=!0;Blockly.WorkspaceSvg.prototype.isFlyout=!1;Blockly.WorkspaceSvg.prototype.isMutator=!1;Blockly.WorkspaceSvg.prototype.resizesEnabled_=!0;Blockly.WorkspaceSvg.prototype.scrollX=0;Blockly.WorkspaceSvg.prototype.scrollY=0;Blockly.WorkspaceSvg.prototype.startScrollX=0;
+Blockly.WorkspaceSvg.prototype.startScrollY=0;Blockly.WorkspaceSvg.prototype.dragDeltaXY_=null;Blockly.WorkspaceSvg.prototype.scale=1;Blockly.WorkspaceSvg.prototype.trashcan=null;Blockly.WorkspaceSvg.prototype.scrollbar=null;Blockly.WorkspaceSvg.prototype.currentGesture_=null;Blockly.WorkspaceSvg.prototype.blockDragSurface_=null;Blockly.WorkspaceSvg.prototype.workspaceDragSurface_=null;Blockly.WorkspaceSvg.prototype.useWorkspaceDragSurface_=!1;Blockly.WorkspaceSvg.prototype.isDragSurfaceActive_=!1;
+Blockly.WorkspaceSvg.prototype.injectionDiv_=null;Blockly.WorkspaceSvg.prototype.lastRecordedPageScroll_=null;Blockly.WorkspaceSvg.prototype.flyoutButtonCallbacks_={};Blockly.WorkspaceSvg.prototype.toolboxCategoryCallbacks_={};Blockly.WorkspaceSvg.prototype.configureContextMenu=null;Blockly.WorkspaceSvg.prototype.targetWorkspace=null;Blockly.WorkspaceSvg.prototype.inverseScreenCTM_=null;Blockly.WorkspaceSvg.prototype.inverseScreenCTMDirty_=!0;
+Blockly.WorkspaceSvg.prototype.getInverseScreenCTM=function(){if(this.inverseScreenCTMDirty_){var a=this.getParentSvg().getScreenCTM();a&&(this.inverseScreenCTM_=a.inverse(),this.inverseScreenCTMDirty_=!1)}return this.inverseScreenCTM_};Blockly.WorkspaceSvg.prototype.updateInverseScreenCTM=function(){this.inverseScreenCTMDirty_=!0};Blockly.WorkspaceSvg.prototype.isVisible=function(){return this.isVisible_};
+Blockly.WorkspaceSvg.prototype.getSvgXY=function(a){var b=0,c=0,d=1;if(Blockly.utils.containsNode(this.getCanvas(),a)||Blockly.utils.containsNode(this.getBubbleCanvas(),a))d=this.scale;do{var e=Blockly.utils.getRelativeXY(a);if(a==this.getCanvas()||a==this.getBubbleCanvas())d=1;b+=e.x*d;c+=e.y*d;a=a.parentNode}while(a&&a!=this.getParentSvg());return new goog.math.Coordinate(b,c)};Blockly.WorkspaceSvg.prototype.getOriginOffsetInPixels=function(){return Blockly.utils.getInjectionDivXY_(this.svgBlockCanvas_)};
+Blockly.WorkspaceSvg.prototype.getInjectionDiv=function(){if(!this.injectionDiv_)for(var a=this.svgGroup_;a;){if(-1!=(" "+(a.getAttribute("class")||"")+" ").indexOf(" injectionDiv ")){this.injectionDiv_=a;break}a=a.parentNode}return this.injectionDiv_};Blockly.WorkspaceSvg.prototype.setResizeHandlerWrapper=function(a){this.resizeHandlerWrapper_=a};
+Blockly.WorkspaceSvg.prototype.createDom=function(a){this.svgGroup_=Blockly.utils.createSvgElement("g",{"class":"blocklyWorkspace"},null);a&&(this.svgBackground_=Blockly.utils.createSvgElement("rect",{height:"100%",width:"100%","class":a},this.svgGroup_),"blocklyMainBackground"==a&&this.grid_&&(this.svgBackground_.style.fill="url(#"+this.grid_.getPatternId()+")"));this.svgBlockCanvas_=Blockly.utils.createSvgElement("g",{"class":"blocklyBlockCanvas"},this.svgGroup_);this.svgBubbleCanvas_=Blockly.utils.createSvgElement("g",
+{"class":"blocklyBubbleCanvas"},this.svgGroup_);this.isFlyout||(Blockly.bindEventWithChecks_(this.svgGroup_,"mousedown",this,this.onMouseDown_,!1,!0),this.options.zoomOptions&&this.options.zoomOptions.wheel&&Blockly.bindEventWithChecks_(this.svgGroup_,"wheel",this,this.onMouseWheel_));this.options.hasCategories&&(this.toolbox_=new Blockly.Toolbox(this));this.grid_&&this.grid_.update(this.scale);this.recordDeleteAreas();return this.svgGroup_};
+Blockly.WorkspaceSvg.prototype.dispose=function(){this.rendered=!1;this.currentGesture_&&this.currentGesture_.cancel();Blockly.WorkspaceSvg.superClass_.dispose.call(this);this.svgGroup_&&(Blockly.utils.removeNode(this.svgGroup_),this.svgGroup_=null);this.svgBubbleCanvas_=this.svgBlockCanvas_=null;this.toolbox_&&(this.toolbox_.dispose(),this.toolbox_=null);this.flyout_&&(this.flyout_.dispose(),this.flyout_=null);this.trashcan&&(this.trashcan.dispose(),this.trashcan=null);this.scrollbar&&(this.scrollbar.dispose(),
+this.scrollbar=null);this.zoomControls_&&(this.zoomControls_.dispose(),this.zoomControls_=null);this.audioManager_&&(this.audioManager_.dispose(),this.audioManager_=null);this.grid_&&(this.grid_.dispose(),this.grid_=null);this.toolboxCategoryCallbacks_&&(this.toolboxCategoryCallbacks_=null);this.flyoutButtonCallbacks_&&(this.flyoutButtonCallbacks_=null);if(!this.options.parentWorkspace){var a=this.getParentSvg().parentNode;a&&Blockly.utils.removeNode(a)}this.resizeHandlerWrapper_&&(Blockly.unbindEvent_(this.resizeHandlerWrapper_),
+this.resizeHandlerWrapper_=null)};Blockly.WorkspaceSvg.prototype.newBlock=function(a,b){return new Blockly.BlockSvg(this,a,b)};Blockly.WorkspaceSvg.prototype.addTrashcan=function(){this.trashcan=new Blockly.Trashcan(this);var a=this.trashcan.createDom();this.svgGroup_.insertBefore(a,this.svgBlockCanvas_)};Blockly.WorkspaceSvg.prototype.addZoomControls=function(){this.zoomControls_=new Blockly.ZoomControls(this);var a=this.zoomControls_.createDom();this.svgGroup_.appendChild(a)};
+Blockly.WorkspaceSvg.prototype.addFlyout_=function(a){var b={disabledPatternId:this.options.disabledPatternId,parentWorkspace:this,RTL:this.RTL,oneBasedIndex:this.options.oneBasedIndex,horizontalLayout:this.horizontalLayout,toolboxPosition:this.options.toolboxPosition};this.flyout_=null;this.flyout_=this.horizontalLayout?new Blockly.HorizontalFlyout(b):new Blockly.VerticalFlyout(b);this.flyout_.autoClose=!1;return this.flyout_.createDom(a)};
+Blockly.WorkspaceSvg.prototype.getFlyout_=function(){return this.flyout_?this.flyout_:this.toolbox_?this.toolbox_.flyout_:null};Blockly.WorkspaceSvg.prototype.getToolbox=function(){return this.toolbox_};Blockly.WorkspaceSvg.prototype.updateScreenCalculations_=function(){this.updateInverseScreenCTM();this.recordDeleteAreas()};Blockly.WorkspaceSvg.prototype.resizeContents=function(){this.resizesEnabled_&&this.rendered&&(this.scrollbar&&this.scrollbar.resize(),this.updateInverseScreenCTM())};
+Blockly.WorkspaceSvg.prototype.resize=function(){this.toolbox_&&this.toolbox_.position();this.flyout_&&this.flyout_.position();this.trashcan&&this.trashcan.position();this.zoomControls_&&this.zoomControls_.position();this.scrollbar&&this.scrollbar.resize();this.updateScreenCalculations_()};Blockly.WorkspaceSvg.prototype.updateScreenCalculationsIfScrolled=function(){var a=goog.dom.getDocumentScroll();goog.math.Coordinate.equals(this.lastRecordedPageScroll_,a)||(this.lastRecordedPageScroll_=a,this.updateScreenCalculations_())};
+Blockly.WorkspaceSvg.prototype.getCanvas=function(){return this.svgBlockCanvas_};Blockly.WorkspaceSvg.prototype.getBubbleCanvas=function(){return this.svgBubbleCanvas_};Blockly.WorkspaceSvg.prototype.getParentSvg=function(){if(this.cachedParentSvg_)return this.cachedParentSvg_;for(var a=this.svgGroup_;a;){if("svg"==a.tagName)return this.cachedParentSvg_=a;a=a.parentNode}return null};
+Blockly.WorkspaceSvg.prototype.translate=function(a,b){if(this.useWorkspaceDragSurface_&&this.isDragSurfaceActive_)this.workspaceDragSurface_.translateSurface(a,b);else{var c="translate("+a+","+b+") scale("+this.scale+")";this.svgBlockCanvas_.setAttribute("transform",c);this.svgBubbleCanvas_.setAttribute("transform",c)}this.blockDragSurface_&&this.blockDragSurface_.translateAndScaleGroup(a,b,this.scale)};
+Blockly.WorkspaceSvg.prototype.resetDragSurface=function(){if(this.useWorkspaceDragSurface_){this.isDragSurfaceActive_=!1;var a=this.workspaceDragSurface_.getSurfaceTranslation();this.workspaceDragSurface_.clearAndHide(this.svgGroup_);a="translate("+a.x+","+a.y+") scale("+this.scale+")";this.svgBlockCanvas_.setAttribute("transform",a);this.svgBubbleCanvas_.setAttribute("transform",a)}};
+Blockly.WorkspaceSvg.prototype.setupDragSurface=function(){if(this.useWorkspaceDragSurface_&&!this.isDragSurfaceActive_){this.isDragSurfaceActive_=!0;var a=this.svgBlockCanvas_.previousSibling,b=parseInt(this.getParentSvg().getAttribute("width"),10),c=parseInt(this.getParentSvg().getAttribute("height"),10),d=Blockly.utils.getRelativeXY(this.svgBlockCanvas_);this.workspaceDragSurface_.setContentsAndShow(this.svgBlockCanvas_,this.svgBubbleCanvas_,a,b,c,this.scale);this.workspaceDragSurface_.translateSurface(d.x,
+d.y)}};Blockly.WorkspaceSvg.prototype.getBlockDragSurface=function(){return this.blockDragSurface_};Blockly.WorkspaceSvg.prototype.getWidth=function(){var a=this.getMetrics();return a?a.viewWidth/this.scale:0};
+Blockly.WorkspaceSvg.prototype.setVisible=function(a){this.scrollbar&&this.scrollbar.setContainerVisible(a);this.getFlyout_()&&this.getFlyout_().setContainerVisible(a);this.getParentSvg().style.display=a?"block":"none";this.toolbox_&&(this.toolbox_.HtmlDiv.style.display=a?"block":"none");a?(this.render(),this.toolbox_&&this.toolbox_.position()):Blockly.hideChaff(!0);this.isVisible_=a};
+Blockly.WorkspaceSvg.prototype.render=function(){for(var a=this.getAllBlocks(!1),b=a.length-1;0<=b;b--)a[b].render(!1);if(this.currentGesture_)for(a=this.currentGesture_.getInsertionMarkers(),b=0;b<a.length;b++)a[b].render(!1)};Blockly.WorkspaceSvg.prototype.traceOn=function(){console.warn("Deprecated call to traceOn, delete this.")};
+Blockly.WorkspaceSvg.prototype.highlightBlock=function(a,b){if(void 0===b){for(var c=0,d;d=this.highlightedBlocks_[c];c++)d.setHighlighted(!1);this.highlightedBlocks_.length=0}if(d=a?this.getBlockById(a):null)(c=void 0===b||b)?-1==this.highlightedBlocks_.indexOf(d)&&this.highlightedBlocks_.push(d):Blockly.utils.arrayRemove(this.highlightedBlocks_,d),d.setHighlighted(c)};
+Blockly.WorkspaceSvg.prototype.paste=function(a){!this.rendered||a.getElementsByTagName("block").length>=this.remainingCapacity()||(this.currentGesture_&&this.currentGesture_.cancel(),"comment"==a.tagName.toLowerCase()?this.pasteWorkspaceComment_(a):this.pasteBlock_(a))};
+Blockly.WorkspaceSvg.prototype.pasteBlock_=function(a){Blockly.Events.disable();try{var b=Blockly.Xml.domToBlock(a,this),c=parseInt(a.getAttribute("x"),10),d=parseInt(a.getAttribute("y"),10);if(!isNaN(c)&&!isNaN(d)){this.RTL&&(c=-c);do{a=!1;for(var e=this.getAllBlocks(!1),f=0,g;g=e[f];f++){var h=g.getRelativeToSurfaceXY();if(1>=Math.abs(c-h.x)&&1>=Math.abs(d-h.y)){a=!0;break}}if(!a){var k=b.getConnections_(!1);f=0;for(var l;l=k[f];f++)if(l.closest(Blockly.SNAP_RADIUS,new goog.math.Coordinate(c,d)).connection){a=
+!0;break}}a&&(c=this.RTL?c-Blockly.SNAP_RADIUS:c+Blockly.SNAP_RADIUS,d+=2*Blockly.SNAP_RADIUS)}while(a);b.moveBy(c,d)}}finally{Blockly.Events.enable()}Blockly.Events.isEnabled()&&!b.isShadow()&&Blockly.Events.fire(new Blockly.Events.BlockCreate(b));b.select()};
+Blockly.WorkspaceSvg.prototype.pasteWorkspaceComment_=function(a){Blockly.Events.disable();try{var b=Blockly.WorkspaceCommentSvg.fromXml(a,this),c=parseInt(a.getAttribute("x"),10),d=parseInt(a.getAttribute("y"),10);isNaN(c)||isNaN(d)||(this.RTL&&(c=-c),b.moveBy(c+50,d+50))}finally{Blockly.Events.enable()}Blockly.Events.isEnabled();b.select()};
+Blockly.WorkspaceSvg.prototype.refreshToolboxSelection=function(){var a=this.isFlyout?this.targetWorkspace:this;a&&!a.currentGesture_&&a.toolbox_&&a.toolbox_.flyout_&&a.toolbox_.refreshSelection()};Blockly.WorkspaceSvg.prototype.renameVariableById=function(a,b){Blockly.WorkspaceSvg.superClass_.renameVariableById.call(this,a,b);this.refreshToolboxSelection()};Blockly.WorkspaceSvg.prototype.deleteVariableById=function(a){Blockly.WorkspaceSvg.superClass_.deleteVariableById.call(this,a);this.refreshToolboxSelection()};
+Blockly.WorkspaceSvg.prototype.createVariable=function(a,b,c){a=Blockly.WorkspaceSvg.superClass_.createVariable.call(this,a,b,c);this.refreshToolboxSelection();return a};Blockly.WorkspaceSvg.prototype.recordDeleteAreas=function(){this.deleteAreaTrash_=this.trashcan&&this.svgGroup_.parentNode?this.trashcan.getClientRect():null;this.deleteAreaToolbox_=this.flyout_?this.flyout_.getClientRect():this.toolbox_?this.toolbox_.getClientRect():null};
+Blockly.WorkspaceSvg.prototype.isDeleteArea=function(a){a=new goog.math.Coordinate(a.clientX,a.clientY);return this.deleteAreaTrash_&&this.deleteAreaTrash_.contains(a)?Blockly.DELETE_AREA_TRASH:this.deleteAreaToolbox_&&this.deleteAreaToolbox_.contains(a)?Blockly.DELETE_AREA_TOOLBOX:Blockly.DELETE_AREA_NONE};Blockly.WorkspaceSvg.prototype.onMouseDown_=function(a){var b=this.getGesture(a);b&&b.handleWsStart(a,this)};
+Blockly.WorkspaceSvg.prototype.startDrag=function(a,b){var c=Blockly.utils.mouseToSvg(a,this.getParentSvg(),this.getInverseScreenCTM());c.x/=this.scale;c.y/=this.scale;this.dragDeltaXY_=goog.math.Coordinate.difference(b,c)};Blockly.WorkspaceSvg.prototype.moveDrag=function(a){a=Blockly.utils.mouseToSvg(a,this.getParentSvg(),this.getInverseScreenCTM());a.x/=this.scale;a.y/=this.scale;return goog.math.Coordinate.sum(this.dragDeltaXY_,a)};
+Blockly.WorkspaceSvg.prototype.isDragging=function(){return null!=this.currentGesture_&&this.currentGesture_.isDragging()};Blockly.WorkspaceSvg.prototype.isDraggable=function(){return!!this.scrollbar};Blockly.WorkspaceSvg.prototype.onMouseWheel_=function(a){this.currentGesture_&&this.currentGesture_.cancel();var b=-a.deltaY/50,c=Blockly.utils.mouseToSvg(a,this.getParentSvg(),this.getInverseScreenCTM());this.zoom(c.x,c.y,b);a.preventDefault()};
+Blockly.WorkspaceSvg.prototype.getBlocksBoundingBox=function(){var a=this.getTopBlocks(!1),b=this.getTopComments(!1);a=a.concat(b);if(!a.length)return{x:0,y:0,width:0,height:0};b=a[0].getBoundingRectangle();for(var c=1;c<a.length;c++){var d=a[c].getBoundingRectangle();d.topLeft.x<b.topLeft.x&&(b.topLeft.x=d.topLeft.x);d.bottomRight.x>b.bottomRight.x&&(b.bottomRight.x=d.bottomRight.x);d.topLeft.y<b.topLeft.y&&(b.topLeft.y=d.topLeft.y);d.bottomRight.y>b.bottomRight.y&&(b.bottomRight.y=d.bottomRight.y)}return{x:b.topLeft.x,
+y:b.topLeft.y,width:b.bottomRight.x-b.topLeft.x,height:b.bottomRight.y-b.topLeft.y}};Blockly.WorkspaceSvg.prototype.cleanUp=function(){this.setResizesEnabled(!1);Blockly.Events.setGroup(!0);for(var a=this.getTopBlocks(!0),b=0,c=0,d;d=a[c];c++)if(d.isMovable()){var e=d.getRelativeToSurfaceXY();d.moveBy(-e.x,b-e.y);d.snapToGrid();b=d.getRelativeToSurfaceXY().y+d.getHeightWidth().height+Blockly.BlockSvg.MIN_BLOCK_Y}Blockly.Events.setGroup(!1);this.setResizesEnabled(!0)};
+Blockly.WorkspaceSvg.prototype.showContextMenu_=function(a){function b(a){if(a.isDeletable())p=p.concat(a.getDescendants(!1));else{a=a.getChildren(!1);for(var c=0;c<a.length;c++)b(a[c])}}function c(){Blockly.Events.setGroup(f);var a=p.shift();a&&(a.workspace?(a.dispose(!1,!0),setTimeout(c,10)):c());Blockly.Events.setGroup(!1)}if(!this.options.readOnly&&!this.isFlyout){var d=[],e=this.getTopBlocks(!0),f=Blockly.utils.genUid(),g=this,h={};h.text=Blockly.Msg.UNDO;h.enabled=0<this.undoStack_.length;h.callback=
+this.undo.bind(this,!1);d.push(h);h={};h.text=Blockly.Msg.REDO;h.enabled=0<this.redoStack_.length;h.callback=this.undo.bind(this,!0);d.push(h);this.scrollbar&&(h={},h.text=Blockly.Msg.CLEAN_UP,h.enabled=1<e.length,h.callback=this.cleanUp.bind(this),d.push(h));if(this.options.collapse){for(var k=h=!1,l=0;l<e.length;l++)for(var n=e[l];n;)n.isCollapsed()?h=!0:k=!0,n=n.getNextBlock();var m=function(a){for(var b=0,c=0;c<e.length;c++)for(var d=e[c];d;)setTimeout(d.setCollapsed.bind(d,a),b),d=d.getNextBlock(),
+b+=10};k={enabled:k};k.text=Blockly.Msg.COLLAPSE_ALL;k.callback=function(){m(!0)};d.push(k);h={enabled:h};h.text=Blockly.Msg.EXPAND_ALL;h.callback=function(){m(!1)};d.push(h)}var p=[];for(l=0;l<e.length;l++)b(e[l]);h={text:1==p.length?Blockly.Msg.DELETE_BLOCK:Blockly.Msg.DELETE_X_BLOCKS.replace("%1",String(p.length)),enabled:0<p.length,callback:function(){g.currentGesture_&&g.currentGesture_.cancel();2>p.length?c():Blockly.confirm(Blockly.Msg.DELETE_ALL_BLOCKS.replace("%1",p.length),function(a){a&&
+c()})}};d.push(h);this.configureContextMenu&&this.configureContextMenu(d);Blockly.ContextMenu.show(a,d,this.RTL)}};
+Blockly.WorkspaceSvg.prototype.updateToolbox=function(a){if(a=Blockly.Options.parseToolboxTree(a)){if(!this.options.languageTree)throw Error("Existing toolbox is null.  Can't create new toolbox.");if(a.getElementsByTagName("category").length){if(!this.toolbox_)throw Error("Existing toolbox has no categories.  Can't change mode.");this.options.languageTree=a;this.toolbox_.populate_(a);this.toolbox_.addColour_()}else{if(!this.flyout_)throw Error("Existing toolbox has categories.  Can't change mode.");
+this.options.languageTree=a;this.flyout_.show(a.childNodes)}}else if(this.options.languageTree)throw Error("Can't nullify an existing toolbox.");};Blockly.WorkspaceSvg.prototype.markFocused=function(){this.options.parentWorkspace?this.options.parentWorkspace.markFocused():(Blockly.mainWorkspace=this,this.setBrowserFocus())};Blockly.WorkspaceSvg.prototype.setBrowserFocus=function(){document.activeElement&&document.activeElement.blur();try{this.getParentSvg().focus()}catch(a){try{this.getParentSvg().parentNode.setActive()}catch(b){this.getParentSvg().parentNode.focus()}}};
+Blockly.WorkspaceSvg.prototype.zoom=function(a,b,c){var d=this.options.zoomOptions.scaleSpeed,e=this.getMetrics(),f=this.getParentSvg().createSVGPoint();f.x=a;f.y=b;f=f.matrixTransform(this.getCanvas().getCTM().inverse());a=f.x;b=f.y;f=this.getCanvas();d=Math.pow(d,c);c=this.scale*d;c>this.options.zoomOptions.maxScale?d=this.options.zoomOptions.maxScale/this.scale:c<this.options.zoomOptions.minScale&&(d=this.options.zoomOptions.minScale/this.scale);this.scale!=c&&(this.scrollbar&&(a=f.getCTM().translate(a*
+(1-d),b*(1-d)).scale(d),this.scrollX=a.e-e.absoluteLeft,this.scrollY=a.f-e.absoluteTop),this.setScale(c))};Blockly.WorkspaceSvg.prototype.zoomCenter=function(a){var b=this.getMetrics();this.zoom(b.viewWidth/2,b.viewHeight/2,a)};
+Blockly.WorkspaceSvg.prototype.zoomToFit=function(){var a=this.getMetrics(),b=this.getBlocksBoundingBox(),c=b.width;b=b.height;if(c){var d=a.viewWidth,e=a.viewHeight;this.flyout_&&(d-=this.flyout_.width_);this.scrollbar||(c+=a.contentLeft,b+=a.contentTop);this.setScale(Math.min(d/c,e/b));this.scrollCenter()}};Blockly.WorkspaceSvg.prototype.beginCanvasTransition=function(){Blockly.utils.addClass(this.svgBlockCanvas_,"blocklyCanvasTransitioning");Blockly.utils.addClass(this.svgBubbleCanvas_,"blocklyCanvasTransitioning")};
+Blockly.WorkspaceSvg.prototype.endCanvasTransition=function(){Blockly.utils.removeClass(this.svgBlockCanvas_,"blocklyCanvasTransitioning");Blockly.utils.removeClass(this.svgBubbleCanvas_,"blocklyCanvasTransitioning")};Blockly.WorkspaceSvg.prototype.scrollCenter=function(){if(this.scrollbar){var a=this.getMetrics(),b=(a.contentWidth-a.viewWidth)/2;this.flyout_&&(b-=this.flyout_.width_/2);this.scrollbar.set(b,(a.contentHeight-a.viewHeight)/2)}else console.warn("Tried to scroll a non-scrollable workspace.")};
+Blockly.WorkspaceSvg.prototype.centerOnBlock=function(a){if(this.scrollbar){if(a=this.getBlockById(a)){var b=a.getRelativeToSurfaceXY(),c=a.getHeightWidth(),d=this.scale;a=(b.x+(this.RTL?-1:1)*c.width/2)*d;b=(b.y+c.height/2)*d;c=this.getMetrics();a=a-c.contentLeft-c.viewWidth/2;b=b-c.contentTop-c.viewHeight/2;Blockly.hideChaff();this.scrollbar.set(a,b)}}else console.warn("Tried to scroll a non-scrollable workspace.")};
+Blockly.WorkspaceSvg.prototype.setScale=function(a){this.options.zoomOptions.maxScale&&a>this.options.zoomOptions.maxScale?a=this.options.zoomOptions.maxScale:this.options.zoomOptions.minScale&&a<this.options.zoomOptions.minScale&&(a=this.options.zoomOptions.minScale);this.scale=a;this.grid_&&this.grid_.update(this.scale);this.scrollbar?this.scrollbar.resize():this.translate(this.scrollX,this.scrollY);Blockly.hideChaff(!1);this.flyout_&&this.flyout_.reflow()};
+Blockly.WorkspaceSvg.getDimensionsPx_=function(a){var b=0,c=0;a&&(b=a.getWidth(),c=a.getHeight());return{width:b,height:c}};Blockly.WorkspaceSvg.getContentDimensions_=function(a,b){return a.scrollbar?Blockly.WorkspaceSvg.getContentDimensionsBounded_(a,b):Blockly.WorkspaceSvg.getContentDimensionsExact_(a)};
+Blockly.WorkspaceSvg.getContentDimensionsExact_=function(a){var b=a.getBlocksBoundingBox(),c=a.scale;a=b.width*c;var d=b.height*c,e=b.x*c;b=b.y*c;return{left:e,top:b,right:e+a,bottom:b+d,width:a,height:d}};
+Blockly.WorkspaceSvg.getContentDimensionsBounded_=function(a,b){var c=Blockly.WorkspaceSvg.getContentDimensionsExact_(a),d=b.width,e=b.height,f=d/2,g=e/2,h=Math.min(c.left-f,c.right-d),k=Math.min(c.top-g,c.bottom-e);return{left:h,top:k,height:Math.max(c.bottom+g,c.top+e)-k,width:Math.max(c.right+f,c.left+d)-h}};
+Blockly.WorkspaceSvg.getTopLevelWorkspaceMetrics_=function(){var a=Blockly.WorkspaceSvg.getDimensionsPx_(this.toolbox_),b=Blockly.WorkspaceSvg.getDimensionsPx_(this.flyout_),c=Blockly.svgSize(this.getParentSvg());if(this.toolbox_)if(this.toolboxPosition==Blockly.TOOLBOX_AT_TOP||this.toolboxPosition==Blockly.TOOLBOX_AT_BOTTOM)c.height-=a.height;else if(this.toolboxPosition==Blockly.TOOLBOX_AT_LEFT||this.toolboxPosition==Blockly.TOOLBOX_AT_RIGHT)c.width-=a.width;var d=Blockly.WorkspaceSvg.getContentDimensions_(this,
+c),e=0;this.toolbox_&&this.toolboxPosition==Blockly.TOOLBOX_AT_LEFT&&(e=a.width);var f=0;this.toolbox_&&this.toolboxPosition==Blockly.TOOLBOX_AT_TOP&&(f=a.height);return{contentHeight:d.height,contentWidth:d.width,contentTop:d.top,contentLeft:d.left,viewHeight:c.height,viewWidth:c.width,viewTop:-this.scrollY,viewLeft:-this.scrollX,absoluteTop:f,absoluteLeft:e,toolboxWidth:a.width,toolboxHeight:a.height,flyoutWidth:b.width,flyoutHeight:b.height,toolboxPosition:this.toolboxPosition}};
+Blockly.WorkspaceSvg.setTopLevelWorkspaceMetrics_=function(a){if(!this.scrollbar)throw Error("Attempt to set top level workspace scroll without scrollbars.");var b=this.getMetrics();"number"==typeof a.x&&(this.scrollX=-b.contentWidth*a.x-b.contentLeft);"number"==typeof a.y&&(this.scrollY=-b.contentHeight*a.y-b.contentTop);a=this.scrollX+b.absoluteLeft;b=this.scrollY+b.absoluteTop;this.translate(a,b);this.grid_&&this.grid_.moveTo(a,b)};
+Blockly.WorkspaceSvg.prototype.setResizesEnabled=function(a){var b=!this.resizesEnabled_&&a;this.resizesEnabled_=a;b&&this.resizeContents()};Blockly.WorkspaceSvg.prototype.clear=function(){this.setResizesEnabled(!1);Blockly.WorkspaceSvg.superClass_.clear.call(this);this.setResizesEnabled(!0)};Blockly.WorkspaceSvg.prototype.registerButtonCallback=function(a,b){if("function"!=typeof b)throw TypeError("Button callbacks must be functions.");this.flyoutButtonCallbacks_[a]=b};
+Blockly.WorkspaceSvg.prototype.getButtonCallback=function(a){return(a=this.flyoutButtonCallbacks_[a])?a:null};Blockly.WorkspaceSvg.prototype.removeButtonCallback=function(a){this.flyoutButtonCallbacks_[a]=null};Blockly.WorkspaceSvg.prototype.registerToolboxCategoryCallback=function(a,b){if("function"!=typeof b)throw TypeError("Toolbox category callbacks must be functions.");this.toolboxCategoryCallbacks_[a]=b};
+Blockly.WorkspaceSvg.prototype.getToolboxCategoryCallback=function(a){return(a=this.toolboxCategoryCallbacks_[a])?a:null};Blockly.WorkspaceSvg.prototype.removeToolboxCategoryCallback=function(a){this.toolboxCategoryCallbacks_[a]=null};
+Blockly.WorkspaceSvg.prototype.getGesture=function(a){var b="mousedown"==a.type||"touchstart"==a.type||"pointerdown"==a.type,c=this.currentGesture_;return c?b&&c.hasStarted()?(console.warn("tried to start the same gesture twice"),c.cancel(),null):c:b?this.currentGesture_=new Blockly.TouchGesture(a,this):null};Blockly.WorkspaceSvg.prototype.clearGesture=function(){this.currentGesture_=null};Blockly.WorkspaceSvg.prototype.cancelCurrentGesture=function(){this.currentGesture_&&this.currentGesture_.cancel()};
+Blockly.WorkspaceSvg.prototype.getAudioManager=function(){return this.audioManager_};Blockly.WorkspaceSvg.prototype.getGrid=function(){return this.grid_};Blockly.WorkspaceSvg.prototype.setVisible=Blockly.WorkspaceSvg.prototype.setVisible;Blockly.Mutator=function(a){Blockly.Mutator.superClass_.constructor.call(this,null);this.quarkNames_=a};goog.inherits(Blockly.Mutator,Blockly.Icon);Blockly.Mutator.prototype.workspaceWidth_=0;Blockly.Mutator.prototype.workspaceHeight_=0;
+Blockly.Mutator.prototype.drawIcon_=function(a){Blockly.utils.createSvgElement("rect",{"class":"blocklyIconShape",rx:"4",ry:"4",height:"16",width:"16"},a);Blockly.utils.createSvgElement("path",{"class":"blocklyIconSymbol",d:"m4.203,7.296 0,1.368 -0.92,0.677 -0.11,0.41 0.9,1.559 0.41,0.11 1.043,-0.457 1.187,0.683 0.127,1.134 0.3,0.3 1.8,0 0.3,-0.299 0.127,-1.138 1.185,-0.682 1.046,0.458 0.409,-0.11 0.9,-1.559 -0.11,-0.41 -0.92,-0.677 0,-1.366 0.92,-0.677 0.11,-0.41 -0.9,-1.559 -0.409,-0.109 -1.046,0.458 -1.185,-0.682 -0.127,-1.138 -0.3,-0.299 -1.8,0 -0.3,0.3 -0.126,1.135 -1.187,0.682 -1.043,-0.457 -0.41,0.11 -0.899,1.559 0.108,0.409z"},a);
+Blockly.utils.createSvgElement("circle",{"class":"blocklyIconShape",r:"2.7",cx:"8",cy:"8"},a)};Blockly.Mutator.prototype.iconClick_=function(a){this.block_.isEditable()&&Blockly.Icon.prototype.iconClick_.call(this,a)};
+Blockly.Mutator.prototype.createEditor_=function(){this.svgDialog_=Blockly.utils.createSvgElement("svg",{x:Blockly.Bubble.BORDER_WIDTH,y:Blockly.Bubble.BORDER_WIDTH},null);if(this.quarkNames_.length)for(var a=Blockly.Xml.utils.createElement("xml"),b=0,c;c=this.quarkNames_[b];b++){var d=Blockly.Xml.utils.createElement("block");d.setAttribute("type",c);a.appendChild(d)}else a=null;a={languageTree:a,parentWorkspace:this.block_.workspace,pathToMedia:this.block_.workspace.options.pathToMedia,RTL:this.block_.RTL,
+toolboxPosition:this.block_.RTL?Blockly.TOOLBOX_AT_RIGHT:Blockly.TOOLBOX_AT_LEFT,horizontalLayout:!1,getMetrics:this.getFlyoutMetrics_.bind(this),setMetrics:null};this.workspace_=new Blockly.WorkspaceSvg(a);this.workspace_.isMutator=!0;a=this.workspace_.addFlyout_("g");b=this.workspace_.createDom("blocklyMutatorBackground");b.insertBefore(a,this.workspace_.svgBlockCanvas_);this.svgDialog_.appendChild(b);return this.svgDialog_};
+Blockly.Mutator.prototype.updateEditable=function(){this.block_.isInFlyout||(this.block_.isEditable()?this.iconGroup_&&Blockly.utils.removeClass(this.iconGroup_,"blocklyIconGroupReadonly"):(this.setVisible(!1),this.iconGroup_&&Blockly.utils.addClass(this.iconGroup_,"blocklyIconGroupReadonly")));Blockly.Icon.prototype.updateEditable.call(this)};
+Blockly.Mutator.prototype.resizeBubble_=function(){var a=2*Blockly.Bubble.BORDER_WIDTH,b=this.workspace_.getCanvas().getBBox();var c=this.block_.RTL?-b.x:b.width+b.x;b=b.height+3*a;if(this.workspace_.flyout_){var d=this.workspace_.flyout_.getMetrics_();b=Math.max(b,d.contentHeight+20)}c+=3*a;if(Math.abs(this.workspaceWidth_-c)>a||Math.abs(this.workspaceHeight_-b)>a)this.workspaceWidth_=c,this.workspaceHeight_=b,this.bubble_.setBubbleSize(c+a,b+a),this.svgDialog_.setAttribute("width",this.workspaceWidth_),
+this.svgDialog_.setAttribute("height",this.workspaceHeight_);this.block_.RTL&&(a="translate("+this.workspaceWidth_+",0)",this.workspace_.getCanvas().setAttribute("transform",a));this.workspace_.resize()};
+Blockly.Mutator.prototype.setVisible=function(a){if(a!=this.isVisible())if(Blockly.Events.fire(new Blockly.Events.Ui(this.block_,"mutatorOpen",!a,a)),a){this.bubble_=new Blockly.Bubble(this.block_.workspace,this.createEditor_(),this.block_.svgPath_,this.iconXY_,null,null);this.bubble_.setSvgId(this.block_.id);if(a=this.workspace_.options.languageTree)this.workspace_.flyout_.init(this.workspace_),this.workspace_.flyout_.show(a.childNodes);this.rootBlock_=this.block_.decompose(this.workspace_);a=this.rootBlock_.getDescendants(!1);
+for(var b=0,c;c=a[b];b++)c.render();this.rootBlock_.setMovable(!1);this.rootBlock_.setDeletable(!1);this.workspace_.flyout_?(a=2*this.workspace_.flyout_.CORNER_RADIUS,b=this.workspace_.flyout_.width_+a):b=a=16;this.block_.RTL&&(b=-b);this.rootBlock_.moveBy(b,a);if(this.block_.saveConnections){var d=this;this.block_.saveConnections(this.rootBlock_);this.sourceListener_=function(){d.block_.saveConnections(d.rootBlock_)};this.block_.workspace.addChangeListener(this.sourceListener_)}this.resizeBubble_();
+this.workspace_.addChangeListener(this.workspaceChanged_.bind(this));this.updateColour()}else this.svgDialog_=null,this.workspace_.dispose(),this.rootBlock_=this.workspace_=null,this.bubble_.dispose(),this.bubble_=null,this.workspaceHeight_=this.workspaceWidth_=0,this.sourceListener_&&(this.block_.workspace.removeChangeListener(this.sourceListener_),this.sourceListener_=null)};
+Blockly.Mutator.prototype.workspaceChanged_=function(){if(!this.workspace_.isDragging())for(var a=this.workspace_.getTopBlocks(!1),b=0,c;c=a[b];b++){var d=c.getRelativeToSurfaceXY(),e=c.getHeightWidth();20>d.y+e.height&&c.moveBy(0,20-e.height-d.y)}if(this.rootBlock_.workspace==this.workspace_){Blockly.Events.setGroup(!0);c=this.block_;a=(a=c.mutationToDom())&&Blockly.Xml.domToText(a);b=c.rendered;c.rendered=!1;c.compose(this.rootBlock_);c.rendered=b;c.initSvg();b=(b=c.mutationToDom())&&Blockly.Xml.domToText(b);
+if(a!=b){Blockly.Events.fire(new Blockly.Events.BlockChange(c,"mutation",null,a,b));var f=Blockly.Events.getGroup();setTimeout(function(){Blockly.Events.setGroup(f);c.bumpNeighbours_();Blockly.Events.setGroup(!1)},Blockly.BUMP_DELAY)}c.rendered&&c.render();this.workspace_.isDragging()||this.resizeBubble_();Blockly.Events.setGroup(!1)}};Blockly.Mutator.prototype.getFlyoutMetrics_=function(){return{viewHeight:this.workspaceHeight_,viewWidth:this.workspaceWidth_,absoluteTop:0,absoluteLeft:0}};
+Blockly.Mutator.prototype.dispose=function(){this.block_.mutator=null;Blockly.Icon.prototype.dispose.call(this)};Blockly.Mutator.prototype.updateBlockStyle=function(){var a=this.workspace_;if(a&&a.getAllBlocks()){for(var b=a.getAllBlocks(),c=0;c<b.length;c++){var d=b[c];d.setStyle(d.getStyleName())}a=a.flyout_.workspace_.getAllBlocks();for(c=0;c<a.length;c++)d=a[c],d.setStyle(d.getStyleName())}};
+Blockly.Mutator.reconnect=function(a,b,c){if(!a||!a.getSourceBlock().workspace)return!1;c=b.getInput(c).connection;var d=a.targetBlock();return d&&d!=b||c.targetConnection==a?!1:(c.isConnected()&&c.disconnect(),c.connect(a),!0)};Blockly.Mutator.findParentWs=function(a){var b=null;if(a&&a.options){var c=a.options.parentWorkspace;a.isFlyout?c&&c.options&&(b=c.options.parentWorkspace):c&&(b=c)}return b};goog.global.Blockly||(goog.global.Blockly={});
+goog.global.Blockly.Mutator||(goog.global.Blockly.Mutator={});goog.global.Blockly.Mutator.reconnect=Blockly.Mutator.reconnect;Blockly.Extensions={};Blockly.Extensions.ALL_={};Blockly.Extensions.register=function(a,b){if("string"!=typeof a||""==a.trim())throw Error('Error: Invalid extension name "'+a+'"');if(Blockly.Extensions.ALL_[a])throw Error('Error: Extension "'+a+'" is already registered.');if("function"!=typeof b)throw Error('Error: Extension "'+a+'" must be a function');Blockly.Extensions.ALL_[a]=b};
+Blockly.Extensions.registerMixin=function(a,b){if(!b||"object"!=typeof b)throw Error('Error: Mixin "'+a+'" must be a object');Blockly.Extensions.register(a,function(){this.mixin(b)})};
+Blockly.Extensions.registerMutator=function(a,b,c,d){var e='Error when registering mutator "'+a+'": ';Blockly.Extensions.checkHasFunction_(e,b.domToMutation,"domToMutation");Blockly.Extensions.checkHasFunction_(e,b.mutationToDom,"mutationToDom");var f=Blockly.Extensions.checkMutatorDialog_(b,e);if(c&&"function"!=typeof c)throw Error('Extension "'+a+'" is not a function');Blockly.Extensions.register(a,function(){f&&this.setMutator(new Blockly.Mutator(d));this.mixin(b);c&&c.apply(this)})};
+Blockly.Extensions.apply=function(a,b,c){var d=Blockly.Extensions.ALL_[a];if("function"!=typeof d)throw Error('Error: Extension "'+a+'" not found.');if(c)Blockly.Extensions.checkNoMutatorProperties_(a,b);else var e=Blockly.Extensions.getMutatorProperties_(b);d.apply(b);if(c)Blockly.Extensions.checkBlockHasMutatorProperties_('Error after applying mutator "'+a+'": ',b);else if(!Blockly.Extensions.mutatorPropertiesMatch_(e,b))throw Error('Error when applying extension "'+a+'": mutation properties changed when applying a non-mutator extension.');
+};Blockly.Extensions.checkHasFunction_=function(a,b,c){if(!b)throw Error(a+'missing required property "'+c+'"');if("function"!=typeof b)throw Error(a+'" required property "'+c+'" must be a function');};Blockly.Extensions.checkNoMutatorProperties_=function(a,b){if(Blockly.Extensions.getMutatorProperties_(b).length)throw Error('Error: tried to apply mutation "'+a+'" to a block that already has mutator functions.  Block id: '+b.id);};
+Blockly.Extensions.checkMutatorDialog_=function(a,b){var c=void 0!==a.compose,d=void 0!==a.decompose;if(c&&d){if("function"!=typeof a.compose)throw Error(b+"compose must be a function.");if("function"!=typeof a.decompose)throw Error(b+"decompose must be a function.");return!0}if(c||d)throw Error(b+'Must have both or neither of "compose" and "decompose"');return!1};
+Blockly.Extensions.checkBlockHasMutatorProperties_=function(a,b){if("function"!=typeof b.domToMutation)throw Error(a+'Applying a mutator didn\'t add "domToMutation"');if("function"!=typeof b.mutationToDom)throw Error(a+'Applying a mutator didn\'t add "mutationToDom"');Blockly.Extensions.checkMutatorDialog_(b,a)};
+Blockly.Extensions.getMutatorProperties_=function(a){var b=[];void 0!==a.domToMutation&&b.push(a.domToMutation);void 0!==a.mutationToDom&&b.push(a.mutationToDom);void 0!==a.compose&&b.push(a.compose);void 0!==a.decompose&&b.push(a.decompose);return b};Blockly.Extensions.mutatorPropertiesMatch_=function(a,b){var c=Blockly.Extensions.getMutatorProperties_(b);if(c.length!=a.length)return!1;for(var d=0;d<c.length;d++)if(a[d]!=c[d])return!1;return!0};
+Blockly.Extensions.buildTooltipForDropdown=function(a,b){var c=[];"object"==typeof document&&Blockly.utils.runAfterPageLoad(function(){for(var a in b)Blockly.utils.checkMessageReferences(b[a])});return function(){this.type&&-1===c.indexOf(this.type)&&(Blockly.Extensions.checkDropdownOptionsInTable_(this,a,b),c.push(this.type));this.setTooltip(function(){var d=this.getFieldValue(a),e=b[d];null==e?-1===c.indexOf(this.type)&&(d="No tooltip mapping for value "+d+" of field "+a,null!=this.type&&(d+=" of block type "+
+this.type),console.warn(d+".")):e=Blockly.utils.replaceMessageReferences(e);return e}.bind(this))}};Blockly.Extensions.checkDropdownOptionsInTable_=function(a,b,c){var d=a.getField(b);if(!d.isOptionListDynamic()){d=d.getOptions();for(var e=0;e<d.length;++e){var f=d[e][1];null==c[f]&&console.warn("No tooltip mapping for value "+f+" of field "+b+" of block type "+a.type)}}};
+Blockly.Extensions.buildTooltipWithFieldText=function(a,b){"object"==typeof document&&Blockly.utils.runAfterPageLoad(function(){Blockly.utils.checkMessageReferences(a)});return function(){this.setTooltip(function(){var c=this.getField(b);return Blockly.utils.replaceMessageReferences(a).replace("%1",c?c.getText():"")}.bind(this))}};
+Blockly.Extensions.extensionParentTooltip_=function(){this.tooltipWhenNotConnected_=this.tooltip;this.setTooltip(function(){var a=this.getParent();return a&&a.getInputsInline()&&a.tooltip||this.tooltipWhenNotConnected_}.bind(this))};Blockly.Extensions.register("parent_tooltip_when_inline",Blockly.Extensions.extensionParentTooltip_);Blockly.Field=function(a,b){this.size_=new goog.math.Size(0,Blockly.BlockSvg.MIN_BLOCK_Y);this.setValue(a);this.setValidator(b)};Blockly.Field.TYPE_MAP_={};Blockly.Field.register=function(a,b){if("string"!=typeof a||""==a.trim())throw Error('Invalid field type "'+a+'"');if(!b||"function"!=typeof b.fromJson)throw Error('Field "'+b+'" must have a fromJson function');Blockly.Field.TYPE_MAP_[a]=b};Blockly.Field.fromJson=function(a){var b=Blockly.Field.TYPE_MAP_[a.type];return b?b.fromJson(a):null};
+Blockly.Field.cacheWidths_=null;Blockly.Field.cacheReference_=0;Blockly.Field.prototype.name=void 0;Blockly.Field.prototype.maxDisplayLength=50;Blockly.Field.prototype.text_="";Blockly.Field.prototype.sourceBlock_=null;Blockly.Field.prototype.visible_=!0;Blockly.Field.prototype.validator_=null;Blockly.Field.NBSP="\u00a0";Blockly.Field.prototype.EDITABLE=!0;Blockly.Field.prototype.setSourceBlock=function(a){if(this.sourceBlock_)throw Error("Field already bound to a block.");this.sourceBlock_=a};
+Blockly.Field.prototype.init=function(){this.fieldGroup_||(this.fieldGroup_=Blockly.utils.createSvgElement("g",{},null),this.visible_||(this.fieldGroup_.style.display="none"),this.borderRect_=Blockly.utils.createSvgElement("rect",{rx:4,ry:4,x:-Blockly.BlockSvg.SEP_SPACE_X/2,y:0,height:16},this.fieldGroup_),this.textElement_=Blockly.utils.createSvgElement("text",{"class":"blocklyText",y:this.size_.height-12.5},this.fieldGroup_),this.updateEditable(),this.sourceBlock_.getSvgRoot().appendChild(this.fieldGroup_),
+this.mouseDownWrapper_=Blockly.bindEventWithChecks_(this.fieldGroup_,"mousedown",this,this.onMouseDown_))};Blockly.Field.prototype.initModel=function(){};Blockly.Field.prototype.dispose=function(){this.mouseDownWrapper_&&(Blockly.unbindEvent_(this.mouseDownWrapper_),this.mouseDownWrapper_=null);this.sourceBlock_=null;this.fieldGroup_&&(Blockly.utils.removeNode(this.fieldGroup_),this.fieldGroup_=null);this.validator_=this.borderRect_=this.textElement_=null};
+Blockly.Field.prototype.updateEditable=function(){var a=this.fieldGroup_;this.EDITABLE&&a&&(this.sourceBlock_.isEditable()?(Blockly.utils.addClass(a,"blocklyEditableText"),Blockly.utils.removeClass(a,"blocklyNonEditableText"),this.fieldGroup_.style.cursor=this.CURSOR):(Blockly.utils.addClass(a,"blocklyNonEditableText"),Blockly.utils.removeClass(a,"blocklyEditableText"),this.fieldGroup_.style.cursor=""))};
+Blockly.Field.prototype.isCurrentlyEditable=function(){return this.EDITABLE&&!!this.sourceBlock_&&this.sourceBlock_.isEditable()};Blockly.Field.prototype.isVisible=function(){return this.visible_};Blockly.Field.prototype.setVisible=function(a){if(this.visible_!=a){this.visible_=a;var b=this.getSvgRoot();b&&(b.style.display=a?"block":"none",this.render_())}};Blockly.Field.prototype.setValidator=function(a){this.validator_=a};Blockly.Field.prototype.getValidator=function(){return this.validator_};
+Blockly.Field.prototype.classValidator=function(a){return a};Blockly.Field.prototype.callValidator=function(a){var b=this.classValidator(a);if(null===b)return null;void 0!==b&&(a=b);if(b=this.getValidator()){b=b.call(this,a);if(null===b)return null;void 0!==b&&(a=b)}return a};Blockly.Field.prototype.getSvgRoot=function(){return this.fieldGroup_};Blockly.Field.prototype.render_=function(){this.visible_?(this.textElement_.textContent=this.getDisplayText_(),this.updateWidth()):this.size_.width=0};
+Blockly.Field.prototype.updateWidth=function(){var a=Blockly.Field.getCachedWidth(this.textElement_);this.borderRect_&&this.borderRect_.setAttribute("width",a+Blockly.BlockSvg.SEP_SPACE_X);this.size_.width=a};
+Blockly.Field.getCachedWidth=function(a){var b=a.textContent+"\n"+a.className.baseVal,c;if(Blockly.Field.cacheWidths_&&(c=Blockly.Field.cacheWidths_[b]))return c;try{c=goog.userAgent.IE||goog.userAgent.EDGE?a.getBBox().width:a.getComputedTextLength()}catch(d){return 8*a.textContent.length}Blockly.Field.cacheWidths_&&(Blockly.Field.cacheWidths_[b]=c);return c};Blockly.Field.startCache=function(){Blockly.Field.cacheReference_++;Blockly.Field.cacheWidths_||(Blockly.Field.cacheWidths_={})};
+Blockly.Field.stopCache=function(){Blockly.Field.cacheReference_--;Blockly.Field.cacheReference_||(Blockly.Field.cacheWidths_=null)};Blockly.Field.prototype.getSize=function(){this.size_.width||this.render_();return this.size_};Blockly.Field.prototype.getScaledBBox_=function(){var a=this.borderRect_.getBBox(),b=a.height*this.sourceBlock_.workspace.scale;a=a.width*this.sourceBlock_.workspace.scale;var c=this.getAbsoluteXY_();return{top:c.y,bottom:c.y+b,left:c.x,right:c.x+a}};
+Blockly.Field.prototype.getDisplayText_=function(){var a=this.text_;if(!a)return Blockly.Field.NBSP;a.length>this.maxDisplayLength&&(a=a.substring(0,this.maxDisplayLength-2)+"\u2026");a=a.replace(/\s/g,Blockly.Field.NBSP);this.sourceBlock_.RTL&&(a+="\u200f");return a};Blockly.Field.prototype.getText=function(){return this.text_};Blockly.Field.prototype.setText=function(a){null!==a&&(a=String(a),a!==this.text_&&(this.text_=a,this.forceRerender()))};
+Blockly.Field.prototype.forceRerender=function(){this.size_.width=0;this.sourceBlock_&&this.sourceBlock_.rendered&&(this.sourceBlock_.render(),this.sourceBlock_.bumpNeighbours_())};Blockly.Field.prototype.getValue=function(){return this.getText()};Blockly.Field.prototype.setValue=function(a){if(null!==a){var b=this.getValue();b!=a&&(this.sourceBlock_&&Blockly.Events.isEnabled()&&Blockly.Events.fire(new Blockly.Events.BlockChange(this.sourceBlock_,"field",this.name,b,a)),this.setText(a))}};
+Blockly.Field.prototype.onMouseDown_=function(a){this.sourceBlock_&&this.sourceBlock_.workspace&&(a=this.sourceBlock_.workspace.getGesture(a))&&a.setStartField(this)};Blockly.Field.prototype.setTooltip=function(a){};Blockly.Field.prototype.getAbsoluteXY_=function(){return goog.style.getPageOffset(this.borderRect_)};Blockly.Field.prototype.referencesVariables=function(){return!1};Blockly.FieldLabel=function(a,b){this.size_=new goog.math.Size(0,17.5);this.class_=b;this.setValue(a);this.tooltip_=""};goog.inherits(Blockly.FieldLabel,Blockly.Field);Blockly.FieldLabel.fromJson=function(a){var b=Blockly.utils.replaceMessageReferences(a.text);return new Blockly.FieldLabel(b,a["class"])};Blockly.FieldLabel.prototype.EDITABLE=!1;
+Blockly.FieldLabel.prototype.init=function(){this.textElement_||(this.textElement_=Blockly.utils.createSvgElement("text",{"class":"blocklyText",y:this.size_.height-5},null),this.class_&&Blockly.utils.addClass(this.textElement_,this.class_),this.visible_||(this.textElement_.style.display="none"),this.sourceBlock_.getSvgRoot().appendChild(this.textElement_),this.textElement_.tooltip=this.tooltip_?this.tooltip_:this.sourceBlock_,Blockly.Tooltip.bindMouseEvents(this.textElement_),this.render_())};
+Blockly.FieldLabel.prototype.dispose=function(){this.textElement_&&(Blockly.utils.removeNode(this.textElement_),this.textElement_=null)};Blockly.FieldLabel.prototype.getSvgRoot=function(){return this.textElement_};Blockly.FieldLabel.prototype.setTooltip=function(a){this.tooltip_=a;this.textElement_&&(this.textElement_.tooltip=a)};Blockly.Field.register("field_label",Blockly.FieldLabel);Blockly.Input=function(a,b,c,d){if(a!=Blockly.DUMMY_INPUT&&!b)throw Error("Value inputs and statement inputs must have non-empty name.");this.type=a;this.name=b;this.sourceBlock_=c;this.connection=d;this.fieldRow=[]};Blockly.Input.prototype.align=Blockly.ALIGN_LEFT;Blockly.Input.prototype.visible_=!0;Blockly.Input.prototype.appendField=function(a,b){this.insertFieldAt(this.fieldRow.length,a,b);return this};
+Blockly.Input.prototype.insertFieldAt=function(a,b,c){if(0>a||a>this.fieldRow.length)throw Error("index "+a+" out of bounds.");if(!b&&!c)return a;"string"==typeof b&&(b=new Blockly.FieldLabel(b));b.setSourceBlock(this.sourceBlock_);this.sourceBlock_.rendered&&b.init();b.name=c;b.prefixField&&(a=this.insertFieldAt(a,b.prefixField));this.fieldRow.splice(a,0,b);++a;b.suffixField&&(a=this.insertFieldAt(a,b.suffixField));this.sourceBlock_.rendered&&(this.sourceBlock_.render(),this.sourceBlock_.bumpNeighbours_());
+return a};Blockly.Input.prototype.removeField=function(a){for(var b=0,c;c=this.fieldRow[b];b++)if(c.name===a){c.dispose();this.fieldRow.splice(b,1);this.sourceBlock_.rendered&&(this.sourceBlock_.render(),this.sourceBlock_.bumpNeighbours_());return}throw Error('Field "%s" not found.',a);};Blockly.Input.prototype.isVisible=function(){return this.visible_};
+Blockly.Input.prototype.setVisible=function(a){var b=[];if(this.visible_==a)return b;for(var c=(this.visible_=a)?"block":"none",d=0,e;e=this.fieldRow[d];d++)e.setVisible(a);this.connection&&(a?b=this.connection.unhideAll():this.connection.hideAll(),d=this.connection.targetBlock())&&(d.getSvgRoot().style.display=c,a||(d.rendered=!1));return b};Blockly.Input.prototype.setCheck=function(a){if(!this.connection)throw Error("This input does not have a connection.");this.connection.setCheck(a);return this};
+Blockly.Input.prototype.setAlign=function(a){this.align=a;this.sourceBlock_.rendered&&this.sourceBlock_.render();return this};Blockly.Input.prototype.init=function(){if(this.sourceBlock_.workspace.rendered)for(var a=0;a<this.fieldRow.length;a++)this.fieldRow[a].init()};Blockly.Input.prototype.dispose=function(){for(var a=0,b;b=this.fieldRow[a];a++)b.dispose();this.connection&&this.connection.dispose();this.sourceBlock_=null};Blockly.Warning=function(a){Blockly.Warning.superClass_.constructor.call(this,a);this.createIcon();this.text_={}};goog.inherits(Blockly.Warning,Blockly.Icon);Blockly.Warning.prototype.collapseHidden=!1;
+Blockly.Warning.prototype.drawIcon_=function(a){Blockly.utils.createSvgElement("path",{"class":"blocklyIconShape",d:"M2,15Q-1,15 0.5,12L6.5,1.7Q8,-1 9.5,1.7L15.5,12Q17,15 14,15z"},a);Blockly.utils.createSvgElement("path",{"class":"blocklyIconSymbol",d:"m7,4.8v3.16l0.27,2.27h1.46l0.27,-2.27v-3.16z"},a);Blockly.utils.createSvgElement("rect",{"class":"blocklyIconSymbol",x:"7",y:"11",height:"2",width:"2"},a)};
+Blockly.Warning.textToDom_=function(a){var b=Blockly.utils.createSvgElement("text",{"class":"blocklyText blocklyBubbleText",y:Blockly.Bubble.BORDER_WIDTH},null);a=a.split("\n");for(var c=0;c<a.length;c++){var d=Blockly.utils.createSvgElement("tspan",{dy:"1em",x:Blockly.Bubble.BORDER_WIDTH},b),e=document.createTextNode(a[c]);d.appendChild(e)}return b};
+Blockly.Warning.prototype.setVisible=function(a){if(a!=this.isVisible())if(Blockly.Events.fire(new Blockly.Events.Ui(this.block_,"warningOpen",!a,a)),a){a=Blockly.Warning.textToDom_(this.getText());this.bubble_=new Blockly.Bubble(this.block_.workspace,a,this.block_.svgPath_,this.iconXY_,null,null);this.bubble_.setSvgId(this.block_.id);if(this.block_.RTL)for(var b=a.getBBox().width,c=0,d;d=a.childNodes[c];c++)d.setAttribute("text-anchor","end"),d.setAttribute("x",b+Blockly.Bubble.BORDER_WIDTH);this.updateColour();
+a=this.bubble_.getBubbleSize();this.bubble_.setBubbleSize(a.width,a.height)}else this.bubble_.dispose(),this.body_=this.bubble_=null};Blockly.Warning.prototype.bodyFocus_=function(a){this.bubble_.promote_()};Blockly.Warning.prototype.setText=function(a,b){this.text_[b]!=a&&(a?this.text_[b]=a:delete this.text_[b],this.isVisible()&&(this.setVisible(!1),this.setVisible(!0)))};Blockly.Warning.prototype.getText=function(){var a=[],b;for(b in this.text_)a.push(this.text_[b]);return a.join("\n")};
+Blockly.Warning.prototype.dispose=function(){this.block_.warning=null;Blockly.Icon.prototype.dispose.call(this)};Blockly.Block=function(a,b,c){if("undefined"!==typeof Blockly.Generator.prototype[b])throw Error('Block prototypeName "'+b+'" conflicts with Blockly.Generator members.');this.id=c&&!a.getBlockById(c)?c:Blockly.utils.genUid();a.blockDB_[this.id]=this;this.previousConnection=this.nextConnection=this.outputConnection=null;this.inputList=[];this.inputsInline=void 0;this.disabled=!1;this.tooltip="";this.contextMenu=!0;this.parentBlock_=null;this.childBlocks_=[];this.editable_=this.movable_=this.deletable_=
+!0;this.collapsed_=this.isShadow_=!1;this.comment=null;this.xy_=new goog.math.Coordinate(0,0);this.workspace=a;this.isInFlyout=a.isFlyout;this.isInMutator=a.isMutator;this.RTL=a.RTL;this.isInsertionMarker_=!1;this.hat=void 0;if(b){this.type=b;c=Blockly.Blocks[b];if(!c||"object"!=typeof c)throw TypeError("Unknown block type: "+b);goog.mixin(this,c)}a.addTopBlock(this);a.addTypedBlock(this);"function"==typeof this.init&&this.init();this.inputsInlineDefault=this.inputsInline;if(Blockly.Events.isEnabled()){(a=
+Blockly.Events.getGroup())||Blockly.Events.setGroup(!0);try{Blockly.Events.fire(new Blockly.Events.BlockCreate(this))}finally{a||Blockly.Events.setGroup(!1)}}"function"==typeof this.onchange&&this.setOnChange(this.onchange)};Blockly.Block.obtain=function(a,b){console.warn("Deprecated call to Blockly.Block.obtain, use workspace.newBlock instead.");return a.newBlock(b)};Blockly.Block.prototype.data=null;Blockly.Block.prototype.hue_=null;Blockly.Block.prototype.colour_="#000000";
+Blockly.Block.prototype.colourSecondary_=null;Blockly.Block.prototype.colourTertiary_=null;Blockly.Block.prototype.styleName_=null;
+Blockly.Block.prototype.dispose=function(a){if(this.workspace){this.onchangeWrapper_&&this.workspace.removeChangeListener(this.onchangeWrapper_);this.unplug(a);Blockly.Events.isEnabled()&&Blockly.Events.fire(new Blockly.Events.BlockDelete(this));Blockly.Events.disable();try{this.workspace&&(this.workspace.removeTopBlock(this),this.workspace.removeTypedBlock(this),delete this.workspace.blockDB_[this.id],this.workspace=null);Blockly.selected==this&&(Blockly.selected=null);for(var b=this.childBlocks_.length-
+1;0<=b;b--)this.childBlocks_[b].dispose(!1);b=0;for(var c;c=this.inputList[b];b++)c.dispose();this.inputList.length=0;var d=this.getConnections_(!0);for(b=0;b<d.length;b++){var e=d[b];e.isConnected()&&e.disconnect();d[b].dispose()}}finally{Blockly.Events.enable()}}};Blockly.Block.prototype.initModel=function(){for(var a=0,b;b=this.inputList[a];a++)for(var c=0,d;d=b.fieldRow[c];c++)d.initModel&&d.initModel()};
+Blockly.Block.prototype.unplug=function(a){this.outputConnection?this.unplugFromRow_(a):this.previousConnection&&this.unplugFromStack_(a)};Blockly.Block.prototype.unplugFromRow_=function(a){var b=null;this.outputConnection.isConnected()&&(b=this.outputConnection.targetConnection,this.outputConnection.disconnect());b&&a&&(a=this.getOnlyValueConnection_())&&a.isConnected()&&!a.targetBlock().isShadow()&&(a=a.targetConnection,a.checkType_(b)&&(a.disconnect(),b.connect(a)))};
+Blockly.Block.prototype.getOnlyValueConnection_=function(){for(var a=null,b=0;b<this.inputList.length;b++){var c=this.inputList[b].connection;if(c&&c.type==Blockly.INPUT_VALUE){if(a)return null;a=c}}return a};
+Blockly.Block.prototype.unplugFromStack_=function(a){var b=null;this.previousConnection.isConnected()&&(b=this.previousConnection.targetConnection,this.previousConnection.disconnect());var c=this.getNextBlock();a&&c&&!c.isShadow()&&(a=this.nextConnection.targetConnection,a.disconnect(),b&&b.checkType_(a)&&b.connect(a))};
+Blockly.Block.prototype.getConnections_=function(a){a=[];this.outputConnection&&a.push(this.outputConnection);this.previousConnection&&a.push(this.previousConnection);this.nextConnection&&a.push(this.nextConnection);for(var b=0,c;c=this.inputList[b];b++)c.connection&&a.push(c.connection);return a};Blockly.Block.prototype.lastConnectionInStack=function(){for(var a=this.nextConnection;a;){var b=a.targetBlock();if(!b)return a;a=b.nextConnection}return null};Blockly.Block.prototype.bumpNeighbours_=function(){console.warn("Not expected to reach this bumpNeighbours_ function. The BlockSvg function for bumpNeighbours_ was expected to be called instead.")};
+Blockly.Block.prototype.getParent=function(){return this.parentBlock_};Blockly.Block.prototype.getInputWithBlock=function(a){for(var b=0,c;c=this.inputList[b];b++)if(c.connection&&c.connection.targetBlock()==a)return c;return null};Blockly.Block.prototype.getSurroundParent=function(){var a=this;do{var b=a;a=a.getParent();if(!a)return null}while(a.getNextBlock()==b);return a};Blockly.Block.prototype.getNextBlock=function(){return this.nextConnection&&this.nextConnection.targetBlock()};
+Blockly.Block.prototype.getPreviousBlock=function(){return this.previousConnection&&this.previousConnection.targetBlock()};Blockly.Block.prototype.getFirstStatementConnection=function(){for(var a=0,b;b=this.inputList[a];a++)if(b.connection&&b.connection.type==Blockly.NEXT_STATEMENT)return b.connection;return null};Blockly.Block.prototype.getRootBlock=function(){var a=this;do{var b=a;a=b.parentBlock_}while(a);return b};
+Blockly.Block.prototype.getChildren=function(a){if(!a)return this.childBlocks_;a=[];for(var b=0,c;c=this.inputList[b];b++)c.connection&&(c=c.connection.targetBlock())&&a.push(c);(b=this.getNextBlock())&&a.push(b);return a};
+Blockly.Block.prototype.setParent=function(a){if(a!=this.parentBlock_){if(this.parentBlock_){Blockly.utils.arrayRemove(this.parentBlock_.childBlocks_,this);if(this.previousConnection&&this.previousConnection.isConnected())throw Error("Still connected to previous block.");if(this.outputConnection&&this.outputConnection.isConnected())throw Error("Still connected to parent block.");this.parentBlock_=null}else this.workspace.removeTopBlock(this);(this.parentBlock_=a)?a.childBlocks_.push(this):this.workspace.addTopBlock(this)}};
+Blockly.Block.prototype.getDescendants=function(a){for(var b=[this],c=this.getChildren(a),d,e=0;d=c[e];e++)b.push.apply(b,d.getDescendants(a));return b};Blockly.Block.prototype.isDeletable=function(){return this.deletable_&&!this.isShadow_&&!(this.workspace&&this.workspace.options.readOnly)};Blockly.Block.prototype.setDeletable=function(a){this.deletable_=a};Blockly.Block.prototype.isMovable=function(){return this.movable_&&!this.isShadow_&&!(this.workspace&&this.workspace.options.readOnly)};
+Blockly.Block.prototype.setMovable=function(a){this.movable_=a};Blockly.Block.prototype.isDuplicatable=function(){return this.workspace.hasBlockLimits()?this.workspace.isCapacityAvailable(Blockly.utils.getBlockTypeCounts(this,!0)):!0};Blockly.Block.prototype.isShadow=function(){return this.isShadow_};Blockly.Block.prototype.setShadow=function(a){this.isShadow_=a};Blockly.Block.prototype.isInsertionMarker=function(){return this.isInsertionMarker_};
+Blockly.Block.prototype.setInsertionMarker=function(a){this.isInsertionMarker_=a};Blockly.Block.prototype.isEditable=function(){return this.editable_&&!(this.workspace&&this.workspace.options.readOnly)};Blockly.Block.prototype.setEditable=function(a){this.editable_=a;a=0;for(var b;b=this.inputList[a];a++)for(var c=0,d;d=b.fieldRow[c];c++)d.updateEditable()};
+Blockly.Block.prototype.setConnectionsHidden=function(a){if(!a&&this.isCollapsed()){if(this.outputConnection&&this.outputConnection.setHidden(a),this.previousConnection&&this.previousConnection.setHidden(a),this.nextConnection){this.nextConnection.setHidden(a);var b=this.nextConnection.targetBlock();b&&b.setConnectionsHidden(a)}}else for(var c=this.getConnections_(!0),d=0;b=c[d];d++)b.setHidden(a),b.isSuperior()&&(b=b.targetBlock())&&b.setConnectionsHidden(a)};
+Blockly.Block.prototype.getMatchingConnection=function(a,b){var c=this.getConnections_(!0),d=a.getConnections_(!0);if(c.length!=d.length)throw Error("Connection lists did not match in length.");for(var e=0;e<d.length;e++)if(d[e]==b)return c[e];return null};Blockly.Block.prototype.setHelpUrl=function(a){this.helpUrl=a};Blockly.Block.prototype.setTooltip=function(a){this.tooltip=a};Blockly.Block.prototype.getColour=function(){return this.colour_};Blockly.Block.prototype.getColourSecondary=function(){return this.colourSecondary_};
+Blockly.Block.prototype.getColourTertiary=function(){return this.colourTertiary_};Blockly.Block.prototype.getStyleName=function(){return this.styleName_};Blockly.Block.prototype.getHue=function(){return this.hue_};
+Blockly.Block.prototype.setColour=function(a){var b="string"==typeof a?Blockly.utils.replaceMessageReferences(a):a,c=Number(b);if(!isNaN(c)&&0<=c&&360>=c)this.hue_=c,this.colour_=Blockly.hueToRgb(c);else if("string"==typeof b&&/^#[0-9a-fA-F]{6}$/.test(b))this.colour_=b,this.hue_=null;else throw c='Invalid colour: "'+b+'"',a!=b&&(c+=' (from "'+a+'")'),c;};
+Blockly.Block.prototype.setStyle=function(a){var b=Blockly.getTheme();if(!b)throw Error("Trying to set block style to "+a+" before theme was defined via Blockly.setTheme().");b=b.getBlockStyle(a);this.styleName_=a;if(b)this.colourSecondary_=b.colourSecondary,this.colourTertiary_=b.colourTertiary,this.hat=b.hat,this.setColour(b.colourPrimary);else throw Error("Invalid style name: "+a);};
+Blockly.Block.prototype.setOnChange=function(a){if(a&&"function"!=typeof a)throw Error("onchange must be a function.");this.onchangeWrapper_&&this.workspace.removeChangeListener(this.onchangeWrapper_);if(this.onchange=a)this.onchangeWrapper_=a.bind(this),this.workspace.addChangeListener(this.onchangeWrapper_)};Blockly.Block.prototype.getField=function(a){for(var b=0,c;c=this.inputList[b];b++)for(var d=0,e;e=c.fieldRow[d];d++)if(e.name===a)return e;return null};
+Blockly.Block.prototype.getVars=function(){for(var a=[],b=0,c;c=this.inputList[b];b++)for(var d=0,e;e=c.fieldRow[d];d++)e.referencesVariables()&&a.push(e.getValue());return a};Blockly.Block.prototype.getVarModels=function(){for(var a=[],b=0,c;c=this.inputList[b];b++)for(var d=0,e;e=c.fieldRow[d];d++)e.referencesVariables()&&(e=this.workspace.getVariableById(e.getValue()))&&a.push(e);return a};
+Blockly.Block.prototype.updateVarName=function(a){for(var b=0,c;c=this.inputList[b];b++)for(var d=0,e;e=c.fieldRow[d];d++)e.referencesVariables()&&a.getId()==e.getValue()&&e.setText(a.name)};Blockly.Block.prototype.renameVarById=function(a,b){for(var c=0,d;d=this.inputList[c];c++)for(var e=0,f;f=d.fieldRow[e];e++)f.referencesVariables()&&a==f.getValue()&&f.setValue(b)};Blockly.Block.prototype.getFieldValue=function(a){return(a=this.getField(a))?a.getValue():null};
+Blockly.Block.prototype.setFieldValue=function(a,b){var c=this.getField(b);if(!c)throw Error('Field "'+b+'" not found.');c.setValue(a)};
+Blockly.Block.prototype.setPreviousStatement=function(a,b){if(a){void 0===b&&(b=null);if(!this.previousConnection){if(this.outputConnection)throw Error("Remove output connection prior to adding previous connection.");this.previousConnection=this.makeConnection_(Blockly.PREVIOUS_STATEMENT)}this.previousConnection.setCheck(b)}else if(this.previousConnection){if(this.previousConnection.isConnected())throw Error("Must disconnect previous statement before removing connection.");this.previousConnection.dispose();
+this.previousConnection=null}};Blockly.Block.prototype.setNextStatement=function(a,b){if(a)void 0===b&&(b=null),this.nextConnection||(this.nextConnection=this.makeConnection_(Blockly.NEXT_STATEMENT)),this.nextConnection.setCheck(b);else if(this.nextConnection){if(this.nextConnection.isConnected())throw Error("Must disconnect next statement before removing connection.");this.nextConnection.dispose();this.nextConnection=null}};
+Blockly.Block.prototype.setOutput=function(a,b){if(a){void 0===b&&(b=null);if(!this.outputConnection){if(this.previousConnection)throw Error("Remove previous connection prior to adding output connection.");this.outputConnection=this.makeConnection_(Blockly.OUTPUT_VALUE)}this.outputConnection.setCheck(b)}else if(this.outputConnection){if(this.outputConnection.isConnected())throw Error("Must disconnect output value before removing connection.");this.outputConnection.dispose();this.outputConnection=
+null}};Blockly.Block.prototype.setInputsInline=function(a){this.inputsInline!=a&&(Blockly.Events.fire(new Blockly.Events.BlockChange(this,"inline",null,this.inputsInline,a)),this.inputsInline=a)};
+Blockly.Block.prototype.getInputsInline=function(){if(void 0!=this.inputsInline)return this.inputsInline;for(var a=1;a<this.inputList.length;a++)if(this.inputList[a-1].type==Blockly.DUMMY_INPUT&&this.inputList[a].type==Blockly.DUMMY_INPUT)return!1;for(a=1;a<this.inputList.length;a++)if(this.inputList[a-1].type==Blockly.INPUT_VALUE&&this.inputList[a].type==Blockly.DUMMY_INPUT)return!0;return!1};
+Blockly.Block.prototype.setDisabled=function(a){this.disabled!=a&&(Blockly.Events.fire(new Blockly.Events.BlockChange(this,"disabled",null,this.disabled,a)),this.disabled=a)};Blockly.Block.prototype.getInheritedDisabled=function(){for(var a=this.getSurroundParent();a;){if(a.disabled)return!0;a=a.getSurroundParent()}return!1};Blockly.Block.prototype.isCollapsed=function(){return this.collapsed_};
+Blockly.Block.prototype.setCollapsed=function(a){this.collapsed_!=a&&(Blockly.Events.fire(new Blockly.Events.BlockChange(this,"collapsed",null,this.collapsed_,a)),this.collapsed_=a)};
+Blockly.Block.prototype.toString=function(a,b){var c=[],d=b||"?";if(this.collapsed_)c.push(this.getInput("_TEMP_COLLAPSED_INPUT").fieldRow[0].text_);else for(var e=0,f;f=this.inputList[e];e++){for(var g=0,h;h=f.fieldRow[g];g++)h instanceof Blockly.FieldDropdown&&!h.getValue()?c.push(d):c.push(h.getText());f.connection&&((f=f.connection.targetBlock())?c.push(f.toString(void 0,b)):c.push(d))}c=c.join(" ").trim()||"???";a&&c.length>a&&(c=c.substring(0,a-3)+"...");return c};
+Blockly.Block.prototype.appendValueInput=function(a){return this.appendInput_(Blockly.INPUT_VALUE,a)};Blockly.Block.prototype.appendStatementInput=function(a){return this.appendInput_(Blockly.NEXT_STATEMENT,a)};Blockly.Block.prototype.appendDummyInput=function(a){return this.appendInput_(Blockly.DUMMY_INPUT,a||"")};
+Blockly.Block.prototype.jsonInit=function(a){var b=a.type?'Block "'+a.type+'": ':"";if(a.output&&a.previousStatement)throw Error(b+"Must not have both an output and a previousStatement.");a.style&&a.style.hat&&(this.hat=a.style.hat,a.style=null);if(a.style&&a.colour)throw Error(b+"Must not have both a colour and a style.");a.style?this.jsonInitStyle_(a,b):this.jsonInitColour_(a,b);for(var c=0;void 0!==a["message"+c];)this.interpolate_(a["message"+c],a["args"+c]||[],a["lastDummyAlign"+c]),c++;void 0!==
+a.inputsInline&&this.setInputsInline(a.inputsInline);void 0!==a.output&&this.setOutput(!0,a.output);void 0!==a.previousStatement&&this.setPreviousStatement(!0,a.previousStatement);void 0!==a.nextStatement&&this.setNextStatement(!0,a.nextStatement);void 0!==a.tooltip&&(c=a.tooltip,c=Blockly.utils.replaceMessageReferences(c),this.setTooltip(c));void 0!==a.enableContextMenu&&(c=a.enableContextMenu,this.contextMenu=!!c);void 0!==a.helpUrl&&(c=a.helpUrl,c=Blockly.utils.replaceMessageReferences(c),this.setHelpUrl(c));
+"string"==typeof a.extensions&&(console.warn(b+"JSON attribute 'extensions' should be an array of strings. Found raw string in JSON for '"+a.type+"' block."),a.extensions=[a.extensions]);void 0!==a.mutator&&Blockly.Extensions.apply(a.mutator,this,!0);if(Array.isArray(a.extensions))for(a=a.extensions,b=0;b<a.length;++b)Blockly.Extensions.apply(a[b],this,!1)};
+Blockly.Block.prototype.jsonInitColour_=function(a,b){if("colour"in a)if(void 0===a.colour)console.warn(b+"Undefined color value.");else{var c=a.colour;try{this.setColour(c)}catch(d){console.warn(b+"Illegal color value: ",c)}}};Blockly.Block.prototype.jsonInitStyle_=function(a,b){var c=a.style;try{this.setStyle(c)}catch(d){console.warn(b+"Style does not exist: ",c)}};
+Blockly.Block.prototype.mixin=function(a,b){if(void 0!==b&&"boolean"!=typeof b)throw Error("opt_disableCheck must be a boolean if provided");if(!b){var c=[],d;for(d in a)void 0!==this[d]&&c.push(d);if(c.length)throw Error("Mixin will overwrite block members: "+JSON.stringify(c));}goog.mixin(this,a)};
+Blockly.Block.prototype.interpolate_=function(a,b,c){var d=Blockly.utils.tokenizeInterpolation(a),e=[],f=0;a=[];for(var g=0;g<d.length;g++){var h=d[g];if("number"==typeof h){if(0>=h||h>b.length)throw Error('Block "'+this.type+'": Message index %'+h+" out of range.");if(e[h])throw Error('Block "'+this.type+'": Message index %'+h+" duplicated.");e[h]=!0;f++;a.push(b[h-1])}else(h=h.trim())&&a.push(h)}if(f!=b.length)throw Error('Block "'+this.type+'": Message does not reference all '+b.length+" arg(s).");
+a.length&&("string"==typeof a[a.length-1]||Blockly.utils.startsWith(a[a.length-1].type,"field_"))&&(g={type:"input_dummy"},c&&(g.align=c),a.push(g));c={LEFT:Blockly.ALIGN_LEFT,RIGHT:Blockly.ALIGN_RIGHT,CENTRE:Blockly.ALIGN_CENTRE};b=[];for(g=0;g<a.length;g++)if(e=a[g],"string"==typeof e)b.push([e,void 0]);else{d=f=null;do if(h=!1,"string"==typeof e)f=new Blockly.FieldLabel(e);else switch(e.type){case "input_value":d=this.appendValueInput(e.name);break;case "input_statement":d=this.appendStatementInput(e.name);
+break;case "input_dummy":d=this.appendDummyInput(e.name);break;default:f=Blockly.Field.fromJson(e),f||(e.alt?(e=e.alt,h=!0):console.warn("Blockly could not create a field of type "+e.type+". You may need to register your custom field.  See github.com/google/blockly/issues/1584"))}while(h);if(f)b.push([f,e.name]);else if(d){e.check&&d.setCheck(e.check);e.align&&d.setAlign(c[e.align]);for(e=0;e<b.length;e++)d.appendField(b[e][0],b[e][1]);b.length=0}}};
+Blockly.Block.prototype.appendInput_=function(a,b){var c=null;if(a==Blockly.INPUT_VALUE||a==Blockly.NEXT_STATEMENT)c=this.makeConnection_(a);c=new Blockly.Input(a,b,this,c);this.inputList.push(c);return c};
+Blockly.Block.prototype.moveInputBefore=function(a,b){if(a!=b){for(var c=-1,d=b?-1:this.inputList.length,e=0,f;f=this.inputList[e];e++)if(f.name==a){if(c=e,-1!=d)break}else if(b&&f.name==b&&(d=e,-1!=c))break;if(-1==c)throw Error('Named input "'+a+'" not found.');if(-1==d)throw Error('Reference input "'+b+'" not found.');this.moveNumberedInputBefore(c,d)}};
+Blockly.Block.prototype.moveNumberedInputBefore=function(a,b){if(a==b)throw Error("Can't move input to itself.");if(a>=this.inputList.length)throw RangeError("Input index "+a+" out of bounds.");if(b>this.inputList.length)throw RangeError("Reference input "+b+" out of bounds.");var c=this.inputList[a];this.inputList.splice(a,1);a<b&&b--;this.inputList.splice(b,0,c)};
+Blockly.Block.prototype.removeInput=function(a,b){for(var c=0,d;d=this.inputList[c];c++)if(d.name==a){if(d.connection&&d.connection.isConnected()){d.connection.setShadowDom(null);var e=d.connection.targetBlock();e.isShadow()?e.dispose():e.unplug()}d.dispose();this.inputList.splice(c,1);return}if(!b)throw Error("Input not found: "+a);};Blockly.Block.prototype.getInput=function(a){for(var b=0,c;c=this.inputList[b];b++)if(c.name==a)return c;return null};
+Blockly.Block.prototype.getInputTargetBlock=function(a){return(a=this.getInput(a))&&a.connection&&a.connection.targetBlock()};Blockly.Block.prototype.getCommentText=function(){return this.comment||""};Blockly.Block.prototype.setCommentText=function(a){this.comment!=a&&(Blockly.Events.fire(new Blockly.Events.BlockChange(this,"comment",null,this.comment,a||"")),this.comment=a)};Blockly.Block.prototype.setWarningText=function(a,b){};Blockly.Block.prototype.setMutator=function(a){};
+Blockly.Block.prototype.getRelativeToSurfaceXY=function(){return this.xy_};Blockly.Block.prototype.moveBy=function(a,b){if(this.parentBlock_)throw Error("Block has parent.");var c=new Blockly.Events.BlockMove(this);this.xy_.translate(a,b);c.recordNew();Blockly.Events.fire(c)};Blockly.Block.prototype.makeConnection_=function(a){return new Blockly.Connection(this,a)};
+Blockly.Block.prototype.allInputsFilled=function(a){void 0===a&&(a=!0);if(!a&&this.isShadow())return!1;for(var b=0,c;c=this.inputList[b];b++)if(c.connection&&(c=c.connection.targetBlock(),!c||!c.allInputsFilled(a)))return!1;return(b=this.getNextBlock())?b.allInputsFilled(a):!0};Blockly.Block.prototype.toDevString=function(){var a=this.type?'"'+this.type+'" block':"Block";this.id&&(a+=' (id="'+this.id+'")');return a};Blockly.BlockDragSurfaceSvg=function(a){this.container_=a;this.createDom()};Blockly.BlockDragSurfaceSvg.prototype.SVG_=null;Blockly.BlockDragSurfaceSvg.prototype.dragGroup_=null;Blockly.BlockDragSurfaceSvg.prototype.container_=null;Blockly.BlockDragSurfaceSvg.prototype.scale_=1;Blockly.BlockDragSurfaceSvg.prototype.surfaceXY_=null;
+Blockly.BlockDragSurfaceSvg.prototype.createDom=function(){this.SVG_||(this.SVG_=Blockly.utils.createSvgElement("svg",{xmlns:Blockly.SVG_NS,"xmlns:html":Blockly.HTML_NS,"xmlns:xlink":"http://www.w3.org/1999/xlink",version:"1.1","class":"blocklyBlockDragSurface"},this.container_),this.dragGroup_=Blockly.utils.createSvgElement("g",{},this.SVG_))};
+Blockly.BlockDragSurfaceSvg.prototype.setBlocksAndShow=function(a){if(this.dragGroup_.childNodes.length)throw Error("Already dragging a block.");this.dragGroup_.appendChild(a);this.SVG_.style.display="block";this.surfaceXY_=new goog.math.Coordinate(0,0)};Blockly.BlockDragSurfaceSvg.prototype.translateAndScaleGroup=function(a,b,c){this.scale_=c;a=a.toFixed(0);b=b.toFixed(0);this.dragGroup_.setAttribute("transform","translate("+a+","+b+") scale("+c+")")};
+Blockly.BlockDragSurfaceSvg.prototype.translateSurfaceInternal_=function(){var a=this.surfaceXY_.x,b=this.surfaceXY_.y;a=a.toFixed(0);b=b.toFixed(0);this.SVG_.style.display="block";Blockly.utils.setCssTransform(this.SVG_,"translate3d("+a+"px, "+b+"px, 0px)")};Blockly.BlockDragSurfaceSvg.prototype.translateSurface=function(a,b){this.surfaceXY_=new goog.math.Coordinate(a*this.scale_,b*this.scale_);this.translateSurfaceInternal_()};
+Blockly.BlockDragSurfaceSvg.prototype.getSurfaceTranslation=function(){var a=Blockly.utils.getRelativeXY(this.SVG_);return new goog.math.Coordinate(a.x/this.scale_,a.y/this.scale_)};Blockly.BlockDragSurfaceSvg.prototype.getGroup=function(){return this.dragGroup_};Blockly.BlockDragSurfaceSvg.prototype.getCurrentBlock=function(){return this.dragGroup_.firstChild};
+Blockly.BlockDragSurfaceSvg.prototype.clearAndHide=function(a){a?a.appendChild(this.getCurrentBlock()):this.dragGroup_.removeChild(this.getCurrentBlock());this.SVG_.style.display="none";if(this.dragGroup_.childNodes.length)throw Error("Drag group was not cleared.");this.surfaceXY_=null};Blockly.utils.uiMenu={};Blockly.utils.uiMenu.getSize=function(a){a=a.getElement();var b=goog.style.getSize(a);b.height=a.scrollHeight;return b};Blockly.utils.uiMenu.adjustBBoxesForRTL=function(a,b,c){b.left+=c.width;b.right+=c.width;a.left+=c.width;a.right+=c.width};Blockly.ContextMenu={};Blockly.ContextMenu.currentBlock=null;Blockly.ContextMenu.eventWrapper_=null;Blockly.ContextMenu.show=function(a,b,c){Blockly.WidgetDiv.show(Blockly.ContextMenu,c,null);if(b.length){var d=Blockly.ContextMenu.populate_(b,c);goog.events.listen(d,goog.ui.Component.EventType.ACTION,Blockly.ContextMenu.hide);Blockly.ContextMenu.position_(d,a,c);setTimeout(function(){d.getElement().focus()},1);Blockly.ContextMenu.currentBlock=null}else Blockly.ContextMenu.hide()};
+Blockly.ContextMenu.populate_=function(a,b){var c=new goog.ui.Menu;c.setRightToLeft(b);for(var d=0,e;e=a[d];d++){var f=new goog.ui.MenuItem(e.text);f.setRightToLeft(b);c.addChild(f,!0);f.setEnabled(e.enabled);e.enabled&&(goog.events.listen(f,goog.ui.Component.EventType.ACTION,e.callback),f.handleContextMenu=function(){goog.events.dispatchEvent(this,goog.ui.Component.EventType.ACTION)})}return c};
+Blockly.ContextMenu.position_=function(a,b,c){var d=Blockly.utils.getViewportBBox();b={top:b.clientY+d.top,bottom:b.clientY+d.top,left:b.clientX+d.left,right:b.clientX+d.left};Blockly.ContextMenu.createWidget_(a);var e=Blockly.utils.uiMenu.getSize(a);c&&Blockly.utils.uiMenu.adjustBBoxesForRTL(d,b,e);Blockly.WidgetDiv.positionWithAnchor(d,b,e,c);a.getElement().focus()};
+Blockly.ContextMenu.createWidget_=function(a){a.render(Blockly.WidgetDiv.DIV);var b=a.getElement();Blockly.utils.addClass(b,"blocklyContextMenu");Blockly.bindEventWithChecks_(b,"contextmenu",null,Blockly.utils.noEvent);a.setAllowAutoFocus(!0)};Blockly.ContextMenu.hide=function(){Blockly.WidgetDiv.hideIfOwner(Blockly.ContextMenu);Blockly.ContextMenu.currentBlock=null;Blockly.ContextMenu.eventWrapper_&&Blockly.unbindEvent_(Blockly.ContextMenu.eventWrapper_)};
+Blockly.ContextMenu.callbackFactory=function(a,b){return function(){Blockly.Events.disable();try{var c=Blockly.Xml.domToBlock(b,a.workspace),d=a.getRelativeToSurfaceXY();d.x=a.RTL?d.x-Blockly.SNAP_RADIUS:d.x+Blockly.SNAP_RADIUS;d.y+=2*Blockly.SNAP_RADIUS;c.moveBy(d.x,d.y)}finally{Blockly.Events.enable()}Blockly.Events.isEnabled()&&!c.isShadow()&&Blockly.Events.fire(new Blockly.Events.BlockCreate(c));c.select()}};
+Blockly.ContextMenu.blockDeleteOption=function(a){var b=a.getDescendants(!1).length,c=a.getNextBlock();c&&(b-=c.getDescendants(!1).length);return{text:1==b?Blockly.Msg.DELETE_BLOCK:Blockly.Msg.DELETE_X_BLOCKS.replace("%1",String(b)),enabled:!0,callback:function(){Blockly.Events.setGroup(!0);a.dispose(!0,!0);Blockly.Events.setGroup(!1)}}};Blockly.ContextMenu.blockHelpOption=function(a){return{enabled:!("function"==typeof a.helpUrl?!a.helpUrl():!a.helpUrl),text:Blockly.Msg.HELP,callback:function(){a.showHelp_()}}};
+Blockly.ContextMenu.blockDuplicateOption=function(a){var b=a.isDuplicatable();return{text:Blockly.Msg.DUPLICATE_BLOCK,enabled:b,callback:function(){Blockly.duplicate_(a)}}};Blockly.ContextMenu.blockCommentOption=function(a){var b={enabled:!goog.userAgent.IE};a.comment?(b.text=Blockly.Msg.REMOVE_COMMENT,b.callback=function(){a.setCommentText(null)}):(b.text=Blockly.Msg.ADD_COMMENT,b.callback=function(){a.setCommentText("")});return b};
+Blockly.ContextMenu.commentDeleteOption=function(a){return{text:Blockly.Msg.REMOVE_COMMENT,enabled:!0,callback:function(){Blockly.Events.setGroup(!0);a.dispose(!0,!0);Blockly.Events.setGroup(!1)}}};Blockly.ContextMenu.commentDuplicateOption=function(a){return{text:Blockly.Msg.DUPLICATE_COMMENT,enabled:!0,callback:function(){Blockly.duplicate_(a)}}};
+Blockly.ContextMenu.workspaceCommentOption=function(a,b){var c={enabled:!goog.userAgent.IE};c.text=Blockly.Msg.ADD_COMMENT;c.callback=function(){var c=new Blockly.WorkspaceCommentSvg(a,Blockly.Msg.WORKSPACE_COMMENT_DEFAULT_TEXT,Blockly.WorkspaceCommentSvg.DEFAULT_SIZE,Blockly.WorkspaceCommentSvg.DEFAULT_SIZE),e=a.getInjectionDiv().getBoundingClientRect();e=new goog.math.Coordinate(b.clientX-e.left,b.clientY-e.top);var f=a.getOriginOffsetInPixels();e=goog.math.Coordinate.difference(e,f).scale(1/a.scale);
+c.moveBy(e.x,e.y);a.rendered&&(c.initSvg(),c.render(!1),c.select())};return c};Blockly.BlockSvg=function(a,b,c){this.svgGroup_=Blockly.utils.createSvgElement("g",{},null);this.svgGroup_.translate_="";this.svgPathDark_=Blockly.utils.createSvgElement("path",{"class":"blocklyPathDark",transform:"translate(1,1)"},this.svgGroup_);this.svgPath_=Blockly.utils.createSvgElement("path",{"class":"blocklyPath"},this.svgGroup_);this.svgPathLight_=Blockly.utils.createSvgElement("path",{"class":"blocklyPathLight"},this.svgGroup_);this.svgPath_.tooltip=this;this.rendered=!1;this.useDragSurface_=
+Blockly.utils.is3dSupported()&&!!a.blockDragSurface_;Blockly.Tooltip.bindMouseEvents(this.svgPath_);Blockly.BlockSvg.superClass_.constructor.call(this,a,b,c);this.svgGroup_.dataset&&(this.svgGroup_.dataset.id=this.id)};goog.inherits(Blockly.BlockSvg,Blockly.Block);Blockly.BlockSvg.prototype.height=0;Blockly.BlockSvg.prototype.width=0;Blockly.BlockSvg.prototype.dragStartXY_=null;Blockly.BlockSvg.prototype.warningTextDb_=null;Blockly.BlockSvg.INLINE=-1;Blockly.BlockSvg.COLLAPSED_WARNING_ID="TEMP_COLLAPSED_WARNING_";
+Blockly.BlockSvg.prototype.initSvg=function(){if(!this.workspace.rendered)throw TypeError("Workspace is headless.");for(var a=0,b;b=this.inputList[a];a++)b.init();b=this.getIcons();for(a=0;a<b.length;a++)b[a].createIcon();this.updateColour();this.updateMovable();this.workspace.options.readOnly||this.eventsInit_||Blockly.bindEventWithChecks_(this.getSvgRoot(),"mousedown",this,this.onMouseDown_);this.eventsInit_=!0;this.getSvgRoot().parentNode||this.workspace.getCanvas().appendChild(this.getSvgRoot())};
+Blockly.BlockSvg.prototype.select=function(){if(this.isShadow()&&this.getParent())this.getParent().select();else if(Blockly.selected!=this){var a=null;if(Blockly.selected){a=Blockly.selected.id;Blockly.Events.disable();try{Blockly.selected.unselect()}finally{Blockly.Events.enable()}}a=new Blockly.Events.Ui(null,"selected",a,this.id);a.workspaceId=this.workspace.id;Blockly.Events.fire(a);Blockly.selected=this;this.addSelect()}};
+Blockly.BlockSvg.prototype.unselect=function(){if(Blockly.selected==this){var a=new Blockly.Events.Ui(null,"selected",this.id,null);a.workspaceId=this.workspace.id;Blockly.Events.fire(a);Blockly.selected=null;this.removeSelect()}};Blockly.BlockSvg.prototype.mutator=null;Blockly.BlockSvg.prototype.comment=null;Blockly.BlockSvg.prototype.warning=null;
+Blockly.BlockSvg.prototype.getIcons=function(){var a=[];this.mutator&&a.push(this.mutator);this.comment&&a.push(this.comment);this.warning&&a.push(this.warning);return a};
+Blockly.BlockSvg.prototype.setParent=function(a){var b=this.parentBlock_;if(a!=b){Blockly.Field.startCache();Blockly.BlockSvg.superClass_.setParent.call(this,a);Blockly.Field.stopCache();var c=this.getSvgRoot();if(!this.workspace.isClearing&&c){var d=this.getRelativeToSurfaceXY();a?(a.getSvgRoot().appendChild(c),a=this.getRelativeToSurfaceXY(),this.moveConnections_(a.x-d.x,a.y-d.y)):b&&(this.workspace.getCanvas().appendChild(c),this.translate(d.x,d.y))}}};
+Blockly.BlockSvg.prototype.getRelativeToSurfaceXY=function(){var a=0,b=0,c=this.useDragSurface_?this.workspace.blockDragSurface_.getGroup():null,d=this.getSvgRoot();if(d){do{var e=Blockly.utils.getRelativeXY(d);a+=e.x;b+=e.y;this.useDragSurface_&&this.workspace.blockDragSurface_.getCurrentBlock()==d&&(e=this.workspace.blockDragSurface_.getSurfaceTranslation(),a+=e.x,b+=e.y);d=d.parentNode}while(d&&d!=this.workspace.getCanvas()&&d!=c)}return new goog.math.Coordinate(a,b)};
+Blockly.BlockSvg.prototype.moveBy=function(a,b){if(this.parentBlock_)throw Error("Block has parent.");var c=Blockly.Events.isEnabled();if(c)var d=new Blockly.Events.BlockMove(this);var e=this.getRelativeToSurfaceXY();this.translate(e.x+a,e.y+b);this.moveConnections_(a,b);c&&(d.recordNew(),Blockly.Events.fire(d));this.workspace.resizeContents()};Blockly.BlockSvg.prototype.translate=function(a,b){this.getSvgRoot().setAttribute("transform","translate("+a+","+b+")")};
+Blockly.BlockSvg.prototype.moveToDragSurface_=function(){if(this.useDragSurface_){var a=this.getRelativeToSurfaceXY();this.clearTransformAttributes_();this.workspace.blockDragSurface_.translateSurface(a.x,a.y);this.workspace.blockDragSurface_.setBlocksAndShow(this.getSvgRoot())}};Blockly.BlockSvg.prototype.moveOffDragSurface_=function(a){this.useDragSurface_&&(this.translate(a.x,a.y),this.workspace.blockDragSurface_.clearAndHide(this.workspace.getCanvas()))};
+Blockly.BlockSvg.prototype.moveDuringDrag=function(a){this.useDragSurface_?this.workspace.blockDragSurface_.translateSurface(a.x,a.y):(this.svgGroup_.translate_="translate("+a.x+","+a.y+")",this.svgGroup_.setAttribute("transform",this.svgGroup_.translate_+this.svgGroup_.skew_))};Blockly.BlockSvg.prototype.clearTransformAttributes_=function(){Blockly.utils.removeAttribute(this.getSvgRoot(),"transform")};
+Blockly.BlockSvg.prototype.snapToGrid=function(){if(this.workspace&&!this.workspace.isDragging()&&!this.getParent()&&!this.isInFlyout){var a=this.workspace.getGrid();if(a&&a.shouldSnap()){var b=a.getSpacing(),c=b/2,d=this.getRelativeToSurfaceXY();a=Math.round((d.x-c)/b)*b+c-d.x;b=Math.round((d.y-c)/b)*b+c-d.y;a=Math.round(a);b=Math.round(b);0==a&&0==b||this.moveBy(a,b)}}};
+Blockly.BlockSvg.prototype.getBoundingRectangle=function(){var a=this.getRelativeToSurfaceXY(this),b=this.outputConnection?Blockly.BlockSvg.TAB_WIDTH:0,c=this.getHeightWidth();if(this.RTL){var d=new goog.math.Coordinate(a.x-(c.width-b),a.y);a=new goog.math.Coordinate(a.x+b,a.y+c.height)}else d=new goog.math.Coordinate(a.x-b,a.y),a=new goog.math.Coordinate(a.x+c.width-b,a.y+c.height);return{topLeft:d,bottomRight:a}};
+Blockly.BlockSvg.prototype.setCollapsed=function(a){if(this.collapsed_!=a){for(var b=[],c=0,d;d=this.inputList[c];c++)b.push.apply(b,d.setVisible(!a));if(a){d=this.getIcons();for(c=0;c<d.length;c++)d[c].setVisible(!1);c=this.toString(Blockly.COLLAPSE_CHARS);this.appendDummyInput("_TEMP_COLLAPSED_INPUT").appendField(c).init();d=this.getDescendants(!0);if(c=this.getNextBlock())c=d.indexOf(c),d.splice(c,d.length-c);c=1;for(var e;e=d[c];c++)if(e.warning){this.setWarningText(Blockly.Msg.COLLAPSED_WARNINGS_WARNING,
+Blockly.BlockSvg.COLLAPSED_WARNING_ID);break}}else this.removeInput("_TEMP_COLLAPSED_INPUT"),this.warning&&(this.warning.setText("",Blockly.BlockSvg.COLLAPSED_WARNING_ID),Object.keys(this.warning.text_).length||this.setWarningText(null));Blockly.BlockSvg.superClass_.setCollapsed.call(this,a);b.length||(b[0]=this);if(this.rendered)for(c=0;e=b[c];c++)e.render()}};
+Blockly.BlockSvg.prototype.tab=function(a,b){var c=this.createTabList_(),d=c.indexOf(a);-1==d&&(d=b?-1:c.length);(c=c[b?d+1:d-1])?c instanceof Blockly.Field?c.showEditor_():c.tab(null,b):(c=this.getParent())&&c.tab(this,b)};Blockly.BlockSvg.prototype.createTabList_=function(){for(var a=[],b=0,c;c=this.inputList[b];b++){for(var d=0,e;e=c.fieldRow[d];d++)e instanceof Blockly.FieldTextInput&&a.push(e);c.connection&&(c=c.connection.targetBlock())&&a.push(c)}return a};
+Blockly.BlockSvg.prototype.onMouseDown_=function(a){var b=this.workspace&&this.workspace.getGesture(a);b&&b.handleBlockStart(a,this)};Blockly.BlockSvg.prototype.showHelp_=function(){var a="function"==typeof this.helpUrl?this.helpUrl():this.helpUrl;a&&window.open(a)};
+Blockly.BlockSvg.prototype.showContextMenu_=function(a){if(!this.workspace.options.readOnly&&this.contextMenu){var b=this,c=[];if(this.isDeletable()&&this.isMovable()&&!b.isInFlyout){c.push(Blockly.ContextMenu.blockDuplicateOption(b));this.isEditable()&&!this.collapsed_&&this.workspace.options.comments&&c.push(Blockly.ContextMenu.blockCommentOption(b));if(!this.collapsed_)for(var d=1;d<this.inputList.length;d++)if(this.inputList[d-1].type!=Blockly.NEXT_STATEMENT&&this.inputList[d].type!=Blockly.NEXT_STATEMENT){d=
+{enabled:!0};var e=this.getInputsInline();d.text=e?Blockly.Msg.EXTERNAL_INPUTS:Blockly.Msg.INLINE_INPUTS;d.callback=function(){b.setInputsInline(!e)};c.push(d);break}this.workspace.options.collapse&&(this.collapsed_?(d={enabled:!0},d.text=Blockly.Msg.EXPAND_BLOCK,d.callback=function(){b.setCollapsed(!1)},c.push(d)):(d={enabled:!0},d.text=Blockly.Msg.COLLAPSE_BLOCK,d.callback=function(){b.setCollapsed(!0)},c.push(d)));this.workspace.options.disable&&(d={text:this.disabled?Blockly.Msg.ENABLE_BLOCK:
+Blockly.Msg.DISABLE_BLOCK,enabled:!this.getInheritedDisabled(),callback:function(){var a=Blockly.Events.getGroup();a||Blockly.Events.setGroup(!0);b.setDisabled(!b.disabled);a||Blockly.Events.setGroup(!1)}},c.push(d));c.push(Blockly.ContextMenu.blockDeleteOption(b))}c.push(Blockly.ContextMenu.blockHelpOption(b));this.customContextMenu&&this.customContextMenu(c);Blockly.ContextMenu.show(a,c,this.RTL);Blockly.ContextMenu.currentBlock=this}};
+Blockly.BlockSvg.prototype.moveConnections_=function(a,b){if(this.rendered){for(var c=this.getConnections_(!1),d=0;d<c.length;d++)c[d].moveBy(a,b);c=this.getIcons();for(d=0;d<c.length;d++)c[d].computeIconLocation();for(d=0;d<this.childBlocks_.length;d++)this.childBlocks_[d].moveConnections_(a,b)}};
+Blockly.BlockSvg.prototype.setDragging=function(a){if(a){var b=this.getSvgRoot();b.translate_="";b.skew_="";Blockly.draggingConnections_=Blockly.draggingConnections_.concat(this.getConnections_(!0));Blockly.utils.addClass(this.svgGroup_,"blocklyDragging")}else Blockly.draggingConnections_=[],Blockly.utils.removeClass(this.svgGroup_,"blocklyDragging");for(b=0;b<this.childBlocks_.length;b++)this.childBlocks_[b].setDragging(a)};
+Blockly.BlockSvg.prototype.updateMovable=function(){this.isMovable()?Blockly.utils.addClass(this.svgGroup_,"blocklyDraggable"):Blockly.utils.removeClass(this.svgGroup_,"blocklyDraggable")};Blockly.BlockSvg.prototype.setMovable=function(a){Blockly.BlockSvg.superClass_.setMovable.call(this,a);this.updateMovable()};Blockly.BlockSvg.prototype.setEditable=function(a){Blockly.BlockSvg.superClass_.setEditable.call(this,a);a=this.getIcons();for(var b=0;b<a.length;b++)a[b].updateEditable()};
+Blockly.BlockSvg.prototype.setShadow=function(a){Blockly.BlockSvg.superClass_.setShadow.call(this,a);this.updateColour()};Blockly.BlockSvg.prototype.setInsertionMarker=function(a){this.isInsertionMarker_!=a&&(this.isInsertionMarker_=a)&&(this.setColour(Blockly.INSERTION_MARKER_COLOUR),Blockly.utils.addClass(this.svgGroup_,"blocklyInsertionMarker"))};Blockly.BlockSvg.prototype.getSvgRoot=function(){return this.svgGroup_};
+Blockly.BlockSvg.prototype.dispose=function(a,b){if(this.workspace){Blockly.Tooltip.hide();Blockly.Field.startCache();var c=this.workspace;Blockly.selected==this&&(this.unselect(),this.workspace.cancelCurrentGesture());Blockly.ContextMenu.currentBlock==this&&Blockly.ContextMenu.hide();b&&this.rendered&&(this.unplug(a),Blockly.BlockAnimations.disposeUiEffect(this));this.rendered=!1;if(this.warningTextDb_){for(var d in this.warningTextDb_)clearTimeout(this.warningTextDb_[d]);this.warningTextDb_=null}this.unplug(a);
+var e;Blockly.Events.isEnabled()&&(e=new Blockly.Events.BlockDelete(this));Blockly.Events.disable();try{var f=this.getIcons();for(d=0;d<f.length;d++)f[d].dispose();Blockly.BlockSvg.superClass_.dispose.call(this,a)}finally{Blockly.Events.enable()}Blockly.Events.isEnabled()&&e&&Blockly.Events.fire(e);Blockly.utils.removeNode(this.svgGroup_);c.resizeContents();this.svgPathDark_=this.svgPathLight_=this.svgPath_=this.svgGroup_=null;Blockly.Field.stopCache()}};
+Blockly.BlockSvg.prototype.updateColour=function(){if(!this.disabled){var a=this.getColour(),b=this.getColourSecondary(),c=this.getColourTertiary(),d=goog.color.hexToRgb(a);this.isShadow()?a=this.setShadowColour_(d,b):this.setBorderColour_(d,c);this.svgPath_.setAttribute("fill",a);a=this.getIcons();for(b=0;b<a.length;b++)a[b].updateColour();for(a=0;b=this.inputList[a];a++)for(c=0;d=b.fieldRow[c];c++)d.forceRerender()}};
+Blockly.BlockSvg.prototype.setBorderColour_=function(a,b){if(b)this.svgPathLight_.setAttribute("stroke","none"),this.svgPathDark_.setAttribute("fill","none"),this.svgPath_.setAttribute("stroke",b);else{this.svgPathLight_.style.display="";var c=goog.color.rgbArrayToHex(goog.color.lighten(a,.3)),d=goog.color.rgbArrayToHex(goog.color.darken(a,.2));this.svgPathLight_.setAttribute("stroke",c);this.svgPathDark_.setAttribute("fill",d);this.svgPath_.setAttribute("stroke","none")}};
+Blockly.BlockSvg.prototype.setShadowColour_=function(a,b){if(b){this.svgPathLight_.style.display="none";this.svgPathDark_.style.display="none";this.svgPath_.setAttribute("fill",b);var c=b}else a=goog.color.lighten(a,.6),c=goog.color.rgbArrayToHex(a),this.svgPathLight_.style.display="none",this.svgPathDark_.setAttribute("fill",c);return c};
+Blockly.BlockSvg.prototype.updateDisabled=function(){this.disabled||this.getInheritedDisabled()?Blockly.utils.addClass(this.svgGroup_,"blocklyDisabled")&&this.svgPath_.setAttribute("fill","url(#"+this.workspace.options.disabledPatternId+")"):Blockly.utils.removeClass(this.svgGroup_,"blocklyDisabled")&&this.updateColour();for(var a=this.getChildren(!1),b=0,c;c=a[b];b++)c.updateDisabled()};
+Blockly.BlockSvg.prototype.getCommentText=function(){return this.comment?this.comment.getText().replace(/\s+$/,"").replace(/ +\n/g,"\n"):""};Blockly.BlockSvg.prototype.setCommentText=function(a){var b=!1;"string"==typeof a?(this.comment||(this.comment=new Blockly.Comment(this),b=!0),this.comment.setText(a)):this.comment&&(this.comment.dispose(),b=!0);b&&this.rendered&&(this.render(),this.bumpNeighbours_())};
+Blockly.BlockSvg.prototype.setWarningText=function(a,b){this.warningTextDb_||(this.warningTextDb_=Object.create(null));var c=b||"";if(c)this.warningTextDb_[c]&&(clearTimeout(this.warningTextDb_[c]),delete this.warningTextDb_[c]);else for(var d in this.warningTextDb_)clearTimeout(this.warningTextDb_[d]),delete this.warningTextDb_[d];if(this.workspace.isDragging()){var e=this;this.warningTextDb_[c]=setTimeout(function(){e.workspace&&(delete e.warningTextDb_[c],e.setWarningText(a,c))},100)}else{this.isInFlyout&&
+(a=null);d=this.getSurroundParent();for(var f=null;d;)d.isCollapsed()&&(f=d),d=d.getSurroundParent();f&&f.setWarningText(Blockly.Msg.COLLAPSED_WARNINGS_WARNING,Blockly.BlockSvg.COLLAPSED_WARNING_ID);d=!1;"string"==typeof a?(this.warning||(this.warning=new Blockly.Warning(this),d=!0),this.warning.setText(a,c)):this.warning&&!c?(this.warning.dispose(),d=!0):this.warning&&(d=this.warning.getText(),this.warning.setText("",c),(f=this.warning.getText())||this.warning.dispose(),d=d!=f);d&&this.rendered&&
+(this.render(),this.bumpNeighbours_())}};Blockly.BlockSvg.prototype.setMutator=function(a){this.mutator&&this.mutator!==a&&this.mutator.dispose();a&&(a.block_=this,this.mutator=a,a.createIcon())};Blockly.BlockSvg.prototype.setDisabled=function(a){this.disabled!=a&&(Blockly.BlockSvg.superClass_.setDisabled.call(this,a),this.rendered&&this.updateDisabled())};
+Blockly.BlockSvg.prototype.setHighlighted=function(a){this.rendered&&(a?(this.svgPath_.setAttribute("filter","url(#"+this.workspace.options.embossFilterId+")"),this.svgPathLight_.style.display="none"):(Blockly.utils.removeAttribute(this.svgPath_,"filter"),delete this.svgPathLight_.style.display))};Blockly.BlockSvg.prototype.addSelect=function(){Blockly.utils.addClass(this.svgGroup_,"blocklySelected")};Blockly.BlockSvg.prototype.removeSelect=function(){Blockly.utils.removeClass(this.svgGroup_,"blocklySelected")};
+Blockly.BlockSvg.prototype.setDeleteStyle=function(a){a?Blockly.utils.addClass(this.svgGroup_,"blocklyDraggingDelete"):Blockly.utils.removeClass(this.svgGroup_,"blocklyDraggingDelete")};Blockly.BlockSvg.prototype.setColour=function(a){Blockly.BlockSvg.superClass_.setColour.call(this,a);this.rendered&&this.updateColour()};Blockly.BlockSvg.prototype.bringToFront=function(){var a=this;do{var b=a.getSvgRoot();b.parentNode.appendChild(b);a=a.getParent()}while(a)};
+Blockly.BlockSvg.prototype.setPreviousStatement=function(a,b){Blockly.BlockSvg.superClass_.setPreviousStatement.call(this,a,b);this.rendered&&(this.render(),this.bumpNeighbours_())};Blockly.BlockSvg.prototype.setNextStatement=function(a,b){Blockly.BlockSvg.superClass_.setNextStatement.call(this,a,b);this.rendered&&(this.render(),this.bumpNeighbours_())};Blockly.BlockSvg.prototype.setOutput=function(a,b){Blockly.BlockSvg.superClass_.setOutput.call(this,a,b);this.rendered&&(this.render(),this.bumpNeighbours_())};
+Blockly.BlockSvg.prototype.setInputsInline=function(a){Blockly.BlockSvg.superClass_.setInputsInline.call(this,a);this.rendered&&(this.render(),this.bumpNeighbours_())};Blockly.BlockSvg.prototype.removeInput=function(a,b){Blockly.BlockSvg.superClass_.removeInput.call(this,a,b);this.rendered&&(this.render(),this.bumpNeighbours_())};Blockly.BlockSvg.prototype.moveNumberedInputBefore=function(a,b){Blockly.BlockSvg.superClass_.moveNumberedInputBefore.call(this,a,b);this.rendered&&(this.render(),this.bumpNeighbours_())};
+Blockly.BlockSvg.prototype.appendInput_=function(a,b){var c=Blockly.BlockSvg.superClass_.appendInput_.call(this,a,b);this.rendered&&(this.render(),this.bumpNeighbours_());return c};Blockly.BlockSvg.prototype.getConnections_=function(a){var b=[];if(a||this.rendered)if(this.outputConnection&&b.push(this.outputConnection),this.previousConnection&&b.push(this.previousConnection),this.nextConnection&&b.push(this.nextConnection),a||!this.collapsed_){a=0;for(var c;c=this.inputList[a];a++)c.connection&&b.push(c.connection)}return b};
+Blockly.BlockSvg.prototype.makeConnection_=function(a){return new Blockly.RenderedConnection(this,a)};
+Blockly.BlockSvg.prototype.bumpNeighbours_=function(){if(this.workspace&&!this.workspace.isDragging()){var a=this.getRootBlock();if(!a.isInFlyout)for(var b=this.getConnections_(!1),c=0,d;d=b[c];c++){d.isConnected()&&d.isSuperior()&&d.targetBlock().bumpNeighbours_();for(var e=d.neighbours_(Blockly.SNAP_RADIUS),f=0,g;g=e[f];f++)d.isConnected()&&g.isConnected()||g.getSourceBlock().getRootBlock()!=a&&(d.isSuperior()?g.bumpAwayFrom_(d):d.bumpAwayFrom_(g))}}};
+Blockly.BlockSvg.prototype.scheduleSnapAndBump=function(){var a=this,b=Blockly.Events.getGroup();setTimeout(function(){Blockly.Events.setGroup(b);a.snapToGrid();Blockly.Events.setGroup(!1)},Blockly.BUMP_DELAY/2);setTimeout(function(){Blockly.Events.setGroup(b);a.bumpNeighbours_();Blockly.Events.setGroup(!1)},Blockly.BUMP_DELAY)};Blockly.BlockSvg.render={};Blockly.BlockSvg.PathObject=function(){this.steps=[];this.highlightSteps=[];this.inlineSteps=[];this.highlightInlineSteps=[]};Blockly.BlockSvg.SEP_SPACE_X=10;Blockly.BlockSvg.SEP_SPACE_Y=10;Blockly.BlockSvg.INLINE_PADDING_Y=5;Blockly.BlockSvg.MIN_BLOCK_Y=25;Blockly.BlockSvg.TAB_HEIGHT=20;Blockly.BlockSvg.TAB_WIDTH=8;Blockly.BlockSvg.NOTCH_WIDTH=30;Blockly.BlockSvg.CORNER_RADIUS=8;Blockly.BlockSvg.START_HAT=!1;Blockly.BlockSvg.START_HAT_HEIGHT=15;
+Blockly.BlockSvg.START_HAT_PATH="c 30,-"+Blockly.BlockSvg.START_HAT_HEIGHT+" 70,-"+Blockly.BlockSvg.START_HAT_HEIGHT+" 100,0";Blockly.BlockSvg.START_HAT_HIGHLIGHT_LTR="c 17.8,-9.2 45.3,-14.9 75,-8.7 M 100.5,0.5";Blockly.BlockSvg.START_HAT_HIGHLIGHT_RTL="m 25,-8.7 c 29.7,-6.2 57.2,-0.5 75,8.7";Blockly.BlockSvg.DISTANCE_45_INSIDE=(1-Math.SQRT1_2)*(Blockly.BlockSvg.CORNER_RADIUS-.5)+.5;Blockly.BlockSvg.DISTANCE_45_OUTSIDE=(1-Math.SQRT1_2)*(Blockly.BlockSvg.CORNER_RADIUS+.5)-.5;
+Blockly.BlockSvg.NOTCH_PATH_LEFT="l 6,4 3,0 6,-4";Blockly.BlockSvg.NOTCH_PATH_LEFT_HIGHLIGHT="l 6,4 3,0 6,-4";Blockly.BlockSvg.NOTCH_PATH_RIGHT="l -6,4 -3,0 -6,-4";Blockly.BlockSvg.JAGGED_TEETH="l 8,0 0,4 8,4 -16,8 8,4";Blockly.BlockSvg.JAGGED_TEETH_HEIGHT=20;Blockly.BlockSvg.JAGGED_TEETH_WIDTH=15;Blockly.BlockSvg.TAB_PATH_DOWN="v 5 c 0,10 -"+Blockly.BlockSvg.TAB_WIDTH+",-8 -"+Blockly.BlockSvg.TAB_WIDTH+",7.5 s "+Blockly.BlockSvg.TAB_WIDTH+",-2.5 "+Blockly.BlockSvg.TAB_WIDTH+",7.5";
+Blockly.BlockSvg.TAB_PATH_DOWN_HIGHLIGHT_RTL="v 6.5 m -"+.97*Blockly.BlockSvg.TAB_WIDTH+",3 q -"+.05*Blockly.BlockSvg.TAB_WIDTH+",10 "+.3*Blockly.BlockSvg.TAB_WIDTH+",9.5 m "+.67*Blockly.BlockSvg.TAB_WIDTH+",-1.9 v 1.4";Blockly.BlockSvg.TOP_LEFT_CORNER_START="m 0,"+Blockly.BlockSvg.CORNER_RADIUS;Blockly.BlockSvg.TOP_LEFT_CORNER_START_HIGHLIGHT_RTL="m "+Blockly.BlockSvg.DISTANCE_45_INSIDE+","+Blockly.BlockSvg.DISTANCE_45_INSIDE;
+Blockly.BlockSvg.TOP_LEFT_CORNER_START_HIGHLIGHT_LTR="m 0.5,"+(Blockly.BlockSvg.CORNER_RADIUS-.5);Blockly.BlockSvg.TOP_LEFT_CORNER="A "+Blockly.BlockSvg.CORNER_RADIUS+","+Blockly.BlockSvg.CORNER_RADIUS+" 0 0,1 "+Blockly.BlockSvg.CORNER_RADIUS+",0";Blockly.BlockSvg.TOP_LEFT_CORNER_HIGHLIGHT="A "+(Blockly.BlockSvg.CORNER_RADIUS-.5)+","+(Blockly.BlockSvg.CORNER_RADIUS-.5)+" 0 0,1 "+Blockly.BlockSvg.CORNER_RADIUS+",0.5";
+Blockly.BlockSvg.INNER_TOP_LEFT_CORNER=Blockly.BlockSvg.NOTCH_PATH_RIGHT+" h -"+(Blockly.BlockSvg.NOTCH_WIDTH-15-Blockly.BlockSvg.CORNER_RADIUS)+" a "+Blockly.BlockSvg.CORNER_RADIUS+","+Blockly.BlockSvg.CORNER_RADIUS+" 0 0,0 -"+Blockly.BlockSvg.CORNER_RADIUS+","+Blockly.BlockSvg.CORNER_RADIUS;Blockly.BlockSvg.INNER_BOTTOM_LEFT_CORNER="a "+Blockly.BlockSvg.CORNER_RADIUS+","+Blockly.BlockSvg.CORNER_RADIUS+" 0 0,0 "+Blockly.BlockSvg.CORNER_RADIUS+","+Blockly.BlockSvg.CORNER_RADIUS;
+Blockly.BlockSvg.INNER_TOP_LEFT_CORNER_HIGHLIGHT_RTL="a "+Blockly.BlockSvg.CORNER_RADIUS+","+Blockly.BlockSvg.CORNER_RADIUS+" 0 0,0 "+(-Blockly.BlockSvg.DISTANCE_45_OUTSIDE-.5)+","+(Blockly.BlockSvg.CORNER_RADIUS-Blockly.BlockSvg.DISTANCE_45_OUTSIDE);Blockly.BlockSvg.INNER_BOTTOM_LEFT_CORNER_HIGHLIGHT_RTL="a "+(Blockly.BlockSvg.CORNER_RADIUS+.5)+","+(Blockly.BlockSvg.CORNER_RADIUS+.5)+" 0 0,0 "+(Blockly.BlockSvg.CORNER_RADIUS+.5)+","+(Blockly.BlockSvg.CORNER_RADIUS+.5);
+Blockly.BlockSvg.INNER_BOTTOM_LEFT_CORNER_HIGHLIGHT_LTR="a "+(Blockly.BlockSvg.CORNER_RADIUS+.5)+","+(Blockly.BlockSvg.CORNER_RADIUS+.5)+" 0 0,0 "+(Blockly.BlockSvg.CORNER_RADIUS-Blockly.BlockSvg.DISTANCE_45_OUTSIDE)+","+(Blockly.BlockSvg.DISTANCE_45_OUTSIDE+.5);Blockly.BlockSvg.prototype.getHeightWidth=function(){var a=this.height,b=this.width,c=this.getNextBlock();c?(c=c.getHeightWidth(),a+=c.height-4,b=Math.max(b,c.width)):this.nextConnection||this.outputConnection||(a+=2);return{height:a,width:b}};
+Blockly.BlockSvg.prototype.render=function(a){Blockly.Field.startCache();this.rendered=!0;var b=Blockly.BlockSvg.SEP_SPACE_X;this.RTL&&(b=-b);for(var c=this.getIcons(),d=0;d<c.length;d++)b=c[d].renderIcon(b);b+=this.RTL?Blockly.BlockSvg.SEP_SPACE_X:-Blockly.BlockSvg.SEP_SPACE_X;c=this.renderCompute_(b);this.renderDraw_(b,c);this.renderMoveConnections_();!1!==a&&((a=this.getParent())?a.render(!0):this.workspace.resizeContents());Blockly.Field.stopCache()};
+Blockly.BlockSvg.prototype.renderFields_=function(a,b,c){c+=Blockly.BlockSvg.INLINE_PADDING_Y;this.RTL&&(b=-b);for(var d=0,e;e=a[d];d++){var f=e.getSvgRoot();if(f){var g="";if(this.RTL){var h=b-=e.renderSep+e.renderWidth;e.renderWidth&&(b-=Blockly.BlockSvg.SEP_SPACE_X)}else h=b+e.renderSep,e.renderWidth&&(b+=e.renderSep+e.renderWidth+Blockly.BlockSvg.SEP_SPACE_X);this.RTL&&e instanceof Blockly.FieldImage&&e.getFlipRtl()&&(g="scale(-1 1)",h+=e.renderWidth);f.setAttribute("transform","translate("+h+
+","+c+")"+g);this.isInsertionMarker()&&f.setAttribute("display","none")}}return this.RTL?-b:b};
+Blockly.BlockSvg.prototype.renderCompute_=function(a){var b=this.inputList,c=[];c.rightEdge=a+2*Blockly.BlockSvg.SEP_SPACE_X;if(this.previousConnection||this.nextConnection)c.rightEdge=Math.max(c.rightEdge,Blockly.BlockSvg.NOTCH_WIDTH+Blockly.BlockSvg.SEP_SPACE_X);for(var d=0,e=0,f=!1,g=!1,h=!1,k=void 0,l=this.getInputsInline()&&!this.isCollapsed(),n=0,m;m=b[n];n++)if(m.isVisible()){if(l&&k&&k!=Blockly.NEXT_STATEMENT&&m.type!=Blockly.NEXT_STATEMENT)var p=c[c.length-1];else k=m.type,p=[],p.type=l&&
+m.type!=Blockly.NEXT_STATEMENT?Blockly.BlockSvg.INLINE:m.type,p.height=0,c.push(p);p.push(m);m.renderHeight=Blockly.BlockSvg.MIN_BLOCK_Y;m.renderWidth=l&&m.type==Blockly.INPUT_VALUE?Blockly.BlockSvg.TAB_WIDTH+1.25*Blockly.BlockSvg.SEP_SPACE_X:0;if(m.connection&&m.connection.isConnected()){var q=m.connection.targetBlock().getHeightWidth();m.renderHeight=Math.max(m.renderHeight,q.height);m.renderWidth=Math.max(m.renderWidth,q.width)}l||n!=b.length-1?!l&&m.type==Blockly.INPUT_VALUE&&b[n+1]&&b[n+1].type==
+Blockly.NEXT_STATEMENT&&m.renderHeight--:m.renderHeight--;p.height=Math.max(p.height,m.renderHeight);m.fieldWidth=0;1==c.length&&(m.fieldWidth+=this.RTL?-a:a);q=!1;for(var t=0,r;r=m.fieldRow[t];t++){0!=t&&(m.fieldWidth+=Blockly.BlockSvg.SEP_SPACE_X);var u=r.getSize();r.renderWidth=u.width;r.renderSep=q&&r.EDITABLE?Blockly.BlockSvg.SEP_SPACE_X:0;m.fieldWidth+=r.renderWidth+r.renderSep;p.height=Math.max(p.height,u.height);q=r.EDITABLE}p.type!=Blockly.BlockSvg.INLINE&&(p.type==Blockly.NEXT_STATEMENT?
+(g=!0,e=Math.max(e,m.fieldWidth)):(p.type==Blockly.INPUT_VALUE?f=!0:p.type==Blockly.DUMMY_INPUT&&(h=!0),d=Math.max(d,m.fieldWidth)))}for(a=0;p=c[a];a++)if(p.thicker=!1,p.type==Blockly.BlockSvg.INLINE)for(b=0;m=p[b];b++)if(m.type==Blockly.INPUT_VALUE){p.height+=2*Blockly.BlockSvg.INLINE_PADDING_Y;p.thicker=!0;break}c.statementEdge=2*Blockly.BlockSvg.SEP_SPACE_X+e;g&&(c.rightEdge=Math.max(c.rightEdge,c.statementEdge+Blockly.BlockSvg.NOTCH_WIDTH));f?c.rightEdge=Math.max(c.rightEdge,d+2*Blockly.BlockSvg.SEP_SPACE_X+
+Blockly.BlockSvg.TAB_WIDTH):h&&(c.rightEdge=Math.max(c.rightEdge,d+2*Blockly.BlockSvg.SEP_SPACE_X));c.hasValue=f;c.hasStatement=g;c.hasDummy=h;return c};
+Blockly.BlockSvg.prototype.renderDraw_=function(a,b){this.startHat_=!1;this.height=0;if(this.outputConnection)this.squareBottomLeftCorner_=this.squareTopLeftCorner_=!0;else{var c="cap"===this.hat;this.squareBottomLeftCorner_=this.squareTopLeftCorner_=!1;this.previousConnection?(c=this.previousConnection.targetBlock())&&c.getNextBlock()==this&&(this.squareTopLeftCorner_=!0):c&&(this.startHat_=this.squareTopLeftCorner_=!0,this.height+=Blockly.BlockSvg.START_HAT_HEIGHT,b.rightEdge=Math.max(b.rightEdge,
+100));this.getNextBlock()&&(this.squareBottomLeftCorner_=!0)}c=new Blockly.BlockSvg.PathObject;this.renderDrawTop_(c,b.rightEdge);var d=this.renderDrawRight_(c,b,a);this.renderDrawBottom_(c,d);this.renderDrawLeft_(c);this.setPaths_(c)};
+Blockly.BlockSvg.prototype.setPaths_=function(a){var b=a.steps.join(" ")+"\n"+a.inlineSteps.join(" ");this.svgPath_.setAttribute("d",b);this.svgPathDark_.setAttribute("d",b);b=a.highlightSteps.join(" ")+"\n"+a.highlightInlineSteps.join(" ");this.svgPathLight_.setAttribute("d",b);this.RTL&&(this.svgPath_.setAttribute("transform","scale(-1 1)"),this.svgPathLight_.setAttribute("transform","scale(-1 1)"),this.svgPathDark_.setAttribute("transform","translate(1,1) scale(-1 1)"))};
+Blockly.BlockSvg.prototype.renderMoveConnections_=function(){var a=this.getRelativeToSurfaceXY();this.previousConnection&&this.previousConnection.moveToOffset(a);this.outputConnection&&this.outputConnection.moveToOffset(a);for(var b=0;b<this.inputList.length;b++){var c=this.inputList[b].connection;c&&(c.moveToOffset(a),c.isConnected()&&c.tighten_())}this.nextConnection&&(this.nextConnection.moveToOffset(a),this.nextConnection.isConnected()&&this.nextConnection.tighten_())};
+Blockly.BlockSvg.prototype.renderDrawTop_=function(a,b){var c=a.steps,d=a.highlightSteps;this.squareTopLeftCorner_?(c.push("m 0,0"),d.push("m 0.5,0.5"),this.startHat_&&(c.push(Blockly.BlockSvg.START_HAT_PATH),d.push(this.RTL?Blockly.BlockSvg.START_HAT_HIGHLIGHT_RTL:Blockly.BlockSvg.START_HAT_HIGHLIGHT_LTR))):(c.push(Blockly.BlockSvg.TOP_LEFT_CORNER_START),d.push(this.RTL?Blockly.BlockSvg.TOP_LEFT_CORNER_START_HIGHLIGHT_RTL:Blockly.BlockSvg.TOP_LEFT_CORNER_START_HIGHLIGHT_LTR),c.push(Blockly.BlockSvg.TOP_LEFT_CORNER),
+d.push(Blockly.BlockSvg.TOP_LEFT_CORNER_HIGHLIGHT));this.previousConnection&&(c.push("H",Blockly.BlockSvg.NOTCH_WIDTH-15),d.push("H",Blockly.BlockSvg.NOTCH_WIDTH-15),c.push(Blockly.BlockSvg.NOTCH_PATH_LEFT),d.push(Blockly.BlockSvg.NOTCH_PATH_LEFT_HIGHLIGHT),this.previousConnection.setOffsetInBlock(this.RTL?-Blockly.BlockSvg.NOTCH_WIDTH:Blockly.BlockSvg.NOTCH_WIDTH,0));c.push("H",b);d.push("H",b-.5);this.width=b};
+Blockly.BlockSvg.prototype.renderDrawRight_=function(a,b,c){for(var d={x:0,y:0},e={x:0,y:0},f=0,g;g=b[f];f++)d.x=Blockly.BlockSvg.SEP_SPACE_X,0==f&&(d.x+=this.RTL?-c:c),a.highlightSteps.push("M",b.rightEdge-.5+","+(d.y+.5)),this.isCollapsed()?this.renderJaggedEdge_(a,g,d):g.type==Blockly.BlockSvg.INLINE?this.renderInlineRow_(a,g,d,e,b.rightEdge):g.type==Blockly.INPUT_VALUE?this.renderExternalValueInput_(a,g,d,e,b.rightEdge):g.type==Blockly.DUMMY_INPUT?this.renderDummyInput_(a,g,d,b.rightEdge,b.hasValue):
+g.type==Blockly.NEXT_STATEMENT&&this.renderStatementInput_(a,g,d,e,b,f),d.y+=g.height;b.length||(d.y=Blockly.BlockSvg.MIN_BLOCK_Y,a.steps.push("V",d.y),this.RTL&&a.highlightSteps.push("V",d.y-1));return d.y};
+Blockly.BlockSvg.prototype.renderDrawBottom_=function(a,b){var c=a.steps,d=a.highlightSteps;this.height+=b+1;this.nextConnection&&(c.push("H",Blockly.BlockSvg.NOTCH_WIDTH+(this.RTL?.5:-.5)+" "+Blockly.BlockSvg.NOTCH_PATH_RIGHT),this.nextConnection.setOffsetInBlock(this.RTL?-Blockly.BlockSvg.NOTCH_WIDTH:Blockly.BlockSvg.NOTCH_WIDTH,b+1),this.height+=4);this.squareBottomLeftCorner_?(c.push("H 0"),this.RTL||d.push("M","0.5,"+(b-.5))):(c.push("H",Blockly.BlockSvg.CORNER_RADIUS),c.push("a",Blockly.BlockSvg.CORNER_RADIUS+
+","+Blockly.BlockSvg.CORNER_RADIUS+" 0 0,1 -"+Blockly.BlockSvg.CORNER_RADIUS+",-"+Blockly.BlockSvg.CORNER_RADIUS),this.RTL||(d.push("M",Blockly.BlockSvg.DISTANCE_45_INSIDE+","+(b-Blockly.BlockSvg.DISTANCE_45_INSIDE)),d.push("A",Blockly.BlockSvg.CORNER_RADIUS-.5+","+(Blockly.BlockSvg.CORNER_RADIUS-.5)+" 0 0,1 0.5,"+(b-Blockly.BlockSvg.CORNER_RADIUS))))};
+Blockly.BlockSvg.prototype.renderDrawLeft_=function(a){var b=a.steps;a=a.highlightSteps;this.outputConnection?(this.outputConnection.setOffsetInBlock(0,0),b.push("V",Blockly.BlockSvg.TAB_HEIGHT),b.push("c 0,-10 -"+Blockly.BlockSvg.TAB_WIDTH+",8 -"+Blockly.BlockSvg.TAB_WIDTH+",-7.5 s "+Blockly.BlockSvg.TAB_WIDTH+",2.5 "+Blockly.BlockSvg.TAB_WIDTH+",-7.5"),this.RTL?(a.push("M",-.25*Blockly.BlockSvg.TAB_WIDTH+",8.4"),a.push("l",-.45*Blockly.BlockSvg.TAB_WIDTH+",-2.1")):(a.push("V",Blockly.BlockSvg.TAB_HEIGHT-
+1.5),a.push("m",-.92*Blockly.BlockSvg.TAB_WIDTH+",-0.5 q "+-.19*Blockly.BlockSvg.TAB_WIDTH+",-5.5 0,-11"),a.push("m",.92*Blockly.BlockSvg.TAB_WIDTH+",1 V 0.5 H 1")),this.width+=Blockly.BlockSvg.TAB_WIDTH):this.RTL||(this.squareTopLeftCorner_?a.push("V",.5):a.push("V",Blockly.BlockSvg.CORNER_RADIUS));b.push("z")};
+Blockly.BlockSvg.prototype.renderJaggedEdge_=function(a,b,c){var d=a.steps;a=a.highlightSteps;this.renderFields_(b[0].fieldRow,c.x,c.y);d.push(Blockly.BlockSvg.JAGGED_TEETH);a.push("h 8");b=b.height-Blockly.BlockSvg.JAGGED_TEETH_HEIGHT;d.push("v",b);this.RTL&&(a.push("v 3.9 l 7.2,3.4 m -14.5,8.9 l 7.3,3.5"),a.push("v",b-.7));this.width+=Blockly.BlockSvg.JAGGED_TEETH_WIDTH};
+Blockly.BlockSvg.prototype.renderInlineRow_=function(a,b,c,d,e){var f=a.inlineSteps,g=a.highlightInlineSteps,h=a.steps;a=a.highlightSteps;for(var k=0,l;l=b[k];k++){var n=c.x,m=c.y;b.thicker&&(m+=Blockly.BlockSvg.INLINE_PADDING_Y);c.x=this.renderFields_(l.fieldRow,n,m);l.type!=Blockly.DUMMY_INPUT&&(c.x+=l.renderWidth+Blockly.BlockSvg.SEP_SPACE_X);l.type==Blockly.INPUT_VALUE&&(f.push("M",c.x-Blockly.BlockSvg.SEP_SPACE_X+","+(c.y+Blockly.BlockSvg.INLINE_PADDING_Y)),f.push("h",Blockly.BlockSvg.TAB_WIDTH-
+2-l.renderWidth),f.push(Blockly.BlockSvg.TAB_PATH_DOWN),f.push("v",l.renderHeight+1-Blockly.BlockSvg.TAB_HEIGHT),f.push("h",l.renderWidth+2-Blockly.BlockSvg.TAB_WIDTH),f.push("z"),this.RTL?(g.push("M",c.x-Blockly.BlockSvg.SEP_SPACE_X-2.5+Blockly.BlockSvg.TAB_WIDTH-l.renderWidth+","+(c.y+Blockly.BlockSvg.INLINE_PADDING_Y+.5)),g.push(Blockly.BlockSvg.TAB_PATH_DOWN_HIGHLIGHT_RTL),g.push("v",l.renderHeight-Blockly.BlockSvg.TAB_HEIGHT+2.5),g.push("h",l.renderWidth-Blockly.BlockSvg.TAB_WIDTH+2)):(g.push("M",
+c.x-Blockly.BlockSvg.SEP_SPACE_X+.5+","+(c.y+Blockly.BlockSvg.INLINE_PADDING_Y+.5)),g.push("v",l.renderHeight+1),g.push("h",Blockly.BlockSvg.TAB_WIDTH-2-l.renderWidth),g.push("M",c.x-l.renderWidth-Blockly.BlockSvg.SEP_SPACE_X+.9+","+(c.y+Blockly.BlockSvg.INLINE_PADDING_Y+Blockly.BlockSvg.TAB_HEIGHT-.7)),g.push("l",.46*Blockly.BlockSvg.TAB_WIDTH+",-2.1")),d.x=this.RTL?-c.x-Blockly.BlockSvg.TAB_WIDTH+Blockly.BlockSvg.SEP_SPACE_X+l.renderWidth+1:c.x+Blockly.BlockSvg.TAB_WIDTH-Blockly.BlockSvg.SEP_SPACE_X-
+l.renderWidth-1,d.y=c.y+Blockly.BlockSvg.INLINE_PADDING_Y+1,l.connection.setOffsetInBlock(d.x,d.y))}c.x=Math.max(c.x,e);this.width=Math.max(this.width,c.x);h.push("H",c.x);a.push("H",c.x-.5);h.push("v",b.height);this.RTL&&a.push("v",b.height-1)};
+Blockly.BlockSvg.prototype.renderExternalValueInput_=function(a,b,c,d,e){var f=a.steps;a=a.highlightSteps;var g=b[0],h=c.x,k=c.y;if(g.align!=Blockly.ALIGN_LEFT){var l=e-g.fieldWidth-Blockly.BlockSvg.TAB_WIDTH-2*Blockly.BlockSvg.SEP_SPACE_X;g.align==Blockly.ALIGN_RIGHT?h+=l:g.align==Blockly.ALIGN_CENTRE&&(h+=l/2)}this.renderFields_(g.fieldRow,h,k);f.push(Blockly.BlockSvg.TAB_PATH_DOWN);b=b.height-Blockly.BlockSvg.TAB_HEIGHT;f.push("v",b);this.RTL?(a.push(Blockly.BlockSvg.TAB_PATH_DOWN_HIGHLIGHT_RTL),
+a.push("v",b+.5)):(a.push("M",e-5+","+(c.y+Blockly.BlockSvg.TAB_HEIGHT-.7)),a.push("l",.46*Blockly.BlockSvg.TAB_WIDTH+",-2.1"));d.x=this.RTL?-e-1:e+1;g.connection.setOffsetInBlock(d.x,c.y);g.connection.isConnected()&&(this.width=Math.max(this.width,e+g.connection.targetBlock().getHeightWidth().width-Blockly.BlockSvg.TAB_WIDTH+1))};
+Blockly.BlockSvg.prototype.renderDummyInput_=function(a,b,c,d,e){var f=a.steps;a=a.highlightSteps;var g=b[0],h=c.x;c=c.y;g.align!=Blockly.ALIGN_LEFT&&(d=d-g.fieldWidth-2*Blockly.BlockSvg.SEP_SPACE_X,e&&(d-=Blockly.BlockSvg.TAB_WIDTH),g.align==Blockly.ALIGN_RIGHT?h+=d:g.align==Blockly.ALIGN_CENTRE&&(h+=d/2));this.renderFields_(g.fieldRow,h,c);f.push("v",b.height);this.RTL&&a.push("v",b.height-1)};
+Blockly.BlockSvg.prototype.renderStatementInput_=function(a,b,c,d,e,f){var g=a.steps;a=a.highlightSteps;var h=b[0];0==f&&(g.push("v",Blockly.BlockSvg.SEP_SPACE_Y),this.RTL&&a.push("v",Blockly.BlockSvg.SEP_SPACE_Y-1),c.y+=Blockly.BlockSvg.SEP_SPACE_Y);var k=c.x,l=c.y;if(h.align!=Blockly.ALIGN_LEFT){var n=e.statementEdge-h.fieldWidth-2*Blockly.BlockSvg.SEP_SPACE_X;h.align==Blockly.ALIGN_RIGHT?k+=n:h.align==Blockly.ALIGN_CENTRE&&(k+=n/2)}this.renderFields_(h.fieldRow,k,l);c.x=e.statementEdge+Blockly.BlockSvg.NOTCH_WIDTH;
+g.push("H",c.x);g.push(Blockly.BlockSvg.INNER_TOP_LEFT_CORNER);g.push("v",b.height-2*Blockly.BlockSvg.CORNER_RADIUS);g.push(Blockly.BlockSvg.INNER_BOTTOM_LEFT_CORNER);g.push("H",e.rightEdge);this.RTL?(a.push("M",c.x-Blockly.BlockSvg.NOTCH_WIDTH+Blockly.BlockSvg.DISTANCE_45_OUTSIDE+","+(c.y+Blockly.BlockSvg.DISTANCE_45_OUTSIDE)),a.push(Blockly.BlockSvg.INNER_TOP_LEFT_CORNER_HIGHLIGHT_RTL),a.push("v",b.height-2*Blockly.BlockSvg.CORNER_RADIUS),a.push(Blockly.BlockSvg.INNER_BOTTOM_LEFT_CORNER_HIGHLIGHT_RTL)):
+(a.push("M",c.x-Blockly.BlockSvg.NOTCH_WIDTH+Blockly.BlockSvg.DISTANCE_45_OUTSIDE+","+(c.y+b.height-Blockly.BlockSvg.DISTANCE_45_OUTSIDE)),a.push(Blockly.BlockSvg.INNER_BOTTOM_LEFT_CORNER_HIGHLIGHT_LTR));a.push("H",e.rightEdge-.5);d.x=this.RTL?-c.x:c.x+1;h.connection.setOffsetInBlock(d.x,c.y+1);h.connection.isConnected()&&(this.width=Math.max(this.width,e.statementEdge+h.connection.targetBlock().getHeightWidth().width));if(f==e.length-1||e[f+1].type==Blockly.NEXT_STATEMENT)g.push("v",Blockly.BlockSvg.SEP_SPACE_Y),
+this.RTL&&a.push("v",Blockly.BlockSvg.SEP_SPACE_Y-1),c.y+=Blockly.BlockSvg.SEP_SPACE_Y};Blockly.BlockSvg.prototype.positionNewBlock=function(a,b,c){b.type!=Blockly.NEXT_STATEMENT&&b.type!=Blockly.INPUT_VALUE||a.moveBy(c.x_-b.x_,c.y_-b.y_)};Blockly.BlockSvg.prototype.highlightForReplacement=function(a){a?Blockly.utils.addClass(this.svgGroup_,"blocklyReplaceable"):Blockly.utils.removeClass(this.svgGroup_,"blocklyReplaceable")};Blockly.Msg={};goog.getMsgOrig=goog.getMsg;goog.getMsg=function(a,b){var c=goog.getMsg.blocklyMsgMap[a];c&&(a=Blockly.Msg[c]);return goog.getMsgOrig(a,b)};goog.getMsg.blocklyMsgMap={Today:"TODAY"};Blockly.FieldTextInput=function(a,b){Blockly.FieldTextInput.superClass_.constructor.call(this,a,b)};goog.inherits(Blockly.FieldTextInput,Blockly.Field);Blockly.FieldTextInput.fromJson=function(a){var b=Blockly.utils.replaceMessageReferences(a.text);b=new Blockly.FieldTextInput(b,a["class"]);"boolean"===typeof a.spellcheck&&b.setSpellcheck(a.spellcheck);return b};Blockly.FieldTextInput.FONTSIZE=11;Blockly.FieldTextInput.htmlInput_=null;Blockly.FieldTextInput.prototype.CURSOR="text";
+Blockly.FieldTextInput.prototype.spellcheck_=!0;Blockly.FieldTextInput.prototype.dispose=function(){Blockly.WidgetDiv.hideIfOwner(this);Blockly.FieldTextInput.superClass_.dispose.call(this)};Blockly.FieldTextInput.prototype.setValue=function(a){if(null!==a){if(this.sourceBlock_){var b=this.callValidator(a);null!==b&&(a=b)}Blockly.Field.prototype.setValue.call(this,a)}};
+Blockly.FieldTextInput.prototype.setText=function(a){null!==a&&(a=String(a),a!==this.text_&&(this.sourceBlock_&&Blockly.Events.isEnabled()&&Blockly.Events.fire(new Blockly.Events.BlockChange(this.sourceBlock_,"field",this.name,this.text_,a)),Blockly.Field.prototype.setText.call(this,a)))};Blockly.FieldTextInput.prototype.setSpellcheck=function(a){this.spellcheck_=a};
+Blockly.FieldTextInput.prototype.showEditor_=function(a){this.workspace_=this.sourceBlock_.workspace;a=a||!1;!a&&(goog.userAgent.MOBILE||goog.userAgent.ANDROID||goog.userAgent.IPAD)?this.showPromptEditor_():this.showInlineEditor_(a)};Blockly.FieldTextInput.prototype.showPromptEditor_=function(){var a=this;Blockly.prompt(Blockly.Msg.CHANGE_VALUE_TITLE,this.text_,function(b){a.sourceBlock_&&(b=a.callValidator(b));a.setValue(b)})};
+Blockly.FieldTextInput.prototype.showInlineEditor_=function(a){Blockly.WidgetDiv.show(this,this.sourceBlock_.RTL,this.widgetDispose_());var b=Blockly.WidgetDiv.DIV,c=document.createElement("input");c.className="blocklyHtmlInput";c.setAttribute("spellcheck",this.spellcheck_);var d=Blockly.FieldTextInput.FONTSIZE*this.workspace_.scale+"pt";b.style.fontSize=d;c.style.fontSize=d;Blockly.FieldTextInput.htmlInput_=c;b.appendChild(c);c.value=c.defaultValue=this.text_;c.oldValue_=null;this.validate_();this.resizeEditor_();
+a||(c.focus(),c.select());this.bindEvents_(c)};Blockly.FieldTextInput.prototype.bindEvents_=function(a){a.onKeyDownWrapper_=Blockly.bindEventWithChecks_(a,"keydown",this,this.onHtmlInputKeyDown_);a.onKeyUpWrapper_=Blockly.bindEventWithChecks_(a,"keyup",this,this.onHtmlInputChange_);a.onKeyPressWrapper_=Blockly.bindEventWithChecks_(a,"keypress",this,this.onHtmlInputChange_);a.onWorkspaceChangeWrapper_=this.resizeEditor_.bind(this);this.workspace_.addChangeListener(a.onWorkspaceChangeWrapper_)};
+Blockly.FieldTextInput.prototype.unbindEvents_=function(a){Blockly.unbindEvent_(a.onKeyDownWrapper_);Blockly.unbindEvent_(a.onKeyUpWrapper_);Blockly.unbindEvent_(a.onKeyPressWrapper_);this.workspace_.removeChangeListener(a.onWorkspaceChangeWrapper_)};
+Blockly.FieldTextInput.prototype.onHtmlInputKeyDown_=function(a){var b=Blockly.FieldTextInput.htmlInput_;13==a.keyCode?Blockly.WidgetDiv.hide():27==a.keyCode?(b.value=b.defaultValue,Blockly.WidgetDiv.hide()):9==a.keyCode&&(Blockly.WidgetDiv.hide(),this.sourceBlock_.tab(this,!a.shiftKey),a.preventDefault())};
+Blockly.FieldTextInput.prototype.onHtmlInputChange_=function(a){a=Blockly.FieldTextInput.htmlInput_;var b=a.value;b!==a.oldValue_?(a.oldValue_=b,Blockly.Events.setGroup(!0),this.setValue(b),Blockly.Events.setGroup(!1),this.validate_()):goog.userAgent.WEBKIT&&this.sourceBlock_.render();this.resizeEditor_();Blockly.svgResize(this.sourceBlock_.workspace)};
+Blockly.FieldTextInput.prototype.validate_=function(){var a=!0;if(!Blockly.FieldTextInput.htmlInput_)throw Error("htmlInput not defined");var b=Blockly.FieldTextInput.htmlInput_;this.sourceBlock_&&(a=this.callValidator(b.value));null===a?Blockly.utils.addClass(b,"blocklyInvalidInput"):Blockly.utils.removeClass(b,"blocklyInvalidInput")};
+Blockly.FieldTextInput.prototype.resizeEditor_=function(){var a=Blockly.WidgetDiv.DIV,b=this.getScaledBBox_();a.style.width=b.right-b.left+"px";a.style.height=b.bottom-b.top+"px";b=new goog.math.Coordinate(this.sourceBlock_.RTL?b.right-a.offsetWidth:b.left,b.top);b.y+=1;goog.userAgent.GECKO&&Blockly.WidgetDiv.DIV.style.top&&(--b.x,--b.y);goog.userAgent.WEBKIT&&(b.y-=3);a.style.left=b.x+"px";a.style.top=b.y+"px"};
+Blockly.FieldTextInput.prototype.widgetDispose_=function(){var a=this;return function(){var b=Blockly.FieldTextInput.htmlInput_;a.maybeSaveEdit_();a.unbindEvents_(b);Blockly.FieldTextInput.htmlInput_=null;Blockly.Events.setGroup(!1);b=Blockly.WidgetDiv.DIV.style;b.width="auto";b.height="auto";b.fontSize=""}};
+Blockly.FieldTextInput.prototype.maybeSaveEdit_=function(){var a=Blockly.FieldTextInput.htmlInput_,b=a.value;if(this.sourceBlock_)if(b=this.callValidator(b),null===b)b=a.defaultValue;else if(this.onFinishEditing_)this.onFinishEditing_(b);this.setText(b);this.sourceBlock_.rendered&&this.sourceBlock_.render()};
+Blockly.FieldTextInput.numberValidator=function(a){console.warn("Blockly.FieldTextInput.numberValidator is deprecated. Use Blockly.FieldNumber instead.");if(null===a)return null;a=String(a);a=a.replace(/O/ig,"0");a=a.replace(/,/g,"");a=parseFloat(a||0);return isNaN(a)?null:String(a)};Blockly.FieldTextInput.nonnegativeIntegerValidator=function(a){(a=Blockly.FieldTextInput.numberValidator(a))&&(a=String(Math.max(0,Math.floor(a))));return a};Blockly.Field.register("field_input",Blockly.FieldTextInput);Blockly.FieldAngle=function(a,b){this.symbol_=Blockly.utils.createSvgElement("tspan",{},null);this.symbol_.appendChild(document.createTextNode("\u00b0"));a=a&&!isNaN(a)?String(a):"0";Blockly.FieldAngle.superClass_.constructor.call(this,a,b)};goog.inherits(Blockly.FieldAngle,Blockly.FieldTextInput);Blockly.FieldAngle.fromJson=function(a){return new Blockly.FieldAngle(a.angle)};Blockly.FieldAngle.ROUND=15;Blockly.FieldAngle.HALF=50;Blockly.FieldAngle.CLOCKWISE=!1;Blockly.FieldAngle.OFFSET=0;
+Blockly.FieldAngle.WRAP=360;Blockly.FieldAngle.RADIUS=Blockly.FieldAngle.HALF-1;Blockly.FieldAngle.prototype.render_=function(){this.visible_?(this.textElement_.textContent=this.getDisplayText_(),this.sourceBlock_.RTL?this.textElement_.insertBefore(this.symbol_,this.textElement_.firstChild):this.textElement_.appendChild(this.symbol_),this.updateWidth()):this.size_.width=0};
+Blockly.FieldAngle.prototype.dispose_=function(){var a=this;return function(){Blockly.FieldAngle.superClass_.dispose_.call(a)();a.gauge_=null;a.clickWrapper_&&Blockly.unbindEvent_(a.clickWrapper_);a.moveWrapper1_&&Blockly.unbindEvent_(a.moveWrapper1_);a.moveWrapper2_&&Blockly.unbindEvent_(a.moveWrapper2_)}};
+Blockly.FieldAngle.prototype.showEditor_=function(){Blockly.FieldAngle.superClass_.showEditor_.call(this,goog.userAgent.MOBILE||goog.userAgent.ANDROID||goog.userAgent.IPAD);var a=Blockly.WidgetDiv.DIV;if(a.firstChild){a=Blockly.utils.createSvgElement("svg",{xmlns:"http://www.w3.org/2000/svg","xmlns:html":"http://www.w3.org/1999/xhtml","xmlns:xlink":"http://www.w3.org/1999/xlink",version:"1.1",height:2*Blockly.FieldAngle.HALF+"px",width:2*Blockly.FieldAngle.HALF+"px"},a);var b=Blockly.utils.createSvgElement("circle",
+{cx:Blockly.FieldAngle.HALF,cy:Blockly.FieldAngle.HALF,r:Blockly.FieldAngle.RADIUS,"class":"blocklyAngleCircle"},a);this.gauge_=Blockly.utils.createSvgElement("path",{"class":"blocklyAngleGauge"},a);this.line_=Blockly.utils.createSvgElement("line",{x1:Blockly.FieldAngle.HALF,y1:Blockly.FieldAngle.HALF,"class":"blocklyAngleLine"},a);for(var c=0;360>c;c+=15)Blockly.utils.createSvgElement("line",{x1:Blockly.FieldAngle.HALF+Blockly.FieldAngle.RADIUS,y1:Blockly.FieldAngle.HALF,x2:Blockly.FieldAngle.HALF+
+Blockly.FieldAngle.RADIUS-(0==c%45?10:5),y2:Blockly.FieldAngle.HALF,"class":"blocklyAngleMarks",transform:"rotate("+c+","+Blockly.FieldAngle.HALF+","+Blockly.FieldAngle.HALF+")"},a);a.style.marginLeft=15-Blockly.FieldAngle.RADIUS+"px";this.clickWrapper_=Blockly.bindEvent_(a,"click",this,Blockly.WidgetDiv.hide);this.moveWrapper1_=Blockly.bindEvent_(b,"mousemove",this,this.onMouseMove);this.moveWrapper2_=Blockly.bindEvent_(this.gauge_,"mousemove",this,this.onMouseMove);this.updateGraph_()}};
+Blockly.FieldAngle.prototype.onMouseMove=function(a){var b=this.gauge_.ownerSVGElement.getBoundingClientRect(),c=a.clientX-b.left-Blockly.FieldAngle.HALF;a=a.clientY-b.top-Blockly.FieldAngle.HALF;b=Math.atan(-a/c);isNaN(b)||(b=Blockly.utils.toDegrees(b),0>c?b+=180:0<a&&(b+=360),b=Blockly.FieldAngle.CLOCKWISE?Blockly.FieldAngle.OFFSET+360-b:b-Blockly.FieldAngle.OFFSET,Blockly.FieldAngle.ROUND&&(b=Math.round(b/Blockly.FieldAngle.ROUND)*Blockly.FieldAngle.ROUND),b=this.callValidator(b),Blockly.FieldTextInput.htmlInput_.value=
+b,this.setValue(b),this.validate_(),this.resizeEditor_())};Blockly.FieldAngle.prototype.setText=function(a){Blockly.FieldAngle.superClass_.setText.call(this,a);this.textElement_&&(this.updateGraph_(),this.size_.width=0)};
+Blockly.FieldAngle.prototype.updateGraph_=function(){if(this.gauge_){var a=Number(this.getText())+Blockly.FieldAngle.OFFSET,b=Blockly.utils.toRadians(a);a=["M ",Blockly.FieldAngle.HALF,",",Blockly.FieldAngle.HALF];var c=Blockly.FieldAngle.HALF,d=Blockly.FieldAngle.HALF;if(!isNaN(b)){var e=Blockly.utils.toRadians(Blockly.FieldAngle.OFFSET),f=Math.cos(e)*Blockly.FieldAngle.RADIUS,g=Math.sin(e)*-Blockly.FieldAngle.RADIUS;Blockly.FieldAngle.CLOCKWISE&&(b=2*e-b);c+=Math.cos(b)*Blockly.FieldAngle.RADIUS;
+d-=Math.sin(b)*Blockly.FieldAngle.RADIUS;b=Math.abs(Math.floor((b-e)/Math.PI)%2);Blockly.FieldAngle.CLOCKWISE&&(b=1-b);a.push(" l ",f,",",g," A ",Blockly.FieldAngle.RADIUS,",",Blockly.FieldAngle.RADIUS," 0 ",b," ",Number(Blockly.FieldAngle.CLOCKWISE)," ",c,",",d," z")}this.gauge_.setAttribute("d",a.join(""));this.line_.setAttribute("x2",c);this.line_.setAttribute("y2",d)}};
+Blockly.FieldAngle.prototype.classValidator=function(a){if(null===a)return null;a=parseFloat(a||0);if(isNaN(a))return null;a%=360;0>a&&(a+=360);a>Blockly.FieldAngle.WRAP&&(a-=360);return String(a)};Blockly.Field.register("field_angle",Blockly.FieldAngle);Blockly.FieldCheckbox=function(a,b){Blockly.FieldCheckbox.superClass_.constructor.call(this,"",b);this.setValue(a)};goog.inherits(Blockly.FieldCheckbox,Blockly.Field);Blockly.FieldCheckbox.fromJson=function(a){return new Blockly.FieldCheckbox(a.checked?"TRUE":"FALSE")};Blockly.FieldCheckbox.CHECK_CHAR="\u2713";Blockly.FieldCheckbox.prototype.CURSOR="default";
+Blockly.FieldCheckbox.prototype.init=function(){if(!this.fieldGroup_){Blockly.FieldCheckbox.superClass_.init.call(this);this.checkElement_=Blockly.utils.createSvgElement("text",{"class":"blocklyText blocklyCheckbox",x:-3,y:14},this.fieldGroup_);var a=document.createTextNode(Blockly.FieldCheckbox.CHECK_CHAR);this.checkElement_.appendChild(a);this.checkElement_.style.display=this.state_?"block":"none"}};Blockly.FieldCheckbox.prototype.getValue=function(){return String(this.state_).toUpperCase()};
+Blockly.FieldCheckbox.prototype.setValue=function(a){a="string"==typeof a?"TRUE"==a.toUpperCase():!!a;this.state_!==a&&(this.sourceBlock_&&Blockly.Events.isEnabled()&&Blockly.Events.fire(new Blockly.Events.BlockChange(this.sourceBlock_,"field",this.name,this.state_,a)),this.state_=a,this.checkElement_&&(this.checkElement_.style.display=a?"block":"none"))};Blockly.FieldCheckbox.prototype.showEditor_=function(){var a=!this.state_;this.sourceBlock_&&(a=this.callValidator(a));null!==a&&this.setValue(String(a).toUpperCase())};
+Blockly.Field.register("field_checkbox",Blockly.FieldCheckbox);Blockly.FieldColour=function(a,b){Blockly.FieldColour.superClass_.constructor.call(this,a,b);this.setText(Blockly.Field.NBSP+Blockly.Field.NBSP+Blockly.Field.NBSP)};goog.inherits(Blockly.FieldColour,Blockly.Field);Blockly.FieldColour.fromJson=function(a){return new Blockly.FieldColour(a.colour)};Blockly.FieldColour.prototype.colours_=null;Blockly.FieldColour.prototype.titles_=null;Blockly.FieldColour.prototype.columns_=0;
+Blockly.FieldColour.prototype.init=function(){Blockly.FieldColour.superClass_.init.call(this);this.borderRect_.style.fillOpacity=1;this.setValue(this.getValue())};Blockly.FieldColour.prototype.CURSOR="default";Blockly.FieldColour.prototype.dispose=function(){Blockly.WidgetDiv.hideIfOwner(this);Blockly.FieldColour.superClass_.dispose.call(this)};Blockly.FieldColour.prototype.getValue=function(){return this.colour_};
+Blockly.FieldColour.prototype.setValue=function(a){this.sourceBlock_&&Blockly.Events.isEnabled()&&this.colour_!=a&&Blockly.Events.fire(new Blockly.Events.BlockChange(this.sourceBlock_,"field",this.name,this.colour_,a));this.colour_=a;this.borderRect_&&(this.borderRect_.style.fill=a)};Blockly.FieldColour.prototype.getText=function(){var a=this.colour_,b=a.match(/^#(.)\1(.)\2(.)\3$/);b&&(a="#"+b[1]+b[2]+b[3]);return a};Blockly.FieldColour.COLOURS="#ffffff #cccccc #c0c0c0 #999999 #666666 #333333 #000000 #ffcccc #ff6666 #ff0000 #cc0000 #990000 #660000 #330000 #ffcc99 #ff9966 #ff9900 #ff6600 #cc6600 #993300 #663300 #ffff99 #ffff66 #ffcc66 #ffcc33 #cc9933 #996633 #663333 #ffffcc #ffff33 #ffff00 #ffcc00 #999900 #666600 #333300 #99ff99 #66ff99 #33ff33 #33cc00 #009900 #006600 #003300 #99ffff #33ffff #66cccc #00cccc #339999 #336666 #003333 #ccffff #66ffff #33ccff #3366ff #3333ff #000099 #000066 #ccccff #9999ff #6666cc #6633ff #6600cc #333399 #330099 #ffccff #ff99ff #cc66cc #cc33cc #993399 #663366 #330033".split(" ");
+Blockly.FieldColour.TITLES=[];Blockly.FieldColour.COLUMNS=7;Blockly.FieldColour.prototype.setColours=function(a,b){this.colours_=a;void 0!==b&&(this.titles_=b);return this};Blockly.FieldColour.prototype.setColumns=function(a){this.columns_=a;return this};
+Blockly.FieldColour.prototype.showEditor_=function(){Blockly.WidgetDiv.show(this,this.sourceBlock_.RTL,Blockly.FieldColour.widgetDispose_);var a=Blockly.utils.getViewportBBox(),b=this.getScaledBBox_(),c=this.createWidget_();Blockly.WidgetDiv.DIV.appendChild(c);var d=goog.style.getSize(c);Blockly.WidgetDiv.positionWithAnchor(a,b,d,this.sourceBlock_.RTL);Blockly.FieldColour.onUpWrapper_=Blockly.bindEvent_(c,"mouseup",this,this.onClick_)};
+Blockly.FieldColour.prototype.onClick_=function(a){(a=a.target)&&!a.label&&(a=a.parentNode);a=a&&a.label;Blockly.WidgetDiv.hide();this.sourceBlock_&&(a=this.callValidator(a));null!==a&&this.setValue(a)};
+Blockly.FieldColour.prototype.createWidget_=function(){var a=this.columns_||Blockly.FieldColour.COLUMNS,b=this.colours_||Blockly.FieldColour.COLOURS,c=this.titles_||Blockly.FieldColour.TITLES,d=this.getValue(),e=document.createElement("table");e.className="blocklyColourTable";for(var f,g=0;g<b.length;g++){0==g%a&&(f=document.createElement("tr"),e.appendChild(f));var h=document.createElement("td");f.appendChild(h);var k=document.createElement("div");h.appendChild(k);h.label=b[g];h.title=c[g]||b[g];
+k.style.backgroundColor=b[g];b[g]==d&&(k.className="blocklyColourSelected")}return e};Blockly.FieldColour.widgetDispose_=function(){Blockly.FieldColour.onUpWrapper_&&Blockly.unbindEvent_(Blockly.FieldColour.onUpWrapper_);Blockly.Events.setGroup(!1)};Blockly.Field.register("field_colour",Blockly.FieldColour);Blockly.FieldDropdown=function(a,b){"function"!=typeof a&&Blockly.FieldDropdown.validateOptions_(a);this.menuGenerator_=a;this.trimOptions_();var c=this.getOptions()[0];Blockly.FieldDropdown.superClass_.constructor.call(this,c[1],b)};goog.inherits(Blockly.FieldDropdown,Blockly.Field);Blockly.FieldDropdown.fromJson=function(a){return new Blockly.FieldDropdown(a.options)};Blockly.FieldDropdown.CHECKMARK_OVERHANG=25;Blockly.FieldDropdown.MAX_MENU_HEIGHT_VH=.45;
+Blockly.FieldDropdown.ARROW_CHAR=goog.userAgent.ANDROID?"\u25bc":"\u25be";Blockly.FieldDropdown.prototype.CURSOR="default";Blockly.FieldDropdown.prototype.value_="";Blockly.FieldDropdown.prototype.imageElement_=null;Blockly.FieldDropdown.prototype.imageJson_=null;
+Blockly.FieldDropdown.prototype.init=function(){this.fieldGroup_||(this.arrow_=Blockly.utils.createSvgElement("tspan",{},null),this.arrow_.appendChild(document.createTextNode(this.sourceBlock_.RTL?Blockly.FieldDropdown.ARROW_CHAR+" ":" "+Blockly.FieldDropdown.ARROW_CHAR)),Blockly.FieldDropdown.superClass_.init.call(this))};Blockly.FieldDropdown.prototype.showEditor_=function(){Blockly.WidgetDiv.show(this,this.sourceBlock_.RTL,null);var a=this.createMenu_();this.addActionListener_(a);this.positionMenu_(a)};
+Blockly.FieldDropdown.prototype.addActionListener_=function(a){var b=this;goog.events.listen(a,goog.ui.Component.EventType.ACTION,function(a){if(a=a.target)b.onItemSelected(this,a);Blockly.WidgetDiv.hideIfOwner(b);Blockly.Events.setGroup(!1)})};
+Blockly.FieldDropdown.prototype.createMenu_=function(){var a=new goog.ui.Menu;a.setRightToLeft(this.sourceBlock_.RTL);for(var b=this.getOptions(),c=0;c<b.length;c++){var d=b[c][0],e=b[c][1];if("object"==typeof d){var f=new Image(d.width,d.height);f.src=d.src;f.alt=d.alt||"";d=f}d=new goog.ui.MenuItem(d);d.setRightToLeft(this.sourceBlock_.RTL);d.setValue(e);d.setCheckable(!0);a.addChild(d,!0);d.setChecked(e==this.value_)}return a};
+Blockly.FieldDropdown.prototype.positionMenu_=function(a){var b=Blockly.utils.getViewportBBox(),c=this.getAnchorDimensions_();this.createWidget_(a);var d=Blockly.utils.uiMenu.getSize(a),e=Blockly.FieldDropdown.MAX_MENU_HEIGHT_VH*document.documentElement.clientHeight;d.height>e&&(d.height=e);this.sourceBlock_.RTL&&Blockly.utils.uiMenu.adjustBBoxesForRTL(b,c,d);Blockly.WidgetDiv.positionWithAnchor(b,c,d,this.sourceBlock_.RTL);a.getElement().focus()};
+Blockly.FieldDropdown.prototype.createWidget_=function(a){a.render(Blockly.WidgetDiv.DIV);Blockly.utils.addClass(a.getElement(),"blocklyDropdownMenu");a.setAllowAutoFocus(!0)};Blockly.FieldDropdown.prototype.getAnchorDimensions_=function(){var a=this.getScaledBBox_();this.sourceBlock_.RTL?a.right+=Blockly.FieldDropdown.CHECKMARK_OVERHANG:a.left-=Blockly.FieldDropdown.CHECKMARK_OVERHANG;return a};
+Blockly.FieldDropdown.prototype.onItemSelected=function(a,b){var c=b.getValue();this.sourceBlock_&&(c=this.callValidator(c));null!==c&&this.setValue(c)};
+Blockly.FieldDropdown.prototype.trimOptions_=function(){this.suffixField=this.prefixField=null;var a=this.menuGenerator_;if(Array.isArray(a)){for(var b=!1,c=0;c<a.length;c++){var d=a[c][0];"string"==typeof d?a[c][0]=Blockly.utils.replaceMessageReferences(d):(null!=d.alt&&(a[c][0].alt=Blockly.utils.replaceMessageReferences(d.alt)),b=!0)}if(!(b||2>a.length)){b=[];for(c=0;c<a.length;c++)b.push(a[c][0]);c=Blockly.utils.shortestStringLength(b);d=Blockly.utils.commonWordPrefix(b,c);var e=Blockly.utils.commonWordSuffix(b,
+c);!d&&!e||c<=d+e||(d&&(this.prefixField=b[0].substring(0,d-1)),e&&(this.suffixField=b[0].substr(1-e)),this.menuGenerator_=Blockly.FieldDropdown.applyTrim_(a,d,e))}}};Blockly.FieldDropdown.applyTrim_=function(a,b,c){for(var d=[],e=0;e<a.length;e++){var f=a[e][0],g=a[e][1];f=f.substring(b,f.length-c);d[e]=[f,g]}return d};Blockly.FieldDropdown.prototype.isOptionListDynamic=function(){return"function"==typeof this.menuGenerator_};
+Blockly.FieldDropdown.prototype.getOptions=function(){if(this.isOptionListDynamic()){var a=this.menuGenerator_.call(this);Blockly.FieldDropdown.validateOptions_(a);return a}return this.menuGenerator_};Blockly.FieldDropdown.prototype.getValue=function(){return this.value_};
+Blockly.FieldDropdown.prototype.setValue=function(a){if(null!==a&&a!==this.value_){this.sourceBlock_&&Blockly.Events.isEnabled()&&Blockly.Events.fire(new Blockly.Events.BlockChange(this.sourceBlock_,"field",this.name,this.value_,a));this.value_=a;for(var b=this.getOptions(),c=0;c<b.length;c++)if(b[c][1]==a){a=b[c][0];"object"==typeof a?(this.imageJson_=a,this.text_=a.alt):(this.imageJson_=null,this.text_=a);this.forceRerender();return}this.text_=a;this.forceRerender()}};
+Blockly.FieldDropdown.prototype.render_=function(){if(this.visible_){this.sourceBlock_&&this.arrow_&&(this.arrow_.style.fill=this.sourceBlock_.getColour());for(var a;a=this.textElement_.firstChild;)this.textElement_.removeChild(a);this.imageElement_&&(Blockly.utils.removeNode(this.imageElement_),this.imageElement_=null);this.imageJson_?this.renderSelectedImage_():this.renderSelectedText_();this.borderRect_.setAttribute("height",this.size_.height-9);this.borderRect_.setAttribute("width",this.size_.width+
+Blockly.BlockSvg.SEP_SPACE_X)}else this.size_.width=0};
+Blockly.FieldDropdown.prototype.renderSelectedImage_=function(){this.imageElement_=Blockly.utils.createSvgElement("image",{y:5,height:this.imageJson_.height+"px",width:this.imageJson_.width+"px"},this.fieldGroup_);this.imageElement_.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",this.imageJson_.src);this.textElement_.appendChild(this.arrow_);var a=Blockly.Field.getCachedWidth(this.arrow_);this.size_.height=Number(this.imageJson_.height)+19;this.size_.width=Number(this.imageJson_.width)+
+a;this.sourceBlock_.RTL?(this.imageElement_.setAttribute("x",a),this.textElement_.setAttribute("x",-1)):(this.textElement_.setAttribute("text-anchor","end"),this.textElement_.setAttribute("x",this.size_.width+1))};
+Blockly.FieldDropdown.prototype.renderSelectedText_=function(){var a=document.createTextNode(this.getDisplayText_());this.textElement_.appendChild(a);this.sourceBlock_.RTL?this.textElement_.insertBefore(this.arrow_,this.textElement_.firstChild):this.textElement_.appendChild(this.arrow_);this.textElement_.setAttribute("text-anchor","start");this.textElement_.setAttribute("x",0);this.size_.height=Blockly.BlockSvg.MIN_BLOCK_Y;this.size_.width=Blockly.Field.getCachedWidth(this.textElement_)};
+Blockly.FieldDropdown.prototype.updateWidth=function(){if(this.imageJson_&&(goog.userAgent.IE||goog.userAgent.EDGE)){var a=Blockly.Field.getCachedWidth(this.arrow_);a=Number(this.imageJson_.width)+a+Blockly.BlockSvg.SEP_SPACE_X;this.borderRect_&&this.borderRect_.setAttribute("width",a);this.size_.width=a}else Blockly.Field.prototype.updateWidth.call(this)};Blockly.FieldDropdown.prototype.dispose=function(){Blockly.WidgetDiv.hideIfOwner(this);Blockly.FieldDropdown.superClass_.dispose.call(this)};
+Blockly.FieldDropdown.validateOptions_=function(a){if(!Array.isArray(a))throw TypeError("FieldDropdown options must be an array.");for(var b=!1,c=0;c<a.length;++c){var d=a[c];Array.isArray(d)?"string"!=typeof d[1]?(b=!0,console.error("Invalid option["+c+"]: Each FieldDropdown option id must be a string. Found "+d[1]+" in: ",d)):"string"!=typeof d[0]&&"string"!=typeof d[0].src&&(b=!0,console.error("Invalid option["+c+"]: Each FieldDropdown option must have a string label or image description. Found"+
+d[0]+" in: ",d)):(b=!0,console.error("Invalid option["+c+"]: Each FieldDropdown option must be an array. Found: ",d))}if(b)throw TypeError("Found invalid FieldDropdown options.");};Blockly.Field.register("field_dropdown",Blockly.FieldDropdown);Blockly.FieldImage=function(a,b,c,d,e,f){this.sourceBlock_=null;this.height_=Number(c);this.width_=Number(b);this.size_=new goog.math.Size(this.width_,this.height_+2*Blockly.BlockSvg.INLINE_PADDING_Y);this.flipRtl_=f;this.tooltip_="";this.setValue(a);this.setText(d);"function"==typeof e&&(this.clickHandler_=e)};goog.inherits(Blockly.FieldImage,Blockly.Field);
+Blockly.FieldImage.fromJson=function(a){var b=Blockly.utils.replaceMessageReferences(a.src),c=Number(Blockly.utils.replaceMessageReferences(a.width)),d=Number(Blockly.utils.replaceMessageReferences(a.height)),e=Blockly.utils.replaceMessageReferences(a.alt);return new Blockly.FieldImage(b,c,d,e,null,!!a.flipRtl)};Blockly.FieldImage.prototype.EDITABLE=!1;
+Blockly.FieldImage.prototype.init=function(){this.fieldGroup_||(this.fieldGroup_=Blockly.utils.createSvgElement("g",{},null),this.visible_||(this.fieldGroup_.style.display="none"),this.imageElement_=Blockly.utils.createSvgElement("image",{height:this.height_+"px",width:this.width_+"px"},this.fieldGroup_),this.setValue(this.src_),this.setText(this.text_),this.sourceBlock_.getSvgRoot().appendChild(this.fieldGroup_),this.tooltip_?this.imageElement_.tooltip=this.tooltip_:this.setTooltip(this.sourceBlock_),
+Blockly.Tooltip.bindMouseEvents(this.imageElement_),this.maybeAddClickHandler_())};Blockly.FieldImage.prototype.dispose=function(){this.fieldGroup_&&(Blockly.utils.removeNode(this.fieldGroup_),this.fieldGroup_=null);this.imageElement_=null};Blockly.FieldImage.prototype.maybeAddClickHandler_=function(){this.clickHandler_&&(this.mouseDownWrapper_=Blockly.bindEventWithChecks_(this.fieldGroup_,"mousedown",this,this.clickHandler_))};
+Blockly.FieldImage.prototype.setTooltip=function(a){this.tooltip_=a;this.imageElement_&&(this.imageElement_.tooltip=a)};Blockly.FieldImage.prototype.getValue=function(){return this.src_};Blockly.FieldImage.prototype.setValue=function(a){null!==a&&(this.src_=a,this.imageElement_&&this.imageElement_.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",a||""))};Blockly.FieldImage.prototype.getFlipRtl=function(){return this.flipRtl_};
+Blockly.FieldImage.prototype.setText=function(a){null!==a&&(this.text_=a,this.imageElement_&&this.imageElement_.setAttribute("alt",a||""))};Blockly.FieldImage.prototype.render_=function(){};Blockly.FieldImage.prototype.forceRerender=function(){};Blockly.FieldImage.prototype.updateWidth=function(){};Blockly.FieldImage.prototype.showEditor_=function(){this.clickHandler_&&this.clickHandler_(this)};Blockly.Field.register("field_image",Blockly.FieldImage);Blockly.FieldNumber=function(a,b,c,d,e){a=a&&!isNaN(a)?String(a):"0";Blockly.FieldNumber.superClass_.constructor.call(this,a,e);this.setConstraints(b,c,d)};goog.inherits(Blockly.FieldNumber,Blockly.FieldTextInput);Blockly.FieldNumber.fromJson=function(a){return new Blockly.FieldNumber(a.value,a.min,a.max,a.precision)};
+Blockly.FieldNumber.prototype.setConstraints=function(a,b,c){c=parseFloat(c);this.precision_=isNaN(c)?0:c;a=parseFloat(a);this.min_=isNaN(a)?-Infinity:a;b=parseFloat(b);this.max_=isNaN(b)?Infinity:b;this.setValue(this.callValidator(this.getValue()))};
+Blockly.FieldNumber.prototype.classValidator=function(a){if(null===a)return null;a=String(a);a=a.replace(/O/ig,"0");a=a.replace(/,/g,"");a=parseFloat(a||0);if(isNaN(a))return null;this.precision_&&isFinite(a)&&(a=Math.round(a/this.precision_)*this.precision_);a=Math.min(Math.max(a,this.min_),this.max_);return String(a)};Blockly.Field.register("field_number",Blockly.FieldNumber);Blockly.FieldVariable=function(a,b,c,d){this.menuGenerator_=Blockly.FieldVariable.dropdownCreate;this.size_=new goog.math.Size(0,Blockly.BlockSvg.MIN_BLOCK_Y);this.setValidator(b);this.defaultVariableName=a||"";this.setTypes_(c,d);this.value_=null};goog.inherits(Blockly.FieldVariable,Blockly.FieldDropdown);Blockly.FieldVariable.fromJson=function(a){var b=Blockly.utils.replaceMessageReferences(a.variable);return new Blockly.FieldVariable(b,null,a.variableTypes,a.defaultType)};
+Blockly.FieldVariable.prototype.init=function(){this.fieldGroup_||(Blockly.FieldVariable.superClass_.init.call(this),this.initModel())};Blockly.FieldVariable.prototype.initModel=function(){if(!this.variable_){this.workspace_=this.sourceBlock_.workspace;var a=Blockly.Variables.getOrCreateVariablePackage(this.workspace_,null,this.defaultVariableName,this.defaultType_);Blockly.Events.disable();try{this.setValue(a.getId())}finally{Blockly.Events.enable()}}};
+Blockly.FieldVariable.prototype.dispose=function(){Blockly.FieldVariable.superClass_.dispose.call(this);this.variableMap_=this.workspace_=null};Blockly.FieldVariable.prototype.setSourceBlock=function(a){if(a.isShadow())throw Error("Variable fields are not allowed to exist on shadow blocks.");Blockly.FieldVariable.superClass_.setSourceBlock.call(this,a)};Blockly.FieldVariable.prototype.getValue=function(){return this.variable_?this.variable_.getId():null};
+Blockly.FieldVariable.prototype.getText=function(){return this.variable_?this.variable_.name:""};Blockly.FieldVariable.prototype.getVariable=function(){return this.variable_};
+Blockly.FieldVariable.prototype.setValue=function(a){var b=Blockly.Variables.getVariable(this.sourceBlock_.workspace,a);if(!b)throw Error("Variable id doesn't point to a real variable!  ID was "+a);var c=b.type;if(!this.typeIsAllowed_(c))throw Error("Variable type doesn't match this field!  Type was "+c);this.sourceBlock_&&Blockly.Events.isEnabled()&&(c=this.variable_?this.variable_.getId():null,Blockly.Events.fire(new Blockly.Events.BlockChange(this.sourceBlock_,"field",this.name,c,a)));this.variable_=
+b;this.value_=a;this.setText(b.name)};Blockly.FieldVariable.prototype.typeIsAllowed_=function(a){var b=this.getVariableTypes_();if(!b)return!0;for(var c=0;c<b.length;c++)if(a==b[c])return!0;return!1};Blockly.FieldVariable.prototype.getVariableTypes_=function(){var a=this.variableTypes;if(null===a&&this.sourceBlock_)return this.sourceBlock_.workspace.getVariableTypes();a=a||[""];if(0==a.length)throw a=this.getText(),Error("'variableTypes' of field variable "+a+" was an empty list");return a};
+Blockly.FieldVariable.prototype.setTypes_=function(a,b){var c=b||"";if(null==a||void 0==a)var d=null;else if(Array.isArray(a)){d=a;for(var e=!1,f=0;f<d.length;f++)d[f]==c&&(e=!0);if(!e)throw Error("Invalid default type '"+c+"' in the definition of a FieldVariable");}else throw Error("'variableTypes' was not an array in the definition of a FieldVariable");this.defaultType_=c;this.variableTypes=d};
+Blockly.FieldVariable.dropdownCreate=function(){if(!this.variable_)throw Error("Tried to call dropdownCreate on a variable field with no variable selected.");var a=this.getText(),b=null;this.sourceBlock_&&(b=this.sourceBlock_.workspace);var c=[];if(b)for(var d=this.getVariableTypes_(),e=0;e<d.length;e++){var f=b.getVariablesOfType(d[e]);c=c.concat(f)}c.sort(Blockly.VariableModel.compareByName);b=[];for(e=0;e<c.length;e++)b[e]=[c[e].name,c[e].getId()];b.push([Blockly.Msg.RENAME_VARIABLE,Blockly.RENAME_VARIABLE_ID]);
+Blockly.Msg.DELETE_VARIABLE&&b.push([Blockly.Msg.DELETE_VARIABLE.replace("%1",a),Blockly.DELETE_VARIABLE_ID]);return b};Blockly.FieldVariable.prototype.onItemSelected=function(a,b){var c=b.getValue();if(this.sourceBlock_&&this.sourceBlock_.workspace){var d=this.sourceBlock_.workspace;if(c==Blockly.RENAME_VARIABLE_ID){Blockly.Variables.renameVariable(d,this.variable_);return}if(c==Blockly.DELETE_VARIABLE_ID){d.deleteVariableById(this.variable_.getId());return}}this.setValue(c)};
+Blockly.FieldVariable.prototype.referencesVariables=function(){return!0};Blockly.Field.register("field_variable",Blockly.FieldVariable);Blockly.Generator=function(a){this.name_=a;this.FUNCTION_NAME_PLACEHOLDER_REGEXP_=new RegExp(this.FUNCTION_NAME_PLACEHOLDER_,"g")};Blockly.Generator.NAME_TYPE="generated_function";Blockly.Generator.prototype.INFINITE_LOOP_TRAP=null;Blockly.Generator.prototype.STATEMENT_PREFIX=null;Blockly.Generator.prototype.INDENT="  ";Blockly.Generator.prototype.COMMENT_WRAP=60;Blockly.Generator.prototype.ORDER_OVERRIDES=[];
+Blockly.Generator.prototype.workspaceToCode=function(a){a||(console.warn("No workspace specified in workspaceToCode call.  Guessing."),a=Blockly.getMainWorkspace());var b=[];this.init(a);a=a.getTopBlocks(!0);for(var c=0,d;d=a[c];c++){var e=this.blockToCode(d);Array.isArray(e)&&(e=e[0]);e&&(d.outputConnection&&(e=this.scrubNakedValue(e)),b.push(e))}b=b.join("\n");b=this.finish(b);b=b.replace(/^\s+\n/,"");b=b.replace(/\n\s+$/,"\n");return b=b.replace(/[ \t]+\n/g,"\n")};
+Blockly.Generator.prototype.prefixLines=function(a,b){return b+a.replace(/(?!\n$)\n/g,"\n"+b)};Blockly.Generator.prototype.allNestedComments=function(a){var b=[];a=a.getDescendants(!0);for(var c=0;c<a.length;c++){var d=a[c].getCommentText();d&&b.push(d)}b.length&&b.push("");return b.join("\n")};
+Blockly.Generator.prototype.blockToCode=function(a,b){if(!a)return"";if(a.disabled)return b?"":this.blockToCode(a.getNextBlock());var c=this[a.type];if("function"!=typeof c)throw Error('Language "'+this.name_+'" does not know how to generate  code for block type "'+a.type+'".');c=c.call(a,a);if(Array.isArray(c)){if(!a.outputConnection)throw TypeError("Expecting string from statement block: "+a.type);return[this.scrub_(a,c[0],b),c[1]]}if("string"==typeof c){var d=a.id.replace(/\$/g,"$$$$");this.STATEMENT_PREFIX&&
+(c=this.STATEMENT_PREFIX.replace(/%1/g,"'"+d+"'")+c);return this.scrub_(a,c,b)}if(null===c)return"";throw SyntaxError("Invalid code generated: "+c);};
+Blockly.Generator.prototype.valueToCode=function(a,b,c){if(isNaN(c))throw TypeError("Expecting valid order from block: "+a.type);var d=a.getInputTargetBlock(b);if(!d)return"";b=this.blockToCode(d);if(""===b)return"";if(!Array.isArray(b))throw TypeError("Expecting tuple from value block: "+d.type);a=b[0];b=b[1];if(isNaN(b))throw TypeError("Expecting valid order from value block: "+d.type);if(!a)return"";d=!1;var e=Math.floor(c),f=Math.floor(b);if(e<=f&&(e!=f||0!=e&&99!=e))for(d=!0,e=0;e<this.ORDER_OVERRIDES.length;e++)if(this.ORDER_OVERRIDES[e][0]==
+c&&this.ORDER_OVERRIDES[e][1]==b){d=!1;break}d&&(a="("+a+")");return a};Blockly.Generator.prototype.statementToCode=function(a,b){var c=a.getInputTargetBlock(b),d=this.blockToCode(c);if("string"!=typeof d)throw TypeError("Expecting code from statement block: "+(c&&c.type));d&&(d=this.prefixLines(d,this.INDENT));return d};
+Blockly.Generator.prototype.addLoopTrap=function(a,b){b=b.replace(/\$/g,"$$$$");this.INFINITE_LOOP_TRAP&&(a=this.INFINITE_LOOP_TRAP.replace(/%1/g,"'"+b+"'")+a);this.STATEMENT_PREFIX&&(a+=this.prefixLines(this.STATEMENT_PREFIX.replace(/%1/g,"'"+b+"'"),this.INDENT));return a};Blockly.Generator.prototype.RESERVED_WORDS_="";Blockly.Generator.prototype.addReservedWords=function(a){this.RESERVED_WORDS_+=a+","};Blockly.Generator.prototype.FUNCTION_NAME_PLACEHOLDER_="{leCUI8hutHZI4480Dc}";
+Blockly.Generator.prototype.provideFunction_=function(a,b){if(!this.definitions_[a]){var c=this.variableDB_.getDistinctName(a,Blockly.Procedures.NAME_TYPE);this.functionNames_[a]=c;c=b.join("\n").replace(this.FUNCTION_NAME_PLACEHOLDER_REGEXP_,c);for(var d;d!=c;)d=c,c=c.replace(/^(( {2})*) {2}/gm,"$1\x00");c=c.replace(/\0/g,this.INDENT);this.definitions_[a]=c}return this.functionNames_[a]};Blockly.Generator.prototype.init=function(a){};Blockly.Generator.prototype.scrub_=function(a,b){return b};
+Blockly.Generator.prototype.finish=function(a){return a};Blockly.Generator.prototype.scrubNakedValue=function(a){return a};Blockly.Names=function(a,b){this.variablePrefix_=b||"";this.reservedDict_=Object.create(null);if(a)for(var c=a.split(","),d=0;d<c.length;d++)this.reservedDict_[c[d]]=!0;this.reset()};Blockly.Names.DEVELOPER_VARIABLE_TYPE="DEVELOPER_VARIABLE";Blockly.Names.prototype.reset=function(){this.db_=Object.create(null);this.dbReverse_=Object.create(null);this.variableMap_=null};Blockly.Names.prototype.setVariableMap=function(a){this.variableMap_=a};
+Blockly.Names.prototype.getNameForUserVariable_=function(a){return this.variableMap_?(a=this.variableMap_.getVariableById(a))?a.name:null:(console.log("Deprecated call to Blockly.Names.prototype.getName without defining a variable map. To fix, add the folowing code in your generator's init() function:\nBlockly.YourGeneratorName.variableDB_.setVariableMap(workspace.getVariableMap());"),null)};
+Blockly.Names.prototype.getName=function(a,b){if(b==Blockly.Variables.NAME_TYPE){var c=this.getNameForUserVariable_(a);c&&(a=c)}c=a.toLowerCase()+"_"+b;var d=b==Blockly.Variables.NAME_TYPE||b==Blockly.Names.DEVELOPER_VARIABLE_TYPE?this.variablePrefix_:"";if(c in this.db_)return d+this.db_[c];var e=this.getDistinctName(a,b);this.db_[c]=e.substr(d.length);return e};
+Blockly.Names.prototype.getDistinctName=function(a,b){for(var c=this.safeName_(a),d="";this.dbReverse_[c+d]||c+d in this.reservedDict_;)d=d?d+1:2;c+=d;this.dbReverse_[c]=!0;return(b==Blockly.Variables.NAME_TYPE||b==Blockly.Names.DEVELOPER_VARIABLE_TYPE?this.variablePrefix_:"")+c};Blockly.Names.prototype.safeName_=function(a){a?(a=encodeURI(a.replace(/ /g,"_")).replace(/[^\w]/g,"_"),-1!="0123456789".indexOf(a[0])&&(a="my_"+a)):a="unnamed";return a};
+Blockly.Names.equals=function(a,b){return a.toLowerCase()==b.toLowerCase()};Blockly.Procedures={};Blockly.Procedures.NAME_TYPE=Blockly.PROCEDURE_CATEGORY_NAME;Blockly.Procedures.allProcedures=function(a){a=a.getAllBlocks(!1);for(var b=[],c=[],d=0;d<a.length;d++)if(a[d].getProcedureDef){var e=a[d].getProcedureDef();e&&(e[2]?b.push(e):c.push(e))}c.sort(Blockly.Procedures.procTupleComparator_);b.sort(Blockly.Procedures.procTupleComparator_);return[c,b]};Blockly.Procedures.procTupleComparator_=function(a,b){return a[0].toLowerCase().localeCompare(b[0].toLowerCase())};
+Blockly.Procedures.findLegalName=function(a,b){if(b.isInFlyout)return a;for(;!Blockly.Procedures.isLegalName_(a,b.workspace,b);){var c=a.match(/^(.*?)(\d+)$/);a=c?c[1]+(parseInt(c[2],10)+1):a+"2"}return a};Blockly.Procedures.isLegalName_=function(a,b,c){return!Blockly.Procedures.isNameUsed(a,b,c)};Blockly.Procedures.isNameUsed=function(a,b,c){b=b.getAllBlocks(!1);for(var d=0;d<b.length;d++)if(b[d]!=c&&b[d].getProcedureDef){var e=b[d].getProcedureDef();if(Blockly.Names.equals(e[0],a))return!0}return!1};
+Blockly.Procedures.rename=function(a){a=a.replace(/^[\s\xa0]+|[\s\xa0]+$/g,"");var b=Blockly.Procedures.findLegalName(a,this.sourceBlock_),c=this.text_;if(c!=a&&c!=b){a=this.sourceBlock_.workspace.getAllBlocks(!1);for(var d=0;d<a.length;d++)a[d].renameProcedure&&a[d].renameProcedure(c,b)}return b};
+Blockly.Procedures.flyoutCategory=function(a){function b(a,b){for(var d=0;d<a.length;d++){var e=a[d][0],f=a[d][1],g=Blockly.Xml.utils.createElement("block");g.setAttribute("type",b);g.setAttribute("gap",16);var m=Blockly.Xml.utils.createElement("mutation");m.setAttribute("name",e);g.appendChild(m);for(e=0;e<f.length;e++){var p=Blockly.Xml.utils.createElement("arg");p.setAttribute("name",f[e]);m.appendChild(p)}c.push(g)}}var c=[];if(Blockly.Blocks.procedures_defnoreturn){var d=Blockly.Xml.utils.createElement("block");
+d.setAttribute("type","procedures_defnoreturn");d.setAttribute("gap",16);var e=Blockly.Xml.utils.createElement("field");e.setAttribute("name","NAME");e.appendChild(Blockly.Xml.utils.createTextNode(Blockly.Msg.PROCEDURES_DEFNORETURN_PROCEDURE));d.appendChild(e);c.push(d)}Blockly.Blocks.procedures_defreturn&&(d=Blockly.Xml.utils.createElement("block"),d.setAttribute("type","procedures_defreturn"),d.setAttribute("gap",16),e=Blockly.Xml.utils.createElement("field"),e.setAttribute("name","NAME"),e.appendChild(Blockly.Xml.utils.createTextNode(Blockly.Msg.PROCEDURES_DEFRETURN_PROCEDURE)),
+d.appendChild(e),c.push(d));Blockly.Blocks.procedures_ifreturn&&(d=Blockly.Xml.utils.createElement("block"),d.setAttribute("type","procedures_ifreturn"),d.setAttribute("gap",16),c.push(d));c.length&&c[c.length-1].setAttribute("gap",24);a=Blockly.Procedures.allProcedures(a);b(a[0],"procedures_callnoreturn");b(a[1],"procedures_callreturn");return c};
+Blockly.Procedures.getCallers=function(a,b){for(var c=[],d=b.getAllBlocks(!1),e=0;e<d.length;e++)if(d[e].getProcedureCall){var f=d[e].getProcedureCall();f&&Blockly.Names.equals(f,a)&&c.push(d[e])}return c};
+Blockly.Procedures.mutateCallers=function(a){var b=Blockly.Events.recordUndo,c=a.getProcedureDef()[0],d=a.mutationToDom(!0);a=Blockly.Procedures.getCallers(c,a.workspace);c=0;for(var e;e=a[c];c++){var f=e.mutationToDom();f=f&&Blockly.Xml.domToText(f);e.domToMutation(d);var g=e.mutationToDom();g=g&&Blockly.Xml.domToText(g);f!=g&&(Blockly.Events.recordUndo=!1,Blockly.Events.fire(new Blockly.Events.BlockChange(e,"mutation",null,f,g)),Blockly.Events.recordUndo=b)}};
+Blockly.Procedures.getDefinition=function(a,b){for(var c=b.getTopBlocks(!1),d=0;d<c.length;d++)if(c[d].getProcedureDef){var e=c[d].getProcedureDef();if(e&&Blockly.Names.equals(e[0],a))return c[d]}return null};Blockly.FlyoutButton=function(a,b,c,d){this.workspace_=a;this.targetWorkspace_=b;this.text_=c.getAttribute("text");this.position_=new goog.math.Coordinate(0,0);this.isLabel_=d;this.callbackKey_=c.getAttribute("callbackKey");this.cssClass_=c.getAttribute("web-class")||null};Blockly.FlyoutButton.MARGIN=5;Blockly.FlyoutButton.prototype.width=0;Blockly.FlyoutButton.prototype.height=0;Blockly.FlyoutButton.prototype.onMouseUpWrapper_=null;
+Blockly.FlyoutButton.prototype.createDom=function(){var a=this.isLabel_?"blocklyFlyoutLabel":"blocklyFlyoutButton";this.cssClass_&&(a+=" "+this.cssClass_);this.svgGroup_=Blockly.utils.createSvgElement("g",{"class":a},this.workspace_.getCanvas());if(!this.isLabel_)var b=Blockly.utils.createSvgElement("rect",{"class":"blocklyFlyoutButtonShadow",rx:4,ry:4,x:1,y:1},this.svgGroup_);a=Blockly.utils.createSvgElement("rect",{"class":this.isLabel_?"blocklyFlyoutLabelBackground":"blocklyFlyoutButtonBackground",
+rx:4,ry:4},this.svgGroup_);var c=Blockly.utils.createSvgElement("text",{"class":this.isLabel_?"blocklyFlyoutLabelText":"blocklyText",x:0,y:0,"text-anchor":"middle"},this.svgGroup_);c.textContent=Blockly.utils.replaceMessageReferences(this.text_);this.width=Blockly.Field.getCachedWidth(c);this.height=20;this.isLabel_||(this.width+=2*Blockly.FlyoutButton.MARGIN,b.setAttribute("width",this.width),b.setAttribute("height",this.height));a.setAttribute("width",this.width);a.setAttribute("height",this.height);
+c.setAttribute("x",this.width/2);c.setAttribute("y",this.height-Blockly.FlyoutButton.MARGIN);this.updateTransform_();this.onMouseUpWrapper_=Blockly.bindEventWithChecks_(this.svgGroup_,"mouseup",this,this.onMouseUp_);return this.svgGroup_};Blockly.FlyoutButton.prototype.show=function(){this.updateTransform_();this.svgGroup_.setAttribute("display","block")};
+Blockly.FlyoutButton.prototype.updateTransform_=function(){this.svgGroup_.setAttribute("transform","translate("+this.position_.x+","+this.position_.y+")")};Blockly.FlyoutButton.prototype.moveTo=function(a,b){this.position_.x=a;this.position_.y=b;this.updateTransform_()};Blockly.FlyoutButton.prototype.getPosition=function(){return this.position_};Blockly.FlyoutButton.prototype.getTargetWorkspace=function(){return this.targetWorkspace_};
+Blockly.FlyoutButton.prototype.dispose=function(){this.onMouseUpWrapper_&&Blockly.unbindEvent_(this.onMouseUpWrapper_);this.svgGroup_&&(Blockly.utils.removeNode(this.svgGroup_),this.svgGroup_=null);this.targetWorkspace_=this.workspace_=null};
+Blockly.FlyoutButton.prototype.onMouseUp_=function(a){(a=this.targetWorkspace_.getGesture(a))&&a.cancel();this.isLabel_&&this.callbackKey_?console.warn("Labels should not have callbacks. Label text: "+this.text_):this.isLabel_||this.callbackKey_&&this.targetWorkspace_.getButtonCallback(this.callbackKey_)?this.isLabel_||this.targetWorkspace_.getButtonCallback(this.callbackKey_)(this):console.warn("Buttons should have callbacks. Button text: "+this.text_)};Blockly.Flyout=function(a){a.getMetrics=this.getMetrics_.bind(this);a.setMetrics=this.setMetrics_.bind(this);this.workspace_=new Blockly.WorkspaceSvg(a);this.workspace_.isFlyout=!0;this.RTL=!!a.RTL;this.toolboxPosition_=a.toolboxPosition;this.eventWrappers_=[];this.mats_=[];this.buttons_=[];this.listeners_=[];this.permanentlyDisabled_=[]};Blockly.Flyout.prototype.autoClose=!0;Blockly.Flyout.prototype.isVisible_=!1;Blockly.Flyout.prototype.containerVisible_=!0;
+Blockly.Flyout.prototype.CORNER_RADIUS=8;Blockly.Flyout.prototype.MARGIN=Blockly.Flyout.prototype.CORNER_RADIUS;Blockly.Flyout.prototype.GAP_X=3*Blockly.Flyout.prototype.MARGIN;Blockly.Flyout.prototype.GAP_Y=3*Blockly.Flyout.prototype.MARGIN;Blockly.Flyout.prototype.SCROLLBAR_PADDING=2;Blockly.Flyout.prototype.width_=0;Blockly.Flyout.prototype.height_=0;Blockly.Flyout.prototype.dragAngleRange_=70;
+Blockly.Flyout.prototype.createDom=function(a){this.svgGroup_=Blockly.utils.createSvgElement(a,{"class":"blocklyFlyout",style:"display: none"},null);this.svgBackground_=Blockly.utils.createSvgElement("path",{"class":"blocklyFlyoutBackground"},this.svgGroup_);this.svgGroup_.appendChild(this.workspace_.createDom());return this.svgGroup_};
+Blockly.Flyout.prototype.init=function(a){this.targetWorkspace_=a;this.workspace_.targetWorkspace=a;this.scrollbar_=new Blockly.Scrollbar(this.workspace_,this.horizontalLayout_,!1,"blocklyFlyoutScrollbar");this.hide();Array.prototype.push.apply(this.eventWrappers_,Blockly.bindEventWithChecks_(this.svgGroup_,"wheel",this,this.wheel_));this.autoClose||(this.filterWrapper_=this.filterForCapacity_.bind(this),this.targetWorkspace_.addChangeListener(this.filterWrapper_));Array.prototype.push.apply(this.eventWrappers_,
+Blockly.bindEventWithChecks_(this.svgBackground_,"mousedown",this,this.onMouseDown_));this.workspace_.getGesture=this.targetWorkspace_.getGesture.bind(this.targetWorkspace_);this.workspace_.variableMap_=this.targetWorkspace_.getVariableMap();this.workspace_.createPotentialVariableMap()};
+Blockly.Flyout.prototype.dispose=function(){this.hide();Blockly.unbindEvent_(this.eventWrappers_);this.filterWrapper_&&(this.targetWorkspace_.removeChangeListener(this.filterWrapper_),this.filterWrapper_=null);this.scrollbar_&&(this.scrollbar_.dispose(),this.scrollbar_=null);this.workspace_&&(this.workspace_.targetWorkspace=null,this.workspace_.dispose(),this.workspace_=null);this.svgGroup_&&(Blockly.utils.removeNode(this.svgGroup_),this.svgGroup_=null);this.targetWorkspace_=this.svgBackground_=null};
+Blockly.Flyout.prototype.getWidth=function(){return this.width_};Blockly.Flyout.prototype.getHeight=function(){return this.height_};Blockly.Flyout.prototype.getWorkspace=function(){return this.workspace_};Blockly.Flyout.prototype.isVisible=function(){return this.isVisible_};Blockly.Flyout.prototype.setVisible=function(a){var b=a!=this.isVisible();this.isVisible_=a;b&&this.updateDisplay_()};
+Blockly.Flyout.prototype.setContainerVisible=function(a){var b=a!=this.containerVisible_;this.containerVisible_=a;b&&this.updateDisplay_()};Blockly.Flyout.prototype.updateDisplay_=function(){var a=this.containerVisible_?this.isVisible():!1;this.svgGroup_.style.display=a?"block":"none";this.scrollbar_.setContainerVisible(a)};
+Blockly.Flyout.prototype.positionAt_=function(a,b,c,d){this.svgGroup_.setAttribute("width",a);this.svgGroup_.setAttribute("height",b);"svg"==this.svgGroup_.tagName?Blockly.utils.setCssTransform(this.svgGroup_,"translate("+c+"px,"+d+"px)"):this.svgGroup_.setAttribute("transform","translate("+c+","+d+")");this.scrollbar_&&(this.scrollbar_.setOrigin(c,d),this.scrollbar_.resize(),this.scrollbar_.setPosition_(this.scrollbar_.position_.x,this.scrollbar_.position_.y))};
+Blockly.Flyout.prototype.hide=function(){if(this.isVisible()){this.setVisible(!1);for(var a=0,b;b=this.listeners_[a];a++)Blockly.unbindEvent_(b);this.listeners_.length=0;this.reflowWrapper_&&(this.workspace_.removeChangeListener(this.reflowWrapper_),this.reflowWrapper_=null)}};
+Blockly.Flyout.prototype.show=function(a){this.workspace_.setResizesEnabled(!1);this.hide();this.clearOldBlocks_();if("string"==typeof a){a=this.workspace_.targetWorkspace.getToolboxCategoryCallback(a);if("function"!=typeof a)throw TypeError("Couldn't find a callback function when opening a toolbox category.");a=a(this.workspace_.targetWorkspace);if(!Array.isArray(a))throw TypeError("Result of toolbox category callback must be an array.");}this.setVisible(!0);for(var b=[],c=[],d=this.permanentlyDisabled_.length=
+0,e;e=a[d];d++)if(e.tagName){var f=e.tagName.toUpperCase(),g=this.horizontalLayout_?this.GAP_X:this.GAP_Y;if("BLOCK"==f)f=Blockly.Xml.domToBlock(e,this.workspace_),f.disabled&&this.permanentlyDisabled_.push(f),b.push({type:"block",block:f}),e=parseInt(e.getAttribute("gap"),10),c.push(isNaN(e)?g:e);else if("SEP"==e.tagName.toUpperCase())e=parseInt(e.getAttribute("gap"),10),!isNaN(e)&&0<c.length?c[c.length-1]=e:c.push(g);else if("BUTTON"==f||"LABEL"==f)e=new Blockly.FlyoutButton(this.workspace_,this.targetWorkspace_,
+e,"LABEL"==f),b.push({type:"button",button:e}),c.push(g)}this.layout_(b,c);this.listeners_.push(Blockly.bindEventWithChecks_(this.svgBackground_,"mouseover",this,function(){for(var a=this.workspace_.getTopBlocks(!1),b=0,c;c=a[b];b++)c.removeSelect()}));this.horizontalLayout_?this.height_=0:this.width_=0;this.workspace_.setResizesEnabled(!0);this.reflow();this.filterForCapacity_();this.position();this.reflowWrapper_=this.reflow.bind(this);this.workspace_.addChangeListener(this.reflowWrapper_)};
+Blockly.Flyout.prototype.clearOldBlocks_=function(){for(var a=this.workspace_.getTopBlocks(!1),b=0,c;c=a[b];b++)c.workspace==this.workspace_&&c.dispose(!1,!1);for(b=0;b<this.mats_.length;b++)(a=this.mats_[b])&&Blockly.utils.removeNode(a);for(b=this.mats_.length=0;a=this.buttons_[b];b++)a.dispose();this.buttons_.length=0;this.workspace_.getPotentialVariableMap().clear()};
+Blockly.Flyout.prototype.addBlockListeners_=function(a,b,c){this.listeners_.push(Blockly.bindEventWithChecks_(a,"mousedown",null,this.blockMouseDown_(b)));this.listeners_.push(Blockly.bindEventWithChecks_(c,"mousedown",null,this.blockMouseDown_(b)));this.listeners_.push(Blockly.bindEvent_(a,"mouseover",b,b.addSelect));this.listeners_.push(Blockly.bindEvent_(a,"mouseout",b,b.removeSelect));this.listeners_.push(Blockly.bindEvent_(c,"mouseover",b,b.addSelect));this.listeners_.push(Blockly.bindEvent_(c,
+"mouseout",b,b.removeSelect))};Blockly.Flyout.prototype.blockMouseDown_=function(a){var b=this;return function(c){var d=b.targetWorkspace_.getGesture(c);d&&(d.setStartBlock(a),d.handleFlyoutStart(c,b))}};Blockly.Flyout.prototype.onMouseDown_=function(a){var b=this.targetWorkspace_.getGesture(a);b&&b.handleFlyoutStart(a,this)};Blockly.Flyout.prototype.isBlockCreatable_=function(a){return!a.disabled};
+Blockly.Flyout.prototype.createBlock=function(a){var b=null;Blockly.Events.disable();var c=this.targetWorkspace_.getAllVariables();this.targetWorkspace_.setResizesEnabled(!1);try{b=this.placeNewBlock_(a),Blockly.hideChaff()}finally{Blockly.Events.enable()}a=Blockly.Variables.getAddedVariables(this.targetWorkspace_,c);if(Blockly.Events.isEnabled())for(Blockly.Events.setGroup(!0),Blockly.Events.fire(new Blockly.Events.Create(b)),c=0;c<a.length;c++)Blockly.Events.fire(new Blockly.Events.VarCreate(a[c]));
+this.autoClose?this.hide():this.filterForCapacity_();return b};Blockly.Flyout.prototype.initFlyoutButton_=function(a,b,c){var d=a.createDom();a.moveTo(b,c);a.show();this.listeners_.push(Blockly.bindEventWithChecks_(d,"mousedown",this,this.onMouseDown_));this.buttons_.push(a)};
+Blockly.Flyout.prototype.createRect_=function(a,b,c,d,e){b=Blockly.utils.createSvgElement("rect",{"fill-opacity":0,x:b,y:c,height:d.height,width:d.width},null);b.tooltip=a;Blockly.Tooltip.bindMouseEvents(b);this.workspace_.getCanvas().insertBefore(b,a.getSvgRoot());a.flyoutRect_=b;return this.mats_[e]=b};
+Blockly.Flyout.prototype.moveRectToBlock_=function(a,b){var c=b.getHeightWidth();a.setAttribute("width",c.width);a.setAttribute("height",c.height);var d=b.startHat_?Blockly.BlockSvg.START_HAT_HEIGHT:0;d&&b.moveBy(0,d);d=b.outputConnection?Blockly.BlockSvg.TAB_WIDTH:0;var e=b.getRelativeToSurfaceXY();a.setAttribute("y",e.y);a.setAttribute("x",this.RTL?e.x-c.width+d:e.x-d)};
+Blockly.Flyout.prototype.filterForCapacity_=function(){for(var a=this.workspace_.getTopBlocks(!1),b=0,c;c=a[b];b++)if(-1==this.permanentlyDisabled_.indexOf(c))for(var d=!this.targetWorkspace_.isCapacityAvailable(Blockly.utils.getBlockTypeCounts(c));c;)c.setDisabled(d),c=c.getNextBlock()};Blockly.Flyout.prototype.reflow=function(){this.reflowWrapper_&&this.workspace_.removeChangeListener(this.reflowWrapper_);this.reflowInternal_();this.reflowWrapper_&&this.workspace_.addChangeListener(this.reflowWrapper_)};
+Blockly.Flyout.prototype.isScrollable=function(){return this.scrollbar_?this.scrollbar_.isVisible():!1};
+Blockly.Flyout.prototype.placeNewBlock_=function(a){var b=this.targetWorkspace_;if(!a.getSvgRoot())throw Error("oldBlock is not rendered.");var c=Blockly.Xml.blockToDom(a);b.setResizesEnabled(!1);c=Blockly.Xml.domToBlock(c,b);if(!c.getSvgRoot())throw Error("block is not rendered.");var d=b.getOriginOffsetInPixels(),e=this.workspace_.getOriginOffsetInPixels();a=a.getRelativeToSurfaceXY().scale(this.workspace_.scale);a=goog.math.Coordinate.sum(e,a);b=goog.math.Coordinate.difference(a,d).scale(1/b.scale);
+c.moveBy(b.x,b.y);return c};Blockly.HorizontalFlyout=function(a){a.getMetrics=this.getMetrics_.bind(this);a.setMetrics=this.setMetrics_.bind(this);Blockly.HorizontalFlyout.superClass_.constructor.call(this,a);this.horizontalLayout_=!0};goog.inherits(Blockly.HorizontalFlyout,Blockly.Flyout);
+Blockly.HorizontalFlyout.prototype.getMetrics_=function(){if(!this.isVisible())return null;try{var a=this.workspace_.getCanvas().getBBox()}catch(e){a={height:0,y:0,width:0,x:0}}var b=this.SCROLLBAR_PADDING,c=this.SCROLLBAR_PADDING;this.toolboxPosition_==Blockly.TOOLBOX_AT_BOTTOM&&(b=0);var d=this.height_;this.toolboxPosition_==Blockly.TOOLBOX_AT_TOP&&(d-=this.SCROLLBAR_PADDING);return{viewHeight:d,viewWidth:this.width_-2*this.SCROLLBAR_PADDING,contentHeight:(a.height+2*this.MARGIN)*this.workspace_.scale,
+contentWidth:(a.width+2*this.MARGIN)*this.workspace_.scale,viewTop:-this.workspace_.scrollY,viewLeft:-this.workspace_.scrollX,contentTop:0,contentLeft:0,absoluteTop:b,absoluteLeft:c}};Blockly.HorizontalFlyout.prototype.setMetrics_=function(a){var b=this.getMetrics_();b&&("number"==typeof a.x&&(this.workspace_.scrollX=-b.contentWidth*a.x),this.workspace_.translate(this.workspace_.scrollX+b.absoluteLeft,this.workspace_.scrollY+b.absoluteTop))};
+Blockly.HorizontalFlyout.prototype.position=function(){if(this.isVisible()){var a=this.targetWorkspace_.getMetrics();if(a){this.width_=a.viewWidth;this.setBackgroundPath_(a.viewWidth-2*this.CORNER_RADIUS,this.height_-this.CORNER_RADIUS);var b=a.absoluteLeft,c=a.absoluteTop;this.toolboxPosition_==Blockly.TOOLBOX_AT_BOTTOM&&(c+=a.viewHeight-this.height_);this.positionAt_(this.width_,this.height_,b,c)}}};
+Blockly.HorizontalFlyout.prototype.setBackgroundPath_=function(a,b){var c=this.toolboxPosition_==Blockly.TOOLBOX_AT_TOP,d=["M 0,"+(c?0:this.CORNER_RADIUS)];c?(d.push("h",a+2*this.CORNER_RADIUS),d.push("v",b),d.push("a",this.CORNER_RADIUS,this.CORNER_RADIUS,0,0,1,-this.CORNER_RADIUS,this.CORNER_RADIUS),d.push("h",-1*a),d.push("a",this.CORNER_RADIUS,this.CORNER_RADIUS,0,0,1,-this.CORNER_RADIUS,-this.CORNER_RADIUS)):(d.push("a",this.CORNER_RADIUS,this.CORNER_RADIUS,0,0,1,this.CORNER_RADIUS,-this.CORNER_RADIUS),
+d.push("h",a),d.push("a",this.CORNER_RADIUS,this.CORNER_RADIUS,0,0,1,this.CORNER_RADIUS,this.CORNER_RADIUS),d.push("v",b),d.push("h",-a-2*this.CORNER_RADIUS));d.push("z");this.svgBackground_.setAttribute("d",d.join(" "))};Blockly.HorizontalFlyout.prototype.scrollToStart=function(){this.scrollbar_.set(this.RTL?Infinity:0)};
+Blockly.HorizontalFlyout.prototype.wheel_=function(a){var b=a.deltaX||a.deltaY;if(b){goog.userAgent.GECKO&&1===a.deltaMode&&(b*=10);var c=this.getMetrics_();b=c.viewLeft+b;b=Math.min(b,c.contentWidth-c.viewWidth);b=Math.max(b,0);this.scrollbar_.set(b);Blockly.WidgetDiv.hide()}a.preventDefault();a.stopPropagation()};
+Blockly.HorizontalFlyout.prototype.layout_=function(a,b){this.workspace_.scale=this.targetWorkspace_.scale;var c=this.MARGIN,d=this.RTL?c:c+Blockly.BlockSvg.TAB_WIDTH;this.RTL&&(a=a.reverse());for(var e=0,f;f=a[e];e++)if("block"==f.type){f=f.block;for(var g=f.getDescendants(!1),h=0,k;k=g[h];h++)k.isInFlyout=!0;f.render();g=f.getSvgRoot();h=f.getHeightWidth();k=f.outputConnection?Blockly.BlockSvg.TAB_WIDTH:0;k=this.RTL?d+h.width:d+k;f.moveBy(k,c);k=this.createRect_(f,k,c,h,e);d+=h.width+b[e];this.addBlockListeners_(g,
+f,k)}else"button"==f.type&&(this.initFlyoutButton_(f.button,d,c),d+=f.button.width+b[e])};Blockly.HorizontalFlyout.prototype.isDragTowardWorkspace=function(a){a=Math.atan2(a.y,a.x)/Math.PI*180;var b=this.dragAngleRange_;return a<90+b&&a>90-b||a>-90-b&&a<-90+b?!0:!1};
+Blockly.HorizontalFlyout.prototype.getClientRect=function(){if(!this.svgGroup_)return null;var a=this.svgGroup_.getBoundingClientRect(),b=a.top;a=a.height;if(this.toolboxPosition_==Blockly.TOOLBOX_AT_TOP)return new goog.math.Rect(-1E9,b-1E9,2E9,1E9+a);if(this.toolboxPosition_==Blockly.TOOLBOX_AT_BOTTOM)return new goog.math.Rect(-1E9,b,2E9,1E9+a)};
+Blockly.HorizontalFlyout.prototype.reflowInternal_=function(){this.workspace_.scale=this.targetWorkspace_.scale;for(var a=0,b=this.workspace_.getTopBlocks(!1),c=0,d;d=b[c];c++)a=Math.max(a,d.getHeightWidth().height);a+=1.5*this.MARGIN;a*=this.workspace_.scale;a+=Blockly.Scrollbar.scrollbarThickness;if(this.height_!=a){for(c=0;d=b[c];c++)d.flyoutRect_&&this.moveRectToBlock_(d.flyoutRect_,d);this.height_=a;this.position()}};Blockly.VerticalFlyout=function(a){a.getMetrics=this.getMetrics_.bind(this);a.setMetrics=this.setMetrics_.bind(this);Blockly.VerticalFlyout.superClass_.constructor.call(this,a);this.horizontalLayout_=!1};goog.inherits(Blockly.VerticalFlyout,Blockly.Flyout);
+Blockly.VerticalFlyout.prototype.getMetrics_=function(){if(!this.isVisible())return null;try{var a=this.workspace_.getCanvas().getBBox()}catch(e){a={height:0,y:0,width:0,x:0}}var b=this.SCROLLBAR_PADDING,c=this.height_-2*this.SCROLLBAR_PADDING,d=this.width_;this.RTL||(d-=this.SCROLLBAR_PADDING);return{viewHeight:c,viewWidth:d,contentHeight:a.height*this.workspace_.scale+2*this.MARGIN,contentWidth:a.width*this.workspace_.scale+2*this.MARGIN,viewTop:-this.workspace_.scrollY+a.y,viewLeft:-this.workspace_.scrollX,
+contentTop:a.y,contentLeft:a.x,absoluteTop:b,absoluteLeft:0}};Blockly.VerticalFlyout.prototype.setMetrics_=function(a){var b=this.getMetrics_();b&&("number"==typeof a.y&&(this.workspace_.scrollY=-b.contentHeight*a.y),this.workspace_.translate(this.workspace_.scrollX+b.absoluteLeft,this.workspace_.scrollY+b.absoluteTop))};
+Blockly.VerticalFlyout.prototype.position=function(){if(this.isVisible()){var a=this.targetWorkspace_.getMetrics();if(a){this.height_=a.viewHeight;this.setBackgroundPath_(this.width_-this.CORNER_RADIUS,a.viewHeight-2*this.CORNER_RADIUS);var b=a.absoluteTop,c=a.absoluteLeft;this.toolboxPosition_==Blockly.TOOLBOX_AT_RIGHT&&(this.leftEdge_=c+=a.viewWidth-this.width_);this.positionAt_(this.width_,this.height_,c,b)}}};
+Blockly.VerticalFlyout.prototype.setBackgroundPath_=function(a,b){var c=this.toolboxPosition_==Blockly.TOOLBOX_AT_RIGHT,d=a+this.CORNER_RADIUS;d=["M "+(c?d:0)+",0"];d.push("h",c?-a:a);d.push("a",this.CORNER_RADIUS,this.CORNER_RADIUS,0,0,c?0:1,c?-this.CORNER_RADIUS:this.CORNER_RADIUS,this.CORNER_RADIUS);d.push("v",Math.max(0,b));d.push("a",this.CORNER_RADIUS,this.CORNER_RADIUS,0,0,c?0:1,c?this.CORNER_RADIUS:-this.CORNER_RADIUS,this.CORNER_RADIUS);d.push("h",c?a:-a);d.push("z");this.svgBackground_.setAttribute("d",
+d.join(" "))};Blockly.VerticalFlyout.prototype.scrollToStart=function(){this.scrollbar_.set(0)};Blockly.VerticalFlyout.prototype.wheel_=function(a){var b=a.deltaY;if(b){goog.userAgent.GECKO&&1===a.deltaMode&&(b*=10);var c=this.getMetrics_();b=c.viewTop-c.contentTop+b;b=Math.min(b,c.contentHeight-c.viewHeight);b=Math.max(b,0);this.scrollbar_.set(b);Blockly.WidgetDiv.hide()}a.preventDefault();a.stopPropagation()};
+Blockly.VerticalFlyout.prototype.layout_=function(a,b){this.workspace_.scale=this.targetWorkspace_.scale;for(var c=this.MARGIN,d=this.RTL?c:c+Blockly.BlockSvg.TAB_WIDTH,e=0,f;f=a[e];e++)if("block"==f.type){f=f.block;for(var g=f.getDescendants(!1),h=0,k;k=g[h];h++)k.isInFlyout=!0;f.render();g=f.getSvgRoot();h=f.getHeightWidth();f.moveBy(d,c);k=this.createRect_(f,this.RTL?d-h.width:d,c,h,e);this.addBlockListeners_(g,f,k);c+=h.height+b[e]}else"button"==f.type&&(this.initFlyoutButton_(f.button,d,c),c+=
+f.button.height+b[e])};Blockly.VerticalFlyout.prototype.isDragTowardWorkspace=function(a){a=Math.atan2(a.y,a.x)/Math.PI*180;var b=this.dragAngleRange_;return a<b&&a>-b||a<-180+b||a>180-b?!0:!1};
+Blockly.VerticalFlyout.prototype.getClientRect=function(){if(!this.svgGroup_)return null;var a=this.svgGroup_.getBoundingClientRect(),b=a.left;a=a.width;if(this.toolboxPosition_==Blockly.TOOLBOX_AT_LEFT)return new goog.math.Rect(b-1E9,-1E9,1E9+a,2E9);if(goog.userAgent.GECKO&&this.targetWorkspace_&&this.targetWorkspace_.isMutator){var c=this.targetWorkspace_.svgGroup_.getBoundingClientRect().x;10>Math.abs(c-b)&&(b+=this.leftEdge_*this.targetWorkspace_.options.parentWorkspace.scale)}return new goog.math.Rect(b,
+-1E9,1E9+a,2E9)};
+Blockly.VerticalFlyout.prototype.reflowInternal_=function(){this.workspace_.scale=this.targetWorkspace_.scale;for(var a=0,b=this.workspace_.getTopBlocks(!1),c=0,d;d=b[c];c++){var e=d.getHeightWidth().width;d.outputConnection&&(e-=Blockly.BlockSvg.TAB_WIDTH);a=Math.max(a,e)}for(c=0;d=this.buttons_[c];c++)a=Math.max(a,d.width);a+=1.5*this.MARGIN+Blockly.BlockSvg.TAB_WIDTH;a*=this.workspace_.scale;a+=Blockly.Scrollbar.scrollbarThickness;if(this.width_!=a){for(c=0;d=b[c];c++)this.RTL&&(e=d.getRelativeToSurfaceXY().x,
+d.moveBy(a/this.workspace_.scale-this.MARGIN-Blockly.BlockSvg.TAB_WIDTH-e,0)),d.flyoutRect_&&this.moveRectToBlock_(d.flyoutRect_,d);if(this.RTL)for(c=0;d=this.buttons_[c];c++)b=d.getPosition().y,d.moveTo(a/this.workspace_.scale-d.width-this.MARGIN-Blockly.BlockSvg.TAB_WIDTH,b);this.width_=a;this.position()}};Blockly.Toolbox=function(a){this.workspace_=a;this.RTL=a.options.RTL;this.horizontalLayout_=a.options.horizontalLayout;this.toolboxPosition=a.options.toolboxPosition;this.config_={indentWidth:19,cssRoot:"blocklyTreeRoot",cssHideRoot:"blocklyHidden",cssItem:"",cssTreeRow:"blocklyTreeRow",cssItemLabel:"blocklyTreeLabel",cssTreeIcon:"blocklyTreeIcon",cssExpandedFolderIcon:"blocklyTreeIconOpen",cssFileIcon:"blocklyTreeIconNone",cssSelectedRow:"blocklyTreeSelected"};this.treeSeparatorConfig_={cssTreeRow:"blocklyTreeSeparator"};
+this.horizontalLayout_&&(this.config_.cssTreeRow+=a.RTL?" blocklyHorizontalTreeRtl":" blocklyHorizontalTree",this.treeSeparatorConfig_.cssTreeRow="blocklyTreeSeparatorHorizontal "+(a.RTL?"blocklyHorizontalTreeRtl":"blocklyHorizontalTree"),this.config_.cssTreeIcon="")};Blockly.Toolbox.prototype.width=0;Blockly.Toolbox.prototype.height=0;Blockly.Toolbox.prototype.selectedOption_=null;Blockly.Toolbox.prototype.lastCategory_=null;
+Blockly.Toolbox.prototype.init=function(){var a=this.workspace_,b=this.workspace_.getParentSvg();this.HtmlDiv=document.createElement("div");this.HtmlDiv.className="blocklyToolboxDiv";this.HtmlDiv.setAttribute("dir",a.RTL?"RTL":"LTR");b.parentNode.insertBefore(this.HtmlDiv,b);Blockly.bindEventWithChecks_(this.HtmlDiv,"mousedown",this,function(a){Blockly.utils.isRightButton(a)||a.target==this.HtmlDiv?Blockly.hideChaff(!1):Blockly.hideChaff(!0);Blockly.Touch.clearTouchIdentifier()},!1,!0);b={disabledPatternId:a.options.disabledPatternId,
+parentWorkspace:a,RTL:a.RTL,oneBasedIndex:a.options.oneBasedIndex,horizontalLayout:a.horizontalLayout,toolboxPosition:a.options.toolboxPosition};this.flyout_=null;this.flyout_=a.horizontalLayout?new Blockly.HorizontalFlyout(b):new Blockly.VerticalFlyout(b);Blockly.utils.insertAfter(this.flyout_.createDom("svg"),this.workspace_.getParentSvg());this.flyout_.init(a);this.config_.cleardotPath=a.options.pathToMedia+"1x1.gif";this.config_.cssCollapsedFolderIcon="blocklyTreeIconClosed"+(a.RTL?"Rtl":"Ltr");
+this.tree_=b=new Blockly.Toolbox.TreeControl(this,this.config_);b.setShowRootNode(!1);b.setShowLines(!1);b.setShowExpandIcons(!1);b.setSelectedItem(null);a=this.populate_(a.options.languageTree);b.render(this.HtmlDiv);a&&b.setSelectedItem(a);this.addColour_();this.position()};Blockly.Toolbox.prototype.dispose=function(){this.flyout_.dispose();this.tree_.dispose();Blockly.utils.removeNode(this.HtmlDiv);this.lastCategory_=this.workspace_=null};Blockly.Toolbox.prototype.getWidth=function(){return this.width};
+Blockly.Toolbox.prototype.getHeight=function(){return this.height};
+Blockly.Toolbox.prototype.position=function(){var a=this.HtmlDiv;if(a){var b=this.workspace_.getParentSvg();b=Blockly.svgSize(b);this.horizontalLayout_?(a.style.left="0",a.style.height="auto",a.style.width=b.width+"px",this.height=a.offsetHeight,this.toolboxPosition==Blockly.TOOLBOX_AT_TOP?a.style.top="0":a.style.bottom="0"):(this.toolboxPosition==Blockly.TOOLBOX_AT_RIGHT?a.style.right="0":a.style.left="0",a.style.height=b.height+"px",this.width=a.offsetWidth);this.flyout_.position()}};
+Blockly.Toolbox.prototype.populate_=function(a){this.tree_.removeChildren();this.tree_.blocks=[];this.hasColours_=!1;a=this.syncTrees_(a,this.tree_,this.workspace_.options.pathToMedia);if(this.tree_.blocks.length)throw Error("Toolbox cannot have both blocks and categories in the root level.");this.workspace_.resizeContents();return a};
+Blockly.Toolbox.prototype.syncTrees_=function(a,b,c){for(var d=null,e=null,f=0,g;g=a.childNodes[f];f++)if(g.tagName)switch(g.tagName.toUpperCase()){case "CATEGORY":e=Blockly.utils.replaceMessageReferences(g.getAttribute("name"));var h=this.tree_.createNode(e);h.blocks=[];b.add(h);var k=g.getAttribute("custom");k?h.blocks=k:(k=this.syncTrees_(g,h,c))&&(d=k);k=g.getAttribute("style");var l=g.getAttribute("colour");l&&k?(h.hexColour="",console.warn('Toolbox category "'+e+'" can not have both a style and a colour')):
+k?this.setColourFromStyle_(k,h,e):this.setColour_(l,h,e);"true"==g.getAttribute("expanded")?(h.blocks.length&&(d=h),h.setExpanded(!0)):h.setExpanded(!1);e=g;break;case "SEP":e&&("CATEGORY"==e.tagName.toUpperCase()?b.add(new Blockly.Toolbox.TreeSeparator(this.treeSeparatorConfig_)):(g=parseFloat(g.getAttribute("gap")),!isNaN(g)&&e&&e.setAttribute("gap",g)));break;case "BLOCK":case "SHADOW":case "LABEL":case "BUTTON":b.blocks.push(g),e=g}return d};
+Blockly.Toolbox.prototype.setColour_=function(a,b,c){a=Blockly.utils.replaceMessageReferences(a);null===a||""===a?b.hexColour="":/^#[0-9a-fA-F]{6}$/.test(a)?(b.hexColour=a,this.hasColours_=!0):"number"===typeof a||"string"===typeof a&&!isNaN(Number(a))?(b.hexColour=Blockly.hueToRgb(Number(a)),this.hasColours_=!0):(b.hexColour="",console.warn('Toolbox category "'+c+'" has unrecognized colour attribute: '+a))};
+Blockly.Toolbox.prototype.setColourFromStyle_=function(a,b,c){if((b.styleName=a)&&Blockly.getTheme()){var d=Blockly.getTheme().getCategoryStyle(a);d&&d.colour?this.setColour_(d.colour,b,c):console.warn('Style "'+a+'" must exist and contain a colour value')}};Blockly.Toolbox.prototype.updateColourFromTheme_=function(a){if(a=a||this.tree_){a=a.getChildren(!1);for(var b=0,c;c=a[b];b++)c.styleName&&(this.setColourFromStyle_(c.styleName,c,""),this.addColour_()),this.updateColourFromTheme_(c)}};
+Blockly.Toolbox.prototype.updateColourFromTheme=function(){var a=this.tree_;a&&(this.updateColourFromTheme_(a),this.updateSelectedItemColour_(a))};Blockly.Toolbox.prototype.updateSelectedItemColour_=function(a){var b=a.selectedItem_;if(b){var c=b.hexColour||"#57e";b.getRowElement().style.backgroundColor=c;a.toolbox_.addColour_(b)}};
+Blockly.Toolbox.prototype.addColour_=function(a){a=(a||this.tree_).getChildren(!1);for(var b=0,c;c=a[b];b++){var d=c.getRowElement();if(d){var e=this.hasColours_?"8px solid "+(c.hexColour||"#ddd"):"none";this.workspace_.RTL?d.style.borderRight=e:d.style.borderLeft=e}this.addColour_(c)}};Blockly.Toolbox.prototype.clearSelection=function(){this.tree_.setSelectedItem(null)};Blockly.Toolbox.prototype.addStyle=function(a){Blockly.utils.addClass(this.HtmlDiv,a)};
+Blockly.Toolbox.prototype.removeStyle=function(a){Blockly.utils.removeClass(this.HtmlDiv,a)};
+Blockly.Toolbox.prototype.getClientRect=function(){if(!this.HtmlDiv)return null;var a=this.HtmlDiv.getBoundingClientRect(),b=a.left,c=a.top,d=a.width;a=a.height;return this.toolboxPosition==Blockly.TOOLBOX_AT_LEFT?new goog.math.Rect(-1E7,-1E7,1E7+b+d,2E7):this.toolboxPosition==Blockly.TOOLBOX_AT_RIGHT?new goog.math.Rect(b,-1E7,1E7+d,2E7):this.toolboxPosition==Blockly.TOOLBOX_AT_TOP?new goog.math.Rect(-1E7,-1E7,2E7,1E7+c+a):new goog.math.Rect(0,c,2E7,1E7+d)};
+Blockly.Toolbox.prototype.refreshSelection=function(){var a=this.tree_.getSelectedItem();a&&a.blocks&&this.flyout_.show(a.blocks)};Blockly.Toolbox.TreeControl=function(a,b){this.toolbox_=a;goog.ui.tree.TreeControl.call(this,goog.html.SafeHtml.EMPTY,b)};goog.inherits(Blockly.Toolbox.TreeControl,goog.ui.tree.TreeControl);
+Blockly.Toolbox.TreeControl.prototype.enterDocument=function(){Blockly.Toolbox.TreeControl.superClass_.enterDocument.call(this);if(goog.events.BrowserFeature.TOUCH_ENABLED){var a=this.getElement();Blockly.bindEventWithChecks_(a,goog.events.EventType.TOUCHEND,this,this.handleTouchEvent_)}};Blockly.Toolbox.TreeControl.prototype.handleTouchEvent_=function(a){var b=this.getNodeFromEvent_(a);b&&a.type===goog.events.EventType.TOUCHEND&&setTimeout(function(){b.onClick_(a)},1)};
+Blockly.Toolbox.TreeControl.prototype.createNode=function(a){a=a?goog.html.SafeHtml.htmlEscape(a):goog.html.SafeHtml.EMPTY;return new Blockly.Toolbox.TreeNode(this.toolbox_,a,this.getConfig(),this.getDomHelper())};
+Blockly.Toolbox.TreeControl.prototype.setSelectedItem=function(a){var b=this.toolbox_;if(a!=this.selectedItem_&&a!=b.tree_){b.lastCategory_&&(b.lastCategory_.getRowElement().style.backgroundColor="");if(a){var c=a.hexColour||"#57e";a.getRowElement().style.backgroundColor=c;b.addColour_(a)}c=this.getSelectedItem();goog.ui.tree.TreeControl.prototype.setSelectedItem.call(this,a);a&&a.blocks&&a.blocks.length?(b.flyout_.show(a.blocks),b.lastCategory_!=a&&b.flyout_.scrollToStart()):b.flyout_.hide();c!=
+a&&c!=this&&(c=new Blockly.Events.Ui(null,"category",c&&c.getHtml(),a&&a.getHtml()),c.workspaceId=b.workspace_.id,Blockly.Events.fire(c));a&&(b.lastCategory_=a)}};Blockly.Toolbox.TreeNode=function(a,b,c,d){goog.ui.tree.TreeNode.call(this,b,c,d);a&&(b=function(){Blockly.svgResize(a.workspace_)},goog.events.listen(a.tree_,goog.ui.tree.BaseNode.EventType.EXPAND,b),goog.events.listen(a.tree_,goog.ui.tree.BaseNode.EventType.COLLAPSE,b))};goog.inherits(Blockly.Toolbox.TreeNode,goog.ui.tree.TreeNode);
+Blockly.Toolbox.TreeNode.prototype.getExpandIconSafeHtml=function(){return goog.html.SafeHtml.create("span")};Blockly.Toolbox.TreeNode.prototype.onClick_=function(a){this.hasChildren()&&this.isUserCollapsible_?(this.toggle(),this.select()):this.isSelected()?this.getTree().setSelectedItem(null):this.select();this.updateRow()};Blockly.Toolbox.TreeNode.prototype.onMouseDown=function(a){};Blockly.Toolbox.TreeNode.prototype.onDoubleClick_=function(a){};
+Blockly.Toolbox.TreeNode.prototype.onKeyDown=function(a){if(this.tree.toolbox_.horizontalLayout_){var b={},c=goog.events.KeyCodes.DOWN,d=goog.events.KeyCodes.UP;b[goog.events.KeyCodes.RIGHT]=this.rightToLeft_?d:c;b[goog.events.KeyCodes.LEFT]=this.rightToLeft_?c:d;b[goog.events.KeyCodes.UP]=goog.events.KeyCodes.LEFT;b[goog.events.KeyCodes.DOWN]=goog.events.KeyCodes.RIGHT;a.keyCode=b[a.keyCode]||a.keyCode}return Blockly.Toolbox.TreeNode.superClass_.onKeyDown.call(this,a)};
+Blockly.Toolbox.TreeSeparator=function(a){Blockly.Toolbox.TreeNode.call(this,null,goog.html.SafeHtml.EMPTY,a)};goog.inherits(Blockly.Toolbox.TreeSeparator,Blockly.Toolbox.TreeNode);Blockly.Css={};Blockly.Css.Cursor={OPEN:"handopen",CLOSED:"handclosed",DELETE:"handdelete"};Blockly.Css.currentCursor_="";Blockly.Css.styleSheet_=null;Blockly.Css.mediaPath_="";
+Blockly.Css.inject=function(a,b){if(!Blockly.Css.styleSheet_){var c=".blocklyDraggable {}\n";a&&(c+=Blockly.Css.CONTENT.join("\n"),Blockly.FieldDate&&(c+=Blockly.FieldDate.CSS.join("\n")));Blockly.Css.mediaPath_=b.replace(/[\\\/]$/,"");c=c.replace(/<<<PATH>>>/g,Blockly.Css.mediaPath_);var d=document.createElement("style");document.head.insertBefore(d,document.head.firstChild);c=document.createTextNode(c);d.appendChild(c);Blockly.Css.styleSheet_=d.sheet}};Blockly.Css.setCursor=function(a){console.warn("Deprecated call to Blockly.Css.setCursor.See https://github.com/google/blockly/issues/981 for context")};
+Blockly.Css.CONTENT=[".blocklySvg {","background-color: #fff;","outline: none;","overflow: hidden;","position: absolute;","display: block;","}",".blocklyWidgetDiv {","display: none;","position: absolute;","z-index: 99999;","}",".injectionDiv {","height: 100%;","position: relative;","overflow: hidden;","touch-action: none","}",".blocklyNonSelectable {","user-select: none;","-moz-user-select: none;","-ms-user-select: none;","-webkit-user-select: none;","}",".blocklyWsDragSurface {","display: none;",
+"position: absolute;","top: 0;","left: 0;","}",".blocklyWsDragSurface.blocklyOverflowVisible {","overflow: visible;","}",".blocklyBlockDragSurface {","display: none;","position: absolute;","top: 0;","left: 0;","right: 0;","bottom: 0;","overflow: visible !important;","z-index: 50;","}",".blocklyBlockCanvas.blocklyCanvasTransitioning,",".blocklyBubbleCanvas.blocklyCanvasTransitioning {","transition: transform .5s;","}",".blocklyTooltipDiv {","background-color: #ffffc7;","border: 1px solid #ddc;","box-shadow: 4px 4px 20px 1px rgba(0,0,0,.15);",
+"color: #000;","display: none;","font-family: sans-serif;","font-size: 9pt;","opacity: .9;","padding: 2px;","position: absolute;","z-index: 100000;","}",".blocklyResizeSE {","cursor: se-resize;","fill: #aaa;","}",".blocklyResizeSW {","cursor: sw-resize;","fill: #aaa;","}",".blocklyResizeLine {","stroke: #515A5A;","stroke-width: 1;","}",".blocklyHighlightedConnectionPath {","fill: none;","stroke: #fc3;","stroke-width: 4px;","}",".blocklyPathLight {","fill: none;","stroke-linecap: round;","stroke-width: 1;",
+"}",".blocklySelected>.blocklyPath {","stroke: #fc3;","stroke-width: 3px;","}",".blocklySelected>.blocklyPathLight {","display: none;","}",".blocklyDraggable {",'cursor: url("<<<PATH>>>/handopen.cur"), auto;',"cursor: grab;","cursor: -webkit-grab;","}",".blocklyDragging {",'cursor: url("<<<PATH>>>/handclosed.cur"), auto;',"cursor: grabbing;","cursor: -webkit-grabbing;","}",".blocklyDraggable:active {",'cursor: url("<<<PATH>>>/handclosed.cur"), auto;',"cursor: grabbing;","cursor: -webkit-grabbing;",
+"}",".blocklyBlockDragSurface .blocklyDraggable {",'cursor: url("<<<PATH>>>/handclosed.cur"), auto;',"cursor: grabbing;","cursor: -webkit-grabbing;","}",".blocklyDragging.blocklyDraggingDelete {",'cursor: url("<<<PATH>>>/handdelete.cur"), auto;',"}",".blocklyToolboxDelete {",'cursor: url("<<<PATH>>>/handdelete.cur"), auto;',"}",".blocklyToolboxGrab {",'cursor: url("<<<PATH>>>/handclosed.cur"), auto;',"cursor: grabbing;","cursor: -webkit-grabbing;","}",".blocklyDragging>.blocklyPath,",".blocklyDragging>.blocklyPathLight {",
+"fill-opacity: .8;","stroke-opacity: .8;","}",".blocklyDragging>.blocklyPathDark {","display: none;","}",".blocklyDisabled>.blocklyPath {","fill-opacity: .5;","stroke-opacity: .5;","}",".blocklyDisabled>.blocklyPathLight,",".blocklyDisabled>.blocklyPathDark {","display: none;","}",".blocklyInsertionMarker>.blocklyPath,",".blocklyInsertionMarker>.blocklyPathLight,",".blocklyInsertionMarker>.blocklyPathDark {","fill-opacity: .2;","stroke: none","}",".blocklyReplaceable .blocklyPath {","fill-opacity: 0.5;",
+"}",".blocklyReplaceable .blocklyPathLight,",".blocklyReplaceable .blocklyPathDark {","display: none;","}",".blocklyText {","cursor: default;","fill: #fff;","font-family: sans-serif;","font-size: 11pt;","}",".blocklyNonEditableText>text {","pointer-events: none;","}",".blocklyNonEditableText>rect,",".blocklyEditableText>rect {","fill: #fff;","fill-opacity: .6;","}",".blocklyNonEditableText>text,",".blocklyEditableText>text {","fill: #000;","}",".blocklyEditableText:hover>rect {","stroke: #fff;","stroke-width: 2;",
+"}",".blocklyBubbleText {","fill: #000;","}",".blocklyFlyout {","position: absolute;","z-index: 20;","}",".blocklyFlyoutButton {","fill: #888;","cursor: default;","}",".blocklyFlyoutButtonShadow {","fill: #666;","}",".blocklyFlyoutButton:hover {","fill: #aaa;","}",".blocklyFlyoutLabel {","cursor: default;","}",".blocklyFlyoutLabelBackground {","opacity: 0;","}",".blocklyFlyoutLabelText {","fill: #000;","}",".blocklySvg text, .blocklyBlockDragSurface text {","user-select: none;","-moz-user-select: none;",
+"-ms-user-select: none;","-webkit-user-select: none;","cursor: inherit;","}",".blocklyHidden {","display: none;","}",".blocklyFieldDropdown:not(.blocklyHidden) {","display: block;","}",".blocklyIconGroup {","cursor: default;","}",".blocklyIconGroup:not(:hover),",".blocklyIconGroupReadonly {","opacity: .6;","}",".blocklyIconShape {","fill: #00f;","stroke: #fff;","stroke-width: 1px;","}",".blocklyIconSymbol {","fill: #fff;","}",".blocklyMinimalBody {","margin: 0;","padding: 0;","}",".blocklyCommentForeignObject {",
+"position: relative;","z-index: 0;","}",".blocklyCommentRect {","fill: #E7DE8E;","stroke: #bcA903;","stroke-width: 1px","}",".blocklyCommentTarget {","fill: transparent;","stroke: #bcA903;","}",".blocklyCommentTargetFocused {","fill: none;","}",".blocklyCommentHandleTarget {","fill: none;","}",".blocklyCommentHandleTargetFocused {","fill: transparent;","}",".blocklyFocused>.blocklyCommentRect {","fill: #B9B272;","stroke: #B9B272;","}",".blocklySelected>.blocklyCommentTarget {","stroke: #fc3;","stroke-width: 3px;",
+"}",".blocklyCommentTextarea {","background-color: #fef49c;","border: 0;","outline: 0;","margin: 0;","padding: 3px;","resize: none;","display: block;","overflow: hidden;","}",".blocklyCommentDeleteIcon {","cursor: pointer;","fill: #000;","display: none","}",".blocklySelected > .blocklyCommentDeleteIcon {","display: block","}",".blocklyDeleteIconShape {","fill: #000;","stroke: #000;","stroke-width: 1px;","}",".blocklyDeleteIconShape.blocklyDeleteIconHighlighted {","stroke: #fc3;","}",".blocklyHtmlInput {",
+"border: none;","border-radius: 4px;","font-family: sans-serif;","height: 100%;","margin: 0;","outline: none;","padding: 0 1px;","width: 100%","}",".blocklyMainBackground {","stroke-width: 1;","stroke: #c6c6c6;","}",".blocklyMutatorBackground {","fill: #fff;","stroke: #ddd;","stroke-width: 1;","}",".blocklyFlyoutBackground {","fill: #ddd;","fill-opacity: .8;","}",".blocklyTransparentBackground {","opacity: 0;","}",".blocklyMainWorkspaceScrollbar {","z-index: 20;","}",".blocklyFlyoutScrollbar {","z-index: 30;",
+"}",".blocklyScrollbarHorizontal, .blocklyScrollbarVertical {","position: absolute;","outline: none;","}",".blocklyScrollbarBackground {","opacity: 0;","}",".blocklyScrollbarHandle {","fill: #ccc;","}",".blocklyScrollbarBackground:hover+.blocklyScrollbarHandle,",".blocklyScrollbarHandle:hover {","fill: #bbb;","}",".blocklyZoom>image, .blocklyZoom>svg>image {","opacity: .4;","}",".blocklyZoom>image:hover, .blocklyZoom>svg>image:hover {","opacity: .6;","}",".blocklyZoom>image:active, .blocklyZoom>svg>image:active {",
+"opacity: .8;","}",".blocklyFlyout .blocklyScrollbarHandle {","fill: #bbb;","}",".blocklyFlyout .blocklyScrollbarBackground:hover+.blocklyScrollbarHandle,",".blocklyFlyout .blocklyScrollbarHandle:hover {","fill: #aaa;","}",".blocklyInvalidInput {","background: #faa;","}",".blocklyAngleCircle {","stroke: #444;","stroke-width: 1;","fill: #ddd;","fill-opacity: .8;","}",".blocklyAngleMarks {","stroke: #444;","stroke-width: 1;","}",".blocklyAngleGauge {","fill: #f88;","fill-opacity: .8;","}",".blocklyAngleLine {",
+"stroke: #f00;","stroke-width: 2;","stroke-linecap: round;","pointer-events: none;","}",".blocklyContextMenu {","border-radius: 4px;","max-height: 100%;","}",".blocklyDropdownMenu {","padding: 0 !important;","}",".blocklyWidgetDiv .goog-option-selected .goog-menuitem-checkbox,",".blocklyWidgetDiv .goog-option-selected .goog-menuitem-icon {","background: url(<<<PATH>>>/sprites.png) no-repeat -48px -16px !important;","}",".blocklyToolboxDiv {","background-color: #ddd;","overflow-x: visible;","overflow-y: auto;",
+"position: absolute;","user-select: none;","-moz-user-select: none;","-ms-user-select: none;","-webkit-user-select: none;","z-index: 70;","-webkit-tap-highlight-color: transparent;","}",".blocklyTreeRoot {","padding: 4px 0;","}",".blocklyTreeRoot:focus {","outline: none;","}",".blocklyTreeRow {","height: 22px;","line-height: 22px;","margin-bottom: 3px;","padding-right: 8px;","white-space: nowrap;","}",".blocklyHorizontalTree {","float: left;","margin: 1px 5px 8px 0;","}",".blocklyHorizontalTreeRtl {",
+"float: right;","margin: 1px 0 8px 5px;","}",'.blocklyToolboxDiv[dir="RTL"] .blocklyTreeRow {',"margin-left: 8px;","}",".blocklyTreeRow:not(.blocklyTreeSelected):hover {","background-color: #e4e4e4;","}",".blocklyTreeSeparator {","border-bottom: solid #e5e5e5 1px;","height: 0;","margin: 5px 0;","}",".blocklyTreeSeparatorHorizontal {","border-right: solid #e5e5e5 1px;","width: 0;","padding: 5px 0;","margin: 0 5px;","}",".blocklyTreeIcon {","background-image: url(<<<PATH>>>/sprites.png);","height: 16px;",
+"vertical-align: middle;","width: 16px;","}",".blocklyTreeIconClosedLtr {","background-position: -32px -1px;","}",".blocklyTreeIconClosedRtl {","background-position: 0 -1px;","}",".blocklyTreeIconOpen {","background-position: -16px -1px;","}",".blocklyTreeSelected>.blocklyTreeIconClosedLtr {","background-position: -32px -17px;","}",".blocklyTreeSelected>.blocklyTreeIconClosedRtl {","background-position: 0 -17px;","}",".blocklyTreeSelected>.blocklyTreeIconOpen {","background-position: -16px -17px;",
+"}",".blocklyTreeIconNone,",".blocklyTreeSelected>.blocklyTreeIconNone {","background-position: -48px -1px;","}",".blocklyTreeLabel {","cursor: default;","font-family: sans-serif;","font-size: 16px;","padding: 0 3px;","vertical-align: middle;","}",".blocklyToolboxDelete .blocklyTreeLabel {",'cursor: url("<<<PATH>>>/handdelete.cur"), auto;',"}",".blocklyTreeSelected .blocklyTreeLabel {","color: #fff;","}",".blocklyColourTable {","border-collapse: collapse;","}",".blocklyColourTable>tr>td {","border: 1px solid #666;",
+"padding: 0;","}",".blocklyColourTable>tr>td>div {","border: 1px solid #666;","height: 13px;","width: 15px;","}",".blocklyColourTable>tr>td>div:hover {","border: 1px solid #fff;","}",".blocklyColourSelected, .blocklyColourSelected:hover {","border: 1px solid #000 !important;","}",".blocklyWidgetDiv .goog-menu {","background: #fff;","border-color: #ccc #666 #666 #ccc;","border-style: solid;","border-width: 1px;","cursor: default;","font: normal 13px Arial, sans-serif;","margin: 0;","outline: none;",
+"padding: 4px 0;","position: absolute;","overflow-y: auto;","overflow-x: hidden;","max-height: 100%;","z-index: 20000;","}",".blocklyWidgetDiv .goog-menuitem {","color: #000;","font: normal 13px Arial, sans-serif;","list-style: none;","margin: 0;","padding: 4px 7em 4px 28px;","white-space: nowrap;","}",".blocklyWidgetDiv .goog-menuitem.goog-menuitem-rtl {","padding-left: 7em;","padding-right: 28px;","}",".blocklyWidgetDiv .goog-menu-nocheckbox .goog-menuitem,",".blocklyWidgetDiv .goog-menu-noicon .goog-menuitem {",
+"padding-left: 12px;","}",".blocklyWidgetDiv .goog-menu-noaccel .goog-menuitem {","padding-right: 20px;","}",".blocklyWidgetDiv .goog-menuitem-content {","color: #000;","font: normal 13px Arial, sans-serif;","}",".blocklyWidgetDiv .goog-menuitem-disabled .goog-menuitem-accel,",".blocklyWidgetDiv .goog-menuitem-disabled .goog-menuitem-content {","color: #ccc !important;","}",".blocklyWidgetDiv .goog-menuitem-disabled .goog-menuitem-icon {","opacity: 0.3;","filter: alpha(opacity=30);","}",".blocklyWidgetDiv .goog-menuitem-highlight,",
+".blocklyWidgetDiv .goog-menuitem-hover {","background-color: #d6e9f8;","border-color: #d6e9f8;","border-style: dotted;","border-width: 1px 0;","padding-bottom: 3px;","padding-top: 3px;","}",".blocklyWidgetDiv .goog-menuitem-checkbox,",".blocklyWidgetDiv .goog-menuitem-icon {","background-repeat: no-repeat;","height: 16px;","left: 6px;","position: absolute;","right: auto;","vertical-align: middle;","width: 16px;","}",".blocklyWidgetDiv .goog-menuitem-rtl .goog-menuitem-checkbox,",".blocklyWidgetDiv .goog-menuitem-rtl .goog-menuitem-icon {",
+"left: auto;","right: 6px;","}",".blocklyWidgetDiv .goog-option-selected .goog-menuitem-checkbox,",".blocklyWidgetDiv .goog-option-selected .goog-menuitem-icon {","background: url(//ssl.gstatic.com/editor/editortoolbar.png) no-repeat -512px 0;","}",".blocklyWidgetDiv .goog-menuitem-accel {","color: #999;","direction: ltr;","left: auto;","padding: 0 6px;","position: absolute;","right: 0;","text-align: right;","}",".blocklyWidgetDiv .goog-menuitem-rtl .goog-menuitem-accel {","left: 0;","right: auto;",
+"text-align: left;","}",".blocklyWidgetDiv .goog-menuitem-mnemonic-hint {","text-decoration: underline;","}",".blocklyWidgetDiv .goog-menuitem-mnemonic-separator {","color: #999;","font-size: 12px;","padding-left: 4px;","}",".blocklyWidgetDiv .goog-menuseparator {","border-top: 1px solid #ccc;","margin: 4px 0;","padding: 0;","}",""];Blockly.WidgetDiv={};Blockly.WidgetDiv.DIV=null;Blockly.WidgetDiv.owner_=null;Blockly.WidgetDiv.dispose_=null;Blockly.WidgetDiv.createDom=function(){Blockly.WidgetDiv.DIV||(Blockly.WidgetDiv.DIV=document.createElement("div"),Blockly.WidgetDiv.DIV.className="blocklyWidgetDiv",document.body.appendChild(Blockly.WidgetDiv.DIV))};
+Blockly.WidgetDiv.show=function(a,b,c){Blockly.WidgetDiv.hide();Blockly.WidgetDiv.owner_=a;Blockly.WidgetDiv.dispose_=c;a=goog.style.getViewportPageOffset(document);Blockly.WidgetDiv.DIV.style.top=a.y+"px";Blockly.WidgetDiv.DIV.style.direction=b?"rtl":"ltr";Blockly.WidgetDiv.DIV.style.display="block"};
+Blockly.WidgetDiv.hide=function(){Blockly.WidgetDiv.owner_&&(Blockly.WidgetDiv.owner_=null,Blockly.WidgetDiv.DIV.style.display="none",Blockly.WidgetDiv.DIV.style.left="",Blockly.WidgetDiv.DIV.style.top="",Blockly.WidgetDiv.dispose_&&Blockly.WidgetDiv.dispose_(),Blockly.WidgetDiv.dispose_=null,Blockly.WidgetDiv.DIV.innerHTML="")};Blockly.WidgetDiv.isVisible=function(){return!!Blockly.WidgetDiv.owner_};Blockly.WidgetDiv.hideIfOwner=function(a){Blockly.WidgetDiv.owner_==a&&Blockly.WidgetDiv.hide()};
+Blockly.WidgetDiv.position=function(a,b,c,d,e){b<d.y&&(b=d.y);e?a>c.width+d.x&&(a=c.width+d.x):a<d.x&&(a=d.x);Blockly.WidgetDiv.positionInternal_(a,b,c.height)};Blockly.WidgetDiv.positionInternal_=function(a,b,c){Blockly.WidgetDiv.DIV.style.left=a+"px";Blockly.WidgetDiv.DIV.style.top=b+"px";Blockly.WidgetDiv.DIV.style.height=c+"px"};
+Blockly.WidgetDiv.positionWithAnchor=function(a,b,c,d){var e=Blockly.WidgetDiv.calculateY_(a,b,c);a=Blockly.WidgetDiv.calculateX_(a,b,c,d);0>e?Blockly.WidgetDiv.positionInternal_(a,0,c.height+e):Blockly.WidgetDiv.positionInternal_(a,e,c.height)};Blockly.WidgetDiv.calculateX_=function(a,b,c,d){if(d)return b=Math.max(b.right-c.width,a.left),Math.min(b,a.right-c.width);b=Math.min(b.left,a.right-c.width);return Math.max(b,a.left)};
+Blockly.WidgetDiv.calculateY_=function(a,b,c){return b.bottom+c.height>=a.bottom?b.top-c.height:b.bottom};Blockly.inject=function(a,b){Blockly.checkBlockColourConstants();"string"==typeof a&&(a=document.getElementById(a)||document.querySelector(a));if(!Blockly.utils.containsNode(document,a))throw Error("Error: container is not in current document.");var c=new Blockly.Options(b||{}),d=document.createElement("div");d.className="injectionDiv";a.appendChild(d);var e=Blockly.createDom_(d,c),f=new Blockly.BlockDragSurfaceSvg(d);d=new Blockly.WorkspaceDragSurfaceSvg(d);e=Blockly.createMainWorkspace_(e,c,f,d);
+Blockly.setTheme(c.theme);Blockly.init_(e);Blockly.mainWorkspace=e;Blockly.svgResize(e);return e};
+Blockly.createDom_=function(a,b){a.setAttribute("dir","LTR");goog.ui.Component.setDefaultRightToLeft(b.RTL);Blockly.Css.inject(b.hasCss,b.pathToMedia);var c=Blockly.utils.createSvgElement("svg",{xmlns:"http://www.w3.org/2000/svg","xmlns:html":"http://www.w3.org/1999/xhtml","xmlns:xlink":"http://www.w3.org/1999/xlink",version:"1.1","class":"blocklySvg"},a),d=Blockly.utils.createSvgElement("defs",{},c),e=String(Math.random()).substring(2),f=Blockly.utils.createSvgElement("filter",{id:"blocklyEmbossFilter"+
+e},d);Blockly.utils.createSvgElement("feGaussianBlur",{"in":"SourceAlpha",stdDeviation:1,result:"blur"},f);var g=Blockly.utils.createSvgElement("feSpecularLighting",{"in":"blur",surfaceScale:1,specularConstant:.5,specularExponent:10,"lighting-color":"white",result:"specOut"},f);Blockly.utils.createSvgElement("fePointLight",{x:-5E3,y:-1E4,z:2E4},g);Blockly.utils.createSvgElement("feComposite",{"in":"specOut",in2:"SourceAlpha",operator:"in",result:"specOut"},f);Blockly.utils.createSvgElement("feComposite",
+{"in":"SourceGraphic",in2:"specOut",operator:"arithmetic",k1:0,k2:1,k3:1,k4:0},f);b.embossFilterId=f.id;f=Blockly.utils.createSvgElement("pattern",{id:"blocklyDisabledPattern"+e,patternUnits:"userSpaceOnUse",width:10,height:10},d);Blockly.utils.createSvgElement("rect",{width:10,height:10,fill:"#aaa"},f);Blockly.utils.createSvgElement("path",{d:"M 0 0 L 10 10 M 10 0 L 0 10",stroke:"#cc0"},f);b.disabledPatternId=f.id;b.gridPattern=Blockly.Grid.createDom(e,b.gridOptions,d);return c};
+Blockly.createMainWorkspace_=function(a,b,c,d){b.parentWorkspace=null;var e=new Blockly.WorkspaceSvg(b,c,d);e.scale=b.zoomOptions.startScale;a.appendChild(e.createDom("blocklyMainBackground"));!b.hasCategories&&b.languageTree&&(c=e.addFlyout_("svg"),Blockly.utils.insertAfter(c,a));b.hasTrashcan&&e.addTrashcan();b.zoomOptions&&b.zoomOptions.controls&&e.addZoomControls();e.translate(0,0);Blockly.mainWorkspace=e;b.readOnly||b.hasScrollbars||e.addChangeListener(function(a){if(!e.isDragging()){var c=e.getMetrics(),
+d=c.viewLeft+c.absoluteLeft,f=c.viewTop+c.absoluteTop;if(c.contentTop<f||c.contentTop+c.contentHeight>c.viewHeight+f||c.contentLeft<(b.RTL?c.viewLeft:d)||c.contentLeft+c.contentWidth>(b.RTL?c.viewWidth:c.viewWidth+d)){var l=e.getTopBlocks(!1),n=null;a&&(n=Blockly.Events.getGroup(),Blockly.Events.setGroup(a.group));for(var m=!1,p=0,q;q=l[p];p++){var t=q.getRelativeToSurfaceXY(),r=q.getHeightWidth(),u=f+25-r.height-t.y;0<u&&(q.moveBy(0,u),m=!0);u=f+c.viewHeight-25-t.y;0>u&&(q.moveBy(0,u),m=!0);u=25+
+d-t.x-(b.RTL?0:r.width);0<u&&(q.moveBy(u,0),m=!0);t=d+c.viewWidth-25-t.x+(b.RTL?r.width:0);0>t&&(q.moveBy(t,0),m=!0)}a&&(!a.group&&m&&console.log("WARNING: Moved blocks in bounds but there was no event group. This may break undo."),Blockly.Events.setGroup(n))}}});Blockly.svgResize(e);Blockly.WidgetDiv.createDom();Blockly.Tooltip.createDom();return e};
+Blockly.init_=function(a){var b=a.options,c=a.getParentSvg();Blockly.bindEventWithChecks_(c.parentNode,"contextmenu",null,function(a){Blockly.utils.isTargetInput(a)||a.preventDefault()});c=Blockly.bindEventWithChecks_(window,"resize",null,function(){Blockly.hideChaff(!0);Blockly.svgResize(a)});a.setResizeHandlerWrapper(c);Blockly.inject.bindDocumentEvents_();b.languageTree&&(a.toolbox_?a.toolbox_.init(a):a.flyout_&&(a.flyout_.init(a),a.flyout_.show(b.languageTree.childNodes),a.flyout_.scrollToStart(),
+a.scrollX=a.flyout_.width_,b.toolboxPosition==Blockly.TOOLBOX_AT_RIGHT&&(a.scrollX*=-1),a.translate(a.scrollX,0)));c=Blockly.Scrollbar.scrollbarThickness;b.hasTrashcan&&(c=a.trashcan.init(c));b.zoomOptions&&b.zoomOptions.controls&&a.zoomControls_.init(c);b.hasScrollbars&&(a.scrollbar=new Blockly.ScrollbarPair(a),a.scrollbar.resize());b.hasSounds&&Blockly.inject.loadSounds_(b.pathToMedia,a)};
+Blockly.inject.bindDocumentEvents_=function(){Blockly.documentEventsBound_||(Blockly.bindEventWithChecks_(document,"keydown",null,Blockly.onKeyDown_),Blockly.bindEvent_(document,"touchend",null,Blockly.longStop_),Blockly.bindEvent_(document,"touchcancel",null,Blockly.longStop_),goog.userAgent.IPAD&&Blockly.bindEventWithChecks_(window,"orientationchange",document,function(){Blockly.svgResize(Blockly.getMainWorkspace())}));Blockly.documentEventsBound_=!0};
+Blockly.inject.loadSounds_=function(a,b){var c=b.getAudioManager();c.load([a+"click.mp3",a+"click.wav",a+"click.ogg"],"click");c.load([a+"disconnect.wav",a+"disconnect.mp3",a+"disconnect.ogg"],"disconnect");c.load([a+"delete.mp3",a+"delete.ogg",a+"delete.wav"],"delete");var d=[],e=function(){for(;d.length;)Blockly.unbindEvent_(d.pop());c.preload()};d.push(Blockly.bindEventWithChecks_(document,"mousemove",null,e,!0));d.push(Blockly.bindEventWithChecks_(document,"touchstart",null,e,!0))};
+Blockly.updateToolbox=function(a){console.warn("Deprecated call to Blockly.updateToolbox, use workspace.updateToolbox instead.");Blockly.getMainWorkspace().updateToolbox(a)};var CLOSURE_DEFINES={"goog.DEBUG":!1};Blockly.mainWorkspace=null;Blockly.selected=null;Blockly.draggingConnections_=[];Blockly.clipboardXml_=null;Blockly.clipboardSource_=null;Blockly.clipboardTypeCounts_=null;Blockly.cache3dSupported_=null;Blockly.theme_=null;Blockly.hueToRgb=function(a){return goog.color.hsvToHex(a,Blockly.HSV_SATURATION,255*Blockly.HSV_VALUE)};Blockly.svgSize=function(a){return{width:a.cachedWidth_,height:a.cachedHeight_}};Blockly.resizeSvgContents=function(a){a.resizeContents()};
+Blockly.svgResize=function(a){for(;a.options.parentWorkspace;)a=a.options.parentWorkspace;var b=a.getParentSvg(),c=b.parentNode;if(c){var d=c.offsetWidth;c=c.offsetHeight;b.cachedWidth_!=d&&(b.setAttribute("width",d+"px"),b.cachedWidth_=d);b.cachedHeight_!=c&&(b.setAttribute("height",c+"px"),b.cachedHeight_=c);a.resize()}};
+Blockly.onKeyDown_=function(a){var b=Blockly.mainWorkspace;if(!(b.options.readOnly||Blockly.utils.isTargetInput(a)||b.rendered&&!b.isVisible())){var c=!1;if(27==a.keyCode)Blockly.hideChaff();else if(8==a.keyCode||46==a.keyCode){a.preventDefault();if(b.isDragging())return;Blockly.selected&&Blockly.selected.isDeletable()&&(c=!0)}else if(a.altKey||a.ctrlKey||a.metaKey){if(b.isDragging())return;Blockly.selected&&Blockly.selected.isDeletable()&&Blockly.selected.isMovable()&&(67==a.keyCode?(Blockly.hideChaff(),
+Blockly.copy_(Blockly.selected)):88!=a.keyCode||Blockly.selected.workspace.isFlyout||(Blockly.copy_(Blockly.selected),c=!0));86==a.keyCode?Blockly.clipboardXml_&&(b=Blockly.clipboardSource_,b.isFlyout&&(b=b.targetWorkspace),Blockly.clipboardTypeCounts_&&b.isCapacityAvailable(Blockly.clipboardTypeCounts_)&&(Blockly.Events.setGroup(!0),b.paste(Blockly.clipboardXml_),Blockly.Events.setGroup(!1))):90==a.keyCode&&(Blockly.hideChaff(),b.undo(a.shiftKey))}c&&!Blockly.selected.workspace.isFlyout&&(Blockly.Events.setGroup(!0),
+Blockly.hideChaff(),Blockly.selected.dispose(!0,!0),Blockly.Events.setGroup(!1))}};Blockly.copy_=function(a){if(a.isComment)var b=a.toXmlWithXY();else{b=Blockly.Xml.blockToDom(a);Blockly.Xml.deleteNext(b);var c=a.getRelativeToSurfaceXY();b.setAttribute("x",a.RTL?-c.x:c.x);b.setAttribute("y",c.y)}Blockly.clipboardXml_=b;Blockly.clipboardSource_=a.workspace;Blockly.clipboardTypeCounts_=a.isComment?null:Blockly.utils.getBlockTypeCounts(a,!0)};
+Blockly.duplicate_=function(a){var b=Blockly.clipboardXml_,c=Blockly.clipboardSource_;Blockly.copy_(a);a.workspace.paste(Blockly.clipboardXml_);Blockly.clipboardXml_=b;Blockly.clipboardSource_=c};Blockly.onContextMenu_=function(a){Blockly.utils.isTargetInput(a)||a.preventDefault()};
+Blockly.hideChaff=function(a){Blockly.Tooltip.hide();Blockly.WidgetDiv.hide();var b=Blockly.getMainWorkspace();b.trashcan&&b.trashcan.flyout_&&b.trashcan.flyout_.hide();a||b.toolbox_&&b.toolbox_.flyout_&&b.toolbox_.flyout_.autoClose&&b.toolbox_.clearSelection()};Blockly.addChangeListener=function(a){console.warn("Deprecated call to Blockly.addChangeListener, use workspace.addChangeListener instead.");return Blockly.getMainWorkspace().addChangeListener(a)};Blockly.getMainWorkspace=function(){return Blockly.mainWorkspace};
+Blockly.alert=function(a,b){window.alert(a);b&&b()};Blockly.confirm=function(a,b){b(window.confirm(a))};Blockly.prompt=function(a,b,c){c(window.prompt(a,b))};Blockly.jsonInitFactory_=function(a){return function(){this.jsonInit(a)}};
+Blockly.defineBlocksWithJsonArray=function(a){for(var b=0;b<a.length;b++){var c=a[b];if(c){var d=c.type;null==d||""===d?console.warn("Block definition #"+b+" in JSON array is missing a type attribute. Skipping."):(Blockly.Blocks[d]&&console.warn("Block definition #"+b+' in JSON array overwrites prior definition of "'+d+'".'),Blockly.Blocks[d]={init:Blockly.jsonInitFactory_(c)})}else console.warn("Block definition #"+b+" in JSON array is "+c+". Skipping.")}};
+Blockly.bindEventWithChecks_=function(a,b,c,d,e,f){var g=!1,h=function(a){var b=!e;a=Blockly.Touch.splitEventByTouches(a);for(var f=0,h;h=a[f];f++)if(!b||Blockly.Touch.shouldHandleEvent(h))Blockly.Touch.setClientFromTouch(h),c?d.call(c,h):d(h),g=!0},k=[];if(goog.global.PointerEvent&&b in Blockly.Touch.TOUCH_MAP)for(var l=0,n;n=Blockly.Touch.TOUCH_MAP[b][l];l++)a.addEventListener(n,h,!1),k.push([a,n,h]);else if(a.addEventListener(b,h,!1),k.push([a,b,h]),b in Blockly.Touch.TOUCH_MAP){var m=function(a){h(a);
+var b=!f;g&&b&&a.preventDefault()};for(l=0;n=Blockly.Touch.TOUCH_MAP[b][l];l++)a.addEventListener(n,m,!1),k.push([a,n,m])}return k};
+Blockly.bindEvent_=function(a,b,c,d){var e=function(a){c?d.call(c,a):d(a)},f=[],g=goog.global.window;if(g&&g.PointerEvent&&b in Blockly.Touch.TOUCH_MAP){g=0;for(var h;h=Blockly.Touch.TOUCH_MAP[b][g];g++)a.addEventListener(h,e,!1),f.push([a,h,e])}else if(a.addEventListener(b,e,!1),f.push([a,b,e]),b in Blockly.Touch.TOUCH_MAP){var k=function(a){if(a.changedTouches&&1==a.changedTouches.length){var b=a.changedTouches[0];a.clientX=b.clientX;a.clientY=b.clientY}e(a);a.preventDefault()};for(g=0;h=Blockly.Touch.TOUCH_MAP[b][g];g++)a.addEventListener(h,
+k,!1),f.push([a,h,k])}return f};Blockly.unbindEvent_=function(a){for(;a.length;){var b=a.pop(),c=b[2];b[0].removeEventListener(b[1],c,!1)}return c};Blockly.isNumber=function(a){return/^\s*-?\d+(\.\d+)?\s*$/.test(a)};
+Blockly.checkBlockColourConstants=function(){Blockly.checkBlockColourConstant_("LOGIC_HUE",["Blocks","logic","HUE"],void 0);Blockly.checkBlockColourConstant_("LOGIC_HUE",["Constants","Logic","HUE"],210);Blockly.checkBlockColourConstant_("LOOPS_HUE",["Blocks","loops","HUE"],void 0);Blockly.checkBlockColourConstant_("LOOPS_HUE",["Constants","Loops","HUE"],120);Blockly.checkBlockColourConstant_("MATH_HUE",["Blocks","math","HUE"],void 0);Blockly.checkBlockColourConstant_("MATH_HUE",["Constants","Math",
+"HUE"],230);Blockly.checkBlockColourConstant_("TEXTS_HUE",["Blocks","texts","HUE"],void 0);Blockly.checkBlockColourConstant_("TEXTS_HUE",["Constants","Text","HUE"],160);Blockly.checkBlockColourConstant_("LISTS_HUE",["Blocks","lists","HUE"],void 0);Blockly.checkBlockColourConstant_("LISTS_HUE",["Constants","Lists","HUE"],260);Blockly.checkBlockColourConstant_("COLOUR_HUE",["Blocks","colour","HUE"],void 0);Blockly.checkBlockColourConstant_("COLOUR_HUE",["Constants","Colour","HUE"],20);Blockly.checkBlockColourConstant_("VARIABLES_HUE",
+["Blocks","variables","HUE"],void 0);Blockly.checkBlockColourConstant_("VARIABLES_HUE",["Constants","Variables","HUE"],330);Blockly.checkBlockColourConstant_("VARIABLES_DYNAMIC_HUE",["Constants","VariablesDynamic","HUE"],310);Blockly.checkBlockColourConstant_("PROCEDURES_HUE",["Blocks","procedures","HUE"],void 0)};
+Blockly.checkBlockColourConstant_=function(a,b,c){for(var d="Blockly",e=Blockly,f=0;f<b.length;++f)d+="."+b[f],e&&(e=e[b[f]]);e&&e!==c&&(a=(void 0===c?'%1 has been removed. Use Blockly.Msg["%2"].':'%1 is deprecated and unused. Override Blockly.Msg["%2"].').replace("%1",d).replace("%2",a),console.warn(a))};
+Blockly.setTheme=function(a){this.theme_=a;a=Blockly.getMainWorkspace();this.updateBlockStyles_(a.getAllBlocks().filter(function(a){return void 0!==a.getStyleName()}));!a.toolbox_&&a.flyout_&&a.flyout_.workspace_?this.updateBlockStyles_(a.flyout_.workspace_.getAllBlocks()):a.refreshToolboxSelection();a.toolbox_&&a.toolbox_.updateColourFromTheme();var b=new Blockly.Events.Ui(null,"theme");b.workspaceId=a.id;Blockly.Events.fire(b)};
+Blockly.updateBlockStyles_=function(a){for(var b=0;b<a.length;b++){var c=a[b],d=c.getStyleName();c.setStyle(d);c.mutator&&c.mutator.updateBlockStyle(d)}};Blockly.getTheme=function(){return this.theme_};goog.global.console||(goog.global.console={log:function(){},warn:function(){}});goog.global.Blockly||(goog.global.Blockly={});goog.global.Blockly.getMainWorkspace=Blockly.getMainWorkspace;goog.global.Blockly.addChangeListener=Blockly.addChangeListener;
\ No newline at end of file
diff --git a/_server/blockly/blockly_compressed.min.js b/_server/blockly/blockly_compressed.min.js
deleted file mode 100644
index 8aaa9dcb..00000000
--- a/_server/blockly/blockly_compressed.min.js
+++ /dev/null
@@ -1,342 +0,0 @@
-"use strict";var $jscomp=$jscomp||{};$jscomp.scope={};var COMPILED=!0,goog=goog||{};goog.global=this;goog.isDef=function(a){return void 0!==a};goog.isString=function(a){return"string"==typeof a};goog.isBoolean=function(a){return"boolean"==typeof a};goog.isNumber=function(a){return"number"==typeof a};goog.exportPath_=function(a,b,c){a=a.split(".");c=c||goog.global;a[0] in c||!c.execScript||c.execScript("var "+a[0]);for(var d;a.length&&(d=a.shift());){!a.length&&goog.isDef(b)?c[d]=b:c=c[d]&&c[d]!==Object.prototype[d]?c[d]:c[d]={}}};goog.define=function(a,b){var c=b;COMPILED||(goog.global.CLOSURE_UNCOMPILED_DEFINES&&void 0===goog.global.CLOSURE_UNCOMPILED_DEFINES.nodeType&&Object.prototype.hasOwnProperty.call(goog.global.CLOSURE_UNCOMPILED_DEFINES,a)?c=goog.global.CLOSURE_UNCOMPILED_DEFINES[a]:goog.global.CLOSURE_DEFINES&&void 0===goog.global.CLOSURE_DEFINES.nodeType&&Object.prototype.hasOwnProperty.call(goog.global.CLOSURE_DEFINES,a)&&(c=goog.global.CLOSURE_DEFINES[a]));goog.exportPath_(a,c)};goog.DEBUG=!1;goog.LOCALE="en";goog.TRUSTED_SITE=!0;goog.STRICT_MODE_COMPATIBLE=!1;goog.DISALLOW_TEST_ONLY_CODE=COMPILED&&!goog.DEBUG;goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING=!1;goog.provide=function(a){if(goog.isInModuleLoader_()){throw Error("goog.provide can not be used within a goog.module.")}if(!COMPILED&&goog.isProvided_(a)){throw Error('Namespace "'+a+'" already declared.')}goog.constructNamespace_(a)};goog.constructNamespace_=function(a,b){if(!COMPILED){delete goog.implicitNamespaces_[a];for(var c=a;(c=c.substring(0,c.lastIndexOf(".")))&&!goog.getObjectByName(c);){goog.implicitNamespaces_[c]=!0}}goog.exportPath_(a,b)};goog.VALID_MODULE_RE_=/^[a-zA-Z_$][a-zA-Z0-9._$]*$/;goog.module=function(a){if(!goog.isString(a)||!a||-1==a.search(goog.VALID_MODULE_RE_)){throw Error("Invalid module identifier")}if(!goog.isInModuleLoader_()){throw Error("Module "+a+" has been loaded incorrectly. Note, modules cannot be loaded as normal scripts. They require some kind of pre-processing step. You're likely trying to load a module via a script tag or as a part of a concatenated bundle without rewriting the module. For more info see: https://github.com/google/closure-library/wiki/goog.module:-an-ES6-module-like-alternative-to-goog.provide.")
-}if(goog.moduleLoaderState_.moduleName){throw Error("goog.module may only be called once per module.")}goog.moduleLoaderState_.moduleName=a;if(!COMPILED){if(goog.isProvided_(a)){throw Error('Namespace "'+a+'" already declared.')}delete goog.implicitNamespaces_[a]}};goog.module.get=function(a){return goog.module.getInternal_(a)};goog.module.getInternal_=function(a){if(!COMPILED){if(a in goog.loadedModules_){return goog.loadedModules_[a]}if(!goog.implicitNamespaces_[a]){return a=goog.getObjectByName(a),null!=a?a:null}}return null};goog.moduleLoaderState_=null;goog.isInModuleLoader_=function(){return null!=goog.moduleLoaderState_};goog.module.declareLegacyNamespace=function(){if(!COMPILED&&!goog.isInModuleLoader_()){throw Error("goog.module.declareLegacyNamespace must be called from within a goog.module")}if(!COMPILED&&!goog.moduleLoaderState_.moduleName){throw Error("goog.module must be called prior to goog.module.declareLegacyNamespace.")}goog.moduleLoaderState_.declareLegacyNamespace=!0};goog.setTestOnly=function(a){if(goog.DISALLOW_TEST_ONLY_CODE){throw a=a||"",Error("Importing test-only code into non-debug environment"+(a?": "+a:"."))}};goog.forwardDeclare=function(a){};COMPILED||(goog.isProvided_=function(a){return a in goog.loadedModules_||!goog.implicitNamespaces_[a]&&goog.isDefAndNotNull(goog.getObjectByName(a))},goog.implicitNamespaces_={"goog.module":!0});goog.getObjectByName=function(a,b){for(var c=a.split("."),d=b||goog.global,e=0;e<c.length;e++){if(d=d[c[e]],!goog.isDefAndNotNull(d)){return null}}return d};goog.globalize=function(a,b){var c=b||goog.global,d;for(d in a){c[d]=a[d]}};goog.addDependency=function(a,b,c,d){if(goog.DEPENDENCIES_ENABLED){var e=goog.getLoader_();e&&e.addDependency(a,b,c,d)}};goog.ENABLE_DEBUG_LOADER=!0;goog.logToConsole_=function(a){goog.global.console&&goog.global.console.error(a)};goog.require=function(a){goog.ENABLE_DEBUG_LOADER&&goog.debugLoader_&&goog.getLoader_().earlyProcessLoad(a);if(!COMPILED){if(goog.isProvided_(a)){if(goog.isInModuleLoader_()){return goog.module.getInternal_(a)
-}}else{if(goog.ENABLE_DEBUG_LOADER){var b=goog.moduleLoaderState_;goog.moduleLoaderState_=null;try{var c=goog.getLoader_();c?c.load(a):goog.logToConsole_("Could not load "+a+" because there is no debug loader.")}finally{goog.moduleLoaderState_=b}}}return null}};goog.basePath="";goog.nullFunction=function(){};goog.abstractMethod=function(){throw Error("unimplemented abstract method")};goog.addSingletonGetter=function(a){a.instance_=void 0;a.getInstance=function(){if(a.instance_){return a.instance_}goog.DEBUG&&(goog.instantiatedSingletons_[goog.instantiatedSingletons_.length]=a);return a.instance_=new a}};goog.instantiatedSingletons_=[];goog.LOAD_MODULE_USING_EVAL=!0;goog.SEAL_MODULE_EXPORTS=goog.DEBUG;goog.loadedModules_={};goog.DEPENDENCIES_ENABLED=!COMPILED&&goog.ENABLE_DEBUG_LOADER;goog.TRANSPILE="detect";goog.TRANSPILER="transpile.js";goog.DEBUG_LOADER="";goog.hasBadLetScoping=null;goog.useSafari10Workaround=function(){if(null==goog.hasBadLetScoping){try{var a=!eval('"use strict";let x = 1; function f() { return typeof x; };f() == "number";')}catch(b){a=!1}goog.hasBadLetScoping=a}return goog.hasBadLetScoping};goog.workaroundSafari10EvalBug=function(a){return"(function(){"+a+"\n;})();\n"};goog.loadModule=function(a){var b=goog.moduleLoaderState_;try{goog.moduleLoaderState_={moduleName:void 0,declareLegacyNamespace:!1};if(goog.isFunction(a)){var c=a.call(void 0,{})}else{if(goog.isString(a)){goog.useSafari10Workaround()&&(a=goog.workaroundSafari10EvalBug(a)),c=goog.loadModuleFromSource_.call(void 0,a)}else{throw Error("Invalid module definition")}}var d=goog.moduleLoaderState_.moduleName;if(!goog.isString(d)||!d){throw Error('Invalid module name "'+d+'"')}goog.moduleLoaderState_.declareLegacyNamespace?goog.constructNamespace_(d,c):goog.SEAL_MODULE_EXPORTS&&Object.seal&&"object"==typeof c&&null!=c&&Object.seal(c);goog.loadedModules_[d]=c}finally{goog.moduleLoaderState_=b}};goog.loadModuleFromSource_=function(a){eval(a);return{}};goog.normalizePath_=function(a){a=a.split("/");
-for(var b=0;b<a.length;){"."==a[b]?a.splice(b,1):b&&".."==a[b]&&a[b-1]&&".."!=a[b-1]?a.splice(--b,2):b++}return a.join("/")};goog.loadFileSync_=function(a){if(goog.global.CLOSURE_LOAD_FILE_SYNC){return goog.global.CLOSURE_LOAD_FILE_SYNC(a)}try{var b=new goog.global.XMLHttpRequest;b.open("get",a,!1);b.send();return 0==b.status||200==b.status?b.responseText:null}catch(c){return null}};goog.transpile_=function(a,b){var c=goog.global.$jscomp;c||(goog.global.$jscomp=c={});var d=c.transpile;if(!d){var e=goog.basePath+goog.TRANSPILER,f=goog.loadFileSync_(e);if(f){(function(){eval(f+"\n//# sourceURL="+e)}).call(goog.global);if(goog.global.$gwtExport&&goog.global.$gwtExport.$jscomp&&!goog.global.$gwtExport.$jscomp.transpile){throw Error('The transpiler did not properly export the "transpile" method. $gwtExport: '+JSON.stringify(goog.global.$gwtExport))}goog.global.$jscomp.transpile=goog.global.$gwtExport.$jscomp.transpile;c=goog.global.$jscomp;d=c.transpile}}d||(d=c.transpile=function(a,b){goog.logToConsole_(b+" requires transpilation but no transpiler was found.");return a});return d(a,b)};goog.typeOf=function(a){var b=typeof a;if("object"==b){if(a){if(a instanceof Array){return"array"}if(a instanceof Object){return b}var c=Object.prototype.toString.call(a);if("[object Window]"==c){return"object"}if("[object Array]"==c||"number"==typeof a.length&&"undefined"!=typeof a.splice&&"undefined"!=typeof a.propertyIsEnumerable&&!a.propertyIsEnumerable("splice")){return"array"}if("[object Function]"==c||"undefined"!=typeof a.call&&"undefined"!=typeof a.propertyIsEnumerable&&!a.propertyIsEnumerable("call")){return"function"}}else{return"null"}}else{if("function"==b&&"undefined"==typeof a.call){return"object"}}return b};goog.isNull=function(a){return null===a};goog.isDefAndNotNull=function(a){return null!=a};goog.isArray=function(a){return"array"==goog.typeOf(a)};goog.isArrayLike=function(a){var b=goog.typeOf(a);return"array"==b||"object"==b&&"number"==typeof a.length};goog.isDateLike=function(a){return goog.isObject(a)&&"function"==typeof a.getFullYear
-};goog.isFunction=function(a){return"function"==goog.typeOf(a)};goog.isObject=function(a){var b=typeof a;return"object"==b&&null!=a||"function"==b};goog.getUid=function(a){return a[goog.UID_PROPERTY_]||(a[goog.UID_PROPERTY_]=++goog.uidCounter_)};goog.hasUid=function(a){return !!a[goog.UID_PROPERTY_]};goog.removeUid=function(a){null!==a&&"removeAttribute" in a&&a.removeAttribute(goog.UID_PROPERTY_);try{delete a[goog.UID_PROPERTY_]}catch(b){}};goog.UID_PROPERTY_="closure_uid_"+(1000000000*Math.random()>>>0);goog.uidCounter_=0;goog.getHashCode=goog.getUid;goog.removeHashCode=goog.removeUid;goog.cloneObject=function(a){var b=goog.typeOf(a);if("object"==b||"array"==b){if(a.clone){return a.clone()}b="array"==b?[]:{};for(var c in a){b[c]=goog.cloneObject(a[c])}return b}return a};goog.bindNative_=function(a,b,c){return a.call.apply(a.bind,arguments)};goog.bindJs_=function(a,b,c){if(!a){throw Error()}if(2<arguments.length){var d=Array.prototype.slice.call(arguments,2);return function(){var c=Array.prototype.slice.call(arguments);Array.prototype.unshift.apply(c,d);return a.apply(b,c)}}return function(){return a.apply(b,arguments)}};goog.bind=function(a,b,c){Function.prototype.bind&&-1!=Function.prototype.bind.toString().indexOf("native code")?goog.bind=goog.bindNative_:goog.bind=goog.bindJs_;return goog.bind.apply(null,arguments)};goog.partial=function(a,b){var c=Array.prototype.slice.call(arguments,1);return function(){var b=c.slice();b.push.apply(b,arguments);return a.apply(this,b)}};goog.mixin=function(a,b){for(var c in b){a[c]=b[c]}};goog.now=goog.TRUSTED_SITE&&Date.now||function(){return +new Date};goog.globalEval=function(a){if(goog.global.execScript){goog.global.execScript(a,"JavaScript")}else{if(goog.global.eval){if(null==goog.evalWorksForGlobals_){try{goog.global.eval("var _evalTest_ = 1;")}catch(d){}if("undefined"!=typeof goog.global._evalTest_){try{delete goog.global._evalTest_}catch(d){}goog.evalWorksForGlobals_=!0}else{goog.evalWorksForGlobals_=!1}}if(goog.evalWorksForGlobals_){goog.global.eval(a)
-}else{var b=goog.global.document,c=b.createElement("SCRIPT");c.type="text/javascript";c.defer=!1;c.appendChild(b.createTextNode(a));b.head.appendChild(c);b.head.removeChild(c)}}else{throw Error("goog.globalEval not available")}}};goog.evalWorksForGlobals_=null;goog.getCssName=function(a,b){if("."==String(a).charAt(0)){throw Error('className passed in goog.getCssName must not start with ".". You passed: '+a)}var c=function(a){return goog.cssNameMapping_[a]||a},d=function(a){a=a.split("-");for(var b=[],d=0;d<a.length;d++){b.push(c(a[d]))}return b.join("-")};d=goog.cssNameMapping_?"BY_WHOLE"==goog.cssNameMappingStyle_?c:d:function(a){return a};d=b?a+"-"+d(b):d(a);return goog.global.CLOSURE_CSS_NAME_MAP_FN?goog.global.CLOSURE_CSS_NAME_MAP_FN(d):d};goog.setCssNameMapping=function(a,b){goog.cssNameMapping_=a;goog.cssNameMappingStyle_=b};!COMPILED&&goog.global.CLOSURE_CSS_NAME_MAPPING&&(goog.cssNameMapping_=goog.global.CLOSURE_CSS_NAME_MAPPING);goog.getMsg=function(a,b){b&&(a=a.replace(/\{\$([^}]+)}/g,function(a,d){return null!=b&&d in b?b[d]:a}));return a};goog.getMsgWithFallback=function(a,b){return a};goog.exportSymbol=function(a,b,c){goog.exportPath_(a,b,c)};goog.exportProperty=function(a,b,c){a[b]=c};goog.inherits=function(a,b){function c(){}c.prototype=b.prototype;a.superClass_=b.prototype;a.prototype=new c;a.prototype.constructor=a;a.base=function(a,c,f){for(var d=Array(arguments.length-2),e=2;e<arguments.length;e++){d[e-2]=arguments[e]}return b.prototype[c].apply(a,d)}};goog.base=function(a,b,c){var d=arguments.callee.caller;if(goog.STRICT_MODE_COMPATIBLE||goog.DEBUG&&!d){throw Error("arguments.caller not defined.  goog.base() cannot be used with strict mode code. See http://www.ecma-international.org/ecma-262/5.1/#sec-C")}if(d.superClass_){for(var e=Array(arguments.length-1),f=1;f<arguments.length;f++){e[f-1]=arguments[f]}return d.superClass_.constructor.apply(a,e)}e=Array(arguments.length-2);for(f=2;f<arguments.length;f++){e[f-2]=arguments[f]}f=!1;for(var g=a.constructor;
-g;g=g.superClass_&&g.superClass_.constructor){if(g.prototype[b]===d){f=!0}else{if(f){return g.prototype[b].apply(a,e)}}}if(a[b]===d){return a.constructor.prototype[b].apply(a,e)}throw Error("goog.base called from a method of one name to a method of a different name")};goog.scope=function(a){if(goog.isInModuleLoader_()){throw Error("goog.scope is not supported within a goog.module.")}a.call(goog.global)};COMPILED||(goog.global.COMPILED=COMPILED);goog.defineClass=function(a,b){var c=b.constructor,d=b.statics;c&&c!=Object.prototype.constructor||(c=function(){throw Error("cannot instantiate an interface (no constructor defined).")});c=goog.defineClass.createSealingConstructor_(c,a);a&&goog.inherits(c,a);delete b.constructor;delete b.statics;goog.defineClass.applyProperties_(c.prototype,b);null!=d&&(d instanceof Function?d(c):goog.defineClass.applyProperties_(c,d));return c};goog.defineClass.SEAL_CLASS_INSTANCES=goog.DEBUG;goog.defineClass.createSealingConstructor_=function(a,b){if(!goog.defineClass.SEAL_CLASS_INSTANCES){return a}var c=!goog.defineClass.isUnsealable_(b),d=function(){var b=a.apply(this,arguments)||this;b[goog.UID_PROPERTY_]=b[goog.UID_PROPERTY_];this.constructor===d&&c&&Object.seal instanceof Function&&Object.seal(b);return b};return d};goog.defineClass.isUnsealable_=function(a){return a&&a.prototype&&a.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_]};goog.defineClass.OBJECT_PROTOTYPE_FIELDS_="constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf".split(" ");goog.defineClass.applyProperties_=function(a,b){for(var c in b){Object.prototype.hasOwnProperty.call(b,c)&&(a[c]=b[c])}for(var d=0;d<goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length;d++){c=goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[d],Object.prototype.hasOwnProperty.call(b,c)&&(a[c]=b[c])}};goog.tagUnsealableClass=function(a){!COMPILED&&goog.defineClass.SEAL_CLASS_INSTANCES&&(a.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_]=!0)};goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_="goog_defineClass_legacy_unsealable";
-goog.DEPENDENCIES_ENABLED&&(goog.inHtmlDocument_=function(){var a=goog.global.document;return null!=a&&"write" in a},goog.findBasePath_=function(){if(goog.isDef(goog.global.CLOSURE_BASE_PATH)&&goog.isString(goog.global.CLOSURE_BASE_PATH)){goog.basePath=goog.global.CLOSURE_BASE_PATH}else{if(goog.inHtmlDocument_()){var a=goog.global.document,b=a.currentScript;a=b?[b]:a.getElementsByTagName("SCRIPT");for(b=a.length-1;0<=b;--b){var c=a[b].src,d=c.lastIndexOf("?");d=-1==d?c.length:d;if("base.js"==c.substr(d-7,7)){goog.basePath=c.substr(0,d-7);break}}}}},goog.findBasePath_(),goog.Transpiler=function(){this.requiresTranspilation_=null},goog.Transpiler.prototype.createRequiresTranspilation_=function(){function a(a,b){d?c[a]=!0:b()?c[a]=!1:d=c[a]=!0}function b(a){try{return !!eval(a)}catch(g){return !1}}var c={es3:!1},d=!1,e=goog.global.navigator&&goog.global.navigator.userAgent?goog.global.navigator.userAgent:"";a("es5",function(){return b("[1,].length==1")});a("es6",function(){var a=e.match(/Edge\/(\d+)(\.\d)*/i);return a&&15>Number(a[1])?!1:b('(()=>{"use strict";class X{constructor(){if(new.target!=String)throw 1;this.x=42}}let q=Reflect.construct(X,[],String);if(q.x!=42||!(q instanceof String))throw 1;for(const a of[2,3]){if(a==2)continue;function f(z={a}){let a=0;return z.a}{function f(){return 0;}}return f()==3}})()')});a("es6-impl",function(){return !0});a("es7",function(){return b("2 ** 2 == 4")});a("es8",function(){return b("async () => 1, true")});return c},goog.Transpiler.prototype.needsTranspile=function(a){if("always"==goog.TRANSPILE){return !0}if("never"==goog.TRANSPILE){return !1}this.requiresTranspilation_||(this.requiresTranspilation_=this.createRequiresTranspilation_());if(a in this.requiresTranspilation_){return this.requiresTranspilation_[a]}throw Error("Unknown language mode: "+a)},goog.Transpiler.prototype.transpile=function(a,b){return goog.transpile_(a,b)},goog.transpiler_=new goog.Transpiler,goog.DebugLoader=function(){this.dependencies_={loadFlags:{},nameToPath:{},requires:{},visited:{},written:{},deferred:{}};
-this.oldIeWaiting_=!1;this.queuedModules_=[];this.lastNonModuleScriptIndex_=0},goog.DebugLoader.IS_OLD_IE_=!(goog.global.atob||!goog.global.document||!goog.global.document.all),goog.DebugLoader.prototype.earlyProcessLoad=function(a){goog.DebugLoader.IS_OLD_IE_&&this.maybeProcessDeferredDep_(a)},goog.DebugLoader.prototype.load=function(a){var b=this.getPathFromDeps_(a);if(b){var c=function(a){if(!(a in f.written||a in f.visited)){f.visited[a]=!0;if(a in f.requires){for(var b in f.requires[a]){if(!g.isProvided(b)){if(b in f.nameToPath){c(f.nameToPath[b])}else{throw Error("Undefined nameToPath for "+b)}}}}a in e||(e[a]=!0,d.push(a))}},d=[],e={},f=this.dependencies_,g=this;c(b);for(a=0;a<d.length;a++){b=d[a],this.dependencies_.written[b]=!0}for(a=0;a<d.length;a++){if(b=d[a]){var h=f.loadFlags[b]||{},k=h.lang||"es3";k=this.getTranspiler().needsTranspile(k);"goog"==h.module||k?this.importProcessedScript_(goog.basePath+b,"goog"==h.module,k):this.importScript_(goog.basePath+b)}else{throw Error("Undefined script input")}}}else{throw a="goog.require could not find: "+a,this.logToConsole(a),Error(a)}},goog.DebugLoader.prototype.addDependency=function(a,b,c,d){var e;a=a.replace(/\\/g,"/");var f=this.dependencies_;d&&"boolean"!==typeof d||(d=d?{module:"goog"}:{});for(var g=0;e=b[g];g++){f.nameToPath[e]=a,f.loadFlags[a]=d}for(d=0;b=c[d];d++){a in f.requires||(f.requires[a]={}),f.requires[a][b]=!0}},goog.DebugLoader.prototype.importScript_=function(a,b){(goog.global.CLOSURE_IMPORT_SCRIPT||goog.bind(this.writeScriptTag_,this))(a,b)&&(this.dependencies_.written[a]=!0)},goog.DebugLoader.prototype.importProcessedScript_=function(a,b,c){this.importScript_("",'goog.debugLoader_.retrieveAndExec_("'+a+'", '+b+", "+c+");")},goog.DebugLoader.prototype.retrieveAndExec_=function(a,b,c){if(!COMPILED){var d=a;a=this.normalizePath(a);var e=goog.global.CLOSURE_IMPORT_SCRIPT||goog.bind(this.writeScriptTag_,this),f=this.loadFileSync(a);if(null==f){throw Error('Load of "'+a+'" failed')}c&&(f=this.getTranspiler().transpile(f,a));
-f=b?this.wrapModule_(a,f):f+("\n//# sourceURL="+a);goog.DebugLoader.IS_OLD_IE_&&this.oldIeWaiting_?(this.dependencies_.deferred[d]=f,this.queuedModules_.push(d)):e(a,f)}},goog.DebugLoader.prototype.wrapModule_=function(a,b){return goog.LOAD_MODULE_USING_EVAL&&goog.isDef(goog.global.JSON)?"goog.loadModule("+goog.global.JSON.stringify(b+"\n//# sourceURL="+a+"\n")+");":'goog.loadModule(function(exports) {"use strict";'+b+"\n;return exports});\n//# sourceURL="+a+"\n"},goog.DebugLoader.prototype.loadQueuedModules_=function(){var a=this.queuedModules_.length;if(0<a){var b=this.queuedModules_;this.queuedModules_=[];for(var c=0;c<a;c++){this.maybeProcessDeferredPath_(b[c])}}this.oldIeWaiting_=!1},goog.DebugLoader.prototype.maybeProcessDeferredDep_=function(a){this.isDeferredModule_(a)&&this.allDepsAreAvailable_(a)&&(a=this.getPathFromDeps_(a),this.maybeProcessDeferredPath_(goog.basePath+a))},goog.DebugLoader.prototype.isDeferredModule_=function(a){var b=(a=this.getPathFromDeps_(a))&&this.dependencies_.loadFlags[a]||{},c=b.lang||"es3";return a&&("goog"==b.module||this.getTranspiler().needsTranspile(c))?goog.basePath+a in this.dependencies_.deferred:!1},goog.DebugLoader.prototype.allDepsAreAvailable_=function(a){if((a=this.getPathFromDeps_(a))&&a in this.dependencies_.requires){for(var b in this.dependencies_.requires[a]){if(!this.isProvided(b)&&!this.isDeferredModule_(b)){return !1}}}return !0},goog.DebugLoader.prototype.maybeProcessDeferredPath_=function(a){if(a in this.dependencies_.deferred){var b=this.dependencies_.deferred[a];delete this.dependencies_.deferred[a];goog.globalEval(b)}},goog.DebugLoader.prototype.writeScriptSrcNode_=function(a){goog.global.document.write('<script type="text/javascript" src="'+a+'">\x3c/script>')},goog.DebugLoader.prototype.appendScriptSrcNode_=function(a){var b=goog.global.document,c=b.createElement("script");c.type="text/javascript";c.src=a;c.defer=!1;c.async=!1;b.head.appendChild(c)},goog.DebugLoader.prototype.writeScriptTag_=function(a,b){if(this.inHtmlDocument()){var c=goog.global.document;
-if(!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING&&"complete"==c.readyState){if(/\bdeps.js$/.test(a)){return !1}throw Error('Cannot write "'+a+'" after document load')}if(void 0===b){if(goog.DebugLoader.IS_OLD_IE_){this.oldIeWaiting_=!0;var d=" onreadystatechange='goog.debugLoader_.onScriptLoad_(this, "+ ++this.lastNonModuleScriptIndex_+")' ";c.write('<script type="text/javascript" src="'+a+'"'+d+">\x3c/script>")}else{goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING?this.appendScriptSrcNode_(a):this.writeScriptSrcNode_(a)}}else{c.write('<script type="text/javascript">'+this.protectScriptTag_(b)+"\x3c/script>")}return !0}return !1},goog.DebugLoader.prototype.protectScriptTag_=function(a){return a.replace(/<\/(SCRIPT)/ig,"\\x3c/$1")},goog.DebugLoader.prototype.onScriptLoad_=function(a,b){"complete"==a.readyState&&this.lastNonModuleScriptIndex_==b&&this.loadQueuedModules_();return !0},goog.DebugLoader.prototype.getPathFromDeps_=function(a){return a in this.dependencies_.nameToPath?this.dependencies_.nameToPath[a]:null},goog.DebugLoader.prototype.getTranspiler=function(){return goog.transpiler_},goog.DebugLoader.prototype.isProvided=function(a){return goog.isProvided_(a)},goog.DebugLoader.prototype.inHtmlDocument=function(){return goog.inHtmlDocument_()},goog.DebugLoader.prototype.logToConsole=function(a){goog.logToConsole_(a)},goog.DebugLoader.prototype.loadFileSync=function(a){return goog.loadFileSync_(a)},goog.DebugLoader.prototype.normalizePath=function(a){return goog.normalizePath_(a)},goog.debugLoader_=null,goog.registerDebugLoader=function(a){if(goog.debugLoader_){throw Error("Debug loader already registered!")}if(!(a instanceof goog.DebugLoader)){throw Error("Not a goog.DebugLoader.")}goog.debugLoader_=a},goog.getLoader_=function(){if(!goog.debugLoader_&&goog.DEBUG_LOADER){throw Error("Loaded debug loader file but no loader was registered!")}goog.debugLoader_||(goog.debugLoader_=new goog.DebugLoader);return goog.debugLoader_},function(){if(goog.DEBUG_LOADER){var a=new goog.DebugLoader;
-a.importScript_(goog.basePath+goog.DEBUG_LOADER)}goog.global.CLOSURE_NO_DEPS||(a=a||new goog.DebugLoader,goog.DEBUG_LOADER||goog.registerDebugLoader(a),a.importScript_(goog.basePath+"deps.js"))}());goog.debug={};goog.debug.Error=function(a){if(Error.captureStackTrace){Error.captureStackTrace(this,goog.debug.Error)}else{var b=Error().stack;b&&(this.stack=b)}a&&(this.message=String(a));this.reportErrorToServer=!0};goog.inherits(goog.debug.Error,Error);goog.debug.Error.prototype.name="CustomError";goog.dom={};goog.dom.NodeType={ELEMENT:1,ATTRIBUTE:2,TEXT:3,CDATA_SECTION:4,ENTITY_REFERENCE:5,ENTITY:6,PROCESSING_INSTRUCTION:7,COMMENT:8,DOCUMENT:9,DOCUMENT_TYPE:10,DOCUMENT_FRAGMENT:11,NOTATION:12};goog.asserts={};goog.asserts.ENABLE_ASSERTS=goog.DEBUG;goog.asserts.AssertionError=function(a,b){goog.debug.Error.call(this,goog.asserts.subs_(a,b));this.messagePattern=a};goog.inherits(goog.asserts.AssertionError,goog.debug.Error);goog.asserts.AssertionError.prototype.name="AssertionError";goog.asserts.DEFAULT_ERROR_HANDLER=function(a){throw a};goog.asserts.errorHandler_=goog.asserts.DEFAULT_ERROR_HANDLER;goog.asserts.subs_=function(a,b){for(var c=a.split("%s"),d="",e=c.length-1,f=0;f<e;f++){d+=c[f]+(f<b.length?b[f]:"%s")}return d+c[e]};goog.asserts.doAssertFailure_=function(a,b,c,d){var e="Assertion failed";if(c){e+=": "+c;var f=d}else{a&&(e+=": "+a,f=b)}a=new goog.asserts.AssertionError(""+e,f||[]);goog.asserts.errorHandler_(a)};goog.asserts.setErrorHandler=function(a){goog.asserts.ENABLE_ASSERTS&&(goog.asserts.errorHandler_=a)};goog.asserts.assert=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!a&&goog.asserts.doAssertFailure_("",null,b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.fail=function(a,b){goog.asserts.ENABLE_ASSERTS&&goog.asserts.errorHandler_(new goog.asserts.AssertionError("Failure"+(a?": "+a:""),Array.prototype.slice.call(arguments,1)))};goog.asserts.assertNumber=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!goog.isNumber(a)&&goog.asserts.doAssertFailure_("Expected number but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));
-return a};goog.asserts.assertString=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!goog.isString(a)&&goog.asserts.doAssertFailure_("Expected string but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.assertFunction=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!goog.isFunction(a)&&goog.asserts.doAssertFailure_("Expected function but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.assertObject=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!goog.isObject(a)&&goog.asserts.doAssertFailure_("Expected object but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.assertArray=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!goog.isArray(a)&&goog.asserts.doAssertFailure_("Expected array but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.assertBoolean=function(a,b,c){goog.asserts.ENABLE_ASSERTS&&!goog.isBoolean(a)&&goog.asserts.doAssertFailure_("Expected boolean but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.assertElement=function(a,b,c){!goog.asserts.ENABLE_ASSERTS||goog.isObject(a)&&a.nodeType==goog.dom.NodeType.ELEMENT||goog.asserts.doAssertFailure_("Expected Element but got %s: %s.",[goog.typeOf(a),a],b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.assertInstanceof=function(a,b,c,d){!goog.asserts.ENABLE_ASSERTS||a instanceof b||goog.asserts.doAssertFailure_("Expected instanceof %s but got %s.",[goog.asserts.getType_(b),goog.asserts.getType_(a)],c,Array.prototype.slice.call(arguments,3));return a};goog.asserts.assertFinite=function(a,b,c){!goog.asserts.ENABLE_ASSERTS||"number"==typeof a&&isFinite(a)||goog.asserts.doAssertFailure_("Expected %s to be a finite number but it is not.",[a],b,Array.prototype.slice.call(arguments,2));return a};goog.asserts.assertObjectPrototypeIsIntact=function(){for(var a in Object.prototype){goog.asserts.fail(a+" should not be enumerable in Object.prototype.")
-}};goog.asserts.getType_=function(a){return a instanceof Function?a.displayName||a.name||"unknown type name":a instanceof Object?a.constructor.displayName||a.constructor.name||Object.prototype.toString.call(a):null===a?"null":typeof a};goog.array={};goog.NATIVE_ARRAY_PROTOTYPES=goog.TRUSTED_SITE;goog.array.ASSUME_NATIVE_FUNCTIONS=!1;goog.array.peek=function(a){return a[a.length-1]};goog.array.last=goog.array.peek;goog.array.indexOf=goog.NATIVE_ARRAY_PROTOTYPES&&(goog.array.ASSUME_NATIVE_FUNCTIONS||Array.prototype.indexOf)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.indexOf.call(a,b,c)}:function(a,b,c){c=null==c?0:0>c?Math.max(0,a.length+c):c;if(goog.isString(a)){return goog.isString(b)&&1==b.length?a.indexOf(b,c):-1}for(;c<a.length;c++){if(c in a&&a[c]===b){return c}}return -1};goog.array.lastIndexOf=goog.NATIVE_ARRAY_PROTOTYPES&&(goog.array.ASSUME_NATIVE_FUNCTIONS||Array.prototype.lastIndexOf)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.lastIndexOf.call(a,b,null==c?a.length-1:c)}:function(a,b,c){c=null==c?a.length-1:c;0>c&&(c=Math.max(0,a.length+c));if(goog.isString(a)){return goog.isString(b)&&1==b.length?a.lastIndexOf(b,c):-1}for(;0<=c;c--){if(c in a&&a[c]===b){return c}}return -1};goog.array.forEach=goog.NATIVE_ARRAY_PROTOTYPES&&(goog.array.ASSUME_NATIVE_FUNCTIONS||Array.prototype.forEach)?function(a,b,c){goog.asserts.assert(null!=a.length);Array.prototype.forEach.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=goog.isString(a)?a.split(""):a,f=0;f<d;f++){f in e&&b.call(c,e[f],f,a)}};goog.array.forEachRight=function(a,b,c){var d=a.length,e=goog.isString(a)?a.split(""):a;for(--d;0<=d;--d){d in e&&b.call(c,e[d],d,a)}};goog.array.filter=goog.NATIVE_ARRAY_PROTOTYPES&&(goog.array.ASSUME_NATIVE_FUNCTIONS||Array.prototype.filter)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.filter.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=[],f=0,g=goog.isString(a)?a.split(""):a,h=0;h<d;h++){if(h in g){var k=g[h];
-b.call(c,k,h,a)&&(e[f++]=k)}}return e};goog.array.map=goog.NATIVE_ARRAY_PROTOTYPES&&(goog.array.ASSUME_NATIVE_FUNCTIONS||Array.prototype.map)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.map.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=Array(d),f=goog.isString(a)?a.split(""):a,g=0;g<d;g++){g in f&&(e[g]=b.call(c,f[g],g,a))}return e};goog.array.reduce=goog.NATIVE_ARRAY_PROTOTYPES&&(goog.array.ASSUME_NATIVE_FUNCTIONS||Array.prototype.reduce)?function(a,b,c,d){goog.asserts.assert(null!=a.length);d&&(b=goog.bind(b,d));return Array.prototype.reduce.call(a,b,c)}:function(a,b,c,d){var e=c;goog.array.forEach(a,function(c,g){e=b.call(d,e,c,g,a)});return e};goog.array.reduceRight=goog.NATIVE_ARRAY_PROTOTYPES&&(goog.array.ASSUME_NATIVE_FUNCTIONS||Array.prototype.reduceRight)?function(a,b,c,d){goog.asserts.assert(null!=a.length);goog.asserts.assert(null!=b);d&&(b=goog.bind(b,d));return Array.prototype.reduceRight.call(a,b,c)}:function(a,b,c,d){var e=c;goog.array.forEachRight(a,function(c,g){e=b.call(d,e,c,g,a)});return e};goog.array.some=goog.NATIVE_ARRAY_PROTOTYPES&&(goog.array.ASSUME_NATIVE_FUNCTIONS||Array.prototype.some)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.some.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=goog.isString(a)?a.split(""):a,f=0;f<d;f++){if(f in e&&b.call(c,e[f],f,a)){return !0}}return !1};goog.array.every=goog.NATIVE_ARRAY_PROTOTYPES&&(goog.array.ASSUME_NATIVE_FUNCTIONS||Array.prototype.every)?function(a,b,c){goog.asserts.assert(null!=a.length);return Array.prototype.every.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=goog.isString(a)?a.split(""):a,f=0;f<d;f++){if(f in e&&!b.call(c,e[f],f,a)){return !1}}return !0};goog.array.count=function(a,b,c){var d=0;goog.array.forEach(a,function(a,f,g){b.call(c,a,f,g)&&++d},c);return d};goog.array.find=function(a,b,c){b=goog.array.findIndex(a,b,c);return 0>b?null:goog.isString(a)?a.charAt(b):a[b]};goog.array.findIndex=function(a,b,c){for(var d=a.length,e=goog.isString(a)?a.split(""):a,f=0;
-f<d;f++){if(f in e&&b.call(c,e[f],f,a)){return f}}return -1};goog.array.findRight=function(a,b,c){b=goog.array.findIndexRight(a,b,c);return 0>b?null:goog.isString(a)?a.charAt(b):a[b]};goog.array.findIndexRight=function(a,b,c){var d=a.length,e=goog.isString(a)?a.split(""):a;for(--d;0<=d;d--){if(d in e&&b.call(c,e[d],d,a)){return d}}return -1};goog.array.contains=function(a,b){return 0<=goog.array.indexOf(a,b)};goog.array.isEmpty=function(a){return 0==a.length};goog.array.clear=function(a){if(!goog.isArray(a)){for(var b=a.length-1;0<=b;b--){delete a[b]}}a.length=0};goog.array.insert=function(a,b){goog.array.contains(a,b)||a.push(b)};goog.array.insertAt=function(a,b,c){goog.array.splice(a,c,0,b)};goog.array.insertArrayAt=function(a,b,c){goog.partial(goog.array.splice,a,c,0).apply(null,b)};goog.array.insertBefore=function(a,b,c){var d;2==arguments.length||0>(d=goog.array.indexOf(a,c))?a.push(b):goog.array.insertAt(a,b,d)};goog.array.remove=function(a,b){var c=goog.array.indexOf(a,b),d;(d=0<=c)&&goog.array.removeAt(a,c);return d};goog.array.removeLast=function(a,b){var c=goog.array.lastIndexOf(a,b);return 0<=c?(goog.array.removeAt(a,c),!0):!1};goog.array.removeAt=function(a,b){goog.asserts.assert(null!=a.length);return 1==Array.prototype.splice.call(a,b,1).length};goog.array.removeIf=function(a,b,c){b=goog.array.findIndex(a,b,c);return 0<=b?(goog.array.removeAt(a,b),!0):!1};goog.array.removeAllIf=function(a,b,c){var d=0;goog.array.forEachRight(a,function(e,f){b.call(c,e,f,a)&&goog.array.removeAt(a,f)&&d++});return d};goog.array.concat=function(a){return Array.prototype.concat.apply([],arguments)};goog.array.join=function(a){return Array.prototype.concat.apply([],arguments)};goog.array.toArray=function(a){var b=a.length;if(0<b){for(var c=Array(b),d=0;d<b;d++){c[d]=a[d]}return c}return[]};goog.array.clone=goog.array.toArray;goog.array.extend=function(a,b){for(var c=1;c<arguments.length;c++){var d=arguments[c];if(goog.isArrayLike(d)){var e=a.length||0,f=d.length||0;a.length=e+f;
-for(var g=0;g<f;g++){a[e+g]=d[g]}}else{a.push(d)}}};goog.array.splice=function(a,b,c,d){goog.asserts.assert(null!=a.length);return Array.prototype.splice.apply(a,goog.array.slice(arguments,1))};goog.array.slice=function(a,b,c){goog.asserts.assert(null!=a.length);return 2>=arguments.length?Array.prototype.slice.call(a,b):Array.prototype.slice.call(a,b,c)};goog.array.removeDuplicates=function(a,b,c){b=b||a;var d=function(a){return goog.isObject(a)?"o"+goog.getUid(a):(typeof a).charAt(0)+a};c=c||d;d={};for(var e=0,f=0;f<a.length;){var g=a[f++],h=c(g);Object.prototype.hasOwnProperty.call(d,h)||(d[h]=!0,b[e++]=g)}b.length=e};goog.array.binarySearch=function(a,b,c){return goog.array.binarySearch_(a,c||goog.array.defaultCompare,!1,b)};goog.array.binarySelect=function(a,b,c){return goog.array.binarySearch_(a,b,!0,void 0,c)};goog.array.binarySearch_=function(a,b,c,d,e){for(var f=0,g=a.length,h;f<g;){var k=f+g>>1;var n=c?b.call(e,a[k],k,a):b(d,a[k]);0<n?f=k+1:(g=k,h=!n)}return h?f:~f};goog.array.sort=function(a,b){a.sort(b||goog.array.defaultCompare)};goog.array.stableSort=function(a,b){for(var c=Array(a.length),d=0;d<a.length;d++){c[d]={index:d,value:a[d]}}var e=b||goog.array.defaultCompare;goog.array.sort(c,function(a,b){return e(a.value,b.value)||a.index-b.index});for(d=0;d<a.length;d++){a[d]=c[d].value}};goog.array.sortByKey=function(a,b,c){var d=c||goog.array.defaultCompare;goog.array.sort(a,function(a,c){return d(b(a),b(c))})};goog.array.sortObjectsByKey=function(a,b,c){goog.array.sortByKey(a,function(a){return a[b]},c)};goog.array.isSorted=function(a,b,c){b=b||goog.array.defaultCompare;for(var d=1;d<a.length;d++){var e=b(a[d-1],a[d]);if(0<e||0==e&&c){return !1}}return !0};goog.array.equals=function(a,b,c){if(!goog.isArrayLike(a)||!goog.isArrayLike(b)||a.length!=b.length){return !1}var d=a.length;c=c||goog.array.defaultCompareEquality;for(var e=0;e<d;e++){if(!c(a[e],b[e])){return !1}}return !0};goog.array.compare3=function(a,b,c){c=c||goog.array.defaultCompare;for(var d=Math.min(a.length,b.length),e=0;
-e<d;e++){var f=c(a[e],b[e]);if(0!=f){return f}}return goog.array.defaultCompare(a.length,b.length)};goog.array.defaultCompare=function(a,b){return a>b?1:a<b?-1:0};goog.array.inverseDefaultCompare=function(a,b){return -goog.array.defaultCompare(a,b)};goog.array.defaultCompareEquality=function(a,b){return a===b};goog.array.binaryInsert=function(a,b,c){c=goog.array.binarySearch(a,b,c);return 0>c?(goog.array.insertAt(a,b,-(c+1)),!0):!1};goog.array.binaryRemove=function(a,b,c){b=goog.array.binarySearch(a,b,c);return 0<=b?goog.array.removeAt(a,b):!1};goog.array.bucket=function(a,b,c){for(var d={},e=0;e<a.length;e++){var f=a[e],g=b.call(c,f,e,a);goog.isDef(g)&&(d[g]||(d[g]=[])).push(f)}return d};goog.array.toObject=function(a,b,c){var d={};goog.array.forEach(a,function(e,f){d[b.call(c,e,f,a)]=e});return d};goog.array.range=function(a,b,c){var d=[],e=0,f=a;c=c||1;void 0!==b&&(e=a,f=b);if(0>c*(f-e)){return[]}if(0<c){for(a=e;a<f;a+=c){d.push(a)}}else{for(a=e;a>f;a+=c){d.push(a)}}return d};goog.array.repeat=function(a,b){for(var c=[],d=0;d<b;d++){c[d]=a}return c};goog.array.flatten=function(a){for(var b=[],c=0;c<arguments.length;c++){var d=arguments[c];if(goog.isArray(d)){for(var e=0;e<d.length;e+=8192){var f=goog.array.slice(d,e,e+8192);f=goog.array.flatten.apply(null,f);for(var g=0;g<f.length;g++){b.push(f[g])}}}else{b.push(d)}}return b};goog.array.rotate=function(a,b){goog.asserts.assert(null!=a.length);a.length&&(b%=a.length,0<b?Array.prototype.unshift.apply(a,a.splice(-b,b)):0>b&&Array.prototype.push.apply(a,a.splice(0,-b)));return a};goog.array.moveItem=function(a,b,c){goog.asserts.assert(0<=b&&b<a.length);goog.asserts.assert(0<=c&&c<a.length);b=Array.prototype.splice.call(a,b,1);Array.prototype.splice.call(a,c,0,b[0])};goog.array.zip=function(a){if(!arguments.length){return[]}for(var b=[],c=arguments[0].length,d=1;d<arguments.length;d++){arguments[d].length<c&&(c=arguments[d].length)}for(d=0;d<c;d++){for(var e=[],f=0;f<arguments.length;f++){e.push(arguments[f][d])}b.push(e)
-}return b};goog.array.shuffle=function(a,b){for(var c=b||Math.random,d=a.length-1;0<d;d--){var e=Math.floor(c()*(d+1)),f=a[d];a[d]=a[e];a[e]=f}};goog.array.copyByIndex=function(a,b){var c=[];goog.array.forEach(b,function(b){c.push(a[b])});return c};goog.array.concatMap=function(a,b,c){return goog.array.concat.apply([],goog.array.map(a,b,c))};goog.math={};goog.math.randomInt=function(a){return Math.floor(Math.random()*a)};goog.math.uniformRandom=function(a,b){return a+Math.random()*(b-a)};goog.math.clamp=function(a,b,c){return Math.min(Math.max(a,b),c)};goog.math.modulo=function(a,b){var c=a%b;return 0>c*b?c+b:c};goog.math.lerp=function(a,b,c){return a+c*(b-a)};goog.math.nearlyEquals=function(a,b,c){return Math.abs(a-b)<=(c||0.000001)};goog.math.standardAngle=function(a){return goog.math.modulo(a,360)};goog.math.standardAngleInRadians=function(a){return goog.math.modulo(a,2*Math.PI)};goog.math.toRadians=function(a){return a*Math.PI/180};goog.math.toDegrees=function(a){return 180*a/Math.PI};goog.math.angleDx=function(a,b){return b*Math.cos(goog.math.toRadians(a))};goog.math.angleDy=function(a,b){return b*Math.sin(goog.math.toRadians(a))};goog.math.angle=function(a,b,c,d){return goog.math.standardAngle(goog.math.toDegrees(Math.atan2(d-b,c-a)))};goog.math.angleDifference=function(a,b){var c=goog.math.standardAngle(b)-goog.math.standardAngle(a);180<c?c-=360:-180>=c&&(c=360+c);return c};goog.math.sign=function(a){return 0<a?1:0>a?-1:a};goog.math.longestCommonSubsequence=function(a,b,c,d){c=c||function(a,b){return a==b};d=d||function(b,c){return a[b]};for(var e=a.length,f=b.length,g=[],h=0;h<e+1;h++){g[h]=[],g[h][0]=0}for(var k=0;k<f+1;k++){g[0][k]=0}for(h=1;h<=e;h++){for(k=1;k<=f;k++){c(a[h-1],b[k-1])?g[h][k]=g[h-1][k-1]+1:g[h][k]=Math.max(g[h-1][k],g[h][k-1])}}var n=[];h=e;for(k=f;0<h&&0<k;){c(a[h-1],b[k-1])?(n.unshift(d(h-1,k-1)),h--,k--):g[h-1][k]>g[h][k-1]?h--:k--}return n};goog.math.sum=function(a){return goog.array.reduce(arguments,function(a,c){return a+c},0)};goog.math.average=function(a){return goog.math.sum.apply(null,arguments)/arguments.length
-};goog.math.sampleVariance=function(a){var b=arguments.length;if(2>b){return 0}var c=goog.math.average.apply(null,arguments);return goog.math.sum.apply(null,goog.array.map(arguments,function(a){return Math.pow(a-c,2)}))/(b-1)};goog.math.standardDeviation=function(a){return Math.sqrt(goog.math.sampleVariance.apply(null,arguments))};goog.math.isInt=function(a){return isFinite(a)&&0==a%1};goog.math.isFiniteNumber=function(a){return isFinite(a)};goog.math.isNegativeZero=function(a){return 0==a&&0>1/a};goog.math.log10Floor=function(a){if(0<a){var b=Math.round(Math.log(a)*Math.LOG10E);return b-(parseFloat("1e"+b)>a?1:0)}return 0==a?-Infinity:NaN};goog.math.safeFloor=function(a,b){goog.asserts.assert(!goog.isDef(b)||0<b);return Math.floor(a+(b||2e-15))};goog.math.safeCeil=function(a,b){goog.asserts.assert(!goog.isDef(b)||0<b);return Math.ceil(a-(b||2e-15))};goog.math.Coordinate=function(a,b){this.x=goog.isDef(a)?a:0;this.y=goog.isDef(b)?b:0};goog.math.Coordinate.prototype.clone=function(){return new goog.math.Coordinate(this.x,this.y)};goog.DEBUG&&(goog.math.Coordinate.prototype.toString=function(){return"("+this.x+", "+this.y+")"});goog.math.Coordinate.prototype.equals=function(a){return a instanceof goog.math.Coordinate&&goog.math.Coordinate.equals(this,a)};goog.math.Coordinate.equals=function(a,b){return a==b?!0:a&&b?a.x==b.x&&a.y==b.y:!1};goog.math.Coordinate.distance=function(a,b){var c=a.x-b.x,d=a.y-b.y;return Math.sqrt(c*c+d*d)};goog.math.Coordinate.magnitude=function(a){return Math.sqrt(a.x*a.x+a.y*a.y)};goog.math.Coordinate.azimuth=function(a){return goog.math.angle(0,0,a.x,a.y)};goog.math.Coordinate.squaredDistance=function(a,b){var c=a.x-b.x,d=a.y-b.y;return c*c+d*d};goog.math.Coordinate.difference=function(a,b){return new goog.math.Coordinate(a.x-b.x,a.y-b.y)};goog.math.Coordinate.sum=function(a,b){return new goog.math.Coordinate(a.x+b.x,a.y+b.y)};goog.math.Coordinate.prototype.ceil=function(){this.x=Math.ceil(this.x);this.y=Math.ceil(this.y);return this};goog.math.Coordinate.prototype.floor=function(){this.x=Math.floor(this.x);
-this.y=Math.floor(this.y);return this};goog.math.Coordinate.prototype.round=function(){this.x=Math.round(this.x);this.y=Math.round(this.y);return this};goog.math.Coordinate.prototype.translate=function(a,b){a instanceof goog.math.Coordinate?(this.x+=a.x,this.y+=a.y):(this.x+=Number(a),goog.isNumber(b)&&(this.y+=b));return this};goog.math.Coordinate.prototype.scale=function(a,b){var c=goog.isNumber(b)?b:a;this.x*=a;this.y*=c;return this};goog.math.Coordinate.prototype.rotateRadians=function(a,b){var c=b||new goog.math.Coordinate(0,0),d=this.x,e=this.y,f=Math.cos(a),g=Math.sin(a);this.x=(d-c.x)*f-(e-c.y)*g+c.x;this.y=(d-c.x)*g+(e-c.y)*f+c.y};goog.math.Coordinate.prototype.rotateDegrees=function(a,b){this.rotateRadians(goog.math.toRadians(a),b)};goog.string={};goog.string.DETECT_DOUBLE_ESCAPING=!1;goog.string.FORCE_NON_DOM_HTML_UNESCAPING=!1;goog.string.Unicode={NBSP:"\u00a0"};goog.string.startsWith=function(a,b){return 0==a.lastIndexOf(b,0)};goog.string.endsWith=function(a,b){var c=a.length-b.length;return 0<=c&&a.indexOf(b,c)==c};goog.string.caseInsensitiveStartsWith=function(a,b){return 0==goog.string.caseInsensitiveCompare(b,a.substr(0,b.length))};goog.string.caseInsensitiveEndsWith=function(a,b){return 0==goog.string.caseInsensitiveCompare(b,a.substr(a.length-b.length,b.length))};goog.string.caseInsensitiveEquals=function(a,b){return a.toLowerCase()==b.toLowerCase()};goog.string.subs=function(a,b){for(var c=a.split("%s"),d="",e=Array.prototype.slice.call(arguments,1);e.length&&1<c.length;){d+=c.shift()+e.shift()}return d+c.join("%s")};goog.string.collapseWhitespace=function(a){return a.replace(/[\s\xa0]+/g," ").replace(/^\s+|\s+$/g,"")};goog.string.isEmptyOrWhitespace=function(a){return/^[\s\xa0]*$/.test(a)};goog.string.isEmptyString=function(a){return 0==a.length};goog.string.isEmpty=goog.string.isEmptyOrWhitespace;goog.string.isEmptyOrWhitespaceSafe=function(a){return goog.string.isEmptyOrWhitespace(goog.string.makeSafe(a))};goog.string.isEmptySafe=goog.string.isEmptyOrWhitespaceSafe;
-goog.string.isBreakingWhitespace=function(a){return !/[^\t\n\r ]/.test(a)};goog.string.isAlpha=function(a){return !/[^a-zA-Z]/.test(a)};goog.string.isNumeric=function(a){return !/[^0-9]/.test(a)};goog.string.isAlphaNumeric=function(a){return !/[^a-zA-Z0-9]/.test(a)};goog.string.isSpace=function(a){return" "==a};goog.string.isUnicodeChar=function(a){return 1==a.length&&" "<=a&&"~">=a||"\u0080"<=a&&"\ufffd">=a};goog.string.stripNewlines=function(a){return a.replace(/(\r\n|\r|\n)+/g," ")};goog.string.canonicalizeNewlines=function(a){return a.replace(/(\r\n|\r|\n)/g,"\n")};goog.string.normalizeWhitespace=function(a){return a.replace(/\xa0|\s/g," ")};goog.string.normalizeSpaces=function(a){return a.replace(/\xa0|[ \t]+/g," ")};goog.string.collapseBreakingSpaces=function(a){return a.replace(/[\t\r\n ]+/g," ").replace(/^[\t\r\n ]+|[\t\r\n ]+$/g,"")};goog.string.trim=goog.TRUSTED_SITE&&String.prototype.trim?function(a){return a.trim()}:function(a){return/^[\s\xa0]*([\s\S]*?)[\s\xa0]*$/.exec(a)[1]};goog.string.trimLeft=function(a){return a.replace(/^[\s\xa0]+/,"")};goog.string.trimRight=function(a){return a.replace(/[\s\xa0]+$/,"")};goog.string.caseInsensitiveCompare=function(a,b){var c=String(a).toLowerCase(),d=String(b).toLowerCase();return c<d?-1:c==d?0:1};goog.string.numberAwareCompare_=function(a,b,c){if(a==b){return 0}if(!a){return -1}if(!b){return 1}for(var d=a.toLowerCase().match(c),e=b.toLowerCase().match(c),f=Math.min(d.length,e.length),g=0;g<f;g++){c=d[g];var h=e[g];if(c!=h){return a=parseInt(c,10),!isNaN(a)&&(b=parseInt(h,10),!isNaN(b)&&a-b)?a-b:c<h?-1:1}}return d.length!=e.length?d.length-e.length:a<b?-1:1};goog.string.intAwareCompare=function(a,b){return goog.string.numberAwareCompare_(a,b,/\d+|\D+/g)};goog.string.floatAwareCompare=function(a,b){return goog.string.numberAwareCompare_(a,b,/\d+|\.\d+|\D+/g)};goog.string.numerateCompare=goog.string.floatAwareCompare;goog.string.urlEncode=function(a){return encodeURIComponent(String(a))};goog.string.urlDecode=function(a){return decodeURIComponent(a.replace(/\+/g," "))
-};goog.string.newLineToBr=function(a,b){return a.replace(/(\r\n|\r|\n)/g,b?"<br />":"<br>")};goog.string.htmlEscape=function(a,b){if(b){a=a.replace(goog.string.AMP_RE_,"&amp;").replace(goog.string.LT_RE_,"&lt;").replace(goog.string.GT_RE_,"&gt;").replace(goog.string.QUOT_RE_,"&quot;").replace(goog.string.SINGLE_QUOTE_RE_,"&#39;").replace(goog.string.NULL_RE_,"&#0;"),goog.string.DETECT_DOUBLE_ESCAPING&&(a=a.replace(goog.string.E_RE_,"&#101;"))}else{if(!goog.string.ALL_RE_.test(a)){return a}-1!=a.indexOf("&")&&(a=a.replace(goog.string.AMP_RE_,"&amp;"));-1!=a.indexOf("<")&&(a=a.replace(goog.string.LT_RE_,"&lt;"));-1!=a.indexOf(">")&&(a=a.replace(goog.string.GT_RE_,"&gt;"));-1!=a.indexOf('"')&&(a=a.replace(goog.string.QUOT_RE_,"&quot;"));-1!=a.indexOf("'")&&(a=a.replace(goog.string.SINGLE_QUOTE_RE_,"&#39;"));-1!=a.indexOf("\x00")&&(a=a.replace(goog.string.NULL_RE_,"&#0;"));goog.string.DETECT_DOUBLE_ESCAPING&&-1!=a.indexOf("e")&&(a=a.replace(goog.string.E_RE_,"&#101;"))}return a};goog.string.AMP_RE_=/&/g;goog.string.LT_RE_=/</g;goog.string.GT_RE_=/>/g;goog.string.QUOT_RE_=/"/g;goog.string.SINGLE_QUOTE_RE_=/'/g;goog.string.NULL_RE_=/\x00/g;goog.string.E_RE_=/e/g;goog.string.ALL_RE_=goog.string.DETECT_DOUBLE_ESCAPING?/[\x00&<>"'e]/:/[\x00&<>"']/;goog.string.unescapeEntities=function(a){return goog.string.contains(a,"&")?!goog.string.FORCE_NON_DOM_HTML_UNESCAPING&&"document" in goog.global?goog.string.unescapeEntitiesUsingDom_(a):goog.string.unescapePureXmlEntities_(a):a};goog.string.unescapeEntitiesWithDocument=function(a,b){return goog.string.contains(a,"&")?goog.string.unescapeEntitiesUsingDom_(a,b):a};goog.string.unescapeEntitiesUsingDom_=function(a,b){var c={"&amp;":"&","&lt;":"<","&gt;":">","&quot;":'"'};var d=b?b.createElement("div"):goog.global.document.createElement("div");return a.replace(goog.string.HTML_ENTITY_PATTERN_,function(a,b){var e=c[a];if(e){return e}if("#"==b.charAt(0)){var f=Number("0"+b.substr(1));isNaN(f)||(e=String.fromCharCode(f))}e||(d.innerHTML=a+" ",e=d.firstChild.nodeValue.slice(0,-1));
-return c[a]=e})};goog.string.unescapePureXmlEntities_=function(a){return a.replace(/&([^;]+);/g,function(a,c){switch(c){case"amp":return"&";case"lt":return"<";case"gt":return">";case"quot":return'"';default:if("#"==c.charAt(0)){var b=Number("0"+c.substr(1));if(!isNaN(b)){return String.fromCharCode(b)}}return a}})};goog.string.HTML_ENTITY_PATTERN_=/&([^;\s<&]+);?/g;goog.string.whitespaceEscape=function(a,b){return goog.string.newLineToBr(a.replace(/  /g," &#160;"),b)};goog.string.preserveSpaces=function(a){return a.replace(/(^|[\n ]) /g,"$1"+goog.string.Unicode.NBSP)};goog.string.stripQuotes=function(a,b){for(var c=b.length,d=0;d<c;d++){var e=1==c?b:b.charAt(d);if(a.charAt(0)==e&&a.charAt(a.length-1)==e){return a.substring(1,a.length-1)}}return a};goog.string.truncate=function(a,b,c){c&&(a=goog.string.unescapeEntities(a));a.length>b&&(a=a.substring(0,b-3)+"...");c&&(a=goog.string.htmlEscape(a));return a};goog.string.truncateMiddle=function(a,b,c,d){c&&(a=goog.string.unescapeEntities(a));if(d&&a.length>b){d>b&&(d=b);var e=a.length-d;a=a.substring(0,b-d)+"..."+a.substring(e)}else{a.length>b&&(d=Math.floor(b/2),e=a.length-d,a=a.substring(0,d+b%2)+"..."+a.substring(e))}c&&(a=goog.string.htmlEscape(a));return a};goog.string.specialEscapeChars_={"\x00":"\\0","\b":"\\b","\f":"\\f","\n":"\\n","\r":"\\r","\t":"\\t","\x0B":"\\x0B",'"':'\\"',"\\":"\\\\","<":"<"};goog.string.jsEscapeCache_={"'":"\\'"};goog.string.quote=function(a){a=String(a);for(var b=['"'],c=0;c<a.length;c++){var d=a.charAt(c),e=d.charCodeAt(0);b[c+1]=goog.string.specialEscapeChars_[d]||(31<e&&127>e?d:goog.string.escapeChar(d))}b.push('"');return b.join("")};goog.string.escapeString=function(a){for(var b=[],c=0;c<a.length;c++){b[c]=goog.string.escapeChar(a.charAt(c))}return b.join("")};goog.string.escapeChar=function(a){if(a in goog.string.jsEscapeCache_){return goog.string.jsEscapeCache_[a]}if(a in goog.string.specialEscapeChars_){return goog.string.jsEscapeCache_[a]=goog.string.specialEscapeChars_[a]}var b=a.charCodeAt(0);
-if(31<b&&127>b){var c=a}else{if(256>b){if(c="\\x",16>b||256<b){c+="0"}}else{c="\\u",4096>b&&(c+="0")}c+=b.toString(16).toUpperCase()}return goog.string.jsEscapeCache_[a]=c};goog.string.contains=function(a,b){return -1!=a.indexOf(b)};goog.string.caseInsensitiveContains=function(a,b){return goog.string.contains(a.toLowerCase(),b.toLowerCase())};goog.string.countOf=function(a,b){return a&&b?a.split(b).length-1:0};goog.string.removeAt=function(a,b,c){var d=a;0<=b&&b<a.length&&0<c&&(d=a.substr(0,b)+a.substr(b+c,a.length-b-c));return d};goog.string.remove=function(a,b){return a.replace(b,"")};goog.string.removeAll=function(a,b){var c=new RegExp(goog.string.regExpEscape(b),"g");return a.replace(c,"")};goog.string.replaceAll=function(a,b,c){b=new RegExp(goog.string.regExpEscape(b),"g");return a.replace(b,c.replace(/\$/g,"$$$$"))};goog.string.regExpEscape=function(a){return String(a).replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g,"\\$1").replace(/\x08/g,"\\x08")};goog.string.repeat=String.prototype.repeat?function(a,b){return a.repeat(b)}:function(a,b){return Array(b+1).join(a)};goog.string.padNumber=function(a,b,c){a=goog.isDef(c)?a.toFixed(c):String(a);c=a.indexOf(".");-1==c&&(c=a.length);return goog.string.repeat("0",Math.max(0,b-c))+a};goog.string.makeSafe=function(a){return null==a?"":String(a)};goog.string.buildString=function(a){return Array.prototype.join.call(arguments,"")};goog.string.getRandomString=function(){return Math.floor(2147483648*Math.random()).toString(36)+Math.abs(Math.floor(2147483648*Math.random())^goog.now()).toString(36)};goog.string.compareVersions=function(a,b){for(var c=0,d=goog.string.trim(String(a)).split("."),e=goog.string.trim(String(b)).split("."),f=Math.max(d.length,e.length),g=0;0==c&&g<f;g++){var h=d[g]||"",k=e[g]||"";do{h=/(\d*)(\D*)(.*)/.exec(h)||["","","",""];k=/(\d*)(\D*)(.*)/.exec(k)||["","","",""];if(0==h[0].length&&0==k[0].length){break}c=0==h[1].length?0:parseInt(h[1],10);var n=0==k[1].length?0:parseInt(k[1],10);c=goog.string.compareElements_(c,n)||goog.string.compareElements_(0==h[2].length,0==k[2].length)||goog.string.compareElements_(h[2],k[2]);
-h=h[3];k=k[3]}while(0==c)}return c};goog.string.compareElements_=function(a,b){return a<b?-1:a>b?1:0};goog.string.hashCode=function(a){for(var b=0,c=0;c<a.length;++c){b=31*b+a.charCodeAt(c)>>>0}return b};goog.string.uniqueStringCounter_=2147483648*Math.random()|0;goog.string.createUniqueString=function(){return"goog_"+goog.string.uniqueStringCounter_++};goog.string.toNumber=function(a){var b=Number(a);return 0==b&&goog.string.isEmptyOrWhitespace(a)?NaN:b};goog.string.isLowerCamelCase=function(a){return/^[a-z]+([A-Z][a-z]*)*$/.test(a)};goog.string.isUpperCamelCase=function(a){return/^([A-Z][a-z]*)+$/.test(a)};goog.string.toCamelCase=function(a){return String(a).replace(/\-([a-z])/g,function(a,c){return c.toUpperCase()})};goog.string.toSelectorCase=function(a){return String(a).replace(/([A-Z])/g,"-$1").toLowerCase()};goog.string.toTitleCase=function(a,b){var c=goog.isString(b)?goog.string.regExpEscape(b):"\\s";return a.replace(new RegExp("(^"+(c?"|["+c+"]+":"")+")([a-z])","g"),function(a,b,c){return b+c.toUpperCase()})};goog.string.capitalize=function(a){return String(a.charAt(0)).toUpperCase()+String(a.substr(1)).toLowerCase()};goog.string.parseInt=function(a){isFinite(a)&&(a=String(a));return goog.isString(a)?/^\s*-?0x/i.test(a)?parseInt(a,16):parseInt(a,10):NaN};goog.string.splitLimit=function(a,b,c){a=a.split(b);for(var d=[];0<c&&a.length;){d.push(a.shift()),c--}a.length&&d.push(a.join(b));return d};goog.string.lastComponent=function(a,b){if(b){"string"==typeof b&&(b=[b])}else{return a}for(var c=-1,d=0;d<b.length;d++){if(""!=b[d]){var e=a.lastIndexOf(b[d]);e>c&&(c=e)}}return -1==c?a:a.slice(c+1)};goog.string.editDistance=function(a,b){var c=[],d=[];if(a==b){return 0}if(!a.length||!b.length){return Math.max(a.length,b.length)}for(var e=0;e<b.length+1;e++){c[e]=e}for(e=0;e<a.length;e++){d[0]=e+1;for(var f=0;f<b.length;f++){d[f+1]=Math.min(d[f]+1,c[f+1]+1,c[f]+Number(a[e]!=b[f]))}for(f=0;f<c.length;f++){c[f]=d[f]}}return d[b.length]};goog.labs={};goog.labs.userAgent={};
-goog.labs.userAgent.util={};goog.labs.userAgent.util.getNativeUserAgentString_=function(){var a=goog.labs.userAgent.util.getNavigator_();return a&&(a=a.userAgent)?a:""};goog.labs.userAgent.util.getNavigator_=function(){return goog.global.navigator};goog.labs.userAgent.util.userAgent_=goog.labs.userAgent.util.getNativeUserAgentString_();goog.labs.userAgent.util.setUserAgent=function(a){goog.labs.userAgent.util.userAgent_=a||goog.labs.userAgent.util.getNativeUserAgentString_()};goog.labs.userAgent.util.getUserAgent=function(){return goog.labs.userAgent.util.userAgent_};goog.labs.userAgent.util.matchUserAgent=function(a){var b=goog.labs.userAgent.util.getUserAgent();return goog.string.contains(b,a)};goog.labs.userAgent.util.matchUserAgentIgnoreCase=function(a){var b=goog.labs.userAgent.util.getUserAgent();return goog.string.caseInsensitiveContains(b,a)};goog.labs.userAgent.util.extractVersionTuples=function(a){for(var b=RegExp("(\\w[\\w ]+)/([^\\s]+)\\s*(?:\\((.*?)\\))?","g"),c=[],d;d=b.exec(a);){c.push([d[1],d[2],d[3]||void 0])}return c};goog.object={};goog.object.is=function(a,b){return a===b?0!==a||1/a===1/b:a!==a&&b!==b};goog.object.forEach=function(a,b,c){for(var d in a){b.call(c,a[d],d,a)}};goog.object.filter=function(a,b,c){var d={},e;for(e in a){b.call(c,a[e],e,a)&&(d[e]=a[e])}return d};goog.object.map=function(a,b,c){var d={},e;for(e in a){d[e]=b.call(c,a[e],e,a)}return d};goog.object.some=function(a,b,c){for(var d in a){if(b.call(c,a[d],d,a)){return !0}}return !1};goog.object.every=function(a,b,c){for(var d in a){if(!b.call(c,a[d],d,a)){return !1}}return !0};goog.object.getCount=function(a){var b=0,c;for(c in a){b++}return b};goog.object.getAnyKey=function(a){for(var b in a){return b}};goog.object.getAnyValue=function(a){for(var b in a){return a[b]}};goog.object.contains=function(a,b){return goog.object.containsValue(a,b)};goog.object.getValues=function(a){var b=[],c=0,d;for(d in a){b[c++]=a[d]}return b};goog.object.getKeys=function(a){var b=[],c=0,d;for(d in a){b[c++]=d
-}return b};goog.object.getValueByKeys=function(a,b){var c=goog.isArrayLike(b),d=c?b:arguments;for(c=c?0:1;c<d.length;c++){if(null==a){return}a=a[d[c]]}return a};goog.object.containsKey=function(a,b){return null!==a&&b in a};goog.object.containsValue=function(a,b){for(var c in a){if(a[c]==b){return !0}}return !1};goog.object.findKey=function(a,b,c){for(var d in a){if(b.call(c,a[d],d,a)){return d}}};goog.object.findValue=function(a,b,c){return(b=goog.object.findKey(a,b,c))&&a[b]};goog.object.isEmpty=function(a){for(var b in a){return !1}return !0};goog.object.clear=function(a){for(var b in a){delete a[b]}};goog.object.remove=function(a,b){var c;(c=b in a)&&delete a[b];return c};goog.object.add=function(a,b,c){if(null!==a&&b in a){throw Error('The object already contains the key "'+b+'"')}goog.object.set(a,b,c)};goog.object.get=function(a,b,c){return null!==a&&b in a?a[b]:c};goog.object.set=function(a,b,c){a[b]=c};goog.object.setIfUndefined=function(a,b,c){return b in a?a[b]:a[b]=c};goog.object.setWithReturnValueIfNotSet=function(a,b,c){if(b in a){return a[b]}c=c();return a[b]=c};goog.object.equals=function(a,b){for(var c in a){if(!(c in b)||a[c]!==b[c]){return !1}}for(c in b){if(!(c in a)){return !1}}return !0};goog.object.clone=function(a){var b={},c;for(c in a){b[c]=a[c]}return b};goog.object.unsafeClone=function(a){var b=goog.typeOf(a);if("object"==b||"array"==b){if(goog.isFunction(a.clone)){return a.clone()}b="array"==b?[]:{};for(var c in a){b[c]=goog.object.unsafeClone(a[c])}return b}return a};goog.object.transpose=function(a){var b={},c;for(c in a){b[a[c]]=c}return b};goog.object.PROTOTYPE_FIELDS_="constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf".split(" ");goog.object.extend=function(a,b){for(var c,d,e=1;e<arguments.length;e++){d=arguments[e];for(c in d){a[c]=d[c]}for(var f=0;f<goog.object.PROTOTYPE_FIELDS_.length;f++){c=goog.object.PROTOTYPE_FIELDS_[f],Object.prototype.hasOwnProperty.call(d,c)&&(a[c]=d[c])}}};goog.object.create=function(a){var b=arguments.length;
-if(1==b&&goog.isArray(arguments[0])){return goog.object.create.apply(null,arguments[0])}if(b%2){throw Error("Uneven number of arguments")}for(var c={},d=0;d<b;d+=2){c[arguments[d]]=arguments[d+1]}return c};goog.object.createSet=function(a){var b=arguments.length;if(1==b&&goog.isArray(arguments[0])){return goog.object.createSet.apply(null,arguments[0])}for(var c={},d=0;d<b;d++){c[arguments[d]]=!0}return c};goog.object.createImmutableView=function(a){var b=a;Object.isFrozen&&!Object.isFrozen(a)&&(b=Object.create(a),Object.freeze(b));return b};goog.object.isImmutableView=function(a){return !!Object.isFrozen&&Object.isFrozen(a)};goog.object.getAllPropertyNames=function(a,b,c){if(!a){return[]}if(!Object.getOwnPropertyNames||!Object.getPrototypeOf){return goog.object.getKeys(a)}for(var d={};a&&(a!==Object.prototype||b)&&(a!==Function.prototype||c);){for(var e=Object.getOwnPropertyNames(a),f=0;f<e.length;f++){d[e[f]]=!0}a=Object.getPrototypeOf(a)}return goog.object.getKeys(d)};goog.labs.userAgent.browser={};goog.labs.userAgent.browser.matchOpera_=function(){return goog.labs.userAgent.util.matchUserAgent("Opera")};goog.labs.userAgent.browser.matchIE_=function(){return goog.labs.userAgent.util.matchUserAgent("Trident")||goog.labs.userAgent.util.matchUserAgent("MSIE")};goog.labs.userAgent.browser.matchEdge_=function(){return goog.labs.userAgent.util.matchUserAgent("Edge")};goog.labs.userAgent.browser.matchFirefox_=function(){return goog.labs.userAgent.util.matchUserAgent("Firefox")};goog.labs.userAgent.browser.matchSafari_=function(){return goog.labs.userAgent.util.matchUserAgent("Safari")&&!(goog.labs.userAgent.browser.matchChrome_()||goog.labs.userAgent.browser.matchCoast_()||goog.labs.userAgent.browser.matchOpera_()||goog.labs.userAgent.browser.matchEdge_()||goog.labs.userAgent.browser.isSilk()||goog.labs.userAgent.util.matchUserAgent("Android"))};goog.labs.userAgent.browser.matchCoast_=function(){return goog.labs.userAgent.util.matchUserAgent("Coast")};goog.labs.userAgent.browser.matchIosWebview_=function(){return(goog.labs.userAgent.util.matchUserAgent("iPad")||goog.labs.userAgent.util.matchUserAgent("iPhone"))&&!goog.labs.userAgent.browser.matchSafari_()&&!goog.labs.userAgent.browser.matchChrome_()&&!goog.labs.userAgent.browser.matchCoast_()&&goog.labs.userAgent.util.matchUserAgent("AppleWebKit")
-};goog.labs.userAgent.browser.matchChrome_=function(){return(goog.labs.userAgent.util.matchUserAgent("Chrome")||goog.labs.userAgent.util.matchUserAgent("CriOS"))&&!goog.labs.userAgent.browser.matchEdge_()};goog.labs.userAgent.browser.matchAndroidBrowser_=function(){return goog.labs.userAgent.util.matchUserAgent("Android")&&!(goog.labs.userAgent.browser.isChrome()||goog.labs.userAgent.browser.isFirefox()||goog.labs.userAgent.browser.isOpera()||goog.labs.userAgent.browser.isSilk())};goog.labs.userAgent.browser.isOpera=goog.labs.userAgent.browser.matchOpera_;goog.labs.userAgent.browser.isIE=goog.labs.userAgent.browser.matchIE_;goog.labs.userAgent.browser.isEdge=goog.labs.userAgent.browser.matchEdge_;goog.labs.userAgent.browser.isFirefox=goog.labs.userAgent.browser.matchFirefox_;goog.labs.userAgent.browser.isSafari=goog.labs.userAgent.browser.matchSafari_;goog.labs.userAgent.browser.isCoast=goog.labs.userAgent.browser.matchCoast_;goog.labs.userAgent.browser.isIosWebview=goog.labs.userAgent.browser.matchIosWebview_;goog.labs.userAgent.browser.isChrome=goog.labs.userAgent.browser.matchChrome_;goog.labs.userAgent.browser.isAndroidBrowser=goog.labs.userAgent.browser.matchAndroidBrowser_;goog.labs.userAgent.browser.isSilk=function(){return goog.labs.userAgent.util.matchUserAgent("Silk")};goog.labs.userAgent.browser.getVersion=function(){function a(a){a=goog.array.find(a,d);return c[a]||""}var b=goog.labs.userAgent.util.getUserAgent();if(goog.labs.userAgent.browser.isIE()){return goog.labs.userAgent.browser.getIEVersion_(b)}b=goog.labs.userAgent.util.extractVersionTuples(b);var c={};goog.array.forEach(b,function(a){c[a[0]]=a[1]});var d=goog.partial(goog.object.containsKey,c);return goog.labs.userAgent.browser.isOpera()?a(["Version","Opera"]):goog.labs.userAgent.browser.isEdge()?a(["Edge"]):goog.labs.userAgent.browser.isChrome()?a(["Chrome","CriOS"]):(b=b[2])&&b[1]||""};goog.labs.userAgent.browser.isVersionOrHigher=function(a){return 0<=goog.string.compareVersions(goog.labs.userAgent.browser.getVersion(),a)
-};goog.labs.userAgent.browser.getIEVersion_=function(a){var b=/rv: *([\d\.]*)/.exec(a);if(b&&b[1]){return b[1]}b="";var c=/MSIE +([\d\.]+)/.exec(a);if(c&&c[1]){if(a=/Trident\/(\d.\d)/.exec(a),"7.0"==c[1]){if(a&&a[1]){switch(a[1]){case"4.0":b="8.0";break;case"5.0":b="9.0";break;case"6.0":b="10.0";break;case"7.0":b="11.0"}}else{b="7.0"}}else{b=c[1]}}return b};goog.labs.userAgent.engine={};goog.labs.userAgent.engine.isPresto=function(){return goog.labs.userAgent.util.matchUserAgent("Presto")};goog.labs.userAgent.engine.isTrident=function(){return goog.labs.userAgent.util.matchUserAgent("Trident")||goog.labs.userAgent.util.matchUserAgent("MSIE")};goog.labs.userAgent.engine.isEdge=function(){return goog.labs.userAgent.util.matchUserAgent("Edge")};goog.labs.userAgent.engine.isWebKit=function(){return goog.labs.userAgent.util.matchUserAgentIgnoreCase("WebKit")&&!goog.labs.userAgent.engine.isEdge()};goog.labs.userAgent.engine.isGecko=function(){return goog.labs.userAgent.util.matchUserAgent("Gecko")&&!goog.labs.userAgent.engine.isWebKit()&&!goog.labs.userAgent.engine.isTrident()&&!goog.labs.userAgent.engine.isEdge()};goog.labs.userAgent.engine.getVersion=function(){var a=goog.labs.userAgent.util.getUserAgent();if(a){a=goog.labs.userAgent.util.extractVersionTuples(a);var b=goog.labs.userAgent.engine.getEngineTuple_(a);if(b){return"Gecko"==b[0]?goog.labs.userAgent.engine.getVersionForKey_(a,"Firefox"):b[1]}a=a[0];var c;if(a&&(c=a[2])&&(c=/Trident\/([^\s;]+)/.exec(c))){return c[1]}}return""};goog.labs.userAgent.engine.getEngineTuple_=function(a){if(!goog.labs.userAgent.engine.isEdge()){return a[1]}for(var b=0;b<a.length;b++){var c=a[b];if("Edge"==c[0]){return c}}};goog.labs.userAgent.engine.isVersionOrHigher=function(a){return 0<=goog.string.compareVersions(goog.labs.userAgent.engine.getVersion(),a)};goog.labs.userAgent.engine.getVersionForKey_=function(a,b){var c=goog.array.find(a,function(a){return b==a[0]});return c&&c[1]||""};goog.labs.userAgent.platform={};goog.labs.userAgent.platform.isAndroid=function(){return goog.labs.userAgent.util.matchUserAgent("Android")
-};goog.labs.userAgent.platform.isIpod=function(){return goog.labs.userAgent.util.matchUserAgent("iPod")};goog.labs.userAgent.platform.isIphone=function(){return goog.labs.userAgent.util.matchUserAgent("iPhone")&&!goog.labs.userAgent.util.matchUserAgent("iPod")&&!goog.labs.userAgent.util.matchUserAgent("iPad")};goog.labs.userAgent.platform.isIpad=function(){return goog.labs.userAgent.util.matchUserAgent("iPad")};goog.labs.userAgent.platform.isIos=function(){return goog.labs.userAgent.platform.isIphone()||goog.labs.userAgent.platform.isIpad()||goog.labs.userAgent.platform.isIpod()};goog.labs.userAgent.platform.isMacintosh=function(){return goog.labs.userAgent.util.matchUserAgent("Macintosh")};goog.labs.userAgent.platform.isLinux=function(){return goog.labs.userAgent.util.matchUserAgent("Linux")};goog.labs.userAgent.platform.isWindows=function(){return goog.labs.userAgent.util.matchUserAgent("Windows")};goog.labs.userAgent.platform.isChromeOS=function(){return goog.labs.userAgent.util.matchUserAgent("CrOS")};goog.labs.userAgent.platform.getVersion=function(){var a=goog.labs.userAgent.util.getUserAgent(),b="";goog.labs.userAgent.platform.isWindows()?(b=/Windows (?:NT|Phone) ([0-9.]+)/,b=(a=b.exec(a))?a[1]:"0.0"):goog.labs.userAgent.platform.isIos()?(b=/(?:iPhone|iPod|iPad|CPU)\s+OS\s+(\S+)/,b=(a=b.exec(a))&&a[1].replace(/_/g,".")):goog.labs.userAgent.platform.isMacintosh()?(b=/Mac OS X ([0-9_.]+)/,b=(a=b.exec(a))?a[1].replace(/_/g,"."):"10"):goog.labs.userAgent.platform.isAndroid()?(b=/Android\s+([^\);]+)(\)|;)/,b=(a=b.exec(a))&&a[1]):goog.labs.userAgent.platform.isChromeOS()&&(b=/(?:CrOS\s+(?:i686|x86_64)\s+([0-9.]+))/,b=(a=b.exec(a))&&a[1]);return b||""};goog.labs.userAgent.platform.isVersionOrHigher=function(a){return 0<=goog.string.compareVersions(goog.labs.userAgent.platform.getVersion(),a)};goog.reflect={};goog.reflect.object=function(a,b){return b};goog.reflect.objectProperty=function(a,b){return a};goog.reflect.sinkValue=function(a){goog.reflect.sinkValue[" "](a);
-return a};goog.reflect.sinkValue[" "]=goog.nullFunction;goog.reflect.canAccessProperty=function(a,b){try{return goog.reflect.sinkValue(a[b]),!0}catch(c){}return !1};goog.reflect.cache=function(a,b,c,d){d=d?d(b):b;return Object.prototype.hasOwnProperty.call(a,d)?a[d]:a[d]=c(b)};goog.userAgent={};goog.userAgent.ASSUME_IE=!1;goog.userAgent.ASSUME_EDGE=!1;goog.userAgent.ASSUME_GECKO=!1;goog.userAgent.ASSUME_WEBKIT=!1;goog.userAgent.ASSUME_MOBILE_WEBKIT=!1;goog.userAgent.ASSUME_OPERA=!1;goog.userAgent.ASSUME_ANY_VERSION=!1;goog.userAgent.BROWSER_KNOWN_=goog.userAgent.ASSUME_IE||goog.userAgent.ASSUME_EDGE||goog.userAgent.ASSUME_GECKO||goog.userAgent.ASSUME_MOBILE_WEBKIT||goog.userAgent.ASSUME_WEBKIT||goog.userAgent.ASSUME_OPERA;goog.userAgent.getUserAgentString=function(){return goog.labs.userAgent.util.getUserAgent()};goog.userAgent.getNavigator=function(){return goog.global.navigator||null};goog.userAgent.OPERA=goog.userAgent.BROWSER_KNOWN_?goog.userAgent.ASSUME_OPERA:goog.labs.userAgent.browser.isOpera();goog.userAgent.IE=goog.userAgent.BROWSER_KNOWN_?goog.userAgent.ASSUME_IE:goog.labs.userAgent.browser.isIE();goog.userAgent.EDGE=goog.userAgent.BROWSER_KNOWN_?goog.userAgent.ASSUME_EDGE:goog.labs.userAgent.engine.isEdge();goog.userAgent.EDGE_OR_IE=goog.userAgent.EDGE||goog.userAgent.IE;goog.userAgent.GECKO=goog.userAgent.BROWSER_KNOWN_?goog.userAgent.ASSUME_GECKO:goog.labs.userAgent.engine.isGecko();goog.userAgent.WEBKIT=goog.userAgent.BROWSER_KNOWN_?goog.userAgent.ASSUME_WEBKIT||goog.userAgent.ASSUME_MOBILE_WEBKIT:goog.labs.userAgent.engine.isWebKit();goog.userAgent.isMobile_=function(){return goog.userAgent.WEBKIT&&goog.labs.userAgent.util.matchUserAgent("Mobile")};goog.userAgent.MOBILE=goog.userAgent.ASSUME_MOBILE_WEBKIT||goog.userAgent.isMobile_();goog.userAgent.SAFARI=goog.userAgent.WEBKIT;goog.userAgent.determinePlatform_=function(){var a=goog.userAgent.getNavigator();return a&&a.platform||""};goog.userAgent.PLATFORM=goog.userAgent.determinePlatform_();goog.userAgent.ASSUME_MAC=!1;
-goog.userAgent.ASSUME_WINDOWS=!1;goog.userAgent.ASSUME_LINUX=!1;goog.userAgent.ASSUME_X11=!1;goog.userAgent.ASSUME_ANDROID=!1;goog.userAgent.ASSUME_IPHONE=!1;goog.userAgent.ASSUME_IPAD=!1;goog.userAgent.ASSUME_IPOD=!1;goog.userAgent.PLATFORM_KNOWN_=goog.userAgent.ASSUME_MAC||goog.userAgent.ASSUME_WINDOWS||goog.userAgent.ASSUME_LINUX||goog.userAgent.ASSUME_X11||goog.userAgent.ASSUME_ANDROID||goog.userAgent.ASSUME_IPHONE||goog.userAgent.ASSUME_IPAD||goog.userAgent.ASSUME_IPOD;goog.userAgent.MAC=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_MAC:goog.labs.userAgent.platform.isMacintosh();goog.userAgent.WINDOWS=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_WINDOWS:goog.labs.userAgent.platform.isWindows();goog.userAgent.isLegacyLinux_=function(){return goog.labs.userAgent.platform.isLinux()||goog.labs.userAgent.platform.isChromeOS()};goog.userAgent.LINUX=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_LINUX:goog.userAgent.isLegacyLinux_();goog.userAgent.isX11_=function(){var a=goog.userAgent.getNavigator();return !!a&&goog.string.contains(a.appVersion||"","X11")};goog.userAgent.X11=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_X11:goog.userAgent.isX11_();goog.userAgent.ANDROID=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_ANDROID:goog.labs.userAgent.platform.isAndroid();goog.userAgent.IPHONE=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_IPHONE:goog.labs.userAgent.platform.isIphone();goog.userAgent.IPAD=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_IPAD:goog.labs.userAgent.platform.isIpad();goog.userAgent.IPOD=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_IPOD:goog.labs.userAgent.platform.isIpod();goog.userAgent.IOS=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_IPHONE||goog.userAgent.ASSUME_IPAD||goog.userAgent.ASSUME_IPOD:goog.labs.userAgent.platform.isIos();goog.userAgent.determineVersion_=function(){var a="",b=goog.userAgent.getVersionRegexResult_();b&&(a=b?b[1]:"");return goog.userAgent.IE&&(b=goog.userAgent.getDocumentMode_(),null!=b&&b>parseFloat(a))?String(b):a
-};goog.userAgent.getVersionRegexResult_=function(){var a=goog.userAgent.getUserAgentString();if(goog.userAgent.GECKO){return/rv:([^\);]+)(\)|;)/.exec(a)}if(goog.userAgent.EDGE){return/Edge\/([\d\.]+)/.exec(a)}if(goog.userAgent.IE){return/\b(?:MSIE|rv)[: ]([^\);]+)(\)|;)/.exec(a)}if(goog.userAgent.WEBKIT){return/WebKit\/(\S+)/.exec(a)}if(goog.userAgent.OPERA){return/(?:Version)[ \/]?(\S+)/.exec(a)}};goog.userAgent.getDocumentMode_=function(){var a=goog.global.document;return a?a.documentMode:void 0};goog.userAgent.VERSION=goog.userAgent.determineVersion_();goog.userAgent.compare=function(a,b){return goog.string.compareVersions(a,b)};goog.userAgent.isVersionOrHigherCache_={};goog.userAgent.isVersionOrHigher=function(a){return goog.userAgent.ASSUME_ANY_VERSION||goog.reflect.cache(goog.userAgent.isVersionOrHigherCache_,a,function(){return 0<=goog.string.compareVersions(goog.userAgent.VERSION,a)})};goog.userAgent.isVersion=goog.userAgent.isVersionOrHigher;goog.userAgent.isDocumentModeOrHigher=function(a){return Number(goog.userAgent.DOCUMENT_MODE)>=a};goog.userAgent.isDocumentMode=goog.userAgent.isDocumentModeOrHigher;goog.userAgent.DOCUMENT_MODE=function(){var a=goog.global.document,b=goog.userAgent.getDocumentMode_();if(a&&goog.userAgent.IE){return b||("CSS1Compat"==a.compatMode?parseInt(goog.userAgent.VERSION,10):5)}}();goog.Thenable=function(){};goog.Thenable.prototype.then=function(a,b,c){};goog.Thenable.IMPLEMENTED_BY_PROP="$goog_Thenable";goog.Thenable.addImplementation=function(a){a.prototype.then=a.prototype.then;COMPILED?a.prototype[goog.Thenable.IMPLEMENTED_BY_PROP]=!0:a.prototype.$goog_Thenable=!0};goog.Thenable.isImplementedBy=function(a){if(!a){return !1}try{return COMPILED?!!a[goog.Thenable.IMPLEMENTED_BY_PROP]:!!a.$goog_Thenable}catch(b){return !1}};goog.async={};goog.async.FreeList=function(a,b,c){this.limit_=c;this.create_=a;this.reset_=b;this.occupants_=0;this.head_=null};goog.async.FreeList.prototype.get=function(){if(0<this.occupants_){this.occupants_--;
-var a=this.head_;this.head_=a.next;a.next=null}else{a=this.create_()}return a};goog.async.FreeList.prototype.put=function(a){this.reset_(a);this.occupants_<this.limit_&&(this.occupants_++,a.next=this.head_,this.head_=a)};goog.async.FreeList.prototype.occupants=function(){return this.occupants_};goog.async.WorkQueue=function(){this.workTail_=this.workHead_=null};goog.async.WorkQueue.DEFAULT_MAX_UNUSED=100;goog.async.WorkQueue.freelist_=new goog.async.FreeList(function(){return new goog.async.WorkItem},function(a){a.reset()},goog.async.WorkQueue.DEFAULT_MAX_UNUSED);goog.async.WorkQueue.prototype.add=function(a,b){var c=this.getUnusedItem_();c.set(a,b);this.workTail_?this.workTail_.next=c:(goog.asserts.assert(!this.workHead_),this.workHead_=c);this.workTail_=c};goog.async.WorkQueue.prototype.remove=function(){var a=null;this.workHead_&&(a=this.workHead_,this.workHead_=this.workHead_.next,this.workHead_||(this.workTail_=null),a.next=null);return a};goog.async.WorkQueue.prototype.returnUnused=function(a){goog.async.WorkQueue.freelist_.put(a)};goog.async.WorkQueue.prototype.getUnusedItem_=function(){return goog.async.WorkQueue.freelist_.get()};goog.async.WorkItem=function(){this.next=this.scope=this.fn=null};goog.async.WorkItem.prototype.set=function(a,b){this.fn=a;this.scope=b;this.next=null};goog.async.WorkItem.prototype.reset=function(){this.next=this.scope=this.fn=null};goog.debug.entryPointRegistry={};goog.debug.EntryPointMonitor=function(){};goog.debug.entryPointRegistry.refList_=[];goog.debug.entryPointRegistry.monitors_=[];goog.debug.entryPointRegistry.monitorsMayExist_=!1;goog.debug.entryPointRegistry.register=function(a){goog.debug.entryPointRegistry.refList_[goog.debug.entryPointRegistry.refList_.length]=a;if(goog.debug.entryPointRegistry.monitorsMayExist_){for(var b=goog.debug.entryPointRegistry.monitors_,c=0;c<b.length;c++){a(goog.bind(b[c].wrap,b[c]))}}};goog.debug.entryPointRegistry.monitorAll=function(a){goog.debug.entryPointRegistry.monitorsMayExist_=!0;for(var b=goog.bind(a.wrap,a),c=0;
-c<goog.debug.entryPointRegistry.refList_.length;c++){goog.debug.entryPointRegistry.refList_[c](b)}goog.debug.entryPointRegistry.monitors_.push(a)};goog.debug.entryPointRegistry.unmonitorAllIfPossible=function(a){var b=goog.debug.entryPointRegistry.monitors_;goog.asserts.assert(a==b[b.length-1],"Only the most recent monitor can be unwrapped.");a=goog.bind(a.unwrap,a);for(var c=0;c<goog.debug.entryPointRegistry.refList_.length;c++){goog.debug.entryPointRegistry.refList_[c](a)}b.length--};goog.dom.HtmlElement=function(){};goog.dom.TagName=function(a){this.tagName_=a};goog.dom.TagName.prototype.toString=function(){return this.tagName_};goog.dom.TagName.A=new goog.dom.TagName("A");goog.dom.TagName.ABBR=new goog.dom.TagName("ABBR");goog.dom.TagName.ACRONYM=new goog.dom.TagName("ACRONYM");goog.dom.TagName.ADDRESS=new goog.dom.TagName("ADDRESS");goog.dom.TagName.APPLET=new goog.dom.TagName("APPLET");goog.dom.TagName.AREA=new goog.dom.TagName("AREA");goog.dom.TagName.ARTICLE=new goog.dom.TagName("ARTICLE");goog.dom.TagName.ASIDE=new goog.dom.TagName("ASIDE");goog.dom.TagName.AUDIO=new goog.dom.TagName("AUDIO");goog.dom.TagName.B=new goog.dom.TagName("B");goog.dom.TagName.BASE=new goog.dom.TagName("BASE");goog.dom.TagName.BASEFONT=new goog.dom.TagName("BASEFONT");goog.dom.TagName.BDI=new goog.dom.TagName("BDI");goog.dom.TagName.BDO=new goog.dom.TagName("BDO");goog.dom.TagName.BIG=new goog.dom.TagName("BIG");goog.dom.TagName.BLOCKQUOTE=new goog.dom.TagName("BLOCKQUOTE");goog.dom.TagName.BODY=new goog.dom.TagName("BODY");goog.dom.TagName.BR=new goog.dom.TagName("BR");goog.dom.TagName.BUTTON=new goog.dom.TagName("BUTTON");goog.dom.TagName.CANVAS=new goog.dom.TagName("CANVAS");goog.dom.TagName.CAPTION=new goog.dom.TagName("CAPTION");goog.dom.TagName.CENTER=new goog.dom.TagName("CENTER");goog.dom.TagName.CITE=new goog.dom.TagName("CITE");goog.dom.TagName.CODE=new goog.dom.TagName("CODE");goog.dom.TagName.COL=new goog.dom.TagName("COL");goog.dom.TagName.COLGROUP=new goog.dom.TagName("COLGROUP");
-goog.dom.TagName.COMMAND=new goog.dom.TagName("COMMAND");goog.dom.TagName.DATA=new goog.dom.TagName("DATA");goog.dom.TagName.DATALIST=new goog.dom.TagName("DATALIST");goog.dom.TagName.DD=new goog.dom.TagName("DD");goog.dom.TagName.DEL=new goog.dom.TagName("DEL");goog.dom.TagName.DETAILS=new goog.dom.TagName("DETAILS");goog.dom.TagName.DFN=new goog.dom.TagName("DFN");goog.dom.TagName.DIALOG=new goog.dom.TagName("DIALOG");goog.dom.TagName.DIR=new goog.dom.TagName("DIR");goog.dom.TagName.DIV=new goog.dom.TagName("DIV");goog.dom.TagName.DL=new goog.dom.TagName("DL");goog.dom.TagName.DT=new goog.dom.TagName("DT");goog.dom.TagName.EM=new goog.dom.TagName("EM");goog.dom.TagName.EMBED=new goog.dom.TagName("EMBED");goog.dom.TagName.FIELDSET=new goog.dom.TagName("FIELDSET");goog.dom.TagName.FIGCAPTION=new goog.dom.TagName("FIGCAPTION");goog.dom.TagName.FIGURE=new goog.dom.TagName("FIGURE");goog.dom.TagName.FONT=new goog.dom.TagName("FONT");goog.dom.TagName.FOOTER=new goog.dom.TagName("FOOTER");goog.dom.TagName.FORM=new goog.dom.TagName("FORM");goog.dom.TagName.FRAME=new goog.dom.TagName("FRAME");goog.dom.TagName.FRAMESET=new goog.dom.TagName("FRAMESET");goog.dom.TagName.H1=new goog.dom.TagName("H1");goog.dom.TagName.H2=new goog.dom.TagName("H2");goog.dom.TagName.H3=new goog.dom.TagName("H3");goog.dom.TagName.H4=new goog.dom.TagName("H4");goog.dom.TagName.H5=new goog.dom.TagName("H5");goog.dom.TagName.H6=new goog.dom.TagName("H6");goog.dom.TagName.HEAD=new goog.dom.TagName("HEAD");goog.dom.TagName.HEADER=new goog.dom.TagName("HEADER");goog.dom.TagName.HGROUP=new goog.dom.TagName("HGROUP");goog.dom.TagName.HR=new goog.dom.TagName("HR");goog.dom.TagName.HTML=new goog.dom.TagName("HTML");goog.dom.TagName.I=new goog.dom.TagName("I");goog.dom.TagName.IFRAME=new goog.dom.TagName("IFRAME");goog.dom.TagName.IMG=new goog.dom.TagName("IMG");goog.dom.TagName.INPUT=new goog.dom.TagName("INPUT");goog.dom.TagName.INS=new goog.dom.TagName("INS");goog.dom.TagName.ISINDEX=new goog.dom.TagName("ISINDEX");
-goog.dom.TagName.KBD=new goog.dom.TagName("KBD");goog.dom.TagName.KEYGEN=new goog.dom.TagName("KEYGEN");goog.dom.TagName.LABEL=new goog.dom.TagName("LABEL");goog.dom.TagName.LEGEND=new goog.dom.TagName("LEGEND");goog.dom.TagName.LI=new goog.dom.TagName("LI");goog.dom.TagName.LINK=new goog.dom.TagName("LINK");goog.dom.TagName.MAIN=new goog.dom.TagName("MAIN");goog.dom.TagName.MAP=new goog.dom.TagName("MAP");goog.dom.TagName.MARK=new goog.dom.TagName("MARK");goog.dom.TagName.MATH=new goog.dom.TagName("MATH");goog.dom.TagName.MENU=new goog.dom.TagName("MENU");goog.dom.TagName.MENUITEM=new goog.dom.TagName("MENUITEM");goog.dom.TagName.META=new goog.dom.TagName("META");goog.dom.TagName.METER=new goog.dom.TagName("METER");goog.dom.TagName.NAV=new goog.dom.TagName("NAV");goog.dom.TagName.NOFRAMES=new goog.dom.TagName("NOFRAMES");goog.dom.TagName.NOSCRIPT=new goog.dom.TagName("NOSCRIPT");goog.dom.TagName.OBJECT=new goog.dom.TagName("OBJECT");goog.dom.TagName.OL=new goog.dom.TagName("OL");goog.dom.TagName.OPTGROUP=new goog.dom.TagName("OPTGROUP");goog.dom.TagName.OPTION=new goog.dom.TagName("OPTION");goog.dom.TagName.OUTPUT=new goog.dom.TagName("OUTPUT");goog.dom.TagName.P=new goog.dom.TagName("P");goog.dom.TagName.PARAM=new goog.dom.TagName("PARAM");goog.dom.TagName.PICTURE=new goog.dom.TagName("PICTURE");goog.dom.TagName.PRE=new goog.dom.TagName("PRE");goog.dom.TagName.PROGRESS=new goog.dom.TagName("PROGRESS");goog.dom.TagName.Q=new goog.dom.TagName("Q");goog.dom.TagName.RP=new goog.dom.TagName("RP");goog.dom.TagName.RT=new goog.dom.TagName("RT");goog.dom.TagName.RTC=new goog.dom.TagName("RTC");goog.dom.TagName.RUBY=new goog.dom.TagName("RUBY");goog.dom.TagName.S=new goog.dom.TagName("S");goog.dom.TagName.SAMP=new goog.dom.TagName("SAMP");goog.dom.TagName.SCRIPT=new goog.dom.TagName("SCRIPT");goog.dom.TagName.SECTION=new goog.dom.TagName("SECTION");goog.dom.TagName.SELECT=new goog.dom.TagName("SELECT");goog.dom.TagName.SMALL=new goog.dom.TagName("SMALL");goog.dom.TagName.SOURCE=new goog.dom.TagName("SOURCE");
-goog.dom.TagName.SPAN=new goog.dom.TagName("SPAN");goog.dom.TagName.STRIKE=new goog.dom.TagName("STRIKE");goog.dom.TagName.STRONG=new goog.dom.TagName("STRONG");goog.dom.TagName.STYLE=new goog.dom.TagName("STYLE");goog.dom.TagName.SUB=new goog.dom.TagName("SUB");goog.dom.TagName.SUMMARY=new goog.dom.TagName("SUMMARY");goog.dom.TagName.SUP=new goog.dom.TagName("SUP");goog.dom.TagName.SVG=new goog.dom.TagName("SVG");goog.dom.TagName.TABLE=new goog.dom.TagName("TABLE");goog.dom.TagName.TBODY=new goog.dom.TagName("TBODY");goog.dom.TagName.TD=new goog.dom.TagName("TD");goog.dom.TagName.TEMPLATE=new goog.dom.TagName("TEMPLATE");goog.dom.TagName.TEXTAREA=new goog.dom.TagName("TEXTAREA");goog.dom.TagName.TFOOT=new goog.dom.TagName("TFOOT");goog.dom.TagName.TH=new goog.dom.TagName("TH");goog.dom.TagName.THEAD=new goog.dom.TagName("THEAD");goog.dom.TagName.TIME=new goog.dom.TagName("TIME");goog.dom.TagName.TITLE=new goog.dom.TagName("TITLE");goog.dom.TagName.TR=new goog.dom.TagName("TR");goog.dom.TagName.TRACK=new goog.dom.TagName("TRACK");goog.dom.TagName.TT=new goog.dom.TagName("TT");goog.dom.TagName.U=new goog.dom.TagName("U");goog.dom.TagName.UL=new goog.dom.TagName("UL");goog.dom.TagName.VAR=new goog.dom.TagName("VAR");goog.dom.TagName.VIDEO=new goog.dom.TagName("VIDEO");goog.dom.TagName.WBR=new goog.dom.TagName("WBR");goog.functions={};goog.functions.constant=function(a){return function(){return a}};goog.functions.FALSE=goog.functions.constant(!1);goog.functions.TRUE=goog.functions.constant(!0);goog.functions.NULL=goog.functions.constant(null);goog.functions.identity=function(a,b){return a};goog.functions.error=function(a){return function(){throw Error(a)}};goog.functions.fail=function(a){return function(){throw a}};goog.functions.lock=function(a,b){b=b||0;return function(){return a.apply(this,Array.prototype.slice.call(arguments,0,b))}};goog.functions.nth=function(a){return function(){return arguments[a]}};goog.functions.partialRight=function(a,b){var c=Array.prototype.slice.call(arguments,1);
-return function(){var b=Array.prototype.slice.call(arguments);b.push.apply(b,c);return a.apply(this,b)}};goog.functions.withReturnValue=function(a,b){return goog.functions.sequence(a,goog.functions.constant(b))};goog.functions.equalTo=function(a,b){return function(c){return b?a==c:a===c}};goog.functions.compose=function(a,b){var c=arguments,d=c.length;return function(){var a;d&&(a=c[d-1].apply(this,arguments));for(var b=d-2;0<=b;b--){a=c[b].call(this,a)}return a}};goog.functions.sequence=function(a){var b=arguments,c=b.length;return function(){for(var a,e=0;e<c;e++){a=b[e].apply(this,arguments)}return a}};goog.functions.and=function(a){var b=arguments,c=b.length;return function(){for(var a=0;a<c;a++){if(!b[a].apply(this,arguments)){return !1}}return !0}};goog.functions.or=function(a){var b=arguments,c=b.length;return function(){for(var a=0;a<c;a++){if(b[a].apply(this,arguments)){return !0}}return !1}};goog.functions.not=function(a){return function(){return !a.apply(this,arguments)}};goog.functions.create=function(a,b){var c=function(){};c.prototype=a.prototype;c=new c;a.apply(c,Array.prototype.slice.call(arguments,1));return c};goog.functions.CACHE_RETURN_VALUE=!0;goog.functions.cacheReturnValue=function(a){var b=!1,c;return function(){if(!goog.functions.CACHE_RETURN_VALUE){return a()}b||(c=a(),b=!0);return c}};goog.functions.once=function(a){var b=a;return function(){if(b){var a=b;b=null;a()}}};goog.functions.debounce=function(a,b,c){var d=0;return function(e){goog.global.clearTimeout(d);var f=arguments;d=goog.global.setTimeout(function(){a.apply(c,f)},b)}};goog.functions.throttle=function(a,b,c){var d=0,e=!1,f=[],g=function(){d=0;e&&(e=!1,h())},h=function(){d=goog.global.setTimeout(g,b);a.apply(c,f)};return function(a){f=arguments;d?e=!0:h()}};goog.functions.rateLimit=function(a,b,c){var d=0,e=function(){d=0};return function(f){d||(d=goog.global.setTimeout(e,b),a.apply(c,arguments))}};goog.async.throwException=function(a){goog.global.setTimeout(function(){throw a},0)
-};goog.async.nextTick=function(a,b,c){var d=a;b&&(d=goog.bind(a,b));d=goog.async.nextTick.wrapCallback_(d);goog.isFunction(goog.global.setImmediate)&&(c||goog.async.nextTick.useSetImmediate_())?goog.global.setImmediate(d):(goog.async.nextTick.setImmediate_||(goog.async.nextTick.setImmediate_=goog.async.nextTick.getSetImmediateEmulator_()),goog.async.nextTick.setImmediate_(d))};goog.async.nextTick.useSetImmediate_=function(){return goog.global.Window&&goog.global.Window.prototype&&!goog.labs.userAgent.browser.isEdge()&&goog.global.Window.prototype.setImmediate==goog.global.setImmediate?!1:!0};goog.async.nextTick.getSetImmediateEmulator_=function(){var a=goog.global.MessageChannel;"undefined"===typeof a&&"undefined"!==typeof window&&window.postMessage&&window.addEventListener&&!goog.labs.userAgent.engine.isPresto()&&(a=function(){var a=document.createElement("IFRAME");a.style.display="none";a.src="";document.documentElement.appendChild(a);var b=a.contentWindow;a=b.document;a.open();a.write("");a.close();var c="callImmediate"+Math.random(),d="file:"==b.location.protocol?"*":b.location.protocol+"//"+b.location.host;a=goog.bind(function(a){if(("*"==d||a.origin==d)&&a.data==c){this.port1.onmessage()}},this);b.addEventListener("message",a,!1);this.port1={};this.port2={postMessage:function(){b.postMessage(c,d)}}});if("undefined"!==typeof a&&!goog.labs.userAgent.browser.isIE()){var b=new a,c={},d=c;b.port1.onmessage=function(){if(goog.isDef(c.next)){c=c.next;var a=c.cb;c.cb=null;a()}};return function(a){d.next={cb:a};d=d.next;b.port2.postMessage(0)}}return"undefined"!==typeof document&&"onreadystatechange" in document.createElement("SCRIPT")?function(a){var b=document.createElement("SCRIPT");b.onreadystatechange=function(){b.onreadystatechange=null;b.parentNode.removeChild(b);b=null;a();a=null};document.documentElement.appendChild(b)}:function(a){goog.global.setTimeout(a,0)}};goog.async.nextTick.wrapCallback_=goog.functions.identity;goog.debug.entryPointRegistry.register(function(a){goog.async.nextTick.wrapCallback_=a
-});goog.async.run=function(a,b){goog.async.run.schedule_||goog.async.run.initializeRunner_();goog.async.run.workQueueScheduled_||(goog.async.run.schedule_(),goog.async.run.workQueueScheduled_=!0);goog.async.run.workQueue_.add(a,b)};goog.async.run.initializeRunner_=function(){if(-1!=String(goog.global.Promise).indexOf("[native code]")){var a=goog.global.Promise.resolve(void 0);goog.async.run.schedule_=function(){a.then(goog.async.run.processWorkQueue)}}else{goog.async.run.schedule_=function(){goog.async.nextTick(goog.async.run.processWorkQueue)}}};goog.async.run.forceNextTick=function(a){goog.async.run.schedule_=function(){goog.async.nextTick(goog.async.run.processWorkQueue);a&&a(goog.async.run.processWorkQueue)}};goog.async.run.workQueueScheduled_=!1;goog.async.run.workQueue_=new goog.async.WorkQueue;goog.DEBUG&&(goog.async.run.resetQueue=function(){goog.async.run.workQueueScheduled_=!1;goog.async.run.workQueue_=new goog.async.WorkQueue});goog.async.run.processWorkQueue=function(){for(var a;a=goog.async.run.workQueue_.remove();){try{a.fn.call(a.scope)}catch(b){goog.async.throwException(b)}goog.async.run.workQueue_.returnUnused(a)}goog.async.run.workQueueScheduled_=!1};goog.promise={};goog.promise.Resolver=function(){};goog.Promise=function(a,b){this.state_=goog.Promise.State_.PENDING;this.result_=void 0;this.callbackEntriesTail_=this.callbackEntries_=this.parent_=null;this.executing_=!1;0<goog.Promise.UNHANDLED_REJECTION_DELAY?this.unhandledRejectionId_=0:0==goog.Promise.UNHANDLED_REJECTION_DELAY&&(this.hadUnhandledRejection_=!1);goog.Promise.LONG_STACK_TRACES&&(this.stack_=[],this.addStackTrace_(Error("created")),this.currentStep_=0);if(a!=goog.nullFunction){try{var c=this;a.call(b,function(a){c.resolve_(goog.Promise.State_.FULFILLED,a)},function(a){if(goog.DEBUG&&!(a instanceof goog.Promise.CancellationError)){try{if(a instanceof Error){throw a}throw Error("Promise rejected.")}catch(e){}}c.resolve_(goog.Promise.State_.REJECTED,a)})}catch(d){this.resolve_(goog.Promise.State_.REJECTED,d)
-}}};goog.Promise.LONG_STACK_TRACES=!1;goog.Promise.UNHANDLED_REJECTION_DELAY=0;goog.Promise.State_={PENDING:0,BLOCKED:1,FULFILLED:2,REJECTED:3};goog.Promise.CallbackEntry_=function(){this.next=this.context=this.onRejected=this.onFulfilled=this.child=null;this.always=!1};goog.Promise.CallbackEntry_.prototype.reset=function(){this.context=this.onRejected=this.onFulfilled=this.child=null;this.always=!1};goog.Promise.DEFAULT_MAX_UNUSED=100;goog.Promise.freelist_=new goog.async.FreeList(function(){return new goog.Promise.CallbackEntry_},function(a){a.reset()},goog.Promise.DEFAULT_MAX_UNUSED);goog.Promise.getCallbackEntry_=function(a,b,c){var d=goog.Promise.freelist_.get();d.onFulfilled=a;d.onRejected=b;d.context=c;return d};goog.Promise.returnEntry_=function(a){goog.Promise.freelist_.put(a)};goog.Promise.resolve=function(a){if(a instanceof goog.Promise){return a}var b=new goog.Promise(goog.nullFunction);b.resolve_(goog.Promise.State_.FULFILLED,a);return b};goog.Promise.reject=function(a){return new goog.Promise(function(b,c){c(a)})};goog.Promise.resolveThen_=function(a,b,c){goog.Promise.maybeThen_(a,b,c,null)||goog.async.run(goog.partial(b,a))};goog.Promise.race=function(a){return new goog.Promise(function(b,c){a.length||b(void 0);for(var d=0,e;d<a.length;d++){e=a[d],goog.Promise.resolveThen_(e,b,c)}})};goog.Promise.all=function(a){return new goog.Promise(function(b,c){var d=a.length,e=[];if(d){for(var f=function(a,c){d--;e[a]=c;0==d&&b(e)},g=function(a){c(a)},h=0,k;h<a.length;h++){k=a[h],goog.Promise.resolveThen_(k,goog.partial(f,h),g)}}else{b(e)}})};goog.Promise.allSettled=function(a){return new goog.Promise(function(b,c){var d=a.length,e=[];if(d){for(var f=function(a,c,f){d--;e[a]=c?{fulfilled:!0,value:f}:{fulfilled:!1,reason:f};0==d&&b(e)},g=0,h;g<a.length;g++){h=a[g],goog.Promise.resolveThen_(h,goog.partial(f,g,!0),goog.partial(f,g,!1))}}else{b(e)}})};goog.Promise.firstFulfilled=function(a){return new goog.Promise(function(b,c){var d=a.length,e=[];if(d){for(var f=function(a){b(a)
-},g=function(a,b){d--;e[a]=b;0==d&&c(e)},h=0,k;h<a.length;h++){k=a[h],goog.Promise.resolveThen_(k,f,goog.partial(g,h))}}else{b(void 0)}})};goog.Promise.withResolver=function(){var a,b,c=new goog.Promise(function(c,e){a=c;b=e});return new goog.Promise.Resolver_(c,a,b)};goog.Promise.prototype.then=function(a,b,c){null!=a&&goog.asserts.assertFunction(a,"opt_onFulfilled should be a function.");null!=b&&goog.asserts.assertFunction(b,"opt_onRejected should be a function. Did you pass opt_context as the second argument instead of the third?");goog.Promise.LONG_STACK_TRACES&&this.addStackTrace_(Error("then"));return this.addChildPromise_(goog.isFunction(a)?a:null,goog.isFunction(b)?b:null,c)};goog.Thenable.addImplementation(goog.Promise);goog.Promise.prototype.thenVoid=function(a,b,c){null!=a&&goog.asserts.assertFunction(a,"opt_onFulfilled should be a function.");null!=b&&goog.asserts.assertFunction(b,"opt_onRejected should be a function. Did you pass opt_context as the second argument instead of the third?");goog.Promise.LONG_STACK_TRACES&&this.addStackTrace_(Error("then"));this.addCallbackEntry_(goog.Promise.getCallbackEntry_(a||goog.nullFunction,b||null,c))};goog.Promise.prototype.thenAlways=function(a,b){goog.Promise.LONG_STACK_TRACES&&this.addStackTrace_(Error("thenAlways"));var c=goog.Promise.getCallbackEntry_(a,a,b);c.always=!0;this.addCallbackEntry_(c);return this};goog.Promise.prototype.thenCatch=function(a,b){goog.Promise.LONG_STACK_TRACES&&this.addStackTrace_(Error("thenCatch"));return this.addChildPromise_(null,a,b)};goog.Promise.prototype.cancel=function(a){this.state_==goog.Promise.State_.PENDING&&goog.async.run(function(){var b=new goog.Promise.CancellationError(a);this.cancelInternal_(b)},this)};goog.Promise.prototype.cancelInternal_=function(a){this.state_==goog.Promise.State_.PENDING&&(this.parent_?(this.parent_.cancelChild_(this,a),this.parent_=null):this.resolve_(goog.Promise.State_.REJECTED,a))};goog.Promise.prototype.cancelChild_=function(a,b){if(this.callbackEntries_){for(var c=0,d=null,e=null,f=this.callbackEntries_;
-f&&(f.always||(c++,f.child==a&&(d=f),!(d&&1<c)));f=f.next){d||(e=f)}d&&(this.state_==goog.Promise.State_.PENDING&&1==c?this.cancelInternal_(b):(e?this.removeEntryAfter_(e):this.popEntry_(),this.executeCallback_(d,goog.Promise.State_.REJECTED,b)))}};goog.Promise.prototype.addCallbackEntry_=function(a){this.hasEntry_()||this.state_!=goog.Promise.State_.FULFILLED&&this.state_!=goog.Promise.State_.REJECTED||this.scheduleCallbacks_();this.queueEntry_(a)};goog.Promise.prototype.addChildPromise_=function(a,b,c){var d=goog.Promise.getCallbackEntry_(null,null,null);d.child=new goog.Promise(function(e,f){d.onFulfilled=a?function(b){try{var d=a.call(c,b);e(d)}catch(k){f(k)}}:e;d.onRejected=b?function(a){try{var d=b.call(c,a);!goog.isDef(d)&&a instanceof goog.Promise.CancellationError?f(a):e(d)}catch(k){f(k)}}:f});d.child.parent_=this;this.addCallbackEntry_(d);return d.child};goog.Promise.prototype.unblockAndFulfill_=function(a){goog.asserts.assert(this.state_==goog.Promise.State_.BLOCKED);this.state_=goog.Promise.State_.PENDING;this.resolve_(goog.Promise.State_.FULFILLED,a)};goog.Promise.prototype.unblockAndReject_=function(a){goog.asserts.assert(this.state_==goog.Promise.State_.BLOCKED);this.state_=goog.Promise.State_.PENDING;this.resolve_(goog.Promise.State_.REJECTED,a)};goog.Promise.prototype.resolve_=function(a,b){this.state_==goog.Promise.State_.PENDING&&(this===b&&(a=goog.Promise.State_.REJECTED,b=new TypeError("Promise cannot resolve to itself")),this.state_=goog.Promise.State_.BLOCKED,goog.Promise.maybeThen_(b,this.unblockAndFulfill_,this.unblockAndReject_,this)||(this.result_=b,this.state_=a,this.parent_=null,this.scheduleCallbacks_(),a!=goog.Promise.State_.REJECTED||b instanceof goog.Promise.CancellationError||goog.Promise.addUnhandledRejection_(this,b)))};goog.Promise.maybeThen_=function(a,b,c,d){if(a instanceof goog.Promise){return a.thenVoid(b,c,d),!0}if(goog.Thenable.isImplementedBy(a)){return a.then(b,c,d),!0}if(goog.isObject(a)){try{var e=a.then;if(goog.isFunction(e)){return goog.Promise.tryThen_(a,e,b,c,d),!0
-}}catch(f){return c.call(d,f),!0}}return !1};goog.Promise.tryThen_=function(a,b,c,d,e){var f=!1,g=function(a){f||(f=!0,c.call(e,a))},h=function(a){f||(f=!0,d.call(e,a))};try{b.call(a,g,h)}catch(k){h(k)}};goog.Promise.prototype.scheduleCallbacks_=function(){this.executing_||(this.executing_=!0,goog.async.run(this.executeCallbacks_,this))};goog.Promise.prototype.hasEntry_=function(){return !!this.callbackEntries_};goog.Promise.prototype.queueEntry_=function(a){goog.asserts.assert(null!=a.onFulfilled);this.callbackEntriesTail_?this.callbackEntriesTail_.next=a:this.callbackEntries_=a;this.callbackEntriesTail_=a};goog.Promise.prototype.popEntry_=function(){var a=null;this.callbackEntries_&&(a=this.callbackEntries_,this.callbackEntries_=a.next,a.next=null);this.callbackEntries_||(this.callbackEntriesTail_=null);null!=a&&goog.asserts.assert(null!=a.onFulfilled);return a};goog.Promise.prototype.removeEntryAfter_=function(a){goog.asserts.assert(this.callbackEntries_);goog.asserts.assert(null!=a);a.next==this.callbackEntriesTail_&&(this.callbackEntriesTail_=a);a.next=a.next.next};goog.Promise.prototype.executeCallbacks_=function(){for(var a;a=this.popEntry_();){goog.Promise.LONG_STACK_TRACES&&this.currentStep_++,this.executeCallback_(a,this.state_,this.result_)}this.executing_=!1};goog.Promise.prototype.executeCallback_=function(a,b,c){b==goog.Promise.State_.REJECTED&&a.onRejected&&!a.always&&this.removeUnhandledRejection_();if(a.child){a.child.parent_=null,goog.Promise.invokeCallback_(a,b,c)}else{try{a.always?a.onFulfilled.call(a.context):goog.Promise.invokeCallback_(a,b,c)}catch(d){goog.Promise.handleRejection_.call(null,d)}}goog.Promise.returnEntry_(a)};goog.Promise.invokeCallback_=function(a,b,c){b==goog.Promise.State_.FULFILLED?a.onFulfilled.call(a.context,c):a.onRejected&&a.onRejected.call(a.context,c)};goog.Promise.prototype.addStackTrace_=function(a){if(goog.Promise.LONG_STACK_TRACES&&goog.isString(a.stack)){var b=a.stack.split("\n",4)[3];a=a.message;a+=Array(11-a.length).join(" ");
-this.stack_.push(a+b)}};goog.Promise.prototype.appendLongStack_=function(a){if(goog.Promise.LONG_STACK_TRACES&&a&&goog.isString(a.stack)&&this.stack_.length){for(var b=["Promise trace:"],c=this;c;c=c.parent_){for(var d=this.currentStep_;0<=d;d--){b.push(c.stack_[d])}b.push("Value: ["+(c.state_==goog.Promise.State_.REJECTED?"REJECTED":"FULFILLED")+"] <"+String(c.result_)+">")}a.stack+="\n\n"+b.join("\n")}};goog.Promise.prototype.removeUnhandledRejection_=function(){if(0<goog.Promise.UNHANDLED_REJECTION_DELAY){for(var a=this;a&&a.unhandledRejectionId_;a=a.parent_){goog.global.clearTimeout(a.unhandledRejectionId_),a.unhandledRejectionId_=0}}else{if(0==goog.Promise.UNHANDLED_REJECTION_DELAY){for(a=this;a&&a.hadUnhandledRejection_;a=a.parent_){a.hadUnhandledRejection_=!1}}}};goog.Promise.addUnhandledRejection_=function(a,b){0<goog.Promise.UNHANDLED_REJECTION_DELAY?a.unhandledRejectionId_=goog.global.setTimeout(function(){a.appendLongStack_(b);goog.Promise.handleRejection_.call(null,b)},goog.Promise.UNHANDLED_REJECTION_DELAY):0==goog.Promise.UNHANDLED_REJECTION_DELAY&&(a.hadUnhandledRejection_=!0,goog.async.run(function(){a.hadUnhandledRejection_&&(a.appendLongStack_(b),goog.Promise.handleRejection_.call(null,b))}))};goog.Promise.handleRejection_=goog.async.throwException;goog.Promise.setUnhandledRejectionHandler=function(a){goog.Promise.handleRejection_=a};goog.Promise.CancellationError=function(a){goog.debug.Error.call(this,a)};goog.inherits(goog.Promise.CancellationError,goog.debug.Error);goog.Promise.CancellationError.prototype.name="cancel";goog.Promise.Resolver_=function(a,b,c){this.promise=a;this.resolve=b;this.reject=c};goog.disposable={};goog.disposable.IDisposable=function(){};goog.disposable.IDisposable.prototype.dispose=goog.abstractMethod;goog.disposable.IDisposable.prototype.isDisposed=goog.abstractMethod;goog.Disposable=function(){goog.Disposable.MONITORING_MODE!=goog.Disposable.MonitoringMode.OFF&&(goog.Disposable.INCLUDE_STACK_ON_CREATION&&(this.creationStack=Error().stack),goog.Disposable.instances_[goog.getUid(this)]=this);
-this.disposed_=this.disposed_;this.onDisposeCallbacks_=this.onDisposeCallbacks_};goog.Disposable.MonitoringMode={OFF:0,PERMANENT:1,INTERACTIVE:2};goog.Disposable.MONITORING_MODE=0;goog.Disposable.INCLUDE_STACK_ON_CREATION=!0;goog.Disposable.instances_={};goog.Disposable.getUndisposedObjects=function(){var a=[],b;for(b in goog.Disposable.instances_){goog.Disposable.instances_.hasOwnProperty(b)&&a.push(goog.Disposable.instances_[Number(b)])}return a};goog.Disposable.clearUndisposedObjects=function(){goog.Disposable.instances_={}};goog.Disposable.prototype.disposed_=!1;goog.Disposable.prototype.isDisposed=function(){return this.disposed_};goog.Disposable.prototype.getDisposed=goog.Disposable.prototype.isDisposed;goog.Disposable.prototype.dispose=function(){if(!this.disposed_&&(this.disposed_=!0,this.disposeInternal(),goog.Disposable.MONITORING_MODE!=goog.Disposable.MonitoringMode.OFF)){var a=goog.getUid(this);if(goog.Disposable.MONITORING_MODE==goog.Disposable.MonitoringMode.PERMANENT&&!goog.Disposable.instances_.hasOwnProperty(a)){throw Error(this+" did not call the goog.Disposable base constructor or was disposed of after a clearUndisposedObjects call")}delete goog.Disposable.instances_[a]}};goog.Disposable.prototype.registerDisposable=function(a){this.addOnDisposeCallback(goog.partial(goog.dispose,a))};goog.Disposable.prototype.addOnDisposeCallback=function(a,b){this.disposed_?goog.isDef(b)?a.call(b):a():(this.onDisposeCallbacks_||(this.onDisposeCallbacks_=[]),this.onDisposeCallbacks_.push(goog.isDef(b)?goog.bind(a,b):a))};goog.Disposable.prototype.disposeInternal=function(){if(this.onDisposeCallbacks_){for(;this.onDisposeCallbacks_.length;){this.onDisposeCallbacks_.shift()()}}};goog.Disposable.isDisposed=function(a){return a&&"function"==typeof a.isDisposed?a.isDisposed():!1};goog.dispose=function(a){a&&"function"==typeof a.dispose&&a.dispose()};goog.disposeAll=function(a){for(var b=0,c=arguments.length;b<c;++b){var d=arguments[b];goog.isArrayLike(d)?goog.disposeAll.apply(null,d):goog.dispose(d)
-}};goog.debug.errorcontext={};goog.debug.errorcontext.addErrorContext=function(a,b,c){a[goog.debug.errorcontext.CONTEXT_KEY_]||(a[goog.debug.errorcontext.CONTEXT_KEY_]={});a[goog.debug.errorcontext.CONTEXT_KEY_][b]=c};goog.debug.errorcontext.getErrorContext=function(a){return a[goog.debug.errorcontext.CONTEXT_KEY_]||{}};goog.debug.errorcontext.CONTEXT_KEY_="__closure__error__context__984382";goog.debug.LOGGING_ENABLED=goog.DEBUG;goog.debug.FORCE_SLOPPY_STACKS=!1;goog.debug.catchErrors=function(a,b,c){c=c||goog.global;var d=c.onerror,e=!!b;goog.userAgent.WEBKIT&&!goog.userAgent.isVersionOrHigher("535.3")&&(e=!e);c.onerror=function(b,c,h,k,n){d&&d(b,c,h,k,n);a({message:b,fileName:c,line:h,lineNumber:h,col:k,error:n});return e}};goog.debug.expose=function(a,b){if("undefined"==typeof a){return"undefined"}if(null==a){return"NULL"}var c=[],d;for(d in a){if(b||!goog.isFunction(a[d])){var e=d+" = ";try{e+=a[d]}catch(f){e+="*** "+f+" ***"}c.push(e)}}return c.join("\n")};goog.debug.deepExpose=function(a,b){var c=[],d=[],e={},f=function(a,g){var h=g+"  ";try{if(goog.isDef(a)){if(goog.isNull(a)){c.push("NULL")}else{if(goog.isString(a)){c.push('"'+a.replace(/\n/g,"\n"+g)+'"')}else{if(goog.isFunction(a)){c.push(String(a).replace(/\n/g,"\n"+g))}else{if(goog.isObject(a)){goog.hasUid(a)||d.push(a);var k=goog.getUid(a);if(e[k]){c.push("*** reference loop detected (id="+k+") ***")}else{e[k]=!0;c.push("{");for(var l in a){if(b||!goog.isFunction(a[l])){c.push("\n"),c.push(h),c.push(l+" = "),f(a[l],h)}}c.push("\n"+g+"}");delete e[k]}}else{c.push(a)}}}}}else{c.push("undefined")}}catch(m){c.push("*** "+m+" ***")}};f(a,"");for(var g=0;g<d.length;g++){goog.removeUid(d[g])}return c.join("")};goog.debug.exposeArray=function(a){for(var b=[],c=0;c<a.length;c++){goog.isArray(a[c])?b.push(goog.debug.exposeArray(a[c])):b.push(a[c])}return"[ "+b.join(", ")+" ]"};goog.debug.normalizeErrorObject=function(a){var b=goog.getObjectByName("window.location.href");if(goog.isString(a)){return{message:a,name:"Unknown error",lineNumber:"Not available",fileName:b,stack:"Not available"}
-}var c=!1;try{var d=a.lineNumber||a.line||"Not available"}catch(f){d="Not available",c=!0}try{var e=a.fileName||a.filename||a.sourceURL||goog.global.$googDebugFname||b}catch(f){e="Not available",c=!0}return !c&&a.lineNumber&&a.fileName&&a.stack&&a.message&&a.name?a:{message:a.message||"Not available",name:a.name||"UnknownError",lineNumber:d,fileName:e,stack:a.stack||"Not available"}};goog.debug.enhanceError=function(a,b){if(a instanceof Error){var c=a}else{c=Error(a),Error.captureStackTrace&&Error.captureStackTrace(c,goog.debug.enhanceError)}c.stack||(c.stack=goog.debug.getStacktrace(goog.debug.enhanceError));if(b){for(var d=0;c["message"+d];){++d}c["message"+d]=String(b)}return c};goog.debug.enhanceErrorWithContext=function(a,b){var c=goog.debug.enhanceError(a);if(b){for(var d in b){goog.debug.errorcontext.addErrorContext(c,d,b[d])}}return c};goog.debug.getStacktraceSimple=function(a){if(!goog.debug.FORCE_SLOPPY_STACKS){var b=goog.debug.getNativeStackTrace_(goog.debug.getStacktraceSimple);if(b){return b}}b=[];for(var c=arguments.callee.caller,d=0;c&&(!a||d<a);){b.push(goog.debug.getFunctionName(c));b.push("()\n");try{c=c.caller}catch(e){b.push("[exception trying to get caller]\n");break}d++;if(d>=goog.debug.MAX_STACK_DEPTH){b.push("[...long stack...]");break}}a&&d>=a?b.push("[...reached max depth limit...]"):b.push("[end]");return b.join("")};goog.debug.MAX_STACK_DEPTH=50;goog.debug.getNativeStackTrace_=function(a){var b=Error();if(Error.captureStackTrace){return Error.captureStackTrace(b,a),String(b.stack)}try{throw b}catch(c){b=c}return(a=b.stack)?String(a):null};goog.debug.getStacktrace=function(a){var b;goog.debug.FORCE_SLOPPY_STACKS||(b=goog.debug.getNativeStackTrace_(a||goog.debug.getStacktrace));b||(b=goog.debug.getStacktraceHelper_(a||arguments.callee.caller,[]));return b};goog.debug.getStacktraceHelper_=function(a,b){var c=[];if(goog.array.contains(b,a)){c.push("[...circular reference...]")}else{if(a&&b.length<goog.debug.MAX_STACK_DEPTH){c.push(goog.debug.getFunctionName(a)+"(");
-for(var d=a.arguments,e=0;d&&e<d.length;e++){0<e&&c.push(", ");var f=d[e];switch(typeof f){case"object":f=f?"object":"null";break;case"string":break;case"number":f=String(f);break;case"boolean":f=f?"true":"false";break;case"function":f=(f=goog.debug.getFunctionName(f))?f:"[fn]";break;default:f=typeof f}40<f.length&&(f=f.substr(0,40)+"...");c.push(f)}b.push(a);c.push(")\n");try{c.push(goog.debug.getStacktraceHelper_(a.caller,b))}catch(g){c.push("[exception trying to get caller]\n")}}else{a?c.push("[...long stack...]"):c.push("[end]")}}return c.join("")};goog.debug.setFunctionResolver=function(a){goog.debug.fnNameResolver_=a};goog.debug.getFunctionName=function(a){if(goog.debug.fnNameCache_[a]){return goog.debug.fnNameCache_[a]}if(goog.debug.fnNameResolver_){var b=goog.debug.fnNameResolver_(a);if(b){return goog.debug.fnNameCache_[a]=b}}a=String(a);goog.debug.fnNameCache_[a]||(b=/function ([^\(]+)/.exec(a),goog.debug.fnNameCache_[a]=b?b[1]:"[Anonymous]");return goog.debug.fnNameCache_[a]};goog.debug.makeWhitespaceVisible=function(a){return a.replace(/ /g,"[_]").replace(/\f/g,"[f]").replace(/\n/g,"[n]\n").replace(/\r/g,"[r]").replace(/\t/g,"[t]")};goog.debug.runtimeType=function(a){return a instanceof Function?a.displayName||a.name||"unknown type name":a instanceof Object?a.constructor.displayName||a.constructor.name||Object.prototype.toString.call(a):null===a?"null":typeof a};goog.debug.fnNameCache_={};goog.debug.freezeInternal_=goog.DEBUG&&Object.freeze||function(a){return a};goog.debug.freeze=function(a){return goog.debug.freezeInternal_(a)};goog.events={};$jscomp.scope.purify=function(a){return a()};goog.events.BrowserFeature={HAS_W3C_BUTTON:!goog.userAgent.IE||goog.userAgent.isDocumentModeOrHigher(9),HAS_W3C_EVENT_SUPPORT:!goog.userAgent.IE||goog.userAgent.isDocumentModeOrHigher(9),SET_KEY_CODE_TO_PREVENT_DEFAULT:goog.userAgent.IE&&!goog.userAgent.isVersionOrHigher("9"),HAS_NAVIGATOR_ONLINE_PROPERTY:!goog.userAgent.WEBKIT||goog.userAgent.isVersionOrHigher("528"),HAS_HTML5_NETWORK_EVENT_SUPPORT:goog.userAgent.GECKO&&goog.userAgent.isVersionOrHigher("1.9b")||goog.userAgent.IE&&goog.userAgent.isVersionOrHigher("8")||goog.userAgent.OPERA&&goog.userAgent.isVersionOrHigher("9.5")||goog.userAgent.WEBKIT&&goog.userAgent.isVersionOrHigher("528"),HTML5_NETWORK_EVENTS_FIRE_ON_BODY:goog.userAgent.GECKO&&!goog.userAgent.isVersionOrHigher("8")||goog.userAgent.IE&&!goog.userAgent.isVersionOrHigher("9"),TOUCH_ENABLED:"ontouchstart" in goog.global||!!(goog.global.document&&document.documentElement&&"ontouchstart" in document.documentElement)||!(!goog.global.navigator||!goog.global.navigator.maxTouchPoints&&!goog.global.navigator.msMaxTouchPoints),POINTER_EVENTS:"PointerEvent" in goog.global,MSPOINTER_EVENTS:"MSPointerEvent" in goog.global&&!(!goog.global.navigator||!goog.global.navigator.msPointerEnabled),PASSIVE_EVENTS:(0,$jscomp.scope.purify)(function(){if(!goog.global.addEventListener||!Object.defineProperty){return !1
-}var a=!1,b=Object.defineProperty({},"passive",{get:function(){a=!0}});goog.global.addEventListener("test",goog.nullFunction,b);goog.global.removeEventListener("test",goog.nullFunction,b);return a})};goog.events.EventId=function(a){this.id=a};goog.events.EventId.prototype.toString=function(){return this.id};goog.events.Event=function(a,b){this.type=a instanceof goog.events.EventId?String(a):a;this.currentTarget=this.target=b;this.defaultPrevented=this.propagationStopped_=!1;this.returnValue_=!0};goog.events.Event.prototype.stopPropagation=function(){this.propagationStopped_=!0};goog.events.Event.prototype.preventDefault=function(){this.defaultPrevented=!0;this.returnValue_=!1};goog.events.Event.stopPropagation=function(a){a.stopPropagation()};goog.events.Event.preventDefault=function(a){a.preventDefault()};goog.events.getVendorPrefixedName_=function(a){return goog.userAgent.WEBKIT?"webkit"+a:goog.userAgent.OPERA?"o"+a.toLowerCase():a.toLowerCase()};goog.events.EventType={CLICK:"click",RIGHTCLICK:"rightclick",DBLCLICK:"dblclick",MOUSEDOWN:"mousedown",MOUSEUP:"mouseup",MOUSEOVER:"mouseover",MOUSEOUT:"mouseout",MOUSEMOVE:"mousemove",MOUSEENTER:"mouseenter",MOUSELEAVE:"mouseleave",SELECTIONCHANGE:"selectionchange",SELECTSTART:"selectstart",WHEEL:"wheel",KEYPRESS:"keypress",KEYDOWN:"keydown",KEYUP:"keyup",BLUR:"blur",FOCUS:"focus",DEACTIVATE:"deactivate",FOCUSIN:goog.userAgent.IE?"focusin":"DOMFocusIn",FOCUSOUT:goog.userAgent.IE?"focusout":"DOMFocusOut",CHANGE:"change",RESET:"reset",SELECT:"select",SUBMIT:"submit",INPUT:"input",PROPERTYCHANGE:"propertychange",DRAGSTART:"dragstart",DRAG:"drag",DRAGENTER:"dragenter",DRAGOVER:"dragover",DRAGLEAVE:"dragleave",DROP:"drop",DRAGEND:"dragend",TOUCHSTART:"touchstart",TOUCHMOVE:"touchmove",TOUCHEND:"touchend",TOUCHCANCEL:"touchcancel",BEFOREUNLOAD:"beforeunload",CONSOLEMESSAGE:"consolemessage",CONTEXTMENU:"contextmenu",DEVICEMOTION:"devicemotion",DEVICEORIENTATION:"deviceorientation",DOMCONTENTLOADED:"DOMContentLoaded",ERROR:"error",HELP:"help",LOAD:"load",LOSECAPTURE:"losecapture",ORIENTATIONCHANGE:"orientationchange",READYSTATECHANGE:"readystatechange",RESIZE:"resize",SCROLL:"scroll",UNLOAD:"unload",CANPLAY:"canplay",CANPLAYTHROUGH:"canplaythrough",DURATIONCHANGE:"durationchange",EMPTIED:"emptied",ENDED:"ended",LOADEDDATA:"loadeddata",LOADEDMETADATA:"loadedmetadata",PAUSE:"pause",PLAY:"play",PLAYING:"playing",RATECHANGE:"ratechange",SEEKED:"seeked",SEEKING:"seeking",STALLED:"stalled",SUSPEND:"suspend",TIMEUPDATE:"timeupdate",VOLUMECHANGE:"volumechange",WAITING:"waiting",SOURCEOPEN:"sourceopen",SOURCEENDED:"sourceended",SOURCECLOSED:"sourceclosed",ABORT:"abort",UPDATE:"update",UPDATESTART:"updatestart",UPDATEEND:"updateend",HASHCHANGE:"hashchange",PAGEHIDE:"pagehide",PAGESHOW:"pageshow",POPSTATE:"popstate",COPY:"copy",PASTE:"paste",CUT:"cut",BEFORECOPY:"beforecopy",BEFORECUT:"beforecut",BEFOREPASTE:"beforepaste",ONLINE:"online",OFFLINE:"offline",MESSAGE:"message",CONNECT:"connect",INSTALL:"install",ACTIVATE:"activate",FETCH:"fetch",FOREIGNFETCH:"foreignfetch",MESSAGEERROR:"messageerror",STATECHANGE:"statechange",UPDATEFOUND:"updatefound",CONTROLLERCHANGE:"controllerchange",ANIMATIONSTART:goog.events.getVendorPrefixedName_("AnimationStart"),ANIMATIONEND:goog.events.getVendorPrefixedName_("AnimationEnd"),ANIMATIONITERATION:goog.events.getVendorPrefixedName_("AnimationIteration"),TRANSITIONEND:goog.events.getVendorPrefixedName_("TransitionEnd"),POINTERDOWN:"pointerdown",POINTERUP:"pointerup",POINTERCANCEL:"pointercancel",POINTERMOVE:"pointermove",POINTEROVER:"pointerover",POINTEROUT:"pointerout",POINTERENTER:"pointerenter",POINTERLEAVE:"pointerleave",GOTPOINTERCAPTURE:"gotpointercapture",LOSTPOINTERCAPTURE:"lostpointercapture",MSGESTURECHANGE:"MSGestureChange",MSGESTUREEND:"MSGestureEnd",MSGESTUREHOLD:"MSGestureHold",MSGESTURESTART:"MSGestureStart",MSGESTURETAP:"MSGestureTap",MSGOTPOINTERCAPTURE:"MSGotPointerCapture",MSINERTIASTART:"MSInertiaStart",MSLOSTPOINTERCAPTURE:"MSLostPointerCapture",MSPOINTERCANCEL:"MSPointerCancel",MSPOINTERDOWN:"MSPointerDown",MSPOINTERENTER:"MSPointerEnter",MSPOINTERHOVER:"MSPointerHover",MSPOINTERLEAVE:"MSPointerLeave",MSPOINTERMOVE:"MSPointerMove",MSPOINTEROUT:"MSPointerOut",MSPOINTEROVER:"MSPointerOver",MSPOINTERUP:"MSPointerUp",TEXT:"text",TEXTINPUT:goog.userAgent.IE?"textinput":"textInput",COMPOSITIONSTART:"compositionstart",COMPOSITIONUPDATE:"compositionupdate",COMPOSITIONEND:"compositionend",BEFOREINPUT:"beforeinput",EXIT:"exit",LOADABORT:"loadabort",LOADCOMMIT:"loadcommit",LOADREDIRECT:"loadredirect",LOADSTART:"loadstart",LOADSTOP:"loadstop",RESPONSIVE:"responsive",SIZECHANGED:"sizechanged",UNRESPONSIVE:"unresponsive",VISIBILITYCHANGE:"visibilitychange",STORAGE:"storage",DOMSUBTREEMODIFIED:"DOMSubtreeModified",DOMNODEINSERTED:"DOMNodeInserted",DOMNODEREMOVED:"DOMNodeRemoved",DOMNODEREMOVEDFROMDOCUMENT:"DOMNodeRemovedFromDocument",DOMNODEINSERTEDINTODOCUMENT:"DOMNodeInsertedIntoDocument",DOMATTRMODIFIED:"DOMAttrModified",DOMCHARACTERDATAMODIFIED:"DOMCharacterDataModified",BEFOREPRINT:"beforeprint",AFTERPRINT:"afterprint"};
-goog.events.getPointerFallbackEventName_=function(a,b,c){return goog.events.BrowserFeature.POINTER_EVENTS?a:goog.events.BrowserFeature.MSPOINTER_EVENTS?b:c};goog.events.PointerFallbackEventType={POINTERDOWN:goog.events.getPointerFallbackEventName_(goog.events.EventType.POINTERDOWN,goog.events.EventType.MSPOINTERDOWN,goog.events.EventType.MOUSEDOWN),POINTERUP:goog.events.getPointerFallbackEventName_(goog.events.EventType.POINTERUP,goog.events.EventType.MSPOINTERUP,goog.events.EventType.MOUSEUP),POINTERCANCEL:goog.events.getPointerFallbackEventName_(goog.events.EventType.POINTERCANCEL,goog.events.EventType.MSPOINTERCANCEL,"mousecancel"),POINTERMOVE:goog.events.getPointerFallbackEventName_(goog.events.EventType.POINTERMOVE,goog.events.EventType.MSPOINTERMOVE,goog.events.EventType.MOUSEMOVE),POINTEROVER:goog.events.getPointerFallbackEventName_(goog.events.EventType.POINTEROVER,goog.events.EventType.MSPOINTEROVER,goog.events.EventType.MOUSEOVER),POINTEROUT:goog.events.getPointerFallbackEventName_(goog.events.EventType.POINTEROUT,goog.events.EventType.MSPOINTEROUT,goog.events.EventType.MOUSEOUT),POINTERENTER:goog.events.getPointerFallbackEventName_(goog.events.EventType.POINTERENTER,goog.events.EventType.MSPOINTERENTER,goog.events.EventType.MOUSEENTER),POINTERLEAVE:goog.events.getPointerFallbackEventName_(goog.events.EventType.POINTERLEAVE,goog.events.EventType.MSPOINTERLEAVE,goog.events.EventType.MOUSELEAVE)};goog.events.BrowserEvent=function(a,b){goog.events.Event.call(this,a?a.type:"");this.relatedTarget=this.currentTarget=this.target=null;this.button=this.screenY=this.screenX=this.clientY=this.clientX=this.offsetY=this.offsetX=0;this.key="";this.charCode=this.keyCode=0;this.metaKey=this.shiftKey=this.altKey=this.ctrlKey=!1;this.state=null;this.platformModifierKey=!1;this.pointerId=0;this.pointerType="";this.event_=null;a&&this.init(a,b)};goog.inherits(goog.events.BrowserEvent,goog.events.Event);goog.events.BrowserEvent.MouseButton={LEFT:0,MIDDLE:1,RIGHT:2};goog.events.BrowserEvent.PointerType={MOUSE:"mouse",PEN:"pen",TOUCH:"touch"};
-goog.events.BrowserEvent.IEButtonMap=goog.debug.freeze([1,4,2]);goog.events.BrowserEvent.IE_BUTTON_MAP=goog.events.BrowserEvent.IEButtonMap;goog.events.BrowserEvent.IE_POINTER_TYPE_MAP=goog.debug.freeze({2:goog.events.BrowserEvent.PointerType.TOUCH,3:goog.events.BrowserEvent.PointerType.PEN,4:goog.events.BrowserEvent.PointerType.MOUSE});goog.events.BrowserEvent.prototype.init=function(a,b){var c=this.type=a.type,d=a.changedTouches?a.changedTouches[0]:null;this.target=a.target||a.srcElement;this.currentTarget=b;var e=a.relatedTarget;e?goog.userAgent.GECKO&&(goog.reflect.canAccessProperty(e,"nodeName")||(e=null)):c==goog.events.EventType.MOUSEOVER?e=a.fromElement:c==goog.events.EventType.MOUSEOUT&&(e=a.toElement);this.relatedTarget=e;goog.isNull(d)?(this.offsetX=goog.userAgent.WEBKIT||void 0!==a.offsetX?a.offsetX:a.layerX,this.offsetY=goog.userAgent.WEBKIT||void 0!==a.offsetY?a.offsetY:a.layerY,this.clientX=void 0!==a.clientX?a.clientX:a.pageX,this.clientY=void 0!==a.clientY?a.clientY:a.pageY,this.screenX=a.screenX||0,this.screenY=a.screenY||0):(this.clientX=void 0!==d.clientX?d.clientX:d.pageX,this.clientY=void 0!==d.clientY?d.clientY:d.pageY,this.screenX=d.screenX||0,this.screenY=d.screenY||0);this.button=a.button;this.keyCode=a.keyCode||0;this.key=a.key||"";this.charCode=a.charCode||("keypress"==c?a.keyCode:0);this.ctrlKey=a.ctrlKey;this.altKey=a.altKey;this.shiftKey=a.shiftKey;this.metaKey=a.metaKey;this.platformModifierKey=goog.userAgent.MAC?a.metaKey:a.ctrlKey;this.pointerId=a.pointerId||0;this.pointerType=goog.events.BrowserEvent.getPointerType_(a);this.state=a.state;this.event_=a;a.defaultPrevented&&this.preventDefault()};goog.events.BrowserEvent.prototype.isButton=function(a){return goog.events.BrowserFeature.HAS_W3C_BUTTON?this.event_.button==a:"click"==this.type?a==goog.events.BrowserEvent.MouseButton.LEFT:!!(this.event_.button&goog.events.BrowserEvent.IE_BUTTON_MAP[a])};goog.events.BrowserEvent.prototype.isMouseActionButton=function(){return this.isButton(goog.events.BrowserEvent.MouseButton.LEFT)&&!(goog.userAgent.WEBKIT&&goog.userAgent.MAC&&this.ctrlKey)
-};goog.events.BrowserEvent.prototype.stopPropagation=function(){goog.events.BrowserEvent.superClass_.stopPropagation.call(this);this.event_.stopPropagation?this.event_.stopPropagation():this.event_.cancelBubble=!0};goog.events.BrowserEvent.prototype.preventDefault=function(){goog.events.BrowserEvent.superClass_.preventDefault.call(this);var a=this.event_;if(a.preventDefault){a.preventDefault()}else{if(a.returnValue=!1,goog.events.BrowserFeature.SET_KEY_CODE_TO_PREVENT_DEFAULT){try{if(a.ctrlKey||112<=a.keyCode&&123>=a.keyCode){a.keyCode=-1}}catch(b){}}}};goog.events.BrowserEvent.prototype.getBrowserEvent=function(){return this.event_};goog.events.BrowserEvent.getPointerType_=function(a){return goog.isString(a.pointerType)?a.pointerType:goog.events.BrowserEvent.IE_POINTER_TYPE_MAP[a.pointerType]||""};goog.events.Listenable=function(){};goog.events.Listenable.IMPLEMENTED_BY_PROP="closure_listenable_"+(1000000*Math.random()|0);goog.events.Listenable.addImplementation=function(a){a.prototype[goog.events.Listenable.IMPLEMENTED_BY_PROP]=!0};goog.events.Listenable.isImplementedBy=function(a){return !(!a||!a[goog.events.Listenable.IMPLEMENTED_BY_PROP])};goog.events.ListenableKey=function(){};goog.events.ListenableKey.counter_=0;goog.events.ListenableKey.reserveKey=function(){return ++goog.events.ListenableKey.counter_};goog.events.Listener=function(a,b,c,d,e,f){goog.events.Listener.ENABLE_MONITORING&&(this.creationStack=Error().stack);this.listener=a;this.proxy=b;this.src=c;this.type=d;this.capture=!!e;this.handler=f;this.key=goog.events.ListenableKey.reserveKey();this.removed=this.callOnce=!1};goog.events.Listener.ENABLE_MONITORING=!1;goog.events.Listener.prototype.markAsRemoved=function(){this.removed=!0;this.handler=this.src=this.proxy=this.listener=null};goog.events.ListenerMap=function(a){this.src=a;this.listeners={};this.typeCount_=0};goog.events.ListenerMap.prototype.getTypeCount=function(){return this.typeCount_};goog.events.ListenerMap.prototype.getListenerCount=function(){var a=0,b;
-for(b in this.listeners){a+=this.listeners[b].length}return a};goog.events.ListenerMap.prototype.add=function(a,b,c,d,e){var f=a.toString();a=this.listeners[f];a||(a=this.listeners[f]=[],this.typeCount_++);var g=goog.events.ListenerMap.findListenerIndex_(a,b,d,e);-1<g?(b=a[g],c||(b.callOnce=!1)):(b=new goog.events.Listener(b,null,this.src,f,!!d,e),b.callOnce=c,a.push(b));return b};goog.events.ListenerMap.prototype.remove=function(a,b,c,d){a=a.toString();if(!(a in this.listeners)){return !1}var e=this.listeners[a];b=goog.events.ListenerMap.findListenerIndex_(e,b,c,d);return -1<b?(e[b].markAsRemoved(),goog.array.removeAt(e,b),0==e.length&&(delete this.listeners[a],this.typeCount_--),!0):!1};goog.events.ListenerMap.prototype.removeByKey=function(a){var b=a.type;if(!(b in this.listeners)){return !1}var c=goog.array.remove(this.listeners[b],a);c&&(a.markAsRemoved(),0==this.listeners[b].length&&(delete this.listeners[b],this.typeCount_--));return c};goog.events.ListenerMap.prototype.removeAll=function(a){a=a&&a.toString();var b=0,c;for(c in this.listeners){if(!a||c==a){for(var d=this.listeners[c],e=0;e<d.length;e++){++b,d[e].markAsRemoved()}delete this.listeners[c];this.typeCount_--}}return b};goog.events.ListenerMap.prototype.getListeners=function(a,b){var c=this.listeners[a.toString()],d=[];if(c){for(var e=0;e<c.length;++e){var f=c[e];f.capture==b&&d.push(f)}}return d};goog.events.ListenerMap.prototype.getListener=function(a,b,c,d){a=this.listeners[a.toString()];var e=-1;a&&(e=goog.events.ListenerMap.findListenerIndex_(a,b,c,d));return -1<e?a[e]:null};goog.events.ListenerMap.prototype.hasListener=function(a,b){var c=goog.isDef(a),d=c?a.toString():"",e=goog.isDef(b);return goog.object.some(this.listeners,function(a,g){for(var f=0;f<a.length;++f){if(!(c&&a[f].type!=d||e&&a[f].capture!=b)){return !0}}return !1})};goog.events.ListenerMap.findListenerIndex_=function(a,b,c,d){for(var e=0;e<a.length;++e){var f=a[e];if(!f.removed&&f.listener==b&&f.capture==!!c&&f.handler==d){return e
-}}return -1};goog.events.LISTENER_MAP_PROP_="closure_lm_"+(1000000*Math.random()|0);goog.events.onString_="on";goog.events.onStringMap_={};goog.events.CaptureSimulationMode={OFF_AND_FAIL:0,OFF_AND_SILENT:1,ON:2};goog.events.CAPTURE_SIMULATION_MODE=2;goog.events.listenerCountEstimate_=0;goog.events.listen=function(a,b,c,d,e){if(d&&d.once){return goog.events.listenOnce(a,b,c,d,e)}if(goog.isArray(b)){for(var f=0;f<b.length;f++){goog.events.listen(a,b[f],c,d,e)}return null}c=goog.events.wrapListener(c);return goog.events.Listenable.isImplementedBy(a)?(d=goog.isObject(d)?!!d.capture:!!d,a.listen(b,c,d,e)):goog.events.listen_(a,b,c,!1,d,e)};goog.events.listen_=function(a,b,c,d,e,f){if(!b){throw Error("Invalid event type")}var g=goog.isObject(e)?!!e.capture:!!e;if(g&&!goog.events.BrowserFeature.HAS_W3C_EVENT_SUPPORT){if(goog.events.CAPTURE_SIMULATION_MODE==goog.events.CaptureSimulationMode.OFF_AND_FAIL){return goog.asserts.fail("Can not register capture listener in IE8-."),null}if(goog.events.CAPTURE_SIMULATION_MODE==goog.events.CaptureSimulationMode.OFF_AND_SILENT){return null}}var h=goog.events.getListenerMap_(a);h||(a[goog.events.LISTENER_MAP_PROP_]=h=new goog.events.ListenerMap(a));c=h.add(b,c,d,g,f);if(c.proxy){return c}d=goog.events.getProxy();c.proxy=d;d.src=a;d.listener=c;if(a.addEventListener){goog.events.BrowserFeature.PASSIVE_EVENTS||(e=g),void 0===e&&(e=!1),a.addEventListener(b.toString(),d,e)}else{if(a.attachEvent){a.attachEvent(goog.events.getOnString_(b.toString()),d)}else{if(a.addListener&&a.removeListener){goog.asserts.assert("change"===b,"MediaQueryList only has a change event"),a.addListener(d)}else{throw Error("addEventListener and attachEvent are unavailable.")}}}goog.events.listenerCountEstimate_++;return c};goog.events.getProxy=function(){var a=goog.events.handleBrowserEvent_,b=goog.events.BrowserFeature.HAS_W3C_EVENT_SUPPORT?function(c){return a.call(b.src,b.listener,c)}:function(c){c=a.call(b.src,b.listener,c);if(!c){return c}};return b};goog.events.listenOnce=function(a,b,c,d,e){if(goog.isArray(b)){for(var f=0;
-f<b.length;f++){goog.events.listenOnce(a,b[f],c,d,e)}return null}c=goog.events.wrapListener(c);return goog.events.Listenable.isImplementedBy(a)?(d=goog.isObject(d)?!!d.capture:!!d,a.listenOnce(b,c,d,e)):goog.events.listen_(a,b,c,!0,d,e)};goog.events.listenWithWrapper=function(a,b,c,d,e){b.listen(a,c,d,e)};goog.events.unlisten=function(a,b,c,d,e){if(goog.isArray(b)){for(var f=0;f<b.length;f++){goog.events.unlisten(a,b[f],c,d,e)}return null}d=goog.isObject(d)?!!d.capture:!!d;c=goog.events.wrapListener(c);if(goog.events.Listenable.isImplementedBy(a)){return a.unlisten(b,c,d,e)}if(!a){return !1}if(a=goog.events.getListenerMap_(a)){if(b=a.getListener(b,c,d,e)){return goog.events.unlistenByKey(b)}}return !1};goog.events.unlistenByKey=function(a){if(goog.isNumber(a)||!a||a.removed){return !1}var b=a.src;if(goog.events.Listenable.isImplementedBy(b)){return b.unlistenByKey(a)}var c=a.type,d=a.proxy;b.removeEventListener?b.removeEventListener(c,d,a.capture):b.detachEvent?b.detachEvent(goog.events.getOnString_(c),d):b.addListener&&b.removeListener&&b.removeListener(d);goog.events.listenerCountEstimate_--;(c=goog.events.getListenerMap_(b))?(c.removeByKey(a),0==c.getTypeCount()&&(c.src=null,b[goog.events.LISTENER_MAP_PROP_]=null)):a.markAsRemoved();return !0};goog.events.unlistenWithWrapper=function(a,b,c,d,e){b.unlisten(a,c,d,e)};goog.events.removeAll=function(a,b){if(!a){return 0}if(goog.events.Listenable.isImplementedBy(a)){return a.removeAllListeners(b)}var c=goog.events.getListenerMap_(a);if(!c){return 0}var d=0,e=b&&b.toString(),f;for(f in c.listeners){if(!e||f==e){for(var g=c.listeners[f].concat(),h=0;h<g.length;++h){goog.events.unlistenByKey(g[h])&&++d}}}return d};goog.events.getListeners=function(a,b,c){return goog.events.Listenable.isImplementedBy(a)?a.getListeners(b,c):a?(a=goog.events.getListenerMap_(a))?a.getListeners(b,c):[]:[]};goog.events.getListener=function(a,b,c,d,e){c=goog.events.wrapListener(c);d=!!d;return goog.events.Listenable.isImplementedBy(a)?a.getListener(b,c,d,e):a?(a=goog.events.getListenerMap_(a))?a.getListener(b,c,d,e):null:null
-};goog.events.hasListener=function(a,b,c){if(goog.events.Listenable.isImplementedBy(a)){return a.hasListener(b,c)}a=goog.events.getListenerMap_(a);return !!a&&a.hasListener(b,c)};goog.events.expose=function(a){var b=[],c;for(c in a){a[c]&&a[c].id?b.push(c+" = "+a[c]+" ("+a[c].id+")"):b.push(c+" = "+a[c])}return b.join("\n")};goog.events.getOnString_=function(a){return a in goog.events.onStringMap_?goog.events.onStringMap_[a]:goog.events.onStringMap_[a]=goog.events.onString_+a};goog.events.fireListeners=function(a,b,c,d){return goog.events.Listenable.isImplementedBy(a)?a.fireListeners(b,c,d):goog.events.fireListeners_(a,b,c,d)};goog.events.fireListeners_=function(a,b,c,d){var e=!0;if(a=goog.events.getListenerMap_(a)){if(b=a.listeners[b.toString()]){for(b=b.concat(),a=0;a<b.length;a++){var f=b[a];f&&f.capture==c&&!f.removed&&(f=goog.events.fireListener(f,d),e=e&&!1!==f)}}}return e};goog.events.fireListener=function(a,b){var c=a.listener,d=a.handler||a.src;a.callOnce&&goog.events.unlistenByKey(a);return c.call(d,b)};goog.events.getTotalListenerCount=function(){return goog.events.listenerCountEstimate_};goog.events.dispatchEvent=function(a,b){goog.asserts.assert(goog.events.Listenable.isImplementedBy(a),"Can not use goog.events.dispatchEvent with non-goog.events.Listenable instance.");return a.dispatchEvent(b)};goog.events.protectBrowserEventEntryPoint=function(a){goog.events.handleBrowserEvent_=a.protectEntryPoint(goog.events.handleBrowserEvent_)};goog.events.handleBrowserEvent_=function(a,b){if(a.removed){return !0}if(!goog.events.BrowserFeature.HAS_W3C_EVENT_SUPPORT){var c=b||goog.getObjectByName("window.event"),d=new goog.events.BrowserEvent(c,this),e=!0;if(goog.events.CAPTURE_SIMULATION_MODE==goog.events.CaptureSimulationMode.ON){if(!goog.events.isMarkedIeEvent_(c)){goog.events.markIeEvent_(c);c=[];for(var f=d.currentTarget;f;f=f.parentNode){c.push(f)}f=a.type;for(var g=c.length-1;!d.propagationStopped_&&0<=g;g--){d.currentTarget=c[g];var h=goog.events.fireListeners_(c[g],f,!0,d);
-e=e&&h}for(g=0;!d.propagationStopped_&&g<c.length;g++){d.currentTarget=c[g],h=goog.events.fireListeners_(c[g],f,!1,d),e=e&&h}}}else{e=goog.events.fireListener(a,d)}return e}return goog.events.fireListener(a,new goog.events.BrowserEvent(b,this))};goog.events.markIeEvent_=function(a){var b=!1;if(0==a.keyCode){try{a.keyCode=-1;return}catch(c){b=!0}}if(b||void 0==a.returnValue){a.returnValue=!0}};goog.events.isMarkedIeEvent_=function(a){return 0>a.keyCode||void 0!=a.returnValue};goog.events.uniqueIdCounter_=0;goog.events.getUniqueId=function(a){return a+"_"+goog.events.uniqueIdCounter_++};goog.events.getListenerMap_=function(a){a=a[goog.events.LISTENER_MAP_PROP_];return a instanceof goog.events.ListenerMap?a:null};goog.events.LISTENER_WRAPPER_PROP_="__closure_events_fn_"+(1000000000*Math.random()>>>0);goog.events.wrapListener=function(a){goog.asserts.assert(a,"Listener can not be null.");if(goog.isFunction(a)){return a}goog.asserts.assert(a.handleEvent,"An object listener must have handleEvent method.");a[goog.events.LISTENER_WRAPPER_PROP_]||(a[goog.events.LISTENER_WRAPPER_PROP_]=function(b){return a.handleEvent(b)});return a[goog.events.LISTENER_WRAPPER_PROP_]};goog.debug.entryPointRegistry.register(function(a){goog.events.handleBrowserEvent_=a(goog.events.handleBrowserEvent_)});goog.events.EventTarget=function(){goog.Disposable.call(this);this.eventTargetListeners_=new goog.events.ListenerMap(this);this.actualEventTarget_=this;this.parentEventTarget_=null};goog.inherits(goog.events.EventTarget,goog.Disposable);goog.events.Listenable.addImplementation(goog.events.EventTarget);goog.events.EventTarget.MAX_ANCESTORS_=1000;goog.events.EventTarget.prototype.getParentEventTarget=function(){return this.parentEventTarget_};goog.events.EventTarget.prototype.setParentEventTarget=function(a){this.parentEventTarget_=a};goog.events.EventTarget.prototype.addEventListener=function(a,b,c,d){goog.events.listen(this,a,b,c,d)};goog.events.EventTarget.prototype.removeEventListener=function(a,b,c,d){goog.events.unlisten(this,a,b,c,d)
-};goog.events.EventTarget.prototype.dispatchEvent=function(a){this.assertInitialized_();var b=this.getParentEventTarget();if(b){var c=[];for(var d=1;b;b=b.getParentEventTarget()){c.push(b),goog.asserts.assert(++d<goog.events.EventTarget.MAX_ANCESTORS_,"infinite loop")}}return goog.events.EventTarget.dispatchEventInternal_(this.actualEventTarget_,a,c)};goog.events.EventTarget.prototype.disposeInternal=function(){goog.events.EventTarget.superClass_.disposeInternal.call(this);this.removeAllListeners();this.parentEventTarget_=null};goog.events.EventTarget.prototype.listen=function(a,b,c,d){this.assertInitialized_();return this.eventTargetListeners_.add(String(a),b,!1,c,d)};goog.events.EventTarget.prototype.listenOnce=function(a,b,c,d){return this.eventTargetListeners_.add(String(a),b,!0,c,d)};goog.events.EventTarget.prototype.unlisten=function(a,b,c,d){return this.eventTargetListeners_.remove(String(a),b,c,d)};goog.events.EventTarget.prototype.unlistenByKey=function(a){return this.eventTargetListeners_.removeByKey(a)};goog.events.EventTarget.prototype.removeAllListeners=function(a){return this.eventTargetListeners_?this.eventTargetListeners_.removeAll(a):0};goog.events.EventTarget.prototype.fireListeners=function(a,b,c){a=this.eventTargetListeners_.listeners[String(a)];if(!a){return !0}a=a.concat();for(var d=!0,e=0;e<a.length;++e){var f=a[e];if(f&&!f.removed&&f.capture==b){var g=f.listener,h=f.handler||f.src;f.callOnce&&this.unlistenByKey(f);d=!1!==g.call(h,c)&&d}}return d&&0!=c.returnValue_};goog.events.EventTarget.prototype.getListeners=function(a,b){return this.eventTargetListeners_.getListeners(String(a),b)};goog.events.EventTarget.prototype.getListener=function(a,b,c,d){return this.eventTargetListeners_.getListener(String(a),b,c,d)};goog.events.EventTarget.prototype.hasListener=function(a,b){var c=goog.isDef(a)?String(a):void 0;return this.eventTargetListeners_.hasListener(c,b)};goog.events.EventTarget.prototype.setTargetForTesting=function(a){this.actualEventTarget_=a
-};goog.events.EventTarget.prototype.assertInitialized_=function(){goog.asserts.assert(this.eventTargetListeners_,"Event target is not initialized. Did you call the superclass (goog.events.EventTarget) constructor?")};goog.events.EventTarget.dispatchEventInternal_=function(a,b,c){var d=b.type||b;if(goog.isString(b)){b=new goog.events.Event(b,a)}else{if(b instanceof goog.events.Event){b.target=b.target||a}else{var e=b;b=new goog.events.Event(d,a);goog.object.extend(b,e)}}e=!0;if(c){for(var f=c.length-1;!b.propagationStopped_&&0<=f;f--){var g=b.currentTarget=c[f];e=g.fireListeners(d,!0,b)&&e}}b.propagationStopped_||(g=b.currentTarget=a,e=g.fireListeners(d,!0,b)&&e,b.propagationStopped_||(e=g.fireListeners(d,!1,b)&&e));if(c){for(f=0;!b.propagationStopped_&&f<c.length;f++){g=b.currentTarget=c[f],e=g.fireListeners(d,!1,b)&&e}}return e};goog.Timer=function(a,b){goog.events.EventTarget.call(this);this.interval_=a||1;this.timerObject_=b||goog.Timer.defaultTimerObject;this.boundTick_=goog.bind(this.tick_,this);this.last_=goog.now()};goog.inherits(goog.Timer,goog.events.EventTarget);goog.Timer.MAX_TIMEOUT_=2147483647;goog.Timer.INVALID_TIMEOUT_ID_=-1;goog.Timer.prototype.enabled=!1;goog.Timer.defaultTimerObject=goog.global;goog.Timer.intervalScale=0.8;goog.Timer.prototype.timer_=null;goog.Timer.prototype.getInterval=function(){return this.interval_};goog.Timer.prototype.setInterval=function(a){this.interval_=a;this.timer_&&this.enabled?(this.stop(),this.start()):this.timer_&&this.stop()};goog.Timer.prototype.tick_=function(){if(this.enabled){var a=goog.now()-this.last_;0<a&&a<this.interval_*goog.Timer.intervalScale?this.timer_=this.timerObject_.setTimeout(this.boundTick_,this.interval_-a):(this.timer_&&(this.timerObject_.clearTimeout(this.timer_),this.timer_=null),this.dispatchTick(),this.enabled&&(this.timer_=this.timerObject_.setTimeout(this.boundTick_,this.interval_),this.last_=goog.now()))}};goog.Timer.prototype.dispatchTick=function(){this.dispatchEvent(goog.Timer.TICK)};goog.Timer.prototype.start=function(){this.enabled=!0;
-this.timer_||(this.timer_=this.timerObject_.setTimeout(this.boundTick_,this.interval_),this.last_=goog.now())};goog.Timer.prototype.stop=function(){this.enabled=!1;this.timer_&&(this.timerObject_.clearTimeout(this.timer_),this.timer_=null)};goog.Timer.prototype.disposeInternal=function(){goog.Timer.superClass_.disposeInternal.call(this);this.stop();delete this.timerObject_};goog.Timer.TICK="tick";goog.Timer.callOnce=function(a,b,c){if(goog.isFunction(a)){c&&(a=goog.bind(a,c))}else{if(a&&"function"==typeof a.handleEvent){a=goog.bind(a.handleEvent,a)}else{throw Error("Invalid listener argument")}}return Number(b)>goog.Timer.MAX_TIMEOUT_?goog.Timer.INVALID_TIMEOUT_ID_:goog.Timer.defaultTimerObject.setTimeout(a,b||0)};goog.Timer.clear=function(a){goog.Timer.defaultTimerObject.clearTimeout(a)};goog.Timer.promise=function(a,b){var c=null;return(new goog.Promise(function(d,e){c=goog.Timer.callOnce(function(){d(b)},a);c==goog.Timer.INVALID_TIMEOUT_ID_&&e(Error("Failed to schedule timer."))})).thenCatch(function(a){goog.Timer.clear(c);throw a})};goog.dom.BrowserFeature={CAN_ADD_NAME_OR_TYPE_ATTRIBUTES:!goog.userAgent.IE||goog.userAgent.isDocumentModeOrHigher(9),CAN_USE_CHILDREN_ATTRIBUTE:!goog.userAgent.GECKO&&!goog.userAgent.IE||goog.userAgent.IE&&goog.userAgent.isDocumentModeOrHigher(9)||goog.userAgent.GECKO&&goog.userAgent.isVersionOrHigher("1.9.1"),CAN_USE_INNER_TEXT:goog.userAgent.IE&&!goog.userAgent.isVersionOrHigher("9"),CAN_USE_PARENT_ELEMENT_PROPERTY:goog.userAgent.IE||goog.userAgent.OPERA||goog.userAgent.WEBKIT,INNER_HTML_NEEDS_SCOPED_ELEMENT:goog.userAgent.IE,LEGACY_IE_RANGES:goog.userAgent.IE&&!goog.userAgent.isDocumentModeOrHigher(9)};goog.dom.asserts={};goog.dom.asserts.assertIsLocation=function(a){if(goog.asserts.ENABLE_ASSERTS){var b=goog.dom.asserts.getWindow_(a);"undefined"!=typeof b.Location&&"undefined"!=typeof b.Element&&goog.asserts.assert(a&&(a instanceof b.Location||!(a instanceof b.Element)),"Argument is not a Location (or a non-Element mock); got: %s",goog.dom.asserts.debugStringForType_(a))
-}return a};goog.dom.asserts.assertIsElementType_=function(a,b){if(goog.asserts.ENABLE_ASSERTS){var c=goog.dom.asserts.getWindow_(a);"undefined"!=typeof c[b]&&"undefined"!=typeof c.Location&&"undefined"!=typeof c.Element&&goog.asserts.assert(a&&(a instanceof c[b]||!(a instanceof c.Location||a instanceof c.Element)),"Argument is not a %s (or a non-Element, non-Location mock); got: %s",b,goog.dom.asserts.debugStringForType_(a))}return a};goog.dom.asserts.assertIsHTMLAnchorElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLAnchorElement")};goog.dom.asserts.assertIsHTMLButtonElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLButtonElement")};goog.dom.asserts.assertIsHTMLLinkElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLLinkElement")};goog.dom.asserts.assertIsHTMLImageElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLImageElement")};goog.dom.asserts.assertIsHTMLInputElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLInputElement")};goog.dom.asserts.assertIsHTMLEmbedElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLEmbedElement")};goog.dom.asserts.assertIsHTMLFormElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLFormElement")};goog.dom.asserts.assertIsHTMLFrameElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLFrameElement")};goog.dom.asserts.assertIsHTMLIFrameElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLIFrameElement")};goog.dom.asserts.assertIsHTMLObjectElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLObjectElement")};goog.dom.asserts.assertIsHTMLScriptElement=function(a){return goog.dom.asserts.assertIsElementType_(a,"HTMLScriptElement")};goog.dom.asserts.debugStringForType_=function(a){return goog.isObject(a)?a.constructor.displayName||a.constructor.name||Object.prototype.toString.call(a):void 0===a?"undefined":null===a?"null":typeof a};goog.dom.asserts.getWindow_=function(a){return(a=a&&a.ownerDocument)&&(a.defaultView||a.parentWindow)||goog.global
-};goog.dom.tags={};goog.dom.tags.VOID_TAGS_={area:!0,base:!0,br:!0,col:!0,command:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0};goog.dom.tags.isVoidTag=function(a){return !0===goog.dom.tags.VOID_TAGS_[a]};goog.string.TypedString=function(){};goog.string.Const=function(){this.stringConstValueWithSecurityContract__googStringSecurityPrivate_="";this.STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_=goog.string.Const.TYPE_MARKER_};goog.string.Const.prototype.implementsGoogStringTypedString=!0;goog.string.Const.prototype.getTypedStringValue=function(){return this.stringConstValueWithSecurityContract__googStringSecurityPrivate_};goog.string.Const.prototype.toString=function(){return"Const{"+this.stringConstValueWithSecurityContract__googStringSecurityPrivate_+"}"};goog.string.Const.unwrap=function(a){if(a instanceof goog.string.Const&&a.constructor===goog.string.Const&&a.STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_===goog.string.Const.TYPE_MARKER_){return a.stringConstValueWithSecurityContract__googStringSecurityPrivate_}goog.asserts.fail("expected object of type Const, got '"+a+"'");return"type_error:Const"};goog.string.Const.from=function(a){return goog.string.Const.create__googStringSecurityPrivate_(a)};goog.string.Const.TYPE_MARKER_={};goog.string.Const.create__googStringSecurityPrivate_=function(a){var b=new goog.string.Const;b.stringConstValueWithSecurityContract__googStringSecurityPrivate_=a;return b};goog.string.Const.EMPTY=goog.string.Const.from("");goog.html={};goog.html.SafeScript=function(){this.privateDoNotAccessOrElseSafeScriptWrappedValue_="";this.SAFE_SCRIPT_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_=goog.html.SafeScript.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_};goog.html.SafeScript.prototype.implementsGoogStringTypedString=!0;goog.html.SafeScript.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_={};goog.html.SafeScript.fromConstant=function(a){a=goog.string.Const.unwrap(a);return 0===a.length?goog.html.SafeScript.EMPTY:goog.html.SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(a)
-};goog.html.SafeScript.prototype.getTypedStringValue=function(){return this.privateDoNotAccessOrElseSafeScriptWrappedValue_};goog.DEBUG&&(goog.html.SafeScript.prototype.toString=function(){return"SafeScript{"+this.privateDoNotAccessOrElseSafeScriptWrappedValue_+"}"});goog.html.SafeScript.unwrap=function(a){if(a instanceof goog.html.SafeScript&&a.constructor===goog.html.SafeScript&&a.SAFE_SCRIPT_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_===goog.html.SafeScript.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_){return a.privateDoNotAccessOrElseSafeScriptWrappedValue_}goog.asserts.fail("expected object of type SafeScript, got '"+a+"' of type "+goog.typeOf(a));return"type_error:SafeScript"};goog.html.SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse=function(a){return(new goog.html.SafeScript).initSecurityPrivateDoNotAccessOrElse_(a)};goog.html.SafeScript.prototype.initSecurityPrivateDoNotAccessOrElse_=function(a){this.privateDoNotAccessOrElseSafeScriptWrappedValue_=a;return this};goog.html.SafeScript.EMPTY=goog.html.SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse("");goog.fs={};goog.fs.url={};goog.fs.url.createObjectUrl=function(a){return goog.fs.url.getUrlObject_().createObjectURL(a)};goog.fs.url.revokeObjectUrl=function(a){goog.fs.url.getUrlObject_().revokeObjectURL(a)};goog.fs.url.getUrlObject_=function(){var a=goog.fs.url.findUrlObject_();if(null!=a){return a}throw Error("This browser doesn't seem to support blob URLs")};goog.fs.url.findUrlObject_=function(){return goog.isDef(goog.global.URL)&&goog.isDef(goog.global.URL.createObjectURL)?goog.global.URL:goog.isDef(goog.global.webkitURL)&&goog.isDef(goog.global.webkitURL.createObjectURL)?goog.global.webkitURL:goog.isDef(goog.global.createObjectURL)?goog.global:null};goog.fs.url.browserSupportsObjectUrls=function(){return null!=goog.fs.url.findUrlObject_()};goog.i18n={};goog.i18n.bidi={};goog.i18n.bidi.FORCE_RTL=!1;goog.i18n.bidi.IS_RTL=goog.i18n.bidi.FORCE_RTL||("ar"==goog.LOCALE.substring(0,2).toLowerCase()||"fa"==goog.LOCALE.substring(0,2).toLowerCase()||"he"==goog.LOCALE.substring(0,2).toLowerCase()||"iw"==goog.LOCALE.substring(0,2).toLowerCase()||"ps"==goog.LOCALE.substring(0,2).toLowerCase()||"sd"==goog.LOCALE.substring(0,2).toLowerCase()||"ug"==goog.LOCALE.substring(0,2).toLowerCase()||"ur"==goog.LOCALE.substring(0,2).toLowerCase()||"yi"==goog.LOCALE.substring(0,2).toLowerCase())&&(2==goog.LOCALE.length||"-"==goog.LOCALE.substring(2,3)||"_"==goog.LOCALE.substring(2,3))||3<=goog.LOCALE.length&&"ckb"==goog.LOCALE.substring(0,3).toLowerCase()&&(3==goog.LOCALE.length||"-"==goog.LOCALE.substring(3,4)||"_"==goog.LOCALE.substring(3,4));
-goog.i18n.bidi.Format={LRE:"\u202a",RLE:"\u202b",PDF:"\u202c",LRM:"\u200e",RLM:"\u200f"};goog.i18n.bidi.Dir={LTR:1,RTL:-1,NEUTRAL:0};goog.i18n.bidi.RIGHT="right";goog.i18n.bidi.LEFT="left";goog.i18n.bidi.I18N_RIGHT=goog.i18n.bidi.IS_RTL?goog.i18n.bidi.LEFT:goog.i18n.bidi.RIGHT;goog.i18n.bidi.I18N_LEFT=goog.i18n.bidi.IS_RTL?goog.i18n.bidi.RIGHT:goog.i18n.bidi.LEFT;goog.i18n.bidi.toDir=function(a,b){return"number"==typeof a?0<a?goog.i18n.bidi.Dir.LTR:0>a?goog.i18n.bidi.Dir.RTL:b?null:goog.i18n.bidi.Dir.NEUTRAL:null==a?null:a?goog.i18n.bidi.Dir.RTL:goog.i18n.bidi.Dir.LTR};goog.i18n.bidi.ltrChars_="A-Za-z\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u02b8\u0300-\u0590\u0800-\u1fff\u200e\u2c00-\ufb1c\ufe00-\ufe6f\ufefd-\uffff";goog.i18n.bidi.rtlChars_="\u0591-\u06ef\u06fa-\u07ff\u200f\ufb1d-\ufdff\ufe70-\ufefc";goog.i18n.bidi.htmlSkipReg_=/<[^>]*>|&[^;]+;/g;goog.i18n.bidi.stripHtmlIfNeeded_=function(a,b){return b?a.replace(goog.i18n.bidi.htmlSkipReg_,""):a};goog.i18n.bidi.rtlCharReg_=new RegExp("["+goog.i18n.bidi.rtlChars_+"]");goog.i18n.bidi.ltrCharReg_=new RegExp("["+goog.i18n.bidi.ltrChars_+"]");goog.i18n.bidi.hasAnyRtl=function(a,b){return goog.i18n.bidi.rtlCharReg_.test(goog.i18n.bidi.stripHtmlIfNeeded_(a,b))};goog.i18n.bidi.hasRtlChar=goog.i18n.bidi.hasAnyRtl;goog.i18n.bidi.hasAnyLtr=function(a,b){return goog.i18n.bidi.ltrCharReg_.test(goog.i18n.bidi.stripHtmlIfNeeded_(a,b))};goog.i18n.bidi.ltrRe_=new RegExp("^["+goog.i18n.bidi.ltrChars_+"]");goog.i18n.bidi.rtlRe_=new RegExp("^["+goog.i18n.bidi.rtlChars_+"]");goog.i18n.bidi.isRtlChar=function(a){return goog.i18n.bidi.rtlRe_.test(a)};goog.i18n.bidi.isLtrChar=function(a){return goog.i18n.bidi.ltrRe_.test(a)};goog.i18n.bidi.isNeutralChar=function(a){return !goog.i18n.bidi.isLtrChar(a)&&!goog.i18n.bidi.isRtlChar(a)};goog.i18n.bidi.ltrDirCheckRe_=new RegExp("^[^"+goog.i18n.bidi.rtlChars_+"]*["+goog.i18n.bidi.ltrChars_+"]");goog.i18n.bidi.rtlDirCheckRe_=new RegExp("^[^"+goog.i18n.bidi.ltrChars_+"]*["+goog.i18n.bidi.rtlChars_+"]");goog.i18n.bidi.startsWithRtl=function(a,b){return goog.i18n.bidi.rtlDirCheckRe_.test(goog.i18n.bidi.stripHtmlIfNeeded_(a,b))
-};goog.i18n.bidi.isRtlText=goog.i18n.bidi.startsWithRtl;goog.i18n.bidi.startsWithLtr=function(a,b){return goog.i18n.bidi.ltrDirCheckRe_.test(goog.i18n.bidi.stripHtmlIfNeeded_(a,b))};goog.i18n.bidi.isLtrText=goog.i18n.bidi.startsWithLtr;goog.i18n.bidi.isRequiredLtrRe_=/^http:\/\/.*/;goog.i18n.bidi.isNeutralText=function(a,b){a=goog.i18n.bidi.stripHtmlIfNeeded_(a,b);return goog.i18n.bidi.isRequiredLtrRe_.test(a)||!goog.i18n.bidi.hasAnyLtr(a)&&!goog.i18n.bidi.hasAnyRtl(a)};goog.i18n.bidi.ltrExitDirCheckRe_=new RegExp("["+goog.i18n.bidi.ltrChars_+"][^"+goog.i18n.bidi.rtlChars_+"]*$");goog.i18n.bidi.rtlExitDirCheckRe_=new RegExp("["+goog.i18n.bidi.rtlChars_+"][^"+goog.i18n.bidi.ltrChars_+"]*$");goog.i18n.bidi.endsWithLtr=function(a,b){return goog.i18n.bidi.ltrExitDirCheckRe_.test(goog.i18n.bidi.stripHtmlIfNeeded_(a,b))};goog.i18n.bidi.isLtrExitText=goog.i18n.bidi.endsWithLtr;goog.i18n.bidi.endsWithRtl=function(a,b){return goog.i18n.bidi.rtlExitDirCheckRe_.test(goog.i18n.bidi.stripHtmlIfNeeded_(a,b))};goog.i18n.bidi.isRtlExitText=goog.i18n.bidi.endsWithRtl;goog.i18n.bidi.rtlLocalesRe_=/^(ar|ckb|dv|he|iw|fa|nqo|ps|sd|ug|ur|yi|.*[-_](Arab|Hebr|Thaa|Nkoo|Tfng))(?!.*[-_](Latn|Cyrl)($|-|_))($|-|_)/i;goog.i18n.bidi.isRtlLanguage=function(a){return goog.i18n.bidi.rtlLocalesRe_.test(a)};goog.i18n.bidi.bracketGuardTextRe_=/(\(.*?\)+)|(\[.*?\]+)|(\{.*?\}+)|(<.*?>+)/g;goog.i18n.bidi.guardBracketInText=function(a,b){var c=(void 0===b?goog.i18n.bidi.hasAnyRtl(a):b)?goog.i18n.bidi.Format.RLM:goog.i18n.bidi.Format.LRM;return a.replace(goog.i18n.bidi.bracketGuardTextRe_,c+"$&"+c)};goog.i18n.bidi.enforceRtlInHtml=function(a){return"<"==a.charAt(0)?a.replace(/<\w+/,"$& dir=rtl"):"\n<span dir=rtl>"+a+"</span>"};goog.i18n.bidi.enforceRtlInText=function(a){return goog.i18n.bidi.Format.RLE+a+goog.i18n.bidi.Format.PDF};goog.i18n.bidi.enforceLtrInHtml=function(a){return"<"==a.charAt(0)?a.replace(/<\w+/,"$& dir=ltr"):"\n<span dir=ltr>"+a+"</span>"};goog.i18n.bidi.enforceLtrInText=function(a){return goog.i18n.bidi.Format.LRE+a+goog.i18n.bidi.Format.PDF
-};goog.i18n.bidi.dimensionsRe_=/:\s*([.\d][.\w]*)\s+([.\d][.\w]*)\s+([.\d][.\w]*)\s+([.\d][.\w]*)/g;goog.i18n.bidi.leftRe_=/left/gi;goog.i18n.bidi.rightRe_=/right/gi;goog.i18n.bidi.tempRe_=/%%%%/g;goog.i18n.bidi.mirrorCSS=function(a){return a.replace(goog.i18n.bidi.dimensionsRe_,":$1 $4 $3 $2").replace(goog.i18n.bidi.leftRe_,"%%%%").replace(goog.i18n.bidi.rightRe_,goog.i18n.bidi.LEFT).replace(goog.i18n.bidi.tempRe_,goog.i18n.bidi.RIGHT)};goog.i18n.bidi.doubleQuoteSubstituteRe_=/([\u0591-\u05f2])"/g;goog.i18n.bidi.singleQuoteSubstituteRe_=/([\u0591-\u05f2])'/g;goog.i18n.bidi.normalizeHebrewQuote=function(a){return a.replace(goog.i18n.bidi.doubleQuoteSubstituteRe_,"$1\u05f4").replace(goog.i18n.bidi.singleQuoteSubstituteRe_,"$1\u05f3")};goog.i18n.bidi.wordSeparatorRe_=/\s+/;goog.i18n.bidi.hasNumeralsRe_=/[\d\u06f0-\u06f9]/;goog.i18n.bidi.rtlDetectionThreshold_=0.4;goog.i18n.bidi.estimateDirection=function(a,b){for(var c=0,d=0,e=!1,f=goog.i18n.bidi.stripHtmlIfNeeded_(a,b).split(goog.i18n.bidi.wordSeparatorRe_),g=0;g<f.length;g++){var h=f[g];goog.i18n.bidi.startsWithRtl(h)?(c++,d++):goog.i18n.bidi.isRequiredLtrRe_.test(h)?e=!0:goog.i18n.bidi.hasAnyLtr(h)?d++:goog.i18n.bidi.hasNumeralsRe_.test(h)&&(e=!0)}return 0==d?e?goog.i18n.bidi.Dir.LTR:goog.i18n.bidi.Dir.NEUTRAL:c/d>goog.i18n.bidi.rtlDetectionThreshold_?goog.i18n.bidi.Dir.RTL:goog.i18n.bidi.Dir.LTR};goog.i18n.bidi.detectRtlDirectionality=function(a,b){return goog.i18n.bidi.estimateDirection(a,b)==goog.i18n.bidi.Dir.RTL};goog.i18n.bidi.setElementDirAndAlign=function(a,b){a&&(b=goog.i18n.bidi.toDir(b))&&(a.style.textAlign=b==goog.i18n.bidi.Dir.RTL?goog.i18n.bidi.RIGHT:goog.i18n.bidi.LEFT,a.dir=b==goog.i18n.bidi.Dir.RTL?"rtl":"ltr")};goog.i18n.bidi.setElementDirByTextDirectionality=function(a,b){switch(goog.i18n.bidi.estimateDirection(b)){case goog.i18n.bidi.Dir.LTR:a.dir="ltr";break;case goog.i18n.bidi.Dir.RTL:a.dir="rtl";break;default:a.removeAttribute("dir")}};goog.i18n.bidi.DirectionalString=function(){};goog.html.TrustedResourceUrl=function(){this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_="";
-this.TRUSTED_RESOURCE_URL_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_=goog.html.TrustedResourceUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_};goog.html.TrustedResourceUrl.prototype.implementsGoogStringTypedString=!0;goog.html.TrustedResourceUrl.prototype.getTypedStringValue=function(){return this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_};goog.html.TrustedResourceUrl.prototype.implementsGoogI18nBidiDirectionalString=!0;goog.html.TrustedResourceUrl.prototype.getDirection=function(){return goog.i18n.bidi.Dir.LTR};goog.html.TrustedResourceUrl.prototype.cloneWithParams=function(a){var b=goog.html.TrustedResourceUrl.unwrap(this),c=/\?/.test(b)?"&":"?",d;for(d in a){for(var e=goog.isArray(a[d])?a[d]:[a[d]],f=0;f<e.length;f++){null!=e[f]&&(b+=c+encodeURIComponent(d)+"="+encodeURIComponent(String(e[f])),c="&")}}return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(b)};goog.DEBUG&&(goog.html.TrustedResourceUrl.prototype.toString=function(){return"TrustedResourceUrl{"+this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_+"}"});goog.html.TrustedResourceUrl.unwrap=function(a){if(a instanceof goog.html.TrustedResourceUrl&&a.constructor===goog.html.TrustedResourceUrl&&a.TRUSTED_RESOURCE_URL_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_===goog.html.TrustedResourceUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_){return a.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_}goog.asserts.fail("expected object of type TrustedResourceUrl, got '"+a+"' of type "+goog.typeOf(a));return"type_error:TrustedResourceUrl"};goog.html.TrustedResourceUrl.format=function(a,b){var c=goog.string.Const.unwrap(a);if(!goog.html.TrustedResourceUrl.BASE_URL_.test(c)){throw Error("Invalid TrustedResourceUrl format: "+c)}var d=c.replace(goog.html.TrustedResourceUrl.FORMAT_MARKER_,function(a,d){if(!Object.prototype.hasOwnProperty.call(b,d)){throw Error('Found marker, "'+d+'", in format string, "'+c+'", but no valid label mapping found in args: '+JSON.stringify(b))
-}var e=b[d];return e instanceof goog.string.Const?goog.string.Const.unwrap(e):encodeURIComponent(String(e))});return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(d)};goog.html.TrustedResourceUrl.FORMAT_MARKER_=/%{(\w+)}/g;goog.html.TrustedResourceUrl.BASE_URL_=/^(?:https:)?\/\/[0-9a-z.:[\]-]+\/|^\/[^\/\\]|^about:blank(#|$)/i;goog.html.TrustedResourceUrl.formatWithParams=function(a,b,c){return goog.html.TrustedResourceUrl.format(a,b).cloneWithParams(c)};goog.html.TrustedResourceUrl.fromConstant=function(a){return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(goog.string.Const.unwrap(a))};goog.html.TrustedResourceUrl.fromConstants=function(a){for(var b="",c=0;c<a.length;c++){b+=goog.string.Const.unwrap(a[c])}return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(b)};goog.html.TrustedResourceUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_={};goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse=function(a){var b=new goog.html.TrustedResourceUrl;b.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_=a;return b};goog.html.SafeUrl=function(){this.privateDoNotAccessOrElseSafeHtmlWrappedValue_="";this.SAFE_URL_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_=goog.html.SafeUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_};goog.html.SafeUrl.INNOCUOUS_STRING="about:invalid#zClosurez";goog.html.SafeUrl.prototype.implementsGoogStringTypedString=!0;goog.html.SafeUrl.prototype.getTypedStringValue=function(){return this.privateDoNotAccessOrElseSafeHtmlWrappedValue_};goog.html.SafeUrl.prototype.implementsGoogI18nBidiDirectionalString=!0;goog.html.SafeUrl.prototype.getDirection=function(){return goog.i18n.bidi.Dir.LTR};goog.DEBUG&&(goog.html.SafeUrl.prototype.toString=function(){return"SafeUrl{"+this.privateDoNotAccessOrElseSafeHtmlWrappedValue_+"}"});goog.html.SafeUrl.unwrap=function(a){if(a instanceof goog.html.SafeUrl&&a.constructor===goog.html.SafeUrl&&a.SAFE_URL_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_===goog.html.SafeUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_){return a.privateDoNotAccessOrElseSafeHtmlWrappedValue_
-}goog.asserts.fail("expected object of type SafeUrl, got '"+a+"' of type "+goog.typeOf(a));return"type_error:SafeUrl"};goog.html.SafeUrl.fromConstant=function(a){return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(goog.string.Const.unwrap(a))};goog.html.SAFE_MIME_TYPE_PATTERN_=/^(?:audio\/(?:3gpp|3gpp2|aac|midi|mp4|mpeg|ogg|x-m4a|x-wav|webm)|image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|text\/csv|video\/(?:mpeg|mp4|ogg|webm))$/i;goog.html.SafeUrl.fromBlob=function(a){a=goog.html.SAFE_MIME_TYPE_PATTERN_.test(a.type)?goog.fs.url.createObjectUrl(a):goog.html.SafeUrl.INNOCUOUS_STRING;return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.DATA_URL_PATTERN_=/^data:([^;,]*);base64,[a-z0-9+\/]+=*$/i;goog.html.SafeUrl.fromDataUrl=function(a){var b=a.match(goog.html.DATA_URL_PATTERN_);b=b&&goog.html.SAFE_MIME_TYPE_PATTERN_.test(b[1]);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(b?a:goog.html.SafeUrl.INNOCUOUS_STRING)};goog.html.SafeUrl.fromTelUrl=function(a){goog.string.caseInsensitiveStartsWith(a,"tel:")||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.SafeUrl.fromTrustedResourceUrl=function(a){return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(goog.html.TrustedResourceUrl.unwrap(a))};goog.html.SAFE_URL_PATTERN_=/^(?:(?:https?|mailto|ftp):|[^:/?#]*(?:[/?#]|$))/i;goog.html.SafeUrl.sanitize=function(a){if(a instanceof goog.html.SafeUrl){return a}a=a.implementsGoogStringTypedString?a.getTypedStringValue():String(a);goog.html.SAFE_URL_PATTERN_.test(a)||(a=goog.html.SafeUrl.INNOCUOUS_STRING);return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.SafeUrl.sanitizeAssertUnchanged=function(a){if(a instanceof goog.html.SafeUrl){return a}a=a.implementsGoogStringTypedString?a.getTypedStringValue():String(a);goog.asserts.assert(goog.html.SAFE_URL_PATTERN_.test(a))||(a=goog.html.SafeUrl.INNOCUOUS_STRING);
-return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(a)};goog.html.SafeUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_={};goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse=function(a){var b=new goog.html.SafeUrl;b.privateDoNotAccessOrElseSafeHtmlWrappedValue_=a;return b};goog.html.SafeUrl.ABOUT_BLANK=goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse("about:blank");goog.html.SafeStyle=function(){this.privateDoNotAccessOrElseSafeStyleWrappedValue_="";this.SAFE_STYLE_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_=goog.html.SafeStyle.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_};goog.html.SafeStyle.prototype.implementsGoogStringTypedString=!0;goog.html.SafeStyle.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_={};goog.html.SafeStyle.fromConstant=function(a){a=goog.string.Const.unwrap(a);if(0===a.length){return goog.html.SafeStyle.EMPTY}goog.html.SafeStyle.checkStyle_(a);goog.asserts.assert(goog.string.endsWith(a,";"),"Last character of style string is not ';': "+a);goog.asserts.assert(goog.string.contains(a,":"),"Style string must contain at least one ':', to specify a \"name: value\" pair: "+a);return goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(a)};goog.html.SafeStyle.checkStyle_=function(a){goog.asserts.assert(!/[<>]/.test(a),"Forbidden characters in style string: "+a)};goog.html.SafeStyle.prototype.getTypedStringValue=function(){return this.privateDoNotAccessOrElseSafeStyleWrappedValue_};goog.DEBUG&&(goog.html.SafeStyle.prototype.toString=function(){return"SafeStyle{"+this.privateDoNotAccessOrElseSafeStyleWrappedValue_+"}"});goog.html.SafeStyle.unwrap=function(a){if(a instanceof goog.html.SafeStyle&&a.constructor===goog.html.SafeStyle&&a.SAFE_STYLE_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_===goog.html.SafeStyle.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_){return a.privateDoNotAccessOrElseSafeStyleWrappedValue_}goog.asserts.fail("expected object of type SafeStyle, got '"+a+"' of type "+goog.typeOf(a));return"type_error:SafeStyle"};
-goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse=function(a){return(new goog.html.SafeStyle).initSecurityPrivateDoNotAccessOrElse_(a)};goog.html.SafeStyle.prototype.initSecurityPrivateDoNotAccessOrElse_=function(a){this.privateDoNotAccessOrElseSafeStyleWrappedValue_=a;return this};goog.html.SafeStyle.EMPTY=goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse("");goog.html.SafeStyle.INNOCUOUS_STRING="zClosurez";goog.html.SafeStyle.create=function(a){var b="",c;for(c in a){if(!/^[-_a-zA-Z0-9]+$/.test(c)){throw Error("Name allows only [-_a-zA-Z0-9], got: "+c)}var d=a[c];null!=d&&(d=goog.isArray(d)?goog.array.map(d,goog.html.SafeStyle.sanitizePropertyValue_).join(" "):goog.html.SafeStyle.sanitizePropertyValue_(d),b+=c+":"+d+";")}if(!b){return goog.html.SafeStyle.EMPTY}goog.html.SafeStyle.checkStyle_(b);return goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(b)};goog.html.SafeStyle.sanitizePropertyValue_=function(a){if(a instanceof goog.html.SafeUrl){return'url("'+goog.html.SafeUrl.unwrap(a).replace(/</g,"%3c").replace(/[\\"]/g,"\\$&")+'")'}a=a instanceof goog.string.Const?goog.string.Const.unwrap(a):goog.html.SafeStyle.sanitizePropertyValueString_(String(a));goog.asserts.assert(!/[{;}]/.test(a),"Value does not allow [{;}].");return a};goog.html.SafeStyle.sanitizePropertyValueString_=function(a){var b=a.replace(goog.html.SafeUrl.FUNCTIONS_RE_,"$1").replace(goog.html.SafeUrl.URL_RE_,"url");return goog.html.SafeStyle.VALUE_RE_.test(b)?goog.html.SafeStyle.hasBalancedQuotes_(a)?goog.html.SafeStyle.sanitizeUrl_(a):(goog.asserts.fail("String value requires balanced quotes, got: "+a),goog.html.SafeStyle.INNOCUOUS_STRING):(goog.asserts.fail("String value allows only "+goog.html.SafeStyle.VALUE_ALLOWED_CHARS_+" and simple functions, got: "+a),goog.html.SafeStyle.INNOCUOUS_STRING)};goog.html.SafeStyle.hasBalancedQuotes_=function(a){for(var b=!0,c=!0,d=0;d<a.length;d++){var e=a.charAt(d);"'"==e&&c?b=!b:'"'==e&&b&&(c=!c)}return b&&c
-};goog.html.SafeStyle.VALUE_ALLOWED_CHARS_="[-,.\"'%_!# a-zA-Z0-9]";goog.html.SafeStyle.VALUE_RE_=new RegExp("^"+goog.html.SafeStyle.VALUE_ALLOWED_CHARS_+"+$");goog.html.SafeUrl.URL_RE_=RegExp("\\b(url\\([ \t\n]*)('[ -&(-\\[\\]-~]*'|\"[ !#-\\[\\]-~]*\"|[!#-&*-\\[\\]-~]*)([ \t\n]*\\))","g");goog.html.SafeUrl.FUNCTIONS_RE_=RegExp("\\b(hsl|hsla|rgb|rgba|(rotate|scale|translate)(X|Y|Z|3d)?)\\([-0-9a-z.%, ]+\\)","g");goog.html.SafeStyle.sanitizeUrl_=function(a){return a.replace(goog.html.SafeUrl.URL_RE_,function(a,c,d,e){var b="";d=d.replace(/^(['"])(.*)\1$/,function(a,c,d){b=c;return d});a=goog.html.SafeUrl.sanitize(d).getTypedStringValue();return c+b+a+b+e})};goog.html.SafeStyle.concat=function(a){var b="",c=function(a){goog.isArray(a)?goog.array.forEach(a,c):b+=goog.html.SafeStyle.unwrap(a)};goog.array.forEach(arguments,c);return b?goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(b):goog.html.SafeStyle.EMPTY};goog.html.SafeStyleSheet=function(){this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_="";this.SAFE_STYLE_SHEET_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_=goog.html.SafeStyleSheet.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_};goog.html.SafeStyleSheet.prototype.implementsGoogStringTypedString=!0;goog.html.SafeStyleSheet.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_={};goog.html.SafeStyleSheet.createRule=function(a,b){if(goog.string.contains(a,"<")){throw Error("Selector does not allow '<', got: "+a)}var c=a.replace(/('|")((?!\1)[^\r\n\f\\]|\\[\s\S])*\1/g,"");if(!/^[-_a-zA-Z0-9#.:* ,>+~[\]()=^$|]+$/.test(c)){throw Error("Selector allows only [-_a-zA-Z0-9#.:* ,>+~[\\]()=^$|] and strings, got: "+a)}if(!goog.html.SafeStyleSheet.hasBalancedBrackets_(c)){throw Error("() and [] in selector must be balanced, got: "+a)}b instanceof goog.html.SafeStyle||(b=goog.html.SafeStyle.create(b));c=a+"{"+goog.html.SafeStyle.unwrap(b)+"}";return goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(c)};goog.html.SafeStyleSheet.hasBalancedBrackets_=function(a){for(var b={"(":")","[":"]"},c=[],d=0;
-d<a.length;d++){var e=a[d];if(b[e]){c.push(b[e])}else{if(goog.object.contains(b,e)&&c.pop()!=e){return !1}}}return 0==c.length};goog.html.SafeStyleSheet.concat=function(a){var b="",c=function(a){goog.isArray(a)?goog.array.forEach(a,c):b+=goog.html.SafeStyleSheet.unwrap(a)};goog.array.forEach(arguments,c);return goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(b)};goog.html.SafeStyleSheet.fromConstant=function(a){a=goog.string.Const.unwrap(a);if(0===a.length){return goog.html.SafeStyleSheet.EMPTY}goog.asserts.assert(!goog.string.contains(a,"<"),"Forbidden '<' character in style sheet string: "+a);return goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(a)};goog.html.SafeStyleSheet.prototype.getTypedStringValue=function(){return this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_};goog.DEBUG&&(goog.html.SafeStyleSheet.prototype.toString=function(){return"SafeStyleSheet{"+this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_+"}"});goog.html.SafeStyleSheet.unwrap=function(a){if(a instanceof goog.html.SafeStyleSheet&&a.constructor===goog.html.SafeStyleSheet&&a.SAFE_STYLE_SHEET_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_===goog.html.SafeStyleSheet.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_){return a.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_}goog.asserts.fail("expected object of type SafeStyleSheet, got '"+a+"' of type "+goog.typeOf(a));return"type_error:SafeStyleSheet"};goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse=function(a){return(new goog.html.SafeStyleSheet).initSecurityPrivateDoNotAccessOrElse_(a)};goog.html.SafeStyleSheet.prototype.initSecurityPrivateDoNotAccessOrElse_=function(a){this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_=a;return this};goog.html.SafeStyleSheet.EMPTY=goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse("");goog.html.SafeHtml=function(){this.privateDoNotAccessOrElseSafeHtmlWrappedValue_="";this.SAFE_HTML_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_=goog.html.SafeHtml.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_;
-this.dir_=null};goog.html.SafeHtml.prototype.implementsGoogI18nBidiDirectionalString=!0;goog.html.SafeHtml.prototype.getDirection=function(){return this.dir_};goog.html.SafeHtml.prototype.implementsGoogStringTypedString=!0;goog.html.SafeHtml.prototype.getTypedStringValue=function(){return this.privateDoNotAccessOrElseSafeHtmlWrappedValue_};goog.DEBUG&&(goog.html.SafeHtml.prototype.toString=function(){return"SafeHtml{"+this.privateDoNotAccessOrElseSafeHtmlWrappedValue_+"}"});goog.html.SafeHtml.unwrap=function(a){if(a instanceof goog.html.SafeHtml&&a.constructor===goog.html.SafeHtml&&a.SAFE_HTML_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_===goog.html.SafeHtml.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_){return a.privateDoNotAccessOrElseSafeHtmlWrappedValue_}goog.asserts.fail("expected object of type SafeHtml, got '"+a+"' of type "+goog.typeOf(a));return"type_error:SafeHtml"};goog.html.SafeHtml.htmlEscape=function(a){if(a instanceof goog.html.SafeHtml){return a}var b=null;a.implementsGoogI18nBidiDirectionalString&&(b=a.getDirection());a=a.implementsGoogStringTypedString?a.getTypedStringValue():String(a);return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(goog.string.htmlEscape(a),b)};goog.html.SafeHtml.htmlEscapePreservingNewlines=function(a){if(a instanceof goog.html.SafeHtml){return a}a=goog.html.SafeHtml.htmlEscape(a);return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(goog.string.newLineToBr(goog.html.SafeHtml.unwrap(a)),a.getDirection())};goog.html.SafeHtml.htmlEscapePreservingNewlinesAndSpaces=function(a){if(a instanceof goog.html.SafeHtml){return a}a=goog.html.SafeHtml.htmlEscape(a);return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(goog.string.whitespaceEscape(goog.html.SafeHtml.unwrap(a)),a.getDirection())};goog.html.SafeHtml.from=goog.html.SafeHtml.htmlEscape;goog.html.SafeHtml.VALID_NAMES_IN_TAG_=/^[a-zA-Z0-9-]+$/;goog.html.SafeHtml.URL_ATTRIBUTES_={action:!0,cite:!0,data:!0,formaction:!0,href:!0,manifest:!0,poster:!0,src:!0};
-goog.html.SafeHtml.NOT_ALLOWED_TAG_NAMES_={APPLET:!0,BASE:!0,EMBED:!0,IFRAME:!0,LINK:!0,MATH:!0,META:!0,OBJECT:!0,SCRIPT:!0,STYLE:!0,SVG:!0,TEMPLATE:!0};goog.html.SafeHtml.create=function(a,b,c){goog.html.SafeHtml.verifyTagName(String(a));return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(String(a),b,c)};goog.html.SafeHtml.verifyTagName=function(a){if(!goog.html.SafeHtml.VALID_NAMES_IN_TAG_.test(a)){throw Error("Invalid tag name <"+a+">.")}if(a.toUpperCase() in goog.html.SafeHtml.NOT_ALLOWED_TAG_NAMES_){throw Error("Tag name <"+a+"> is not allowed for SafeHtml.")}};goog.html.SafeHtml.createIframe=function(a,b,c,d){a&&goog.html.TrustedResourceUrl.unwrap(a);var e={};e.src=a||null;e.srcdoc=b&&goog.html.SafeHtml.unwrap(b);a=goog.html.SafeHtml.combineAttributes(e,{sandbox:""},c);return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("iframe",a,d)};goog.html.SafeHtml.createSandboxIframe=function(a,b,c,d){if(!goog.html.SafeHtml.canUseSandboxIframe()){throw Error("The browser does not support sandboxed iframes.")}var e={};e.src=a?goog.html.SafeUrl.unwrap(goog.html.SafeUrl.sanitize(a)):null;e.srcdoc=b||null;e.sandbox="";a=goog.html.SafeHtml.combineAttributes(e,{},c);return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("iframe",a,d)};goog.html.SafeHtml.canUseSandboxIframe=function(){return goog.global.HTMLIFrameElement&&"sandbox" in goog.global.HTMLIFrameElement.prototype};goog.html.SafeHtml.createScriptSrc=function(a,b){goog.html.TrustedResourceUrl.unwrap(a);var c=goog.html.SafeHtml.combineAttributes({src:a},{},b);return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("script",c)};goog.html.SafeHtml.createScript=function(a,b){for(var c in b){var d=c.toLowerCase();if("language"==d||"src"==d||"text"==d||"type"==d){throw Error('Cannot set "'+d+'" attribute')}}c="";a=goog.array.concat(a);for(d=0;d<a.length;d++){c+=goog.html.SafeScript.unwrap(a[d])}c=goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(c,goog.i18n.bidi.Dir.NEUTRAL);
-return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("script",b,c)};goog.html.SafeHtml.createStyle=function(a,b){var c=goog.html.SafeHtml.combineAttributes({type:"text/css"},{},b),d="";a=goog.array.concat(a);for(var e=0;e<a.length;e++){d+=goog.html.SafeStyleSheet.unwrap(a[e])}d=goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(d,goog.i18n.bidi.Dir.NEUTRAL);return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("style",c,d)};goog.html.SafeHtml.createMetaRefresh=function(a,b){var c=goog.html.SafeUrl.unwrap(goog.html.SafeUrl.sanitize(a));(goog.labs.userAgent.browser.isIE()||goog.labs.userAgent.browser.isEdge())&&goog.string.contains(c,";")&&(c="'"+c.replace(/'/g,"%27")+"'");return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("meta",{"http-equiv":"refresh",content:(b||0)+"; url="+c})};goog.html.SafeHtml.getAttrNameAndValue_=function(a,b,c){if(c instanceof goog.string.Const){c=goog.string.Const.unwrap(c)}else{if("style"==b.toLowerCase()){c=goog.html.SafeHtml.getStyleValue_(c)}else{if(/^on/i.test(b)){throw Error('Attribute "'+b+'" requires goog.string.Const value, "'+c+'" given.')}if(b.toLowerCase() in goog.html.SafeHtml.URL_ATTRIBUTES_){if(c instanceof goog.html.TrustedResourceUrl){c=goog.html.TrustedResourceUrl.unwrap(c)}else{if(c instanceof goog.html.SafeUrl){c=goog.html.SafeUrl.unwrap(c)}else{if(goog.isString(c)){c=goog.html.SafeUrl.sanitize(c).getTypedStringValue()}else{throw Error('Attribute "'+b+'" on tag "'+a+'" requires goog.html.SafeUrl, goog.string.Const, or string, value "'+c+'" given.')}}}}}}c.implementsGoogStringTypedString&&(c=c.getTypedStringValue());goog.asserts.assert(goog.isString(c)||goog.isNumber(c),"String or number value expected, got "+typeof c+" with value: "+c);return b+'="'+goog.string.htmlEscape(String(c))+'"'};goog.html.SafeHtml.getStyleValue_=function(a){if(!goog.isObject(a)){throw Error('The "style" attribute requires goog.html.SafeStyle or map of style properties, '+typeof a+" given: "+a)
-}a instanceof goog.html.SafeStyle||(a=goog.html.SafeStyle.create(a));return goog.html.SafeStyle.unwrap(a)};goog.html.SafeHtml.createWithDir=function(a,b,c,d){b=goog.html.SafeHtml.create(b,c,d);b.dir_=a;return b};goog.html.SafeHtml.concat=function(a){var b=goog.i18n.bidi.Dir.NEUTRAL,c="",d=function(a){goog.isArray(a)?goog.array.forEach(a,d):(a=goog.html.SafeHtml.htmlEscape(a),c+=goog.html.SafeHtml.unwrap(a),a=a.getDirection(),b==goog.i18n.bidi.Dir.NEUTRAL?b=a:a!=goog.i18n.bidi.Dir.NEUTRAL&&b!=a&&(b=null))};goog.array.forEach(arguments,d);return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(c,b)};goog.html.SafeHtml.concatWithDir=function(a,b){var c=goog.html.SafeHtml.concat(goog.array.slice(arguments,1));c.dir_=a;return c};goog.html.SafeHtml.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_={};goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse=function(a,b){return(new goog.html.SafeHtml).initSecurityPrivateDoNotAccessOrElse_(a,b)};goog.html.SafeHtml.prototype.initSecurityPrivateDoNotAccessOrElse_=function(a,b){this.privateDoNotAccessOrElseSafeHtmlWrappedValue_=a;this.dir_=b;return this};goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse=function(a,b,c){var d=null;var e="<"+a+goog.html.SafeHtml.stringifyAttributes(a,b);goog.isDefAndNotNull(c)?goog.isArray(c)||(c=[c]):c=[];goog.dom.tags.isVoidTag(a.toLowerCase())?(goog.asserts.assert(!c.length,"Void tag <"+a+"> does not allow content."),e+=">"):(d=goog.html.SafeHtml.concat(c),e+=">"+goog.html.SafeHtml.unwrap(d)+"</"+a+">",d=d.getDirection());(a=b&&b.dir)&&(d=/^(ltr|rtl|auto)$/i.test(a)?goog.i18n.bidi.Dir.NEUTRAL:null);return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(e,d)};goog.html.SafeHtml.stringifyAttributes=function(a,b){var c="";if(b){for(var d in b){if(!goog.html.SafeHtml.VALID_NAMES_IN_TAG_.test(d)){throw Error('Invalid attribute name "'+d+'".')}var e=b[d];goog.isDefAndNotNull(e)&&(c+=" "+goog.html.SafeHtml.getAttrNameAndValue_(a,d,e))}}return c};goog.html.SafeHtml.combineAttributes=function(a,b,c){var d={},e;
-for(e in a){goog.asserts.assert(e.toLowerCase()==e,"Must be lower case"),d[e]=a[e]}for(e in b){goog.asserts.assert(e.toLowerCase()==e,"Must be lower case"),d[e]=b[e]}for(e in c){var f=e.toLowerCase();if(f in a){throw Error('Cannot override "'+f+'" attribute, got "'+e+'" with value "'+c[e]+'"')}f in b&&delete d[f];d[e]=c[e]}return d};goog.html.SafeHtml.DOCTYPE_HTML=goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse("<!DOCTYPE html>",goog.i18n.bidi.Dir.NEUTRAL);goog.html.SafeHtml.EMPTY=goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse("",goog.i18n.bidi.Dir.NEUTRAL);goog.html.SafeHtml.BR=goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse("<br>",goog.i18n.bidi.Dir.NEUTRAL);goog.dom.safe={};goog.dom.safe.InsertAdjacentHtmlPosition={AFTERBEGIN:"afterbegin",AFTEREND:"afterend",BEFOREBEGIN:"beforebegin",BEFOREEND:"beforeend"};goog.dom.safe.insertAdjacentHtml=function(a,b,c){a.insertAdjacentHTML(b,goog.html.SafeHtml.unwrap(c))};goog.dom.safe.SET_INNER_HTML_DISALLOWED_TAGS_={MATH:!0,SCRIPT:!0,STYLE:!0,SVG:!0,TEMPLATE:!0};goog.dom.safe.setInnerHtml=function(a,b){if(goog.asserts.ENABLE_ASSERTS){var c=a.tagName.toUpperCase();if(goog.dom.safe.SET_INNER_HTML_DISALLOWED_TAGS_[c]){throw Error("goog.dom.safe.setInnerHtml cannot be used to set content of "+a.tagName+".")}}a.innerHTML=goog.html.SafeHtml.unwrap(b)};goog.dom.safe.setOuterHtml=function(a,b){a.outerHTML=goog.html.SafeHtml.unwrap(b)};goog.dom.safe.setFormElementAction=function(a,b){var c=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);goog.dom.asserts.assertIsHTMLFormElement(a).action=goog.html.SafeUrl.unwrap(c)};goog.dom.safe.setButtonFormAction=function(a,b){var c=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);goog.dom.asserts.assertIsHTMLButtonElement(a).formaction=goog.html.SafeUrl.unwrap(c)};goog.dom.safe.setInputFormAction=function(a,b){var c=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);
-goog.dom.asserts.assertIsHTMLInputElement(a).formaction=goog.html.SafeUrl.unwrap(c)};goog.dom.safe.setStyle=function(a,b){a.style.cssText=goog.html.SafeStyle.unwrap(b)};goog.dom.safe.documentWrite=function(a,b){a.write(goog.html.SafeHtml.unwrap(b))};goog.dom.safe.setAnchorHref=function(a,b){goog.dom.asserts.assertIsHTMLAnchorElement(a);var c=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.href=goog.html.SafeUrl.unwrap(c)};goog.dom.safe.setImageSrc=function(a,b){goog.dom.asserts.assertIsHTMLImageElement(a);var c=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.src=goog.html.SafeUrl.unwrap(c)};goog.dom.safe.setEmbedSrc=function(a,b){goog.dom.asserts.assertIsHTMLEmbedElement(a);a.src=goog.html.TrustedResourceUrl.unwrap(b)};goog.dom.safe.setFrameSrc=function(a,b){goog.dom.asserts.assertIsHTMLFrameElement(a);a.src=goog.html.TrustedResourceUrl.unwrap(b)};goog.dom.safe.setIframeSrc=function(a,b){goog.dom.asserts.assertIsHTMLIFrameElement(a);a.src=goog.html.TrustedResourceUrl.unwrap(b)};goog.dom.safe.setIframeSrcdoc=function(a,b){goog.dom.asserts.assertIsHTMLIFrameElement(a);a.srcdoc=goog.html.SafeHtml.unwrap(b)};goog.dom.safe.setLinkHrefAndRel=function(a,b,c){goog.dom.asserts.assertIsHTMLLinkElement(a);a.rel=c;goog.string.caseInsensitiveContains(c,"stylesheet")?(goog.asserts.assert(b instanceof goog.html.TrustedResourceUrl,'URL must be TrustedResourceUrl because "rel" contains "stylesheet"'),a.href=goog.html.TrustedResourceUrl.unwrap(b)):a.href=b instanceof goog.html.TrustedResourceUrl?goog.html.TrustedResourceUrl.unwrap(b):b instanceof goog.html.SafeUrl?goog.html.SafeUrl.unwrap(b):goog.html.SafeUrl.sanitizeAssertUnchanged(b).getTypedStringValue()};goog.dom.safe.setObjectData=function(a,b){goog.dom.asserts.assertIsHTMLObjectElement(a);a.data=goog.html.TrustedResourceUrl.unwrap(b)};goog.dom.safe.setScriptSrc=function(a,b){goog.dom.asserts.assertIsHTMLScriptElement(a);a.src=goog.html.TrustedResourceUrl.unwrap(b)};
-goog.dom.safe.setScriptContent=function(a,b){goog.dom.asserts.assertIsHTMLScriptElement(a);a.text=goog.html.SafeScript.unwrap(b)};goog.dom.safe.setLocationHref=function(a,b){goog.dom.asserts.assertIsLocation(a);var c=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.href=goog.html.SafeUrl.unwrap(c)};goog.dom.safe.replaceLocation=function(a,b){goog.dom.asserts.assertIsLocation(a);var c=b instanceof goog.html.SafeUrl?b:goog.html.SafeUrl.sanitizeAssertUnchanged(b);a.replace(goog.html.SafeUrl.unwrap(c))};goog.dom.safe.openInWindow=function(a,b,c,d,e){a=a instanceof goog.html.SafeUrl?a:goog.html.SafeUrl.sanitizeAssertUnchanged(a);return(b||window).open(goog.html.SafeUrl.unwrap(a),c?goog.string.Const.unwrap(c):"",d,e)};goog.html.uncheckedconversions={};goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract=function(a,b,c){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(b,c||null)};goog.html.uncheckedconversions.safeScriptFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return goog.html.SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(b)};goog.html.uncheckedconversions.safeStyleFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(b)};goog.html.uncheckedconversions.safeStyleSheetFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");
-goog.asserts.assert(!goog.string.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(b)};goog.html.uncheckedconversions.safeUrlFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(b)};goog.html.uncheckedconversions.trustedResourceUrlFromStringKnownToSatisfyTypeContract=function(a,b){goog.asserts.assertString(goog.string.Const.unwrap(a),"must provide justification");goog.asserts.assert(!goog.string.isEmptyOrWhitespace(goog.string.Const.unwrap(a)),"must provide non-empty justification");return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(b)};goog.math.Size=function(a,b){this.width=a;this.height=b};goog.math.Size.equals=function(a,b){return a==b?!0:a&&b?a.width==b.width&&a.height==b.height:!1};goog.math.Size.prototype.clone=function(){return new goog.math.Size(this.width,this.height)};goog.DEBUG&&(goog.math.Size.prototype.toString=function(){return"("+this.width+" x "+this.height+")"});goog.math.Size.prototype.getLongest=function(){return Math.max(this.width,this.height)};goog.math.Size.prototype.getShortest=function(){return Math.min(this.width,this.height)};goog.math.Size.prototype.area=function(){return this.width*this.height};goog.math.Size.prototype.perimeter=function(){return 2*(this.width+this.height)};goog.math.Size.prototype.aspectRatio=function(){return this.width/this.height};goog.math.Size.prototype.isEmpty=function(){return !this.area()};goog.math.Size.prototype.ceil=function(){this.width=Math.ceil(this.width);this.height=Math.ceil(this.height);return this};goog.math.Size.prototype.fitsInside=function(a){return this.width<=a.width&&this.height<=a.height
-};goog.math.Size.prototype.floor=function(){this.width=Math.floor(this.width);this.height=Math.floor(this.height);return this};goog.math.Size.prototype.round=function(){this.width=Math.round(this.width);this.height=Math.round(this.height);return this};goog.math.Size.prototype.scale=function(a,b){var c=goog.isNumber(b)?b:a;this.width*=a;this.height*=c;return this};goog.math.Size.prototype.scaleToCover=function(a){a=this.aspectRatio()<=a.aspectRatio()?a.width/this.width:a.height/this.height;return this.scale(a)};goog.math.Size.prototype.scaleToFit=function(a){a=this.aspectRatio()>a.aspectRatio()?a.width/this.width:a.height/this.height;return this.scale(a)};goog.dom.ASSUME_QUIRKS_MODE=!1;goog.dom.ASSUME_STANDARDS_MODE=!1;goog.dom.COMPAT_MODE_KNOWN_=goog.dom.ASSUME_QUIRKS_MODE||goog.dom.ASSUME_STANDARDS_MODE;goog.dom.getDomHelper=function(a){return a?new goog.dom.DomHelper(goog.dom.getOwnerDocument(a)):goog.dom.defaultDomHelper_||(goog.dom.defaultDomHelper_=new goog.dom.DomHelper)};goog.dom.getDocument=function(){return document};goog.dom.getElement=function(a){return goog.dom.getElementHelper_(document,a)};goog.dom.getElementHelper_=function(a,b){return goog.isString(b)?a.getElementById(b):b};goog.dom.getRequiredElement=function(a){return goog.dom.getRequiredElementHelper_(document,a)};goog.dom.getRequiredElementHelper_=function(a,b){goog.asserts.assertString(b);var c=goog.dom.getElementHelper_(a,b);return c=goog.asserts.assertElement(c,"No element found with id: "+b)};goog.dom.$=goog.dom.getElement;goog.dom.getElementsByTagName=function(a,b){return(b||document).getElementsByTagName(String(a))};goog.dom.getElementsByTagNameAndClass=function(a,b,c){return goog.dom.getElementsByTagNameAndClass_(document,a,b,c)};goog.dom.getElementByTagNameAndClass=function(a,b,c){return goog.dom.getElementByTagNameAndClass_(document,a,b,c)};goog.dom.getElementsByClass=function(a,b){var c=b||document;return goog.dom.canUseQuerySelector_(c)?c.querySelectorAll("."+a):goog.dom.getElementsByTagNameAndClass_(document,"*",a,b)
-};goog.dom.getElementByClass=function(a,b){var c=b||document;return(c.getElementsByClassName?c.getElementsByClassName(a)[0]:goog.dom.getElementByTagNameAndClass_(document,"*",a,b))||null};goog.dom.getRequiredElementByClass=function(a,b){var c=goog.dom.getElementByClass(a,b);return goog.asserts.assert(c,"No element found with className: "+a)};goog.dom.canUseQuerySelector_=function(a){return !(!a.querySelectorAll||!a.querySelector)};goog.dom.getElementsByTagNameAndClass_=function(a,b,c,d){a=d||a;b=b&&"*"!=b?String(b).toUpperCase():"";if(goog.dom.canUseQuerySelector_(a)&&(b||c)){return a.querySelectorAll(b+(c?"."+c:""))}if(c&&a.getElementsByClassName){a=a.getElementsByClassName(c);if(b){d={};for(var e=0,f=0,g;g=a[f];f++){b==g.nodeName&&(d[e++]=g)}d.length=e;return d}return a}a=a.getElementsByTagName(b||"*");if(c){d={};for(f=e=0;g=a[f];f++){b=g.className,"function"==typeof b.split&&goog.array.contains(b.split(/\s+/),c)&&(d[e++]=g)}d.length=e;return d}return a};goog.dom.getElementByTagNameAndClass_=function(a,b,c,d){var e=d||a,f=b&&"*"!=b?String(b).toUpperCase():"";return goog.dom.canUseQuerySelector_(e)&&(f||c)?e.querySelector(f+(c?"."+c:"")):goog.dom.getElementsByTagNameAndClass_(a,b,c,d)[0]||null};goog.dom.$$=goog.dom.getElementsByTagNameAndClass;goog.dom.setProperties=function(a,b){goog.object.forEach(b,function(b,d){b&&b.implementsGoogStringTypedString&&(b=b.getTypedStringValue());"style"==d?a.style.cssText=b:"class"==d?a.className=b:"for"==d?a.htmlFor=b:goog.dom.DIRECT_ATTRIBUTE_MAP_.hasOwnProperty(d)?a.setAttribute(goog.dom.DIRECT_ATTRIBUTE_MAP_[d],b):goog.string.startsWith(d,"aria-")||goog.string.startsWith(d,"data-")?a.setAttribute(d,b):a[d]=b})};goog.dom.DIRECT_ATTRIBUTE_MAP_={cellpadding:"cellPadding",cellspacing:"cellSpacing",colspan:"colSpan",frameborder:"frameBorder",height:"height",maxlength:"maxLength",nonce:"nonce",role:"role",rowspan:"rowSpan",type:"type",usemap:"useMap",valign:"vAlign",width:"width"};goog.dom.getViewportSize=function(a){return goog.dom.getViewportSize_(a||window)
-};goog.dom.getViewportSize_=function(a){a=a.document;a=goog.dom.isCss1CompatMode_(a)?a.documentElement:a.body;return new goog.math.Size(a.clientWidth,a.clientHeight)};goog.dom.getDocumentHeight=function(){return goog.dom.getDocumentHeight_(window)};goog.dom.getDocumentHeightForWindow=function(a){return goog.dom.getDocumentHeight_(a)};goog.dom.getDocumentHeight_=function(a){var b=a.document,c=0;if(b){c=b.body;var d=b.documentElement;if(!d||!c){return 0}a=goog.dom.getViewportSize_(a).height;if(goog.dom.isCss1CompatMode_(b)&&d.scrollHeight){c=d.scrollHeight!=a?d.scrollHeight:d.offsetHeight}else{b=d.scrollHeight;var e=d.offsetHeight;d.clientHeight!=e&&(b=c.scrollHeight,e=c.offsetHeight);c=b>a?b>e?b:e:b<e?b:e}}return c};goog.dom.getPageScroll=function(a){return goog.dom.getDomHelper((a||goog.global||window).document).getDocumentScroll()};goog.dom.getDocumentScroll=function(){return goog.dom.getDocumentScroll_(document)};goog.dom.getDocumentScroll_=function(a){var b=goog.dom.getDocumentScrollElement_(a);a=goog.dom.getWindow_(a);return goog.userAgent.IE&&goog.userAgent.isVersionOrHigher("10")&&a.pageYOffset!=b.scrollTop?new goog.math.Coordinate(b.scrollLeft,b.scrollTop):new goog.math.Coordinate(a.pageXOffset||b.scrollLeft,a.pageYOffset||b.scrollTop)};goog.dom.getDocumentScrollElement=function(){return goog.dom.getDocumentScrollElement_(document)};goog.dom.getDocumentScrollElement_=function(a){return a.scrollingElement?a.scrollingElement:!goog.userAgent.WEBKIT&&goog.dom.isCss1CompatMode_(a)?a.documentElement:a.body||a.documentElement};goog.dom.getWindow=function(a){return a?goog.dom.getWindow_(a):window};goog.dom.getWindow_=function(a){return a.parentWindow||a.defaultView};goog.dom.createDom=function(a,b,c){return goog.dom.createDom_(document,arguments)};goog.dom.createDom_=function(a,b){var c=String(b[0]),d=b[1];if(!goog.dom.BrowserFeature.CAN_ADD_NAME_OR_TYPE_ATTRIBUTES&&d&&(d.name||d.type)){c=["<",c];d.name&&c.push(' name="',goog.string.htmlEscape(d.name),'"');if(d.type){c.push(' type="',goog.string.htmlEscape(d.type),'"');
-var e={};goog.object.extend(e,d);delete e.type;d=e}c.push(">");c=c.join("")}c=a.createElement(c);d&&(goog.isString(d)?c.className=d:goog.isArray(d)?c.className=d.join(" "):goog.dom.setProperties(c,d));2<b.length&&goog.dom.append_(a,c,b,2);return c};goog.dom.append_=function(a,b,c,d){function e(c){c&&b.appendChild(goog.isString(c)?a.createTextNode(c):c)}for(;d<c.length;d++){var f=c[d];goog.isArrayLike(f)&&!goog.dom.isNodeLike(f)?goog.array.forEach(goog.dom.isNodeList(f)?goog.array.toArray(f):f,e):e(f)}};goog.dom.$dom=goog.dom.createDom;goog.dom.createElement=function(a){return goog.dom.createElement_(document,a)};goog.dom.createElement_=function(a,b){return a.createElement(String(b))};goog.dom.createTextNode=function(a){return document.createTextNode(String(a))};goog.dom.createTable=function(a,b,c){return goog.dom.createTable_(document,a,b,!!c)};goog.dom.createTable_=function(a,b,c,d){for(var e=goog.dom.createElement_(a,"TABLE"),f=e.appendChild(goog.dom.createElement_(a,"TBODY")),g=0;g<b;g++){for(var h=goog.dom.createElement_(a,"TR"),k=0;k<c;k++){var n=goog.dom.createElement_(a,"TD");d&&goog.dom.setTextContent(n,goog.string.Unicode.NBSP);h.appendChild(n)}f.appendChild(h)}return e};goog.dom.constHtmlToNode=function(a){var b=goog.array.map(arguments,goog.string.Const.unwrap);b=goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract(goog.string.Const.from("Constant HTML string, that gets turned into a Node later, so it will be automatically balanced."),b.join(""));return goog.dom.safeHtmlToNode(b)};goog.dom.safeHtmlToNode=function(a){return goog.dom.safeHtmlToNode_(document,a)};goog.dom.safeHtmlToNode_=function(a,b){var c=goog.dom.createElement_(a,"DIV");goog.dom.BrowserFeature.INNER_HTML_NEEDS_SCOPED_ELEMENT?(goog.dom.safe.setInnerHtml(c,goog.html.SafeHtml.concat(goog.html.SafeHtml.BR,b)),c.removeChild(c.firstChild)):goog.dom.safe.setInnerHtml(c,b);return goog.dom.childrenToNode_(a,c)};goog.dom.childrenToNode_=function(a,b){if(1==b.childNodes.length){return b.removeChild(b.firstChild)
-}for(var c=a.createDocumentFragment();b.firstChild;){c.appendChild(b.firstChild)}return c};goog.dom.isCss1CompatMode=function(){return goog.dom.isCss1CompatMode_(document)};goog.dom.isCss1CompatMode_=function(a){return goog.dom.COMPAT_MODE_KNOWN_?goog.dom.ASSUME_STANDARDS_MODE:"CSS1Compat"==a.compatMode};goog.dom.canHaveChildren=function(a){if(a.nodeType!=goog.dom.NodeType.ELEMENT){return !1}switch(a.tagName){case"APPLET":case"AREA":case"BASE":case"BR":case"COL":case"COMMAND":case"EMBED":case"FRAME":case"HR":case"IMG":case"INPUT":case"IFRAME":case"ISINDEX":case"KEYGEN":case"LINK":case"NOFRAMES":case"NOSCRIPT":case"META":case"OBJECT":case"PARAM":case"SCRIPT":case"SOURCE":case"STYLE":case"TRACK":case"WBR":return !1}return !0};goog.dom.appendChild=function(a,b){a.appendChild(b)};goog.dom.append=function(a,b){goog.dom.append_(goog.dom.getOwnerDocument(a),a,arguments,1)};goog.dom.removeChildren=function(a){for(var b;b=a.firstChild;){a.removeChild(b)}};goog.dom.insertSiblingBefore=function(a,b){b.parentNode&&b.parentNode.insertBefore(a,b)};goog.dom.insertSiblingAfter=function(a,b){b.parentNode&&b.parentNode.insertBefore(a,b.nextSibling)};goog.dom.insertChildAt=function(a,b,c){a.insertBefore(b,a.childNodes[c]||null)};goog.dom.removeNode=function(a){return a&&a.parentNode?a.parentNode.removeChild(a):null};goog.dom.replaceNode=function(a,b){var c=b.parentNode;c&&c.replaceChild(a,b)};goog.dom.flattenElement=function(a){var b,c=a.parentNode;if(c&&c.nodeType!=goog.dom.NodeType.DOCUMENT_FRAGMENT){if(a.removeNode){return a.removeNode(!1)}for(;b=a.firstChild;){c.insertBefore(b,a)}return goog.dom.removeNode(a)}};goog.dom.getChildren=function(a){return goog.dom.BrowserFeature.CAN_USE_CHILDREN_ATTRIBUTE&&void 0!=a.children?a.children:goog.array.filter(a.childNodes,function(a){return a.nodeType==goog.dom.NodeType.ELEMENT})};goog.dom.getFirstElementChild=function(a){return goog.isDef(a.firstElementChild)?a.firstElementChild:goog.dom.getNextElementNode_(a.firstChild,!0)};goog.dom.getLastElementChild=function(a){return goog.isDef(a.lastElementChild)?a.lastElementChild:goog.dom.getNextElementNode_(a.lastChild,!1)
-};goog.dom.getNextElementSibling=function(a){return goog.isDef(a.nextElementSibling)?a.nextElementSibling:goog.dom.getNextElementNode_(a.nextSibling,!0)};goog.dom.getPreviousElementSibling=function(a){return goog.isDef(a.previousElementSibling)?a.previousElementSibling:goog.dom.getNextElementNode_(a.previousSibling,!1)};goog.dom.getNextElementNode_=function(a,b){for(;a&&a.nodeType!=goog.dom.NodeType.ELEMENT;){a=b?a.nextSibling:a.previousSibling}return a};goog.dom.getNextNode=function(a){if(!a){return null}if(a.firstChild){return a.firstChild}for(;a&&!a.nextSibling;){a=a.parentNode}return a?a.nextSibling:null};goog.dom.getPreviousNode=function(a){if(!a){return null}if(!a.previousSibling){return a.parentNode}for(a=a.previousSibling;a&&a.lastChild;){a=a.lastChild}return a};goog.dom.isNodeLike=function(a){return goog.isObject(a)&&0<a.nodeType};goog.dom.isElement=function(a){return goog.isObject(a)&&a.nodeType==goog.dom.NodeType.ELEMENT};goog.dom.isWindow=function(a){return goog.isObject(a)&&a.window==a};goog.dom.getParentElement=function(a){var b;if(goog.dom.BrowserFeature.CAN_USE_PARENT_ELEMENT_PROPERTY&&!(goog.userAgent.IE&&goog.userAgent.isVersionOrHigher("9")&&!goog.userAgent.isVersionOrHigher("10")&&goog.global.SVGElement&&a instanceof goog.global.SVGElement)&&(b=a.parentElement)){return b}b=a.parentNode;return goog.dom.isElement(b)?b:null};goog.dom.contains=function(a,b){if(!a||!b){return !1}if(a.contains&&b.nodeType==goog.dom.NodeType.ELEMENT){return a==b||a.contains(b)}if("undefined"!=typeof a.compareDocumentPosition){return a==b||!!(a.compareDocumentPosition(b)&16)}for(;b&&a!=b;){b=b.parentNode}return b==a};goog.dom.compareNodeOrder=function(a,b){if(a==b){return 0}if(a.compareDocumentPosition){return a.compareDocumentPosition(b)&2?1:-1}if(goog.userAgent.IE&&!goog.userAgent.isDocumentModeOrHigher(9)){if(a.nodeType==goog.dom.NodeType.DOCUMENT){return -1}if(b.nodeType==goog.dom.NodeType.DOCUMENT){return 1}}if("sourceIndex" in a||a.parentNode&&"sourceIndex" in a.parentNode){var c=a.nodeType==goog.dom.NodeType.ELEMENT,d=b.nodeType==goog.dom.NodeType.ELEMENT;
-if(c&&d){return a.sourceIndex-b.sourceIndex}var e=a.parentNode,f=b.parentNode;return e==f?goog.dom.compareSiblingOrder_(a,b):!c&&goog.dom.contains(e,b)?-1*goog.dom.compareParentsDescendantNodeIe_(a,b):!d&&goog.dom.contains(f,a)?goog.dom.compareParentsDescendantNodeIe_(b,a):(c?a.sourceIndex:e.sourceIndex)-(d?b.sourceIndex:f.sourceIndex)}d=goog.dom.getOwnerDocument(a);c=d.createRange();c.selectNode(a);c.collapse(!0);d=d.createRange();d.selectNode(b);d.collapse(!0);return c.compareBoundaryPoints(goog.global.Range.START_TO_END,d)};goog.dom.compareParentsDescendantNodeIe_=function(a,b){var c=a.parentNode;if(c==b){return -1}for(var d=b;d.parentNode!=c;){d=d.parentNode}return goog.dom.compareSiblingOrder_(d,a)};goog.dom.compareSiblingOrder_=function(a,b){for(var c=b;c=c.previousSibling;){if(c==a){return -1}}return 1};goog.dom.findCommonAncestor=function(a){var b,c=arguments.length;if(!c){return null}if(1==c){return arguments[0]}var d=[],e=Infinity;for(b=0;b<c;b++){for(var f=[],g=arguments[b];g;){f.unshift(g),g=g.parentNode}d.push(f);e=Math.min(e,f.length)}f=null;for(b=0;b<e;b++){g=d[0][b];for(var h=1;h<c;h++){if(g!=d[h][b]){return f}}f=g}return f};goog.dom.getOwnerDocument=function(a){goog.asserts.assert(a,"Node cannot be null or undefined.");return a.nodeType==goog.dom.NodeType.DOCUMENT?a:a.ownerDocument||a.document};goog.dom.getFrameContentDocument=function(a){return a.contentDocument||a.contentWindow.document};goog.dom.getFrameContentWindow=function(a){try{return a.contentWindow||(a.contentDocument?goog.dom.getWindow(a.contentDocument):null)}catch(b){}return null};goog.dom.setTextContent=function(a,b){goog.asserts.assert(null!=a,"goog.dom.setTextContent expects a non-null value for node");if("textContent" in a){a.textContent=b}else{if(a.nodeType==goog.dom.NodeType.TEXT){a.data=String(b)}else{if(a.firstChild&&a.firstChild.nodeType==goog.dom.NodeType.TEXT){for(;a.lastChild!=a.firstChild;){a.removeChild(a.lastChild)}a.firstChild.data=String(b)}else{goog.dom.removeChildren(a);
-var c=goog.dom.getOwnerDocument(a);a.appendChild(c.createTextNode(String(b)))}}}};goog.dom.getOuterHtml=function(a){goog.asserts.assert(null!==a,"goog.dom.getOuterHtml expects a non-null value for element");if("outerHTML" in a){return a.outerHTML}var b=goog.dom.getOwnerDocument(a);b=goog.dom.createElement_(b,"DIV");b.appendChild(a.cloneNode(!0));return b.innerHTML};goog.dom.findNode=function(a,b){var c=[];return goog.dom.findNodes_(a,b,c,!0)?c[0]:void 0};goog.dom.findNodes=function(a,b){var c=[];goog.dom.findNodes_(a,b,c,!1);return c};goog.dom.findNodes_=function(a,b,c,d){if(null!=a){for(a=a.firstChild;a;){if(b(a)&&(c.push(a),d)||goog.dom.findNodes_(a,b,c,d)){return !0}a=a.nextSibling}}return !1};goog.dom.TAGS_TO_IGNORE_={SCRIPT:1,STYLE:1,HEAD:1,IFRAME:1,OBJECT:1};goog.dom.PREDEFINED_TAG_VALUES_={IMG:" ",BR:"\n"};goog.dom.isFocusableTabIndex=function(a){return goog.dom.hasSpecifiedTabIndex_(a)&&goog.dom.isTabIndexFocusable_(a)};goog.dom.setFocusableTabIndex=function(a,b){b?a.tabIndex=0:(a.tabIndex=-1,a.removeAttribute("tabIndex"))};goog.dom.isFocusable=function(a){var b;return(b=goog.dom.nativelySupportsFocus_(a)?!a.disabled&&(!goog.dom.hasSpecifiedTabIndex_(a)||goog.dom.isTabIndexFocusable_(a)):goog.dom.isFocusableTabIndex(a))&&goog.userAgent.IE?goog.dom.hasNonZeroBoundingRect_(a):b};goog.dom.hasSpecifiedTabIndex_=function(a){return goog.userAgent.IE&&!goog.userAgent.isVersionOrHigher("9")?(a=a.getAttributeNode("tabindex"),goog.isDefAndNotNull(a)&&a.specified):a.hasAttribute("tabindex")};goog.dom.isTabIndexFocusable_=function(a){a=a.tabIndex;return goog.isNumber(a)&&0<=a&&32768>a};goog.dom.nativelySupportsFocus_=function(a){return"A"==a.tagName||"INPUT"==a.tagName||"TEXTAREA"==a.tagName||"SELECT"==a.tagName||"BUTTON"==a.tagName};goog.dom.hasNonZeroBoundingRect_=function(a){a=!goog.isFunction(a.getBoundingClientRect)||goog.userAgent.IE&&null==a.parentElement?{height:a.offsetHeight,width:a.offsetWidth}:a.getBoundingClientRect();return goog.isDefAndNotNull(a)&&0<a.height&&0<a.width
-};goog.dom.getTextContent=function(a){if(goog.dom.BrowserFeature.CAN_USE_INNER_TEXT&&null!==a&&"innerText" in a){a=goog.string.canonicalizeNewlines(a.innerText)}else{var b=[];goog.dom.getTextContent_(a,b,!0);a=b.join("")}a=a.replace(/ \xAD /g," ").replace(/\xAD/g,"");a=a.replace(/\u200B/g,"");goog.dom.BrowserFeature.CAN_USE_INNER_TEXT||(a=a.replace(/ +/g," "));" "!=a&&(a=a.replace(/^\s*/,""));return a};goog.dom.getRawTextContent=function(a){var b=[];goog.dom.getTextContent_(a,b,!1);return b.join("")};goog.dom.getTextContent_=function(a,b,c){if(!(a.nodeName in goog.dom.TAGS_TO_IGNORE_)){if(a.nodeType==goog.dom.NodeType.TEXT){c?b.push(String(a.nodeValue).replace(/(\r\n|\r|\n)/g,"")):b.push(a.nodeValue)}else{if(a.nodeName in goog.dom.PREDEFINED_TAG_VALUES_){b.push(goog.dom.PREDEFINED_TAG_VALUES_[a.nodeName])}else{for(a=a.firstChild;a;){goog.dom.getTextContent_(a,b,c),a=a.nextSibling}}}}};goog.dom.getNodeTextLength=function(a){return goog.dom.getTextContent(a).length};goog.dom.getNodeTextOffset=function(a,b){for(var c=b||goog.dom.getOwnerDocument(a).body,d=[];a&&a!=c;){for(var e=a;e=e.previousSibling;){d.unshift(goog.dom.getTextContent(e))}a=a.parentNode}return goog.string.trimLeft(d.join("")).replace(/ +/g," ").length};goog.dom.getNodeAtOffset=function(a,b,c){a=[a];for(var d=0,e=null;0<a.length&&d<b;){if(e=a.pop(),!(e.nodeName in goog.dom.TAGS_TO_IGNORE_)){if(e.nodeType==goog.dom.NodeType.TEXT){var f=e.nodeValue.replace(/(\r\n|\r|\n)/g,"").replace(/ +/g," ");d+=f.length}else{if(e.nodeName in goog.dom.PREDEFINED_TAG_VALUES_){d+=goog.dom.PREDEFINED_TAG_VALUES_[e.nodeName].length}else{for(f=e.childNodes.length-1;0<=f;f--){a.push(e.childNodes[f])}}}}}goog.isObject(c)&&(c.remainder=e?e.nodeValue.length+b-d-1:0,c.node=e);return e};goog.dom.isNodeList=function(a){if(a&&"number"==typeof a.length){if(goog.isObject(a)){return"function"==typeof a.item||"string"==typeof a.item}if(goog.isFunction(a)){return"function"==typeof a.item}}return !1};goog.dom.getAncestorByTagNameAndClass=function(a,b,c,d){if(!b&&!c){return null
-}var e=b?String(b).toUpperCase():null;return goog.dom.getAncestor(a,function(a){return(!e||a.nodeName==e)&&(!c||goog.isString(a.className)&&goog.array.contains(a.className.split(/\s+/),c))},!0,d)};goog.dom.getAncestorByClass=function(a,b,c){return goog.dom.getAncestorByTagNameAndClass(a,null,b,c)};goog.dom.getAncestor=function(a,b,c,d){a&&!c&&(a=a.parentNode);for(c=0;a&&(null==d||c<=d);){goog.asserts.assert("parentNode"!=a.name);if(b(a)){return a}a=a.parentNode;c++}return null};goog.dom.getActiveElement=function(a){try{return a&&a.activeElement}catch(b){}return null};goog.dom.getPixelRatio=function(){var a=goog.dom.getWindow();return goog.isDef(a.devicePixelRatio)?a.devicePixelRatio:a.matchMedia?goog.dom.matchesPixelRatio_(3)||goog.dom.matchesPixelRatio_(2)||goog.dom.matchesPixelRatio_(1.5)||goog.dom.matchesPixelRatio_(1)||0.75:1};goog.dom.matchesPixelRatio_=function(a){return goog.dom.getWindow().matchMedia("(min-resolution: "+a+"dppx),(min--moz-device-pixel-ratio: "+a+"),(min-resolution: "+96*a+"dpi)").matches?a:0};goog.dom.getCanvasContext2D=function(a){return a.getContext("2d")};goog.dom.DomHelper=function(a){this.document_=a||goog.global.document||document};goog.dom.DomHelper.prototype.getDomHelper=goog.dom.getDomHelper;goog.dom.DomHelper.prototype.setDocument=function(a){this.document_=a};goog.dom.DomHelper.prototype.getDocument=function(){return this.document_};goog.dom.DomHelper.prototype.getElement=function(a){return goog.dom.getElementHelper_(this.document_,a)};goog.dom.DomHelper.prototype.getRequiredElement=function(a){return goog.dom.getRequiredElementHelper_(this.document_,a)};goog.dom.DomHelper.prototype.$=goog.dom.DomHelper.prototype.getElement;goog.dom.DomHelper.prototype.getElementsByTagName=function(a,b){return(b||this.document_).getElementsByTagName(String(a))};goog.dom.DomHelper.prototype.getElementsByTagNameAndClass=function(a,b,c){return goog.dom.getElementsByTagNameAndClass_(this.document_,a,b,c)};goog.dom.DomHelper.prototype.getElementByTagNameAndClass=function(a,b,c){return goog.dom.getElementByTagNameAndClass_(this.document_,a,b,c)
-};goog.dom.DomHelper.prototype.getElementsByClass=function(a,b){return goog.dom.getElementsByClass(a,b||this.document_)};goog.dom.DomHelper.prototype.getElementByClass=function(a,b){return goog.dom.getElementByClass(a,b||this.document_)};goog.dom.DomHelper.prototype.getRequiredElementByClass=function(a,b){return goog.dom.getRequiredElementByClass(a,b||this.document_)};goog.dom.DomHelper.prototype.$$=goog.dom.DomHelper.prototype.getElementsByTagNameAndClass;goog.dom.DomHelper.prototype.setProperties=goog.dom.setProperties;goog.dom.DomHelper.prototype.getViewportSize=function(a){return goog.dom.getViewportSize(a||this.getWindow())};goog.dom.DomHelper.prototype.getDocumentHeight=function(){return goog.dom.getDocumentHeight_(this.getWindow())};goog.dom.DomHelper.prototype.createDom=function(a,b,c){return goog.dom.createDom_(this.document_,arguments)};goog.dom.DomHelper.prototype.$dom=goog.dom.DomHelper.prototype.createDom;goog.dom.DomHelper.prototype.createElement=function(a){return goog.dom.createElement_(this.document_,a)};goog.dom.DomHelper.prototype.createTextNode=function(a){return this.document_.createTextNode(String(a))};goog.dom.DomHelper.prototype.createTable=function(a,b,c){return goog.dom.createTable_(this.document_,a,b,!!c)};goog.dom.DomHelper.prototype.safeHtmlToNode=function(a){return goog.dom.safeHtmlToNode_(this.document_,a)};goog.dom.DomHelper.prototype.isCss1CompatMode=function(){return goog.dom.isCss1CompatMode_(this.document_)};goog.dom.DomHelper.prototype.getWindow=function(){return goog.dom.getWindow_(this.document_)};goog.dom.DomHelper.prototype.getDocumentScrollElement=function(){return goog.dom.getDocumentScrollElement_(this.document_)};goog.dom.DomHelper.prototype.getDocumentScroll=function(){return goog.dom.getDocumentScroll_(this.document_)};goog.dom.DomHelper.prototype.getActiveElement=function(a){return goog.dom.getActiveElement(a||this.document_)};goog.dom.DomHelper.prototype.appendChild=goog.dom.appendChild;goog.dom.DomHelper.prototype.append=goog.dom.append;
-goog.dom.DomHelper.prototype.canHaveChildren=goog.dom.canHaveChildren;goog.dom.DomHelper.prototype.removeChildren=goog.dom.removeChildren;goog.dom.DomHelper.prototype.insertSiblingBefore=goog.dom.insertSiblingBefore;goog.dom.DomHelper.prototype.insertSiblingAfter=goog.dom.insertSiblingAfter;goog.dom.DomHelper.prototype.insertChildAt=goog.dom.insertChildAt;goog.dom.DomHelper.prototype.removeNode=goog.dom.removeNode;goog.dom.DomHelper.prototype.replaceNode=goog.dom.replaceNode;goog.dom.DomHelper.prototype.flattenElement=goog.dom.flattenElement;goog.dom.DomHelper.prototype.getChildren=goog.dom.getChildren;goog.dom.DomHelper.prototype.getFirstElementChild=goog.dom.getFirstElementChild;goog.dom.DomHelper.prototype.getLastElementChild=goog.dom.getLastElementChild;goog.dom.DomHelper.prototype.getNextElementSibling=goog.dom.getNextElementSibling;goog.dom.DomHelper.prototype.getPreviousElementSibling=goog.dom.getPreviousElementSibling;goog.dom.DomHelper.prototype.getNextNode=goog.dom.getNextNode;goog.dom.DomHelper.prototype.getPreviousNode=goog.dom.getPreviousNode;goog.dom.DomHelper.prototype.isNodeLike=goog.dom.isNodeLike;goog.dom.DomHelper.prototype.isElement=goog.dom.isElement;goog.dom.DomHelper.prototype.isWindow=goog.dom.isWindow;goog.dom.DomHelper.prototype.getParentElement=goog.dom.getParentElement;goog.dom.DomHelper.prototype.contains=goog.dom.contains;goog.dom.DomHelper.prototype.compareNodeOrder=goog.dom.compareNodeOrder;goog.dom.DomHelper.prototype.findCommonAncestor=goog.dom.findCommonAncestor;goog.dom.DomHelper.prototype.getOwnerDocument=goog.dom.getOwnerDocument;goog.dom.DomHelper.prototype.getFrameContentDocument=goog.dom.getFrameContentDocument;goog.dom.DomHelper.prototype.getFrameContentWindow=goog.dom.getFrameContentWindow;goog.dom.DomHelper.prototype.setTextContent=goog.dom.setTextContent;goog.dom.DomHelper.prototype.getOuterHtml=goog.dom.getOuterHtml;goog.dom.DomHelper.prototype.findNode=goog.dom.findNode;goog.dom.DomHelper.prototype.findNodes=goog.dom.findNodes;
-goog.dom.DomHelper.prototype.isFocusableTabIndex=goog.dom.isFocusableTabIndex;goog.dom.DomHelper.prototype.setFocusableTabIndex=goog.dom.setFocusableTabIndex;goog.dom.DomHelper.prototype.isFocusable=goog.dom.isFocusable;goog.dom.DomHelper.prototype.getTextContent=goog.dom.getTextContent;goog.dom.DomHelper.prototype.getNodeTextLength=goog.dom.getNodeTextLength;goog.dom.DomHelper.prototype.getNodeTextOffset=goog.dom.getNodeTextOffset;goog.dom.DomHelper.prototype.getNodeAtOffset=goog.dom.getNodeAtOffset;goog.dom.DomHelper.prototype.isNodeList=goog.dom.isNodeList;goog.dom.DomHelper.prototype.getAncestorByTagNameAndClass=goog.dom.getAncestorByTagNameAndClass;goog.dom.DomHelper.prototype.getAncestorByClass=goog.dom.getAncestorByClass;goog.dom.DomHelper.prototype.getAncestor=goog.dom.getAncestor;goog.dom.DomHelper.prototype.getCanvasContext2D=goog.dom.getCanvasContext2D;goog.color={};goog.color.names={aliceblue:"#f0f8ff",antiquewhite:"#faebd7",aqua:"#00ffff",aquamarine:"#7fffd4",azure:"#f0ffff",beige:"#f5f5dc",bisque:"#ffe4c4",black:"#000000",blanchedalmond:"#ffebcd",blue:"#0000ff",blueviolet:"#8a2be2",brown:"#a52a2a",burlywood:"#deb887",cadetblue:"#5f9ea0",chartreuse:"#7fff00",chocolate:"#d2691e",coral:"#ff7f50",cornflowerblue:"#6495ed",cornsilk:"#fff8dc",crimson:"#dc143c",cyan:"#00ffff",darkblue:"#00008b",darkcyan:"#008b8b",darkgoldenrod:"#b8860b",darkgray:"#a9a9a9",darkgreen:"#006400",darkgrey:"#a9a9a9",darkkhaki:"#bdb76b",darkmagenta:"#8b008b",darkolivegreen:"#556b2f",darkorange:"#ff8c00",darkorchid:"#9932cc",darkred:"#8b0000",darksalmon:"#e9967a",darkseagreen:"#8fbc8f",darkslateblue:"#483d8b",darkslategray:"#2f4f4f",darkslategrey:"#2f4f4f",darkturquoise:"#00ced1",darkviolet:"#9400d3",deeppink:"#ff1493",deepskyblue:"#00bfff",dimgray:"#696969",dimgrey:"#696969",dodgerblue:"#1e90ff",firebrick:"#b22222",floralwhite:"#fffaf0",forestgreen:"#228b22",fuchsia:"#ff00ff",gainsboro:"#dcdcdc",ghostwhite:"#f8f8ff",gold:"#ffd700",goldenrod:"#daa520",gray:"#808080",green:"#008000",greenyellow:"#adff2f",grey:"#808080",honeydew:"#f0fff0",hotpink:"#ff69b4",indianred:"#cd5c5c",indigo:"#4b0082",ivory:"#fffff0",khaki:"#f0e68c",lavender:"#e6e6fa",lavenderblush:"#fff0f5",lawngreen:"#7cfc00",lemonchiffon:"#fffacd",lightblue:"#add8e6",lightcoral:"#f08080",lightcyan:"#e0ffff",lightgoldenrodyellow:"#fafad2",lightgray:"#d3d3d3",lightgreen:"#90ee90",lightgrey:"#d3d3d3",lightpink:"#ffb6c1",lightsalmon:"#ffa07a",lightseagreen:"#20b2aa",lightskyblue:"#87cefa",lightslategray:"#778899",lightslategrey:"#778899",lightsteelblue:"#b0c4de",lightyellow:"#ffffe0",lime:"#00ff00",limegreen:"#32cd32",linen:"#faf0e6",magenta:"#ff00ff",maroon:"#800000",mediumaquamarine:"#66cdaa",mediumblue:"#0000cd",mediumorchid:"#ba55d3",mediumpurple:"#9370db",mediumseagreen:"#3cb371",mediumslateblue:"#7b68ee",mediumspringgreen:"#00fa9a",mediumturquoise:"#48d1cc",mediumvioletred:"#c71585",midnightblue:"#191970",mintcream:"#f5fffa",mistyrose:"#ffe4e1",moccasin:"#ffe4b5",navajowhite:"#ffdead",navy:"#000080",oldlace:"#fdf5e6",olive:"#808000",olivedrab:"#6b8e23",orange:"#ffa500",orangered:"#ff4500",orchid:"#da70d6",palegoldenrod:"#eee8aa",palegreen:"#98fb98",paleturquoise:"#afeeee",palevioletred:"#db7093",papayawhip:"#ffefd5",peachpuff:"#ffdab9",peru:"#cd853f",pink:"#ffc0cb",plum:"#dda0dd",powderblue:"#b0e0e6",purple:"#800080",red:"#ff0000",rosybrown:"#bc8f8f",royalblue:"#4169e1",saddlebrown:"#8b4513",salmon:"#fa8072",sandybrown:"#f4a460",seagreen:"#2e8b57",seashell:"#fff5ee",sienna:"#a0522d",silver:"#c0c0c0",skyblue:"#87ceeb",slateblue:"#6a5acd",slategray:"#708090",slategrey:"#708090",snow:"#fffafa",springgreen:"#00ff7f",steelblue:"#4682b4",tan:"#d2b48c",teal:"#008080",thistle:"#d8bfd8",tomato:"#ff6347",turquoise:"#40e0d0",violet:"#ee82ee",wheat:"#f5deb3",white:"#ffffff",whitesmoke:"#f5f5f5",yellow:"#ffff00",yellowgreen:"#9acd32"};
-goog.color.parse=function(a){var b={};a=String(a);var c=goog.color.prependHashIfNecessaryHelper(a);if(goog.color.isValidHexColor_(c)){return b.hex=goog.color.normalizeHex(c),b.type="hex",b}c=goog.color.isValidRgbColor_(a);if(c.length){return b.hex=goog.color.rgbArrayToHex(c),b.type="rgb",b}if(goog.color.names&&(c=goog.color.names[a.toLowerCase()])){return b.hex=c,b.type="named",b}throw Error(a+" is not a valid color string")};goog.color.isValidColor=function(a){var b=goog.color.prependHashIfNecessaryHelper(a);return !!(goog.color.isValidHexColor_(b)||goog.color.isValidRgbColor_(a).length||goog.color.names&&goog.color.names[a.toLowerCase()])};goog.color.parseRgb=function(a){var b=goog.color.isValidRgbColor_(a);if(!b.length){throw Error(a+" is not a valid RGB color")}return b};goog.color.hexToRgbStyle=function(a){return goog.color.rgbStyle_(goog.color.hexToRgb(a))};goog.color.hexTripletRe_=/#(.)(.)(.)/;goog.color.normalizeHex=function(a){if(!goog.color.isValidHexColor_(a)){throw Error("'"+a+"' is not a valid hex color")}4==a.length&&(a=a.replace(goog.color.hexTripletRe_,"#$1$1$2$2$3$3"));return a.toLowerCase()};goog.color.hexToRgb=function(a){a=goog.color.normalizeHex(a);var b=parseInt(a.substr(1,2),16),c=parseInt(a.substr(3,2),16);a=parseInt(a.substr(5,2),16);return[b,c,a]};goog.color.rgbToHex=function(a,b,c){a=Number(a);b=Number(b);c=Number(c);if(a!=(a&255)||b!=(b&255)||c!=(c&255)){throw Error('"('+a+","+b+","+c+'") is not a valid RGB color')}a=goog.color.prependZeroIfNecessaryHelper(a.toString(16));b=goog.color.prependZeroIfNecessaryHelper(b.toString(16));c=goog.color.prependZeroIfNecessaryHelper(c.toString(16));return"#"+a+b+c};goog.color.rgbArrayToHex=function(a){return goog.color.rgbToHex(a[0],a[1],a[2])};goog.color.rgbToHsl=function(a,b,c){a/=255;b/=255;c/=255;var d=Math.max(a,b,c),e=Math.min(a,b,c),f=0,g=0,h=0.5*(d+e);d!=e&&(d==a?f=60*(b-c)/(d-e):d==b?f=60*(c-a)/(d-e)+120:d==c&&(f=60*(a-b)/(d-e)+240),g=0<h&&0.5>=h?(d-e)/(2*h):(d-e)/(2-2*h));return[Math.round(f+360)%360,g,h]
-};goog.color.rgbArrayToHsl=function(a){return goog.color.rgbToHsl(a[0],a[1],a[2])};goog.color.hueToRgb_=function(a,b,c){0>c?c+=1:1<c&&--c;return 1>6*c?a+6*(b-a)*c:1>2*c?b:2>3*c?a+(b-a)*(2/3-c)*6:a};goog.color.hslToRgb=function(a,b,c){a/=360;if(0==b){c=b=a=255*c}else{var d=0.5>c?c*(1+b):c+b-b*c;var e=2*c-d;c=255*goog.color.hueToRgb_(e,d,a+1/3);b=255*goog.color.hueToRgb_(e,d,a);a=255*goog.color.hueToRgb_(e,d,a-1/3)}return[Math.round(c),Math.round(b),Math.round(a)]};goog.color.hslArrayToRgb=function(a){return goog.color.hslToRgb(a[0],a[1],a[2])};goog.color.validHexColorRe_=/^#(?:[0-9a-f]{3}){1,2}$/i;goog.color.isValidHexColor_=function(a){return goog.color.validHexColorRe_.test(a)};goog.color.normalizedHexColorRe_=/^#[0-9a-f]{6}$/;goog.color.isNormalizedHexColor_=function(a){return goog.color.normalizedHexColorRe_.test(a)};goog.color.rgbColorRe_=/^(?:rgb)?\((0|[1-9]\d{0,2}),\s?(0|[1-9]\d{0,2}),\s?(0|[1-9]\d{0,2})\)$/i;goog.color.isValidRgbColor_=function(a){var b=a.match(goog.color.rgbColorRe_);if(b){a=Number(b[1]);var c=Number(b[2]);b=Number(b[3]);if(0<=a&&255>=a&&0<=c&&255>=c&&0<=b&&255>=b){return[a,c,b]}}return[]};goog.color.prependZeroIfNecessaryHelper=function(a){return 1==a.length?"0"+a:a};goog.color.prependHashIfNecessaryHelper=function(a){return"#"==a.charAt(0)?a:"#"+a};goog.color.rgbStyle_=function(a){return"rgb("+a.join(",")+")"};goog.color.hsvToRgb=function(a,b,c){var d=0,e=0,f=0;if(0==b){f=e=d=c}else{var g=Math.floor(a/60),h=a/60-g;a=c*(1-b);var k=c*(1-b*h);b=c*(1-b*(1-h));switch(g){case 1:d=k;e=c;f=a;break;case 2:d=a;e=c;f=b;break;case 3:d=a;e=k;f=c;break;case 4:d=b;e=a;f=c;break;case 5:d=c;e=a;f=k;break;case 6:case 0:d=c,e=b,f=a}}return[Math.floor(d),Math.floor(e),Math.floor(f)]};goog.color.rgbToHsv=function(a,b,c){var d=Math.max(Math.max(a,b),c),e=Math.min(Math.min(a,b),c);if(e==d){e=a=0}else{var f=d-e;e=f/d;a=60*(a==d?(b-c)/f:b==d?2+(c-a)/f:4+(a-b)/f);0>a&&(a+=360);360<a&&(a-=360)}return[a,e,d]};goog.color.rgbArrayToHsv=function(a){return goog.color.rgbToHsv(a[0],a[1],a[2])
-};goog.color.hsvArrayToRgb=function(a){return goog.color.hsvToRgb(a[0],a[1],a[2])};goog.color.hexToHsl=function(a){a=goog.color.hexToRgb(a);return goog.color.rgbToHsl(a[0],a[1],a[2])};goog.color.hslToHex=function(a,b,c){return goog.color.rgbArrayToHex(goog.color.hslToRgb(a,b,c))};goog.color.hslArrayToHex=function(a){return goog.color.rgbArrayToHex(goog.color.hslToRgb(a[0],a[1],a[2]))};goog.color.hexToHsv=function(a){return goog.color.rgbArrayToHsv(goog.color.hexToRgb(a))};goog.color.hsvToHex=function(a,b,c){return goog.color.rgbArrayToHex(goog.color.hsvToRgb(a,b,c))};goog.color.hsvArrayToHex=function(a){return goog.color.hsvToHex(a[0],a[1],a[2])};goog.color.hslDistance=function(a,b){var c=0.5>=a[2]?a[1]*a[2]:a[1]*(1-a[2]);var d=0.5>=b[2]?b[1]*b[2]:b[1]*(1-b[2]);return(a[2]-b[2])*(a[2]-b[2])+c*c+d*d-2*c*d*Math.cos(2*(a[0]/360-b[0]/360)*Math.PI)};goog.color.blend=function(a,b,c){c=goog.math.clamp(c,0,1);return[Math.round(c*a[0]+(1-c)*b[0]),Math.round(c*a[1]+(1-c)*b[1]),Math.round(c*a[2]+(1-c)*b[2])]};goog.color.darken=function(a,b){return goog.color.blend([0,0,0],a,b)};goog.color.lighten=function(a,b){return goog.color.blend([255,255,255],a,b)};goog.color.highContrast=function(a,b){for(var c=[],d=0;d<b.length;d++){c.push({color:b[d],diff:goog.color.yiqBrightnessDiff_(b[d],a)+goog.color.colorDiff_(b[d],a)})}c.sort(function(a,b){return b.diff-a.diff});return c[0].color};goog.color.yiqBrightness_=function(a){return Math.round((299*a[0]+587*a[1]+114*a[2])/1000)};goog.color.yiqBrightnessDiff_=function(a,b){return Math.abs(goog.color.yiqBrightness_(a)-goog.color.yiqBrightness_(b))};goog.color.colorDiff_=function(a,b){return Math.abs(a[0]-b[0])+Math.abs(a[1]-b[1])+Math.abs(a[2]-b[2])};goog.dom.vendor={};goog.dom.vendor.getVendorJsPrefix=function(){return goog.userAgent.WEBKIT?"Webkit":goog.userAgent.GECKO?"Moz":goog.userAgent.IE?"ms":goog.userAgent.OPERA?"O":null};goog.dom.vendor.getVendorPrefix=function(){return goog.userAgent.WEBKIT?"-webkit":goog.userAgent.GECKO?"-moz":goog.userAgent.IE?"-ms":goog.userAgent.OPERA?"-o":null
-};goog.dom.vendor.getPrefixedPropertyName=function(a,b){if(b&&a in b){return a}var c=goog.dom.vendor.getVendorJsPrefix();return c?(c=c.toLowerCase(),c+=goog.string.toTitleCase(a),!goog.isDef(b)||c in b?c:null):null};goog.dom.vendor.getPrefixedEventType=function(a){return((goog.dom.vendor.getVendorJsPrefix()||"")+a).toLowerCase()};goog.math.Box=function(a,b,c,d){this.top=a;this.right=b;this.bottom=c;this.left=d};goog.math.Box.boundingBox=function(a){for(var b=new goog.math.Box(arguments[0].y,arguments[0].x,arguments[0].y,arguments[0].x),c=1;c<arguments.length;c++){b.expandToIncludeCoordinate(arguments[c])}return b};goog.math.Box.prototype.getWidth=function(){return this.right-this.left};goog.math.Box.prototype.getHeight=function(){return this.bottom-this.top};goog.math.Box.prototype.clone=function(){return new goog.math.Box(this.top,this.right,this.bottom,this.left)};goog.DEBUG&&(goog.math.Box.prototype.toString=function(){return"("+this.top+"t, "+this.right+"r, "+this.bottom+"b, "+this.left+"l)"});goog.math.Box.prototype.contains=function(a){return goog.math.Box.contains(this,a)};goog.math.Box.prototype.expand=function(a,b,c,d){goog.isObject(a)?(this.top-=a.top,this.right+=a.right,this.bottom+=a.bottom,this.left-=a.left):(this.top-=a,this.right+=Number(b),this.bottom+=Number(c),this.left-=Number(d));return this};goog.math.Box.prototype.expandToInclude=function(a){this.left=Math.min(this.left,a.left);this.top=Math.min(this.top,a.top);this.right=Math.max(this.right,a.right);this.bottom=Math.max(this.bottom,a.bottom)};goog.math.Box.prototype.expandToIncludeCoordinate=function(a){this.top=Math.min(this.top,a.y);this.right=Math.max(this.right,a.x);this.bottom=Math.max(this.bottom,a.y);this.left=Math.min(this.left,a.x)};goog.math.Box.equals=function(a,b){return a==b?!0:a&&b?a.top==b.top&&a.right==b.right&&a.bottom==b.bottom&&a.left==b.left:!1};goog.math.Box.contains=function(a,b){return a&&b?b instanceof goog.math.Box?b.left>=a.left&&b.right<=a.right&&b.top>=a.top&&b.bottom<=a.bottom:b.x>=a.left&&b.x<=a.right&&b.y>=a.top&&b.y<=a.bottom:!1
-};goog.math.Box.relativePositionX=function(a,b){return b.x<a.left?b.x-a.left:b.x>a.right?b.x-a.right:0};goog.math.Box.relativePositionY=function(a,b){return b.y<a.top?b.y-a.top:b.y>a.bottom?b.y-a.bottom:0};goog.math.Box.distance=function(a,b){var c=goog.math.Box.relativePositionX(a,b),d=goog.math.Box.relativePositionY(a,b);return Math.sqrt(c*c+d*d)};goog.math.Box.intersects=function(a,b){return a.left<=b.right&&b.left<=a.right&&a.top<=b.bottom&&b.top<=a.bottom};goog.math.Box.intersectsWithPadding=function(a,b,c){return a.left<=b.right+c&&b.left<=a.right+c&&a.top<=b.bottom+c&&b.top<=a.bottom+c};goog.math.Box.prototype.ceil=function(){this.top=Math.ceil(this.top);this.right=Math.ceil(this.right);this.bottom=Math.ceil(this.bottom);this.left=Math.ceil(this.left);return this};goog.math.Box.prototype.floor=function(){this.top=Math.floor(this.top);this.right=Math.floor(this.right);this.bottom=Math.floor(this.bottom);this.left=Math.floor(this.left);return this};goog.math.Box.prototype.round=function(){this.top=Math.round(this.top);this.right=Math.round(this.right);this.bottom=Math.round(this.bottom);this.left=Math.round(this.left);return this};goog.math.Box.prototype.translate=function(a,b){a instanceof goog.math.Coordinate?(this.left+=a.x,this.right+=a.x,this.top+=a.y,this.bottom+=a.y):(goog.asserts.assertNumber(a),this.left+=a,this.right+=a,goog.isNumber(b)&&(this.top+=b,this.bottom+=b));return this};goog.math.Box.prototype.scale=function(a,b){var c=goog.isNumber(b)?b:a;this.left*=a;this.right*=a;this.top*=c;this.bottom*=c;return this};goog.math.IRect=function(){};goog.math.Rect=function(a,b,c,d){this.left=a;this.top=b;this.width=c;this.height=d};goog.math.Rect.prototype.clone=function(){return new goog.math.Rect(this.left,this.top,this.width,this.height)};goog.math.Rect.prototype.toBox=function(){return new goog.math.Box(this.top,this.left+this.width,this.top+this.height,this.left)};goog.math.Rect.createFromPositionAndSize=function(a,b){return new goog.math.Rect(a.x,a.y,b.width,b.height)
-};goog.math.Rect.createFromBox=function(a){return new goog.math.Rect(a.left,a.top,a.right-a.left,a.bottom-a.top)};goog.DEBUG&&(goog.math.Rect.prototype.toString=function(){return"("+this.left+", "+this.top+" - "+this.width+"w x "+this.height+"h)"});goog.math.Rect.equals=function(a,b){return a==b?!0:a&&b?a.left==b.left&&a.width==b.width&&a.top==b.top&&a.height==b.height:!1};goog.math.Rect.prototype.intersection=function(a){var b=Math.max(this.left,a.left),c=Math.min(this.left+this.width,a.left+a.width);if(b<=c){var d=Math.max(this.top,a.top);a=Math.min(this.top+this.height,a.top+a.height);if(d<=a){return this.left=b,this.top=d,this.width=c-b,this.height=a-d,!0}}return !1};goog.math.Rect.intersection=function(a,b){var c=Math.max(a.left,b.left),d=Math.min(a.left+a.width,b.left+b.width);if(c<=d){var e=Math.max(a.top,b.top),f=Math.min(a.top+a.height,b.top+b.height);if(e<=f){return new goog.math.Rect(c,e,d-c,f-e)}}return null};goog.math.Rect.intersects=function(a,b){return a.left<=b.left+b.width&&b.left<=a.left+a.width&&a.top<=b.top+b.height&&b.top<=a.top+a.height};goog.math.Rect.prototype.intersects=function(a){return goog.math.Rect.intersects(this,a)};goog.math.Rect.difference=function(a,b){var c=goog.math.Rect.intersection(a,b);if(!c||!c.height||!c.width){return[a.clone()]}c=[];var d=a.top,e=a.height,f=a.left+a.width,g=a.top+a.height,h=b.left+b.width,k=b.top+b.height;b.top>a.top&&(c.push(new goog.math.Rect(a.left,a.top,a.width,b.top-a.top)),d=b.top,e-=b.top-a.top);k<g&&(c.push(new goog.math.Rect(a.left,k,a.width,g-k)),e=k-d);b.left>a.left&&c.push(new goog.math.Rect(a.left,d,b.left-a.left,e));h<f&&c.push(new goog.math.Rect(h,d,f-h,e));return c};goog.math.Rect.prototype.difference=function(a){return goog.math.Rect.difference(this,a)};goog.math.Rect.prototype.boundingRect=function(a){var b=Math.max(this.left+this.width,a.left+a.width),c=Math.max(this.top+this.height,a.top+a.height);this.left=Math.min(this.left,a.left);this.top=Math.min(this.top,a.top);this.width=b-this.left;
-this.height=c-this.top};goog.math.Rect.boundingRect=function(a,b){if(!a||!b){return null}var c=new goog.math.Rect(a.left,a.top,a.width,a.height);c.boundingRect(b);return c};goog.math.Rect.prototype.contains=function(a){return a instanceof goog.math.Coordinate?a.x>=this.left&&a.x<=this.left+this.width&&a.y>=this.top&&a.y<=this.top+this.height:this.left<=a.left&&this.left+this.width>=a.left+a.width&&this.top<=a.top&&this.top+this.height>=a.top+a.height};goog.math.Rect.prototype.squaredDistance=function(a){var b=a.x<this.left?this.left-a.x:Math.max(a.x-(this.left+this.width),0);a=a.y<this.top?this.top-a.y:Math.max(a.y-(this.top+this.height),0);return b*b+a*a};goog.math.Rect.prototype.distance=function(a){return Math.sqrt(this.squaredDistance(a))};goog.math.Rect.prototype.getSize=function(){return new goog.math.Size(this.width,this.height)};goog.math.Rect.prototype.getTopLeft=function(){return new goog.math.Coordinate(this.left,this.top)};goog.math.Rect.prototype.getCenter=function(){return new goog.math.Coordinate(this.left+this.width/2,this.top+this.height/2)};goog.math.Rect.prototype.getBottomRight=function(){return new goog.math.Coordinate(this.left+this.width,this.top+this.height)};goog.math.Rect.prototype.ceil=function(){this.left=Math.ceil(this.left);this.top=Math.ceil(this.top);this.width=Math.ceil(this.width);this.height=Math.ceil(this.height);return this};goog.math.Rect.prototype.floor=function(){this.left=Math.floor(this.left);this.top=Math.floor(this.top);this.width=Math.floor(this.width);this.height=Math.floor(this.height);return this};goog.math.Rect.prototype.round=function(){this.left=Math.round(this.left);this.top=Math.round(this.top);this.width=Math.round(this.width);this.height=Math.round(this.height);return this};goog.math.Rect.prototype.translate=function(a,b){a instanceof goog.math.Coordinate?(this.left+=a.x,this.top+=a.y):(this.left+=goog.asserts.assertNumber(a),goog.isNumber(b)&&(this.top+=b));return this};goog.math.Rect.prototype.scale=function(a,b){var c=goog.isNumber(b)?b:a;
-this.left*=a;this.width*=a;this.top*=c;this.height*=c;return this};goog.style={};goog.style.setStyle=function(a,b,c){if(goog.isString(b)){goog.style.setStyle_(a,c,b)}else{for(var d in b){goog.style.setStyle_(a,b[d],d)}}};goog.style.setStyle_=function(a,b,c){(c=goog.style.getVendorJsStyleName_(a,c))&&(a.style[c]=b)};goog.style.styleNameCache_={};goog.style.getVendorJsStyleName_=function(a,b){var c=goog.style.styleNameCache_[b];if(!c){var d=goog.string.toCamelCase(b);c=d;void 0===a.style[d]&&(d=goog.dom.vendor.getVendorJsPrefix()+goog.string.toTitleCase(d),void 0!==a.style[d]&&(c=d));goog.style.styleNameCache_[b]=c}return c};goog.style.getVendorStyleName_=function(a,b){var c=goog.string.toCamelCase(b);return void 0===a.style[c]&&(c=goog.dom.vendor.getVendorJsPrefix()+goog.string.toTitleCase(c),void 0!==a.style[c])?goog.dom.vendor.getVendorPrefix()+"-"+b:b};goog.style.getStyle=function(a,b){var c=a.style[goog.string.toCamelCase(b)];return"undefined"!==typeof c?c:a.style[goog.style.getVendorJsStyleName_(a,b)]||""};goog.style.getComputedStyle=function(a,b){var c=goog.dom.getOwnerDocument(a);return c.defaultView&&c.defaultView.getComputedStyle&&(c=c.defaultView.getComputedStyle(a,null))?c[b]||c.getPropertyValue(b)||"":""};goog.style.getCascadedStyle=function(a,b){return a.currentStyle?a.currentStyle[b]:null};goog.style.getStyle_=function(a,b){return goog.style.getComputedStyle(a,b)||goog.style.getCascadedStyle(a,b)||a.style&&a.style[b]};goog.style.getComputedBoxSizing=function(a){return goog.style.getStyle_(a,"boxSizing")||goog.style.getStyle_(a,"MozBoxSizing")||goog.style.getStyle_(a,"WebkitBoxSizing")||null};goog.style.getComputedPosition=function(a){return goog.style.getStyle_(a,"position")};goog.style.getBackgroundColor=function(a){return goog.style.getStyle_(a,"backgroundColor")};goog.style.getComputedOverflowX=function(a){return goog.style.getStyle_(a,"overflowX")};goog.style.getComputedOverflowY=function(a){return goog.style.getStyle_(a,"overflowY")};goog.style.getComputedZIndex=function(a){return goog.style.getStyle_(a,"zIndex")
-};goog.style.getComputedTextAlign=function(a){return goog.style.getStyle_(a,"textAlign")};goog.style.getComputedCursor=function(a){return goog.style.getStyle_(a,"cursor")};goog.style.getComputedTransform=function(a){var b=goog.style.getVendorStyleName_(a,"transform");return goog.style.getStyle_(a,b)||goog.style.getStyle_(a,"transform")};goog.style.setPosition=function(a,b,c){if(b instanceof goog.math.Coordinate){var d=b.x;b=b.y}else{d=b,b=c}a.style.left=goog.style.getPixelStyleValue_(d,!1);a.style.top=goog.style.getPixelStyleValue_(b,!1)};goog.style.getPosition=function(a){return new goog.math.Coordinate(a.offsetLeft,a.offsetTop)};goog.style.getClientViewportElement=function(a){a=a?goog.dom.getOwnerDocument(a):goog.dom.getDocument();return !goog.userAgent.IE||goog.userAgent.isDocumentModeOrHigher(9)||goog.dom.getDomHelper(a).isCss1CompatMode()?a.documentElement:a.body};goog.style.getViewportPageOffset=function(a){var b=a.body;a=a.documentElement;return new goog.math.Coordinate(b.scrollLeft||a.scrollLeft,b.scrollTop||a.scrollTop)};goog.style.getBoundingClientRect_=function(a){try{var b=a.getBoundingClientRect()}catch(c){return{left:0,top:0,right:0,bottom:0}}goog.userAgent.IE&&a.ownerDocument.body&&(a=a.ownerDocument,b.left-=a.documentElement.clientLeft+a.body.clientLeft,b.top-=a.documentElement.clientTop+a.body.clientTop);return b};goog.style.getOffsetParent=function(a){if(goog.userAgent.IE&&!goog.userAgent.isDocumentModeOrHigher(8)){return goog.asserts.assert(a&&"offsetParent" in a),a.offsetParent}var b=goog.dom.getOwnerDocument(a),c=goog.style.getStyle_(a,"position"),d="fixed"==c||"absolute"==c;for(a=a.parentNode;a&&a!=b;a=a.parentNode){if(a.nodeType==goog.dom.NodeType.DOCUMENT_FRAGMENT&&a.host&&(a=a.host),c=goog.style.getStyle_(a,"position"),d=d&&"static"==c&&a!=b.documentElement&&a!=b.body,!d&&(a.scrollWidth>a.clientWidth||a.scrollHeight>a.clientHeight||"fixed"==c||"absolute"==c||"relative"==c)){return a}}return null};goog.style.getVisibleRectForElement=function(a){for(var b=new goog.math.Box(0,Infinity,Infinity,0),c=goog.dom.getDomHelper(a),d=c.getDocument().body,e=c.getDocument().documentElement,f=c.getDocumentScrollElement();
-a=goog.style.getOffsetParent(a);){if(!(goog.userAgent.IE&&0==a.clientWidth||goog.userAgent.WEBKIT&&0==a.clientHeight&&a==d)&&a!=d&&a!=e&&"visible"!=goog.style.getStyle_(a,"overflow")){var g=goog.style.getPageOffset(a),h=goog.style.getClientLeftTop(a);g.x+=h.x;g.y+=h.y;b.top=Math.max(b.top,g.y);b.right=Math.min(b.right,g.x+a.clientWidth);b.bottom=Math.min(b.bottom,g.y+a.clientHeight);b.left=Math.max(b.left,g.x)}}d=f.scrollLeft;f=f.scrollTop;b.left=Math.max(b.left,d);b.top=Math.max(b.top,f);c=c.getViewportSize();b.right=Math.min(b.right,d+c.width);b.bottom=Math.min(b.bottom,f+c.height);return 0<=b.top&&0<=b.left&&b.bottom>b.top&&b.right>b.left?b:null};goog.style.getContainerOffsetToScrollInto=function(a,b,c){var d=b||goog.dom.getDocumentScrollElement(),e=goog.style.getPageOffset(a),f=goog.style.getPageOffset(d),g=goog.style.getBorderBox(d);d==goog.dom.getDocumentScrollElement()?(b=e.x-d.scrollLeft,e=e.y-d.scrollTop,goog.userAgent.IE&&!goog.userAgent.isDocumentModeOrHigher(10)&&(b+=g.left,e+=g.top)):(b=e.x-f.x-g.left,e=e.y-f.y-g.top);g=goog.style.getSizeWithDisplay_(a);a=d.clientWidth-g.width;g=d.clientHeight-g.height;f=d.scrollLeft;d=d.scrollTop;c?(f+=b-a/2,d+=e-g/2):(f+=Math.min(b,Math.max(b-a,0)),d+=Math.min(e,Math.max(e-g,0)));return new goog.math.Coordinate(f,d)};goog.style.scrollIntoContainerView=function(a,b,c){b=b||goog.dom.getDocumentScrollElement();a=goog.style.getContainerOffsetToScrollInto(a,b,c);b.scrollLeft=a.x;b.scrollTop=a.y};goog.style.getClientLeftTop=function(a){return new goog.math.Coordinate(a.clientLeft,a.clientTop)};goog.style.getPageOffset=function(a){var b=goog.dom.getOwnerDocument(a);goog.asserts.assertObject(a,"Parameter is required");var c=new goog.math.Coordinate(0,0),d=goog.style.getClientViewportElement(b);if(a==d){return c}a=goog.style.getBoundingClientRect_(a);b=goog.dom.getDomHelper(b).getDocumentScroll();c.x=a.left+b.x;c.y=a.top+b.y;return c};goog.style.getPageOffsetLeft=function(a){return goog.style.getPageOffset(a).x};goog.style.getPageOffsetTop=function(a){return goog.style.getPageOffset(a).y
-};goog.style.getFramedPageOffset=function(a,b){var c=new goog.math.Coordinate(0,0),d=goog.dom.getWindow(goog.dom.getOwnerDocument(a));if(!goog.reflect.canAccessProperty(d,"parent")){return c}var e=a;do{var f=d==b?goog.style.getPageOffset(e):goog.style.getClientPositionForElement_(goog.asserts.assert(e));c.x+=f.x;c.y+=f.y}while(d&&d!=b&&d!=d.parent&&(e=d.frameElement)&&(d=d.parent));return c};goog.style.translateRectForAnotherFrame=function(a,b,c){if(b.getDocument()!=c.getDocument()){var d=b.getDocument().body;c=goog.style.getFramedPageOffset(d,c.getWindow());c=goog.math.Coordinate.difference(c,goog.style.getPageOffset(d));!goog.userAgent.IE||goog.userAgent.isDocumentModeOrHigher(9)||b.isCss1CompatMode()||(c=goog.math.Coordinate.difference(c,b.getDocumentScroll()));a.left+=c.x;a.top+=c.y}};goog.style.getRelativePosition=function(a,b){var c=goog.style.getClientPosition(a),d=goog.style.getClientPosition(b);return new goog.math.Coordinate(c.x-d.x,c.y-d.y)};goog.style.getClientPositionForElement_=function(a){a=goog.style.getBoundingClientRect_(a);return new goog.math.Coordinate(a.left,a.top)};goog.style.getClientPosition=function(a){goog.asserts.assert(a);if(a.nodeType==goog.dom.NodeType.ELEMENT){return goog.style.getClientPositionForElement_(a)}a=a.changedTouches?a.changedTouches[0]:a;return new goog.math.Coordinate(a.clientX,a.clientY)};goog.style.setPageOffset=function(a,b,c){var d=goog.style.getPageOffset(a);b instanceof goog.math.Coordinate&&(c=b.y,b=b.x);b=goog.asserts.assertNumber(b)-d.x;goog.style.setPosition(a,a.offsetLeft+b,a.offsetTop+(Number(c)-d.y))};goog.style.setSize=function(a,b,c){if(b instanceof goog.math.Size){c=b.height,b=b.width}else{if(void 0==c){throw Error("missing height argument")}}goog.style.setWidth(a,b);goog.style.setHeight(a,c)};goog.style.getPixelStyleValue_=function(a,b){"number"==typeof a&&(a=(b?Math.round(a):a)+"px");return a};goog.style.setHeight=function(a,b){a.style.height=goog.style.getPixelStyleValue_(b,!0)};goog.style.setWidth=function(a,b){a.style.width=goog.style.getPixelStyleValue_(b,!0)
-};goog.style.getSize=function(a){return goog.style.evaluateWithTemporaryDisplay_(goog.style.getSizeWithDisplay_,a)};goog.style.evaluateWithTemporaryDisplay_=function(a,b){if("none"!=goog.style.getStyle_(b,"display")){return a(b)}var c=b.style,d=c.display,e=c.visibility,f=c.position;c.visibility="hidden";c.position="absolute";c.display="inline";var g=a(b);c.display=d;c.position=f;c.visibility=e;return g};goog.style.getSizeWithDisplay_=function(a){var b=a.offsetWidth,c=a.offsetHeight,d=goog.userAgent.WEBKIT&&!b&&!c;return goog.isDef(b)&&!d||!a.getBoundingClientRect?new goog.math.Size(b,c):(a=goog.style.getBoundingClientRect_(a),new goog.math.Size(a.right-a.left,a.bottom-a.top))};goog.style.getTransformedSize=function(a){if(!a.getBoundingClientRect){return null}a=goog.style.evaluateWithTemporaryDisplay_(goog.style.getBoundingClientRect_,a);return new goog.math.Size(a.right-a.left,a.bottom-a.top)};goog.style.getBounds=function(a){var b=goog.style.getPageOffset(a);a=goog.style.getSize(a);return new goog.math.Rect(b.x,b.y,a.width,a.height)};goog.style.toCamelCase=function(a){return goog.string.toCamelCase(String(a))};goog.style.toSelectorCase=function(a){return goog.string.toSelectorCase(a)};goog.style.getOpacity=function(a){goog.asserts.assert(a);var b=a.style;a="";"opacity" in b?a=b.opacity:"MozOpacity" in b?a=b.MozOpacity:"filter" in b&&(b=b.filter.match(/alpha\(opacity=([\d.]+)\)/))&&(a=String(b[1]/100));return""==a?a:Number(a)};goog.style.setOpacity=function(a,b){goog.asserts.assert(a);var c=a.style;"opacity" in c?c.opacity=b:"MozOpacity" in c?c.MozOpacity=b:"filter" in c&&(c.filter=""===b?"":"alpha(opacity="+100*Number(b)+")")};goog.style.setTransparentBackgroundImage=function(a,b){var c=a.style;goog.userAgent.IE&&!goog.userAgent.isVersionOrHigher("8")?c.filter='progid:DXImageTransform.Microsoft.AlphaImageLoader(src="'+b+'", sizingMethod="crop")':(c.backgroundImage="url("+b+")",c.backgroundPosition="top left",c.backgroundRepeat="no-repeat")};goog.style.clearTransparentBackgroundImage=function(a){a=a.style;
-"filter" in a?a.filter="":a.backgroundImage="none"};goog.style.showElement=function(a,b){goog.style.setElementShown(a,b)};goog.style.setElementShown=function(a,b){a.style.display=b?"":"none"};goog.style.isElementShown=function(a){return"none"!=a.style.display};goog.style.installSafeStyleSheet=function(a,b){var c=goog.dom.getDomHelper(b),d=c.getDocument();if(goog.userAgent.IE&&d.createStyleSheet){return c=d.createStyleSheet(),goog.style.setSafeStyleSheet(c,a),c}d=c.getElementsByTagNameAndClass("HEAD")[0];if(!d){var e=c.getElementsByTagNameAndClass("BODY")[0];d=c.createDom("HEAD");e.parentNode.insertBefore(d,e)}e=c.createDom("STYLE");goog.style.setSafeStyleSheet(e,a);c.appendChild(d,e);return e};goog.style.uninstallStyles=function(a){goog.dom.removeNode(a.ownerNode||a.owningElement||a)};goog.style.setSafeStyleSheet=function(a,b){var c=goog.html.SafeStyleSheet.unwrap(b);goog.userAgent.IE&&goog.isDef(a.cssText)?a.cssText=c:a.innerHTML=c};goog.style.setPreWrap=function(a){a=a.style;goog.userAgent.IE&&!goog.userAgent.isVersionOrHigher("8")?(a.whiteSpace="pre",a.wordWrap="break-word"):a.whiteSpace=goog.userAgent.GECKO?"-moz-pre-wrap":"pre-wrap"};goog.style.setInlineBlock=function(a){a=a.style;a.position="relative";goog.userAgent.IE&&!goog.userAgent.isVersionOrHigher("8")?(a.zoom="1",a.display="inline"):a.display="inline-block"};goog.style.isRightToLeft=function(a){return"rtl"==goog.style.getStyle_(a,"direction")};goog.style.unselectableStyle_=goog.userAgent.GECKO?"MozUserSelect":goog.userAgent.WEBKIT||goog.userAgent.EDGE?"WebkitUserSelect":null;goog.style.isUnselectable=function(a){return goog.style.unselectableStyle_?"none"==a.style[goog.style.unselectableStyle_].toLowerCase():goog.userAgent.IE||goog.userAgent.OPERA?"on"==a.getAttribute("unselectable"):!1};goog.style.setUnselectable=function(a,b,c){c=c?null:a.getElementsByTagName("*");var d=goog.style.unselectableStyle_;if(d){if(b=b?"none":"",a.style&&(a.style[d]=b),c){a=0;for(var e;e=c[a];a++){e.style&&(e.style[d]=b)}}}else{if(goog.userAgent.IE||goog.userAgent.OPERA){if(b=b?"on":"",a.setAttribute("unselectable",b),c){for(a=0;
-e=c[a];a++){e.setAttribute("unselectable",b)}}}}};goog.style.getBorderBoxSize=function(a){return new goog.math.Size(a.offsetWidth,a.offsetHeight)};goog.style.setBorderBoxSize=function(a,b){var c=goog.dom.getOwnerDocument(a),d=goog.dom.getDomHelper(c).isCss1CompatMode();if(!goog.userAgent.IE||goog.userAgent.isVersionOrHigher("10")||d&&goog.userAgent.isVersionOrHigher("8")){goog.style.setBoxSizingSize_(a,b,"border-box")}else{if(c=a.style,d){d=goog.style.getPaddingBox(a);var e=goog.style.getBorderBox(a);c.pixelWidth=b.width-e.left-d.left-d.right-e.right;c.pixelHeight=b.height-e.top-d.top-d.bottom-e.bottom}else{c.pixelWidth=b.width,c.pixelHeight=b.height}}};goog.style.getContentBoxSize=function(a){var b=goog.dom.getOwnerDocument(a),c=goog.userAgent.IE&&a.currentStyle;if(c&&goog.dom.getDomHelper(b).isCss1CompatMode()&&"auto"!=c.width&&"auto"!=c.height&&!c.boxSizing){return b=goog.style.getIePixelValue_(a,c.width,"width","pixelWidth"),a=goog.style.getIePixelValue_(a,c.height,"height","pixelHeight"),new goog.math.Size(b,a)}c=goog.style.getBorderBoxSize(a);b=goog.style.getPaddingBox(a);a=goog.style.getBorderBox(a);return new goog.math.Size(c.width-a.left-b.left-b.right-a.right,c.height-a.top-b.top-b.bottom-a.bottom)};goog.style.setContentBoxSize=function(a,b){var c=goog.dom.getOwnerDocument(a),d=goog.dom.getDomHelper(c).isCss1CompatMode();if(!goog.userAgent.IE||goog.userAgent.isVersionOrHigher("10")||d&&goog.userAgent.isVersionOrHigher("8")){goog.style.setBoxSizingSize_(a,b,"content-box")}else{if(c=a.style,d){c.pixelWidth=b.width,c.pixelHeight=b.height}else{d=goog.style.getPaddingBox(a);var e=goog.style.getBorderBox(a);c.pixelWidth=b.width+e.left+d.left+d.right+e.right;c.pixelHeight=b.height+e.top+d.top+d.bottom+e.bottom}}};goog.style.setBoxSizingSize_=function(a,b,c){a=a.style;goog.userAgent.GECKO?a.MozBoxSizing=c:goog.userAgent.WEBKIT?a.WebkitBoxSizing=c:a.boxSizing=c;a.width=Math.max(b.width,0)+"px";a.height=Math.max(b.height,0)+"px"};goog.style.getIePixelValue_=function(a,b,c,d){if(/^\d+px?$/.test(b)){return parseInt(b,10)
-}var e=a.style[c],f=a.runtimeStyle[c];a.runtimeStyle[c]=a.currentStyle[c];a.style[c]=b;b=a.style[d];a.style[c]=e;a.runtimeStyle[c]=f;return +b};goog.style.getIePixelDistance_=function(a,b){var c=goog.style.getCascadedStyle(a,b);return c?goog.style.getIePixelValue_(a,c,"left","pixelLeft"):0};goog.style.getBox_=function(a,b){if(goog.userAgent.IE){var c=goog.style.getIePixelDistance_(a,b+"Left"),d=goog.style.getIePixelDistance_(a,b+"Right"),e=goog.style.getIePixelDistance_(a,b+"Top"),f=goog.style.getIePixelDistance_(a,b+"Bottom");return new goog.math.Box(e,d,f,c)}c=goog.style.getComputedStyle(a,b+"Left");d=goog.style.getComputedStyle(a,b+"Right");e=goog.style.getComputedStyle(a,b+"Top");f=goog.style.getComputedStyle(a,b+"Bottom");return new goog.math.Box(parseFloat(e),parseFloat(d),parseFloat(f),parseFloat(c))};goog.style.getPaddingBox=function(a){return goog.style.getBox_(a,"padding")};goog.style.getMarginBox=function(a){return goog.style.getBox_(a,"margin")};goog.style.ieBorderWidthKeywords_={thin:2,medium:4,thick:6};goog.style.getIePixelBorder_=function(a,b){if("none"==goog.style.getCascadedStyle(a,b+"Style")){return 0}var c=goog.style.getCascadedStyle(a,b+"Width");return c in goog.style.ieBorderWidthKeywords_?goog.style.ieBorderWidthKeywords_[c]:goog.style.getIePixelValue_(a,c,"left","pixelLeft")};goog.style.getBorderBox=function(a){if(goog.userAgent.IE&&!goog.userAgent.isDocumentModeOrHigher(9)){var b=goog.style.getIePixelBorder_(a,"borderLeft"),c=goog.style.getIePixelBorder_(a,"borderRight"),d=goog.style.getIePixelBorder_(a,"borderTop");a=goog.style.getIePixelBorder_(a,"borderBottom");return new goog.math.Box(d,c,a,b)}b=goog.style.getComputedStyle(a,"borderLeftWidth");c=goog.style.getComputedStyle(a,"borderRightWidth");d=goog.style.getComputedStyle(a,"borderTopWidth");a=goog.style.getComputedStyle(a,"borderBottomWidth");return new goog.math.Box(parseFloat(d),parseFloat(c),parseFloat(a),parseFloat(b))};goog.style.getFontFamily=function(a){var b=goog.dom.getOwnerDocument(a),c="";
-if(b.body.createTextRange&&goog.dom.contains(b,a)){b=b.body.createTextRange();b.moveToElementText(a);try{c=b.queryCommandValue("FontName")}catch(d){c=""}}c||(c=goog.style.getStyle_(a,"fontFamily"));a=c.split(",");1<a.length&&(c=a[0]);return goog.string.stripQuotes(c,"\"'")};goog.style.lengthUnitRegex_=/[^\d]+$/;goog.style.getLengthUnits=function(a){return(a=a.match(goog.style.lengthUnitRegex_))&&a[0]||null};goog.style.ABSOLUTE_CSS_LENGTH_UNITS_={cm:1,"in":1,mm:1,pc:1,pt:1};goog.style.CONVERTIBLE_RELATIVE_CSS_UNITS_={em:1,ex:1};goog.style.getFontSize=function(a){var b=goog.style.getStyle_(a,"fontSize"),c=goog.style.getLengthUnits(b);if(b&&"px"==c){return parseInt(b,10)}if(goog.userAgent.IE){if(String(c) in goog.style.ABSOLUTE_CSS_LENGTH_UNITS_){return goog.style.getIePixelValue_(a,b,"left","pixelLeft")}if(a.parentNode&&a.parentNode.nodeType==goog.dom.NodeType.ELEMENT&&String(c) in goog.style.CONVERTIBLE_RELATIVE_CSS_UNITS_){return a=a.parentNode,c=goog.style.getStyle_(a,"fontSize"),goog.style.getIePixelValue_(a,b==c?"1em":b,"left","pixelLeft")}}c=goog.dom.createDom("SPAN",{style:"visibility:hidden;position:absolute;line-height:0;padding:0;margin:0;border:0;height:1em;"});goog.dom.appendChild(a,c);b=c.offsetHeight;goog.dom.removeNode(c);return b};goog.style.parseStyleAttribute=function(a){var b={};goog.array.forEach(a.split(/\s*;\s*/),function(a){var c=a.match(/\s*([\w-]+)\s*:(.+)/);c&&(a=c[1],c=goog.string.trim(c[2]),b[goog.string.toCamelCase(a.toLowerCase())]=c)});return b};goog.style.toStyleAttribute=function(a){var b=[];goog.object.forEach(a,function(a,d){b.push(goog.string.toSelectorCase(d),":",a,";")});return b.join("")};goog.style.setFloat=function(a,b){a.style[goog.userAgent.IE?"styleFloat":"cssFloat"]=b};goog.style.getFloat=function(a){return a.style[goog.userAgent.IE?"styleFloat":"cssFloat"]||""};goog.style.getScrollbarWidth=function(a){var b=goog.dom.createElement("DIV");a&&(b.className=a);b.style.cssText="overflow:auto;position:absolute;top:0;width:100px;height:100px";
-a=goog.dom.createElement("DIV");goog.style.setSize(a,"200px","200px");b.appendChild(a);goog.dom.appendChild(goog.dom.getDocument().body,b);a=b.offsetWidth-b.clientWidth;goog.dom.removeNode(b);return a};goog.style.MATRIX_TRANSLATION_REGEX_=/matrix\([0-9\.\-]+, [0-9\.\-]+, [0-9\.\-]+, [0-9\.\-]+, ([0-9\.\-]+)p?x?, ([0-9\.\-]+)p?x?\)/;goog.style.getCssTranslation=function(a){a=goog.style.getComputedTransform(a);return a?(a=a.match(goog.style.MATRIX_TRANSLATION_REGEX_))?new goog.math.Coordinate(parseFloat(a[1]),parseFloat(a[2])):new goog.math.Coordinate(0,0):new goog.math.Coordinate(0,0)};goog.events.EventHandler=function(a){goog.Disposable.call(this);this.handler_=a;this.keys_={}};goog.inherits(goog.events.EventHandler,goog.Disposable);goog.events.EventHandler.typeArray_=[];goog.events.EventHandler.prototype.listen=function(a,b,c,d){return this.listen_(a,b,c,d)};goog.events.EventHandler.prototype.listenWithScope=function(a,b,c,d,e){return this.listen_(a,b,c,d,e)};goog.events.EventHandler.prototype.listen_=function(a,b,c,d,e){goog.isArray(b)||(b&&(goog.events.EventHandler.typeArray_[0]=b.toString()),b=goog.events.EventHandler.typeArray_);for(var f=0;f<b.length;f++){var g=goog.events.listen(a,b[f],c||this.handleEvent,d||!1,e||this.handler_||this);if(!g){break}this.keys_[g.key]=g}return this};goog.events.EventHandler.prototype.listenOnce=function(a,b,c,d){return this.listenOnce_(a,b,c,d)};goog.events.EventHandler.prototype.listenOnceWithScope=function(a,b,c,d,e){return this.listenOnce_(a,b,c,d,e)};goog.events.EventHandler.prototype.listenOnce_=function(a,b,c,d,e){if(goog.isArray(b)){for(var f=0;f<b.length;f++){this.listenOnce_(a,b[f],c,d,e)}}else{a=goog.events.listenOnce(a,b,c||this.handleEvent,d,e||this.handler_||this);if(!a){return this}this.keys_[a.key]=a}return this};goog.events.EventHandler.prototype.listenWithWrapper=function(a,b,c,d){return this.listenWithWrapper_(a,b,c,d)};goog.events.EventHandler.prototype.listenWithWrapperAndScope=function(a,b,c,d,e){return this.listenWithWrapper_(a,b,c,d,e)
-};goog.events.EventHandler.prototype.listenWithWrapper_=function(a,b,c,d,e){b.listen(a,c,d,e||this.handler_||this,this);return this};goog.events.EventHandler.prototype.getListenerCount=function(){var a=0,b;for(b in this.keys_){Object.prototype.hasOwnProperty.call(this.keys_,b)&&a++}return a};goog.events.EventHandler.prototype.unlisten=function(a,b,c,d,e){if(goog.isArray(b)){for(var f=0;f<b.length;f++){this.unlisten(a,b[f],c,d,e)}}else{if(d=goog.isObject(d)?!!d.capture:!!d,a=goog.events.getListener(a,b,c||this.handleEvent,d,e||this.handler_||this)){goog.events.unlistenByKey(a),delete this.keys_[a.key]}}return this};goog.events.EventHandler.prototype.unlistenWithWrapper=function(a,b,c,d,e){b.unlisten(a,c,d,e||this.handler_||this,this);return this};goog.events.EventHandler.prototype.removeAll=function(){goog.object.forEach(this.keys_,function(a,b){this.keys_.hasOwnProperty(b)&&goog.events.unlistenByKey(a)},this);this.keys_={}};goog.events.EventHandler.prototype.disposeInternal=function(){goog.events.EventHandler.superClass_.disposeInternal.call(this);this.removeAll()};goog.events.EventHandler.prototype.handleEvent=function(a){throw Error("EventHandler.handleEvent not implemented")};goog.ui={};goog.ui.IdGenerator=function(){};goog.addSingletonGetter(goog.ui.IdGenerator);goog.ui.IdGenerator.prototype.nextId_=0;goog.ui.IdGenerator.prototype.getNextUniqueId=function(){return":"+(this.nextId_++).toString(36)};goog.ui.Component=function(a){goog.events.EventTarget.call(this);this.dom_=a||goog.dom.getDomHelper();this.rightToLeft_=goog.ui.Component.defaultRightToLeft_;this.id_=null;this.inDocument_=!1;this.element_=null;this.googUiComponentHandler_=void 0;this.childIndex_=this.children_=this.parent_=this.model_=null;this.wasDecorated_=!1};goog.inherits(goog.ui.Component,goog.events.EventTarget);goog.ui.Component.ALLOW_DETACHED_DECORATION=!1;goog.ui.Component.prototype.idGenerator_=goog.ui.IdGenerator.getInstance();goog.ui.Component.DEFAULT_BIDI_DIR=0;goog.ui.Component.defaultRightToLeft_=1==goog.ui.Component.DEFAULT_BIDI_DIR?!1:-1==goog.ui.Component.DEFAULT_BIDI_DIR?!0:null;
-goog.ui.Component.EventType={BEFORE_SHOW:"beforeshow",SHOW:"show",HIDE:"hide",DISABLE:"disable",ENABLE:"enable",HIGHLIGHT:"highlight",UNHIGHLIGHT:"unhighlight",ACTIVATE:"activate",DEACTIVATE:"deactivate",SELECT:"select",UNSELECT:"unselect",CHECK:"check",UNCHECK:"uncheck",FOCUS:"focus",BLUR:"blur",OPEN:"open",CLOSE:"close",ENTER:"enter",LEAVE:"leave",ACTION:"action",CHANGE:"change"};goog.ui.Component.Error={NOT_SUPPORTED:"Method not supported",DECORATE_INVALID:"Invalid element to decorate",ALREADY_RENDERED:"Component already rendered",PARENT_UNABLE_TO_BE_SET:"Unable to set parent component",CHILD_INDEX_OUT_OF_BOUNDS:"Child component index out of bounds",NOT_OUR_CHILD:"Child is not in parent component",NOT_IN_DOCUMENT:"Operation not supported while component is not in document",STATE_INVALID:"Invalid component state"};goog.ui.Component.State={ALL:255,DISABLED:1,HOVER:2,ACTIVE:4,SELECTED:8,CHECKED:16,FOCUSED:32,OPENED:64};goog.ui.Component.getStateTransitionEvent=function(a,b){switch(a){case goog.ui.Component.State.DISABLED:return b?goog.ui.Component.EventType.DISABLE:goog.ui.Component.EventType.ENABLE;case goog.ui.Component.State.HOVER:return b?goog.ui.Component.EventType.HIGHLIGHT:goog.ui.Component.EventType.UNHIGHLIGHT;case goog.ui.Component.State.ACTIVE:return b?goog.ui.Component.EventType.ACTIVATE:goog.ui.Component.EventType.DEACTIVATE;case goog.ui.Component.State.SELECTED:return b?goog.ui.Component.EventType.SELECT:goog.ui.Component.EventType.UNSELECT;case goog.ui.Component.State.CHECKED:return b?goog.ui.Component.EventType.CHECK:goog.ui.Component.EventType.UNCHECK;case goog.ui.Component.State.FOCUSED:return b?goog.ui.Component.EventType.FOCUS:goog.ui.Component.EventType.BLUR;case goog.ui.Component.State.OPENED:return b?goog.ui.Component.EventType.OPEN:goog.ui.Component.EventType.CLOSE}throw Error(goog.ui.Component.Error.STATE_INVALID)};goog.ui.Component.setDefaultRightToLeft=function(a){goog.ui.Component.defaultRightToLeft_=a};goog.ui.Component.prototype.getId=function(){return this.id_||(this.id_=this.idGenerator_.getNextUniqueId())
-};goog.ui.Component.prototype.setId=function(a){this.parent_&&this.parent_.childIndex_&&(goog.object.remove(this.parent_.childIndex_,this.id_),goog.object.add(this.parent_.childIndex_,a,this));this.id_=a};goog.ui.Component.prototype.getElement=function(){return this.element_};goog.ui.Component.prototype.getElementStrict=function(){var a=this.element_;goog.asserts.assert(a,"Can not call getElementStrict before rendering/decorating.");return a};goog.ui.Component.prototype.setElementInternal=function(a){this.element_=a};goog.ui.Component.prototype.getElementsByClass=function(a){return this.element_?this.dom_.getElementsByClass(a,this.element_):[]};goog.ui.Component.prototype.getElementByClass=function(a){return this.element_?this.dom_.getElementByClass(a,this.element_):null};goog.ui.Component.prototype.getRequiredElementByClass=function(a){var b=this.getElementByClass(a);goog.asserts.assert(b,"Expected element in component with class: %s",a);return b};goog.ui.Component.prototype.getHandler=function(){this.googUiComponentHandler_||(this.googUiComponentHandler_=new goog.events.EventHandler(this));return this.googUiComponentHandler_};goog.ui.Component.prototype.setParent=function(a){if(this==a){throw Error(goog.ui.Component.Error.PARENT_UNABLE_TO_BE_SET)}if(a&&this.parent_&&this.id_&&this.parent_.getChild(this.id_)&&this.parent_!=a){throw Error(goog.ui.Component.Error.PARENT_UNABLE_TO_BE_SET)}this.parent_=a;goog.ui.Component.superClass_.setParentEventTarget.call(this,a)};goog.ui.Component.prototype.getParent=function(){return this.parent_};goog.ui.Component.prototype.setParentEventTarget=function(a){if(this.parent_&&this.parent_!=a){throw Error(goog.ui.Component.Error.NOT_SUPPORTED)}goog.ui.Component.superClass_.setParentEventTarget.call(this,a)};goog.ui.Component.prototype.getDomHelper=function(){return this.dom_};goog.ui.Component.prototype.isInDocument=function(){return this.inDocument_};goog.ui.Component.prototype.createDom=function(){this.element_=this.dom_.createElement("DIV")
-};goog.ui.Component.prototype.render=function(a){this.render_(a)};goog.ui.Component.prototype.renderBefore=function(a){this.render_(a.parentNode,a)};goog.ui.Component.prototype.render_=function(a,b){if(this.inDocument_){throw Error(goog.ui.Component.Error.ALREADY_RENDERED)}this.element_||this.createDom();a?a.insertBefore(this.element_,b||null):this.dom_.getDocument().body.appendChild(this.element_);this.parent_&&!this.parent_.isInDocument()||this.enterDocument()};goog.ui.Component.prototype.decorate=function(a){if(this.inDocument_){throw Error(goog.ui.Component.Error.ALREADY_RENDERED)}if(a&&this.canDecorate(a)){this.wasDecorated_=!0;var b=goog.dom.getOwnerDocument(a);this.dom_&&this.dom_.getDocument()==b||(this.dom_=goog.dom.getDomHelper(a));this.decorateInternal(a);goog.ui.Component.ALLOW_DETACHED_DECORATION&&!goog.dom.contains(b,a)||this.enterDocument()}else{throw Error(goog.ui.Component.Error.DECORATE_INVALID)}};goog.ui.Component.prototype.canDecorate=function(a){return !0};goog.ui.Component.prototype.wasDecorated=function(){return this.wasDecorated_};goog.ui.Component.prototype.decorateInternal=function(a){this.element_=a};goog.ui.Component.prototype.enterDocument=function(){this.inDocument_=!0;this.forEachChild(function(a){!a.isInDocument()&&a.getElement()&&a.enterDocument()})};goog.ui.Component.prototype.exitDocument=function(){this.forEachChild(function(a){a.isInDocument()&&a.exitDocument()});this.googUiComponentHandler_&&this.googUiComponentHandler_.removeAll();this.inDocument_=!1};goog.ui.Component.prototype.disposeInternal=function(){this.inDocument_&&this.exitDocument();this.googUiComponentHandler_&&(this.googUiComponentHandler_.dispose(),delete this.googUiComponentHandler_);this.forEachChild(function(a){a.dispose()});!this.wasDecorated_&&this.element_&&goog.dom.removeNode(this.element_);this.parent_=this.model_=this.element_=this.childIndex_=this.children_=null;goog.ui.Component.superClass_.disposeInternal.call(this)};goog.ui.Component.prototype.makeId=function(a){return this.getId()+"."+a
-};goog.ui.Component.prototype.makeIds=function(a){var b={},c;for(c in a){b[c]=this.makeId(a[c])}return b};goog.ui.Component.prototype.getModel=function(){return this.model_};goog.ui.Component.prototype.setModel=function(a){this.model_=a};goog.ui.Component.prototype.getFragmentFromId=function(a){return a.substring(this.getId().length+1)};goog.ui.Component.prototype.getElementByFragment=function(a){if(!this.inDocument_){throw Error(goog.ui.Component.Error.NOT_IN_DOCUMENT)}return this.dom_.getElement(this.makeId(a))};goog.ui.Component.prototype.addChild=function(a,b){this.addChildAt(a,this.getChildCount(),b)};goog.ui.Component.prototype.addChildAt=function(a,b,c){goog.asserts.assert(!!a,"Provided element must not be null.");if(a.inDocument_&&(c||!this.inDocument_)){throw Error(goog.ui.Component.Error.ALREADY_RENDERED)}if(0>b||b>this.getChildCount()){throw Error(goog.ui.Component.Error.CHILD_INDEX_OUT_OF_BOUNDS)}this.childIndex_&&this.children_||(this.childIndex_={},this.children_=[]);a.getParent()==this?(goog.object.set(this.childIndex_,a.getId(),a),goog.array.remove(this.children_,a)):goog.object.add(this.childIndex_,a.getId(),a);a.setParent(this);goog.array.insertAt(this.children_,a,b);a.inDocument_&&this.inDocument_&&a.getParent()==this?(c=this.getContentElement(),b=c.childNodes[b]||null,b!=a.getElement()&&c.insertBefore(a.getElement(),b)):c?(this.element_||this.createDom(),b=this.getChildAt(b+1),a.render_(this.getContentElement(),b?b.element_:null)):this.inDocument_&&!a.inDocument_&&a.element_&&a.element_.parentNode&&a.element_.parentNode.nodeType==goog.dom.NodeType.ELEMENT&&a.enterDocument()};goog.ui.Component.prototype.getContentElement=function(){return this.element_};goog.ui.Component.prototype.isRightToLeft=function(){null==this.rightToLeft_&&(this.rightToLeft_=goog.style.isRightToLeft(this.inDocument_?this.element_:this.dom_.getDocument().body));return this.rightToLeft_};goog.ui.Component.prototype.setRightToLeft=function(a){if(this.inDocument_){throw Error(goog.ui.Component.Error.ALREADY_RENDERED)
-}this.rightToLeft_=a};goog.ui.Component.prototype.hasChildren=function(){return !!this.children_&&0!=this.children_.length};goog.ui.Component.prototype.getChildCount=function(){return this.children_?this.children_.length:0};goog.ui.Component.prototype.getChildIds=function(){var a=[];this.forEachChild(function(b){a.push(b.getId())});return a};goog.ui.Component.prototype.getChild=function(a){return this.childIndex_&&a?goog.object.get(this.childIndex_,a)||null:null};goog.ui.Component.prototype.getChildAt=function(a){return this.children_?this.children_[a]||null:null};goog.ui.Component.prototype.forEachChild=function(a,b){this.children_&&goog.array.forEach(this.children_,a,b)};goog.ui.Component.prototype.indexOfChild=function(a){return this.children_&&a?goog.array.indexOf(this.children_,a):-1};goog.ui.Component.prototype.removeChild=function(a,b){if(a){var c=goog.isString(a)?a:a.getId();a=this.getChild(c);c&&a&&(goog.object.remove(this.childIndex_,c),goog.array.remove(this.children_,a),b&&(a.exitDocument(),a.element_&&goog.dom.removeNode(a.element_)),a.setParent(null))}if(!a){throw Error(goog.ui.Component.Error.NOT_OUR_CHILD)}return a};goog.ui.Component.prototype.removeChildAt=function(a,b){return this.removeChild(this.getChildAt(a),b)};goog.ui.Component.prototype.removeChildren=function(a){for(var b=[];this.hasChildren();){b.push(this.removeChildAt(0,a))}return b};goog.a11y={};goog.a11y.aria={};goog.a11y.aria.Role={ALERT:"alert",ALERTDIALOG:"alertdialog",APPLICATION:"application",ARTICLE:"article",BANNER:"banner",BUTTON:"button",CHECKBOX:"checkbox",COLUMNHEADER:"columnheader",COMBOBOX:"combobox",COMPLEMENTARY:"complementary",CONTENTINFO:"contentinfo",DEFINITION:"definition",DIALOG:"dialog",DIRECTORY:"directory",DOCUMENT:"document",FORM:"form",GRID:"grid",GRIDCELL:"gridcell",GROUP:"group",HEADING:"heading",IMG:"img",LINK:"link",LIST:"list",LISTBOX:"listbox",LISTITEM:"listitem",LOG:"log",MAIN:"main",MARQUEE:"marquee",MATH:"math",MENU:"menu",MENUBAR:"menubar",MENU_ITEM:"menuitem",MENU_ITEM_CHECKBOX:"menuitemcheckbox",MENU_ITEM_RADIO:"menuitemradio",NAVIGATION:"navigation",NOTE:"note",OPTION:"option",PRESENTATION:"presentation",PROGRESSBAR:"progressbar",RADIO:"radio",RADIOGROUP:"radiogroup",REGION:"region",ROW:"row",ROWGROUP:"rowgroup",ROWHEADER:"rowheader",SCROLLBAR:"scrollbar",SEARCH:"search",SEPARATOR:"separator",SLIDER:"slider",SPINBUTTON:"spinbutton",STATUS:"status",TAB:"tab",TAB_LIST:"tablist",TAB_PANEL:"tabpanel",TEXTBOX:"textbox",TEXTINFO:"textinfo",TIMER:"timer",TOOLBAR:"toolbar",TOOLTIP:"tooltip",TREE:"tree",TREEGRID:"treegrid",TREEITEM:"treeitem"};
-goog.a11y.aria.State={ACTIVEDESCENDANT:"activedescendant",ATOMIC:"atomic",AUTOCOMPLETE:"autocomplete",BUSY:"busy",CHECKED:"checked",COLINDEX:"colindex",CONTROLS:"controls",DESCRIBEDBY:"describedby",DISABLED:"disabled",DROPEFFECT:"dropeffect",EXPANDED:"expanded",FLOWTO:"flowto",GRABBED:"grabbed",HASPOPUP:"haspopup",HIDDEN:"hidden",INVALID:"invalid",LABEL:"label",LABELLEDBY:"labelledby",LEVEL:"level",LIVE:"live",MULTILINE:"multiline",MULTISELECTABLE:"multiselectable",ORIENTATION:"orientation",OWNS:"owns",POSINSET:"posinset",PRESSED:"pressed",READONLY:"readonly",RELEVANT:"relevant",REQUIRED:"required",ROWINDEX:"rowindex",SELECTED:"selected",SETSIZE:"setsize",SORT:"sort",VALUEMAX:"valuemax",VALUEMIN:"valuemin",VALUENOW:"valuenow",VALUETEXT:"valuetext"};goog.a11y.aria.AutoCompleteValues={INLINE:"inline",LIST:"list",BOTH:"both",NONE:"none"};goog.a11y.aria.DropEffectValues={COPY:"copy",MOVE:"move",LINK:"link",EXECUTE:"execute",POPUP:"popup",NONE:"none"};goog.a11y.aria.LivePriority={OFF:"off",POLITE:"polite",ASSERTIVE:"assertive"};goog.a11y.aria.OrientationValues={VERTICAL:"vertical",HORIZONTAL:"horizontal"};goog.a11y.aria.RelevantValues={ADDITIONS:"additions",REMOVALS:"removals",TEXT:"text",ALL:"all"};goog.a11y.aria.SortValues={ASCENDING:"ascending",DESCENDING:"descending",NONE:"none",OTHER:"other"};goog.a11y.aria.CheckedValues={TRUE:"true",FALSE:"false",MIXED:"mixed",UNDEFINED:"undefined"};goog.a11y.aria.ExpandedValues={TRUE:"true",FALSE:"false",UNDEFINED:"undefined"};goog.a11y.aria.GrabbedValues={TRUE:"true",FALSE:"false",UNDEFINED:"undefined"};goog.a11y.aria.InvalidValues={FALSE:"false",TRUE:"true",GRAMMAR:"grammar",SPELLING:"spelling"};goog.a11y.aria.PressedValues={TRUE:"true",FALSE:"false",MIXED:"mixed",UNDEFINED:"undefined"};goog.a11y.aria.SelectedValues={TRUE:"true",FALSE:"false",UNDEFINED:"undefined"};goog.a11y.aria.datatables={};goog.a11y.aria.datatables.getDefaultValuesMap=function(){goog.a11y.aria.DefaultStateValueMap_||(goog.a11y.aria.DefaultStateValueMap_=goog.object.create(goog.a11y.aria.State.ATOMIC,!1,goog.a11y.aria.State.AUTOCOMPLETE,"none",goog.a11y.aria.State.DROPEFFECT,"none",goog.a11y.aria.State.HASPOPUP,!1,goog.a11y.aria.State.LIVE,"off",goog.a11y.aria.State.MULTILINE,!1,goog.a11y.aria.State.MULTISELECTABLE,!1,goog.a11y.aria.State.ORIENTATION,"vertical",goog.a11y.aria.State.READONLY,!1,goog.a11y.aria.State.RELEVANT,"additions text",goog.a11y.aria.State.REQUIRED,!1,goog.a11y.aria.State.SORT,"none",goog.a11y.aria.State.BUSY,!1,goog.a11y.aria.State.DISABLED,!1,goog.a11y.aria.State.HIDDEN,!1,goog.a11y.aria.State.INVALID,"false"));
-return goog.a11y.aria.DefaultStateValueMap_};goog.a11y.aria.ARIA_PREFIX_="aria-";goog.a11y.aria.ROLE_ATTRIBUTE_="role";goog.a11y.aria.TAGS_WITH_ASSUMED_ROLES_=goog.object.createSet("A AREA BUTTON HEAD INPUT LINK MENU META OPTGROUP OPTION PROGRESS STYLE SELECT SOURCE TEXTAREA TITLE TRACK".split(" "));goog.a11y.aria.CONTAINER_ROLES_=[goog.a11y.aria.Role.COMBOBOX,goog.a11y.aria.Role.GRID,goog.a11y.aria.Role.GROUP,goog.a11y.aria.Role.LISTBOX,goog.a11y.aria.Role.MENU,goog.a11y.aria.Role.MENUBAR,goog.a11y.aria.Role.RADIOGROUP,goog.a11y.aria.Role.ROW,goog.a11y.aria.Role.ROWGROUP,goog.a11y.aria.Role.TAB_LIST,goog.a11y.aria.Role.TEXTBOX,goog.a11y.aria.Role.TOOLBAR,goog.a11y.aria.Role.TREE,goog.a11y.aria.Role.TREEGRID];goog.a11y.aria.setRole=function(a,b){b?(goog.asserts.ENABLE_ASSERTS&&goog.asserts.assert(goog.object.containsValue(goog.a11y.aria.Role,b),"No such ARIA role "+b),a.setAttribute(goog.a11y.aria.ROLE_ATTRIBUTE_,b)):goog.a11y.aria.removeRole(a)};goog.a11y.aria.getRole=function(a){return a.getAttribute(goog.a11y.aria.ROLE_ATTRIBUTE_)||null};goog.a11y.aria.removeRole=function(a){a.removeAttribute(goog.a11y.aria.ROLE_ATTRIBUTE_)};goog.a11y.aria.setState=function(a,b,c){goog.isArray(c)&&(c=c.join(" "));var d=goog.a11y.aria.getAriaAttributeName_(b);""===c||void 0==c?(c=goog.a11y.aria.datatables.getDefaultValuesMap(),b in c?a.setAttribute(d,c[b]):a.removeAttribute(d)):a.setAttribute(d,c)};goog.a11y.aria.toggleState=function(a,b){var c=goog.a11y.aria.getState(a,b);goog.string.isEmptyOrWhitespace(goog.string.makeSafe(c))||"true"==c||"false"==c?goog.a11y.aria.setState(a,b,"true"==c?"false":"true"):goog.a11y.aria.removeState(a,b)};goog.a11y.aria.removeState=function(a,b){a.removeAttribute(goog.a11y.aria.getAriaAttributeName_(b))};goog.a11y.aria.getState=function(a,b){var c=a.getAttribute(goog.a11y.aria.getAriaAttributeName_(b));return null==c||void 0==c?"":String(c)};goog.a11y.aria.getActiveDescendant=function(a){var b=goog.a11y.aria.getState(a,goog.a11y.aria.State.ACTIVEDESCENDANT);
-return goog.dom.getOwnerDocument(a).getElementById(b)};goog.a11y.aria.setActiveDescendant=function(a,b){var c="";b&&(c=b.id,goog.asserts.assert(c,"The active element should have an id."));goog.a11y.aria.setState(a,goog.a11y.aria.State.ACTIVEDESCENDANT,c)};goog.a11y.aria.getLabel=function(a){return goog.a11y.aria.getState(a,goog.a11y.aria.State.LABEL)};goog.a11y.aria.setLabel=function(a,b){goog.a11y.aria.setState(a,goog.a11y.aria.State.LABEL,b)};goog.a11y.aria.assertRoleIsSetInternalUtil=function(a,b){if(!goog.a11y.aria.TAGS_WITH_ASSUMED_ROLES_[a.tagName]){var c=goog.a11y.aria.getRole(a);goog.asserts.assert(null!=c,"The element ARIA role cannot be null.");goog.asserts.assert(goog.array.contains(b,c),'Non existing or incorrect role set for element.The role set is "'+c+'". The role should be any of "'+b+'". Check the ARIA specification for more details http://www.w3.org/TR/wai-aria/roles.')}};goog.a11y.aria.getStateBoolean=function(a,b){var c=a.getAttribute(goog.a11y.aria.getAriaAttributeName_(b));goog.asserts.assert(goog.isBoolean(c)||null==c||"true"==c||"false"==c);return null==c?c:goog.isBoolean(c)?c:"true"==c};goog.a11y.aria.getStateNumber=function(a,b){var c=a.getAttribute(goog.a11y.aria.getAriaAttributeName_(b));goog.asserts.assert((null==c||!isNaN(Number(c)))&&!goog.isBoolean(c));return null==c?null:Number(c)};goog.a11y.aria.getStateString=function(a,b){var c=a.getAttribute(goog.a11y.aria.getAriaAttributeName_(b));goog.asserts.assert((null==c||goog.isString(c))&&(""==c||isNaN(Number(c)))&&"true"!=c&&"false"!=c);return null==c||""==c?null:c};goog.a11y.aria.getStringArrayStateInternalUtil=function(a,b){var c=a.getAttribute(goog.a11y.aria.getAriaAttributeName_(b));return goog.a11y.aria.splitStringOnWhitespace_(c)};goog.a11y.aria.hasState=function(a,b){return a.hasAttribute(goog.a11y.aria.getAriaAttributeName_(b))};goog.a11y.aria.isContainerRole=function(a){a=goog.a11y.aria.getRole(a);return goog.array.contains(goog.a11y.aria.CONTAINER_ROLES_,a)};goog.a11y.aria.splitStringOnWhitespace_=function(a){return a?a.split(/\s+/):[]
-};goog.a11y.aria.getAriaAttributeName_=function(a){goog.asserts.ENABLE_ASSERTS&&(goog.asserts.assert(a,"ARIA attribute cannot be empty."),goog.asserts.assert(goog.object.containsValue(goog.a11y.aria.State,a),"No such ARIA attribute "+a));return goog.a11y.aria.ARIA_PREFIX_+a};goog.events.KeyCodes={WIN_KEY_FF_LINUX:0,MAC_ENTER:3,BACKSPACE:8,TAB:9,NUM_CENTER:12,ENTER:13,SHIFT:16,CTRL:17,ALT:18,PAUSE:19,CAPS_LOCK:20,ESC:27,SPACE:32,PAGE_UP:33,PAGE_DOWN:34,END:35,HOME:36,LEFT:37,UP:38,RIGHT:39,DOWN:40,PLUS_SIGN:43,PRINT_SCREEN:44,INSERT:45,DELETE:46,ZERO:48,ONE:49,TWO:50,THREE:51,FOUR:52,FIVE:53,SIX:54,SEVEN:55,EIGHT:56,NINE:57,FF_SEMICOLON:59,FF_EQUALS:61,FF_DASH:173,QUESTION_MARK:63,AT_SIGN:64,A:65,B:66,C:67,D:68,E:69,F:70,G:71,H:72,I:73,J:74,K:75,L:76,M:77,N:78,O:79,P:80,Q:81,R:82,S:83,T:84,U:85,V:86,W:87,X:88,Y:89,Z:90,META:91,WIN_KEY_RIGHT:92,CONTEXT_MENU:93,NUM_ZERO:96,NUM_ONE:97,NUM_TWO:98,NUM_THREE:99,NUM_FOUR:100,NUM_FIVE:101,NUM_SIX:102,NUM_SEVEN:103,NUM_EIGHT:104,NUM_NINE:105,NUM_MULTIPLY:106,NUM_PLUS:107,NUM_MINUS:109,NUM_PERIOD:110,NUM_DIVISION:111,F1:112,F2:113,F3:114,F4:115,F5:116,F6:117,F7:118,F8:119,F9:120,F10:121,F11:122,F12:123,NUMLOCK:144,SCROLL_LOCK:145,FIRST_MEDIA_KEY:166,LAST_MEDIA_KEY:183,SEMICOLON:186,DASH:189,EQUALS:187,COMMA:188,PERIOD:190,SLASH:191,APOSTROPHE:192,TILDE:192,SINGLE_QUOTE:222,OPEN_SQUARE_BRACKET:219,BACKSLASH:220,CLOSE_SQUARE_BRACKET:221,WIN_KEY:224,MAC_FF_META:224,MAC_WK_CMD_LEFT:91,MAC_WK_CMD_RIGHT:93,WIN_IME:229,VK_NONAME:252,PHANTOM:255};goog.events.KeyCodes.isTextModifyingKeyEvent=function(a){if(a.altKey&&!a.ctrlKey||a.metaKey||a.keyCode>=goog.events.KeyCodes.F1&&a.keyCode<=goog.events.KeyCodes.F12){return !1}switch(a.keyCode){case goog.events.KeyCodes.ALT:case goog.events.KeyCodes.CAPS_LOCK:case goog.events.KeyCodes.CONTEXT_MENU:case goog.events.KeyCodes.CTRL:case goog.events.KeyCodes.DOWN:case goog.events.KeyCodes.END:case goog.events.KeyCodes.ESC:case goog.events.KeyCodes.HOME:case goog.events.KeyCodes.INSERT:case goog.events.KeyCodes.LEFT:case goog.events.KeyCodes.MAC_FF_META:case goog.events.KeyCodes.META:case goog.events.KeyCodes.NUMLOCK:case goog.events.KeyCodes.NUM_CENTER:case goog.events.KeyCodes.PAGE_DOWN:case goog.events.KeyCodes.PAGE_UP:case goog.events.KeyCodes.PAUSE:case goog.events.KeyCodes.PHANTOM:case goog.events.KeyCodes.PRINT_SCREEN:case goog.events.KeyCodes.RIGHT:case goog.events.KeyCodes.SCROLL_LOCK:case goog.events.KeyCodes.SHIFT:case goog.events.KeyCodes.UP:case goog.events.KeyCodes.VK_NONAME:case goog.events.KeyCodes.WIN_KEY:case goog.events.KeyCodes.WIN_KEY_RIGHT:return !1;
-case goog.events.KeyCodes.WIN_KEY_FF_LINUX:return !goog.userAgent.GECKO;default:return a.keyCode<goog.events.KeyCodes.FIRST_MEDIA_KEY||a.keyCode>goog.events.KeyCodes.LAST_MEDIA_KEY}};goog.events.KeyCodes.firesKeyPressEvent=function(a,b,c,d,e,f){if(!(goog.userAgent.IE||goog.userAgent.EDGE||goog.userAgent.WEBKIT&&goog.userAgent.isVersionOrHigher("525"))){return !0}if(goog.userAgent.MAC&&e){return goog.events.KeyCodes.isCharacterKey(a)}if(e&&!d){return !1}goog.isNumber(b)&&(b=goog.events.KeyCodes.normalizeKeyCode(b));e=b==goog.events.KeyCodes.CTRL||b==goog.events.KeyCodes.ALT||goog.userAgent.MAC&&b==goog.events.KeyCodes.META;f=b==goog.events.KeyCodes.SHIFT&&(d||f);if((!c||goog.userAgent.MAC)&&e||goog.userAgent.MAC&&f){return !1}if((goog.userAgent.WEBKIT||goog.userAgent.EDGE)&&d&&c){switch(a){case goog.events.KeyCodes.BACKSLASH:case goog.events.KeyCodes.OPEN_SQUARE_BRACKET:case goog.events.KeyCodes.CLOSE_SQUARE_BRACKET:case goog.events.KeyCodes.TILDE:case goog.events.KeyCodes.SEMICOLON:case goog.events.KeyCodes.DASH:case goog.events.KeyCodes.EQUALS:case goog.events.KeyCodes.COMMA:case goog.events.KeyCodes.PERIOD:case goog.events.KeyCodes.SLASH:case goog.events.KeyCodes.APOSTROPHE:case goog.events.KeyCodes.SINGLE_QUOTE:return !1}}if(goog.userAgent.IE&&d&&b==a){return !1}switch(a){case goog.events.KeyCodes.ENTER:return !0;case goog.events.KeyCodes.ESC:return !(goog.userAgent.WEBKIT||goog.userAgent.EDGE)}return goog.events.KeyCodes.isCharacterKey(a)};goog.events.KeyCodes.isCharacterKey=function(a){if(a>=goog.events.KeyCodes.ZERO&&a<=goog.events.KeyCodes.NINE||a>=goog.events.KeyCodes.NUM_ZERO&&a<=goog.events.KeyCodes.NUM_MULTIPLY||a>=goog.events.KeyCodes.A&&a<=goog.events.KeyCodes.Z||(goog.userAgent.WEBKIT||goog.userAgent.EDGE)&&0==a){return !0}switch(a){case goog.events.KeyCodes.SPACE:case goog.events.KeyCodes.PLUS_SIGN:case goog.events.KeyCodes.QUESTION_MARK:case goog.events.KeyCodes.AT_SIGN:case goog.events.KeyCodes.NUM_PLUS:case goog.events.KeyCodes.NUM_MINUS:case goog.events.KeyCodes.NUM_PERIOD:case goog.events.KeyCodes.NUM_DIVISION:case goog.events.KeyCodes.SEMICOLON:case goog.events.KeyCodes.FF_SEMICOLON:case goog.events.KeyCodes.DASH:case goog.events.KeyCodes.EQUALS:case goog.events.KeyCodes.FF_EQUALS:case goog.events.KeyCodes.COMMA:case goog.events.KeyCodes.PERIOD:case goog.events.KeyCodes.SLASH:case goog.events.KeyCodes.APOSTROPHE:case goog.events.KeyCodes.SINGLE_QUOTE:case goog.events.KeyCodes.OPEN_SQUARE_BRACKET:case goog.events.KeyCodes.BACKSLASH:case goog.events.KeyCodes.CLOSE_SQUARE_BRACKET:return !0;
-default:return !1}};goog.events.KeyCodes.normalizeKeyCode=function(a){return goog.userAgent.GECKO?goog.events.KeyCodes.normalizeGeckoKeyCode(a):goog.userAgent.MAC&&goog.userAgent.WEBKIT?goog.events.KeyCodes.normalizeMacWebKitKeyCode(a):a};goog.events.KeyCodes.normalizeGeckoKeyCode=function(a){switch(a){case goog.events.KeyCodes.FF_EQUALS:return goog.events.KeyCodes.EQUALS;case goog.events.KeyCodes.FF_SEMICOLON:return goog.events.KeyCodes.SEMICOLON;case goog.events.KeyCodes.FF_DASH:return goog.events.KeyCodes.DASH;case goog.events.KeyCodes.MAC_FF_META:return goog.events.KeyCodes.META;case goog.events.KeyCodes.WIN_KEY_FF_LINUX:return goog.events.KeyCodes.WIN_KEY;default:return a}};goog.events.KeyCodes.normalizeMacWebKitKeyCode=function(a){switch(a){case goog.events.KeyCodes.MAC_WK_CMD_RIGHT:return goog.events.KeyCodes.META;default:return a}};goog.events.KeyHandler=function(a,b){goog.events.EventTarget.call(this);a&&this.attach(a,b)};goog.inherits(goog.events.KeyHandler,goog.events.EventTarget);goog.events.KeyHandler.prototype.element_=null;goog.events.KeyHandler.prototype.keyPressKey_=null;goog.events.KeyHandler.prototype.keyDownKey_=null;goog.events.KeyHandler.prototype.keyUpKey_=null;goog.events.KeyHandler.prototype.lastKey_=-1;goog.events.KeyHandler.prototype.keyCode_=-1;goog.events.KeyHandler.prototype.altKey_=!1;goog.events.KeyHandler.EventType={KEY:"key"};goog.events.KeyHandler.safariKey_={3:goog.events.KeyCodes.ENTER,12:goog.events.KeyCodes.NUMLOCK,63232:goog.events.KeyCodes.UP,63233:goog.events.KeyCodes.DOWN,63234:goog.events.KeyCodes.LEFT,63235:goog.events.KeyCodes.RIGHT,63236:goog.events.KeyCodes.F1,63237:goog.events.KeyCodes.F2,63238:goog.events.KeyCodes.F3,63239:goog.events.KeyCodes.F4,63240:goog.events.KeyCodes.F5,63241:goog.events.KeyCodes.F6,63242:goog.events.KeyCodes.F7,63243:goog.events.KeyCodes.F8,63244:goog.events.KeyCodes.F9,63245:goog.events.KeyCodes.F10,63246:goog.events.KeyCodes.F11,63247:goog.events.KeyCodes.F12,63248:goog.events.KeyCodes.PRINT_SCREEN,63272:goog.events.KeyCodes.DELETE,63273:goog.events.KeyCodes.HOME,63275:goog.events.KeyCodes.END,63276:goog.events.KeyCodes.PAGE_UP,63277:goog.events.KeyCodes.PAGE_DOWN,63289:goog.events.KeyCodes.NUMLOCK,63302:goog.events.KeyCodes.INSERT};
-goog.events.KeyHandler.keyIdentifier_={Up:goog.events.KeyCodes.UP,Down:goog.events.KeyCodes.DOWN,Left:goog.events.KeyCodes.LEFT,Right:goog.events.KeyCodes.RIGHT,Enter:goog.events.KeyCodes.ENTER,F1:goog.events.KeyCodes.F1,F2:goog.events.KeyCodes.F2,F3:goog.events.KeyCodes.F3,F4:goog.events.KeyCodes.F4,F5:goog.events.KeyCodes.F5,F6:goog.events.KeyCodes.F6,F7:goog.events.KeyCodes.F7,F8:goog.events.KeyCodes.F8,F9:goog.events.KeyCodes.F9,F10:goog.events.KeyCodes.F10,F11:goog.events.KeyCodes.F11,F12:goog.events.KeyCodes.F12,"U+007F":goog.events.KeyCodes.DELETE,Home:goog.events.KeyCodes.HOME,End:goog.events.KeyCodes.END,PageUp:goog.events.KeyCodes.PAGE_UP,PageDown:goog.events.KeyCodes.PAGE_DOWN,Insert:goog.events.KeyCodes.INSERT};goog.events.KeyHandler.USES_KEYDOWN_=goog.userAgent.IE||goog.userAgent.EDGE||goog.userAgent.WEBKIT&&goog.userAgent.isVersionOrHigher("525");goog.events.KeyHandler.SAVE_ALT_FOR_KEYPRESS_=goog.userAgent.MAC&&goog.userAgent.GECKO;goog.events.KeyHandler.prototype.handleKeyDown_=function(a){(goog.userAgent.WEBKIT||goog.userAgent.EDGE)&&(this.lastKey_==goog.events.KeyCodes.CTRL&&!a.ctrlKey||this.lastKey_==goog.events.KeyCodes.ALT&&!a.altKey||goog.userAgent.MAC&&this.lastKey_==goog.events.KeyCodes.META&&!a.metaKey)&&this.resetState();-1==this.lastKey_&&(a.ctrlKey&&a.keyCode!=goog.events.KeyCodes.CTRL?this.lastKey_=goog.events.KeyCodes.CTRL:a.altKey&&a.keyCode!=goog.events.KeyCodes.ALT?this.lastKey_=goog.events.KeyCodes.ALT:a.metaKey&&a.keyCode!=goog.events.KeyCodes.META&&(this.lastKey_=goog.events.KeyCodes.META));goog.events.KeyHandler.USES_KEYDOWN_&&!goog.events.KeyCodes.firesKeyPressEvent(a.keyCode,this.lastKey_,a.shiftKey,a.ctrlKey,a.altKey,a.metaKey)?this.handleEvent(a):(this.keyCode_=goog.events.KeyCodes.normalizeKeyCode(a.keyCode),goog.events.KeyHandler.SAVE_ALT_FOR_KEYPRESS_&&(this.altKey_=a.altKey))};goog.events.KeyHandler.prototype.resetState=function(){this.keyCode_=this.lastKey_=-1};goog.events.KeyHandler.prototype.handleKeyup_=function(a){this.resetState();
-this.altKey_=a.altKey};goog.events.KeyHandler.prototype.handleEvent=function(a){var b=a.getBrowserEvent(),c=b.altKey;if(goog.userAgent.IE&&a.type==goog.events.EventType.KEYPRESS){var d=this.keyCode_;var e=d!=goog.events.KeyCodes.ENTER&&d!=goog.events.KeyCodes.ESC?b.keyCode:0}else{(goog.userAgent.WEBKIT||goog.userAgent.EDGE)&&a.type==goog.events.EventType.KEYPRESS?(d=this.keyCode_,e=0<=b.charCode&&63232>b.charCode&&goog.events.KeyCodes.isCharacterKey(d)?b.charCode:0):goog.userAgent.OPERA&&!goog.userAgent.WEBKIT?(d=this.keyCode_,e=goog.events.KeyCodes.isCharacterKey(d)?b.keyCode:0):(d=b.keyCode||this.keyCode_,e=b.charCode||0,goog.events.KeyHandler.SAVE_ALT_FOR_KEYPRESS_&&(c=this.altKey_),goog.userAgent.MAC&&e==goog.events.KeyCodes.QUESTION_MARK&&d==goog.events.KeyCodes.WIN_KEY&&(d=goog.events.KeyCodes.SLASH))}var f=d=goog.events.KeyCodes.normalizeKeyCode(d);d?63232<=d&&d in goog.events.KeyHandler.safariKey_?f=goog.events.KeyHandler.safariKey_[d]:25==d&&a.shiftKey&&(f=9):b.keyIdentifier&&b.keyIdentifier in goog.events.KeyHandler.keyIdentifier_&&(f=goog.events.KeyHandler.keyIdentifier_[b.keyIdentifier]);a=f==this.lastKey_;this.lastKey_=f;b=new goog.events.KeyEvent(f,e,a,b);b.altKey=c;this.dispatchEvent(b)};goog.events.KeyHandler.prototype.getElement=function(){return this.element_};goog.events.KeyHandler.prototype.attach=function(a,b){this.keyUpKey_&&this.detach();this.element_=a;this.keyPressKey_=goog.events.listen(this.element_,goog.events.EventType.KEYPRESS,this,b);this.keyDownKey_=goog.events.listen(this.element_,goog.events.EventType.KEYDOWN,this.handleKeyDown_,b,this);this.keyUpKey_=goog.events.listen(this.element_,goog.events.EventType.KEYUP,this.handleKeyup_,b,this)};goog.events.KeyHandler.prototype.detach=function(){this.keyPressKey_&&(goog.events.unlistenByKey(this.keyPressKey_),goog.events.unlistenByKey(this.keyDownKey_),goog.events.unlistenByKey(this.keyUpKey_),this.keyUpKey_=this.keyDownKey_=this.keyPressKey_=null);this.element_=null;this.keyCode_=this.lastKey_=-1
-};goog.events.KeyHandler.prototype.disposeInternal=function(){goog.events.KeyHandler.superClass_.disposeInternal.call(this);this.detach()};goog.events.KeyEvent=function(a,b,c,d){goog.events.BrowserEvent.call(this,d);this.type=goog.events.KeyHandler.EventType.KEY;this.keyCode=a;this.charCode=b;this.repeat=c};goog.inherits(goog.events.KeyEvent,goog.events.BrowserEvent);goog.dom.classlist={};goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST=!1;goog.dom.classlist.get=function(a){if(goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST||a.classList){return a.classList}a=a.className;return goog.isString(a)&&a.match(/\S+/g)||[]};goog.dom.classlist.set=function(a,b){a.className=b};goog.dom.classlist.contains=function(a,b){return goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST||a.classList?a.classList.contains(b):goog.array.contains(goog.dom.classlist.get(a),b)};goog.dom.classlist.add=function(a,b){goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST||a.classList?a.classList.add(b):goog.dom.classlist.contains(a,b)||(a.className+=0<a.className.length?" "+b:b)};goog.dom.classlist.addAll=function(a,b){if(goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST||a.classList){goog.array.forEach(b,function(b){goog.dom.classlist.add(a,b)})}else{var c={};goog.array.forEach(goog.dom.classlist.get(a),function(a){c[a]=!0});goog.array.forEach(b,function(a){c[a]=!0});a.className="";for(var d in c){a.className+=0<a.className.length?" "+d:d}}};goog.dom.classlist.remove=function(a,b){goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST||a.classList?a.classList.remove(b):goog.dom.classlist.contains(a,b)&&(a.className=goog.array.filter(goog.dom.classlist.get(a),function(a){return a!=b}).join(" "))};goog.dom.classlist.removeAll=function(a,b){goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST||a.classList?goog.array.forEach(b,function(b){goog.dom.classlist.remove(a,b)}):a.className=goog.array.filter(goog.dom.classlist.get(a),function(a){return !goog.array.contains(b,a)}).join(" ")};goog.dom.classlist.enable=function(a,b,c){c?goog.dom.classlist.add(a,b):goog.dom.classlist.remove(a,b)
-};goog.dom.classlist.enableAll=function(a,b,c){(c?goog.dom.classlist.addAll:goog.dom.classlist.removeAll)(a,b)};goog.dom.classlist.swap=function(a,b,c){return goog.dom.classlist.contains(a,b)?(goog.dom.classlist.remove(a,b),goog.dom.classlist.add(a,c),!0):!1};goog.dom.classlist.toggle=function(a,b){var c=!goog.dom.classlist.contains(a,b);goog.dom.classlist.enable(a,b,c);return c};goog.dom.classlist.addRemove=function(a,b,c){goog.dom.classlist.remove(a,b);goog.dom.classlist.add(a,c)};goog.ui.registry={};goog.ui.registry.getDefaultRenderer=function(a){for(var b;a;){b=goog.getUid(a);if(b=goog.ui.registry.defaultRenderers_[b]){break}a=a.superClass_?a.superClass_.constructor:null}return b?goog.isFunction(b.getInstance)?b.getInstance():new b:null};goog.ui.registry.setDefaultRenderer=function(a,b){if(!goog.isFunction(a)){throw Error("Invalid component class "+a)}if(!goog.isFunction(b)){throw Error("Invalid renderer class "+b)}var c=goog.getUid(a);goog.ui.registry.defaultRenderers_[c]=b};goog.ui.registry.getDecoratorByClassName=function(a){return a in goog.ui.registry.decoratorFunctions_?goog.ui.registry.decoratorFunctions_[a]():null};goog.ui.registry.setDecoratorByClassName=function(a,b){if(!a){throw Error("Invalid class name "+a)}if(!goog.isFunction(b)){throw Error("Invalid decorator function "+b)}goog.ui.registry.decoratorFunctions_[a]=b};goog.ui.registry.getDecorator=function(a){goog.asserts.assert(a);for(var b=goog.dom.classlist.get(a),c=0,d=b.length;c<d;c++){if(a=goog.ui.registry.getDecoratorByClassName(b[c])){return a}}return null};goog.ui.registry.reset=function(){goog.ui.registry.defaultRenderers_={};goog.ui.registry.decoratorFunctions_={}};goog.ui.registry.defaultRenderers_={};goog.ui.registry.decoratorFunctions_={};goog.ui.ContainerRenderer=function(a){this.ariaRole_=a};goog.addSingletonGetter(goog.ui.ContainerRenderer);goog.ui.ContainerRenderer.getCustomRenderer=function(a,b){var c=new a;c.getCssClass=function(){return b};return c};goog.ui.ContainerRenderer.CSS_CLASS="goog-container";
-goog.ui.ContainerRenderer.prototype.getAriaRole=function(){return this.ariaRole_};goog.ui.ContainerRenderer.prototype.enableTabIndex=function(a,b){a&&(a.tabIndex=b?0:-1)};goog.ui.ContainerRenderer.prototype.createDom=function(a){return a.getDomHelper().createDom("DIV",this.getClassNames(a).join(" "))};goog.ui.ContainerRenderer.prototype.getContentElement=function(a){return a};goog.ui.ContainerRenderer.prototype.canDecorate=function(a){return"DIV"==a.tagName};goog.ui.ContainerRenderer.prototype.decorate=function(a,b){b.id&&a.setId(b.id);var c=this.getCssClass(),d=!1,e=goog.dom.classlist.get(b);e&&goog.array.forEach(e,function(b){b==c?d=!0:b&&this.setStateFromClassName(a,b,c)},this);d||goog.dom.classlist.add(b,c);this.decorateChildren(a,this.getContentElement(b));return b};goog.ui.ContainerRenderer.prototype.setStateFromClassName=function(a,b,c){b==c+"-disabled"?a.setEnabled(!1):b==c+"-horizontal"?a.setOrientation(goog.ui.Container.Orientation.HORIZONTAL):b==c+"-vertical"&&a.setOrientation(goog.ui.Container.Orientation.VERTICAL)};goog.ui.ContainerRenderer.prototype.decorateChildren=function(a,b,c){if(b){c=c||b.firstChild;for(var d;c&&c.parentNode==b;){d=c.nextSibling;if(c.nodeType==goog.dom.NodeType.ELEMENT){var e=this.getDecoratorForChild(c);e&&(e.setElementInternal(c),a.isEnabled()||e.setEnabled(!1),a.addChild(e),e.decorate(c))}else{c.nodeValue&&""!=goog.string.trim(c.nodeValue)||b.removeChild(c)}c=d}}};goog.ui.ContainerRenderer.prototype.getDecoratorForChild=function(a){return goog.ui.registry.getDecorator(a)};goog.ui.ContainerRenderer.prototype.initializeDom=function(a){a=a.getElement();goog.asserts.assert(a,"The container DOM element cannot be null.");goog.style.setUnselectable(a,!0,goog.userAgent.GECKO);goog.userAgent.IE&&(a.hideFocus=!0);var b=this.getAriaRole();b&&goog.a11y.aria.setRole(a,b)};goog.ui.ContainerRenderer.prototype.getKeyEventTarget=function(a){return a.getElement()};goog.ui.ContainerRenderer.prototype.getCssClass=function(){return goog.ui.ContainerRenderer.CSS_CLASS
-};goog.ui.ContainerRenderer.prototype.getClassNames=function(a){var b=this.getCssClass(),c=a.getOrientation()==goog.ui.Container.Orientation.HORIZONTAL;c=[b,c?b+"-horizontal":b+"-vertical"];a.isEnabled()||c.push(b+"-disabled");return c};goog.ui.ContainerRenderer.prototype.getDefaultOrientation=function(){return goog.ui.Container.Orientation.VERTICAL};goog.ui.ControlRenderer=function(){};goog.addSingletonGetter(goog.ui.ControlRenderer);goog.tagUnsealableClass(goog.ui.ControlRenderer);goog.ui.ControlRenderer.getCustomRenderer=function(a,b){var c=new a;c.getCssClass=function(){return b};return c};goog.ui.ControlRenderer.CSS_CLASS="goog-control";goog.ui.ControlRenderer.IE6_CLASS_COMBINATIONS=[];goog.ui.ControlRenderer.TOGGLE_ARIA_STATE_MAP_=goog.object.create(goog.a11y.aria.Role.BUTTON,goog.a11y.aria.State.PRESSED,goog.a11y.aria.Role.CHECKBOX,goog.a11y.aria.State.CHECKED,goog.a11y.aria.Role.MENU_ITEM,goog.a11y.aria.State.SELECTED,goog.a11y.aria.Role.MENU_ITEM_CHECKBOX,goog.a11y.aria.State.CHECKED,goog.a11y.aria.Role.MENU_ITEM_RADIO,goog.a11y.aria.State.CHECKED,goog.a11y.aria.Role.RADIO,goog.a11y.aria.State.CHECKED,goog.a11y.aria.Role.TAB,goog.a11y.aria.State.SELECTED,goog.a11y.aria.Role.TREEITEM,goog.a11y.aria.State.SELECTED);goog.ui.ControlRenderer.prototype.getAriaRole=function(){};goog.ui.ControlRenderer.prototype.createDom=function(a){return a.getDomHelper().createDom("DIV",this.getClassNames(a).join(" "),a.getContent())};goog.ui.ControlRenderer.prototype.getContentElement=function(a){return a};goog.ui.ControlRenderer.prototype.enableClassName=function(a,b,c){if(a=a.getElement?a.getElement():a){var d=[b];goog.userAgent.IE&&!goog.userAgent.isVersionOrHigher("7")&&(d=this.getAppliedCombinedClassNames_(goog.dom.classlist.get(a),b),d.push(b));goog.dom.classlist.enableAll(a,d,c)}};goog.ui.ControlRenderer.prototype.enableExtraClassName=function(a,b,c){this.enableClassName(a,b,c)};goog.ui.ControlRenderer.prototype.canDecorate=function(a){return !0};goog.ui.ControlRenderer.prototype.decorate=function(a,b){b.id&&a.setId(b.id);
-var c=this.getContentElement(b);c&&c.firstChild?a.setContentInternal(c.firstChild.nextSibling?goog.array.clone(c.childNodes):c.firstChild):a.setContentInternal(null);var d=0,e=this.getCssClass(),f=this.getStructuralCssClass(),g=!1,h=!1,k=!1,n=goog.array.toArray(goog.dom.classlist.get(b));goog.array.forEach(n,function(a){g||a!=e?h||a!=f?d|=this.getStateFromClass(a):h=!0:(g=!0,f==e&&(h=!0));this.getStateFromClass(a)==goog.ui.Component.State.DISABLED&&(goog.asserts.assertElement(c),goog.dom.isFocusableTabIndex(c)&&goog.dom.setFocusableTabIndex(c,!1))},this);a.setStateInternal(d);g||(n.push(e),f==e&&(h=!0));h||n.push(f);var p=a.getExtraClassNames();p&&n.push.apply(n,p);if(goog.userAgent.IE&&!goog.userAgent.isVersionOrHigher("7")){var l=this.getAppliedCombinedClassNames_(n);0<l.length&&(n.push.apply(n,l),k=!0)}g&&h&&!p&&!k||goog.dom.classlist.set(b,n.join(" "));return b};goog.ui.ControlRenderer.prototype.initializeDom=function(a){a.isRightToLeft()&&this.setRightToLeft(a.getElement(),!0);a.isEnabled()&&this.setFocusable(a,a.isVisible())};goog.ui.ControlRenderer.prototype.setAriaRole=function(a,b){var c=b||this.getAriaRole();if(c){goog.asserts.assert(a,"The element passed as a first parameter cannot be null.");var d=goog.a11y.aria.getRole(a);c!=d&&goog.a11y.aria.setRole(a,c)}};goog.ui.ControlRenderer.prototype.setAriaStates=function(a,b){goog.asserts.assert(a);goog.asserts.assert(b);var c=a.getAriaLabel();goog.isDefAndNotNull(c)&&this.setAriaLabel(b,c);a.isVisible()||goog.a11y.aria.setState(b,goog.a11y.aria.State.HIDDEN,!a.isVisible());a.isEnabled()||this.updateAriaState(b,goog.ui.Component.State.DISABLED,!a.isEnabled());a.isSupportedState(goog.ui.Component.State.SELECTED)&&this.updateAriaState(b,goog.ui.Component.State.SELECTED,a.isSelected());a.isSupportedState(goog.ui.Component.State.CHECKED)&&this.updateAriaState(b,goog.ui.Component.State.CHECKED,a.isChecked());a.isSupportedState(goog.ui.Component.State.OPENED)&&this.updateAriaState(b,goog.ui.Component.State.OPENED,a.isOpen())
-};goog.ui.ControlRenderer.prototype.setAriaLabel=function(a,b){goog.a11y.aria.setLabel(a,b)};goog.ui.ControlRenderer.prototype.setAllowTextSelection=function(a,b){goog.style.setUnselectable(a,!b,!goog.userAgent.IE&&!goog.userAgent.OPERA)};goog.ui.ControlRenderer.prototype.setRightToLeft=function(a,b){this.enableClassName(a,this.getStructuralCssClass()+"-rtl",b)};goog.ui.ControlRenderer.prototype.isFocusable=function(a){var b;return a.isSupportedState(goog.ui.Component.State.FOCUSED)&&(b=a.getKeyEventTarget())?goog.dom.isFocusableTabIndex(b):!1};goog.ui.ControlRenderer.prototype.setFocusable=function(a,b){var c;if(a.isSupportedState(goog.ui.Component.State.FOCUSED)&&(c=a.getKeyEventTarget())){if(!b&&a.isFocused()){try{c.blur()}catch(d){}a.isFocused()&&a.handleBlur(null)}goog.dom.isFocusableTabIndex(c)!=b&&goog.dom.setFocusableTabIndex(c,b)}};goog.ui.ControlRenderer.prototype.setVisible=function(a,b){goog.style.setElementShown(a,b);a&&goog.a11y.aria.setState(a,goog.a11y.aria.State.HIDDEN,!b)};goog.ui.ControlRenderer.prototype.setState=function(a,b,c){var d=a.getElement();if(d){var e=this.getClassForState(b);e&&this.enableClassName(a,e,c);this.updateAriaState(d,b,c)}};goog.ui.ControlRenderer.prototype.updateAriaState=function(a,b,c){goog.ui.ControlRenderer.ariaAttributeMap_||(goog.ui.ControlRenderer.ariaAttributeMap_=goog.object.create(goog.ui.Component.State.DISABLED,goog.a11y.aria.State.DISABLED,goog.ui.Component.State.SELECTED,goog.a11y.aria.State.SELECTED,goog.ui.Component.State.CHECKED,goog.a11y.aria.State.CHECKED,goog.ui.Component.State.OPENED,goog.a11y.aria.State.EXPANDED));goog.asserts.assert(a,"The element passed as a first parameter cannot be null.");(b=goog.ui.ControlRenderer.getAriaStateForAriaRole_(a,goog.ui.ControlRenderer.ariaAttributeMap_[b]))&&goog.a11y.aria.setState(a,b,c)};goog.ui.ControlRenderer.getAriaStateForAriaRole_=function(a,b){var c=goog.a11y.aria.getRole(a);if(!c){return b}c=goog.ui.ControlRenderer.TOGGLE_ARIA_STATE_MAP_[c]||b;return goog.ui.ControlRenderer.isAriaState_(b)?c:b
-};goog.ui.ControlRenderer.isAriaState_=function(a){return a==goog.a11y.aria.State.CHECKED||a==goog.a11y.aria.State.SELECTED};goog.ui.ControlRenderer.prototype.setContent=function(a,b){var c=this.getContentElement(a);if(c&&(goog.dom.removeChildren(c),b)){if(goog.isString(b)){goog.dom.setTextContent(c,b)}else{var d=function(a){if(a){var b=goog.dom.getOwnerDocument(c);c.appendChild(goog.isString(a)?b.createTextNode(a):a)}};goog.isArray(b)?goog.array.forEach(b,d):!goog.isArrayLike(b)||"nodeType" in b?d(b):goog.array.forEach(goog.array.clone(b),d)}}};goog.ui.ControlRenderer.prototype.getKeyEventTarget=function(a){return a.getElement()};goog.ui.ControlRenderer.prototype.getCssClass=function(){return goog.ui.ControlRenderer.CSS_CLASS};goog.ui.ControlRenderer.prototype.getIe6ClassCombinations=function(){return[]};goog.ui.ControlRenderer.prototype.getStructuralCssClass=function(){return this.getCssClass()};goog.ui.ControlRenderer.prototype.getClassNames=function(a){var b=this.getCssClass(),c=[b],d=this.getStructuralCssClass();d!=b&&c.push(d);b=this.getClassNamesForState(a.getState());c.push.apply(c,b);(a=a.getExtraClassNames())&&c.push.apply(c,a);goog.userAgent.IE&&!goog.userAgent.isVersionOrHigher("7")&&c.push.apply(c,this.getAppliedCombinedClassNames_(c));return c};goog.ui.ControlRenderer.prototype.getAppliedCombinedClassNames_=function(a,b){var c=[];b&&(a=goog.array.concat(a,[b]));goog.array.forEach(this.getIe6ClassCombinations(),function(d){!goog.array.every(d,goog.partial(goog.array.contains,a))||b&&!goog.array.contains(d,b)||c.push(d.join("_"))});return c};goog.ui.ControlRenderer.prototype.getClassNamesForState=function(a){for(var b=[];a;){var c=a&-a;b.push(this.getClassForState(c));a&=~c}return b};goog.ui.ControlRenderer.prototype.getClassForState=function(a){this.classByState_||this.createClassByStateMap_();return this.classByState_[a]};goog.ui.ControlRenderer.prototype.getStateFromClass=function(a){this.stateByClass_||this.createStateByClassMap_();a=parseInt(this.stateByClass_[a],10);
-return isNaN(a)?0:a};goog.ui.ControlRenderer.prototype.createClassByStateMap_=function(){var a=this.getStructuralCssClass(),b=!goog.string.contains(goog.string.normalizeWhitespace(a)," ");goog.asserts.assert(b,"ControlRenderer has an invalid css class: '"+a+"'");this.classByState_=goog.object.create(goog.ui.Component.State.DISABLED,a+"-disabled",goog.ui.Component.State.HOVER,a+"-hover",goog.ui.Component.State.ACTIVE,a+"-active",goog.ui.Component.State.SELECTED,a+"-selected",goog.ui.Component.State.CHECKED,a+"-checked",goog.ui.Component.State.FOCUSED,a+"-focused",goog.ui.Component.State.OPENED,a+"-open")};goog.ui.ControlRenderer.prototype.createStateByClassMap_=function(){this.classByState_||this.createClassByStateMap_();this.stateByClass_=goog.object.transpose(this.classByState_)};goog.ui.Control=function(a,b,c){goog.ui.Component.call(this,c);this.renderer_=b||goog.ui.registry.getDefaultRenderer(this.constructor);this.setContentInternal(goog.isDef(a)?a:null);this.ariaLabel_=null};goog.inherits(goog.ui.Control,goog.ui.Component);goog.tagUnsealableClass(goog.ui.Control);goog.ui.Control.registerDecorator=goog.ui.registry.setDecoratorByClassName;goog.ui.Control.getDecorator=goog.ui.registry.getDecorator;goog.ui.Control.prototype.content_=null;goog.ui.Control.prototype.state_=0;goog.ui.Control.prototype.supportedStates_=goog.ui.Component.State.DISABLED|goog.ui.Component.State.HOVER|goog.ui.Component.State.ACTIVE|goog.ui.Component.State.FOCUSED;goog.ui.Control.prototype.autoStates_=goog.ui.Component.State.ALL;goog.ui.Control.prototype.statesWithTransitionEvents_=0;goog.ui.Control.prototype.visible_=!0;goog.ui.Control.prototype.extraClassNames_=null;goog.ui.Control.prototype.handleMouseEvents_=!0;goog.ui.Control.prototype.allowTextSelection_=!1;goog.ui.Control.prototype.preferredAriaRole_=null;goog.ui.Control.prototype.isHandleMouseEvents=function(){return this.handleMouseEvents_};goog.ui.Control.prototype.setHandleMouseEvents=function(a){this.isInDocument()&&a!=this.handleMouseEvents_&&this.enableMouseEventHandling_(a);
-this.handleMouseEvents_=a};goog.ui.Control.prototype.getKeyEventTarget=function(){return this.renderer_.getKeyEventTarget(this)};goog.ui.Control.prototype.getKeyHandler=function(){return this.keyHandler_||(this.keyHandler_=new goog.events.KeyHandler)};goog.ui.Control.prototype.getRenderer=function(){return this.renderer_};goog.ui.Control.prototype.setRenderer=function(a){if(this.isInDocument()){throw Error(goog.ui.Component.Error.ALREADY_RENDERED)}this.getElement()&&this.setElementInternal(null);this.renderer_=a};goog.ui.Control.prototype.getExtraClassNames=function(){return this.extraClassNames_};goog.ui.Control.prototype.addClassName=function(a){a&&(this.extraClassNames_?goog.array.contains(this.extraClassNames_,a)||this.extraClassNames_.push(a):this.extraClassNames_=[a],this.renderer_.enableExtraClassName(this,a,!0))};goog.ui.Control.prototype.removeClassName=function(a){a&&this.extraClassNames_&&goog.array.remove(this.extraClassNames_,a)&&(0==this.extraClassNames_.length&&(this.extraClassNames_=null),this.renderer_.enableExtraClassName(this,a,!1))};goog.ui.Control.prototype.enableClassName=function(a,b){b?this.addClassName(a):this.removeClassName(a)};goog.ui.Control.prototype.createDom=function(){var a=this.renderer_.createDom(this);this.setElementInternal(a);this.renderer_.setAriaRole(a,this.getPreferredAriaRole());this.isAllowTextSelection()||this.renderer_.setAllowTextSelection(a,!1);this.isVisible()||this.renderer_.setVisible(a,!1)};goog.ui.Control.prototype.getPreferredAriaRole=function(){return this.preferredAriaRole_};goog.ui.Control.prototype.setPreferredAriaRole=function(a){this.preferredAriaRole_=a};goog.ui.Control.prototype.getAriaLabel=function(){return this.ariaLabel_};goog.ui.Control.prototype.setAriaLabel=function(a){this.ariaLabel_=a;var b=this.getElement();b&&this.renderer_.setAriaLabel(b,a)};goog.ui.Control.prototype.getContentElement=function(){return this.renderer_.getContentElement(this.getElement())};goog.ui.Control.prototype.canDecorate=function(a){return this.renderer_.canDecorate(a)
-};goog.ui.Control.prototype.decorateInternal=function(a){a=this.renderer_.decorate(this,a);this.setElementInternal(a);this.renderer_.setAriaRole(a,this.getPreferredAriaRole());this.isAllowTextSelection()||this.renderer_.setAllowTextSelection(a,!1);this.visible_="none"!=a.style.display};goog.ui.Control.prototype.enterDocument=function(){goog.ui.Control.superClass_.enterDocument.call(this);this.renderer_.setAriaStates(this,this.getElementStrict());this.renderer_.initializeDom(this);if(this.supportedStates_&~goog.ui.Component.State.DISABLED&&(this.isHandleMouseEvents()&&this.enableMouseEventHandling_(!0),this.isSupportedState(goog.ui.Component.State.FOCUSED))){var a=this.getKeyEventTarget();if(a){var b=this.getKeyHandler();b.attach(a);this.getHandler().listen(b,goog.events.KeyHandler.EventType.KEY,this.handleKeyEvent).listen(a,goog.events.EventType.FOCUS,this.handleFocus).listen(a,goog.events.EventType.BLUR,this.handleBlur)}}};goog.ui.Control.prototype.enableMouseEventHandling_=function(a){var b=this.getHandler(),c=this.getElement();a?(b.listen(c,goog.events.EventType.MOUSEOVER,this.handleMouseOver).listen(c,goog.events.EventType.MOUSEDOWN,this.handleMouseDown).listen(c,goog.events.EventType.MOUSEUP,this.handleMouseUp).listen(c,goog.events.EventType.MOUSEOUT,this.handleMouseOut),this.handleContextMenu!=goog.nullFunction&&b.listen(c,goog.events.EventType.CONTEXTMENU,this.handleContextMenu),goog.userAgent.IE&&(goog.userAgent.isVersionOrHigher(9)||b.listen(c,goog.events.EventType.DBLCLICK,this.handleDblClick),this.ieMouseEventSequenceSimulator_||(this.ieMouseEventSequenceSimulator_=new goog.ui.Control.IeMouseEventSequenceSimulator_(this),this.registerDisposable(this.ieMouseEventSequenceSimulator_)))):(b.unlisten(c,goog.events.EventType.MOUSEOVER,this.handleMouseOver).unlisten(c,goog.events.EventType.MOUSEDOWN,this.handleMouseDown).unlisten(c,goog.events.EventType.MOUSEUP,this.handleMouseUp).unlisten(c,goog.events.EventType.MOUSEOUT,this.handleMouseOut),this.handleContextMenu!=goog.nullFunction&&b.unlisten(c,goog.events.EventType.CONTEXTMENU,this.handleContextMenu),goog.userAgent.IE&&(goog.userAgent.isVersionOrHigher(9)||b.unlisten(c,goog.events.EventType.DBLCLICK,this.handleDblClick),goog.dispose(this.ieMouseEventSequenceSimulator_),this.ieMouseEventSequenceSimulator_=null))
-};goog.ui.Control.prototype.exitDocument=function(){goog.ui.Control.superClass_.exitDocument.call(this);this.keyHandler_&&this.keyHandler_.detach();this.isVisible()&&this.isEnabled()&&this.renderer_.setFocusable(this,!1)};goog.ui.Control.prototype.disposeInternal=function(){goog.ui.Control.superClass_.disposeInternal.call(this);this.keyHandler_&&(this.keyHandler_.dispose(),delete this.keyHandler_);delete this.renderer_;this.ieMouseEventSequenceSimulator_=this.extraClassNames_=this.content_=null};goog.ui.Control.prototype.getContent=function(){return this.content_};goog.ui.Control.prototype.setContent=function(a){this.renderer_.setContent(this.getElement(),a);this.setContentInternal(a)};goog.ui.Control.prototype.setContentInternal=function(a){this.content_=a};goog.ui.Control.prototype.getCaption=function(){var a=this.getContent();if(!a){return""}a=goog.isString(a)?a:goog.isArray(a)?goog.array.map(a,goog.dom.getRawTextContent).join(""):goog.dom.getTextContent(a);return goog.string.collapseBreakingSpaces(a)};goog.ui.Control.prototype.setCaption=function(a){this.setContent(a)};goog.ui.Control.prototype.setRightToLeft=function(a){goog.ui.Control.superClass_.setRightToLeft.call(this,a);var b=this.getElement();b&&this.renderer_.setRightToLeft(b,a)};goog.ui.Control.prototype.isAllowTextSelection=function(){return this.allowTextSelection_};goog.ui.Control.prototype.setAllowTextSelection=function(a){this.allowTextSelection_=a;var b=this.getElement();b&&this.renderer_.setAllowTextSelection(b,a)};goog.ui.Control.prototype.isVisible=function(){return this.visible_};goog.ui.Control.prototype.setVisible=function(a,b){if(b||this.visible_!=a&&this.dispatchEvent(a?goog.ui.Component.EventType.SHOW:goog.ui.Component.EventType.HIDE)){var c=this.getElement();c&&this.renderer_.setVisible(c,a);this.isEnabled()&&this.renderer_.setFocusable(this,a);this.visible_=a;return !0}return !1};goog.ui.Control.prototype.isEnabled=function(){return !this.hasState(goog.ui.Component.State.DISABLED)};goog.ui.Control.prototype.isParentDisabled_=function(){var a=this.getParent();
-return !!a&&"function"==typeof a.isEnabled&&!a.isEnabled()};goog.ui.Control.prototype.setEnabled=function(a){!this.isParentDisabled_()&&this.isTransitionAllowed(goog.ui.Component.State.DISABLED,!a)&&(a||(this.setActive(!1),this.setHighlighted(!1)),this.isVisible()&&this.renderer_.setFocusable(this,a),this.setState(goog.ui.Component.State.DISABLED,!a,!0))};goog.ui.Control.prototype.isHighlighted=function(){return this.hasState(goog.ui.Component.State.HOVER)};goog.ui.Control.prototype.setHighlighted=function(a){this.isTransitionAllowed(goog.ui.Component.State.HOVER,a)&&this.setState(goog.ui.Component.State.HOVER,a)};goog.ui.Control.prototype.isActive=function(){return this.hasState(goog.ui.Component.State.ACTIVE)};goog.ui.Control.prototype.setActive=function(a){this.isTransitionAllowed(goog.ui.Component.State.ACTIVE,a)&&this.setState(goog.ui.Component.State.ACTIVE,a)};goog.ui.Control.prototype.isSelected=function(){return this.hasState(goog.ui.Component.State.SELECTED)};goog.ui.Control.prototype.setSelected=function(a){this.isTransitionAllowed(goog.ui.Component.State.SELECTED,a)&&this.setState(goog.ui.Component.State.SELECTED,a)};goog.ui.Control.prototype.isChecked=function(){return this.hasState(goog.ui.Component.State.CHECKED)};goog.ui.Control.prototype.setChecked=function(a){this.isTransitionAllowed(goog.ui.Component.State.CHECKED,a)&&this.setState(goog.ui.Component.State.CHECKED,a)};goog.ui.Control.prototype.isFocused=function(){return this.hasState(goog.ui.Component.State.FOCUSED)};goog.ui.Control.prototype.setFocused=function(a){this.isTransitionAllowed(goog.ui.Component.State.FOCUSED,a)&&this.setState(goog.ui.Component.State.FOCUSED,a)};goog.ui.Control.prototype.isOpen=function(){return this.hasState(goog.ui.Component.State.OPENED)};goog.ui.Control.prototype.setOpen=function(a){this.isTransitionAllowed(goog.ui.Component.State.OPENED,a)&&this.setState(goog.ui.Component.State.OPENED,a)};goog.ui.Control.prototype.getState=function(){return this.state_};goog.ui.Control.prototype.hasState=function(a){return !!(this.state_&a)
-};goog.ui.Control.prototype.setState=function(a,b,c){c||a!=goog.ui.Component.State.DISABLED?this.isSupportedState(a)&&b!=this.hasState(a)&&(this.renderer_.setState(this,a,b),this.state_=b?this.state_|a:this.state_&~a):this.setEnabled(!b)};goog.ui.Control.prototype.setStateInternal=function(a){this.state_=a};goog.ui.Control.prototype.isSupportedState=function(a){return !!(this.supportedStates_&a)};goog.ui.Control.prototype.setSupportedState=function(a,b){if(this.isInDocument()&&this.hasState(a)&&!b){throw Error(goog.ui.Component.Error.ALREADY_RENDERED)}!b&&this.hasState(a)&&this.setState(a,!1);this.supportedStates_=b?this.supportedStates_|a:this.supportedStates_&~a};goog.ui.Control.prototype.isAutoState=function(a){return !!(this.autoStates_&a)&&this.isSupportedState(a)};goog.ui.Control.prototype.setAutoStates=function(a,b){this.autoStates_=b?this.autoStates_|a:this.autoStates_&~a};goog.ui.Control.prototype.isDispatchTransitionEvents=function(a){return !!(this.statesWithTransitionEvents_&a)&&this.isSupportedState(a)};goog.ui.Control.prototype.setDispatchTransitionEvents=function(a,b){this.statesWithTransitionEvents_=b?this.statesWithTransitionEvents_|a:this.statesWithTransitionEvents_&~a};goog.ui.Control.prototype.isTransitionAllowed=function(a,b){return this.isSupportedState(a)&&this.hasState(a)!=b&&(!(this.statesWithTransitionEvents_&a)||this.dispatchEvent(goog.ui.Component.getStateTransitionEvent(a,b)))&&!this.isDisposed()};goog.ui.Control.prototype.handleMouseOver=function(a){!goog.ui.Control.isMouseEventWithinElement_(a,this.getElement())&&this.dispatchEvent(goog.ui.Component.EventType.ENTER)&&this.isEnabled()&&this.isAutoState(goog.ui.Component.State.HOVER)&&this.setHighlighted(!0)};goog.ui.Control.prototype.handleMouseOut=function(a){!goog.ui.Control.isMouseEventWithinElement_(a,this.getElement())&&this.dispatchEvent(goog.ui.Component.EventType.LEAVE)&&(this.isAutoState(goog.ui.Component.State.ACTIVE)&&this.setActive(!1),this.isAutoState(goog.ui.Component.State.HOVER)&&this.setHighlighted(!1))
-};goog.ui.Control.prototype.handleContextMenu=goog.nullFunction;goog.ui.Control.isMouseEventWithinElement_=function(a,b){return !!a.relatedTarget&&goog.dom.contains(b,a.relatedTarget)};goog.ui.Control.prototype.handleMouseDown=function(a){this.isEnabled()&&(this.isAutoState(goog.ui.Component.State.HOVER)&&this.setHighlighted(!0),a.isMouseActionButton()&&(this.isAutoState(goog.ui.Component.State.ACTIVE)&&this.setActive(!0),this.renderer_&&this.renderer_.isFocusable(this)&&this.getKeyEventTarget().focus()));!this.isAllowTextSelection()&&a.isMouseActionButton()&&a.preventDefault()};goog.ui.Control.prototype.handleMouseUp=function(a){this.isEnabled()&&(this.isAutoState(goog.ui.Component.State.HOVER)&&this.setHighlighted(!0),this.isActive()&&this.performActionInternal(a)&&this.isAutoState(goog.ui.Component.State.ACTIVE)&&this.setActive(!1))};goog.ui.Control.prototype.handleDblClick=function(a){this.isEnabled()&&this.performActionInternal(a)};goog.ui.Control.prototype.performActionInternal=function(a){this.isAutoState(goog.ui.Component.State.CHECKED)&&this.setChecked(!this.isChecked());this.isAutoState(goog.ui.Component.State.SELECTED)&&this.setSelected(!0);this.isAutoState(goog.ui.Component.State.OPENED)&&this.setOpen(!this.isOpen());var b=new goog.events.Event(goog.ui.Component.EventType.ACTION,this);a&&(b.altKey=a.altKey,b.ctrlKey=a.ctrlKey,b.metaKey=a.metaKey,b.shiftKey=a.shiftKey,b.platformModifierKey=a.platformModifierKey);return this.dispatchEvent(b)};goog.ui.Control.prototype.handleFocus=function(a){this.isAutoState(goog.ui.Component.State.FOCUSED)&&this.setFocused(!0)};goog.ui.Control.prototype.handleBlur=function(a){this.isAutoState(goog.ui.Component.State.ACTIVE)&&this.setActive(!1);this.isAutoState(goog.ui.Component.State.FOCUSED)&&this.setFocused(!1)};goog.ui.Control.prototype.handleKeyEvent=function(a){return this.isVisible()&&this.isEnabled()&&this.handleKeyEventInternal(a)?(a.preventDefault(),a.stopPropagation(),!0):!1};goog.ui.Control.prototype.handleKeyEventInternal=function(a){return a.keyCode==goog.events.KeyCodes.ENTER&&this.performActionInternal(a)
-};goog.ui.registry.setDefaultRenderer(goog.ui.Control,goog.ui.ControlRenderer);goog.ui.registry.setDecoratorByClassName(goog.ui.ControlRenderer.CSS_CLASS,function(){return new goog.ui.Control(null)});goog.ui.Control.IeMouseEventSequenceSimulator_=function(a){goog.Disposable.call(this);this.control_=a;this.clickExpected_=!1;this.handler_=new goog.events.EventHandler(this);this.registerDisposable(this.handler_);a=this.control_.getElementStrict();this.handler_.listen(a,goog.events.EventType.MOUSEDOWN,this.handleMouseDown_).listen(a,goog.events.EventType.MOUSEUP,this.handleMouseUp_).listen(a,goog.events.EventType.CLICK,this.handleClick_)};goog.inherits(goog.ui.Control.IeMouseEventSequenceSimulator_,goog.Disposable);goog.ui.Control.IeMouseEventSequenceSimulator_.SYNTHETIC_EVENTS_=!goog.userAgent.IE||goog.userAgent.isDocumentModeOrHigher(9);goog.ui.Control.IeMouseEventSequenceSimulator_.prototype.handleMouseDown_=function(){this.clickExpected_=!1};goog.ui.Control.IeMouseEventSequenceSimulator_.prototype.handleMouseUp_=function(){this.clickExpected_=!0};goog.ui.Control.IeMouseEventSequenceSimulator_.makeLeftMouseEvent_=function(a,b){if(!goog.ui.Control.IeMouseEventSequenceSimulator_.SYNTHETIC_EVENTS_){return a.button=goog.events.BrowserEvent.MouseButton.LEFT,a.type=b,a}var c=document.createEvent("MouseEvents");c.initMouseEvent(b,a.bubbles,a.cancelable,a.view||null,a.detail,a.screenX,a.screenY,a.clientX,a.clientY,a.ctrlKey,a.altKey,a.shiftKey,a.metaKey,goog.events.BrowserEvent.MouseButton.LEFT,a.relatedTarget||null);return c};goog.ui.Control.IeMouseEventSequenceSimulator_.prototype.handleClick_=function(a){if(this.clickExpected_){this.clickExpected_=!1}else{var b=a.getBrowserEvent(),c=b.button,d=b.type,e=goog.ui.Control.IeMouseEventSequenceSimulator_.makeLeftMouseEvent_(b,goog.events.EventType.MOUSEDOWN);this.control_.handleMouseDown(new goog.events.BrowserEvent(e,a.currentTarget));e=goog.ui.Control.IeMouseEventSequenceSimulator_.makeLeftMouseEvent_(b,goog.events.EventType.MOUSEUP);
-this.control_.handleMouseUp(new goog.events.BrowserEvent(e,a.currentTarget));goog.ui.Control.IeMouseEventSequenceSimulator_.SYNTHETIC_EVENTS_||(b.button=c,b.type=d)}};goog.ui.Control.IeMouseEventSequenceSimulator_.prototype.disposeInternal=function(){this.control_=null;goog.ui.Control.IeMouseEventSequenceSimulator_.superClass_.disposeInternal.call(this)};goog.ui.Container=function(a,b,c){goog.ui.Component.call(this,c);this.renderer_=b||goog.ui.ContainerRenderer.getInstance();this.orientation_=a||this.renderer_.getDefaultOrientation()};goog.inherits(goog.ui.Container,goog.ui.Component);goog.tagUnsealableClass(goog.ui.Container);goog.ui.Container.EventType={AFTER_SHOW:"aftershow",AFTER_HIDE:"afterhide"};goog.ui.Container.Orientation={HORIZONTAL:"horizontal",VERTICAL:"vertical"};goog.ui.Container.prototype.keyEventTarget_=null;goog.ui.Container.prototype.keyHandler_=null;goog.ui.Container.prototype.renderer_=null;goog.ui.Container.prototype.orientation_=null;goog.ui.Container.prototype.visible_=!0;goog.ui.Container.prototype.enabled_=!0;goog.ui.Container.prototype.focusable_=!0;goog.ui.Container.prototype.highlightedIndex_=-1;goog.ui.Container.prototype.openItem_=null;goog.ui.Container.prototype.mouseButtonPressed_=!1;goog.ui.Container.prototype.allowFocusableChildren_=!1;goog.ui.Container.prototype.openFollowsHighlight_=!0;goog.ui.Container.prototype.childElementIdMap_=null;goog.ui.Container.prototype.getKeyEventTarget=function(){return this.keyEventTarget_||this.renderer_.getKeyEventTarget(this)};goog.ui.Container.prototype.setKeyEventTarget=function(a){if(this.focusable_){var b=this.getKeyEventTarget(),c=this.isInDocument();this.keyEventTarget_=a;var d=this.getKeyEventTarget();c&&(this.keyEventTarget_=b,this.enableFocusHandling_(!1),this.keyEventTarget_=a,this.getKeyHandler().attach(d),this.enableFocusHandling_(!0))}else{throw Error("Can't set key event target for container that doesn't support keyboard focus!")}};goog.ui.Container.prototype.getKeyHandler=function(){return this.keyHandler_||(this.keyHandler_=new goog.events.KeyHandler(this.getKeyEventTarget()))
-};goog.ui.Container.prototype.getRenderer=function(){return this.renderer_};goog.ui.Container.prototype.setRenderer=function(a){if(this.getElement()){throw Error(goog.ui.Component.Error.ALREADY_RENDERED)}this.renderer_=a};goog.ui.Container.prototype.createDom=function(){this.setElementInternal(this.renderer_.createDom(this))};goog.ui.Container.prototype.getContentElement=function(){return this.renderer_.getContentElement(this.getElement())};goog.ui.Container.prototype.canDecorate=function(a){return this.renderer_.canDecorate(a)};goog.ui.Container.prototype.decorateInternal=function(a){this.setElementInternal(this.renderer_.decorate(this,a));"none"==a.style.display&&(this.visible_=!1)};goog.ui.Container.prototype.enterDocument=function(){goog.ui.Container.superClass_.enterDocument.call(this);this.forEachChild(function(a){a.isInDocument()&&this.registerChildId_(a)},this);var a=this.getElement();this.renderer_.initializeDom(this);this.setVisible(this.visible_,!0);this.getHandler().listen(this,goog.ui.Component.EventType.ENTER,this.handleEnterItem).listen(this,goog.ui.Component.EventType.HIGHLIGHT,this.handleHighlightItem).listen(this,goog.ui.Component.EventType.UNHIGHLIGHT,this.handleUnHighlightItem).listen(this,goog.ui.Component.EventType.OPEN,this.handleOpenItem).listen(this,goog.ui.Component.EventType.CLOSE,this.handleCloseItem).listen(a,goog.events.EventType.MOUSEDOWN,this.handleMouseDown).listen(goog.dom.getOwnerDocument(a),goog.events.EventType.MOUSEUP,this.handleDocumentMouseUp).listen(a,[goog.events.EventType.MOUSEDOWN,goog.events.EventType.MOUSEUP,goog.events.EventType.MOUSEOVER,goog.events.EventType.MOUSEOUT,goog.events.EventType.CONTEXTMENU],this.handleChildMouseEvents);this.isFocusable()&&this.enableFocusHandling_(!0)};goog.ui.Container.prototype.enableFocusHandling_=function(a){var b=this.getHandler(),c=this.getKeyEventTarget();a?b.listen(c,goog.events.EventType.FOCUS,this.handleFocus).listen(c,goog.events.EventType.BLUR,this.handleBlur).listen(this.getKeyHandler(),goog.events.KeyHandler.EventType.KEY,this.handleKeyEvent):b.unlisten(c,goog.events.EventType.FOCUS,this.handleFocus).unlisten(c,goog.events.EventType.BLUR,this.handleBlur).unlisten(this.getKeyHandler(),goog.events.KeyHandler.EventType.KEY,this.handleKeyEvent)
-};goog.ui.Container.prototype.exitDocument=function(){this.setHighlightedIndex(-1);this.openItem_&&this.openItem_.setOpen(!1);this.mouseButtonPressed_=!1;goog.ui.Container.superClass_.exitDocument.call(this)};goog.ui.Container.prototype.disposeInternal=function(){goog.ui.Container.superClass_.disposeInternal.call(this);this.keyHandler_&&(this.keyHandler_.dispose(),this.keyHandler_=null);this.renderer_=this.openItem_=this.childElementIdMap_=this.keyEventTarget_=null};goog.ui.Container.prototype.handleEnterItem=function(a){return !0};goog.ui.Container.prototype.handleHighlightItem=function(a){var b=this.indexOfChild(a.target);if(-1<b&&b!=this.highlightedIndex_){var c=this.getHighlighted();c&&c.setHighlighted(!1);this.highlightedIndex_=b;c=this.getHighlighted();this.isMouseButtonPressed()&&c.setActive(!0);this.openFollowsHighlight_&&this.openItem_&&c!=this.openItem_&&(c.isSupportedState(goog.ui.Component.State.OPENED)?c.setOpen(!0):this.openItem_.setOpen(!1))}b=this.getElement();goog.asserts.assert(b,"The DOM element for the container cannot be null.");null!=a.target.getElement()&&goog.a11y.aria.setState(b,goog.a11y.aria.State.ACTIVEDESCENDANT,a.target.getElement().id)};goog.ui.Container.prototype.handleUnHighlightItem=function(a){a.target==this.getHighlighted()&&(this.highlightedIndex_=-1);a=this.getElement();goog.asserts.assert(a,"The DOM element for the container cannot be null.");goog.a11y.aria.removeState(a,goog.a11y.aria.State.ACTIVEDESCENDANT)};goog.ui.Container.prototype.handleOpenItem=function(a){(a=a.target)&&a!=this.openItem_&&a.getParent()==this&&(this.openItem_&&this.openItem_.setOpen(!1),this.openItem_=a)};goog.ui.Container.prototype.handleCloseItem=function(a){a.target==this.openItem_&&(this.openItem_=null);var b=this.getElement(),c=a.target.getElement();b&&a.target.isHighlighted()&&c&&goog.a11y.aria.setActiveDescendant(b,c)};goog.ui.Container.prototype.handleMouseDown=function(a){this.enabled_&&this.setMouseButtonPressed(!0);var b=this.getKeyEventTarget();
-b&&goog.dom.isFocusableTabIndex(b)?b.focus():a.preventDefault()};goog.ui.Container.prototype.handleDocumentMouseUp=function(a){this.setMouseButtonPressed(!1)};goog.ui.Container.prototype.handleChildMouseEvents=function(a){var b=this.getOwnerControl(a.target);if(b){switch(a.type){case goog.events.EventType.MOUSEDOWN:b.handleMouseDown(a);break;case goog.events.EventType.MOUSEUP:b.handleMouseUp(a);break;case goog.events.EventType.MOUSEOVER:b.handleMouseOver(a);break;case goog.events.EventType.MOUSEOUT:b.handleMouseOut(a);break;case goog.events.EventType.CONTEXTMENU:b.handleContextMenu(a)}}};goog.ui.Container.prototype.getOwnerControl=function(a){if(this.childElementIdMap_){for(var b=this.getElement();a&&a!==b;){var c=a.id;if(c in this.childElementIdMap_){return this.childElementIdMap_[c]}a=a.parentNode}}return null};goog.ui.Container.prototype.handleFocus=function(a){};goog.ui.Container.prototype.handleBlur=function(a){this.setHighlightedIndex(-1);this.setMouseButtonPressed(!1);this.openItem_&&this.openItem_.setOpen(!1)};goog.ui.Container.prototype.handleKeyEvent=function(a){return this.isEnabled()&&this.isVisible()&&(0!=this.getChildCount()||this.keyEventTarget_)&&this.handleKeyEventInternal(a)?(a.preventDefault(),a.stopPropagation(),!0):!1};goog.ui.Container.prototype.handleKeyEventInternal=function(a){var b=this.getHighlighted();if(b&&"function"==typeof b.handleKeyEvent&&b.handleKeyEvent(a)||this.openItem_&&this.openItem_!=b&&"function"==typeof this.openItem_.handleKeyEvent&&this.openItem_.handleKeyEvent(a)){return !0}if(a.shiftKey||a.ctrlKey||a.metaKey||a.altKey){return !1}switch(a.keyCode){case goog.events.KeyCodes.ESC:if(this.isFocusable()){this.getKeyEventTarget().blur()}else{return !1}break;case goog.events.KeyCodes.HOME:this.highlightFirst();break;case goog.events.KeyCodes.END:this.highlightLast();break;case goog.events.KeyCodes.UP:if(this.orientation_==goog.ui.Container.Orientation.VERTICAL){this.highlightPrevious()}else{return !1}break;case goog.events.KeyCodes.LEFT:if(this.orientation_==goog.ui.Container.Orientation.HORIZONTAL){this.isRightToLeft()?this.highlightNext():this.highlightPrevious()
-}else{return !1}break;case goog.events.KeyCodes.DOWN:if(this.orientation_==goog.ui.Container.Orientation.VERTICAL){this.highlightNext()}else{return !1}break;case goog.events.KeyCodes.RIGHT:if(this.orientation_==goog.ui.Container.Orientation.HORIZONTAL){this.isRightToLeft()?this.highlightPrevious():this.highlightNext()}else{return !1}break;default:return !1}return !0};goog.ui.Container.prototype.registerChildId_=function(a){var b=a.getElement();b=b.id||(b.id=a.getId());this.childElementIdMap_||(this.childElementIdMap_={});this.childElementIdMap_[b]=a};goog.ui.Container.prototype.addChild=function(a,b){goog.asserts.assertInstanceof(a,goog.ui.Control,"The child of a container must be a control");goog.ui.Container.superClass_.addChild.call(this,a,b)};goog.ui.Container.prototype.addChildAt=function(a,b,c){goog.asserts.assertInstanceof(a,goog.ui.Control);a.setDispatchTransitionEvents(goog.ui.Component.State.HOVER,!0);a.setDispatchTransitionEvents(goog.ui.Component.State.OPENED,!0);!this.isFocusable()&&this.isFocusableChildrenAllowed()||a.setSupportedState(goog.ui.Component.State.FOCUSED,!1);a.setHandleMouseEvents(!1);var d=a.getParent()==this?this.indexOfChild(a):-1;goog.ui.Container.superClass_.addChildAt.call(this,a,b,c);a.isInDocument()&&this.isInDocument()&&this.registerChildId_(a);this.updateHighlightedIndex_(d,b)};goog.ui.Container.prototype.updateHighlightedIndex_=function(a,b){-1==a&&(a=this.getChildCount());a==this.highlightedIndex_?this.highlightedIndex_=Math.min(this.getChildCount()-1,b):a>this.highlightedIndex_&&b<=this.highlightedIndex_?this.highlightedIndex_++:a<this.highlightedIndex_&&b>this.highlightedIndex_&&this.highlightedIndex_--};goog.ui.Container.prototype.removeChild=function(a,b){a=goog.isString(a)?this.getChild(a):a;goog.asserts.assertInstanceof(a,goog.ui.Control);if(a){var c=this.indexOfChild(a);-1!=c&&(c==this.highlightedIndex_?(a.setHighlighted(!1),this.highlightedIndex_=-1):c<this.highlightedIndex_&&this.highlightedIndex_--);(c=a.getElement())&&c.id&&this.childElementIdMap_&&goog.object.remove(this.childElementIdMap_,c.id)
-}a=goog.ui.Container.superClass_.removeChild.call(this,a,b);a.setHandleMouseEvents(!0);return a};goog.ui.Container.prototype.getOrientation=function(){return this.orientation_};goog.ui.Container.prototype.setOrientation=function(a){if(this.getElement()){throw Error(goog.ui.Component.Error.ALREADY_RENDERED)}this.orientation_=a};goog.ui.Container.prototype.isVisible=function(){return this.visible_};goog.ui.Container.prototype.setVisible=function(a,b){if(b||this.visible_!=a&&this.dispatchEvent(a?goog.ui.Component.EventType.SHOW:goog.ui.Component.EventType.HIDE)){this.visible_=a;var c=this.getElement();c&&(goog.style.setElementShown(c,a),this.isFocusable()&&this.renderer_.enableTabIndex(this.getKeyEventTarget(),this.enabled_&&this.visible_),b||this.dispatchEvent(this.visible_?goog.ui.Container.EventType.AFTER_SHOW:goog.ui.Container.EventType.AFTER_HIDE));return !0}return !1};goog.ui.Container.prototype.isEnabled=function(){return this.enabled_};goog.ui.Container.prototype.setEnabled=function(a){this.enabled_!=a&&this.dispatchEvent(a?goog.ui.Component.EventType.ENABLE:goog.ui.Component.EventType.DISABLE)&&(a?(this.enabled_=!0,this.forEachChild(function(a){a.wasDisabled?delete a.wasDisabled:a.setEnabled(!0)})):(this.forEachChild(function(a){a.isEnabled()?a.setEnabled(!1):a.wasDisabled=!0}),this.enabled_=!1,this.setMouseButtonPressed(!1)),this.isFocusable()&&this.renderer_.enableTabIndex(this.getKeyEventTarget(),a&&this.visible_))};goog.ui.Container.prototype.isFocusable=function(){return this.focusable_};goog.ui.Container.prototype.setFocusable=function(a){a!=this.focusable_&&this.isInDocument()&&this.enableFocusHandling_(a);this.focusable_=a;this.enabled_&&this.visible_&&this.renderer_.enableTabIndex(this.getKeyEventTarget(),a)};goog.ui.Container.prototype.isFocusableChildrenAllowed=function(){return this.allowFocusableChildren_};goog.ui.Container.prototype.setFocusableChildrenAllowed=function(a){this.allowFocusableChildren_=a};goog.ui.Container.prototype.isOpenFollowsHighlight=function(){return this.openFollowsHighlight_
-};goog.ui.Container.prototype.setOpenFollowsHighlight=function(a){this.openFollowsHighlight_=a};goog.ui.Container.prototype.getHighlightedIndex=function(){return this.highlightedIndex_};goog.ui.Container.prototype.setHighlightedIndex=function(a){(a=this.getChildAt(a))?a.setHighlighted(!0):-1<this.highlightedIndex_&&this.getHighlighted().setHighlighted(!1)};goog.ui.Container.prototype.setHighlighted=function(a){this.setHighlightedIndex(this.indexOfChild(a))};goog.ui.Container.prototype.getHighlighted=function(){return this.getChildAt(this.highlightedIndex_)};goog.ui.Container.prototype.highlightFirst=function(){this.highlightHelper(function(a,b){return(a+1)%b},this.getChildCount()-1)};goog.ui.Container.prototype.highlightLast=function(){this.highlightHelper(function(a,b){a--;return 0>a?b-1:a},0)};goog.ui.Container.prototype.highlightNext=function(){this.highlightHelper(function(a,b){return(a+1)%b},this.highlightedIndex_)};goog.ui.Container.prototype.highlightPrevious=function(){this.highlightHelper(function(a,b){a--;return 0>a?b-1:a},this.highlightedIndex_)};goog.ui.Container.prototype.highlightHelper=function(a,b){var c=0>b?this.indexOfChild(this.openItem_):b,d=this.getChildCount();c=a.call(this,c,d);for(var e=0;e<=d;){var f=this.getChildAt(c);if(f&&this.canHighlightItem(f)){return this.setHighlightedIndexFromKeyEvent(c),!0}e++;c=a.call(this,c,d)}return !1};goog.ui.Container.prototype.canHighlightItem=function(a){return a.isVisible()&&a.isEnabled()&&a.isSupportedState(goog.ui.Component.State.HOVER)};goog.ui.Container.prototype.setHighlightedIndexFromKeyEvent=function(a){this.setHighlightedIndex(a)};goog.ui.Container.prototype.getOpenItem=function(){return this.openItem_};goog.ui.Container.prototype.isMouseButtonPressed=function(){return this.mouseButtonPressed_};goog.ui.Container.prototype.setMouseButtonPressed=function(a){this.mouseButtonPressed_=a};goog.ui.MenuHeaderRenderer=function(){goog.ui.ControlRenderer.call(this)};goog.inherits(goog.ui.MenuHeaderRenderer,goog.ui.ControlRenderer);
-goog.addSingletonGetter(goog.ui.MenuHeaderRenderer);goog.ui.MenuHeaderRenderer.CSS_CLASS="goog-menuheader";goog.ui.MenuHeaderRenderer.prototype.getCssClass=function(){return goog.ui.MenuHeaderRenderer.CSS_CLASS};goog.ui.MenuHeader=function(a,b,c){goog.ui.Control.call(this,a,c||goog.ui.MenuHeaderRenderer.getInstance(),b);this.setSupportedState(goog.ui.Component.State.DISABLED,!1);this.setSupportedState(goog.ui.Component.State.HOVER,!1);this.setSupportedState(goog.ui.Component.State.ACTIVE,!1);this.setSupportedState(goog.ui.Component.State.FOCUSED,!1);this.setStateInternal(goog.ui.Component.State.DISABLED)};goog.inherits(goog.ui.MenuHeader,goog.ui.Control);goog.ui.registry.setDecoratorByClassName(goog.ui.MenuHeaderRenderer.CSS_CLASS,function(){return new goog.ui.MenuHeader(null)});goog.ui.MenuItemRenderer=function(){goog.ui.ControlRenderer.call(this);this.classNameCache_=[]};goog.inherits(goog.ui.MenuItemRenderer,goog.ui.ControlRenderer);goog.addSingletonGetter(goog.ui.MenuItemRenderer);goog.ui.MenuItemRenderer.CSS_CLASS="goog-menuitem";goog.ui.MenuItemRenderer.CompositeCssClassIndex_={HOVER:0,CHECKBOX:1,CONTENT:2};goog.ui.MenuItemRenderer.prototype.getCompositeCssClass_=function(a){var b=this.classNameCache_[a];if(!b){switch(a){case goog.ui.MenuItemRenderer.CompositeCssClassIndex_.HOVER:b=this.getStructuralCssClass()+"-highlight";break;case goog.ui.MenuItemRenderer.CompositeCssClassIndex_.CHECKBOX:b=this.getStructuralCssClass()+"-checkbox";break;case goog.ui.MenuItemRenderer.CompositeCssClassIndex_.CONTENT:b=this.getStructuralCssClass()+"-content"}this.classNameCache_[a]=b}return b};goog.ui.MenuItemRenderer.prototype.getAriaRole=function(){return goog.a11y.aria.Role.MENU_ITEM};goog.ui.MenuItemRenderer.prototype.createDom=function(a){var b=a.getDomHelper().createDom("DIV",this.getClassNames(a).join(" "),this.createContent(a.getContent(),a.getDomHelper()));this.setEnableCheckBoxStructure(a,b,a.isSupportedState(goog.ui.Component.State.SELECTED)||a.isSupportedState(goog.ui.Component.State.CHECKED));
-return b};goog.ui.MenuItemRenderer.prototype.getContentElement=function(a){return a&&a.firstChild};goog.ui.MenuItemRenderer.prototype.decorate=function(a,b){goog.asserts.assert(b);this.hasContentStructure(b)||b.appendChild(this.createContent(b.childNodes,a.getDomHelper()));goog.dom.classlist.contains(b,"goog-option")&&(a.setCheckable(!0),this.setCheckable(a,b,!0));return goog.ui.MenuItemRenderer.superClass_.decorate.call(this,a,b)};goog.ui.MenuItemRenderer.prototype.setContent=function(a,b){var c=this.getContentElement(a),d=this.hasCheckBoxStructure(a)?c.firstChild:null;goog.ui.MenuItemRenderer.superClass_.setContent.call(this,a,b);d&&!this.hasCheckBoxStructure(a)&&c.insertBefore(d,c.firstChild||null)};goog.ui.MenuItemRenderer.prototype.hasContentStructure=function(a){a=goog.dom.getFirstElementChild(a);var b=this.getCompositeCssClass_(goog.ui.MenuItemRenderer.CompositeCssClassIndex_.CONTENT);return !!a&&goog.dom.classlist.contains(a,b)};goog.ui.MenuItemRenderer.prototype.createContent=function(a,b){var c=this.getCompositeCssClass_(goog.ui.MenuItemRenderer.CompositeCssClassIndex_.CONTENT);return b.createDom("DIV",c,a)};goog.ui.MenuItemRenderer.prototype.setSelectable=function(a,b,c){a&&b&&this.setEnableCheckBoxStructure(a,b,c)};goog.ui.MenuItemRenderer.prototype.setCheckable=function(a,b,c){a&&b&&this.setEnableCheckBoxStructure(a,b,c)};goog.ui.MenuItemRenderer.prototype.hasCheckBoxStructure=function(a){if(a=this.getContentElement(a)){a=a.firstChild;var b=this.getCompositeCssClass_(goog.ui.MenuItemRenderer.CompositeCssClassIndex_.CHECKBOX);return !!a&&goog.dom.isElement(a)&&goog.dom.classlist.contains(a,b)}return !1};goog.ui.MenuItemRenderer.prototype.setEnableCheckBoxStructure=function(a,b,c){this.setAriaRole(b,a.getPreferredAriaRole());this.setAriaStates(a,b);c!=this.hasCheckBoxStructure(b)&&(goog.dom.classlist.enable(b,"goog-option",c),b=this.getContentElement(b),c?(c=this.getCompositeCssClass_(goog.ui.MenuItemRenderer.CompositeCssClassIndex_.CHECKBOX),b.insertBefore(a.getDomHelper().createDom("DIV",c),b.firstChild||null)):b.removeChild(b.firstChild))
-};goog.ui.MenuItemRenderer.prototype.getClassForState=function(a){switch(a){case goog.ui.Component.State.HOVER:return this.getCompositeCssClass_(goog.ui.MenuItemRenderer.CompositeCssClassIndex_.HOVER);case goog.ui.Component.State.CHECKED:case goog.ui.Component.State.SELECTED:return"goog-option-selected";default:return goog.ui.MenuItemRenderer.superClass_.getClassForState.call(this,a)}};goog.ui.MenuItemRenderer.prototype.getStateFromClass=function(a){var b=this.getCompositeCssClass_(goog.ui.MenuItemRenderer.CompositeCssClassIndex_.HOVER);switch(a){case"goog-option-selected":return goog.ui.Component.State.CHECKED;case b:return goog.ui.Component.State.HOVER;default:return goog.ui.MenuItemRenderer.superClass_.getStateFromClass.call(this,a)}};goog.ui.MenuItemRenderer.prototype.getCssClass=function(){return goog.ui.MenuItemRenderer.CSS_CLASS};goog.ui.MenuItem=function(a,b,c,d){goog.ui.Control.call(this,a,d||goog.ui.MenuItemRenderer.getInstance(),c);this.setValue(b)};goog.inherits(goog.ui.MenuItem,goog.ui.Control);goog.tagUnsealableClass(goog.ui.MenuItem);goog.ui.MenuItem.MNEMONIC_WRAPPER_CLASS_="goog-menuitem-mnemonic-separator";goog.ui.MenuItem.ACCELERATOR_CLASS="goog-menuitem-accel";goog.ui.MenuItem.prototype.getValue=function(){var a=this.getModel();return null!=a?a:this.getCaption()};goog.ui.MenuItem.prototype.setValue=function(a){this.setModel(a)};goog.ui.MenuItem.prototype.setSupportedState=function(a,b){goog.ui.MenuItem.superClass_.setSupportedState.call(this,a,b);switch(a){case goog.ui.Component.State.SELECTED:this.setSelectableInternal_(b);break;case goog.ui.Component.State.CHECKED:this.setCheckableInternal_(b)}};goog.ui.MenuItem.prototype.setSelectable=function(a){this.setSupportedState(goog.ui.Component.State.SELECTED,a)};goog.ui.MenuItem.prototype.setSelectableInternal_=function(a){this.isChecked()&&!a&&this.setChecked(!1);var b=this.getElement();b&&this.getRenderer().setSelectable(this,b,a)};goog.ui.MenuItem.prototype.setCheckable=function(a){this.setSupportedState(goog.ui.Component.State.CHECKED,a)
-};goog.ui.MenuItem.prototype.setCheckableInternal_=function(a){var b=this.getElement();b&&this.getRenderer().setCheckable(this,b,a)};goog.ui.MenuItem.prototype.getCaption=function(){var a=this.getContent();if(goog.isArray(a)){var b=goog.ui.MenuItem.ACCELERATOR_CLASS,c=goog.ui.MenuItem.MNEMONIC_WRAPPER_CLASS_;a=goog.array.map(a,function(a){return goog.dom.isElement(a)&&(goog.dom.classlist.contains(a,b)||goog.dom.classlist.contains(a,c))?"":goog.dom.getRawTextContent(a)}).join("");return goog.string.collapseBreakingSpaces(a)}return goog.ui.MenuItem.superClass_.getCaption.call(this)};goog.ui.MenuItem.prototype.getAccelerator=function(){var a=this.getDomHelper(),b=this.getContent();return goog.isArray(b)&&(b=goog.array.find(b,function(a){return goog.dom.classlist.contains(a,goog.ui.MenuItem.ACCELERATOR_CLASS)}))?a.getTextContent(b):null};goog.ui.MenuItem.prototype.handleMouseUp=function(a){var b=this.getParent();if(b){var c=b.openingCoords;b.openingCoords=null;if(c&&goog.isNumber(a.clientX)&&(b=new goog.math.Coordinate(a.clientX,a.clientY),goog.math.Coordinate.equals(c,b))){return}}goog.ui.MenuItem.superClass_.handleMouseUp.call(this,a)};goog.ui.MenuItem.prototype.handleKeyEventInternal=function(a){return a.keyCode==this.getMnemonic()&&this.performActionInternal(a)?!0:goog.ui.MenuItem.superClass_.handleKeyEventInternal.call(this,a)};goog.ui.MenuItem.prototype.setMnemonic=function(a){this.mnemonicKey_=a};goog.ui.MenuItem.prototype.getMnemonic=function(){return this.mnemonicKey_};goog.ui.registry.setDecoratorByClassName(goog.ui.MenuItemRenderer.CSS_CLASS,function(){return new goog.ui.MenuItem(null)});goog.ui.MenuItem.prototype.getPreferredAriaRole=function(){return this.isSupportedState(goog.ui.Component.State.CHECKED)?goog.a11y.aria.Role.MENU_ITEM_CHECKBOX:this.isSupportedState(goog.ui.Component.State.SELECTED)?goog.a11y.aria.Role.MENU_ITEM_RADIO:goog.ui.MenuItem.superClass_.getPreferredAriaRole.call(this)};goog.ui.MenuItem.prototype.getParent=function(){return goog.ui.Control.prototype.getParent.call(this)
-};goog.ui.MenuItem.prototype.getParentEventTarget=function(){return goog.ui.Control.prototype.getParentEventTarget.call(this)};goog.ui.MenuSeparatorRenderer=function(){goog.ui.ControlRenderer.call(this)};goog.inherits(goog.ui.MenuSeparatorRenderer,goog.ui.ControlRenderer);goog.addSingletonGetter(goog.ui.MenuSeparatorRenderer);goog.ui.MenuSeparatorRenderer.CSS_CLASS="goog-menuseparator";goog.ui.MenuSeparatorRenderer.prototype.createDom=function(a){return a.getDomHelper().createDom("DIV",this.getCssClass())};goog.ui.MenuSeparatorRenderer.prototype.decorate=function(a,b){b.id&&a.setId(b.id);if("HR"==b.tagName){var c=b;b=this.createDom(a);goog.dom.insertSiblingBefore(b,c);goog.dom.removeNode(c)}else{goog.dom.classlist.add(b,this.getCssClass())}return b};goog.ui.MenuSeparatorRenderer.prototype.setContent=function(a,b){};goog.ui.MenuSeparatorRenderer.prototype.getCssClass=function(){return goog.ui.MenuSeparatorRenderer.CSS_CLASS};goog.ui.Separator=function(a,b){goog.ui.Control.call(this,null,a||goog.ui.MenuSeparatorRenderer.getInstance(),b);this.setSupportedState(goog.ui.Component.State.DISABLED,!1);this.setSupportedState(goog.ui.Component.State.HOVER,!1);this.setSupportedState(goog.ui.Component.State.ACTIVE,!1);this.setSupportedState(goog.ui.Component.State.FOCUSED,!1);this.setStateInternal(goog.ui.Component.State.DISABLED)};goog.inherits(goog.ui.Separator,goog.ui.Control);goog.ui.Separator.prototype.enterDocument=function(){goog.ui.Separator.superClass_.enterDocument.call(this);var a=this.getElement();goog.asserts.assert(a,"The DOM element for the separator cannot be null.");goog.a11y.aria.setRole(a,"separator")};goog.ui.registry.setDecoratorByClassName(goog.ui.MenuSeparatorRenderer.CSS_CLASS,function(){return new goog.ui.Separator});goog.ui.MenuRenderer=function(a){goog.ui.ContainerRenderer.call(this,a||goog.a11y.aria.Role.MENU)};goog.inherits(goog.ui.MenuRenderer,goog.ui.ContainerRenderer);goog.addSingletonGetter(goog.ui.MenuRenderer);goog.ui.MenuRenderer.CSS_CLASS="goog-menu";
-goog.ui.MenuRenderer.prototype.canDecorate=function(a){return"UL"==a.tagName||goog.ui.MenuRenderer.superClass_.canDecorate.call(this,a)};goog.ui.MenuRenderer.prototype.getDecoratorForChild=function(a){return"HR"==a.tagName?new goog.ui.Separator:goog.ui.MenuRenderer.superClass_.getDecoratorForChild.call(this,a)};goog.ui.MenuRenderer.prototype.containsElement=function(a,b){return goog.dom.contains(a.getElement(),b)};goog.ui.MenuRenderer.prototype.getCssClass=function(){return goog.ui.MenuRenderer.CSS_CLASS};goog.ui.MenuRenderer.prototype.initializeDom=function(a){goog.ui.MenuRenderer.superClass_.initializeDom.call(this,a);a=a.getElement();goog.asserts.assert(a,"The menu DOM element cannot be null.");goog.a11y.aria.setState(a,goog.a11y.aria.State.HASPOPUP,"true")};goog.ui.MenuSeparator=function(a){goog.ui.Separator.call(this,goog.ui.MenuSeparatorRenderer.getInstance(),a)};goog.inherits(goog.ui.MenuSeparator,goog.ui.Separator);goog.ui.registry.setDecoratorByClassName(goog.ui.MenuSeparatorRenderer.CSS_CLASS,function(){return new goog.ui.Separator});goog.ui.Menu=function(a,b){goog.ui.Container.call(this,goog.ui.Container.Orientation.VERTICAL,b||goog.ui.MenuRenderer.getInstance(),a);this.setFocusable(!1)};goog.inherits(goog.ui.Menu,goog.ui.Container);goog.tagUnsealableClass(goog.ui.Menu);goog.ui.Menu.EventType={BEFORE_SHOW:goog.ui.Component.EventType.BEFORE_SHOW,SHOW:goog.ui.Component.EventType.SHOW,BEFORE_HIDE:goog.ui.Component.EventType.HIDE,HIDE:goog.ui.Component.EventType.HIDE};goog.ui.Menu.CSS_CLASS=goog.ui.MenuRenderer.CSS_CLASS;goog.ui.Menu.prototype.allowAutoFocus_=!0;goog.ui.Menu.prototype.allowHighlightDisabled_=!1;goog.ui.Menu.prototype.getCssClass=function(){return this.getRenderer().getCssClass()};goog.ui.Menu.prototype.containsElement=function(a){if(this.getRenderer().containsElement(this,a)){return !0}for(var b=0,c=this.getChildCount();b<c;b++){var d=this.getChildAt(b);if("function"==typeof d.containsElement&&d.containsElement(a)){return !0}}return !1};goog.ui.Menu.prototype.addItem=function(a){this.addChild(a,!0)
-};goog.ui.Menu.prototype.addItemAt=function(a,b){this.addChildAt(a,b,!0)};goog.ui.Menu.prototype.removeItem=function(a){(a=this.removeChild(a,!0))&&a.dispose()};goog.ui.Menu.prototype.removeItemAt=function(a){(a=this.removeChildAt(a,!0))&&a.dispose()};goog.ui.Menu.prototype.getItemAt=function(a){return this.getChildAt(a)};goog.ui.Menu.prototype.getItemCount=function(){return this.getChildCount()};goog.ui.Menu.prototype.getItems=function(){var a=[];this.forEachChild(function(b){a.push(b)});return a};goog.ui.Menu.prototype.setPosition=function(a,b){var c=this.isVisible();c||goog.style.setElementShown(this.getElement(),!0);goog.style.setPageOffset(this.getElement(),a,b);c||goog.style.setElementShown(this.getElement(),!1)};goog.ui.Menu.prototype.getPosition=function(){return this.isVisible()?goog.style.getPageOffset(this.getElement()):null};goog.ui.Menu.prototype.setAllowAutoFocus=function(a){(this.allowAutoFocus_=a)&&this.setFocusable(!0)};goog.ui.Menu.prototype.getAllowAutoFocus=function(){return this.allowAutoFocus_};goog.ui.Menu.prototype.setAllowHighlightDisabled=function(a){this.allowHighlightDisabled_=a};goog.ui.Menu.prototype.getAllowHighlightDisabled=function(){return this.allowHighlightDisabled_};goog.ui.Menu.prototype.setVisible=function(a,b,c){(b=goog.ui.Menu.superClass_.setVisible.call(this,a,b))&&a&&this.isInDocument()&&this.allowAutoFocus_&&this.getKeyEventTarget().focus();a&&c&&goog.isNumber(c.clientX)?this.openingCoords=new goog.math.Coordinate(c.clientX,c.clientY):this.openingCoords=null;return b};goog.ui.Menu.prototype.handleEnterItem=function(a){this.allowAutoFocus_&&this.getKeyEventTarget().focus();return goog.ui.Menu.superClass_.handleEnterItem.call(this,a)};goog.ui.Menu.prototype.highlightNextPrefix=function(a){var b=new RegExp("^"+goog.string.regExpEscape(a),"i");return this.highlightHelper(function(a,d){var c=0>a?0:a,f=!1;do{++a;a==d&&(a=0,f=!0);var g=this.getChildAt(a).getCaption();if(g&&g.match(b)){return a}}while(!f||a!=c);return this.getHighlightedIndex()
-},this.getHighlightedIndex())};goog.ui.Menu.prototype.canHighlightItem=function(a){return(this.allowHighlightDisabled_||a.isEnabled())&&a.isVisible()&&a.isSupportedState(goog.ui.Component.State.HOVER)};goog.ui.Menu.prototype.decorateInternal=function(a){this.decorateContent(a);goog.ui.Menu.superClass_.decorateInternal.call(this,a)};goog.ui.Menu.prototype.handleKeyEventInternal=function(a){var b=goog.ui.Menu.superClass_.handleKeyEventInternal.call(this,a);b||this.forEachChild(function(c){!b&&c.getMnemonic&&c.getMnemonic()==a.keyCode&&(this.isEnabled()&&this.setHighlighted(c),b=c.handleKeyEvent(a))},this);return b};goog.ui.Menu.prototype.setHighlightedIndex=function(a){goog.ui.Menu.superClass_.setHighlightedIndex.call(this,a);(a=this.getChildAt(a))&&goog.style.scrollIntoContainerView(a.getElement(),this.getElement())};goog.ui.Menu.prototype.decorateContent=function(a){var b=this.getRenderer();a=this.getDomHelper().getElementsByTagNameAndClass("DIV",b.getCssClass()+"-content",a);for(var c=a.length,d=0;d<c;d++){b.decorateChildren(this,a[d])}};goog.iter={};goog.iter.StopIteration="StopIteration" in goog.global?goog.global.StopIteration:{message:"StopIteration",stack:""};goog.iter.Iterator=function(){};goog.iter.Iterator.prototype.next=function(){throw goog.iter.StopIteration};goog.iter.Iterator.prototype.__iterator__=function(a){return this};goog.iter.toIterator=function(a){if(a instanceof goog.iter.Iterator){return a}if("function"==typeof a.__iterator__){return a.__iterator__(!1)}if(goog.isArrayLike(a)){var b=0,c=new goog.iter.Iterator;c.next=function(){for(;;){if(b>=a.length){throw goog.iter.StopIteration}if(b in a){return a[b++]}b++}};return c}throw Error("Not implemented")};goog.iter.forEach=function(a,b,c){if(goog.isArrayLike(a)){try{goog.array.forEach(a,b,c)}catch(d){if(d!==goog.iter.StopIteration){throw d}}}else{a=goog.iter.toIterator(a);try{for(;;){b.call(c,a.next(),void 0,a)}}catch(d){if(d!==goog.iter.StopIteration){throw d}}}};goog.iter.filter=function(a,b,c){var d=goog.iter.toIterator(a);
-a=new goog.iter.Iterator;a.next=function(){for(;;){var a=d.next();if(b.call(c,a,void 0,d)){return a}}};return a};goog.iter.filterFalse=function(a,b,c){return goog.iter.filter(a,goog.functions.not(b),c)};goog.iter.range=function(a,b,c){var d=0,e=a,f=c||1;1<arguments.length&&(d=a,e=b);if(0==f){throw Error("Range step argument must not be zero")}var g=new goog.iter.Iterator;g.next=function(){if(0<f&&d>=e||0>f&&d<=e){throw goog.iter.StopIteration}var a=d;d+=f;return a};return g};goog.iter.join=function(a,b){return goog.iter.toArray(a).join(b)};goog.iter.map=function(a,b,c){var d=goog.iter.toIterator(a);a=new goog.iter.Iterator;a.next=function(){var a=d.next();return b.call(c,a,void 0,d)};return a};goog.iter.reduce=function(a,b,c,d){var e=c;goog.iter.forEach(a,function(a){e=b.call(d,e,a)});return e};goog.iter.some=function(a,b,c){a=goog.iter.toIterator(a);try{for(;;){if(b.call(c,a.next(),void 0,a)){return !0}}}catch(d){if(d!==goog.iter.StopIteration){throw d}}return !1};goog.iter.every=function(a,b,c){a=goog.iter.toIterator(a);try{for(;;){if(!b.call(c,a.next(),void 0,a)){return !1}}}catch(d){if(d!==goog.iter.StopIteration){throw d}}return !0};goog.iter.chain=function(a){return goog.iter.chainFromIterable(arguments)};goog.iter.chainFromIterable=function(a){var b=goog.iter.toIterator(a);a=new goog.iter.Iterator;var c=null;a.next=function(){for(;;){if(null==c){var a=b.next();c=goog.iter.toIterator(a)}try{return c.next()}catch(e){if(e!==goog.iter.StopIteration){throw e}c=null}}};return a};goog.iter.dropWhile=function(a,b,c){var d=goog.iter.toIterator(a);a=new goog.iter.Iterator;var e=!0;a.next=function(){for(;;){var a=d.next();if(!e||!b.call(c,a,void 0,d)){return e=!1,a}}};return a};goog.iter.takeWhile=function(a,b,c){var d=goog.iter.toIterator(a);a=new goog.iter.Iterator;a.next=function(){var a=d.next();if(b.call(c,a,void 0,d)){return a}throw goog.iter.StopIteration};return a};goog.iter.toArray=function(a){if(goog.isArrayLike(a)){return goog.array.toArray(a)}a=goog.iter.toIterator(a);
-var b=[];goog.iter.forEach(a,function(a){b.push(a)});return b};goog.iter.equals=function(a,b,c){a=goog.iter.zipLongest({},a,b);var d=c||goog.array.defaultCompareEquality;return goog.iter.every(a,function(a){return d(a[0],a[1])})};goog.iter.nextOrValue=function(a,b){try{return goog.iter.toIterator(a).next()}catch(c){if(c!=goog.iter.StopIteration){throw c}return b}};goog.iter.product=function(a){if(goog.array.some(arguments,function(a){return !a.length})||!arguments.length){return new goog.iter.Iterator}var b=new goog.iter.Iterator,c=arguments,d=goog.array.repeat(0,c.length);b.next=function(){if(d){for(var a=goog.array.map(d,function(a,b){return c[b][a]}),b=d.length-1;0<=b;b--){goog.asserts.assert(d);if(d[b]<c[b].length-1){d[b]++;break}if(0==b){d=null;break}d[b]=0}return a}throw goog.iter.StopIteration};return b};goog.iter.cycle=function(a){var b=goog.iter.toIterator(a),c=[],d=0;a=new goog.iter.Iterator;var e=!1;a.next=function(){var a=null;if(!e){try{return a=b.next(),c.push(a),a}catch(g){if(g!=goog.iter.StopIteration||goog.array.isEmpty(c)){throw g}e=!0}}a=c[d];d=(d+1)%c.length;return a};return a};goog.iter.count=function(a,b){var c=a||0,d=goog.isDef(b)?b:1,e=new goog.iter.Iterator;e.next=function(){var a=c;c+=d;return a};return e};goog.iter.repeat=function(a){var b=new goog.iter.Iterator;b.next=goog.functions.constant(a);return b};goog.iter.accumulate=function(a){var b=goog.iter.toIterator(a),c=0;a=new goog.iter.Iterator;a.next=function(){return c+=b.next()};return a};goog.iter.zip=function(a){var b=arguments,c=new goog.iter.Iterator;if(0<b.length){var d=goog.array.map(b,goog.iter.toIterator);c.next=function(){return goog.array.map(d,function(a){return a.next()})}}return c};goog.iter.zipLongest=function(a,b){var c=goog.array.slice(arguments,1),d=new goog.iter.Iterator;if(0<c.length){var e=goog.array.map(c,goog.iter.toIterator);d.next=function(){var b=!1,c=goog.array.map(e,function(c){try{var d=c.next();b=!0}catch(n){if(n!==goog.iter.StopIteration){throw n}d=a}return d
-});if(!b){throw goog.iter.StopIteration}return c}}return d};goog.iter.compress=function(a,b){var c=goog.iter.toIterator(b);return goog.iter.filter(a,function(){return !!c.next()})};goog.iter.GroupByIterator_=function(a,b){this.iterator=goog.iter.toIterator(a);this.keyFunc=b||goog.functions.identity};goog.inherits(goog.iter.GroupByIterator_,goog.iter.Iterator);goog.iter.GroupByIterator_.prototype.next=function(){for(;this.currentKey==this.targetKey;){this.currentValue=this.iterator.next(),this.currentKey=this.keyFunc(this.currentValue)}this.targetKey=this.currentKey;return[this.currentKey,this.groupItems_(this.targetKey)]};goog.iter.GroupByIterator_.prototype.groupItems_=function(a){for(var b=[];this.currentKey==a;){b.push(this.currentValue);try{this.currentValue=this.iterator.next()}catch(c){if(c!==goog.iter.StopIteration){throw c}break}this.currentKey=this.keyFunc(this.currentValue)}return b};goog.iter.groupBy=function(a,b){return new goog.iter.GroupByIterator_(a,b)};goog.iter.starMap=function(a,b,c){var d=goog.iter.toIterator(a);a=new goog.iter.Iterator;a.next=function(){var a=goog.iter.toArray(d.next());return b.apply(c,goog.array.concat(a,void 0,d))};return a};goog.iter.tee=function(a,b){var c=goog.iter.toIterator(a),d=goog.isNumber(b)?b:2,e=goog.array.map(goog.array.range(d),function(){return[]}),f=function(){var a=c.next();goog.array.forEach(e,function(b){b.push(a)})};return goog.array.map(e,function(a){var b=new goog.iter.Iterator;b.next=function(){goog.array.isEmpty(a)&&f();goog.asserts.assert(!goog.array.isEmpty(a));return a.shift()};return b})};goog.iter.enumerate=function(a,b){return goog.iter.zip(goog.iter.count(b),a)};goog.iter.limit=function(a,b){goog.asserts.assert(goog.math.isInt(b)&&0<=b);var c=goog.iter.toIterator(a),d=new goog.iter.Iterator,e=b;d.next=function(){if(0<e--){return c.next()}throw goog.iter.StopIteration};return d};goog.iter.consume=function(a,b){goog.asserts.assert(goog.math.isInt(b)&&0<=b);for(var c=goog.iter.toIterator(a);0<b--;){goog.iter.nextOrValue(c,null)
-}return c};goog.iter.slice=function(a,b,c){goog.asserts.assert(goog.math.isInt(b)&&0<=b);a=goog.iter.consume(a,b);goog.isNumber(c)&&(goog.asserts.assert(goog.math.isInt(c)&&c>=b),a=goog.iter.limit(a,c-b));return a};goog.iter.hasDuplicates_=function(a){var b=[];goog.array.removeDuplicates(a,b);return a.length!=b.length};goog.iter.permutations=function(a,b){var c=goog.iter.toArray(a),d=goog.isNumber(b)?b:c.length;c=goog.array.repeat(c,d);c=goog.iter.product.apply(void 0,c);return goog.iter.filter(c,function(a){return !goog.iter.hasDuplicates_(a)})};goog.iter.combinations=function(a,b){function c(a){return d[a]}var d=goog.iter.toArray(a),e=goog.iter.range(d.length);e=goog.iter.permutations(e,b);var f=goog.iter.filter(e,function(a){return goog.array.isSorted(a)});e=new goog.iter.Iterator;e.next=function(){return goog.array.map(f.next(),c)};return e};goog.iter.combinationsWithReplacement=function(a,b){function c(a){return d[a]}var d=goog.iter.toArray(a),e=goog.array.range(d.length);e=goog.array.repeat(e,b);e=goog.iter.product.apply(void 0,e);var f=goog.iter.filter(e,function(a){return goog.array.isSorted(a)});e=new goog.iter.Iterator;e.next=function(){return goog.array.map(f.next(),c)};return e};goog.dom.TagWalkType={START_TAG:1,OTHER:0,END_TAG:-1};goog.dom.TagIterator=function(a,b,c,d,e){this.reversed=!!b;this.node=null;this.tagType=goog.dom.TagWalkType.OTHER;this.started_=!1;this.constrained=!c;a&&this.setPosition(a,d);this.depth=void 0!=e?e:this.tagType||0;this.reversed&&(this.depth*=-1)};goog.inherits(goog.dom.TagIterator,goog.iter.Iterator);goog.dom.TagIterator.prototype.setPosition=function(a,b,c){if(this.node=a){goog.isNumber(b)?this.tagType=b:this.tagType=this.node.nodeType!=goog.dom.NodeType.ELEMENT?goog.dom.TagWalkType.OTHER:this.reversed?goog.dom.TagWalkType.END_TAG:goog.dom.TagWalkType.START_TAG}goog.isNumber(c)&&(this.depth=c)};goog.dom.TagIterator.prototype.copyFrom=function(a){this.node=a.node;this.tagType=a.tagType;this.depth=a.depth;this.reversed=a.reversed;
-this.constrained=a.constrained};goog.dom.TagIterator.prototype.clone=function(){return new goog.dom.TagIterator(this.node,this.reversed,!this.constrained,this.tagType,this.depth)};goog.dom.TagIterator.prototype.skipTag=function(){var a=this.reversed?goog.dom.TagWalkType.END_TAG:goog.dom.TagWalkType.START_TAG;this.tagType==a&&(this.tagType=-1*a,this.depth+=this.tagType*(this.reversed?-1:1))};goog.dom.TagIterator.prototype.restartTag=function(){var a=this.reversed?goog.dom.TagWalkType.START_TAG:goog.dom.TagWalkType.END_TAG;this.tagType==a&&(this.tagType=-1*a,this.depth+=this.tagType*(this.reversed?-1:1))};goog.dom.TagIterator.prototype.next=function(){if(this.started_){if(!this.node||this.constrained&&0==this.depth){throw goog.iter.StopIteration}var a=this.node;var b=this.reversed?goog.dom.TagWalkType.END_TAG:goog.dom.TagWalkType.START_TAG;if(this.tagType==b){var c=this.reversed?a.lastChild:a.firstChild;c?this.setPosition(c):this.setPosition(a,-1*b)}else{(c=this.reversed?a.previousSibling:a.nextSibling)?this.setPosition(c):this.setPosition(a.parentNode,-1*b)}this.depth+=this.tagType*(this.reversed?-1:1)}else{this.started_=!0}a=this.node;if(!this.node){throw goog.iter.StopIteration}return a};goog.dom.TagIterator.prototype.isStarted=function(){return this.started_};goog.dom.TagIterator.prototype.isStartTag=function(){return this.tagType==goog.dom.TagWalkType.START_TAG};goog.dom.TagIterator.prototype.isEndTag=function(){return this.tagType==goog.dom.TagWalkType.END_TAG};goog.dom.TagIterator.prototype.isNonElement=function(){return this.tagType==goog.dom.TagWalkType.OTHER};goog.dom.TagIterator.prototype.equals=function(a){return a.node==this.node&&(!this.node||a.tagType==this.tagType)};goog.dom.TagIterator.prototype.splice=function(a){var b=this.node;this.restartTag();this.reversed=!this.reversed;goog.dom.TagIterator.prototype.next.call(this);this.reversed=!this.reversed;for(var c=goog.isArrayLike(arguments[0])?arguments[0]:arguments,d=c.length-1;0<=d;d--){goog.dom.insertSiblingAfter(c[d],b)
-}goog.dom.removeNode(b)};goog.dom.NodeIterator=function(a,b,c,d){goog.dom.TagIterator.call(this,a,b,c,null,d)};goog.inherits(goog.dom.NodeIterator,goog.dom.TagIterator);goog.dom.NodeIterator.prototype.next=function(){do{goog.dom.NodeIterator.superClass_.next.call(this)}while(this.isEndTag());return this.node};goog.ui.PaletteRenderer=function(){goog.ui.ControlRenderer.call(this)};goog.inherits(goog.ui.PaletteRenderer,goog.ui.ControlRenderer);goog.addSingletonGetter(goog.ui.PaletteRenderer);goog.ui.PaletteRenderer.cellId_=0;goog.ui.PaletteRenderer.CSS_CLASS="goog-palette";goog.ui.PaletteRenderer.prototype.createDom=function(a){var b=this.getClassNames(a);a=a.getDomHelper().createDom("DIV",b,this.createGrid(a.getContent(),a.getSize(),a.getDomHelper()));goog.a11y.aria.setRole(a,goog.a11y.aria.Role.GRID);return a};goog.ui.PaletteRenderer.prototype.createGrid=function(a,b,c){for(var d=[],e=0,f=0;e<b.height;e++){for(var g=[],h=0;h<b.width;h++){var k=a&&a[f++];g.push(this.createCell(k,c))}d.push(this.createRow(g,c))}return this.createTable(d,c)};goog.ui.PaletteRenderer.prototype.createTable=function(a,b){var c=b.createDom("TABLE",this.getCssClass()+"-table",b.createDom("TBODY",this.getCssClass()+"-body",a));c.cellSpacing="0";c.cellPadding="0";return c};goog.ui.PaletteRenderer.prototype.createRow=function(a,b){var c=b.createDom("TR",this.getCssClass()+"-row",a);goog.a11y.aria.setRole(c,goog.a11y.aria.Role.ROW);return c};goog.ui.PaletteRenderer.prototype.createCell=function(a,b){var c=b.createDom("TD",{"class":this.getCssClass()+"-cell",id:this.getCssClass()+"-cell-"+goog.ui.PaletteRenderer.cellId_++},a);goog.a11y.aria.setRole(c,goog.a11y.aria.Role.GRIDCELL);goog.a11y.aria.setState(c,goog.a11y.aria.State.SELECTED,!1);if(!goog.dom.getTextContent(c)&&!goog.a11y.aria.getLabel(c)){var d=this.findAriaLabelForCell_(c);d&&goog.a11y.aria.setLabel(c,d)}return c};goog.ui.PaletteRenderer.prototype.findAriaLabelForCell_=function(a){a=new goog.dom.NodeIterator(a);for(var b="",c;!b&&(c=goog.iter.nextOrValue(a,null));
-){c.nodeType==goog.dom.NodeType.ELEMENT&&(b=goog.a11y.aria.getLabel(c)||c.title)}return b};goog.ui.PaletteRenderer.prototype.canDecorate=function(a){return !1};goog.ui.PaletteRenderer.prototype.decorate=function(a,b){return null};goog.ui.PaletteRenderer.prototype.setContent=function(a,b){if(a){var c=goog.dom.getElementsByTagNameAndClass("TBODY",this.getCssClass()+"-body",a)[0];if(c){var d=0;goog.array.forEach(c.rows,function(a){goog.array.forEach(a.cells,function(a){goog.dom.removeChildren(a);if(b){var c=b[d++];c&&goog.dom.appendChild(a,c)}})});if(d<b.length){for(var e=[],f=goog.dom.getDomHelper(a),g=c.rows[0].cells.length;d<b.length;){var h=b[d++];e.push(this.createCell(h,f));e.length==g&&(h=this.createRow(e,f),goog.dom.appendChild(c,h),e.length=0)}if(0<e.length){for(;e.length<g;){e.push(this.createCell("",f))}h=this.createRow(e,f);goog.dom.appendChild(c,h)}}}goog.style.setUnselectable(a,!0,goog.userAgent.GECKO)}};goog.ui.PaletteRenderer.prototype.getContainingItem=function(a,b){for(var c=a.getElement();b&&b.nodeType==goog.dom.NodeType.ELEMENT&&b!=c;){if("TD"==b.tagName&&goog.dom.classlist.contains(b,this.getCssClass()+"-cell")){return b.firstChild}b=b.parentNode}return null};goog.ui.PaletteRenderer.prototype.highlightCell=function(a,b,c){b&&(b=this.getCellForItem(b),goog.asserts.assert(b),goog.dom.classlist.enable(b,this.getCssClass()+"-cell-hover",c),c?goog.a11y.aria.setState(a.getElementStrict(),goog.a11y.aria.State.ACTIVEDESCENDANT,b.id):b.id==goog.a11y.aria.getState(a.getElementStrict(),goog.a11y.aria.State.ACTIVEDESCENDANT)&&goog.a11y.aria.removeState(a.getElementStrict(),goog.a11y.aria.State.ACTIVEDESCENDANT))};goog.ui.PaletteRenderer.prototype.getCellForItem=function(a){return a?a.parentNode:null};goog.ui.PaletteRenderer.prototype.selectCell=function(a,b,c){b&&(a=b.parentNode,goog.dom.classlist.enable(a,this.getCssClass()+"-cell-selected",c),goog.a11y.aria.setState(a,goog.a11y.aria.State.SELECTED,c))};goog.ui.PaletteRenderer.prototype.getCssClass=function(){return goog.ui.PaletteRenderer.CSS_CLASS
-};goog.ui.SelectionModel=function(a){goog.events.EventTarget.call(this);this.items_=[];this.addItems(a)};goog.inherits(goog.ui.SelectionModel,goog.events.EventTarget);goog.tagUnsealableClass(goog.ui.SelectionModel);goog.ui.SelectionModel.prototype.selectedItem_=null;goog.ui.SelectionModel.prototype.selectionHandler_=null;goog.ui.SelectionModel.prototype.getSelectionHandler=function(){return this.selectionHandler_};goog.ui.SelectionModel.prototype.setSelectionHandler=function(a){this.selectionHandler_=a};goog.ui.SelectionModel.prototype.getItemCount=function(){return this.items_.length};goog.ui.SelectionModel.prototype.indexOfItem=function(a){return a?goog.array.indexOf(this.items_,a):-1};goog.ui.SelectionModel.prototype.getFirst=function(){return this.items_[0]};goog.ui.SelectionModel.prototype.getLast=function(){return this.items_[this.items_.length-1]};goog.ui.SelectionModel.prototype.getItemAt=function(a){return this.items_[a]||null};goog.ui.SelectionModel.prototype.addItems=function(a){a&&(goog.array.forEach(a,function(a){this.selectItem_(a,!1)},this),goog.array.extend(this.items_,a))};goog.ui.SelectionModel.prototype.addItem=function(a){this.addItemAt(a,this.getItemCount())};goog.ui.SelectionModel.prototype.addItemAt=function(a,b){a&&(this.selectItem_(a,!1),goog.array.insertAt(this.items_,a,b))};goog.ui.SelectionModel.prototype.removeItem=function(a){a&&goog.array.remove(this.items_,a)&&a==this.selectedItem_&&(this.selectedItem_=null,this.dispatchEvent(goog.events.EventType.SELECT))};goog.ui.SelectionModel.prototype.removeItemAt=function(a){this.removeItem(this.getItemAt(a))};goog.ui.SelectionModel.prototype.getSelectedItem=function(){return this.selectedItem_};goog.ui.SelectionModel.prototype.getItems=function(){return goog.array.clone(this.items_)};goog.ui.SelectionModel.prototype.setSelectedItem=function(a){a!=this.selectedItem_&&(this.selectItem_(this.selectedItem_,!1),this.selectedItem_=a,this.selectItem_(a,!0));this.dispatchEvent(goog.events.EventType.SELECT)
-};goog.ui.SelectionModel.prototype.getSelectedIndex=function(){return this.indexOfItem(this.selectedItem_)};goog.ui.SelectionModel.prototype.setSelectedIndex=function(a){this.setSelectedItem(this.getItemAt(a))};goog.ui.SelectionModel.prototype.clear=function(){goog.array.clear(this.items_);this.selectedItem_=null};goog.ui.SelectionModel.prototype.disposeInternal=function(){goog.ui.SelectionModel.superClass_.disposeInternal.call(this);delete this.items_;this.selectedItem_=null};goog.ui.SelectionModel.prototype.selectItem_=function(a,b){a&&("function"==typeof this.selectionHandler_?this.selectionHandler_(a,b):"function"==typeof a.setSelected&&a.setSelected(b))};goog.ui.Palette=function(a,b,c){goog.ui.Control.call(this,a,b||goog.ui.PaletteRenderer.getInstance(),c);this.setAutoStates(goog.ui.Component.State.CHECKED|goog.ui.Component.State.SELECTED|goog.ui.Component.State.OPENED,!1);this.currentCellControl_=new goog.ui.Palette.CurrentCell_;this.currentCellControl_.setParentEventTarget(this);this.lastHighlightedIndex_=-1};goog.inherits(goog.ui.Palette,goog.ui.Control);goog.tagUnsealableClass(goog.ui.Palette);goog.ui.Palette.EventType={AFTER_HIGHLIGHT:goog.events.getUniqueId("afterhighlight")};goog.ui.Palette.prototype.size_=null;goog.ui.Palette.prototype.highlightedIndex_=-1;goog.ui.Palette.prototype.selectionModel_=null;goog.ui.Palette.prototype.disposeInternal=function(){goog.ui.Palette.superClass_.disposeInternal.call(this);this.selectionModel_&&(this.selectionModel_.dispose(),this.selectionModel_=null);this.size_=null;this.currentCellControl_.dispose()};goog.ui.Palette.prototype.setContentInternal=function(a){goog.ui.Palette.superClass_.setContentInternal.call(this,a);this.adjustSize_();this.selectionModel_?(this.selectionModel_.clear(),this.selectionModel_.addItems(a)):(this.selectionModel_=new goog.ui.SelectionModel(a),this.selectionModel_.setSelectionHandler(goog.bind(this.selectItem_,this)),this.getHandler().listen(this.selectionModel_,goog.events.EventType.SELECT,this.handleSelectionChange));
-this.highlightedIndex_=-1};goog.ui.Palette.prototype.getCaption=function(){return""};goog.ui.Palette.prototype.setCaption=function(a){};goog.ui.Palette.prototype.handleMouseOver=function(a){goog.ui.Palette.superClass_.handleMouseOver.call(this,a);var b=this.getRenderer().getContainingItem(this,a.target);b&&a.relatedTarget&&goog.dom.contains(b,a.relatedTarget)||b!=this.getHighlightedItem()&&this.setHighlightedItem(b)};goog.ui.Palette.prototype.handleMouseDown=function(a){goog.ui.Palette.superClass_.handleMouseDown.call(this,a);this.isActive()&&(a=this.getRenderer().getContainingItem(this,a.target),a!=this.getHighlightedItem()&&this.setHighlightedItem(a))};goog.ui.Palette.prototype.performActionInternal=function(a){var b=this.getHighlightedItem();return b?(a&&this.shouldSelectHighlightedItem_(a)&&this.setSelectedItem(b),goog.ui.Palette.superClass_.performActionInternal.call(this,a)):!1};goog.ui.Palette.prototype.shouldSelectHighlightedItem_=function(a){return this.getSelectedItem()?"mouseup"!=a.type?!0:!!this.getRenderer().getContainingItem(this,a.target):!0};goog.ui.Palette.prototype.handleKeyEvent=function(a){var b=this.getContent();b=b?b.length:0;var c=this.size_.width;if(0==b||!this.isEnabled()){return !1}if(a.keyCode==goog.events.KeyCodes.ENTER||a.keyCode==goog.events.KeyCodes.SPACE){return this.performActionInternal(a)}if(a.keyCode==goog.events.KeyCodes.HOME){return this.setHighlightedIndex(0),!0}if(a.keyCode==goog.events.KeyCodes.END){return this.setHighlightedIndex(b-1),!0}var d=0>this.highlightedIndex_?this.getSelectedIndex():this.highlightedIndex_;switch(a.keyCode){case goog.events.KeyCodes.LEFT:if(-1==d||0==d){d=b}this.setHighlightedIndex(d-1);a.preventDefault();return !0;case goog.events.KeyCodes.RIGHT:return d==b-1&&(d=-1),this.setHighlightedIndex(d+1),a.preventDefault(),!0;case goog.events.KeyCodes.UP:-1==d&&(d=b+c-1);if(d>=c){return this.setHighlightedIndex(d-c),a.preventDefault(),!0}break;case goog.events.KeyCodes.DOWN:if(-1==d&&(d=-c),d<b-c){return this.setHighlightedIndex(d+c),a.preventDefault(),!0
-}}return !1};goog.ui.Palette.prototype.handleSelectionChange=function(a){};goog.ui.Palette.prototype.getSize=function(){return this.size_};goog.ui.Palette.prototype.setSize=function(a,b){if(this.getElement()){throw Error(goog.ui.Component.Error.ALREADY_RENDERED)}this.size_=goog.isNumber(a)?new goog.math.Size(a,b):a;this.adjustSize_()};goog.ui.Palette.prototype.getHighlightedIndex=function(){return this.highlightedIndex_};goog.ui.Palette.prototype.getHighlightedItem=function(){var a=this.getContent();return a&&a[this.highlightedIndex_]};goog.ui.Palette.prototype.getHighlightedCellElement_=function(){return this.getRenderer().getCellForItem(this.getHighlightedItem())};goog.ui.Palette.prototype.setHighlightedIndex=function(a){a!=this.highlightedIndex_&&(this.highlightIndex_(this.highlightedIndex_,!1),this.lastHighlightedIndex_=this.highlightedIndex_,this.highlightedIndex_=a,this.highlightIndex_(a,!0),this.dispatchEvent(goog.ui.Palette.EventType.AFTER_HIGHLIGHT))};goog.ui.Palette.prototype.setHighlightedItem=function(a){var b=this.getContent();this.setHighlightedIndex(b&&a?goog.array.indexOf(b,a):-1)};goog.ui.Palette.prototype.getSelectedIndex=function(){return this.selectionModel_?this.selectionModel_.getSelectedIndex():-1};goog.ui.Palette.prototype.getSelectedItem=function(){return this.selectionModel_?this.selectionModel_.getSelectedItem():null};goog.ui.Palette.prototype.setSelectedIndex=function(a){this.selectionModel_&&this.selectionModel_.setSelectedIndex(a)};goog.ui.Palette.prototype.setSelectedItem=function(a){this.selectionModel_&&this.selectionModel_.setSelectedItem(a)};goog.ui.Palette.prototype.highlightIndex_=function(a,b){if(this.getElement()){var c=this.getContent();if(c&&0<=a&&a<c.length){var d=this.getHighlightedCellElement_();this.currentCellControl_.getElement()!=d&&this.currentCellControl_.setElementInternal(d);this.currentCellControl_.tryHighlight(b)&&this.getRenderer().highlightCell(this,c[a],b)}}};goog.ui.Palette.prototype.setHighlighted=function(a){a&&-1==this.highlightedIndex_?this.setHighlightedIndex(-1<this.lastHighlightedIndex_?this.lastHighlightedIndex_:0):a||this.setHighlightedIndex(-1);
-goog.ui.Palette.superClass_.setHighlighted.call(this,a)};goog.ui.Palette.prototype.selectItem_=function(a,b){this.getElement()&&this.getRenderer().selectCell(this,a,b)};goog.ui.Palette.prototype.adjustSize_=function(){var a=this.getContent();if(a){if(this.size_&&this.size_.width){if(a=Math.ceil(a.length/this.size_.width),!goog.isNumber(this.size_.height)||this.size_.height<a){this.size_.height=a}}else{a=Math.ceil(Math.sqrt(a.length)),this.size_=new goog.math.Size(a,a)}}else{this.size_=new goog.math.Size(0,0)}};goog.ui.Palette.CurrentCell_=function(){goog.ui.Control.call(this,null);this.setDispatchTransitionEvents(goog.ui.Component.State.HOVER,!0)};goog.inherits(goog.ui.Palette.CurrentCell_,goog.ui.Control);goog.ui.Palette.CurrentCell_.prototype.tryHighlight=function(a){this.setHighlighted(a);return this.isHighlighted()==a};goog.ui.ColorPalette=function(a,b,c){this.colors_=a||[];goog.ui.Palette.call(this,null,b||goog.ui.PaletteRenderer.getInstance(),c);this.setColors(this.colors_)};goog.inherits(goog.ui.ColorPalette,goog.ui.Palette);goog.tagUnsealableClass(goog.ui.ColorPalette);goog.ui.ColorPalette.prototype.normalizedColors_=null;goog.ui.ColorPalette.prototype.labels_=null;goog.ui.ColorPalette.prototype.getColors=function(){return this.colors_};goog.ui.ColorPalette.prototype.setColors=function(a,b){this.colors_=a;this.labels_=b||null;this.normalizedColors_=null;this.setContent(this.createColorNodes())};goog.ui.ColorPalette.prototype.getSelectedColor=function(){var a=this.getSelectedItem();return a?(a=goog.style.getStyle(a,"background-color"),goog.ui.ColorPalette.parseColor_(a)):null};goog.ui.ColorPalette.prototype.setSelectedColor=function(a){a=goog.ui.ColorPalette.parseColor_(a);this.normalizedColors_||(this.normalizedColors_=goog.array.map(this.colors_,function(a){return goog.ui.ColorPalette.parseColor_(a)}));this.setSelectedIndex(a?goog.array.indexOf(this.normalizedColors_,a):-1)};goog.ui.ColorPalette.prototype.createColorNodes=function(){return goog.array.map(this.colors_,function(a,b){var c=this.getDomHelper().createDom("DIV",{"class":this.getRenderer().getCssClass()+"-colorswatch",style:"background-color:"+a});
-c.title=this.labels_&&this.labels_[b]?this.labels_[b]:"#"==a.charAt(0)?"RGB ("+goog.color.hexToRgb(a).join(", ")+")":a;return c},this)};goog.ui.ColorPalette.parseColor_=function(a){if(a){try{return goog.color.parse(a).hex}catch(b){}}return null};goog.ui.ColorPicker=function(a,b){goog.ui.Component.call(this,a);this.colorPalette_=b||null;this.getHandler().listen(this,goog.ui.Component.EventType.ACTION,this.onColorPaletteAction_)};goog.inherits(goog.ui.ColorPicker,goog.ui.Component);goog.ui.ColorPicker.DEFAULT_NUM_COLS=5;goog.ui.ColorPicker.EventType={CHANGE:"change"};goog.ui.ColorPicker.prototype.focusable_=!0;goog.ui.ColorPicker.prototype.getColors=function(){return this.colorPalette_?this.colorPalette_.getColors():null};goog.ui.ColorPicker.prototype.setColors=function(a){this.colorPalette_?this.colorPalette_.setColors(a):this.createColorPalette_(a)};goog.ui.ColorPicker.prototype.addColors=function(a){this.setColors(a)};goog.ui.ColorPicker.prototype.setSize=function(a){this.colorPalette_||this.createColorPalette_([]);this.colorPalette_.setSize(a)};goog.ui.ColorPicker.prototype.getSize=function(){return this.colorPalette_?this.colorPalette_.getSize():null};goog.ui.ColorPicker.prototype.setColumnCount=function(a){this.setSize(a)};goog.ui.ColorPicker.prototype.getSelectedIndex=function(){return this.colorPalette_?this.colorPalette_.getSelectedIndex():-1};goog.ui.ColorPicker.prototype.setSelectedIndex=function(a){this.colorPalette_&&this.colorPalette_.setSelectedIndex(a)};goog.ui.ColorPicker.prototype.getSelectedColor=function(){return this.colorPalette_?this.colorPalette_.getSelectedColor():null};goog.ui.ColorPicker.prototype.setSelectedColor=function(a){this.colorPalette_&&this.colorPalette_.setSelectedColor(a)};goog.ui.ColorPicker.prototype.isFocusable=function(){return this.focusable_};goog.ui.ColorPicker.prototype.setFocusable=function(a){this.focusable_=a;this.colorPalette_&&this.colorPalette_.setSupportedState(goog.ui.Component.State.FOCUSED,a)};goog.ui.ColorPicker.prototype.canDecorate=function(a){return !1
-};goog.ui.ColorPicker.prototype.enterDocument=function(){goog.ui.ColorPicker.superClass_.enterDocument.call(this);this.colorPalette_&&this.colorPalette_.render(this.getElement());this.getElement().unselectable="on"};goog.ui.ColorPicker.prototype.disposeInternal=function(){goog.ui.ColorPicker.superClass_.disposeInternal.call(this);this.colorPalette_&&(this.colorPalette_.dispose(),this.colorPalette_=null)};goog.ui.ColorPicker.prototype.focus=function(){this.colorPalette_&&this.colorPalette_.getElement().focus()};goog.ui.ColorPicker.prototype.onColorPaletteAction_=function(a){a.stopPropagation();this.dispatchEvent(goog.ui.ColorPicker.EventType.CHANGE)};goog.ui.ColorPicker.prototype.createColorPalette_=function(a){a=new goog.ui.ColorPalette(a,null,this.getDomHelper());a.setSize(goog.ui.ColorPicker.DEFAULT_NUM_COLS);a.setSupportedState(goog.ui.Component.State.FOCUSED,this.focusable_);this.addChild(a);this.colorPalette_=a;this.isInDocument()&&this.colorPalette_.render(this.getElement())};goog.ui.ColorPicker.createSimpleColorGrid=function(a){a=new goog.ui.ColorPicker(a);a.setSize(7);a.setColors(goog.ui.ColorPicker.SIMPLE_GRID_COLORS);return a};goog.ui.ColorPicker.SIMPLE_GRID_COLORS="#ffffff #cccccc #c0c0c0 #999999 #666666 #333333 #000000 #ffcccc #ff6666 #ff0000 #cc0000 #990000 #660000 #330000 #ffcc99 #ff9966 #ff9900 #ff6600 #cc6600 #993300 #663300 #ffff99 #ffff66 #ffcc66 #ffcc33 #cc9933 #996633 #663333 #ffffcc #ffff33 #ffff00 #ffcc00 #999900 #666600 #333300 #99ff99 #66ff99 #33ff33 #33cc00 #009900 #006600 #003300 #99ffff #33ffff #66cccc #00cccc #339999 #336666 #003333 #ccffff #66ffff #33ccff #3366ff #3333ff #000099 #000066 #ccccff #9999ff #6666cc #6633ff #6600cc #333399 #330099 #ffccff #ff99ff #cc66cc #cc33cc #993399 #663366 #330033".split(" ");goog.events.FocusHandler=function(a){goog.events.EventTarget.call(this);this.element_=a;a=goog.userAgent.IE?"focusout":"blur";this.listenKeyIn_=goog.events.listen(this.element_,goog.userAgent.IE?"focusin":"focus",this,!goog.userAgent.IE);
-this.listenKeyOut_=goog.events.listen(this.element_,a,this,!goog.userAgent.IE)};goog.inherits(goog.events.FocusHandler,goog.events.EventTarget);goog.events.FocusHandler.EventType={FOCUSIN:"focusin",FOCUSOUT:"focusout"};goog.events.FocusHandler.prototype.handleEvent=function(a){var b=a.getBrowserEvent();b=new goog.events.BrowserEvent(b);b.type="focusin"==a.type||"focus"==a.type?goog.events.FocusHandler.EventType.FOCUSIN:goog.events.FocusHandler.EventType.FOCUSOUT;this.dispatchEvent(b)};goog.events.FocusHandler.prototype.disposeInternal=function(){goog.events.FocusHandler.superClass_.disposeInternal.call(this);goog.events.unlistenByKey(this.listenKeyIn_);goog.events.unlistenByKey(this.listenKeyOut_);delete this.element_};goog.debug.LogRecord=function(a,b,c,d,e){this.reset(a,b,c,d,e)};goog.debug.LogRecord.prototype.sequenceNumber_=0;goog.debug.LogRecord.prototype.exception_=null;goog.debug.LogRecord.ENABLE_SEQUENCE_NUMBERS=!0;goog.debug.LogRecord.nextSequenceNumber_=0;goog.debug.LogRecord.prototype.reset=function(a,b,c,d,e){goog.debug.LogRecord.ENABLE_SEQUENCE_NUMBERS&&(this.sequenceNumber_="number"==typeof e?e:goog.debug.LogRecord.nextSequenceNumber_++);this.time_=d||goog.now();this.level_=a;this.msg_=b;this.loggerName_=c;delete this.exception_};goog.debug.LogRecord.prototype.getLoggerName=function(){return this.loggerName_};goog.debug.LogRecord.prototype.getException=function(){return this.exception_};goog.debug.LogRecord.prototype.setException=function(a){this.exception_=a};goog.debug.LogRecord.prototype.setLoggerName=function(a){this.loggerName_=a};goog.debug.LogRecord.prototype.getLevel=function(){return this.level_};goog.debug.LogRecord.prototype.setLevel=function(a){this.level_=a};goog.debug.LogRecord.prototype.getMessage=function(){return this.msg_};goog.debug.LogRecord.prototype.setMessage=function(a){this.msg_=a};goog.debug.LogRecord.prototype.getMillis=function(){return this.time_};goog.debug.LogRecord.prototype.setMillis=function(a){this.time_=a};goog.debug.LogRecord.prototype.getSequenceNumber=function(){return this.sequenceNumber_
-};goog.debug.LogBuffer=function(){goog.asserts.assert(goog.debug.LogBuffer.isBufferingEnabled(),"Cannot use goog.debug.LogBuffer without defining goog.debug.LogBuffer.CAPACITY.");this.clear()};goog.debug.LogBuffer.getInstance=function(){goog.debug.LogBuffer.instance_||(goog.debug.LogBuffer.instance_=new goog.debug.LogBuffer);return goog.debug.LogBuffer.instance_};goog.debug.LogBuffer.CAPACITY=0;goog.debug.LogBuffer.prototype.addRecord=function(a,b,c){var d=(this.curIndex_+1)%goog.debug.LogBuffer.CAPACITY;this.curIndex_=d;if(this.isFull_){return d=this.buffer_[d],d.reset(a,b,c),d}this.isFull_=d==goog.debug.LogBuffer.CAPACITY-1;return this.buffer_[d]=new goog.debug.LogRecord(a,b,c)};goog.debug.LogBuffer.isBufferingEnabled=function(){return 0<goog.debug.LogBuffer.CAPACITY};goog.debug.LogBuffer.prototype.clear=function(){this.buffer_=Array(goog.debug.LogBuffer.CAPACITY);this.curIndex_=-1;this.isFull_=!1};goog.debug.LogBuffer.prototype.forEachRecord=function(a){var b=this.buffer_;if(b[0]){var c=this.curIndex_,d=this.isFull_?c:-1;do{d=(d+1)%goog.debug.LogBuffer.CAPACITY,a(b[d])}while(d!=c)}};goog.debug.Logger=function(a){this.name_=a;this.handlers_=this.children_=this.level_=this.parent_=null};goog.debug.Logger.ROOT_LOGGER_NAME="";goog.debug.Logger.ENABLE_HIERARCHY=!0;goog.debug.Logger.ENABLE_PROFILER_LOGGING=!1;goog.debug.Logger.ENABLE_HIERARCHY||(goog.debug.Logger.rootHandlers_=[]);goog.debug.Logger.Level=function(a,b){this.name=a;this.value=b};goog.debug.Logger.Level.prototype.toString=function(){return this.name};goog.debug.Logger.Level.OFF=new goog.debug.Logger.Level("OFF",Infinity);goog.debug.Logger.Level.SHOUT=new goog.debug.Logger.Level("SHOUT",1200);goog.debug.Logger.Level.SEVERE=new goog.debug.Logger.Level("SEVERE",1000);goog.debug.Logger.Level.WARNING=new goog.debug.Logger.Level("WARNING",900);goog.debug.Logger.Level.INFO=new goog.debug.Logger.Level("INFO",800);goog.debug.Logger.Level.CONFIG=new goog.debug.Logger.Level("CONFIG",700);goog.debug.Logger.Level.FINE=new goog.debug.Logger.Level("FINE",500);
-goog.debug.Logger.Level.FINER=new goog.debug.Logger.Level("FINER",400);goog.debug.Logger.Level.FINEST=new goog.debug.Logger.Level("FINEST",300);goog.debug.Logger.Level.ALL=new goog.debug.Logger.Level("ALL",0);goog.debug.Logger.Level.PREDEFINED_LEVELS=[goog.debug.Logger.Level.OFF,goog.debug.Logger.Level.SHOUT,goog.debug.Logger.Level.SEVERE,goog.debug.Logger.Level.WARNING,goog.debug.Logger.Level.INFO,goog.debug.Logger.Level.CONFIG,goog.debug.Logger.Level.FINE,goog.debug.Logger.Level.FINER,goog.debug.Logger.Level.FINEST,goog.debug.Logger.Level.ALL];goog.debug.Logger.Level.predefinedLevelsCache_=null;goog.debug.Logger.Level.createPredefinedLevelsCache_=function(){goog.debug.Logger.Level.predefinedLevelsCache_={};for(var a=0,b;b=goog.debug.Logger.Level.PREDEFINED_LEVELS[a];a++){goog.debug.Logger.Level.predefinedLevelsCache_[b.value]=b,goog.debug.Logger.Level.predefinedLevelsCache_[b.name]=b}};goog.debug.Logger.Level.getPredefinedLevel=function(a){goog.debug.Logger.Level.predefinedLevelsCache_||goog.debug.Logger.Level.createPredefinedLevelsCache_();return goog.debug.Logger.Level.predefinedLevelsCache_[a]||null};goog.debug.Logger.Level.getPredefinedLevelByValue=function(a){goog.debug.Logger.Level.predefinedLevelsCache_||goog.debug.Logger.Level.createPredefinedLevelsCache_();if(a in goog.debug.Logger.Level.predefinedLevelsCache_){return goog.debug.Logger.Level.predefinedLevelsCache_[a]}for(var b=0;b<goog.debug.Logger.Level.PREDEFINED_LEVELS.length;++b){var c=goog.debug.Logger.Level.PREDEFINED_LEVELS[b];if(c.value<=a){return c}}return null};goog.debug.Logger.getLogger=function(a){return goog.debug.LogManager.getLogger(a)};goog.debug.Logger.logToProfilers=function(a){if(goog.debug.Logger.ENABLE_PROFILER_LOGGING){var b=goog.global.msWriteProfilerMark;b?b(a):(b=goog.global.console)&&b.timeStamp&&b.timeStamp(a)}};goog.debug.Logger.prototype.getName=function(){return this.name_};goog.debug.Logger.prototype.addHandler=function(a){goog.debug.LOGGING_ENABLED&&(goog.debug.Logger.ENABLE_HIERARCHY?(this.handlers_||(this.handlers_=[]),this.handlers_.push(a)):(goog.asserts.assert(!this.name_,"Cannot call addHandler on a non-root logger when goog.debug.Logger.ENABLE_HIERARCHY is false."),goog.debug.Logger.rootHandlers_.push(a)))
-};goog.debug.Logger.prototype.removeHandler=function(a){if(goog.debug.LOGGING_ENABLED){var b=goog.debug.Logger.ENABLE_HIERARCHY?this.handlers_:goog.debug.Logger.rootHandlers_;return !!b&&goog.array.remove(b,a)}return !1};goog.debug.Logger.prototype.getParent=function(){return this.parent_};goog.debug.Logger.prototype.getChildren=function(){this.children_||(this.children_={});return this.children_};goog.debug.Logger.prototype.setLevel=function(a){goog.debug.LOGGING_ENABLED&&(goog.debug.Logger.ENABLE_HIERARCHY?this.level_=a:(goog.asserts.assert(!this.name_,"Cannot call setLevel() on a non-root logger when goog.debug.Logger.ENABLE_HIERARCHY is false."),goog.debug.Logger.rootLevel_=a))};goog.debug.Logger.prototype.getLevel=function(){return goog.debug.LOGGING_ENABLED?this.level_:goog.debug.Logger.Level.OFF};goog.debug.Logger.prototype.getEffectiveLevel=function(){if(!goog.debug.LOGGING_ENABLED){return goog.debug.Logger.Level.OFF}if(!goog.debug.Logger.ENABLE_HIERARCHY){return goog.debug.Logger.rootLevel_}if(this.level_){return this.level_}if(this.parent_){return this.parent_.getEffectiveLevel()}goog.asserts.fail("Root logger has no level set.");return null};goog.debug.Logger.prototype.isLoggable=function(a){return goog.debug.LOGGING_ENABLED&&a.value>=this.getEffectiveLevel().value};goog.debug.Logger.prototype.log=function(a,b,c){goog.debug.LOGGING_ENABLED&&this.isLoggable(a)&&(goog.isFunction(b)&&(b=b()),this.doLogRecord_(this.getLogRecord(a,b,c)))};goog.debug.Logger.prototype.getLogRecord=function(a,b,c){a=goog.debug.LogBuffer.isBufferingEnabled()?goog.debug.LogBuffer.getInstance().addRecord(a,b,this.name_):new goog.debug.LogRecord(a,String(b),this.name_);c&&a.setException(c);return a};goog.debug.Logger.prototype.shout=function(a,b){goog.debug.LOGGING_ENABLED&&this.log(goog.debug.Logger.Level.SHOUT,a,b)};goog.debug.Logger.prototype.severe=function(a,b){goog.debug.LOGGING_ENABLED&&this.log(goog.debug.Logger.Level.SEVERE,a,b)};goog.debug.Logger.prototype.warning=function(a,b){goog.debug.LOGGING_ENABLED&&this.log(goog.debug.Logger.Level.WARNING,a,b)
-};goog.debug.Logger.prototype.info=function(a,b){goog.debug.LOGGING_ENABLED&&this.log(goog.debug.Logger.Level.INFO,a,b)};goog.debug.Logger.prototype.config=function(a,b){goog.debug.LOGGING_ENABLED&&this.log(goog.debug.Logger.Level.CONFIG,a,b)};goog.debug.Logger.prototype.fine=function(a,b){goog.debug.LOGGING_ENABLED&&this.log(goog.debug.Logger.Level.FINE,a,b)};goog.debug.Logger.prototype.finer=function(a,b){goog.debug.LOGGING_ENABLED&&this.log(goog.debug.Logger.Level.FINER,a,b)};goog.debug.Logger.prototype.finest=function(a,b){goog.debug.LOGGING_ENABLED&&this.log(goog.debug.Logger.Level.FINEST,a,b)};goog.debug.Logger.prototype.logRecord=function(a){goog.debug.LOGGING_ENABLED&&this.isLoggable(a.getLevel())&&this.doLogRecord_(a)};goog.debug.Logger.prototype.doLogRecord_=function(a){goog.debug.Logger.ENABLE_PROFILER_LOGGING&&goog.debug.Logger.logToProfilers("log:"+a.getMessage());if(goog.debug.Logger.ENABLE_HIERARCHY){for(var b=this;b;){b.callPublish_(a),b=b.getParent()}}else{b=0;for(var c;c=goog.debug.Logger.rootHandlers_[b++];){c(a)}}};goog.debug.Logger.prototype.callPublish_=function(a){if(this.handlers_){for(var b=0,c;c=this.handlers_[b];b++){c(a)}}};goog.debug.Logger.prototype.setParent_=function(a){this.parent_=a};goog.debug.Logger.prototype.addChild_=function(a,b){this.getChildren()[a]=b};goog.debug.LogManager={};goog.debug.LogManager.loggers_={};goog.debug.LogManager.rootLogger_=null;goog.debug.LogManager.initialize=function(){goog.debug.LogManager.rootLogger_||(goog.debug.LogManager.rootLogger_=new goog.debug.Logger(goog.debug.Logger.ROOT_LOGGER_NAME),goog.debug.LogManager.loggers_[goog.debug.Logger.ROOT_LOGGER_NAME]=goog.debug.LogManager.rootLogger_,goog.debug.LogManager.rootLogger_.setLevel(goog.debug.Logger.Level.CONFIG))};goog.debug.LogManager.getLoggers=function(){return goog.debug.LogManager.loggers_};goog.debug.LogManager.getRoot=function(){goog.debug.LogManager.initialize();return goog.debug.LogManager.rootLogger_};goog.debug.LogManager.getLogger=function(a){goog.debug.LogManager.initialize();
-return goog.debug.LogManager.loggers_[a]||goog.debug.LogManager.createLogger_(a)};goog.debug.LogManager.createFunctionForCatchErrors=function(a){return function(b){(a||goog.debug.LogManager.getRoot()).severe("Error: "+b.message+" ("+b.fileName+" @ Line: "+b.line+")")}};goog.debug.LogManager.createLogger_=function(a){var b=new goog.debug.Logger(a);if(goog.debug.Logger.ENABLE_HIERARCHY){var c=a.lastIndexOf("."),d=a.substr(0,c);c=a.substr(c+1);d=goog.debug.LogManager.getLogger(d);d.addChild_(c,b);b.setParent_(d)}return goog.debug.LogManager.loggers_[a]=b};goog.log={};goog.log.ENABLED=goog.debug.LOGGING_ENABLED;goog.log.ROOT_LOGGER_NAME=goog.debug.Logger.ROOT_LOGGER_NAME;goog.log.Logger=goog.debug.Logger;goog.log.Level=goog.debug.Logger.Level;goog.log.LogRecord=goog.debug.LogRecord;goog.log.getLogger=function(a,b){if(goog.log.ENABLED){var c=goog.debug.LogManager.getLogger(a);b&&c&&c.setLevel(b);return c}return null};goog.log.addHandler=function(a,b){goog.log.ENABLED&&a&&a.addHandler(b)};goog.log.removeHandler=function(a,b){return goog.log.ENABLED&&a?a.removeHandler(b):!1};goog.log.log=function(a,b,c,d){goog.log.ENABLED&&a&&a.log(b,c,d)};goog.log.error=function(a,b,c){goog.log.ENABLED&&a&&a.severe(b,c)};goog.log.warning=function(a,b,c){goog.log.ENABLED&&a&&a.warning(b,c)};goog.log.info=function(a,b,c){goog.log.ENABLED&&a&&a.info(b,c)};goog.log.fine=function(a,b,c){goog.log.ENABLED&&a&&a.fine(b,c)};goog.string.StringBuffer=function(a,b){null!=a&&this.append.apply(this,arguments)};goog.string.StringBuffer.prototype.buffer_="";goog.string.StringBuffer.prototype.set=function(a){this.buffer_=""+a};goog.string.StringBuffer.prototype.append=function(a,b,c){this.buffer_+=String(a);if(null!=b){for(var d=1;d<arguments.length;d++){this.buffer_+=arguments[d]}}return this};goog.string.StringBuffer.prototype.clear=function(){this.buffer_=""};goog.string.StringBuffer.prototype.getLength=function(){return this.buffer_.length};goog.string.StringBuffer.prototype.toString=function(){return this.buffer_
-};goog.ui.tree={};goog.ui.tree.BaseNode=function(a,b,c){goog.ui.Component.call(this,c);this.config_=b||goog.ui.tree.BaseNode.defaultConfig;this.html_=goog.html.SafeHtml.htmlEscapePreservingNewlines(a);this.expanded_=this.selected_=!1;this.toolTip_=null;this.afterLabelHtml_=goog.html.SafeHtml.EMPTY;this.isUserCollapsible_=!0;this.depth_=-1};goog.inherits(goog.ui.tree.BaseNode,goog.ui.Component);goog.ui.tree.BaseNode.EventType={BEFORE_EXPAND:"beforeexpand",EXPAND:"expand",BEFORE_COLLAPSE:"beforecollapse",COLLAPSE:"collapse"};goog.ui.tree.BaseNode.allNodes={};goog.ui.tree.BaseNode.prototype.disposeInternal=function(){goog.ui.tree.BaseNode.superClass_.disposeInternal.call(this);this.tree&&(this.tree.removeNode(this),this.tree=null);this.setElementInternal(null)};goog.ui.tree.BaseNode.prototype.initAccessibility=function(){var a=this.getElement();if(a){var b=this.getLabelElement();b&&!b.id&&(b.id=this.getId()+".label");goog.a11y.aria.setRole(a,"treeitem");goog.a11y.aria.setState(a,"selected",!1);goog.a11y.aria.setState(a,"level",this.getDepth());b&&goog.a11y.aria.setState(a,"labelledby",b.id);(b=this.getIconElement())&&goog.a11y.aria.setRole(b,"presentation");(b=this.getExpandIconElement())&&goog.a11y.aria.setRole(b,"presentation");if(b=this.getChildrenElement()){if(goog.a11y.aria.setRole(b,"group"),b.hasChildNodes()){for(goog.a11y.aria.setState(a,goog.a11y.aria.State.EXPANDED,!1),a=this.getChildCount(),b=1;b<=a;b++){var c=this.getChildAt(b-1).getElement();goog.asserts.assert(c,"The child element cannot be null");goog.a11y.aria.setState(c,"setsize",a);goog.a11y.aria.setState(c,"posinset",b)}}}}};goog.ui.tree.BaseNode.prototype.createDom=function(){var a=this.getDomHelper().safeHtmlToNode(this.toSafeHtml());this.setElementInternal(a)};goog.ui.tree.BaseNode.prototype.enterDocument=function(){goog.ui.tree.BaseNode.superClass_.enterDocument.call(this);goog.ui.tree.BaseNode.allNodes[this.getId()]=this;this.initAccessibility()};goog.ui.tree.BaseNode.prototype.exitDocument=function(){goog.ui.tree.BaseNode.superClass_.exitDocument.call(this);
-delete goog.ui.tree.BaseNode.allNodes[this.getId()]};goog.ui.tree.BaseNode.prototype.addChildAt=function(a,b,c){goog.asserts.assert(!a.getParent());goog.asserts.assertInstanceof(a,goog.ui.tree.BaseNode);c=this.getChildAt(b-1);var d=this.getChildAt(b);goog.ui.tree.BaseNode.superClass_.addChildAt.call(this,a,b);a.previousSibling_=c;a.nextSibling_=d;c?c.nextSibling_=a:this.firstChild_=a;d?d.previousSibling_=a:this.lastChild_=a;(b=this.getTree())&&a.setTreeInternal(b);a.setDepth_(this.getDepth()+1);if(b=this.getElement()){if(this.updateExpandIcon(),goog.a11y.aria.setState(b,goog.a11y.aria.State.EXPANDED,this.getExpanded()),this.getExpanded()){b=this.getChildrenElement();a.getElement()||a.createDom();var e=a.getElement(),f=d&&d.getElement();b.insertBefore(e,f);this.isInDocument()&&a.enterDocument();d||(c?c.updateExpandIcon():(goog.style.setElementShown(b,!0),this.setExpanded(this.getExpanded())))}}};goog.ui.tree.BaseNode.prototype.add=function(a,b){goog.asserts.assert(!b||b.getParent()==this,"Can only add nodes before siblings");a.getParent()&&a.getParent().removeChild(a);this.addChildAt(a,b?this.indexOfChild(b):this.getChildCount());return a};goog.ui.tree.BaseNode.prototype.removeChild=function(a,b){var c=this.getTree(),d=c?c.getSelectedItem():null;if(d==a||a.contains(d)){c.hasFocus()?(this.select(),goog.Timer.callOnce(this.onTimeoutSelect_,10,this)):this.select()}goog.ui.tree.BaseNode.superClass_.removeChild.call(this,a);this.lastChild_==a&&(this.lastChild_=a.previousSibling_);this.firstChild_==a&&(this.firstChild_=a.nextSibling_);a.previousSibling_&&(a.previousSibling_.nextSibling_=a.nextSibling_);a.nextSibling_&&(a.nextSibling_.previousSibling_=a.previousSibling_);d=a.isLastSibling();a.tree=null;a.depth_=-1;if(c&&(c.removeNode(a),this.isInDocument())){c=this.getChildrenElement();if(a.isInDocument()){var e=a.getElement();c.removeChild(e);a.exitDocument()}d&&(d=this.getLastChild())&&d.updateExpandIcon();this.hasChildren()||(c.style.display="none",this.updateExpandIcon(),this.updateIcon_(),(d=this.getElement())&&goog.a11y.aria.removeState(d,goog.a11y.aria.State.EXPANDED))
-}return a};goog.ui.tree.BaseNode.prototype.remove=goog.ui.tree.BaseNode.prototype.removeChild;goog.ui.tree.BaseNode.prototype.onTimeoutSelect_=function(){this.select()};goog.ui.tree.BaseNode.prototype.getTree=goog.abstractMethod;goog.ui.tree.BaseNode.prototype.getDepth=function(){var a=this.depth_;0>a&&(a=this.computeDepth_(),this.setDepth_(a));return a};goog.ui.tree.BaseNode.prototype.computeDepth_=function(){var a=this.getParent();return a?a.getDepth()+1:0};goog.ui.tree.BaseNode.prototype.setDepth_=function(a){if(a!=this.depth_){this.depth_=a;var b=this.getRowElement();if(b){var c=this.getPixelIndent_()+"px";this.isRightToLeft()?b.style.paddingRight=c:b.style.paddingLeft=c}this.forEachChild(function(b){b.setDepth_(a+1)})}};goog.ui.tree.BaseNode.prototype.contains=function(a){for(;a;){if(a==this){return !0}a=a.getParent()}return !1};goog.ui.tree.BaseNode.EMPTY_CHILDREN_=[];goog.ui.tree.BaseNode.prototype.getChildren=function(){var a=[];this.forEachChild(function(b){a.push(b)});return a};goog.ui.tree.BaseNode.prototype.getFirstChild=function(){return this.getChildAt(0)};goog.ui.tree.BaseNode.prototype.getLastChild=function(){return this.getChildAt(this.getChildCount()-1)};goog.ui.tree.BaseNode.prototype.getPreviousSibling=function(){return this.previousSibling_};goog.ui.tree.BaseNode.prototype.getNextSibling=function(){return this.nextSibling_};goog.ui.tree.BaseNode.prototype.isLastSibling=function(){return !this.nextSibling_};goog.ui.tree.BaseNode.prototype.isSelected=function(){return this.selected_};goog.ui.tree.BaseNode.prototype.select=function(){var a=this.getTree();a&&a.setSelectedItem(this)};goog.ui.tree.BaseNode.prototype.deselect=goog.nullFunction;goog.ui.tree.BaseNode.prototype.setSelectedInternal=function(a){if(this.selected_!=a){this.selected_=a;this.updateRow();var b=this.getElement();b&&(goog.a11y.aria.setState(b,"selected",a),a&&(a=this.getTree().getElement(),goog.asserts.assert(a,"The DOM element for the tree cannot be null"),goog.a11y.aria.setState(a,"activedescendant",this.getId())))
-}};goog.ui.tree.BaseNode.prototype.getExpanded=function(){return this.expanded_};goog.ui.tree.BaseNode.prototype.setExpandedInternal=function(a){this.expanded_=a};goog.ui.tree.BaseNode.prototype.setExpanded=function(a){var b=a!=this.expanded_;if(!b||this.dispatchEvent(a?goog.ui.tree.BaseNode.EventType.BEFORE_EXPAND:goog.ui.tree.BaseNode.EventType.BEFORE_COLLAPSE)){this.expanded_=a;var c=this.getTree();var d=this.getElement();if(this.hasChildren()){if(!a&&c&&this.contains(c.getSelectedItem())&&this.select(),d){if(c=this.getChildrenElement()){if(goog.style.setElementShown(c,a),goog.a11y.aria.setState(d,goog.a11y.aria.State.EXPANDED,a),a&&this.isInDocument()&&!c.hasChildNodes()){var e=[];this.forEachChild(function(a){e.push(a.toSafeHtml())});goog.dom.safe.setInnerHtml(c,goog.html.SafeHtml.concat(e));this.forEachChild(function(a){a.enterDocument()})}}this.updateExpandIcon()}}else{(c=this.getChildrenElement())&&goog.style.setElementShown(c,!1)}d&&this.updateIcon_();b&&this.dispatchEvent(a?goog.ui.tree.BaseNode.EventType.EXPAND:goog.ui.tree.BaseNode.EventType.COLLAPSE)}};goog.ui.tree.BaseNode.prototype.toggle=function(){this.setExpanded(!this.getExpanded())};goog.ui.tree.BaseNode.prototype.expand=function(){this.setExpanded(!0)};goog.ui.tree.BaseNode.prototype.collapse=function(){this.setExpanded(!1)};goog.ui.tree.BaseNode.prototype.collapseChildren=function(){this.forEachChild(function(a){a.collapseAll()})};goog.ui.tree.BaseNode.prototype.collapseAll=function(){this.collapseChildren();this.collapse()};goog.ui.tree.BaseNode.prototype.expandChildren=function(){this.forEachChild(function(a){a.expandAll()})};goog.ui.tree.BaseNode.prototype.expandAll=function(){this.expandChildren();this.expand()};goog.ui.tree.BaseNode.prototype.reveal=function(){var a=this.getParent();a&&(a.setExpanded(!0),a.reveal())};goog.ui.tree.BaseNode.prototype.setIsUserCollapsible=function(a){(this.isUserCollapsible_=a)||this.expand();this.getElement()&&this.updateExpandIcon()};goog.ui.tree.BaseNode.prototype.isUserCollapsible=function(){return this.isUserCollapsible_
-};goog.ui.tree.BaseNode.prototype.toSafeHtml=function(){var a=this.getTree(),b=!a.getShowLines()||a==this.getParent()&&!a.getShowRootLines()?this.config_.cssChildrenNoLines:this.config_.cssChildren;a=this.getExpanded()&&this.hasChildren();b={"class":b,style:this.getLineStyle()};var c=[];a&&this.forEachChild(function(a){c.push(a.toSafeHtml())});a=goog.html.SafeHtml.create("div",b,c);return goog.html.SafeHtml.create("div",{"class":this.config_.cssItem,id:this.getId()},[this.getRowSafeHtml(),a])};goog.ui.tree.BaseNode.prototype.getPixelIndent_=function(){return Math.max(0,(this.getDepth()-1)*this.config_.indentWidth)};goog.ui.tree.BaseNode.prototype.getRowSafeHtml=function(){var a={};a["padding-"+(this.isRightToLeft()?"right":"left")]=this.getPixelIndent_()+"px";a={"class":this.getRowClassName(),style:a};var b=[this.getExpandIconSafeHtml(),this.getIconSafeHtml(),this.getLabelSafeHtml()];return goog.html.SafeHtml.create("div",a,b)};goog.ui.tree.BaseNode.prototype.getRowClassName=function(){var a=this.isSelected()?" "+this.config_.cssSelectedRow:"";return this.config_.cssTreeRow+a};goog.ui.tree.BaseNode.prototype.getLabelSafeHtml=function(){var a=goog.html.SafeHtml.create("span",{"class":this.config_.cssItemLabel,title:this.getToolTip()||null},this.getSafeHtml());return goog.html.SafeHtml.concat(a,goog.html.SafeHtml.create("span",{},this.getAfterLabelSafeHtml()))};goog.ui.tree.BaseNode.prototype.getAfterLabelHtml=function(){return goog.html.SafeHtml.unwrap(this.getAfterLabelSafeHtml())};goog.ui.tree.BaseNode.prototype.getAfterLabelSafeHtml=function(){return this.afterLabelHtml_};goog.ui.tree.BaseNode.prototype.setAfterLabelSafeHtml=function(a){this.afterLabelHtml_=a;var b=this.getAfterLabelElement();b&&goog.dom.safe.setInnerHtml(b,a)};goog.ui.tree.BaseNode.prototype.getIconSafeHtml=function(){return goog.html.SafeHtml.create("span",{style:{display:"inline-block"},"class":this.getCalculatedIconClass()})};goog.ui.tree.BaseNode.prototype.getCalculatedIconClass=goog.abstractMethod;
-goog.ui.tree.BaseNode.prototype.getExpandIconSafeHtml=function(){return goog.html.SafeHtml.create("span",{type:"expand",style:{display:"inline-block"},"class":this.getExpandIconClass()})};goog.ui.tree.BaseNode.prototype.getExpandIconClass=function(){var a=this.getTree(),b=!a.getShowLines()||a==this.getParent()&&!a.getShowRootLines(),c=this.config_,d=new goog.string.StringBuffer;d.append(c.cssTreeIcon," ",c.cssExpandTreeIcon," ");if(this.hasChildren()){var e=0;a.getShowExpandIcons()&&this.isUserCollapsible_&&(e=this.getExpanded()?2:1);b||(e=this.isLastSibling()?e+4:e+8);switch(e){case 1:d.append(c.cssExpandTreeIconPlus);break;case 2:d.append(c.cssExpandTreeIconMinus);break;case 4:d.append(c.cssExpandTreeIconL);break;case 5:d.append(c.cssExpandTreeIconLPlus);break;case 6:d.append(c.cssExpandTreeIconLMinus);break;case 8:d.append(c.cssExpandTreeIconT);break;case 9:d.append(c.cssExpandTreeIconTPlus);break;case 10:d.append(c.cssExpandTreeIconTMinus);break;default:d.append(c.cssExpandTreeIconBlank)}}else{b?d.append(c.cssExpandTreeIconBlank):this.isLastSibling()?d.append(c.cssExpandTreeIconL):d.append(c.cssExpandTreeIconT)}return d.toString()};goog.ui.tree.BaseNode.prototype.getLineStyle=function(){var a=this.getExpanded()&&this.hasChildren();return goog.html.SafeStyle.create({"background-position":this.getBackgroundPosition(),display:a?null:"none"})};goog.ui.tree.BaseNode.prototype.getBackgroundPosition=function(){return(this.isLastSibling()?"-100":(this.getDepth()-1)*this.config_.indentWidth)+"px 0"};goog.ui.tree.BaseNode.prototype.getElement=function(){var a=goog.ui.tree.BaseNode.superClass_.getElement.call(this);a||(a=this.getDomHelper().getElement(this.getId()),this.setElementInternal(a));return a};goog.ui.tree.BaseNode.prototype.getRowElement=function(){var a=this.getElement();return a?a.firstChild:null};goog.ui.tree.BaseNode.prototype.getExpandIconElement=function(){var a=this.getRowElement();return a?a.firstChild:null};goog.ui.tree.BaseNode.prototype.getIconElement=function(){var a=this.getRowElement();
-return a?a.childNodes[1]:null};goog.ui.tree.BaseNode.prototype.getLabelElement=function(){var a=this.getRowElement();return a&&a.lastChild?a.lastChild.previousSibling:null};goog.ui.tree.BaseNode.prototype.getAfterLabelElement=function(){var a=this.getRowElement();return a?a.lastChild:null};goog.ui.tree.BaseNode.prototype.getChildrenElement=function(){var a=this.getElement();return a?a.lastChild:null};goog.ui.tree.BaseNode.prototype.setIconClass=function(a){this.iconClass_=a;this.isInDocument()&&this.updateIcon_()};goog.ui.tree.BaseNode.prototype.getIconClass=function(){return this.iconClass_};goog.ui.tree.BaseNode.prototype.setExpandedIconClass=function(a){this.expandedIconClass_=a;this.isInDocument()&&this.updateIcon_()};goog.ui.tree.BaseNode.prototype.getExpandedIconClass=function(){return this.expandedIconClass_};goog.ui.tree.BaseNode.prototype.setText=function(a){this.setSafeHtml(goog.html.SafeHtml.htmlEscape(a))};goog.ui.tree.BaseNode.prototype.getText=function(){return goog.string.unescapeEntities(goog.html.SafeHtml.unwrap(this.html_))};goog.ui.tree.BaseNode.prototype.setSafeHtml=function(a){this.html_=a;var b=this.getLabelElement();b&&goog.dom.safe.setInnerHtml(b,a);(a=this.getTree())&&a.setNode(this)};goog.ui.tree.BaseNode.prototype.getHtml=function(){return goog.html.SafeHtml.unwrap(this.getSafeHtml())};goog.ui.tree.BaseNode.prototype.getSafeHtml=function(){return this.html_};goog.ui.tree.BaseNode.prototype.setToolTip=function(a){this.toolTip_=a;var b=this.getLabelElement();b&&(b.title=a)};goog.ui.tree.BaseNode.prototype.getToolTip=function(){return this.toolTip_};goog.ui.tree.BaseNode.prototype.updateRow=function(){var a=this.getRowElement();a&&(a.className=this.getRowClassName())};goog.ui.tree.BaseNode.prototype.updateExpandIcon=function(){var a=this.getExpandIconElement();a&&(a.className=this.getExpandIconClass());if(a=this.getChildrenElement()){a.style.backgroundPosition=this.getBackgroundPosition()}};goog.ui.tree.BaseNode.prototype.updateIcon_=function(){this.getIconElement().className=this.getCalculatedIconClass()
-};goog.ui.tree.BaseNode.prototype.onMouseDown=function(a){"expand"==a.target.getAttribute("type")&&this.hasChildren()?this.isUserCollapsible_&&this.toggle():(this.select(),this.updateRow())};goog.ui.tree.BaseNode.prototype.onClick_=goog.events.Event.preventDefault;goog.ui.tree.BaseNode.prototype.onDoubleClick_=function(a){"expand"==a.target.getAttribute("type")&&this.hasChildren()||this.isUserCollapsible_&&this.toggle()};goog.ui.tree.BaseNode.prototype.onKeyDown=function(a){var b=!0;switch(a.keyCode){case goog.events.KeyCodes.RIGHT:if(a.altKey){break}this.hasChildren()&&(this.getExpanded()?this.getFirstChild().select():this.setExpanded(!0));break;case goog.events.KeyCodes.LEFT:if(a.altKey){break}if(this.hasChildren()&&this.getExpanded()&&this.isUserCollapsible_){this.setExpanded(!1)}else{var c=this.getParent(),d=this.getTree();c&&(d.getShowRootNode()||c!=d)&&c.select()}break;case goog.events.KeyCodes.DOWN:(c=this.getNextShownNode())&&c.select();break;case goog.events.KeyCodes.UP:(c=this.getPreviousShownNode())&&c.select();break;default:b=!1}b&&(a.preventDefault(),(d=this.getTree())&&d.clearTypeAhead());return b};goog.ui.tree.BaseNode.prototype.getLastShownDescendant=function(){return this.getExpanded()&&this.hasChildren()?this.getLastChild().getLastShownDescendant():this};goog.ui.tree.BaseNode.prototype.getNextShownNode=function(){if(this.hasChildren()&&this.getExpanded()){return this.getFirstChild()}for(var a=this,b;a!=this.getTree();){b=a.getNextSibling();if(null!=b){return b}a=a.getParent()}return null};goog.ui.tree.BaseNode.prototype.getPreviousShownNode=function(){var a=this.getPreviousSibling();if(null!=a){return a.getLastShownDescendant()}a=this.getParent();var b=this.getTree();return !b.getShowRootNode()&&a==b||this==b?null:a};goog.ui.tree.BaseNode.prototype.getClientData=goog.ui.tree.BaseNode.prototype.getModel;goog.ui.tree.BaseNode.prototype.setClientData=goog.ui.tree.BaseNode.prototype.setModel;goog.ui.tree.BaseNode.prototype.getConfig=function(){return this.config_
-};goog.ui.tree.BaseNode.prototype.setTreeInternal=function(a){this.tree!=a&&(this.tree=a,a.setNode(this),this.forEachChild(function(b){b.setTreeInternal(a)}))};goog.ui.tree.BaseNode.defaultConfig={indentWidth:19,cssRoot:"goog-tree-root goog-tree-item",cssHideRoot:"goog-tree-hide-root",cssItem:"goog-tree-item",cssChildren:"goog-tree-children",cssChildrenNoLines:"goog-tree-children-nolines",cssTreeRow:"goog-tree-row",cssItemLabel:"goog-tree-item-label",cssTreeIcon:"goog-tree-icon",cssExpandTreeIcon:"goog-tree-expand-icon",cssExpandTreeIconPlus:"goog-tree-expand-icon-plus",cssExpandTreeIconMinus:"goog-tree-expand-icon-minus",cssExpandTreeIconTPlus:"goog-tree-expand-icon-tplus",cssExpandTreeIconTMinus:"goog-tree-expand-icon-tminus",cssExpandTreeIconLPlus:"goog-tree-expand-icon-lplus",cssExpandTreeIconLMinus:"goog-tree-expand-icon-lminus",cssExpandTreeIconT:"goog-tree-expand-icon-t",cssExpandTreeIconL:"goog-tree-expand-icon-l",cssExpandTreeIconBlank:"goog-tree-expand-icon-blank",cssExpandedFolderIcon:"goog-tree-expanded-folder-icon",cssCollapsedFolderIcon:"goog-tree-collapsed-folder-icon",cssFileIcon:"goog-tree-file-icon",cssExpandedRootIcon:"goog-tree-expanded-folder-icon",cssCollapsedRootIcon:"goog-tree-collapsed-folder-icon",cssSelectedRow:"selected"};goog.ui.tree.TreeNode=function(a,b,c){goog.ui.tree.BaseNode.call(this,a,b,c)};goog.inherits(goog.ui.tree.TreeNode,goog.ui.tree.BaseNode);goog.ui.tree.TreeNode.prototype.getTree=function(){if(this.tree){return this.tree}var a=this.getParent();return a&&(a=a.getTree())?(this.setTreeInternal(a),a):null};goog.ui.tree.TreeNode.prototype.getCalculatedIconClass=function(){var a=this.getExpanded(),b=this.getExpandedIconClass();if(a&&b){return b}b=this.getIconClass();if(!a&&b){return b}b=this.getConfig();if(this.hasChildren()){if(a&&b.cssExpandedFolderIcon){return b.cssTreeIcon+" "+b.cssExpandedFolderIcon}if(!a&&b.cssCollapsedFolderIcon){return b.cssTreeIcon+" "+b.cssCollapsedFolderIcon}}else{if(b.cssFileIcon){return b.cssTreeIcon+" "+b.cssFileIcon
-}}return""};goog.structs={};goog.structs.getCount=function(a){return a.getCount&&"function"==typeof a.getCount?a.getCount():goog.isArrayLike(a)||goog.isString(a)?a.length:goog.object.getCount(a)};goog.structs.getValues=function(a){if(a.getValues&&"function"==typeof a.getValues){return a.getValues()}if(goog.isString(a)){return a.split("")}if(goog.isArrayLike(a)){for(var b=[],c=a.length,d=0;d<c;d++){b.push(a[d])}return b}return goog.object.getValues(a)};goog.structs.getKeys=function(a){if(a.getKeys&&"function"==typeof a.getKeys){return a.getKeys()}if(!a.getValues||"function"!=typeof a.getValues){if(goog.isArrayLike(a)||goog.isString(a)){var b=[];a=a.length;for(var c=0;c<a;c++){b.push(c)}return b}return goog.object.getKeys(a)}};goog.structs.contains=function(a,b){return a.contains&&"function"==typeof a.contains?a.contains(b):a.containsValue&&"function"==typeof a.containsValue?a.containsValue(b):goog.isArrayLike(a)||goog.isString(a)?goog.array.contains(a,b):goog.object.containsValue(a,b)};goog.structs.isEmpty=function(a){return a.isEmpty&&"function"==typeof a.isEmpty?a.isEmpty():goog.isArrayLike(a)||goog.isString(a)?goog.array.isEmpty(a):goog.object.isEmpty(a)};goog.structs.clear=function(a){a.clear&&"function"==typeof a.clear?a.clear():goog.isArrayLike(a)?goog.array.clear(a):goog.object.clear(a)};goog.structs.forEach=function(a,b,c){if(a.forEach&&"function"==typeof a.forEach){a.forEach(b,c)}else{if(goog.isArrayLike(a)||goog.isString(a)){goog.array.forEach(a,b,c)}else{for(var d=goog.structs.getKeys(a),e=goog.structs.getValues(a),f=e.length,g=0;g<f;g++){b.call(c,e[g],d&&d[g],a)}}}};goog.structs.filter=function(a,b,c){if("function"==typeof a.filter){return a.filter(b,c)}if(goog.isArrayLike(a)||goog.isString(a)){return goog.array.filter(a,b,c)}var d=goog.structs.getKeys(a),e=goog.structs.getValues(a),f=e.length;if(d){var g={};for(var h=0;h<f;h++){b.call(c,e[h],d[h],a)&&(g[d[h]]=e[h])}}else{for(g=[],h=0;h<f;h++){b.call(c,e[h],void 0,a)&&g.push(e[h])}}return g};goog.structs.map=function(a,b,c){if("function"==typeof a.map){return a.map(b,c)
-}if(goog.isArrayLike(a)||goog.isString(a)){return goog.array.map(a,b,c)}var d=goog.structs.getKeys(a),e=goog.structs.getValues(a),f=e.length;if(d){var g={};for(var h=0;h<f;h++){g[d[h]]=b.call(c,e[h],d[h],a)}}else{for(g=[],h=0;h<f;h++){g[h]=b.call(c,e[h],void 0,a)}}return g};goog.structs.some=function(a,b,c){if("function"==typeof a.some){return a.some(b,c)}if(goog.isArrayLike(a)||goog.isString(a)){return goog.array.some(a,b,c)}for(var d=goog.structs.getKeys(a),e=goog.structs.getValues(a),f=e.length,g=0;g<f;g++){if(b.call(c,e[g],d&&d[g],a)){return !0}}return !1};goog.structs.every=function(a,b,c){if("function"==typeof a.every){return a.every(b,c)}if(goog.isArrayLike(a)||goog.isString(a)){return goog.array.every(a,b,c)}for(var d=goog.structs.getKeys(a),e=goog.structs.getValues(a),f=e.length,g=0;g<f;g++){if(!b.call(c,e[g],d&&d[g],a)){return !1}}return !0};goog.structs.Trie=function(a){this.value_=void 0;this.childNodes_={};a&&this.setAll(a)};goog.structs.Trie.prototype.set=function(a,b){this.setOrAdd_(a,b,!1)};goog.structs.Trie.prototype.add=function(a,b){this.setOrAdd_(a,b,!0)};goog.structs.Trie.prototype.setOrAdd_=function(a,b,c){for(var d=this,e=0;e<a.length;e++){var f=a.charAt(e);d.childNodes_[f]||(d.childNodes_[f]=new goog.structs.Trie);d=d.childNodes_[f]}if(c&&void 0!==d.value_){throw Error('The collection already contains the key "'+a+'"')}d.value_=b};goog.structs.Trie.prototype.setAll=function(a){var b=goog.structs.getKeys(a);a=goog.structs.getValues(a);for(var c=0;c<b.length;c++){this.set(b[c],a[c])}};goog.structs.Trie.prototype.getChildNode_=function(a){for(var b=this,c=0;c<a.length;c++){var d=a.charAt(c);b=b.childNodes_[d];if(!b){return}}return b};goog.structs.Trie.prototype.get=function(a){return(a=this.getChildNode_(a))?a.value_:void 0};goog.structs.Trie.prototype.getKeyAndPrefixes=function(a,b){var c=this,d={},e=b||0;void 0!==c.value_&&(d[e]=c.value_);for(;e<a.length;e++){var f=a.charAt(e);if(!(f in c.childNodes_)){break}c=c.childNodes_[f];void 0!==c.value_&&(d[e]=c.value_)
-}return d};goog.structs.Trie.prototype.getValues=function(){var a=[];this.getValuesInternal_(a);return a};goog.structs.Trie.prototype.getValuesInternal_=function(a){void 0!==this.value_&&a.push(this.value_);for(var b in this.childNodes_){this.childNodes_[b].getValuesInternal_(a)}};goog.structs.Trie.prototype.getKeys=function(a){var b=[];if(a){for(var c=this,d=0;d<a.length;d++){var e=a.charAt(d);if(!c.childNodes_[e]){return[]}c=c.childNodes_[e]}c.getKeysInternal_(a,b)}else{this.getKeysInternal_("",b)}return b};goog.structs.Trie.prototype.getKeysInternal_=function(a,b){void 0!==this.value_&&b.push(a);for(var c in this.childNodes_){this.childNodes_[c].getKeysInternal_(a+c,b)}};goog.structs.Trie.prototype.containsKey=function(a){return void 0!==this.get(a)};goog.structs.Trie.prototype.containsPrefix=function(a){return 0==a.length?!this.isEmpty():!!this.getChildNode_(a)};goog.structs.Trie.prototype.containsValue=function(a){if(this.value_===a){return !0}for(var b in this.childNodes_){if(this.childNodes_[b].containsValue(a)){return !0}}return !1};goog.structs.Trie.prototype.clear=function(){this.childNodes_={};this.value_=void 0};goog.structs.Trie.prototype.remove=function(a){for(var b=this,c=[],d=0;d<a.length;d++){var e=a.charAt(d);if(!b.childNodes_[e]){throw Error('The collection does not have the key "'+a+'"')}c.push([b,e]);b=b.childNodes_[e]}a=b.value_;for(delete b.value_;0<c.length;){if(e=c.pop(),b=e[0],e=e[1],b.childNodes_[e].isEmpty()){delete b.childNodes_[e]}else{break}}return a};goog.structs.Trie.prototype.clone=function(){return new goog.structs.Trie(this)};goog.structs.Trie.prototype.getCount=function(){return goog.structs.getCount(this.getValues())};goog.structs.Trie.prototype.isEmpty=function(){return void 0===this.value_&&goog.object.isEmpty(this.childNodes_)};goog.ui.tree.TypeAhead=function(){this.nodeMap_=new goog.structs.Trie;this.buffer_="";this.matchingNodes_=this.matchingLabels_=null;this.matchingNodeIndex_=this.matchingLabelIndex_=0};goog.ui.tree.TypeAhead.Offset={DOWN:1,UP:-1};
-goog.ui.tree.TypeAhead.prototype.handleNavigation=function(a){var b=!1;switch(a.keyCode){case goog.events.KeyCodes.DOWN:case goog.events.KeyCodes.UP:a.ctrlKey&&(this.jumpTo_(a.keyCode==goog.events.KeyCodes.DOWN?goog.ui.tree.TypeAhead.Offset.DOWN:goog.ui.tree.TypeAhead.Offset.UP),b=!0);break;case goog.events.KeyCodes.BACKSPACE:a=this.buffer_.length-1;b=!0;0<a?(this.buffer_=this.buffer_.substring(0,a),this.jumpToLabel_(this.buffer_)):0==a?this.buffer_="":b=!1;break;case goog.events.KeyCodes.ESC:this.buffer_="",b=!0}return b};goog.ui.tree.TypeAhead.prototype.handleTypeAheadChar=function(a){var b=!1;a.ctrlKey||a.altKey||(a=String.fromCharCode(a.charCode||a.keyCode).toLowerCase(),goog.string.isUnicodeChar(a)&&(" "!=a||this.buffer_)&&(this.buffer_+=a,b=this.jumpToLabel_(this.buffer_)));return b};goog.ui.tree.TypeAhead.prototype.setNodeInMap=function(a){var b=a.getText();if(b&&!goog.string.isEmptyOrWhitespace(goog.string.makeSafe(b))){b=b.toLowerCase();var c=this.nodeMap_.get(b);c?c.push(a):this.nodeMap_.set(b,[a])}};goog.ui.tree.TypeAhead.prototype.removeNodeFromMap=function(a){var b=a.getText();if(b&&!goog.string.isEmptyOrWhitespace(goog.string.makeSafe(b))){b=b.toLowerCase();var c=this.nodeMap_.get(b);if(c){for(var d=a.getChildCount(),e=0;e<d;e++){this.removeNodeFromMap(a.getChildAt(e))}goog.array.remove(c,a);c.length||this.nodeMap_.remove(b)}}};goog.ui.tree.TypeAhead.prototype.jumpToLabel_=function(a){var b=!1;(a=this.nodeMap_.getKeys(a))&&a.length&&(this.matchingLabelIndex_=this.matchingNodeIndex_=0,b=this.nodeMap_.get(a[0]),b=this.selectMatchingNode_(b))&&(this.matchingLabels_=a);return b};goog.ui.tree.TypeAhead.prototype.jumpTo_=function(a){var b=!1,c=this.matchingLabels_;if(c){b=null;var d=!1;if(this.matchingNodes_){var e=this.matchingNodeIndex_+a;0<=e&&e<this.matchingNodes_.length?(this.matchingNodeIndex_=e,b=this.matchingNodes_):d=!0}b||(e=this.matchingLabelIndex_+a,0<=e&&e<c.length&&(this.matchingLabelIndex_=e),c.length>this.matchingLabelIndex_&&(b=this.nodeMap_.get(c[this.matchingLabelIndex_])),b&&b.length&&d&&(this.matchingNodeIndex_=a==goog.ui.tree.TypeAhead.Offset.UP?b.length-1:0));
-if(b=this.selectMatchingNode_(b)){this.matchingLabels_=c}}return b};goog.ui.tree.TypeAhead.prototype.selectMatchingNode_=function(a){if(a){if(this.matchingNodeIndex_<a.length){var b=a[this.matchingNodeIndex_];this.matchingNodes_=a}b&&(b.reveal(),b.select())}return !!b};goog.ui.tree.TypeAhead.prototype.clear=function(){this.buffer_=""};goog.ui.tree.TreeControl=function(a,b,c){goog.ui.tree.BaseNode.call(this,a,b,c);this.setExpandedInternal(!0);this.setSelectedInternal(!0);this.selectedItem_=this;this.typeAhead_=new goog.ui.tree.TypeAhead;this.focusHandler_=this.keyHandler_=null;this.logger_=goog.log.getLogger("this");this.focused_=!1;this.focusedNode_=null;this.showRootLines_=this.showRootNode_=this.showExpandIcons_=this.showLines_=!0;if(goog.userAgent.IE){try{document.execCommand("BackgroundImageCache",!1,!0)}catch(d){goog.log.warning(this.logger_,"Failed to enable background image cache")}}};goog.inherits(goog.ui.tree.TreeControl,goog.ui.tree.BaseNode);goog.ui.tree.TreeControl.prototype.getTree=function(){return this};goog.ui.tree.TreeControl.prototype.getDepth=function(){return 0};goog.ui.tree.TreeControl.prototype.reveal=function(){};goog.ui.tree.TreeControl.prototype.handleFocus_=function(a){this.focused_=!0;goog.dom.classlist.add(goog.asserts.assert(this.getElement()),"focused");this.selectedItem_&&this.selectedItem_.select()};goog.ui.tree.TreeControl.prototype.handleBlur_=function(a){this.focused_=!1;goog.dom.classlist.remove(goog.asserts.assert(this.getElement()),"focused")};goog.ui.tree.TreeControl.prototype.hasFocus=function(){return this.focused_};goog.ui.tree.TreeControl.prototype.getExpanded=function(){return !this.showRootNode_||goog.ui.tree.TreeControl.superClass_.getExpanded.call(this)};goog.ui.tree.TreeControl.prototype.setExpanded=function(a){this.showRootNode_?goog.ui.tree.TreeControl.superClass_.setExpanded.call(this,a):this.setExpandedInternal(a)};goog.ui.tree.TreeControl.prototype.getExpandIconSafeHtml=function(){return goog.html.SafeHtml.EMPTY};goog.ui.tree.TreeControl.prototype.getIconElement=function(){var a=this.getRowElement();
-return a?a.firstChild:null};goog.ui.tree.TreeControl.prototype.getExpandIconElement=function(){return null};goog.ui.tree.TreeControl.prototype.updateExpandIcon=function(){};goog.ui.tree.TreeControl.prototype.getRowClassName=function(){return goog.ui.tree.TreeControl.superClass_.getRowClassName.call(this)+(this.showRootNode_?"":" "+this.getConfig().cssHideRoot)};goog.ui.tree.TreeControl.prototype.getCalculatedIconClass=function(){var a=this.getExpanded(),b=this.getExpandedIconClass();if(a&&b){return b}b=this.getIconClass();if(!a&&b){return b}b=this.getConfig();return a&&b.cssExpandedRootIcon?b.cssTreeIcon+" "+b.cssExpandedRootIcon:!a&&b.cssCollapsedRootIcon?b.cssTreeIcon+" "+b.cssCollapsedRootIcon:""};goog.ui.tree.TreeControl.prototype.setSelectedItem=function(a){if(this.selectedItem_!=a){var b=!1;this.selectedItem_&&(b=this.selectedItem_==this.focusedNode_,this.selectedItem_.setSelectedInternal(!1));if(this.selectedItem_=a){a.setSelectedInternal(!0),b&&a.select()}this.dispatchEvent(goog.events.EventType.CHANGE)}};goog.ui.tree.TreeControl.prototype.getSelectedItem=function(){return this.selectedItem_};goog.ui.tree.TreeControl.prototype.setShowLines=function(a){this.showLines_!=a&&(this.showLines_=a,this.isInDocument()&&this.updateLinesAndExpandIcons_())};goog.ui.tree.TreeControl.prototype.getShowLines=function(){return this.showLines_};goog.ui.tree.TreeControl.prototype.updateLinesAndExpandIcons_=function(){function a(e){var f=e.getChildrenElement();if(f){var g=!c||b==e.getParent()&&!d?e.getConfig().cssChildrenNoLines:e.getConfig().cssChildren;f.className=g;if(f=e.getExpandIconElement()){f.className=e.getExpandIconClass()}}e.forEachChild(a)}var b=this,c=b.getShowLines(),d=b.getShowRootLines();a(this)};goog.ui.tree.TreeControl.prototype.setShowRootLines=function(a){this.showRootLines_!=a&&(this.showRootLines_=a,this.isInDocument()&&this.updateLinesAndExpandIcons_())};goog.ui.tree.TreeControl.prototype.getShowRootLines=function(){return this.showRootLines_};goog.ui.tree.TreeControl.prototype.setShowExpandIcons=function(a){this.showExpandIcons_!=a&&(this.showExpandIcons_=a,this.isInDocument()&&this.updateLinesAndExpandIcons_())
-};goog.ui.tree.TreeControl.prototype.getShowExpandIcons=function(){return this.showExpandIcons_};goog.ui.tree.TreeControl.prototype.setShowRootNode=function(a){if(this.showRootNode_!=a){this.showRootNode_=a;if(this.isInDocument()){var b=this.getRowElement();b&&(b.className=this.getRowClassName())}!a&&this.getSelectedItem()==this&&this.getFirstChild()&&this.setSelectedItem(this.getFirstChild())}};goog.ui.tree.TreeControl.prototype.getShowRootNode=function(){return this.showRootNode_};goog.ui.tree.TreeControl.prototype.initAccessibility=function(){goog.ui.tree.TreeControl.superClass_.initAccessibility.call(this);var a=this.getElement();goog.asserts.assert(a,"The DOM element for the tree cannot be null.");goog.a11y.aria.setRole(a,"tree");goog.a11y.aria.setState(a,"labelledby",this.getLabelElement().id)};goog.ui.tree.TreeControl.prototype.enterDocument=function(){goog.ui.tree.TreeControl.superClass_.enterDocument.call(this);var a=this.getElement();a.className=this.getConfig().cssRoot;a.setAttribute("hideFocus","true");this.attachEvents_();this.initAccessibility()};goog.ui.tree.TreeControl.prototype.exitDocument=function(){goog.ui.tree.TreeControl.superClass_.exitDocument.call(this);this.detachEvents_()};goog.ui.tree.TreeControl.prototype.attachEvents_=function(){var a=this.getElement();a.tabIndex=0;var b=this.keyHandler_=new goog.events.KeyHandler(a),c=this.focusHandler_=new goog.events.FocusHandler(a);this.getHandler().listen(c,goog.events.FocusHandler.EventType.FOCUSOUT,this.handleBlur_).listen(c,goog.events.FocusHandler.EventType.FOCUSIN,this.handleFocus_).listen(b,goog.events.KeyHandler.EventType.KEY,this.handleKeyEvent).listen(a,goog.events.EventType.MOUSEDOWN,this.handleMouseEvent_).listen(a,goog.events.EventType.CLICK,this.handleMouseEvent_).listen(a,goog.events.EventType.DBLCLICK,this.handleMouseEvent_)};goog.ui.tree.TreeControl.prototype.detachEvents_=function(){this.keyHandler_.dispose();this.keyHandler_=null;this.focusHandler_.dispose();this.focusHandler_=null
-};goog.ui.tree.TreeControl.prototype.handleMouseEvent_=function(a){goog.log.fine(this.logger_,"Received event "+a.type);var b=this.getNodeFromEvent_(a);if(b){switch(a.type){case goog.events.EventType.MOUSEDOWN:b.onMouseDown(a);break;case goog.events.EventType.CLICK:b.onClick_(a);break;case goog.events.EventType.DBLCLICK:b.onDoubleClick_(a)}}};goog.ui.tree.TreeControl.prototype.handleKeyEvent=function(a){var b;(b=this.typeAhead_.handleNavigation(a)||this.selectedItem_&&this.selectedItem_.onKeyDown(a)||this.typeAhead_.handleTypeAheadChar(a))&&a.preventDefault();return b};goog.ui.tree.TreeControl.prototype.getNodeFromEvent_=function(a){for(var b=a.target;null!=b;){if(a=goog.ui.tree.BaseNode.allNodes[b.id]){return a}if(b==this.getElement()){break}b=b.parentNode}return null};goog.ui.tree.TreeControl.prototype.createNode=function(a){return new goog.ui.tree.TreeNode(a||goog.html.SafeHtml.EMPTY,this.getConfig(),this.getDomHelper())};goog.ui.tree.TreeControl.prototype.setNode=function(a){this.typeAhead_.setNodeInMap(a)};goog.ui.tree.TreeControl.prototype.removeNode=function(a){this.typeAhead_.removeNodeFromMap(a)};goog.ui.tree.TreeControl.prototype.clearTypeAhead=function(){this.typeAhead_.clear()};goog.ui.tree.TreeControl.defaultConfig=goog.ui.tree.BaseNode.defaultConfig;var Blockly={};Blockly.Blocks=Object(null);Blockly.Touch={};Blockly.Touch.touchIdentifier_=null;Blockly.Touch.TOUCH_MAP={};goog.events.BrowserFeature.TOUCH_ENABLED&&(Blockly.Touch.TOUCH_MAP={mousedown:["touchstart"],mousemove:["touchmove"],mouseup:["touchend","touchcancel"]});Blockly.longPid_=0;Blockly.longStart_=function(a,b){Blockly.longStop_();1==a.changedTouches.length&&(Blockly.longPid_=setTimeout(function(){a.button=2;a.clientX=a.changedTouches[0].clientX;a.clientY=a.changedTouches[0].clientY;b&&b.handleRightClick(a)},Blockly.LONGPRESS))};Blockly.longStop_=function(){Blockly.longPid_&&(clearTimeout(Blockly.longPid_),Blockly.longPid_=0)};Blockly.Touch.clearTouchIdentifier=function(){Blockly.Touch.touchIdentifier_=null
-};Blockly.Touch.shouldHandleEvent=function(a){return !Blockly.Touch.isMouseOrTouchEvent(a)||Blockly.Touch.checkTouchIdentifier(a)};Blockly.Touch.getTouchIdentifierFromEvent=function(a){return a.changedTouches&&a.changedTouches[0]&&void 0!=a.changedTouches[0].identifier&&null!=a.changedTouches[0].identifier?a.changedTouches[0].identifier:"mouse"};Blockly.Touch.checkTouchIdentifier=function(a){var b=Blockly.Touch.getTouchIdentifierFromEvent(a);return void 0!=Blockly.Touch.touchIdentifier_&&null!=Blockly.Touch.touchIdentifier_?Blockly.Touch.touchIdentifier_==b:"mousedown"==a.type||"touchstart"==a.type?(Blockly.Touch.touchIdentifier_=b,!0):!1};Blockly.Touch.setClientFromTouch=function(a){if(goog.string.startsWith(a.type,"touch")){var b=a.changedTouches[0];a.clientX=b.clientX;a.clientY=b.clientY}};Blockly.Touch.isMouseOrTouchEvent=function(a){return goog.string.startsWith(a.type,"touch")||goog.string.startsWith(a.type,"mouse")};Blockly.Touch.splitEventByTouches=function(a){var b=[];if(a.changedTouches){for(var c=0;c<a.changedTouches.length;c++){b[c]={type:a.type,changedTouches:[a.changedTouches[c]],target:a.target,stopPropagation:function(){a.stopPropagation()},preventDefault:function(){a.preventDefault()}}}}else{b.push(a)}return b};Blockly.VariableMap=function(a){this.variableMap_={};this.workspace=a};Blockly.VariableMap.prototype.clear=function(){this.variableMap_=Object(null)};Blockly.VariableMap.prototype.renameVariable=function(a,b){var c=this.getVariable(b),d=-1,e=-1,f="";if(a||c){f=(a||c).type}var g=this.getVariablesOfType(f);a&&(d=g.indexOf(a));c&&(e=g.indexOf(c));-1==d&&-1==e?(this.createVariable(b,""),console.log("Tried to rename an non-existent variable.")):d==e||-1!=d&&-1==e?(c=this.variableMap_[f][d],Blockly.Events.fire(new Blockly.Events.VarRename(c,b)),c.name=b):-1!=d&&-1!=e&&(c=this.variableMap_[f][e],Blockly.Events.fire(new Blockly.Events.VarRename(c,b)),Blockly.Events.fire(new Blockly.Events.VarDelete(this.variableMap_[f][d])),c.name=b,this.variableMap_[f].splice(d,1))
-};Blockly.VariableMap.prototype.createVariable=function(a,b,c){var d=this.getVariable(a);if(d){if(b&&d.type!=b){throw Error('Variable "'+a+'" is already in use and its type is "'+d.type+'" which conflicts with the passed in type, "'+b+'".')}if(c&&d.getId()!=c){throw Error('Variable "'+a+'" is already in use and its id is "'+d.getId()+'" which conflicts with the passed in id, "'+c+'".')}return d}if(c&&this.getVariableById(c)){throw Error('Variable id, "'+c+'", is already in use.')}c=c||Blockly.utils.genUid();b=b||"";d=new Blockly.VariableModel(this.workspace,a,b,c);this.variableMap_[b]?this.variableMap_[b].push(d):this.variableMap_[b]=[d];return d};Blockly.VariableMap.prototype.deleteVariable=function(a){for(var b=this.variableMap_[a.type],c=0,d;d=b[c];c++){if(d.getId()==a.getId()){b.splice(c,1);Blockly.Events.fire(new Blockly.Events.VarDelete(a));break}}};Blockly.VariableMap.prototype.getVariable=function(a){for(var b=Object.keys(this.variableMap_),c=0;c<b.length;c++){for(var d=b[c],e=0,f;f=this.variableMap_[d][e];e++){if(Blockly.Names.equals(f.name,a)){return f}}}return null};Blockly.VariableMap.prototype.getVariableById=function(a){for(var b=Object.keys(this.variableMap_),c=0;c<b.length;c++){for(var d=b[c],e=0,f;f=this.variableMap_[d][e];e++){if(f.getId()==a){return f}}}return null};Blockly.VariableMap.prototype.getVariablesOfType=function(a){return(a=this.variableMap_[a||""])?a.slice():[]};Blockly.VariableMap.prototype.getVariableTypes=function(){return Object.keys(this.variableMap_)};Blockly.VariableMap.prototype.getAllVariables=function(){for(var a=[],b=Object.keys(this.variableMap_),c=0;c<b.length;c++){a=a.concat(this.variableMap_[b[c]])}return a};Blockly.Workspace=function(a){this.id=Blockly.utils.genUid();Blockly.Workspace.WorkspaceDB_[this.id]=this;this.options=a||{};this.RTL=!!this.options.RTL;this.horizontalLayout=!!this.options.horizontalLayout;this.toolboxPosition=this.options.toolboxPosition;this.topBlocks_=[];this.listeners_=[];this.undoStack_=[];this.redoStack_=[];
-this.blockDB_=Object.create(null);this.variableMap_=new Blockly.VariableMap(this)};Blockly.Workspace.prototype.rendered=!1;Blockly.Workspace.prototype.MAX_UNDO=1024;Blockly.Workspace.prototype.dispose=function(){this.listeners_.length=0;this.clear();delete Blockly.Workspace.WorkspaceDB_[this.id]};Blockly.Workspace.SCAN_ANGLE=3;Blockly.Workspace.prototype.addTopBlock=function(a){this.topBlocks_.push(a);if(this.isFlyout){a=Blockly.Variables.allUsedVariables(a);for(var b=0,c;c=a[b];b++){this.getVariable(c)||this.createVariable(c)}}};Blockly.Workspace.prototype.removeTopBlock=function(a){if(!goog.array.remove(this.topBlocks_,a)){throw"Block not present in workspace's list of top-most blocks."}};Blockly.Workspace.prototype.getTopBlocks=function(a){var b=[].concat(this.topBlocks_);if(a&&1<b.length){var c=Math.sin(goog.math.toRadians(Blockly.Workspace.SCAN_ANGLE));this.RTL&&(c*=-1);b.sort(function(a,b){var d=a.getRelativeToSurfaceXY(),e=b.getRelativeToSurfaceXY();return d.y+c*d.x-(e.y+c*e.x)})}return b};Blockly.Workspace.prototype.getAllBlocks=function(){for(var a=this.getTopBlocks(!1),b=0;b<a.length;b++){a.push.apply(a,a[b].getChildren())}return a};Blockly.Workspace.prototype.clear=function(){var a=Blockly.Events.getGroup();for(a||Blockly.Events.setGroup(!0);this.topBlocks_.length;){this.topBlocks_[0].dispose()}a||Blockly.Events.setGroup(!1);this.variableMap_.clear()};Blockly.Workspace.prototype.updateVariableStore=function(a){if(!this.isFlyout){for(var b=Blockly.Variables.allUsedVariables(this),c=[],d=0,e;e=b[d];d++){var f=this.getVariable(e);f?c.push({name:f.name,type:f.type,id:f.getId()}):c.push({name:e,type:null,id:null})}a&&this.variableMap_.clear();for(d=0;a=c[d];d++){this.getVariable(a.name)||this.createVariable(a.name,a.type,a.id)}}};Blockly.Workspace.prototype.renameVariableInternal_=function(a,b){var c=this.getVariable(b);if(a&&c&&a.type!=c.type){throw Error('Variable "'+a.name+'" is type "'+a.type+'" and variable "'+b+'" is type "'+c.type+'". Both must be the same type.')
-}if(c&&c.name!=b){var d=c.name}Blockly.Events.setGroup(!0);c=this.getAllBlocks();for(var e=0;e<c.length;e++){c[e].renameVar(a.name,b),d&&c[e].renameVar(d,b)}this.variableMap_.renameVariable(a,b);Blockly.Events.setGroup(!1)};Blockly.Workspace.prototype.renameVariable=function(a,b){var c=this.getVariable(a);this.renameVariableInternal_(c,b)};Blockly.Workspace.prototype.renameVariableById=function(a,b){var c=this.getVariableById(a);this.renameVariableInternal_(c,b)};Blockly.Workspace.prototype.createVariable=function(a,b,c){return this.variableMap_.createVariable(a,b,c)};Blockly.Workspace.prototype.getVariableUses=function(a){for(var b=[],c=this.getAllBlocks(),d=0;d<c.length;d++){var e=c[d].getVars();if(e){for(var f=0;f<e.length;f++){var g=e[f];g&&a&&Blockly.Names.equals(g,a)&&b.push(c[d])}}}return b};Blockly.Workspace.prototype.deleteVariable=function(a){for(var b=this.getVariableUses(a),c=0,d;d=b[c];c++){if("procedures_defnoreturn"==d.type||"procedures_defreturn"==d.type){b=d.getFieldValue("NAME");Blockly.alert(Blockly.Msg.CANNOT_DELETE_VARIABLE_PROCEDURE.replace("%1",a).replace("%2",b));return}}var e=this,f=e.getVariable(a);1<b.length?Blockly.confirm(Blockly.Msg.DELETE_VARIABLE_CONFIRMATION.replace("%1",String(b.length)).replace("%2",a),function(a){a&&e.deleteVariableInternal_(f)}):this.deleteVariableInternal_(f)};Blockly.Workspace.prototype.deleteVariableById=function(a){var b=this.getVariableById(a);b?this.deleteVariableInternal_(b):console.warn("Can't delete non-existent variable: "+a)};Blockly.Workspace.prototype.deleteVariableInternal_=function(a){var b=this.getVariableUses(a.name);Blockly.Events.setGroup(!0);for(var c=0;c<b.length;c++){b[c].dispose(!0,!1)}this.variableMap_.deleteVariable(a);Blockly.Events.setGroup(!1)};Blockly.Workspace.prototype.variableIndexOf=function(a){console.warn("Deprecated call to Blockly.Workspace.prototype.variableIndexOf");return -1};Blockly.Workspace.prototype.getVariable=function(a){return this.variableMap_.getVariable(a)};Blockly.Workspace.prototype.getVariableById=function(a){return this.variableMap_.getVariableById(a)
-};Blockly.Workspace.prototype.getWidth=function(){return 0};Blockly.Workspace.prototype.newBlock=function(a,b){return new Blockly.Block(this,a,b)};Blockly.Workspace.prototype.remainingCapacity=function(){return isNaN(this.options.maxBlocks)?Infinity:this.options.maxBlocks-this.getAllBlocks().length};Blockly.Workspace.prototype.undo=function(a){var b=a?this.redoStack_:this.undoStack_,c=a?this.undoStack_:this.redoStack_,d=b.pop();if(d){for(var e=[d];b.length&&d.group&&d.group==b[b.length-1].group;){e.push(b.pop())}for(b=0;d=e[b];b++){c.push(d)}e=Blockly.Events.filter(e,a);Blockly.Events.recordUndo=!1;try{for(b=0;d=e[b];b++){d.run(a)}}finally{Blockly.Events.recordUndo=!0}}};Blockly.Workspace.prototype.clearUndo=function(){this.undoStack_.length=0;this.redoStack_.length=0;Blockly.Events.clearPendingUndo()};Blockly.Workspace.prototype.addChangeListener=function(a){this.listeners_.push(a);return a};Blockly.Workspace.prototype.removeChangeListener=function(a){goog.array.remove(this.listeners_,a)};Blockly.Workspace.prototype.fireChangeListener=function(a){a.recordUndo&&(this.undoStack_.push(a),this.redoStack_.length=0,this.undoStack_.length>this.MAX_UNDO&&this.undoStack_.unshift());for(var b=0,c;c=this.listeners_[b];b++){c(a)}};Blockly.Workspace.prototype.getBlockById=function(a){return this.blockDB_[a]||null};Blockly.Workspace.prototype.allInputsFilled=function(a){for(var b=this.getTopBlocks(!1),c=0,d;d=b[c];c++){if(!d.allInputsFilled(a)){return !1}}return !0};Blockly.Workspace.prototype.getVariablesOfType=function(a){return this.variableMap_.getVariablesOfType(a)};Blockly.Workspace.prototype.getVariableTypes=function(){return this.variableMap_.getVariableTypes()};Blockly.Workspace.prototype.getAllVariables=function(){return this.variableMap_.getAllVariables()};Blockly.Workspace.WorkspaceDB_=Object.create(null);Blockly.Workspace.getById=function(a){return Blockly.Workspace.WorkspaceDB_[a]||null};Blockly.Workspace.prototype.clear=Blockly.Workspace.prototype.clear;Blockly.Workspace.prototype.clearUndo=Blockly.Workspace.prototype.clearUndo;
-Blockly.Workspace.prototype.addChangeListener=Blockly.Workspace.prototype.addChangeListener;Blockly.Workspace.prototype.removeChangeListener=Blockly.Workspace.prototype.removeChangeListener;Blockly.Bubble=function(a,b,c,d,e,f){this.workspace_=a;this.content_=b;this.shape_=c;c=Blockly.Bubble.ARROW_ANGLE;this.workspace_.RTL&&(c=-c);this.arrow_radians_=goog.math.toRadians(c);a.getBubbleCanvas().appendChild(this.createDom_(b,!(!e||!f)));this.setAnchorLocation(d);e&&f||(b=this.content_.getBBox(),e=b.width+2*Blockly.Bubble.BORDER_WIDTH,f=b.height+2*Blockly.Bubble.BORDER_WIDTH);this.setBubbleSize(e,f);this.positionBubble_();this.renderArrow_();this.rendered_=!0;a.options.readOnly||(Blockly.bindEventWithChecks_(this.bubbleBack_,"mousedown",this,this.bubbleMouseDown_),this.resizeGroup_&&Blockly.bindEventWithChecks_(this.resizeGroup_,"mousedown",this,this.resizeMouseDown_))};Blockly.Bubble.BORDER_WIDTH=6;Blockly.Bubble.ARROW_THICKNESS=5;Blockly.Bubble.ARROW_ANGLE=20;Blockly.Bubble.ARROW_BEND=4;Blockly.Bubble.ANCHOR_RADIUS=8;Blockly.Bubble.onMouseUpWrapper_=null;Blockly.Bubble.onMouseMoveWrapper_=null;Blockly.Bubble.prototype.resizeCallback_=null;Blockly.Bubble.unbindDragEvents_=function(){Blockly.Bubble.onMouseUpWrapper_&&(Blockly.unbindEvent_(Blockly.Bubble.onMouseUpWrapper_),Blockly.Bubble.onMouseUpWrapper_=null);Blockly.Bubble.onMouseMoveWrapper_&&(Blockly.unbindEvent_(Blockly.Bubble.onMouseMoveWrapper_),Blockly.Bubble.onMouseMoveWrapper_=null)};Blockly.Bubble.bubbleMouseUp_=function(){Blockly.Touch.clearTouchIdentifier();Blockly.Bubble.unbindDragEvents_()};Blockly.Bubble.prototype.rendered_=!1;Blockly.Bubble.prototype.anchorXY_=null;Blockly.Bubble.prototype.relativeLeft_=0;Blockly.Bubble.prototype.relativeTop_=0;Blockly.Bubble.prototype.width_=0;Blockly.Bubble.prototype.height_=0;Blockly.Bubble.prototype.autoLayout_=!0;Blockly.Bubble.prototype.createDom_=function(a,b){this.bubbleGroup_=Blockly.utils.createSvgElement("g",{},null);var c={filter:"url(#"+this.workspace_.options.embossFilterId+")"};
--1!=goog.userAgent.getUserAgentString().indexOf("JavaFX")&&(c={});c=Blockly.utils.createSvgElement("g",c,this.bubbleGroup_);this.bubbleArrow_=Blockly.utils.createSvgElement("path",{},c);this.bubbleBack_=Blockly.utils.createSvgElement("rect",{"class":"blocklyDraggable",x:0,y:0,rx:Blockly.Bubble.BORDER_WIDTH,ry:Blockly.Bubble.BORDER_WIDTH},c);b?(this.resizeGroup_=Blockly.utils.createSvgElement("g",{"class":this.workspace_.RTL?"blocklyResizeSW":"blocklyResizeSE"},this.bubbleGroup_),c=2*Blockly.Bubble.BORDER_WIDTH,Blockly.utils.createSvgElement("polygon",{points:"0,x x,x x,0".replace(/x/g,c.toString())},this.resizeGroup_),Blockly.utils.createSvgElement("line",{"class":"blocklyResizeLine",x1:c/3,y1:c-1,x2:c-1,y2:c/3},this.resizeGroup_),Blockly.utils.createSvgElement("line",{"class":"blocklyResizeLine",x1:2*c/3,y1:c-1,x2:c-1,y2:2*c/3},this.resizeGroup_)):this.resizeGroup_=null;this.bubbleGroup_.appendChild(a);return this.bubbleGroup_};Blockly.Bubble.prototype.bubbleMouseDown_=function(a){this.promote_();Blockly.Bubble.unbindDragEvents_();Blockly.utils.isRightButton(a)?a.stopPropagation():Blockly.utils.isTargetInput(a)||(this.workspace_.startDrag(a,new goog.math.Coordinate(this.workspace_.RTL?-this.relativeLeft_:this.relativeLeft_,this.relativeTop_)),Blockly.Bubble.onMouseUpWrapper_=Blockly.bindEventWithChecks_(document,"mouseup",this,Blockly.Bubble.bubbleMouseUp_),Blockly.Bubble.onMouseMoveWrapper_=Blockly.bindEventWithChecks_(document,"mousemove",this,this.bubbleMouseMove_),Blockly.hideChaff(),a.stopPropagation())};Blockly.Bubble.prototype.bubbleMouseMove_=function(a){this.autoLayout_=!1;a=this.workspace_.moveDrag(a);this.relativeLeft_=this.workspace_.RTL?-a.x:a.x;this.relativeTop_=a.y;this.positionBubble_();this.renderArrow_()};Blockly.Bubble.prototype.resizeMouseDown_=function(a){this.promote_();Blockly.Bubble.unbindDragEvents_();Blockly.utils.isRightButton(a)||(this.workspace_.startDrag(a,new goog.math.Coordinate(this.workspace_.RTL?-this.width_:this.width_,this.height_)),Blockly.Bubble.onMouseUpWrapper_=Blockly.bindEventWithChecks_(document,"mouseup",this,Blockly.Bubble.bubbleMouseUp_),Blockly.Bubble.onMouseMoveWrapper_=Blockly.bindEventWithChecks_(document,"mousemove",this,this.resizeMouseMove_),Blockly.hideChaff());
-a.stopPropagation()};Blockly.Bubble.prototype.resizeMouseMove_=function(a){this.autoLayout_=!1;a=this.workspace_.moveDrag(a);this.setBubbleSize(this.workspace_.RTL?-a.x:a.x,a.y);this.workspace_.RTL&&this.positionBubble_()};Blockly.Bubble.prototype.registerResizeEvent=function(a){this.resizeCallback_=a};Blockly.Bubble.prototype.promote_=function(){this.bubbleGroup_.parentNode.appendChild(this.bubbleGroup_)};Blockly.Bubble.prototype.setAnchorLocation=function(a){this.anchorXY_=a;this.rendered_&&this.positionBubble_()};Blockly.Bubble.prototype.layoutBubble_=function(){var a=-this.width_/4,b=-this.height_-Blockly.BlockSvg.MIN_BLOCK_Y,c=this.workspace_.getMetrics();c.viewWidth/=this.workspace_.scale;c.viewLeft/=this.workspace_.scale;var d=this.anchorXY_.x;this.workspace_.RTL?d-c.viewLeft-a-this.width_<Blockly.Scrollbar.scrollbarThickness?a=d-c.viewLeft-this.width_-Blockly.Scrollbar.scrollbarThickness:d-c.viewLeft-a>c.viewWidth&&(a=d-c.viewLeft-c.viewWidth):d+a<c.viewLeft?a=c.viewLeft-d:c.viewLeft+c.viewWidth<d+a+this.width_+Blockly.BlockSvg.SEP_SPACE_X+Blockly.Scrollbar.scrollbarThickness&&(a=c.viewLeft+c.viewWidth-d-this.width_-Blockly.Scrollbar.scrollbarThickness);this.anchorXY_.y+b<c.viewTop&&(b=this.shape_.getBBox().height);this.relativeLeft_=a;this.relativeTop_=b};Blockly.Bubble.prototype.positionBubble_=function(){var a=this.anchorXY_.x;a=this.workspace_.RTL?a-(this.relativeLeft_+this.width_):a+this.relativeLeft_;this.bubbleGroup_.setAttribute("transform","translate("+a+","+(this.relativeTop_+this.anchorXY_.y)+")")};Blockly.Bubble.prototype.getBubbleSize=function(){return{width:this.width_,height:this.height_}};Blockly.Bubble.prototype.setBubbleSize=function(a,b){var c=2*Blockly.Bubble.BORDER_WIDTH;a=Math.max(a,c+45);b=Math.max(b,c+20);this.width_=a;this.height_=b;this.bubbleBack_.setAttribute("width",a);this.bubbleBack_.setAttribute("height",b);this.resizeGroup_&&(this.workspace_.RTL?this.resizeGroup_.setAttribute("transform","translate("+2*Blockly.Bubble.BORDER_WIDTH+","+(b-c)+") scale(-1 1)"):this.resizeGroup_.setAttribute("transform","translate("+(a-c)+","+(b-c)+")"));
-this.rendered_&&(this.autoLayout_&&this.layoutBubble_(),this.positionBubble_(),this.renderArrow_());this.resizeCallback_&&this.resizeCallback_()};Blockly.Bubble.prototype.renderArrow_=function(){var a=[],b=this.width_/2,c=this.height_/2,d=-this.relativeLeft_,e=-this.relativeTop_;if(b==d&&c==e){a.push("M "+b+","+c)}else{e-=c;d-=b;this.workspace_.RTL&&(d*=-1);var f=Math.sqrt(e*e+d*d),g=Math.acos(d/f);0>e&&(g=2*Math.PI-g);var h=g+Math.PI/2;h>2*Math.PI&&(h-=2*Math.PI);var k=Math.sin(h),n=Math.cos(h),p=this.getBubbleSize();h=(p.width+p.height)/Blockly.Bubble.ARROW_THICKNESS;h=Math.min(h,p.width,p.height)/4;p=1-Blockly.Bubble.ANCHOR_RADIUS/f;d=b+p*d;e=c+p*e;p=b+h*n;var l=c+h*k;b-=h*n;c-=h*k;k=g+this.arrow_radians_;k>2*Math.PI&&(k-=2*Math.PI);g=Math.sin(k)*f/Blockly.Bubble.ARROW_BEND;f=Math.cos(k)*f/Blockly.Bubble.ARROW_BEND;a.push("M"+p+","+l);a.push("C"+(p+f)+","+(l+g)+" "+d+","+e+" "+d+","+e);a.push("C"+d+","+e+" "+(b+f)+","+(c+g)+" "+b+","+c)}a.push("z");this.bubbleArrow_.setAttribute("d",a.join(" "))};Blockly.Bubble.prototype.setColour=function(a){this.bubbleBack_.setAttribute("fill",a);this.bubbleArrow_.setAttribute("fill",a)};Blockly.Bubble.prototype.dispose=function(){Blockly.Bubble.unbindDragEvents_();goog.dom.removeNode(this.bubbleGroup_);this.shape_=this.content_=this.workspace_=this.resizeGroup_=this.bubbleBack_=this.bubbleArrow_=this.bubbleGroup_=null};Blockly.Icon=function(a){this.block_=a};Blockly.Icon.prototype.collapseHidden=!0;Blockly.Icon.prototype.SIZE=17;Blockly.Icon.prototype.bubble_=null;Blockly.Icon.prototype.iconXY_=null;Blockly.Icon.prototype.createIcon=function(){this.iconGroup_||(this.iconGroup_=Blockly.utils.createSvgElement("g",{"class":"blocklyIconGroup"},null),this.block_.isInFlyout&&Blockly.utils.addClass(this.iconGroup_,"blocklyIconGroupReadonly"),this.drawIcon_(this.iconGroup_),this.block_.getSvgRoot().appendChild(this.iconGroup_),Blockly.bindEventWithChecks_(this.iconGroup_,"mouseup",this,this.iconClick_),this.updateEditable())};Blockly.Icon.prototype.dispose=function(){goog.dom.removeNode(this.iconGroup_);
-this.iconGroup_=null;this.setVisible(!1);this.block_=null};Blockly.Icon.prototype.updateEditable=function(){};Blockly.Icon.prototype.isVisible=function(){return !!this.bubble_};Blockly.Icon.prototype.iconClick_=function(a){this.block_.workspace.isDragging()||this.block_.isInFlyout||Blockly.utils.isRightButton(a)||this.setVisible(!this.isVisible())};Blockly.Icon.prototype.updateColour=function(){this.isVisible()&&this.bubble_.setColour(this.block_.getColour())};Blockly.Icon.prototype.renderIcon=function(a){if(this.collapseHidden&&this.block_.isCollapsed()){return this.iconGroup_.setAttribute("display","none"),a}this.iconGroup_.setAttribute("display","block");var b=this.SIZE;this.block_.RTL&&(a-=b);this.iconGroup_.setAttribute("transform","translate("+a+",5)");this.computeIconLocation();return a=this.block_.RTL?a-Blockly.BlockSvg.SEP_SPACE_X:a+(b+Blockly.BlockSvg.SEP_SPACE_X)};Blockly.Icon.prototype.setIconLocation=function(a){this.iconXY_=a;this.isVisible()&&this.bubble_.setAnchorLocation(a)};Blockly.Icon.prototype.computeIconLocation=function(){var a=this.block_.getRelativeToSurfaceXY(),b=Blockly.utils.getRelativeXY(this.iconGroup_);a=new goog.math.Coordinate(a.x+b.x+this.SIZE/2,a.y+b.y+this.SIZE/2);goog.math.Coordinate.equals(this.getIconLocation(),a)||this.setIconLocation(a)};Blockly.Icon.prototype.getIconLocation=function(){return this.iconXY_};Blockly.Comment=function(a){Blockly.Comment.superClass_.constructor.call(this,a);this.createIcon()};goog.inherits(Blockly.Comment,Blockly.Icon);Blockly.Comment.prototype.text_="";Blockly.Comment.prototype.width_=160;Blockly.Comment.prototype.height_=80;Blockly.Comment.prototype.drawIcon_=function(a){Blockly.utils.createSvgElement("circle",{"class":"blocklyIconShape",r:"8",cx:"8",cy:"8"},a);Blockly.utils.createSvgElement("path",{"class":"blocklyIconSymbol",d:"m6.8,10h2c0.003,-0.617 0.271,-0.962 0.633,-1.266 2.875,-2.4050.607,-5.534 -3.765,-3.874v1.7c3.12,-1.657 3.698,0.118 2.336,1.25-1.201,0.998 -1.201,1.528 -1.204,2.19z"},a);
-Blockly.utils.createSvgElement("rect",{"class":"blocklyIconSymbol",x:"6.8",y:"10.78",height:"2",width:"2"},a)};Blockly.Comment.prototype.createEditor_=function(){this.foreignObject_=Blockly.utils.createSvgElement("foreignObject",{x:Blockly.Bubble.BORDER_WIDTH,y:Blockly.Bubble.BORDER_WIDTH},null);var a=document.createElementNS(Blockly.HTML_NS,"body");a.setAttribute("xmlns",Blockly.HTML_NS);a.className="blocklyMinimalBody";var b=document.createElementNS(Blockly.HTML_NS,"textarea");b.className="blocklyCommentTextarea";b.setAttribute("dir",this.block_.RTL?"RTL":"LTR");a.appendChild(b);this.textarea_=b;this.foreignObject_.appendChild(a);Blockly.bindEventWithChecks_(b,"mouseup",this,this.textareaFocus_);Blockly.bindEventWithChecks_(b,"wheel",this,function(a){a.stopPropagation()});Blockly.bindEventWithChecks_(b,"change",this,function(a){this.text_!=b.value&&(Blockly.Events.fire(new Blockly.Events.BlockChange(this.block_,"comment",null,this.text_,b.value)),this.text_=b.value)});setTimeout(function(){b.focus()},0);return this.foreignObject_};Blockly.Comment.prototype.updateEditable=function(){this.isVisible()&&(this.setVisible(!1),this.setVisible(!0));Blockly.Icon.prototype.updateEditable.call(this)};Blockly.Comment.prototype.resizeBubble_=function(){if(this.isVisible()){var a=this.bubble_.getBubbleSize(),b=2*Blockly.Bubble.BORDER_WIDTH;this.foreignObject_.setAttribute("width",a.width-b);this.foreignObject_.setAttribute("height",a.height-b);this.textarea_.style.width=a.width-b-4+"px";this.textarea_.style.height=a.height-b-4+"px"}};Blockly.Comment.prototype.setVisible=function(a){if(a!=this.isVisible()){if(Blockly.Events.fire(new Blockly.Events.Ui(this.block_,"commentOpen",!a,a)),!this.block_.isEditable()&&!this.textarea_||goog.userAgent.IE){Blockly.Warning.prototype.setVisible.call(this,a)}else{var b=this.getText(),c=this.getBubbleSize();a?(this.bubble_=new Blockly.Bubble(this.block_.workspace,this.createEditor_(),this.block_.svgPath_,this.iconXY_,this.width_,this.height_),this.bubble_.registerResizeEvent(this.resizeBubble_.bind(this)),this.updateColour()):(this.bubble_.dispose(),this.foreignObject_=this.textarea_=this.bubble_=null);
-this.setText(b);this.setBubbleSize(c.width,c.height)}}};Blockly.Comment.prototype.textareaFocus_=function(a){this.bubble_.promote_();this.textarea_.focus()};Blockly.Comment.prototype.getBubbleSize=function(){return this.isVisible()?this.bubble_.getBubbleSize():{width:this.width_,height:this.height_}};Blockly.Comment.prototype.setBubbleSize=function(a,b){this.textarea_?this.bubble_.setBubbleSize(a,b):(this.width_=a,this.height_=b)};Blockly.Comment.prototype.getText=function(){return this.textarea_?this.textarea_.value:this.text_};Blockly.Comment.prototype.setText=function(a){this.text_!=a&&(Blockly.Events.fire(new Blockly.Events.BlockChange(this.block_,"comment",null,this.text_,a)),this.text_=a);this.textarea_&&(this.textarea_.value=a)};Blockly.Comment.prototype.dispose=function(){Blockly.Events.isEnabled()&&this.setText("");this.block_.comment=null;Blockly.Icon.prototype.dispose.call(this)};Blockly.Connection=function(a,b){this.sourceBlock_=a;this.type=b;a.workspace.connectionDBList&&(this.db_=a.workspace.connectionDBList[b],this.dbOpposite_=a.workspace.connectionDBList[Blockly.OPPOSITE_TYPE[b]],this.hidden_=!this.db_)};Blockly.Connection.CAN_CONNECT=0;Blockly.Connection.REASON_SELF_CONNECTION=1;Blockly.Connection.REASON_WRONG_TYPE=2;Blockly.Connection.REASON_TARGET_NULL=3;Blockly.Connection.REASON_CHECKS_FAILED=4;Blockly.Connection.REASON_DIFFERENT_WORKSPACES=5;Blockly.Connection.REASON_SHADOW_PARENT=6;Blockly.Connection.prototype.targetConnection=null;Blockly.Connection.prototype.check_=null;Blockly.Connection.prototype.shadowDom_=null;Blockly.Connection.prototype.x_=0;Blockly.Connection.prototype.y_=0;Blockly.Connection.prototype.inDB_=!1;Blockly.Connection.prototype.db_=null;Blockly.Connection.prototype.dbOpposite_=null;Blockly.Connection.prototype.hidden_=null;Blockly.Connection.prototype.connect_=function(a){var b=this,c=b.getSourceBlock(),d=a.getSourceBlock();a.isConnected()&&a.disconnect();if(b.isConnected()){var e=b.targetBlock(),f=b.getShadowDom();b.setShadowDom(null);
-if(e.isShadow()){f=Blockly.Xml.blockToDom(e),e.dispose(),e=null}else{if(b.type==Blockly.INPUT_VALUE){if(!e.outputConnection){throw"Orphan block does not have an output connection."}var g=Blockly.Connection.lastConnectionInRow_(d,e);g&&(e.outputConnection.connect(g),e=null)}else{if(b.type==Blockly.NEXT_STATEMENT){if(!e.previousConnection){throw"Orphan block does not have a previous connection."}for(g=d;g.nextConnection;){var h=g.getNextBlock();if(h&&!h.isShadow()){g=h}else{e.previousConnection.checkType_(g.nextConnection)&&(g.nextConnection.connect(e.previousConnection),e=null);break}}}}}if(e&&(b.disconnect(),Blockly.Events.recordUndo)){var k=Blockly.Events.getGroup();setTimeout(function(){e.workspace&&!e.getParent()&&(Blockly.Events.setGroup(k),e.outputConnection?e.outputConnection.bumpAwayFrom_(b):e.previousConnection&&e.previousConnection.bumpAwayFrom_(b),Blockly.Events.setGroup(!1))},Blockly.BUMP_DELAY)}b.setShadowDom(f)}var n;Blockly.Events.isEnabled()&&(n=new Blockly.Events.BlockMove(d));Blockly.Connection.connectReciprocally_(b,a);d.setParent(c);n&&(n.recordNew(),Blockly.Events.fire(n))};Blockly.Connection.prototype.dispose=function(){if(this.isConnected()){throw"Disconnect connection before disposing of it."}this.inDB_&&this.db_.removeConnection_(this);this.dbOpposite_=this.db_=null};Blockly.Connection.prototype.getSourceBlock=function(){return this.sourceBlock_};Blockly.Connection.prototype.isSuperior=function(){return this.type==Blockly.INPUT_VALUE||this.type==Blockly.NEXT_STATEMENT};Blockly.Connection.prototype.isConnected=function(){return !!this.targetConnection};Blockly.Connection.prototype.canConnectWithReason_=function(a){if(!a){return Blockly.Connection.REASON_TARGET_NULL}if(this.isSuperior()){var b=this.sourceBlock_,c=a.getSourceBlock()}else{c=this.sourceBlock_,b=a.getSourceBlock()}return b&&b==c?Blockly.Connection.REASON_SELF_CONNECTION:a.type!=Blockly.OPPOSITE_TYPE[this.type]?Blockly.Connection.REASON_WRONG_TYPE:b&&c&&b.workspace!==c.workspace?Blockly.Connection.REASON_DIFFERENT_WORKSPACES:this.checkType_(a)?b.isShadow()&&!c.isShadow()?Blockly.Connection.REASON_SHADOW_PARENT:Blockly.Connection.CAN_CONNECT:Blockly.Connection.REASON_CHECKS_FAILED
-};Blockly.Connection.prototype.checkConnection_=function(a){switch(this.canConnectWithReason_(a)){case Blockly.Connection.CAN_CONNECT:break;case Blockly.Connection.REASON_SELF_CONNECTION:throw"Attempted to connect a block to itself.";case Blockly.Connection.REASON_DIFFERENT_WORKSPACES:throw"Blocks not on same workspace.";case Blockly.Connection.REASON_WRONG_TYPE:throw"Attempt to connect incompatible types.";case Blockly.Connection.REASON_TARGET_NULL:throw"Target connection is null.";case Blockly.Connection.REASON_CHECKS_FAILED:throw"Connection checks failed. "+(this+" expected "+this.check_+", found "+a.check_);case Blockly.Connection.REASON_SHADOW_PARENT:throw"Connecting non-shadow to shadow block.";default:throw"Unknown connection failure: this should never happen!"}};Blockly.Connection.prototype.isConnectionAllowed=function(a){if(this.canConnectWithReason_(a)!=Blockly.Connection.CAN_CONNECT){return !1}if(a.type==Blockly.OUTPUT_VALUE||a.type==Blockly.PREVIOUS_STATEMENT){if(a.isConnected()||this.isConnected()){return !1}}return a.type==Blockly.INPUT_VALUE&&a.isConnected()&&!a.targetBlock().isMovable()&&!a.targetBlock().isShadow()||this.type==Blockly.PREVIOUS_STATEMENT&&a.isConnected()&&!this.sourceBlock_.nextConnection&&!a.targetBlock().isShadow()&&a.targetBlock().nextConnection||-1!=Blockly.draggingConnections_.indexOf(a)?!1:!0};Blockly.Connection.prototype.connect=function(a){this.targetConnection!=a&&(this.checkConnection_(a),this.isSuperior()?this.connect_(a):a.connect_(this))};Blockly.Connection.connectReciprocally_=function(a,b){goog.asserts.assert(a&&b,"Cannot connect null connections.");a.targetConnection=b;b.targetConnection=a};Blockly.Connection.singleConnection_=function(a,b){for(var c=!1,d=0;d<a.inputList.length;d++){var e=a.inputList[d].connection;if(e&&e.type==Blockly.INPUT_VALUE&&b.outputConnection.checkType_(e)){if(c){return null}c=e}}return c};Blockly.Connection.lastConnectionInRow_=function(a,b){for(var c=a,d;d=Blockly.Connection.singleConnection_(c,b);
-){if(c=d.targetBlock(),!c||c.isShadow()){return d}}return null};Blockly.Connection.prototype.disconnect=function(){var a=this.targetConnection;goog.asserts.assert(a,"Source connection not connected.");goog.asserts.assert(a.targetConnection==this,"Target connection not connected to source connection.");if(this.isSuperior()){var b=this.sourceBlock_;var c=a.getSourceBlock();a=this}else{b=a.getSourceBlock(),c=this.sourceBlock_}this.disconnectInternal_(b,c);a.respawnShadow_()};Blockly.Connection.prototype.disconnectInternal_=function(a,b){var c;Blockly.Events.isEnabled()&&(c=new Blockly.Events.BlockMove(b));this.targetConnection=this.targetConnection.targetConnection=null;b.setParent(null);c&&(c.recordNew(),Blockly.Events.fire(c))};Blockly.Connection.prototype.respawnShadow_=function(){var a=this.getSourceBlock(),b=this.getShadowDom();if(a.workspace&&b&&Blockly.Events.recordUndo){if(a=Blockly.Xml.domToBlock(b,a.workspace),a.outputConnection){this.connect(a.outputConnection)}else{if(a.previousConnection){this.connect(a.previousConnection)}else{throw"Child block does not have output or previous statement."}}}};Blockly.Connection.prototype.targetBlock=function(){return this.isConnected()?this.targetConnection.getSourceBlock():null};Blockly.Connection.prototype.checkType_=function(a){if(!this.check_||!a.check_){return !0}for(var b=0;b<this.check_.length;b++){if(-1!=a.check_.indexOf(this.check_[b])){return !0}}return !1};Blockly.Connection.prototype.onCheckChanged_=function(){this.isConnected()&&!this.checkType_(this.targetConnection)&&(this.isSuperior()?this.targetBlock():this.sourceBlock_).unplug()};Blockly.Connection.prototype.setCheck=function(a){a?(goog.isArray(a)||(a=[a]),this.check_=a,this.onCheckChanged_()):this.check_=null;return this};Blockly.Connection.prototype.setShadowDom=function(a){this.shadowDom_=a};Blockly.Connection.prototype.getShadowDom=function(){return this.shadowDom_};Blockly.Connection.prototype.neighbours_=function(){return[]};Blockly.Connection.prototype.toString=function(){var a=this.sourceBlock_;
-if(a){if(a.outputConnection==this){var b="Output Connection of "}else{if(a.previousConnection==this){b="Previous Connection of "}else{if(a.nextConnection==this){b="Next Connection of "}else{if(b=goog.array.find(a.inputList,function(a){return a.connection==this},this)){b='Input "'+b.name+'" connection on '}else{return console.warn("Connection not actually connected to sourceBlock_"),"Orphan Connection"}}}}}else{return"Orphan Connection"}return b+a.toDevString()};Blockly.Extensions={};Blockly.Extensions.ALL_={};Blockly.Extensions.register=function(a,b){if(!goog.isString(a)||goog.string.isEmptyOrWhitespace(a)){throw Error('Error: Invalid extension name "'+a+'"')}if(Blockly.Extensions.ALL_[a]){throw Error('Error: Extension "'+a+'" is already registered.')}if(!goog.isFunction(b)){throw Error('Error: Extension "'+a+'" must be a function')}Blockly.Extensions.ALL_[a]=b};Blockly.Extensions.registerMixin=function(a,b){Blockly.Extensions.register(a,function(){this.mixin(b)})};Blockly.Extensions.registerMutator=function(a,b,c,d){var e='Error when registering mutator "'+a+'": ';Blockly.Extensions.checkHasFunction_(e,b.domToMutation,"domToMutation");Blockly.Extensions.checkHasFunction_(e,b.mutationToDom,"mutationToDom");var f=Blockly.Extensions.checkMutatorDialog_(b,e);if(c&&!goog.isFunction(c)){throw Error('Extension "'+a+'" is not a function')}Blockly.Extensions.register(a,function(){f&&this.setMutator(new Blockly.Mutator(d));this.mixin(b);c&&c.apply(this)})};Blockly.Extensions.apply=function(a,b,c){var d=Blockly.Extensions.ALL_[a];if(!goog.isFunction(d)){throw Error('Error: Extension "'+a+'" not found.')}if(c){Blockly.Extensions.checkNoMutatorProperties_(a,b)}else{var e=Blockly.Extensions.getMutatorProperties_(b)}d.apply(b);if(c){Blockly.Extensions.checkBlockHasMutatorProperties_('Error after applying mutator "'+a+'": ',b)}else{if(!Blockly.Extensions.mutatorPropertiesMatch_(e,b)){throw Error('Error when applying extension "'+a+'": mutation properties changed when applying a non-mutator extension.')
-}}};Blockly.Extensions.checkHasFunction_=function(a,b,c){if(!b){throw Error(a+'missing required property "'+c+'"')}if("function"!=typeof b){throw Error(a+'" required property "'+c+'" must be a function')}};Blockly.Extensions.checkNoMutatorProperties_=function(a,b){if(Blockly.Extensions.getMutatorProperties_(b).length){throw Error('Error: tried to apply mutation "'+a+'" to a block that already has mutator functions.  Block id: '+b.id)}};Blockly.Extensions.checkMutatorDialog_=function(a,b){var c=void 0!==a.compose,d=void 0!==a.decompose;if(c&&d){if("function"!=typeof a.compose){throw Error(b+"compose must be a function.")}if("function"!=typeof a.decompose){throw Error(b+"decompose must be a function.")}return !0}if(c||d){throw Error(b+'Must have both or neither of "compose" and "decompose"')}return !1};Blockly.Extensions.checkBlockHasMutatorProperties_=function(a,b){if("function"!=typeof b.domToMutation){throw Error(a+'Applying a mutator didn\'t add "domToMutation"')}if("function"!=typeof b.mutationToDom){throw Error(a+'Applying a mutator didn\'t add "mutationToDom"')}Blockly.Extensions.checkMutatorDialog_(b,a)};Blockly.Extensions.getMutatorProperties_=function(a){var b=[];void 0!==a.domToMutation&&b.push(a.domToMutation);void 0!==a.mutationToDom&&b.push(a.mutationToDom);void 0!==a.compose&&b.push(a.compose);void 0!==a.decompose&&b.push(a.decompose);return b};Blockly.Extensions.mutatorPropertiesMatch_=function(a,b){var c=Blockly.Extensions.getMutatorProperties_(b);if(c.length!=a.length){return !1}for(var d=0;d<c.length;d++){if(a[d]!=c[d]){return !1}}return !0};Blockly.Extensions.buildTooltipForDropdown=function(a,b){var c=[];document&&Blockly.utils.runAfterPageLoad(function(){for(var a in b){Blockly.utils.checkMessageReferences(b[a])}});return function(){this.type&&-1===c.indexOf(this.type)&&(Blockly.Extensions.checkDropdownOptionsInTable_(this,a,b),c.push(this.type));this.setTooltip(function(){var d=this.getFieldValue(a),e=b[d];null==e?-1===c.indexOf(this.type)&&(d="No tooltip mapping for value "+d+" of field "+a,null!=this.type&&(d+=" of block type "+this.type),console.warn(d+".")):e=Blockly.utils.replaceMessageReferences(e);
-return e}.bind(this))}};Blockly.Extensions.checkDropdownOptionsInTable_=function(a,b,c){var d=a.getField(b);if(!d.isOptionListDynamic()){d=d.getOptions();for(var e=0;e<d.length;++e){var f=d[e][1];null==c[f]&&console.warn("No tooltip mapping for value "+f+" of field "+b+" of block type "+a.type)}}};Blockly.Extensions.buildTooltipWithFieldValue=function(a,b){document&&Blockly.utils.runAfterPageLoad(function(){Blockly.utils.checkMessageReferences(a)});return function(){this.setTooltip(function(){return Blockly.utils.replaceMessageReferences(a).replace("%1",this.getFieldValue(b))}.bind(this))}};Blockly.Extensions.extensionParentTooltip_=function(){this.tooltipWhenNotConnected_=this.tooltip;this.setTooltip(function(){var a=this.getParent();return a&&a.getInputsInline()&&a.tooltip||this.tooltipWhenNotConnected_}.bind(this))};Blockly.Extensions.register("parent_tooltip_when_inline",Blockly.Extensions.extensionParentTooltip_);Blockly.RenderedConnection=function(a,b){Blockly.RenderedConnection.superClass_.constructor.call(this,a,b);this.offsetInBlock_=new goog.math.Coordinate(0,0)};goog.inherits(Blockly.RenderedConnection,Blockly.Connection);Blockly.RenderedConnection.prototype.distanceFrom=function(a){var b=this.x_-a.x_;a=this.y_-a.y_;return Math.sqrt(b*b+a*a)};Blockly.RenderedConnection.prototype.bumpAwayFrom_=function(a){if(!this.sourceBlock_.workspace.isDragging()){var b=this.sourceBlock_.getRootBlock();if(!b.isInFlyout){var c=!1;if(!b.isMovable()){b=a.getSourceBlock().getRootBlock();if(!b.isMovable()){return}a=this;c=!0}var d=Blockly.selected==b;d||b.addSelect();var e=a.x_+Blockly.SNAP_RADIUS-this.x_;a=a.y_+Blockly.SNAP_RADIUS-this.y_;c&&(a=-a);b.RTL&&(e=-e);b.moveBy(e,a);d||b.removeSelect()}}};Blockly.RenderedConnection.prototype.moveTo=function(a,b){this.inDB_&&this.db_.removeConnection_(this);this.x_=a;this.y_=b;this.hidden_||this.db_.addConnection(this)};Blockly.RenderedConnection.prototype.moveBy=function(a,b){this.moveTo(this.x_+a,this.y_+b)};Blockly.RenderedConnection.prototype.moveToOffset=function(a){this.moveTo(a.x+this.offsetInBlock_.x,a.y+this.offsetInBlock_.y)
-};Blockly.RenderedConnection.prototype.setOffsetInBlock=function(a,b){this.offsetInBlock_.x=a;this.offsetInBlock_.y=b};Blockly.RenderedConnection.prototype.tighten_=function(){var a=this.targetConnection.x_-this.x_,b=this.targetConnection.y_-this.y_;if(0!=a||0!=b){var c=this.targetBlock(),d=c.getSvgRoot();if(!d){throw"block is not rendered."}d=Blockly.utils.getRelativeXY(d);c.getSvgRoot().setAttribute("transform","translate("+(d.x-a)+","+(d.y-b)+")");c.moveConnections_(-a,-b)}};Blockly.RenderedConnection.prototype.closest=function(a,b,c){return this.dbOpposite_.searchForClosest(this,a,b,c)};Blockly.RenderedConnection.prototype.highlight=function(){var a=this.type==Blockly.INPUT_VALUE||this.type==Blockly.OUTPUT_VALUE?"m 0,0 "+Blockly.BlockSvg.TAB_PATH_DOWN+" v 5":"m -20,0 h 5 "+Blockly.BlockSvg.NOTCH_PATH_LEFT+" h 5";var b=this.sourceBlock_.getRelativeToSurfaceXY();Blockly.Connection.highlightedPath_=Blockly.utils.createSvgElement("path",{"class":"blocklyHighlightedConnectionPath",d:a,transform:"translate("+(this.x_-b.x)+","+(this.y_-b.y)+")"+(this.sourceBlock_.RTL?" scale(-1 1)":"")},this.sourceBlock_.getSvgRoot())};Blockly.RenderedConnection.prototype.unhideAll=function(){this.setHidden(!1);var a=[];if(this.type!=Blockly.INPUT_VALUE&&this.type!=Blockly.NEXT_STATEMENT){return a}var b=this.targetBlock();if(b){if(b.isCollapsed()){var c=[];b.outputConnection&&c.push(b.outputConnection);b.nextConnection&&c.push(b.nextConnection);b.previousConnection&&c.push(b.previousConnection)}else{c=b.getConnections_(!0)}for(var d=0;d<c.length;d++){a.push.apply(a,c[d].unhideAll())}a.length||(a[0]=b)}return a};Blockly.RenderedConnection.prototype.unhighlight=function(){goog.dom.removeNode(Blockly.Connection.highlightedPath_);delete Blockly.Connection.highlightedPath_};Blockly.RenderedConnection.prototype.setHidden=function(a){(this.hidden_=a)&&this.inDB_?this.db_.removeConnection_(this):a||this.inDB_||this.db_.addConnection(this)};Blockly.RenderedConnection.prototype.hideAll=function(){this.setHidden(!0);
-if(this.targetConnection){for(var a=this.targetBlock().getDescendants(),b=0;b<a.length;b++){for(var c=a[b],d=c.getConnections_(!0),e=0;e<d.length;e++){d[e].setHidden(!0)}c=c.getIcons();for(e=0;e<c.length;e++){c[e].setVisible(!1)}}}};Blockly.RenderedConnection.prototype.isConnectionAllowed=function(a,b){return this.distanceFrom(a)>b?!1:Blockly.RenderedConnection.superClass_.isConnectionAllowed.call(this,a)};Blockly.RenderedConnection.prototype.disconnectInternal_=function(a,b){Blockly.RenderedConnection.superClass_.disconnectInternal_.call(this,a,b);a.rendered&&a.render();b.rendered&&(b.updateDisabled(),b.render())};Blockly.RenderedConnection.prototype.respawnShadow_=function(){var a=this.getSourceBlock(),b=this.getShadowDom();if(a.workspace&&b&&Blockly.Events.recordUndo){Blockly.RenderedConnection.superClass_.respawnShadow_.call(this);b=this.targetBlock();if(!b){throw"Couldn't respawn the shadow block that should exist here."}b.initSvg();b.render(!1);a.rendered&&a.render()}};Blockly.RenderedConnection.prototype.neighbours_=function(a){return this.dbOpposite_.getNeighbours(this,a)};Blockly.RenderedConnection.prototype.connect_=function(a){Blockly.RenderedConnection.superClass_.connect_.call(this,a);var b=this.getSourceBlock();a=a.getSourceBlock();b.rendered&&b.updateDisabled();a.rendered&&a.updateDisabled();b.rendered&&a.rendered&&(this.type==Blockly.NEXT_STATEMENT||this.type==Blockly.PREVIOUS_STATEMENT?a.render():b.render())};Blockly.RenderedConnection.prototype.onCheckChanged_=function(){this.isConnected()&&!this.checkType_(this.targetConnection)&&((this.isSuperior()?this.targetBlock():this.sourceBlock_).unplug(),this.sourceBlock_.bumpNeighbours_())};Blockly.DraggedConnectionManager=function(a){this.topBlock_=Blockly.selected=a;this.workspace_=a.workspace;this.availableConnections_=this.initAvailableConnections_();this.localConnection_=this.closestConnection_=null;this.radiusConnection_=0;this.wouldDeleteBlock_=!1};Blockly.DraggedConnectionManager.prototype.dispose=function(){this.workspace_=this.topBlock_=null;
-this.availableConnections_.length=0;this.localConnection_=this.closestConnection_=null};Blockly.DraggedConnectionManager.prototype.wouldDeleteBlock=function(){return this.wouldDeleteBlock_};Blockly.DraggedConnectionManager.prototype.applyConnections=function(){this.closestConnection_&&(this.localConnection_.connect(this.closestConnection_),this.topBlock_.rendered&&((this.localConnection_.isSuperior()?this.closestConnection_:this.localConnection_).getSourceBlock().connectionUiEffect(),this.topBlock_.getRootBlock().bringToFront()),this.removeHighlighting_())};Blockly.DraggedConnectionManager.prototype.update=function(a,b){var c=this.closestConnection_,d=this.updateClosest_(a);d&&c&&c.unhighlight();c=!!this.closestConnection_&&b!=Blockly.DELETE_AREA_TOOLBOX;var e=!!b&&!this.topBlock_.getParent()&&this.topBlock_.isDeletable();this.wouldDeleteBlock_=e&&!c;e&&this.closestConnection_&&(this.closestConnection_.unhighlight(),this.closestConnection_=null);!this.wouldDeleteBlock_&&d&&this.closestConnection_&&this.addHighlighting_()};Blockly.DraggedConnectionManager.prototype.removeHighlighting_=function(){this.closestConnection_&&this.closestConnection_.unhighlight()};Blockly.DraggedConnectionManager.prototype.addHighlighting_=function(){this.closestConnection_&&this.closestConnection_.highlight()};Blockly.DraggedConnectionManager.prototype.initAvailableConnections_=function(){var a=this.topBlock_.getConnections_(!1),b=this.topBlock_.lastConnectionInStack_();b&&b!=this.topBlock_.nextConnection&&a.push(b);return a};Blockly.DraggedConnectionManager.prototype.updateClosest_=function(a){var b=this.closestConnection_;this.localConnection_=this.closestConnection_=null;this.radiusConnection_=Blockly.SNAP_RADIUS;for(var c=0;c<this.availableConnections_.length;c++){var d=this.availableConnections_[c],e=d.closest(this.radiusConnection_,a);e.connection&&(this.closestConnection_=e.connection,this.localConnection_=d,this.radiusConnection_=e.radius)}return b!=this.closestConnection_};Blockly.BlockDragger=function(a,b){this.draggingBlock_=a;
-this.workspace_=b;this.draggedConnectionManager_=new Blockly.DraggedConnectionManager(this.draggingBlock_);this.deleteArea_=null;this.wouldDeleteBlock_=!1;this.startXY_=this.draggingBlock_.getRelativeToSurfaceXY();this.dragIconData_=Blockly.BlockDragger.initIconData_(a)};Blockly.BlockDragger.prototype.dispose=function(){this.startWorkspace_=this.workspace_=this.draggingBlock_=null;this.dragIconData_.length=0;this.draggedConnectionManager_&&(this.draggedConnectionManager_.dispose(),this.draggedConnectionManager_=null)};Blockly.BlockDragger.initIconData_=function(a){var b=[];a=a.getDescendants();for(var c=0,d;d=a[c];c++){d=d.getIcons();for(var e=0;e<d.length;e++){var f={location:d[e].getIconLocation(),icon:d[e]};b.push(f)}}return b};Blockly.BlockDragger.prototype.startBlockDrag=function(a){Blockly.Events.getGroup()||Blockly.Events.setGroup(!0);this.workspace_.setResizesEnabled(!1);Blockly.BlockSvg.disconnectUiStop_();this.draggingBlock_.getParent()&&(this.draggingBlock_.unplug(),a=this.pixelsToWorkspaceUnits_(a),a=goog.math.Coordinate.sum(this.startXY_,a),this.draggingBlock_.translate(a.x,a.y),this.draggingBlock_.disconnectUiEffect());this.draggingBlock_.setDragging(!0);this.draggingBlock_.moveToDragSurface_();this.workspace_.toolbox_&&this.workspace_.toolbox_.addDeleteStyle()};Blockly.BlockDragger.prototype.dragBlock=function(a,b){var c=this.pixelsToWorkspaceUnits_(b),d=goog.math.Coordinate.sum(this.startXY_,c);this.draggingBlock_.moveDuringDrag(d);this.dragIcons_(c);this.deleteArea_=this.workspace_.isDeleteArea(a);this.draggedConnectionManager_.update(c,this.deleteArea_);this.updateCursorDuringBlockDrag_()};Blockly.BlockDragger.prototype.endBlockDrag=function(a,b){this.dragBlock(a,b);this.dragIconData_=[];Blockly.BlockSvg.disconnectUiStop_();var c=this.pixelsToWorkspaceUnits_(b),d=goog.math.Coordinate.sum(this.startXY_,c);this.draggingBlock_.moveOffDragSurface_(d);this.maybeDeleteBlock_()||(this.draggingBlock_.moveConnections_(c.x,c.y),this.draggingBlock_.setDragging(!1),this.draggedConnectionManager_.applyConnections(),this.draggingBlock_.render(),this.fireMoveEvent_(),this.draggingBlock_.scheduleSnapAndBump());
-this.workspace_.setResizesEnabled(!0);this.workspace_.toolbox_&&this.workspace_.toolbox_.removeDeleteStyle();Blockly.Events.setGroup(!1)};Blockly.BlockDragger.prototype.fireMoveEvent_=function(){var a=new Blockly.Events.BlockMove(this.draggingBlock_);a.oldCoordinate=this.startXY_;a.recordNew();Blockly.Events.fire(a)};Blockly.BlockDragger.prototype.maybeDeleteBlock_=function(){var a=this.workspace_.trashcan;this.wouldDeleteBlock_?(a&&goog.Timer.callOnce(a.close,100,a),this.fireMoveEvent_(),this.draggingBlock_.dispose(!1,!0)):a&&a.close();return this.wouldDeleteBlock_};Blockly.BlockDragger.prototype.updateCursorDuringBlockDrag_=function(){this.wouldDeleteBlock_=this.draggedConnectionManager_.wouldDeleteBlock();var a=this.workspace_.trashcan;this.wouldDeleteBlock_?(this.draggingBlock_.setDeleteStyle(!0),this.deleteArea_==Blockly.DELETE_AREA_TRASH&&a&&a.setOpen_(!0)):(this.draggingBlock_.setDeleteStyle(!1),a&&a.setOpen_(!1))};Blockly.BlockDragger.prototype.pixelsToWorkspaceUnits_=function(a){a=new goog.math.Coordinate(a.x/this.workspace_.scale,a.y/this.workspace_.scale);this.workspace_.isMutator&&(a=a.scale(1/this.workspace_.options.parentWorkspace.scale));return a};Blockly.BlockDragger.prototype.dragIcons_=function(a){for(var b=0;b<this.dragIconData_.length;b++){var c=this.dragIconData_[b];c.icon.setIconLocation(goog.math.Coordinate.sum(c.location,a))}};Blockly.constants={};Blockly.DRAG_RADIUS=5;Blockly.FLYOUT_DRAG_RADIUS=10;Blockly.SNAP_RADIUS=20;Blockly.BUMP_DELAY=250;Blockly.COLLAPSE_CHARS=30;Blockly.LONGPRESS=750;Blockly.SOUND_LIMIT=100;Blockly.DRAG_STACK=!0;Blockly.HSV_SATURATION=0.45;Blockly.HSV_VALUE=0.65;Blockly.SPRITE={width:96,height:124,url:"sprites.png"};Blockly.SVG_NS="http://www.w3.org/2000/svg";Blockly.HTML_NS="http://www.w3.org/1999/xhtml";Blockly.INPUT_VALUE=1;Blockly.OUTPUT_VALUE=2;Blockly.NEXT_STATEMENT=3;Blockly.PREVIOUS_STATEMENT=4;Blockly.DUMMY_INPUT=5;Blockly.ALIGN_LEFT=-1;Blockly.ALIGN_CENTRE=0;Blockly.ALIGN_RIGHT=1;Blockly.DRAG_NONE=0;Blockly.DRAG_STICKY=1;
-Blockly.DRAG_BEGIN=1;Blockly.DRAG_FREE=2;Blockly.OPPOSITE_TYPE=[];Blockly.OPPOSITE_TYPE[Blockly.INPUT_VALUE]=Blockly.OUTPUT_VALUE;Blockly.OPPOSITE_TYPE[Blockly.OUTPUT_VALUE]=Blockly.INPUT_VALUE;Blockly.OPPOSITE_TYPE[Blockly.NEXT_STATEMENT]=Blockly.PREVIOUS_STATEMENT;Blockly.OPPOSITE_TYPE[Blockly.PREVIOUS_STATEMENT]=Blockly.NEXT_STATEMENT;Blockly.TOOLBOX_AT_TOP=0;Blockly.TOOLBOX_AT_BOTTOM=1;Blockly.TOOLBOX_AT_LEFT=2;Blockly.TOOLBOX_AT_RIGHT=3;Blockly.DELETE_AREA_NONE=null;Blockly.DELETE_AREA_TRASH=1;Blockly.DELETE_AREA_TOOLBOX=2;Blockly.VARIABLE_CATEGORY_NAME="VARIABLE";Blockly.PROCEDURE_CATEGORY_NAME="PROCEDURE";Blockly.RENAME_VARIABLE_ID="RENAME_VARIABLE_ID";Blockly.DELETE_VARIABLE_ID="DELETE_VARIABLE_ID";Blockly.WorkspaceDragger=function(a){this.workspace_=a;this.startDragMetrics_=a.getMetrics();this.startScrollXY_=new goog.math.Coordinate(a.scrollX,a.scrollY)};Blockly.WorkspaceDragger.prototype.dispose=function(){this.workspace_=null};Blockly.WorkspaceDragger.prototype.startDrag=function(){Blockly.selected&&Blockly.selected.unselect();this.workspace_.setupDragSurface()};Blockly.WorkspaceDragger.prototype.endDrag=function(a){this.drag(a);this.workspace_.resetDragSurface()};Blockly.WorkspaceDragger.prototype.drag=function(a){var b=this.startDragMetrics_,c=goog.math.Coordinate.sum(this.startScrollXY_,a);a=Math.min(c.x,-b.contentLeft);c=Math.min(c.y,-b.contentTop);a=Math.max(a,b.viewWidth-b.contentLeft-b.contentWidth);c=Math.max(c,b.viewHeight-b.contentTop-b.contentHeight);a=-a-b.contentLeft;c=-c-b.contentTop;this.updateScroll_(a,c)};Blockly.WorkspaceDragger.prototype.updateScroll_=function(a,b){this.workspace_.scrollbar.set(a,b)};Blockly.FlyoutDragger=function(a){Blockly.FlyoutDragger.superClass_.constructor.call(this,a.getWorkspace());this.scrollbar_=a.scrollbar_;this.horizontalLayout_=a.horizontalLayout_};goog.inherits(Blockly.FlyoutDragger,Blockly.WorkspaceDragger);Blockly.FlyoutDragger.prototype.updateScroll_=function(a,b){this.horizontalLayout_?this.scrollbar_.set(a):this.scrollbar_.set(b)
-};Blockly.Tooltip={};Blockly.Tooltip.visible=!1;Blockly.Tooltip.blocked_=!1;Blockly.Tooltip.LIMIT=50;Blockly.Tooltip.mouseOutPid_=0;Blockly.Tooltip.showPid_=0;Blockly.Tooltip.lastX_=0;Blockly.Tooltip.lastY_=0;Blockly.Tooltip.element_=null;Blockly.Tooltip.poisonedElement_=null;Blockly.Tooltip.OFFSET_X=0;Blockly.Tooltip.OFFSET_Y=10;Blockly.Tooltip.RADIUS_OK=10;Blockly.Tooltip.HOVER_MS=750;Blockly.Tooltip.MARGINS=5;Blockly.Tooltip.DIV=null;Blockly.Tooltip.createDom=function(){Blockly.Tooltip.DIV||(Blockly.Tooltip.DIV=goog.dom.createDom("DIV","blocklyTooltipDiv"),document.body.appendChild(Blockly.Tooltip.DIV))};Blockly.Tooltip.bindMouseEvents=function(a){Blockly.bindEvent_(a,"mouseover",null,Blockly.Tooltip.onMouseOver_);Blockly.bindEvent_(a,"mouseout",null,Blockly.Tooltip.onMouseOut_);a.addEventListener("mousemove",Blockly.Tooltip.onMouseMove_,!1)};Blockly.Tooltip.onMouseOver_=function(a){if(!Blockly.Tooltip.blocked_){for(a=a.target;!goog.isString(a.tooltip)&&!goog.isFunction(a.tooltip);){a=a.tooltip}Blockly.Tooltip.element_!=a&&(Blockly.Tooltip.hide(),Blockly.Tooltip.poisonedElement_=null,Blockly.Tooltip.element_=a);clearTimeout(Blockly.Tooltip.mouseOutPid_)}};Blockly.Tooltip.onMouseOut_=function(a){Blockly.Tooltip.blocked_||(Blockly.Tooltip.mouseOutPid_=setTimeout(function(){Blockly.Tooltip.element_=null;Blockly.Tooltip.poisonedElement_=null;Blockly.Tooltip.hide()},1),clearTimeout(Blockly.Tooltip.showPid_))};Blockly.Tooltip.onMouseMove_=function(a){if(Blockly.Tooltip.element_&&Blockly.Tooltip.element_.tooltip&&!Blockly.WidgetDiv.isVisible()&&!Blockly.Tooltip.blocked_){if(Blockly.Tooltip.visible){var b=Blockly.Tooltip.lastX_-a.pageX;a=Blockly.Tooltip.lastY_-a.pageY;Math.sqrt(b*b+a*a)>Blockly.Tooltip.RADIUS_OK&&Blockly.Tooltip.hide()}else{Blockly.Tooltip.poisonedElement_!=Blockly.Tooltip.element_&&(clearTimeout(Blockly.Tooltip.showPid_),Blockly.Tooltip.lastX_=a.pageX,Blockly.Tooltip.lastY_=a.pageY,Blockly.Tooltip.showPid_=setTimeout(Blockly.Tooltip.show_,Blockly.Tooltip.HOVER_MS))
-}}};Blockly.Tooltip.hide=function(){Blockly.Tooltip.visible&&(Blockly.Tooltip.visible=!1,Blockly.Tooltip.DIV&&(Blockly.Tooltip.DIV.style.display="none"));Blockly.Tooltip.showPid_&&clearTimeout(Blockly.Tooltip.showPid_)};Blockly.Tooltip.block=function(){Blockly.Tooltip.hide();Blockly.Tooltip.blocked_=!0};Blockly.Tooltip.unblock=function(){Blockly.Tooltip.blocked_=!1};Blockly.Tooltip.show_=function(){if(!Blockly.Tooltip.blocked_&&(Blockly.Tooltip.poisonedElement_=Blockly.Tooltip.element_,Blockly.Tooltip.DIV)){goog.dom.removeChildren(Blockly.Tooltip.DIV);for(var a=Blockly.Tooltip.element_.tooltip;goog.isFunction(a);){a=a()}a=Blockly.utils.wrap(a,Blockly.Tooltip.LIMIT);a=a.split("\n");for(var b=0;b<a.length;b++){var c=document.createElement("div");c.appendChild(document.createTextNode(a[b]));Blockly.Tooltip.DIV.appendChild(c)}a=Blockly.Tooltip.element_.RTL;b=goog.dom.getViewportSize();Blockly.Tooltip.DIV.style.direction=a?"rtl":"ltr";Blockly.Tooltip.DIV.style.display="block";Blockly.Tooltip.visible=!0;c=Blockly.Tooltip.lastX_;c=a?c-(Blockly.Tooltip.OFFSET_X+Blockly.Tooltip.DIV.offsetWidth):c+Blockly.Tooltip.OFFSET_X;var d=Blockly.Tooltip.lastY_+Blockly.Tooltip.OFFSET_Y;d+Blockly.Tooltip.DIV.offsetHeight>b.height+window.scrollY&&(d-=Blockly.Tooltip.DIV.offsetHeight+2*Blockly.Tooltip.OFFSET_Y);a?c=Math.max(Blockly.Tooltip.MARGINS-window.scrollX,c):c+Blockly.Tooltip.DIV.offsetWidth>b.width+window.scrollX-2*Blockly.Tooltip.MARGINS&&(c=b.width-Blockly.Tooltip.DIV.offsetWidth-2*Blockly.Tooltip.MARGINS);Blockly.Tooltip.DIV.style.top=d+"px";Blockly.Tooltip.DIV.style.left=c+"px"}};Blockly.Gesture=function(a,b){this.mouseDownXY_=null;this.currentDragDeltaXY_=0;this.startWorkspace_=this.targetBlock_=this.startBlock_=this.startField_=null;this.creatorWorkspace_=b;this.isDraggingBlock_=this.isDraggingWorkspace_=this.hasExceededDragRadius_=!1;this.mostRecentEvent_=a;this.flyout_=this.workspaceDragger_=this.blockDragger_=this.onUpWrapper_=this.onMoveWrapper_=null;this.isEnding_=this.hasStarted_=this.calledUpdateIsDragging_=!1
-};Blockly.Gesture.prototype.dispose=function(){Blockly.Touch.clearTouchIdentifier();Blockly.Tooltip.unblock();this.creatorWorkspace_.clearGesture();this.onMoveWrapper_&&Blockly.unbindEvent_(this.onMoveWrapper_);this.onUpWrapper_&&Blockly.unbindEvent_(this.onUpWrapper_);this.flyout_=this.startWorkspace_=this.targetBlock_=this.startBlock_=this.startField_=null;this.blockDragger_&&(this.blockDragger_.dispose(),this.blockDragger_=null);this.workspaceDragger_&&(this.workspaceDragger_.dispose(),this.workspaceDragger_=null)};Blockly.Gesture.prototype.updateFromEvent_=function(a){var b=new goog.math.Coordinate(a.clientX,a.clientY);this.updateDragDelta_(b)&&(this.updateIsDragging_(),Blockly.longStop_());this.mostRecentEvent_=a};Blockly.Gesture.prototype.updateDragDelta_=function(a){this.currentDragDeltaXY_=goog.math.Coordinate.difference(a,this.mouseDownXY_);return this.hasExceededDragRadius_?!1:this.hasExceededDragRadius_=goog.math.Coordinate.magnitude(this.currentDragDeltaXY_)>(this.flyout_?Blockly.FLYOUT_DRAG_RADIUS:Blockly.DRAG_RADIUS)};Blockly.Gesture.prototype.updateIsDraggingFromFlyout_=function(){return this.targetBlock_.disabled?!1:!this.flyout_.isScrollable()||this.flyout_.isDragTowardWorkspace(this.currentDragDeltaXY_)?(this.startWorkspace_=this.flyout_.targetWorkspace_,this.startWorkspace_.updateScreenCalculationsIfScrolled(),Blockly.Events.getGroup()||Blockly.Events.setGroup(!0),this.startBlock_=null,this.targetBlock_=this.flyout_.createBlock(this.targetBlock_),this.targetBlock_.select(),!0):!1};Blockly.Gesture.prototype.updateIsDraggingBlock_=function(){if(!this.targetBlock_){return !1}this.flyout_?this.isDraggingBlock_=this.updateIsDraggingFromFlyout_():this.targetBlock_.isMovable()&&(this.isDraggingBlock_=!0);return this.isDraggingBlock_?(this.startDraggingBlock_(),!0):!1};Blockly.Gesture.prototype.updateIsDraggingWorkspace_=function(){if(this.flyout_?this.flyout_.isScrollable():this.startWorkspace_&&this.startWorkspace_.isDraggable()){this.workspaceDragger_=this.flyout_?new Blockly.FlyoutDragger(this.flyout_):new Blockly.WorkspaceDragger(this.startWorkspace_),this.isDraggingWorkspace_=!0,this.workspaceDragger_.startDrag()
-}};Blockly.Gesture.prototype.updateIsDragging_=function(){goog.asserts.assert(!this.calledUpdateIsDragging_,"updateIsDragging_ should only be called once per gesture.");this.calledUpdateIsDragging_=!0;this.updateIsDraggingBlock_()||this.updateIsDraggingWorkspace_()};Blockly.Gesture.prototype.startDraggingBlock_=function(){this.blockDragger_=new Blockly.BlockDragger(this.targetBlock_,this.startWorkspace_);this.blockDragger_.startBlockDrag(this.currentDragDeltaXY_);this.blockDragger_.dragBlock(this.mostRecentEvent_,this.currentDragDeltaXY_)};Blockly.Gesture.prototype.doStart=function(a){Blockly.utils.isTargetInput(a)?this.cancel():(this.hasStarted_=!0,Blockly.BlockSvg.disconnectUiStop_(),this.startWorkspace_.updateScreenCalculationsIfScrolled(),this.startWorkspace_.isMutator&&this.startWorkspace_.resize(),this.startWorkspace_.markFocused(),this.mostRecentEvent_=a,Blockly.hideChaff(!!this.flyout_),Blockly.Tooltip.block(),this.targetBlock_&&this.targetBlock_.select(),Blockly.utils.isRightButton(a)?this.handleRightClick(a):(goog.string.caseInsensitiveEquals(a.type,"touchstart")&&Blockly.longStart_(a,this),this.mouseDownXY_=new goog.math.Coordinate(a.clientX,a.clientY),this.onMoveWrapper_=Blockly.bindEventWithChecks_(document,"mousemove",null,this.handleMove.bind(this)),this.onUpWrapper_=Blockly.bindEventWithChecks_(document,"mouseup",null,this.handleUp.bind(this)),a.preventDefault(),a.stopPropagation()))};Blockly.Gesture.prototype.handleMove=function(a){this.updateFromEvent_(a);this.isDraggingWorkspace_?this.workspaceDragger_.drag(this.currentDragDeltaXY_):this.isDraggingBlock_&&this.blockDragger_.dragBlock(this.mostRecentEvent_,this.currentDragDeltaXY_);a.preventDefault();a.stopPropagation()};Blockly.Gesture.prototype.handleUp=function(a){this.updateFromEvent_(a);Blockly.longStop_();this.isEnding_?console.log("Trying to end a gesture recursively."):(this.isEnding_=!0,this.isDraggingBlock_?this.blockDragger_.endBlockDrag(a,this.currentDragDeltaXY_):this.isDraggingWorkspace_?this.workspaceDragger_.endDrag(this.currentDragDeltaXY_):this.isFieldClick_()?this.doFieldClick_():this.isBlockClick_()?this.doBlockClick_():this.isWorkspaceClick_()&&this.doWorkspaceClick_(),a.preventDefault(),a.stopPropagation(),this.dispose())
-};Blockly.Gesture.prototype.cancel=function(){this.isEnding_||(Blockly.longStop_(),this.isDraggingBlock_?this.blockDragger_.endBlockDrag(this.mostRecentEvent_,this.currentDragDeltaXY_):this.isDraggingWorkspace_&&this.workspaceDragger_.endDrag(this.currentDragDeltaXY_),this.dispose())};Blockly.Gesture.prototype.handleRightClick=function(a){this.targetBlock_?(this.bringBlockToFront_(),Blockly.hideChaff(this.flyout_),this.targetBlock_.showContextMenu_(a)):this.startWorkspace_&&!this.flyout_&&(Blockly.hideChaff(),this.startWorkspace_.showContextMenu_(a));a.preventDefault();a.stopPropagation();this.dispose()};Blockly.Gesture.prototype.handleWsStart=function(a,b){goog.asserts.assert(!this.hasStarted_,"Tried to call gesture.handleWsStart, but the gesture had already been started.");this.setStartWorkspace_(b);this.mostRecentEvent_=a;this.doStart(a)};Blockly.Gesture.prototype.handleFlyoutStart=function(a,b){goog.asserts.assert(!this.hasStarted_,"Tried to call gesture.handleFlyoutStart, but the gesture had already been started.");this.setStartFlyout_(b);this.handleWsStart(a,b.getWorkspace())};Blockly.Gesture.prototype.handleBlockStart=function(a,b){goog.asserts.assert(!this.hasStarted_,"Tried to call gesture.handleBlockStart, but the gesture had already been started.");this.setStartBlock(b);this.mostRecentEvent_=a};Blockly.Gesture.prototype.doFieldClick_=function(){this.startField_.showEditor_();this.bringBlockToFront_()};Blockly.Gesture.prototype.doBlockClick_=function(){this.flyout_&&this.flyout_.autoClose?this.targetBlock_.disabled||(Blockly.Events.getGroup()||Blockly.Events.setGroup(!0),this.flyout_.createBlock(this.targetBlock_).scheduleSnapAndBump()):Blockly.Events.fire(new Blockly.Events.Ui(this.startBlock_,"click",void 0,void 0));this.bringBlockToFront_();Blockly.Events.setGroup(!1)};Blockly.Gesture.prototype.doWorkspaceClick_=function(){Blockly.selected&&Blockly.selected.unselect()};Blockly.Gesture.prototype.bringBlockToFront_=function(){this.targetBlock_&&!this.flyout_&&this.targetBlock_.bringToFront()
-};Blockly.Gesture.prototype.setStartField=function(a){goog.asserts.assert(!this.hasStarted_,"Tried to call gesture.setStartField, but the gesture had already been started.");this.startField_||(this.startField_=a)};Blockly.Gesture.prototype.setStartBlock=function(a){this.startBlock_||(this.startBlock_=a,a.isInFlyout&&a!=a.getRootBlock()?this.setTargetBlock_(a.getRootBlock()):this.setTargetBlock_(a))};Blockly.Gesture.prototype.setTargetBlock_=function(a){a.isShadow()?this.setTargetBlock_(a.getParent()):this.targetBlock_=a};Blockly.Gesture.prototype.setStartWorkspace_=function(a){this.startWorkspace_||(this.startWorkspace_=a)};Blockly.Gesture.prototype.setStartFlyout_=function(a){this.flyout_||(this.flyout_=a)};Blockly.Gesture.prototype.isBlockClick_=function(){return !!this.startBlock_&&!this.hasExceededDragRadius_&&!this.isFieldClick_()};Blockly.Gesture.prototype.isFieldClick_=function(){return(this.startField_?this.startField_.isCurrentlyEditable():!1)&&!this.hasExceededDragRadius_&&(!this.flyout_||!this.flyout_.autoClose)};Blockly.Gesture.prototype.isWorkspaceClick_=function(){return !this.startBlock_&&!this.startField_&&!this.hasExceededDragRadius_};Blockly.Gesture.prototype.isDragging=function(){return this.isDraggingWorkspace_||this.isDraggingBlock_};Blockly.Gesture.prototype.hasStarted=function(){return this.hasStarted_};Blockly.Field=function(a,b){this.size_=new goog.math.Size(0,Blockly.BlockSvg.MIN_BLOCK_Y);this.setValue(a);this.setValidator(b)};Blockly.Field.cacheWidths_=null;Blockly.Field.cacheReference_=0;Blockly.Field.prototype.name=void 0;Blockly.Field.prototype.maxDisplayLength=50;Blockly.Field.prototype.text_="";Blockly.Field.prototype.sourceBlock_=null;Blockly.Field.prototype.visible_=!0;Blockly.Field.prototype.validator_=null;Blockly.Field.NBSP="\u00a0";Blockly.Field.prototype.EDITABLE=!0;Blockly.Field.prototype.setSourceBlock=function(a){goog.asserts.assert(!this.sourceBlock_,"Field already bound to a block.");this.sourceBlock_=a};Blockly.Field.prototype.init=function(){this.fieldGroup_||(this.fieldGroup_=Blockly.utils.createSvgElement("g",{},null),this.visible_||(this.fieldGroup_.style.display="none"),this.borderRect_=Blockly.utils.createSvgElement("rect",{rx:4,ry:4,x:-Blockly.BlockSvg.SEP_SPACE_X/2,y:0,height:16},this.fieldGroup_),this.textElement_=Blockly.utils.createSvgElement("text",{"class":"blocklyText",y:this.size_.height-12.5},this.fieldGroup_),this.updateEditable(),this.sourceBlock_.getSvgRoot().appendChild(this.fieldGroup_),this.mouseDownWrapper_=Blockly.bindEventWithChecks_(this.fieldGroup_,"mousedown",this,this.onMouseDown_),this.render_())
-};Blockly.Field.prototype.initModel=function(){};Blockly.Field.prototype.dispose=function(){this.mouseDownWrapper_&&(Blockly.unbindEvent_(this.mouseDownWrapper_),this.mouseDownWrapper_=null);this.sourceBlock_=null;goog.dom.removeNode(this.fieldGroup_);this.validator_=this.borderRect_=this.textElement_=this.fieldGroup_=null};Blockly.Field.prototype.updateEditable=function(){var a=this.fieldGroup_;this.EDITABLE&&a&&(this.sourceBlock_.isEditable()?(Blockly.utils.addClass(a,"blocklyEditableText"),Blockly.utils.removeClass(a,"blocklyNonEditableText"),this.fieldGroup_.style.cursor=this.CURSOR):(Blockly.utils.addClass(a,"blocklyNonEditableText"),Blockly.utils.removeClass(a,"blocklyEditableText"),this.fieldGroup_.style.cursor=""))};Blockly.Field.prototype.isCurrentlyEditable=function(){return this.EDITABLE&&!!this.sourceBlock_&&this.sourceBlock_.isEditable()};Blockly.Field.prototype.isVisible=function(){return this.visible_};Blockly.Field.prototype.setVisible=function(a){if(this.visible_!=a){this.visible_=a;var b=this.getSvgRoot();b&&(b.style.display=a?"block":"none",this.render_())}};Blockly.Field.prototype.setValidator=function(a){this.validator_=a};Blockly.Field.prototype.getValidator=function(){return this.validator_};Blockly.Field.prototype.classValidator=function(a){return a};Blockly.Field.prototype.callValidator=function(a){var b=this.classValidator(a);if(null===b){return null}void 0!==b&&(a=b);if(b=this.getValidator()){b=b.call(this,a);if(null===b){return null}void 0!==b&&(a=b)}return a};Blockly.Field.prototype.getSvgRoot=function(){return this.fieldGroup_};Blockly.Field.prototype.render_=function(){if(this.visible_){goog.dom.removeChildren(this.textElement_);var a=document.createTextNode(this.getDisplayText_());this.textElement_.appendChild(a);this.updateWidth()}else{this.size_.width=0}};Blockly.Field.prototype.updateWidth=function(){var a=Blockly.Field.getCachedWidth(this.textElement_);this.borderRect_&&this.borderRect_.setAttribute("width",a+Blockly.BlockSvg.SEP_SPACE_X);
-this.size_.width=a};Blockly.Field.getCachedWidth=function(a){var b=a.textContent+"\n"+a.className.baseVal,c;if(Blockly.Field.cacheWidths_&&(c=Blockly.Field.cacheWidths_[b])){return c}try{c=goog.userAgent.IE||goog.userAgent.EDGE?a.getBBox().width:a.getComputedTextLength()}catch(d){return 8*a.textContent.length}Blockly.Field.cacheWidths_&&(Blockly.Field.cacheWidths_[b]=c);return c};Blockly.Field.startCache=function(){Blockly.Field.cacheReference_++;Blockly.Field.cacheWidths_||(Blockly.Field.cacheWidths_={})};Blockly.Field.stopCache=function(){Blockly.Field.cacheReference_--;Blockly.Field.cacheReference_||(Blockly.Field.cacheWidths_=null)};Blockly.Field.prototype.getSize=function(){this.size_.width||this.render_();return this.size_};Blockly.Field.prototype.getScaledBBox_=function(){var a=this.borderRect_.getBBox(),b=a.height*this.sourceBlock_.workspace.scale;a=a.width*this.sourceBlock_.workspace.scale;var c=this.getAbsoluteXY_();return{top:c.y,bottom:c.y+b,left:c.x,right:c.x+a}};Blockly.Field.prototype.getDisplayText_=function(){var a=this.text_;if(!a){return Blockly.Field.NBSP}a.length>this.maxDisplayLength&&(a=a.substring(0,this.maxDisplayLength-2)+"\u2026");a=a.replace(/\s/g,Blockly.Field.NBSP);this.sourceBlock_.RTL&&(a+="\u200f");return a};Blockly.Field.prototype.getText=function(){return this.text_};Blockly.Field.prototype.setText=function(a){null!==a&&(a=String(a),a!==this.text_&&(this.text_=a,this.forceRerender()))};Blockly.Field.prototype.forceRerender=function(){this.size_.width=0;this.sourceBlock_&&this.sourceBlock_.rendered&&(this.sourceBlock_.render(),this.sourceBlock_.bumpNeighbours_())};Blockly.Field.prototype.getValue=function(){return this.getText()};Blockly.Field.prototype.setValue=function(a){if(null!==a){var b=this.getValue();b!=a&&(this.sourceBlock_&&Blockly.Events.isEnabled()&&Blockly.Events.fire(new Blockly.Events.BlockChange(this.sourceBlock_,"field",this.name,b,a)),this.setText(a))}};Blockly.Field.prototype.onMouseDown_=function(a){this.sourceBlock_&&this.sourceBlock_.workspace&&(a=this.sourceBlock_.workspace.getGesture(a))&&a.setStartField(this)
-};Blockly.Field.prototype.setTooltip=function(a){};Blockly.Field.prototype.getAbsoluteXY_=function(){return goog.style.getPageOffset(this.borderRect_)};Blockly.FieldLabel=function(a,b){this.size_=new goog.math.Size(0,17.5);this.class_=b;this.setValue(a)};goog.inherits(Blockly.FieldLabel,Blockly.Field);Blockly.FieldLabel.prototype.EDITABLE=!1;Blockly.FieldLabel.prototype.init=function(){this.textElement_||(this.textElement_=Blockly.utils.createSvgElement("text",{"class":"blocklyText",y:this.size_.height-5},null),this.class_&&Blockly.utils.addClass(this.textElement_,this.class_),this.visible_||(this.textElement_.style.display="none"),this.sourceBlock_.getSvgRoot().appendChild(this.textElement_),this.textElement_.tooltip=this.sourceBlock_,Blockly.Tooltip.bindMouseEvents(this.textElement_),this.render_())};Blockly.FieldLabel.prototype.dispose=function(){goog.dom.removeNode(this.textElement_);this.textElement_=null};Blockly.FieldLabel.prototype.getSvgRoot=function(){return this.textElement_};Blockly.FieldLabel.prototype.setTooltip=function(a){this.textElement_.tooltip=a};Blockly.Input=function(a,b,c,d){if(a!=Blockly.DUMMY_INPUT&&!b){throw"Value inputs and statement inputs must have non-empty name."}this.type=a;this.name=b;this.sourceBlock_=c;this.connection=d;this.fieldRow=[]};Blockly.Input.prototype.align=Blockly.ALIGN_LEFT;Blockly.Input.prototype.visible_=!0;Blockly.Input.prototype.appendField=function(a,b){this.insertFieldAt(this.fieldRow.length,a,b);return this};Blockly.Input.prototype.insertFieldAt=function(a,b,c){if(0>a||a>this.fieldRow.length){throw Error("index "+a+" out of bounds.")}if(!b&&!c){return a}goog.isString(b)&&(b=new Blockly.FieldLabel(b));b.setSourceBlock(this.sourceBlock_);this.sourceBlock_.rendered&&b.init();b.name=c;b.prefixField&&(a=this.insertFieldAt(a,b.prefixField));this.fieldRow.splice(a,0,b);++a;b.suffixField&&(a=this.insertFieldAt(a,b.suffixField));this.sourceBlock_.rendered&&(this.sourceBlock_.render(),this.sourceBlock_.bumpNeighbours_());return a
-};Blockly.Input.prototype.removeField=function(a){for(var b=0,c;c=this.fieldRow[b];b++){if(c.name===a){c.dispose();this.fieldRow.splice(b,1);this.sourceBlock_.rendered&&(this.sourceBlock_.render(),this.sourceBlock_.bumpNeighbours_());return}}goog.asserts.fail('Field "%s" not found.',a)};Blockly.Input.prototype.isVisible=function(){return this.visible_};Blockly.Input.prototype.setVisible=function(a){var b=[];if(this.visible_==a){return b}for(var c=(this.visible_=a)?"block":"none",d=0,e;e=this.fieldRow[d];d++){e.setVisible(a)}this.connection&&(a?b=this.connection.unhideAll():this.connection.hideAll(),d=this.connection.targetBlock())&&(d.getSvgRoot().style.display=c,a||(d.rendered=!1));return b};Blockly.Input.prototype.setCheck=function(a){if(!this.connection){throw"This input does not have a connection."}this.connection.setCheck(a);return this};Blockly.Input.prototype.setAlign=function(a){this.align=a;this.sourceBlock_.rendered&&this.sourceBlock_.render();return this};Blockly.Input.prototype.init=function(){if(this.sourceBlock_.workspace.rendered){for(var a=0;a<this.fieldRow.length;a++){this.fieldRow[a].init()}}};Blockly.Input.prototype.dispose=function(){for(var a=0,b;b=this.fieldRow[a];a++){b.dispose()}this.connection&&this.connection.dispose();this.sourceBlock_=null};Blockly.ConnectionDB=function(){};Blockly.ConnectionDB.prototype=[];Blockly.ConnectionDB.constructor=Blockly.ConnectionDB;Blockly.ConnectionDB.prototype.addConnection=function(a){if(a.inDB_){throw"Connection already in database."}if(!a.getSourceBlock().isInFlyout){var b=this.findPositionForConnection_(a);this.splice(b,0,a);a.inDB_=!0}};Blockly.ConnectionDB.prototype.findConnection=function(a){if(!this.length){return -1}var b=this.findPositionForConnection_(a);if(b>=this.length){return -1}for(var c=a.y_,d=b;0<=d&&this[d].y_==c;){if(this[d]==a){return d}d--}for(;b<this.length&&this[b].y_==c;){if(this[b]==a){return b}b++}return -1};Blockly.ConnectionDB.prototype.findPositionForConnection_=function(a){if(!this.length){return 0
-}for(var b=0,c=this.length;b<c;){var d=Math.floor((b+c)/2);if(this[d].y_<a.y_){b=d+1}else{if(this[d].y_>a.y_){c=d}else{b=d;break}}}return b};Blockly.ConnectionDB.prototype.removeConnection_=function(a){if(!a.inDB_){throw"Connection not in database."}var b=this.findConnection(a);if(-1==b){throw"Unable to find connection in connectionDB."}a.inDB_=!1;this.splice(b,1)};Blockly.ConnectionDB.prototype.getNeighbours=function(a,b){function c(a){var c=e-d[a].x_,g=f-d[a].y_;Math.sqrt(c*c+g*g)<=b&&n.push(d[a]);return g<b}for(var d=this,e=a.x_,f=a.y_,g=0,h=d.length-2,k=h;g<k;){d[k].y_<f?g=k:h=k,k=Math.floor((g+h)/2)}var n=[];h=g=k;if(d.length){for(;0<=g&&c(g);){g--}do{h++}while(h<d.length&&c(h))}return n};Blockly.ConnectionDB.prototype.isInYRange_=function(a,b,c){return Math.abs(this[a].y_-b)<=c};Blockly.ConnectionDB.prototype.searchForClosest=function(a,b,c){if(!this.length){return{connection:null,radius:b}}var d=a.y_,e=a.x_;a.x_=e+c.x;a.y_=d+c.y;var f=this.findPositionForConnection_(a);c=null;for(var g=b,h,k=f-1;0<=k&&this.isInYRange_(k,a.y_,b);){h=this[k],a.isConnectionAllowed(h,g)&&(c=h,g=h.distanceFrom(a)),k--}for(;f<this.length&&this.isInYRange_(f,a.y_,b);){h=this[f],a.isConnectionAllowed(h,g)&&(c=h,g=h.distanceFrom(a)),f++}a.x_=e;a.y_=d;return{connection:c,radius:g}};Blockly.ConnectionDB.init=function(a){var b=[];b[Blockly.INPUT_VALUE]=new Blockly.ConnectionDB;b[Blockly.OUTPUT_VALUE]=new Blockly.ConnectionDB;b[Blockly.NEXT_STATEMENT]=new Blockly.ConnectionDB;b[Blockly.PREVIOUS_STATEMENT]=new Blockly.ConnectionDB;a.connectionDBList=b};Blockly.utils={};Blockly.utils.getMessageArray_=function(){return goog.global.Blockly.Msg};Blockly.utils.removeAttribute=function(a,b){goog.userAgent.IE&&goog.userAgent.isVersion("10.0")?a.setAttribute(b,null):a.removeAttribute(b)};Blockly.utils.addClass=function(a,b){var c=a.getAttribute("class")||"";if(-1!=(" "+c+" ").indexOf(" "+b+" ")){return !1}c&&(c+=" ");a.setAttribute("class",c+b);return !0};Blockly.utils.removeClass=function(a,b){var c=a.getAttribute("class");
-if(-1==(" "+c+" ").indexOf(" "+b+" ")){return !1}c=c.split(/\s+/);for(var d=0;d<c.length;d++){c[d]&&c[d]!=b||(c.splice(d,1),d--)}c.length?a.setAttribute("class",c.join(" ")):Blockly.utils.removeAttribute(a,"class");return !0};Blockly.utils.hasClass=function(a,b){return -1!=(" "+a.getAttribute("class")+" ").indexOf(" "+b+" ")};Blockly.utils.noEvent=function(a){a.preventDefault();a.stopPropagation()};Blockly.utils.isTargetInput=function(a){return"textarea"==a.target.type||"text"==a.target.type||"number"==a.target.type||"email"==a.target.type||"password"==a.target.type||"search"==a.target.type||"tel"==a.target.type||"url"==a.target.type||a.target.isContentEditable};Blockly.utils.getRelativeXY=function(a){var b=new goog.math.Coordinate(0,0),c=a.getAttribute("x");c&&(b.x=parseInt(c,10));if(c=a.getAttribute("y")){b.y=parseInt(c,10)}if(c=(c=a.getAttribute("transform"))&&c.match(Blockly.utils.getRelativeXY.XY_REGEX_)){b.x+=parseFloat(c[1]),c[3]&&(b.y+=parseFloat(c[3]))}(a=a.getAttribute("style"))&&-1<a.indexOf("translate")&&((c=a.match(Blockly.utils.getRelativeXY.XY_2D_REGEX_))||(c=a.match(Blockly.utils.getRelativeXY.XY_3D_REGEX_)),c&&(b.x+=parseFloat(c[1]),c[3]&&(b.y+=parseFloat(c[3]))));return b};Blockly.utils.getInjectionDivXY_=function(a){for(var b=0,c=0;a;){var d=Blockly.utils.getRelativeXY(a),e=Blockly.utils.getScale_(a);b=b*e+d.x;c=c*e+d.y;if(-1!=(" "+(a.getAttribute("class")||"")+" ").indexOf(" injectionDiv ")){break}a=a.parentNode}return new goog.math.Coordinate(b,c)};Blockly.utils.getScale_=function(a){var b=1;(a=a.getAttribute("transform"))&&(a=a.match(Blockly.utils.getScale_.REGEXP_))&&a[0]&&(b=parseFloat(a[0]));return b};Blockly.utils.getRelativeXY.XY_REGEX_=/translate\(\s*([-+\d.e]+)([ ,]\s*([-+\d.e]+)\s*\))?/;Blockly.utils.getScale_REGEXP_=/scale\(\s*([-+\d.e]+)\s*\)/;Blockly.utils.getRelativeXY.XY_3D_REGEX_=/transform:\s*translate3d\(\s*([-+\d.e]+)px([ ,]\s*([-+\d.e]+)\s*)px([ ,]\s*([-+\d.e]+)\s*)px\)?/;Blockly.utils.getRelativeXY.XY_2D_REGEX_=/transform:\s*translate\(\s*([-+\d.e]+)px([ ,]\s*([-+\d.e]+)\s*)px\)?/;
-Blockly.utils.createSvgElement=function(a,b,c){a=document.createElementNS(Blockly.SVG_NS,a);for(var d in b){a.setAttribute(d,b[d])}document.body.runtimeStyle&&(a.runtimeStyle=a.currentStyle=a.style);c&&c.appendChild(a);return a};Blockly.utils.isRightButton=function(a){return a.ctrlKey&&goog.userAgent.MAC?!0:2==a.button};Blockly.utils.mouseToSvg=function(a,b,c){var d=b.createSVGPoint();d.x=a.clientX;d.y=a.clientY;c||(c=b.getScreenCTM().inverse());return d.matrixTransform(c)};Blockly.utils.shortestStringLength=function(a){return a.length?a.reduce(function(a,c){return a.length<c.length?a:c}).length:0};Blockly.utils.commonWordPrefix=function(a,b){if(!a.length){return 0}if(1==a.length){return a[0].length}for(var c=0,d=b||Blockly.utils.shortestStringLength(a),e=0;e<d;e++){for(var f=a[0][e],g=1;g<a.length;g++){if(f!=a[g][e]){return c}}" "==f&&(c=e+1)}for(g=1;g<a.length;g++){if((f=a[g][e])&&" "!=f){return c}}return d};Blockly.utils.commonWordSuffix=function(a,b){if(!a.length){return 0}if(1==a.length){return a[0].length}for(var c=0,d=b||Blockly.utils.shortestStringLength(a),e=0;e<d;e++){for(var f=a[0].substr(-e-1,1),g=1;g<a.length;g++){if(f!=a[g].substr(-e-1,1)){return c}}" "==f&&(c=e+1)}for(g=1;g<a.length;g++){if((f=a[g].charAt(a[g].length-e-1))&&" "!=f){return c}}return d};Blockly.utils.tokenizeInterpolation=function(a){return Blockly.utils.tokenizeInterpolation_(a,!0)};Blockly.utils.replaceMessageReferences=function(a){if(!goog.isString(a)){return a}a=Blockly.utils.tokenizeInterpolation_(a,!1);return a.length?a[0]:""};Blockly.utils.checkMessageReferences=function(a){for(var b=!0,c=Blockly.utils.getMessageArray_(),d=/%{(BKY_[A-Z][A-Z0-9_]*)}/gi,e=d.exec(a);e;){var f=e[1];f=f.toUpperCase();"BKY_"!=f.substr(0,4)?(console.log("WARNING: Unsupported message table prefix in %{"+e[1]+"}."),b=!1):void 0==c[f.substr(4)]&&(console.log("WARNING: No message string for %{"+e[1]+"}."),b=!1);a=a.substring(e.index+f.length+1);e=d.exec(a)}return b};Blockly.utils.tokenizeInterpolation_=function(a,b){var c=[],d=a.split("");
-d.push("");for(var e=0,f=[],g=null,h=0;h<d.length;h++){var k=d[h];0==e?"%"==k?((k=f.join(""))&&c.push(k),f.length=0,e=1):f.push(k):1==e?"%"==k?(f.push(k),e=0):b&&"0"<=k&&"9">=k?(e=2,g=k,(k=f.join(""))&&c.push(k),f.length=0):"{"==k?e=3:(f.push("%",k),e=0):2==e?"0"<=k&&"9">=k?g+=k:(c.push(parseInt(g,10)),h--,e=0):3==e&&(""==k?(f.splice(0,0,"%{"),h--,e=0):"}"!=k?f.push(k):(e=f.join(""),/[a-zA-Z][a-zA-Z0-9_]*/.test(e)?(k=e.toUpperCase(),(k=goog.string.startsWith(k,"BKY_")?k.substring(4):null)&&k in Blockly.utils.getMessageArray_()?(e=Blockly.utils.getMessageArray_()[k],goog.isString(e)?Array.prototype.push.apply(c,Blockly.utils.tokenizeInterpolation_(e,b)):b?c.push(String(e)):c.push(e)):c.push("%{"+e+"}")):c.push("%{"+e+"}"),e=f.length=0))}(k=f.join(""))&&c.push(k);d=[];for(h=f.length=0;h<c.length;++h){"string"==typeof c[h]?f.push(c[h]):((k=f.join(""))&&d.push(k),f.length=0,d.push(c[h]))}(k=f.join(""))&&d.push(k);f.length=0;return d};Blockly.utils.genUid=function(){for(var a=Blockly.utils.genUid.soup_.length,b=[],c=0;20>c;c++){b[c]=Blockly.utils.genUid.soup_.charAt(Math.random()*a)}return b.join("")};Blockly.utils.genUid.soup_="!#$%()*+,-./:;=?@[]^_`{|}~ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";Blockly.utils.wrap=function(a,b){for(var c=a.split("\n"),d=0;d<c.length;d++){c[d]=Blockly.utils.wrapLine_(c[d],b)}return c.join("\n")};Blockly.utils.wrapLine_=function(a,b){if(a.length<=b){return a}for(var c=a.trim().split(/\s+/),d=0;d<c.length;d++){c[d].length>b&&(b=c[d].length)}d=-Infinity;var e=1;do{var f=d;var g=a;var h=[],k=c.length/e,n=1;for(d=0;d<c.length-1;d++){n<(d+1.5)/k?(n++,h[d]=!0):h[d]=!1}h=Blockly.utils.wrapMutate_(c,h,b);d=Blockly.utils.wrapScore_(c,h,b);a=Blockly.utils.wrapToText_(c,h);e++}while(d>f);return g};Blockly.utils.wrapScore_=function(a,b,c){for(var d=[0],e=[],f=0;f<a.length;f++){d[d.length-1]+=a[f].length,!0===b[f]?(d.push(0),e.push(a[f].charAt(a[f].length-1))):!1===b[f]&&d[d.length-1]++}a=Math.max.apply(Math,d);for(f=b=0;f<d.length;
-f++){b-=2*Math.pow(Math.abs(c-d[f]),1.5),b-=Math.pow(a-d[f],1.5),-1!=".?!".indexOf(e[f])?b+=c/3:-1!=",;)]}".indexOf(e[f])&&(b+=c/4)}1<d.length&&d[d.length-1]<=d[d.length-2]&&(b+=0.5);return b};Blockly.utils.wrapMutate_=function(a,b,c){for(var d=Blockly.utils.wrapScore_(a,b,c),e,f=0;f<b.length-1;f++){if(b[f]!=b[f+1]){var g=[].concat(b);g[f]=!g[f];g[f+1]=!g[f+1];var h=Blockly.utils.wrapScore_(a,g,c);h>d&&(d=h,e=g)}}return e?Blockly.utils.wrapMutate_(a,e,c):b};Blockly.utils.wrapToText_=function(a,b){for(var c=[],d=0;d<a.length;d++){c.push(a[d]),void 0!==b[d]&&c.push(b[d]?"\n":" ")}return c.join("")};Blockly.utils.is3dSupported=function(){if(void 0!==Blockly.utils.is3dSupported.cached_){return Blockly.utils.is3dSupported.cached_}if(!goog.global.getComputedStyle){return !1}var a=document.createElement("p"),b="none",c={webkitTransform:"-webkit-transform",OTransform:"-o-transform",msTransform:"-ms-transform",MozTransform:"-moz-transform",transform:"transform"};document.body.insertBefore(a,null);for(var d in c){if(void 0!==a.style[d]){a.style[d]="translate3d(1px,1px,1px)";b=goog.global.getComputedStyle(a);if(!b){return document.body.removeChild(a),!1}b=b.getPropertyValue(c[d])}}document.body.removeChild(a);Blockly.utils.is3dSupported.cached_="none"!==b;return Blockly.utils.is3dSupported.cached_};Blockly.utils.insertAfter_=function(a,b){var c=b.nextSibling,d=b.parentNode;if(!d){throw"Reference node has no parent."}c?d.insertBefore(a,c):d.appendChild(a)};Blockly.utils.runAfterPageLoad=function(a){if(!document){throw Error("Blockly.utils.runAfterPageLoad() requires browser document.")}if("complete"===document.readyState){a()}else{var b=setInterval(function(){"complete"===document.readyState&&(clearInterval(b),a())},10)}};Blockly.utils.setCssTransform=function(a,b){a.style.transform=b;a.style["-webkit-transform"]=b};Blockly.utils.getViewportBBox=function(){var a=goog.dom.getViewportSize(),b=goog.style.getViewportPageOffset(document);return{right:a.width+b.x,bottom:a.height+b.y,top:b.y,left:b.x}
-};Blockly.Grid=function(a,b){this.gridPattern_=a;this.spacing_=b.spacing;this.length_=b.length;this.line2_=(this.line1_=a.firstChild)&&this.line1_.nextSibling;this.snapToGrid_=b.snap};Blockly.Grid.prototype.scale_=1;Blockly.Grid.prototype.dispose=function(){this.gridPattern_=null};Blockly.Grid.prototype.shouldSnap=function(){return this.snapToGrid_};Blockly.Grid.prototype.getSpacing=function(){return this.spacing_};Blockly.Grid.prototype.getPatternId=function(){return this.gridPattern_.id};Blockly.Grid.prototype.update=function(a){this.scale_=a;var b=this.spacing_*a||100;this.gridPattern_.setAttribute("width",b);this.gridPattern_.setAttribute("height",b);b=Math.floor(this.spacing_/2)+0.5;var c=b-this.length_/2,d=b+this.length_/2;b*=a;c*=a;d*=a;this.setLineAttributes_(this.line1_,a,c,d,b,b);this.setLineAttributes_(this.line2_,a,b,b,c,d)};Blockly.Grid.prototype.setLineAttributes_=function(a,b,c,d,e,f){a&&(a.setAttribute("stroke-width",b),a.setAttribute("x1",c),a.setAttribute("y1",e),a.setAttribute("x2",d),a.setAttribute("y2",f))};Blockly.Grid.prototype.moveTo=function(a,b){this.gridPattern_.setAttribute("x",a);this.gridPattern_.setAttribute("y",b);(goog.userAgent.IE||goog.userAgent.EDGE)&&this.update(this.scale_)};Blockly.Grid.createDom=function(a,b,c){a=Blockly.utils.createSvgElement("pattern",{id:"blocklyGridPattern"+a,patternUnits:"userSpaceOnUse"},c);0<b.length&&0<b.spacing&&(Blockly.utils.createSvgElement("line",{stroke:b.colour},a),1<b.length&&Blockly.utils.createSvgElement("line",{stroke:b.colour},a));return a};Blockly.Options=function(a){var b=!!a.readOnly;if(b){var c=null,d=!1,e=!1,f=!1,g=!1,h=!1,k=!1}else{c=Blockly.Options.parseToolboxTree(a.toolbox),d=!(!c||!c.getElementsByTagName("category").length),e=a.trashcan,void 0===e&&(e=d),f=a.collapse,void 0===f&&(f=d),g=a.comments,void 0===g&&(g=d),h=a.disable,void 0===h&&(h=d),k=a.sounds,void 0===k&&(k=!0)}var n=!!a.rtl,p=a.horizontalLayout;void 0===p&&(p=!1);var l=a.toolboxPosition;l="end"===l?!1:!0;l=p?l?Blockly.TOOLBOX_AT_TOP:Blockly.TOOLBOX_AT_BOTTOM:l==n?Blockly.TOOLBOX_AT_RIGHT:Blockly.TOOLBOX_AT_LEFT;
-var m=a.scrollbars;void 0===m&&(m=d);var q=a.css;void 0===q&&(q=!0);var t="https://blockly-demo.appspot.com/static/media/";a.media?t=a.media:a.path&&(t=a.path+"media/");var r=void 0===a.oneBasedIndex?!0:!!a.oneBasedIndex;this.RTL=n;this.oneBasedIndex=r;this.collapse=f;this.comments=g;this.disable=h;this.readOnly=b;this.maxBlocks=a.maxBlocks||Infinity;this.pathToMedia=t;this.hasCategories=d;this.hasScrollbars=m;this.hasTrashcan=e;this.hasSounds=k;this.hasCss=q;this.horizontalLayout=p;this.languageTree=c;this.gridOptions=Blockly.Options.parseGridOptions_(a);this.zoomOptions=Blockly.Options.parseZoomOptions_(a);this.toolboxPosition=l};Blockly.Options.prototype.parentWorkspace=null;Blockly.Options.prototype.setMetrics=null;Blockly.Options.prototype.getMetrics=null;Blockly.Options.parseZoomOptions_=function(a){a=a.zoom||{};var b={};b.controls=void 0===a.controls?!1:!!a.controls;b.wheel=void 0===a.wheel?!1:!!a.wheel;b.startScale=void 0===a.startScale?1:parseFloat(a.startScale);b.maxScale=void 0===a.maxScale?3:parseFloat(a.maxScale);b.minScale=void 0===a.minScale?0.3:parseFloat(a.minScale);b.scaleSpeed=void 0===a.scaleSpeed?1.2:parseFloat(a.scaleSpeed);return b};Blockly.Options.parseGridOptions_=function(a){a=a.grid||{};var b={};b.spacing=parseFloat(a.spacing)||0;b.colour=a.colour||"#888";b.length=parseFloat(a.length)||1;b.snap=0<b.spacing&&!!a.snap;return b};Blockly.Options.parseToolboxTree=function(a){a?("string"!=typeof a&&("undefined"==typeof XSLTProcessor&&a.outerHTML?a=a.outerHTML:a instanceof Element||(a=null)),"string"==typeof a&&(a=Blockly.Xml.textToDom(a))):a=null;return a};Blockly.ScrollbarPair=function(a){this.workspace_=a;this.hScroll=new Blockly.Scrollbar(a,!0,!0,"blocklyMainWorkspaceScrollbar");this.vScroll=new Blockly.Scrollbar(a,!1,!0,"blocklyMainWorkspaceScrollbar");this.corner_=Blockly.utils.createSvgElement("rect",{height:Blockly.Scrollbar.scrollbarThickness,width:Blockly.Scrollbar.scrollbarThickness,"class":"blocklyScrollbarBackground"},null);Blockly.utils.insertAfter_(this.corner_,a.getBubbleCanvas())
-};Blockly.ScrollbarPair.prototype.oldHostMetrics_=null;Blockly.ScrollbarPair.prototype.dispose=function(){goog.dom.removeNode(this.corner_);this.oldHostMetrics_=this.workspace_=this.corner_=null;this.hScroll.dispose();this.hScroll=null;this.vScroll.dispose();this.vScroll=null};Blockly.ScrollbarPair.prototype.resize=function(){var a=this.workspace_.getMetrics();if(a){var b=!1,c=!1;this.oldHostMetrics_&&this.oldHostMetrics_.viewWidth==a.viewWidth&&this.oldHostMetrics_.viewHeight==a.viewHeight&&this.oldHostMetrics_.absoluteTop==a.absoluteTop&&this.oldHostMetrics_.absoluteLeft==a.absoluteLeft?(this.oldHostMetrics_&&this.oldHostMetrics_.contentWidth==a.contentWidth&&this.oldHostMetrics_.viewLeft==a.viewLeft&&this.oldHostMetrics_.contentLeft==a.contentLeft||(b=!0),this.oldHostMetrics_&&this.oldHostMetrics_.contentHeight==a.contentHeight&&this.oldHostMetrics_.viewTop==a.viewTop&&this.oldHostMetrics_.contentTop==a.contentTop||(c=!0)):c=b=!0;b&&this.hScroll.resize(a);c&&this.vScroll.resize(a);this.oldHostMetrics_&&this.oldHostMetrics_.viewWidth==a.viewWidth&&this.oldHostMetrics_.absoluteLeft==a.absoluteLeft||this.corner_.setAttribute("x",this.vScroll.position_.x);this.oldHostMetrics_&&this.oldHostMetrics_.viewHeight==a.viewHeight&&this.oldHostMetrics_.absoluteTop==a.absoluteTop||this.corner_.setAttribute("y",this.hScroll.position_.y);this.oldHostMetrics_=a}};Blockly.ScrollbarPair.prototype.set=function(a,b){var c={},d=a*this.hScroll.ratio_,e=b*this.vScroll.ratio_,f=this.vScroll.scrollViewSize_;c.x=this.getRatio_(d,this.hScroll.scrollViewSize_);c.y=this.getRatio_(e,f);this.workspace_.setMetrics(c);this.hScroll.setHandlePosition(d);this.vScroll.setHandlePosition(e)};Blockly.ScrollbarPair.prototype.getRatio_=function(a,b){var c=a/b;return isNaN(c)?0:c};Blockly.Scrollbar=function(a,b,c,d){this.workspace_=a;this.pair_=c||!1;this.horizontal_=b;this.oldHostMetrics_=null;this.createDom_(d);this.position_=new goog.math.Coordinate(0,0);b?(this.svgBackground_.setAttribute("height",Blockly.Scrollbar.scrollbarThickness),this.outerSvg_.setAttribute("height",Blockly.Scrollbar.scrollbarThickness),this.svgHandle_.setAttribute("height",Blockly.Scrollbar.scrollbarThickness-5),this.svgHandle_.setAttribute("y",2.5),this.lengthAttribute_="width",this.positionAttribute_="x"):(this.svgBackground_.setAttribute("width",Blockly.Scrollbar.scrollbarThickness),this.outerSvg_.setAttribute("width",Blockly.Scrollbar.scrollbarThickness),this.svgHandle_.setAttribute("width",Blockly.Scrollbar.scrollbarThickness-5),this.svgHandle_.setAttribute("x",2.5),this.lengthAttribute_="height",this.positionAttribute_="y");
-this.onMouseDownBarWrapper_=Blockly.bindEventWithChecks_(this.svgBackground_,"mousedown",this,this.onMouseDownBar_);this.onMouseDownHandleWrapper_=Blockly.bindEventWithChecks_(this.svgHandle_,"mousedown",this,this.onMouseDownHandle_)};Blockly.Scrollbar.prototype.origin_=new goog.math.Coordinate(0,0);Blockly.Scrollbar.prototype.startDragMouse_=0;Blockly.Scrollbar.prototype.scrollViewSize_=0;Blockly.Scrollbar.prototype.handleLength_=0;Blockly.Scrollbar.prototype.handlePosition_=0;Blockly.Scrollbar.prototype.isVisible_=!0;Blockly.Scrollbar.prototype.containerVisible_=!0;Blockly.Scrollbar.scrollbarThickness=15;goog.events.BrowserFeature.TOUCH_ENABLED&&(Blockly.Scrollbar.scrollbarThickness=25);Blockly.Scrollbar.metricsAreEquivalent_=function(a,b){return a&&b&&a.viewWidth==b.viewWidth&&a.viewHeight==b.viewHeight&&a.viewLeft==b.viewLeft&&a.viewTop==b.viewTop&&a.absoluteTop==b.absoluteTop&&a.absoluteLeft==b.absoluteLeft&&a.contentWidth==b.contentWidth&&a.contentHeight==b.contentHeight&&a.contentLeft==b.contentLeft&&a.contentTop==b.contentTop?!0:!1};Blockly.Scrollbar.prototype.dispose=function(){this.cleanUp_();Blockly.unbindEvent_(this.onMouseDownBarWrapper_);this.onMouseDownBarWrapper_=null;Blockly.unbindEvent_(this.onMouseDownHandleWrapper_);this.onMouseDownHandleWrapper_=null;goog.dom.removeNode(this.outerSvg_);this.workspace_=this.svgHandle_=this.svgBackground_=this.svgGroup_=this.outerSvg_=null};Blockly.Scrollbar.prototype.setHandleLength_=function(a){this.handleLength_=a;this.svgHandle_.setAttribute(this.lengthAttribute_,this.handleLength_)};Blockly.Scrollbar.prototype.setHandlePosition=function(a){this.handlePosition_=a;this.svgHandle_.setAttribute(this.positionAttribute_,this.handlePosition_)};Blockly.Scrollbar.prototype.setScrollViewSize_=function(a){this.scrollViewSize_=a;this.outerSvg_.setAttribute(this.lengthAttribute_,this.scrollViewSize_);this.svgBackground_.setAttribute(this.lengthAttribute_,this.scrollViewSize_)};Blockly.ScrollbarPair.prototype.setContainerVisible=function(a){this.hScroll.setContainerVisible(a);
-this.vScroll.setContainerVisible(a)};Blockly.Scrollbar.prototype.setPosition_=function(a,b){this.position_.x=a;this.position_.y=b;Blockly.utils.setCssTransform(this.outerSvg_,"translate("+(this.position_.x+this.origin_.x)+"px,"+(this.position_.y+this.origin_.y)+"px)")};Blockly.Scrollbar.prototype.resize=function(a){if(!a&&(a=this.workspace_.getMetrics(),!a)){return}Blockly.Scrollbar.metricsAreEquivalent_(a,this.oldHostMetrics_)||(this.oldHostMetrics_=a,this.horizontal_?this.resizeHorizontal_(a):this.resizeVertical_(a),this.onScroll_())};Blockly.Scrollbar.prototype.resizeHorizontal_=function(a){this.resizeViewHorizontal(a)};Blockly.Scrollbar.prototype.resizeViewHorizontal=function(a){var b=a.viewWidth-1;this.pair_&&(b-=Blockly.Scrollbar.scrollbarThickness);this.setScrollViewSize_(Math.max(0,b));b=a.absoluteLeft+0.5;this.pair_&&this.workspace_.RTL&&(b+=Blockly.Scrollbar.scrollbarThickness);this.setPosition_(b,a.absoluteTop+a.viewHeight-Blockly.Scrollbar.scrollbarThickness-0.5);this.resizeContentHorizontal(a)};Blockly.Scrollbar.prototype.resizeContentHorizontal=function(a){this.pair_||this.setVisible(this.scrollViewSize_<a.contentWidth);this.ratio_=this.scrollViewSize_/a.contentWidth;if(-Infinity==this.ratio_||Infinity==this.ratio_||isNaN(this.ratio_)){this.ratio_=0}this.setHandleLength_(Math.max(0,a.viewWidth*this.ratio_));this.setHandlePosition(this.constrainHandle_((a.viewLeft-a.contentLeft)*this.ratio_))};Blockly.Scrollbar.prototype.resizeVertical_=function(a){this.resizeViewVertical(a)};Blockly.Scrollbar.prototype.resizeViewVertical=function(a){var b=a.viewHeight-1;this.pair_&&(b-=Blockly.Scrollbar.scrollbarThickness);this.setScrollViewSize_(Math.max(0,b));b=a.absoluteLeft+0.5;this.workspace_.RTL||(b+=a.viewWidth-Blockly.Scrollbar.scrollbarThickness-1);this.setPosition_(b,a.absoluteTop+0.5);this.resizeContentVertical(a)};Blockly.Scrollbar.prototype.resizeContentVertical=function(a){this.pair_||this.setVisible(this.scrollViewSize_<a.contentHeight);this.ratio_=this.scrollViewSize_/a.contentHeight;
-if(-Infinity==this.ratio_||Infinity==this.ratio_||isNaN(this.ratio_)){this.ratio_=0}this.setHandleLength_(Math.max(0,a.viewHeight*this.ratio_));this.setHandlePosition(this.constrainHandle_((a.viewTop-a.contentTop)*this.ratio_))};Blockly.Scrollbar.prototype.createDom_=function(a){var b="blocklyScrollbar"+(this.horizontal_?"Horizontal":"Vertical");a&&(b+=" "+a);this.outerSvg_=Blockly.utils.createSvgElement("svg",{"class":b},null);this.svgGroup_=Blockly.utils.createSvgElement("g",{},this.outerSvg_);this.svgBackground_=Blockly.utils.createSvgElement("rect",{"class":"blocklyScrollbarBackground"},this.svgGroup_);a=Math.floor((Blockly.Scrollbar.scrollbarThickness-5)/2);this.svgHandle_=Blockly.utils.createSvgElement("rect",{"class":"blocklyScrollbarHandle",rx:a,ry:a},this.svgGroup_);Blockly.utils.insertAfter_(this.outerSvg_,this.workspace_.getParentSvg())};Blockly.Scrollbar.prototype.isVisible=function(){return this.isVisible_};Blockly.Scrollbar.prototype.setContainerVisible=function(a){var b=a!=this.containerVisible_;this.containerVisible_=a;b&&this.updateDisplay_()};Blockly.Scrollbar.prototype.setVisible=function(a){var b=a!=this.isVisible();if(this.pair_){throw"Unable to toggle visibility of paired scrollbars."}this.isVisible_=a;b&&this.updateDisplay_()};Blockly.Scrollbar.prototype.updateDisplay_=function(){this.containerVisible_&&this.isVisible()?this.outerSvg_.setAttribute("display","block"):this.outerSvg_.setAttribute("display","none")};Blockly.Scrollbar.prototype.onMouseDownBar_=function(a){this.workspace_.markFocused();Blockly.Touch.clearTouchIdentifier();this.cleanUp_();if(Blockly.utils.isRightButton(a)){a.stopPropagation()}else{var b=Blockly.utils.mouseToSvg(a,this.workspace_.getParentSvg(),this.workspace_.getInverseScreenCTM());b=this.horizontal_?b.x:b.y;var c=Blockly.utils.getInjectionDivXY_(this.svgHandle_);c=this.horizontal_?c.x:c.y;var d=this.handlePosition_,e=0.95*this.handleLength_;b<=c?d-=e:b>=c+this.handleLength_&&(d+=e);this.setHandlePosition(this.constrainHandle_(d));
-this.onScroll_();a.stopPropagation();a.preventDefault()}};Blockly.Scrollbar.prototype.onMouseDownHandle_=function(a){this.workspace_.markFocused();this.cleanUp_();Blockly.utils.isRightButton(a)?a.stopPropagation():(this.startDragHandle=this.handlePosition_,this.workspace_.setupDragSurface(),this.startDragMouse_=this.horizontal_?a.clientX:a.clientY,Blockly.Scrollbar.onMouseUpWrapper_=Blockly.bindEventWithChecks_(document,"mouseup",this,this.onMouseUpHandle_),Blockly.Scrollbar.onMouseMoveWrapper_=Blockly.bindEventWithChecks_(document,"mousemove",this,this.onMouseMoveHandle_),a.stopPropagation(),a.preventDefault())};Blockly.Scrollbar.prototype.onMouseMoveHandle_=function(a){this.setHandlePosition(this.constrainHandle_(this.startDragHandle+((this.horizontal_?a.clientX:a.clientY)-this.startDragMouse_)));this.onScroll_()};Blockly.Scrollbar.prototype.onMouseUpHandle_=function(){this.workspace_.resetDragSurface();Blockly.Touch.clearTouchIdentifier();this.cleanUp_()};Blockly.Scrollbar.prototype.cleanUp_=function(){Blockly.hideChaff(!0);Blockly.Scrollbar.onMouseUpWrapper_&&(Blockly.unbindEvent_(Blockly.Scrollbar.onMouseUpWrapper_),Blockly.Scrollbar.onMouseUpWrapper_=null);Blockly.Scrollbar.onMouseMoveWrapper_&&(Blockly.unbindEvent_(Blockly.Scrollbar.onMouseMoveWrapper_),Blockly.Scrollbar.onMouseMoveWrapper_=null)};Blockly.Scrollbar.prototype.constrainHandle_=function(a){return a=0>=a||isNaN(a)||this.scrollViewSize_<this.handleLength_?0:Math.min(a,this.scrollViewSize_-this.handleLength_)};Blockly.Scrollbar.prototype.onScroll_=function(){var a=this.handlePosition_/this.scrollViewSize_;isNaN(a)&&(a=0);var b={};this.horizontal_?b.x=a:b.y=a;this.workspace_.setMetrics(b)};Blockly.Scrollbar.prototype.set=function(a){this.setHandlePosition(this.constrainHandle_(a*this.ratio_));this.onScroll_()};Blockly.Scrollbar.prototype.setOrigin=function(a,b){this.origin_=new goog.math.Coordinate(a,b)};Blockly.Trashcan=function(a){this.workspace_=a};Blockly.Trashcan.prototype.WIDTH_=47;Blockly.Trashcan.prototype.BODY_HEIGHT_=44;
-Blockly.Trashcan.prototype.LID_HEIGHT_=16;Blockly.Trashcan.prototype.MARGIN_BOTTOM_=20;Blockly.Trashcan.prototype.MARGIN_SIDE_=20;Blockly.Trashcan.prototype.MARGIN_HOTSPOT_=10;Blockly.Trashcan.prototype.SPRITE_LEFT_=0;Blockly.Trashcan.prototype.SPRITE_TOP_=32;Blockly.Trashcan.prototype.isOpen=!1;Blockly.Trashcan.prototype.svgGroup_=null;Blockly.Trashcan.prototype.svgLid_=null;Blockly.Trashcan.prototype.lidTask_=0;Blockly.Trashcan.prototype.lidOpen_=0;Blockly.Trashcan.prototype.left_=0;Blockly.Trashcan.prototype.top_=0;Blockly.Trashcan.prototype.createDom=function(){this.svgGroup_=Blockly.utils.createSvgElement("g",{"class":"blocklyTrash"},null);var a=String(Math.random()).substring(2);var b=Blockly.utils.createSvgElement("clipPath",{id:"blocklyTrashBodyClipPath"+a},this.svgGroup_);Blockly.utils.createSvgElement("rect",{width:this.WIDTH_,height:this.BODY_HEIGHT_,y:this.LID_HEIGHT_},b);Blockly.utils.createSvgElement("image",{width:Blockly.SPRITE.width,x:-this.SPRITE_LEFT_,height:Blockly.SPRITE.height,y:-this.SPRITE_TOP_,"clip-path":"url(#blocklyTrashBodyClipPath"+a+")"},this.svgGroup_).setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",this.workspace_.options.pathToMedia+Blockly.SPRITE.url);b=Blockly.utils.createSvgElement("clipPath",{id:"blocklyTrashLidClipPath"+a},this.svgGroup_);Blockly.utils.createSvgElement("rect",{width:this.WIDTH_,height:this.LID_HEIGHT_},b);this.svgLid_=Blockly.utils.createSvgElement("image",{width:Blockly.SPRITE.width,x:-this.SPRITE_LEFT_,height:Blockly.SPRITE.height,y:-this.SPRITE_TOP_,"clip-path":"url(#blocklyTrashLidClipPath"+a+")"},this.svgGroup_);this.svgLid_.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",this.workspace_.options.pathToMedia+Blockly.SPRITE.url);Blockly.bindEventWithChecks_(this.svgGroup_,"mouseup",this,this.click);this.animateLid_();return this.svgGroup_};Blockly.Trashcan.prototype.init=function(a){this.bottom_=this.MARGIN_BOTTOM_+a;this.setOpen_(!1);return this.bottom_+this.BODY_HEIGHT_+this.LID_HEIGHT_
-};Blockly.Trashcan.prototype.dispose=function(){this.svgGroup_&&(goog.dom.removeNode(this.svgGroup_),this.svgGroup_=null);this.workspace_=this.svgLid_=null;goog.Timer.clear(this.lidTask_)};Blockly.Trashcan.prototype.position=function(){var a=this.workspace_.getMetrics();a&&(this.workspace_.RTL?(this.left_=this.MARGIN_SIDE_+Blockly.Scrollbar.scrollbarThickness,a.toolboxPosition==Blockly.TOOLBOX_AT_LEFT&&(this.left_+=a.flyoutWidth,this.workspace_.toolbox_&&(this.left_+=a.absoluteLeft))):(this.left_=a.viewWidth+a.absoluteLeft-this.WIDTH_-this.MARGIN_SIDE_-Blockly.Scrollbar.scrollbarThickness,a.toolboxPosition==Blockly.TOOLBOX_AT_RIGHT&&(this.left_-=a.flyoutWidth)),this.top_=a.viewHeight+a.absoluteTop-(this.BODY_HEIGHT_+this.LID_HEIGHT_)-this.bottom_,a.toolboxPosition==Blockly.TOOLBOX_AT_BOTTOM&&(this.top_-=a.flyoutHeight),this.svgGroup_.setAttribute("transform","translate("+this.left_+","+this.top_+")"))};Blockly.Trashcan.prototype.getClientRect=function(){if(!this.svgGroup_){return null}var a=this.svgGroup_.getBoundingClientRect();return new goog.math.Rect(a.left+this.SPRITE_LEFT_-this.MARGIN_HOTSPOT_,a.top+this.SPRITE_TOP_-this.MARGIN_HOTSPOT_,this.WIDTH_+2*this.MARGIN_HOTSPOT_,this.LID_HEIGHT_+this.BODY_HEIGHT_+2*this.MARGIN_HOTSPOT_)};Blockly.Trashcan.prototype.setOpen_=function(a){this.isOpen!=a&&(goog.Timer.clear(this.lidTask_),this.isOpen=a,this.animateLid_())};Blockly.Trashcan.prototype.animateLid_=function(){this.lidOpen_+=this.isOpen?0.2:-0.2;this.lidOpen_=goog.math.clamp(this.lidOpen_,0,1);var a=45*this.lidOpen_;this.svgLid_.setAttribute("transform","rotate("+(this.workspace_.RTL?-a:a)+","+(this.workspace_.RTL?4:this.WIDTH_-4)+","+(this.LID_HEIGHT_-2)+")");a=goog.math.lerp(0.4,0.8,this.lidOpen_);this.svgGroup_.style.opacity=a;0<this.lidOpen_&&1>this.lidOpen_&&(this.lidTask_=goog.Timer.callOnce(this.animateLid_,20,this))};Blockly.Trashcan.prototype.close=function(){this.setOpen_(!1)};Blockly.Trashcan.prototype.click=function(){var a=this.workspace_.startScrollX-this.workspace_.scrollX,b=this.workspace_.startScrollY-this.workspace_.scrollY;
-Math.sqrt(a*a+b*b)>Blockly.DRAG_RADIUS||console.log("TODO: Inspect trash.")};Blockly.WorkspaceAudio=function(a){this.parentWorkspace_=a;this.SOUNDS_=Object.create(null)};Blockly.WorkspaceAudio.prototype.lastSound_=null;Blockly.WorkspaceAudio.prototype.dispose=function(){this.SOUNDS_=this.parentWorkspace_=null};Blockly.WorkspaceAudio.prototype.load=function(a,b){if(a.length){try{var c=new window.Audio}catch(h){return}for(var d,e=0;e<a.length;e++){var f=a[e],g=f.match(/\.(\w+)$/);if(g&&c.canPlayType("audio/"+g[1])){d=new window.Audio(f);break}}d&&d.play&&(this.SOUNDS_[b]=d)}};Blockly.WorkspaceAudio.prototype.preload=function(){for(var a in this.SOUNDS_){var b=this.SOUNDS_[a];b.volume=0.01;b.play();b.pause();if(goog.userAgent.IPAD||goog.userAgent.IPHONE){break}}};Blockly.WorkspaceAudio.prototype.play=function(a,b){var c=this.SOUNDS_[a];if(c){var d=new Date;null!=this.lastSound_&&d-this.lastSound_<Blockly.SOUND_LIMIT||(this.lastSound_=d,c=goog.userAgent.DOCUMENT_MODE&&9===goog.userAgent.DOCUMENT_MODE||goog.userAgent.IPAD||goog.userAgent.ANDROID?c:c.cloneNode(),c.volume=void 0===b?1:b,c.play())}else{this.parentWorkspace_&&this.parentWorkspace_.getAudioManager().play(a,b)}};Blockly.WorkspaceDragSurfaceSvg=function(a){this.container_=a;this.createDom()};Blockly.WorkspaceDragSurfaceSvg.prototype.SVG_=null;Blockly.WorkspaceDragSurfaceSvg.prototype.dragGroup_=null;Blockly.WorkspaceDragSurfaceSvg.prototype.container_=null;Blockly.WorkspaceDragSurfaceSvg.prototype.createDom=function(){this.SVG_||(this.SVG_=Blockly.utils.createSvgElement("svg",{xmlns:Blockly.SVG_NS,"xmlns:html":Blockly.HTML_NS,"xmlns:xlink":"http://www.w3.org/1999/xlink",version:"1.1","class":"blocklyWsDragSurface blocklyOverflowVisible"},null),this.container_.appendChild(this.SVG_))};Blockly.WorkspaceDragSurfaceSvg.prototype.translateSurface=function(a,b){a=a.toFixed(0);b=b.toFixed(0);this.SVG_.style.display="block";Blockly.utils.setCssTransform(this.SVG_,"translate3d("+a+"px, "+b+"px, 0px)")};Blockly.WorkspaceDragSurfaceSvg.prototype.getSurfaceTranslation=function(){return Blockly.utils.getRelativeXY(this.SVG_)
-};Blockly.WorkspaceDragSurfaceSvg.prototype.clearAndHide=function(a){var b=this.SVG_.childNodes[0],c=this.SVG_.childNodes[1];if(!(b&&c&&Blockly.utils.hasClass(b,"blocklyBlockCanvas")&&Blockly.utils.hasClass(c,"blocklyBubbleCanvas"))){throw"Couldn't clear and hide the drag surface.  A node was missing."}null!=this.previousSibling_?Blockly.utils.insertAfter_(b,this.previousSibling_):a.insertBefore(b,a.firstChild);Blockly.utils.insertAfter_(c,b);this.SVG_.style.display="none";goog.asserts.assert(0==this.SVG_.childNodes.length,"Drag surface was not cleared.");Blockly.utils.setCssTransform(this.SVG_,"");this.previousSibling_=null};Blockly.WorkspaceDragSurfaceSvg.prototype.setContentsAndShow=function(a,b,c,d,e,f){goog.asserts.assert(0==this.SVG_.childNodes.length,"Already dragging a block.");this.previousSibling_=c;a.setAttribute("transform","translate(0, 0) scale("+f+")");b.setAttribute("transform","translate(0, 0) scale("+f+")");this.SVG_.setAttribute("width",d);this.SVG_.setAttribute("height",e);this.SVG_.appendChild(a);this.SVG_.appendChild(b);this.SVG_.style.display="block"};Blockly.Xml={};Blockly.Xml.workspaceToDom=function(a,b){var c=goog.dom.createDom("xml");c.appendChild(Blockly.Xml.variablesToDom(a.getAllVariables()));for(var d=a.getTopBlocks(!0),e=0,f;f=d[e];e++){c.appendChild(Blockly.Xml.blockToDomWithXY(f,b))}return c};Blockly.Xml.variablesToDom=function(a){for(var b=goog.dom.createDom("variables"),c=0,d;d=a[c];c++){var e=goog.dom.createDom("variable",null,d.name);e.setAttribute("type",d.type);e.setAttribute("id",d.getId());b.appendChild(e)}return b};Blockly.Xml.blockToDomWithXY=function(a,b){var c;a.workspace.RTL&&(c=a.workspace.getWidth());var d=Blockly.Xml.blockToDom(a,b),e=a.getRelativeToSurfaceXY();d.setAttribute("x",Math.round(a.workspace.RTL?c-e.x:e.x));d.setAttribute("y",Math.round(e.y));return d};Blockly.Xml.blockToDom=function(a,b){var c=goog.dom.createDom(a.isShadow()?"shadow":"block");c.setAttribute("type",a.type);b||c.setAttribute("id",a.id);if(a.mutationToDom){var d=a.mutationToDom();
-d&&(d.hasChildNodes()||d.hasAttributes())&&c.appendChild(d)}d=0;for(var e;e=a.inputList[d];d++){for(var f=0,g;g=e.fieldRow[f];f++){var h=g;h.name&&h.EDITABLE&&(g=goog.dom.createDom("field",null,h.getValue()),g.setAttribute("name",h.name),h instanceof Blockly.FieldVariable&&(h=a.workspace.getVariable(h.getValue()))&&(g.setAttribute("id",h.getId()),g.setAttribute("variabletype",h.type)),c.appendChild(g))}}if(d=a.getCommentText()){d=goog.dom.createDom("comment",null,d),"object"==typeof a.comment&&(d.setAttribute("pinned",a.comment.isVisible()),e=a.comment.getBubbleSize(),d.setAttribute("h",e.height),d.setAttribute("w",e.width)),c.appendChild(d)}a.data&&(d=goog.dom.createDom("data",null,a.data),c.appendChild(d));for(d=0;e=a.inputList[d];d++){var k;g=!0;e.type!=Blockly.DUMMY_INPUT&&(h=e.connection.targetBlock(),e.type==Blockly.INPUT_VALUE?k=goog.dom.createDom("value"):e.type==Blockly.NEXT_STATEMENT&&(k=goog.dom.createDom("statement")),f=e.connection.getShadowDom(),!f||h&&h.isShadow()||k.appendChild(Blockly.Xml.cloneShadow_(f)),h&&(k.appendChild(Blockly.Xml.blockToDom(h,b)),g=!1),k.setAttribute("name",e.name),g||c.appendChild(k))}a.inputsInlineDefault!=a.inputsInline&&c.setAttribute("inline",a.inputsInline);a.isCollapsed()&&c.setAttribute("collapsed",!0);a.disabled&&c.setAttribute("disabled",!0);a.isDeletable()||a.isShadow()||c.setAttribute("deletable",!1);a.isMovable()||a.isShadow()||c.setAttribute("movable",!1);a.isEditable()||c.setAttribute("editable",!1);if(d=a.getNextBlock()){k=goog.dom.createDom("next",null,Blockly.Xml.blockToDom(d,b)),c.appendChild(k)}f=a.nextConnection&&a.nextConnection.getShadowDom();!f||d&&d.isShadow()||k.appendChild(Blockly.Xml.cloneShadow_(f));return c};Blockly.Xml.cloneShadow_=function(a){for(var b=a=a.cloneNode(!0),c;b;){if(b.firstChild){b=b.firstChild}else{for(;b&&!b.nextSibling;){c=b,b=b.parentNode,3==c.nodeType&&""==c.data.trim()&&b.firstChild!=c&&goog.dom.removeNode(c)}b&&(c=b,b=b.nextSibling,3==c.nodeType&&""==c.data.trim()&&goog.dom.removeNode(c))
-}}return a};Blockly.Xml.domToText=function(a){return(new XMLSerializer).serializeToString(a)};Blockly.Xml.domToPrettyText=function(a){a=Blockly.Xml.domToText(a).split("<");for(var b="",c=1;c<a.length;c++){var d=a[c];"/"==d[0]&&(b=b.substring(2));a[c]=b+"<"+d;"/"!=d[0]&&"/>"!=d.slice(-2)&&(b+="  ")}a=a.join("\n");a=a.replace(/(<(\w+)\b[^>]*>[^\n]*)\n *<\/\2>/g,"$1</$2>");return a.replace(/^\n/,"")};Blockly.Xml.textToDom=function(a){(a=(new DOMParser).parseFromString(a,"text/xml"))&&a.firstChild&&"xml"==a.firstChild.nodeName.toLowerCase()&&a.firstChild===a.lastChild||goog.asserts.fail("Blockly.Xml.textToDom did not obtain a valid XML tree.");return a.firstChild};Blockly.Xml.domToWorkspace=function(a,b){if(a instanceof Blockly.Workspace){var c=a;a=b;b=c;console.warn("Deprecated call to Blockly.Xml.domToWorkspace, swap the arguments.")}var d;b.RTL&&(d=b.getWidth());c=[];Blockly.Field.startCache();var e=a.childNodes.length,f=Blockly.Events.getGroup();f||Blockly.Events.setGroup(!0);b.setResizesEnabled&&b.setResizesEnabled(!1);var g=!0;try{for(var h=0;h<e;h++){var k=a.childNodes[h],n=k.nodeName.toLowerCase();if("block"==n||"shadow"==n&&!Blockly.Events.recordUndo){var p=Blockly.Xml.domToBlock(k,b);c.push(p.id);var l=parseInt(k.getAttribute("x"),10),m=parseInt(k.getAttribute("y"),10);isNaN(l)||isNaN(m)||p.moveBy(b.RTL?d-l:l,m);g=!1}else{if("shadow"==n){goog.asserts.fail("Shadow block cannot be a top-level block."),g=!1}else{if("variables"==n){if(g){Blockly.Xml.domToVariables(k,b)}else{throw Error("'variables' tag must exist once before block and shadow tag elements in the workspace XML, but it was found in another location.")}g=!1}}}}}finally{f||Blockly.Events.setGroup(!1),Blockly.Field.stopCache()}b.updateVariableStore(!1);b.setResizesEnabled&&b.setResizesEnabled(!0);return c};Blockly.Xml.appendDomToWorkspace=function(a,b){if(b.hasOwnProperty("scale")){var c=Blockly.BlockSvg.TAB_WIDTH;try{Blockly.BlockSvg.TAB_WIDTH=0;var d=b.getBlocksBoundingBox()}finally{Blockly.BlockSvg.TAB_WIDTH=c
-}}c=Blockly.Xml.domToWorkspace(a,b);if(d&&d.height){var e=d.y+d.height;var f=d.x;var g=Infinity,h=Infinity;for(d=0;d<c.length;d++){var k=b.getBlockById(c[d]).getRelativeToSurfaceXY();k.y<h&&(h=k.y);k.x<g&&(g=k.x)}e=e-h+Blockly.BlockSvg.SEP_SPACE_Y;f-=g;var n;b.RTL&&(n=b.getWidth());for(d=0;d<c.length;d++){b.getBlockById(c[d]).moveBy(b.RTL?n-f:f,e)}}return c};Blockly.Xml.domToBlock=function(a,b){if(a instanceof Blockly.Workspace){var c=a;a=b;b=c;console.warn("Deprecated call to Blockly.Xml.domToBlock, swap the arguments.")}Blockly.Events.disable();try{var d=Blockly.Xml.domToBlockHeadless_(a,b);if(b.rendered){d.setConnectionsHidden(!0);for(var e=d.getDescendants(),f=e.length-1;0<=f;f--){e[f].initSvg()}for(f=e.length-1;0<=f;f--){e[f].render(!1)}setTimeout(function(){d.workspace&&d.setConnectionsHidden(!1)},1);d.updateDisabled();b.resizeContents()}}finally{Blockly.Events.enable()}Blockly.Events.isEnabled()&&Blockly.Events.fire(new Blockly.Events.BlockCreate(d));return d};Blockly.Xml.domToVariables=function(a,b){for(var c=0,d;d=a.children[c];c++){var e=d.getAttribute("type"),f=d.getAttribute("id");d=d.textContent;if(null==e){throw Error("Variable with id, "+f+" is without a type")}b.createVariable(d,e,f)}};Blockly.Xml.domToBlockHeadless_=function(a,b){var c=null,d=a.getAttribute("type");goog.asserts.assert(d,"Block type unspecified: %s",a.outerHTML);var e=a.getAttribute("id");c=b.newBlock(d,e);for(var f=null,g=0,h;h=a.childNodes[g];g++){if(3!=h.nodeType){var k=null,n=null;f=0;for(var p;p=h.childNodes[f];f++){1==p.nodeType&&("block"==p.nodeName.toLowerCase()?k=p:"shadow"==p.nodeName.toLowerCase()&&(n=p))}!k&&n&&(k=n);f=h.getAttribute("name");switch(h.nodeName.toLowerCase()){case"mutation":c.domToMutation&&(c.domToMutation(h),c.initSvg&&c.initSvg());break;case"comment":c.setCommentText(h.textContent);var l=h.getAttribute("pinned");l&&!c.isInFlyout&&setTimeout(function(){c.comment&&c.comment.setVisible&&c.comment.setVisible("true"==l)},1);f=parseInt(h.getAttribute("w"),10);h=parseInt(h.getAttribute("h"),10);
-!isNaN(f)&&!isNaN(h)&&c.comment&&c.comment.setVisible&&c.comment.setBubbleSize(f,h);break;case"data":c.data=h.textContent;break;case"title":case"field":k=c.getField(f);n=h.textContent;if(k instanceof Blockly.FieldVariable){p=h.getAttribute("variabletype")||"";var m=b.getVariable(n);m||(m=b.createVariable(n,p,h.getAttribute(e)));if(null!=p&&p!==m.type){throw Error("Serialized variable type with id '"+m.getId()+"' had type "+m.type+", and does not match variable field that references it: "+Blockly.Xml.domToText(h)+".")}}if(!k){console.warn("Ignoring non-existent field "+f+" in block "+d);break}k.setValue(n);break;case"value":case"statement":h=c.getInput(f);if(!h){console.warn("Ignoring non-existent input "+f+" in block "+d);break}n&&h.connection.setShadowDom(n);k&&(f=Blockly.Xml.domToBlockHeadless_(k,b),f.outputConnection?h.connection.connect(f.outputConnection):f.previousConnection?h.connection.connect(f.previousConnection):goog.asserts.fail("Child block does not have output or previous statement."));break;case"next":n&&c.nextConnection&&c.nextConnection.setShadowDom(n);k&&(goog.asserts.assert(c.nextConnection,"Next statement does not exist."),goog.asserts.assert(!c.nextConnection.isConnected(),"Next statement is already connected."),f=Blockly.Xml.domToBlockHeadless_(k,b),goog.asserts.assert(f.previousConnection,"Next block does not have previous statement."),c.nextConnection.connect(f.previousConnection));break;default:console.warn("Ignoring unknown tag: "+h.nodeName)}}}(g=a.getAttribute("inline"))&&c.setInputsInline("true"==g);(g=a.getAttribute("disabled"))&&c.setDisabled("true"==g);(g=a.getAttribute("deletable"))&&c.setDeletable("true"==g);(g=a.getAttribute("movable"))&&c.setMovable("true"==g);(g=a.getAttribute("editable"))&&c.setEditable("true"==g);(g=a.getAttribute("collapsed"))&&c.setCollapsed("true"==g);if("shadow"==a.nodeName.toLowerCase()){d=c.getChildren();for(g=0;e=d[g];g++){goog.asserts.assert(e.isShadow(),"Shadow block not allowed non-shadow child.")}goog.asserts.assert(0==c.getVars().length,"Shadow blocks cannot have variable fields.");
-c.setShadow(!0)}return c};Blockly.Xml.deleteNext=function(a){for(var b=0,c;c=a.childNodes[b];b++){if("next"==c.nodeName.toLowerCase()){a.removeChild(c);break}}};goog.global.Blockly||(goog.global.Blockly={});goog.global.Blockly.Xml||(goog.global.Blockly.Xml={});goog.global.Blockly.Xml.domToText=Blockly.Xml.domToText;goog.global.Blockly.Xml.domToWorkspace=Blockly.Xml.domToWorkspace;goog.global.Blockly.Xml.textToDom=Blockly.Xml.textToDom;goog.global.Blockly.Xml.workspaceToDom=Blockly.Xml.workspaceToDom;Blockly.ZoomControls=function(a){this.workspace_=a};Blockly.ZoomControls.prototype.WIDTH_=32;Blockly.ZoomControls.prototype.HEIGHT_=110;Blockly.ZoomControls.prototype.MARGIN_BOTTOM_=20;Blockly.ZoomControls.prototype.MARGIN_SIDE_=20;Blockly.ZoomControls.prototype.svgGroup_=null;Blockly.ZoomControls.prototype.left_=0;Blockly.ZoomControls.prototype.top_=0;Blockly.ZoomControls.prototype.createDom=function(){var a=this.workspace_;this.svgGroup_=Blockly.utils.createSvgElement("g",{"class":"blocklyZoom"},null);var b=String(Math.random()).substring(2);var c=Blockly.utils.createSvgElement("clipPath",{id:"blocklyZoomoutClipPath"+b},this.svgGroup_);Blockly.utils.createSvgElement("rect",{width:32,height:32,y:77},c);var d=Blockly.utils.createSvgElement("image",{width:Blockly.SPRITE.width,height:Blockly.SPRITE.height,x:-64,y:-15,"clip-path":"url(#blocklyZoomoutClipPath"+b+")"},this.svgGroup_);d.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",a.options.pathToMedia+Blockly.SPRITE.url);c=Blockly.utils.createSvgElement("clipPath",{id:"blocklyZoominClipPath"+b},this.svgGroup_);Blockly.utils.createSvgElement("rect",{width:32,height:32,y:43},c);var e=Blockly.utils.createSvgElement("image",{width:Blockly.SPRITE.width,height:Blockly.SPRITE.height,x:-32,y:-49,"clip-path":"url(#blocklyZoominClipPath"+b+")"},this.svgGroup_);e.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",a.options.pathToMedia+Blockly.SPRITE.url);c=Blockly.utils.createSvgElement("clipPath",{id:"blocklyZoomresetClipPath"+b},this.svgGroup_);
-Blockly.utils.createSvgElement("rect",{width:32,height:32},c);c=Blockly.utils.createSvgElement("image",{width:Blockly.SPRITE.width,height:Blockly.SPRITE.height,y:-92,"clip-path":"url(#blocklyZoomresetClipPath"+b+")"},this.svgGroup_);c.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",a.options.pathToMedia+Blockly.SPRITE.url);Blockly.bindEventWithChecks_(c,"mousedown",null,function(b){a.markFocused();a.setScale(a.options.zoomOptions.startScale);a.scrollCenter();Blockly.Touch.clearTouchIdentifier();b.stopPropagation();b.preventDefault()});Blockly.bindEventWithChecks_(e,"mousedown",null,function(b){a.markFocused();a.zoomCenter(1);Blockly.Touch.clearTouchIdentifier();b.stopPropagation();b.preventDefault()});Blockly.bindEventWithChecks_(d,"mousedown",null,function(b){a.markFocused();a.zoomCenter(-1);Blockly.Touch.clearTouchIdentifier();b.stopPropagation();b.preventDefault()});return this.svgGroup_};Blockly.ZoomControls.prototype.init=function(a){this.bottom_=this.MARGIN_BOTTOM_+a;return this.bottom_+this.HEIGHT_};Blockly.ZoomControls.prototype.dispose=function(){this.svgGroup_&&(goog.dom.removeNode(this.svgGroup_),this.svgGroup_=null);this.workspace_=null};Blockly.ZoomControls.prototype.position=function(){var a=this.workspace_.getMetrics();a&&(this.workspace_.RTL?(this.left_=this.MARGIN_SIDE_+Blockly.Scrollbar.scrollbarThickness,a.toolboxPosition==Blockly.TOOLBOX_AT_LEFT&&(this.left_+=a.flyoutWidth,this.workspace_.toolbox_&&(this.left_+=a.absoluteLeft))):(this.left_=a.viewWidth+a.absoluteLeft-this.WIDTH_-this.MARGIN_SIDE_-Blockly.Scrollbar.scrollbarThickness,a.toolboxPosition==Blockly.TOOLBOX_AT_RIGHT&&(this.left_-=a.flyoutWidth)),this.top_=a.viewHeight+a.absoluteTop-this.HEIGHT_-this.bottom_,a.toolboxPosition==Blockly.TOOLBOX_AT_BOTTOM&&(this.top_-=a.flyoutHeight),this.svgGroup_.setAttribute("transform","translate("+this.left_+","+this.top_+")"))};Blockly.WorkspaceSvg=function(a,b,c){Blockly.WorkspaceSvg.superClass_.constructor.call(this,a);this.getMetrics=a.getMetrics||Blockly.WorkspaceSvg.getTopLevelWorkspaceMetrics_;
-this.setMetrics=a.setMetrics||Blockly.WorkspaceSvg.setTopLevelWorkspaceMetrics_;Blockly.ConnectionDB.init(this);b&&(this.blockDragSurface_=b);c&&(this.workspaceDragSurface_=c);this.useWorkspaceDragSurface_=this.workspaceDragSurface_&&Blockly.utils.is3dSupported();this.highlightedBlocks_=[];this.audioManager_=new Blockly.WorkspaceAudio(a.parentWorkspace);this.grid_=this.options.gridPattern?new Blockly.Grid(a.gridPattern,a.gridOptions):null;this.registerToolboxCategoryCallback(Blockly.VARIABLE_CATEGORY_NAME,Blockly.Variables.flyoutCategory);this.registerToolboxCategoryCallback(Blockly.PROCEDURE_CATEGORY_NAME,Blockly.Procedures.flyoutCategory)};goog.inherits(Blockly.WorkspaceSvg,Blockly.Workspace);Blockly.WorkspaceSvg.prototype.resizeHandlerWrapper_=null;Blockly.WorkspaceSvg.prototype.rendered=!0;Blockly.WorkspaceSvg.prototype.isFlyout=!1;Blockly.WorkspaceSvg.prototype.isMutator=!1;Blockly.WorkspaceSvg.prototype.resizesEnabled_=!0;Blockly.WorkspaceSvg.prototype.scrollX=0;Blockly.WorkspaceSvg.prototype.scrollY=0;Blockly.WorkspaceSvg.prototype.startScrollX=0;Blockly.WorkspaceSvg.prototype.startScrollY=0;Blockly.WorkspaceSvg.prototype.dragDeltaXY_=null;Blockly.WorkspaceSvg.prototype.scale=1;Blockly.WorkspaceSvg.prototype.trashcan=null;Blockly.WorkspaceSvg.prototype.scrollbar=null;Blockly.WorkspaceSvg.prototype.currentGesture_=null;Blockly.WorkspaceSvg.prototype.blockDragSurface_=null;Blockly.WorkspaceSvg.prototype.workspaceDragSurface_=null;Blockly.WorkspaceSvg.prototype.useWorkspaceDragSurface_=!1;Blockly.WorkspaceSvg.prototype.isDragSurfaceActive_=!1;Blockly.WorkspaceSvg.prototype.lastRecordedPageScroll_=null;Blockly.WorkspaceSvg.prototype.flyoutButtonCallbacks_={};Blockly.WorkspaceSvg.prototype.toolboxCategoryCallbacks_={};Blockly.WorkspaceSvg.prototype.inverseScreenCTM_=null;Blockly.WorkspaceSvg.prototype.getInverseScreenCTM=function(){return this.inverseScreenCTM_};Blockly.WorkspaceSvg.prototype.updateInverseScreenCTM=function(){var a=this.getParentSvg().getScreenCTM();
-a&&(this.inverseScreenCTM_=a.inverse())};Blockly.WorkspaceSvg.prototype.getSvgXY=function(a){var b=0,c=0,d=1;if(goog.dom.contains(this.getCanvas(),a)||goog.dom.contains(this.getBubbleCanvas(),a)){d=this.scale}do{var e=Blockly.utils.getRelativeXY(a);if(a==this.getCanvas()||a==this.getBubbleCanvas()){d=1}b+=e.x*d;c+=e.y*d;a=a.parentNode}while(a&&a!=this.getParentSvg());return new goog.math.Coordinate(b,c)};Blockly.WorkspaceSvg.prototype.getOriginOffsetInPixels=function(){return Blockly.utils.getInjectionDivXY_(this.svgBlockCanvas_)};Blockly.WorkspaceSvg.prototype.setResizeHandlerWrapper=function(a){this.resizeHandlerWrapper_=a};Blockly.WorkspaceSvg.prototype.createDom=function(a){this.svgGroup_=Blockly.utils.createSvgElement("g",{"class":"blocklyWorkspace"},null);a&&(this.svgBackground_=Blockly.utils.createSvgElement("rect",{height:"100%",width:"100%","class":a},this.svgGroup_),"blocklyMainBackground"==a&&this.grid_&&(this.svgBackground_.style.fill="url(#"+this.grid_.getPatternId()+")"));this.svgBlockCanvas_=Blockly.utils.createSvgElement("g",{"class":"blocklyBlockCanvas"},this.svgGroup_);this.svgBubbleCanvas_=Blockly.utils.createSvgElement("g",{"class":"blocklyBubbleCanvas"},this.svgGroup_);a=Blockly.Scrollbar.scrollbarThickness;this.options.hasTrashcan&&(a=this.addTrashcan_(a));this.options.zoomOptions&&this.options.zoomOptions.controls&&this.addZoomControls_(a);this.isFlyout||(Blockly.bindEventWithChecks_(this.svgGroup_,"mousedown",this,this.onMouseDown_),this.options.zoomOptions&&this.options.zoomOptions.wheel&&Blockly.bindEventWithChecks_(this.svgGroup_,"wheel",this,this.onMouseWheel_));this.options.hasCategories&&(this.toolbox_=new Blockly.Toolbox(this));this.grid_&&this.grid_.update(this.scale);this.recordDeleteAreas();return this.svgGroup_};Blockly.WorkspaceSvg.prototype.dispose=function(){this.rendered=!1;this.currentGesture_&&this.currentGesture_.cancel();Blockly.WorkspaceSvg.superClass_.dispose.call(this);this.svgGroup_&&(goog.dom.removeNode(this.svgGroup_),this.svgGroup_=null);
-this.svgBubbleCanvas_=this.svgBlockCanvas_=null;this.toolbox_&&(this.toolbox_.dispose(),this.toolbox_=null);this.flyout_&&(this.flyout_.dispose(),this.flyout_=null);this.trashcan&&(this.trashcan.dispose(),this.trashcan=null);this.scrollbar&&(this.scrollbar.dispose(),this.scrollbar=null);this.zoomControls_&&(this.zoomControls_.dispose(),this.zoomControls_=null);this.audioManager_&&(this.audioManager_.dispose(),this.audioManager_=null);this.grid_&&(this.grid_.dispose(),this.grid_=null);this.toolboxCategoryCallbacks_&&(this.toolboxCategoryCallbacks_=null);this.flyoutButtonCallbacks_&&(this.flyoutButtonCallbacks_=null);this.options.parentWorkspace||goog.dom.removeNode(this.getParentSvg().parentNode);this.resizeHandlerWrapper_&&(Blockly.unbindEvent_(this.resizeHandlerWrapper_),this.resizeHandlerWrapper_=null)};Blockly.WorkspaceSvg.prototype.newBlock=function(a,b){return new Blockly.BlockSvg(this,a,b)};Blockly.WorkspaceSvg.prototype.addTrashcan_=function(a){this.trashcan=new Blockly.Trashcan(this);var b=this.trashcan.createDom();this.svgGroup_.insertBefore(b,this.svgBlockCanvas_);return this.trashcan.init(a)};Blockly.WorkspaceSvg.prototype.addZoomControls_=function(a){this.zoomControls_=new Blockly.ZoomControls(this);var b=this.zoomControls_.createDom();this.svgGroup_.appendChild(b);return this.zoomControls_.init(a)};Blockly.WorkspaceSvg.prototype.addFlyout_=function(a){var b={disabledPatternId:this.options.disabledPatternId,parentWorkspace:this,RTL:this.RTL,oneBasedIndex:this.options.oneBasedIndex,horizontalLayout:this.horizontalLayout,toolboxPosition:this.options.toolboxPosition};this.flyout_=null;this.flyout_=this.horizontalLayout?new Blockly.HorizontalFlyout(b):new Blockly.VerticalFlyout(b);this.flyout_.autoClose=!1;return this.flyout_.createDom(a)};Blockly.WorkspaceSvg.prototype.getFlyout_=function(){return this.flyout_?this.flyout_:this.toolbox_?this.toolbox_.flyout_:null};Blockly.WorkspaceSvg.prototype.updateScreenCalculations_=function(){this.updateInverseScreenCTM();
-this.recordDeleteAreas()};Blockly.WorkspaceSvg.prototype.resizeContents=function(){this.resizesEnabled_&&this.rendered&&(this.scrollbar&&this.scrollbar.resize(),this.updateInverseScreenCTM())};Blockly.WorkspaceSvg.prototype.resize=function(){this.toolbox_&&this.toolbox_.position();this.flyout_&&this.flyout_.position();this.trashcan&&this.trashcan.position();this.zoomControls_&&this.zoomControls_.position();this.scrollbar&&this.scrollbar.resize();this.updateScreenCalculations_()};Blockly.WorkspaceSvg.prototype.updateScreenCalculationsIfScrolled=function(){var a=goog.dom.getDocumentScroll();goog.math.Coordinate.equals(this.lastRecordedPageScroll_,a)||(this.lastRecordedPageScroll_=a,this.updateScreenCalculations_())};Blockly.WorkspaceSvg.prototype.getCanvas=function(){return this.svgBlockCanvas_};Blockly.WorkspaceSvg.prototype.getBubbleCanvas=function(){return this.svgBubbleCanvas_};Blockly.WorkspaceSvg.prototype.getParentSvg=function(){if(this.cachedParentSvg_){return this.cachedParentSvg_}for(var a=this.svgGroup_;a;){if("svg"==a.tagName){return this.cachedParentSvg_=a}a=a.parentNode}return null};Blockly.WorkspaceSvg.prototype.translate=function(a,b){if(this.useWorkspaceDragSurface_&&this.isDragSurfaceActive_){this.workspaceDragSurface_.translateSurface(a,b)}else{var c="translate("+a+","+b+") scale("+this.scale+")";this.svgBlockCanvas_.setAttribute("transform",c);this.svgBubbleCanvas_.setAttribute("transform",c)}this.blockDragSurface_&&this.blockDragSurface_.translateAndScaleGroup(a,b,this.scale)};Blockly.WorkspaceSvg.prototype.resetDragSurface=function(){if(this.useWorkspaceDragSurface_){this.isDragSurfaceActive_=!1;var a=this.workspaceDragSurface_.getSurfaceTranslation();this.workspaceDragSurface_.clearAndHide(this.svgGroup_);a="translate("+a.x+","+a.y+") scale("+this.scale+")";this.svgBlockCanvas_.setAttribute("transform",a);this.svgBubbleCanvas_.setAttribute("transform",a)}};Blockly.WorkspaceSvg.prototype.setupDragSurface=function(){if(this.useWorkspaceDragSurface_&&!this.isDragSurfaceActive_){this.isDragSurfaceActive_=!0;
-var a=this.svgBlockCanvas_.previousSibling,b=this.getParentSvg().getAttribute("width"),c=this.getParentSvg().getAttribute("height"),d=Blockly.utils.getRelativeXY(this.svgBlockCanvas_);this.workspaceDragSurface_.setContentsAndShow(this.svgBlockCanvas_,this.svgBubbleCanvas_,a,b,c,this.scale);this.workspaceDragSurface_.translateSurface(d.x,d.y)}};Blockly.WorkspaceSvg.prototype.getWidth=function(){var a=this.getMetrics();return a?a.viewWidth/this.scale:0};Blockly.WorkspaceSvg.prototype.setVisible=function(a){this.scrollbar&&this.scrollbar.setContainerVisible(a);this.getFlyout_()&&this.getFlyout_().setContainerVisible(a);this.getParentSvg().style.display=a?"block":"none";this.toolbox_&&(this.toolbox_.HtmlDiv.style.display=a?"block":"none");a?(this.render(),this.toolbox_&&this.toolbox_.position()):Blockly.hideChaff(!0)};Blockly.WorkspaceSvg.prototype.render=function(){for(var a=this.getAllBlocks(),b=a.length-1;0<=b;b--){a[b].render(!1)}};Blockly.WorkspaceSvg.prototype.traceOn=function(){console.warn("Deprecated call to traceOn, delete this.")};Blockly.WorkspaceSvg.prototype.highlightBlock=function(a,b){if(void 0===b){for(var c=0,d;d=this.highlightedBlocks_[c];c++){d.setHighlighted(!1)}this.highlightedBlocks_.length=0}if(d=a?this.getBlockById(a):null){(c=void 0===b||b)?-1==this.highlightedBlocks_.indexOf(d)&&this.highlightedBlocks_.push(d):goog.array.remove(this.highlightedBlocks_,d),d.setHighlighted(c)}};Blockly.WorkspaceSvg.prototype.paste=function(a){if(this.rendered&&!(a.getElementsByTagName("block").length>=this.remainingCapacity())){this.currentGesture_&&this.currentGesture_.cancel();Blockly.Events.disable();try{var b=Blockly.Xml.domToBlock(a,this),c=parseInt(a.getAttribute("x"),10),d=parseInt(a.getAttribute("y"),10);if(!isNaN(c)&&!isNaN(d)){this.RTL&&(c=-c);do{a=!1;for(var e=this.getAllBlocks(),f=0,g;g=e[f];f++){var h=g.getRelativeToSurfaceXY();if(1>=Math.abs(c-h.x)&&1>=Math.abs(d-h.y)){a=!0;break}}if(!a){var k=b.getConnections_(!1);f=0;for(var n;n=k[f];f++){if(n.closest(Blockly.SNAP_RADIUS,new goog.math.Coordinate(c,d)).connection){a=!0;
-break}}}a&&(c=this.RTL?c-Blockly.SNAP_RADIUS:c+Blockly.SNAP_RADIUS,d+=2*Blockly.SNAP_RADIUS)}while(a);b.moveBy(c,d)}}finally{Blockly.Events.enable()}Blockly.Events.isEnabled()&&!b.isShadow()&&Blockly.Events.fire(new Blockly.Events.BlockCreate(b));b.select()}};Blockly.WorkspaceSvg.prototype.refreshToolboxSelection_=function(){this.toolbox_&&this.toolbox_.flyout_&&!this.currentGesture_&&this.toolbox_.refreshSelection()};Blockly.WorkspaceSvg.prototype.renameVariable=function(a,b){Blockly.WorkspaceSvg.superClass_.renameVariable.call(this,a,b);this.refreshToolboxSelection_()};Blockly.WorkspaceSvg.prototype.renameVariableById=function(a,b){Blockly.WorkspaceSvg.superClass_.renameVariableById.call(this,a,b);this.refreshToolboxSelection_()};Blockly.WorkspaceSvg.prototype.deleteVariable=function(a){Blockly.WorkspaceSvg.superClass_.deleteVariable.call(this,a);this.refreshToolboxSelection_()};Blockly.WorkspaceSvg.prototype.deleteVariableById=function(a){Blockly.WorkspaceSvg.superClass_.deleteVariableById.call(this,a);this.refreshToolboxSelection_()};Blockly.WorkspaceSvg.prototype.createVariable=function(a,b,c){a=Blockly.WorkspaceSvg.superClass_.createVariable.call(this,a,b,c);this.refreshToolboxSelection_();return a};Blockly.WorkspaceSvg.prototype.recordDeleteAreas=function(){this.deleteAreaTrash_=this.trashcan?this.trashcan.getClientRect():null;this.deleteAreaToolbox_=this.flyout_?this.flyout_.getClientRect():this.toolbox_?this.toolbox_.getClientRect():null};Blockly.WorkspaceSvg.prototype.isDeleteArea=function(a){a=new goog.math.Coordinate(a.clientX,a.clientY);return this.deleteAreaTrash_&&this.deleteAreaTrash_.contains(a)?Blockly.DELETE_AREA_TRASH:this.deleteAreaToolbox_&&this.deleteAreaToolbox_.contains(a)?Blockly.DELETE_AREA_TOOLBOX:Blockly.DELETE_AREA_NONE};Blockly.WorkspaceSvg.prototype.onMouseDown_=function(a){var b=this.getGesture(a);b&&b.handleWsStart(a,this)};Blockly.WorkspaceSvg.prototype.startDrag=function(a,b){var c=Blockly.utils.mouseToSvg(a,this.getParentSvg(),this.getInverseScreenCTM());
-c.x/=this.scale;c.y/=this.scale;this.dragDeltaXY_=goog.math.Coordinate.difference(b,c)};Blockly.WorkspaceSvg.prototype.moveDrag=function(a){a=Blockly.utils.mouseToSvg(a,this.getParentSvg(),this.getInverseScreenCTM());a.x/=this.scale;a.y/=this.scale;return goog.math.Coordinate.sum(this.dragDeltaXY_,a)};Blockly.WorkspaceSvg.prototype.isDragging=function(){return null!=this.currentGesture_&&this.currentGesture_.isDragging()};Blockly.WorkspaceSvg.prototype.isDraggable=function(){return !!this.scrollbar};Blockly.WorkspaceSvg.prototype.onMouseWheel_=function(a){this.currentGesture_&&this.currentGesture_.cancel();var b=-a.deltaY/50,c=Blockly.utils.mouseToSvg(a,this.getParentSvg(),this.getInverseScreenCTM());this.zoom(c.x,c.y,b);a.preventDefault()};Blockly.WorkspaceSvg.prototype.getBlocksBoundingBox=function(){var a=this.getTopBlocks(!1);if(!a.length){return{x:0,y:0,width:0,height:0}}for(var b=a[0].getBoundingRectangle(),c=1;c<a.length;c++){var d=a[c].getBoundingRectangle();d.topLeft.x<b.topLeft.x&&(b.topLeft.x=d.topLeft.x);d.bottomRight.x>b.bottomRight.x&&(b.bottomRight.x=d.bottomRight.x);d.topLeft.y<b.topLeft.y&&(b.topLeft.y=d.topLeft.y);d.bottomRight.y>b.bottomRight.y&&(b.bottomRight.y=d.bottomRight.y)}return{x:b.topLeft.x,y:b.topLeft.y,width:b.bottomRight.x-b.topLeft.x,height:b.bottomRight.y-b.topLeft.y}};Blockly.WorkspaceSvg.prototype.cleanUp=function(){this.setResizesEnabled(!1);Blockly.Events.setGroup(!0);for(var a=this.getTopBlocks(!0),b=0,c=0,d;d=a[c];c++){var e=d.getRelativeToSurfaceXY();d.moveBy(-e.x,b-e.y);d.snapToGrid();b=d.getRelativeToSurfaceXY().y+d.getHeightWidth().height+Blockly.BlockSvg.MIN_BLOCK_Y}Blockly.Events.setGroup(!1);this.setResizesEnabled(!0)};Blockly.WorkspaceSvg.prototype.showContextMenu_=function(a){function b(a){if(a.isDeletable()){m=m.concat(a.getDescendants())}else{a=a.getChildren();for(var c=0;c<a.length;c++){b(a[c])}}}function c(){Blockly.Events.setGroup(f);var a=m.shift();a&&(a.workspace?(a.dispose(!1,!0),setTimeout(c,10)):c());Blockly.Events.setGroup(!1)
-}if(!this.options.readOnly&&!this.isFlyout){var d=[],e=this.getTopBlocks(!0),f=Blockly.utils.genUid(),g=this,h={};h.text=Blockly.Msg.UNDO;h.enabled=0<this.undoStack_.length;h.callback=this.undo.bind(this,!1);d.push(h);h={};h.text=Blockly.Msg.REDO;h.enabled=0<this.redoStack_.length;h.callback=this.undo.bind(this,!0);d.push(h);this.scrollbar&&(h={},h.text=Blockly.Msg.CLEAN_UP,h.enabled=1<e.length,h.callback=this.cleanUp.bind(this),d.push(h));if(this.options.collapse){for(var k=h=!1,n=0;n<e.length;n++){for(var p=e[n];p;){p.isCollapsed()?h=!0:k=!0,p=p.getNextBlock()}}var l=function(a){for(var b=0,c=0;c<e.length;c++){for(var d=e[c];d;){setTimeout(d.setCollapsed.bind(d,a),b),d=d.getNextBlock(),b+=10}}};k={enabled:k};k.text=Blockly.Msg.COLLAPSE_ALL;k.callback=function(){l(!0)};d.push(k);h={enabled:h};h.text=Blockly.Msg.EXPAND_ALL;h.callback=function(){l(!1)};d.push(h)}var m=[];for(n=0;n<e.length;n++){b(e[n])}h={text:1==m.length?Blockly.Msg.DELETE_BLOCK:Blockly.Msg.DELETE_X_BLOCKS.replace("%1",String(m.length)),enabled:0<m.length,callback:function(){g.currentGesture_&&g.currentGesture_.cancel();2>m.length?c():Blockly.confirm(Blockly.Msg.DELETE_ALL_BLOCKS.replace("%1",m.length),function(a){a&&c()})}};d.push(h);Blockly.ContextMenu.show(a,d,this.RTL)}};Blockly.WorkspaceSvg.prototype.updateToolbox=function(a){if(a=Blockly.Options.parseToolboxTree(a)){if(!this.options.languageTree){throw"Existing toolbox is null.  Can't create new toolbox."}if(a.getElementsByTagName("category").length){if(!this.toolbox_){throw"Existing toolbox has no categories.  Can't change mode."}this.options.languageTree=a;this.toolbox_.populate_(a);this.toolbox_.addColour_()}else{if(!this.flyout_){throw"Existing toolbox has categories.  Can't change mode."}this.options.languageTree=a;this.flyout_.show(a.childNodes)}}else{if(this.options.languageTree){throw"Can't nullify an existing toolbox."}}};Blockly.WorkspaceSvg.prototype.markFocused=function(){this.options.parentWorkspace?this.options.parentWorkspace.markFocused():(Blockly.mainWorkspace=this,this.setBrowserFocus())
-};Blockly.WorkspaceSvg.prototype.setBrowserFocus=function(){document.activeElement&&document.activeElement.blur();try{this.getParentSvg().focus()}catch(a){try{this.getParentSvg().parentNode.setActive()}catch(b){this.getParentSvg().parentNode.focus()}}};Blockly.WorkspaceSvg.prototype.zoom=function(a,b,c){var d=this.options.zoomOptions.scaleSpeed,e=this.getMetrics(),f=this.getParentSvg().createSVGPoint();f.x=a;f.y=b;f=f.matrixTransform(this.getCanvas().getCTM().inverse());a=f.x;b=f.y;f=this.getCanvas();d=Math.pow(d,c);c=this.scale*d;c>this.options.zoomOptions.maxScale?d=this.options.zoomOptions.maxScale/this.scale:c<this.options.zoomOptions.minScale&&(d=this.options.zoomOptions.minScale/this.scale);this.scale!=c&&(this.scrollbar&&(a=f.getCTM().translate(a*(1-d),b*(1-d)).scale(d),this.scrollX=a.e-e.absoluteLeft,this.scrollY=a.f-e.absoluteTop),this.setScale(c))};Blockly.WorkspaceSvg.prototype.zoomCenter=function(a){var b=this.getMetrics();this.zoom(b.viewWidth/2,b.viewHeight/2,a)};Blockly.WorkspaceSvg.prototype.zoomToFit=function(){var a=this.getMetrics(),b=this.getBlocksBoundingBox(),c=b.width;b=b.height;if(c){var d=a.viewWidth,e=a.viewHeight;this.flyout_&&(d-=this.flyout_.width_);this.scrollbar||(c+=a.contentLeft,b+=a.contentTop);this.setScale(Math.min(d/c,e/b));this.scrollCenter()}};Blockly.WorkspaceSvg.prototype.scrollCenter=function(){if(this.scrollbar){var a=this.getMetrics(),b=(a.contentWidth-a.viewWidth)/2;this.flyout_&&(b-=this.flyout_.width_/2);this.scrollbar.set(b,(a.contentHeight-a.viewHeight)/2)}};Blockly.WorkspaceSvg.prototype.setScale=function(a){this.options.zoomOptions.maxScale&&a>this.options.zoomOptions.maxScale?a=this.options.zoomOptions.maxScale:this.options.zoomOptions.minScale&&a<this.options.zoomOptions.minScale&&(a=this.options.zoomOptions.minScale);this.scale=a;this.grid_&&this.grid_.update(this.scale);this.scrollbar?this.scrollbar.resize():this.translate(this.scrollX,this.scrollY);Blockly.hideChaff(!1);this.flyout_&&this.flyout_.reflow()};Blockly.WorkspaceSvg.getDimensionsPx_=function(a){var b=0,c=0;
-a&&(b=a.getWidth(),c=a.getHeight());return{width:b,height:c}};Blockly.WorkspaceSvg.getContentDimensions_=function(a,b){return a.scrollbar?Blockly.WorkspaceSvg.getContentDimensionsBounded_(a,b):Blockly.WorkspaceSvg.getContentDimensionsExact_(a)};Blockly.WorkspaceSvg.getContentDimensionsExact_=function(a){var b=a.getBlocksBoundingBox(),c=a.scale;a=b.width*c;var d=b.height*c,e=b.x*c;b=b.y*c;return{left:e,top:b,right:e+a,bottom:b+d,width:a,height:d}};Blockly.WorkspaceSvg.getContentDimensionsBounded_=function(a,b){var c=Blockly.WorkspaceSvg.getContentDimensionsExact_(a),d=b.width,e=b.height,f=d/2,g=e/2,h=Math.min(c.left-f,c.right-d),k=Math.min(c.top-g,c.bottom-e);return{left:h,top:k,height:Math.max(c.bottom+g,c.top+e)-k,width:Math.max(c.right+f,c.left+d)-h}};Blockly.WorkspaceSvg.getTopLevelWorkspaceMetrics_=function(){var a=Blockly.WorkspaceSvg.getDimensionsPx_(this.toolbox_),b=Blockly.WorkspaceSvg.getDimensionsPx_(this.flyout_),c=Blockly.svgSize(this.getParentSvg());if(this.toolbox_){if(this.toolboxPosition==Blockly.TOOLBOX_AT_TOP||this.toolboxPosition==Blockly.TOOLBOX_AT_BOTTOM){c.height-=a.height}else{if(this.toolboxPosition==Blockly.TOOLBOX_AT_LEFT||this.toolboxPosition==Blockly.TOOLBOX_AT_RIGHT){c.width-=a.width}}}var d=Blockly.WorkspaceSvg.getContentDimensions_(this,c),e=0;this.toolbox_&&this.toolboxPosition==Blockly.TOOLBOX_AT_LEFT&&(e=a.width);var f=0;this.toolbox_&&this.toolboxPosition==Blockly.TOOLBOX_AT_TOP&&(f=a.height);return{contentHeight:d.height,contentWidth:d.width,contentTop:d.top,contentLeft:d.left,viewHeight:c.height,viewWidth:c.width,viewTop:-this.scrollY,viewLeft:-this.scrollX,absoluteTop:f,absoluteLeft:e,toolboxWidth:a.width,toolboxHeight:a.height,flyoutWidth:b.width,flyoutHeight:b.height,toolboxPosition:this.toolboxPosition}};Blockly.WorkspaceSvg.setTopLevelWorkspaceMetrics_=function(a){if(!this.scrollbar){throw"Attempt to set top level workspace scroll without scrollbars."}var b=this.getMetrics();goog.isNumber(a.x)&&(this.scrollX=-b.contentWidth*a.x-b.contentLeft);
-goog.isNumber(a.y)&&(this.scrollY=-b.contentHeight*a.y-b.contentTop);a=this.scrollX+b.absoluteLeft;b=this.scrollY+b.absoluteTop;this.translate(a,b);this.grid_&&this.grid_.moveTo(a,b)};Blockly.WorkspaceSvg.prototype.setResizesEnabled=function(a){var b=!this.resizesEnabled_&&a;this.resizesEnabled_=a;b&&this.resizeContents()};Blockly.WorkspaceSvg.prototype.clear=function(){this.setResizesEnabled(!1);Blockly.WorkspaceSvg.superClass_.clear.call(this);this.setResizesEnabled(!0)};Blockly.WorkspaceSvg.prototype.registerButtonCallback=function(a,b){goog.asserts.assert(goog.isFunction(b),"Button callbacks must be functions.");this.flyoutButtonCallbacks_[a]=b};Blockly.WorkspaceSvg.prototype.getButtonCallback=function(a){return(a=this.flyoutButtonCallbacks_[a])?a:null};Blockly.WorkspaceSvg.prototype.removeButtonCallback=function(a){this.flyoutButtonCallbacks_[a]=null};Blockly.WorkspaceSvg.prototype.registerToolboxCategoryCallback=function(a,b){goog.asserts.assert(goog.isFunction(b),"Toolbox category callbacks must be functions.");this.toolboxCategoryCallbacks_[a]=b};Blockly.WorkspaceSvg.prototype.getToolboxCategoryCallback=function(a){return(a=this.toolboxCategoryCallbacks_[a])?a:null};Blockly.WorkspaceSvg.prototype.removeToolboxCategoryCallback=function(a){this.toolboxCategoryCallbacks_[a]=null};Blockly.WorkspaceSvg.prototype.getGesture=function(a){var b="mousedown"==a.type||"touchstart"==a.type,c=this.currentGesture_;return c?b&&c.hasStarted()?(console.warn("tried to start the same gesture twice"),c.cancel(),null):c:b?this.currentGesture_=new Blockly.Gesture(a,this):null};Blockly.WorkspaceSvg.prototype.clearGesture=function(){this.currentGesture_=null};Blockly.WorkspaceSvg.prototype.cancelCurrentGesture=function(){this.currentGesture_&&this.currentGesture_.cancel()};Blockly.WorkspaceSvg.prototype.getAudioManager=function(){return this.audioManager_};Blockly.WorkspaceSvg.prototype.getGrid=function(){return this.grid_};Blockly.WorkspaceSvg.prototype.setVisible=Blockly.WorkspaceSvg.prototype.setVisible;
-Blockly.Mutator=function(a){Blockly.Mutator.superClass_.constructor.call(this,null);this.quarkNames_=a};goog.inherits(Blockly.Mutator,Blockly.Icon);Blockly.Mutator.prototype.workspaceWidth_=0;Blockly.Mutator.prototype.workspaceHeight_=0;Blockly.Mutator.prototype.drawIcon_=function(a){Blockly.utils.createSvgElement("rect",{"class":"blocklyIconShape",rx:"4",ry:"4",height:"16",width:"16"},a);Blockly.utils.createSvgElement("path",{"class":"blocklyIconSymbol",d:"m4.203,7.296 0,1.368 -0.92,0.677 -0.11,0.41 0.9,1.559 0.41,0.11 1.043,-0.457 1.187,0.683 0.127,1.134 0.3,0.3 1.8,0 0.3,-0.299 0.127,-1.138 1.185,-0.682 1.046,0.458 0.409,-0.11 0.9,-1.559 -0.11,-0.41 -0.92,-0.677 0,-1.366 0.92,-0.677 0.11,-0.41 -0.9,-1.559 -0.409,-0.109 -1.046,0.458 -1.185,-0.682 -0.127,-1.138 -0.3,-0.299 -1.8,0 -0.3,0.3 -0.126,1.135 -1.187,0.682 -1.043,-0.457 -0.41,0.11 -0.899,1.559 0.108,0.409z"},a);Blockly.utils.createSvgElement("circle",{"class":"blocklyIconShape",r:"2.7",cx:"8",cy:"8"},a)};Blockly.Mutator.prototype.iconClick_=function(a){this.block_.isEditable()&&Blockly.Icon.prototype.iconClick_.call(this,a)};Blockly.Mutator.prototype.createEditor_=function(){this.svgDialog_=Blockly.utils.createSvgElement("svg",{x:Blockly.Bubble.BORDER_WIDTH,y:Blockly.Bubble.BORDER_WIDTH},null);if(this.quarkNames_.length){for(var a=goog.dom.createDom("xml"),b=0,c;c=this.quarkNames_[b];b++){a.appendChild(goog.dom.createDom("block",{type:c}))}}else{a=null}a={languageTree:a,parentWorkspace:this.block_.workspace,pathToMedia:this.block_.workspace.options.pathToMedia,RTL:this.block_.RTL,toolboxPosition:this.block_.RTL?Blockly.TOOLBOX_AT_RIGHT:Blockly.TOOLBOX_AT_LEFT,horizontalLayout:!1,getMetrics:this.getFlyoutMetrics_.bind(this),setMetrics:null};this.workspace_=new Blockly.WorkspaceSvg(a);this.workspace_.isMutator=!0;a=this.workspace_.addFlyout_("g");b=this.workspace_.createDom("blocklyMutatorBackground");b.insertBefore(a,this.workspace_.svgBlockCanvas_);this.svgDialog_.appendChild(b);return this.svgDialog_};Blockly.Mutator.prototype.updateEditable=function(){this.block_.isInFlyout||(this.block_.isEditable()?this.iconGroup_&&Blockly.utils.removeClass(this.iconGroup_,"blocklyIconGroupReadonly"):(this.setVisible(!1),this.iconGroup_&&Blockly.utils.addClass(this.iconGroup_,"blocklyIconGroupReadonly")));
-Blockly.Icon.prototype.updateEditable.call(this)};Blockly.Mutator.prototype.resizeBubble_=function(){var a=2*Blockly.Bubble.BORDER_WIDTH,b=this.workspace_.getCanvas().getBBox();var c=this.block_.RTL?-b.x:b.width+b.x;b=b.height+3*a;if(this.workspace_.flyout_){var d=this.workspace_.flyout_.getMetrics_();b=Math.max(b,d.contentHeight+20)}c+=3*a;if(Math.abs(this.workspaceWidth_-c)>a||Math.abs(this.workspaceHeight_-b)>a){this.workspaceWidth_=c,this.workspaceHeight_=b,this.bubble_.setBubbleSize(c+a,b+a),this.svgDialog_.setAttribute("width",this.workspaceWidth_),this.svgDialog_.setAttribute("height",this.workspaceHeight_)}this.block_.RTL&&(a="translate("+this.workspaceWidth_+",0)",this.workspace_.getCanvas().setAttribute("transform",a));this.workspace_.resize()};Blockly.Mutator.prototype.setVisible=function(a){if(a!=this.isVisible()){if(Blockly.Events.fire(new Blockly.Events.Ui(this.block_,"mutatorOpen",!a,a)),a){this.bubble_=new Blockly.Bubble(this.block_.workspace,this.createEditor_(),this.block_.svgPath_,this.iconXY_,null,null);if(a=this.workspace_.options.languageTree){this.workspace_.flyout_.init(this.workspace_),this.workspace_.flyout_.show(a.childNodes)}this.rootBlock_=this.block_.decompose(this.workspace_);a=this.rootBlock_.getDescendants();for(var b=0,c;c=a[b];b++){c.render()}this.rootBlock_.setMovable(!1);this.rootBlock_.setDeletable(!1);this.workspace_.flyout_?(a=2*this.workspace_.flyout_.CORNER_RADIUS,b=this.workspace_.flyout_.width_+a):b=a=16;this.block_.RTL&&(b=-b);this.rootBlock_.moveBy(b,a);if(this.block_.saveConnections){var d=this;this.block_.saveConnections(this.rootBlock_);this.sourceListener_=function(){d.block_.saveConnections(d.rootBlock_)};this.block_.workspace.addChangeListener(this.sourceListener_)}this.resizeBubble_();this.workspace_.addChangeListener(this.workspaceChanged_.bind(this));this.updateColour()}else{this.svgDialog_=null,this.workspace_.dispose(),this.rootBlock_=this.workspace_=null,this.bubble_.dispose(),this.bubble_=null,this.workspaceHeight_=this.workspaceWidth_=0,this.sourceListener_&&(this.block_.workspace.removeChangeListener(this.sourceListener_),this.sourceListener_=null)
-}}};Blockly.Mutator.prototype.workspaceChanged_=function(){if(!this.workspace_.isDragging()){for(var a=this.workspace_.getTopBlocks(!1),b=0,c;c=a[b];b++){var d=c.getRelativeToSurfaceXY(),e=c.getHeightWidth();20>d.y+e.height&&c.moveBy(0,20-e.height-d.y)}}if(this.rootBlock_.workspace==this.workspace_){Blockly.Events.setGroup(!0);c=this.block_;a=(a=c.mutationToDom())&&Blockly.Xml.domToText(a);b=c.rendered;c.rendered=!1;c.compose(this.rootBlock_);c.rendered=b;c.initSvg();b=(b=c.mutationToDom())&&Blockly.Xml.domToText(b);if(a!=b){Blockly.Events.fire(new Blockly.Events.BlockChange(c,"mutation",null,a,b));var f=Blockly.Events.getGroup();setTimeout(function(){Blockly.Events.setGroup(f);c.bumpNeighbours_();Blockly.Events.setGroup(!1)},Blockly.BUMP_DELAY)}c.rendered&&c.render();this.workspace_.isDragging()||this.resizeBubble_();Blockly.Events.setGroup(!1)}};Blockly.Mutator.prototype.getFlyoutMetrics_=function(){return{viewHeight:this.workspaceHeight_,viewWidth:this.workspaceWidth_,absoluteTop:0,absoluteLeft:0}};Blockly.Mutator.prototype.dispose=function(){this.block_.mutator=null;Blockly.Icon.prototype.dispose.call(this)};Blockly.Mutator.reconnect=function(a,b,c){if(!a||!a.getSourceBlock().workspace){return !1}c=b.getInput(c).connection;var d=a.targetBlock();return d&&d!=b||c.targetConnection==a?!1:(c.isConnected()&&c.disconnect(),c.connect(a),!0)};goog.global.Blockly||(goog.global.Blockly={});goog.global.Blockly.Mutator||(goog.global.Blockly.Mutator={});goog.global.Blockly.Mutator.reconnect=Blockly.Mutator.reconnect;Blockly.Warning=function(a){Blockly.Warning.superClass_.constructor.call(this,a);this.createIcon();this.text_={}};goog.inherits(Blockly.Warning,Blockly.Icon);Blockly.Warning.prototype.collapseHidden=!1;Blockly.Warning.prototype.drawIcon_=function(a){Blockly.utils.createSvgElement("path",{"class":"blocklyIconShape",d:"M2,15Q-1,15 0.5,12L6.5,1.7Q8,-1 9.5,1.7L15.5,12Q17,15 14,15z"},a);Blockly.utils.createSvgElement("path",{"class":"blocklyIconSymbol",d:"m7,4.8v3.16l0.27,2.27h1.46l0.27,-2.27v-3.16z"},a);
-Blockly.utils.createSvgElement("rect",{"class":"blocklyIconSymbol",x:"7",y:"11",height:"2",width:"2"},a)};Blockly.Warning.textToDom_=function(a){var b=Blockly.utils.createSvgElement("text",{"class":"blocklyText blocklyBubbleText",y:Blockly.Bubble.BORDER_WIDTH},null);a=a.split("\n");for(var c=0;c<a.length;c++){var d=Blockly.utils.createSvgElement("tspan",{dy:"1em",x:Blockly.Bubble.BORDER_WIDTH},b),e=document.createTextNode(a[c]);d.appendChild(e)}return b};Blockly.Warning.prototype.setVisible=function(a){if(a!=this.isVisible()){if(Blockly.Events.fire(new Blockly.Events.Ui(this.block_,"warningOpen",!a,a)),a){a=Blockly.Warning.textToDom_(this.getText());this.bubble_=new Blockly.Bubble(this.block_.workspace,a,this.block_.svgPath_,this.iconXY_,null,null);if(this.block_.RTL){for(var b=a.getBBox().width,c=0,d;d=a.childNodes[c];c++){d.setAttribute("text-anchor","end"),d.setAttribute("x",b+Blockly.Bubble.BORDER_WIDTH)}}this.updateColour();a=this.bubble_.getBubbleSize();this.bubble_.setBubbleSize(a.width,a.height)}else{this.bubble_.dispose(),this.body_=this.bubble_=null}}};Blockly.Warning.prototype.bodyFocus_=function(a){this.bubble_.promote_()};Blockly.Warning.prototype.setText=function(a,b){this.text_[b]!=a&&(a?this.text_[b]=a:delete this.text_[b],this.isVisible()&&(this.setVisible(!1),this.setVisible(!0)))};Blockly.Warning.prototype.getText=function(){var a=[],b;for(b in this.text_){a.push(this.text_[b])}return a.join("\n")};Blockly.Warning.prototype.dispose=function(){this.block_.warning=null;Blockly.Icon.prototype.dispose.call(this)};Blockly.Block=function(a,b,c){this.id=c&&!a.getBlockById(c)?c:Blockly.utils.genUid();a.blockDB_[this.id]=this;this.previousConnection=this.nextConnection=this.outputConnection=null;this.inputList=[];this.inputsInline=void 0;this.disabled=!1;this.tooltip="";this.contextMenu=!0;this.parentBlock_=null;this.childBlocks_=[];this.editable_=this.movable_=this.deletable_=!0;this.collapsed_=this.isShadow_=!1;this.comment=null;this.xy_=new goog.math.Coordinate(0,0);
-this.workspace=a;this.isInFlyout=a.isFlyout;this.isInMutator=a.isMutator;this.RTL=a.RTL;b&&(this.type=b,c=Blockly.Blocks[b],goog.asserts.assertObject(c,'Error: Unknown block type "%s".',b),goog.mixin(this,c));a.addTopBlock(this);goog.isFunction(this.init)&&this.init();this.inputsInlineDefault=this.inputsInline;Blockly.Events.isEnabled()&&Blockly.Events.fire(new Blockly.Events.BlockCreate(this));goog.isFunction(this.onchange)&&this.setOnChange(this.onchange)};Blockly.Block.obtain=function(a,b){console.warn("Deprecated call to Blockly.Block.obtain, use workspace.newBlock instead.");return a.newBlock(b)};Blockly.Block.prototype.data=null;Blockly.Block.prototype.colour_="#000000";Blockly.Block.prototype.hue_=null;Blockly.Block.prototype.dispose=function(a){if(this.workspace){this.onchangeWrapper_&&this.workspace.removeChangeListener(this.onchangeWrapper_);this.unplug(a);Blockly.Events.isEnabled()&&Blockly.Events.fire(new Blockly.Events.BlockDelete(this));Blockly.Events.disable();try{this.workspace&&(this.workspace.removeTopBlock(this),delete this.workspace.blockDB_[this.id],this.workspace=null);for(var b=this.childBlocks_.length-1;0<=b;b--){this.childBlocks_[b].dispose(!1)}b=0;for(var c;c=this.inputList[b];b++){c.dispose()}this.inputList.length=0;var d=this.getConnections_(!0);for(b=0;b<d.length;b++){var e=d[b];e.isConnected()&&e.disconnect();d[b].dispose()}}finally{Blockly.Events.enable()}}};Blockly.Block.prototype.unplug=function(a){if(this.outputConnection){this.outputConnection.isConnected()&&this.outputConnection.disconnect()}else{if(this.previousConnection){var b=null;this.previousConnection.isConnected()&&(b=this.previousConnection.targetConnection,this.previousConnection.disconnect());var c=this.getNextBlock();a&&c&&(a=this.nextConnection.targetConnection,a.disconnect(),b&&b.checkType_(a)&&b.connect(a))}}};Blockly.Block.prototype.getConnections_=function(a){a=[];this.outputConnection&&a.push(this.outputConnection);this.previousConnection&&a.push(this.previousConnection);
-this.nextConnection&&a.push(this.nextConnection);for(var b=0,c;c=this.inputList[b];b++){c.connection&&a.push(c.connection)}return a};Blockly.Block.prototype.lastConnectionInStack_=function(){for(var a=this.nextConnection;a;){var b=a.targetBlock();if(!b){return a}a=b.nextConnection}return null};Blockly.Block.prototype.bumpNeighbours_=function(){console.warn("Not expected to reach this bumpNeighbours_ function. The BlockSvg function for bumpNeighbours_ was expected to be called instead.")};Blockly.Block.prototype.getParent=function(){return this.parentBlock_};Blockly.Block.prototype.getInputWithBlock=function(a){for(var b=0,c;c=this.inputList[b];b++){if(c.connection&&c.connection.targetBlock()==a){return c}}return null};Blockly.Block.prototype.getSurroundParent=function(){var a=this;do{var b=a;a=a.getParent();if(!a){return null}}while(a.getNextBlock()==b);return a};Blockly.Block.prototype.getNextBlock=function(){return this.nextConnection&&this.nextConnection.targetBlock()};Blockly.Block.prototype.getRootBlock=function(){var a=this;do{var b=a;a=b.parentBlock_}while(a);return b};Blockly.Block.prototype.getChildren=function(){return this.childBlocks_};Blockly.Block.prototype.setParent=function(a){if(a!=this.parentBlock_){if(this.parentBlock_){goog.array.remove(this.parentBlock_.childBlocks_,this);if(this.previousConnection&&this.previousConnection.isConnected()){throw"Still connected to previous block."}if(this.outputConnection&&this.outputConnection.isConnected()){throw"Still connected to parent block."}this.parentBlock_=null}else{this.workspace.removeTopBlock(this)}(this.parentBlock_=a)?a.childBlocks_.push(this):this.workspace.addTopBlock(this)}};Blockly.Block.prototype.getDescendants=function(){for(var a=[this],b,c=0;b=this.childBlocks_[c];c++){a.push.apply(a,b.getDescendants())}return a};Blockly.Block.prototype.isDeletable=function(){return this.deletable_&&!this.isShadow_&&!(this.workspace&&this.workspace.options.readOnly)};Blockly.Block.prototype.setDeletable=function(a){this.deletable_=a
-};Blockly.Block.prototype.isMovable=function(){return this.movable_&&!this.isShadow_&&!(this.workspace&&this.workspace.options.readOnly)};Blockly.Block.prototype.setMovable=function(a){this.movable_=a};Blockly.Block.prototype.isShadow=function(){return this.isShadow_};Blockly.Block.prototype.setShadow=function(a){this.isShadow_=a};Blockly.Block.prototype.isEditable=function(){return this.editable_&&!(this.workspace&&this.workspace.options.readOnly)};Blockly.Block.prototype.setEditable=function(a){this.editable_=a;a=0;for(var b;b=this.inputList[a];a++){for(var c=0,d;d=b.fieldRow[c];c++){d.updateEditable()}}};Blockly.Block.prototype.setConnectionsHidden=function(a){if(!a&&this.isCollapsed()){if(this.outputConnection&&this.outputConnection.setHidden(a),this.previousConnection&&this.previousConnection.setHidden(a),this.nextConnection){this.nextConnection.setHidden(a);var b=this.nextConnection.targetBlock();b&&b.setConnectionsHidden(a)}}else{for(var c=this.getConnections_(!0),d=0;b=c[d];d++){b.setHidden(a),b.isSuperior()&&(b=b.targetBlock())&&b.setConnectionsHidden(a)}}};Blockly.Block.prototype.setHelpUrl=function(a){this.helpUrl=a};Blockly.Block.prototype.setTooltip=function(a){this.tooltip=a};Blockly.Block.prototype.getColour=function(){return this.colour_};Blockly.Block.prototype.getHue=function(){return this.hue_};Blockly.Block.prototype.setColour=function(a){var b=Number(a);if(!isNaN(b)&&0<=b&&360>=b){this.hue_=b,this.colour_=Blockly.hueToRgb(b)}else{if(goog.isString(a)&&/^#[0-9a-fA-F]{6}$/.test(a)){this.colour_=a,this.hue_=null}else{throw"Invalid colour: "+a}}};Blockly.Block.prototype.setOnChange=function(a){if(a&&!goog.isFunction(a)){throw Error("onchange must be a function.")}this.onchangeWrapper_&&this.workspace.removeChangeListener(this.onchangeWrapper_);if(this.onchange=a){this.onchangeWrapper_=a.bind(this),this.workspace.addChangeListener(this.onchangeWrapper_)}};Blockly.Block.prototype.getField=function(a){for(var b=0,c;c=this.inputList[b];b++){for(var d=0,e;
-e=c.fieldRow[d];d++){if(e.name===a){return e}}}return null};Blockly.Block.prototype.getVars=function(){for(var a=[],b=0,c;c=this.inputList[b];b++){for(var d=0,e;e=c.fieldRow[d];d++){e instanceof Blockly.FieldVariable&&a.push(e.getValue())}}return a};Blockly.Block.prototype.renameVar=function(a,b){for(var c=0,d;d=this.inputList[c];c++){for(var e=0,f;f=d.fieldRow[e];e++){f instanceof Blockly.FieldVariable&&Blockly.Names.equals(a,f.getValue())&&f.setValue(b)}}};Blockly.Block.prototype.getFieldValue=function(a){return(a=this.getField(a))?a.getValue():null};Blockly.Block.prototype.setFieldValue=function(a,b){var c=this.getField(b);goog.asserts.assertObject(c,'Field "%s" not found.',b);c.setValue(a)};Blockly.Block.prototype.setPreviousStatement=function(a,b){a?(void 0===b&&(b=null),this.previousConnection||(goog.asserts.assert(!this.outputConnection,"Remove output connection prior to adding previous connection."),this.previousConnection=this.makeConnection_(Blockly.PREVIOUS_STATEMENT)),this.previousConnection.setCheck(b)):this.previousConnection&&(goog.asserts.assert(!this.previousConnection.isConnected(),"Must disconnect previous statement before removing connection."),this.previousConnection.dispose(),this.previousConnection=null)};Blockly.Block.prototype.setNextStatement=function(a,b){a?(void 0===b&&(b=null),this.nextConnection||(this.nextConnection=this.makeConnection_(Blockly.NEXT_STATEMENT)),this.nextConnection.setCheck(b)):this.nextConnection&&(goog.asserts.assert(!this.nextConnection.isConnected(),"Must disconnect next statement before removing connection."),this.nextConnection.dispose(),this.nextConnection=null)};Blockly.Block.prototype.setOutput=function(a,b){a?(void 0===b&&(b=null),this.outputConnection||(goog.asserts.assert(!this.previousConnection,"Remove previous connection prior to adding output connection."),this.outputConnection=this.makeConnection_(Blockly.OUTPUT_VALUE)),this.outputConnection.setCheck(b)):this.outputConnection&&(goog.asserts.assert(!this.outputConnection.isConnected(),"Must disconnect output value before removing connection."),this.outputConnection.dispose(),this.outputConnection=null)
-};Blockly.Block.prototype.setInputsInline=function(a){this.inputsInline!=a&&(Blockly.Events.fire(new Blockly.Events.BlockChange(this,"inline",null,this.inputsInline,a)),this.inputsInline=a)};Blockly.Block.prototype.getInputsInline=function(){if(void 0!=this.inputsInline){return this.inputsInline}for(var a=1;a<this.inputList.length;a++){if(this.inputList[a-1].type==Blockly.DUMMY_INPUT&&this.inputList[a].type==Blockly.DUMMY_INPUT){return !1}}for(a=1;a<this.inputList.length;a++){if(this.inputList[a-1].type==Blockly.INPUT_VALUE&&this.inputList[a].type==Blockly.DUMMY_INPUT){return !0}}return !1};Blockly.Block.prototype.setDisabled=function(a){this.disabled!=a&&(Blockly.Events.fire(new Blockly.Events.BlockChange(this,"disabled",null,this.disabled,a)),this.disabled=a)};Blockly.Block.prototype.getInheritedDisabled=function(){for(var a=this.getSurroundParent();a;){if(a.disabled){return !0}a=a.getSurroundParent()}return !1};Blockly.Block.prototype.isCollapsed=function(){return this.collapsed_};Blockly.Block.prototype.setCollapsed=function(a){this.collapsed_!=a&&(Blockly.Events.fire(new Blockly.Events.BlockChange(this,"collapsed",null,this.collapsed_,a)),this.collapsed_=a)};Blockly.Block.prototype.toString=function(a,b){var c=[],d=b||"?";if(this.collapsed_){c.push(this.getInput("_TEMP_COLLAPSED_INPUT").fieldRow[0].text_)}else{for(var e=0,f;f=this.inputList[e];e++){for(var g=0,h;h=f.fieldRow[g];g++){h instanceof Blockly.FieldDropdown&&!h.getValue()?c.push(d):c.push(h.getText())}f.connection&&((f=f.connection.targetBlock())?c.push(f.toString(void 0,b)):c.push(d))}}c=goog.string.trim(c.join(" "))||"???";a&&(c=goog.string.truncate(c,a));return c};Blockly.Block.prototype.appendValueInput=function(a){return this.appendInput_(Blockly.INPUT_VALUE,a)};Blockly.Block.prototype.appendStatementInput=function(a){return this.appendInput_(Blockly.NEXT_STATEMENT,a)};Blockly.Block.prototype.appendDummyInput=function(a){return this.appendInput_(Blockly.DUMMY_INPUT,a||"")};Blockly.Block.prototype.jsonInit=function(a){goog.asserts.assert(void 0==a.output||void 0==a.previousStatement,"Must not have both an output and a previousStatement.");
-if(void 0!==a.colour){var b=a.colour;b=goog.isString(b)?Blockly.utils.replaceMessageReferences(b):b;this.setColour(b)}for(b=0;void 0!==a["message"+b];){this.interpolate_(a["message"+b],a["args"+b]||[],a["lastDummyAlign"+b]),b++}void 0!==a.inputsInline&&this.setInputsInline(a.inputsInline);void 0!==a.output&&this.setOutput(!0,a.output);void 0!==a.previousStatement&&this.setPreviousStatement(!0,a.previousStatement);void 0!==a.nextStatement&&this.setNextStatement(!0,a.nextStatement);void 0!==a.tooltip&&(b=a.tooltip,b=Blockly.utils.replaceMessageReferences(b),this.setTooltip(b));void 0!==a.enableContextMenu&&(b=a.enableContextMenu,this.contextMenu=!!b);void 0!==a.helpUrl&&(b=a.helpUrl,b=Blockly.utils.replaceMessageReferences(b),this.setHelpUrl(b));goog.isString(a.extensions)&&(console.warn("JSON attribute 'extensions' should be an array of strings. Found raw string in JSON for '"+a.type+"' block."),a.extensions=[a.extensions]);void 0!==a.mutator&&Blockly.Extensions.apply(a.mutator,this,!0);if(Array.isArray(a.extensions)){for(a=a.extensions,b=0;b<a.length;++b){Blockly.Extensions.apply(a[b],this,!1)}}};Blockly.Block.prototype.mixin=function(a,b){if(goog.isDef(b)&&!goog.isBoolean(b)){throw Error("opt_disableCheck must be a boolean if provided")}if(!b){var c=[],d;for(d in a){void 0!==this[d]&&c.push(d)}if(c.length){throw Error("Mixin will overwrite block members: "+JSON.stringify(c))}}goog.mixin(this,a)};Blockly.Block.prototype.interpolate_=function(a,b,c){var d=Blockly.utils.tokenizeInterpolation(a),e=[],f=0;a=[];for(var g=0;g<d.length;g++){var h=d[g];if("number"==typeof h){if(0>=h||h>b.length){throw Error('Block "'+this.type+'": Message index %'+h+" out of range.")}if(e[h]){throw Error('Block "'+this.type+'": Message index %'+h+" duplicated.")}e[h]=!0;f++;a.push(b[h-1])}else{(h=h.trim())&&a.push(h)}}if(f!=b.length){throw Error('Block "'+this.type+'": Message does not reference all '+b.length+" arg(s).")}a.length&&("string"==typeof a[a.length-1]||goog.string.startsWith(a[a.length-1].type,"field_"))&&(g={type:"input_dummy"},c&&(g.align=c),a.push(g));
-c={LEFT:Blockly.ALIGN_LEFT,RIGHT:Blockly.ALIGN_RIGHT,CENTRE:Blockly.ALIGN_CENTRE};b=[];for(g=0;g<a.length;g++){if(e=a[g],"string"==typeof e){b.push([e,void 0])}else{d=f=null;do{if(h=!1,"string"==typeof e){f=new Blockly.FieldLabel(e)}else{switch(e.type){case"input_value":d=this.appendValueInput(e.name);break;case"input_statement":d=this.appendStatementInput(e.name);break;case"input_dummy":d=this.appendDummyInput(e.name);break;case"field_label":f=Blockly.Block.newFieldLabelFromJson_(e);break;case"field_input":f=Blockly.Block.newFieldTextInputFromJson_(e);break;case"field_angle":f=new Blockly.FieldAngle(e.angle);break;case"field_checkbox":f=new Blockly.FieldCheckbox(e.checked?"TRUE":"FALSE");break;case"field_colour":f=new Blockly.FieldColour(e.colour);break;case"field_variable":f=Blockly.Block.newFieldVariableFromJson_(e);break;case"field_dropdown":f=new Blockly.FieldDropdown(e.options);break;case"field_image":f=Blockly.Block.newFieldImageFromJson_(e);break;case"field_number":f=new Blockly.FieldNumber(e.value,e.min,e.max,e.precision);break;case"field_date":if(Blockly.FieldDate){f=new Blockly.FieldDate(e.date);break}default:e.alt&&(e=e.alt,h=!0)}}}while(h);if(f){b.push([f,e.name])}else{if(d){e.check&&d.setCheck(e.check);e.align&&d.setAlign(c[e.align]);for(e=0;e<b.length;e++){d.appendField(b[e][0],b[e][1])}b.length=0}}}}};Blockly.Block.newFieldImageFromJson_=function(a){var b=Blockly.utils.replaceMessageReferences(a.src),c=Number(Blockly.utils.replaceMessageReferences(a.width)),d=Number(Blockly.utils.replaceMessageReferences(a.height));a=Blockly.utils.replaceMessageReferences(a.alt);return new Blockly.FieldImage(b,c,d,a)};Blockly.Block.newFieldLabelFromJson_=function(a){var b=Blockly.utils.replaceMessageReferences(a.text);return new Blockly.FieldLabel(b,a["class"])};Blockly.Block.newFieldTextInputFromJson_=function(a){var b=Blockly.utils.replaceMessageReferences(a.text);b=new Blockly.FieldTextInput(b,a["class"]);"boolean"==typeof a.spellcheck&&b.setSpellcheck(a.spellcheck);
-return b};Blockly.Block.newFieldVariableFromJson_=function(a){var b=Blockly.utils.replaceMessageReferences(a.variable);return new Blockly.FieldVariable(b,null,a.variableTypes)};Blockly.Block.prototype.appendInput_=function(a,b){var c=null;if(a==Blockly.INPUT_VALUE||a==Blockly.NEXT_STATEMENT){c=this.makeConnection_(a)}c=new Blockly.Input(a,b,this,c);this.inputList.push(c);return c};Blockly.Block.prototype.moveInputBefore=function(a,b){if(a!=b){for(var c=-1,d=b?-1:this.inputList.length,e=0,f;f=this.inputList[e];e++){if(f.name==a){if(c=e,-1!=d){break}}else{if(b&&f.name==b&&(d=e,-1!=c)){break}}}goog.asserts.assert(-1!=c,'Named input "%s" not found.',a);goog.asserts.assert(-1!=d,'Reference input "%s" not found.',b);this.moveNumberedInputBefore(c,d)}};Blockly.Block.prototype.moveNumberedInputBefore=function(a,b){goog.asserts.assert(a!=b,"Can't move input to itself.");goog.asserts.assert(a<this.inputList.length,"Input index "+a+" out of bounds.");goog.asserts.assert(b<=this.inputList.length,"Reference input "+b+" out of bounds.");var c=this.inputList[a];this.inputList.splice(a,1);a<b&&b--;this.inputList.splice(b,0,c)};Blockly.Block.prototype.removeInput=function(a,b){for(var c=0,d;d=this.inputList[c];c++){if(d.name==a){if(d.connection&&d.connection.isConnected()){d.connection.setShadowDom(null);var e=d.connection.targetBlock();e.isShadow()?e.dispose():e.unplug()}d.dispose();this.inputList.splice(c,1);return}}b||goog.asserts.fail('Input "%s" not found.',a)};Blockly.Block.prototype.getInput=function(a){for(var b=0,c;c=this.inputList[b];b++){if(c.name==a){return c}}return null};Blockly.Block.prototype.getInputTargetBlock=function(a){return(a=this.getInput(a))&&a.connection&&a.connection.targetBlock()};Blockly.Block.prototype.getCommentText=function(){return this.comment||""};Blockly.Block.prototype.setCommentText=function(a){this.comment!=a&&(Blockly.Events.fire(new Blockly.Events.BlockChange(this,"comment",null,this.comment,a||"")),this.comment=a)};Blockly.Block.prototype.setWarningText=function(a,b){};
-Blockly.Block.prototype.setMutator=function(a){};Blockly.Block.prototype.getRelativeToSurfaceXY=function(){return this.xy_};Blockly.Block.prototype.moveBy=function(a,b){goog.asserts.assert(!this.parentBlock_,"Block has parent.");var c=new Blockly.Events.BlockMove(this);this.xy_.translate(a,b);c.recordNew();Blockly.Events.fire(c)};Blockly.Block.prototype.makeConnection_=function(a){return new Blockly.Connection(this,a)};Blockly.Block.prototype.allInputsFilled=function(a){void 0===a&&(a=!0);if(!a&&this.isShadow()){return !1}for(var b=0,c;c=this.inputList[b];b++){if(c.connection&&(c=c.connection.targetBlock(),!c||!c.allInputsFilled(a))){return !1}}return(b=this.getNextBlock())?b.allInputsFilled(a):!0};Blockly.Block.prototype.toDevString=function(){var a=this.type?'"'+this.type+'" block':"Block";this.id&&(a+=' (id="'+this.id+'")');return a};Blockly.BlockDragSurfaceSvg=function(a){this.container_=a;this.createDom()};Blockly.BlockDragSurfaceSvg.prototype.SVG_=null;Blockly.BlockDragSurfaceSvg.prototype.dragGroup_=null;Blockly.BlockDragSurfaceSvg.prototype.container_=null;Blockly.BlockDragSurfaceSvg.prototype.scale_=1;Blockly.BlockDragSurfaceSvg.prototype.surfaceXY_=null;Blockly.BlockDragSurfaceSvg.prototype.createDom=function(){this.SVG_||(this.SVG_=Blockly.utils.createSvgElement("svg",{xmlns:Blockly.SVG_NS,"xmlns:html":Blockly.HTML_NS,"xmlns:xlink":"http://www.w3.org/1999/xlink",version:"1.1","class":"blocklyBlockDragSurface"},this.container_),this.dragGroup_=Blockly.utils.createSvgElement("g",{},this.SVG_))};Blockly.BlockDragSurfaceSvg.prototype.setBlocksAndShow=function(a){goog.asserts.assert(0==this.dragGroup_.childNodes.length,"Already dragging a block.");this.dragGroup_.appendChild(a);this.SVG_.style.display="block";this.surfaceXY_=new goog.math.Coordinate(0,0)};Blockly.BlockDragSurfaceSvg.prototype.translateAndScaleGroup=function(a,b,c){this.scale_=c;a=a.toFixed(0);b=b.toFixed(0);this.dragGroup_.setAttribute("transform","translate("+a+","+b+") scale("+c+")")};Blockly.BlockDragSurfaceSvg.prototype.translateSurfaceInternal_=function(){var a=this.surfaceXY_.x,b=this.surfaceXY_.y;
-a=a.toFixed(0);b=b.toFixed(0);this.SVG_.style.display="block";Blockly.utils.setCssTransform(this.SVG_,"translate3d("+a+"px, "+b+"px, 0px)")};Blockly.BlockDragSurfaceSvg.prototype.translateSurface=function(a,b){this.surfaceXY_=new goog.math.Coordinate(a*this.scale_,b*this.scale_);this.translateSurfaceInternal_()};Blockly.BlockDragSurfaceSvg.prototype.getSurfaceTranslation=function(){var a=Blockly.utils.getRelativeXY(this.SVG_);return new goog.math.Coordinate(a.x/this.scale_,a.y/this.scale_)};Blockly.BlockDragSurfaceSvg.prototype.getGroup=function(){return this.dragGroup_};Blockly.BlockDragSurfaceSvg.prototype.getCurrentBlock=function(){return this.dragGroup_.firstChild};Blockly.BlockDragSurfaceSvg.prototype.clearAndHide=function(a){a?a.appendChild(this.getCurrentBlock()):this.dragGroup_.removeChild(this.getCurrentBlock());this.SVG_.style.display="none";goog.asserts.assert(0==this.dragGroup_.childNodes.length,"Drag group was not cleared.");this.surfaceXY_=null};Blockly.utils.uiMenu={};Blockly.utils.uiMenu.getSize=function(a){a=a.getElement();var b=goog.style.getSize(a);b.height=a.scrollHeight;return b};Blockly.utils.uiMenu.adjustBBoxesForRTL=function(a,b,c){b.left+=c.width;b.right+=c.width;a.left+=c.width;a.right+=c.width};Blockly.ContextMenu={};Blockly.ContextMenu.currentBlock=null;Blockly.ContextMenu.eventWrapper_=null;Blockly.ContextMenu.show=function(a,b,c){Blockly.WidgetDiv.show(Blockly.ContextMenu,c,null);if(b.length){var d=Blockly.ContextMenu.populate_(b,c);goog.events.listen(d,goog.ui.Component.EventType.ACTION,Blockly.ContextMenu.hide);Blockly.ContextMenu.position_(d,a,c);setTimeout(function(){d.getElement().focus()},1);Blockly.ContextMenu.currentBlock=null}else{Blockly.ContextMenu.hide()}};Blockly.ContextMenu.populate_=function(a,b){var c=new goog.ui.Menu;c.setRightToLeft(b);for(var d=0,e;e=a[d];d++){var f=new goog.ui.MenuItem(e.text);f.setRightToLeft(b);c.addChild(f,!0);f.setEnabled(e.enabled);e.enabled&&(goog.events.listen(f,goog.ui.Component.EventType.ACTION,e.callback),f.handleContextMenu=function(){goog.events.dispatchEvent(this,goog.ui.Component.EventType.ACTION)
-})}return c};Blockly.ContextMenu.position_=function(a,b,c){var d=Blockly.utils.getViewportBBox();b={top:b.clientY+d.top,bottom:b.clientY+d.top,left:b.clientX+d.left,right:b.clientX+d.left};Blockly.ContextMenu.createWidget_(a);var e=Blockly.utils.uiMenu.getSize(a);c&&Blockly.utils.uiMenu.adjustBBoxesForRTL(d,b,e);Blockly.WidgetDiv.positionWithAnchor(d,b,e,c);a.getElement().focus()};Blockly.ContextMenu.createWidget_=function(a){a.render(Blockly.WidgetDiv.DIV);var b=a.getElement();Blockly.utils.addClass(b,"blocklyContextMenu");Blockly.bindEventWithChecks_(b,"contextmenu",null,Blockly.utils.noEvent);a.setAllowAutoFocus(!0)};Blockly.ContextMenu.hide=function(){Blockly.WidgetDiv.hideIfOwner(Blockly.ContextMenu);Blockly.ContextMenu.currentBlock=null;Blockly.ContextMenu.eventWrapper_&&Blockly.unbindEvent_(Blockly.ContextMenu.eventWrapper_)};Blockly.ContextMenu.callbackFactory=function(a,b){return function(){Blockly.Events.disable();try{var c=Blockly.Xml.domToBlock(b,a.workspace),d=a.getRelativeToSurfaceXY();d.x=a.RTL?d.x-Blockly.SNAP_RADIUS:d.x+Blockly.SNAP_RADIUS;d.y+=2*Blockly.SNAP_RADIUS;c.moveBy(d.x,d.y)}finally{Blockly.Events.enable()}Blockly.Events.isEnabled()&&!c.isShadow()&&Blockly.Events.fire(new Blockly.Events.BlockCreate(c));c.select()}};Blockly.ContextMenu.blockDeleteOption=function(a){var b=a.getDescendants(!0).length,c=a.getNextBlock();c&&(b-=c.getDescendants(!0).length);return{text:1==b?Blockly.Msg.DELETE_BLOCK:Blockly.Msg.DELETE_X_BLOCKS.replace("%1",String(b)),enabled:!0,callback:function(){Blockly.Events.setGroup(!0);a.dispose(!0,!0);Blockly.Events.setGroup(!1)}}};Blockly.ContextMenu.blockHelpOption=function(a){return{enabled:!(goog.isFunction(a.helpUrl)?!a.helpUrl():!a.helpUrl),text:Blockly.Msg.HELP,callback:function(){a.showHelp_()}}};Blockly.ContextMenu.blockDuplicateOption=function(a){var b=!0;a.getDescendants().length>a.workspace.remainingCapacity()&&(b=!1);return{text:Blockly.Msg.DUPLICATE_BLOCK,enabled:b,callback:function(){Blockly.duplicate_(a)}}};Blockly.ContextMenu.blockCommentOption=function(a){var b={enabled:!goog.userAgent.IE};
-a.comment?(b.text=Blockly.Msg.REMOVE_COMMENT,b.callback=function(){a.setCommentText(null)}):(b.text=Blockly.Msg.ADD_COMMENT,b.callback=function(){a.setCommentText("")});return b};Blockly.BlockSvg=function(a,b,c){this.svgGroup_=Blockly.utils.createSvgElement("g",{},null);this.svgGroup_.translate_="";this.svgPathDark_=Blockly.utils.createSvgElement("path",{"class":"blocklyPathDark",transform:"translate(1,1)"},this.svgGroup_);this.svgPath_=Blockly.utils.createSvgElement("path",{"class":"blocklyPath"},this.svgGroup_);this.svgPathLight_=Blockly.utils.createSvgElement("path",{"class":"blocklyPathLight"},this.svgGroup_);this.svgPath_.tooltip=this;this.rendered=!1;this.useDragSurface_=Blockly.utils.is3dSupported()&&!!a.blockDragSurface_;Blockly.Tooltip.bindMouseEvents(this.svgPath_);Blockly.BlockSvg.superClass_.constructor.call(this,a,b,c)};goog.inherits(Blockly.BlockSvg,Blockly.Block);Blockly.BlockSvg.prototype.height=0;Blockly.BlockSvg.prototype.width=0;Blockly.BlockSvg.prototype.dragStartXY_=null;Blockly.BlockSvg.prototype.warningTextDb_=null;Blockly.BlockSvg.INLINE=-1;Blockly.BlockSvg.prototype.initSvg=function(){goog.asserts.assert(this.workspace.rendered,"Workspace is headless.");for(var a=0,b;b=this.inputList[a];a++){b.init()}b=this.getIcons();for(a=0;a<b.length;a++){b[a].createIcon()}this.updateColour();this.updateMovable();this.workspace.options.readOnly||this.eventsInit_||Blockly.bindEventWithChecks_(this.getSvgRoot(),"mousedown",this,this.onMouseDown_);this.eventsInit_=!0;this.getSvgRoot().parentNode||this.workspace.getCanvas().appendChild(this.getSvgRoot())};Blockly.BlockSvg.prototype.select=function(){if(this.isShadow()&&this.getParent()){this.getParent().select()}else{if(Blockly.selected!=this){var a=null;if(Blockly.selected){a=Blockly.selected.id;Blockly.Events.disable();try{Blockly.selected.unselect()}finally{Blockly.Events.enable()}}a=new Blockly.Events.Ui(null,"selected",a,this.id);a.workspaceId=this.workspace.id;Blockly.Events.fire(a);Blockly.selected=this;
-this.addSelect()}}};Blockly.BlockSvg.prototype.unselect=function(){if(Blockly.selected==this){var a=new Blockly.Events.Ui(null,"selected",this.id,null);a.workspaceId=this.workspace.id;Blockly.Events.fire(a);Blockly.selected=null;this.removeSelect()}};Blockly.BlockSvg.prototype.mutator=null;Blockly.BlockSvg.prototype.comment=null;Blockly.BlockSvg.prototype.warning=null;Blockly.BlockSvg.prototype.getIcons=function(){var a=[];this.mutator&&a.push(this.mutator);this.comment&&a.push(this.comment);this.warning&&a.push(this.warning);return a};Blockly.BlockSvg.prototype.setParent=function(a){if(a!=this.parentBlock_){var b=this.getSvgRoot();if(this.parentBlock_&&b){var c=this.getRelativeToSurfaceXY();this.workspace.getCanvas().appendChild(b);b.setAttribute("transform","translate("+c.x+","+c.y+")")}Blockly.Field.startCache();Blockly.BlockSvg.superClass_.setParent.call(this,a);Blockly.Field.stopCache();a&&(c=this.getRelativeToSurfaceXY(),a.getSvgRoot().appendChild(b),a=this.getRelativeToSurfaceXY(),this.moveConnections_(a.x-c.x,a.y-c.y))}};Blockly.BlockSvg.prototype.getRelativeToSurfaceXY=function(){var a=0,b=0,c=this.useDragSurface_?this.workspace.blockDragSurface_.getGroup():null,d=this.getSvgRoot();if(d){do{var e=Blockly.utils.getRelativeXY(d);a+=e.x;b+=e.y;this.useDragSurface_&&this.workspace.blockDragSurface_.getCurrentBlock()==d&&(e=this.workspace.blockDragSurface_.getSurfaceTranslation(),a+=e.x,b+=e.y);d=d.parentNode}while(d&&d!=this.workspace.getCanvas()&&d!=c)}return new goog.math.Coordinate(a,b)};Blockly.BlockSvg.prototype.moveBy=function(a,b){goog.asserts.assert(!this.parentBlock_,"Block has parent.");var c=new Blockly.Events.BlockMove(this),d=this.getRelativeToSurfaceXY();this.translate(d.x+a,d.y+b);this.moveConnections_(a,b);c.recordNew();this.workspace.resizeContents();Blockly.Events.fire(c)};Blockly.BlockSvg.prototype.translate=function(a,b){this.getSvgRoot().setAttribute("transform","translate("+a+","+b+")")};Blockly.BlockSvg.prototype.moveToDragSurface_=function(){if(this.useDragSurface_){var a=this.getRelativeToSurfaceXY();
-this.clearTransformAttributes_();this.workspace.blockDragSurface_.translateSurface(a.x,a.y);this.workspace.blockDragSurface_.setBlocksAndShow(this.getSvgRoot())}};Blockly.BlockSvg.prototype.moveOffDragSurface_=function(a){this.useDragSurface_&&(this.translate(a.x,a.y),this.workspace.blockDragSurface_.clearAndHide(this.workspace.getCanvas()))};Blockly.BlockSvg.prototype.moveDuringDrag=function(a){this.useDragSurface_?this.workspace.blockDragSurface_.translateSurface(a.x,a.y):(this.svgGroup_.translate_="translate("+a.x+","+a.y+")",this.svgGroup_.setAttribute("transform",this.svgGroup_.translate_+this.svgGroup_.skew_))};Blockly.BlockSvg.prototype.clearTransformAttributes_=function(){Blockly.utils.removeAttribute(this.getSvgRoot(),"transform")};Blockly.BlockSvg.prototype.snapToGrid=function(){if(this.workspace&&!this.workspace.isDragging()&&!this.getParent()&&!this.isInFlyout){var a=this.workspace.getGrid();if(a&&a.shouldSnap()){var b=a.getSpacing(),c=b/2,d=this.getRelativeToSurfaceXY();a=Math.round((d.x-c)/b)*b+c-d.x;b=Math.round((d.y-c)/b)*b+c-d.y;a=Math.round(a);b=Math.round(b);0==a&&0==b||this.moveBy(a,b)}}};Blockly.BlockSvg.prototype.getBoundingRectangle=function(){var a=this.getRelativeToSurfaceXY(this),b=this.outputConnection?Blockly.BlockSvg.TAB_WIDTH:0,c=this.getHeightWidth();if(this.RTL){var d=new goog.math.Coordinate(a.x-(c.width-b),a.y);a=new goog.math.Coordinate(a.x+b,a.y+c.height)}else{d=new goog.math.Coordinate(a.x-b,a.y),a=new goog.math.Coordinate(a.x+c.width-b,a.y+c.height)}return{topLeft:d,bottomRight:a}};Blockly.BlockSvg.prototype.setCollapsed=function(a){if(this.collapsed_!=a){for(var b=[],c=0,d;d=this.inputList[c];c++){b.push.apply(b,d.setVisible(!a))}if(a){d=this.getIcons();for(c=0;c<d.length;c++){d[c].setVisible(!1)}c=this.toString(Blockly.COLLAPSE_CHARS);this.appendDummyInput("_TEMP_COLLAPSED_INPUT").appendField(c).init()}else{this.removeInput("_TEMP_COLLAPSED_INPUT"),this.setWarningText(null)}Blockly.BlockSvg.superClass_.setCollapsed.call(this,a);
-b.length||(b[0]=this);if(this.rendered){for(c=0;a=b[c];c++){a.render()}}}};Blockly.BlockSvg.prototype.tab=function(a,b){var c=this.createTabList_(),d=c.indexOf(a);-1==d&&(d=b?-1:c.length);(c=c[b?d+1:d-1])?c instanceof Blockly.Field?c.showEditor_():c.tab(null,b):(c=this.getParent())&&c.tab(this,b)};Blockly.BlockSvg.prototype.createTabList_=function(){for(var a=[],b=0,c;c=this.inputList[b];b++){for(var d=0,e;e=c.fieldRow[d];d++){e instanceof Blockly.FieldTextInput&&a.push(e)}c.connection&&(c=c.connection.targetBlock())&&a.push(c)}return a};Blockly.BlockSvg.prototype.onMouseDown_=function(a){var b=this.workspace.getGesture(a);b&&b.handleBlockStart(a,this)};Blockly.BlockSvg.prototype.showHelp_=function(){var a=goog.isFunction(this.helpUrl)?this.helpUrl():this.helpUrl;a&&window.open(a)};Blockly.BlockSvg.prototype.showContextMenu_=function(a){if(!this.workspace.options.readOnly&&this.contextMenu){var b=this,c=[];if(this.isDeletable()&&this.isMovable()&&!b.isInFlyout){c.push(Blockly.ContextMenu.blockDuplicateOption(b));this.isEditable()&&!this.collapsed_&&this.workspace.options.comments&&c.push(Blockly.ContextMenu.blockCommentOption(b));if(!this.collapsed_){for(var d=1;d<this.inputList.length;d++){if(this.inputList[d-1].type!=Blockly.NEXT_STATEMENT&&this.inputList[d].type!=Blockly.NEXT_STATEMENT){d={enabled:!0};var e=this.getInputsInline();d.text=e?Blockly.Msg.EXTERNAL_INPUTS:Blockly.Msg.INLINE_INPUTS;d.callback=function(){b.setInputsInline(!e)};c.push(d);break}}}this.workspace.options.collapse&&(this.collapsed_?(d={enabled:!0},d.text=Blockly.Msg.EXPAND_BLOCK,d.callback=function(){b.setCollapsed(!1)}):(d={enabled:!0},d.text=Blockly.Msg.COLLAPSE_BLOCK,d.callback=function(){b.setCollapsed(!0)}),c.push(d));this.workspace.options.disable&&(d={text:this.disabled?Blockly.Msg.ENABLE_BLOCK:Blockly.Msg.DISABLE_BLOCK,enabled:!this.getInheritedDisabled(),callback:function(){b.setDisabled(!b.disabled)}},c.push(d));c.push(Blockly.ContextMenu.blockDeleteOption(b))}c.push(Blockly.ContextMenu.blockHelpOption(b));
-this.customContextMenu&&this.customContextMenu(c);Blockly.ContextMenu.show(a,c,this.RTL);Blockly.ContextMenu.currentBlock=this}};Blockly.BlockSvg.prototype.moveConnections_=function(a,b){if(this.rendered){for(var c=this.getConnections_(!1),d=0;d<c.length;d++){c[d].moveBy(a,b)}c=this.getIcons();for(d=0;d<c.length;d++){c[d].computeIconLocation()}for(d=0;d<this.childBlocks_.length;d++){this.childBlocks_[d].moveConnections_(a,b)}}};Blockly.BlockSvg.prototype.setDragging=function(a){if(a){var b=this.getSvgRoot();b.translate_="";b.skew_="";Blockly.draggingConnections_=Blockly.draggingConnections_.concat(this.getConnections_(!0));Blockly.utils.addClass(this.svgGroup_,"blocklyDragging")}else{Blockly.draggingConnections_=[],Blockly.utils.removeClass(this.svgGroup_,"blocklyDragging")}for(b=0;b<this.childBlocks_.length;b++){this.childBlocks_[b].setDragging(a)}};Blockly.BlockSvg.prototype.updateMovable=function(){this.isMovable()?Blockly.utils.addClass(this.svgGroup_,"blocklyDraggable"):Blockly.utils.removeClass(this.svgGroup_,"blocklyDraggable")};Blockly.BlockSvg.prototype.setMovable=function(a){Blockly.BlockSvg.superClass_.setMovable.call(this,a);this.updateMovable()};Blockly.BlockSvg.prototype.setEditable=function(a){Blockly.BlockSvg.superClass_.setEditable.call(this,a);a=this.getIcons();for(var b=0;b<a.length;b++){a[b].updateEditable()}};Blockly.BlockSvg.prototype.setShadow=function(a){Blockly.BlockSvg.superClass_.setShadow.call(this,a);this.updateColour()};Blockly.BlockSvg.prototype.getSvgRoot=function(){return this.svgGroup_};Blockly.BlockSvg.prototype.dispose=function(a,b){if(this.workspace){Blockly.Tooltip.hide();Blockly.Field.startCache();var c=this.workspace;Blockly.selected==this&&(this.unselect(),this.workspace.cancelCurrentGesture());Blockly.ContextMenu.currentBlock==this&&Blockly.ContextMenu.hide();b&&this.rendered&&(this.unplug(a),this.disposeUiEffect());this.rendered=!1;if(this.warningTextDb_){for(var d in this.warningTextDb_){clearTimeout(this.warningTextDb_[d])
-}this.warningTextDb_=null}Blockly.Events.disable();try{var e=this.getIcons();for(d=0;d<e.length;d++){e[d].dispose()}}finally{Blockly.Events.enable()}Blockly.BlockSvg.superClass_.dispose.call(this,a);goog.dom.removeNode(this.svgGroup_);c.resizeContents();this.svgPathDark_=this.svgPathLight_=this.svgPath_=this.svgGroup_=null;Blockly.Field.stopCache()}};Blockly.BlockSvg.prototype.disposeUiEffect=function(){this.workspace.getAudioManager().play("delete");var a=this.workspace.getSvgXY(this.svgGroup_),b=this.svgGroup_.cloneNode(!0);b.translateX_=a.x;b.translateY_=a.y;b.setAttribute("transform","translate("+b.translateX_+","+b.translateY_+")");this.workspace.getParentSvg().appendChild(b);b.bBox_=b.getBBox();Blockly.BlockSvg.disposeUiStep_(b,this.RTL,new Date,this.workspace.scale)};Blockly.BlockSvg.disposeUiStep_=function(a,b,c,d){var e=(new Date-c)/150;1<e?goog.dom.removeNode(a):(a.setAttribute("transform","translate("+(a.translateX_+(b?-1:1)*a.bBox_.width*d/2*e)+","+(a.translateY_+a.bBox_.height*d*e)+") scale("+(1-e)*d+")"),setTimeout(Blockly.BlockSvg.disposeUiStep_,10,a,b,c,d))};Blockly.BlockSvg.prototype.connectionUiEffect=function(){this.workspace.getAudioManager().play("click");if(!(1>this.workspace.scale)){var a=this.workspace.getSvgXY(this.svgGroup_);this.outputConnection?(a.x+=(this.RTL?3:-3)*this.workspace.scale,a.y+=13*this.workspace.scale):this.previousConnection&&(a.x+=(this.RTL?-23:23)*this.workspace.scale,a.y+=3*this.workspace.scale);a=Blockly.utils.createSvgElement("circle",{cx:a.x,cy:a.y,r:0,fill:"none",stroke:"#888","stroke-width":10},this.workspace.getParentSvg());Blockly.BlockSvg.connectionUiStep_(a,new Date,this.workspace.scale)}};Blockly.BlockSvg.connectionUiStep_=function(a,b,c){var d=(new Date-b)/150;1<d?goog.dom.removeNode(a):(a.setAttribute("r",25*d*c),a.style.opacity=1-d,Blockly.BlockSvg.disconnectUiStop_.pid_=setTimeout(Blockly.BlockSvg.connectionUiStep_,10,a,b,c))};Blockly.BlockSvg.prototype.disconnectUiEffect=function(){this.workspace.getAudioManager().play("disconnect");
-if(!(1>this.workspace.scale)){var a=this.getHeightWidth().height;a=Math.atan(10/a)/Math.PI*180;this.RTL||(a*=-1);Blockly.BlockSvg.disconnectUiStep_(this.svgGroup_,a,new Date)}};Blockly.BlockSvg.disconnectUiStep_=function(a,b,c){var d=(new Date-c)/200;1<d?a.skew_="":(a.skew_="skewX("+Math.round(Math.sin(d*Math.PI*3)*(1-d)*b)+")",Blockly.BlockSvg.disconnectUiStop_.group=a,Blockly.BlockSvg.disconnectUiStop_.pid=setTimeout(Blockly.BlockSvg.disconnectUiStep_,10,a,b,c));a.setAttribute("transform",a.translate_+a.skew_)};Blockly.BlockSvg.disconnectUiStop_=function(){if(Blockly.BlockSvg.disconnectUiStop_.group){clearTimeout(Blockly.BlockSvg.disconnectUiStop_.pid);var a=Blockly.BlockSvg.disconnectUiStop_.group;a.skew_="";a.setAttribute("transform",a.translate_);Blockly.BlockSvg.disconnectUiStop_.group=null}};Blockly.BlockSvg.disconnectUiStop_.pid=0;Blockly.BlockSvg.disconnectUiStop_.group=null;Blockly.BlockSvg.prototype.updateColour=function(){if(!this.disabled){var a=this.getColour(),b=goog.color.hexToRgb(a);if(this.isShadow()){b=goog.color.lighten(b,0.6),a=goog.color.rgbArrayToHex(b),this.svgPathLight_.style.display="none",this.svgPathDark_.setAttribute("fill",a)}else{this.svgPathLight_.style.display="";var c=goog.color.rgbArrayToHex(goog.color.lighten(b,0.3));b=goog.color.rgbArrayToHex(goog.color.darken(b,0.2));this.svgPathLight_.setAttribute("stroke",c);this.svgPathDark_.setAttribute("fill",b)}this.svgPath_.setAttribute("fill",a);a=this.getIcons();for(c=0;c<a.length;c++){a[c].updateColour()}for(a=0;c=this.inputList[a];a++){b=0;for(var d;d=c.fieldRow[b];b++){d.setText(null)}}}};Blockly.BlockSvg.prototype.updateDisabled=function(){this.disabled||this.getInheritedDisabled()?Blockly.utils.addClass(this.svgGroup_,"blocklyDisabled")&&this.svgPath_.setAttribute("fill","url(#"+this.workspace.options.disabledPatternId+")"):Blockly.utils.removeClass(this.svgGroup_,"blocklyDisabled")&&this.updateColour();for(var a=this.getChildren(),b=0,c;c=a[b];b++){c.updateDisabled()}};Blockly.BlockSvg.prototype.getCommentText=function(){return this.comment?this.comment.getText().replace(/\s+$/,"").replace(/ +\n/g,"\n"):""
-};Blockly.BlockSvg.prototype.setCommentText=function(a){var b=!1;goog.isString(a)?(this.comment||(this.comment=new Blockly.Comment(this),b=!0),this.comment.setText(a)):this.comment&&(this.comment.dispose(),b=!0);b&&this.rendered&&(this.render(),this.bumpNeighbours_())};Blockly.BlockSvg.prototype.setWarningText=function(a,b){this.warningTextDb_||(this.warningTextDb_=Object.create(null));var c=b||"";if(c){this.warningTextDb_[c]&&(clearTimeout(this.warningTextDb_[c]),delete this.warningTextDb_[c])}else{for(var d in this.warningTextDb_){clearTimeout(this.warningTextDb_[d]),delete this.warningTextDb_[d]}}if(this.workspace.isDragging()){var e=this;this.warningTextDb_[c]=setTimeout(function(){e.workspace&&(delete e.warningTextDb_[c],e.setWarningText(a,c))},100)}else{this.isInFlyout&&(a=null);d=this.getSurroundParent();for(var f=null;d;){d.isCollapsed()&&(f=d),d=d.getSurroundParent()}f&&f.setWarningText(a,"collapsed "+this.id+" "+c);d=!1;goog.isString(a)?(this.warning||(this.warning=new Blockly.Warning(this),d=!0),this.warning.setText(a,c)):this.warning&&!c?(this.warning.dispose(),d=!0):this.warning&&(d=this.warning.getText(),this.warning.setText("",c),(f=this.warning.getText())||this.warning.dispose(),d=d!=f);d&&this.rendered&&(this.render(),this.bumpNeighbours_())}};Blockly.BlockSvg.prototype.setMutator=function(a){this.mutator&&this.mutator!==a&&this.mutator.dispose();a&&(a.block_=this,this.mutator=a,a.createIcon())};Blockly.BlockSvg.prototype.setDisabled=function(a){this.disabled!=a&&(Blockly.BlockSvg.superClass_.setDisabled.call(this,a),this.rendered&&this.updateDisabled())};Blockly.BlockSvg.prototype.setHighlighted=function(a){this.rendered&&(a?(this.svgPath_.setAttribute("filter","url(#"+this.workspace.options.embossFilterId+")"),this.svgPathLight_.style.display="none"):(Blockly.utils.removeAttribute(this.svgPath_,"filter"),delete this.svgPathLight_.style.display))};Blockly.BlockSvg.prototype.addSelect=function(){Blockly.utils.addClass(this.svgGroup_,"blocklySelected")
-};Blockly.BlockSvg.prototype.removeSelect=function(){Blockly.utils.removeClass(this.svgGroup_,"blocklySelected")};Blockly.BlockSvg.prototype.setDeleteStyle=function(a){a?Blockly.utils.addClass(this.svgGroup_,"blocklyDraggingDelete"):Blockly.utils.removeClass(this.svgGroup_,"blocklyDraggingDelete")};Blockly.BlockSvg.prototype.setColour=function(a){Blockly.BlockSvg.superClass_.setColour.call(this,a);this.rendered&&this.updateColour()};Blockly.BlockSvg.prototype.bringToFront=function(){var a=this;do{var b=a.getSvgRoot();b.parentNode.appendChild(b);a=a.getParent()}while(a)};Blockly.BlockSvg.prototype.setPreviousStatement=function(a,b){Blockly.BlockSvg.superClass_.setPreviousStatement.call(this,a,b);this.rendered&&(this.render(),this.bumpNeighbours_())};Blockly.BlockSvg.prototype.setNextStatement=function(a,b){Blockly.BlockSvg.superClass_.setNextStatement.call(this,a,b);this.rendered&&(this.render(),this.bumpNeighbours_())};Blockly.BlockSvg.prototype.setOutput=function(a,b){Blockly.BlockSvg.superClass_.setOutput.call(this,a,b);this.rendered&&(this.render(),this.bumpNeighbours_())};Blockly.BlockSvg.prototype.setInputsInline=function(a){Blockly.BlockSvg.superClass_.setInputsInline.call(this,a);this.rendered&&(this.render(),this.bumpNeighbours_())};Blockly.BlockSvg.prototype.removeInput=function(a,b){Blockly.BlockSvg.superClass_.removeInput.call(this,a,b);this.rendered&&(this.render(),this.bumpNeighbours_())};Blockly.BlockSvg.prototype.moveNumberedInputBefore=function(a,b){Blockly.BlockSvg.superClass_.moveNumberedInputBefore.call(this,a,b);this.rendered&&(this.render(),this.bumpNeighbours_())};Blockly.BlockSvg.prototype.appendInput_=function(a,b){var c=Blockly.BlockSvg.superClass_.appendInput_.call(this,a,b);this.rendered&&(this.render(),this.bumpNeighbours_());return c};Blockly.BlockSvg.prototype.getConnections_=function(a){var b=[];if(a||this.rendered){if(this.outputConnection&&b.push(this.outputConnection),this.previousConnection&&b.push(this.previousConnection),this.nextConnection&&b.push(this.nextConnection),a||!this.collapsed_){a=0;
-for(var c;c=this.inputList[a];a++){c.connection&&b.push(c.connection)}}}return b};Blockly.BlockSvg.prototype.makeConnection_=function(a){return new Blockly.RenderedConnection(this,a)};Blockly.BlockSvg.prototype.bumpNeighbours_=function(){if(this.workspace&&!this.workspace.isDragging()){var a=this.getRootBlock();if(!a.isInFlyout){for(var b=this.getConnections_(!1),c=0,d;d=b[c];c++){d.isConnected()&&d.isSuperior()&&d.targetBlock().bumpNeighbours_();for(var e=d.neighbours_(Blockly.SNAP_RADIUS),f=0,g;g=e[f];f++){d.isConnected()&&g.isConnected()||g.getSourceBlock().getRootBlock()!=a&&(d.isSuperior()?g.bumpAwayFrom_(d):d.bumpAwayFrom_(g))}}}}};Blockly.BlockSvg.prototype.scheduleSnapAndBump=function(){var a=this,b=Blockly.Events.getGroup();setTimeout(function(){Blockly.Events.setGroup(b);a.snapToGrid();Blockly.Events.setGroup(!1)},Blockly.BUMP_DELAY/2);setTimeout(function(){Blockly.Events.setGroup(b);a.bumpNeighbours_();Blockly.Events.setGroup(!1)},Blockly.BUMP_DELAY)};Blockly.BlockSvg.render={};Blockly.BlockSvg.SEP_SPACE_X=10;Blockly.BlockSvg.SEP_SPACE_Y=10;Blockly.BlockSvg.INLINE_PADDING_Y=5;Blockly.BlockSvg.MIN_BLOCK_Y=25;Blockly.BlockSvg.TAB_HEIGHT=20;Blockly.BlockSvg.TAB_WIDTH=8;Blockly.BlockSvg.NOTCH_WIDTH=30;Blockly.BlockSvg.CORNER_RADIUS=8;Blockly.BlockSvg.START_HAT=!1;Blockly.BlockSvg.START_HAT_HEIGHT=15;Blockly.BlockSvg.START_HAT_PATH="c 30,-"+Blockly.BlockSvg.START_HAT_HEIGHT+" 70,-"+Blockly.BlockSvg.START_HAT_HEIGHT+" 100,0";Blockly.BlockSvg.START_HAT_HIGHLIGHT_LTR="c 17.8,-9.2 45.3,-14.9 75,-8.7 M 100.5,0.5";Blockly.BlockSvg.START_HAT_HIGHLIGHT_RTL="m 25,-8.7 c 29.7,-6.2 57.2,-0.5 75,8.7";Blockly.BlockSvg.DISTANCE_45_INSIDE=(1-Math.SQRT1_2)*(Blockly.BlockSvg.CORNER_RADIUS-0.5)+0.5;Blockly.BlockSvg.DISTANCE_45_OUTSIDE=(1-Math.SQRT1_2)*(Blockly.BlockSvg.CORNER_RADIUS+0.5)-0.5;Blockly.BlockSvg.NOTCH_PATH_LEFT="l 6,4 3,0 6,-4";Blockly.BlockSvg.NOTCH_PATH_LEFT_HIGHLIGHT="l 6,4 3,0 6,-4";Blockly.BlockSvg.NOTCH_PATH_RIGHT="l -6,4 -3,0 -6,-4";Blockly.BlockSvg.JAGGED_TEETH="l 8,0 0,4 8,4 -16,8 8,4";
-Blockly.BlockSvg.JAGGED_TEETH_HEIGHT=20;Blockly.BlockSvg.JAGGED_TEETH_WIDTH=15;Blockly.BlockSvg.TAB_PATH_DOWN="v 5 c 0,10 -"+Blockly.BlockSvg.TAB_WIDTH+",-8 -"+Blockly.BlockSvg.TAB_WIDTH+",7.5 s "+Blockly.BlockSvg.TAB_WIDTH+",-2.5 "+Blockly.BlockSvg.TAB_WIDTH+",7.5";Blockly.BlockSvg.TAB_PATH_DOWN_HIGHLIGHT_RTL="v 6.5 m -"+0.97*Blockly.BlockSvg.TAB_WIDTH+",3 q -"+0.05*Blockly.BlockSvg.TAB_WIDTH+",10 "+0.3*Blockly.BlockSvg.TAB_WIDTH+",9.5 m "+0.67*Blockly.BlockSvg.TAB_WIDTH+",-1.9 v 1.4";Blockly.BlockSvg.TOP_LEFT_CORNER_START="m 0,"+Blockly.BlockSvg.CORNER_RADIUS;Blockly.BlockSvg.TOP_LEFT_CORNER_START_HIGHLIGHT_RTL="m "+Blockly.BlockSvg.DISTANCE_45_INSIDE+","+Blockly.BlockSvg.DISTANCE_45_INSIDE;Blockly.BlockSvg.TOP_LEFT_CORNER_START_HIGHLIGHT_LTR="m 0.5,"+(Blockly.BlockSvg.CORNER_RADIUS-0.5);Blockly.BlockSvg.TOP_LEFT_CORNER="A "+Blockly.BlockSvg.CORNER_RADIUS+","+Blockly.BlockSvg.CORNER_RADIUS+" 0 0,1 "+Blockly.BlockSvg.CORNER_RADIUS+",0";Blockly.BlockSvg.TOP_LEFT_CORNER_HIGHLIGHT="A "+(Blockly.BlockSvg.CORNER_RADIUS-0.5)+","+(Blockly.BlockSvg.CORNER_RADIUS-0.5)+" 0 0,1 "+Blockly.BlockSvg.CORNER_RADIUS+",0.5";Blockly.BlockSvg.INNER_TOP_LEFT_CORNER=Blockly.BlockSvg.NOTCH_PATH_RIGHT+" h -"+(Blockly.BlockSvg.NOTCH_WIDTH-15-Blockly.BlockSvg.CORNER_RADIUS)+" a "+Blockly.BlockSvg.CORNER_RADIUS+","+Blockly.BlockSvg.CORNER_RADIUS+" 0 0,0 -"+Blockly.BlockSvg.CORNER_RADIUS+","+Blockly.BlockSvg.CORNER_RADIUS;Blockly.BlockSvg.INNER_BOTTOM_LEFT_CORNER="a "+Blockly.BlockSvg.CORNER_RADIUS+","+Blockly.BlockSvg.CORNER_RADIUS+" 0 0,0 "+Blockly.BlockSvg.CORNER_RADIUS+","+Blockly.BlockSvg.CORNER_RADIUS;Blockly.BlockSvg.INNER_TOP_LEFT_CORNER_HIGHLIGHT_RTL="a "+Blockly.BlockSvg.CORNER_RADIUS+","+Blockly.BlockSvg.CORNER_RADIUS+" 0 0,0 "+(-Blockly.BlockSvg.DISTANCE_45_OUTSIDE-0.5)+","+(Blockly.BlockSvg.CORNER_RADIUS-Blockly.BlockSvg.DISTANCE_45_OUTSIDE);Blockly.BlockSvg.INNER_BOTTOM_LEFT_CORNER_HIGHLIGHT_RTL="a "+(Blockly.BlockSvg.CORNER_RADIUS+0.5)+","+(Blockly.BlockSvg.CORNER_RADIUS+0.5)+" 0 0,0 "+(Blockly.BlockSvg.CORNER_RADIUS+0.5)+","+(Blockly.BlockSvg.CORNER_RADIUS+0.5);
-Blockly.BlockSvg.INNER_BOTTOM_LEFT_CORNER_HIGHLIGHT_LTR="a "+(Blockly.BlockSvg.CORNER_RADIUS+0.5)+","+(Blockly.BlockSvg.CORNER_RADIUS+0.5)+" 0 0,0 "+(Blockly.BlockSvg.CORNER_RADIUS-Blockly.BlockSvg.DISTANCE_45_OUTSIDE)+","+(Blockly.BlockSvg.DISTANCE_45_OUTSIDE+0.5);Blockly.BlockSvg.prototype.getHeightWidth=function(){var a=this.height,b=this.width,c=this.getNextBlock();c?(c=c.getHeightWidth(),a+=c.height-4,b=Math.max(b,c.width)):this.nextConnection||this.outputConnection||(a+=2);return{height:a,width:b}};Blockly.BlockSvg.prototype.render=function(a){Blockly.Field.startCache();this.rendered=!0;var b=Blockly.BlockSvg.SEP_SPACE_X;this.RTL&&(b=-b);for(var c=this.getIcons(),d=0;d<c.length;d++){b=c[d].renderIcon(b)}b+=this.RTL?Blockly.BlockSvg.SEP_SPACE_X:-Blockly.BlockSvg.SEP_SPACE_X;c=this.renderCompute_(b);this.renderDraw_(b,c);this.renderMoveConnections_();!1!==a&&((a=this.getParent())?a.render(!0):this.workspace.resizeContents());Blockly.Field.stopCache()};Blockly.BlockSvg.prototype.renderFields_=function(a,b,c){c+=Blockly.BlockSvg.INLINE_PADDING_Y;this.RTL&&(b=-b);for(var d=0,e;e=a[d];d++){var f=e.getSvgRoot();f&&(this.RTL?(b-=e.renderSep+e.renderWidth,f.setAttribute("transform","translate("+b+","+c+")"),e.renderWidth&&(b-=Blockly.BlockSvg.SEP_SPACE_X)):(f.setAttribute("transform","translate("+(b+e.renderSep)+","+c+")"),e.renderWidth&&(b+=e.renderSep+e.renderWidth+Blockly.BlockSvg.SEP_SPACE_X)))}return this.RTL?-b:b};Blockly.BlockSvg.prototype.renderCompute_=function(a){var b=this.inputList,c=[];c.rightEdge=a+2*Blockly.BlockSvg.SEP_SPACE_X;if(this.previousConnection||this.nextConnection){c.rightEdge=Math.max(c.rightEdge,Blockly.BlockSvg.NOTCH_WIDTH+Blockly.BlockSvg.SEP_SPACE_X)}for(var d=0,e=0,f=!1,g=!1,h=!1,k=void 0,n=this.getInputsInline()&&!this.isCollapsed(),p=0,l;l=b[p];p++){if(l.isVisible()){if(n&&k&&k!=Blockly.NEXT_STATEMENT&&l.type!=Blockly.NEXT_STATEMENT){var m=c[c.length-1]}else{k=l.type,m=[],m.type=n&&l.type!=Blockly.NEXT_STATEMENT?Blockly.BlockSvg.INLINE:l.type,m.height=0,c.push(m)
-}m.push(l);l.renderHeight=Blockly.BlockSvg.MIN_BLOCK_Y;l.renderWidth=n&&l.type==Blockly.INPUT_VALUE?Blockly.BlockSvg.TAB_WIDTH+1.25*Blockly.BlockSvg.SEP_SPACE_X:0;if(l.connection&&l.connection.isConnected()){var q=l.connection.targetBlock().getHeightWidth();l.renderHeight=Math.max(l.renderHeight,q.height);l.renderWidth=Math.max(l.renderWidth,q.width)}n||p!=b.length-1?!n&&l.type==Blockly.INPUT_VALUE&&b[p+1]&&b[p+1].type==Blockly.NEXT_STATEMENT&&l.renderHeight--:l.renderHeight--;m.height=Math.max(m.height,l.renderHeight);l.fieldWidth=0;1==c.length&&(l.fieldWidth+=this.RTL?-a:a);q=!1;for(var t=0,r;r=l.fieldRow[t];t++){0!=t&&(l.fieldWidth+=Blockly.BlockSvg.SEP_SPACE_X);var u=r.getSize();r.renderWidth=u.width;r.renderSep=q&&r.EDITABLE?Blockly.BlockSvg.SEP_SPACE_X:0;l.fieldWidth+=r.renderWidth+r.renderSep;m.height=Math.max(m.height,u.height);q=r.EDITABLE}m.type!=Blockly.BlockSvg.INLINE&&(m.type==Blockly.NEXT_STATEMENT?(g=!0,e=Math.max(e,l.fieldWidth)):(m.type==Blockly.INPUT_VALUE?f=!0:m.type==Blockly.DUMMY_INPUT&&(h=!0),d=Math.max(d,l.fieldWidth)))}}for(a=0;m=c[a];a++){if(m.thicker=!1,m.type==Blockly.BlockSvg.INLINE){for(b=0;l=m[b];b++){if(l.type==Blockly.INPUT_VALUE){m.height+=2*Blockly.BlockSvg.INLINE_PADDING_Y;m.thicker=!0;break}}}}c.statementEdge=2*Blockly.BlockSvg.SEP_SPACE_X+e;g&&(c.rightEdge=Math.max(c.rightEdge,c.statementEdge+Blockly.BlockSvg.NOTCH_WIDTH));f?c.rightEdge=Math.max(c.rightEdge,d+2*Blockly.BlockSvg.SEP_SPACE_X+Blockly.BlockSvg.TAB_WIDTH):h&&(c.rightEdge=Math.max(c.rightEdge,d+2*Blockly.BlockSvg.SEP_SPACE_X));c.hasValue=f;c.hasStatement=g;c.hasDummy=h;return c};Blockly.BlockSvg.prototype.renderDraw_=function(a,b){this.startHat_=!1;this.height=0;if(this.outputConnection){this.squareBottomLeftCorner_=this.squareTopLeftCorner_=!0}else{this.squareBottomLeftCorner_=this.squareTopLeftCorner_=!1;if(this.previousConnection){var c=this.previousConnection.targetBlock();c&&c.getNextBlock()==this&&(this.squareTopLeftCorner_=!0)}else{Blockly.BlockSvg.START_HAT&&(this.startHat_=this.squareTopLeftCorner_=!0,this.height+=Blockly.BlockSvg.START_HAT_HEIGHT,b.rightEdge=Math.max(b.rightEdge,100))
-}this.getNextBlock()&&(this.squareBottomLeftCorner_=!0)}var d=[],e=[];c=[];var f=[];this.renderDrawTop_(d,c,b.rightEdge);var g=this.renderDrawRight_(d,c,e,f,b,a);this.renderDrawBottom_(d,c,g);this.renderDrawLeft_(d,c);d=d.join(" ")+"\n"+e.join(" ");this.svgPath_.setAttribute("d",d);this.svgPathDark_.setAttribute("d",d);d=c.join(" ")+"\n"+f.join(" ");this.svgPathLight_.setAttribute("d",d);this.RTL&&(this.svgPath_.setAttribute("transform","scale(-1 1)"),this.svgPathLight_.setAttribute("transform","scale(-1 1)"),this.svgPathDark_.setAttribute("transform","translate(1,1) scale(-1 1)"))};Blockly.BlockSvg.prototype.renderMoveConnections_=function(){var a=this.getRelativeToSurfaceXY();this.previousConnection&&this.previousConnection.moveToOffset(a);this.outputConnection&&this.outputConnection.moveToOffset(a);for(var b=0;b<this.inputList.length;b++){var c=this.inputList[b].connection;c&&(c.moveToOffset(a),c.isConnected()&&c.tighten_())}this.nextConnection&&(this.nextConnection.moveToOffset(a),this.nextConnection.isConnected()&&this.nextConnection.tighten_())};Blockly.BlockSvg.prototype.renderDrawTop_=function(a,b,c){this.squareTopLeftCorner_?(a.push("m 0,0"),b.push("m 0.5,0.5"),this.startHat_&&(a.push(Blockly.BlockSvg.START_HAT_PATH),b.push(this.RTL?Blockly.BlockSvg.START_HAT_HIGHLIGHT_RTL:Blockly.BlockSvg.START_HAT_HIGHLIGHT_LTR))):(a.push(Blockly.BlockSvg.TOP_LEFT_CORNER_START),b.push(this.RTL?Blockly.BlockSvg.TOP_LEFT_CORNER_START_HIGHLIGHT_RTL:Blockly.BlockSvg.TOP_LEFT_CORNER_START_HIGHLIGHT_LTR),a.push(Blockly.BlockSvg.TOP_LEFT_CORNER),b.push(Blockly.BlockSvg.TOP_LEFT_CORNER_HIGHLIGHT));this.previousConnection&&(a.push("H",Blockly.BlockSvg.NOTCH_WIDTH-15),b.push("H",Blockly.BlockSvg.NOTCH_WIDTH-15),a.push(Blockly.BlockSvg.NOTCH_PATH_LEFT),b.push(Blockly.BlockSvg.NOTCH_PATH_LEFT_HIGHLIGHT),this.previousConnection.setOffsetInBlock(this.RTL?-Blockly.BlockSvg.NOTCH_WIDTH:Blockly.BlockSvg.NOTCH_WIDTH,0));a.push("H",c);b.push("H",c-0.5);this.width=c};Blockly.BlockSvg.prototype.renderDrawRight_=function(a,b,c,d,e,f){for(var g,h=0,k,n,p=0,l;
-l=e[p];p++){g=Blockly.BlockSvg.SEP_SPACE_X;0==p&&(g+=this.RTL?-f:f);b.push("M",e.rightEdge-0.5+","+(h+0.5));if(this.isCollapsed()){var m=l[0];k=h;this.renderFields_(m.fieldRow,g,k);a.push(Blockly.BlockSvg.JAGGED_TEETH);b.push("h 8");m=l.height-Blockly.BlockSvg.JAGGED_TEETH_HEIGHT;a.push("v",m);this.RTL&&(b.push("v 3.9 l 7.2,3.4 m -14.5,8.9 l 7.3,3.5"),b.push("v",m-0.7));this.width+=Blockly.BlockSvg.JAGGED_TEETH_WIDTH}else{if(l.type==Blockly.BlockSvg.INLINE){for(var q=0;m=l[q];q++){k=h,l.thicker&&(k+=Blockly.BlockSvg.INLINE_PADDING_Y),g=this.renderFields_(m.fieldRow,g,k),m.type!=Blockly.DUMMY_INPUT&&(g+=m.renderWidth+Blockly.BlockSvg.SEP_SPACE_X),m.type==Blockly.INPUT_VALUE&&(c.push("M",g-Blockly.BlockSvg.SEP_SPACE_X+","+(h+Blockly.BlockSvg.INLINE_PADDING_Y)),c.push("h",Blockly.BlockSvg.TAB_WIDTH-2-m.renderWidth),c.push(Blockly.BlockSvg.TAB_PATH_DOWN),c.push("v",m.renderHeight+1-Blockly.BlockSvg.TAB_HEIGHT),c.push("h",m.renderWidth+2-Blockly.BlockSvg.TAB_WIDTH),c.push("z"),this.RTL?(d.push("M",g-Blockly.BlockSvg.SEP_SPACE_X-2.5+Blockly.BlockSvg.TAB_WIDTH-m.renderWidth+","+(h+Blockly.BlockSvg.INLINE_PADDING_Y+0.5)),d.push(Blockly.BlockSvg.TAB_PATH_DOWN_HIGHLIGHT_RTL),d.push("v",m.renderHeight-Blockly.BlockSvg.TAB_HEIGHT+2.5),d.push("h",m.renderWidth-Blockly.BlockSvg.TAB_WIDTH+2)):(d.push("M",g-Blockly.BlockSvg.SEP_SPACE_X+0.5+","+(h+Blockly.BlockSvg.INLINE_PADDING_Y+0.5)),d.push("v",m.renderHeight+1),d.push("h",Blockly.BlockSvg.TAB_WIDTH-2-m.renderWidth),d.push("M",g-m.renderWidth-Blockly.BlockSvg.SEP_SPACE_X+0.9+","+(h+Blockly.BlockSvg.INLINE_PADDING_Y+Blockly.BlockSvg.TAB_HEIGHT-0.7)),d.push("l",0.46*Blockly.BlockSvg.TAB_WIDTH+",-2.1")),k=this.RTL?-g-Blockly.BlockSvg.TAB_WIDTH+Blockly.BlockSvg.SEP_SPACE_X+m.renderWidth+1:g+Blockly.BlockSvg.TAB_WIDTH-Blockly.BlockSvg.SEP_SPACE_X-m.renderWidth-1,n=h+Blockly.BlockSvg.INLINE_PADDING_Y+1,m.connection.setOffsetInBlock(k,n))}g=Math.max(g,e.rightEdge);this.width=Math.max(this.width,g);a.push("H",g);b.push("H",g-0.5);a.push("v",l.height);
-this.RTL&&b.push("v",l.height-1)}else{l.type==Blockly.INPUT_VALUE?(m=l[0],k=h,m.align!=Blockly.ALIGN_LEFT&&(q=e.rightEdge-m.fieldWidth-Blockly.BlockSvg.TAB_WIDTH-2*Blockly.BlockSvg.SEP_SPACE_X,m.align==Blockly.ALIGN_RIGHT?g+=q:m.align==Blockly.ALIGN_CENTRE&&(g+=q/2)),this.renderFields_(m.fieldRow,g,k),a.push(Blockly.BlockSvg.TAB_PATH_DOWN),q=l.height-Blockly.BlockSvg.TAB_HEIGHT,a.push("v",q),this.RTL?(b.push(Blockly.BlockSvg.TAB_PATH_DOWN_HIGHLIGHT_RTL),b.push("v",q+0.5)):(b.push("M",e.rightEdge-5+","+(h+Blockly.BlockSvg.TAB_HEIGHT-0.7)),b.push("l",0.46*Blockly.BlockSvg.TAB_WIDTH+",-2.1")),k=this.RTL?-e.rightEdge-1:e.rightEdge+1,m.connection.setOffsetInBlock(k,h),m.connection.isConnected()&&(this.width=Math.max(this.width,e.rightEdge+m.connection.targetBlock().getHeightWidth().width-Blockly.BlockSvg.TAB_WIDTH+1))):l.type==Blockly.DUMMY_INPUT?(m=l[0],k=h,m.align!=Blockly.ALIGN_LEFT&&(q=e.rightEdge-m.fieldWidth-2*Blockly.BlockSvg.SEP_SPACE_X,e.hasValue&&(q-=Blockly.BlockSvg.TAB_WIDTH),m.align==Blockly.ALIGN_RIGHT?g+=q:m.align==Blockly.ALIGN_CENTRE&&(g+=q/2)),this.renderFields_(m.fieldRow,g,k),a.push("v",l.height),this.RTL&&b.push("v",l.height-1)):l.type==Blockly.NEXT_STATEMENT&&(m=l[0],0==p&&(a.push("v",Blockly.BlockSvg.SEP_SPACE_Y),this.RTL&&b.push("v",Blockly.BlockSvg.SEP_SPACE_Y-1),h+=Blockly.BlockSvg.SEP_SPACE_Y),k=h,m.align!=Blockly.ALIGN_LEFT&&(q=e.statementEdge-m.fieldWidth-2*Blockly.BlockSvg.SEP_SPACE_X,m.align==Blockly.ALIGN_RIGHT?g+=q:m.align==Blockly.ALIGN_CENTRE&&(g+=q/2)),this.renderFields_(m.fieldRow,g,k),g=e.statementEdge+Blockly.BlockSvg.NOTCH_WIDTH,a.push("H",g),a.push(Blockly.BlockSvg.INNER_TOP_LEFT_CORNER),a.push("v",l.height-2*Blockly.BlockSvg.CORNER_RADIUS),a.push(Blockly.BlockSvg.INNER_BOTTOM_LEFT_CORNER),a.push("H",e.rightEdge),this.RTL?(b.push("M",g-Blockly.BlockSvg.NOTCH_WIDTH+Blockly.BlockSvg.DISTANCE_45_OUTSIDE+","+(h+Blockly.BlockSvg.DISTANCE_45_OUTSIDE)),b.push(Blockly.BlockSvg.INNER_TOP_LEFT_CORNER_HIGHLIGHT_RTL),b.push("v",l.height-2*Blockly.BlockSvg.CORNER_RADIUS),b.push(Blockly.BlockSvg.INNER_BOTTOM_LEFT_CORNER_HIGHLIGHT_RTL)):(b.push("M",g-Blockly.BlockSvg.NOTCH_WIDTH+Blockly.BlockSvg.DISTANCE_45_OUTSIDE+","+(h+l.height-Blockly.BlockSvg.DISTANCE_45_OUTSIDE)),b.push(Blockly.BlockSvg.INNER_BOTTOM_LEFT_CORNER_HIGHLIGHT_LTR)),b.push("H",e.rightEdge-0.5),k=this.RTL?-g:g+1,m.connection.setOffsetInBlock(k,h+1),m.connection.isConnected()&&(this.width=Math.max(this.width,e.statementEdge+m.connection.targetBlock().getHeightWidth().width)),p==e.length-1||e[p+1].type==Blockly.NEXT_STATEMENT)&&(a.push("v",Blockly.BlockSvg.SEP_SPACE_Y),this.RTL&&b.push("v",Blockly.BlockSvg.SEP_SPACE_Y-1),h+=Blockly.BlockSvg.SEP_SPACE_Y)
-}}h+=l.height}e.length||(h=Blockly.BlockSvg.MIN_BLOCK_Y,a.push("V",h),this.RTL&&b.push("V",h-1));return h};Blockly.BlockSvg.prototype.renderDrawBottom_=function(a,b,c){this.height+=c+1;this.nextConnection&&(a.push("H",Blockly.BlockSvg.NOTCH_WIDTH+(this.RTL?0.5:-0.5)+" "+Blockly.BlockSvg.NOTCH_PATH_RIGHT),this.nextConnection.setOffsetInBlock(this.RTL?-Blockly.BlockSvg.NOTCH_WIDTH:Blockly.BlockSvg.NOTCH_WIDTH,c+1),this.height+=4);this.squareBottomLeftCorner_?(a.push("H 0"),this.RTL||b.push("M","0.5,"+(c-0.5))):(a.push("H",Blockly.BlockSvg.CORNER_RADIUS),a.push("a",Blockly.BlockSvg.CORNER_RADIUS+","+Blockly.BlockSvg.CORNER_RADIUS+" 0 0,1 -"+Blockly.BlockSvg.CORNER_RADIUS+",-"+Blockly.BlockSvg.CORNER_RADIUS),this.RTL||(b.push("M",Blockly.BlockSvg.DISTANCE_45_INSIDE+","+(c-Blockly.BlockSvg.DISTANCE_45_INSIDE)),b.push("A",Blockly.BlockSvg.CORNER_RADIUS-0.5+","+(Blockly.BlockSvg.CORNER_RADIUS-0.5)+" 0 0,1 0.5,"+(c-Blockly.BlockSvg.CORNER_RADIUS))))};Blockly.BlockSvg.prototype.renderDrawLeft_=function(a,b){this.outputConnection?(this.outputConnection.setOffsetInBlock(0,0),a.push("V",Blockly.BlockSvg.TAB_HEIGHT),a.push("c 0,-10 -"+Blockly.BlockSvg.TAB_WIDTH+",8 -"+Blockly.BlockSvg.TAB_WIDTH+",-7.5 s "+Blockly.BlockSvg.TAB_WIDTH+",2.5 "+Blockly.BlockSvg.TAB_WIDTH+",-7.5"),this.RTL?(b.push("M",-0.25*Blockly.BlockSvg.TAB_WIDTH+",8.4"),b.push("l",-0.45*Blockly.BlockSvg.TAB_WIDTH+",-2.1")):(b.push("V",Blockly.BlockSvg.TAB_HEIGHT-1.5),b.push("m",-0.92*Blockly.BlockSvg.TAB_WIDTH+",-0.5 q "+-0.19*Blockly.BlockSvg.TAB_WIDTH+",-5.5 0,-11"),b.push("m",0.92*Blockly.BlockSvg.TAB_WIDTH+",1 V 0.5 H 1")),this.width+=Blockly.BlockSvg.TAB_WIDTH):this.RTL||(this.squareTopLeftCorner_?b.push("V",0.5):b.push("V",Blockly.BlockSvg.CORNER_RADIUS));a.push("z")};Blockly.Events={};Blockly.Events.group_="";Blockly.Events.recordUndo=!0;Blockly.Events.disabled_=0;Blockly.Events.CREATE="create";Blockly.Events.BLOCK_CREATE=Blockly.Events.CREATE;Blockly.Events.DELETE="delete";Blockly.Events.BLOCK_DELETE=Blockly.Events.DELETE;
-Blockly.Events.CHANGE="change";Blockly.Events.BLOCK_CHANGE=Blockly.Events.CHANGE;Blockly.Events.MOVE="move";Blockly.Events.BLOCK_MOVE=Blockly.Events.MOVE;Blockly.Events.VAR_CREATE="var_create";Blockly.Events.VAR_DELETE="var_delete";Blockly.Events.VAR_RENAME="var_rename";Blockly.Events.UI="ui";Blockly.Events.FIRE_QUEUE_=[];Blockly.Events.fire=function(a){Blockly.Events.isEnabled()&&(Blockly.Events.FIRE_QUEUE_.length||setTimeout(Blockly.Events.fireNow_,0),Blockly.Events.FIRE_QUEUE_.push(a))};Blockly.Events.fireNow_=function(){for(var a=Blockly.Events.filter(Blockly.Events.FIRE_QUEUE_,!0),b=Blockly.Events.FIRE_QUEUE_.length=0,c;c=a[b];b++){var d=Blockly.Workspace.getById(c.workspaceId);d&&d.fireChangeListener(c)}};Blockly.Events.filter=function(a,b){var c=goog.array.clone(a);b||c.reverse();for(var d=[],e=Object.create(null),f=0,g;g=c[f];f++){if(!g.isNull()){var h=[g.type,g.blockId,g.workspaceId].join(" "),k=e[h];k?g.type==Blockly.Events.MOVE?(k.newParentId=g.newParentId,k.newInputName=g.newInputName,k.newCoordinate=g.newCoordinate):g.type==Blockly.Events.CHANGE&&g.element==k.element&&g.name==k.name?k.newValue=g.newValue:g.type!=Blockly.Events.UI||"click"!=g.element||"commentOpen"!=k.element&&"mutatorOpen"!=k.element&&"warningOpen"!=k.element?(e[h]=g,d.push(g)):k.newValue=g.newValue:(e[h]=g,d.push(g))}}c=d.filter(function(a){return !a.isNull()});b||c.reverse();for(f=1;g=c[f];f++){g.type==Blockly.Events.CHANGE&&"mutation"==g.element&&c.unshift(c.splice(f,1)[0])}return c};Blockly.Events.clearPendingUndo=function(){for(var a=0,b;b=Blockly.Events.FIRE_QUEUE_[a];a++){b.recordUndo=!1}};Blockly.Events.disable=function(){Blockly.Events.disabled_++};Blockly.Events.enable=function(){Blockly.Events.disabled_--};Blockly.Events.isEnabled=function(){return 0==Blockly.Events.disabled_};Blockly.Events.getGroup=function(){return Blockly.Events.group_};Blockly.Events.setGroup=function(a){Blockly.Events.group_="boolean"==typeof a?a?Blockly.utils.genUid():"":a};Blockly.Events.getDescendantIds_=function(a){var b=[];
-a=a.getDescendants();for(var c=0,d;d=a[c];c++){b[c]=d.id}return b};Blockly.Events.fromJson=function(a,b){switch(a.type){case Blockly.Events.CREATE:var c=new Blockly.Events.Create(null);break;case Blockly.Events.DELETE:c=new Blockly.Events.Delete(null);break;case Blockly.Events.CHANGE:c=new Blockly.Events.Change(null,"","","","");break;case Blockly.Events.MOVE:c=new Blockly.Events.Move(null);break;case Blockly.Events.VAR_CREATE:c=new Blockly.Events.VarCreate(null);break;case Blockly.Events.VAR_DELETE:c=new Blockly.Events.VarDelete(null);break;case Blockly.Events.VAR_RENAME:c=new Blockly.Events.VarRename(null,"");break;case Blockly.Events.UI:c=new Blockly.Events.Ui(null);break;default:throw"Unknown event type."}c.fromJson(a);c.workspaceId=b.id;return c};Blockly.Events.Abstract=function(a){this.recordUndo=this.group=this.workspaceId=this.varId=this.blockId=void 0;a instanceof Blockly.Block?(this.blockId=a.id,this.workspaceId=a.workspace.id):a instanceof Blockly.VariableModel&&(this.workspaceId=a.workspace.id,this.varId=a.getId());this.group=Blockly.Events.group_;this.recordUndo=Blockly.Events.recordUndo};Blockly.Events.Abstract.prototype.toJson=function(){var a={type:this.type};this.blockId&&(a.blockId=this.blockId);this.varId&&(a.varId=this.varId);this.group&&(a.group=this.group);return a};Blockly.Events.Abstract.prototype.fromJson=function(a){this.blockId=a.blockId;this.varId=a.varId;this.group=a.group};Blockly.Events.Abstract.prototype.isNull=function(){return !1};Blockly.Events.Abstract.prototype.run=function(a){};Blockly.Events.Abstract.prototype.getEventWorkspace_=function(){var a=Blockly.Workspace.getById(this.workspaceId);if(!a){throw Error("Workspace is null. Event must have been generated from real Blockly events.")}return a};Blockly.Events.Create=function(a){a&&(Blockly.Events.Create.superClass_.constructor.call(this,a),this.xml=a.workspace.rendered?Blockly.Xml.blockToDomWithXY(a):Blockly.Xml.blockToDom(a),this.ids=Blockly.Events.getDescendantIds_(a))};goog.inherits(Blockly.Events.Create,Blockly.Events.Abstract);
-Blockly.Events.BlockCreate=Blockly.Events.Create;Blockly.Events.Create.prototype.type=Blockly.Events.CREATE;Blockly.Events.Create.prototype.toJson=function(){var a=Blockly.Events.Create.superClass_.toJson.call(this);a.xml=Blockly.Xml.domToText(this.xml);a.ids=this.ids;return a};Blockly.Events.Create.prototype.fromJson=function(a){Blockly.Events.Create.superClass_.fromJson.call(this,a);this.xml=Blockly.Xml.textToDom("<xml>"+a.xml+"</xml>").firstChild;this.ids=a.ids};Blockly.Events.Create.prototype.run=function(a){var b=this.getEventWorkspace_();if(a){a=goog.dom.createDom("xml"),a.appendChild(this.xml),Blockly.Xml.domToWorkspace(a,b)}else{a=0;for(var c;c=this.ids[a];a++){var d=b.getBlockById(c);d?d.dispose(!1,!1):c==this.blockId&&console.warn("Can't uncreate non-existent block: "+c)}}};Blockly.Events.Delete=function(a){if(a){if(a.getParent()){throw"Connected blocks cannot be deleted."}Blockly.Events.Delete.superClass_.constructor.call(this,a);this.oldXml=a.workspace.rendered?Blockly.Xml.blockToDomWithXY(a):Blockly.Xml.blockToDom(a);this.ids=Blockly.Events.getDescendantIds_(a)}};goog.inherits(Blockly.Events.Delete,Blockly.Events.Abstract);Blockly.Events.BlockDelete=Blockly.Events.Delete;Blockly.Events.Delete.prototype.type=Blockly.Events.DELETE;Blockly.Events.Delete.prototype.toJson=function(){var a=Blockly.Events.Delete.superClass_.toJson.call(this);a.ids=this.ids;return a};Blockly.Events.Delete.prototype.fromJson=function(a){Blockly.Events.Delete.superClass_.fromJson.call(this,a);this.ids=a.ids};Blockly.Events.Delete.prototype.run=function(a){var b=this.getEventWorkspace_();if(a){a=0;for(var c;c=this.ids[a];a++){var d=b.getBlockById(c);d?d.dispose(!1,!1):c==this.blockId&&console.warn("Can't delete non-existent block: "+c)}}else{a=goog.dom.createDom("xml"),a.appendChild(this.oldXml),Blockly.Xml.domToWorkspace(a,b)}};Blockly.Events.Change=function(a,b,c,d,e){a&&(Blockly.Events.Change.superClass_.constructor.call(this,a),this.element=b,this.name=c,this.oldValue=d,this.newValue=e)
-};goog.inherits(Blockly.Events.Change,Blockly.Events.Abstract);Blockly.Events.BlockChange=Blockly.Events.Change;Blockly.Events.Change.prototype.type=Blockly.Events.CHANGE;Blockly.Events.Change.prototype.toJson=function(){var a=Blockly.Events.Change.superClass_.toJson.call(this);a.element=this.element;this.name&&(a.name=this.name);a.newValue=this.newValue;return a};Blockly.Events.Change.prototype.fromJson=function(a){Blockly.Events.Change.superClass_.fromJson.call(this,a);this.element=a.element;this.name=a.name;this.newValue=a.newValue};Blockly.Events.Change.prototype.isNull=function(){return this.oldValue==this.newValue};Blockly.Events.Change.prototype.run=function(a){var b=this.getEventWorkspace_().getBlockById(this.blockId);if(b){switch(b.mutator&&b.mutator.setVisible(!1),a=a?this.newValue:this.oldValue,this.element){case"field":(b=b.getField(this.name))?(b.callValidator(a),b.setValue(a)):console.warn("Can't set non-existent field: "+this.name);break;case"comment":b.setCommentText(a||null);break;case"collapsed":b.setCollapsed(a);break;case"disabled":b.setDisabled(a);break;case"inline":b.setInputsInline(a);break;case"mutation":var c="";b.mutationToDom&&(c=(c=b.mutationToDom())&&Blockly.Xml.domToText(c));if(b.domToMutation){a=a||"<mutation></mutation>";var d=Blockly.Xml.textToDom("<xml>"+a+"</xml>");b.domToMutation(d.firstChild)}Blockly.Events.fire(new Blockly.Events.Change(b,"mutation",null,c,a));break;default:console.warn("Unknown change type: "+this.element)}}else{console.warn("Can't change non-existent block: "+this.blockId)}};Blockly.Events.Move=function(a){a&&(Blockly.Events.Move.superClass_.constructor.call(this,a),a=this.currentLocation_(),this.oldParentId=a.parentId,this.oldInputName=a.inputName,this.oldCoordinate=a.coordinate)};goog.inherits(Blockly.Events.Move,Blockly.Events.Abstract);Blockly.Events.BlockMove=Blockly.Events.Move;Blockly.Events.Move.prototype.type=Blockly.Events.MOVE;Blockly.Events.Move.prototype.toJson=function(){var a=Blockly.Events.Move.superClass_.toJson.call(this);
-this.newParentId&&(a.newParentId=this.newParentId);this.newInputName&&(a.newInputName=this.newInputName);this.newCoordinate&&(a.newCoordinate=Math.round(this.newCoordinate.x)+","+Math.round(this.newCoordinate.y));return a};Blockly.Events.Move.prototype.fromJson=function(a){Blockly.Events.Move.superClass_.fromJson.call(this,a);this.newParentId=a.newParentId;this.newInputName=a.newInputName;a.newCoordinate&&(a=a.newCoordinate.split(","),this.newCoordinate=new goog.math.Coordinate(parseFloat(a[0]),parseFloat(a[1])))};Blockly.Events.Move.prototype.recordNew=function(){var a=this.currentLocation_();this.newParentId=a.parentId;this.newInputName=a.inputName;this.newCoordinate=a.coordinate};Blockly.Events.Move.prototype.currentLocation_=function(){var a=Blockly.Workspace.getById(this.workspaceId).getBlockById(this.blockId),b={},c=a.getParent();if(c){if(b.parentId=c.id,a=c.getInputWithBlock(a)){b.inputName=a.name}}else{b.coordinate=a.getRelativeToSurfaceXY()}return b};Blockly.Events.Move.prototype.isNull=function(){return this.oldParentId==this.newParentId&&this.oldInputName==this.newInputName&&goog.math.Coordinate.equals(this.oldCoordinate,this.newCoordinate)};Blockly.Events.Move.prototype.run=function(a){var b=this.getEventWorkspace_(),c=b.getBlockById(this.blockId);if(c){var d=a?this.newParentId:this.oldParentId,e=a?this.newInputName:this.oldInputName;a=a?this.newCoordinate:this.oldCoordinate;var f=null;if(d&&(f=b.getBlockById(d),!f)){console.warn("Can't connect to non-existent block: "+d);return}c.getParent()&&c.unplug();if(a){e=c.getRelativeToSurfaceXY(),c.moveBy(a.x-e.x,a.y-e.y)}else{c=c.outputConnection||c.previousConnection;if(e){if(b=f.getInput(e)){var g=b.connection}}else{c.type==Blockly.PREVIOUS_STATEMENT&&(g=f.nextConnection)}g?c.connect(g):console.warn("Can't connect to non-existent input: "+e)}}else{console.warn("Can't move non-existent block: "+this.blockId)}};Blockly.Events.Ui=function(a,b,c,d){Blockly.Events.Ui.superClass_.constructor.call(this,a);this.element=b;
-this.oldValue=c;this.newValue=d;this.recordUndo=!1};goog.inherits(Blockly.Events.Ui,Blockly.Events.Abstract);Blockly.Events.Ui.prototype.type=Blockly.Events.UI;Blockly.Events.Ui.prototype.toJson=function(){var a=Blockly.Events.Ui.superClass_.toJson.call(this);a.element=this.element;void 0!==this.newValue&&(a.newValue=this.newValue);return a};Blockly.Events.Ui.prototype.fromJson=function(a){Blockly.Events.Ui.superClass_.fromJson.call(this,a);this.element=a.element;this.newValue=a.newValue};Blockly.Events.VarCreate=function(a){a&&(Blockly.Events.VarCreate.superClass_.constructor.call(this,a),this.varType=a.type,this.varName=a.name)};goog.inherits(Blockly.Events.VarCreate,Blockly.Events.Abstract);Blockly.Events.VarCreate.prototype.type=Blockly.Events.VAR_CREATE;Blockly.Events.VarCreate.prototype.toJson=function(){var a=Blockly.Events.VarCreate.superClass_.toJson.call(this);a.varType=this.varType;a.varName=this.varName;return a};Blockly.Events.VarCreate.prototype.fromJson=function(a){Blockly.Events.VarCreate.superClass_.fromJson.call(this,a);this.varType=a.varType;this.varName=a.varName};Blockly.Events.VarCreate.prototype.run=function(a){var b=this.getEventWorkspace_();a?b.createVariable(this.varName,this.varType,this.varId):b.deleteVariableById(this.varId)};Blockly.Events.VarDelete=function(a){a&&(Blockly.Events.VarDelete.superClass_.constructor.call(this,a),this.varType=a.type,this.varName=a.name)};goog.inherits(Blockly.Events.VarDelete,Blockly.Events.Abstract);Blockly.Events.VarDelete.prototype.type=Blockly.Events.VAR_DELETE;Blockly.Events.VarDelete.prototype.toJson=function(){var a=Blockly.Events.VarDelete.superClass_.toJson.call(this);a.varType=this.varType;a.varName=this.varName;return a};Blockly.Events.VarDelete.prototype.fromJson=function(a){Blockly.Events.VarDelete.superClass_.fromJson.call(this,a);this.varType=a.varType;this.varName=a.varName};Blockly.Events.VarDelete.prototype.run=function(a){var b=this.getEventWorkspace_();a?b.deleteVariableById(this.varId):b.createVariable(this.varName,this.varType,this.varId)
-};Blockly.Events.VarRename=function(a,b){a&&(Blockly.Events.VarRename.superClass_.constructor.call(this,a),this.oldName=a.name,this.newName=b)};goog.inherits(Blockly.Events.VarRename,Blockly.Events.Abstract);Blockly.Events.VarRename.prototype.type=Blockly.Events.VAR_RENAME;Blockly.Events.VarRename.prototype.toJson=function(){var a=Blockly.Events.VarRename.superClass_.toJson.call(this);a.oldName=this.oldName;a.newName=this.newName;return a};Blockly.Events.VarRename.prototype.fromJson=function(a){Blockly.Events.VarRename.superClass_.fromJson.call(this,a);this.oldName=a.oldName;this.newName=a.newName};Blockly.Events.VarRename.prototype.run=function(a){var b=this.getEventWorkspace_();a?b.renameVariableById(this.varId,this.newName):b.renameVariableById(this.varId,this.oldName)};Blockly.Events.disableOrphans=function(a){if(a.type==Blockly.Events.MOVE||a.type==Blockly.Events.CREATE){Blockly.Events.disable();var b=Blockly.Workspace.getById(a.workspaceId);if(a=b.getBlockById(a.blockId)){if(a.getParent()&&!a.getParent().disabled){b=a.getDescendants();a=0;for(var c;c=b[a];a++){c.setDisabled(!1)}}else{if((a.outputConnection||a.previousConnection)&&!b.isDragging()){do{a.setDisabled(!0),a=a.getNextBlock()}while(a)}}}Blockly.Events.enable()}};Blockly.Msg={};goog.getMsgOrig=goog.getMsg;goog.getMsg=function(a,b){var c=goog.getMsg.blocklyMsgMap[a];c&&(a=Blockly.Msg[c]);return goog.getMsgOrig(a,b)};goog.getMsg.blocklyMsgMap={Today:"TODAY"};Blockly.FieldTextInput=function(a,b){Blockly.FieldTextInput.superClass_.constructor.call(this,a,b)};goog.inherits(Blockly.FieldTextInput,Blockly.Field);Blockly.FieldTextInput.FONTSIZE=11;Blockly.FieldTextInput.htmlInput_=null;Blockly.FieldTextInput.prototype.CURSOR="text";Blockly.FieldTextInput.prototype.spellcheck_=!0;Blockly.FieldTextInput.prototype.dispose=function(){Blockly.WidgetDiv.hideIfOwner(this);Blockly.FieldTextInput.superClass_.dispose.call(this)};Blockly.FieldTextInput.prototype.setValue=function(a){if(null!==a){if(this.sourceBlock_){var b=this.callValidator(a);
-null!==b&&(a=b)}Blockly.Field.prototype.setValue.call(this,a)}};Blockly.FieldTextInput.prototype.setText=function(a){null!==a&&(a=String(a),a!==this.text_&&(this.sourceBlock_&&Blockly.Events.isEnabled()&&Blockly.Events.fire(new Blockly.Events.BlockChange(this.sourceBlock_,"field",this.name,this.text_,a)),Blockly.Field.prototype.setText.call(this,a)))};Blockly.FieldTextInput.prototype.setSpellcheck=function(a){this.spellcheck_=a};Blockly.FieldTextInput.prototype.showEditor_=function(a){this.workspace_=this.sourceBlock_.workspace;a=a||!1;!a&&(goog.userAgent.MOBILE||goog.userAgent.ANDROID||goog.userAgent.IPAD)?this.showPromptEditor_():this.showInlineEditor_(a)};Blockly.FieldTextInput.prototype.showPromptEditor_=function(){var a=this;Blockly.prompt(Blockly.Msg.CHANGE_VALUE_TITLE,this.text_,function(b){a.sourceBlock_&&(b=a.callValidator(b));a.setValue(b)})};Blockly.FieldTextInput.prototype.showInlineEditor_=function(a){Blockly.WidgetDiv.show(this,this.sourceBlock_.RTL,this.widgetDispose_());var b=Blockly.WidgetDiv.DIV,c=goog.dom.createDom("INPUT","blocklyHtmlInput");c.setAttribute("spellcheck",this.spellcheck_);var d=Blockly.FieldTextInput.FONTSIZE*this.workspace_.scale+"pt";b.style.fontSize=d;c.style.fontSize=d;Blockly.FieldTextInput.htmlInput_=c;b.appendChild(c);c.value=c.defaultValue=this.text_;c.oldValue_=null;this.validate_();this.resizeEditor_();a||(c.focus(),c.select());this.bindEvents_(c)};Blockly.FieldTextInput.prototype.bindEvents_=function(a){a.onKeyDownWrapper_=Blockly.bindEventWithChecks_(a,"keydown",this,this.onHtmlInputKeyDown_);a.onKeyUpWrapper_=Blockly.bindEventWithChecks_(a,"keyup",this,this.onHtmlInputChange_);a.onKeyPressWrapper_=Blockly.bindEventWithChecks_(a,"keypress",this,this.onHtmlInputChange_);a.onWorkspaceChangeWrapper_=this.resizeEditor_.bind(this);this.workspace_.addChangeListener(a.onWorkspaceChangeWrapper_)};Blockly.FieldTextInput.prototype.unbindEvents_=function(a){Blockly.unbindEvent_(a.onKeyDownWrapper_);Blockly.unbindEvent_(a.onKeyUpWrapper_);
-Blockly.unbindEvent_(a.onKeyPressWrapper_);this.workspace_.removeChangeListener(a.onWorkspaceChangeWrapper_)};Blockly.FieldTextInput.prototype.onHtmlInputKeyDown_=function(a){var b=Blockly.FieldTextInput.htmlInput_;13==a.keyCode?Blockly.WidgetDiv.hide():27==a.keyCode?(b.value=b.defaultValue,Blockly.WidgetDiv.hide()):9==a.keyCode&&(Blockly.WidgetDiv.hide(),this.sourceBlock_.tab(this,!a.shiftKey),a.preventDefault())};Blockly.FieldTextInput.prototype.onHtmlInputChange_=function(a){a=Blockly.FieldTextInput.htmlInput_;var b=a.value;b!==a.oldValue_?(a.oldValue_=b,this.setValue(b),this.validate_()):goog.userAgent.WEBKIT&&this.sourceBlock_.render();this.resizeEditor_();Blockly.svgResize(this.sourceBlock_.workspace)};Blockly.FieldTextInput.prototype.validate_=function(){var a=!0;goog.asserts.assertObject(Blockly.FieldTextInput.htmlInput_);var b=Blockly.FieldTextInput.htmlInput_;this.sourceBlock_&&(a=this.callValidator(b.value));null===a?Blockly.utils.addClass(b,"blocklyInvalidInput"):Blockly.utils.removeClass(b,"blocklyInvalidInput")};Blockly.FieldTextInput.prototype.resizeEditor_=function(){var a=Blockly.WidgetDiv.DIV,b=this.getScaledBBox_();a.style.width=b.right-b.left+"px";a.style.height=b.bottom-b.top+"px";b=new goog.math.Coordinate(this.sourceBlock_.RTL?b.right-a.offsetWidth:b.left,b.top);b.y+=1;goog.userAgent.GECKO&&Blockly.WidgetDiv.DIV.style.top&&(--b.x,--b.y);goog.userAgent.WEBKIT&&(b.y-=3);a.style.left=b.x+"px";a.style.top=b.y+"px"};Blockly.FieldTextInput.prototype.widgetDispose_=function(){var a=this;return function(){var b=Blockly.FieldTextInput.htmlInput_;a.maybeSaveEdit_();a.unbindEvents_(b);Blockly.FieldTextInput.htmlInput_=null;Blockly.Events.setGroup(!1);b=Blockly.WidgetDiv.DIV.style;b.width="auto";b.height="auto";b.fontSize=""}};Blockly.FieldTextInput.prototype.maybeSaveEdit_=function(){var a=Blockly.FieldTextInput.htmlInput_,b=a.value;if(this.sourceBlock_){if(b=this.callValidator(b),null===b){b=a.defaultValue}else{if(this.onFinishEditing_){this.onFinishEditing_(b)
-}}}this.setText(b);this.sourceBlock_.rendered&&this.sourceBlock_.render()};Blockly.FieldTextInput.numberValidator=function(a){console.warn("Blockly.FieldTextInput.numberValidator is deprecated. Use Blockly.FieldNumber instead.");if(null===a){return null}a=String(a);a=a.replace(/O/ig,"0");a=a.replace(/,/g,"");a=parseFloat(a||0);return isNaN(a)?null:String(a)};Blockly.FieldTextInput.nonnegativeIntegerValidator=function(a){(a=Blockly.FieldTextInput.numberValidator(a))&&(a=String(Math.max(0,Math.floor(a))));return a};Blockly.FieldAngle=function(a,b){this.symbol_=Blockly.utils.createSvgElement("tspan",{},null);this.symbol_.appendChild(document.createTextNode("\u00b0"));a=a&&!isNaN(a)?String(a):"0";Blockly.FieldAngle.superClass_.constructor.call(this,a,b)};goog.inherits(Blockly.FieldAngle,Blockly.FieldTextInput);Blockly.FieldAngle.ROUND=15;Blockly.FieldAngle.HALF=50;Blockly.FieldAngle.CLOCKWISE=!1;Blockly.FieldAngle.OFFSET=0;Blockly.FieldAngle.WRAP=360;Blockly.FieldAngle.RADIUS=Blockly.FieldAngle.HALF-1;Blockly.FieldAngle.prototype.render_=function(){this.visible_?(this.textElement_.textContent=this.getDisplayText_(),this.sourceBlock_.RTL?this.textElement_.insertBefore(this.symbol_,this.textElement_.firstChild):this.textElement_.appendChild(this.symbol_),this.updateWidth()):this.size_.width=0};Blockly.FieldAngle.prototype.dispose_=function(){var a=this;return function(){Blockly.FieldAngle.superClass_.dispose_.call(a)();a.gauge_=null;a.clickWrapper_&&Blockly.unbindEvent_(a.clickWrapper_);a.moveWrapper1_&&Blockly.unbindEvent_(a.moveWrapper1_);a.moveWrapper2_&&Blockly.unbindEvent_(a.moveWrapper2_)}};Blockly.FieldAngle.prototype.showEditor_=function(){Blockly.FieldAngle.superClass_.showEditor_.call(this,goog.userAgent.MOBILE||goog.userAgent.ANDROID||goog.userAgent.IPAD);var a=Blockly.WidgetDiv.DIV;if(a.firstChild){a=Blockly.utils.createSvgElement("svg",{xmlns:"http://www.w3.org/2000/svg","xmlns:html":"http://www.w3.org/1999/xhtml","xmlns:xlink":"http://www.w3.org/1999/xlink",version:"1.1",height:2*Blockly.FieldAngle.HALF+"px",width:2*Blockly.FieldAngle.HALF+"px"},a);
-var b=Blockly.utils.createSvgElement("circle",{cx:Blockly.FieldAngle.HALF,cy:Blockly.FieldAngle.HALF,r:Blockly.FieldAngle.RADIUS,"class":"blocklyAngleCircle"},a);this.gauge_=Blockly.utils.createSvgElement("path",{"class":"blocklyAngleGauge"},a);this.line_=Blockly.utils.createSvgElement("line",{x1:Blockly.FieldAngle.HALF,y1:Blockly.FieldAngle.HALF,"class":"blocklyAngleLine"},a);for(var c=0;360>c;c+=15){Blockly.utils.createSvgElement("line",{x1:Blockly.FieldAngle.HALF+Blockly.FieldAngle.RADIUS,y1:Blockly.FieldAngle.HALF,x2:Blockly.FieldAngle.HALF+Blockly.FieldAngle.RADIUS-(0==c%45?10:5),y2:Blockly.FieldAngle.HALF,"class":"blocklyAngleMarks",transform:"rotate("+c+","+Blockly.FieldAngle.HALF+","+Blockly.FieldAngle.HALF+")"},a)}a.style.marginLeft=15-Blockly.FieldAngle.RADIUS+"px";this.clickWrapper_=Blockly.bindEvent_(a,"click",this,Blockly.WidgetDiv.hide);this.moveWrapper1_=Blockly.bindEvent_(b,"mousemove",this,this.onMouseMove);this.moveWrapper2_=Blockly.bindEvent_(this.gauge_,"mousemove",this,this.onMouseMove);this.updateGraph_()}};Blockly.FieldAngle.prototype.onMouseMove=function(a){var b=this.gauge_.ownerSVGElement.getBoundingClientRect(),c=a.clientX-b.left-Blockly.FieldAngle.HALF;a=a.clientY-b.top-Blockly.FieldAngle.HALF;b=Math.atan(-a/c);isNaN(b)||(b=goog.math.toDegrees(b),0>c?b+=180:0<a&&(b+=360),b=Blockly.FieldAngle.CLOCKWISE?Blockly.FieldAngle.OFFSET+360-b:b-Blockly.FieldAngle.OFFSET,Blockly.FieldAngle.ROUND&&(b=Math.round(b/Blockly.FieldAngle.ROUND)*Blockly.FieldAngle.ROUND),b=this.callValidator(b),Blockly.FieldTextInput.htmlInput_.value=b,this.setValue(b),this.validate_(),this.resizeEditor_())};Blockly.FieldAngle.prototype.setText=function(a){Blockly.FieldAngle.superClass_.setText.call(this,a);this.textElement_&&(this.updateGraph_(),this.size_.width=0)};Blockly.FieldAngle.prototype.updateGraph_=function(){if(this.gauge_){var a=Number(this.getText())+Blockly.FieldAngle.OFFSET,b=goog.math.toRadians(a);a=["M ",Blockly.FieldAngle.HALF,",",Blockly.FieldAngle.HALF];var c=Blockly.FieldAngle.HALF,d=Blockly.FieldAngle.HALF;
-if(!isNaN(b)){var e=goog.math.toRadians(Blockly.FieldAngle.OFFSET),f=Math.cos(e)*Blockly.FieldAngle.RADIUS,g=Math.sin(e)*-Blockly.FieldAngle.RADIUS;Blockly.FieldAngle.CLOCKWISE&&(b=2*e-b);c+=Math.cos(b)*Blockly.FieldAngle.RADIUS;d-=Math.sin(b)*Blockly.FieldAngle.RADIUS;b=Math.abs(Math.floor((b-e)/Math.PI)%2);Blockly.FieldAngle.CLOCKWISE&&(b=1-b);a.push(" l ",f,",",g," A ",Blockly.FieldAngle.RADIUS,",",Blockly.FieldAngle.RADIUS," 0 ",b," ",Number(Blockly.FieldAngle.CLOCKWISE)," ",c,",",d," z")}this.gauge_.setAttribute("d",a.join(""));this.line_.setAttribute("x2",c);this.line_.setAttribute("y2",d)}};Blockly.FieldAngle.prototype.classValidator=function(a){if(null===a){return null}a=parseFloat(a||0);if(isNaN(a)){return null}a%=360;0>a&&(a+=360);a>Blockly.FieldAngle.WRAP&&(a-=360);return String(a)};Blockly.FieldCheckbox=function(a,b){Blockly.FieldCheckbox.superClass_.constructor.call(this,"",b);this.setValue(a)};goog.inherits(Blockly.FieldCheckbox,Blockly.Field);Blockly.FieldCheckbox.CHECK_CHAR="\u2713";Blockly.FieldCheckbox.prototype.CURSOR="default";Blockly.FieldCheckbox.prototype.init=function(){if(!this.fieldGroup_){Blockly.FieldCheckbox.superClass_.init.call(this);this.checkElement_=Blockly.utils.createSvgElement("text",{"class":"blocklyText blocklyCheckbox",x:-3,y:14},this.fieldGroup_);var a=document.createTextNode(Blockly.FieldCheckbox.CHECK_CHAR);this.checkElement_.appendChild(a);this.checkElement_.style.display=this.state_?"block":"none"}};Blockly.FieldCheckbox.prototype.getValue=function(){return String(this.state_).toUpperCase()};Blockly.FieldCheckbox.prototype.setValue=function(a){a="string"==typeof a?"TRUE"==a.toUpperCase():!!a;this.state_!==a&&(this.sourceBlock_&&Blockly.Events.isEnabled()&&Blockly.Events.fire(new Blockly.Events.BlockChange(this.sourceBlock_,"field",this.name,this.state_,a)),this.state_=a,this.checkElement_&&(this.checkElement_.style.display=a?"block":"none"))};Blockly.FieldCheckbox.prototype.showEditor_=function(){var a=!this.state_;this.sourceBlock_&&(a=this.callValidator(a));
-null!==a&&this.setValue(String(a).toUpperCase())};Blockly.FieldColour=function(a,b){Blockly.FieldColour.superClass_.constructor.call(this,a,b);this.setText(Blockly.Field.NBSP+Blockly.Field.NBSP+Blockly.Field.NBSP)};goog.inherits(Blockly.FieldColour,Blockly.Field);Blockly.FieldColour.prototype.colours_=null;Blockly.FieldColour.prototype.columns_=0;Blockly.FieldColour.prototype.init=function(){Blockly.FieldColour.superClass_.init.call(this);this.borderRect_.style.fillOpacity=1;this.setValue(this.getValue())};Blockly.FieldColour.prototype.CURSOR="default";Blockly.FieldColour.prototype.dispose=function(){Blockly.WidgetDiv.hideIfOwner(this);Blockly.FieldColour.superClass_.dispose.call(this)};Blockly.FieldColour.prototype.getValue=function(){return this.colour_};Blockly.FieldColour.prototype.setValue=function(a){this.sourceBlock_&&Blockly.Events.isEnabled()&&this.colour_!=a&&Blockly.Events.fire(new Blockly.Events.BlockChange(this.sourceBlock_,"field",this.name,this.colour_,a));this.colour_=a;this.borderRect_&&(this.borderRect_.style.fill=a)};Blockly.FieldColour.prototype.getText=function(){var a=this.colour_,b=a.match(/^#(.)\1(.)\2(.)\3$/);b&&(a="#"+b[1]+b[2]+b[3]);return a};Blockly.FieldColour.COLOURS=goog.ui.ColorPicker.SIMPLE_GRID_COLORS;Blockly.FieldColour.COLUMNS=7;Blockly.FieldColour.prototype.setColours=function(a){this.colours_=a;return this};Blockly.FieldColour.prototype.setColumns=function(a){this.columns_=a;return this};Blockly.FieldColour.prototype.showEditor_=function(){Blockly.WidgetDiv.show(this,this.sourceBlock_.RTL,Blockly.FieldColour.widgetDispose_);var a=Blockly.utils.getViewportBBox(),b=this.getScaledBBox_(),c=this.createWidget_(),d=goog.style.getSize(c.getElement());Blockly.WidgetDiv.positionWithAnchor(a,b,d,this.sourceBlock_.RTL);var e=this;Blockly.FieldColour.changeEventKey_=goog.events.listen(c,goog.ui.ColorPicker.EventType.CHANGE,function(a){a=a.target.getSelectedColor()||"#000000";Blockly.WidgetDiv.hide();e.sourceBlock_&&(a=e.callValidator(a));null!==a&&e.setValue(a)
-})};Blockly.FieldColour.prototype.createWidget_=function(){var a=new goog.ui.ColorPicker;a.setSize(this.columns_||Blockly.FieldColour.COLUMNS);a.setColors(this.colours_||Blockly.FieldColour.COLOURS);a.render(Blockly.WidgetDiv.DIV);a.setSelectedColor(this.getValue());return a};Blockly.FieldColour.widgetDispose_=function(){Blockly.FieldColour.changeEventKey_&&goog.events.unlistenByKey(Blockly.FieldColour.changeEventKey_);Blockly.Events.setGroup(!1)};Blockly.FieldDropdown=function(a,b){this.menuGenerator_=a;this.trimOptions_();var c=this.getOptions()[0];Blockly.FieldDropdown.superClass_.constructor.call(this,c[1],b)};goog.inherits(Blockly.FieldDropdown,Blockly.Field);Blockly.FieldDropdown.CHECKMARK_OVERHANG=25;Blockly.FieldDropdown.ARROW_CHAR=goog.userAgent.ANDROID?"\u25bc":"\u25be";Blockly.FieldDropdown.prototype.CURSOR="default";Blockly.FieldDropdown.prototype.value_="";Blockly.FieldDropdown.prototype.imageElement_=null;Blockly.FieldDropdown.prototype.imageJson_=null;Blockly.FieldDropdown.prototype.init=function(){if(!this.fieldGroup_){this.arrow_=Blockly.utils.createSvgElement("tspan",{},null);this.arrow_.appendChild(document.createTextNode(this.sourceBlock_.RTL?Blockly.FieldDropdown.ARROW_CHAR+" ":" "+Blockly.FieldDropdown.ARROW_CHAR));Blockly.FieldDropdown.superClass_.init.call(this);var a=this.text_;this.text_=null;this.setText(a)}};Blockly.FieldDropdown.prototype.showEditor_=function(){Blockly.WidgetDiv.show(this,this.sourceBlock_.RTL,null);var a=this.createMenu_();this.addEventListeners_(a);this.positionMenu_(a)};Blockly.FieldDropdown.prototype.addEventListeners_=function(a){this.addActionListener_(a);this.addTouchStartListener_(a);this.addTouchEndListener_(a)};Blockly.FieldDropdown.prototype.addActionListener_=function(a){var b=this;goog.events.listen(a,goog.ui.Component.EventType.ACTION,function(a){if(a=a.target){b.onItemSelected(this,a)}Blockly.WidgetDiv.hideIfOwner(b);Blockly.Events.setGroup(!1)})};Blockly.FieldDropdown.prototype.addTouchStartListener_=function(a){a.getHandler().listen(a.getElement(),goog.events.EventType.TOUCHSTART,function(a){this.getOwnerControl(a.target).handleMouseDown(a)
-})};Blockly.FieldDropdown.prototype.addTouchEndListener_=function(a){a.getHandler().listen(a.getElement(),goog.events.EventType.TOUCHEND,function(a){this.getOwnerControl(a.target).performActionInternal(a)})};Blockly.FieldDropdown.prototype.createMenu_=function(){var a=new goog.ui.Menu;a.setRightToLeft(this.sourceBlock_.RTL);for(var b=this.getOptions(),c=0;c<b.length;c++){var d=b[c][0],e=b[c][1];if("object"==typeof d){var f=new Image(d.width,d.height);f.src=d.src;f.alt=d.alt||"";d=f}d=new goog.ui.MenuItem(d);d.setRightToLeft(this.sourceBlock_.RTL);d.setValue(e);d.setCheckable(!0);a.addChild(d,!0);d.setChecked(e==this.value_)}return a};Blockly.FieldDropdown.prototype.positionMenu_=function(a){var b=Blockly.utils.getViewportBBox(),c=this.getAnchorDimensions_();this.createWidget_(a);var d=Blockly.utils.uiMenu.getSize(a);this.sourceBlock_.RTL&&Blockly.utils.uiMenu.adjustBBoxesForRTL(b,c,d);Blockly.WidgetDiv.positionWithAnchor(b,c,d,this.sourceBlock_.RTL);a.getElement().focus()};Blockly.FieldDropdown.prototype.createWidget_=function(a){a.render(Blockly.WidgetDiv.DIV);Blockly.utils.addClass(a.getElement(),"blocklyDropdownMenu");a.setAllowAutoFocus(!0)};Blockly.FieldDropdown.prototype.getAnchorDimensions_=function(){var a=this.getScaledBBox_();this.sourceBlock_.RTL?a.right+=Blockly.FieldDropdown.CHECKMARK_OVERHANG:a.left-=Blockly.FieldDropdown.CHECKMARK_OVERHANG;return a};Blockly.FieldDropdown.prototype.onItemSelected=function(a,b){var c=b.getValue();this.sourceBlock_&&(c=this.callValidator(c));null!==c&&this.setValue(c)};Blockly.FieldDropdown.prototype.trimOptions_=function(){this.suffixField=this.prefixField=null;var a=this.menuGenerator_;if(goog.isArray(a)){for(var b=!1,c=0;c<a.length;c++){var d=a[c][0];"string"==typeof d?a[c][0]=Blockly.utils.replaceMessageReferences(d):(null!=d.alt&&(a[c][0].alt=Blockly.utils.replaceMessageReferences(d.alt)),b=!0)}if(!(b||2>a.length)){b=[];for(c=0;c<a.length;c++){b.push(a[c][0])}c=Blockly.utils.shortestStringLength(b);d=Blockly.utils.commonWordPrefix(b,c);
-var e=Blockly.utils.commonWordSuffix(b,c);!d&&!e||c<=d+e||(d&&(this.prefixField=b[0].substring(0,d-1)),e&&(this.suffixField=b[0].substr(1-e)),this.menuGenerator_=Blockly.FieldDropdown.applyTrim_(a,d,e))}}};Blockly.FieldDropdown.applyTrim_=function(a,b,c){for(var d=[],e=0;e<a.length;e++){var f=a[e][0],g=a[e][1];f=f.substring(b,f.length-c);d[e]=[f,g]}return d};Blockly.FieldDropdown.prototype.isOptionListDynamic=function(){return goog.isFunction(this.menuGenerator_)};Blockly.FieldDropdown.prototype.getOptions=function(){return goog.isFunction(this.menuGenerator_)?this.menuGenerator_.call(this):this.menuGenerator_};Blockly.FieldDropdown.prototype.getValue=function(){return this.value_};Blockly.FieldDropdown.prototype.setValue=function(a){if(null!==a&&a!==this.value_){this.sourceBlock_&&Blockly.Events.isEnabled()&&Blockly.Events.fire(new Blockly.Events.BlockChange(this.sourceBlock_,"field",this.name,this.value_,a));this.value_=a;for(var b=this.getOptions(),c=0;c<b.length;c++){if(b[c][1]==a){a=b[c][0];"object"==typeof a?(this.imageJson_=a,this.text_=a.alt):(this.imageJson_=null,this.text_=a);this.forceRerender();return}}this.text_=a;this.forceRerender()}};Blockly.FieldDropdown.prototype.render_=function(){this.visible_?(this.sourceBlock_&&this.arrow_&&(this.arrow_.style.fill=this.sourceBlock_.getColour()),goog.dom.removeChildren(this.textElement_),goog.dom.removeNode(this.imageElement_),this.imageElement_=null,this.imageJson_?this.renderSelectedImage_():this.renderSelectedText_(),this.borderRect_.setAttribute("height",this.size_.height-9),this.borderRect_.setAttribute("width",this.size_.width+Blockly.BlockSvg.SEP_SPACE_X)):this.size_.width=0};Blockly.FieldDropdown.prototype.renderSelectedImage_=function(){this.imageElement_=Blockly.utils.createSvgElement("image",{y:5,height:this.imageJson_.height+"px",width:this.imageJson_.width+"px"},this.fieldGroup_);this.imageElement_.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",this.imageJson_.src);this.textElement_.appendChild(this.arrow_);
-var a=Blockly.Field.getCachedWidth(this.arrow_);this.size_.height=Number(this.imageJson_.height)+19;this.size_.width=Number(this.imageJson_.width)+a;this.sourceBlock_.RTL?(this.imageElement_.setAttribute("x",a),this.textElement_.setAttribute("x",-1)):(this.textElement_.setAttribute("text-anchor","end"),this.textElement_.setAttribute("x",this.size_.width+1))};Blockly.FieldDropdown.prototype.renderSelectedText_=function(){var a=document.createTextNode(this.getDisplayText_());this.textElement_.appendChild(a);this.sourceBlock_.RTL?this.textElement_.insertBefore(this.arrow_,this.textElement_.firstChild):this.textElement_.appendChild(this.arrow_);this.textElement_.setAttribute("text-anchor","start");this.textElement_.setAttribute("x",0);this.size_.height=Blockly.BlockSvg.MIN_BLOCK_Y;this.size_.width=Blockly.Field.getCachedWidth(this.textElement_)};Blockly.FieldDropdown.prototype.updateWidth=function(){if(this.imageJson_&&(goog.userAgent.IE||goog.userAgent.EDGE)){var a=Blockly.Field.getCachedWidth(this.arrow_);a=Number(this.imageJson_.width)+a+Blockly.BlockSvg.SEP_SPACE_X;this.borderRect_&&this.borderRect_.setAttribute("width",a);this.size_.width=a}else{Blockly.Field.prototype.updateWidth.call(this)}};Blockly.FieldDropdown.prototype.dispose=function(){Blockly.WidgetDiv.hideIfOwner(this);Blockly.FieldDropdown.superClass_.dispose.call(this)};Blockly.FieldImage=function(a,b,c,d,e){this.sourceBlock_=null;this.height_=Number(c);this.width_=Number(b);this.size_=new goog.math.Size(this.width_,this.height_+2*Blockly.BlockSvg.INLINE_PADDING_Y);this.text_=d||"";this.setValue(a);"function"==typeof e&&(this.clickHandler_=e)};goog.inherits(Blockly.FieldImage,Blockly.Field);Blockly.FieldImage.prototype.EDITABLE=!1;Blockly.FieldImage.prototype.init=function(){this.fieldGroup_||(this.fieldGroup_=Blockly.utils.createSvgElement("g",{},null),this.visible_||(this.fieldGroup_.style.display="none"),this.imageElement_=Blockly.utils.createSvgElement("image",{height:this.height_+"px",width:this.width_+"px"},this.fieldGroup_),this.setValue(this.src_),this.sourceBlock_.getSvgRoot().appendChild(this.fieldGroup_),this.setTooltip(this.sourceBlock_),Blockly.Tooltip.bindMouseEvents(this.imageElement_),this.maybeAddClickHandler_())
-};Blockly.FieldImage.prototype.dispose=function(){goog.dom.removeNode(this.fieldGroup_);this.imageElement_=this.fieldGroup_=null};Blockly.FieldImage.prototype.maybeAddClickHandler_=function(){this.clickHandler_&&(this.mouseDownWrapper_=Blockly.bindEventWithChecks_(this.fieldGroup_,"mousedown",this,this.onMouseDown_))};Blockly.FieldImage.prototype.setTooltip=function(a){this.imageElement_.tooltip=a};Blockly.FieldImage.prototype.getValue=function(){return this.src_};Blockly.FieldImage.prototype.setValue=function(a){null!==a&&(this.src_=a,this.imageElement_&&this.imageElement_.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",a||""))};Blockly.FieldImage.prototype.setText=function(a){null!==a&&(this.text_=a)};Blockly.FieldImage.prototype.render_=function(){};Blockly.FieldImage.prototype.updateWidth=function(){};Blockly.FieldImage.prototype.showEditor_=function(){this.clickHandler_&&this.clickHandler_(this)};Blockly.FieldNumber=function(a,b,c,d,e){a=a&&!isNaN(a)?String(a):"0";Blockly.FieldNumber.superClass_.constructor.call(this,a,e);this.setConstraints(b,c,d)};goog.inherits(Blockly.FieldNumber,Blockly.FieldTextInput);Blockly.FieldNumber.prototype.setConstraints=function(a,b,c){c=parseFloat(c);this.precision_=isNaN(c)?0:c;a=parseFloat(a);this.min_=isNaN(a)?-Infinity:a;b=parseFloat(b);this.max_=isNaN(b)?Infinity:b;this.setValue(this.callValidator(this.getValue()))};Blockly.FieldNumber.prototype.classValidator=function(a){if(null===a){return null}a=String(a);a=a.replace(/O/ig,"0");a=a.replace(/,/g,"");a=parseFloat(a||0);if(isNaN(a)){return null}this.precision_&&isFinite(a)&&(a=Math.round(a/this.precision_)*this.precision_);a=goog.math.clamp(a,this.min_,this.max_);return String(a)};Blockly.VariableModel=function(a,b,c,d){this.workspace=a;this.name=b;this.type=c||"";this.id_=d||Blockly.utils.genUid();Blockly.Events.fire(new Blockly.Events.VarCreate(this))};Blockly.VariableModel.prototype.getId=function(){return this.id_};Blockly.VariableModel.compareByName=function(a,b){return goog.string.caseInsensitiveCompare(a.name,b.name)
-};Blockly.Variables={};Blockly.Variables.NAME_TYPE=Blockly.VARIABLE_CATEGORY_NAME;Blockly.Variables.allUsedVariables=function(a){if(a instanceof Blockly.Block){var b=a.getDescendants()}else{if(a.getAllBlocks){b=a.getAllBlocks()}else{throw"Not Block or Workspace: "+a}}a=Object.create(null);for(var c=0;c<b.length;c++){var d=b[c].getVars();if(d){for(var e=0;e<d.length;e++){var f=d[e];f&&(a[f.toLowerCase()]=f)}}}b=[];for(var g in a){b.push(a[g])}return b};Blockly.Variables.allVariables=function(a){return a instanceof Blockly.Block?(console.warn("Deprecated call to Blockly.Variables.allVariables with a block instead of a workspace.  You may want Blockly.Variables.allUsedVariables"),{}):a.getAllVariables()};Blockly.Variables.flyoutCategory=function(a){var b=[],c=goog.dom.createDom("button");c.setAttribute("text",Blockly.Msg.NEW_VARIABLE);c.setAttribute("callbackKey","CREATE_VARIABLE");a.registerButtonCallback("CREATE_VARIABLE",function(a){Blockly.Variables.createVariable(a.getTargetWorkspace())});b.push(c);a=Blockly.Variables.flyoutCategoryBlocks(a);return b=b.concat(a)};Blockly.Variables.flyoutCategoryBlocks=function(a){a=a.getVariablesOfType("");a.sort(Blockly.VariableModel.compareByName);var b=[];if(0<a.length){var c=a[0];if(Blockly.Blocks.variables_set){var d=Blockly.Blocks.math_change?8:24;d='<xml><block type="variables_set" gap="'+d+'">'+Blockly.Variables.generateVariableFieldXml_(c)+"</block></xml>";d=Blockly.Xml.textToDom(d).firstChild;b.push(d)}Blockly.Blocks.math_change&&(d=Blockly.Blocks.variables_get?20:8,d='<xml><block type="math_change" gap="'+d+'">'+Blockly.Variables.generateVariableFieldXml_(c)+'<value name="DELTA"><shadow type="math_number"><field name="NUM">1</field></shadow></value></block></xml>',d=Blockly.Xml.textToDom(d).firstChild,b.push(d));for(c=0;d=a[c];c++){Blockly.Blocks.variables_get&&(d='<xml><block type="variables_get" gap="8">'+Blockly.Variables.generateVariableFieldXml_(d)+"</block></xml>",d=Blockly.Xml.textToDom(d).firstChild,b.push(d))}}return b
-};Blockly.Variables.generateUniqueName=function(a){a=a.getAllVariables();var b="";if(a.length){for(var c=1,d=0,e="ijkmnopqrstuvwxyzabcdefgh".charAt(d);!b;){for(var f=!1,g=0;g<a.length;g++){if(a[g].name.toLowerCase()==e){f=!0;break}}f?(d++,25==d&&(d=0,c++),e="ijkmnopqrstuvwxyzabcdefgh".charAt(d),1<c&&(e+=c)):b=e}}else{b="i"}return b};Blockly.Variables.createVariable=function(a,b,c){var d=function(e){Blockly.Variables.promptName(Blockly.Msg.NEW_VARIABLE_TITLE,e,function(e){e?a.getVariable(e)?Blockly.alert(Blockly.Msg.VARIABLE_ALREADY_EXISTS.replace("%1",e.toLowerCase()),function(){d(e)}):(a.createVariable(e,c),b&&b(e)):b&&b(null)})};d("")};Blockly.Variables.renameVariable=function(a,b,c){var d=function(e){Blockly.Variables.promptName(Blockly.Msg.RENAME_VARIABLE_TITLE.replace("%1",b.name),e,function(e){if(e){var f=a.getVariable(e);f&&f.type!=b.type?Blockly.alert(Blockly.Msg.VARIABLE_ALREADY_EXISTS_FOR_ANOTHER_TYPE.replace("%1",e.toLowerCase()).replace("%2",f.type),function(){d(e)}):(a.renameVariable(b.name,e),c&&c(e))}else{c&&c(null)}})};d("")};Blockly.Variables.promptName=function(a,b,c){Blockly.prompt(a,b,function(a){a&&(a=a.replace(/[\s\xa0]+/g," ").replace(/^ | $/g,""),a==Blockly.Msg.RENAME_VARIABLE||a==Blockly.Msg.NEW_VARIABLE)&&(a=null);c(a)})};Blockly.Variables.generateVariableFieldXml_=function(a){var b=goog.dom.createDom("field");b.setAttribute("name","VAR");b.setAttribute("variabletype",a.type);b.setAttribute("id",a.getId());b.textContent=a.name;return Blockly.Xml.domToText(b)};Blockly.FieldVariable=function(a,b,c){Blockly.FieldVariable.superClass_.constructor.call(this,Blockly.FieldVariable.dropdownCreate,b);this.setValue(a||"");this.variableTypes=c};goog.inherits(Blockly.FieldVariable,Blockly.FieldDropdown);Blockly.FieldVariable.prototype.init=function(){this.fieldGroup_||(Blockly.FieldVariable.superClass_.init.call(this),this.initModel())};Blockly.FieldVariable.prototype.initModel=function(){this.getValue()||this.setValue(Blockly.Variables.generateUniqueName(this.sourceBlock_.isInFlyout?this.sourceBlock_.workspace.targetWorkspace:this.sourceBlock_.workspace));
-this.sourceBlock_.isInFlyout||this.sourceBlock_.workspace.createVariable(this.getValue())};Blockly.FieldVariable.prototype.setSourceBlock=function(a){goog.asserts.assert(!a.isShadow(),"Variable fields are not allowed to exist on shadow blocks.");Blockly.FieldVariable.superClass_.setSourceBlock.call(this,a)};Blockly.FieldVariable.prototype.getValue=function(){return this.getText()};Blockly.FieldVariable.prototype.setValue=function(a){var b=a,c=a;if(this.sourceBlock_){var d=this.sourceBlock_.workspace.getVariableById(a);if(d){c=d.name}else{if(d=this.sourceBlock_.workspace.getVariable(a)){b=d.getId()}}Blockly.Events.isEnabled()&&Blockly.Events.fire(new Blockly.Events.BlockChange(this.sourceBlock_,"field",this.name,this.value_,b))}this.value_=b;this.setText(c)};Blockly.FieldVariable.prototype.getVariableTypes_=function(){var a=this.variableTypes;if(null===a&&this.sourceBlock_){return this.sourceBlock_.workspace.getVariableTypes()}a=a||[""];if(0==a.length){throw a=this.getText(),Error("'variableTypes' of field variable "+a+" was an empty list")}return a};Blockly.FieldVariable.dropdownCreate=function(){var a=[],b=this.getText(),c=b?!0:!1,d=null;this.sourceBlock_&&(d=this.sourceBlock_.workspace);if(d){var e=this.getVariableTypes_();a=[];for(var f=0;f<e.length;f++){var g=d.getVariablesOfType(e[f]);a=a.concat(g)}for(f=0;f<a.length;f++){if(c&&goog.string.caseInsensitiveEquals(a[f].name,b)){c=!1;break}}}c&&d&&(f=d.createVariable(b),a.push(f));a.sort(Blockly.VariableModel.compareByName);c=[];for(f=0;f<a.length;f++){c[f]=[a[f].name,a[f].getId()]}c.push([Blockly.Msg.RENAME_VARIABLE,Blockly.RENAME_VARIABLE_ID]);Blockly.Msg.DELETE_VARIABLE&&c.push([Blockly.Msg.DELETE_VARIABLE.replace("%1",b),Blockly.DELETE_VARIABLE_ID]);return c};Blockly.FieldVariable.prototype.onItemSelected=function(a,b){var c=b.getValue();if(this.sourceBlock_&&this.sourceBlock_.workspace){var d=this.sourceBlock_.workspace,e=d.getVariableById(c);if(e){var f=e.name}else{if(c==Blockly.RENAME_VARIABLE_ID){c=this.getText();
-e=d.getVariable(c);Blockly.Variables.renameVariable(d,e);return}if(c==Blockly.DELETE_VARIABLE_ID){d.deleteVariable(this.getText());return}}f=this.callValidator(f)}null!==f&&this.setValue(f)};Blockly.Generator=function(a){this.name_=a;this.FUNCTION_NAME_PLACEHOLDER_REGEXP_=new RegExp(this.FUNCTION_NAME_PLACEHOLDER_,"g")};Blockly.Generator.NAME_TYPE="generated_function";Blockly.Generator.prototype.INFINITE_LOOP_TRAP=null;Blockly.Generator.prototype.STATEMENT_PREFIX=null;Blockly.Generator.prototype.INDENT="  ";Blockly.Generator.prototype.COMMENT_WRAP=60;Blockly.Generator.prototype.ORDER_OVERRIDES=[];Blockly.Generator.prototype.workspaceToCode=function(a){a||(console.warn("No workspace specified in workspaceToCode call.  Guessing."),a=Blockly.getMainWorkspace());var b=[];this.init(a);a=a.getTopBlocks(!0);for(var c=0,d;d=a[c];c++){var e=this.blockToCode(d);goog.isArray(e)&&(e=e[0]);e&&(d.outputConnection&&this.scrubNakedValue&&(e=this.scrubNakedValue(e)),b.push(e))}b=b.join("\n");b=this.finish(b);b=b.replace(/^\s+\n/,"");b=b.replace(/\n\s+$/,"\n");return b=b.replace(/[ \t]+\n/g,"\n")};Blockly.Generator.prototype.prefixLines=function(a,b){return b+a.replace(/(?!\n$)\n/g,"\n"+b)};Blockly.Generator.prototype.allNestedComments=function(a){var b=[];a=a.getDescendants();for(var c=0;c<a.length;c++){var d=a[c].getCommentText();d&&b.push(d)}b.length&&b.push("");return b.join("\n")};Blockly.Generator.prototype.blockToCode=function(a){if(!a){return""}if(a.disabled){return this.blockToCode(a.getNextBlock())}var b=this[a.type];goog.asserts.assertFunction(b,'Language "%s" does not know how to generate code for block type "%s".',this.name_,a.type);b=b.call(a,a);if(goog.isArray(b)){return goog.asserts.assert(a.outputConnection,'Expecting string from statement block "%s".',a.type),[this.scrub_(a,b[0]),b[1]]}if(goog.isString(b)){var c=a.id.replace(/\$/g,"$$$$");this.STATEMENT_PREFIX&&(b=this.STATEMENT_PREFIX.replace(/%1/g,"'"+c+"'")+b);return this.scrub_(a,b)}if(null===b){return""}goog.asserts.fail("Invalid code generated: %s",b)
-};Blockly.Generator.prototype.valueToCode=function(a,b,c){isNaN(c)&&goog.asserts.fail('Expecting valid order from block "%s".',a.type);var d=a.getInputTargetBlock(b);if(!d){return""}b=this.blockToCode(d);if(""===b){return""}goog.asserts.assertArray(b,'Expecting tuple from value block "%s".',d.type);a=b[0];b=b[1];isNaN(b)&&goog.asserts.fail('Expecting valid order from value block "%s".',d.type);if(!a){return""}d=!1;var e=Math.floor(c),f=Math.floor(b);if(e<=f&&(e!=f||0!=e&&99!=e)){for(d=!0,e=0;e<this.ORDER_OVERRIDES.length;e++){if(this.ORDER_OVERRIDES[e][0]==c&&this.ORDER_OVERRIDES[e][1]==b){d=!1;break}}}d&&(a="("+a+")");return a};Blockly.Generator.prototype.statementToCode=function(a,b){var c=a.getInputTargetBlock(b),d=this.blockToCode(c);goog.asserts.assertString(d,'Expecting code from statement block "%s".',c&&c.type);d&&(d=this.prefixLines(d,this.INDENT));return d};Blockly.Generator.prototype.addLoopTrap=function(a,b){b=b.replace(/\$/g,"$$$$");this.INFINITE_LOOP_TRAP&&(a=this.INFINITE_LOOP_TRAP.replace(/%1/g,"'"+b+"'")+a);this.STATEMENT_PREFIX&&(a+=this.prefixLines(this.STATEMENT_PREFIX.replace(/%1/g,"'"+b+"'"),this.INDENT));return a};Blockly.Generator.prototype.RESERVED_WORDS_="";Blockly.Generator.prototype.addReservedWords=function(a){this.RESERVED_WORDS_+=a+","};Blockly.Generator.prototype.FUNCTION_NAME_PLACEHOLDER_="{leCUI8hutHZI4480Dc}";Blockly.Generator.prototype.provideFunction_=function(a,b){if(!this.definitions_[a]){var c=this.variableDB_.getDistinctName(a,Blockly.Procedures.NAME_TYPE);this.functionNames_[a]=c;c=b.join("\n").replace(this.FUNCTION_NAME_PLACEHOLDER_REGEXP_,c);for(var d;d!=c;){d=c,c=c.replace(/^(( {2})*) {2}/gm,"$1\x00")}c=c.replace(/\0/g,this.INDENT);this.definitions_[a]=c}return this.functionNames_[a]};Blockly.Generator.prototype.init=void 0;Blockly.Generator.prototype.scrub_=void 0;Blockly.Generator.prototype.finish=void 0;Blockly.Generator.prototype.scrubNakedValue=void 0;Blockly.Names=function(a,b){this.variablePrefix_=b||"";this.reservedDict_=Object.create(null);
-if(a){for(var c=a.split(","),d=0;d<c.length;d++){this.reservedDict_[c[d]]=!0}}this.reset()};Blockly.Names.prototype.reset=function(){this.db_=Object.create(null);this.dbReverse_=Object.create(null)};Blockly.Names.prototype.getName=function(a,b){var c=a.toLowerCase()+"_"+b,d=b==Blockly.Variables.NAME_TYPE?this.variablePrefix_:"";if(c in this.db_){return d+this.db_[c]}var e=this.getDistinctName(a,b);this.db_[c]=e.substr(d.length);return e};Blockly.Names.prototype.getDistinctName=function(a,b){for(var c=this.safeName_(a),d="";this.dbReverse_[c+d]||c+d in this.reservedDict_;){d=d?d+1:2}c+=d;this.dbReverse_[c]=!0;return(b==Blockly.Variables.NAME_TYPE?this.variablePrefix_:"")+c};Blockly.Names.prototype.safeName_=function(a){a?(a=encodeURI(a.replace(/ /g,"_")).replace(/[^\w]/g,"_"),-1!="0123456789".indexOf(a[0])&&(a="my_"+a)):a="unnamed";return a};Blockly.Names.equals=function(a,b){return a.toLowerCase()==b.toLowerCase()};Blockly.Procedures={};Blockly.Procedures.NAME_TYPE=Blockly.PROCEDURE_CATEGORY_NAME;Blockly.Procedures.allProcedures=function(a){a=a.getAllBlocks();for(var b=[],c=[],d=0;d<a.length;d++){if(a[d].getProcedureDef){var e=a[d].getProcedureDef();e&&(e[2]?b.push(e):c.push(e))}}c.sort(Blockly.Procedures.procTupleComparator_);b.sort(Blockly.Procedures.procTupleComparator_);return[c,b]};Blockly.Procedures.procTupleComparator_=function(a,b){return a[0].toLowerCase().localeCompare(b[0].toLowerCase())};Blockly.Procedures.findLegalName=function(a,b){if(b.isInFlyout){return a}for(;!Blockly.Procedures.isLegalName_(a,b.workspace,b);){var c=a.match(/^(.*?)(\d+)$/);a=c?c[1]+(parseInt(c[2],10)+1):a+"2"}return a};Blockly.Procedures.isLegalName_=function(a,b,c){return !Blockly.Procedures.isNameUsed(a,b,c)};Blockly.Procedures.isNameUsed=function(a,b,c){b=b.getAllBlocks();for(var d=0;d<b.length;d++){if(b[d]!=c&&b[d].getProcedureDef){var e=b[d].getProcedureDef();if(Blockly.Names.equals(e[0],a)){return !0}}}return !1};Blockly.Procedures.rename=function(a){a=a.replace(/^[\s\xa0]+|[\s\xa0]+$/g,"");
-var b=Blockly.Procedures.findLegalName(a,this.sourceBlock_),c=this.text_;if(c!=a&&c!=b){a=this.sourceBlock_.workspace.getAllBlocks();for(var d=0;d<a.length;d++){a[d].renameProcedure&&a[d].renameProcedure(c,b)}}return b};Blockly.Procedures.flyoutCategory=function(a){function b(a,b){for(var d=0;d<a.length;d++){var e=a[d][0],f=a[d][1],g=goog.dom.createDom("block");g.setAttribute("type",b);g.setAttribute("gap",16);var l=goog.dom.createDom("mutation");l.setAttribute("name",e);g.appendChild(l);for(e=0;e<f.length;e++){var m=goog.dom.createDom("arg");m.setAttribute("name",f[e]);l.appendChild(m)}c.push(g)}}var c=[];if(Blockly.Blocks.procedures_defnoreturn){var d=goog.dom.createDom("block");d.setAttribute("type","procedures_defnoreturn");d.setAttribute("gap",16);var e=goog.dom.createDom("field",null,Blockly.Msg.PROCEDURES_DEFNORETURN_PROCEDURE);e.setAttribute("name","NAME");d.appendChild(e);c.push(d)}Blockly.Blocks.procedures_defreturn&&(d=goog.dom.createDom("block"),d.setAttribute("type","procedures_defreturn"),d.setAttribute("gap",16),e=goog.dom.createDom("field",null,Blockly.Msg.PROCEDURES_DEFRETURN_PROCEDURE),e.setAttribute("name","NAME"),d.appendChild(e),c.push(d));Blockly.Blocks.procedures_ifreturn&&(d=goog.dom.createDom("block"),d.setAttribute("type","procedures_ifreturn"),d.setAttribute("gap",16),c.push(d));c.length&&c[c.length-1].setAttribute("gap",24);a=Blockly.Procedures.allProcedures(a);b(a[0],"procedures_callnoreturn");b(a[1],"procedures_callreturn");return c};Blockly.Procedures.getCallers=function(a,b){for(var c=[],d=b.getAllBlocks(),e=0;e<d.length;e++){if(d[e].getProcedureCall){var f=d[e].getProcedureCall();f&&Blockly.Names.equals(f,a)&&c.push(d[e])}}return c};Blockly.Procedures.mutateCallers=function(a){var b=Blockly.Events.recordUndo,c=a.getProcedureDef()[0],d=a.mutationToDom(!0);a=Blockly.Procedures.getCallers(c,a.workspace);c=0;for(var e;e=a[c];c++){var f=e.mutationToDom();f=f&&Blockly.Xml.domToText(f);e.domToMutation(d);var g=e.mutationToDom();g=g&&Blockly.Xml.domToText(g);
-f!=g&&(Blockly.Events.recordUndo=!1,Blockly.Events.fire(new Blockly.Events.BlockChange(e,"mutation",null,f,g)),Blockly.Events.recordUndo=b)}};Blockly.Procedures.getDefinition=function(a,b){for(var c=b.getTopBlocks(!1),d=0;d<c.length;d++){if(c[d].getProcedureDef){var e=c[d].getProcedureDef();if(e&&Blockly.Names.equals(e[0],a)){return c[d]}}}return null};Blockly.FlyoutButton=function(a,b,c,d){this.workspace_=a;this.targetWorkspace_=b;this.text_=c.getAttribute("text");this.position_=new goog.math.Coordinate(0,0);this.isLabel_=d;this.callback_=null;a=c.getAttribute("callbackKey");this.isLabel_&&a?console.warn("Labels should not have callbacks. Label text: "+this.text_):this.isLabel_||a&&b.getButtonCallback(a)?this.callback_=b.getButtonCallback(a):console.warn("Buttons should have callbacks. Button text: "+this.text_);this.cssClass_=c.getAttribute("web-class")||null};Blockly.FlyoutButton.MARGIN=5;Blockly.FlyoutButton.prototype.width=0;Blockly.FlyoutButton.prototype.height=0;Blockly.FlyoutButton.prototype.onMouseUpWrapper_=null;Blockly.FlyoutButton.prototype.createDom=function(){var a=this.isLabel_?"blocklyFlyoutLabel":"blocklyFlyoutButton";this.cssClass_&&(a+=" "+this.cssClass_);this.svgGroup_=Blockly.utils.createSvgElement("g",{"class":a},this.workspace_.getCanvas());if(!this.isLabel_){var b=Blockly.utils.createSvgElement("rect",{"class":"blocklyFlyoutButtonShadow",rx:4,ry:4,x:1,y:1},this.svgGroup_)}a=Blockly.utils.createSvgElement("rect",{"class":this.isLabel_?"blocklyFlyoutLabelBackground":"blocklyFlyoutButtonBackground",rx:4,ry:4},this.svgGroup_);var c=Blockly.utils.createSvgElement("text",{"class":this.isLabel_?"blocklyFlyoutLabelText":"blocklyText",x:0,y:0,"text-anchor":"middle"},this.svgGroup_);c.textContent=this.text_;this.width=Blockly.Field.getCachedWidth(c);this.height=20;this.isLabel_||(this.width+=2*Blockly.FlyoutButton.MARGIN,b.setAttribute("width",this.width),b.setAttribute("height",this.height));a.setAttribute("width",this.width);a.setAttribute("height",this.height);
-c.setAttribute("x",this.width/2);c.setAttribute("y",this.height-Blockly.FlyoutButton.MARGIN);this.updateTransform_();this.mouseUpWrapper_=Blockly.bindEventWithChecks_(this.svgGroup_,"mouseup",this,this.onMouseUp_);return this.svgGroup_};Blockly.FlyoutButton.prototype.show=function(){this.updateTransform_();this.svgGroup_.setAttribute("display","block")};Blockly.FlyoutButton.prototype.updateTransform_=function(){this.svgGroup_.setAttribute("transform","translate("+this.position_.x+","+this.position_.y+")")};Blockly.FlyoutButton.prototype.moveTo=function(a,b){this.position_.x=a;this.position_.y=b;this.updateTransform_()};Blockly.FlyoutButton.prototype.getPosition=function(){return this.position_};Blockly.FlyoutButton.prototype.getTargetWorkspace=function(){return this.targetWorkspace_};Blockly.FlyoutButton.prototype.dispose=function(){this.onMouseUpWrapper_&&Blockly.unbindEvent_(this.onMouseUpWrapper_);this.svgGroup_&&(goog.dom.removeNode(this.svgGroup_),this.svgGroup_=null);this.targetWorkspace_=this.workspace_=null};Blockly.FlyoutButton.prototype.onMouseUp_=function(a){(a=this.targetWorkspace_.getGesture(a))&&a.cancel();this.callback_&&this.callback_(this)};Blockly.Flyout=function(a){a.getMetrics=this.getMetrics_.bind(this);a.setMetrics=this.setMetrics_.bind(this);this.workspace_=new Blockly.WorkspaceSvg(a);this.workspace_.isFlyout=!0;this.RTL=!!a.RTL;this.toolboxPosition_=a.toolboxPosition;this.eventWrappers_=[];this.mats_=[];this.buttons_=[];this.listeners_=[];this.permanentlyDisabled_=[]};Blockly.Flyout.prototype.autoClose=!0;Blockly.Flyout.prototype.isVisible_=!1;Blockly.Flyout.prototype.containerVisible_=!0;Blockly.Flyout.prototype.CORNER_RADIUS=8;Blockly.Flyout.prototype.MARGIN=Blockly.Flyout.prototype.CORNER_RADIUS;Blockly.Flyout.prototype.GAP_X=3*Blockly.Flyout.prototype.MARGIN;Blockly.Flyout.prototype.GAP_Y=3*Blockly.Flyout.prototype.MARGIN;Blockly.Flyout.prototype.SCROLLBAR_PADDING=2;Blockly.Flyout.prototype.width_=0;Blockly.Flyout.prototype.height_=0;Blockly.Flyout.prototype.dragAngleRange_=70;
-Blockly.Flyout.prototype.createDom=function(a){this.svgGroup_=Blockly.utils.createSvgElement(a,{"class":"blocklyFlyout",style:"display: none"},null);this.svgBackground_=Blockly.utils.createSvgElement("path",{"class":"blocklyFlyoutBackground"},this.svgGroup_);this.svgGroup_.appendChild(this.workspace_.createDom());return this.svgGroup_};Blockly.Flyout.prototype.init=function(a){this.targetWorkspace_=a;this.workspace_.targetWorkspace=a;this.scrollbar_=new Blockly.Scrollbar(this.workspace_,this.horizontalLayout_,!1,"blocklyFlyoutScrollbar");this.hide();Array.prototype.push.apply(this.eventWrappers_,Blockly.bindEventWithChecks_(this.svgGroup_,"wheel",this,this.wheel_));this.autoClose||(this.filterWrapper_=this.filterForCapacity_.bind(this),this.targetWorkspace_.addChangeListener(this.filterWrapper_));Array.prototype.push.apply(this.eventWrappers_,Blockly.bindEventWithChecks_(this.svgBackground_,"mousedown",this,this.onMouseDown_));this.workspace_.getGesture=this.targetWorkspace_.getGesture.bind(this.targetWorkspace_);this.workspace_.getVariable=this.targetWorkspace_.getVariable.bind(this.targetWorkspace_);this.workspace_.getVariableById=this.targetWorkspace_.getVariableById.bind(this.targetWorkspace_);this.workspace_.getVariablesOfType=this.targetWorkspace_.getVariablesOfType.bind(this.targetWorkspace_);this.workspace_.deleteVariable=this.targetWorkspace_.deleteVariable.bind(this.targetWorkspace_);this.workspace_.deleteVariableById=this.targetWorkspace_.deleteVariableById.bind(this.targetWorkspace_);this.workspace_.renameVariable=this.targetWorkspace_.renameVariable.bind(this.targetWorkspace_);this.workspace_.renameVariableById=this.targetWorkspace_.renameVariableById.bind(this.targetWorkspace_)};Blockly.Flyout.prototype.dispose=function(){this.hide();Blockly.unbindEvent_(this.eventWrappers_);this.filterWrapper_&&(this.targetWorkspace_.removeChangeListener(this.filterWrapper_),this.filterWrapper_=null);this.scrollbar_&&(this.scrollbar_.dispose(),this.scrollbar_=null);this.workspace_&&(this.workspace_.targetWorkspace=null,this.workspace_.dispose(),this.workspace_=null);
-this.svgGroup_&&(goog.dom.removeNode(this.svgGroup_),this.svgGroup_=null);this.targetWorkspace_=this.svgBackground_=null};Blockly.Flyout.prototype.getWidth=function(){return this.width_};Blockly.Flyout.prototype.getHeight=function(){return this.height_};Blockly.Flyout.prototype.getWorkspace=function(){return this.workspace_};Blockly.Flyout.prototype.isVisible=function(){return this.isVisible_};Blockly.Flyout.prototype.setVisible=function(a){var b=a!=this.isVisible();this.isVisible_=a;b&&this.updateDisplay_()};Blockly.Flyout.prototype.setContainerVisible=function(a){var b=a!=this.containerVisible_;this.containerVisible_=a;b&&this.updateDisplay_()};Blockly.Flyout.prototype.updateDisplay_=function(){var a=this.containerVisible_?this.isVisible():!1;this.svgGroup_.style.display=a?"block":"none";this.scrollbar_.setContainerVisible(a)};Blockly.Flyout.prototype.positionAt_=function(a,b,c,d){this.svgGroup_.setAttribute("width",a);this.svgGroup_.setAttribute("height",b);Blockly.utils.setCssTransform(this.svgGroup_,"translate("+c+"px,"+d+"px)");this.scrollbar_&&(this.scrollbar_.setOrigin(c,d),this.scrollbar_.resize())};Blockly.Flyout.prototype.hide=function(){if(this.isVisible()){this.setVisible(!1);for(var a=0,b;b=this.listeners_[a];a++){Blockly.unbindEvent_(b)}this.listeners_.length=0;this.reflowWrapper_&&(this.workspace_.removeChangeListener(this.reflowWrapper_),this.reflowWrapper_=null)}};Blockly.Flyout.prototype.show=function(a){this.workspace_.setResizesEnabled(!1);this.hide();this.clearOldBlocks_();"string"==typeof a&&(a=this.workspace_.targetWorkspace.getToolboxCategoryCallback(a),goog.asserts.assert(goog.isFunction(a),"Couldn't find a callback function when opening a toolbox category."),a=a(this.workspace_.targetWorkspace),goog.asserts.assert(goog.isArray(a),"The result of a toolbox category callback must be an array."));this.setVisible(!0);for(var b=[],c=[],d=this.permanentlyDisabled_.length=0,e;e=a[d];d++){if(e.tagName){var f=e.tagName.toUpperCase(),g=this.horizontalLayout_?this.GAP_X:this.GAP_Y;
-if("BLOCK"==f){f=Blockly.Xml.domToBlock(e,this.workspace_),f.disabled&&this.permanentlyDisabled_.push(f),b.push({type:"block",block:f}),e=parseInt(e.getAttribute("gap"),10),c.push(isNaN(e)?g:e)}else{if("SEP"==e.tagName.toUpperCase()){e=parseInt(e.getAttribute("gap"),10),!isNaN(e)&&0<c.length?c[c.length-1]=e:c.push(g)}else{if("BUTTON"==f||"LABEL"==f){e=new Blockly.FlyoutButton(this.workspace_,this.targetWorkspace_,e,"LABEL"==f),b.push({type:"button",button:e}),c.push(g)}}}}}this.layout_(b,c);this.listeners_.push(Blockly.bindEventWithChecks_(this.svgBackground_,"mouseover",this,function(){for(var a=this.workspace_.getTopBlocks(!1),b=0,c;c=a[b];b++){c.removeSelect()}}));this.horizontalLayout_?this.height_=0:this.width_=0;this.workspace_.setResizesEnabled(!0);this.reflow();this.filterForCapacity_();this.position();this.reflowWrapper_=this.reflow.bind(this);this.workspace_.addChangeListener(this.reflowWrapper_)};Blockly.Flyout.prototype.clearOldBlocks_=function(){for(var a=this.workspace_.getTopBlocks(!1),b=0,c;c=a[b];b++){c.workspace==this.workspace_&&c.dispose(!1,!1)}for(b=0;b<this.mats_.length;b++){(a=this.mats_[b])&&goog.dom.removeNode(a)}for(b=this.mats_.length=0;a=this.buttons_[b];b++){a.dispose()}this.buttons_.length=0};Blockly.Flyout.prototype.addBlockListeners_=function(a,b,c){this.listeners_.push(Blockly.bindEventWithChecks_(a,"mousedown",null,this.blockMouseDown_(b)));this.listeners_.push(Blockly.bindEventWithChecks_(c,"mousedown",null,this.blockMouseDown_(b)));this.listeners_.push(Blockly.bindEvent_(a,"mouseover",b,b.addSelect));this.listeners_.push(Blockly.bindEvent_(a,"mouseout",b,b.removeSelect));this.listeners_.push(Blockly.bindEvent_(c,"mouseover",b,b.addSelect));this.listeners_.push(Blockly.bindEvent_(c,"mouseout",b,b.removeSelect))};Blockly.Flyout.prototype.blockMouseDown_=function(a){var b=this;return function(c){var d=b.targetWorkspace_.getGesture(c);d&&(d.setStartBlock(a),d.handleFlyoutStart(c,b))}};Blockly.Flyout.prototype.onMouseDown_=function(a){var b=this.targetWorkspace_.getGesture(a);
-b&&b.handleFlyoutStart(a,this)};Blockly.Flyout.prototype.createBlock=function(a){var b=null;Blockly.Events.disable();this.targetWorkspace_.setResizesEnabled(!1);try{b=this.placeNewBlock_(a),Blockly.hideChaff()}finally{Blockly.Events.enable()}Blockly.Events.isEnabled()&&(Blockly.Events.setGroup(!0),Blockly.Events.fire(new Blockly.Events.Create(b)));this.autoClose?this.hide():this.filterForCapacity_();return b};Blockly.Flyout.prototype.initFlyoutButton_=function(a,b,c){var d=a.createDom();a.moveTo(b,c);a.show();this.listeners_.push(Blockly.bindEventWithChecks_(d,"mousedown",this,this.onMouseDown_));this.buttons_.push(a)};Blockly.Flyout.prototype.createRect_=function(a,b,c,d,e){b=Blockly.utils.createSvgElement("rect",{"fill-opacity":0,x:b,y:c,height:d.height,width:d.width},null);b.tooltip=a;Blockly.Tooltip.bindMouseEvents(b);this.workspace_.getCanvas().insertBefore(b,a.getSvgRoot());a.flyoutRect_=b;return this.mats_[e]=b};Blockly.Flyout.prototype.moveRectToBlock_=function(a,b){var c=b.getHeightWidth();a.setAttribute("width",c.width);a.setAttribute("height",c.height);var d=b.startHat_?Blockly.BlockSvg.START_HAT_HEIGHT:0;d&&b.moveBy(0,d);d=b.outputConnection?Blockly.BlockSvg.TAB_WIDTH:0;var e=b.getRelativeToSurfaceXY();a.setAttribute("y",e.y);a.setAttribute("x",this.RTL?e.x-c.width+d:e.x-d)};Blockly.Flyout.prototype.filterForCapacity_=function(){for(var a=this.targetWorkspace_.remainingCapacity(),b=this.workspace_.getTopBlocks(!1),c=0,d;d=b[c];c++){if(-1==this.permanentlyDisabled_.indexOf(d)){var e=d.getDescendants();d.setDisabled(e.length>a)}}};Blockly.Flyout.prototype.reflow=function(){this.reflowWrapper_&&this.workspace_.removeChangeListener(this.reflowWrapper_);this.reflowInternal_();this.reflowWrapper_&&this.workspace_.addChangeListener(this.reflowWrapper_)};Blockly.Flyout.prototype.isScrollable=function(){return this.scrollbar_?this.scrollbar_.isVisible():!1};Blockly.Flyout.prototype.placeNewBlock_=function(a){var b=this.targetWorkspace_;if(!a.getSvgRoot()){throw"oldBlock is not rendered."
-}var c=Blockly.Xml.blockToDom(a);b.setResizesEnabled(!1);c=Blockly.Xml.domToBlock(c,b);if(!c.getSvgRoot()){throw"block is not rendered."}var d=b.getOriginOffsetInPixels(),e=this.workspace_.getOriginOffsetInPixels();a=a.getRelativeToSurfaceXY().scale(this.workspace_.scale);a=goog.math.Coordinate.sum(e,a);b=goog.math.Coordinate.difference(a,d).scale(1/b.scale);c.moveBy(b.x,b.y);return c};Blockly.HorizontalFlyout=function(a){a.getMetrics=this.getMetrics_.bind(this);a.setMetrics=this.setMetrics_.bind(this);Blockly.HorizontalFlyout.superClass_.constructor.call(this,a);this.horizontalLayout_=!0};goog.inherits(Blockly.HorizontalFlyout,Blockly.Flyout);Blockly.HorizontalFlyout.prototype.getMetrics_=function(){if(!this.isVisible()){return null}try{var a=this.workspace_.getCanvas().getBBox()}catch(e){a={height:0,y:0,width:0,x:0}}var b=this.SCROLLBAR_PADDING,c=this.SCROLLBAR_PADDING;this.toolboxPosition_==Blockly.TOOLBOX_AT_BOTTOM&&(b=0);var d=this.height_;this.toolboxPosition_==Blockly.TOOLBOX_AT_TOP&&(d-=this.SCROLLBAR_PADDING);return{viewHeight:d,viewWidth:this.width_-2*this.SCROLLBAR_PADDING,contentHeight:(a.height+2*this.MARGIN)*this.workspace_.scale,contentWidth:(a.width+2*this.MARGIN)*this.workspace_.scale,viewTop:-this.workspace_.scrollY,viewLeft:-this.workspace_.scrollX,contentTop:a.y,contentLeft:a.x,absoluteTop:b,absoluteLeft:c}};Blockly.HorizontalFlyout.prototype.setMetrics_=function(a){var b=this.getMetrics_();b&&(goog.isNumber(a.x)&&(this.workspace_.scrollX=-b.contentWidth*a.x),this.workspace_.translate(this.workspace_.scrollX+b.absoluteLeft,this.workspace_.scrollY+b.absoluteTop))};Blockly.HorizontalFlyout.prototype.position=function(){if(this.isVisible()){var a=this.targetWorkspace_.getMetrics();if(a){this.width_=a.viewWidth;this.setBackgroundPath_(a.viewWidth-2*this.CORNER_RADIUS,this.height_-this.CORNER_RADIUS);var b=a.absoluteLeft,c=a.absoluteTop;this.toolboxPosition_==Blockly.TOOLBOX_AT_BOTTOM&&(c+=a.viewHeight-this.height_);this.positionAt_(this.width_,this.height_,b,c)
-}}};Blockly.HorizontalFlyout.prototype.setBackgroundPath_=function(a,b){var c=this.toolboxPosition_==Blockly.TOOLBOX_AT_TOP,d=["M 0,"+(c?0:this.CORNER_RADIUS)];c?(d.push("h",a+2*this.CORNER_RADIUS),d.push("v",b),d.push("a",this.CORNER_RADIUS,this.CORNER_RADIUS,0,0,1,-this.CORNER_RADIUS,this.CORNER_RADIUS),d.push("h",-1*a),d.push("a",this.CORNER_RADIUS,this.CORNER_RADIUS,0,0,1,-this.CORNER_RADIUS,-this.CORNER_RADIUS)):(d.push("a",this.CORNER_RADIUS,this.CORNER_RADIUS,0,0,1,this.CORNER_RADIUS,-this.CORNER_RADIUS),d.push("h",a),d.push("a",this.CORNER_RADIUS,this.CORNER_RADIUS,0,0,1,this.CORNER_RADIUS,this.CORNER_RADIUS),d.push("v",b),d.push("h",-a-2*this.CORNER_RADIUS));d.push("z");this.svgBackground_.setAttribute("d",d.join(" "))};Blockly.HorizontalFlyout.prototype.scrollToStart=function(){this.scrollbar_.set(this.RTL?Infinity:0)};Blockly.HorizontalFlyout.prototype.wheel_=function(a){var b=a.deltaX;if(b){goog.userAgent.GECKO&&1===a.deltaMode&&(b*=10);var c=this.getMetrics_();b=c.viewLeft+b;b=Math.min(b,c.contentWidth-c.viewWidth);b=Math.max(b,0);this.scrollbar_.set(b);Blockly.WidgetDiv.hide()}a.preventDefault();a.stopPropagation()};Blockly.HorizontalFlyout.prototype.layout_=function(a,b){this.workspace_.scale=this.targetWorkspace_.scale;var c=this.MARGIN,d=this.RTL?c:c+Blockly.BlockSvg.TAB_WIDTH;this.RTL&&(a=a.reverse());for(var e=0,f;f=a[e];e++){if("block"==f.type){f=f.block;for(var g=f.getDescendants(),h=0,k;k=g[h];h++){k.isInFlyout=!0}f.render();g=f.getSvgRoot();h=f.getHeightWidth();k=f.outputConnection?Blockly.BlockSvg.TAB_WIDTH:0;k=this.RTL?d+h.width:d+k;f.moveBy(k,c);k=this.createRect_(f,k,c,h,e);d+=h.width+b[e];this.addBlockListeners_(g,f,k)}else{"button"==f.type&&(this.initFlyoutButton_(f.button,d,c),d+=f.button.width+b[e])}}};Blockly.HorizontalFlyout.prototype.isDragTowardWorkspace=function(a){a=Math.atan2(a.y,a.x)/Math.PI*180;var b=this.dragAngleRange_;if(this.toolboxPosition_==Blockly.TOOLBOX_AT_TOP){if(a<90+b&&a>90-b){return !0}}else{if(a>-90-b&&a<-90+b){return !0
-}}return !1};Blockly.HorizontalFlyout.prototype.getClientRect=function(){if(!this.svgGroup_){return null}var a=this.svgGroup_.getBoundingClientRect(),b=a.top;a=a.height;if(this.toolboxPosition_==Blockly.TOOLBOX_AT_TOP){return new goog.math.Rect(-1000000000,b-1000000000,2000000000,1000000000+a)}if(this.toolboxPosition_==Blockly.TOOLBOX_AT_BOTTOM){return new goog.math.Rect(-1000000000,b,2000000000,1000000000+a)}};Blockly.HorizontalFlyout.prototype.reflowInternal_=function(){this.workspace_.scale=this.targetWorkspace_.scale;for(var a=0,b=this.workspace_.getTopBlocks(!1),c=0,d;d=b[c];c++){a=Math.max(a,d.getHeightWidth().height)}a+=1.5*this.MARGIN;a*=this.workspace_.scale;a+=Blockly.Scrollbar.scrollbarThickness;if(this.height_!=a){for(c=0;d=b[c];c++){d.flyoutRect_&&this.moveRectToBlock_(d.flyoutRect_,d)}this.height_=a;this.targetWorkspace_.resize()}};Blockly.VerticalFlyout=function(a){a.getMetrics=this.getMetrics_.bind(this);a.setMetrics=this.setMetrics_.bind(this);Blockly.VerticalFlyout.superClass_.constructor.call(this,a);this.horizontalLayout_=!1};goog.inherits(Blockly.VerticalFlyout,Blockly.Flyout);Blockly.VerticalFlyout.prototype.getMetrics_=function(){if(!this.isVisible()){return null}try{var a=this.workspace_.getCanvas().getBBox()}catch(e){a={height:0,y:0,width:0,x:0}}var b=this.SCROLLBAR_PADDING,c=this.height_-2*this.SCROLLBAR_PADDING,d=this.width_;this.RTL||(d-=this.SCROLLBAR_PADDING);return{viewHeight:c,viewWidth:d,contentHeight:a.height*this.workspace_.scale+2*this.MARGIN,contentWidth:a.width*this.workspace_.scale+2*this.MARGIN,viewTop:-this.workspace_.scrollY+a.y,viewLeft:-this.workspace_.scrollX,contentTop:a.y,contentLeft:a.x,absoluteTop:b,absoluteLeft:0}};Blockly.VerticalFlyout.prototype.setMetrics_=function(a){var b=this.getMetrics_();b&&(goog.isNumber(a.y)&&(this.workspace_.scrollY=-b.contentHeight*a.y),this.workspace_.translate(this.workspace_.scrollX+b.absoluteLeft,this.workspace_.scrollY+b.absoluteTop))};Blockly.VerticalFlyout.prototype.position=function(){if(this.isVisible()){var a=this.targetWorkspace_.getMetrics();
-if(a){this.height_=a.viewHeight;this.setBackgroundPath_(this.width_-this.CORNER_RADIUS,a.viewHeight-2*this.CORNER_RADIUS);var b=a.absoluteTop,c=a.absoluteLeft;this.toolboxPosition_==Blockly.TOOLBOX_AT_RIGHT&&(c+=a.viewWidth-this.width_);this.positionAt_(this.width_,this.height_,c,b)}}};Blockly.VerticalFlyout.prototype.setBackgroundPath_=function(a,b){var c=this.toolboxPosition_==Blockly.TOOLBOX_AT_RIGHT,d=a+this.CORNER_RADIUS;d=["M "+(c?d:0)+",0"];d.push("h",c?-a:a);d.push("a",this.CORNER_RADIUS,this.CORNER_RADIUS,0,0,c?0:1,c?-this.CORNER_RADIUS:this.CORNER_RADIUS,this.CORNER_RADIUS);d.push("v",Math.max(0,b));d.push("a",this.CORNER_RADIUS,this.CORNER_RADIUS,0,0,c?0:1,c?this.CORNER_RADIUS:-this.CORNER_RADIUS,this.CORNER_RADIUS);d.push("h",c?a:-a);d.push("z");this.svgBackground_.setAttribute("d",d.join(" "))};Blockly.VerticalFlyout.prototype.scrollToStart=function(){this.scrollbar_.set(0)};Blockly.VerticalFlyout.prototype.wheel_=function(a){var b=a.deltaY;if(b){goog.userAgent.GECKO&&(b*=10);var c=this.getMetrics_();b=c.viewTop-c.contentTop+b;b=Math.min(b,c.contentHeight-c.viewHeight);b=Math.max(b,0);this.scrollbar_.set(b);Blockly.WidgetDiv.hide()}a.preventDefault();a.stopPropagation()};Blockly.VerticalFlyout.prototype.layout_=function(a,b){this.workspace_.scale=this.targetWorkspace_.scale;for(var c=this.MARGIN,d=this.RTL?c:c+Blockly.BlockSvg.TAB_WIDTH,e=0,f;f=a[e];e++){if("block"==f.type){f=f.block;for(var g=f.getDescendants(),h=0,k;k=g[h];h++){k.isInFlyout=!0}f.render();g=f.getSvgRoot();h=f.getHeightWidth();f.moveBy(d,c);k=this.createRect_(f,this.RTL?d-h.width:d,c,h,e);this.addBlockListeners_(g,f,k);c+=h.height+b[e]}else{"button"==f.type&&(this.initFlyoutButton_(f.button,d,c),c+=f.button.height+b[e])}}};Blockly.VerticalFlyout.prototype.isDragTowardWorkspace=function(a){a=Math.atan2(a.y,a.x)/Math.PI*180;var b=this.dragAngleRange_;if(this.toolboxPosition_==Blockly.TOOLBOX_AT_LEFT){if(a<b&&a>-b){return !0}}else{if(a<-180+b||a>180-b){return !0}}return !1};Blockly.VerticalFlyout.prototype.getClientRect=function(){if(!this.svgGroup_){return null
-}var a=this.svgGroup_.getBoundingClientRect(),b=a.left;a=a.width;return this.toolboxPosition_==Blockly.TOOLBOX_AT_LEFT?new goog.math.Rect(b-1000000000,-1000000000,1000000000+a,2000000000):new goog.math.Rect(b,-1000000000,1000000000+a,2000000000)};Blockly.VerticalFlyout.prototype.reflowInternal_=function(){this.workspace_.scale=this.targetWorkspace_.scale;for(var a=0,b=this.workspace_.getTopBlocks(!1),c=0,d;d=b[c];c++){var e=d.getHeightWidth().width;d.outputConnection&&(e-=Blockly.BlockSvg.TAB_WIDTH);a=Math.max(a,e)}for(c=0;d=this.buttons_[c];c++){a=Math.max(a,d.width)}a+=1.5*this.MARGIN+Blockly.BlockSvg.TAB_WIDTH;a*=this.workspace_.scale;a+=Blockly.Scrollbar.scrollbarThickness;if(this.width_!=a){for(c=0;d=b[c];c++){this.RTL&&(e=d.getRelativeToSurfaceXY().x,d.moveBy(a/this.workspace_.scale-this.MARGIN-Blockly.BlockSvg.TAB_WIDTH-e,0)),d.flyoutRect_&&this.moveRectToBlock_(d.flyoutRect_,d)}if(this.RTL){for(c=0;d=this.buttons_[c];c++){b=d.getPosition().y,d.moveTo(a-d.width-this.MARGIN-Blockly.BlockSvg.TAB_WIDTH,b)}}this.width_=a;this.targetWorkspace_.resize()}};Blockly.Toolbox=function(a){this.workspace_=a;this.RTL=a.options.RTL;this.horizontalLayout_=a.options.horizontalLayout;this.toolboxPosition=a.options.toolboxPosition;this.config_={indentWidth:19,cssRoot:"blocklyTreeRoot",cssHideRoot:"blocklyHidden",cssItem:"",cssTreeRow:"blocklyTreeRow",cssItemLabel:"blocklyTreeLabel",cssTreeIcon:"blocklyTreeIcon",cssExpandedFolderIcon:"blocklyTreeIconOpen",cssFileIcon:"blocklyTreeIconNone",cssSelectedRow:"blocklyTreeSelected"};this.treeSeparatorConfig_={cssTreeRow:"blocklyTreeSeparator"};this.horizontalLayout_&&(this.config_.cssTreeRow+=a.RTL?" blocklyHorizontalTreeRtl":" blocklyHorizontalTree",this.treeSeparatorConfig_.cssTreeRow="blocklyTreeSeparatorHorizontal "+(a.RTL?"blocklyHorizontalTreeRtl":"blocklyHorizontalTree"),this.config_.cssTreeIcon="")};Blockly.Toolbox.prototype.width=0;Blockly.Toolbox.prototype.height=0;Blockly.Toolbox.prototype.selectedOption_=null;Blockly.Toolbox.prototype.lastCategory_=null;
-Blockly.Toolbox.prototype.init=function(){var a=this.workspace_,b=this.workspace_.getParentSvg();this.HtmlDiv=goog.dom.createDom("DIV","blocklyToolboxDiv");this.HtmlDiv.setAttribute("dir",a.RTL?"RTL":"LTR");b.parentNode.insertBefore(this.HtmlDiv,b);Blockly.bindEventWithChecks_(this.HtmlDiv,"mousedown",this,function(a){Blockly.utils.isRightButton(a)||a.target==this.HtmlDiv?Blockly.hideChaff(!1):Blockly.hideChaff(!0);Blockly.Touch.clearTouchIdentifier()},!1,!0);b={disabledPatternId:a.options.disabledPatternId,parentWorkspace:a,RTL:a.RTL,oneBasedIndex:a.options.oneBasedIndex,horizontalLayout:a.horizontalLayout,toolboxPosition:a.options.toolboxPosition};this.flyout_=null;this.flyout_=a.horizontalLayout?new Blockly.HorizontalFlyout(b):new Blockly.VerticalFlyout(b);goog.dom.insertSiblingAfter(this.flyout_.createDom("svg"),this.workspace_.getParentSvg());this.flyout_.init(a);this.config_.cleardotPath=a.options.pathToMedia+"1x1.gif";this.config_.cssCollapsedFolderIcon="blocklyTreeIconClosed"+(a.RTL?"Rtl":"Ltr");this.tree_=b=new Blockly.Toolbox.TreeControl(this,this.config_);b.setShowRootNode(!1);b.setShowLines(!1);b.setShowExpandIcons(!1);b.setSelectedItem(null);a=this.populate_(a.options.languageTree);b.render(this.HtmlDiv);a&&b.setSelectedItem(a);this.addColour_();this.position()};Blockly.Toolbox.prototype.dispose=function(){this.flyout_.dispose();this.tree_.dispose();goog.dom.removeNode(this.HtmlDiv);this.lastCategory_=this.workspace_=null};Blockly.Toolbox.prototype.getWidth=function(){return this.width};Blockly.Toolbox.prototype.getHeight=function(){return this.height};Blockly.Toolbox.prototype.position=function(){var a=this.HtmlDiv;if(a){var b=this.workspace_.getParentSvg();b=Blockly.svgSize(b);this.horizontalLayout_?(a.style.left="0",a.style.height="auto",a.style.width=b.width+"px",this.height=a.offsetHeight,this.toolboxPosition==Blockly.TOOLBOX_AT_TOP?a.style.top="0":a.style.bottom="0"):(this.toolboxPosition==Blockly.TOOLBOX_AT_RIGHT?a.style.right="0":a.style.left="0",a.style.height=b.height+"px",this.width=a.offsetWidth);
-this.flyout_.position()}};Blockly.Toolbox.prototype.populate_=function(a){this.tree_.removeChildren();this.tree_.blocks=[];this.hasColours_=!1;a=this.syncTrees_(a,this.tree_,this.workspace_.options.pathToMedia);if(this.tree_.blocks.length){throw"Toolbox cannot have both blocks and categories in the root level."}this.workspace_.resizeContents();return a};Blockly.Toolbox.prototype.syncTrees_=function(a,b,c){for(var d=null,e=null,f=0,g;g=a.childNodes[f];f++){if(g.tagName){switch(g.tagName.toUpperCase()){case"CATEGORY":e=Blockly.utils.replaceMessageReferences(g.getAttribute("name"));e=this.tree_.createNode(e);e.blocks=[];b.add(e);var h=g.getAttribute("custom");h?e.blocks=h:(h=this.syncTrees_(g,e,c))&&(d=h);h=Blockly.utils.replaceMessageReferences(g.getAttribute("colour"));goog.isString(h)?(/^#[0-9a-fA-F]{6}$/.test(h)?e.hexColour=h:e.hexColour=Blockly.hueToRgb(Number(h)),this.hasColours_=!0):e.hexColour="";"true"==g.getAttribute("expanded")?(e.blocks.length&&(d=e),e.setExpanded(!0)):e.setExpanded(!1);e=g;break;case"SEP":e&&("CATEGORY"==e.tagName.toUpperCase()?b.add(new Blockly.Toolbox.TreeSeparator(this.treeSeparatorConfig_)):(g=parseFloat(g.getAttribute("gap")),!isNaN(g)&&e&&e.setAttribute("gap",g)));break;case"BLOCK":case"SHADOW":case"LABEL":case"BUTTON":b.blocks.push(g),e=g}}}return d};Blockly.Toolbox.prototype.addColour_=function(a){a=(a||this.tree_).getChildren();for(var b=0,c;c=a[b];b++){var d=c.getRowElement();if(d){var e=this.hasColours_?"8px solid "+(c.hexColour||"#ddd"):"none";this.workspace_.RTL?d.style.borderRight=e:d.style.borderLeft=e}this.addColour_(c)}};Blockly.Toolbox.prototype.clearSelection=function(){this.tree_.setSelectedItem(null)};Blockly.Toolbox.prototype.addDeleteStyle=function(){Blockly.utils.addClass(this.HtmlDiv,"blocklyToolboxDelete")};Blockly.Toolbox.prototype.removeDeleteStyle=function(){Blockly.utils.removeClass(this.HtmlDiv,"blocklyToolboxDelete")};Blockly.Toolbox.prototype.getClientRect=function(){if(!this.HtmlDiv){return null}var a=this.HtmlDiv.getBoundingClientRect(),b=a.left,c=a.top,d=a.width;
-a=a.height;return this.toolboxPosition==Blockly.TOOLBOX_AT_LEFT?new goog.math.Rect(-10000000,-10000000,10000000+b+d,20000000):this.toolboxPosition==Blockly.TOOLBOX_AT_RIGHT?new goog.math.Rect(b,-10000000,10000000+d,20000000):this.toolboxPosition==Blockly.TOOLBOX_AT_TOP?new goog.math.Rect(-10000000,-10000000,20000000,10000000+c+a):new goog.math.Rect(0,c,20000000,10000000+d)};Blockly.Toolbox.prototype.refreshSelection=function(){var a=this.tree_.getSelectedItem();a&&a.blocks&&this.flyout_.show(a.blocks)};Blockly.Toolbox.TreeControl=function(a,b){this.toolbox_=a;goog.ui.tree.TreeControl.call(this,goog.html.SafeHtml.EMPTY,b)};goog.inherits(Blockly.Toolbox.TreeControl,goog.ui.tree.TreeControl);Blockly.Toolbox.TreeControl.prototype.enterDocument=function(){Blockly.Toolbox.TreeControl.superClass_.enterDocument.call(this);if(goog.events.BrowserFeature.TOUCH_ENABLED){var a=this.getElement();Blockly.bindEventWithChecks_(a,goog.events.EventType.TOUCHEND,this,this.handleTouchEvent_)}};Blockly.Toolbox.TreeControl.prototype.handleTouchEvent_=function(a){var b=this.getNodeFromEvent_(a);b&&a.type===goog.events.EventType.TOUCHEND&&setTimeout(function(){b.onClick_(a)},1)};Blockly.Toolbox.TreeControl.prototype.createNode=function(a){return new Blockly.Toolbox.TreeNode(this.toolbox_,a?goog.html.SafeHtml.htmlEscape(a):goog.html.SafeHtml.EMPTY,this.getConfig(),this.getDomHelper())};Blockly.Toolbox.TreeControl.prototype.setSelectedItem=function(a){var b=this.toolbox_;if(a!=this.selectedItem_&&a!=b.tree_){b.lastCategory_&&(b.lastCategory_.getRowElement().style.backgroundColor="");if(a){var c=a.hexColour||"#57e";a.getRowElement().style.backgroundColor=c;b.addColour_(a)}c=this.getSelectedItem();goog.ui.tree.TreeControl.prototype.setSelectedItem.call(this,a);a&&a.blocks&&a.blocks.length?(b.flyout_.show(a.blocks),b.lastCategory_!=a&&b.flyout_.scrollToStart()):b.flyout_.hide();c!=a&&c!=this&&(c=new Blockly.Events.Ui(null,"category",c&&c.getHtml(),a&&a.getHtml()),c.workspaceId=b.workspace_.id,Blockly.Events.fire(c));
-a&&(b.lastCategory_=a)}};Blockly.Toolbox.TreeNode=function(a,b,c,d){goog.ui.tree.TreeNode.call(this,b,c,d);a&&(b=function(){Blockly.svgResize(a.workspace_)},goog.events.listen(a.tree_,goog.ui.tree.BaseNode.EventType.EXPAND,b),goog.events.listen(a.tree_,goog.ui.tree.BaseNode.EventType.COLLAPSE,b))};goog.inherits(Blockly.Toolbox.TreeNode,goog.ui.tree.TreeNode);Blockly.Toolbox.TreeNode.prototype.getExpandIconSafeHtml=function(){return goog.html.SafeHtml.create("span")};Blockly.Toolbox.TreeNode.prototype.onClick_=function(a){this.hasChildren()&&this.isUserCollapsible_?(this.toggle(),this.select()):this.isSelected()?this.getTree().setSelectedItem(null):this.select();this.updateRow()};Blockly.Toolbox.TreeNode.prototype.onMouseDown=function(a){};Blockly.Toolbox.TreeNode.prototype.onDoubleClick_=function(a){};Blockly.Toolbox.TreeNode.prototype.onKeyDown=function(a){if(this.tree.toolbox_.horizontalLayout_){var b={},c=goog.events.KeyCodes.DOWN,d=goog.events.KeyCodes.UP;b[goog.events.KeyCodes.RIGHT]=this.rightToLeft_?d:c;b[goog.events.KeyCodes.LEFT]=this.rightToLeft_?c:d;b[goog.events.KeyCodes.UP]=goog.events.KeyCodes.LEFT;b[goog.events.KeyCodes.DOWN]=goog.events.KeyCodes.RIGHT;a.keyCode=b[a.keyCode]||a.keyCode}return Blockly.Toolbox.TreeNode.superClass_.onKeyDown.call(this,a)};Blockly.Toolbox.TreeSeparator=function(a){Blockly.Toolbox.TreeNode.call(this,null,goog.html.SafeHtml.EMPTY,a)};goog.inherits(Blockly.Toolbox.TreeSeparator,Blockly.Toolbox.TreeNode);Blockly.Css={};Blockly.Css.Cursor={OPEN:"handopen",CLOSED:"handclosed",DELETE:"handdelete"};Blockly.Css.currentCursor_="";Blockly.Css.styleSheet_=null;Blockly.Css.mediaPath_="";Blockly.Css.inject=function(a,b){if(!Blockly.Css.styleSheet_){var c=".blocklyDraggable {}\n";a&&(c+=Blockly.Css.CONTENT.join("\n"),Blockly.FieldDate&&(c+=Blockly.FieldDate.CSS.join("\n")));Blockly.Css.mediaPath_=b.replace(/[\\\/]$/,"");c=c.replace(/<<<PATH>>>/g,Blockly.Css.mediaPath_);var d=document.createElement("style");document.head.insertBefore(d,document.head.firstChild);
-c=document.createTextNode(c);d.appendChild(c);Blockly.Css.styleSheet_=d.sheet}};Blockly.Css.setCursor=function(a){console.warn("Deprecated call to Blockly.Css.setCursor.See https://github.com/google/blockly/issues/981 for context")};Blockly.Css.CONTENT=[".blocklySvg {","background-color: #fff;","outline: none;","overflow: hidden;","position: absolute;","display: block;","}",".blocklyWidgetDiv {","display: none;","position: absolute;","z-index: 99999;","}",".injectionDiv {","height: 100%;","position: relative;","overflow: hidden;","touch-action: none","}",".blocklyNonSelectable {","user-select: none;","-moz-user-select: none;","-webkit-user-select: none;","-ms-user-select: none;","}",".blocklyWsDragSurface {","display: none;","position: absolute;","top: 0;","left: 0;","}",".blocklyWsDragSurface.blocklyOverflowVisible {","overflow: visible;","}",".blocklyBlockDragSurface {","display: none;","position: absolute;","top: 0;","left: 0;","right: 0;","bottom: 0;","overflow: visible !important;","z-index: 50;","}",".blocklyTooltipDiv {","background-color: #ffffc7;","border: 1px solid #ddc;","box-shadow: 4px 4px 20px 1px rgba(0,0,0,.15);","color: #000;","display: none;","font-family: sans-serif;","font-size: 9pt;","opacity: 0.9;","padding: 2px;","position: absolute;","z-index: 100000;","}",".blocklyResizeSE {","cursor: se-resize;","fill: #aaa;","}",".blocklyResizeSW {","cursor: sw-resize;","fill: #aaa;","}",".blocklyResizeLine {","stroke: #888;","stroke-width: 1;","}",".blocklyHighlightedConnectionPath {","fill: none;","stroke: #fc3;","stroke-width: 4px;","}",".blocklyPathLight {","fill: none;","stroke-linecap: round;","stroke-width: 1;","}",".blocklySelected>.blocklyPath {","stroke: #fc3;","stroke-width: 3px;","}",".blocklySelected>.blocklyPathLight {","display: none;","}",".blocklyDraggable {",'cursor: url("<<<PATH>>>/handopen.cur"), auto;',"cursor: grab;","cursor: -webkit-grab;","cursor: -moz-grab;","}",".blocklyDragging {",'cursor: url("<<<PATH>>>/handclosed.cur"), auto;',"cursor: grabbing;","cursor: -webkit-grabbing;","cursor: -moz-grabbing;","}",".blocklyDraggable:active {",'cursor: url("<<<PATH>>>/handclosed.cur"), auto;',"cursor: grabbing;","cursor: -webkit-grabbing;","cursor: -moz-grabbing;","}",".blocklyBlockDragSurface .blocklyDraggable {",'cursor: url("<<<PATH>>>/handclosed.cur"), auto;',"cursor: grabbing;","cursor: -webkit-grabbing;","cursor: -moz-grabbing;","}",".blocklyDragging.blocklyDraggingDelete {",'cursor: url("<<<PATH>>>/handdelete.cur"), auto;',"}",".blocklyToolboxDelete {",'cursor: url("<<<PATH>>>/handdelete.cur"), auto;',"}",".blocklyDragging>.blocklyPath,",".blocklyDragging>.blocklyPathLight {","fill-opacity: .8;","stroke-opacity: .8;","}",".blocklyDragging>.blocklyPathDark {","display: none;","}",".blocklyDisabled>.blocklyPath {","fill-opacity: .5;","stroke-opacity: .5;","}",".blocklyDisabled>.blocklyPathLight,",".blocklyDisabled>.blocklyPathDark {","display: none;","}",".blocklyText {","cursor: default;","fill: #fff;","font-family: sans-serif;","font-size: 11pt;","}",".blocklyNonEditableText>text {","pointer-events: none;","}",".blocklyNonEditableText>rect,",".blocklyEditableText>rect {","fill: #fff;","fill-opacity: .6;","}",".blocklyNonEditableText>text,",".blocklyEditableText>text {","fill: #000;","}",".blocklyEditableText:hover>rect {","stroke: #fff;","stroke-width: 2;","}",".blocklyBubbleText {","fill: #000;","}",".blocklyFlyout {","position: absolute;","z-index: 20;","}",".blocklyFlyoutButton {","fill: #888;","cursor: default;","}",".blocklyFlyoutButtonShadow {","fill: #666;","}",".blocklyFlyoutButton:hover {","fill: #aaa;","}",".blocklyFlyoutLabel {","cursor: default;","}",".blocklyFlyoutLabelBackground {","opacity: 0;","}",".blocklyFlyoutLabelText {","fill: #000;","}",".blocklySvg text, .blocklyBlockDragSurface text {","user-select: none;","-moz-user-select: none;","-webkit-user-select: none;","cursor: inherit;","}",".blocklyHidden {","display: none;","}",".blocklyFieldDropdown:not(.blocklyHidden) {","display: block;","}",".blocklyIconGroup {","cursor: default;","}",".blocklyIconGroup:not(:hover),",".blocklyIconGroupReadonly {","opacity: .6;","}",".blocklyIconShape {","fill: #00f;","stroke: #fff;","stroke-width: 1px;","}",".blocklyIconSymbol {","fill: #fff;","}",".blocklyMinimalBody {","margin: 0;","padding: 0;","}",".blocklyCommentTextarea {","background-color: #ffc;","border: 0;","margin: 0;","padding: 2px;","resize: none;","}",".blocklyHtmlInput {","border: none;","border-radius: 4px;","font-family: sans-serif;","height: 100%;","margin: 0;","outline: none;","padding: 0 1px;","width: 100%","}",".blocklyMainBackground {","stroke-width: 1;","stroke: #c6c6c6;","}",".blocklyMutatorBackground {","fill: #fff;","stroke: #ddd;","stroke-width: 1;","}",".blocklyFlyoutBackground {","fill: #ddd;","fill-opacity: .8;","}",".blocklyTransparentBackground {","opacity: 0;","}",".blocklyMainWorkspaceScrollbar {","z-index: 20;","}",".blocklyFlyoutScrollbar {","z-index: 30;","}",".blocklyScrollbarHorizontal, .blocklyScrollbarVertical {","position: absolute;","outline: none;","}",".blocklyScrollbarBackground {","opacity: 0;","}",".blocklyScrollbarHandle {","fill: #ccc;","}",".blocklyScrollbarBackground:hover+.blocklyScrollbarHandle,",".blocklyScrollbarHandle:hover {","fill: #bbb;","}",".blocklyZoom>image {","opacity: .4;","}",".blocklyZoom>image:hover {","opacity: .6;","}",".blocklyZoom>image:active {","opacity: .8;","}",".blocklyFlyout .blocklyScrollbarHandle {","fill: #bbb;","}",".blocklyFlyout .blocklyScrollbarBackground:hover+.blocklyScrollbarHandle,",".blocklyFlyout .blocklyScrollbarHandle:hover {","fill: #aaa;","}",".blocklyInvalidInput {","background: #faa;","}",".blocklyAngleCircle {","stroke: #444;","stroke-width: 1;","fill: #ddd;","fill-opacity: .8;","}",".blocklyAngleMarks {","stroke: #444;","stroke-width: 1;","}",".blocklyAngleGauge {","fill: #f88;","fill-opacity: .8;","}",".blocklyAngleLine {","stroke: #f00;","stroke-width: 2;","stroke-linecap: round;","pointer-events: none;","}",".blocklyContextMenu {","border-radius: 4px;","}",".blocklyDropdownMenu {","padding: 0 !important;","}",".blocklyWidgetDiv .goog-option-selected .goog-menuitem-checkbox,",".blocklyWidgetDiv .goog-option-selected .goog-menuitem-icon {","background: url(<<<PATH>>>/sprites.png) no-repeat -48px -16px !important;","}",".blocklyToolboxDiv {","background-color: #ddd;","overflow-x: visible;","overflow-y: auto;","position: absolute;","z-index: 70;","-webkit-tap-highlight-color: transparent;","}",".blocklyTreeRoot {","padding: 4px 0;","}",".blocklyTreeRoot:focus {","outline: none;","}",".blocklyTreeRow {","height: 22px;","line-height: 22px;","margin-bottom: 3px;","padding-right: 8px;","white-space: nowrap;","}",".blocklyHorizontalTree {","float: left;","margin: 1px 5px 8px 0;","}",".blocklyHorizontalTreeRtl {","float: right;","margin: 1px 0 8px 5px;","}",'.blocklyToolboxDiv[dir="RTL"] .blocklyTreeRow {',"margin-left: 8px;","}",".blocklyTreeRow:not(.blocklyTreeSelected):hover {","background-color: #e4e4e4;","}",".blocklyTreeSeparator {","border-bottom: solid #e5e5e5 1px;","height: 0;","margin: 5px 0;","}",".blocklyTreeSeparatorHorizontal {","border-right: solid #e5e5e5 1px;","width: 0;","padding: 5px 0;","margin: 0 5px;","}",".blocklyTreeIcon {","background-image: url(<<<PATH>>>/sprites.png);","height: 16px;","vertical-align: middle;","width: 16px;","}",".blocklyTreeIconClosedLtr {","background-position: -32px -1px;","}",".blocklyTreeIconClosedRtl {","background-position: 0px -1px;","}",".blocklyTreeIconOpen {","background-position: -16px -1px;","}",".blocklyTreeSelected>.blocklyTreeIconClosedLtr {","background-position: -32px -17px;","}",".blocklyTreeSelected>.blocklyTreeIconClosedRtl {","background-position: 0px -17px;","}",".blocklyTreeSelected>.blocklyTreeIconOpen {","background-position: -16px -17px;","}",".blocklyTreeIconNone,",".blocklyTreeSelected>.blocklyTreeIconNone {","background-position: -48px -1px;","}",".blocklyTreeLabel {","cursor: default;","font-family: sans-serif;","font-size: 16px;","padding: 0 3px;","vertical-align: middle;","}",".blocklyToolboxDelete .blocklyTreeLabel {",'cursor: url("<<<PATH>>>/handdelete.cur"), auto;',"}",".blocklyTreeSelected .blocklyTreeLabel {","color: #fff;","}",".blocklyWidgetDiv .goog-palette {","outline: none;","cursor: default;","}",".blocklyWidgetDiv .goog-palette-table {","border: 1px solid #666;","border-collapse: collapse;","}",".blocklyWidgetDiv .goog-palette-cell {","height: 13px;","width: 15px;","margin: 0;","border: 0;","text-align: center;","vertical-align: middle;","border-right: 1px solid #666;","font-size: 1px;","}",".blocklyWidgetDiv .goog-palette-colorswatch {","position: relative;","height: 13px;","width: 15px;","border: 1px solid #666;","}",".blocklyWidgetDiv .goog-palette-cell-hover .goog-palette-colorswatch {","border: 1px solid #FFF;","}",".blocklyWidgetDiv .goog-palette-cell-selected .goog-palette-colorswatch {","border: 1px solid #000;","color: #fff;","}",".blocklyWidgetDiv .goog-menu {","background: #fff;","border-color: #ccc #666 #666 #ccc;","border-style: solid;","border-width: 1px;","cursor: default;","font: normal 13px Arial, sans-serif;","margin: 0;","outline: none;","padding: 4px 0;","position: absolute;","overflow-y: auto;","overflow-x: hidden;","max-height: 100%;","z-index: 20000;","}",".blocklyWidgetDiv .goog-menuitem {","color: #000;","font: normal 13px Arial, sans-serif;","list-style: none;","margin: 0;","padding: 4px 7em 4px 28px;","white-space: nowrap;","}",".blocklyWidgetDiv .goog-menuitem.goog-menuitem-rtl {","padding-left: 7em;","padding-right: 28px;","}",".blocklyWidgetDiv .goog-menu-nocheckbox .goog-menuitem,",".blocklyWidgetDiv .goog-menu-noicon .goog-menuitem {","padding-left: 12px;","}",".blocklyWidgetDiv .goog-menu-noaccel .goog-menuitem {","padding-right: 20px;","}",".blocklyWidgetDiv .goog-menuitem-content {","color: #000;","font: normal 13px Arial, sans-serif;","}",".blocklyWidgetDiv .goog-menuitem-disabled .goog-menuitem-accel,",".blocklyWidgetDiv .goog-menuitem-disabled .goog-menuitem-content {","color: #ccc !important;","}",".blocklyWidgetDiv .goog-menuitem-disabled .goog-menuitem-icon {","opacity: 0.3;","-moz-opacity: 0.3;","filter: alpha(opacity=30);","}",".blocklyWidgetDiv .goog-menuitem-highlight,",".blocklyWidgetDiv .goog-menuitem-hover {","background-color: #d6e9f8;","border-color: #d6e9f8;","border-style: dotted;","border-width: 1px 0;","padding-bottom: 3px;","padding-top: 3px;","}",".blocklyWidgetDiv .goog-menuitem-checkbox,",".blocklyWidgetDiv .goog-menuitem-icon {","background-repeat: no-repeat;","height: 16px;","left: 6px;","position: absolute;","right: auto;","vertical-align: middle;","width: 16px;","}",".blocklyWidgetDiv .goog-menuitem-rtl .goog-menuitem-checkbox,",".blocklyWidgetDiv .goog-menuitem-rtl .goog-menuitem-icon {","left: auto;","right: 6px;","}",".blocklyWidgetDiv .goog-option-selected .goog-menuitem-checkbox,",".blocklyWidgetDiv .goog-option-selected .goog-menuitem-icon {","background: url(//ssl.gstatic.com/editor/editortoolbar.png) no-repeat -512px 0;","}",".blocklyWidgetDiv .goog-menuitem-accel {","color: #999;","direction: ltr;","left: auto;","padding: 0 6px;","position: absolute;","right: 0;","text-align: right;","}",".blocklyWidgetDiv .goog-menuitem-rtl .goog-menuitem-accel {","left: 0;","right: auto;","text-align: left;","}",".blocklyWidgetDiv .goog-menuitem-mnemonic-hint {","text-decoration: underline;","}",".blocklyWidgetDiv .goog-menuitem-mnemonic-separator {","color: #999;","font-size: 12px;","padding-left: 4px;","}",".blocklyWidgetDiv .goog-menuseparator {","border-top: 1px solid #ccc;","margin: 4px 0;","padding: 0;","}",""];
-Blockly.WidgetDiv={};Blockly.WidgetDiv.DIV=null;Blockly.WidgetDiv.owner_=null;Blockly.WidgetDiv.dispose_=null;Blockly.WidgetDiv.createDom=function(){Blockly.WidgetDiv.DIV||(Blockly.WidgetDiv.DIV=goog.dom.createDom("DIV","blocklyWidgetDiv"),document.body.appendChild(Blockly.WidgetDiv.DIV))};Blockly.WidgetDiv.show=function(a,b,c){Blockly.WidgetDiv.hide();Blockly.WidgetDiv.owner_=a;Blockly.WidgetDiv.dispose_=c;a=goog.style.getViewportPageOffset(document);Blockly.WidgetDiv.DIV.style.top=a.y+"px";Blockly.WidgetDiv.DIV.style.direction=b?"rtl":"ltr";Blockly.WidgetDiv.DIV.style.display="block"};Blockly.WidgetDiv.hide=function(){Blockly.WidgetDiv.owner_&&(Blockly.WidgetDiv.owner_=null,Blockly.WidgetDiv.DIV.style.display="none",Blockly.WidgetDiv.DIV.style.left="",Blockly.WidgetDiv.DIV.style.top="",Blockly.WidgetDiv.dispose_&&Blockly.WidgetDiv.dispose_(),Blockly.WidgetDiv.dispose_=null,goog.dom.removeChildren(Blockly.WidgetDiv.DIV))};Blockly.WidgetDiv.isVisible=function(){return !!Blockly.WidgetDiv.owner_};Blockly.WidgetDiv.hideIfOwner=function(a){Blockly.WidgetDiv.owner_==a&&Blockly.WidgetDiv.hide()};Blockly.WidgetDiv.position=function(a,b,c,d,e){b<d.y&&(b=d.y);e?a>c.width+d.x&&(a=c.width+d.x):a<d.x&&(a=d.x);Blockly.WidgetDiv.positionInternal_(a,b,c.height)};Blockly.WidgetDiv.positionInternal_=function(a,b,c){Blockly.WidgetDiv.DIV.style.left=a+"px";Blockly.WidgetDiv.DIV.style.top=b+"px";Blockly.WidgetDiv.DIV.style.height=c+"px"};Blockly.WidgetDiv.positionWithAnchor=function(a,b,c,d){var e=Blockly.WidgetDiv.calculateY_(a,b,c);a=Blockly.WidgetDiv.calculateX_(a,b,c,d);Blockly.WidgetDiv.positionInternal_(a,e,c.height)};Blockly.WidgetDiv.calculateX_=function(a,b,c,d){if(d){return b=Math.max(b.right-c.width,a.left),Math.min(b,a.right-c.width)}b=Math.min(b.left,a.right-c.width);return Math.max(b,a.left)};Blockly.WidgetDiv.calculateY_=function(a,b,c){return b.bottom+c.height>=a.bottom?b.top-c.height:b.bottom};Blockly.inject=function(a,b){goog.isString(a)&&(a=document.getElementById(a)||document.querySelector(a));
-if(!goog.dom.contains(document,a)){throw"Error: container is not in current document."}var c=new Blockly.Options(b||{}),d=goog.dom.createDom("DIV","injectionDiv");a.appendChild(d);var e=Blockly.createDom_(d,c),f=new Blockly.BlockDragSurfaceSvg(d);d=new Blockly.WorkspaceDragSurfaceSvg(d);c=Blockly.createMainWorkspace_(e,c,f,d);Blockly.init_(c);Blockly.mainWorkspace=c;Blockly.svgResize(c);return c};Blockly.createDom_=function(a,b){a.setAttribute("dir","LTR");goog.ui.Component.setDefaultRightToLeft(b.RTL);Blockly.Css.inject(b.hasCss,b.pathToMedia);var c=Blockly.utils.createSvgElement("svg",{xmlns:"http://www.w3.org/2000/svg","xmlns:html":"http://www.w3.org/1999/xhtml","xmlns:xlink":"http://www.w3.org/1999/xlink",version:"1.1","class":"blocklySvg"},a),d=Blockly.utils.createSvgElement("defs",{},c),e=String(Math.random()).substring(2),f=Blockly.utils.createSvgElement("filter",{id:"blocklyEmbossFilter"+e},d);Blockly.utils.createSvgElement("feGaussianBlur",{"in":"SourceAlpha",stdDeviation:1,result:"blur"},f);var g=Blockly.utils.createSvgElement("feSpecularLighting",{"in":"blur",surfaceScale:1,specularConstant:0.5,specularExponent:10,"lighting-color":"white",result:"specOut"},f);Blockly.utils.createSvgElement("fePointLight",{x:-5000,y:-10000,z:20000},g);Blockly.utils.createSvgElement("feComposite",{"in":"specOut",in2:"SourceAlpha",operator:"in",result:"specOut"},f);Blockly.utils.createSvgElement("feComposite",{"in":"SourceGraphic",in2:"specOut",operator:"arithmetic",k1:0,k2:1,k3:1,k4:0},f);b.embossFilterId=f.id;f=Blockly.utils.createSvgElement("pattern",{id:"blocklyDisabledPattern"+e,patternUnits:"userSpaceOnUse",width:10,height:10},d);Blockly.utils.createSvgElement("rect",{width:10,height:10,fill:"#aaa"},f);Blockly.utils.createSvgElement("path",{d:"M 0 0 L 10 10 M 10 0 L 0 10",stroke:"#cc0"},f);b.disabledPatternId=f.id;b.gridPattern=Blockly.Grid.createDom(e,b.gridOptions,d);return c};Blockly.createMainWorkspace_=function(a,b,c,d){b.parentWorkspace=null;var e=new Blockly.WorkspaceSvg(b,c,d);
-e.scale=b.zoomOptions.startScale;a.appendChild(e.createDom("blocklyMainBackground"));!b.hasCategories&&b.languageTree&&(c=e.addFlyout_("svg"),Blockly.utils.insertAfter_(c,a));e.translate(0,0);Blockly.mainWorkspace=e;b.readOnly||b.hasScrollbars||e.addChangeListener(function(){if(!e.isDragging()){var a=e.getMetrics(),c=a.viewLeft+a.absoluteLeft,d=a.viewTop+a.absoluteTop;if(a.contentTop<d||a.contentTop+a.contentHeight>a.viewHeight+d||a.contentLeft<(b.RTL?a.viewLeft:c)||a.contentLeft+a.contentWidth>(b.RTL?a.viewWidth:a.viewWidth+c)){for(var k=e.getTopBlocks(!1),n=0,p;p=k[n];n++){var l=p.getRelativeToSurfaceXY(),m=p.getHeightWidth(),q=d+25-m.height-l.y;0<q&&p.moveBy(0,q);q=d+a.viewHeight-25-l.y;0>q&&p.moveBy(0,q);q=25+c-l.x-(b.RTL?0:m.width);0<q&&p.moveBy(q,0);l=c+a.viewWidth-25-l.x+(b.RTL?m.width:0);0>l&&p.moveBy(l,0)}}}});Blockly.svgResize(e);Blockly.WidgetDiv.createDom();Blockly.Tooltip.createDom();return e};Blockly.init_=function(a){var b=a.options,c=a.getParentSvg();Blockly.bindEventWithChecks_(c.parentNode,"contextmenu",null,function(a){Blockly.utils.isTargetInput(a)||a.preventDefault()});c=Blockly.bindEventWithChecks_(window,"resize",null,function(){Blockly.hideChaff(!0);Blockly.svgResize(a)});a.setResizeHandlerWrapper(c);Blockly.inject.bindDocumentEvents_();b.languageTree&&(a.toolbox_?a.toolbox_.init(a):a.flyout_&&(a.flyout_.init(a),a.flyout_.show(b.languageTree.childNodes),a.flyout_.scrollToStart(),a.scrollX=a.flyout_.width_,b.toolboxPosition==Blockly.TOOLBOX_AT_RIGHT&&(a.scrollX*=-1),a.translate(a.scrollX,0)));b.hasScrollbars&&(a.scrollbar=new Blockly.ScrollbarPair(a),a.scrollbar.resize());b.hasSounds&&Blockly.inject.loadSounds_(b.pathToMedia,a)};Blockly.inject.bindDocumentEvents_=function(){Blockly.documentEventsBound_||(Blockly.bindEventWithChecks_(document,"keydown",null,Blockly.onKeyDown_),Blockly.bindEvent_(document,"touchend",null,Blockly.longStop_),Blockly.bindEvent_(document,"touchcancel",null,Blockly.longStop_),goog.userAgent.IPAD&&Blockly.bindEventWithChecks_(window,"orientationchange",document,function(){Blockly.svgResize(Blockly.getMainWorkspace())
-}));Blockly.documentEventsBound_=!0};Blockly.inject.loadSounds_=function(a,b){var c=b.getAudioManager();c.load([a+"click.mp3",a+"click.wav",a+"click.ogg"],"click");c.load([a+"disconnect.wav",a+"disconnect.mp3",a+"disconnect.ogg"],"disconnect");c.load([a+"delete.mp3",a+"delete.ogg",a+"delete.wav"],"delete");var d=[],e=function(){for(;d.length;){Blockly.unbindEvent_(d.pop())}c.preload()};d.push(Blockly.bindEventWithChecks_(document,"mousemove",null,e,!0));d.push(Blockly.bindEventWithChecks_(document,"touchstart",null,e,!0))};Blockly.updateToolbox=function(a){console.warn("Deprecated call to Blockly.updateToolbox, use workspace.updateToolbox instead.");Blockly.getMainWorkspace().updateToolbox(a)};var CLOSURE_DEFINES={"goog.DEBUG":!1};Blockly.mainWorkspace=null;Blockly.selected=null;Blockly.draggingConnections_=[];Blockly.clipboardXml_=null;Blockly.clipboardSource_=null;Blockly.cache3dSupported_=null;Blockly.hueToRgb=function(a){return goog.color.hsvToHex(a,Blockly.HSV_SATURATION,255*Blockly.HSV_VALUE)};Blockly.svgSize=function(a){return{width:a.cachedWidth_,height:a.cachedHeight_}};Blockly.resizeSvgContents=function(a){a.resizeContents()};Blockly.svgResize=function(a){for(;a.options.parentWorkspace;){a=a.options.parentWorkspace}var b=a.getParentSvg(),c=b.parentNode;if(c){var d=c.offsetWidth;c=c.offsetHeight;b.cachedWidth_!=d&&(b.setAttribute("width",d+"px"),b.cachedWidth_=d);b.cachedHeight_!=c&&(b.setAttribute("height",c+"px"),b.cachedHeight_=c);a.resize()}};Blockly.onKeyDown_=function(a){if(!Blockly.mainWorkspace.options.readOnly&&!Blockly.utils.isTargetInput(a)){var b=!1;if(27==a.keyCode){Blockly.hideChaff()}else{if(8==a.keyCode||46==a.keyCode){a.preventDefault();if(Blockly.mainWorkspace.isDragging()){return}Blockly.selected&&Blockly.selected.isDeletable()&&(b=!0)}else{if(a.altKey||a.ctrlKey||a.metaKey){if(Blockly.mainWorkspace.isDragging()){return}Blockly.selected&&Blockly.selected.isDeletable()&&Blockly.selected.isMovable()&&(67==a.keyCode?(Blockly.hideChaff(),Blockly.copy_(Blockly.selected)):88==a.keyCode&&(Blockly.copy_(Blockly.selected),b=!0));
-86==a.keyCode?Blockly.clipboardXml_&&(Blockly.Events.setGroup(!0),Blockly.clipboardSource_.paste(Blockly.clipboardXml_),Blockly.Events.setGroup(!1)):90==a.keyCode&&(Blockly.hideChaff(),Blockly.mainWorkspace.undo(a.shiftKey))}}}b&&(Blockly.Events.setGroup(!0),Blockly.hideChaff(),Blockly.selected.dispose(!0,!0),Blockly.Events.setGroup(!1))}};Blockly.copy_=function(a){var b=Blockly.Xml.blockToDom(a);Blockly.Xml.deleteNext(b);var c=a.getRelativeToSurfaceXY();b.setAttribute("x",a.RTL?-c.x:c.x);b.setAttribute("y",c.y);Blockly.clipboardXml_=b;Blockly.clipboardSource_=a.workspace};Blockly.duplicate_=function(a){var b=Blockly.clipboardXml_,c=Blockly.clipboardSource_;Blockly.copy_(a);a.workspace.paste(Blockly.clipboardXml_);Blockly.clipboardXml_=b;Blockly.clipboardSource_=c};Blockly.onContextMenu_=function(a){Blockly.utils.isTargetInput(a)||a.preventDefault()};Blockly.hideChaff=function(a){Blockly.Tooltip.hide();Blockly.WidgetDiv.hide();a||(a=Blockly.getMainWorkspace(),a.toolbox_&&a.toolbox_.flyout_&&a.toolbox_.flyout_.autoClose&&a.toolbox_.clearSelection())};Blockly.addChangeListener=function(a){console.warn("Deprecated call to Blockly.addChangeListener, use workspace.addChangeListener instead.");return Blockly.getMainWorkspace().addChangeListener(a)};Blockly.getMainWorkspace=function(){return Blockly.mainWorkspace};Blockly.alert=function(a,b){window.alert(a);b&&b()};Blockly.confirm=function(a,b){b(window.confirm(a))};Blockly.prompt=function(a,b,c){c(window.prompt(a,b))};Blockly.jsonInitFactory_=function(a){return function(){this.jsonInit(a)}};Blockly.defineBlocksWithJsonArray=function(a){for(var b=0,c;c=a[b];b++){var d=c.type;null==d||""===d?console.warn("Block definition #"+b+" in JSON array is missing a type attribute. Skipping."):(Blockly.Blocks[d]&&console.warn("Block definition #"+b+' in JSON array overwrites prior definition of "'+d+'".'),Blockly.Blocks[d]={init:Blockly.jsonInitFactory_(c)})}};Blockly.bindEventWithChecks_=function(a,b,c,d,e,f){var g=!1,h=function(a){var b=!e;
-a=Blockly.Touch.splitEventByTouches(a);for(var f=0,h;h=a[f];f++){if(!b||Blockly.Touch.shouldHandleEvent(h)){Blockly.Touch.setClientFromTouch(h),c?d.call(c,h):d(h),g=!0}}};a.addEventListener(b,h,!1);var k=[[a,b,h]];if(b in Blockly.Touch.TOUCH_MAP){for(var n=function(a){h(a);var b=!f;g&&b&&a.preventDefault()},p=0,l;l=Blockly.Touch.TOUCH_MAP[b][p];p++){a.addEventListener(l,n,!1),k.push([a,l,n])}}return k};Blockly.bindEvent_=function(a,b,c,d){var e=function(a){c?d.call(c,a):d(a)};a.addEventListener(b,e,!1);var f=[[a,b,e]];if(b in Blockly.Touch.TOUCH_MAP){for(var g=function(a){if(1==a.changedTouches.length){var b=a.changedTouches[0];a.clientX=b.clientX;a.clientY=b.clientY}e(a);a.preventDefault()},h=0,k;k=Blockly.Touch.TOUCH_MAP[b][h];h++){a.addEventListener(k,g,!1),f.push([a,k,g])}}return f};Blockly.unbindEvent_=function(a){for(;a.length;){var b=a.pop(),c=b[2];b[0].removeEventListener(b[1],c,!1)}return c};Blockly.isNumber=function(a){return/^\s*-?\d+(\.\d+)?\s*$/.test(a)};goog.global.console||(goog.global.console={log:function(){},warn:function(){}});goog.global.Blockly||(goog.global.Blockly={});goog.global.Blockly.getMainWorkspace=Blockly.getMainWorkspace;goog.global.Blockly.addChangeListener=Blockly.addChangeListener;
diff --git a/_server/blockly/blockly_config.min.js b/_server/blockly/blockly_config.min.js
deleted file mode 100644
index bd003241..00000000
--- a/_server/blockly/blockly_config.min.js
+++ /dev/null
@@ -1,59 +0,0 @@
-"use strict";goog.provide("Blockly.Msg.zh.hans");goog.require("Blockly.Msg");Blockly.Msg.ADD_COMMENT="添加注释";Blockly.Msg.CANNOT_DELETE_VARIABLE_PROCEDURE="不能删除变量“%1”，因为它是功能“%2”定义的一部分";Blockly.Msg.CHANGE_VALUE_TITLE="更改值：";Blockly.Msg.CLEAN_UP="整理块";Blockly.Msg.COLLAPSE_ALL="折叠块";Blockly.Msg.COLLAPSE_BLOCK="折叠块";Blockly.Msg.COLOUR_BLEND_COLOUR1="颜色1";Blockly.Msg.COLOUR_BLEND_COLOUR2="颜色2";Blockly.Msg.COLOUR_BLEND_HELPURL="http://meyerweb.com/eric/tools/color-blend/";Blockly.Msg.COLOUR_BLEND_RATIO="比例";Blockly.Msg.COLOUR_BLEND_TITLE="混合";Blockly.Msg.COLOUR_BLEND_TOOLTIP="用一个给定的比率(0.0-1.0)混合两种颜色。";Blockly.Msg.COLOUR_PICKER_HELPURL="https://zh.wikipedia.org/wiki/颜色";Blockly.Msg.COLOUR_PICKER_TOOLTIP="从调色板中选择一种颜色。";Blockly.Msg.COLOUR_RANDOM_HELPURL="http://randomcolour.com";Blockly.Msg.COLOUR_RANDOM_TITLE="随机颜色";Blockly.Msg.COLOUR_RANDOM_TOOLTIP="随机选择一种颜色。";Blockly.Msg.COLOUR_RGB_BLUE="蓝色";Blockly.Msg.COLOUR_RGB_GREEN="绿色";Blockly.Msg.COLOUR_RGB_HELPURL="http://www.december.com/html/spec/colorper.html";Blockly.Msg.COLOUR_RGB_RED="红色";Blockly.Msg.COLOUR_RGB_TITLE="颜色";Blockly.Msg.COLOUR_RGB_TOOLTIP="通过指定红色、绿色和蓝色的量创建一种颜色。所有的值必须在0和100之间。";Blockly.Msg.CONTROLS_FLOW_STATEMENTS_HELPURL="https://github.com/google/blockly/wiki/Loops#loop-termination-blocks";Blockly.Msg.CONTROLS_FLOW_STATEMENTS_OPERATOR_BREAK="中断循环";Blockly.Msg.CONTROLS_FLOW_STATEMENTS_OPERATOR_CONTINUE="继续下一次循环";Blockly.Msg.CONTROLS_FLOW_STATEMENTS_TOOLTIP_BREAK="中断包含它的循环。";Blockly.Msg.CONTROLS_FLOW_STATEMENTS_TOOLTIP_CONTINUE="跳过这个循环的剩余部分，并继续下一次迭代。";Blockly.Msg.CONTROLS_FLOW_STATEMENTS_WARNING="警告：此块仅可用于在一个循环内。";Blockly.Msg.CONTROLS_FOREACH_HELPURL="https://github.com/google/blockly/wiki/Loops#for-each";Blockly.Msg.CONTROLS_FOREACH_TITLE="为每个项目 %1 在列表中 %2";Blockly.Msg.CONTROLS_FOREACH_TOOLTIP="遍历每个列表中的项目，将变量“%1”设定到该项中，然后执行某些语句。";Blockly.Msg.CONTROLS_FOR_HELPURL="https://github.com/google/blockly/wiki/Loops#count-with";Blockly.Msg.CONTROLS_FOR_TITLE="使用 %1 从范围 %2 到 %3 每隔 %4";Blockly.Msg.CONTROLS_FOR_TOOLTIP="从起始数到结尾数中取出变量“%1”的值，按指定的时间间隔，执行指定的块。";
-Blockly.Msg.CONTROLS_IF_ELSEIF_TOOLTIP="在if语句块中增加一个条件。";Blockly.Msg.CONTROLS_IF_ELSE_TOOLTIP="添加一个最终的，包括所有情况的节到if块中。";Blockly.Msg.CONTROLS_IF_HELPURL="https://github.com/google/blockly/wiki/IfElse";Blockly.Msg.CONTROLS_IF_IF_TOOLTIP="增加、删除或重新排列各节来重新配置“if”块。";Blockly.Msg.CONTROLS_IF_MSG_ELSE="否则";Blockly.Msg.CONTROLS_IF_MSG_ELSEIF="否则如果";Blockly.Msg.CONTROLS_IF_MSG_IF="如果";Blockly.Msg.CONTROLS_IF_TOOLTIP_1="如果值为真，执行一些语句。";Blockly.Msg.CONTROLS_IF_TOOLTIP_2="如果值为真，则执行第一块语句。否则，则执行第二块语句。";Blockly.Msg.CONTROLS_IF_TOOLTIP_3="如果第一个值为真，则执行第一块的语句。否则，如果第二个值为真，则执行第二块的语句。";Blockly.Msg.CONTROLS_IF_TOOLTIP_4="如果第一个值为真，则执行第一块对语句。否则，如果第二个值为真，则执行语句的第二块。如果没有值为真，则执行最后一块的语句。";Blockly.Msg.CONTROLS_REPEAT_HELPURL="https://zh.wikipedia.org/wiki/For循环";Blockly.Msg.CONTROLS_REPEAT_INPUT_DO="执行";Blockly.Msg.CONTROLS_REPEAT_TITLE="重复 %1 次";Blockly.Msg.CONTROLS_REPEAT_TOOLTIP="多次执行一些语句。";Blockly.Msg.CONTROLS_WHILEUNTIL_HELPURL="https://github.com/google/blockly/wiki/Loops#repeat";Blockly.Msg.CONTROLS_WHILEUNTIL_OPERATOR_UNTIL="重复直到";Blockly.Msg.CONTROLS_WHILEUNTIL_OPERATOR_WHILE="重复当";Blockly.Msg.CONTROLS_WHILEUNTIL_TOOLTIP_UNTIL="只要值为假，执行一些语句。";Blockly.Msg.CONTROLS_WHILEUNTIL_TOOLTIP_WHILE="只要值为真，执行一些语句。";Blockly.Msg.DELETE_ALL_BLOCKS="删除所有%1块吗？";Blockly.Msg.DELETE_BLOCK="删除块";Blockly.Msg.DELETE_VARIABLE="删除“%1”变量";Blockly.Msg.DELETE_VARIABLE_CONFIRMATION="删除“%2”变量的%1用途么？";Blockly.Msg.DELETE_X_BLOCKS="删除 %1 块";Blockly.Msg.DISABLE_BLOCK="禁用块";Blockly.Msg.DUPLICATE_BLOCK="复制";Blockly.Msg.ENABLE_BLOCK="启用块";Blockly.Msg.EXPAND_ALL="展开块";Blockly.Msg.EXPAND_BLOCK="展开块";Blockly.Msg.EXTERNAL_INPUTS="外部输入";Blockly.Msg.HELP="帮助";Blockly.Msg.INLINE_INPUTS="单行输入";Blockly.Msg.IOS_CANCEL="取消";Blockly.Msg.IOS_ERROR="错误";Blockly.Msg.IOS_OK="确定";Blockly.Msg.IOS_PROCEDURES_ADD_INPUT="+添加输入";Blockly.Msg.IOS_PROCEDURES_ALLOW_STATEMENTS="允许声明";Blockly.Msg.IOS_PROCEDURES_DUPLICATE_INPUTS_ERROR="此功能有重复输入内容。";Blockly.Msg.IOS_PROCEDURES_INPUTS="输入";Blockly.Msg.IOS_VARIABLES_ADD_BUTTON="添加";Blockly.Msg.IOS_VARIABLES_ADD_VARIABLE="+添加变量";
-Blockly.Msg.IOS_VARIABLES_DELETE_BUTTON="删除";Blockly.Msg.IOS_VARIABLES_EMPTY_NAME_ERROR="您不能使用空变量名称。";Blockly.Msg.IOS_VARIABLES_RENAME_BUTTON="重命名";Blockly.Msg.IOS_VARIABLES_VARIABLE_NAME="变量名称";Blockly.Msg.LISTS_CREATE_EMPTY_HELPURL="https://github.com/google/blockly/wiki/Lists#create-empty-list";Blockly.Msg.LISTS_CREATE_EMPTY_TITLE="创建空列表";Blockly.Msg.LISTS_CREATE_EMPTY_TOOLTIP="返回一个列表，长度为 0，不包含任何数据记录";Blockly.Msg.LISTS_CREATE_WITH_CONTAINER_TITLE_ADD="列表";Blockly.Msg.LISTS_CREATE_WITH_CONTAINER_TOOLTIP="增加、删除或重新排列各部分以此重新配置这个列表块。";Blockly.Msg.LISTS_CREATE_WITH_HELPURL="https://github.com/google/blockly/wiki/Lists#create-list-with";Blockly.Msg.LISTS_CREATE_WITH_INPUT_WITH="建立列表使用";Blockly.Msg.LISTS_CREATE_WITH_ITEM_TOOLTIP="将一个项添加到列表中。";Blockly.Msg.LISTS_CREATE_WITH_TOOLTIP="建立一个具有任意数量项目的列表。";Blockly.Msg.LISTS_GET_INDEX_FIRST="第一";Blockly.Msg.LISTS_GET_INDEX_FROM_END="倒数第#";Blockly.Msg.LISTS_GET_INDEX_FROM_START="#";Blockly.Msg.LISTS_GET_INDEX_GET="取得";Blockly.Msg.LISTS_GET_INDEX_GET_REMOVE="取出并移除";Blockly.Msg.LISTS_GET_INDEX_LAST="最后";Blockly.Msg.LISTS_GET_INDEX_RANDOM="随机";Blockly.Msg.LISTS_GET_INDEX_REMOVE="移除";Blockly.Msg.LISTS_GET_INDEX_TAIL="空白";Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_FIRST="返回列表中的第一个项目。";Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_FROM="返回在列表中的指定位置的项。";Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_LAST="返回列表中的最后一项。";Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_RANDOM="随机返回列表中的一个项目。";Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FIRST="移除并返回列表中的第一个项目。";Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FROM="移除并返回列表中的指定位置的项。";Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_LAST="移除并返回列表中的最后一个项目。";Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_RANDOM="移除并返回列表中的一个随机项目中。";Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_FIRST="移除列表中的第一项";Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_FROM="移除在列表中的指定位置的项。";Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_LAST="移除列表中的最后一项";Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_RANDOM="删除列表中的一个随机的项。";Blockly.Msg.LISTS_GET_SUBLIST_END_FROM_END="到倒数第#";
-Blockly.Msg.LISTS_GET_SUBLIST_END_FROM_START="到#";Blockly.Msg.LISTS_GET_SUBLIST_END_LAST="到最后";Blockly.Msg.LISTS_GET_SUBLIST_HELPURL="https://github.com/google/blockly/wiki/Lists#getting-a-sublist";Blockly.Msg.LISTS_GET_SUBLIST_START_FIRST="从头获得子列表";Blockly.Msg.LISTS_GET_SUBLIST_START_FROM_END="从倒数#取得子列表";Blockly.Msg.LISTS_GET_SUBLIST_START_FROM_START="从#取得子列表";Blockly.Msg.LISTS_GET_SUBLIST_TAIL="空白";Blockly.Msg.LISTS_GET_SUBLIST_TOOLTIP="复制列表中指定的部分。";Blockly.Msg.LISTS_INDEX_FROM_END_TOOLTIP="%1是最后一项。";Blockly.Msg.LISTS_INDEX_FROM_START_TOOLTIP="%1是第一个项目。";Blockly.Msg.LISTS_INDEX_OF_FIRST="找出第一个项出现";Blockly.Msg.LISTS_INDEX_OF_HELPURL="https://github.com/google/blockly/wiki/Lists#getting-items-from-a-list";Blockly.Msg.LISTS_INDEX_OF_LAST="找出最后一个项出现";Blockly.Msg.LISTS_INDEX_OF_TOOLTIP="返回在列表中的第一/最后一个匹配项的索引值。如果找不到项目则返回%1。";Blockly.Msg.LISTS_INLIST="在列表中";Blockly.Msg.LISTS_ISEMPTY_HELPURL="https://github.com/google/blockly/wiki/Lists#is-empty";Blockly.Msg.LISTS_ISEMPTY_TITLE="%1是空的";Blockly.Msg.LISTS_ISEMPTY_TOOLTIP="如果改列表为空，则返回真。";Blockly.Msg.LISTS_LENGTH_HELPURL="https://github.com/google/blockly/wiki/Lists#length-of";Blockly.Msg.LISTS_LENGTH_TITLE="%1的长度";Blockly.Msg.LISTS_LENGTH_TOOLTIP="返回列表的长度。";Blockly.Msg.LISTS_REPEAT_HELPURL="https://github.com/google/blockly/wiki/Lists#create-list-with";Blockly.Msg.LISTS_REPEAT_TITLE="建立列表使用项 %1 重复 %2 次";Blockly.Msg.LISTS_REPEAT_TOOLTIP="建立包含指定重复次数的值的列表。";Blockly.Msg.LISTS_REVERSE_HELPURL="https://github.com/google/blockly/wiki/Lists#reversing-a-list";Blockly.Msg.LISTS_REVERSE_MESSAGE0="倒转%1";Blockly.Msg.LISTS_REVERSE_TOOLTIP="倒转一个列表的拷贝。";Blockly.Msg.LISTS_SET_INDEX_HELPURL="https://github.com/google/blockly/wiki/Lists#in-list--set";Blockly.Msg.LISTS_SET_INDEX_INPUT_TO="为";Blockly.Msg.LISTS_SET_INDEX_INSERT="插入在";Blockly.Msg.LISTS_SET_INDEX_SET="设置";Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_FIRST="在列表的起始处添加该项。";Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_FROM="插入在列表中指定位置的项。";Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_LAST="将该项追加到列表的末尾。";
-Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_RANDOM="在列表中随机插入项。";Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_FIRST="设置列表中的第一个项目。";Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_FROM="设置在列表中指定位置的项。";Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_LAST="设置列表中的最后一项。";Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_RANDOM="设置列表中一个随机的项目。";Blockly.Msg.LISTS_SORT_HELPURL="https://github.com/google/blockly/wiki/Lists#sorting-a-list";Blockly.Msg.LISTS_SORT_ORDER_ASCENDING="升序";Blockly.Msg.LISTS_SORT_ORDER_DESCENDING="降序";Blockly.Msg.LISTS_SORT_TITLE="排序%1 %2 %3";Blockly.Msg.LISTS_SORT_TOOLTIP="排序一个列表的拷贝。";Blockly.Msg.LISTS_SORT_TYPE_IGNORECASE="按字母排序，忽略大小写";Blockly.Msg.LISTS_SORT_TYPE_NUMERIC="按数字排序";Blockly.Msg.LISTS_SORT_TYPE_TEXT="按字母排序";Blockly.Msg.LISTS_SPLIT_HELPURL="https://github.com/google/blockly/wiki/Lists#splitting-strings-and-joining-lists";Blockly.Msg.LISTS_SPLIT_LIST_FROM_TEXT="从文本制作列表";Blockly.Msg.LISTS_SPLIT_TEXT_FROM_LIST="从列表拆出文本";Blockly.Msg.LISTS_SPLIT_TOOLTIP_JOIN="加入文本列表至一个文本，由分隔符分隔。";Blockly.Msg.LISTS_SPLIT_TOOLTIP_SPLIT="拆分文本到文本列表，按每个分隔符拆分。";Blockly.Msg.LISTS_SPLIT_WITH_DELIMITER="用分隔符";Blockly.Msg.LOGIC_BOOLEAN_FALSE="假";Blockly.Msg.LOGIC_BOOLEAN_HELPURL="https://github.com/google/blockly/wiki/Logic#values";Blockly.Msg.LOGIC_BOOLEAN_TOOLTIP="返回真或假。";Blockly.Msg.LOGIC_BOOLEAN_TRUE="真";Blockly.Msg.LOGIC_COMPARE_HELPURL="https://zh.wikipedia.org/wiki/不等";Blockly.Msg.LOGIC_COMPARE_TOOLTIP_EQ="如果两个输入结果相等，则返回真。";Blockly.Msg.LOGIC_COMPARE_TOOLTIP_GT="如果第一个输入结果比第二个大，则返回真。";Blockly.Msg.LOGIC_COMPARE_TOOLTIP_GTE="如果第一个输入结果大于或等于第二个输入结果，则返回真。";Blockly.Msg.LOGIC_COMPARE_TOOLTIP_LT="如果第一个输入结果比第二个小，则返回真。";Blockly.Msg.LOGIC_COMPARE_TOOLTIP_LTE="如果第一个输入结果小于或等于第二个输入结果，则返回真。";Blockly.Msg.LOGIC_COMPARE_TOOLTIP_NEQ="如果两个输入结果不相等，则返回真。";Blockly.Msg.LOGIC_NEGATE_HELPURL="https://github.com/google/blockly/wiki/Logic#not";Blockly.Msg.LOGIC_NEGATE_TITLE="非%1";Blockly.Msg.LOGIC_NEGATE_TOOLTIP="如果输入结果为假，则返回真；如果输入结果为真，则返回假。";Blockly.Msg.LOGIC_NULL="空";Blockly.Msg.LOGIC_NULL_HELPURL="https://en.wikipedia.org/wiki/Nullable_type";
-Blockly.Msg.LOGIC_NULL_TOOLTIP="返回空值。";Blockly.Msg.LOGIC_OPERATION_AND="和";Blockly.Msg.LOGIC_OPERATION_HELPURL="https://github.com/google/blockly/wiki/Logic#logical-operations";Blockly.Msg.LOGIC_OPERATION_OR="或";Blockly.Msg.LOGIC_OPERATION_TOOLTIP_AND="如果两个输入结果都为真，则返回真。";Blockly.Msg.LOGIC_OPERATION_TOOLTIP_OR="如果至少有一个输入结果为真，则返回真。";Blockly.Msg.LOGIC_TERNARY_CONDITION="测试";Blockly.Msg.LOGIC_TERNARY_HELPURL="https://zh.wikipedia.org/wiki/条件运算符";Blockly.Msg.LOGIC_TERNARY_IF_FALSE="如果为假";Blockly.Msg.LOGIC_TERNARY_IF_TRUE="如果为真";Blockly.Msg.LOGIC_TERNARY_TOOLTIP="检查“test”中的条件。如果条件为真，则返回“if true”的值，否则，则返回“if false”的值。";Blockly.Msg.MATH_ADDITION_SYMBOL="+";Blockly.Msg.MATH_ARITHMETIC_HELPURL="https://zh.wikipedia.org/wiki/算术";Blockly.Msg.MATH_ARITHMETIC_TOOLTIP_ADD="返回两个数字的和。";Blockly.Msg.MATH_ARITHMETIC_TOOLTIP_DIVIDE="返回两个数字的商。";Blockly.Msg.MATH_ARITHMETIC_TOOLTIP_MINUS="返回两个数字的区别。";Blockly.Msg.MATH_ARITHMETIC_TOOLTIP_MULTIPLY="返回两个数字的乘积。";Blockly.Msg.MATH_ARITHMETIC_TOOLTIP_POWER="返回第一个数的第二个数次幂。";Blockly.Msg.MATH_CHANGE_HELPURL="https://zh.wikipedia.org/wiki/加法";Blockly.Msg.MATH_CHANGE_TITLE="更改 %1 从 %2";Blockly.Msg.MATH_CHANGE_TOOLTIP="将一个数添加到变量“%1”。";Blockly.Msg.MATH_CONSTANT_HELPURL="https://zh.wikipedia.org/wiki/数学常数";Blockly.Msg.MATH_CONSTANT_TOOLTIP="返回一个常见常量：π (3.141…)、e (2.718…)、φ (1.618…)、平方根 (1.414…)、开平方根 (0.707…)或∞ (infinity)。";Blockly.Msg.MATH_CONSTRAIN_HELPURL="https://en.wikipedia.org/wiki/Clamping_(graphics)";Blockly.Msg.MATH_CONSTRAIN_TITLE="限制数字 %1 介于 (低) %2 到 (高) %3";Blockly.Msg.MATH_CONSTRAIN_TOOLTIP="限制数字介于两个指定的数字之间";Blockly.Msg.MATH_DIVISION_SYMBOL="÷";Blockly.Msg.MATH_IS_DIVISIBLE_BY="可被整除";Blockly.Msg.MATH_IS_EVEN="是偶数";Blockly.Msg.MATH_IS_NEGATIVE="为负";Blockly.Msg.MATH_IS_ODD="是奇数";Blockly.Msg.MATH_IS_POSITIVE="为正";Blockly.Msg.MATH_IS_PRIME="是质数";Blockly.Msg.MATH_IS_TOOLTIP="如果数字是偶数、奇数、非负整数、正数、负数或如果它可被某数字整除，则返回真或假。";Blockly.Msg.MATH_IS_WHOLE="为整数";Blockly.Msg.MATH_MODULO_HELPURL="https://zh.wikipedia.org/wiki/模除";Blockly.Msg.MATH_MODULO_TITLE="取余数自 %1 ÷ %2";
-Blockly.Msg.MATH_MODULO_TOOLTIP="返回这两个数字相除后的余数。";Blockly.Msg.MATH_MULTIPLICATION_SYMBOL="×";Blockly.Msg.MATH_NUMBER_HELPURL="https://zh.wikipedia.org/wiki/数";Blockly.Msg.MATH_NUMBER_TOOLTIP="一个数字。";Blockly.Msg.MATH_ONLIST_HELPURL="";Blockly.Msg.MATH_ONLIST_OPERATOR_AVERAGE="列表中的平均数";Blockly.Msg.MATH_ONLIST_OPERATOR_MAX="列表中的最大值";Blockly.Msg.MATH_ONLIST_OPERATOR_MEDIAN="列表中位数";Blockly.Msg.MATH_ONLIST_OPERATOR_MIN="列表中的最小值";Blockly.Msg.MATH_ONLIST_OPERATOR_MODE="列表模式";Blockly.Msg.MATH_ONLIST_OPERATOR_RANDOM="列表的随机项";Blockly.Msg.MATH_ONLIST_OPERATOR_STD_DEV="列表中的标准差";Blockly.Msg.MATH_ONLIST_OPERATOR_SUM="列表中的数的总和";Blockly.Msg.MATH_ONLIST_TOOLTIP_AVERAGE="返回列表中的数值的平均值。";Blockly.Msg.MATH_ONLIST_TOOLTIP_MAX="返回列表中最大数。";Blockly.Msg.MATH_ONLIST_TOOLTIP_MEDIAN="返回列表中的中位数。";Blockly.Msg.MATH_ONLIST_TOOLTIP_MIN="返回列表中最小数。";Blockly.Msg.MATH_ONLIST_TOOLTIP_MODE="返回列表中的最常见的项的列表。";Blockly.Msg.MATH_ONLIST_TOOLTIP_RANDOM="从列表中返回一个随机的元素。";Blockly.Msg.MATH_ONLIST_TOOLTIP_STD_DEV="返回列表的标准偏差。";Blockly.Msg.MATH_ONLIST_TOOLTIP_SUM="返回列表中的所有数字的和。";Blockly.Msg.MATH_POWER_SYMBOL="^";Blockly.Msg.MATH_RANDOM_FLOAT_HELPURL="https://zh.wikipedia.org/wiki/随机数生成器";Blockly.Msg.MATH_RANDOM_FLOAT_TITLE_RANDOM="随机分数";Blockly.Msg.MATH_RANDOM_FLOAT_TOOLTIP="返回介于（包含）0.0到1.0之间的随机数。";Blockly.Msg.MATH_RANDOM_INT_HELPURL="https://zh.wikipedia.org/wiki/随机数生成器";Blockly.Msg.MATH_RANDOM_INT_TITLE="从 %1 到 %2 之间的随机整数";Blockly.Msg.MATH_RANDOM_INT_TOOLTIP="返回两个指定的范围（含）之间的随机整数。";Blockly.Msg.MATH_ROUND_HELPURL="https://zh.wikipedia.org/wiki/数值修约";Blockly.Msg.MATH_ROUND_OPERATOR_ROUND="向下舍入";Blockly.Msg.MATH_ROUND_OPERATOR_ROUNDDOWN="向下舍入";Blockly.Msg.MATH_ROUND_OPERATOR_ROUNDUP="向上舍入";Blockly.Msg.MATH_ROUND_TOOLTIP="数字向上或向下舍入。";Blockly.Msg.MATH_SINGLE_HELPURL="https://zh.wikipedia.org/wiki/平方根";Blockly.Msg.MATH_SINGLE_OP_ABSOLUTE="绝对";Blockly.Msg.MATH_SINGLE_OP_ROOT="平方根";Blockly.Msg.MATH_SINGLE_TOOLTIP_ABS="返回一个数的绝对值。";Blockly.Msg.MATH_SINGLE_TOOLTIP_EXP="返回一个数的e次幂。";Blockly.Msg.MATH_SINGLE_TOOLTIP_LN="返回一个数的自然对数。";Blockly.Msg.MATH_SINGLE_TOOLTIP_LOG10="返回一个数的对数。";
-Blockly.Msg.MATH_SINGLE_TOOLTIP_NEG="返回一个数的逻辑非。";Blockly.Msg.MATH_SINGLE_TOOLTIP_POW10="返回一个数的10次幂。";Blockly.Msg.MATH_SINGLE_TOOLTIP_ROOT="返回一个数的平方根。";Blockly.Msg.MATH_SUBTRACTION_SYMBOL="-";Blockly.Msg.MATH_TRIG_ACOS="acos";Blockly.Msg.MATH_TRIG_ASIN="asin";Blockly.Msg.MATH_TRIG_ATAN="atan";Blockly.Msg.MATH_TRIG_COS="cos";Blockly.Msg.MATH_TRIG_HELPURL="https://zh.wikipedia.org/wiki/三角函数";Blockly.Msg.MATH_TRIG_SIN="sin";Blockly.Msg.MATH_TRIG_TAN="tan";Blockly.Msg.MATH_TRIG_TOOLTIP_ACOS="返回一个数的反余弦值。";Blockly.Msg.MATH_TRIG_TOOLTIP_ASIN="返回一个数的反正弦值。";Blockly.Msg.MATH_TRIG_TOOLTIP_ATAN="返回指定角度的反正切值。";Blockly.Msg.MATH_TRIG_TOOLTIP_COS="返回指定角度的余弦值(非弧度）。";Blockly.Msg.MATH_TRIG_TOOLTIP_SIN="返回指定角度的正弦值(非弧度）。";Blockly.Msg.MATH_TRIG_TOOLTIP_TAN="返回指定角度的正切值(非弧度）。";Blockly.Msg.NEW_VARIABLE="创建变量...";Blockly.Msg.NEW_VARIABLE_TITLE="新变量的名称：";Blockly.Msg.ORDINAL_NUMBER_SUFFIX="空白";Blockly.Msg.PROCEDURES_ALLOW_STATEMENTS="允许声明";Blockly.Msg.PROCEDURES_BEFORE_PARAMS="与：";Blockly.Msg.PROCEDURES_CALLNORETURN_HELPURL="https://zh.wikipedia.org/wiki/子程序";Blockly.Msg.PROCEDURES_CALLNORETURN_TOOLTIP="运行用户定义的函数“%1”。";Blockly.Msg.PROCEDURES_CALLRETURN_HELPURL="https://zh.wikipedia.org/wiki/子程序";Blockly.Msg.PROCEDURES_CALLRETURN_TOOLTIP="运行用户定义的函数“%1”，并使用它的输出值。";Blockly.Msg.PROCEDURES_CALL_BEFORE_PARAMS="与：";Blockly.Msg.PROCEDURES_CREATE_DO="创建“%1”";Blockly.Msg.PROCEDURES_DEFNORETURN_COMMENT="描述该功能...";Blockly.Msg.PROCEDURES_DEFNORETURN_DO="空白";Blockly.Msg.PROCEDURES_DEFNORETURN_HELPURL="https://zh.wikipedia.org/wiki/子程序";Blockly.Msg.PROCEDURES_DEFNORETURN_PROCEDURE="做点什么";Blockly.Msg.PROCEDURES_DEFNORETURN_TITLE="至";Blockly.Msg.PROCEDURES_DEFNORETURN_TOOLTIP="创建一个不带输出值的函数。";Blockly.Msg.PROCEDURES_DEFRETURN_HELPURL="https://zh.wikipedia.org/wiki/子程序";Blockly.Msg.PROCEDURES_DEFRETURN_RETURN="返回";Blockly.Msg.PROCEDURES_DEFRETURN_TOOLTIP="创建一个有输出值的函数。";Blockly.Msg.PROCEDURES_DEF_DUPLICATE_WARNING="警告: 此函数具有重复参数。";Blockly.Msg.PROCEDURES_HIGHLIGHT_DEF="突出显示函数定义";Blockly.Msg.PROCEDURES_IFRETURN_HELPURL="http://c2.com/cgi/wiki?GuardClause";
-Blockly.Msg.PROCEDURES_IFRETURN_TOOLTIP="如果值为真，则返回第二个值。";Blockly.Msg.PROCEDURES_IFRETURN_WARNING="警告: 仅在定义函数内可使用此块。";Blockly.Msg.PROCEDURES_MUTATORARG_TITLE="输入名称：";Blockly.Msg.PROCEDURES_MUTATORARG_TOOLTIP="添加函数输入。";Blockly.Msg.PROCEDURES_MUTATORCONTAINER_TITLE="输入";Blockly.Msg.PROCEDURES_MUTATORCONTAINER_TOOLTIP="添加、删除或重新排此函数的输入。";Blockly.Msg.REDO="重做";Blockly.Msg.REMOVE_COMMENT="删除注释";Blockly.Msg.RENAME_VARIABLE="重命名变量...";Blockly.Msg.RENAME_VARIABLE_TITLE="将所有“%1”变量重命名为:";Blockly.Msg.TEXT_APPEND_HELPURL="https://github.com/google/blockly/wiki/Text#text-modification";Blockly.Msg.TEXT_APPEND_TITLE="至%1附加文本%2";Blockly.Msg.TEXT_APPEND_TOOLTIP="将一些文本追加到变量“%1”。";Blockly.Msg.TEXT_CHANGECASE_HELPURL="https://github.com/google/blockly/wiki/Text#adjusting-text-case";Blockly.Msg.TEXT_CHANGECASE_OPERATOR_LOWERCASE="转为小写";Blockly.Msg.TEXT_CHANGECASE_OPERATOR_TITLECASE="将首字母大写";Blockly.Msg.TEXT_CHANGECASE_OPERATOR_UPPERCASE="转为大写";Blockly.Msg.TEXT_CHANGECASE_TOOLTIP="在不同大小写下复制并返回这段文字。";Blockly.Msg.TEXT_CHARAT_FIRST="获得第一个字符";Blockly.Msg.TEXT_CHARAT_FROM_END="获得倒数第#个字符";Blockly.Msg.TEXT_CHARAT_FROM_START="获得字符#";Blockly.Msg.TEXT_CHARAT_HELPURL="https://github.com/google/blockly/wiki/Text#extracting-text";Blockly.Msg.TEXT_CHARAT_LAST="获得最后一个字符";Blockly.Msg.TEXT_CHARAT_RANDOM="获取随机的字母";Blockly.Msg.TEXT_CHARAT_TAIL="空白";Blockly.Msg.TEXT_CHARAT_TITLE="在文本%1 %2中";Blockly.Msg.TEXT_CHARAT_TOOLTIP="返回位于指定位置的字母。";Blockly.Msg.TEXT_COUNT_HELPURL="https://github.com/google/blockly/wiki/Text#counting-substrings";Blockly.Msg.TEXT_COUNT_MESSAGE0="将%1计算在%2之内";Blockly.Msg.TEXT_COUNT_TOOLTIP="计算在一些其他文本中，部分文本重现了多少次。";Blockly.Msg.TEXT_CREATE_JOIN_ITEM_TOOLTIP="将一个项添加到文本中。";Blockly.Msg.TEXT_CREATE_JOIN_TITLE_JOIN="加入";Blockly.Msg.TEXT_CREATE_JOIN_TOOLTIP="添加、移除或重新排列各节来重新配置这个文本块。";Blockly.Msg.TEXT_GET_SUBSTRING_END_FROM_END="到倒数第#个字符";Blockly.Msg.TEXT_GET_SUBSTRING_END_FROM_START="到字符#";Blockly.Msg.TEXT_GET_SUBSTRING_END_LAST="到最后一个字符";Blockly.Msg.TEXT_GET_SUBSTRING_HELPURL="https://github.com/google/blockly/wiki/Text#extracting-a-region-of-text";
-Blockly.Msg.TEXT_GET_SUBSTRING_INPUT_IN_TEXT="自文本";Blockly.Msg.TEXT_GET_SUBSTRING_START_FIRST="取得一段字串自第一个字符";Blockly.Msg.TEXT_GET_SUBSTRING_START_FROM_END="取得一段字串自倒数第#个字符";Blockly.Msg.TEXT_GET_SUBSTRING_START_FROM_START="取得一段字串自#";Blockly.Msg.TEXT_GET_SUBSTRING_TAIL="空白";Blockly.Msg.TEXT_GET_SUBSTRING_TOOLTIP="返回指定的部分文本。";Blockly.Msg.TEXT_INDEXOF_HELPURL="https://github.com/google/blockly/wiki/Text#finding-text";Blockly.Msg.TEXT_INDEXOF_OPERATOR_FIRST="寻找第一个出现的文本";Blockly.Msg.TEXT_INDEXOF_OPERATOR_LAST="寻找最后一个出现的文本";Blockly.Msg.TEXT_INDEXOF_TITLE="在文本%1 %2 %3中";Blockly.Msg.TEXT_INDEXOF_TOOLTIP="返回在第二个字串中的第一/最后一个匹配项的索引值。如果未找到则返回%1。";Blockly.Msg.TEXT_ISEMPTY_HELPURL="https://github.com/google/blockly/wiki/Text#checking-for-empty-text";Blockly.Msg.TEXT_ISEMPTY_TITLE="%1是空的";Blockly.Msg.TEXT_ISEMPTY_TOOLTIP="如果提供的文本为空，则返回真。";Blockly.Msg.TEXT_JOIN_HELPURL="https://github.com/google/blockly/wiki/Text#text-creation";Blockly.Msg.TEXT_JOIN_TITLE_CREATEWITH="建立字串使用";Blockly.Msg.TEXT_JOIN_TOOLTIP="通过串起任意数量的项以建立一段文字。";Blockly.Msg.TEXT_LENGTH_HELPURL="https://github.com/google/blockly/wiki/Text#text-modification";Blockly.Msg.TEXT_LENGTH_TITLE="%1的长度";Blockly.Msg.TEXT_LENGTH_TOOLTIP="返回提供文本的字母数（包括空格）。";Blockly.Msg.TEXT_PRINT_HELPURL="https://github.com/google/blockly/wiki/Text#printing-text";Blockly.Msg.TEXT_PRINT_TITLE="打印%1";Blockly.Msg.TEXT_PRINT_TOOLTIP="打印指定的文字、数字或其他值。";Blockly.Msg.TEXT_PROMPT_HELPURL="https://github.com/google/blockly/wiki/Text#getting-input-from-the-user";Blockly.Msg.TEXT_PROMPT_TOOLTIP_NUMBER="提示用户输入数字。";Blockly.Msg.TEXT_PROMPT_TOOLTIP_TEXT="提示用户输入一些文本。";Blockly.Msg.TEXT_PROMPT_TYPE_NUMBER="输入数字并显示提示消息";Blockly.Msg.TEXT_PROMPT_TYPE_TEXT="输入数字并显示提示消息";Blockly.Msg.TEXT_REPLACE_HELPURL="https://github.com/google/blockly/wiki/Text#replacing-substrings";Blockly.Msg.TEXT_REPLACE_MESSAGE0="在%3中，将%1替换为%2";Blockly.Msg.TEXT_REPLACE_TOOLTIP="在某些其他文本中，替换部分文本的所有事件。";Blockly.Msg.TEXT_REVERSE_HELPURL="https://github.com/google/blockly/wiki/Text#reversing-text";Blockly.Msg.TEXT_REVERSE_MESSAGE0="倒转%1";
-Blockly.Msg.TEXT_REVERSE_TOOLTIP="倒转文本中字符的排序。";Blockly.Msg.TEXT_TEXT_HELPURL="https://zh.wikipedia.org/wiki/字符串";Blockly.Msg.TEXT_TEXT_TOOLTIP="一个字母、单词或一行文本。";Blockly.Msg.TEXT_TRIM_HELPURL="https://github.com/google/blockly/wiki/Text#trimming-removing-spaces";Blockly.Msg.TEXT_TRIM_OPERATOR_BOTH="消除两侧空格";Blockly.Msg.TEXT_TRIM_OPERATOR_LEFT="消除左侧空格";Blockly.Msg.TEXT_TRIM_OPERATOR_RIGHT="消除右侧空格";Blockly.Msg.TEXT_TRIM_TOOLTIP="复制这段文字的同时删除两端多余的空格。";Blockly.Msg.TODAY="今天";Blockly.Msg.UNDO="撤销";Blockly.Msg.VARIABLES_DEFAULT_NAME="项目";Blockly.Msg.VARIABLES_GET_CREATE_SET="创建“设定%1”";Blockly.Msg.VARIABLES_GET_HELPURL="https://github.com/google/blockly/wiki/Variables#get";Blockly.Msg.VARIABLES_GET_TOOLTIP="返回此变量的值。";Blockly.Msg.VARIABLES_SET="赋值 %1 到 %2";Blockly.Msg.VARIABLES_SET_CREATE_GET="创建“获得%1”";Blockly.Msg.VARIABLES_SET_HELPURL="https://github.com/google/blockly/wiki/Variables#set";Blockly.Msg.VARIABLES_SET_TOOLTIP="设置此变量，以使它和输入值相等。";Blockly.Msg.VARIABLE_ALREADY_EXISTS="已存在名为“%1”的变量。";Blockly.Msg.VARIABLE_ALREADY_EXISTS_FOR_ANOTHER_TYPE="名叫“%1”的变量已存在，但作为另一个变量类型“%2”存在。";Blockly.Msg.PROCEDURES_DEFRETURN_TITLE=Blockly.Msg.PROCEDURES_DEFNORETURN_TITLE;Blockly.Msg.CONTROLS_IF_IF_TITLE_IF=Blockly.Msg.CONTROLS_IF_MSG_IF;Blockly.Msg.CONTROLS_WHILEUNTIL_INPUT_DO=Blockly.Msg.CONTROLS_REPEAT_INPUT_DO;Blockly.Msg.CONTROLS_IF_MSG_THEN=Blockly.Msg.CONTROLS_REPEAT_INPUT_DO;Blockly.Msg.CONTROLS_IF_ELSE_TITLE_ELSE=Blockly.Msg.CONTROLS_IF_MSG_ELSE;Blockly.Msg.PROCEDURES_DEFRETURN_PROCEDURE=Blockly.Msg.PROCEDURES_DEFNORETURN_PROCEDURE;Blockly.Msg.LISTS_GET_SUBLIST_INPUT_IN_LIST=Blockly.Msg.LISTS_INLIST;Blockly.Msg.LISTS_GET_INDEX_INPUT_IN_LIST=Blockly.Msg.LISTS_INLIST;Blockly.Msg.MATH_CHANGE_TITLE_ITEM=Blockly.Msg.VARIABLES_DEFAULT_NAME;Blockly.Msg.PROCEDURES_DEFRETURN_DO=Blockly.Msg.PROCEDURES_DEFNORETURN_DO;Blockly.Msg.CONTROLS_IF_ELSEIF_TITLE_ELSEIF=Blockly.Msg.CONTROLS_IF_MSG_ELSEIF;Blockly.Msg.LISTS_GET_INDEX_HELPURL=Blockly.Msg.LISTS_INDEX_OF_HELPURL;Blockly.Msg.CONTROLS_FOREACH_INPUT_DO=Blockly.Msg.CONTROLS_REPEAT_INPUT_DO;
-Blockly.Msg.LISTS_SET_INDEX_INPUT_IN_LIST=Blockly.Msg.LISTS_INLIST;Blockly.Msg.CONTROLS_FOR_INPUT_DO=Blockly.Msg.CONTROLS_REPEAT_INPUT_DO;Blockly.Msg.LISTS_CREATE_WITH_ITEM_TITLE=Blockly.Msg.VARIABLES_DEFAULT_NAME;Blockly.Msg.TEXT_APPEND_VARIABLE=Blockly.Msg.VARIABLES_DEFAULT_NAME;Blockly.Msg.TEXT_CREATE_JOIN_ITEM_TITLE_ITEM=Blockly.Msg.VARIABLES_DEFAULT_NAME;Blockly.Msg.LISTS_INDEX_OF_INPUT_IN_LIST=Blockly.Msg.LISTS_INLIST;Blockly.Msg.PROCEDURES_DEFRETURN_COMMENT=Blockly.Msg.PROCEDURES_DEFNORETURN_COMMENT;Blockly.Msg.MATH_HUE="230";Blockly.Msg.LOOPS_HUE="120";Blockly.Msg.LISTS_HUE="260";Blockly.Msg.LOGIC_HUE="210";Blockly.Msg.VARIABLES_HUE="330";Blockly.Msg.TEXTS_HUE="160";Blockly.Msg.PROCEDURES_HUE="290";Blockly.Msg.COLOUR_HUE="20";
-"use strict";Blockly.Blocks.colour={};Blockly.Constants={};Blockly.Constants.Colour={};Blockly.Constants.Colour.HUE=20;Blockly.Blocks.colour.HUE=Blockly.Constants.Colour.HUE;Blockly.defineBlocksWithJsonArray([{type:"colour_picker",message0:"%1",args0:[{type:"field_colour",name:"COLOUR",colour:"#ff0000"}],output:"Colour",colour:"%{BKY_COLOUR_HUE}",helpUrl:"%{BKY_COLOUR_PICKER_HELPURL}",tooltip:"%{BKY_COLOUR_PICKER_TOOLTIP}",extensions:["parent_tooltip_when_inline"]},{type:"colour_random",message0:"%{BKY_COLOUR_RANDOM_TITLE}",output:"Colour",colour:"%{BKY_COLOUR_HUE}",helpUrl:"%{BKY_COLOUR_RANDOM_HELPURL}",tooltip:"%{BKY_COLOUR_RANDOM_TOOLTIP}"},{type:"colour_rgb",message0:"%{BKY_COLOUR_RGB_TITLE} %{BKY_COLOUR_RGB_RED} %1 %{BKY_COLOUR_RGB_GREEN} %2 %{BKY_COLOUR_RGB_BLUE} %3",args0:[{type:"input_value",name:"RED",check:"Number",align:"RIGHT"},{type:"input_value",name:"GREEN",check:"Number",align:"RIGHT"},{type:"input_value",name:"BLUE",check:"Number",align:"RIGHT"}],output:"Colour",colour:"%{BKY_COLOUR_HUE}",helpUrl:"%{BKY_COLOUR_RGB_HELPURL}",tooltip:"%{BKY_COLOUR_RGB_TOOLTIP}"},{type:"colour_blend",message0:"%{BKY_COLOUR_BLEND_TITLE} %{BKY_COLOUR_BLEND_COLOUR1} %1 %{BKY_COLOUR_BLEND_COLOUR2} %2 %{BKY_COLOUR_BLEND_RATIO} %3",args0:[{type:"input_value",name:"COLOUR1",check:"Colour",align:"RIGHT"},{type:"input_value",name:"COLOUR2",check:"Colour",align:"RIGHT"},{type:"input_value",name:"RATIO",check:"Number",align:"RIGHT"}],output:"Colour",colour:"%{BKY_COLOUR_HUE}",helpUrl:"%{BKY_COLOUR_BLEND_HELPURL}",tooltip:"%{BKY_COLOUR_BLEND_TOOLTIP}"}]);Blockly.Blocks.lists={};Blockly.Constants.Lists={};Blockly.Constants.Lists.HUE=260;Blockly.Blocks.lists.HUE=Blockly.Constants.Lists.HUE;Blockly.defineBlocksWithJsonArray([{type:"lists_create_empty",message0:"%{BKY_LISTS_CREATE_EMPTY_TITLE}",output:"Array",colour:"%{BKY_LISTS_HUE}",tooltip:"%{BKY_LISTS_CREATE_EMPTY_TOOLTIP}",helpUrl:"%{BKY_LISTS_CREATE_EMPTY_HELPURL}"},{type:"lists_repeat",message0:"%{BKY_LISTS_REPEAT_TITLE}",args0:[{type:"input_value",name:"ITEM"},{type:"input_value",name:"NUM",check:"Number"}],output:"Array",colour:"%{BKY_LISTS_HUE}",tooltip:"%{BKY_LISTS_REPEAT_TOOLTIP}",helpUrl:"%{BKY_LISTS_REPEAT_HELPURL}"},{type:"lists_reverse",message0:"%{BKY_LISTS_REVERSE_MESSAGE0}",args0:[{type:"input_value",name:"LIST",check:"Array"}],output:"Array",inputsInline:!0,colour:"%{BKY_LISTS_HUE}",tooltip:"%{BKY_LISTS_REVERSE_TOOLTIP}",helpUrl:"%{BKY_LISTS_REVERSE_HELPURL}"},{type:"lists_isEmpty",message0:"%{BKY_LISTS_ISEMPTY_TITLE}",args0:[{type:"input_value",name:"VALUE",check:["String","Array"]}],output:"Boolean",colour:"%{BKY_LISTS_HUE}",tooltip:"%{BKY_LISTS_ISEMPTY_TOOLTIP}",helpUrl:"%{BKY_LISTS_ISEMPTY_HELPURL}"},{type:"lists_length",message0:"%{BKY_LISTS_LENGTH_TITLE}",args0:[{type:"input_value",name:"VALUE",check:["String","Array"]}],output:"Number",colour:"%{BKY_LISTS_HUE}",tooltip:"%{BKY_LISTS_LENGTH_TOOLTIP}",helpUrl:"%{BKY_LISTS_LENGTH_HELPURL}"}]);
-Blockly.Blocks.lists_create_with={init:function(){this.setHelpUrl(Blockly.Msg.LISTS_CREATE_WITH_HELPURL);this.setColour(Blockly.Blocks.lists.HUE);this.itemCount_=3;this.updateShape_();this.setOutput(!0,"Array");this.setMutator(new Blockly.Mutator(["lists_create_with_item"]));this.setTooltip(Blockly.Msg.LISTS_CREATE_WITH_TOOLTIP)},mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("items",this.itemCount_);return a},domToMutation:function(a){this.itemCount_=parseInt(a.getAttribute("items"),10);this.updateShape_()},decompose:function(a){var b=a.newBlock("lists_create_with_container");b.initSvg();for(var c=b.getInput("STACK").connection,d=0;d<this.itemCount_;d++){var e=a.newBlock("lists_create_with_item");e.initSvg();c.connect(e.previousConnection);c=e.nextConnection}return b},compose:function(a){var b=a.getInputTargetBlock("STACK");for(a=[];b;){a.push(b.valueConnection_),b=b.nextConnection&&b.nextConnection.targetBlock()}for(b=0;b<this.itemCount_;b++){var c=this.getInput("ADD"+b).connection.targetConnection;c&&-1==a.indexOf(c)&&c.disconnect()}this.itemCount_=a.length;this.updateShape_();for(b=0;b<this.itemCount_;b++){Blockly.Mutator.reconnect(a[b],this,"ADD"+b)}},saveConnections:function(a){a=a.getInputTargetBlock("STACK");for(var b=0;a;){var c=this.getInput("ADD"+b);a.valueConnection_=c&&c.connection.targetConnection;b++;a=a.nextConnection&&a.nextConnection.targetBlock()}},updateShape_:function(){this.itemCount_&&this.getInput("EMPTY")?this.removeInput("EMPTY"):this.itemCount_||this.getInput("EMPTY")||this.appendDummyInput("EMPTY").appendField(Blockly.Msg.LISTS_CREATE_EMPTY_TITLE);for(var a=0;a<this.itemCount_;a++){if(!this.getInput("ADD"+a)){var b=this.appendValueInput("ADD"+a);0==a&&b.appendField(Blockly.Msg.LISTS_CREATE_WITH_INPUT_WITH)}}for(;this.getInput("ADD"+a);){this.removeInput("ADD"+a),a++}}};Blockly.Blocks.lists_create_with_container={init:function(){this.setColour(Blockly.Blocks.lists.HUE);this.appendDummyInput().appendField(Blockly.Msg.LISTS_CREATE_WITH_CONTAINER_TITLE_ADD);
-this.appendStatementInput("STACK");this.setTooltip(Blockly.Msg.LISTS_CREATE_WITH_CONTAINER_TOOLTIP);this.contextMenu=!1}};Blockly.Blocks.lists_create_with_item={init:function(){this.setColour(Blockly.Blocks.lists.HUE);this.appendDummyInput().appendField(Blockly.Msg.LISTS_CREATE_WITH_ITEM_TITLE);this.setPreviousStatement(!0);this.setNextStatement(!0);this.setTooltip(Blockly.Msg.LISTS_CREATE_WITH_ITEM_TOOLTIP);this.contextMenu=!1}};Blockly.Blocks.lists_indexOf={init:function(){var a=[[Blockly.Msg.LISTS_INDEX_OF_FIRST,"FIRST"],[Blockly.Msg.LISTS_INDEX_OF_LAST,"LAST"]];this.setHelpUrl(Blockly.Msg.LISTS_INDEX_OF_HELPURL);this.setColour(Blockly.Blocks.lists.HUE);this.setOutput(!0,"Number");this.appendValueInput("VALUE").setCheck("Array").appendField(Blockly.Msg.LISTS_INDEX_OF_INPUT_IN_LIST);this.appendValueInput("FIND").appendField(new Blockly.FieldDropdown(a),"END");this.setInputsInline(!0);var b=this;this.setTooltip(function(){return Blockly.Msg.LISTS_INDEX_OF_TOOLTIP.replace("%1",b.workspace.options.oneBasedIndex?"0":"-1")})}};Blockly.Blocks.lists_getIndex={init:function(){var a=[[Blockly.Msg.LISTS_GET_INDEX_GET,"GET"],[Blockly.Msg.LISTS_GET_INDEX_GET_REMOVE,"GET_REMOVE"],[Blockly.Msg.LISTS_GET_INDEX_REMOVE,"REMOVE"]];this.WHERE_OPTIONS=[[Blockly.Msg.LISTS_GET_INDEX_FROM_START,"FROM_START"],[Blockly.Msg.LISTS_GET_INDEX_FROM_END,"FROM_END"],[Blockly.Msg.LISTS_GET_INDEX_FIRST,"FIRST"],[Blockly.Msg.LISTS_GET_INDEX_LAST,"LAST"],[Blockly.Msg.LISTS_GET_INDEX_RANDOM,"RANDOM"]];this.setHelpUrl(Blockly.Msg.LISTS_GET_INDEX_HELPURL);this.setColour(Blockly.Blocks.lists.HUE);a=new Blockly.FieldDropdown(a,function(a){this.sourceBlock_.updateStatement_("REMOVE"==a)});this.appendValueInput("VALUE").setCheck("Array").appendField(Blockly.Msg.LISTS_GET_INDEX_INPUT_IN_LIST);this.appendDummyInput().appendField(a,"MODE").appendField("","SPACE");this.appendDummyInput("AT");Blockly.Msg.LISTS_GET_INDEX_TAIL&&this.appendDummyInput("TAIL").appendField(Blockly.Msg.LISTS_GET_INDEX_TAIL);this.setInputsInline(!0);
-this.setOutput(!0);this.updateAt_(!0);var b=this;this.setTooltip(function(){var a=b.getFieldValue("MODE"),d=b.getFieldValue("WHERE"),e="";switch(a+" "+d){case"GET FROM_START":case"GET FROM_END":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_FROM;break;case"GET FIRST":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_FIRST;break;case"GET LAST":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_LAST;break;case"GET RANDOM":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_RANDOM;break;case"GET_REMOVE FROM_START":case"GET_REMOVE FROM_END":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FROM;break;case"GET_REMOVE FIRST":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FIRST;break;case"GET_REMOVE LAST":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_LAST;break;case"GET_REMOVE RANDOM":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_RANDOM;break;case"REMOVE FROM_START":case"REMOVE FROM_END":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_FROM;break;case"REMOVE FIRST":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_FIRST;break;case"REMOVE LAST":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_LAST;break;case"REMOVE RANDOM":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_RANDOM}if("FROM_START"==d||"FROM_END"==d){e+="  "+("FROM_START"==d?Blockly.Msg.LISTS_INDEX_FROM_START_TOOLTIP:Blockly.Msg.LISTS_INDEX_FROM_END_TOOLTIP).replace("%1",b.workspace.options.oneBasedIndex?"#1":"#0")}return e})},mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("statement",!this.outputConnection);var b=this.getInput("AT").type==Blockly.INPUT_VALUE;a.setAttribute("at",b);return a},domToMutation:function(a){var b="true"==a.getAttribute("statement");this.updateStatement_(b);a="false"!=a.getAttribute("at");this.updateAt_(a)},updateStatement_:function(a){a!=!this.outputConnection&&(this.unplug(!0,!0),a?(this.setOutput(!1),this.setPreviousStatement(!0),this.setNextStatement(!0)):(this.setPreviousStatement(!1),this.setNextStatement(!1),this.setOutput(!0)))},updateAt_:function(a){this.removeInput("AT");this.removeInput("ORDINAL",!0);
-a?(this.appendValueInput("AT").setCheck("Number"),Blockly.Msg.ORDINAL_NUMBER_SUFFIX&&this.appendDummyInput("ORDINAL").appendField(Blockly.Msg.ORDINAL_NUMBER_SUFFIX)):this.appendDummyInput("AT");var b=new Blockly.FieldDropdown(this.WHERE_OPTIONS,function(b){var c="FROM_START"==b||"FROM_END"==b;if(c!=a){var e=this.sourceBlock_;e.updateAt_(c);e.setFieldValue(b,"WHERE");return null}});this.getInput("AT").appendField(b,"WHERE");Blockly.Msg.LISTS_GET_INDEX_TAIL&&this.moveInputBefore("TAIL",null)}};Blockly.Blocks.lists_setIndex={init:function(){var a=[[Blockly.Msg.LISTS_SET_INDEX_SET,"SET"],[Blockly.Msg.LISTS_SET_INDEX_INSERT,"INSERT"]];this.WHERE_OPTIONS=[[Blockly.Msg.LISTS_GET_INDEX_FROM_START,"FROM_START"],[Blockly.Msg.LISTS_GET_INDEX_FROM_END,"FROM_END"],[Blockly.Msg.LISTS_GET_INDEX_FIRST,"FIRST"],[Blockly.Msg.LISTS_GET_INDEX_LAST,"LAST"],[Blockly.Msg.LISTS_GET_INDEX_RANDOM,"RANDOM"]];this.setHelpUrl(Blockly.Msg.LISTS_SET_INDEX_HELPURL);this.setColour(Blockly.Blocks.lists.HUE);this.appendValueInput("LIST").setCheck("Array").appendField(Blockly.Msg.LISTS_SET_INDEX_INPUT_IN_LIST);this.appendDummyInput().appendField(new Blockly.FieldDropdown(a),"MODE").appendField("","SPACE");this.appendDummyInput("AT");this.appendValueInput("TO").appendField(Blockly.Msg.LISTS_SET_INDEX_INPUT_TO);this.setInputsInline(!0);this.setPreviousStatement(!0);this.setNextStatement(!0);this.setTooltip(Blockly.Msg.LISTS_SET_INDEX_TOOLTIP);this.updateAt_(!0);var b=this;this.setTooltip(function(){var a=b.getFieldValue("MODE"),d=b.getFieldValue("WHERE"),e="";switch(a+" "+d){case"SET FROM_START":case"SET FROM_END":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_FROM;break;case"SET FIRST":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_FIRST;break;case"SET LAST":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_LAST;break;case"SET RANDOM":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_RANDOM;break;case"INSERT FROM_START":case"INSERT FROM_END":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_FROM;break;case"INSERT FIRST":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_FIRST;
-break;case"INSERT LAST":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_LAST;break;case"INSERT RANDOM":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_RANDOM}if("FROM_START"==d||"FROM_END"==d){e+="  "+Blockly.Msg.LISTS_INDEX_FROM_START_TOOLTIP.replace("%1",b.workspace.options.oneBasedIndex?"#1":"#0")}return e})},mutationToDom:function(){var a=document.createElement("mutation"),b=this.getInput("AT").type==Blockly.INPUT_VALUE;a.setAttribute("at",b);return a},domToMutation:function(a){a="false"!=a.getAttribute("at");this.updateAt_(a)},updateAt_:function(a){this.removeInput("AT");this.removeInput("ORDINAL",!0);a?(this.appendValueInput("AT").setCheck("Number"),Blockly.Msg.ORDINAL_NUMBER_SUFFIX&&this.appendDummyInput("ORDINAL").appendField(Blockly.Msg.ORDINAL_NUMBER_SUFFIX)):this.appendDummyInput("AT");var b=new Blockly.FieldDropdown(this.WHERE_OPTIONS,function(b){var c="FROM_START"==b||"FROM_END"==b;if(c!=a){var e=this.sourceBlock_;e.updateAt_(c);e.setFieldValue(b,"WHERE");return null}});this.moveInputBefore("AT","TO");this.getInput("ORDINAL")&&this.moveInputBefore("ORDINAL","TO");this.getInput("AT").appendField(b,"WHERE")}};Blockly.Blocks.lists_getSublist={init:function(){this.WHERE_OPTIONS_1=[[Blockly.Msg.LISTS_GET_SUBLIST_START_FROM_START,"FROM_START"],[Blockly.Msg.LISTS_GET_SUBLIST_START_FROM_END,"FROM_END"],[Blockly.Msg.LISTS_GET_SUBLIST_START_FIRST,"FIRST"]];this.WHERE_OPTIONS_2=[[Blockly.Msg.LISTS_GET_SUBLIST_END_FROM_START,"FROM_START"],[Blockly.Msg.LISTS_GET_SUBLIST_END_FROM_END,"FROM_END"],[Blockly.Msg.LISTS_GET_SUBLIST_END_LAST,"LAST"]];this.setHelpUrl(Blockly.Msg.LISTS_GET_SUBLIST_HELPURL);this.setColour(Blockly.Blocks.lists.HUE);this.appendValueInput("LIST").setCheck("Array").appendField(Blockly.Msg.LISTS_GET_SUBLIST_INPUT_IN_LIST);this.appendDummyInput("AT1");this.appendDummyInput("AT2");Blockly.Msg.LISTS_GET_SUBLIST_TAIL&&this.appendDummyInput("TAIL").appendField(Blockly.Msg.LISTS_GET_SUBLIST_TAIL);this.setInputsInline(!0);this.setOutput(!0,"Array");this.updateAt_(1,!0);
-this.updateAt_(2,!0);this.setTooltip(Blockly.Msg.LISTS_GET_SUBLIST_TOOLTIP)},mutationToDom:function(){var a=document.createElement("mutation"),b=this.getInput("AT1").type==Blockly.INPUT_VALUE;a.setAttribute("at1",b);b=this.getInput("AT2").type==Blockly.INPUT_VALUE;a.setAttribute("at2",b);return a},domToMutation:function(a){var b="true"==a.getAttribute("at1");a="true"==a.getAttribute("at2");this.updateAt_(1,b);this.updateAt_(2,a)},updateAt_:function(a,b){this.removeInput("AT"+a);this.removeInput("ORDINAL"+a,!0);b?(this.appendValueInput("AT"+a).setCheck("Number"),Blockly.Msg.ORDINAL_NUMBER_SUFFIX&&this.appendDummyInput("ORDINAL"+a).appendField(Blockly.Msg.ORDINAL_NUMBER_SUFFIX)):this.appendDummyInput("AT"+a);var c=new Blockly.FieldDropdown(this["WHERE_OPTIONS_"+a],function(c){var d="FROM_START"==c||"FROM_END"==c;if(d!=b){var f=this.sourceBlock_;f.updateAt_(a,d);f.setFieldValue(c,"WHERE"+a);return null}});this.getInput("AT"+a).appendField(c,"WHERE"+a);1==a&&(this.moveInputBefore("AT1","AT2"),this.getInput("ORDINAL1")&&this.moveInputBefore("ORDINAL1","AT2"));Blockly.Msg.LISTS_GET_SUBLIST_TAIL&&this.moveInputBefore("TAIL",null)}};Blockly.Blocks.lists_sort={init:function(){this.jsonInit({message0:Blockly.Msg.LISTS_SORT_TITLE,args0:[{type:"field_dropdown",name:"TYPE",options:[[Blockly.Msg.LISTS_SORT_TYPE_NUMERIC,"NUMERIC"],[Blockly.Msg.LISTS_SORT_TYPE_TEXT,"TEXT"],[Blockly.Msg.LISTS_SORT_TYPE_IGNORECASE,"IGNORE_CASE"]]},{type:"field_dropdown",name:"DIRECTION",options:[[Blockly.Msg.LISTS_SORT_ORDER_ASCENDING,"1"],[Blockly.Msg.LISTS_SORT_ORDER_DESCENDING,"-1"]]},{type:"input_value",name:"LIST",check:"Array"}],output:"Array",colour:Blockly.Blocks.lists.HUE,tooltip:Blockly.Msg.LISTS_SORT_TOOLTIP,helpUrl:Blockly.Msg.LISTS_SORT_HELPURL})}};Blockly.Blocks.lists_split={init:function(){var a=this,b=new Blockly.FieldDropdown([[Blockly.Msg.LISTS_SPLIT_LIST_FROM_TEXT,"SPLIT"],[Blockly.Msg.LISTS_SPLIT_TEXT_FROM_LIST,"JOIN"]],function(b){a.updateType_(b)});this.setHelpUrl(Blockly.Msg.LISTS_SPLIT_HELPURL);
-this.setColour(Blockly.Blocks.lists.HUE);this.appendValueInput("INPUT").setCheck("String").appendField(b,"MODE");this.appendValueInput("DELIM").setCheck("String").appendField(Blockly.Msg.LISTS_SPLIT_WITH_DELIMITER);this.setInputsInline(!0);this.setOutput(!0,"Array");this.setTooltip(function(){var b=a.getFieldValue("MODE");if("SPLIT"==b){return Blockly.Msg.LISTS_SPLIT_TOOLTIP_SPLIT}if("JOIN"==b){return Blockly.Msg.LISTS_SPLIT_TOOLTIP_JOIN}throw"Unknown mode: "+b})},updateType_:function(a){"SPLIT"==a?(this.outputConnection.setCheck("Array"),this.getInput("INPUT").setCheck("String")):(this.outputConnection.setCheck("String"),this.getInput("INPUT").setCheck("Array"))},mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("mode",this.getFieldValue("MODE"));return a},domToMutation:function(a){this.updateType_(a.getAttribute("mode"))}};Blockly.Blocks.logic={};Blockly.Constants.Logic={};Blockly.Constants.Logic.HUE=210;Blockly.Blocks.logic.HUE=Blockly.Constants.Logic.HUE;Blockly.defineBlocksWithJsonArray([{type:"logic_boolean",message0:"%1",args0:[{type:"field_dropdown",name:"BOOL",options:[["%{BKY_LOGIC_BOOLEAN_TRUE}","TRUE"],["%{BKY_LOGIC_BOOLEAN_FALSE}","FALSE"]]}],output:"Boolean",colour:"%{BKY_LOGIC_HUE}",tooltip:"%{BKY_LOGIC_BOOLEAN_TOOLTIP}",helpUrl:"%{BKY_LOGIC_BOOLEAN_HELPURL}"},{type:"controls_if",message0:"%{BKY_CONTROLS_IF_MSG_IF} %1",args0:[{type:"input_value",name:"IF0",check:"Boolean"}],message1:"%{BKY_CONTROLS_IF_MSG_THEN} %1",args1:[{type:"input_statement",name:"DO0"}],previousStatement:null,nextStatement:null,colour:"%{BKY_LOGIC_HUE}",helpUrl:"%{BKY_CONTROLS_IF_HELPURL}",mutator:"controls_if_mutator",extensions:["controls_if_tooltip"]},{type:"controls_ifelse",message0:"%{BKY_CONTROLS_IF_MSG_IF} %1",args0:[{type:"input_value",name:"IF0",check:"Boolean"}],message1:"%{BKY_CONTROLS_IF_MSG_THEN} %1",args1:[{type:"input_statement",name:"DO0"}],message2:"%{BKY_CONTROLS_IF_MSG_ELSE} %1",args2:[{type:"input_statement",name:"ELSE"}],previousStatement:null,nextStatement:null,colour:"%{BKY_LOGIC_HUE}",tooltip:"%{BKYCONTROLS_IF_TOOLTIP_2}",helpUrl:"%{BKY_CONTROLS_IF_HELPURL}",extensions:["controls_if_tooltip"]},{type:"logic_compare",message0:"%1 %2 %3",args0:[{type:"input_value",name:"A"},{type:"field_dropdown",name:"OP",options:[["=","EQ"],["\u2260","NEQ"],["<","LT"],["\u2264","LTE"],[">","GT"],["\u2265","GTE"]]},{type:"input_value",name:"B"}],inputsInline:!0,output:null,colour:"%{BKY_LOGIC_HUE}",helpUrl:"%{BKY_LOGIC_COMPARE_HELPURL}",extensions:["logic_compare","logic_op_tooltip"]},{type:"logic_operation",message0:"%1 %2 %3",args0:[{type:"input_value",name:"A",check:null},{type:"field_dropdown",name:"OP",options:[["%{BKY_LOGIC_OPERATION_AND}","AND"],["%{BKY_LOGIC_OPERATION_OR}","OR"]]},{type:"input_value",name:"B",check:null}],inputsInline:!0,output:null,colour:"%{BKY_LOGIC_HUE}",helpUrl:"%{BKY_LOGIC_OPERATION_HELPURL}",extensions:["logic_op_tooltip"]},{type:"logic_negate",message0:"%{BKY_LOGIC_NEGATE_TITLE}",args0:[{type:"input_value",name:"BOOL",check:null}],output:null,colour:"%{BKY_LOGIC_HUE}",tooltip:"%{BKY_LOGIC_NEGATE_TOOLTIP}",helpUrl:"%{BKY_LOGIC_NEGATE_HELPURL}"},{type:"logic_null",message0:"%{BKY_LOGIC_NULL}",output:null,colour:"%{BKY_LOGIC_HUE}",tooltip:"%{BKY_LOGIC_NULL_TOOLTIP}",helpUrl:"%{BKY_LOGIC_NULL_HELPURL}"},{type:"logic_ternary",message0:"%{BKY_LOGIC_TERNARY_CONDITION} %1",args0:[{type:"input_value",name:"IF",check:"Boolean"}],message1:"%{BKY_LOGIC_TERNARY_IF_TRUE} %1",args1:[{type:"input_value",name:"THEN"}],message2:"%{BKY_LOGIC_TERNARY_IF_FALSE} %1",args2:[{type:"input_value",name:"ELSE"}],output:null,colour:"%{BKY_LOGIC_HUE}",tooltip:"%{BKY_LOGIC_TERNARY_TOOLTIP}",helpUrl:"%{BKY_LOGIC_TERNARY_HELPURL}",extensions:["logic_ternary"]}]);
-Blockly.defineBlocksWithJsonArray([{type:"controls_if_if",message0:"%{BKY_CONTROLS_IF_IF_TITLE_IF}",nextStatement:null,enableContextMenu:!1,colour:"%{BKY_LOGIC_HUE}",tooltip:"%{BKY_CONTROLS_IF_IF_TOOLTIP}"},{type:"controls_if_elseif",message0:"%{BKY_CONTROLS_IF_ELSEIF_TITLE_ELSEIF}",previousStatement:null,nextStatement:null,enableContextMenu:!1,colour:"%{BKY_LOGIC_HUE}",tooltip:"%{BKY_CONTROLS_IF_ELSEIF_TOOLTIP}"},{type:"controls_if_else",message0:"%{BKY_CONTROLS_IF_ELSE_TITLE_ELSE}",previousStatement:null,enableContextMenu:!1,colour:"%{BKY_LOGIC_HUE}",tooltip:"%{BKY_CONTROLS_IF_ELSE_TOOLTIP}"}]);Blockly.Constants.Logic.TOOLTIPS_BY_OP={EQ:"%{BKY_LOGIC_COMPARE_TOOLTIP_EQ}",NEQ:"%{BKY_LOGIC_COMPARE_TOOLTIP_NEQ}",LT:"%{BKY_LOGIC_COMPARE_TOOLTIP_LT}",LTE:"%{BKY_LOGIC_COMPARE_TOOLTIP_LTE}",GT:"%{BKY_LOGIC_COMPARE_TOOLTIP_GT}",GTE:"%{BKY_LOGIC_COMPARE_TOOLTIP_GTE}",AND:"%{BKY_LOGIC_OPERATION_TOOLTIP_AND}",OR:"%{BKY_LOGIC_OPERATION_TOOLTIP_OR}"};Blockly.Extensions.register("logic_op_tooltip",Blockly.Extensions.buildTooltipForDropdown("OP",Blockly.Constants.Logic.TOOLTIPS_BY_OP));Blockly.Constants.Logic.CONTROLS_IF_MUTATOR_MIXIN={elseifCount_:0,elseCount_:0,mutationToDom:function(){if(!this.elseifCount_&&!this.elseCount_){return null}var a=document.createElement("mutation");this.elseifCount_&&a.setAttribute("elseif",this.elseifCount_);this.elseCount_&&a.setAttribute("else",1);return a},domToMutation:function(a){this.elseifCount_=parseInt(a.getAttribute("elseif"),10)||0;this.elseCount_=parseInt(a.getAttribute("else"),10)||0;this.updateShape_()},decompose:function(a){var b=a.newBlock("controls_if_if");b.initSvg();for(var c=b.nextConnection,d=1;d<=this.elseifCount_;d++){var e=a.newBlock("controls_if_elseif");e.initSvg();c.connect(e.previousConnection);c=e.nextConnection}this.elseCount_&&(a=a.newBlock("controls_if_else"),a.initSvg(),c.connect(a.previousConnection));return b},compose:function(a){var b=a.nextConnection.targetBlock();this.elseCount_=this.elseifCount_=0;a=[null];for(var c=[null],d=null;
-b;){switch(b.type){case"controls_if_elseif":this.elseifCount_++;a.push(b.valueConnection_);c.push(b.statementConnection_);break;case"controls_if_else":this.elseCount_++;d=b.statementConnection_;break;default:throw"Unknown block type."}b=b.nextConnection&&b.nextConnection.targetBlock()}this.updateShape_();for(b=1;b<=this.elseifCount_;b++){Blockly.Mutator.reconnect(a[b],this,"IF"+b),Blockly.Mutator.reconnect(c[b],this,"DO"+b)}Blockly.Mutator.reconnect(d,this,"ELSE")},saveConnections:function(a){a=a.nextConnection.targetBlock();for(var b=1;a;){switch(a.type){case"controls_if_elseif":var c=this.getInput("IF"+b),d=this.getInput("DO"+b);a.valueConnection_=c&&c.connection.targetConnection;a.statementConnection_=d&&d.connection.targetConnection;b++;break;case"controls_if_else":d=this.getInput("ELSE");a.statementConnection_=d&&d.connection.targetConnection;break;default:throw"Unknown block type."}a=a.nextConnection&&a.nextConnection.targetBlock()}},updateShape_:function(){this.getInput("ELSE")&&this.removeInput("ELSE");for(var a=1;this.getInput("IF"+a);){this.removeInput("IF"+a),this.removeInput("DO"+a),a++}for(a=1;a<=this.elseifCount_;a++){this.appendValueInput("IF"+a).setCheck("Boolean").appendField(Blockly.Msg.CONTROLS_IF_MSG_ELSEIF),this.appendStatementInput("DO"+a).appendField(Blockly.Msg.CONTROLS_IF_MSG_THEN)}this.elseCount_&&this.appendStatementInput("ELSE").appendField(Blockly.Msg.CONTROLS_IF_MSG_ELSE)}};Blockly.Extensions.registerMutator("controls_if_mutator",Blockly.Constants.Logic.CONTROLS_IF_MUTATOR_MIXIN,null,["controls_if_elseif","controls_if_else"]);Blockly.Constants.Logic.CONTROLS_IF_TOOLTIP_EXTENSION=function(){this.setTooltip(function(){if(this.elseifCount_||this.elseCount_){if(!this.elseifCount_&&this.elseCount_){return Blockly.Msg.CONTROLS_IF_TOOLTIP_2}if(this.elseifCount_&&!this.elseCount_){return Blockly.Msg.CONTROLS_IF_TOOLTIP_3}if(this.elseifCount_&&this.elseCount_){return Blockly.Msg.CONTROLS_IF_TOOLTIP_4}}else{return Blockly.Msg.CONTROLS_IF_TOOLTIP_1
-}return""}.bind(this))};Blockly.Extensions.register("controls_if_tooltip",Blockly.Constants.Logic.CONTROLS_IF_TOOLTIP_EXTENSION);Blockly.Constants.Logic.fixLogicCompareRtlOpLabels=function(){var a={LT:"\u200f<\u200f",LTE:"\u200f\u2264\u200f",GT:"\u200f>\u200f",GTE:"\u200f\u2265\u200f"},b=this.getField("OP");if(b){b=b.getOptions();for(var c=0;c<b.length;++c){var d=b[c],e=a[d[1]];goog.isString(d[0])&&e&&(d[0]=e)}}};Blockly.Constants.Logic.LOGIC_COMPARE_ONCHANGE_MIXIN={prevBlocks_:[null,null],onchange:function(a){var b=this.getInputTargetBlock("A"),c=this.getInputTargetBlock("B");if(b&&c&&!b.outputConnection.checkType_(c.outputConnection)){Blockly.Events.setGroup(a.group);for(a=0;a<this.prevBlocks_.length;a++){var d=this.prevBlocks_[a];if(d===b||d===c){d.unplug(),d.bumpNeighbours_()}}Blockly.Events.setGroup(!1)}this.prevBlocks_[0]=b;this.prevBlocks_[1]=c}};Blockly.Constants.Logic.LOGIC_COMPARE_EXTENSION=function(){this.RTL&&Blockly.Constants.Logic.fixLogicCompareRtlOpLabels.apply(this);this.mixin(Blockly.Constants.Logic.LOGIC_COMPARE_ONCHANGE_MIXIN)};Blockly.Extensions.register("logic_compare",Blockly.Constants.Logic.LOGIC_COMPARE_EXTENSION);Blockly.Constants.Logic.LOGIC_TERNARY_ONCHANGE_MIXIN={prevParentConnection_:null,onchange:function(a){var b=this.getInputTargetBlock("THEN"),c=this.getInputTargetBlock("ELSE"),d=this.outputConnection.targetConnection;if((b||c)&&d){for(var e=0;2>e;e++){var f=1==e?b:c;f&&!f.outputConnection.checkType_(d)&&(Blockly.Events.setGroup(a.group),d===this.prevParentConnection_?(this.unplug(),d.getSourceBlock().bumpNeighbours_()):(f.unplug(),f.bumpNeighbours_()),Blockly.Events.setGroup(!1))}}this.prevParentConnection_=d}};Blockly.Extensions.registerMixin("logic_ternary",Blockly.Constants.Logic.LOGIC_TERNARY_ONCHANGE_MIXIN);Blockly.Blocks.loops={};Blockly.Constants.Loops={};Blockly.Constants.Loops.HUE=120;Blockly.Blocks.loops.HUE=Blockly.Constants.Loops.HUE;Blockly.defineBlocksWithJsonArray([{type:"controls_repeat_ext",message0:"%{BKY_CONTROLS_REPEAT_TITLE}",args0:[{type:"input_value",name:"TIMES",check:"Number"}],message1:"%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",args1:[{type:"input_statement",name:"DO"}],previousStatement:null,nextStatement:null,colour:"%{BKY_LOOPS_HUE}",tooltip:"%{BKY_CONTROLS_REPEAT_TOOLTIP}",helpUrl:"%{BKY_CONTROLS_REPEAT_HELPURL}"},{type:"controls_repeat",message0:"%{BKY_CONTROLS_REPEAT_TITLE}",args0:[{type:"field_number",name:"TIMES",value:10,min:0,precision:1}],message1:"%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",args1:[{type:"input_statement",name:"DO"}],previousStatement:null,nextStatement:null,colour:"%{BKY_LOOPS_HUE}",tooltip:"%{BKY_CONTROLS_REPEAT_TOOLTIP}",helpUrl:"%{BKY_CONTROLS_REPEAT_HELPURL}"},{type:"controls_whileUntil",message0:"%1 %2",args0:[{type:"field_dropdown",name:"MODE",options:[["%{BKY_CONTROLS_WHILEUNTIL_OPERATOR_WHILE}","WHILE"],["%{BKY_CONTROLS_WHILEUNTIL_OPERATOR_UNTIL}","UNTIL"]]},{type:"input_value",name:"BOOL",check:"Boolean"}],message1:"%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",args1:[{type:"input_statement",name:"DO"}],previousStatement:null,nextStatement:null,colour:"%{BKY_LOOPS_HUE}",helpUrl:"%{BKY_CONTROLS_WHILEUNTIL_HELPURL}",extensions:["controls_whileUntil_tooltip"]},{type:"controls_for",message0:"%{BKY_CONTROLS_FOR_TITLE}",args0:[{type:"field_variable",name:"VAR",variable:null},{type:"input_value",name:"FROM",check:"Number",align:"RIGHT"},{type:"input_value",name:"TO",check:"Number",align:"RIGHT"},{type:"input_value",name:"BY",check:"Number",align:"RIGHT"}],message1:"%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",args1:[{type:"input_statement",name:"DO"}],inputsInline:!0,previousStatement:null,nextStatement:null,colour:"%{BKY_LOOPS_HUE}",helpUrl:"%{BKY_CONTROLS_FOR_HELPURL}",extensions:["contextMenu_newGetVariableBlock","controls_for_tooltip"]},{type:"controls_forEach",message0:"%{BKY_CONTROLS_FOREACH_TITLE}",args0:[{type:"field_variable",name:"VAR",variable:null},{type:"input_value",name:"LIST",check:"Array"}],message1:"%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",args1:[{type:"input_statement",name:"DO"}],previousStatement:null,nextStatement:null,colour:"%{BKY_LOOPS_HUE}",helpUrl:"%{BKY_CONTROLS_FOREACH_HELPURL}",extensions:["contextMenu_newGetVariableBlock","controls_forEach_tooltip"]},{type:"controls_flow_statements",message0:"%1",args0:[{type:"field_dropdown",name:"FLOW",options:[["%{BKY_CONTROLS_FLOW_STATEMENTS_OPERATOR_BREAK}","BREAK"],["%{BKY_CONTROLS_FLOW_STATEMENTS_OPERATOR_CONTINUE}","CONTINUE"]]}],previousStatement:null,colour:"%{BKY_LOOPS_HUE}",helpUrl:"%{BKY_CONTROLS_FLOW_STATEMENTS_HELPURL}",extensions:["controls_flow_tooltip","controls_flow_in_loop_check"]}]);
-Blockly.Constants.Loops.WHILE_UNTIL_TOOLTIPS={WHILE:"%{BKY_CONTROLS_WHILEUNTIL_TOOLTIP_WHILE}",UNTIL:"%{BKY_CONTROLS_WHILEUNTIL_TOOLTIP_UNTIL}"};Blockly.Extensions.register("controls_whileUntil_tooltip",Blockly.Extensions.buildTooltipForDropdown("MODE",Blockly.Constants.Loops.WHILE_UNTIL_TOOLTIPS));Blockly.Constants.Loops.BREAK_CONTINUE_TOOLTIPS={BREAK:"%{BKY_CONTROLS_FLOW_STATEMENTS_TOOLTIP_BREAK}",CONTINUE:"%{BKY_CONTROLS_FLOW_STATEMENTS_TOOLTIP_CONTINUE}"};Blockly.Extensions.register("controls_flow_tooltip",Blockly.Extensions.buildTooltipForDropdown("FLOW",Blockly.Constants.Loops.BREAK_CONTINUE_TOOLTIPS));Blockly.Constants.Loops.CUSTOM_CONTEXT_MENU_CREATE_VARIABLES_GET_MIXIN={customContextMenu:function(a){var b=this.getFieldValue("VAR");if(!this.isCollapsed()&&null!=b){var c={enabled:!0};c.text=Blockly.Msg.VARIABLES_SET_CREATE_GET.replace("%1",b);b=goog.dom.createDom("field",null,b);b.setAttribute("name","VAR");b=goog.dom.createDom("block",null,b);b.setAttribute("type","variables_get");c.callback=Blockly.ContextMenu.callbackFactory(this,b);a.push(c)}}};Blockly.Extensions.registerMixin("contextMenu_newGetVariableBlock",Blockly.Constants.Loops.CUSTOM_CONTEXT_MENU_CREATE_VARIABLES_GET_MIXIN);Blockly.Extensions.register("controls_for_tooltip",Blockly.Extensions.buildTooltipWithFieldValue("%{BKY_CONTROLS_FOR_TOOLTIP}","VAR"));Blockly.Extensions.register("controls_forEach_tooltip",Blockly.Extensions.buildTooltipWithFieldValue("%{BKY_CONTROLS_FOREACH_TOOLTIP}","VAR"));Blockly.Constants.Loops.CONTROL_FLOW_IN_LOOP_CHECK_MIXIN={LOOP_TYPES:["controls_repeat","controls_repeat_ext","controls_forEach","controls_for","controls_whileUntil"],onchange:function(){if(this.workspace.isDragging&&!this.workspace.isDragging()){var a=!1,b=this;do{if(-1!=this.LOOP_TYPES.indexOf(b.type)){a=!0;break}b=b.getSurroundParent()}while(b);a?(this.setWarningText(null),this.isInFlyout||this.setDisabled(!1)):(this.setWarningText(Blockly.Msg.CONTROLS_FLOW_STATEMENTS_WARNING),this.isInFlyout||this.getInheritedDisabled()||this.setDisabled(!0))
-}}};Blockly.Extensions.registerMixin("controls_flow_in_loop_check",Blockly.Constants.Loops.CONTROL_FLOW_IN_LOOP_CHECK_MIXIN);Blockly.Blocks.math={};Blockly.Constants.Math={};Blockly.Constants.Math.HUE=230;Blockly.Blocks.math.HUE=Blockly.Constants.Math.HUE;Blockly.defineBlocksWithJsonArray([{type:"math_number",message0:"%1",args0:[{type:"field_number",name:"NUM",value:0}],output:"Number",colour:"%{BKY_MATH_HUE}",helpUrl:"%{BKY_MATH_NUMBER_HELPURL}",tooltip:"%{BKY_MATH_NUMBER_TOOLTIP}",extensions:["parent_tooltip_when_inline"]},{type:"math_arithmetic",message0:"%1 %2 %3",args0:[{type:"input_value",name:"A",check:"Number"},{type:"field_dropdown",name:"OP",options:[["%{BKY_MATH_ADDITION_SYMBOL}","ADD"],["%{BKY_MATH_SUBTRACTION_SYMBOL}","MINUS"],["%{BKY_MATH_MULTIPLICATION_SYMBOL}","MULTIPLY"],["%{BKY_MATH_DIVISION_SYMBOL}","DIVIDE"],["%{BKY_MATH_POWER_SYMBOL}","POWER"]]},{type:"input_value",name:"B",check:"Number"}],inputsInline:!0,output:"Number",colour:"%{BKY_MATH_HUE}",helpUrl:"%{BKY_MATH_ARITHMETIC_HELPURL}",extensions:["math_op_tooltip"]},{type:"math_single",message0:"%1 %2",args0:[{type:"field_dropdown",name:"OP",options:[["%{BKY_MATH_SINGLE_OP_ROOT}","ROOT"],["%{BKY_MATH_SINGLE_OP_ABSOLUTE}","ABS"],["-","NEG"],["ln","LN"],["log10","LOG10"],["e^","EXP"],["10^","POW10"]]},{type:"input_value",name:"NUM",check:"Number"}],output:"Number",colour:"%{BKY_MATH_HUE}",helpUrl:"%{BKY_MATH_SINGLE_HELPURL}",extensions:["math_op_tooltip"]},{type:"math_trig",message0:"%1 %2",args0:[{type:"field_dropdown",name:"OP",options:[["%{BKY_MATH_TRIG_SIN}","SIN"],["%{BKY_MATH_TRIG_COS}","COS"],["%{BKY_MATH_TRIG_TAN}","TAN"],["%{BKY_MATH_TRIG_ASIN}","ASIN"],["%{BKY_MATH_TRIG_ACOS}","ACOS"],["%{BKY_MATH_TRIG_ATAN}","ATAN"]]},{type:"input_value",name:"NUM",check:"Number"}],output:"Number",colour:"%{BKY_MATH_HUE}",helpUrl:"%{BKY_MATH_TRIG_HELPURL}",extensions:["math_op_tooltip"]},{type:"math_constant",message0:"%1",args0:[{type:"field_dropdown",name:"CONSTANT",options:[["\u03c0","PI"],["e","E"],["\u03c6","GOLDEN_RATIO"],["sqrt(2)","SQRT2"],["sqrt(\u00bd)","SQRT1_2"],["\u221e","INFINITY"]]}],output:"Number",colour:"%{BKY_MATH_HUE}",tooltip:"%{BKY_MATH_CONSTANT_TOOLTIP}",helpUrl:"%{BKY_MATH_CONSTANT_HELPURL}"},{type:"math_number_property",message0:"%1 %2",args0:[{type:"input_value",name:"NUMBER_TO_CHECK",check:"Number"},{type:"field_dropdown",name:"PROPERTY",options:[["%{BKY_MATH_IS_EVEN}","EVEN"],["%{BKY_MATH_IS_ODD}","ODD"],["%{BKY_MATH_IS_PRIME}","PRIME"],["%{BKY_MATH_IS_WHOLE}","WHOLE"],["%{BKY_MATH_IS_POSITIVE}","POSITIVE"],["%{BKY_MATH_IS_NEGATIVE}","NEGATIVE"],["%{BKY_MATH_IS_DIVISIBLE_BY}","DIVISIBLE_BY"]]}],inputsInline:!0,output:"Boolean",colour:"%{BKY_MATH_HUE}",tooltip:"%{BKY_MATH_IS_TOOLTIP}",mutator:"math_is_divisibleby_mutator"},{type:"math_change",message0:"%{BKY_MATH_CHANGE_TITLE}",args0:[{type:"field_variable",name:"VAR",variable:"%{BKY_MATH_CHANGE_TITLE_ITEM}"},{type:"input_value",name:"DELTA",check:"Number"}],previousStatement:null,nextStatement:null,colour:"%{BKY_VARIABLES_HUE}",helpUrl:"%{BKY_MATH_CHANGE_HELPURL}",extensions:["math_change_tooltip"]},{type:"math_round",message0:"%1 %2",args0:[{type:"field_dropdown",name:"OP",options:[["%{BKY_MATH_ROUND_OPERATOR_ROUND}","ROUND"],["%{BKY_MATH_ROUND_OPERATOR_ROUNDUP}","ROUNDUP"],["%{BKY_MATH_ROUND_OPERATOR_ROUNDDOWN}","ROUNDDOWN"]]},{type:"input_value",name:"NUM",check:"Number"}],output:"Number",colour:"%{BKY_MATH_HUE}",helpUrl:"%{BKY_MATH_ROUND_HELPURL}",tooltip:"%{BKY_MATH_ROUND_TOOLTIP}"},{type:"math_on_list",message0:"%1 %2",args0:[{type:"field_dropdown",name:"OP",options:[["%{BKY_MATH_ONLIST_OPERATOR_SUM}","SUM"],["%{BKY_MATH_ONLIST_OPERATOR_MIN}","MIN"],["%{BKY_MATH_ONLIST_OPERATOR_MAX}","MAX"],["%{BKY_MATH_ONLIST_OPERATOR_AVERAGE}","AVERAGE"],["%{BKY_MATH_ONLIST_OPERATOR_MEDIAN}","MEDIAN"],["%{BKY_MATH_ONLIST_OPERATOR_MODE}","MODE"],["%{BKY_MATH_ONLIST_OPERATOR_STD_DEV}","STD_DEV"],["%{BKY_MATH_ONLIST_OPERATOR_RANDOM}","RANDOM"]]},{type:"input_value",name:"LIST",check:"Array"}],output:"Number",colour:"%{BKY_MATH_HUE}",helpUrl:"%{BKY_MATH_ONLIST_HELPURL}",mutator:"math_modes_of_list_mutator",extensions:["math_op_tooltip"]},{type:"math_modulo",message0:"%{BKY_MATH_MODULO_TITLE}",args0:[{type:"input_value",name:"DIVIDEND",check:"Number"},{type:"input_value",name:"DIVISOR",check:"Number"}],inputsInline:!0,output:"Number",colour:"%{BKY_MATH_HUE}",tooltip:"%{BKY_MATH_MODULO_TOOLTIP}",helpUrl:"%{BKY_MATH_MODULO_HELPURL}"},{type:"math_constrain",message0:"%{BKY_MATH_CONSTRAIN_TITLE}",args0:[{type:"input_value",name:"VALUE",check:"Number"},{type:"input_value",name:"LOW",check:"Number"},{type:"input_value",name:"HIGH",check:"Number"}],inputsInline:!0,output:"Number",colour:"%{BKY_MATH_HUE}",tooltip:"%{BKY_MATH_CONSTRAIN_TOOLTIP}",helpUrl:"%{BKY_MATH_CONSTRAIN_HELPURL}"},{type:"math_random_int",message0:"%{BKY_MATH_RANDOM_INT_TITLE}",args0:[{type:"input_value",name:"FROM",check:"Number"},{type:"input_value",name:"TO",check:"Number"}],inputsInline:!0,output:"Number",colour:"%{BKY_MATH_HUE}",tooltip:"%{BKY_MATH_RANDOM_INT_TOOLTIP}",helpUrl:"%{BKY_MATH_RANDOM_INT_HELPURL}"},{type:"math_random_float",message0:"%{BKY_MATH_RANDOM_FLOAT_TITLE_RANDOM}",output:"Number",colour:"%{BKY_MATH_HUE}",tooltip:"%{BKY_MATH_RANDOM_FLOAT_TOOLTIP}",helpUrl:"%{BKY_MATH_RANDOM_FLOAT_HELPURL}"}]);
-Blockly.Constants.Math.TOOLTIPS_BY_OP={ADD:"%{BKY_MATH_ARITHMETIC_TOOLTIP_ADD}",MINUS:"%{BKY_MATH_ARITHMETIC_TOOLTIP_MINUS}",MULTIPLY:"%{BKY_MATH_ARITHMETIC_TOOLTIP_MULTIPLY}",DIVIDE:"%{BKY_MATH_ARITHMETIC_TOOLTIP_DIVIDE}",POWER:"%{BKY_MATH_ARITHMETIC_TOOLTIP_POWER}",ROOT:"%{BKY_MATH_SINGLE_TOOLTIP_ROOT}",ABS:"%{BKY_MATH_SINGLE_TOOLTIP_ABS}",NEG:"%{BKY_MATH_SINGLE_TOOLTIP_NEG}",LN:"%{BKY_MATH_SINGLE_TOOLTIP_LN}",LOG10:"%{BKY_MATH_SINGLE_TOOLTIP_LOG10}",EXP:"%{BKY_MATH_SINGLE_TOOLTIP_EXP}",POW10:"%{BKY_MATH_SINGLE_TOOLTIP_POW10}",SIN:"%{BKY_MATH_TRIG_TOOLTIP_SIN}",COS:"%{BKY_MATH_TRIG_TOOLTIP_COS}",TAN:"%{BKY_MATH_TRIG_TOOLTIP_TAN}",ASIN:"%{BKY_MATH_TRIG_TOOLTIP_ASIN}",ACOS:"%{BKY_MATH_TRIG_TOOLTIP_ACOS}",ATAN:"%{BKY_MATH_TRIG_TOOLTIP_ATAN}",SUM:"%{BKY_MATH_ONLIST_TOOLTIP_SUM}",MIN:"%{BKY_MATH_ONLIST_TOOLTIP_MIN}",MAX:"%{BKY_MATH_ONLIST_TOOLTIP_MAX}",AVERAGE:"%{BKY_MATH_ONLIST_TOOLTIP_AVERAGE}",MEDIAN:"%{BKY_MATH_ONLIST_TOOLTIP_MEDIAN}",MODE:"%{BKY_MATH_ONLIST_TOOLTIP_MODE}",STD_DEV:"%{BKY_MATH_ONLIST_TOOLTIP_STD_DEV}",RANDOM:"%{BKY_MATH_ONLIST_TOOLTIP_RANDOM}"};Blockly.Extensions.register("math_op_tooltip",Blockly.Extensions.buildTooltipForDropdown("OP",Blockly.Constants.Math.TOOLTIPS_BY_OP));Blockly.Constants.Math.IS_DIVISIBLEBY_MUTATOR_MIXIN={mutationToDom:function(){var a=document.createElement("mutation"),b="DIVISIBLE_BY"==this.getFieldValue("PROPERTY");a.setAttribute("divisor_input",b);return a},domToMutation:function(a){a="true"==a.getAttribute("divisor_input");this.updateShape_(a)},updateShape_:function(a){var b=this.getInput("DIVISOR");a?b||this.appendValueInput("DIVISOR").setCheck("Number"):b&&this.removeInput("DIVISOR")}};Blockly.Constants.Math.IS_DIVISIBLE_MUTATOR_EXTENSION=function(){this.getField("PROPERTY").setValidator(function(a){this.sourceBlock_.updateShape_("DIVISIBLE_BY"==a)})};Blockly.Extensions.registerMutator("math_is_divisibleby_mutator",Blockly.Constants.Math.IS_DIVISIBLEBY_MUTATOR_MIXIN,Blockly.Constants.Math.IS_DIVISIBLE_MUTATOR_EXTENSION);
-Blockly.Constants.Math.CHANGE_TOOLTIP_EXTENSION=function(){this.setTooltip(function(){return Blockly.Msg.MATH_CHANGE_TOOLTIP.replace("%1",this.getFieldValue("VAR"))}.bind(this))};Blockly.Extensions.register("math_change_tooltip",Blockly.Extensions.buildTooltipWithFieldValue("%{BKY_MATH_CHANGE_TOOLTIP}","VAR"));Blockly.Constants.Math.LIST_MODES_MUTATOR_MIXIN={updateType_:function(a){"MODE"==a?this.outputConnection.setCheck("Array"):this.outputConnection.setCheck("Number")},mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("op",this.getFieldValue("OP"));return a},domToMutation:function(a){this.updateType_(a.getAttribute("op"))}};Blockly.Constants.Math.LIST_MODES_MUTATOR_EXTENSION=function(){this.getField("OP").setValidator(function(a){this.updateType_(a)}.bind(this))};Blockly.Extensions.registerMutator("math_modes_of_list_mutator",Blockly.Constants.Math.LIST_MODES_MUTATOR_MIXIN,Blockly.Constants.Math.LIST_MODES_MUTATOR_EXTENSION);Blockly.Blocks.procedures={};Blockly.Blocks.procedures.HUE=290;Blockly.Blocks.procedures_defnoreturn={init:function(){var a=new Blockly.FieldTextInput("",Blockly.Procedures.rename);a.setSpellcheck(!1);this.appendDummyInput().appendField(Blockly.Msg.PROCEDURES_DEFNORETURN_TITLE).appendField(a,"NAME").appendField("","PARAMS");this.setMutator(new Blockly.Mutator(["procedures_mutatorarg"]));(this.workspace.options.comments||this.workspace.options.parentWorkspace&&this.workspace.options.parentWorkspace.options.comments)&&Blockly.Msg.PROCEDURES_DEFNORETURN_COMMENT&&this.setCommentText(Blockly.Msg.PROCEDURES_DEFNORETURN_COMMENT);this.setColour(Blockly.Blocks.procedures.HUE);this.setTooltip(Blockly.Msg.PROCEDURES_DEFNORETURN_TOOLTIP);this.setHelpUrl(Blockly.Msg.PROCEDURES_DEFNORETURN_HELPURL);this.arguments_=[];this.setStatements_(!0);this.statementConnection_=null},setStatements_:function(a){this.hasStatements_!==a&&(a?(this.appendStatementInput("STACK").appendField(Blockly.Msg.PROCEDURES_DEFNORETURN_DO),this.getInput("RETURN")&&this.moveInputBefore("STACK","RETURN")):this.removeInput("STACK",!0),this.hasStatements_=a)
-},updateParams_:function(){for(var a=!1,b={},c=0;c<this.arguments_.length;c++){if(b["arg_"+this.arguments_[c].toLowerCase()]){a=!0;break}b["arg_"+this.arguments_[c].toLowerCase()]=!0}a?this.setWarningText(Blockly.Msg.PROCEDURES_DEF_DUPLICATE_WARNING):this.setWarningText(null);a="";this.arguments_.length&&(a=Blockly.Msg.PROCEDURES_BEFORE_PARAMS+" "+this.arguments_.join(", "));Blockly.Events.disable();try{this.setFieldValue(a,"PARAMS")}finally{Blockly.Events.enable()}},mutationToDom:function(a){var b=document.createElement("mutation");a&&b.setAttribute("name",this.getFieldValue("NAME"));for(var c=0;c<this.arguments_.length;c++){var d=document.createElement("arg");d.setAttribute("name",this.arguments_[c]);a&&this.paramIds_&&d.setAttribute("paramId",this.paramIds_[c]);b.appendChild(d)}this.hasStatements_||b.setAttribute("statements","false");return b},domToMutation:function(a){this.arguments_=[];for(var b=0,c;c=a.childNodes[b];b++){"arg"==c.nodeName.toLowerCase()&&this.arguments_.push(c.getAttribute("name"))}this.updateParams_();Blockly.Procedures.mutateCallers(this);this.setStatements_("false"!==a.getAttribute("statements"))},decompose:function(a){var b=a.newBlock("procedures_mutatorcontainer");b.initSvg();this.getInput("RETURN")?b.setFieldValue(this.hasStatements_?"TRUE":"FALSE","STATEMENTS"):b.getInput("STATEMENT_INPUT").setVisible(!1);for(var c=b.getInput("STACK").connection,d=0;d<this.arguments_.length;d++){var e=a.newBlock("procedures_mutatorarg");e.initSvg();e.setFieldValue(this.arguments_[d],"NAME");e.oldLocation=d;c.connect(e.previousConnection);c=e.nextConnection}Blockly.Procedures.mutateCallers(this);return b},compose:function(a){this.arguments_=[];this.paramIds_=[];for(var b=a.getInputTargetBlock("STACK");b;){this.arguments_.push(b.getFieldValue("NAME")),this.paramIds_.push(b.id),b=b.nextConnection&&b.nextConnection.targetBlock()}this.updateParams_();Blockly.Procedures.mutateCallers(this);a=a.getFieldValue("STATEMENTS");if(null!==a&&(a="TRUE"==a,this.hasStatements_!=a)){if(a){this.setStatements_(!0),Blockly.Mutator.reconnect(this.statementConnection_,this,"STACK"),this.statementConnection_=null
-}else{a=this.getInput("STACK").connection;if(this.statementConnection_=a.targetConnection){a=a.targetBlock(),a.unplug(),a.bumpNeighbours_()}this.setStatements_(!1)}}},getProcedureDef:function(){return[this.getFieldValue("NAME"),this.arguments_,!1]},getVars:function(){return this.arguments_},renameVar:function(a,b){for(var c=!1,d=0;d<this.arguments_.length;d++){Blockly.Names.equals(a,this.arguments_[d])&&(this.arguments_[d]=b,c=!0)}if(c&&(this.updateParams_(),this.mutator.isVisible())){c=this.mutator.workspace_.getAllBlocks();d=0;for(var e;e=c[d];d++){"procedures_mutatorarg"==e.type&&Blockly.Names.equals(a,e.getFieldValue("NAME"))&&e.setFieldValue(b,"NAME")}}},customContextMenu:function(a){var b={enabled:!0},c=this.getFieldValue("NAME");b.text=Blockly.Msg.PROCEDURES_CREATE_DO.replace("%1",c);var d=goog.dom.createDom("mutation");d.setAttribute("name",c);for(var e=0;e<this.arguments_.length;e++){c=goog.dom.createDom("arg"),c.setAttribute("name",this.arguments_[e]),d.appendChild(c)}d=goog.dom.createDom("block",null,d);d.setAttribute("type",this.callType_);b.callback=Blockly.ContextMenu.callbackFactory(this,d);a.push(b);if(!this.isCollapsed()){for(e=0;e<this.arguments_.length;e++){b={enabled:!0},c=this.arguments_[e],b.text=Blockly.Msg.VARIABLES_SET_CREATE_GET.replace("%1",c),d=goog.dom.createDom("field",null,c),d.setAttribute("name","VAR"),d=goog.dom.createDom("block",null,d),d.setAttribute("type","variables_get"),b.callback=Blockly.ContextMenu.callbackFactory(this,d),a.push(b)}}},callType_:"procedures_callnoreturn"};Blockly.Blocks.procedures_defreturn={init:function(){var a=new Blockly.FieldTextInput("",Blockly.Procedures.rename);a.setSpellcheck(!1);this.appendDummyInput().appendField(Blockly.Msg.PROCEDURES_DEFRETURN_TITLE).appendField(a,"NAME").appendField("","PARAMS");this.appendValueInput("RETURN").setAlign(Blockly.ALIGN_RIGHT).appendField(Blockly.Msg.PROCEDURES_DEFRETURN_RETURN);this.setMutator(new Blockly.Mutator(["procedures_mutatorarg"]));(this.workspace.options.comments||this.workspace.options.parentWorkspace&&this.workspace.options.parentWorkspace.options.comments)&&Blockly.Msg.PROCEDURES_DEFRETURN_COMMENT&&this.setCommentText(Blockly.Msg.PROCEDURES_DEFRETURN_COMMENT);
-this.setColour(Blockly.Blocks.procedures.HUE);this.setTooltip(Blockly.Msg.PROCEDURES_DEFRETURN_TOOLTIP);this.setHelpUrl(Blockly.Msg.PROCEDURES_DEFRETURN_HELPURL);this.arguments_=[];this.setStatements_(!0);this.statementConnection_=null},setStatements_:Blockly.Blocks.procedures_defnoreturn.setStatements_,updateParams_:Blockly.Blocks.procedures_defnoreturn.updateParams_,mutationToDom:Blockly.Blocks.procedures_defnoreturn.mutationToDom,domToMutation:Blockly.Blocks.procedures_defnoreturn.domToMutation,decompose:Blockly.Blocks.procedures_defnoreturn.decompose,compose:Blockly.Blocks.procedures_defnoreturn.compose,getProcedureDef:function(){return[this.getFieldValue("NAME"),this.arguments_,!0]},getVars:Blockly.Blocks.procedures_defnoreturn.getVars,renameVar:Blockly.Blocks.procedures_defnoreturn.renameVar,customContextMenu:Blockly.Blocks.procedures_defnoreturn.customContextMenu,callType_:"procedures_callreturn"};Blockly.Blocks.procedures_mutatorcontainer={init:function(){this.appendDummyInput().appendField(Blockly.Msg.PROCEDURES_MUTATORCONTAINER_TITLE);this.appendStatementInput("STACK");this.appendDummyInput("STATEMENT_INPUT").appendField(Blockly.Msg.PROCEDURES_ALLOW_STATEMENTS).appendField(new Blockly.FieldCheckbox("TRUE"),"STATEMENTS");this.setColour(Blockly.Blocks.procedures.HUE);this.setTooltip(Blockly.Msg.PROCEDURES_MUTATORCONTAINER_TOOLTIP);this.contextMenu=!1}};Blockly.Blocks.procedures_mutatorarg={init:function(){var a=new Blockly.FieldTextInput("x",this.validator_);this.appendDummyInput().appendField(Blockly.Msg.PROCEDURES_MUTATORARG_TITLE).appendField(a,"NAME");this.setPreviousStatement(!0);this.setNextStatement(!0);this.setColour(Blockly.Blocks.procedures.HUE);this.setTooltip(Blockly.Msg.PROCEDURES_MUTATORARG_TOOLTIP);this.contextMenu=!1;a.onFinishEditing_=this.createNewVar_;a.onFinishEditing_("x")},validator_:function(a){return(a=a.replace(/[\s\xa0]+/g," ").replace(/^ | $/g,""))||null},createNewVar_:function(a){var b=this.sourceBlock_;if(b&&b.workspace&&b.workspace.options&&b.workspace.options.parentWorkspace){b=b.workspace.options.parentWorkspace;
-var c=b.getVariable(a);c&&c.name!==a?b.renameVariableById(c.getId(),a):b.createVariable(a)}}};Blockly.Blocks.procedures_callnoreturn={init:function(){this.appendDummyInput("TOPROW").appendField(this.id,"NAME");this.setPreviousStatement(!0);this.setNextStatement(!0);this.setColour(Blockly.Blocks.procedures.HUE);this.setHelpUrl(Blockly.Msg.PROCEDURES_CALLNORETURN_HELPURL);this.arguments_=[];this.quarkConnections_={};this.quarkIds_=null},getProcedureCall:function(){return this.getFieldValue("NAME")},renameProcedure:function(a,b){Blockly.Names.equals(a,this.getProcedureCall())&&(this.setFieldValue(b,"NAME"),this.setTooltip((this.outputConnection?Blockly.Msg.PROCEDURES_CALLRETURN_TOOLTIP:Blockly.Msg.PROCEDURES_CALLNORETURN_TOOLTIP).replace("%1",b)))},setProcedureParameters_:function(a,b){var c=Blockly.Procedures.getDefinition(this.getProcedureCall(),this.workspace),d=c&&c.mutator&&c.mutator.isVisible();d||(this.quarkConnections_={},this.quarkIds_=null);if(b){if(goog.array.equals(this.arguments_,a)){this.quarkIds_=b}else{if(b.length!=a.length){throw"Error: paramNames and paramIds must be the same length."}this.setCollapsed(!1);this.quarkIds_||(this.quarkConnections_={},a.join("\n")==this.arguments_.join("\n")?this.quarkIds_=b:this.quarkIds_=[]);c=this.rendered;this.rendered=!1;for(var e=0;e<this.arguments_.length;e++){var f=this.getInput("ARG"+e);f&&(f=f.connection.targetConnection,this.quarkConnections_[this.quarkIds_[e]]=f,d&&f&&-1==b.indexOf(this.quarkIds_[e])&&(f.disconnect(),f.getSourceBlock().bumpNeighbours_()))}this.arguments_=[].concat(a);this.updateShape_();if(this.quarkIds_=b){for(e=0;e<this.arguments_.length;e++){d=this.quarkIds_[e],d in this.quarkConnections_&&(f=this.quarkConnections_[d],Blockly.Mutator.reconnect(f,this,"ARG"+e)||delete this.quarkConnections_[d])}}(this.rendered=c)&&this.render()}}},updateShape_:function(){for(var a=0;a<this.arguments_.length;a++){var b=this.getField("ARGNAME"+a);if(b){Blockly.Events.disable();try{b.setValue(this.arguments_[a])
-}finally{Blockly.Events.enable()}}else{b=new Blockly.FieldLabel(this.arguments_[a]),this.appendValueInput("ARG"+a).setAlign(Blockly.ALIGN_RIGHT).appendField(b,"ARGNAME"+a).init()}}for(;this.getInput("ARG"+a);){this.removeInput("ARG"+a),a++}if(a=this.getInput("TOPROW")){this.arguments_.length?this.getField("WITH")||(a.appendField(Blockly.Msg.PROCEDURES_CALL_BEFORE_PARAMS,"WITH"),a.init()):this.getField("WITH")&&a.removeField("WITH")}},mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("name",this.getProcedureCall());for(var b=0;b<this.arguments_.length;b++){var c=document.createElement("arg");c.setAttribute("name",this.arguments_[b]);a.appendChild(c)}return a},domToMutation:function(a){var b=a.getAttribute("name");this.renameProcedure(this.getProcedureCall(),b);b=[];for(var c=[],d=0,e;e=a.childNodes[d];d++){"arg"==e.nodeName.toLowerCase()&&(b.push(e.getAttribute("name")),c.push(e.getAttribute("paramId")))}this.setProcedureParameters_(b,c)},renameVar:function(a,b){for(var c=0;c<this.arguments_.length;c++){Blockly.Names.equals(a,this.arguments_[c])&&(this.arguments_[c]=b,this.getField("ARGNAME"+c).setValue(b))}},onchange:function(a){if(this.workspace&&!this.workspace.isFlyout){if(a.type==Blockly.Events.BLOCK_CREATE&&-1!=a.ids.indexOf(this.id)){var b=this.getProcedureCall();b=Blockly.Procedures.getDefinition(b,this.workspace);!b||b.type==this.defType_&&JSON.stringify(b.arguments_)==JSON.stringify(this.arguments_)||(b=null);if(!b){Blockly.Events.setGroup(a.group);a=goog.dom.createDom("xml");b=goog.dom.createDom("block");b.setAttribute("type",this.defType_);var c=this.getRelativeToSurfaceXY(),d=c.y+2*Blockly.SNAP_RADIUS;b.setAttribute("x",c.x+Blockly.SNAP_RADIUS*(this.RTL?-1:1));b.setAttribute("y",d);c=this.mutationToDom();b.appendChild(c);c=goog.dom.createDom("field");c.setAttribute("name","NAME");c.appendChild(document.createTextNode(this.getProcedureCall()));b.appendChild(c);a.appendChild(b);Blockly.Xml.domToWorkspace(a,this.workspace);Blockly.Events.setGroup(!1)
-}}else{a.type==Blockly.Events.BLOCK_DELETE&&(b=this.getProcedureCall(),b=Blockly.Procedures.getDefinition(b,this.workspace),b||(Blockly.Events.setGroup(a.group),this.dispose(!0,!1),Blockly.Events.setGroup(!1)))}}},customContextMenu:function(a){var b={enabled:!0};b.text=Blockly.Msg.PROCEDURES_HIGHLIGHT_DEF;var c=this.getProcedureCall(),d=this.workspace;b.callback=function(){var a=Blockly.Procedures.getDefinition(c,d);a&&a.select()};a.push(b)},defType_:"procedures_defnoreturn"};Blockly.Blocks.procedures_callreturn={init:function(){this.appendDummyInput("TOPROW").appendField("","NAME");this.setOutput(!0);this.setColour(Blockly.Blocks.procedures.HUE);this.setHelpUrl(Blockly.Msg.PROCEDURES_CALLRETURN_HELPURL);this.arguments_=[];this.quarkConnections_={};this.quarkIds_=null},getProcedureCall:Blockly.Blocks.procedures_callnoreturn.getProcedureCall,renameProcedure:Blockly.Blocks.procedures_callnoreturn.renameProcedure,setProcedureParameters_:Blockly.Blocks.procedures_callnoreturn.setProcedureParameters_,updateShape_:Blockly.Blocks.procedures_callnoreturn.updateShape_,mutationToDom:Blockly.Blocks.procedures_callnoreturn.mutationToDom,domToMutation:Blockly.Blocks.procedures_callnoreturn.domToMutation,renameVar:Blockly.Blocks.procedures_callnoreturn.renameVar,onchange:Blockly.Blocks.procedures_callnoreturn.onchange,customContextMenu:Blockly.Blocks.procedures_callnoreturn.customContextMenu,defType_:"procedures_defreturn"};Blockly.Blocks.procedures_ifreturn={init:function(){this.appendValueInput("CONDITION").setCheck("Boolean").appendField(Blockly.Msg.CONTROLS_IF_MSG_IF);this.appendValueInput("VALUE").appendField(Blockly.Msg.PROCEDURES_DEFRETURN_RETURN);this.setInputsInline(!0);this.setPreviousStatement(!0);this.setNextStatement(!0);this.setColour(Blockly.Blocks.procedures.HUE);this.setTooltip(Blockly.Msg.PROCEDURES_IFRETURN_TOOLTIP);this.setHelpUrl(Blockly.Msg.PROCEDURES_IFRETURN_HELPURL);this.hasReturnValue_=!0},mutationToDom:function(){var a=document.createElement("mutation");
-a.setAttribute("value",Number(this.hasReturnValue_));return a},domToMutation:function(a){this.hasReturnValue_=1==a.getAttribute("value");this.hasReturnValue_||(this.removeInput("VALUE"),this.appendDummyInput("VALUE").appendField(Blockly.Msg.PROCEDURES_DEFRETURN_RETURN))},onchange:function(){if(this.workspace.isDragging&&!this.workspace.isDragging()){var a=!1,b=this;do{if(-1!=this.FUNCTION_TYPES.indexOf(b.type)){a=!0;break}b=b.getSurroundParent()}while(b);a?("procedures_defnoreturn"==b.type&&this.hasReturnValue_?(this.removeInput("VALUE"),this.appendDummyInput("VALUE").appendField(Blockly.Msg.PROCEDURES_DEFRETURN_RETURN),this.hasReturnValue_=!1):"procedures_defreturn"!=b.type||this.hasReturnValue_||(this.removeInput("VALUE"),this.appendValueInput("VALUE").appendField(Blockly.Msg.PROCEDURES_DEFRETURN_RETURN),this.hasReturnValue_=!0),this.setWarningText(null),this.isInFlyout||this.setDisabled(!1)):(this.setWarningText(Blockly.Msg.PROCEDURES_IFRETURN_WARNING),this.isInFlyout||this.getInheritedDisabled()||this.setDisabled(!0))}},FUNCTION_TYPES:["procedures_defnoreturn","procedures_defreturn"]};Blockly.Blocks.texts={};Blockly.Constants.Text={};Blockly.Constants.Text.HUE=160;Blockly.Blocks.texts.HUE=Blockly.Constants.Text.HUE;Blockly.defineBlocksWithJsonArray([{type:"text",message0:"%1",args0:[{type:"field_input",name:"TEXT",text:""}],output:"String",colour:"%{BKY_TEXTS_HUE}",helpUrl:"%{BKY_TEXT_TEXT_HELPURL}",tooltip:"%{BKY_TEXT_TEXT_TOOLTIP}",extensions:["text_quotes","parent_tooltip_when_inline"]},{type:"text_join",message0:"",output:"String",colour:"%{BKY_TEXTS_HUE}",helpUrl:"%{BKY_TEXT_JOIN_HELPURL}",tooltip:"%{BKY_TEXT_JOIN_TOOLTIP}",mutator:"text_join_mutator"},{type:"text_create_join_container",message0:"%{BKY_TEXT_CREATE_JOIN_TITLE_JOIN} %1 %2",args0:[{type:"input_dummy"},{type:"input_statement",name:"STACK"}],colour:"%{BKY_TEXTS_HUE}",tooltip:"%{BKY_TEXT_CREATE_JOIN_TOOLTIP}",enableContextMenu:!1},{type:"text_create_join_item",message0:"%{BKY_TEXT_CREATE_JOIN_ITEM_TITLE_ITEM}",previousStatement:null,nextStatement:null,colour:"%{BKY_TEXTS_HUE}",tooltip:"{%BKY_TEXT_CREATE_JOIN_ITEM_TOOLTIP}",enableContextMenu:!1},{type:"text_append",message0:"%{BKY_TEXT_APPEND_TITLE}",args0:[{type:"field_variable",name:"VAR",variable:"%{BKY_TEXT_APPEND_VARIABLE}"},{type:"input_value",name:"TEXT"}],previousStatement:null,nextStatement:null,colour:"%{BKY_TEXTS_HUE}",extensions:["text_append_tooltip"]},{type:"text_length",message0:"%{BKY_TEXT_LENGTH_TITLE}",args0:[{type:"input_value",name:"VALUE",check:["String","Array"]}],output:"Number",colour:"%{BKY_TEXTS_HUE}",tooltip:"%{BKY_TEXT_LENGTH_TOOLTIP}",helpUrl:"%{BKY_TEXT_LENGTH_HELPURL}"},{type:"text_isEmpty",message0:"%{BKY_TEXT_ISEMPTY_TITLE}",args0:[{type:"input_value",name:"VALUE",check:["String","Array"]}],output:"Boolean",colour:"%{BKY_TEXTS_HUE}",tooltip:"%{BKY_TEXT_ISEMPTY_TOOLTIP}",helpUrl:"%{BKY_TEXT_ISEMPTY_HELPURL}"},{type:"text_indexOf",message0:"%{BKY_TEXT_INDEXOF_TITLE}",args0:[{type:"input_value",name:"VALUE",check:"String"},{type:"field_dropdown",name:"END",options:[["%{BKY_TEXT_INDEXOF_OPERATOR_FIRST}","FIRST"],["%{BKY_TEXT_INDEXOF_OPERATOR_LAST}","LAST"]]},{type:"input_value",name:"FIND",check:"String"}],output:"Number",colour:"%{BKY_TEXTS_HUE}",helpUrl:"%{BKY_TEXT_INDEXOF_HELPURL}",inputsInline:!0,extensions:["text_indexOf_tooltip"]},{type:"text_charAt",message0:"%{BKY_TEXT_CHARAT_TITLE}",args0:[{type:"input_value",name:"VALUE",check:"String"},{type:"field_dropdown",name:"WHERE",options:[["%{BKY_TEXT_CHARAT_FROM_START}","FROM_START"],["%{BKY_TEXT_CHARAT_FROM_END}","FROM_END"],["%{BKY_TEXT_CHARAT_FIRST}","FIRST"],["%{BKY_TEXT_CHARAT_LAST}","LAST"],["%{BKY_TEXT_CHARAT_RANDOM}","RANDOM"]]}],output:"String",colour:"%{BKY_TEXTS_HUE}",helpUrl:"%{BKY_TEXT_CHARAT_HELPURL}",inputsInline:!0,mutator:"text_charAt_mutator"}]);
-Blockly.Blocks.text_getSubstring={init:function(){this.WHERE_OPTIONS_1=[[Blockly.Msg.TEXT_GET_SUBSTRING_START_FROM_START,"FROM_START"],[Blockly.Msg.TEXT_GET_SUBSTRING_START_FROM_END,"FROM_END"],[Blockly.Msg.TEXT_GET_SUBSTRING_START_FIRST,"FIRST"]];this.WHERE_OPTIONS_2=[[Blockly.Msg.TEXT_GET_SUBSTRING_END_FROM_START,"FROM_START"],[Blockly.Msg.TEXT_GET_SUBSTRING_END_FROM_END,"FROM_END"],[Blockly.Msg.TEXT_GET_SUBSTRING_END_LAST,"LAST"]];this.setHelpUrl(Blockly.Msg.TEXT_GET_SUBSTRING_HELPURL);this.setColour(Blockly.Blocks.texts.HUE);this.appendValueInput("STRING").setCheck("String").appendField(Blockly.Msg.TEXT_GET_SUBSTRING_INPUT_IN_TEXT);this.appendDummyInput("AT1");this.appendDummyInput("AT2");Blockly.Msg.TEXT_GET_SUBSTRING_TAIL&&this.appendDummyInput("TAIL").appendField(Blockly.Msg.TEXT_GET_SUBSTRING_TAIL);this.setInputsInline(!0);this.setOutput(!0,"String");this.updateAt_(1,!0);this.updateAt_(2,!0);this.setTooltip(Blockly.Msg.TEXT_GET_SUBSTRING_TOOLTIP)},mutationToDom:function(){var a=document.createElement("mutation"),b=this.getInput("AT1").type==Blockly.INPUT_VALUE;a.setAttribute("at1",b);b=this.getInput("AT2").type==Blockly.INPUT_VALUE;a.setAttribute("at2",b);return a},domToMutation:function(a){var b="true"==a.getAttribute("at1");a="true"==a.getAttribute("at2");this.updateAt_(1,b);this.updateAt_(2,a)},updateAt_:function(a,b){this.removeInput("AT"+a);this.removeInput("ORDINAL"+a,!0);b?(this.appendValueInput("AT"+a).setCheck("Number"),Blockly.Msg.ORDINAL_NUMBER_SUFFIX&&this.appendDummyInput("ORDINAL"+a).appendField(Blockly.Msg.ORDINAL_NUMBER_SUFFIX)):this.appendDummyInput("AT"+a);2==a&&Blockly.Msg.TEXT_GET_SUBSTRING_TAIL&&(this.removeInput("TAIL",!0),this.appendDummyInput("TAIL").appendField(Blockly.Msg.TEXT_GET_SUBSTRING_TAIL));var c=new Blockly.FieldDropdown(this["WHERE_OPTIONS_"+a],function(c){var d="FROM_START"==c||"FROM_END"==c;if(d!=b){var f=this.sourceBlock_;f.updateAt_(a,d);f.setFieldValue(c,"WHERE"+a);return null}});this.getInput("AT"+a).appendField(c,"WHERE"+a);
-1==a&&this.moveInputBefore("AT1","AT2")}};Blockly.Blocks.text_changeCase={init:function(){var a=[[Blockly.Msg.TEXT_CHANGECASE_OPERATOR_UPPERCASE,"UPPERCASE"],[Blockly.Msg.TEXT_CHANGECASE_OPERATOR_LOWERCASE,"LOWERCASE"],[Blockly.Msg.TEXT_CHANGECASE_OPERATOR_TITLECASE,"TITLECASE"]];this.setHelpUrl(Blockly.Msg.TEXT_CHANGECASE_HELPURL);this.setColour(Blockly.Blocks.texts.HUE);this.appendValueInput("TEXT").setCheck("String").appendField(new Blockly.FieldDropdown(a),"CASE");this.setOutput(!0,"String");this.setTooltip(Blockly.Msg.TEXT_CHANGECASE_TOOLTIP)}};Blockly.Blocks.text_trim={init:function(){var a=[[Blockly.Msg.TEXT_TRIM_OPERATOR_BOTH,"BOTH"],[Blockly.Msg.TEXT_TRIM_OPERATOR_LEFT,"LEFT"],[Blockly.Msg.TEXT_TRIM_OPERATOR_RIGHT,"RIGHT"]];this.setHelpUrl(Blockly.Msg.TEXT_TRIM_HELPURL);this.setColour(Blockly.Blocks.texts.HUE);this.appendValueInput("TEXT").setCheck("String").appendField(new Blockly.FieldDropdown(a),"MODE");this.setOutput(!0,"String");this.setTooltip(Blockly.Msg.TEXT_TRIM_TOOLTIP)}};Blockly.Blocks.text_print={init:function(){this.jsonInit({message0:Blockly.Msg.TEXT_PRINT_TITLE,args0:[{type:"input_value",name:"TEXT"}],previousStatement:null,nextStatement:null,colour:Blockly.Blocks.texts.HUE,tooltip:Blockly.Msg.TEXT_PRINT_TOOLTIP,helpUrl:Blockly.Msg.TEXT_PRINT_HELPURL})}};Blockly.Blocks.text_prompt_ext={init:function(){var a=[[Blockly.Msg.TEXT_PROMPT_TYPE_TEXT,"TEXT"],[Blockly.Msg.TEXT_PROMPT_TYPE_NUMBER,"NUMBER"]];this.setHelpUrl(Blockly.Msg.TEXT_PROMPT_HELPURL);this.setColour(Blockly.Blocks.texts.HUE);var b=this;a=new Blockly.FieldDropdown(a,function(a){b.updateType_(a)});this.appendValueInput("TEXT").appendField(a,"TYPE");this.setOutput(!0,"String");this.setTooltip(function(){return"TEXT"==b.getFieldValue("TYPE")?Blockly.Msg.TEXT_PROMPT_TOOLTIP_TEXT:Blockly.Msg.TEXT_PROMPT_TOOLTIP_NUMBER})},updateType_:function(a){this.outputConnection.setCheck("NUMBER"==a?"Number":"String")},mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("type",this.getFieldValue("TYPE"));
-return a},domToMutation:function(a){this.updateType_(a.getAttribute("type"))}};Blockly.Blocks.text_prompt={init:function(){this.mixin(Blockly.Constants.Text.QUOTE_IMAGE_MIXIN);var a=[[Blockly.Msg.TEXT_PROMPT_TYPE_TEXT,"TEXT"],[Blockly.Msg.TEXT_PROMPT_TYPE_NUMBER,"NUMBER"]],b=this;this.setHelpUrl(Blockly.Msg.TEXT_PROMPT_HELPURL);this.setColour(Blockly.Blocks.texts.HUE);a=new Blockly.FieldDropdown(a,function(a){b.updateType_(a)});this.appendDummyInput().appendField(a,"TYPE").appendField(this.newQuote_(!0)).appendField(new Blockly.FieldTextInput(""),"TEXT").appendField(this.newQuote_(!1));this.setOutput(!0,"String");this.setTooltip(function(){return"TEXT"==b.getFieldValue("TYPE")?Blockly.Msg.TEXT_PROMPT_TOOLTIP_TEXT:Blockly.Msg.TEXT_PROMPT_TOOLTIP_NUMBER})},updateType_:Blockly.Blocks.text_prompt_ext.updateType_,mutationToDom:Blockly.Blocks.text_prompt_ext.mutationToDom,domToMutation:Blockly.Blocks.text_prompt_ext.domToMutation};Blockly.Blocks.text_count={init:function(){this.jsonInit({message0:Blockly.Msg.TEXT_COUNT_MESSAGE0,args0:[{type:"input_value",name:"SUB",check:"String"},{type:"input_value",name:"TEXT",check:"String"}],output:"Number",inputsInline:!0,colour:Blockly.Blocks.texts.HUE,tooltip:Blockly.Msg.TEXT_COUNT_TOOLTIP,helpUrl:Blockly.Msg.TEXT_COUNT_HELPURL})}};Blockly.Blocks.text_replace={init:function(){this.jsonInit({message0:Blockly.Msg.TEXT_REPLACE_MESSAGE0,args0:[{type:"input_value",name:"FROM",check:"String"},{type:"input_value",name:"TO",check:"String"},{type:"input_value",name:"TEXT",check:"String"}],output:"String",inputsInline:!0,colour:Blockly.Blocks.texts.HUE,tooltip:Blockly.Msg.TEXT_REPLACE_TOOLTIP,helpUrl:Blockly.Msg.TEXT_REPLACE_HELPURL})}};Blockly.Blocks.text_reverse={init:function(){this.jsonInit({message0:Blockly.Msg.TEXT_REVERSE_MESSAGE0,args0:[{type:"input_value",name:"TEXT",check:"String"}],output:"String",inputsInline:!0,colour:Blockly.Blocks.texts.HUE,tooltip:Blockly.Msg.TEXT_REVERSE_TOOLTIP,helpUrl:Blockly.Msg.TEXT_REVERSE_HELPURL})}};Blockly.Constants.Text.QUOTE_IMAGE_MIXIN={QUOTE_IMAGE_LEFT_DATAURI:"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAwAAAAKCAQAAAAqJXdxAAAAn0lEQVQI1z3OMa5BURSF4f/cQhAKjUQhuQmFNwGJEUi0RKN5rU7FHKhpjEH3TEMtkdBSCY1EIv8r7nFX9e29V7EBAOvu7RPjwmWGH/VuF8CyN9/OAdvqIXYLvtRaNjx9mMTDyo+NjAN1HNcl9ZQ5oQMM3dgDUqDo1l8DzvwmtZN7mnD+PkmLa+4mhrxVA9fRowBWmVBhFy5gYEjKMfz9AylsaRRgGzvZAAAAAElFTkSuQmCC",QUOTE_IMAGE_RIGHT_DATAURI:"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAwAAAAKCAQAAAAqJXdxAAAAqUlEQVQI1z3KvUpCcRiA8ef9E4JNHhI0aFEacm1o0BsI0Slx8wa8gLauoDnoBhq7DcfWhggONDmJJgqCPA7neJ7p934EOOKOnM8Q7PDElo/4x4lFb2DmuUjcUzS3URnGib9qaPNbuXvBO3sGPHJDRG6fGVdMSeWDP2q99FQdFrz26Gu5Tq7dFMzUvbXy8KXeAj57cOklgA+u1B5AoslLtGIHQMaCVnwDnADZIFIrXsoXrgAAAABJRU5ErkJggg==",QUOTE_IMAGE_WIDTH:12,QUOTE_IMAGE_HEIGHT:12,quoteField_:function(a){for(var b=0,c;
-c=this.inputList[b];b++){for(var d=0,e;e=c.fieldRow[d];d++){if(a==e.name){c.insertFieldAt(d,this.newQuote_(!0));c.insertFieldAt(d+2,this.newQuote_(!1));return}}}console.warn('field named "'+a+'" not found in '+this.toDevString())},newQuote_:function(a){a=this.RTL?!a:a;return new Blockly.FieldImage(a?this.QUOTE_IMAGE_LEFT_DATAURI:this.QUOTE_IMAGE_RIGHT_DATAURI,this.QUOTE_IMAGE_WIDTH,this.QUOTE_IMAGE_HEIGHT,a?"\u201c":"\u201d")}};Blockly.Constants.Text.TEXT_QUOTES_EXTENSION=function(){this.mixin(Blockly.Constants.Text.QUOTE_IMAGE_MIXIN);this.quoteField_("TEXT")};Blockly.Constants.Text.TEXT_JOIN_MUTATOR_MIXIN={mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("items",this.itemCount_);return a},domToMutation:function(a){this.itemCount_=parseInt(a.getAttribute("items"),10);this.updateShape_()},decompose:function(a){var b=a.newBlock("text_create_join_container");b.initSvg();for(var c=b.getInput("STACK").connection,d=0;d<this.itemCount_;d++){var e=a.newBlock("text_create_join_item");e.initSvg();c.connect(e.previousConnection);c=e.nextConnection}return b},compose:function(a){var b=a.getInputTargetBlock("STACK");for(a=[];b;){a.push(b.valueConnection_),b=b.nextConnection&&b.nextConnection.targetBlock()}for(b=0;b<this.itemCount_;b++){var c=this.getInput("ADD"+b).connection.targetConnection;c&&-1==a.indexOf(c)&&c.disconnect()}this.itemCount_=a.length;this.updateShape_();for(b=0;b<this.itemCount_;b++){Blockly.Mutator.reconnect(a[b],this,"ADD"+b)}},saveConnections:function(a){a=a.getInputTargetBlock("STACK");for(var b=0;a;){var c=this.getInput("ADD"+b);a.valueConnection_=c&&c.connection.targetConnection;b++;a=a.nextConnection&&a.nextConnection.targetBlock()}},updateShape_:function(){this.itemCount_&&this.getInput("EMPTY")?this.removeInput("EMPTY"):this.itemCount_||this.getInput("EMPTY")||this.appendDummyInput("EMPTY").appendField(this.newQuote_(!0)).appendField(this.newQuote_(!1));for(var a=0;a<this.itemCount_;a++){if(!this.getInput("ADD"+a)){var b=this.appendValueInput("ADD"+a);
-0==a&&b.appendField(Blockly.Msg.TEXT_JOIN_TITLE_CREATEWITH)}}for(;this.getInput("ADD"+a);){this.removeInput("ADD"+a),a++}}};Blockly.Constants.Text.TEXT_JOIN_EXTENSION=function(){this.mixin(Blockly.Constants.Text.QUOTE_IMAGE_MIXIN);this.itemCount_=2;this.updateShape_();this.setMutator(new Blockly.Mutator(["text_create_join_item"]))};Blockly.Constants.Text.TEXT_APPEND_TOOLTIP_EXTENSION=function(){var a=this;this.setTooltip(function(){return Blockly.Msg.TEXT_APPEND_TOOLTIP?Blockly.Msg.TEXT_APPEND_TOOLTIP.replace("%1",a.getFieldValue("VAR")):""})};Blockly.Constants.Text.TEXT_INDEXOF_TOOLTIP_EXTENSION=function(){var a=this;this.setTooltip(function(){return Blockly.Msg.TEXT_INDEXOF_TOOLTIP.replace("%1",a.workspace.options.oneBasedIndex?"0":"-1")})};Blockly.Constants.Text.TEXT_CHARAT_MUTATOR_MIXIN={mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("at",!!this.isAt_);return a},domToMutation:function(a){a="false"!=a.getAttribute("at");this.updateAt_(a)},updateAt_:function(a){this.removeInput("AT",!0);this.removeInput("ORDINAL",!0);a&&(this.appendValueInput("AT").setCheck("Number"),Blockly.Msg.ORDINAL_NUMBER_SUFFIX&&this.appendDummyInput("ORDINAL").appendField(Blockly.Msg.ORDINAL_NUMBER_SUFFIX));Blockly.Msg.TEXT_CHARAT_TAIL&&(this.removeInput("TAIL",!0),this.appendDummyInput("TAIL").appendField(Blockly.Msg.TEXT_CHARAT_TAIL));this.isAt_=a}};Blockly.Constants.Text.TEXT_CHARAT_EXTENSION=function(){this.getField("WHERE").setValidator(function(a){var b="FROM_START"==a||"FROM_END"==a;if(b!=this.isAt_){var d=this.sourceBlock_;d.updateAt_(b);d.setFieldValue(a,"WHERE");return null}});this.updateAt_(!0);var a=this;this.setTooltip(function(){var b=a.getFieldValue("WHERE"),c=Blockly.Msg.TEXT_CHARAT_TOOLTIP;("FROM_START"==b||"FROM_END"==b)&&(b="FROM_START"==b?Blockly.Msg.LISTS_INDEX_FROM_START_TOOLTIP:Blockly.Msg.LISTS_INDEX_FROM_END_TOOLTIP)&&(c+="  "+b.replace("%1",a.workspace.options.oneBasedIndex?"#1":"#0"));return c})};Blockly.Extensions.register("text_indexOf_tooltip",Blockly.Constants.Text.TEXT_INDEXOF_TOOLTIP_EXTENSION);
-Blockly.Extensions.register("text_quotes",Blockly.Constants.Text.TEXT_QUOTES_EXTENSION);Blockly.Extensions.register("text_append_tooltip",Blockly.Constants.Text.TEXT_APPEND_TOOLTIP_EXTENSION);Blockly.Extensions.registerMutator("text_join_mutator",Blockly.Constants.Text.TEXT_JOIN_MUTATOR_MIXIN,Blockly.Constants.Text.TEXT_JOIN_EXTENSION);Blockly.Extensions.registerMutator("text_charAt_mutator",Blockly.Constants.Text.TEXT_CHARAT_MUTATOR_MIXIN,Blockly.Constants.Text.TEXT_CHARAT_EXTENSION);Blockly.Blocks.variables={};Blockly.Constants.Variables={};Blockly.Constants.Variables.HUE=330;Blockly.Blocks.variables.HUE=Blockly.Constants.Variables.HUE;Blockly.defineBlocksWithJsonArray([{type:"variables_get",message0:"%1",args0:[{type:"field_variable",name:"VAR",variable:"%{BKY_VARIABLES_DEFAULT_NAME}"}],output:null,colour:"%{BKY_VARIABLES_HUE}",helpUrl:"%{BKY_VARIABLES_GET_HELPURL}",tooltip:"%{BKY_VARIABLES_GET_TOOLTIP}",extensions:["contextMenu_variableSetterGetter"]},{type:"variables_set",message0:"%{BKY_VARIABLES_SET}",args0:[{type:"field_variable",name:"VAR",variable:"%{BKY_VARIABLES_DEFAULT_NAME}"},{type:"input_value",name:"VALUE"}],previousStatement:null,nextStatement:null,colour:"%{BKY_VARIABLES_HUE}",tooltip:"%{BKY_VARIABLES_SET_TOOLTIP}",helpUrl:"%{BKY_VARIABLES_SET_HELPURL}",extensions:["contextMenu_variableSetterGetter"]}]);Blockly.Constants.Variables.CUSTOM_CONTEXT_MENU_VARIABLE_GETTER_SETTER_MIXIN={customContextMenu:function(a){if("variables_get"==this.type){var b="variables_set",c=Blockly.Msg.VARIABLES_GET_CREATE_SET}else{b="variables_get",c=Blockly.Msg.VARIABLES_SET_CREATE_GET}var d={enabled:0<this.workspace.remainingCapacity()},e=this.getFieldValue("VAR");d.text=c.replace("%1",e);c=goog.dom.createDom("field",null,e);c.setAttribute("name","VAR");c=goog.dom.createDom("block",null,c);c.setAttribute("type",b);d.callback=Blockly.ContextMenu.callbackFactory(this,c);a.push(d)}};Blockly.Extensions.registerMixin("contextMenu_variableSetterGetter",Blockly.Constants.Variables.CUSTOM_CONTEXT_MENU_VARIABLE_GETTER_SETTER_MIXIN);
-"use strict";Blockly.JavaScript=new Blockly.Generator("JavaScript");Blockly.JavaScript.addReservedWords("Blockly,break,case,catch,continue,debugger,default,delete,do,else,finally,for,function,if,in,instanceof,new,return,switch,this,throw,try,typeof,var,void,while,with,class,enum,export,extends,import,super,implements,interface,let,package,private,protected,public,static,yield,const,null,true,false,Array,ArrayBuffer,Boolean,Date,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Error,eval,EvalError,Float32Array,Float64Array,Function,Infinity,Int16Array,Int32Array,Int8Array,isFinite,isNaN,Iterator,JSON,Math,NaN,Number,Object,parseFloat,parseInt,RangeError,ReferenceError,RegExp,StopIteration,String,SyntaxError,TypeError,Uint16Array,Uint32Array,Uint8Array,Uint8ClampedArray,undefined,uneval,URIError,applicationCache,closed,Components,content,_content,controllers,crypto,defaultStatus,dialogArguments,directories,document,frameElement,frames,fullScreen,globalStorage,history,innerHeight,innerWidth,length,location,locationbar,localStorage,menubar,messageManager,mozAnimationStartTime,mozInnerScreenX,mozInnerScreenY,mozPaintCount,name,navigator,opener,outerHeight,outerWidth,pageXOffset,pageYOffset,parent,performance,personalbar,pkcs11,returnValue,screen,screenX,screenY,scrollbars,scrollMaxX,scrollMaxY,scrollX,scrollY,self,sessionStorage,sidebar,status,statusbar,toolbar,top,URL,window,addEventListener,alert,atob,back,blur,btoa,captureEvents,clearImmediate,clearInterval,clearTimeout,close,confirm,disableExternalCapture,dispatchEvent,dump,enableExternalCapture,escape,find,focus,forward,GeckoActiveXObject,getAttention,getAttentionWithCycleCount,getComputedStyle,getSelection,home,matchMedia,maximize,minimize,moveBy,moveTo,mozRequestAnimationFrame,open,openDialog,postMessage,print,prompt,QueryInterface,releaseEvents,removeEventListener,resizeBy,resizeTo,restore,routeEvent,scroll,scrollBy,scrollByLines,scrollByPages,scrollTo,setCursor,setImmediate,setInterval,setResizable,setTimeout,showModalDialog,sizeToContent,stop,unescape,updateCommands,XPCNativeWrapper,XPCSafeJSObjectWrapper,onabort,onbeforeunload,onblur,onchange,onclick,onclose,oncontextmenu,ondevicemotion,ondeviceorientation,ondragdrop,onerror,onfocus,onhashchange,onkeydown,onkeypress,onkeyup,onload,onmousedown,onmousemove,onmouseout,onmouseover,onmouseup,onmozbeforepaint,onpaint,onpopstate,onreset,onresize,onscroll,onselect,onsubmit,onunload,onpageshow,onpagehide,Image,Option,Worker,Event,Range,File,FileReader,Blob,BlobBuilder,Attr,CDATASection,CharacterData,Comment,console,DocumentFragment,DocumentType,DomConfiguration,DOMError,DOMErrorHandler,DOMException,DOMImplementation,DOMImplementationList,DOMImplementationRegistry,DOMImplementationSource,DOMLocator,DOMObject,DOMString,DOMStringList,DOMTimeStamp,DOMUserData,Entity,EntityReference,MediaQueryList,MediaQueryListListener,NameList,NamedNodeMap,Node,NodeFilter,NodeIterator,NodeList,Notation,Plugin,PluginArray,ProcessingInstruction,SharedWorker,Text,TimeRanges,Treewalker,TypeInfo,UserDataHandler,Worker,WorkerGlobalScope,HTMLDocument,HTMLElement,HTMLAnchorElement,HTMLAppletElement,HTMLAudioElement,HTMLAreaElement,HTMLBaseElement,HTMLBaseFontElement,HTMLBodyElement,HTMLBRElement,HTMLButtonElement,HTMLCanvasElement,HTMLDirectoryElement,HTMLDivElement,HTMLDListElement,HTMLEmbedElement,HTMLFieldSetElement,HTMLFontElement,HTMLFormElement,HTMLFrameElement,HTMLFrameSetElement,HTMLHeadElement,HTMLHeadingElement,HTMLHtmlElement,HTMLHRElement,HTMLIFrameElement,HTMLImageElement,HTMLInputElement,HTMLKeygenElement,HTMLLabelElement,HTMLLIElement,HTMLLinkElement,HTMLMapElement,HTMLMenuElement,HTMLMetaElement,HTMLModElement,HTMLObjectElement,HTMLOListElement,HTMLOptGroupElement,HTMLOptionElement,HTMLOutputElement,HTMLParagraphElement,HTMLParamElement,HTMLPreElement,HTMLQuoteElement,HTMLScriptElement,HTMLSelectElement,HTMLSourceElement,HTMLSpanElement,HTMLStyleElement,HTMLTableElement,HTMLTableCaptionElement,HTMLTableCellElement,HTMLTableDataCellElement,HTMLTableHeaderCellElement,HTMLTableColElement,HTMLTableRowElement,HTMLTableSectionElement,HTMLTextAreaElement,HTMLTimeElement,HTMLTitleElement,HTMLTrackElement,HTMLUListElement,HTMLUnknownElement,HTMLVideoElement,HTMLCanvasElement,CanvasRenderingContext2D,CanvasGradient,CanvasPattern,TextMetrics,ImageData,CanvasPixelArray,HTMLAudioElement,HTMLVideoElement,NotifyAudioAvailableEvent,HTMLCollection,HTMLAllCollection,HTMLFormControlsCollection,HTMLOptionsCollection,HTMLPropertiesCollection,DOMTokenList,DOMSettableTokenList,DOMStringMap,RadioNodeList,SVGDocument,SVGElement,SVGAElement,SVGAltGlyphElement,SVGAltGlyphDefElement,SVGAltGlyphItemElement,SVGAnimationElement,SVGAnimateElement,SVGAnimateColorElement,SVGAnimateMotionElement,SVGAnimateTransformElement,SVGSetElement,SVGCircleElement,SVGClipPathElement,SVGColorProfileElement,SVGCursorElement,SVGDefsElement,SVGDescElement,SVGEllipseElement,SVGFilterElement,SVGFilterPrimitiveStandardAttributes,SVGFEBlendElement,SVGFEColorMatrixElement,SVGFEComponentTransferElement,SVGFECompositeElement,SVGFEConvolveMatrixElement,SVGFEDiffuseLightingElement,SVGFEDisplacementMapElement,SVGFEDistantLightElement,SVGFEFloodElement,SVGFEGaussianBlurElement,SVGFEImageElement,SVGFEMergeElement,SVGFEMergeNodeElement,SVGFEMorphologyElement,SVGFEOffsetElement,SVGFEPointLightElement,SVGFESpecularLightingElement,SVGFESpotLightElement,SVGFETileElement,SVGFETurbulenceElement,SVGComponentTransferFunctionElement,SVGFEFuncRElement,SVGFEFuncGElement,SVGFEFuncBElement,SVGFEFuncAElement,SVGFontElement,SVGFontFaceElement,SVGFontFaceFormatElement,SVGFontFaceNameElement,SVGFontFaceSrcElement,SVGFontFaceUriElement,SVGForeignObjectElement,SVGGElement,SVGGlyphElement,SVGGlyphRefElement,SVGGradientElement,SVGLinearGradientElement,SVGRadialGradientElement,SVGHKernElement,SVGImageElement,SVGLineElement,SVGMarkerElement,SVGMaskElement,SVGMetadataElement,SVGMissingGlyphElement,SVGMPathElement,SVGPathElement,SVGPatternElement,SVGPolylineElement,SVGPolygonElement,SVGRectElement,SVGScriptElement,SVGStopElement,SVGStyleElement,SVGSVGElement,SVGSwitchElement,SVGSymbolElement,SVGTextElement,SVGTextPathElement,SVGTitleElement,SVGTRefElement,SVGTSpanElement,SVGUseElement,SVGViewElement,SVGVKernElement,SVGAngle,SVGColor,SVGICCColor,SVGElementInstance,SVGElementInstanceList,SVGLength,SVGLengthList,SVGMatrix,SVGNumber,SVGNumberList,SVGPaint,SVGPoint,SVGPointList,SVGPreserveAspectRatio,SVGRect,SVGStringList,SVGTransform,SVGTransformList,SVGAnimatedAngle,SVGAnimatedBoolean,SVGAnimatedEnumeration,SVGAnimatedInteger,SVGAnimatedLength,SVGAnimatedLengthList,SVGAnimatedNumber,SVGAnimatedNumberList,SVGAnimatedPreserveAspectRatio,SVGAnimatedRect,SVGAnimatedString,SVGAnimatedTransformList,SVGPathSegList,SVGPathSeg,SVGPathSegArcAbs,SVGPathSegArcRel,SVGPathSegClosePath,SVGPathSegCurvetoCubicAbs,SVGPathSegCurvetoCubicRel,SVGPathSegCurvetoCubicSmoothAbs,SVGPathSegCurvetoCubicSmoothRel,SVGPathSegCurvetoQuadraticAbs,SVGPathSegCurvetoQuadraticRel,SVGPathSegCurvetoQuadraticSmoothAbs,SVGPathSegCurvetoQuadraticSmoothRel,SVGPathSegLinetoAbs,SVGPathSegLinetoHorizontalAbs,SVGPathSegLinetoHorizontalRel,SVGPathSegLinetoRel,SVGPathSegLinetoVerticalAbs,SVGPathSegLinetoVerticalRel,SVGPathSegMovetoAbs,SVGPathSegMovetoRel,ElementTimeControl,TimeEvent,SVGAnimatedPathData,SVGAnimatedPoints,SVGColorProfileRule,SVGCSSRule,SVGExternalResourcesRequired,SVGFitToViewBox,SVGLangSpace,SVGLocatable,SVGRenderingIntent,SVGStylable,SVGTests,SVGTextContentElement,SVGTextPositioningElement,SVGTransformable,SVGUnitTypes,SVGURIReference,SVGViewSpec,SVGZoomAndPan");
-Blockly.JavaScript.ORDER_ATOMIC=0;Blockly.JavaScript.ORDER_NEW=1.1;Blockly.JavaScript.ORDER_MEMBER=1.2;Blockly.JavaScript.ORDER_FUNCTION_CALL=2;Blockly.JavaScript.ORDER_INCREMENT=3;Blockly.JavaScript.ORDER_DECREMENT=3;Blockly.JavaScript.ORDER_BITWISE_NOT=4.1;Blockly.JavaScript.ORDER_UNARY_PLUS=4.2;Blockly.JavaScript.ORDER_UNARY_NEGATION=4.3;Blockly.JavaScript.ORDER_LOGICAL_NOT=4.4;Blockly.JavaScript.ORDER_TYPEOF=4.5;Blockly.JavaScript.ORDER_VOID=4.6;Blockly.JavaScript.ORDER_DELETE=4.7;Blockly.JavaScript.ORDER_DIVISION=5.1;Blockly.JavaScript.ORDER_MULTIPLICATION=5.2;Blockly.JavaScript.ORDER_MODULUS=5.3;Blockly.JavaScript.ORDER_SUBTRACTION=6.1;Blockly.JavaScript.ORDER_ADDITION=6.2;Blockly.JavaScript.ORDER_BITWISE_SHIFT=7;Blockly.JavaScript.ORDER_RELATIONAL=8;Blockly.JavaScript.ORDER_IN=8;Blockly.JavaScript.ORDER_INSTANCEOF=8;Blockly.JavaScript.ORDER_EQUALITY=9;Blockly.JavaScript.ORDER_BITWISE_AND=10;Blockly.JavaScript.ORDER_BITWISE_XOR=11;Blockly.JavaScript.ORDER_BITWISE_OR=12;Blockly.JavaScript.ORDER_LOGICAL_AND=13;Blockly.JavaScript.ORDER_LOGICAL_OR=14;Blockly.JavaScript.ORDER_CONDITIONAL=15;Blockly.JavaScript.ORDER_ASSIGNMENT=16;Blockly.JavaScript.ORDER_COMMA=17;Blockly.JavaScript.ORDER_NONE=99;Blockly.JavaScript.ORDER_OVERRIDES=[[Blockly.JavaScript.ORDER_FUNCTION_CALL,Blockly.JavaScript.ORDER_MEMBER],[Blockly.JavaScript.ORDER_FUNCTION_CALL,Blockly.JavaScript.ORDER_FUNCTION_CALL],[Blockly.JavaScript.ORDER_MEMBER,Blockly.JavaScript.ORDER_MEMBER],[Blockly.JavaScript.ORDER_MEMBER,Blockly.JavaScript.ORDER_FUNCTION_CALL],[Blockly.JavaScript.ORDER_LOGICAL_NOT,Blockly.JavaScript.ORDER_LOGICAL_NOT],[Blockly.JavaScript.ORDER_MULTIPLICATION,Blockly.JavaScript.ORDER_MULTIPLICATION],[Blockly.JavaScript.ORDER_ADDITION,Blockly.JavaScript.ORDER_ADDITION],[Blockly.JavaScript.ORDER_LOGICAL_AND,Blockly.JavaScript.ORDER_LOGICAL_AND],[Blockly.JavaScript.ORDER_LOGICAL_OR,Blockly.JavaScript.ORDER_LOGICAL_OR]];Blockly.JavaScript.init=function(a){Blockly.JavaScript.definitions_=Object.create(null);
-Blockly.JavaScript.functionNames_=Object.create(null);Blockly.JavaScript.variableDB_?Blockly.JavaScript.variableDB_.reset():Blockly.JavaScript.variableDB_=new Blockly.Names(Blockly.JavaScript.RESERVED_WORDS_);var b=[];a=a.getAllVariables();if(a.length){for(var c=0;c<a.length;c++){b[c]=Blockly.JavaScript.variableDB_.getName(a[c].name,Blockly.Variables.NAME_TYPE)}Blockly.JavaScript.definitions_.variables="var "+b.join(", ")+";"}};Blockly.JavaScript.finish=function(a){var b=[],c;for(c in Blockly.JavaScript.definitions_){b.push(Blockly.JavaScript.definitions_[c])}delete Blockly.JavaScript.definitions_;delete Blockly.JavaScript.functionNames_;Blockly.JavaScript.variableDB_.reset();return b.join("\n\n")+"\n\n\n"+a};Blockly.JavaScript.scrubNakedValue=function(a){return a+";\n"};Blockly.JavaScript.quote_=function(a){a=a.replace(/\\/g,"\\\\").replace(/\n/g,"\\\n").replace(/'/g,"\\'");return"'"+a+"'"};Blockly.JavaScript.scrub_=function(a,b){var c="";if(!a.outputConnection||!a.outputConnection.targetConnection){var d=a.getCommentText();(d=Blockly.utils.wrap(d,Blockly.JavaScript.COMMENT_WRAP-3))&&(c=a.getProcedureDef?c+("/**\n"+Blockly.JavaScript.prefixLines(d+"\n"," * ")+" */\n"):c+Blockly.JavaScript.prefixLines(d+"\n","// "));for(var e=0;e<a.inputList.length;e++){a.inputList[e].type==Blockly.INPUT_VALUE&&(d=a.inputList[e].connection.targetBlock())&&(d=Blockly.JavaScript.allNestedComments(d))&&(c+=Blockly.JavaScript.prefixLines(d,"// "))}}e=a.nextConnection&&a.nextConnection.targetBlock();e=Blockly.JavaScript.blockToCode(e);return c+b+e};Blockly.JavaScript.getAdjusted=function(a,b,c,d,e){c=c||0;e=e||Blockly.JavaScript.ORDER_NONE;a.workspace.options.oneBasedIndex&&c--;var f=a.workspace.options.oneBasedIndex?"1":"0";a=0<c?Blockly.JavaScript.valueToCode(a,b,Blockly.JavaScript.ORDER_ADDITION)||f:0>c?Blockly.JavaScript.valueToCode(a,b,Blockly.JavaScript.ORDER_SUBTRACTION)||f:d?Blockly.JavaScript.valueToCode(a,b,Blockly.JavaScript.ORDER_UNARY_NEGATION)||f:Blockly.JavaScript.valueToCode(a,b,e)||f;
-if(Blockly.isNumber(a)){a=parseFloat(a)+c,d&&(a=-a)}else{if(0<c){a=a+" + "+c;var g=Blockly.JavaScript.ORDER_ADDITION}else{0>c&&(a=a+" - "+-c,g=Blockly.JavaScript.ORDER_SUBTRACTION)}d&&(a=c?"-("+a+")":"-"+a,g=Blockly.JavaScript.ORDER_UNARY_NEGATION);g=Math.floor(g);e=Math.floor(e);g&&e>=g&&(a="("+a+")")}return a};Blockly.JavaScript.colour={};Blockly.JavaScript.colour_picker=function(a){return["'"+a.getFieldValue("COLOUR")+"'",Blockly.JavaScript.ORDER_ATOMIC]};Blockly.JavaScript.colour_random=function(a){return[Blockly.JavaScript.provideFunction_("colourRandom",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"() {","  var num = Math.floor(Math.random() * Math.pow(2, 24));","  return '#' + ('00000' + num.toString(16)).substr(-6);","}"])+"()",Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.colour_rgb=function(a){var b=Blockly.JavaScript.valueToCode(a,"RED",Blockly.JavaScript.ORDER_COMMA)||0,c=Blockly.JavaScript.valueToCode(a,"GREEN",Blockly.JavaScript.ORDER_COMMA)||0;a=Blockly.JavaScript.valueToCode(a,"BLUE",Blockly.JavaScript.ORDER_COMMA)||0;return[Blockly.JavaScript.provideFunction_("colourRgb",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(r, g, b) {","  r = Math.max(Math.min(Number(r), 100), 0) * 2.55;","  g = Math.max(Math.min(Number(g), 100), 0) * 2.55;","  b = Math.max(Math.min(Number(b), 100), 0) * 2.55;","  r = ('0' + (Math.round(r) || 0).toString(16)).slice(-2);","  g = ('0' + (Math.round(g) || 0).toString(16)).slice(-2);","  b = ('0' + (Math.round(b) || 0).toString(16)).slice(-2);","  return '#' + r + g + b;","}"])+"("+b+", "+c+", "+a+")",Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.colour_blend=function(a){var b=Blockly.JavaScript.valueToCode(a,"COLOUR1",Blockly.JavaScript.ORDER_COMMA)||"'#000000'",c=Blockly.JavaScript.valueToCode(a,"COLOUR2",Blockly.JavaScript.ORDER_COMMA)||"'#000000'";a=Blockly.JavaScript.valueToCode(a,"RATIO",Blockly.JavaScript.ORDER_COMMA)||0.5;return[Blockly.JavaScript.provideFunction_("colourBlend",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(c1, c2, ratio) {","  ratio = Math.max(Math.min(Number(ratio), 1), 0);","  var r1 = parseInt(c1.substring(1, 3), 16);","  var g1 = parseInt(c1.substring(3, 5), 16);","  var b1 = parseInt(c1.substring(5, 7), 16);","  var r2 = parseInt(c2.substring(1, 3), 16);","  var g2 = parseInt(c2.substring(3, 5), 16);","  var b2 = parseInt(c2.substring(5, 7), 16);","  var r = Math.round(r1 * (1 - ratio) + r2 * ratio);","  var g = Math.round(g1 * (1 - ratio) + g2 * ratio);","  var b = Math.round(b1 * (1 - ratio) + b2 * ratio);","  r = ('0' + (r || 0).toString(16)).slice(-2);","  g = ('0' + (g || 0).toString(16)).slice(-2);","  b = ('0' + (b || 0).toString(16)).slice(-2);","  return '#' + r + g + b;","}"])+"("+b+", "+c+", "+a+")",Blockly.JavaScript.ORDER_FUNCTION_CALL]
-};Blockly.JavaScript.lists={};Blockly.JavaScript.lists_create_empty=function(a){return["[]",Blockly.JavaScript.ORDER_ATOMIC]};Blockly.JavaScript.lists_create_with=function(a){for(var b=Array(a.itemCount_),c=0;c<a.itemCount_;c++){b[c]=Blockly.JavaScript.valueToCode(a,"ADD"+c,Blockly.JavaScript.ORDER_COMMA)||"null"}return["["+b.join(", ")+"]",Blockly.JavaScript.ORDER_ATOMIC]};Blockly.JavaScript.lists_repeat=function(a){var b=Blockly.JavaScript.provideFunction_("listsRepeat",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(value, n) {","  var array = [];","  for (var i = 0; i < n; i++) {","    array[i] = value;","  }","  return array;","}"]),c=Blockly.JavaScript.valueToCode(a,"ITEM",Blockly.JavaScript.ORDER_COMMA)||"null";a=Blockly.JavaScript.valueToCode(a,"NUM",Blockly.JavaScript.ORDER_COMMA)||"0";return[b+"("+c+", "+a+")",Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.lists_length=function(a){return[(Blockly.JavaScript.valueToCode(a,"VALUE",Blockly.JavaScript.ORDER_MEMBER)||"[]")+".length",Blockly.JavaScript.ORDER_MEMBER]};Blockly.JavaScript.lists_isEmpty=function(a){return["!"+(Blockly.JavaScript.valueToCode(a,"VALUE",Blockly.JavaScript.ORDER_MEMBER)||"[]")+".length",Blockly.JavaScript.ORDER_LOGICAL_NOT]};Blockly.JavaScript.lists_indexOf=function(a){var b="FIRST"==a.getFieldValue("END")?"indexOf":"lastIndexOf",c=Blockly.JavaScript.valueToCode(a,"FIND",Blockly.JavaScript.ORDER_NONE)||"''";b=(Blockly.JavaScript.valueToCode(a,"VALUE",Blockly.JavaScript.ORDER_MEMBER)||"[]")+"."+b+"("+c+")";return a.workspace.options.oneBasedIndex?[b+" + 1",Blockly.JavaScript.ORDER_ADDITION]:[b,Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.lists_getIndex=function(a){var b=a.getFieldValue("MODE")||"GET",c=a.getFieldValue("WHERE")||"FROM_START",d=Blockly.JavaScript.valueToCode(a,"VALUE","RANDOM"==c?Blockly.JavaScript.ORDER_COMMA:Blockly.JavaScript.ORDER_MEMBER)||"[]";switch(c){case"FIRST":if("GET"==b){return[d+"[0]",Blockly.JavaScript.ORDER_MEMBER]}if("GET_REMOVE"==b){return[d+".shift()",Blockly.JavaScript.ORDER_MEMBER]
-}if("REMOVE"==b){return d+".shift();\n"}break;case"LAST":if("GET"==b){return[d+".slice(-1)[0]",Blockly.JavaScript.ORDER_MEMBER]}if("GET_REMOVE"==b){return[d+".pop()",Blockly.JavaScript.ORDER_MEMBER]}if("REMOVE"==b){return d+".pop();\n"}break;case"FROM_START":a=Blockly.JavaScript.getAdjusted(a,"AT");if("GET"==b){return[d+"["+a+"]",Blockly.JavaScript.ORDER_MEMBER]}if("GET_REMOVE"==b){return[d+".splice("+a+", 1)[0]",Blockly.JavaScript.ORDER_FUNCTION_CALL]}if("REMOVE"==b){return d+".splice("+a+", 1);\n"}break;case"FROM_END":a=Blockly.JavaScript.getAdjusted(a,"AT",1,!0);if("GET"==b){return[d+".slice("+a+")[0]",Blockly.JavaScript.ORDER_FUNCTION_CALL]}if("GET_REMOVE"==b){return[d+".splice("+a+", 1)[0]",Blockly.JavaScript.ORDER_FUNCTION_CALL]}if("REMOVE"==b){return d+".splice("+a+", 1);"}break;case"RANDOM":d=Blockly.JavaScript.provideFunction_("listsGetRandomItem",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(list, remove) {","  var x = Math.floor(Math.random() * list.length);","  if (remove) {","    return list.splice(x, 1)[0];","  } else {","    return list[x];","  }","}"])+"("+d+", "+("GET"!=b)+")";if("GET"==b||"GET_REMOVE"==b){return[d,Blockly.JavaScript.ORDER_FUNCTION_CALL]}if("REMOVE"==b){return d+";\n"}}throw"Unhandled combination (lists_getIndex)."};Blockly.JavaScript.lists_setIndex=function(a){function b(){if(c.match(/^\w+$/)){return""}var a=Blockly.JavaScript.variableDB_.getDistinctName("tmpList",Blockly.Variables.NAME_TYPE),b="var "+a+" = "+c+";\n";c=a;return b}var c=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_MEMBER)||"[]",d=a.getFieldValue("MODE")||"GET",e=a.getFieldValue("WHERE")||"FROM_START",f=Blockly.JavaScript.valueToCode(a,"TO",Blockly.JavaScript.ORDER_ASSIGNMENT)||"null";switch(e){case"FIRST":if("SET"==d){return c+"[0] = "+f+";\n"}if("INSERT"==d){return c+".unshift("+f+");\n"}break;case"LAST":if("SET"==d){return a=b(),a+(c+"["+c+".length - 1] = "+f+";\n")}if("INSERT"==d){return c+".push("+f+");\n"}break;case"FROM_START":e=Blockly.JavaScript.getAdjusted(a,"AT");
-if("SET"==d){return c+"["+e+"] = "+f+";\n"}if("INSERT"==d){return c+".splice("+e+", 0, "+f+");\n"}break;case"FROM_END":e=Blockly.JavaScript.getAdjusted(a,"AT",1,!1,Blockly.JavaScript.ORDER_SUBTRACTION);a=b();if("SET"==d){return a+(c+"["+c+".length - "+e+"] = "+f+";\n")}if("INSERT"==d){return a+(c+".splice("+c+".length - "+e+", 0, "+f+");\n")}break;case"RANDOM":a=b();e=Blockly.JavaScript.variableDB_.getDistinctName("tmpX",Blockly.Variables.NAME_TYPE);a+="var "+e+" = Math.floor(Math.random() * "+c+".length);\n";if("SET"==d){return a+(c+"["+e+"] = "+f+";\n")}if("INSERT"==d){return a+(c+".splice("+e+", 0, "+f+");\n")}}throw"Unhandled combination (lists_setIndex)."};Blockly.JavaScript.lists.getIndex_=function(a,b,c){return"FIRST"==b?"0":"FROM_END"==b?a+".length - 1 - "+c:"LAST"==b?a+".length - 1":c};Blockly.JavaScript.lists_getSublist=function(a){var b=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_MEMBER)||"[]",c=a.getFieldValue("WHERE1"),d=a.getFieldValue("WHERE2");if("FIRST"==c&&"LAST"==d){b+=".slice(0)"}else{if(b.match(/^\w+$/)||"FROM_END"!=c&&"FROM_START"==d){switch(c){case"FROM_START":var e=Blockly.JavaScript.getAdjusted(a,"AT1");break;case"FROM_END":e=Blockly.JavaScript.getAdjusted(a,"AT1",1,!1,Blockly.JavaScript.ORDER_SUBTRACTION);e=b+".length - "+e;break;case"FIRST":e="0";break;default:throw"Unhandled option (lists_getSublist)."}switch(d){case"FROM_START":a=Blockly.JavaScript.getAdjusted(a,"AT2",1);break;case"FROM_END":a=Blockly.JavaScript.getAdjusted(a,"AT2",0,!1,Blockly.JavaScript.ORDER_SUBTRACTION);a=b+".length - "+a;break;case"LAST":a=b+".length";break;default:throw"Unhandled option (lists_getSublist)."}b=b+".slice("+e+", "+a+")"}else{e=Blockly.JavaScript.getAdjusted(a,"AT1");a=Blockly.JavaScript.getAdjusted(a,"AT2");var f=Blockly.JavaScript.lists.getIndex_,g={FIRST:"First",LAST:"Last",FROM_START:"FromStart",FROM_END:"FromEnd"};b=Blockly.JavaScript.provideFunction_("subsequence"+g[c]+g[d],["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(sequence"+("FROM_END"==c||"FROM_START"==c?", at1":"")+("FROM_END"==d||"FROM_START"==d?", at2":"")+") {","  var start = "+f("sequence",c,"at1")+";","  var end = "+f("sequence",d,"at2")+" + 1;","  return sequence.slice(start, end);","}"])+"("+b+("FROM_END"==c||"FROM_START"==c?", "+e:"")+("FROM_END"==d||"FROM_START"==d?", "+a:"")+")"
-}}return[b,Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.lists_sort=function(a){var b=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_FUNCTION_CALL)||"[]",c="1"===a.getFieldValue("DIRECTION")?1:-1;a=a.getFieldValue("TYPE");var d=Blockly.JavaScript.provideFunction_("listsGetSortCompare",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(type, direction) {","  var compareFuncs = {",'    "NUMERIC": function(a, b) {',"        return parseFloat(a) - parseFloat(b); },",'    "TEXT": function(a, b) {',"        return a.toString() > b.toString() ? 1 : -1; },",'    "IGNORE_CASE": function(a, b) {',"        return a.toString().toLowerCase() > b.toString().toLowerCase() ? 1 : -1; },","  };","  var compare = compareFuncs[type];","  return function(a, b) { return compare(a, b) * direction; }","}"]);return[b+".slice().sort("+d+'("'+a+'", '+c+"))",Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.lists_split=function(a){var b=Blockly.JavaScript.valueToCode(a,"INPUT",Blockly.JavaScript.ORDER_MEMBER),c=Blockly.JavaScript.valueToCode(a,"DELIM",Blockly.JavaScript.ORDER_NONE)||"''";a=a.getFieldValue("MODE");if("SPLIT"==a){b||(b="''"),a="split"}else{if("JOIN"==a){b||(b="[]"),a="join"}else{throw"Unknown mode: "+a}}return[b+"."+a+"("+c+")",Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.lists_reverse=function(a){return[(Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_FUNCTION_CALL)||"[]")+".slice().reverse()",Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.logic={};Blockly.JavaScript.controls_if=function(a){var b=0,c="";do{var d=Blockly.JavaScript.valueToCode(a,"IF"+b,Blockly.JavaScript.ORDER_NONE)||"false";var e=Blockly.JavaScript.statementToCode(a,"DO"+b);c+=(0<b?" else ":"")+"if ("+d+") {\n"+e+"}";++b}while(a.getInput("IF"+b));a.getInput("ELSE")&&(e=Blockly.JavaScript.statementToCode(a,"ELSE"),c+=" else {\n"+e+"}");return c+"\n"};Blockly.JavaScript.controls_ifelse=Blockly.JavaScript.controls_if;Blockly.JavaScript.logic_compare=function(a){var b={EQ:"==",NEQ:"!=",LT:"<",LTE:"<=",GT:">",GTE:">="}[a.getFieldValue("OP")],c="=="==b||"!="==b?Blockly.JavaScript.ORDER_EQUALITY:Blockly.JavaScript.ORDER_RELATIONAL,d=Blockly.JavaScript.valueToCode(a,"A",c)||"0";
-a=Blockly.JavaScript.valueToCode(a,"B",c)||"0";return[d+" "+b+" "+a,c]};Blockly.JavaScript.logic_operation=function(a){var b="AND"==a.getFieldValue("OP")?"&&":"||",c="&&"==b?Blockly.JavaScript.ORDER_LOGICAL_AND:Blockly.JavaScript.ORDER_LOGICAL_OR,d=Blockly.JavaScript.valueToCode(a,"A",c);a=Blockly.JavaScript.valueToCode(a,"B",c);if(d||a){var e="&&"==b?"true":"false";d||(d=e);a||(a=e)}else{a=d="false"}return[d+" "+b+" "+a,c]};Blockly.JavaScript.logic_negate=function(a){var b=Blockly.JavaScript.ORDER_LOGICAL_NOT;return["!"+(Blockly.JavaScript.valueToCode(a,"BOOL",b)||"true"),b]};Blockly.JavaScript.logic_boolean=function(a){return["TRUE"==a.getFieldValue("BOOL")?"true":"false",Blockly.JavaScript.ORDER_ATOMIC]};Blockly.JavaScript.logic_null=function(a){return["null",Blockly.JavaScript.ORDER_ATOMIC]};Blockly.JavaScript.logic_ternary=function(a){var b=Blockly.JavaScript.valueToCode(a,"IF",Blockly.JavaScript.ORDER_CONDITIONAL)||"false",c=Blockly.JavaScript.valueToCode(a,"THEN",Blockly.JavaScript.ORDER_CONDITIONAL)||"null";a=Blockly.JavaScript.valueToCode(a,"ELSE",Blockly.JavaScript.ORDER_CONDITIONAL)||"null";return[b+" ? "+c+" : "+a,Blockly.JavaScript.ORDER_CONDITIONAL]};Blockly.JavaScript.loops={};Blockly.JavaScript.controls_repeat_ext=function(a){var b=a.getField("TIMES")?String(Number(a.getFieldValue("TIMES"))):Blockly.JavaScript.valueToCode(a,"TIMES",Blockly.JavaScript.ORDER_ASSIGNMENT)||"0",c=Blockly.JavaScript.statementToCode(a,"DO");c=Blockly.JavaScript.addLoopTrap(c,a.id);a="";var d=Blockly.JavaScript.variableDB_.getDistinctName("count",Blockly.Variables.NAME_TYPE),e=b;b.match(/^\w+$/)||Blockly.isNumber(b)||(e=Blockly.JavaScript.variableDB_.getDistinctName("repeat_end",Blockly.Variables.NAME_TYPE),a+="var "+e+" = "+b+";\n");return a+("for (var "+d+" = 0; "+d+" < "+e+"; "+d+"++) {\n"+c+"}\n")};Blockly.JavaScript.controls_repeat=Blockly.JavaScript.controls_repeat_ext;Blockly.JavaScript.controls_whileUntil=function(a){var b="UNTIL"==a.getFieldValue("MODE"),c=Blockly.JavaScript.valueToCode(a,"BOOL",b?Blockly.JavaScript.ORDER_LOGICAL_NOT:Blockly.JavaScript.ORDER_NONE)||"false",d=Blockly.JavaScript.statementToCode(a,"DO");
-d=Blockly.JavaScript.addLoopTrap(d,a.id);b&&(c="!"+c);return"while ("+c+") {\n"+d+"}\n"};Blockly.JavaScript.controls_for=function(a){var b=Blockly.JavaScript.variableDB_.getName(a.getFieldValue("VAR"),Blockly.Variables.NAME_TYPE),c=Blockly.JavaScript.valueToCode(a,"FROM",Blockly.JavaScript.ORDER_ASSIGNMENT)||"0",d=Blockly.JavaScript.valueToCode(a,"TO",Blockly.JavaScript.ORDER_ASSIGNMENT)||"0",e=Blockly.JavaScript.valueToCode(a,"BY",Blockly.JavaScript.ORDER_ASSIGNMENT)||"1",f=Blockly.JavaScript.statementToCode(a,"DO");f=Blockly.JavaScript.addLoopTrap(f,a.id);if(Blockly.isNumber(c)&&Blockly.isNumber(d)&&Blockly.isNumber(e)){var g=parseFloat(c)<=parseFloat(d);a="for ("+b+" = "+c+"; "+b+(g?" <= ":" >= ")+d+"; "+b;b=Math.abs(parseFloat(e));a=(1==b?a+(g?"++":"--"):a+((g?" += ":" -= ")+b))+(") {\n"+f+"}\n")}else{a="",g=c,c.match(/^\w+$/)||Blockly.isNumber(c)||(g=Blockly.JavaScript.variableDB_.getDistinctName(b+"_start",Blockly.Variables.NAME_TYPE),a+="var "+g+" = "+c+";\n"),c=d,d.match(/^\w+$/)||Blockly.isNumber(d)||(c=Blockly.JavaScript.variableDB_.getDistinctName(b+"_end",Blockly.Variables.NAME_TYPE),a+="var "+c+" = "+d+";\n"),d=Blockly.JavaScript.variableDB_.getDistinctName(b+"_inc",Blockly.Variables.NAME_TYPE),a+="var "+d+" = ",a=Blockly.isNumber(e)?a+(Math.abs(e)+";\n"):a+("Math.abs("+e+");\n"),a=a+("if ("+g+" > "+c+") {\n")+(Blockly.JavaScript.INDENT+d+" = -"+d+";\n"),a+="}\n",a+="for ("+b+" = "+g+"; "+d+" >= 0 ? "+b+" <= "+c+" : "+b+" >= "+c+"; "+b+" += "+d+") {\n"+f+"}\n"}return a};Blockly.JavaScript.controls_forEach=function(a){var b=Blockly.JavaScript.variableDB_.getName(a.getFieldValue("VAR"),Blockly.Variables.NAME_TYPE),c=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_ASSIGNMENT)||"[]",d=Blockly.JavaScript.statementToCode(a,"DO");d=Blockly.JavaScript.addLoopTrap(d,a.id);a="";var e=c;c.match(/^\w+$/)||(e=Blockly.JavaScript.variableDB_.getDistinctName(b+"_list",Blockly.Variables.NAME_TYPE),a+="var "+e+" = "+c+";\n");c=Blockly.JavaScript.variableDB_.getDistinctName(b+"_index",Blockly.Variables.NAME_TYPE);
-d=Blockly.JavaScript.INDENT+b+" = "+e+"["+c+"];\n"+d;return a+("for (var "+c+" in "+e+") {\n"+d+"}\n")};Blockly.JavaScript.controls_flow_statements=function(a){switch(a.getFieldValue("FLOW")){case"BREAK":return"break;\n";case"CONTINUE":return"continue;\n"}throw"Unknown flow statement."};Blockly.JavaScript.math={};Blockly.JavaScript.math_number=function(a){return[parseFloat(a.getFieldValue("NUM")),Blockly.JavaScript.ORDER_ATOMIC]};Blockly.JavaScript.math_arithmetic=function(a){var b={ADD:[" + ",Blockly.JavaScript.ORDER_ADDITION],MINUS:[" - ",Blockly.JavaScript.ORDER_SUBTRACTION],MULTIPLY:[" * ",Blockly.JavaScript.ORDER_MULTIPLICATION],DIVIDE:[" / ",Blockly.JavaScript.ORDER_DIVISION],POWER:[null,Blockly.JavaScript.ORDER_COMMA]}[a.getFieldValue("OP")],c=b[0];b=b[1];var d=Blockly.JavaScript.valueToCode(a,"A",b)||"0";a=Blockly.JavaScript.valueToCode(a,"B",b)||"0";return c?[d+c+a,b]:["Math.pow("+d+", "+a+")",Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.math_single=function(a){var b=a.getFieldValue("OP");if("NEG"==b){return a=Blockly.JavaScript.valueToCode(a,"NUM",Blockly.JavaScript.ORDER_UNARY_NEGATION)||"0","-"==a[0]&&(a=" "+a),["-"+a,Blockly.JavaScript.ORDER_UNARY_NEGATION]}a="SIN"==b||"COS"==b||"TAN"==b?Blockly.JavaScript.valueToCode(a,"NUM",Blockly.JavaScript.ORDER_DIVISION)||"0":Blockly.JavaScript.valueToCode(a,"NUM",Blockly.JavaScript.ORDER_NONE)||"0";switch(b){case"ABS":var c="Math.abs("+a+")";break;case"ROOT":c="Math.sqrt("+a+")";break;case"LN":c="Math.log("+a+")";break;case"EXP":c="Math.exp("+a+")";break;case"POW10":c="Math.pow(10,"+a+")";break;case"ROUND":c="Math.round("+a+")";break;case"ROUNDUP":c="Math.ceil("+a+")";break;case"ROUNDDOWN":c="Math.floor("+a+")";break;case"SIN":c="Math.sin("+a+" / 180 * Math.PI)";break;case"COS":c="Math.cos("+a+" / 180 * Math.PI)";break;case"TAN":c="Math.tan("+a+" / 180 * Math.PI)"}if(c){return[c,Blockly.JavaScript.ORDER_FUNCTION_CALL]}switch(b){case"LOG10":c="Math.log("+a+") / Math.log(10)";break;case"ASIN":c="Math.asin("+a+") / Math.PI * 180";
-break;case"ACOS":c="Math.acos("+a+") / Math.PI * 180";break;case"ATAN":c="Math.atan("+a+") / Math.PI * 180";break;default:throw"Unknown math operator: "+b}return[c,Blockly.JavaScript.ORDER_DIVISION]};Blockly.JavaScript.math_constant=function(a){return{PI:["Math.PI",Blockly.JavaScript.ORDER_MEMBER],E:["Math.E",Blockly.JavaScript.ORDER_MEMBER],GOLDEN_RATIO:["(1 + Math.sqrt(5)) / 2",Blockly.JavaScript.ORDER_DIVISION],SQRT2:["Math.SQRT2",Blockly.JavaScript.ORDER_MEMBER],SQRT1_2:["Math.SQRT1_2",Blockly.JavaScript.ORDER_MEMBER],INFINITY:["Infinity",Blockly.JavaScript.ORDER_ATOMIC]}[a.getFieldValue("CONSTANT")]};Blockly.JavaScript.math_number_property=function(a){var b=Blockly.JavaScript.valueToCode(a,"NUMBER_TO_CHECK",Blockly.JavaScript.ORDER_MODULUS)||"0",c=a.getFieldValue("PROPERTY");if("PRIME"==c){return[Blockly.JavaScript.provideFunction_("mathIsPrime",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(n) {","  // https://en.wikipedia.org/wiki/Primality_test#Naive_methods","  if (n == 2 || n == 3) {","    return true;","  }","  // False if n is NaN, negative, is 1, or not whole.","  // And false if n is divisible by 2 or 3.","  if (isNaN(n) || n <= 1 || n % 1 != 0 || n % 2 == 0 || n % 3 == 0) {","    return false;","  }","  // Check all the numbers of form 6k +/- 1, up to sqrt(n).","  for (var x = 6; x <= Math.sqrt(n) + 1; x += 6) {","    if (n % (x - 1) == 0 || n % (x + 1) == 0) {","      return false;","    }","  }","  return true;","}"])+"("+b+")",Blockly.JavaScript.ORDER_FUNCTION_CALL]}switch(c){case"EVEN":var d=b+" % 2 == 0";break;case"ODD":d=b+" % 2 == 1";break;case"WHOLE":d=b+" % 1 == 0";break;case"POSITIVE":d=b+" > 0";break;case"NEGATIVE":d=b+" < 0";break;case"DIVISIBLE_BY":a=Blockly.JavaScript.valueToCode(a,"DIVISOR",Blockly.JavaScript.ORDER_MODULUS)||"0",d=b+" % "+a+" == 0"}return[d,Blockly.JavaScript.ORDER_EQUALITY]};Blockly.JavaScript.math_change=function(a){var b=Blockly.JavaScript.valueToCode(a,"DELTA",Blockly.JavaScript.ORDER_ADDITION)||"0";a=Blockly.JavaScript.variableDB_.getName(a.getFieldValue("VAR"),Blockly.Variables.NAME_TYPE);
-return a+" = (typeof "+a+" == 'number' ? "+a+" : 0) + "+b+";\n"};Blockly.JavaScript.math_round=Blockly.JavaScript.math_single;Blockly.JavaScript.math_trig=Blockly.JavaScript.math_single;Blockly.JavaScript.math_on_list=function(a){var b=a.getFieldValue("OP");switch(b){case"SUM":a=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_MEMBER)||"[]";a+=".reduce(function(x, y) {return x + y;})";break;case"MIN":a=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_COMMA)||"[]";a="Math.min.apply(null, "+a+")";break;case"MAX":a=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_COMMA)||"[]";a="Math.max.apply(null, "+a+")";break;case"AVERAGE":b=Blockly.JavaScript.provideFunction_("mathMean",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(myList) {","  return myList.reduce(function(x, y) {return x + y;}) / myList.length;","}"]);a=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_NONE)||"[]";a=b+"("+a+")";break;case"MEDIAN":b=Blockly.JavaScript.provideFunction_("mathMedian",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(myList) {","  var localList = myList.filter(function (x) {return typeof x == 'number';});","  if (!localList.length) return null;","  localList.sort(function(a, b) {return b - a;});","  if (localList.length % 2 == 0) {","    return (localList[localList.length / 2 - 1] + localList[localList.length / 2]) / 2;","  } else {","    return localList[(localList.length - 1) / 2];","  }","}"]);a=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_NONE)||"[]";a=b+"("+a+")";break;case"MODE":b=Blockly.JavaScript.provideFunction_("mathModes",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(values) {","  var modes = [];","  var counts = [];","  var maxCount = 0;","  for (var i = 0; i < values.length; i++) {","    var value = values[i];","    var found = false;","    var thisCount;","    for (var j = 0; j < counts.length; j++) {","      if (counts[j][0] === value) {","        thisCount = ++counts[j][1];","        found = true;","        break;","      }","    }","    if (!found) {","      counts.push([value, 1]);","      thisCount = 1;","    }","    maxCount = Math.max(thisCount, maxCount);","  }","  for (var j = 0; j < counts.length; j++) {","    if (counts[j][1] == maxCount) {","        modes.push(counts[j][0]);","    }","  }","  return modes;","}"]);
-a=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_NONE)||"[]";a=b+"("+a+")";break;case"STD_DEV":b=Blockly.JavaScript.provideFunction_("mathStandardDeviation",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(numbers) {","  var n = numbers.length;","  if (!n) return null;","  var mean = numbers.reduce(function(x, y) {return x + y;}) / n;","  var variance = 0;","  for (var j = 0; j < n; j++) {","    variance += Math.pow(numbers[j] - mean, 2);","  }","  variance = variance / n;","  return Math.sqrt(variance);","}"]);a=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_NONE)||"[]";a=b+"("+a+")";break;case"RANDOM":b=Blockly.JavaScript.provideFunction_("mathRandomList",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(list) {","  var x = Math.floor(Math.random() * list.length);","  return list[x];","}"]);a=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_NONE)||"[]";a=b+"("+a+")";break;default:throw"Unknown operator: "+b}return[a,Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.math_modulo=function(a){var b=Blockly.JavaScript.valueToCode(a,"DIVIDEND",Blockly.JavaScript.ORDER_MODULUS)||"0";a=Blockly.JavaScript.valueToCode(a,"DIVISOR",Blockly.JavaScript.ORDER_MODULUS)||"0";return[b+" % "+a,Blockly.JavaScript.ORDER_MODULUS]};Blockly.JavaScript.math_constrain=function(a){var b=Blockly.JavaScript.valueToCode(a,"VALUE",Blockly.JavaScript.ORDER_COMMA)||"0",c=Blockly.JavaScript.valueToCode(a,"LOW",Blockly.JavaScript.ORDER_COMMA)||"0";a=Blockly.JavaScript.valueToCode(a,"HIGH",Blockly.JavaScript.ORDER_COMMA)||"Infinity";return["Math.min(Math.max("+b+", "+c+"), "+a+")",Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.math_random_int=function(a){var b=Blockly.JavaScript.valueToCode(a,"FROM",Blockly.JavaScript.ORDER_COMMA)||"0";a=Blockly.JavaScript.valueToCode(a,"TO",Blockly.JavaScript.ORDER_COMMA)||"0";return[Blockly.JavaScript.provideFunction_("mathRandomInt",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(a, b) {","  if (a > b) {","    // Swap a and b to ensure a is smaller.","    var c = a;","    a = b;","    b = c;","  }","  return Math.floor(Math.random() * (b - a + 1) + a);","}"])+"("+b+", "+a+")",Blockly.JavaScript.ORDER_FUNCTION_CALL]
-};Blockly.JavaScript.math_random_float=function(a){return["Math.random()",Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.procedures={};Blockly.JavaScript.procedures_defreturn=function(a){var b=Blockly.JavaScript.variableDB_.getName(a.getFieldValue("NAME"),Blockly.Procedures.NAME_TYPE),c=Blockly.JavaScript.statementToCode(a,"STACK");if(Blockly.JavaScript.STATEMENT_PREFIX){var d=a.id.replace(/\$/g,"$$$$");c=Blockly.JavaScript.prefixLines(Blockly.JavaScript.STATEMENT_PREFIX.replace(/%1/g,"'"+d+"'"),Blockly.JavaScript.INDENT)+c}Blockly.JavaScript.INFINITE_LOOP_TRAP&&(c=Blockly.JavaScript.INFINITE_LOOP_TRAP.replace(/%1/g,"'"+a.id+"'")+c);(d=Blockly.JavaScript.valueToCode(a,"RETURN",Blockly.JavaScript.ORDER_NONE)||"")&&(d=Blockly.JavaScript.INDENT+"return "+d+";\n");for(var e=[],f=0;f<a.arguments_.length;f++){e[f]=Blockly.JavaScript.variableDB_.getName(a.arguments_[f],Blockly.Variables.NAME_TYPE)}c="function "+b+"("+e.join(", ")+") {\n"+c+d+"}";c=Blockly.JavaScript.scrub_(a,c);Blockly.JavaScript.definitions_["%"+b]=c;return null};Blockly.JavaScript.procedures_defnoreturn=Blockly.JavaScript.procedures_defreturn;Blockly.JavaScript.procedures_callreturn=function(a){for(var b=Blockly.JavaScript.variableDB_.getName(a.getFieldValue("NAME"),Blockly.Procedures.NAME_TYPE),c=[],d=0;d<a.arguments_.length;d++){c[d]=Blockly.JavaScript.valueToCode(a,"ARG"+d,Blockly.JavaScript.ORDER_COMMA)||"null"}return[b+"("+c.join(", ")+")",Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.procedures_callnoreturn=function(a){for(var b=Blockly.JavaScript.variableDB_.getName(a.getFieldValue("NAME"),Blockly.Procedures.NAME_TYPE),c=[],d=0;d<a.arguments_.length;d++){c[d]=Blockly.JavaScript.valueToCode(a,"ARG"+d,Blockly.JavaScript.ORDER_COMMA)||"null"}return b+"("+c.join(", ")+");\n"};Blockly.JavaScript.procedures_ifreturn=function(a){var b="if ("+(Blockly.JavaScript.valueToCode(a,"CONDITION",Blockly.JavaScript.ORDER_NONE)||"false")+") {\n";a.hasReturnValue_?(a=Blockly.JavaScript.valueToCode(a,"VALUE",Blockly.JavaScript.ORDER_NONE)||"null",b+=Blockly.JavaScript.INDENT+"return "+a+";\n"):b+=Blockly.JavaScript.INDENT+"return;\n";
-return b+"}\n"};Blockly.JavaScript.texts={};Blockly.JavaScript.text=function(a){return[Blockly.JavaScript.quote_(a.getFieldValue("TEXT")),Blockly.JavaScript.ORDER_ATOMIC]};Blockly.JavaScript.text_join=function(a){switch(a.itemCount_){case 0:return["''",Blockly.JavaScript.ORDER_ATOMIC];case 1:return["String("+(Blockly.JavaScript.valueToCode(a,"ADD0",Blockly.JavaScript.ORDER_NONE)||"''")+")",Blockly.JavaScript.ORDER_FUNCTION_CALL];case 2:var b=Blockly.JavaScript.valueToCode(a,"ADD0",Blockly.JavaScript.ORDER_NONE)||"''";a=Blockly.JavaScript.valueToCode(a,"ADD1",Blockly.JavaScript.ORDER_NONE)||"''";return["String("+b+") + String("+a+")",Blockly.JavaScript.ORDER_ADDITION];default:b=Array(a.itemCount_);for(var c=0;c<a.itemCount_;c++){b[c]=Blockly.JavaScript.valueToCode(a,"ADD"+c,Blockly.JavaScript.ORDER_COMMA)||"''"}a="["+b.join(",")+"].join('')";return[a,Blockly.JavaScript.ORDER_FUNCTION_CALL]}};Blockly.JavaScript.text_append=function(a){var b=Blockly.JavaScript.variableDB_.getName(a.getFieldValue("VAR"),Blockly.Variables.NAME_TYPE);a=Blockly.JavaScript.valueToCode(a,"TEXT",Blockly.JavaScript.ORDER_NONE)||"''";return b+" = String("+b+") + String("+a+");\n"};Blockly.JavaScript.text_length=function(a){return[(Blockly.JavaScript.valueToCode(a,"VALUE",Blockly.JavaScript.ORDER_FUNCTION_CALL)||"''")+".length",Blockly.JavaScript.ORDER_MEMBER]};Blockly.JavaScript.text_isEmpty=function(a){return["!"+(Blockly.JavaScript.valueToCode(a,"VALUE",Blockly.JavaScript.ORDER_MEMBER)||"''")+".length",Blockly.JavaScript.ORDER_LOGICAL_NOT]};Blockly.JavaScript.text_indexOf=function(a){var b="FIRST"==a.getFieldValue("END")?"indexOf":"lastIndexOf",c=Blockly.JavaScript.valueToCode(a,"FIND",Blockly.JavaScript.ORDER_NONE)||"''";b=(Blockly.JavaScript.valueToCode(a,"VALUE",Blockly.JavaScript.ORDER_MEMBER)||"''")+"."+b+"("+c+")";return a.workspace.options.oneBasedIndex?[b+" + 1",Blockly.JavaScript.ORDER_ADDITION]:[b,Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.text_charAt=function(a){var b=a.getFieldValue("WHERE")||"FROM_START",c=Blockly.JavaScript.valueToCode(a,"VALUE","RANDOM"==b?Blockly.JavaScript.ORDER_NONE:Blockly.JavaScript.ORDER_MEMBER)||"''";
-switch(b){case"FIRST":return[c+".charAt(0)",Blockly.JavaScript.ORDER_FUNCTION_CALL];case"LAST":return[c+".slice(-1)",Blockly.JavaScript.ORDER_FUNCTION_CALL];case"FROM_START":return a=Blockly.JavaScript.getAdjusted(a,"AT"),[c+".charAt("+a+")",Blockly.JavaScript.ORDER_FUNCTION_CALL];case"FROM_END":return a=Blockly.JavaScript.getAdjusted(a,"AT",1,!0),[c+".slice("+a+").charAt(0)",Blockly.JavaScript.ORDER_FUNCTION_CALL];case"RANDOM":return[Blockly.JavaScript.provideFunction_("textRandomLetter",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(text) {","  var x = Math.floor(Math.random() * text.length);","  return text[x];","}"])+"("+c+")",Blockly.JavaScript.ORDER_FUNCTION_CALL]}throw"Unhandled option (text_charAt)."};Blockly.JavaScript.text.getIndex_=function(a,b,c){return"FIRST"==b?"0":"FROM_END"==b?a+".length - 1 - "+c:"LAST"==b?a+".length - 1":c};Blockly.JavaScript.text_getSubstring=function(a){var b=Blockly.JavaScript.valueToCode(a,"STRING",Blockly.JavaScript.ORDER_FUNCTION_CALL)||"''",c=a.getFieldValue("WHERE1"),d=a.getFieldValue("WHERE2");if("FIRST"!=c||"LAST"!=d){if(b.match(/^'?\w+'?$/)||"FROM_END"!=c&&"LAST"!=c&&"FROM_END"!=d&&"LAST"!=d){switch(c){case"FROM_START":var e=Blockly.JavaScript.getAdjusted(a,"AT1");break;case"FROM_END":e=Blockly.JavaScript.getAdjusted(a,"AT1",1,!1,Blockly.JavaScript.ORDER_SUBTRACTION);e=b+".length - "+e;break;case"FIRST":e="0";break;default:throw"Unhandled option (text_getSubstring)."}switch(d){case"FROM_START":a=Blockly.JavaScript.getAdjusted(a,"AT2",1);break;case"FROM_END":a=Blockly.JavaScript.getAdjusted(a,"AT2",0,!1,Blockly.JavaScript.ORDER_SUBTRACTION);a=b+".length - "+a;break;case"LAST":a=b+".length";break;default:throw"Unhandled option (text_getSubstring)."}b=b+".slice("+e+", "+a+")"}else{e=Blockly.JavaScript.getAdjusted(a,"AT1");a=Blockly.JavaScript.getAdjusted(a,"AT2");var f=Blockly.JavaScript.text.getIndex_,g={FIRST:"First",LAST:"Last",FROM_START:"FromStart",FROM_END:"FromEnd"};b=Blockly.JavaScript.provideFunction_("subsequence"+g[c]+g[d],["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(sequence"+("FROM_END"==c||"FROM_START"==c?", at1":"")+("FROM_END"==d||"FROM_START"==d?", at2":"")+") {","  var start = "+f("sequence",c,"at1")+";","  var end = "+f("sequence",d,"at2")+" + 1;","  return sequence.slice(start, end);","}"])+"("+b+("FROM_END"==c||"FROM_START"==c?", "+e:"")+("FROM_END"==d||"FROM_START"==d?", "+a:"")+")"
-}}return[b,Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.text_changeCase=function(a){var b={UPPERCASE:".toUpperCase()",LOWERCASE:".toLowerCase()",TITLECASE:null}[a.getFieldValue("CASE")];a=Blockly.JavaScript.valueToCode(a,"TEXT",b?Blockly.JavaScript.ORDER_MEMBER:Blockly.JavaScript.ORDER_NONE)||"''";return[b?a+b:Blockly.JavaScript.provideFunction_("textToTitleCase",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(str) {","  return str.replace(/\\S+/g,","      function(txt) {return txt[0].toUpperCase() + txt.substring(1).toLowerCase();});","}"])+"("+a+")",Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.text_trim=function(a){var b={LEFT:".replace(/^[\\s\\xa0]+/, '')",RIGHT:".replace(/[\\s\\xa0]+$/, '')",BOTH:".trim()"}[a.getFieldValue("MODE")];return[(Blockly.JavaScript.valueToCode(a,"TEXT",Blockly.JavaScript.ORDER_MEMBER)||"''")+b,Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.text_print=function(a){return"window.alert("+(Blockly.JavaScript.valueToCode(a,"TEXT",Blockly.JavaScript.ORDER_NONE)||"''")+");\n"};Blockly.JavaScript.text_prompt_ext=function(a){var b="window.prompt("+(a.getField("TEXT")?Blockly.JavaScript.quote_(a.getFieldValue("TEXT")):Blockly.JavaScript.valueToCode(a,"TEXT",Blockly.JavaScript.ORDER_NONE)||"''")+")";"NUMBER"==a.getFieldValue("TYPE")&&(b="parseFloat("+b+")");return[b,Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.text_prompt=Blockly.JavaScript.text_prompt_ext;Blockly.JavaScript.text_count=function(a){var b=Blockly.JavaScript.valueToCode(a,"TEXT",Blockly.JavaScript.ORDER_MEMBER)||"''";a=Blockly.JavaScript.valueToCode(a,"SUB",Blockly.JavaScript.ORDER_NONE)||"''";return[Blockly.JavaScript.provideFunction_("textCount",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(haystack, needle) {","  if (needle.length === 0) {","    return haystack.length + 1;","  } else {","    return haystack.split(needle).length - 1;","  }","}"])+"("+b+", "+a+")",Blockly.JavaScript.ORDER_SUBTRACTION]
-};Blockly.JavaScript.text_replace=function(a){var b=Blockly.JavaScript.valueToCode(a,"TEXT",Blockly.JavaScript.ORDER_MEMBER)||"''",c=Blockly.JavaScript.valueToCode(a,"FROM",Blockly.JavaScript.ORDER_NONE)||"''";a=Blockly.JavaScript.valueToCode(a,"TO",Blockly.JavaScript.ORDER_NONE)||"''";return[Blockly.JavaScript.provideFunction_("textReplace",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(haystack, needle, replacement) {",'  needle = needle.replace(/([-()\\[\\]{}+?*.$\\^|,:#<!\\\\])/g,"\\\\$1")','                 .replace(/\\x08/g,"\\\\x08");',"  return haystack.replace(new RegExp(needle, 'g'), replacement);","}"])+"("+b+", "+c+", "+a+")",Blockly.JavaScript.ORDER_MEMBER]};Blockly.JavaScript.text_reverse=function(a){return[(Blockly.JavaScript.valueToCode(a,"TEXT",Blockly.JavaScript.ORDER_MEMBER)||"''")+".split('').reverse().join('')",Blockly.JavaScript.ORDER_MEMBER]};Blockly.JavaScript.variables={};Blockly.JavaScript.variables_get=function(a){return[Blockly.JavaScript.variableDB_.getName(a.getFieldValue("VAR"),Blockly.Variables.NAME_TYPE),Blockly.JavaScript.ORDER_ATOMIC]};Blockly.JavaScript.variables_set=function(a){var b=Blockly.JavaScript.valueToCode(a,"VALUE",Blockly.JavaScript.ORDER_ASSIGNMENT)||"0";return Blockly.JavaScript.variableDB_.getName(a.getFieldValue("VAR"),Blockly.Variables.NAME_TYPE)+" = "+b+";\n"};
diff --git a/_server/blockly/blocks_compressed.js b/_server/blockly/blocks_compressed.js
new file mode 100644
index 00000000..8baac402
--- /dev/null
+++ b/_server/blockly/blocks_compressed.js
@@ -0,0 +1,171 @@
+// Do not edit this file; automatically generated by build.py.
+'use strict';
+
+
+Blockly.Blocks.colour={};Blockly.Constants={};Blockly.Constants.Colour={};Blockly.Constants.Colour.HUE=20;
+Blockly.defineBlocksWithJsonArray([{type:"colour_picker",message0:"%1",args0:[{type:"field_colour",name:"COLOUR",colour:"#ff0000"}],output:"Colour",helpUrl:"%{BKY_COLOUR_PICKER_HELPURL}",style:"colour_blocks",tooltip:"%{BKY_COLOUR_PICKER_TOOLTIP}",extensions:["parent_tooltip_when_inline"]},{type:"colour_random",message0:"%{BKY_COLOUR_RANDOM_TITLE}",output:"Colour",helpUrl:"%{BKY_COLOUR_RANDOM_HELPURL}",style:"colour_blocks",tooltip:"%{BKY_COLOUR_RANDOM_TOOLTIP}"},{type:"colour_rgb",message0:"%{BKY_COLOUR_RGB_TITLE} %{BKY_COLOUR_RGB_RED} %1 %{BKY_COLOUR_RGB_GREEN} %2 %{BKY_COLOUR_RGB_BLUE} %3",
+args0:[{type:"input_value",name:"RED",check:"Number",align:"RIGHT"},{type:"input_value",name:"GREEN",check:"Number",align:"RIGHT"},{type:"input_value",name:"BLUE",check:"Number",align:"RIGHT"}],output:"Colour",helpUrl:"%{BKY_COLOUR_RGB_HELPURL}",style:"colour_blocks",tooltip:"%{BKY_COLOUR_RGB_TOOLTIP}"},{type:"colour_blend",message0:"%{BKY_COLOUR_BLEND_TITLE} %{BKY_COLOUR_BLEND_COLOUR1} %1 %{BKY_COLOUR_BLEND_COLOUR2} %2 %{BKY_COLOUR_BLEND_RATIO} %3",args0:[{type:"input_value",name:"COLOUR1",check:"Colour",
+align:"RIGHT"},{type:"input_value",name:"COLOUR2",check:"Colour",align:"RIGHT"},{type:"input_value",name:"RATIO",check:"Number",align:"RIGHT"}],output:"Colour",helpUrl:"%{BKY_COLOUR_BLEND_HELPURL}",style:"colour_blocks",tooltip:"%{BKY_COLOUR_BLEND_TOOLTIP}"}]);Blockly.Blocks.lists={};Blockly.Constants.Lists={};Blockly.Constants.Lists.HUE=260;
+Blockly.defineBlocksWithJsonArray([{type:"lists_create_empty",message0:"%{BKY_LISTS_CREATE_EMPTY_TITLE}",output:"Array",style:"list_blocks",tooltip:"%{BKY_LISTS_CREATE_EMPTY_TOOLTIP}",helpUrl:"%{BKY_LISTS_CREATE_EMPTY_HELPURL}"},{type:"lists_repeat",message0:"%{BKY_LISTS_REPEAT_TITLE}",args0:[{type:"input_value",name:"ITEM"},{type:"input_value",name:"NUM",check:"Number"}],output:"Array",style:"list_blocks",tooltip:"%{BKY_LISTS_REPEAT_TOOLTIP}",helpUrl:"%{BKY_LISTS_REPEAT_HELPURL}"},{type:"lists_reverse",
+message0:"%{BKY_LISTS_REVERSE_MESSAGE0}",args0:[{type:"input_value",name:"LIST",check:"Array"}],output:"Array",inputsInline:!0,style:"list_blocks",tooltip:"%{BKY_LISTS_REVERSE_TOOLTIP}",helpUrl:"%{BKY_LISTS_REVERSE_HELPURL}"},{type:"lists_isEmpty",message0:"%{BKY_LISTS_ISEMPTY_TITLE}",args0:[{type:"input_value",name:"VALUE",check:["String","Array"]}],output:"Boolean",style:"list_blocks",tooltip:"%{BKY_LISTS_ISEMPTY_TOOLTIP}",helpUrl:"%{BKY_LISTS_ISEMPTY_HELPURL}"},{type:"lists_length",message0:"%{BKY_LISTS_LENGTH_TITLE}",
+args0:[{type:"input_value",name:"VALUE",check:["String","Array"]}],output:"Number",style:"list_blocks",tooltip:"%{BKY_LISTS_LENGTH_TOOLTIP}",helpUrl:"%{BKY_LISTS_LENGTH_HELPURL}"}]);
+Blockly.Blocks.lists_create_with={init:function(){this.setHelpUrl(Blockly.Msg.LISTS_CREATE_WITH_HELPURL);this.setStyle("list_blocks");this.itemCount_=3;this.updateShape_();this.setOutput(!0,"Array");this.setMutator(new Blockly.Mutator(["lists_create_with_item"]));this.setTooltip(Blockly.Msg.LISTS_CREATE_WITH_TOOLTIP)},mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("items",this.itemCount_);return a},domToMutation:function(a){this.itemCount_=parseInt(a.getAttribute("items"),
+10);this.updateShape_()},decompose:function(a){var b=a.newBlock("lists_create_with_container");b.initSvg();for(var c=b.getInput("STACK").connection,d=0;d<this.itemCount_;d++){var e=a.newBlock("lists_create_with_item");e.initSvg();c.connect(e.previousConnection);c=e.nextConnection}return b},compose:function(a){var b=a.getInputTargetBlock("STACK");for(a=[];b;)a.push(b.valueConnection_),b=b.nextConnection&&b.nextConnection.targetBlock();for(b=0;b<this.itemCount_;b++){var c=this.getInput("ADD"+b).connection.targetConnection;
+c&&-1==a.indexOf(c)&&c.disconnect()}this.itemCount_=a.length;this.updateShape_();for(b=0;b<this.itemCount_;b++)Blockly.Mutator.reconnect(a[b],this,"ADD"+b)},saveConnections:function(a){a=a.getInputTargetBlock("STACK");for(var b=0;a;){var c=this.getInput("ADD"+b);a.valueConnection_=c&&c.connection.targetConnection;b++;a=a.nextConnection&&a.nextConnection.targetBlock()}},updateShape_:function(){this.itemCount_&&this.getInput("EMPTY")?this.removeInput("EMPTY"):this.itemCount_||this.getInput("EMPTY")||
+this.appendDummyInput("EMPTY").appendField(Blockly.Msg.LISTS_CREATE_EMPTY_TITLE);for(var a=0;a<this.itemCount_;a++)if(!this.getInput("ADD"+a)){var b=this.appendValueInput("ADD"+a);0==a&&b.appendField(Blockly.Msg.LISTS_CREATE_WITH_INPUT_WITH)}for(;this.getInput("ADD"+a);)this.removeInput("ADD"+a),a++}};
+Blockly.Blocks.lists_create_with_container={init:function(){this.setStyle("list_blocks");this.appendDummyInput().appendField(Blockly.Msg.LISTS_CREATE_WITH_CONTAINER_TITLE_ADD);this.appendStatementInput("STACK");this.setTooltip(Blockly.Msg.LISTS_CREATE_WITH_CONTAINER_TOOLTIP);this.contextMenu=!1}};
+Blockly.Blocks.lists_create_with_item={init:function(){this.setStyle("list_blocks");this.appendDummyInput().appendField(Blockly.Msg.LISTS_CREATE_WITH_ITEM_TITLE);this.setPreviousStatement(!0);this.setNextStatement(!0);this.setTooltip(Blockly.Msg.LISTS_CREATE_WITH_ITEM_TOOLTIP);this.contextMenu=!1}};
+Blockly.Blocks.lists_indexOf={init:function(){var a=[[Blockly.Msg.LISTS_INDEX_OF_FIRST,"FIRST"],[Blockly.Msg.LISTS_INDEX_OF_LAST,"LAST"]];this.setHelpUrl(Blockly.Msg.LISTS_INDEX_OF_HELPURL);this.setStyle("list_blocks");this.setOutput(!0,"Number");this.appendValueInput("VALUE").setCheck("Array").appendField(Blockly.Msg.LISTS_INDEX_OF_INPUT_IN_LIST);this.appendValueInput("FIND").appendField(new Blockly.FieldDropdown(a),"END");this.setInputsInline(!0);var b=this;this.setTooltip(function(){return Blockly.Msg.LISTS_INDEX_OF_TOOLTIP.replace("%1",
+b.workspace.options.oneBasedIndex?"0":"-1")})}};
+Blockly.Blocks.lists_getIndex={init:function(){var a=[[Blockly.Msg.LISTS_GET_INDEX_GET,"GET"],[Blockly.Msg.LISTS_GET_INDEX_GET_REMOVE,"GET_REMOVE"],[Blockly.Msg.LISTS_GET_INDEX_REMOVE,"REMOVE"]];this.WHERE_OPTIONS=[[Blockly.Msg.LISTS_GET_INDEX_FROM_START,"FROM_START"],[Blockly.Msg.LISTS_GET_INDEX_FROM_END,"FROM_END"],[Blockly.Msg.LISTS_GET_INDEX_FIRST,"FIRST"],[Blockly.Msg.LISTS_GET_INDEX_LAST,"LAST"],[Blockly.Msg.LISTS_GET_INDEX_RANDOM,"RANDOM"]];this.setHelpUrl(Blockly.Msg.LISTS_GET_INDEX_HELPURL);this.setStyle("list_blocks");
+a=new Blockly.FieldDropdown(a,function(a){this.sourceBlock_.updateStatement_("REMOVE"==a)});this.appendValueInput("VALUE").setCheck("Array").appendField(Blockly.Msg.LISTS_GET_INDEX_INPUT_IN_LIST);this.appendDummyInput().appendField(a,"MODE").appendField("","SPACE");this.appendDummyInput("AT");Blockly.Msg.LISTS_GET_INDEX_TAIL&&this.appendDummyInput("TAIL").appendField(Blockly.Msg.LISTS_GET_INDEX_TAIL);this.setInputsInline(!0);this.setOutput(!0);this.updateAt_(!0);var b=this;this.setTooltip(function(){var a=
+b.getFieldValue("MODE"),d=b.getFieldValue("WHERE"),e="";switch(a+" "+d){case "GET FROM_START":case "GET FROM_END":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_FROM;break;case "GET FIRST":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_FIRST;break;case "GET LAST":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_LAST;break;case "GET RANDOM":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_RANDOM;break;case "GET_REMOVE FROM_START":case "GET_REMOVE FROM_END":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FROM;break;case "GET_REMOVE FIRST":e=
+Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FIRST;break;case "GET_REMOVE LAST":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_LAST;break;case "GET_REMOVE RANDOM":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_RANDOM;break;case "REMOVE FROM_START":case "REMOVE FROM_END":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_FROM;break;case "REMOVE FIRST":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_FIRST;break;case "REMOVE LAST":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_LAST;break;case "REMOVE RANDOM":e=
+Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_RANDOM}if("FROM_START"==d||"FROM_END"==d)e+="  "+("FROM_START"==d?Blockly.Msg.LISTS_INDEX_FROM_START_TOOLTIP:Blockly.Msg.LISTS_INDEX_FROM_END_TOOLTIP).replace("%1",b.workspace.options.oneBasedIndex?"#1":"#0");return e})},mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("statement",!this.outputConnection);var b=this.getInput("AT").type==Blockly.INPUT_VALUE;a.setAttribute("at",b);return a},domToMutation:function(a){var b="true"==
+a.getAttribute("statement");this.updateStatement_(b);a="false"!=a.getAttribute("at");this.updateAt_(a)},updateStatement_:function(a){a!=!this.outputConnection&&(this.unplug(!0,!0),a?(this.setOutput(!1),this.setPreviousStatement(!0),this.setNextStatement(!0)):(this.setPreviousStatement(!1),this.setNextStatement(!1),this.setOutput(!0)))},updateAt_:function(a){this.removeInput("AT");this.removeInput("ORDINAL",!0);a?(this.appendValueInput("AT").setCheck("Number"),Blockly.Msg.ORDINAL_NUMBER_SUFFIX&&this.appendDummyInput("ORDINAL").appendField(Blockly.Msg.ORDINAL_NUMBER_SUFFIX)):
+this.appendDummyInput("AT");var b=new Blockly.FieldDropdown(this.WHERE_OPTIONS,function(b){var c="FROM_START"==b||"FROM_END"==b;if(c!=a){var e=this.sourceBlock_;e.updateAt_(c);e.setFieldValue(b,"WHERE");return null}});this.getInput("AT").appendField(b,"WHERE");Blockly.Msg.LISTS_GET_INDEX_TAIL&&this.moveInputBefore("TAIL",null)}};
+Blockly.Blocks.lists_setIndex={init:function(){var a=[[Blockly.Msg.LISTS_SET_INDEX_SET,"SET"],[Blockly.Msg.LISTS_SET_INDEX_INSERT,"INSERT"]];this.WHERE_OPTIONS=[[Blockly.Msg.LISTS_GET_INDEX_FROM_START,"FROM_START"],[Blockly.Msg.LISTS_GET_INDEX_FROM_END,"FROM_END"],[Blockly.Msg.LISTS_GET_INDEX_FIRST,"FIRST"],[Blockly.Msg.LISTS_GET_INDEX_LAST,"LAST"],[Blockly.Msg.LISTS_GET_INDEX_RANDOM,"RANDOM"]];this.setHelpUrl(Blockly.Msg.LISTS_SET_INDEX_HELPURL);this.setStyle("list_blocks");this.appendValueInput("LIST").setCheck("Array").appendField(Blockly.Msg.LISTS_SET_INDEX_INPUT_IN_LIST);
+this.appendDummyInput().appendField(new Blockly.FieldDropdown(a),"MODE").appendField("","SPACE");this.appendDummyInput("AT");this.appendValueInput("TO").appendField(Blockly.Msg.LISTS_SET_INDEX_INPUT_TO);this.setInputsInline(!0);this.setPreviousStatement(!0);this.setNextStatement(!0);this.setTooltip(Blockly.Msg.LISTS_SET_INDEX_TOOLTIP);this.updateAt_(!0);var b=this;this.setTooltip(function(){var a=b.getFieldValue("MODE"),d=b.getFieldValue("WHERE"),e="";switch(a+" "+d){case "SET FROM_START":case "SET FROM_END":e=
+Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_FROM;break;case "SET FIRST":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_FIRST;break;case "SET LAST":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_LAST;break;case "SET RANDOM":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_RANDOM;break;case "INSERT FROM_START":case "INSERT FROM_END":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_FROM;break;case "INSERT FIRST":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_FIRST;break;case "INSERT LAST":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_LAST;
+break;case "INSERT RANDOM":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_RANDOM}if("FROM_START"==d||"FROM_END"==d)e+="  "+Blockly.Msg.LISTS_INDEX_FROM_START_TOOLTIP.replace("%1",b.workspace.options.oneBasedIndex?"#1":"#0");return e})},mutationToDom:function(){var a=document.createElement("mutation"),b=this.getInput("AT").type==Blockly.INPUT_VALUE;a.setAttribute("at",b);return a},domToMutation:function(a){a="false"!=a.getAttribute("at");this.updateAt_(a)},updateAt_:function(a){this.removeInput("AT");
+this.removeInput("ORDINAL",!0);a?(this.appendValueInput("AT").setCheck("Number"),Blockly.Msg.ORDINAL_NUMBER_SUFFIX&&this.appendDummyInput("ORDINAL").appendField(Blockly.Msg.ORDINAL_NUMBER_SUFFIX)):this.appendDummyInput("AT");var b=new Blockly.FieldDropdown(this.WHERE_OPTIONS,function(b){var c="FROM_START"==b||"FROM_END"==b;if(c!=a){var e=this.sourceBlock_;e.updateAt_(c);e.setFieldValue(b,"WHERE");return null}});this.moveInputBefore("AT","TO");this.getInput("ORDINAL")&&this.moveInputBefore("ORDINAL",
+"TO");this.getInput("AT").appendField(b,"WHERE")}};
+Blockly.Blocks.lists_getSublist={init:function(){this.WHERE_OPTIONS_1=[[Blockly.Msg.LISTS_GET_SUBLIST_START_FROM_START,"FROM_START"],[Blockly.Msg.LISTS_GET_SUBLIST_START_FROM_END,"FROM_END"],[Blockly.Msg.LISTS_GET_SUBLIST_START_FIRST,"FIRST"]];this.WHERE_OPTIONS_2=[[Blockly.Msg.LISTS_GET_SUBLIST_END_FROM_START,"FROM_START"],[Blockly.Msg.LISTS_GET_SUBLIST_END_FROM_END,"FROM_END"],[Blockly.Msg.LISTS_GET_SUBLIST_END_LAST,"LAST"]];this.setHelpUrl(Blockly.Msg.LISTS_GET_SUBLIST_HELPURL);this.setStyle("list_blocks");
+this.appendValueInput("LIST").setCheck("Array").appendField(Blockly.Msg.LISTS_GET_SUBLIST_INPUT_IN_LIST);this.appendDummyInput("AT1");this.appendDummyInput("AT2");Blockly.Msg.LISTS_GET_SUBLIST_TAIL&&this.appendDummyInput("TAIL").appendField(Blockly.Msg.LISTS_GET_SUBLIST_TAIL);this.setInputsInline(!0);this.setOutput(!0,"Array");this.updateAt_(1,!0);this.updateAt_(2,!0);this.setTooltip(Blockly.Msg.LISTS_GET_SUBLIST_TOOLTIP)},mutationToDom:function(){var a=document.createElement("mutation"),b=this.getInput("AT1").type==
+Blockly.INPUT_VALUE;a.setAttribute("at1",b);b=this.getInput("AT2").type==Blockly.INPUT_VALUE;a.setAttribute("at2",b);return a},domToMutation:function(a){var b="true"==a.getAttribute("at1");a="true"==a.getAttribute("at2");this.updateAt_(1,b);this.updateAt_(2,a)},updateAt_:function(a,b){this.removeInput("AT"+a);this.removeInput("ORDINAL"+a,!0);b?(this.appendValueInput("AT"+a).setCheck("Number"),Blockly.Msg.ORDINAL_NUMBER_SUFFIX&&this.appendDummyInput("ORDINAL"+a).appendField(Blockly.Msg.ORDINAL_NUMBER_SUFFIX)):
+this.appendDummyInput("AT"+a);var c=new Blockly.FieldDropdown(this["WHERE_OPTIONS_"+a],function(c){var d="FROM_START"==c||"FROM_END"==c;if(d!=b){var f=this.sourceBlock_;f.updateAt_(a,d);f.setFieldValue(c,"WHERE"+a);return null}});this.getInput("AT"+a).appendField(c,"WHERE"+a);1==a&&(this.moveInputBefore("AT1","AT2"),this.getInput("ORDINAL1")&&this.moveInputBefore("ORDINAL1","AT2"));Blockly.Msg.LISTS_GET_SUBLIST_TAIL&&this.moveInputBefore("TAIL",null)}};
+Blockly.Blocks.lists_sort={init:function(){this.jsonInit({message0:Blockly.Msg.LISTS_SORT_TITLE,args0:[{type:"field_dropdown",name:"TYPE",options:[[Blockly.Msg.LISTS_SORT_TYPE_NUMERIC,"NUMERIC"],[Blockly.Msg.LISTS_SORT_TYPE_TEXT,"TEXT"],[Blockly.Msg.LISTS_SORT_TYPE_IGNORECASE,"IGNORE_CASE"]]},{type:"field_dropdown",name:"DIRECTION",options:[[Blockly.Msg.LISTS_SORT_ORDER_ASCENDING,"1"],[Blockly.Msg.LISTS_SORT_ORDER_DESCENDING,"-1"]]},{type:"input_value",name:"LIST",check:"Array"}],output:"Array",style:"list_blocks",
+tooltip:Blockly.Msg.LISTS_SORT_TOOLTIP,helpUrl:Blockly.Msg.LISTS_SORT_HELPURL})}};
+Blockly.Blocks.lists_split={init:function(){var a=this,b=new Blockly.FieldDropdown([[Blockly.Msg.LISTS_SPLIT_LIST_FROM_TEXT,"SPLIT"],[Blockly.Msg.LISTS_SPLIT_TEXT_FROM_LIST,"JOIN"]],function(b){a.updateType_(b)});this.setHelpUrl(Blockly.Msg.LISTS_SPLIT_HELPURL);this.setStyle("list_blocks");this.appendValueInput("INPUT").setCheck("String").appendField(b,"MODE");this.appendValueInput("DELIM").setCheck("String").appendField(Blockly.Msg.LISTS_SPLIT_WITH_DELIMITER);this.setInputsInline(!0);this.setOutput(!0,
+"Array");this.setTooltip(function(){var b=a.getFieldValue("MODE");if("SPLIT"==b)return Blockly.Msg.LISTS_SPLIT_TOOLTIP_SPLIT;if("JOIN"==b)return Blockly.Msg.LISTS_SPLIT_TOOLTIP_JOIN;throw Error("Unknown mode: "+b);})},updateType_:function(a){"SPLIT"==a?(this.outputConnection.setCheck("Array"),this.getInput("INPUT").setCheck("String")):(this.outputConnection.setCheck("String"),this.getInput("INPUT").setCheck("Array"))},mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("mode",
+this.getFieldValue("MODE"));return a},domToMutation:function(a){this.updateType_(a.getAttribute("mode"))}};Blockly.Blocks.logic={};Blockly.Constants.Logic={};Blockly.Constants.Logic.HUE=210;
+Blockly.defineBlocksWithJsonArray([{type:"logic_boolean",message0:"%1",args0:[{type:"field_dropdown",name:"BOOL",options:[["%{BKY_LOGIC_BOOLEAN_TRUE}","TRUE"],["%{BKY_LOGIC_BOOLEAN_FALSE}","FALSE"]]}],output:"Boolean",style:"logic_blocks",tooltip:"%{BKY_LOGIC_BOOLEAN_TOOLTIP}",helpUrl:"%{BKY_LOGIC_BOOLEAN_HELPURL}"},{type:"controls_if",message0:"%{BKY_CONTROLS_IF_MSG_IF} %1",args0:[{type:"input_value",name:"IF0",check:"Boolean"}],message1:"%{BKY_CONTROLS_IF_MSG_THEN} %1",args1:[{type:"input_statement",
+name:"DO0"}],previousStatement:null,nextStatement:null,style:"logic_blocks",helpUrl:"%{BKY_CONTROLS_IF_HELPURL}",mutator:"controls_if_mutator",extensions:["controls_if_tooltip"]},{type:"controls_ifelse",message0:"%{BKY_CONTROLS_IF_MSG_IF} %1",args0:[{type:"input_value",name:"IF0",check:"Boolean"}],message1:"%{BKY_CONTROLS_IF_MSG_THEN} %1",args1:[{type:"input_statement",name:"DO0"}],message2:"%{BKY_CONTROLS_IF_MSG_ELSE} %1",args2:[{type:"input_statement",name:"ELSE"}],previousStatement:null,nextStatement:null,
+style:"logic_blocks",tooltip:"%{BKYCONTROLS_IF_TOOLTIP_2}",helpUrl:"%{BKY_CONTROLS_IF_HELPURL}",extensions:["controls_if_tooltip"]},{type:"logic_compare",message0:"%1 %2 %3",args0:[{type:"input_value",name:"A"},{type:"field_dropdown",name:"OP",options:[["=","EQ"],["\u2260","NEQ"],["\u200f<","LT"],["\u200f\u2264","LTE"],["\u200f>","GT"],["\u200f\u2265","GTE"]]},{type:"input_value",name:"B"}],inputsInline:!0,output:"Boolean",style:"logic_blocks",helpUrl:"%{BKY_LOGIC_COMPARE_HELPURL}",extensions:["logic_compare",
+"logic_op_tooltip"]},{type:"logic_operation",message0:"%1 %2 %3",args0:[{type:"input_value",name:"A",check:"Boolean"},{type:"field_dropdown",name:"OP",options:[["%{BKY_LOGIC_OPERATION_AND}","AND"],["%{BKY_LOGIC_OPERATION_OR}","OR"]]},{type:"input_value",name:"B",check:"Boolean"}],inputsInline:!0,output:"Boolean",style:"logic_blocks",helpUrl:"%{BKY_LOGIC_OPERATION_HELPURL}",extensions:["logic_op_tooltip"]},{type:"logic_negate",message0:"%{BKY_LOGIC_NEGATE_TITLE}",args0:[{type:"input_value",name:"BOOL",
+check:"Boolean"}],output:"Boolean",style:"logic_blocks",tooltip:"%{BKY_LOGIC_NEGATE_TOOLTIP}",helpUrl:"%{BKY_LOGIC_NEGATE_HELPURL}"},{type:"logic_null",message0:"%{BKY_LOGIC_NULL}",output:null,style:"logic_blocks",tooltip:"%{BKY_LOGIC_NULL_TOOLTIP}",helpUrl:"%{BKY_LOGIC_NULL_HELPURL}"},{type:"logic_ternary",message0:"%{BKY_LOGIC_TERNARY_CONDITION} %1",args0:[{type:"input_value",name:"IF",check:"Boolean"}],message1:"%{BKY_LOGIC_TERNARY_IF_TRUE} %1",args1:[{type:"input_value",name:"THEN"}],message2:"%{BKY_LOGIC_TERNARY_IF_FALSE} %1",
+args2:[{type:"input_value",name:"ELSE"}],output:null,style:"logic_blocks",tooltip:"%{BKY_LOGIC_TERNARY_TOOLTIP}",helpUrl:"%{BKY_LOGIC_TERNARY_HELPURL}",extensions:["logic_ternary"]}]);
+Blockly.defineBlocksWithJsonArray([{type:"controls_if_if",message0:"%{BKY_CONTROLS_IF_IF_TITLE_IF}",nextStatement:null,enableContextMenu:!1,style:"logic_blocks",tooltip:"%{BKY_CONTROLS_IF_IF_TOOLTIP}"},{type:"controls_if_elseif",message0:"%{BKY_CONTROLS_IF_ELSEIF_TITLE_ELSEIF}",previousStatement:null,nextStatement:null,enableContextMenu:!1,style:"logic_blocks",tooltip:"%{BKY_CONTROLS_IF_ELSEIF_TOOLTIP}"},{type:"controls_if_else",message0:"%{BKY_CONTROLS_IF_ELSE_TITLE_ELSE}",previousStatement:null,
+enableContextMenu:!1,style:"logic_blocks",tooltip:"%{BKY_CONTROLS_IF_ELSE_TOOLTIP}"}]);Blockly.Constants.Logic.TOOLTIPS_BY_OP={EQ:"%{BKY_LOGIC_COMPARE_TOOLTIP_EQ}",NEQ:"%{BKY_LOGIC_COMPARE_TOOLTIP_NEQ}",LT:"%{BKY_LOGIC_COMPARE_TOOLTIP_LT}",LTE:"%{BKY_LOGIC_COMPARE_TOOLTIP_LTE}",GT:"%{BKY_LOGIC_COMPARE_TOOLTIP_GT}",GTE:"%{BKY_LOGIC_COMPARE_TOOLTIP_GTE}",AND:"%{BKY_LOGIC_OPERATION_TOOLTIP_AND}",OR:"%{BKY_LOGIC_OPERATION_TOOLTIP_OR}"};
+Blockly.Extensions.register("logic_op_tooltip",Blockly.Extensions.buildTooltipForDropdown("OP",Blockly.Constants.Logic.TOOLTIPS_BY_OP));
+Blockly.Constants.Logic.CONTROLS_IF_MUTATOR_MIXIN={elseifCount_:0,elseCount_:0,mutationToDom:function(){if(!this.elseifCount_&&!this.elseCount_)return null;var a=document.createElement("mutation");this.elseifCount_&&a.setAttribute("elseif",this.elseifCount_);this.elseCount_&&a.setAttribute("else",1);return a},domToMutation:function(a){this.elseifCount_=parseInt(a.getAttribute("elseif"),10)||0;this.elseCount_=parseInt(a.getAttribute("else"),10)||0;this.rebuildShape_()},decompose:function(a){var b=
+a.newBlock("controls_if_if");b.initSvg();for(var c=b.nextConnection,d=1;d<=this.elseifCount_;d++){var e=a.newBlock("controls_if_elseif");e.initSvg();c.connect(e.previousConnection);c=e.nextConnection}this.elseCount_&&(a=a.newBlock("controls_if_else"),a.initSvg(),c.connect(a.previousConnection));return b},compose:function(a){a=a.nextConnection.targetBlock();this.elseCount_=this.elseifCount_=0;for(var b=[null],c=[null],d=null;a;){switch(a.type){case "controls_if_elseif":this.elseifCount_++;b.push(a.valueConnection_);
+c.push(a.statementConnection_);break;case "controls_if_else":this.elseCount_++;d=a.statementConnection_;break;default:throw TypeError("Unknown block type: "+a.type);}a=a.nextConnection&&a.nextConnection.targetBlock()}this.updateShape_();this.reconnectChildBlocks_(b,c,d)},saveConnections:function(a){a=a.nextConnection.targetBlock();for(var b=1;a;){switch(a.type){case "controls_if_elseif":var c=this.getInput("IF"+b),d=this.getInput("DO"+b);a.valueConnection_=c&&c.connection.targetConnection;a.statementConnection_=
+d&&d.connection.targetConnection;b++;break;case "controls_if_else":d=this.getInput("ELSE");a.statementConnection_=d&&d.connection.targetConnection;break;default:throw TypeError("Unknown block type: "+a.type);}a=a.nextConnection&&a.nextConnection.targetBlock()}},rebuildShape_:function(){var a=[null],b=[null],c=null;this.getInput("ELSE")&&(c=this.getInput("ELSE").connection.targetConnection);for(var d=1;this.getInput("IF"+d);){var e=this.getInput("IF"+d),f=this.getInput("DO"+d);a.push(e.connection.targetConnection);
+b.push(f.connection.targetConnection);d++}this.updateShape_();this.reconnectChildBlocks_(a,b,c)},updateShape_:function(){this.getInput("ELSE")&&this.removeInput("ELSE");for(var a=1;this.getInput("IF"+a);)this.removeInput("IF"+a),this.removeInput("DO"+a),a++;for(a=1;a<=this.elseifCount_;a++)this.appendValueInput("IF"+a).setCheck("Boolean").appendField(Blockly.Msg.CONTROLS_IF_MSG_ELSEIF),this.appendStatementInput("DO"+a).appendField(Blockly.Msg.CONTROLS_IF_MSG_THEN);this.elseCount_&&this.appendStatementInput("ELSE").appendField(Blockly.Msg.CONTROLS_IF_MSG_ELSE)},
+reconnectChildBlocks_:function(a,b,c){for(var d=1;d<=this.elseifCount_;d++)Blockly.Mutator.reconnect(a[d],this,"IF"+d),Blockly.Mutator.reconnect(b[d],this,"DO"+d);Blockly.Mutator.reconnect(c,this,"ELSE")}};Blockly.Extensions.registerMutator("controls_if_mutator",Blockly.Constants.Logic.CONTROLS_IF_MUTATOR_MIXIN,null,["controls_if_elseif","controls_if_else"]);
+Blockly.Constants.Logic.CONTROLS_IF_TOOLTIP_EXTENSION=function(){this.setTooltip(function(){if(this.elseifCount_||this.elseCount_){if(!this.elseifCount_&&this.elseCount_)return Blockly.Msg.CONTROLS_IF_TOOLTIP_2;if(this.elseifCount_&&!this.elseCount_)return Blockly.Msg.CONTROLS_IF_TOOLTIP_3;if(this.elseifCount_&&this.elseCount_)return Blockly.Msg.CONTROLS_IF_TOOLTIP_4}else return Blockly.Msg.CONTROLS_IF_TOOLTIP_1;return""}.bind(this))};Blockly.Extensions.register("controls_if_tooltip",Blockly.Constants.Logic.CONTROLS_IF_TOOLTIP_EXTENSION);
+Blockly.Constants.Logic.LOGIC_COMPARE_ONCHANGE_MIXIN={onchange:function(a){this.prevBlocks_||(this.prevBlocks_=[null,null]);var b=this.getInputTargetBlock("A"),c=this.getInputTargetBlock("B");b&&c&&!b.outputConnection.checkType_(c.outputConnection)&&(Blockly.Events.setGroup(a.group),a=this.prevBlocks_[0],a!==b&&(b.unplug(),a&&!a.isShadow()&&this.getInput("A").connection.connect(a.outputConnection)),b=this.prevBlocks_[1],b!==c&&(c.unplug(),b&&!b.isShadow()&&this.getInput("B").connection.connect(b.outputConnection)),
+this.bumpNeighbours_(),Blockly.Events.setGroup(!1));this.prevBlocks_[0]=this.getInputTargetBlock("A");this.prevBlocks_[1]=this.getInputTargetBlock("B")}};Blockly.Constants.Logic.LOGIC_COMPARE_EXTENSION=function(){this.mixin(Blockly.Constants.Logic.LOGIC_COMPARE_ONCHANGE_MIXIN)};Blockly.Extensions.register("logic_compare",Blockly.Constants.Logic.LOGIC_COMPARE_EXTENSION);
+Blockly.Constants.Logic.LOGIC_TERNARY_ONCHANGE_MIXIN={prevParentConnection_:null,onchange:function(a){var b=this.getInputTargetBlock("THEN"),c=this.getInputTargetBlock("ELSE"),d=this.outputConnection.targetConnection;if((b||c)&&d)for(var e=0;2>e;e++){var f=1==e?b:c;f&&!f.outputConnection.checkType_(d)&&(Blockly.Events.setGroup(a.group),d===this.prevParentConnection_?(this.unplug(),d.getSourceBlock().bumpNeighbours_()):(f.unplug(),f.bumpNeighbours_()),Blockly.Events.setGroup(!1))}this.prevParentConnection_=
+d}};Blockly.Extensions.registerMixin("logic_ternary",Blockly.Constants.Logic.LOGIC_TERNARY_ONCHANGE_MIXIN);Blockly.Blocks.loops={};Blockly.Constants.Loops={};Blockly.Constants.Loops.HUE=120;
+Blockly.defineBlocksWithJsonArray([{type:"controls_repeat_ext",message0:"%{BKY_CONTROLS_REPEAT_TITLE}",args0:[{type:"input_value",name:"TIMES",check:"Number"}],message1:"%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",args1:[{type:"input_statement",name:"DO"}],previousStatement:null,nextStatement:null,style:"loop_blocks",tooltip:"%{BKY_CONTROLS_REPEAT_TOOLTIP}",helpUrl:"%{BKY_CONTROLS_REPEAT_HELPURL}"},{type:"controls_repeat",message0:"%{BKY_CONTROLS_REPEAT_TITLE}",args0:[{type:"field_number",name:"TIMES",value:10,
+min:0,precision:1}],message1:"%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",args1:[{type:"input_statement",name:"DO"}],previousStatement:null,nextStatement:null,style:"loop_blocks",tooltip:"%{BKY_CONTROLS_REPEAT_TOOLTIP}",helpUrl:"%{BKY_CONTROLS_REPEAT_HELPURL}"},{type:"controls_whileUntil",message0:"%1 %2",args0:[{type:"field_dropdown",name:"MODE",options:[["%{BKY_CONTROLS_WHILEUNTIL_OPERATOR_WHILE}","WHILE"],["%{BKY_CONTROLS_WHILEUNTIL_OPERATOR_UNTIL}","UNTIL"]]},{type:"input_value",name:"BOOL",check:"Boolean"}],
+message1:"%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",args1:[{type:"input_statement",name:"DO"}],previousStatement:null,nextStatement:null,style:"loop_blocks",helpUrl:"%{BKY_CONTROLS_WHILEUNTIL_HELPURL}",extensions:["controls_whileUntil_tooltip"]},{type:"controls_for",message0:"%{BKY_CONTROLS_FOR_TITLE}",args0:[{type:"field_variable",name:"VAR",variable:null},{type:"input_value",name:"FROM",check:"Number",align:"RIGHT"},{type:"input_value",name:"TO",check:"Number",align:"RIGHT"},{type:"input_value",name:"BY",
+check:"Number",align:"RIGHT"}],message1:"%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",args1:[{type:"input_statement",name:"DO"}],inputsInline:!0,previousStatement:null,nextStatement:null,style:"loop_blocks",helpUrl:"%{BKY_CONTROLS_FOR_HELPURL}",extensions:["contextMenu_newGetVariableBlock","controls_for_tooltip"]},{type:"controls_forEach",message0:"%{BKY_CONTROLS_FOREACH_TITLE}",args0:[{type:"field_variable",name:"VAR",variable:null},{type:"input_value",name:"LIST",check:"Array"}],message1:"%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",
+args1:[{type:"input_statement",name:"DO"}],previousStatement:null,nextStatement:null,style:"loop_blocks",helpUrl:"%{BKY_CONTROLS_FOREACH_HELPURL}",extensions:["contextMenu_newGetVariableBlock","controls_forEach_tooltip"]},{type:"controls_flow_statements",message0:"%1",args0:[{type:"field_dropdown",name:"FLOW",options:[["%{BKY_CONTROLS_FLOW_STATEMENTS_OPERATOR_BREAK}","BREAK"],["%{BKY_CONTROLS_FLOW_STATEMENTS_OPERATOR_CONTINUE}","CONTINUE"]]}],previousStatement:null,style:"loop_blocks",helpUrl:"%{BKY_CONTROLS_FLOW_STATEMENTS_HELPURL}",
+extensions:["controls_flow_tooltip","controls_flow_in_loop_check"]}]);Blockly.Constants.Loops.WHILE_UNTIL_TOOLTIPS={WHILE:"%{BKY_CONTROLS_WHILEUNTIL_TOOLTIP_WHILE}",UNTIL:"%{BKY_CONTROLS_WHILEUNTIL_TOOLTIP_UNTIL}"};Blockly.Extensions.register("controls_whileUntil_tooltip",Blockly.Extensions.buildTooltipForDropdown("MODE",Blockly.Constants.Loops.WHILE_UNTIL_TOOLTIPS));Blockly.Constants.Loops.BREAK_CONTINUE_TOOLTIPS={BREAK:"%{BKY_CONTROLS_FLOW_STATEMENTS_TOOLTIP_BREAK}",CONTINUE:"%{BKY_CONTROLS_FLOW_STATEMENTS_TOOLTIP_CONTINUE}"};
+Blockly.Extensions.register("controls_flow_tooltip",Blockly.Extensions.buildTooltipForDropdown("FLOW",Blockly.Constants.Loops.BREAK_CONTINUE_TOOLTIPS));
+Blockly.Constants.Loops.CUSTOM_CONTEXT_MENU_CREATE_VARIABLES_GET_MIXIN={customContextMenu:function(a){if(!this.isInFlyout){var b=this.getField("VAR").getVariable(),c=b.name;if(!this.isCollapsed()&&null!=c){var d={enabled:!0};d.text=Blockly.Msg.VARIABLES_SET_CREATE_GET.replace("%1",c);b=Blockly.Variables.generateVariableFieldDom(b);c=document.createElement("block");c.setAttribute("type","variables_get");c.appendChild(b);d.callback=Blockly.ContextMenu.callbackFactory(this,c);a.push(d)}}}};
+Blockly.Extensions.registerMixin("contextMenu_newGetVariableBlock",Blockly.Constants.Loops.CUSTOM_CONTEXT_MENU_CREATE_VARIABLES_GET_MIXIN);Blockly.Extensions.register("controls_for_tooltip",Blockly.Extensions.buildTooltipWithFieldText("%{BKY_CONTROLS_FOR_TOOLTIP}","VAR"));Blockly.Extensions.register("controls_forEach_tooltip",Blockly.Extensions.buildTooltipWithFieldText("%{BKY_CONTROLS_FOREACH_TOOLTIP}","VAR"));
+Blockly.Constants.Loops.CONTROL_FLOW_IN_LOOP_CHECK_MIXIN={LOOP_TYPES:["controls_repeat","controls_repeat_ext","controls_forEach","controls_for","controls_whileUntil"],onchange:function(){if(this.workspace.isDragging&&!this.workspace.isDragging()){var a=!1,b=this;do{if(-1!=this.LOOP_TYPES.indexOf(b.type)){a=!0;break}b=b.getSurroundParent()}while(b);a?(this.setWarningText(null),this.isInFlyout||this.setDisabled(!1)):(this.setWarningText(Blockly.Msg.CONTROLS_FLOW_STATEMENTS_WARNING),this.isInFlyout||
+this.getInheritedDisabled()||this.setDisabled(!0))}}};Blockly.Extensions.registerMixin("controls_flow_in_loop_check",Blockly.Constants.Loops.CONTROL_FLOW_IN_LOOP_CHECK_MIXIN);Blockly.Blocks.math={};Blockly.Constants.Math={};Blockly.Constants.Math.HUE=230;
+Blockly.defineBlocksWithJsonArray([{type:"math_number",message0:"%1",args0:[{type:"field_number",name:"NUM",value:0}],output:"Number",helpUrl:"%{BKY_MATH_NUMBER_HELPURL}",style:"math_blocks",tooltip:"%{BKY_MATH_NUMBER_TOOLTIP}",extensions:["parent_tooltip_when_inline"]},{type:"math_arithmetic",message0:"%1 %2 %3",args0:[{type:"input_value",name:"A",check:"Number"},{type:"field_dropdown",name:"OP",options:[["%{BKY_MATH_ADDITION_SYMBOL}","ADD"],["%{BKY_MATH_SUBTRACTION_SYMBOL}","MINUS"],["%{BKY_MATH_MULTIPLICATION_SYMBOL}",
+"MULTIPLY"],["%{BKY_MATH_DIVISION_SYMBOL}","DIVIDE"],["%{BKY_MATH_POWER_SYMBOL}","POWER"]]},{type:"input_value",name:"B",check:"Number"}],inputsInline:!0,output:"Number",style:"math_blocks",helpUrl:"%{BKY_MATH_ARITHMETIC_HELPURL}",extensions:["math_op_tooltip"]},{type:"math_single",message0:"%1 %2",args0:[{type:"field_dropdown",name:"OP",options:[["%{BKY_MATH_SINGLE_OP_ROOT}","ROOT"],["%{BKY_MATH_SINGLE_OP_ABSOLUTE}","ABS"],["-","NEG"],["ln","LN"],["log10","LOG10"],["e^","EXP"],["10^","POW10"]]},
+{type:"input_value",name:"NUM",check:"Number"}],output:"Number",style:"math_blocks",helpUrl:"%{BKY_MATH_SINGLE_HELPURL}",extensions:["math_op_tooltip"]},{type:"math_trig",message0:"%1 %2",args0:[{type:"field_dropdown",name:"OP",options:[["%{BKY_MATH_TRIG_SIN}","SIN"],["%{BKY_MATH_TRIG_COS}","COS"],["%{BKY_MATH_TRIG_TAN}","TAN"],["%{BKY_MATH_TRIG_ASIN}","ASIN"],["%{BKY_MATH_TRIG_ACOS}","ACOS"],["%{BKY_MATH_TRIG_ATAN}","ATAN"]]},{type:"input_value",name:"NUM",check:"Number"}],output:"Number",style:"math_blocks",
+helpUrl:"%{BKY_MATH_TRIG_HELPURL}",extensions:["math_op_tooltip"]},{type:"math_constant",message0:"%1",args0:[{type:"field_dropdown",name:"CONSTANT",options:[["\u03c0","PI"],["e","E"],["\u03c6","GOLDEN_RATIO"],["sqrt(2)","SQRT2"],["sqrt(\u00bd)","SQRT1_2"],["\u221e","INFINITY"]]}],output:"Number",style:"math_blocks",tooltip:"%{BKY_MATH_CONSTANT_TOOLTIP}",helpUrl:"%{BKY_MATH_CONSTANT_HELPURL}"},{type:"math_number_property",message0:"%1 %2",args0:[{type:"input_value",name:"NUMBER_TO_CHECK",check:"Number"},
+{type:"field_dropdown",name:"PROPERTY",options:[["%{BKY_MATH_IS_EVEN}","EVEN"],["%{BKY_MATH_IS_ODD}","ODD"],["%{BKY_MATH_IS_PRIME}","PRIME"],["%{BKY_MATH_IS_WHOLE}","WHOLE"],["%{BKY_MATH_IS_POSITIVE}","POSITIVE"],["%{BKY_MATH_IS_NEGATIVE}","NEGATIVE"],["%{BKY_MATH_IS_DIVISIBLE_BY}","DIVISIBLE_BY"]]}],inputsInline:!0,output:"Boolean",style:"math_blocks",tooltip:"%{BKY_MATH_IS_TOOLTIP}",mutator:"math_is_divisibleby_mutator"},{type:"math_change",message0:"%{BKY_MATH_CHANGE_TITLE}",args0:[{type:"field_variable",
+name:"VAR",variable:"%{BKY_MATH_CHANGE_TITLE_ITEM}"},{type:"input_value",name:"DELTA",check:"Number"}],previousStatement:null,nextStatement:null,style:"variable_blocks",helpUrl:"%{BKY_MATH_CHANGE_HELPURL}",extensions:["math_change_tooltip"]},{type:"math_round",message0:"%1 %2",args0:[{type:"field_dropdown",name:"OP",options:[["%{BKY_MATH_ROUND_OPERATOR_ROUND}","ROUND"],["%{BKY_MATH_ROUND_OPERATOR_ROUNDUP}","ROUNDUP"],["%{BKY_MATH_ROUND_OPERATOR_ROUNDDOWN}","ROUNDDOWN"]]},{type:"input_value",name:"NUM",
+check:"Number"}],output:"Number",style:"math_blocks",helpUrl:"%{BKY_MATH_ROUND_HELPURL}",tooltip:"%{BKY_MATH_ROUND_TOOLTIP}"},{type:"math_on_list",message0:"%1 %2",args0:[{type:"field_dropdown",name:"OP",options:[["%{BKY_MATH_ONLIST_OPERATOR_SUM}","SUM"],["%{BKY_MATH_ONLIST_OPERATOR_MIN}","MIN"],["%{BKY_MATH_ONLIST_OPERATOR_MAX}","MAX"],["%{BKY_MATH_ONLIST_OPERATOR_AVERAGE}","AVERAGE"],["%{BKY_MATH_ONLIST_OPERATOR_MEDIAN}","MEDIAN"],["%{BKY_MATH_ONLIST_OPERATOR_MODE}","MODE"],["%{BKY_MATH_ONLIST_OPERATOR_STD_DEV}",
+"STD_DEV"],["%{BKY_MATH_ONLIST_OPERATOR_RANDOM}","RANDOM"]]},{type:"input_value",name:"LIST",check:"Array"}],output:"Number",style:"math_blocks",helpUrl:"%{BKY_MATH_ONLIST_HELPURL}",mutator:"math_modes_of_list_mutator",extensions:["math_op_tooltip"]},{type:"math_modulo",message0:"%{BKY_MATH_MODULO_TITLE}",args0:[{type:"input_value",name:"DIVIDEND",check:"Number"},{type:"input_value",name:"DIVISOR",check:"Number"}],inputsInline:!0,output:"Number",style:"math_blocks",tooltip:"%{BKY_MATH_MODULO_TOOLTIP}",
+helpUrl:"%{BKY_MATH_MODULO_HELPURL}"},{type:"math_constrain",message0:"%{BKY_MATH_CONSTRAIN_TITLE}",args0:[{type:"input_value",name:"VALUE",check:"Number"},{type:"input_value",name:"LOW",check:"Number"},{type:"input_value",name:"HIGH",check:"Number"}],inputsInline:!0,output:"Number",style:"math_blocks",tooltip:"%{BKY_MATH_CONSTRAIN_TOOLTIP}",helpUrl:"%{BKY_MATH_CONSTRAIN_HELPURL}"},{type:"math_random_int",message0:"%{BKY_MATH_RANDOM_INT_TITLE}",args0:[{type:"input_value",name:"FROM",check:"Number"},
+{type:"input_value",name:"TO",check:"Number"}],inputsInline:!0,output:"Number",style:"math_blocks",tooltip:"%{BKY_MATH_RANDOM_INT_TOOLTIP}",helpUrl:"%{BKY_MATH_RANDOM_INT_HELPURL}"},{type:"math_random_float",message0:"%{BKY_MATH_RANDOM_FLOAT_TITLE_RANDOM}",output:"Number",style:"math_blocks",tooltip:"%{BKY_MATH_RANDOM_FLOAT_TOOLTIP}",helpUrl:"%{BKY_MATH_RANDOM_FLOAT_HELPURL}"},{type:"math_atan2",message0:"%{BKY_MATH_ATAN2_TITLE}",args0:[{type:"input_value",name:"X",check:"Number"},{type:"input_value",
+name:"Y",check:"Number"}],inputsInline:!0,output:"Number",style:"math_blocks",tooltip:"%{BKY_MATH_ATAN2_TOOLTIP}",helpUrl:"%{BKY_MATH_ATAN2_HELPURL}"}]);
+Blockly.Constants.Math.TOOLTIPS_BY_OP={ADD:"%{BKY_MATH_ARITHMETIC_TOOLTIP_ADD}",MINUS:"%{BKY_MATH_ARITHMETIC_TOOLTIP_MINUS}",MULTIPLY:"%{BKY_MATH_ARITHMETIC_TOOLTIP_MULTIPLY}",DIVIDE:"%{BKY_MATH_ARITHMETIC_TOOLTIP_DIVIDE}",POWER:"%{BKY_MATH_ARITHMETIC_TOOLTIP_POWER}",ROOT:"%{BKY_MATH_SINGLE_TOOLTIP_ROOT}",ABS:"%{BKY_MATH_SINGLE_TOOLTIP_ABS}",NEG:"%{BKY_MATH_SINGLE_TOOLTIP_NEG}",LN:"%{BKY_MATH_SINGLE_TOOLTIP_LN}",LOG10:"%{BKY_MATH_SINGLE_TOOLTIP_LOG10}",EXP:"%{BKY_MATH_SINGLE_TOOLTIP_EXP}",POW10:"%{BKY_MATH_SINGLE_TOOLTIP_POW10}",
+SIN:"%{BKY_MATH_TRIG_TOOLTIP_SIN}",COS:"%{BKY_MATH_TRIG_TOOLTIP_COS}",TAN:"%{BKY_MATH_TRIG_TOOLTIP_TAN}",ASIN:"%{BKY_MATH_TRIG_TOOLTIP_ASIN}",ACOS:"%{BKY_MATH_TRIG_TOOLTIP_ACOS}",ATAN:"%{BKY_MATH_TRIG_TOOLTIP_ATAN}",SUM:"%{BKY_MATH_ONLIST_TOOLTIP_SUM}",MIN:"%{BKY_MATH_ONLIST_TOOLTIP_MIN}",MAX:"%{BKY_MATH_ONLIST_TOOLTIP_MAX}",AVERAGE:"%{BKY_MATH_ONLIST_TOOLTIP_AVERAGE}",MEDIAN:"%{BKY_MATH_ONLIST_TOOLTIP_MEDIAN}",MODE:"%{BKY_MATH_ONLIST_TOOLTIP_MODE}",STD_DEV:"%{BKY_MATH_ONLIST_TOOLTIP_STD_DEV}",RANDOM:"%{BKY_MATH_ONLIST_TOOLTIP_RANDOM}"};
+Blockly.Extensions.register("math_op_tooltip",Blockly.Extensions.buildTooltipForDropdown("OP",Blockly.Constants.Math.TOOLTIPS_BY_OP));
+Blockly.Constants.Math.IS_DIVISIBLEBY_MUTATOR_MIXIN={mutationToDom:function(){var a=document.createElement("mutation"),b="DIVISIBLE_BY"==this.getFieldValue("PROPERTY");a.setAttribute("divisor_input",b);return a},domToMutation:function(a){a="true"==a.getAttribute("divisor_input");this.updateShape_(a)},updateShape_:function(a){var b=this.getInput("DIVISOR");a?b||this.appendValueInput("DIVISOR").setCheck("Number"):b&&this.removeInput("DIVISOR")}};
+Blockly.Constants.Math.IS_DIVISIBLE_MUTATOR_EXTENSION=function(){this.getField("PROPERTY").setValidator(function(a){this.sourceBlock_.updateShape_("DIVISIBLE_BY"==a)})};Blockly.Extensions.registerMutator("math_is_divisibleby_mutator",Blockly.Constants.Math.IS_DIVISIBLEBY_MUTATOR_MIXIN,Blockly.Constants.Math.IS_DIVISIBLE_MUTATOR_EXTENSION);Blockly.Extensions.register("math_change_tooltip",Blockly.Extensions.buildTooltipWithFieldText("%{BKY_MATH_CHANGE_TOOLTIP}","VAR"));
+Blockly.Constants.Math.LIST_MODES_MUTATOR_MIXIN={updateType_:function(a){"MODE"==a?this.outputConnection.setCheck("Array"):this.outputConnection.setCheck("Number")},mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("op",this.getFieldValue("OP"));return a},domToMutation:function(a){this.updateType_(a.getAttribute("op"))}};Blockly.Constants.Math.LIST_MODES_MUTATOR_EXTENSION=function(){this.getField("OP").setValidator(function(a){this.updateType_(a)}.bind(this))};
+Blockly.Extensions.registerMutator("math_modes_of_list_mutator",Blockly.Constants.Math.LIST_MODES_MUTATOR_MIXIN,Blockly.Constants.Math.LIST_MODES_MUTATOR_EXTENSION);Blockly.Blocks.procedures={};
+Blockly.Blocks.procedures_defnoreturn={init:function(){var a=new Blockly.FieldTextInput("",Blockly.Procedures.rename);a.setSpellcheck(!1);this.appendDummyInput().appendField(Blockly.Msg.PROCEDURES_DEFNORETURN_TITLE).appendField(a,"NAME").appendField("","PARAMS");this.setMutator(new Blockly.Mutator(["procedures_mutatorarg"]));(this.workspace.options.comments||this.workspace.options.parentWorkspace&&this.workspace.options.parentWorkspace.options.comments)&&Blockly.Msg.PROCEDURES_DEFNORETURN_COMMENT&&this.setCommentText(Blockly.Msg.PROCEDURES_DEFNORETURN_COMMENT);
+this.setStyle("procedure_blocks");this.setTooltip(Blockly.Msg.PROCEDURES_DEFNORETURN_TOOLTIP);this.setHelpUrl(Blockly.Msg.PROCEDURES_DEFNORETURN_HELPURL);this.arguments_=[];this.argumentVarModels_=[];this.setStatements_(!0);this.statementConnection_=null},setStatements_:function(a){this.hasStatements_!==a&&(a?(this.appendStatementInput("STACK").appendField(Blockly.Msg.PROCEDURES_DEFNORETURN_DO),this.getInput("RETURN")&&this.moveInputBefore("STACK","RETURN")):this.removeInput("STACK",!0),this.hasStatements_=
+a)},updateParams_:function(){var a="";this.arguments_.length&&(a=Blockly.Msg.PROCEDURES_BEFORE_PARAMS+" "+this.arguments_.join(", "));Blockly.Events.disable();try{this.setFieldValue(a,"PARAMS")}finally{Blockly.Events.enable()}},mutationToDom:function(a){var b=document.createElement("mutation");a&&b.setAttribute("name",this.getFieldValue("NAME"));for(var c=0;c<this.argumentVarModels_.length;c++){var d=document.createElement("arg"),e=this.argumentVarModels_[c];d.setAttribute("name",e.name);d.setAttribute("varid",
+e.getId());a&&this.paramIds_&&d.setAttribute("paramId",this.paramIds_[c]);b.appendChild(d)}this.hasStatements_||b.setAttribute("statements","false");return b},domToMutation:function(a){this.arguments_=[];this.argumentVarModels_=[];for(var b=0,c;c=a.childNodes[b];b++)if("arg"==c.nodeName.toLowerCase()){var d=c.getAttribute("name");c=c.getAttribute("varid")||c.getAttribute("varId");this.arguments_.push(d);c=Blockly.Variables.getOrCreateVariablePackage(this.workspace,c,d,"");null!=c?this.argumentVarModels_.push(c):
+console.log("Failed to create a variable with name "+d+", ignoring.")}this.updateParams_();Blockly.Procedures.mutateCallers(this);this.setStatements_("false"!==a.getAttribute("statements"))},decompose:function(a){var b=a.newBlock("procedures_mutatorcontainer");b.initSvg();this.getInput("RETURN")?b.setFieldValue(this.hasStatements_?"TRUE":"FALSE","STATEMENTS"):b.getInput("STATEMENT_INPUT").setVisible(!1);for(var c=b.getInput("STACK").connection,d=0;d<this.arguments_.length;d++){var e=a.newBlock("procedures_mutatorarg");
+e.initSvg();e.setFieldValue(this.arguments_[d],"NAME");e.oldLocation=d;c.connect(e.previousConnection);c=e.nextConnection}Blockly.Procedures.mutateCallers(this);return b},compose:function(a){this.arguments_=[];this.paramIds_=[];this.argumentVarModels_=[];for(var b=a.getInputTargetBlock("STACK");b;){var c=b.getFieldValue("NAME");this.arguments_.push(c);var d=this.workspace.getVariable(c,"");null!=d?this.argumentVarModels_.push(d):console.log("Failed to get variable named "+c+", ignoring.");this.paramIds_.push(b.id);
+b=b.nextConnection&&b.nextConnection.targetBlock()}this.updateParams_();Blockly.Procedures.mutateCallers(this);a=a.getFieldValue("STATEMENTS");if(null!==a&&(a="TRUE"==a,this.hasStatements_!=a))if(a)this.setStatements_(!0),Blockly.Mutator.reconnect(this.statementConnection_,this,"STACK"),this.statementConnection_=null;else{a=this.getInput("STACK").connection;if(this.statementConnection_=a.targetConnection)a=a.targetBlock(),a.unplug(),a.bumpNeighbours_();this.setStatements_(!1)}},getProcedureDef:function(){return[this.getFieldValue("NAME"),
+this.arguments_,!1]},getVars:function(){return this.arguments_},getVarModels:function(){return this.argumentVarModels_},renameVarById:function(a,b){var c=this.workspace.getVariableById(a);if(""==c.type){c=c.name;for(var d=this.workspace.getVariableById(b),e=!1,f=0;f<this.argumentVarModels_.length;f++)this.argumentVarModels_[f].getId()==a&&(this.arguments_[f]=d.name,this.argumentVarModels_[f]=d,e=!0);e&&(this.displayRenamedVar_(c,d.name),Blockly.Procedures.mutateCallers(this))}},updateVarName:function(a){for(var b=
+a.name,c=!1,d=0;d<this.argumentVarModels_.length;d++)if(this.argumentVarModels_[d].getId()==a.getId()){var e=this.arguments_[d];this.arguments_[d]=b;c=!0}c&&(this.displayRenamedVar_(e,b),Blockly.Procedures.mutateCallers(this))},displayRenamedVar_:function(a,b){this.updateParams_();if(this.mutator.isVisible())for(var c=this.mutator.workspace_.getAllBlocks(!1),d=0,e;e=c[d];d++)"procedures_mutatorarg"==e.type&&Blockly.Names.equals(a,e.getFieldValue("NAME"))&&e.setFieldValue(b,"NAME")},customContextMenu:function(a){if(!this.isInFlyout){var b=
+{enabled:!0},c=this.getFieldValue("NAME");b.text=Blockly.Msg.PROCEDURES_CREATE_DO.replace("%1",c);var d=document.createElement("mutation");d.setAttribute("name",c);for(var e=0;e<this.arguments_.length;e++)c=document.createElement("arg"),c.setAttribute("name",this.arguments_[e]),d.appendChild(c);c=document.createElement("block");c.setAttribute("type",this.callType_);c.appendChild(d);b.callback=Blockly.ContextMenu.callbackFactory(this,c);a.push(b);if(!this.isCollapsed())for(e=0;e<this.argumentVarModels_.length;e++)b=
+{enabled:!0},d=this.argumentVarModels_[e],c=d.name,b.text=Blockly.Msg.VARIABLES_SET_CREATE_GET.replace("%1",c),d=Blockly.Variables.generateVariableFieldDom(d),c=document.createElement("block"),c.setAttribute("type","variables_get"),c.appendChild(d),b.callback=Blockly.ContextMenu.callbackFactory(this,c),a.push(b)}},callType_:"procedures_callnoreturn"};
+Blockly.Blocks.procedures_defreturn={init:function(){var a=new Blockly.FieldTextInput("",Blockly.Procedures.rename);a.setSpellcheck(!1);this.appendDummyInput().appendField(Blockly.Msg.PROCEDURES_DEFRETURN_TITLE).appendField(a,"NAME").appendField("","PARAMS");this.appendValueInput("RETURN").setAlign(Blockly.ALIGN_RIGHT).appendField(Blockly.Msg.PROCEDURES_DEFRETURN_RETURN);this.setMutator(new Blockly.Mutator(["procedures_mutatorarg"]));(this.workspace.options.comments||this.workspace.options.parentWorkspace&&
+this.workspace.options.parentWorkspace.options.comments)&&Blockly.Msg.PROCEDURES_DEFRETURN_COMMENT&&this.setCommentText(Blockly.Msg.PROCEDURES_DEFRETURN_COMMENT);this.setStyle("procedure_blocks");this.setTooltip(Blockly.Msg.PROCEDURES_DEFRETURN_TOOLTIP);this.setHelpUrl(Blockly.Msg.PROCEDURES_DEFRETURN_HELPURL);this.arguments_=[];this.argumentVarModels_=[];this.setStatements_(!0);this.statementConnection_=null},setStatements_:Blockly.Blocks.procedures_defnoreturn.setStatements_,updateParams_:Blockly.Blocks.procedures_defnoreturn.updateParams_,
+mutationToDom:Blockly.Blocks.procedures_defnoreturn.mutationToDom,domToMutation:Blockly.Blocks.procedures_defnoreturn.domToMutation,decompose:Blockly.Blocks.procedures_defnoreturn.decompose,compose:Blockly.Blocks.procedures_defnoreturn.compose,getProcedureDef:function(){return[this.getFieldValue("NAME"),this.arguments_,!0]},getVars:Blockly.Blocks.procedures_defnoreturn.getVars,getVarModels:Blockly.Blocks.procedures_defnoreturn.getVarModels,renameVarById:Blockly.Blocks.procedures_defnoreturn.renameVarById,
+updateVarName:Blockly.Blocks.procedures_defnoreturn.updateVarName,displayRenamedVar_:Blockly.Blocks.procedures_defnoreturn.displayRenamedVar_,customContextMenu:Blockly.Blocks.procedures_defnoreturn.customContextMenu,callType_:"procedures_callreturn"};
+Blockly.Blocks.procedures_mutatorcontainer={init:function(){this.appendDummyInput().appendField(Blockly.Msg.PROCEDURES_MUTATORCONTAINER_TITLE);this.appendStatementInput("STACK");this.appendDummyInput("STATEMENT_INPUT").appendField(Blockly.Msg.PROCEDURES_ALLOW_STATEMENTS).appendField(new Blockly.FieldCheckbox("TRUE"),"STATEMENTS");this.setStyle("procedure_blocks");this.setTooltip(Blockly.Msg.PROCEDURES_MUTATORCONTAINER_TOOLTIP);this.contextMenu=!1},onchange:function(a){if(this.workspace&&!this.workspace.isFlyout&&
+(a.type==Blockly.Events.BLOCK_DELETE||a.type==Blockly.Events.BLOCK_CREATE)){var b=this.workspace.getAllBlocks(),c=this.workspace.getAllVariables();if(a.type==Blockly.Events.BLOCK_DELETE){a=[];for(var d=0;d<b.length;d+=1)b[d].getFieldValue("NAME")&&a.push(b[d].getFieldValue("NAME"));for(b=0;b<c.length;b+=1)-1==a.indexOf(c[b].name)&&this.workspace.deleteVariableById(c[b].getId())}else if(a.type==Blockly.Events.BLOCK_CREATE&&(c=this.workspace.getBlockById(a.blockId),c.getField("NAME")&&(d=c.getFieldValue("NAME"),
+(a=this.workspace.getVariable(d))||(a=this.workspace.createVariable(d)),!c.previousConnection.isConnected()&&!c.nextConnection.isConnected())))for(d=0;d<b.length;d+=1)if(c.id!=b[d].id&&b[d].getFieldValue("NAME")==a.name){d=Blockly.Variables.generateUniqueName(this.workspace);a=this.workspace.createVariable(d);c.setFieldValue(a.name,"NAME");break}}}};
+Blockly.Blocks.procedures_mutatorarg={init:function(){var a=new Blockly.FieldTextInput("x",this.validator_);a.oldShowEditorFn_=a.showEditor_;a.showEditor_=function(){this.createdVariables_=[];this.oldShowEditorFn_()};this.appendDummyInput().appendField(Blockly.Msg.PROCEDURES_MUTATORARG_TITLE).appendField(a,"NAME");this.setPreviousStatement(!0);this.setNextStatement(!0);this.setStyle("procedure_blocks");this.setTooltip(Blockly.Msg.PROCEDURES_MUTATORARG_TOOLTIP);this.contextMenu=!1;a.onFinishEditing_=
+this.deleteIntermediateVars_;a.createdVariables_=[];a.onFinishEditing_("x")},validator_:function(a){var b=Blockly.Mutator.findParentWs(this.sourceBlock_.workspace);a=a.replace(/[\s\xa0]+/g," ").replace(/^ | $/g,"");if(!a)return null;for(var c=this.sourceBlock_.workspace.getAllBlocks(),d=0;d<c.length;d+=1)if(c[d].id!=this.sourceBlock_.id&&c[d].getFieldValue("NAME")==a)return null;(c=b.getVariable(a,""))&&c.name!=a&&b.renameVarById(c.getId(),a);c||(c=b.createVariable(a,""))&&this.createdVariables_&&
+this.createdVariables_.push(c);return a},deleteIntermediateVars_:function(a){var b=Blockly.Mutator.findParentWs(this.sourceBlock_.workspace);if(b)for(var c=0;c<this.createdVariables_.length;c++){var d=this.createdVariables_[c];d.name!=a&&b.deleteVariableById(d.getId())}}};
+Blockly.Blocks.procedures_callnoreturn={init:function(){this.appendDummyInput("TOPROW").appendField(this.id,"NAME");this.setPreviousStatement(!0);this.setNextStatement(!0);this.setStyle("procedure_blocks");this.setHelpUrl(Blockly.Msg.PROCEDURES_CALLNORETURN_HELPURL);this.arguments_=[];this.argumentVarModels_=[];this.quarkConnections_={};this.quarkIds_=null;this.previousDisabledState_=!1},getProcedureCall:function(){return this.getFieldValue("NAME")},renameProcedure:function(a,b){Blockly.Names.equals(a,
+this.getProcedureCall())&&(this.setFieldValue(b,"NAME"),this.setTooltip((this.outputConnection?Blockly.Msg.PROCEDURES_CALLRETURN_TOOLTIP:Blockly.Msg.PROCEDURES_CALLNORETURN_TOOLTIP).replace("%1",b)))},setProcedureParameters_:function(a,b){var c=Blockly.Procedures.getDefinition(this.getProcedureCall(),this.workspace),d=c&&c.mutator&&c.mutator.isVisible();d||(this.quarkConnections_={},this.quarkIds_=null);if(b)if(a.join("\n")==this.arguments_.join("\n"))this.quarkIds_=b;else{if(b.length!=a.length)throw RangeError("paramNames and paramIds must be the same length.");
+this.setCollapsed(!1);this.quarkIds_||(this.quarkConnections_={},this.quarkIds_=[]);c=this.rendered;this.rendered=!1;for(var e=0;e<this.arguments_.length;e++){var f=this.getInput("ARG"+e);f&&(f=f.connection.targetConnection,this.quarkConnections_[this.quarkIds_[e]]=f,d&&f&&-1==b.indexOf(this.quarkIds_[e])&&(f.disconnect(),f.getSourceBlock().bumpNeighbours_()))}this.arguments_=[].concat(a);this.argumentVarModels_=[];for(e=0;e<this.arguments_.length;e++)d=Blockly.Variables.getOrCreateVariablePackage(this.workspace,
+null,this.arguments_[e],""),this.argumentVarModels_.push(d);this.updateShape_();if(this.quarkIds_=b)for(e=0;e<this.arguments_.length;e++)d=this.quarkIds_[e],d in this.quarkConnections_&&(f=this.quarkConnections_[d],Blockly.Mutator.reconnect(f,this,"ARG"+e)||delete this.quarkConnections_[d]);(this.rendered=c)&&this.render()}},updateShape_:function(){for(var a=0;a<this.arguments_.length;a++){var b=this.getField("ARGNAME"+a);if(b){Blockly.Events.disable();try{b.setValue(this.arguments_[a])}finally{Blockly.Events.enable()}}else b=
+new Blockly.FieldLabel(this.arguments_[a]),this.appendValueInput("ARG"+a).setAlign(Blockly.ALIGN_RIGHT).appendField(b,"ARGNAME"+a).init()}for(;this.getInput("ARG"+a);)this.removeInput("ARG"+a),a++;if(a=this.getInput("TOPROW"))this.arguments_.length?this.getField("WITH")||(a.appendField(Blockly.Msg.PROCEDURES_CALL_BEFORE_PARAMS,"WITH"),a.init()):this.getField("WITH")&&a.removeField("WITH")},mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("name",this.getProcedureCall());
+for(var b=0;b<this.arguments_.length;b++){var c=document.createElement("arg");c.setAttribute("name",this.arguments_[b]);a.appendChild(c)}return a},domToMutation:function(a){var b=a.getAttribute("name");this.renameProcedure(this.getProcedureCall(),b);b=[];for(var c=[],d=0,e;e=a.childNodes[d];d++)"arg"==e.nodeName.toLowerCase()&&(b.push(e.getAttribute("name")),c.push(e.getAttribute("paramId")));this.setProcedureParameters_(b,c)},getVarModels:function(){return this.argumentVarModels_},onchange:function(a){if(this.workspace&&
+!this.workspace.isFlyout&&a.recordUndo)if(a.type==Blockly.Events.BLOCK_CREATE&&-1!=a.ids.indexOf(this.id)){var b=this.getProcedureCall();b=Blockly.Procedures.getDefinition(b,this.workspace);!b||b.type==this.defType_&&JSON.stringify(b.arguments_)==JSON.stringify(this.arguments_)||(b=null);if(!b){Blockly.Events.setGroup(a.group);a=document.createElement("xml");b=document.createElement("block");b.setAttribute("type",this.defType_);var c=this.getRelativeToSurfaceXY(),d=c.y+2*Blockly.SNAP_RADIUS;b.setAttribute("x",
+c.x+Blockly.SNAP_RADIUS*(this.RTL?-1:1));b.setAttribute("y",d);c=this.mutationToDom();b.appendChild(c);c=document.createElement("field");c.setAttribute("name","NAME");c.appendChild(document.createTextNode(this.getProcedureCall()));b.appendChild(c);a.appendChild(b);Blockly.Xml.domToWorkspace(a,this.workspace);Blockly.Events.setGroup(!1)}}else a.type==Blockly.Events.BLOCK_DELETE?(b=this.getProcedureCall(),b=Blockly.Procedures.getDefinition(b,this.workspace),b||(Blockly.Events.setGroup(a.group),this.dispose(!0,
+!1),Blockly.Events.setGroup(!1))):a.type==Blockly.Events.CHANGE&&"disabled"==a.element&&(b=this.getProcedureCall(),(b=Blockly.Procedures.getDefinition(b,this.workspace))&&b.id==a.blockId&&((b=Blockly.Events.getGroup())&&console.log("Saw an existing group while responding to a definition change"),Blockly.Events.setGroup(a.group),a.newValue?(this.previousDisabledState_=this.disabled,this.setDisabled(!0)):this.setDisabled(this.previousDisabledState_),Blockly.Events.setGroup(b)))},customContextMenu:function(a){var b=
+{enabled:!0};b.text=Blockly.Msg.PROCEDURES_HIGHLIGHT_DEF;var c=this.getProcedureCall(),d=this.workspace;b.callback=function(){var a=Blockly.Procedures.getDefinition(c,d);a&&(d.centerOnBlock(a.id),a.select())};a.push(b)},defType_:"procedures_defnoreturn"};
+Blockly.Blocks.procedures_callreturn={init:function(){this.appendDummyInput("TOPROW").appendField("","NAME");this.setOutput(!0);this.setStyle("procedure_blocks");this.setHelpUrl(Blockly.Msg.PROCEDURES_CALLRETURN_HELPURL);this.arguments_=[];this.quarkConnections_={};this.quarkIds_=null;this.previousDisabledState_=!1},getProcedureCall:Blockly.Blocks.procedures_callnoreturn.getProcedureCall,renameProcedure:Blockly.Blocks.procedures_callnoreturn.renameProcedure,setProcedureParameters_:Blockly.Blocks.procedures_callnoreturn.setProcedureParameters_,
+updateShape_:Blockly.Blocks.procedures_callnoreturn.updateShape_,mutationToDom:Blockly.Blocks.procedures_callnoreturn.mutationToDom,domToMutation:Blockly.Blocks.procedures_callnoreturn.domToMutation,getVarModels:Blockly.Blocks.procedures_callnoreturn.getVarModels,onchange:Blockly.Blocks.procedures_callnoreturn.onchange,customContextMenu:Blockly.Blocks.procedures_callnoreturn.customContextMenu,defType_:"procedures_defreturn"};
+Blockly.Blocks.procedures_ifreturn={init:function(){this.appendValueInput("CONDITION").setCheck("Boolean").appendField(Blockly.Msg.CONTROLS_IF_MSG_IF);this.appendValueInput("VALUE").appendField(Blockly.Msg.PROCEDURES_DEFRETURN_RETURN);this.setInputsInline(!0);this.setPreviousStatement(!0);this.setNextStatement(!0);this.setStyle("procedure_blocks");this.setTooltip(Blockly.Msg.PROCEDURES_IFRETURN_TOOLTIP);this.setHelpUrl(Blockly.Msg.PROCEDURES_IFRETURN_HELPURL);this.hasReturnValue_=!0},mutationToDom:function(){var a=
+document.createElement("mutation");a.setAttribute("value",Number(this.hasReturnValue_));return a},domToMutation:function(a){this.hasReturnValue_=1==a.getAttribute("value");this.hasReturnValue_||(this.removeInput("VALUE"),this.appendDummyInput("VALUE").appendField(Blockly.Msg.PROCEDURES_DEFRETURN_RETURN))},onchange:function(){if(this.workspace.isDragging&&!this.workspace.isDragging()){var a=!1,b=this;do{if(-1!=this.FUNCTION_TYPES.indexOf(b.type)){a=!0;break}b=b.getSurroundParent()}while(b);a?("procedures_defnoreturn"==
+b.type&&this.hasReturnValue_?(this.removeInput("VALUE"),this.appendDummyInput("VALUE").appendField(Blockly.Msg.PROCEDURES_DEFRETURN_RETURN),this.hasReturnValue_=!1):"procedures_defreturn"!=b.type||this.hasReturnValue_||(this.removeInput("VALUE"),this.appendValueInput("VALUE").appendField(Blockly.Msg.PROCEDURES_DEFRETURN_RETURN),this.hasReturnValue_=!0),this.setWarningText(null),this.isInFlyout||this.setDisabled(!1)):(this.setWarningText(Blockly.Msg.PROCEDURES_IFRETURN_WARNING),this.isInFlyout||this.getInheritedDisabled()||
+this.setDisabled(!0))}},FUNCTION_TYPES:["procedures_defnoreturn","procedures_defreturn"]};Blockly.Blocks.texts={};Blockly.Constants.Text={};Blockly.Constants.Text.HUE=160;
+Blockly.defineBlocksWithJsonArray([{type:"text",message0:"%1",args0:[{type:"field_input",name:"TEXT",text:""}],output:"String",style:"text_blocks",helpUrl:"%{BKY_TEXT_TEXT_HELPURL}",tooltip:"%{BKY_TEXT_TEXT_TOOLTIP}",extensions:["text_quotes","parent_tooltip_when_inline"]},{type:"text_join",message0:"",output:"String",style:"text_blocks",helpUrl:"%{BKY_TEXT_JOIN_HELPURL}",tooltip:"%{BKY_TEXT_JOIN_TOOLTIP}",mutator:"text_join_mutator"},{type:"text_create_join_container",message0:"%{BKY_TEXT_CREATE_JOIN_TITLE_JOIN} %1 %2",
+args0:[{type:"input_dummy"},{type:"input_statement",name:"STACK"}],style:"text_blocks",tooltip:"%{BKY_TEXT_CREATE_JOIN_TOOLTIP}",enableContextMenu:!1},{type:"text_create_join_item",message0:"%{BKY_TEXT_CREATE_JOIN_ITEM_TITLE_ITEM}",previousStatement:null,nextStatement:null,style:"text_blocks",tooltip:"%{BKY_TEXT_CREATE_JOIN_ITEM_TOOLTIP}",enableContextMenu:!1},{type:"text_append",message0:"%{BKY_TEXT_APPEND_TITLE}",args0:[{type:"field_variable",name:"VAR",variable:"%{BKY_TEXT_APPEND_VARIABLE}"},{type:"input_value",
+name:"TEXT"}],previousStatement:null,nextStatement:null,style:"text_blocks",extensions:["text_append_tooltip"]},{type:"text_length",message0:"%{BKY_TEXT_LENGTH_TITLE}",args0:[{type:"input_value",name:"VALUE",check:["String","Array"]}],output:"Number",style:"text_blocks",tooltip:"%{BKY_TEXT_LENGTH_TOOLTIP}",helpUrl:"%{BKY_TEXT_LENGTH_HELPURL}"},{type:"text_isEmpty",message0:"%{BKY_TEXT_ISEMPTY_TITLE}",args0:[{type:"input_value",name:"VALUE",check:["String","Array"]}],output:"Boolean",style:"text_blocks",
+tooltip:"%{BKY_TEXT_ISEMPTY_TOOLTIP}",helpUrl:"%{BKY_TEXT_ISEMPTY_HELPURL}"},{type:"text_indexOf",message0:"%{BKY_TEXT_INDEXOF_TITLE}",args0:[{type:"input_value",name:"VALUE",check:"String"},{type:"field_dropdown",name:"END",options:[["%{BKY_TEXT_INDEXOF_OPERATOR_FIRST}","FIRST"],["%{BKY_TEXT_INDEXOF_OPERATOR_LAST}","LAST"]]},{type:"input_value",name:"FIND",check:"String"}],output:"Number",style:"text_blocks",helpUrl:"%{BKY_TEXT_INDEXOF_HELPURL}",inputsInline:!0,extensions:["text_indexOf_tooltip"]},
+{type:"text_charAt",message0:"%{BKY_TEXT_CHARAT_TITLE}",args0:[{type:"input_value",name:"VALUE",check:"String"},{type:"field_dropdown",name:"WHERE",options:[["%{BKY_TEXT_CHARAT_FROM_START}","FROM_START"],["%{BKY_TEXT_CHARAT_FROM_END}","FROM_END"],["%{BKY_TEXT_CHARAT_FIRST}","FIRST"],["%{BKY_TEXT_CHARAT_LAST}","LAST"],["%{BKY_TEXT_CHARAT_RANDOM}","RANDOM"]]}],output:"String",style:"text_blocks",helpUrl:"%{BKY_TEXT_CHARAT_HELPURL}",inputsInline:!0,mutator:"text_charAt_mutator"}]);
+Blockly.Blocks.text_getSubstring={init:function(){this.WHERE_OPTIONS_1=[[Blockly.Msg.TEXT_GET_SUBSTRING_START_FROM_START,"FROM_START"],[Blockly.Msg.TEXT_GET_SUBSTRING_START_FROM_END,"FROM_END"],[Blockly.Msg.TEXT_GET_SUBSTRING_START_FIRST,"FIRST"]];this.WHERE_OPTIONS_2=[[Blockly.Msg.TEXT_GET_SUBSTRING_END_FROM_START,"FROM_START"],[Blockly.Msg.TEXT_GET_SUBSTRING_END_FROM_END,"FROM_END"],[Blockly.Msg.TEXT_GET_SUBSTRING_END_LAST,"LAST"]];this.setHelpUrl(Blockly.Msg.TEXT_GET_SUBSTRING_HELPURL);this.setStyle("text_blocks");
+this.appendValueInput("STRING").setCheck("String").appendField(Blockly.Msg.TEXT_GET_SUBSTRING_INPUT_IN_TEXT);this.appendDummyInput("AT1");this.appendDummyInput("AT2");Blockly.Msg.TEXT_GET_SUBSTRING_TAIL&&this.appendDummyInput("TAIL").appendField(Blockly.Msg.TEXT_GET_SUBSTRING_TAIL);this.setInputsInline(!0);this.setOutput(!0,"String");this.updateAt_(1,!0);this.updateAt_(2,!0);this.setTooltip(Blockly.Msg.TEXT_GET_SUBSTRING_TOOLTIP)},mutationToDom:function(){var a=document.createElement("mutation"),
+b=this.getInput("AT1").type==Blockly.INPUT_VALUE;a.setAttribute("at1",b);b=this.getInput("AT2").type==Blockly.INPUT_VALUE;a.setAttribute("at2",b);return a},domToMutation:function(a){var b="true"==a.getAttribute("at1");a="true"==a.getAttribute("at2");this.updateAt_(1,b);this.updateAt_(2,a)},updateAt_:function(a,b){this.removeInput("AT"+a);this.removeInput("ORDINAL"+a,!0);b?(this.appendValueInput("AT"+a).setCheck("Number"),Blockly.Msg.ORDINAL_NUMBER_SUFFIX&&this.appendDummyInput("ORDINAL"+a).appendField(Blockly.Msg.ORDINAL_NUMBER_SUFFIX)):
+this.appendDummyInput("AT"+a);2==a&&Blockly.Msg.TEXT_GET_SUBSTRING_TAIL&&(this.removeInput("TAIL",!0),this.appendDummyInput("TAIL").appendField(Blockly.Msg.TEXT_GET_SUBSTRING_TAIL));var c=new Blockly.FieldDropdown(this["WHERE_OPTIONS_"+a],function(c){var d="FROM_START"==c||"FROM_END"==c;if(d!=b){var f=this.sourceBlock_;f.updateAt_(a,d);f.setFieldValue(c,"WHERE"+a);return null}});this.getInput("AT"+a).appendField(c,"WHERE"+a);1==a&&(this.moveInputBefore("AT1","AT2"),this.getInput("ORDINAL1")&&this.moveInputBefore("ORDINAL1",
+"AT2"))}};Blockly.Blocks.text_changeCase={init:function(){var a=[[Blockly.Msg.TEXT_CHANGECASE_OPERATOR_UPPERCASE,"UPPERCASE"],[Blockly.Msg.TEXT_CHANGECASE_OPERATOR_LOWERCASE,"LOWERCASE"],[Blockly.Msg.TEXT_CHANGECASE_OPERATOR_TITLECASE,"TITLECASE"]];this.setHelpUrl(Blockly.Msg.TEXT_CHANGECASE_HELPURL);this.setStyle("text_blocks");this.appendValueInput("TEXT").setCheck("String").appendField(new Blockly.FieldDropdown(a),"CASE");this.setOutput(!0,"String");this.setTooltip(Blockly.Msg.TEXT_CHANGECASE_TOOLTIP)}};
+Blockly.Blocks.text_trim={init:function(){var a=[[Blockly.Msg.TEXT_TRIM_OPERATOR_BOTH,"BOTH"],[Blockly.Msg.TEXT_TRIM_OPERATOR_LEFT,"LEFT"],[Blockly.Msg.TEXT_TRIM_OPERATOR_RIGHT,"RIGHT"]];this.setHelpUrl(Blockly.Msg.TEXT_TRIM_HELPURL);this.setStyle("text_blocks");this.appendValueInput("TEXT").setCheck("String").appendField(new Blockly.FieldDropdown(a),"MODE");this.setOutput(!0,"String");this.setTooltip(Blockly.Msg.TEXT_TRIM_TOOLTIP)}};
+Blockly.Blocks.text_print={init:function(){this.jsonInit({message0:Blockly.Msg.TEXT_PRINT_TITLE,args0:[{type:"input_value",name:"TEXT"}],previousStatement:null,nextStatement:null,style:"text_blocks",tooltip:Blockly.Msg.TEXT_PRINT_TOOLTIP,helpUrl:Blockly.Msg.TEXT_PRINT_HELPURL})}};
+Blockly.Blocks.text_prompt_ext={init:function(){var a=[[Blockly.Msg.TEXT_PROMPT_TYPE_TEXT,"TEXT"],[Blockly.Msg.TEXT_PROMPT_TYPE_NUMBER,"NUMBER"]];this.setHelpUrl(Blockly.Msg.TEXT_PROMPT_HELPURL);this.setStyle("text_blocks");var b=this;a=new Blockly.FieldDropdown(a,function(a){b.updateType_(a)});this.appendValueInput("TEXT").appendField(a,"TYPE");this.setOutput(!0,"String");this.setTooltip(function(){return"TEXT"==b.getFieldValue("TYPE")?Blockly.Msg.TEXT_PROMPT_TOOLTIP_TEXT:Blockly.Msg.TEXT_PROMPT_TOOLTIP_NUMBER})},
+updateType_:function(a){this.outputConnection.setCheck("NUMBER"==a?"Number":"String")},mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("type",this.getFieldValue("TYPE"));return a},domToMutation:function(a){this.updateType_(a.getAttribute("type"))}};
+Blockly.Blocks.text_prompt={init:function(){this.mixin(Blockly.Constants.Text.QUOTE_IMAGE_MIXIN);var a=[[Blockly.Msg.TEXT_PROMPT_TYPE_TEXT,"TEXT"],[Blockly.Msg.TEXT_PROMPT_TYPE_NUMBER,"NUMBER"]],b=this;this.setHelpUrl(Blockly.Msg.TEXT_PROMPT_HELPURL);this.setStyle("text_blocks");a=new Blockly.FieldDropdown(a,function(a){b.updateType_(a)});this.appendDummyInput().appendField(a,"TYPE").appendField(this.newQuote_(!0)).appendField(new Blockly.FieldTextInput(""),"TEXT").appendField(this.newQuote_(!1));
+this.setOutput(!0,"String");this.setTooltip(function(){return"TEXT"==b.getFieldValue("TYPE")?Blockly.Msg.TEXT_PROMPT_TOOLTIP_TEXT:Blockly.Msg.TEXT_PROMPT_TOOLTIP_NUMBER})},updateType_:Blockly.Blocks.text_prompt_ext.updateType_,mutationToDom:Blockly.Blocks.text_prompt_ext.mutationToDom,domToMutation:Blockly.Blocks.text_prompt_ext.domToMutation};
+Blockly.Blocks.text_count={init:function(){this.jsonInit({message0:Blockly.Msg.TEXT_COUNT_MESSAGE0,args0:[{type:"input_value",name:"SUB",check:"String"},{type:"input_value",name:"TEXT",check:"String"}],output:"Number",inputsInline:!0,style:"text_blocks",tooltip:Blockly.Msg.TEXT_COUNT_TOOLTIP,helpUrl:Blockly.Msg.TEXT_COUNT_HELPURL})}};
+Blockly.Blocks.text_replace={init:function(){this.jsonInit({message0:Blockly.Msg.TEXT_REPLACE_MESSAGE0,args0:[{type:"input_value",name:"FROM",check:"String"},{type:"input_value",name:"TO",check:"String"},{type:"input_value",name:"TEXT",check:"String"}],output:"String",inputsInline:!0,style:"text_blocks",tooltip:Blockly.Msg.TEXT_REPLACE_TOOLTIP,helpUrl:Blockly.Msg.TEXT_REPLACE_HELPURL})}};
+Blockly.Blocks.text_reverse={init:function(){this.jsonInit({message0:Blockly.Msg.TEXT_REVERSE_MESSAGE0,args0:[{type:"input_value",name:"TEXT",check:"String"}],output:"String",inputsInline:!0,style:"text_blocks",tooltip:Blockly.Msg.TEXT_REVERSE_TOOLTIP,helpUrl:Blockly.Msg.TEXT_REVERSE_HELPURL})}};
+Blockly.Constants.Text.QUOTE_IMAGE_MIXIN={QUOTE_IMAGE_LEFT_DATAURI:"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAwAAAAKCAQAAAAqJXdxAAAAn0lEQVQI1z3OMa5BURSF4f/cQhAKjUQhuQmFNwGJEUi0RKN5rU7FHKhpjEH3TEMtkdBSCY1EIv8r7nFX9e29V7EBAOvu7RPjwmWGH/VuF8CyN9/OAdvqIXYLvtRaNjx9mMTDyo+NjAN1HNcl9ZQ5oQMM3dgDUqDo1l8DzvwmtZN7mnD+PkmLa+4mhrxVA9fRowBWmVBhFy5gYEjKMfz9AylsaRRgGzvZAAAAAElFTkSuQmCC",QUOTE_IMAGE_RIGHT_DATAURI:"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAwAAAAKCAQAAAAqJXdxAAAAqUlEQVQI1z3KvUpCcRiA8ef9E4JNHhI0aFEacm1o0BsI0Slx8wa8gLauoDnoBhq7DcfWhggONDmJJgqCPA7neJ7p934EOOKOnM8Q7PDElo/4x4lFb2DmuUjcUzS3URnGib9qaPNbuXvBO3sGPHJDRG6fGVdMSeWDP2q99FQdFrz26Gu5Tq7dFMzUvbXy8KXeAj57cOklgA+u1B5AoslLtGIHQMaCVnwDnADZIFIrXsoXrgAAAABJRU5ErkJggg==",
+QUOTE_IMAGE_WIDTH:12,QUOTE_IMAGE_HEIGHT:12,quoteField_:function(a){for(var b=0,c;c=this.inputList[b];b++)for(var d=0,e;e=c.fieldRow[d];d++)if(a==e.name){c.insertFieldAt(d,this.newQuote_(!0));c.insertFieldAt(d+2,this.newQuote_(!1));return}console.warn('field named "'+a+'" not found in '+this.toDevString())},newQuote_:function(a){a=this.RTL?!a:a;return new Blockly.FieldImage(a?this.QUOTE_IMAGE_LEFT_DATAURI:this.QUOTE_IMAGE_RIGHT_DATAURI,this.QUOTE_IMAGE_WIDTH,this.QUOTE_IMAGE_HEIGHT,a?"\u201c":"\u201d")}};
+Blockly.Constants.Text.TEXT_QUOTES_EXTENSION=function(){this.mixin(Blockly.Constants.Text.QUOTE_IMAGE_MIXIN);this.quoteField_("TEXT")};
+Blockly.Constants.Text.TEXT_JOIN_MUTATOR_MIXIN={mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("items",this.itemCount_);return a},domToMutation:function(a){this.itemCount_=parseInt(a.getAttribute("items"),10);this.updateShape_()},decompose:function(a){var b=a.newBlock("text_create_join_container");b.initSvg();for(var c=b.getInput("STACK").connection,d=0;d<this.itemCount_;d++){var e=a.newBlock("text_create_join_item");e.initSvg();c.connect(e.previousConnection);c=
+e.nextConnection}return b},compose:function(a){var b=a.getInputTargetBlock("STACK");for(a=[];b;)a.push(b.valueConnection_),b=b.nextConnection&&b.nextConnection.targetBlock();for(b=0;b<this.itemCount_;b++){var c=this.getInput("ADD"+b).connection.targetConnection;c&&-1==a.indexOf(c)&&c.disconnect()}this.itemCount_=a.length;this.updateShape_();for(b=0;b<this.itemCount_;b++)Blockly.Mutator.reconnect(a[b],this,"ADD"+b)},saveConnections:function(a){a=a.getInputTargetBlock("STACK");for(var b=0;a;){var c=
+this.getInput("ADD"+b);a.valueConnection_=c&&c.connection.targetConnection;b++;a=a.nextConnection&&a.nextConnection.targetBlock()}},updateShape_:function(){this.itemCount_&&this.getInput("EMPTY")?this.removeInput("EMPTY"):this.itemCount_||this.getInput("EMPTY")||this.appendDummyInput("EMPTY").appendField(this.newQuote_(!0)).appendField(this.newQuote_(!1));for(var a=0;a<this.itemCount_;a++)if(!this.getInput("ADD"+a)){var b=this.appendValueInput("ADD"+a);0==a&&b.appendField(Blockly.Msg.TEXT_JOIN_TITLE_CREATEWITH)}for(;this.getInput("ADD"+
+a);)this.removeInput("ADD"+a),a++}};Blockly.Constants.Text.TEXT_JOIN_EXTENSION=function(){this.mixin(Blockly.Constants.Text.QUOTE_IMAGE_MIXIN);this.itemCount_=2;this.updateShape_();this.setMutator(new Blockly.Mutator(["text_create_join_item"]))};Blockly.Extensions.register("text_append_tooltip",Blockly.Extensions.buildTooltipWithFieldText("%{BKY_TEXT_APPEND_TOOLTIP}","VAR"));
+Blockly.Constants.Text.TEXT_INDEXOF_TOOLTIP_EXTENSION=function(){var a=this;this.setTooltip(function(){return Blockly.Msg.TEXT_INDEXOF_TOOLTIP.replace("%1",a.workspace.options.oneBasedIndex?"0":"-1")})};
+Blockly.Constants.Text.TEXT_CHARAT_MUTATOR_MIXIN={mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("at",!!this.isAt_);return a},domToMutation:function(a){a="false"!=a.getAttribute("at");this.updateAt_(a)},updateAt_:function(a){this.removeInput("AT",!0);this.removeInput("ORDINAL",!0);a&&(this.appendValueInput("AT").setCheck("Number"),Blockly.Msg.ORDINAL_NUMBER_SUFFIX&&this.appendDummyInput("ORDINAL").appendField(Blockly.Msg.ORDINAL_NUMBER_SUFFIX));Blockly.Msg.TEXT_CHARAT_TAIL&&
+(this.removeInput("TAIL",!0),this.appendDummyInput("TAIL").appendField(Blockly.Msg.TEXT_CHARAT_TAIL));this.isAt_=a}};
+Blockly.Constants.Text.TEXT_CHARAT_EXTENSION=function(){this.getField("WHERE").setValidator(function(a){var b="FROM_START"==a||"FROM_END"==a;if(b!=this.isAt_){var d=this.sourceBlock_;d.updateAt_(b);d.setFieldValue(a,"WHERE");return null}});this.updateAt_(!0);var a=this;this.setTooltip(function(){var b=a.getFieldValue("WHERE"),c=Blockly.Msg.TEXT_CHARAT_TOOLTIP;("FROM_START"==b||"FROM_END"==b)&&(b="FROM_START"==b?Blockly.Msg.LISTS_INDEX_FROM_START_TOOLTIP:Blockly.Msg.LISTS_INDEX_FROM_END_TOOLTIP)&&
+(c+="  "+b.replace("%1",a.workspace.options.oneBasedIndex?"#1":"#0"));return c})};Blockly.Extensions.register("text_indexOf_tooltip",Blockly.Constants.Text.TEXT_INDEXOF_TOOLTIP_EXTENSION);Blockly.Extensions.register("text_quotes",Blockly.Constants.Text.TEXT_QUOTES_EXTENSION);Blockly.Extensions.registerMutator("text_join_mutator",Blockly.Constants.Text.TEXT_JOIN_MUTATOR_MIXIN,Blockly.Constants.Text.TEXT_JOIN_EXTENSION);
+Blockly.Extensions.registerMutator("text_charAt_mutator",Blockly.Constants.Text.TEXT_CHARAT_MUTATOR_MIXIN,Blockly.Constants.Text.TEXT_CHARAT_EXTENSION);Blockly.Blocks.variables={};Blockly.Constants.Variables={};Blockly.Constants.Variables.HUE=330;
+Blockly.defineBlocksWithJsonArray([{type:"variables_get",message0:"%1",args0:[{type:"field_variable",name:"VAR",variable:"%{BKY_VARIABLES_DEFAULT_NAME}"}],output:null,style:"variable_blocks",helpUrl:"%{BKY_VARIABLES_GET_HELPURL}",tooltip:"%{BKY_VARIABLES_GET_TOOLTIP}",extensions:["contextMenu_variableSetterGetter"]},{type:"variables_set",message0:"%{BKY_VARIABLES_SET}",args0:[{type:"field_variable",name:"VAR",variable:"%{BKY_VARIABLES_DEFAULT_NAME}"},{type:"input_value",name:"VALUE"}],previousStatement:null,
+nextStatement:null,style:"variable_blocks",tooltip:"%{BKY_VARIABLES_SET_TOOLTIP}",helpUrl:"%{BKY_VARIABLES_SET_HELPURL}",extensions:["contextMenu_variableSetterGetter"]}]);
+Blockly.Constants.Variables.CUSTOM_CONTEXT_MENU_VARIABLE_GETTER_SETTER_MIXIN={customContextMenu:function(a){if(!this.isInFlyout){if("variables_get"==this.type)var b="variables_set",c=Blockly.Msg.VARIABLES_GET_CREATE_SET;else b="variables_get",c=Blockly.Msg.VARIABLES_SET_CREATE_GET;var d={enabled:0<this.workspace.remainingCapacity()},e=this.getField("VAR").getText();d.text=c.replace("%1",e);c=document.createElement("field");c.setAttribute("name","VAR");c.appendChild(document.createTextNode(e));e=document.createElement("block");
+e.setAttribute("type",b);e.appendChild(c);d.callback=Blockly.ContextMenu.callbackFactory(this,e);a.push(d)}else if("variables_get"==this.type||"variables_get_reporter"==this.type)b={text:Blockly.Msg.RENAME_VARIABLE,enabled:!0,callback:Blockly.Constants.Variables.RENAME_OPTION_CALLBACK_FACTORY(this)},e=this.getField("VAR").getText(),d={text:Blockly.Msg.DELETE_VARIABLE.replace("%1",e),enabled:!0,callback:Blockly.Constants.Variables.DELETE_OPTION_CALLBACK_FACTORY(this)},a.unshift(b),a.unshift(d)}};
+Blockly.Constants.Variables.RENAME_OPTION_CALLBACK_FACTORY=function(a){return function(){var b=a.workspace,c=a.getField("VAR").getVariable();Blockly.Variables.renameVariable(b,c)}};Blockly.Constants.Variables.DELETE_OPTION_CALLBACK_FACTORY=function(a){return function(){var b=a.workspace,c=a.getField("VAR").getVariable();b.deleteVariableById(c.getId());b.refreshToolboxSelection()}};Blockly.Extensions.registerMixin("contextMenu_variableSetterGetter",Blockly.Constants.Variables.CUSTOM_CONTEXT_MENU_VARIABLE_GETTER_SETTER_MIXIN);
+Blockly.Constants.VariablesDynamic={};Blockly.Constants.VariablesDynamic.HUE=310;
+Blockly.defineBlocksWithJsonArray([{type:"variables_get_dynamic",message0:"%1",args0:[{type:"field_variable",name:"VAR",variable:"%{BKY_VARIABLES_DEFAULT_NAME}"}],output:null,style:"variable_dynamic_blocks",helpUrl:"%{BKY_VARIABLES_GET_HELPURL}",tooltip:"%{BKY_VARIABLES_GET_TOOLTIP}",extensions:["contextMenu_variableDynamicSetterGetter"]},{type:"variables_set_dynamic",message0:"%{BKY_VARIABLES_SET}",args0:[{type:"field_variable",name:"VAR",variable:"%{BKY_VARIABLES_DEFAULT_NAME}"},{type:"input_value",
+name:"VALUE"}],previousStatement:null,nextStatement:null,style:"variable_dynamic_blocks",tooltip:"%{BKY_VARIABLES_SET_TOOLTIP}",helpUrl:"%{BKY_VARIABLES_SET_HELPURL}",extensions:["contextMenu_variableDynamicSetterGetter"]}]);
+Blockly.Constants.VariablesDynamic.CUSTOM_CONTEXT_MENU_VARIABLE_GETTER_SETTER_MIXIN={customContextMenu:function(a){if(!this.isInFlyout){var b=this.getFieldValue("VAR");var c=this.workspace.getVariableById(b).type;if("variables_get_dynamic"==this.type){b="variables_set_dynamic";var d=Blockly.Msg.VARIABLES_GET_CREATE_SET}else b="variables_get_dynamic",d=Blockly.Msg.VARIABLES_SET_CREATE_GET;var e={enabled:0<this.workspace.remainingCapacity()},f=this.getField("VAR").getText();e.text=d.replace("%1",f);
+d=document.createElement("field");d.setAttribute("name","VAR");d.setAttribute("variabletype",c);d.appendChild(document.createTextNode(f));f=document.createElement("block");f.setAttribute("type",b);f.appendChild(d);e.callback=Blockly.ContextMenu.callbackFactory(this,f);a.push(e)}else if("variables_get_dynamic"==this.type||"variables_get_reporter_dynamic"==this.type)b={text:Blockly.Msg.RENAME_VARIABLE,enabled:!0,callback:Blockly.Constants.Variables.RENAME_OPTION_CALLBACK_FACTORY(this)},f=this.getField("VAR").getText(),
+e={text:Blockly.Msg.DELETE_VARIABLE.replace("%1",f),enabled:!0,callback:Blockly.Constants.Variables.DELETE_OPTION_CALLBACK_FACTORY(this)},a.unshift(b),a.unshift(e)},onchange:function(){var a=this.getFieldValue("VAR");a=this.workspace.getVariableById(a);"variables_get_dynamic"==this.type?this.outputConnection.setCheck(a.type):this.getInput("VALUE").connection.setCheck(a.type)}};
+Blockly.Constants.VariablesDynamic.RENAME_OPTION_CALLBACK_FACTORY=function(a){return function(){var b=a.workspace,c=a.getField("VAR").getVariable();Blockly.Variables.renameVariable(b,c)}};Blockly.Constants.VariablesDynamic.DELETE_OPTION_CALLBACK_FACTORY=function(a){return function(){var b=a.workspace,c=a.getField("VAR").getVariable();b.deleteVariableById(c.getId());b.refreshToolboxSelection()}};Blockly.Extensions.registerMixin("contextMenu_variableDynamicSetterGetter",Blockly.Constants.VariablesDynamic.CUSTOM_CONTEXT_MENU_VARIABLE_GETTER_SETTER_MIXIN);
\ No newline at end of file
diff --git a/_server/blockly/javascript_compressed.js b/_server/blockly/javascript_compressed.js
new file mode 100644
index 00000000..dec1616c
--- /dev/null
+++ b/_server/blockly/javascript_compressed.js
@@ -0,0 +1,96 @@
+// Do not edit this file; automatically generated by build.py.
+'use strict';
+
+
+Blockly.JavaScript=new Blockly.Generator("JavaScript");Blockly.JavaScript.addReservedWords("Blockly,break,case,catch,continue,debugger,default,delete,do,else,finally,for,function,if,in,instanceof,new,return,switch,this,throw,try,typeof,var,void,while,with,class,enum,export,extends,import,super,implements,interface,let,package,private,protected,public,static,yield,const,null,true,false,Array,ArrayBuffer,Boolean,Date,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Error,eval,EvalError,Float32Array,Float64Array,Function,Infinity,Int16Array,Int32Array,Int8Array,isFinite,isNaN,Iterator,JSON,Math,NaN,Number,Object,parseFloat,parseInt,RangeError,ReferenceError,RegExp,StopIteration,String,SyntaxError,TypeError,Uint16Array,Uint32Array,Uint8Array,Uint8ClampedArray,undefined,uneval,URIError,applicationCache,closed,Components,content,_content,controllers,crypto,defaultStatus,dialogArguments,directories,document,frameElement,frames,fullScreen,globalStorage,history,innerHeight,innerWidth,length,location,locationbar,localStorage,menubar,messageManager,mozAnimationStartTime,mozInnerScreenX,mozInnerScreenY,mozPaintCount,name,navigator,opener,outerHeight,outerWidth,pageXOffset,pageYOffset,parent,performance,personalbar,pkcs11,returnValue,screen,screenX,screenY,scrollbars,scrollMaxX,scrollMaxY,scrollX,scrollY,self,sessionStorage,sidebar,status,statusbar,toolbar,top,URL,window,addEventListener,alert,atob,back,blur,btoa,captureEvents,clearImmediate,clearInterval,clearTimeout,close,confirm,disableExternalCapture,dispatchEvent,dump,enableExternalCapture,escape,find,focus,forward,GeckoActiveXObject,getAttention,getAttentionWithCycleCount,getComputedStyle,getSelection,home,matchMedia,maximize,minimize,moveBy,moveTo,mozRequestAnimationFrame,open,openDialog,postMessage,print,prompt,QueryInterface,releaseEvents,removeEventListener,resizeBy,resizeTo,restore,routeEvent,scroll,scrollBy,scrollByLines,scrollByPages,scrollTo,setCursor,setImmediate,setInterval,setResizable,setTimeout,showModalDialog,sizeToContent,stop,unescape,updateCommands,XPCNativeWrapper,XPCSafeJSObjectWrapper,onabort,onbeforeunload,onblur,onchange,onclick,onclose,oncontextmenu,ondevicemotion,ondeviceorientation,ondragdrop,onerror,onfocus,onhashchange,onkeydown,onkeypress,onkeyup,onload,onmousedown,onmousemove,onmouseout,onmouseover,onmouseup,onmozbeforepaint,onpaint,onpopstate,onreset,onresize,onscroll,onselect,onsubmit,onunload,onpageshow,onpagehide,Image,Option,Worker,Event,Range,File,FileReader,Blob,BlobBuilder,Attr,CDATASection,CharacterData,Comment,console,DocumentFragment,DocumentType,DomConfiguration,DOMError,DOMErrorHandler,DOMException,DOMImplementation,DOMImplementationList,DOMImplementationRegistry,DOMImplementationSource,DOMLocator,DOMObject,DOMString,DOMStringList,DOMTimeStamp,DOMUserData,Entity,EntityReference,MediaQueryList,MediaQueryListListener,NameList,NamedNodeMap,Node,NodeFilter,NodeIterator,NodeList,Notation,Plugin,PluginArray,ProcessingInstruction,SharedWorker,Text,TimeRanges,Treewalker,TypeInfo,UserDataHandler,Worker,WorkerGlobalScope,HTMLDocument,HTMLElement,HTMLAnchorElement,HTMLAppletElement,HTMLAudioElement,HTMLAreaElement,HTMLBaseElement,HTMLBaseFontElement,HTMLBodyElement,HTMLBRElement,HTMLButtonElement,HTMLCanvasElement,HTMLDirectoryElement,HTMLDivElement,HTMLDListElement,HTMLEmbedElement,HTMLFieldSetElement,HTMLFontElement,HTMLFormElement,HTMLFrameElement,HTMLFrameSetElement,HTMLHeadElement,HTMLHeadingElement,HTMLHtmlElement,HTMLHRElement,HTMLIFrameElement,HTMLImageElement,HTMLInputElement,HTMLKeygenElement,HTMLLabelElement,HTMLLIElement,HTMLLinkElement,HTMLMapElement,HTMLMenuElement,HTMLMetaElement,HTMLModElement,HTMLObjectElement,HTMLOListElement,HTMLOptGroupElement,HTMLOptionElement,HTMLOutputElement,HTMLParagraphElement,HTMLParamElement,HTMLPreElement,HTMLQuoteElement,HTMLScriptElement,HTMLSelectElement,HTMLSourceElement,HTMLSpanElement,HTMLStyleElement,HTMLTableElement,HTMLTableCaptionElement,HTMLTableCellElement,HTMLTableDataCellElement,HTMLTableHeaderCellElement,HTMLTableColElement,HTMLTableRowElement,HTMLTableSectionElement,HTMLTextAreaElement,HTMLTimeElement,HTMLTitleElement,HTMLTrackElement,HTMLUListElement,HTMLUnknownElement,HTMLVideoElement,HTMLCanvasElement,CanvasRenderingContext2D,CanvasGradient,CanvasPattern,TextMetrics,ImageData,CanvasPixelArray,HTMLAudioElement,HTMLVideoElement,NotifyAudioAvailableEvent,HTMLCollection,HTMLAllCollection,HTMLFormControlsCollection,HTMLOptionsCollection,HTMLPropertiesCollection,DOMTokenList,DOMSettableTokenList,DOMStringMap,RadioNodeList,SVGDocument,SVGElement,SVGAElement,SVGAltGlyphElement,SVGAltGlyphDefElement,SVGAltGlyphItemElement,SVGAnimationElement,SVGAnimateElement,SVGAnimateColorElement,SVGAnimateMotionElement,SVGAnimateTransformElement,SVGSetElement,SVGCircleElement,SVGClipPathElement,SVGColorProfileElement,SVGCursorElement,SVGDefsElement,SVGDescElement,SVGEllipseElement,SVGFilterElement,SVGFilterPrimitiveStandardAttributes,SVGFEBlendElement,SVGFEColorMatrixElement,SVGFEComponentTransferElement,SVGFECompositeElement,SVGFEConvolveMatrixElement,SVGFEDiffuseLightingElement,SVGFEDisplacementMapElement,SVGFEDistantLightElement,SVGFEFloodElement,SVGFEGaussianBlurElement,SVGFEImageElement,SVGFEMergeElement,SVGFEMergeNodeElement,SVGFEMorphologyElement,SVGFEOffsetElement,SVGFEPointLightElement,SVGFESpecularLightingElement,SVGFESpotLightElement,SVGFETileElement,SVGFETurbulenceElement,SVGComponentTransferFunctionElement,SVGFEFuncRElement,SVGFEFuncGElement,SVGFEFuncBElement,SVGFEFuncAElement,SVGFontElement,SVGFontFaceElement,SVGFontFaceFormatElement,SVGFontFaceNameElement,SVGFontFaceSrcElement,SVGFontFaceUriElement,SVGForeignObjectElement,SVGGElement,SVGGlyphElement,SVGGlyphRefElement,SVGGradientElement,SVGLinearGradientElement,SVGRadialGradientElement,SVGHKernElement,SVGImageElement,SVGLineElement,SVGMarkerElement,SVGMaskElement,SVGMetadataElement,SVGMissingGlyphElement,SVGMPathElement,SVGPathElement,SVGPatternElement,SVGPolylineElement,SVGPolygonElement,SVGRectElement,SVGScriptElement,SVGStopElement,SVGStyleElement,SVGSVGElement,SVGSwitchElement,SVGSymbolElement,SVGTextElement,SVGTextPathElement,SVGTitleElement,SVGTRefElement,SVGTSpanElement,SVGUseElement,SVGViewElement,SVGVKernElement,SVGAngle,SVGColor,SVGICCColor,SVGElementInstance,SVGElementInstanceList,SVGLength,SVGLengthList,SVGMatrix,SVGNumber,SVGNumberList,SVGPaint,SVGPoint,SVGPointList,SVGPreserveAspectRatio,SVGRect,SVGStringList,SVGTransform,SVGTransformList,SVGAnimatedAngle,SVGAnimatedBoolean,SVGAnimatedEnumeration,SVGAnimatedInteger,SVGAnimatedLength,SVGAnimatedLengthList,SVGAnimatedNumber,SVGAnimatedNumberList,SVGAnimatedPreserveAspectRatio,SVGAnimatedRect,SVGAnimatedString,SVGAnimatedTransformList,SVGPathSegList,SVGPathSeg,SVGPathSegArcAbs,SVGPathSegArcRel,SVGPathSegClosePath,SVGPathSegCurvetoCubicAbs,SVGPathSegCurvetoCubicRel,SVGPathSegCurvetoCubicSmoothAbs,SVGPathSegCurvetoCubicSmoothRel,SVGPathSegCurvetoQuadraticAbs,SVGPathSegCurvetoQuadraticRel,SVGPathSegCurvetoQuadraticSmoothAbs,SVGPathSegCurvetoQuadraticSmoothRel,SVGPathSegLinetoAbs,SVGPathSegLinetoHorizontalAbs,SVGPathSegLinetoHorizontalRel,SVGPathSegLinetoRel,SVGPathSegLinetoVerticalAbs,SVGPathSegLinetoVerticalRel,SVGPathSegMovetoAbs,SVGPathSegMovetoRel,ElementTimeControl,TimeEvent,SVGAnimatedPathData,SVGAnimatedPoints,SVGColorProfileRule,SVGCSSRule,SVGExternalResourcesRequired,SVGFitToViewBox,SVGLangSpace,SVGLocatable,SVGRenderingIntent,SVGStylable,SVGTests,SVGTextContentElement,SVGTextPositioningElement,SVGTransformable,SVGUnitTypes,SVGURIReference,SVGViewSpec,SVGZoomAndPan");
+Blockly.JavaScript.ORDER_ATOMIC=0;Blockly.JavaScript.ORDER_NEW=1.1;Blockly.JavaScript.ORDER_MEMBER=1.2;Blockly.JavaScript.ORDER_FUNCTION_CALL=2;Blockly.JavaScript.ORDER_INCREMENT=3;Blockly.JavaScript.ORDER_DECREMENT=3;Blockly.JavaScript.ORDER_BITWISE_NOT=4.1;Blockly.JavaScript.ORDER_UNARY_PLUS=4.2;Blockly.JavaScript.ORDER_UNARY_NEGATION=4.3;Blockly.JavaScript.ORDER_LOGICAL_NOT=4.4;Blockly.JavaScript.ORDER_TYPEOF=4.5;Blockly.JavaScript.ORDER_VOID=4.6;Blockly.JavaScript.ORDER_DELETE=4.7;
+Blockly.JavaScript.ORDER_AWAIT=4.8;Blockly.JavaScript.ORDER_EXPONENTIATION=5;Blockly.JavaScript.ORDER_MULTIPLICATION=5.1;Blockly.JavaScript.ORDER_DIVISION=5.2;Blockly.JavaScript.ORDER_MODULUS=5.3;Blockly.JavaScript.ORDER_SUBTRACTION=6.1;Blockly.JavaScript.ORDER_ADDITION=6.2;Blockly.JavaScript.ORDER_BITWISE_SHIFT=7;Blockly.JavaScript.ORDER_RELATIONAL=8;Blockly.JavaScript.ORDER_IN=8;Blockly.JavaScript.ORDER_INSTANCEOF=8;Blockly.JavaScript.ORDER_EQUALITY=9;Blockly.JavaScript.ORDER_BITWISE_AND=10;
+Blockly.JavaScript.ORDER_BITWISE_XOR=11;Blockly.JavaScript.ORDER_BITWISE_OR=12;Blockly.JavaScript.ORDER_LOGICAL_AND=13;Blockly.JavaScript.ORDER_LOGICAL_OR=14;Blockly.JavaScript.ORDER_CONDITIONAL=15;Blockly.JavaScript.ORDER_ASSIGNMENT=16;Blockly.JavaScript.ORDER_YIELD=17;Blockly.JavaScript.ORDER_COMMA=18;Blockly.JavaScript.ORDER_NONE=99;
+Blockly.JavaScript.ORDER_OVERRIDES=[[Blockly.JavaScript.ORDER_FUNCTION_CALL,Blockly.JavaScript.ORDER_MEMBER],[Blockly.JavaScript.ORDER_FUNCTION_CALL,Blockly.JavaScript.ORDER_FUNCTION_CALL],[Blockly.JavaScript.ORDER_MEMBER,Blockly.JavaScript.ORDER_MEMBER],[Blockly.JavaScript.ORDER_MEMBER,Blockly.JavaScript.ORDER_FUNCTION_CALL],[Blockly.JavaScript.ORDER_LOGICAL_NOT,Blockly.JavaScript.ORDER_LOGICAL_NOT],[Blockly.JavaScript.ORDER_MULTIPLICATION,Blockly.JavaScript.ORDER_MULTIPLICATION],[Blockly.JavaScript.ORDER_ADDITION,
+Blockly.JavaScript.ORDER_ADDITION],[Blockly.JavaScript.ORDER_LOGICAL_AND,Blockly.JavaScript.ORDER_LOGICAL_AND],[Blockly.JavaScript.ORDER_LOGICAL_OR,Blockly.JavaScript.ORDER_LOGICAL_OR]];
+Blockly.JavaScript.init=function(a){Blockly.JavaScript.definitions_=Object.create(null);Blockly.JavaScript.functionNames_=Object.create(null);Blockly.JavaScript.variableDB_?Blockly.JavaScript.variableDB_.reset():Blockly.JavaScript.variableDB_=new Blockly.Names(Blockly.JavaScript.RESERVED_WORDS_);Blockly.JavaScript.variableDB_.setVariableMap(a.getVariableMap());for(var b=[],c=Blockly.Variables.allDeveloperVariables(a),d=0;d<c.length;d++)b.push(Blockly.JavaScript.variableDB_.getName(c[d],Blockly.Names.DEVELOPER_VARIABLE_TYPE));
+a=Blockly.Variables.allUsedVarModels(a);for(d=0;d<a.length;d++)b.push(Blockly.JavaScript.variableDB_.getName(a[d].getId(),Blockly.Variables.NAME_TYPE));b.length&&(Blockly.JavaScript.definitions_.variables="var "+b.join(", ")+";")};
+Blockly.JavaScript.finish=function(a){var b=[],c;for(c in Blockly.JavaScript.definitions_)b.push(Blockly.JavaScript.definitions_[c]);delete Blockly.JavaScript.definitions_;delete Blockly.JavaScript.functionNames_;Blockly.JavaScript.variableDB_.reset();return b.join("\n\n")+"\n\n\n"+a};Blockly.JavaScript.scrubNakedValue=function(a){return a+";\n"};Blockly.JavaScript.quote_=function(a){a=a.replace(/\\/g,"\\\\").replace(/\n/g,"\\\n").replace(/'/g,"\\'");return"'"+a+"'"};
+Blockly.JavaScript.scrub_=function(a,b,c){var d="";if(!a.outputConnection||!a.outputConnection.targetConnection){var e=a.getCommentText();(e=Blockly.utils.wrap(e,Blockly.JavaScript.COMMENT_WRAP-3))&&(d=a.getProcedureDef?d+("/**\n"+Blockly.JavaScript.prefixLines(e+"\n"," * ")+" */\n"):d+Blockly.JavaScript.prefixLines(e+"\n","// "));for(var f=0;f<a.inputList.length;f++)a.inputList[f].type==Blockly.INPUT_VALUE&&(e=a.inputList[f].connection.targetBlock())&&(e=Blockly.JavaScript.allNestedComments(e))&&
+(d+=Blockly.JavaScript.prefixLines(e,"// "))}a=a.nextConnection&&a.nextConnection.targetBlock();c=c?"":Blockly.JavaScript.blockToCode(a);return d+b+c};
+Blockly.JavaScript.getAdjusted=function(a,b,c,d,e){c=c||0;e=e||Blockly.JavaScript.ORDER_NONE;a.workspace.options.oneBasedIndex&&c--;var f=a.workspace.options.oneBasedIndex?"1":"0";a=0<c?Blockly.JavaScript.valueToCode(a,b,Blockly.JavaScript.ORDER_ADDITION)||f:0>c?Blockly.JavaScript.valueToCode(a,b,Blockly.JavaScript.ORDER_SUBTRACTION)||f:d?Blockly.JavaScript.valueToCode(a,b,Blockly.JavaScript.ORDER_UNARY_NEGATION)||f:Blockly.JavaScript.valueToCode(a,b,e)||f;if(Blockly.isNumber(a))a=parseFloat(a)+c,
+d&&(a=-a);else{if(0<c){a=a+" + "+c;var g=Blockly.JavaScript.ORDER_ADDITION}else 0>c&&(a=a+" - "+-c,g=Blockly.JavaScript.ORDER_SUBTRACTION);d&&(a=c?"-("+a+")":"-"+a,g=Blockly.JavaScript.ORDER_UNARY_NEGATION);g=Math.floor(g);e=Math.floor(e);g&&e>=g&&(a="("+a+")")}return a};Blockly.JavaScript.colour={};Blockly.JavaScript.colour_picker=function(a){return["'"+a.getFieldValue("COLOUR")+"'",Blockly.JavaScript.ORDER_ATOMIC]};Blockly.JavaScript.colour_random=function(a){return[Blockly.JavaScript.provideFunction_("colourRandom",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"() {","  var num = Math.floor(Math.random() * Math.pow(2, 24));","  return '#' + ('00000' + num.toString(16)).substr(-6);","}"])+"()",Blockly.JavaScript.ORDER_FUNCTION_CALL]};
+Blockly.JavaScript.colour_rgb=function(a){var b=Blockly.JavaScript.valueToCode(a,"RED",Blockly.JavaScript.ORDER_COMMA)||0,c=Blockly.JavaScript.valueToCode(a,"GREEN",Blockly.JavaScript.ORDER_COMMA)||0;a=Blockly.JavaScript.valueToCode(a,"BLUE",Blockly.JavaScript.ORDER_COMMA)||0;return[Blockly.JavaScript.provideFunction_("colourRgb",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(r, g, b) {","  r = Math.max(Math.min(Number(r), 100), 0) * 2.55;","  g = Math.max(Math.min(Number(g), 100), 0) * 2.55;",
+"  b = Math.max(Math.min(Number(b), 100), 0) * 2.55;","  r = ('0' + (Math.round(r) || 0).toString(16)).slice(-2);","  g = ('0' + (Math.round(g) || 0).toString(16)).slice(-2);","  b = ('0' + (Math.round(b) || 0).toString(16)).slice(-2);","  return '#' + r + g + b;","}"])+"("+b+", "+c+", "+a+")",Blockly.JavaScript.ORDER_FUNCTION_CALL]};
+Blockly.JavaScript.colour_blend=function(a){var b=Blockly.JavaScript.valueToCode(a,"COLOUR1",Blockly.JavaScript.ORDER_COMMA)||"'#000000'",c=Blockly.JavaScript.valueToCode(a,"COLOUR2",Blockly.JavaScript.ORDER_COMMA)||"'#000000'";a=Blockly.JavaScript.valueToCode(a,"RATIO",Blockly.JavaScript.ORDER_COMMA)||.5;return[Blockly.JavaScript.provideFunction_("colourBlend",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(c1, c2, ratio) {","  ratio = Math.max(Math.min(Number(ratio), 1), 0);","  var r1 = parseInt(c1.substring(1, 3), 16);",
+"  var g1 = parseInt(c1.substring(3, 5), 16);","  var b1 = parseInt(c1.substring(5, 7), 16);","  var r2 = parseInt(c2.substring(1, 3), 16);","  var g2 = parseInt(c2.substring(3, 5), 16);","  var b2 = parseInt(c2.substring(5, 7), 16);","  var r = Math.round(r1 * (1 - ratio) + r2 * ratio);","  var g = Math.round(g1 * (1 - ratio) + g2 * ratio);","  var b = Math.round(b1 * (1 - ratio) + b2 * ratio);","  r = ('0' + (r || 0).toString(16)).slice(-2);","  g = ('0' + (g || 0).toString(16)).slice(-2);","  b = ('0' + (b || 0).toString(16)).slice(-2);",
+"  return '#' + r + g + b;","}"])+"("+b+", "+c+", "+a+")",Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.lists={};Blockly.JavaScript.lists_create_empty=function(a){return["[]",Blockly.JavaScript.ORDER_ATOMIC]};Blockly.JavaScript.lists_create_with=function(a){for(var b=Array(a.itemCount_),c=0;c<a.itemCount_;c++)b[c]=Blockly.JavaScript.valueToCode(a,"ADD"+c,Blockly.JavaScript.ORDER_COMMA)||"null";return["["+b.join(", ")+"]",Blockly.JavaScript.ORDER_ATOMIC]};
+Blockly.JavaScript.lists_repeat=function(a){var b=Blockly.JavaScript.provideFunction_("listsRepeat",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(value, n) {","  var array = [];","  for (var i = 0; i < n; i++) {","    array[i] = value;","  }","  return array;","}"]),c=Blockly.JavaScript.valueToCode(a,"ITEM",Blockly.JavaScript.ORDER_COMMA)||"null";a=Blockly.JavaScript.valueToCode(a,"NUM",Blockly.JavaScript.ORDER_COMMA)||"0";return[b+"("+c+", "+a+")",Blockly.JavaScript.ORDER_FUNCTION_CALL]};
+Blockly.JavaScript.lists_length=function(a){return[(Blockly.JavaScript.valueToCode(a,"VALUE",Blockly.JavaScript.ORDER_MEMBER)||"[]")+".length",Blockly.JavaScript.ORDER_MEMBER]};Blockly.JavaScript.lists_isEmpty=function(a){return["!"+(Blockly.JavaScript.valueToCode(a,"VALUE",Blockly.JavaScript.ORDER_MEMBER)||"[]")+".length",Blockly.JavaScript.ORDER_LOGICAL_NOT]};
+Blockly.JavaScript.lists_indexOf=function(a){var b="FIRST"==a.getFieldValue("END")?"indexOf":"lastIndexOf",c=Blockly.JavaScript.valueToCode(a,"FIND",Blockly.JavaScript.ORDER_NONE)||"''";b=(Blockly.JavaScript.valueToCode(a,"VALUE",Blockly.JavaScript.ORDER_MEMBER)||"[]")+"."+b+"("+c+")";return a.workspace.options.oneBasedIndex?[b+" + 1",Blockly.JavaScript.ORDER_ADDITION]:[b,Blockly.JavaScript.ORDER_FUNCTION_CALL]};
+Blockly.JavaScript.lists_getIndex=function(a){var b=a.getFieldValue("MODE")||"GET",c=a.getFieldValue("WHERE")||"FROM_START",d=Blockly.JavaScript.valueToCode(a,"VALUE","RANDOM"==c?Blockly.JavaScript.ORDER_COMMA:Blockly.JavaScript.ORDER_MEMBER)||"[]";switch(c){case "FIRST":if("GET"==b)return[d+"[0]",Blockly.JavaScript.ORDER_MEMBER];if("GET_REMOVE"==b)return[d+".shift()",Blockly.JavaScript.ORDER_MEMBER];if("REMOVE"==b)return d+".shift();\n";break;case "LAST":if("GET"==b)return[d+".slice(-1)[0]",Blockly.JavaScript.ORDER_MEMBER];
+if("GET_REMOVE"==b)return[d+".pop()",Blockly.JavaScript.ORDER_MEMBER];if("REMOVE"==b)return d+".pop();\n";break;case "FROM_START":a=Blockly.JavaScript.getAdjusted(a,"AT");if("GET"==b)return[d+"["+a+"]",Blockly.JavaScript.ORDER_MEMBER];if("GET_REMOVE"==b)return[d+".splice("+a+", 1)[0]",Blockly.JavaScript.ORDER_FUNCTION_CALL];if("REMOVE"==b)return d+".splice("+a+", 1);\n";break;case "FROM_END":a=Blockly.JavaScript.getAdjusted(a,"AT",1,!0);if("GET"==b)return[d+".slice("+a+")[0]",Blockly.JavaScript.ORDER_FUNCTION_CALL];
+if("GET_REMOVE"==b)return[d+".splice("+a+", 1)[0]",Blockly.JavaScript.ORDER_FUNCTION_CALL];if("REMOVE"==b)return d+".splice("+a+", 1);";break;case "RANDOM":d=Blockly.JavaScript.provideFunction_("listsGetRandomItem",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(list, remove) {","  var x = Math.floor(Math.random() * list.length);","  if (remove) {","    return list.splice(x, 1)[0];","  } else {","    return list[x];","  }","}"])+"("+d+", "+("GET"!=b)+")";if("GET"==b||"GET_REMOVE"==b)return[d,
+Blockly.JavaScript.ORDER_FUNCTION_CALL];if("REMOVE"==b)return d+";\n"}throw Error("Unhandled combination (lists_getIndex).");};
+Blockly.JavaScript.lists_setIndex=function(a){function b(){if(c.match(/^\w+$/))return"";var a=Blockly.JavaScript.variableDB_.getDistinctName("tmpList",Blockly.Variables.NAME_TYPE),b="var "+a+" = "+c+";\n";c=a;return b}var c=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_MEMBER)||"[]",d=a.getFieldValue("MODE")||"GET",e=a.getFieldValue("WHERE")||"FROM_START",f=Blockly.JavaScript.valueToCode(a,"TO",Blockly.JavaScript.ORDER_ASSIGNMENT)||"null";switch(e){case "FIRST":if("SET"==d)return c+
+"[0] = "+f+";\n";if("INSERT"==d)return c+".unshift("+f+");\n";break;case "LAST":if("SET"==d)return a=b(),a+(c+"["+c+".length - 1] = "+f+";\n");if("INSERT"==d)return c+".push("+f+");\n";break;case "FROM_START":e=Blockly.JavaScript.getAdjusted(a,"AT");if("SET"==d)return c+"["+e+"] = "+f+";\n";if("INSERT"==d)return c+".splice("+e+", 0, "+f+");\n";break;case "FROM_END":e=Blockly.JavaScript.getAdjusted(a,"AT",1,!1,Blockly.JavaScript.ORDER_SUBTRACTION);a=b();if("SET"==d)return a+(c+"["+c+".length - "+e+
+"] = "+f+";\n");if("INSERT"==d)return a+(c+".splice("+c+".length - "+e+", 0, "+f+");\n");break;case "RANDOM":a=b();e=Blockly.JavaScript.variableDB_.getDistinctName("tmpX",Blockly.Variables.NAME_TYPE);a+="var "+e+" = Math.floor(Math.random() * "+c+".length);\n";if("SET"==d)return a+(c+"["+e+"] = "+f+";\n");if("INSERT"==d)return a+(c+".splice("+e+", 0, "+f+");\n")}throw Error("Unhandled combination (lists_setIndex).");};
+Blockly.JavaScript.lists.getIndex_=function(a,b,c){return"FIRST"==b?"0":"FROM_END"==b?a+".length - 1 - "+c:"LAST"==b?a+".length - 1":c};
+Blockly.JavaScript.lists_getSublist=function(a){var b=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_MEMBER)||"[]",c=a.getFieldValue("WHERE1"),d=a.getFieldValue("WHERE2");if("FIRST"==c&&"LAST"==d)b+=".slice(0)";else if(b.match(/^\w+$/)||"FROM_END"!=c&&"FROM_START"==d){switch(c){case "FROM_START":var e=Blockly.JavaScript.getAdjusted(a,"AT1");break;case "FROM_END":e=Blockly.JavaScript.getAdjusted(a,"AT1",1,!1,Blockly.JavaScript.ORDER_SUBTRACTION);e=b+".length - "+e;break;case "FIRST":e=
+"0";break;default:throw Error("Unhandled option (lists_getSublist).");}switch(d){case "FROM_START":a=Blockly.JavaScript.getAdjusted(a,"AT2",1);break;case "FROM_END":a=Blockly.JavaScript.getAdjusted(a,"AT2",0,!1,Blockly.JavaScript.ORDER_SUBTRACTION);a=b+".length - "+a;break;case "LAST":a=b+".length";break;default:throw Error("Unhandled option (lists_getSublist).");}b=b+".slice("+e+", "+a+")"}else{e=Blockly.JavaScript.getAdjusted(a,"AT1");a=Blockly.JavaScript.getAdjusted(a,"AT2");var f=Blockly.JavaScript.lists.getIndex_,
+g={FIRST:"First",LAST:"Last",FROM_START:"FromStart",FROM_END:"FromEnd"};b=Blockly.JavaScript.provideFunction_("subsequence"+g[c]+g[d],["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(sequence"+("FROM_END"==c||"FROM_START"==c?", at1":"")+("FROM_END"==d||"FROM_START"==d?", at2":"")+") {","  var start = "+f("sequence",c,"at1")+";","  var end = "+f("sequence",d,"at2")+" + 1;","  return sequence.slice(start, end);","}"])+"("+b+("FROM_END"==c||"FROM_START"==c?", "+e:"")+("FROM_END"==d||"FROM_START"==
+d?", "+a:"")+")"}return[b,Blockly.JavaScript.ORDER_FUNCTION_CALL]};
+Blockly.JavaScript.lists_sort=function(a){var b=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_FUNCTION_CALL)||"[]",c="1"===a.getFieldValue("DIRECTION")?1:-1;a=a.getFieldValue("TYPE");var d=Blockly.JavaScript.provideFunction_("listsGetSortCompare",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(type, direction) {","  var compareFuncs = {",'    "NUMERIC": function(a, b) {',"        return parseFloat(a) - parseFloat(b); },",'    "TEXT": function(a, b) {',"        return a.toString() > b.toString() ? 1 : -1; },",
+'    "IGNORE_CASE": function(a, b) {',"        return a.toString().toLowerCase() > b.toString().toLowerCase() ? 1 : -1; },","  };","  var compare = compareFuncs[type];","  return function(a, b) { return compare(a, b) * direction; }","}"]);return[b+".slice().sort("+d+'("'+a+'", '+c+"))",Blockly.JavaScript.ORDER_FUNCTION_CALL]};
+Blockly.JavaScript.lists_split=function(a){var b=Blockly.JavaScript.valueToCode(a,"INPUT",Blockly.JavaScript.ORDER_MEMBER),c=Blockly.JavaScript.valueToCode(a,"DELIM",Blockly.JavaScript.ORDER_NONE)||"''";a=a.getFieldValue("MODE");if("SPLIT"==a)b||(b="''"),a="split";else if("JOIN"==a)b||(b="[]"),a="join";else throw Error("Unknown mode: "+a);return[b+"."+a+"("+c+")",Blockly.JavaScript.ORDER_FUNCTION_CALL]};
+Blockly.JavaScript.lists_reverse=function(a){return[(Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_FUNCTION_CALL)||"[]")+".slice().reverse()",Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.logic={};Blockly.JavaScript.controls_if=function(a){var b=0,c="";do{var d=Blockly.JavaScript.valueToCode(a,"IF"+b,Blockly.JavaScript.ORDER_NONE)||"false";var e=Blockly.JavaScript.statementToCode(a,"DO"+b);c+=(0<b?" else ":"")+"if ("+d+") {\n"+e+"}";++b}while(a.getInput("IF"+b));a.getInput("ELSE")&&(e=Blockly.JavaScript.statementToCode(a,"ELSE"),c+=" else {\n"+e+"}");return c+"\n"};Blockly.JavaScript.controls_ifelse=Blockly.JavaScript.controls_if;
+Blockly.JavaScript.logic_compare=function(a){var b={EQ:"==",NEQ:"!=",LT:"<",LTE:"<=",GT:">",GTE:">="}[a.getFieldValue("OP")],c="=="==b||"!="==b?Blockly.JavaScript.ORDER_EQUALITY:Blockly.JavaScript.ORDER_RELATIONAL,d=Blockly.JavaScript.valueToCode(a,"A",c)||"0";a=Blockly.JavaScript.valueToCode(a,"B",c)||"0";return[d+" "+b+" "+a,c]};
+Blockly.JavaScript.logic_operation=function(a){var b="AND"==a.getFieldValue("OP")?"&&":"||",c="&&"==b?Blockly.JavaScript.ORDER_LOGICAL_AND:Blockly.JavaScript.ORDER_LOGICAL_OR,d=Blockly.JavaScript.valueToCode(a,"A",c);a=Blockly.JavaScript.valueToCode(a,"B",c);if(d||a){var e="&&"==b?"true":"false";d||(d=e);a||(a=e)}else a=d="false";return[d+" "+b+" "+a,c]};
+Blockly.JavaScript.logic_negate=function(a){var b=Blockly.JavaScript.ORDER_LOGICAL_NOT;return["!"+(Blockly.JavaScript.valueToCode(a,"BOOL",b)||"true"),b]};Blockly.JavaScript.logic_boolean=function(a){return["TRUE"==a.getFieldValue("BOOL")?"true":"false",Blockly.JavaScript.ORDER_ATOMIC]};Blockly.JavaScript.logic_null=function(a){return["null",Blockly.JavaScript.ORDER_ATOMIC]};
+Blockly.JavaScript.logic_ternary=function(a){var b=Blockly.JavaScript.valueToCode(a,"IF",Blockly.JavaScript.ORDER_CONDITIONAL)||"false",c=Blockly.JavaScript.valueToCode(a,"THEN",Blockly.JavaScript.ORDER_CONDITIONAL)||"null";a=Blockly.JavaScript.valueToCode(a,"ELSE",Blockly.JavaScript.ORDER_CONDITIONAL)||"null";return[b+" ? "+c+" : "+a,Blockly.JavaScript.ORDER_CONDITIONAL]};Blockly.JavaScript.loops={};
+Blockly.JavaScript.controls_repeat_ext=function(a){var b=a.getField("TIMES")?String(Number(a.getFieldValue("TIMES"))):Blockly.JavaScript.valueToCode(a,"TIMES",Blockly.JavaScript.ORDER_ASSIGNMENT)||"0",c=Blockly.JavaScript.statementToCode(a,"DO");c=Blockly.JavaScript.addLoopTrap(c,a.id);a="";var d=Blockly.JavaScript.variableDB_.getDistinctName("count",Blockly.Variables.NAME_TYPE),e=b;b.match(/^\w+$/)||Blockly.isNumber(b)||(e=Blockly.JavaScript.variableDB_.getDistinctName("repeat_end",Blockly.Variables.NAME_TYPE),
+a+="var "+e+" = "+b+";\n");return a+("for (var "+d+" = 0; "+d+" < "+e+"; "+d+"++) {\n"+c+"}\n")};Blockly.JavaScript.controls_repeat=Blockly.JavaScript.controls_repeat_ext;
+Blockly.JavaScript.controls_whileUntil=function(a){var b="UNTIL"==a.getFieldValue("MODE"),c=Blockly.JavaScript.valueToCode(a,"BOOL",b?Blockly.JavaScript.ORDER_LOGICAL_NOT:Blockly.JavaScript.ORDER_NONE)||"false",d=Blockly.JavaScript.statementToCode(a,"DO");d=Blockly.JavaScript.addLoopTrap(d,a.id);b&&(c="!"+c);return"while ("+c+") {\n"+d+"}\n"};
+Blockly.JavaScript.controls_for=function(a){var b=Blockly.JavaScript.variableDB_.getName(a.getFieldValue("VAR"),Blockly.Variables.NAME_TYPE),c=Blockly.JavaScript.valueToCode(a,"FROM",Blockly.JavaScript.ORDER_ASSIGNMENT)||"0",d=Blockly.JavaScript.valueToCode(a,"TO",Blockly.JavaScript.ORDER_ASSIGNMENT)||"0",e=Blockly.JavaScript.valueToCode(a,"BY",Blockly.JavaScript.ORDER_ASSIGNMENT)||"1",f=Blockly.JavaScript.statementToCode(a,"DO");f=Blockly.JavaScript.addLoopTrap(f,a.id);if(Blockly.isNumber(c)&&Blockly.isNumber(d)&&
+Blockly.isNumber(e)){var g=parseFloat(c)<=parseFloat(d);a="for ("+b+" = "+c+"; "+b+(g?" <= ":" >= ")+d+"; "+b;b=Math.abs(parseFloat(e));a=(1==b?a+(g?"++":"--"):a+((g?" += ":" -= ")+b))+(") {\n"+f+"}\n")}else a="",g=c,c.match(/^\w+$/)||Blockly.isNumber(c)||(g=Blockly.JavaScript.variableDB_.getDistinctName(b+"_start",Blockly.Variables.NAME_TYPE),a+="var "+g+" = "+c+";\n"),c=d,d.match(/^\w+$/)||Blockly.isNumber(d)||(c=Blockly.JavaScript.variableDB_.getDistinctName(b+"_end",Blockly.Variables.NAME_TYPE),
+a+="var "+c+" = "+d+";\n"),d=Blockly.JavaScript.variableDB_.getDistinctName(b+"_inc",Blockly.Variables.NAME_TYPE),a+="var "+d+" = ",a=Blockly.isNumber(e)?a+(Math.abs(e)+";\n"):a+("Math.abs("+e+");\n"),a=a+("if ("+g+" > "+c+") {\n")+(Blockly.JavaScript.INDENT+d+" = -"+d+";\n"),a+="}\n",a+="for ("+b+" = "+g+"; "+d+" >= 0 ? "+b+" <= "+c+" : "+b+" >= "+c+"; "+b+" += "+d+") {\n"+f+"}\n";return a};
+Blockly.JavaScript.controls_forEach=function(a){var b=Blockly.JavaScript.variableDB_.getName(a.getFieldValue("VAR"),Blockly.Variables.NAME_TYPE),c=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_ASSIGNMENT)||"[]",d=Blockly.JavaScript.statementToCode(a,"DO");d=Blockly.JavaScript.addLoopTrap(d,a.id);a="";var e=c;c.match(/^\w+$/)||(e=Blockly.JavaScript.variableDB_.getDistinctName(b+"_list",Blockly.Variables.NAME_TYPE),a+="var "+e+" = "+c+";\n");c=Blockly.JavaScript.variableDB_.getDistinctName(b+
+"_index",Blockly.Variables.NAME_TYPE);d=Blockly.JavaScript.INDENT+b+" = "+e+"["+c+"];\n"+d;return a+("for (var "+c+" in "+e+") {\n"+d+"}\n")};Blockly.JavaScript.controls_flow_statements=function(a){switch(a.getFieldValue("FLOW")){case "BREAK":return"break;\n";case "CONTINUE":return"continue;\n"}throw Error("Unknown flow statement.");};Blockly.JavaScript.math={};Blockly.JavaScript.math_number=function(a){a=parseFloat(a.getFieldValue("NUM"));return[a,0<=a?Blockly.JavaScript.ORDER_ATOMIC:Blockly.JavaScript.ORDER_UNARY_NEGATION]};
+Blockly.JavaScript.math_arithmetic=function(a){var b={ADD:[" + ",Blockly.JavaScript.ORDER_ADDITION],MINUS:[" - ",Blockly.JavaScript.ORDER_SUBTRACTION],MULTIPLY:[" * ",Blockly.JavaScript.ORDER_MULTIPLICATION],DIVIDE:[" / ",Blockly.JavaScript.ORDER_DIVISION],POWER:[null,Blockly.JavaScript.ORDER_COMMA]}[a.getFieldValue("OP")],c=b[0];b=b[1];var d=Blockly.JavaScript.valueToCode(a,"A",b)||"0";a=Blockly.JavaScript.valueToCode(a,"B",b)||"0";return c?[d+c+a,b]:["Math.pow("+d+", "+a+")",Blockly.JavaScript.ORDER_FUNCTION_CALL]};
+Blockly.JavaScript.math_single=function(a){var b=a.getFieldValue("OP");if("NEG"==b)return a=Blockly.JavaScript.valueToCode(a,"NUM",Blockly.JavaScript.ORDER_UNARY_NEGATION)||"0","-"==a[0]&&(a=" "+a),["-"+a,Blockly.JavaScript.ORDER_UNARY_NEGATION];a="SIN"==b||"COS"==b||"TAN"==b?Blockly.JavaScript.valueToCode(a,"NUM",Blockly.JavaScript.ORDER_DIVISION)||"0":Blockly.JavaScript.valueToCode(a,"NUM",Blockly.JavaScript.ORDER_NONE)||"0";switch(b){case "ABS":var c="Math.abs("+a+")";break;case "ROOT":c="Math.sqrt("+
+a+")";break;case "LN":c="Math.log("+a+")";break;case "EXP":c="Math.exp("+a+")";break;case "POW10":c="Math.pow(10,"+a+")";break;case "ROUND":c="Math.round("+a+")";break;case "ROUNDUP":c="Math.ceil("+a+")";break;case "ROUNDDOWN":c="Math.floor("+a+")";break;case "SIN":c="Math.sin("+a+" / 180 * Math.PI)";break;case "COS":c="Math.cos("+a+" / 180 * Math.PI)";break;case "TAN":c="Math.tan("+a+" / 180 * Math.PI)"}if(c)return[c,Blockly.JavaScript.ORDER_FUNCTION_CALL];switch(b){case "LOG10":c="Math.log("+a+
+") / Math.log(10)";break;case "ASIN":c="Math.asin("+a+") / Math.PI * 180";break;case "ACOS":c="Math.acos("+a+") / Math.PI * 180";break;case "ATAN":c="Math.atan("+a+") / Math.PI * 180";break;default:throw Error("Unknown math operator: "+b);}return[c,Blockly.JavaScript.ORDER_DIVISION]};
+Blockly.JavaScript.math_constant=function(a){return{PI:["Math.PI",Blockly.JavaScript.ORDER_MEMBER],E:["Math.E",Blockly.JavaScript.ORDER_MEMBER],GOLDEN_RATIO:["(1 + Math.sqrt(5)) / 2",Blockly.JavaScript.ORDER_DIVISION],SQRT2:["Math.SQRT2",Blockly.JavaScript.ORDER_MEMBER],SQRT1_2:["Math.SQRT1_2",Blockly.JavaScript.ORDER_MEMBER],INFINITY:["Infinity",Blockly.JavaScript.ORDER_ATOMIC]}[a.getFieldValue("CONSTANT")]};
+Blockly.JavaScript.math_number_property=function(a){var b=Blockly.JavaScript.valueToCode(a,"NUMBER_TO_CHECK",Blockly.JavaScript.ORDER_MODULUS)||"0",c=a.getFieldValue("PROPERTY");if("PRIME"==c)return[Blockly.JavaScript.provideFunction_("mathIsPrime",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(n) {","  // https://en.wikipedia.org/wiki/Primality_test#Naive_methods","  if (n == 2 || n == 3) {","    return true;","  }","  // False if n is NaN, negative, is 1, or not whole.","  // And false if n is divisible by 2 or 3.",
+"  if (isNaN(n) || n <= 1 || n % 1 != 0 || n % 2 == 0 || n % 3 == 0) {","    return false;","  }","  // Check all the numbers of form 6k +/- 1, up to sqrt(n).","  for (var x = 6; x <= Math.sqrt(n) + 1; x += 6) {","    if (n % (x - 1) == 0 || n % (x + 1) == 0) {","      return false;","    }","  }","  return true;","}"])+"("+b+")",Blockly.JavaScript.ORDER_FUNCTION_CALL];switch(c){case "EVEN":var d=b+" % 2 == 0";break;case "ODD":d=b+" % 2 == 1";break;case "WHOLE":d=b+" % 1 == 0";break;case "POSITIVE":d=
+b+" > 0";break;case "NEGATIVE":d=b+" < 0";break;case "DIVISIBLE_BY":a=Blockly.JavaScript.valueToCode(a,"DIVISOR",Blockly.JavaScript.ORDER_MODULUS)||"0",d=b+" % "+a+" == 0"}return[d,Blockly.JavaScript.ORDER_EQUALITY]};Blockly.JavaScript.math_change=function(a){var b=Blockly.JavaScript.valueToCode(a,"DELTA",Blockly.JavaScript.ORDER_ADDITION)||"0";a=Blockly.JavaScript.variableDB_.getName(a.getFieldValue("VAR"),Blockly.Variables.NAME_TYPE);return a+" = (typeof "+a+" == 'number' ? "+a+" : 0) + "+b+";\n"};
+Blockly.JavaScript.math_round=Blockly.JavaScript.math_single;Blockly.JavaScript.math_trig=Blockly.JavaScript.math_single;
+Blockly.JavaScript.math_on_list=function(a){var b=a.getFieldValue("OP");switch(b){case "SUM":a=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_MEMBER)||"[]";a+=".reduce(function(x, y) {return x + y;})";break;case "MIN":a=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_COMMA)||"[]";a="Math.min.apply(null, "+a+")";break;case "MAX":a=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_COMMA)||"[]";a="Math.max.apply(null, "+a+")";break;case "AVERAGE":b=Blockly.JavaScript.provideFunction_("mathMean",
+["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(myList) {","  return myList.reduce(function(x, y) {return x + y;}) / myList.length;","}"]);a=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_NONE)||"[]";a=b+"("+a+")";break;case "MEDIAN":b=Blockly.JavaScript.provideFunction_("mathMedian",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(myList) {","  var localList = myList.filter(function (x) {return typeof x == 'number';});","  if (!localList.length) return null;",
+"  localList.sort(function(a, b) {return b - a;});","  if (localList.length % 2 == 0) {","    return (localList[localList.length / 2 - 1] + localList[localList.length / 2]) / 2;","  } else {","    return localList[(localList.length - 1) / 2];","  }","}"]);a=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_NONE)||"[]";a=b+"("+a+")";break;case "MODE":b=Blockly.JavaScript.provideFunction_("mathModes",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(values) {","  var modes = [];",
+"  var counts = [];","  var maxCount = 0;","  for (var i = 0; i < values.length; i++) {","    var value = values[i];","    var found = false;","    var thisCount;","    for (var j = 0; j < counts.length; j++) {","      if (counts[j][0] === value) {","        thisCount = ++counts[j][1];","        found = true;","        break;","      }","    }","    if (!found) {","      counts.push([value, 1]);","      thisCount = 1;","    }","    maxCount = Math.max(thisCount, maxCount);","  }","  for (var j = 0; j < counts.length; j++) {",
+"    if (counts[j][1] == maxCount) {","        modes.push(counts[j][0]);","    }","  }","  return modes;","}"]);a=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_NONE)||"[]";a=b+"("+a+")";break;case "STD_DEV":b=Blockly.JavaScript.provideFunction_("mathStandardDeviation",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(numbers) {","  var n = numbers.length;","  if (!n) return null;","  var mean = numbers.reduce(function(x, y) {return x + y;}) / n;","  var variance = 0;",
+"  for (var j = 0; j < n; j++) {","    variance += Math.pow(numbers[j] - mean, 2);","  }","  variance = variance / n;","  return Math.sqrt(variance);","}"]);a=Blockly.JavaScript.valueToCode(a,"LIST",Blockly.JavaScript.ORDER_NONE)||"[]";a=b+"("+a+")";break;case "RANDOM":b=Blockly.JavaScript.provideFunction_("mathRandomList",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(list) {","  var x = Math.floor(Math.random() * list.length);","  return list[x];","}"]);a=Blockly.JavaScript.valueToCode(a,
+"LIST",Blockly.JavaScript.ORDER_NONE)||"[]";a=b+"("+a+")";break;default:throw Error("Unknown operator: "+b);}return[a,Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.math_modulo=function(a){var b=Blockly.JavaScript.valueToCode(a,"DIVIDEND",Blockly.JavaScript.ORDER_MODULUS)||"0";a=Blockly.JavaScript.valueToCode(a,"DIVISOR",Blockly.JavaScript.ORDER_MODULUS)||"0";return[b+" % "+a,Blockly.JavaScript.ORDER_MODULUS]};
+Blockly.JavaScript.math_constrain=function(a){var b=Blockly.JavaScript.valueToCode(a,"VALUE",Blockly.JavaScript.ORDER_COMMA)||"0",c=Blockly.JavaScript.valueToCode(a,"LOW",Blockly.JavaScript.ORDER_COMMA)||"0";a=Blockly.JavaScript.valueToCode(a,"HIGH",Blockly.JavaScript.ORDER_COMMA)||"Infinity";return["Math.min(Math.max("+b+", "+c+"), "+a+")",Blockly.JavaScript.ORDER_FUNCTION_CALL]};
+Blockly.JavaScript.math_random_int=function(a){var b=Blockly.JavaScript.valueToCode(a,"FROM",Blockly.JavaScript.ORDER_COMMA)||"0";a=Blockly.JavaScript.valueToCode(a,"TO",Blockly.JavaScript.ORDER_COMMA)||"0";return[Blockly.JavaScript.provideFunction_("mathRandomInt",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(a, b) {","  if (a > b) {","    // Swap a and b to ensure a is smaller.","    var c = a;","    a = b;","    b = c;","  }","  return Math.floor(Math.random() * (b - a + 1) + a);",
+"}"])+"("+b+", "+a+")",Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.math_random_float=function(a){return["Math.random()",Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.math_atan2=function(a){var b=Blockly.JavaScript.valueToCode(a,"X",Blockly.JavaScript.ORDER_COMMA)||"0";return["Math.atan2("+(Blockly.JavaScript.valueToCode(a,"Y",Blockly.JavaScript.ORDER_COMMA)||"0")+", "+b+") / Math.PI * 180",Blockly.JavaScript.ORDER_DIVISION]};Blockly.JavaScript.procedures={};
+Blockly.JavaScript.procedures_defreturn=function(a){var b=Blockly.JavaScript.variableDB_.getName(a.getFieldValue("NAME"),Blockly.Procedures.NAME_TYPE),c=Blockly.JavaScript.statementToCode(a,"STACK");if(Blockly.JavaScript.STATEMENT_PREFIX){var d=a.id.replace(/\$/g,"$$$$");c=Blockly.JavaScript.prefixLines(Blockly.JavaScript.STATEMENT_PREFIX.replace(/%1/g,"'"+d+"'"),Blockly.JavaScript.INDENT)+c}Blockly.JavaScript.INFINITE_LOOP_TRAP&&(c=Blockly.JavaScript.INFINITE_LOOP_TRAP.replace(/%1/g,"'"+a.id+"'")+
+c);(d=Blockly.JavaScript.valueToCode(a,"RETURN",Blockly.JavaScript.ORDER_NONE)||"")&&(d=Blockly.JavaScript.INDENT+"return "+d+";\n");for(var e=[],f=0;f<a.arguments_.length;f++)e[f]=Blockly.JavaScript.variableDB_.getName(a.arguments_[f],Blockly.Variables.NAME_TYPE);c="function "+b+"("+e.join(", ")+") {\n"+c+d+"}";c=Blockly.JavaScript.scrub_(a,c);Blockly.JavaScript.definitions_["%"+b]=c;return null};Blockly.JavaScript.procedures_defnoreturn=Blockly.JavaScript.procedures_defreturn;
+Blockly.JavaScript.procedures_callreturn=function(a){for(var b=Blockly.JavaScript.variableDB_.getName(a.getFieldValue("NAME"),Blockly.Procedures.NAME_TYPE),c=[],d=0;d<a.arguments_.length;d++)c[d]=Blockly.JavaScript.valueToCode(a,"ARG"+d,Blockly.JavaScript.ORDER_COMMA)||"null";return[b+"("+c.join(", ")+")",Blockly.JavaScript.ORDER_FUNCTION_CALL]};
+Blockly.JavaScript.procedures_callnoreturn=function(a){for(var b=Blockly.JavaScript.variableDB_.getName(a.getFieldValue("NAME"),Blockly.Procedures.NAME_TYPE),c=[],d=0;d<a.arguments_.length;d++)c[d]=Blockly.JavaScript.valueToCode(a,"ARG"+d,Blockly.JavaScript.ORDER_COMMA)||"null";return b+"("+c.join(", ")+");\n"};
+Blockly.JavaScript.procedures_ifreturn=function(a){var b="if ("+(Blockly.JavaScript.valueToCode(a,"CONDITION",Blockly.JavaScript.ORDER_NONE)||"false")+") {\n";a.hasReturnValue_?(a=Blockly.JavaScript.valueToCode(a,"VALUE",Blockly.JavaScript.ORDER_NONE)||"null",b+=Blockly.JavaScript.INDENT+"return "+a+";\n"):b+=Blockly.JavaScript.INDENT+"return;\n";return b+"}\n"};Blockly.JavaScript.texts={};Blockly.JavaScript.text=function(a){return[Blockly.JavaScript.quote_(a.getFieldValue("TEXT")),Blockly.JavaScript.ORDER_ATOMIC]};Blockly.JavaScript.text.forceString_=function(a){return Blockly.JavaScript.text.forceString_.strRegExp.test(a)?a:"String("+a+")"};Blockly.JavaScript.text.forceString_.strRegExp=/^\s*'([^']|\\')*'\s*$/;
+Blockly.JavaScript.text_join=function(a){switch(a.itemCount_){case 0:return["''",Blockly.JavaScript.ORDER_ATOMIC];case 1:return a=Blockly.JavaScript.valueToCode(a,"ADD0",Blockly.JavaScript.ORDER_NONE)||"''",a=Blockly.JavaScript.text.forceString_(a),[a,Blockly.JavaScript.ORDER_FUNCTION_CALL];case 2:var b=Blockly.JavaScript.valueToCode(a,"ADD0",Blockly.JavaScript.ORDER_NONE)||"''";a=Blockly.JavaScript.valueToCode(a,"ADD1",Blockly.JavaScript.ORDER_NONE)||"''";a=Blockly.JavaScript.text.forceString_(b)+
+" + "+Blockly.JavaScript.text.forceString_(a);return[a,Blockly.JavaScript.ORDER_ADDITION];default:b=Array(a.itemCount_);for(var c=0;c<a.itemCount_;c++)b[c]=Blockly.JavaScript.valueToCode(a,"ADD"+c,Blockly.JavaScript.ORDER_COMMA)||"''";a="["+b.join(",")+"].join('')";return[a,Blockly.JavaScript.ORDER_FUNCTION_CALL]}};
+Blockly.JavaScript.text_append=function(a){var b=Blockly.JavaScript.variableDB_.getName(a.getFieldValue("VAR"),Blockly.Variables.NAME_TYPE);a=Blockly.JavaScript.valueToCode(a,"TEXT",Blockly.JavaScript.ORDER_NONE)||"''";return b+" += "+Blockly.JavaScript.text.forceString_(a)+";\n"};Blockly.JavaScript.text_length=function(a){return[(Blockly.JavaScript.valueToCode(a,"VALUE",Blockly.JavaScript.ORDER_FUNCTION_CALL)||"''")+".length",Blockly.JavaScript.ORDER_MEMBER]};
+Blockly.JavaScript.text_isEmpty=function(a){return["!"+(Blockly.JavaScript.valueToCode(a,"VALUE",Blockly.JavaScript.ORDER_MEMBER)||"''")+".length",Blockly.JavaScript.ORDER_LOGICAL_NOT]};
+Blockly.JavaScript.text_indexOf=function(a){var b="FIRST"==a.getFieldValue("END")?"indexOf":"lastIndexOf",c=Blockly.JavaScript.valueToCode(a,"FIND",Blockly.JavaScript.ORDER_NONE)||"''";b=(Blockly.JavaScript.valueToCode(a,"VALUE",Blockly.JavaScript.ORDER_MEMBER)||"''")+"."+b+"("+c+")";return a.workspace.options.oneBasedIndex?[b+" + 1",Blockly.JavaScript.ORDER_ADDITION]:[b,Blockly.JavaScript.ORDER_FUNCTION_CALL]};
+Blockly.JavaScript.text_charAt=function(a){var b=a.getFieldValue("WHERE")||"FROM_START",c=Blockly.JavaScript.valueToCode(a,"VALUE","RANDOM"==b?Blockly.JavaScript.ORDER_NONE:Blockly.JavaScript.ORDER_MEMBER)||"''";switch(b){case "FIRST":return[c+".charAt(0)",Blockly.JavaScript.ORDER_FUNCTION_CALL];case "LAST":return[c+".slice(-1)",Blockly.JavaScript.ORDER_FUNCTION_CALL];case "FROM_START":return a=Blockly.JavaScript.getAdjusted(a,"AT"),[c+".charAt("+a+")",Blockly.JavaScript.ORDER_FUNCTION_CALL];case "FROM_END":return a=
+Blockly.JavaScript.getAdjusted(a,"AT",1,!0),[c+".slice("+a+").charAt(0)",Blockly.JavaScript.ORDER_FUNCTION_CALL];case "RANDOM":return[Blockly.JavaScript.provideFunction_("textRandomLetter",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(text) {","  var x = Math.floor(Math.random() * text.length);","  return text[x];","}"])+"("+c+")",Blockly.JavaScript.ORDER_FUNCTION_CALL]}throw Error("Unhandled option (text_charAt).");};
+Blockly.JavaScript.text.getIndex_=function(a,b,c){return"FIRST"==b?"0":"FROM_END"==b?a+".length - 1 - "+c:"LAST"==b?a+".length - 1":c};
+Blockly.JavaScript.text_getSubstring=function(a){var b=Blockly.JavaScript.valueToCode(a,"STRING",Blockly.JavaScript.ORDER_FUNCTION_CALL)||"''",c=a.getFieldValue("WHERE1"),d=a.getFieldValue("WHERE2");if("FIRST"!=c||"LAST"!=d)if(b.match(/^'?\w+'?$/)||"FROM_END"!=c&&"LAST"!=c&&"FROM_END"!=d&&"LAST"!=d){switch(c){case "FROM_START":var e=Blockly.JavaScript.getAdjusted(a,"AT1");break;case "FROM_END":e=Blockly.JavaScript.getAdjusted(a,"AT1",1,!1,Blockly.JavaScript.ORDER_SUBTRACTION);e=b+".length - "+e;break;
+case "FIRST":e="0";break;default:throw Error("Unhandled option (text_getSubstring).");}switch(d){case "FROM_START":a=Blockly.JavaScript.getAdjusted(a,"AT2",1);break;case "FROM_END":a=Blockly.JavaScript.getAdjusted(a,"AT2",0,!1,Blockly.JavaScript.ORDER_SUBTRACTION);a=b+".length - "+a;break;case "LAST":a=b+".length";break;default:throw Error("Unhandled option (text_getSubstring).");}b=b+".slice("+e+", "+a+")"}else{e=Blockly.JavaScript.getAdjusted(a,"AT1");a=Blockly.JavaScript.getAdjusted(a,"AT2");var f=
+Blockly.JavaScript.text.getIndex_,g={FIRST:"First",LAST:"Last",FROM_START:"FromStart",FROM_END:"FromEnd"};b=Blockly.JavaScript.provideFunction_("subsequence"+g[c]+g[d],["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(sequence"+("FROM_END"==c||"FROM_START"==c?", at1":"")+("FROM_END"==d||"FROM_START"==d?", at2":"")+") {","  var start = "+f("sequence",c,"at1")+";","  var end = "+f("sequence",d,"at2")+" + 1;","  return sequence.slice(start, end);","}"])+"("+b+("FROM_END"==c||"FROM_START"==
+c?", "+e:"")+("FROM_END"==d||"FROM_START"==d?", "+a:"")+")"}return[b,Blockly.JavaScript.ORDER_FUNCTION_CALL]};
+Blockly.JavaScript.text_changeCase=function(a){var b={UPPERCASE:".toUpperCase()",LOWERCASE:".toLowerCase()",TITLECASE:null}[a.getFieldValue("CASE")];a=Blockly.JavaScript.valueToCode(a,"TEXT",b?Blockly.JavaScript.ORDER_MEMBER:Blockly.JavaScript.ORDER_NONE)||"''";return[b?a+b:Blockly.JavaScript.provideFunction_("textToTitleCase",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(str) {","  return str.replace(/\\S+/g,","      function(txt) {return txt[0].toUpperCase() + txt.substring(1).toLowerCase();});",
+"}"])+"("+a+")",Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.text_trim=function(a){var b={LEFT:".replace(/^[\\s\\xa0]+/, '')",RIGHT:".replace(/[\\s\\xa0]+$/, '')",BOTH:".trim()"}[a.getFieldValue("MODE")];return[(Blockly.JavaScript.valueToCode(a,"TEXT",Blockly.JavaScript.ORDER_MEMBER)||"''")+b,Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.text_print=function(a){return"window.alert("+(Blockly.JavaScript.valueToCode(a,"TEXT",Blockly.JavaScript.ORDER_NONE)||"''")+");\n"};
+Blockly.JavaScript.text_prompt_ext=function(a){var b="window.prompt("+(a.getField("TEXT")?Blockly.JavaScript.quote_(a.getFieldValue("TEXT")):Blockly.JavaScript.valueToCode(a,"TEXT",Blockly.JavaScript.ORDER_NONE)||"''")+")";"NUMBER"==a.getFieldValue("TYPE")&&(b="parseFloat("+b+")");return[b,Blockly.JavaScript.ORDER_FUNCTION_CALL]};Blockly.JavaScript.text_prompt=Blockly.JavaScript.text_prompt_ext;
+Blockly.JavaScript.text_count=function(a){var b=Blockly.JavaScript.valueToCode(a,"TEXT",Blockly.JavaScript.ORDER_MEMBER)||"''";a=Blockly.JavaScript.valueToCode(a,"SUB",Blockly.JavaScript.ORDER_NONE)||"''";return[Blockly.JavaScript.provideFunction_("textCount",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(haystack, needle) {","  if (needle.length === 0) {","    return haystack.length + 1;","  } else {","    return haystack.split(needle).length - 1;","  }","}"])+"("+b+", "+a+")",Blockly.JavaScript.ORDER_SUBTRACTION]};
+Blockly.JavaScript.text_replace=function(a){var b=Blockly.JavaScript.valueToCode(a,"TEXT",Blockly.JavaScript.ORDER_MEMBER)||"''",c=Blockly.JavaScript.valueToCode(a,"FROM",Blockly.JavaScript.ORDER_NONE)||"''";a=Blockly.JavaScript.valueToCode(a,"TO",Blockly.JavaScript.ORDER_NONE)||"''";return[Blockly.JavaScript.provideFunction_("textReplace",["function "+Blockly.JavaScript.FUNCTION_NAME_PLACEHOLDER_+"(haystack, needle, replacement) {",'  needle = needle.replace(/([-()\\[\\]{}+?*.$\\^|,:#<!\\\\])/g,"\\\\$1")',
+'                 .replace(/\\x08/g,"\\\\x08");',"  return haystack.replace(new RegExp(needle, 'g'), replacement);","}"])+"("+b+", "+c+", "+a+")",Blockly.JavaScript.ORDER_MEMBER]};Blockly.JavaScript.text_reverse=function(a){return[(Blockly.JavaScript.valueToCode(a,"TEXT",Blockly.JavaScript.ORDER_MEMBER)||"''")+".split('').reverse().join('')",Blockly.JavaScript.ORDER_MEMBER]};Blockly.JavaScript.variables={};Blockly.JavaScript.variables_get=function(a){return[Blockly.JavaScript.variableDB_.getName(a.getFieldValue("VAR"),Blockly.Variables.NAME_TYPE),Blockly.JavaScript.ORDER_ATOMIC]};Blockly.JavaScript.variables_set=function(a){var b=Blockly.JavaScript.valueToCode(a,"VALUE",Blockly.JavaScript.ORDER_ASSIGNMENT)||"0";return Blockly.JavaScript.variableDB_.getName(a.getFieldValue("VAR"),Blockly.Variables.NAME_TYPE)+" = "+b+";\n"};
+Blockly.JavaScript.variablesDynamic={};Blockly.JavaScript.variables_get_dynamic=Blockly.JavaScript.variables_get;Blockly.JavaScript.variables_set_dynamic=Blockly.JavaScript.variables_set;
\ No newline at end of file
diff --git a/_server/blockly/media/quote0.png b/_server/blockly/media/quote0.png
index b2fd10f6..c7820d60 100644
Binary files a/_server/blockly/media/quote0.png and b/_server/blockly/media/quote0.png differ
diff --git a/_server/blockly/media/sprites.png b/_server/blockly/media/sprites.png
index 7f704a5f..20aadb6c 100644
Binary files a/_server/blockly/media/sprites.png and b/_server/blockly/media/sprites.png differ
diff --git a/_server/blockly/media/sprites.svg b/_server/blockly/media/sprites.svg
index 77403127..3f09ef3a 100644
--- a/_server/blockly/media/sprites.svg
+++ b/_server/blockly/media/sprites.svg
@@ -1,74 +1,74 @@
 <?xml version="1.0" encoding="utf-8" standalone="no"?>
 <svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="96px" height="124px">
-    <style type="text/css">
-        #background {
-        fill: none;
-        }
-        .arrows {
-        fill: #000;
-        stroke: none;
-        }
-        .selected>.arrows {
-        fill: #fff;
-        }
-        .checkmark {
-        fill: #000;
-        font-family: sans-serif;
-        font-size: 10pt;
-        text-anchor: middle;
-        }
-        .trash {
-        fill: #888;
-        }
-        .zoom {
-        fill: none;
-        stroke: #888;
-        stroke-width: 2;
-        stroke-linecap: round;
-        }
-        .zoom>.center {
-        fill: #888;
-        stroke-width: 0;
-        }
-    </style>
-    <rect id="background" width="96" height="124" x="0" y="0"/>
+  <style type="text/css">
+#background {
+  fill: none;
+}
+.arrows {
+  fill: #000;
+  stroke: none;
+}
+.selected>.arrows {
+  fill: #fff;
+}
+.checkmark {
+  fill: #000;
+  font-family: sans-serif;
+  font-size: 10pt;
+  text-anchor: middle;
+}
+.trash {
+  fill: #888;
+}
+.zoom {
+  fill: none;
+  stroke: #888;
+  stroke-width: 2;
+  stroke-linecap: round;
+}
+.zoom>.center {
+  fill: #888;
+  stroke-width: 0;
+}
+  </style>
+  <rect id="background" width="96" height="124" x="0" y="0" />
 
-    <g>
-        <path class="arrows" d="M 13,1.5 13,14.5 1.74,8 z"/>
-        <path class="arrows" d="M 17.5,3 30.5,3 24,14.26 z"/>
-        <path class="arrows" d="M 35,1.5 35,14.5 46.26,8 z"/>
-    </g>
-    <g class="selected" transform="translate(0, 16)">
-        <path class="arrows" d="M 13,1.5 13,14.5 1.74,8 z"/>
-        <path class="arrows" d="M 17.5,3 30.5,3 24,14.26 z"/>
-        <path class="arrows" d="M 35,1.5 35,14.5 46.26,8 z"/>
-    </g>
+  <g>
+    <path class="arrows" d="M 13,1.5 13,14.5 1.74,8 z" />
+    <path class="arrows" d="M 17.5,3 30.5,3 24,14.26 z" />
+    <path class="arrows" d="M 35,1.5 35,14.5 46.26,8 z" />
+  </g>
+  <g class="selected" transform="translate(0, 16)">
+    <path class="arrows" d="M 13,1.5 13,14.5 1.74,8 z" />
+    <path class="arrows" d="M 17.5,3 30.5,3 24,14.26 z" />
+    <path class="arrows" d="M 35,1.5 35,14.5 46.26,8 z" />
+  </g>
 
-    <text class="checkmark" x="55.5" y="28">&#10003;</text>
+  <text class="checkmark" x="55.5" y="28">&#10003;</text>
 
-    <g class="trash">
-        <path d="M 2,41 v 6 h 42 v -6 h -10.5 l -3,-3 h -15 l -3,3 z"/>
-        <rect width="36" height="20" x="5" y="50"/>
-        <rect width="36" height="42" x="5" y="50" rx="4" ry="4"/>
-    </g>
+  <g class="trash">
+    <path d="M 2,41 v 6 h 42 v -6 h -10.5 l -3,-3 h -15 l -3,3 z" />
+    <rect width="36" height="20" x="5" y="50" />
+    <rect width="36" height="42" x="5" y="50" rx="4" ry="4" />
+  </g>
 
-    <g class="zoom">
-        <circle r="11.5" cx="16" cy="108"/>
-        <circle r="4.3" cx="16" cy="108" class="center"/>
-        <path d="m 28,108 h3"/>
-        <path d="m 1,108 h3"/>
-        <path d="m 16,120 v3"/>
-        <path d="m 16,93 v3"/>
-    </g>
+  <g class="zoom">
+    <circle r="11.5" cx="16" cy="108" />
+    <circle r="4.3" cx="16" cy="108" class="center" />
+    <path d="m 28,108 h3" />
+    <path d="m 1,108 h3" />
+    <path d="m 16,120 v3" />
+    <path d="m 16,93 v3" />
+  </g>
 
-    <g class="zoom">
-        <circle r="15" cx="48" cy="108"/>
-        <path d="m 48,101.6 v12.8"/>
-        <path d="m 41.6,108 h12.8"/>
-    </g>
+  <g class="zoom">
+    <circle r="15" cx="48" cy="108" />
+    <path d="m 48,101.6 v12.8" />
+    <path d="m 41.6,108 h12.8" />
+  </g>
 
-    <g class="zoom">
-        <circle r="15" cx="80" cy="108"/>
-        <path d="m 73.6,108 h12.8"/>
-    </g>
+  <g class="zoom">
+    <circle r="15" cx="80" cy="108" />
+    <path d="m 73.6,108 h12.8" />
+  </g>
 </svg>
diff --git a/_server/blockly/zh-hans.js b/_server/blockly/zh-hans.js
new file mode 100644
index 00000000..cc860623
--- /dev/null
+++ b/_server/blockly/zh-hans.js
@@ -0,0 +1,435 @@
+// This file was automatically generated.  Do not modify.
+
+'use strict';
+
+goog.provide('Blockly.Msg.zh.hans');
+
+goog.require('Blockly.Msg');
+
+Blockly.Msg["ADD_COMMENT"] = "添加注释";
+Blockly.Msg["CANNOT_DELETE_VARIABLE_PROCEDURE"] = "不能删除变量“%1”，因为它是函数“%2”定义的一部分";
+Blockly.Msg["CHANGE_VALUE_TITLE"] = "更改值：";
+Blockly.Msg["CLEAN_UP"] = "整理块";
+Blockly.Msg["COLLAPSE_ALL"] = "折叠块";
+Blockly.Msg["COLLAPSE_BLOCK"] = "折叠块";
+Blockly.Msg["COLOUR_BLEND_COLOUR1"] = "颜色1";
+Blockly.Msg["COLOUR_BLEND_COLOUR2"] = "颜色2";
+Blockly.Msg["COLOUR_BLEND_HELPURL"] = "http://meyerweb.com/eric/tools/color-blend/";  // untranslated
+Blockly.Msg["COLOUR_BLEND_RATIO"] = "比例";
+Blockly.Msg["COLOUR_BLEND_TITLE"] = "混合";
+Blockly.Msg["COLOUR_BLEND_TOOLTIP"] = "把两种颜色以一个给定的比例(0.0-1.0)进行混合。";
+Blockly.Msg["COLOUR_PICKER_HELPURL"] = "https://zh.wikipedia.org/wiki/颜色";
+Blockly.Msg["COLOUR_PICKER_TOOLTIP"] = "从调色板中选择一种颜色。";
+Blockly.Msg["COLOUR_RANDOM_HELPURL"] = "http://randomcolour.com";  // untranslated
+Blockly.Msg["COLOUR_RANDOM_TITLE"] = "随机颜色";
+Blockly.Msg["COLOUR_RANDOM_TOOLTIP"] = "随机选择一种颜色。";
+Blockly.Msg["COLOUR_RGB_BLUE"] = "蓝色";
+Blockly.Msg["COLOUR_RGB_GREEN"] = "绿色";
+Blockly.Msg["COLOUR_RGB_HELPURL"] = "http://www.december.com/html/spec/colorper.html";  // untranslated
+Blockly.Msg["COLOUR_RGB_RED"] = "红色";
+Blockly.Msg["COLOUR_RGB_TITLE"] = "颜色";
+Blockly.Msg["COLOUR_RGB_TOOLTIP"] = "通过指定红色、绿色和蓝色的量创建一种颜色。所有的值必须在0和100之间。";
+Blockly.Msg["CONTROLS_FLOW_STATEMENTS_HELPURL"] = "https://github.com/google/blockly/wiki/Loops#loop-termination-blocks";  // untranslated
+Blockly.Msg["CONTROLS_FLOW_STATEMENTS_OPERATOR_BREAK"] = "跳出循环";
+Blockly.Msg["CONTROLS_FLOW_STATEMENTS_OPERATOR_CONTINUE"] = "继续下一轮循环";
+Blockly.Msg["CONTROLS_FLOW_STATEMENTS_TOOLTIP_BREAK"] = "跳出包含它的循环。";
+Blockly.Msg["CONTROLS_FLOW_STATEMENTS_TOOLTIP_CONTINUE"] = "跳过本轮循环的剩余部分，并继进行续下一轮迭代。";
+Blockly.Msg["CONTROLS_FLOW_STATEMENTS_WARNING"] = "警告：这个块只能在循环内使用。";
+Blockly.Msg["CONTROLS_FOREACH_HELPURL"] = "https://github.com/google/blockly/wiki/Loops#for-each";  // untranslated
+Blockly.Msg["CONTROLS_FOREACH_TITLE"] = "为列表 %2 里的每一项 %1";
+Blockly.Msg["CONTROLS_FOREACH_TOOLTIP"] = "遍历列表中的每一项，将变量“%1”设为所选项，并执行一些语句。";
+Blockly.Msg["CONTROLS_FOR_HELPURL"] = "https://github.com/google/blockly/wiki/Loops#count-with";  // untranslated
+Blockly.Msg["CONTROLS_FOR_TITLE"] = "变量 %1 从 %2 数到 %3 每次增加 %4";
+Blockly.Msg["CONTROLS_FOR_TOOLTIP"] = "用变量%1记录从开始数值到终止数值之间的数值，数值按指定间隔增加，并执行指定的块。";
+Blockly.Msg["CONTROLS_IF_ELSEIF_TOOLTIP"] = "在这个if语句块中增加一个条件。";
+Blockly.Msg["CONTROLS_IF_ELSE_TOOLTIP"] = "在这个if语句块中添加一个最终的，包括所有其余情况的条件。";
+Blockly.Msg["CONTROLS_IF_HELPURL"] = "https://github.com/google/blockly/wiki/IfElse";  // untranslated
+Blockly.Msg["CONTROLS_IF_IF_TOOLTIP"] = "增加、删除或重新排列各节来重新配置这个if语句块。";
+Blockly.Msg["CONTROLS_IF_MSG_ELSE"] = "否则";
+Blockly.Msg["CONTROLS_IF_MSG_ELSEIF"] = "否则如果";
+Blockly.Msg["CONTROLS_IF_MSG_IF"] = "如果";
+Blockly.Msg["CONTROLS_IF_TOOLTIP_1"] = "如果值为真，执行一些语句。";
+Blockly.Msg["CONTROLS_IF_TOOLTIP_2"] = "如果值为真，则执行第一块语句。否则，则执行第二块语句。";
+Blockly.Msg["CONTROLS_IF_TOOLTIP_3"] = "如果第一个值为真，则执行第一块的语句。否则，如果第二个值为真，则执行第二块的语句。";
+Blockly.Msg["CONTROLS_IF_TOOLTIP_4"] = "如果第一个值为真，则执行第一块对语句。否则，如果第二个值为真，则执行语句的第二块。如果没有值为真，则执行最后一块的语句。";
+Blockly.Msg["CONTROLS_REPEAT_HELPURL"] = "https://zh.wikipedia.org/wiki/For循环";
+Blockly.Msg["CONTROLS_REPEAT_INPUT_DO"] = "执行";
+Blockly.Msg["CONTROLS_REPEAT_TITLE"] = "重复 %1 次";
+Blockly.Msg["CONTROLS_REPEAT_TOOLTIP"] = "多次执行一些语句。";
+Blockly.Msg["CONTROLS_WHILEUNTIL_HELPURL"] = "https://github.com/google/blockly/wiki/Loops#repeat";  // untranslated
+Blockly.Msg["CONTROLS_WHILEUNTIL_OPERATOR_UNTIL"] = "重复直到条件满足";
+Blockly.Msg["CONTROLS_WHILEUNTIL_OPERATOR_WHILE"] = "当条件满足时重复";
+Blockly.Msg["CONTROLS_WHILEUNTIL_TOOLTIP_UNTIL"] = "只要值为假，执行一些语句。";
+Blockly.Msg["CONTROLS_WHILEUNTIL_TOOLTIP_WHILE"] = "只要值为真，执行一些语句。";
+Blockly.Msg["DELETE_ALL_BLOCKS"] = "删除所有 %1 个块吗？";
+Blockly.Msg["DELETE_BLOCK"] = "删除块";
+Blockly.Msg["DELETE_VARIABLE"] = "删除变量“%1”";
+Blockly.Msg["DELETE_VARIABLE_CONFIRMATION"] = "要删除变量“%2”的%1个使用之处吗？";
+Blockly.Msg["DELETE_X_BLOCKS"] = "删除 %1 个块";
+Blockly.Msg["DISABLE_BLOCK"] = "禁用块";
+Blockly.Msg["DUPLICATE_BLOCK"] = "复制";
+Blockly.Msg["DUPLICATE_COMMENT"] = "复制注释";
+Blockly.Msg["ENABLE_BLOCK"] = "启用块";
+Blockly.Msg["EXPAND_ALL"] = "展开块";
+Blockly.Msg["EXPAND_BLOCK"] = "展开块";
+Blockly.Msg["EXTERNAL_INPUTS"] = "外部输入";
+Blockly.Msg["HELP"] = "帮助";
+Blockly.Msg["INLINE_INPUTS"] = "单行输入";
+Blockly.Msg["IOS_CANCEL"] = "取消";
+Blockly.Msg["IOS_ERROR"] = "错误";
+Blockly.Msg["IOS_OK"] = "确定";
+Blockly.Msg["IOS_PROCEDURES_ADD_INPUT"] = "+添加输入";
+Blockly.Msg["IOS_PROCEDURES_ALLOW_STATEMENTS"] = "允许的语句";
+Blockly.Msg["IOS_PROCEDURES_DUPLICATE_INPUTS_ERROR"] = "这个函数有多个输入。";
+Blockly.Msg["IOS_PROCEDURES_INPUTS"] = "输入";
+Blockly.Msg["IOS_VARIABLES_ADD_BUTTON"] = "添加";
+Blockly.Msg["IOS_VARIABLES_ADD_VARIABLE"] = "+添加变量";
+Blockly.Msg["IOS_VARIABLES_DELETE_BUTTON"] = "删除";
+Blockly.Msg["IOS_VARIABLES_EMPTY_NAME_ERROR"] = "你不能使用空白的变量名。";
+Blockly.Msg["IOS_VARIABLES_RENAME_BUTTON"] = "重命名";
+Blockly.Msg["IOS_VARIABLES_VARIABLE_NAME"] = "变量名";
+Blockly.Msg["LISTS_CREATE_EMPTY_HELPURL"] = "https://github.com/google/blockly/wiki/Lists#create-empty-list";
+Blockly.Msg["LISTS_CREATE_EMPTY_TITLE"] = "创建空列表";
+Blockly.Msg["LISTS_CREATE_EMPTY_TOOLTIP"] = "返回一个列表，长度为 0，不包含任何数据记录";
+Blockly.Msg["LISTS_CREATE_WITH_CONTAINER_TITLE_ADD"] = "列表";
+Blockly.Msg["LISTS_CREATE_WITH_CONTAINER_TOOLTIP"] = "增加、删除或重新排列各部分以此重新配置这个列表块。";
+Blockly.Msg["LISTS_CREATE_WITH_HELPURL"] = "https://github.com/google/blockly/wiki/Lists#create-list-with";
+Blockly.Msg["LISTS_CREATE_WITH_INPUT_WITH"] = "建立列表从";
+Blockly.Msg["LISTS_CREATE_WITH_ITEM_TOOLTIP"] = "将一个项添加到列表中。";
+Blockly.Msg["LISTS_CREATE_WITH_TOOLTIP"] = "建立一个具有任意数量项目的列表。";
+Blockly.Msg["LISTS_GET_INDEX_FIRST"] = "第一个";
+Blockly.Msg["LISTS_GET_INDEX_FROM_END"] = "倒数第#";
+Blockly.Msg["LISTS_GET_INDEX_FROM_START"] = "#";
+Blockly.Msg["LISTS_GET_INDEX_GET"] = "取得";
+Blockly.Msg["LISTS_GET_INDEX_GET_REMOVE"] = "取得并移除";
+Blockly.Msg["LISTS_GET_INDEX_LAST"] = "最后一个";
+Blockly.Msg["LISTS_GET_INDEX_RANDOM"] = "随机的";
+Blockly.Msg["LISTS_GET_INDEX_REMOVE"] = "移除";
+Blockly.Msg["LISTS_GET_INDEX_TAIL"] = "空白";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_GET_FIRST"] = "返回列表中的第一项。";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_GET_FROM"] = "返回在列表中的指定位置的项。";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_GET_LAST"] = "返回列表中的最后一项。";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_GET_RANDOM"] = "返回列表中的随机一项。";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FIRST"] = "移除并返回列表中的第一项。";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FROM"] = "移除并返回列表中的指定位置的项。";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_LAST"] = "移除并返回列表中的最后一项。";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_RANDOM"] = "移除并返回列表中的随机一项。";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_REMOVE_FIRST"] = "移除列表中的第一项";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_REMOVE_FROM"] = "移除在列表中的指定位置的项。";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_REMOVE_LAST"] = "移除列表中的最后一项";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_REMOVE_RANDOM"] = "删除列表中的随机一项。";
+Blockly.Msg["LISTS_GET_SUBLIST_END_FROM_END"] = "到倒数第#";
+Blockly.Msg["LISTS_GET_SUBLIST_END_FROM_START"] = "到#";
+Blockly.Msg["LISTS_GET_SUBLIST_END_LAST"] = "到最后";
+Blockly.Msg["LISTS_GET_SUBLIST_HELPURL"] = "https://github.com/google/blockly/wiki/Lists#getting-a-sublist";  // untranslated
+Blockly.Msg["LISTS_GET_SUBLIST_START_FIRST"] = "获取子列表从第一个";
+Blockly.Msg["LISTS_GET_SUBLIST_START_FROM_END"] = "获取子列表从最后一个#";
+Blockly.Msg["LISTS_GET_SUBLIST_START_FROM_START"] = "获取子列表从#";
+Blockly.Msg["LISTS_GET_SUBLIST_TAIL"] = "空白";
+Blockly.Msg["LISTS_GET_SUBLIST_TOOLTIP"] = "复制列表中指定的部分。";
+Blockly.Msg["LISTS_INDEX_FROM_END_TOOLTIP"] = "%1是最后一项。";
+Blockly.Msg["LISTS_INDEX_FROM_START_TOOLTIP"] = "%1是第一项。";
+Blockly.Msg["LISTS_INDEX_OF_FIRST"] = "寻找第一次出现的项";
+Blockly.Msg["LISTS_INDEX_OF_HELPURL"] = "https://github.com/google/blockly/wiki/Lists#getting-items-from-a-list";  // untranslated
+Blockly.Msg["LISTS_INDEX_OF_LAST"] = "寻找最后一次出现的项";
+Blockly.Msg["LISTS_INDEX_OF_TOOLTIP"] = "返回在列表中的第一/最后一个匹配项的索引值。如果找不到项目则返回%1。";
+Blockly.Msg["LISTS_INLIST"] = "在列表中";
+Blockly.Msg["LISTS_ISEMPTY_HELPURL"] = "https://github.com/google/blockly/wiki/Lists#is-empty";  // untranslated
+Blockly.Msg["LISTS_ISEMPTY_TITLE"] = "%1是空的";
+Blockly.Msg["LISTS_ISEMPTY_TOOLTIP"] = "如果改列表为空，则返回真。";
+Blockly.Msg["LISTS_LENGTH_HELPURL"] = "https://github.com/google/blockly/wiki/Lists#length-of";  // untranslated
+Blockly.Msg["LISTS_LENGTH_TITLE"] = "%1的长度";
+Blockly.Msg["LISTS_LENGTH_TOOLTIP"] = "返回列表的长度。";
+Blockly.Msg["LISTS_REPEAT_HELPURL"] = "https://github.com/google/blockly/wiki/Lists#create-list-with";  // untranslated
+Blockly.Msg["LISTS_REPEAT_TITLE"] = "建立列表使用项 %1 重复 %2 次";
+Blockly.Msg["LISTS_REPEAT_TOOLTIP"] = "建立包含指定重复次数的值的列表。";
+Blockly.Msg["LISTS_REVERSE_HELPURL"] = "https://github.com/google/blockly/wiki/Lists#reversing-a-list";
+Blockly.Msg["LISTS_REVERSE_MESSAGE0"] = "倒转%1";
+Blockly.Msg["LISTS_REVERSE_TOOLTIP"] = "倒转一个列表的拷贝。";
+Blockly.Msg["LISTS_SET_INDEX_HELPURL"] = "https://github.com/google/blockly/wiki/Lists#in-list--set";  // untranslated
+Blockly.Msg["LISTS_SET_INDEX_INPUT_TO"] = "值为";
+Blockly.Msg["LISTS_SET_INDEX_INSERT"] = "插入在";
+Blockly.Msg["LISTS_SET_INDEX_SET"] = "设置";
+Blockly.Msg["LISTS_SET_INDEX_TOOLTIP_INSERT_FIRST"] = "在列表的起始处添加该项。";
+Blockly.Msg["LISTS_SET_INDEX_TOOLTIP_INSERT_FROM"] = "插入在列表中指定位置的项。";
+Blockly.Msg["LISTS_SET_INDEX_TOOLTIP_INSERT_LAST"] = "在列表的末尾处添加该项。";
+Blockly.Msg["LISTS_SET_INDEX_TOOLTIP_INSERT_RANDOM"] = "在列表的随机位置插入该项。";
+Blockly.Msg["LISTS_SET_INDEX_TOOLTIP_SET_FIRST"] = "设置列表中的第一项。";
+Blockly.Msg["LISTS_SET_INDEX_TOOLTIP_SET_FROM"] = "设置在列表中指定位置的项。";
+Blockly.Msg["LISTS_SET_INDEX_TOOLTIP_SET_LAST"] = "设置列表中的最后一项。";
+Blockly.Msg["LISTS_SET_INDEX_TOOLTIP_SET_RANDOM"] = "设置列表中的随机一项。";
+Blockly.Msg["LISTS_SORT_HELPURL"] = "https://github.com/google/blockly/wiki/Lists#sorting-a-list";
+Blockly.Msg["LISTS_SORT_ORDER_ASCENDING"] = "升序";
+Blockly.Msg["LISTS_SORT_ORDER_DESCENDING"] = "降序";
+Blockly.Msg["LISTS_SORT_TITLE"] = "排序%1 %2 %3";
+Blockly.Msg["LISTS_SORT_TOOLTIP"] = "排序一个列表的拷贝。";
+Blockly.Msg["LISTS_SORT_TYPE_IGNORECASE"] = "按字母排序，忽略大小写";
+Blockly.Msg["LISTS_SORT_TYPE_NUMERIC"] = "按数字排序";
+Blockly.Msg["LISTS_SORT_TYPE_TEXT"] = "按字母排序";
+Blockly.Msg["LISTS_SPLIT_HELPURL"] = "https://github.com/google/blockly/wiki/Lists#splitting-strings-and-joining-lists";
+Blockly.Msg["LISTS_SPLIT_LIST_FROM_TEXT"] = "从文本制作列表";
+Blockly.Msg["LISTS_SPLIT_TEXT_FROM_LIST"] = "从列表拆出文本";
+Blockly.Msg["LISTS_SPLIT_TOOLTIP_JOIN"] = "加入文本列表至一个文本，由分隔符分隔。";
+Blockly.Msg["LISTS_SPLIT_TOOLTIP_SPLIT"] = "拆分文本到文本列表，按每个分隔符拆分。";
+Blockly.Msg["LISTS_SPLIT_WITH_DELIMITER"] = "用分隔符";
+Blockly.Msg["LOGIC_BOOLEAN_FALSE"] = "假";
+Blockly.Msg["LOGIC_BOOLEAN_HELPURL"] = "https://github.com/google/blockly/wiki/Logic#values";  // untranslated
+Blockly.Msg["LOGIC_BOOLEAN_TOOLTIP"] = "返回真或假。";
+Blockly.Msg["LOGIC_BOOLEAN_TRUE"] = "真";
+Blockly.Msg["LOGIC_COMPARE_HELPURL"] = "https://zh.wikipedia.org/wiki/不等";
+Blockly.Msg["LOGIC_COMPARE_TOOLTIP_EQ"] = "如果两个输入结果相等，则返回真。";
+Blockly.Msg["LOGIC_COMPARE_TOOLTIP_GT"] = "如果第一个输入结果比第二个大，则返回真。";
+Blockly.Msg["LOGIC_COMPARE_TOOLTIP_GTE"] = "如果第一个输入结果大于或等于第二个输入结果，则返回真。";
+Blockly.Msg["LOGIC_COMPARE_TOOLTIP_LT"] = "如果第一个输入结果比第二个小，则返回真。";
+Blockly.Msg["LOGIC_COMPARE_TOOLTIP_LTE"] = "如果第一个输入结果小于或等于第二个输入结果，则返回真。";
+Blockly.Msg["LOGIC_COMPARE_TOOLTIP_NEQ"] = "如果两个输入结果不相等，则返回真。";
+Blockly.Msg["LOGIC_NEGATE_HELPURL"] = "https://github.com/google/blockly/wiki/Logic#not";
+Blockly.Msg["LOGIC_NEGATE_TITLE"] = "非%1";
+Blockly.Msg["LOGIC_NEGATE_TOOLTIP"] = "如果输入结果为假，则返回真；如果输入结果为真，则返回假。";
+Blockly.Msg["LOGIC_NULL"] = "空";
+Blockly.Msg["LOGIC_NULL_HELPURL"] = "https://en.wikipedia.org/wiki/Nullable_type";  // untranslated
+Blockly.Msg["LOGIC_NULL_TOOLTIP"] = "返回空值。";
+Blockly.Msg["LOGIC_OPERATION_AND"] = "并且";
+Blockly.Msg["LOGIC_OPERATION_HELPURL"] = "https://github.com/google/blockly/wiki/Logic#logical-operations";  // untranslated
+Blockly.Msg["LOGIC_OPERATION_OR"] = "或";
+Blockly.Msg["LOGIC_OPERATION_TOOLTIP_AND"] = "如果两个输入结果都为真，则返回真。";
+Blockly.Msg["LOGIC_OPERATION_TOOLTIP_OR"] = "如果至少有一个输入结果为真，则返回真。";
+Blockly.Msg["LOGIC_TERNARY_CONDITION"] = "断言";
+Blockly.Msg["LOGIC_TERNARY_HELPURL"] = "https://zh.wikipedia.org/wiki/条件运算符";
+Blockly.Msg["LOGIC_TERNARY_IF_FALSE"] = "如果为假";
+Blockly.Msg["LOGIC_TERNARY_IF_TRUE"] = "如果为真";
+Blockly.Msg["LOGIC_TERNARY_TOOLTIP"] = "检查“断言”里的条件语句。如果条件为真，则返回“如果为真”的值，否则，则返回“如果为假”的值。";
+Blockly.Msg["MATH_ADDITION_SYMBOL"] = "+";  // untranslated
+Blockly.Msg["MATH_ARITHMETIC_HELPURL"] = "https://zh.wikipedia.org/wiki/算术";
+Blockly.Msg["MATH_ARITHMETIC_TOOLTIP_ADD"] = "返回两个数值的和。";
+Blockly.Msg["MATH_ARITHMETIC_TOOLTIP_DIVIDE"] = "返回两个数值的商。";
+Blockly.Msg["MATH_ARITHMETIC_TOOLTIP_MINUS"] = "返回两个数值的差值。";
+Blockly.Msg["MATH_ARITHMETIC_TOOLTIP_MULTIPLY"] = "返回两个数值的乘积。";
+Blockly.Msg["MATH_ARITHMETIC_TOOLTIP_POWER"] = "返回以第一个数值为底数，以第二个数值为幂的结果。";
+Blockly.Msg["MATH_ATAN2_HELPURL"] = "https://zh.wikipedia.org/wiki/反正切2";
+Blockly.Msg["MATH_ATAN2_TITLE"] = "点(x:%1,y:%2)的方位角";
+Blockly.Msg["MATH_ATAN2_TOOLTIP"] = "返回点（X，Y）的反正切值，范围为-180到180度。";
+Blockly.Msg["MATH_CHANGE_HELPURL"] = "https://zh.wikipedia.org/wiki/加法";
+Blockly.Msg["MATH_CHANGE_TITLE"] = "将 %1 改为 %2";
+Blockly.Msg["MATH_CHANGE_TOOLTIP"] = "为变量“%1”增加一个数值。";
+Blockly.Msg["MATH_CONSTANT_HELPURL"] = "https://zh.wikipedia.org/wiki/数学常数";
+Blockly.Msg["MATH_CONSTANT_TOOLTIP"] = "返回一个常见常量：π (3.141…)、e (2.718…)、φ (1.618…)、平方根 (1.414…)、开平方根 (0.707…)或∞ (无限大)。";
+Blockly.Msg["MATH_CONSTRAIN_HELPURL"] = "https://en.wikipedia.org/wiki/Clamping_(graphics)";  // untranslated
+Blockly.Msg["MATH_CONSTRAIN_TITLE"] = "将 %1 限制在 最低 %2 到最高 %3 之间";
+Blockly.Msg["MATH_CONSTRAIN_TOOLTIP"] = "将一个数值限制在两个指定的数值范围（含边界）之间。";
+Blockly.Msg["MATH_DIVISION_SYMBOL"] = "÷";  // untranslated
+Blockly.Msg["MATH_IS_DIVISIBLE_BY"] = "可被整除";
+Blockly.Msg["MATH_IS_EVEN"] = "是偶数";
+Blockly.Msg["MATH_IS_NEGATIVE"] = "是负数";
+Blockly.Msg["MATH_IS_ODD"] = "是奇数";
+Blockly.Msg["MATH_IS_POSITIVE"] = "是正数";
+Blockly.Msg["MATH_IS_PRIME"] = "是质数";
+Blockly.Msg["MATH_IS_TOOLTIP"] = "检查一个数值是否是偶数、奇数、质数、自然数、正数、负数或者是否能被某数整除。返回真或假。";
+Blockly.Msg["MATH_IS_WHOLE"] = "是整数";
+Blockly.Msg["MATH_MODULO_HELPURL"] = "https://zh.wikipedia.org/wiki/模除";
+Blockly.Msg["MATH_MODULO_TITLE"] = "取 %1 ÷ %2 的余数";
+Blockly.Msg["MATH_MODULO_TOOLTIP"] = "返回这两个数字相除后的余数。";
+Blockly.Msg["MATH_MULTIPLICATION_SYMBOL"] = "×";  // untranslated
+Blockly.Msg["MATH_NUMBER_HELPURL"] = "https://zh.wikipedia.org/wiki/数";
+Blockly.Msg["MATH_NUMBER_TOOLTIP"] = "一个数值。";
+Blockly.Msg["MATH_ONLIST_HELPURL"] = "";  // untranslated
+Blockly.Msg["MATH_ONLIST_OPERATOR_AVERAGE"] = "列表平均值";
+Blockly.Msg["MATH_ONLIST_OPERATOR_MAX"] = "列表最大值";
+Blockly.Msg["MATH_ONLIST_OPERATOR_MEDIAN"] = "列表中位数";
+Blockly.Msg["MATH_ONLIST_OPERATOR_MIN"] = "列表最小值";
+Blockly.Msg["MATH_ONLIST_OPERATOR_MODE"] = "列表中的众数";
+Blockly.Msg["MATH_ONLIST_OPERATOR_RANDOM"] = "列表随机项";
+Blockly.Msg["MATH_ONLIST_OPERATOR_STD_DEV"] = "列表的标准差";
+Blockly.Msg["MATH_ONLIST_OPERATOR_SUM"] = "列表中数值的和";
+Blockly.Msg["MATH_ONLIST_TOOLTIP_AVERAGE"] = "返回列表中的数值的平均值。";
+Blockly.Msg["MATH_ONLIST_TOOLTIP_MAX"] = "返回列表中最大值。";
+Blockly.Msg["MATH_ONLIST_TOOLTIP_MEDIAN"] = "返回列表中数值的中位数。";
+Blockly.Msg["MATH_ONLIST_TOOLTIP_MIN"] = "返回列表中最小值。";
+Blockly.Msg["MATH_ONLIST_TOOLTIP_MODE"] = "返回列表中的出现次数最多的项的列表。";
+Blockly.Msg["MATH_ONLIST_TOOLTIP_RANDOM"] = "从列表中返回一个随机的元素。";
+Blockly.Msg["MATH_ONLIST_TOOLTIP_STD_DEV"] = "返回列表的标准差。";
+Blockly.Msg["MATH_ONLIST_TOOLTIP_SUM"] = "返回列表中的所有数值的和。";
+Blockly.Msg["MATH_POWER_SYMBOL"] = "^";  // untranslated
+Blockly.Msg["MATH_RANDOM_FLOAT_HELPURL"] = "https://zh.wikipedia.org/wiki/随机数生成器";
+Blockly.Msg["MATH_RANDOM_FLOAT_TITLE_RANDOM"] = "随机小数";
+Blockly.Msg["MATH_RANDOM_FLOAT_TOOLTIP"] = "返回一个介于0.0到1.0之间（含边界）的随机数。";
+Blockly.Msg["MATH_RANDOM_INT_HELPURL"] = "https://zh.wikipedia.org/wiki/随机数生成器";
+Blockly.Msg["MATH_RANDOM_INT_TITLE"] = "从 %1 到 %2 范围内的随机整数";
+Blockly.Msg["MATH_RANDOM_INT_TOOLTIP"] = "返回一个限制在两个指定数值的范围（含边界）之间的随机整数。";
+Blockly.Msg["MATH_ROUND_HELPURL"] = "https://zh.wikipedia.org/wiki/数值修约";
+Blockly.Msg["MATH_ROUND_OPERATOR_ROUND"] = "四舍五入";
+Blockly.Msg["MATH_ROUND_OPERATOR_ROUNDDOWN"] = "向下舍入";
+Blockly.Msg["MATH_ROUND_OPERATOR_ROUNDUP"] = "向上舍入";
+Blockly.Msg["MATH_ROUND_TOOLTIP"] = "数字向上或向下舍入。";
+Blockly.Msg["MATH_SINGLE_HELPURL"] = "https://zh.wikipedia.org/wiki/平方根";
+Blockly.Msg["MATH_SINGLE_OP_ABSOLUTE"] = "绝对值";
+Blockly.Msg["MATH_SINGLE_OP_ROOT"] = "平方根";
+Blockly.Msg["MATH_SINGLE_TOOLTIP_ABS"] = "返回一个数值的绝对值。";
+Blockly.Msg["MATH_SINGLE_TOOLTIP_EXP"] = "返回一个数值的e次幂。";
+Blockly.Msg["MATH_SINGLE_TOOLTIP_LN"] = "返回一个数值的自然对数。";
+Blockly.Msg["MATH_SINGLE_TOOLTIP_LOG10"] = "返回一个数值的以10为底的对数。";
+Blockly.Msg["MATH_SINGLE_TOOLTIP_NEG"] = "返回一个数值的相反数。";
+Blockly.Msg["MATH_SINGLE_TOOLTIP_POW10"] = "返回一个数值的10次幂。";
+Blockly.Msg["MATH_SINGLE_TOOLTIP_ROOT"] = "返回一个数的平方根。";
+Blockly.Msg["MATH_SUBTRACTION_SYMBOL"] = "-";  // untranslated
+Blockly.Msg["MATH_TRIG_ACOS"] = "acos";  // untranslated
+Blockly.Msg["MATH_TRIG_ASIN"] = "asin";  // untranslated
+Blockly.Msg["MATH_TRIG_ATAN"] = "atan";  // untranslated
+Blockly.Msg["MATH_TRIG_COS"] = "cos";  // untranslated
+Blockly.Msg["MATH_TRIG_HELPURL"] = "https://zh.wikipedia.org/wiki/三角函数";
+Blockly.Msg["MATH_TRIG_SIN"] = "sin";  // untranslated
+Blockly.Msg["MATH_TRIG_TAN"] = "tan";  // untranslated
+Blockly.Msg["MATH_TRIG_TOOLTIP_ACOS"] = "返回一个数值的反余弦值。";
+Blockly.Msg["MATH_TRIG_TOOLTIP_ASIN"] = "返回一个数值的反正弦值。";
+Blockly.Msg["MATH_TRIG_TOOLTIP_ATAN"] = "返回一个数值的反正切值。";
+Blockly.Msg["MATH_TRIG_TOOLTIP_COS"] = "返回指定角度的余弦值(非弧度）。";
+Blockly.Msg["MATH_TRIG_TOOLTIP_SIN"] = "返回指定角度的正弦值(非弧度）。";
+Blockly.Msg["MATH_TRIG_TOOLTIP_TAN"] = "返回指定角度的正切值(非弧度）。";
+Blockly.Msg["NEW_COLOUR_VARIABLE"] = "创建颜色变量...";
+Blockly.Msg["NEW_NUMBER_VARIABLE"] = "创建数字变量...";
+Blockly.Msg["NEW_STRING_VARIABLE"] = "创建字符串变量...";
+Blockly.Msg["NEW_VARIABLE"] = "创建变量...";
+Blockly.Msg["NEW_VARIABLE_TITLE"] = "新变量的名称：";
+Blockly.Msg["NEW_VARIABLE_TYPE_TITLE"] = "新变量的类型：";
+Blockly.Msg["ORDINAL_NUMBER_SUFFIX"] = "空白";
+Blockly.Msg["PROCEDURES_ALLOW_STATEMENTS"] = "允许声明";
+Blockly.Msg["PROCEDURES_BEFORE_PARAMS"] = "与：";
+Blockly.Msg["PROCEDURES_CALLNORETURN_HELPURL"] = "https://zh.wikipedia.org/wiki/子程序";
+Blockly.Msg["PROCEDURES_CALLNORETURN_TOOLTIP"] = "运行用户定义的函数“%1”。";
+Blockly.Msg["PROCEDURES_CALLRETURN_HELPURL"] = "https://zh.wikipedia.org/wiki/子程序";
+Blockly.Msg["PROCEDURES_CALLRETURN_TOOLTIP"] = "运行用户定义的函数“%1”，并使用它的输出值。";
+Blockly.Msg["PROCEDURES_CALL_BEFORE_PARAMS"] = "与：";
+Blockly.Msg["PROCEDURES_CREATE_DO"] = "创建“%1”";
+Blockly.Msg["PROCEDURES_DEFNORETURN_COMMENT"] = "描述该功能...";
+Blockly.Msg["PROCEDURES_DEFNORETURN_DO"] = "空白";
+Blockly.Msg["PROCEDURES_DEFNORETURN_HELPURL"] = "https://zh.wikipedia.org/wiki/子程序";
+Blockly.Msg["PROCEDURES_DEFNORETURN_PROCEDURE"] = "做点什么";
+Blockly.Msg["PROCEDURES_DEFNORETURN_TITLE"] = "至";
+Blockly.Msg["PROCEDURES_DEFNORETURN_TOOLTIP"] = "创建一个不带输出值的函数。";
+Blockly.Msg["PROCEDURES_DEFRETURN_HELPURL"] = "https://zh.wikipedia.org/wiki/子程序";
+Blockly.Msg["PROCEDURES_DEFRETURN_RETURN"] = "返回";
+Blockly.Msg["PROCEDURES_DEFRETURN_TOOLTIP"] = "创建一个有输出值的函数。";
+Blockly.Msg["PROCEDURES_DEF_DUPLICATE_WARNING"] = "警告：此函数具有重复参数。";
+Blockly.Msg["PROCEDURES_HIGHLIGHT_DEF"] = "突出显示函数定义";
+Blockly.Msg["PROCEDURES_IFRETURN_HELPURL"] = "http://c2.com/cgi/wiki?GuardClause";
+Blockly.Msg["PROCEDURES_IFRETURN_TOOLTIP"] = "如果值为真，则返回第二个值。";
+Blockly.Msg["PROCEDURES_IFRETURN_WARNING"] = "警告：这个块只能在函数内部使用。";
+Blockly.Msg["PROCEDURES_MUTATORARG_TITLE"] = "输入名称：";
+Blockly.Msg["PROCEDURES_MUTATORARG_TOOLTIP"] = "添加函数输入。";
+Blockly.Msg["PROCEDURES_MUTATORCONTAINER_TITLE"] = "输入";
+Blockly.Msg["PROCEDURES_MUTATORCONTAINER_TOOLTIP"] = "添加、移除或重新排此函数的输入。";
+Blockly.Msg["REDO"] = "重做";
+Blockly.Msg["REMOVE_COMMENT"] = "删除注释";
+Blockly.Msg["RENAME_VARIABLE"] = "重命名变量...";
+Blockly.Msg["RENAME_VARIABLE_TITLE"] = "将所有“%1”变量重命名为:";
+Blockly.Msg["TEXT_APPEND_HELPURL"] = "https://github.com/google/blockly/wiki/Text#text-modification";  // untranslated
+Blockly.Msg["TEXT_APPEND_TITLE"] = "向%1附加文本%2";
+Blockly.Msg["TEXT_APPEND_TOOLTIP"] = "将一些文本追加到变量“%1”里。";
+Blockly.Msg["TEXT_CHANGECASE_HELPURL"] = "https://github.com/google/blockly/wiki/Text#adjusting-text-case";  // untranslated
+Blockly.Msg["TEXT_CHANGECASE_OPERATOR_LOWERCASE"] = "转为小写";
+Blockly.Msg["TEXT_CHANGECASE_OPERATOR_TITLECASE"] = "转为首字母大写";
+Blockly.Msg["TEXT_CHANGECASE_OPERATOR_UPPERCASE"] = "转为大写";
+Blockly.Msg["TEXT_CHANGECASE_TOOLTIP"] = "用不同的大小写模式复制并返回这段文字。";
+Blockly.Msg["TEXT_CHARAT_FIRST"] = "寻找第一个字母";
+Blockly.Msg["TEXT_CHARAT_FROM_END"] = "获取字符从倒数#";
+Blockly.Msg["TEXT_CHARAT_FROM_START"] = "获取字符从#";
+Blockly.Msg["TEXT_CHARAT_HELPURL"] = "https://github.com/google/blockly/wiki/Text#extracting-text";  // untranslated
+Blockly.Msg["TEXT_CHARAT_LAST"] = "寻找最后一个字母";
+Blockly.Msg["TEXT_CHARAT_RANDOM"] = "寻找随机的字母";
+Blockly.Msg["TEXT_CHARAT_TAIL"] = "空白";
+Blockly.Msg["TEXT_CHARAT_TITLE"] = "在文本%1 里 %2";
+Blockly.Msg["TEXT_CHARAT_TOOLTIP"] = "返回位于指定位置的字母。";
+Blockly.Msg["TEXT_COUNT_HELPURL"] = "https://github.com/google/blockly/wiki/Text#counting-substrings";
+Blockly.Msg["TEXT_COUNT_MESSAGE0"] = "计算%1在%2里出现的次数";
+Blockly.Msg["TEXT_COUNT_TOOLTIP"] = "计算在一段文本中，某个部分文本重复出现了多少次。";
+Blockly.Msg["TEXT_CREATE_JOIN_ITEM_TOOLTIP"] = "将一个项添加到文本中。";
+Blockly.Msg["TEXT_CREATE_JOIN_TITLE_JOIN"] = "加入";
+Blockly.Msg["TEXT_CREATE_JOIN_TOOLTIP"] = "添加、移除或重新排列各节来重新配置这个文本块。";
+Blockly.Msg["TEXT_GET_SUBSTRING_END_FROM_END"] = "到最后一个字符#";
+Blockly.Msg["TEXT_GET_SUBSTRING_END_FROM_START"] = "至字符#";
+Blockly.Msg["TEXT_GET_SUBSTRING_END_LAST"] = "到最后一个字符";
+Blockly.Msg["TEXT_GET_SUBSTRING_HELPURL"] = "https://github.com/google/blockly/wiki/Text#extracting-a-region-of-text";  // untranslated
+Blockly.Msg["TEXT_GET_SUBSTRING_INPUT_IN_TEXT"] = "从文本";
+Blockly.Msg["TEXT_GET_SUBSTRING_START_FIRST"] = "取得子串自第一个字符";
+Blockly.Msg["TEXT_GET_SUBSTRING_START_FROM_END"] = "取得子串自倒数#";
+Blockly.Msg["TEXT_GET_SUBSTRING_START_FROM_START"] = "取得子串自#";
+Blockly.Msg["TEXT_GET_SUBSTRING_TAIL"] = "空白";
+Blockly.Msg["TEXT_GET_SUBSTRING_TOOLTIP"] = "返回文本中指定的一部分。";
+Blockly.Msg["TEXT_INDEXOF_HELPURL"] = "https://github.com/google/blockly/wiki/Text#finding-text";  // untranslated
+Blockly.Msg["TEXT_INDEXOF_OPERATOR_FIRST"] = "寻找第一次出现的文本";
+Blockly.Msg["TEXT_INDEXOF_OPERATOR_LAST"] = "寻找最后一次出现的文本";
+Blockly.Msg["TEXT_INDEXOF_TITLE"] = "在文本 %1 里 %2  %3";
+Blockly.Msg["TEXT_INDEXOF_TOOLTIP"] = "返回第一个文本段在第二个文本段中的第一/最后一个匹配项的起始位置。如果未找到，则返回%1。";
+Blockly.Msg["TEXT_ISEMPTY_HELPURL"] = "https://github.com/google/blockly/wiki/Text#checking-for-empty-text";  // untranslated
+Blockly.Msg["TEXT_ISEMPTY_TITLE"] = "%1是空的";
+Blockly.Msg["TEXT_ISEMPTY_TOOLTIP"] = "如果给定的文本为空，则返回真。";
+Blockly.Msg["TEXT_JOIN_HELPURL"] = "https://github.com/google/blockly/wiki/Text#text-creation";  // untranslated
+Blockly.Msg["TEXT_JOIN_TITLE_CREATEWITH"] = "建立文本从";
+Blockly.Msg["TEXT_JOIN_TOOLTIP"] = "通过串起任意数量的项以建立一段文本。";
+Blockly.Msg["TEXT_LENGTH_HELPURL"] = "https://github.com/google/blockly/wiki/Text#text-modification";  // untranslated
+Blockly.Msg["TEXT_LENGTH_TITLE"] = "%1的长度";
+Blockly.Msg["TEXT_LENGTH_TOOLTIP"] = "返回给定文本的字母数（包括空格）。";
+Blockly.Msg["TEXT_PRINT_HELPURL"] = "https://github.com/google/blockly/wiki/Text#printing-text";  // untranslated
+Blockly.Msg["TEXT_PRINT_TITLE"] = "输出%1";
+Blockly.Msg["TEXT_PRINT_TOOLTIP"] = "输出指定的文字、数字或其他值。";
+Blockly.Msg["TEXT_PROMPT_HELPURL"] = "https://github.com/google/blockly/wiki/Text#getting-input-from-the-user";  // untranslated
+Blockly.Msg["TEXT_PROMPT_TOOLTIP_NUMBER"] = "要求用户输入数字。";
+Blockly.Msg["TEXT_PROMPT_TOOLTIP_TEXT"] = "要求用户输入一些文本。";
+Blockly.Msg["TEXT_PROMPT_TYPE_NUMBER"] = "要求输入数字，并显示提示消息";
+Blockly.Msg["TEXT_PROMPT_TYPE_TEXT"] = "要求输入文本，并显示提示消息";
+Blockly.Msg["TEXT_REPLACE_HELPURL"] = "https://github.com/google/blockly/wiki/Text#replacing-substrings";
+Blockly.Msg["TEXT_REPLACE_MESSAGE0"] = "在%3中，将%1替换为%2";
+Blockly.Msg["TEXT_REPLACE_TOOLTIP"] = "在一段文本中，将出现过的某部分文本都替换掉。";
+Blockly.Msg["TEXT_REVERSE_HELPURL"] = "https://github.com/google/blockly/wiki/Text#reversing-text";
+Blockly.Msg["TEXT_REVERSE_MESSAGE0"] = "翻转文本%1";
+Blockly.Msg["TEXT_REVERSE_TOOLTIP"] = "将文本中各个字符的顺序倒转。";
+Blockly.Msg["TEXT_TEXT_HELPURL"] = "https://zh.wikipedia.org/wiki/字符串";
+Blockly.Msg["TEXT_TEXT_TOOLTIP"] = "一个字、词语或一行文本。";
+Blockly.Msg["TEXT_TRIM_HELPURL"] = "https://github.com/google/blockly/wiki/Text#trimming-removing-spaces";  // untranslated
+Blockly.Msg["TEXT_TRIM_OPERATOR_BOTH"] = "消除其两侧的空白";
+Blockly.Msg["TEXT_TRIM_OPERATOR_LEFT"] = "消除其左侧的空白";
+Blockly.Msg["TEXT_TRIM_OPERATOR_RIGHT"] = "消除其右侧的空白";
+Blockly.Msg["TEXT_TRIM_TOOLTIP"] = "从某一端或同时从两端删除多余的空白，并返回这段文字的一个副本。";
+Blockly.Msg["TODAY"] = "今天";
+Blockly.Msg["UNDO"] = "撤销";
+Blockly.Msg["VARIABLES_DEFAULT_NAME"] = "项目";
+Blockly.Msg["VARIABLES_GET_CREATE_SET"] = "创建“设定%1”";
+Blockly.Msg["VARIABLES_GET_HELPURL"] = "https://github.com/google/blockly/wiki/Variables#get";  // untranslated
+Blockly.Msg["VARIABLES_GET_TOOLTIP"] = "返回此变量的值。";
+Blockly.Msg["VARIABLES_SET"] = "赋值 %1 为 %2";
+Blockly.Msg["VARIABLES_SET_CREATE_GET"] = "创建“获得%1”";
+Blockly.Msg["VARIABLES_SET_HELPURL"] = "https://github.com/google/blockly/wiki/Variables#set";  // untranslated
+Blockly.Msg["VARIABLES_SET_TOOLTIP"] = "设置此变量，以使它和输入值相等。";
+Blockly.Msg["VARIABLE_ALREADY_EXISTS"] = "名字叫“%1”的变量已经存在了。";
+Blockly.Msg["VARIABLE_ALREADY_EXISTS_FOR_ANOTHER_TYPE"] = "名字叫“%1”的变量已经有了另一个类型：“%2”。";
+Blockly.Msg["WORKSPACE_COMMENT_DEFAULT_TEXT"] = "说点什么...";
+Blockly.Msg["CONTROLS_FOREACH_INPUT_DO"] = Blockly.Msg["CONTROLS_REPEAT_INPUT_DO"];
+Blockly.Msg["CONTROLS_FOR_INPUT_DO"] = Blockly.Msg["CONTROLS_REPEAT_INPUT_DO"];
+Blockly.Msg["CONTROLS_IF_ELSEIF_TITLE_ELSEIF"] = Blockly.Msg["CONTROLS_IF_MSG_ELSEIF"];
+Blockly.Msg["CONTROLS_IF_ELSE_TITLE_ELSE"] = Blockly.Msg["CONTROLS_IF_MSG_ELSE"];
+Blockly.Msg["CONTROLS_IF_IF_TITLE_IF"] = Blockly.Msg["CONTROLS_IF_MSG_IF"];
+Blockly.Msg["CONTROLS_IF_MSG_THEN"] = Blockly.Msg["CONTROLS_REPEAT_INPUT_DO"];
+Blockly.Msg["CONTROLS_WHILEUNTIL_INPUT_DO"] = Blockly.Msg["CONTROLS_REPEAT_INPUT_DO"];
+Blockly.Msg["LISTS_CREATE_WITH_ITEM_TITLE"] = Blockly.Msg["VARIABLES_DEFAULT_NAME"];
+Blockly.Msg["LISTS_GET_INDEX_HELPURL"] = Blockly.Msg["LISTS_INDEX_OF_HELPURL"];
+Blockly.Msg["LISTS_GET_INDEX_INPUT_IN_LIST"] = Blockly.Msg["LISTS_INLIST"];
+Blockly.Msg["LISTS_GET_SUBLIST_INPUT_IN_LIST"] = Blockly.Msg["LISTS_INLIST"];
+Blockly.Msg["LISTS_INDEX_OF_INPUT_IN_LIST"] = Blockly.Msg["LISTS_INLIST"];
+Blockly.Msg["LISTS_SET_INDEX_INPUT_IN_LIST"] = Blockly.Msg["LISTS_INLIST"];
+Blockly.Msg["MATH_CHANGE_TITLE_ITEM"] = Blockly.Msg["VARIABLES_DEFAULT_NAME"];
+Blockly.Msg["PROCEDURES_DEFRETURN_COMMENT"] = Blockly.Msg["PROCEDURES_DEFNORETURN_COMMENT"];
+Blockly.Msg["PROCEDURES_DEFRETURN_DO"] = Blockly.Msg["PROCEDURES_DEFNORETURN_DO"];
+Blockly.Msg["PROCEDURES_DEFRETURN_PROCEDURE"] = Blockly.Msg["PROCEDURES_DEFNORETURN_PROCEDURE"];
+Blockly.Msg["PROCEDURES_DEFRETURN_TITLE"] = Blockly.Msg["PROCEDURES_DEFNORETURN_TITLE"];
+Blockly.Msg["TEXT_APPEND_VARIABLE"] = Blockly.Msg["VARIABLES_DEFAULT_NAME"];
+Blockly.Msg["TEXT_CREATE_JOIN_ITEM_TITLE_ITEM"] = Blockly.Msg["VARIABLES_DEFAULT_NAME"];
+
+Blockly.Msg["MATH_HUE"] = "230";
+Blockly.Msg["LOOPS_HUE"] = "120";
+Blockly.Msg["LISTS_HUE"] = "260";
+Blockly.Msg["LOGIC_HUE"] = "210";
+Blockly.Msg["VARIABLES_HUE"] = "330";
+Blockly.Msg["TEXTS_HUE"] = "160";
+Blockly.Msg["PROCEDURES_HUE"] = "290";
+Blockly.Msg["COLOUR_HUE"] = "20";
+Blockly.Msg["VARIABLES_DYNAMIC_HUE"] = "310";
\ No newline at end of file
diff --git a/_server/colorPicker/LICENSE.md b/_server/colorPicker/LICENSE.md
new file mode 100644
index 00000000..8394aa4a
--- /dev/null
+++ b/_server/colorPicker/LICENSE.md
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Peter Dematté
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
\ No newline at end of file
diff --git a/_server/colorPicker/color.all.min.js b/_server/colorPicker/color.all.min.js
new file mode 100644
index 00000000..a8032a09
--- /dev/null
+++ b/_server/colorPicker/color.all.min.js
@@ -0,0 +1,4 @@
+/*! colorPicker - v1.0.0 2016-05-18 */
+
+!function(a,b){"use strict";function c(a,c,d,f,g){if("string"==typeof c){var c=v.txt2color(c);d=c.type,n[d]=c[d],g=g!==b?g:c.alpha}else if(c)for(var h in c)a[d][h]="Lab"===d?k(c[h],l[d][h][0],l[d][h][1]):k(c[h]/l[d][h][1],0,1);return g!==b&&(a.alpha=k(+g,0,1)),e(d,f?a:b)}function d(a,b,c){var d=m.options.grey,e={};return e.RGB={r:a.r,g:a.g,b:a.b},e.rgb={r:b.r,g:b.g,b:b.b},e.alpha=c,e.equivalentGrey=r.round(d.r*a.r+d.g*a.g+d.b*a.b),e.rgbaMixBlack=i(b,{r:0,g:0,b:0},c,1),e.rgbaMixWhite=i(b,{r:1,g:1,b:1},c,1),e.rgbaMixBlack.luminance=h(e.rgbaMixBlack,!0),e.rgbaMixWhite.luminance=h(e.rgbaMixWhite,!0),m.options.customBG&&(e.rgbaMixCustom=i(b,m.options.customBG,c,1),e.rgbaMixCustom.luminance=h(e.rgbaMixCustom,!0),m.options.customBG.luminance=h(m.options.customBG,!0)),e}function e(a,b){var c,e,k,o=r,p=b||n,q=v,s=m.options,t=l,u=p.RND,w="",x="",y={hsl:"hsv",cmyk:"cmy",rgb:a},z=u.rgb;if("alpha"!==a){for(var A in t)if(!t[A][A]){a!==A&&"XYZ"!==A&&(x=y[A]||"rgb",p[A]=q[x+"2"+A](p[x])),u[A]||(u[A]={}),c=p[A];for(w in c)u[A][w]=o.round(c[w]*("Lab"===A?1:t[A][w][1]))}"Lab"!==a&&delete p._rgb,z=u.rgb,p.HEX=q.RGB2HEX(z),p.equivalentGrey=s.grey.r*p.rgb.r+s.grey.g*p.rgb.g+s.grey.b*p.rgb.b,p.webSave=e=f(z,51),p.webSmart=k=f(z,17),p.saveColor=z.r===e.r&&z.g===e.g&&z.b===e.b?"web save":z.r===k.r&&z.g===k.g&&z.b===k.b?"web smart":"",p.hueRGB=q.hue2RGB(p.hsv.h),b&&(p.background=d(z,p.rgb,p.alpha))}var B,C,D,E,F,G,H,I=p.rgb,J=p.alpha,K="luminance",L=p.background,M=i,N=h,O=j,P=g;return B=M(I,{r:0,g:0,b:0},J,1),B[K]=N(B,!0),p.rgbaMixBlack=B,C=M(I,{r:1,g:1,b:1},J,1),C[K]=N(C,!0),p.rgbaMixWhite=C,s.allMixDetails&&(B.WCAG2Ratio=O(B[K],0),C.WCAG2Ratio=O(C[K],1),s.customBG&&(D=M(I,s.customBG,J,1),D[K]=N(D,!0),D.WCAG2Ratio=O(D[K],s.customBG[K]),p.rgbaMixCustom=D),E=M(I,L.rgb,J,L.alpha),E[K]=N(E,!0),p.rgbaMixBG=E,F=M(I,L.rgbaMixBlack,J,1),F[K]=N(F,!0),F.WCAG2Ratio=O(F[K],L.rgbaMixBlack[K]),F.luminanceDelta=o.abs(F[K]-L.rgbaMixBlack[K]),F.hueDelta=P(L.rgbaMixBlack,F,!0),p.rgbaMixBGMixBlack=F,G=M(I,L.rgbaMixWhite,J,1),G[K]=N(G,!0),G.WCAG2Ratio=O(G[K],L.rgbaMixWhite[K]),G.luminanceDelta=o.abs(G[K]-L.rgbaMixWhite[K]),G.hueDelta=P(L.rgbaMixWhite,G,!0),p.rgbaMixBGMixWhite=G),s.customBG&&(H=M(I,L.rgbaMixCustom,J,1),H[K]=N(H,!0),H.WCAG2Ratio=O(H[K],L.rgbaMixCustom[K]),p.rgbaMixBGMixCustom=H,H.luminanceDelta=o.abs(H[K]-L.rgbaMixCustom[K]),H.hueDelta=P(L.rgbaMixCustom,H,!0)),p.RGBLuminance=N(z),p.HUELuminance=N(p.hueRGB),s.convertCallback&&s.convertCallback(p,a),p}function f(a,b){var c={},d=0,e=b/2;for(var f in a)d=a[f]%b,c[f]=a[f]+(d>e?b-d:-d);return c}function g(a,b,c){var d=r;return(d.max(a.r-b.r,b.r-a.r)+d.max(a.g-b.g,b.g-a.g)+d.max(a.b-b.b,b.b-a.b))*(c?255:1)/765}function h(a,b){for(var c=b?1:255,d=[a.r/c,a.g/c,a.b/c],e=m.options.luminance,f=d.length;f--;)d[f]=d[f]<=.03928?d[f]/12.92:r.pow((d[f]+.055)/1.055,2.4);return e.r*d[0]+e.g*d[1]+e.b*d[2]}function i(a,c,d,e){var f={},g=d!==b?d:1,h=e!==b?e:1,i=g+h*(1-g);for(var j in a)f[j]=(a[j]*g+c[j]*h*(1-g))/i;return f.a=i,f}function j(a,b){var c=1;return c=a>=b?(a+.05)/(b+.05):(b+.05)/(a+.05),r.round(100*c)/100}function k(a,b,c){return a>c?c:b>a?b:a}var l={rgb:{r:[0,255],g:[0,255],b:[0,255]},hsv:{h:[0,360],s:[0,100],v:[0,100]},hsl:{h:[0,360],s:[0,100],l:[0,100]},cmy:{c:[0,100],m:[0,100],y:[0,100]},cmyk:{c:[0,100],m:[0,100],y:[0,100],k:[0,100]},Lab:{L:[0,100],a:[-128,127],b:[-128,127]},XYZ:{X:[0,100],Y:[0,100],Z:[0,100]},alpha:{alpha:[0,1]},HEX:{HEX:[0,16777215]}},m={},n={},o={X:[.4124564,.3575761,.1804375],Y:[.2126729,.7151522,.072175],Z:[.0193339,.119192,.9503041],R:[3.2404542,-1.5371385,-.4985314],G:[-.969266,1.8760108,.041556],B:[.0556434,-.2040259,1.0572252]},p={r:.298954,g:.586434,b:.114612},q={r:.2126,g:.7152,b:.0722},r=a.Math,s=(a.parseInt,a.Colors=function(a){this.colors={RND:{}},this.options={color:"rgba(204, 82, 37, 0.8)",XYZMatrix:o,grey:p,luminance:q,valueRanges:l},t(this,a||{})}),t=function(a,d){var e,f,g=a.options;u(a);for(var h in d)d[h]!==b&&(g[h]=d[h]);e=g.XYZMatrix,d.XYZReference||(g.XYZReference={X:e.X[0]+e.X[1]+e.X[2],Y:e.Y[0]+e.Y[1]+e.Y[2],Z:e.Z[0]+e.Z[1]+e.Z[2]}),f=g.customBG,g.customBG="string"==typeof f?v.txt2color(f).rgb:f,n=c(a.colors,g.color,b,!0)},u=function(a){m!==a&&(m=a,n=a.colors)};s.prototype.setColor=function(a,d,f){return u(this),a?c(this.colors,a,d,b,f):(f!==b&&(this.colors.alpha=k(f,0,1)),e(d))},s.prototype.getColor=function(a){var c=this.colors,d=0;if(a){for(a=a.split(".");c[a[d]];)c=c[a[d++]];a.length!==d&&(c=b)}return c},s.prototype.setCustomBackground=function(a){return u(this),this.options.customBG="string"==typeof a?v.txt2color(a).rgb:a,c(this.colors,b,"rgb")},s.prototype.saveAsBackground=function(){return u(this),c(this.colors,b,"rgb",!0)},s.prototype.convertColor=function(a,b){var c=v,d=l,e=b.split("2"),f=e[0],g=e[1],h=/(?:RG|HS|CM|LA)/,i=h.test(f),j=h.test(g),k={LAB:"Lab"},m=function(a,b,c){var e={},f="Lab"===b?1:0;for(var g in a)e[g]=c?r.round(a[g]*(f||d[b][g][1])):a[g]/(f||d[b][g][1]);return e};return f=d[f]?f:k[f]||f.toLowerCase(),g=d[g]?g:k[g]||g.toLowerCase(),i&&"RGB2HEX"!==b&&(a=m(a,f)),a=f===g?a:c[f+"2"+g]?c[f+"2"+g](a,!0):"HEX"===g?c.RGB2HEX("RGB2HEX"===b?a:m("rgb"===f?a:c[f+"2rgb"](a,!0),"rgb",!0)):c["rgb2"+g](c[f+"2rgb"](a,!0),!0),j&&(a=m(a,g,!0)),a},s.prototype.toString=function(a,b){return v.color2text((a||"rgb").toLowerCase(),this.colors,b)};var v={txt2color:function(a){var b={},c=a.replace(/(?:#|\)|%)/g,"").split("("),d=(c[1]||"").split(/,\s*/),e=c[1]?c[0].substr(0,3):"rgb",f="";if(b.type=e,b[e]={},c[1])for(var g=3;g--;)f=e[g]||e.charAt(g),b[e][f]=+d[g]/l[e][f][1];else b.rgb=v.HEX2rgb(c[0]);return b.alpha=d[3]?+d[3]:1,b},color2text:function(a,b,c){var d=c!==!1&&r.round(100*b.alpha)/100,e="number"==typeof d&&c!==!1&&(c||1!==d),f=b.RND.rgb,g=b.RND.hsl,h="hex"===a&&e,i="hex"===a&&!h,j="rgb"===a||h,k=j?f.r+", "+f.g+", "+f.b:i?"#"+b.HEX:g.h+", "+g.s+"%, "+g.l+"%";return i?k:(h?"rgb":a)+(e?"a":"")+"("+k+(e?", "+d:"")+")"},RGB2HEX:function(a){return((a.r<16?"0":"")+a.r.toString(16)+(a.g<16?"0":"")+a.g.toString(16)+(a.b<16?"0":"")+a.b.toString(16)).toUpperCase()},HEX2rgb:function(a){return a=a.split(""),{r:+("0x"+a[0]+a[a[3]?1:0])/255,g:+("0x"+a[a[3]?2:1]+(a[3]||a[1]))/255,b:+("0x"+(a[4]||a[2])+(a[5]||a[2]))/255}},hue2RGB:function(a){var b=r,c=6*a,d=~~c%6,e=6===c?0:c-d;return{r:b.round(255*[1,1-e,0,0,e,1][d]),g:b.round(255*[e,1,1,1-e,0,0][d]),b:b.round(255*[0,0,e,1,1,1-e][d])}},rgb2hsv:function(a){var b,c,d,e=r,f=a.r,g=a.g,h=a.b,i=0;return h>g&&(g=h+(h=g,0),i=-1),c=h,g>f&&(f=g+(g=f,0),i=-2/6-i,c=e.min(g,h)),b=f-c,d=f?b/f:0,{h:1e-15>d?n&&n.hsl&&n.hsl.h||0:b?e.abs(i+(g-h)/(6*b)):0,s:f?b/f:n&&n.hsv&&n.hsv.s||0,v:f}},hsv2rgb:function(a){var b=6*a.h,c=a.s,d=a.v,e=~~b,f=b-e,g=d*(1-c),h=d*(1-f*c),i=d*(1-(1-f)*c),j=e%6;return{r:[d,h,g,g,i,d][j],g:[i,d,d,h,g,g][j],b:[g,g,i,d,d,h][j]}},hsv2hsl:function(a){var b=(2-a.s)*a.v,c=a.s*a.v;return c=a.s?1>b?b?c/b:0:c/(2-b):0,{h:a.h,s:a.v||c?c:n&&n.hsl&&n.hsl.s||0,l:b/2}},rgb2hsl:function(a,b){var c=v.rgb2hsv(a);return v.hsv2hsl(b?c:n.hsv=c)},hsl2rgb:function(a){var b=6*a.h,c=a.s,d=a.l,e=.5>d?d*(1+c):d+c-c*d,f=d+d-e,g=e?(e-f)/e:0,h=~~b,i=b-h,j=e*g*i,k=f+j,l=e-j,m=h%6;return{r:[e,l,f,f,k,e][m],g:[k,e,e,l,f,f][m],b:[f,f,k,e,e,l][m]}},rgb2cmy:function(a){return{c:1-a.r,m:1-a.g,y:1-a.b}},cmy2cmyk:function(a){var b=r,c=b.min(b.min(a.c,a.m),a.y),d=1-c||1e-20;return{c:(a.c-c)/d,m:(a.m-c)/d,y:(a.y-c)/d,k:c}},cmyk2cmy:function(a){var b=a.k;return{c:a.c*(1-b)+b,m:a.m*(1-b)+b,y:a.y*(1-b)+b}},cmy2rgb:function(a){return{r:1-a.c,g:1-a.m,b:1-a.y}},rgb2cmyk:function(a,b){var c=v.rgb2cmy(a);return v.cmy2cmyk(b?c:n.cmy=c)},cmyk2rgb:function(a,b){var c=v.cmyk2cmy(a);return v.cmy2rgb(b?c:n.cmy=c)},XYZ2rgb:function(a,b){var c=r,d=m.options.XYZMatrix,e=a.X,f=a.Y,g=a.Z,h=e*d.R[0]+f*d.R[1]+g*d.R[2],i=e*d.G[0]+f*d.G[1]+g*d.G[2],j=e*d.B[0]+f*d.B[1]+g*d.B[2],l=1/2.4;return d=.0031308,h=h>d?1.055*c.pow(h,l)-.055:12.92*h,i=i>d?1.055*c.pow(i,l)-.055:12.92*i,j=j>d?1.055*c.pow(j,l)-.055:12.92*j,b||(n._rgb={r:h,g:i,b:j}),{r:k(h,0,1),g:k(i,0,1),b:k(j,0,1)}},rgb2XYZ:function(a){var b=r,c=m.options.XYZMatrix,d=a.r,e=a.g,f=a.b,g=.04045;return d=d>g?b.pow((d+.055)/1.055,2.4):d/12.92,e=e>g?b.pow((e+.055)/1.055,2.4):e/12.92,f=f>g?b.pow((f+.055)/1.055,2.4):f/12.92,{X:d*c.X[0]+e*c.X[1]+f*c.X[2],Y:d*c.Y[0]+e*c.Y[1]+f*c.Y[2],Z:d*c.Z[0]+e*c.Z[1]+f*c.Z[2]}},XYZ2Lab:function(a){var b=r,c=m.options.XYZReference,d=a.X/c.X,e=a.Y/c.Y,f=a.Z/c.Z,g=16/116,h=1/3,i=.008856,j=7.787037;return d=d>i?b.pow(d,h):j*d+g,e=e>i?b.pow(e,h):j*e+g,f=f>i?b.pow(f,h):j*f+g,{L:116*e-16,a:500*(d-e),b:200*(e-f)}},Lab2XYZ:function(a){var b=r,c=m.options.XYZReference,d=(a.L+16)/116,e=a.a/500+d,f=d-a.b/200,g=b.pow(e,3),h=b.pow(d,3),i=b.pow(f,3),j=16/116,k=.008856,l=7.787037;return{X:(g>k?g:(e-j)/l)*c.X,Y:(h>k?h:(d-j)/l)*c.Y,Z:(i>k?i:(f-j)/l)*c.Z}},rgb2Lab:function(a,b){var c=v.rgb2XYZ(a);return v.XYZ2Lab(b?c:n.XYZ=c)},Lab2rgb:function(a,b){var c=v.Lab2XYZ(a);return v.XYZ2rgb(b?c:n.XYZ=c,b)}}}(window),function(a){"use strict";var b='^§app alpha-bg-w">^§slds">^§sldl-1">$^§sldl-2">$^§sldl-3">$^§curm">$^§sldr-1">$^§sldr-2">$^§sldr-4">$^§curl">$^§curr">$$^§opacity">|^§opacity-slider">$$$^§memo">^§raster">$^§raster-bg">$|$|$|$|$|$|$|$|$^§memo-store">$^§memo-cursor">$$^§panel">^§hsv">^hsl-mode §ß">$^hsv-h-ß §ß">H$^hsv-h-~ §~">-^§nsarrow">$$^hsl-h-@ §@">H$^hsv-s-ß §ß">S$^hsv-s-~ §~">-$^hsl-s-@ §@">S$^hsv-v-ß §ß">B$^hsv-v-~ §~">-$^hsl-l-@ §@">L$$^§hsl §hide">^hsv-mode §ß">$^hsl-h-ß §ß">H$^hsl-h-~ §~">-$^hsv-h-@ §@">H$^hsl-s-ß §ß">S$^hsl-s-~ §~">-$^hsv-s-@ §@">S$^hsl-l-ß §ß">L$^hsl-l-~ §~">-$^hsv-v-@ §@">B$$^§rgb">^rgb-r-ß §ß">R$^rgb-r-~ §~">-$^rgb-r-@ §ß">&nbsp;$^rgb-g-ß §ß">G$^rgb-g-~ §~">-$^rgb-g-@ §ß">&nbsp;$^rgb-b-ß §ß">B$^rgb-b-~ §~">-$^rgb-b-@ §ß">&nbsp;$$^§cmyk">^Lab-mode §ß">$^cmyk-c-ß §@">C$^cmyk-c-~ §~">-$^Lab-L-@ §@">L$^cmyk-m-ß §@">M$^cmyk-m-~ §~">-$^Lab-a-@ §@">a$^cmyk-y-ß §@">Y$^cmyk-y-~ §~">-$^Lab-b-@ §@">b$^cmyk-k-ß §@">K$^cmyk-k-~ §~">-$^Lab-x-@ §ß">&nbsp;$$^§Lab §hide">^cmyk-mode §ß">$^Lab-L-ß §@">L$^Lab-L-~ §~">-$^cmyk-c-@ §@">C$^Lab-a-ß §@">a$^Lab-a-~ §~">-$^cmyk-m-@ §@">M$^Lab-b-ß §@">b$^Lab-b-~ §~">-$^cmyk-y-@ §@">Y$^Lab-x-ß §@">&nbsp;$^Lab-x-~ §~">-$^cmyk-k-@ §@">K$$^§alpha">^alpha-ß §ß">A$^alpha-~ §~">-$^alpha-@ §ß">W$$^§HEX">^HEX-ß §ß">#$^HEX-~ §~">-$^HEX-@ §ß">M$$^§ctrl">^§raster">$^§cont">$^§cold">$^§col1">|&nbsp;$$^§col2">|&nbsp;$$^§bres">RESET$^§bsav">SAVE$$$^§exit">$^§resize">$^§resizer">|$$$'.replace(/\^/g,'<div class="').replace(/\$/g,"</div>").replace(/~/g,"disp").replace(/ß/g,"butt").replace(/@/g,"labl").replace(/\|/g,"<div>"),c="är^1,äg^1,äb^1,öh^1,öh?1,öh?2,ös?1,öv?1,üh^1,üh?1,üh?2,üs?1,ül?1,.no-rgb-r är?2,.no-rgb-r är?3,.no-rgb-r är?4,.no-rgb-g äg?2,.no-rgb-g äg?3,.no-rgb-g äg?4,.no-rgb-b äb?2,.no-rgb-b äb?3,.no-rgb-b äb?4{visibility:hidden}är^2,är^3,äg^2,äg^3,äb^2,äb^3{@-image:url(_patches.png)}.§slds div{@-image:url(_vertical.png)}öh^2,ös^1,öv^1,üh^2,üs^1,ül^1{@-image:url(_horizontal.png)}ös?4,öv^3,üs?4,ül^3{@:#000}üs?3,ül^4{@:#fff}är?1{@-color:#f00}äg?1{@-color:#0f0}äb?1{@-color:#00f}är^2{@|-1664px 0}är^3{@|-896px 0}är?1,äg?1,äb?1,öh^3,ös^2,öv?2Ü-2432Öär?2Ü-2944Öär?3Ü-4480Öär?4Ü-3202Öäg^2Äöh^2{@|-640px 0}äg^3{@|-384px 0}äg?2Ü-4736Öäg?3Ü-3968Öäg?4Ü-3712Öäb^2{@|-1152px 0}äb^3{@|-1408px 0}äb?2Ü-3456Öäb?3Ü-4224Öäb?4Ü-2688Ööh^2Äär^3Ääb?4Ü0}öh?4,üh?4Ü-1664Öös^1,öv^1,üs^1,ül^1Ääg^3{@|-256px 0}ös^3,öv?4,üs^3,ül?4Ü-2176Öös?2,öv^2Ü-1920Öüh^2{@|-768px 0}üh^3,üs^2,ül?2Ü-5184Öüs?2,ül^2Ü-5824Ö.S är^2{@|-128px -128Ö.S är?1Ääg?1Ääb?1Äöh^3Äös^2Äöv?2Ü-1408Ö.S är?2Ääb^3Ü-128Ö.S är?3Ü-896Ö.S är?4Ü-256Ö.S äg^2{@|-256px -128Ö.S äg?2Ü-1024Ö.S äg?3Ü-640Ö.S äg?4Ü-512Ö.S äb^2{@|-128px 0}.S äb?2Ü-384Ö.S äb?3Ü-768Ö.S öh?4Äüh?4Ü-1536Ö.S ös^1Äöv^1Äüs^1Äül^1{@|-512px 0}.S ös^3Äöv?4Äüs^3Äül?4Ü-1280Ö.S ös?2Äöv^2Ü-1152Ö.S üh^2{@|-1024px 0}.S üh^3Äüs^2Äül?2Ü-5440Ö.S üs?2Äül^2Ü-5696Ö.XXS ös^2,.XXS öv?2Ü-5120Ö.XXS ös^3,.XXS öv?4,.XXS üs^3,.XXS ül^3,.XXS ül?4Ü-5056Ö.XXS ös?2,.XXS öv^2Ü-4992Ö.XXS üs^2,.XXS ül?2Ü-5568Ö.XXS üs?2,.XXS ül^2Ü-5632Ö".replace(/Ü/g,"{@|0 ").replace(/Ö/g,"px}").replace(/Ä/g,",.S ").replace(/\|/g,"-position:").replace(/@/g,"background").replace(/ü/g,".hsl-").replace(/ö/g,".hsv-").replace(/ä/g,".rgb-").replace(/~/g," .no-rgb-}").replace(/\?/g," .§sldr-").replace(/\^/g," .§sldl-"),d='∑{@#bbb;font-family:monospace, "Courier New", Courier, mono;font-size:12¥line-ä15¥font-weight:bold;cursor:default;~412¥ä323¥?top-left-radius:7¥?top-Ü-radius:7¥?bottom-Ü-radius:7¥?bottom-left-radius:7¥ö@#444}.S{~266¥ä177px}.XS{~158¥ä173px}.XXS{ä105¥~154px}.no-alpha{ä308px}.no-alpha .§opacity,.no-alpha .§alpha{display:none}.S.no-alpha{ä162px}.XS.no-alpha{ä158px}.XXS.no-alpha{ä90px}∑,∑ div{border:none;padding:0¥float:none;margin:0¥outline:none;box-sizing:content-box}∑ div{|absolute}^s .§curm,«§disp,«§nsarrow,∑ .§exit,∑ ø-cursor,∑ .§resize{öimage:url(_icons.png)}∑ .do-drag div{cursor:none}∑ .§opacity,ø .§raster-bg,∑ .§raster{öimage:url(_bgs.png)}∑ ^s{~287¥ä256¥top:10¥left:10¥overflow:hidden;cursor:crosshair}.S ^s{~143¥ä128¥left:9¥top:9px}.XS ^s{left:7¥top:7px}.XXS ^s{left:5¥top:5px}^s div{~256¥ä256¥left:0px}.S ^l-1,.S ^l-2,.S ^l-3,.S ^l-4{~128¥ä128px}.XXS ^s,.XXS ^s ^l-1,.XXS ^s ^l-2,.XXS ^s ^l-3,.XXS ^s ^l-4{ä64px}^s ^r-1,^s ^r-2,^s ^r-3,^s ^r-4{~31¥left:256¥cursor:default}.S ^r-1,.S ^r-2,.S ^r-3,.S ^r-4{~15¥ä128¥left:128px}^s .§curm{margin:-5¥~11¥ä11¥ö|-36px -30px}.light .§curm{ö|-7px -30px}^s .§curl,^s .§curr{~0¥ä0¥margin:-3px -4¥border:4px solid;cursor:default;left:auto;öimage:none}^s .§curl,∑ ^s .§curl-dark,.hue-dark div.§curl{Ü:27¥?@† † † #fff}.light .§curl,∑ ^s .§curl-light,.hue-light .§curl{?@† † † #000}.S ^s .§curl,.S ^s .§curr{?~3px}.S ^s .§curl-light,.S ^s .§curl{Ü:13px}^s .§curr,∑ ^s .§curr-dark{Ü:4¥?@† #fff † †}.light .§curr,∑ ^s .§curr-light{?@† #000 † †}∑ .§opacity{bottom:44¥left:10¥ä10¥~287¥ö|0 -87px}.S .§opacity{bottom:27¥left:9¥~143¥ö|0 -100px}.XS .§opacity{left:7¥bottom:25px}.XXS .§opacity{left:5¥bottom:23px}.§opacity div{~100%;ä16¥margin-top:-3¥overflow:hidden}.§opacity .§opacity-slider{margin:0 -4¥~0¥ä8¥?~4¥?style:solid;?@#eee †}∑ ø{bottom:10¥left:10¥~288¥ä31¥ö@#fff}.S ø{ä15¥~144¥left:9¥bottom:9px}.XS ø{left:7¥bottom:7px}.XXS ø{left:5¥bottom:5px}ø div{|relative;float:left;~31¥ä31¥margin-Ü:1px}.S ø div{~15¥ä15px}∑ .§raster,ø .§raster-bg,.S ø .§raster,.S ø .§raster-bg{|absolute;top:0¥Ü:0¥bottom:0¥left:0¥~100%}.S ø .§raster-bg{ö|0 -31px}∑ .§raster{opacity:0.2;ö|0 -49px}.alpha-bg-b ø{ö@#333}.alpha-bg-b .§raster{opacity:1}ø ø-cursor{|absolute;Ü:0¥ö|-26px -87px}∑ .light ø-cursor{ö|3px -87px}.S ø-cursor{ö|-34px -95px}.S .light ø-cursor{ö|-5px -95px}∑ .§panel{|absolute;top:10¥Ü:10¥bottom:10¥~94¥?~1¥?style:solid;?@#222 #555 #555 #222;overflow:hidden;ö@#333}.S .§panel{top:9¥Ü:9¥bottom:9px}.XS .§panel{display:none}.§panel div{|relative}«§hsv,«§hsl,«§rgb,«§cmyk,«§Lab,«§alpha,.no-alpha «§HEX,«§HEX{~86¥margin:-1px 0px 1px 4¥padding:1px 0px 3¥?top-~1¥?top-style:solid;?top-@#444;?bottom-~1¥?bottom-style:solid;?bottom-@#222;float:Ö«§hsv,«§hsl{padding-top:2px}.S .§hsv,.S .§hsl{padding-top:1px}«§HEX{?bottom-style:none;?top-~0¥margin-top:-4¥padding-top:0px}.no-alpha «§HEX{?bottom-style:none}«§alpha{?bottom-style:none}.S .rgb-r .§hsv,.S .rgb-g .§hsv,.S .rgb-b .§hsv,.S .rgb-r .§hsl,.S .rgb-g .§hsl,.S .rgb-b .§hsl,.S .hsv-h .§rgb,.S .hsv-s .§rgb,.S .hsv-v .§rgb,.S .hsl-h .§rgb,.S .hsl-s .§rgb,.S .hsl-l .§rgb,.S .§cmyk,.S .§Lab{display:none}«§butt,«§labl{float:left;~14¥ä14¥margin-top:2¥text-align:center;border:1px solid}«§butt{?@#555 #222 #222 #555}«§butt:active{ö@#444}«§labl{?@†}«Lab-mode,«cmyk-mode,«hsv-mode,«hsl-mode{|absolute;Ü:0¥top:1¥ä50px}«hsv-mode,«hsl-mode{top:2px}«cmyk-mode{ä68px}.hsl-h .hsl-h-labl,.hsl-s .hsl-s-labl,.hsl-l .hsl-l-labl,.hsv-h .hsv-h-labl,.hsv-s .hsv-s-labl,.hsv-v .hsv-v-labl{@#f90}«cmyk-mode,«hsv-mode,.rgb-r .rgb-r-butt,.rgb-g .rgb-g-butt,.rgb-b .rgb-b-butt,.hsv-h .hsv-h-butt,.hsv-s .hsv-s-butt,.hsv-v .hsv-v-butt,.hsl-h .hsl-h-butt,.hsl-s .hsl-s-butt,.hsl-l .hsl-l-butt,«rgb-r-labl,«rgb-g-labl,«rgb-b-labl,«alpha-butt,«HEX-butt,«Lab-x-labl{?@#222 #555 #555 #222;ö@#444}.no-rgb-r .rgb-r-labl,.no-rgb-g .rgb-g-labl,.no-rgb-b .rgb-b-labl,.mute-alpha .alpha-butt,.no-HEX .HEX-butt,.cmy-only .Lab-x-labl{?@#555 #222 #222 #555;ö@#333}.Lab-x-disp,.cmy-only .cmyk-k-disp,.cmy-only .cmyk-k-butt{visibility:hidden}«HEX-disp{öimage:none}«§disp{float:left;~48¥ä14¥margin:2px 2px 0¥cursor:text;text-align:left;text-indent:3¥?~1¥?style:solid;?@#222 #555 #555 #222}∑ .§nsarrow{|absolute;top:0¥left:-13¥~8¥ä16¥display:none;ö|-87px -23px}∑ .start-change .§nsarrow{display:block}∑ .do-change .§nsarrow{display:block;ö|-87px -36px}.do-change .§disp{cursor:default}«§hide{display:none}«§cont,«§cold{|absolute;top:-5¥left:0¥ä3¥border:1px solid #333}«§cold{z-index:1;ö@#c00}«§cont{margin-Ü:-1¥z-index:2}«contrast .§cont{z-index:1;ö@#ccc}«orange .§cold{ö@#f90}«green .§cold{ö@#4d0}«§ctrl{|absolute;bottom:0¥left:0¥~100%;ö@#fff}.alpha-bg-b .§ctrl,«§bres,«§bsav{ö@#333}«§col1,«§col2,«§bres,«§bsav{?~1¥?style:solid;?@#555 #222 #222 #555;float:left;~45¥line-ä28¥text-align:center;top:0px}.§panel div div{ä100%}.S .§ctrl div{line-ä25px}.S «§bres,.S «§bsav{line-ä26px}∑ .§exit,∑ .§resize{Ü:3¥top:3¥~15¥ä15¥ö|0 -52px}∑ .§resize{top:auto;bottom:3¥cursor:nwse-resize;ö|-15px -52px}.S .§exit{ö|1px -52px}.XS .§resize,.XS .§exit{~10¥ä10¥Ü:0¥öimage:none}.XS .§exit{top:0px}.XS .§resize{bottom:0px}∑ .§resizer,∑ .§resizer div{|absolute;border:1px solid #888;top:-1¥Ü:-1¥bottom:-1¥left:-1¥z-index:2;display:none;cursor:nwse-resize}∑ .§resizer div{border:1px dashed #333;opacity:0.3;display:block;ö@#bbb}'.replace(/Ü/g,"right").replace(/Ö/g,"left}").replace(/∑/g,".§app").replace(/«/g,".§panel .").replace(/¥/g,"px;").replace(/\|/g,"position:").replace(/@/g,"color:").replace(/ö/g,"background-").replace(/ä/g,"height:").replace(/ø/g,".§memo").replace(/†/g,"transparent").replace(/\~/g,"width:").replace(/\?/g,"border-").replace(/\^/g,".§sld"),e="iVBORw0KGgoAAAANSUhEUgAABIAAAAABCAYAAACmC9U0AAABT0lEQVR4Xu2S3Y6CMBCFhyqIsjGBO1/B9/F5DC/pK3DHhVkUgc7Zqus2DVlGU/cnQZKTjznttNPJBABA149HyRf1iN//4mIBCg0jV4In+j9xJiuihly1V/Z9X88v//kNeDXVvyO/lK+IPR76B019+1Riab3H1zkmeqerKnL+Bzwxx6PAgZxaSQU8vB62T28pxcQeRQ2sHw6GxCOWHvP78zwHAARBABOfdYtd30rwxXOEPDF+dj2+91r6vV/id3k+/brrXmaGUkqKhX3i+ffSt16HQ/dorTGZTHrs7ev7Tl7XdZhOpzc651nfsm1bRFF0YRiGaJoGs9nsQuN/xafTCXEco65rzOdzHI9HJEmCqqqwXC6x3++RZRnKssRqtUJRFFiv19jtdthutyAi5Hl+Jo9VZg7+7f3yXuvZf5c3KaXYzByb+WIzO5ymKW82G/0BNcFhO/tOuuMAAAAASUVORK5CYII=",f="iVBORw0KGgoAAAANSUhEUgAAAAEAABfACAYAAABn2KvYAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAABHtJREFUeNrtnN9SqzAQxpOF1to6zuiVvoI+j6/gva/lA/kKeqUzjtX+QTi7SzSYBg49xdIzfL34+e1usoQQklCnmLwoCjImNwDQA2xRGMqNAYB+gPEH9IdCgIUA6Aem0P1fLoMQAPYNHYDoCKAv8OMHFgKgX2AjDPQDXn4t1l+gt/1fId//yWgE/hUJ+mAn8EyY5wCwXxhrbaHzn8E9iPlv79DdHxXTqciZ4KROnXRVZMF/6U2OPhcEavtAbZH1SM7wRDD7VoHZItCiyEQf4t6+MW9UOxaZybmdCGKqNrB9Eb5SfMg3wTyiagMtigTmWofiSDCOYNTSNz6sLDIoaCU9GWDd0tdhoMMsRm+r8U/EfB0GfjmLXiqzimDd0tdhoLMsI7la45+I+ToM/HIW0kfGVQTrlr7tA91kaUr//fxrKo8jUFB7VAn6AKpHJf+EKwAAAIYD/f7F7/8MVgMo7P+gBqDKr57Lf72V8x8AAMDgYIuvH4EAAAAMDQX6AACAQcI9GGMjDADA4MA/P2KlP8IEAAAYFCz6AACAgaLA8y8AAIN+CMYXoQAADA7u/UPYCAMAMDjI7z9S+SdwDFQX2C9Gh9GMEOWriz8/Pw1lWQZsi/L3R4czzP678Ve+P8f9nCv/C7hwLq99ah8NfKrU15zPB5pVcwtiJt9qGy0IfEE+jQa+Fn0VtI/fkxUPqBlEfRENeF+tqUpbGpi1iu8epwJzvV5XA4GpWC6XGz7F+/u766EgwJ+ckiTJKU3TnI6OjnI6OzvLZf6zMggt3dzckPhIoiTlSGpQ+eEsVegdz0fbCCi4fRs+Po+4yWdeDXiT+6pBSTeHple1pkz3FZ+avpyavoiPxgLN0B7yprY08PlyQTTm0+PWmkH7ynedNKraar4F/lRj1WpTtYh+ozL/cY2sAvZl0gcbZm0gSLBLvkxGoaogiy/HDXemQk2t5pUm8OAhH8/HH6e0mkJ9q9XKKQXfb07xfZnJbZrRxcVFVt6/t7e3Kc1ms5RGo1Eq5VIZuyl9fHw4k/M5xYeoKj64A7eqCt1ZeqWFVSl8NV9OTV3fmvP5qE9VmzSoEcsXpArK1UHen/hZbgL53BZSdyEXalGau/hU8TEW0u3VcoFPy3EDFrTgT+njydeZ0+l0UV7fu7u7iVzziQQmUm4iqRw4n/NxMxw4s/Mp1NSALxf4NEtQ10cjMDwSl+b+/j6hp6enVGb+jUvrn05iKobm6PboOt8vPISY5Pr6OqGXlxe3fOokoGtAbMUJZmqvYmaLQDP+sdrecOjtO/SXeH69P8Imutm5urqy9PDwYOny8tLS4+OjpfPzc0vPz8+WTk9PLb2+vlpZbCzN53NLx8fHVtYZS5PJxMoEZWWqsjKULY3HYytTi1Pex5OMldXKRVXxuLcy/20onmms3BBOxcr5qCrZtsrd45SPel8sGlOxGoGy0neynQ6VL9fsa1YtWlCrtj9G83G7PjdVush5n5q1iJWLZW6u21a1bUvbVnVzlru0pe3RdmlV1/23fZtbZv4Dx+7FBypx77kAAAAASUVORK5CYII=",g="iVBORw0KGgo^NSUhEUgAAB4^EACAI#DdoPxz#L0UlEQVR4Xu3cQWrDQBREwR7FF8/BPR3wXktnQL+KvxfypuEhvLJXcp06d/bXd71OPt+trIw95zr33Z1bk1/fudEv79wa++7OfayZ59wrO2PBzklcGQmAZggAAOBYgAYBmpWRAGg^BGgRofAENgAAN#I0CBA6w8AG^ECABgEa/QH§AI0CNDoDwAY^QIAGAVp/AM§AjQI0OgPAAY^QoEGARn8Aw§CNAjQ+gMABg#BCgQYCmGQmABgAAEKBBgEZ/AM§AjQI0PoDAAY^QoEGARn8AM^IAADQI0+gMABg#BCgQYDWHwAw^gAANAjT6A4AB^BGgQoNEfAD^C#0CtP4AgAE^EaBCgaUYCoAE#RoEKDRHwAw^gAANArT+AIAB^BGgQoNEfAAw^gQIMAjf4AgAE^EaBCg9QcAD^CBAgwCN/gBg§EaBGj0BwAM^IECDAK0/AG§ARoEaJqRAGg^BGgRo9AcAD^CBAgwCtPwBg§EaBGj0BwAD^CNAgQKM/AG§ARoEaP0BAAM^I0CBAoz8AG^ECABgEa/QEAAw^jQIEDrDwAY^QIAGAZpmJACaBw^RoEKD1BwAM^IECDAK0/AG§ARoEaPQHAAw^gQIMArT8AY§BGgRo/QEAAw^jQIECjPwBg§EaBGj9AQAD^CNAgQOsPABg#BAgAYBGv0BAANwCwAAGB6gYeckmpEAa^AEaBGj0BwAM^IECDAK0/AG§ARoEaPQHAAM^I0CBAoz8AY§BGgRo/QEAAw^jQIECjPwAY^QIAGARr9AQAD^CNAgQOsPABg#BAgAYBmmYkABoAAECABgEa/QEAAw^jQIEDrDwAY^QIAGARr9Ac§AjQI0OgPABg#BAgAYBWn8Aw§CNAjQ6A8ABg#BCgQYBGfwD§AI0CND6AwAG^EKBBgKYZCYAG#QoEGARn8Aw§CNAjQ+gMABg#BCgQYBGfwAw^gAANAjT6AwAG^EKBBgNYfAD^C#0CNPoDgAE^EaBCg0R8AM^IAADQK0/gCAAQ^RoEKBpRgKgAQAABGgQoNEfAD^C#0CtP4AgAE^EaBCg0R8AD^CBAgwCN/gCAAQ^RoEKD1BwAM^IECDAI3+AG§ARoEaPQHAAw^gQIMArT8AY§BGgRomsMAM^IAADQK0/gCAAQ^RoEKDRHwAw^gAANO7fQHwAw^gAANArT+AIAB^BGgQoNEfAGg^BGgRo9AcAD^CBAgwCtPwBg§EaBGj0BwAD^RIB+Ntg5iea5AD^DAIwI0CND6AwAG^EKBBgEZ/AKAB#EaBCg0R8AM^IAADQK0/gCAAQ^RoEKDRHwAM^IECDAI3+AIAB^BGgQoPUHAAw^gQIMAjf4AY§BGgRo9AcAD^CBAgwCtPwBg§EaBGiakQBo^ARoEaPQHAAw^gQIMArT8AY§BGgRo9AcAAw^jQIECjPwBg§EaBGj9AQAD^CNAgQKM/ABg#BAgAYBGv0BAAM^I0CBA6w8AG^ECABgGaZiQAGgAAQIAGARr9AQAD^CNAgQOsPABg#BAgAYBGv0Bw§CNAjQ6A8AG^ECABgFafwD§AI0CNDoDwAG^EKBBgEZ/AM§AjQI0PoDAAY^QoEGApjkMAAM^I0CBA6w8AG^ECABgEa/QEAAw^jQsIP+AIAB^BGgQoPUHAAw^gQIMAjf4AgAE#Bea/fK+3P5/3PJOvh8t1cO4nflmQAQoAEAAF9Aw/7JHfQHAAw^gQIMArT8AY§BGvwHNPoDAA0AACBAgwCN/gCAAQ^RoEKD1BwAM^IECDAI3+AG§ARoEaPQHAAw^gQIMArT8AY§BGgRo9AcAAw^jQIECjPwBg§EaBGj9AQAD^CNAgQNOMBEAD#I0CBAoz8AY§BGgRo/QEAAw^jQIECjPwAY^QIAGARr9AQAD^CNAgQOsPABg#BAgAYBGv0Bw§CNAjQ6A8AG^ECABgFafwD§AI0CNA0IwHQ^AjQI0OgPABg#BAgAYBWn8Aw§CNAjQ6A8ABg#BCgQYBGfwD§AI0CND6AwAG^EKBBgEZ/AD^C#0CNPoDAAY^QoEGA1h8AM^IAADQI0DQAG^EKBBgEZ/AM§AjQI0PoDAAY^QoEGA1h8AM^IAADQI0+gMABg#BCgQYDWHwAw^gAANArT+AIAB^BGgQoNEfAD^C#0CtP4AgAE^EaBCg9QcAD^CBAgwCN/gCAAQ^RoEKD1BwAM^IECDAK0/AG§ARoEaPQHAAw^gQIMArT8AY§BGgRo/QEAAw^jQIECjPwBgACDhFgC#07t9AfAD^C#0CtP4AgAE^EaBCg0R8Aa^AEaBGj0BwAM^IECDAK0/AG§ARoEaPQHAAM^I0CBAoz8AY§BGgRo/QEAAw^jQIECjPwAY^QIAGARr9AQAD^CNAgQOsPABg#BAgAYBmmYkABoAAECABgEa/QEAAw^jQIEDrDwAY^QIAGARr9Ac§AjQI0OgPABg#BAgAYBWn8Aw§CNAjQ6A8ABg#BCgQYBGfwD§AI0CND6AwAG^EKBBgKYZCYAG#QoEGARn8Aw§CNAjQ+gMABg#BCgQYBGfwAw^gAANAjT6AwAG^EKBBgNYfAD^C#0CNPoDgAE^EaBCg0R8AM^IAADQK0/gCAAQ^RoEKBpRgKgAQAABGgQoNEfAD^C#0CtP4AgAE^EaBCg0R8AD^CBAgwCN/gCAAQ^RoEKD1BwAM^IECDAI3+AG§ARoEaPQHAAw^gQIMArT8AY§BGgRommEAM^CBAgwCN/gCAAQ^RoEKD1BwAM^IECDAI3+AIAB^ARoEaPQHAAw^gQIMArT8AY§BGgRo9AcAGgAAQICGCNBfRfNcABg#BgeICGnVvoDwAY^QIAGAVp/AM§AjQI0OgPADQAAIAADQI0+gMABg#BCgQYDWHwAw^gAANAjT6A4AB^BGgQoNEfAD^C#0CtP4AgAE^EaBCg0R8AD^CBAgwCN/gCAAQ^RoEKD1BwAM^IECDAE0zEgAN#gQIMAjf4AgAE^EaBCg9QcAD^CBAgwCN/gBg§EaBGj0BwAM^IECDAK0/AG§ARoEaPQHAAM^I0CBAoz8AY§BGgRo/QEAAw^jQIEDTjARAAwAACNAgQKM/AG§ARoEaP0BAAM^I0CBAoz8AG^ECABgEa/QEAAw^jQIEDrDwAY^QIAGARr9Ac§AjQI0OgPABg#BAgAYBWn8Aw§CNAjQNIcBY§BGgRo/QEAAw^jQIECjPwBg§EadtAfAD^C#0CtP4AgAE^EaBCgAQABGgAA+AO2TAbHupOgH^ABJRU5ErkJggg==".replace(/§/g,"AAAAAA").replace(/\^/g,"AAAA").replace(/#/g,"AAA"),h="iVBORw0KGgoAAAANSUhEUgAAAGEAAABDCAMAAAC7vJusAAAAkFBMVEUAAAAvLy9ERERubm7///8AAAD///9EREREREREREREREQAAAD///8AAAD///8AAAD///8AAAD///8AAAD///8AAAD///8AAAD///8AAAD///8AAAD///8cHBwkJCQnJycoKCgpKSkqKiouLi4vLy8/Pz9AQEBCQkJDQ0NdXV1ubm58fHykpKRERERVVVUzMzPx7Ab+AAAAHXRSTlMAAAAAAAQEBQ4QGR4eIyMtLUVFVVVqapKSnJy7u9JKTggAAAFUSURBVHja7dXbUoMwEAbgSICqLYeW88F6KIogqe//dpoYZ0W4AXbv8g9TwkxmvtndZMrEwlw/F8YIRjCCEYxgBCOsFmzqGMEI28J5zzmt0Pc9rdDL0NYgMxIYC5KiKpKAzZphWtZlGm4SjlnkOV6UHeeEUx77rh/npw1dCrI9k9lnwUwF+UG9D3m4ftJJxH4SJdPtaawXcbr+tBaeFrxiur309cIv19+4ytGCU0031a5euPVigLYGqjlAqM4ShOQ+QAYQUO80AMMAAkUGGfMfR9Ul+kmvPq2QGxXKOQBAKdjUgk0t2NiCGEVP+rHT3/iCUMBT90YrPMsKsIWP3x/VolaonJEETchHCS8AYAmaUICQQwaAQnjoXgHAES7jLkEFaHO4bdq/k25HAIpgWY34FwAE5xjCffM+D2DV8B0gRsAZT7hr5gE8wdrJcU+CJqhcqQD7Cx5L7Ph4WnrKAAAAAElFTkSuQmCC",i="iVBORw0KGgoAAAANSUhEUgAAASAAAABvCAYAAABM+h2NAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAABORJREFUeNrs3VtTW1UYBuCEcxAI4YydWqTWdqr1V7T/2QsvvPDCCy9qjxZbamsrhZIQUHsCEtfafpmJe8qFjpUxfZ4Zuvt2feydJvAOARZUut1u5bRerl692nV913f99/f6QxWAU6KAAAUEKCAABQQoIAAFBCggAAUEKCAABQQoIAAFBCggAAUEKCAABQQoIEABASggQAEBKCBAAQEoIEABASggQAEBKCBAAQEoIGBQC+jatWvd07zxrv9+Xx8fAQEoIEABASggQAEBKCBAAQEoIEABAQoIQAEBCghAAQEKCEABAQOk2u36kS6AAgLetwJKL29toFRM1be+QrVq3rx58//KvM8BAadGAQEKCFBAAAoIGHwnfhneZ+/Nmzf/LufzrI+AAE/BAAUEoIAABQTwztgLZt68eXvBAE/BABQQoIAAFBAweOwFM2/evL1ggKdgAAoIUEAACggYPPaCmTdv3l4wwFMwAAUEKCAABQQMHnvBzJs3by8Y4CkYgAICFBCAAgIGz4lfBQNQQMDgFlCtVisaaHV1tThubW1VInciD0U+ysdnz54N5+PKysphOnRTHsvHlN9EHo/1l5FrkV9Enoz8W87b29tTOS8vLx9EnoncjlyPvBe5EbkZeT4fU96NvBDr2znv7Ows57y0tLQVeSXy08gf5mNfPhPrjyOfrVarlcXFxZ9yfv78+bl8TPlh5LU8n/KDyOuxfj/y+VjfyHl3d/dCKv28fi/yp/m4sLDwQ+SLke9GvhT5Tinfjnw5f4/F/Pz8rZybzeZn+ZjyzVK+EfnzUr4S+Xopf9/L+fxzc3M5d1qt1hf531Mu5k/IxzGf85VYL+fefHH+RqNRrO/t7RW3L+UbkS9Hvhk5/386Kd/qW8/5duRLMV/OdyJfzNebnZ0t7t92u53v/07K9yJfiLwROT9+ef7HyOux/iDyWuSHkT+K+eLtZX9//2xer9frjyOfyY9/Wn8S86v59qT1p7Ge315zLt4RU16K19+O9YXIu5HnYn435hux3opcj9yOPB3z+5E/iPXf43y1yMX778HBQS3f3pTz+28l5bHIr2N+LN3+zszMzGHkoh/S+mHMF98XlNaP8zHd/0W/pMe943NAwKlSQIACAhQQgAICFBCAAgIUEIACAhQQgAIC/n9GqtXqYbfbHa38+RtSu32llPdqdNL6aOSj+LfxyMVekLTem39Ryr/mPDQ0NBznzXtROikPRW6W8k7k3m9rzXthOsPDw73bUuylGRkZ6cR63nvTSfko8oPIr+Pnz96P/DLW816ezujoaN6DdtyX9+P8eS9QZ2xs7Hxf7qa8Xlr/JO6Ljcjrcf6cj1P+OO+N6V1/fHz8XLz+/Tjfubh+sZcorZ+N9Ycxfybyo8ircf6fc56YmFiJ1/8l8mLk7cjzkfP92U15Ns63G+u9nPcKdWq12lQ8Xu3Ixd6f9Pd8P3UmJycnUszzL2N9LM7/anNzs9V7Q2q32395w/q7ubdH6L/KrVbrpPxlKX9Vyl+X8jel/G0pf5f/aDabvXy9tH6ztH63lDdKebOUH5Xyk1LeKuWd/ry2tlap9P125Onp6Zf9eWpq6lW3b8f6zMzM6/71er3+ppSP+u/XNN/pz41Go+sjIMBTMEABASggQAEBKCBAAQEoIEABASggQAEB/CN/CDAAw78uW9AVDw4AAAAASUVORK5CYII=";a.ColorPicker={_html:b,_cssFunc:c,_cssMain:d,_horizontalPng:e,_verticalPng:f,_patchesPng:g,_iconsPng:h,_bgsPng:i}}(window),function(a,b){"use strict";function c(c,e){var j,k="",l="";for(var m in e)c.options[m]=e[m];Q=document.createStyleSheet!==b&&document.getElementById||!!a.MSInputMethodContext,R="undefined"!=typeof document.body.style.opacity,_=new Colors(c.options),delete c.options,bb=_.options,bb.scale=1,l=bb.CSSPrefix,c.color=_,S=bb.valueRanges,c.nodes=cb=g(f(c),c),q(bb.mode),d(c),u(),k=" "+bb.mode.type+"-"+bb.mode.z,cb.slds.className+=k,cb.panel.className+=k,bb.noHexButton&&C(cb.HEX_butt,l+"butt",l+"labl"),bb.size!==b&&p(b,bb.size),j={alphaBG:cb.alpha_labl,cmyOnly:cb.HEX_labl};for(var n in j)bb[n]!==b&&o({target:j[n],data:bb[n]});bb.noAlpha&&(cb.colorPicker.className+=" no-alpha"),c.renderMemory(bb.memoryColors),h(c),I=!0,i(b,"init"),N&&(d(N),w())}function d(a){Y=!0,M!==a&&(M=a,ab=a.color.colors,bb=a.color.options,cb=a.nodes,_=a.color,$={},v(ab))}function e(){var a=["L","S","XS","XXS"];bb.sizes={},cb.testNode.style.cssText="position:absolute;left:-1000px;top:-1000px;",document.body.appendChild(cb.testNode);for(var b=a.length;b--;)cb.testNode.className=bb.CSSPrefix+"app "+a[b],bb.sizes[a[b]]=[cb.testNode.offsetWidth,cb.testNode.offsetHeight];cb.testNode.removeNode?cb.testNode.removeNode(!0):document.body.removeChild(cb.testNode)}function f(a){var b=document.createElement("div"),c=bb.CSSPrefix,d="data:image/png;base64,",e=function(a,b){var c=document.createElement("style");c.setAttribute("type","text/css"),b&&c.setAttribute("id",b),c.styleSheet||c.appendChild(document.createTextNode(a)),document.getElementsByTagName("head")[0].appendChild(c),c.styleSheet&&(document.styleSheets[document.styleSheets.length-1].cssText=a)},f=function(a){O._cssFunc=O._cssFunc.replace(/§/g,c).replace("_patches.png",a?d+O._patchesPng:bb.imagePath+"_patches.png").replace("_vertical.png",a?d+O._verticalPng:bb.imagePath+"_vertical.png").replace("_horizontal.png",a?d+O._horizontalPng:bb.imagePath+"_horizontal.png"),e(O._cssFunc,"colorPickerCSS"),bb.customCSS||(O._cssMain=O._cssMain.replace(/§/g,c).replace("_bgs.png",a?d+O._bgsPng:bb.imagePath+"_bgs.png").replace("_icons.png",a?d+O._iconsPng:bb.imagePath+"_icons.png").replace(/opacity:(\d*\.*(\d+))/g,function(a,b){return R?"-moz-opacity: "+b+"; -khtml-opacity: "+b+"; opacity: "+b:'-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity='+db.round(100*+b)+')";filter: alpha(opacity='+db.round(100*+b)+")"}),e(O._cssMain))},g=document.createElement("img");return P?a.color.options.devPicker:(document.getElementById("colorPickerCSS")?a.cssIsReady=!0:(g.onload=g.onerror=function(){O._cssFunc&&f(1===this.width&&1===this.height),a.cssIsReady=!0},g.src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw=="),(N=M)&&r(),b.insertAdjacentHTML("afterbegin",M?M.nodes.colorPicker.outerHTML||(new XMLSerializer).serializeToString(M.nodes.colorPicker):O._html.replace(/§/g,c)),b=b.children[0],b.style.cssText=bb.initStyle||"",(bb.appendTo||document.body).appendChild(b))}function g(a){var b,c,d=a.getElementsByTagName("*"),e={colorPicker:a},f=new RegExp(bb.CSSPrefix);e.styles={},e.textNodes={},e.memos=[],e.testNode=document.createElement("div");for(var g=0,h=d.length;h>g;g++)b=d[g],(c=b.className)&&f.test(c)?(c=c.split(" ")[0].replace(bb.CSSPrefix,"").replace(/-/g,"_"),/_disp/.test(c)?(c=c.replace("_disp",""),e.styles[c]=b.style,e.textNodes[c]=b.firstChild,b.contentEditable=!0):(/(?:hs|cmyk|Lab).*?(?:butt|labl)/.test(c)||(e[c]=b),/(?:cur|sld[^s]|opacity|cont|col)/.test(c)&&(e.styles[c]=/(?:col\d)/.test(c)?b.children[0].style:b.style))):/memo/.test(b.parentNode.className)&&e.memos.push(b);return e.panelCover=e.panel.appendChild(document.createElement("div")),e}function h(c,f){var g=f?G:F;g(cb.colorPicker,"mousedown",function(f){var g=f||a.event,h=E(g),n=(g.button||g.which)<2?g.target||g.srcElement:{},o=n.className;return d(c),J=n,i(b,"resetEventListener"),U="",n===cb.sldl_3||n===cb.curm?(J=cb.sldl_3,I=j,U="changeXYValue",C(cb.slds,"do-drag")):/sldr/.test(o)||n===cb.curl||n===cb.curr?(J=cb.sldr_4,I=k,U="changeZValue"):n===cb.opacity.children[0]||n===cb.opacity_slider?(J=cb.opacity,I=l,U="changeOpacityValue"):/-disp/.test(o)&&!/HEX-/.test(o)?(I=m,U="changeInputValue",(3===n.nextSibling.nodeType?n.nextSibling.nextSibling:n.nextSibling).appendChild(cb.nsarrow),K=o.split("-disp")[0].split("-"),K={type:K[0],z:K[1]||""},C(cb.panel,"start-change"),V=0):n!==cb.resize||bb.noResize?I=b:(bb.sizes||e(),J=cb.resizer,I=p,U="resizeApp"),I&&(W={pageX:h.X,pageY:h.Y},J.style.display="block",X=D(J),X.width=cb.opacity.offsetWidth,X.childWidth=cb.opacity_slider.offsetWidth,J.style.display="",I(g),F(Q?document.body:a,"mousemove",I),L=a[fb](w)),/-disp/.test(o)?void 0:B(g)}),g(cb.colorPicker,"click",function(a){d(c),o(a)}),g(cb.colorPicker,"dblclick",o),g(cb.colorPicker,"keydown",function(a){d(c),n(a)}),g(cb.colorPicker,"keypress",n),g(cb.colorPicker,"paste",function(a){return a.target.firstChild.data=a.clipboardData.getData("Text"),B(a)})}function i(c,d){var e=I;I&&(a[gb](L),G(Q?document.body:a,"mousemove",I),V&&(K={type:"alpha"},w()),("function"==typeof I||"number"==typeof I)&&delete bb.webUnsave,V=1,I=b,C(cb.slds,"do-drag",""),C(cb.panel,"(?:start-change|do-change)",""),cb.resizer.style.cssText="",cb.panelCover.style.cssText="",cb.memo_store.style.cssText="background-color: "+y(ab.RND.rgb)+"; "+A(ab.alpha),cb.memo.className=cb.memo.className.replace(/\s+(?:dark|light)/,"")+(ab["rgbaMix"+T[bb.alphaBG]].luminance<.22?" dark":" light"),K=b,s(),bb.actionCallback&&bb.actionCallback(c,U||e.name||d||"external"))}function j(b){var c=b||a.event,d=bb.scale,e=E(c),f=(e.X-X.left)*(4===d?2:d),g=(e.Y-X.top)*d,h=bb.mode;return ab[h.type][h.x]=z(f/255,0,1),ab[h.type][h.y]=1-z(g/255,0,1),t(),B(c)}function k(b){var c=b||a.event,d=E(c),e=(d.Y-X.top)*bb.scale,f=bb.mode;return ab[f.type][f.z]=1-z(e/255,0,1),t(),B(c)}function l(b){var c=b||a.event,d=E(c);return Y=!0,ab.alpha=z(db.round((d.X-X.left)/X.width*100),0,100)/100,t("alpha"),B(c)}function m(b){var c,d=b||a.event,e=E(d),f=W.pageY-e.Y,g=bb.delayOffset,h=K.type,i="alpha"===h;return V||db.abs(f)>=g?(V||(V=(f>0?-g:g)+ +J.firstChild.data*(i?100:1),W.pageY+=V,f+=V,V=1,C(cb.panel,"start-change","do-change"),cb.panelCover.style.cssText="position:absolute;left:0;top:0;right:0;bottom:0",document.activeElement.blur(),L=a[fb](w)),"cmyk"===h&&bb.cmyOnly&&(h="cmy"),i?(Y=!0,ab.alpha=z(f/100,0,1)):(c=S[h][K.z],ab[h][K.z]="Lab"===h?z(f,c[0],c[1]):z(f/c[1],0,1)),t(i?"alpha":h),B(d)):void 0
+}function n(c){var d,e=c||a.event,f=e.which||e.keyCode,g=String.fromCharCode(f),h=document.activeElement,j=h.className.replace(bb.CSSPrefix,"").split("-"),k=j[0],l=j[1],m="alpha"===k,n="HEX"===k,o={k40:-1,k38:1,k34:-10,k33:10}["k"+f]/(m?100:1),p={HEX:/[0-9a-fA-F]/,Lab:/[\-0-9]/,alpha:/[\.0-9]/}[k]||/[0-9]/,q=S[k][k]||S[k][l],r=h.firstChild,s=H(h),u=r.data,w="0"!==u||n?u.split(""):[];return/^(?:27|13)$/.test(f)?(B(e),h.blur()):"keydown"===e.type?(o?d=z(db.round(1e6*(+u+o))/1e6,q[0],q[1]):/^(?:8|46)$/.test(f)&&(s.range||(s.range++,s.start-=8===f?1:0),w.splice(s.start,s.range),d=w.join("")||"0"),d!==b&&B(e,!0)):"keypress"===e.type&&(/^(?:37|39|8|46|9)$/.test(f)||B(e,!0),p.test(g)&&(w.splice(s.start,s.range,g),d=w.join("")),s.start++),13===f&&n?r.data.length%3===0||"0"===r.data?M.setColor("0"===r.data?"000":r.data,"rgb",ab.alpha,!0):(B(e,!0),h.focus()):(n&&d!==b&&(d=/^0+/.test(d)?d:parseInt(""+d,16)||0),void(d!==b&&""!==d&&+d>=q[0]&&+d<=q[1]&&(n&&(d=d.toString(16).toUpperCase()||"0"),m?ab[k]=+d:n||(ab[k][l]=+d/("Lab"===k?1:q[1])),t(m?"alpha":k),v(ab),I=!0,i(c,e.type),r.data=d,H(h,db.min(h.firstChild.data.length,s.start<0?0:s.start)))))}function o(c){var d,e,f=c||a.event,g=f.target||f.srcElement,h=g.className,j=g.parentNode,k=bb,l=ab.RND.rgb,m=bb.mode,n="",o=k.CSSPrefix,p=/(?:hs|rgb)/.test(j.className)&&/^[HSBLRG]$/.test(g.firstChild?g.firstChild.data:""),q=/dblc/.test(f.type),r="";if(!q||p){if(-1!==h.indexOf("-labl "+o+"labl"))C(cb[h.split("-")[0]],o+"hide",""),C(cb[j.className.split("-")[1]],o+"hide");else if(-1!==h.indexOf(o+"butt"))if(p)q&&2===bb.scale&&(n=/hs/.test(m.type)?"rgb":/hide/.test(cb.hsl.className)?"hsv":"hsl",n=n+"-"+n[m.type.indexOf(m.z)]),M.setMode(n?n:h.replace("-butt","").split(" ")[0]),r="modeChange";else if(/^[rgb]/.test(h))n=h.split("-")[1],C(cb.colorPicker,"no-rgb-"+n,(k["noRGB"+n]=!k["noRGB"+n])?b:""),r="noRGB"+n;else if(g===cb.alpha_labl)d=k.customBG,e=k.alphaBG,C(cb.colorPicker,"alpha-bg-"+e,"alpha-bg-"+(e=k.alphaBG=c.data||("w"===e?d?"c":"b":"c"===e?"b":"w"))),g.firstChild.data=e.toUpperCase(),cb.ctrl.style.backgroundColor=cb.memo.style.backgroundColor="c"!==e?"":"rgb("+db.round(255*d.r)+", "+db.round(255*d.g)+", "+db.round(255*d.b)+")",cb.raster.style.cssText=cb.raster_bg.previousSibling.style.cssText="c"!==e?"":A(d.luminance<.22?.5:.4),r="alphaBackground";else if(g===cb.alpha_butt)C(cb.colorPicker,"mute-alpha",(k.muteAlpha=!k.muteAlpha)?b:""),r="alphaState";else if(g===cb.HEX_butt)C(cb.colorPicker,"no-HEX",(k.HEXState=!k.HEXState)?b:""),r="HEXState";else if(g===cb.HEX_labl){var s="web save"===ab.saveColor;"web smart"===ab.saveColor||s?s?M.setColor(k.webUnsave,"rgb"):(k.webUnsave||(k.webUnsave=x(l)),M.setColor(ab.webSave,"rgb")):(k.webUnsave=x(l),M.setColor(ab.webSmart,"rgb")),r="webColorState"}else/Lab-x-labl/.test(h)&&(C(cb.colorPicker,"cmy-only",(k.cmyOnly=!k.cmyOnly)?b:""),r="cmykState");else if(g===cb.bsav)u(),r="saveAsBackground";else if(g===cb.bres){var w=x(l),y=ab.alpha;M.setColor(k.color),u(),M.setColor(w,"rgb",y),r="resetColor"}else if(j===cb.col1)ab.hsv.h-=ab.hsv.h>.5?.5:-.5,t("hsv"),r="shiftColor";else if(j===cb.col2)M.setColor(g.style.backgroundColor,"rgb",ab.background.alpha),r="setSavedColor";else if(j===cb.memo){var z=function(){cb.memos.blinker&&(cb.memos.blinker.style.cssText=cb.memos.cssText)},B=function(b){cb.memos.blinker=b,b.style.cssText="background-color:"+(ab.RGBLuminance>.22?"#333":"#DDD"),a.setTimeout(z,200)};if(g===cb.memo_cursor){z(),cb.memos.blinker=b,cb.testNode.style.cssText=cb.memo_store.style.cssText,cb.memos.cssText=cb.testNode.style.cssText;for(var D=cb.memos.length-1;D--;)if(cb.memos.cssText===cb.memos[D].style.cssText){B(cb.memos[D]);break}if(!cb.memos.blinker){for(var D=cb.memos.length-1;D--;)cb.memos[D+1].style.cssText=cb.memos[D].style.cssText;cb.memos[0].style.cssText=cb.memo_store.style.cssText}r="toMemory"}else z(),M.setColor(g.style.backgroundColor,"rgb",g.style.opacity||1),cb.memos.cssText=g.style.cssText,B(g),I=1,r="fromMemory"}r&&(v(ab),I=I||!0,i(c,r))}}function p(c,d){var e,f=c||a.event,g=f?E(f):{},h=d!==b,i=h?d:g.X-X.left+8,j=h?d:g.Y-X.top+8,k=[" S XS XXS"," S XS"," S",""],l=bb.sizes,m=h?d:j<l.XXS[1]+25?0:i<l.XS[0]+25?1:i<l.S[0]+25||j<l.S[1]+25?2:3,n=k[m],o=!1,p="";$.resizer!==n&&(o=/XX/.test(n),e=bb.mode,!o||/hs/.test(e.type)&&"h"!==e.z?e.original&&M.setMode(e.original):(p=e.type+"-"+e.z,M.setMode(/hs/.test(e.type)?e.type+"-s":"hsv-s"),bb.mode.original=p),cb.colorPicker.className=cb.colorPicker.className.replace(/\s+(?:S|XS|XXS)/g,"")+n,bb.scale=o?4:/S/.test(n)?2:1,bb.currentSize=m,$.resizer=n,Y=!0,w(),s()),cb.resizer.style.cssText="display: block;width: "+(i>10?i:10)+"px;height: "+(j>10?j:10)+"px;"}function q(a){var b={rgb_r:{x:"b",y:"g"},rgb_g:{x:"b",y:"r"},rgb_b:{x:"r",y:"g"},hsv_h:{x:"s",y:"v"},hsv_s:{x:"h",y:"v"},hsv_v:{x:"h",y:"s"},hsl_h:{x:"s",y:"l"},hsl_s:{x:"h",y:"l"},hsl_l:{x:"h",y:"s"}},c=a.replace("-","_"),d="\\b(?:rg|hs)\\w\\-\\w\\b";return C(cb.panel,d,a),C(cb.slds,d,a),a=a.split("-"),bb.mode={type:a[0],x:b[c].x,y:b[c].y,z:a[1]}}function r(){var a=/\s+(?:hue-)*(?:dark|light)/g,b="className";cb.curl[b]=cb.curl[b].replace(a,""),cb.curr[b]=cb.curr[b].replace(a,""),cb.slds[b]=cb.slds[b].replace(a,""),cb.sldr_2[b]=bb.CSSPrefix+"sldr-2",cb.sldr_4[b]=bb.CSSPrefix+"sldr-4",cb.sldl_3[b]=bb.CSSPrefix+"sldl-3";for(var c in cb.styles)c.indexOf("sld")||(cb.styles[c].cssText="");$={}}function s(){cb.styles.curr.cssText=cb.styles.curl.cssText,cb.curl.className=bb.CSSPrefix+"curl"+(Z.noRGBZ?" "+bb.CSSPrefix+"curl-"+Z.noRGBZ:""),cb.curr.className=bb.CSSPrefix+"curr "+bb.CSSPrefix+"curr-"+("h"===bb.mode.z?Z.HUEContrast:Z.noRGBZ?Z.noRGBZ:Z.RGBLuminance)}function t(a){v(_.setColor(b,a||bb.mode.type)),Y=!0}function u(a){return _.saveAsBackground(),cb.styles.col2.cssText="background-color: "+y(ab.background.RGB)+";"+A(ab.background.alpha),a&&v(ab),ab}function v(a){var c=db,d=Z,e=T[bb.alphaBG];d.hueDelta=c.round(100*a["rgbaMixBGMix"+e].hueDelta),d.luminanceDelta=c.round(100*a["rgbaMixBGMix"+e].luminanceDelta),d.RGBLuminance=a.RGBLuminance>.22?"light":"dark",d.HUEContrast=a.HUELuminance>.22?"light":"dark",d.contrast=d.luminanceDelta>d.hueDelta?"contrast":"",d.readabiltiy=a["rgbaMixBGMix"+e].WCAG2Ratio>=7?"green":a["rgbaMixBGMix"+e].WCAG2Ratio>=4.5?"orange":"",d.noRGBZ=bb["no"+bb.mode.type.toUpperCase()+bb.mode.z]?"g"===bb.mode.z&&a.rgb.g<.59||"b"===bb.mode.z||"r"===bb.mode.z?"dark":"light":b}function w(){if(I){if(!Y)return L=a[fb](w);Y=!1}var c,d,e,f,g=bb,h=g.mode,i=g.scale,l=g.CSSPrefix,m=ab,n=cb,o=n.styles,p=n.textNodes,q=S,r=K,s=Z,t=$,u=db,v=A,x=y,z=0,B=0,C=m[h.type][h.x],D=u.round(255*C/(4===i?2:i)),E=m[h.type][h.y],F=1-E,G=u.round(255*F/i),H=1-m[h.type][h.z],M=u.round(255*H/i),N=[C,E],O="rgb"===h.type,P="h"===h.z,Q="hsl"===h.type,R=Q&&"s"===h.z,T=I===j,U=I===k;O&&(N[0]>=N[1]?B=1:z=1,t.sliderSwap!==z&&(n.sldr_2.className=g.CSSPrefix+"sldr-"+(3-z),t.sliderSwap=z)),(O&&!U||P&&!T||!P&&!U)&&(o[P?"sldl_2":"sldr_2"][O?"cssText":"backgroundColor"]=O?v((N[z]-N[B])/(1-N[B]||0)):x(m.hueRGB)),P||(U||(o.sldr_4.cssText=v(O?N[B]:R?u.abs(1-2*F):F)),T||(o.sldl_3.cssText=v(Q&&"l"===h.z?u.abs(1-2*H):H)),Q&&(f=R?"sldr_4":"sldl_3",d=R?"r-":"l-",e=R?F>.5?4:3:H>.5?3:4,t[f]!==e&&(n[f].className=g.CSSPrefix+"sld"+d+e,t[f]=e))),U||(o.curm.cssText="left: "+D+"px; top: "+G+"px;"),T||(o.curl.top=M+"px"),r&&(o.curr.top=M+"px"),(r&&"alpha"===r.type||J===n.opacity)&&(o.opacity_slider.left=g.opacityPositionRelative?m.alpha*((X.width||n.opacity.offsetWidth)-(X.childWidth||n.opacity_slider.offsetWidth))+"px":100*m.alpha+"%"),o.col1.cssText="background-color: "+x(m.RND.rgb)+"; "+(g.muteAlpha?"":v(m.alpha)),o.opacity.backgroundColor=x(m.RND.rgb),o.cold.width=s.hueDelta+"%",o.cont.width=s.luminanceDelta+"%";for(c in p)d=c.split("_"),g.cmyOnly&&(d[0]=d[0].replace("k","")),e=d[1]?m.RND[d[0]][d[1]]:m.RND[d[0]]||m[d[0]],t[c]!==e&&(t[c]=e,p[c].data=e>359.5&&"HEX"!==c?0:e,"HEX"===c||g.noRangeBackground||(e=m[d[0]][d[1]]!==b?m[d[0]][d[1]]:m[d[0]],"Lab"===d[0]&&(e=(e-q[d[0]][d[1]][0])/(q[d[0]][d[1]][1]-q[d[0]][d[1]][0])),o[c].backgroundPosition=u.round(100*(1-e))+"% 0%"));d=m._rgb?[m._rgb.r!==m.rgb.r,m._rgb.g!==m.rgb.g,m._rgb.b!==m.rgb.b]:[],d.join("")!==t.outOfGammut&&(n.rgb_r_labl.firstChild.data=d[0]?"!":" ",n.rgb_g_labl.firstChild.data=d[1]?"!":" ",n.rgb_b_labl.firstChild.data=d[2]?"!":" ",t.outOfGammut=d.join("")),s.noRGBZ&&t.noRGBZ!==s.noRGBZ&&(n.curl.className=l+"curl "+l+"curl-"+s.noRGBZ,U||(n.curr.className=l+"curr "+l+"curr-"+s.noRGBZ),t.noRGBZ=s.noRGBZ),t.HUEContrast!==s.HUEContrast&&"h"===h.z?(n.slds.className=n.slds.className.replace(/\s+hue-(?:dark|light)/,"")+" hue-"+s.HUEContrast,U||(n.curr.className=l+"curr "+l+"curr-"+s.HUEContrast),t.HUEContrast=s.HUEContrast):t.RGBLuminance!==s.RGBLuminance&&(n.colorPicker.className=n.colorPicker.className.replace(/\s+(?:dark|light)/,"")+" "+s.RGBLuminance,U||"h"===h.z||s.noRGBZ||(n.curr.className=l+"curr "+l+"curr-"+s.RGBLuminance),t.RGBLuminance=s.RGBLuminance),(t.contrast!==s.contrast||t.readabiltiy!==s.readabiltiy)&&(n.ctrl.className=n.ctrl.className.replace(" contrast","").replace(/\s*(?:orange|green)/,"")+(s.contrast?" "+s.contrast:"")+(s.readabiltiy?" "+s.readabiltiy:""),t.contrast=s.contrast,t.readabiltiy=s.readabiltiy),t.saveColor!==m.saveColor&&(n.HEX_labl.firstChild.data=m.saveColor?"web save"===m.saveColor?"W":"M":"!",t.saveColor=m.saveColor),g.renderCallback&&g.renderCallback(m,h),I&&(L=a[fb](w))}function x(a){var b={};for(var c in a)b[c]=a[c];return b}function y(a,b){for(var c="",d=(b||"rgb").split(""),e=d.length;e--;)c=", "+a[d[e]]+c;return(b||"rgb")+"("+c.substr(2)+")"}function z(a,b,c){return a>c?c:b>a?b:a}function A(a){return a===b&&(a=1),R?"opacity: "+db.round(1e10*a)/1e10+";":"filter: alpha(opacity="+db.round(100*a)+");"}function B(b,c){return b.preventDefault?b.preventDefault():b.returnValue=!1,c||(a.getSelection?a.getSelection().removeAllRanges():document.selection.empty()),!1}function C(a,c,d){return a?a.className=d!==b?a.className.replace(new RegExp("\\s+?"+c,"g"),d?" "+d:""):a.className+" "+c:!1}function D(b){var c=b.getBoundingClientRect?b.getBoundingClientRect():{top:0,left:0},d=b&&b.ownerDocument,e=d.body,f=d.defaultView||d.parentWindow||a,g=d.documentElement||e.parentNode,h=g.clientTop||e.clientTop||0,i=g.clientLeft||e.clientLeft||0;return{left:c.left+(f.pageXOffset||g.scrollLeft)-i,top:c.top+(f.pageYOffset||g.scrollTop)-h}}function E(b){var c=a.document;return{X:b.pageX||b.clientX+c.body.scrollLeft+c.documentElement.scrollLeft,Y:b.pageY||b.clientY+c.body.scrollTop+c.documentElement.scrollTop}}function F(a,b,c){F.cache=F.cache||{_get:function(a,b,c,d){for(var e=F.cache[b]||[],f=e.length;f--;)if(a===e[f].obj&&""+c==""+e[f].func)return c=e[f].func,d||(e[f]=e[f].obj=e[f].func=null,e.splice(f,1)),c},_set:function(a,b,c){var d=F.cache[b]=F.cache[b]||[];return F.cache._get(a,b,c,!0)?!0:void d.push({func:c,obj:a})}},!c.name&&F.cache._set(a,b,c)||"function"!=typeof c||(a.addEventListener?a.addEventListener(b,c,!1):a.attachEvent("on"+b,c))}function G(a,b,c){"function"==typeof c&&(c.name||(c=F.cache._get(a,b,c)||c),a.removeEventListener?a.removeEventListener(b,c,!1):a.detachEvent("on"+b,c))}function H(c,d){var e={};if(d===b){if(a.getSelection){c.focus();var f=a.getSelection().getRangeAt(0),g=f.cloneRange();g.selectNodeContents(c),g.setEnd(f.endContainer,f.endOffset),e={end:g.toString().length,range:f.toString().length}}else{c.focus();var f=document.selection.createRange(),g=document.body.createTextRange();g.moveToElementText(c),g.setEndPoint("EndToEnd",f),e={end:g.text.length,range:f.text.length}}return e.start=e.end-e.range,e}if(-1==d&&(d=c.text().length),a.getSelection)c.focus(),a.getSelection().collapse(c.firstChild,d);else{var h=document.body.createTextRange();h.moveToElementText(c),h.moveStart("character",d),h.collapse(!0),h.select()}return d}var I,J,K,L,M,N,O=a.ColorPicker,P=!O,Q=!1,R=!1,S={},T={w:"White",b:"Black",c:"Custom"},U="",V=1,W={},X={},Y=!0,Z={},$={},_={},ab={},bb={},cb={},db=Math,eb="AnimationFrame",fb="request"+eb,gb="cancel"+eb,hb=["ms","moz","webkit","o"],ib=function(a){this.options={color:"rgba(204, 82, 37, 0.8)",mode:"rgb-b",fps:60,delayOffset:8,CSSPrefix:"cp-",allMixDetails:!0,alphaBG:"w",imagePath:""},c(this,a||{})};a.ColorPicker=ib,ib.addEvent=F,ib.removeEvent=G,ib.getOrigin=D,ib.limitValue=z,ib.changeClass=C,ib.prototype.setColor=function(a,b,c,e){d(this),K=!0,v(_.setColor.apply(_,arguments)),e&&this.startRender(!0)},ib.prototype.saveAsBackground=function(){return d(this),u(!0)},ib.prototype.setCustomBackground=function(a){return d(this),_.setCustomBackground(a)},ib.prototype.startRender=function(b){d(this),b?(I=!1,w(),this.stopRender()):(I=1,L=a[fb](w))},ib.prototype.stopRender=function(){d(this),a[gb](L),K&&(I=1,i(b,"external"))},ib.prototype.setMode=function(a){d(this),q(a),r(),w()},ib.prototype.destroyAll=function(){var a=this.nodes.colorPicker,b=function(a){for(var c in a)(a[c]&&"[object Object]"===a[c].toString()||a[c]instanceof Array)&&b(a[c]),a[c]=null,delete a[c]};this.stopRender(),h(this,!0),b(this),a.parentNode.removeChild(a),a=null},ib.prototype.renderMemory=function(a){var c=this.nodes.memos,d=[];"string"==typeof a&&(a=a.replace(/^'|'$/g,"").replace(/\s*/,"").split("','"));for(var e=c.length;e--;)a&&"string"==typeof a[e]&&(d=a[e].replace("rgba(","").replace(")","").split(","),a[e]={r:d[0],g:d[1],b:d[2],a:d[3]}),c[e].style.cssText="background-color: "+(a&&a[e]!==b?y(a[e])+";"+A(a[e].a||1):"rgb(0,0,0);")},F(Q?document.body:a,"mouseup",i);for(var jb=hb.length;jb--&&!a[fb];)a[fb]=a[hb[jb]+"Request"+eb],a[gb]=a[hb[jb]+"Cancel"+eb]||a[hb[jb]+"CancelRequest"+eb];a[fb]=a[fb]||function(b){return a.setTimeout(b,1e3/bb.fps)},a[gb]=a[gb]||function(b){return a.clearTimeout(b),L=null}}(window);
\ No newline at end of file
diff --git a/_server/colorPicker/jsColor.js b/_server/colorPicker/jsColor.js
new file mode 100644
index 00000000..b3ca28ea
--- /dev/null
+++ b/_server/colorPicker/jsColor.js
@@ -0,0 +1,387 @@
+(function (window) {
+    window.jsColorPicker = function(selectors, config) {
+        var renderCallback = function(colors, mode) {
+                var options = this,
+                    input = options.input,
+                    patch = options.patch,
+                    RGB = colors.RND.rgb,
+                    HSL = colors.RND.hsl,
+                    AHEX = options.isIE8 ? (colors.alpha < 0.16 ? '0' : '') +
+                        (Math.round(colors.alpha * 100)).toString(16).toUpperCase() + colors.HEX : '',
+                    RGBInnerText = RGB.r + ',' + RGB.g + ',' + RGB.b,
+                    RGBAText = RGBInnerText + ',' + colors.alpha,
+                    isAlpha = colors.alpha !== 1 && !options.isIE8,
+                    colorMode = input.getAttribute('data-colorMode');
+
+                patch.style.cssText =
+                    'color:' + (colors.rgbaMixCustom.luminance > 0.22 ? '#222' : '#ddd') + ';' + // Black...???
+                    'background-color: rgba(' + RGBAText + ');' +
+                    'filter:' + (options.isIE8 ? 'progid:DXImageTransform.Microsoft.gradient(' + // IE<9
+                        'startColorstr=#' + AHEX + ',' + 'endColorstr=#' + AHEX + ')' : '');
+
+                input.value = RGBAText;
+
+                if (options.displayCallback) {
+                    options.displayCallback(colors, mode, options);
+                }
+            },
+            extractValue = function(elm) {
+                var val = elm.value || elm.getAttribute('value') || elm.style.backgroundColor || "0,0,0,1";
+                if (/^[0-9 ]+,[0-9 ]+,[0-9 ]+,[0-9. ]+$/.test(val)) return "rgba("+val+")";
+                if (/^[0-9 ]+,[0-9 ]+,[0-9 ]+$/.test(val)) return "rgba("+val+",1)";
+                return null;
+            },
+            actionCallback = function(event, action) {
+                var options = this,
+                    colorPicker = colorPickers.current;
+
+                if (action === 'toMemory') {
+                    var memos = colorPicker.nodes.memos,
+                        backgroundColor = '',
+                        opacity = 0,
+                        cookieTXT = [];
+
+                    for (var n = 0, m = memos.length; n < m; n++) {
+                        backgroundColor = memos[n].style.backgroundColor;
+                        opacity = memos[n].style.opacity;
+                        opacity = Math.round((opacity === '' ? 1 : opacity) * 100) / 100;
+                        cookieTXT.push(backgroundColor.
+                            replace(/, /g, ',').
+                            replace('rgb(', 'rgba(').
+                            replace(')', ',' + opacity + ')')
+                        );
+                    }
+                    cookieTXT = '\'' + cookieTXT.join('\',\'') + '\'';
+                    ColorPicker.docCookies('colorPickerMemos' + (options.noAlpha ? 'NoAlpha' : ''), cookieTXT);
+                } else if (action === 'resizeApp') {
+                    ColorPicker.docCookies('colorPickerSize', colorPicker.color.options.currentSize);
+                } else if (action === 'modeChange') {
+                    var mode = colorPicker.color.options.mode;
+
+                    ColorPicker.docCookies('colorPickerMode', mode.type + '-' + mode.z);
+                }
+            },
+            createInstance = function(elm, config) {
+                var initConfig = {
+                        klass: window.ColorPicker,
+                        input: elm,
+                        patch: elm,
+                        isIE8: !!document.all && !document.addEventListener, // Opera???
+                        // *** animationSpeed: 200,
+                        // *** draggable: true,
+                        margin: {left: -1, top: 2},
+                        customBG: '#FFFFFF',
+                        // displayCallback: displayCallback,
+                        /* --- regular colorPicker options from this point --- */
+                        color: extractValue(elm),
+                        initStyle: 'display: none',
+                        mode: ColorPicker.docCookies('colorPickerMode') || 'hsv-h',
+                        // memoryColors: (function(colors, config) {
+                        //     return config.noAlpha ?
+                        //         colors.replace(/\,\d*\.*\d*\)/g, ',1)') : colors;
+                        // })($.docCookies('colorPickerMemos'), config || {}),
+                        memoryColors: ColorPicker.docCookies('colorPickerMemos' +
+                            ((config || {}).noAlpha ? 'NoAlpha' : '')),
+                        size: ColorPicker.docCookies('colorPickerSize') || 1,
+                        renderCallback: renderCallback,
+                        actionCallback: actionCallback
+                    };
+
+                for (var n in config) {
+                    initConfig[n] = config[n]; 
+                }
+                return new initConfig.klass(initConfig);
+            },
+            doEventListeners = function(elm, multiple, off) {
+                var onOff = off ? 'removeEventListener' : 'addEventListener',
+                    inputListener = function(e) {
+                        var index = multiple ? Array.prototype.indexOf.call(elms, this) : 0,
+                            colorPicker = colorPickers[index] ||
+                                (colorPickers[index] = createInstance(this, config)),
+                            options = colorPicker.color.options;
+
+                        options.color = extractValue(elm); // brings color to default on reset
+                        //检查颜色合法性
+                        if (options.color != null && options.color == options.color.match(/rgba\([0-9 ]+,[0-9 ]+,[0-9 ]+,[0-9. ]+\)/)[0]) {
+                            var chec = options.color.match(/[0-9.]+/g);
+                            if (chec.length != 4)
+                                return;
+                            for (var i = 0; i < 3; i++) {
+                                if (chec[i] != chec[i].match(/\d+/)[0] || +chec[i] < 0 || +chec[i] > 255)
+                                    return;
+                            }
+                            if (chec[3] != chec[3].match(/\d+(\.\d+)?/)[0] || parseFloat(chec[3]) > 1 || parseFloat(chec[3] < 0))
+                                return;
+                            if (!multiple) {
+                                colorPicker.setColor(extractValue(elm), undefined, undefined, true);
+                                colorPicker.saveAsBackground();
+                            }
+                            colorPickers.current = colorPickers[index];
+                        }
+                    },
+                    createListener = function(e) {
+                        elm = document.getElementById("colorPicker");
+                        var input = elm,
+                            position = window.ColorPicker.getOrigin(input),
+                            index = multiple ? Array.prototype.indexOf.call(elms, elm) : 0,
+                            colorPicker = colorPickers[index] ||
+                                (colorPickers[index] = createInstance(elm, config)),
+                            options = colorPicker.color.options,
+                            colorPickerUI = colorPicker.nodes.colorPicker,
+                            appendTo = (options.appendTo || document.body),
+                            isStatic = /static/.test(window.getComputedStyle(appendTo).position),
+                            atrect = isStatic ? {left: 0, top: 0} : appendTo.getBoundingClientRect(),
+                            waitTimer = 0;
+                        
+                        options.color = extractValue(elm); // brings color to default on reset
+                        colorPickerUI.style.cssText = 
+                            'position: absolute;' + (!colorPickers[index].cssIsReady ? 'display: none;' : '') +
+                            'left:' + (position.left + options.margin.left - atrect.left) + 'px;' +
+                            'top:' + (position.top + +input.offsetHeight + options.margin.top - atrect.top) + 'px;';
+
+                        if (!multiple) {
+                            options.input = elm;
+                            options.patch = elm; // check again???
+                            colorPicker.setColor(extractValue(elm), undefined, undefined, true);
+                            colorPicker.saveAsBackground();
+                        }
+                        colorPickers.current = colorPickers[index];
+                        appendTo.appendChild(colorPickerUI);
+                        waitTimer = setInterval(function() { // compensating late style on onload in colorPicker
+                            if (colorPickers.current.cssIsReady) {
+                                waitTimer = clearInterval(waitTimer);
+                                colorPickerUI.style.display = 'block';
+                            }
+                        }, 10);
+                    },
+                    hideListener = function(e) {
+                        var colorPicker = colorPickers.current,
+                            colorPickerUI = (colorPicker ? colorPicker.nodes.colorPicker : undefined),
+                            animationSpeed = colorPicker ? colorPicker.color.options.animationSpeed : 0,
+                            isColorPicker = colorPicker && (function(elm) {
+                                while (elm) {
+                                    if ((elm.className || '').indexOf('cpPanel') !== -1) return elm;
+                                    elm = elm.parentNode;
+                                }
+                                return false;
+                            })(e.target),
+                            inputIndex = Array.prototype.indexOf.call(elms, e.target);
+
+                        if (isColorPicker && Array.prototype.indexOf.call(colorPickers, isColorPicker)) {
+                            if (e.target === colorPicker.nodes.exit) {
+                                colorPickerUI.parentNode.style.display = 'none';
+                                document.activeElement.blur();
+                            } else {
+                                // ...
+                            }
+                        } else if (inputIndex !== -1) {
+                            // ...
+                        } else if (colorPickerUI) {
+                            colorPickerUI.parentNode.style.display = 'none';
+                        }
+                    };
+                elm[onOff]('input', inputListener);
+                window.jsColorPicker.create = createListener;
+            },
+            // this is a way to prevent data binding on HTMLElements
+            colorPickers = window.jsColorPicker.colorPickers || [],
+            elms = document.querySelectorAll(selectors),
+            testColors = new window.Colors({customBG: config.customBG, allMixDetails: true});
+
+        window.jsColorPicker.colorPickers = colorPickers;
+
+        for (var n = 0, m = elms.length; n < m; n++) {
+            var elm = elms[n];
+
+            if (config === 'destroy') {
+                doEventListeners(elm, (config && config.multipleInstances), true);
+                if (colorPickers[n]) {
+                    colorPickers[n].destroyAll();
+                }
+            } else {
+                var color = extractValue(elm);
+                var value = color.split('(');
+
+                testColors.setColor(color);
+                if (config && config.init) {
+                    config.init(elm, testColors.colors);
+                }
+                elm.setAttribute('data-colorMode', value[1] ? value[0].substr(0, 3) : 'HEX');
+                doEventListeners(elm, (config && config.multipleInstances), false);
+                if (config && config.readOnly) {
+                    elm.readOnly = true;
+                }
+            }
+        };
+
+        return window.jsColorPicker.colorPickers;
+    };
+
+    window.ColorPicker.docCookies = function(key, val, options) {
+        var encode = encodeURIComponent, decode = decodeURIComponent,
+            cookies, n, tmp, cache = {},
+            days;
+
+        if (val === undefined) { // all about reading cookies
+            cookies = document.cookie.split(/;\s*/) || [];
+            for (n = cookies.length; n--; ) {
+                tmp = cookies[n].split('=');
+                if (tmp[0]) cache[decode(tmp.shift())] = decode(tmp.join('=')); // there might be '='s in the value...
+            }
+
+            if (!key) return cache; // return Json for easy access to all cookies
+            else return cache[key]; // easy access to cookies from here
+        } else { // write/delete cookie
+            options = options || {};
+
+            if (val === '' || options.expires < 0) { // prepare deleteing the cookie
+                options.expires = -1;
+                // options.path = options.domain = options.secure = undefined; // to make shure the cookie gets deleted...
+            }
+
+            if (options.expires !== undefined) { // prepare date if any
+                days = new Date();
+                days.setDate(days.getDate() + options.expires);
+            }
+
+            document.cookie = encode(key) + '=' + encode(val) +
+                (days            ? '; expires=' + days.toUTCString() : '') +
+                (options.path    ? '; path='    + options.path       : '') +
+                (options.domain  ? '; domain='  + options.domain     : '') +
+                (options.secure  ? '; secure'                        : '');
+        }
+    };
+})(this);
+
+// Added
+var colors = jsColorPicker('input.color', {
+    customBG: '#222',
+    readOnly: false,
+    // patch: false,
+    init: function(elm, colors) { // colors is a different instance (not connected to colorPicker)
+        elm.style.backgroundColor = elm.value;
+        elm.style.color = colors.rgbaMixCustom.luminance > 0.22 ? '#222' : '#ddd';
+    },
+    appendTo: document.getElementById("colorPanel"),
+    size: 1,
+});
+
+function openColorFromButton() {
+    delete window.jsColorPicker.confirm;
+    triggerColorPicker('414px', '53px');
+}
+
+function confirmColor() {
+    var colorPicker = document.getElementById("colorPicker");
+    if (window.jsColorPicker.confirm) { /* 存在块 */
+        // 检测需要是合法数值
+        var val = colorPicker.value;
+        if (/^[0-9 ]+,[0-9 ]+,[0-9 ]+,[0-9. ]+$/.test(val)) val = "rgba("+val+")";
+        else if (/^[0-9 ]+,[0-9 ]+,[0-9 ]+$/.test(val)) val = "rgba("+val+",1)";
+        else val = null;
+        if (val) window.jsColorPicker.confirm(val);
+    }
+    else {
+        colorPicker.select();
+        document.execCommand("Copy");
+    }
+
+    triggerColorPicker();
+}
+
+function triggerColorPicker(left, top) {
+    var colorPanel = document.getElementById('colorPanel');
+    if (colorPanel.style.display=='none' && left && top) {
+        colorPanel.style.display = "inline-block";
+        colorPanel.style.left = left;
+        colorPanel.style.top = top;
+        window.jsColorPicker.create();
+    }
+    else {
+        colorPanel.style.display = 'none';
+        delete window.jsColorPicker.confirm;
+    }
+}
+
+Blockly.FieldColour.prototype.createWidget_ = function() {
+    Blockly.WidgetDiv.hide();
+
+    // console.log('here')
+    var self=this;
+    var pb=self.sourceBlock_
+    var args = MotaActionBlocks[pb.type].args
+    var targetf=args[args.indexOf(self.name)-1]
+
+    var getValue=function(){
+        // return self.getValue() // css颜色
+        return pb.getFieldValue(targetf);
+        // 也可以用 pb.getFieldValue(targetf) 获得颜色块左边的域的内容
+    }
+
+    var setValue=function(newValue){ // css颜色
+        self.setValue(newValue)
+        var c=new Colors();
+        c.setColor(newValue)
+        var rgbatext = [c.colors.webSmart.r,c.colors.webSmart.g,c.colors.webSmart.b,c.colors.alpha].join(",");
+        pb.setFieldValue(rgbatext, targetf) // 放在颜色块左边的域中
+    }
+
+    setTimeout(function () {
+        document.getElementById("colorPicker").value = getValue();
+        window.jsColorPicker.confirm = setValue;
+        // 设置位置
+        triggerColorPicker(Blockly.WidgetDiv.DIV.style.left, Blockly.WidgetDiv.DIV.style.top);
+    });
+
+    return document.createElement('table');
+};
+
+Blockly.FieldTextInput.prototype.showInlineEditor_ = function(quietInput) {
+  Blockly.WidgetDiv.show(this, this.sourceBlock_.RTL, this.widgetDispose_());
+  var div = Blockly.WidgetDiv.DIV;
+  // Create the input.
+  var htmlInput =
+      goog.dom.createDom(goog.dom.TagName.INPUT, 'blocklyHtmlInput');
+  htmlInput.setAttribute('spellcheck', this.spellcheck_);
+  var fontSize =
+      (Blockly.FieldTextInput.FONTSIZE * this.workspace_.scale) + 'pt';
+  div.style.fontSize = fontSize;
+  htmlInput.style.fontSize = fontSize;
+
+  Blockly.FieldTextInput.htmlInput_ = htmlInput;
+  div.appendChild(htmlInput);
+
+  htmlInput.value = htmlInput.defaultValue = this.text_;
+  htmlInput.oldValue_ = null;
+  this.validate_();
+  this.resizeEditor_();
+  if (!quietInput) {
+    htmlInput.focus();
+    htmlInput.select();
+  }
+
+  // console.log('here')
+  var self=this;
+  var pb=self.sourceBlock_
+  var args = MotaActionBlocks[pb.type].args
+  var targetf=args[args.indexOf(self.name)+1]
+
+  if(targetf && targetf.slice(0,7)==='Colour_'){
+    var inputDom = htmlInput;
+    // var getValue=function(){ // 获得自己的字符串
+    //     return pb.getFieldValue(self.name);
+    // }
+    var setValue = function(newValue){ // 设置右边颜色块的css颜色
+        pb.setFieldValue(newValue, targetf)
+    }
+    // 给inputDom绑事件
+    inputDom.oninput=function(){
+        var value=inputDom.value
+        if(/[0-9 ]+,[0-9 ]+,[0-9 ]+(,[0-9. ]+)?/.test(value)){
+            setValue('rgba('+value+')')
+        }
+    }
+  }
+
+  this.bindEvents_(htmlInput);
+};
\ No newline at end of file
diff --git a/_server/comment.js b/_server/comment.js
deleted file mode 100644
index 42422d46..00000000
--- a/_server/comment.js
+++ /dev/null
@@ -1,382 +0,0 @@
-comment_c456ea59_6018_45ef_8bcc_211a24c627dc = 
-{
-    "_leaf": false,
-    "_type": "object",
-    "_data": {
-        "items": {
-            "_leaf": false,
-            "_type": "object",
-            "_data": {
-                "items": {
-                    "_leaf": false,
-                    "_type": "object",
-                    "_data": {
-                        "cls": {
-                            "_leaf": true,
-                            "_type": "select",
-                            "_select": {
-                                "values": [
-                                    "keys",
-                                    "items",
-                                    "constants",
-                                    "tools"
-                                ]
-                            },
-                            "_data": "只能取keys(钥匙) items(宝石、血瓶) constants(永久物品) tools(消耗道具)"
-                        },
-                        "name": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_string": true,
-                            "_data": "名称"
-                        },
-                        "text": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_string": true,
-                            "_data": "道具在道具栏中显示的描述"
-                        }
-                    }
-                },
-                "itemEffect": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_string": true,
-                    "_lint": true,
-                    "_data": "cls为items的即捡即用类物品的效果。"
-                },
-                "itemEffectTip": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_string": true,
-                    "_lint": true,
-                    "_data": "cls为items的即捡即用类物品，在获得时左上角额外显示的文字。"
-                },
-                "useItemEffect": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_string": true,
-                    "_lint": true,
-                    "_data": "cls为tools或contants时的使用物品效果。"
-                },
-                "canUseItemEffect": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_string": true,
-                    "_lint": true,
-                    "_data": "cls为tools或contants时对当前能否使用该物品的判断。"
-                }
-            }
-        },
-        "items_template" : {'cls': 'items', 'name': '新物品'},
-        "enemys": {
-            "_leaf": false,
-            "_type": "object",
-            "_data": {
-                "name": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_string": true,
-                    "_data": "名称"
-                },
-                "hp": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "生命值"
-                },
-                "atk": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "攻击力"
-                },
-                "def": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "防御力"
-                },
-                "money": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "金币"
-                },
-                "experience": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "经验"
-                },
-                "point": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "加点"
-                },
-                "special": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "特殊属性\n\n0:无,1:先攻,2:魔攻,3:坚固,4:2连击,\n5:3连击,6:n连击,7:破甲,8:反击,9:净化,\n10:模仿,11:吸血,12:中毒,13:衰弱,14:诅咒,\n15:领域,16:夹击,17:仇恨,18:阻击,19:自爆,\n20:无敌,21:退化,22:固伤,23:重生\n\n多个属性例如用[1,4,11]表示先攻2连击吸血\n模仿怪的攻防设为0就好"
-                },
-                "value": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "特殊属性的数值\n领域怪需要加value表示领域伤害的数值\n吸血怪需要在后面添加value代表吸血比例"
-                },
-                "zoneSquare": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "领域怪zoneSquare代表是否九宫格伤害"
-                },
-                "range": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_range": "(thiseval==~~thiseval && thiseval>0)||thiseval==null",
-                    "_data": "range可选，代表领域伤害的范围；不加默认为1"
-                },
-                "notBomb": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "加入 \"notBomb\": true 代表该怪物不可被炸弹或圣锤炸掉"
-                },
-                "n": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_range": "(thiseval==~~thiseval && thiseval>0)||thiseval==null",
-                    "_data": "多连击需要在后面指定n代表是几连击"
-                },
-                "add": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "代表吸血后是否加到自身"
-                },
-                "atkValue": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_range": "thiseval==~~thiseval||thiseval==null",
-                    "_data": "退化时勇士下降的攻击力点数"
-                },
-                "defValue": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_range": "thiseval==~~thiseval||thiseval==null",
-                    "_data": "退化时勇士下降的防御力点数"
-                },
-                "damage": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_range": "thiseval==~~thiseval||thiseval==null",
-                    "_data": "战前扣血的点数"
-                }
-            }
-        },
-        "enemys_template" : {'name': '新敌人', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-        "maps": {
-            "_leaf": false,
-            "_type": "object",
-            "_data": {
-                "id": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_range": "false",
-                    "_data": "图块ID"
-                },
-                "idnum": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_range": "false",
-                    "_data": "图块数字"
-                },
-                "cls": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_range": "false",
-                    "_data": "图块类别"
-                },
-                "trigger": {
-                    "_leaf": true,
-                    "_type": "select",
-                    "_select": {
-                        "values": [
-                            null,
-                            "openDoor",
-                            "passNet",
-                            "changeLight",
-                            "ski",
-                            "pushBox"
-                        ]
-                    },
-                    "_data": "图块的默认触发器"
-                },
-                "noPass": {
-                    "_leaf": true,
-                    "_type": "select",
-                    "_select": {
-                        "values": [
-                            null,
-                            true,
-                            false
-                        ]
-                    },
-                    "_data": "图块默认可通行状态"
-                }
-            }
-        },
-        "floors": {
-            "_leaf": false,
-            "_type": "object",
-            "_data": {
-                "floor": {
-                    "_leaf": false,
-                    "_type": "object",
-                    "_data": {
-                        "floorId": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_range": "false",
-                            "_data": "文件名和floorId需要保持完全一致 \n楼层唯一标识符仅能由字母、数字、下划线组成，且不能由数字开头 \n推荐用法：第20层就用MT20，第38层就用MT38，地下6层就用MT_6（用下划线代替负号），隐藏3层用MT3h（h表示隐藏），等等 \n楼层唯一标识符，需要和名字完全一致 \n这里不能更改floorId,请通过另存为来实现"
-                        },
-                        "title": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "楼层中文名，将在切换楼层和浏览地图时显示"
-                        },
-                        "name": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "显示在状态栏中的层数"
-                        },
-                        "width": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_range": "false",
-                            "_data": "地图x方向大小,这里不能更改,仅能在新建地图时设置,null视为13"
-                        },
-                        "height": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_range": "false",
-                            "_data": "地图y方向大小,这里不能更改,仅能在新建地图时设置,null视为13"
-                        },
-                        "canFlyTo": {
-                            "_leaf": true,
-                            "_type": "checkbox",
-                            "_bool": "bool",
-                            "_data": "该楼能否被楼传器飞到（不能的话在该楼也不允许使用楼传器）"
-                        },
-                        "canUseQuickShop": {
-                            "_leaf": true,
-                            "_type": "checkbox",
-                            "_bool": "bool",
-                            "_data": "该层是否允许使用快捷商店"
-                        },
-                        "cannotViewMap": {
-                            "_leaf": true,
-                            "_type": "checkbox",
-                            "_bool": "bool",
-                            "_data": "该层是否不允许被浏览地图看到；如果勾上则浏览地图会跳过该层"
-                        },
-                        "upFloor": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_range": "thiseval==null||((thiseval instanceof Array) && thiseval.length==2)",
-                            "_data": "该层上楼点，如[2,3]。\n如果此项不为null，则楼层转换时的stair:upFloor，以及楼传器的落点会被替换成该点而不是该层的上楼梯。"
-                        },
-                        "downFloor": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_range": "thiseval==null||((thiseval instanceof Array) && thiseval.length==2)",
-                            "_data": "该层上楼点，如[2,3]。\n如果此项不为null，则楼层转换时的stair:downFloor，以及楼传器的落点会被替换成该点而不是该层的下楼梯。"
-                        },
-                        "defaultGround": {
-                            "_leaf": true,
-                            "_type": "select",
-                            "_select": {
-                                "values": Object.keys(editor.core.icons.icons.terrains)
-                            },
-                            "_data": "默认地面的图块ID，此项修改后需要刷新才能看到效果。"
-                        },
-                        "images": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "背景/前景图；你可以选择若干张图片来作为背景/前景素材。详细用法请参见文档“自定义素材”中的说明。"
-                        },
-                        "color": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "该层的默认画面色调。本项可不写（代表无色调），如果写需要是一个RGBA数组如[255,0,0,0.3]"
-                        },
-                        "weather": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "该层的默认天气。本项可忽略表示晴天，如果写则第一项为\"rain\"或\"snow\"代表雨雪，第二项为1-10之间的数代表强度。\n如[\"rain\", 8]代表8级雨天。"
-                        },
-                        "bgm": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "到达该层后默认播放的BGM。本项可忽略，或者为一个定义过的背景音乐如\"bgm.mp3\"。"
-                        },
-                        "item_ratio": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_range": "(thiseval==~~thiseval && thiseval>=0)||thiseval==null",
-                            "_data": "每一层的宝石/血瓶效果，即获得宝石和血瓶时框内\"ratio\"的值。"
-                        },
-                        "firstArrive": {
-                            "_leaf": true,
-                            "_type": "event",
-                            "_event": "firstArrive",
-                            "_data": "第一次到该楼层触发的事件，可以双击进入事件编辑器。"
-                        },
-                        "underGround": {
-                            "_leaf": true,
-                            "_type": "checkbox",
-                            "_bool": "bool",
-                            "_data": "是否是地下层；如果该项为true则同层传送将传送至上楼梯"
-                        }
-                    }
-                },
-                "loc": {
-                    "_leaf": false,
-                    "_type": "object",
-                    "_data": {
-                        "events": {
-                            "_leaf": true,
-                            "_type": "event",
-                            "_event": "event",
-                            "_data": "该点的可能事件列表，可以双击进入事件编辑器。"
-                        },
-                        "changeFloor": {
-                            "_leaf": true,
-                            "_type": "event",
-                            "_event": "changeFloor",
-                            "_data": "该点楼层转换事件；该事件不能和上面的events同时出现，否则会被覆盖"
-                        },
-                        "afterBattle": {
-                            "_leaf": true,
-                            "_type": "event",
-                            "_event": "afterBattle",
-                            "_data": "该点战斗后可能触发的事件列表，可以双击进入事件编辑器。"
-                        },
-                        "afterGetItem": {
-                            "_leaf": true,
-                            "_type": "event",
-                            "_event": "afterGetItem",
-                            "_data": "该点获得道具后可能触发的事件列表，可以双击进入事件编辑器。"
-                        },
-                        "afterOpenDoor": {
-                            "_leaf": true,
-                            "_type": "event",
-                            "_event": "afterOpenDoor",
-                            "_data": "该点开完门后可能触发的事件列表，可以双击进入事件编辑器。"
-                        },
-                        "cannotMove": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "该点不可通行的方向 \n 可以在这里定义该点不能前往哪个方向，可以达到悬崖之类的效果\n例如 [\"up\", \"left\"], // 代表该点不能往上和左走"
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/_server/css/editor.css b/_server/css/editor.css
index 928a0964..dd9c0e18 100644
--- a/_server/css/editor.css
+++ b/_server/css/editor.css
@@ -18,6 +18,28 @@ body {
     margin: 0 auto;
 }
 
+.cp-app {
+	z-index: 250;
+}
+
+#colorPanel {
+    position: fixed;
+    width: max-content;
+    height: 205px;
+    z-index: 240;
+    padding: 4px 6px;
+    margin-top: 6px;
+    background-color: #F5F5F5;
+    box-sizing: border-box;
+    box-shadow: 0 2px 2px 0 rgba(0, 0, 0, .14), 0 3px 1px -2px rgba(0, 0, 0, .2), 0 1px 5px 0 rgba(0, 0, 0, .12);
+}
+
+#colorPicker {
+    margin: 2px 0; 
+    border-radius: 3px;
+    width: 104px;
+}
+
 #left, #mid, #right {
     border-radius: 2px;
     box-sizing: border-box;
@@ -32,10 +54,10 @@ body {
     height: 630px;
 }
 
-#editArea {
+#mapEditArea {
     position: absolute;
     width: 100%;
-    height: 70%;
+    height: 400px;
     left: 0;
     top: 0;
     /* padding: 10px 5px; */
@@ -45,7 +67,7 @@ body {
 #pout {
     display: block;
     width: 410px;
-    height: 100%;
+    height: 380px;
     box-sizing: border-box;
     margin-left: 22px;
     margin-top: 23px;
@@ -61,12 +83,31 @@ body {
 #editTip {
     position: absolute;
     width: 100%;
-    margin-bottom: 120px;
-    bottom: 0;
     left: 10px;
+    top: 430px;
 }
 
-#editArea p {
+#editBtns {
+    position: absolute;
+    width: 100%;
+    left: 10px;
+    top: 465px;
+}
+
+#newMaps {
+    position: absolute;
+    left: 10px;
+    top: 505px;
+}
+
+#newFloors {
+    position: absolute;
+    width: 100%;
+    left: 10px;
+    top: 530px;
+}
+
+#mapEditArea p {
     margin: 10px;
     display: block;
     width: 70%;
@@ -107,7 +148,6 @@ body {
     height: 180px;
     left: 0;
     bottom: 0;
-    border-top: 1px solid #ccc;
     padding: 10px 5px;
     margin-left: 8px;;
     box-sizing: border-box;
@@ -213,6 +253,15 @@ body {
     overflow: auto;
 }
 
+#iconImages {
+    z-index: 0;
+    overflow: hidden;
+}
+
+#iconImages img {
+    position: absolute;
+}
+
 .egameCanvas {
     position: absolute;
 }
@@ -392,3 +441,21 @@ table.row td {
 [v-cloak] {
     display: none !important;
 }
+
+#searchBlock {
+    width: 100px;
+    background-color: #E9EBF2;
+    border-radius: 10px;
+    outline: none;
+    padding-left: 20px;
+    height: 14px;
+}
+
+.searchLogo {
+    width: 15px;
+    height: 15px;
+    position: absolute;
+    left: 6px;
+    top: 6px;
+    background-image:url('data:image/svg+xml;base64,PHN2ZyB2ZXJzaW9uPSIxLjEiIGJhc2VQcm9maWxlPSJmdWxsIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB4bWxuczpldj0iaHR0cDovL3d3dy53My5vcmcvMjAwMS94bWwtZXZlbnRzIj4KPGc%2BCgk8cG9seWdvbiBmaWxsPSIjNjY2IiBwb2ludHM9IjkuMjA3LDYuMTI2IDcuNzkzLDcuNTQxIDExLjc5MywxMS41NDEgMTMuMjA3LDEwLjEyNiIgLz4KCTxwYXRoIGZpbGw9IiM2NjYiIGQ9Ik01LjkxNywyYzEuNjA4LDAsMi45MTcsMS4zMDgsMi45MTcsMi45MTdTNy41MjUsNy44MzMsNS45MTcsNy44MzNTMyw2LjUyNSwzLDQuOTE3UzQuMzA4LDIsNS45MTcsMgoJCSBNNS45MTcsMEMzLjIwMSwwLDEsMi4yMDEsMSw0LjkxN3MyLjIwMSw0LjkxNyw0LjkxNyw0LjkxN3M0LjkxNy0yLjIwMSw0LjkxNy00LjkxN0MxMC44MzMsMi4yMDEsOC42MzIsMCw1LjkxNywwTDUuOTE3LDB6IiAvPgo8L2c%2BCjwvc3ZnPgo%3D');
+}
\ No newline at end of file
diff --git a/_server/css/editor_mobile.css b/_server/css/editor_mobile.css
index 36ca92ae..1120c9fd 100644
--- a/_server/css/editor_mobile.css
+++ b/_server/css/editor_mobile.css
@@ -37,7 +37,7 @@ body {
     position: absolute;
 }
 
-#editArea {
+#mapEditArea {
     position: absolute;
     width: 100%;
     height: 70%;
@@ -45,6 +45,7 @@ body {
     top: 0;
     /* padding: 10px 5px; */
     box-sizing: border-box;
+    display: none;
 }
 
 #pout {
@@ -63,7 +64,7 @@ body {
     overflow: auto;
 }
 
-#editArea p {
+#mapEditArea p {
     margin: 10px;
     display: block;
     width: 70%;
@@ -72,12 +73,39 @@ body {
     font-size: 14px;
 }
 
+#editTip {
+    position: absolute;
+    width: 95vw;
+    left: 4vw;
+    top: 4vw;
+}
+
 #editTip .btn {
     float: right;
     margin-right: 20px;
     margin-top: 5px;
 }
 
+#editBtns {
+    position: absolute;
+    width: 95vw;
+    left: 4vw;
+    top: 20vw;
+}
+
+#newMaps {
+    position: absolute;
+    left: 4vw;
+    top: 35vw;
+}
+
+#newFloors {
+    position: absolute;
+    width: 95vw;
+    left: 4vw;
+    top: 43vw;
+}
+
 #mid {
     position: absolute;
 }
@@ -112,7 +140,7 @@ body {
 
 #tip {
     float: right;
-    width: 50%;
+    width: 45%;
     /* height: 95%; */
     min-height: 9rem;
     padding: 5px 10px 10px 10px;
@@ -210,6 +238,15 @@ body {
     overflow: auto;
 }
 
+#iconImages {
+    z-index: 0;
+    overflow: hidden;
+}
+
+#iconImages img {
+    position: absolute;
+}
+
 .egameCanvas {
     position: absolute;
 }
@@ -279,6 +316,7 @@ div.col .coltd {
     width: 95vw;
     height: 16px;
     font-size: 13px;
+    display: none;
 }
 
 #mapColMark {
@@ -334,6 +372,7 @@ div.row .rowtd .rowtext{
     width: 4vw;
     height: 62vw;
     font-size: 12px;
+    display: none;
 }
 
 #mapRowMark {
@@ -425,4 +464,22 @@ div.row .rowtd .rowtext{
     top:100vw;
     bottom: 0;
     width: 100vw;
+}
+
+#colorPanel {
+    position: fixed;
+    width: max-content;
+    height: 205px;
+    z-index: 240;
+    padding: 4px 6px;
+    margin-top: 6px;
+    background-color: #F5F5F5;
+    box-sizing: border-box;
+    box-shadow: 0 2px 2px 0 rgba(0, 0, 0, .14), 0 3px 1px -2px rgba(0, 0, 0, .2), 0 1px 5px 0 rgba(0, 0, 0, .12);
+}
+
+#colorPicker {
+    margin: 2px 0;
+    border-radius: 3px;
+    width: 90px;
 }
\ No newline at end of file
diff --git a/_server/css/editor_mode.css b/_server/css/editor_mode.css
index 2cb2e95a..a1859f65 100644
--- a/_server/css/editor_mode.css
+++ b/_server/css/editor_mode.css
@@ -32,6 +32,7 @@
     position: fixed;
     top: 15px;
     left: 15px;
+    z-index: 20;
 }
 
 .leftTab .leftTabContent {
diff --git a/_server/data.comment.js b/_server/data.comment.js
deleted file mode 100644
index acfae9fc..00000000
--- a/_server/data.comment.js
+++ /dev/null
@@ -1,596 +0,0 @@
-data_comment_c456ea59_6018_45ef_8bcc_211a24c627dc = 
-{
-    "_leaf": false,
-    "_type": "object",
-    "_data": {
-        "main": {
-            "_leaf": false,
-            "_type": "object",
-            "_data": {
-                "floorIds": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "在这里按顺序放所有的楼层；其顺序直接影响到楼层传送器、浏览地图和上/下楼器的顺序"
-                },
-                "images": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "在此存放所有可能使用的图片 \n  图片可以被作为背景图（的一部分），也可以直接用自定义事件进行显示。 \n 图片名不能使用中文，不能带空格或特殊字符；可以直接改名拼音就好 \n 建议对于较大的图片，在网上使用在线的“图片压缩工具(http://compresspng.com/zh/)”来进行压缩，以节省流量 \n 依次向后添加"
-                },
-                "animates": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "在此存放所有可能使用的动画，必须是animate格式，在这里不写后缀名 \n 动画必须放在animates目录下；文件名不能使用中文，不能带空格或特殊字符 \n \"jianji\", \"thunder\" \n 根据需求自行添加"
-                },
-                "bgms": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "在此存放所有的bgm，和文件名一致。第一项为默认播放项 \n 音频名不能使用中文，不能带空格或特殊字符；可以直接改名拼音就好"
-                },
-                "sounds": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "在此存放所有的SE，和文件名一致 \n 音频名不能使用中文，不能带空格或特殊字符；可以直接改名拼音就好"
-                },
-                "startBackground": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "标题界面的背景，建议使用jpg格式以压缩背景图空间"
-                },
-                "startLogoStyle": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "标题样式：可以改变颜色，也可以写\"display: none\"来隐藏标题"
-                },
-                "levelChoose": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "难度选择:每个数组的第一个是其在标题界面显示的难度,第二个是在游戏内部传输的字符串,会显示在状态栏,修改此处后需要在project/functions中作相应更改"
-                },
-                "statusLeftBackground": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "横屏时左侧状态栏的背景样式，可以定义背景图、平铺方式等。\n具体请网上搜索\"css background\"了解写法。\n如果弄一张图片作为背景图，推荐写法：\n\"url(project/images/XXX.png) 0 0/100% 100% no-repeat\"\n图片最好进行一些压缩等操作节省流量。"
-                },
-                "statusTopBackground": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "竖屏时上方状态栏的背景样式，可以定义背景图、平铺方式等。\n具体请网上搜索\"css background\"了解写法。\n如果弄一张图片作为背景图，推荐写法：\n\"url(project/images/XXX.png) 0 0/100% 100% no-repeat\"\n图片最好进行一些压缩等操作节省流量。"
-                },
-                "toolsBackground": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "竖屏时下方道具栏的背景样式，可以定义背景图、平铺方式等。\n具体请网上搜索\"css background\"了解写法。\n如果弄一张图片作为背景图，推荐写法：\n\"url(project/images/XXX.png) 0 0/100% 100% no-repeat\"\n图片最好进行一些压缩等操作节省流量。"
-                },
-                "borderColor": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "边框颜色，包括游戏边界的边框和对话框边框等。"
-                }
-            }
-        },
-        "firstData": {
-            "_leaf": false,
-            "_type": "object",
-            "_data": {
-                "title": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "游戏名，将显示在标题页面以及切换楼层的界面中"
-                },
-                "name": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_range": "/^[a-zA-Z0-9_]{1,30}$/.test(thiseval)",
-                    "_data": "游戏的唯一英文标识符。由英文、数字、下划线组成，不能超过30个字符。\n此项必须修改，其将直接影响到存档的定位！"
-                },
-                "version": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "当前游戏版本；版本不一致的存档不能通用。"
-                },
-                "floorId": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "初始楼层的ID"
-                },
-                "hero": {
-                    "_leaf": false,
-                    "_type": "object",
-                    "_data": {
-                        "name": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "勇士名；可以改成喜欢的"
-                        },
-                        "lv": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_range": "thiseval==~~thiseval &&thiseval>0",
-                            "_data": "初始等级，该项必须为正整数"
-                        },
-                        "hpmax": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "初始生命上限，只有在enableHPMax开启时才有效"
-                        },
-                        "hp": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "初始生命值"
-                        },
-                        "atk": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "初始攻击"
-                        },
-                        "def": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "初始防御"
-                        },
-                        "mdef": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "初始魔防"
-                        },
-                        "money": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "初始金币"
-                        },
-                        "experience": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "初始经验"
-                        },
-                        "items": {
-                            "_leaf": false,
-                            "_type": "object",
-                            "_data": {
-                                "keys": {
-                                    "_leaf": true,
-                                    "_type": "textarea",
-                                    "_data": "初始三种钥匙个数"
-                                },
-                                "constants": {
-                                    "_leaf": true,
-                                    "_type": "textarea",
-                                    "_data": "初始永久道具个数，例如初始送手册可以写 {\"book\": 1}"
-                                },
-                                "tools": {
-                                    "_leaf": true,
-                                    "_type": "textarea",
-                                    "_data": "初始消耗道具个数，例如初始有两破可以写 {\"pickaxe\": 2}"
-                                }
-                            }
-                        },
-                        "flyRange": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "初始可飞的楼层；一般留空数组即可"
-                        },
-                        "loc": {
-                            "_leaf": false,
-                            "_type": "object",
-                            "_data": {
-                                "direction": {
-                                    "_leaf": true,
-                                    "_type": "textarea",
-                                    "_data": "勇士初始方向"
-                                },
-                                "x": {
-                                    "_leaf": true,
-                                    "_type": "textarea",
-                                    "_data": "勇士初始x坐标"
-                                },
-                                "y": {
-                                    "_leaf": true,
-                                    "_type": "textarea",
-                                    "_data": "勇士初始y坐标"
-                                }
-                            }
-                        },
-                        "flags": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "游戏过程中的变量或flags"
-                        },
-                        "steps": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "行走步数统计"
-                        }
-                    }
-                },
-                "startText": {
-                    "_leaf": true,
-                    "_type": "event",
-                    "_event": "firstArrive",
-                    "_data": "游戏开始前剧情。\n可以双击进入事件编辑器。\n如果无剧情直接留一个空数组即可。"
-                },
-                "shops": {
-                    "_leaf": true,
-                    "_type": "event",
-                    "_event": "shop",
-                    "_data": "全局商店，是一个数组，可以双击进入事件编辑器。"
-                },
-                "levelUp": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "经验升级所需要的数值，是一个数组，可以双击进行编辑。 \n 第一项为初始等级，可以简单留空，也可以写name \n 每一个里面可以含有三个参数 need, name, effect \n need为所需要的经验数值，是一个正整数。请确保need所需的依次递增 \n name为该等级的名称，也可以省略代表使用系统默认值；本项将显示在状态栏中 \n effect为本次升级所执行的操作，可由若干项组成，由分号分开 \n 其中每一项写法和上面的商店完全相同，同样必须是X+=Y的形式，Y是一个表达式，同样可以使用status:xxx或item:xxx代表勇士的某项数值/道具个数"
-                }
-            }
-        },
-        "values": {
-            "_leaf": false,
-            "_type": "object",
-            "_data": {
-                "lavaDamage": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "经过血网受到的伤害"
-                },
-                "poisonDamage": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "中毒后每步受到的伤害"
-                },
-                "weakValue": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "衰弱状态下攻防减少的数值\n如果此项不小于1，则作为实际下降的数值（比如10就是攻防各下降10）\n如果在0到1之间则为下降的比例（比如0.3就是下降30%的攻防）"
-                },
-                "redJewel": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "红宝石加攻击的数值"
-                },
-                "blueJewel": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "蓝宝石加防御的数值"
-                },
-                "greenJewel": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "绿宝石加魔防的数值"
-                },
-                "redPotion": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "红血瓶加血数值"
-                },
-                "bluePotion": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "蓝血瓶加血数值"
-                },
-                "yellowPotion": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "黄血瓶加血数值"
-                },
-                "greenPotion": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "绿血瓶加血数值"
-                },
-                "sword0": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "空剑的攻击力，此项请保持为0"
-                },
-                "shield0": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "空盾的防御力，此项请保持为0"
-                },
-                "sword1": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "铁剑加攻数值"
-                },
-                "shield1": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "铁盾加防数值"
-                },
-                "sword2": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "银剑加攻数值"
-                },
-                "shield2": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "银盾加防数值"
-                },
-                "sword3": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "骑士剑加攻数值"
-                },
-                "shield3": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "骑士盾加防数值"
-                },
-                "sword4": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "圣剑加攻数值"
-                },
-                "shield4": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "圣盾加防数值"
-                },
-                "sword5": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "神圣剑加攻数值"
-                },
-                "shield5": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "神圣盾加防数值"
-                },
-                "moneyPocket": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "金钱袋加金币的数值"
-                },
-                "breakArmor": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "破甲的比例（战斗前，怪物附加角色防御的x倍作为伤害）"
-                },
-                "counterAttack": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "反击的比例（战斗时，怪物每回合附加角色攻击的x倍作为伤害，无视角色防御）"
-                },
-                "purify": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "净化的比例（战斗前，怪物附加勇士魔防的x倍作为伤害）"
-                },
-                "hatred": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "仇恨属性中，每杀死一个怪物获得的仇恨值"
-                },
-                "maxValidHp": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_range": "thiseval==null||thiseval>0",
-                    "_data": "最大合法生命值；如果此项不为null且用户通关血量超过本值，则视为作弊，不上传成绩"
-                },
-                "animateSpeed": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "动画时间，一般300比较合适"
-                }
-            }
-        },
-        "flags": {
-            "_leaf": false,
-            "_type": "object",
-            "_data": {
-                "enableFloor": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否在状态栏显示当前楼层"
-                },
-                "enableLv": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否在状态栏显示当前等级"
-                },
-                "enableHPMax": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否是否启用生命上限"
-                },
-                "enableMDef": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否在状态栏及战斗界面显示魔防（护盾）"
-                },
-                "enableMoney": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否在状态栏、怪物手册及战斗界面显示金币"
-                },
-                "enableExperience": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否在状态栏、怪物手册及战斗界面显示经验"
-                },
-                "enableLevelUp": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否允许等级提升（进阶）；如果上面enableExperience为false，则此项恒视为false"
-                },
-                "enableKeys": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否在状态栏显示三色钥匙数量"
-                },
-                "enablePZF": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否在状态栏显示破炸飞数量"
-                },
-                "enableDebuff": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否涉及毒衰咒；如果此项为false则不会在状态栏中显示毒衰咒的debuff"
-                },
-                "flyNearStair": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否需要在楼梯边使用传送器"
-                },
-                "pickaxeFourDirections": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "使用破墙镐是否四个方向都破坏；如果false则只破坏面前的墙壁"
-                },
-                "bombFourDirections": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "使用炸弹是否四个方向都会炸；如果false则只炸面前的怪物（即和圣锤等价）"
-                },
-                "snowFourDirections": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "使用冰冻徽章是否四个方向都会消除熔岩；如果false则只消除面前的熔岩"
-                },
-                "bigKeyIsBox": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "如果此项为true，则视为钥匙盒，红黄蓝钥匙+1；若为false，则视为大黄门钥匙"
-                },
-                "equipment": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "剑和盾是否直接作为装备。如果此项为true，则作为装备，需要在道具栏使用，否则将直接加属性。"
-                },
-                /*
-                "enableDeleteItem": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否允许删除（丢弃）道具"
-                },
-                */
-                "enableAddPoint": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否支持加点"
-                },
-                "enableNegativeDamage": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否支持负伤害（回血）"
-                },
-                "hatredDecrease": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否在和仇恨怪战斗后减一半的仇恨值，此项为false则和仇恨怪不会扣减仇恨值。"
-                },
-                "betweenAttackCeil": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "夹击方式是向上取整还是向下取整。如果此项为true则为向上取整，为false则为向下取整"
-                },
-                "useLoop": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否循环计算临界；如果此项为true则使用循环法（而不是回合数计算法）来算临界"
-                },
-                "startDirectly": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "点击“开始游戏”后是否立刻开始游戏而不显示难度选择界面"
-                },
-                "canOpenBattleAnimate": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否允许用户开启战斗过程；如果此项为false，则下面两项均强制视为false"
-                },
-                "showBattleAnimateConfirm": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否在游戏开始时提供“是否开启战斗动画”的选项"
-                },
-                "battleAnimate": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否默认显示战斗动画；用户可以手动在菜单栏中开关"
-                },
-                "displayEnemyDamage": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否地图怪物显伤；用户可以手动在菜单栏中开关"
-                },
-                "displayCritical": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否地图显示临界；用户可以手动在菜单栏中开关"
-                },
-                "displayExtraDamage": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否地图高级显伤（领域、夹击等）；用户可以手动在菜单栏中开关"
-                },
-                "enableGentleClick": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否允许轻触（获得面前物品）"
-                },
-                "potionWhileRouting": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "寻路算法是否经过血瓶；如果该项为false，则寻路算法会自动尽量绕过血瓶"
-                },
-                "enableViewMaps": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否支持在菜单栏中查看所有楼层的地图"
-                },
-                "portalWithoutTrigger": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "经过楼梯、传送门时是否能“穿透”。\n穿透的意思是，自动寻路得到的的路径中间经过了楼梯，行走时是否触发楼层转换事件"
-                },
-                "canGoDeadZone": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否允许走到将死的领域上。如果此项为true，则可以走到将死的领域上"
-                },
-                "enableMoveDirectly": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否允许瞬间移动"
-                }
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/_server/editor.js b/_server/editor.js
index 612df88f..aa5a21ec 100644
--- a/_server/editor.js
+++ b/_server/editor.js
@@ -1,105 +1,274 @@
 function editor() {
     this.version = "2.0";
-    this.material = {};
-    this.brushMod = "line";//["line","rectangle"]
+    this.brushMod = "line";//["line","rectangle","tileset"]
+    this.layerMod = "map";//["fgmap","map","bgmap"]
+    this.isMobile = false;
+
+    window.onerror = function (msg, url, lineNo, columnNo, error) {
+        var string = msg.toLowerCase();
+        var substring = "script error";
+        var message;
+        if (string.indexOf(substring) > -1){
+            message = 'Script Error: See Browser Console for Detail';
+        } else {
+            if (url) url = url.substring(url.lastIndexOf('/')+1);
+            message = [
+                'Message: ' + msg,
+                'URL: ' + url,
+                'Line: ' + lineNo,
+                'Column: ' + columnNo,
+                'Error object: ' + JSON.stringify(error)
+            ].join(' - ');
+            // alert(message);
+        }
+        try {
+            printe(message)
+        } catch (e) {
+            alert(message);
+        }
+        return false;
+    };
 }
 
+/* 
+editor.loc
+editor.pos
+editor.info
+始终是最后一次点击的结果
+注意editor.info可能因为点击其他地方而被清空
+*/
+
+/////////// 数据相关 ///////////
+
 editor.prototype.init = function (callback) {
-    var afterCoreReset = function () {
+    
+    var useCompress = main.useCompress;
+    main.useCompress = false;
+    editor.airwallImg = new Image();
+    editor.airwallImg.src = './project/images/airwall.png';
 
-        main.editor.disableGlobalAnimate = false;//允许GlobalAnimate
-        /* core.setHeroMoveTriggerInterval(); */
-
-        editor.reset(function () {
-            editor.drawMapBg();
-            var mapArray = core.maps.save(core.status.maps, core.status.floorId);
-            editor.map = mapArray.map(function (v) {
-                return v.map(function (v) {
-                    return editor.ids[[editor.indexs[parseInt(v)][0]]]
-                })
-            });
-            editor.currentFloorId = core.status.floorId;
-            editor.currentFloorData = core.floors[core.status.floorId];
-            editor.updateMap();
-            editor.buildMark();
-            editor.drawEventBlock();
-            if (Boolean(callback)) callback();
-        });
-    }
+    main.init('editor', function () {
+        editor_util_wrapper(editor);
+        editor_game_wrapper(editor, main, core);
+        editor_file_wrapper(editor);
+        editor_table_wrapper(editor);
+        editor_unsorted_1_wrapper(editor);
+        editor.printe=printe;
+        afterMainInit();
+    });
 
     var afterMainInit = function () {
-        core.floors = JSON.parse(JSON.stringify(core.floors, function (k, v) {
-            if (v instanceof Function) {
-                return v.toString()
-            } else return v
-        }));
-        core.data = JSON.parse(JSON.stringify(core.data, function (k, v) {
-            if (v instanceof Function) {
-                return v.toString()
-            } else return v
-        }));
-        data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d = JSON.parse(JSON.stringify(data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d, function (k, v) {
-            if (v instanceof Function) {
-                return v.toString()
-            } else return v
-        }));
+        editor.game.fixFunctionInGameData();
         editor.main = main;
         editor.core = core;
         editor.fs = fs;
         editor_file = editor_file(editor, function () {
             editor.file = editor_file;
             editor_mode = editor_mode(editor);
+            editor_unsorted_2_wrapper(editor_mode);
             editor.mode = editor_mode;
-            editor.material.images = core.material.images;
-            editor.listen(); // 开始监听事件
-            core.resetStatus(core.firstData.hero, null, core.firstData.floorId, null, core.initStatus.maps);
+            core.resetGame(core.firstData.hero, null, core.firstData.floorId, core.clone(core.initStatus.maps));
             core.changeFloor(core.status.floorId, null, core.firstData.hero.loc, null, function () {
                 afterCoreReset();
             }, true);
             core.events.setInitData(null);
         });
     }
-    afterMainInit();
+
+    var afterCoreReset = function () {
+        
+        editor.game.idsInit(core.maps, core.icons.icons); // 初始化图片素材信息
+        editor.drawInitData(core.icons.icons); // 初始化绘图
+
+        editor.game.fetchMapFromCore();
+        editor.updateMap();
+        editor.buildMark();
+        editor.drawEventBlock();
+        
+        editor.pos = {x: 0, y: 0};
+        editor.mode.loc();
+        editor.info = editor.ids[editor.indexs[201]];
+        editor.mode.enemyitem();
+        editor.mode.floor();
+        editor.mode.tower();
+        editor.mode.functions();
+        editor.mode.commonevent();
+        editor.mode.showMode('tower');
+        
+        editor_multi = editor_multi();
+        editor_blockly = editor_blockly();
+
+        if (editor.useCompress == null) editor.useCompress = useCompress;
+        if (Boolean(callback)) callback();
+
+    }
+
+    
 }
 
-editor.prototype.reset = function (callback) {
-    editor.idsInit(core.maps, core.icons.icons); // 初始化图片素材信息
-    editor.drawInitData(core.icons.icons); // 初始化绘图
-    if (Boolean(callback)) callback();
-}
-
-editor.prototype.idsInit = function (maps, icons) {
-    editor.ids = [0];
-    editor.indexs = [];
-    var MAX_NUM = 1000;
-    var getInfoById = function (id) {
-        var block = maps.initBlock(0, 0, id);
-        if (hasOwnProp(block, 'event')) {
-            return block;
+editor.prototype.mapInit = function () {
+    var ec = document.getElementById('event').getContext('2d');
+    ec.clearRect(0, 0, core.bigmap.width*32, core.bigmap.height*32);
+    document.getElementById('event2').getContext('2d').clearRect(0, 0, core.bigmap.width*32, core.bigmap.height*32);
+    editor.map = [];
+    var sy=editor.currentFloorData.map.length,sx=editor.currentFloorData.map[0].length;
+    for (var y = 0; y < sy; y++) {
+        editor.map[y] = [];
+        for (var x = 0; x < sx; x++) {
+            editor.map[y][x] = 0;
         }
     }
-    var point = 0;
-    for (var i = 0; i < MAX_NUM; i++) {
-        var indexBlock = getInfoById(i);
-        editor.indexs[i] = [];
-        if (indexBlock) {
-            var id = indexBlock.event.id;
-            var indexId = indexBlock.id;
-            var allCls = Object.keys(icons);
-            for (var j = 0; j < allCls.length; j++) {
-                if (id in icons[allCls[j]]) {
-                    editor.ids.push({'idnum': indexId, 'id': id, 'images': allCls[j], 'y': icons[allCls[j]][id]});
-                    point++;
-                    editor.indexs[i].push(point);
-                }
+    editor.fgmap=JSON.parse(JSON.stringify(editor.map));
+    editor.bgmap=JSON.parse(JSON.stringify(editor.map));
+    editor.currentFloorData.map = editor.map;
+    editor.currentFloorData.fgmap = editor.fgmap;
+    editor.currentFloorData.bgmap = editor.bgmap;
+    editor.currentFloorData.firstArrive = [];
+    editor.currentFloorData.eachArrive = [];
+    editor.currentFloorData.events = {};
+    editor.currentFloorData.changeFloor = {};
+    editor.currentFloorData.afterBattle = {};
+    editor.currentFloorData.afterGetItem = {};
+    editor.currentFloorData.afterOpenDoor = {};
+    editor.currentFloorData.cannotMove = {};
+}
+
+editor.prototype.changeFloor = function (floorId, callback) {
+    for(var ii=0,name;name=['map','bgmap','fgmap'][ii];ii++){
+        var mapArray=editor[name].map(function (v) {
+            return v.map(function (v) {
+                return v.idnum || v || 0
+            })
+        });
+        editor.currentFloorData[name]=mapArray;
+    }
+    editor.preMapData = null;
+    core.changeFloor(floorId, null, {"x": 0, "y": 0, "direction": "up"}, null, function () {
+        core.bigmap.offsetX=0;
+        core.bigmap.offsetY=0;
+        editor.moveViewport(0,0);
+
+        editor.game.fetchMapFromCore();
+        editor.updateMap();
+        editor_mode.floor();
+        editor.drawEventBlock();
+        if (callback) callback();
+    });
+}
+
+/////////// 游戏绘图相关 ///////////
+
+editor.prototype.drawEventBlock = function () {
+    var fg=document.getElementById('efg').getContext('2d');
+
+    fg.clearRect(0, 0, core.__PIXELS__, core.__PIXELS__);
+    for (var i=0;i<core.__SIZE__;i++) {
+        for (var j=0;j<core.__SIZE__;j++) {
+            var color=[];
+            var loc=(i+core.bigmap.offsetX/32)+","+(j+core.bigmap.offsetY/32);
+            if (editor.currentFloorData.events[loc])
+                color.push('#FF0000');
+            if (editor.currentFloorData.changeFloor[loc])
+                color.push('#00FF00');
+            if (editor.currentFloorData.afterBattle[loc])
+                color.push('#FFFF00');
+            if (editor.currentFloorData.afterGetItem[loc])
+                color.push('#00FFFF');
+            if (editor.currentFloorData.afterOpenDoor[loc])
+                color.push('#FF00FF');
+            if (editor.currentFloorData.cannotMove[loc])
+                color.push('#0000FF');
+            for(var kk=0,cc;cc=color[kk];kk++){
+                fg.fillStyle = cc;
+                fg.fillRect(32*i+8*kk, 32*j+32-8, 8, 8);
             }
         }
     }
-    editor.indexs[0] = [0];
 }
+
+editor.prototype.drawPosSelection = function () {
+    this.drawEventBlock();
+    var fg=document.getElementById('efg').getContext('2d');
+    fg.strokeStyle = 'rgba(255,255,255,0.7)';
+    fg.lineWidth = 4;
+    fg.strokeRect(32*editor.pos.x - core.bigmap.offsetX + 4, 32*editor.pos.y - core.bigmap.offsetY + 4, 24, 24);
+}
+
+editor.prototype.updateMap = function () {
+    var blocks =  core.maps._mapIntoBlocks(editor.map.map(function (v) {
+        return v.map(function (v) {
+            try {
+                return v.idnum || v || 0
+            }
+            catch (e) {
+                console.log("Unable to read idnum from "+v);
+                return 0;
+            }
+        });
+    }), {'events': editor.currentFloorData.events}, editor.currentFloorId);
+    core.status.thisMap.blocks = blocks;
+
+    var updateMap = function () {
+        core.removeGlobalAnimate();
+        core.clearMap('bg');
+        core.clearMap('event');
+        core.clearMap('event2');
+        core.clearMap('fg');
+        core.maps._drawMap_drawAll();
+    }
+    updateMap();
+
+    var drawTile = function (ctx, x, y, tileInfo) { // 绘制一个普通块
+
+        //ctx.clearRect(x*32, y*32, 32, 32);
+        if (tileInfo == 0) return;
+
+        if (typeof(tileInfo) == typeof([][0]) || !Object.prototype.hasOwnProperty.call(tileInfo, 'idnum')) {//未定义块画红块
+            if (typeof(tileInfo) != typeof([][0]) && Object.prototype.hasOwnProperty.call(tileInfo, 'images')) {
+                ctx.drawImage(core.material.images[tileInfo.images], 0, tileInfo.y * 32, 32, 32, x * 32, y * 32, 32, 32);
+            }
+            ctx.strokeStyle = 'red';
+            var OFFSET = 2;
+            ctx.lineWidth = OFFSET;
+            ctx.strokeRect(x * 32 + OFFSET, y * 32 + OFFSET, 32 - OFFSET * 2, 32 - OFFSET * 2);
+            ctx.font = "30px Verdana";
+            ctx.textAlign = 'center';
+            ctx.fillStyle = 'red';
+            ctx.fillText("?", x * 32 + 16, y * 32 + 27);
+            return;
+        }
+        //ctx.drawImage(core.material.images[tileInfo.images], 0, tileInfo.y*32, 32, 32, x*32, y*32, 32, 32);
+    }
+    // 绘制地图 start
+    var eventCtx = document.getElementById('event').getContext("2d");
+    var fgCtx = document.getElementById('fg').getContext("2d");
+    var bgCtx = document.getElementById('bg').getContext("2d");
+    for (var y = 0; y < editor.map.length; y++)
+        for (var x = 0; x < editor.map[0].length; x++) {
+            var tileInfo = editor.map[y][x];
+            drawTile(eventCtx, x, y, tileInfo);
+            tileInfo = editor.fgmap[y][x];
+            drawTile(fgCtx, x, y, tileInfo);
+            tileInfo = editor.bgmap[y][x];
+            drawTile(bgCtx, x, y, tileInfo);
+        }
+    // 绘制地图 end
+    
+}
+
+editor.prototype.moveViewport=function(x,y){
+    core.bigmap.offsetX = core.clamp(core.bigmap.offsetX+32*x, 0, 32*core.bigmap.width-core.__PIXELS__);
+    core.bigmap.offsetY = core.clamp(core.bigmap.offsetY+32*y, 0, 32*core.bigmap.height-core.__PIXELS__);
+    core.control.updateViewport();
+    editor.buildMark();
+    editor.drawPosSelection();
+}
+
+/////////// 界面交互相关 ///////////
+
 editor.prototype.drawInitData = function (icons) {
     var ratio = 1;
-    var images = editor.material.images;
+    var images = core.material.images;
     var maxHeight = 700;
     var sumWidth = 0;
     editor.widthsX = {};
@@ -119,154 +288,110 @@ editor.prototype.drawInitData = function (icons) {
             continue;
         }
         if (img == 'terrains') {
-            editor.widthsX[img] = [img, sumWidth / 32, (sumWidth + images[img].width) / 32, images[img].height + 32]
+            editor.widthsX[img] = [img, sumWidth / 32, (sumWidth + images[img].width) / 32, images[img].height + 32*2]
             sumWidth += images[img].width;
-            maxHeight = Math.max(maxHeight, images[img].height + 32);
+            maxHeight = Math.max(maxHeight, images[img].height + 32*2);
             continue;
         }
         editor.widthsX[img] = [img, sumWidth / 32, (sumWidth + images[img].width) / 32, images[img].height];
         sumWidth += images[img].width;
         maxHeight = Math.max(maxHeight, images[img].height);
     }
+    var tilesets = images.tilesets;
+    for (var ii in core.tilesets) {
+        var img = core.tilesets[ii];
+        editor.widthsX[img] = [img, sumWidth / 32, (sumWidth + tilesets[img].width) / 32, tilesets[img].height];
+        sumWidth += tilesets[img].width;
+        maxHeight = Math.max(maxHeight, tilesets[img].height);
+    }
+
     var fullWidth = ~~(sumWidth * ratio);
     var fullHeight = ~~(maxHeight * ratio);
 
+    /*
     if (fullWidth > edata.width) edata.style.width = (edata.width = fullWidth) / ratio + 'px';
     edata.style.height = (edata.height = fullHeight) / ratio + 'px';
-    var dc = edata.getContext('2d');
+    */
+    iconImages.style.width = (iconImages.width = fullWidth) / ratio + 'px';
+    iconImages.style.height = (iconImages.height = fullHeight) / ratio + 'px';
+    var dc = {drawImage:function(){
+        var image, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight;
+        var a=Array.prototype.slice.call(arguments)
+        if(arguments.length==3){
+            // [image, dx, dy]=arguments
+            // [sx, sy, sWidth, sHeight, dWidth, dHeight]=[0,0,image.width,image.height,image.width,image.height]
+            image=a[0]
+            a=[a[0],0,0,image.width,image.height,a[1],a[2],image.width,image.height]
+        }
+        if(arguments.length==5){
+            // [image, dx, dy, dWidth, dHeight]=arguments
+            // [sx, sy, sWidth, sHeight]=[0,0,image.width,image.height]
+            image=a[0]
+            a=[a[0],0,0,image.width,image.height,a[1],a[2],a[3],a[4]]
+        }
+        if(arguments.length==9){
+            // [image, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight]=arguments
+        }
+        image=a[0];
+        sx=a[1];
+        sy=a[2];
+        sWidth=a[3];
+        sHeight=a[4];
+        dx=a[5];
+        dy=a[6];
+        dWidth=a[7];
+        dHeight=a[8];
+        //放弃对 dWidth, dHeight 的支持, 始终画一样大的
+        var dimg=new Image()
+        dimg.src = image.src;
+        dimg.style.clip=['rect(',sy,'px,',sx+sWidth,'px,',sy+sHeight,'px,',sx,'px)'].join('')
+        dimg.style.top=dy-sy+'px'
+        dimg.style.left=dx-sx+'px'
+        dimg.width=image.width/ratio
+        dimg.height=image.height/ratio
+        iconImages.appendChild(dimg)
+    }}
+    // var dc = edata.getContext('2d');
     var nowx = 0;
     var nowy = 0;
     for (var ii = 0; ii < imgNames.length; ii++) {
         var img = imgNames[ii];
         if (img == 'terrains') {
-            dc.drawImage(images[img], nowx, 32);
+            (function(image,dc,nowx){
+                if (image.complete) {
+                    dc.drawImage(image, nowx, 32);
+                    core.material.images.airwall = image;
+                    delete(editor.airwallImg);
+                } else image.onload = function () {
+                    dc.drawImage(image, nowx, 32);
+                    core.material.images.airwall = image;
+                    delete(editor.airwallImg);
+                    editor.updateMap();
+                }
+            })(editor.airwallImg,dc,nowx);
+            dc.drawImage(images[img], nowx, 32*2);
             nowx += images[img].width;
             continue;
         }
         if (img == 'autotile') {
             var autotiles = images[img];
             for (var im in autotiles) {
-                dc.drawImage(autotiles[im], nowx, nowy);
+                dc.drawImage(autotiles[im], 0, 0, 96, 128, nowx, nowy, 96, 128);
                 nowy += autotiles[im].height;
             }
+            nowx += 3 * 32;
             continue;
         }
         dc.drawImage(images[img], nowx, 0)
         nowx += images[img].width;
     }
-    bgSelect.bgs = Object.keys(icons.terrains);
-    //editor.drawMapBg();
+    for (var ii in core.tilesets) {
+        var img = core.tilesets[ii];
+        dc.drawImage(tilesets[img], nowx, 0)
+        nowx += tilesets[img].width;
+    }
     //editor.mapInit();
 }
-editor.prototype.mapInit = function () {
-    var ec = document.getElementById('event').getContext('2d');
-    ec.clearRect(0, 0, core.bigmap.width*32, core.bigmap.height*32);
-    document.getElementById('event2').getContext('2d').clearRect(0, 0, core.bigmap.width*32, core.bigmap.height*32);
-    editor.map = [];
-    var sy=editor.currentFloorData.map.length,sx=editor.currentFloorData.map[0].length;
-    for (var y = 0; y < sy; y++) {
-        editor.map[y] = [];
-        for (var x = 0; x < sx; x++) {
-            editor.map[y][x] = 0;
-        }
-    }
-    editor.currentFloorData.map = editor.map;
-    editor.currentFloorData.firstArrive = [];
-    editor.currentFloorData.events = {};
-    editor.currentFloorData.changeFloor = {};
-    editor.currentFloorData.afterBattle = {};
-    editor.currentFloorData.afterGetItem = {};
-    editor.currentFloorData.afterOpenDoor = {};
-    editor.currentFloorData.cannotMove = {};
-}
-editor.prototype.drawMapBg = function (img) {
-    var bgc = bg.getContext('2d');
-    if (!core.isset(editor.bgY) || editor.bgY == 0) {
-        editor.main.editor.drawMapBg();
-        return;
-    }
-
-    for (var ii = 0; ii < 13; ii++)
-        for (var jj = 0; jj < 13; jj++) {
-            bgc.clearRect(ii * 32, jj * 32, 32, 32);
-            bgc.drawImage(editor.material.images['terrains'], 0, 32 * (editor.bgY || 0), 32, 32, ii * 32, jj * 32, 32, 32);
-        }
-    if (img) {
-        bgc.drawImage(img, 0, 0, 416, 416);
-    }
-}
-
-editor.prototype.drawEventBlock = function () {
-    var fg=document.getElementById('efg').getContext('2d');
-
-    fg.clearRect(0, 0, 416, 416);
-    for (var i=0;i<13;i++) {
-        for (var j=0;j<13;j++) {
-            var color=[];
-            var loc=(i+core.bigmap.offsetX/32)+","+(j+core.bigmap.offsetY/32);
-            if (core.isset(editor.currentFloorData.events[loc]))
-                color.push('#FF0000');
-            if (core.isset(editor.currentFloorData.changeFloor[loc]))
-                color.push('#00FF00');
-            if (core.isset(editor.currentFloorData.afterBattle[loc]))
-                color.push('#FFFF00');
-            if (core.isset(editor.currentFloorData.afterGetItem[loc]))
-                color.push('#00FFFF');
-            if (core.isset(editor.currentFloorData.afterOpenDoor[loc]))
-                color.push('#FF00FF');
-            if (core.isset(editor.currentFloorData.cannotMove[loc]))
-                color.push('#0000FF');
-            for(var kk=0,cc;cc=color[kk];kk++){
-                fg.fillStyle = cc;
-                fg.fillRect(32*i+8*kk, 32*j+32-8, 8, 8);
-            }
-        }
-    }
-}
-
-editor.prototype.updateMap = function () {
-    var blocks = main.editor.mapIntoBlocks(editor.map.map(function (v) {
-        return v.map(function (v) {
-            return v.idnum || v || 0
-        })
-    }), {'events': {}, 'changeFloor': {}}, editor.currentFloorId);
-    core.status.thisMap.blocks = blocks;
-    main.editor.updateMap();
-
-    var drawTile = function (ctx, x, y, tileInfo) { // 绘制一个普通块
-
-        //ctx.clearRect(x*32, y*32, 32, 32);
-        if (tileInfo == 0) return;
-
-        if (typeof(tileInfo) == typeof([][0]) || !hasOwnProp(tileInfo, 'idnum')) {//未定义块画红块
-            if (typeof(tileInfo) != typeof([][0]) && hasOwnProp(tileInfo, 'images')) {
-                ctx.drawImage(editor.material.images[tileInfo.images], 0, tileInfo.y * 32, 32, 32, x * 32, y * 32, 32, 32);
-            }
-            ctx.strokeStyle = 'red';
-            var OFFSET = 2;
-            ctx.lineWidth = OFFSET;
-            ctx.strokeRect(x * 32 + OFFSET, y * 32 + OFFSET, 32 - OFFSET * 2, 32 - OFFSET * 2);
-            ctx.font = "30px Verdana";
-            ctx.textAlign = 'center'
-            ctx.fillStyle = 'red';
-            ctx.fillText("?", x * 32 + 16, y * 32 + 27);
-            return;
-        }
-        //ctx.drawImage(editor.material.images[tileInfo.images], 0, tileInfo.y*32, 32, 32, x*32, y*32, 32, 32);
-    }
-    // 绘制地图 start
-    var eventCtx = document.getElementById('event').getContext("2d");
-    for (var y = 0; y < editor.map.length; y++)
-        for (var x = 0; x < editor.map[0].length; x++) {
-            var tileInfo = editor.map[y][x];
-            if (false && isAutotile(tileInfo)) {
-                addIndexToAutotileInfo(x, y);
-                drawAutotile(eventCtx, x, y, tileInfo);
-            } else drawTile(eventCtx, x, y, tileInfo);
-        }
-    // 绘制地图 end
-    
-}
 
 editor.prototype.buildMark = function(){
     // 生成定位编号
@@ -276,14 +401,14 @@ editor.prototype.buildMark = function(){
     var mapRowMark=document.getElementById('mapRowMark');
     var buildMark = function (offsetX,offsetY) {
         var colNum = ' ';
-        for (var i = 0; i < 13; i++) {
+        for (var i = 0; i < core.__SIZE__; i++) {
             var tpl = '<td>' + (i+offsetX) + '<div class="colBlock" style="left:' + (i * 32 + 1) + 'px;"></div></td>';
             colNum += tpl;
         }
         arrColMark.innerHTML = '<tr>' + colNum + '</tr>';
         mapColMark.innerHTML = '<tr>' + colNum + '</tr>';
         var rowNum = ' ';
-        for (var i = 0; i < 13; i++) {
+        for (var i = 0; i < core.__SIZE__; i++) {
             var tpl = '<tr><td>' + (i+offsetY) + '<div class="rowBlock" style="top:' + (i * 32 + 1) + 'px;"></div></td></tr>';
             rowNum += tpl;
         }
@@ -292,29 +417,29 @@ editor.prototype.buildMark = function(){
     }
     var buildMark_mobile = function (offsetX,offsetY) {
         var colNum = ' ';
-        for (var i = 0; i < 13; i++) {
-            var tpl = '<td>' + (' '+i).slice(-2).replace(' ','&nbsp;') + '<div class="colBlock" style="left:' + (i * 96/13 ) + 'vw;"></div></td>';
+        for (var i = 0; i < core.__SIZE__; i++) {
+            var tpl = '<td>' + (' '+i).slice(-2).replace(' ','&nbsp;') + '<div class="colBlock" style="left:' + (i * 96/core.__SIZE__) + 'vw;"></div></td>';
             colNum += tpl;
         }
         arrColMark.innerHTML = '<tr>' + colNum + '</tr>';
         //mapColMark.innerHTML = '<tr>' + colNum + '</tr>';
         var rowNum = ' ';
-        for (var i = 0; i < 13; i++) {
-            var tpl = '<tr><td>' + (' '+i).slice(-2).replace(' ','&nbsp;') + '<div class="rowBlock" style="top:' + (i * 96/13 ) + 'vw;"></div></td></tr>';
+        for (var i = 0; i < core.__SIZE__; i++) {
+            var tpl = '<tr><td>' + (' '+i).slice(-2).replace(' ','&nbsp;') + '<div class="rowBlock" style="top:' + (i * 96/core.__SIZE__) + 'vw;"></div></td></tr>';
             rowNum += tpl;
         }
         arrRowMark.innerHTML = rowNum;
         //mapRowMark.innerHTML = rowNum;
         //=====
         var colNum = ' ';
-        for (var i = 0; i < 13; i++) {
-            var tpl = '<div class="coltd" style="left:' + (i * 96/13 ) + 'vw;"><div class="coltext">' + (' '+(i+offsetX)).slice(-2).replace(' ','&nbsp;') + '</div><div class="colBlock"></div></div>';
+        for (var i = 0; i < core.__SIZE__; i++) {
+            var tpl = '<div class="coltd" style="left:' + (i * 96/core.__SIZE__) + 'vw;"><div class="coltext">' + (' '+(i+offsetX)).slice(-2).replace(' ','&nbsp;') + '</div><div class="colBlock"></div></div>';
             colNum += tpl;
         }
         mapColMark.innerHTML = '<div class="coltr">' + colNum + '</div>';
         var rowNum = ' ';
-        for (var i = 0; i < 13; i++) {
-            var tpl = '<div class="rowtr"><div class="rowtd"  style="top:' + (i * 96/13 ) + 'vw;"><div class="rowtext">' + (' '+(i+offsetY)).slice(-2).replace(' ','&nbsp;') + '</div><div class="rowBlock"></div></div></div>';
+        for (var i = 0; i < core.__SIZE__; i++) {
+            var tpl = '<div class="rowtr"><div class="rowtd"  style="top:' + (i * 96/core.__SIZE__) + 'vw;"><div class="rowtext">' + (' '+(i+offsetY)).slice(-2).replace(' ','&nbsp;') + '</div><div class="rowBlock"></div></div></div>';
             rowNum += tpl;
         }
         mapRowMark.innerHTML = rowNum;
@@ -326,567 +451,37 @@ editor.prototype.buildMark = function(){
     }
 }
 
-editor.prototype.changeFloor = function (floorId, callback) {
-    editor.currentFloorData.map = editor.map.map(function (v) {
-        return v.map(function (v) {
-            return v.idnum || v || 0
-        })
-    });
-    core.changeFloor(floorId, null, core.firstData.hero.loc, null, function () {
-        editor.drawMapBg();
-        var mapArray = core.maps.save(core.status.maps, core.status.floorId);
-        editor.map = mapArray.map(function (v) {
-            return v.map(function (v) {
-                return editor.ids[[editor.indexs[parseInt(v)][0]]]
-            })
-        });
-        editor.currentFloorId = core.status.floorId;
-        editor.currentFloorData = core.floors[core.status.floorId];
-        editor.updateMap();
-        editor_mode.floor();
-        editor.drawEventBlock();
-        if (core.isset(callback)) callback();
-    });
-}
-
-editor.prototype.guid = function () {
-    return 'id_' + 'xxxxxxxx_xxxx_4xxx_yxxx_xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-        var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
-        return v.toString(16);
-    });
-}
-
-editor.prototype.HTMLescape = function (str_) {
-    return String(str_).split('').map(function (v) {
-        return '&#' + v.charCodeAt(0) + ';'
-    }).join('');
+editor.prototype.setSelectBoxFromInfo=function(thisevent){
+    var pos={x: 0, y: 0, images: "terrains"};
+    var ysize = 32;
+    if(thisevent==0){
+    } else if (thisevent.idnum==17){
+        pos.y=1;
+    } else {
+        pos.x=editor.widthsX[thisevent.images][1];
+        pos.y=thisevent.y;
+        if(thisevent.x)pos.x+=thisevent.x;
+        if(thisevent.images=='terrains')pos.y+=2;
+        ysize = thisevent.images.endsWith('48') ? 48 : 32;
+    }
+    var dataSelection = document.getElementById('dataSelection');
+    dataSelection.style.left = pos.x * 32 + 'px';
+    dataSelection.style.top = pos.y * ysize + 'px';
+    dataSelection.style.height = ysize - 6 + 'px';
+    setTimeout(function(){selectBox.isSelected(true);});
+    editor.info = JSON.parse(JSON.stringify(thisevent));
+    tip.infos(JSON.parse(JSON.stringify(thisevent)));
+    editor.pos=pos;
+    editor_mode.onmode('nextChange');
+    editor_mode.onmode('enemyitem');
 }
 
 editor.prototype.listen = function () {
-    var eui=document.getElementById('eui');
-    var uc = eui.getContext('2d');
-
-    function fillPos(pos) {
-        uc.fillStyle = '#' + ~~(Math.random() * 8) + ~~(Math.random() * 8) + ~~(Math.random() * 8);
-        uc.fillRect(pos.x * 32 + 12 - core.bigmap.offsetX, pos.y * 32 + 12 - core.bigmap.offsetY, 8, 8);
-    }//在格子内画一个随机色块
-
-    function eToLoc(e) {
-        var scrollLeft = document.documentElement.scrollLeft || document.body.scrollLeft
-        var scrollTop = document.documentElement.scrollTop || document.body.scrollTop
-        var xx=e.clientX,yy=e.clientY
-        if(editor.isMobile){xx=e.touches[0].clientX,yy=e.touches[0].clientY}
-        editor.loc = {
-            'x': scrollLeft + xx - mid.offsetLeft - mapEdit.offsetLeft,
-            'y': scrollTop + yy - mid.offsetTop - mapEdit.offsetTop,
-            'size': editor.isMobile?(32*innerWidth*0.96/416):32
-        };
-        return editor.loc;
-    }//返回可用的组件内坐标
-
-    function locToPos(loc, addViewportOffset) {
-        var offsetX=0, offsetY=0;
-        if (addViewportOffset){
-            offsetX=core.bigmap.offsetX/32;
-            offsetY=core.bigmap.offsetY/32;
-        }
-        editor.pos = {'x': ~~(loc.x / loc.size)+offsetX, 'y': ~~(loc.y / loc.size)+offsetY}
-        return editor.pos;
-    }
-
-    var holdingPath = 0;
-    var stepPostfix = null;//用于存放寻路检测的第一个点之后的后续移动
-
-    var mouseOutCheck = 2;
-
-    function clear1() {
-        if (mouseOutCheck > 1) {
-            mouseOutCheck--;
-            setTimeout(clear1, 1000);
-            return;
-        }
-        holdingPath = 0;
-        stepPostfix = [];
-        uc.clearRect(0, 0, 416, 416);
-    }//用于鼠标移出canvas时的自动清除状态
-
-    eui.oncontextmenu=function(e){e.preventDefault()}
-
-    eui.onmousedown = function (e) {
-        if (e.button==2){
-            var loc = eToLoc(e);
-            var pos = locToPos(loc,true);
-            editor.showMidMenu(e.clientX,e.clientY);
-            return;
-        }
-        if (!selectBox.isSelected) {
-            var loc = eToLoc(e);
-            var pos = locToPos(loc,true);
-            editor_mode.onmode('nextChange');
-            editor_mode.onmode('loc');
-            //editor_mode.loc();
-            //tip.whichShow = 1;
-            if(editor.isMobile)editor.showMidMenu(e.clientX,e.clientY);
-            return;
-        }
-        
-
-        holdingPath = 1;
-        mouseOutCheck = 2;
-        setTimeout(clear1);
-        e.stopPropagation();
-        uc.clearRect(0, 0, 416, 416);
-        var loc = eToLoc(e);
-        var pos = locToPos(loc,true);
-        stepPostfix = [];
-        stepPostfix.push(pos);
-        fillPos(pos);
-    }
-
-    eui.onmousemove = function (e) {
-        if (!selectBox.isSelected) {
-            //tip.whichShow = 1;
-            return;
-        }
-
-        if (holdingPath == 0) {
-            return;
-        }
-        mouseOutCheck = 2;
-        e.stopPropagation();
-        var loc = eToLoc(e);
-        var pos = locToPos(loc,true);
-        var pos0 = stepPostfix[stepPostfix.length - 1]
-        var directionDistance = [pos.y - pos0.y, pos0.x - pos.x, pos0.y - pos.y, pos.x - pos0.x]
-        var max = 0, index = 4;
-        for (var i = 0; i < 4; i++) {
-            if (directionDistance[i] > max) {
-                index = i;
-                max = directionDistance[i];
-            }
-        }
-        var pos = [{'x': 0, 'y': 1}, {'x': -1, 'y': 0}, {'x': 0, 'y': -1}, {'x': 1, 'y': 0}, false][index]
-        if (pos) {
-            pos.x += pos0.x;
-            pos.y += pos0.y;
-            stepPostfix.push(pos);
-            fillPos(pos);
-        }
-    }
-
-    eui.onmouseup = function (e) {
-        if (!selectBox.isSelected) {
-            //tip.whichShow = 1;
-            return;
-        }
-        holdingPath = 0;
-        e.stopPropagation();
-        if (stepPostfix && stepPostfix.length) {
-            preMapData = JSON.parse(JSON.stringify(editor.map));
-            if(editor.brushMod==='rectangle'){
-                var x0=stepPostfix[0].x;
-                var y0=stepPostfix[0].y;
-                var x1=stepPostfix[stepPostfix.length-1].x;
-                var y1=stepPostfix[stepPostfix.length-1].y;
-                if(x0>x1){x0^=x1;x1^=x0;x0^=x1;}//swap
-                if(y0>y1){y0^=y1;y1^=y0;y0^=y1;}//swap
-                stepPostfix=[];
-                for(var ii=x0;ii<=x1;ii++){
-                    for(var jj=y0;jj<=y1;jj++){
-                        stepPostfix.push({x:ii,y:jj})
-                    }
-                }
-            }
-            currDrawData.pos = JSON.parse(JSON.stringify(stepPostfix));
-            currDrawData.info = JSON.parse(JSON.stringify(editor.info));
-            reDo = null;
-            // console.log(stepPostfix);
-            for (var ii = 0; ii < stepPostfix.length; ii++)
-                editor.map[stepPostfix[ii].y][stepPostfix[ii].x] = editor.info;
-            // console.log(editor.map);
-            editor.updateMap();
-            holdingPath = 0;
-            stepPostfix = [];
-            uc.clearRect(0, 0, 416, 416);
-        }
-    }
-
-    /*
-    document.getElementById('mid').onkeydown = function (e) {
-        console.log(e);
-        if (e.keyCode==37) {
-            editor.moveViewport(-1, 0);
-        }
-        if (e.keyCode==38) {
-            editor.moveViewport(0, -1);
-        }
-        if (e.keyCode==39) {
-            editor.moveViewport(1, 0);
-        }
-        if (e.keyCode==40) {
-            editor.moveViewport(0, 1);
-        }
-    }
-    */
-
-    document.getElementById('mid').onmousewheel = function (e) {
-        e.preventDefault();
-        var wheel = function (direct) {
-            var index=editor.core.floorIds.indexOf(editor.currentFloorId);
-            var toId = editor.currentFloorId;
-
-            if (direct>0 && index<editor.core.floorIds.length-1)
-                toId = editor.core.floorIds[index+1];
-            else if (direct<0 && index>0)
-                toId = editor.core.floorIds[index-1];
-            else return;
-
-            editor_mode.onmode('nextChange');
-            editor_mode.onmode('floor');
-            document.getElementById('selectFloor').value = toId;
-            editor.changeFloor(toId);
-        }
-
-        try {
-            if (e.wheelDelta)
-                wheel(Math.sign(e.wheelDelta))
-            else if (e.detail)
-                wheel(Math.sign(e.detail));
-        }
-        catch (ee) {
-            console.log(ee);
-        }
-    }
-
-    var preMapData = {};
-    var currDrawData = {
-        pos: [],
-        info: {}
-    };
-    var reDo = null;
-    document.body.onkeydown = function (e) {
-        // 禁止快捷键的默认行为
-        if (e.ctrlKey && ( e.keyCode == 90 || e.keyCode == 89 ))
-            e.preventDefault();
-        //Ctrl+z 撤销上一步undo
-        if (e.keyCode == 90 && e.ctrlKey && preMapData && currDrawData.pos.length && selectBox.isSelected) {
-            editor.map = JSON.parse(JSON.stringify(preMapData));
-            editor.updateMap();
-            reDo = JSON.parse(JSON.stringify(currDrawData));
-            currDrawData = {pos: [], info: {}};
-            preMapData = null;
-        }
-        //Ctrl+y 重做一步redo
-        if (e.keyCode == 89 && e.ctrlKey && reDo && reDo.pos.length && selectBox.isSelected) {
-            preMapData = JSON.parse(JSON.stringify(editor.map));
-            for (var j = 0; j < reDo.pos.length; j++)
-                editor.map[reDo.pos[j].y][reDo.pos[j].x] = JSON.parse(JSON.stringify(reDo.info));
-
-            editor.updateMap();
-            currDrawData = JSON.parse(JSON.stringify(reDo));
-            reDo = null;
-        }
-        // PGUP和PGDOWN切换楼层
-        if (e.keyCode==33) {
-            e.preventDefault();
-            var index=editor.core.floorIds.indexOf(editor.currentFloorId);
-            if (index<editor.core.floorIds.length-1) {
-                var toId = editor.core.floorIds[index+1];
-                editor_mode.onmode('nextChange');
-                editor_mode.onmode('floor');
-                document.getElementById('selectFloor').value = toId;
-                editor.changeFloor(toId);
-            }
-        }
-        if (e.keyCode==34) {
-            e.preventDefault();
-            var index=editor.core.floorIds.indexOf(editor.currentFloorId);
-            if (index>0) {
-                var toId = editor.core.floorIds[index-1];
-                editor_mode.onmode('nextChange');
-                editor_mode.onmode('floor');
-                document.getElementById('selectFloor').value = toId;
-                editor.changeFloor(toId);
-            }
-        }
-    }
-
-    var dataSelection = document.getElementById('dataSelection');
-    edata.onmousedown = function (e) {
-        e.stopPropagation();
-        var scrollLeft = document.documentElement.scrollLeft || document.body.scrollLeft;
-        var scrollTop = document.documentElement.scrollTop || document.body.scrollTop;
-        var loc = {
-            'x': scrollLeft + e.clientX + iconLib.scrollLeft - right.offsetLeft - iconLib.offsetLeft,
-            'y': scrollTop + e.clientY + iconLib.scrollTop - right.offsetTop - iconLib.offsetTop,
-            'size': 32
-        };
-        editor.loc = loc;
-        var pos = locToPos(loc);
-        for (var spriter in editor.widthsX) {
-            if (pos.x >= editor.widthsX[spriter][1] && pos.x < editor.widthsX[spriter][2]) {
-                var ysize = spriter.indexOf('48') === -1 ? 32 : 48;
-                loc.ysize = ysize;
-                pos.y = ~~(loc.y / loc.ysize);
-                pos.x = editor.widthsX[spriter][1];
-                pos.images = editor.widthsX[spriter][0];
-                var autotiles = editor.material.images['autotile'];
-                if (pos.images == 'autotile') {
-                    var imNames = Object.keys(autotiles);
-                    if ((pos.y + 1) * ysize > editor.widthsX[spriter][3])
-                        pos.y = ~~(editor.widthsX[spriter][3] / ysize) - 4;
-                    else {
-                        for (var i = 0; i < imNames.length; i++) {
-                            if (pos.y >= 4 * i && pos.y < 4 * (i + 1)) {
-                                pos.images = imNames[i];
-                                pos.y = 4 * i;
-                            }
-                        }
-                    }
-                } else if ((pos.y + 1) * ysize > editor.widthsX[spriter][3])
-                    pos.y = ~~(editor.widthsX[spriter][3] / ysize) - 1;
-
-                selectBox.isSelected = true;
-                // console.log(pos,editor.material.images[pos.images].height)
-                dataSelection.style.left = pos.x * 32 + 'px';
-                dataSelection.style.top = pos.y * ysize + 'px';
-                dataSelection.style.height = ysize - 6 + 'px';
-
-                if (pos.x == 0 && pos.y == 0) {
-                    // editor.info={idnum:0, id:'empty','images':'清除块', 'y':0};
-                    editor.info = 0;
-                } else {
-                    if (hasOwnProp(autotiles, pos.images)) editor.info = {'images': pos.images, 'y': 0};
-                    else if (pos.images == 'terrains') editor.info = {'images': pos.images, 'y': pos.y - 1};
-                    else editor.info = {'images': pos.images, 'y': pos.y};
-
-                    for (var ii = 0; ii < editor.ids.length; ii++) {
-                        if (( editor.info.images == editor.ids[ii].images
-                                && editor.info.y == editor.ids[ii].y )
-                            || (hasOwnProp(autotiles, pos.images) && editor.info.images == editor.ids[ii].id
-                                && editor.info.y == editor.ids[ii].y)) {
-
-                            editor.info = editor.ids[ii];
-                            break;
-                        }
-                    }
-                }
-                tip.infos = JSON.parse(JSON.stringify(editor.info));
-                editor_mode.onmode('nextChange');
-                editor_mode.onmode('emenyitem');
-                //editor_mode.emenyitem();
-            }
-        }
-    }
-
-    var midMenu=document.getElementById('midMenu');
-    midMenu.oncontextmenu=function(e){e.preventDefault()}
-    editor.lastRightButtonPos=[{x:0,y:0},{x:0,y:0}];
-    editor.showMidMenu=function(x,y){
-        editor.lastRightButtonPos=JSON.parse(JSON.stringify(
-            [editor.pos,editor.lastRightButtonPos[0]]
-        ));
-        var locStr='('+editor.lastRightButtonPos[1].x+','+editor.lastRightButtonPos[1].y+')';
-        var scrollLeft = document.documentElement.scrollLeft || document.body.scrollLeft;
-        var scrollTop = document.documentElement.scrollTop || document.body.scrollTop;
-        chooseThis.children[0].innerHTML='选中此点'+'('+editor.pos.x+','+editor.pos.y+')'
-        copyLoc.children[0].innerHTML='复制事件'+locStr+'到此处';
-        moveLoc.children[0].innerHTML='交换事件'+locStr+'与此事件的位置';
-        midMenu.style='top:'+(y+scrollTop)+'px;left:'+(x+scrollLeft)+'px;';
-    }
-    editor.hideMidMenu=function(){
-        if(editor.isMobile){
-            setTimeout(function(){
-                midMenu.style='display:none';
-            },200)
-        } else {
-            midMenu.style='display:none';
-        }
-    }
-
-    var chooseThis = document.getElementById('chooseThis');
-    chooseThis.onmousedown = function(e){
-        editor.hideMidMenu();
-        e.stopPropagation();
-        selectBox.isSelected = false;
-
-        editor_mode.onmode('nextChange');
-        editor_mode.onmode('loc');
-        //editor_mode.loc();
-        //tip.whichShow = 1;
-        if(editor.isMobile)editor.showdataarea(false);
-    }
-
-    var chooseInRight = document.getElementById('chooseInRight');
-    chooseInRight.onmousedown = function(e){
-        editor.hideMidMenu();
-        e.stopPropagation();
-        var thisevent = editor.map[editor.pos.y][editor.pos.x];
-        var pos={x: 0, y: 0, images: "terrains"};
-        var ysize = 32;
-        if(thisevent==0){
-            //选中清除块
-            editor.info = 0;
-            editor.pos=pos;
-        } else {
-            var ids=editor.indexs[thisevent.idnum];
-            ids=ids[0]?ids[0]:ids;
-            editor.info=editor.ids[ids];
-            pos.x=editor.widthsX[thisevent.images][1];
-            pos.y=editor.info.y;
-            if(thisevent.images=='terrains')pos.y++;
-            ysize = thisevent.images.indexOf('48') === -1 ? 32 : 48;
-        }
-        setTimeout(function(){selectBox.isSelected = true;});
-        dataSelection.style.left = pos.x * 32 + 'px';
-        dataSelection.style.top = pos.y * ysize + 'px';
-        dataSelection.style.height = ysize - 6 + 'px';
-        tip.infos = JSON.parse(JSON.stringify(editor.info));
-        editor_mode.onmode('nextChange');
-        editor_mode.onmode('emenyitem');
-    }
-
-    var fields = Object.keys(editor.file.comment._data.floors._data.loc._data);
-
-    var copyLoc = document.getElementById('copyLoc');
-    copyLoc.onmousedown = function(e){
-        editor.hideMidMenu();
-        e.stopPropagation();
-        preMapData = null;
-        reDo = null;
-        editor_mode.onmode('');
-        var now = editor.pos;
-        var last = editor.lastRightButtonPos[1];
-        var lastevent = editor.map[last.y][last.x];
-        var lastinfo = 0;
-        if(lastevent==0){
-            lastinfo = 0;
-        } else {
-            var ids=editor.indexs[lastevent.idnum];
-            ids=ids[0]?ids[0]:ids;
-            lastinfo=editor.ids[ids];
-        }
-        editor.map[now.y][now.x]=lastinfo;
-        editor.updateMap();
-        fields.forEach(function(v){
-            editor.currentFloorData[v][now.x+','+now.y]=editor.currentFloorData[v][last.x+','+last.y]
-        })
-        editor.file.saveFloorFile(function (err) {
-            if (err) {
-                printe(err);
-                throw(err)
-            }
-            ;printf('复制事件成功');
-            editor.drawEventBlock();
-        });
-    }
-
-    var moveLoc = document.getElementById('moveLoc');
-    moveLoc.onmousedown = function(e){
-        editor.hideMidMenu();
-        e.stopPropagation();
-        preMapData = null;
-        reDo = null;
-        var thisevent = editor.map[editor.pos.y][editor.pos.x];
-        if(thisevent==0){
-            editor.info = 0;
-        } else {
-            var ids=editor.indexs[thisevent.idnum];
-            ids=ids[0]?ids[0]:ids;
-            editor.info=editor.ids[ids];
-        }
-        editor_mode.onmode('');
-        var now = editor.pos;
-        var last = editor.lastRightButtonPos[1];
-        
-        var lastevent = editor.map[last.y][last.x];
-        var lastinfo = 0;
-        if(lastevent==0){
-            lastinfo = 0;
-        } else {
-            var ids=editor.indexs[lastevent.idnum];
-            ids=ids[0]?ids[0]:ids;
-            lastinfo=editor.ids[ids];
-        }
-        editor.map[last.y][last.x]=editor.info;
-        editor.map[now.y][now.x]=lastinfo;
-        editor.updateMap();
-
-        fields.forEach(function(v){
-            var temp_atsfcytaf=editor.currentFloorData[v][now.x+','+now.y];
-            editor.currentFloorData[v][now.x+','+now.y]=editor.currentFloorData[v][last.x+','+last.y];
-            editor.currentFloorData[v][last.x+','+last.y]=temp_atsfcytaf
-        })
-        editor.file.saveFloorFile(function (err) {
-            if (err) {
-                printe(err);
-                throw(err)
-            }
-            ;printf('两位置的事件已互换');
-            editor.drawEventBlock();
-        });
-    }
-
-    var clearLoc = document.getElementById('clearLoc');
-    clearLoc.onmousedown = function(e){
-        editor.hideMidMenu();
-        e.stopPropagation();
-        preMapData = null;
-        reDo = null;
-        editor.info = 0;
-        editor_mode.onmode('');
-        var now = editor.pos;
-        editor.map[now.y][now.x]=editor.info;
-        editor.updateMap();
-        fields.forEach(function(v){
-            editor.currentFloorData[v][now.x+','+now.y]=null;
-        })
-        editor.file.saveFloorFile(function (err) {
-            if (err) {
-                printe(err);
-                throw(err)
-            }
-            ;printf('清空此点及事件成功');
-            editor.drawEventBlock();
-        });
-    }
-
-    var brushMod=document.getElementById('brushMod');
-    brushMod.onchange=function(){
-        editor.brushMod=brushMod.value;
-    }
-
-    var brushMod2=document.getElementById('brushMod2');
-    if(brushMod2)brushMod2.onchange=function(){
-        editor.brushMod=brushMod2.value;
-    }
-
-
-    editor.moveViewport=function(x,y){
-        core.bigmap.offsetX = core.clamp(core.bigmap.offsetX+32*x, 0, 32*core.bigmap.width-416);
-        core.bigmap.offsetY = core.clamp(core.bigmap.offsetY+32*y, 0, 32*core.bigmap.height-416);
-        core.control.updateViewport();
-        editor.buildMark();
-        editor.drawEventBlock();
-    }
-
-    var viewportButtons=document.getElementById('viewportButtons');
-    for(var ii=0,node;node=viewportButtons.children[ii];ii++){
-        (function(x,y){
-            node.onclick=function(){
-                editor.moveViewport(x,y);
-            }
-        })([-1,0,0,1][ii],[0,-1,1,0][ii]);
-    }
-
+    // 移动至 editor_unsorted_1.js
 }//绑定事件
 
-/* 
-editor.loc
-editor.pos
-editor.info
-始终是最后一次点击的结果
-注意editor.info可能因为点击其他地方而被清空
-*/
+editor.prototype.mobile_listen=function(){
+    // 移动至 editor_unsorted_1.js
+}
 
 editor = new editor();
\ No newline at end of file
diff --git a/_server/editor_blockly.js b/_server/editor_blockly.js
index 12805b87..b81d675a 100644
--- a/_server/editor_blockly.js
+++ b/_server/editor_blockly.js
@@ -2,14 +2,19 @@ editor_blockly = function () {
 
     var editor_blockly = {};
 
-    initscript = String.raw`
+/////////////////initscript start/////////////////////////////
+// do not use String.raw because of highlighting
+// Comment tagged templates
+// https://marketplace.visualstudio.com/items?itemName=bierner.comment-tagged-templates
+    initscript = /* js */`
 (function(){
-  var getCategory = function(name){
+  var getCategory = function(name,custom){
     for(var node of document.getElementById('toolbox').children) {
       if(node.getAttribute('name')==name) return node;
     }
     var node = document.createElement('category');
     node.setAttribute('name',name);
+    if(custom)node.setAttribute('custom',custom);
     document.getElementById('toolbox').appendChild(node);
     return node;
   }
@@ -22,17 +27,6 @@ editor_blockly = function () {
         {"type": "hide", "time": 500},
       ],'event'),
       MotaActionBlocks['changeFloor_m'].xmlText(),
-      //MotaActionFunctions.actionParser.parse({"type": "choices", "choices": [
-      //  {"text": "攻击+\${point}", "action": [
-      //    {"type": "setValue", "name": "status:atk", "value": "status:atk+\${point}"},
-      //  ]},
-      //  {"text": "防御+\${2*point}", "action": [
-      //    {"type": "setValue", "name": "status:def", "value": "status:def+\${2*point}"},
-      //  ]},
-      //  {"text": "生命+\${200*point}", "action": [
-      //    {"type": "setValue", "name": "status:hp", "value": "status:hp+\${200*point}"},
-      //  ]},
-      //]},'point'),
       MotaActionFunctions.actionParser.parse([{
         "id": "moneyShop1",
         "name": "贪婪之神", 
@@ -40,45 +34,51 @@ editor_blockly = function () {
         "textInList": "1F金币商店", 
         "use": "money",
         "need": "20+10*times*(times+1)",  
-        "text": "勇敢的武士啊，给我\${need}金币就可以：", 
+        "text": "勇敢的武士啊，给我\\\${need}金币就可以：", 
         "choices": [ 
           {"text": "生命+800", "effect": "status:hp+=800"},
           {"text": "攻击+4", "effect": "status:atk+=4"},
           {"text": "防御+4", "effect": "status:def+=4"},
           {"text": "魔防+10", "effect": "status:mdef+=10"}
         ]
+      },{
+        "id": "keyShop1",
+        "textInList": "回收钥匙商店",
+        "commonEvent": "回收钥匙商店",
+        "args": ""
       }],'shop'),
       MotaActionBlocks['afterBattle_m'].xmlText(),
       MotaActionBlocks['afterGetItem_m'].xmlText(),
       MotaActionBlocks['afterOpenDoor_m'].xmlText(),
       MotaActionBlocks['firstArrive_m'].xmlText(),
+      MotaActionBlocks['eachArrive_m'].xmlText(),
+      MotaActionBlocks['level_m'].xmlText(),
+      MotaActionBlocks['commonEvent_m'].xmlText(),
     ],
     '显示文字':[
       MotaActionBlocks['text_0_s'].xmlText(),
       MotaActionBlocks['text_1_s'].xmlText(),
-      MotaActionFunctions.actionParser.parseList({"type": "choices", "text": "是否跳过剧情", "choices": [
-        {"text": "是", "action": []},
-        {"text": "否", "action": [
-          {"type": "autoText", "text": "\\t[小妖精,fairy]双击方块进入多行编辑\\n用户无法跳过自动剧情文本,大段剧情文本请添加“是否跳过剧情”的提示\\n自动剧情文本\\n自动剧情文本\\n自动剧情文本", "time" :3000},
-          {"type": "autoText", "text": "(可以右键方块后点复制)", "time" :3000},
-        ]},
-      ]}),
+      MotaActionBlocks['comment_s'].xmlText(),
+      MotaActionBlocks['autoText_s'].xmlText(),
+      MotaActionBlocks['scrollText_s'].xmlText(),
       MotaActionBlocks['setText_s'].xmlText(),
-      MotaActionBlocks['showImage_0_s'].xmlText(),
-      MotaActionBlocks['animateImage_0_s'].xmlText(),
-      MotaActionBlocks['animateImage_1_s'].xmlText(),
+      MotaActionBlocks['showImage_s'].xmlText(),
       MotaActionBlocks['showImage_1_s'].xmlText(),
+      MotaActionBlocks['hideImage_s'].xmlText(),
+      MotaActionBlocks['showTextImage_s'].xmlText(),
+      MotaActionBlocks['moveImage_s'].xmlText(),
       MotaActionBlocks['showGif_0_s'].xmlText(),
       MotaActionBlocks['showGif_1_s'].xmlText(),
-      MotaActionBlocks['moveImage_0_s'].xmlText(),
       MotaActionBlocks['tip_s'].xmlText(),
       MotaActionBlocks['win_s'].xmlText(),
       MotaActionBlocks['lose_s'].xmlText(),
+      MotaActionBlocks['restart_s'].xmlText(),
+      MotaActionBlocks['confirm_s'].xmlText(),
       MotaActionBlocks['choices_s'].xmlText([
         '选择剑或者盾','流浪者','man',MotaActionBlocks['choicesContext'].xmlText([
-          '剑',MotaActionFunctions.actionParser.parseList([{"type": "openDoor", "loc": [3,3]}]),
+          '剑','','',null,MotaActionFunctions.actionParser.parseList([{"type": "openDoor", "loc": [3,3]}]),
           MotaActionBlocks['choicesContext'].xmlText([
-            '盾',MotaActionFunctions.actionParser.parseList([{"type": "openDoor", "loc": [9,3]}]),
+            '盾','','',null,MotaActionFunctions.actionParser.parseList([{"type": "openDoor", "loc": [9,3]}]),
           ])
         ])
       ]),
@@ -87,7 +87,15 @@ editor_blockly = function () {
       MotaActionBlocks['setValue_s'].xmlText([
         MotaActionBlocks['idString_1_e'].xmlText(['status','hp'])
       ]),
+      MotaActionBlocks['addValue_s'].xmlText([
+        MotaActionBlocks['idString_1_e'].xmlText(['status','hp'])
+      ]),
+      MotaActionBlocks['setFloor_s'].xmlText(),
+      MotaActionBlocks['setGlobalAttribute_s'].xmlText(),
+      MotaActionBlocks['setGlobalValue_s'].xmlText(),
+      MotaActionBlocks['setGlobalFlag_s'].xmlText(),
       MotaActionBlocks['input_s'].xmlText(),
+      MotaActionBlocks['input2_s'].xmlText(),
       MotaActionBlocks['update_s'].xmlText(),
       MotaActionBlocks['updateEnemys_s'].xmlText(),
       MotaActionBlocks['moveHero_s'].xmlText(),
@@ -96,49 +104,84 @@ editor_blockly = function () {
       MotaActionBlocks['changePos_0_s'].xmlText(),
       MotaActionBlocks['changePos_1_s'].xmlText(),
       MotaActionBlocks['battle_s'].xmlText(),
-      MotaActionBlocks['openDoor_s'].xmlText(),
+      MotaActionBlocks['useItem_s'].xmlText(),
       MotaActionBlocks['openShop_s'].xmlText(),
-      MotaActionBlocks['setBlock_s'].xmlText(),
+      MotaActionBlocks['disableShop_s'].xmlText(),
       MotaActionBlocks['setHeroIcon_s'].xmlText(),
       MotaActionBlocks['follow_s'].xmlText(),
       MotaActionBlocks['unfollow_s'].xmlText(),
     ],
+    '地图处理':[
+      MotaActionBlocks['battle_1_s'].xmlText(),
+      MotaActionBlocks['openDoor_s'].xmlText(),
+      MotaActionBlocks['closeDoor_s'].xmlText(),
+      MotaActionBlocks['show_s'].xmlText(),
+      MotaActionBlocks['hide_s'].xmlText(),
+      MotaActionBlocks['setBlock_s'].xmlText(),
+      MotaActionBlocks['move_s'].xmlText(),
+      MotaActionBlocks['jump_s'].xmlText(),
+      MotaActionBlocks['showBgFgMap_s'].xmlText(),
+      MotaActionBlocks['hideBgFgMap_s'].xmlText(),
+      MotaActionBlocks['setBgFgBlock_s'].xmlText(),
+      MotaActionBlocks['showFloorImg_s'].xmlText(),
+      MotaActionBlocks['hideFloorImg_s'].xmlText(),
+    ],
     '事件控制':[
       MotaActionBlocks['if_s'].xmlText(),
+      MotaActionBlocks['if_1_s'].xmlText(),
+      MotaActionFunctions.actionParser.parseList({"type": "switch", "condition": "判别值", "caseList": [
+        {"action": [{"type": "comment", "text": "当判别值是值的场合执行此事件"}]},
+        {"action": [], "nobreak": true},
+        {"case": "default", "action": [{"type": "comment", "text": "当没有符合的值的场合执行default事件"}]},
+      ]}),
       MotaActionBlocks['while_s'].xmlText(),
+      MotaActionBlocks['dowhile_s'].xmlText(),
       MotaActionBlocks['break_s'].xmlText(),
       MotaActionBlocks['continue_s'].xmlText(),
       MotaActionBlocks['revisit_s'].xmlText(),
       MotaActionBlocks['exit_s'].xmlText(),
-      MotaActionBlocks['show_s'].xmlText(),
-      MotaActionBlocks['hide_s'].xmlText(),
       MotaActionBlocks['trigger_s'].xmlText(),
-      MotaActionBlocks['move_s'].xmlText(),
-      MotaActionBlocks['jump_s'].xmlText(),
-      MotaActionBlocks['disableShop_s'].xmlText(),
+      MotaActionBlocks['insert_1_s'].xmlText(),
+      MotaActionBlocks['insert_2_s'].xmlText(),
     ],
     '特效/声音':[
       MotaActionBlocks['sleep_s'].xmlText(),
       MotaActionBlocks['wait_s'].xmlText(),
-      MotaActionBlocks['viberate_s'].xmlText(),
+      MotaActionBlocks['waitAsync_s'].xmlText(),
+      MotaActionBlocks['vibrate_s'].xmlText(),
       MotaActionBlocks['animate_s'].xmlText(),
-      MotaActionBlocks['setFg_0_s'].xmlText(),
-      MotaActionBlocks['setFg_1_s'].xmlText(),
+      MotaActionBlocks['showStatusBar_s'].xmlText(),
+      MotaActionBlocks['hideStatusBar_s'].xmlText(),
+      MotaActionBlocks['setCurtain_0_s'].xmlText(),
+      MotaActionBlocks['setCurtain_1_s'].xmlText(),
+      MotaActionBlocks['screenFlash_s'].xmlText(),
       MotaActionBlocks['setWeather_s'].xmlText(),
       MotaActionBlocks['playBgm_s'].xmlText(),
       MotaActionBlocks['pauseBgm_s'].xmlText(),
       MotaActionBlocks['resumeBgm_s'].xmlText(),
+      MotaActionBlocks['loadBgm_s'].xmlText(),
+      MotaActionBlocks['freeBgm_s'].xmlText(),
       MotaActionBlocks['playSound_s'].xmlText(),
+      MotaActionBlocks['stopSound_s'].xmlText(),
       MotaActionBlocks['setVolume_s'].xmlText(),
+      MotaActionBlocks['callBook_s'].xmlText(),
+      MotaActionBlocks['callSave_s'].xmlText(),
+      MotaActionBlocks['autoSave_s'].xmlText(),
+      MotaActionBlocks['callLoad_s'].xmlText(),
     ],
     '原生脚本':[
       MotaActionBlocks['function_s'].xmlText(),
+      MotaActionBlocks['unknown_s'].xmlText(),
     ],
     '值块':[
       MotaActionBlocks['setValue_s'].xmlText([
         MotaActionBlocks['idString_1_e'].xmlText(['status','hp'])
       ]),
+      MotaActionBlocks['addValue_s'].xmlText([
+        MotaActionBlocks['idString_1_e'].xmlText(['status','hp'])
+      ]),
       MotaActionBlocks['expression_arithmetic_0'].xmlText(),
+      MotaActionBlocks['evFlag_e'].xmlText(),
       MotaActionBlocks['negate_e'].xmlText(),
       MotaActionBlocks['bool_e'].xmlText(),
       MotaActionBlocks['idString_e'].xmlText(),
@@ -150,34 +193,34 @@ editor_blockly = function () {
       '<label text="检测音乐如果没有开启则系统提示开启"></label>',
       MotaActionFunctions.actionParser.parseList({"type": "if", "condition": "!core.musicStatus.bgmStatus",
         "true": [
-          "\t[系统提示]你当前音乐处于关闭状态，本塔开音乐游戏效果更佳"
+          "\\t[系统提示]你当前音乐处于关闭状态，本塔开音乐游戏效果更佳"
         ],
         "false": []
       }),
       '<label text="商店购买属性/钥匙"></label>',
       MotaActionFunctions.actionParser.parse([
-        {"type": "choices", "text": "\t[老人,man]少年，你需要钥匙吗？\n我这里有大把的！",
+        {"type": "choices", "text": "\\t[老人,man]少年，你需要钥匙吗？\\n我这里有大把的！",
         "choices": [
-            {"text": "黄钥匙（\${9+flag:shop_times}金币）", "action": [
+            {"text": "黄钥匙（\\\${9+flag:shop_times}金币）", "color": [255,255,0,1], "action": [
                 {"type": "if", "condition": "status:money>=9+flag:shop_times",
                     "true": [
-                        {"type": "setValue", "name": "status:money", "value": "status:money-(9+flag:shop_times)"},
-                        {"type": "setValue", "name": "item:yellowKey", "value": "item:yellowKey+1"},
+                        {"type": "addValue", "name": "status:money", "value": "-(9+flag:shop_times)"},
+                        {"type": "addValue", "name": "item:yellowKey", "value": "1"},
                     ],
                     "false": [
-                        "\t[老人,man]你的金钱不足！",
+                        "\\t[老人,man]你的金钱不足！",
                         {"type": "revisit"}
                     ]
                 }
             ]},
-            {"text": "蓝钥匙（\${18+2*flag:shop_times}金币）", "action": [
+            {"text": "蓝钥匙（\\\${18+2*flag:shop_times}金币）", "color": [0,0,255,1], "action": [
             ]},
             {"text": "离开", "action": [
                 {"type": "exit"}
             ]}
         ]
     },
-    {"type": "setValue", "name": "flag:shop_times", "value": "flag:shop_times+1"},
+    {"type": "addValue", "name": "flag:shop_times", "value": "1"},
     {"type": "revisit"}
       ], 'event'),  
       '<label text="战前剧情"></label>',
@@ -200,7 +243,7 @@ editor_blockly = function () {
       ],'afterBattle'),
       '<label text="打怪开门"></label>',
       MotaActionFunctions.actionParser.parse([
-        {"type": "setValue", "name": "flag:__door__", "value": "flag:__door__+1"},
+        {"type": "addValue", "name": "flag:__door__", "value": "1"},
         {"type": "if", "condition": "flag:__door__==2", 
           "true": [
             {"type": "openDoor", "loc": [10,5]}
@@ -227,15 +270,19 @@ editor_blockly = function () {
           }
         ]
       },'event'),
-
     ],
+    '最近使用事件':[
+      '<label text="此处只是占位符,实际定义在editor_blockly.searchBlockCategoryCallback中"></label>',
+    ]
   }
   var toolboxgap = '<sep gap="5"></sep>'
   //xml_text = MotaActionFunctions.actionParser.parse(obj,type||'event')
   //MotaActionBlocks['idString_e'].xmlText()
 
   for (var name in toolboxObj){
-    getCategory(name).innerHTML = toolboxObj[name].join(toolboxgap);
+    var custom = null;
+    if(name=='最近使用事件')custom='searchBlockCategory';
+    getCategory(name,custom).innerHTML = toolboxObj[name].join(toolboxgap);
   }
 
 var blocklyArea = document.getElementById('blocklyArea');
@@ -253,6 +300,23 @@ var workspace = Blockly.inject(blocklyDiv,{
   },
   trashcan: false,
 });
+
+editor_blockly.searchBlockCategoryCallback = function(workspace) {
+  var xmlList = [];
+  var labels = editor_blockly.searchBlock();
+  for (var i = 0; i < labels.length; i++) {
+    var blockText = '<xml>' +
+        MotaActionBlocks[labels[i]].xmlText() +
+        '</xml>';
+    var block = Blockly.Xml.textToDom(blockText).firstChild;
+    block.setAttribute("gap", 5);
+    xmlList.push(block);
+  }
+  return xmlList;
+};
+
+workspace.registerToolboxCategoryCallback(
+  'searchBlockCategory', editor_blockly.searchBlockCategoryCallback);
  
 var onresize = function(e) {
   blocklyDiv.style.width = blocklyArea.offsetWidth + 'px';
@@ -268,13 +332,17 @@ document.getElementById('blocklyDiv').onmousewheel = function(e){
   //console.log(e);
   e.preventDefault();
   var hvScroll = e.shiftKey?'hScroll':'vScroll';
-  workspace.scrollbar[hvScroll].handlePosition_+=( ((e.deltaY||0)+(e.detail||0)) >0?20:-20);
+  var mousewheelOffsetValue=20/380*workspace.scrollbar[hvScroll].handleLength_*3;
+  workspace.scrollbar[hvScroll].handlePosition_+=( ((e.deltaY||0)+(e.detail||0)) >0?mousewheelOffsetValue:-mousewheelOffsetValue);
   workspace.scrollbar[hvScroll].onScroll_();
   workspace.setScale(workspace.scale);
 }
 
-  var doubleClickCheck=[[0,'abc']];
-  function omitedcheckUpdateFunction(event) {
+var doubleClickCheck=[[0,'abc']];
+function omitedcheckUpdateFunction(event) {
+  if(event.type==='create'){
+    editor_blockly.addIntoLastUsedType(event.blockId);
+  }
   if(event.type==='ui'){
     var newClick = [new Date().getTime(),event.blockId];
     var lastClick = doubleClickCheck.shift();
@@ -298,7 +366,7 @@ document.getElementById('blocklyDiv').onmousewheel = function(e){
     }
   }
   try {
-    var code = Blockly.JavaScript.workspaceToCode(workspace);
+    var code = Blockly.JavaScript.workspaceToCode(workspace).replace(/\\\\i/g, '\\\\\\\\i');
     codeAreaHL.setValue(code);
   } catch (error) {
     codeAreaHL.setValue(String(error));
@@ -320,8 +388,57 @@ document.getElementById('blocklyDiv').onmousewheel = function(e){
   MotaActionFunctions.workspace = function(){
     return editor_blockly.workspace;
   }
+
+  // 因为在editor_blockly.parse里已经HTML转义过一次了,所以这里要覆盖掉以避免在注释中出现&lt;等
+  MotaActionFunctions.xmlText = function (ruleName,inputs,isShadow,comment) {
+    var rule = MotaActionBlocks[ruleName];
+    var blocktext = isShadow?'shadow':'block';
+    var xmlText = [];
+    xmlText.push('<'+blocktext+' type="'+ruleName+'">');
+    if(!inputs)inputs=[];
+    for (var ii=0,inputType;inputType=rule.argsType[ii];ii++) {
+      var input = inputs[ii];
+      var _input = '';
+      var noinput = (input===null || input===undefined);
+      if(noinput && inputType==='field') continue;
+      if(noinput) input = '';
+      if(inputType!=='field') {
+        var subList = false;
+        var subrulename = rule.args[ii];
+        subrulename=subrulename.split('_').slice(0,-1).join('_');
+        var subrule = MotaActionBlocks[subrulename];
+        if (subrule instanceof Array) {
+          subrulename=subrule[subrule.length-1];
+          subrule = MotaActionBlocks[subrulename];
+          subList = true;
+        }
+        _input = subrule.xmlText([],true);
+        if(noinput && !subList && !isShadow) {
+          //无输入的默认行为是: 如果语句块的备选方块只有一个,直接代入方块
+          input = subrule.xmlText();
+        }
+      }
+      xmlText.push('<'+inputType+' name="'+rule.args[ii]+'">');
+      xmlText.push(_input+input);
+      xmlText.push('</'+inputType+'>');
+    }
+    if(comment){
+      xmlText.push('<comment>');
+      xmlText.push(comment);
+      xmlText.push('</comment>');
+    }
+    var next = inputs[rule.args.length];
+    if (next) {//next
+      xmlText.push('<next>');
+      xmlText.push(next);
+      xmlText.push('</next>');
+    }
+    xmlText.push('</'+blocktext+'>');
+    return xmlText.join('');
+  }
 })();
 `;
+/////////////////initscript end  /////////////////////////////
 
     var input_ = '';
     editor_blockly.runOne = function () {
@@ -347,13 +464,13 @@ document.getElementById('blocklyDiv').onmousewheel = function(e){
     xhr.onreadystatechange = function () {
         if (xhr.readyState != 4) return;
         if (xhr.status != 200) {
-            alert("无法在file://下加载");
+            alert("图块描述文件加载失败, 请在'启动服务.exe'中打开编辑器");
             return;
         }
         input_ = xhr.responseText;
         editor_blockly.runOne();
     }
-    xhr.open('GET', '_server/blockly/MotaAction.g4', true);
+    xhr.open('GET', '_server/MotaAction.g4', true);
     xhr.send(null);
 
     codeAreaHL = CodeMirror.fromTextArea(document.getElementById("codeArea"), {
@@ -392,7 +509,8 @@ document.getElementById('blocklyDiv').onmousewheel = function(e){
         MotaActionFunctions.parse(
             eval('obj=' + codeAreaHL.getValue().replace(/[<>&]/g, function (c) {
                 return {'<': '&lt;', '>': '&gt;', '&': '&amp;'}[c];
-            })),
+            }).replace(/\\r/g, '\\\\r').replace(/\\f/g, '\\\\f')
+                .replace(/\\i/,'\\\\i')),
             document.getElementById('entryType').value
         );
     }
@@ -416,7 +534,7 @@ document.getElementById('blocklyDiv').onmousewheel = function(e){
 
     var blocklyWidgetDiv = document.getElementsByClassName('blocklyWidgetDiv');
     editor_blockly.show = function () {
-        if (typeof(selectBox) !== typeof(undefined)) selectBox.isSelected = false;
+        if (typeof(selectBox) !== typeof(undefined)) selectBox.isSelected(false);
         document.getElementById('left6').style = '';
         for (var ii = 0, node; node = blocklyWidgetDiv[ii]; ii++) {
             node.style.zIndex = 201;
@@ -466,6 +584,7 @@ document.getElementById('blocklyDiv').onmousewheel = function(e){
             return;
         }
         var code = Blockly.JavaScript.workspaceToCode(editor_blockly.workspace);
+        code = code.replace(/\\i/g, '\\\\i');
         eval('var obj=' + code);
         setvalue(JSON.stringify(obj));
     }
@@ -477,9 +596,13 @@ document.getElementById('blocklyDiv').onmousewheel = function(e){
             'text_0_s': 'EvalString_0',
             'text_1_s': 'EvalString_2',
             'autoText_s': 'EvalString_2',
+            'scrollText_s': 'EvalString_0',
+            'comment_s': 'EvalString_0',
             'choices_s': 'EvalString_0',
+            'showTextImage_s': 'EvalString_0',
             'function_s': 'RawEvalString_0',
             'shopsub': 'EvalString_3',
+            'confirm_s': 'EvalString_0',
         }
         var f = b ? textStringDict[b.type] : null;
         if (f) {
@@ -493,6 +616,98 @@ document.getElementById('blocklyDiv').onmousewheel = function(e){
         }
     }
 
+    editor_blockly.lastUsedType=[
+        'text_0_s',
+        'comment_s',
+        'show_s',
+        'hide_s',
+        'setValue_s',
+        'if_s',
+        'battle_s',
+        'openDoor_s',
+        'choices_s',
+        'setText_s',
+        'exit_s',
+        'revisit_s',
+        'sleep_s',
+        'setBlock_s',
+        'insert_1_s'
+    ]; // 最常用的15个图块
+    editor_blockly.lastUsedTypeNum=15;
+
+    editor_blockly.addIntoLastUsedType=function(blockId) {
+        var b = editor_blockly.workspace.getBlockById(blockId);
+        if(!b)return;
+        var blockType = b.type;
+        if(!blockType || blockType.indexOf("_s")!==blockType.length-2 || blockType==='pass_s')return;
+        editor_blockly.lastUsedType = editor_blockly.lastUsedType.filter(function (v) {return v!==blockType;});
+        if (editor_blockly.lastUsedType.length >= editor_blockly.lastUsedTypeNum)
+            editor_blockly.lastUsedType.pop();
+        editor_blockly.lastUsedType.unshift(blockType);
+
+        document.getElementById("searchBlock").value='';
+    }
+
+    // Index from 1 - 9
+    editor_blockly.openToolbox = function(index) {
+        // var element = document.getElementById(':'+index);
+        // if (element == null || element.getAttribute("aria-selected")=="true") return;
+        // element.click();
+        editor_blockly.workspace.toolbox_.tree_.setSelectedItem(editor_blockly.workspace.toolbox_.tree_.children_[index-1]);
+    }
+    editor_blockly.reopenToolbox = function(index) {
+        // var element = document.getElementById(':'+index);
+        // if (element == null) return;
+        // if (element.getAttribute("aria-selected")=="true") element.click();
+        // element.click();
+        editor_blockly.workspace.toolbox_.tree_.setSelectedItem(editor_blockly.workspace.toolbox_.tree_.children_[index-1]);
+        editor_blockly.workspace.getFlyout_().show(editor_blockly.workspace.toolbox_.tree_.children_[index-1].blocks);
+    }
+
+    editor_blockly.closeToolbox = function() {
+        /*
+        for (var i=1; i<=10; i++) {
+            var element = document.getElementById(':'+i);
+            if (element && element.getAttribute("aria-selected")=="true") {
+                element.click();
+                return;
+            }
+        }
+        */
+        editor_blockly.workspace.toolbox_.clearSelection();
+    }
+
+    var searchInput = document.getElementById("searchBlock");
+    searchInput.onfocus = function () {
+        editor_blockly.reopenToolbox(10);
+    }
+
+    searchInput.oninput = function () {
+        editor_blockly.reopenToolbox(10);
+    }
+
+    editor_blockly.searchBlock = function (value) {
+        if (value == null) value = searchInput.value;
+        value = value.toLowerCase();
+        if (value == '') return editor_blockly.lastUsedType;
+        var results = [];
+        for (var name in MotaActionBlocks) {
+            if (typeof name !== 'string' || name.indexOf("_s") !== name.length-2) continue;
+            var block = MotaActionBlocks[name];
+            if(block && block.json) {
+                if ((block.json.type||"").toLowerCase().indexOf(value)>=0
+                    || (block.json.message0||"").toLowerCase().indexOf(value)>=0
+                    || (block.json.tooltip||"").toLowerCase().indexOf(value)>=0) {
+                    results.push(name);
+                    if (results.length>=editor_blockly.lastUsedTypeNum)
+                        break;
+                }
+            }
+        }
+
+        return results.length == 0 ? editor_blockly.lastUsedType : results;
+    }
+
     return editor_blockly;
 }
 //editor_blockly=editor_blockly();
\ No newline at end of file
diff --git a/_server/editor_file.js b/_server/editor_file.js
index 4f534d2a..9b9f0418 100644
--- a/_server/editor_file.js
+++ b/_server/editor_file.js
@@ -1,881 +1,37 @@
-editor_file = function (editor, callback) {
+editor_file_wrapper = function (editor) {
+    editor_file_proto = function () {
 
-    var editor_file = {};
-
-
-    var commentjs = {
-        'comment': 'comment',
-        'data.comment': 'dataComment',
-        'functions.comment': 'functionsComment',
-    }
-    for (var key in commentjs) {
-        (function (key) {
-            var value = commentjs[key];
-            var script = document.createElement('script');
-            if (window.location.href.indexOf('_server') !== -1)
-                script.src = key + '.js';
-            else
-                script.src = '_server/' + key + '.js';
-            document.body.appendChild(script);
-            script.onload = function () {
-                editor_file[value] = eval(key.replace('.', '_') + '_c456ea59_6018_45ef_8bcc_211a24c627dc');
-                var loaded = Boolean(callback);
-                for (var key_ in commentjs) {
-                    loaded = loaded && editor_file[commentjs[key_]]
-                }
-                if (loaded) callback();
-            }
-        })(key);
     }
 
-
-    editor_file.getFloorFileList = function (callback) {
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
+    // 这个函数之后挪到editor.table?
+    editor_file_proto.prototype.loadCommentjs=function(callback){
+        var commentjs = {
+            'comment': 'comment',
+            'data.comment': 'dataComment',
+            'functions.comment': 'functionsComment',
+            'events.comment': 'eventsComment',
+            'plugins.comment': 'pluginsComment',
         }
-        ;
-        /* var fs = editor.fs;
-        fs.readdir('project/floors',function(err, data){
-          callback([data,err]);
-        }); */
-        callback([editor.core.floorIds, null]);
-    }
-    //callback([Array<String>,err:String])
-    editor_file.loadFloorFile = function (filename, callback) {
-        //filename不含'/'不含'.js'
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
-        }
-        ;
-        /* var fs = editor.fs;
-        fs.readFile('project/floors/'+filename+'.js','utf-8',function(err, data){
-          if (err!=null){callback(err);return;}
-          data=data.split('=');
-          data=[data[0],data.slice(1).join('=')];
-          var varnameId = data[0].split('.').slice(-1)[0].trim();
-          var filenameId = filename.split('/').slice(-1)[0].split('\\').slice(-1)[0];
-          eval('b3917d1d_71c2_41f2_a8aa_481b215ffb99='+data[1]);
-          var floorData = b3917d1d_71c2_41f2_a8aa_481b215ffb99;
-          delete(b3917d1d_71c2_41f2_a8aa_481b215ffb99);
-          var floorId = floorData.floorId;
-          if (varnameId!=filenameId || filenameId!=floorId){
-            callback('文件名,第一行的变量名以及floorId不一致');
-            return;
-          }
-          editor.currentFloorId = floorId;
-          editor.currentFloorData = floorData;
-          callback(null)
-        }); */
-        editor.currentFloorId = editor.core.status.floorId;
-        editor.currentFloorData = editor.core.floors[editor.currentFloorId];
-    }
-    //callback(err:String)
-    editor_file.saveFloorFile = function (callback) {
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
-        }
-        ;
-        /* if (!isset(editor.currentFloorId) || !isset(editor.currentFloorData)) {
-          callback('未选中文件或无数据');
-        } */
-        var filename = 'project/floors/' + editor.currentFloorId + '.js';
-        var datastr = ['main.floors.', editor.currentFloorId, '=\n{'];
-        if (editor.currentFloorData.map == 'new') {
-            /*
-            editor.currentFloorData.map = editor.map.map(function (v) {
-                return v.map(function () {
-                    return 0
-                })
-            });
-            */
-            var width = parseInt(document.getElementById('newMapWidth').value);
-            var height = parseInt(document.getElementById('newMapHeight').value);
-            var row = [];
-            for (var i=0;i<width;i++) row.push(0);
-            editor.currentFloorData.map = [];
-            for (var i=0;i<height;i++) editor.currentFloorData.map.push(row);
-        }
-        else
-            editor.currentFloorData.map = editor.map.map(function (v) {
-                return v.map(function (v) {
-                    return v.idnum || v || 0
-                })
-            });
-        for (var ii in editor.currentFloorData)
-            if (editor.currentFloorData.hasOwnProperty(ii)) {
-                if (ii == 'map')
-                    datastr = datastr.concat(['\n"', ii, '": [\n', formatMap(editor.currentFloorData[ii]), '\n],']);
+        for (var key in commentjs) {
+            (function (key) {
+                var value = commentjs[key];
+                var script = document.createElement('script');
+                if (window.location.href.indexOf('_server') !== -1)
+                    script.src = key + '.js';
                 else
-                    datastr = datastr.concat(['\n"', ii, '": ', JSON.stringify(editor.currentFloorData[ii], null, 4), ',']);
-            }
-        datastr = datastr.concat(['\n}']);
-        datastr = datastr.join('');
-        alertWhenCompress();
-        fs.writeFile(filename, encode(datastr), 'base64', function (err, data) {
-            callback(err);
-        });
-    }
-    //callback(err:String)
-    editor_file.saveNewFile = function (saveFilename, callback) {
-        //saveAsFilename不含'/'不含'.js'
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
-        };
-        var currData=editor.currentFloorData;
-        var saveStatus = document.getElementById('newMapStatus').checked;
-        editor.currentFloorData = {
-            floorId: saveFilename,
-            title: saveStatus?currData.title:"新建楼层",
-            name: saveStatus?currData.name:"0",
-            width: parseInt(document.getElementById('newMapWidth').value),
-            height: parseInt(document.getElementById('newMapHeight').value),
-            canFlyTo: saveStatus?currData.canFlyTo:true,
-            canUseQuickShop: saveStatus?currData.canUseQuickShop:true,
-            cannotViewMap: saveStatus?currData.cannotViewMap:false,
-            images: [],
-            item_ratio: saveStatus?currData.item_ratio:1,
-            defaultGround: saveStatus?currData.defaultGround:"ground",
-            bgm: saveStatus?currData.bgm:null,
-            upFloor: null,
-            downFloor: null,
-            color: saveStatus?currData.color:null,
-            weather: saveStatus?currData.weather:null,
-            firstArrive: [],
-            events: {},
-            changeFloor: {},
-            afterBattle: {},
-            afterGetItem: {},
-            afterOpenDoor: {},
-            cannotMove: {}
-        };
-        Object.keys(editor.currentFloorData).forEach(function (t) {
-            if (!core.isset(editor.currentFloorData[t]))
-                delete editor.currentFloorData[t];
-        })
-        editor.currentFloorData.map = "new";
-        editor.currentFloorId = saveFilename;
-        editor_file.saveFloorFile(callback);
-    }
-    //callback(err:String)
-
-    ////////////////////////////////////////////////////////////////////
-
-    editor_file.autoRegister = function (info, callback) {
-
-        var iconActions = [];
-        var mapActions = [];
-        var templateActions = [];
-
-        var image = info.images;
-
-        if (image=='autotile') {
-            callback('不能对自动元件进行自动注册！');
-            return;
-        }
-        var c=image.toUpperCase().charAt(0);
-
-        // terrains id
-        var terrainsId = [];
-        Object.keys(core.material.icons.terrains).forEach(function (id) {
-            terrainsId[core.material.icons.terrains[id]]=id;
-        })
-
-        var allIds = [];
-        editor.ids.forEach(function (v) {
-            if (v.images==image) {
-                allIds[v.y]=true;
-            }
-        })
-
-        var per_height = image.indexOf('48')>=0?48:32;
-
-        var idnum=300;
-        for (var y=0; y<editor.widthsX[image][3]/per_height;y++) {
-            if (allIds[y]) continue;
-            while (editor.core.maps.blocksInfo[idnum]) idnum++;
-
-            // get id num
-            var id = c+idnum;
-
-            if (image=='terrains' && core.isset(terrainsId[y])) {
-                id=terrainsId[y];
-            }
-            else {
-                iconActions.push(["add", "['" + image + "']['" + id + "']", y])
-            }
-            mapActions.push(["add", "['" + idnum + "']", {'cls': image, 'id': id}])
-            if (image=='items')
-                templateActions.push(["add", "['items']['" + id + "']", editor_file.comment._data.items_template]);
-            else if (image.indexOf('enemy')==0)
-                templateActions.push(["add", "['" + id + "']", editor_file.comment._data.enemys_template]);
-            idnum++;
-        }
-
-        if (mapActions.length==0) {
-            callback("没有要注册的项！");
-            return;
-        }
-
-        var templist = [];
-        var tempcallback = function (err) {
-            templist.push(err);
-            if (templist.length == 3) {
-                if (templist[0] != null || templist[1] != null || templist[2] != null)
-                    callback((templist[0] || '') + '\n' + (templist[1] || '') + '\n' + (templist[2] || ''));
-                //这里如果一个成功一个失败会出严重bug
-                else
-                    callback(null);
-            }
-        }
-        if (iconActions.length>0)
-            saveSetting('icons', iconActions, tempcallback);
-        else tempcallback(null);
-
-        saveSetting('maps', mapActions, tempcallback);
-
-        if (image=='items')
-            saveSetting('items', templateActions, tempcallback);
-        else if (image.indexOf('enemy')==0)
-            saveSetting('enemys', templateActions, tempcallback);
-        else tempcallback(null);
-    }
-
-    editor_file.changeIdAndIdnum = function (id, idnum, info, callback) {
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
-        }
-        ;
-        //检查maps中是否有重复的idnum或id
-        var change = -1;
-        for (var ii in editor.core.maps.blocksInfo) {
-            if (ii == idnum) {
-                //暂时只允许创建新的不允许修改已有的
-                //if (info.idnum==idnum){change=ii;break;}//修改id
-                callback('idnum重复了');
-                return;
-            }
-            if (editor.core.maps.blocksInfo[ii].id == id) {
-                //if (info.id==id){change=ii;break;}//修改idnum
-                callback('id重复了');
-                return;
-            }
-        }
-        /*
-        if (change!=-1 && change!=idnum){//修改idnum
-          editor.core.maps.blocksInfo[idnum] = editor.core.maps.blocksInfo[change];
-          delete(editor.core.maps.blocksInfo[change]);
-        } else if (change==idnum) {//修改id
-          var oldid = editor.core.maps.blocksInfo[idnum].id;
-          editor.core.maps.blocksInfo[idnum].id = id;
-          for(var ii in editor.core.icons.icons){
-            if (ii.hasOwnProperty(oldid)){
-              ii[id]=ii[oldid];
-              delete(ii[oldid]);
-            }
-          }
-        } else {//创建新的
-          editor.core.maps.blocksInfo[idnum]={'cls': info.images, 'id':id};
-          editor.core.icons.icons[info.images][id]=info.y;
-        }
-        */
-        var templist = [];
-        var tempcallback = function (err) {
-            templist.push(err);
-            if (templist.length == 2) {
-                if (templist[0] != null || templist[1] != null)
-                    callback((templist[0] || '') + '\n' + (templist[1] || ''));
-                //这里如果一个成功一个失败会出严重bug
-                else
-                    callback(null);
-            }
-        }
-        saveSetting('maps', [["add", "['" + idnum + "']", {'cls': info.images, 'id': id}]], tempcallback);
-        saveSetting('icons', [["add", "['" + info.images + "']['" + id + "']", info.y]], tempcallback);
-        if (info.images === 'items') {
-            saveSetting('items', [["add", "['items']['" + id + "']", editor_file.comment._data.items_template]], function (err) {
-                if (err) {
-                    printe(err);
-                    throw(err)
+                    script.src = '_server/table/' + key + '.js';
+                document.body.appendChild(script);
+                script.onload = function () {
+                    editor.file[value] = eval(key.replace('.', '_') + '_c456ea59_6018_45ef_8bcc_211a24c627dc');
+                    var loaded = Boolean(callback);
+                    for (var key_ in commentjs) {
+                        loaded = loaded && editor.file[commentjs[key_]]
+                    }
+                    if (loaded) callback();
                 }
-            });
-        }
-        if (info.images === 'enemys' || info.images === 'enemy48') {
-            saveSetting('enemys', [["add", "['" + id + "']", editor_file.comment._data.enemys_template]], function (err) {
-                if (err) {
-                    printe(err);
-                    throw(err)
-                }
-            });
-        }
-
-        callback(null);
-    }
-    //callback(err:String)
-    editor_file.editItem = function (id, actionList, callback) {
-        /*actionList:[
-          ["change","['items']['name']","红宝石的新名字"],
-          ["add","['items']['新的和name同级的属性']",123],
-          ["change","['itemEffectTip']","'，攻击力+'+editor.core.values.redJewel"],
-        ]
-        为[]时只查询不修改
-        */
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
-        }
-        ;
-        if (isset(actionList) && actionList.length > 0) {
-            actionList.forEach(function (value) {
-                var tempindex = value[1].indexOf(']') + 1;
-                value[1] = [value[1].slice(0, tempindex), "['" + id + "']", value[1].slice(tempindex)].join('');
-            });
-            saveSetting('items', actionList, function (err) {
-                callback([
-                    (function () {
-                        var locObj_ = {};
-                        Object.keys(editor_file.comment._data.items._data).forEach(function (v) {
-                            if (isset(editor.core.items[v][id]) && v !== 'items')
-                                locObj_[v] = editor.core.items[v][id];
-                            else
-                                locObj_[v] = null;
-                        });
-                        locObj_['items'] = (function () {
-                            var locObj = Object.assign({}, editor.core.items.items[id]);
-                            Object.keys(editor_file.comment._data.items._data.items._data).forEach(function (v) {
-                                if (!isset(editor.core.items.items[id][v]))
-                                    locObj[v] = null;
-                            });
-                            return locObj;
-                        })();
-                        return locObj_;
-                    })(),
-                    editor_file.comment._data.items,
-                    err]);
-            });
-        } else {
-            callback([
-                (function () {
-                    var locObj_ = {};
-                    Object.keys(editor_file.comment._data.items._data).forEach(function (v) {
-                        if (isset(editor.core.items[v][id]) && v !== 'items')
-                            locObj_[v] = editor.core.items[v][id];
-                        else
-                            locObj_[v] = null;
-                    });
-                    locObj_['items'] = (function () {
-                        var locObj = Object.assign({}, editor.core.items.items[id]);
-                        Object.keys(editor_file.comment._data.items._data.items._data).forEach(function (v) {
-                            if (!isset(editor.core.items.items[id][v]))
-                                locObj[v] = null;
-                        });
-                        return locObj;
-                    })();
-                    return locObj_;
-                })(),
-                editor_file.comment._data.items,
-                null]);
-        }
-        //只有items.cls是items的才有itemEffect和itemEffectTip,keys和constants和tools只有items
-    }
-    //callback([obj,commentObj,err:String])
-    editor_file.editEnemy = function (id, actionList, callback) {
-        /*actionList:[
-          ["change","['name']","初级巫师的新名字"],
-          ["add","['新的和name同级的属性']",123],
-          ["change","['bomb']",null],
-        ]
-        为[]时只查询不修改
-        */
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
-        }
-        ;
-        if (isset(actionList) && actionList.length > 0) {
-            actionList.forEach(function (value) {
-                value[1] = "['" + id + "']" + value[1];
-            });
-            saveSetting('enemys', actionList, function (err) {
-                callback([
-                    (function () {
-                        var locObj = Object.assign({}, editor.core.enemys.enemys[id]);
-                        Object.keys(editor_file.comment._data.enemys._data).forEach(function (v) {
-                            if (!isset(editor.core.enemys.enemys[id][v]))
-                            /* locObj[v]=editor.core.enemys.enemys[id][v];
-                          else */
-                                locObj[v] = null;
-                        });
-                        return locObj;
-                    })(),
-                    editor_file.comment._data.enemys,
-                    err]);
-            });
-        } else {
-            callback([
-                (function () {
-                    var locObj = Object.assign({}, editor.core.enemys.enemys[id]);
-                    Object.keys(editor_file.comment._data.enemys._data).forEach(function (v) {
-                        if (!isset(editor.core.enemys.enemys[id][v]))
-                        /* locObj[v]=editor.core.enemys.enemys[id][v];
-                      else */
-                            locObj[v] = null;
-                    });
-                    return locObj;
-                })(),
-                editor_file.comment._data.enemys,
-                null]);
-        }
-    }
-    //callback([obj,commentObj,err:String])
-
-    editor_file.editMapBlocksInfo = function (idnum, actionList, callback) {
-        /*actionList:[
-          ["change","['events']",["\t[老人,magician]领域、夹击。\n请注意领域怪需要设置value为伤害数值，可参见样板中初级巫师的写法。"]],
-          ["change","['afterBattle']",null],
-        ]
-        为[]时只查询不修改
-        */
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
-        }
-        ;
-        if (isset(actionList) && actionList.length > 0) {
-            actionList.forEach(function (value) {
-                value[1] = "['" + idnum + "']" + value[1];
-            });
-            saveSetting('maps', actionList, function (err) {
-                callback([
-                    (function () {
-                        var locObj = Object.assign({}, editor.core.maps.blocksInfo[idnum]);
-                        Object.keys(editor_file.comment._data.maps._data).forEach(function (v) {
-                            if (!isset(editor.core.maps.blocksInfo[idnum][v]))
-                                locObj[v] = null;
-                        });
-                        locObj.idnum = idnum;
-                        return locObj;
-                    })(),
-                    editor_file.comment._data.maps,
-                    null]);
-            });
-        } else {
-            callback([
-                (function () {
-                    var locObj = Object.assign({}, editor.core.maps.blocksInfo[idnum]);
-                    Object.keys(editor_file.comment._data.maps._data).forEach(function (v) {
-                        if (!isset(editor.core.maps.blocksInfo[idnum][v]))
-                            locObj[v] = null;
-                    });
-                    locObj.idnum = idnum;
-                    return locObj;
-                })(),
-                editor_file.comment._data.maps,
-                null]);
-        }
-    }
-    //callback([obj,commentObj,err:String])
-
-    ////////////////////////////////////////////////////////////////////
-
-    editor_file.editLoc = function (x, y, actionList, callback) {
-        /*actionList:[
-          ["change","['events']",["\t[老人,magician]领域、夹击。\n请注意领域怪需要设置value为伤害数值，可参见样板中初级巫师的写法。"]],
-          ["change","['afterBattle']",null],
-        ]
-        为[]时只查询不修改
-        */
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
-        }
-        ;
-        if (isset(actionList) && actionList.length > 0) {
-            actionList.forEach(function (value) {
-                value[1] = value[1] + "['" + x + "," + y + "']";
-            });
-            saveSetting('floors', actionList, function (err) {
-                callback([
-                    (function () {
-                        var locObj = {};
-                        Object.keys(editor_file.comment._data.floors._data.loc._data).forEach(function (v) {
-                            if (isset(editor.currentFloorData[v][x + ',' + y]))
-                                locObj[v] = editor.currentFloorData[v][x + ',' + y];
-                            else
-                                locObj[v] = null;
-                        });
-                        return locObj;
-                    })(),
-                    editor_file.comment._data.floors._data.loc,
-                    err]);
-            });
-        } else {
-            callback([
-                (function () {
-                    var locObj = {};
-                    Object.keys(editor_file.comment._data.floors._data.loc._data).forEach(function (v) {
-                        if (isset(editor.currentFloorData[v][x + ',' + y]))
-                            locObj[v] = editor.currentFloorData[v][x + ',' + y];
-                        else
-                            locObj[v] = null;
-                    });
-                    return locObj;
-                })(),
-                editor_file.comment._data.floors._data.loc,
-                null]);
-        }
-
-    }
-    //callback([obj,commentObj,err:String])
-
-    ////////////////////////////////////////////////////////////////////
-
-    editor_file.editFloor = function (actionList, callback) {
-        /*actionList:[
-          ["change","['title']",'样板 3 层'],
-          ["change","['color']",null],
-        ]
-        为[]时只查询不修改
-        */
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
-        }
-        ;
-        if (isset(actionList) && actionList.length > 0) {
-            saveSetting('floors', actionList, function (err) {
-                callback([
-                    (function () {
-                        var locObj = Object.assign({}, editor.currentFloorData);
-                        Object.keys(editor_file.comment._data.floors._data.floor._data).forEach(function (v) {
-                            if (!isset(editor.currentFloorData[v]))
-                            /* locObj[v]=editor.currentFloorData[v];
-                          else */
-                                locObj[v] = null;
-                        });
-                        Object.keys(editor_file.comment._data.floors._data.loc._data).forEach(function (v) {
-                            delete(locObj[v]);
-                        });
-                        delete(locObj.map);
-                        return locObj;
-                    })(),
-                    editor_file.comment._data.floors._data.floor,
-                    err]);
-            });
-        } else {
-            callback([
-                (function () {
-                    var locObj = Object.assign({}, editor.currentFloorData);
-                    Object.keys(editor_file.comment._data.floors._data.floor._data).forEach(function (v) {
-                        if (!isset(editor.currentFloorData[v]))
-                        /* locObj[v]=editor.currentFloorData[v];
-                      else */
-                            locObj[v] = null;
-                    });
-                    Object.keys(editor_file.comment._data.floors._data.loc._data).forEach(function (v) {
-                        delete(locObj[v]);
-                    });
-                    delete(locObj.map);
-                    return locObj;
-                })(),
-                editor_file.comment._data.floors._data.floor,
-                null]);
-        }
-    }
-    //callback([obj,commentObj,err:String])
-
-    ////////////////////////////////////////////////////////////////////
-
-    editor_file.editTower = function (actionList, callback) {
-        /*actionList:[
-          ["change","['firstData']['version']",'Ver 1.0.1 (Beta)'],
-          ["change","['values']['lavaDamage']",200],
-        ]
-        为[]时只查询不修改
-        */
-        var data_obj = data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d;
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
-        }
-        ;
-        if (isset(actionList) && actionList.length > 0) {
-            saveSetting('data', actionList, function (err) {
-                callback([
-                    (function () {
-                        //var locObj=Object.assign({'main':{}},editor.core.data);
-                        var locObj = Object.assign({}, data_obj, {'main': {}});
-                        Object.keys(editor_file.dataComment._data.main._data).forEach(function (v) {
-                            if (isset(editor.main[v]))
-                                locObj.main[v] = data_obj.main[v];
-                            else
-                                locObj[v] = null;
-                        });
-                        return locObj;
-                    })(),
-                    editor_file.dataComment,
-                    err]);
-            });
-        } else {
-            callback([
-                (function () {
-                    //var locObj=Object.assign({'main':{}},editor.core.data);
-                    var locObj = Object.assign({}, data_obj, {'main': {}});
-                    Object.keys(editor_file.dataComment._data.main._data).forEach(function (v) {
-                        if (isset(editor.main[v]))
-                            locObj.main[v] = data_obj.main[v];
-                        else
-                            locObj[v] = null;
-                    });
-                    return locObj;
-                })(),
-                editor_file.dataComment,
-                null]);
-        }
-    }
-    //callback([obj,commentObj,err:String])
-
-    ////////////////////////////////////////////////////////////////////
-
-    var fmap = {};
-    var fjson = JSON.stringify(functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a, function (k, v) {
-        if (v instanceof Function) {
-            var id_ = editor.guid();
-            fmap[id_] = v.toString();
-            return id_;
-        } else return v
-    }, 4);
-    var fobj = JSON.parse(fjson);
-    editor_file.functionsMap = fmap;
-    editor_file.functionsJSON = fjson;
-    var buildlocobj = function (locObj) {
-        for (var key in locObj) {
-            if (typeof(locObj[key]) !== typeof('')) buildlocobj(locObj[key]);
-            else locObj[key] = fmap[locObj[key]];
-        }
-    };
-
-    editor_file.editFunctions = function (actionList, callback) {
-        /*actionList:[
-          ["change","['events']['afterChangeLight']","function(x,y){console.log(x,y)}"],
-          ["change","['ui']['drawAbout']","function(){...}"],
-        ]
-        为[]时只查询不修改
-        */
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
-        }
-        ;
-        if (isset(actionList) && actionList.length > 0) {
-            saveSetting('functions', actionList, function (err) {
-                callback([
-                    (function () {
-                        var locObj = JSON.parse(fjson);
-                        buildlocobj(locObj);
-                        return locObj;
-                    })(),
-                    editor_file.functionsComment,
-                    err]);
-            });
-        } else {
-            callback([
-                (function () {
-                    var locObj = JSON.parse(fjson);
-                    buildlocobj(locObj);
-                    return locObj;
-                })(),
-                editor_file.functionsComment,
-                null]);
-        }
-    }
-    //callback([obj,commentObj,err:String])
-
-    ////////////////////////////////////////////////////////////////////
-
-    var isset = function (val) {
-        if (val == undefined || val == null) {
-            return false;
-        }
-        return true
-    }
-
-    var formatMap = function (mapArr) {
-        //把二维数组格式化
-        var formatArrStr = '';
-        var arr = JSON.stringify(mapArr).replace(/\s+/g, '').split('],[');
-        var si=mapArr.length-1,sk=mapArr[0].length-1;
-        for (var i = 0; i <= si; i++) {
-            var a = [];
-            formatArrStr += '    [';
-            if (i == 0 || i == si) a = arr[i].split(/\D+/).join(' ').trim().split(' ');
-            else a = arr[i].split(/\D+/);
-            for (var k = 0; k <= sk; k++) {
-                var num = parseInt(a[k]);
-                formatArrStr += Array(Math.max(4 - String(num).length, 0)).join(' ') + num + (k == sk ? '' : ',');
-            }
-            formatArrStr += ']' + (i == si ? '' : ',\n');
-        }
-        return formatArrStr;
-    }
-
-    var encode = function (str) {
-        return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, function (match, p1) {
-            return String.fromCharCode(parseInt(p1, 16))
-        }))
-    }
-
-    var alertWhenCompress = function(){
-        if(editor.useCompress===true){
-            editor.useCompress=null;
-            setTimeout("alert('当前游戏使用的是压缩文件,修改完成后请重新压缩')",1000)
+            })(key);
         }
     }
 
-    var saveSetting = function (file, actionList, callback) {
-        //console.log(file);
-        //console.log(actionList);
-        alertWhenCompress();
 
-        if (file == 'icons') {
-            actionList.forEach(function (value) {
-                eval("icons_4665ee12_3a1f_44a4_bea3_0fccba634dc1" + value[1] + '=' + JSON.stringify(value[2]));
-            });
-            var datastr = 'icons_4665ee12_3a1f_44a4_bea3_0fccba634dc1 = \n';
-            datastr += JSON.stringify(icons_4665ee12_3a1f_44a4_bea3_0fccba634dc1, null, '\t');
-            fs.writeFile('project/icons.js', encode(datastr), 'base64', function (err, data) {
-                callback(err);
-            });
-            return;
-        }
-        if (file == 'maps') {
-            actionList.forEach(function (value) {
-                eval("maps_90f36752_8815_4be8_b32b_d7fad1d0542e" + value[1] + '=' + JSON.stringify(value[2]));
-            });
-            var datastr = 'maps_90f36752_8815_4be8_b32b_d7fad1d0542e = \n';
-            //datastr+=JSON.stringify(maps_90f36752_8815_4be8_b32b_d7fad1d0542e,null,4);
-
-            var emap = {};
-            var estr = JSON.stringify(maps_90f36752_8815_4be8_b32b_d7fad1d0542e, function (k, v) {
-                if (v.id != null) {
-                    var id_ = editor.guid();
-                    emap[id_] = JSON.stringify(v);
-                    return id_;
-                } else return v
-            }, '\t');
-            for (var id_ in emap) {
-                estr = estr.replace('"' + id_ + '"', emap[id_])
-            }
-            datastr += estr;
-
-            fs.writeFile('project/maps.js', encode(datastr), 'base64', function (err, data) {
-                callback(err);
-            });
-            return;
-        }
-        if (file == 'items') {
-            actionList.forEach(function (value) {
-                eval("items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a" + value[1] + '=' + JSON.stringify(value[2]));
-            });
-            var datastr = 'items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a = \n';
-            datastr += JSON.stringify(items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a, null, '\t');
-            fs.writeFile('project/items.js', encode(datastr), 'base64', function (err, data) {
-                callback(err);
-            });
-            return;
-        }
-        if (file == 'enemys') {
-            actionList.forEach(function (value) {
-                eval("enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80" + value[1] + '=' + JSON.stringify(value[2]));
-            });
-            var datastr = 'enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80 = \n';
-            var emap = {};
-            var estr = JSON.stringify(enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80, function (k, v) {
-                if (v.hp != null) {
-                    var id_ = editor.guid();
-                    emap[id_] = JSON.stringify(v);
-                    return id_;
-                } else return v
-            }, '\t');
-            for (var id_ in emap) {
-                estr = estr.replace('"' + id_ + '"', emap[id_])
-            }
-            datastr += estr;
-            fs.writeFile('project/enemys.js', encode(datastr), 'base64', function (err, data) {
-                callback(err);
-            });
-            return;
-        }
-        if (file == 'data') {
-            actionList.forEach(function (value) {
-                eval("data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d" + value[1] + '=' + JSON.stringify(value[2]));
-            });
-            if (data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.main.floorIds.indexOf(data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.firstData.floorId) < 0)
-                data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.firstData.floorId = data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.main.floorIds[0];
-            var datastr = 'data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d = \n';
-            datastr += JSON.stringify(data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d, null, '\t');
-            fs.writeFile('project/data.js', encode(datastr), 'base64', function (err, data) {
-                callback(err);
-            });
-            return;
-        }
-        if (file == 'functions') {
-            actionList.forEach(function (value) {
-                eval("fmap[fobj" + value[1] + ']=' + JSON.stringify(value[2]));
-            });
-            var fraw = fjson;
-            for (var id_ in fmap) {
-                fraw = fraw.replace('"' + id_ + '"', fmap[id_])
-            }
-            var datastr = 'functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = \n';
-            datastr += fraw;
-            fs.writeFile('project/functions.js', encode(datastr), 'base64', function (err, data) {
-                callback(err);
-            });
-            return;
-        }
-        if (file == 'floors') {
-            actionList.forEach(function (value) {
-                eval("editor.currentFloorData" + value[1] + '=' + JSON.stringify(value[2]));
-            });
-            editor_file.saveFloorFile(callback);
-            return;
-        }
-        callback('出错了,要设置的文件名不识别');
-    }
-
-    /*
-    $select({\"values\":[\"keys\",\"items\",\"constants\",\"tools\"]})$end
-    $range(thiseval==~~thiseval &&thiseval>0)$end
-    $leaf(true)$end
-    $select({\"values\":[true]})$end
-    $select({\"values\":[false]})$end
-    $select({\"values\":[true,false]})$end
-
-    */
-
-    /*
-    所有注释中的特殊指令
-    $range(evalstr:thiseval)$end
-      限制取值范围,要求修改后的eval(evalstr)为true
-    $leaf(evalstr:thiseval)$end
-      强制指定为叶节点,如果eval(evalstr)为true
-
-    //以下几个中选一个 [
-    $select(evalstr)$end
-      渲染成<select>,选项为数组eval(evalstr)['values']
-    $input(evalstr)$end
-      渲染成<input>
-    $textarea(evalstr)$end
-      渲染成<textarea>
-    默认选项为$textarea()$end
-    // ]
-
-    */
-    return editor_file;
-}
-//editor_file = editor_file(editor);
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/_server/editor_file_unsorted.js b/_server/editor_file_unsorted.js
new file mode 100644
index 00000000..04c46d99
--- /dev/null
+++ b/_server/editor_file_unsorted.js
@@ -0,0 +1,913 @@
+editor_file = function (editor, callback) {
+
+    var editor_file = new editor_file_proto();
+    editor.file=editor_file;
+
+    editor.file.loadCommentjs(callback);
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    editor.file.saveFloorFile = function (callback) {
+        checkCallback(callback);
+        /* if (!isset(editor.currentFloorId) || !isset(editor.currentFloorData)) {
+          callback('未选中文件或无数据');
+        } */
+        var filename = 'project/floors/' + editor.currentFloorId + '.js';
+        var datastr = ['main.floors.', editor.currentFloorId, '=\n'];
+
+        for(var ii=0,name;name=['map','bgmap','fgmap'][ii];ii++){
+            var mapArray=editor[name].map(function (v) {
+                return v.map(function (v) {
+                    return v.idnum || v || 0
+                })
+            });
+            editor.currentFloorData[name]=mapArray;
+        }
+        
+        // format 更改实现方式以支持undefined删除
+        var tempJsonObj=Object.assign({},editor.currentFloorData);
+        var tempMap=[['map',editor.util.guid()],['bgmap',editor.util.guid()],['fgmap',editor.util.guid()]];
+        tempMap.forEach(function(v){
+            v[2]=tempJsonObj[v[0]];
+            tempJsonObj[v[0]]=v[1];
+        });
+        var tempJson=JSON.stringify(tempJsonObj, null, 4);
+        tempMap.forEach(function(v){
+            tempJson=tempJson.replace('"'+v[1]+'"','[\n'+ formatMap(v[2],v[0]!='map')+ '\n]')
+        });
+        datastr = datastr.concat([tempJson]);
+        datastr = datastr.join('');
+        alertWhenCompress();
+        fs.writeFile(filename, encode(datastr), 'base64', function (err, data) {
+            callback(err);
+        });
+    }
+    //callback(err:String)
+    editor.file.saveNewFile = function (saveFilename, callback) {
+        //saveAsFilename不含'/'不含'.js'
+        checkCallback(callback);
+        var currData=editor.currentFloorData;
+        var saveStatus = document.getElementById('newMapStatus').checked;
+
+        var title = saveStatus?currData.title:"新建楼层";
+        var name = saveStatus?currData.name:"0";
+        if (/^mt\d+$/i.test(saveFilename)) {
+            name = saveFilename.substring(2);
+            title = "主塔 "+name+" 层";
+        }
+        
+        var width = parseInt(document.getElementById('newMapsWidth').value);
+        var height = parseInt(document.getElementById('newMapsHeight').value);
+        var row = [], map = [];
+        for (var i=0;i<width;i++) row.push(0);
+        for (var i=0;i<height;i++) map.push(row);
+        editor.currentFloorData = Object.assign(JSON.parse(JSON.stringify(editor.file.comment._data.floors_template)), {
+            floorId: saveFilename,
+            title: title,
+            name: name,
+            width: width,
+            height: height,
+            map: map,
+        },saveStatus?{
+            canFlyTo: currData.canFlyTo,
+            canUseQuickShop: currData.canUseQuickShop,
+            cannotViewMap: currData.cannotViewMap,
+            cannotMoveDirectly: currData.cannotMoveDirectly,
+            item_ratio: currData.item_ratio,
+            defaultGround: currData.defaultGround,
+            bgm: currData.bgm,
+            color: currData.color,
+            weather: currData.weather,
+        }:{});
+        
+        Object.keys(editor.currentFloorData).forEach(function (t) {
+            if (editor.currentFloorData[t] == null)
+                delete editor.currentFloorData[t];
+        })
+        editor.currentFloorId = saveFilename;
+        editor.file.saveFloorFile(callback);
+    }
+    editor.file.saveNewFiles = function (floorIdList, from, to, callback) {
+        checkCallback(callback);
+        var currData=editor.currentFloorData;
+        var saveStatus = document.getElementById('newMapsStatus').checked;
+
+        var calValue = function (text, i) {
+            return text.replace(/\${(.*?)}/g, function (word, value) {
+                return eval(value);
+            });
+        }
+
+        var width = parseInt(document.getElementById('newMapsWidth').value);
+        var height = parseInt(document.getElementById('newMapsHeight').value);
+
+        var row = [], map = [];
+        for (var i=0;i<width;i++) row.push(0);
+        for (var i=0;i<height;i++) map.push(row);
+
+        var filenames = floorIdList.map(function (v) {return "project/floors/"+v+".js";});
+        var datas = [];
+        for (var i=from;i<=to;i++) {
+            var datastr = ['main.floors.', floorIdList[i-from], '=\n{'];
+            var data = Object.assign(JSON.parse(JSON.stringify(editor.file.comment._data.floors_template)), {
+                floorId: floorIdList[i-from],
+                title: calValue(document.getElementById('newFloorTitles').value, i),
+                name: calValue(document.getElementById('newFloorNames').value, i),
+                width: width,
+                height: height,
+                map: map,
+            },saveStatus?{
+                canFlyTo: currData.canFlyTo,
+                canUseQuickShop: currData.canUseQuickShop,
+                cannotViewMap: currData.cannotViewMap,
+                cannotMoveDirectly: currData.cannotMoveDirectly,
+                item_ratio: currData.item_ratio,
+                defaultGround: currData.defaultGround,
+                bgm: currData.bgm,
+                color: currData.color,
+                weather: currData.weather,
+            }:{});
+            Object.keys(data).forEach(function (t) {
+                if (data[t] == null)
+                    delete data[t];
+                else {
+                    if (t=='map') {
+                        datastr = datastr.concat(['\n"', t, '": [\n', formatMap(data[t]), '\n],']);
+                    }
+                    else {
+                        datastr = datastr.concat(['\n"', t, '": ', JSON.stringify(data[t], null, 4), ',']);
+                    }
+                }
+            });
+            datastr = datastr.concat(['\n}']);
+            datastr = datastr.join('');
+            datas.push(encode(datastr));
+        }
+        alertWhenCompress();
+        fs.writeMultiFiles(filenames, datas, function (err, data) {
+            callback(err);
+        });
+    }
+
+    //callback(err:String)
+
+    ////////////////////////////////////////////////////////////////////
+
+    editor.file.autoRegister = function (info, callback) {
+
+        var iconActions = [];
+        var mapActions = [];
+        var templateActions = [];
+
+        var image = info.images;
+
+        if (image=='autotile') {
+            callback('不能对自动元件进行自动注册！');
+            return;
+        }
+        var c=image.toUpperCase().charAt(0);
+
+        // terrains id
+        var terrainsId = [];
+        Object.keys(core.material.icons.terrains).forEach(function (id) {
+            terrainsId[core.material.icons.terrains[id]]=id;
+        })
+
+        var allIds = [];
+        editor.ids.forEach(function (v) {
+            if (v.images==image) {
+                allIds[v.y]=true;
+            }
+        })
+
+        var per_height = image.endsWith('48')?48:32;
+
+        var idnum=300;
+        for (var y=0; y<editor.widthsX[image][3]/per_height;y++) {
+            if (allIds[y]) continue;
+            while (editor.core.maps.blocksInfo[idnum]) idnum++;
+
+            // get id num
+            var id = c+idnum;
+
+            if (image=='terrains' && terrainsId[y] != null) {
+                id=terrainsId[y];
+            }
+            else {
+                iconActions.push(["add", "['" + image + "']['" + id + "']", y])
+            }
+            mapActions.push(["add", "['" + idnum + "']", {'cls': image, 'id': id}])
+            if (image=='items')
+                templateActions.push(["add", "['items']['" + id + "']", editor.file.comment._data.items_template]);
+            else if (image.indexOf('enemy')==0)
+                templateActions.push(["add", "['" + id + "']", editor.file.comment._data.enemys_template]);
+            idnum++;
+        }
+
+        if (mapActions.length==0) {
+            callback("没有要注册的项！");
+            return;
+        }
+
+        var templist = [];
+        var tempcallback = function (err) {
+            templist.push(err);
+            if (templist.length == 3) {
+                if (templist[0] != null || templist[1] != null || templist[2] != null)
+                    callback((templist[0] || '') + '\n' + (templist[1] || '') + '\n' + (templist[2] || ''));
+                //这里如果一个成功一个失败会出严重bug
+                else
+                    callback(null);
+            }
+        }
+        if (iconActions.length>0)
+            saveSetting('icons', iconActions, tempcallback);
+        else tempcallback(null);
+
+        saveSetting('maps', mapActions, tempcallback);
+
+        if (image=='items')
+            saveSetting('items', templateActions, tempcallback);
+        else if (image.indexOf('enemy')==0)
+            saveSetting('enemys', templateActions, tempcallback);
+        else tempcallback(null);
+    }
+
+    editor.file.registerAutotile = function (filename, callback) {
+        var idnum = 140;
+        while (editor.core.maps.blocksInfo[idnum]) idnum++;
+
+        var iconActions = [];
+        var mapActions = [];
+
+        iconActions.push(["add", "['autotile']['" + filename + "']", 0]);
+        mapActions.push(["add", "['" + idnum + "']", {'cls': 'autotile', 'id': filename, 'noPass': true}]);
+
+        var templist = [];
+        var tempcallback = function (err) {
+            templist.push(err);
+            if (templist.length == 2) {
+                if (templist[0] != null || templist[1] != null)
+                    callback((templist[0] || '') + '\n' + (templist[1] || ''));
+                //这里如果一个成功一个失败会出严重bug
+                else
+                    callback(null);
+            }
+        }
+
+        saveSetting('icons', iconActions, tempcallback);
+        saveSetting('maps', mapActions, tempcallback);
+    }
+
+    editor.file.changeIdAndIdnum = function (id, idnum, info, callback) {
+        checkCallback(callback);
+        
+        var changeOrNew=core.isset(editor_mode.info.id)?'change':'new'
+        if(changeOrNew=='new'){
+            //检查maps中是否有重复的idnum或id
+            for (var ii in editor.core.maps.blocksInfo) {
+                if (ii == idnum) {
+                    callback('idnum重复了');
+                    return;
+                }
+                if (editor.core.maps.blocksInfo[ii].id == id) {
+                    callback('id重复了');
+                    return;
+                }
+            }
+            var templist = [];
+            var tempcallback = function (err) {
+                templist.push(err);
+                if (templist.length == 2) {
+                    if (templist[0] != null || templist[1] != null)
+                        callback((templist[0] || '') + '\n' + (templist[1] || ''));
+                    //这里如果一个成功一个失败会出严重bug
+                    else
+                        callback(null);
+                }
+            }
+            saveSetting('maps', [["add", "['" + idnum + "']", {'cls': info.images, 'id': id}]], tempcallback);
+            saveSetting('icons', [["add", "['" + info.images + "']['" + id + "']", info.y]], tempcallback);
+            if (info.images === 'items') {
+                saveSetting('items', [["add", "['items']['" + id + "']", editor.file.comment._data.items_template]], function (err) {
+                    if (err) {
+                        printe(err);
+                        throw(err)
+                    }
+                });
+            }
+            if (info.images === 'enemys' || info.images === 'enemy48') {
+                saveSetting('enemys', [["add", "['" + id + "']", editor.file.comment._data.enemys_template]], function (err) {
+                    if (err) {
+                        printe(err);
+                        throw(err)
+                    }
+                });
+            }
+
+            callback(null);
+
+        }else{
+            //检查maps中是否有重复的idnum或id
+            for (var ii in editor.core.maps.blocksInfo) {
+                if (editor.core.maps.blocksInfo[ii].id == id) {
+                    callback('id重复了');
+                    return;
+                }
+            }
+            idnum = info.idnum;
+
+            maps_90f36752_8815_4be8_b32b_d7fad1d0542e[idnum].id = id;
+
+            var arr=[icons_4665ee12_3a1f_44a4_bea3_0fccba634dc1,items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a,{enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80:enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80}]
+            arr.forEach(function (obj) {
+                for(var jj in obj){
+                    var ii=obj[jj]
+                    if (ii.hasOwnProperty(info.id)){
+                        ii[id]=ii[info.id];
+                        delete(ii[info.id]);
+                    }
+                }
+            });
+
+            editor.file.save_icons_maps_items_enemys(callback)
+            
+        }
+    }
+    //callback(err:String)
+    editor.file.editItem = function (id, actionList, callback) {
+        /*actionList:[
+          ["change","['items']['name']","红宝石的新名字"],
+          ["add","['items']['新的和name同级的属性']",123],
+          ["change","['itemEffectTip']","'，攻击力+'+editor.core.values.redJewel"],
+        ]
+        为[]时只查询不修改
+        */
+        checkCallback(callback);
+        if (isset(actionList) && actionList.length > 0) {
+            actionList.forEach(function (value) {
+                var tempindex = value[1].indexOf(']') + 1;
+                value[1] = [value[1].slice(0, tempindex), "['" + id + "']", value[1].slice(tempindex)].join('');
+            });
+            saveSetting('items', actionList, function (err) {
+                callback([err]);
+            });
+        } else {
+            callback([
+                (function () {
+                    var locObj_ = {};
+                    Object.keys(editor.file.comment._data.items._data).forEach(function (v) {
+                        if (isset(editor.core.items[v][id]) && v !== 'items')
+                            locObj_[v] = editor.core.items[v][id];
+                        else
+                            locObj_[v] = null;
+                    });
+                    locObj_['items'] = (function () {
+                        var locObj = Object.assign({}, editor.core.items.items[id]);
+                        Object.keys(editor.file.comment._data.items._data.items._data).forEach(function (v) {
+                            if (!isset(editor.core.items.items[id][v]))
+                                locObj[v] = null;
+                        });
+                        return locObj;
+                    })();
+                    return locObj_;
+                })(),
+                editor.file.comment._data.items,
+                null]);
+        }
+        //只有items.cls是items的才有itemEffect和itemEffectTip,keys和constants和tools只有items
+    }
+    //callback([obj,commentObj,err:String])
+    editor.file.editEnemy = function (id, actionList, callback) {
+        /*actionList:[
+          ["change","['name']","初级巫师的新名字"],
+          ["add","['新的和name同级的属性']",123],
+          ["change","['bomb']",null],
+        ]
+        为[]时只查询不修改
+        */
+        checkCallback(callback);
+        if (isset(actionList) && actionList.length > 0) {
+            actionList.forEach(function (value) {
+                value[1] = "['" + id + "']" + value[1];
+            });
+            saveSetting('enemys', actionList, function (err) {
+                callback([err]);
+            });
+        } else {
+            callback([
+                (function () {
+                    var locObj = Object.assign({}, editor.core.enemys.enemys[id]);
+                    Object.keys(editor.file.comment._data.enemys._data).forEach(function (v) {
+                        if (!isset(editor.core.enemys.enemys[id][v]))
+                        /* locObj[v]=editor.core.enemys.enemys[id][v];
+                      else */
+                            locObj[v] = null;
+                    });
+                    return locObj;
+                })(),
+                editor.file.comment._data.enemys,
+                null]);
+        }
+    }
+    //callback([obj,commentObj,err:String])
+
+    editor.file.editMapBlocksInfo = function (idnum, actionList, callback) {
+        /*actionList:[
+          ["change","['events']",["\t[老人,magician]领域、夹击。\n请注意领域怪需要设置value为伤害数值，可参见样板中初级巫师的写法。"]],
+          ["change","['afterBattle']",null],
+        ]
+        为[]时只查询不修改
+        */
+        checkCallback(callback);
+        if (isset(actionList) && actionList.length > 0) {
+            var tempmap=[];
+            for(var ii=0;ii<actionList.length;ii++){
+                var value=actionList[ii];
+                // 是tilesets 且未定义 且在这里是第一次定义
+                if(idnum>=editor.core.icons.tilesetStartOffset && !isset(editor.core.maps.blocksInfo[idnum]) && tempmap.indexOf(idnum)===-1){
+                    actionList.splice(ii,0,["add","['" + idnum + "']",{"cls": "tileset", "id": "X"+idnum, "noPass": true}]);
+                    tempmap.push(idnum);
+                    ii++;
+                }
+                value[1] = "['" + idnum + "']" + value[1];
+            }
+            saveSetting('maps', actionList, function (err) {
+                callback([err]);
+            });
+        } else {
+            callback([
+                (function () {
+                    var sourceobj=editor.core.maps.blocksInfo[idnum];
+                    if(!isset(sourceobj) && idnum>=editor.core.icons.tilesetStartOffset)sourceobj={"cls": "tileset", "id": "X"+idnum, "noPass": true}
+                    var locObj = Object.assign({}, sourceobj);
+                    Object.keys(editor.file.comment._data.maps._data).forEach(function (v) {
+                        if (!isset(sourceobj[v]))
+                            locObj[v] = null;
+                    });
+                    locObj.idnum = idnum;
+                    return locObj;
+                })(),
+                editor.file.comment._data.maps,
+                null]);
+        }
+    }
+    //callback([obj,commentObj,err:String])
+
+    ////////////////////////////////////////////////////////////////////
+
+    editor.file.editLoc = function (x, y, actionList, callback) {
+        /*actionList:[
+          ["change","['events']",["\t[老人,magician]领域、夹击。\n请注意领域怪需要设置value为伤害数值，可参见样板中初级巫师的写法。"]],
+          ["change","['afterBattle']",null],
+        ]
+        为[]时只查询不修改
+        */
+        checkCallback(callback);
+        if (isset(actionList) && actionList.length > 0) {
+            actionList.forEach(function (value) {
+                value[1] = value[1] + "['" + x + "," + y + "']";
+            });
+            saveSetting('floorloc', actionList, function (err) {
+                callback([err]);
+            });
+        } else {
+            callback([
+                (function () {
+                    var locObj = {};
+                    Object.keys(editor.file.comment._data.floors._data.loc._data).forEach(function (v) {
+                        if (isset(editor.currentFloorData[v][x + ',' + y]))
+                            locObj[v] = editor.currentFloorData[v][x + ',' + y];
+                        else
+                            locObj[v] = null;
+                    });
+                    return locObj;
+                })(),
+                editor.file.comment._data.floors._data.loc,
+                null]);
+        }
+
+    }
+    //callback([obj,commentObj,err:String])
+
+    ////////////////////////////////////////////////////////////////////
+
+    editor.file.editFloor = function (actionList, callback) {
+        /*actionList:[
+          ["change","['title']",'样板 3 层'],
+          ["change","['color']",null],
+        ]
+        为[]时只查询不修改
+        */
+        checkCallback(callback);
+        if (isset(actionList) && actionList.length > 0) {
+            saveSetting('floors', actionList, function (err) {
+                callback([err]);
+            });
+        } else {
+            callback([
+                (function () {
+                    var locObj = Object.assign({}, editor.currentFloorData);
+                    Object.keys(editor.file.comment._data.floors._data.floor._data).forEach(function (v) {
+                        if (!isset(editor.currentFloorData[v]))
+                        /* locObj[v]=editor.currentFloorData[v];
+                      else */
+                            locObj[v] = null;
+                    });
+                    Object.keys(editor.file.comment._data.floors._data.loc._data).forEach(function (v) {
+                        delete(locObj[v]);
+                    });
+                    delete(locObj.map);
+                    delete(locObj.bgmap);
+                    delete(locObj.fgmap);
+                    return locObj;
+                })(),
+                editor.file.comment._data.floors._data.floor,
+                null]);
+        }
+    }
+    //callback([obj,commentObj,err:String])
+
+    ////////////////////////////////////////////////////////////////////
+
+    editor.file.editTower = function (actionList, callback) {
+        /*actionList:[
+          ["change","['firstData']['version']",'Ver 1.0.1 (Beta)'],
+          ["change","['values']['lavaDamage']",200],
+        ]
+        为[]时只查询不修改
+        */
+        var data_obj = data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d;
+        checkCallback(callback);
+        if (isset(actionList) && actionList.length > 0) {
+            saveSetting('data', actionList, function (err) {
+                callback([err]);
+            });
+        } else {
+            callback([
+                (function () {
+                    //var locObj=Object.assign({'main':{}},editor.core.data);
+                    var locObj = Object.assign({}, data_obj, {'main': {}});
+                    Object.keys(editor.file.dataComment._data.main._data).forEach(function (v) {
+                        if (isset(editor.main[v]))
+                            locObj.main[v] = data_obj.main[v];
+                        else
+                            locObj.main[v] = null;
+                    });
+                    return locObj;
+                })(),
+                editor.file.dataComment,
+                null]);
+        }
+    }
+    //callback([obj,commentObj,err:String])
+
+    ////////////////////////////////////////////////////////////////////
+
+    var fmap = {};
+    var fjson = JSON.stringify(functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a, function (k, v) {
+        if (v instanceof Function) {
+            var id_ = editor.util.guid();
+            fmap[id_] = v.toString();
+            return id_;
+        } else return v
+    }, 4);
+    var fobj = JSON.parse(fjson);
+    editor.file.functionsMap = fmap;
+    editor.file.functionsJSON = fjson;
+    var buildlocobj = function (locObj) {
+        for (var key in locObj) {
+            if (typeof(locObj[key]) !== typeof('')) buildlocobj(locObj[key]);
+            else locObj[key] = fmap[locObj[key]];
+        }
+    };
+
+    editor.file.editFunctions = function (actionList, callback) {
+        /*actionList:[
+          ["change","['events']['afterChangeLight']","function(x,y){console.log(x,y)}"],
+          ["change","['ui']['drawAbout']","function(){...}"],
+        ]
+        为[]时只查询不修改
+        */
+        checkCallback(callback);
+        if (isset(actionList) && actionList.length > 0) {
+            saveSetting('functions', actionList, function (err) {
+                callback([err]);
+            });
+        } else {
+            callback([
+                (function () {
+                    var locObj = JSON.parse(fjson);
+                    buildlocobj(locObj);
+                    return locObj;
+                })(),
+                editor.file.functionsComment,
+                null]);
+        }
+    }
+    //callback([obj,commentObj,err:String])
+
+    ////////////////////////////////////////////////////////////////////
+
+    editor.file.editCommonEvent = function (actionList, callback) {
+        /*actionList:[
+          ["change","['test']",['123']],
+        ]
+        为[]时只查询不修改
+        */
+        var data_obj = events_c12a15a8_c380_4b28_8144_256cba95f760.commonEvent;
+        checkCallback(callback);
+        if (isset(actionList) && actionList.length > 0) {
+            actionList.forEach(function (value) {
+                value[1] = "['commonEvent']" + value[1];
+            });
+            saveSetting('events', actionList, function (err) {
+                callback([err]);
+            });
+        } else {
+            callback([
+                Object.assign({},data_obj),
+                editor.file.eventsComment._data.commonEvent,
+                null]);
+        }
+    }
+    //callback([obj,commentObj,err:String])
+
+    ////////////////////////////////////////////////////////////////////
+
+    var plmap = {};
+    var pljson = JSON.stringify(plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1, function (k, v) {
+        if (v instanceof Function) {
+            var id_ = editor.util.guid();
+            plmap[id_] = v.toString();
+            return id_;
+        } else if(v===null){
+            var id_ = editor.util.guid();
+            plmap[id_] = null;
+            return id_;
+        } return v
+    }, 4);
+    var plobj = JSON.parse(pljson);
+    editor.file.pluginsMap = plmap;
+    editor.file.pluginsObj = plobj;
+    var buildpllocobj = function (locObj) {
+        for (var key in locObj) {
+            if (typeof(locObj[key]) !== typeof('')) buildpllocobj(locObj[key]);
+            else locObj[key] = plmap[locObj[key]];
+        }
+    };
+
+    editor.file.editPlugins = function (actionList, callback) {
+        /*actionList:[
+          ["change","['test']","function(x,y){console.log(x,y)}"],
+        ]
+        为[]时只查询不修改
+        */
+        checkCallback(callback);
+        if (isset(actionList) && actionList.length > 0) {
+            saveSetting('plugins', actionList, function (err) {
+                callback([err]);
+            });
+        } else {
+            callback([
+                (function () {
+                    var locObj = JSON.parse(JSON.stringify(plobj));
+                    buildpllocobj(locObj);
+                    return locObj;
+                })(),
+                editor.file.pluginsComment,
+                null]);
+        }
+    }
+    //callback([obj,commentObj,err:String])
+
+    ////////////////////////////////////////////////////////////////////
+
+    var isset = function (val) {
+        if (val == undefined || val == null) {
+            return false;
+        }
+        return true
+    }
+
+    var checkCallback=function(callback){
+        if (!isset(callback)) {
+            printe('未设置callback');
+            throw('未设置callback')
+        }
+    }
+
+    var formatMap = function (mapArr,trySimplify) {
+        if(!mapArr || JSON.stringify(mapArr)==JSON.stringify([]))return '';
+        if(trySimplify){
+            //检查是否是全0二维数组
+            var jsoncheck=JSON.stringify(mapArr).replace(/\D/g,'');
+            if(jsoncheck==Array(jsoncheck.length+1).join('0'))return '';
+        }
+        //把二维数组格式化
+        var formatArrStr = '';
+        var arr = JSON.stringify(mapArr).replace(/\s+/g, '').split('],[');
+        var si=mapArr.length-1,sk=mapArr[0].length-1;
+        for (var i = 0; i <= si; i++) {
+            var a = [];
+            formatArrStr += '    [';
+            if (i == 0 || i == si) a = arr[i].split(/\D+/).join(' ').trim().split(' ');
+            else a = arr[i].split(/\D+/);
+            for (var k = 0; k <= sk; k++) {
+                var num = parseInt(a[k]);
+                formatArrStr += Array(Math.max(4 - String(num).length, 0)).join(' ') + num + (k == sk ? '' : ',');
+            }
+            formatArrStr += ']' + (i == si ? '' : ',\n');
+        }
+        return formatArrStr;
+    }
+
+    var encode = editor.util.encode64
+
+    var alertWhenCompress = function(){
+        if(editor.useCompress===true){
+            editor.useCompress='alerted';
+            setTimeout("alert('当前游戏使用的是压缩文件,修改完成后请使用启动服务.exe->Js代码压缩工具重新压缩,或者把main.js的useCompress改成false来使用原始文件')",1000)
+        }
+    }
+
+    editor.file.save_icons_maps_items_enemys=function(callback){
+        var check=[]
+        saveSetting('icons',[],function(err){
+            if(err){callback(err);return;}
+            check.push('icons')
+            if(check.length==4)callback(null);
+        })
+        saveSetting('maps',[],function(err){
+            if(err){callback(err);return;}
+            check.push('maps')
+            if(check.length==4)callback(null);
+        })
+        saveSetting('items',[],function(err){
+            if(err){callback(err);return;}
+            check.push('items')
+            if(check.length==4)callback(null);
+        })
+        saveSetting('enemys',[],function(err){
+            if(err){callback(err);return;}
+            check.push('enemys')
+            if(check.length==4)callback(null);
+        })
+    }
+
+    var saveSetting = function (file, actionList, callback) {
+        //console.log(file);
+        //console.log(actionList);
+        alertWhenCompress();
+
+        if (file == 'icons') {
+            actionList.forEach(function (value) {
+                eval("icons_4665ee12_3a1f_44a4_bea3_0fccba634dc1" + value[1] + '=' + JSON.stringify(value[2]));
+            });
+            var datastr = 'var icons_4665ee12_3a1f_44a4_bea3_0fccba634dc1 = \n';
+            datastr += JSON.stringify(icons_4665ee12_3a1f_44a4_bea3_0fccba634dc1, null, '\t');
+            fs.writeFile('project/icons.js', encode(datastr), 'base64', function (err, data) {
+                callback(err);
+            });
+            return;
+        }
+        if (file == 'maps') {
+            actionList.forEach(function (value) {
+                eval("maps_90f36752_8815_4be8_b32b_d7fad1d0542e" + value[1] + '=' + JSON.stringify(value[2]));
+            });
+            var datastr = 'var maps_90f36752_8815_4be8_b32b_d7fad1d0542e = \n';
+            //datastr+=JSON.stringify(maps_90f36752_8815_4be8_b32b_d7fad1d0542e,null,4);
+
+            var emap = {};
+            var estr = JSON.stringify(maps_90f36752_8815_4be8_b32b_d7fad1d0542e, function (k, v) {
+                if (v.id != null) {
+                    var id_ = editor.util.guid();
+                    emap[id_] = JSON.stringify(v);
+                    return id_;
+                } else return v
+            }, '\t');
+            for (var id_ in emap) {
+                estr = estr.replace('"' + id_ + '"', emap[id_])
+            }
+            datastr += estr;
+
+            fs.writeFile('project/maps.js', encode(datastr), 'base64', function (err, data) {
+                callback(err);
+            });
+            return;
+        }
+        if (file == 'items') {
+            actionList.forEach(function (value) {
+                eval("items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a" + value[1] + '=' + JSON.stringify(value[2]));
+            });
+            var datastr = 'var items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a = \n';
+            datastr += JSON.stringify(items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a, null, '\t');
+            fs.writeFile('project/items.js', encode(datastr), 'base64', function (err, data) {
+                callback(err);
+            });
+            return;
+        }
+        if (file == 'enemys') {
+            actionList.forEach(function (value) {
+                eval("enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80" + value[1] + '=' + JSON.stringify(value[2]));
+            });
+            var datastr = 'var enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80 = \n';
+            var emap = {};
+            var estr = JSON.stringify(enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80, function (k, v) {
+                if (v.hp != null) {
+                    var id_ = editor.util.guid();
+                    emap[id_] = JSON.stringify(v);
+                    return id_;
+                } else return v
+            }, '\t');
+            for (var id_ in emap) {
+                estr = estr.replace('"' + id_ + '"', emap[id_])
+            }
+            datastr += estr;
+            fs.writeFile('project/enemys.js', encode(datastr), 'base64', function (err, data) {
+                callback(err);
+            });
+            return;
+        }
+        if (file == 'data') {
+            actionList.forEach(function (value) {
+                eval("data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d" + value[1] + '=' + JSON.stringify(value[2]));
+            });
+            if (data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.main.floorIds.indexOf(data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.firstData.floorId) < 0)
+                data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.firstData.floorId = data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.main.floorIds[0];
+            var datastr = 'var data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d = \n';
+            datastr += JSON.stringify(data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d, null, '\t');
+            fs.writeFile('project/data.js', encode(datastr), 'base64', function (err, data) {
+                callback(err);
+            });
+            return;
+        }
+        if (file == 'functions') {
+            actionList.forEach(function (value) {
+                eval("fmap[fobj" + value[1] + ']=' + JSON.stringify(value[2]));
+            });
+            var fraw = fjson;
+            for (var id_ in fmap) {
+                fraw = fraw.replace('"' + id_ + '"', fmap[id_])
+            }
+            var datastr = 'var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = \n';
+            datastr += fraw;
+            fs.writeFile('project/functions.js', encode(datastr), 'base64', function (err, data) {
+                callback(err);
+            });
+            return;
+        }
+        if (file == 'floorloc') {
+            actionList.forEach(function (value) {
+                // 检测null/undefined
+                if (value[2]==null)
+                    eval("delete editor.currentFloorData" + value[1]);
+                else
+                    eval("editor.currentFloorData" + value[1] + '=' + JSON.stringify(value[2]));
+            });
+            editor.file.saveFloorFile(callback);
+            return;
+        }
+        if (file == 'floors') {
+            actionList.forEach(function (value) {
+                eval("editor.currentFloorData" + value[1] + '=' + JSON.stringify(value[2]));
+            });
+            editor.file.saveFloorFile(callback);
+            return;
+        }
+        if (file == 'events') {
+            actionList.forEach(function (value) {
+                eval("events_c12a15a8_c380_4b28_8144_256cba95f760" + value[1] + '=' + JSON.stringify(value[2]));
+            });
+            var datastr = 'var events_c12a15a8_c380_4b28_8144_256cba95f760 = \n';
+            datastr += JSON.stringify(events_c12a15a8_c380_4b28_8144_256cba95f760, null, '\t');
+            fs.writeFile('project/events.js', encode(datastr), 'base64', function (err, data) {
+                callback(err);
+            });
+            return;
+        }
+        if (file == 'plugins') {
+            actionList.forEach(function (value) {
+                if(value[0]==='add'){
+                    eval("plobj" + value[1] + '=' + JSON.stringify(value[2]));
+                } else {
+                    eval("plmap[plobj" + value[1] + ']=' + JSON.stringify(value[2]));
+                }
+            });
+            var plraw = JSON.stringify(plobj,null,4);
+            for (var id_ in plmap) {
+                plraw = plraw.replace('"' + id_ + '"', plmap[id_])
+            }
+            var datastr = 'var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 = \n';
+            datastr += plraw;
+            fs.writeFile('project/plugins.js', encode(datastr), 'base64', function (err, data) {
+                callback(err);
+            });
+            return;
+        }
+        callback('出错了,要设置的文件名不识别');
+    }
+
+    return editor_file;
+}
+//editor_file = editor_file(editor);
\ No newline at end of file
diff --git a/_server/editor_game.js b/_server/editor_game.js
new file mode 100644
index 00000000..278dd67e
--- /dev/null
+++ b/_server/editor_game.js
@@ -0,0 +1,180 @@
+editor_game_wrapper = function (editor, main, core) {
+    // 原则上重构后只有此文件允许`\s(main|core)`形式的调用, 以及其初始化 editor_game_wrapper(editor, main, core)
+
+    editor_game = function () {
+        this.replacerRecord = {}
+    }
+
+
+    //////////////////// 修改数据相关 ////////////////////
+    // 三个 replacer 和 replacerRecord 暂时放在此处
+
+    editor_game.prototype.replacerForLoading = function (_key, value) {
+        var rmap = editor.game.replacerRecord;
+        if (value instanceof Function) {
+            var guid_ = editor.util.guid()
+            rmap[guid_] = value.toString()
+            return guid_
+        } else if (value === null) {
+            // 为了包含plugins的新建
+            var guid_ = editor.util.guid()
+            rmap[guid_] = null
+            return guid_
+        }
+        return value
+    }
+
+    editor_game.prototype.replacerForSaving = function (_key, value) {
+        var rmap = editor.game.replacerRecord;
+        if (rmap.hasOwnProperty(value)) {
+            return rmap[value]
+        }
+        return value
+    }
+
+    editor_game.prototype.getValue = function (field) {
+        var rmap = editor.game.replacerRecord;
+        var value = eval(field)
+        if (rmap.hasOwnProperty(oldval)) {
+            return rmap[value]
+        } else {
+            return value
+        }
+    }
+
+    editor_game.prototype.setValue = function (field, value) {
+        var rmap = editor.game.replacerRecord;
+        var oldval = eval(field)
+        if (rmap.hasOwnProperty(oldval)) {
+            rmap[value] = eval(value)
+        } else {
+            eval(field + '=' + value)
+        }
+    }
+
+    editor_game.prototype.replacerWithoutRecord = function (_key, value) {
+        if (value instanceof Function) {
+            return value.toString()
+        } else return value
+    }
+
+    editor_game.prototype.fixFunctionInGameData = function () {
+        var rf = editor.game.replacerWithoutRecord
+        core.floors = JSON.parse(JSON.stringify(core.floors, rf));
+        core.data = JSON.parse(JSON.stringify(core.data, rf));
+        data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d = JSON.parse(JSON.stringify(data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d, rf));
+    }
+
+    //////////////////// 加载游戏数据相关 ////////////////////
+
+    // 初始化数字与地图图块的对应
+    editor_game.prototype.idsInit = function (maps, icons) {
+        editor.ids = [0];
+        editor.indexs = [];
+        var MAX_NUM = 0;
+        var keys = Object.keys(maps_90f36752_8815_4be8_b32b_d7fad1d0542e);
+        for (var ii = 0; ii < keys.length; ii++) {
+            var v = ~~keys[ii];
+            if (v > MAX_NUM && v < core.icons.tilesetStartOffset) MAX_NUM = v;
+        }
+        editor.MAX_NUM = MAX_NUM;
+        var getInfoById = function (id) {
+            var block = maps.initBlock(0, 0, id);
+            if (Object.prototype.hasOwnProperty.call(block, 'event')) {
+                return block;
+            }
+        }
+        var point = 0;
+        for (var i = 0; i <= MAX_NUM; i++) {
+            var indexBlock = getInfoById(i);
+            editor.indexs[i] = [];
+            if (indexBlock) {
+                var id = indexBlock.event.id;
+                var indexId = indexBlock.id;
+                var allCls = Object.keys(icons);
+                if (i == 17) {
+                    editor.ids.push({ 'idnum': 17, 'id': id, 'images': 'terrains' });
+                    point++;
+                    editor.indexs[i].push(point);
+                    continue;
+                }
+                for (var j = 0; j < allCls.length; j++) {
+                    if (id in icons[allCls[j]]) {
+                        editor.ids.push({ 'idnum': indexId, 'id': id, 'images': allCls[j], 'y': icons[allCls[j]][id] });
+                        point++;
+                        editor.indexs[i].push(point);
+                    }
+                }
+            }
+        }
+        editor.indexs[0] = [0];
+
+        var startOffset = core.icons.tilesetStartOffset;
+        for (var i in core.tilesets) {
+            var imgName = core.tilesets[i];
+            var img = core.material.images.tilesets[imgName];
+            var width = Math.floor(img.width / 32), height = Math.floor(img.height / 32);
+            if (img.width % 32 || img.height % 32) {
+                alert(imgName + '的长或宽不是32的整数倍, 请修改后刷新页面');
+            }
+            if (img.width * img.height > 32 * 32 * 3000) {
+                alert(imgName + '上的图块数量超过了3000，请修改后刷新页面');
+            }
+            for (var id = startOffset; id < startOffset + width * height; id++) {
+                var x = (id - startOffset) % width, y = parseInt((id - startOffset) / width);
+                var indexBlock = getInfoById(id);
+                editor.ids.push({ 'idnum': id, 'id': indexBlock.event.id, 'images': imgName, "x": x, "y": y, isTile: true });
+                point++;
+                editor.indexs[id] = [point];
+            }
+            startOffset += core.icons.tilesetStartOffset;
+        }
+    }
+
+    // 获取当前地图
+    editor_game.prototype.fetchMapFromCore = function () {
+        var mapArray = core.maps.saveMap(core.status.floorId);
+        editor.map = mapArray.map(function (v) {
+            return v.map(function (v) {
+                var x = parseInt(v), y = editor.indexs[x];
+                if (y == null) {
+                    printe("素材数字" + x + "未定义。是不是忘了注册，或者接档时没有覆盖icons.js和maps.js？");
+                    y = [0];
+                }
+                return editor.ids[y[0]]
+            })
+        });
+        editor.currentFloorId = core.status.floorId;
+        editor.currentFloorData = core.floors[core.status.floorId];
+        for (var ii = 0, name; name = ['bgmap', 'fgmap'][ii]; ii++) {
+            var mapArray = editor.currentFloorData[name];
+            if (!mapArray || JSON.stringify(mapArray) == JSON.stringify([])) {//未设置或空数组
+                //与editor.map同形的全0
+                mapArray = eval('[' + Array(editor.map.length + 1).join('[' + Array(editor.map[0].length + 1).join('0,') + '],') + ']');
+            }
+            editor[name] = mapArray.map(function (v) {
+                return v.map(function (v) {
+                    var x = parseInt(v), y = editor.indexs[x];
+                    if (y == null) {
+                        printe("素材数字" + x + "未定义。是不是忘了注册，或者接档时没有覆盖icons.js和maps.js？");
+                        y = [0];
+                    }
+                    return editor.ids[y[0]]
+                })
+            });
+        }
+    }
+
+    // 获取地图列表
+    editor_game.prototype.getFloorFileList = function (callback) {
+        // callback([Array<String>,err:String])
+        editor.util.checkCallback(callback);
+        /* editor.fs.readdir('project/floors',function(err, data){
+          callback([data,err]);
+        }); */
+        callback([editor.core.floorIds, null]);
+    }
+
+    editor.constructor.prototype.game = new editor_game();
+}
+//editor_game_wrapper(editor);
\ No newline at end of file
diff --git a/_server/editor_mode.js b/_server/editor_mode.js
index 47ddbd94..8bf22dc9 100644
--- a/_server/editor_mode.js
+++ b/_server/editor_mode.js
@@ -4,13 +4,16 @@ editor_mode = function (editor) {
     function editor_mode() {
         this.ids = {
             'loc': 'left2',
-            'emenyitem': 'left3',
+            'enemyitem': 'left3',
             'floor': 'left4',
             'tower': 'left5',
             'functions': 'left8',
 
             'map': 'left',
             'appendpic': 'left1',
+
+            'commonevent': 'left9',
+            'plugins': 'left10',
         }
         this._ids = {}
         this.dom = {}
@@ -18,6 +21,7 @@ editor_mode = function (editor) {
         this.mode = '';
         this.info = {};
         this.appendPic = {};
+        this.doubleClickMode='change';
     }
 
     editor_mode.prototype.init = function (callback) {
@@ -34,157 +38,9 @@ editor_mode = function (editor) {
         if (Boolean(callback)) callback();
     }
 
-/////////////////////////////////////////////////////////////////////////////
-    editor_mode.prototype.objToTable_ = function (obj, commentObj) {
-        var outstr = ["\n<tr><td>条目</td><td>注释</td><td>值</td></tr>\n"];
-        var guids = [];
-        var defaultcobj = {
-            _type: 'textarea',
-            _data: '',
-            _string: function (args) {//object~[field,cfield,vobj,cobj]
-                var thiseval = args.vobj;
-                return (typeof(thiseval) === typeof('')) && thiseval[0] === '"';
-            },
-            _leaf: function (args) {//object~[field,cfield,vobj,cobj]
-                var thiseval = args.vobj;
-                if (thiseval == null || thiseval == undefined) return true;//null,undefined
-                if (typeof(thiseval) === typeof('')) return true;//字符串
-                if (Object.keys(thiseval).length === 0) return true;//数字,true,false,空数组,空对象
-                return false;
-            },
-        }
-        var recursionParse = function (pfield, pcfield, pvobj, pcobj) {
-            for (var ii in pvobj) {
-                var field = pfield + "['" + ii + "']";
-                var cfield = pcfield + "['_data']['" + ii + "']";
-                var vobj = pvobj[ii];
-                var cobj = null;
-                if (pcobj && pcobj['_data'] && pcobj['_data'][ii]) {
-                    cobj = Object.assign({}, defaultcobj, pcobj['_data'][ii]);
-                } else {
-                    if (pcobj && (pcobj['_data'] instanceof Function)) cobj = Object.assign({}, defaultcobj, pcobj['_data'](ii));
-                    else cobj = Object.assign({}, defaultcobj);
-                }
-                var args = {field: field, cfield: cfield, vobj: vobj, cobj: cobj}
-                if (cobj._leaf instanceof Function) cobj._leaf = cobj._leaf(args);
-                for (var key in cobj) {
-                    if (key === '_data') continue;
-                    if (cobj[key] instanceof Function) cobj[key] = cobj[key](args);
-                }
-                if (cobj._leaf) {
-                    var leafnode = editor_mode.objToTr_(obj, commentObj, field, cfield, vobj, cobj);
-                    outstr.push(leafnode[0]);
-                    guids.push(leafnode[1]);
-                } else {
-                    outstr.push(["<tr><td>----</td><td>----</td><td>", field, "</td></tr>\n"].join(''));
-                    recursionParse(field, cfield, vobj, cobj);
-                }
-            }
-        }
-        recursionParse("", "", obj, commentObj);
-        var checkRange = function (evalstr, thiseval) {
-            if (evalstr) {
-                return eval(evalstr);
-            }
-            return true;
-        }
-        var listen = function (guids) {
-            guids.forEach(function (guid) {
-                // tr>td[title=field]
-                //   >td[title=comment,cobj=cobj:json]
-                //   >td>div>input[value=thiseval]
-                var thisTr = document.getElementById(guid);
-                var input = thisTr.children[2].children[0].children[0];
-                var field = thisTr.children[0].getAttribute('title');
-                var cobj = JSON.parse(thisTr.children[1].getAttribute('cobj'));
-                input.onchange = function () {
-                    var node = thisTr.parentNode;
-                    while (!editor_mode._ids.hasOwnProperty(node.getAttribute('id'))) {
-                        node = node.parentNode;
-                    }
-                    editor_mode.onmode(editor_mode._ids[node.getAttribute('id')]);
-                    var thiseval = null;
-                    if (input.checked != null) input.value = input.checked;
-                    try {
-                        thiseval = JSON.parse(input.value);
-                    } catch (ee) {
-                        printe(field + ' : ' + ee);
-                        throw ee;
-                    }
-                    if (checkRange(cobj._range, thiseval)) {
-                        editor_mode.addAction(['change', field, thiseval]);
-                        editor_mode.onmode('save');//自动保存
-                    } else {
-                        printe(field + ' : 输入的值不合要求,请鼠标放置在注释上查看说明');
-                    }
-                }
-                var dblclickfunc=function () {
-                    if (cobj._type === 'event') editor_blockly.import(guid, {type: cobj._event});
-                    if (cobj._type === 'textarea') editor_multi.import(guid, {lint: cobj._lint, string: cobj._string});
-                }
-                input.ondblclick = dblclickfunc
-                var doubleClickCheck=[0];
-                thisTr.onclick = function(){
-                    var newClick = new Date().getTime();
-                    var lastClick = doubleClickCheck.shift();
-                    doubleClickCheck.push(newClick);
-                    if(newClick-lastClick<500){
-                        dblclickfunc()
-                    }
-                }
-            });
-        }
-        return {"HTML": outstr.join(''), "guids": guids, "listen": listen};
-    }
-
-    editor_mode.prototype.objToTr_ = function (obj, commentObj, field, cfield, vobj, cobj) {
-        var guid = editor.guid();
-        var thiseval = vobj;
-        var comment = cobj._data;
-
-        var charlength = 10;
-
-        var shortField = field.split("']").slice(-2)[0].split("['").slice(-1)[0];
-        shortField = (shortField.length < charlength ? shortField : shortField.slice(0, charlength) + '...');
-
-        var commentHTMLescape = editor.HTMLescape(comment);
-        var shortCommentHTMLescape = (comment.length < charlength ? commentHTMLescape : editor.HTMLescape(comment.slice(0, charlength)) + '...');
-
-        var cobjstr = Object.assign({}, cobj);
-        delete cobjstr._data;
-        cobjstr = editor.HTMLescape(JSON.stringify(cobjstr));
-
-        var outstr = ['<tr id="', guid, '"><td title="', field, '">', shortField, '</td>',
-            '<td title="', commentHTMLescape, '" cobj="', cobjstr, '">', shortCommentHTMLescape, '</td>',
-            '<td><div class="etableInputDiv">', editor_mode.objToTd_(obj, commentObj, field, cfield, vobj, cobj), '</div></td></tr>\n',
-        ];
-        return [outstr.join(''), guid];
-    }
-
-    editor_mode.prototype.objToTd_ = function (obj, commentObj, field, cfield, vobj, cobj) {
-        var thiseval = vobj;
-        if (cobj._select) {
-            var values = cobj._select.values;
-            var outstr = ['<select>\n', "<option value='", JSON.stringify(thiseval), "'>", JSON.stringify(thiseval), '</option>\n'];
-            values.forEach(function (v) {
-                outstr.push(["<option value='", JSON.stringify(v), "'>", JSON.stringify(v), '</option>\n'].join(''))
-            });
-            outstr.push('</select>');
-            return outstr.join('');
-        } else if (cobj._input) {
-            return ["<input type='text' spellcheck='false' value='", JSON.stringify(thiseval), "'/>\n"].join('');
-        } else if (cobj._bool) {
-            return ["<input type='checkbox' ", (thiseval ? 'checked ' : ''), "/>\n"].join('');
-        } else {
-            var num = 0;//editor_mode.indent(field);
-            return ["<textarea spellcheck='false' >", JSON.stringify(thiseval, null, num), '</textarea>\n'].join('');
-        }
-    }
-
     editor_mode.prototype.indent = function (field) {
         var num = '\t';
         if (field.indexOf("['main']") === 0) return 0;
-        if (field.indexOf("['flyRange']") !== -1) return 0;
         if (field === "['special']") return 0;
         return num;
     }
@@ -196,75 +52,43 @@ editor_mode = function (editor) {
     editor_mode.prototype.doActionList = function (mode, actionList) {
         if (actionList.length == 0) return;
         printf('修改中...');
+        var cb=function(objs_){
+            if (objs_.slice(-1)[0] != null) {
+                printe(objs_.slice(-1)[0]);
+                throw(objs_.slice(-1)[0])
+            }
+            ;printf('修改成功');
+        }
         switch (mode) {
             case 'loc':
-
-                editor.file.editLoc(editor_mode.pos.x, editor_mode.pos.y, actionList, function (objs_) {/*console.log(objs_);*/
-                    if (objs_.slice(-1)[0] != null) {
-                        printe(objs_.slice(-1)[0]);
-                        throw(objs_.slice(-1)[0])
-                    }
-                    ;printf('修改成功');
-                    editor.drawEventBlock();
+                editor.file.editLoc(editor_mode.pos.x, editor_mode.pos.y, actionList, function (objs_) {
+                    cb(objs_);
+                    editor.drawPosSelection();
                 });
                 break;
-            case 'emenyitem':
-
+            case 'enemyitem':
                 if (editor_mode.info.images == 'enemys' || editor_mode.info.images == 'enemy48') {
-                    editor.file.editEnemy(editor_mode.info.id, actionList, function (objs_) {/*console.log(objs_);*/
-                        if (objs_.slice(-1)[0] != null) {
-                            printe(objs_.slice(-1)[0]);
-                            throw(objs_.slice(-1)[0])
-                        }
-                        ;printf('修改成功')
-                    });
+                    editor.file.editEnemy(editor_mode.info.id, actionList, cb);
                 } else if (editor_mode.info.images == 'items') {
-                    editor.file.editItem(editor_mode.info.id, actionList, function (objs_) {/*console.log(objs_);*/
-                        if (objs_.slice(-1)[0] != null) {
-                            printe(objs_.slice(-1)[0]);
-                            throw(objs_.slice(-1)[0])
-                        }
-                        ;printf('修改成功')
-                    });
+                    editor.file.editItem(editor_mode.info.id, actionList, cb);
                 } else {
-                    editor.file.editMapBlocksInfo(editor_mode.info.idnum, actionList, function (objs_) {/*console.log(objs_);*/
-                        if (objs_.slice(-1)[0] != null) {
-                            printe(objs_.slice(-1)[0]);
-                            throw(objs_.slice(-1)[0])
-                        }
-                        ;printf('修改成功');
-                    });
+                    editor.file.editMapBlocksInfo(editor_mode.info.idnum, actionList, cb);
                 }
                 break;
             case 'floor':
-
-                editor.file.editFloor(actionList, function (objs_) {/*console.log(objs_);*/
-                    if (objs_.slice(-1)[0] != null) {
-                        printe(objs_.slice(-1)[0]);
-                        throw(objs_.slice(-1)[0])
-                    }
-                    ;printf('修改成功');
-                });
+                editor.file.editFloor(actionList, cb);
                 break;
             case 'tower':
-
-                editor.file.editTower(actionList, function (objs_) {/*console.log(objs_);*/
-                    if (objs_.slice(-1)[0] != null) {
-                        printe(objs_.slice(-1)[0]);
-                        throw(objs_.slice(-1)[0])
-                    }
-                    ;printf('修改成功')
-                });
+                editor.file.editTower(actionList, cb);
                 break;
             case 'functions':
-
-                editor.file.editFunctions(actionList, function (objs_) {/*console.log(objs_);*/
-                    if (objs_.slice(-1)[0] != null) {
-                        printe(objs_.slice(-1)[0]);
-                        throw(objs_.slice(-1)[0])
-                    }
-                    ;printf('修改成功')
-                });
+                editor.file.editFunctions(actionList, cb);
+                break;
+            case 'commonevent':
+                editor.file.editCommonEvent(actionList, cb);
+                break;
+            case 'plugins':
+                editor.file.editPlugins(actionList, cb);
                 break;
             default:
                 break;
@@ -275,7 +99,7 @@ editor_mode = function (editor) {
         if (editor_mode.mode != mode) {
             if (mode === 'save') editor_mode.doActionList(editor_mode.mode, editor_mode.actionList);
             if (editor_mode.mode === 'nextChange' && mode) editor_mode.showMode(mode);
-            editor_mode.mode = mode;
+            if (mode !== 'save') editor_mode.mode = mode;
             editor_mode.actionList = [];
         }
     }
@@ -285,10 +109,13 @@ editor_mode = function (editor) {
             editor_mode.dom[name].style = 'z-index:-1;opacity: 0;';
         }
         editor_mode.dom[mode].style = '';
+        editor_mode.doubleClickMode='change';
+        // clear
+        editor.drawEventBlock();
         if (editor_mode[mode]) editor_mode[mode]();
         document.getElementById('editModeSelect').value = mode;
         var tips = tip_in_showMode;
-        if (!selectBox.isSelected) printf('tips: ' + tips[~~(tips.length * Math.random())]);
+        if (!selectBox.isSelected()) printf('tips: ' + tips[~~(tips.length * Math.random())]);
     }
 
     editor_mode.prototype.loc = function (callback) {
@@ -300,52 +127,55 @@ editor_mode = function (editor) {
         var objs = [];
         editor.file.editLoc(editor_mode.pos.x, editor_mode.pos.y, [], function (objs_) {
             objs = objs_;
-            /*console.log(objs_)*/
+            //console.log(objs_)
         });
         //只查询不修改时,内部实现不是异步的,所以可以这么写
-        var tableinfo = editor_mode.objToTable_(objs[0], objs[1]);
+        var tableinfo = editor.table.objToTable(objs[0], objs[1]);
         document.getElementById('table_3d846fc4_7644_44d1_aa04_433d266a73df').innerHTML = tableinfo.HTML;
         tableinfo.listen(tableinfo.guids);
-
+        editor.drawPosSelection();
         if (Boolean(callback)) callback();
     }
 
-    editor_mode.prototype.emenyitem = function (callback) {
+    editor_mode.prototype.enemyitem = function (callback) {
         //editor.info=editor.ids[editor.indexs[201]];
         if (!core.isset(editor.info)) return;
 
-        if (Object.keys(editor.info).length !== 0) editor_mode.info = editor.info;//避免editor.info被清空导致无法获得是物品还是怪物
+        if (Object.keys(editor.info).length !== 0 && editor.info.idnum!=17) editor_mode.info = editor.info;//避免editor.info被清空导致无法获得是物品还是怪物
 
         if (!core.isset(editor_mode.info.id)) {
             // document.getElementById('table_a3f03d4c_55b8_4ef6_b362_b345783acd72').innerHTML = '';
-            document.getElementById('enemyItemTable').style.display = 'none';
             document.getElementById('newIdIdnum').style.display = 'block';
+            document.getElementById('enemyItemTable').style.display = 'none';
+            document.getElementById('changeId').style.display = 'none';
             return;
         }
+
         document.getElementById('newIdIdnum').style.display = 'none';
         document.getElementById('enemyItemTable').style.display = 'block';
+        document.getElementById('changeId').style.display = 'block';
 
         var objs = [];
         if (editor_mode.info.images == 'enemys' || editor_mode.info.images == 'enemy48') {
             editor.file.editEnemy(editor_mode.info.id, [], function (objs_) {
                 objs = objs_;
-                /*console.log(objs_)*/
+                //console.log(objs_)
             });
         } else if (editor_mode.info.images == 'items') {
             editor.file.editItem(editor_mode.info.id, [], function (objs_) {
                 objs = objs_;
-                /*console.log(objs_)*/
+                //console.log(objs_)
             });
         } else {
             /* document.getElementById('table_a3f03d4c_55b8_4ef6_b362_b345783acd72').innerHTML='';
             return; */
             editor.file.editMapBlocksInfo(editor_mode.info.idnum, [], function (objs_) {
                 objs = objs_;
-                /*console.log(objs_)*/
+                //console.log(objs_)
             });
         }
         //只查询不修改时,内部实现不是异步的,所以可以这么写
-        var tableinfo = editor_mode.objToTable_(objs[0], objs[1]);
+        var tableinfo = editor.table.objToTable(objs[0], objs[1]);
         document.getElementById('table_a3f03d4c_55b8_4ef6_b362_b345783acd72').innerHTML = tableinfo.HTML;
         tableinfo.listen(tableinfo.guids);
 
@@ -356,10 +186,10 @@ editor_mode = function (editor) {
         var objs = [];
         editor.file.editFloor([], function (objs_) {
             objs = objs_;
-            /*console.log(objs_)*/
+            //console.log(objs_)
         });
         //只查询不修改时,内部实现不是异步的,所以可以这么写
-        var tableinfo = editor_mode.objToTable_(objs[0], objs[1]);
+        var tableinfo = editor.table.objToTable(objs[0], objs[1]);
         document.getElementById('table_4a3b1b09_b2fb_4bdf_b9ab_9f4cdac14c74').innerHTML = tableinfo.HTML;
         tableinfo.listen(tableinfo.guids);
         if (Boolean(callback)) callback();
@@ -369,10 +199,10 @@ editor_mode = function (editor) {
         var objs = [];
         editor.file.editTower([], function (objs_) {
             objs = objs_;
-            /*console.log(objs_)*/
+            //console.log(objs_)
         });
         //只查询不修改时,内部实现不是异步的,所以可以这么写
-        var tableinfo = editor_mode.objToTable_(objs[0], objs[1]);
+        var tableinfo = editor.table.objToTable(objs[0], objs[1]);
         document.getElementById('table_b6a03e4c_5968_4633_ac40_0dfdd2c9cde5').innerHTML = tableinfo.HTML;
         tableinfo.listen(tableinfo.guids);
         if (Boolean(callback)) callback();
@@ -382,274 +212,46 @@ editor_mode = function (editor) {
         var objs = [];
         editor.file.editFunctions([], function (objs_) {
             objs = objs_;
-            /*console.log(objs_)*/
+            //console.log(objs_)
         });
         //只查询不修改时,内部实现不是异步的,所以可以这么写
-        var tableinfo = editor_mode.objToTable_(objs[0], objs[1]);
+        var tableinfo = editor.table.objToTable(objs[0], objs[1]);
         document.getElementById('table_e260a2be_5690_476a_b04e_dacddede78b3').innerHTML = tableinfo.HTML;
         tableinfo.listen(tableinfo.guids);
         if (Boolean(callback)) callback();
     }
 
+    editor_mode.prototype.commonevent = function (callback) {
+        var objs = [];
+        editor.file.editCommonEvent([], function (objs_) {
+            objs = objs_;
+            //console.log(objs_)
+        });
+        //只查询不修改时,内部实现不是异步的,所以可以这么写
+        var tableinfo = editor.table.objToTable(objs[0], objs[1]);
+        document.getElementById('table_b7bf0124_99fd_4af8_ae2f_0017f04a7c7d').innerHTML = tableinfo.HTML;
+        tableinfo.listen(tableinfo.guids);
+        if (Boolean(callback)) callback();
+    }
+    
+    editor_mode.prototype.plugins = function (callback) {
+        var objs = [];
+        editor.file.editPlugins([], function (objs_) {
+            objs = objs_;
+            //console.log(objs_)
+        });
+        //只查询不修改时,内部实现不是异步的,所以可以这么写
+        var tableinfo = editor.table.objToTable(objs[0], objs[1]);
+        document.getElementById('table_e2c034ec_47c6_48ae_8db8_4f8f32fea2d6').innerHTML = tableinfo.HTML;
+        tableinfo.listen(tableinfo.guids);
+        if (Boolean(callback)) callback();
+    }
+
 /////////////////////////////////////////////////////////////////////////////
 
     editor_mode.prototype.listen = function (callback) {
 
-        var newIdIdnum = document.getElementById('newIdIdnum');
-        newIdIdnum.children[2].onclick = function () {
-            if (newIdIdnum.children[0].value && newIdIdnum.children[1].value) {
-                var id = newIdIdnum.children[0].value;
-                var idnum = parseInt(newIdIdnum.children[1].value);
-                if (!core.isset(idnum)) {
-                    printe('不合法的idnum');
-                    return;
-                }
-                if (!/^[0-9a-zA-Z_]+$/.test(id)) {
-                    printe('不合法的id，请使用字母、数字或下划线')
-                    return;
-                }
-                editor.file.changeIdAndIdnum(id, idnum, editor_mode.info, function (err) {
-                    if (err) {
-                        printe(err);
-                        throw(err)
-                    }
-                    printe('添加id的idnum成功,请F5刷新编辑器');
-                });
-            } else {
-                printe('请输入id和idnum');
-            }
-        }
-
-        newIdIdnum.children[4].onclick = function () {
-            editor.file.autoRegister(editor_mode.info, function (err) {
-                if (err) {
-                    printe(err);
-                    throw(err)
-                }
-                printe('该列所有剩余项全部自动注册成功,请F5刷新编辑器');
-            })
-        }
-
-        var selectFloor = document.getElementById('selectFloor');
-        editor.file.getFloorFileList(function (floors) {
-            var outstr = [];
-            floors[0].forEach(function (floor) {
-                outstr.push(["<option value='", floor, "'>", floor, '</option>\n'].join(''));
-            });
-            selectFloor.innerHTML = outstr.join('');
-            selectFloor.value = core.status.floorId;
-            selectFloor.onchange = function () {
-                editor_mode.onmode('nextChange');
-                editor_mode.onmode('floor');
-                editor.changeFloor(selectFloor.value);
-            }
-        });
-
-        var saveFloor = document.getElementById('saveFloor');
-        saveFloor.onclick = function () {
-            editor_mode.onmode('');
-            editor.file.saveFloorFile(function (err) {
-                if (err) {
-                    printe(err);
-                    throw(err)
-                }
-                ;printf('保存成功');
-            });
-        }
-
-        var newMap = document.getElementById('newMap');
-        var newFileName = document.getElementById('newFileName');
-        newMap.onclick = function () {
-            if (!newFileName.value) return;
-            if (core.floorIds.indexOf(newFileName.value)>=0) {
-                printe("该楼层已存在！");
-                return;
-            }
-            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(newFileName.value)) {
-                printe("楼层名不合法！请使用字母、数字、下划线，且不能以数字开头！");
-                return;
-            }
-            var width = parseInt(document.getElementById('newMapWidth').value);
-            var height = parseInt(document.getElementById('newMapHeight').value);
-            if (!core.isset(width) || !core.isset(height) || width<13 || height<13 || width*height>1000) {
-                printe("新建地图的宽高都不得小于13，且宽高之积不能超过1000");
-                return;
-            }
-
-            editor_mode.onmode('');
-            editor.file.saveNewFile(newFileName.value, function (err) {
-                if (err) {
-                    printe(err);
-                    throw(err)
-                }
-                core.floorIds.push(newFileName.value);
-                editor.file.editTower([['change', "['main']['floorIds']", core.floorIds]], function (objs_) {/*console.log(objs_);*/
-                    if (objs_.slice(-1)[0] != null) {
-                        printe(objs_.slice(-1)[0]);
-                        throw(objs_.slice(-1)[0])
-                    }
-                    ;printe('新建成功,请F5刷新编辑器生效');
-                });
-            });
-        }
-
-        var ratio = 1;
-        var appendPicCanvas = document.getElementById('appendPicCanvas');
-        var bg = appendPicCanvas.children[0];
-        var source = appendPicCanvas.children[1];
-        var picClick = appendPicCanvas.children[2];
-        var sprite = appendPicCanvas.children[3];
-        var appendPicSelection = document.getElementById('appendPicSelection');
-
-        var selectAppend = document.getElementById('selectAppend');
-        var selectAppend_str = [];
-        ["terrains", "animates", "enemys", "enemy48", "items", "npcs", "npc48"].forEach(function (image) {
-            selectAppend_str.push(["<option value='", image, "'>", image, '</option>\n'].join(''));
-        });
-        selectAppend.innerHTML = selectAppend_str.join('');
-        selectAppend.onchange = function () {
-            var value = selectAppend.value;
-            var ysize = selectAppend.value.indexOf('48') === -1 ? 32 : 48;
-            editor_mode.appendPic.imageName = value;
-            var img = editor.material.images[value];
-            editor_mode.appendPic.toImg = img;
-            var num = ~~img.width / 32;
-            editor_mode.appendPic.num = num;
-            editor_mode.appendPic.index = 0;
-            var selectStr = '';
-            for (var ii = 0; ii < num; ii++) {
-                appendPicSelection.children[ii].style = 'left:0;top:0;height:' + (ysize - 6) + 'px';
-                selectStr += '{"x":0,"y":0},'
-            }
-            editor_mode.appendPic.selectPos = eval('[' + selectStr + ']');
-            for (var jj = num; jj < 4; jj++) {
-                appendPicSelection.children[jj].style = 'display:none';
-            }
-            sprite.style.width = (sprite.width = img.width) / ratio + 'px';
-            sprite.style.height = (sprite.height = img.height + ysize) / ratio + 'px';
-            sprite.getContext('2d').drawImage(img, 0, 0);
-        }
-        selectAppend.onchange();
-
-        var selectFileBtn = document.getElementById('selectFileBtn');
-        selectFileBtn.onclick = function () {
-            var loadImage = function (content, callback) {
-                var image = new Image();
-                try {
-                    image.src = content;
-                    if (image.complete) {
-                        callback(image);
-                        return;
-                    }
-                    image.onload = function () {
-                        callback(image);
-                    }
-                }
-                catch (e) {
-                    printe(e);
-                }
-            }
-            core.readFile(function (content) {
-                loadImage(content, function (image) {
-                    editor_mode.appendPic.img = image;
-                    editor_mode.appendPic.width = image.width;
-                    editor_mode.appendPic.height = image.height;
-                    var ysize = selectAppend.value.indexOf('48') === -1 ? 32 : 48;
-                    for (var ii = 0; ii < 3; ii++) {
-                        var newsprite = appendPicCanvas.children[ii];
-                        newsprite.style.width = (newsprite.width = Math.floor(image.width / 32) * 32) / ratio + 'px';
-                        newsprite.style.height = (newsprite.height = Math.floor(image.height / ysize) * ysize) / ratio + 'px';
-                    }
-
-                    //画灰白相间的格子
-                    var bgc = bg.getContext('2d');
-                    var colorA = ["#f8f8f8", "#cccccc"];
-                    var colorIndex;
-                    var sratio = 4;
-                    for (var ii = 0; ii < image.width / 32 * sratio; ii++) {
-                        colorIndex = 1 - ii % 2;
-                        for (var jj = 0; jj < image.height / 32 * sratio; jj++) {
-                            bgc.fillStyle = colorA[colorIndex];
-                            colorIndex = 1 - colorIndex;
-                            bgc.fillRect(ii * 32 / sratio, jj * 32 / sratio, 32 / sratio, 32 / sratio);
-                        }
-                    }
-
-                    //把导入的图片画出
-                    source.getContext('2d').drawImage(image, 0, 0);
-
-                    //重置临时变量
-                    selectAppend.onchange();
-                });
-            }, null, 'img');
-
-            return;
-        }
-
-        var left1 = document.getElementById('left1');
-        var eToLoc = function (e) {
-            var scrollLeft = document.documentElement.scrollLeft || document.body.scrollLeft
-            var scrollTop = document.documentElement.scrollTop || document.body.scrollTop
-            var loc = {
-                'x': scrollLeft + e.clientX + appendPicCanvas.scrollLeft - left1.offsetLeft - appendPicCanvas.offsetLeft,
-                'y': scrollTop + e.clientY + appendPicCanvas.scrollTop - left1.offsetTop - appendPicCanvas.offsetTop,
-                'size': 32,
-                'ysize': selectAppend.value.indexOf('48') === -1 ? 32 : 48
-            };
-            return loc;
-        }//返回可用的组件内坐标
-
-        var locToPos = function (loc) {
-            var pos = {'x': ~~(loc.x / loc.size), 'y': ~~(loc.y / loc.ysize), 'ysize': loc.ysize}
-            return pos;
-        }
-
-        picClick.onclick = function (e) {
-            var loc = eToLoc(e);
-            var pos = locToPos(loc);
-            /*console.log(e,loc,pos);*/
-            var num = editor_mode.appendPic.num;
-            var ii = editor_mode.appendPic.index;
-            if (ii + 1 >= num) editor_mode.appendPic.index = ii + 1 - num;
-            else editor_mode.appendPic.index++;
-            editor_mode.appendPic.selectPos[ii] = pos;
-            appendPicSelection.children[ii].style = [
-                'left:', pos.x * 32, 'px;',
-                'top:', pos.y * pos.ysize, 'px;',
-                'height:', pos.ysize - 6, 'px;'
-            ].join('');
-        }
-
-        var appendConfirm = document.getElementById('appendConfirm');
-        appendConfirm.onclick = function () {
-            var ysize = selectAppend.value.indexOf('48') === -1 ? 32 : 48;
-            var sprited = sprite.getContext('2d');
-            //sprited.drawImage(img, 0, 0);
-            var height = editor_mode.appendPic.toImg.height;
-            var sourced = source.getContext('2d');
-            for (var ii = 0, v; v = editor_mode.appendPic.selectPos[ii]; ii++) {
-                // var imgData = sourced.getImageData(v.x * 32, v.y * ysize, 32, ysize);
-                // sprited.putImageData(imgData, ii * 32, height);
-                sprited.drawImage(editor_mode.appendPic.img, v.x * 32, v.y * ysize, 32, ysize,  ii * 32, height,  32, ysize)
-            }
-            var imgbase64 = sprite.toDataURL().split(',')[1];
-            fs.writeFile('./project/images/' + editor_mode.appendPic.imageName + '.png', imgbase64, 'base64', function (err, data) {
-                if (err) {
-                    printe(err);
-                    throw(err)
-                }
-                printe('追加素材成功,请F5刷新编辑器');
-            });
-        }
-
-        var editModeSelect = document.getElementById('editModeSelect');
-        editModeSelect.onchange = function () {
-            editor_mode.onmode('nextChange');
-            editor_mode.onmode(editModeSelect.value);
-            if(editor.isMobile)editor.showdataarea(false);
-        }
-
-        if (Boolean(callback)) callback();
+        // 移动至 editor_unsorted_2.js
     }
 
     var editor_mode = new editor_mode();
diff --git a/_server/editor_multi.js b/_server/editor_multi.js
index 2c426991..476536bb 100644
--- a/_server/editor_multi.js
+++ b/_server/editor_multi.js
@@ -1,3 +1,5 @@
+
+
 editor_multi = function () {
 
     var editor_multi = {};
@@ -9,22 +11,24 @@ editor_multi = function () {
         tabSize: 4,
         indentWithTabs: true,
         smartIndent: true,
-        mode: {name: "javascript", globalVars: true, localVars: true},
+        mode: { name: "javascript", globalVars: true, localVars: true },
         lineWrapping: true,
         continueComments: "Enter",
         gutters: ["CodeMirror-lint-markers"],
         lint: true,
         autocomplete: true,
         autoCloseBrackets: true,
-        highlightSelectionMatches: {showToken: /\w/, annotateScrollbar: true}
+        highlightSelectionMatches: { showToken: /\w/, annotateScrollbar: true }
     });
 
+    editor_multi.codeEditor = codeEditor;
+
     codeEditor.on("keyup", function (cm, event) {
         if (codeEditor.getOption("autocomplete") && !event.ctrlKey && (
             (event.keyCode >= 65 && event.keyCode <= 90) ||
-                (!event.shiftKey && event.keyCode == 190) || (event.shiftKey && event.keyCode == 189))){
+            (!event.shiftKey && event.keyCode == 190) || (event.shiftKey && event.keyCode == 189))) {
             try {
-                CodeMirror.commands.autocomplete(cm, null, {completeSingle: false});
+                CodeMirror.commands.autocomplete(cm, null, { completeSingle: false });
             } catch (e) {
             }
         }
@@ -35,7 +39,7 @@ editor_multi = function () {
     editor_multi.lintAutocomplete = false;
 
     editor_multi.show = function () {
-        if (typeof(selectBox) !== typeof(undefined)) selectBox.isSelected = false;
+        if (typeof (selectBox) !== typeof (undefined)) selectBox.isSelected(false);
         var valueNow = codeEditor.getValue();
         //try{eval('function _asdygakufyg_() { return '+valueNow+'\n}');editor_multi.lintAutocomplete=true;}catch(ee){}
         if (valueNow.slice(0, 8) === 'function') editor_multi.lintAutocomplete = true;
@@ -56,10 +60,28 @@ editor_multi = function () {
     }
 
     editor_multi.indent = function (field) {
-        if (typeof(editor) !== typeof(undefined) && editor && editor.mode && editor.mode.indent) return editor.mode.indent(field);
+        if (typeof (editor) !== typeof (undefined) && editor && editor.mode && editor.mode.indent) return editor.mode.indent(field);
         return '\t';
     }
 
+    var _format = function () {
+        if (!editor_multi.lintAutocomplete) return;
+        codeEditor.setValue(js_beautify(codeEditor.getValue(), {
+            brace_style: "collapse-preserve-inline",
+            indent_with_tabs: true,
+            jslint_happy: true
+        }));
+    }
+
+    editor_multi.format = function () {
+        if (!editor_multi.lintAutocomplete) {
+            alert("只有代码才能进行格式化操作！");
+            return;
+        }
+        _format();
+    }
+
+
     editor_multi.import = function (id_, args) {
         var thisTr = document.getElementById(id_);
         if (!thisTr) return false;
@@ -80,8 +102,8 @@ editor_multi = function () {
             eval('var tobj=' + (input.value || 'null'));
             var tmap = {};
             var tstr = JSON.stringify(tobj, function (k, v) {
-                if (typeof(v) === typeof('') && v.slice(0, 8) === 'function') {
-                    var id_ = editor.guid();
+                if (typeof (v) === typeof ('') && v.slice(0, 8) === 'function') {
+                    var id_ = editor.util.guid();
                     tmap[id_] = v.toString();
                     return id_;
                 } else return v
@@ -106,11 +128,22 @@ editor_multi = function () {
             editor_multi.id = '';
             return;
         }
+
         if (editor_multi.id === 'callFromBlockly') {
+            // ----- 自动格式化
+            _format();
             editor_multi.id = '';
             editor_multi.multiLineDone();
             return;
         }
+
+        if (editor_multi.id === 'importFile') {
+            _format();
+            editor_multi.id = '';
+            editor_multi.writeFileDone();
+            return;
+        }
+
         var setvalue = function (value) {
             var thisTr = document.getElementById(editor_multi.id);
             editor_multi.id = '';
@@ -122,7 +155,7 @@ editor_multi = function () {
                 var tmap = {};
                 var tstr = JSON.stringify(tobj, function (k, v) {
                     if (v instanceof Function) {
-                        var id_ = editor.guid();
+                        var id_ = editor.util.guid();
                         tmap[id_] = v.toString();
                         return id_;
                     } else return v
@@ -135,6 +168,8 @@ editor_multi = function () {
             editor_multi.hide();
             input.onchange();
         }
+        // ----- 自动格式化
+        _format();
         setvalue(codeEditor.getValue() || '');
     }
 
@@ -155,6 +190,49 @@ editor_multi = function () {
         multiLineArgs[2](newvalue, multiLineArgs[0], multiLineArgs[1])
     }
 
+    var _fileValues = ['']
+    editor_multi.importFile = function (filename) {
+        editor_multi.id = 'importFile'
+        _fileValues[0] = filename
+        codeEditor.setValue('loading')
+        editor_multi.show();
+        fs.readFile(filename, 'base64', function (e, d) {
+            if (e) {
+                codeEditor.setValue('加载文件失败:\n' + e)
+                editor_multi.id = ''
+                return;
+            }
+            var str = editor.util.decode64(d)
+            codeEditor.setValue(str)
+            _fileValues[1] = str
+        })
+    }
+
+    editor_multi.writeFileDone = function () {
+        fs.writeFile(_fileValues[0], editor.util.encode64(codeEditor.getValue() || ''), 'base64', function (err, data) {
+            if (err) printe('文件写入失败,请手动粘贴至' + _fileValues[0] + '\n' + err);
+            else {
+                editor_multi.hide();
+                printf(_fileValues[0] + " 写入成功，F5刷新后生效");
+            }
+        });
+    }
+
+    editor_multi.editCommentJs = function (mod) {
+        var dict = {
+            loc: '_server/table/comment.js',
+            enemyitem: '_server/table/comment.js',
+            floor: '_server/table/comment.js',
+            tower: '_server/table/data.comment.js',
+            functions: '_server/table/functions.comment.js',
+            commonevent: '_server/table/events.comment.js',
+            plugins: '_server/table/plugins.comment.js',
+        }
+        editor_multi.lintAutocomplete = true
+        editor_multi.setLint()
+        editor_multi.importFile(dict[mod])
+    }
+
     return editor_multi;
 }
 //editor_multi=editor_multi();
\ No newline at end of file
diff --git a/_server/editor_table.js b/_server/editor_table.js
new file mode 100644
index 00000000..e141e5ff
--- /dev/null
+++ b/_server/editor_table.js
@@ -0,0 +1,383 @@
+editor_table_wrapper = function (editor) {
+
+    editor_table = function () {
+
+    }
+
+    /////////////////////////////////////////////////////////////////////////////
+    // HTML模板
+
+    editor_table.prototype.select = function (value, values) {
+        let content = editor.table.option(value) +
+            values.map(function (v) {
+                return editor.table.option(v)
+            }).join('')
+        return /* html */`<select>\n${content}</select>\n`
+    }
+    editor_table.prototype.option = function (value) {
+        return /* html */`<option value='${JSON.stringify(value)}'>${JSON.stringify(value)}</option>\n`
+    }
+    editor_table.prototype.text = function (value) {
+        return /* html */`<input type='text' spellcheck='false' value='${JSON.stringify(value)}'/>\n`
+    }
+    editor_table.prototype.checkbox = function (value) {
+        return /* html */`<input type='checkbox' ${(value ? 'checked ' : '')}/>\n`
+    }
+    editor_table.prototype.textarea = function (value, indent) {
+        return /* html */`<textarea spellcheck='false'>${JSON.stringify(value, null, indent || 0)}</textarea>\n`
+    }
+
+    editor_table.prototype.title = function () {
+        return /* html */`\n<tr><td>条目</td><td>注释</td><td>值</td></tr>\n`
+    }
+
+    editor_table.prototype.gap = function (field) {
+        return /* html */`<tr><td>----</td><td>----</td><td>${field}</td></tr>\n`
+    }
+
+    editor_table.prototype.tr = function (guid, field, shortField, commentHTMLescape, cobjstr, shortCommentHTMLescape, tdstr) {
+        return /* html */`<tr id="${guid}">
+        <td title="${field}">${shortField}</td>
+        <td title="${commentHTMLescape}" cobj="${cobjstr}">${shortCommentHTMLescape}</td>
+        <td><div class="etableInputDiv">${tdstr}</div></td>
+        </tr>\n`
+    }
+
+
+    /////////////////////////////////////////////////////////////////////////////
+    // 表格生成的控制
+
+    /**
+     * 注释对象的默认值
+     */
+    editor_table.prototype.defaultcobj = {
+        // 默认是文本域
+        _type: 'textarea',
+        _data: '',
+        _string: function (args) {//object~[field,cfield,vobj,cobj]
+            var thiseval = args.vobj;
+            return (typeof (thiseval) === typeof ('')) && thiseval[0] === '"';
+        },
+        // 默认情况下 非对象和数组的视为叶节点
+        _leaf: function (args) {//object~[field,cfield,vobj,cobj]
+            var thiseval = args.vobj;
+            if (thiseval == null || thiseval == undefined) return true;//null,undefined
+            if (typeof (thiseval) === typeof ('')) return true;//字符串
+            if (Object.keys(thiseval).length === 0) return true;//数字,true,false,空数组,空对象
+            return false;
+        },
+    }
+
+    /**
+     * 把来自数据文件的obj和来自*comment.js的commentObj组装成表格
+     * commentObj在无视['_data']的意义下与obj同形
+     * 即: commentObj['_data']['a']['_data']['b'] 与 obj['a']['b'] 是对应的
+     *     在此意义下, 两者的结构是一致的
+     *     在commentObj没有被定义的obj的分支, 会取defaultcobj作为默认值
+     * 因此在深度优先遍历时,维护 
+     *     field="['a']['b']"
+     *     cfield="['_data']['a']['_data']['b']"
+     *     vobj=obj['a']['b']
+     *     cobj=commentObj['_data']['a']['_data']['b']
+     * cobj
+     *     cobj = Object.assign({}, defaultcobj, pcobj['_data'][ii])
+     *     每一项若未定义,就从defaultcobj中取
+     *     当其是函数不是具体值时,把args = {field: field, cfield: cfield, vobj: vobj, cobj: cobj}代入算出该值
+     * 得到的叶节点的<tr>结构如下
+     *     tr>td[title=field]
+     *       >td[title=comment,cobj=cobj:json]
+     *       >td>div>input[value=thiseval]
+     * 返回结果
+     *     返回一个对象, 假设被命名为tableinfo
+     *     在把一个 table 的 innerHTML 赋值为 tableinfo.HTML 后
+     *     再调 tableinfo.listen(tableinfo.guids) 进行绑定事件
+     * @param {Object} obj 
+     * @param {Object} commentObj 
+     * @returns {{"HTML":String,"guids":String[],"listen":Function}}
+     */
+    editor_table.prototype.objToTable = function (obj, commentObj) {
+        // 表格抬头
+        var outstr = [editor.table.title()];
+        var guids = [];
+        var defaultcobj = this.defaultcobj
+        /**
+         * 深度优先遍历, p*即为父节点的四个属性
+         * @param {String} pfield 
+         * @param {String} pcfield 
+         * @param {Object} pvobj 
+         * @param {Object} pcobj 
+         */
+        var recursionParse = function (pfield, pcfield, pvobj, pcobj) {
+            var keysForTableOrder = {};
+            var voidMark = {};
+            // 1. 按照pcobj排序生成
+            if (pcobj && pcobj['_data']) {
+                for (var ii in pcobj['_data']) keysForTableOrder[ii] = voidMark;
+            }
+            // 2. 对每个pvobj且不在pcobj的，再添加到最后
+            keysForTableOrder = Object.assign(keysForTableOrder, pvobj)
+            for (var ii in keysForTableOrder) {
+                // 3. 对于pcobj有但是pvobj中没有的, 弹出提示, (正常情况下editor_file会补全成null)
+                //    事实上能执行到这一步工程没崩掉打不开,就继续吧..
+                if (keysForTableOrder[ii] === voidMark) {
+                    if (typeof id_815975ad_ee6f_4684_aac7_397b7e392702 === "undefined") {
+                        // alert('comment和data不匹配,请在群 HTML5造塔技术交流群 959329661 内反馈')
+                        console.error('comment和data不匹配,请在群 HTML5造塔技术交流群 959329661 内反馈')
+                        id_815975ad_ee6f_4684_aac7_397b7e392702 = 1;
+                    }
+                    pvobj[ii] = null;
+                }
+                var field = pfield + "['" + ii + "']";
+                var cfield = pcfield + "['_data']['" + ii + "']";
+                var vobj = pvobj[ii];
+                var cobj = null;
+                if (pcobj && pcobj['_data'] && pcobj['_data'][ii]) {
+                    // cobj存在时直接取
+                    cobj = Object.assign({}, defaultcobj, pcobj['_data'][ii]);
+                } else {
+                    // 当其函数时代入参数算出cobj, 不存在时只取defaultcobj
+                    if (pcobj && (pcobj['_data'] instanceof Function)) cobj = Object.assign({}, defaultcobj, pcobj['_data'](ii));
+                    else cobj = Object.assign({}, defaultcobj);
+                }
+                var args = { field: field, cfield: cfield, vobj: vobj, cobj: cobj }
+                // 当cobj的参数为函数时,代入args算出值
+                for (var key in cobj) {
+                    if (key === '_data') continue;
+                    if (cobj[key] instanceof Function) cobj[key] = cobj[key](args);
+                }
+                // 标记为_hide的属性不展示
+                if (cobj._hide) continue;
+                if (!cobj._leaf) {
+                    // 不是叶节点时, 插入展开的标记并继续遍历, 此处可以改成按钮用来添加新项或折叠等
+                    outstr.push(editor.table.gap(field));
+                    recursionParse(field, cfield, vobj, cobj);
+                } else {
+                    // 是叶节点时, 调objToTr_渲染<tr>
+                    var leafnode = editor.table.objToTr(obj, commentObj, field, cfield, vobj, cobj);
+                    outstr.push(leafnode[0]);
+                    guids.push(leafnode[1]);
+                }
+            }
+        }
+        // 开始遍历
+        recursionParse("", "", obj, commentObj);
+
+        var listen = function (guids) {
+            // 每个叶节点的事件绑定
+            guids.forEach(function (guid) {
+                editor.table.guidListen(guid, obj, commentObj)
+            });
+        }
+        return { "HTML": outstr.join(''), "guids": guids, "listen": listen };
+    }
+
+    /**
+     * 返回叶节点<tr>形如
+     * tr>td[title=field]
+     *   >td[title=comment,cobj=cobj:json]
+     *   >td>div>input[value=thiseval]
+     * 参数意义在 objToTable 中已解释
+     * @param {Object} obj 
+     * @param {Object} commentObj 
+     * @param {String} field 
+     * @param {String} cfield 
+     * @param {Object} vobj 
+     * @param {Object} cobj 
+     */
+    editor_table.prototype.objToTr = function (obj, commentObj, field, cfield, vobj, cobj) {
+        var guid = editor.util.guid();
+        var thiseval = vobj;
+        var comment = String(cobj._data);
+
+        var charlength = 10;
+        // "['a']['b']" => "b"
+        var shortField = field.split("']").slice(-2)[0].split("['").slice(-1)[0];
+        // 把长度超过 charlength 的字符改成 固定长度+...的形式
+        shortField = (shortField.length < charlength ? shortField : shortField.slice(0, charlength) + '...');
+
+        // 完整的内容转义后供悬停查看
+        var commentHTMLescape = editor.util.HTMLescape(comment);
+        // 把长度超过 charlength 的字符改成 固定长度+...的形式
+        var shortCommentHTMLescape = (comment.length < charlength ? commentHTMLescape : editor.util.HTMLescape(comment.slice(0, charlength)) + '...');
+
+        var cobjstr = Object.assign({}, cobj);
+        delete cobjstr._data;
+        // 把cobj塞到第二个td的[cobj]中, 方便绑定事件时取
+        cobjstr = editor.util.HTMLescape(JSON.stringify(cobjstr));
+
+        var tdstr = editor.table.objToTd(obj, commentObj, field, cfield, vobj, cobj)
+        var outstr = editor.table.tr(guid, field, shortField, commentHTMLescape, cobjstr, shortCommentHTMLescape, tdstr)
+        return [outstr, guid];
+    }
+
+    editor_table.prototype.objToTd = function (obj, commentObj, field, cfield, vobj, cobj) {
+        var thiseval = vobj;
+        if (cobj._select) {
+            var values = cobj._select.values;
+            return editor.table.select(thiseval, values);
+        } else if (cobj._input) {
+            return editor.table.text(thiseval);
+        } else if (cobj._bool) {
+            return editor.table.checkbox(thiseval);
+        } else {
+            var indent = 0;
+            return editor.table.textarea(thiseval, indent);
+        }
+    }
+
+    /////////////////////////////////////////////////////////////////////////////
+    // 表格的用户交互
+
+    /**
+     * 检查一个值是否允许被设置为当前输入
+     * @param {Object} cobj 
+     * @param {*} thiseval 
+     */
+    editor_table.prototype.checkRange = function (cobj, thiseval) {
+        if (cobj._range) {
+            return eval(cobj._range);
+        }
+        if (cobj._select) {
+            return cobj._select.values.indexOf(thiseval) !== -1;
+        }
+        if (cobj._bool) {
+            return [true, false].indexOf(thiseval) !== -1;
+        }
+        return true;
+    }
+
+    /**
+     * 监听一个guid对应的表格项
+     * @param {String} guid 
+     */
+    editor_table.prototype.guidListen = function (guid, obj, commentObj) {
+        // tr>td[title=field]
+        //   >td[title=comment,cobj=cobj:json]
+        //   >td>div>input[value=thiseval]
+        var thisTr = document.getElementById(guid);
+        var input = thisTr.children[2].children[0].children[0];
+        var field = thisTr.children[0].getAttribute('title');
+        var cobj = JSON.parse(thisTr.children[1].getAttribute('cobj'));
+        var modeNode = thisTr.parentNode;
+        while (!editor_mode._ids.hasOwnProperty(modeNode.getAttribute('id'))) {
+            modeNode = modeNode.parentNode;
+        }
+        input.onchange = function () {
+            editor.table.onchange(guid, obj, commentObj, thisTr, input, field, cobj, modeNode)
+        }
+        // 用检测两次单击的方式来实现双击(以支持手机端的双击)
+        var doubleClickCheck = [0];
+        thisTr.onclick = function () {
+            var newClick = new Date().getTime();
+            var lastClick = doubleClickCheck.shift();
+            doubleClickCheck.push(newClick);
+            if (newClick - lastClick < 500) {
+                editor.table.dblclickfunc(guid, obj, commentObj, thisTr, input, field, cobj, modeNode)
+            }
+        }
+    }
+
+    /**
+     * 表格的值变化时
+     */
+    editor_table.prototype.onchange = function (guid, obj, commentObj, thisTr, input, field, cobj, modeNode) {
+        editor_mode.onmode(editor_mode._ids[modeNode.getAttribute('id')]);
+        var thiseval = null;
+        if (input.checked != null) input.value = input.checked;
+        try {
+            thiseval = JSON.parse(input.value);
+        } catch (ee) {
+            printe(field + ' : ' + ee);
+            throw ee;
+        }
+        if (editor.table.checkRange(cobj, thiseval)) {
+            editor_mode.addAction(['change', field, thiseval]);
+            editor_mode.onmode('save');//自动保存 删掉此行的话点保存按钮才会保存
+        } else {
+            printe(field + ' : 输入的值不合要求,请鼠标放置在注释上查看说明');
+        }
+    }
+
+    /**
+     * 双击表格时
+     *     正常编辑: 尝试用事件编辑器或多行文本编辑器打开
+     *     添加: 在该项的同一级创建一个内容为null新的项, 刷新后生效并可以继续编辑
+     *     删除: 删除该项, 刷新后生效
+     * 在点击按钮 添加/删除 后,下一次双击将被视为 添加/删除
+     */
+    editor_table.prototype.dblclickfunc = function (guid, obj, commentObj, thisTr, input, field, cobj, modeNode) {
+        if (editor_mode.doubleClickMode === 'change') {
+            if (cobj._type === 'event') editor_blockly.import(guid, { type: cobj._event });
+            if (cobj._type === 'textarea') editor_multi.import(guid, { lint: cobj._lint, string: cobj._string });
+        } else if (editor_mode.doubleClickMode === 'add') {
+            editor_mode.doubleClickMode = 'change';
+            editor.table.addfunc(guid, obj, commentObj, thisTr, input, field, cobj, modeNode)
+        } else if (editor_mode.doubleClickMode === 'delete') {
+            editor_mode.doubleClickMode = 'change';
+            editor.table.deletefunc(guid, obj, commentObj, thisTr, input, field, cobj, modeNode)
+        }
+    }
+
+    /**
+     * 删除表格项
+     */
+    editor_table.prototype.deletefunc = function (guid, obj, commentObj, thisTr, input, field, cobj, modeNode) {
+        editor_mode.onmode(editor_mode._ids[modeNode.getAttribute('id')]);
+        if (editor.table.checkRange(cobj, null)) {
+            editor_mode.addAction(['delete', field, undefined]);
+            editor_mode.onmode('save');//自动保存 删掉此行的话点保存按钮才会保存
+        } else {
+            printe(field + ' : 该值不允许为null，无法删除');
+        }
+    }
+
+    /**
+     * 添加表格项
+     */
+    editor_table.prototype.addfunc = function (guid, obj, commentObj, thisTr, input, field, cobj, modeNode) {
+        editor_mode.onmode(editor_mode._ids[modeNode.getAttribute('id')]);
+
+        var mode = document.getElementById('editModeSelect').value;
+
+        // 1.输入id
+        var newid = prompt('请输入新项的ID（仅公共事件支持中文ID）');
+        if (newid == null || newid.length == 0) {
+            return;
+        }
+
+        // 检查commentEvents
+        if (mode !== 'commonevent') {
+            // 2.检查id是否符合规范或与已有id重复
+            if (!/^[a-zA-Z0-9_]+$/.test(newid)) {
+                printe('id不符合规范, 请使用大小写字母数字下划线来构成');
+                return;
+            }
+        }
+
+        var conflict = true;
+        var basefield = field.replace(/\[[^\[]*\]$/, '');
+        if (basefield === "['main']") {
+            printe("全塔属性 ~ ['main'] 不允许添加新值");
+            return;
+        }
+        try {
+            var baseobj = eval('obj' + basefield);
+            conflict = newid in baseobj;
+        } catch (ee) {
+            // 理论上这里不会发生错误
+            printe(ee);
+            throw ee;
+        }
+        if (conflict) {
+            printe('id已存在, 请直接修改该项的值');
+            return;
+        }
+        // 3.添加 
+        editor_mode.addAction(['add', basefield + "['" + newid + "']", null]);
+        editor_mode.onmode('save');//自动保存 删掉此行的话点保存按钮才会保存
+    }
+
+    /////////////////////////////////////////////////////////////////////////////
+    editor.constructor.prototype.table = new editor_table();
+}
+//editor_table_wrapper(editor);
\ No newline at end of file
diff --git a/_server/editor_unsorted_1.js b/_server/editor_unsorted_1.js
new file mode 100644
index 00000000..0d3861d8
--- /dev/null
+++ b/_server/editor_unsorted_1.js
@@ -0,0 +1,839 @@
+editor_unsorted_1_wrapper=function(editor){
+
+editor.constructor.prototype.listen=function () {
+    document.body.onmousedown = function (e) {
+        //console.log(e);
+        var clickpath = [];
+        var getpath=function(e) {
+            var path = [];
+            var currentElem = e.target;
+            while (currentElem) {
+                path.push(currentElem);
+                currentElem = currentElem.parentElement;
+            }
+            if (path.indexOf(window) === -1 && path.indexOf(document) === -1)
+                path.push(document);
+            if (path.indexOf(window) === -1)
+                path.push(window);
+            return path;
+        }
+        getpath(e).forEach(function (node) {
+            if (!node.getAttribute) return;
+            var id_ = node.getAttribute('id');
+            if (id_) {
+                if (['left', 'left1', 'left2', 'left3', 'left4', 'left5', 'left8', 'mobileview'].indexOf(id_) !== -1) clickpath.push('edit');
+                clickpath.push(id_);
+            }
+        });
+    
+        var unselect=true;
+        for(var ii=0,thisId;thisId=['edit','tip','brushMod','brushMod2','brushMod3','layerMod','layerMod2','layerMod3','viewportButtons'][ii];ii++){
+            if (clickpath.indexOf(thisId) !== -1){
+                unselect=false;
+                break;
+            }
+        }
+        if (unselect) {
+            if (clickpath.indexOf('eui') === -1) {
+                if (selectBox.isSelected()) {
+                    editor_mode.onmode('');
+                    editor.file.saveFloorFile(function (err) {
+                        if (err) {
+                            printe(err);
+                            throw(err)
+                        }
+                        ;printf('地图保存成功');
+                    });
+                }
+                selectBox.isSelected(false);
+                editor.info = {};
+            }
+        }
+        //editor.mode.onmode('');
+        if (e.button!=2 && !editor.isMobile){
+            editor.hideMidMenu();
+        }
+        if (clickpath.indexOf('down') !== -1 && editor.isMobile && clickpath.indexOf('midMenu') === -1){
+            editor.hideMidMenu();
+        }
+        if(clickpath.length>=2 && clickpath[0].indexOf('id_')===0){editor.lastClickId=clickpath[0]}
+    }
+
+    var eui=document.getElementById('eui');
+    var uc = eui.getContext('2d');
+
+    function fillPos(pos) {
+        uc.fillStyle = '#' + ~~(Math.random() * 8) + ~~(Math.random() * 8) + ~~(Math.random() * 8);
+        uc.fillRect(pos.x * 32 + 12 - core.bigmap.offsetX, pos.y * 32 + 12 - core.bigmap.offsetY, 8, 8);
+    }//在格子内画一个随机色块
+
+    function eToLoc(e) {
+        var scrollLeft = document.documentElement.scrollLeft || document.body.scrollLeft
+        var scrollTop = document.documentElement.scrollTop || document.body.scrollTop
+        var xx=e.clientX,yy=e.clientY
+        if(editor.isMobile){xx=e.touches[0].clientX,yy=e.touches[0].clientY}
+        editor.loc = {
+            'x': scrollLeft + xx - mid.offsetLeft - mapEdit.offsetLeft,
+            'y': scrollTop + yy - mid.offsetTop - mapEdit.offsetTop,
+            'size': editor.isMobile?(32*innerWidth*0.96/core.__PIXELS__):32
+        };
+        return editor.loc;
+    }//返回可用的组件内坐标
+
+    function locToPos(loc, addViewportOffset) {
+        var offsetX=0, offsetY=0;
+        if (addViewportOffset){
+            offsetX=core.bigmap.offsetX/32;
+            offsetY=core.bigmap.offsetY/32;
+        }
+        editor.pos = {'x': ~~(loc.x / loc.size)+offsetX, 'y': ~~(loc.y / loc.size)+offsetY}
+        return editor.pos;
+    }
+
+    var holdingPath = 0;
+    var stepPostfix = null;//用于存放寻路检测的第一个点之后的后续移动
+
+    var mouseOutCheck = 2;
+
+    function clear1() {
+        if (mouseOutCheck > 1) {
+            mouseOutCheck--;
+            setTimeout(clear1, 1000);
+            return;
+        }
+        holdingPath = 0;
+        stepPostfix = [];
+        uc.clearRect(0, 0, core.__PIXELS__, core.__PIXELS__);
+    }//用于鼠标移出canvas时的自动清除状态
+
+    eui.oncontextmenu=function(e){e.preventDefault()}
+
+    eui.ondblclick = function(e) {
+        // 双击地图可以选中素材
+        var loc = eToLoc(e);
+        var pos = locToPos(loc,true);
+        editor.setSelectBoxFromInfo(editor[editor.layerMod][pos.y][pos.x]);
+        return;
+    }
+
+    eui.onmousedown = function (e) {
+        if (e.button==2){
+            var loc = eToLoc(e);
+            var pos = locToPos(loc,true);
+            editor.showMidMenu(e.clientX,e.clientY);
+            return;
+        }
+        if (!selectBox.isSelected()) {
+            var loc = eToLoc(e);
+            var pos = locToPos(loc,true);
+            editor_mode.onmode('nextChange');
+            editor_mode.onmode('loc');
+            //editor_mode.loc();
+            //tip.whichShow(1);
+            if(editor.isMobile)editor.showMidMenu(e.clientX,e.clientY);
+            return;
+        }
+        
+
+        holdingPath = 1;
+        mouseOutCheck = 2;
+        setTimeout(clear1);
+        e.stopPropagation();
+        uc.clearRect(0, 0, core.__PIXELS__, core.__PIXELS__);
+        var loc = eToLoc(e);
+        var pos = locToPos(loc,true);
+        stepPostfix = [];
+        stepPostfix.push(pos);
+        fillPos(pos);
+    }
+
+    eui.onmousemove = function (e) {
+        if (!selectBox.isSelected()) {
+            //tip.whichShow(1);
+            return;
+        }
+
+        if (holdingPath == 0) {
+            return;
+        }
+        mouseOutCheck = 2;
+        e.stopPropagation();
+        var loc = eToLoc(e);
+        var pos = locToPos(loc,true);
+        var pos0 = stepPostfix[stepPostfix.length - 1]
+        var directionDistance = [pos.y - pos0.y, pos0.x - pos.x, pos0.y - pos.y, pos.x - pos0.x]
+        var max = 0, index = 4;
+        for (var i = 0; i < 4; i++) {
+            if (directionDistance[i] > max) {
+                index = i;
+                max = directionDistance[i];
+            }
+        }
+        var pos = [{'x': 0, 'y': 1}, {'x': -1, 'y': 0}, {'x': 0, 'y': -1}, {'x': 1, 'y': 0}, false][index]
+        if (pos) {
+            pos.x += pos0.x;
+            pos.y += pos0.y;
+            stepPostfix.push(pos);
+            fillPos(pos);
+        }
+    }
+
+    eui.onmouseup = function (e) {
+        if (!selectBox.isSelected()) {
+            //tip.whichShow(1);
+            return;
+        }
+        holdingPath = 0;
+        e.stopPropagation();
+        if (stepPostfix && stepPostfix.length) {
+            editor.preMapData = JSON.parse(JSON.stringify({map:editor.map,fgmap:editor.fgmap,bgmap:editor.bgmap}));
+            if(editor.brushMod!=='line'){
+                var x0=stepPostfix[0].x;
+                var y0=stepPostfix[0].y;
+                var x1=stepPostfix[stepPostfix.length-1].x;
+                var y1=stepPostfix[stepPostfix.length-1].y;
+                if(x0>x1){x0^=x1;x1^=x0;x0^=x1;}//swap
+                if(y0>y1){y0^=y1;y1^=y0;y0^=y1;}//swap
+                stepPostfix=[];
+                for(var jj=y0;jj<=y1;jj++){
+                    for(var ii=x0;ii<=x1;ii++){
+                        stepPostfix.push({x:ii,y:jj})
+                    }
+                }
+            }
+            currDrawData.pos = JSON.parse(JSON.stringify(stepPostfix));
+            currDrawData.info = JSON.parse(JSON.stringify(editor.info));
+            reDo = null;
+            // console.log(stepPostfix);
+            if(editor.brushMod==='tileset' && core.tilesets.indexOf(editor.info.images)!==-1){
+                var imgWidth=~~(core.material.images.tilesets[editor.info.images].width/32);
+                var x0=stepPostfix[0].x;
+                var y0=stepPostfix[0].y;
+                var idnum=editor.info.idnum;
+                for (var ii = 0; ii < stepPostfix.length; ii++){
+                    if(stepPostfix[ii].y!=y0){
+                        y0++;
+                        idnum+=imgWidth;
+                    }
+                    editor[editor.layerMod][stepPostfix[ii].y][stepPostfix[ii].x] = editor.ids[editor.indexs[idnum+stepPostfix[ii].x-x0]];
+                }
+            } else {
+                for (var ii = 0; ii < stepPostfix.length; ii++)
+                editor[editor.layerMod][stepPostfix[ii].y][stepPostfix[ii].x] = editor.info;
+            }
+            // console.log(editor.map);
+            editor.updateMap();
+            holdingPath = 0;
+            stepPostfix = [];
+            uc.clearRect(0, 0, core.__PIXELS__, core.__PIXELS__);
+        }
+    }
+
+    /*
+    document.getElementById('mid').onkeydown = function (e) {
+        console.log(e);
+        if (e.keyCode==37) {
+            editor.moveViewport(-1, 0);
+        }
+        if (e.keyCode==38) {
+            editor.moveViewport(0, -1);
+        }
+        if (e.keyCode==39) {
+            editor.moveViewport(1, 0);
+        }
+        if (e.keyCode==40) {
+            editor.moveViewport(0, 1);
+        }
+    }
+    */
+
+    document.getElementById('mid').onmousewheel = function (e) {
+        e.preventDefault();
+        var wheel = function (direct) {
+            var index=editor.core.floorIds.indexOf(editor.currentFloorId);
+            var toId = editor.currentFloorId;
+
+            if (direct>0 && index<editor.core.floorIds.length-1)
+                toId = editor.core.floorIds[index+1];
+            else if (direct<0 && index>0)
+                toId = editor.core.floorIds[index-1];
+            else return;
+
+            editor_mode.onmode('nextChange');
+            editor_mode.onmode('floor');
+            document.getElementById('selectFloor').value = toId;
+            editor.changeFloor(toId);
+        }
+
+        try {
+            if (e.wheelDelta)
+                wheel(Math.sign(e.wheelDelta))
+            else if (e.detail)
+                wheel(Math.sign(e.detail));
+        }
+        catch (ee) {
+            console.log(ee);
+        }
+    }
+
+    editor.preMapData = null;
+    var currDrawData = {
+        pos: [],
+        info: {}
+    };
+    var reDo = null;
+    var shortcut = core.getLocalStorage('shortcut',{48: 0, 49: 0, 50: 0, 51: 0, 52: 0, 53: 0, 54: 0, 55: 0, 56: 0, 57: 0});
+    document.body.onkeydown = function (e) {
+
+        // 监听Ctrl+S保存
+        if (e.ctrlKey && e.keyCode == 83) {
+            e.preventDefault();
+            if (editor_multi.id != "") {
+                editor_multi.confirm(); // 保存脚本编辑器
+            }
+            else if (editor_blockly.id != "") {
+                editor_blockly.confirm(); // 保存事件编辑器
+            }
+            else {
+                editor_mode.saveFloor();
+            }
+            return;
+        }
+
+        // 如果是开启事件/脚本编辑器状态，则忽略
+        if (editor_multi.id!="" || editor_blockly.id!="")
+            return;
+
+        // 禁止快捷键的默认行为
+        if (e.ctrlKey && [89, 90, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57].indexOf(e.keyCode) !== -1)
+            e.preventDefault();
+        if (e.altKey && [48, 49, 50, 51, 52, 53, 54, 55, 56, 57].indexOf(e.keyCode) !== -1)
+            e.preventDefault();
+        //Ctrl+z 撤销上一步undo
+        if (e.keyCode == 90 && e.ctrlKey && editor.preMapData && currDrawData.pos.length && selectBox.isSelected()) {
+            editor.map = JSON.parse(JSON.stringify(editor.preMapData.map));
+            editor.fgmap = JSON.parse(JSON.stringify(editor.preMapData.fgmap));
+            editor.bgmap = JSON.parse(JSON.stringify(editor.preMapData.bgmap));
+            editor.updateMap();
+            reDo = JSON.parse(JSON.stringify(currDrawData));
+            currDrawData = {pos: [], info: {}};
+            editor.preMapData = null;
+        }
+        //Ctrl+y 重做一步redo
+        if (e.keyCode == 89 && e.ctrlKey && reDo && reDo.pos.length && selectBox.isSelected()) {
+            editor.preMapData = JSON.parse(JSON.stringify({map:editor.map,fgmap:editor.fgmap,bgmap:editor.bgmap}));
+            for (var j = 0; j < reDo.pos.length; j++)
+                editor.map[reDo.pos[j].y][reDo.pos[j].x] = JSON.parse(JSON.stringify(reDo.info));
+
+            editor.updateMap();
+            currDrawData = JSON.parse(JSON.stringify(reDo));
+            reDo = null;
+        }
+
+        // PGUP和PGDOWN切换楼层
+        if (e.keyCode==33) {
+            e.preventDefault();
+            var index=editor.core.floorIds.indexOf(editor.currentFloorId);
+            if (index<editor.core.floorIds.length-1) {
+                var toId = editor.core.floorIds[index+1];
+                editor_mode.onmode('nextChange');
+                editor_mode.onmode('floor');
+                document.getElementById('selectFloor').value = toId;
+                editor.changeFloor(toId);
+            }
+        }
+        if (e.keyCode==34) {
+            e.preventDefault();
+            var index=editor.core.floorIds.indexOf(editor.currentFloorId);
+            if (index>0) {
+                var toId = editor.core.floorIds[index-1];
+                editor_mode.onmode('nextChange');
+                editor_mode.onmode('floor');
+                document.getElementById('selectFloor').value = toId;
+                editor.changeFloor(toId);
+            }
+        }
+        //ctrl + 0~9 切换到快捷图块
+        if (e.ctrlKey && [48, 49, 50, 51, 52, 53, 54, 55, 56, 57].indexOf(e.keyCode) !== -1){
+            editor.setSelectBoxFromInfo(JSON.parse(JSON.stringify(shortcut[e.keyCode]||0)));
+        }
+        //alt + 0~9 改变快捷图块
+        if (e.altKey && [48, 49, 50, 51, 52, 53, 54, 55, 56, 57].indexOf(e.keyCode) !== -1){
+            var infoToSave = JSON.stringify(editor.info||0);
+            if(infoToSave==JSON.stringify({}))return;
+            shortcut[e.keyCode]=JSON.parse(infoToSave);
+            printf('已保存该快捷图块, ctrl + '+(e.keyCode-48)+' 使用.')
+            core.setLocalStorage('shortcut',shortcut);
+        }
+        var focusElement = document.activeElement;
+        if (!focusElement || focusElement.tagName.toLowerCase()=='body') {
+            // wasd平移大地图
+            if (e.keyCode==87)
+                editor.moveViewport(0,-1)
+            else if (e.keyCode==65)
+                editor.moveViewport(-1,0)
+            else if (e.keyCode==83)
+                editor.moveViewport(0,1);
+            else if (e.keyCode==68)
+                editor.moveViewport(1,0);
+        }
+    }
+
+    var getScrollBarHeight = function () {
+        var outer = document.createElement("div");
+        outer.style.visibility = "hidden";
+        outer.style.width = "100px";
+        outer.style.msOverflowStyle = "scrollbar"; // needed for WinJS apps
+
+        document.body.appendChild(outer);
+
+        var widthNoScroll = outer.offsetWidth;
+        // force scrollbars
+        outer.style.overflow = "scroll";
+
+        // add innerdiv
+        var inner = document.createElement("div");
+        inner.style.width = "100%";
+        outer.appendChild(inner);
+
+        var widthWithScroll = inner.offsetWidth;
+
+        // remove divs
+        outer.parentNode.removeChild(outer);
+
+        return widthNoScroll - widthWithScroll;
+    }
+    var scrollBarHeight = getScrollBarHeight();
+
+    var dataSelection = document.getElementById('dataSelection');
+    var iconLib=document.getElementById('iconLib');
+    iconLib.onmousedown = function (e) {
+        e.stopPropagation();
+        if (!editor.isMobile && e.clientY>=((core.__SIZE__==13?630:655) - scrollBarHeight)) return;
+        var scrollLeft = document.documentElement.scrollLeft || document.body.scrollLeft;
+        var scrollTop = document.documentElement.scrollTop || document.body.scrollTop;
+        var loc = {
+            'x': scrollLeft + e.clientX + iconLib.scrollLeft - right.offsetLeft - iconLib.offsetLeft,
+            'y': scrollTop + e.clientY + iconLib.scrollTop - right.offsetTop - iconLib.offsetTop,
+            'size': 32
+        };
+        editor.loc = loc;
+        var pos = locToPos(loc);
+        for (var spriter in editor.widthsX) {
+            if (pos.x >= editor.widthsX[spriter][1] && pos.x < editor.widthsX[spriter][2]) {
+                var ysize = spriter.indexOf('48') === -1 ? 32 : 48;
+                loc.ysize = ysize;
+                pos.images = editor.widthsX[spriter][0];
+                pos.y = ~~(loc.y / loc.ysize);
+                if(core.tilesets.indexOf(pos.images)==-1)pos.x = editor.widthsX[spriter][1];
+                var autotiles = core.material.images['autotile'];
+                if (pos.images == 'autotile') {
+                    var imNames = Object.keys(autotiles);
+                    if ((pos.y + 1) * ysize > editor.widthsX[spriter][3])
+                        pos.y = ~~(editor.widthsX[spriter][3] / ysize) - 4;
+                    else {
+                        for (var i = 0; i < imNames.length; i++) {
+                            if (pos.y >= 4 * i && pos.y < 4 * (i + 1)) {
+                                pos.images = imNames[i];
+                                pos.y = 4 * i;
+                            }
+                        }
+                    }
+                } else if ((pos.y + 1) * ysize > editor.widthsX[spriter][3])
+                    pos.y = ~~(editor.widthsX[spriter][3] / ysize) - 1;
+
+                selectBox.isSelected(true);
+                // console.log(pos,core.material.images[pos.images].height)
+                dataSelection.style.left = pos.x * 32 + 'px';
+                dataSelection.style.top = pos.y * ysize + 'px';
+                dataSelection.style.height = ysize - 6 + 'px';
+
+                if (pos.x == 0 && pos.y == 0) {
+                    // editor.info={idnum:0, id:'empty','images':'清除块', 'y':0};
+                    editor.info = 0;
+                } else if(pos.x == 0 && pos.y == 1){
+                    editor.info = editor.ids[editor.indexs[17]];
+                } else {
+                    if (Object.prototype.hasOwnProperty.call(autotiles, pos.images)) editor.info = {'images': pos.images, 'y': 0};
+                    else if (pos.images == 'terrains') editor.info = {'images': pos.images, 'y': pos.y - 2};
+                    else if (core.tilesets.indexOf(pos.images)!=-1) editor.info = {'images': pos.images, 'y': pos.y, 'x': pos.x-editor.widthsX[spriter][1]};
+                    else editor.info = {'images': pos.images, 'y': pos.y};
+
+                    for (var ii = 0; ii < editor.ids.length; ii++) {
+                        if ((core.tilesets.indexOf(pos.images)!=-1 && editor.info.images == editor.ids[ii].images
+                                && editor.info.y == editor.ids[ii].y && editor.info.x == editor.ids[ii].x)
+                            || (Object.prototype.hasOwnProperty.call(autotiles, pos.images) && editor.info.images == editor.ids[ii].id
+                            && editor.info.y == editor.ids[ii].y)
+                            || (core.tilesets.indexOf(pos.images)==-1 && editor.info.images == editor.ids[ii].images
+                                && editor.info.y == editor.ids[ii].y )
+                            ) {
+
+                            editor.info = editor.ids[ii];
+                            break;
+                        }
+                    }
+                }
+                tip.infos(JSON.parse(JSON.stringify(editor.info)));
+                editor_mode.onmode('nextChange');
+                editor_mode.onmode('enemyitem');
+                //editor_mode.enemyitem();
+            }
+        }
+    }
+
+    var midMenu=document.getElementById('midMenu');
+    midMenu.oncontextmenu=function(e){e.preventDefault()}
+    editor.lastRightButtonPos=[{x:0,y:0},{x:0,y:0}];
+    editor.showMidMenu=function(x,y){
+        editor.lastRightButtonPos=JSON.parse(JSON.stringify(
+            [editor.pos,editor.lastRightButtonPos[0]]
+        ));
+        var locStr='('+editor.lastRightButtonPos[1].x+','+editor.lastRightButtonPos[1].y+')';
+        var scrollLeft = document.documentElement.scrollLeft || document.body.scrollLeft;
+        var scrollTop = document.documentElement.scrollTop || document.body.scrollTop;
+
+        // 检测是否是上下楼
+        var thisevent = editor.map[editor.pos.y][editor.pos.x];
+        if (thisevent.id=='upFloor') {
+            addFloorEvent.style.display='block';
+            addFloorEvent.children[0].innerHTML='绑定上楼事件';
+        }
+        else if (thisevent.id=='downFloor') {
+            addFloorEvent.style.display='block';
+            addFloorEvent.children[0].innerHTML='绑定下楼事件';
+        }
+        else addFloorEvent.style.display='none';
+
+        chooseThis.children[0].innerHTML='选中此点'+'('+editor.pos.x+','+editor.pos.y+')'
+        copyLoc.children[0].innerHTML='复制事件'+locStr+'到此处';
+        moveLoc.children[0].innerHTML='交换事件'+locStr+'与此事件的位置';
+        midMenu.style='top:'+(y+scrollTop)+'px;left:'+(x+scrollLeft)+'px;';
+    }
+    editor.hideMidMenu=function(){
+        if(editor.isMobile){
+            setTimeout(function(){
+                midMenu.style='display:none';
+            },200)
+        } else {
+            midMenu.style='display:none';
+        }
+    }
+
+    var addFloorEvent = document.getElementById('addFloorEvent');
+    addFloorEvent.onmousedown = function(e) {
+        editor.hideMidMenu();
+        e.stopPropagation();
+        var thisevent = editor.map[editor.pos.y][editor.pos.x];
+        if (thisevent.id=='upFloor') {
+            editor.currentFloorData.changeFloor[editor.pos.x+","+editor.pos.y] = {"floorId": ":next", "stair": "downFloor"};
+        }
+        else if (thisevent.id=='downFloor') {
+            editor.currentFloorData.changeFloor[editor.pos.x+","+editor.pos.y] = {"floorId": ":before", "stair": "upFloor"};
+        }
+        editor.file.saveFloorFile(function (err) {
+            if (err) {
+                printe(err);
+                throw(err)
+            }
+            ;printf('添加楼梯事件成功');
+            editor.drawPosSelection();
+            editor_mode.showMode('loc');
+        });
+    }
+
+    var chooseThis = document.getElementById('chooseThis');
+    chooseThis.onmousedown = function(e){
+        editor.hideMidMenu();
+        e.stopPropagation();
+        selectBox.isSelected(false);
+
+        editor_mode.onmode('nextChange');
+        editor_mode.onmode('loc');
+        //editor_mode.loc();
+        //tip.whichShow(1);
+        if(editor.isMobile)editor.showdataarea(false);
+    }
+
+    var chooseInRight = document.getElementById('chooseInRight');
+    chooseInRight.onmousedown = function(e){
+        editor.hideMidMenu();
+        e.stopPropagation();
+        var thisevent = editor[editor.layerMod][editor.pos.y][editor.pos.x];
+        editor.setSelectBoxFromInfo(thisevent);
+    }
+
+    var fields = Object.keys(editor.file.comment._data.floors._data.loc._data);
+
+    var copyLoc = document.getElementById('copyLoc');
+    copyLoc.onmousedown = function(e){
+        editor.hideMidMenu();
+        e.stopPropagation();
+        editor.preMapData = null;
+        reDo = null;
+        editor_mode.onmode('');
+        var now = editor.pos;
+        var last = editor.lastRightButtonPos[1];
+        var lastevent = editor.map[last.y][last.x];
+        var lastinfo = 0;
+        if(lastevent==0){
+            lastinfo = 0;
+        } else {
+            var ids=editor.indexs[lastevent.idnum];
+            ids=ids[0]?ids[0]:ids;
+            lastinfo=editor.ids[ids];
+        }
+        editor.map[now.y][now.x]=lastinfo;
+        editor.updateMap();
+        fields.forEach(function(v){
+            editor.currentFloorData[v][now.x+','+now.y]=editor.currentFloorData[v][last.x+','+last.y]
+        })
+        editor.file.saveFloorFile(function (err) {
+            if (err) {
+                printe(err);
+                throw(err)
+            }
+            ;printf('复制事件成功');
+            editor.drawPosSelection();
+        });
+    }
+
+    var moveLoc = document.getElementById('moveLoc');
+    moveLoc.onmousedown = function(e){
+        editor.hideMidMenu();
+        e.stopPropagation();
+        editor.preMapData = null;
+        reDo = null;
+        var thisevent = editor.map[editor.pos.y][editor.pos.x];
+        if(thisevent==0){
+            editor.info = 0;
+        } else {
+            var ids=editor.indexs[thisevent.idnum];
+            ids=ids[0]?ids[0]:ids;
+            editor.info=editor.ids[ids];
+        }
+        editor_mode.onmode('');
+        var now = editor.pos;
+        var last = editor.lastRightButtonPos[1];
+        
+        var lastevent = editor.map[last.y][last.x];
+        var lastinfo = 0;
+        if(lastevent==0){
+            lastinfo = 0;
+        } else {
+            var ids=editor.indexs[lastevent.idnum];
+            ids=ids[0]?ids[0]:ids;
+            lastinfo=editor.ids[ids];
+        }
+        editor.map[last.y][last.x]=editor.info;
+        editor.map[now.y][now.x]=lastinfo;
+        editor.updateMap();
+
+        fields.forEach(function(v){
+            var temp_atsfcytaf=editor.currentFloorData[v][now.x+','+now.y];
+            editor.currentFloorData[v][now.x+','+now.y]=editor.currentFloorData[v][last.x+','+last.y];
+            editor.currentFloorData[v][last.x+','+last.y]=temp_atsfcytaf;
+        })
+        editor.file.saveFloorFile(function (err) {
+            if (err) {
+                printe(err);
+                throw(err)
+            }
+            ;printf('两位置的事件已互换');
+            editor.drawPosSelection();
+        });
+    }
+
+    var _clearPoint = function (clearPoint) {
+        editor.hideMidMenu();
+        editor.preMapData = null;
+        reDo = null;
+        editor.info = 0;
+        editor_mode.onmode('');
+        var now = editor.pos;
+        if (clearPoint)
+            editor.map[now.y][now.x]=editor.info;
+        editor.updateMap();
+        fields.forEach(function(v){
+            delete editor.currentFloorData[v][now.x+','+now.y];
+        })
+        editor.file.saveFloorFile(function (err) {
+            if (err) {
+                printe(err);
+                throw(err)
+            }
+            ;printf(clearPoint?'清空该点和事件成功':'只清空该点事件成功');
+            editor.drawPosSelection();
+        });
+    }
+
+    var clearEvent = document.getElementById('clearEvent');
+    clearEvent.onmousedown = function (e) {
+        e.stopPropagation();
+        _clearPoint(false);
+    }
+
+    var clearLoc = document.getElementById('clearLoc');
+    clearLoc.onmousedown = function(e){
+        e.stopPropagation();
+        _clearPoint(true);
+    }
+
+    var brushMod=document.getElementById('brushMod');
+    brushMod.onchange=function(){
+        editor.brushMod=brushMod.value;
+    }
+
+    var brushMod2=document.getElementById('brushMod2');
+    if(brushMod2)brushMod2.onchange=function(){
+        editor.brushMod=brushMod2.value;
+    }
+
+    var brushMod3=document.getElementById('brushMod3');
+    if(brushMod3)brushMod3.onchange=function(){
+        editor.brushMod=brushMod3.value;
+    }
+
+    var bgc = document.getElementById('bg'), fgc = document.getElementById('fg'),
+        evc = document.getElementById('event'), ev2c = document.getElementById('event2');
+
+    var layerMod=document.getElementById('layerMod');
+    layerMod.onchange=function(){
+        editor.layerMod=layerMod.value;
+        [bgc,fgc,evc,ev2c].forEach(function (x) {
+            x.style.opacity = 1;
+        });
+
+        // 手机端....
+        if (editor.isMobile) {
+            if (layerMod.value == 'bgmap') {
+                [fgc,evc,ev2c].forEach(function (x) {
+                    x.style.opacity = 0.3;
+                });
+            }
+            if (layerMod.value == 'fgmap') {
+                [bgc,evc,ev2c].forEach(function (x) {
+                    x.style.opacity = 0.3;
+                });
+            }
+        }
+    }
+
+    var layerMod2=document.getElementById('layerMod2');
+    if(layerMod2)layerMod2.onchange=function(){
+        editor.layerMod=layerMod2.value;
+        [fgc,evc,ev2c].forEach(function (x) {
+            x.style.opacity = 0.3;
+        });
+        bgc.style.opacity = 1;
+    }
+
+    var layerMod3=document.getElementById('layerMod3');
+    if(layerMod3)layerMod3.onchange=function(){
+        editor.layerMod=layerMod3.value;
+        [bgc,evc,ev2c].forEach(function (x) {
+            x.style.opacity = 0.3;
+        });
+        fgc.style.opacity = 1;
+    }
+
+    var viewportButtons=document.getElementById('viewportButtons');
+    for(var ii=0,node;node=viewportButtons.children[ii];ii++){
+        (function(x,y){
+            node.onclick=function(){
+                editor.moveViewport(x,y);
+            }
+        })([-1,0,0,1][ii],[0,-1,1,0][ii]);
+    }
+}
+
+editor.constructor.prototype.mobile_listen=function () {
+    if(!editor.isMobile)return;
+
+    var mobileview=document.getElementById('mobileview');
+    var editModeSelect=document.getElementById('editModeSelect');
+    var mid=document.getElementById('mid');
+    var right=document.getElementById('right');
+    var mobileeditdata=document.getElementById('mobileeditdata');
+
+    
+    editor.showdataarea=function(callShowMode){
+        mid.style='z-index:-1;opacity: 0;';
+        right.style='z-index:-1;opacity: 0;';
+        mobileeditdata.style='';
+        if(callShowMode)editor.mode.showMode(editModeSelect.value);
+        editor.hideMidMenu();
+    }
+    mobileview.children[0].onclick=function(){
+        editor.showdataarea(true)
+    }
+    mobileview.children[1].onclick=function(){
+        mid.style='';
+        right.style='z-index:-1;opacity: 0;';
+        mobileeditdata.style='z-index:-1;opacity: 0;';
+        editor.lastClickId='';
+    }
+    mobileview.children[3].onclick=function(){
+        mid.style='z-index:-1;opacity: 0;';
+        right.style='';
+        mobileeditdata.style='z-index:-1;opacity: 0;';
+        editor.lastClickId='';
+    }
+
+
+    var gettrbyid=function(){
+        if(!editor.lastClickId)return false;
+        thisTr = document.getElementById(editor.lastClickId);
+        input = thisTr.children[2].children[0].children[0];
+        field = thisTr.children[0].getAttribute('title');
+        cobj = JSON.parse(thisTr.children[1].getAttribute('cobj'));
+        return [thisTr,input,field,cobj];
+    }
+    mobileeditdata.children[0].onclick=function(){
+        var info = gettrbyid()
+        if(!info)return;
+        info[1].ondblclick()
+    }
+    mobileeditdata.children[1].onclick=function(){
+        var info = gettrbyid()
+        if(!info)return;
+        printf(info[2])
+    }
+    mobileeditdata.children[2].onclick=function(){
+        var info = gettrbyid()
+        if(!info)return;
+        printf(info[0].children[1].getAttribute('title'))
+    }
+
+    //=====
+
+    document.body.ontouchstart=document.body.onmousedown;
+    document.body.onmousedown=null;
+
+
+    var eui=document.getElementById('eui');
+    eui.ontouchstart=eui.onmousedown
+    eui.onmousedown=null
+    eui.ontouchmove=eui.onmousemove
+    eui.onmousemove=null
+    eui.ontouchend=eui.onmouseup
+    eui.onmouseup=null
+
+
+    var chooseThis = document.getElementById('chooseThis');
+    chooseThis.ontouchstart=chooseThis.onmousedown
+    chooseThis.onmousedown=null
+    var chooseInRight = document.getElementById('chooseInRight');
+    chooseInRight.ontouchstart=chooseInRight.onmousedown
+    chooseInRight.onmousedown=null
+    var copyLoc = document.getElementById('copyLoc');
+    copyLoc.ontouchstart=copyLoc.onmousedown
+    copyLoc.onmousedown=null
+    var moveLoc = document.getElementById('moveLoc');
+    moveLoc.ontouchstart=moveLoc.onmousedown
+    moveLoc.onmousedown=null
+    var clearLoc = document.getElementById('clearLoc');
+    clearLoc.ontouchstart=clearLoc.onmousedown
+    clearLoc.onmousedown=null
+}
+
+}
\ No newline at end of file
diff --git a/_server/editor_unsorted_2.js b/_server/editor_unsorted_2.js
new file mode 100644
index 00000000..17b8092e
--- /dev/null
+++ b/_server/editor_unsorted_2.js
@@ -0,0 +1,636 @@
+editor_unsorted_2_wrapper=function(editor_mode){
+
+    editor_mode.constructor.prototype.listen=function (callback) {
+        var newIdIdnum = document.getElementById('newIdIdnum');
+        newIdIdnum.children[2].onclick = function () {
+            if (newIdIdnum.children[0].value && newIdIdnum.children[1].value) {
+                var id = newIdIdnum.children[0].value;
+                var idnum = parseInt(newIdIdnum.children[1].value);
+                if (!core.isset(idnum)) {
+                    printe('不合法的idnum');
+                    return;
+                }
+                if (!/^[0-9a-zA-Z_]+$/.test(id)) {
+                    printe('不合法的id，请使用字母、数字或下划线')
+                    return;
+                }
+                editor.file.changeIdAndIdnum(id, idnum, editor_mode.info, function (err) {
+                    if (err) {
+                        printe(err);
+                        throw(err)
+                    }
+                    printe('添加id和idnum成功,请F5刷新编辑器');
+                });
+            } else {
+                printe('请输入id和idnum');
+            }
+        }
+
+        newIdIdnum.children[4].onclick = function () {
+            editor.file.autoRegister(editor_mode.info, function (err) {
+                if (err) {
+                    printe(err);
+                    throw(err)
+                }
+                printe('该列所有剩余项全部自动注册成功,请F5刷新编辑器');
+            })
+        }
+
+        var changeId = document.getElementById('changeId');
+        changeId.children[1].onclick = function () {
+            var id = changeId.children[0].value;
+            if (id) {
+                if (!/^[0-9a-zA-Z_]+$/.test(id)) {
+                    printe('不合法的id，请使用字母、数字或下划线')
+                    return;
+                }
+                editor.file.changeIdAndIdnum(id, null, editor_mode.info, function (err) {
+                    if (err) {
+                        printe(err);
+                        throw(err);
+                    }
+                    printe('修改id成功,请F5刷新编辑器');
+                });
+            } else {
+                printe('请输入要修改到的ID');
+            }
+        }
+
+        var selectFloor = document.getElementById('selectFloor');
+        editor.game.getFloorFileList(function (floors) {
+            var outstr = [];
+            floors[0].forEach(function (floor) {
+                outstr.push(["<option value='", floor, "'>", floor, '</option>\n'].join(''));
+            });
+            selectFloor.innerHTML = outstr.join('');
+            selectFloor.value = core.status.floorId;
+            selectFloor.onchange = function () {
+                editor_mode.onmode('nextChange');
+                editor_mode.onmode('floor');
+                editor.changeFloor(selectFloor.value);
+            }
+        });
+
+        var saveFloor = document.getElementById('saveFloor');
+        editor_mode.saveFloor = function () {
+            editor_mode.onmode('');
+            editor.file.saveFloorFile(function (err) {
+                if (err) {
+                    printe(err);
+                    throw(err)
+                }
+                ;printf('保存成功');
+            });
+        }
+        saveFloor.onclick = editor_mode.saveFloor;
+
+        var newMap = document.getElementById('newMap');
+        var newFileName = document.getElementById('newFileName');
+        newMap.onclick = function () {
+            if (!newFileName.value) return;
+            if (core.floorIds.indexOf(newFileName.value)>=0) {
+                printe("该楼层已存在！");
+                return;
+            }
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(newFileName.value)) {
+                printe("楼层名不合法！请使用字母、数字、下划线，且不能以数字开头！");
+                return;
+            }
+            var width = parseInt(document.getElementById('newMapWidth').value);
+            var height = parseInt(document.getElementById('newMapHeight').value);
+            if (!core.isset(width) || !core.isset(height) || width<core.__SIZE__ || height<core.__SIZE__ || width*height>1000) {
+                printe("新建地图的宽高都不得小于"+core.__SIZE__+"，且宽高之积不能超过1000");
+                return;
+            }
+
+            editor_mode.onmode('');
+            editor.file.saveNewFile(newFileName.value, function (err) {
+                if (err) {
+                    printe(err);
+                    throw(err)
+                }
+                core.floorIds.push(newFileName.value);
+                editor.file.editTower([['change', "['main']['floorIds']", core.floorIds]], function (objs_) {//console.log(objs_);
+                    if (objs_.slice(-1)[0] != null) {
+                        printe(objs_.slice(-1)[0]);
+                        throw(objs_.slice(-1)[0])
+                    }
+                    ;printe('新建成功,请F5刷新编辑器生效');
+                });
+            });
+        }
+
+        var newMaps = document.getElementById('newMaps');
+        var newFloors = document.getElementById('newFloors');
+        newMaps.onclick = function () {
+            if (newFloors.style.display == 'none') newFloors.style.display = 'block';
+            else newFloors.style.display = 'none';
+        }
+
+        var createNewMaps = document.getElementById('createNewMaps');
+        createNewMaps.onclick = function () {
+            var floorIds = document.getElementById('newFloorIds').value;
+            if (!floorIds) return;
+            var from = parseInt(document.getElementById('newMapsFrom').value),
+                to = parseInt(document.getElementById('newMapsTo').value);
+            if (!core.isset(from) || !core.isset(to) || from>to || from<0 || to<0) {
+                printe("请输入有效的起始和终止楼层");
+                return;
+            }
+            if (to-from >= 100) {
+                printe("一次最多创建99个楼层");
+                return;
+            }
+            var floorIdList = [];
+            for (var i = from; i<=to; i++) {
+                var floorId = floorIds.replace(/\${(.*?)}/g, function (word, value) {
+                    return eval(value);
+                });
+                if (core.floorIds.indexOf(floorId)>=0) {
+                    printe("要创建的楼层 "+floorId+" 已存在！");
+                    return;
+                }
+                if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(floorId)) {
+                    printe("楼层名 "+floorId+" 不合法！请使用字母、数字、下划线，且不能以数字开头！");
+                    return;
+                }
+                if (floorIdList.indexOf(floorId)>=0) {
+                    printe("尝试重复创建楼层 "+floorId+" ！");
+                    return;
+                }
+                floorIdList.push(floorId);
+            }
+
+            var width = parseInt(document.getElementById('newMapsWidth').value);
+            var height = parseInt(document.getElementById('newMapsHeight').value);
+            if (!core.isset(width) || !core.isset(height) || width<core.__SIZE__ || height<core.__SIZE__ || width*height>1000) {
+                printe("新建地图的宽高都不得小于"+core.__SIZE__+"，且宽高之积不能超过1000");
+                return;
+            }
+            editor_mode.onmode('');
+            
+            editor.file.saveNewFiles(floorIdList, from, to, function (err) {
+                if (err) {
+                    printe(err);
+                    throw(err)
+                }
+                core.floorIds = core.floorIds.concat(floorIdList);
+                editor.file.editTower([['change', "['main']['floorIds']", core.floorIds]], function (objs_) {//console.log(objs_);
+                    if (objs_.slice(-1)[0] != null) {
+                        printe(objs_.slice(-1)[0]);
+                        throw(objs_.slice(-1)[0])
+                    }
+                    ;printe('批量创建 '+floorIdList[0]+'~'+floorIdList[floorIdList.length-1]+' 成功,请F5刷新编辑器生效');
+                });
+            });
+        }
+
+        var changeFloorId = document.getElementById('changeFloorId');
+        changeFloorId.children[1].onclick = function () {
+            var floorId = changeFloorId.children[0].value;
+            if (floorId) {
+                if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(floorId)) {
+                    printe("楼层名 "+floorId+" 不合法！请使用字母、数字、下划线，且不能以数字开头！");
+                    return;
+                }
+                if (main.floorIds.indexOf(floorId)>=0) {
+                    printe("楼层名 "+floorId+" 已存在！");
+                    return;
+                }
+                var currentFloorId = editor.currentFloorId;
+                editor.currentFloorId = floorId;
+                editor.currentFloorData.floorId = floorId;
+                editor.file.saveFloorFile(function (err) {
+                    if (err) {
+                        printe(err);
+                        throw(err);
+                    }
+                    core.floorIds[core.floorIds.indexOf(currentFloorId)] = floorId;
+                    editor.file.editTower([['change', "['main']['floorIds']", core.floorIds]], function (objs_) {//console.log(objs_);
+                        if (objs_.slice(-1)[0] != null) {
+                            printe(objs_.slice(-1)[0]);
+                            throw(objs_.slice(-1)[0])
+                        }
+                        alert("修改floorId成功，需要刷新编辑器生效。\n请注意，原始的楼层文件没有删除，请根据需要手动删除。");
+                        window.location.reload();
+                    });
+                });
+            } else {
+                printe('请输入要修改到的floorId');
+            }
+        }
+
+        var ratio = 1;
+        var appendPicCanvas = document.getElementById('appendPicCanvas');
+        var bg = appendPicCanvas.children[0];
+        var source = appendPicCanvas.children[1];
+        var source_ctx=source.getContext('2d');
+        var picClick = appendPicCanvas.children[2];
+        var sprite = appendPicCanvas.children[3];
+        var sprite_ctx=sprite.getContext('2d');
+        var appendPicSelection = document.getElementById('appendPicSelection');
+        
+        [source_ctx,sprite_ctx].forEach(function(ctx){
+            ctx.mozImageSmoothingEnabled = false;
+            ctx.webkitImageSmoothingEnabled = false;
+            ctx.msImageSmoothingEnabled = false;
+            ctx.imageSmoothingEnabled = false;
+        })
+
+        var selectAppend = document.getElementById('selectAppend');
+        var selectAppend_str = [];
+        ["terrains", "animates", "enemys", "enemy48", "items", "npcs", "npc48", "autotile"].forEach(function (image) {
+            selectAppend_str.push(["<option value='", image, "'>", image, '</option>\n'].join(''));
+        });
+        selectAppend.innerHTML = selectAppend_str.join('');
+        selectAppend.onchange = function () {
+
+            var value = selectAppend.value;
+
+            if (value == 'autotile') {
+                editor_mode.appendPic.imageName = 'autotile';
+                for (var jj=0;jj<4;jj++) appendPicSelection.children[jj].style = 'display:none';
+                if (editor_mode.appendPic.img) {
+                    sprite.style.width = (sprite.width = editor_mode.appendPic.img.width) / ratio + 'px';
+                    sprite.style.height = (sprite.height = editor_mode.appendPic.img.height) / ratio + 'px';
+                    sprite_ctx.clearRect(0, 0, sprite.width, sprite.height);
+                    sprite_ctx.drawImage(editor_mode.appendPic.img, 0, 0);
+                }
+                return;
+            }
+
+            var ysize = selectAppend.value.endsWith('48') ? 48 : 32;
+            editor_mode.appendPic.imageName = value;
+            var img = core.material.images[value];
+            editor_mode.appendPic.toImg = img;
+            var num = ~~img.width / 32;
+            editor_mode.appendPic.num = num;
+            editor_mode.appendPic.index = 0;
+            var selectStr = '';
+            for (var ii = 0; ii < num; ii++) {
+                appendPicSelection.children[ii].style = 'left:0;top:0;height:' + (ysize - 6) + 'px';
+                selectStr += '{"x":0,"y":0},'
+            }
+            editor_mode.appendPic.selectPos = eval('[' + selectStr + ']');
+            for (var jj = num; jj < 4; jj++) {
+                appendPicSelection.children[jj].style = 'display:none';
+            }
+            sprite.style.width = (sprite.width = img.width) / ratio + 'px';
+            sprite.style.height = (sprite.height = img.height + ysize) / ratio + 'px';
+            sprite_ctx.drawImage(img, 0, 0);
+        }
+        selectAppend.onchange();
+
+        var getPixel=editor.util.getPixel
+        var setPixel=editor.util.setPixel
+
+        var autoAdjust = function (image, callback) {
+            var changed = false;
+
+            // Step 1: 检测白底
+            var tempCanvas = document.createElement('canvas').getContext('2d');
+            tempCanvas.canvas.width = image.width;
+            tempCanvas.canvas.height = image.height;
+            tempCanvas.mozImageSmoothingEnabled = false;
+            tempCanvas.webkitImageSmoothingEnabled = false;
+            tempCanvas.msImageSmoothingEnabled = false;
+            tempCanvas.imageSmoothingEnabled = false;
+            tempCanvas.drawImage(image, 0, 0);
+            var imgData = tempCanvas.getImageData(0, 0, image.width, image.height);
+            var trans = 0, white = 0, black=0;
+            for (var i=0;i<image.width;i++) {
+                for (var j=0;j<image.height;j++) {
+                    var pixel = getPixel(imgData, i, j);
+                    if (pixel[3]==0) trans++;
+                    if (pixel[0]==255 && pixel[1]==255 && pixel[2]==255 && pixel[3]==255) white++;
+                    // if (pixel[0]==0 && pixel[1]==0 && pixel[2]==0 && pixel[3]==255) black++;
+                }
+            }
+            if (white>black && white>trans*10 && confirm("看起来这张图片是以纯白为底色，是否自动调整为透明底色？")) {
+                for (var i=0;i<image.width;i++) {
+                    for (var j=0;j<image.height;j++) {
+                        var pixel = getPixel(imgData, i, j);
+                        if (pixel[0]==255 && pixel[1]==255 && pixel[2]==255 && pixel[3]==255) {
+                            setPixel(imgData, i, j, [0,0,0,0]);
+                        }
+                    }
+                }
+                tempCanvas.clearRect(0, 0, image.width, image.height);
+                tempCanvas.putImageData(imgData, 0, 0);
+                changed = true;
+            }
+            /*
+            if (black>white && black>trans*10 && confirm("看起来这张图片是以纯黑为底色，是否自动调整为透明底色？")) {
+                for (var i=0;i<image.width;i++) {
+                    for (var j=0;j<image.height;j++) {
+                        var pixel = getPixel(imgData, i, j);
+                        if (pixel[0]==0 && pixel[1]==0 && pixel[2]==0 && pixel[3]==255) {
+                            setPixel(imgData, i, j, [0,0,0,0]);
+                        }
+                    }
+                }
+                tempCanvas.clearRect(0, 0, image.width, image.height);
+                tempCanvas.putImageData(imgData, 0, 0);
+                changed = true;
+            }
+            */
+
+            // Step 2: 检测长宽比
+            var ysize = selectAppend.value.endsWith('48') ? 48 : 32;
+            if ((image.width%32!=0 || image.height%ysize!=0) && (image.width<=128 && image.height<=ysize*4)
+                && confirm("目标长宽不符合条件，是否自动进行调整？")) {
+                var ncanvas = document.createElement('canvas').getContext('2d');
+                ncanvas.canvas.width = 128;
+                ncanvas.canvas.height = 4*ysize;
+                ncanvas.mozImageSmoothingEnabled = false;
+                ncanvas.webkitImageSmoothingEnabled = false;
+                ncanvas.msImageSmoothingEnabled = false;
+                ncanvas.imageSmoothingEnabled = false;
+                var w = image.width / 4, h = image.height / 4;
+                for (var i=0;i<4;i++) {
+                    for (var j=0;j<4;j++) {
+                        ncanvas.drawImage(tempCanvas.canvas, i*w, j*h, w, h, i*32 + (32-w)/2, j*ysize + (ysize-h)/2, w, h);
+                    }
+                }
+                tempCanvas = ncanvas;
+                changed = true;
+            }
+
+            if (!changed) {
+                callback(image);
+            }
+            else {
+                var nimg = new Image();
+                nimg.onload = function () {
+                    callback(nimg);
+                };
+                nimg.src = tempCanvas.canvas.toDataURL();
+            }
+        }
+
+        var selectFileBtn = document.getElementById('selectFileBtn');
+        selectFileBtn.onclick = function () {
+            var loadImage = function (content, callback) {
+                var image = new Image();
+                try {
+                    image.onload = function () {
+                        callback(image);
+                    }
+                    image.src = content;
+                }
+                catch (e) {
+                    printe(e);
+                }
+            }
+            core.readFile(function (content) {
+                loadImage(content, function (image) {
+                    autoAdjust(image, function (image) {
+                        editor_mode.appendPic.img = image;
+                        editor_mode.appendPic.width = image.width;
+                        editor_mode.appendPic.height = image.height;
+
+                        if (selectAppend.value == 'autotile') {
+                            for (var ii = 0; ii < 3; ii++) {
+                                var newsprite = appendPicCanvas.children[ii];
+                                newsprite.style.width = (newsprite.width = image.width) / ratio + 'px';
+                                newsprite.style.height = (newsprite.height = image.height) / ratio + 'px';
+                            }
+                            sprite_ctx.clearRect(0, 0, sprite.width, sprite.height);
+                            sprite_ctx.drawImage(image, 0, 0);
+                        }
+                        else {
+                            var ysize = selectAppend.value.endsWith('48') ? 48 : 32;
+                            for (var ii = 0; ii < 3; ii++) {
+                                var newsprite = appendPicCanvas.children[ii];
+                                newsprite.style.width = (newsprite.width = Math.floor(image.width / 32) * 32) / ratio + 'px';
+                                newsprite.style.height = (newsprite.height = Math.floor(image.height / ysize) * ysize) / ratio + 'px';
+                            }
+                        }
+
+                        //画灰白相间的格子
+                        var bgc = bg.getContext('2d');
+                        var colorA = ["#f8f8f8", "#cccccc"];
+                        var colorIndex;
+                        var sratio = 4;
+                        for (var ii = 0; ii < image.width / 32 * sratio; ii++) {
+                            colorIndex = 1 - ii % 2;
+                            for (var jj = 0; jj < image.height / 32 * sratio; jj++) {
+                                bgc.fillStyle = colorA[colorIndex];
+                                colorIndex = 1 - colorIndex;
+                                bgc.fillRect(ii * 32 / sratio, jj * 32 / sratio, 32 / sratio, 32 / sratio);
+                            }
+                        }
+
+                        //把导入的图片画出
+                        source_ctx.drawImage(image, 0, 0);
+                        editor_mode.appendPic.sourceImageData=source_ctx.getImageData(0,0,image.width,image.height);
+
+                        //重置临时变量
+                        selectAppend.onchange();
+                    });
+                });
+            }, null, 'img');
+
+            return;
+        }
+
+        var changeColorInput=document.getElementById('changeColorInput')
+        changeColorInput.oninput=function(){
+            var delta=(~~changeColorInput.value)*30;
+            var imgData=editor_mode.appendPic.sourceImageData;
+            var nimgData=new ImageData(imgData.width,imgData.height);
+            // ImageData .data 形如一维数组,依次排着每个点的 R(0~255) G(0~255) B(0~255) A(0~255)
+            var convert=function(rgba,delta){
+                var rgbToHsl = editor.util.rgbToHsl
+                var hue2rgb = editor.util.hue2rgb
+                var hslToRgb = editor.util.hslToRgb
+                //
+                var hsl=rgbToHsl(rgba)
+                hsl[0]=(hsl[0]+delta)%360
+                var nrgb=hslToRgb(hsl)
+                nrgb.push(rgba[3])
+                return nrgb
+            }
+            for(var x=0; x<imgData.width; x++){
+                for(var y=0 ; y<imgData.height; y++){
+                    setPixel(nimgData,x,y,convert(getPixel(imgData,x,y),delta))
+                }
+            }
+            source_ctx.clearRect(0, 0, imgData.width, imgData.height);
+            source_ctx.putImageData(nimgData, 0, 0);
+        }
+
+        var left1 = document.getElementById('left1');
+        var eToLoc = function (e) {
+            var scrollLeft = document.documentElement.scrollLeft || document.body.scrollLeft
+            var scrollTop = document.documentElement.scrollTop || document.body.scrollTop
+            var loc = {
+                'x': scrollLeft + e.clientX + appendPicCanvas.scrollLeft - left1.offsetLeft - appendPicCanvas.offsetLeft,
+                'y': scrollTop + e.clientY + appendPicCanvas.scrollTop - left1.offsetTop - appendPicCanvas.offsetTop,
+                'size': 32,
+                'ysize': selectAppend.value.endsWith('48') ? 48 : 32
+            };
+            return loc;
+        }//返回可用的组件内坐标
+
+        var locToPos = function (loc) {
+            var pos = {'x': ~~(loc.x / loc.size), 'y': ~~(loc.y / loc.ysize), 'ysize': loc.ysize}
+            return pos;
+        }
+
+        picClick.onclick = function (e) {
+            var loc = eToLoc(e);
+            var pos = locToPos(loc);
+            //console.log(e,loc,pos);
+            var num = editor_mode.appendPic.num;
+            var ii = editor_mode.appendPic.index;
+            if (ii + 1 >= num) editor_mode.appendPic.index = ii + 1 - num;
+            else editor_mode.appendPic.index++;
+            editor_mode.appendPic.selectPos[ii] = pos;
+            appendPicSelection.children[ii].style = [
+                'left:', pos.x * 32, 'px;',
+                'top:', pos.y * pos.ysize, 'px;',
+                'height:', pos.ysize - 6, 'px;'
+            ].join('');
+        }
+
+        var appendConfirm = document.getElementById('appendConfirm');
+        appendConfirm.onclick = function () {
+
+            var confirmAutotile = function () {
+                var image = editor_mode.appendPic.img;
+                if (image.width % 96 !=0 || image.height != 128) {
+                    printe("不合法的Autotile图片！");
+                    return;
+                }
+                var imgData = source_ctx.getImageData(0,0,image.width,image.height);
+                sprite_ctx.putImageData(imgData, 0, 0);
+                var imgbase64 = sprite.toDataURL().split(',')[1];
+
+                // Step 1: List文件名
+                fs.readdir('./project/images', function (err, data) {
+                    if (err) {
+                        printe(err);
+                        throw(err);
+                    }
+
+                    // Step 2: 选择Autotile文件名
+                    var filename;
+                    for (var i=1;;++i) {
+                        filename = 'autotile'+i;
+                        if (data.indexOf(filename+".png")==-1) break;
+                    }
+
+                    // Step 3: 写入文件
+                    fs.writeFile('./project/images/'+filename+".png", imgbase64, 'base64', function (err, data) {
+                        if (err) {
+                            printe(err);
+                            throw(err);
+                        }
+                        // Step 4: 自动注册
+                        editor.file.registerAutotile(filename, function (err) {
+                            if (err) {
+                                printe(err);
+                                throw(err);
+                            }
+                            printe('自动元件'+filename+'注册成功,请F5刷新编辑器');
+                        })
+
+                    })
+
+                })
+
+            }
+
+            if (selectAppend.value == 'autotile') {
+                confirmAutotile();
+                return;
+            }
+
+            var ysize = selectAppend.value.endsWith('48') ? 48 : 32;
+            for (var ii = 0, v; v = editor_mode.appendPic.selectPos[ii]; ii++) {
+                // var imgData = source_ctx.getImageData(v.x * 32, v.y * ysize, 32, ysize);
+                // sprite_ctx.putImageData(imgData, ii * 32, sprite.height - ysize);
+                // sprite_ctx.drawImage(editor_mode.appendPic.img, v.x * 32, v.y * ysize, 32, ysize,  ii * 32, height,  32, ysize)
+
+                sprite_ctx.drawImage(source_ctx.canvas, v.x*32, v.y*ysize, 32, ysize, 32*ii, sprite.height - ysize, 32, ysize);
+            }
+            var dt = sprite_ctx.getImageData(0, 0, sprite.width, sprite.height);
+            var imgbase64 = sprite.toDataURL().split(',')[1];
+            fs.writeFile('./project/images/' + editor_mode.appendPic.imageName + '.png', imgbase64, 'base64', function (err, data) {
+                if (err) {
+                    printe(err);
+                    throw(err)
+                }
+                printe('追加素材成功，请F5刷新编辑器，或继续追加当前素材');
+                sprite.style.height = (sprite.height = (sprite.height+ysize)) + "px";
+                sprite_ctx.putImageData(dt, 0, 0);
+            });
+        }
+
+        var editModeSelect = document.getElementById('editModeSelect');
+        editModeSelect.onchange = function () {
+            editor_mode.onmode('nextChange');
+            editor_mode.onmode(editModeSelect.value);
+            if(editor.isMobile)editor.showdataarea(false);
+        }
+
+        editor_mode.checkUnique = function (thiseval) {
+            if (!(thiseval instanceof Array)) return false;
+            var map = {};
+            for (var i = 0; i<thiseval.length; ++i) {
+                if (map[thiseval[i]]) {
+                    alert("警告：存在重复定义！");
+                    return false;
+                }
+                map[thiseval[i]] = true;
+            }
+            return true;
+        }
+
+        editor_mode.checkFloorIds = function(thiseval){
+            if (!editor_mode.checkUnique(thiseval)) return false;
+            var oldvalue = data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.main.floorIds;
+            fs.readdir('project/floors',function(err, data){
+                if(err){
+                    printe(err);
+                    throw Error(err);
+                }
+                var newfiles=thiseval.map(function(v){return v+'.js'});
+                var notExist='';
+                for(var name,ii=0;name=newfiles[ii];ii++){
+                    if(data.indexOf(name)===-1)notExist=name;
+                }
+                if(notExist){
+                    var discard=confirm('文件'+notExist+'不存在, 保存会导致工程无法打开, 是否放弃更改');
+                    if(discard){
+                        editor.file.editTower([['change', "['main']['floorIds']", oldvalue]], function (objs_) {//console.log(objs_);
+                            if (objs_.slice(-1)[0] != null) {
+                                printe(objs_.slice(-1)[0]);
+                                throw(objs_.slice(-1)[0])
+                            }
+                            ;printe('已放弃floorIds的修改，请F5进行刷新');
+                        });
+                    }
+                }
+            });
+            return true
+        }
+
+        editor_mode.changeDoubleClickModeByButton=function(mode){
+            ({
+                delete:function(){
+                    printf('下一次双击表格的项删除，切换下拉菜单可取消；编辑后需刷新浏览器生效。');
+                    editor_mode.doubleClickMode=mode;
+                },
+                add:function(){
+                    printf('下一次双击表格的项则在同级添加新项，切换下拉菜单可取消；编辑后需刷新浏览器生效。');
+                    editor_mode.doubleClickMode=mode;
+                }
+            }[mode])();
+        }
+
+        if (Boolean(callback)) callback();
+    }
+
+}
\ No newline at end of file
diff --git a/_server/editor_unsorted_3.js b/_server/editor_unsorted_3.js
new file mode 100644
index 00000000..170238e9
--- /dev/null
+++ b/_server/editor_unsorted_3.js
@@ -0,0 +1,369 @@
+
+exportMap = document.getElementById('exportMap')
+exportMap.isExport=false
+exportMap.onclick=function(){
+    editor.updateMap();
+    var sx=editor.map.length-1,sy=editor.map[0].length-1;
+
+    var filestr = '';
+    for (var yy = 0; yy <= sy; yy++) {
+        filestr += '['
+        for (var xx = 0; xx <= sx; xx++) {
+            var mapxy = editor.map[yy][xx];
+            if (typeof(mapxy) == typeof({})) {
+                if ('idnum' in mapxy) mapxy = mapxy.idnum;
+                else {
+                    // mapxy='!!?';
+                    tip.whichShow(3);
+                    return;
+                }
+            } else if (typeof(mapxy) == 'undefined') {
+                tip.whichShow(3);
+                return;
+            }
+            mapxy = String(mapxy);
+            mapxy = Array(Math.max(4 - mapxy.length, 0)).join(' ') + mapxy;
+            filestr += mapxy + (xx == sx ? '' : ',')
+        }
+
+        filestr += ']' + (yy == sy ? '' : ',\n');
+    }
+    pout.value = filestr;
+    mapEditArea.mapArr(filestr);
+    exportMap.isExport = true;
+    mapEditArea.error(0);
+    tip.whichShow(2);
+}
+mapEditArea = document.getElementById('mapEditArea')
+mapEditArea.errors=[ // 编号1,2
+    "格式错误！请使用正确格式(请使用地图生成器进行生成，且需要和本地图宽高完全一致)",
+    "当前有未定义ID（在地图区域显示红块），请修改ID或者到icons.js和maps.js中进行定义！"
+]
+mapEditArea.formatTimer=null
+mapEditArea._mapArr=''
+mapEditArea.mapArr=function(value){
+    if(value!=null){
+        var val=value
+        var oldval=mapEditArea._mapArr
+        if (val==oldval) return;
+
+        if (exportMap.isExport) {
+            exportMap.isExport = false;
+            return;
+        }
+        if (mapEditArea.formatArr()) {
+            mapEditArea.error(0);
+
+            setTimeout(function () {
+                if (mapEditArea.formatArr())mapEditArea.mapArr(mapEditArea.formatArr());
+                mapEditArea.drawMap();
+                tip.whichShow(8)
+            }, 1000);
+            clearTimeout(mapEditArea.formatTimer);
+            mapEditArea.formatTimer = setTimeout(function () {
+                pout.value = mapEditArea.formatArr();
+            }, 5000); //5s后再格式化，不然光标跳到最后很烦
+        } else {
+            mapEditArea.error(1);
+        }
+
+        mapEditArea._mapArr=value
+    }
+    return mapEditArea._mapArr
+}
+pout.oninput=function(){
+    mapEditArea.mapArr(pout.value)
+}
+mapEditArea._error=0
+mapEditArea.error=function(value){
+    if(value!=null){
+        mapEditArea._error=value
+        if (value>0)
+        printe(mapEditArea.errors[value-1])
+    }
+    return mapEditArea._error
+}
+mapEditArea.drawMap= function () {
+    // var mapArray = mapEditArea.mapArr().split(/\D+/).join(' ').trim().split(' ');
+    var mapArray = JSON.parse('[' + mapEditArea.mapArr() + ']');
+    var sy=editor.map.length,sx=editor.map[0].length;
+    for (var y = 0; y < sy; y++)
+        for (var x = 0; x < sx; x++) {
+            var num = mapArray[y][x];
+            if (num == 0)
+                editor.map[y][x] = 0;
+            else if (typeof(editor.indexs[num][0]) == 'undefined') {
+                mapEditArea.error(2);
+                editor.map[y][x] = undefined;
+            } else editor.map[y][x] = editor.ids[[editor.indexs[num][0]]];
+        }
+
+    editor.updateMap();
+
+}
+mapEditArea.formatArr= function () {
+    var formatArrStr = '';
+    console.log(1)
+    
+    var si=editor.map.length,sk=editor.map[0].length;
+    if (mapEditArea.mapArr().split(/\D+/).join(' ').trim().split(' ').length != si*sk) return false;
+    var arr = mapEditArea.mapArr().replace(/\s+/g, '').split('],[');
+
+    if (arr.length != si) return;
+    for (var i = 0; i < si; i++) {
+        var a = [];
+        formatArrStr += '[';
+        if (i == 0 || i == si-1) a = arr[i].split(/\D+/).join(' ').trim().split(' ');
+        else a = arr[i].split(/\D+/);
+        if (a.length != sk) {
+            formatArrStr = '';
+            return;
+        }
+
+        for (var k = 0; k < sk; k++) {
+            var num = parseInt(a[k]);
+            formatArrStr += Array(Math.max(4 - String(num).length, 0)).join(' ') + num + (k == sk-1 ? '' : ',');
+        }
+        formatArrStr += ']' + (i == si-1 ? '' : ',\n');
+    }
+    return formatArrStr;
+}
+copyMap=document.getElementById('copyMap')
+copyMap.err=''
+copyMap.onclick=function(){
+    tip.whichShow(0);
+    if (pout.value.trim() != '') {
+        if (mapEditArea.error()) {
+            copyMap.err = mapEditArea.errors[mapEditArea.error() - 1];
+            tip.whichShow(5)
+            return;
+        }
+        try {
+            pout.focus();
+            pout.setSelectionRange(0, pout.value.length);
+            document.execCommand("Copy");
+            tip.whichShow(6);
+        } catch (e) {
+            copyMap.err = e;
+            tip.whichShow(5);
+        }
+    } else {
+        tip.whichShow(7);
+    }
+}
+clearMapButton=document.getElementById('clearMapButton')
+clearMapButton.onclick=function () {
+    editor.mapInit();
+    editor_mode.onmode('');
+    editor.file.saveFloorFile(function (err) {
+        if (err) {
+            printe(err);
+            throw(err)
+        }
+        ;printf('地图清除成功');
+    });
+    editor.updateMap();
+    clearTimeout(mapEditArea.formatTimer);
+    clearTimeout(tip.timer);
+    pout.value = '';
+    mapEditArea.mapArr('');
+    tip.whichShow(4);
+    mapEditArea.error(0);
+}
+deleteMap=document.getElementById('deleteMap')
+deleteMap.onclick=function () {
+    editor_mode.onmode('');
+    var index = core.floorIds.indexOf(editor.currentFloorId);
+    if (index>=0) {
+        core.floorIds.splice(index,1);
+        editor.file.editTower([['change', "['main']['floorIds']", core.floorIds]], function (objs_) {//console.log(objs_);
+            if (objs_.slice(-1)[0] != null) {
+                printe(objs_.slice(-1)[0]);
+                throw(objs_.slice(-1)[0])
+            }
+            ;printe('删除成功,请F5刷新编辑器生效');
+        });
+    }
+    else printe('删除成功,请F5刷新编辑器生效');
+}
+printf = function (str_, type) {
+    selectBox.isSelected(false);
+    if (!type) {
+        tip.whichShow(11);
+    } else {
+        tip.whichShow(12);
+    }
+    setTimeout(function () {
+        if (!type) {
+            tip.msgs[11] = String(str_);
+            tip.whichShow(12);
+        } else {
+            tip.msgs[10] = String(str_);
+            tip.whichShow(11);
+        }
+    }, 1);
+}
+printe = function (str_) {
+    printf(str_, 'error')
+}
+tip_in_showMode = [
+    '涉及图片的更改需要F5刷新浏览器来生效',
+    '文本域可以通过双击,在文本编辑器或事件编辑器中编辑',
+    '事件编辑器中的显示文本和自定义脚本的方块也可以双击',
+    "画出的地图要点击\"保存地图\"才会写入到文件中",
+];
+tip=document.getElementById('tip')
+tip._infos= {}
+tip.infos=function(value){
+    if(value!=null){
+        var val=value
+        var oldval=tip._infos
+
+        tip.isClearBlock(false);
+        tip.isAirwall(false);
+        if (typeof(val) != 'undefined') {
+            if (val == 0) {
+                tip.isClearBlock(true);
+                return;
+            }
+            if ('id' in val) {
+                if (val.idnum == 17) {
+                    tip.isAirwall(true);
+                    return;
+                }
+                tip.hasId = true;
+            } else {
+                tip.hasId = false;
+            }
+            tip.isAutotile = false;
+            if (val.images == "autotile" && tip.hasId) tip.isAutotile = true;
+            document.getElementById('isAirwall-else').innerHTML=(tip.hasId?`<p>图块编号：<span class="infoText">${ value['idnum'] }</span></p>
+            <p>图块ID：<span class="infoText">${ value['id'] }</span></p>`:`
+            <p class="warnText">该图块无对应的数字或ID存在，请先前往icons.js和maps.js中进行定义！</p>`)+`
+            <p>图块所在素材：<span class="infoText">${ value['images'] + (tip.isAutotile ? '( '+value['id']+' )' : '') }</span>
+            </p>
+            <p>图块索引：<span class="infoText">${ value['y'] }</span></p>`
+        }
+
+        tip._infos=value
+    }
+    return tip._infos
+}
+tip.hasId= true
+tip.isAutotile= false
+tip._isSelectedBlock= false
+tip.isSelectedBlock=function(value){
+    if(value!=null){
+        var dshow=document.getElementById('isSelectedBlock-if')
+        var dhide=document.getElementById('isSelectedBlock-else')
+        if(!value){
+            var dtemp=dshow
+            dshow=dhide
+            dhide=dtemp
+        }
+        dshow.style.display=''
+        dhide.style.display='none'
+        tip._isSelectedBlock=value
+    }
+    return tip._isSelectedBlock
+}
+tip._isClearBlock= false
+tip.isClearBlock=function(value){
+    if(value!=null){
+        var dshow=document.getElementById('isClearBlock-if')
+        var dhide=document.getElementById('isClearBlock-else')
+        if(!value){
+            var dtemp=dshow
+            dshow=dhide
+            dhide=dtemp
+        }
+        dshow.style.display=''
+        dhide.style.display='none'
+        tip._isClearBlock=value
+    }
+    return tip._isClearBlock
+}
+tip._isAirwall= false
+tip.isAirwall=function(value){
+    if(value!=null){
+        var dshow=document.getElementById('isAirwall-if')
+        var dhide=document.getElementById('isAirwall-else')
+        if(!value){
+            var dtemp=dshow
+            dshow=dhide
+            dhide=dtemp
+        }
+        dshow.style.display=''
+        dhide.style.display='none'
+        tip._isAirwall=value
+    }
+    return tip._isAirwall
+}
+tip.geneMapSuccess= false
+tip.timer= null
+tip.msgs= [ //分别编号1,2,3,4,5,6,7,8,9,10；奇数警告，偶数成功
+    "当前未选择任何图块，请先在右边选择要画的图块!",
+    "生成地图成功！可点击复制按钮复制地图数组到剪切板",
+    "生成失败! 地图中有未定义的图块，建议先用其他有效图块覆盖或点击清除地图！",
+    "地图清除成功!",
+    "复制失败！",
+    "复制成功！可直接粘贴到楼层文件的地图数组中。",
+    "复制失败！当前还没有数据",
+    "修改成功！可点击复制按钮复制地图数组到剪切板",
+    "选择背景图片失败！文件名格式错误或图片不存在！",
+    "更新背景图片成功！",
+    "11:警告",
+    "12:成功"
+]
+tip._mapMsg= ''
+tip.mapMsg=function(value){
+    if(value!=null){
+        document.getElementById('whichShow-if').innerText=value
+        tip._mapMsg=value
+    }
+    return tip._mapMsg
+}
+tip._whichShow= 0
+tip.whichShow=function(value){
+    if(value!=null){
+
+        var dshow=document.getElementById('whichShow-if')
+        var dhide=null
+        if(!value){
+            var dtemp=dshow
+            dshow=dhide
+            dhide=dtemp
+        }
+        if(dshow)dshow.style.display=''
+        if(dhide)dhide.style.display='none'
+
+        if(dshow)dshow.setAttribute('class',(value%2) ? 'warnText' : 'successText')
+
+        tip.mapMsg('');
+        tip.msgs[4] = "复制失败！" + editTip.err;
+        clearTimeout(tip.timer);
+        if (value) {
+            tip.mapMsg(tip.msgs[value - 1]);
+            tip.timer = setTimeout(function () {
+                if (!(value % 2))
+                value = 0;
+            }, 5000); //5秒后自动清除success，warn不清除
+        }
+        tip._whichShow=value
+    }
+    return tip._whichShow
+}
+selectBox=document.getElementById('selectBox')
+dataSelection=document.getElementById('dataSelection')
+selectBox._isSelected=false
+selectBox.isSelected=function(value){
+    if(value!=null){
+        selectBox._isSelected=value;
+        tip.isSelectedBlock(value);
+        tip.whichShow(0);
+        clearTimeout(tip.timer);
+        dataSelection.style.display=value?'':'none'
+    }
+    return selectBox._isSelected
+}
+
diff --git a/_server/editor_util.js b/_server/editor_util.js
new file mode 100644
index 00000000..6f81a8c1
--- /dev/null
+++ b/_server/editor_util.js
@@ -0,0 +1,173 @@
+editor_util_wrapper = function (editor) {
+
+    editor_util = function () {
+
+    }
+
+    editor_util.prototype.guid = function () {
+        return 'id_' + 'xxxxxxxx_xxxx_4xxx_yxxx_xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    }
+
+    editor_util.prototype.HTMLescape = function (str_) {
+        return String(str_).split('').map(function (v) {
+            return '&#' + v.charCodeAt(0) + ';'
+        }).join('');
+    }
+
+    editor_util.prototype.getPixel = function (imgData, x, y) {
+        var offset = (x + y * imgData.width) * 4;
+        var r = imgData.data[offset + 0];
+        var g = imgData.data[offset + 1];
+        var b = imgData.data[offset + 2];
+        var a = imgData.data[offset + 3];
+        return [r, g, b, a];
+    }
+
+    editor_util.prototype.setPixel = function (imgData, x, y, rgba) {
+        var offset = (x + y * imgData.width) * 4;
+        imgData.data[offset + 0] = rgba[0];
+        imgData.data[offset + 1] = rgba[1];
+        imgData.data[offset + 2] = rgba[2];
+        imgData.data[offset + 3] = rgba[3];
+    }
+
+    // rgbToHsl hue2rgb hslToRgb from https://github.com/carloscabo/colz.git
+    //--------------------------------------------
+    // The MIT License (MIT)
+    //
+    // Copyright (c) 2014 Carlos Cabo
+    //
+    // Permission is hereby granted, free of charge, to any person obtaining a copy
+    // of this software and associated documentation files (the "Software"), to deal
+    // in the Software without restriction, including without limitation the rights
+    // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    // copies of the Software, and to permit persons to whom the Software is
+    // furnished to do so, subject to the following conditions:
+    //
+    // The above copyright notice and this permission notice shall be included in all
+    // copies or substantial portions of the Software.
+    //
+    // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    // SOFTWARE.
+    //--------------------------------------------
+    // https://github.com/carloscabo/colz/blob/master/public/js/colz.class.js
+    var round = Math.round;
+    var rgbToHsl = function (rgba) {
+        var arg, r, g, b, h, s, l, d, max, min;
+
+        arg = rgba;
+
+        if (typeof arg[0] === 'number') {
+            r = arg[0];
+            g = arg[1];
+            b = arg[2];
+        } else {
+            r = arg[0][0];
+            g = arg[0][1];
+            b = arg[0][2];
+        }
+
+        r /= 255;
+        g /= 255;
+        b /= 255;
+
+        max = Math.max(r, g, b);
+        min = Math.min(r, g, b);
+        l = (max + min) / 2;
+
+        if (max === min) {
+            h = s = 0; // achromatic
+        } else {
+            d = max - min;
+            s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+
+            switch (max) {
+                case r: h = (g - b) / d + (g < b ? 6 : 0); break;
+                case g: h = (b - r) / d + 2; break;
+                case b: h = (r - g) / d + 4; break;
+            }
+
+            h /= 6;
+        }
+
+        //CARLOS
+        h = round(h * 360);
+        s = round(s * 100);
+        l = round(l * 100);
+
+        return [h, s, l];
+    }
+    //
+    var hue2rgb = function (p, q, t) {
+        if (t < 0) { t += 1; }
+        if (t > 1) { t -= 1; }
+        if (t < 1 / 6) { return p + (q - p) * 6 * t; }
+        if (t < 1 / 2) { return q; }
+        if (t < 2 / 3) { return p + (q - p) * (2 / 3 - t) * 6; }
+        return p;
+    }
+    var hslToRgb = function (hsl) {
+        var arg, r, g, b, h, s, l, q, p;
+
+        arg = hsl;
+
+        if (typeof arg[0] === 'number') {
+            h = arg[0] / 360;
+            s = arg[1] / 100;
+            l = arg[2] / 100;
+        } else {
+            h = arg[0][0] / 360;
+            s = arg[0][1] / 100;
+            l = arg[0][2] / 100;
+        }
+
+        if (s === 0) {
+            r = g = b = l; // achromatic
+        } else {
+
+            q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+            p = 2 * l - q;
+            r = hue2rgb(p, q, h + 1 / 3);
+            g = hue2rgb(p, q, h);
+            b = hue2rgb(p, q, h - 1 / 3);
+        }
+        return [round(r * 255), round(g * 255), round(b * 255)];
+    }
+    editor_util.prototype.rgbToHsl = rgbToHsl
+    editor_util.prototype.hue2rgb = hue2rgb
+    editor_util.prototype.hslToRgb = hslToRgb
+
+    editor_util.prototype.encode64 = function (str) {
+        return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, function (match, p1) {
+            return String.fromCharCode(parseInt(p1, 16))
+        }))
+    }
+
+    editor_util.prototype.decode64 = function (str) {
+        return decodeURIComponent(atob(str.replace(/-/g, '+').replace(/_/g, '/').replace(/\s/g, '')).split('').map(function (c) {
+            return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2)
+        }).join(''))
+    }
+
+    editor_util.prototype.isset = function (val) {
+        return val != null && !(typeof val == 'number' && isNaN(val));
+    }
+
+    editor_util.prototype.checkCallback=function(callback){
+        if (!editor.util.isset(callback)) {
+            editor.printe('未设置callback');
+            throw('未设置callback')
+        }
+    }
+
+    editor.constructor.prototype.util = new editor_util();
+}
+//editor_util_wrapper(editor);
\ No newline at end of file
diff --git a/_server/fs.js b/_server/fs.js
index c95065d3..dddfbbec 100644
--- a/_server/fs.js
+++ b/_server/fs.js
@@ -56,7 +56,7 @@
                 callback(null, data);
             }
         }, function (e) {
-            console.log(e);
+            main.log(e);
             callback(e+"：请检查启动服务是否处于正常运行状态。");
         }, "text/plain; charset=x-user-defined");
     }
@@ -119,6 +119,10 @@
         throw 'Type Error in fs.writeFile';
     }
 
+    fs.writeMultiFiles = function (filenames, datastrs, callback) {
+        postsomething('name='+filenames.join(';')+'&value='+datastrs.join(';'), '/writeMultiFiles', callback);
+    }
+
     fs.readdir = function (path, callback) {
         //callback:function(err, data)
         //path:支持"/"做分隔符,不以"/"结尾
diff --git a/_server/fsTest_cs.html b/_server/fsTest_cs.html
index a6455ad4..9a392e4a 100644
--- a/_server/fsTest_cs.html
+++ b/_server/fsTest_cs.html
@@ -34,6 +34,12 @@
             console.log(d);
         })
     }, 4000);
+    setTimeout(function () {
+        fs.writeMultiFiles(['_test.txt','_test_multi.txt'], ['abc=','abe='], function (e, d) {
+            console.log(e);
+            console.log(d);
+        })
+    }, 5000);
 
 
 </script>
diff --git a/_server/functions.comment.js b/_server/functions.comment.js
deleted file mode 100644
index 0b2901ae..00000000
--- a/_server/functions.comment.js
+++ /dev/null
@@ -1,139 +0,0 @@
-functions_comment_c456ea59_6018_45ef_8bcc_211a24c627dc = 
-{
-    "_leaf": false,
-    "_type": "object",
-    "_data": {
-        "events": {
-            "_leaf": false,
-            "_type": "object",
-            "_data": {
-                "initGame": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_lint": true,
-                    "_data": "游戏开始前的一些初始化操作"
-                },
-                "setInitData": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_lint": true,
-                    "_data": "不同难度分别设置初始属性"
-                },
-                "win": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_lint": true,
-                    "_data": "游戏获胜事件"
-                },
-                "lose": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_lint": true,
-                    "_data": "游戏失败事件"
-                },
-                "afterChangeFloor": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_lint": true,
-                    "_data": "转换楼层结束的事件"
-                },
-                "addPoint": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_lint": true,
-                    "_data": "加点事件"
-                },
-                "afterBattle": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_lint": true,
-                    "_data": "战斗结束后触发的事件"
-                },
-                "afterOpenDoor": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_lint": true,
-                    "_data": "开一个门后触发的事件"
-                },
-                "afterChangeLight": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_lint": true,
-                    "_data": "改变亮灯之后，可以触发的事件"
-                },
-                "afterPushBox": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_lint": true,
-                    "_data": "推箱子后的事件"
-                },
-                "afterUseBomb": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_lint": true,
-                    "_data": "使用炸弹/圣锤后的事件"
-                },
-                "beforeSaveData": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_lint": true,
-                    "_data": "即将存档前可以执行的操作"
-                },
-                "afterLoadData": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_lint": true,
-                    "_data": "读档事件后，载入事件前，可以执行的操作"
-                }
-            }
-        },
-        "enemys": {
-            "_leaf": false,
-            "_type": "object",
-            "_data": {
-                "getSpecials": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_lint": true,
-                    "_data": "怪物特殊属性的定义（获得怪物的特殊属性）"
-                },
-                "getDamageInfo": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_lint": true,
-                    "_data": "获得战斗伤害信息（实际伤害计算函数）"
-                },
-                "updateEnemys": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_lint": true,
-                    "_data": "更新怪物数据，可以在这里对怪物属性和数据进行动态更新"
-                }
-            }
-        },
-        "ui": {
-            "_leaf": false,
-            "_type": "object",
-            "_data": {
-                "drawAbout": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_lint": true,
-                    "_data": "绘制“关于”界面"
-                }
-            }
-        },
-        "plugins": {
-            "_leaf": false,
-            "_type": "object",
-            "_data": {
-                "plugin": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_lint": true,
-                    "_data": "自定义插件编写"
-                }
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/_server/refactoring.md b/_server/refactoring.md
new file mode 100644
index 00000000..8ea8c365
--- /dev/null
+++ b/_server/refactoring.md
@@ -0,0 +1,125 @@
+# 重构
+
+总体思路  
++ 按功能拆分文件
++ 左侧页面模块化, 方便添加
++ 不同的模式的文件操作尽可能模块化
+
+目前主要在重构editor_file, 思路是editor.file负责把editor.game内的游戏数据格式化成字符串以及写入到文件, 由editor.game来修改数据
++ editor.file维护一些标记, 描述哪些数据需要格式化并写入, 在save时写入文件(自动保存的话就是每次修改数据都触发save)
++ editor.game修改数据, 并修改editor.file中的标记
++ 此思路下editor.file的大部分内容会挪到editor.game, editor.game和editor.table可能会再进一步合并拆分
+
+editor_file之后是更改editor.map的储存方式, 现有的存对象的模式要在对象和数字间来回转换, 非常繁琐和奇怪
+
+再之后是把editor_unsorted_*.js整理清晰
+
+## 文件结构
+
++ [ ] editor_blockly 图块化事件编辑器
++ [ ] editor_multi 多行文本编辑器
++ [x] editor_table 处理表格的生成, 及其响应的事件, 从原editor\_mode中分离
++ [ ] editor_file 调用fs.js编辑文件, 把原editor\_file模块化, 并且只负责文件写入
++ [ ] editor_game 处理游戏数据, 导入为editor的数据, 编辑数据, 从原editor和editor_file中抽离. **只有此文件允许`\s(main|core)`形式的调用**(以及其初始化`editor_game_wrapper(editor, main, core);`)
++ [x] editor_util 生成guid/处理颜色 等函数, 从editor分离
++ [ ] editor 执行初始化流程加组合各组件
++ [ ] 原editor_mode 移除
++ [x] 原vm 移除
++ [x] \*comment.js 表格注释与结构, 移至table/\*comment.js
+
+## 对象结构
+
+```
+editor: {
+    __proto__: {
+        fs
+        util
+        file
+        table
+        multi
+        blockly
+        game
+    }
+    config: 编辑器配置
+    mode: 当前的模式(左侧的选择)
+    map: 当前编辑层的地图
+    isMobile: 编辑器是否是手机端
+    currentFloorData: 当前编辑的楼层数据
+    ...
+}
+```
+
+---
+
+## 某些注意到的点&准备修改的内容
+
++ 插入公共事件的参数的转义处理, .g4中添加ObjectString, 要求其中的值可以JSON.parse, 生成的code中也是作为对象而不是字符串出现
+
++ 修改editor.multi中的转义处理, 目前双击某些方块使用文本编辑的处理, 一部分在editor.blockly, 一部分在editor.multi, 比较混乱
+
++ 地图的编辑与其他(如全塔属性和楼层属性), 现在的文件操作的模式是完全不同的  
+  楼层文件的储存与其他不同
+
++ [x] editor.file在修改时不再返回obj和commentobj,只在查询时返回
+
++ editor.file中的各个条目, 非常相似, 但是细节的不同处理非常麻烦. 是类似的代码复制后修改一部分, 尝试模块化(或者重写)
+
++ functions和plugins的借助JSON.stringify的replacer特殊处理, 与其他项的处理完全不同, 改成用统一的方法处理(为了统一,全部使用这种不直观的replacer的处理)
+
++ 怪物/物品/地图选点事件的处理, field中怪物id等明显与其他节地位不等, 处理起来很繁琐
+
++ 目前editor.map中储存的是info\<object\>, 准备改为和core一致只储存数字
+
++ editor.widthX特别不直观
+
+## 功能改进
+
++ [ ] 大地图  
+  在切换时, 每次都回到最左上->每个楼层记录一个位置  
+  四个箭头支持长按  
+  ? 滚动条
+
++ [ ] ? 表格折叠  
+  变为四栏, 可以折叠展开
+
++ [x] blockly对于无法识别的图块原样返回
+
++ [ ] ? 简洁的事件方块注册
+  `editor.registerEvent('log',[['test','Int','测试',0],['floorId','Idstring','楼层','MT0']])`
+
++ [ ] 一个显示所有快捷键的文本
+
++ [ ] 更多快捷键  
+  【全塔属性】、【楼层属性】等常用的编辑栏切换  
+
++ [ ] ? 地图编辑优化
+  常用的地图编辑快捷键/命令：复制ctrl+c、粘贴ctrl+v、（复制可绑定为现在的“选中xx位置事件” 粘贴为复制xx事件到此处），撤回ctrl+z、取消撤回ctrl+y  
+  可以按住拖动图块与事件。
+
++ [ ] ? 自由建立快捷键到命令的注册表。
+
++ [ ] 画地图也自动保存
+
++ [x] 修改系统的触发器（下拉菜单增加新项）  
+  在编辑器修改`comment.js`：现场发readFile请求读文件，然后开脚本编辑器进行编辑
+
++ [ ] ? 删除注册项/修改图块ID
+
++ [ ] ? 怪物和道具也能像其他类型那样查看“图块信息”（而不只是具体的怪物属性）
+
++ [ ] 素材区自动换列  
+  怪物或道具太多时, 按照每100个进行拆分新开列来显示  
+
++ [ ] 多帧素材只显示第一帧  
+
++ [ ] `显示文章`以及`选项`等方块, 把`标题`和`图像`从字符串提取出填回相应的空
+
++ [ ] blockly中某些需要选点的填空, 增加按钮, 点击后从缩略图中点击位置
+
+## 左侧页面模式
+
+标题? 保存按钮? 添加按钮? 删除按钮?
+
+自定义内容?
+
+表格?
diff --git a/_server/table/comment.js b/_server/table/comment.js
new file mode 100644
index 00000000..ef03953d
--- /dev/null
+++ b/_server/table/comment.js
@@ -0,0 +1,496 @@
+/*
+ * 表格配置项。
+ * 在这里可以对表格中的各项显示进行配置，包括表格项、提示内容等内容。具体写法照葫芦画瓢即可。
+ * 本配置项包括：道具、怪物、图块属性、楼层属性等内容。
+ */
+
+var comment_c456ea59_6018_45ef_8bcc_211a24c627dc = {
+	"_type": "object",
+	"_data": {
+		// --------------------------- 【道具】相关的表格配置 --------------------------- //
+		"items": {
+			"_type": "object",
+			"_data": {
+				"items": {
+					"_type": "object",
+					"_data": {
+						"cls": {
+							"_leaf": true,
+							"_type": "select",
+							"_select": {
+								"values": [
+									"keys",
+									"items",
+									"constants",
+									"tools",
+									"equips"
+								]
+							},
+							"_data": "只能取keys(钥匙) items(宝石、血瓶) constants(永久物品) tools(消耗道具) equips(装备)"
+						},
+						"name": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_string": true,
+							"_data": "名称"
+						},
+						"text": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_string": true,
+							"_data": "道具在道具栏中显示的描述"
+						},
+						"equip": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_data": "装备属性设置，仅对cls为equips有效。\n如果此项不为null，需要是一个对象，里面可含\"type\"，\"atk\"，\"def\"，\"mdef\"，\"animate\"五项，分别对应装备部位、攻防魔防和动画。\n具体详见文档（元件说明-装备）和已有的几个装备的写法。"
+						},
+						"hideInReplay": {
+							"_leaf": true,
+							"_type": "checkbox",
+							"_bool": "bool",
+							"_data": "是否回放时绘制道具栏。\n如果此项为true，则在回放录像时使用本道具将不会绘制道具栏页面，而是直接使用。\n此项建议在会频繁连续多次使用的道具开启（如开启技能，或者《镜子》那样的镜像切换等等）"
+						}
+					}
+				},
+				"itemEffect": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_string": true,
+					"_lint": true,
+					"_data": "即捡即用类物品的效果，仅对cls为items有效。"
+				},
+				"itemEffectTip": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_string": true,
+					"_lint": true,
+					"_data": "即捡即用类物品在获得时提示的文字，仅对cls为items有效。"
+				},
+				"useItemEffect": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_string": true,
+					"_lint": true,
+					"_data": "道具效果，仅对cls为tools或constants有效。"
+				},
+				"canUseItemEffect": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_string": true,
+					"_lint": true,
+					"_data": "当前能否使用该道具，仅对cls为tools或constants有效。"
+				},
+				"equipCondition": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_string": true,
+					"_lint": true,
+					"_data": "能装备某个装备的条件，仅对cls为equips有效。\n与canUseItemEffect不同，这里null代表可以装备。"
+				}
+			}
+		},
+		"items_template": { 'cls': 'items', 'name': '新物品' },
+
+
+		// --------------------------- 【怪物】相关的表格配置 --------------------------- //
+		"enemys": {
+			"_type": "object",
+			"_data": {
+				"name": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_string": true,
+					"_data": "名称"
+				},
+				"displayIdInBook": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_string": true,
+					"_data": "在怪物手册中映射到的怪物ID。如果此项不为null，则在怪物手册中，将用目标ID来替换该怪物原本的ID。\n此项应被运用在同一个怪物的多朝向上。\n例如，如果想定义同一个怪物的向下和向左的行走图，则需要建立两个属性完全相同的怪物。\n但是这样会导致在怪物手册中同时存在向下和向左的两种怪物的显示。\n可以将朝向左的怪物的displayIdInBook项指定为朝向下的怪物ID，这样在怪物手册中则会归一化，只显示一个。"
+				},
+				"hp": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "生命值"
+				},
+				"atk": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "攻击力"
+				},
+				"def": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "防御力"
+				},
+				"money": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "金币"
+				},
+				"experience": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "经验"
+				},
+				"point": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "加点"
+				},
+				"special": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_range": "thiseval==null || thiseval instanceof Array || (thiseval==~~thiseval && thiseval>=0)",
+					"_data": "特殊属性\n\n0:无,1:先攻,2:魔攻,3:坚固,4:2连击,\n5:3连击,6:n连击,7:破甲,8:反击,9:净化,\n10:模仿,11:吸血,12:中毒,13:衰弱,14:诅咒,\n15:领域,16:夹击,17:仇恨,18:阻击,19:自爆,\n20:无敌,21:退化,22:固伤,23:重生,24:激光,25:光环\n\n多个属性例如用[1,4,11]表示先攻2连击吸血"
+				},
+				"value": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "特殊属性的数值\n如：领域/阻激/激光怪的伤害值；吸血怪的吸血比例；光环怪增加生命的比例"
+				},
+				"zoneSquare": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "领域怪是否九宫格伤害"
+				},
+				"range": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_range": "(thiseval==~~thiseval && thiseval>0)||thiseval==null",
+					"_data": "领域伤害的范围；不加默认为1"
+				},
+				"notBomb": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "该怪物不可被炸"
+				},
+				"n": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_range": "(thiseval==~~thiseval && thiseval>0)||thiseval==null",
+					"_data": "多连击的连击数"
+				},
+				"add": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "吸血后是否加到自身；光环是否叠加"
+				},
+				"atkValue": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_range": "thiseval==~~thiseval||thiseval==null",
+					"_data": "退化时勇士下降的攻击力点数；光环怪增加攻击的比例"
+				},
+				"defValue": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_range": "thiseval==~~thiseval||thiseval==null",
+					"_data": "退化时勇士下降的防御力点数；光环怪增加防御的比例"
+				},
+				"damage": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_range": "thiseval==~~thiseval||thiseval==null",
+					"_data": "战前扣血的点数"
+				}
+			}
+		},
+		"enemys_template": { 'name': '新敌人', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0 },
+
+
+		// --------------------------- 【图块属性】相关的表格配置 --------------------------- //
+		"maps": {
+			"_type": "object",
+			"_data": {
+				"id": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_range": "false",
+					"_data": "图块ID"
+				},
+				"idnum": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_range": "false",
+					"_data": "图块数字"
+				},
+				"cls": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_range": "false",
+					"_data": "图块类别"
+				},
+				"trigger": {
+					"_leaf": true,
+					"_type": "select",
+					"_select": {
+						"values": [
+							"null",
+							"openDoor",
+							"passNet",
+							"changeLight",
+							"pushBox",
+							"custom"
+						]
+					},
+					"_data": "该图块的默认触发器"
+				},
+				"noPass": {
+					"_leaf": true,
+					"_type": "select",
+					"_select": {
+						"values": [
+							"null",
+							"true",
+							"false"
+						]
+					},
+					"_data": "该图块是否不可通行；true代表不可通行，false代表可通行，null代表使用系统缺省值"
+				},
+				"canBreak": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "该图块是否可被破墙或地震"
+				},
+				"cannotOut": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_range": "thiseval==null||(thiseval instanceof Array)",
+					"_data": "该图块的不可出方向\n可以在这里定义在该图块时不能前往哪个方向，可以达到悬崖之类的效果\n例如 [\"up\", \"left\"] 代表在该图块时不能往上和左走\n此值对背景层、事件层、前景层上的图块均有效"
+				},
+				"cannotIn": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_range": "thiseval==null||(thiseval instanceof Array)",
+					"_data": "该图块的不可入方向\n可以在这里定义不能朝哪个方向进入该图块，可以达到悬崖之类的效果\n例如 [\"down\"] 代表不能从该图块的上方点朝向下进入此图块\n此值对背景层、事件层、前景层上的图块均有效"
+				},
+				"animate": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_range": "thiseval==~~thiseval||thiseval==null",
+					"_data": "该图块的全局动画帧数。\n如果此项为null，则对于除了npc48外，使用素材默认帧数；npc48默认是1帧（即静止）。"
+				},
+				"faceIds": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "行走图朝向，仅对NPC有效。可以在这里定义同一个NPC的多个朝向行走图。\n比如 {\"up\":\"N333\",\"down\":\"N334\",\"left\":\"N335\",\"right\":\"N336\"} 就将该素材的上下左右朝向分别绑定到N333,N334,N335和N336四个图块。\n在勇士撞上NPC时，或NPC在移动时，会自动选择最合适的朝向图块（如果存在定义）来进行绘制。"
+				}
+			}
+		},
+
+
+		// --------------------------- 【楼层属性】相关的表格配置 --------------------------- //
+		"floors": {
+			"_type": "object",
+			"_data": {
+				"floor": {
+					"_type": "object",
+					"_data": {
+						"floorId": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_range": "false",
+							"_data": "文件名和floorId需要保持完全一致 \n楼层唯一标识符仅能由字母、数字、下划线组成，且不能由数字开头 \n推荐用法：第20层就用MT20，第38层就用MT38，地下6层就用MT_6（用下划线代替负号），隐藏3层用MT3h（h表示隐藏），等等 \n楼层唯一标识符，需要和名字完全一致 \n这里不能更改floorId,请通过另存为来实现"
+						},
+						"title": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_data": "楼层中文名，将在切换楼层和浏览地图时显示"
+						},
+						"name": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_data": "显示在状态栏中的层数"
+						},
+						"width": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_range": "false",
+							"_data": "地图x方向大小,这里不能更改,仅能在新建地图时设置,null视为13"
+						},
+						"height": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_range": "false",
+							"_data": "地图y方向大小,这里不能更改,仅能在新建地图时设置,null视为13"
+						},
+						"canFlyTo": {
+							"_leaf": true,
+							"_type": "checkbox",
+							"_bool": "bool",
+							"_data": "该楼能否被楼传器飞到（不能的话在该楼也不允许使用楼传器）"
+						},
+						"canUseQuickShop": {
+							"_leaf": true,
+							"_type": "checkbox",
+							"_bool": "bool",
+							"_data": "该层是否允许使用快捷商店"
+						},
+						"cannotViewMap": {
+							"_leaf": true,
+							"_type": "checkbox",
+							"_bool": "bool",
+							"_data": "该层是否不允许被浏览地图看到；如果勾上则浏览地图会跳过该层"
+						},
+						"cannotMoveDirectly": {
+							"_leaf": true,
+							"_type": "checkbox",
+							"_bool": "bool",
+							"_data": "该层是否不允许瞬间移动；如果勾上则不可在此层进行瞬移"
+						},
+						"firstArrive": {
+							"_leaf": true,
+							"_type": "event",
+							"_event": "firstArrive",
+							"_data": "第一次到该楼层触发的事件，可以双击进入事件编辑器。"
+						},
+						"eachArrive": {
+							"_leaf": true,
+							"_type": "event",
+							"_event": "eachArrive",
+							"_data": "每次到该楼层触发的事件，可以双击进入事件编辑器；该事件会在firstArrive执行后再执行。"
+						},
+						"parallelDo": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_string": true,
+							"_lint": true,
+							"_data": "在该层楼时执行的并行事件处理。\n可以在这里写上任意需要自动执行的脚本，比如打怪自动开门等。\n详见文档-事件-并行事件处理。"
+						},
+						"upFloor": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_range": "thiseval==null||((thiseval instanceof Array) && thiseval.length==2)",
+							"_data": "该层上楼点，如[2,3]。\n如果此项不为null，则楼层转换时的stair:upFloor，以及楼传器的落点会被替换成该点而不是该层的上楼梯。"
+						},
+						"downFloor": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_range": "thiseval==null||((thiseval instanceof Array) && thiseval.length==2)",
+							"_data": "该层下楼点，如[2,3]。\n如果此项不为null，则楼层转换时的stair:downFloor，以及楼传器的落点会被替换成该点而不是该层的下楼梯。"
+						},
+						"defaultGround": {
+							"_leaf": true,
+							"_type": "select",
+							"_select": {
+								"values": Object.keys(editor.core.icons.icons.terrains)
+							},
+							"_data": "默认地面的图块ID，此项修改后需要刷新才能看到效果。"
+						},
+						"images": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_data": "背景/前景图；你可以选择若干张图片来作为背景/前景素材。详细用法请参见文档“自定义素材”中的说明。"
+						},
+						"color": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_data": "该层的默认画面色调。本项可不写（代表无色调），如果写需要是一个RGBA数组如[255,0,0,0.3]"
+						},
+						"weather": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_data": "该层的默认天气。本项可忽略表示晴天，如果写则第一项为\"rain\"，\"snow\"或\"fog\"代表雨雪雾，第二项为1-10之间的数代表强度。\n如[\"rain\", 8]代表8级雨天。"
+						},
+						"bgm": {
+							"_leaf": true,
+							"_type": "select",
+							"_select": {
+								"values": [null].concat(Object.keys(editor.core.material.bgms))
+							},
+							"_data": "到达该层后默认播放的BGM。本项可忽略，或者为一个定义过的背景音乐如\"bgm.mp3\"。"
+						},
+						"item_ratio": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_range": "(thiseval==~~thiseval && thiseval>=0)||thiseval==null",
+							"_data": "每一层的宝石/血瓶效果，即获得宝石和血瓶时框内\"ratio\"的值。"
+						},
+						"underGround": {
+							"_leaf": true,
+							"_type": "checkbox",
+							"_bool": "bool",
+							"_data": "是否是地下层；如果该项为true则同层传送将传送至上楼梯"
+						}
+					}
+				},
+				"loc": {
+					"_type": "object",
+					"_data": {
+						"events": {
+							"_leaf": true,
+							"_type": "event",
+							"_event": "event",
+							"_data": "该点的可能事件列表，可以双击进入事件编辑器。"
+						},
+						"changeFloor": {
+							"_leaf": true,
+							"_type": "event",
+							"_event": "changeFloor",
+							"_data": "该点楼层转换事件；该事件不能和上面的events同时出现，否则会被覆盖"
+						},
+						"afterBattle": {
+							"_leaf": true,
+							"_type": "event",
+							"_event": "afterBattle",
+							"_data": "该点战斗后可能触发的事件列表，可以双击进入事件编辑器。"
+						},
+						"afterGetItem": {
+							"_leaf": true,
+							"_type": "event",
+							"_event": "afterGetItem",
+							"_data": "该点获得道具后可能触发的事件列表，可以双击进入事件编辑器。"
+						},
+						"afterOpenDoor": {
+							"_leaf": true,
+							"_type": "event",
+							"_event": "afterOpenDoor",
+							"_data": "该点开完门后可能触发的事件列表，可以双击进入事件编辑器。"
+						},
+						"cannotMove": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_range": "thiseval==null||(thiseval instanceof Array)",
+							"_data": "该点不可通行的方向 \n 可以在这里定义该点不能前往哪个方向，可以达到悬崖之类的效果\n例如 [\"up\", \"left\"] 代表该点不能往上和左走"
+						}
+					}
+				}
+			}
+		},
+
+		"floors_template": {
+			"floorId": "to be covered",
+			"title": "new floor",
+			"name": "new floor",
+			"width": 13,
+			"height": 13,
+			"canFlyTo": true,
+			"canUseQuickShop": true,
+			"cannotViewMap": false,
+			"cannotMoveDirectly": false,
+			"images": [],
+			"item_ratio": 1,
+			"defaultGround": "ground",
+			"bgm": null,
+			"upFloor": null,
+			"downFloor": null,
+			"color": null,
+			"weather": null,
+			"firstArrive": [],
+			"eachArrive": [],
+			"parallelDo": "",
+			"events": {},
+			"changeFloor": {},
+			"afterBattle": {},
+			"afterGetItem": {},
+			"afterOpenDoor": {},
+			"cannotMove": {}
+		}
+	}
+}
\ No newline at end of file
diff --git a/_server/table/data.comment.js b/_server/table/data.comment.js
new file mode 100644
index 00000000..2a2addfd
--- /dev/null
+++ b/_server/table/data.comment.js
@@ -0,0 +1,697 @@
+/*
+ * 表格配置项。
+ * 在这里可以对表格中的各项显示进行配置，包括表格项、提示内容等内容。具体写法照葫芦画瓢即可。
+ * 本配置项包括：全塔属性的配置项。
+ */
+
+var data_comment_c456ea59_6018_45ef_8bcc_211a24c627dc = {
+	"_type": "object",
+	"_data": {
+		"main": {
+			"_type": "object",
+			"_data": {
+				"floorIds": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_range": "editor.mode.checkFloorIds(thiseval)",
+					"_data": "在这里按顺序放所有的楼层；其顺序直接影响到楼层传送器、浏览地图和上/下楼器的顺序"
+				},
+				"images": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_range": "editor.mode.checkUnique(thiseval)",
+					"_data": "在此存放所有可能使用的图片（tilesets除外） \n图片可以被作为背景图（的一部分），也可以直接用自定义事件进行显示。 \n 图片名不能使用中文，不能带空格或特殊字符；可以直接改名拼音就好 \n 建议对于较大的图片，在网上使用在线的“图片压缩工具(http://compresspng.com/zh/)”来进行压缩，以节省流量 \n 依次向后添加"
+				},
+				"tilesets": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_range": "editor.mode.checkUnique(thiseval)",
+					"_data": "在此存放额外素材的图片名, \n可以自定导入任意张素材图片，无需PS，无需注册，即可直接在游戏中使用 \n 形式如[\"1.png\", \"2.png\"] ,将需要的素材图片放在images目录下 \n 素材的宽高必须都是32的倍数，且图片上的总图块数不超过1000（即最多有1000个32*32的图块在该图片上）"
+				},
+				"animates": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_range": "editor.mode.checkUnique(thiseval)",
+					"_data": "在此存放所有可能使用的动画，必须是animate格式，在这里不写后缀名 \n动画必须放在animates目录下；文件名不能使用中文，不能带空格或特殊字符 \n \"jianji\", \"thunder\" 根据需求自行添加"
+				},
+				"bgms": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_range": "editor.mode.checkUnique(thiseval)",
+					"_data": "在此存放所有的bgm，和文件名一致。 \n音频名不能使用中文，不能带空格或特殊字符；可以直接改名拼音就好"
+				},
+				"sounds": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_range": "editor.mode.checkUnique(thiseval)",
+					"_data": "在此存放所有的SE，和文件名一致 \n音频名不能使用中文，不能带空格或特殊字符；可以直接改名拼音就好"
+				},
+				"nameMap": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "文件名映射，目前仅对images, animates, bgms, sounds有效。\n例如定义 {\"精灵石.mp3\":\"jinglingshi.mp3\"} 就可以使用\ncore.playBgm(\"精灵石.mp3\") 或对应的事件来播放该bgm。"
+				},
+				"startBackground": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_string": true,
+					"_data": "标题界面的背景，建议使用jpg格式以压缩背景图空间"
+				},
+				"startLogoStyle": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_string": true,
+					"_data": "标题样式：可以改变颜色，也可以写\"display: none\"来隐藏标题"
+				},
+				"levelChoose": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_range": "thiseval instanceof Array && thiseval.length>=1 && thiseval[0] instanceof Array && thiseval[0].length==2",
+					"_data": "难度选择：每个数组的第一个是其在标题界面显示的难度，第二个是在游戏内部传输的字符串，会显示在状态栏，修改此处后需要在project/functions中作相应更改。\n如果需直接开始游戏将下面的startDirectly开关打开即可。"
+				},
+				"equipName": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_range": "(thiseval instanceof Array && thiseval.length<=6)||thiseval==null",
+					"_data": "装备位名称，为不超过6个的数组，此项的顺序与equiptype数值关联；例如可写[\"武器\",\"防具\",\"首饰\"]等等。"
+				},
+				"startBgm": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_string": true,
+					"_data": "在标题界面应该播放的bgm内容"
+				},
+				"statusLeftBackground": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_string": true,
+					"_data": "横屏时左侧状态栏的背景样式，可以定义背景图、平铺方式等。\n具体请网上搜索\"css background\"了解写法。\n如果弄一张图片作为背景图，推荐写法：\n\"url(project/images/XXX.png) 0 0/100% 100% no-repeat\"\n图片最好进行一些压缩等操作节省流量。"
+				},
+				"statusTopBackground": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_string": true,
+					"_data": "竖屏时上方状态栏的背景样式，可以定义背景图、平铺方式等。\n具体请网上搜索\"css background\"了解写法。\n如果弄一张图片作为背景图，推荐写法：\n\"url(project/images/XXX.png) 0 0/100% 100% no-repeat\"\n图片最好进行一些压缩等操作节省流量。"
+				},
+				"toolsBackground": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_string": true,
+					"_data": "竖屏时下方道具栏的背景样式，可以定义背景图、平铺方式等。\n具体请网上搜索\"css background\"了解写法。\n如果弄一张图片作为背景图，推荐写法：\n\"url(project/images/XXX.png) 0 0/100% 100% no-repeat\"\n图片最好进行一些压缩等操作节省流量。"
+				},
+				"borderColor": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_string": true,
+					"_data": "边框颜色，包括游戏边界的边框和对话框边框等。"
+				},
+				"statusBarColor": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_string": true,
+					"_data": "状态栏的文字颜色，默认是白色"
+				},
+				"hardLabelColor": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_string": true,
+					"_data": "难度显示的颜色，默认是红色"
+				},
+				"floorChangingBackground": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_string": true,
+					"_data": "楼层转换界面的背景样式；可以使用纯色（默认值black），也可以使用图片（参见状态栏的图片写法）"
+				},
+				"floorChangingTextColor": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_string": true,
+					"_data": "楼层转换界面的文字颜色，默认是白色"
+				},
+				"font": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_string": true,
+					"_data": "游戏中使用的字体，默认是Verdana"
+				}
+			}
+		},
+		"firstData": {
+			"_type": "object",
+			"_data": {
+				"title": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_string": true,
+					"_data": "游戏名，将显示在标题页面以及切换楼层的界面中"
+				},
+				"name": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_string": true,
+					"_range": "/^[a-zA-Z0-9_]{1,30}$/.test(thiseval)",
+					"_data": "游戏的唯一英文标识符。由英文、数字、下划线组成，不能超过30个字符。\n此项必须修改，其将直接影响到存档的定位！"
+				},
+				"version": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_string": true,
+					"_data": "当前游戏版本；版本不一致的存档不能通用。"
+				},
+				"floorId": {
+					"_leaf": true,
+					"_type": "select",
+					"_select": {
+						"values": data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.main.floorIds
+					},
+					"_range": "data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.main.floorIds.indexOf(thiseval)!==-1",
+					"_data": "初始楼层的ID"
+				},
+				"hero": {
+					"_type": "object",
+					"_data": {
+						"name": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_string": true,
+							"_data": "勇士名；可以改成喜欢的"
+						},
+						"lv": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_range": "thiseval==~~thiseval &&thiseval>0",
+							"_data": "初始等级，该项必须为正整数"
+						},
+						"hpmax": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_data": "初始生命上限，只有在enableHPMax开启时才有效"
+						},
+						"hp": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_data": "初始生命值"
+						},
+						"manamax": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_data": "魔力上限；此项非负才会生效（null或小于0都不会生效）"
+						},
+						"mana": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_data": "初始魔力值，只在enableMana开启时才有效"
+						},
+						"atk": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_data": "初始攻击"
+						},
+						"def": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_data": "初始防御"
+						},
+						"mdef": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_data": "初始魔防"
+						},
+						"money": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_data": "初始金币"
+						},
+						"experience": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_data": "初始经验"
+						},
+						"equipment": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_range": "thiseval instanceof Array",
+							"_data": "初始装上的装备，此处建议请直接留空数组"
+						},
+						"items": {
+							"_type": "object",
+							"_data": {
+								"keys": {
+									"_leaf": true,
+									"_type": "textarea",
+									"_range": "thiseval instanceof Object && !(thiseval instanceof Array)",
+									"_data": "初始三种钥匙个数"
+								},
+								"constants": {
+									"_leaf": true,
+									"_type": "textarea",
+									"_range": "thiseval instanceof Object && !(thiseval instanceof Array)",
+									"_data": "初始永久道具个数，例如初始送手册可以写 {\"book\": 1}"
+								},
+								"tools": {
+									"_leaf": true,
+									"_type": "textarea",
+									"_range": "thiseval instanceof Object && !(thiseval instanceof Array)",
+									"_data": "初始消耗道具个数，例如初始有两破可以写 {\"pickaxe\": 2}"
+								},
+								"equips": {
+									"_leaf": true,
+									"_type": "textarea",
+									"_range": "thiseval instanceof Object && !(thiseval instanceof Array)",
+									"_data": "初始装备个数，例如初始送铁剑可以写 {\"sword1\": 1}"
+								}
+							}
+						},
+						"loc": {
+							"_type": "object",
+							"_data": {
+								"direction": {
+									"_leaf": true,
+									"_type": "select",
+									"_data": "勇士初始方向",
+									"_select": {
+										"values": [
+											"up",
+											"down",
+											"left",
+											"right"
+										]
+									},
+								},
+								"x": {
+									"_leaf": true,
+									"_type": "textarea",
+									"_data": "勇士初始x坐标"
+								},
+								"y": {
+									"_leaf": true,
+									"_type": "textarea",
+									"_data": "勇士初始y坐标"
+								}
+							}
+						},
+						"flags": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_range": "thiseval instanceof Object && !(thiseval instanceof Array)",
+							"_data": "游戏过程中的变量或flags"
+						},
+						"steps": {
+							"_leaf": true,
+							"_type": "textarea",
+							"_data": "行走步数统计"
+						}
+					}
+				},
+				"startCanvas": {
+					"_leaf": true,
+					"_type": "event",
+					"_event": "firstArrive",
+					"_range": "thiseval==null || thiseval instanceof Array",
+					"_data": "标题界面事件化，可以使用事件流的形式来绘制开始界面等。\n需要开启startUsingCanvas这个开关。\n详见文档-个性化-标题界面事件化。"
+				},
+				"startText": {
+					"_leaf": true,
+					"_type": "event",
+					"_event": "firstArrive",
+					"_range": "thiseval==null || thiseval instanceof Array",
+					"_data": "游戏开始前剧情，可以执行任意自定义事件。\n双击进入事件编辑器。\n如果无剧情直接留一个空数组即可。"
+				},
+				"shops": {
+					"_leaf": true,
+					"_type": "event",
+					"_event": "shop",
+					"_range": "thiseval instanceof Array",
+					"_data": "全局商店，是一个数组，可以双击进入事件编辑器。"
+				},
+				"levelUp": {
+					"_leaf": true,
+					"_type": "event",
+					"_event": "level",
+					"_range": "thiseval==null || thiseval instanceof Array",
+					"_data": "经验升级所需要的数值，是一个数组，可以双击进行编辑。 \n 第一项为初始等级，仅title生效 \n 每一个里面可以含有三个参数 need, title, action \n need为所需要的经验数值，可以是个表达式。请确保need依次递增 \n title为该等级的名称，也可以省略代表使用系统默认值；本项将显示在状态栏中 \n action为本次升级所执行的事件，可由若干项组成"
+				}
+			}
+		},
+		"values": {
+			"_type": "object",
+			"_data": {
+				"lavaDamage": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "经过血网受到的伤害"
+				},
+				"poisonDamage": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "中毒后每步受到的伤害"
+				},
+				"weakValue": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "衰弱状态下攻防减少的数值\n如果此项不小于1，则作为实际下降的数值（比如10就是攻防各下降10）\n如果在0到1之间则为下降的比例（比如0.3就是下降30%的攻防）"
+				},
+				"redJewel": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "红宝石加攻击的数值"
+				},
+				"blueJewel": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "蓝宝石加防御的数值"
+				},
+				"greenJewel": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "绿宝石加魔防的数值"
+				},
+				"redPotion": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "红血瓶加血数值"
+				},
+				"bluePotion": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "蓝血瓶加血数值"
+				},
+				"yellowPotion": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "黄血瓶加血数值"
+				},
+				"greenPotion": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "绿血瓶加血数值"
+				},
+				"breakArmor": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "破甲的比例（战斗前，怪物附加角色防御的x倍作为伤害）"
+				},
+				"counterAttack": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "反击的比例（战斗时，怪物每回合附加角色攻击的x倍作为伤害，无视角色防御）"
+				},
+				"purify": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "净化的比例（战斗前，怪物附加勇士魔防的x倍作为伤害）"
+				},
+				"hatred": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "仇恨属性中，每杀死一个怪物获得的仇恨值"
+				},
+				"moveSpeed": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "行走速度，即勇士每走一格的时间，一般100比较合适"
+				},
+				"animateSpeed": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "全局动画时间，即怪物振动频率，一般300比较合适"
+				},
+				"floorChangeTime": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_data": "默认楼层切换时间"
+				}
+			}
+		},
+		"flags": {
+			"_type": "object",
+			"_data": {
+				"enableFloor": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否在状态栏显示当前楼层"
+				},
+				"enableName": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否在状态栏显示勇士名字"
+				},
+				"enableLv": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否在状态栏显示当前等级"
+				},
+				"enableHPMax": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否是否启用生命上限"
+				},
+				"enableMana": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否开启魔力值"
+				},
+				"enableMDef": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否在状态栏及战斗界面显示魔防（护盾）"
+				},
+				"enableMoney": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否在状态栏、怪物手册及战斗界面显示金币"
+				},
+				"enableExperience": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否在状态栏、怪物手册及战斗界面显示经验"
+				},
+				"enableLevelUp": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否允许等级提升（进阶）；如果上面enableExperience为false，则此项恒视为false"
+				},
+				"levelUpLeftMode": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "进阶使用扣除模式，即在状态栏显示距离下个等级所需要的经验值；只有enableExperience和enableLevelUp均开启时才有效。"
+				},
+				"enableKeys": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否在状态栏显示三色钥匙数量"
+				},
+				"enablePZF": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否在状态栏显示破炸飞数量"
+				},
+				"enableDebuff": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否在状态栏显示毒衰咒"
+				},
+				"enableSkill": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否启用技能栏"
+				},
+				"flyNearStair": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否需要在楼梯边使用传送器"
+				},
+				"pickaxeFourDirections": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "使用破墙镐是否四个方向都破坏；如果false则只破坏面前的墙壁"
+				},
+				"bombFourDirections": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "使用炸弹是否四个方向都会炸；如果false则只炸面前的怪物（即和圣锤等价）"
+				},
+				"snowFourDirections": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "使用冰冻徽章是否四个方向都会消除熔岩；如果false则只消除面前的熔岩"
+				},
+				"bigKeyIsBox": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "如果此项为true，则视为钥匙盒，红黄蓝钥匙+1；若为false，则视为大黄门钥匙"
+				},
+				"steelDoorWithoutKey": {
+					"_left": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "铁门是否不需要钥匙开启。如果此项为true，则无需钥匙也可以开铁门。"
+				},
+				"equipment": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "剑和盾是否作为装备。如果此项为true，则作为装备，需要在装备栏使用，否则将直接加属性。"
+				},
+				"equipboxButton": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "状态栏的装备按钮。若此项为true则将状态栏中的楼层转换器按钮换为装备栏按钮"
+				},
+				"iconInEquipbox": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "在装备栏中的属性变化，是否绘制图标；如果此项开启，则会绘制图标而不是文字"
+				},
+				"enableAddPoint": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否支持加点"
+				},
+				"enableNegativeDamage": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否支持负伤害（回血）"
+				},
+				"hatredDecrease": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否在和仇恨怪战斗后减一半的仇恨值，此项为false则和仇恨怪不会扣减仇恨值。"
+				},
+				"betweenAttackCeil": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "夹击上整还是下整。如果此项为true则夹击伤害值向上取整，为false则为向下取整"
+				},
+				"betweenAttackMax": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "夹击伤害是否不超过怪物伤害值。"
+				},
+				"useLoop": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否循环计算临界；如果此项为true则使用循环法（而不是回合数计算法）来算临界\n从V2.5.3开始，对于大数据的循环法将改为使用二分法进行计算"
+				},
+				"startUsingCanvas": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否开始菜单canvas化；如果此项为true，则将使用canvas来绘制开始菜单"
+				},
+				"startDirectly": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "点击“开始游戏”后是否立刻开始游戏而不显示难度选择界面"
+				},
+				"statusCanvas": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否状态栏canvas化，即手动自定义绘制状态栏。\n如果此项开启，则可在脚本编辑的drawStatusBar中自定义绘制菜单栏。"
+				},
+				"statusCanvasRowsOnMobile": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_range": "thiseval==null || (thiseval>0 && thiseval<=4)",
+					"_data": "竖屏模式下，顶端状态栏canvas化后的行数。\n此项将决定竖屏的状态栏高度，如果设置则不小于1且不大于4。\n仅在statusCanvas开启时才有效"
+				},
+				"displayEnemyDamage": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否地图怪物显伤；用户可以手动在菜单栏中开关"
+				},
+				"displayCritical": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否地图显示临界；用户可以手动在菜单栏中开关"
+				},
+				"displayExtraDamage": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否地图高级显伤（领域、夹击等）；用户可以手动在菜单栏中开关"
+				},
+				"enableGentleClick": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否允许轻触（获得面前物品）"
+				},
+				"potionWhileRouting": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "寻路算法是否经过血瓶；如果该项为false，则寻路算法会自动尽量绕过血瓶"
+				},
+				"ignoreChangeFloor": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "经过楼梯、传送门时是否能“穿透”。\n穿透的意思是，自动寻路得到的的路径中间经过了楼梯，行走时是否触发楼层转换事件"
+				},
+				"canGoDeadZone": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否允许走到将死的领域上。如果此项为true，则可以走到将死的领域上"
+				},
+				"enableMoveDirectly": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否允许瞬间移动"
+				},
+				"enableDisabledShop": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否允许查看未开启状态的快捷商店内容；如果此项为真，则对于未开启状态的商店允许查看其内容（但不能购买）"
+				},
+				"disableShopOnDamage": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否在经过领域/夹击/路障等伤害后禁用快捷商店。"
+				},
+				"checkConsole": {
+					"_leaf": true,
+					"_type": "checkbox",
+					"_bool": "bool",
+					"_data": "是否检查控制台的开启情况。"
+				}
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/_server/table/events.comment.js b/_server/table/events.comment.js
new file mode 100644
index 00000000..4432901f
--- /dev/null
+++ b/_server/table/events.comment.js
@@ -0,0 +1,46 @@
+/*
+ * 表格配置项。
+ * 在这里可以对表格中的各项显示进行配置，包括表格项、提示内容等内容。具体写法照葫芦画瓢即可。
+ * 本配置项包括：公共事件。
+ */
+
+var events_comment_c456ea59_6018_45ef_8bcc_211a24c627dc = {
+	"_type": "object",
+	"_data": {
+		"commonEvent": {
+			"_type": "object",
+			"_data": function (key) {
+				var obj = {
+					"加点事件": {
+						"_leaf": true,
+						"_type": "event",
+						"_range": "thiseval instanceof Array",
+						"_event": "commonEvent",
+						"_data": "打败怪物后加点"
+					},
+					"毒衰咒处理": {
+						"_leaf": true,
+						"_type": "event",
+						"_range": "thiseval instanceof Array",
+						"_event": "commonEvent",
+						"_data": "毒衰咒效果处理"
+					},
+					"滑冰事件": {
+						"_leaf": true,
+						"_type": "event",
+						"_range": "thiseval instanceof Array",
+						"_event": "commonEvent",
+						"_data": "滑冰事件"
+					},
+				}
+				if (obj[key]) return obj[key];
+				return {
+					"_leaf": true,
+					"_type": "event",
+					"_event": "commonEvent",
+					"_data": "自定义公共事件，可以双击进入事件编辑器"
+				}
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/_server/table/functions.comment.js b/_server/table/functions.comment.js
new file mode 100644
index 00000000..44396901
--- /dev/null
+++ b/_server/table/functions.comment.js
@@ -0,0 +1,216 @@
+/*
+ * 表格配置项。
+ * 在这里可以对表格中的各项显示进行配置，包括表格项、提示内容等内容。具体写法照葫芦画瓢即可。
+ * 本配置项包括：脚本编辑。
+ */
+
+var functions_comment_c456ea59_6018_45ef_8bcc_211a24c627dc = {
+	"_type": "object",
+	"_data": {
+		"events": {
+			"_type": "object",
+			"_data": {
+				"resetGame": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "重置整个游戏"
+				},
+				"setInitData": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "设置初始属性"
+				},
+				"win": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "游戏获胜事件"
+				},
+				"lose": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "游戏失败事件"
+				},
+				"changingFloor": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "切换楼层中"
+				},
+				"afterChangeFloor": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "切换楼层后"
+				},
+				"flyTo": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "楼层飞行"
+				},
+				"beforeBattle": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "战前事件"
+				},
+				"afterBattle": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "战后事件"
+				},
+				"afterOpenDoor": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "开门后事件"
+				},
+				"afterGetItem": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "获得道具后事件"
+				},
+				"afterChangeLight": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "改变亮灯事件"
+				},
+				"afterPushBox": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "推箱子事件"
+				},
+				"afterUseBomb": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "炸弹事件"
+				},
+				"canUseQuickShop": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "能否用快捷商店"
+				}
+			}
+		},
+		"enemys": {
+			"_type": "object",
+			"_data": {
+				"getSpecials": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "怪物特殊属性定义"
+				},
+				"getEnemyInfo": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "获得怪物真实属性"
+				},
+				"getDamageInfo": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "获得战斗伤害信息"
+				},
+				"updateEnemys": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "更新怪物数据"
+				}
+			}
+		},
+		"actions": {
+			"_type": "object",
+			"_data": {
+				"onKeyUp": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "按键处理"
+				}
+			}
+		},
+		"control": {
+			"_type": "object",
+			"_data": {
+				"saveData": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "存档操作"
+				},
+				"loadData": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "读档操作"
+				},
+				"updateStatusBar": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "更新状态栏"
+				},
+				"updateCheckBlock": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "阻激夹域伤害"
+				},
+				"moveOneStep": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "每一步后的操作"
+				},
+				"moveDirectly": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "瞬间移动处理"
+				},
+				"parallelDo": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "并行事件处理"
+				}
+			}
+		},
+		"ui": {
+			"_type": "object",
+			"_data": {
+				"drawStatusBar": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "自绘状态栏"
+				},
+				"drawStatistics": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "地图数据统计"
+				},
+				"drawAbout": {
+					"_leaf": true,
+					"_type": "textarea",
+					"_lint": true,
+					"_data": "绘制关于界面"
+				}
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/_server/maps.comment.js b/_server/table/maps.comment.js
similarity index 98%
rename from _server/maps.comment.js
rename to _server/table/maps.comment.js
index ddf8e8e6..187119a9 100644
--- a/_server/maps.comment.js
+++ b/_server/table/maps.comment.js
@@ -1,4 +1,4 @@
-maps_comment_90f36752_8815_4be8_b32b_d7fad1d0542e = 
+var maps_comment_c456ea59_6018_45ef_8bcc_211a24c627dc =
 {
     ////////////////////////// 地形部分 //////////////////////////
 
diff --git a/_server/table/plugins.comment.js b/_server/table/plugins.comment.js
new file mode 100644
index 00000000..fc4f5144
--- /dev/null
+++ b/_server/table/plugins.comment.js
@@ -0,0 +1,32 @@
+/*
+ * 表格配置项。
+ * 在这里可以对表格中的各项显示进行配置，包括表格项、提示内容等内容。具体写法照葫芦画瓢即可。
+ * 本配置项包括：插件编写。
+ */
+
+var plugins_comment_c456ea59_6018_45ef_8bcc_211a24c627dc = {
+	"_type": "object",
+	"_data": function (key) {
+		var obj = {
+			"init": {
+				"_leaf": true,
+				"_type": "textarea",
+				"_range": "typeof(thiseval)=='string'",
+				"_data": "自定义插件"
+			},
+			"drawLight": {
+				"_leaf": true,
+				"_type": "textarea",
+				"_range": "typeof(thiseval)=='string' || thiseval==null",
+				"_data": "绘制灯光效果"
+			},
+		}
+		if (obj[key]) return obj[key];
+		return {
+			"_leaf": true,
+			"_type": "textarea",
+			"_range": "typeof(thiseval)=='string' || thiseval==null",
+			"_data": "自定义插件"
+		}
+	}
+}
\ No newline at end of file
diff --git a/_server/vm.js b/_server/vm.js
deleted file mode 100644
index 7f932169..00000000
--- a/_server/vm.js
+++ /dev/null
@@ -1,405 +0,0 @@
-// vue 相关处理
-document.body.onmousedown = function (e) {
-    //console.log(e);
-    var clickpath = [];
-    var getpath=function(e) {
-        var path = [];
-        var currentElem = e.target;
-        while (currentElem) {
-            path.push(currentElem);
-            currentElem = currentElem.parentElement;
-        }
-        if (path.indexOf(window) === -1 && path.indexOf(document) === -1)
-            path.push(document);
-        if (path.indexOf(window) === -1)
-            path.push(window);
-        return path;
-    }
-    getpath(e).forEach(function (node) {
-        if (!node.getAttribute) return;
-        var id_ = node.getAttribute('id');
-        if (id_) {
-            if (['left', 'left1', 'left2', 'left3', 'left4', 'left5', 'left8', 'mobileview'].indexOf(id_) !== -1) clickpath.push('edit');
-            clickpath.push(id_);
-        }
-    });
-
-    var unselect=true;
-    for(var ii=0,thisId;thisId=['edit','tip','brushMod','brushMod2','viewportButtons'][ii];ii++){
-        if (clickpath.indexOf(thisId) !== -1){
-            unselect=false;
-            break;
-        }
-    }
-    if (unselect) {
-        if (clickpath.indexOf('eui') === -1) {
-            if (selectBox.isSelected) {
-                editor_mode.onmode('');
-                editor.file.saveFloorFile(function (err) {
-                    if (err) {
-                        printe(err);
-                        throw(err)
-                    }
-                    ;printf('地图保存成功');
-                });
-            }
-            selectBox.isSelected = false;
-            editor.info = {};
-        }
-    }
-    //editor.mode.onmode('');
-    if (e.button!=2 && !editor.isMobile){
-        editor.hideMidMenu();
-    }
-    if (clickpath.indexOf('down') !== -1 && editor.isMobile && clickpath.indexOf('midMenu') === -1){
-        editor.hideMidMenu();
-    }
-    if(clickpath.length>=2 && clickpath[0].indexOf('id_')===0){editor.lastClickId=clickpath[0]}
-}
-iconLib.onmousedown = function (e) {
-    e.stopPropagation();
-}
-var exportMap = new Vue({
-    el: '#exportMap',
-    data: {
-        isExport: false,
-    },
-    methods: {
-        exportMap: function () {
-            editor.updateMap();
-            var sx=editor.map.length-1,sy=editor.map[0].length-1;
-
-            var filestr = '';
-            for (var yy = 0; yy <= sy; yy++) {
-                filestr += '['
-                for (var xx = 0; xx <= sx; xx++) {
-                    var mapxy = editor.map[yy][xx];
-                    if (typeof(mapxy) == typeof({})) {
-                        if ('idnum' in mapxy) mapxy = mapxy.idnum;
-                        else {
-                            // mapxy='!!?';
-                            tip.whichShow = 3;
-                            return;
-                        }
-                    } else if (typeof(mapxy) == 'undefined') {
-                        tip.whichShow = 3;
-                        return;
-                    }
-                    mapxy = String(mapxy);
-                    mapxy = Array(Math.max(4 - mapxy.length, 0)).join(' ') + mapxy;
-                    filestr += mapxy + (xx == sx ? '' : ',')
-                }
-
-                filestr += ']' + (yy == sy ? '' : ',\n');
-            }
-            pout.value = filestr;
-            editArea.mapArr = filestr;
-            this.isExport = true;
-            editArea.error = 0;
-            tip.whichShow = 2;
-        }
-    }
-})
-var editArea = new Vue({
-    el: '#editArea',
-    data: {
-        mapArr: '',
-        errors: [ // 编号1,2,3,4
-            "格式错误！请使用正确格式(width*height数组，如不清楚，可先点击生成地图查看正确格式)",
-            "当前有未定义ID（在地图区域显示红块），请修改ID或者到icons.js和maps.js中进行定义！",
-            "ID越界（在地图区域显示红块），当前编辑器暂时支持编号小于400，请修改编号！",
-            // "发生错误！",
-        ],
-        error: 0,
-        formatTimer: null,
-    },
-    watch: {
-        mapArr: function (val, oldval) {
-            var that = this;
-            if (val == '') return;
-            if (exportMap.isExport) {
-                exportMap.isExport = false;
-                return;
-            }
-            if (that.formatArr()) {
-                that.error = 0;
-
-                setTimeout(function () {
-                    that.mapArr = that.formatArr();
-                    that.drawMap();
-                    tip.whichShow = 8
-                }, 1000);
-                that.formatTimer = setTimeout(function () {
-                    pout.value = that.formatArr();
-                }, 5000); //5s后再格式化，不然光标跳到最后很烦
-            } else {
-                that.error = 1;
-            }
-        },
-        error: function () {
-            // console.log(editArea.mapArr);
-        }
-    },
-    methods: {
-        drawMap: function () {
-            var that = this;
-
-            // var mapArray = that.mapArr.split(/\D+/).join(' ').trim().split(' ');
-            var mapArray = JSON.parse('[' + that.mapArr + ']');
-            var sy=editor.map.length,sx=editor.map[0].length;
-            for (var y = 0; y < sy; y++)
-                for (var x = 0; x < sx; x++) {
-                    var num = mapArray[y][x];
-                    if (num == 0)
-                        editor.map[y][x] = 0;
-                    else if (num >= 1000) {
-                        that.error = 3;
-                        editor.map[y][x] = undefined;
-                    } else if (typeof(editor.indexs[num][0]) == 'undefined') {
-                        that.error = 2;
-                        editor.map[y][x] = undefined;
-                    } else editor.map[y][x] = editor.ids[[editor.indexs[num][0]]];
-                }
-
-            editor.updateMap();
-
-        },
-        formatArr: function () {
-            var formatArrStr = '';
-            var that = this;
-            clearTimeout(that.formatTimer);
-            var si=editor.map.length,sk=editor.map[0].length;
-            if (this.mapArr.split(/\D+/).join(' ').trim().split(' ').length != si*sk) return false;
-            var arr = this.mapArr.replace(/\s+/g, '').split('],[');
-
-            if (arr.length != si) return;
-            for (var i = 0; i < si; i++) {
-                var a = [];
-                formatArrStr += '[';
-                if (i == 0 || i == si-1) a = arr[i].split(/\D+/).join(' ').trim().split(' ');
-                else a = arr[i].split(/\D+/);
-                if (a.length != sk) {
-                    formatArrStr = '';
-                    return;
-                }
-
-                for (var k = 0; k < sk; k++) {
-                    var num = parseInt(a[k]);
-                    formatArrStr += Array(Math.max(4 - String(num).length, 0)).join(' ') + num + (k == sk-1 ? '' : ',');
-                }
-                formatArrStr += ']' + (i == si-1 ? '' : ',\n');
-            }
-            return formatArrStr;
-        }
-    }
-});
-var copyMap = new Vue({
-    el: '#copyMap',
-    data: {
-        err: ''
-    },
-    methods: {
-        copyMap: function () {
-
-            tip.whichShow = 0;
-            if (pout.value.trim() != '') {
-                if (editArea.error) {
-                    this.err = editArea.errors[editArea.error - 1];
-                    tip.whichShow = 5
-                    return;
-                }
-                try {
-                    pout.focus();
-                    pout.setSelectionRange(0, pout.value.length);
-                    document.execCommand("Copy");
-                    tip.whichShow = 6;
-                } catch (e) {
-                    this.err = e;
-                    tip.whichShow = 5;
-                }
-            } else {
-                tip.whichShow = 7;
-            }
-        }
-    },
-})
-var clearMap = new Vue({
-    el: '#clearMap',
-
-    methods: {
-        clearMap: function () {
-            editor.mapInit();
-            editor_mode.onmode('');
-            editor.file.saveFloorFile(function (err) {
-                if (err) {
-                    printe(err);
-                    throw(err)
-                }
-                ;printf('地图清除成功');
-            });
-            editor.updateMap();
-            clearTimeout(editArea.formatTimer);
-            clearTimeout(tip.timer);
-            pout.value = '';
-            editArea.mapArr = '';
-            tip.whichShow = 4;
-            editArea.error = 0;
-        }
-    }
-})
-var deleteMap = new Vue({
-    el: '#deleteMap',
-    methods: {
-        deleteMap: function () {
-            editor_mode.onmode('');
-            var index = core.floorIds.indexOf(editor.currentFloorId);
-            if (index>=0) {
-                core.floorIds.splice(index,1);
-                editor.file.editTower([['change', "['main']['floorIds']", core.floorIds]], function (objs_) {/*console.log(objs_);*/
-                    if (objs_.slice(-1)[0] != null) {
-                        printe(objs_.slice(-1)[0]);
-                        throw(objs_.slice(-1)[0])
-                    }
-                    ;printe('删除成功,请F5刷新编辑器生效');
-                });
-            }
-            else printe('删除成功,请F5刷新编辑器生效');
-        }
-    }
-})
-printf = function (str_, type) {
-    selectBox.isSelected = false;
-    if (!type) {
-        tip.whichShow = 11;
-    } else {
-        tip.whichShow = 12;
-    }
-    setTimeout(function () {
-        if (!type) {
-            tip.msgs[11] = String(str_);
-            tip.whichShow = 12;
-        } else {
-            tip.msgs[10] = String(str_);
-            tip.whichShow = 11;
-        }
-    }, 1);
-}
-printe = function (str_) {
-    printf(str_, 'error')
-}
-tip_in_showMode = [
-    '涉及图片的更改需要F5刷新浏览器来生效',
-    '文本域可以通过双击,在文本编辑器或事件编辑器中编辑',
-    '事件编辑器中的显示文本和自定义脚本的方块也可以双击',
-    "画出的地图要点击\"保存地图\"才会写入到文件中",
-];
-var tip = new Vue({
-    el: '#tip',
-    data: {
-        infos: {},
-        hasId: true,
-        isAutotile: false,
-        isSelectedBlock: false,
-        isClearBlock: false,
-        geneMapSuccess: false,
-        timer: null,
-        msgs: [ //分别编号1,2,3,4,5,6,7,8,9,10；奇数警告，偶数成功
-            "当前未选择任何图块，请先在右边选择要画的图块!",
-            "生成地图成功！可点击复制按钮复制地图数组到剪切板",
-            "生成失败! 地图中有未定义的图块，建议先用其他有效图块覆盖或点击清除地图！",
-            "地图清除成功!",
-            "复制失败！",
-            "复制成功！可直接粘贴到楼层文件的地图数组中。",
-            "复制失败！当前还没有数据",
-            "修改成功！可点击复制按钮复制地图数组到剪切板",
-            "选择背景图片失败！文件名格式错误或图片不存在！",
-            "更新背景图片成功！",
-            "11:警告",
-            "12:成功"
-        ],
-        mapMsg: '',
-        whichShow: 0,
-    },
-    watch: {
-        infos: {
-            handler: function (val, oldval) {
-                this.isClearBlock = false;
-                if (typeof(val) != 'undefined') {
-                    if (val == 0) {
-                        this.isClearBlock = true;
-                        return;
-                    }
-                    if ('id' in val) {
-                        this.hasId = true;
-                    } else {
-                        this.hasId = false;
-                    }
-                    this.isAutotile = false;
-                    if (val.images == "autotile" && this.hasId) this.isAutotile = true;
-                }
-            },
-            deep: true
-        },
-
-        whichShow: function () {
-            var that = this;
-            that.mapMsg = '';
-            that.msgs[4] = "复制失败！" + editTip.err;
-            clearTimeout(that.timer);
-            if (that.whichShow) {
-                that.mapMsg = that.msgs[that.whichShow - 1];
-                that.timer = setTimeout(function () {
-                    if (!(that.whichShow % 2))
-                        that.whichShow = 0;
-                }, 5000); //5秒后自动清除success，warn不清除
-            }
-        }
-    }
-})
-
-var selectBox = new Vue({
-    el: '#selectBox',
-    data: {
-        isSelected: false
-    },
-    watch: {
-        isSelected: function () {
-            tip.isSelectedBlock = this.isSelected;
-            tip.whichShow = 0;
-            clearTimeout(tip.timer);
-        }
-    }
-})
-
-var bgSelect = new Vue({
-    el: '#bgSelect',
-    data: {
-        bgs: {},
-        selectedBg: 'ground',
-        imgname: ''
-    },
-    watch: {
-        selectedBg: function () {
-            editor.bgY = this.bgs.indexOf(this.selectedBg);
-            editor.drawMapBg();
-        }
-    },
-    methods: {
-        updatebg: function () {
-            tip.whichShow = 0;
-            var regx = /\S+\.(png|bmp|jpg|jpeg|gif)$/i;
-            if (regx.test(this.imgname)) {
-                var url = 'images/' + this.imgname;
-                editor.loadImg(url).then(function (img) {
-                    editor.drawMapBg(img);
-                    tip.whichShow = 10;
-                }).catch(function (err) {
-                    console.log(err);
-                    tip.whichShow = 9;
-                });
-            } else {
-                tip.whichShow = 9;
-            }
-        }
-    }
-})
\ No newline at end of file
diff --git a/docs/.nojekyll b/docs/.nojekyll
deleted file mode 100644
index e69de29b..00000000
diff --git a/docs/_api.md b/docs/_api.md
deleted file mode 100644
index f64ed2ac..00000000
--- a/docs/_api.md
+++ /dev/null
@@ -1,367 +0,0 @@
-# 附录:API列表
-
-?> 目前版本**v2.3.3**，上次更新时间：* {docsify-updated} *
-
-所有系统支持的API都列在了这里。所有可能被用到的API都在前面用\*标记。
-
-可以在chrome浏览器的控制台中（`ctrl+shift+I`，找到Console）中直接进行调用，以查看效果。
-
-!> **`main.js`：游戏入口，所有其他JS文件都是被此文件加载。**
-
-``` js
-main.init // 初始化
-main.loaderJs // 动态加载所有核心JS文件
-main,loaderFloors // 动态加载所有楼层（剧本）
-main.loadMod // 加载某一个JS文件
-main.loadFloor // 加载某一个楼层
-main.setMainTipsText // 加载过程提示
-window.onresize // 窗口大小变化时
-main.dom.body.onkeydown // 在界面上按下某按键时
-main.dom.body.onkeydown // 在界面上放开某按键时
-main.dom.body.onselectstart // 开始选择时
-main.dom.data.onmousedown // 鼠标按下时
-main.dom.data.onmousemove // 鼠标移动时
-main.dom.data.onmouseup // 鼠标放开时
-main.dom.data.onmousewheel // 鼠标滑轮滚动时
-main.dom.data.ontouchstart // 手指在触摸屏开始触摸时
-main.dom.data.ontouchmove // 手指在触摸屏上移动时
-main.dom.data.ontouchend // 手指离开触摸屏时
-main.statusBar.image.book.onclick // 点击状态栏中的怪物手册时
-main.statusBar.image.fly.onclick // 点击状态栏中的楼层传送器时
-main.statusBar.image.toolbox.onclick // 点击状态栏中的工具箱时
-main.statusBar.image.shop.onclick // 点击状态栏中的快捷商店时
-main.statusBar.image.save.onclick // 点击状态栏中的存档按钮时
-main.statusBar.image.load.onclick // 点击状态栏中的读档按钮时
-main.statusBar.image.settings.onclick // 点击状态栏中的系统菜单时
-main.dom.playGame.onclick // 点击“开始游戏”时
-main.dom.loadGame.onclick // 点击“载入游戏”时
-main.dom.replayGame.onclick // 点击“录像回放”时
-main.dom.easyLevel.onclick // 点击“简单难度”时
-main.dom.normalLevel.onclick // 点击“普通难度”时
-main.dom.hardLevel.onclick // 点击“困难难度”时
-```
-
-!> **`core.js`：系统核心文件。所有核心逻辑处理都在此文件完成。**
-
-``` js
-* core.status.floorId // 获得当前层floorId
-* core.status.thisMap // 获得当前层的地图信息
-* core.status.maps // 获得所有楼层的地图信息
-* core.floors // 获得所有楼层的剧本
-
-// ------ 初始化部分 ------
-core.init // 初始化
-core.showStartAnimate // 显示游戏开始界面
-core.hideStartAnimate // 隐藏游戏开始界面
-core.setStartProgressVal // 设置加载进度条进度
-core.setStartLoadTipText // 设置加载进度条提示文字
-core.loader // 加载图片和音频
-core.loadAutotile // 加载Autotile
-core.loadImage // 加载图片
-core.loadMusic // 加载音频
-core.isPlaying // 游戏是否已经开始
-core.clearStatus // 清除游戏状态和数据
-core.resetStatus // 重置游戏状态和初始数据
-core.startGame // 开始游戏
-* core.restart // 重新开始游戏；此函数将回到标题页面
-
-// ------ 键盘、鼠标事件 ------
-core.onKeyDown // 按下某个键时
-core.onKeyUp // 放开某个键时
-core.pressKey // 按住某个键时
-core.keyDown // 根据按下键的code来执行一系列操作
-core.keyUp // 根据放开键的code来执行一系列操作
-core.ondown // 点击（触摸）事件按下时
-core.onmove // 当在触摸屏上滑动时
-core.onup // 当点击（触摸）事件放开时
-core.getClickLoc // 获得点击事件相对左上角的坐标（0到12之间）
-core.onclick // 具体点击屏幕上(x,y)点时，执行的操作
-core.onmousewheel // 滑动鼠标滚轮时的操作
-
-// ------ 自动寻路代码相关 ------
-core.clearAutomaticRouteNode // 清除自动寻路路线
-core.stopAutomaticRoute // 停止自动寻路操作
-core.continueAutomaticRoute // 继续剩下的自动寻路操作
-core.clearContinueAutomaticRoute // 清空剩下的自动寻路列表
-core.setAutomaticRoute // 设置自动寻路路线
-core.automaticRoute // 自动寻路算法，找寻最优路径
-core.fillPosWithPoint // 显示离散的寻路点
-core.clearStepPostfix // 清除已经寻路过的部分
-
-// ------ 自动行走，行走控制 ------
-core.stopAutoHeroMove // 停止勇士的自动行走
-core.setAutoHeroMove // 设置勇士的自动行走路线
-core.autoHeroMove // 让勇士开始自动行走
-core.setHeroMoveInterval // 设置行走的效果动画
-core.setHeroMoveTriggerInterval // 设置勇士行走过程中对事件的触发检测
-core.moveAction // 实际每一步的行走过程
-* core.turnHero(direction) // 设置勇士的方向（转向）
-core.canMoveHero // 勇士能否前往某方向
-core.moveHero // 让勇士开始移动
-core.eventMoveHero // 使用事件让勇士移动。这个函数将不会触发任何事件。
-core.moveOneStep // 每移动一格后执行的事件。中毒时在这里进行扣血判断。
-core.waitHeroToStop(callback) // 停止勇士的一切行动，等待勇士行动结束后，再执行callback回调函数。
-core.stopHero // 停止勇士的移动状态。
-core.drawHero // 绘制勇士。
-* core.setHeroLoc(name, value) // 设置勇士的位置。name为”direction”,”x”,”y”
-* core.getHeroLoc(name) // 获得勇士的位置。
-* core.nextX // 获得勇士面对位置的x坐标
-* core.nextY // 获得勇士面对位置的y坐标
-
-// ------ 地图和事件处理 ------
-* core.openDoor(id, x, y, needKey, callback) // 打开一扇位于 (x,y) 的门
-* core.battle(id, x, y, force, callback) // 进行战斗；force表示是否强制战斗
-core.afterBattle // 战斗完毕
-core.trigger(x,y) // 触发x,y点的事件
-* core.changeFloor(floorId, stair, heroLoc, time, callback) // 楼层切换。floorId为目标楼层Id，stair可指定为上/下楼梯，time动画时间
-core.mapChangeAnimate // 地图切换动画效果
-core.clearMap // 清除地图
-core.fillText // 在某个canvas上绘制一段文字
-core.fillRect // 在某个canvas上绘制一个矩形
-core.strokeRect // 在某个canvas上绘制一个矩形的边框
-core.drawLine // 在某个canvas上绘制一条线
-core.setFont // 设置某个canvas的文字字体
-core.setLineWidth // 设置某个canvas的线宽度
-core.saveCanvas // 保存某个canvas状态
-core.loadCanvas // 加载某个canvas状态
-core.setStrokeStyle // 设置某个canvas边框属性
-core.setAlpha // 设置某个canvas的alpha值
-core.setOpacity // 设置某个canvas的透明度
-core.setFillStyle // 设置某个canvas的绘制属性（如颜色等）
-* core.drawMap(mapId, callback) // 绘制某张地图。mapId为地图Id，绘制完毕将执行callback回调函数。
-core.drawAutotile // 绘制Autotile
-* core.noPassExists(x,y) // 某个点是否不可通行
-core.noPass // 某个点是否在区域内且不可通行
-* core.npcExists(x,y) // 某个点是否存在NPC
-* core.terrainExists(x,y) // 某个点是否存在（指定的）地形
-* core.stairExists(x,y) // 某个点是否存在楼梯
-* core.nearStair // 当前位置是否在楼梯边
-* core.enemyExists(x,y) // 某个点是否存在（指定的）怪物
-* core.getBlock(x, y, floorId, needEnable) // 获得某个点的block。floorId指定目标楼层，needEnable如果为false则即使该点的事件处于禁用状态也将被返回（否则只有事件启用的点才被返回）
-core.moveBlock // 显示移动某块的动画，达到{“type”:”move”}的效果
-core.animateBlock // 显示/隐藏某个块时的动画效果
-core.showBlock // 将某个块从禁用变成启用状态
-core.removeBlock // 将某个块从启用变成禁用状态
-core.removeBlockById // 根据block的索引删除该块
-core.removeBlockByIds // 一次性删除多个block
-core.addGlobalAnimate // 添加一个全局动画
-core.removeGlobalAnimate // 删除一个或所有全局动画
-core.setGlobalAnimate // 设置全局动画的显示效果
-core.syncGlobalAnimate // 同步所有的全局动画效果
-core.drawBoxAnimate // 绘制UI层的box动画
-core.updateCheckBlock // 更新领域、夹击、阻击的伤害地图
-core.checkBlock // 检查并执行领域、夹击、阻击事件
-core.snipe // 阻击事件（动画效果）
-core.setFg // 更改画面色调
-* core.updateFg // 更新全地图显伤
-* core.itemCount // 获得某个物品的个数
-* core.hasItem // 是否存在某个物品
-* core.setItem // 设置某个物品的个数
-* core.removeItem // 删除某个物品
-* core.useItem // 使用某个物品；直接调用items.js中的useItem函数。
-* core.canUseItem // 能否使用某个物品。直接调用items.js中的canUseItem函数。
-* core.addItem // 增加某个物品的个数
-core.getNextItem // 获得面前的物品（轻按）
-* core.getItem // 获得某个物品
-* core.drawTip // 左上角绘制一段提示
-* core.drawText // 地图中间绘制一段文字
-
-// ------ 系统机制 ------
-core.replaceText // 将文字中的${和}（表达式）进行替换
-core.calValue // 计算表达式的值
-core.doEffect // 执行一个表达式的effect操作
-core.splitLines // 字符串自动换行的分割
-core.unshift // 向某个数组前插入另一个数组或元素
-core.setLocalStorage // 设置本地存储
-core.getLocalStorage // 获得本地存储
-core.removeLocalStorage // 移除本地存储
-core.clone // 深拷贝一个对象
-core.formatDate // 格式化时间为字符串
-core.formatDate2 // 格式化时间为最简字符串
-core.setTwoDigits // 两位数显示
-core.debug // 进入Debug模式，攻防血和钥匙都调成很高的数值
-core.replay // 开始回放
-core.checkStatus // 判断当前能否进入某个事件
-core.openBook // 点击怪物手册时的打开操作
-core.useFly // 点击楼层传送器时的打开操作
-core.openToolbox // 点击工具栏时的打开操作
-core.openQuickShop // 点击快捷商店时的打开操作
-core.save // 点击保存按钮时的打开操作
-core.load // 点击读取按钮时的打开操作
-core.openSettings // 点击设置按钮时的打开操作
-core.autosave // 自动存档
-core.doSL // 实际进行存读档事件
-core.syncSave // 存档同步操作
-core.saveData // 存档到本地
-core.loadData // 从本地读档
-core.encodeRoute // 将路线压缩
-core.decodeRoute // 将路线解压缩
-* core.setStatus // 设置勇士属性
-* core.getStatus // 获得勇士属性
-core.getLvName // 获得某个等级的名称
-* core.setFlag // 设置某个自定义变量或flag
-* core.getFlag // 获得某个自定义变量或flag
-* core.hasFlag // 是否存在某个自定义变量或flag，且值为true
-core.insertAction // 往当前事件列表之前插入一系列事件
-* core.lockControl // 锁定状态栏，常常用于事件处理
-* core.unlockControl // 解锁状态栏
-* core.isset // 判断某对象是否不为undefined也不会null
-core.readFile // 读取一个本地文件内容
-core.download // 下载文件到本地
-core.copy // 复制一段文字到剪切板
-* core.playBgm // 播放背景音乐
-* core.pauseBgm // 暂停背景音乐的播放
-* core.resumeBgm // 恢复背景音乐的播放
-* core.playSound // 播放音频
-core.show // 动画显示某对象
-core.hide // 动画使某对象消失
-core.clearStatusBar // 清空状态栏
-core.updateStatusBar // 更新状态栏
-core.resize // 屏幕分辨率改变后重新自适应
-core.domRenderer // 渲染DOM
-
-// ------ core.js 结束 ------
-```
-
-!> **`data.js` 定义了一些初始化的数据信息。**
-
-!> **`enemys.js` 定义了怪物信息。**
-
-``` js
-core.enemys.init // 初始化
-* core.enemys.getEnemys // 获得一个或所有怪物数据
-* core.enemys.hasSpecial // 判断是否含有某特殊属性
-* core.enemys.getSpecialText // 获得所有特殊属性的名称
-* core.enemys.getSpecialHint // 获得每个特殊属性的说明
-* core.enemys.getDamage // 获得某个怪物的伤害
-* core.enemys.getExtraDamage // 获得某个怪物的额外伤害
-* core.enemys.getCritical // 临界值计算
-* core.enemys.getCriticalDamage // 临界减伤计算
-* core.enemys.getDefDamage // 1防减伤计算
-* core.enemys.calDamage // 具体的伤害计算公式
-core.enemys.getCurrentEnemys // 获得当前楼层的怪物列表
-```
-
-!> **`events.js` 定义了各个事件的处理流程。**
-
-``` js
-core.events.init // 初始化
-core.events.getEvents // 获得一个或所有系统事件类型
-core.events.startGame // 游戏开始事件
-* core.events.setInitData // 不同难度分别设置初始属性
-* core.events.win // 游戏获胜事件
-* core.events.lose // 游戏失败事件
-core.evens.gameOver // 游戏结束
-core.events.afterChangeFloor // 转换楼层结束的事件
-core.events.doEvents // 开始执行一系列自定义事件
-core.events.doAction // 执行当前自定义事件列表中的下一个事件
-core.events.insertAction // 往当前事件列表之前添加一个或多个事件
-core.events.openShop // 打开一个全局商店
-core.events.disableQuickShop // 禁用一个全局商店
-* core.events.canUseQuickShop // 当前能否使用快捷商店
-* core.events.checkLvUp // 检查升级事件
-* core.events.useItem // 尝试使用道具
-core.events.addPoint // 加点事件
-core.events.afterBattle // 战斗结束后触发的事件
-core.events.afterOpenDoor // 开一个门后触发的事件
-core.events.passNet // 经过一个路障
-core.events.changeLight // 改变亮灯（感叹号）的事件
-* core.events.afterChangeLight // 改变亮灯之后，可以触发的事件
-* core.events.afterUseBomb // 使用炸弹/圣锤后的事件
-* core.events.beforeSaveData // 即将存档前可以执行的操作
-* core.events.afterLoadData // 读档事件后，载入事件前，可以执行的操作
-
-// ------ 点击事件和键盘事件的处理 ------
-core.events.longClick // 长按
-core.events.keyDownCtrl // 按下Ctrl键时（快捷跳过对话）
-core.events.clickConfirmBox // 确认框界面时的点击操作
-core.events.keyUpConfirmBox // 确认框界面时，放开某个键的操作
-core.events.clickAction // 自定义事件时的点击操作
-core.events.keyDownAction // 自定义事件时，按下某个键的操作
-core.events.keyUpAction // 自定义事件时，放开某个键的操作
-core.events.clickBook // 怪物手册界面的点击操作
-core.events.keyDownBook // 怪物手册界面时，按下某个键的操作
-core.events.keyUpBook // 怪物手册界面时，放开某个键的操作
-core.events.clickBookDetail // 怪物手册属性显示界面时的点击操作
-core.events.clickFly // 楼层传送器界面时的点击操作
-core.events.keyDownFly // 楼层传送器界面时，按下某个键的操作
-core.events.keyUpFly // 楼层传送器界面时，放开某个键的操作
-core.events.clickViewMaps // 浏览地图界面时的点击操作
-core.events.keyDownViewMaps // 浏览地图界面时，按下某个键的操作
-core.events.keyUpViewMaps // 浏览地图界面时，放开某个键的操作
-core.events.clickShop // 商店界面时的点击操作
-core.events.keyDownShop // 商店界面时，按下某个键的操作
-core.events.keyUpShop // 商店界面时，放开某个键的操作
-core.events.clickQuickShop // 快捷商店界面时的点击操作
-core.events.keyDownQuickShop // 快捷商店界面时，按下某个键的操作
-core.events.keyUpQuickShop // 快捷商店界面时，放开某个键的操作
-core.events.clickToolbox // 工具栏界面时的点击操作
-core.events.clickToolboxIndex // 选择工具栏界面中某个Index后的操作
-core.events.keyDownToolbox // 工具栏界面时，按下某个键的操作
-core.events.keyUpToolbox // 工具栏界面时，放开某个键的操作
-core.events.clickSL // 存读档界面时的点击操作
-core.events.keyDownSL // 存读档界面时，按下某个键的操作
-core.events.keyUpSL // 存读档界面时，放开某个键的操作
-core.events.clickSwitchs // 系统设置界面时的点击操作
-core.events.keyDownSwitchs // 系统设置界面时，按下某个键的操作
-core.events.keyUpSwitchs // 系统设置界面时，放开某个键的操作
-core.events.clickSettings // 系统菜单栏界面时的点击事件
-core.events.keyDownSettings // 系统菜单栏界面时，按下某个键的操作
-core.events.keyUpSettings // 系统菜单栏界面时，放开某个键的操作
-core.events.clickSyncSave // 同步存档界面时的点击操作
-core.events.keyDownSyncSave // 同步存档界面时，按下某个键的操作
-core.events.keyUpSyncSave // 同步存档界面时，放开某个键的操作
-core.events.clickKeyBoard // 虚拟键盘界面时的点击操作
-core.events.clickAbout // “关于”界面时的点击操作
-```
-
-!> `icons.js` 定义了素材ID和它在图片上的索引的对应关系。
-
-!> `items.js` 定义了每个道具的名称，以及使用效果。
-
-``` js
-core.items.init // 初始化
-core.items.getItems // 获得所有道具
-core.items.getItemEffect // “即捡即用类”道具的使用效果
-core.items.getItemEffectTip // “即捡即用类”道具的文字提示
-* core.items.useItem // 使用道具
-* core.items.cauUseItem // 当前能否使用道具
-```
-
-!> `maps.js` 定义了数字-ID的对应关系。
-
-``` js
-core.maps.loadFloor // 加载某个楼层（从剧本或存档中）
-core.maps.getBlock // 数字和ID的对应关系
-core.maps.addEvent // 向该楼层添加剧本的自定义事件
-core.maps.addChangeFloor // 向该楼层添加剧本的楼层转换事件
-core.maps.initMaps // 初始化所有地图
-core.maps.save // 将当前地图重新变成数字，以便于存档
-core.maps.load // 将存档中的地图信息重新读取出来
-core.maps.getMapArray // 将当前地图重新变成二维数组形式
-```
-
-!> `ui.js` 定义了各种界面的绘制。
-
-``` js
-core.ui.closePanel // 结束一切事件和绘制，关闭UI窗口，返回游戏进程
-core.ui.drawTextBox // 绘制一个对话框
-core.ui.drawChoices // 绘制一个选项界面
-core.ui.drawConfirmBox // 绘制一个确认/取消的警告页面
-core.ui.drawSwitchs // 绘制系统设置界面
-core.ui.drawSettings // 绘制系统菜单栏
-core.ui.drawQuickShop // 绘制快捷商店选择栏
-core.ui.drawBattleAnimate // 绘制战斗动画
-core.ui.drawWaiting // 绘制等待界面
-core.ui.drawSyncSave // 绘制存档同步界面
-core.ui.drawPagination // 绘制分页
-core.ui.drawEnemyBook // 绘制怪物手册
-core.ui.drawBookDetail // 绘制怪物属性的详细信息
-core.ui.drawFly // 绘制楼层传送器
-core.ui.drawMaps // 绘制浏览地图界面
-core.ui.drawToolbox // 绘制道具栏
-core.ui.drawSLPanel // 绘制存档/读档界面
-core.ui.drawThumbnail // 绘制一个缩略图
-core.ui.drawAbout // 绘制“关于”界面
-core.ui.drawHelp // 绘制帮助界面
-```
diff --git a/docs/_start.md b/docs/_start.md
deleted file mode 100644
index 5b3d91dc..00000000
--- a/docs/_start.md
+++ /dev/null
@@ -1,222 +0,0 @@
-# 快速上手
-
-?> 目前版本**v2.3.3**，上次更新时间：* {docsify-updated} *
-
-在这一节中，将详细介绍做一部塔的流程。现在，让我们来做一部单层塔！
-
-## 前置需求
-
-你需要有满足如下条件才能进行制作：
-
-- Windows 8以上操作系统；Windows 7需要安装.Net Framework 4.0。（能打开同目录下的“启动服务.exe”即可）
-- Chrome浏览器。其他浏览器可能会导致本地服务器产生闪退等现象。
-- 一个很好的文本编辑器。推荐带有高亮染色、错误提示等效果。例如：WebStorm，VSCode，或者至少也要Sublime Text。
-  - （[VSCode下载地址](https://code.visualstudio.com/)，群里的群文件中也有，强烈推荐之。）
-  - **2.0版本可以不需要，但是仍然强烈推荐有一个，从而能对H5造塔有更深的了解。**
-
-只要满足了上述条件，你就可以开始做自己的塔啦！
-
-## V2.0的使用
-
-目前版本已经更新到V2.0，在2.0版本中，我们可以进行全GUI造塔。
-
-下面的文档主要是讲如何通过代码编辑的方式来造，仍然强烈建议进行阅读从而有着一定的了解。
-
-如果想直接知道如何在V2.0造塔，可以直接参见[V2.0版本介绍](V2.0)的说明，或者看[B站视频教程](http://www.bilibili.com/video/av17608025/)。
-
-## 启动HTTP服务
-
-在根目录下有一个“启动服务.exe”，运行之。
-
-![启动服务](img/server.png)
-
-* “启动游戏”按钮将打开一个网页，你能在里面看到现在游戏的效果。
-* “地图编辑器”允许你以可视化的方式进行编辑地图。
-* “便捷PS工具”能让你很方便的对自定义素材进行添加。参见[自定义素材](personalization#自定义素材)。
-* “地图生成器”能让你从已有的截图（如RMXP项目）中立刻生成可被本样板识别的地图数据。
-* “RM动画导出器”能让你从RMXP中导出动画而被H5魔塔使用。
-* “JS代码压缩工具”能对JS代码进行压缩，从而减少IO请求数和文件大小。
-* “伤害和临界值计算器”是一个很便捷的小工具，能对怪物的伤害和临界值进行计算。
-
-!> **警告：** 非Chrome浏览器（如Edge/IE等）下本地服务器可能表现不正常，会出现闪退等现象。请务必下载安装Chrome浏览器。
-
-## 新建剧本
-
-类似于RMXP，本塔每层楼都是一个“剧本”，剧本内主要定义了本层的地图和各种事件。主函数将读取每个剧本，并生成实际的地图供游戏使用。
-
-我们打开 `project/floors/` 目录，这个目录是所有剧本的目录。我们需要指定一个楼层名，例如MT1；然后，我们可以将`MT0.js`（模板）复制重命名为为`MT1.js`，并使用文本编辑器打开。
-
-![新建剧本](./img/script.png)
-
-然后将楼层名改为MT1，floorId改名为MT1；title可以改成任意内容，将在切换楼层时进行显示（比如可以改成“1层小塔”）。
-
-具体样板文件的每个要素如下：
-- **`floorId`** 楼层唯一标识符；必须和文件名，以及 `main.floors.xxx` 完全一致
-- **`title`** 楼层中文名，将在切换楼层时进行显示
-- **`name`** 楼层再状态栏显示的名称
-- **`canFlyTo`** 当前楼层可否被楼传器飞到。如果该层不能飞到，则也在该层也不允许使用楼传器。
-- **`canUseQuickShop`** 当前楼层可否使用快捷商店。
-- **`defaultGround`** 该层的背景（地面）素材。
-- **`images`** 该层默认显示的前景/背景图片
-- **`color`** 该层的画面色调。
-- **`bgm`** 到达该层后默认播放的BGM。本项可忽略。
-- **`item_ratio`** 该层的宝石/血瓶倍率
-- **`map`** 本层地图，需要是13x13数组，建议使用地图生成器或者可视化地图编辑器制作。
-- **`firstArrive`** 第一次到该楼层触发的事件
-- **`events`** 该楼的所有可能事件列表
-- **`changeFloor`** 楼层转换事件；该事件不能和上面的events有冲突（同位置点），否则会被覆盖
-- **`afterBattle`** 战斗后可能触发的事件列表
-- **`afterGetItem`** 获得道具后可能触发的事件列表
-- **`afterOpenDoor`** 开完门后可能触发的事件列表
-- **`cannotMove`** 每个图块不可通行的方向，也就是悬崖效果
-
-我们最终的任务其实是，将每个楼层的剧本（地图&事件）给写完即可。
-
-换句话说，只需要简单的复制操作，我们就可以新建一个剧本了。
-
-## 绘制地图
-
-有两种绘制地图的方式：从头绘制地图；从RMXP中导入已有的地图。
-
-### 从头绘制地图
-
-我们直接打开“地图编辑器”，可以看到一个可视化的UI界面。
-
-![地图编辑器](img/mapgui.png)
-
-然后可以在上面任意进行绘制地图。
-
-!> **如果地图的数字和ID未被定义，则会进行提示：数字和ID未被定义！此时要对素材的ID和数字进行定义，请参见[自定义素材](personalization#自定义素材)。**
-
-绘制地图完毕后，点击"导出地图"，即可在左边看到对应的JSON数组，并且已经复制到了剪切板。将其粘贴到剧本中的map位置即可。
-
-![地图数组](./img/maparray.png)
-
-!> V2.0版本可以直接将当前地图进行保存或另存为，不需要这样手动打开进行编辑。
-
-### 从RMXP导入已有的地图
-
-如果我们想复刻一个现有的，已经被RMXP所制作的塔，也有很便捷的方式，那就是用到我们的“地图生成器”。
-
-首先，我们打开RMXP和对应的项目，可以看到它的地图。
-
-![绘制地图](./img/rmxp2.png)
-
-我们打开Windows自带的“截图工具”，并将整个地图有效区域截图下来，并将其复制到剪切板。
-
-![绘制地图](./img/rmxp3.png)
-
-截图时请注意：**只截取有效游戏空间内数据，并且有效空间内的范围必须是13x13。（如果地图小于13*13，请用星空或墙壁填充到13x13）。**
-
-确认地图的图片文件已经复制到剪切板后，我们打开“地图生成器”，并点“加载图片”。大约1-2秒后，可以得到地图的数据。
-
-![生成地图](./img/map1.png)
-
-然后点击“复制地图”，即可将地图数据复制到剪切板。
-
-!> **如果有识别不一致的存在，即生成的地图和实际的地图不符，我们可以在地图编辑器中粘贴，再可视化进行编辑。**
-
-!> **地图生成器默认只支持经典素材。如果有自定义素材需求（例如原版的1层小塔那种素材），请参见[自定义素材](personalization#自定义素材)。**  
-
-!> **请确保截图范围刚好为13x13，并且保证每个位置的像素都是32x32。**
-
-
-## 录入数据
-
-有了地图后，我们下一步需要做的就是录入数据。数据主要包括如下几种：
-
-- 勇士初始的属性
-- 全局变量（宝石效果、全局Flag等）
-- 怪物数据（每个怪物的攻防血金币经验等等）
-
-下面依次进行说明。
-
-我们打开`data.js`文件，这里面定义了各种全局属性和勇士初始值。
-
-!> V2.0版本可以直接在地图编辑器的`全塔属性`中进行修改！
-
-我们可以将本塔标题改名为“1层小塔”，
-
-游戏的唯一标识符叫onefloor，然后可以直接修改勇士的各项初始数据.
-
-!> **注：name作为游戏的唯一标识符必须进行修改，否则可能会导致存档等出现问题。**
-
-![初始数据](./img/init.png)
-
-!> **请注意，勇士的初始位置一栏，x为横坐标，y为纵坐标；即，x为从左到右第几列，y为从上到下第几行，均从0开始计算。**
-
-修改完初始化信息后，接下来我们需要修改道具的信息（比如宝石加攻防的数值，血瓶加生命的数值等）。还是在这个`data.js`文件，往下拉，找到values一项，并进行相应的设置
-
-![修改数据](./img/moddata.png)
-
-然后，再设置一些系统Flag，以进行游戏。继续将`data.js`往下拉，我们注意到本塔是存在魔防的，不存在经验，因此我们可以简单地将enableMDef改为true，enableExperience改成false，enableDebuff改成false。
-
-同理，本塔的破墙镐只能破面前的墙壁，因此`pickaxeFourDirections`需要改成`false`。
-
-![系统标志](./img/flag.png)
-
-其他的几项暂时不会被涉及到，因此不用考虑。
-
-全局变量修改完毕后，我们需要告诉主函数加载该楼层。打开`data.js`，找到`floorIds`项，将其值改为楼层ID即MT1。
-
-最后一步就是录入怪物数据。打开`enemys.js`文件，依次输入你在本塔内使用到的所有怪物的攻防血的数据。其中怪物的特殊属性（special项）与该文件下面的getSpecialText对应。
-
-!> V2.0版本可以直接在“图块属性”一栏进行修改怪物属性！
-
-![怪物数据](./img/enemyarray.png)
-
-只需要修改自己用到的怪物属性即可，其他没有用到的怪物完全无所谓。
-
-做完后保存所有文件，在本地服务器中“启动游戏”，就能立刻看到自己的塔并开始游戏啦！是不是很简单呢！
-
-![保存](./img/save.png)
-
-## 压缩与发布
-
-当你将上述步骤完成后，你实际上已经做出来了一个魔塔，并且可以发布给大家进行游戏了。
-目前而言发布有如下几种方式：
-
-- 离线版本：直接将游戏文件夹打包，放到百度网盘等地方供用户下载；用户下载到本地后直接使用浏览器打开`index.html`进行游戏。
-  - 手机端的部分浏览器如chrome也支持本地网页，可以下载到手机然后直接打开进行游戏。
-- 在线版本：将游戏放到某个服务器上，大家在线联网游戏。
-
-**离线版本的好处是：先全部下载后再游戏，无需考虑流量的问题，也可以支持高清音乐的播放。坏处是：没办法在多平台之间迁移，无法及时获得游戏更新（需要重新下载），而浏览器打开本地文件有丢失存档的风险。  
-在线版本的好处是：随时随地可以玩，可以多平台接档，还可以在后台看到一些统计信息，可以随时对游戏进行更新；坏处是需要一个服务器，且还要考虑到用户流量的问题。**
-
-在此我们只讨论在线版本。当你决定发布游戏时，强烈建议先将JS代码进行压缩以节省可能的IO请求以及网络流量。直接打开同目录下的“JS代码压缩工具”进行压缩即可。
-
-压缩完毕后，你还需要将`main.js`中的useCompress从false改为true，这样方才只会加载压缩后的文件。
-
-如果你需要发布到服务器上且你没有服务器，可以直接将本塔发给我（`艾之葵`），我会给负责你部署上去的。我的服务器至少能保证两年内有效。
-
-然后就是发布帖子、链接二维码，能让任何人在任何时候任何平台上都能进行游戏啦！是不是很简单呢！
-
-## 注意事项和常见FAQ
-
-1. 截图请务必刚好截取13x13的图片，并需要保证每个位置必须为32x32像素。一般无放缩的RMXP符合条件。
-2. 游戏的唯一标识符name请务必修改。如果不修改可能会导致存档出现异常。
-3. 别忘了data.js中要修改floorIds指明所用到的所有楼层哦~
-
-下面是几个常见的FAQ：
-
-**Q: 为什么截图识别不出来？**
-
-**A:** 请保证刚好为13x13，且每个位置必须32x32像素。如果不确定，可以保存你的截图，右键属性查看详细信息，看像素的宽高是不是在416左右。多少几十像素都是没关系的。
-
-![图片大小](./img/imginfo.png)
-
-**Q: 打开游戏时卡死在了xxx.js加载完毕！无法进入游戏。**
-
-**A:** 最大的可能是因为少了逗号，或者反括号等等。一般而言VSCode都会有错误提示，你哪里少了东西。
-
-如果没有，可以采用如下方式debug：
-
-Ctrl+Shift+I 打开Chrome的控制台，找到Console。
-
-如果出现了语法错误，会有红色提示 **Unexpected xxx** ，找到后面文件名和行号，打开，使用VSCode检查该处是否存在问题，即可。
-
-![检查错误](./img/chrome.png)
-
-==========================================================================================
-
-[继续阅读下一章：元件说明](element)
\ No newline at end of file
diff --git a/docs/element.md b/docs/element.md
deleted file mode 100644
index b5496f4a..00000000
--- a/docs/element.md
+++ /dev/null
@@ -1,322 +0,0 @@
-# 元件说明
-
-?> 目前版本**v2.3.3**，上次更新时间：* {docsify-updated} *
-
-在本章中，将对样板里的各个元件进行说明。各个元件主要包括道具、门、怪物、楼梯等等。
-
-请打开样板0层 `sample0.js` 进行参照对比。
-
-![生成地图](./img/sample0.png)
-
-## 道具
-
-本塔目前支持的所有道具列表在样板0层中已全部给出。当你在样板0层中拿到某个宝物时会有提示，这里不再赘述，详见拿到该道具的说明。
-
-大多数宝物都有默认的效果，屠龙匕首暂未定义，如有自己的需求可参见[自定义道具效果](personalization#自定义道具效果)。
-
-拿到道具后将触发`afterGetItem`事件，有关事件的详细介绍请参见[事件](event)。
-
-如需修改某个道具的效果，在不同区域宝石数据发生变化等问题，请参见[自定义道具效果](personalization#自定义道具效果)的说明。
-
-**有关轻按，在data.js的系统变量中有定义。如果`enableGentleClick`为true，则鼠标（触摸屏）通过双击勇士，键盘通过空格可达到轻按效果，即不向前移动而获得前方物品。**
-
-## 装备
-
-如果需要让剑盾等变成装备，可以直接在`data.js`中设置`'equipment': true`即可。
-
-有关装备更为详细的资料可参见[自定义装备](personalization#自定义装备)的说明。
-
-## 门
-
-本塔支持6种门，黄蓝红绿铁花。前五种门需要有对应的钥匙打开，花门只能通过调用`openDoor`事件进行打开。
-
-开门后可触发该层的`afterOpenDoor`事件，有关事件的详细介绍请参见第四章。
-
-## 暗墙
-
-本塔支持暗墙。
-
-要制作一个暗墙非常简单：在该点直接放一个普通墙壁，然后事件写“开门”，坐标为该点就行。
-
-``` js
-// 该点画一个普通的墙壁，比如`yellowWall`
-
-// 在该点的事件events中:
-"x,y": [
-    {"type": "openDoor", "loc": [x,y]} // 直接使用开门事件，坐标需写当前点坐标。
-]
-```
-
-系统会自动调用animates中的开暗墙动画。
-
-目前只有如下ID支持以这种方式开门：
-
-``` text
-yellowDoor, blueDoor, redDoor, greenDoor, specialDoor, steelDoor,
-yellowWall, blueWall, whiteWall, lava, star
-```
-
-## 怪物
-
-本塔支持的怪物列表参见`project/enemys.js`。其与images目录下的`enemys.png`素材按顺序一一对应。
-
-如有自己的怪物素材需求请参见[自定义素材](personalization#自定义素材)的内容。
-
-怪物可以有特殊属性，每个怪物可以有多个自定义属性。
-
-怪物的特殊属性所对应的数字（special）在`libs/enemys.js`中的`getSpecialText`中定义，请勿对已有的属性进行修改。
-
-``` js
-enemys.prototype.getSpecialText = function (enemyId) {
-    if (enemyId == undefined) return "";
-    var enemy = this.enemys[enemyId];
-    var special = enemy.special;
-    var text = [];
-    if (this.hasSpecial(special, 1)) text.push("先攻");
-    if (this.hasSpecial(special, 2)) text.push("魔攻");
-    if (this.hasSpecial(special, 3)) text.push("坚固");
-    if (this.hasSpecial(special, 4)) text.push("2连击");
-    if (this.hasSpecial(special, 5)) text.push("3连击");
-    if (this.hasSpecial(special, 6)) text.push((enemy.n||4)+"连击");
-    if (this.hasSpecial(special, 7)) text.push("破甲");
-    if (this.hasSpecial(special, 8)) text.push("反击");
-    if (this.hasSpecial(special, 9)) text.push("净化");
-    if (this.hasSpecial(special, 10)) text.push("模仿");
-    if (this.hasSpecial(special, 11)) text.push("吸血");
-    if (this.hasSpecial(special, 12)) text.push("中毒");
-    if (this.hasSpecial(special, 13)) text.push("衰弱");
-    if (this.hasSpecial(special, 14)) text.push("诅咒");
-    if (this.hasSpecial(special, 15)) text.push("领域");
-    if (this.hasSpecial(special, 16)) text.push("夹击");
-    if (this.hasSpecial(special, 17)) text.push("仇恨");
-    if (this.hasSpecial(special, 18)) text.push("阻击");
-    if (this.hasSpecial(special, 19)) text.push("自爆");
-    if (this.hasSpecial(special, 20)) text.push("无敌");
-    if (this.hasSpecial(special, 21)) text.push("退化");
-    if (this.hasSpecial(special, 22)) text.push("固伤");
-    if (this.hasSpecial(special, 23)) text.push("重生");
-    return text.join("  ");
-}
-```
-
-多属性可采用数组的写法，比如`'special': [1,3]`视为同时拥有先攻和坚固属性；`'special': [5,10,14,18]`视为拥有3连击、魔防、诅咒、阻击四个属性。
-
-本塔支持战斗动画，在`data.js`中存在三个全局选项：`canOpenBattleAnimate`, `showBattleAnimateConfirm`, `battleAnimate`。
-
-- `canOpenBattleAnimate`代表是否允许用户开启战斗动画。如果你添加了一些自定义属性，且不想修改战斗界面的UI，则可以将其关闭。
-- `showBattleAnimateConfirm`代表是否在游戏开始时给用户提供开启动画的选项。对于一些偏向于萌新的塔，可以开启此项。
-- `battleAnimate`代表是否默认开启战斗动画。此项会被用户存储的设置给覆盖。
-- 如果`canOpenBattleAnimate`为false，则后面两个也强制为false。
-
-怪物可以负伤，在`data.js`的全局变量`enableNegativeDamage`中指定。
-
-下面的`getSpecialHint`函数则给定了每个特殊属性的详细描述。这个描述将在怪物手册中看到。
-
-打败怪物后可以进行加点操作。有关加点塔的制作可参见[加点事件](event#加点事件)。
-
-如果`data.js`中的enableExperience为false，即不启用经验的话，怪物手册里将不显示怪物的经验值，打败怪物也不获得任何经验。
-
-拿到幸运金币后，打怪获得的金币将翻倍。
-
-如果怪物有`"notBomb": true`，则该系列诖怪物均不可被炸。
-
-N连击怪物的special是6，且我们可以为它定义n代表实际连击数。参见样板中剑王的写法。
-
-吸血怪需要给怪物设置value，代表吸血的比例。
-
-可以给吸血怪添加`'add': true`来将吸血的数值加到自身上。
-
-中毒怪让勇士中毒后，每步扣减的生命值由`data.js`中的values定义。
-
-衰弱怪让勇士衰弱后，攻防会下降一定比例或固定数值（直到衰弱状态解除恢复）；其在`data.js`中的values定义。
-
-诅咒怪将让勇士陷入诅咒状态，诅咒状态下杀怪不获得金币和经验值。
-
-领域怪需要在怪物后添加value，代表领域伤害的数值。如果勇士生命值扣减到0，则直接死亡触发lose事件。
-
-领域是十字伤害还是九宫格伤害由`zoneSquare`设定，如设置为true则为九宫格伤害，不指定或为false则为十字伤害。
-
-领域怪还可以设置`range`选项代表该领域怪的范围，不写则默认为1。
-
-阻击怪同样需要设置value，代表领域伤害的数值。如果勇士生命值扣减到0，则直接死亡触发lose事件。
-
-!> 阻击怪后退的地点不能有任何事件存在，即使是已经被禁用的自定义事件！
-
-请注意如果吸血、领域、阻击中任何两个同时存在，则value会冲突。**因此请勿将吸血、领域或阻击放置在同一个怪物身上。**
-
-退化怪需要设置'atkValue'和'defValue'表示退化的数值；也可以不设置默认为0。
-
-固伤怪则需要设置`damage`选项，代表战前扣血数值。
-
-如有额外需求，可参见[自定义怪物属性](personalization#自定义自定义怪物属性)，里面讲了如何设置一个新的怪物属性。
-
-## 路障，楼梯，传送门
-
-血网的伤害数值、中毒后每步伤害数值、衰弱时暂时攻防下降的数值，都在 `data.js` 的values内定义。
-
-路障同样会尽量被自动寻路绕过。
-
-有关楼梯和传送门，必须在该层样板的changeFloor里指定传送点的目标。
-
-![楼层转换](./img/changefloor.png)
-
-!> **请注意这里的`"x,y"`代表该点的横坐标为x，纵坐标为y；即从左到右第x列，从上到下的第y行（从0开始计算）。如(6,0)代表最上面一行的正中间一列。**
-
-floorId指定的是目标楼层的唯一标识符（ID）。
-
-也可以写`"floorId": ":before"`和`"floorId": ":next"`表示上一楼和下一楼。
-
-后面可以写stair到upFloor或downFloor，表示将前往目标楼层的上楼梯/下楼梯位置。你也可以写loc然后指定目标点的坐标。
-
-请注意的是，如果目标楼层有多个楼梯，写stair可能会导致到达的楼梯不确定，这时候请使用loc方式来指定具体的点位置。
-
-可以指定direction为up/left/right/down，指定后勇士将面向该方向。
-
-可以指定time，指定后切换动画时长为指定的数值。
-
-**从2.1.1开始，楼层属性中提供了`upFloor`和`downFloor`两项。如果设置此项（比如`"upFloor": [2,3]`），则写stair:upFloor或者楼传器的落点将用此点来替换楼梯位置（即类似于RM中的上箭头）。**
-
-## 动画和天气系统
-
-现在我们的H5魔塔支持播放动画，也支持天气系统了。
-
-要播放动画，你需要先使用“RM动画导出器”将动画导出，放在animates目录下，然后再data.js中定义。
-
-``` js
-"animates": [// 在此存放所有可能使用的动画，必须是animate格式，在这里不写后缀名
-    // 动画必须放在animates目录下；文件名不能使用中文，不能带空格或特殊字符
-    "hand", "sword", "zone", "yongchang", "thunder" // 根据需求自行添加
-]
-```
-
-!> 动画必须是animate格式，名称不能使用中文，不能带空格或特殊字符。
-
-导出动画时可能会进行一些压缩以节省流量，因此清晰度可能不如原版。
-
-从2.3.2开始，动画可以同时导出所用的音效。**如果导出音效，请确保将所用到的音效复制到了`sounds`目录下，并且在全塔属性中注册过。**
-
-动画播放时，是按照每秒20帧的速度（即50ms/帧）。
-
-定义完毕后，我们可以调用`animate`事件来播放该动画，有关事件的详细介绍请参见[事件](event)。
-
-!> 播放录像时，将默认忽略所有动画。
-
-目前天气系统只支持雨和雪两种天气。
-
-在每层楼的剧本文件里存在一个weather选项，表示该层楼的默认天气。
-
-``` js
-// 该层的默认天气。本项可忽略表示晴天，如果写则第一项为"rain"或"snow"代表雨雪，第二项为1-10之间的数代表强度。
-"weather": ["snow",5] 
-```
-
-我们也可以使用`setWeather`事件来设置当前天气，有关事件的详细介绍请参见[事件](event)。
-
-## 背景音乐
-
-本塔支持BGM和SE的播放。
-
-要播放音乐和音效，你需要将对应的文件放在sounds目录下，然后在全塔属性中进行定义
-
-``` js
-"bgms": [ // 在此存放所有的bgm，和文件名一致。第一项为默认播放项
-    // 音频名不能使用中文，不能带空格或特殊字符；可以直接改名拼音就好
-    'bgm.mp3'
-];
-"sounds": [ // 在此存放所有的SE，和文件名一致
-    // 音频名不能使用中文，不能带空格或特殊字符；可以直接改名拼音就好
-    'floor.mp3', 'attack.mp3', 'door.mp3', 'item.mp3', 'zone.mp3'
-]
-```
-
-!> 音频名不能使用中文，不能带空格或特殊字符。
-
-目前BGM支持主流的音乐格式，如mp3, ogg, mid格式等。SE则不支持mid格式的播放。
-
-!> mid格式是通过数学方法模拟出来的音乐效果，质量可能会和实际效果差距较大。
-
-!> **警告！** mid格式在手机端播放可能会特别卡，仍推荐直接使用mp3/ogg来播放。
-
-定义完毕后，我们可以调用`playBgm`/`playSound`事件来播放对应的音乐/音效，有关事件的详细介绍请参见[事件](event)。
-
-**另外，考虑到用户的流量问题，将遵循如下规则：**
-
-- **如果用户当前使用的电脑，则默认开启音乐效果，并播放默认BGM**
-- **如果用户当前使用的手机，且处于Wifi状态，则默认开启音乐效果，并播放默认BGM**
-- **其他情况，将默认关闭音乐效果，只有在用户在菜单栏中点击“音乐开关”后才会播放音乐**
-
-!> iOS平台以及部分浏览器不支持获得当前网络状态，此时即使在使用Wifi也必须要用户点击“音乐开关”才能播放音乐。
-
-## 录像
-
-HTML5魔塔一大亮点就是存在录像系统，可以很方便进行录像回放。
-
-当你在游戏的过程中，随着你的操作，录像也会被依次记录。游戏结束后将提示是否下载录像，上传成绩时也会上传你的录像信息。
-
-在菜单栏-同步存档中，可以直接对当前录像进行下载。
-
-!> 录像记录的是你当前的路线（本质上是模拟键盘操作），是一个纯文本文件，占用空间很小！
-
-录像的回放主要有两种方式：
-
-1. 保存成的录像文件(.h5route文件)：在标题界面点录像回放，再选择文件即可。
-2. 游戏过程中时的当前录像：随时按R可以进行回放；手机端则长按任何位置3秒以上调出虚拟键盘，再按R。
-
-录像播放过程中，可以进行如下操作：
-
-- **暂停/播放：** 按空格可以随时暂停或播放录像。
-- **加速：** 按X可以加速录像播放，最高可达6倍速。
-- **减速：** 按Z可以减速录像播放，最低可达0.3倍速。
-- **停止：** 按ESC可以立刻停止录像播放，并返回正常游戏。
-- **回退：** 按A可以回退到上一个录像节点（录像播放过程中每50步存一个录像节点）。
-- **存档：** 按S可以在录像播放过程中进行存档。
-- **查看手册：** 按C可以在录像播放过程中查看怪物手册。
-
-上述操作在手机端均有工具栏的对应按钮可点击操作。
-
-如果录像出现问题，请加群539113091找小艾反馈Bug。
-
-## 操作说明
-
-本塔主要支持鼠标（触摸屏）操作和键盘操作。
-
-鼠标（触摸屏）操作说明如下：
-
-- **点状态栏中图标：** 进行对应的操作
-- **点任意块：** 寻路并移动
-- **点任意块并拖动：** 指定寻路路线
-- **单击勇士：** 转向
-- **双击勇士：** 轻按（仅在轻按开关打开时有效）
-- **长按任意位置：** 打开虚拟键盘
-
-键盘操作快捷键如下：
-
-- **[CTRL]** 跳过对话
-- **[Z]** 转向
-- **[X]** 打开/关闭怪物手册
-- **[G]** 打开/关闭楼层传送器
-- **[A]** 读取自动存档
-- **[S/D]** 打开/关闭存/读档页面
-- **[K]** 打开/关闭快捷商店选择列表
-- **[T]** 打开/关闭工具栏
-- **[ESC]** 打开/关闭系统菜单
-- **[H]** 打开帮助页面
-- **[R]** 回放录像
-- **[SPACE]** 轻按（仅在轻按开关打开时有效）
-- **[1]** 快捷使用破墙镐
-- **[2]** 快捷使用炸弹/圣锤
-- **[3]** 快捷使用中心对称飞行器
-
-以上快捷键也能在游戏菜单中的操作说明中看到。
-
-&nbsp;
-
-&nbsp;
-
-上面就是整个样板中的各个元件说明。通过这种方式，你就已经可以做出一部没有任何事件的塔了。
-
-尝试着做一个两到三层的塔吧！
-
-==========================================================================================
-
-[继续阅读下一章：事件](event)
diff --git a/docs/img/plugin.png b/docs/img/plugin.png
deleted file mode 100644
index 4e87fa84..00000000
Binary files a/docs/img/plugin.png and /dev/null differ
diff --git a/docs/index.html b/docs/index.html
index cb5df153..a1ea8b98 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,58 +1 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <title>HTML5魔塔样板</title>
-  <link rel="shortcut icon" type="image/png" href="./img/logo.png">
-  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
-  <meta name="description" content="Description">
-  <meta http-equiv="pragma" content="no-cache">
-  <meta http-equiv="cache-control" content="no-cache">
-  <meta http-equiv="expires" content="0">
-  <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
-  <link href="https://cdn.bootcss.com/docsify/4.5.5/themes/vue.css" rel="stylesheet">
-</head>
-<body>
-  <div id="app"></div>
-  <script>
-    window.$docsify = {
-      homepage: 'index.md',
-      loadSidebar: true,
-      name: 'HTML5魔塔样板',
-      repo: 'https://github.com/ckcz123/mota-js',
-      // basepath: '../docs/',
-      
-        // Search Support
-      // search: {
-      //   maxAge: 43200000, // 过期时间，单位毫秒，默认一天
-      //   paths: 'auto',
-      //   placeholder: {
-      //     '/en/': 'Search',
-      //     '/': '搜索',
-      //   },
-      //   noData: {
-      //     '/en/': 'No Results',
-      //     '/': '找不到结果',
-      //   },
-      // },
-
-       // load sidebar from _sidebar.md
-      loadSidebar: '_sidebar.md',
-      subMaxLevel: 2,
-      autoHeader: true,
-      auto2top: true,
-      mergeNavbar: true,
-      formatUpdated: '{YYYY}-{MM}-{DD} {HH}:{mm}:{ss}',
-    }
-    if (navigator.serviceWorker) {
-        navigator.serviceWorker.getRegistrations()
-            .then(function(registrations) {
-                for(let registration of registrations) {
-                    registration.unregister();
-                }
-            });
-    }
-  </script>
-  <script src="https://cdn.bootcss.com/docsify/4.5.5/docsify.min.js"></script>
-</body>
-</html>
+<html><body><script>window.location="https://h5mota.com/games/template/_docs/"</script></body></html>
\ No newline at end of file
diff --git a/docs/personalization.md b/docs/personalization.md
deleted file mode 100644
index 0c2a6075..00000000
--- a/docs/personalization.md
+++ /dev/null
@@ -1,794 +0,0 @@
-# 个性化
-
-?> 目前版本**v2.3.3**，上次更新时间：* {docsify-updated} *
-
-有时候只靠样板本身可能是不够的。我们需要一些个性化、自定义的素材，道具效果，怪物属性，等等。
-
-## 图层的说明
-
-HTML5魔塔是使用画布（canvas）来绘制，存在若干个图层，它们之间有一个覆盖关系，后面的图层将覆盖前面的图层。
-
-所有图层从低往高依次如下：
-
-- bg：背景层；绘制地面素材，或者作为背景的图片素材
-- event：事件层；所有事件（道具、墙壁、NPC、怪物等）都绘制在这一层进行处理
-- hero：勇士层；主要用来绘制勇士
-- event2：事件2层；本层主要用来绘制48x32的图片素材的上半部分（避免和勇士错位），也可以用来绘制该层的前景图片素材
-- fg：显伤层；主要用来绘制怪物显伤和领域显伤
-- animate：动画层；主要用来绘制动画，图块的淡入/淡出效果，图块的移动。showImage事件绘制的图片也是在这一层。
-- weather：天气层；主要用来绘制天气（雨/雪）
-- curtain：色调层；用来控制当前楼层的画面色调
-- route：路线层；主要用来绘制勇士的行走路线图
-- ui：UI层；用来绘制一切UI窗口，如剧情文本、怪物手册、楼传器、系统菜单等等
-- data：数据层；用来绘制一些顶层的或更新比较快的数据，如左上角的提示，战斗界面中数据的变化等等。
-
-## 自定义素材
-
-所有素材的图片都在`images`目录下。
-- `animates.png` 为所有动画效果。主要是星空熔岩，开门，毒网，传送门之类的效果。为四帧。
-- `autotile.png` 为Autotile块。
-- `enemys.png` 为所有怪物的图片。
-- `enemy48.png` 为所有48x32怪物的图片。
-- `heros.png` 为勇士行走图。
-- `items.png` 为所有道具的图标。
-- `npcs.png` 为所有NPC的图标。
-- `npc48.png` 为所有48x32的NPC图标。
-- `terrains.png` 为所有地形的图标。
-
-系统会读取`icon.js`文件，并获取每个ID对应的图标所在的位置。
-
-### 使用预定义的素材
-
-在images目录的“默认素材”下给定了若干预定义的自定义素材。
-
-如果你需要某个素材已经存在，则可以直接将其覆盖images目录下的同名文件，就能看到效果。
-
-### 使用自己的图片作为某层楼的背景/前景素材
-
-由于HTML5功能（素材）有限，导致了对很多比较复杂的素材（比如房子内）等无法有着较好的绘图方式。
-
-为了解决这个问题，我们允许用户自己放置一张或多张图片作为某一层的背景素材。
-
-要启用这个功能，我们首先需要在`data.js`中将可能的图片进行加载。
-
-``` js
-"images": [ // 在此存放所有可能使用的图片
-    // 图片可以被作为背景图（的一部分），也可以直接用自定义事件进行显示。
-    // 图片名不能使用中文，不能带空格或特殊字符；可以直接改名拼音就好
-    // 建议对于较大的图片，在网上使用在线的“图片压缩工具(http://compresspng.com/zh/)”来进行压缩，以节省流量
-    "bg.jpg", "house.png", "bed.png"// 依次向后添加
-];
-```
-
-!> 请使用网上的一些[在线图片压缩工具](http://compresspng.com/zh/)对图片进行压缩，以节省流量。
-
-之后，我们可以在每层剧本的`"images"`里来定义该层的默认背景图片素材。
-
-``` js
-"images": [[3,5,"bg.jpg",0]], // 背景图；你可以选择一张或多张图片来作为背景/前景素材。
-"images": [], // 无任何背景图
-"images": [[1,1,"house.png",0], [6,7,"bed.png",1]] // 在(1,1)放一个house.png在背景层，且(6,7)放bed.png在前景层
-"images": [[3,5,"tree.png",2]] // 如果写2，则会自动调节遮挡效果
-```
-
-images为一个数组，代表当前层所有作为背景素材的图片信息。
-
-每一项为一个四元组，分别为该背景素材的x，y，图片名和遮挡方式。其中x和y分别为横纵坐标，在0-12之间；图片名则必须在上面的images中定义过。
-
-第四项为遮挡方式，定义如下：
-
-- 0：该图片将全部画在背景层，被勇士所遮挡。举例：某些特殊地形等。
-- 1：该图片将全部画在前景层，可以遮挡勇士。举例：云彩等效果。
-- 2：该图片将上部分画在前景层，下部分画在背景层。从而可以达到一个“自动调节遮挡的效果”。举例：树、房子等等。
-
-!> 如果写2的话，请确保图片高度是32的倍数！
-
-**如果你需要让某些点不可通行（比如你建了个房子，墙壁和家具等位置不让通行），则需在`events`中指定`{"noPass": false}`，参见[自定义事件](event#自定义事件)的写法。**
-
-``` js
-"events": {
-    "x,y": {"noPass": true} // (x,y)点不可通行
-}
-```
-
-### 使用便捷PS工具生成素材
-
-如果我们有更多的素材要求，我们可以使用“便捷PS工具”进行处理。
-
-![便捷PS工具](img/ps.png)
-
-我们可以打开有需求改变的素材，和我们需要被替换的素材，然后简单的Ctrl+C和Ctrl+V操作即可。
-
-便捷PS工具同样支持图片色相的修改，和RMXP几乎完全相同。
-
-用这种方式，我们能极快地替换或素材，包括需要新增的怪物。
-
-### 添加素材到游戏
-
-在使用地图编辑器编辑的过程中，我们有可能会出现“该数字和ID未被定义”的错误提示。
-
-这是因为，该素材没有被定义，无法被游戏所识别。
-
-!> 在V2.0中，我们可以简单的在地图编辑器中新增素材，以及定义新增素材的ID和数字，但是仍然**强烈建议**对素材的机制进行了解。
-
-#### 素材的机制
-
-本塔所有的素材都拥有三个属性：**ID**，**索引**，**数字**。
-- **ID** 为该素材的唯一标识符，任何两个素材的ID都不能相同。
-- **索引** 为该素材的在对应图片上的图标索引，即该素材是图片上的第几个。
-- **数字** 为该素材的对应数字，以方便地图的生成和存储。
-
-**`ID-索引` 对应关系定义在icons.js文件中。该文件将唯一确定一个ID在图片上所在的位置。**
-
-**`ID-数字` 对应关系定义在maps.js文件中。该文件将唯一确定一个ID对应的数字是多少。**
-
-在V2.0中，我们可以在地图编辑器中很方便查看每个图块的三个属性信息。
-
-#### 注册素材
-
-在V2.0的地图编辑器中，要注册新素材，我们只需要在图块属性一栏输入新素材的ID和数字。
-
-![素材注册](./img/register.png)
-
-ID必须由数字字母下划线组成，数字在1000以内，且均不能和已有的进行重复。
-
-之后刷新编辑器即可。
-
-对于怪物和道具，我们也可以进行自动注册，只需要点击“自动注册”按钮，将对该栏下所有未注册的素材进行自动注册（自动分配ID和数字）。
-
-素材注册完毕后，即可在游戏中正常使用，也可以被地图生成器所识别（需要重开地图生成器）。
-
-#### Autotile的注册
-
-但是，通过上面这种方式，我们是没办法新增并注册Autotile的。
-
-除了替换样板现有的几个外，如果我们还需要新添加Autotile，则：
-
-1. 将新的Autotile图片复制到images目录下。文件名必须是字母数字和下划线组成。
-2. 进入icons.js，在autotile分类下进行添加该文件的名称，索引简单的写0。
-3. 指定一个数字，在maps.js中类似进行添加。
-
-!> Autotile的ID和文件名应确保完全相同！
-
-<!--
-#### 新添加自定义地形（路面、墙壁等）
-
-如果你在terrains.png中新增了一行：
-
-1. 指定一个唯一的英文ID，不能和现有的重复。
-2. 进入icons.js，在terrains分类下进行添加索引（对应图标在图片上的位置，即index）
-
-**如果你无须在游戏内使用本地形，而仅仅是将其作为“背景图”使用，则操作如下：**
-3. 修改对应楼层的剧本文件的`defaultGround`项，改成新的ID。
-
-**如果你要在游戏内使用本地形，则操作如下：**
-3. 指定一个数字，在maps.js中类似进行添加。
-
-#### 新添加Autotile
-
-如果你需要新增一个Autotile：
-
-1. 将新的Autotile图片复制到images目录下。
-2. 进入icons.js，在autotile分类下进行添加该文件的名称，索引简单的写0。
-3. 指定一个数字，在maps.js中类似进行添加。
-
-!> Autotile的ID和文件名完全相同！且其ID/文件名不能含有中文、空格或特殊字符。
-
-!> V2.0版本不能在地图编辑器中添加Autotile，请按上面的操作来执行。
-
-#### 新添加道具
-
-如果你需要新增一个未被定义的道具：
-
-1. 指定一个唯一的英文ID，不能和现有的重复。
-2. 进入icons.js，在items分类下进行添加索引（对应图标在图片上的位置，即index）
-3. 指定一个数字，在maps.js中类似进行添加。
-4. 在items.js中仿照其他道具，来添加道具的信息。
-
-有关如何自行实现一个道具的效果，参见[自定义道具效果](#自定义道具效果)。
-
-#### 新添加怪物
-
-如果我们需要新添加怪物，请在enemys.png中新增一行。
-
-你可以通过便捷PS工具的“更改色相”来将红头怪变成橙头怪等。
-
-然后执行如下操作：
-
-1. 指定一个唯一的英文ID，不能和enemys中现有的重复。
-2. 进入icons.js，在enemys分类下进行添加索引（对应图标在图片上的位置，即index）
-3. 在maps.js中继续进行添加。
-4. 在enemys.js中仿照其他怪物，来添加怪物的信息。
-
-!> 如果是48x32的怪物素材，请放在enemy48.png中，然后在icons.js的enemy48下添加索引。
-
-有关如何自行实现一个怪物的特殊属性或伤害计算公式，参见[怪物的特殊属性](#怪物的特殊属性)。
-
-#### 新添加NPC
-
-1. 指定一个唯一的英文ID，不能和现有的重复。
-2. 进入icons.js，在npcs分类下进行添加索引（对应图标在图片上的位置，即index）
-3. 指定一个数字，在maps.js的getBlock下类似进行添加。
-
-!> 如果是48x32的怪物素材，请放在npc48.png中，然后在icons.js的npc48下添加索引。
-
--->
-
-### 地图生成器使用自定义素材
-
-地图生成器是直接从js文件中读取数字-图标对应关系的。
-
-因此，在你修改了icons.js和maps.js两个文件，也就是将素材添加到游戏后，地图生成器的对应关系也将同步更新。
-
-## 自定义道具效果
-
-本节中将继续介绍如何自己编辑一个道具的效果。
-
-道具效果的具体实现都在`items.js`中。
-
-### 即捡即用类道具（cls: items）
-
-对于即捡即用类道具，如宝石、血瓶、剑盾等，我们可以简单地修改`data.js`中的value一栏即可。
-
-如果你想要同种宝石在不同层效果不同的话，可以进行如下操作：
-
-1. 在楼层的item_ratio中定义宝石的比率（比如1-10的写1，11-20层写2等）
-2. 修改获得道具的itemEffect函数（编辑器中双击进行编辑）
-
-``` js
-// ratio为楼层的item_ratio值，可以进行翻倍宝石属性
-core.status.hero.atk += core.values.redJewel * ratio
-```
-
-这里我们可以直接写ratio来取用该楼层中定义的`item_ratio`的值。
-
-如果不是倍数增加（比如线性增加）也可以类似来写
-
-``` js
-// 一个二倍线性增加的例子
-core.status.hero.atk += core.values.redJewel + 2*ratio
-```
-
-### 消耗类道具（cls: tools）；永久类道具（cls: constants）
-
-如果要自己实现消耗类道具或永久类道具的使用效果，则需修改`items.js`中的canUseItem和useItem两个函数。
-
-具体过程比较复杂，需要一定的JS能力，在这里就不多说了，有需求可以找`艾之葵`进行了解。
-
-但值得一提的是，我们可以使用`core.hasItem(name)` 来判断是否某个道具是否存在。例如下面是passNet（通过路障处理）的一部分：
-
-``` js
-/****** 经过路障 ******/
-events.prototype.passNet = function (data) {
-    // 有鞋子
-    if (core.hasItem('shoes')) return;
-    if (data.event.id=='lavaNet') { // 血网
-// ... 下略
-```
-
-我们进行了一个简单的判断，如果拥有绿鞋，则不进行任何路障的处理。
-
-### 实战！拿到神圣盾后免疫吸血、领域、夹击效果
-
-1. 在itemEffect中修改拿到神圣盾时的效果，标记一个自定义Flag。
-``` js
-core.status.hero.def += core.values.shield5 * ratio;
-core.setFlag("shield5", true); // 增加一个自定义Flag：已经拿到神圣盾
-```
-2. 免疫吸血效果：在`enemys.js`的伤害计算中，编辑成如果存在神圣盾标记，吸血伤害为0。
-``` js
-enemys.prototype.calDamage = function (monster, hero_hp, hero_atk, hero_def, hero_mdef) {
-// ... 上略
-    // 吸血
-    if (this.hasSpecial(mon_special, 11)) {
-        var vampireDamage = hero_hp * monster.value;
-
-        // 如果有神圣盾免疫吸血等可以在这里写
-        if (core.hasFlag("shield5")) vampireDamage = 0; // 存在神圣盾，吸血伤害为0
-
-        vampireDamage = Math.floor(vampireDamage) || 0;
-        // 加到自身
-        if (monster.add) // 如果加到自身
-            mon_hp += vampireDamage;
-
-        initDamage += vampireDamage;
-    }
-// ... 下略
-```
-3. 免疫领域、夹击、阻击效果：在`control.js`中，找到checkBlock函数，并编辑成如果有神圣盾标记，则将伤害变成0。
-``` js
-// 检查领域、夹击、阻击事件
-control.prototype.checkBlock = function () {
-    var x=core.getHeroLoc('x'), y=core.getHeroLoc('y');
-    var damage = core.status.checkBlock.damage[x+core.bigmap.width*y];
-    if (damage>0) {
-        if (core.hasFlag("shield5")) damage = 0; // 如果存在神圣盾，则将伤害变成0
-        core.status.hero.hp -= damage;
-
-        // 检查阻击事件
-        var snipe = [];
-        var scan = {
-            'up': {'x': 0, 'y': -1},
-            'left': {'x': -1, 'y': 0},
-            'down': {'x': 0, 'y': 1},
-            'right': {'x': 1, 'y': 0}
-        }
-// ... 下略
-```
-4. 如果有更高的需求，例如想让吸血效果变成一半，则还是在上面这些地方进行对应的修改即可。
-
-## 新增门和对应的钥匙
-
-如果要新增一个门和对应的钥匙，需要进行如下几步：
-
-1. 在terrains.png中添加新的门的素材，并在地图编辑器中注册门的ID。该ID必须是以`Door`结尾，例如`abcDoor`。
-2. 在animates.png中添加开门的四格动画，然后直接打开icons.js文件，在animates下直接添加ID和索引信息，例如`'abcDoor': 34`。
-3. 在items.png中添加钥匙的素材，并在地图编辑器中注册钥匙的ID。该ID必须是和门对应且以`Key`结尾，例如`abcKey`。
-4. 该道具的cls应为`tools`，可以自行写道具描述，最下面几项均留`null`即可。
-
-!> **请勿在animates中对门的动画素材进行注册！而是请直接打开icons.js文件并添加ID和索引信息！！！**
-
-!> terrains和animates的门ID必须完全一致，且以`Door`结尾；所对应的钥匙ID应当是把`Door`换成`Key`，这样才能对应的上！
-
-## 覆盖楼传事件
-
-对于特殊的塔，我们可以考虑修改楼传事件来完成一些特殊的要求，比如镜子可以按楼传来切换表里。
-
-要修改楼传事件，需要进行如下几步：
-
-1. 截获楼传的点击事件。在control.js中找到useFly函数，并将其替换成如下内容：
-``` js
-////// 点击楼层传送器时的打开操作 //////
-control.prototype.useFly = function (need) {
-    if (!core.status.heroStop) {
-        core.drawTip("请先停止勇士行动");
-        return;
-    }
-    if (core.canUseItem('fly')) core.useItem('fly');
-    else core.drawTip("当前无法使用"+core.material.items.fly.name);
-}
-```
-2. 让录像记下楼传的使用。在items.js的useItem函数中找到记录路线的那几行，修改为：
-``` js
-    // 记录路线
-    if (itemId!='book') {  // 把 `&& itemId!='fly'` 给删除
-        core.status.route.push("item:"+itemId);
-    }
-```
-3. 修改楼传的使用事件。和其他永久道具一样，在地图编辑器的图块属性中修改楼传的useItemEffect和canUseItemEffect两个内容。例如：
-``` js
-"useItemEffect": "core.insertAction([...])" // 执行某段自定义事件，或者其他脚本
-"canUseItemEffect": "true" // 任何时候可用
-```
-修改时，请先把`null`改成空字符串`""`，然后再双击进行编辑。
-
-
-## 自定义装备
-
-由于HTML5魔塔并不像RM那样存在一个装备界面可供我们对装备进行调整，但是我们也可以使用一个替代的方式实现这个目标。
-
-### 装备的实现原理
-
-在HTML5中，装备将全部看成是永久道具（constants），同时对于每个装备位置，勇士都定义一个flag域表示正在装备的内容。
-
-例如：当勇士获得银剑时，将获得一个永久道具“银剑”；当使用这个银剑，首先检查勇士当前是否装备了武器（比如铁剑），如果
-装备了则先脱掉装备（减去已装备的铁剑所加的属性，并获得永久道具铁剑），然后再穿上新的银剑。
-
-同时由于脱剑术和脱盾术的存在，我们还需要一个“脱掉装备”的永久道具（比如sword0），使用它可以脱掉对应位置的装备。
-
-### 装备加值的修改
-
-要启用装备，首先需要在data.js（全塔属性）中设置`'equipment': true`。此时，游戏内将自动将剑盾变成装备的存在，其
-所加的数值就是全塔属性中对应的数值（比如铁剑sword1就加的全塔属性中sword1的值）。
-
-有时候，我们还会有一个装备加多种属性的需求，此时需要将对应的项从数值改变成一个对象。
-
-``` js
-"sword1": {"atk": 10, "def": 0, "mdef": 5}, // 铁剑加10攻和5魔防
-"shield1": {"atk": 0, "def": 10, "mdef": 10}, // 铁盾加10防和10魔防
-```
-
-通过这种方式，当穿上装备时，将会给你的三围分别加上对应项的数值（支持负数，比如装剑减防御）。
-
-### 新增剑盾
-
-样板默认提供了铁剑（盾），银剑（盾），骑士剑（盾），圣剑（盾）和神圣剑（盾）这五类装备。但有时候，五类是不够的，
-我们可能还需要更多的剑盾。
-
-要增加更多的剑盾，我们需要进行如下步骤：（以新增剑为例）
-
-1. 新注册一个素材到游戏；**其ID必须是sword+数字的形式，比如sword6等。**（同理如果是盾就必须是shield+数字的形式比如shield6。）
-2. 将其cls设置为`constants`，`useItemEffect`和`canUseItem`直接复制其他几个剑盾的内容。  
-（即：`useItemEffect`必须为`"core.plugin.useEquipment(itemId)"`，`canUseItemEffect`必须为`"true"`）。
-3. 使用VSCode或其他文本编辑器直接打开`data.js`文件，并在`"values"`中仿照已有的内容添加剑盾的属性。  
-（例如：`"sword6": 100`，或者`"sword6": `{"atk": 100, "def": 0, "mdef": 50}`）
-
-!> 请注意：新的剑的ID必须是sword+数字，新的盾的ID必须是shield+数字的形式，不然装备将无效！
-
-### 新增其他部位的装备
-
-如果我们还需要新增更多部位的装备，比如戒指、首饰等等，也是可以的，只需要依次进行如下步骤：（以新建戒指为例）
-
-1. 选择一个装备的部位的ID；比如假设我们的装备部位为戒指，那么我们可以选择"ring"作为装备的部位。
-2. 定义一个空戒指，相当于脱掉戒指。注册一个素材到游戏，**其ID必须是ring0**（即部位ID+数字0）。
-3. 同上述新建剑盾的方式来设置ring0这个空戒指的属性。请注意打开data.js后，设置的其值必须为0。  
-(即：必须是`"ring0": 0`)
-3. 创建更多的戒指；每加一个新的戒指到游戏，其ID必须是**ring+数字**的形式，比如`ring1`, `ring2`，等等。
-4. 对于每一个创建的戒指，按照上述新建剑盾的方式设置属性（图块属性，打开data.js直接编辑）。  
-（例如：`"ring2": {"atk": 3, "def": 5, "mdef": 8}`）
-5. **切换到脚本编辑 - 自定义插件编写，在`this.useEquipment`中仿照着新增一行代表戒指的使用。**
-
-``` js
-this.useEquipment = function (itemId) { // 使用装备
-	_useEquipment(itemId, "sword", "atk"); // 剑
-	_useEquipment(itemId, "shield", "def"); // 盾
-	_useEquipment(itemId, "ring", "mdef"); // 新增的戒指
-}
-```
-
-我们仿照着新增一行`_useEquipment(itemId, "ring", "mdef")`。
-
-其中第二项为装备部位的ID，比如我们上述定义的是ring；第三项表示“如果values中该值为数字，则加到什么属性上”。
-比如如果我们这里写mdef，那么我们假设在data.js的values中设置`"ring1": 20`，则使用该戒指会增加20点魔防。
-
-如果你定义的是对象`{"atk": xxx, "def": xxx, "mdef": xxx}`的形式，则不会受到第三项的影响。
-
-!> 必须对于每一个装备部位定义唯一一个不同的ID；脱掉装备（空装备）必须是该ID加数字0的形式，其他有效装备必须是
-该ID+正整数的形式，不然会出错！
-
-## 自定义怪物属性
-
-如果你对现有的怪物不满意，想自行添加怪物属性（例如让怪物拥有双属性乃至更多属性），也是可以的。具体参见`enemys.js`文件。
-
-你需自己指定一个special数字，修改getSpecialText函数（属性名）和getSpecialHint函数（属性提示文字）。
-
-如果要修改伤害计算公式，请修改下面的getDamageInfo函数。请注意，如果无法战斗，该函数必须返回`null`。
-
-对于毒衰弱怪物的战斗后结算在`functions.js`中的afterBattle函数中。
-
-对于领域、夹击、阻击怪物的检查在`control.js`中的checkBlock函数中。
-
-`getCritical`, `getCriticalDamage`和`getDefDamage`三个函数依次计算的是该怪物的临界值、临界减伤和1防减伤。也可以适当进行修改。
-
-## 自定义快捷键
-
-如果需要绑定某个快捷键为处理一段事件，也是可行的。
-
-要修改按键，我们可以在`actions.js`的`keyUp`进行处理：
-
-比如，我们设置一个快捷键进行绑定，比如`W`，其keycode是87。（有关每个键的keycode搜一下就能得到）
-
-然后在`actions.js`的`keyUp`函数的`switch`中进行处理。
-
-``` js
-case 87: // W
-    if (core.status.heroStop) { 
-        // ... 在这里写你要执行脚本
-        // 请使用同步脚本，请勿执行任何异步代码，否则可能导致游戏过程或录像出现问题。
-        core.insertAction([...]) // 例如，插入一段自定义事件并执行。
-        
-        core.status.route.push("key:"+keyCode); // 录像的支持！这句话必须要加，不然录像回放会出错！
-    }
-    break;
-```
-
-
-在勇士处于停止的条件下，按下W键时，将执行你写的脚本代码。请只使用同步脚本而不要使用异步代码，不然可能导致游戏出现问题。
-
-`core.status.route.push("key:"+keyCode);` 这句话是对录像的支持，一定要加（这样录像播放时也会模拟该按键）。
-
-!> H5不支持组合快捷键，所以不存在`W+1`这种组合快捷键的说法！
-
-!> 手机端可以通过长按任何位置调出虚拟键盘，再进行按键，和键盘按键是等价的效果！
-
-## 公共事件
-
-在RM中，存在公共事件的说法；也就是通过某个指令来调用一系列事件的触发。
-
-在H5中，我们可以使用“插件”的形式来达成这个效果。具体参见“脚本编辑 - 插件编写”。
-
-![插件编写](./img/plugin.png)
-
-当我们在这上面定义了自己需要的函数（插件后），就可以通过任何方式进行调用。
-
-在这个插件编写的过程中，我们可以使用任何[常见API](api)里面的代码调用；也可以通过`core.insertAction`来插入自定义事件执行。
-
-下面是一个很简单的例子，我编写一个公共事件（插件），其效果是让勇士生命值变成原来的x倍，并令面前的图块消失。
-
-``` js
-this.myfunc = function(x) {
-    core.status.hero.hp *= x; // 勇士生命翻若干倍
-    core.insertAction([ // 自定义事件：令面前的图块消失。
-        {"type": "setValue", "name": "flag:x", "value": "core.nextX()"},
-        {"type": "setValue", "name": "flag:y", "value": "core.nextY()"},
-        {"type": "hide", "loc": ["flag:x", "flag:y"]}
-    ]);
-}
-```
-
-然后比如我们在某个道具的使用效果 `useItemEffect` 中写 `core.plugin.myfunc(2)` 即可调用此公共事件（插件）。也可以在战后事件或自定义脚本等位置来写。
-
-通过这种，将脚本和自定义事件混用的方式，可以达到和RM中公共事件类似的效果，即一个调用触发一系列事件。
-
-## 自定义状态栏（新增显示项）
-
-在V2.2以后，我们可以自定义状态栏背景图（全塔属性 - statusLeftBackground）等等。
-
-但是，如果我们还想新增其他项目的显示，比如技能塔所需要的魔力值（气息），该怎么办？
-
-需要进行如下几个操作：
-
-1. 定义图标ID；比如魔力我就定义mana，气息可以简单的定义qixi；你也可以定义其他的ID，但是不能和已有的重复。这里以mana为例。
-2. 在index.html的statusBar中（44行起），进行该状态栏项的定义。仿照其他几项，插在其应当显示的位置，注意替换掉相应的ID。
-``` html
-<div class="status" id="manaCol">
-    <img id="img-mana">
-    <p class='statusLabel' id='mana'></p>
-</div>
-```
-3. 在editor.html中的statusBar（305行起），仿照第二点同样添加；这一项如果不进行则会地图编辑器报错。
-4. 使用便捷PS工具，打开icons.png，新增一行并将魔力的图标P上去；记下其索引比如23（减速播放图标的下方）。
-5. 在main.js的this.statusBar中增加图片、图标和内容的定义。
-``` js
-this.statusBar = {
-    'images': {
-        // ...其他略
-        'mana': document.getElementById("img-mana"), // 图片的定义
-    },
-    'icons': {
-        // ...其他略
-        'mana': 23, // 图标的定义，这里对应的是icons.png中的索引
-    },
-    // ...其他略
-    'mana': document.getElementById('mana'), // 显示内容（数据）的定义
-}
-```
-6. 显示内容的设置。在control.js的updateStatusBar函数，可以对该状态栏显示内容进行设置，下面是几个例子。
-``` js
-core.statusBar.mana.innerHTML = core.getFlag('mana', 0); // 设置其显示内容为flag:mana值。
-core.statusBar.mana.innerHTML = core.getFlag('mana', 0) + '/' + core.getFlag('manaMax', 0); // 显示内容将类似 "32/60" 这样。
-core.statusBar.mana.style.fontStyle = 'normal'; // 这一行会取消斜体。如果是汉字（比如技能名）的话，斜体起来会非常难看，可以通过这一句取消。
-```
-7. 在control.js的clearStatusBar函数，`statusList`里面也要增加mana项，这样清空状态栏时也会对其清空。
-
-## 技能塔的支持
-
-其实，在HTML5上制作技能塔是完全可行的。
-
-要支持技能塔，可能需要如下几个方面：
-
-- 魔力（和上限）的定义添加
-- 状态栏的显示
-- 技能的触发（按键与录像问题）
-- 技能的效果
-
-下面依次进行描述。
-
-### 魔力的定义添加
-
-当我们定义了魔力的ID，比如`mana`后，要使用它，一般有两种方式：属性获取`status:mana`或者flag标记`flag:mana`。
-
-如果要属性获取，则需要打开`data.js`文件，并在`hero`中添加定义。
-
-通过这种方式定义的，可以通过`core.setStatus('mana', 0)`以及`core.getStatus('mana')`来设置或获取。
-
-``` js
-'hero': {
-    // ... 上略
-    'mana': 0, // 增添mana定义，可以放在experience之后。同理可定义manaMax表示当前最大魔力值。
-}
-```
-
-如果要flag标记，则无需额外在任何地方进行定义。只需要在设置或取用的时候使用 `core.setFlag('mana', 0)` 或 `core.getFlag('mana', 0)` 即可。
-
-下面我都使用属性获取的方式来进行说明。
-
-### 状态栏的显示
-
-首先我们需要额外新增一个状态栏；请参见[自定义状态栏（新增显示项）](#自定义状态栏（新增显示项）)。
-
-我们可以在魔力那一行显示当前值和最大值：
-
-``` js
-core.setStatus('mana', Math.min(core.getStatus('mana'), core.getStatus('manaMax'))); // 如果魔力存在上限，则不能超过其上限值
-core.statusBar.mana.innerHTML = core.getStatus('mana') + '/' + core.getStatus('manaMax', 0); // 显示比如 6/30 这样
-```
-
-如果我们还需要显示当前使用的技能名，也是可以的；定义一个ID为skill，然后按照上面的做法新增一行。
-
-请注意，如果是中文字符，需要取消斜体（不然会非常难看的）！
-
-``` js
-core.statusBar.skill.style.fontStyle = 'normal'; // 取消斜体显示
-core.statusBar.skill.innerHTML = core.getFlag('skillName', '无'); // 使用flag:skillName表示当前激活的技能名。
-```
-
-### 技能的触发
-
-我们可以按键触发技能。有关绑定按键请参见[自定义快捷键](#自定义快捷键)。
-
-下面是一个很简单的例子，当勇士按下W后，如果魔力不小于5点则允许开启技能"二倍斩"，再次按W则关闭技能。
-
-``` js
-case 87: // W
-    if (core.status.heroStop) { // 当前停止状态；这个if需要加，不能在行走过程中触发不然容易出错。
-        if (core.getFlag('skill', 0)==0) { // 判断当前是否已经开了技能
-            if (core.getStatus('mana')>=5) { // 这里要写当前能否开技能的条件判断，比如魔力值至少要多少
-                core.setFlag('skill', 1); // 开技能1
-                core.setFlag('skillName', '二倍斩'); // 设置技能名
-            }
-            else {
-                core.drawTip("魔力不足，无法开技能");
-            }
-        }
-        else { // 关闭技能
-            core.setFlag('skill', 0); // 关闭技能状态
-            core.setFlag('skillName', '无');
-        }
-        core.updateStatusBar(); // 立刻更新状态栏和地图显伤
-        core.status.route.push("key:"+keyCode); // 录像的支持！这句话必须要加，不然录像回放会出错！
-    }
-    break;
-```
-
-简单的说，用flag:skill判断当前开启的技能，flag:skillName表示该技能名。（可在状态栏显示）
-
-在勇士处于停止的条件下，按下W键时，判断当前是否开启了技能，如果开启则关闭，没开则再判断是否允许开启（魔力值够不够等）。
-
-`core.status.route.push("key:"+keyCode);` 这句话是对录像的支持，一定要加（这样录像播放时也会模拟该按键）。
-
-!> 1，2，3这三个键被默认绑定到了破炸飞；如果想用的话也是一样，只不过是把已有的实现进行替换。
-
-!> 手机端可以通过长按任何位置调出虚拟键盘，再进行按键，和键盘按键是等价的效果！
-
-### 技能的效果
-
-最后一点就是技能的效果；其实到了这里就和RM差不多了。
-
-技能的效果要分的话有地图类技能，战斗效果类技能，后续影响类技能什么的，这里只介绍最简单的战斗效果类技能。
-其他的几类技能根据需求可能更为麻烦，有兴趣可自行进行研究。
-
-战斗效果内技能要改两个地方：战斗伤害计算，战后扣除魔力值。
-
-战斗伤害计算在`enenmys.js`的`getDamageInfo`函数，有需求直接修改这个函数即可。
-
-战后扣除魔力值则在脚本编辑的`afterBattle`中进行编辑即可。
-
-举个例子，我设置一个勇士的技能：二倍斩，开启技能消耗5点魔力，下一场战斗攻击力翻倍。
-
-那么，直接在`getDamageInfo`中进行判断：
-
-``` js
-if (core.getFlag('skill', 0)==1) { // 开启了技能1
-    hero_atk *= 2; // 计算时攻击力翻倍
-}
-```
-
-然后在脚本编辑的战后事件中进行魔力值的扣除：
-
-``` js
-if (core.getFlag('skill', 0)==1) { // 开启了技能1
-    core.status.hero.mana -= 5; // 扣除5点魔力值
-    core.setFlag('skill', 0); // 自动关闭技能
-    core.setFlag('skillName', '无');
-}
-```
-
-&nbsp;
-
-通过上述这几种方式，我们就能成功的让H5支持技能啦！
-
-## 多角色的支持
-
-其实，我们的样板还能支持多角色的制作。比如《黑·白·间》之类的塔也是完全可以刻的。
-
-你只需要如下几步来达到多角色的效果。
-
-1. 每个角色弄一张行走图。相关信息参见[自定义事件：setHeroIcon](event#setHeroIcon：更改角色行走图)。
-2. [覆盖楼传事件](#覆盖楼传事件)，这样可以通过点工具栏的楼层传送按钮来切换角色。当然你也完全可以自己写一个道具，或[自定义快捷键](#自定义快捷键)来进行绑定。
-3. 将下述代码直接贴入脚本编辑 - 插件编写中。（写在`var _useEquipment = ...`之前。）
-    ``` js
-    // 所有需要保存的内容；这些保存的内容不会多角色共用，在切换时会进行恢复。
-    // 你也可以自行新增或删除，比如不共用金币则可以加上"money"的初始化，不共用道具则可以加上"items"的初始化，
-    // 多角色共用hp的话则删除hp，等等。总之，不共用的属性都在这里进行定义就好。
-    var hero1 = { // 1号勇士（默认的是0号）
-        "floorId": "MT0", // 该角色楼层ID
-        "icon": "hero1.png", // 角色的行走图名称
-        "name": "1号角色",
-        "lv": 1,
-        "hp": 1000,
-        "atk": 10,
-        "def": 10,
-        "mdef": 0,
-        "loc": {"x": 0, "y": 0, "direction": "up"},
-        // 如果道具不共用就将下面这句话取消注释
-        // "items": {"keys":{"yellowKey":0,"blueKey":0,"redKey":0},"tools":{},"constants":{}}
-    }
-    // 也可以类似新增其他勇士
-    // var hero2 = { ...
-
-    var heroCount = 2; // 包含默认的在内总共多少个勇士，该值需手动修改。
-    
-    // 初始化该勇士
-    this.initHeros = function () {
-        core.status.hero.icon = "hero.png";
-        core.setFlag("hero1", core.clone(hero1)); // 将属性值存到变量中
-        // core.setFlag("hero2", core.clone(hero2)); // 更多的勇士...
-    }
-    
-    // 切换勇士
-    this.changeHero = function (toHeroId) {
-        var currHeroId = core.getFlag("heroId", 0); // 获得当前角色ID
-        if (!core.isset(toHeroId)) {
-            toHeroId = (currHeroId+1)%heroCount;
-        }
-        if (currHeroId == toHeroId) return;
-
-        var saveList = Object.keys(hero1);
-
-	    // 保存当前内容
-        var toSave = {};
-        saveList.forEach(function(name) {
-            if (name=='floorId') toSave[name] = core.status.floorId; // 楼层单独设置
-            else toSave[name] = core.clone(core.status.hero[name]); // 使用core.clone()来创建新对象
-        })
-    
-        core.setFlag("hero"+currHeroId, toSave); // 将当前角色信息进行保存
-        var data = core.getFlag("hero"+toHeroId); // 获得要切换的角色保存内容
-    
-        // 设置角色的属性值
-        saveList.forEach(function(name) {
-            if (name != 'floorId')
-                core.status.hero[name] = core.clone(data[name]);
-        })
-    
-        // 插入事件：改变角色行走图并进行楼层切换
-        core.insertAction([
-            {"type": "setHeroIcon", "name": data.icon||"hero.png"}, // 改变行走图
-            {"type": "changeFloor", "floorId": data.floorId, "loc": [data.loc.x, data.loc.y], 
-                "direction": data.loc.direction, "time": 0} // 楼层切换事件
-        ])
-        core.setFlag("heroId", toHeroId); // 保存切换到的角色ID
-    }
-    ```
-3. 在脚本编辑 - setInitData中加上`core.plugin.initHeros()`来初始化新勇士。（写在`core.events.afterLoadData()`后，反大括号之前。）
-4. 如果需要切换角色（包括事件、道具或者快捷键等），可以直接调用自定义JS脚本：`core.plugin.changeHero();`进行切换。也可以指定参数调用`core.plugin.changeHero(1)`来切换到某个具体的勇士上。
-
-!> 如果道具不共用，需要在初始定义那里写 `'items': {"keys": {"yellowKey": 0, "blueKey": 0, "redKey": 0}, "tools": {}, "constants": {}}`
-
-## 根据难度分歧来自定义地图
-
-遗憾的是，所有地图数据必须在剧本的map中指定，换句话说，我们无法在游戏进行中动态修改地图，比如为简单难度增加一个血瓶。
-
-幸运的是，我们可以采用如下方式进行难度分歧，为用户简单难度下增加额外的血瓶或宝石。
-
-``` js
-"firstArrive": [ // 第一次到该楼层触发的事件
-    {"type": "if", "condition": "flag:hard!=3", // 判断是否困难难度
-        "true": [ // 不为困难，则为普通或简单难度
-            {"type": "show", "loc": [3,6]} // 显示血瓶
-            {"type": "if", "condition": "flag:hard==1", // 判断是否是简单难度
-                "true": [
-                    {"type": "show", "loc": [3,7]} // 简单难度则显示宝石
-                ],
-                "false": [] // 普通难度则只显示血瓶
-            },
-        ],
-        "false": [] // 困难难度，不进行任何操作
-  },
-],
-"events": {
-  "3,6": {"enable": false} // 比如[3,6]点是一个血瓶，初始不可见
-  "3,7": {"enable": false} // 比如[3,7]点是一个宝石，初始不可见
-}
-```
-
-如上所示，我们在地图上设置一个额外的血瓶和宝石，并初始时设为禁用状态。
-
-当第一次到达该楼层时，进行一次判断；如果不为困难难度，则将血瓶显示出来；再判断是否为简单难度，如果是则再把宝石显示出来。
-
-通过对`flag:hard`进行判断的方式，我们也可以达成“对于不同的难度有着不同的地图效果”。
-
-==========================================================================================
-
-[继续阅读附录：所有API列表](api)
diff --git a/editor-mobile.html b/editor-mobile.html
index 70d5f8b0..67db31dd 100644
--- a/editor-mobile.html
+++ b/editor-mobile.html
@@ -12,40 +12,60 @@
     if(innerWidth>innerHeight){ //pic:1242*2208 | chrome info:1340*2380
         confirm('宽大于高的设备请使用正常版本的editor, 点击确定跳转')?(window.location='./editor.html'):'';
     }
+    if (location.protocol.indexOf("http")!=0) {
+        alert("请在启动服务中打开本编辑器！不然包括编辑在内的绝大多数功能都无法使用。");
+    }
 </script>
 <div class="main">
     <div id="left" style="z-index:-1;opacity: 0;"><!-- map -->
         <div id="arrEditor">
             <table class="col" id='arrColMark'></table>
             <table class="row" id='arrRowMark'></table>
-            <div id="editArea" v-cloak>
-                <textarea cols="10" rows="10" id="pout" v-model="mapArr"></textarea>
-                <p class="warnText" v-if="error">{{ errors[error-1] }}</p>
+            <div id="mapEditArea">
+                <textarea cols="10" rows="10" id="pout"></textarea>
             </div>
-            <div id="editTip" style="position: absolute; width: 95vw;margin-bottom: 10%;bottom: 0;left: 4vw;">
-                <input type="button" value="新建空白地图" id='newMap'/>
-                <input id='newFileName' placeholder="新楼层id" style="width: 70px"/>
+            <div id="editTip">
+                <input id='newFileName' placeholder="新楼层id" style="width: 100px"/>
                 <span style="vertical-align: bottom">宽</span>
                 <input id='newMapWidth' value="13" style="width: 20px"/>
                 <span style="vertical-align: bottom">高</span>
                 <input id='newMapHeight' value="13" style="width: 20px"/>
                 <input type="checkbox" id='newMapStatus' checked='checked' style='vertical-align: bottom'/>
-                <span style='vertical-align: bottom; margin-left: -4px'>保留属性</span>
+                <span style='vertical-align: bottom;'>保留楼层属性</span>
+                <br/>
+                <input type="button" value="新建空白地图" id='newMap'/>
             </div>
-            <div style="position: absolute;left: 10px;bottom:0; margin-bottom: 0%">
-                <input type="button" value="导出地图" id="exportMap" v-on:click="exportMap"/>
-                <input type="button" value="复制地图" id="copyMap" v-on:click="copyMap"/>
-                <input type="button" value="清除地图" id='clearMap' v-on:click="clearMap"/>
-                <input type="button" value="删除地图" id="deleteMap" v-on:click="deleteMap"/>
+            <div id='editBtns'>
+                <input type="button" value="导出地图" id="exportMap"/>
+                <input type="button" value="复制地图" id="copyMap"/>
+                <input type="button" value="清除地图" id='clearMapButton'/>
+                <input type="button" value="删除地图" id="deleteMap"/>
+            </div>
+            <input type="button" value="批量创建空白地图 ↓" id='newMaps'/>
+            <div id='newFloors' style='display:none'>
+                <span style="vertical-align: bottom">楼层ID格式: </span>
+                <input id='newFloorIds' style="width: 70px" value='MT${i}'/>
+                <br/>
+                <span style="vertical-align: bottom">地图中文名格式: </span>
+                <input id='newFloorTitles' style="width: 100px" value='主塔 ${i} 层'/>
+                <br/>
+                <span style="vertical-align: bottom">状态栏名称: </span>
+                <input id='newFloorNames' style="width: 70px" value='${i}'/>
+                <br/>
+                <span style="vertical-align: bottom">宽</span>
+                <input id='newMapsWidth' value="13" style="width: 20px"/>
+                <span style="vertical-align: bottom">高</span>
+                <input id='newMapsHeight' value="13" style="width: 20px"/>
+                <input type="checkbox" id='newMapsStatus' checked='checked' style='vertical-align: bottom'/>
+                <span style='vertical-align: bottom; margin-left: -4px'>保留楼层属性</span>
+                <br/>
+                <span style="vertical-align: bottom">从 i=</span>
+                <input id='newMapsFrom' value="1" style="width: 20px"/>
+                <span style="vertical-align: bottom">到</span>
+                <input id='newMapsTo' value="5" style="width: 20px"/>
+                <input type="button" value="确认创建" id='createNewMaps'>
             </div>
         </div>
-        <div id="objDataEditor">
-
-        </div>
-        <div id="eventEditor">
-
-        </div>
-
     </div>
     <div id="left1" class='leftTab' style="z-index:-1;opacity: 0;"><!-- appendpic -->
         <h3 class="leftTabHeader">追加素材</h3>
@@ -56,6 +76,15 @@
                 <!-- ["terrains", "animates", "enemys", "enemy48", "items", "npcs", "npc48"] -->
                 <input id="appendConfirm" type="button" value="追加"/>
             </p>
+            <p>
+                色相:<input id='changeColorInput' type="range" min="0" max="12" step="1" value="0" list="huelists" style="width: 60%;margin-left: 3%;vertical-align: middle">
+                <datalist id="huelists" style="display: none">
+                    <option value="0"/><option value="1"/><option value="2"/>
+                    <option value="3"/><option value="4"/><option value="5"/>
+                    <option value="6"/><option value="7"/><option value="8"/>
+                    <option value="9"/><option value="10"/><option value="11"/><option value="12"/>
+                </datalist>
+            </p>
             <div id="appendPicCanvas" style="position:relative;overflow: auto;height:470px;">
                 <canvas style="position:absolute"></canvas><!-- 用于画出灰白相间背景 -->
                 <canvas style="position:absolute"></canvas><!-- 用于画出选中文件 -->
@@ -71,7 +100,7 @@
         </div>
     </div>
     <div id="left2" class='leftTab' style="z-index:-1;opacity: 0;"><!-- loc -->
-        <h3 class="leftTabHeader">地图选点&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>
+        <h3 class="leftTabHeader">地图选点&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>&nbsp;&nbsp;<button onclick="editor_multi.editCommentJs('loc')">配置表格</button>
         </h3>
         <div class="leftTabContent">
             <p id='pos_a6771a78_a099_417c_828f_0a24851ebfce' style="margin-left: 15px">0,0</p>
@@ -88,17 +117,10 @@
             </div>
         </div>
     </div>
-    <div id="left3" class='leftTab' style="z-index:-1;opacity: 0;"><!-- emenyitem -->
-        <h3 class="leftTabHeader">图块属性&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>
+    <div id="left3" class='leftTab' style="z-index:-1;opacity: 0;"><!-- enemyitem -->
+        <h3 class="leftTabHeader">图块属性&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>&nbsp;&nbsp;<button onclick="editor.mode.changeDoubleClickModeByButton('add')">添加</button>&nbsp;&nbsp;<button onclick="editor.mode.changeDoubleClickModeByButton('delete')">删除</button>&nbsp;&nbsp;<button onclick="editor_multi.editCommentJs('enemyitem')">配置表格</button>
         </h3>
         <div class="leftTabContent">
-            <div id='newIdIdnum'><!-- id and idnum -->
-                <input placeholder="新id（唯一标识符）"/>
-                <input placeholder="新idnum（1000以内数字）"/>
-                <button>save</button>
-                <br/>
-                <button style="margin-top: 10px">自动注册</button>
-            </div>
             <div id="enemyItemTable"><!-- enemy and item -->
                 <div class='etable'>
                     <table>
@@ -112,10 +134,21 @@
                     </table>
                 </div>
             </div>
+            <div id='newIdIdnum'><!-- id and idnum -->
+                <input placeholder="新id（唯一标识符）"/>
+                <input placeholder="新idnum（10000以内数字）"/>
+                <button>save</button>
+                <br/>
+                <button style="margin-top: 10px">自动注册</button>
+            </div>
+            <div id='changeId'><!-- id and idnum -->
+                <input placeholder="修改图块id为"/>
+                <button>save</button>
+            </div>
         </div>
     </div>
     <div id="left4" class='leftTab' style="z-index:-1;opacity: 0;"><!-- floor -->
-        <h3 class="leftTabHeader">楼层属性&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>
+        <h3 class="leftTabHeader">楼层属性&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>&nbsp;&nbsp;<button onclick="editor.mode.changeDoubleClickModeByButton('add')">添加</button>&nbsp;&nbsp;<button onclick="editor.mode.changeDoubleClickModeByButton('delete')">删除</button>&nbsp;&nbsp;<button onclick="editor_multi.editCommentJs('floor')">配置表格</button>
         </h3>
         <div class="leftTabContent">
             <div class='etable'>
@@ -129,10 +162,14 @@
                     </tbody>
                 </table>
             </div>
+            <div id='changeFloorId'><!-- id and idnum -->
+                <input placeholder="修改floorId为"/>
+                <button>save</button>
+            </div>
         </div>
     </div>
     <div id="left5" class='leftTab' style="z-index:-1;opacity: 0;"><!-- tower -->
-        <h3 class="leftTabHeader">全塔属性&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>
+        <h3 class="leftTabHeader">全塔属性&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>&nbsp;&nbsp;<button onclick="editor.mode.changeDoubleClickModeByButton('add')">添加</button>&nbsp;&nbsp;<button onclick="editor_multi.editCommentJs('tower')">配置表格</button>
         </h3>
         <div class="leftTabContent">
             <div class='etable'>
@@ -158,16 +195,27 @@
                 <select id="entryType" disabled="disabled" style="display: none">
                     <option value="event">event</option>
                     <option value="changeFloor">changeFloor</option>
-                    <option value="point">point</option>
+                    <option value="level">level</option>
                     <option value="shop">shop</option>
                     <option value="afterBattle">afterBattle</option>
                     <option value="afterGetItem">afterGetItem</option>
                     <option value="afterOpenDoor">afterOpenDoor</option>
                     <option value="firstArrive">firstArrive</option>
+                    <option value="eachArrive">eachArrive</option>
+                    <option value="commonEvent">commonEvent</option>
                 </select>
                 <button onclick="editor_blockly.confirm()">确认</button>
                 <button onclick="editor_blockly.parse()">解析</button>
                 <button onclick="editor_blockly.cancel()">取消</button>
+                <!-- 手机端放不下，因此不显示搜索框 -->
+                <div style="display: none">
+                    <div class="searchLogo"></div>
+                    <input type="text" id="searchBlock" placeholder="搜索图块"/>
+                </div>
+                <div id="colorPanel" class="cpPanel" style="display: none">
+                    <input class="color" id="colorPicker" value="255,215,0,1"/>
+                    <button onclick="confirmColor()">确定</button>
+                </div>
                 <xml id="toolbox" style="display:none">
                 </xml>
             </h3>
@@ -182,13 +230,14 @@
     <div id="left7" style="z-index:-1;opacity: 0;"><!-- 多行文本编辑器 -->
         <button onclick="editor_multi.confirm()">确认</button>
         <button onclick="editor_multi.cancel()">取消</button>
+        <button onclick="editor_multi.format()">格式化</button>
         <input type="checkbox" onclick="editor_multi.toggerLint()" id="lintCheckbox"
                style="vertical-align: bottom;margin-left:6px"/>
         <span style="vertical-align: bottom; margin-left: -3px">语法检查</span>
         <textarea id="multiLineCode" name="multiLineCode"></textarea>
     </div>
     <div id="left8" class='leftTab' style="z-index:-1;opacity: 0;"><!-- functions -->
-        <h3 class="leftTabHeader">脚本编辑&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>
+        <h3 class="leftTabHeader">脚本编辑&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>&nbsp;&nbsp;<button onclick="editor_multi.editCommentJs('functions')">配置表格</button>
         </h3>
         <div class="leftTabContent">
             <div class='etable'>
@@ -204,6 +253,40 @@
             </div>
         </div>
     </div>
+    <div id="left9" class='leftTab' style="z-index:-1;opacity: 0;"><!-- commonevent -->
+        <h3 class="leftTabHeader">公共事件&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>&nbsp;&nbsp;<button onclick="editor.mode.changeDoubleClickModeByButton('add')">添加</button>&nbsp;&nbsp;<button onclick="editor.mode.changeDoubleClickModeByButton('delete')">删除</button>&nbsp;&nbsp;<button onclick="editor_multi.editCommentJs('commonevent')">配置表格</button>
+        </h3>
+        <div class="leftTabContent">
+            <div class='etable'>
+                <table>
+                    <tbody id='table_b7bf0124_99fd_4af8_ae2f_0017f04a7c7d'>
+                    <tr>
+                        <td>条目</td>
+                        <td>注释</td>
+                        <td>值</td>
+                    </tr>
+                    </tbody>
+                </table>
+            </div>
+        </div>
+    </div>
+    <div id="left10" class='leftTab' style="z-index:-1;opacity: 0;"><!-- plugins -->
+        <h3 class="leftTabHeader">插件编写&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>&nbsp;&nbsp;<button onclick="editor.mode.changeDoubleClickModeByButton('add')">添加</button>&nbsp;&nbsp;<button onclick="editor.mode.changeDoubleClickModeByButton('delete')">删除</button>&nbsp;&nbsp;<button onclick="editor_multi.editCommentJs('plugins')">配置表格</button>
+        </h3>
+        <div class="leftTabContent">
+            <div class='etable'>
+                <table>
+                    <tbody id='table_e2c034ec_47c6_48ae_8db8_4f8f32fea2d6'>
+                    <tr>
+                        <td>条目</td>
+                        <td>注释</td>
+                        <td>值</td>
+                    </tr>
+                    </tbody>
+                </table>
+            </div>
+        </div>
+    </div>
     <div id="mid">
         <div class="col" id='mapColMark'></div>
         <div class="row" id='mapRowMark'></div>
@@ -211,6 +294,7 @@
             <canvas class='gameCanvas' id='bg' width='416' height='416'></canvas>
             <canvas class='gameCanvas' id='event' width='416' height='416'></canvas>
             <canvas class='gameCanvas' id='event2' width='416' height='416'></canvas>
+            <canvas class='gameCanvas' id='fg' width='416' height='416'></canvas>
             <canvas class='gameCanvas' id='efg' width='416' height='416'></canvas>
             <canvas class='egameCanvas' id='eui' width='416' height='416' style='z-index:100'></canvas>
         </div>
@@ -218,88 +302,80 @@
     </div>
     <div id="right" style="z-index:-1;opacity: 0;">
         <div id="iconLib">
-            <canvas class='egameCanvas' id='edata' width='416' height='416' style='z-index:0'></canvas>
+            <div id="iconImages"></div>
             <div id="selectBox">
-                <div id='dataSelection' v-show="isSelected" v-cloak></div>
+                <div id='dataSelection' style="display:none"></div>
             </div>
         </div>
     </div>
     <div id="down">
         <div style="margin:0.5rem">
             <div class="tools">
-                <div id="tip" v-cloak>
-                    <div v-if="isSelectedBlock">
-                        <p v-if="isClearBlock" class="infoText">当前选择为清除块，可擦除地图上块</p>
-                        <div v-else>
-                            <p v-if="hasId">图块编号：<span class="infoText">{{ infos['idnum'] }}</span></p>
-                            <p v-if="hasId">图块ID：<span class="infoText">{{ infos['id'] }}</span></p>
-                            <p v-else class="warnText">该图块无对应的数字或ID存在，请先前往icons.js和maps.js中进行定义！</p>
-                            <p>图块所在素材：<span class="infoText">{{ infos['images'] + (isAutotile ? '( '+infos['id']+' )' : '') }}</span>
-                            </p>
-                            <p>图块索引：<span class="infoText">{{ infos['y'] }}</span></p>
-                        </div>
+                <div id="tip">
+                    <div id="isSelectedBlock-if" style="display:none">
+                        <p id="isClearBlock-if" style="display:none" class="infoText">当前选择为清除块，可擦除地图上块</p>
+                        <div id="isClearBlock-else"><p id="isAirwall-if" style="display:none" class="infoText">当前选择为空气墙, 在编辑器中可视, 在游戏中隐藏的墙, 用来配合前景/背景的贴图</p>
+                        <div id="isAirwall-else">
+                            
+                        </div></div>
                     </div>
-                    <div v-else>
-                        <p v-if="whichShow" v-bind:class="[ (whichShow%2) ? 'warnText' : 'successText']">{{ mapMsg }}</p>
+                    <div id="isSelectedBlock-else">
+                        <p id="whichShow-if" style="display:none"></p>
                     </div>
                 </div>
     
                 <span id='mobileview'>
                     <input type="button" value="数据区"/>
                     <input type="button" value="地图区"/>
+                    <br />
                     <input type="button" value="素材库"/>
                     <input type="button" value="前往游戏" onclick="window.location='./index.html'"/>
                 </span>
                 <div id="menuDiv">
                     <div id="midMenu" style="display:none">
+                        <div id='addFloorEvent' class="menuitem" style="display:none"><div class="menuitem-content">添加上下楼事件</div></div>
                         <div id='chooseThis' class="menuitem"><div class="menuitem-content">选中此点</div></div>
                         <div id='chooseInRight' class="menuitem"><div class="menuitem-content">在素材区选中此图块</div></div>
                         <div id='copyLoc' class="menuitem"><div class="menuitem-content">复制此事件</div></div>
                         <div id='moveLoc' class="menuitem"><div class="menuitem-content">移动此事件</div></div>
+                        <div id='clearEvent' class="menuitem"><div class="menuitem-content">仅清空此点事件</div></div>
                         <div id='clearLoc' class="menuitem"><div class="menuitem-content">清空此点及事件</div></div>
                     </div>
                 </div>
                 <select id="editModeSelect">
                     <option value="map">地图编辑</option>
                     <option value="loc">地图选点</option>
-                    <option value="emenyitem">图块属性</option>
+                    <option value="enemyitem">图块属性</option>
                     <option value="floor">楼层属性</option>
                     <option value="tower">全塔属性</option>
                     <option value="functions">脚本编辑</option>
                     <option value="appendpic">追加素材</option>
+                    <option value="commonevent">公共事件</option>
+                    <option value="plugins">插件编写</option>
                 </select>
-                <select id="brushMod">
+                <select id="brushMod" style="clear:right">
                     <option value="line">画线</option>
                     <option value="rectangle">画矩形</option>
+                    <option value="tileset">tileset贴图</option>
                 </select>
-                <div id="viewportButtons">
-                    <input type="button" value="←"/>
-                    <input type="button" value="↑"/>
-                    <input type="button" value="↓"/>
-                    <input type="button" value="→"/>
+                <select id="layerMod" style="float:left;margin-right:3px">
+                    <option value="bgmap">背景层</option>
+                    <option value="map" selected>事件层</option>
+                    <option value="fgmap">前景层</option>
+                </select>
+                <div id="viewportButtons" style="float:left">
+                    <input type="button" style="padding:1px 1px" value="←"/>
+                    <input type="button" style="padding:1px 6px" value="↑"/>
+                    <input type="button" style="padding:1px 6px" value="↓"/>
+                    <input type="button" style="padding:1px 1px" value="→"/>
                 </div>
-                <select id="selectFloor"></select>
+                <select id="selectFloor" style="clear:left"></select>
                 <input type="button" value="保存地图" id='saveFloor'/>
                 <span id='mobileeditdata' style="display:none">
                     <input type="button" value="编辑"/>
                     <input type="button" value="显示完整名称" style="display: none;"/>
                     <input type="button" value="显示完整注释"/>
                 </span>
-                <!--  -->
-                <div id="bgSelect" v-cloak style="display:none">
-                    <span>当前地板: </span>
-                    <select v-model="selectedBg">
-                        <option disabled value="">请选择地板</option>
-                        <option v-for="bg in bgs" v-bind:value="bg">
-                            {{ bg }}
-                        </option>
-                    </select>
-                    <div class="selectpng">
-                        <input class='input' id='pin' v-model="imgname" placeholder="请输入自定义背景文件名"/>
-                        <input class='btn' type="button" value="确定" v-on:click="updatebg"/>
-                    </div>
-                </div>
-                <!--  -->
             </div>
         </div>
     </div>
@@ -308,6 +384,7 @@
 <!-- <script>/* -->
 <div id='gameGroup' style='display:none'>
     <p id='mainTips'>请稍后...</p>
+    <img id='musicBtn'>
     <div id='startPanel'>
         <div id='startTop'>
             <div id='startTopProgressBar'>
@@ -334,43 +411,55 @@
     <div id='statusBar' class="clearfix">
         <div class="status" id="floorCol">
             <img id="img-floor">
-            <p class='statusLabel' id='floor'></p>
+            <p class='statusLabel statusText' id='floor'></p>
+        </div>
+        <div class="status" id="nameCol">
+            <img id="img-name">
+            <p class='statusLabel statusText' id='name'></p>
         </div>
         <div class="status" id="lvCol">
             <img id="img-lv">
-            <p class='statusLabel' id='lv'></p>
+            <p class='statusLabel statusText' id='lv'></p>
         </div>
         <div class="status" id='hpmaxCol'>
             <img id="img-hpmax">
-            <p class='statusLabel' id='hpmax'></p>
+            <p class='statusLabel statusText' id='hpmax'></p>
         </div>
-        <div class="status">
+        <div class="status" id='hpCol'>
             <img id="img-hp">
-            <p class='statusLabel' id='hp'></p>
+            <p class='statusLabel statusText' id='hp'></p>
         </div>
-        <div class="status">
+        <div class="status" id='manaCol'>
+            <img id="img-mana">
+            <p class='statusLabel statusText' id='mana'></p>
+        </div>
+        <div class="status" id='atkCol'>
             <img id="img-atk">
-            <p class='statusLabel' id='atk'></p>
+            <p class='statusLabel statusText' id='atk'></p>
         </div>
-        <div class="status">
+        <div class="status" id='defCol'>
             <img id="img-def">
-            <p class='statusLabel' id='def'></p>
+            <p class='statusLabel statusText' id='def'></p>
         </div>
         <div class="status" id="mdefCol">
             <img id="img-mdef">
-            <p class='statusLabel' id='mdef'></p>
+            <p class='statusLabel statusText' id='mdef'></p>
         </div>
         <div class="status" id="moneyCol">
             <img id="img-money">
-            <p class='statusLabel' id='money'></p>
+            <p class='statusLabel statusText' id='money'></p>
         </div>
-        <div class="status" id="expCol">
+        <div class="status" id="experienceCol">
             <img id="img-experience">
-            <p class='statusLabel' id='experience'></p>
+            <p class='statusLabel statusText' id='experience'></p>
         </div>
         <div class="status" id="upCol">
             <img id="img-up">
-            <p class='statusLabel' id='up'></p>
+            <p class='statusLabel statusText' id='up'></p>
+        </div>
+        <div class="status" id="skillCol">
+            <img id="img-skill">
+            <p class='statusLabel statusText' id='skill' style='font-style: normal'></p>
         </div>
         <div class="status" id='keyCol'>
             <span class='statusLabel' id='yellowKey' style="color:#FFCCAA"></span>
@@ -387,179 +476,80 @@
             <span class='statusLabel' id='weak' style="color: #FECCD0;"></span>
             <span class='statusLabel' id='curse' style="color: #C2F4E7;"></span>
         </div>
+
+        <!-- 状态栏canvas化 -->
+        <canvas id="statusCanvas"></canvas>
     </div>
     <div id="toolBar" class="clearfix">
         <img class="tools" id='img-book'>
         <img class="tools" id='img-fly'>
         <img class="tools" id='img-toolbox'>
+        <img class="tools" id='img-keyboard'>
         <img class="tools" id='img-shop'>
         <img class="tools" id='img-save'>
         <img class="tools" id='img-load'>
         <img class="tools" id='img-settings'>
+        <img class="tools" id='img-btn1' style='display:none'>
+        <img class="tools" id='img-btn2' style='display:none'>
+        <img class="tools" id='img-btn3' style='display:none'>
+        <img class="tools" id='img-btn4' style='display:none'>
+        <img class="tools" id='img-btn5' style='display:none'>
+        <img class="tools" id='img-btn6' style='display:none'>
+        <img class="tools" id='img-btn7' style='display:none'>
+        <img class="tools" id='img-btn8' style='display:none'>
         <p class="statusLabel tools" id="hard"></p>
     </div>
-    <div id="gif"></div>
-    <div id="gif2"></div>
-    <div id="curtain"></div>
     <div id="gameDraw">
+        <div id="gif"></div>
+        <div id="gif2"></div>
         <!-- <canvas class='gameCanvas' id='bg' width='416' height='416'></canvas> -->
         <!-- <canvas class='gameCanvas' id='event' width='416' height='416'></canvas> -->
         <canvas class='gameCanvas' id='hero' width='416' height='416'></canvas>
         <!-- <canvas class='gameCanvas' id='event2' width='416' height='416'></canvas> -->
-        <canvas class='gameCanvas' id='fg' width='416' height='416'></canvas>
+        <!-- <canvas class='gameCanvas' id='fg' width='416' height='416'></canvas> -->
+        <canvas class='gameCanvas' id='damage' width='416' height='416'></canvas>
         <canvas class='gameCanvas' id='animate' width='416' height='416'></canvas>
-        <canvas class='gameCanvas' id='weather' width='416' height='416'></canvas>
-        <canvas class='gameCanvas' id='route' width='416' height='416'></canvas>
+        <canvas class='gameCanvas' id='curtain' width='416' height='416'></canvas>
         <canvas class='gameCanvas' id='ui' width='416' height='416'></canvas>
         <canvas class='gameCanvas' id='data' width='416' height='416'>此浏览器不支持HTML5</canvas>
     </div>
 </div>
+<div id='inputBackground' style='display: none'>
+    <div id='inputDialog'>
+        <p id="inputMessage">请输入文字...</p>
+        <input id='inputBox' type="text"/>
+        <button id='inputYes'>确定</button>
+        <button id='inputNo'>取消</button>
+    </div>
+</div>
 <!-- */</script> -->
 
 <!-- =========================================================== -->
 
-<script>
-if (location.protocol.indexOf("http")!=0) {
-    alert("请在启动服务中打开本编辑器！不然包括编辑在内的绝大多数功能都无法使用。");
-}
-</script>
-
-<script src='_server/vendor/vue.min.js'></script>
+<!-- <script src='_server/vendor/vue.min.js'></script> -->
 <!-- <script src="https://cdn.bootcss.com/vue/2.5.13/vue.js"></script> -->
-<script src='_server/vendor/polyfill.min.js'></script>
+<!-- <script src='_server/vendor/polyfill.min.js'></script> -->
 <script src='_server/fs.js'></script>
+<script src='_server/editor_util.js'></script>
+<script src='_server/editor_game.js'></script>
 <script src='_server/editor_file.js'></script>
+<script src='_server/editor_file_unsorted.js'></script>
+<script src='_server/editor_table.js'></script>
 <script src='_server/editor_mode.js'></script>
-<script src='_server/vm.js'></script>
+<script src='_server/editor_unsorted_1.js'></script>
+<script src='_server/editor_unsorted_2.js'></script>
+<script src='_server/editor_unsorted_3.js'></script>
 <script src='libs/thirdparty/lz-string.min.js'></script>
+<script src='libs/thirdparty/localforage.min.js'></script>
 <script id='mainScript' src='main.js'></script>
-<script>
-    //所有全局量
-    __all__ = ['Vue', 'fs', 'editor_file', 'editor_mode', 'main', 'core', 'hasOwnProp', 'printf', 'printe', 'editor', 'converter', 'ActionParser', 'MotaActionFunctions', 'MotaActionBlocks'];
-    __id__ = ['editArea', 'arrRowMark', 'mapRowMark', 'data', 'bg', 'dataSelection', 'blocklyDiv', 'codeAreaHL', 'entryType'];
-    __Vue__ = ['editArea', 'exportMap', 'copyMap', 'clearMap', 'deleteMap', 'tip', 'selectBox'];
-    //var event = document.getElementById('event');
-
-    var hasOwnProperty = Object.prototype.hasOwnProperty;
-
-    function hasOwnProp(obj, key) {
-        return hasOwnProperty.call(obj, key)
-    }
-</script>
 <script src='_server/editor.js'></script>
 <script>
-editor.isMobile=true
-var editor_mobile_listen=function(){
-    var mobileview=document.getElementById('mobileview');
-    var editModeSelect=document.getElementById('editModeSelect');
-    var mid=document.getElementById('mid');
-    var right=document.getElementById('right');
-    var mobileeditdata=document.getElementById('mobileeditdata');
-
-    
-    editor.showdataarea=function(callShowMode){
-        mid.style='z-index:-1;opacity: 0;';
-        right.style='z-index:-1;opacity: 0;';
-        mobileeditdata.style='';
-        if(callShowMode)editor.mode.showMode(editModeSelect.value);
-        editor.hideMidMenu();
-    }
-    mobileview.children[0].onclick=function(){
-        editor.showdataarea(true)
-    }
-    mobileview.children[1].onclick=function(){
-        mid.style='';
-        right.style='z-index:-1;opacity: 0;';
-        mobileeditdata.style='z-index:-1;opacity: 0;';
-        editor.lastClickId='';
-    }
-    mobileview.children[2].onclick=function(){
-        mid.style='z-index:-1;opacity: 0;';
-        right.style='';
-        mobileeditdata.style='z-index:-1;opacity: 0;';
-        editor.lastClickId='';
-    }
-
-
-    var gettrbyid=function(){
-        if(!editor.lastClickId)return false;
-        thisTr = document.getElementById(editor.lastClickId);
-        input = thisTr.children[2].children[0].children[0];
-        field = thisTr.children[0].getAttribute('title');
-        cobj = JSON.parse(thisTr.children[1].getAttribute('cobj'));
-        return [thisTr,input,field,cobj];
-    }
-    mobileeditdata.children[0].onclick=function(){
-        var info = gettrbyid()
-        if(!info)return;
-        info[1].ondblclick()
-    }
-    mobileeditdata.children[1].onclick=function(){
-        var info = gettrbyid()
-        if(!info)return;
-        printf(info[2])
-    }
-    mobileeditdata.children[2].onclick=function(){
-        var info = gettrbyid()
-        if(!info)return;
-        printf(info[0].children[1].getAttribute('title'))
-    }
-
-    //=====
-
-    document.body.ontouchstart=document.body.onmousedown;
-    document.body.onmousedown=null;
-
-
-    var eui=document.getElementById('eui');
-    eui.ontouchstart=eui.onmousedown
-    eui.onmousedown=null
-    eui.ontouchmove=eui.onmousemove
-    eui.onmousemove=null
-    eui.ontouchend=eui.onmouseup
-    eui.onmouseup=null
-
-
-    var chooseThis = document.getElementById('chooseThis');
-    chooseThis.ontouchstart=chooseThis.onmousedown
-    chooseThis.onmousedown=null
-    var chooseInRight = document.getElementById('chooseInRight');
-    chooseInRight.ontouchstart=chooseInRight.onmousedown
-    chooseInRight.onmousedown=null
-    var copyLoc = document.getElementById('copyLoc');
-    copyLoc.ontouchstart=copyLoc.onmousedown
-    copyLoc.onmousedown=null
-    var moveLoc = document.getElementById('moveLoc');
-    moveLoc.ontouchstart=moveLoc.onmousedown
-    moveLoc.onmousedown=null
-    var clearLoc = document.getElementById('clearLoc');
-    clearLoc.ontouchstart=clearLoc.onmousedown
-    clearLoc.onmousedown=null
-    
-}
-
-    var useCompress = main.useCompress;
-    main.useCompress = false;
-    main.init('editor', function () {
-        editor.init(function () {
-            editor.pos = {x: 0, y: 0};
-            editor.mode.loc();
-            editor.info = editor.ids[editor.indexs[201]];
-            editor.mode.emenyitem();
-            editor.mode.floor();
-            editor.mode.tower();
-            editor.mode.functions();
-            editor.mode.showMode('floor');
-            editor.mode.listen();
-            editor_multi = editor_multi();
-            editor_blockly = editor_blockly();
-            editor.useCompress = useCompress;
-            delete(useCompress);
-            editor_mobile_listen();
-        });
+    editor.isMobile=true;
+    editor.init(function () {
+        editor.listen();
+        editor.mode.listen();
+        editor.mobile_listen();
     });
-
-
     //main.listen();
 </script>
 
@@ -567,13 +557,19 @@ var editor_mobile_listen=function(){
 <script src='_server/editor_multi.js'></script>
 <!-- blockly -->
 <script src="_server/blockly/Converter.bundle.min.js"></script>
-<script src="_server/blockly/blockly_compressed.min.js"></script>
-<script src="_server/blockly/blockly_config.min.js"></script>
+<script src="_server/blockly/blockly_compressed.js"></script>
+<script src="_server/blockly/blocks_compressed.js"></script>
+<script src="_server/blockly/javascript_compressed.js"></script>
+<script src="_server/blockly/zh-hans.js"></script>
 <script src='_server/editor_blockly.js'></script>
 <!-- codemirror -->
 <script src="_server/CodeMirror/codeMirror.bundle.min.js"></script>
 <script src="_server/CodeMirror/jshint.min.js"></script>
+<script src="_server/CodeMirror/beautify.min.js"></script>
 <script src="_server/CodeMirror/codeMirror.plugin.min.js"></script>
+<!-- colorPicker -->
+<script type="text/javascript" src="_server/colorPicker/color.all.min.js"></script>
+<script type="text/javascript" src="_server/colorPicker/jsColor.js"></script>
 
 </body>
 </html>
diff --git a/editor.html b/editor.html
index 30ce7708..4ea3654f 100644
--- a/editor.html
+++ b/editor.html
@@ -11,15 +11,17 @@
     if(innerWidth<innerHeight){ //pic:1242*2208 | chrome info:1340*2380
         confirm('高大于宽的设备请使用移动版本的editor, 点击确定跳转')?(window.location='./editor-mobile.html'):'';
     }
+    if (location.protocol.indexOf("http")!=0) {
+        alert("请在启动服务中打开本编辑器！不然包括编辑在内的绝大多数功能都无法使用。");
+    }
 </script>
 <div class="main">
     <div id="left" style="z-index:-1;opacity: 0;"><!-- map -->
         <div id="arrEditor">
             <table class="col" id='arrColMark'></table>
             <table class="row" id='arrRowMark'></table>
-            <div id="editArea" v-cloak>
-                <textarea cols="10" rows="10" id="pout" v-model="mapArr"></textarea>
-                <p class="warnText" v-if="error">{{ errors[error-1] }}</p>
+            <div id="mapEditArea">
+                <textarea cols="10" rows="10" id="pout"></textarea>
             </div>
             <div id="editTip">
                 <input type="button" value="新建空白地图" id='newMap'/>
@@ -31,20 +33,35 @@
                 <input type="checkbox" id='newMapStatus' checked='checked' style='vertical-align: bottom'/>
                 <span style='vertical-align: bottom; margin-left: -4px'>保留楼层属性</span>
             </div>
-            <div style="position: absolute;left: 10px;bottom:0; margin-bottom: 90px">
-                <input type="button" value="导出地图" id="exportMap" v-on:click="exportMap"/>
-                <input type="button" value="复制地图" id="copyMap" v-on:click="copyMap"/>
-                <input type="button" value="清除地图" id='clearMap' v-on:click="clearMap"/>
-                <input type="button" value="删除地图" id="deleteMap" v-on:click="deleteMap"/>
+            <div id="editBtns">
+                <input type="button" value="导出地图" id="exportMap"/>
+                <input type="button" value="复制地图" id="copyMap"/>
+                <input type="button" value="清除地图" id='clearMapButton'/>
+                <input type="button" value="删除地图" id="deleteMap"/>
+            </div>
+            <input type="button" value="批量创建空白地图 ↓" id='newMaps'/>
+            <div id='newFloors' style='display:none'>
+                <span style="vertical-align: bottom">楼层ID格式: </span>
+                <input id='newFloorIds' style="width: 70px" value='MT${i}'/>
+                <span style="vertical-align: bottom">地图中文名格式: </span>
+                <input id='newFloorTitles' style="width: 100px" value='主塔 ${i} 层'/>
+                <br/>
+                <span style="vertical-align: bottom">状态栏名称: </span>
+                <input id='newFloorNames' style="width: 70px" value='${i}'/>
+                <span style="vertical-align: bottom">宽</span>
+                <input id='newMapsWidth' value="13" style="width: 20px"/>
+                <span style="vertical-align: bottom">高</span>
+                <input id='newMapsHeight' value="13" style="width: 20px"/>
+                <input type="checkbox" id='newMapsStatus' checked='checked' style='vertical-align: bottom'/>
+                <span style='vertical-align: bottom; margin-left: -4px'>保留楼层属性</span>
+                <br/>
+                <span style="vertical-align: bottom">从 i=</span>
+                <input id='newMapsFrom' value="1" style="width: 20px"/>
+                <span style="vertical-align: bottom">到</span>
+                <input id='newMapsTo' value="5" style="width: 20px"/>
+                <input type="button" value="确认创建" id='createNewMaps'>
             </div>
         </div>
-        <div id="objDataEditor">
-
-        </div>
-        <div id="eventEditor">
-
-        </div>
-
     </div>
     <div id="left1" class='leftTab' style="z-index:-1;opacity: 0;"><!-- appendpic -->
         <h3 class="leftTabHeader">追加素材</h3>
@@ -55,6 +72,15 @@
                 <!-- ["terrains", "animates", "enemys", "enemy48", "items", "npcs", "npc48"] -->
                 <input id="appendConfirm" type="button" value="追加"/>
             </p>
+            <p>
+                色相:<input id='changeColorInput' type="range" min="0" max="12" step="1" value="0" list="huelists" style="width: 60%;margin-left: 3%;vertical-align: middle">
+                <datalist id="huelists" style="display: none">
+                    <option value="0"/><option value="1"/><option value="2"/>
+                    <option value="3"/><option value="4"/><option value="5"/>
+                    <option value="6"/><option value="7"/><option value="8"/>
+                    <option value="9"/><option value="10"/><option value="11"/><option value="12"/>
+                </datalist>
+            </p>
             <div id="appendPicCanvas" style="position:relative;overflow: auto;height:470px;">
                 <canvas style="position:absolute"></canvas><!-- 用于画出灰白相间背景 -->
                 <canvas style="position:absolute"></canvas><!-- 用于画出选中文件 -->
@@ -70,7 +96,7 @@
         </div>
     </div>
     <div id="left2" class='leftTab' style="z-index:-1;opacity: 0;"><!-- loc -->
-        <h3 class="leftTabHeader">地图选点&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>
+        <h3 class="leftTabHeader">地图选点&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>&nbsp;&nbsp;<button onclick="editor_multi.editCommentJs('loc')">配置表格</button>
         </h3>
         <div class="leftTabContent">
             <p id='pos_a6771a78_a099_417c_828f_0a24851ebfce' style="margin-left: 15px">0,0</p>
@@ -87,34 +113,38 @@
             </div>
         </div>
     </div>
-    <div id="left3" class='leftTab' style="z-index:-1;opacity: 0;"><!-- emenyitem -->
-        <h3 class="leftTabHeader">图块属性&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>
+    <div id="left3" class='leftTab' style="z-index:-1;opacity: 0;"><!-- enemyitem -->
+        <h3 class="leftTabHeader">图块属性&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>&nbsp;&nbsp;<button onclick="editor.mode.changeDoubleClickModeByButton('add')">添加</button>&nbsp;&nbsp;<button onclick="editor.mode.changeDoubleClickModeByButton('delete')">删除</button>&nbsp;&nbsp;<button onclick="editor_multi.editCommentJs('enemyitem')">配置表格</button>
         </h3>
         <div class="leftTabContent">
-            <div id='newIdIdnum'><!-- id and idnum -->
-                <input placeholder="新id（唯一标识符）"/>
-                <input placeholder="新idnum（1000以内数字）"/>
-                <button>save</button>
-                <br/>
-                <button style="margin-top: 10px">自动注册</button>
-            </div>
             <div id="enemyItemTable"><!-- enemy and item -->
                 <div class='etable'>
                     <table>
                         <tbody id='table_a3f03d4c_55b8_4ef6_b362_b345783acd72'>
-                        <tr>
-                            <td>条目</td>
-                            <td>注释</td>
-                            <td>值</td>
-                        </tr>
+                            <tr>
+                                <td>条目</td>
+                                <td>注释</td>
+                                <td>值</td>
+                            </tr>
                         </tbody>
                     </table>
                 </div>
             </div>
+            <div id='newIdIdnum'><!-- id and idnum -->
+                <input placeholder="新id（唯一标识符）"/>
+                <input placeholder="新idnum（10000以内数字）"/>
+                <button>save</button>
+                <br/>
+                <button style="margin-top: 10px">自动注册</button>
+            </div>
+            <div id='changeId'><!-- id and idnum -->
+                <input placeholder="修改图块id为"/>
+                <button>save</button>
+            </div>
         </div>
     </div>
     <div id="left4" class='leftTab' style="z-index:-1;opacity: 0;"><!-- floor -->
-        <h3 class="leftTabHeader">楼层属性&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>
+        <h3 class="leftTabHeader">楼层属性&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>&nbsp;&nbsp;<button onclick="editor.mode.changeDoubleClickModeByButton('add')">添加</button>&nbsp;&nbsp;<button onclick="editor.mode.changeDoubleClickModeByButton('delete')">删除</button>&nbsp;&nbsp;<button onclick="editor_multi.editCommentJs('floor')">配置表格</button>
         </h3>
         <div class="leftTabContent">
             <div class='etable'>
@@ -128,10 +158,14 @@
                     </tbody>
                 </table>
             </div>
+            <div id='changeFloorId'><!-- id and idnum -->
+                <input placeholder="修改floorId为"/>
+                <button>save</button>
+            </div>
         </div>
     </div>
     <div id="left5" class='leftTab' style="z-index:-1;opacity: 0;"><!-- tower -->
-        <h3 class="leftTabHeader">全塔属性&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>
+        <h3 class="leftTabHeader">全塔属性&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>&nbsp;&nbsp;<button onclick="editor.mode.changeDoubleClickModeByButton('add')">添加</button>&nbsp;&nbsp;<button onclick="editor_multi.editCommentJs('tower')">配置表格</button>
         </h3>
         <div class="leftTabContent">
             <div class='etable'>
@@ -157,16 +191,27 @@
                 <select id="entryType" disabled="disabled" style="display: none">
                     <option value="event">event</option>
                     <option value="changeFloor">changeFloor</option>
-                    <option value="point">point</option>
+                    <option value="level">level</option>
                     <option value="shop">shop</option>
                     <option value="afterBattle">afterBattle</option>
                     <option value="afterGetItem">afterGetItem</option>
                     <option value="afterOpenDoor">afterOpenDoor</option>
                     <option value="firstArrive">firstArrive</option>
+                    <option value="eachArrive">eachArrive</option>
+                    <option value="commonEvent">commonEvent</option>
                 </select>
                 <button onclick="editor_blockly.confirm()">确认</button>
                 <button onclick="editor_blockly.parse()">解析</button>
                 <button onclick="editor_blockly.cancel()">取消</button>
+                <div style="position: relative; display: inline-block; margin-left: 10px">
+                    <div class="searchLogo"></div>
+                    <input type="text" id="searchBlock" placeholder="搜索图块"/>
+                    <button id = "colorSwitch" class="cpPanel" onclick="openColorFromButton()" style="margin-left:5px">颜色选择器</button>
+                    <div id="colorPanel" class="cpPanel" style="display: none">
+                        <input class="color" id="colorPicker" value="255,215,0,1"/>
+                        <button onclick="confirmColor()">确定</button>
+                    </div>
+                </div>
                 <xml id="toolbox" style="display:none">
                 </xml>
             </h3>
@@ -181,13 +226,14 @@
     <div id="left7" style="z-index:-1;opacity: 0;"><!-- 多行文本编辑器 -->
         <button onclick="editor_multi.confirm()">确认</button>
         <button onclick="editor_multi.cancel()">取消</button>
+        <button onclick="editor_multi.format()">格式化</button>
         <input type="checkbox" onclick="editor_multi.toggerLint()" id="lintCheckbox"
                style="vertical-align: bottom;margin-left:6px"/>
         <span style="vertical-align: bottom; margin-left: -3px">语法检查</span>
         <textarea id="multiLineCode" name="multiLineCode"></textarea>
     </div>
     <div id="left8" class='leftTab' style="z-index:-1;opacity: 0;"><!-- functions -->
-        <h3 class="leftTabHeader">脚本编辑&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>
+        <h3 class="leftTabHeader">脚本编辑&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>&nbsp;&nbsp;<button onclick="editor_multi.editCommentJs('functions')">配置表格</button>
         </h3>
         <div class="leftTabContent">
             <div class='etable'>
@@ -203,6 +249,40 @@
             </div>
         </div>
     </div>
+    <div id="left9" class='leftTab' style="z-index:-1;opacity: 0;"><!-- commonevent -->
+        <h3 class="leftTabHeader">公共事件&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>&nbsp;&nbsp;<button onclick="editor.mode.changeDoubleClickModeByButton('add')">添加</button>&nbsp;&nbsp;<button onclick="editor.mode.changeDoubleClickModeByButton('delete')">删除</button>&nbsp;&nbsp;<button onclick="editor_multi.editCommentJs('commonevent')">配置表格</button>
+        </h3>
+        <div class="leftTabContent">
+            <div class='etable'>
+                <table>
+                    <tbody id='table_b7bf0124_99fd_4af8_ae2f_0017f04a7c7d'>
+                    <tr>
+                        <td>条目</td>
+                        <td>注释</td>
+                        <td>值</td>
+                    </tr>
+                    </tbody>
+                </table>
+            </div>
+        </div>
+    </div>
+    <div id="left10" class='leftTab' style="z-index:-1;opacity: 0;"><!-- plugins -->
+        <h3 class="leftTabHeader">插件编写&nbsp;&nbsp;<button onclick="editor.mode.onmode('save')">保存</button>&nbsp;&nbsp;<button onclick="editor.mode.changeDoubleClickModeByButton('add')">添加</button>&nbsp;&nbsp;<button onclick="editor.mode.changeDoubleClickModeByButton('delete')">删除</button>&nbsp;&nbsp;<button onclick="editor_multi.editCommentJs('plugins')">配置表格</button>
+        </h3>
+        <div class="leftTabContent">
+            <div class='etable'>
+                <table>
+                    <tbody id='table_e2c034ec_47c6_48ae_8db8_4f8f32fea2d6'>
+                    <tr>
+                        <td>条目</td>
+                        <td>注释</td>
+                        <td>值</td>
+                    </tr>
+                    </tbody>
+                </table>
+            </div>
+        </div>
+    </div>
     <div id="mid">
         <table class="col" id='mapColMark'></table>
         <table class="row" id='mapRowMark'></table>
@@ -210,24 +290,21 @@
             <canvas class='gameCanvas' id='bg' width='416' height='416'></canvas>
             <canvas class='gameCanvas' id='event' width='416' height='416'></canvas>
             <canvas class='gameCanvas' id='event2' width='416' height='416'></canvas>
+            <canvas class='gameCanvas' id='fg' width='416' height='416'></canvas>
             <canvas class='gameCanvas' id='efg' width='416' height='416'></canvas>
             <canvas class='egameCanvas' id='eui' width='416' height='416' style='z-index:100'></canvas>
         </div>
         <div class="tools">
-            <div id="tip" v-cloak>
-                <div v-if="isSelectedBlock">
-                    <p v-if="isClearBlock" class="infoText">当前选择为清除块，可擦除地图上块</p>
-                    <div v-else>
-                        <p v-if="hasId">图块编号：<span class="infoText">{{ infos['idnum'] }}</span></p>
-                        <p v-if="hasId">图块ID：<span class="infoText">{{ infos['id'] }}</span></p>
-                        <p v-else class="warnText">该图块无对应的数字或ID存在，请先前往icons.js和maps.js中进行定义！</p>
-                        <p>图块所在素材：<span class="infoText">{{ infos['images'] + (isAutotile ? '( '+infos['id']+' )' : '') }}</span>
-                        </p>
-                        <p>图块索引：<span class="infoText">{{ infos['y'] }}</span></p>
-                    </div>
+            <div id="tip">
+                <div id="isSelectedBlock-if" style="display:none">
+                    <p id="isClearBlock-if" style="display:none" class="infoText">当前选择为清除块，可擦除地图上块</p>
+                    <div id="isClearBlock-else"><p id="isAirwall-if" style="display:none" class="infoText">当前选择为空气墙, 在编辑器中可视, 在游戏中隐藏的墙, 用来配合前景/背景的贴图</p>
+                    <div id="isAirwall-else">
+                        
+                    </div></div>
                 </div>
-                <div v-else>
-                    <p v-if="whichShow" v-bind:class="[ (whichShow%2) ? 'warnText' : 'successText']">{{ mapMsg }}</p>
+                <div id="isSelectedBlock-else">
+                    <p id="whichShow-if" style="display:none"></p>
                 </div>
             </div>
 
@@ -235,15 +312,25 @@
             <select id="editModeSelect">
                 <option value="map">地图编辑</option>
                 <option value="loc">地图选点</option>
-                <option value="emenyitem">图块属性</option>
+                <option value="enemyitem">图块属性</option>
                 <option value="floor">楼层属性</option>
                 <option value="tower">全塔属性</option>
                 <option value="functions">脚本编辑</option>
                 <option value="appendpic">追加素材</option>
+                <option value="commonevent">公共事件</option>
+                <option value="plugins">插件编写</option>
             </select>
-            <span style="font-size: 12px; margin-left: 5px">
+            <br/>
+            <span style="font-size: 12px;">
             <input type="radio" id="brushMod" name="brushMod" value="line" checked="checked" />画线
             <input type="radio" id="brushMod2" name="brushMod" value="rectangle" />画矩形
+            <input type="radio" id="brushMod3" name="brushMod" value="tileset" />tileset贴图
+            </span>
+            <br/>
+            <span style="font-size: 12px">
+            <input type="radio" id="layerMod2" name="layerMod" value="bgmap" />背景层
+            <input type="radio" id="layerMod" name="layerMod" value="map" checked="checked" style="margin-left: 5px" />事件层
+            <input type="radio" id="layerMod3" name="layerMod" value="fgmap" style="margin-left: 5px" />前景层
             </span>
             <br>
             <div id="viewportButtons">
@@ -255,37 +342,24 @@
             <br>
             <select id="selectFloor"></select>
             <input type="button" value="保存地图" id='saveFloor'/>
-            <!--  -->
-            <div id="bgSelect" v-cloak style="display:none">
-                <span>当前地板: </span>
-                <select v-model="selectedBg">
-                    <option disabled value="">请选择地板</option>
-                    <option v-for="bg in bgs" v-bind:value="bg">
-                        {{ bg }}
-                    </option>
-                </select>
-                <div class="selectpng">
-                    <input class='input' id='pin' v-model="imgname" placeholder="请输入自定义背景文件名"/>
-                    <input class='btn' type="button" value="确定" v-on:click="updatebg"/>
-                </div>
-            </div>
-            <!--  -->
         </div>
     </div>
     <div id="right">
         <div id="iconLib">
-            <canvas class='egameCanvas' id='edata' width='416' height='416' style='z-index:0'></canvas>
+            <div id="iconImages"></div>
             <div id="selectBox">
-                <div id='dataSelection' v-show="isSelected" v-cloak></div>
+                <div id='dataSelection' style="display:none"></div>
             </div>
         </div>
     </div>
     <div id="menuDiv">
         <div id="midMenu" style="display:none">
+            <div id='addFloorEvent' class="menuitem" style="display:none"><div class="menuitem-content">添加上下楼事件</div></div>
             <div id='chooseThis' class="menuitem"><div class="menuitem-content">选中此点</div></div>
             <div id='chooseInRight' class="menuitem"><div class="menuitem-content">在素材区选中此图块</div></div>
             <div id='copyLoc' class="menuitem"><div class="menuitem-content">复制此事件</div></div>
             <div id='moveLoc' class="menuitem"><div class="menuitem-content">移动此事件</div></div>
+            <div id='clearEvent' class="menuitem"><div class="menuitem-content">仅清空此点事件</div></div>
             <div id='clearLoc' class="menuitem"><div class="menuitem-content">清空此点及事件</div></div>
         </div>
     </div>
@@ -293,6 +367,7 @@
 <!-- <script>/* -->
 <div id='gameGroup' style='display:none'>
     <p id='mainTips'>请稍后...</p>
+    <img id='musicBtn'>
     <div id='startPanel'>
         <div id='startTop'>
             <div id='startTopProgressBar'>
@@ -319,43 +394,55 @@
     <div id='statusBar' class="clearfix">
         <div class="status" id="floorCol">
             <img id="img-floor">
-            <p class='statusLabel' id='floor'></p>
+            <p class='statusLabel statusText' id='floor'></p>
+        </div>
+        <div class="status" id="nameCol">
+            <img id="img-name">
+            <p class='statusLabel statusText' id='name'></p>
         </div>
         <div class="status" id="lvCol">
             <img id="img-lv">
-            <p class='statusLabel' id='lv'></p>
+            <p class='statusLabel statusText' id='lv'></p>
         </div>
         <div class="status" id='hpmaxCol'>
             <img id="img-hpmax">
-            <p class='statusLabel' id='hpmax'></p>
+            <p class='statusLabel statusText' id='hpmax'></p>
         </div>
-        <div class="status">
+        <div class="status" id='hpCol'>
             <img id="img-hp">
-            <p class='statusLabel' id='hp'></p>
+            <p class='statusLabel statusText' id='hp'></p>
         </div>
-        <div class="status">
+        <div class="status" id='manaCol'>
+            <img id="img-mana">
+            <p class='statusLabel statusText' id='mana'></p>
+        </div>
+        <div class="status" id='atkCol'>
             <img id="img-atk">
-            <p class='statusLabel' id='atk'></p>
+            <p class='statusLabel statusText' id='atk'></p>
         </div>
-        <div class="status">
+        <div class="status" id='defCol'>
             <img id="img-def">
-            <p class='statusLabel' id='def'></p>
+            <p class='statusLabel statusText' id='def'></p>
         </div>
         <div class="status" id="mdefCol">
             <img id="img-mdef">
-            <p class='statusLabel' id='mdef'></p>
+            <p class='statusLabel statusText' id='mdef'></p>
         </div>
         <div class="status" id="moneyCol">
             <img id="img-money">
-            <p class='statusLabel' id='money'></p>
+            <p class='statusLabel statusText' id='money'></p>
         </div>
-        <div class="status" id="expCol">
+        <div class="status" id="experienceCol">
             <img id="img-experience">
-            <p class='statusLabel' id='experience'></p>
+            <p class='statusLabel statusText' id='experience'></p>
         </div>
         <div class="status" id="upCol">
             <img id="img-up">
-            <p class='statusLabel' id='up'></p>
+            <p class='statusLabel statusText' id='up'></p>
+        </div>
+        <div class="status" id="skillCol">
+            <img id="img-skill">
+            <p class='statusLabel statusText' id='skill' style='font-style: normal'></p>
         </div>
         <div class="status" id='keyCol'>
             <span class='statusLabel' id='yellowKey' style="color:#FFCCAA"></span>
@@ -372,88 +459,79 @@
             <span class='statusLabel' id='weak' style="color: #FECCD0;"></span>
             <span class='statusLabel' id='curse' style="color: #C2F4E7;"></span>
         </div>
+
+        <!-- 状态栏canvas化 -->
+        <canvas id="statusCanvas"></canvas>
     </div>
     <div id="toolBar" class="clearfix">
         <img class="tools" id='img-book'>
         <img class="tools" id='img-fly'>
         <img class="tools" id='img-toolbox'>
+        <img class="tools" id='img-keyboard'>
         <img class="tools" id='img-shop'>
         <img class="tools" id='img-save'>
         <img class="tools" id='img-load'>
         <img class="tools" id='img-settings'>
+        <img class="tools" id='img-btn1' style='display:none'>
+        <img class="tools" id='img-btn2' style='display:none'>
+        <img class="tools" id='img-btn3' style='display:none'>
+        <img class="tools" id='img-btn4' style='display:none'>
+        <img class="tools" id='img-btn5' style='display:none'>
+        <img class="tools" id='img-btn6' style='display:none'>
+        <img class="tools" id='img-btn7' style='display:none'>
+        <img class="tools" id='img-btn8' style='display:none'>
         <p class="statusLabel tools" id="hard"></p>
     </div>
-    <div id="gif"></div>
-    <div id="gif2"></div>
-    <div id="curtain"></div>
     <div id="gameDraw">
+        <div id="gif"></div>
+        <div id="gif2"></div>
         <!-- <canvas class='gameCanvas' id='bg' width='416' height='416'></canvas> -->
         <!-- <canvas class='gameCanvas' id='event' width='416' height='416'></canvas> -->
         <canvas class='gameCanvas' id='hero' width='416' height='416'></canvas>
         <!-- <canvas class='gameCanvas' id='event2' width='416' height='416'></canvas> -->
-        <canvas class='gameCanvas' id='fg' width='416' height='416'></canvas>
+        <!-- <canvas class='gameCanvas' id='fg' width='416' height='416'></canvas> -->
+        <canvas class='gameCanvas' id='damage' width='416' height='416'></canvas>
         <canvas class='gameCanvas' id='animate' width='416' height='416'></canvas>
-        <canvas class='gameCanvas' id='weather' width='416' height='416'></canvas>
-        <canvas class='gameCanvas' id='route' width='416' height='416'></canvas>
+        <canvas class='gameCanvas' id='curtain' width='416' height='416'></canvas>
         <canvas class='gameCanvas' id='ui' width='416' height='416'></canvas>
         <canvas class='gameCanvas' id='data' width='416' height='416'>此浏览器不支持HTML5</canvas>
     </div>
 </div>
+<div id='inputBackground' style='display: none'>
+    <div id='inputDialog'>
+        <p id="inputMessage">请输入文字...</p>
+        <input id='inputBox' type="text"/>
+        <button id='inputYes'>确定</button>
+        <button id='inputNo'>取消</button>
+    </div>
+</div>
 <!-- */</script> -->
 
 <!-- =========================================================== -->
 
-<script>
-if (location.protocol.indexOf("http")!=0) {
-    alert("请在启动服务中打开本编辑器！不然包括编辑在内的绝大多数功能都无法使用。");
-}
-</script>
-
-<script src='_server/vendor/vue.min.js'></script>
+<!-- <script src='_server/vendor/vue.min.js'></script> -->
 <!-- <script src="https://cdn.bootcss.com/vue/2.5.13/vue.js"></script> -->
-<script src='_server/vendor/polyfill.min.js'></script>
+<!-- <script src='_server/vendor/polyfill.min.js'></script> -->
 <script src='_server/fs.js'></script>
+<script src='_server/editor_util.js'></script>
+<script src='_server/editor_game.js'></script>
 <script src='_server/editor_file.js'></script>
+<script src='_server/editor_file_unsorted.js'></script>
+<script src='_server/editor_table.js'></script>
 <script src='_server/editor_mode.js'></script>
-<script src='_server/vm.js'></script>
+<script src='_server/editor_unsorted_1.js'></script>
+<script src='_server/editor_unsorted_2.js'></script>
+<script src='_server/editor_unsorted_3.js'></script>
 <script src='libs/thirdparty/lz-string.min.js'></script>
+<script src='libs/thirdparty/localforage.min.js'></script>
 <script id='mainScript' src='main.js'></script>
-<script>
-    //所有全局量
-    __all__ = ['Vue', 'fs', 'editor_file', 'editor_mode', 'main', 'core', 'hasOwnProp', 'printf', 'printe', 'editor', 'converter', 'ActionParser', 'MotaActionFunctions', 'MotaActionBlocks'];
-    __id__ = ['editArea', 'arrRowMark', 'mapRowMark', 'data', 'bg', 'dataSelection', 'blocklyDiv', 'codeAreaHL', 'entryType'];
-    __Vue__ = ['editArea', 'exportMap', 'copyMap', 'clearMap', 'deleteMap', 'tip', 'selectBox'];
-    //var event = document.getElementById('event');
-
-    var hasOwnProperty = Object.prototype.hasOwnProperty;
-
-    function hasOwnProp(obj, key) {
-        return hasOwnProperty.call(obj, key)
-    }
-</script>
 <script src='_server/editor.js'></script>
 <script>
-    var useCompress = main.useCompress;
-    main.useCompress = false;
-    main.init('editor', function () {
-        editor.init(function () {
-            editor.pos = {x: 0, y: 0};
-            editor.mode.loc();
-            editor.info = editor.ids[editor.indexs[201]];
-            editor.mode.emenyitem();
-            editor.mode.floor();
-            editor.mode.tower();
-            editor.mode.functions();
-            editor.mode.showMode('floor');
-            editor.mode.listen();
-            editor_multi = editor_multi();
-            editor_blockly = editor_blockly();
-            editor.useCompress = useCompress;
-            delete(useCompress);
-        });
+    editor.init(function () {
+        editor.listen();
+        editor.mode.listen();
+        editor.mobile_listen();
     });
-
-
     //main.listen();
 </script>
 
@@ -461,13 +539,19 @@ if (location.protocol.indexOf("http")!=0) {
 <script src='_server/editor_multi.js'></script>
 <!-- blockly -->
 <script src="_server/blockly/Converter.bundle.min.js"></script>
-<script src="_server/blockly/blockly_compressed.min.js"></script>
-<script src="_server/blockly/blockly_config.min.js"></script>
+<script src="_server/blockly/blockly_compressed.js"></script>
+<script src="_server/blockly/blocks_compressed.js"></script>
+<script src="_server/blockly/javascript_compressed.js"></script>
+<script src="_server/blockly/zh-hans.js"></script>
 <script src='_server/editor_blockly.js'></script>
 <!-- codemirror -->
 <script src="_server/CodeMirror/codeMirror.bundle.min.js"></script>
 <script src="_server/CodeMirror/jshint.min.js"></script>
+<script src="_server/CodeMirror/beautify.min.js"></script>
 <script src="_server/CodeMirror/codeMirror.plugin.min.js"></script>
+<!-- colorPicker -->
+<script type="text/javascript" src="_server/colorPicker/color.all.min.js"></script>
+<script type="text/javascript" src="_server/colorPicker/jsColor.js"></script>
 
 </body>
 </html>
diff --git a/index.html b/index.html
index 7b07028a..06398202 100644
--- a/index.html
+++ b/index.html
@@ -5,7 +5,7 @@
     <meta http-equiv='X-UA-Compatible' content='IE=Edge, chrome=1'>
     <meta name='author' content='ckcz123'>
     <meta name='viewport' content='width=device-width, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0, user-scalable=yes'>
-    <title></title>
+    <title>HTML5魔塔</title>
     <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent"/>
     <meta name="screen-orientation" content="portrait">
     <meta name="full-screen" content="yes">
@@ -18,12 +18,14 @@
 <body>
 <div id='gameGroup'>
     <p id='mainTips'>请稍后...</p>
+    <img id='musicBtn'>
     <div id='startPanel'>
         <div id='startTop'>
             <div id='startTopProgressBar'>
                 <div id='startTopProgress'></div>
             </div>
             <p id='startTopLoadTips'>资源即将开始加载</p>
+            <p id='startTopHint'>HTML5魔塔游戏平台，享受更多魔塔游戏：<br/>https://h5mota.com/</p>
         </div>
         <img id='startBackground'>
         <p id='startLogo'></p>
@@ -44,43 +46,55 @@
     <div id='statusBar' class="clearfix">
         <div class="status" id="floorCol">
             <img id="img-floor">
-            <p class='statusLabel' id='floor'></p>
+            <p class='statusLabel statusText' id='floor'></p>
+        </div>
+        <div class="status" id="nameCol">
+            <img id="img-name">
+            <p class='statusLabel statusText' id='name'></p>
         </div>
         <div class="status" id="lvCol">
             <img id="img-lv">
-            <p class='statusLabel' id='lv'></p>
+            <p class='statusLabel statusText' id='lv'></p>
         </div>
         <div class="status" id='hpmaxCol'>
             <img id="img-hpmax">
-            <p class='statusLabel' id='hpmax'></p>
+            <p class='statusLabel statusText' id='hpmax'></p>
         </div>
-        <div class="status">
+        <div class="status" id='hpCol'>
             <img id="img-hp">
-            <p class='statusLabel' id='hp'></p>
+            <p class='statusLabel statusText' id='hp'></p>
         </div>
-        <div class="status">
+        <div class="status" id='manaCol'>
+            <img id="img-mana">
+            <p class='statusLabel statusText' id='mana'></p>
+        </div>
+        <div class="status" id='atkCol'>
             <img id="img-atk">
-            <p class='statusLabel' id='atk'></p>
+            <p class='statusLabel statusText' id='atk'></p>
         </div>
-        <div class="status">
+        <div class="status" id='defCol'>
             <img id="img-def">
-            <p class='statusLabel' id='def'></p>
+            <p class='statusLabel statusText' id='def'></p>
         </div>
         <div class="status" id="mdefCol">
             <img id="img-mdef">
-            <p class='statusLabel' id='mdef'></p>
+            <p class='statusLabel statusText' id='mdef'></p>
         </div>
         <div class="status" id="moneyCol">
             <img id="img-money">
-            <p class='statusLabel' id='money'></p>
+            <p class='statusLabel statusText' id='money'></p>
         </div>
-        <div class="status" id="expCol">
+        <div class="status" id="experienceCol">
             <img id="img-experience">
-            <p class='statusLabel' id='experience'></p>
+            <p class='statusLabel statusText' id='experience'></p>
         </div>
         <div class="status" id="upCol">
             <img id="img-up">
-            <p class='statusLabel' id='up'></p>
+            <p class='statusLabel statusText' id='up'></p>
+        </div>
+        <div class="status" id="skillCol">
+            <img id="img-skill">
+            <p class='statusLabel statusText' id='skill' style='font-style: normal'></p>
         </div>
         <div class="status" id='keyCol'>
             <span class='statusLabel' id='yellowKey' style="color:#FFCCAA"></span>
@@ -97,37 +111,56 @@
             <span class='statusLabel' id='weak' style="color: #FECCD0;"></span>
             <span class='statusLabel' id='curse' style="color: #C2F4E7;"></span>
         </div>
+
+        <!-- 状态栏canvas化 -->
+        <canvas id="statusCanvas" style="position: absolute; left: 0; top: 0;"></canvas>
     </div>
     <div id="toolBar" class="clearfix">
         <img class="tools" id='img-book'>
         <img class="tools" id='img-fly'>
         <img class="tools" id='img-toolbox'>
+        <img class="tools" id='img-keyboard'>
         <img class="tools" id='img-shop'>
         <img class="tools" id='img-save'>
         <img class="tools" id='img-load'>
         <img class="tools" id='img-settings'>
+        <img class="tools" id='img-btn1' style='display:none'>
+        <img class="tools" id='img-btn2' style='display:none'>
+        <img class="tools" id='img-btn3' style='display:none'>
+        <img class="tools" id='img-btn4' style='display:none'>
+        <img class="tools" id='img-btn5' style='display:none'>
+        <img class="tools" id='img-btn6' style='display:none'>
+        <img class="tools" id='img-btn7' style='display:none'>
+        <img class="tools" id='img-btn8' style='display:none'>
         <p class="statusLabel tools" id="hard"></p>
     </div>
-    <div id="gif"></div>
-    <div id="gif2"></div>
-    <div id="curtain"></div>
     <div id="gameDraw">
+        <div id="gif"></div>
+        <div id="gif2"></div>
         <canvas class='gameCanvas' id='bg' width='416' height='416'></canvas>
         <canvas class='gameCanvas' id='event' width='416' height='416'></canvas>
         <canvas class='gameCanvas' id='hero' width='416' height='416'></canvas>
         <canvas class='gameCanvas' id='event2' width='416' height='416'></canvas>
         <canvas class='gameCanvas' id='fg' width='416' height='416'></canvas>
+        <canvas class='gameCanvas' id='damage' width='416' height='416'></canvas>
         <canvas class='gameCanvas' id='animate' width='416' height='416'></canvas>
-        <canvas class='gameCanvas' id='weather' width='416' height='416'></canvas>
-        <canvas class='gameCanvas' id='route' width='416' height='416'></canvas>
+        <canvas class='gameCanvas' id='curtain' width='416' height='416'></canvas>
         <canvas class='gameCanvas' id='ui' width='416' height='416'></canvas>
         <canvas class='gameCanvas' id='data' width='416' height='416'>此浏览器不支持HTML5</canvas>
     </div>
 </div>
-<script src='libs/thirdparty/mid.min.js'></script>
+<div id='inputDiv'>
+    <div id='inputDialog'>
+        <p id="inputMessage">请输入文字...</p>
+        <input id='inputBox' type="text"/>
+        <button id='inputYes'>确定</button>
+        <button id='inputNo'>取消</button>
+    </div>
+</div>
 <script src='libs/thirdparty/lz-string.min.js'></script>
 <script src='libs/thirdparty/priority-queue.min.js'></script>
+<script src='libs/thirdparty/localforage.min.js'></script>
 <script id='mainScript' src='main.js'></script>
-<script>main.init();main.listen();</script>
+<script>main.init('play');main.listen();</script>
 </body>
 </html>
\ No newline at end of file
diff --git a/libs/actions.js b/libs/actions.js
index 772182a5..75a43b8b 100644
--- a/libs/actions.js
+++ b/libs/actions.js
@@ -3,161 +3,278 @@ actions.js：用户交互的事件的处理
 键盘、鼠标、触摸屏事件相关
  */
 
+"use strict";
+
 function actions() {
-    this.init();
+    this._init();
+    this.SIZE = core.__SIZE__;
+    this.HSIZE = core.__HALF_SIZE__;
+    this.LAST = this.SIZE - 1;
+    this.CHOICES_LEFT = 5; // choices
+    this.CHOICES_RIGHT = this.LAST - this.CHOICES_LEFT;
 }
 
-actions.prototype.init = function () {
+actions.prototype._init = function () {
+    this.actionsdata = functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a.actions;
+    this.actions = {};
+    // --- onkeyDown注册
+    this.registerAction('onkeyDown', '_sys_checkReplay', this._sys_checkReplay, 100);
+    this.registerAction('onkeyDown', '_sys_onkeyDown', this._sys_onkeyDown, 0);
+    // --- onkeyUp注册
+    this.registerAction('onkeyUp', '_sys_onkeyUp_replay', this._sys_onkeyUp_replay, 100);
+    this.registerAction('onkeyUp', '_sys_onkeyUp', this._sys_onkeyUp, 0);
+    // --- pressKey注册
+    this.registerAction('pressKey', '_sys_checkReplay', this._sys_checkReplay, 100);
+    this.registerAction('pressKey', '_sys_pressKey', this._sys_pressKey, 0);
+    // --- keyDown注册
+    this.registerAction('keyDown', '_sys_checkReplay', this._sys_checkReplay, 100);
+    this.registerAction('keyDown', '_sys_keyDown_lockControl', this._sys_keyDown_lockControl, 50);
+    this.registerAction('keyDown', '_sys_keyDown', this._sys_keyDown, 0);
+    // --- keyUp注册
+    this.registerAction('keyUp', '_sys_keyUp_replay', this._sys_keyUp_replay, 100);
+    this.registerAction('keyUp', '_sys_keyUp_lockControl', this._sys_keyUp_lockControl, 50);
+    this.registerAction('keyUp', '_sys_keyUp', this._sys_keyUp, 0);
+    // --- ondown注册
+    this.registerAction('ondown', '_sys_checkReplay', this._sys_checkReplay, 100);
+    this.registerAction('ondown', '_sys_ondown_paint', this._sys_ondown_paint, 60);
+    this.registerAction('ondown', '_sys_ondown_lockControl', this._sys_ondown_lockControl, 30);
+    this.registerAction('ondown', '_sys_ondown', this._sys_ondown, 0);
+    // --- onmove注册
+    this.registerAction('onmove', '_sys_checkReplay', this._sys_checkReplay, 100);
+    this.registerAction('onmove', '_sys_onmove_paint', this._sys_onmove_paint, 50);
+    this.registerAction('onmove', '_sys_onmove', this._sys_onmove, 0);
+    // --- onup注册
+    this.registerAction('onup', '_sys_checkReplay', this._sys_checkReplay, 100);
+    this.registerAction('onup', '_sys_onup_paint', this._sys_onup_paint, 50);
+    this.registerAction('onup', '_sys_onup', this._sys_onup, 0);
+    // --- onclick注册
+    this.registerAction('onclick', '_sys_checkReplay', this._sys_checkReplay, 100);
+    this.registerAction('onclick', '_sys_onclick_lockControl', this._sys_onclick_lockControl, 50);
+    this.registerAction('onclick', '_sys_onclick', this._sys_onclick, 0);
+    // --- onmousewheel注册
+    this.registerAction('onmousewheel', '_sys_onmousewheel', this._sys_onmousewheel, 0);
+    // --- keyDownCtrl注册
+    this.registerAction('keyDownCtrl', '_sys_keyDownCtrl', this._sys_keyDownCtrl, 0);
+    // --- longClick注册
+    this.registerAction('longClick', '_sys_longClick_lockControl', this._sys_longClick_lockControl, 50);
+    this.registerAction('longClick', '_sys_longClick', this._sys_longClick, 0);
 
 }
 
+//////  注册一个用户交互行为 //////
+/*
+ * 此函数将注册一个用户交互行为。
+ * action：要注册的交互类型，如 ondown, onclick, keyDown 等等。
+ * name：你的自定义名称，可被注销使用；同名重复注册将后者覆盖前者。
+ * func：执行函数。
+ * priority：优先级；优先级高的将会被执行。此项可不填，默认为0。
+ * 返回：如果func返回true，则不会再继续执行其他的交互函数；否则会继续执行其他的交互函数。
+ */
+actions.prototype.registerAction = function (action, name, func, priority) {
+    if (!name || !func)
+        return;
+    priority = priority || 0;
+    if (!this.actions[action]) {
+        this.actions[action] = [];
+    }
+    this.unregisterAction(action, name);
+    this.actions[action].push(
+        {"action": action, "name": name, "func": func, "priority": priority}
+    );
+    this.actions[action] = this.actions[action].sort(function (a, b) {
+        return b.priority - a.priority;
+    });
+}
+
+////// 注销一个用户交互行为 //////
+actions.prototype.unregisterAction = function (action, name) {
+    if (!this.actions[action]) return;
+    this.actions[action] = this.actions[action].filter(function (x) {
+        return x.name != name;
+    });
+}
+
+////// 执行一个用户交互行为 //////
+actions.prototype.doRegisteredAction = function (action) {
+    var actions = this.actions[action];
+    if (!actions) return false;
+    for (var i = 0; i < actions.length; ++i) {
+        try {
+            if (core.doFunc.apply(core, [actions[i].func, this].concat(Array.prototype.slice.call(arguments, 1))))
+                return true;
+        }
+        catch (e) {
+            main.log(e);
+            main.log("ERROR in actions["+actions[i].name+"].");
+        }
+    }
+    return false;
+}
+
+actions.prototype._checkReplaying = function () {
+    if (core.isReplaying() && core.status.event.id != 'save'
+        && (core.status.event.id || "").indexOf('book') != 0 && core.status.event.id != 'viewMaps')
+        return true;
+    return false;
+}
+
+////// 检查是否在录像播放中，如果是，则停止交互
+actions.prototype._sys_checkReplay = function () {
+    if (this._checkReplaying()) return true;
+}
+
 ////// 按下某个键时 //////
 actions.prototype.onkeyDown = function (e) {
-    if (core.isset(core.status.replay)&&core.status.replay.replaying
-        &&core.status.event.id!='save'&&(core.status.event.id||"").indexOf('book')!=0&&core.status.event.id!='viewMaps') return;
-    if (!core.isset(core.status.holdingKeys))core.status.holdingKeys=[];
-    var isArrow={37:true,38:true,39:true,40:true}[e.keyCode]
-    if(isArrow && !core.status.lockControl){
-        for(var ii =0;ii<core.status.holdingKeys.length;ii++){
-            if (core.status.holdingKeys[ii]===e.keyCode){
+    this.doRegisteredAction('onkeyDown', e);
+}
+
+actions.prototype._sys_onkeyDown = function (e) {
+    core.status.holdingKeys = core.status.holdingKeys || []
+    var isArrow = {37: true, 38: true, 39: true, 40: true}[e.keyCode]
+    if (isArrow && !core.status.lockControl) {
+        for (var ii = 0; ii < core.status.holdingKeys.length; ii++) {
+            if (core.status.holdingKeys[ii] === e.keyCode) {
                 return;
             }
         }
         core.status.holdingKeys.push(e.keyCode);
         this.pressKey(e.keyCode);
     } else {
-        if (e.keyCode==17) core.status.ctrlDown = true;
+        if (e.keyCode == 17) core.status.ctrlDown = true;
         this.keyDown(e.keyCode);
     }
 }
 
 ////// 放开某个键时 //////
-actions.prototype.onkeyUp = function(e) {
-    if (core.isset(core.status.replay)&&core.status.replay.replaying
-        &&core.status.event.id!='save'&&(core.status.event.id||"").indexOf('book')!=0&&core.status.event.id!='viewMaps') {
-        if (e.keyCode==27) // ESCAPE
-            core.stopReplay();
-        else if (e.keyCode==90) // Z
-            core.speedDownReplay();
-        else if (e.keyCode==88) // X
-            core.speedUpReplay();
-        else if (e.keyCode==32) // SPACE
-            core.triggerReplay();
-        else if (e.keyCode==65) // A
-            core.rewindReplay();
-        else if (e.keyCode==83)
-            core.saveReplay();
-        else if (e.keyCode==67)
-            core.bookReplay();
-        else if (e.keyCode==33||e.keyCode==34)
-            core.viewMapReplay();
-        return;
-    }
+actions.prototype.onkeyUp = function (e) {
+    this.doRegisteredAction('onkeyUp', e);
+}
 
-    var isArrow={37:true,38:true,39:true,40:true}[e.keyCode]
-    if(isArrow && !core.status.lockControl){
-        for(var ii =0;ii<core.status.holdingKeys.length;ii++){
-            if (core.status.holdingKeys[ii]===e.keyCode){
-                core.status.holdingKeys= core.status.holdingKeys.slice(0,ii).concat(core.status.holdingKeys.slice(ii+1));
-                if (ii === core.status.holdingKeys.length && core.status.holdingKeys.length!==0)core.pressKey(core.status.holdingKeys.slice(-1)[0]);
+actions.prototype._sys_onkeyUp_replay = function (e) {
+    if (this._checkReplaying()) {
+        if (e.keyCode == 27) // ESCAPE
+            core.stopReplay();
+        else if (e.keyCode == 90) // Z
+            core.speedDownReplay();
+        else if (e.keyCode == 88) // X
+            core.speedUpReplay();
+        else if (e.keyCode == 32) // SPACE
+            core.triggerReplay();
+        else if (e.keyCode == 65) // A
+            core.rewindReplay();
+        else if (e.keyCode == 83) // S
+            core.saveReplay();
+        else if (e.keyCode == 67) // C
+            core.bookReplay();
+        else if (e.keyCode == 33 || e.keyCode == 34) // PgUp/PgDn
+            core.viewMapReplay();
+        else if (e.keyCode == 78) // N
+            core.stepReplay();
+        else if (e.keyCode >= 49 && e.keyCode <= 51) // 1-3
+            core.setReplaySpeed(e.keyCode - 48);
+        else if (e.keyCode == 52) // 4
+            core.setReplaySpeed(6);
+        else if (e.keyCode == 53) // 5
+            core.setReplaySpeed(12);
+        else if (e.keyCode == 54) // 6
+            core.setReplaySpeed(24);
+        return true;
+    }
+}
+
+actions.prototype._sys_onkeyUp = function (e) {
+    var isArrow = {37: true, 38: true, 39: true, 40: true}[e.keyCode]
+    if (isArrow && !core.status.lockControl) {
+        for (var ii = 0; ii < core.status.holdingKeys.length; ii++) {
+            if (core.status.holdingKeys[ii] === e.keyCode) {
+                core.status.holdingKeys = core.status.holdingKeys.slice(0, ii).concat(core.status.holdingKeys.slice(ii + 1));
+                if (ii === core.status.holdingKeys.length && core.status.holdingKeys.length !== 0) core.pressKey(core.status.holdingKeys.slice(-1)[0]);
                 break;
             }
         }
-        this.keyUp(e.keyCode);
+        this.keyUp(e.keyCode, e.altKey);
     } else {
-        if (e.keyCode==17) core.status.ctrlDown = false;
-        this.keyUp(e.keyCode);
+        if (e.keyCode == 17) core.status.ctrlDown = false;
+        this.keyUp(e.keyCode, e.altKey);
     }
 }
 
 ////// 按住某个键时 //////
 actions.prototype.pressKey = function (keyCode) {
-    if (core.isset(core.status.replay)&&core.status.replay.replaying&&core.status.event.id!='save'&&(core.status.event.id||"").indexOf('book')!=0) return;
+    this.doRegisteredAction('pressKey', keyCode);
+}
+
+actions.prototype._sys_pressKey = function (keyCode) {
     if (keyCode === core.status.holdingKeys.slice(-1)[0]) {
         this.keyDown(keyCode);
-        window.setTimeout(function(){core.pressKey(keyCode);},30);
+        window.setTimeout(function () {
+            core.pressKey(keyCode);
+        }, 30);
     }
 }
 
 ////// 根据按下键的code来执行一系列操作 //////
-actions.prototype.keyDown = function(keyCode) {
-    if (core.isset(core.status.replay)&&core.status.replay.replaying
-        &&core.status.event.id!='save'&&(core.status.event.id||"").indexOf('book')!=0&&core.status.event.id!='viewMaps') return;
-    if (core.status.lockControl) {
-        // Ctrl跳过对话
-        if (keyCode==17) {
-            this.keyDownCtrl();
-            return;
-        }
-        if (core.status.event.id == 'action') {
-            this.keyDownAction(keyCode);
-            return;
-        }
-        if (core.status.event.id == 'book') {
-            this.keyDownBook(keyCode);
-            return;
-        }
-        if (core.status.event.id == 'fly') {
-            this.keyDownFly(keyCode);
-            return;
-        }
-        if (core.status.event.id == 'viewMaps') {
-            this.keyDownViewMaps(keyCode);
-            return;
-        }
-        if (core.status.event.id=='shop') {
-            this.keyDownShop(keyCode);
-            return;
-        }
-        if (core.status.event.id=='selectShop') {
-            this.keyDownQuickShop(keyCode);
-            return;
-        }
-        if (core.status.event.id=='toolbox') {
-            this.keyDownToolbox(keyCode);
-            return;
-        }
-        if (core.status.event.id=='save' || core.status.event.id=='load' || core.status.event.id=='replayLoad') {
-            this.keyDownSL(keyCode);
-            return;
-        }
-        if (core.status.event.id=='switchs') {
-            this.keyDownSwitchs(keyCode);
-            return;
-        }
-        if (core.status.event.id=='settings') {
-            this.keyDownSettings(keyCode);
-            return;
-        }
-        if (core.status.event.id=='syncSave') {
-            this.keyDownSyncSave(keyCode);
-            return;
-        }
-        if (core.status.event.id=='syncSelect') {
-            this.keyDownSyncSelect(keyCode);
-            return;
-        }
-        if (core.status.event.id=='localSaveSelect') {
-            this.keyDownLocalSaveSelect(keyCode);
-            return;
-        }
-        if (core.status.event.id=='storageRemove') {
-            this.keyDownStorageRemove(keyCode);
-            return;
-        }
-        if (core.status.event.id=='cursor') {
-            this.keyDownCursor(keyCode);
-            return;
-        }
-        if (core.status.event.id=='replay') {
-            this.keyDownReplay(keyCode);
-        }
-        return;
+actions.prototype.keyDown = function (keyCode) {
+    this.doRegisteredAction('keyDown', keyCode);
+}
+
+actions.prototype._sys_keyDown_lockControl = function (keyCode) {
+    if (!core.status.lockControl) return false;
+    // Ctrl跳过对话
+    if (keyCode == 17) {
+        this.keyDownCtrl();
+        return true;
     }
-    if(!core.status.played) {
-        return;
+    switch (core.status.event.id) {
+        case 'action':
+            this._keyDownAction(keyCode);
+            break;
+        case 'book':
+            this._keyDownBook(keyCode);
+            break;
+        case 'fly':
+            this._keyDownFly(keyCode);
+            break;
+        case 'viewMaps':
+            this._keyDownViewMaps(keyCode);
+            break;
+        case 'equipbox':
+            this._keyDownEquipbox(keyCode);
+            break;
+        case 'toolbox':
+            this._keyDownToolbox(keyCode);
+            break;
+        case 'save':
+        case 'load':
+        case 'replayLoad':
+        case 'replayRemain':
+            this._keyDownSL(keyCode);
+            break;
+        case 'shop':
+            this._keyDownShop(keyCode);
+            break;
+        case 'selectShop':
+        case 'switchs':
+        case 'settings':
+        case 'syncSave':
+        case 'syncSelect':
+        case 'localSaveSelect':
+        case 'storageRemove':
+        case 'replay':
+        case 'gameInfo':
+            this._keyDownChoices(keyCode);
+            break;
+        case 'cursor':
+            this._keyDownCursor(keyCode);
+            break;
     }
-    switch(keyCode) {
+    return true;
+}
+
+actions.prototype._sys_keyDown = function (keyCode) {
+    if (!core.status.played)
+        return true;
+    switch (keyCode) {
         case 37:
             core.moveHero('left');
             break;
@@ -170,567 +287,549 @@ actions.prototype.keyDown = function(keyCode) {
         case 40:
             core.moveHero('down');
             break;
-        break;
     }
+    return true;
 }
 
 ////// 根据放开键的code来执行一系列操作 //////
-actions.prototype.keyUp = function(keyCode, fromReplay) {
-    if (core.isset(core.status.replay)&&core.status.replay.replaying
-        &&core.status.event.id!='save'&&(core.status.event.id||"").indexOf('book')!=0&&core.status.event.id!='viewMaps') return;
+actions.prototype.keyUp = function (keyCode, altKey, fromReplay) {
+    this.doRegisteredAction('keyUp', keyCode, altKey, fromReplay);
+}
 
-    if (core.status.lockControl) {
-        core.status.holdingKeys = [];
-        // 全键盘操作部分
-        if (core.status.event.id == 'text' && (keyCode==13 || keyCode==32 || keyCode==67)) {
-            core.drawText();
-            return;
-        }
-        if (core.status.event.id=='confirmBox') {
-            this.keyUpConfirmBox(keyCode);
-            return;
-        }
-        if (core.status.event.id == 'action') {
-            this.keyUpAction(keyCode);
-            return;
-        }
-        if (core.status.event.id=='about' && (keyCode==13 || keyCode==32 || keyCode==67)) {
-            this.clickAbout();
-            return;
-        }
-        if (core.status.event.id=='book') {
-            this.keyUpBook(keyCode);
-            return;
-        }
-        if (core.status.event.id=='book-detail' && (keyCode==13 || keyCode==32 || keyCode==67)) {
-            this.clickBookDetail();
-            return;
-        }
-        if (core.status.event.id=='fly') {
-            this.keyUpFly(keyCode);
-            return;
-        }
-        if (core.status.event.id == 'viewMaps') {
-            this.keyUpViewMaps(keyCode);
-            return;
-        }
-        if (core.status.event.id=='shop') {
-            this.keyUpShop(keyCode);
-            return;
-        }
-        if (core.status.event.id=='selectShop') {
-            this.keyUpQuickShop(keyCode);
-            return;
-        }
-        if (core.status.event.id=='toolbox') {
-            this.keyUpToolbox(keyCode);
-            return;
-        }
-        if (core.status.event.id=='save' || core.status.event.id=='load' || core.status.event.id=='replayLoad') {
-            this.keyUpSL(keyCode);
-            return;
-        }
-        if (core.status.event.id=='switchs') {
-            this.keyUpSwitchs(keyCode);
-            return;
-        }
-        if (core.status.event.id=='settings') {
-            this.keyUpSettings(keyCode);
-            return;
-        }
-        if (core.status.event.id=='syncSave') {
-            this.keyUpSyncSave(keyCode);
-            return;
-        }
-        if (core.status.event.id=='syncSelect') {
-            this.keyUpSyncSelect(keyCode);
-            return;
-        }
-        if (core.status.event.id=='localSaveSelect') {
-            this.keyUpLocalSaveSelect(keyCode);
-            return;
-        }
-        if (core.status.event.id=='storageRemove') {
-            this.keyUpStorageRemove(keyCode);
-            return;
-        }
-        if (core.status.event.id=='cursor') {
-            this.keyUpCursor(keyCode);
-            return;
-        }
-        if (core.status.event.id=='replay') {
-            this.keyUpReplay(keyCode);
-            return;
-        }
-        if (core.status.event.id=='centerFly') {
-            this.keyUpCenterFly(keyCode);
-            return;
-        }
-        return;
+actions.prototype._sys_keyUp_replay = function (keyCode, altKey, fromReplay) {
+    if (!fromReplay && this._checkReplaying()) return true;
+}
+
+actions.prototype._sys_keyUp_lockControl = function (keyCode, altKey) {
+    if (!core.status.lockControl) return false;
+
+    var ok = function () {
+        return keyCode == 27 || keyCode == 88 || keyCode == 13 || keyCode == 32 || keyCode == 67;
     }
 
-    if(!core.status.played)
-        return;
-
-    switch (keyCode) {
-        case 27: // ESC
-            if (core.status.heroStop)
-                core.openSettings(true);
+    core.status.holdingKeys = [];
+    switch (core.status.event.id) {
+        case 'text':
+            ok() && core.drawText();
             break;
-        case 71: // G
-            if (core.status.heroStop)
-                core.useFly(true);
+        case 'confirmBox':
+            this._keyUpConfirmBox(keyCode);
             break;
-        case 88: // X
-            if (core.status.heroStop)
-                core.openBook(true);
+        case 'action':
+            this._keyUpAction(keyCode);
             break;
-        case 65: // A
-            if (core.status.heroStop)
-                core.doSL("autoSave", "load");
+        case 'about':
+            ok() && core.closePanel();
             break;
-        case 83: // S
-            if (core.status.heroStop)
-                core.save(true);
+        case 'help':
+            ok() && core.closePanel();
             break;
-        case 68: // D
-            if (core.status.heroStop)
-                core.load(true);
+        case 'book':
+            this._keyUpBook(keyCode);
             break;
-        case 69: // E
-            if (core.status.heroStop)
-                core.ui.drawCursor();
+        case 'book-detail':
+            ok() && this._clickBookDetail();
             break;
-        case 84: // T
-            if (core.status.heroStop)
-                core.openToolbox(true);
+        case 'fly':
+            this._keyUpFly(keyCode);
             break;
-        case 90: // Z
-            if (core.status.heroStop)
-                core.turnHero();
+        case 'viewMaps':
+            this._keyUpViewMaps(keyCode);
             break;
-        case 75: case 86: // K/V
-            if (core.status.heroStop)
-                core.openQuickShop(true);
+        case 'shop':
+            this._keyUpShop(keyCode);
             break;
-        case 32: // SPACE
-            if (core.status.heroStop)
-                core.getNextItem();
+        case 'selectShop':
+            this._keyUpQuickShop(keyCode);
             break;
-        case 72: // H
-            if (core.status.heroStop)
-                core.ui.drawHelp();
+        case 'toolbox':
+            this._keyUpToolbox(keyCode);
             break;
-        case 82: // R
-            if (core.status.heroStop) {
-                if (core.hasFlag('debug')) {
-                    core.drawText("\t[系统提示]调试模式下无法回放录像");
-                }
-                else {
-                    core.ui.drawReplay();
-                }
-            }
+        case 'equipbox':
+            this._keyUpEquipbox(keyCode, altKey);
             break;
-        case 33: case 34: // PAGEUP/PAGEDOWN
-        if (core.status.heroStop) {
-            if (core.flags.enableViewMaps) {
-                core.ui.drawMaps();
-            }
-            else {
-                core.drawTip("本塔不允许浏览地图！");
-            }
-        }
-        break;
-        case 37: // UP
+        case 'save':
+        case 'load':
+        case 'replayLoad':
+        case 'replayRemain':
+            this._keyUpSL(keyCode);
             break;
-        case 38: // DOWN
+        case 'keyBoard':
+            ok() && core.closePanel();
             break;
-        case 39: // RIGHT
+        case 'switchs':
+            this._keyUpSwitchs(keyCode);
             break;
-        case 40: // DOWN
+        case 'settings':
+            this._keyUpSettings(keyCode);
             break;
-        case 49: // 快捷键1: 破
-            if (core.status.heroStop && core.hasItem('pickaxe')) {
-                if (core.canUseItem('pickaxe')) {
-                    core.useItem('pickaxe');
-                }
-                else {
-                    core.drawTip('当前不能使用破墙镐');
-                }
-            }
+        case 'syncSave':
+            this._keyUpSyncSave(keyCode);
             break;
-        case 50: // 快捷键2: 炸
-            if (core.status.heroStop) {
-                if (core.hasItem('bomb')) {
-                    if (core.canUseItem('bomb')) {
-                        core.useItem('bomb');
-                    }
-                    else {
-                        core.drawTip('当前不能使用炸弹');
-                    }
-                }
-                else if (core.hasItem('hammer')) {
-                    if (core.canUseItem('hammer')) {
-                        core.useItem('hammer');
-                    }
-                    else {
-                        core.drawTip('当前不能使用圣锤');
-                    }
-
-                }
-            }
+        case 'syncSelect':
+            this._keyUpSyncSelect(keyCode);
             break;
-        case 51: // 快捷键3: 飞
-            if (core.status.heroStop && core.hasItem('centerFly')) {
-                core.events.useItem('centerFly');
-            }
+        case 'localSaveSelect':
+            this._keyUpLocalSaveSelect(keyCode);
+            break;
+        case 'storageRemove':
+            this._keyUpStorageRemove(keyCode);
+            break;
+        case 'cursor':
+            this._keyUpCursor(keyCode);
+            break;
+        case 'replay':
+            this._keyUpReplay(keyCode);
+            break;
+        case 'gameInfo':
+            this._keyUpGameInfo(keyCode);
+            break;
+        case 'centerFly':
+            this._keyUpCenterFly(keyCode);
+            break;
+        case 'paint':
+            this._keyUpPaint(keyCode);
             break;
-
     }
+    return true;
+}
 
-    if (core.isset(core.status.automaticRoute)&&core.status.automaticRoute.autoHeroMove) {
+actions.prototype._sys_keyUp = function (keyCode, altKey) {
+    if (!core.status.played)
+        return true;
+    this.actionsdata.onKeyUp(keyCode, altKey);
+    if (core.status.automaticRoute && core.status.automaticRoute.autoHeroMove) {
         core.stopAutomaticRoute();
     }
-
-    core.stopHero();
-
+    core.status.heroStop = true;
+    return true;
 }
 
 ////// 点击（触摸）事件按下时 //////
-actions.prototype.ondown = function (x ,y) {
-    if (core.isset(core.status.replay)&&core.status.replay.replaying
-        &&core.status.event.id!='save'&&(core.status.event.id||"").indexOf('book')!=0&&core.status.event.id!='viewMaps') return;
-    if (!core.status.played || core.status.lockControl) {
-        this.onclick(x, y, []);
-        if (core.timeout.onDownTimeout==null) {
-            core.timeout.onDownTimeout = setTimeout(function () {
-                if (core.interval.onDownInterval == null) {
-                    core.interval.onDownInterval = setInterval(function () {
-                        if (!core.actions.longClick(x, y, true)) {
-                            clearInterval(core.interval.onDownInterval);
-                            core.interval.onDownInterval = null;
-                        }
-                    }, 40)
-                }
-            }, 500);
-        }
-        return;
+actions.prototype.ondown = function (loc) {
+    var x = parseInt(loc.x / loc.size), y = parseInt(loc.y / loc.size);
+    var px = parseInt(loc.x / core.domStyle.scale), py = parseInt(loc.y / core.domStyle.scale);
+    this.doRegisteredAction('ondown', x, y, px, py);
+}
+
+actions.prototype._sys_ondown_paint = function (x, y, px, py) {
+    // 画板
+    if (core.status.played && (core.status.event || {}).id == 'paint') {
+        this._ondownPaint(px, py);
+        return true;
+    }
+}
+
+actions.prototype._sys_ondown_lockControl = function (x, y, px, py) {
+    if (core.status.played && !core.status.lockControl) return false;
+
+    // --- wait事件也要提供px和py
+    if (core.status.event.id == 'action' && core.status.event.data.type == 'wait') {
+        core.setFlag('type', 1);
+        core.setFlag('x', x);
+        core.setFlag('y', y);
+        core.setFlag('px', px);
+        core.setFlag('py', py);
+        core.status.route.push("input:" + (1000000 + 1000 * px + py));
+        core.doAction();
+    }
+    else {
+        core.actions.onclick(x, y, []);
     }
 
+    // --- 长按判定
+    if (core.timeout.onDownTimeout == null) {
+        core.timeout.onDownTimeout = setTimeout(function () {
+            if (core.interval.onDownInterval == null) {
+                core.interval.onDownInterval = setInterval(function () {
+                    if (!core.actions.longClick(x, y, true)) {
+                        clearInterval(core.interval.onDownInterval);
+                        core.interval.onDownInterval = null;
+                    }
+                }, 40)
+            }
+        }, 500);
+    }
+    return true;
+}
+
+actions.prototype._sys_ondown = function (x, y, px, py) {
     core.status.downTime = new Date();
-    core.clearMap('route');
-    var pos={'x':x,'y':y}
-    core.status.stepPostfix=[];
+    core.deleteCanvas('route');
+    var pos = {'x': x, 'y': y}
+    core.status.stepPostfix = [];
     core.status.stepPostfix.push(pos);
     core.fillPosWithPoint(pos);
 }
 
 ////// 当在触摸屏上滑动时 //////
-actions.prototype.onmove = function (x ,y) {
-    if (core.isset(core.status.replay)&&core.status.replay.replaying
-        &&core.status.event.id!='save'&&(core.status.event.id||"").indexOf('book')!=0&&core.status.event.id!='viewMaps') return;
-    // if (core.status.holdingPath==0){return;}
-    //core.status.mouseOutCheck =1;
-    var pos={'x':x,'y':y};
-    var pos0=core.status.stepPostfix[core.status.stepPostfix.length-1];
-    var directionDistance=[pos.y-pos0.y,pos0.x-pos.x,pos0.y-pos.y,pos.x-pos0.x];
-    var max=0,index=4;
-    for(var ii=0;ii<4;ii++){
-        if(directionDistance[ii]>max){
-            index=ii;
-            max=directionDistance[ii];
+actions.prototype.onmove = function (loc) {
+    var x = parseInt(loc.x / loc.size), y = parseInt(loc.y / loc.size);
+    var px = parseInt(loc.x / core.domStyle.scale), py = parseInt(loc.y / core.domStyle.scale);
+    this.doRegisteredAction('onmove', x, y, px, py);
+}
+
+actions.prototype._sys_onmove_paint = function (x, y, px, py) {
+    // 画板
+    if (core.status.played && (core.status.event || {}).id == 'paint') {
+        core.actions._onmovePaint(px, py);
+        return true;
+    }
+}
+
+actions.prototype._sys_onmove = function (x, y) {
+    if ((core.status.stepPostfix || []).length > 0) {
+        var pos = {'x': x, 'y': y};
+        var pos0 = core.status.stepPostfix[core.status.stepPostfix.length - 1];
+        var directionDistance = [pos.y - pos0.y, pos0.x - pos.x, pos0.y - pos.y, pos.x - pos0.x];
+        var max = 0, index = 4;
+        for (var ii = 0; ii < 4; ii++) {
+            if (directionDistance[ii] > max) {
+                index = ii;
+                max = directionDistance[ii];
+            }
+        }
+        pos = [{'x': 0, 'y': 1}, {'x': -1, 'y': 0}, {'x': 0, 'y': -1}, {'x': 1, 'y': 0}, false][index]
+        if (pos) {
+            pos.x += pos0.x;
+            pos.y += pos0.y;
+            core.status.stepPostfix.push(pos);
+            core.fillPosWithPoint(pos);
         }
     }
-    pos=[{'x':0,'y':1},{'x':-1,'y':0},{'x':0,'y':-1},{'x':1,'y':0},false][index]
-    if(pos){
-        pos.x+=pos0.x;
-        pos.y+=pos0.y;
-        core.status.stepPostfix.push(pos);
-        core.fillPosWithPoint(pos);
-    }
+    return true;
 }
 
 ////// 当点击（触摸）事件放开时 //////
 actions.prototype.onup = function () {
-    if (core.isset(core.status.replay)&&core.status.replay.replaying
-        &&core.status.event.id!='save'&&(core.status.event.id||"").indexOf('book')!=0&&core.status.event.id!='viewMaps') return;
+    this.doRegisteredAction('onup');
+}
 
+actions.prototype._sys_onup_paint = function () {
+    // 画板
+    if (core.status.played && (core.status.event || {}).id == 'paint') {
+        this._onupPaint();
+        return true;
+    }
+}
+
+actions.prototype._sys_onup = function () {
     clearTimeout(core.timeout.onDownTimeout);
     core.timeout.onDownTimeout = null;
     clearInterval(core.interval.onDownInterval);
     core.interval.onDownInterval = null;
 
-    // core.status.holdingPath=0;
-    if(core.status.stepPostfix.length>0){
-        var stepPostfix = [];
-        var direction={'0':{'1':'down','-1':'up'},'-1':{'0':'left'},'1':{'0':'right'}};
-        for(var ii=1;ii<core.status.stepPostfix.length;ii++){
-            var pos0 = core.status.stepPostfix[ii-1];
-            var pos = core.status.stepPostfix[ii];
-            stepPostfix.push({'direction': direction[pos.x-pos0.x][pos.y-pos0.y], 'x': pos.x+parseInt(core.bigmap.offsetX/32), 'y': pos.y+parseInt(core.bigmap.offsetY/32)});
-        }
-        var posx=core.status.stepPostfix[0].x;
-        var posy=core.status.stepPostfix[0].y;
-        core.status.stepPostfix=[];
-        if (!core.status.lockControl) {
-            core.clearMap('route');
-            core.canvas.route.restore();
-        }
+    if ((core.status.stepPostfix || []).length == 0) return false;
 
-        // 长按
-        if (!core.status.lockControl && stepPostfix.length==0 && core.status.downTime!=null && new Date()-core.status.downTime>=1000) {
-            this.longClick(posx, posy);
-        }
-        else {
-            //posx,posy是寻路的目标点,stepPostfix是后续的移动
-            this.onclick(posx,posy,stepPostfix);
-        }
-        core.status.downTime=null;
+    var stepPostfix = [];
+    var direction = {'0': {'1': 'down', '-1': 'up'}, '-1': {'0': 'left'}, '1': {'0': 'right'}};
+    for (var ii = 1; ii < core.status.stepPostfix.length; ii++) {
+        var pos0 = core.status.stepPostfix[ii - 1];
+        var pos = core.status.stepPostfix[ii];
+        stepPostfix.push({
+            'direction': direction[pos.x - pos0.x][pos.y - pos0.y],
+            'x': pos.x + parseInt(core.bigmap.offsetX / 32),
+            'y': pos.y + parseInt(core.bigmap.offsetY / 32)
+        });
     }
+    var posx = core.status.stepPostfix[0].x;
+    var posy = core.status.stepPostfix[0].y;
+    core.status.stepPostfix = [];
+    if (!core.status.lockControl) {
+        core.clearMap('ui');
+    }
+
+    // 长按
+    if (!core.status.lockControl && stepPostfix.length == 0 && core.status.downTime != null && new Date() - core.status.downTime >= 1000) {
+        core.actions.longClick(posx, posy);
+    }
+    else {
+        //posx,posy是寻路的目标点,stepPostfix是后续的移动
+        core.actions.onclick(posx, posy, stepPostfix);
+    }
+    core.status.downTime = null;
+    return true;
 }
 
-////// 获得点击事件相对左上角的坐标（0到12之间） //////
-actions.prototype.getClickLoc = function (x, y) {
+////// 获得点击事件相对左上角的坐标 //////
+actions.prototype._getClickLoc = function (x, y) {
 
     var statusBar = {'x': 0, 'y': 0};
     var size = 32;
     size = size * core.domStyle.scale;
 
-    switch (core.domStyle.screenMode) {// 这里的3是指statusBar和游戏画布之间的白线宽度
-        case 'vertical':
-            statusBar.x = 0;
-            statusBar.y = core.dom.statusBar.offsetHeight + 3;
-            break;
-        case 'horizontal':
-        case 'bigScreen':
-            statusBar.x = core.dom.statusBar.offsetWidth + 3;
-            statusBar.y = 0;
-            break;
+    if (core.domStyle.isVertical) {
+        statusBar.x = 0;
+        statusBar.y = core.dom.statusBar.offsetHeight + 3;
+    }
+    else {
+        statusBar.x = core.dom.statusBar.offsetWidth + 3;
+        statusBar.y = 0;
     }
 
     var left = core.dom.gameGroup.offsetLeft + statusBar.x;
     var top = core.dom.gameGroup.offsetTop + statusBar.y;
-    var loc={'x': x - left, 'y': y - top, 'size': size};
+    var loc = {'x': x - left, 'y': y - top, 'size': size};
     return loc;
 }
 
 ////// 具体点击屏幕上(x,y)点时，执行的操作 //////
 actions.prototype.onclick = function (x, y, stepPostfix) {
-    if (core.isset(core.status.replay)&&core.status.replay.replaying
-        &&core.status.event.id!='save'&&(core.status.event.id||"").indexOf('book')!=0&&core.status.event.id!='viewMaps') return;
     // console.log("Click: (" + x + "," + y + ")");
+    this.doRegisteredAction('onclick', x, y, stepPostfix || []);
+}
 
-    stepPostfix=stepPostfix||[];
-
-    // 非游戏屏幕内
-    if (x<0 || y<0 || x>12 || y>12) return;
+actions.prototype._sys_onclick_lockControl = function (x, y) {
+    if (!core.status.lockControl) return false;
+    switch (core.status.event.id) {
+        case 'centerFly':
+            this._clickCenterFly(x, y);
+            break;
+        case 'book':
+            this._clickBook(x, y);
+            break;
+        case 'book-detail':
+            this._clickBookDetail(x, y);
+            break;
+        case 'fly':
+            this._clickFly(x, y);
+            break;
+        case 'viewMaps':
+            this._clickViewMaps(x, y);
+            break;
+        case 'switchs':
+            this._clickSwitchs(x, y);
+            break;
+        case 'settings':
+            this._clickSettings(x, y);
+            break;
+        case 'shop':
+            this._clickShop(x, y);
+            break;
+        case 'selectShop':
+            this._clickQuickShop(x, y);
+            break;
+        case 'equipbox':
+            this._clickEquipbox(x, y);
+            break;
+        case 'toolbox':
+            this._clickToolbox(x, y);
+            break;
+        case 'save':
+        case 'load':
+        case 'replayLoad':
+        case 'replayRemain':
+            this._clickSL(x, y);
+            break;
+        case 'confirmBox':
+            this._clickConfirmBox(x, y);
+            break;
+        case 'keyBoard':
+            this._clickKeyBoard(x, y);
+            break;
+        case 'action':
+            this._clickAction(x, y);
+            break;
+        case 'text':
+            core.drawText();
+            break;
+        case 'syncSave':
+            this._clickSyncSave(x, y);
+            break;
+        case 'syncSelect':
+            this._clickSyncSelect(x, y);
+            break;
+        case 'localSaveSelect':
+            this._clickLocalSaveSelect(x, y);
+            break;
+        case 'storageRemove':
+            this._clickStorageRemove(x, y);
+            break;
+        case 'cursor':
+            this._clickCursor(x, y);
+            break;
+        case 'replay':
+            this._clickReplay(x, y);
+            break;
+        case 'gameInfo':
+            this._clickGameInfo(x, y);
+            break;
+        case 'about':
+        case 'help':
+            core.ui.closePanel();
+            break;
+    }
+    return true;
+}
 
+actions.prototype._sys_onclick = function (x, y, stepPostfix) {
     // 寻路
-    if (!core.status.lockControl) {
-        core.setAutomaticRoute(x+parseInt(core.bigmap.offsetX/32), y+parseInt(core.bigmap.offsetY/32), stepPostfix);
-        return;
-    }
-
-    // 中心对称飞行器
-    if (core.status.event.id == 'centerFly') {
-        this.clickCenterFly(x, y);
-        return;
-    }
-
-    // 怪物手册
-    if (core.status.event.id == 'book') {
-        this.clickBook(x,y);
-        return;
-    }
-
-    // 怪物详细信息
-    if (core.status.event.id == 'book-detail') {
-        this.clickBookDetail(x,y);
-        return;
-    }
-
-    // 楼层飞行器
-    if (core.status.event.id == 'fly') {
-        this.clickFly(x,y);
-        return;
-    }
-
-    // 查看地图
-    if (core.status.event.id == 'viewMaps') {
-        this.clickViewMaps(x,y);
-        return;
-    }
-
-    // 开关
-    if (core.status.event.id == 'switchs') {
-        this.clickSwitchs(x,y);
-        return;
-    }
-
-    // 设置
-    if (core.status.event.id == 'settings') {
-        this.clickSettings(x,y);
-        return;
-    }
-
-    // 商店
-    if (core.status.event.id == 'shop') {
-        this.clickShop(x,y);
-        return;
-    }
-
-    // 快捷商店
-    if (core.status.event.id == 'selectShop') {
-        this.clickQuickShop(x,y);
-        return;
-    }
-
-    // 工具栏
-    if (core.status.event.id == 'toolbox') {
-        this.clickToolbox(x,y);
-        return;
-    }
-
-    // 存读档
-    if (core.status.event.id == 'save' || core.status.event.id == 'load' || core.status.event.id=='replayLoad') {
-        this.clickSL(x,y);
-        return;
-    }
-
-    // 选项
-    if (core.status.event.id == 'confirmBox') {
-        this.clickConfirmBox(x,y);
-        return;
-    }
-
-    if (core.status.event.id == 'keyBoard') {
-        this.clickKeyBoard(x,y);
-        return;
-    }
-
-    // 关于
-    if (core.status.event.id == 'about') {
-        this.clickAbout(x,y);
-        return;
-    }
-
-    if (core.status.event.id == 'action') {
-        this.clickAction(x,y);
-        return;
-    }
-
-    // 纯文本
-    if (core.status.event.id == 'text') {
-        core.drawText();
-        return;
-    }
-
-    // 同步存档
-    if (core.status.event.id == 'syncSave') {
-        this.clickSyncSave(x,y);
-        return;
-    }
-
-    if (core.status.event.id == 'syncSelect') {
-        this.clickSyncSelect(x,y);
-        return;
-    }
-
-    if (core.status.event.id == 'localSaveSelect') {
-        this.clickLocalSaveSelect(x,y);
-        return;
-    }
-    if (core.status.event.id=='storageRemove') {
-        this.clickStorageRemove(x,y);
-        return;
-    }
-
-    if (core.status.event.id == 'cursor') {
-        this.clickCursor(x,y);
-        return;
-    }
-
-    if (core.status.event.id == 'replay') {
-        this.clickReplay(x,y);
-        return;
-    }
-
+    core.setAutomaticRoute(x + parseInt(core.bigmap.offsetX / 32), y + parseInt(core.bigmap.offsetY / 32), stepPostfix);
+    return true;
 }
 
 ////// 滑动鼠标滚轮时的操作 //////
 actions.prototype.onmousewheel = function (direct) {
-    if (core.isset(core.status.replay)&&core.status.replay.replaying
-        &&core.status.event.id!='save'&&(core.status.event.id||"").indexOf('book')!=0&&core.status.event.id!='viewMaps') return;
+    this.doRegisteredAction('onmousewheel', direct);
+}
+
+actions.prototype._sys_onmousewheel = function (direct) {
     // 向下滚动是 -1 ,向上是 1
 
+    if (this._checkReplaying()) {
+        // 滚轮控制速度
+        if (direct == 1) core.speedUpReplay();
+        if (direct == -1) core.speedDownReplay();
+        return;
+    }
+
     // 楼层飞行器
     if (core.status.lockControl && core.status.event.id == 'fly') {
-        if (direct==1) core.ui.drawFly(core.status.event.data+1);
-        if (direct==-1) core.ui.drawFly(core.status.event.data-1);
+        if (direct == 1) core.ui.drawFly(this._getNextFlyFloor(1));
+        if (direct == -1) core.ui.drawFly(this._getNextFlyFloor(-1));
         return;
     }
 
     // 怪物手册
     if (core.status.lockControl && core.status.event.id == 'book') {
-        if (direct==1) core.ui.drawBook(core.status.event.data - 6);
-        if (direct==-1) core.ui.drawBook(core.status.event.data + 6);
+        if (direct == 1) core.ui.drawBook(core.status.event.data - this.HSIZE);
+        if (direct == -1) core.ui.drawBook(core.status.event.data + this.HSIZE);
         return;
     }
 
     // 存读档
     if (core.status.lockControl && (core.status.event.id == 'save' || core.status.event.id == 'load')) {
-        if (direct==1) core.ui.drawSLPanel(core.status.event.data - 10);
-        if (direct==-1) core.ui.drawSLPanel(core.status.event.data + 10);
+        var index = core.status.event.data.page*10+core.status.event.data.offset;
+        if (direct == 1) core.ui.drawSLPanel(index - 10);
+        if (direct == -1) core.ui.drawSLPanel(index + 10);
         return;
     }
 
     // 浏览地图
     if (core.status.lockControl && core.status.event.id == 'viewMaps') {
-        if (direct==1) this.clickViewMaps(6,3);
-        if (direct==-1) this.clickViewMaps(6,9);
+        if (direct == 1) this._clickViewMaps(this.HSIZE, this.HSIZE - 3);
+        if (direct == -1) this._clickViewMaps(this.HSIZE, this.HSIZE + 3);
         return;
     }
+
 }
 
-/////////////////// 在某个界面时的按键点击效果 ///////////////////
+////// 长按Ctrl键时 //////
+actions.prototype.keyDownCtrl = function () {
+    this.doRegisteredAction('keyDownCtrl');
+}
+
+actions.prototype._sys_keyDownCtrl = function () {
+    if (core.status.event.id == 'text') {
+        core.drawText();
+        return true;
+    }
+    if (core.status.event.id == 'action' && core.status.event.data.type == 'text') {
+        core.doAction();
+        return true;
+    }
+    if (core.status.event.id == 'action' && core.status.event.data.type == 'sleep'
+        && !core.status.event.data.current.noSkip) {
+        if (core.timeout.sleepTimeout && !core.hasAsync()) {
+            clearTimeout(core.timeout.sleepTimeout);
+            core.timeout.sleepTimeout = null;
+            core.doAction();
+        }
+        return true;
+    }
+}
 
 ////// 长按 //////
 actions.prototype.longClick = function (x, y, fromEvent) {
     if (!core.isPlaying()) return false;
-    if (core.status.lockControl) {
-        if (core.status.event.id=='text') {
-            core.drawText();
+    return this.doRegisteredAction('longClick', x, y, fromEvent);
+}
+
+actions.prototype._sys_longClick_lockControl = function (x, y) {
+    if (!core.status.lockControl) return false;
+    if (core.status.event.id == 'text') {
+        core.drawText();
+        return true;
+    }
+    if (core.status.event.id == 'action' && core.status.event.data.type == 'text') {
+        core.doAction();
+        return true;
+    }
+    // 长按楼传器的箭头可以快速翻页
+    if (core.status.event.id == 'fly') {
+        if ((x == this.SIZE-2 || x == this.SIZE-3) && (y == this.HSIZE - 1 || y == this.HSIZE+3)) {
+            this._clickFly(x, y);
             return true;
         }
-        if (core.status.event.id=='action' && core.status.event.data.type=='text') {
+    }
+    // 长按SL上下页快速翻页
+    if (["save","load","replayLoad","replayRemain"].indexOf(core.status.event.id) >= 0) {
+        if ([this.HSIZE-2, this.HSIZE-3, this.HSIZE+2, this.HSIZE+3].indexOf(x) >= 0 && y == this.LAST) {
+            this._clickSL(x, y);
+            return true;
+        }
+    }
+    // 长按商店连续购买
+    if (core.status.event.id == 'shop' && x >= this.CHOICES_LEFT && x <= this.CHOICES_RIGHT) {
+        return this._clickShop(x, y);
+    }
+    // 长按可以跳过等待事件
+    if (core.status.event.id == 'action' && core.status.event.data.type == 'sleep'
+        && !core.status.event.data.current.noSkip) {
+        if (core.timeout.sleepTimeout && !core.hasAsync()) {
+            clearTimeout(core.timeout.sleepTimeout);
+            core.timeout.sleepTimeout = null;
             core.doAction();
             return true;
         }
     }
-    else if (!fromEvent) {
+    return false;
+}
+
+actions.prototype._sys_longClick = function (x, y, fromEvent) {
+    if (!core.status.lockControl && !fromEvent) {
+        // 虚拟键盘
         core.waitHeroToStop(function () {
-            // 绘制快捷键
             core.ui.drawKeyBoard();
         });
+        return true;
     }
     return false;
 }
 
-////// 按下Ctrl键时（快捷跳过对话） //////
-actions.prototype.keyDownCtrl = function () {
-    if (core.status.event.id=='text') {
-        core.drawText();
-        return;
+/////////////////// 在某个界面时的按键点击效果 ///////////////////
+
+// 数字键快速选择选项
+actions.prototype._selectChoices = function (length, keycode, callback) {
+    var topIndex = this.HSIZE - parseInt((length - 1) / 2) + (core.status.event.ui.offset || 0);
+    if (keycode == 13 || keycode == 32 || keycode == 67) {
+        callback.apply(this, [this.HSIZE, topIndex + core.status.event.selection]);
     }
-    if (core.status.event.id=='action' && core.status.event.data.type=='text') {
-        core.doAction();
-        return;
+    if (keycode >= 49 && keycode <= 57) {
+        var index = keycode - 49;
+        if (index < length) {
+            callback.apply(this, [this.HSIZE, topIndex + index]);
+        }
     }
 }
 
-//////
-actions.prototype.clickCenterFly = function(x, y) {
-    if (x==core.status.event.data.x && y==core.status.event.data.y) {
+// 上下键调整选项
+actions.prototype._keyDownChoices = function (keycode) {
+    if (keycode == 38) {
+        core.status.event.selection--;
+        core.ui.drawChoices(core.status.event.ui.text, core.status.event.ui.choices);
+    }
+    if (keycode == 40) {
+        core.status.event.selection++;
+        core.ui.drawChoices(core.status.event.ui.text, core.status.event.ui.choices);
+    }
+}
+
+////// 点击中心对称飞行器时
+actions.prototype._clickCenterFly = function (x, y) {
+    var posX = core.status.event.data.posX, posY = core.status.event.data.posY;
+    core.ui.closePanel();
+    if (x == posX && y == posY) {
         if (core.canUseItem('centerFly')) {
             core.useItem('centerFly');
         }
@@ -738,11 +837,11 @@ actions.prototype.clickCenterFly = function(x, y) {
             core.drawTip('当前不能使用中心对称飞行器');
         }
     }
-    core.ui.closePanel();
 }
 
-actions.prototype.keyUpCenterFly = function (keycode) {
-    if (keycode==51 ||  keycode==13 || keycode==32 || keycode==67) {
+actions.prototype._keyUpCenterFly = function (keycode) {
+    core.ui.closePanel();
+    if (keycode == 51 || keycode == 13 || keycode == 32 || keycode == 67) {
         if (core.canUseItem('centerFly')) {
             core.useItem('centerFly');
         }
@@ -750,526 +849,534 @@ actions.prototype.keyUpCenterFly = function (keycode) {
             core.drawTip('当前不能使用中心对称飞行器');
         }
     }
-    core.ui.closePanel();
 }
 
-
 ////// 点击确认框时 //////
-actions.prototype.clickConfirmBox = function (x,y) {
-    if ((x == 4 || x == 5) && y == 7 && core.isset(core.status.event.data.yes))
+actions.prototype._clickConfirmBox = function (x, y) {
+    if ((x == this.HSIZE-2 || x == this.HSIZE-1) && y == this.HSIZE+1 && core.status.event.data.yes)
         core.status.event.data.yes();
-    if ((x == 7 || x == 8) && y == 7 && core.isset(core.status.event.data.no))
+    if ((x == this.HSIZE+2 || x == this.HSIZE+1) && y == this.HSIZE+1 && core.status.event.data.no)
         core.status.event.data.no();
 }
 
 ////// 键盘操作确认框时 //////
-actions.prototype.keyUpConfirmBox = function (keycode) {
-    if (keycode==37) {
-        core.status.event.selection=0;
+actions.prototype._keyUpConfirmBox = function (keycode) {
+    if (keycode == 37) {
+        core.status.event.selection = 0;
         core.ui.drawConfirmBox(core.status.event.ui, core.status.event.data.yes, core.status.event.data.no);
+        return;
     }
 
-    if (keycode==39) {
-        core.status.event.selection=1;
+    if (keycode == 39) {
+        core.status.event.selection = 1;
         core.ui.drawConfirmBox(core.status.event.ui, core.status.event.data.yes, core.status.event.data.no);
+        return;
     }
 
-    if (keycode==13 || keycode==32 || keycode==67) {
-        if (core.status.event.selection==0 && core.isset(core.status.event.data.yes)) {
-            core.status.event.selection=null;
+    if (keycode == 13 || keycode == 32 || keycode == 67) {
+        if (core.status.event.selection == 0 && core.status.event.data.yes) {
+            core.status.event.selection = null;
             core.status.event.data.yes();
+            return;
         }
-        if (core.status.event.selection==1 && core.isset(core.status.event.data.no)) {
-            core.status.event.selection=null;
+        if (core.status.event.selection == 1 && core.status.event.data.no) {
+            core.status.event.selection = null;
             core.status.event.data.no();
+            return;
         }
     }
 }
 
 ////// 自定义事件时的点击操作 //////
-actions.prototype.clickAction = function (x,y) {
+actions.prototype._clickAction = function (x, y) {
+    if (core.status.event.data.type == 'text') {
+
+        // 打字机效果显示全部文字
+        if (core.status.event.interval != null) {
+            core.insertAction({"type": "text", "text": core.status.event.ui, "showAll": true});
+        }
 
-    if (core.status.event.data.type=='text') {
         // 文字
         core.doAction();
         return;
     }
-    if (core.status.event.data.type=='wait') {
-        core.setFlag('type', 1);
-        core.setFlag('x', x);
-        core.setFlag('y', y);
-        core.status.route.push("input:"+(10000+100*x+y));
-        core.doAction();
-        return;
-    }
 
-    if (core.status.event.data.type=='choices') {
+    if (core.status.event.data.type == 'choices') {
         // 选项
         var data = core.status.event.data.current;
         var choices = data.choices;
-        if (choices.length==0) return;
-        if (x >= 5 && x <= 7) {
-            var topIndex = 6 - parseInt((choices.length - 1) / 2);
-            if (y>=topIndex && y<topIndex+choices.length) {
+        if (choices.length == 0) return;
+        if (x >= this.CHOICES_LEFT && x <= this.CHOICES_RIGHT) {
+            var topIndex = this.HSIZE - parseInt((choices.length - 1) / 2) + (core.status.event.ui.offset || 0);
+            if (y >= topIndex && y < topIndex + choices.length) {
                 // 选择
-                core.status.route.push("choices:"+(y-topIndex));
-                core.insertAction(choices[y-topIndex].action);
+                core.status.route.push("choices:" + (y - topIndex));
+                core.insertAction(choices[y - topIndex].action);
                 core.doAction();
             }
         }
+        return;
+    }
+
+    if (core.status.event.data.type == 'confirm') {
+        if ((x == this.HSIZE-2 || x == this.HSIZE-1) && y == this.HSIZE+1) {
+            core.status.route.push("choices:0");
+            core.insertAction(core.status.event.ui.yes);
+            core.doAction();
+        }
+        else if ((x == this.HSIZE+2 || x == this.HSIZE+1) && y == this.HSIZE+1) {
+            core.status.route.push("choices:1");
+            core.insertAction(core.status.event.ui.no);
+            core.doAction();
+        }
+        return;
     }
 }
 
 ////// 自定义事件时，按下某个键的操作 //////
-actions.prototype.keyDownAction = function (keycode) {
-    if (core.status.event.data.type=='choices') {
-        var data = core.status.event.data.current;
-        var choices = data.choices;
-        if (choices.length>0) {
-            if (keycode==38) {
-                core.status.event.selection--;
-                core.ui.drawChoices(core.status.event.ui.text, core.status.event.ui.choices);
-            }
-            if (keycode==40) {
-                core.status.event.selection++;
-                core.ui.drawChoices(core.status.event.ui.text, core.status.event.ui.choices);
-            }
-        }
+actions.prototype._keyDownAction = function (keycode) {
+    if (core.status.event.data.type == 'choices') {
+        this._keyDownChoices(keycode);
+        return;
+    }
+    if (core.status.event.data.type == 'confirm' && (keycode == 37 || keycode == 39)) {
+        core.status.event.selection = 1 - core.status.event.selection;
+        core.drawConfirmBox(core.status.event.ui.text);
+        return;
     }
 }
 
 ////// 自定义事件时，放开某个键的操作 //////
-actions.prototype.keyUpAction = function (keycode) {
-    if (core.status.event.data.type=='text' && (keycode==13 || keycode==32 || keycode==67)) {
+actions.prototype._keyUpAction = function (keycode) {
+    if (core.status.event.data.type == 'text' && (keycode == 13 || keycode == 32 || keycode == 67)) {
+        // 打字机效果显示全部文字
+        if (core.status.event.interval != null) {
+            core.insertAction({"type": "text", "text": core.status.event.ui, "showAll": true});
+        }
         core.doAction();
         return;
     }
-    if (core.status.event.data.type=='wait') {
+    if (core.status.event.data.type == 'wait') {
         core.setFlag('type', 0);
         core.setFlag('keycode', keycode);
-        core.status.route.push("input:"+keycode);
+        core.status.route.push("input:" + keycode);
         core.doAction();
         return;
     }
-    if (core.status.event.data.type=='choices') {
+    if (core.status.event.data.type == 'choices') {
         var data = core.status.event.data.current;
         var choices = data.choices;
-        if (choices.length>0) {
-            if (keycode==13 || keycode==32 || keycode==67) {
-                core.status.route.push("choices:"+core.status.event.selection);
-                core.insertAction(choices[core.status.event.selection].action);
-                core.doAction();
-            }
+        if (choices.length > 0) {
+            this._selectChoices(choices.length, keycode, this._clickAction);
         }
+        return;
+    }
+    if (core.status.event.data.type == 'confirm'&& (keycode == 13 || keycode == 32 || keycode == 67)) {
+        core.status.route.push("choices:" + core.status.event.selection);
+        if (core.status.event.selection == 0)
+            core.insertAction(core.status.event.ui.yes);
+        else core.insertAction(core.status.event.ui.no);
+        core.doAction();
+        return;
     }
 }
 
 ////// 怪物手册界面的点击操作 //////
-actions.prototype.clickBook = function(x,y) {
+actions.prototype._clickBook = function (x, y) {
     // 上一页
-    if ((x == 3 || x == 4) && y == 12) {
-        core.ui.drawBook(core.status.event.data - 6);
+    if ((x == this.HSIZE-2 || x == this.HSIZE-3) && y == this.LAST) {
+        core.ui.drawBook(core.status.event.data - this.HSIZE);
         return;
     }
     // 下一页
-    if ((x == 8 || x == 9) && y == 12) {
-        core.ui.drawBook(core.status.event.data + 6);
+    if ((x == this.HSIZE+2 || x == this.HSIZE+3) && y == this.LAST) {
+        core.ui.drawBook(core.status.event.data + this.HSIZE);
         return;
     }
     // 返回
-    if (x>=10 && x<=12 && y==12) {
-        if (core.status.event.selection==null)
-            core.ui.closePanel();
-        else {
-            core.status.boxAnimateObjs = [];
-            core.ui.drawMaps(core.status.event.selection);
+    if (x >= this.LAST-2 && y == this.LAST) {
+        if (core.events.recoverEvents(core.status.event.interval)) {
+            return;
         }
+        else if (core.status.event.ui != null) {
+            core.status.boxAnimateObjs = [];
+            core.ui.drawMaps(core.status.event.ui);
+        }
+        else core.ui.closePanel();
         return;
     }
     // 怪物信息
     var data = core.status.event.data;
-    if (core.isset(data) && y<12) {
-        var page=parseInt(data/6);
-        var index=6*page+parseInt(y/2);
-        core.ui.drawBook(index);
-        core.ui.drawBookDetail(index);
+    if (data != null && y < this.LAST) {
+        var pageinfo = core.ui._drawBook_pageinfo();
+        var per_page = pageinfo.per_page, page = parseInt(data / per_page);
+        var u = this.LAST / per_page;
+        for (var i = 0; i < per_page; ++i) {
+            if (y >= u*i && y < u*(i+1)) {
+                var index = per_page * page + i;
+                core.ui.drawBook(index);
+                core.ui.drawBookDetail(index);
+                break;
+            }
+        }
+        return;
     }
     return;
 }
 
 ////// 怪物手册界面时，按下某个键的操作 //////
-actions.prototype.keyDownBook = function (keycode) {
-    if (keycode==37) core.ui.drawBook(core.status.event.data-6);
-    if (keycode==38) core.ui.drawBook(core.status.event.data-1);
-    if (keycode==39) core.ui.drawBook(core.status.event.data+6);
-    if (keycode==40) core.ui.drawBook(core.status.event.data+1);
-    if (keycode==33) core.ui.drawBook(core.status.event.data-6);
-    if (keycode==34) core.ui.drawBook(core.status.event.data+6);
+actions.prototype._keyDownBook = function (keycode) {
+    if (keycode == 37) core.ui.drawBook(core.status.event.data - this.HSIZE);
+    if (keycode == 38) core.ui.drawBook(core.status.event.data - 1);
+    if (keycode == 39) core.ui.drawBook(core.status.event.data + this.HSIZE);
+    if (keycode == 40) core.ui.drawBook(core.status.event.data + 1);
+    if (keycode == 33) core.ui.drawBook(core.status.event.data - this.HSIZE);
+    if (keycode == 34) core.ui.drawBook(core.status.event.data + this.HSIZE);
     return;
 }
 
 ////// 怪物手册界面时，放开某个键的操作 //////
-actions.prototype.keyUpBook = function (keycode) {
-    if (keycode==27 || keycode==88) {
-        if (core.status.event.selection==null)
-            core.ui.closePanel();
-        else {
-            core.status.boxAnimateObjs = [];
-            core.ui.drawMaps(core.status.event.selection);
+actions.prototype._keyUpBook = function (keycode) {
+    if (keycode == 27 || keycode == 88) {
+        if (core.events.recoverEvents(core.status.event.interval)) {
+            return;
         }
+        else if (core.status.event.ui != null) {
+            core.status.boxAnimateObjs = [];
+            core.ui.drawMaps(core.status.event.ui);
+        }
+        else core.ui.closePanel();
         return;
     }
-    if (keycode==13 || keycode==32 || keycode==67) {
-        var data=core.status.event.data;
-        if (core.isset(data)) {
-            this.clickBook(6, 2*(data%6));
+    if (keycode == 13 || keycode == 32 || keycode == 67) {
+        var data = core.status.event.data;
+        if (data != null) {
+            core.ui.drawBookDetail(data);
         }
         return;
     }
 }
 
 ////// 怪物手册属性显示界面时的点击操作 //////
-actions.prototype.clickBookDetail = function () {
+actions.prototype._clickBookDetail = function () {
     core.clearMap('data');
     core.status.event.id = 'book';
 }
 
 ////// 楼层传送器界面时的点击操作 //////
-actions.prototype.clickFly = function(x,y) {
-    if ((x==10 || x==11) && y==9) core.ui.drawFly(core.status.event.data-1);
-    if ((x==10 || x==11) && y==5) core.ui.drawFly(core.status.event.data+1);
-    if ((x==10 || x==11) && y==10) core.ui.drawFly(core.status.event.data-10);
-    if ((x==10 || x==11) && y==4) core.ui.drawFly(core.status.event.data+10);
-    if (x>=5 && x<=7 && y==12) core.ui.closePanel();
-    if (x>=0 && x<=9 && y>=3 && y<=11) {
-        var index=core.status.hero.flyRange.indexOf(core.status.floorId);
-        var stair=core.status.event.data<index?"upFloor":"downFloor";
-        if (core.status.event.data==index && core.floors[core.status.floorId].underGround)
-            stair = "upFloor";
-        var floorId=core.status.event.data;
-        var toFloor = core.status.hero.flyRange[floorId];
-        core.status.route.push("fly:"+toFloor);
-        core.ui.closePanel();
-        core.changeFloor(toFloor, stair);
-    }
+actions.prototype._clickFly = function (x, y) {
+    if ((x == this.SIZE-2 || x == this.SIZE-3) && y == this.HSIZE+3) core.ui.drawFly(this._getNextFlyFloor(-1));
+    if ((x == this.SIZE-2 || x == this.SIZE-3) && y == this.HSIZE-1) core.ui.drawFly(this._getNextFlyFloor(1));
+    if ((x == this.SIZE-2 || x == this.SIZE-3) && y == this.HSIZE+4) core.ui.drawFly(this._getNextFlyFloor(-10));
+    if ((x == this.SIZE-2 || x == this.SIZE-3) && y == this.HSIZE-2) core.ui.drawFly(this._getNextFlyFloor(10));
+    if (x >= this.HSIZE-1 && x <= this.HSIZE+1 && y == this.LAST) core.ui.closePanel();
+    if (x >= 0 && x <= this.HSIZE+3 && y >= 3 && y <= this.LAST - 1)
+        core.flyTo(core.floorIds[core.status.event.data]);
     return;
 }
 
 ////// 楼层传送器界面时，按下某个键的操作 //////
-actions.prototype.keyDownFly = function (keycode) {
-    if (keycode==37) core.ui.drawFly(core.status.event.data-10);
-    else if ( keycode==38) core.ui.drawFly(core.status.event.data+1);
-    else if (keycode==39) core.ui.drawFly(core.status.event.data+10);
-    else if (keycode==40) core.ui.drawFly(core.status.event.data-1);
+actions.prototype._keyDownFly = function (keycode) {
+    if (keycode == 37) core.ui.drawFly(this._getNextFlyFloor(-10));
+    else if (keycode == 38) core.ui.drawFly(this._getNextFlyFloor(1));
+    else if (keycode == 39) core.ui.drawFly(this._getNextFlyFloor(10));
+    else if (keycode == 40) core.ui.drawFly(this._getNextFlyFloor(-1));
     return;
 }
 
+actions.prototype._getNextFlyFloor = function (delta, index) {
+    if (index == null) index = core.status.event.data;
+    if (delta == 0) return index;
+    var sign = Math.sign(delta);
+    delta = Math.abs(delta);
+    var ans = index;
+    while (true) {
+        index += sign;
+        if (index < 0 || index >= core.floorIds.length) break;
+        var floorId = core.floorIds[index];
+        if (core.status.maps[floorId].canFlyTo && core.hasVisitedFloor(floorId)) {
+            delta--;
+            ans = index;
+        }
+        if (delta == 0) break;
+    }
+    return ans;
+}
+
 ////// 楼层传送器界面时，放开某个键的操作 //////
-actions.prototype.keyUpFly = function (keycode) {
-    if (keycode==71 || keycode==27 || keycode==88)
+actions.prototype._keyUpFly = function (keycode) {
+    if (keycode == 71 || keycode == 27 || keycode == 88)
         core.ui.closePanel();
-    if (keycode==13 || keycode==32 || keycode==67)
-        this.clickFly(5,5);
+    if (keycode == 13 || keycode == 32 || keycode == 67)
+        this._clickFly(this.HSIZE-1, this.HSIZE-1);
     return;
 }
 
 ////// 查看地图界面时的点击操作 //////
-actions.prototype.clickViewMaps = function (x,y) {
-    if (!core.isset(core.status.event.data)) {
+actions.prototype._clickViewMaps = function (x, y) {
+    if (core.status.event.data == null) {
         core.ui.drawMaps(core.floorIds.indexOf(core.status.floorId));
         return;
     }
-
     var now = core.floorIds.indexOf(core.status.floorId);
     var index = core.status.event.data.index;
     var cx = core.status.event.data.x, cy = core.status.event.data.y;
-    var floorId = core.floorIds[index], mw = core.floors[floorId].width||13, mh = core.floors[floorId].height||13;
+    var floorId = core.floorIds[index], mw = core.floors[floorId].width, mh = core.floors[floorId].height;
+    var per = this.HSIZE - 4;
 
-    if (x>=2 && x<=10 && y<=1 && mh>13) {
-        core.ui.drawMaps(index, cx, cy-1);
+    if (x <= per - 2 && y <= per - 2) {
+        core.status.event.data.damage = !core.status.event.data.damage;
+        core.ui.drawMaps(index, cx, cy);
         return;
     }
-    if (x>=2 && x<=10 && y>=11 && mh>13) {
-        core.ui.drawMaps(index, cx, cy+1);
+    if (x <= per - 2 && y >= this.SIZE + 1 - per) {
+        core.status.event.data.paint = !core.status.event.data.paint;
+        core.ui.drawMaps(index, cx, cy);
         return;
     }
-    if (x<=1 && y>=2 && y<=10) {
-        core.ui.drawMaps(index, cx-1, cy);
-        return;
-    }
-    if (x>=11 && y>=2 && y<=10) {
-        core.ui.drawMaps(index, cx+1, cy);
+    if (x >= this.SIZE + 1 - per && y <= per - 2) {
+        core.status.event.data.all = !core.status.event.data.all;
+        core.ui.drawMaps(index, cx, cy);
         return;
     }
 
-    if(x>=2 && x<=10 && y<=4) {
+    if (x >= per && x <= this.LAST - per && y <= per - 1 && mh > this.SIZE) {
+        core.ui.drawMaps(index, cx, cy - 1);
+        return;
+    }
+    if (x >= per && x <= this.LAST - per && y >= this.SIZE - per && mh > this.SIZE) {
+        core.ui.drawMaps(index, cx, cy + 1);
+        return;
+    }
+    if (x <= per - 1 && y >= per && y <= this.LAST - per) {
+        core.ui.drawMaps(index, cx - 1, cy);
+        return;
+    }
+    if (x >= this.SIZE - per && y >= per && y <= this.LAST - per) {
+        core.ui.drawMaps(index, cx + 1, cy);
+        return;
+    }
+
+    if (y <= this.HSIZE - 2 && (mh == this.SIZE || (x >= per && x <= this.LAST - per))) {
         index++;
-        while (index<core.floorIds.length && index!=now && core.floors[core.floorIds[index]].cannotViewMap)
+        while (index < core.floorIds.length && index != now && core.status.maps[core.floorIds[index]].cannotViewMap)
             index++;
-        if (index<core.floorIds.length)
+        if (index < core.floorIds.length)
             core.ui.drawMaps(index);
+        return;
     }
-    else if (x>=2 && x<=10 && y>=8) {
+    if (y >= this.HSIZE + 2 && (mh == this.SIZE || (x >= per && x <= this.LAST - per))) {
         index--;
-        while (index>=0 && index!=now && core.floors[core.floorIds[index]].cannotViewMap)
+        while (index >= 0 && index != now && core.status.maps[core.floorIds[index]].cannotViewMap)
             index--;
-        if (index>=0)
+        if (index >= 0)
             core.ui.drawMaps(index);
+        return;
     }
-    else if (x>=2 && x<=10 && y>=5 && y<=7) {
+    if (x >= per && x <= this.LAST - per && y >= this.HSIZE - 1 && y <= this.HSIZE + 1) {
         core.clearMap('data');
-        core.setOpacity('data', 1);
         core.ui.closePanel();
+        return;
     }
 }
 
 ////// 查看地图界面时，按下某个键的操作 //////
-actions.prototype.keyDownViewMaps = function (keycode) {
-    if (!core.isset(core.status.event.data)) return;
+actions.prototype._keyDownViewMaps = function (keycode) {
+    if (core.status.event.data == null) return;
 
-    var floorId = core.floorIds[core.status.event.data.index], mh = core.floors[floorId].height||13;
+    var floorId = core.floorIds[core.status.event.data.index], mh = core.floors[floorId].height;
 
-    if (keycode==38||keycode==33) this.clickViewMaps(6, 3);
-    if (keycode==40||keycode==34) this.clickViewMaps(6, 9);
-    if (keycode==87 && mh>13) this.clickViewMaps(6,0);
-    if (keycode==65) this.clickViewMaps(0,6);
-    if (keycode==83 && mh>13) this.clickViewMaps(6,12);
-    if (keycode==68) this.clickViewMaps(12,6);
+    if (keycode == 38 || keycode == 33) this._clickViewMaps(this.HSIZE, this.HSIZE - 3);
+    if (keycode == 40 || keycode == 34) this._clickViewMaps(this.HSIZE, this.HSIZE + 3);
+    if (keycode == 87 && mh > this.SIZE) this._clickViewMaps(this.HSIZE, 0);
+    if (keycode == 65) this._clickViewMaps(0, this.HSIZE);
+    if (keycode == 83 && mh > this.SIZE) this._clickViewMaps(this.HSIZE, this.LAST);
+    if (keycode == 68) this._clickViewMaps(this.LAST, this.HSIZE);
     return;
 }
 
 ////// 查看地图界面时，放开某个键的操作 //////
-actions.prototype.keyUpViewMaps = function (keycode) {
-    if (!core.isset(core.status.event.data)) {
+actions.prototype._keyUpViewMaps = function (keycode) {
+    if (core.status.event.data == null) {
         core.ui.drawMaps(core.floorIds.indexOf(core.status.floorId));
         return;
     }
 
-    if (keycode==27 || keycode==13 || keycode==32 || (!core.status.replay.replaying && keycode==67)) {
+    if (keycode == 27 || keycode == 13 || keycode == 32 || (!core.isReplaying() && keycode == 67)) {
         core.clearMap('data');
-        core.setOpacity('data', 1);
         core.ui.closePanel();
+        return;
     }
-    if (keycode==88 || (core.status.replay.replaying && keycode==67)) {
-        if (core.isset(core.status.replay)&&core.status.replay.replaying) {
+    if (keycode == 86) {
+        core.status.event.data.damage = !core.status.event.data.damage;
+        core.ui.drawMaps(core.status.event.data);
+        return;
+    }
+    if (keycode == 90) {
+        core.status.event.data.all = !core.status.event.data.all;
+        core.ui.drawMaps(core.status.event.data);
+        return;
+    }
+    if (keycode == 77) {
+        core.status.event.data.paint = !core.status.event.data.paint;
+        core.ui.drawMaps(core.status.event.data);
+        return;
+    }
+    if (keycode == 88 || (core.isReplaying() && keycode == 67)) {
+        if (core.isReplaying()) {
             core.bookReplay();
         } else {
             core.openBook(false);
         }
+        return;
     }
     return;
 }
 
 ////// 商店界面时的点击操作 //////
-actions.prototype.clickShop = function(x,y) {
+actions.prototype._clickShop = function (x, y) {
     var shop = core.status.event.data.shop;
     var choices = shop.choices;
-    if (x >= 5 && x <= 7) {
-        var topIndex = 6 - parseInt(choices.length / 2);
-        if (y>=topIndex && y<topIndex+choices.length) {
-
-            core.status.event.selection=y-topIndex;
-
-            var money = core.getStatus('money'), experience = core.getStatus('experience');
-            var times = shop.times, need = eval(shop.need);
-            var use = shop.use;
-            var use_text = use=='money'?"金币":"经验";
-
-            var choice = choices[y-topIndex];
-            if (core.isset(choice.need))
-                need = eval(choice.need);
-
-            if (need > eval(use)) {
-                core.drawTip("你的"+use_text+"不足");
-                return false;
-            }
-
-            core.status.event.data.actions.push(y-topIndex);
-
-            eval(use+'-='+need);
-            core.setStatus('money', money);
-            core.setStatus('experience', experience);
-
-            // 更新属性
-            choice.effect.split(";").forEach(function (t) {
-                core.doEffect(t);
-            });
-            core.updateStatusBar();
-            shop.times++;
-            core.events.openShop(core.status.event.data.id);
+    if (x >= this.CHOICES_LEFT && x <= this.CHOICES_RIGHT) {
+        var topIndex = this.HSIZE - parseInt(choices.length / 2) + (core.status.event.ui.offset || 0);
+        if (y >= topIndex && y < topIndex + choices.length) {
+            return core.events._useShop(shop, y - topIndex);
         }
         // 离开
-        else if (y==topIndex+choices.length) {
-            if (core.status.event.data.actions.length>0) {
-                core.status.route.push("shop:"+core.status.event.data.id+":"+core.status.event.data.actions.join(""));
-            }
-
-            core.status.event.data.actions = [];
-            core.status.boxAnimateObjs = [];
-            if (core.status.event.data.fromList)
-                core.ui.drawQuickShop();
-            else core.ui.closePanel();
+        else if (y == topIndex + choices.length) {
+            core.events._exitShop();
         }
         else return false;
     }
     return true;
 }
 
-////// 商店界面时，按下某个键的操作 //////
-actions.prototype.keyDownShop = function (keycode) {
-    if (keycode==38) {
-        core.status.event.selection--;
-        core.ui.drawChoices(core.status.event.ui.text, core.status.event.ui.choices);
-    }
-    if (keycode==40) {
-        core.status.event.selection++;
-        core.ui.drawChoices(core.status.event.ui.text, core.status.event.ui.choices);
+actions.prototype._keyDownShop = function (keycode) {
+    // 商店界面长按空格连续购买
+    if (keycode == 32) {
+        this._selectChoices(core.status.event.data.shop.choices.length + 1, keycode, this._clickShop);
+        return;
     }
+    this._keyDownChoices(keycode);
 }
 
 ////// 商店界面时，放开某个键的操作 //////
-actions.prototype.keyUpShop = function (keycode) {
-    if (keycode==27 || keycode==88) {
-        if (core.status.event.data.actions.length>0) {
-            core.status.route.push("shop:"+core.status.event.data.id+":"+core.status.event.data.actions.join(""));
-        }
-
-        core.status.event.data.actions = [];
-
-        core.status.boxAnimateObjs = [];
-
-        if (core.status.event.data.fromList)
-            core.ui.drawQuickShop();
-        else
-            core.ui.closePanel();
+actions.prototype._keyUpShop = function (keycode) {
+    if (keycode == 27 || keycode == 88) {
+        core.events._exitShop();
         return;
     }
-    var shop = core.status.event.data.shop;
-    var choices = shop.choices;
-    if (keycode==13 || keycode==32 || keycode==67) {
-        var topIndex = 6 - parseInt(choices.length / 2);
-        this.clickShop(6, topIndex+core.status.event.selection);
+    if (keycode != 32) {
+        this._selectChoices(core.status.event.data.shop.choices.length + 1, keycode, this._clickShop);
+        return;
     }
     return;
 }
 
 ////// 快捷商店界面时的点击操作 //////
-actions.prototype.clickQuickShop = function(x, y) {
-    var shopList = core.status.shops, keys = Object.keys(shopList);
-    if (x >= 5 && x <= 7) {
-        var topIndex = 6 - parseInt(keys.length / 2);
-        if (y>=topIndex && y<topIndex+keys.length) {
+actions.prototype._clickQuickShop = function (x, y) {
+    var keys = Object.keys(core.status.shops).filter(function (shopId) {
+        return core.status.shops[shopId].visited || !core.status.shops[shopId].mustEnable
+    });
+
+    if (x >= this.CHOICES_LEFT && x <= this.CHOICES_RIGHT) {
+        var topIndex = this.HSIZE - parseInt(keys.length / 2) + (core.status.event.ui.offset || 0);
+        if (y >= topIndex && y < topIndex + keys.length) {
             var reason = core.events.canUseQuickShop(keys[y - topIndex]);
-            if (core.isset(reason)) {
+            if (!core.flags.enableDisabledShop && reason) {
                 core.drawText(reason);
                 return;
             }
             core.events.openShop(keys[y - topIndex], true);
-            if (core.status.event.id=='shop')
+            if (core.status.event.id == 'shop')
                 core.status.event.data.fromList = true;
         }
         // 离开
-        else if (y==topIndex+keys.length)
+        else if (y == topIndex + keys.length)
             core.ui.closePanel();
-    }
-}
-
-////// 快捷商店界面时，按下某个键的操作 //////
-actions.prototype.keyDownQuickShop = function (keycode) {
-    if (keycode==38) {
-        core.status.event.selection--;
-        core.ui.drawChoices(core.status.event.ui.text, core.status.event.ui.choices);
-    }
-    if (keycode==40) {
-        core.status.event.selection++;
-        core.ui.drawChoices(core.status.event.ui.text, core.status.event.ui.choices);
-    }
-}
-
-////// 快捷商店界面时，放开某个键的操作 //////
-actions.prototype.keyUpQuickShop = function (keycode) {
-    if (keycode==27 || keycode==75 || keycode==88 || keycode==86) {
-        core.ui.closePanel();
         return;
     }
-    var shopList = core.status.shops, keys = Object.keys(shopList);
-    if (keycode==13 || keycode==32 || keycode==67) {
-        var topIndex = 6 - parseInt(keys.length / 2);
-        this.clickQuickShop(6, topIndex+core.status.event.selection);
-    }
     return;
 }
 
-////// 工具栏界面时的点击操作 //////
-actions.prototype.clickToolbox = function(x,y) {
-    // 返回
-    if (x>=10 && x<=12 && y==12) {
+////// 快捷商店界面时，放开某个键的操作 //////
+actions.prototype._keyUpQuickShop = function (keycode) {
+    if (keycode == 27 || keycode == 75 || keycode == 88 || keycode == 86) {
         core.ui.closePanel();
         return;
     }
-    /*
-    if (x>=10 && x<=12 && y<=1) {
-        if (!core.isset(core.status.event.data)) return;
-        if (!core.flags.enableDeleteItem) {
-            core.drawTip("不支持删除道具！");
-            return;
-        }
-        core.removeItem(core.status.event.data);
-        core.status.event.data = null;
-        core.ui.drawToolbox();
+    var keys = Object.keys(core.status.shops).filter(function (shopId) {
+        return core.status.shops[shopId].visited || !core.status.shops[shopId].mustEnable
+    });
+    this._selectChoices(keys.length + 1, keycode, this._clickQuickShop);
+    return;
+}
+
+////// 工具栏界面时的点击操作 //////
+actions.prototype._clickToolbox = function (x, y) {
+    // 装备栏
+    if (x >= this.LAST - 2 && y == 0) {
+        core.ui.closePanel();
+        core.openEquipbox();
         return;
     }
-    */
-
-    // 当前页面
-    var page = parseInt((core.status.event.selection%1000)/12)+1;
-
-    // 上一页
-    if ((x == 3 || x == 4) && y == 12) {
-        if (page>1) {
-            core.ui.drawToolbox(core.status.event.selection-12);
-        }
+    if (x >= this.LAST - 2 && y == this.LAST) {
+        core.ui.closePanel();
         return;
     }
+
+    var toolsPage = core.status.event.data.toolsPage;
+    var constantsPage = core.status.event.data.constantsPage;
+    // 上一页
+    if (x == this.HSIZE-2 || x == this.HSIZE-3) {
+        if (y == this.LAST - 5 && toolsPage > 1) {
+            core.status.event.data.toolsPage--;
+            core.ui.drawToolbox(core.status.event.selection);
+        }
+        if (y == this.LAST && constantsPage > 1) {
+            core.status.event.data.constantsPage--;
+            core.ui.drawToolbox(core.status.event.selection);
+        }
+    }
     // 下一页
-    if ((x == 8 || x == 9) && y == 12) {
-        var toolPage = Math.ceil(Object.keys(core.status.hero.items.tools).length/12),
-            constantPage = Math.ceil(Object.keys(core.status.hero.items.constants).length/12);
-        if (page<toolPage) {
-            core.ui.drawToolbox(12*page);
+    if (x == this.HSIZE+2 || x == this.HSIZE+3) {
+        if (y == this.LAST - 5 && toolsPage < Math.ceil(Object.keys(core.status.hero.items.tools).length / this.LAST)) {
+            core.status.event.data.toolsPage++;
+            core.ui.drawToolbox(core.status.event.selection);
         }
-        else if (page<constantPage) {
-            core.ui.drawToolbox(1000+12*page);
+        if (y == this.LAST && constantsPage < Math.ceil(Object.keys(core.status.hero.items.constants).length / this.LAST)) {
+            core.status.event.data.constantsPage++;
+            core.ui.drawToolbox(core.status.event.selection);
         }
-        return;
     }
 
-    var index=parseInt(12*(page-1)+x/2);
-    if (y==4) index+=0;
-    else if (y==6) index+=6;
-    else if (y==9) index+=1000;
-    else if (y==11) index+=1006;
-    else index=-1;
-
-    if (index>=0)
-        this.clickToolboxIndex(index);
+    var index = parseInt(x / 2);
+    if (y == this.LAST - 8) index += 0;
+    else if (y == this.LAST - 6) index += this.HSIZE;
+    else if (y == this.LAST - 3) index += this.LAST;
+    else if (y == this.LAST - 1) index += this.LAST + this.HSIZE;
+    else index = -1;
+    if (index >= 0)
+        this._clickToolboxIndex(index);
 }
 
 ////// 选择工具栏界面中某个Index后的操作 //////
-actions.prototype.clickToolboxIndex = function(index) {
+actions.prototype._clickToolboxIndex = function (index) {
     var items = null;
-    var ii=index;
-    if (ii<1000)
+    var select;
+    if (index < this.LAST) {
+        select = index + this.LAST * (core.status.event.data.toolsPage - 1);
         items = Object.keys(core.status.hero.items.tools).sort();
+    }
     else {
-        ii-=1000;
+        select = index % this.LAST + this.LAST * (core.status.event.data.constantsPage - 1);
         items = Object.keys(core.status.hero.items.constants).sort();
     }
-    if (items==null) return;
-    if (ii>=items.length) return;
-    var itemId=items[ii];
-    if (itemId==core.status.event.data) {
-        core.events.useItem(itemId);
+    if (items == null) return;
+    if (select >= items.length) return;
+    var itemId = items[select];
+    if (itemId == core.status.event.data.selectId) {
+        core.events.tryUseItem(itemId);
     }
     else {
         core.ui.drawToolbox(index);
@@ -1277,456 +1384,636 @@ actions.prototype.clickToolboxIndex = function(index) {
 }
 
 ////// 工具栏界面时，按下某个键的操作 //////
-actions.prototype.keyDownToolbox = function (keycode) {
-    if (!core.isset(core.status.event.data)) return;
+actions.prototype._keyDownToolbox = function (keycode) {
+    if (core.status.event.data == null) return;
+
+    var last_index = this.LAST - 1;
 
     var tools = Object.keys(core.status.hero.items.tools).sort();
     var constants = Object.keys(core.status.hero.items.constants).sort();
-    var index=core.status.event.selection;
-    var page=parseInt(index%1000/12), offset=12*page;
+    var index = core.status.event.selection;
+    var toolsPage = core.status.event.data.toolsPage;
+    var constantsPage = core.status.event.data.constantsPage;
+    var toolsTotalPage = Math.ceil(tools.length / this.LAST);
+    var constantsTotalPage = Math.ceil(constants.length / this.LAST);
+    var toolsLastIndex = toolsPage < toolsTotalPage ? last_index : (tools.length + last_index) % this.LAST;
+    var constantsLastIndex = this.LAST + (constantsPage < constantsTotalPage ? last_index : (constants.length + last_index) % this.LAST);
 
-    if (keycode==37) { // left
-        if ((index>0 && index<1000) || index>1000) {
-            this.clickToolboxIndex(index-1);
-            return;
+    if (keycode == 37) { // left
+        if (index == 0) { // 处理向前翻页
+            if (toolsPage > 1) {
+                core.status.event.data.toolsPage--;
+                index = last_index;
+            }
+            else return; // 第一页不向前翻
         }
-        if (index==1000 && tools.length>0) {
-            this.clickToolboxIndex(tools.length-1);
-            return;
+        else if (index == this.LAST) {
+            if (constantsPage == 1) {
+                if (toolsTotalPage == 0) return;
+                core.status.event.data.toolsPage = toolsTotalPage;
+                index = (tools.length + last_index) % this.LAST;
+            }
+            else {
+                core.status.event.data.constantsPage--;
+                index = 2 * this.LAST - 1;
+            }
         }
+        else index -= 1;
+        this._clickToolboxIndex(index);
+        return;
     }
-    if (keycode==38) { // up
-        if ((index>offset+5 && index<1000) || index>offset+1005) {
-            this.clickToolboxIndex(index-6);
-            return;
-        }
-        if (index>=offset+1000 && index<=offset+1005) {
-            if (tools.length>offset+6) {
-                this.clickToolboxIndex(Math.min(tools.length-1, index-1000+6));
-            }
-            else if (tools.length>offset) {
-                this.clickToolboxIndex(Math.min(tools.length-1, index-1000));
-            }
-            return;
+    if (keycode == 38) { // up
+        if (index >= this.LAST && index < this.LAST + this.HSIZE) { // 进入tools
+            if (toolsTotalPage == 0) return;
+            if (toolsLastIndex >= this.HSIZE) index = Math.min(toolsLastIndex, index - this.HSIZE);
+            else index = Math.min(toolsLastIndex, index - this.LAST);
         }
+        else if (index < this.HSIZE) return; // 第一行没有向上
+        else index -= this.HSIZE;
+        this._clickToolboxIndex(index);
+        return;
     }
-    if (keycode==39) { // right
-        if ((index<tools.length-1) || (index>=1000 && index<constants.length+1000)) {
-            this.clickToolboxIndex(index+1);
-            return;
+    if (keycode == 39) { // right
+        if (toolsPage < toolsTotalPage && index == last_index) {
+            core.status.event.data.toolsPage++;
+            index = 0;
         }
-        if (index==tools.length-1 && constants.length>0) {
-            this.clickToolboxIndex(1000);
-            return;
+        else if (constantsPage < constantsTotalPage && index == 2 * this.LAST - 1) {
+            core.status.event.data.constantsPage++;
+            index = this.LAST;
         }
+        else if (index == toolsLastIndex) {
+            if (constantsTotalPage == 0) return;
+            core.status.event.data.constantsPage = 1;
+            index = this.LAST;
+        }
+        else if (index == constantsLastIndex) // 一个物品无操作
+            return;
+        else index++;
+        this._clickToolboxIndex(index);
+        return;
     }
-    if (keycode==40) { // down
-        if (index<=offset+5) {
-            if (tools.length>offset+6) {
-                this.clickToolboxIndex(Math.min(tools.length-1, index+6));
-            }
-            else if (constants.length>offset) {
-                this.clickToolboxIndex(1000+Math.min(constants.length-1, index));
-            }
-            return;
+    if (keycode == 40) { // down
+        var nextIndex = null;
+        if (index < this.HSIZE) {
+            if (toolsLastIndex >= this.HSIZE) nextIndex = Math.min(toolsLastIndex, index + this.HSIZE);
+            else index += this.HSIZE;
         }
-        if (index>offset+5 && index<offset+1000 && constants.length>offset) {
-            this.clickToolboxIndex(1000+Math.min(constants.length-1, index-6));
-            return;
+        if (nextIndex == null && index < this.LAST) {
+            if (constantsTotalPage == 0) return;
+            nextIndex = Math.min(index + this.HSIZE, constantsLastIndex);
         }
-        if (index>=offset+1000 && index<=offset+1005 && constants.length>offset+6) {
-            this.clickToolboxIndex(Math.min(1000+constants.length-1, index+6));
-            return;
+        if (nextIndex == null && index < this.LAST + this.HSIZE) {
+            if (constantsLastIndex >= this.LAST + this.HSIZE)
+                nextIndex = Math.min(constantsLastIndex, index + this.HSIZE);
         }
+        if (nextIndex != null) {
+            this._clickToolboxIndex(nextIndex);
+        }
+        return;
     }
 }
 
 ////// 工具栏界面时，放开某个键的操作 //////
-actions.prototype.keyUpToolbox = function (keycode) {
-    if (keycode==84 || keycode==27 || keycode==88) {
+actions.prototype._keyUpToolbox = function (keycode) {
+    if (keycode == 81) {
+        core.ui.closePanel();
+        core.openEquipbox();
+        return;
+    }
+    if (keycode == 84 || keycode == 27 || keycode == 88) {
         core.ui.closePanel();
         return;
     }
-    if (!core.isset(core.status.event.data)) return;
+    if (core.status.event.data == null) return;
 
-    if (keycode==13 || keycode==32 || keycode==67) {
-        this.clickToolboxIndex(core.status.event.selection);
+    if (keycode == 13 || keycode == 32 || keycode == 67) {
+        this._clickToolboxIndex(core.status.event.selection);
         return;
     }
-
-    /*
-    if (keycode==46) { // delete
-        if (!core.isset(core.status.event.data)) return;
-        if (!core.flags.enableDeleteItem) {
-            core.drawTip("不支持删除道具！");
-            return;
-        }
-        core.removeItem(core.status.event.data);
-        core.status.event.data = null;
-        core.ui.drawToolbox();
-        return;
-    }
-    */
-
 }
 
-////// 存读档界面时的点击操作 //////
-actions.prototype.clickSL = function(x,y) {
-
-    var index=core.status.event.data;
-    var page = parseInt(index/10), offset=index%10;
-
-    // 上一页
-    if ((x == 3 || x == 4) && y == 12) {
-        core.ui.drawSLPanel(10*(page-1)+offset);
-        return;
-    }
-    // 下一页
-    if ((x == 8 || x == 9) && y == 12) {
-        core.ui.drawSLPanel(10*(page+1)+offset);
+////// 装备栏界面时的点击操作 //////
+actions.prototype._clickEquipbox = function (x, y) {
+    // 道具栏
+    if (x >= this.LAST - 2 && y == 0) {
+        core.ui.closePanel();
+        core.openToolbox();
         return;
     }
     // 返回
-    if (x>=10 && x<=12 && y==12) {
+    if (x >= this.LAST - 2 && y == this.LAST) {
         core.ui.closePanel();
-        if (!core.isPlaying()) {
-            core.showStartAnimate();
+        return;
+    }
+
+    // 上一页
+    if ((x == this.HSIZE-2 || x == this.HSIZE-3) && y == this.LAST) {
+        if (core.status.event.data.page > 1) {
+            core.status.event.data.page--;
+            core.ui.drawEquipbox(core.status.event.selection);
         }
         return;
     }
+    // 下一页
+    if ((x == this.HSIZE+2 || x == this.HSIZE+3) && y == this.LAST) {
+        var lastPage = Math.ceil(Object.keys(core.status.hero.items.equips).length / this.LAST);
+        if (core.status.event.data.page < lastPage) {
+            core.status.event.data.page++;
+            core.ui.drawEquipbox(core.status.event.selection);
+        }
+        return;
+    }
+
+    var per_page = this.HSIZE - 3, v = this.SIZE / per_page;
+    if (y == this.LAST - 8) {
+        for (var i = 0; i < per_page; ++i)
+            if (x >= i * v && x <= (i + 1) * v)
+                return this._clickEquipboxIndex(i);
+    }
+    else if (y == this.LAST - 6) {
+        for (var i = 0; i < per_page; ++i)
+            if (x >= i * v && x <= (i + 1) * v)
+                return this._clickEquipboxIndex(per_page + i);
+    }
+    else if (y == this.LAST - 3)
+        this._clickEquipboxIndex(this.LAST + parseInt(x / 2))
+    else if (y == this.LAST - 1)
+        this._clickEquipboxIndex(this.LAST + this.HSIZE + parseInt(x / 2));
+}
+
+////// 选择装备栏界面中某个Index后的操作 //////
+actions.prototype._clickEquipboxIndex = function (index) {
+    if (index < this.LAST) {
+        if (index >= core.status.globalAttribute.equipName.length) return;
+        if (index == core.status.event.selection && core.status.hero.equipment[index]) {
+            core.unloadEquip(index);
+            core.status.route.push("unEquip:" + index);
+        }
+    }
+    else {
+        var equips = Object.keys(core.status.hero.items.equips || {}).sort();
+        if (index == core.status.event.selection) {
+            var equipId = equips[index - this.LAST + (core.status.event.data.page - 1) * this.LAST];
+            core.loadEquip(equipId);
+            core.status.route.push("equip:" + equipId);
+        }
+    }
+    core.ui.drawEquipbox(index);
+}
+
+////// 装备栏界面时，按下某个键的操作 //////
+actions.prototype._keyDownEquipbox = function (keycode) {
+    if (core.status.event.data == null) return;
+
+    var last_index = this.LAST - 1;
+    var per_line = this.HSIZE - 3;
+    var equipCapacity = core.status.globalAttribute.equipName.length;
+    var ownEquipment = Object.keys(core.status.hero.items.equips).sort();
+    var index = core.status.event.selection;
+    var page = core.status.event.data.page;
+    var totalPage = Math.ceil(ownEquipment.length / this.LAST);
+    var totalLastIndex = this.LAST + (page < totalPage ? last_index : (ownEquipment.length + last_index) % this.LAST);
+
+    if (keycode == 37) { // left
+        if (index == 0) return;
+        if (index == this.LAST) {
+            if (page > 1) {
+                core.status.event.data.page--;
+                index = this.LAST + last_index;
+            }
+            else if (page == 1)
+                index = equipCapacity - 1;
+            else return;
+        }
+        else index -= 1;
+        this._clickEquipboxIndex(index);
+        return;
+    }
+    if (keycode == 38) { // up
+        if (index < per_line) return;
+        else if (index < 2 * per_line) index -= per_line;
+        else if (index < this.LAST + this.HSIZE) {
+            index = parseInt((index - this.LAST) / 2);
+            if (equipCapacity > per_line) index = Math.min(equipCapacity - 1, index + per_line);
+            else index = Math.min(equipCapacity - 1, index);
+        }
+        else index -= this.HSIZE;
+        this._clickEquipboxIndex(index);
+        return;
+    }
+    if (keycode == 39) { // right
+        if (page < totalPage && index == this.LAST + last_index) {
+            core.status.event.data.page++;
+            index = this.LAST;
+        }
+        else if (index == equipCapacity - 1) {
+            if (totalPage == 0) return;
+            index = this.LAST;
+        }
+        else if (index == totalLastIndex)
+            return;
+        else index++;
+        this._clickEquipboxIndex(index);
+        return;
+    }
+    if (keycode == 40) { // down
+        if (index < per_line) {
+            if (equipCapacity > per_line) index = Math.min(index + per_line, equipCapacity - 1);
+            else {
+                if (totalPage == 0) return;
+                index = Math.min(2 * index + 1 + this.LAST, totalLastIndex);
+            }
+        }
+        else if (index < 2 * per_line) {
+            if (totalPage == 0) return;
+            index = Math.min(2 * (index - per_line) + 1 + this.LAST, totalLastIndex);
+        }
+        else if (index < this.LAST + this.HSIZE)
+            index = Math.min(index + this.HSIZE, totalLastIndex);
+        else return;
+        this._clickEquipboxIndex(index);
+        return;
+    }
+}
+
+////// 装备栏界面时，放开某个键的操作 //////
+actions.prototype._keyUpEquipbox = function (keycode, altKey) {
+    if (altKey && keycode >= 48 && keycode <= 57) {
+        core.items.quickSaveEquip(keycode - 48);
+        return;
+    }
+    if (keycode == 84) {
+        core.ui.closePanel();
+        core.openToolbox();
+        return;
+    }
+    if (keycode == 81 || keycode == 27 || keycode == 88) {
+        core.ui.closePanel();
+        return;
+    }
+    if (!core.status.event.data.selectId) return;
+
+    if (keycode == 13 || keycode == 32 || keycode == 67) {
+        this._clickEquipboxIndex(core.status.event.selection);
+        return;
+    }
+}
+
+////// 存读档界面时的点击操作 //////
+actions.prototype._clickSL = function (x, y) {
+    var page = core.status.event.data.page, offset = core.status.event.data.offset;
+    var index = page * 10 + offset;
+
+    // 上一页
+    if ((x == this.HSIZE-2 || x == this.HSIZE-3) && y == this.LAST) {
+        core.ui.drawSLPanel(10 * (page - 1) + offset);
+        return;
+    }
+    // 下一页
+    if ((x == this.HSIZE+2 || x == this.HSIZE+3) && y == this.LAST) {
+        core.ui.drawSLPanel(10 * (page + 1) + offset);
+        return;
+    }
+    // 返回
+    if (x >= this.LAST-2 && y == this.LAST) {
+        if (core.events.recoverEvents(core.status.event.interval))
+            return;
+        core.ui.closePanel();
+        delete core.status.tempRoute;
+        if (!core.isPlaying())
+            core.showStartAnimate(true);
+        return;
+    }
     // 删除
-    if (x>=0 && x<=2 && y==12) {
-
-        if (core.status.event.id=='save') {
-            core.status.event.selection=!core.status.event.selection;
+    if (x >= 0 && x <= 2 && y == this.LAST) {
+        if (core.status.event.id == 'save') {
+            core.status.event.selection = !core.status.event.selection;
             core.ui.drawSLPanel(index);
         }
-        else {
-            var index = parseInt(prompt("请输入读档编号"))||0;
-            if (index>0) {
-                core.doSL(index, core.status.event.id);
+        else { // 显示收藏
+            core.status.event.data.mode = core.status.event.data.mode == 'all'?'fav':'all';
+            if (core.status.event.data.mode == 'fav')
+                core.ui.drawSLPanel(1, true);
+            else {
+                page = parseInt((core.saves.saveIndex-1)/5);
+                offset = core.saves.saveIndex-5*page;
+                core.ui.drawSLPanel(10*page + offset, true);
             }
         }
         return;
     }
+    // 点存档名
+    var xLeft = parseInt(this.SIZE/3), xRight = parseInt(this.SIZE*2/3);
+    var topY1 = 0, topY2 = this.HSIZE;
+    if(y >= topY1 && y <= topY1 + 1) {
+        if (x >= xLeft && x < xRight) return this._clickSL_favorite(page, 1);
+        if (x >= xRight) return this._clickSL_favorite(page, 2);
+    }
+    if(y >= topY2 && y <= topY2 + 1) {
+        if (x < xLeft) return this._clickSL_favorite(page, 3);
+        if (x >= xLeft && x < xRight) return this._clickSL_favorite(page, 4);
+        if (x >= xRight) return this._clickSL_favorite(page, 5);
+    }
 
-    var id=null;
-    if (y>=1 && y<=4) {
-        if (x>=1 && x<=3) id = "autoSave";
-        if (x>=5 && x<=7) id = 5*page+1;
-        if (x>=9 && x<=11) id = 5*page+2;
+    var id = null;
+    if (y >= topY1 + 2 && y < this.HSIZE - 1) {
+        if (x < xLeft) id = "autoSave";
+        if (x >= xLeft && x < xRight) id = 5 * page + 1;
+        if (x >= xRight) id = 5 * page + 2;
     }
-    if (y>=7 && y<=10) {
-        if (x>=1 && x<=3) id = 5*page+3;
-        if (x>=5 && x<=7) id = 5*page+4;
-        if (x>=9 && x<=11) id = 5*page+5;
+    if (y >= topY2 + 2 && y < this.SIZE - 1) {
+        if (x < xLeft) id = 5 * page + 3;
+        if (x >= xLeft && x < xRight) id = 5 * page + 4;
+        if (x >= xRight) id = 5 * page + 5;
     }
-    if (id!=null) {
-        if (core.status.event.selection)  {
-            if (id == 'autoSave') {
+    if (id != null) {
+        if (core.status.event.selection) {
+            if (id == 'autoSave')
                 core.drawTip("无法删除自动存档！");
-            }
             else {
-                core.removeLocalStorage("save"+id);
-                core.ui.drawSLPanel(index);
+                core.removeSave(id, function () {
+                    core.ui.drawSLPanel(index, true);
+                });
             }
         }
         else {
+            if(core.status.event.data.mode == 'fav' && id != 'autoSave')
+                id = core.saves.favorite[id - 1];
             core.doSL(id, core.status.event.id);
         }
     }
 }
 
+actions.prototype._clickSL_favorite = function (page, offset) {
+    if (offset == 0) return;
+    var index = 5 * page + offset;
+    if (core.status.event.data.mode == 'fav') { // 收藏模式下点击的下标直接对应favorite
+        index = core.saves.favorite[index - 1];
+        core.myprompt("请输入想要显示的存档名(长度不超过5字符)", null, function (value) {
+            if(value && value.length <= 5){
+                core.saves.favoriteName[index] = value;
+                core.control._updateFavoriteSaves();
+                core.drawSLPanel(10 * page + offset);
+            } else if (value) {
+                alert("无效的输入！");
+            }
+        });
+    } else {
+        var v = core.saves.favorite.indexOf(index);
+        if (v >= 0) { // 已经处于收藏状态：取消收藏
+            core.saves.favorite.splice(v, 1);
+            delete core.saves.favoriteName[index];
+        }
+        else if (core.hasSave(index)) { // 存在存档则进行收藏
+            core.saves.favorite.push(index);
+            core.saves.favorite = core.saves.favorite.sort(function (a,b) {return a-b;}); // 保证有序
+            core.drawTip("收藏成功！");
+        }
+        core.control._updateFavoriteSaves();
+        core.ui.drawSLPanel(10 * page + offset);
+    }
+}
+
 ////// 存读档界面时，按下某个键的操作 //////
-actions.prototype.keyDownSL = function(keycode) {
+actions.prototype._keyDownSL = function (keycode) {
 
-    var index=core.status.event.data;
-    var page = parseInt(index/10), offset=index%10;
+//    var index = core.status.event.data;
+    var page = core.status.event.data.page, offset = core.status.event.data.offset;
+    var index = page*10 + offset;
 
-    if (keycode==37) { // left
-        if (offset==0) {
-            core.ui.drawSLPanel(10*(page-1) + 5);
+    if (keycode == 37) { // left
+        if (offset == 0) {
+            core.ui.drawSLPanel(10 * (page - 1) + 5);
         }
         else {
             core.ui.drawSLPanel(index - 1);
         }
         return;
     }
-    if (keycode==38) { // up
-        if (offset<3) {
-            core.ui.drawSLPanel(10*(page-1) + offset + 3);
+    if (keycode == 38) { // up
+        if (offset < 3) {
+            core.ui.drawSLPanel(10 * (page - 1) + offset + 3);
         }
         else {
             core.ui.drawSLPanel(index - 3);
         }
         return;
     }
-    if (keycode==39) { // right
-        if (offset==5) {
-            core.ui.drawSLPanel(10*(page+1)+1);
+    if (keycode == 39) { // right
+        if (offset == 5) {
+            core.ui.drawSLPanel(10 * (page + 1) + 1);
         }
         else {
             core.ui.drawSLPanel(index + 1);
         }
         return;
     }
-    if (keycode==40) { // down
-        if (offset>=3) {
-            core.ui.drawSLPanel(10*(page+1) + offset - 3);
+    if (keycode == 40) { // down
+        if (offset >= 3) {
+            core.ui.drawSLPanel(10 * (page + 1) + offset - 3);
         }
         else {
             core.ui.drawSLPanel(index + 3);
         }
         return;
     }
-    if (keycode==33) { // PAGEUP
-        core.ui.drawSLPanel(10*(page-1) + offset);
+    if (keycode == 33) { // PAGEUP
+        core.ui.drawSLPanel(10 * (page - 1) + offset);
         return;
     }
-    if (keycode==34) { // PAGEDOWN
-        core.ui.drawSLPanel(10*(page+1) + offset);
+    if (keycode == 34) { // PAGEDOWN
+        core.ui.drawSLPanel(10 * (page + 1) + offset);
         return;
     }
 }
 
 ////// 存读档界面时，放开某个键的操作 //////
-actions.prototype.keyUpSL = function (keycode) {
+actions.prototype._keyUpSL = function (keycode) {
+    var page = core.status.event.data.page, offset = core.status.event.data.offset;
+    var index = page * 10 + offset;
 
-    var index=core.status.event.data;
-    var page = parseInt(index/10), offset=index%10;
-
-    if (keycode==27 || keycode==88 || (core.status.event.id == 'save' && keycode==83) || (core.status.event.id == 'load' && keycode==68)) {
-        core.ui.closePanel();
-        if (!core.isPlaying()) {
-            core.showStartAnimate();
-        }
+    if (keycode == 27 || keycode == 88 || (core.status.event.id == 'save' && keycode == 83)
+        || (core.status.event.id == 'load' && keycode == 68)) {
+        this._clickSL(this.LAST, this.LAST);
         return;
     }
-    if (keycode==13 || keycode==32 || keycode==67) {
-        if (offset==0) {
+    if (keycode == 13 || keycode == 32 || keycode == 67) {
+        if (offset == 0)
             core.doSL("autoSave", core.status.event.id);
-        }
         else {
-            core.doSL(5*page+offset, core.status.event.id);
+            var id = 5 * page + offset;
+            if(core.status.event.data.mode == 'fav') id = core.saves.favorite[id - 1];
+            core.doSL(id, core.status.event.id);
         }
         return;
     }
-    if (keycode==69 && core.status.event.id == 'load') { // E
-        var index = parseInt(prompt("请输入读档编号"))||0;
-        if (index>0) {
-            core.doSL(index, core.status.event.id);
-        }
+    if (keycode == 69 && core.status.event.id != 'save') { // E 收藏切换
+        this._clickSL(0, this.LAST);
         return;
     }
-    if (keycode==46) {
-        if (offset==0) {
+    if (keycode == 46) {
+        if (offset == 0) {
             core.drawTip("无法删除自动存档！");
         }
         else {
-            core.removeLocalStorage("save"+(5*page+offset));
-            core.ui.drawSLPanel(index);
+            var id = 5 * page + offset;
+            if(core.status.event.data.mode == 'fav') id = core.saves.favorite[id - 1];
+            core.removeSave(id, function () {
+                core.ui.drawSLPanel(index, true);
+            });
         }
     }
+    if (keycode == 70 && core.status.event.data.mode == 'all') { // F
+        this._clickSL_favorite(page, offset);
+    }
 }
 
+
 ////// 系统设置界面时的点击操作 //////
-actions.prototype.clickSwitchs = function (x,y) {
-    if (x<5 || x>7) return;
+actions.prototype._clickSwitchs = function (x, y) {
+    if (x < this.CHOICES_LEFT || x > this.CHOICES_RIGHT) return;
     var choices = core.status.event.ui.choices;
-    var topIndex = 6 - parseInt((choices.length - 1) / 2);
-    if (y>=topIndex && y<topIndex+choices.length) {
-        var selection = y-topIndex;
+    var topIndex = this.HSIZE - parseInt((choices.length - 1) / 2) + (core.status.event.ui.offset || 0);
+    if (y >= topIndex && y < topIndex + choices.length) {
+        var selection = y - topIndex;
+        core.status.event.selection = selection;
         switch (selection) {
             case 0:
-                core.musicStatus.bgmStatus = !core.musicStatus.bgmStatus;
-                if (core.musicStatus.bgmStatus)
-                    core.resumeBgm();
-                else {
-                    core.pauseBgm();
-                    core.musicStatus.playingBgm = null;
-                }
-                core.setLocalStorage('bgmStatus', core.musicStatus.bgmStatus);
-                core.ui.drawSwitchs();
-                break;
+                return this._clickSwitchs_bgm();
             case 1:
-                core.musicStatus.soundStatus = !core.musicStatus.soundStatus;
-                core.setLocalStorage('soundStatus', core.musicStatus.soundStatus);
-                core.ui.drawSwitchs();
-                break;
+                return this._clickSwitchs_sound();
             case 2:
-                if (!core.flags.canOpenBattleAnimate) {
-                    core.drawTip("本塔不能开启战斗动画！");
-                }
-                else {
-                    core.flags.battleAnimate=!core.flags.battleAnimate;
-                    core.setLocalStorage('battleAnimate', core.flags.battleAnimate);
-                    core.ui.drawSwitchs();
-                }
-                break;
+                return this._clickSwitchs_moveSpeed();
             case 3:
-                core.flags.displayEnemyDamage=!core.flags.displayEnemyDamage;
-                core.updateFg();
-                core.setLocalStorage('enemyDamage', core.flags.displayEnemyDamage);
-                core.ui.drawSwitchs();
-                break;
+                return this._clickSwitchs_displayEnemyDamage();
             case 4:
-                core.flags.displayCritical=!core.flags.displayCritical;
-                core.updateFg();
-                core.setLocalStorage('critical', core.flags.displayCritical);
-                core.ui.drawSwitchs();
-                break;
+                return this._clickSwitchs_displayCritical();
             case 5:
-                core.flags.displayExtraDamage=!core.flags.displayExtraDamage;
-                core.updateFg();
-                core.setLocalStorage('extraDamage', core.flags.displayExtraDamage);
-                core.ui.drawSwitchs();
-                break;
+                return this._clickSwitchs_displayExtraDamage();
             case 6:
-                core.status.automaticRoute.clickMoveDirectly=!core.status.automaticRoute.clickMoveDirectly;
-                core.setLocalStorage('clickMoveDirectly', core.status.automaticRoute.clickMoveDirectly);
-                core.ui.drawSwitchs();
-                break;
+                return this._clickSwitchs_localForage();
             case 7:
-                window.open(core.firstData.name+".zip", "_blank");
-                break;
+                return this._clickSwitchs_clickMove();
             case 8:
-                core.status.event.selection=0;
+                return this._clickSwitchs_ExtendKeyboard();
+            case 9:
+                core.status.event.selection = 0;
                 core.ui.drawSettings();
                 break;
         }
     }
 }
 
-////// 系统设置界面时，按下某个键的操作 //////
-actions.prototype.keyDownSwitchs = function (keycode) {
-    if (keycode==38) {
-        core.status.event.selection--;
-        core.ui.drawChoices(core.status.event.ui.text, core.status.event.ui.choices);
-    }
-    if (keycode==40) {
-        core.status.event.selection++;
-        core.ui.drawChoices(core.status.event.ui.text, core.status.event.ui.choices);
-    }
+actions.prototype._clickSwitchs_bgm = function () {
+    core.triggerBgm();
+    core.ui.drawSwitchs();
+}
+
+actions.prototype._clickSwitchs_sound = function () {
+    core.musicStatus.soundStatus = !core.musicStatus.soundStatus;
+    core.setLocalStorage('soundStatus', core.musicStatus.soundStatus);
+    core.ui.drawSwitchs();
+}
+
+actions.prototype._clickSwitchs_moveSpeed = function () {
+    core.myprompt("请输入行走速度（每走一步的时间，单位毫秒，默认100）", core.values.moveSpeed, function (value) {
+        value = parseInt(value) || core.values.moveSpeed;
+        value = core.clamp(value, 10, 500);
+        core.values.moveSpeed = value;
+        core.setLocalStorage("moveSpeed", value);
+        core.ui.drawSwitchs();
+    });
+}
+
+actions.prototype._clickSwitchs_displayEnemyDamage = function () {
+    core.flags.displayEnemyDamage = !core.flags.displayEnemyDamage;
+    core.updateDamage();
+    core.setLocalStorage('enemyDamage', core.flags.displayEnemyDamage);
+    core.ui.drawSwitchs();
+}
+
+actions.prototype._clickSwitchs_displayCritical = function () {
+    core.flags.displayCritical = !core.flags.displayCritical;
+    core.updateDamage();
+    core.setLocalStorage('critical', core.flags.displayCritical);
+    core.ui.drawSwitchs();
+}
+
+actions.prototype._clickSwitchs_displayExtraDamage = function () {
+    core.flags.displayExtraDamage = !core.flags.displayExtraDamage;
+    core.updateDamage();
+    core.setLocalStorage('extraDamage', core.flags.displayExtraDamage);
+    core.ui.drawSwitchs();
+}
+
+actions.prototype._clickSwitchs_localForage = function () {
+    core.platform.useLocalForage = !core.platform.useLocalForage;
+    core.setLocalStorage('useLocalForage', core.platform.useLocalForage);
+    core.control.getSaveIndexes(function (indexes) {
+        core.saves.ids = indexes;
+    });
+    core.ui.drawSwitchs();
+}
+
+actions.prototype._clickSwitchs_clickMove = function () {
+    if (core.hasFlag('__noClickMove__')) core.removeFlag('__noClickMove__');
+    else core.setFlag('__noClickMove__', true);
+    core.ui.drawSwitchs();
+}
+
+actions.prototype._clickSwitchs_ExtendKeyboard = function () {
+    core.platform.extendKeyboard = !core.platform.extendKeyboard;
+    core.setLocalStorage('extendKeyboard', core.platform.extendKeyboard);
+    core.updateStatusBar();
+    core.ui.drawSwitchs();
 }
 
 ////// 系统设置界面时，放开某个键的操作 //////
-actions.prototype.keyUpSwitchs = function (keycode) {
-    if (keycode==27 || keycode==88) {
-        core.status.event.selection=0;
+actions.prototype._keyUpSwitchs = function (keycode) {
+    if (keycode == 27 || keycode == 88) {
+        core.status.event.selection = 0;
         core.ui.drawSettings();
         return;
     }
-    var choices = core.status.event.ui.choices;
-    if (keycode==13 || keycode==32 || keycode==67) {
-        var topIndex = 6 - parseInt((choices.length - 1) / 2);
-        this.clickSwitchs(6, topIndex+core.status.event.selection);
-    }
+    this._selectChoices(core.status.event.ui.choices.length, keycode, this._clickSwitchs);
 }
 
-
-////// 系统菜单栏界面时的点击事件 //////
-actions.prototype.clickSettings = function (x,y) {
-    if (x<5 || x>7) return;
+////// 系统菜单栏界面时的点击操作 //////
+actions.prototype._clickSettings = function (x, y) {
+    if (x < this.CHOICES_LEFT || x > this.CHOICES_RIGHT) return;
     var choices = core.status.event.ui.choices;
-    var topIndex = 6 - parseInt((choices.length - 1) / 2);
-    if (y>=topIndex && y<topIndex+choices.length) {
-        var selection = y-topIndex;
-
+    var topIndex = this.HSIZE - parseInt((choices.length - 1) / 2) + (core.status.event.ui.offset || 0);
+    if (y >= topIndex && y < topIndex + choices.length) {
+        var selection = y - topIndex;
+        core.status.event.selection = selection;
         switch (selection) {
             case 0:
-                core.status.event.selection=0;
+                core.status.event.selection = 0;
                 core.ui.drawSwitchs();
                 break;
             case 1:
-                core.status.event.selection=0;
-                core.ui.drawQuickShop();
+                core.ui.drawKeyBoard();
                 break;
             case 2:
-                if (!core.flags.enableViewMaps) {
-                    core.drawTip("本塔不允许浏览地图！");
-                }
-                else {
-                    /*
-                    core.drawText("\t[系统提示]即将进入浏览地图模式。\n\n点击地图上半部分，或按[↑]键可查看前一张地图\n点击地图下半部分，或按[↓]键可查看后一张地图\n点击地图中间，或按[ESC]键可离开浏览地图模式\n此模式下可以打开怪物手册以查看某层楼的怪物属性", function () {
-                        core.ui.drawMaps(core.floorIds.indexOf(core.status.floorId));
-                    })
-                    */
-                    core.ui.drawMaps();
-                }
+                core.clearUI();
+                core.ui.drawMaps();
                 break;
             case 3:
-                core.status.event.selection=0;
-                core.ui.drawSyncSave();
+                core.clearUI();
+                core.ui.drawPaint();
                 break;
             case 4:
-                core.status.event.selection=1;
-                core.ui.drawConfirmBox("你确定要返回标题页面吗？", function () {
-                    core.ui.closePanel();
-                    core.restart();
-                }, function () {
-                    core.status.event.selection=3;
-                    core.ui.drawSettings();
-                });
+                core.status.event.selection = 0;
+                core.ui.drawSyncSave();
                 break;
             case 5:
-                core.ui.drawStatistics();
-                /*
-                core.ui.drawWaiting("正在拉取统计信息，请稍后...");
-
-                var formData = new FormData();
-                formData.append('type', 'statistics');
-                formData.append('name', core.firstData.name);
-                formData.append('version', core.firstData.version);
-
-                var xhr = new XMLHttpRequest();
-                xhr.open("POST", "/games/upload.php");
-
-                xhr.onload = function(e) {
-                    if (xhr.status==200) {
-                        var response = JSON.parse(xhr.response);
-                        if (response.code<0) {
-                            core.drawText("出错啦！\n无法拉取统计信息。\n错误原因："+response.msg);
-                        }
-                        else {
-                            var text="\t[本塔统计信息]";
-                            var toAdd=false;
-                            response.data.forEach(function (t) {
-                                if (toAdd) text+="\n\n";
-                                toAdd=true;
-                                if (t.hard!='') text+=t.hard+"难度： "
-                                text+="已有"+t.people+"人次游戏，"+t.score+"人次通关。";
-                                t.info.forEach(function(ending) {
-                                    if (ending.ending!='') {
-                                        text+="\n"+ending.ending+"： 已有"+ending.score+"人次通关。";
-                                    }
-                                    if (core.isset(ending.max) && ending.max>0) {
-                                        text+="\n当前MAX为"+ending.max+"，最早由 "+(ending.username||"匿名")+" 于"+core.formatDate(new Date(1000*ending.timestamp))+"打出。";
-                                    }
-                                })
-                            })
-                            core.drawText(text);
-                        }
-                    }
-                    else {
-                        core.drawText("出错啦！\n无法拉取统计信息。\n错误原因：HTTP "+xhr.status);
-                    }
-                };
-                xhr.ontimeout = function() {
-                    core.drawText("出错啦！\n无法拉取统计信息。\n错误原因：Timeout");
-                }
-                xhr.onerror = function() {
-                    core.drawText("出错啦！\n无法拉取统计信息。\n错误原因：XHR Error");
-                }
-                xhr.send(formData);
-                */
+                core.status.event.selection = 0;
+                core.ui.drawGameInfo();
                 break;
             case 6:
-                core.ui.drawHelp();
-                break;
+                return core.confirmRestart();
             case 7:
-                core.ui.drawAbout();
-                break;
-            case 8:
                 core.ui.closePanel();
                 break;
         }
@@ -1734,109 +2021,45 @@ actions.prototype.clickSettings = function (x,y) {
     return;
 }
 
-////// 系统菜单栏界面时，按下某个键的操作 //////
-actions.prototype.keyDownSettings = function (keycode) {
-    if (keycode==38) {
-        core.status.event.selection--;
-        core.ui.drawChoices(core.status.event.ui.text, core.status.event.ui.choices);
-    }
-    if (keycode==40) {
-        core.status.event.selection++;
-        core.ui.drawChoices(core.status.event.ui.text, core.status.event.ui.choices);
-    }
-}
-
 ////// 系统菜单栏界面时，放开某个键的操作 //////
-actions.prototype.keyUpSettings = function (keycode) {
-    if (keycode==27 || keycode==88) {
+actions.prototype._keyUpSettings = function (keycode) {
+    if (keycode == 27 || keycode == 88) {
         core.ui.closePanel();
         return;
     }
-    var choices = core.status.event.ui.choices;
-    if (keycode==13 || keycode==32 || keycode==67) {
-        var topIndex = 6 - parseInt((choices.length - 1) / 2);
-        this.clickSettings(6, topIndex+core.status.event.selection);
-    }
+    this._selectChoices(core.status.event.ui.choices.length, keycode, this._clickSettings);
 }
 
 ////// 同步存档界面时的点击操作 //////
-actions.prototype.clickSyncSave = function (x,y) {
-    if (x<5 || x>7) return;
+actions.prototype._clickSyncSave = function (x, y) {
+    if (x < this.CHOICES_LEFT || x > this.CHOICES_RIGHT) return;
     var choices = core.status.event.ui.choices;
-    var topIndex = 6 - parseInt((choices.length - 1) / 2);
-    if (y>=topIndex && y<topIndex+choices.length) {
-        var selection = y-topIndex;
+    var topIndex = this.HSIZE - parseInt((choices.length - 1) / 2) + (core.status.event.ui.offset || 0);
+    if (y >= topIndex && y < topIndex + choices.length) {
+        var selection = y - topIndex;
+        core.status.event.selection = selection;
         switch (selection) {
             case 0:
-                // core.syncSave("save");
-                core.status.event.selection=0;
+                core.status.event.selection = 0;
                 core.ui.drawSyncSelect();
                 break;
             case 1:
                 core.syncLoad();
                 break;
             case 2:
-                core.status.event.selection=0;
+                core.status.event.selection = 0;
                 core.ui.drawLocalSaveSelect();
                 break;
             case 3:
-                core.readFile(function (obj) {
-                    if (obj.name!=core.firstData.name) {
-                        alert("存档和游戏不一致！");
-                        return;
-                    }
-                    if (obj.version!=core.firstData.version) {
-                        alert("游戏版本不一致！");
-                        return;
-                    }
-                    if (!core.isset(obj.data)) {
-                        alert("无效的存档！");
-                        return;
-                    }
-                    var data=obj.data;
-
-                    if (data instanceof Array) {
-                        core.ui.drawConfirmBox("所有本地存档都将被覆盖，确认？", function () {
-                            for (var i=1;i<=5*(main.savePages||30);i++) {
-                                if (i<=data.length) {
-                                    core.setLocalStorage("save"+i, data[i-1]);
-                                }
-                                else {
-                                    core.removeLocalStorage("save"+i);
-                                }
-                            }
-                            core.drawText("读取成功！\n你的本地所有存档均已被覆盖。");
-                        }, function () {
-                            core.status.event.selection=0;
-                            core.ui.drawSyncSave();
-                        })
-                    }
-                    else {
-                        core.setLocalStorage("save"+core.status.saveIndex, data);
-                        core.drawText("同步成功！\n单存档已覆盖至存档"+core.status.saveIndex);
-                    }
-                }, function () {
-
-                });
-                break;
+                return this._clickSyncSave_readFile();
             case 4:
-                if (core.hasFlag('debug')) {
-                    core.drawText("\t[系统提示]调试模式下无法下载录像");
-                    break;
-                }
-                core.download(core.firstData.name+"_"+core.formatDate2(new Date())+".h5route", JSON.stringify({
-                    'name': core.firstData.name,
-                    'hard': core.status.hard,
-                    'seed': core.getFlag('seed'),
-                    'route': core.encodeRoute(core.status.route)
-                }));
-                break;
+                return this._clickSyncSave_replay();
             case 5:
-                core.status.event.selection=0;
+                core.status.event.selection = 0;
                 core.ui.drawStorageRemove();
                 break;
             case 6:
-                core.status.event.selection=3;
+                core.status.event.selection = 4;
                 core.ui.drawSettings();
                 break;
 
@@ -1845,40 +2068,44 @@ actions.prototype.clickSyncSave = function (x,y) {
     return;
 }
 
-////// 同步存档界面时，按下某个键的操作 //////
-actions.prototype.keyDownSyncSave = function (keycode) {
-    if (keycode==38) {
-        core.status.event.selection--;
-        core.ui.drawChoices(core.status.event.ui.text, core.status.event.ui.choices);
+actions.prototype._clickSyncSave_readFile = function () {
+    core.readFile(function (obj) {
+        if (obj.name != core.firstData.name) return alert("存档和游戏不一致！");
+        if (obj.version != core.firstData.version) return alert("游戏版本不一致！");
+        if (!obj.data) return alert("无效的存档！");
+        core.control._syncLoad_write(obj.data);
+    });
+}
+
+actions.prototype._clickSyncSave_replay = function () {
+    if (core.hasFlag('debug')) {
+        core.drawText("\t[系统提示]调试模式下无法回放录像");
     }
-    if (keycode==40) {
-        core.status.event.selection++;
-        core.ui.drawChoices(core.status.event.ui.text, core.status.event.ui.choices);
+    else {
+        core.status.event.selection = 0;
+        core.ui.drawReplay();
     }
 }
 
 ////// 同步存档界面时，放开某个键的操作 //////
-actions.prototype.keyUpSyncSave = function (keycode) {
-    if (keycode==27 || keycode==88) {
-        core.status.event.selection=2;
+actions.prototype._keyUpSyncSave = function (keycode) {
+    if (keycode == 27 || keycode == 88) {
+        core.status.event.selection = 2;
         core.ui.drawSettings();
         return;
     }
-    var choices = core.status.event.ui.choices;
-    if (keycode==13 || keycode==32 || keycode==67) {
-        var topIndex = 6 - parseInt((choices.length - 1) / 2);
-        this.clickSyncSave(6, topIndex+core.status.event.selection);
-    }
+    this._selectChoices(core.status.event.ui.choices.length, keycode, this._clickSyncSave);
 }
 
 ////// 同步存档选择界面时的点击操作 //////
-actions.prototype.clickSyncSelect = function (x, y) {
-    if (x<5 || x>7) return;
+actions.prototype._clickSyncSelect = function (x, y) {
+    if (x < this.CHOICES_LEFT || x > this.CHOICES_RIGHT) return;
     var choices = core.status.event.ui.choices;
 
-    var topIndex = 6 - parseInt((choices.length - 1) / 2);
-    if (y>=topIndex && y<topIndex+choices.length) {
+    var topIndex = this.HSIZE - parseInt((choices.length - 1) / 2) + (core.status.event.ui.offset || 0);
+    if (y >= topIndex && y < topIndex + choices.length) {
         var selection = y - topIndex;
+        core.status.event.selection = selection;
         switch (selection) {
             case 0:
                 core.syncSave('all');
@@ -1887,328 +2114,384 @@ actions.prototype.clickSyncSelect = function (x, y) {
                 core.syncSave();
                 break;
             case 2:
-                core.status.event.selection=0;
+                core.status.event.selection = 0;
                 core.ui.drawSyncSave();
                 break;
         }
     }
 }
 
-////// 同步存档选择界面时，按下某个键的操作 //////
-actions.prototype.keyDownSyncSelect = function (keycode) {
-    if (keycode==38) {
-        core.status.event.selection--;
-        core.ui.drawChoices(core.status.event.ui.text, core.status.event.ui.choices);
-    }
-    if (keycode==40) {
-        core.status.event.selection++;
-        core.ui.drawChoices(core.status.event.ui.text, core.status.event.ui.choices);
-    }
-}
-
 ////// 同步存档选择界面时，放开某个键的操作 //////
-actions.prototype.keyUpSyncSelect = function (keycode) {
-    if (keycode==27 || keycode==88) {
-        core.status.event.selection=0;
+actions.prototype._keyUpSyncSelect = function (keycode) {
+    if (keycode == 27 || keycode == 88) {
+        core.status.event.selection = 0;
         core.ui.drawSettings();
         return;
     }
-    var choices = core.status.event.ui.choices;
-    if (keycode==13 || keycode==32 || keycode==67) {
-        var topIndex = 6 - parseInt((choices.length - 1) / 2);
-        this.clickSyncSelect(6, topIndex+core.status.event.selection);
-    }
+    this._selectChoices(core.status.event.ui.choices.length, keycode, this._clickSyncSelect);
 }
 
 ////// 存档下载界面时的点击操作 //////
-actions.prototype.clickLocalSaveSelect = function (x,y) {
-    if (x<5 || x>7) return;
+actions.prototype._clickLocalSaveSelect = function (x, y) {
+    if (x < this.CHOICES_LEFT || x > this.CHOICES_RIGHT) return;
     var choices = core.status.event.ui.choices;
 
-    var topIndex = 6 - parseInt((choices.length - 1) / 2);
+    var topIndex = this.HSIZE - parseInt((choices.length - 1) / 2) + (core.status.event.ui.offset || 0);
 
-    var saves=null;
-
-    if (y>=topIndex && y<topIndex+choices.length) {
+    if (y >= topIndex && y < topIndex + choices.length) {
         var selection = y - topIndex;
-        switch (selection) {
-            case 0:
-                saves=[];
-                for (var i=1;i<=5*(main.savePages||30);i++) {
-                    var data = core.getLocalStorage("save"+i, null);
-                    if (core.isset(data)) {
-                        saves.push(data);
+        core.status.event.selection = selection;
+        if (selection < 2) {
+            var callback = function (saves) {
+                if (saves) {
+                    var content = {
+                        "name": core.firstData.name,
+                        "version": core.firstData.version,
+                        "data": saves
                     }
+                    core.download(core.firstData.name + "_" + core.formatDate2(new Date()) + ".h5save", JSON.stringify(content));
                 }
-                break;
-            case 1:
-                saves=core.getLocalStorage("save"+core.status.saveIndex, null);
-                break;
-            case 2:
-                break;
+            };
+            if (selection == 0) core.getAllSaves(callback);
+            else core.getSave(core.saves.saveIndex, callback);
         }
-    }
-    if (core.isset(saves)) {
-        var content = {
-            "name": core.firstData.name,
-            "version": core.firstData.version,
-            "data": saves
-        }
-        core.download(core.firstData.name+"_"+core.formatDate2(new Date())+".h5save", JSON.stringify(content));
-    }
-    core.status.event.selection=2;
-    core.ui.drawSyncSave();
-}
 
-////// 存档下载界面时，按下某个键的操作 //////
-actions.prototype.keyDownLocalSaveSelect = function (keycode) {
-    if (keycode==38) {
-        core.status.event.selection--;
-        core.ui.drawChoices(core.status.event.ui.text, core.status.event.ui.choices);
-    }
-    if (keycode==40) {
-        core.status.event.selection++;
-        core.ui.drawChoices(core.status.event.ui.text, core.status.event.ui.choices);
+        core.status.event.selection = 2;
+        core.ui.drawSyncSave();
     }
 }
 
 ////// 存档下载界面时，放开某个键的操作 //////
-actions.prototype.keyUpLocalSaveSelect = function (keycode) {
-    if (keycode==27 || keycode==88) {
-        core.status.event.selection=0;
+actions.prototype._keyUpLocalSaveSelect = function (keycode) {
+    if (keycode == 27 || keycode == 88) {
+        core.status.event.selection = 0;
         core.ui.drawSettings();
         return;
     }
-    var choices = core.status.event.ui.choices;
-    if (keycode==13 || keycode==32 || keycode==67) {
-        var topIndex = 6 - parseInt((choices.length - 1) / 2);
-        this.clickLocalSaveSelect(6, topIndex+core.status.event.selection);
-    }
+    this._selectChoices(core.status.event.ui.choices.length, keycode, this._clickLocalSaveSelect);
 }
 
 ////// 存档删除界面时的点击操作 //////
-actions.prototype.clickStorageRemove = function (x, y) {
-    if (x<5 || x>7) return;
+actions.prototype._clickStorageRemove = function (x, y) {
+    if (x < this.CHOICES_LEFT || x > this.CHOICES_RIGHT) return;
     var choices = core.status.event.ui.choices;
 
-    var topIndex = 6 - parseInt((choices.length - 1) / 2);
+    var topIndex = this.HSIZE - parseInt((choices.length - 1) / 2) + (core.status.event.ui.offset || 0);
 
-    if (y>=topIndex && y<topIndex+choices.length) {
+    if (y >= topIndex && y < topIndex + choices.length) {
         var selection = y - topIndex;
+        core.status.event.selection = selection;
         switch (selection) {
             case 0:
-                localStorage.clear();
-                core.drawText("\t[操作成功]你的所有存档已被清空。");
-                break;
+                return this._clickStorageRemove_all();
             case 1:
-                for (var i=1;i<=5*(main.savePages||30);i++) {
-                    core.removeLocalStorage("save"+i);
-                }
-                core.drawText("\t[操作成功]当前塔的存档已被清空。");
-                core.removeLocalStorage("autoSave");
-                break;
+                return this._clickStorageRemove_current();
             case 2:
-                core.status.event.selection=5;
+                core.status.event.selection = 6;
                 core.ui.drawSyncSave();
                 break;
         }
     }
 }
 
-////// 存档删除界面时，按下某个键的操作 //////
-actions.prototype.keyDownStorageRemove = function (keycode) {
-    if (keycode==38) {
-        core.status.event.selection--;
-        core.ui.drawChoices(core.status.event.ui.text, core.status.event.ui.choices);
-    }
-    if (keycode==40) {
-        core.status.event.selection++;
-        core.ui.drawChoices(core.status.event.ui.text, core.status.event.ui.choices);
-    }
+actions.prototype._clickStorageRemove_all = function () {
+    core.myconfirm("你确定要清除【全部塔】的所有本地存档？\n此行为不可逆！！！", function () {
+        var done = function () {
+            core.saves.ids = {};
+            core.saves.autosave.data = null;
+            core.saves.autosave.updated = false;
+            core.ui.closePanel();
+            core.saves.saveIndex = 1;
+            core.saves.favorite = [];
+            core.saves.favoriteName = {};
+            core.control._updateFavoriteSaves();
+            core.removeLocalStorage('saveIndex');
+            core.drawText("\t[操作成功]你的所有存档已被清空。");
+        };
+        if (core.platform.useLocalForage) {
+            core.ui.drawWaiting("正在清空，请稍后...");
+            localforage.clear(done);
+        }
+        else {
+            localStorage.clear();
+            done();
+        }
+    });
+}
+
+actions.prototype._clickStorageRemove_current = function () {
+    core.myconfirm("你确定要清除本塔的所有本地存档？\n此行为不可逆！！！", function () {
+        var done = function () {
+            core.saves.ids = {};
+            core.saves.autosave.data = null;
+            core.saves.autosave.updated = false;
+            core.ui.closePanel();
+            core.saves.saveIndex = 1;
+            core.saves.favorite = [];
+            core.saves.favoriteName = {};
+            core.control._updateFavoriteSaves();
+            core.removeLocalStorage('saveIndex');
+            core.drawText("\t[操作成功]当前塔的存档已被清空。");
+        }
+        if (core.platform.useLocalForage) {
+            core.ui.drawWaiting("正在清空，请稍后...");
+            Object.keys(core.saves.ids).forEach(function (v) {
+                core.removeLocalForage("save" + v);
+            });
+            core.removeLocalForage("autoSave", done);
+        }
+        else {
+            Object.keys(core.saves.ids).forEach(function (v) {
+                core.removeLocalStorage("save" + v);
+            });
+            core.removeLocalStorage("autoSave");
+            done();
+        }
+    });
 }
 
 ////// 存档删除界面时，放开某个键的操作 //////
-actions.prototype.keyUpStorageRemove = function (keycode) {
-    if (keycode==27 || keycode==88) {
-        core.status.event.selection=5;
+actions.prototype._keyUpStorageRemove = function (keycode) {
+    if (keycode == 27 || keycode == 88) {
+        core.status.event.selection = 5;
         core.ui.drawSyncSave();
         return;
     }
-    var choices = core.status.event.ui.choices;
-    if (keycode==13 || keycode==32 || keycode==67) {
-        var topIndex = 6 - parseInt((choices.length - 1) / 2);
-        this.clickStorageRemove(6, topIndex+core.status.event.selection);
-    }
+    this._selectChoices(core.status.event.ui.choices.length, keycode, this._clickStorageRemove);
 }
 
 ////// 回放选择界面时的点击操作 //////
-actions.prototype.clickReplay = function (x, y) {
-    if (x<5 || x>7) return;
+actions.prototype._clickReplay = function (x, y) {
+    if (x < this.CHOICES_LEFT || x > this.CHOICES_RIGHT) return;
     var choices = core.status.event.ui.choices;
 
-    var topIndex = 6 - parseInt((choices.length - 1) / 2);
+    var topIndex = this.HSIZE - parseInt((choices.length - 1) / 2) + (core.status.event.ui.offset || 0);
 
-    if (y>=topIndex && y<topIndex+choices.length) {
+    if (y >= topIndex && y < topIndex + choices.length) {
         var selection = y - topIndex;
+        core.status.event.selection = selection;
         switch (selection) {
-            case 0:
-                {
-                    core.ui.closePanel();
-                    var hard=core.status.hard, route=core.clone(core.status.route);
-                    var seed = core.getFlag('seed');
-                    core.resetStatus(core.firstData.hero, hard, core.firstData.floorId, null, core.initStatus.maps);
-                    core.events.setInitData(hard);
-                    core.setFlag('seed', seed);
-                    core.setFlag('rand', seed);
-                    core.changeFloor(core.status.floorId, null, core.firstData.hero.loc, null, function() {
-                        core.startReplay(route);
-                    }, true);
-                    break;
-                }
-            case 1:
-                {
-                    core.status.event.id = 'replayLoad';
-                    core.status.event.selection = null;
-                    var saveIndex = core.status.saveIndex;
-                    var page=parseInt((saveIndex-1)/5), offset=saveIndex-5*page;
-                    core.ui.drawSLPanel(10*page+offset);
-                    break;
-                }
-            case 2:
-                if (core.hasFlag('debug')) {
-                    core.drawText("\t[系统提示]调试模式下无法下载录像");
-                    break;
-                }
-                core.download(core.firstData.name+"_"+core.formatDate2(new Date())+".h5route", JSON.stringify({
-                    'name': core.firstData.name,
-                    'hard': core.status.hard,
-                    'seed': core.getFlag('seed'),
-                    'route': core.encodeRoute(core.status.route)
-                }));
-                break;
-                break;
-            case 3:
-                core.ui.closePanel();
+            case 0: return this._clickReplay_fromBeginning();
+            case 1: return this._clickReplay_fromLoad();
+            case 2: return this._clickReplay_replayRemain();
+            case 3: return core.chooseReplayFile();
+            case 4: return this._clickReplay_download();
+            case 5: return core.ui.closePanel();
+        }
+    }
+}
+
+actions.prototype._clickReplay_fromBeginning = function () {
+    core.ui.closePanel();
+    core.startGame(core.status.hard, core.getFlag('__seed__'), core.clone(core.status.route));
+}
+
+actions.prototype._clickReplay_fromLoad = function () {
+    core.status.event.id = 'replayLoad';
+    core.status.event.selection = null;
+    core.clearUI();
+    var saveIndex = core.saves.saveIndex;
+    var page = parseInt((saveIndex - 1) / 5), offset = saveIndex - 5 * page;
+    core.ui.drawSLPanel(10 * page + offset);
+}
+
+actions.prototype._clickReplay_replayRemain = function () {
+    core.closePanel();
+    core.drawText([
+        "\t[接续播放录像]该功能允许你播放\r[yellow]两个存档之间的录像\r，常常用于\r[yellow]区域优化\r。\n" +
+        "例如，有若干个区，已经全部通关；之后重打一区并进行了优化，则可以对剩余区域直接播放录像而无需全部重打。",
+        "\t[步骤1]请选择一个存档。\n\r[yellow]该存档的坐标必须和当前勇士坐标完全相同。\r\n将尝试从此处开始回放。",
+    ], function () {
+        core.status.event.id = 'replayRemain';
+        core.lockControl();
+        var saveIndex = core.saves.saveIndex;
+        var page = parseInt((saveIndex - 1) / 5), offset = saveIndex - 5 * page;
+        core.ui.drawSLPanel(10 * page + offset);
+    });
+}
+
+actions.prototype._clickReplay_download = function () {
+    if (core.hasFlag('debug')) return core.drawText("\t[系统提示]调试模式下无法下载录像");
+    core.download(core.firstData.name + "_" + core.formatDate2() + ".h5route", JSON.stringify({
+        'name': core.firstData.name,
+        'hard': core.status.hard,
+        'seed': core.getFlag('__seed__'),
+        'route': core.encodeRoute(core.status.route)
+    }));
+
+}
+
+////// 回放选择界面时，放开某个键的操作 //////
+actions.prototype._keyUpReplay = function (keycode) {
+    if (keycode == 27 || keycode == 88) {
+        core.ui.closePanel();
+        return;
+    }
+    this._selectChoices(core.status.event.ui.choices.length, keycode, this._clickReplay);
+}
+
+////// 游戏信息界面时的点击操作 //////
+actions.prototype._clickGameInfo = function (x, y) {
+    if (x < this.CHOICES_LEFT || x > this.CHOICES_RIGHT) return;
+    var choices = core.status.event.ui.choices;
+
+    var topIndex = this.HSIZE - parseInt((choices.length - 1) / 2) + (core.status.event.ui.offset || 0);
+
+    if (y >= topIndex && y < topIndex + choices.length) {
+        var selection = y - topIndex;
+        core.status.event.selection = selection;
+        switch (selection) {
+            case 0: return core.ui.drawStatistics();
+            case 1: return this._clickGameInfo_openProject();
+            case 2: return this._clickGameInfo_openComments();
+            case 3: return core.ui.drawHelp();
+            case 4: return core.ui.drawAbout();
+            case 5: return this._clickGameInfo_download();
+            case 6:
+                core.status.event.selection = 5;
+                core.ui.drawSettings();
                 break;
         }
     }
 }
 
-////// 回放选择界面时，按下某个键的操作 //////
-actions.prototype.keyDownReplay = function (keycode) {
-    if (keycode==38) {
-        core.status.event.selection--;
-        core.ui.drawChoices(core.status.event.ui.text, core.status.event.ui.choices);
-    }
-    if (keycode==40) {
-        core.status.event.selection++;
-        core.ui.drawChoices(core.status.event.ui.text, core.status.event.ui.choices);
+actions.prototype._clickGameInfo_openProject = function () {
+    if (core.platform.isPC)
+        window.open("editor.html", "_blank");
+    else {
+        core.myconfirm("即将离开本塔，跳转至本塔工程页面，确认？", function () {
+            window.location.href = "editor-mobile.html";
+        });
     }
 }
 
-////// 回放选择界面时，放开某个键的操作 //////
-actions.prototype.keyUpReplay = function (keycode) {
-    if (keycode==27 || keycode==88) {
+actions.prototype._clickGameInfo_openComments = function () {
+    if (core.platform.isPC) {
+        window.open("/score.php?name=" + core.firstData.name + "&num=10", "_blank");
+    }
+    else {
+        core.myconfirm("即将离开本塔，跳转至本塔评论页面，确认？", function () {
+            window.location.href = "/score.php?name=" + core.firstData.name + "&num=10";
+        });
+    }
+}
+
+actions.prototype._clickGameInfo_download = function () {
+    if (core.platform.isPC)
+        window.open(core.firstData.name + ".zip");
+    else
+        window.location.href = core.firstData.name + ".zip";
+}
+
+////// 游戏信息界面时，放开某个键的操作 //////
+actions.prototype._keyUpGameInfo = function (keycode) {
+    if (keycode == 27 || keycode == 88) {
         core.ui.closePanel();
         return;
     }
-    var choices = core.status.event.ui.choices;
-    if (keycode==13 || keycode==32 || keycode==67) {
-        var topIndex = 6 - parseInt((choices.length - 1) / 2);
-        this.clickReplay(6, topIndex+core.status.event.selection);
-    }
+    this._selectChoices(core.status.event.ui.choices.length, keycode, this._clickGameInfo);
 }
 
 ////// “虚拟键盘”界面时的点击操作 //////
-actions.prototype.clickKeyBoard = function (x, y) {
-    if (y==3 && x>=1 && x<=11) {
+actions.prototype._clickKeyBoard = function (x, y) {
+    var m = this.HSIZE;
+    if (y == m - 3 && x >= m - 5 && x <= m + 5) {
         core.ui.closePanel();
-        core.keyUp(112+x-1); // F1-F12: 112-122
+        core.keyUp(112 + x + 5 - m);
     }
-    if (y==4 && x>=1 && x<=10) {
+    if (y == m - 3 && x == m + 6) {
+        var val = prompt();
+        if (val != null) {
+            try {
+                eval(val);
+            }
+            catch (e) {
+            }
+        }
+    }
+    if (y == m - 2 && x >= m - 5 && x <= m + 4) {
         core.ui.closePanel();
-        core.keyUp(x==10?48:48+x); // 1-9: 49-57; 0: 48
+        core.keyUp(x == m + 4 ? 48 : 49 + x + 5 - m); // 1-9: 49-57; 0: 48
     }
     // 字母
     var lines = [
-        ["Q","W","E","R","T","Y","U","I","O","P"],
-        ["A","S","D","F","G","H","J","K","L"],
-        ["Z","X","C","V","B","N","M"],
+        ["Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P"],
+        ["A", "S", "D", "F", "G", "H", "J", "K", "L"],
+        ["Z", "X", "C", "V", "B", "N", "M"],
     ];
-    if (y==5 && x>=1 && x<=10) {
+    if (y == m - 1 && x >= m - 5 && x <= m + 4) {
         core.ui.closePanel();
-        core.keyUp(lines[0][x-1].charCodeAt(0));
+        core.keyUp(lines[0][x + 5 - m].charCodeAt(0));
     }
-    if (y==6 && x>=1 && x<=9) {
+    if (y == m && x >= m - 5 && x <= m + 3) {
         core.ui.closePanel();
-        core.keyUp(lines[1][x-1].charCodeAt(0));
+        core.keyUp(lines[1][x + 5 - m].charCodeAt(0));
     }
-    if (y==7 && x>=1 && x<=7) {
+    if (y == m + 1 && x >= m - 5 && x <= m + 1) {
         core.ui.closePanel();
-        core.keyUp(lines[2][x-1].charCodeAt(0));
+        core.keyUp(lines[2][x + 5 - m].charCodeAt(0));
     }
-    if (y==8 && x>=1 && x<=11) {
+    if (y == m + 2 && x >= m - 5 && x <= m + 5) {
         core.ui.closePanel();
-        if (x==1) core.keyUp(189); // -
-        if (x==2) core.keyUp(187); // =
-        if (x==3) core.keyUp(219); // [
-        if (x==4) core.keyUp(221); // ]
-        if (x==5) core.keyUp(220); // \
-        if (x==6) core.keyUp(186); // ;
-        if (x==7) core.keyUp(222); // '
-        if (x==8) core.keyUp(188); // ,
-        if (x==9) core.keyUp(190); // .
-        if (x==10) core.keyUp(191); // /
-        if (x==11) core.keyUp(192); // `
+        if (x == m - 5) core.keyUp(189); // -
+        if (x == m - 4) core.keyUp(187); // =
+        if (x == m - 3) core.keyUp(219); // [
+        if (x == m - 2) core.keyUp(221); // ]
+        if (x == m - 1) core.keyUp(220); // \
+        if (x == m) core.keyUp(186); // ;
+        if (x == m + 1) core.keyUp(222); // '
+        if (x == m + 2) core.keyUp(188); // ,
+        if (x == m + 3) core.keyUp(190); // .
+        if (x == m + 4) core.keyUp(191); // /
+        if (x == m + 5) core.keyUp(192); // `
     }
-    if (y==9 && x>=1 && x<=10) {
+    if (y == m + 3 && x >= m - 5 && x <= m + 4) {
         core.ui.closePanel();
-        if (x==1) core.keyUp(27); // ESC
-        if (x==2) core.keyUp(9); // TAB
-        if (x==3) core.keyUp(20); // CAPS
-        if (x==4) core.keyUp(16); // SHIFT
-        if (x==5) core.keyUp(17); // CTRL
-        if (x==6) core.keyUp(18); // ALT
-        if (x==7) core.keyUp(32); // SPACE
-        if (x==8) core.keyUp(8); // BACKSPACE
-        if (x==9) core.keyUp(13); // ENTER
-        if (x==10) core.keyUp(46); // DEL
+        if (x == m - 5) core.keyUp(27); // ESC
+        if (x == m - 4) core.keyUp(9); // TAB
+        if (x == m - 3) core.keyUp(20); // CAPS
+        if (x == m - 2) core.keyUp(16); // SHIFT
+        if (x == m - 1) core.keyUp(17); // CTRL
+        if (x == m) core.keyUp(18); // ALT
+        if (x == m + 1) core.keyUp(32); // SPACE
+        if (x == m + 2) core.keyUp(8); // BACKSPACE
+        if (x == m + 3) core.keyUp(13); // ENTER
+        if (x == m + 4) core.keyUp(46); // DEL
     }
-    if (y==10 && x>=9 && x<=11)
+    if (y == m + 4 && x >= m + 3 && x <= m + 5)
         core.ui.closePanel();
 }
 
 ////// 光标界面时的点击操作 //////
-actions.prototype.clickCursor = function (x,y) {
-
-    if (x==core.status.automaticRoute.cursorX && y==core.status.automaticRoute.cursorY) {
+actions.prototype._clickCursor = function (x, y) {
+    if (x == core.status.automaticRoute.cursorX && y == core.status.automaticRoute.cursorY) {
         core.ui.closePanel();
-        core.onclick(x,y,[]);
+        core.onclick(x, y, []);
         return;
     }
-    core.status.automaticRoute.cursorX=x;
-    core.status.automaticRoute.cursorY=y;
+    core.status.automaticRoute.cursorX = x;
+    core.status.automaticRoute.cursorY = y;
     core.ui.drawCursor();
 }
 
 ////// 光标界面时，按下某个键的操作 //////
-actions.prototype.keyDownCursor = function (keycode) {
-    if (keycode==37) { // left
+actions.prototype._keyDownCursor = function (keycode) {
+    if (keycode == 37) { // left
         core.status.automaticRoute.cursorX--;
         core.ui.drawCursor();
         return;
     }
-    if (keycode==38) { // up
+    if (keycode == 38) { // up
         core.status.automaticRoute.cursorY--;
         core.ui.drawCursor();
         return;
     }
-    if (keycode==39) { // right
+    if (keycode == 39) { // right
         core.status.automaticRoute.cursorX++;
         core.ui.drawCursor();
         return;
     }
-    if (keycode==40) { // down
+    if (keycode == 40) { // down
         core.status.automaticRoute.cursorY++;
         core.ui.drawCursor();
         return;
@@ -2216,22 +2499,119 @@ actions.prototype.keyDownCursor = function (keycode) {
 }
 
 ////// 光标界面时，放开某个键的操作 //////
-actions.prototype.keyUpCursor = function (keycode) {
-    if (keycode==27 || keycode==88) {
+actions.prototype._keyUpCursor = function (keycode) {
+    if (keycode == 27 || keycode == 88) {
         core.ui.closePanel();
         return;
     }
-    if (keycode==13 || keycode==32 || keycode==67 || keycode==69) {
+    if (keycode == 13 || keycode == 32 || keycode == 67 || keycode == 69) {
         core.ui.closePanel();
         core.onclick(core.status.automaticRoute.cursorX, core.status.automaticRoute.cursorY, []);
         return;
     }
 }
 
-////// “关于”界面时的点击操作 //////
-actions.prototype.clickAbout = function () {
-    if (core.isPlaying())
-        core.ui.closePanel();
-    else
-        core.restart();
+////// 绘图相关 //////
+
+actions.prototype._ondownPaint = function (x, y) {
+    x += core.bigmap.offsetX;
+    y += core.bigmap.offsetY;
+    if (!core.status.event.data.erase) {
+        core.dymCanvas.paint.beginPath();
+        core.dymCanvas.paint.moveTo(x, y);
+    }
+    core.status.event.data.x = x;
+    core.status.event.data.y = y;
 }
+
+actions.prototype._onmovePaint = function (x, y) {
+    if (core.status.event.data.x == null) return;
+    x += core.bigmap.offsetX;
+    y += core.bigmap.offsetY;
+    if (core.status.event.data.erase) {
+        core.clearMap('paint', x - 10, y - 10, 20, 20);
+        return;
+    }
+    var midx = (core.status.event.data.x + x) / 2, midy = (core.status.event.data.y + y) / 2;
+    core.dymCanvas.paint.quadraticCurveTo(midx, midy, x, y);
+    core.dymCanvas.paint.stroke();
+    core.status.event.data.x = x;
+    core.status.event.data.y = y;
+}
+
+actions.prototype._onupPaint = function () {
+    core.status.event.data.x = null;
+    core.status.event.data.y = null;
+    // 保存
+    core.paint[core.status.floorId] = lzw_encode(core.utils._encodeCanvas(core.dymCanvas.paint).join(","));
+}
+
+actions.prototype.setPaintMode = function (mode) {
+    if (mode == 'paint') core.status.event.data.erase = false;
+    else if (mode == 'erase') core.status.event.data.erase = true;
+    else return;
+
+    core.drawTip("进入" + (core.status.event.data.erase ? "擦除" : "绘图") + "模式");
+}
+
+actions.prototype.clearPaint = function () {
+    core.clearMap('paint');
+    delete core.paint[core.status.floorId];
+    core.drawTip("已清空绘图内容");
+}
+
+actions.prototype.savePaint = function () {
+    var data = {};
+    for (var floorId in core.paint) {
+        if (core.paint[floorId])
+            data[floorId] = lzw_decode(core.paint[floorId]);
+    }
+    core.download(core.firstData.name + ".h5paint", JSON.stringify({
+        'name': core.firstData.name,
+        'paint': data
+    }));
+}
+
+actions.prototype.loadPaint = function () {
+    core.readFile(function (obj) {
+        if (obj.name != core.firstData.name) {
+            alert("绘图文件和游戏不一致！");
+            return;
+        }
+        if (!obj.paint) {
+            alert("无效的绘图文件！");
+            return;
+        }
+        core.paint = {};
+        for (var floorId in obj.paint) {
+            if (obj.paint[floorId])
+                core.paint[floorId] = lzw_encode(obj.paint[floorId]);
+        }
+
+        core.clearMap('paint');
+        var value = core.paint[core.status.floorId];
+        if (value) value = lzw_decode(value).split(",");
+        core.utils._decodeCanvas(value, 32 * core.bigmap.width, 32 * core.bigmap.height);
+        core.drawImage('paint', core.bigmap.tempCanvas.canvas, 0, 0);
+
+        core.drawTip("读取绘图文件成功");
+    })
+}
+
+actions.prototype.exitPaint = function () {
+    core.deleteCanvas('paint');
+    core.ui.closePanel();
+    core.statusBar.image.keyboard.style.opacity = 1;
+    core.statusBar.image.shop.style.opacity = 1;
+    core.updateStatusBar();
+    core.drawTip("退出绘图模式");
+}
+
+actions.prototype._keyUpPaint = function (keycode) {
+    if (keycode == 27 || keycode == 88 || keycode == 77 || keycode == 13 || keycode == 32 || keycode == 67) {
+        this.exitPaint();
+        return;
+    }
+}
+
+////// 绘图相关 END //////
diff --git a/libs/control.js b/libs/control.js
index bfed3751..d3289e37 100644
--- a/libs/control.js
+++ b/libs/control.js
@@ -4,17 +4,86 @@ control.js：游戏主要逻辑控制
 寻路算法和人物行走也在此文件内
  */
 
+"use strict";
+
 function control() {
-    this.init();
+    this._init();
 }
 
-control.prototype.init = function () {
+control.prototype._init = function () {
+    this.controldata = functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a.control;
+    this.renderFrameFuncs = [];
+    this.replayActions = [];
+    this.resizes = [];
+    // --- 注册系统的animationFrame
+    this.registerAnimationFrame("totalTime", false, this._animationFrame_totalTime);
+    this.registerAnimationFrame("autoSave", true, this._animationFrame_autoSave);
+    this.registerAnimationFrame("globalAnimate", true, this._animationFrame_globalAnimate);
+    this.registerAnimationFrame("selector", false, this._animationFrame_selector);
+    this.registerAnimationFrame("animate", true, this._animationFrame_animate);
+    this.registerAnimationFrame("heroMoving", true, this._animationFrame_heroMoving);
+    this.registerAnimationFrame("weather", true, this._animationFrame_weather);
+    this.registerAnimationFrame("parallelDo", false, this._animationFrame_parallelDo);
+    this.registerAnimationFrame("checkConsoleOpened", true, this._animationFrame_checkConsoleOpened);
+    // --- 注册系统的replay
+    this.registerReplayAction("move", this._replayAction_move);
+    this.registerReplayAction("item", this._replayAction_item);
+    this.registerReplayAction("equip", this._replayAction_equip);
+    this.registerReplayAction("unEquip", this._replayAction_unEquip);
+    this.registerReplayAction("fly", this._replayAction_fly);
+    this.registerReplayAction("shop", this._replayAction_shop);
+    this.registerReplayAction("turn", this._replayAction_turn);
+    this.registerReplayAction("getNext", this._replayAction_getNext);
+    this.registerReplayAction("moveDirectly", this._replayAction_moveDirectly);
+    this.registerReplayAction("key", this._replayAction_key);
+    // --- 注册系统的resize
+    this.registerResize("gameGroup", this._resize_gameGroup);
+    this.registerResize("canvas", this._resize_canvas);
+    this.registerResize("statusBar", this._resize_statusBar);
+    this.registerResize("status", this._resize_status);
+    this.registerResize("toolBar", this._resize_toolBar);
+    this.registerResize("tools", this._resize_tools);
+}
 
+// ------ requestAnimationFrame 相关 ------ //
+
+////// 注册一个 animationFrame //////
+// name：名称，可用来作为注销使用；needPlaying：是否只在游戏运行时才执行（在标题界面不执行）
+// func：要执行的函数，或插件中的函数名；可接受timestamp（从页面加载完毕到当前所经过的时间）作为参数
+control.prototype.registerAnimationFrame = function (name, needPlaying, func) {
+    this.unregisterAnimationFrame(name);
+    this.renderFrameFuncs.push({name: name, needPlaying: needPlaying, func: func});
+}
+
+////// 注销一个 animationFrame //////
+control.prototype.unregisterAnimationFrame = function (name) {
+    this.renderFrameFuncs = this.renderFrameFuncs.filter(function (x) { return x.name!=name; });
 }
 
 ////// 设置requestAnimationFrame //////
-control.prototype.setRequestAnimationFrame = function () {
+control.prototype._setRequestAnimationFrame = function () {
+    this._checkRequestAnimationFrame();
+    core.animateFrame.totalTime = Math.max(core.animateFrame.totalTime, core.getLocalStorage('totalTime', 0));
+    var loop = function (timestamp) {
+        core.control.renderFrameFuncs.forEach(function (b) {
+            if (b.func) {
+                try {
+                    if (core.isPlaying() || !b.needPlaying)
+                        core.doFunc(b.func, core.control, timestamp);
+                }
+                catch (e) {
+                    main.log(e);
+                    main.log("ERROR in requestAnimationFrame["+b.name+"]：已自动注销该项。");
+                    core.unregisterAnimationFrame(b.name);
+                }
+            }
+        })
+        window.requestAnimationFrame(loop);
+    }
+    window.requestAnimationFrame(loop);
+}
 
+control.prototype._checkRequestAnimationFrame = function () {
     (function() {
         var lastTime = 0;
         var vendors = ['webkit', 'moz'];
@@ -41,145 +110,209 @@ control.prototype.setRequestAnimationFrame = function () {
             };
         }
     }());
-
-    core.animateFrame.speed = core.values.animateSpeed;
-    core.animateFrame.background = core.canvas.ui.createPattern(core.material.ground, "repeat");
-
-    var scan = {
-        'up': {'x': 0, 'y': -1},
-        'left': {'x': -1, 'y': 0},
-        'down': {'x': 0, 'y': 1},
-        'right': {'x': 1, 'y': 0}
-    };
-
-    var draw = function(timestamp) {
-
-        core.animateFrame.globalTime = core.animateFrame.globalTime||timestamp;
-        core.animateFrame.boxTime = core.animateFrame.boxTime||timestamp;
-        core.animateFrame.moveTime = core.animateFrame.moveTime||timestamp;
-        core.animateFrame.weather.time = core.animateFrame.weather.time||timestamp;
-
-        // move time
-        if (core.isPlaying() && core.isset(core.status) && core.isset(core.status.hero)
-            && core.isset(core.status.hero.statistics)) {
-            core.status.hero.statistics.totalTime += timestamp-(core.status.hero.statistics.start||timestamp);
-            core.status.hero.statistics.currTime += timestamp-(core.status.hero.statistics.start||timestamp);
-            core.status.hero.statistics.start=timestamp;
-        }
-
-        // Global Animate
-        if (core.animateFrame.globalAnimate && core.isPlaying()) {
-
-            if (timestamp-core.animateFrame.globalTime>core.animateFrame.speed && core.isset(core.status.globalAnimateObjs)) {
-
-                for (var a = 0; a < core.status.globalAnimateObjs.length; a++) {
-                    var obj = core.status.globalAnimateObjs[a];
-                    obj.status = (obj.status+1)%(obj.event.animate||1);
-                    core.drawBlock(obj, obj.status);
-                }
-
-                core.animateFrame.globalTime = timestamp;
-            }
-        }
-
-        // Box
-        if (timestamp-core.animateFrame.boxTime>core.animateFrame.speed && core.isset(core.status.boxAnimateObjs) && core.status.boxAnimateObjs.length>0) {
-            core.drawBoxAnimate();
-            core.animateFrame.boxTime = timestamp;
-        }
-
-        // Hero move
-        if (timestamp-core.animateFrame.moveTime>16 && core.isset(core.status.heroMoving) && core.status.heroMoving>0) {
-            var x=core.getHeroLoc('x'), y=core.getHeroLoc('y'), direction = core.getHeroLoc('direction');
-            if (core.status.heroMoving<=4) {
-                core.drawHero(direction, x, y, 'leftFoot', 4*core.status.heroMoving);
-            }
-            else if (core.status.heroMoving<=8) {
-                core.drawHero(direction, x, y, 'rightFoot', 4*core.status.heroMoving);
-            }
-            core.animateFrame.moveTime = timestamp;
-        }
-
-        // weather
-        if (core.isPlaying() && timestamp-core.animateFrame.weather.time>30) {
-            if (core.animateFrame.weather.type == 'rain' && core.animateFrame.weather.level > 0) {
-
-                core.clearMap('weather');
-
-                core.canvas.weather.strokeStyle = 'rgba(174,194,224,0.8)';
-                core.canvas.weather.lineWidth = 1;
-                core.canvas.weather.lineCap = 'round';
-
-                core.animateFrame.weather.nodes.forEach(function (p) {
-                    core.canvas.weather.beginPath();
-                    core.canvas.weather.moveTo(p.x, p.y);
-                    core.canvas.weather.lineTo(p.x + p.l * p.xs, p.y + p.l * p.ys);
-                    core.canvas.weather.stroke();
-
-                    p.x += p.xs;
-                    p.y += p.ys;
-                    if (p.x > 416 || p.y > 416) {
-                        p.x = Math.random() * 416;
-                        p.y = -10;
-                    }
-
-                })
-
-                core.canvas.weather.fill();
-
-            }
-            else if (core.animateFrame.weather.type == 'snow' && core.animateFrame.weather.level > 0) {
-
-                core.clearMap('weather');
-
-                core.canvas.weather.fillStyle = "rgba(255, 255, 255, 0.8)";
-                core.canvas.weather.beginPath();
-
-                if (!core.isset(core.animateFrame.weather.data))
-                    core.animateFrame.weather.data = 0;
-                core.animateFrame.weather.data += 0.01;
-
-                var angle = core.animateFrame.weather.data;
-                core.animateFrame.weather.nodes.forEach(function (p) {
-                    core.canvas.weather.moveTo(p.x, p.y);
-                    core.canvas.weather.arc(p.x, p.y, p.r, 0, Math.PI * 2, true);
-
-                    // update
-                    p.x += Math.sin(angle) * 2;
-                    p.y += Math.cos(angle + p.d) + 1 + p.r / 2;
-
-                    if (p.x > 416 + 5 || p.x < -5 || p.y > 416) {
-                        if (Math.random() > 1 / 3) {
-                            p.x = Math.random() * 416;
-                            p.y = -10;
-                        }
-                        else {
-                            if (Math.sin(angle) > 0) {
-                                p.x = -5;
-                                p.y = Math.random() * 416;
-                            }
-                            else {
-                                p.x = 416 + 5;
-                                p.y = Math.random() * 416;
-                            }
-                        }
-                    }
-
-                })
-
-                core.canvas.weather.fill();
-
-            }
-            core.animateFrame.weather.time = timestamp;
-
-        }
-        window.requestAnimationFrame(draw);
-    }
-    window.requestAnimationFrame(draw);
 }
 
+control.prototype._animationFrame_totalTime = function (timestamp) {
+    core.animateFrame.totalTime += timestamp - core.animateFrame.totalTimeStart;
+    core.animateFrame.totalTimeStart = timestamp;
+    if (core.isPlaying()) {
+        core.status.hero.statistics.totalTime = core.animateFrame.totalTime;
+        core.status.hero.statistics.currTime += timestamp-(core.status.hero.statistics.start||timestamp);
+        core.status.hero.statistics.start = timestamp;
+    }
+}
+
+control.prototype._animationFrame_autoSave = function (timestamp) {
+    if (timestamp - core.saves.autosave.time <= 5000) return;
+    core.control.checkAutosave();
+    core.saves.autosave.time = timestamp;
+}
+
+control.prototype._animationFrame_globalAnimate = function (timestamp) {
+    if (timestamp - core.animateFrame.globalTime <= core.values.animateSpeed) return;
+    core.status.globalAnimateStatus++;
+    if (core.status.floorId) {
+        // Global Animate
+        core.status.globalAnimateObjs.forEach(function (block) {
+            core.drawBlock(block, core.status.globalAnimateStatus % (block.event.animate||1));
+        });
+
+        // Global floor images
+        core.maps._drawFloorImages(core.status.floorId, core.canvas.bg, 'bg', core.status.floorAnimateObjs||[], core.status.globalAnimateStatus);
+        core.maps._drawFloorImages(core.status.floorId, core.canvas.fg, 'fg', core.status.floorAnimateObjs||[], core.status.globalAnimateStatus);
+
+        // Global Autotile Animate
+        core.status.autotileAnimateObjs.blocks.forEach(function (block) {
+            core.maps._drawAutotileAnimate(block, core.status.globalAnimateStatus);
+        });
+    }
+    // Box animate
+    core.drawBoxAnimate();
+    core.animateFrame.globalTime = timestamp;
+}
+
+control.prototype._animationFrame_selector = function (timestamp) {
+    if (timestamp - core.animateFrame.selectorTime <= 20 || !core.dymCanvas._selector) return;
+    var opacity = parseFloat(core.dymCanvas._selector.canvas.style.opacity);
+    if (core.animateFrame.selectorUp)
+        opacity += 0.02;
+    else
+        opacity -= 0.02;
+    if (opacity > 0.95 || opacity < 0.55)
+        core.animateFrame.selectorUp = !core.animateFrame.selectorUp;
+    core.setOpacity("_selector", opacity);
+    core.animateFrame.selectorTime = timestamp;
+}
+
+control.prototype._animationFrame_animate = function (timestamp) {
+    if (timestamp - core.animateFrame.animateTime < 50 || !core.status.animateObjs || core.status.animateObjs.length == 0) return;
+    core.clearMap('animate');
+    // 更新帧
+    for (var i = 0; i < core.status.animateObjs.length; i++) {
+        var obj = core.status.animateObjs[i];
+        if (obj.index == obj.animate.frames.length) {
+            (function (callback) {
+                setTimeout(function () {
+                    if (callback) callback();
+                });
+            })(obj.callback);
+        }
+    }
+    core.status.animateObjs = core.status.animateObjs.filter(function (obj) {
+        return obj.index < obj.animate.frames.length;
+    });
+    core.status.animateObjs.forEach(function (obj) {
+        core.maps._drawAnimateFrame(obj.animate, obj.centerX, obj.centerY, obj.index++);
+    });
+    core.animateFrame.animateTime = timestamp;
+}
+
+control.prototype._animationFrame_heroMoving = function (timestamp) {
+    if (core.status.heroMoving <= 0) return;
+    // 换腿
+    if (timestamp - core.animateFrame.moveTime > (core.values.moveSpeed||100)) {
+        core.animateFrame.leftLeg = !core.animateFrame.leftLeg;
+        core.animateFrame.moveTime = timestamp;
+    }
+    core.drawHero(core.animateFrame.leftLeg?'leftFoot':'rightFoot', 4*core.status.heroMoving);
+}
+
+control.prototype._animationFrame_weather = function (timestamp) {
+    var weather = core.animateFrame.weather;
+    if (timestamp - weather.time <= 30 || !core.dymCanvas.weather) return;
+    core.control["_animationFrame_weather_"+weather.type]();
+    weather.time = timestamp;
+}
+
+control.prototype._animationFrame_weather_rain = function () {
+    var ctx = core.dymCanvas.weather, ox = core.bigmap.offsetX, oy = core.bigmap.offsetY;
+    core.clearMap('weather');
+    ctx.strokeStyle = 'rgba(174,194,224,0.8)';
+    ctx.lineWidth = 1;
+    ctx.lineCap = 'round';
+
+    core.animateFrame.weather.nodes.forEach(function (p) {
+        ctx.beginPath();
+        ctx.moveTo(p.x-ox, p.y-oy);
+        ctx.lineTo(p.x + p.l * p.xs - ox, p.y + p.l * p.ys - oy);
+        ctx.stroke();
+
+        p.x += p.xs;
+        p.y += p.ys;
+        if (p.x > core.bigmap.width * 32 || p.y > core.bigmap.height * 32) {
+            p.x = Math.random() * core.bigmap.width * 32;
+            p.y = -10;
+        }
+
+    });
+
+    ctx.fill();
+}
+
+control.prototype._animationFrame_weather_snow = function () {
+    var ctx = core.dymCanvas.weather, ox = core.bigmap.offsetX, oy = core.bigmap.offsetY;
+    core.clearMap('weather');
+    ctx.fillStyle = "rgba(255, 255, 255, 0.8)";
+    ctx.beginPath();
+    core.animateFrame.weather.data = core.animateFrame.weather.data || 0;
+    core.animateFrame.weather.data += 0.01;
+
+    var angle = core.animateFrame.weather.data;
+    core.animateFrame.weather.nodes.forEach(function (p) {
+        ctx.moveTo(p.x - ox, p.y - oy);
+        ctx.arc(p.x - ox, p.y - oy, p.r, 0, Math.PI * 2, true);
+        // update
+        p.x += Math.sin(angle) * 2;
+        p.y += Math.cos(angle + p.d) + 1 + p.r / 2;
+        if (p.x > core.bigmap.width*32 + 5 || p.x < -5 || p.y > core.bigmap.height*32) {
+            if (Math.random() > 1 / 3) {
+                p.x = Math.random() * core.bigmap.width*32;
+                p.y = -10;
+            }
+            else {
+                if (Math.sin(angle) > 0)
+                    p.x = -5;
+                else
+                    p.x = core.bigmap.width*32 + 5;
+                p.y = Math.random() * core.bigmap.height*32;
+            }
+        }
+    });
+    ctx.fill();
+}
+
+control.prototype._animationFrame_weather_fog = function () {
+    var ctx = core.dymCanvas.weather, ox = core.bigmap.offsetX, oy = core.bigmap.offsetY;
+    core.clearMap('weather');
+    if (core.animateFrame.weather.fog) {
+        var w = core.__PIXELS__, h = core.__PIXELS__;
+        core.setAlpha('weather', 0.5);
+        core.animateFrame.weather.nodes.forEach(function (p) {
+            ctx.drawImage(core.animateFrame.weather.fog, p.x - ox, p.y - oy, w, h);
+            p.x += p.xs;
+            p.y += p.ys;
+            if (p.x > core.bigmap.width*32 - w/2) {
+                p.x = core.bigmap.width*32 - w/2 - 1;
+                p.xs = -p.xs;
+            }
+            if (p.x < -w/2) {
+                p.x = -w/2+1;
+                p.xs = -p.xs;
+            }
+            if (p.y > core.bigmap.height*32 - h/2) {
+                p.y = core.bigmap.height*32 - h/2 - 1;
+                p.ys = -p.ys;
+            }
+            if (p.y < -h/2) {
+                p.y = -h/2+1;
+                p.ys = -p.ys;
+            }
+        });
+        core.setAlpha('weather',1);
+    }
+}
+
+control.prototype._animationFrame_parallelDo = function (timestamp) {
+    core.control.controldata.parallelDo(timestamp);
+}
+
+control.prototype._animationFrame_checkConsoleOpened = function (timestamp) {
+    if (core.consoleOpened()) core.setFlag('__consoleOpened__', true);
+}
+
+// ------ 标题界面的处理 ------ //
+
 ////// 显示游戏开始界面 //////
-control.prototype.showStartAnimate = function (callback) {
+control.prototype.showStartAnimate = function (noAnimate, callback) {
+    this._showStartAnimate_resetDom();
+    if (core.flags.startUsingCanvas || noAnimate)
+        return this._showStartAnimate_finished(core.flags.startUsingCanvas, callback);
+    core.hideWithAnimate(core.dom.startTop, 20, function () {
+        core.control._showStartAnimate_finished(false, callback);
+    });
+}
+
+control.prototype._showStartAnimate_resetDom = function () {
     core.dom.startPanel.style.opacity=1;
     core.dom.startPanel.style.display="block";
     core.dom.startTop.style.opacity=1;
@@ -187,43 +320,31 @@ control.prototype.showStartAnimate = function (callback) {
     core.dom.startButtonGroup.style.display = 'none';
     core.dom.startButtons.style.display = 'block';
     core.dom.levelChooseButtons.style.display = 'none';
-    core.dom.curtain.style.background = "#000000";
-    core.dom.curtain.style.opacity = 0;
     core.status.played = false;
     core.clearStatus();
     core.clearMap('all');
+    core.dom.musicBtn.style.display = 'block';
+    core.setMusicBtn();
+    // 重置音量
+    core.events.setVolume(1, 0);
+    core.updateStatusBar();
+}
 
-    var opacityVal = 1;
-    var startAnimate = window.setInterval(function () {
-        opacityVal -= 0.03;
-        if (opacityVal < 0) {
-            clearInterval(startAnimate);
-            core.dom.startTop.style.display = 'none';
-            // core.playGame();
-            core.dom.startButtonGroup.style.display = 'block';
-            if (core.isset(callback)) callback();
-        }
-        core.dom.startTop.style.opacity = opacityVal;
-    }, 20);
+control.prototype._showStartAnimate_finished = function (start, callback) {
+    core.dom.startTop.style.display = 'none';
+    core.dom.startButtonGroup.style.display = 'block';
+    if (start) core.startGame();
+    if (callback) callback();
 }
 
 ////// 隐藏游戏开始界面 //////
 control.prototype.hideStartAnimate = function (callback) {
-    var opacityVal = 1;
-    var startAnimate = window.setInterval(function () {
-        opacityVal -= 0.03;
-        if (opacityVal < 0) {
-            clearInterval(startAnimate);
-            core.dom.startPanel.style.display = 'none';
-            if (core.isset(callback)) callback();
-        }
-        core.dom.startPanel.style.opacity = opacityVal;
-    }, 20);
+    core.hideWithAnimate(core.dom.startPanel, 20, callback);
 }
 
 ////// 游戏是否已经开始 //////
 control.prototype.isPlaying = function() {
-    return core.isset(core.status.played) && core.status.played;
+    return core.status.played;
 }
 
 ////// 清除游戏状态和数据 //////
@@ -239,118 +360,37 @@ control.prototype.clearStatus = function() {
     }
     core.status = {};
     core.clearStatusBar();
-    core.resize(main.dom.body.clientWidth, main.dom.body.clientHeight);
+    core.deleteAllCanvas();
+    core.status.played = false;
 }
 
-////// 重置游戏状态和初始数据 //////
-control.prototype.resetStatus = function(hero, hard, floorId, route, maps, values) {
-
-    var totalTime=0;
-    if (core.isset(core.status) && core.isset(core.status.hero)
-        && core.isset(core.status.hero.statistics) && core.isset(route)) {
-        totalTime=core.status.hero.statistics.totalTime;
-    }
-
-    // 停止各个Timeout和Interval
-    for (var i in core.timeout) {
-        clearTimeout(core.timeout[i]);
-        core.timeout[i] = null;
-    }
-    for (var i in core.interval) {
-        clearInterval(core.interval[i]);
-        core.interval[i] = null;
-    }
-    core.clearStatusBar();
-
-    // 初始化status
-    core.status = core.clone(core.initStatus);
-    core.status.played = true;
-    // 初始化maps
-    core.status.floorId = floorId;
-    core.status.maps = core.clone(maps);
-    // 初始化怪物
-    core.material.enemys = core.clone(core.enemys.getEnemys());
-    core.material.items = core.clone(core.items.getItems());
-    // 初始化人物属性
-    core.status.hero = core.clone(hero);
-    // 统计数据
+control.prototype._initStatistics = function (totalTime) {
     if (!core.isset(core.status.hero.statistics))
         core.status.hero.statistics = {
             'totalTime': totalTime,
             'currTime': 0,
             'hp': 0,
+            "battle": 0,
+            'money': 0,
+            'experience': 0,
             'battleDamage': 0,
             'poisonDamage': 0,
             'extraDamage': 0,
             'moveDirectly': 0,
             'ignoreSteps': 0,
         }
-    core.status.hero.statistics.totalTime = Math.max(core.status.hero.statistics.totalTime, totalTime);
-    core.status.hero.statistics.start = null;
-
-    core.status.hard = hard;
-    // 初始化路线
-    if (core.isset(route))
-        core.status.route = route;
-    // 保存的Index
-    core.status.saveIndex = core.getLocalStorage('saveIndex2', 1);
-
-    core.status.automaticRoute.clickMoveDirectly = core.getLocalStorage('clickMoveDirectly', true);
-
-    if (core.isset(values))
-        core.values = core.clone(values);
-    else core.values = core.clone(core.data.values);
-
-    core.events.initGame();
 }
 
-////// 开始游戏 //////
-control.prototype.startGame = function (hard, callback) {
-    console.log('开始游戏');
-
-    this.resetStatus(core.firstData.hero, hard, core.firstData.floorId, null, core.initStatus.maps);
-
-    core.changeFloor(core.status.floorId, null, core.firstData.hero.loc, null, function() {
-        if (core.isset(callback)) callback();
-    }, true);
-
-    setTimeout(function () {
-        // Upload
-        var formData = new FormData();
-        formData.append('type', 'people');
-        formData.append('name', core.firstData.name);
-        formData.append('version', core.firstData.version);
-        formData.append('platform', core.platform.isPC?"PC":core.platform.isAndroid?"Android":core.platform.isIOS?"iOS":"");
-        formData.append('hard', core.encodeBase64(hard));
-        formData.append('hardCode', core.getFlag('hard', 0));
-        formData.append('base64', 1);
-
-        core.utils.http("POST", "/games/upload.php", formData);
-    })
-
-}
-
-////// 重新开始游戏；此函数将回到标题页面 //////
-control.prototype.restart = function() {
-    this.showStartAnimate();
-    if (core.bgms.length>0)
-        core.playBgm(core.bgms[0]);
-}
-
-
-/////////////////////// 寻路算法 & 人物行走控制 ///////////////////////
+// ------ 自动寻路，人物行走 ------ //
 
 ////// 清除自动寻路路线 //////
 control.prototype.clearAutomaticRouteNode = function (x, y) {
-    if (core.status.event.id==null)
-        core.canvas.route.clearRect(x * 32 + 5, y * 32 + 5, 27, 27);
+    core.clearMap('route', x * 32 + 5 - core.status.automaticRoute.offsetX, y * 32 + 5 - core.status.automaticRoute.offsetY, 27, 27);
 }
 
 ////// 停止自动寻路操作 //////
 control.prototype.stopAutomaticRoute = function () {
-    if (!core.status.played) {
-        return;
-    }
+    if (!core.status.played) return;
     core.status.automaticRoute.autoHeroMove = false;
     core.status.automaticRoute.autoStep = 0;
     core.status.automaticRoute.destStep = 0;
@@ -359,9 +399,20 @@ control.prototype.stopAutomaticRoute = function () {
     core.status.automaticRoute.destX=null;
     core.status.automaticRoute.destY=null;
     core.status.automaticRoute.lastDirection = null;
-    core.stopHero();
+    core.status.heroStop = true;
     if (core.status.automaticRoute.moveStepBeforeStop.length==0)
-        core.clearMap('route');
+        core.deleteCanvas('route');
+}
+
+////// 保存剩下的寻路，并停止 //////
+control.prototype.saveAndStopAutomaticRoute = function () {
+    var automaticRoute = core.status.automaticRoute;
+    if (automaticRoute.moveStepBeforeStop.length == 0) {
+        automaticRoute.moveStepBeforeStop = automaticRoute.autoStepRoutes.slice(automaticRoute.autoStep - 1);
+        if (automaticRoute.moveStepBeforeStop.length>=1)
+            automaticRoute.moveStepBeforeStop[0].step -= automaticRoute.movedStep;
+    }
+    this.stopAutomaticRoute();
 }
 
 ////// 继续剩下的自动寻路操作 //////
@@ -378,55 +429,41 @@ control.prototype.continueAutomaticRoute = function () {
 }
 
 ////// 清空剩下的自动寻路列表 //////
-control.prototype.clearContinueAutomaticRoute = function () {
-    core.clearMap('route');
+control.prototype.clearContinueAutomaticRoute = function (callback) {
+    core.deleteCanvas('route');
     core.status.automaticRoute.moveStepBeforeStop=[];
+    if (callback) callback();
 }
 
-////// 瞬间移动 //////
-control.prototype.moveDirectly = function (destX, destY) {
-    var ignoreSteps = core.canMoveDirectly(destX, destY);
-    if (ignoreSteps>=0) {
-        core.clearMap('hero');
-        var lastDirection = core.status.route[core.status.route.length-1];
-        if (['left', 'right', 'up', 'down'].indexOf(lastDirection)>=0)
-            core.setHeroLoc('direction', lastDirection);
-        core.setHeroLoc('x', destX);
-        core.setHeroLoc('y', destY);
-        core.drawHero();
-        core.status.route.push("move:"+destX+":"+destY);
-        core.status.hero.statistics.moveDirectly++;
-        core.status.hero.statistics.ignoreSteps+=ignoreSteps;
-        return true;
-    }
-    return false;
-}
-
-////// 尝试瞬间移动 //////
-control.prototype.tryMoveDirectly = function (destX, destY) {
-    if (Math.abs(core.getHeroLoc('x')-destX)+Math.abs(core.getHeroLoc('y')-destY)<=1)
-        return false;
-    var testMove = function (dx, dy, dir) {
-        if (dx<0 || dx>=core.bigmap.width|| dy<0 || dy>=core.bigmap.height) return false;
-        if (core.control.moveDirectly(dx, dy)) {
-            if (core.isset(dir)) core.moveHero(dir, function() {});
-            return true;
-        }
-        return false;
-    }
-    return testMove(destX,destY) || testMove(destX-1, destY, "right") || testMove(destX,destY-1,"down")
-        || testMove(destX,destY+1,"up") || testMove(destX+1,destY,"left");
+////// 显示离散的寻路点 //////
+control.prototype.fillPosWithPoint = function (pos) {
+    core.fillRect('ui', pos.x*32+12,pos.y*32+12,8,8, '#bfbfbf');
 }
 
 ////// 设置自动寻路路线 //////
 control.prototype.setAutomaticRoute = function (destX, destY, stepPostfix) {
-    if (!core.status.played || core.status.lockControl) {
+    if (!core.status.played || core.status.lockControl) return;
+    if (this._setAutomaticRoute_isMoving(destX, destY)) return;
+    if (this._setAutomaticRoute_isTurning(destX, destY, stepPostfix)) return;
+    if (this._setAutomaticRoute_clickMoveDirectly(destX, destY, stepPostfix)) return;
+    // 找寻自动寻路路线
+    var moveStep = core.automaticRoute(destX, destY);
+    if (moveStep.length == 0 && (destX != core.status.hero.loc.x || destY != core.status.hero.loc.y || stepPostfix.length == 0))
         return;
-    }
-    // 正在寻路中
+    moveStep = moveStep.concat(stepPostfix);
+    core.status.automaticRoute.destX=destX;
+    core.status.automaticRoute.destY=destY;
+    this._setAutomaticRoute_drawRoute(moveStep);
+    this._setAutomaticRoute_setAutoSteps(moveStep);
+    // 立刻移动
+    core.setAutoHeroMove();
+}
+
+control.prototype._setAutomaticRoute_isMoving = function (destX, destY) {
     if (core.status.automaticRoute.autoHeroMove) {
         var lastX = core.status.automaticRoute.destX, lastY=core.status.automaticRoute.destY;
         core.stopAutomaticRoute();
+        // 双击瞬移
         if (lastX==destX && lastY==destY) {
             core.status.automaticRoute.moveDirectly = true;
             setTimeout(function () {
@@ -434,10 +471,14 @@ control.prototype.setAutomaticRoute = function (destX, destY, stepPostfix) {
                     core.control.tryMoveDirectly(destX, destY);
                 }
                 core.status.automaticRoute.moveDirectly = false;
-            }, 100);
+            }, core.values.moveSpeed || 100);
         }
-        return;
+        return true;
     }
+    return false;
+}
+
+control.prototype._setAutomaticRoute_isTurning = function (destX, destY, stepPostfix) {
     if (destX == core.status.hero.loc.x && destY == core.status.hero.loc.y && stepPostfix.length==0) {
         if (core.timeout.turnHeroTimeout==null) {
             core.timeout.turnHeroTimeout = setTimeout(function() {
@@ -451,195 +492,70 @@ control.prototype.setAutomaticRoute = function (destX, destY, stepPostfix) {
             core.timeout.turnHeroTimeout = null;
             core.getNextItem();
         }
-        return;
+        return true;
     }
+    if (core.timeout.turnHeroTimeout!=null) return true;
+    return false;
+}
 
+control.prototype._setAutomaticRoute_clickMoveDirectly = function (destX, destY, stepPostfix) {
     // 单击瞬间移动
-    if (core.status.automaticRoute.clickMoveDirectly && core.status.heroStop) {
-        if (core.control.tryMoveDirectly(destX, destY))
-            return;
+    if (core.status.heroStop && core.status.heroMoving==0) {
+        if (stepPostfix.length<=1 && !core.hasFlag('__noClickMove__') && core.control.tryMoveDirectly(destX, destY))
+            return true;
     }
+    return false;
+}
 
-    var step = 0;
-    var tempStep = null;
-    var moveStep;
-    if (!(moveStep = core.automaticRoute(destX, destY))) {
-        if (destX == core.status.hero.loc.x && destY == core.status.hero.loc.y){
-            moveStep=[];
-        } else {
-            core.clearMap('route');
-            return;
-        }
-    }
-    moveStep=moveStep.concat(stepPostfix);
-    core.status.automaticRoute.destX=destX;
-    core.status.automaticRoute.destY=destY;
-    core.canvas.route.save();
-    core.clearMap('route');
-    core.canvas.route.fillStyle = '#bfbfbf';
-    core.canvas.route.strokeStyle = '#bfbfbf';
-    core.canvas.route.lineWidth = 8;
+control.prototype._setAutomaticRoute_drawRoute = function (moveStep) {
+    // 计算绘制区域的宽高，并尽可能小的创建route层
+    var sx = core.bigmap.width * 32, sy = core.bigmap.height * 32, dx = 0, dy = 0;
+    moveStep.forEach(function (t) {
+        sx = Math.min(sx, t.x * 32); dx = Math.max(dx, t.x * 32);
+        sy = Math.min(sy, t.y * 32); dy = Math.max(dy, t.y * 32);
+    });
+    core.status.automaticRoute.offsetX = sx;
+    core.status.automaticRoute.offsetY = sy;
+    var ctx = core.createCanvas('route', sx-core.bigmap.offsetX, sy-core.bigmap.offsetY, dx-sx+32, dy-sy+32, 95);
+    ctx.fillStyle = '#bfbfbf';
+    ctx.strokeStyle = '#bfbfbf';
+    ctx.lineWidth = 8;
     for (var m = 0; m < moveStep.length; m++) {
-        if (tempStep == null) {
-            step++;
-            tempStep = moveStep[m].direction;
-        }
-        else if (tempStep == moveStep[m].direction) {
-            step++;
-        }
-        else {
-            //core.status.automaticRoutingTemp.moveStep.push({'direction': tempStep, 'step': step});
-            core.status.automaticRoute.autoStepRoutes.push({'direction': tempStep, 'step': step});
-            step = 1;
-            tempStep = moveStep[m].direction;
-        }
         if (m == moveStep.length - 1) {
-            // core.status.automaticRoutingTemp.moveStep.push({'direction': tempStep, 'step': step});
-            core.status.automaticRoute.autoStepRoutes.push({'direction': tempStep, 'step': step});
-            core.canvas.route.fillRect(moveStep[m].x * 32 + 10, moveStep[m].y * 32 + 10, 12, 12);
+            ctx.fillRect(moveStep[m].x * 32 + 10 - sx, moveStep[m].y * 32 + 10 - sy, 12, 12);
         }
         else {
-            core.canvas.route.beginPath();
-            if (core.isset(moveStep[m + 1]) && tempStep != moveStep[m + 1].direction) {
-                if (tempStep == 'up' && moveStep[m + 1].direction == 'left' || tempStep == 'right' && moveStep[m + 1].direction == 'down') {
-                    core.canvas.route.moveTo(moveStep[m].x * 32 + 5, moveStep[m].y * 32 + 16);
-                    core.canvas.route.lineTo(moveStep[m].x * 32 + 16, moveStep[m].y * 32 + 16);
-                    core.canvas.route.lineTo(moveStep[m].x * 32 + 16, moveStep[m].y * 32 + 27);
-                }
-                else if (tempStep == 'up' && moveStep[m + 1].direction == 'right' || tempStep == 'left' && moveStep[m + 1].direction == 'down') {
-                    core.canvas.route.moveTo(moveStep[m].x * 32 + 27, moveStep[m].y * 32 + 16);
-                    core.canvas.route.lineTo(moveStep[m].x * 32 + 16, moveStep[m].y * 32 + 16);
-                    core.canvas.route.lineTo(moveStep[m].x * 32 + 16, moveStep[m].y * 32 + 27);
-                }
-                else if (tempStep == 'left' && moveStep[m + 1].direction == 'up' || tempStep == 'down' && moveStep[m + 1].direction == 'right') {
-                    core.canvas.route.moveTo(moveStep[m].x * 32 + 27, moveStep[m].y * 32 + 16);
-                    core.canvas.route.lineTo(moveStep[m].x * 32 + 16, moveStep[m].y * 32 + 16);
-                    core.canvas.route.lineTo(moveStep[m].x * 32 + 16, moveStep[m].y * 32 + 5);
-                }
-                else if (tempStep == 'right' && moveStep[m + 1].direction == 'up' || tempStep == 'down' && moveStep[m + 1].direction == 'left') {
-                    core.canvas.route.moveTo(moveStep[m].x * 32 + 5, moveStep[m].y * 32 + 16);
-                    core.canvas.route.lineTo(moveStep[m].x * 32 + 16, moveStep[m].y * 32 + 16);
-                    core.canvas.route.lineTo(moveStep[m].x * 32 + 16, moveStep[m].y * 32 + 5);
-                }
-                core.canvas.route.stroke();
-                continue;
-            }
-            switch (tempStep) {
-                case 'up':
-                case 'down':
-                    core.canvas.route.beginPath();
-                    core.canvas.route.moveTo(moveStep[m].x * 32 + 16, moveStep[m].y * 32 + 5);
-                    core.canvas.route.lineTo(moveStep[m].x * 32 + 16, moveStep[m].y * 32 + 27);
-                    core.canvas.route.stroke();
-                    break;
-                case 'left':
-                case 'right':
-                    core.canvas.route.beginPath();
-                    core.canvas.route.moveTo(moveStep[m].x * 32 + 5, moveStep[m].y * 32 + 16);
-                    core.canvas.route.lineTo(moveStep[m].x * 32 + 27, moveStep[m].y * 32 + 16);
-                    core.canvas.route.stroke();
-                    break;
-            }
+            ctx.beginPath();
+            var cx = moveStep[m].x*32 +16 - sx, cy = moveStep[m].y*32+16 - sy;
+            var currDir = moveStep[m].direction, nextDir = moveStep[m+1].direction;
+            ctx.moveTo(cx-core.utils.scan[currDir].x*11, cy-core.utils.scan[currDir].y*11);
+            ctx.lineTo(cx, cy);
+            ctx.lineTo(cx+core.utils.scan[nextDir].x*11, cy+core.utils.scan[nextDir].y*11);
+            ctx.stroke();
         }
     }
-    core.canvas.route.restore();
-
-    // 立刻移动
-    core.setAutoHeroMove();
-
 }
 
-////// 自动寻路算法，找寻最优路径 //////
-control.prototype.automaticRoute = function (destX, destY) {
-    var fw = core.bigmap.width, fh = core.bigmap.height;
-    var startX = core.getHeroLoc('x');
-    var startY = core.getHeroLoc('y');
-    var scan = {
-        'up': {'x': 0, 'y': -1},
-        'left': {'x': -1, 'y': 0},
-        'down': {'x': 0, 'y': 1},
-        'right': {'x': 1, 'y': 0}
-    };
-    if (destX == startX && destY == startY) return false;
-
-    var route = [];
-    var queue = new PriorityQueue({comparator: function (a,b) {
-        return a.depth - b.depth;
-    }});
-    var ans = [];
-
-    route[startX + fw * startY] = '';
-    queue.queue({depth: 0, x: startX, y: startY});
-    while (queue.length!=0) {
-        var curr = queue.dequeue();
-        var deep = curr.depth, nowX = curr.x, nowY = curr.y;
-
-        for (var direction in scan) {
-            if (!core.canMoveHero(nowX, nowY, direction))
-                continue;
-
-            var nx = nowX + scan[direction].x;
-            var ny = nowY + scan[direction].y;
-            if (nx<0 || nx>=fw || ny<0 || ny>=fh) continue;
-
-            var nid = nx + fw * ny;
-
-            if (core.isset(route[nid])) continue;
-
-            var deepAdd=1;
-            var nextId, nextBlock = core.getBlock(nx,ny);
-            if (nextBlock!=null){
-                nextId = nextBlock.block.event.id;
-                // 绕过亮灯（因为只有一次通行机会很宝贵）
-                if(nextId == "light") deepAdd=100;
-                // 绕过路障
-                // if (nextId.substring(nextId.length-3)=="Net") deepAdd=core.values.lavaDamage*10;
-                // 绕过血瓶
-                if (!core.flags.potionWhileRouting && nextId.substring(nextId.length-6)=="Potion") deepAdd+=20;
-                // 绕过传送点
-                if  (nextBlock.block.event.trigger == 'changeFloor') deepAdd+=10;
-            }
-            deepAdd+=core.status.checkBlock.damage[nid]*10;
-
-            if (nx == destX && ny == destY) {
-                route[nid] = direction;
-                break;
-            }
-            if (core.noPassExists(nx, ny))
-                continue;
-
-            route[nid] = direction;
-            queue.queue({depth: deep+deepAdd, x: nx, y: ny});
+control.prototype._setAutomaticRoute_setAutoSteps = function (moveStep) {
+    // 路线转autoStepRoutes
+    var step = 0, currStep = null;
+    moveStep.forEach(function (t) {
+        var dir = t.direction;
+        if (currStep == null || currStep == dir)
+            step++;
+        else {
+            core.status.automaticRoute.autoStepRoutes.push({'direction': currStep, 'step': step});
+            step = 1;
         }
-        if (core.isset(route[destX + fw * destY])) break;
-    }
-    if (!core.isset(route[destX + fw * destY])) {
-        return false;
-    }
-
-    var nowX = destX, nowY = destY;
-    while (nowX != startX || nowY != startY) {
-        var dir = route[nowX + fw * nowY];
-        ans.push({'direction': dir, 'x': nowX, 'y': nowY});
-        nowX -= scan[dir].x;
-        nowY -= scan[dir].y;
-    }
-
-    ans.reverse();
-    return ans;
-}
-
-////// 显示离散的寻路点 //////
-control.prototype.fillPosWithPoint = function (pos) {
-    core.fillRect('route', pos.x*32+12+core.bigmap.offsetX,pos.y*32+12+core.bigmap.offsetY,8,8, '#bfbfbf');
+        currStep = dir;
+    });
+    core.status.automaticRoute.autoStepRoutes.push({'direction': currStep, 'step': step});
 }
 
 ////// 设置勇士的自动行走路线 //////
 control.prototype.setAutoHeroMove = function (steps) {
     steps=steps||core.status.automaticRoute.autoStepRoutes;
-    if (steps.length == 0) {
-        return;
-    }
+    if (steps.length == 0) return;
     core.status.automaticRoute.autoStepRoutes=steps;
     core.status.automaticRoute.autoHeroMove = true;
     core.status.automaticRoute.autoStep = 1;
@@ -648,118 +564,105 @@ control.prototype.setAutoHeroMove = function (steps) {
 }
 
 ////// 设置行走的效果动画 //////
-control.prototype.setHeroMoveInterval = function (direction, x, y, callback) {
-    if (core.status.heroMoving>0) {
-        return;
-    }
+control.prototype.setHeroMoveInterval = function (callback) {
+    if (core.status.heroMoving > 0) return;
     core.status.heroMoving=1;
-    var scan = {
-        'up': {'x': 0, 'y': -1},
-        'left': {'x': -1, 'y': 0},
-        'down': {'x': 0, 'y': 1},
-        'right': {'x': 1, 'y': 0}
-    };
 
     var toAdd = 1;
-    if (core.status.replay.speed>3)
-        toAdd = 2;
+    if (core.status.replay.speed>3) toAdd = 2;
+    if (core.status.replay.speed>6) toAdd = 4;
+    if (core.status.replay.speed>12) toAdd = 8;
 
     core.interval.heroMoveInterval = window.setInterval(function () {
         core.status.heroMoving+=toAdd;
         if (core.status.heroMoving>=8) {
-            core.setHeroLoc('x', x+scan[direction].x, true);
-            core.setHeroLoc('y', y+scan[direction].y, true);
-            core.control.updateFollowers();
-            core.moveOneStep();
-            core.clearMap('hero');
-            core.drawHero(direction);
             clearInterval(core.interval.heroMoveInterval);
             core.status.heroMoving = 0;
-            if (core.isset(callback)) callback();
+            core.moveOneStep(core.nextX(), core.nextY());
+            if (callback) callback();
         }
-    }, 12.5 * toAdd / core.status.replay.speed);
+    }, (core.values.moveSpeed||100) / 8 * toAdd / core.status.replay.speed);
+}
+
+////// 每移动一格后执行的事件 //////
+control.prototype.moveOneStep = function(x, y) {
+    return this.controldata.moveOneStep(x, y);
 }
 
 ////// 实际每一步的行走过程 //////
 control.prototype.moveAction = function (callback) {
-    if (core.interval.openDoorAnimate!=null) return; // 开门判断
     if (core.status.heroMoving>0) return;
-    var scan = {
-        'up': {'x': 0, 'y': -1},
-        'left': {'x': -1, 'y': 0},
-        'down': {'x': 0, 'y': 1},
-        'right': {'x': 1, 'y': 0}
-    };
-    var direction = core.getHeroLoc('direction');
-    var x = core.getHeroLoc('x');
-    var y = core.getHeroLoc('y');
-    var noPass = core.noPass(x + scan[direction].x, y + scan[direction].y), canMove = core.canMoveHero();
-    if (noPass || !canMove) {
-        if (core.status.event.id!='ski')
-            core.status.route.push(direction);
-        core.status.automaticRoute.moveStepBeforeStop = [];
-        core.status.automaticRoute.lastDirection = core.getHeroLoc('direction');
-        if (canMove) // 非箭头：触发
-            core.trigger(x + scan[direction].x, y + scan[direction].y);
-        core.drawHero(direction, x, y);
-
-        if (core.status.automaticRoute.moveStepBeforeStop.length==0) {
-            core.clearContinueAutomaticRoute();
-            core.stopAutomaticRoute();
-        }
-        if (core.isset(callback))
-            callback();
-    }
-    else {
-        core.setHeroMoveInterval(direction, x, y, function () {
-            if (core.status.automaticRoute.autoHeroMove) {
-                core.status.automaticRoute.movedStep++;
-                core.status.automaticRoute.lastDirection = core.getHeroLoc('direction');
-                if (core.status.automaticRoute.destStep == core.status.automaticRoute.movedStep) {
-                    if (core.status.automaticRoute.autoStep == core.status.automaticRoute.autoStepRoutes.length) {
-                        core.clearContinueAutomaticRoute();
-                        core.stopAutomaticRoute();
-                    }
-                    else {
-                        core.status.automaticRoute.movedStep = 0;
-                        core.status.automaticRoute.destStep = core.status.automaticRoute.autoStepRoutes[core.status.automaticRoute.autoStep].step;
-                        core.setHeroLoc('direction', core.status.automaticRoute.autoStepRoutes[core.status.automaticRoute.autoStep].direction);
-                        core.status.automaticRoute.autoStep++;
-                    }
-                }
-            }
-            else if (core.status.heroStop) {
-                core.drawHero();
-            }
-            if (core.status.event.id!='ski')
-                core.status.route.push(direction);
-
-            // 检查是不是无事件的道具
-            var nowx = core.getHeroLoc('x'), nowy = core.getHeroLoc('y');
-            var block = core.getBlock(nowx,nowy);
-            var hasTrigger = false;
-            if (block!=null && block.block.event.trigger=='getItem' &&
-                !core.isset(core.floors[core.status.floorId].afterGetItem[nowx+","+nowy])) {
-                hasTrigger = true;
-                core.trigger(nowx, nowy);
-            }
-            core.checkBlock();
-            if (!hasTrigger && !core.status.gameOver)
-                core.trigger(nowx, nowy);
-            if (core.isset(callback)) callback();
-        });
-    }
+    var noPass = core.noPass(core.nextX(), core.nextY()), canMove = core.canMoveHero();
+    // 下一个点如果不能走
+    if (noPass || !canMove) return this._moveAction_noPass(canMove, callback);
+    this._moveAction_moving(callback);
 }
 
-////// 转向 //////
-control.prototype.turnHero = function() {
-    if (core.status.hero.loc.direction == 'up') core.status.hero.loc.direction = 'right';
-    else if (core.status.hero.loc.direction == 'right') core.status.hero.loc.direction = 'down';
-    else if (core.status.hero.loc.direction == 'down') core.status.hero.loc.direction = 'left';
-    else if (core.status.hero.loc.direction == 'left') core.status.hero.loc.direction = 'up';
+control.prototype._moveAction_noPass = function (canMove, callback) {
+    core.status.route.push(core.getHeroLoc('direction'));
+    core.status.automaticRoute.moveStepBeforeStop = [];
+    core.status.automaticRoute.lastDirection = core.getHeroLoc('direction');
+    if (canMove) core.events._trigger(core.nextX(), core.nextY());
     core.drawHero();
-    core.clearMap('route');
-    core.status.route.push("turn");
+
+    if (core.status.automaticRoute.moveStepBeforeStop.length==0) {
+        core.clearContinueAutomaticRoute();
+        core.stopAutomaticRoute();
+    }
+    if (callback) callback();
+}
+
+control.prototype._moveAction_moving = function (callback) {
+    core.setHeroMoveInterval(function () {
+        var direction = core.getHeroLoc('direction');
+        core.control._moveAction_popAutomaticRoute();
+        core.status.route.push(direction);
+
+        // 无事件的道具（如血瓶）需要优先于阻激夹域判定
+        var nowx = core.getHeroLoc('x'), nowy = core.getHeroLoc('y');
+        var block = core.getBlock(nowx,nowy);
+        var hasTrigger = false;
+        if (block!=null && block.block.event.trigger=='getItem' &&
+            !core.floors[core.status.floorId].afterGetItem[nowx+","+nowy]) {
+            hasTrigger = true;
+            core.events._trigger(nowx, nowy);
+        }
+        // 执行该点的阻激夹域事件
+        core.checkBlock();
+
+        // 执行该点事件
+        if (!hasTrigger)
+            core.events._trigger(nowx, nowy);
+        core.updateStatusBar();
+
+        // 检查该点是否是滑冰
+        if (core.getBgNumber() == 167) {
+            core.insertAction("滑冰事件", null, null, null, true);
+        }
+
+        if (callback) callback();
+    });
+}
+
+control.prototype._moveAction_popAutomaticRoute = function () {
+    var automaticRoute = core.status.automaticRoute;
+    // 检查自动寻路是否被弹出
+    if (automaticRoute.autoHeroMove) {
+        automaticRoute.movedStep++;
+        automaticRoute.lastDirection = core.getHeroLoc('direction');
+        if (automaticRoute.destStep == automaticRoute.movedStep) {
+            if (automaticRoute.autoStep == automaticRoute.autoStepRoutes.length) {
+                core.clearContinueAutomaticRoute();
+                core.stopAutomaticRoute();
+            }
+            else {
+                automaticRoute.movedStep = 0;
+                automaticRoute.destStep = automaticRoute.autoStepRoutes[automaticRoute.autoStep].step;
+                core.setHeroLoc('direction', automaticRoute.autoStepRoutes[automaticRoute.autoStep].direction);
+                core.status.automaticRoute.autoStep++;
+            }
+        }
+    }
 }
 
 ////// 让勇士开始移动 //////
@@ -768,198 +671,40 @@ control.prototype.moveHero = function (direction, callback) {
     if (core.status.heroMoving!=0) return;
     if (core.isset(direction))
         core.setHeroLoc('direction', direction);
-    if (!core.isset(callback)) { // 如果不存在回调函数，则使用heroMoveTrigger
-        core.status.heroStop = false;
-        core.status.automaticRoute.moveDirectly = false;
 
-        var doAction = function () {
-            if (!core.status.heroStop) {
-                if (core.hasFlag('debug') && core.status.ctrlDown) {
-                    if (core.status.heroMoving!=0) return;
-                    // 检测是否穿出去
-                    var scan = {
-                        'up': {'x': 0, 'y': -1},
-                        'left': {'x': -1, 'y': 0},
-                        'down': {'x': 0, 'y': 1},
-                        'right': {'x': 1, 'y': 0}
-                    };
-                    direction = core.getHeroLoc('direction');
-                    var nx = core.getHeroLoc('x') + scan[direction].x, ny=core.getHeroLoc('y') + scan[direction].y;
-                    if (nx<0 || nx>=core.bigmap.width || ny<0 || ny>=core.bigmap.height) return;
+    if (callback) return this.moveAction(callback);
+    this._moveHero_moving();
+}
 
-                    core.status.heroMoving=-1;
-                    core.eventMoveHero([direction], 100, function () {
-                        core.status.heroMoving=0;
-                        doAction();
-                    });
-                }
-                else {
-                    core.moveAction();
-                    setTimeout(doAction, 50);
-                }
+control.prototype._moveHero_moving = function () {
+    // ------ 我已经看不懂这个函数了，反正好用就行23333333
+    core.status.heroStop = false;
+    core.status.automaticRoute.moveDirectly = false;
+    var move = function () {
+        if (!core.status.heroStop) {
+            if (core.hasFlag('debug') && core.status.ctrlDown) {
+                if (core.status.heroMoving!=0) return;
+                // 检测是否穿出去
+                var nx = core.nextX(), ny = core.nextY();
+                if (nx < 0 || nx >= core.bigmap.width || ny < 0 || ny >= core.bigmap.height) return;
+                core.status.heroMoving=-1;
+                core.eventMoveHero([core.getHeroLoc('direction')], core.values.moveSpeed, function () {
+                    core.status.heroMoving=0;
+                    move();
+                });
             }
             else {
-                core.stopHero();
+                core.moveAction();
+                setTimeout(move, 50);
             }
         }
-        doAction();
-    }
-    else { // 否则，只向某个方向移动一步，然后调用callback
-        core.moveAction(function () {
-            callback();
-        })
     }
+    move();
 }
 
-/////// 使用事件让勇士移动。这个函数将不会触发任何事件 //////
-control.prototype.eventMoveHero = function(steps, time, callback) {
-
-    time = time || 100;
-
-    core.clearMap('ui');
-    core.setAlpha('ui', 1.0);
-
-    // 要运行的轨迹：将steps展开
-    var moveSteps=[];
-    steps.forEach(function (e) {
-        if (typeof e=="string") {
-            moveSteps.push(e);
-        }
-        else {
-            if (!core.isset(e.value)) {
-                moveSteps.push(e.direction)
-            }
-            else {
-                for (var i=0;i<e.value;i++) {
-                    moveSteps.push(e.direction);
-                }
-            }
-        }
-    });
-
-    var step=0;
-    var scan = {
-        'up': {'x': 0, 'y': -1},
-        'left': {'x': -1, 'y': 0},
-        'down': {'x': 0, 'y': 1},
-        'right': {'x': 1, 'y': 0}
-    };
-
-    core.status.replay.animate=true;
-
-    var animate=window.setInterval(function() {
-        var x=core.getHeroLoc('x'), y=core.getHeroLoc('y');
-        if (moveSteps.length==0) {
-            clearInterval(animate);
-            core.drawHero(null, x, y);
-            core.status.replay.animate=false;
-            if (core.isset(callback)) callback();
-        }
-        else {
-            var direction = moveSteps[0];
-            core.setHeroLoc('direction', direction);
-            step++;
-            if (step <= 4) {
-                core.drawHero(direction, x, y, 'leftFoot', 4 * step);
-            }
-            else if (step <= 8) {
-                core.drawHero(direction, x, y, 'rightFoot', 4 * step);
-            }
-            if (step == 8) {
-                step = 0;
-                core.setHeroLoc('x', x + scan[direction].x, true);
-                core.setHeroLoc('y', y + scan[direction].y, true);
-                core.control.updateFollowers();
-                moveSteps.shift();
-            }
-        }
-    }, time / 8 / core.status.replay.speed)
-}
-
-////// 勇士跳跃事件 //////
-control.prototype.jumpHero = function (ex, ey, time, callback) {
-    var sx=core.status.hero.loc.x, sy=core.status.hero.loc.y;
-    if (!core.isset(ex)) ex=sx;
-    if (!core.isset(ey)) ey=sy;
-
-    time = time || 500;
-    core.clearMap('ui');
-    core.setAlpha('ui', 1.0);
-    core.status.replay.animate=true;
-
-    core.playSound('jump.mp3');
-
-    var dx = ex-sx, dy=ey-sy, distance = Math.round(Math.sqrt(dx * dx + dy * dy));
-    var jump_peak = 6 + distance, jump_count = jump_peak * 2;
-    var currx = sx, curry = sy;
-
-    var heroIcon = core.material.icons.hero[core.getHeroLoc('direction')];
-    var status = 'stop';
-    var height = core.material.icons.hero.height;
-
-    var drawX = function() {
-        return currx * 32;
-    }
-    var drawY = function() {
-        var ret = curry * 32;
-        if(jump_count >= jump_peak){
-            var n = jump_count - jump_peak;
-        }else{
-            var n = jump_peak - jump_count;
-        }
-        return ret - (jump_peak * jump_peak - n * n) / 2;
-    }
-    var updateJump = function() {
-        jump_count--;
-        currx = (currx * jump_count + ex) / (jump_count + 1.0);
-        curry = (curry * jump_count + ey) / (jump_count + 1.0);
-    }
-
-    if (core.isset(core.status.hero.followers) && core.status.hero.followers.length>0)
-        core.clearMap('hero');
-
-    var animate=window.setInterval(function() {
-
-        if (jump_count>0) {
-            core.clearMap('hero', drawX()-core.bigmap.offsetX, drawY()-height+32-core.bigmap.offsetY, 32, height);
-            updateJump();
-            var nowx = drawX(), nowy = drawY();
-            core.bigmap.offsetX = core.clamp(nowx - 32*6, 0, 32*core.bigmap.width-416);
-            core.bigmap.offsetY = core.clamp(nowy - 32*6, 0, 32*core.bigmap.height-416);
-            core.control.updateViewport();
-            core.canvas.hero.drawImage(core.material.images.hero, heroIcon[status] * 32, heroIcon.loc * height, 32, height,
-                nowx - core.bigmap.offsetX, nowy + 32-height - core.bigmap.offsetY, 32, height);
-        }
-        else {
-            clearInterval(animate);
-            core.setHeroLoc('x', ex);
-            core.setHeroLoc('y', ey);
-            core.drawHero();
-            core.status.replay.animate=false;
-            if (core.isset(callback)) callback();
-        }
-
-    }, time / 16 / core.status.replay.speed);
-
-
-
-}
-
-////// 每移动一格后执行的事件 //////
-control.prototype.moveOneStep = function() {
-    core.status.hero.steps++;
-    // 中毒状态
-    if (core.hasFlag('poison')) {
-        core.status.hero.statistics.poisonDamage += core.values.poisonDamage;
-        core.status.hero.hp -= core.values.poisonDamage;
-        if (core.status.hero.hp<=0) {
-            core.status.hero.hp=0;
-            core.updateStatusBar();
-            core.events.lose();
-            return;
-        }
-        core.updateStatusBar();
-    }
+////// 当前是否正在移动 //////
+control.prototype.isMoving = function () {
+    return !core.status.heroStop || core.status.heroMoving > 0;
 }
 
 ////// 停止勇士的一切行动，等待勇士行动结束后，再执行callback //////
@@ -967,7 +712,7 @@ control.prototype.waitHeroToStop = function(callback) {
     var lastDirection = core.status.automaticRoute.lastDirection;
     core.stopAutomaticRoute();
     core.clearContinueAutomaticRoute();
-    if (core.isset(callback)) {
+    if (callback) {
         core.status.replay.animate=true;
         core.lockControl();
         core.status.automaticRoute.moveDirectly = false;
@@ -981,11 +726,95 @@ control.prototype.waitHeroToStop = function(callback) {
     }
 }
 
-////// 停止勇士的移动状态 //////
-control.prototype.stopHero = function () {
-    core.status.heroStop = true;
+////// 转向 //////
+control.prototype.turnHero = function(direction) {
+    if (direction) {
+        core.setHeroLoc('direction', direction);
+        core.drawHero();
+        core.status.route.push("turn:"+direction);
+        return;
+    }
+    var dirs = {'up':'right','right':'down','down':'left','left':'up'};
+    core.setHeroLoc('direction', dirs[core.getHeroLoc('direction')]);
+    core.drawHero();
+    core.status.route.push("turn");
 }
 
+////// 瞬间移动 //////
+control.prototype.moveDirectly = function (destX, destY) {
+    return this.controldata.moveDirectly(destX, destY);
+}
+
+////// 尝试瞬间移动 //////
+control.prototype.tryMoveDirectly = function (destX, destY) {
+    if (this.nearHero(destX, destY)) return false;
+    var canMoveArray = core.maps.generateMovableArray();
+    var testMove = function (dx, dy, dir) {
+        if (dx<0 || dx>=core.bigmap.width|| dy<0 || dy>=core.bigmap.height) return false;
+        if (dir && !core.inArray(canMoveArray[dx][dy],dir)) return false;
+        if (core.control.moveDirectly(dx, dy)) {
+            if (dir) core.moveHero(dir, function() {});
+            return true;
+        }
+        return false;
+    }
+    return testMove(destX,destY) || testMove(destX-1, destY, "right") || testMove(destX,destY-1,"down")
+        || testMove(destX,destY+1,"up") || testMove(destX+1,destY,"left");
+}
+
+////// 绘制勇士 //////
+control.prototype.drawHero = function (status, offset) {
+    if (!core.isPlaying() || !core.status.floorId || core.status.gameOver) return;
+    var x = core.getHeroLoc('x'), y = core.getHeroLoc('y'), direction = core.getHeroLoc('direction');
+    status = status || 'stop';
+    offset = offset || 0;
+    var way = core.utils.scan[direction];
+    var dx = way.x, dy = way.y, offsetX = dx * offset, offsetY = dy * offset;
+    core.bigmap.offsetX = core.clamp((x - core.__HALF_SIZE__) * 32 + offsetX, 0, 32*core.bigmap.width-core.__PIXELS__);
+    core.bigmap.offsetY = core.clamp((y - core.__HALF_SIZE__) * 32 + offsetY, 0, 32*core.bigmap.height-core.__PIXELS__);
+    core.clearAutomaticRouteNode(x+dx, y+dy);
+    core.clearMap('hero');
+
+    this._drawHero_getDrawObjs(direction, x, y, status, offset).forEach(function (block) {
+        core.drawImage('hero', block.img, block.heroIcon[block.status]*block.width,
+            block.heroIcon.loc * block.height, block.width, block.height,
+            block.posx+(32-block.width)/2, block.posy+32-block.height, block.width, block.height);
+    });
+
+    core.control.updateViewport();
+}
+
+control.prototype._drawHero_getDrawObjs = function (direction, x, y, status, offset) {
+    var heroIconArr = core.material.icons.hero, drawObjs = [], index = 0;
+    drawObjs.push({
+        "img": core.material.images.hero,
+        "width": core.material.icons.hero.width || 32,
+        "height": core.material.icons.hero.height,
+        "heroIcon": heroIconArr[direction],
+        "posx": x * 32 - core.bigmap.offsetX + core.utils.scan[direction].x * offset,
+        "posy": y * 32 - core.bigmap.offsetY + core.utils.scan[direction].y * offset,
+        "status": status,
+        "index": index++,
+    });
+    (core.status.hero.followers||[]).forEach(function (t) {
+        drawObjs.push({
+            "img": core.material.images.images[t.name],
+            "width": core.material.images.images[t.name].width/4,
+            "height": core.material.images.images[t.name].height/4,
+            "heroIcon": heroIconArr[t.direction],
+            "posx": 32*t.x - core.bigmap.offsetX + (t.stop?0:core.utils.scan[t.direction].x*offset),
+            "posy": 32*t.y - core.bigmap.offsetY + (t.stop?0:core.utils.scan[t.direction].y*offset),
+            "status": t.stop?"stop":status,
+            "index": index++
+        });
+    });
+    return drawObjs.sort(function(a, b) {
+        return a.posy==b.posy?b.index-a.index:a.posy-b.posy;
+    });
+}
+
+// ------ 画布、位置、阻激夹域，显伤 ------ //
+
 ////// 设置画布偏移
 control.prototype.setGameCanvasTranslate = function(canvas,x,y){
     var c=core.dom.gameCanvas[canvas];
@@ -996,133 +825,58 @@ control.prototype.setGameCanvasTranslate = function(canvas,x,y){
     c.style.OTransform='translate('+x+'px,'+y+'px)';
     c.style.MozTransform='translate('+x+'px,'+y+'px)';
     if(main.mode==='editor' && editor.isMobile){
-        c.style.transform='translate('+(x/416*96)+'vw,'+(y/416*96)+'vw)';
-        c.style.webkitTransform='translate('+(x/416*96)+'vw,'+(y/416*96)+'vw)';
-        c.style.OTransform='translate('+(x/416*96)+'vw,'+(y/416*96)+'vw)';
-        c.style.MozTransform='translate('+(x/416*96)+'vw,'+(y/416*96)+'vw)';
+        c.style.transform='translate('+(x/core.__PIXELS__*96)+'vw,'+(y/core.__PIXELS__*96)+'vw)';
+        c.style.webkitTransform='translate('+(x/core.__PIXELS__*96)+'vw,'+(y/core.__PIXELS__*96)+'vw)';
+        c.style.OTransform='translate('+(x/core.__PIXELS__*96)+'vw,'+(y/core.__PIXELS__*96)+'vw)';
+        c.style.MozTransform='translate('+(x/core.__PIXELS__*96)+'vw,'+(y/core.__PIXELS__*96)+'vw)';
     }
 };
 
+////// 加减画布偏移
+control.prototype.addGameCanvasTranslate = function (x, y) {
+    for(var ii=0,canvas;canvas=core.dom.gameCanvas[ii];ii++){
+        var id = canvas.getAttribute('id');
+        if (id=='ui' || id=='data') continue; // UI层和data层不移动
+        var offsetX = x, offsetY = y;
+        if (core.bigmap.canvas.indexOf(id)>=0) {
+            offsetX -= core.bigmap.offsetX;
+            offsetY -= core.bigmap.offsetY;
+        }
+        core.control.setGameCanvasTranslate(id, offsetX, offsetY);
+    }
+}
+
 ////// 更新视野范围 //////
 control.prototype.updateViewport = function() {
     core.bigmap.canvas.forEach(function(cn){
         core.control.setGameCanvasTranslate(cn,-core.bigmap.offsetX,-core.bigmap.offsetY);
     });
-}
-
-////// 绘制勇士 //////
-control.prototype.drawHero = function (direction, x, y, status, offset) {
-
-    var scan = {
-        'up': {'x': 0, 'y': -1},
-        'left': {'x': -1, 'y': 0},
-        'down': {'x': 0, 'y': 1},
-        'right': {'x': 1, 'y': 0}
-    };
-
-    if (!core.isset(x)) x = core.getHeroLoc('x');
-    if (!core.isset(y)) y = core.getHeroLoc('y');
-    status = status || 'stop';
-    direction = direction || core.getHeroLoc('direction');
-    offset = offset || 0;
-    var way = scan[direction];
-    var offsetX = way.x*offset;
-    var offsetY = way.y*offset;
-    var dx=offsetX==0?0:offsetX/Math.abs(offsetX), dy=offsetY==0?0:offsetY/Math.abs(offsetY);
-
-    core.bigmap.offsetX = core.clamp((x - 6) * 32 + offsetX, 0, 32*core.bigmap.width-416);
-    core.bigmap.offsetY = core.clamp((y - 6) * 32 + offsetY, 0, 32*core.bigmap.height-416);
-
-    core.clearAutomaticRouteNode(x+dx, y+dy);
-
-    core.canvas.hero.clearRect(x * 32 - core.bigmap.offsetX - 32, y * 32 - core.bigmap.offsetY - 32, 96, 96);
-
-    var heroIconArr = core.material.icons.hero;
-    var drawObjs = [];
-    // add hero
-    drawObjs.push({
-        "img": core.material.images.hero,
-        "height": core.material.icons.hero.height,
-        "heroIcon": heroIconArr[direction],
-        "posx": x * 32 - core.bigmap.offsetX + offsetX,
-        "posy": y * 32 - core.bigmap.offsetY + offsetY,
-        "status": status,
-        "index": 0,
-    });
-    
-    // Add other followers
-    if (core.isset(core.status.hero.followers)) {
-        var index=1;
-        core.status.hero.followers.forEach(function (t) {
-            core.canvas.hero.clearRect(32*t.x-core.bigmap.offsetX-32, 32*t.y-core.bigmap.offsetY-32, 96, 96);
-            if (core.isset(core.material.images.images[t.img])) {
-                drawObjs.push({
-                    "img": core.material.images.images[t.img],
-                    "height": core.material.images.images[t.img].height/4,
-                    "heroIcon": heroIconArr[t.direction],
-                    "posx": 32*t.x - core.bigmap.offsetX + (t.stop?0:scan[t.direction].x*offset),
-                    "posy": 32*t.y - core.bigmap.offsetY + (t.stop?0:scan[t.direction].y*offset),
-                    "status": t.stop?"stop":status,
-                    "index": index++
-                });
-            }
-        });
-    }
-
-    drawObjs.sort(function (a, b) {
-        return a.posy==b.posy?b.index-a.index:a.posy-b.posy;
-    });
-
-    drawObjs.forEach(function (block) {
-        core.canvas.hero.drawImage(block.img, block.heroIcon[block.status]*32,
-            block.heroIcon.loc * block.height, 32, block.height,
-            block.posx, block.posy+32-block.height, 32, block.height);
-    });
-
-    core.control.updateViewport();
-}
-
-////// 设置勇士的位置 //////
-control.prototype.setHeroLoc = function (itemName, itemVal, noGather) {
-    core.status.hero.loc[itemName] = itemVal;
-    if ((itemName=='x' || itemName=='y') && !noGather) {
-        this.gatherFollowers();
-    }
-}
-
-////// 获得勇士的位置 //////
-control.prototype.getHeroLoc = function (itemName) {
-    if (!core.isset(itemName)) return core.status.hero.loc;
-    return core.status.hero.loc[itemName];
+    // ------ 路线
+    core.relocateCanvas('route', core.status.automaticRoute.offsetX - core.bigmap.offsetX, core.status.automaticRoute.offsetY - core.bigmap.offsetY);
 }
 
 ////// 获得勇士面对位置的x坐标 //////
 control.prototype.nextX = function(n) {
-    var scan = {
-        'up': {'x': 0, 'y': -1},
-        'left': {'x': -1, 'y': 0},
-        'down': {'x': 0, 'y': 1},
-        'right': {'x': 1, 'y': 0}
-    };
-    return core.getHeroLoc('x')+scan[core.getHeroLoc('direction')].x*(n||1);
+    if (n == null) n = 1;
+    return core.getHeroLoc('x')+core.utils.scan[core.getHeroLoc('direction')].x*n;
 }
 
 ////// 获得勇士面对位置的y坐标 //////
 control.prototype.nextY = function (n) {
-    var scan = {
-        'up': {'x': 0, 'y': -1},
-        'left': {'x': -1, 'y': 0},
-        'down': {'x': 0, 'y': 1},
-        'right': {'x': 1, 'y': 0}
-    };
-    return core.getHeroLoc('y')+scan[core.getHeroLoc('direction')].y*(n||1);
+    if (n == null) n = 1;
+    return core.getHeroLoc('y')+core.utils.scan[core.getHeroLoc('direction')].y*n;
+}
+
+////// 某个点是否在勇士旁边 //////
+control.prototype.nearHero = function (x, y, n) {
+    if (n == null) n = 1;
+    return Math.abs(x-core.getHeroLoc('x'))+Math.abs(y-core.getHeroLoc('y'))<=n;
 }
 
 ////// 聚集跟随者 //////
 control.prototype.gatherFollowers = function () {
-    if (!core.isset(core.status.hero.followers) || core.status.hero.followers.length==0) return;
     var x=core.getHeroLoc('x'), y=core.getHeroLoc('y'), dir=core.getHeroLoc('direction');
-    core.status.hero.followers.forEach(function (t) {
+    (core.status.hero.followers||[]).forEach(function (t) {
         t.x = x;
         t.y = y;
         t.stop = true;
@@ -1132,621 +886,197 @@ control.prototype.gatherFollowers = function () {
 
 ////// 更新跟随者坐标 //////
 control.prototype.updateFollowers = function () {
-    if (!core.isset(core.status.hero.followers) || core.status.hero.followers.length==0) return;
-    var scan = {
-        'up': {'x': 0, 'y': -1},
-        'left': {'x': -1, 'y': 0},
-        'down': {'x': 0, 'y': 1},
-        'right': {'x': 1, 'y': 0}
-    };
-    core.status.hero.followers.forEach(function (t) {
+    (core.status.hero.followers||[]).forEach(function (t) {
         if (!t.stop) {
-            t.x += scan[t.direction].x;
-            t.y += scan[t.direction].y;
+            t.x += core.utils.scan[t.direction].x;
+            t.y += core.utils.scan[t.direction].y;
         }
     })
 
     var nowx = core.getHeroLoc('x'), nowy = core.getHeroLoc('y');
-    core.status.hero.followers.forEach(function (t) {
-        if (t.x == nowx && t.y == nowy) {
-            t.stop = true;
-        }
-        else {
-            var dx = nowx-t.x, dy = nowy-t.y;
-            if (dx==-1) {
-                t.stop=false;
-                t.direction='left';
-            }
-            else if (dx==1) {
-                t.stop=false;
-                t.direction='right';
-            }
-            else if (dy==-1) {
-                t.stop=false;
-                t.direction='up';
-            }
-            else if (dy==1) {
-                t.stop=false;
-                t.direction='down';
+    (core.status.hero.followers||[]).forEach(function (t) {
+        t.stop = true;
+        var dx = nowx - t.x, dy = nowy - t.y;
+        for (var dir in core.utils.scan) {
+            if (core.utils.scan[dir].x == dx && core.utils.scan[dir].y == dy) {
+                t.stop = false;
+                t.direction = dir;
             }
         }
-        nowx=t.x; nowy=t.y;
+        nowx = t.x; nowy = t.y;
     })
 }
 
 ////// 更新领域、夹击、阻击的伤害地图 //////
-control.prototype.updateCheckBlock = function() {
-    core.status.checkBlock = {};
-    if (!core.isset(core.status.thisMap)) return;
-    var blocks = core.status.thisMap.blocks;
-
-    // Step1: 更新怪物地图
-    core.status.checkBlock.map = []; // 记录怪物地图
-    for (var n=0;n<blocks.length;n++) {
-        var block = blocks[n];
-        if (core.isset(block.event) && !block.disable && block.event.cls.indexOf('enemy')==0) {
-            var id = block.event.id, enemy = core.material.enemys[id];
-            if (core.isset(enemy)) {
-                core.status.checkBlock.map[block.x+core.bigmap.width*block.y]=id;
-            }
-        }
-        // 血网
-        if (core.isset(block.event) && !block.disable &&
-            block.event.id=='lavaNet' && block.event.trigger=='passNet' && !core.hasItem("shoes")) {
-            core.status.checkBlock.map[block.x+core.bigmap.width*block.y]="lavaNet";
-        }
-    }
-
-    // Step2: 更新领域、阻击伤害
-    core.status.checkBlock.damage = []; // 记录(x,y)点的伤害
-    for (var x=0;x<core.bigmap.width*core.bigmap.height;x++) core.status.checkBlock.damage[x]=0;
-
-    for (var x=0;x<core.bigmap.width;x++) {
-        for (var y=0;y<core.bigmap.height;y++) {
-            var id = core.status.checkBlock.map[x+core.bigmap.width*y];
-            if (core.isset(id)) {
-
-                if (id=="lavaNet") {
-                    core.status.checkBlock.damage[x+core.bigmap.width*y]+=core.values.lavaDamage||0;
-                    continue;
-                }
-
-                var enemy = core.material.enemys[id];
-                // 存在领域
-                if (core.enemys.hasSpecial(enemy.special, 15)) {
-                    var range = enemy.range || 1;
-                    var zoneSquare = false;
-                    if (core.isset(enemy.zoneSquare)) zoneSquare=enemy.zoneSquare;
-                    for (var dx=-range;dx<=range;dx++) {
-                        for (var dy=-range;dy<=range;dy++) {
-                            if (dx==0 && dy==0) continue;
-                            var nx=x+dx, ny=y+dy;
-                            if (nx<0 || nx>=core.bigmap.width || ny<0 || ny>=core.bigmap.height) continue;
-                            if (!zoneSquare && Math.abs(dx)+Math.abs(dy)>range) continue;
-                            core.status.checkBlock.damage[nx+ny*core.bigmap.width]+=enemy.value||0;
-                        }
-                    }
-                }
-                // 存在激光
-                if (core.enemys.hasSpecial(enemy.special, 24)) {
-                    for (var nx=0;nx<core.bigmap.width;nx++) {
-                        if (nx!=x) core.status.checkBlock.damage[nx+y*core.bigmap.width]+=enemy.value||0;
-                    }
-                    for (var ny=0;ny<core.bigmap.height;ny++) {
-                        if (ny!=y) core.status.checkBlock.damage[x+ny*core.bigmap.width]+=enemy.value||0;
-                    }
-                }
-                // 存在阻击
-                if (core.enemys.hasSpecial(enemy.special, 18)) {
-                    for (var dx=-1;dx<=1;dx++) {
-                        for (var dy=-1;dy<=1;dy++) {
-                            if (dx==0 && dy==0) continue;
-                            var nx=x+dx, ny=y+dy;
-                            if (nx<0 || nx>=core.bigmap.width || ny<0 || ny>=core.bigmap.height || Math.abs(dx)+Math.abs(dy)>1) continue;
-                            core.status.checkBlock.damage[nx+ny*core.bigmap.width]+=enemy.value||0;
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-
-    // Step3: 更新夹击点坐标，并将夹击伤害加入到damage中
-    core.status.checkBlock.betweenAttack = []; // 记录(x,y)点是否有夹击
-    for (var x=0;x<core.bigmap.width;x++) {
-        for (var y=0;y<core.bigmap.height;y++) {
-            var has=false;
-            if (x>0 && x<core.bigmap.width-1) {
-                var id1=core.status.checkBlock.map[x-1+core.bigmap.width*y],
-                    id2=core.status.checkBlock.map[x+1+core.bigmap.height*y];
-                if (core.isset(id1) && core.isset(id2) && id1==id2) {
-                    var enemy = core.material.enemys[id1];
-                    if (core.isset(enemy) && core.enemys.hasSpecial(enemy.special, 16)) {
-                        has = true;
-                    }
-                }
-            }
-            if (y>0 && y<core.bigmap.height-1) {
-                var id1=core.status.checkBlock.map[x+core.bigmap.width*(y-1)],
-                    id2=core.status.checkBlock.map[x+core.bigmap.width*(y+1)];
-                if (core.isset(id1) && core.isset(id2) && id1==id2) {
-                    var enemy = core.material.enemys[id1];
-                    if (core.isset(enemy) && core.enemys.hasSpecial(enemy.special, 16)) {
-                        has = true;
-                    }
-                }
-            }
-            // 存在夹击
-            if (has) {
-                core.status.checkBlock.betweenAttack[x+core.bigmap.width*y]=true;
-                var leftHp = core.status.hero.hp - core.status.checkBlock.damage[x+core.bigmap.width*y];
-                if (leftHp>1)
-                    core.status.checkBlock.damage[x+core.bigmap.width*y] += Math.floor((leftHp+(core.flags.betweenAttackCeil?0:1))/2);
-            }
-        }
-    }
+control.prototype.updateCheckBlock = function(floorId) {
+    return this.controldata.updateCheckBlock(floorId);
 }
 
 ////// 检查并执行领域、夹击、阻击事件 //////
 control.prototype.checkBlock = function () {
-    var x=core.getHeroLoc('x'), y=core.getHeroLoc('y');
-    var damage = core.status.checkBlock.damage[x+core.bigmap.width*y];
-    if (damage>0) {
+    var x=core.getHeroLoc('x'), y=core.getHeroLoc('y'), loc = x+","+y;
+    var damage = core.status.checkBlock.damage[loc];
+    if (damage) {
         core.status.hero.hp -= damage;
-
-        // 检查阻击事件
-        var snipe = [];
-        var scan = {
-            'up': {'x': 0, 'y': -1},
-            'left': {'x': -1, 'y': 0},
-            'down': {'x': 0, 'y': 1},
-            'right': {'x': 1, 'y': 0}
-        }
-        for (var direction in scan) {
-            var nx = x+scan[direction].x, ny=y+scan[direction].y;
-            if (nx<0 || nx>=core.bigmap.width || ny<0 || ny>=core.bigmap.height) continue;
-            var id=core.status.checkBlock.map[nx+core.bigmap.width*ny];
-            if (core.isset(id)) {
-                var enemy = core.material.enemys[id];
-                if (core.isset(enemy) && core.enemys.hasSpecial(enemy.special, 18)) {
-                    snipe.push({'direction': direction, 'x': nx, 'y': ny});
-                }
-            }
-        }
-
-        if (core.status.checkBlock.betweenAttack[x+core.bigmap.width*y] && damage>0) {
-            core.drawTip('受到夹击，生命变成一半');
-        }
-        else if (core.status.checkBlock.map[x+core.bigmap.width*y]=='lavaNet') {
-            core.drawTip('受到血网伤害'+damage+'点');
-        }
-        // 阻击
-        else if (snipe.length>0 && damage>0) {
-            core.drawTip('受到阻击伤害'+damage+'点');
-        }
-        else if (damage>0) {
-            core.drawTip('受到领域或激光伤害'+damage+'点');
-        }
-
-        if (damage>0) {
-            core.playSound('zone.mp3');
-            core.drawAnimate("zone", x, y);
-        }
+        core.drawTip("受到"+(core.status.checkBlock.type[loc]||"伤害")+damage+"点");
+        this._checkBlock_soundAndAnimate(x, y);
+        this._checkBlock_disableQuickShop();
         core.status.hero.statistics.extraDamage += damage;
-
-        if (core.status.hero.hp<=0) {
+        if (core.status.hero.hp <= 0) {
             core.status.hero.hp=0;
             core.updateStatusBar();
             core.events.lose();
             return;
         }
-        snipe = snipe.filter(function (t) {
-            var x=t.x, y=t.y, direction = t.direction;
-            var nx = x+scan[direction].x, ny=y+scan[direction].y;
-
-            return nx>=0 && nx<core.bigmap.width && ny>=0 && ny<core.bigmap.height && core.getBlock(nx, ny, null, true)==null;
-        });
-        core.updateStatusBar();
-        if (snipe.length>0)
-            core.snipe(snipe);
     }
+    this._checkBlock_snipe(core.status.checkBlock.snipe[loc]);
+    this._checkBlock_ambush(core.status.checkBlock.ambush[loc]);
 }
 
-////// 阻击事件（动画效果） //////
-control.prototype.snipe = function (snipes) {
-
-    var scan = {
-        'up': {'x': 0, 'y': -1},
-        'left': {'x': -1, 'y': 0},
-        'down': {'x': 0, 'y': 1},
-        'right': {'x': 1, 'y': 0}
-    };
-
-    snipes.forEach(function (snipe) {
-        var x=snipe.x, y=snipe.y, direction = snipe.direction;
-        snipe.nx = x+scan[snipe.direction].x;
-        snipe.ny = y+scan[snipe.direction].y;
-
-        core.removeGlobalAnimate(x, y);
-
-        var block = core.getBlock(x,y).block;
-
-        var cls = block.event.cls;
-        var height = block.event.height || 32;
-
-        snipe.animate = block.event.animate || 1;
-        snipe.blockIcon = core.material.icons[cls][block.event.id];
-        snipe.blockImage = core.material.images[cls];
-        snipe.height = height;
-
-        var damage = core.enemys.getDamage(block.event.id);
-        var color = '#000000';
-
-        if (damage == null) {
-            damage = "???";
-            color = '#FF0000';
-        }
-        else {
-            if (damage <= 0) color = '#00FF00';
-            else if (damage < core.status.hero.hp / 3) color = '#FFFFFF';
-            else if (damage < core.status.hero.hp * 2 / 3) color = '#FFFF00';
-            else if (damage < core.status.hero.hp) color = '#FF7F00';
-            else color = '#FF0000';
-
-            damage = core.formatBigNumber(damage);
-        }
-
-        snipe.damage = damage;
-        snipe.color = color;
-        snipe.block = core.clone(block);
-
-    })
-
-    var finishSnipe = function () {
-        snipes.forEach(function (t) {
-            core.removeBlock(t.x, t.y);
-            var nBlock = core.clone(t.block);
-            nBlock.x = t.nx; nBlock.y = t.ny;
-            core.status.thisMap.blocks.push(nBlock);
-            core.drawBlock(nBlock);
-            core.addGlobalAnimate(nBlock);
-        });
-        core.syncGlobalAnimate();
-        core.updateStatusBar();
-        return;
-    }
-
-    if (core.status.replay.replaying) {
-        finishSnipe();
-    }
-    else {
-        core.waitHeroToStop(function() {
-
-            core.lockControl();
-
-            var time = 500, step = 0;
-
-            var animateCurrent = 0;
-            var animateTime = 0;
-
-            core.canvas.fg.textAlign = 'left';
-
-            var animate=window.setInterval(function() {
-
-                step++;
-                animateTime += time / 16;
-                if (animateTime >= core.values.animateSpeed) {
-                    animateCurrent++;
-                    animateTime = 0;
-                }
-
-                snipes.forEach(function (snipe) {
-                    var x=snipe.x, y=snipe.y, direction = snipe.direction;
-
-                    var dx = scan[direction].x*2*step, dy = scan[direction].y*2*step;
-                    var nowX = 32*x+dx, nowY = 32*y+dy;
-
-                    // 清空上一次
-                    core.clearMap('fg', nowX-2*scan[direction].x, nowY-2*scan[direction].y, 32, 32);
-                    core.canvas.event.clearRect(nowX-2*scan[direction].x, nowY-2*scan[direction].y, 32, 32);
-                    core.canvas.event2.clearRect(nowX-2*scan[direction].x, nowY-2*scan[direction].y-32, 32, 32)
-
-                    core.drawBlock(snipe.block, animateCurrent, dx, dy);
-
-                    if (core.hasItem('book')) {
-                        // drawFG
-                        core.setFillStyle('fg', '#000000');
-                        core.canvas.fg.fillText(snipe.damage, nowX + 2, nowY + 30);
-                        core.canvas.fg.fillText(snipe.damage, nowX, nowY + 30);
-                        core.canvas.fg.fillText(snipe.damage, nowX + 2, nowY + 32);
-                        core.canvas.fg.fillText(snipe.damage, nowX, nowY + 32);
-
-                        core.setFillStyle('fg', snipe.color);
-                        core.canvas.fg.fillText(snipe.damage, nowX + 1, nowY + 31);
-                    }
-
-                })
-
-                if (step==16) { // 移动完毕
-                    clearInterval(animate);
-                    finishSnipe();
-                    // 不存在自定义事件
-                    if (core.status.event.id==null)
-                        core.unLockControl();
-                }
-            }, time/16);
-        });
-    }
+control.prototype._checkBlock_soundAndAnimate = function (x,y) {
+    core.playSound('zone.mp3');
+    core.drawAnimate("zone", x, y);
 }
 
-////// 更改天气效果 //////
-control.prototype.setWeather = function (type, level) {
-
-    // 非雨雪
-    if (type!='rain' && type!='snow') {
-        core.clearMap('weather')
-        core.animateFrame.weather.type = null;
-        core.animateFrame.weather.level = 0;
-        core.animateFrame.weather.nodes = [];
-        return;
-    }
-
-    level = parseInt(level);
-
-    // 当前天气：则忽略
-    if (type==core.animateFrame.weather.type &&
-        (!core.isset(level) || 20*level==core.animateFrame.weather.level)) {
-        return;
-    }
-
-    if (!core.isset(level)) level=5;
-    if (level<1) level=1; if (level>10) level=10;
-    level *= 20;
-
-    core.clearMap('weather')
-    core.animateFrame.weather.type = type;
-    core.animateFrame.weather.level = level;
-
-    core.animateFrame.weather.nodes = [];
-
-    if (type == 'rain') {
-        for (var a=0;a<level;a++) {
-            core.animateFrame.weather.nodes.push({
-                'x': Math.random()*416,
-                'y': Math.random()*416,
-                'l': Math.random() * 2.5,
-                'xs': -4 + Math.random() * 4 + 2,
-                'ys': Math.random() * 10 + 10
-            })
-        }
-    }
-    else if (type=='snow') {
-        for (var a=0;a<level;a++) {
-            core.animateFrame.weather.nodes.push({
-                'x': Math.random()*416,
-                'y': Math.random()*416,
-                'r': Math.random() * 5 + 1,
-                'd': Math.random() * level,
-            })
+control.prototype._checkBlock_disableQuickShop = function () {
+    // 禁用快捷商店
+    if (core.flags.disableShopOnDamage) {
+        for (var shopId in core.status.shops) {
+            core.status.shops[shopId].visited = false;
         }
     }
 }
 
-////// 更改画面色调 //////
-control.prototype.setFg = function(color, time, callback) {
-    if (!core.isset(time)) time=750;
-    if (time<=0) time=0;
+////// 阻击 //////
+control.prototype._checkBlock_snipe = function (snipe) {
+    if (!snipe || snipe.length == 0) return;
+    var actions = [];
+    snipe.forEach(function (t) {
+        actions.push({"type": "move", "loc": [t[0],t[1]], "steps": [t[3]], "time": 500, "keep": true, "async": true});
+    });
+    actions.push({"type": "waitAsync"});
+    core.insertAction(actions);
+}
 
-    if (!core.isset(core.status.curtainColor)) {
-        core.status.curtainColor = [0,0,0,0];
-    }
-
-    var fromColor = core.status.curtainColor;
-
-    if (!core.isset(color))
-        color = [0,0,0,0];
-    if (color.length==3)
-        color.push(1);
-    if (color[3]<0) color[3]=0;
-    if (color[3]>1) color[3]=1;
-
-    if (time==0) {
-        // 直接变色
-        core.dom.curtain.style.background = core.arrayToRGB(color);
-        core.dom.curtain.style.opacity = color[3];
-        core.status.curtainColor = color;
-        if (core.isset(callback)) callback();
-        return;
-    }
-
-    var step=0;
-    core.status.replay.animate=true;
-    var changeAnimate = setInterval(function() {
-        step++;
-
-        var nowAlpha = fromColor[3]+(color[3]-fromColor[3])*step/25;
-        var nowR = parseInt(fromColor[0]+(color[0]-fromColor[0])*step/25);
-        var nowG = parseInt(fromColor[1]+(color[1]-fromColor[1])*step/25);
-        var nowB = parseInt(fromColor[2]+(color[2]-fromColor[2])*step/25);
-        core.dom.curtain.style.background = core.arrayToRGB([nowR,nowG,nowB]);
-        core.dom.curtain.style.opacity = nowAlpha;
-
-        if (step>=25) {
-            clearInterval(changeAnimate);
-            core.status.curtainColor = color;
-            core.status.replay.animate=false;
-            if (core.isset(callback)) callback();
-        }
-    }, time/25);
+////// 捕捉 //////
+control.prototype._checkBlock_ambush = function (ambush) {
+    if (!ambush || ambush.length == 0) return;
+    // 捕捉效果
+    var actions = [];
+    ambush.forEach(function (t) {
+        actions.push({"type": "move", "loc": [t[0],t[1]], "steps": [t[3]], "time": 500, "keep": false, "async":true});
+    });
+    actions.push({"type": "waitAsync"});
+    // 强制战斗
+    ambush.forEach(function (t) {
+        actions.push({"type": "battle", "id": t[2]});
+    });
+    core.insertAction(actions);
 }
 
 ////// 更新全地图显伤 //////
-control.prototype.updateFg = function () {
+control.prototype.updateDamage = function (floorId, ctx) {
+    floorId = floorId || core.status.floorId;
+    if (!core.isset(floorId) || core.status.gameOver) return;
+    if (core.status.gameOver) return;
+    var refreshCheckBlock = true;
+    if (!core.isset(ctx)) {
+        ctx = core.canvas.damage;
+        core.clearMap('damage');
+        refreshCheckBlock = false;
+    }
 
-    if (!core.isset(core.status.thisMap) || !core.isset(core.status.thisMap.blocks)) return;
-    // 更新显伤
-    var mapBlocks = core.status.thisMap.blocks;
-    core.clearMap('fg');
     // 没有怪物手册
     if (!core.hasItem('book')) return;
-    core.setFont('fg', "bold 11px Arial");
-    var hero_hp = core.status.hero.hp;
-    if (core.flags.displayEnemyDamage || core.flags.displayCritical) {
-        core.canvas.fg.textAlign = 'left';
-        for (var b = 0; b < mapBlocks.length; b++) {
-            var x = mapBlocks[b].x, y = mapBlocks[b].y;
-            if (core.isset(mapBlocks[b].event) && mapBlocks[b].event.cls.indexOf('enemy')==0
-                && !mapBlocks[b].disable) {
-
-                // 非系统默认的战斗事件（被覆盖）
-                if (mapBlocks[b].event.trigger != 'battle') {
-                    // 判断显伤
-                    var event = core.floors[core.status.floorId].events[x+","+y];
-                    if (core.isset(event) && !(event instanceof Array)) {
-                        if (core.isset(event.displayDamage) && !event.displayDamage)
-                            continue;
-                    }
-                }
-
-                var id = mapBlocks[b].event.id;
-
-                if (core.flags.displayEnemyDamage) {
-                    var damage = core.enemys.getDamage(id);
-                    var color = '#000000';
-
-                    if (damage == null) {
-                        damage = "???";
-                        color = '#FF0000';
-                    }
-                    else {
-                        if (damage <= 0) color = '#00FF00';
-                        else if (damage < hero_hp / 3) color = '#FFFFFF';
-                        else if (damage < hero_hp * 2 / 3) color = '#FFFF00';
-                        else if (damage < hero_hp) color = '#FF7F00';
-                        else color = '#FF0000';
-                        damage = core.formatBigNumber(damage);
-                        if (core.enemys.hasSpecial(core.material.enemys[id], 19))
-                            damage += "+";
-                    }
-
-                    core.setFillStyle('fg', '#000000');
-                    core.canvas.fg.fillText(damage, 32 * x + 2, 32 * (y + 1) - 2);
-                    core.canvas.fg.fillText(damage, 32 * x, 32 * (y + 1) - 2);
-                    core.canvas.fg.fillText(damage, 32 * x + 2, 32 * (y + 1));
-                    core.canvas.fg.fillText(damage, 32 * x, 32 * (y + 1));
-
-                    core.setFillStyle('fg', color);
-                    core.canvas.fg.fillText(damage, 32 * x + 1, 32 * (y + 1) - 1);
-                }
-
-                // 临界显伤
-                if (core.flags.displayCritical) {
-                    var critical = core.enemys.nextCriticals(id);
-                    if (critical.length>0) critical=critical[0];
-                    critical = core.formatBigNumber(critical[0]);
-                    if (critical == '???') critical = '?';
-                    core.setFillStyle('fg', '#000000');
-                    core.canvas.fg.fillText(critical, 32 * x + 2, 32 * (y + 1) - 2 - 10);
-                    core.canvas.fg.fillText(critical, 32 * x, 32 * (y + 1) - 2 - 10);
-                    core.canvas.fg.fillText(critical, 32 * x + 2, 32 * (y + 1) - 10);
-                    core.canvas.fg.fillText(critical, 32 * x, 32 * (y + 1) - 10);
-                    core.setFillStyle('fg', '#FFFFFF');
-                    core.canvas.fg.fillText(critical, 32 * x + 1, 32 * (y + 1) - 1 - 10);
-                }
-
-            }
-        }
-    }
-    // 如果是领域&夹击
-    if (core.flags.displayExtraDamage) {
-        core.canvas.fg.textAlign = 'center';
-        for (var x=0;x<core.bigmap.width;x++) {
-            for (var y=0;y<core.bigmap.height;y++) {
-                var damage = core.status.checkBlock.damage[x+core.bigmap.width*y];
-                if (damage>0) {
-                    damage = core.formatBigNumber(damage);
-                    core.setFillStyle('fg', '#000000');
-                    core.canvas.fg.fillText(damage, 32 * x + 17, 32 * (y + 1) - 13);
-                    core.canvas.fg.fillText(damage, 32 * x + 15, 32 * (y + 1) - 15);
-                    core.canvas.fg.fillText(damage, 32 * x + 17, 32 * (y + 1) - 15);
-                    core.canvas.fg.fillText(damage, 32 * x + 15, 32 * (y + 1) - 13);
-
-                    core.setFillStyle('fg', '#FF7F00');
-                    core.canvas.fg.fillText(damage, 32 * x + 16, 32 * (y + 1) - 14);
-                }
-            }
-        }
-    }
+    core.setFont(ctx, "bold 11px Arial");
+    this._updateDamage_damage(floorId, ctx);
+    this._updateDamage_extraDamage(floorId, ctx, refreshCheckBlock);
 }
 
-////// 执行一个表达式的effect操作 //////
-control.prototype.doEffect = function (effect) {
-    effect.split(";").forEach(function (expression) {
-        var arr = expression.split("+=");
-        if (arr.length!=2) return;
-        var name=arr[0], value=core.calValue(arr[1]);
-        if (name.indexOf("status:")==0) {
-            var status=name.substring(7);
-            core.setStatus(status, core.getStatus(status)+value);
-        }
-        else if (name.indexOf("item:")==0) {
-            var itemId=name.substring(5);
-            core.setItem(itemId, core.itemCount(itemId)+value);
+control.prototype._updateDamage_damage = function (floorId, ctx) {
+    core.setTextAlign(ctx, 'left');
+    core.status.maps[floorId].blocks.forEach(function (block) {
+        var x = block.x, y = block.y;
+        if (!block.disable && block.event.cls.indexOf('enemy') == 0 && block.event.displayDamage !== false) {
+           if (core.flags.displayEnemyDamage) {
+               var damageString = core.enemys.getDamageString(block.event.id, x, y, floorId);
+               var damage = damageString.damage, color = damageString.color;
+               core.fillBoldText(ctx, damage, 32*x+1, 32*(y+1)-1, color);
+           }
+           if (core.flags.displayCritical) {
+               var critical = core.enemys.nextCriticals(block.event.id, 1, x, y, floorId);
+               critical = core.formatBigNumber((critical[0]||[])[0], true);
+               if (critical == '???') critical = '?';
+               core.fillBoldText(ctx, critical, 32*x+1, 32*(y+1)-11, '#FFFFFF');
+           }
         }
     });
 }
 
-////// 开启debug模式 //////
-control.prototype.debug = function() {
-    core.setFlag('debug', true);
-    core.insertAction(["\t[调试模式开启]此模式下按住Ctrl键（或Ctrl+Shift键）可以穿墙并忽略一切事件。\n同时，录像将失效，也无法上传成绩。"]);
-    /*
-    core.setStatus('hp', 999999);
-    core.setStatus('atk', 10000);
-    core.setStatus('def', 10000);
-    core.setStatus('mdef', 10000);
-    core.setStatus('money', 10000);
-    core.setStatus('experience', 10000);
-    core.setItem('yellowKey', 50);
-    core.setItem('blueKey', 50);
-    core.setItem('redKey', 50);
-    core.setItem('book', 1);
-    core.setItem('fly', 1);
-    for (var i in core.status.maps)
-        if (core.status.maps[i].canFlyTo && core.status.hero.flyRange.indexOf(i)<0)
-            core.status.hero.flyRange.push(i);
-    core.updateStatusBar();
-    core.drawTip("作弊成功");
-    */
+control.prototype._updateDamage_extraDamage = function (floorId, ctx, refresh) {
+    core.setTextAlign(ctx, 'center');
+    if (refresh) this.updateCheckBlock(floorId);
+    if (core.flags.displayExtraDamage) {
+        var width = core.floors[floorId].width, height = core.floors[floorId].height;
+        for (var x=0;x<width;x++) {
+            for (var y=0;y<height;y++) {
+                var damage = core.status.checkBlock.damage[x+","+y]||0;
+                if (damage>0) { // 该点伤害
+                    damage = core.formatBigNumber(damage, true);
+                    core.fillBoldText(ctx, damage, 32*x+16, 32*(y+1)-14, '#FF7F00');
+                }
+                else { // 检查捕捉
+                    if (core.status.checkBlock.ambush[x+","+y]) {
+                        core.fillBoldText(ctx, '!', 32*x+16, 32*(y+1)-14, '#FF7F00');
+                    }
+                }
+            }
+        }
+    }
+}
+
+// ------ 录像相关 ------ //
+
+////// 选择录像文件 //////
+control.prototype.chooseReplayFile = function () {
+    core.readFile(function (obj) {
+        if (obj.name!=core.firstData.name) return alert("存档和游戏不一致！");
+        if (!obj.route) return alert("无效的录像！");
+        var _replay = function () {
+            core.startGame(core.flags.startUsingCanvas?'':obj.hard||'', obj.seed, core.decodeRoute(obj.route));
+        }
+        if (obj.version && obj.version!=core.firstData.version) {
+            core.myconfirm("游戏版本不一致！\n你仍然想播放录像吗？", _replay);
+            return;
+        }
+        _replay();
+    });
 }
 
 ////// 开始播放 //////
 control.prototype.startReplay = function (list) {
+    if (!core.isPlaying()) return;
     core.status.replay.replaying=true;
-    core.status.replay.pausing=false;
+    core.status.replay.pausing=true;
     core.status.replay.speed=1.0;
     core.status.replay.toReplay = core.clone(list);
-    core.status.replay.totalList = core.clone(list);
+    core.status.replay.totalList = core.status.route.concat(list);
     core.status.replay.steps = 0;
     core.status.replay.save = [];
     core.updateStatusBar();
     core.drawTip("开始播放");
     this.replay();
-    return;
 }
 
 ////// 更改播放状态 //////
 control.prototype.triggerReplay = function () {
-    if (core.status.event.id=='save' || (core.status.event.id||"").indexOf('book')==0 || core.status.event.id=='viewMaps') return;
     if (core.status.replay.pausing) this.resumeReplay();
     else this.pauseReplay();
 }
 
 ////// 暂停播放 //////
 control.prototype.pauseReplay = function () {
-    if (core.status.event.id=='save' || (core.status.event.id||"").indexOf('book')==0 || core.status.event.id=='viewMaps') return;
-    if (!core.status.replay.replaying) return;
+    if (!core.isPlaying() || !core.isReplaying()) return;
     core.status.replay.pausing = true;
     core.updateStatusBar();
     core.drawTip("暂停播放");
@@ -1754,38 +1084,61 @@ control.prototype.pauseReplay = function () {
 
 ////// 恢复播放 //////
 control.prototype.resumeReplay = function () {
-    if (core.status.event.id=='save' || (core.status.event.id||"").indexOf('book')==0 || core.status.event.id=='viewMaps') return;
-    if (!core.status.replay.replaying) return;
+    if (!core.isPlaying() || !core.isReplaying()) return;
+    if (core.isMoving() || core.status.replay.animate || core.status.event.id)
+        return core.drawTip("请等待当前事件的处理结束");
     core.status.replay.pausing = false;
     core.updateStatusBar();
     core.drawTip("恢复播放");
     core.replay();
 }
 
+////// 单步播放 //////
+control.prototype.stepReplay = function () {
+    if (!core.isPlaying() || !core.isReplaying()) return;
+    if (!core.status.replay.pausing) return core.drawTip("请先暂停录像");
+    if (core.isMoving() || core.status.replay.animate || core.status.event.id)
+        return core.drawTip("请等待当前事件的处理结束");
+    core.replay(true);
+}
+
 ////// 加速播放 //////
 control.prototype.speedUpReplay = function () {
-    if (core.status.event.id=='save' || (core.status.event.id||"").indexOf('book')==0 || core.status.event.id=='viewMaps') return;
-    if (!core.status.replay.replaying) return;
-    var toAdd = core.status.replay.speed>=3?3:core.status.replay.speed>=2?2:1;
-    core.status.replay.speed = parseInt(10*core.status.replay.speed + toAdd)/10;
-    if (core.status.replay.speed>6.0) core.status.replay.speed=6.0;
+    if (!core.isPlaying() || !core.isReplaying()) return;
+    var speeds = [0.2, 0.5, 1, 2, 3, 6, 12, 24];
+    for (var i = speeds.length - 2; i >= 0; i--) {
+        if (speeds[i] <= core.status.replay.speed) {
+            core.status.replay.speed = speeds[i+1];
+            break;
+        }
+    }
     core.drawTip("x"+core.status.replay.speed+"倍");
 }
 
 ////// 减速播放 //////
 control.prototype.speedDownReplay = function () {
-    if (core.status.event.id=='save' || (core.status.event.id||"").indexOf('book')==0 || core.status.event.id=='viewMaps') return;
-    if (!core.status.replay.replaying) return;
-    var toAdd = core.status.replay.speed>3?3:core.status.replay.speed>2?2:1;
-    core.status.replay.speed = parseInt(10*core.status.replay.speed - toAdd)/10;
-    if (core.status.replay.speed<0.3) core.status.replay.speed=0.3;
+    if (!core.isPlaying() || !core.isReplaying()) return;
+    var speeds = [0.2, 0.5, 1, 2, 3, 6, 12, 24];
+    for (var i = 1; i <= speeds.length; i++) {
+        if (speeds[i] >= core.status.replay.speed) {
+            core.status.replay.speed = speeds[i-1];
+            break;
+        }
+    }
+    core.drawTip("x"+core.status.replay.speed+"倍");
+}
+
+////// 设置播放速度 //////
+control.prototype.setReplaySpeed = function (speed) {
+    if (!core.isPlaying() || !core.isReplaying()) return;
+    core.status.replay.speed = speed;
     core.drawTip("x"+core.status.replay.speed+"倍");
 }
 
 ////// 停止播放 //////
-control.prototype.stopReplay = function () {
-    if (core.status.event.id=='save' || (core.status.event.id||"").indexOf('book')==0 || core.status.event.id=='viewMaps') return;
-    if (!core.status.replay.replaying) return;
+control.prototype.stopReplay = function (force) {
+    if (!core.isPlaying()) return;
+    if (!core.isReplaying() && !force) return;
     core.status.replay.toReplay = [];
     core.status.replay.totalList = [];
     core.status.replay.replaying=false;
@@ -1799,23 +1152,13 @@ control.prototype.stopReplay = function () {
 
 ////// 回退 //////
 control.prototype.rewindReplay = function () {
-    if (core.status.event.id=='save' || (core.status.event.id||"").indexOf('book')==0 || core.status.event.id=='viewMaps') return;
-    if (!core.status.replay.replaying) return;
-    if (!core.status.replay.pausing) {
-        core.drawTip("请先暂停录像");
-        return;
-    }
-    if (core.status.replay.animate) {
-        core.drawTip("请等待当前事件的处理结束");
-        return;
-    }
-    if (core.status.replay.save.length==0) {
-        core.drawTip("无法再回到上一个节点");
-        return;
-    }
-
-    var save = core.status.replay.save;
-    var data = save.pop();
+    if (!core.isPlaying() || !core.isReplaying()) return;
+    if (!core.status.replay.pausing) return core.drawTip("请先暂停录像");
+    if (core.isMoving() || core.status.replay.animate || core.status.event.id)
+        return core.drawTip("请等待当前事件的处理结束");
+    if (core.status.replay.save.length==0)
+        return core.drawTip("无法再回到上一个节点");
+    var save = core.status.replay.save, data = save.pop();
     core.loadData(data.data, function () {
         core.status.replay = {
             "replaying": true,
@@ -1829,25 +1172,19 @@ control.prototype.rewindReplay = function () {
         }
         core.updateStatusBar();
         core.drawTip("成功回退到上一个节点");
-    })
+    });
 }
 
 ////// 回放时存档 //////
 control.prototype.saveReplay = function () {
-    if (core.status.event.id=='save' || (core.status.event.id||"").indexOf('book')==0 || core.status.event.id=='viewMaps') return;
-    if (!core.status.replay.replaying) return;
-    if (!core.status.replay.pausing) {
-        core.drawTip("请先暂停录像");
-        return;
-    }
-    if (core.status.replay.animate || core.isset(core.status.event.id)) {
-        core.drawTip("请等待当前事件的处理结束");
-        return;
-    }
+    if (!core.isPlaying() || !core.isReplaying()) return;
+    if (!core.status.replay.pausing) return core.drawTip("请先暂停录像");
+    if (core.isMoving() || core.status.replay.animate || core.status.event.id)
+        return core.drawTip("请等待当前事件的处理结束");
 
     core.lockControl();
     core.status.event.id='save';
-    var saveIndex = core.status.saveIndex;
+    var saveIndex = core.saves.saveIndex;
     var page=parseInt((saveIndex-1)/5), offset=saveIndex-5*page;
 
     core.ui.drawSLPanel(10*page+offset);
@@ -1855,65 +1192,103 @@ control.prototype.saveReplay = function () {
 
 ////// 回放时查看怪物手册 //////
 control.prototype.bookReplay = function () {
-    if (core.status.event.id=='save' || (core.status.event.id||"").indexOf('book')==0) return;
-    if (!core.status.replay.replaying) return;
-    if (!core.status.replay.pausing) {
-        core.drawTip("请先暂停录像");
-        return;
-    }
+    if (!core.isPlaying() || !core.isReplaying()) return;
+    if (!core.status.replay.pausing) return core.drawTip("请先暂停录像");
+    if (core.isMoving() || core.status.replay.animate
+        || (core.status.event.id && core.status.event.id != 'viewMaps'))
+        return core.drawTip("请等待当前事件的处理结束");
 
     // 从“浏览地图”页面打开
-    if (core.status.event.id=='viewMaps') {
+    if (core.status.event.id=='viewMaps')
         core.status.event.selection = core.status.event.data;
-        core.status.event.id=null;
-    }
-
-    if (core.status.replay.animate || core.isset(core.status.event.id)) {
-        core.drawTip("请等待当前事件的处理结束");
-        return;
-    }
 
     core.lockControl();
     core.status.event.id='book';
-    core.useItem('book');
+    core.useItem('book', true);
 }
 
 ////// 回放录像时浏览地图 //////
 control.prototype.viewMapReplay = function () {
-    if (core.status.event.id=='save' || (core.status.event.id||"").indexOf('book')==0 || core.status.event.id=='viewMaps') return;
-
-    if (!core.status.replay.replaying) return;
-    if (!core.status.replay.pausing) {
-        core.drawTip("请先暂停录像");
-        return;
-    }
-    if (core.status.replay.animate || core.isset(core.status.event.id)) {
-        core.drawTip("请等待当前事件的处理结束");
-        return;
-    }
+    if (!core.isPlaying() || !core.isReplaying()) return;
+    if (!core.status.replay.pausing) return core.drawTip("请先暂停录像");
+    if (core.isMoving() || core.status.replay.animate || core.status.event.id)
+        return core.drawTip("请等待当前事件的处理结束");
 
     core.lockControl();
     core.status.event.id='viewMaps';
     core.ui.drawMaps();
 }
 
+////// 是否正在播放录像 //////
+control.prototype.isReplaying = function () {
+    return (core.status.replay||{}).replaying;
+}
+
 ////// 回放 //////
-control.prototype.replay = function () {
+control.prototype.replay = function (force) {
+    if (!core.isPlaying() || !core.isReplaying()
+         || core.status.replay.animate || core.status.event.id) return;
+    if (core.status.replay.pausing && !force) return;
+    if (core.status.replay.toReplay.length==0)
+        return this._replay_finished();
+    this._replay_save();
+    var action=core.status.replay.toReplay.shift();
+    if (this._doReplayAction(action)) return;
+    this._replay_error(action);
+}
 
-    if (!core.status.replay.replaying) return; // 没有回放
-    if (core.status.replay.pausing) return; // 暂停状态
-    if (core.status.replay.animate) return; // 正在某段动画中
+////// 注册一个录像行为 //////
+// name：自定义名称，可用于注销使用
+// func：具体执行录像的函数，可为一个函数或插件中的函数名；
+//       需要接受一个action参数，代表录像回放时的下一个操作
+// func返回true代表成功处理了此录像行为，false代表没有处理此录像行为。
+control.prototype.registerReplayAction = function (name, func) {
+    this.unregisterReplayAction(name);
+    this.replayActions.push({name: name, func: func});
+}
 
-    if (core.status.replay.toReplay.length==0) { // 回放完毕
-        core.stopReplay();
-        core.insertAction("录像回放完毕！");
-        return;
+////// 注销一个录像行为 //////
+control.prototype.unregisterReplayAction = function (name) {
+    this.replayActions = this.replayActions.filter(function (b) { return b.name != name; });
+}
+
+////// 执行录像行为，会在注册的函数中依次执行直到得到true为止 //////
+control.prototype._doReplayAction = function (action) {
+    for (var i in this.replayActions) {
+        try {
+            if (core.doFunc(this.replayActions[i].func, this, action)) return true;
+        } catch (e) {
+            main.log(e);
+            main.log("ERROR in replayActions["+this.replayActions[i].name+"]：已自动注销该项。");
+            core.unregisterReplayAction(this.replayActions[i].name);
+        }
     }
+    return false;
+}
 
+control.prototype._replay_finished = function () {
+    core.status.replay.replaying = false;
+    core.status.event.selection = 0;
+    var str = "录像播放完毕，你想退出播放吗？";
+    if (core.status.route.length != core.status.replay.totalList.length
+        || core.subarray(core.status.route, core.status.replay.totalList) == null) {
+        str = "录像播放完毕，但记录不一致。\n请检查录像播放时的二次记录问题。\n你想退出播放吗？";
+    }
+    core.ui.drawConfirmBox(str, function () {
+        core.ui.closePanel();
+        core.stopReplay(true);
+    }, function () {
+        core.status.replay.replaying = true;
+        core.ui.closePanel();
+        core.pauseReplay();
+    });
+}
+
+control.prototype._replay_save = function () {
     core.status.replay.steps++;
     if (core.status.replay.steps%50==0) {
-        //if (core.status.replay.save.length == 30)
-        //    core.status.replay.save.shift();
+        if (core.status.replay.save.length == 30)
+            core.status.replay.save.shift();
         core.status.replay.save.push({"data": core.saveData(), "replay": {
             "totalList": core.clone(core.status.replay.totalList),
             "toReplay": core.clone(core.status.replay.toReplay),
@@ -1921,374 +1296,360 @@ control.prototype.replay = function () {
             "steps": core.status.replay.steps
         }});
     }
-
-    var action=core.status.replay.toReplay.shift();
-
-    if (action=='up' || action=='down' || action=='left' || action=='right') {
-        core.moveHero(action, function () {
-            setTimeout(function() {
-                core.replay();
-            });
-        });
-        return;
-    }
-    else if (action.indexOf("item:")==0) {
-        var itemId = action.substring(5);
-        if (core.canUseItem(itemId)) {
-            var tools = Object.keys(core.status.hero.items.tools).sort();
-            var constants = Object.keys(core.status.hero.items.constants).sort();
-            var index;
-            if ((index=tools.indexOf(itemId))>=0 || (index=constants.indexOf(itemId)+1000)>=1000) {
-                core.ui.drawToolbox(index);
-                setTimeout(function () {
-                    core.ui.closePanel();
-                    core.useItem(itemId, function () {
-                        core.replay();
-                    });
-                }, 750 / Math.max(1, core.status.replay.speed));
-            }
-            return;
-        }
-    }
-    else if (action.indexOf("fly:")==0) {
-        var floorId=action.substring(4);
-        var toIndex=core.status.hero.flyRange.indexOf(floorId);
-        var nowIndex=core.status.hero.flyRange.indexOf(core.status.floorId);
-        if (core.hasItem('fly') && toIndex>=0 && nowIndex>=0) {
-            core.ui.drawFly(toIndex);
-            setTimeout(function () {
-                core.ui.closePanel();
-                var stair=toIndex<nowIndex?"upFloor":"downFloor";
-                if (toIndex==nowIndex && core.floors[core.status.floorId].underGround)
-                    stair = "upFloor";
-                core.status.route.push("fly:"+floorId);
-                core.changeFloor(floorId, stair, null, null, function () {
-                    core.replay();
-                });
-            }, 750 / Math.max(1, core.status.replay.speed));
-            return;
-        }
-    }
-    else if (action.indexOf("shop:")==0) {
-        var sps=action.substring(5).split(":");
-        var shopId=sps[0], selections=sps[1].split("");
-
-        if (selections.length>0) {
-            var shop=core.status.shops[shopId];
-            if (core.isset(shop) && shop.visited) { // 商店可用
-                var choices = shop.choices;
-                var topIndex = 6 - parseInt(choices.length / 2);
-
-                core.status.event.selection = parseInt(selections.shift());
-
-                core.events.openShop(shopId, false);
-                var shopInterval = setInterval(function () {
-                    if (!core.actions.clickShop(6, topIndex+core.status.event.selection)) {
-                        clearInterval(shopInterval);
-                        core.stopReplay();
-                        core.drawTip("录像文件出错");
-                        return;
-                    }
-                    if (selections.length==0) {
-                        clearInterval(shopInterval);
-                        core.actions.clickShop(6, topIndex+choices.length);
-                        core.replay();
-                        return;
-                    }
-                    core.status.event.selection = parseInt(selections.shift());
-                    core.events.openShop(shopId, false);
-
-                }, 750 / Math.max(1, core.status.replay.speed));
-                return;
-            }
-        }
-    }
-    else if (action=='turn') {
-        core.turnHero();
-        core.replay();
-        return;
-    }
-    else if (action=='getNext') {
-        if (core.flags.enableGentleClick && core.getBlock(core.nextX(), core.nextY())!=null) {
-            var nextX = core.nextX(), nextY = core.nextY();
-            var block = core.getBlock(nextX, nextY);
-            if (block!=null && block.block.event.trigger=='getItem') {
-                core.getItem(block.block.event.id, 1, nextX, nextY);
-                core.status.route.push("getNext");
-                core.replay();
-                return;
-            }
-        }
-    }
-    else if (action.indexOf('move:')==0) {
-        while (core.status.replay.toReplay.length>0 &&
-            core.status.replay.toReplay[0].indexOf('move:')==0) {
-            action = core.status.replay.toReplay.shift();
-        }
-
-        var pos=action.substring(5).split(":");
-        var x=parseInt(pos[0]), y=parseInt(pos[1]);
-        var nowx=core.getHeroLoc('x'), nowy=core.getHeroLoc('y');
-        if (core.control.moveDirectly(x,y)) {
-            core.ui.drawArrow('route', 32*nowx+16, 32*nowy+16, 32*x+16, 32*y+16, '#FF0000', 3);
-            setTimeout(function () {
-                core.clearMap('route');
-                core.replay();
-            }, 750 / Math.max(1, core.status.replay.speed));
-            return;
-        }
-    }
-    else if (action.indexOf('key:')==0) {
-        core.actions.keyUp(parseInt(action.substring(4)), true);
-        core.replay();
-        return;
-    }
-
-    core.stopReplay();
-    core.insertAction("录像文件出错");
-
 }
 
-////// 判断当前能否进入某个事件 //////
-control.prototype.checkStatus = function (name, need, item) {
-    if (need && core.status.event.id == name) {
+control.prototype._replay_error = function (action) {
+    core.ui.closePanel();
+    core.status.replay.replaying = false;
+    var len = core.status.replay.toReplay.length;
+    var prevList = core.status.replay.totalList.slice(-len - 11, -len - 1);
+    var nextList = core.status.replay.toReplay.slice(0, 10);
+    main.log("录像文件出错，当前操作：" + action);
+    main.log("之前的10个操作是：\n" + prevList.toString());
+    main.log("接下来10个操作是：\n" + nextList.toString());
+    core.ui.drawConfirmBox("录像文件出错，你想回到上个节点吗？", function () {
         core.ui.closePanel();
-        return false;
-    }
+        if (core.status.replay.save.length > 0) {
+            core.status.replay.replaying = true;
+            core.status.replay.pausing = true;
+            core.rewindReplay();
+        }
+        else {
+            core.drawTip("无法回到上一个节点");
+            core.stopReplay(true);
+        }
+    }, function () {
+        core.ui.closePanel();
+        core.stopReplay(true);
+    });
+}
 
-    if (need && core.status.lockControl) return false;
-    if (core.isset(item) && item && !core.hasItem(name)) {
-        core.drawTip("你没有" + core.material.items[name].name);
-        return false;
-    }
-    if (!core.status.heroStop) {
-        core.drawTip("请先停止勇士行动");
-        return false;
-    }
+control.prototype.__replay_getTimeout = function () {
+    return 750 / Math.max(1, core.status.replay.speed);
+}
 
-    core.lockControl();
-    core.status.event.id = name;
+control.prototype._replayAction_move = function (action) {
+    if (["up","down","left","right"].indexOf(action)<0) return false;
+    core.moveHero(action, function () {
+        setTimeout(core.replay);
+    });
     return true;
 }
 
-////// 点击怪物手册时的打开操作 //////
-control.prototype.openBook = function (need) {
-    if (core.isset(core.status.replay)&&core.status.replay.replaying) return;
+control.prototype._replayAction_item = function (action) {
+    if (action.indexOf("item:")!=0) return false;
+    var itemId = action.substring(5);
+    if (!core.canUseItem(itemId)) return false;
+    if (core.material.items[itemId].hideInReplay) {
+        core.useItem(itemId, false, core.replay);
+        return true;
+    }
+    var tools = Object.keys(core.status.hero.items.tools).sort();
+    var constants = Object.keys(core.status.hero.items.constants).sort();
+    var index, per = core.__SIZE__-1;
+    if ((index=tools.indexOf(itemId))>=0) {
+        core.status.event.data = {"toolsPage": Math.floor(index/per)+1, "constantsPage":1};
+        index = index%per;
+    }
+    else if ((index=constants.indexOf(itemId))>=0) {
+        core.status.event.data = {"toolsPage": 1, "constantsPage": Math.floor(index/per)+1};
+        index = index%per+per;
+    }
+    if (index<0) return false;
+    core.ui.drawToolbox(index);
+    setTimeout(function () {
+        core.ui.closePanel();
+        core.useItem(itemId, false, core.replay);
+    }, core.control.__replay_getTimeout());
+    return true;
+}
 
-    // 当前是book，且从“浏览地图”打开
-    if (core.status.event.id == 'book' && core.isset(core.status.event.selection)) {
-        core.status.boxAnimateObjs = [];
-        core.ui.drawMaps(core.status.event.selection);
-        return;
+control.prototype._replayAction_equip = function (action) {
+    if (action.indexOf("equip:")!=0) return false;
+    var equipId = action.substring(6);
+    var ownEquipment = Object.keys(core.status.hero.items.equips).sort();
+    var index = ownEquipment.indexOf(equipId), per = core.__SIZE__-1;
+    if (index<0) return false;
+    core.status.route.push(action);
+    core.status.event.data = {"page":Math.floor(index/per)+1, "selectId":null};
+    index = index%per+per;
+    core.ui.drawEquipbox(index);
+    setTimeout(function () {
+        core.ui.closePanel();
+        core.loadEquip(equipId, core.replay);
+    }, core.control.__replay_getTimeout());
+    return true;
+}
+
+control.prototype._replayAction_unEquip = function (action) {
+    if (action.indexOf("unEquip:")!=0) return false;
+    var equipType = parseInt(action.substring(8));
+    if (!core.isset(equipType)) return false;
+    core.ui.drawEquipbox(equipType);
+    core.status.route.push(action);
+    setTimeout(function () {
+        core.ui.closePanel();
+        core.unloadEquip(equipType, core.replay);
+    }, core.control.__replay_getTimeout());
+    return true;
+}
+
+control.prototype._replayAction_fly = function (action) {
+    if (action.indexOf("fly:")!=0) return false;
+    var floorId=action.substring(4);
+    var toIndex=core.floorIds.indexOf(floorId);
+    if (!core.canUseItem('fly')) return false;
+    core.ui.drawFly(toIndex);
+    setTimeout(function () {
+        if (!core.flyTo(floorId, core.replay))
+            core.control._replay_error(action);
+    }, core.control.__replay_getTimeout());
+    return true;
+}
+
+control.prototype._replayAction_shop = function (action) {
+    if (action.indexOf("shop:")!=0) return false;
+    var sps=action.substring(5).split(":");
+    var shopId=sps[0], selections=sps[1].split("");
+    if (selections.length == 0) return false;
+    var shop=core.status.shops[shopId];
+    if (!shop || !shop.visited) return false;
+    // --- 判定commonEvent
+    if (shop.commonEvent) {
+        core.openShop(shopId, false);
+        setTimeout(core.replay);
+        return true;
+    }
+    var choices = shop.choices;
+    core.status.event.selection = parseInt(selections.shift());
+    core.events.openShop(shopId, false);
+    var topIndex = core.__HALF_SIZE__ - parseInt(choices.length / 2) + (core.status.event.ui.offset || 0);
+    var shopInterval = setInterval(function () {
+        if (!core.actions._clickShop(core.__HALF_SIZE__, topIndex+core.status.event.selection)) {
+            clearInterval(shopInterval);
+            core.control._replay_error(action);
+            return;
+        }
+        if (selections.length==0) {
+            clearInterval(shopInterval);
+            core.actions._clickShop(core.__HALF_SIZE__, topIndex+choices.length);
+            core.replay();
+            return;
+        }
+        core.status.event.selection = parseInt(selections.shift());
+        core.events.openShop(shopId, false);
+    }, core.control.__replay_getTimeout());
+    return true;
+}
+
+control.prototype._replayAction_turn = function (action) {
+    if (action != 'turn' && action.indexOf('turn:') != 0) return false;
+    if (action == 'turn') core.turnHero();
+    else core.turnHero(action.substring(5));
+    setTimeout(core.replay);
+    return true;
+}
+
+control.prototype._replayAction_getNext = function (action) {
+    if (action != "getNext") return false;
+    if (!core.getNextItem()) return false;
+    setTimeout(core.replay);
+    return true;
+}
+
+control.prototype._replayAction_moveDirectly = function (action) {
+    if (action.indexOf("move:")!=0) return false;
+    // 忽略连续的瞬移事件
+    while (core.status.replay.toReplay.length>0 &&
+        core.status.replay.toReplay[0].indexOf('move:')==0) {
+            core.status.route.push(action);
+            action = core.status.replay.toReplay.shift();
     }
 
-    // 从“浏览地图”页面打开
-    if (core.status.event.id=='viewMaps') {
-        need=false;
-        core.status.event.selection = core.status.event.data;
-    }
-
-    if (!core.checkStatus('book', need, true))
-        return;
-    core.useItem('book');
+    var pos=action.substring(5).split(":");
+    var x=parseInt(pos[0]), y=parseInt(pos[1]);
+    var nowx=core.getHeroLoc('x'), nowy=core.getHeroLoc('y');
+    if (!core.moveDirectly(x, y)) return false;
+    core.ui.drawArrow('ui', 32*nowx+16-core.bigmap.offsetX, 32*nowy+16-core.bigmap.offsetY,
+        32*x+16-core.bigmap.offsetX, 32*y+16-core.bigmap.offsetY, '#FF0000', 3);
+    setTimeout(function () {
+        core.clearMap('ui');
+        core.replay();
+    }, core.control.__replay_getTimeout());
+    return true;
 }
 
-////// 点击楼层传送器时的打开操作 //////
-control.prototype.useFly = function (need) {
-    if (core.isset(core.status.replay)&&core.status.replay.replaying) return;
-    if (!core.checkStatus('fly', need, true))
-        return;
-    if (core.flags.flyNearStair && !core.nearStair()) {
-        core.drawTip("只有在楼梯边才能使用传送器");
-        core.unLockControl();
-        core.status.event.data = null;
-        core.status.event.id = null;
-        return;
-    }
-    if (!core.canUseItem('fly')) {
-        core.drawTip("楼层传送器好像失效了");
-        core.unLockControl();
-        core.status.event.data = null;
-        core.status.event.id = null;
-        return;
-    }
-    core.useItem('fly');
-    return;
+control.prototype._replayAction_key = function (action) {
+    if (action.indexOf("key:") != 0) return false;
+    core.actions.keyUp(parseInt(action.substring(4)), false, true);
+    setTimeout(core.replay);
+    return true;
 }
 
-////// 点击工具栏时的打开操作 //////
-control.prototype.openToolbox = function (need) {
-    if (core.isset(core.status.replay)&&core.status.replay.replaying) return;
-    if (!core.checkStatus('toolbox', need))
-        return;
-    core.ui.drawToolbox();
-}
-
-////// 点击快捷商店按钮时的打开操作 //////
-control.prototype.openQuickShop = function (need) {
-    if (core.isset(core.status.replay)&&core.status.replay.replaying) return;
-    if (!core.checkStatus('selectShop', need))
-        return;
-    core.ui.drawQuickShop();
-}
-
-////// 点击保存按钮时的打开操作 //////
-control.prototype.save = function(need) {
-    if (core.isset(core.status.replay)&&core.status.replay.replaying) return;
-    if (!core.checkStatus('save', need))
-        return;
-
-    var saveIndex = core.status.saveIndex;
-    var page=parseInt((saveIndex-1)/5), offset=saveIndex-5*page;
-
-    core.ui.drawSLPanel(10*page+offset);
-}
-
-////// 点击读取按钮时的打开操作 //////
-control.prototype.load = function (need) {
-    if (core.isset(core.status.replay)&&core.status.replay.replaying) return;
-
-    var saveIndex = core.getLocalStorage('saveIndex2', 1);
-    var page=parseInt((saveIndex-1)/5), offset=saveIndex-5*page;
-
-    // 游戏开始前读档
-    if (!core.isPlaying()) {
-        core.status.event = {'id': 'load', 'data': null};
-        core.status.lockControl = true;
-        core.dom.startPanel.style.display = 'none';
-        core.ui.drawSLPanel(10*page+offset);
-        return;
-    }
-
-    if (!core.checkStatus('load', need))
-        return;
-    core.ui.drawSLPanel(10*page+offset);
-}
-
-////// 点击设置按钮时的操作 //////
-control.prototype.openSettings = function (need) {
-    if (core.isset(core.status.replay)&&core.status.replay.replaying) return;
-    if (!core.checkStatus('settings', need))
-        return;
-    core.ui.drawSettings();
-}
+// ------ 存读档相关 ------ //
 
 ////// 自动存档 //////
 control.prototype.autosave = function (removeLast) {
-    if (core.status.event.id!=null)
-        return;
     var x=null;
-    if (removeLast)
+    if (removeLast) {
         x=core.status.route.pop();
-    core.setLocalStorage("autoSave", core.saveData())
-    if (removeLast && core.isset(x))
-        core.status.route.push(x);
+        core.status.route.push("turn:"+core.getHeroLoc('direction'));
+    }
+    if (core.status.event.id == 'action') // 事件中的自动存档
+        core.setFlag("__events__", core.clone(core.status.event.data));
+    core.saves.autosave.data = core.saveData();
+    core.saves.autosave.updated = true;
+    core.saves.ids[0] = true;
+    core.removeFlag("__events__");
+    if (removeLast) {
+        core.status.route.pop();
+        if (x) core.status.route.push(x);
+    }
+}
+
+/////// 实际进行自动存档 //////
+control.prototype.checkAutosave = function () {
+    if (!core.animateFrame || !core.saves || !core.saves.autosave) return;
+    core.setLocalStorage('totalTime', core.animateFrame.totalTime);
+    if (core.saves.autosave.data == null || !core.saves.autosave.updated) return;
+    core.saves.autosave.updated = false;
+    core.setLocalForage("autoSave", core.saves.autosave.data);
 }
 
 ////// 实际进行存读档事件 //////
 control.prototype.doSL = function (id, type) {
-    if (type=='save') {
-        if (id=='autoSave') {
-            core.drawTip('不能覆盖自动存档！');
-            return;
-        }
-        if (core.setLocalStorage("save"+id, core.saveData())) {
+    switch (type) {
+        case 'save': this._doSL_save(id); break;
+        case 'load': this._doSL_load(id, this._doSL_load_afterGet); break;
+        case 'replayLoad': this._doSL_load(id, this._doSL_replayLoad_afterGet); break;
+        case 'replayRemain': this._doSL_load(id, this._doSL_replayRemain_afterGet); break;
+    }
+}
+
+control.prototype._doSL_save = function (id) {
+    if (id=='autoSave') return core.drawTip('不能覆盖自动存档！');
+    // 在事件中的存档
+    if (core.status.event.interval != null)
+        core.setFlag("__events__", core.status.event.interval);
+    core.setLocalForage("save"+id, core.saveData(), function() {
+        core.saves.saveIndex=id;
+        core.setLocalStorage('saveIndex', core.saves.saveIndex);
+        // 恢复事件
+        if (!core.events.recoverEvents(core.status.event.interval))
             core.ui.closePanel();
-            core.drawTip('存档成功！');
-            if (id!="autoSave") {
-                core.status.saveIndex=id;
-                core.setLocalStorage('saveIndex2', core.status.saveIndex);
-            }
+        core.drawTip('存档成功！');
+    }, function(err) {
+        main.log(err);
+        if (core.platform.useLocalForage) {
+            alert("存档失败，错误信息：\n"+err);
         }
         else {
-            core.drawTip('存储空间不足，请覆盖已有的存档或在菜单栏中进行清理');
+            alert("存档失败，错误信息：\n"+err+"\n建议使用垃圾存档清理工具进行清理！");
         }
+    });
+    core.removeFlag("__events__");
+    return;
+}
+
+control.prototype._doSL_load = function (id, callback) {
+    if (id == 'autoSave' && core.saves.autosave.data != null) {
+        callback(id, core.clone(core.saves.autosave.data))
+    }
+    else {
+        core.getLocalForage(id=='autoSave'?id:"save"+id, null, function(data) {
+            if (id == 'autoSave') core.saves.autosave.data = core.clone(data);
+            callback(id, data);
+        }, function(err) {
+            main.log(err);
+            alert("无效的存档");
+        })
+    }
+    return;
+}
+
+control.prototype._doSL_load_afterGet = function (id, data) {
+    if (!data) return alert("无效的存档");
+    var _replay = function () {
+        core.startGame(data.hard, data.hero.flags.__seed__, core.decodeRoute(data.route));
+    };
+    if (core.flags.checkConsole && data.hashCode != null && data.hashCode != core.hashCode(data.hero)) {
+        core.myconfirm("存档校验失败，请勿修改存档文件！\n你想回放此存档的录像吗？\n可以随时停止录像播放以继续游戏。", _replay);
         return;
     }
-    else if (type=='load') {
-        var data = core.getLocalStorage(id=='autoSave'?id:"save"+id, null);
-        if (!core.isset(data)) {
-            core.drawTip("无效的存档");
-            return;
-        }
-        if (data.version != core.firstData.version) {
-            // core.drawTip("存档版本不匹配");
-            if (confirm("存档版本不匹配！\n你想回放此存档的录像吗？\n可以随时停止录像播放以继续游戏。")) {
-                core.dom.startPanel.style.display = 'none';
-                var seed = data.hero.flags.seed;
-                core.resetStatus(core.firstData.hero, data.hard, core.firstData.floorId, null, core.initStatus.maps);
-                core.events.setInitData(data.hard);
-                core.setFlag('seed', seed);
-                core.setFlag('rand', seed);
-                core.changeFloor(core.status.floorId, null, core.firstData.hero.loc, null, function() {
-                    core.startReplay(core.decodeRoute(data.route));
-                }, true);
-            }
-            return;
+    if (data.version != core.firstData.version) {
+        core.myconfirm("存档版本不匹配！\n你想回放此存档的录像吗？\n可以随时停止录像播放以继续游戏。", _replay);
+        return;
+    }
+    core.ui.closePanel();
+    core.loadData(data, function() {
+        core.drawTip("读档成功");
+        if (id!="autoSave") {
+            core.saves.saveIndex=id;
+            core.setLocalStorage('saveIndex', core.saves.saveIndex);
         }
+    });
+}
+
+control.prototype._doSL_replayLoad_afterGet = function (id, data) {
+    if (!data) return core.drawTip("无效的存档");
+    if (data.version != core.firstData.version) return core.drawTip("存档版本不匹配");
+    if (data.hard != core.status.hard) core.drawTip("游戏难度不匹配！");
+    if (data.hashCode != null && data.hashCode != core.utils.hashCode(data.hero))
+        return alert("存档校验失败，请勿修改存档文件！");
+    var route = core.subarray(core.status.route, core.decodeRoute(data.route));
+    if (route == null || data.hero.flags.__seed__ != core.getFlag('__seed__'))
+        return core.drawTip("无法从此存档回放录像");
+    core.loadData(data, function () {
+        core.startReplay(route);
+        core.drawTip("回退到存档节点");
+    });
+
+}
+
+control.prototype._doSL_replayRemain_afterGet = function (id, data) {
+    if (!data) return core.drawTip("无效的存档");
+
+    var route = core.decodeRoute(data.route);
+    if (core.status.tempRoute) {
+        var remainRoute = core.subarray(route, core.status.tempRoute);
+        if (remainRoute == null)
+            return alert("无法接续播放录像！\n该存档必须是前一个选择的存档的后续内容。");
+        delete core.status.tempRoute;
         core.ui.closePanel();
-        core.loadData(data, function() {
-            core.drawTip("读档成功");
-            if (id!="autoSave") {
-                core.status.saveIndex=id;
-                core.setLocalStorage('saveIndex2', core.status.saveIndex);
-            }
-        });
+        core.startReplay(remainRoute);
+        core.drawTip("接续播放录像");
         return;
     }
-    else if (type == 'replayLoad') {
-        var data = core.getLocalStorage(id=='autoSave'?id:"save"+id, null);
-        if (!core.isset(data)) {
-            core.drawTip("无效的存档");
-            return;
-        }
-        if (data.version != core.firstData.version) {
-            core.drawTip("存档版本不匹配");
-            return;
-        }
-        if (data.hard != core.status.hard) {
-            core.drawTip("游戏难度不匹配！");
-            return;
-        }
-        var route = core.subarray(core.status.route, core.decodeRoute(data.route));
-        if (!core.isset(route) || data.hero.flags.seed!=core.getFlag('seed')) {
-            core.drawTip("无法从此存档回放录像");
-            return;
-        }
-        core.loadData(data, function () {
-            core.startReplay(route);
-            core.drawTip("回退到存档节点");
-        });
-    }
+    else if (data.floorId != core.status.floorId || data.hero.loc.x != core.getHeroLoc('x') || data.hero.loc.y != core.getHeroLoc('y'))
+        return alert("楼层或坐标不一致！");
+
+    core.status.tempRoute = route;
+    core.ui.closePanel();
+    core.drawText("\t[步骤2]请选择第二个存档。\n\r[yellow]该存档必须是前一个存档的后续。\r\n将尝试播放到此存档。", function () {
+        core.status.event.id = 'replayRemain';
+        core.lockControl();
+        var saveIndex = core.saves.saveIndex;
+        var page = parseInt((saveIndex - 1) / 5), offset = saveIndex - 5 * page;
+        core.ui.drawSLPanel(10 * page + offset);
+    });
 }
 
 ////// 同步存档到服务器 //////
 control.prototype.syncSave = function (type) {
-    var saves=null;
-    // data
-    if (type=='all') {
-        saves=[];
-        for (var i=1;i<=5*(main.savePages||30);i++) {
-            var data = core.getLocalStorage("save"+i, null);
-            if (core.isset(data)) {
-                saves.push(data);
-            }
-        }
-    }
-    else {
-        saves=core.getLocalStorage("save"+core.status.saveIndex, null);
-    }
-    if (!core.isset(saves)) {
-        core.drawText("没有要同步的存档");
-        return;
-    }
     core.ui.drawWaiting("正在同步，请稍后...");
+    var callback = function (saves) {
+        core.control._syncSave_http(type, saves);
+    }
+    if (type == 'all') core.getAllSaves(callback);
+    else core.getSave(core.saves.saveIndex, callback);
+}
 
+control.prototype._syncSave_http = function (type, saves) {
+    if (!saves) return core.drawText("没有要同步的存档");
     var formData = new FormData();
     formData.append('type', 'save');
     formData.append('name', core.firstData.name);
-    var save_text = JSON.stringify(saves);
-    formData.append('data', save_text);
+    formData.append('data', JSON.stringify(saves));
 
     core.http("POST", "/games/sync.php", formData, function (data) {
         var response = JSON.parse(data);
@@ -2296,9 +1657,9 @@ control.prototype.syncSave = function (type) {
             core.drawText("出错啦！\n无法同步存档到服务器。\n错误原因："+response.msg);
         }
         else {
-            core.drawText((type=='all'?"所有存档":"存档"+core.status.saveIndex)+"同步成功！\n\n您的存档编号： "
+            core.drawText((type=='all'?"所有存档":"存档"+core.saves.saveIndex)+"同步成功！\n\n您的存档编号： "
                 +response.code+"\n您的存档密码： "+response.msg
-                +"\n\n请牢记以上两个信息（如截图等），在从服务器\n同步存档时使用。")
+                +"\n\n请牢记以上两个信息（如截图等），在从服务器\n同步存档时使用。\n\r[yellow]另外请注意，存档同步只会保存一个月的时间。\r")
         }
     }, function (e) {
         core.drawText("出错啦！\n无法同步存档到服务器。\n错误原因："+e);
@@ -2307,18 +1668,17 @@ control.prototype.syncSave = function (type) {
 
 ////// 从服务器加载存档 //////
 control.prototype.syncLoad = function () {
-    core.interval.onDownInterval = 'tmp';
-    var id = prompt("请输入存档编号：");
-    if (id==null || id=="") {
-        core.ui.drawSyncSave(); return;
-    }
-    core.interval.onDownInterval = 'tmp';
-    var password = prompt("请输入存档密码：");
-    if (password==null || password=="") {
-        core.ui.drawSyncSave(); return;
-    }
-    core.ui.drawWaiting("正在同步，请稍后...");
+    core.myprompt("请输入存档编号", null, function (id) {
+        if (!id) return core.ui.drawSyncSave();
+        core.myprompt("请输入存档密码：", null, function (password) {
+            if (!password) return core.ui.drawSyncSave();
+            core.ui.drawWaiting("正在同步，请稍后...");
+            core.control._syncLoad_http(id, password);
+        });
+    });
+}
 
+control.prototype._syncLoad_http = function (id, password) {
     var formData = new FormData();
     formData.append('type', 'load');
     formData.append('name', core.firstData.name);
@@ -2327,146 +1687,286 @@ control.prototype.syncLoad = function () {
 
     core.http("POST", "/games/sync.php", formData, function (data) {
         var response = JSON.parse(data);
-        switch (response.code) {
-            case 0:
-                // 成功
-                var data=JSON.parse(response.msg);
-                // console.log(data);
-
-                if (data instanceof Array) {
-                    core.status.event.selection=1;
-                    core.ui.drawConfirmBox("所有本地存档都将被覆盖，确认？", function () {
-                        for (var i=1;i<=5*(main.savePages||30);i++) {
-                            if (i<=data.length) {
-                                core.setLocalStorage("save"+i, data[i-1]);
-                            }
-                            else {
-                                core.removeLocalStorage("save"+i);
-                            }
-                        }
-                        core.drawText("同步成功！\n你的本地所有存档均已被覆盖。");
-                    }, function () {
-                        core.status.event.selection=0;
-                        core.ui.drawSyncSave();
-                    })
-                }
-                else {
-                    // 只覆盖单存档
-                    core.setLocalStorage("save"+core.status.saveIndex, data);
-                    core.drawText("同步成功！\n单存档已覆盖至存档"+core.status.saveIndex);
-                }
-                break;
-            case -1:
-                core.drawText("出错啦！\n存档编号"+id+"不存在！");
-                break;
-            case -2:
-                core.drawText("出错啦！\n存档密码错误！");
-                break;
-            default:
-                core.drawText("出错啦！\n无法从服务器同步存档。\n错误原因："+response.msg);
-                break;
+        if (response.code == 0) {
+            core.control._syncLoad_write(JSON.parse(response.msg));
+        }
+        else {
+            core.drawText("出错啦！\n无法从服务器同步存档。\n错误原因："+response.msg);
         }
     }, function (e) {
         core.drawText("出错啦！\n无法从服务器同步存档。\n错误原因："+e);
     });
 }
 
+control.prototype._syncLoad_write = function (data) {
+    if (data instanceof Array) {
+        core.status.event.selection=1;
+        core.ui.drawConfirmBox("所有本地存档都将被覆盖，确认？", function () {
+            for (var i=1;i<=5*(main.savePages||30);i++) {
+                if (i<=data.length)
+                    core.setLocalForage("save"+i, data[i-1]);
+                else if (core.saves.ids[i])
+                    core.removeLocalForage("save"+i);
+            }
+            core.ui.closePanel();
+            core.drawText("同步成功！\n你的本地所有存档均已被覆盖。");
+        }, function () {
+            core.status.event.selection=0;
+            core.ui.drawSyncSave();
+        });
+    }
+    else {
+        // 只覆盖单存档
+        core.setLocalForage("save"+core.saves.saveIndex, data, function() {
+            core.drawText("同步成功！\n单存档已覆盖至存档"+core.saves.saveIndex);
+        });
+    }
+}
+
 ////// 存档到本地 //////
 control.prototype.saveData = function() {
-    var data = {
-        'floorId': core.status.floorId,
-        'hero': core.clone(core.status.hero),
-        'hard': core.status.hard,
-        'maps': core.maps.save(core.status.maps),
-        'route': core.encodeRoute(core.status.route),
-        'values': core.clone(core.values),
-        'shops': {},
-        'version': core.firstData.version,
-        "time": new Date().getTime()
-    };
-    // set shop times
-    for (var shop in core.status.shops) {
-        data.shops[shop]={
-            'times': core.status.shops[shop].times || 0,
-            'visited': core.status.shops[shop].visited || false
-        }
-    }
-    core.events.beforeSaveData(data);
-
-    return data;
+    return this.controldata.saveData();
 }
 
 ////// 从本地读档 //////
 control.prototype.loadData = function (data, callback) {
-
-    core.resetStatus(data.hero, data.hard, data.floorId, core.decodeRoute(data.route), core.maps.load(data.maps),
-        data.values);
-
-    // load shop times
-    for (var shop in core.status.shops) {
-        if (core.isset(data.shops[shop])) {
-            core.status.shops[shop].times = data.shops[shop].times;
-            core.status.shops[shop].visited = data.shops[shop].visited;
-        }
-    }
-
-    // load icons
-    var icon = core.getFlag("heroIcon", "hero.png");
-    if (core.isset(core.material.images.images[icon])) {
-        core.material.images.hero.src = core.material.images.images[icon].src;
-        core.material.icons.hero.height = core.material.images.images[icon].height/4;
-    }
-
-    core.events.afterLoadData(data);
-
-    core.changeFloor(data.floorId, null, data.hero.loc, 0, function() {
-        if (core.isset(callback)) callback();
-    }, true);
+    return this.controldata.loadData(data, callback);
 }
 
+control.prototype.getSave = function (index, callback) {
+    if (index == 0) {
+        // --- 自动存档先从缓存中获取
+        if (core.saves.autosave.data != null)
+            callback(core.clone(core.saves.autosave.data));
+        else {
+            core.getLocalForage("autoSave", null, function(data) {
+                callback(data);
+            }, function(err) {
+                main.log(err);
+                callback(null);
+            });
+        }
+        return;
+    }
+    core.getLocalForage("save"+index, null, function(data) {
+        if (callback) callback(data);
+    }, function(err) {
+        main.log(err);
+        if (callback) callback(null);
+    });
+}
+
+control.prototype.getSaves = function (ids, callback) {
+    if (!(ids instanceof Array)) return this.getSave(ids, callback);
+    var count = ids.length, data = {};
+    for (var i = 0; i < ids.length; ++i) {
+        (function (i) {
+            core.getSave(ids[i], function (result) {
+                data[i] = result;
+                if (Object.keys(data).length == count)
+                    callback(data);
+            })
+        })(i);
+    }
+}
+
+control.prototype.getAllSaves = function (callback) {
+    var ids = Object.keys(core.saves.ids).filter(function(x){return x!=0;})
+        .sort(function(a,b) {return a-b;}), saves = [];
+    this.getSaves(ids, function (data) {
+        for (var i = 0; i < ids.length; ++i) {
+            if (data[i] != null)
+                saves.push(data[i]);
+        }
+        callback(saves);
+    });
+}
+
+////// 获得所有存在存档的存档位 //////
+control.prototype.getSaveIndexes = function (callback) {
+    var indexes = {};
+    if (core.platform.useLocalForage) {
+        localforage.iterate(function (value, key, n) {
+            core.control._getSaveIndexes_getIndex(indexes, key);
+        }, function () {
+            callback(indexes);
+        });
+    }
+    else {
+        Object.keys(localStorage).forEach(function (key) {
+            core.control._getSaveIndexes_getIndex(indexes, key);
+        });
+        callback(indexes);
+    }
+}
+
+control.prototype._getSaveIndexes_getIndex = function (indexes, name) {
+    var e = new RegExp('^'+core.firstData.name+"_(save\\d+|autoSave)$").exec(name);
+    if (e) {
+        if (e[1]=='autoSave') indexes[0]=true;
+        else indexes[parseInt(e[1].substring(4))] = true;
+    }
+}
+
+////// 判断某个存档位是否存在存档 //////
+control.prototype.hasSave = function (index) {
+    return core.saves.ids[index] || false;
+}
+
+////// 删除某个存档
+control.prototype.removeSave = function (index, callback) {
+    if (index == 0 || index == "autoSave") {
+        index = "autoSave";
+        core.removeLocalForage(index, function () {
+            core.saves.autosave.data = null;
+            core.saves.autosave.updated = false;
+            if (callback) callback();
+        });
+        return;
+    }
+    core.removeLocalForage("save" + index, function () {
+        core.saves.favorite = core.saves.favorite.filter(function (i) { return core.hasSave(i); });
+        delete core.saves.favoriteName[index];
+        core.control._updateFavoriteSaves();
+        if (callback) callback();
+    }, function () {
+        core.drawTip("无法删除存档！");
+        if (callback) callback();
+    });
+}
+
+////// 读取收藏信息
+control.prototype._loadFavoriteSaves = function () {
+    core.saves.favorite = core.getLocalStorage("favorite", []);
+    // --- 移除不存在的收藏
+    core.saves.favorite = core.saves.favorite.filter(function (i) { return core.hasSave(i); });
+    core.saves.favoriteName = core.getLocalStorage("favoriteName", {});
+}
+
+control.prototype._updateFavoriteSaves = function () {
+    core.setLocalStorage("favorite", core.saves.favorite);
+    core.setLocalStorage("favoriteName", core.saves.favoriteName);
+}
+
+// ------ 属性，状态，位置，buff，变量，锁定控制等 ------ //
+
 ////// 设置勇士属性 //////
-control.prototype.setStatus = function (statusName, statusVal) {
-    if (statusName == 'exp') statusName = 'experience';
-    if (core.isset(core.status.hero.loc[statusName]))
-        core.status.hero.loc[statusName] = statusVal;
+control.prototype.setStatus = function (name, value) {
+    if (!core.status.hero) return;
+    if (name == 'exp') name = 'experience';
+    if (name == 'x' || name == 'y' || name == 'direction')
+        this.setHeroLoc(name, value);
     else
-        core.status.hero[statusName] = statusVal;
+        core.status.hero[name] = value;
+}
+
+////// 增减勇士属性 //////
+control.prototype.addStatus = function (name, value) {
+    this.setStatus(name, this.getStatus(name) + value);
 }
 
 ////// 获得勇士属性 //////
-control.prototype.getStatus = function (statusName) {
-    // support status:x
-    if (core.isset(core.status.hero.loc[statusName]))
-        return core.status.hero.loc[statusName];
-    if (statusName == 'exp') statusName = 'experience';
-    return core.status.hero[statusName];
+control.prototype.getStatus = function (name) {
+    if (!core.status.hero) return null;
+    if (name == 'x' || name == 'y' || name == 'direction')
+        return this.getHeroLoc(name);
+    if (name == 'exp') name = 'experience';
+    return core.status.hero[name];
+}
+
+////// 从status中获得属性，如果不存在则从勇士属性中获取 //////
+control.prototype.getStatusOrDefault = function (status, name) {
+    if (status && name in status)
+        return Math.floor(status[name]);
+    return Math.floor(this.getStatus(name));
+}
+
+////// 获得勇士实际属性（增幅后的） //////
+control.prototype.getRealStatus = function (name) {
+    return this.getRealStatusOrDefault(null, name);
+}
+
+////// 从status中获得实际属性（增幅后的），如果不存在则从勇士属性中获取 //////
+control.prototype.getRealStatusOrDefault = function (status, name) {
+    return Math.floor(this.getStatusOrDefault(status, name) * this.getBuff(name));
+}
+
+////// 设置某个属性的增幅值 //////
+control.prototype.setBuff = function (name, value) {
+    this.setFlag('__'+name+'_buff__', value);
+}
+
+////// 加减某个属性的增幅值 //////
+control.prototype.addBuff = function (name, value) {
+    this.setFlag('__'+name+'_buff__', this.getBuff(name) + value);
+}
+
+////// 获得某个属性的增幅值 //////
+control.prototype.getBuff = function (name) {
+    return core.getFlag('__'+name+'_buff__', 1);
+}
+
+////// 设置勇士的位置 //////
+control.prototype.setHeroLoc = function (name, value, noGather) {
+    if (!core.status.hero) return;
+    core.status.hero.loc[name] = value;
+    if ((name=='x' || name=='y') && !noGather) {
+        this.gatherFollowers();
+    }
+}
+
+////// 获得勇士的位置 //////
+control.prototype.getHeroLoc = function (name) {
+    if (!core.status.hero) return;
+    if (name == null) return core.status.hero.loc;
+    return core.status.hero.loc[name];
+}
+
+////// 获得某个属性的中文名 //////
+control.prototype.getStatusName = function (name) {
+    var map = {
+        name: "名称", lv: "等级", hpmax: "生命上限", hp: "生命", manamax: "魔力上限", mana: "魔力",
+        atk: "攻击", def: "防御", mdef: "魔防", money: "金币", exp: "经验", experience: "经验", steps: "步数"
+    };
+    return map[name] || name;
 }
 
 ////// 获得某个等级的名称 //////
-control.prototype.getLvName = function () {
-    if (!core.isset(core.firstData.levelUp) || core.status.hero.lv<=0
-        || core.status.hero.lv>core.firstData.levelUp.length) return core.status.hero.lv;
-    return core.firstData.levelUp[core.status.hero.lv-1].name || core.status.hero.lv;
+control.prototype.getLvName = function (lv) {
+    if (!core.status.hero) return null;
+    if (lv == null) lv = core.status.hero.lv;
+    return ((core.firstData.levelUp||[])[lv-1]||{}).title || lv;
 }
 
 ////// 设置某个自定义变量或flag //////
-control.prototype.setFlag = function(flag, value) {
-    if (!core.isset(core.status.hero)) return;
-    core.status.hero.flags[flag]=value;
+control.prototype.setFlag = function(name, value) {
+    if (value == null) return this.removeFlag(name);
+    if (!core.status.hero) return;
+    core.status.hero.flags[name]=value;
+}
+
+////// 增加某个flag数值 //////
+control.prototype.addFlag = function(name, value) {
+    if (!core.status.hero) return;
+    core.setFlag(name, core.getFlag(name, 0) + value);
 }
 
 ////// 获得某个自定义变量或flag //////
-control.prototype.getFlag = function(flag, defaultValue) {
-    if (!core.isset(core.status.hero)) return defaultValue;
-    var value = core.status.hero.flags[flag];
-    if (core.isset(value)) return value;
-    return defaultValue;
+control.prototype.getFlag = function(name, defaultValue) {
+    if (!core.status.hero) return defaultValue;
+    var value = core.status.hero.flags[name];
+    return value != null ? value : defaultValue;
 }
 
 ////// 是否存在某个自定义变量或flag，且值为true //////
-control.prototype.hasFlag = function(flag) {
-    if (core.getFlag(flag)) return true;
-    return false;
+control.prototype.hasFlag = function(name) {
+    return !!core.getFlag(name);
+}
+
+////// 删除某个自定义变量或flag //////
+control.prototype.removeFlag = function(name) {
+    if (!core.status.hero) return;
+    delete core.status.hero.flags[name];
 }
 
 ////// 锁定状态栏，常常用于事件处理 //////
@@ -2479,625 +1979,743 @@ control.prototype.unLockControl = function () {
     core.status.lockControl = false;
 }
 
-////// 播放背景音乐 //////
-control.prototype.playBgm = function (bgm) {
-    if (main.mode!='play')return;
-    // 如果不允许播放
-    if (!core.musicStatus.bgmStatus) return;
-    // 音频不存在
-    if (!core.isset(core.material.bgms[bgm])) return;
+////// 开启debug模式 //////
+control.prototype.debug = function() {
+    core.setFlag('debug', true);
+    core.drawText("\t[调试模式开启]此模式下按住Ctrl键（或Ctrl+Shift键）可以穿墙并忽略一切事件。\n同时，录像将失效，也无法上传成绩。");
+}
 
-    // 延迟播放
-    if (core.material.bgms[bgm] == 'loading') {
-        core.material.bgms[bgm] = 'starting';
+// ------ 天气，色调，BGM ------ //
+
+control.prototype.getMappedName = function (name) {
+    return (main.nameMap || {})[name] || name;
+}
+
+////// 更改天气效果 //////
+control.prototype.setWeather = function (type, level) {
+    // 非雨雪
+    if (type == null) {
+        core.deleteCanvas('weather')
+        core.animateFrame.weather.type = null;
+        core.animateFrame.weather.nodes = [];
+        return;
+    }
+    // 当前天气：则忽略
+    if (type==core.animateFrame.weather.type && level == null) return;
+    level = core.clamp(parseInt(level) || 5, 1, 10);
+    level *= parseInt(20*core.bigmap.width*core.bigmap.height/(core.__SIZE__*core.__SIZE__));
+
+    // 计算当前的宽高
+    core.createCanvas('weather', 0, 0, core.__PIXELS__, core.__PIXELS__, 80);
+    core.animateFrame.weather.type = type;
+    core.animateFrame.weather.nodes = [];
+    this._setWeather_createNodes(type, level);
+}
+
+control.prototype._setWeather_createNodes = function (type, level) {
+    switch (type) {
+        case 'rain':
+            for (var a=0;a<level;a++) {
+                core.animateFrame.weather.nodes.push({
+                    'x': Math.random()*core.bigmap.width*32,
+                    'y': Math.random()*core.bigmap.height*32,
+                    'l': Math.random() * 2.5,
+                    'xs': -4 + Math.random() * 4 + 2,
+                    'ys': Math.random() * 10 + 10
+                })
+            }
+            break;
+        case 'snow':
+            for (var a=0;a<level;a++) {
+                core.animateFrame.weather.nodes.push({
+                    'x': Math.random()*core.bigmap.width*32,
+                    'y': Math.random()*core.bigmap.height*32,
+                    'r': Math.random() * 5 + 1,
+                    'd': Math.random() * Math.min(level, 200),
+                })
+            }
+            break;
+        case 'fog':
+            if (core.animateFrame.weather.fog) {
+                for (var a=0;a<level/10;a++) {
+                    core.animateFrame.weather.nodes.push({
+                        'x': Math.random()*core.bigmap.width*32 - 208,
+                        'y': Math.random()*core.bigmap.height*32 - 208,
+                        'xs': Math.random() * 4 - 2,
+                        'ys': Math.random() * 4 - 2
+                    })
+                }
+            }
+            break;
+    }
+}
+
+////// 更改画面色调 //////
+control.prototype.setCurtain = function(color, time, callback) {
+    if (time == null) time=750;
+    if (time<=0) time=0;
+    if (!core.status.curtainColor)
+        core.status.curtainColor = [0,0,0,0];
+    if (!color) color = [0,0,0,0];
+    if (color[3] == null) color[3] = 1;
+    color[3] = core.clamp(color[3],0,1);
+
+    if (time==0) {
+        // 直接变色
+        core.clearMap('curtain');
+        core.fillRect('curtain', 0, 0, core.__PIXELS__, core.__PIXELS__, core.arrayToRGBA(color));
+        core.status.curtainColor = color;
+        if (callback) callback();
         return;
     }
 
+    this._setCurtain_animate(core.status.curtainColor, color, time, callback);
+}
+
+control.prototype._setCurtain_animate = function (nowColor, color, time, callback) {
+    time /= Math.max(core.status.replay.speed, 1)
+    var per_time = 10, step = parseInt(time / per_time);
+    var animate = setInterval(function() {
+        nowColor = [
+            (nowColor[0]*(step-1)+color[0])/step,
+            (nowColor[1]*(step-1)+color[1])/step,
+            (nowColor[2]*(step-1)+color[2])/step,
+            (nowColor[3]*(step-1)+color[3])/step,
+        ];
+        core.clearMap('curtain');
+        core.fillRect('curtain', 0, 0, core.__PIXELS__, core.__PIXELS__, core.arrayToRGBA(nowColor));
+        step--;
+        if (step <= 0) {
+            delete core.animateFrame.asyncId[animate];
+            clearInterval(animate);
+            core.status.curtainColor = color;
+            if (core.isset(callback)) callback();
+        }
+    }, per_time);
+
+    core.animateFrame.asyncId[animate] = true;
+}
+
+////// 画面闪烁 //////
+control.prototype.screenFlash = function (color, time, times, callback) {
+    times = times || 1;
+    time = time / 3;
+    var nowColor = core.clone(core.status.curtainColor);
+    core.setCurtain(color, time, function() {
+        core.setCurtain(nowColor, time * 2, function() {
+            if (times > 1)
+                core.screenFlash(color, time * 3, times - 1, callback);
+            else {
+                if (callback) callback();
+            }
+        });
+    });
+}
+
+////// 播放背景音乐 //////
+control.prototype.playBgm = function (bgm, startTime) {
+    bgm = core.getMappedName(bgm);
+    if (main.mode!='play' || !core.material.bgms[bgm]) return;
+    // 如果不允许播放
+    if (!core.musicStatus.bgmStatus) {
+        try {
+            core.musicStatus.playingBgm = bgm;
+            core.musicStatus.lastBgm = bgm;
+            core.material.bgms[bgm].pause();
+        }
+        catch (e) {
+            main.log(e);
+        }
+        return;
+    }
+    this.setMusicBtn();
+
     try {
-        // 如果当前正在播放，且和本BGM相同，直接忽略
-        if (core.musicStatus.playingBgm == bgm && core.musicStatus.isPlaying) {
-            return;
-        }
-        // 如果正在播放中，暂停
-        if (core.isset(core.musicStatus.playingBgm) && core.musicStatus.isPlaying) {
-            core.material.bgms[core.musicStatus.playingBgm].pause();
-        }
-        // 播放当前BGM
-        core.material.bgms[bgm].volume = core.musicStatus.volume;
-        core.material.bgms[bgm].play();
-        core.musicStatus.playingBgm = bgm;
-        core.musicStatus.isPlaying = true;
+        this._playBgm_play(bgm, startTime);
     }
     catch (e) {
         console.log("无法播放BGM "+bgm);
-        console.log(e);
+        main.log(e);
         core.musicStatus.playingBgm = null;
     }
 }
 
+control.prototype._playBgm_play = function (bgm, startTime) {
+    // 如果当前正在播放，且和本BGM相同，直接忽略
+    if (core.musicStatus.playingBgm == bgm && !core.material.bgms[core.musicStatus.playingBgm].paused) {
+        return;
+    }
+    // 如果正在播放中，暂停
+    if (core.musicStatus.playingBgm) {
+        core.material.bgms[core.musicStatus.playingBgm].pause();
+    }
+    // 缓存BGM
+    core.loader.loadBgm(bgm);
+    // 播放当前BGM
+    core.material.bgms[bgm].volume = core.musicStatus.volume;
+    core.material.bgms[bgm].currentTime = startTime || 0;
+    core.material.bgms[bgm].play();
+    core.musicStatus.playingBgm = bgm;
+    core.musicStatus.lastBgm = bgm;
+}
+
 ////// 暂停背景音乐的播放 //////
 control.prototype.pauseBgm = function () {
-    // 直接暂停播放
+    if (main.mode!='play')return;
     try {
-        if (core.isset(core.musicStatus.playingBgm)) {
+        if (core.musicStatus.playingBgm) {
             core.material.bgms[core.musicStatus.playingBgm].pause();
+            core.musicStatus.playingBgm = null;
         }
-        core.musicStatus.isPlaying = false;
     }
     catch (e) {
-        console.log("无法暂停BGM "+bgm);
-        console.log(e);
+        console.log("无法暂停BGM");
+        main.log(e);
     }
+    this.setMusicBtn();
 }
 
 ////// 恢复背景音乐的播放 //////
 control.prototype.resumeBgm = function () {
     if (main.mode!='play')return;
-    // 如果不允许播放
-    if (!core.musicStatus.bgmStatus) return;
-
-    // 恢复BGM
     try {
-        if (core.isset(core.musicStatus.playingBgm)) {
-            core.material.bgms[core.musicStatus.playingBgm].play();
-            core.musicStatus.isPlaying = true;
-        }
-        else {
-            if (core.bgms.length>0) {
-                if (core.isset(core.floors[core.status.floorId].bgm)) {
-                    core.playBgm(core.floors[core.status.floorId].bgm);
-                }
-                else
-                    core.playBgm(core.bgms[0]);
-                core.musicStatus.isPlaying = true;
-            }
-        }
+        core.playBgm(core.musicStatus.playingBgm || core.musicStatus.lastBgm || main.startBgm);
     }
     catch (e) {
-        console.log("无法恢复BGM "+bgm);
-        console.log(e);
+        console.log("无法恢复BGM");
+        main.log(e);
     }
+    this.setMusicBtn();
+}
+
+control.prototype.setMusicBtn = function () {
+    if (core.musicStatus.bgmStatus)
+        core.dom.musicBtn.src = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABkAAAAZCAMAAADzN3VRAAABWVBMVEX///9iYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmL///8AAAC5ubn+/v6xsbEtLS0MDAxmZmZoaGhvb2/c3Nzd3d38/Pz9/f0oKCgpKSl0dHR1dXW6urrb29v7+/v09PTv7+/39/cgICACAgImJibh4eGFhYWGhoaHh4eOjo5paWm7u7vDw8PMzMwyMjI7OztAQEDe3t5FRUVMTEzj4+Pl5eXm5ubp6enr6+tcXFzi4uL19fVeXl74+PgjIyNkZGQGBgaSkpKYmJiampqenp4DAwMwMDBnZ2cICAivr68eHh63t7cLCwsSEhLw8PBhYWEUFBQVFRXNzc3Pz8/Z2dna2toaGhqkpKSlpaWpqamrq6tFOUNAAAAAc3RSTlMAAwQFBhUWGxwkJSYyO0dISVBRUmpvj5CSk5SVoaOlpqiysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKyA0IuUgAAAVdJREFUeF5NkVVbw0AQRTcQrLR4IIEGcidJoaUuQHF3d3d3+P/CkuxCzss8nG++mbnDBJXhNt2CpbeFK1kQpSEKidlc8S9qdATRa6UIdQMoxEpDA0Ov3wUAPfW+qLWACydNv9zMrzkJwPK6FB3oHyOfXfuNxvoBQ+GmBYinhHB77TmiVBxoYUw1AYcEq332AS8OYKosAuTT0nza9uU2USYPRJgGxEiSOFywJ3mNARozgBJJzkfLvfu8JgGDWcC9FEsjWzR+y80gYDEAA8QZ3N6kmP1Fs3fEASB7pob7Hh+Wz5L0ci17Or05J7bH6B6dZv05XWK3rG+myV05Ert592Qo55sPuoIr7hEZHHtieIPWy0RU9DLwc3Mnck/vi8/E8XNrDWQtEVnL/ySKMrv0jPwPp870fprcyYifmiEmqGpHkI5q9ofSFIUk2qiwIGpEMyxYhhZRRcMPz89RJ2s9W8wAAAAASUVORK5CYII=";
+    else
+        core.dom.musicBtn.src = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABkAAAAZCAMAAADzN3VRAAABYlBMVEX///9iYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmL////8/PwAAABmZmZoaGihoaGioqKxsbG5ubnb29vc3Nzd3d3h4eHi4uL9/f3+/v4tLS1nZ2d0dHSUlJSenp66uroMDAz7+/spKSkoKCgUFBRpaWkVFRVvb291dXU7OzuVlZWYmJhkZGQgICAjIyOkpKQCAgK3t7cGBgbv7++pqamrq6seHh4mJiZhYWGamprp6enr6+saGhpeXl7j4+Pl5eXm5uZKSkrw8PD09PT19fW7u7vDw8PMzMwICAgwMDAyMjILCwtAQECGhoaHh4eBgYGFhYUSEhJXV1dZWVlcXFyOjo6SkpLNzc339/fPz8/Z2dna2tqTk5OlpaWxOPeTAAAAdnRSTlMAAwQFBhUWGxwkJSYyO0dISVBRUmpvj5CSk5SVoaOlpqiysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKyNuo+uwAAAWJJREFUeF5NkmV34zAQReUm7WbTuJBNunY3bvXGDjNTkZkZlpn5/9eR5FPfbzr3jGb0RkwRiMQMDm7EIgHmRxtLwMOaHHoQjwz4MUKeCM8AWMrmd7u7f/aXAMyOShHiQD1n04DtN5e5FMBFlSauIsm585dKi4CpuSYKJIv1tBDVmvOSqJgEoowFLSBHaQh10XHWiCgHWEGmAw2blPrvOK/KRJUGoLM4kCVSKrWz7HwgoiwQZyaQJ0+9PvxV23BNATAZB25IqX9b3+jTW9fcApwB6NLgUD5NY3mPXnwmFwBezff1ztzRFzTp94FXMy36HDuCa2RafdnnmZqtL818Gl9/qNnEeyrUk2aTPiKj3qMyWBVi/YSuWq5qiwxkbtX3vYWzdz/l8M0k8ERlvViiB1Ygslb7SbVtJezncj+Cx5bYaeGuonZqhZlieAp+no74/s5EAh6JcY35Cepxk4ObcT3IJPe/1lKsDpFCFQAAAABJRU5ErkJggg==";
+}
+
+////// 更改背景音乐的播放 //////
+control.prototype.triggerBgm = function () {
+    if (main.mode!='play') return;
+
+    core.musicStatus.bgmStatus = !core.musicStatus.bgmStatus;
+    if (core.musicStatus.bgmStatus)
+        this.resumeBgm();
+    else
+        this.pauseBgm();
+    core.setLocalStorage('bgmStatus', core.musicStatus.bgmStatus);
 }
 
 ////// 播放音频 //////
 control.prototype.playSound = function (sound) {
-    if (main.mode!='play')return;
-    // 如果不允许播放
-    if (!core.musicStatus.soundStatus) return;
-    // 音频不存在
-    if (!core.isset(core.material.sounds[sound])) return;
-
+    sound = core.getMappedName(sound);
+    if (main.mode!='play' || !core.musicStatus.soundStatus || !core.material.sounds[sound]) return;
     try {
         if (core.musicStatus.audioContext != null) {
             var source = core.musicStatus.audioContext.createBufferSource();
             source.buffer = core.material.sounds[sound];
             source.connect(core.musicStatus.gainNode);
-            try {
-                source.start(0);
-            }
-            catch (e) {
-                try {
-                    source.noteOn(0);
-                }
-                catch (ee) {
-                }
+            var id = setTimeout(null);
+            source.onended = function () {
+                delete core.musicStatus.playingSounds[id];
             }
+            if (source.start) source.start(0);
+            else if (source.noteOn) source.noteOn(0);
+            core.musicStatus.playingSounds[id] = source;
         }
         else {
             core.material.sounds[sound].volume = core.musicStatus.volume;
             core.material.sounds[sound].play();
         }
     }
-    catch (eee) {
+    catch (e) {
         console.log("无法播放SE "+sound);
-        console.log(eee);
+        main.log(e);
     }
 }
 
+////// 停止所有音频 //////
+control.prototype.stopSound = function () {
+    for (var i in core.musicStatus.playingSounds) {
+        var source = core.musicStatus.playingSounds[i];
+        try {
+            if (source.stop) source.stop();
+            else if (source.noteOff) source.noteOff();
+        }
+        catch (e) {
+            main.log(e);
+        }
+    }
+    core.musicStatus.playingSounds = {};
+}
+
+////// 检查bgm状态 //////
+control.prototype.checkBgm = function() {
+    core.playBgm(core.musicStatus.playingBgm || main.startBgm);
+}
+
+// ------ 状态栏，工具栏等相关 ------ //
+
 ////// 清空状态栏 //////
 control.prototype.clearStatusBar = function() {
-    var statusList = ['floor', 'lv', 'hpmax', 'hp', 'atk', 'def', 'mdef', 'money', 'experience',
-        'up', 'yellowKey', 'blueKey', 'redKey', 'poison', 'weak', 'curse', 'hard'];
-    statusList.forEach(function (e) {
-        core.statusBar[e].innerHTML = "&nbsp;";
-    });
+    Object.keys(core.statusBar).forEach(function (e) {
+        if (core.statusBar[e].innerHTML != null)
+            core.statusBar[e].innerHTML = "&nbsp;";
+    })
     core.statusBar.image.book.style.opacity = 0.3;
-    core.statusBar.image.fly.style.opacity = 0.3;
+    if (!core.flags.equipboxButton)
+        core.statusBar.image.fly.style.opacity = 0.3;
 }
 
 ////// 更新状态栏 //////
 control.prototype.updateStatusBar = function () {
+    if (!core.isPlaying()) return;
+    this.controldata.updateStatusBar();
+    this._updateStatusBar_setToolboxIcon();
+}
 
-    // 检查等级
-    core.events.checkLvUp();
-
-    // 检查HP上限
-    if (core.flags.enableHPMax) {
-        core.setStatus('hp', Math.min(core.getStatus('hpmax'), core.getStatus('hp')));
-    }
-
-    // 更新领域、阻击、显伤
-    core.updateCheckBlock();
-
-    var lvName = core.getLvName();
-    core.statusBar.lv.innerHTML = lvName;
-    if (/^[+-]?\d+$/.test(lvName))
-        core.statusBar.lv.style.fontStyle = 'italic';
-    else core.statusBar.lv.style.fontStyle = 'normal';
-
-    var statusList = ['hpmax', 'hp', 'atk', 'def', 'mdef', 'money', 'experience'];
-    statusList.forEach(function (item) {
-        if (core.isset(core.status.hero[item]))
-            core.status.hero[item] = Math.floor(core.status.hero[item]);
-        core.statusBar[item].innerHTML = core.formatBigNumber(core.getStatus(item));
-    });
-
-    // 进阶
-    if (core.flags.enableLevelUp && core.status.hero.lv<core.firstData.levelUp.length) {
-        core.statusBar.up.innerHTML = core.firstData.levelUp[core.status.hero.lv].need || "&nbsp;";
-    }
-    else core.statusBar.up.innerHTML = "&nbsp;";
-
-    var keys = ['yellowKey', 'blueKey', 'redKey'];
-    keys.forEach(function (key) {
-        core.statusBar[key].innerHTML = core.setTwoDigits(core.status.hero.items.keys[key]);
-    })
-    if(core.flags.enableDebuff){
-        core.statusBar.poison.innerHTML = core.hasFlag('poison')?"毒":"";
-        core.statusBar.weak.innerHTML = core.hasFlag('weak')?"衰":"";
-        core.statusBar.curse.innerHTML = core.hasFlag('curse')?"咒":"";
-    }
-    if (core.flags.enablePZF) {
-        core.statusBar.pickaxe.innerHTML = "破"+core.itemCount('pickaxe');
-        core.statusBar.bomb.innerHTML = "炸"+core.itemCount('bomb');
-        core.statusBar.fly.innerHTML = "飞"+core.itemCount('centerFly');
-    }
-
-    core.statusBar.hard.innerHTML = core.status.hard;
-
-    // 回放
-    if (core.status.replay.replaying) {
-        core.statusBar.image.book.src = core.status.replay.pausing?core.statusBar.icons.play.src:core.statusBar.icons.pause.src;
+control.prototype._updateStatusBar_setToolboxIcon = function () {
+    if (core.isReplaying()) {
+        core.statusBar.image.book.src = core.status.replay.pausing ? core.statusBar.icons.play.src : core.statusBar.icons.pause.src;
         core.statusBar.image.book.style.opacity = 1;
-
         core.statusBar.image.fly.src = core.statusBar.icons.stop.src;
         core.statusBar.image.fly.style.opacity = 1;
-
         core.statusBar.image.toolbox.src = core.statusBar.icons.rewind.src;
-
-        core.statusBar.image.shop.src = core.statusBar.icons.book.src;
-
+        core.statusBar.image.keyboard.src = core.statusBar.icons.book.src;
+        core.statusBar.image.shop.src = core.statusBar.icons.floor.src;
         core.statusBar.image.save.src = core.statusBar.icons.speedDown.src;
-
         core.statusBar.image.load.src = core.statusBar.icons.speedUp.src;
-
         core.statusBar.image.settings.src = core.statusBar.icons.save.src;
-
     }
     else {
         core.statusBar.image.book.src = core.statusBar.icons.book.src;
-        core.statusBar.image.book.style.opacity = core.hasItem('book')?1:0.3;
-
-        core.statusBar.image.fly.src = core.statusBar.icons.fly.src;
-        core.statusBar.image.fly.style.opacity = core.hasItem('fly')?1:0.3;
-
+        core.statusBar.image.book.style.opacity = core.hasItem('book') ? 1 : 0.3;
+        if (!core.flags.equipboxButton) {
+            core.statusBar.image.fly.src = core.statusBar.icons.fly.src;
+            core.statusBar.image.fly.style.opacity = core.hasItem('fly') ? 1 : 0.3;
+        }
+        else {
+            core.statusBar.image.fly.src = core.statusBar.icons.equipbox.src;
+            core.statusBar.image.fly.style.opacity = 1;
+        }
         core.statusBar.image.toolbox.src = core.statusBar.icons.toolbox.src;
-
+        core.statusBar.image.keyboard.src = core.statusBar.icons.keyboard.src;
         core.statusBar.image.shop.src = core.statusBar.icons.shop.src;
-
         core.statusBar.image.save.src = core.statusBar.icons.save.src;
-
         core.statusBar.image.load.src = core.statusBar.icons.load.src;
-
         core.statusBar.image.settings.src = core.statusBar.icons.settings.src;
     }
+}
 
-    core.updateFg();
+control.prototype.showStatusBar = function () {
+    if (core.domStyle.showStatusBar) return;
+    var statusItems = core.dom.status;
+    core.domStyle.showStatusBar = true;
+    core.removeFlag('hideStatusBar');
+    // 显示
+    for (var i = 0; i < statusItems.length; ++i)
+        statusItems[i].style.opacity = 1;
+    this.setToolbarButton(false);
+    core.dom.tools.hard.style.display = 'block';
+}
+
+control.prototype.hideStatusBar = function (showToolbox) {
+    // 如果原本就是隐藏的，则先显示
+    if (!core.domStyle.showStatusBar)
+        this.showStatusBar();
+
+    var statusItems = core.dom.status, toolItems = core.dom.tools;
+    core.domStyle.showStatusBar = false;
+    core.setFlag('hideStatusBar', true);
+    core.setFlag('showToolbox', showToolbox || null);
+    // 隐藏
+    for (var i = 0; i < statusItems.length; ++i)
+        statusItems[i].style.opacity = 0;
+    if (!core.domStyle.isVertical || !showToolbox) {
+        for (var i = 0; i < toolItems.length; ++i)
+            toolItems[i].style.display = 'none';
+    }
+}
+
+////// 更新状态栏的勇士图标 //////
+control.prototype.updateHeroIcon = function (name) {
+    name = name || "hero.png";
+    if (core.statusBar.icons.name == name) return;
+    core.statusBar.icons.name = name;
+
+    var image = core.material.images.hero;
+    // 全身图
+    var w = core.material.icons.hero.width || 32;
+    var h = core.material.icons.hero.height || 48;
+    var ratio = Math.max(w / h, 1), width = 32 * ratio, left = 16 - width/2;
+
+    var canvas = document.createElement("canvas");
+    var context = canvas.getContext("2d");
+    canvas.width = 32;
+    canvas.height = 32;
+    context.drawImage(image, 0, 0, w, h, left, 0, width, 32);
+
+    core.statusBar.image.name.src = canvas.toDataURL("image/png");
+}
+
+control.prototype.updateGlobalAttribute = function (name) {
+    if (name == null) name = Object.keys(core.status.globalAttribute);
+    if (name instanceof Array) {
+        name.forEach(function (t) {
+            core.control.updateGlobalAttribute(t);
+        });
+        return;
+    }
+    var attribute = core.status.globalAttribute || core.initStatus.globalAttribute;
+    if (attribute == null) return;
+    switch (name) {
+        case 'statusLeftBackground':
+            if (!core.domStyle.isVertical) {
+                core.dom.statusBar.style.background = attribute[name];
+            }
+            break;
+        case 'statusTopBackground':
+            if (core.domStyle.isVertical) {
+                core.dom.statusBar.style.background = attribute[name];
+            }
+            break;
+        case 'toolsBackground':
+            if (core.domStyle.isVertical) {
+                core.dom.toolBar.style.background = attribute[name];
+            }
+            break;
+        case 'borderColor':
+            {
+                var border = '3px ' + attribute[name] + ' solid';
+                core.dom.statusBar.style.borderTop = border;
+                core.dom.statusBar.style.borderLeft = border;
+                core.dom.statusBar.style.borderRight = core.domStyle.isVertical?border:'';
+                core.dom.statusBar.style.borderBottom = core.domStyle.isVertical?'':border;
+                core.dom.gameDraw.style.border = border;
+                core.dom.toolBar.style.borderLeft = border;
+                core.dom.toolBar.style.borderRight = core.domStyle.isVertical?border:'';
+                core.dom.toolBar.style.borderBottom = core.domStyle.isVertical?border:'';
+                break;
+            }
+        case 'statusBarColor':
+            {
+                var texts = core.dom.statusTexts;
+                for (var i=0;i<texts.length;i++)
+                    texts[i].style.color = attribute[name];
+                break;
+            }
+        case 'hardLabelColor':
+            core.dom.hard.style.color = attribute[name];
+            break;
+        case 'floorChangingBackground':
+            core.dom.floorMsgGroup.style.background = attribute[name];
+            break;
+        case 'floorChangingTextColor':
+            core.dom.floorMsgGroup.style.color = attribute[name];
+            break;
+    }
+}
+
+////// 改变工具栏为按钮1-8 //////
+control.prototype.setToolbarButton = function (useButton) {
+    if (!core.domStyle.showStatusBar) {
+        // 隐藏状态栏时检查竖屏
+        if (!core.domStyle.isVertical) {
+            for (var i = 0; i < core.dom.tools.length; ++i)
+                core.dom.tools[i].style.display = 'none';
+            return;
+        }
+        if (!core.hasFlag('showToolbox')) return;
+        else core.dom.tools.hard.style.display = 'block';
+    }
+
+    if (useButton == null) useButton = core.domStyle.toolbarBtn;
+    if (!core.domStyle.isVertical || !core.platform.extendKeyboard) useButton = false;
+    core.domStyle.toolbarBtn = useButton;
+
+    if (useButton) {
+        ["book","fly","toolbox","keyboard","shop","save","load","settings"].forEach(function (t) {
+            core.statusBar.image[t].style.display = 'none';
+        });
+        ["btn1","btn2","btn3","btn4","btn5","btn6","btn7","btn8"].forEach(function (t) {
+            core.statusBar.image[t].style.display = 'block';
+        })
+    }
+    else {
+        ["btn1","btn2","btn3","btn4","btn5","btn6","btn7","btn8"].forEach(function (t) {
+            core.statusBar.image[t].style.display = 'none';
+        });
+        ["book","fly","toolbox","save","load","settings"].forEach(function (t) {
+            core.statusBar.image[t].style.display = 'block';
+        });
+        core.statusBar.image.keyboard.style.display
+            = core.statusBar.image.shop.style.display
+            = core.domStyle.isVertical ? "block":"none";
+    }
+}
+
+////// ------ resize处理 ------ //
+
+control.prototype._shouldDisplayStatus = function(id) {
+    if (id == null) {
+        var toDraw = [], status = core.dom.status;
+        for (var i = 0; i<status.length; ++i) {
+            var dom = core.dom.status[i], idCol = dom.id;
+            if (idCol.indexOf("Col")!=idCol.length-3) continue;
+            var id = idCol.substring(0, idCol.length-3);
+            if (!this._shouldDisplayStatus(id)) continue;
+            toDraw.push(id);
+        }
+        return toDraw;
+    }
+    switch (id) {
+        case 'floor': return core.flags.enableFloor;
+        case 'name': return core.flags.enableName;
+        case 'lv': return core.flags.enableLv;
+        case 'hpmax': return core.flags.enableHPMax;
+        case 'mana': return core.flags.enableMana;
+        case 'mdef': return core.flags.enableMDef;
+        case 'money': return core.flags.enableMoney;
+        case 'experience': return core.flags.enableExperience && !core.flags.levelUpLeftMode;
+        case 'up': return core.flags.enableLevelUp;
+        case 'skill': return core.flags.enableSkill;
+        case 'key': return core.flags.enableKeys;
+        case 'pzf': return core.flags.enablePZF;
+        case 'debuff': return core.flags.enableDebuff;
+        default: return true;
+    }
+}
+
+////// 注册一个resize函数 //////
+// name为名称，可供注销使用
+// func可以是一个函数，或者是插件中的函数名；可以接受obj参数，详见resize函数。
+control.prototype.registerResize = function (name, func) {
+    this.unregisterResize(name);
+    this.resizes.push({ name: name, func: func });
+}
+
+////// 注销一个resize函数 //////
+control.prototype.unregisterResize = function (name) {
+    this.resizes = this.resizes.filter(function (b) { return b.name != name; });
+}
+
+control.prototype._doResize = function (obj) {
+    for (var i in this.resizes) {
+        try {
+            if (core.doFunc(this.resizes[i].func, this, obj)) return true;
+        } catch (e) {
+            main.log(e);
+            main.log("ERROR in resizes["+this.resizes[i].name+"]：已自动注销该项。");
+            this.unregisterResize(this.resizes[i].name);
+        }
+    }
+    return false;
 }
 
 ////// 屏幕分辨率改变后重新自适应 //////
-control.prototype.resize = function(clientWidth, clientHeight) {
+control.prototype.resize = function() {
     if (main.mode=='editor')return;
+    var clientWidth = main.dom.body.clientWidth, clientHeight = main.dom.body.clientHeight;
+    var CANVAS_WIDTH = core.__PIXELS__ + 6, BAR_WIDTH = Math.round(core.__PIXELS__ * 0.31) + 3;
 
-    // 默认画布大小
-    var DEFAULT_CANVAS_WIDTH = 422;
-    // 默认边栏宽度
-    var DEFAULT_BAR_WIDTH = 132;
-
-    var BASE_LINEHEIGHT = 32;
-    var SPACE = 3;
-    var DEFAULT_FONT_SIZE = 16;
-    //适配宽度 422
-    var ADAPT_WIDTH = DEFAULT_CANVAS_WIDTH;
-    var CHANGE_WIDTH = DEFAULT_CANVAS_WIDTH+DEFAULT_BAR_WIDTH;
-    //判断横竖屏
-    var width = clientWidth;
-    var isHorizontal = false;
-    if(clientWidth > clientHeight && clientHeight < ADAPT_WIDTH){
-        isHorizontal = true;
-        width = clientHeight;
+    if (clientWidth >= CANVAS_WIDTH + BAR_WIDTH || (clientWidth > clientHeight && clientHeight < CANVAS_WIDTH)) {
+        // 横屏
+        core.domStyle.isVertical = false;
+        core.domStyle.scale = Math.min(1, clientHeight / CANVAS_WIDTH);
     }
-    // 各元素大小的变量声明
-    var gameGroupWidth, gameGroupHeight, borderRight,
-        canvasWidth, canvasTop, // canvasLeft,
-        statusBarWidth, statusBarHeight, statusBarBorder,
-        statusWidth, statusHeight, statusMaxWidth,statusLabelsLH,
-        toolBarWidth, toolBarHeight, toolBarTop, toolBarBorder,
-        toolsWidth, toolsHeight,toolsMargin,toolsPMaxwidth,
-        fontSize, toolbarFontSize, margin, statusBackground, toolsBackground;
-
-    var count = core.dom.statusBar.children.length;
-    if (!core.flags.enableFloor) count--;
-    if (!core.flags.enableLv) count--;
-    if (!core.flags.enableHPMax) count--;
-    if (!core.flags.enableMDef) count--;
-    if (!core.flags.enableMoney) count--;
-    if (!core.flags.enableExperience) count--;
-    if (!core.flags.enableLevelUp) count--;
-    if (!core.flags.enableDebuff) count--;
-    if (core.isset(core.flags.enableKeys) && !core.flags.enableKeys) count--;
-    if (!core.flags.enablePZF) count--;
-
-    var statusLineHeight = BASE_LINEHEIGHT * 9 / count;
-    var statusLineFontSize = DEFAULT_FONT_SIZE;
-    if (count>9) statusLineFontSize = statusLineFontSize * 9 / count;
-
-    var shopDisplay;
-
-    var borderColor = main.borderColor||"white";
-
-    statusBarBorder = '3px '+borderColor+' solid';
-    toolBarBorder = '3px '+borderColor+' solid';
-    var zoom = (ADAPT_WIDTH - width) / 4.22;
-    var aScale = 1 - zoom / 100;
-
-    // 移动端
-    if (width < CHANGE_WIDTH) {
-        if(width < ADAPT_WIDTH){
-
-            core.domStyle.scale = aScale;
-            canvasWidth = width;
-        }else{
-            canvasWidth = DEFAULT_CANVAS_WIDTH;
-            core.domStyle.scale = 1;
-        }
-
-        var scale = core.domStyle.scale
-        var tempWidth = DEFAULT_CANVAS_WIDTH * scale;
-        if(!isHorizontal){ //竖屏
-            core.domStyle.screenMode = 'vertical';
-            //显示快捷商店图标
-            shopDisplay = 'block';
-            //判断应该显示几行
-            // var col = core.flags.enableMDef || core.flags.enableExperience || core.flags.enableDebuff ? 3 : 2;
-            var col = parseInt((count-1)/3)+1;
-
-            var tempTopBarH = scale * (BASE_LINEHEIGHT * col + SPACE * 2) + 6;
-            var tempBotBarH = scale * (BASE_LINEHEIGHT + SPACE * 4) + 6;
-
-            gameGroupHeight = tempWidth + tempTopBarH + tempBotBarH;
-
-            gameGroupWidth = tempWidth
-            canvasTop = tempTopBarH;
-            // canvasLeft = 0;
-            toolBarWidth = statusBarWidth = canvasWidth;
-            statusBarHeight = tempTopBarH;
-            statusBarBorder = '3px '+borderColor+' solid';
-
-            statusHeight = scale*BASE_LINEHEIGHT * .8;
-            statusLabelsLH = .8 * BASE_LINEHEIGHT *scale;
-            statusMaxWidth = scale * DEFAULT_BAR_WIDTH * .95;
-            statusBackground = main.statusTopBackground;
-            toolBarHeight = tempBotBarH;
-
-            toolBarTop = statusBarHeight + canvasWidth;
-            toolBarBorder = '3px '+borderColor+' solid';
-            toolsHeight = scale * BASE_LINEHEIGHT;
-            toolsPMaxwidth = scale * DEFAULT_BAR_WIDTH * .4;
-            toolsBackground = main.toolsBackground;
-            borderRight = '3px '+borderColor+' solid';
-
-            margin = scale * SPACE * 2;
-            toolsMargin = scale * SPACE * 4;
-            fontSize = DEFAULT_FONT_SIZE * scale;
-            toolbarFontSize = DEFAULT_FONT_SIZE * scale;
-        }else { //横屏
-            core.domStyle.screenMode = 'horizontal';
-            shopDisplay = 'none';
-            gameGroupWidth = tempWidth + DEFAULT_BAR_WIDTH * scale;
-            gameGroupHeight = tempWidth;
-            canvasTop = 0;
-            // canvasLeft = DEFAULT_BAR_WIDTH * scale;
-            toolBarWidth = statusBarWidth = DEFAULT_BAR_WIDTH * scale;
-            statusBarHeight = gameGroupHeight - SPACE;
-            statusBarBorder = '3px '+borderColor+' solid';
-            statusBackground = main.statusLeftBackground;
-
-            statusHeight = scale*statusLineHeight * .8;
-            statusLabelsLH = .8 * statusLineHeight *scale;
-            toolBarTop = scale*statusLineHeight * count + SPACE * 2;
-            toolBarHeight = canvasWidth - toolBarTop;
-            toolBarBorder = '3px '+borderColor+' solid';
-            toolsHeight = scale * BASE_LINEHEIGHT;
-            toolsBackground = 'transparent';
-            fontSize = statusLineFontSize * scale;
-            toolbarFontSize = DEFAULT_FONT_SIZE * scale;
-            borderRight = '';
-            statusMaxWidth = scale * DEFAULT_BAR_WIDTH;
-            toolsPMaxwidth = scale * DEFAULT_BAR_WIDTH;
-
-            margin = scale * SPACE * 2;
-            toolsMargin = 2 * SPACE * scale;
-        }
-
-    }else { //大屏设备 pc端
-        core.domStyle.scale = 1;
-        core.domStyle.screenMode = 'bigScreen';
-        shopDisplay = 'none';
-
-        gameGroupWidth = DEFAULT_CANVAS_WIDTH + DEFAULT_BAR_WIDTH;
-        gameGroupHeight = DEFAULT_CANVAS_WIDTH;
-        canvasWidth = DEFAULT_CANVAS_WIDTH;
-        canvasTop = 0;
-        // canvasLeft = DEFAULT_BAR_WIDTH;
-
-        toolBarWidth = statusBarWidth = DEFAULT_BAR_WIDTH;
-        // statusBarHeight = statusLineHeight * count + SPACE * 2; //一共有9行
-        statusBackground = main.statusLeftBackground;
-        statusBarHeight = gameGroupHeight - SPACE;
-
-        statusHeight = statusLineHeight * .8;
-        statusLabelsLH = .8 * statusLineHeight;
-        toolBarTop = statusLineHeight * count + SPACE * 2;
-        toolBarHeight = DEFAULT_CANVAS_WIDTH - toolBarTop;
-        toolsBackground = 'transparent';
-
-        toolsHeight = BASE_LINEHEIGHT;
-        borderRight = '';
-        fontSize = statusLineFontSize;
-        toolbarFontSize = DEFAULT_FONT_SIZE;
-        statusMaxWidth = DEFAULT_BAR_WIDTH;
-        toolsPMaxwidth = DEFAULT_BAR_WIDTH * .9;
-        margin = SPACE * 2;
-        toolsMargin = 2 * SPACE;
+    else {
+        // 竖屏
+        core.domStyle.isVertical = true;
+        core.domStyle.scale = Math.min(1, clientWidth / CANVAS_WIDTH);
     }
 
-    var unit = 'px'
-    core.domStyle.styles = [
-        {
-            id: 'gameGroup',
-            rules:{
-                width: gameGroupWidth + unit,
-                height: gameGroupHeight + unit,
-                top: (clientHeight-gameGroupHeight)/2 + unit,
-                left: (clientWidth-gameGroupWidth)/2 + unit,
-            }
-        },
-        {
-            className: 'gameCanvas',
-            rules:{
-                width: (canvasWidth - SPACE*2) + unit,
-                height: (canvasWidth - SPACE*2) + unit,
-            }
-        },
-        {
-            id: 'gif',
-            rules: {
-                width: (canvasWidth - SPACE*2) + unit,
-                height:(canvasWidth - SPACE*2) + unit,
-                top: (canvasTop + SPACE) + unit,
-                right: SPACE + unit,
-            }
-        },
-        {
-            id: 'gif2',
-            rules: {
-                width: (canvasWidth - SPACE*2) + unit,
-                height:(canvasWidth - SPACE*2) + unit,
-                top: (canvasTop + SPACE) + unit,
-                right: SPACE + unit,
-            }
-        },
-        {
-            id: 'curtain',
-            rules: {
-                width: (canvasWidth - SPACE*2) + unit,
-                height:(canvasWidth - SPACE*2) + unit,
-                top: (canvasTop + SPACE) + unit,
-                right: SPACE + unit,
-            }
-        },
-        {
-            id: 'gameDraw',
-            rules: {
-                width: (canvasWidth - SPACE*2) + unit,
-                height:(canvasWidth - SPACE*2) + unit,
-                top: canvasTop + unit,
-                right: 0,
-                border: '3px #fff solid'
-            }
-        },
-        {
-            id: 'floorMsgGroup',
-            rules:{
-                width: (canvasWidth - SPACE*2) + unit,
-                height: (gameGroupHeight - SPACE*2) + unit,
-                top: SPACE + unit,
-                right: SPACE + unit,
-            }
-        },
-        {
-            id: 'statusBar',
-            rules:{
-                width: statusBarWidth + unit,
-                height: statusBarHeight + unit,
-                top: 0,
-                left: 0,
-                padding: SPACE + unit,
+    var statusDisplayArr = this._shouldDisplayStatus(), count = statusDisplayArr.length;
+    var statusCanvas = core.flags.statusCanvas, statusCanvasRows = core.flags.statusCanvasRowsOnMobile || 3;
+    var col = statusCanvas ? statusCanvasRows : Math.ceil(count / 3);
+    if (col > 4) {
+        if (statusCanvas) alert("自绘状态栏的在竖屏下的行数应不超过4！");
+        else alert("当前状态栏数目("+count+")大于12，请调整到不超过12以避免手机端出现显示问题。");
+    }
+    var globalAttribute = core.status.globalAttribute || core.initStatus.globalAttribute;
 
-                borderTop: statusBarBorder,
-                borderLeft: statusBarBorder,
-                borderRight: borderRight,
-                fontSize: fontSize + unit,
-                background: statusBackground,
-            }
-        },
-        {
-            className: 'status',
-            rules:{
-                width: '100%',
-                maxWidth: statusMaxWidth + unit,
-                height: statusHeight + unit,
-                margin: margin/2 + unit
-            }
-        },
-        {
-            className: 'statusLabels',
-            rules:{
-                marginLeft: margin + unit,
-                lineHeight: statusLabelsLH + unit,
-            }
-        },
-        {
-            id: 'toolBar',
-            rules:{
-                width: toolBarWidth + unit,
-                height: toolBarHeight + unit,
-                top: toolBarTop +unit,
-                left: 0,
-                padding: SPACE + unit,
-                borderBottom: toolBarBorder,
-                borderLeft: toolBarBorder,
-                borderRight: borderRight,
-                fontSize: toolbarFontSize + unit,
-                background: toolsBackground,
-            }
-        },
-        {
-            className: 'tools',
-            rules:{
-                height: toolsHeight + unit,
-                maxWidth: toolsPMaxwidth + unit,
-                marginLeft: toolsMargin + unit,
-                marginTop: margin + unit,
-            }
-        },
-        {
-            imgId: 'shop',
-            rules:{
-                display: shopDisplay
-            }
-        },
-        {
-            id: 'floorCol',
-            rules: {
-                display: core.flags.enableFloor ? 'block': 'none'
-            }
-        },
-        {
-            id: 'lvCol',
-            rules: {
-                display: core.flags.enableLv ? 'block': 'none'
-            }
-        },
-        {
-            id: 'hpmaxCol',
-            rules: {
-                display: core.flags.enableHPMax ? 'block': 'none'
-            }
-        },
-        {
-            id: 'mdefCol',
-            rules: {
-                display: core.flags.enableMDef ? 'block': 'none'
-            }
-        },
-        {
-            id: 'moneyCol',
-            rules: {
-                display: core.flags.enableMoney ? 'block': 'none'
-            }
-        },
-        {
-            id: 'expCol',
-            rules: {
-                display: core.flags.enableExperience ? 'block': 'none'
-            }
-        },
-        {
-            id: 'upCol',
-            rules: {
-                display: core.flags.enableLevelUp ? 'block': 'none'
-            }
-        },
-        {
-            id: 'keyCol',
-            rules: {
-                display: !core.isset(core.flags.enableKeys)||core.flags.enableKeys?'block':'none'
-            }
-        },
-        {
-            id: 'pzfCol',
-            rules: {
-                display: core.flags.enablePZF?'block':'none'
-            }
-        },
-        {
-            'id': 'debuffCol',
-            rules: {
-                display: core.flags.enableDebuff ? 'block': 'none'
-            }
-        },
-        {
-            id: 'hard',
-            rules: {
-                lineHeight: toolsHeight + unit
-            }
-        }
-    ]
-    core.domRenderer();
+    var obj = {
+        clientWidth: clientWidth,
+        clientHeight: clientHeight,
+        CANVAS_WIDTH: CANVAS_WIDTH,
+        BAR_WIDTH: BAR_WIDTH,
+        outerSize: CANVAS_WIDTH * core.domStyle.scale,
+        globalAttribute: globalAttribute,
+        border: '3px ' + globalAttribute.borderColor + ' solid',
+        statusDisplayArr: statusDisplayArr,
+        count: count,
+        col: col,
+        statusBarHeightInVertical: core.domStyle.isVertical ? (32 * col + 6) * core.domStyle.scale + 6 : 0,
+        toolbarHeightInVertical: core.domStyle.isVertical ? 44 * core.domStyle.scale + 6 : 0,
+        is15x15: core.__SIZE__ == 15
+    };
+
+    this._doResize(obj);
+    this.setToolbarButton();
+    core.updateStatusBar();
 }
 
-////// 渲染DOM //////
-control.prototype.domRenderer = function(){
-
-    core.dom.statusBar.style.display = 'block';
-    core.dom.toolBar.style.display = 'block';
-
-    var styles = core.domStyle.styles;
-
-    for(var i=0; i<styles.length; i++){
-        if(styles[i].hasOwnProperty('rules')){
-            var rules = styles[i].rules;
-            var rulesProp = Object.keys(rules);
-
-            if(styles[i].hasOwnProperty('className')){
-                var className = styles[i].className
-                for(var j=0; j<core.dom[className].length; j++)
-                    for(var k=0; k<rulesProp.length; k++)
-                        core.dom[className][j].style[rulesProp[k]] = rules[rulesProp[k]];
-            }
-            if(styles[i].hasOwnProperty('id')){
-                var id = styles[i].id;
-
-                for(var j=0; j<rulesProp.length; j++)
-                    core.dom[id].style[rulesProp[j]] = rules[rulesProp[j]];
-            }
-            if(styles[i].hasOwnProperty('imgId')){
-                var imgId = styles[i].imgId;
-
-                for(var j=0; j<rulesProp.length; j++)
-                    core.statusBar.image[imgId].style[rulesProp[j]] = rules[rulesProp[j]];
-            }
-        }
-
+control.prototype._resize_gameGroup = function (obj) {
+    var gameGroup = core.dom.gameGroup;
+    var totalWidth, totalHeight;
+    if (core.domStyle.isVertical) {
+        totalWidth = obj.outerSize;
+        totalHeight = obj.outerSize + obj.statusBarHeightInVertical + obj.toolbarHeightInVertical
     }
-    // resize map
-    if (core.isPlaying() && core.isset(core.status) && core.isset(core.bigmap)) {
-        core.bigmap.canvas.forEach(function(cn){
-            core.canvas[cn].canvas.style.width = core.bigmap.width*32*core.domStyle.scale + "px";
-            core.canvas[cn].canvas.style.height = core.bigmap.height*32*core.domStyle.scale + "px";
-        });
+    else {
+        totalWidth = (obj.CANVAS_WIDTH + obj.BAR_WIDTH) * core.domStyle.scale;
+        totalHeight = obj.outerSize;
     }
+    gameGroup.style.width = totalWidth + "px";
+    gameGroup.style.height = totalHeight + "px";
+    gameGroup.style.left = (obj.clientWidth - totalWidth) / 2 + "px";
+    gameGroup.style.top = (obj.clientHeight - totalHeight) / 2 + "px";
+    // floorMsgGroup
+    var floorMsgGroup = core.dom.floorMsgGroup;
+    floorMsgGroup.style.width = obj.outerSize - 6 + "px";
+    floorMsgGroup.style.height = totalHeight - 6 + "px";
+    floorMsgGroup.style.background = obj.globalAttribute.floorChangingBackground;
+    floorMsgGroup.style.color = obj.globalAttribute.floorChangingTextColor;
+    // musicBtn
+    if (core.domStyle.isVertical || core.domStyle.scale < 1) {
+        core.dom.musicBtn.style.right = core.dom.musicBtn.style.bottom = "3px";
+    }
+    else {
+        core.dom.musicBtn.style.right = (obj.clientWidth - totalWidth) / 2 + "px";
+        core.dom.musicBtn.style.bottom = (obj.clientHeight - totalHeight) / 2 - 27 + "px";
+    }
+}
 
-}
\ No newline at end of file
+control.prototype._resize_canvas = function (obj) {
+    var innerSize = (obj.outerSize - 6) + "px";
+    for (var i = 0; i < core.dom.gameCanvas.length; ++i)
+        core.dom.gameCanvas[i].style.width = core.dom.gameCanvas[i].style.height = innerSize;
+    core.dom.gif.style.width = core.dom.gif.style.height = innerSize;
+    core.dom.gif2.style.width = core.dom.gif2.style.height = innerSize;
+    core.dom.gameDraw.style.width = core.dom.gameDraw.style.height = innerSize;
+    core.dom.gameDraw.style.top = obj.statusBarHeightInVertical + "px";
+    core.dom.gameDraw.style.right = 0;
+    core.dom.gameDraw.style.border = obj.border;
+    // resize bigmap
+    core.bigmap.canvas.forEach(function(cn){
+        core.canvas[cn].canvas.style.width = core.bigmap.width * 32 * core.domStyle.scale + "px";
+        core.canvas[cn].canvas.style.height = core.bigmap.height * 32 * core.domStyle.scale + "px";
+    });
+    // resize dynamic canvas
+    for (var name in core.dymCanvas) {
+        var ctx = core.dymCanvas[name], canvas = ctx.canvas;
+        canvas.style.width = canvas.width * core.domStyle.scale + "px";
+        canvas.style.height = canvas.height * core.domStyle.scale + "px";
+        canvas.style.left = parseFloat(canvas.getAttribute("_left")) * core.domStyle.scale + "px";
+        canvas.style.top = parseFloat(canvas.getAttribute("_top")) * core.domStyle.scale + "px";
+    }
+}
+
+control.prototype._resize_statusBar = function (obj) {
+    // statusBar
+    var statusBar = core.dom.statusBar;
+    if (core.domStyle.isVertical) {
+        statusBar.style.width = obj.outerSize + "px";
+        statusBar.style.height = obj.statusBarHeightInVertical + "px";
+        statusBar.style.background = obj.globalAttribute.statusTopBackground;
+        statusBar.style.fontSize = 16 * core.domStyle.scale + "px";
+    }
+    else {
+        statusBar.style.width = obj.BAR_WIDTH * core.domStyle.scale + "px";
+        statusBar.style.height = obj.outerSize + "px";
+        statusBar.style.background = obj.globalAttribute.statusLeftBackground;
+        // --- 计算文字大小
+        statusBar.style.fontSize = 16 * Math.min(1, (core.__HALF_SIZE__ + 3) / obj.count) * core.domStyle.scale + "px";
+    }
+    statusBar.style.display = 'block';
+    statusBar.style.borderTop = statusBar.style.borderLeft = obj.border;
+    statusBar.style.borderRight = core.domStyle.isVertical ? obj.border : '';
+    statusBar.style.borderBottom = core.domStyle.isVertical ? '' : obj.border;
+    // 自绘状态栏
+    if (core.domStyle.isVertical) {
+        core.dom.statusCanvas.style.width = obj.outerSize - 6 + "px";
+        core.dom.statusCanvas.width = core.__PIXELS__;
+        core.dom.statusCanvas.style.height = obj.statusBarHeightInVertical - 3 + "px";
+        core.dom.statusCanvas.height = obj.col * 32 + 9;
+    }
+    else {
+        core.dom.statusCanvas.style.width = obj.BAR_WIDTH * core.domStyle.scale - 3 + "px";
+        core.dom.statusCanvas.width = obj.BAR_WIDTH - 3;
+        core.dom.statusCanvas.style.height = obj.outerSize - 6 + "px";
+        core.dom.statusCanvas.height = core.__PIXELS__;
+    }
+    core.dom.statusCanvas.style.display = core.flags.statusCanvas ? "block" : "none";
+}
+
+control.prototype._resize_status = function (obj) {
+    var statusHeight = (core.domStyle.isVertical ? 1 : (core.__HALF_SIZE__ + 3) / obj.count) *  32 * core.domStyle.scale * 0.8;
+    // status
+    for (var i = 0; i < core.dom.status.length; ++i) {
+        var id = core.dom.status[i].id, style = core.dom.status[i].style;
+        if (id.endsWith("Col")) id = id.substring(0, id.length-3);
+        style.display = core.flags.statusCanvas || obj.statusDisplayArr.indexOf(id) < 0 ? 'none': 'block';
+        style.margin = 3 * core.domStyle.scale + "px";
+        style.height = statusHeight + "px";
+        style.maxWidth = obj.BAR_WIDTH * core.domStyle.scale * (core.domStyle.isVertical ? 0.95 : 1) + "px";
+        if (obj.is15x15 && !core.domStyle.isVertical)
+            style.marginLeft = 11 * core.domStyle.scale + "px";
+    }
+    // statusLabels, statusTexts
+    for (var i = 0; i < core.dom.statusLabels.length; ++i) {
+        core.dom.statusLabels[i].style.lineHeight = statusHeight + "px";
+        core.dom.statusLabels[i].style.marginLeft = 6 * core.domStyle.scale + "px";
+    }
+    for (var i = 0; i < core.dom.statusTexts.length; ++i) {
+        core.dom.statusTexts[i].style.color = obj.globalAttribute.statusBarColor;
+    }
+}
+
+control.prototype._resize_toolBar = function (obj) {
+    // toolBar
+    var toolBar = core.dom.toolBar;
+    if (core.domStyle.isVertical) {
+        toolBar.style.width = obj.outerSize + "px";
+        toolBar.style.top = obj.statusBarHeightInVertical + obj.outerSize + "px";
+        toolBar.style.height = obj.toolbarHeightInVertical + "px";
+        toolBar.style.background = obj.globalAttribute.toolsBackground;
+    }
+    else {
+        toolBar.style.width = obj.BAR_WIDTH * core.domStyle.scale + "px";
+        toolBar.style.top = 0.718 * obj.outerSize + "px";
+        toolBar.style.height = 0.281 * obj.outerSize + "px";
+        toolBar.style.background = 'transparent';
+    }
+    toolBar.style.display = 'block';
+    toolBar.style.borderLeft = obj.border;
+    toolBar.style.borderRight = toolBar.style.borderBottom = core.domStyle.isVertical ? obj.border : '';
+    toolBar.style.fontSize = 16 * core.domStyle.scale + "px";
+}
+
+control.prototype._resize_tools = function (obj) {
+    var toolsHeight = 32 * core.domStyle.scale * (core.domStyle.isVertical && !obj.is15x15 ? 0.95 : 1);
+    var toolsMarginLeft;
+    if (core.domStyle.isVertical)
+        toolsMarginLeft = (core.__HALF_SIZE__ - 3) * 3 * core.domStyle.scale;
+    else
+        toolsMarginLeft = (obj.BAR_WIDTH * core.domStyle.scale - 9 - toolsHeight * 3) / 4;
+    for (var i = 0; i < core.dom.tools.length; ++i) {
+        var style = core.dom.tools[i].style;
+        style.height = toolsHeight + "px";
+        style.marginLeft = toolsMarginLeft + "px";
+        style.marginTop = 6 * core.domStyle.scale + "px"
+    }
+    core.dom.hard.style.lineHeight = toolsHeight + "px";
+    core.dom.hard.style.color = obj.globalAttribute.hardLabelColor;
+    if (core.domStyle.isVertical) {
+        core.dom.hard.style.width = obj.outerSize - 9 * toolsMarginLeft - 8.5 * toolsHeight - 12 + "px";
+    }
+    else {
+        core.dom.hard.style.width = obj.BAR_WIDTH * core.domStyle.scale - 9 - 2 * toolsMarginLeft + "px";
+        if (!obj.is15x15) core.dom.hard.style.marginTop = 0;
+    }
+}
diff --git a/libs/core.js b/libs/core.js
index a575e7ac..be98ccfe 100644
--- a/libs/core.js
+++ b/libs/core.js
@@ -2,7 +2,12 @@
  * 初始化 start
  */
 
+"use strict";
+
 function core() {
+    this.__SIZE__ = 13;
+    this.__PIXELS__ = this.__SIZE__ * 32;
+    this.__HALF_SIZE__ = Math.floor(this.__SIZE__ / 2);
     this.material = {
         'animates': {},
         'images': {},
@@ -11,55 +16,63 @@ function core() {
         'ground': null,
         'items': {},
         'enemys': {},
-        'icons': {},
-        'events': {}
+        'icons': {}
     }
     this.timeout = {
-        'getItemTipTimeout': null,
+        'tipTimeout': null,
         'turnHeroTimeout': null,
         'onDownTimeout': null,
+        'sleepTimeout': null,
     }
     this.interval = {
         'heroMoveInterval': null,
         "tipAnimate": null,
-        'openDoorAnimate': null,
-        'animateInterval': null,
         'onDownInterval': null,
     }
     this.animateFrame = {
-        'background': null,
+        'totalTime': 0,
+        'totalTimeStart': 0,
         'globalAnimate': false,
-        'globalTime': null,
-        'boxTime': null,
-        'moveTime': null,
-        'speed': null,
+        'globalTime': 0,
+        'selectorTime': 0,
+        'selectorUp': true,
+        'animateTime': 0,
+        'moveTime': 0,
+        'lastLegTime': 0,
+        'leftLeg': true,
         'weather': {
-            'time': null,
+            'time': 0,
             'type': null,
-            'level': 0,
             'nodes': [],
             'data': null,
-        }
+            'fog': null,
+        },
+        "asyncId": {}
     }
     this.musicStatus = {
         'audioContext': null, // WebAudioContext
-        'startDirectly': false, // 是否直接播放（加载）音乐
         'bgmStatus': false, // 是否播放BGM
         'soundStatus': true, // 是否播放SE
         'playingBgm': null, // 正在播放的BGM
-        'isPlaying': false,
+        'lastBgm': null, // 上次播放的bgm
         'gainNode': null,
+        'playingSounds': {}, // 正在播放的SE
         'volume': 1.0, // 音量
+        'cachedBgms': [], // 缓存BGM内容
+        'cachedBgmCount': 4, // 缓存的bgm数量
     }
     this.platform = {
         'isOnline': true, // 是否http
         'isPC': true, // 是否是PC
         'isAndroid': false, // 是否是Android
         'isIOS': false, // 是否是iOS
+        'string': 'PC',
         'isWeChat': false, // 是否是微信
         'isQQ': false, // 是否是QQ
         'isChrome': false, // 是否是Chrome
         'supportCopy': false, // 是否支持复制到剪切板
+        'useLocalForage': true,
+        'extendKeyboard': false,
 
         'fileInput': null, // FileInput
         'fileReader': null, // 是否支持FileReader
@@ -68,17 +81,31 @@ function core() {
     }
     // 样式
     this.domStyle = {
-        styles: [],
         scale: 1.0,
+        isVertical: false,
+        showStatusBar: true,
+        toolbarBtn: false,
     }
     this.bigmap = {
-        canvas: ["bg", "event", "event2", "fg", "route"],
+        canvas: ["bg", "event", "event2", "fg", "damage"],
         offsetX: 0, // in pixel
         offsetY: 0,
-        width: 13, // map width and height
-        height: 13,
+        width: this.__SIZE__, // map width and height
+        height: this.__SIZE__,
         tempCanvas: null, // A temp canvas for drawing
     }
+    this.paint = {};
+    this.saves = {
+        "saveIndex": null,
+        "ids": {},
+        "autosave": {
+            "data": null,
+            "time": 0,
+            "updated": false,
+        },
+        "favorite": [],
+        "favoriteName": {}
+    }
     this.initStatus = {
         'played': false,
         'gameOver': false,
@@ -90,6 +117,8 @@ function core() {
         'floorId': null,
         'thisMap': null,
         'maps': null,
+        'bgmaps': {},
+        'fgmaps': {},
         'checkBlock': {}, // 显伤伤害
 
         'lockControl': false,
@@ -106,13 +135,14 @@ function core() {
             'destStep': 0,
             'destX': null,
             'destY': null,
+            'offsetX': null,
+            'offsetY': null,
             'autoStepRoutes': [],
             'moveStepBeforeStop': [],
             'lastDirection': null,
             'cursorX': null,
             'cursorY': null,
             "moveDirectly": false,
-            'clickMoveDirectly': true,
         },
 
         // 按下键的时间：为了判定双击
@@ -133,7 +163,6 @@ function core() {
         },
 
         // event事件
-        'saveIndex': null,
         'shops': {},
         'event': {
             'id': null,
@@ -144,1115 +173,240 @@ function core() {
         },
         'textAttribute': {
             'position': "center",
-            "title": [255,215,0,1],
-            "background": [0,0,0,0.85],
-            "text": [255,255,255,1],
+            "offset": 0,
+            "title": [255, 215, 0, 1],
+            "background": [0, 0, 0, 0.85],
+            "text": [255, 255, 255, 1],
+            "titlefont": 22,
+            "textfont": 16,
             "bold": false,
             "time": 0,
         },
+        "globalAttribute": {
+            'equipName': main.equipName || [],
+            "statusLeftBackground": main.statusLeftBackground || "url(project/images/ground.png) repeat",
+            "statusTopBackground": main.statusTopBackground || "url(project/images/ground.png) repeat",
+            "toolsBackground": main.toolsBackground || "url(project/images/ground.png) repeat",
+            "borderColor": main.borderColor || "white",
+            "statusBarColor": main.statusBarColor || "white",
+            "hardLabelColor": main.hardLabelColor || "red",
+            "floorChangingBackground": main.floorChangingBackground || "black",
+            "floorChangingTextColor": main.floorChangingTextColor || "white",
+            "font": main.font || "Verdana"
+        },
         'curtainColor': null,
         'openingDoor': null,
-        'isSkiing': false,
 
         // 动画
         'globalAnimateObjs': [],
+        'floorAnimateObjs': [],
         'boxAnimateObjs': [],
+        'autotileAnimateObjs': {"blocks": [], "map": null, "bgmap": null, "fgmap": null},
+        "globalAnimateStatus": 0,
+        'animateObjs': [],
     };
     this.status = {};
+    this.dymCanvas = {};
 }
 
 /////////// 系统事件相关 ///////////
 
 ////// 初始化 //////
 core.prototype.init = function (coreData, callback) {
-    for (var key in coreData) {
+    this._forwardFuncs();
+    for (var key in coreData)
         core[key] = coreData[key];
-    }
+    this._init_flags();
+    this._init_platform();
+    this._init_others();
+    this._initPlugins();
+
+    core.loader._load(function () {
+        core._afterLoadResources(callback);
+    });
+}
+
+core.prototype._init_flags = function () {
     core.flags = core.clone(core.data.flags);
     core.values = core.clone(core.data.values);
-    core.firstData = core.data.getFirstData();
-
-    if (!core.flags.enableExperience)
-        core.flags.enableLevelUp = false;
-    if (!core.flags.canOpenBattleAnimate) {
-        core.flags.showBattleAnimateConfirm = false;
-        core.flags.battleAnimate = false;
-        core.setLocalStorage('battleAnimate', false);
-    }
-
-    if (core.isset(core.firstData.shops)) {
-        core.firstData.shops.forEach(function (t) {
-            core.initStatus.shops[t.id] = t;
-        })
-    }
+    core.firstData = core.clone(core.data.firstData);
+    this._init_sys_flags();
 
     core.dom.versionLabel.innerHTML = core.firstData.version;
     core.dom.logoLabel.innerHTML = core.firstData.title;
     document.title = core.firstData.title + " - HTML5魔塔";
     document.getElementById("startLogo").innerHTML = core.firstData.title;
-    core.material.items = core.clone(core.items.getItems());
-    core.initStatus.maps = core.maps.initMaps(core.floorIds);
-    core.material.enemys = core.clone(core.enemys.getEnemys());
+    (core.firstData.shops||[]).forEach(function (t) { core.initStatus.shops[t.id] = t; });
+    core.maps._setFloorSize();
+    // 初始化怪物、道具等
+    core.material.enemys = core.enemys.getEnemys();
+    core.material.items = core.items.getItems();
+    core.items._resetItems();
     core.material.icons = core.icons.getIcons();
-    core.material.events = core.events.getEvents();
+}
 
-    core.platform.isOnline = location.protocol.indexOf("http")==0;
-    if (core.platform.isOnline) {
-        window.AudioContext = window.AudioContext || window.webkitAudioContext || window.mozAudioContext || window.msAudioContext;
-        try {
-            core.musicStatus.audioContext = new window.AudioContext();
-            core.musicStatus.gainNode = core.musicStatus.audioContext.createGain();
-            core.musicStatus.gainNode.connect(core.musicStatus.audioContext.destination);
-        } catch (e) {
-            console.log("该浏览器不支持AudioContext");
-            core.musicStatus.audioContext = null;
-        }
+core.prototype._init_sys_flags = function () {
+    if (!core.flags.enableExperience) core.flags.enableLevelUp = false;
+    if (!core.flags.enableLevelUp) core.flags.levelUpLeftMode = false;
+    if (core.flags.equipboxButton) core.flags.equipment = true;
+    core.flags.displayEnemyDamage = core.getLocalStorage('enemyDamage', core.flags.displayEnemyDamage);
+    core.flags.displayCritical = core.getLocalStorage('critical', core.flags.displayCritical);
+    core.flags.displayExtraDamage = core.getLocalStorage('extraDamage', core.flags.displayExtraDamage);
+    // 行走速度
+    core.values.moveSpeed = core.getLocalStorage('moveSpeed', core.values.moveSpeed);
+}
+
+core.prototype._init_platform = function () {
+    core.platform.isOnline = location.protocol.indexOf("http") == 0;
+    if (!core.platform.isOnline) alert("请勿直接打开html文件！使用启动服务或者APP进行离线游戏。");
+    window.AudioContext = window.AudioContext || window.webkitAudioContext || window.mozAudioContext || window.msAudioContext;
+    try {
+        core.musicStatus.audioContext = new window.AudioContext();
+        core.musicStatus.gainNode = core.musicStatus.audioContext.createGain();
+        core.musicStatus.gainNode.connect(core.musicStatus.audioContext.destination);
+    } catch (e) {
+        console.log("该浏览器不支持AudioContext");
+        core.musicStatus.audioContext = null;
     }
-
+    core.musicStatus.bgmStatus = core.getLocalStorage('bgmStatus', true);
+    core.musicStatus.soundStatus = core.getLocalStorage('soundStatus', true);
     ["Android", "iPhone", "SymbianOS", "Windows Phone", "iPad", "iPod"].forEach(function (t) {
-        if (navigator.userAgent.indexOf(t)>=0) {
-            if (t=='iPhone' || t=='iPad' || t=='iPod') core.platform.isIOS = true;
-            if (t=='Android') core.platform.isAndroid=true;
-            core.platform.isPC=false;
+        if (navigator.userAgent.indexOf(t) >= 0) {
+            if (t == 'iPhone' || t == 'iPad' || t == 'iPod') core.platform.isIOS = true;
+            if (t == 'Android') core.platform.isAndroid = true;
+            core.platform.isPC = false;
         }
     });
-
-    try {
-        core.platform.supportCopy = document.queryCommandSupported("copy");
-    }
-    catch (e) {
-        core.platform.supportCopy = false;
-    }
-
-    var chrome=/Chrome\/(\d+)\./i.exec(navigator.userAgent);
-    if (core.isset(chrome) && parseInt(chrome[1])>=50)
-        core.platform.isChrome = true;
+    core.platform.string = core.platform.isPC ? "PC" : core.platform.isAndroid ? "Android" : core.platform.isIOS ? "iOS" : "";
+    core.platform.supportCopy = document.queryCommandSupported || document.queryCommandSupported("copy");
+    var chrome = /Chrome\/(\d+)\./i.exec(navigator.userAgent);
+    if (chrome && parseInt(chrome[1]) >= 50) core.platform.isChrome = true;
     core.platform.isSafari = /Safari/i.test(navigator.userAgent) && !/Chrome/i.test(navigator.userAgent);
     core.platform.isQQ = /QQ/i.test(navigator.userAgent);
     core.platform.isWeChat = /MicroMessenger/i.test(navigator.userAgent);
-
+    this._init_checkLocalForage();
+    core.platform.extendKeyboard = core.getLocalStorage("extendKeyboard", false);
     if (window.FileReader) {
         core.platform.fileReader = new FileReader();
         core.platform.fileReader.onload = function () {
             core.readFileContent(core.platform.fileReader.result);
         };
         core.platform.fileReader.onerror = function () {
-            if (core.isset(core.platform.errorCallback))
+            if (core.platform.errorCallback)
                 core.platform.errorCallback();
         }
     }
+}
 
-    if (core.platform.isPC) {
-        // 如果是PC端直接加载
-        core.musicStatus.startDirectly = true;
-    }
-    else {
-        var connection = navigator.connection;
-        if (core.isset(connection) && connection.type=='wifi')
-            core.musicStatus.startDirectly = true;
+core.prototype._init_checkLocalForage = function () {
+    core.platform.useLocalForage = core.getLocalStorage('useLocalForage', true);
+    var _error = function (e) {
+        main.log(e);
+        core.platform.useLocalForage = false;
+    };
+    if (core.platform.useLocalForage) {
+        try {
+            core.setLocalForage("__test__", lzw_encode("__test__"), function () {
+                try {
+                    core.getLocalForage("__test__", null, function (data) {
+                        try {
+                            if (lzw_decode(data) != "__test__") {
+                                console.log("localForage unsupported!");
+                                core.platform.useLocalForage = false;
+                            }
+                            else {
+                                console.log("localForage supported!");
+                                core.removeLocalForage("__test__");
+                            }
+                        }
+                        catch (e) {_error(e);}
+                    }, _error)
+                }
+                catch (e) {_error(e);}
+            }, _error)
+        }
+        catch (e) {_error(e);}
     }
+}
 
-    // 先从存储中读取BGM状态
-    core.musicStatus.bgmStatus = core.getLocalStorage('bgmStatus', true);
-    if (!core.musicStatus.startDirectly) // 如果当前网络环境不允许
-        core.musicStatus.bgmStatus = false;
-    core.setLocalStorage('bgmStatus', core.musicStatus.bgmStatus);
-
-    core.musicStatus.soundStatus = core.getLocalStorage('soundStatus', true);
-    core.setLocalStorage('soundStatus', core.musicStatus.soundStatus);
-
-    // switchs
-    core.flags.battleAnimate = core.getLocalStorage('battleAnimate', core.flags.battleAnimate);
-    core.flags.displayEnemyDamage = core.getLocalStorage('enemyDamage', core.flags.displayEnemyDamage);
-    core.flags.displayCritical = core.getLocalStorage('critical', core.flags.displayCritical);
-    core.flags.displayExtraDamage = core.getLocalStorage('extraDamage', core.flags.displayExtraDamage);
-
-    core.material.ground = new Image();
-    core.material.ground.src = "project/images/ground.png";
-
+core.prototype._init_others = function () {
+    // 一些额外的东西
+    core.material.groundCanvas = document.createElement('canvas').getContext('2d');
+    core.material.groundCanvas.canvas.width = core.material.groundCanvas.canvas.height = 32;
+    core.material.groundPattern = core.material.groundCanvas.createPattern(core.material.groundCanvas.canvas, 'repeat');
     core.bigmap.tempCanvas = document.createElement('canvas').getContext('2d');
-
-    core.loader.load(function () {
-        console.log(core.material);
-        // 设置勇士高度
-        core.material.icons.hero.height = core.material.images.hero.height/4;
-        core.setRequestAnimationFrame();
-        core.showStartAnimate();
-
-        if (main.mode=='play')
-            core.events.initGame();
-
-        if (core.isset(functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a.plugins))
-            core.plugin = new functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a.plugins.plugin();
-
-        if (core.isset(callback)) callback();
-
-    });
-}
-
-////// 设置requestAnimationFrame //////
-core.prototype.setRequestAnimationFrame = function () {
-    core.control.setRequestAnimationFrame();
-}
-
-////// 显示游戏开始界面 //////
-core.prototype.showStartAnimate = function (callback) {
-    core.control.showStartAnimate(callback);
-}
-
-////// 隐藏游戏开始界面 //////
-core.prototype.hideStartAnimate = function (callback) {
-    core.control.hideStartAnimate(callback);
-}
-
-////// 游戏是否已经开始 //////
-core.prototype.isPlaying = function() {
-    return core.control.isPlaying();
-}
-
-////// 清除游戏状态和数据 //////
-core.prototype.clearStatus = function() {
-    core.control.clearStatus();
-}
-
-////// 重置游戏状态和初始数据 //////
-core.prototype.resetStatus = function(hero, hard, floorId, route, maps, values) {
-    core.control.resetStatus(hero, hard, floorId, route, maps, values);
-}
-
-////// 开始游戏 //////
-core.prototype.startGame = function (hard, callback) {
-    core.control.startGame(hard, callback);
-}
-
-////// 重新开始游戏；此函数将回到标题页面 //////
-core.prototype.restart = function() {
-    core.control.restart();
-}
-
-/////////// 系统事件相关 END ///////////
-
-
-/////////// 键盘、鼠标事件相关 ///////////
-
-////// 按下某个键时 //////
-core.prototype.onkeyDown = function(e) {
-    return core.actions.onkeyDown(e);
-}
-
-////// 放开某个键时 //////
-core.prototype.onkeyUp = function(e) {
-    return core.actions.onkeyUp(e);
-}
-
-////// 按住某个键时 //////
-core.prototype.pressKey = function (keyCode) {
-    return core.actions.pressKey(keyCode);
-}
-
-////// 根据按下键的code来执行一系列操作 //////
-core.prototype.keyDown = function(keyCode) {
-    return core.actions.keyDown(keyCode);
-}
-
-////// 根据放开键的code来执行一系列操作 //////
-core.prototype.keyUp = function(keyCode) {
-    return core.actions.keyUp(keyCode);
-}
-
-////// 点击（触摸）事件按下时 //////
-core.prototype.ondown = function (x ,y) {
-    return core.actions.ondown(x,y);
-}
-
-////// 当在触摸屏上滑动时 //////
-core.prototype.onmove = function (x ,y) {
-    return core.actions.onmove(x,y);
-}
-
-////// 当点击（触摸）事件放开时 //////
-core.prototype.onup = function () {
-    return core.actions.onup();
-}
-
-////// 获得点击事件相对左上角的坐标（0到12之间） //////
-core.prototype.getClickLoc = function (x, y) {
-    return core.actions.getClickLoc(x,y);
-}
-
-////// 具体点击屏幕上(x,y)点时，执行的操作 //////
-core.prototype.onclick = function (x, y, stepPostfix) {
-    return core.actions.onclick(x,y,stepPostfix);
-}
-
-////// 滑动鼠标滚轮时的操作 //////
-core.prototype.onmousewheel = function (direct) {
-    return core.actions.onmousewheel(direct);
-}
-
-/////////// 键盘、鼠标事件相关 END ///////////
-
-/////////// 寻路代码相关 ///////////
-
-////// 清除自动寻路路线 //////
-core.prototype.clearAutomaticRouteNode = function (x, y) {
-    core.control.clearAutomaticRouteNode(x,y);
-}
-
-////// 停止自动寻路操作 //////
-core.prototype.stopAutomaticRoute = function () {
-    core.control.stopAutomaticRoute();
-}
-
-////// 继续剩下的自动寻路操作 //////
-core.prototype.continueAutomaticRoute = function () {
-    core.control.continueAutomaticRoute();
-}
-
-////// 清空剩下的自动寻路列表 //////
-core.prototype.clearContinueAutomaticRoute = function () {
-    core.control.clearContinueAutomaticRoute();
-}
-
-////// 设置自动寻路路线 //////
-core.prototype.setAutomaticRoute = function (destX, destY, stepPostfix) {
-    core.control.setAutomaticRoute(destX,destY,stepPostfix);
-}
-
-////// 自动寻路算法，找寻最优路径 //////
-core.prototype.automaticRoute = function (destX, destY) {
-    return core.control.automaticRoute(destX, destY);
-}
-
-////// 显示离散的寻路点 //////
-core.prototype.fillPosWithPoint = function (pos) {
-    core.control.fillPosWithPoint(pos);
-}
-
-/////////// 寻路代码相关 END ///////////
-
-
-
-/////////// 自动行走 & 行走控制 ///////////
-
-////// 设置勇士的自动行走路线 //////
-core.prototype.setAutoHeroMove = function (steps) {
-    core.control.setAutoHeroMove(steps);
-}
-
-////// 设置行走的效果动画 //////
-core.prototype.setHeroMoveInterval = function (direction, x, y, callback) {
-    core.control.setHeroMoveInterval(direction, x, y, callback);
-}
-
-////// 实际每一步的行走过程 //////
-core.prototype.moveAction = function (callback) {
-    core.control.moveAction(callback);
-}
-
-////// 转向 //////
-core.prototype.turnHero = function() {
-    core.control.turnHero();
-}
-
-////// 勇士能否前往某方向 //////
-core.prototype.canMoveHero = function(x,y,direction,floorId) {
-    return core.maps.canMoveHero(x,y,direction,floorId);
-}
-
-////// 能否瞬间移动 //////
-core.prototype.canMoveDirectly = function (destX,destY) {
-    return core.maps.canMoveDirectly(destX, destY);
-}
-
-////// 让勇士开始移动 //////
-core.prototype.moveHero = function (direction, callback) {
-    core.control.moveHero(direction, callback);
-}
-
-/////// 使用事件让勇士移动。这个函数将不会触发任何事件 //////
-core.prototype.eventMoveHero = function(steps, time, callback) {
-    core.control.eventMoveHero(steps, time, callback);
-}
-
-////// 使用事件让勇士跳跃。这个函数将不会触发任何事件 //////
-core.prototype.jumpHero = function (ex,ey,time,callback) {
-    core.control.jumpHero(ex,ey,time,callback);
-}
-
-////// 每移动一格后执行的事件 //////
-core.prototype.moveOneStep = function() {
-    core.control.moveOneStep();
-}
-
-////// 停止勇士的一切行动，等待勇士行动结束后，再执行callback //////
-core.prototype.waitHeroToStop = function(callback) {
-    core.control.waitHeroToStop(callback);
-}
-
-////// 停止勇士的移动状态 //////
-core.prototype.stopHero = function () {
-    core.control.stopHero();
-}
-
-////// 绘制勇士 //////
-core.prototype.drawHero = function (direction, x, y, status, offset) {
-    core.control.drawHero(direction, x, y, status, offset);
-}
-
-////// 设置勇士的位置 //////
-core.prototype.setHeroLoc = function (itemName, itemVal, noGather) {
-    core.control.setHeroLoc(itemName, itemVal, noGather);
-}
-
-////// 获得勇士的位置 //////
-core.prototype.getHeroLoc = function (itemName) {
-    return core.control.getHeroLoc(itemName);
-}
-
-////// 获得勇士面对位置的x坐标 //////
-core.prototype.nextX = function(n) {
-    return core.control.nextX(n);
-}
-
-////// 获得勇士面对位置的y坐标 //////
-core.prototype.nextY = function (n) {
-    return core.control.nextY(n);
-}
-
-/////////// 自动行走 & 行走控制 END ///////////
-
-
-
-/////////// 地图处理 ///////////
-
-////// 开门 //////
-core.prototype.openDoor = function (id, x, y, needKey, callback) {
-    core.events.openDoor(id, x, y, needKey, callback);
-}
-
-////// 战斗 //////
-core.prototype.battle = function (id, x, y, force, callback) {
-    core.events.battle(id,x,y,force,callback);
-}
-
-////// 战斗完毕 //////
-core.prototype.afterBattle = function(id, x, y, callback) {
-    core.events.afterBattle(id, x, y, callback);
-}
-
-////// 触发(x,y)点的事件 //////
-core.prototype.trigger = function (x, y) {
-    core.events.trigger(x,y);
-}
-
-////// 楼层切换 //////
-core.prototype.changeFloor = function (floorId, stair, heroLoc, time, callback, fromLoad) {
-    core.events.changeFloor(floorId, stair, heroLoc, time, callback, fromLoad);
-}
-
-////// 清除地图 //////
-core.prototype.clearMap = function (map, x, y, width, height) {
-    core.ui.clearMap(map, x, y, width, height);
-}
-
-////// 在某个canvas上绘制一段文字 //////
-core.prototype.fillText = function (map, text, x, y, style, font) {
-    core.ui.fillText(map, text, x, y, style, font);
-}
-
-////// 在某个canvas上绘制一个矩形 //////
-core.prototype.fillRect = function (map, x, y, width, height, style) {
-    core.ui.fillRect(map, x, y, width, height, style)
-}
-
-////// 在某个canvas上绘制一个矩形的边框 //////
-core.prototype.strokeRect = function (map, x, y, width, height, style, lineWidth) {
-    core.ui.strokeRect(map, x, y, width, height, style, lineWidth)
-}
-
-////// 在某个canvas上绘制一条线 //////
-core.prototype.drawLine = function (map, x1, y1, x2, y2, style, lineWidth) {
-    core.ui.drawLine(map, x1, y1, x2, y2, style, lineWidth);
-}
-
-////// 设置某个canvas的文字字体 //////
-core.prototype.setFont = function (map, font) {
-    core.ui.setFont(map, font);
-}
-
-////// 设置某个canvas的线宽度 //////
-core.prototype.setLineWidth = function (map, lineWidth) {
-    core.ui.setLineWidth(map, lineWidth);
-}
-
-////// 保存某个canvas状态 //////
-core.prototype.saveCanvas = function (map) {
-    core.ui.saveCanvas(map);
-}
-
-////// 加载某个canvas状态 //////
-core.prototype.loadCanvas = function (map) {
-    core.ui.loadCanvas(map);
-}
-
-////// 设置某个canvas边框属性 //////
-core.prototype.setStrokeStyle = function (map, style) {
-    core.ui.setStrokeStyle(map, style);
-}
-
-////// 设置某个canvas的alpha值 //////
-core.prototype.setAlpha = function (map, alpha) {
-    core.ui.setAlpha(map, alpha);
-}
-
-////// 设置某个canvas的透明度 //////
-core.prototype.setOpacity = function (map, opacity) {
-    core.ui.setOpacity(map, opacity);
-}
-
-////// 设置某个canvas的绘制属性（如颜色等） //////
-core.prototype.setFillStyle = function (map, style) {
-    core.ui.setFillStyle(map, style);
-}
-
-core.prototype.drawBlock = function (block, animate, dx, dy) {
-    core.maps.drawBlock(block, animate, dx, dy);
-}
-
-////// 绘制某张地图 //////
-core.prototype.drawMap = function (mapName, callback) {
-    core.maps.drawMap(mapName, callback);
-}
-
-////// 绘制Autotile //////
-core.prototype.drawAutotile = function(ctx, mapArr, block, size, left, top){
-    core.maps.drawAutotile(ctx, mapArr, block, size, left, top);
-}
-
-////// 某个点是否不可通行 //////
-core.prototype.noPassExists = function (x, y, floorId) {
-    return core.maps.noPassExists(x,y,floorId);
-}
-
-////// 某个点是否在区域内且不可通行 //////
-core.prototype.noPass = function (x, y) {
-    return core.maps.noPass(x,y);
-}
-
-////// 某个点是否存在NPC //////
-core.prototype.npcExists = function (x, y, floorId) {
-    return core.maps.npcExists(x, y, floorId);
-}
-
-////// 某个点是否存在（指定的）地形 //////
-core.prototype.terrainExists = function (x, y, id, floorId) {
-    return core.maps.terrainExists(x, y, id, floorId);
-}
-
-////// 某个点是否存在楼梯 //////
-core.prototype.stairExists = function (x, y, floorId) {
-    return core.maps.stairExists(x, y, floorId);
-}
-
-////// 当前位置是否在楼梯边 //////
-core.prototype.nearStair = function() {
-    return core.maps.nearStair();
-}
-
-////// 某个点是否存在（指定的）怪物 //////
-core.prototype.enemyExists = function (x, y, id,floorId) {
-    return core.maps.enemyExists(x, y, id, floorId);
-}
-
-////// 获得某个点的block //////
-core.prototype.getBlock = function (x, y, floorId, showDisable) {
-    return core.maps.getBlock(x,y,floorId,showDisable);
-}
-
-////// 获得某个点的blockId //////
-core.prototype.getBlockId = function (x, y, floorId, showDisable) {
-    return core.maps.getBlockId(x, y, floorId, showDisable);
-}
-
-////// 获得某个点的blockCls //////
-core.prototype.getBlockCls = function (x, y, floorId, showDisable) {
-    return core.maps.getBlockCls(x, y, floorId, showDisable);
-}
-
-////// 显示移动某块的动画，达到{“type”:”move”}的效果 //////
-core.prototype.moveBlock = function(x,y,steps,time,keep,callback) {
-    core.maps.moveBlock(x,y,steps,time,keep,callback)
-}
-
-////// 显示跳跃某块的动画，达到{"type":"jump"}的效果 //////
-core.prototype.jumpBlock = function(sx,sy,ex,ey,time,keep,callback) {
-    core.maps.jumpBlock(sx,sy,ex,ey,time,keep,callback);
-}
-
-////// 显示/隐藏某个块时的动画效果 //////
-core.prototype.animateBlock = function (loc,type,time,callback) {
-    core.maps.animateBlock(loc,type,time,callback)
-}
-
-////// 将某个块从禁用变成启用状态 //////
-core.prototype.showBlock = function(x, y, floodId) {
-    core.maps.showBlock(x,y,floodId);
-}
-
-////// 将某个块从启用变成禁用状态 //////
-core.prototype.removeBlock = function (x, y, floorId) {
-    core.maps.removeBlock(x,y,floorId);
-}
-
-////// 根据block的索引删除该块 //////
-core.prototype.removeBlockById = function (index, floorId) {
-    core.maps.removeBlockById(index, floorId);
-}
-
-////// 一次性删除多个block //////
-core.prototype.removeBlockByIds = function (floorId, ids) {
-    core.maps.removeBlockByIds(floorId, ids);
-}
-
-////// 改变图块 //////
-core.prototype.setBlock = function (number, x, y, floorId) {
-    core.maps.setBlock(number, x, y, floorId);
-}
-
-////// 添加一个全局动画 //////
-core.prototype.addGlobalAnimate = function (block) {
-    core.maps.addGlobalAnimate(block);
-}
-
-////// 删除一个或所有全局动画 //////
-core.prototype.removeGlobalAnimate = function (x, y, all) {
-    core.maps.removeGlobalAnimate(x, y, all);
-}
-
-////// 设置全局动画的显示效果 //////
-core.prototype.setGlobalAnimate = function (speed) {
-    core.maps.setGlobalAnimate(speed);
-}
-
-////// 同步所有的全局动画效果 //////
-core.prototype.syncGlobalAnimate = function () {
-    core.maps.syncGlobalAnimate();
-}
-
-////// 绘制UI层的box动画 //////
-core.prototype.drawBoxAnimate = function () {
-    core.maps.drawBoxAnimate();
-}
-
-////// 绘制动画 //////
-core.prototype.drawAnimate = function (name, x, y, callback) {
-    core.maps.drawAnimate(name, x, y, callback);
-}
-
-////// 更新领域、夹击、阻击的伤害地图 //////
-core.prototype.updateCheckBlock = function() {
-    core.control.updateCheckBlock();
-}
-
-////// 检查并执行领域、夹击、阻击事件 //////
-core.prototype.checkBlock = function () {
-    core.control.checkBlock();
-}
-
-////// 阻击事件（动画效果） //////
-core.prototype.snipe = function (snipes) {
-    core.control.snipe(snipes);
-}
-
-////// 更改天气效果 //////
-core.prototype.setWeather = function (type, level) {
-    core.control.setWeather(type, level);
-}
-
-////// 更改画面色调 //////
-core.prototype.setFg = function(color, time, callback) {
-    core.control.setFg(color, time, callback);
-}
-
-////// 更新全地图显伤 //////
-core.prototype.updateFg = function () {
-    core.control.updateFg();
-}
-
-////// 测试是否拥有某个特殊属性 //////
-core.prototype.hasSpecial = function (special, test) {
-    return core.enemys.hasSpecial(special, test);
-}
-
-////// 判断能否战斗 //////
-core.prototype.canBattle = function(enemyId) {
-    return core.enemys.canBattle(enemyId);
-}
-
-////// 获得伤害数值 //////
-core.prototype.getDamage = function(enemy) {
-    return core.enemys.getDamage(enemy);
-}
-
-////// 获得某个物品的个数 //////
-core.prototype.itemCount = function (itemId) {
-    return core.items.itemCount(itemId);
-}
-
-////// 是否存在某个物品 //////
-core.prototype.hasItem = function (itemId) {
-    return core.items.hasItem(itemId);
-}
-
-////// 设置某个物品的个数 //////
-core.prototype.setItem = function (itemId, itemNum) {
-    core.items.setItem(itemId, itemNum);
-}
-
-////// 删除某个物品 //////
-core.prototype.removeItem = function (itemId) {
-    return core.items.removeItem(itemId);
-}
-
-////// 使用某个物品 //////
-core.prototype.useItem = function (itemId, callback) {
-    core.items.useItem(itemId, callback);
-}
-
-////// 能否使用某个物品 //////
-core.prototype.canUseItem = function (itemId) {
-    return core.items.canUseItem(itemId);
-}
-
-////// 增加某个物品的个数 //////
-core.prototype.addItem = function (itemId, itemNum) {
-    core.items.addItem(itemId, itemNum);
-}
-
-////// 获得面前的物品（轻按） //////
-core.prototype.getNextItem = function() {
-    core.events.getNextItem();
-}
-
-////// 获得某个物品 //////
-core.prototype.getItem = function (itemId, itemNum, itemX, itemY, callback) {
-    core.events.getItem(itemId, itemNum, itemX, itemY, callback);
-}
-
-////// 左上角绘制一段提示 //////
-core.prototype.drawTip = function (text, itemIcon) {
-    core.ui.drawTip(text, itemIcon);
-}
-
-////// 地图中间绘制一段文字 //////
-core.prototype.drawText = function (contents, callback) {
-    core.ui.drawText(contents, callback);
-}
-
-/////////// 地图相关 END ///////////
-
-
-
-
-/////////// 系统机制 ///////////
-
-////// 将文字中的${和}（表达式）进行替换 //////
-core.prototype.replaceText = function (text) {
-    return core.utils.replaceText(text);
-}
-
-////// 计算表达式的值 //////
-core.prototype.calValue = function (value) {
-    return core.utils.calValue(value);
-}
-
-////// 执行一个表达式的effect操作 //////
-core.prototype.doEffect = function (expression) {
-    core.control.doEffect(expression);
-}
-
-////// 字符串自动换行的分割 //////
-core.prototype.splitLines = function(canvas, text, maxLength, font) {
-    return core.utils.splitLines(canvas, text, maxLength, font);
-}
-
-////// 向某个数组前插入另一个数组或元素 //////
-core.prototype.unshift = function (a,b) {
-    return core.utils.unshift(a,b);
-}
-
-////// 设置本地存储 //////
-core.prototype.setLocalStorage = function(key, value) {
-    return core.utils.setLocalStorage(key, value);
-}
-
-////// 获得本地存储 //////
-core.prototype.getLocalStorage = function(key, defaultValue) {
-    return core.utils.getLocalStorage(key, defaultValue);
-}
-
-////// 移除本地存储 //////
-core.prototype.removeLocalStorage = function (key) {
-    core.utils.removeLocalStorage(key);
-}
-
-////// 深拷贝一个对象 //////
-core.prototype.clone = function (data) {
-    return core.utils.clone(data);
-}
-
-////// 裁剪图片 //////
-core.prototype.cropImage = function (image, size) {
-    return core.utils.cropImage(image, size);
-}
-
-////// 格式化时间为字符串 //////
-core.prototype.formatDate = function(date) {
-    return core.utils.formatDate(date);
-}
-
-////// 格式化时间为最简字符串 //////
-core.prototype.formatDate2 = function (date) {
-    return core.utils.formatDate2(date);
-}
-
-////// 格式化大数 //////
-core.prototype.formatBigNumber = function (x) {
-    return core.utils.formatBigNumber(x);
-}
-
-////// 两位数显示 //////
-core.prototype.setTwoDigits = function (x) {
-    return core.utils.setTwoDigits(x);
-}
-
-////// 数组转RGB //////
-core.prototype.arrayToRGB = function (color) {
-    return core.utils.arrayToRGB(color);
-}
-
-////// 作弊 //////
-core.prototype.debug = function() {
-    core.control.debug();
-}
-
-////// 存档前 //////
-core.prototype.beforeSaveData = function (data) {
-    return core.events.beforeSaveData(data);
-}
-
-////// 读档后 //////
-core.prototype.afterLoadData = function (data) {
-    return core.events.afterLoadData(data);
-}
-
-////// 重置当前地图 //////
-core.prototype.resetMap = function(floorId) {
-    core.maps.resetMap(floorId);
-}
-
-////// 开始播放 //////
-core.prototype.startReplay = function (list) {
-    core.control.startReplay(list);
-}
-
-////// 关闭UI窗口 //////
-core.prototype.closePanel = function () {
-    core.ui.closePanel();
-}
-
-////// 更改播放状态 //////
-core.prototype.triggerReplay = function () {
-    core.control.triggerReplay();
-}
-
-////// 暂停播放 //////
-core.prototype.pauseReplay = function () {
-    core.control.pauseReplay();
-}
-
-////// 恢复播放 //////
-core.prototype.resumeReplay = function () {
-    core.control.resumeReplay();
-}
-
-////// 加速播放 //////
-core.prototype.speedUpReplay = function () {
-    core.control.speedUpReplay();
-}
-
-////// 减速播放 //////
-core.prototype.speedDownReplay = function () {
-    core.control.speedDownReplay();
-}
-
-////// 回退播放 //////
-core.prototype.rewindReplay = function () {
-    core.control.rewindReplay();
-}
-
-////// 停止播放 //////
-core.prototype.stopReplay = function () {
-    core.control.stopReplay();
-}
-
-////// 回放时存档 //////
-core.prototype.saveReplay = function () {
-    core.control.saveReplay();
-}
-
-////// 回放时查看怪物手册 //////
-core.prototype.bookReplay = function () {
-    core.control.bookReplay();
-}
-
-////// 回放录像时浏览地图 //////
-core.prototype.viewMapReplay = function () {
-    core.control.viewMapReplay();
-}
-
-////// 回放 //////
-core.prototype.replay = function () {
-    core.control.replay();
-}
-
-////// 判断当前能否进入某个事件 //////
-core.prototype.checkStatus = function (name, need, item) {
-    return core.control.checkStatus(name, need, item);
-}
-
-////// 点击怪物手册时的打开操作 //////
-core.prototype.openBook = function (need) {
-    core.control.openBook(need);
-}
-
-////// 点击楼层传送器时的打开操作 //////
-core.prototype.useFly = function (need) {
-    core.control.useFly(need);
-}
-
-////// 点击工具栏时的打开操作 //////
-core.prototype.openToolbox = function (need) {
-    core.control.openToolbox(need);
-}
-
-////// 点击快捷商店按钮时的打开操作 //////
-core.prototype.openQuickShop = function (need) {
-    core.control.openQuickShop(need);
-}
-
-////// 点击保存按钮时的打开操作 //////
-core.prototype.save = function(need) {
-    core.control.save(need);
-}
-
-////// 点击读取按钮时的打开操作 //////
-core.prototype.load = function (need) {
-    core.control.load(need);
-}
-
-////// 点击设置按钮时的操作 //////
-core.prototype.openSettings = function (need) {
-    core.control.openSettings(need);
-}
-
-////// 自动存档 //////
-core.prototype.autosave = function (removeLast) {
-    core.control.autosave(removeLast);
-}
-
-////// 实际进行存读档事件 //////
-core.prototype.doSL = function (id, type) {
-    core.control.doSL(id, type);
-}
-
-////// 同步存档到服务器 //////
-core.prototype.syncSave = function (type) {
-    core.control.syncSave(type);
-}
-
-////// 从服务器加载存档 //////
-core.prototype.syncLoad = function () {
-    core.control.syncLoad();
-}
-
-////// 存档到本地 //////
-core.prototype.saveData = function() {
-    return core.control.saveData();
-}
-
-////// 从本地读档 //////
-core.prototype.loadData = function (data, callback) {
-    core.control.loadData(data, callback);
-}
-
-////// 加密路线 //////
-core.prototype.encodeRoute = function (route) {
-    return core.utils.encodeRoute(route);
-}
-
-////// 解密路线 //////
-core.prototype.decodeRoute = function (route) {
-    return core.utils.decodeRoute(route);
-}
-
-////// 发送HTTP //////
-core.prototype.http = function (type, url, formData, success, error, mimeType, responseType) {
-    core.utils.http(type, url, formData, success, error, mimeType, responseType)
-}
-
-////// 设置勇士属性 //////
-core.prototype.setStatus = function (statusName, statusVal) {
-    core.control.setStatus(statusName, statusVal);
-}
-
-////// 获得勇士属性 //////
-core.prototype.getStatus = function (statusName) {
-    return core.control.getStatus(statusName);
-}
-
-////// 获得某个等级的名称 //////
-core.prototype.getLvName = function () {
-    return core.control.getLvName();
-}
-
-////// 设置某个自定义变量或flag //////
-core.prototype.setFlag = function(flag, value) {
-    core.control.setFlag(flag, value);
-}
-
-////// 获得某个自定义变量或flag //////
-core.prototype.getFlag = function(flag, defaultValue) {
-    return core.control.getFlag(flag, defaultValue);
-}
-
-////// 是否存在某个自定义变量或flag，且值为true //////
-core.prototype.hasFlag = function(flag) {
-    return core.control.hasFlag(flag);
-}
-
-core.prototype.doAction = function() {
-    core.events.doAction();
-}
-
-////// 往当前事件列表之前插入一系列事件 //////
-core.prototype.insertAction = function (list, x, y, callback) {
-    core.events.insertAction(list, x, y, callback);
-}
-
-////// 锁定状态栏，常常用于事件处理 //////
-core.prototype.lockControl = function () {
-    core.control.lockControl();
-}
-
-////// 解锁状态栏 //////
-core.prototype.unLockControl = function () {
-    core.control.unLockControl();
-}
-
-////// 判断某对象是否不为undefined也不会null //////
-core.prototype.isset = function (val) {
-    return core.utils.isset(val);
-}
-
-////// 获得子数组 //////
-core.prototype.subarray = function (a, b) {
-    return core.utils.subarray(a, b);
-}
-
-core.prototype.clamp = function (x, a, b) {
-    return core.utils.clamp(x, a, b);
-}
-
-////// Base64加密 //////
-core.prototype.encodeBase64 = function (str) {
-    return core.utils.encodeBase64(str);
-}
-
-////// Base64解密 //////
-core.prototype.decodeBase64 = function (str) {
-    return core.utils.decodeBase64(str);
-}
-
-////// 生成随机数（seed方法） //////
-core.prototype.rand = function (num) {
-    return core.utils.rand(num);
-}
-
-////// 生成随机数（录像方法） //////
-core.prototype.rand2 = function (num) {
-    return core.utils.rand2(num);
-}
-
-////// 读取一个本地文件内容 //////
-core.prototype.readFile = function (success, error, readType) {
-    core.utils.readFile(success, error, readType);
-}
-
-////// 读取本地文件完毕 //////
-core.prototype.readFileContent = function (content) {
-    core.utils.readFileContent(content);
-}
-
-////// 下载文件到本地 //////
-core.prototype.download = function (filename, content) {
-    core.utils.download(filename, content);
-}
-
-////// 复制一段内容到剪切板 //////
-core.prototype.copy = function (data) {
-    return core.utils.copy(data);
-}
-
-////// 播放背景音乐 //////
-core.prototype.playBgm = function (bgm) {
-    core.control.playBgm(bgm);
-}
-
-////// 暂停背景音乐的播放 //////
-core.prototype.pauseBgm = function () {
-    core.control.pauseBgm();
-}
-
-////// 恢复背景音乐的播放 //////
-core.prototype.resumeBgm = function () {
-    core.control.resumeBgm();
-}
-
-////// 播放音频 //////
-core.prototype.playSound = function (sound) {
-    core.control.playSound(sound);
-}
-
-////// 动画显示某对象 //////
-core.prototype.show = function (obj, speed, callback) {
-    core.utils.show(obj, speed, callback);
-}
-
-////// 动画使某对象消失 //////
-core.prototype.hide = function (obj, speed, callback) {
-    core.utils.hide(obj, speed, callback);
-}
-
-////// 清空状态栏 //////
-core.prototype.clearStatusBar = function() {
-    core.control.clearStatusBar();
-}
-
-////// 更新状态栏 //////
-core.prototype.updateStatusBar = function () {
-    core.control.updateStatusBar();
-}
-
-////// 屏幕分辨率改变后重新自适应 //////
-core.prototype.resize = function(clientWidth, clientHeight) {
-    core.control.resize(clientWidth, clientHeight);
-}
-
-////// 渲染DOM //////
-core.prototype.domRenderer = function(){
-    core.control.domRenderer();
+    core.loadImage('fog', function (name, img) { core.animateFrame.weather.fog = img; });
+    core.loadImage('keyboard', function (name, img) {core.material.images.keyboard = img; });
+    // 记录存档编号
+    core.saves.saveIndex = core.getLocalStorage('saveIndex', 1);
+    core.control.getSaveIndexes(function (indexes) { core.saves.ids = indexes; });
+}
+
+core.prototype._afterLoadResources = function (callback) {
+    // 初始化地图
+    core.initStatus.maps = core.maps._initMaps();
+    core.control._setRequestAnimationFrame();
+    if (core.plugin._afterLoadResources)
+        core.plugin._afterLoadResources();
+    core.showStartAnimate();
+    if (callback) callback();
+}
+
+core.prototype._initPlugins = function () {
+    core.plugin = new function () {};
+
+    for (var name in plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1) {
+        if (plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1[name] instanceof Function) {
+            try {
+                plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1[name].apply(core.plugin);
+            }
+            catch (e) {
+                main.log(e);
+                main.log("无法初始化插件"+name);
+            }
+        }
+    }
+
+    core._forwardFunc("plugin");
+}
+
+core.prototype._forwardFuncs = function () {
+    for (var i = 0; i < main.loadList.length; ++i) {
+        var name = main.loadList[i];
+        if (name == 'core') continue;
+        this._forwardFunc(name);
+    }
+}
+
+core.prototype._forwardFunc = function (name, funcname) {
+    if (funcname == null) {
+        for (funcname in core[name]) {
+            if (funcname.charAt(0) != "_" && core[name][funcname] instanceof Function) {
+                this._forwardFunc(name, funcname);
+            }
+        }
+        return;
+    }
+
+    if (core[funcname]) {
+        console.error("ERROR: 无法转发 "+name+" 中的函数 "+funcname+" 到 core 中！同名函数已存在。");
+        return;
+    }
+    var parameterInfo = /^\s*function\s*[\w_$]*\(([\w_,$\s]*)\)\s*\{/.exec(core[name][funcname].toString());
+    var parameters = (parameterInfo == null ? "" : parameterInfo[1]).replace(/\s*/g, '').replace(/,/g, ', ');
+    // core[funcname] = new Function(parameters, "return core."+name+"."+funcname+"("+parameters+");");
+    eval("core." + funcname + " = function (" + parameters + ") {\n\treturn core." + name + "." + funcname + "(" + parameters + ");\n}");
+    if (name == 'plugin') {
+        main.log("插件函数转发：core."+funcname+" = core.plugin."+funcname);
+    }
+}
+
+core.prototype.doFunc = function (func, _this) {
+    if (typeof func == 'string') {
+        func = core.plugin[func];
+        _this = core.plugin;
+    }
+    return func.apply(_this, Array.prototype.slice.call(arguments, 2));
 }
 
 /**
diff --git a/libs/data.js b/libs/data.js
index 965c3014..684e71cb 100644
--- a/libs/data.js
+++ b/libs/data.js
@@ -1,14 +1,12 @@
+"use strict";
+
 function data() {
-    this.init();
+    this._init();
 }
 
-data.prototype.init = function() {
+data.prototype._init = function () {
     this.firstData = data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.firstData;
     this.values = data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.values;
     this.flags = data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.flags;
     //delete(data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d);
-}
-
-data.prototype.getFirstData = function() {
-    return core.clone(this.firstData);
 }
\ No newline at end of file
diff --git a/libs/enemys.js b/libs/enemys.js
index d7e0d5d0..70e8263b 100644
--- a/libs/enemys.js
+++ b/libs/enemys.js
@@ -1,40 +1,44 @@
+"use strict";
+
 function enemys() {
-    this.init();
+    this._init();
 }
 
 ////// 初始化 //////
-enemys.prototype.init = function () {
+enemys.prototype._init = function () {
     this.enemys = enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80;
     this.enemydata = functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a.enemys;
-    if (main.mode=='play') this.enemydata.hasSpecial = function (a, b) {return core.enemys.hasSpecial(a, b)};
+    if (main.mode == 'play') {
+        this.enemydata.hasSpecial = function (a, b) {
+            return core.enemys.hasSpecial(a, b)
+        };
+        for (var enemyId in this.enemys) {
+            this.enemys[enemyId].id = enemyId;
+        }
+    }
 }
 
-////// 获得一个或所有怪物数据 //////
-enemys.prototype.getEnemys = function (enemyId) {
-    if (!core.isset(enemyId)) {
-        return this.enemys;
-    }
-    return this.enemys[enemyId];
+enemys.prototype.getEnemys = function () {
+    return core.clone(this.enemys);
 }
 
 ////// 判断是否含有某特殊属性 //////
 enemys.prototype.hasSpecial = function (special, test) {
-
-    if (!core.isset(special)) return false;
+    if (special == null) return false;
 
     if (special instanceof Array) {
-        return special.indexOf(test)>=0;
+        return special.indexOf(test) >= 0;
     }
 
     if (typeof special == 'number') {
-        return special!=0 && (special%100==test||this.hasSpecial(parseInt(special/100), test));
+        return special === test;
     }
 
     if (typeof special == 'string') {
         return this.hasSpecial(core.material.enemys[special], test);
     }
 
-    if (core.isset(special.special)) {
+    if (special.special != null) {
         return this.hasSpecial(special.special, test);
     }
 
@@ -45,29 +49,18 @@ enemys.prototype.getSpecials = function () {
     return this.enemydata.getSpecials();
 }
 
-enemys.prototype.calContent = function (enemy, content) {
-    if (typeof enemy == 'string') enemy = core.material.enemys[enemy];
-    if (typeof content == 'string') return content;
-    if (content instanceof Function) {
-        return content(enemy);
-    }
-    return "";
-}
-
 ////// 获得所有特殊属性的名称 //////
 enemys.prototype.getSpecialText = function (enemy) {
-    // 移动到了脚本编辑 - getSpecials中
-
     if (typeof enemy == 'string') enemy = core.material.enemys[enemy];
-    if (!core.isset(enemy)) return [];
+    if (!enemy) return [];
     var special = enemy.special;
     var text = [];
 
-    var specials=this.getSpecials();
-    if (core.isset(specials)) {
-        for (var i=0;i<specials.length;i++) {
+    var specials = this.getSpecials();
+    if (specials) {
+        for (var i = 0; i < specials.length; i++) {
             if (this.hasSpecial(special, specials[i][0]))
-                text.push(this.calContent(enemy, specials[i][1]));
+                text.push(this._calSpecialContent(enemy, specials[i][1]));
         }
     }
     return text;
@@ -75,144 +68,233 @@ enemys.prototype.getSpecialText = function (enemy) {
 
 ////// 获得每个特殊属性的说明 //////
 enemys.prototype.getSpecialHint = function (enemy, special) {
-    // 移动到了脚本编辑 - getSpecials中
+    var specials = this.getSpecials();
 
-    if (typeof enemy == 'string') enemy = core.material.enemys[enemy];
-    var specials=this.getSpecials();
-
-    if (!core.isset(special)) {
-        if (!core.isset(specials)) return [];
+    if (special == null) {
+        if (specials == null) return [];
         var hints = [];
-        for (var i=0;i<specials.length;i++) {
+        for (var i = 0; i < specials.length; i++) {
             if (this.hasSpecial(enemy, specials[i][0]))
-                hints.push(this.calContent(enemy, specials[i][1])+"："+this.calContent(enemy, specials[i][2]));
+                hints.push(this._calSpecialContent(enemy, specials[i][1]) + "：" + this._calSpecialContent(enemy, specials[i][2]));
         }
         return hints;
     }
 
-    if (!core.isset(specials)) return "";
-    for (var i=0;i<specials.length;i++) {
+    if (specials == null) return "";
+    for (var i = 0; i < specials.length; i++) {
         if (special == specials[i][0])
-            return this.calContent(enemy, specials[i][1])+"："+this.calContent(enemy, specials[i][2]);
+            return this._calSpecialContent(enemy, specials[i][1]) + "：" + this._calSpecialContent(enemy, specials[i][2]);
+    }
+    return "";
+}
+
+enemys.prototype._calSpecialContent = function (enemy, content) {
+    if (typeof content == 'string') return content;
+    if (typeof enemy == 'string') enemy = core.material.enemys[enemy];
+    if (content instanceof Function) {
+        return content(enemy);
     }
     return "";
 }
 
 ////// 能否获胜 //////
-enemys.prototype.canBattle = function (enemyId) {
-    var damage = this.getDamage(enemyId);
+enemys.prototype.canBattle = function (enemy, x, y, floorId) {
+    if (typeof enemy == 'string') enemy = core.material.enemys[enemy];
+    var damage = this.getDamage(enemy, x, y, floorId);
     return damage != null && damage < core.status.hero.hp;
 }
 
 ////// 获得某个怪物的伤害 //////
-enemys.prototype.getDamage = function (enemy) {
+enemys.prototype.getDamage = function (enemy, x, y, floorId) {
     if (typeof enemy == 'string') enemy = core.material.enemys[enemy];
-    var damage = this.calDamage(enemy, core.status.hero.hp, core.status.hero.atk, core.status.hero.def, core.status.hero.mdef);
+    var damage = this._calDamage(enemy, null, x, y, floorId);
     if (damage == null) return null;
-    return damage + this.getExtraDamage(enemy);
+    return damage + this.getExtraDamage(enemy, x, y, floorId);
 }
 
 ////// 获得某个怪物的额外伤害 //////
-enemys.prototype.getExtraDamage = function (enemy) {
+enemys.prototype.getExtraDamage = function (enemy, x, y, floorId) {
     if (typeof enemy == 'string') enemy = core.material.enemys[enemy];
     var extra_damage = 0;
     if (this.hasSpecial(enemy.special, 17)) { // 仇恨
         extra_damage += core.getFlag('hatred', 0);
     }
     if (this.hasSpecial(enemy.special, 22)) { // 固伤
-        extra_damage += enemy.damage||0;
+        extra_damage += enemy.damage || 0;
     }
     return extra_damage;
 }
 
-////// 接下来N个临界值和临界减伤计算 //////
-enemys.prototype.nextCriticals = function (enemy, number) {
+enemys.prototype.getDamageString = function (enemy, x, y, floorId) {
     if (typeof enemy == 'string') enemy = core.material.enemys[enemy];
+    var damage = this.getDamage(enemy, x, y, floorId);
 
-    var useTurn = !core.flags.useLoop; // 是否使用回合法计算临界值；如果要用循环法，则直接改为false。
+    var color = '#000000';
 
-    number = number||1;
+    if (damage == null) {
+        damage = "???";
+        color = '#FF0000';
+    }
+    else {
+        if (damage <= 0) color = '#00FF00';
+        else if (damage < core.status.hero.hp / 3) color = '#FFFFFF';
+        else if (damage < core.status.hero.hp * 2 / 3) color = '#FFFF00';
+        else if (damage < core.status.hero.hp) color = '#FF7F00';
+        else color = '#FF0000';
 
-    if (this.hasSpecial(enemy.special, 3)) {
-        if (core.status.hero.atk<=enemy.def) {
-            return [[enemy.def+1-core.status.hero.atk,'?']];
+        damage = core.formatBigNumber(damage, true);
+        if (core.enemys.hasSpecial(enemy, 19))
+            damage += "+";
+        if (core.enemys.hasSpecial(enemy, 21))
+            damage += "-";
+        if (core.enemys.hasSpecial(enemy, 11))
+            damage += "^";
+    }
+
+    return {
+        "damage": damage,
+        "color": color
+    };
+}
+
+////// 接下来N个临界值和临界减伤计算 //////
+enemys.prototype.nextCriticals = function (enemy, number, x, y, floorId) {
+    if (typeof enemy == 'string') enemy = core.material.enemys[enemy];
+    number = number || 1;
+
+    if (this.hasSpecial(enemy.special, 10)) return []; // 模仿怪物临界
+    var info = this.getDamageInfo(enemy, null, x, y, floorId);
+    if (info == null || this.hasSpecial(enemy.special, 3)) { // 未破防，或是坚固怪
+        info = this.getEnemyInfo(enemy, null, x, y, floorId);
+        if (core.status.hero.atk <= info.def) {
+            return [[info.def + 1 - core.status.hero.atk, '?']];
         }
         return [];
     }
 
-    // 坚固、模仿怪物没有临界！
-    if (this.hasSpecial(enemy.special, 10)) return [];
-    var info = this.getDamageInfo(enemy, core.status.hero.hp, core.status.hero.atk, core.status.hero.def, core.status.hero.mdef);
+    // getDamageInfo直接返回数字；0伤且无负伤
+    if (typeof info == 'number' || (info.damage <= 0 && !core.flags.enableNegativeDamage)) {
+        return [[0, 0]];
+    }
 
-    if (info == null) {
-        if (core.status.hero.atk<=enemy.def) {
-            return [[enemy.def+1-core.status.hero.atk,'?']];
+    if (core.flags.useLoop) {
+        var LOOP_MAX_VALUE = 1;
+        if (core.status.hero.atk <= LOOP_MAX_VALUE) {
+            return this._nextCriticals_useLoop(enemy, info, number, x, y, floorId);
+        }
+        else {
+            return this._nextCriticals_useBinarySearch(enemy, info, number, x, y, floorId);
         }
-        return [];
     }
-
-    if (info.damage<=0 && !core.flags.enableNegativeDamage) {
-        return [[0,0]];
+    else {
+        return this._nextCriticals_useTurn(enemy, info, number, x, y, floorId);
     }
+}
 
+enemys.prototype._nextCriticals_useLoop = function (enemy, info, number, x, y, floorId) {
+    var mon_hp = info.mon_hp, hero_atk = core.status.hero.atk, mon_def = info.mon_def, pre = info.damage;
+    var list = [];
+    for (var atk = hero_atk + 1; atk <= mon_hp + mon_def; atk++) {
+        var nextInfo = this.getDamageInfo(enemy, {"atk": atk}, x, y, floorId);
+        if (nextInfo == null || (typeof nextInfo == 'number')) break;
+        if (pre > nextInfo.damage) {
+            pre = nextInfo.damage;
+            list.push([atk - hero_atk, info.damage - nextInfo.damage]);
+            if (nextInfo.damage <= 0 && !core.flags.enableNegativeDamage) break;
+            if (list.length >= number) break;
+        }
+    }
+    if (list.length == 0) list.push([0, 0]);
+    return list;
+}
+
+enemys.prototype._nextCriticals_useBinarySearch = function (enemy, info, number, x, y, floorId) {
+    var mon_hp = info.mon_hp, hero_atk = core.status.hero.atk, mon_def = info.mon_def, pre = info.damage;
+    var list = [];
+    var calNext = function (currAtk, maxAtk) {
+        var start = Math.floor(currAtk), end = Math.floor(maxAtk);
+        if (start > end) return null;
+
+        while (start < end) {
+            var mid = Math.floor((start + end) / 2);
+            var nextInfo = core.enemys.getDamageInfo(enemy, {"atk": mid}, x, y, floorId);
+            if (nextInfo == null || (typeof nextInfo == 'number')) return null;
+            if (pre > nextInfo.damage) end = mid;
+            else start = mid + 1;
+        }
+        var nextInfo = core.enemys.getDamageInfo(enemy, {"atk": start}, x, y, floorId);
+        return nextInfo == null || (typeof nextInfo == 'number') || nextInfo.damage >= pre ? null : [start, nextInfo.damage];
+    }
+    var currAtk = hero_atk;
+    while (true) {
+        var next = calNext(currAtk + 1, mon_hp + mon_def, pre);
+        if (next == null) break;
+        currAtk = next[0];
+        pre = next[1];
+        list.push([currAtk - hero_atk, info.damage - pre]);
+        if (pre <= 0 && !core.flags.enableNegativeDamage) break;
+        if (list.length >= number) break;
+    }
+    if (list.length == 0) list.push([0, 0]);
+    return list;
+}
+
+enemys.prototype._nextCriticals_useTurn = function (enemy, info, number, x, y, floorId) {
+    var mon_hp = info.mon_hp, hero_atk = core.status.hero.atk, mon_def = info.mon_def, turn = info.turn;
+    // ------ 超大回合数强制使用二分算临界
+    // 以避免1攻10e回合，2攻5e回合导致下述循环卡死问题
+    if (turn >= 1e6) { // 100w回合以上强制二分计算临界
+        return this._nextCriticals_useBinarySearch(enemy, info, number, x, y, floorId);
+    }
     var list = [], pre = null;
-    var mon_hp = info.mon_hp, hero_atk = core.status.hero.atk, mon_def = enemy.def, turn = info.turn;
-
-    if (useTurn) { // 回合数计算法
-        for (var t = turn-1;t>=1;t--) {
-            var nextAtk = Math.ceil(mon_hp/t) + mon_def;
-            if (nextAtk<=hero_atk) break;
-            if (nextAtk!=pre) {
-                var nextInfo = this.getDamageInfo(enemy, core.status.hero.hp, nextAtk, core.status.hero.def, core.status.hero.mdef);
-                if (nextInfo==null) break;
-                list.push([nextAtk-hero_atk,info.damage-nextInfo.damage]);
-                if (nextInfo.damage<=0 && !core.flags.enableNegativeDamage) break;
-                pre = nextAtk;
-            }
-            if (list.length>=number)
-                break;
+    for (var t = turn - 1; t >= 1; t--) {
+        var nextAtk = Math.ceil(mon_hp / t) + mon_def;
+        // 装备提升比例的计算临界
+        nextAtk = Math.ceil(nextAtk / core.getBuff('atk'));
+        if (nextAtk <= hero_atk) break;
+        if (nextAtk != pre) {
+            var nextInfo = this.getDamageInfo(enemy, {"atk": nextAtk}, x, y, floorId);
+            if (nextInfo == null || (typeof nextInfo == 'number')) break;
+            list.push([nextAtk - hero_atk, Math.floor(info.damage - nextInfo.damage)]);
+            if (nextInfo.damage <= 0 && !core.flags.enableNegativeDamage) break;
+            pre = nextAtk;
         }
+        if (list.length >= number)
+            break;
     }
-    else { // 暴力for循环法
-        pre = info.damage;
-        for (var atk=hero_atk+1;atk<=mon_hp+mon_def;atk++) {
-            var nextInfo = this.getDamageInfo(enemy, core.status.hero.hp, atk, core.status.hero.def, core.status.hero.mdef);
-            if (nextInfo==null) break;
-            if (pre>nextInfo.damage) {
-                pre = nextInfo.damage;
-                list.push([atk-hero_atk, info.damage-nextInfo.damage]);
-                if (nextInfo.damage<=0 && !core.flags.enableNegativeDamage) break;
-                if (list.length>=number) break;
-            }
-        }
-    }
-    if (list.length==0) list.push([0,0]);
+    if (list.length == 0) list.push([0, 0]);
     return list;
 }
 
 ////// N防减伤计算 //////
-enemys.prototype.getDefDamage = function (enemy, k) {
+enemys.prototype.getDefDamage = function (enemy, k, x, y, floorId) {
     if (typeof enemy == 'string') enemy = core.material.enemys[enemy];
     k = k || 1;
-    var nowDamage = this.calDamage(enemy, core.status.hero.hp, core.status.hero.atk, core.status.hero.def, core.status.hero.mdef);
-    var nextDamage = this.calDamage(enemy, core.status.hero.hp, core.status.hero.atk, core.status.hero.def + k, core.status.hero.mdef);
-    if (nowDamage == null || nextDamage ==null) return "???";
+    var nowDamage = this._calDamage(enemy, null, x, y, floorId);
+    var nextDamage = this._calDamage(enemy, {"def": core.status.hero.def + k}, x, y, floorId);
+    if (nowDamage == null || nextDamage == null) return "???";
     return nowDamage - nextDamage;
 }
 
+enemys.prototype.getEnemyInfo = function (enemy, hero, x, y, floorId) {
+    if (typeof enemy == 'string') enemy = core.material.enemys[enemy];
+    return this.enemydata.getEnemyInfo(enemy, hero, x, y, floorId)
+}
+
 ////// 获得战斗伤害信息（实际伤害计算函数） //////
-enemys.prototype.getDamageInfo = function(enemy, hero_hp, hero_atk, hero_def, hero_mdef) {
+enemys.prototype.getDamageInfo = function (enemy, hero, x, y, floorId) {
     // 移动到了脚本编辑 - getDamageInfo中
     if (typeof enemy == 'string') enemy = core.material.enemys[enemy];
-    return this.enemydata.getDamageInfo(enemy, hero_hp, hero_atk, hero_def, hero_mdef);
+    return this.enemydata.getDamageInfo(enemy, hero, x, y, floorId);
 }
 
 ////// 获得在某个勇士属性下怪物伤害 //////
-enemys.prototype.calDamage = function (enemy, hero_hp, hero_atk, hero_def, hero_mdef) {
+enemys.prototype._calDamage = function (enemy, hero, x, y, floorId) {
     if (typeof enemy == 'string') enemy = core.material.enemys[enemy];
 
-    var info = this.getDamageInfo(enemy, hero_hp, hero_atk, hero_def, hero_mdef);
+    var info = this.getDamageInfo(enemy, hero, x, y, floorId);
     if (info == null) return null;
+    if (typeof info == 'number') return info;
     return info.damage;
 }
 
@@ -223,53 +305,52 @@ enemys.prototype.updateEnemys = function () {
 
 ////// 获得当前楼层的怪物列表 //////
 enemys.prototype.getCurrentEnemys = function (floorId) {
-    floorId=floorId||core.status.floorId;
-    var enemys = [];
-    var used = {};
+    floorId = floorId || core.status.floorId;
+    var enemys = [], used = {};
     var mapBlocks = core.status.maps[floorId].blocks;
     for (var b = 0; b < mapBlocks.length; b++) {
-        if (core.isset(mapBlocks[b].event) && !mapBlocks[b].disable
-            && mapBlocks[b].event.cls.indexOf('enemy')==0) {
-            var enemyId = mapBlocks[b].event.id;
-            if (core.isset(used[enemyId])) continue;
-
-            var enemy = core.material.enemys[enemyId];
-            var mon_hp = enemy.hp, mon_atk = enemy.atk, mon_def = enemy.def;
-            if (this.hasSpecial(enemy.special, 10)) {
-                mon_atk=core.status.hero.atk;
-                mon_def=core.status.hero.def;
-            }
-            if (this.hasSpecial(enemy.special, 3) && mon_def < core.status.hero.atk - 1)
-                mon_def = core.status.hero.atk - 1;
-
-            var specialText = core.enemys.getSpecialText(enemyId);
-            if (specialText.length>=3) specialText = "多属性...";
-            else specialText = specialText.join("  ");
-
-            var critical = this.nextCriticals(enemyId);
-            if (critical.length>0) critical=critical[0];
-
-            enemys.push({
-                'id': enemyId,
-                'name': enemy.name,
-                'hp': mon_hp,
-                'atk': mon_atk,
-                'def': mon_def,
-                'money': enemy.money,
-                'experience': enemy.experience,
-                'point': enemy.point||0, // 加点
-                'special': specialText,
-                'damage': this.getDamage(enemyId),
-                'critical': critical[0],
-                'criticalDamage': critical[1],
-                'defDamage': this.getDefDamage(enemyId)
-            });
-
-            used[enemyId] = true;
+        if (!mapBlocks[b].disable && mapBlocks[b].event.cls.indexOf('enemy') == 0) {
+            this._getCurrentEnemys_addEnemy(mapBlocks[b].event.id, enemys, used, floorId);
         }
     }
+    return this._getCurrentEnemys_sort(enemys);
+}
 
-    enemys.sort(function (a, b) {
+enemys.prototype._getCurrentEnemys_getEnemy = function (enemyId) {
+    var enemy = core.material.enemys[enemyId];
+    if (!enemy) return null;
+
+    // 检查displayIdInBook
+    return core.material.enemys[enemy.displayIdInBook] || enemy;
+}
+
+enemys.prototype._getCurrentEnemys_addEnemy = function (enemyId, enemys, used, floorId) {
+    var enemy = this._getCurrentEnemys_getEnemy(enemyId);
+    if (enemy == null || used[enemy.id]) return;
+
+    var enemyInfo = this.getEnemyInfo(enemy, null, null, null, floorId);
+    var specialText = core.enemys.getSpecialText(enemy);
+    if (specialText.length >= 3) specialText = "多属性...";
+    else specialText = specialText.join("  ");
+
+    var critical = this.nextCriticals(enemy, 1, null, null, floorId);
+    if (critical.length > 0) critical = critical[0];
+
+    var e = core.clone(enemy);
+    for (var x in enemyInfo) {
+        e[x] = enemyInfo[x];
+    }
+    e.specialText = specialText;
+    e.damage = this.getDamage(enemy, null, null, floorId);
+    e.critical = critical[0];
+    e.criticalDamage = critical[1];
+    e.defDamage = this.getDefDamage(enemy, 1, null, null, floorId);
+    enemys.push(e);
+    used[enemy.id] = true;
+}
+
+enemys.prototype._getCurrentEnemys_sort = function (enemys) {
+    return enemys.sort(function (a, b) {
         if (a.damage == b.damage) {
             return a.money - b.money;
         }
@@ -281,5 +362,18 @@ enemys.prototype.getCurrentEnemys = function (floorId) {
         }
         return a.damage - b.damage;
     });
-    return enemys;
+}
+
+enemys.prototype.hasEnemyLeft = function (enemyId, floorId) {
+    if (floorId == null) floorId = core.status.floorId;
+    if (floorId instanceof Array) {
+        for (var i = 0; i < floorId.length; ++i) {
+            if (core.hasEnemyLeft(enemyId, floorId[i]))
+                return true;
+        }
+        return false;
+    }
+    return core.getCurrentEnemys(floorId).filter(function (enemy) {
+        return enemyId == null || enemy.id == enemyId;
+    }).length > 0;
 }
\ No newline at end of file
diff --git a/libs/events.js b/libs/events.js
index 7b26bf36..8c72173f 100644
--- a/libs/events.js
+++ b/libs/events.js
@@ -1,118 +1,110 @@
+"use strict";
+
 function events() {
-    this.init();
+    this._init();
 }
 
 ////// 初始化 //////
-events.prototype.init = function () {
+events.prototype._init = function () {
     this.eventdata = functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a.events;
-    this.events = {
-        'battle': function (data, core, callback) {
-            //core.autosave(true);
-            core.battle(data.event.id, data.x, data.y);
-            if (core.isset(callback))
-                callback();
-        },
-        'getItem': function (data, core, callback) {
-            core.getItem(data.event.id, 1, data.x, data.y);
-            if (core.isset(callback))
-                callback();
-        },
-        'openDoor': function (data, core, callback) {
-            //core.autosave(true);
-            core.openDoor(data.event.id, data.x, data.y, true, function () {
-                if (core.isset(callback)) callback();
-                core.replay();
-            });
-        },
-        'changeFloor': function (data, core, callback) {
-            var heroLoc = {};
-            if (core.isset(data.event.data.loc))
-                heroLoc = {'x': data.event.data.loc[0], 'y': data.event.data.loc[1]};
-            if (core.isset(data.event.data.direction))
-                heroLoc.direction = data.event.data.direction;
-            if (core.status.event.id!='action') core.status.event.id=null;
-            core.changeFloor(data.event.data.floorId, data.event.data.stair,
-                heroLoc, data.event.data.time, function () {
-                    if (core.isset(callback)) callback();
-                    core.replay();
-                });
-        },
-        'passNet': function (data, core, callback) {
-            core.events.passNet(data);
-            if (core.isset(callback))
-                callback();
-        },
-        "changeLight": function (data, core, callback) {
-            core.events.changeLight(data.x, data.y);
-            if (core.isset(callback))
-                callback();
-        },
-        "ski": function (data, core, callback) {
-            core.events.ski();
-            if (core.isset(callback))
-                callback();
-        },
-        "pushBox": function (data, core, callback) {
-            core.events.pushBox(data);
-            if (core.isset(callback))
-                callback();
-        },
-        'action': function (data, core, callback) {
-            core.events.insertAction(data.event.data, data.x, data.y, callback);
-        }
-    }
+    this.commonEvent = events_c12a15a8_c380_4b28_8144_256cba95f760.commonEvent;
+    this.systemEvents = {};
+    this.actions = {};
 }
 
-////// 获得一个或所有系统事件类型 //////
-events.prototype.getEvents = function (eventName) {
-    if (!core.isset(eventName)) {
-        return this.events;
-    }
-    return this.events[eventName];
-}
+// ------ 初始化，开始和结束 ------ //
 
-events.prototype.initGame = function () {
-    return this.eventdata.initGame();
+/// 初始化游戏
+events.prototype.resetGame = function (hero, hard, floorId, maps, values) {
+    this.eventdata.resetGame(hero, hard, floorId, maps, values);
 }
 
 ////// 游戏开始事件 //////
-events.prototype.startGame = function (hard) {
+events.prototype.startGame = function (hard, seed, route, callback) {
+    main.dom.levelChooseButtons.style.display = 'none';
+    main.dom.startButtonGroup.style.display = 'none';
+    hard = hard || "";
 
-    if (core.status.isStarting) return;
-    core.status.isStarting = true;
+    if (main.mode != 'play') return;
 
-    core.hideStartAnimate(function() {
-        core.drawText(core.clone(core.firstData.startText), function() {
-            if (core.flags.showBattleAnimateConfirm) { // 是否提供“开启战斗动画”的选择项
-                core.status.event.selection = core.flags.battleAnimate ? 0 : 1;
-                core.ui.drawConfirmBox("你想开启战斗动画吗？\n之后可以在菜单栏中开启或关闭。\n（强烈建议新手开启此项）", function () {
-                    core.data.flags.battleAnimate = true;
-                    core.flags.battleAnimate = true;
-                    core.setLocalStorage('battleAnimate', true);
-                    core.startGame(hard);
-                    core.utils.__init_seed();
-                    core.events.setInitData(hard);
-                }, function () {
-                    core.data.flags.battleAnimate = false;
-                    core.flags.battleAnimate = false;
-                    core.setLocalStorage('battleAnimate', false);
-                    core.startGame(hard);
-                    core.utils.__init_seed();
-                    core.events.setInitData(hard);
-                });
-            }
-            else {
-                core.startGame(hard);
-                core.utils.__init_seed();
-                core.events.setInitData(hard);
-            }
+    // 无动画的开始游戏
+    if (core.flags.startUsingCanvas || route != null) {
+        core.dom.startPanel.style.display = 'none';
+        this._startGame_start(hard, seed, route, callback);
+    }
+    else {
+        core.hideStartAnimate(function () {
+            core.events._startGame_start(hard, seed, route, callback);
         });
-    })
+    }
+}
+
+events.prototype._startGame_start = function (hard, seed, route, callback) {
+    console.log('开始游戏');
+    core.resetGame(core.firstData.hero, hard, null, core.clone(core.initStatus.maps));
+    var nowLoc = core.clone(core.getHeroLoc());
+    core.setHeroLoc('x', -1);
+    core.setHeroLoc('y', -1);
+
+    if (seed != null) {
+        core.setFlag('__seed__', seed);
+        core.setFlag('__rand__', seed);
+    }
+    else core.utils.__init_seed();
+    this.setInitData();
+    core.clearStatusBar();
+
+    var todo = [];
+    if (core.flags.startUsingCanvas) {
+        core.hideStatusBar();
+        core.dom.musicBtn.style.display = 'block';
+        core.push(todo, core.firstData.startCanvas);
+    }
+    core.push(todo, core.firstData.startText);
+    this.insertAction(todo, null, null, function () {
+        core.events._startGame_afterStart(nowLoc, callback);
+    });
+
+    if (route != null) core.startReplay(route);
+}
+
+events.prototype._startGame_afterStart = function (nowLoc, callback) {
+    core.ui.closePanel();
+    this._startGame_statusBar();
+    core.dom.musicBtn.style.display = 'none';
+    core.changeFloor(core.firstData.floorId, null, nowLoc, null, function () {
+        // 插入一个空事件避免直接回放录像出错
+        core.insertAction([]);
+        if (callback) callback();
+    });
+    this._startGame_upload();
+}
+
+// 开始游戏时是否显示状态栏
+events.prototype._startGame_statusBar = function () {
+    if (core.flags.startUsingCanvas)
+        core.hideStatusBar();
+    else
+        core.showStatusBar();
+}
+
+events.prototype._startGame_upload = function () {
+    // Upload
+    var formData = new FormData();
+    formData.append('type', 'people');
+    formData.append('name', core.firstData.name);
+    formData.append('version', core.firstData.version);
+    formData.append('platform', core.platform.string);
+    formData.append('hard', core.encodeBase64(core.status.hard));
+    formData.append('hardCode', core.getFlag('hard', 0));
+    formData.append('base64', 1);
+
+    core.utils.http("POST", "/games/upload.php", formData);
 }
 
 ////// 不同难度分别设置初始属性 //////
-events.prototype.setInitData = function (hard) {
-    return this.eventdata.setInitData(hard);
+events.prototype.setInitData = function () {
+    return this.eventdata.setInitData();
 }
 
 ////// 游戏获胜事件 //////
@@ -129,1308 +121,2121 @@ events.prototype.lose = function (reason) {
 
 ////// 游戏结束 //////
 events.prototype.gameOver = function (ending, fromReplay, norank) {
-
-    // 清空图片和天气
-    core.clearMap('animate');
+    core.clearMap('all');
+    core.deleteAllCanvas();
     core.dom.gif2.innerHTML = "";
-    core.clearMap('weather')
-    core.animateFrame.weather.type = null;
-    core.animateFrame.weather.level = 0;
-    core.animateFrame.weather.nodes = [];
-    core.setFg(null, 0);
+    core.setWeather();
     core.ui.closePanel();
 
-    // 下载录像
-    var confirmDownload = function () {
-
-        core.ui.closePanel();
-        core.ui.drawConfirmBox("你想下载录像吗？", function () {
-            var obj = {
-                'name': core.firstData.name,
-                'version': core.firstData.version,
-                'hard': core.status.hard,
-                'seed': core.getFlag('seed'),
-                'route': core.encodeRoute(core.status.route)
-            }
-            core.download(core.firstData.name+"_"+core.formatDate2(new Date())+".h5route", JSON.stringify(obj));
-            core.restart();
-        }, function () {
-            core.restart();
-        })
-
+    if (main.isCompetition && ending != null) {
+        if (ending == "") ending = "恭喜通关";
+        ending += "[比赛]";
     }
 
-    // 上传成绩
-    var confirmUpload = function () {
+    var reason = null;
+    if (fromReplay) reason = "录像回放完毕！";
+    else if (core.hasFlag("debug")) reason = "\t[系统提示]调试模式下无法上传成绩";
+    else if (core.hasFlag("__consoleOpened__")) reason = "\t[系统提示]本存档开启过控制台，无法上传成绩";
 
-        core.ui.closePanel();
+    if (reason != null)
+        core.drawText(reason, core.restart);
+    else
+        this._gameOver_confirmUpload(ending, norank);
+}
 
-        if (!core.isset(ending)) {
-            confirmDownload();
-            return;
-        }
-
-        var doUpload = function(username) {
-            var hp = core.status.hero.hp;
-            if (username==undefined) hp = 1;
-
-            // upload
-            var formData = new FormData();
-            formData.append('type', 'score');
-            formData.append('name', core.firstData.name);
-            formData.append('version', core.firstData.version);
-            formData.append('platform', core.platform.isPC?"PC":core.platform.isAndroid?"Android":core.platform.isIOS?"iOS":"");
-            formData.append('hard', core.encodeBase64(core.status.hard));
-            formData.append('username', core.encodeBase64(username||""));
-            formData.append('ending', core.encodeBase64(ending));
-            formData.append('lv', core.status.hero.lv);
-            formData.append('hp', Math.min(hp, Math.pow(2, 63)));
-            formData.append('atk', core.status.hero.atk);
-            formData.append('def', core.status.hero.def);
-            formData.append('mdef', core.status.hero.mdef);
-            formData.append('money', core.status.hero.money);
-            formData.append('experience', core.status.hero.experience);
-            formData.append('steps', core.status.hero.steps);
-            formData.append('norank', norank||0);
-            formData.append('seed', core.getFlag('seed'));
-            formData.append('totalTime', Math.floor(core.status.hero.statistics.totalTime/1000));
-            formData.append('route', core.encodeRoute(core.status.route));
-            formData.append('base64', 1);
-
-            if (main.isCompetition)
-                core.http("POST", "/games/competition/upload.php", formData);
-            else
-                core.http("POST", "/games/upload.php", formData);
-
-            setTimeout(function() {
-                confirmDownload();
-            }, 150);
-        }
-
-        core.ui.drawConfirmBox("你想记录你的ID和成绩吗？", function () {
-            if (main.isCompetition) {
-                doUpload("");
-            }
-            else {
-                doUpload(prompt("请输入你的ID："));
-            }
-        }, function () {
-            if (main.isCompetition)
-                confirmDownload();
-            else
-                doUpload(undefined);
-        })
+events.prototype._gameOver_confirmUpload = function (ending, norank) {
+    core.ui.closePanel();
 
+    if (ending == null) {
+        this._gameOver_confirmDownload(ending);
         return;
     }
-
-    if (fromReplay) {
-        core.drawText("录像回放完毕！", function () {
-            core.restart();
-        });
-    }
-    else {
-
-        if (core.isset(core.values.maxValidHp) && core.status.hero.hp>core.values.maxValidHp) {
-            core.drawText("作弊可耻！", function () {
-                core.restart();
-            });
-        }
-        else if (core.hasFlag('debug')) {
-            core.drawText("\t[系统提示]调试模式下无法上传成绩", function () {
-                core.restart();
-            })
+    core.ui.drawConfirmBox("你想记录你的ID和成绩吗？", function () {
+        if (main.isCompetition) {
+            core.events._gameOver_doUpload("", ending, norank);
         }
         else {
-            confirmUpload();
+            core.myprompt("请输入你的ID：", core.getCookie('id') || "", function (username)  {
+                core.events._gameOver_doUpload(username, ending, norank);
+            });
         }
-
-    }
-
+    }, function () {
+        if (main.isCompetition)
+            core.events._gameOver_confirmDownload(ending);
+        else
+            core.events._gameOver_doUpload(null, ending, norank);
+    })
 }
 
-////// 转换楼层结束的事件 //////
-events.prototype.afterChangeFloor = function (floorId) {
-    if (main.mode!='play') return;
-    return this.eventdata.afterChangeFloor(floorId);
+events.prototype._gameOver_doUpload = function (username, ending, norank) {
+    var hp = core.status.hero.hp;
+    if (username == null) hp = 1;
+    core.ui.closePanel();
+    // upload
+    var formData = new FormData();
+    formData.append('type', 'score');
+    formData.append('name', core.firstData.name);
+    formData.append('version', core.firstData.version);
+    formData.append('platform', core.platform.string);
+    formData.append('hard', core.encodeBase64(core.status.hard));
+    formData.append('username', core.encodeBase64(username || ""));
+    formData.append('ending', core.encodeBase64(ending));
+    formData.append('lv', core.status.hero.lv);
+    formData.append('hp', Math.min(hp, Math.pow(2, 63)));
+    formData.append('atk', core.status.hero.atk);
+    formData.append('def', core.status.hero.def);
+    formData.append('mdef', core.status.hero.mdef);
+    formData.append('money', core.status.hero.money);
+    formData.append('experience', core.status.hero.experience);
+    formData.append('steps', core.status.hero.steps);
+    formData.append('norank', norank ? 1 : 0);
+    formData.append('seed', core.getFlag('__seed__'));
+    formData.append('totalTime', Math.floor(core.status.hero.statistics.totalTime / 1000));
+    formData.append('route', core.encodeRoute(core.status.route));
+    formData.append('base64', 1);
+
+    if (main.isCompetition)
+        core.http("POST", "/games/competition/upload.php", formData);
+    else
+        core.http("POST", "/games/upload.php", formData);
+
+    core.events._gameOver_confirmDownload(ending);
 }
 
-////// 开始执行一系列自定义事件 //////
-events.prototype.doEvents = function (list, x, y, callback) {
-    if (!core.isset(list)) return;
-    if (!(list instanceof Array)) {
-        list = [list];
-    }
-
-    core.status.event = {'id': 'action', 'data': {
-        'list': [
-            {"todo": core.clone(list), "total": core.clone(list), "condition": "false"}
-        ], 'x': x, 'y': y, 'callback': callback
-    }}
-
-    // 停止勇士
-    core.waitHeroToStop(function() {
-        core.lockControl();
-        core.events.doAction();
+events.prototype._gameOver_confirmDownload = function (ending) {
+    core.ui.closePanel();
+    core.ui.drawConfirmBox("你想下载录像吗？", function () {
+        var obj = {
+            'name': core.firstData.name,
+            'version': core.firstData.version,
+            'hard': core.status.hard,
+            'seed': core.getFlag('__seed__'),
+            'route': core.encodeRoute(core.status.route)
+        }
+        core.download(core.firstData.name + "_" + core.formatDate2(new Date()) + ".h5route", JSON.stringify(obj));
+        core.events._gameOver_askRate(ending);
+    }, function () {
+        core.events._gameOver_askRate(ending);
     });
 }
 
-////// 执行当前自定义事件列表中的下一个事件 //////
-events.prototype.doAction = function() {
-    // 清空boxAnimate和UI层
-    core.status.boxAnimateObjs = [];
-    clearInterval(core.status.event.interval);
-
-    core.clearMap('ui');
-    core.setAlpha('ui', 1.0);
-
-    // 事件处理完毕
-    if (core.status.event.data.list.length==0) {
-        var callback = core.status.event.data.callback;
-        core.ui.closePanel();
-        if (core.isset(callback))
-            callback();
-        core.replay();
+events.prototype._gameOver_askRate = function (ending) {
+    if (ending == null) {
+        core.restart();
         return;
     }
 
-    var current = core.status.event.data.list[0];
-    if (current.todo.length == 0) { // current list is empty
-        if (core.calValue(current.condition)) { // check condition
-            current.todo = core.clone(current.total);
+    core.ui.closePanel();
+    core.ui.drawConfirmBox("恭喜通关本塔，你想进行评分吗？", function () {
+        if (core.platform.isPC) {
+            window.open("/score.php?name=" + core.firstData.name + "&num=10", "_blank");
+            core.restart();
         }
         else {
-            core.status.event.data.list.shift(); // remove stackc
+            window.location.href = "/score.php?name=" + core.firstData.name + "&num=10";
         }
-        this.doAction();
-        return;
-    }
-    var data = current.todo.shift();
-    core.status.event.data.current = data;
-
-    var x=core.status.event.data.x, y=core.status.event.data.y;
-
-    // 不同种类的事件
-
-    // 如果是文字：显示
-    if (typeof data == "string") {
-        core.status.event.data.type='text';
-        // 如果是正在回放中，不显示
-        if (core.status.replay.replaying)
-            core.events.doAction();
-        else
-            core.ui.drawTextBox(data);
-        return;
-    }
-    core.status.event.data.type=data.type;
-    switch (data.type) {
-        case "text": // 文字/对话
-            if (core.status.replay.replaying)
-                core.events.doAction();
-            else
-                core.ui.drawTextBox(data.text);
-            break;
-        case "autoText":
-            if (core.status.replay.replaying)
-                core.events.doAction();
-            else {
-                core.ui.drawTextBox(data.text);
-                setTimeout(function () {
-                    core.events.doAction();
-                }, data.time || 3000);
-            }
-            break;
-        case "setText": // 设置文本状态
-            if (data.position=='up'||data.position=='down'||data.position=='center') {
-                core.status.textAttribute.position=data.position;
-            }
-            ["background", "title", "text"].forEach(function (t) {
-                if (core.isset(data[t]) && (data[t] instanceof Array) && data[t].length>=3) {
-                    if (data[t].length==3) data[t].push(1);
-                    core.status.textAttribute[t]=data[t];
-                }
-            })
-            if (core.isset(data.bold)) {
-                core.status.textAttribute.bold=data.bold;
-            }
-            if (core.isset(data.time)) {
-                core.status.textAttribute.time=data.time;
-            }
-            core.events.doAction();
-            break;
-        case "tip":
-            core.drawTip(core.replaceText(data.text));
-            core.events.doAction();
-            break;
-        case "show": // 显示
-            if (!core.isset(data.loc))
-                data.loc = [x,y];
-            if ((typeof data.loc[0] == 'number' || typeof data.loc[0] == 'string')
-                    && (typeof data.loc[1] == 'number' || typeof data.loc[1] == 'string'))
-                data.loc = [[core.calValue(data.loc[0]), core.calValue(data.loc[1])]];
-            if (core.isset(data.time) && data.time>0 && (!core.isset(data.floorId) || data.floorId==core.status.floorId)) {
-                core.animateBlock(data.loc,'show', data.time, function () {
-                    data.loc.forEach(function (t) {
-                        core.showBlock(t[0],t[1],data.floorId)
-                    })
-                    core.events.doAction();
-                });
-            }
-            else {
-                data.loc.forEach(function (t) {
-                    core.showBlock(t[0],t[1],data.floorId)
-                })
-                this.doAction();
-            }
-            break;
-        case "hide": // 消失
-            if (!core.isset(data.loc))
-                data.loc = [x,y];
-            if ((typeof data.loc[0] == 'number' || typeof data.loc[0] == 'string')
-                && (typeof data.loc[1] == 'number' || typeof data.loc[1] == 'string'))
-                data.loc = [[core.calValue(data.loc[0]), core.calValue(data.loc[1])]];
-            data.loc.forEach(function (t) {
-                core.removeBlock(t[0],t[1],data.floorId);
-            })
-            if (core.isset(data.time) && data.time>0 && (!core.isset(data.floorId) || data.floorId==core.status.floorId)) {
-                core.animateBlock(data.loc,'hide',data.time, function () {
-                    core.events.doAction();
-                });
-            }
-            else this.doAction();
-            break;
-        case "setBlock": // 设置某图块
-            {
-                if (core.isset(data.loc)) {
-                    x=core.calValue(data.loc[0]);
-                    y=core.calValue(data.loc[1]);
-                }
-                core.setBlock(data.number, x, y, data.floorId);
-                this.doAction();
-                break;
-            }
-        case "follow": // 跟随
-            if (core.isset(core.material.images.images[data.name])
-                && core.material.images.images[data.name].width==128) {
-                if (!core.isset(core.status.hero.followers))
-                    core.status.hero.followers = [];
-                core.status.hero.followers.push({"img": data.name});
-                core.control.gatherFollowers();
-                core.clearMap('hero');
-                core.drawHero();
-            }
-            this.doAction();
-            break;
-        case "unfollow": // 取消跟随
-            if (core.isset(core.status.hero.followers)) {
-                var remove = false;
-                if (!core.isset(data.name) && core.status.hero.followers.length>0) {
-                    core.status.hero.followers = [];
-                    remove=true;
-                }
-                if (core.isset(data.name)) {
-                    for (var i=0;i<core.status.hero.followers.length;i++) {
-                        if (core.status.hero.followers[i].img == data.name) {
-                            core.status.hero.followers.splice(i, 1);
-                            remove=true;
-                            break;
-                        }
-                    }
-                }
-                if (remove) {
-                    core.control.gatherFollowers();
-                    core.clearMap('hero');
-                    core.drawHero();
-                }
-            }
-            this.doAction();
-            break;
-        case "animate": // 显示动画
-            if (core.isset(data.loc)) {
-                if (data.loc == 'hero') {
-                    x=core.getHeroLoc('x');
-                    y=core.getHeroLoc('y');
-                }
-                else if (data.loc instanceof Array) {
-                    x=core.calValue(data.loc[0]);
-                    y=core.calValue(data.loc[1]);
-                }
-            }
-            core.drawAnimate(data.name, x, y, function () {
-                core.events.doAction();
-            })
-            break;
-        case "move": // 移动事件
-            if (core.isset(data.loc)) {
-                x=core.calValue(data.loc[0]);
-                y=core.calValue(data.loc[1]);
-            }
-            core.moveBlock(x,y,data.steps,data.time,data.keep,function() {
-                core.events.doAction();
-            })
-            break;
-        case "moveHero":
-            core.eventMoveHero(data.steps,data.time,function() {
-                core.events.doAction();
-            });
-            break;
-        case "jump": // 跳跃事件
-            {
-                var sx=x, sy=y, ex=x,ey=y;
-                if (core.isset(data.from)) {
-                    sx=core.calValue(data.from[0]);
-                    sy=core.calValue(data.from[1]);
-                }
-                if (core.isset(data.to)) {
-                    ex=core.calValue(data.to[0]);
-                    ey=core.calValue(data.to[1]);
-                }
-                core.jumpBlock(sx,sy,ex,ey,data.time,data.keep,function() {
-                    core.events.doAction();
-                });
-                break;
-            }
-        case "jumpHero":
-            {
-                var ex=core.status.hero.loc.x, ey=core.status.hero.loc.y;
-                if (core.isset(data.loc)) {
-                    ex=core.calValue(data.loc[0]);
-                    ey=core.calValue(data.loc[1]);
-                }
-                core.jumpHero(ex,ey,data.time,function() {
-                    core.events.doAction();
-                });
-                break;
-            }
-        case "changeFloor": // 楼层转换
-            {
-                var heroLoc = {"x": core.calValue(data.loc[0]), "y": core.calValue(data.loc[1])};
-                if (core.isset(data.direction)) heroLoc.direction=data.direction;
-                core.changeFloor(data.floorId||core.status.floorId, null, heroLoc, data.time, function() {
-                    core.lockControl();
-                    core.events.doAction();
-                });
-                break;
-            }
-        case "changePos": // 直接更换勇士位置，不切换楼层
-            core.clearMap('hero');
-            if (core.isset(data.loc)) {
-                core.setHeroLoc('x', core.calValue(data.loc[0]));
-                core.setHeroLoc('y', core.calValue(data.loc[1]));
-            }
-            if (core.isset(data.direction)) core.setHeroLoc('direction', data.direction);
-            core.drawHero();
-            this.doAction();
-            break;
-        case "showImage": // 显示图片
-            if (core.isset(data.loc) && core.isset(core.material.images.images[data.name])) {
-                core.canvas.animate.drawImage(core.material.images.images[data.name],
-                    core.calValue(data.loc[0]), core.calValue(data.loc[1]));
-            }
-            else core.clearMap('animate');
-            this.doAction();
-            break;
-        case "animateImage": // 淡入淡出图片
-            if (core.status.replay.replaying) { // 正在播放录像
-                this.doAction();
-            }
-            else {
-                if (core.isset(data.loc) && core.isset(core.material.images.images[data.name]) && (data.action=="show" || data.action=="hide")) {
-                    core.events.animateImage(data.action, core.material.images.images[data.name], data.loc, data.time, function() {
-                        core.events.doAction();
-                    });
-                }
-                else {
-                    this.doAction();
-                }
-            }
-            break;
-        case "showGif": // 显示动图
-            if (core.isset(data.loc) && core.isset(core.material.images.images[data.name])) {
-                var gif = new Image();
-                gif.src = core.material.images.images[data.name].src;
-                gif.style.position = 'absolute';
-                gif.style.left = (core.calValue(data.loc[0])*core.domStyle.scale)+"px";
-                gif.style.top = (core.calValue(data.loc[1])*core.domStyle.scale)+"px";
-                gif.style.width = core.material.images.images[data.name].width*core.domStyle.scale+"px";
-                gif.style.height = core.material.images.images[data.name].height*core.domStyle.scale+"px";
-                core.dom.gif2.appendChild(gif);
-            }
-            else {
-                core.dom.gif2.innerHTML = "";
-            }
-            this.doAction();
-            break;
-        case "moveImage": // 图片移动
-            if (core.status.replay.replaying) { // 正在播放录像
-                this.doAction();
-            }
-            else {
-                if (core.isset(data.from) && core.isset(data.to) && core.isset(core.material.images.images[data.name])) {
-                    core.events.moveImage(core.material.images.images[data.name], data.from, data.to, data.time, function() {
-                        core.events.doAction();
-                    });
-                }
-                else {
-                    this.doAction();
-                }
-            }
-            break;
-        case "setFg": // 颜色渐变
-            core.setFg(data.color, data.time, function() {
-                core.events.doAction();
-            });
-            break;
-        case "setWeather": // 更改天气
-            core.setWeather(data.name, data.level);
-            this.doAction();
-            break;
-        case "openDoor": // 开一个门，包括暗墙
-            {
-                if (core.isset(data.loc)) {
-                    x = core.calValue(data.loc[0]);
-                    y = core.calValue(data.loc[1]);
-                }
-                var floorId=data.floorId || core.status.floorId;
-                var block=core.getBlock(x, y, floorId);
-                if (block!=null) {
-                    if (floorId==core.status.floorId)
-                        core.openDoor(block.block.event.id, block.block.x, block.block.y, false, function() {
-                            core.events.doAction();
-                        })
-                    else {
-                        core.removeBlock(block.block.x,block.block.y,floorId);
-                        this.doAction();
-                    }
-                    break;
-                }
-                this.doAction();
-                break;
-            }
-        case "openShop": // 打开一个全局商店
-            if (core.status.replay.replaying) { // 正在播放录像，简单将visited置为true
-                core.status.shops[data.id].visited=true;
-                core.status.event.data.list = [];
-                this.doAction();
-            }
-            else
-                core.events.openShop(data.id);
-            break;
-        case "disableShop": // 禁用一个全局商店
-            core.events.disableQuickShop(data.id);
-            this.doAction();
-            break;
-        case "battle": // 强制战斗
-            core.battle(data.id,null,null,true,function() {
-                core.events.doAction();
-            })
-            break;
-        case "trigger": // 触发另一个事件；当前事件会被立刻结束。需要另一个地点的事件是有效的
-            {
-                var toX=core.calValue(data.loc[0]), toY=core.calValue(data.loc[1]);
-                var block=core.getBlock(toX, toY);
-                if (block!=null) {
-                    block = block.block;
-                    if (core.isset(block.event) && block.event.trigger=='action') {
-                        // 触发
-                        core.status.event.data.list = [
-                            {"todo": core.clone(block.event.data), "total": core.clone(block.event.data), "condition": "false"}
-                        ];
-                        core.status.event.data.x=block.x;
-                        core.status.event.data.y=block.y;
-                    }
-                }
-                this.doAction();
-                break;
-            }
-        case "playSound":
-            if (!core.status.replay.replaying)
-                core.playSound(data.name);
-            this.doAction();
-            break;
-        case "playBgm":
-            core.playBgm(data.name);
-            this.doAction();
-            break
-        case "pauseBgm":
-            core.pauseBgm();
-            this.doAction();
-            break
-        case "resumeBgm":
-            core.resumeBgm();
-            this.doAction();
-            break
-        case "setVolume":
-            data.value = parseInt(data.value||0);
-            if (data.value<0) data.value=0;
-            if (data.value>100) data.value=100;
-            this.setVolume(data.value/100, data.time, function() {
-                core.doAction();
-            });
-            break;
-        case "setValue":
-            try {
-                var value=core.calValue(data.value);
-                // 属性
-                if (data.name.indexOf("status:")==0) {
-                    value=parseFloat(value);
-                    core.setStatus(data.name.substring(7), value);
-                }
-                // 道具
-                if (data.name.indexOf("item:")==0) {
-                    value=parseInt(value);
-                    var itemId=data.name.substring(5);
-                    if (value>core.itemCount(itemId)) // 效果
-                        core.getItem(itemId,value-core.itemCount(itemId));
-                    else core.setItem(itemId, value);
-                }
-                // flag
-                if (data.name.indexOf("flag:")==0) {
-                    core.setFlag(data.name.substring(5), value);
-                }
-            }
-            catch (e) {console.log(e)}
-            if (core.status.hero.hp<=0) {
-                core.status.hero.hp=0;
-                core.updateStatusBar();
-                core.events.lose();
-            }
-            else {
-                core.updateStatusBar();
-                this.doAction();
-            }
-            break;
-        case "setHeroIcon":
-            {
-                this.setHeroIcon(data.name);
-                this.doAction();
-                break;
-            }
-        case "input":
-            {
-                var value;
-                if (core.status.replay.replaying) {
-                    var action = core.status.replay.toReplay.shift();
-                    if (action.indexOf("input:")==0 ) {
-                        value=parseInt(action.substring(6));
-                    }
-                    else {
-                        core.stopReplay();
-                        core.drawTip("录像文件出错");
-                        return;
-                    }
-                }
-                else {
-                    core.interval.onDownInterval = 'tmp';
-                    value = prompt(core.replaceText(data.text));
-                }
-                value = Math.abs(parseInt(value)||0);
-                core.status.route.push("input:"+value);
-                core.setFlag("input", value);
-                this.doAction();
-            }
-            break;
-        case "if": // 条件判断
-            if (core.calValue(data.condition))
-                core.events.insertAction(data["true"])
-            else
-                core.events.insertAction(data["false"])
-            this.doAction();
-            break;
-        case "choices": // 提供选项
-            if (core.status.replay.replaying) {
-                if (core.status.replay.toReplay.length==0) { // 回放完毕
-                    core.status.replay.replaying=false;
-                    core.drawTip("录像回放完毕");
-                }
-                else {
-                    var action = core.status.replay.toReplay.shift(), index;
-                    if (action == 'turn') action = core.status.replay.toReplay.shift();
-                    if (action.indexOf("choices:")==0 && ((index=parseInt(action.substring(8)))>=0) && index<data.choices.length) {
-                            core.status.event.selection=index;
-                            setTimeout(function () {
-                                core.status.route.push("choices:"+index);
-                                core.events.insertAction(data.choices[index].action);
-                                core.events.doAction();
-                            }, 750 / Math.max(1, core.status.replay.speed))
-                    }
-                    else {
-                        core.stopReplay();
-                        core.drawTip("录像文件出错");
-                    }
-                }
-            }
-            core.ui.drawChoices(data.text, data.choices);
-            break;
-        case "while":
-            if (core.calValue(data.condition)) {
-                core.unshift(core.status.event.data.list,
-                    {"todo": core.clone(data.data), "total": core.clone(data.data), "condition": data.condition}
-                );
-            }
-            this.doAction();
-            break;
-        case "break":
-            core.status.event.data.list.shift();
-            this.doAction();
-            break;
-        case "continue":
-            if (core.calValue(core.status.event.data.list[0].condition)) {
-                core.status.event.data.list[0].todo = core.clone(core.status.event.data.list[0].total);
-            }
-            else {
-                core.status.event.data.list.shift();
-            }
-            this.doAction();
-            break;
-        case "win":
-            core.events.win(data.reason, data.norank);
-            break;
-        case "lose":
-            core.events.lose(data.reason);
-            break;
-        case "function":
-            {
-                var func = data["function"];
-                if (core.isset(func)) {
-                    if ((typeof func == "string") && func.indexOf("function")==0) {
-                        eval('('+func+')()');
-                    }
-                    else if (func instanceof Function)
-                        func();
-                }
-                this.doAction();
-                break;
-            }
-        case "update":
-            core.updateStatusBar();
-            this.doAction();
-            break;
-        case "updateEnemys":
-            core.enemys.updateEnemys();
-            core.updateStatusBar();
-            this.doAction();
-            break;
-        case "viberate":
-            core.events.vibrate(data.time, function () {
-                core.events.doAction();
-            })
-            break;
-        case "sleep": // 等待多少毫秒
-            if (core.status.replay.replaying)
-                core.events.doAction();
-            else {
-                setTimeout(function () {
-                    core.events.doAction();
-                }, data.time);
-            }
-            break;
-        case "wait":
-            if (core.status.replay.replaying) {
-                var code = core.status.replay.toReplay.shift();
-                if (code.indexOf("input:")==0) {
-                    var value = parseInt(code.substring(6));
-                    core.status.route.push("input:"+value);
-                    if (value>=10000) {
-                        core.setFlag('type', 1);
-                        core.setFlag('x', parseInt((value-10000)/100));
-                        core.setFlag('y', value%100);
-                    }
-                    else {
-                        core.setFlag('type', 0);
-                        core.setFlag('keycode', value);
-                    }
-                    core.events.doAction();
-                }
-                else {
-                    core.stopReplay();
-                    core.drawTip("录像文件出错");
-                }
-            }
-            break;
-        case "revisit": // 立刻重新执行该事件
-            {
-                var block=core.getBlock(x,y); // 重新获得事件
-                if (block!=null) {
-                    block = block.block;
-                    if (core.isset(block.event) && block.event.trigger=='action') {
-                        core.status.event.data.list = [
-                            {"todo": core.clone(block.event.data), "total": core.clone(block.event.data), "condition": "false"}
-                        ];
-                    }
-                }
-                this.doAction();
-                break;
-            }
-        case "exit": // 立刻结束事件
-            core.status.event.data.list = [];
-            core.events.doAction();
-            break;
-        default:
-            core.status.event.data.type='text';
-            core.ui.drawTextBox("\t[警告]出错啦！\n"+data.type+" 事件不被支持...");
-    }
-    return;
+    }, function () {
+        core.restart();
+    });
 }
 
-////// 往当前事件列表之前添加一个或多个事件 //////
-events.prototype.insertAction = function (action, x, y, callback) {
-    if (core.status.event.id != 'action') {
-        this.doEvents(action, x, y, callback);
-    }
-    else {
-        core.unshift(core.status.event.data.list[0].todo, action)
-        if (core.isset(x)) core.status.event.data.x=x;
-        if (core.isset(y)) core.status.event.data.y=y;
-        if (core.isset(callback)) core.status.event.data.callback=callback;
-    }
+////// 重新开始游戏；此函数将回到标题页面 //////
+events.prototype.restart = function() {
+    core.showStartAnimate();
+    core.playBgm(main.startBgm);
 }
 
-////// 获得面前的物品（轻按） //////
-events.prototype.getNextItem = function() {
-    if (!core.status.heroStop || !core.flags.enableGentleClick) return;
-    var nextX = core.nextX(), nextY = core.nextY();
-    var block = core.getBlock(nextX, nextY);
-    if (block==null) return;
-    if (block.block.event.trigger=='getItem') {
-        core.getItem(block.block.event.id, 1, nextX, nextY);
-        core.status.route.push("getNext");
-    }
+////// 询问是否需要重新开始 //////
+events.prototype.confirmRestart = function () {
+    core.status.event.selection = 1;
+    core.ui.drawConfirmBox("你确定要返回标题页面吗？", function () {
+        core.ui.closePanel();
+        core.restart();
+    }, function () {
+        core.ui.closePanel();
+    });
 }
 
-////// 获得某个物品 //////
-events.prototype.getItem = function (itemId, itemNum, itemX, itemY, callback) {
-    itemNum=itemNum||1;
-    core.playSound('item.mp3');
-    var itemCls = core.material.items[itemId].cls;
-    core.items.getItemEffect(itemId, itemNum);
-    core.removeBlock(itemX, itemY);
-    var text = '获得 ' + core.material.items[itemId].name;
-    if (itemNum > 1) text += "x" + itemNum;
-    if (itemCls === 'items') text += core.items.getItemEffectTip(itemId);
-    core.drawTip(text, core.material.icons.items[itemId]);
-    core.canvas.event.clearRect(itemX * 32, itemY * 32, 32, 32);
-    core.updateStatusBar();
+// ------ 系统事件的处理 ------ //
 
-    // 检查处理后的事件。
-    var event = core.floors[core.status.floorId].afterGetItem[itemX+","+itemY];
-    if (core.isset(event)) {
-        core.events.doEvents(event, itemX, itemY, callback);
-    }
-    else if (core.isset(callback)) callback();
+////// 注册一个系统事件 //////
+// type为事件名，func为事件的处理函数，可接受(data, callback)参数
+events.prototype.registerSystemEvent = function (type, func) {
+    this.systemEvents[type] = func;
 }
 
-////// 开门 //////
-events.prototype.openDoor = function (id, x, y, needKey, callback) {
+////// 注销一个系统事件 //////
+events.prototype.unregisterSystemEvent = function (type) {
+    delete this.systemEvents[type];
+}
 
-    if (core.interval.openDoorAnimate!=null) return;
+////// 执行一个系统事件 //////
+events.prototype.doSystemEvent = function (type, data, callback) {
+    if (this.systemEvents[type]) {
+        try {
+            return core.doFunc(this.systemEvents[type], this, data, callback);
+        }
+        catch (e) {
+            main.log(e);
+            main.log("ERROR in systemEvents["+type+"]");
+        }
+    }
+    if (this["_sys_" + type]) return this["_sys_" + type](data, callback);
+    main.log("未知的系统事件: " + type + "！");
+    if (callback) callback();
+}
 
-    // 是否存在门
-    if (!core.terrainExists(x, y, id) && id!='lava' && id!='star') {
-        if (core.isset(callback)) callback();
+////// 触发(x,y)点的事件 //////
+events.prototype._trigger = function (x, y) {
+    if (core.status.gameOver) return;
+    if (core.status.event.id == 'action') {
+        core.insertAction({"type": "trigger", "loc": [x, y]}, x, y, null, true);
         return;
     }
-    if (core.status.automaticRoute.moveStepBeforeStop.length==0) {
-        core.status.automaticRoute.moveStepBeforeStop=core.status.automaticRoute.autoStepRoutes.slice(core.status.automaticRoute.autoStep-1,core.status.automaticRoute.autoStepRoutes.length);
-        if (core.status.automaticRoute.moveStepBeforeStop.length>=1)core.status.automaticRoute.moveStepBeforeStop[0].step-=core.status.automaticRoute.movedStep;
-    }
+    if (core.status.event.id) return;
 
-    core.stopAutomaticRoute();
-    var speed=30;
-    var doorId = id;
-    if (doorId.length<4 || doorId.substring(doorId.length-4)!="Door") {
-        doorId=doorId+"Door";
-        speed=70;
-    }
-    // 不存在门
-    if (!core.isset(core.material.icons.animates[doorId])) {
-        if (core.isset(callback)) callback();
-        return;
-    }
+    var block = core.getBlock(x, y);
+    if (block == null) return;
+    block = block.block;
+    if (block.event.trigger) {
+        var noPass = block.event.noPass, trigger = block.event.trigger;
+        if (noPass) core.clearAutomaticRouteNode(x, y);
 
-    var key = id.replace("Door", "Key");
-    if (needKey && (key=="specialKey" || core.isset(core.material.items[key]))) {
-        var key = id.replace("Door", "Key");
-        if (!core.hasItem(key)) {
-            if (key != "specialKey")
-                core.drawTip("你没有" + core.material.items[key].name);
-            else core.drawTip("无法开启此门");
-            core.clearContinueAutomaticRoute();
+        // 转换楼层能否穿透
+        if (trigger == 'changeFloor' && !noPass && this._trigger_ignoreChangeFloor(block))
             return;
-        }
-        core.autosave(true);
-        core.removeItem(key);
+        core.status.automaticRoute.moveDirectly = false;
+        this.doSystemEvent(trigger, block);
     }
+}
 
-    // open
-    core.playSound("door.mp3");
-    var state = 0;
-    var door = core.material.icons.animates[doorId];
-    core.status.replay.animate=true;
-    core.removeGlobalAnimate(x,y);
-    core.interval.openDoorAnimate = window.setInterval(function () {
-        state++;
-        if (state == 4) {
-            clearInterval(core.interval.openDoorAnimate);
-            core.interval.openDoorAnimate=null;
-            core.removeBlock(x, y);
-            core.status.replay.animate=false;
-            core.events.afterOpenDoor(id,x,y,callback);
-            return;
+events.prototype._trigger_ignoreChangeFloor = function (block) {
+    var able = core.flags.ignoreChangeFloor;
+    if (block.event.data && block.event.data.ignoreChangeFloor != null)
+        able = block.event.data.ignoreChangeFloor;
+    if (able) {
+        if (core.isReplaying()) {
+            if (core.status.replay.toReplay[0] == 'no') {
+                core.status.replay.toReplay.shift();
+                core.status.route.push("no");
+                return true;
+            }
         }
-        core.canvas.event.clearRect(32 * x, 32 * y, 32, 32);
-        core.canvas.event.drawImage(core.material.images.animates, 32 * state, 32 * door, 32, 32, 32 * x, 32 * y, 32, 32);
-    }, speed / core.status.replay.speed)
+        else if (core.status.automaticRoute.autoHeroMove
+            || core.status.automaticRoute.autoStep < core.status.automaticRoute.autoStepRoutes.length) {
+            core.status.route.push("no");
+            return true;
+        }
+    }
+    return false;
+}
+
+events.prototype._sys_battle = function (data, callback) {
+    this.battle(data.event.id, data.x, data.y, false, callback);
 }
 
 ////// 战斗 //////
 events.prototype.battle = function (id, x, y, force, callback) {
-    if (core.status.automaticRoute.moveStepBeforeStop.length==0) {
-        core.status.automaticRoute.moveStepBeforeStop=core.status.automaticRoute.autoStepRoutes.slice(core.status.automaticRoute.autoStep-1,core.status.automaticRoute.autoStepRoutes.length);
-        if (core.status.automaticRoute.moveStepBeforeStop.length>=1)core.status.automaticRoute.moveStepBeforeStop[0].step-=core.status.automaticRoute.movedStep;
-    }
-    core.stopHero();
-    core.stopAutomaticRoute();
-
+    core.saveAndStopAutomaticRoute();
+    id = id || core.getBlockId(x, y);
+    if (!id) return core.clearContinueAutomaticRoute(callback);
     // 非强制战斗
-    if (!core.enemys.canBattle(id) && !force) {
+    if (!core.enemys.canBattle(id, x, y) && !force && !core.status.event.id) {
         core.drawTip("你打不过此怪物！");
-        core.clearContinueAutomaticRoute();
-        return;
-    }
-
-    if (!core.isset(core.status.event.id)) // 自动存档
-        core.autosave(true);
-
-    if (core.flags.battleAnimate&&!core.status.replay.replaying) {
-        core.waitHeroToStop(function() {
-            core.ui.drawBattleAnimate(id, function() {
-                core.events.afterBattle(id, x, y, callback);
-            });
-        });
-    }
-    else {
-
-        if (core.flags.equipment && core.getFlag('sword', 'sword0')!='sword0') {
-            core.playSound('zone.mp3');
-            core.drawAnimate('sword', x, y);
-        }
-        else {
-            core.playSound('attack.mp3');
-            core.drawAnimate('hand', x, y);
-        }
-
-        core.events.afterBattle(id, x, y, callback);
+        return core.clearContinueAutomaticRoute(callback);
     }
+    // 自动存档
+    if (!core.status.event.id) core.autosave(true);
+    // 战前事件
+    if (!this.beforeBattle(id, x, y))
+        return core.clearContinueAutomaticRoute(callback);
+    // 战后事件
+    this.afterBattle(id, x, y, callback);
 }
 
-////// 触发(x,y)点的事件 //////
-events.prototype.trigger = function (x, y) {
-    core.status.isSkiing = false;
-    var mapBlocks = core.status.thisMap.blocks;
-    var noPass;
-    for (var b = 0; b < mapBlocks.length; b++) {
-        if (mapBlocks[b].x == x && mapBlocks[b].y == y && !mapBlocks[b].disable) { // 启用事件
-            noPass = mapBlocks[b].event && mapBlocks[b].event.noPass;
-            if (noPass) {
-                core.clearAutomaticRouteNode(x, y);
-            }
-            if (core.isset(mapBlocks[b].event) && core.isset(mapBlocks[b].event.trigger)) {
-                var trigger = mapBlocks[b].event.trigger;
+////// 战斗前触发的事件 //////
+events.prototype.beforeBattle = function (enemyId, x, y) {
+    return this.eventdata.beforeBattle(enemyId, x, y)
+}
 
-                if (trigger == 'ski') core.status.isSkiing = true;
+////// 战斗结束后触发的事件 //////
+events.prototype.afterBattle = function (enemyId, x, y, callback) {
+    return this.eventdata.afterBattle(enemyId, x, y, callback);
+}
 
-                // 转换楼层能否穿透
-                if (trigger=='changeFloor' && !noPass) {
-                    var canCross = core.flags.portalWithoutTrigger;
-                    if (core.isset(mapBlocks[b].event.data) && core.isset(mapBlocks[b].event.data.portalWithoutTrigger))
-                        canCross=mapBlocks[b].event.data.portalWithoutTrigger;
-                    if (canCross) {
-                        if (core.status.replay.replaying) {
-                            if (core.status.replay.toReplay[0]=='no') {
-                                core.status.replay.toReplay.shift();
-                                core.status.route.push("no");
-                                continue;
-                            }
-                        }
-                        else if (core.status.automaticRoute.autoHeroMove || core.status.automaticRoute.autoStep<core.status.automaticRoute.autoStepRoutes.length) {
-                            core.status.route.push("no");
-                            continue;
-                        }
-                    }
-                }
-                core.status.automaticRoute.moveDirectly = false;
-                core.material.events[trigger](mapBlocks[b], core, function (data) {
+events.prototype._sys_openDoor = function (data, callback) {
+    this.openDoor(data.x, data.y, true, function () {
+        core.replay();
+        if (callback) callback();
+    });
+}
 
-                });
-            }
-        }
+////// 开门 //////
+events.prototype.openDoor = function (x, y, needKey, callback) {
+    var id = core.getBlockId(x, y);
+    core.saveAndStopAutomaticRoute();
+    if (!this._openDoor_check(id, x, y, needKey)) {
+        var locked = core.status.lockControl;
+        core.waitHeroToStop(function () {
+            if (!locked) core.unLockControl();
+            if (callback) callback();
+        });
+        return;
     }
+    core.playSound("door.mp3");
+    this._openDoor_animate(id, x, y, callback);
+}
+
+events.prototype._openDoor_check = function (id, x, y, needKey) {
+    // 是否存在门或暗墙
+    if (!core.terrainExists(x, y, id) || !(id.endsWith("Door") || id.endsWith("Wall"))
+        || core.material.icons.animates[id] == null) {
+        core.clearContinueAutomaticRoute();
+        return false;
+    }
+
+    if (id == 'steelDoor' && core.flags.steelDoorWithoutKey)
+        needKey = false;
+
+    if (needKey && id.endsWith("Door")) {
+        var key = id.replace("Door", "Key");
+        if (!core.hasItem(key)) {
+            if (key != "specialKey")
+                core.drawTip("你没有" + ((core.material.items[key] || {}).name || "钥匙"));
+            else core.drawTip("无法开启此门");
+            core.clearContinueAutomaticRoute();
+            return false;
+        }
+        if (!core.status.event.id) core.autosave(true);
+        core.removeItem(key);
+    }
+    return true;
+}
+
+events.prototype._openDoor_animate = function (id, x, y, callback) {
+    var door = core.material.icons.animates[id];
+    var speed = id.endsWith("Door") ? 30 : 70;
+
+    var locked = core.status.lockControl;
+    core.lockControl();
+    core.status.replay.animate = true;
+    core.removeBlock(x, y);
+    core.drawImage('event', core.material.images.animates, 0, 32 * door, 32, 32, 32 * x, 32 * y, 32, 32);
+    var state = 0;
+    var animate = window.setInterval(function () {
+        core.clearMap('event', 32 * x, 32 * y, 32, 32);
+        state++;
+        if (state == 4) {
+            clearInterval(animate);
+            delete core.animateFrame.asyncId[animate];
+            if (!locked) core.unLockControl();
+            core.status.replay.animate = false;
+            core.events.afterOpenDoor(id, x, y, callback);
+            return;
+        }
+        core.drawImage('event', core.material.images.animates, 32 * state, 32 * door, 32, 32, 32 * x, 32 * y, 32, 32);
+    }, speed / Math.max(core.status.replay.speed, 1));
+    core.animateFrame.asyncId[animate] = true;
+}
+
+////// 开一个门后触发的事件 //////
+events.prototype.afterOpenDoor = function (doorId, x, y, callback) {
+    return this.eventdata.afterOpenDoor(doorId, x, y, callback);
+}
+
+events.prototype._sys_getItem = function (data, callback) {
+    this.getItem(data.event.id, 1, data.x, data.y, callback);
+}
+
+////// 获得某个物品 //////
+events.prototype.getItem = function (id, num, x, y, callback) {
+    if (num == null) num = 1;
+    num = num || 1;
+    var itemCls = core.material.items[id].cls;
+    core.items.getItemEffect(id, num);
+    core.removeBlock(x, y);
+    var text = '获得 ' + core.material.items[id].name;
+    if (num > 1) text += "x" + num;
+    if (itemCls === 'items') text += core.items.getItemEffectTip(id);
+    core.drawTip(text, id);
+    core.updateStatusBar();
+
+    this.afterGetItem(id, x, y, callback);
+}
+
+events.prototype.afterGetItem = function (id, x, y, callback) {
+    this.eventdata.afterGetItem(id, x, y, callback);
+}
+
+////// 获得面前的物品（轻按） //////
+events.prototype.getNextItem = function (noRoute) {
+    if (core.isMoving() || !core.canMoveHero() || !core.flags.enableGentleClick) return false;
+
+    var nextX = core.nextX(), nextY = core.nextY();
+    var block = core.getBlock(nextX, nextY);
+    if (block == null) return false;
+    if (block.block.event.trigger == 'getItem') {
+        if (!noRoute) core.status.route.push("getNext");
+        this.getItem(block.block.event.id, 1, nextX, nextY);
+        return true;
+    }
+    return false;
+}
+
+events.prototype._sys_changeFloor = function (data, callback) {
+    data = data.event.data;
+    var heroLoc = {};
+    if (data.loc) heroLoc = {'x': data.loc[0], 'y': data.loc[1]};
+    if (data.direction) heroLoc.direction = data.direction;
+    if (core.status.event.id != 'action') core.status.event.id = null;
+    core.changeFloor(data.floorId, data.stair, heroLoc, data.time, function () {
+        core.replay();
+        if (callback) callback();
+    });
 }
 
 ////// 楼层切换 //////
 events.prototype.changeFloor = function (floorId, stair, heroLoc, time, callback, fromLoad) {
-
-    if (!core.isset(floorId)) floorId = core.status.floorId;
-
-    if (floorId == ':before') {
-        var index=core.floorIds.indexOf(core.status.floorId);
-        if (index>0) floorId = core.floorIds[index-1];
-        else floorId=core.status.floorId;
-    }
-    else if (floorId == ':next') {
-        var index=core.floorIds.indexOf(core.status.floorId);
-        if (index<core.floorIds.length-1) floorId = core.floorIds[index+1];
-        else floorId=core.status.floorId;
+    var info = this._changeFloor_getInfo(floorId, stair, heroLoc, time);
+    if (info == null) {
+        if (callback) callback();
+        return;
     }
+    info.fromLoad = fromLoad;
+    floorId = info.floorId;
+    info.locked = core.status.lockControl;
 
-    var displayAnimate=(!core.isset(time) || time>=100) && !core.status.replay.replaying;
-
-    time = time || 800;
-    time /= 20;
+    core.dom.floorNameLabel.innerHTML = core.status.maps[floorId].title;
     core.lockControl();
-    core.stopHero();
     core.stopAutomaticRoute();
     core.clearContinueAutomaticRoute();
-    core.status.replay.animate=true;
-    core.dom.floorNameLabel.innerHTML = core.status.maps[floorId].title;
-    if (!core.isset(stair) && !core.isset(heroLoc))
-        heroLoc = core.status.hero.loc;
-    if (core.isset(stair)) {
-        if (!core.isset(heroLoc)) heroLoc={};
+    core.status.replay.animate = true;
 
-        if (core.isset(core.floors[floorId][stair])) {
-            heroLoc.x = core.floors[floorId][stair][0];
-            heroLoc.y = core.floors[floorId][stair][1];
+    this._changeFloor_beforeChange(info, callback);
+}
+
+events.prototype._changeFloor_getInfo = function (floorId, stair, heroLoc, time) {
+    floorId = floorId || core.status.floorId;
+    if (floorId == ':before') {
+        var index = core.floorIds.indexOf(core.status.floorId);
+        if (index > 0) floorId = core.floorIds[index - 1];
+        else floorId = core.status.floorId;
+    }
+    else if (floorId == ':next') {
+        var index = core.floorIds.indexOf(core.status.floorId);
+        if (index < core.floorIds.length - 1) floorId = core.floorIds[index + 1];
+        else floorId = core.status.floorId;
+    }
+    if (!core.status.maps[floorId]) {
+        main.log("不存在的楼层：" + floorId);
+        return null;
+    }
+
+    if (main.mode != 'play' || core.isReplaying()) time = 0;
+    if (time == null) time = core.values.floorChangeTime;
+    if (time == null) time = 800;
+    if (time < 100) time = 0;
+    time /= 20;
+
+    return {
+        floorId: floorId,
+        time: time,
+        heroLoc: core.clone(this._changeFloor_getHeroLoc(floorId, stair, heroLoc))
+    };
+}
+
+events.prototype._changeFloor_getHeroLoc = function (floorId, stair, heroLoc) {
+    if (!heroLoc)
+        heroLoc = core.clone(core.status.hero.loc);
+    if (stair) {
+        // 检查该层地图的 upFloor & downFloor
+        if (core.status.maps[floorId][stair]) {
+            heroLoc.x = core.status.maps[floorId][stair][0];
+            heroLoc.y = core.status.maps[floorId][stair][1];
         }
         else {
             var blocks = core.status.maps[floorId].blocks;
             for (var i in blocks) {
-                if (core.isset(blocks[i].event) && !blocks[i].disable && blocks[i].event.id === stair) {
+                if (!blocks[i].disable && blocks[i].event.id === stair) {
                     heroLoc.x = blocks[i].x;
                     heroLoc.y = blocks[i].y;
                     break;
                 }
             }
         }
-        if (!core.isset(heroLoc.x)) {
-            heroLoc.x=core.status.hero.loc.x;
-            heroLoc.y=core.status.hero.loc.y;
-        }
     }
-    if (core.status.maps[floorId].canFlyTo && core.status.hero.flyRange.indexOf(floorId)<0) {
-        core.status.hero.flyRange.push(floorId);
-        core.status.hero.flyRange.sort(function (a, b) {
-            return core.floorIds.indexOf(a) - core.floorIds.indexOf(b);
-        })
-    }
-
-    window.setTimeout(function () {
-
-        var changing = function () {
-
-            // 根据文字判断是否斜体
-            var floorName = core.status.maps[floorId].name;
-            if (!core.isset(floorName) || floorName=="") floorName="&nbsp;"
-            core.statusBar.floor.innerHTML = floorName;
-            if (/^[+-]?\d+$/.test(floorName)) {
-                core.statusBar.floor.style.fontStyle = 'italic';
-                core.statusBar.floor.style.fontSize = '1.1em';
-            }
-            else {
-                core.statusBar.floor.style.fontStyle = 'normal';
-                if (floorName.length<=5)
-                    core.statusBar.floor.style.fontSize = '1.1em';
-                else if (floorName.length==6)
-                    core.statusBar.floor.style.fontSize = '0.9em';
-                else
-                    core.statusBar.floor.style.fontSize = '0.7em';
-            }
-
-            // 更改BGM
-            if (core.isset(core.floors[floorId].bgm)) {
-                core.playBgm(core.floors[floorId].bgm);
-            }
-
-            // 不存在事件时，更改画面色调
-            if (core.status.event.id == null) {
-                // 默认画面色调
-                if (core.isset(core.floors[floorId].color)) {
-                    var color = core.floors[floorId].color;
-
-                    // 直接变色
-                    core.dom.curtain.style.background = core.arrayToRGB(color);
-                    if (core.isset(color[3]))
-                        core.dom.curtain.style.opacity = color[3];
-                    else core.dom.curtain.style.opacity=1;
-                    core.status.curtainColor = color;
-                }
-                else {
-                    core.dom.curtain.style.background = "#000000";
-                    core.dom.curtain.style.opacity = 0;
-                }
-            }
-
-            // 更改天气
-            if (core.isset(core.floors[floorId].weather)) {
-                core.setWeather(core.floors[floorId].weather[0], core.floors[floorId].weather[1])
-            }
-            else core.setWeather();
-
-            // 清除gif
-            core.dom.gif.innerHTML = "";
-
-            // 检查重生
-            if (!core.isset(fromLoad)) {
-                core.status.maps[floorId].blocks.forEach(function(block) {
-                    if (block.disable && core.isset(block.event) && block.event.cls.indexOf('enemy')==0
-                        && core.enemys.hasSpecial(core.material.enemys[block.event.id].special, 23)) {
-                        block.disable = false;
-                    }
-                })
-            }
-            // 重置画布尺寸
-            core.maps.resizeMap(floorId);
-            // 画地图
-            core.drawMap(floorId, function () {
-                if (core.isset(heroLoc.direction))
-                    core.setHeroLoc('direction', heroLoc.direction);
-                core.setHeroLoc('x', heroLoc.x);
-                core.setHeroLoc('y', heroLoc.y);
-                core.clearMap('hero');
-                core.drawHero();
-
-                var changed = function () {
-                    core.unLockControl();
-                    core.status.replay.animate=false;
-                    core.events.afterChangeFloor(floorId);
-                    if (core.isset(callback)) callback();
-                }
-                if (displayAnimate) {
-                    core.hide(core.dom.floorMsgGroup, time/4, function () {
-                        changed();
-                    });
-                }
-                else {
-                    changed();
-                }
-            });
-        }
-        core.playSound('floor.mp3');
-        if (displayAnimate) {
-            core.show(core.dom.floorMsgGroup, time/2, function () {
-                changing();
-            });
-        }
-        else {
-            changing();
-        }
-    }, 25);
+    ['x', 'y', 'direction'].forEach(function (name) {
+        if (heroLoc[name] == null)
+            heroLoc[name] = core.getHeroLoc(name);
+    });
+    return heroLoc;
 }
 
-////// 图片淡入/淡出 //////
-events.prototype.animateImage = function (type, image, loc, time, callback) {
-    time = time||0;
-    if ((type!='show' && type!='hide') || time<=0) {
-        if (core.isset(callback)) callback();
+events.prototype._changeFloor_beforeChange = function (info, callback) {
+    core.playSound('floor.mp3');
+    // 需要 setTimeout 执行，不然会出错
+    window.setTimeout(function () {
+        if (info.time == 0)
+            core.events._changeFloor_changing(info, callback);
+        else
+            core.showWithAnimate(core.dom.floorMsgGroup, info.time / 2, function () {
+                core.events._changeFloor_changing(info, callback);
+            });
+    }, 25)
+}
+
+events.prototype._changeFloor_changing = function (info, callback) {
+    this.changingFloor(info.floorId, info.heroLoc, info.fromLoad);
+
+    if (info.time == 0)
+        this._changeFloor_afterChange(info, callback);
+    else
+        core.hideWithAnimate(core.dom.floorMsgGroup, info.time / 4, function () {
+            core.events._changeFloor_afterChange(info, callback);
+        });
+}
+
+events.prototype._changeFloor_afterChange = function (info, callback) {
+    if (!info.locked) core.unLockControl();
+    core.status.replay.animate = false;
+    core.events.afterChangeFloor(info.floorId, info.fromLoad);
+
+    if (callback) callback();
+}
+
+events.prototype.changingFloor = function (floorId, heroLoc, fromLoad) {
+    this.eventdata.changingFloor(floorId, heroLoc, fromLoad);
+}
+
+////// 转换楼层结束的事件 //////
+events.prototype.afterChangeFloor = function (floorId, fromLoad) {
+    if (main.mode != 'play') return;
+    return this.eventdata.afterChangeFloor(floorId, fromLoad);
+}
+
+////// 是否到达过某个楼层 //////
+events.prototype.hasVisitedFloor = function (floorId) {
+    return core.getFlag("__visited__")[floorId] || false;
+}
+
+////// 到达某楼层 //////
+events.prototype.visitFloor = function (floorId) {
+    core.getFlag("__visited__")[floorId] = true;
+}
+
+events.prototype._sys_passNet = function (data, callback) {
+    this.passNet(data);
+    if (callback) callback();
+}
+
+////// 经过一个路障 //////
+events.prototype.passNet = function (data) {
+    if (core.hasItem('shoes')) return;
+    // 血网 lavaNet 移动到 checkBlock 中处理
+    if (data.event.id == 'poisonNet') { // 毒网
+        core.insertAction({"type":"insert","name":"毒衰咒处理","args":[0]});
+    }
+    else if (data.event.id == 'weakNet') { // 衰网
+        core.insertAction({"type":"insert","name":"毒衰咒处理","args":[1]});
+    }
+    else if (data.event.id == 'curseNet') { // 咒网
+        core.insertAction({"type":"insert","name":"毒衰咒处理","args":[2]});
+    }
+    core.updateStatusBar();
+}
+
+events.prototype._sys_pushBox = function (data, callback) {
+    this.pushBox(data);
+    if (callback) callback();
+}
+
+////// 推箱子 //////
+events.prototype.pushBox = function (data) {
+    if (data.event.id != 'box' && data.event.id != 'boxed') return;
+
+    // 判断还能否前进，看看是否存在事件
+    var direction = core.getHeroLoc('direction'),
+        nx = data.x + core.utils.scan[direction].x, ny = data.y + core.utils.scan[direction].y;
+
+    // 检测能否推上去
+    if (!core.canMoveHero() || !core.canMoveHero(data.x, data.y, direction)) return;
+    var nextId = core.getBlockId(nx, ny);
+    if (nextId != null && nextId != 'flower') return;
+
+    core.setBlock(nextId == null ? 169 : 170, nx, ny);
+
+    if (data.event.id == 'box')
+        core.removeBlock(data.x, data.y);
+    else
+        core.setBlock(168, data.x, data.y);
+
+    core.updateStatusBar();
+    this._pushBox_moveHero(direction);
+}
+
+events.prototype._pushBox_moveHero = function (direction) {
+    core.status.replay.animate = true;
+    core.lockControl();
+    setTimeout(function () {
+        core.moveHero(direction, function () {
+            core.status.replay.animate = false;
+            core.status.route.pop();
+            core.events.afterPushBox();
+            // 可能有阻击...
+            if (core.status.event.id == null) {
+                core.unLockControl();
+                core.replay();
+            }
+        });
+    });
+}
+
+////// 推箱子后的事件 //////
+events.prototype.afterPushBox = function () {
+    return this.eventdata.afterPushBox();
+}
+
+events.prototype._sys_changeLight = function (data, callback) {
+    core.events.changeLight(data.event.id, data.x, data.y);
+    if (callback) callback();
+}
+
+////// 改变亮灯（感叹号）的事件 //////
+events.prototype.changeLight = function (id, x, y) {
+    if (id != null && id != 'light') return;
+    core.setBlock(core.getNumberById('darkLight'), x, y);
+    return this.eventdata.afterChangeLight(x, y);
+}
+
+events.prototype._sys_ski = function (data, callback) {
+    core.insertAction(["V2.6后，请将滑冰放在背景层！"], data.x, data.y, callback);
+}
+
+events.prototype._sys_action = function (data, callback) {
+    var ev = core.clone(data.event.data), ex = data.x, ey = data.y;
+    // 检查是否需要改变朝向
+    if (ex == core.nextX() && ey == core.nextY()) {
+        var dir = core.reverseDirection();
+        var id = data.event.id, toId = (data.event.faceIds || {})[dir];
+        if (toId && id != toId) {
+            var number = core.getNumberById(toId);
+            if (number > 0)
+                core.setBlock(number, ex, ey);
+        }
+    }
+    this.insertAction(ev, ex, ey, callback);
+}
+
+events.prototype._sys_custom = function (data, callback) {
+    core.insertAction(["请使用\r[yellow]core.registerSystemEvent('custom', func)\r来处理自己添加的系统触发器！"],
+        data.x, data.y, callback);
+}
+
+// ------ 自定义事件的处理 ------ //
+
+////// 注册一个自定义事件 //////
+// type为事件名，func为事件的处理函数，可接受(data, x, y, prefix)参数
+// data为事件内容，x和y为当前点坐标（可为null），prefix为当前点前缀
+events.prototype.registerEvent = function (type, func) {
+    this.actions[type] = func;
+}
+
+////// 注销一个自定义事件
+events.prototype.unregisterEvent = function (type) {
+    delete this.actions[type];
+}
+
+////// 执行一个自定义事件
+events.prototype.doEvent = function (data, x, y, prefix) {
+    var type = data.type;
+    if (this.actions[type]) {
+        try {
+            return core.doFunc(this.actions[type], this, data, x, y, prefix);
+        }
+        catch (e) {
+            main.log(e);
+            main.log("ERROR in actions["+type+"]");
+        }
+    }
+    if (this["_action_" + type]) return this["_action_" + type](data, x, y, prefix);
+    core.insertAction("未知的自定义事件: " + type + "！");
+    core.doAction();
+}
+
+events.prototype.setEvents = function (list, x, y, callback) {
+    var data = core.status.event.data || {};
+    if (list)
+        data.list = [{todo: core.clone(list), total: core.clone(list), condition: "false"}];
+    if (x != null) data.x = x;
+    if (y != null) data.y = y;
+    if (callback) data.callback = callback;
+    core.status.event.id = 'action';
+    core.status.event.data = data;
+}
+
+////// 开始执行一系列自定义事件 //////
+events.prototype.startEvents = function (list, x, y, callback) {
+    if (!list) return;
+    if (!(list instanceof Array)) {
+        list = [list];
+    }
+    this.setEvents(list, x, y, callback);
+    // 停止勇士
+    core.waitHeroToStop(function () {
+        core.lockControl();
+        core.doAction();
+    });
+}
+
+////// 执行当前自定义事件列表中的下一个事件 //////
+events.prototype.doAction = function () {
+    // 清空boxAnimate和UI层
+    core.clearUI();
+    clearInterval(core.status.event.interval);
+    core.status.event.interval = null;
+    // 判定是否执行完毕
+    if (this._doAction_finishEvents()) return;
+    // 当前点坐标和前缀
+    var x = core.status.event.data.x, y = core.status.event.data.y;
+    var prefix = [core.status.floorId || ":f", x != null ? x : "x", y != null ? y : "y"].join("@");
+    var current = core.status.event.data.list[0];
+    if (this._popEvents(current, prefix)) return;
+    // 当前要执行的事件
+    var data = current.todo.shift();
+    core.status.event.data.current = data;
+    if (typeof data == "string")
+        data = {"type": "text", "text": data};
+    core.status.event.data.type = data.type;
+    this.doEvent(data, x, y, prefix);
+    return;
+}
+
+events.prototype._doAction_finishEvents = function () {
+    // 事件处理完毕
+    if (core.status.event.data.list.length == 0) {
+        var callback = core.status.event.data.callback;
+        core.ui.closePanel();
+        if (callback) callback();
+        core.replay();
+        return true;
+    }
+    return false;
+}
+
+events.prototype._popEvents = function (current, prefix) {
+    if (current.todo.length == 0) { // current list is empty
+        if (core.calValue(current.condition, prefix)) { // check condition
+            current.todo = core.clone(current.total);
+        }
+        else {
+            core.status.event.data.list.shift(); // remove stack
+        }
+        core.doAction();
+        return true;
+    }
+    return false;
+}
+
+////// 往当前事件列表之前或之后添加一个或多个事件 //////
+events.prototype.insertAction = function (action, x, y, callback, addToLast) {
+    if (core.hasFlag("__statistics__")) return;
+    if (core.status.gameOver) return;
+
+    // ------ 判定commonEvent
+    var commonEvent = this.getCommonEvent(action);
+    if (commonEvent instanceof Array) {
+        // 将公共事件视为一个do-while事件插入执行，可被break跳出
+        action = [{"type": "dowhile", "condition": "false", "data": commonEvent}];
+    }
+    if (!action) return;
+
+    if (core.status.event.id != 'action') {
+        this.startEvents(action, x, y, callback);
+    }
+    else {
+        if (addToLast)
+            core.push(core.status.event.data.list[0].todo, action)
+        else
+            core.unshift(core.status.event.data.list[0].todo, action);
+        this.setEvents(null, x, y, callback);
+    }
+}
+
+////// 获得一个公共事件 //////
+events.prototype.getCommonEvent = function (name) {
+    if (!name || typeof name !== 'string') return null;
+    return this.commonEvent[name] || null;
+}
+
+////// 恢复一个事件 //////
+events.prototype.recoverEvents = function (data) {
+    if (data) {
+        core.ui.closePanel();
+        core.lockControl();
+        core.status.event.id = 'action';
+        core.status.event.data = data;
+        setTimeout(function () {
+            core.doAction();
+        }, 30);
+        return true;
+    }
+    return false;
+}
+
+// ------ 样板提供的的自定义事件 ------ //
+
+events.prototype.__action_checkReplaying = function () {
+    if (core.isReplaying()) {
+        core.doAction();
+        return true;
+    }
+    return false;
+}
+
+events.prototype.__action_getLoc = function (loc, x, y, prefix) {
+    if (loc) {
+        x = core.calValue(loc[0], prefix);
+        y = core.calValue(loc[1], prefix);
+    }
+    return [x, y];
+}
+
+events.prototype.__action_getHeroLoc = function (loc, prefix) {
+    return this.__action_getLoc(loc, core.getHeroLoc('x'), core.getHeroLoc('y'), prefix);
+}
+
+events.prototype.__action_getLoc2D = function (loc, x, y, prefix) {
+    if (!(loc && loc[0] instanceof Array))
+        loc = [this.__action_getLoc(loc, x, y, prefix)];
+    return loc;
+}
+
+events.prototype.__action_doAsyncFunc = function (isAsync, func) {
+    var parameters = Array.prototype.slice.call(arguments, 2);
+    if (isAsync) {
+        func.apply(this, parameters);
+        core.doAction();
+    }
+    else {
+        func.apply(this, parameters.concat(core.doAction));
+    }
+}
+
+events.prototype._action_text = function (data, x, y, prefix) {
+    if (this.__action_checkReplaying()) return;
+    core.ui.drawTextBox(data.text, data.showAll);
+}
+
+events.prototype._action_autoText = function (data, x, y, prefix) {
+    if (this.__action_checkReplaying()) return;
+    core.ui.drawTextBox(data.text);
+    setTimeout(core.doAction, data.time || 3000);
+}
+
+events.prototype._action_scrollText = function (data, x, y, prefix) {
+    if (this.__action_checkReplaying()) return;
+    this.__action_doAsyncFunc(data.async, core.drawScrollText, data.text, data.time || 5000, data.lineHeight || 1.4);
+}
+
+events.prototype._action_comment = function (data, x, y, prefix) {
+    core.doAction();
+}
+
+events.prototype._action_setText = function (data, x, y, prefix) {
+    ["position", "offset", "align", "bold", "titlefont", "textfont", "time"].forEach(function (t) {
+        if (data[t] != null) core.status.textAttribute[t] = data[t];
+    });
+    ["background", "title", "text"].forEach(function (t) {
+        if ((data[t] instanceof Array) && data[t].length >= 3) {
+            if (data[t].length == 3) data[t].push(1);
+            core.status.textAttribute[t] = data[t];
+        }
+        if (t == 'background') {
+            var name = core.getMappedName(data[t]);
+            var img = core.material.images.images[name];
+            if (img && img.width == 192 && img.height == 128) {
+                core.status.textAttribute[t] = name;
+            }
+        }
+    });
+    core.setFlag('textAttribute', core.status.textAttribute);
+    core.doAction();
+}
+
+events.prototype._action_tip = function (data, x, y, prefix) {
+    core.drawTip(core.replaceText(data.text), data.icon);
+    core.doAction();
+}
+
+events.prototype._action_show = function (data, x, y, prefix) {
+    data.loc = this.__action_getLoc2D(data.loc, x, y, prefix);
+    if (data.time > 0 && !(data.floorId && data.floorId != core.status.floorId)) {
+        this.__action_doAsyncFunc(data.async, core.animateBlock, data.loc, 'show', data.time);
+    }
+    else {
+        data.loc.forEach(function (t) {
+            core.showBlock(t[0], t[1], data.floorId);
+        });
+        core.doAction();
+    }
+}
+
+events.prototype._action_hide = function (data, x, y, prefix) {
+    data.loc = this.__action_getLoc2D(data.loc, x, y, prefix);
+    if (data.time > 0 && !(data.floorId && data.floorId != core.status.floorId)) {
+        data.loc.forEach(function (t) {
+            core.hideBlock(t[0], t[1], data.floorId);
+        });
+        this.__action_doAsyncFunc(data.async, core.animateBlock, data.loc, 'hide', data.time);
+    }
+    else {
+        data.loc.forEach(function (t) {
+            core.removeBlock(t[0], t[1], data.floorId)
+        });
+        core.doAction();
+    }
+}
+
+events.prototype._action_setBlock = function (data, x, y, prefix) {
+    var loc = this.__action_getLoc(data.loc, x, y, prefix);
+    core.setBlock(data.number, loc[0], loc[1], data.floorId);
+    core.doAction();
+}
+
+events.prototype._action_showFloorImg = function (data, x, y, prefix) {
+    core.maps.showFloorImage(this.__action_getLoc2D(data.loc, x, y, prefix), data.floorId, core.doAction);
+}
+
+events.prototype._action_hideFloorImg = function (data, x, y, prefix) {
+    core.maps.hideFloorImage(this.__action_getLoc2D(data.loc, x, y, prefix), data.floorId, core.doAction);
+}
+
+events.prototype._action_showBgFgMap = function (data, x, y, prefix) {
+    core.maps.showBgFgMap(data.name, this.__action_getLoc2D(data.loc, x, y, prefix), data.floorId, core.doAction)
+}
+
+events.prototype._action_hideBgFgMap = function (data, x, y, prefix) {
+    core.maps.hideBgFgMap(data.name, this.__action_getLoc2D(data.loc, x, y, prefix), data.floorId, core.doAction);
+}
+
+events.prototype._action_setBgFgBlock = function (data, x, y, prefix) {
+    var loc = this.__action_getLoc(data.loc, x, y, prefix);
+    core.setBgFgBlock(data.name, data.number, loc[0], loc[1], data.floorId);
+    core.doAction();
+}
+
+events.prototype._action_follow = function (data, x, y, prefix) {
+    this.follow(data.name);
+    core.doAction();
+}
+
+events.prototype._action_unfollow = function (data, x, y, prefix) {
+    this.unfollow(data.name);
+    core.doAction();
+}
+
+events.prototype._action_animate = function (data, x, y, prefix) {
+    if (data.loc == 'hero') data.loc = [core.getHeroLoc('x'), core.getHeroLoc('y')];
+    else data.loc = this.__action_getLoc(data.loc, x, y, prefix);
+    this.__action_doAsyncFunc(data.async, core.drawAnimate, data.name, data.loc[0], data.loc[1]);
+}
+
+events.prototype._action_move = function (data, x, y, prefix) {
+    var loc = this.__action_getLoc(data.loc, x, y, prefix);
+    this.__action_doAsyncFunc(data.async, core.moveBlock, loc[0], loc[1], data.steps, data.time, data.keep);
+}
+
+events.prototype._action_moveHero = function (data, x, y, prefix) {
+    this.__action_doAsyncFunc(data.async, core.eventMoveHero, data.steps, data.time);
+}
+
+events.prototype._action_jump = function (data, x, y, prefix) {
+    var from = this.__action_getLoc(data.from, x, y, prefix),
+        to = this.__action_getLoc(data.to, x, y, prefix);
+    this.__action_doAsyncFunc(data.async, core.jumpBlock, from[0], from[1], to[0], to[1], data.time, data.keep);
+}
+
+events.prototype._action_jumpHero = function (data, x, y, prefix) {
+    var loc = this.__action_getHeroLoc(data.loc, prefix);
+    this.__action_doAsyncFunc(data.async, core.jumpHero, loc[0], loc[1], data.time);
+}
+
+events.prototype._action_changeFloor = function (data, x, y, prefix) {
+    var loc = this.__action_getHeroLoc(data.loc, prefix);
+    var heroLoc = {x: loc[0], y: loc[1], direction: data.direction};
+    core.changeFloor(data.floorId || core.status.floorId, null, heroLoc, data.time, core.doAction);
+}
+
+events.prototype._action_changePos = function (data, x, y, prefix) {
+    core.clearMap('hero');
+    var loc = this.__action_getHeroLoc(data.loc, prefix);
+    core.setHeroLoc('x', loc[0]);
+    core.setHeroLoc('y', loc[1]);
+    if (data.direction) core.setHeroLoc('direction', data.direction);
+    core.drawHero();
+    core.doAction();
+}
+
+events.prototype._action_showImage = function (data, x, y, prefix) {
+    if (core.isReplaying()) data.time = 0;
+    this.__action_doAsyncFunc(data.async || data.time == 0, core.showImage,
+        data.code, data.image, data.sloc, data.loc, data.opacity, data.time);
+}
+
+events.prototype._action_showTextImage = function (data, x, y, prefix) {
+    var loc = this.__action_getLoc(data.loc, 0, 0, prefix);
+    if (core.isReplaying()) data.time = 0;
+    this.__action_doAsyncFunc(data.async || data.time == 0, core.showImage,
+        data.code, core.ui.textImage(data.text), loc[0], loc[1], 100, 100, data.opacity, data.time);
+}
+
+events.prototype._action_hideImage = function (data, x, y, prefix) {
+    if (core.isReplaying()) data.time = 0;
+    this.__action_doAsyncFunc(data.async || data.time == 0, core.hideImage, data.code, data.time);
+}
+
+events.prototype._action_showGif = function (data, x, y, prefix) {
+    var loc = this.__action_getLoc(data.loc, 0, 0, prefix);
+    this.showGif(data.name, loc[0], loc[1]);
+    core.doAction();
+}
+
+events.prototype._action_moveImage = function (data, x, y, prefix) {
+    if (this.__action_checkReplaying()) return;
+    this.__action_doAsyncFunc(data.async, core.moveImage, data.code, data.to, data.opacity, data.time);
+}
+
+events.prototype._action_setFg = function (data, x, y, prefix) {
+    return this._action_setCurtain(data, x, y, prefix);
+}
+
+events.prototype._action_setCurtain = function (data, x, y, prefix) {
+    if (data.async) {
+        core.setCurtain(data.color, data.time);
+        core.setFlag('__color__', data.color || null);
+        core.doAction();
+    }
+    else {
+        core.setCurtain(data.color, data.time, function () {
+            core.setFlag('__color__', data.color || null);
+            core.doAction();
+        });
+    }
+}
+
+events.prototype._action_screenFlash = function (data, x, y, prefix) {
+    this.__action_doAsyncFunc(data.async, core.screenFlash, data.color, data.time, data.times);
+}
+
+events.prototype._action_setWeather = function (data, x, y, prefix) {
+    core.setWeather(data.name, data.level);
+    if (data.name == 'rain' || data.name == 'snow' || data.name == 'fog')
+        core.setFlag('__weather__', [data.name, data.level]);
+    else core.removeFlag('__weather__');
+    core.doAction();
+}
+
+events.prototype._action_openDoor = function (data, x, y, prefix) {
+    var loc = this.__action_getLoc(data.loc, x, y, prefix);
+    var floorId = data.floorId || core.status.floorId;
+    if (floorId == core.status.floorId) {
+        this.__action_doAsyncFunc(data.async, core.openDoor, loc[0], loc[1], data.needKey);
+    }
+    else {
+        core.removeBlock(loc[0], loc[1], floorId);
+        core.doAction();
+    }
+}
+
+events.prototype._action_closeDoor = function (data, x, y, prefix) {
+    var loc = this.__action_getLoc(data.loc, x, y, prefix);
+    this.__action_doAsyncFunc(data.async, core.closeDoor, loc[0], loc[1], data.id);
+}
+
+events.prototype._action_useItem = function (data, x, y, prefix) {
+    // 考虑到可能覆盖楼传事件的问题，这里不对fly进行检查。
+    if (data.id != 'book' && core.canUseItem(data.id)) {
+        core.useItem(data.id, true, core.doAction);
+    }
+    else {
+        core.drawTip("当前无法使用" + ((core.material.items[data.id] || {}).name || "未知道具"));
+        core.doAction();
+    }
+}
+
+events.prototype._action_openShop = function (data, x, y, prefix) {
+    core.status.shops[data.id].visited = true;
+    this.setEvents([]);
+    if (!core.isReplaying())
+        this.openShop(data.id);
+    if (core.status.event.id == 'action')
+        core.doAction();
+}
+
+events.prototype._action_disableShop = function (data, x, y, prefix) {
+    this.disableQuickShop(data.id);
+    core.doAction();
+}
+
+events.prototype._action_battle = function (data, x, y, prefix) {
+    if (data.id) {
+        this.battle(data.id, null, null, true, core.doAction);
+    }
+    else {
+        var loc = this.__action_getLoc(data.loc, x, y, prefix);
+        this.battle(null, loc[0], loc[1], true, core.doAction);
+    }
+}
+
+events.prototype._action_trigger = function (data, x, y, prefix) {
+    var loc = this.__action_getLoc(data.loc, x, y, prefix);
+    var block = core.getBlock(loc[0], loc[1]);
+    if (block != null && block.block.event.trigger) {
+        block = block.block;
+        this.setEvents(data.keep ? null : [], block.x, block.y);
+        if (block.event.trigger == 'action')
+            this.insertAction(block.event.data);
+        else {
+            core.doSystemEvent(block.event.trigger, block, core.doAction);
+            return;
+        }
+    }
+    core.doAction();
+}
+
+events.prototype._action_insert = function (data, x, y, prefix) {
+    // 设置参数
+    if (data.args instanceof Array) {
+       for (var i = 0; i < data.args.length; ++i) {
+           try {
+               if (data.args[i] != null)
+                   core.setFlag('arg'+(i+1), data.args[i]);
+           } catch (e) { main.log(e); }
+       }
+    }
+    if (data.name) { // 公共事件
+        core.setFlag('arg0', data.name);
+        core.insertAction(data.name);
+    }
+    else {
+        var loc = this.__action_getLoc(data.loc, x, y, prefix);
+        core.setFlag('arg0', loc);
+        var floorId = data.floorId || core.status.floorId;
+        var which = data.which || "events";
+        var event = (core.floors[floorId][which]||[])[loc[0] + "," + loc[1]];
+        if (event) this.insertAction(event.data || event);
+    }
+    core.doAction();
+}
+
+events.prototype._action_playBgm = function (data, x, y, prefix) {
+    core.playBgm(data.name);
+    core.doAction();
+}
+
+events.prototype._action_pauseBgm = function (data, x, y, prefix) {
+    core.pauseBgm();
+    core.doAction();
+}
+
+events.prototype._action_resumeBgm = function (data, x, y, prefix) {
+    core.resumeBgm();
+    core.doAction();
+}
+
+events.prototype._action_loadBgm = function (data, x, y, prefix) {
+    core.loadBgm(data.name);
+    core.doAction();
+}
+
+events.prototype._action_freeBgm = function (data, x, y, prefix) {
+    core.freeBgm(data.name);
+    core.doAction();
+}
+
+events.prototype._action_playSound = function (data, x, y, prefix) {
+    if (data.stop) core.stopSound();
+    core.playSound(data.name);
+    core.doAction();
+}
+
+events.prototype._action_stopSound = function (data, x, y, prefix) {
+    core.stopSound();
+    core.doAction();
+}
+
+events.prototype._action_setVolume = function (data, x, y, prefix) {
+    data.value = core.clamp(parseInt(data.value) / 100, 0, 1);
+    core.setFlag("__volume__", data.value);
+    this.__action_doAsyncFunc(data.async, core.setVolume, data.value, data.time || 0);
+}
+
+events.prototype._action_setValue = function (data, x, y, prefix) {
+    this.setValue(data.name, data.value, prefix);
+    core.doAction();
+}
+
+events.prototype._action_setValue2 = function (data, x, y, prefix) {
+    this._action_addValue(data, x, y, prefix);
+}
+
+events.prototype._action_addValue = function (data, x, y, prefix) {
+    this.addValue(data.name, data.value, prefix);
+    core.doAction();
+}
+
+events.prototype._action_setFloor = function (data, x, y, prefix) {
+    this.setFloorInfo(data.name, data.value, data.floorId, prefix);
+    core.doAction();
+}
+
+events.prototype._action_setGlobalAttribute = function (data, x, y, prefix) {
+    this.setGlobalAttribute(data.name, data.value);
+    core.doAction();
+}
+
+events.prototype._action_setGlobalValue = function (data, x, y, prefix) {
+    core.values[data.name] = data.value;
+    core.doAction();
+}
+
+events.prototype._action_setGlobalFlag = function (data, x, y, prefix) {
+    this.setGlobalFlag(data.name, data.value);
+    core.doAction();
+}
+
+events.prototype._action_setHeroIcon = function (data, x, y, prefix) {
+    this.setHeroIcon(data.name);
+    core.doAction();
+}
+
+events.prototype._action_input = function (data, x, y, prefix) {
+    this.__action_getInput(data.text, false, function (value) {
+        value = Math.abs(parseInt(value) || 0);
+        core.status.route.push("input:" + value);
+        core.setFlag("input", value);
+        core.doAction();
+    });
+}
+
+events.prototype._action_input2 = function (data, x, y, prefix) {
+    this.__action_getInput(data.text, true, function (value) {
+        value = value || "";
+        core.status.route.push("input2:" + core.encodeBase64(value));
+        core.setFlag("input", value);
+        core.doAction();
+    });
+}
+
+events.prototype.__action_getInput = function (hint, isText, callback) {
+    var value, prefix = isText ? "input2:" : "input:";
+    if (core.isReplaying()) {
+        var action = core.status.replay.toReplay.shift();
+        try {
+            if (action.indexOf(prefix) != 0)
+                throw new Error("录像文件出错！当前需要一个 " + prefix + " 项，实际为 " + action);
+            if (isText) value = core.decodeBase64(action.substring(7));
+            else value = parseInt(action.substring(6));
+            callback(value);
+        }
+        catch (e) {
+            core.control._replay_error(action);
+            return;
+        }
+    }
+    else {
+        core.myprompt(core.replaceText(hint), null, callback);
+    }
+}
+
+events.prototype._action_if = function (data, x, y, prefix) {
+    if (core.calValue(data.condition, prefix))
+        core.events.insertAction(data["true"])
+    else
+        core.events.insertAction(data["false"])
+    core.doAction();
+}
+
+events.prototype._action_switch = function (data, x, y, prefix) {
+    var key = core.calValue(data.condition, prefix)
+    var list = [];
+    for (var i = 0; i < data.caseList.length; i++) {
+        var condition = data.caseList[i]["case"];
+        if (condition == "default" || core.calValue(condition, prefix) == key) {
+            core.push(list, data.caseList[i].action);
+            if (!data.caseList[i].nobreak)
+                break;
+        }
+    }
+    core.insertAction(list);
+    core.doAction();
+}
+
+events.prototype._action_choices = function (data, x, y, prefix) {
+    if (core.isReplaying()) {
+        var action = core.status.replay.toReplay.shift(), index;
+        // --- 忽略可能的turn事件
+        if (action == 'turn') action = core.status.replay.toReplay.shift();
+        if (action.indexOf("choices:") == 0 && ((index = parseInt(action.substring(8))) >= 0) && index < data.choices.length) {
+            core.status.event.selection = index;
+            setTimeout(function () {
+                core.status.route.push("choices:" + index);
+                core.insertAction(data.choices[index].action);
+                core.doAction();
+            }, 750 / Math.max(1, core.status.replay.speed))
+        }
+        else {
+            core.control._replay_error(action);
+            return;
+        }
+    }
+    core.ui.drawChoices(data.text, data.choices);
+}
+
+events.prototype._action_confirm = function (data, x, y, prefix) {
+    core.status.event.ui = {"text": data.text, "yes": data.yes, "no": data.no};
+    if (core.isReplaying()) {
+        var action = core.status.replay.toReplay.shift(), index;
+        // --- 忽略可能的turn事件
+        if (action == 'turn') action = core.status.replay.toReplay.shift();
+        if (action.indexOf("choices:") == 0 && ((index = parseInt(action.substring(8))) >= 0) && index < 2) {
+            core.status.event.selection = index;
+            setTimeout(function () {
+                core.status.route.push("choices:" + index);
+                if (index == 0) core.insertAction(data.yes);
+                else core.insertAction(data.no);
+                core.doAction();
+            }, 750 / Math.max(1, core.status.replay.speed))
+        }
+        else {
+            core.control._replay_error(action);
+            return;
+        }
+    }
+    else {
+        core.status.event.selection = data["default"] ? 0 : 1;
+    }
+    core.ui.drawConfirmBox(data.text);
+}
+
+events.prototype._action_while = function (data, x, y, prefix) {
+    if (core.calValue(data.condition, prefix)) {
+        core.unshift(core.status.event.data.list,
+            {"todo": core.clone(data.data), "total": core.clone(data.data), "condition": data.condition}
+        );
+    }
+    core.doAction();
+}
+
+events.prototype._action_dowhile = function (data, x, y, prefix) {
+    core.unshift(core.status.event.data.list,
+        {"todo": core.clone(data.data), "total": core.clone(data.data), "condition": data.condition}
+    );
+    core.doAction();
+}
+
+events.prototype._action_break = function (data, x, y, prefix) {
+    core.status.event.data.list.shift();
+    core.doAction();
+}
+
+events.prototype._action_continue = function (data, x, y, prefix) {
+    if (core.calValue(core.status.event.data.list[0].condition, prefix)) {
+        core.status.event.data.list[0].todo = core.clone(core.status.event.data.list[0].total);
+    }
+    else {
+        core.status.event.data.list.shift();
+    }
+    core.doAction();
+}
+
+events.prototype._action_win = function (data, x, y, prefix) {
+    this.win(data.reason, data.norank);
+}
+
+events.prototype._action_lose = function (data, x, y, prefix) {
+    this.lose(data.reason);
+}
+
+events.prototype._action_restart = function (data, x, y, prefix) {
+    core.restart();
+}
+
+events.prototype._action_function = function (data, x, y, prefix) {
+    var func = data["function"];
+    try {
+        if (typeof func == "string" && func.indexOf("function") == 0) {
+            eval('(' + func + ')()');
+        }
+    } catch (e) {
+        main.log(e);
+    }
+    if (!data.async)
+        core.doAction();
+}
+
+events.prototype._action_update = function (data, x, y, prefix) {
+    core.updateStatusBar();
+    core.doAction();
+}
+
+events.prototype._action_showStatusBar = function (data, x, y, prefix) {
+    core.showStatusBar();
+    core.doAction();
+}
+
+events.prototype._action_hideStatusBar = function (data, x, y, prefix) {
+    core.hideStatusBar(data.toolbox);
+    core.doAction();
+}
+
+events.prototype._action_updateEnemys = function (data, x, y, prefix) {
+    core.enemys.updateEnemys();
+    core.updateStatusBar();
+    core.doAction();
+}
+
+events.prototype._action_vibrate = function (data, x, y, prefix) {
+    this.__action_doAsyncFunc(data.async, core.vibrate, data.time);
+}
+
+events.prototype._action_sleep = function (data, x, y, prefix) {
+    core.timeout.sleepTimeout = setTimeout(function () {
+        core.timeout.sleepTimeout = null;
+        core.doAction();
+    }, core.isReplaying() ? Math.min(data.time, 20) : data.time);
+}
+
+events.prototype._action_wait = function (data, x, y, prefix) {
+    if (core.isReplaying()) {
+        var code = core.status.replay.toReplay.shift();
+        if (code.indexOf("input:") == 0) {
+            var value = parseInt(code.substring(6));
+            core.status.route.push("input:" + value);
+            this.__action_wait_getValue(value);
+        }
+        else {
+            main.log("录像文件出错！当前需要一个 input: 项，实际为 " + code);
+            core.stopReplay();
+            core.insertAction(["录像文件出错，请在控制台查看报错信息。", {"type": "exit"}]);
+        }
+        core.doAction();
         return;
     }
+}
 
-    clearInterval(core.interval.tipAnimate);
-    core.setAlpha('data', 1);
+events.prototype.__action_wait_getValue = function (value) {
+    if (value >= 1000000) {
+        core.setFlag('type', 1);
+        var px = parseInt((value - 1000000) / 1000), py = value % 1000;
+        core.setFlag('px', px);
+        core.setFlag('py', py);
+        core.setFlag('x', parseInt(px / 32));
+        core.setFlag('y', parseInt(py / 32));
+    }
+    else if (value >= 10000) {
+        core.setFlag('type', 1);
+        var x = parseInt((value - 10000) / 100), y = value % 100;
+        core.setFlag('px', 32 * x + 16);
+        core.setFlag('py', 32 * y + 16);
+        core.setFlag('x', x);
+        core.setFlag('y', y);
+    }
+    else if (value > 0) {
+        core.setFlag('type', 0);
+        core.setFlag('keycode', value);
+    }
+}
 
-    var opacityVal = 0;
-    if (type == 'hide') opacityVal = 1;
-
-    core.setOpacity('data', opacityVal);
-    core.canvas.data.drawImage(image, core.calValue(loc[0]), core.calValue(loc[1]));
-    core.status.replay.animate=true;
-    var animate = setInterval(function () {
-        if (type=='show') opacityVal += 0.1;
-        else opacityVal -= 0.1;
-        core.setOpacity('data', opacityVal);
-        if (opacityVal >=1 || opacityVal<=0) {
-            clearInterval(animate);
-            core.clearMap('data');
-            core.setOpacity('data', 1);
-            core.status.replay.animate=false;
-            if (core.isset(callback)) callback();
+events.prototype._action_waitAsync = function (data, x, y, prefix) {
+    var test = window.setInterval(function () {
+        if (!core.hasAsync()) {
+            clearInterval(test);
+            core.doAction();
         }
-    }, time / 10);
+    }, 50);
+}
+
+events.prototype._action_revisit = function (data, x, y, prefix) {
+    var block = core.getBlock(x, y);
+    if (block != null && block.block.event.trigger == 'action')
+        this.setEvents(block.block.event.data);
+    core.doAction();
+}
+
+events.prototype._action_callBook = function (data, x, y, prefix) {
+    if (core.isReplaying() || !core.hasItem('book')) {
+        core.doAction();
+    }
+    else {
+        var e = core.clone(core.status.event.data);
+        core.ui.closePanel();
+        core.openBook();
+        core.status.event.interval = e;
+    }
+}
+
+events.prototype._action_callSave = function (data, x, y, prefix) {
+    if (core.isReplaying() || core.hasFlag("__events__")) {
+        core.removeFlag("__events__");
+        core.doAction();
+    }
+    else {
+        var e = core.clone(core.status.event.data);
+        core.ui.closePanel();
+        core.save();
+        core.status.event.interval = e;
+    }
+}
+
+events.prototype._action_autoSave = function (data, x, y, prefix) {
+    core.autosave();
+    core.drawTip("已自动存档");
+    core.doAction();
+}
+
+events.prototype._action_callLoad = function (data, x, y, prefix) {
+    if (this.__action_checkReplaying()) return;
+    var e = core.clone(core.status.event.data);
+    core.ui.closePanel();
+    core.load();
+    core.status.event.interval = e;
+}
+
+events.prototype._action_exit = function (data, x, y, prefix) {
+    this.setEvents([]);
+    core.doAction();
+}
+
+// ------ 点击状态栏图标所进行的一些操作 ------ //
+
+////// 判断当前能否进入某个事件 //////
+events.prototype._checkStatus = function (name, fromUserAction, checkItem) {
+    if (fromUserAction && core.status.event.id == name) {
+        core.ui.closePanel();
+        return false;
+    }
+    if (fromUserAction && core.status.lockControl) return false;
+    if (checkItem && !core.hasItem(name)) {
+        core.drawTip("你没有" + core.material.items[name].name);
+        return false;
+    }
+    if (core.isMoving()) {
+        core.drawTip("请先停止勇士行动");
+        return false;
+    }
+    core.lockControl();
+    core.status.event.id = name;
+    return true;
+}
+
+////// 点击怪物手册时的打开操作 //////
+events.prototype.openBook = function (fromUserAction) {
+    if (core.isReplaying()) return;
+    // 如果能恢复事件（从callBook事件触发）
+    if (core.status.event.id == 'book' && core.events.recoverEvents(core.status.event.interval))
+        return;
+    // 当前是book，且从“浏览地图”打开
+    if (core.status.event.id == 'book' && core.status.event.ui) {
+        core.status.boxAnimateObjs = [];
+        core.ui.drawMaps(core.status.event.ui);
+        return;
+    }
+    // 从“浏览地图”页面打开
+    if (core.status.event.id == 'viewMaps') {
+        fromUserAction = false;
+        core.status.event.ui = core.status.event.data;
+    }
+    if (!this._checkStatus('book', fromUserAction, true)) return;
+    core.useItem('book', true);
+}
+
+////// 点击楼层传送器时的打开操作 //////
+events.prototype.useFly = function (fromUserAction) {
+    if (core.isReplaying()) return;
+    if (!this._checkStatus('fly', fromUserAction, true)) return;
+    if (core.flags.flyNearStair && !core.nearStair()) {
+        core.drawTip("只有在楼梯边才能使用传送器");
+        core.unLockControl();
+        core.status.event.data = null;
+        core.status.event.id = null;
+        return;
+    }
+    if (!core.canUseItem('fly')) {
+        core.drawTip("楼层传送器好像失效了");
+        core.unLockControl();
+        core.status.event.data = null;
+        core.status.event.id = null;
+        return;
+    }
+    core.useItem('fly', true);
+    return;
+}
+
+events.prototype.flyTo = function (toId, callback) {
+    return this.eventdata.flyTo(toId, callback);
+}
+
+////// 点击装备栏时的打开操作 //////
+events.prototype.openEquipbox = function (fromUserAction) {
+    if (core.isReplaying()) return;
+    if (!this._checkStatus('equipbox', fromUserAction)) return;
+    core.ui.drawEquipbox();
+}
+
+////// 点击工具栏时的打开操作 //////
+events.prototype.openToolbox = function (fromUserAction) {
+    if (core.isReplaying()) return;
+    if (!this._checkStatus('toolbox', fromUserAction)) return;
+    core.ui.drawToolbox();
+}
+
+////// 点击快捷商店按钮时的打开操作 //////
+events.prototype.openQuickShop = function (fromUserAction) {
+    if (core.isReplaying()) return;
+    if (!this._checkStatus('selectShop', fromUserAction)) return;
+    core.ui.drawQuickShop();
+}
+
+events.prototype.openKeyBoard = function (fromUserAction) {
+    if (core.isReplaying()) return;
+    if (!this._checkStatus('keyBoard', fromUserAction)) return;
+    core.ui.drawKeyBoard();
+}
+
+////// 点击保存按钮时的打开操作 //////
+events.prototype.save = function (fromUserAction) {
+    if (core.isReplaying()) return;
+    if (core.status.event.id == 'save' && core.events.recoverEvents(core.status.event.interval))
+        return;
+    if (!this._checkStatus('save', fromUserAction)) return;
+    var saveIndex = core.saves.saveIndex;
+    var page=parseInt((saveIndex-1)/5), offset=saveIndex-5*page;
+    core.ui.drawSLPanel(10*page+offset);
+}
+
+////// 点击读取按钮时的打开操作 //////
+events.prototype.load = function (fromUserAction) {
+    if (core.isReplaying()) return;
+    var saveIndex = core.saves.saveIndex;
+    var page=parseInt((saveIndex-1)/5), offset=saveIndex-5*page;
+    // 游戏开始前读档
+    if (!core.isPlaying()) {
+        core.dom.startPanel.style.display = 'none';
+        core.clearStatus();
+        core.clearMap('all');
+        core.status.event = {'id': 'load', 'data': null};
+        core.status.lockControl = true;
+        core.ui.drawSLPanel(10*page+offset);
+        return;
+    }
+    if (core.status.event.id == 'load' && core.events.recoverEvents(core.status.event.interval))
+        return;
+    if (!this._checkStatus('load', fromUserAction)) return;
+    core.ui.drawSLPanel(10*page+offset);
+}
+
+////// 点击设置按钮时的操作 //////
+events.prototype.openSettings = function (fromUserAction) {
+    if (core.isReplaying()) return;
+    if (!this._checkStatus('settings', fromUserAction))
+        return;
+    core.ui.drawSettings();
+}
+
+// ------ 一些事件的具体执行过程 ------ //
+
+events.prototype.hasAsync = function () {
+    return Object.keys(core.animateFrame.asyncId).length > 0 || (core.status.animateObjs || []).length > 0;
+}
+
+////// 跟随 //////
+events.prototype.follow = function (name) {
+    core.status.hero.followers = core.status.hero.followers || [];
+    name = core.getMappedName(name);
+    if (core.material.images.images[name]) {
+        core.status.hero.followers.push({"name": name});
+        core.gatherFollowers();
+        core.clearMap('hero');
+        core.drawHero();
+    }
+}
+
+////// 取消跟随 //////
+events.prototype.unfollow = function (name) {
+    core.status.hero.followers = core.status.hero.followers || [];
+    if (!name) {
+        core.status.hero.followers = [];
+    }
+    else {
+        name = core.getMappedName(name);
+        for (var i = 0; i < core.status.hero.followers.length; i++) {
+            if (core.status.hero.followers[i].name == name) {
+                core.status.hero.followers.splice(i, 1);
+                break;
+            }
+        }
+    }
+    core.gatherFollowers();
+    core.clearMap('hero');
+    core.drawHero();
+}
+
+////// 数值操作 //////
+events.prototype.setValue = function (name, value, prefix, add) {
+    var value = core.calValue(value, prefix);
+    if (add) value += core.calValue(name, prefix);
+    this._setValue_setStatus(name, value);
+    this._setValue_setItem(name, value);
+    this._setValue_setFlag(name, value);
+    this._setValue_setSwitch(name, value, prefix);
+    this._setValue_setGlobal(name, value);
+    core.updateStatusBar();
+}
+
+events.prototype._setValue_setStatus = function (name, value) {
+    if (name.indexOf("status:") !== 0) return;
+    core.setStatus(name.substring(7), value);
+    if (core.status.hero.hp <= 0) {
+        core.status.hero.hp = 0;
+        core.updateStatusBar();
+        core.events.lose();
+    }
+}
+
+events.prototype._setValue_setItem = function (name, value) {
+    if (name.indexOf("item:") !== 0) return;
+    var itemId = name.substring(5), count = core.itemCount(itemId);
+    if (value > count) core.getItem(itemId, value - count);
+    else core.setItem(itemId, value);
+}
+
+events.prototype._setValue_setFlag = function (name, value) {
+    if (name.indexOf("flag:") !== 0) return;
+    core.setFlag(name.substring(5), value);
+}
+
+events.prototype._setValue_setSwitch = function (name, value, prefix) {
+    if (name.indexOf("switch:") !== 0) return;
+    core.setFlag((prefix || ":f@x@y") + "@" + name.substring(7), value);
+}
+
+events.prototype._setValue_setGlobal = function (name, value) {
+    if (name.indexOf("global:") !== 0) return;
+    core.setGlobal(name.substring(7), value);
+}
+
+////// 数值增减 //////
+events.prototype.addValue = function (name, value, prefix) {
+    this.setValue(name, value, prefix, true);
+}
+
+////// 执行一个表达式的effect操作 //////
+events.prototype.doEffect = function (effect, need, times) {
+    effect.split(";").forEach(function (expression) {
+        var arr = expression.split("+=");
+        if (arr.length != 2) return;
+        var name=arr[0], value=core.calValue(arr[1], null, need, times);
+        core.addValue(name, value);
+    });
+}
+
+////// 设置楼层属性 //////
+events.prototype.setFloorInfo = function (name, value, floorId, prefix) {
+    floorId = floorId || data.floorId;
+    core.status.maps[floorId][name] = core.calValue(value, prefix);
+    core.updateStatusBar();
+}
+
+////// 设置全塔属性 //////
+events.prototype.setGlobalAttribute = function (name, value) {
+    if (typeof value == 'string') {
+        if ((value.charAt(0) == '"' && value.charAt(value.length - 1) == '"')
+            || (value.charAt(0) == "'" && value.charAt(value.length - 1) == "'"))
+            value = value.substring(1, value.length - 1);
+        // --- 检查 []
+        if (value.charAt(0) == '[' && value.charAt(value.length - 1) == ']')
+            value = eval(value);
+    }
+    core.status.globalAttribute[name] = value;
+    core.updateGlobalAttribute(name);
+    core.setFlag('globalAttribute', core.status.globalAttribute);
+}
+
+////// 设置全局开关 //////
+events.prototype.setGlobalFlag = function (name, value) {
+    var flags = core.getFlag("globalFlags", {});
+    flags[name] = value;
+    core.flags[name] = value;
+    core.setFlag("globalFlags", flags);
+    core.resize();
+}
+
+events.prototype.closeDoor = function (x, y, id, callback) {
+    id = id || "";
+    if (!(id.endsWith("Door") || id.endsWith("Wall"))
+        || !core.material.icons.animates[id] || core.getBlock(x, y) != null) {
+        if (callback) callback();
+        return;
+    }
+    // 关门动画
+    core.playSound('door.mp3');
+    var door = core.material.icons.animates[id];
+    var speed = id.endsWith("Door") ? 30 : 70, state = 0;
+    var animate = window.setInterval(function () {
+        state++;
+        if (state == 4) {
+            clearInterval(animate);
+            delete core.animateFrame.asyncId[animate];
+            core.setBlock(core.getNumberById(id), x, y);
+            if (callback) callback();
+            return;
+        }
+        core.clearMap('event', 32 * x, 32 * y, 32, 32);
+        core.drawImage('event', core.material.images.animates, 32 * (4-state), 32 * door, 32, 32, 32 * x, 32 * y, 32, 32);
+    }, speed / Math.max(core.status.replay.speed, 1));
+    core.animateFrame.asyncId[animate] = true;
+}
+
+////// 显示图片 //////
+events.prototype.showImage = function (code, image, sloc, loc, opacityVal, time, callback) {
+    if (typeof image == 'string') {
+        image = core.getMappedName(image);
+        image = core.material.images.images[image];
+    }
+    if (!image) {
+        if (callback) callback();
+        return;
+    }
+    sloc = sloc || [];
+    var sx = core.calValue(sloc[0]) || 0, sy = core.calValue(sloc[1]) || 0;
+    var sw = core.calValue(sloc[2]), sh = core.calValue(sloc[3]);
+    if (sw == null) sw = image.width;
+    if (sh == null) sh = image.height;
+    loc = loc || [];
+    var x = core.calValue(loc[0]) || 0, y = core.calValue(loc[1]) || 0;
+    var w = core.calValue(loc[2]), h = core.calValue(loc[3]);
+    if (w == null) w = sw;
+    if (h == null) h = sh;
+    var zIndex = code + 100;
+    time = time || 0;
+    var name = "image" + zIndex;
+    var ctx = core.createCanvas(name, x, y, w, h, zIndex);
+    ctx.drawImage(image, sx, sy, sw, sh, 0, 0, w, h);
+    if (time == 0) {
+        core.setOpacity(name, opacityVal);
+        if (callback) callback();
+        return;
+    }
+    core.setOpacity(name, 0);
+    this.moveImage(code, null, opacityVal, time, callback);
+}
+
+////// 隐藏图片 //////
+events.prototype.hideImage = function (code, time, callback) {
+    time = time || 0;
+    var name = "image" + (code + 100);
+    if (time == 0 || !core.dymCanvas[name]) {
+        core.deleteCanvas(name);
+        if (callback) callback();
+        return;
+    }
+    this.moveImage(code, null, 0, time, function () {
+        core.deleteCanvas(name);
+        if (callback) callback();
+    });
 }
 
 ////// 移动图片 //////
-events.prototype.moveImage = function (image, from, to, time, callback) {
+events.prototype.moveImage = function (code, to, opacityVal, time, callback) {
     time = time || 1000;
-    clearInterval(core.interval.tipAnimate);
-    core.setAlpha('data', 1);
-    core.setOpacity('data', 1);
-
-    core.status.replay.animate=true;
-    var fromX = core.calValue(from[0]), fromY = core.calValue(from[1]),
-        toX = core.calValue(to[0]), toY = core.calValue(to[1]);
-    var step = 0;
-    var drawImage = function () {
-        core.clearMap('data');
-        var nowX = parseInt(fromX + (toX-fromX)*step/64);
-        var nowY = parseInt(fromY + (toY-fromY)*step/64);
-        core.canvas.data.drawImage(image, nowX, nowY);
+    to = to || [];
+    var name = "image" + (code + 100);
+    if (!core.dymCanvas[name]) {
+        if (callback) callback();
+        return;
     }
+    var getOrDefault = function (a, b) {
+        a = core.calValue(a);
+        return a != null ? a : b;
+    }
+    var canvas = core.dymCanvas[name].canvas;
+    var fromX = parseFloat(canvas.getAttribute("_left")),
+        fromY = parseFloat(canvas.getAttribute("_top")),
+        toX = getOrDefault(to[0], fromX), toY = getOrDefault(to[1], fromY);
 
-    drawImage();
+    var opacity = parseFloat(canvas.style.opacity), toOpacity = getOrDefault(opacityVal, opacity);
+
+    this._moveImage_moving(name, {
+        fromX: fromX, fromY: fromY, toX: toX, toY: toY, opacity: opacity, toOpacity: toOpacity,
+        time: time / Math.max(core.status.replay.speed, 1)
+    }, callback)
+}
+
+events.prototype._moveImage_moving = function (name, moveInfo, callback) {
+    var per_time = 10, step = 0, steps = parseInt(moveInfo.time / 10);
+    var fromX = moveInfo.fromX, fromY = moveInfo.fromY, toX = moveInfo.toX, toY = moveInfo.toY,
+        opacity = moveInfo.opacity, toOpacity = moveInfo.toOpacity;
+    var currX = fromX, currY = fromY, currOpacity = opacity;
     var animate = setInterval(function () {
         step++;
-        drawImage();
-        if (step>=64) {
+        currOpacity = opacity + (toOpacity - opacity) * step / steps;
+        currX = parseInt(fromX + (toX - fromX) * step / steps);
+        currY = parseInt(fromY + (toY - fromY) * step / steps);
+        core.setOpacity(name, currOpacity);
+        core.relocateCanvas(name, currX, currY);
+        if (step == steps) {
+            core.setOpacity(name, toOpacity);
+            delete core.animateFrame.asyncId[animate];
             clearInterval(animate);
-            core.clearMap('data');
-            core.status.replay.animate=false;
-            if (core.isset(callback)) callback();
+            if (callback) callback();
         }
-    }, time / 64);
+    }, per_time);
+    core.animateFrame.asyncId[animate] = true;
+}
+
+////// 绘制或取消一张gif图片 //////
+events.prototype.showGif = function (name, x, y) {
+    name = core.getMappedName(name);
+    var image = core.material.images.images[name];
+    if (image) {
+        var gif = new Image();
+        gif.src = image.src;
+        gif.style.position = 'absolute';
+        gif.style.left = x * core.domStyle.scale + "px";
+        gif.style.top = y * core.domStyle.scale + "px";
+        gif.style.width = image.width * core.domStyle.scale + "px";
+        gif.style.height = image.height * core.domStyle.scale + "px";
+        core.dom.gif2.appendChild(gif);
+    }
+    else {
+        core.dom.gif2.innerHTML = "";
+    }
 }
 
 ////// 淡入淡出音乐 //////
 events.prototype.setVolume = function (value, time, callback) {
-
     var set = function (value) {
         core.musicStatus.volume = value;
-        if (core.isset(core.musicStatus.playingBgm)) {
+        if (core.musicStatus.playingBgm)
             core.material.bgms[core.musicStatus.playingBgm].volume = value;
-        }
-        core.musicStatus.gainNode.gain.value = value;
     }
-
-    if (!core.isset(time) || time<100) {
+    if (!time || time < 100) {
         set(value);
-        if (core.isset(callback)) callback();
+        if (callback) callback();
         return;
     }
-    core.status.replay.animate=true;
     var currVolume = core.musicStatus.volume;
-    var step = 0;
+    time /= Math.max(core.status.replay.speed, 1);
+    var per_time = 10, step = 0, steps = parseInt(time / per_time);
     var fade = setInterval(function () {
         step++;
-        var nowVolume = currVolume+(value-currVolume)*step/32;
-        set(nowVolume);
-        if (step>=32) {
+        set(currVolume + (value - currVolume) * step / steps);
+        if (step >= steps) {
+            delete core.animateFrame.asyncId[fade];
             clearInterval(fade);
-            core.status.replay.animate=false;
-            if (core.isset(callback))
-                callback();
+            if (callback) callback();
         }
-    }, time / 32);
+    }, per_time);
+    core.animateFrame.asyncId[fade] = true;
 }
 
 ////// 画面震动 //////
-events.prototype.vibrate = function(time, callback) {
-
-    if (core.isset(core.status.replay)&&core.status.replay.replaying) {
-        if (core.isset(callback)) callback();
+events.prototype.vibrate = function (time, callback) {
+    if (core.isReplaying()) {
+        if (callback) callback();
         return;
     }
-
-    core.status.replay.animate=true;
-
-    var addGameCanvasTranslate=function(x,y){
-        for(var ii=0,canvas;canvas=core.dom.gameCanvas[ii];ii++){
-            var id = canvas.getAttribute('id');
-            if (id=='ui' || id=='data') continue;
-            var offsetX = x, offsetY = y;
-            if (core.bigmap.canvas.indexOf(id)>=0) {
-                offsetX-=core.bigmap.offsetX;
-                offsetY-=core.bigmap.offsetY;
-            }
-            core.control.setGameCanvasTranslate(id, offsetX, offsetY);
-        }
-    }
-
-    if (!core.isset(time) || time<1000) time=1000;
-
-    var shake_duration = time*3/50;
-    var shake_speed = 5;
-    var shake_power = 5;
-    var shake_direction = 1;
-    var shake = 0;
-
-    var update = function() {
-        if(shake_duration >= 1 || shake != 0){
-            var delta = (shake_power * shake_speed * shake_direction) / 10.0;
-            if(shake_duration <= 1 && shake * (shake + delta) < 0){
-                shake = 0;
-            }else{
-                shake += delta;
-            }
-            if(shake > shake_power * 2){
-                shake_direction = -1;
-            }
-            if(shake < - shake_power * 2){
-                shake_direction = 1;
-            }
-            if(shake_duration >= 1){
-                shake_duration -= 1
-            }
-        }
-    }
-
-    var animate=setInterval(function(){
-        update();
-        addGameCanvasTranslate(shake, 0);
-        if(shake_duration===0) {
+    if (!time || time < 1000) time = 1000;
+    // --- 将time调整为500的倍数（上整），不然会出错
+    time /= Math.max(core.status.replay.speed, 1)
+    time = Math.ceil(time / 500) * 500;
+    var shakeInfo = {duration: time * 3 / 50, speed: 5, power: 5, direction: 1, shake: 0};
+    var animate = setInterval(function () {
+        core.events._vibrate_update(shakeInfo);
+        core.control.addGameCanvasTranslate(shakeInfo.shake, 0);
+        if (shakeInfo.duration === 0) {
+            delete core.animateFrame.asyncId[animate];
             clearInterval(animate);
-            core.status.replay.animate=false;
-            if (core.isset(callback)) callback();
+            if (callback) callback();
         }
-    }, 50/3);
+    }, 50 / 3);
+
+    core.animateFrame.asyncId[animate] = true;
+}
+
+events.prototype._vibrate_update = function (shakeInfo) {
+    if (shakeInfo.duration >= 1 || shakeInfo.shake != 0) {
+        var delta = (shakeInfo.power * shakeInfo.speed * shakeInfo.direction) / 10.0;
+        if (shakeInfo.duration <= 1 && shakeInfo.shake * (shakeInfo.shake + delta) < 0) {
+            shakeInfo.shake = 0;
+        } else {
+            shakeInfo.shake += delta;
+        }
+        if (shakeInfo.shake > shakeInfo.power * 2) {
+            shakeInfo.direction = -1;
+        }
+        if (shakeInfo.shake < -shakeInfo.power * 2) {
+            shakeInfo.direction = 1;
+        }
+        if (shakeInfo.duration >= 1) {
+            shakeInfo.duration -= 1
+        }
+    }
+}
+
+/////// 使用事件让勇士移动。这个函数将不会触发任何事件 //////
+events.prototype.eventMoveHero = function(steps, time, callback) {
+    time = time || core.values.moveSpeed || 100;
+    var step = 0, moveSteps = (steps||[]).filter(function (t) {
+        return ['up','down','left','right','forward','backward'].indexOf(t)>=0;
+    });
+    var animate=window.setInterval(function() {
+        if (moveSteps.length==0) {
+            delete core.animateFrame.asyncId[animate];
+            clearInterval(animate);
+            core.drawHero();
+            if (callback) callback();
+        }
+        else {
+            if (core.events._eventMoveHero_moving(++step, moveSteps))
+                step = 0;
+        }
+    }, time / 8 / core.status.replay.speed);
+
+    core.animateFrame.asyncId[animate] = true;
+}
+
+events.prototype._eventMoveHero_moving = function (step, moveSteps) {
+    var direction = moveSteps[0], x = core.getHeroLoc('x'), y = core.getHeroLoc('y');
+    // ------ 前进/后退
+    var o = direction == 'backward' ? -1 : 1;
+    if (direction == 'forward' || direction == 'backward') direction = core.getHeroLoc('direction');
+    core.setHeroLoc('direction', direction);
+    if (step <= 4) {
+        core.drawHero('leftFoot', 4 * o * step);
+    }
+    else if (step <= 8) {
+        core.drawHero('rightFoot', 4 * o * step);
+    }
+    if (step == 8) {
+        core.setHeroLoc('x', x + o * core.utils.scan[direction].x, true);
+        core.setHeroLoc('y', y + o * core.utils.scan[direction].y, true);
+        core.updateFollowers();
+        moveSteps.shift();
+        return true;
+    }
+    return false;
+}
+
+////// 勇士跳跃事件 //////
+events.prototype.jumpHero = function (ex, ey, time, callback) {
+    var sx = core.getHeroLoc('x'), sy = core.getHeroLoc('y');
+    if (ex == null) ex = sx;
+    if (ey == null) ey = sy;
+    var sx=core.status.hero.loc.x, sy=core.status.hero.loc.y;
+    if (!core.isset(ex)) ex=sx;
+    if (!core.isset(ey)) ey=sy;
+    core.playSound('jump.mp3');
+    var jumpInfo = core.maps.__generateJumpInfo(sx, sy, ex, ey, time || 500);
+    jumpInfo.icon = core.material.icons.hero[core.getHeroLoc('direction')];
+    jumpInfo.width = core.material.icons.hero.width || 32;
+    jumpInfo.height = core.material.icons.hero.height;
+
+    this._jumpHero_doJump(jumpInfo, callback);
+}
+
+events.prototype._jumpHero_doJump = function (jumpInfo, callback) {
+    var animate = window.setInterval(function () {
+        if (jumpInfo.jump_count > 0)
+            core.events._jumpHero_jumping(jumpInfo)
+        else
+            core.events._jumpHero_finished(animate, jumpInfo.ex, jumpInfo.ey, callback);
+    }, jumpInfo.per_time);
+
+    core.animateFrame.asyncId[animate] = true;
+}
+
+events.prototype._jumpHero_jumping = function (jumpInfo) {
+    core.clearMap('hero');
+    core.maps.__updateJumpInfo(jumpInfo);
+    var nowx = jumpInfo.px, nowy = jumpInfo.py, width = jumpInfo.width || 32, height = jumpInfo.height;
+    core.bigmap.offsetX = core.clamp(nowx - 32*core.__HALF_SIZE__, 0, 32*core.bigmap.width-core.__PIXELS__);
+    core.bigmap.offsetY = core.clamp(nowy - 32*core.__HALF_SIZE__, 0, 32*core.bigmap.height-core.__PIXELS__);
+    core.control.updateViewport();
+    core.drawImage('hero', core.material.images.hero, jumpInfo.icon.stop, jumpInfo.icon.loc * height, width, height,
+        nowx + (32 - width) / 2 - core.bigmap.offsetX, nowy + 32-height - core.bigmap.offsetY, width, height);
+}
+
+events.prototype._jumpHero_finished = function (animate, ex, ey, callback) {
+    delete core.animateFrame.asyncId[animate];
+    clearInterval(animate);
+    core.setHeroLoc('x', ex);
+    core.setHeroLoc('y', ey);
+    core.drawHero();
+    if (callback) callback();
 }
 
 ////// 打开一个全局商店 //////
-events.prototype.openShop = function(shopId, needVisited) {
+events.prototype.openShop = function (shopId, needVisited) {
     var shop = core.status.shops[shopId];
     shop.times = shop.times || 0;
-    shop.visited = shop.visited || false;
+    if (shop.commonTimes) shop.times = core.getFlag('commonTimes', 0);
     if (needVisited && !shop.visited) {
-        if (shop.times==0) core.drawTip("该商店尚未开启");
-        else core.drawTip("该商店已失效");
+        if (!core.flags.enableDisabledShop || shop.commonEvent) {
+            if (shop.times == 0) core.drawTip("该项尚未开启");
+            else core.drawTip("该项已失效");
+            return;
+        }
+        else {
+            core.drawTip("该商店尚未开启，只能浏览不可使用");
+        }
+    }
+    else shop.visited = true;
+
+    // --- 商店
+    if (shop.commonEvent) {
+        core.status.route.push("shop:"+shopId+":0");
+        core.insertAction({"type": "insert", "name": shop.commonEvent, "args": shop.args});
         return;
     }
-    shop.visited = true;
+    core.ui.drawShop(shopId);
+}
 
-    var selection = core.status.event.selection;
-    var actions = [];
-    if (core.isset(core.status.event.data) && core.isset(core.status.event.data.actions))
-        actions=core.status.event.data.actions;
-    var fromList;
-    if (core.isset(core.status.event.data) && core.isset(core.status.event.data.fromList))
-        fromList = core.status.event.data.fromList;
-
-    core.ui.closePanel();
-    core.lockControl();
-    // core.status.event = {'id': 'shop', 'data': {'id': shopId, 'shop': shop}};
-    core.status.event.id = 'shop';
-    core.status.event.data = {'id': shopId, 'shop': shop, 'actions': actions, 'fromList': fromList};
-    core.status.event.selection = selection;
-
-    // 拼词
-    var content = "\t["+shop.name+","+shop.icon+"]";
-    var times = shop.times, need=eval(shop.need);
-
-    content = content + shop.text.replace(/\${([^}]+)}/g, function (word, value) {
-        return eval(value);
-    });
-
-    var use = shop.use=='experience'?'经验':'金币';
-
-    var choices = [];
-    for (var i=0;i<shop.choices.length;i++) {
-        var choice = shop.choices[i];
-        var text = choice.text;
-        if (core.isset(choice.need))
-            text += "（"+eval(choice.need)+use+"）"
-        choices.push(text);
+events.prototype._useShop = function (shop, index) {
+    var reason = core.events.canUseQuickShop(shop.id);
+    if (!reason && !shop.visited) reason = shop.times ? "该商店已失效" : "该商店尚未开启";
+    if (reason) {
+        core.drawTip(reason);
+        return false;
     }
-    choices.push("离开");
-    core.ui.drawChoices(content, choices);
+    var use = shop.use, choice = shop.choices[index];
+    var times = shop.times, need = core.calValue(choice.need || shop.need, null, null, times);
+    if (need > core.getStatus(use)) {
+        core.drawTip("你的" + (use == 'money' ? "金币" : "经验") + "不足");
+        return false;
+    }
+    core.status.event.selection = index;
+    core.status.event.data.actions.push(index);
+    core.setStatus(use, core.getStatus(use) - need);
+    core.doEffect(choice.effect, need, times);
+    core.updateStatusBar();
+    shop.times++;
+    if (shop.commonTimes) core.setFlag('commonTimes', shop.times);
+    this.openShop(shop.id);
+    return true;
+}
+
+events.prototype._exitShop = function () {
+    if (core.status.event.data.actions.length > 0) {
+        core.status.route.push("shop:" + core.status.event.data.id + ":" + core.status.event.data.actions.join(""));
+    }
+    core.status.event.data.actions = [];
+    core.status.boxAnimateObjs = [];
+    if (core.status.event.data.fromList)
+        core.ui.drawQuickShop();
+    else
+        core.ui.closePanel();
 }
 
 ////// 禁用一个全局商店 //////
@@ -1439,229 +2244,60 @@ events.prototype.disableQuickShop = function (shopId) {
 }
 
 ////// 能否使用快捷商店 //////
-events.prototype.canUseQuickShop = function(shopId) {
-    if (core.isset(core.floors[core.status.floorId].canUseQuickShop) && !core.floors[core.status.floorId].canUseQuickShop)
-        return '当前不能使用快捷商店。';
-
-    return null;
+events.prototype.canUseQuickShop = function (shopId) {
+    return this.eventdata.canUseQuickShop(shopId);
 }
 
 ////// 设置角色行走图 //////
-events.prototype.setHeroIcon = function (name) {
-    if (core.isset(core.material.images.images[name]) && core.material.images.images[name].width==128) {
-        core.setFlag("heroIcon", name);
-        core.material.images.hero.src = core.material.images.images[name].src;
-        core.material.icons.hero.height = core.material.images.images[name].height/4;
-        core.drawHero();
-    }
+events.prototype.setHeroIcon = function (name, noDraw) {
+    name = core.getMappedName(name);
+    var img = core.material.images.images[name];
+    if (!img) return;
+    core.setFlag("heroIcon", name);
+    core.material.images.hero = img;
+    core.material.icons.hero.width = img.width / 4;
+    core.material.icons.hero.height = img.height / 4;
+    core.control.updateHeroIcon(name);
+    if (!noDraw) core.drawHero();
 }
 
 ////// 检查升级事件 //////
 events.prototype.checkLvUp = function () {
-    if (!core.flags.enableLevelUp || !core.isset(core.firstData.levelUp)
-        || core.status.hero.lv>=core.firstData.levelUp.length) return;
+    var actions = [];
+    while (true) {
+        var next = this._checkLvUp_check();
+        if (next == null) break;
+        actions = actions.concat(next);
+    }
+    if (actions.length > 0) core.insertAction(actions);
+}
+
+events.prototype._checkLvUp_check = function () {
+    if (!core.flags.enableLevelUp || !core.firstData.levelUp
+        || core.status.hero.lv >= core.firstData.levelUp.length) return null;
     // 计算下一个所需要的数值
-    var need=core.firstData.levelUp[core.status.hero.lv].need;
-    if (!core.isset(need)) return;
-    if (core.status.hero.experience>=need) {
+    var next = (core.firstData.levelUp[core.status.hero.lv] || {});
+    var need = core.calValue(next.need);
+    if (need == null) return null;
+    if (core.status.hero.experience >= need) {
         // 升级
         core.status.hero.lv++;
-        var effect = core.firstData.levelUp[core.status.hero.lv-1].effect;
-        if (typeof effect == "string") {
-            if (effect.indexOf("function")==0) {
-                eval("("+effect+")()");
-            }
-            else {
-                effect.split(";").forEach(function (t) {
-                    core.doEffect(t);
-                });
-            }
-        }
-        else if (effect instanceof Function) {
-            effect();
-        }
-        this.checkLvUp();
+        if (next.clear) core.status.hero.experience -= need;
+        return next.action || [];
     }
+    return null;
 }
 
 ////// 尝试使用道具 //////
-events.prototype.useItem = function(itemId) {
+events.prototype.tryUseItem = function (itemId) {
     core.ui.closePanel();
 
-    if (itemId=='book') {
-        core.openBook(false);
-        return;
-    }
-    if (itemId=='fly') {
-        core.useFly(false);
-        return;
-    }
-    if (itemId=='centerFly') {
-        core.lockControl();
-        core.status.event.id = 'centerFly';
-        var fillstyle = 'rgba(255,0,0,0.5)';
-        if (core.canUseItem('centerFly')) fillstyle = 'rgba(0,255,0,0.5)';
-        var toX = core.bigmap.width-1 - core.getHeroLoc('x'), toY = core.bigmap.height-1-core.getHeroLoc('y');
-        core.ui.drawThumbnail(core.status.floorId, 'ui', core.status.thisMap.blocks, 0, 0, 416, toX, toY, core.status.hero.loc, core.getFlag('heroIcon', "hero.png"));
-        var offsetX = core.clamp(toX-6, 0, core.bigmap.width-13), offsetY = core.clamp(toY-6, 0, core.bigmap.height-13);
-        core.fillRect('ui',(toX-offsetX)*32,(toY-offsetY)*32,32,32,fillstyle);
-        core.status.event.data = {"x": toX, "y": toY, "poxX": toX-offsetX, "posY": toY-offsetY};
-        core.drawTip("请确认当前中心对称飞行器的位置");
-        return;
-    }
+    if (itemId == 'book') return core.openBook(false);
+    if (itemId == 'fly') return core.useFly(false);
+    if (itemId == 'centerFly') return core.ui.drawCenterFly();
 
-    if (core.canUseItem(itemId))core.useItem(itemId);
-    else core.drawTip("当前无法使用"+core.material.items[itemId].name);
-}
-
-////// 加点事件 //////
-events.prototype.addPoint = function (enemy) {
-    return this.eventdata.addPoint(enemy);
-}
-
-////// 战斗结束后触发的事件 //////
-events.prototype.afterBattle = function (enemyId,x,y,callback) {
-    return this.eventdata.afterBattle(enemyId,x,y,callback);
-}
-
-////// 开一个门后触发的事件 //////
-events.prototype.afterOpenDoor = function (doorId,x,y,callback) {
-    return this.eventdata.afterOpenDoor(doorId,x,y,callback);
-}
-
-////// 经过一个路障 //////
-events.prototype.passNet = function (data) {
-    // 有鞋子
-    if (core.hasItem('shoes')) return;
-    if (data.event.id=='lavaNet') { // 血网
-        // 在checkBlock中进行处理
-        /*
-        core.status.hero.hp -= core.values.lavaDamage;
-        if (core.status.hero.hp<=0) {
-            core.status.hero.hp=0;
-            core.updateStatusBar();
-            core.events.lose();
-            return;
-        }
-        */
-        // core.drawTip('经过血网，生命-'+core.values.lavaDamage);
-    }
-    if (data.event.id=='poisonNet') { // 毒网
-        if (core.hasFlag('poison')) return;
-        core.setFlag('poison', true);
-    }
-    if (data.event.id=='weakNet') { // 衰网
-        if (core.hasFlag('weak')) return;
-        core.setFlag('weak', true);
-        var weakValue = core.values.weakValue;
-        var weakAtk = weakValue>=1?weakValue:Math.floor(weakValue*core.status.hero.atk);
-        var weakDef = weakValue>=1?weakValue:Math.floor(weakValue*core.status.hero.def);
-        core.setFlag('weakAtk', weakAtk);
-        core.setFlag('weakDef', weakDef);
-        core.status.hero.atk-=weakAtk;
-        core.status.hero.def-=weakDef;
-    }
-    if (data.event.id=='curseNet') { // 咒网
-        if (core.hasFlag('curse')) return;
-        core.setFlag('curse', true);
-    }
-    core.updateStatusBar();
-}
-
-////// 改变亮灯（感叹号）的事件 //////
-events.prototype.changeLight = function(x, y) {
-    var block = core.getBlock(x, y);
-    if (block==null) return;
-    var index = block.index;
-    block = block.block;
-    if (block.event.id != 'light') return;
-    // 改变为dark
-    block.id = 166;
-    block.event = {'cls': 'terrains', 'id': 'darkLight', 'noPass': true};
-    core.drawBlock(block);
-    this.afterChangeLight(x,y);
-}
-
-////// 改变亮灯之后，可以触发的事件 //////
-events.prototype.afterChangeLight = function (x,y) {
-    return this.eventdata.afterChangeLight(x,y);
-}
-
-////// 滑冰 //////
-events.prototype.ski = function (direction) {
-    if (!core.isset(direction))
-        direction = core.status.automaticRoute.lastDirection || core.getHeroLoc('direction');
-    if (core.status.event.id!='ski') {
-        core.waitHeroToStop(function () {
-            core.status.event.id='ski';
-            core.events.ski(direction);
-        });
-    }
-    else {
-        core.moveHero(direction, function () {
-            if (core.status.event.id=='ski' && !core.status.isSkiing) {
-                core.status.event.id=null;
-                core.unLockControl();
-                core.replay();
-            }
-        })
-    }
-}
-
-////// 推箱子 //////
-events.prototype.pushBox = function (data) {
-    if (data.event.id!='box' && data.event.id!='boxed') return;
-
-    // 判断还能否前进，看看是否存在事件
-    var scan = {
-        'up': {'x': 0, 'y': -1},
-        'left': {'x': -1, 'y': 0},
-        'down': {'x': 0, 'y': 1},
-        'right': {'x': 1, 'y': 0}
-    };
-
-    var direction = core.getHeroLoc('direction'), nx=data.x+scan[direction].x, ny=data.y+scan[direction].y;
-
-    if (nx<0||nx>=core.bigmap.width||ny<0||ny>=core.bigmap.height) return;
-
-    var block = core.getBlock(nx, ny, null, true);
-    if (block!=null && !(core.isset(block.block.event) && block.block.event.id=='flower'))
-        return;
-
-    if (block==null) {
-        core.status.thisMap.blocks.push(core.maps.initBlock(nx, ny, 169));
-        block = core.getBlock(nx, ny);
-    }
-    else {
-        block.block.id=170;
-        block.block.event=core.maps.initBlock(null,null,170).event;
-    }
-    core.drawBlock(block.block);
-
-    if (data.event.id=='box') {
-        core.removeBlock(data.x, data.y);
-    }
-    else {
-        data.id=168;
-        data.event=core.maps.initBlock(null,null,168).event;
-        core.drawBlock(data);
-    }
-
-    core.updateStatusBar();
-
-    core.status.replay.animate = true;
-    core.moveHero(direction, function() {
-        core.status.replay.animate = false;
-        core.status.route.pop();
-        core.events.afterPushBox();
-        core.replay();
-    });
-
-}
-
-////// 推箱子后的事件 //////
-events.prototype.afterPushBox = function () {
-    return this.eventdata.afterPushBox();
+    if (core.canUseItem(itemId)) core.useItem(itemId);
+    else core.drawTip("当前无法使用" + core.material.items[itemId].name);
 }
 
 ////// 使用炸弹/圣锤后的事件 //////
@@ -1669,26 +2305,16 @@ events.prototype.afterUseBomb = function () {
     return this.eventdata.afterUseBomb();
 }
 
-////// 即将存档前可以执行的操作 //////
-events.prototype.beforeSaveData = function (data) {
-    return this.eventdata.beforeSaveData(data);
-}
-
-////// 读档事件后，载入事件前，可以执行的操作 //////
-events.prototype.afterLoadData = function (data) {
-    return this.eventdata.afterLoadData(data);
-}
-
 ////// 上传当前数据 //////
-events.prototype.uploadCurrent = function (username) {
+events.prototype._uploadCurrent = function (username) {
     var formData = new FormData();
 
     formData.append('type', 'score');
     formData.append('name', core.firstData.name);
     formData.append('version', core.firstData.version);
-    formData.append('platform', core.platform.isPC?"PC":core.platform.isAndroid?"Android":core.platform.isIOS?"iOS":"");
+    formData.append('platform', core.platform.string);
     formData.append('hard', core.encodeBase64(core.status.hard));
-    formData.append('username', core.encodeBase64(username||"current"));
+    formData.append('username', core.encodeBase64(username || "current"));
     formData.append('lv', core.status.hero.lv);
     formData.append('hp', Math.min(core.status.hero.hp, Math.pow(2, 63)));
     formData.append('atk', core.status.hero.atk);
@@ -1697,8 +2323,8 @@ events.prototype.uploadCurrent = function (username) {
     formData.append('money', core.status.hero.money);
     formData.append('experience', core.status.hero.experience);
     formData.append('steps', core.status.hero.steps);
-    formData.append('seed', core.getFlag('seed'));
-    formData.append('totalTime', Math.floor(core.status.hero.statistics.totalTime/1000));
+    formData.append('seed', core.getFlag('__seed__'));
+    formData.append('totalTime', Math.floor(core.status.hero.statistics.totalTime / 1000));
     formData.append('route', core.encodeRoute(core.status.route));
     formData.append('deler', 'current');
     formData.append('base64', 1);
diff --git a/libs/icons.js b/libs/icons.js
index f1a557a1..12b78828 100644
--- a/libs/icons.js
+++ b/libs/icons.js
@@ -1,12 +1,66 @@
+"use strict";
+
 function icons() {
-    this.init();
+    this._init();
 }
 
-icons.prototype.init = function () {
+icons.prototype._init = function () {
     this.icons = icons_4665ee12_3a1f_44a4_bea3_0fccba634dc1;
     //delete(icons_4665ee12_3a1f_44a4_bea3_0fccba634dc1);
+
+    // tileset的起点
+    this.tilesetStartOffset = 10000;
 }
 
 icons.prototype.getIcons = function () {
-    return this.icons;
+    return core.clone(this.icons);
+}
+
+////// 根据道具ID获得其cls //////
+icons.prototype.getClsFromId = function (id) {
+    for (var cls in core.material.icons) {
+        if (cls != 'hero' && id in core.material.icons[cls])
+            return cls;
+    }
+    return null;
+}
+
+icons.prototype._getAnimateFrames = function (cls, useOriginValue) {
+    if (cls == 'enemys' || cls == 'npcs') {
+        return 2;
+    }
+    if (cls == 'animates' || cls == 'enemy48') {
+        return 4;
+    }
+    if (cls == 'npc48') {
+        return useOriginValue ? 4 : 1;
+    }
+    return 1;
+}
+
+////// 根据图块数字或ID获得所在的tileset和坐标信息 //////
+icons.prototype.getTilesetOffset = function (id) {
+
+    if (typeof id == 'string') {
+        // Tileset的ID必须是 X+数字 的形式
+        if (!/^X\d+$/.test(id)) return null;
+        id = parseInt(id.substring(1));
+    }
+    else if (typeof id != 'number') {
+        return null;
+    }
+
+    core.tilesets = core.tilesets || [];
+    var startOffset = this.tilesetStartOffset;
+    for (var i in core.tilesets) {
+        var imgName = core.tilesets[i];
+        var img = core.material.images.tilesets[imgName];
+        var width = Math.floor(img.width / 32), height = Math.floor(img.height / 32);
+        if (id >= startOffset && id < startOffset + width * height) {
+            var x = (id - startOffset) % width, y = parseInt((id - startOffset) / width);
+            return {"image": imgName, "x": x, "y": y};
+        }
+        startOffset += this.tilesetStartOffset;
+    }
+    return null;
 }
\ No newline at end of file
diff --git a/libs/items.js b/libs/items.js
index 82ee9204..13030de5 100644
--- a/libs/items.js
+++ b/libs/items.js
@@ -1,30 +1,70 @@
+"use strict";
+
 function items() {
-    this.init();
+    this._init();
 }
 
 ////// 初始化 //////
-items.prototype.init = function () {
+items.prototype._init = function () {
     this.items = items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a.items;
     this.itemEffect = items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a.itemEffect;
     this.itemEffectTip = items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a.itemEffectTip;
     this.useItemEffect = items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a.useItemEffect;
     this.canUseItemEffect = items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a.canUseItemEffect;
-    //delete(items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a);
+    if (!items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a.equipCondition)
+        items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a.equipCondition = {};
+    this.equipCondition = items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a.equipCondition;
 }
 
 ////// 获得所有道具 //////
 items.prototype.getItems = function () {
-    return this.items;
+    return core.clone(this.items);
+}
+
+items.prototype._resetItems = function () {
+    // 只有运行时才能执行此函数！
+    if (main.mode != 'play') return;
+
+    // 根据flag来对道具进行修改
+    if (core.flags.bigKeyIsBox) {
+        core.material.items.bigKey.cls = 'items';
+        core.material.items.bigKey.name = '钥匙盒';
+    }
+    if (core.flags.pickaxeFourDirections)
+        core.material.items.pickaxe.text = "可以破坏勇士四周的墙";
+    if (core.flags.bombFourDirections)
+        core.material.items.bomb.text = "可以炸掉勇士四周的怪物";
+    if (core.flags.snowFourDirections)
+        core.material.items.snow.text = "可以将四周的熔岩变成平地";
+    if (core.flags.equipment) {
+        core.material.items.sword1.cls = 'equips';
+        core.material.items.sword2.cls = 'equips';
+        core.material.items.sword3.cls = 'equips';
+        core.material.items.sword4.cls = 'equips';
+        core.material.items.sword5.cls = 'equips';
+        core.material.items.shield1.cls = 'equips';
+        core.material.items.shield2.cls = 'equips';
+        core.material.items.shield3.cls = 'equips';
+        core.material.items.shield4.cls = 'equips';
+        core.material.items.shield5.cls = 'equips';
+    }
 }
 
 ////// “即捡即用类”道具的使用效果 //////
-items.prototype.getItemEffect = function(itemId, itemNum) {
+items.prototype.getItemEffect = function (itemId, itemNum) {
     var itemCls = core.material.items[itemId].cls;
     // 消耗品
     if (itemCls === 'items') {
-        var ratio = parseInt(core.floors[core.status.floorId].item_ratio) || 1;
+        var ratio = parseInt(core.status.thisMap.item_ratio) || 1;
         var curr_hp = core.status.hero.hp;
-        if (itemId in this.itemEffect)eval(this.itemEffect[itemId]);
+        if (itemId in this.itemEffect) {
+            try {
+                eval(this.itemEffect[itemId]);
+            }
+            catch (e) {
+                main.log(e);
+            }
+        }
         core.status.hero.statistics.hp += core.status.hero.hp - curr_hp;
     }
     else {
@@ -33,42 +73,63 @@ items.prototype.getItemEffect = function(itemId, itemNum) {
 }
 
 ////// “即捡即用类”道具的文字提示 //////
-items.prototype.getItemEffectTip = function(itemId) {
+items.prototype.getItemEffectTip = function (itemId) {
     var itemCls = core.material.items[itemId].cls;
     // 消耗品
     if (itemCls === 'items') {
-        var ratio = parseInt(core.floors[core.status.floorId].item_ratio) || 1;
-        if (itemId in this.itemEffectTip) return eval(this.itemEffectTip[itemId])||"";
+        var ratio = parseInt(core.status.thisMap.item_ratio) || 1;
+        if (itemId in this.itemEffectTip) {
+            try {
+                return eval(this.itemEffectTip[itemId]) || "";
+            } catch (e) {
+                main.log(e);
+                return "";
+            }
+        }
     }
     return "";
 }
 
 ////// 使用道具 //////
-items.prototype.useItem = function (itemId, callback) {
+items.prototype.useItem = function (itemId, noRoute, callback) {
     if (!this.canUseItem(itemId)) {
-        if (core.isset(callback)) callback();
+        if (callback) callback();
         return;
     }
-    var itemCls = core.material.items[itemId].cls;
-
-    if (itemId in this.useItemEffect) {
-        eval(this.useItemEffect[itemId]);
-    }
-
-    core.updateStatusBar();
-
+    // 执行道具效果
+    this._useItemEffect(itemId);
+    // 执行完毕
+    this._afterUseItem(itemId);
     // 记录路线
-    if (itemId!='book' && itemId!='fly') {
-        core.status.route.push("item:"+itemId);
-    }
+    if (!noRoute) core.status.route.push("item:" + itemId);
+    if (callback) callback();
+}
 
+items.prototype._useItemEffect = function (itemId) {
+    if (itemId in this.useItemEffect) {
+        try {
+            var ratio = parseInt(core.status.thisMap.item_ratio) || 1;
+            eval(this.useItemEffect[itemId]);
+        }
+        catch (e) {
+            main.log(e);
+        }
+    }
+}
+
+items.prototype._afterUseItem = function (itemId) {
     // 道具使用完毕：删除
-    if (itemCls=='tools')
+    var itemCls = core.material.items[itemId].cls;
+    if (itemCls == 'tools')
         core.status.hero.items[itemCls][itemId]--;
-    if (core.status.hero.items[itemCls][itemId]==0)
+    if (core.status.hero.items[itemCls][itemId] <= 0)
         delete core.status.hero.items[itemCls][itemId];
 
-    if (core.isset(callback)) callback();
+    if (!core.status.event.id) {
+        core.status.event.data = null;
+        core.status.event.ui = null;
+    }
+    core.updateStatusBar();
 }
 
 ////// 当前能否使用道具 //////
@@ -76,67 +137,276 @@ items.prototype.canUseItem = function (itemId) {
     // 没有道具
     if (!core.hasItem(itemId)) return false;
 
+    var able = false;
     if (itemId in this.canUseItemEffect) {
-        return eval(this.canUseItemEffect[itemId]);
+        try {
+            able = eval(this.canUseItemEffect[itemId]);
+        }
+        catch (e) {
+            main.log(e);
+        }
+    }
+    if (!able) {
+        core.status.event.data = null;
+        core.status.event.ui = null;
     }
 
-    return false;
+    return able;
 }
 
 ////// 获得某个物品的个数 //////
 items.prototype.itemCount = function (itemId) {
-    if (!core.isset(itemId) || !core.isset(core.material.items[itemId])) return 0;
+    if (!core.material.items[itemId] || !core.isPlaying()) return 0;
     var itemCls = core.material.items[itemId].cls;
-    if (itemCls=="items") return 0;
-    return core.isset(core.status.hero.items[itemCls][itemId]) ? core.status.hero.items[itemCls][itemId] : 0;
+    if (itemCls == "items") return 0;
+    return core.status.hero.items[itemCls][itemId] || 0;
 }
 
 ////// 是否存在某个物品 //////
 items.prototype.hasItem = function (itemId) {
-    return core.itemCount(itemId) > 0;
+    return this.itemCount(itemId) > 0;
+}
+
+////// 是否装备某件装备 //////
+items.prototype.hasEquip = function (itemId) {
+    if (!(core.material.items[itemId] || {}).equip || !core.isPlaying()) return null;
+
+    for (var i in core.status.hero.equipment)
+        if (core.status.hero.equipment[i] == itemId)
+            return true;
+    return false
+}
+
+////// 获得某个装备类型的当前装备 //////
+items.prototype.getEquip = function (equipType) {
+    return core.status.hero.equipment[equipType] || null;
 }
 
 ////// 设置某个物品的个数 //////
 items.prototype.setItem = function (itemId, itemNum) {
+    itemNum = itemNum || 0;
     var itemCls = core.material.items[itemId].cls;
     if (itemCls == 'items') return;
-    if (!core.isset(core.status.hero.items[itemCls])) {
-        core.status.hero.items[itemCls] = {};
-    }
+
     core.status.hero.items[itemCls][itemId] = itemNum;
-    if (itemCls!='keys' && itemNum==0) {
-        delete core.status.hero.items[itemCls][itemId];
+    if (core.status.hero.items[itemCls][itemId] <= 0) {
+        if (itemCls != 'keys') delete core.status.hero.items[itemCls][itemId];
+        else core.status.hero.items[itemCls][itemId] = 0;
     }
+    core.updateStatusBar();
+}
+
+////// 增加某个物品的个数 //////
+items.prototype.addItem = function (itemId, itemNum) {
+    if (itemNum == null) itemNum = 1;
+    var itemData = core.material.items[itemId];
+    var itemCls = itemData.cls;
+    if (itemCls == 'items') return;
+    if (core.status.hero.items[itemCls][itemId] == null) {
+        core.status.hero.items[itemCls][itemId] = 0;
+    }
+    core.status.hero.items[itemCls][itemId] += itemNum;
+    if (core.status.hero.items[itemCls][itemId] <= 0) {
+        if (itemCls != 'keys') delete core.status.hero.items[itemCls][itemId];
+        else core.status.hero.items[itemCls][itemId] = 0;
+    }
+    // 永久道具只能有一个
+    if (itemCls == 'constants' && core.status.hero.items[itemCls][itemId] > 1)
+        core.status.hero.items[itemCls][itemId] = 1;
+    core.updateStatusBar();
 }
 
 ////// 删除某个物品 //////
-items.prototype.removeItem = function (itemId) {
+items.prototype.removeItem = function (itemId, itemNum) {
+    if (itemNum == null) itemNum = 1;
     if (!core.hasItem(itemId)) return false;
     var itemCls = core.material.items[itemId].cls;
-    core.status.hero.items[itemCls][itemId]--;
-    if (itemCls!='keys' && core.status.hero.items[itemCls][itemId]==0) {
-        delete core.status.hero.items[itemCls][itemId];
+    core.status.hero.items[itemCls][itemId] -= itemNum;
+    if (core.status.hero.items[itemCls][itemId] <= 0) {
+        if (itemCls != 'keys') delete core.status.hero.items[itemCls][itemId];
+        else core.status.hero.items[itemCls][itemId] = 0;
     }
     core.updateStatusBar();
     return true;
 }
 
-////// 增加某个物品的个数 //////
-items.prototype.addItem = function (itemId, itemNum) {
-    itemNum=itemNum||1;
-    var itemData = core.material.items[itemId];
-    var itemCls = itemData.cls;
-    if (itemCls == 'items') return;
-    if (!core.isset(core.status.hero.items[itemCls])) {
-        core.status.hero.items[itemCls] = {};
-        core.status.hero.items[itemCls][itemId] = 0;
+// ---------- 装备相关 ------------ //
+
+items.prototype.getEquipTypeByName = function (name) {
+    var names = core.status.globalAttribute.equipName;
+    for (var i = 0; i < names.length; ++i) {
+        if (names[i] === name && !core.status.hero.equipment[i]) {
+            return i;
+        }
     }
-    else if (!core.isset(core.status.hero.items[itemCls][itemId])) {
-        core.status.hero.items[itemCls][itemId] = 0;
-    }
-    core.status.hero.items[itemCls][itemId] += itemNum;
-    // 永久道具只能有一个
-    if (itemCls == 'constants' && core.status.hero.items[itemCls][itemId]>1)
-        core.status.hero.items[itemCls][itemId] = 1;
+    return -1;
 }
 
+items.prototype.getEquipTypeById = function (equipId) {
+    var type = core.material.items[equipId].equip.type;
+    if (typeof type == 'string')
+        type = this.getEquipTypeByName(type);
+    return type;
+}
+
+// 当前能否撞上某装备
+items.prototype.canEquip = function (equipId, hint) {
+    // 装备是否合法
+    var equip = core.material.items[equipId] || {};
+    if (!equip.equip) {
+        if (hint) core.drawTip("不合法的装备！");
+        return false;
+    }
+
+    // 是否拥有该装备
+    if (!core.hasItem(equipId) && !core.hasEquip(equipId)) {
+        if (hint) core.drawTip("你当前没有" + equip.name + "，无法换装");
+        return false;
+    }
+
+    // 可装备条件
+    var condition = this.equipCondition[equipId];
+    if (condition) {
+        try {
+            if (!eval(condition)) {
+                if (hint) core.drawTip("当前不可换上" + equip.name);
+                return false;
+            }
+        }
+        catch (e) {
+            console.log(e);
+            return false;
+        }
+    }
+    return true;
+}
+
+////// 换上 //////
+items.prototype.loadEquip = function (equipId, callback) {
+    if (!this.canEquip(equipId, true)) {
+        if (callback) callback();
+        return;
+    }
+
+    var loadEquip = core.material.items[equipId] || {};
+    var type = this.getEquipTypeById(equipId);
+    if (type < 0) {
+        core.drawTip("当前没有" + loadEquip.equip.type + "的空位！");
+        if (callback) callback();
+        return;
+    }
+
+    this._realLoadEquip(type, equipId, core.status.hero.equipment[type], callback);
+}
+
+////// 卸下 //////
+items.prototype.unloadEquip = function (equipType, callback) {
+    var unloadEquipId = core.status.hero.equipment[equipType];
+    if (!unloadEquipId) {
+        if (callback) callback();
+        return;
+    }
+
+    this._realLoadEquip(equipType, null, unloadEquipId, callback);
+}
+
+items.prototype.compareEquipment = function (compareEquipId, beComparedEquipId) {
+    var result = {};
+    var first = core.material.items[compareEquipId], second = core.material.items[beComparedEquipId];
+    for (var name in core.status.hero) {
+        if (typeof core.status.hero[name] == 'number') {
+            var ans = 0;
+            if (first) ans += (first.equip || {})[name] || 0;
+            if (second) ans -= (second.equip || {})[name] || 0;
+            if (ans != 0) result[name] = ans;
+        }
+    }
+    return result;
+}
+
+////// 实际换装的效果 //////
+items.prototype._loadEquipEffect = function (equipId, unloadEquipId, isPercentage) {
+    // 比较能力值
+    var result = core.compareEquipment(equipId, unloadEquipId);
+
+    if (isPercentage) {
+        for (var name in result)
+            core.addBuff(name, result[name] / 100);
+    }
+    else {
+        for (var name in result)
+            core.status.hero[name] += result[name];
+    }
+}
+
+items.prototype._realLoadEquip = function (type, loadId, unloadId, callback) {
+    var loadEquip = core.material.items[loadId] || {}, unloadEquip = core.material.items[unloadId] || {};
+    loadEquip.equip = loadEquip.equip || {};
+    unloadEquip.equip = unloadEquip.equip || {}
+
+    var loadPercentage = loadEquip.equip.percentage, unloadPercentage = unloadEquip.equip.percentage;
+
+    if (loadId && unloadId && (loadPercentage || false) != (unloadPercentage || false)) {
+        this.unloadEquip(type);
+        this.loadEquip(loadId);
+        if (callback) callback();
+        return;
+    }
+
+    // --- 音效
+    core.playSound('equip.mp3');
+
+    // --- 实际换装
+    this._loadEquipEffect(loadId, unloadId, loadPercentage == null ? unloadPercentage : loadPercentage);
+
+    // --- 加减
+    if (loadId) core.removeItem(loadId);
+    if (unloadId) core.addItem(unloadId);
+    core.status.hero.equipment[type] = loadId || null;
+
+    // --- 提示
+    if (loadId) core.drawTip("已装备上" + loadEquip.name, loadId);
+    else if (unloadId) core.drawTip("已卸下" + unloadEquip.name, unloadId);
+
+    if (callback) callback();
+}
+
+////// 保存装备 //////
+items.prototype.quickSaveEquip = function (index) {
+    var saveEquips = core.getFlag("saveEquips", []);
+    saveEquips[index] = core.clone(core.status.hero.equipment);
+    core.setFlag("saveEquips", saveEquips);
+    core.drawTip("已保存" + index + "号套装");
+}
+
+////// 读取装备 //////
+items.prototype.quickLoadEquip = function (index) {
+    var current = core.getFlag("saveEquips", [])[index];
+    if (!current) {
+        core.drawTip(index + "号套装不存在");
+        return;
+    }
+    // 检查所有的装备
+    var equipSize = core.status.globalAttribute.equipName.length;
+    for (var i = 0; i < equipSize; i++) {
+        var v = current[i];
+        if (v && !this.canEquip(v, true))
+            return;
+    }
+    // 快速换装
+    for (var i = 0; i < equipSize; i++) {
+        var now = core.status.hero.equipment[i];
+        if (now) {
+            this.unloadEquip(i);
+            core.status.route.push("unEquip:" + i);
+        }
+    }
+    for (var i = 0; i < equipSize; i++) {
+        var to = current[i];
+        if (to) {
+            this.loadEquip(to);
+            core.status.route.push("equip:" + to);
+        }
+    }
+    core.drawTip("成功换上" + index + "号套装");
+}
diff --git a/libs/loader.js b/libs/loader.js
index fe3c0e4b..74435cd6 100644
--- a/libs/loader.js
+++ b/libs/loader.js
@@ -2,80 +2,116 @@
 loader.js：负责对资源的加载
 
  */
+"use strict";
 
 function loader() {
-    this.init();
+    this._init();
 }
 
-loader.prototype.init = function () {
+loader.prototype._init = function () {
 
 }
 
 ////// 设置加载进度条进度 //////
-loader.prototype.setStartProgressVal = function (val) {
+loader.prototype._setStartProgressVal = function (val) {
     core.dom.startTopProgress.style.width = val + '%';
 }
 
 ////// 设置加载进度条提示文字 //////
-loader.prototype.setStartLoadTipText = function (text) {
+loader.prototype._setStartLoadTipText = function (text) {
     core.dom.startTopLoadTips.innerHTML = text;
 }
 
-loader.prototype.load = function (callback) {
+loader.prototype._load = function (callback) {
+    this._loadIcons();
+    this._loadAnimates();
+    this._loadMusic();
 
-    // 加载icons
-    core.loader.loadIcons();
-
-    // 加载图片
-    core.loader.loadImages(core.materials, core.material.images, function () {
-        // 加载png图片
-        core.material.images.images = {};
-
-        var images = core.clone(core.images);
-        if (images.indexOf("hero.png")<0)
-            images.push("hero.png");
-
-        core.loader.loadImages(images, core.material.images.images, function () {
-            // 加载autotile
-            core.material.images.autotile = {};
-            core.loader.loadImages(Object.keys(core.material.icons.autotile), core.material.images.autotile, function () {
-                core.loader.loadAnimates();
-                core.loader.loadMusic();
-                if (core.isset(callback))
-                    callback();
+    core.loader._loadMaterialImages(function () {
+        core.loader._loadExtraImages(function () {
+            core.loader._loadAutotiles(function () {
+                core.loader._loadTilesets(callback);
             })
         })
-    })
+    });
 }
 
-loader.prototype.loadIcons = function () {
-
+loader.prototype._loadIcons = function () {
     this.loadImage("icons.png", function (id, image) {
-        var images = core.cropImage(image);
+        var images = core.splitImage(image);
         for (var key in core.statusBar.icons) {
             if (typeof core.statusBar.icons[key] == 'number') {
                 core.statusBar.icons[key] = images[core.statusBar.icons[key]];
-                if (core.isset(core.statusBar.image[key]))
+                if (core.statusBar.image[key] != null)
                     core.statusBar.image[key].src = core.statusBar.icons[key].src;
             }
         }
     });
 }
 
+loader.prototype._loadMaterialImages = function (callback) {
+    this.loadImages(core.materials, core.material.images, callback);
+}
+
+loader.prototype._loadExtraImages = function (callback) {
+    core.material.images.images = {};
+
+    var images = core.clone(core.images);
+    if (images.indexOf("hero.png") < 0)
+        images.push("hero.png");
+
+    this.loadImages(images, core.material.images.images, callback);
+}
+
+loader.prototype._loadAutotiles = function (callback) {
+    core.material.images.autotile = {};
+    var keys = Object.keys(core.material.icons.autotile);
+    var autotiles = {};
+    this.loadImages(keys, autotiles, function () {
+        keys.forEach(function (v) {
+            core.material.images.autotile[v] = autotiles[v];
+        });
+
+        setTimeout(function () {
+            core.maps._makeAutotileEdges();
+        });
+
+        callback();
+    });
+}
+
+loader.prototype._loadTilesets = function (callback) {
+    core.material.images.tilesets = {};
+    core.tilesets = core.tilesets || [];
+    core.loader.loadImages(core.clone(core.tilesets), core.material.images.tilesets, function () {
+        // 检查宽高是32倍数，如果出错在控制台报错
+        for (var imgName in core.material.images.tilesets) {
+            var img = core.material.images.tilesets[imgName];
+            if (img.width % 32 != 0 || img.height % 32 != 0) {
+                console.warn("警告！" + imgName + "的宽或高不是32的倍数！");
+            }
+            if (img.width * img.height > 32 * 32 * 3000) {
+                console.warn("警告！" + imgName + "上的图块素材个数大于3000！");
+            }
+        }
+        callback();
+    });
+}
+
 loader.prototype.loadImages = function (names, toSave, callback) {
-    if (names.length==0) {
-        if (core.isset(callback)) callback();
+    if (!names || names.length == 0) {
+        if (callback) callback();
         return;
     }
     var items = 0;
-    for (var i=0;i<names.length;i++) {
+    for (var i = 0; i < names.length; i++) {
         this.loadImage(names[i], function (id, image) {
-            core.loader.setStartLoadTipText('正在加载图片 ' + id + "...");
+            core.loader._setStartLoadTipText('正在加载图片 ' + id + "...");
             toSave[id] = image;
             items++;
-            core.loader.setStartProgressVal(items * (100 / names.length));
+            core.loader._setStartProgressVal(items * (100 / names.length));
             if (items == names.length) {
-                if (core.isset(callback)) callback();
+                if (callback) callback();
             }
         })
     }
@@ -83,25 +119,21 @@ loader.prototype.loadImages = function (names, toSave, callback) {
 
 loader.prototype.loadImage = function (imgName, callback) {
     try {
-        var name=imgName;
-        if (name.indexOf(".")<0)
-            name=name+".png";
+        var name = imgName;
+        if (name.indexOf(".") < 0)
+            name = name + ".png";
         var image = new Image();
-        image.src = 'project/images/' + name + "?v=" + main.version;
-        if (image.complete) {
-            callback(imgName, image);
-            return;
-        }
         image.onload = function () {
             callback(imgName, image);
         }
+        image.src = 'project/images/' + name + "?v=" + main.version;
     }
     catch (e) {
-        console.log(e);
+        main.log(e);
     }
 }
 
-loader.prototype.loadAnimates = function () {
+loader.prototype._loadAnimates = function () {
     core.animates.forEach(function (t) {
         core.http('GET', 'project/animates/' + t + ".animate", null, function (content) {
             try {
@@ -112,7 +144,7 @@ loader.prototype.loadAnimates = function () {
                 data.images = [];
                 data.images_rev = [];
                 content.bitmaps.forEach(function (t2) {
-                    if (!core.isset(t2) || t2 == "") {
+                    if (!t2) {
                         data.images.push(null);
                     }
                     else {
@@ -121,6 +153,7 @@ loader.prototype.loadAnimates = function () {
                             image.src = t2;
                             data.images.push(image);
                         } catch (e) {
+                            main.log(e);
                             data.images.push(null);
                         }
                     }
@@ -145,94 +178,109 @@ loader.prototype.loadAnimates = function () {
                 core.material.animates[t] = data;
             }
             catch (e) {
-                console.log(e);
+                main.log(e);
                 core.material.animates[t] = null;
             }
         }, function (e) {
-            console.log(e);
+            main.log(e);
             core.material.animates[t] = null;
         }, "text/plain; charset=x-user-defined")
     })
 }
 
 ////// 加载音频 //////
-loader.prototype.loadMusic = function () {
-
+loader.prototype._loadMusic = function () {
     core.bgms.forEach(function (t) {
-
-        // 判断是不是mid
-        if (/^.*\.mid$/i.test(t)) {
-
-            if (core.musicStatus.audioContext!=null) {
-                core.material.bgms[t] = 'loading';
-
-                core.http('GET', 'project/sounds/'+t, null, function (data) {
-                    try {
-                        var ff = [];
-                        var mx = data.length;
-                        for (var z = 0; z < mx; z++)
-                            ff[z] = String.fromCharCode(data.charCodeAt(z) & 255);
-                        var shouldStart = core.material.bgms[t] == 'starting';
-                        core.material.bgms[t] = AudioPlayer(core.musicStatus.audioContext, Replayer(MidiFile(ff.join("")), Synth(44100)), true);
-
-                        if (shouldStart)
-                            core.playBgm(t);
-                    }
-                    catch (e) {
-                        console.log(e);
-                        core.material.bgms[t] = null;
-                    }
-                }, function (e) {
-                    console.log(e);
-                    core.material.bgms[t] = null;
-                }, "text/plain; charset=x-user-defined")
-
-            }
-            else {
-                core.material.bgms[t] = null;
-            }
-        }
-        else {
-            var music = new Audio();
-            music.preload = 'none';
-            if (main.bgmRemote) music.src = main.bgmRemoteRoot+core.firstData.name+'/'+t;
-            else music.src = 'project/sounds/'+t;
-            music.loop = 'loop';
-            core.material.bgms[t] = music;
-        }
+        core.loader.loadOneMusic(t);
     });
 
     core.sounds.forEach(function (t) {
-
-        if (core.musicStatus.audioContext != null) {
-
-            core.http('GET', 'project/sounds/'+t, null, function (data) {
-                try {
-                    core.musicStatus.audioContext.decodeAudioData(data, function (buffer) {
-                        core.material.sounds[t] = buffer;
-                    }, function (e) {
-                        console.log(e);
-                        core.material.sounds[t] = null;
-                    })
-                }
-                catch (ee) {
-                    console.log(ee);
-                    core.material.sounds[t] = null;
-                }
-            }, function () {
-                console.log(e);
-                core.material.sounds[t] = null;
-            }, null, 'arraybuffer');
-        }
-        else {
-            var music = new Audio();
-            music.src = 'project/sounds/'+t;
-            core.material.sounds[t] = music;
-        }
-
+        core.loader.loadOneSound(t);
     });
-
     // 直接开始播放
-    if (core.musicStatus.startDirectly && core.bgms.length>0)
-        core.playBgm(core.bgms[0]);
+    core.playBgm(main.startBgm);
 }
+
+loader.prototype.loadOneMusic = function (name) {
+    var music = new Audio();
+    music.preload = 'none';
+    if (main.bgmRemote) music.src = main.bgmRemoteRoot + core.firstData.name + '/' + name;
+    else music.src = 'project/sounds/' + name;
+    music.loop = 'loop';
+    core.material.bgms[name] = music;
+}
+
+loader.prototype.loadOneSound = function (name) {
+    if (core.musicStatus.audioContext != null) {
+        core.http('GET', 'project/sounds/' + name, null, function (data) {
+            try {
+                core.musicStatus.audioContext.decodeAudioData(data, function (buffer) {
+                    core.material.sounds[name] = buffer;
+                }, function (e) {
+                    main.log(e);
+                    core.material.sounds[name] = null;
+                })
+            }
+            catch (e) {
+                main.log(e);
+                core.material.sounds[name] = null;
+            }
+        }, function (e) {
+            main.log(e);
+            core.material.sounds[name] = null;
+        }, null, 'arraybuffer');
+    }
+    else {
+        var music = new Audio();
+        music.src = 'project/sounds/' + name;
+        core.material.sounds[name] = music;
+    }
+}
+
+loader.prototype.loadBgm = function (name) {
+    name = core.getMappedName(name);
+    if (!core.material.bgms[name]) return;
+    // 如果没开启音乐，则不预加载
+    if (!core.musicStatus.bgmStatus) return;
+    // 是否已经预加载过
+    var index = core.musicStatus.cachedBgms.indexOf(name);
+    if (index >= 0) {
+        core.musicStatus.cachedBgms.splice(index, 1);
+    }
+    else {
+        // 预加载BGM
+        this._preloadBgm(core.material.bgms[name]);
+        // core.material.bgms[name].load();
+        // 清理尾巴
+        if (core.musicStatus.cachedBgms.length == core.musicStatus.cachedBgmCount) {
+            this.freeBgm(core.musicStatus.cachedBgms.pop());
+        }
+    }
+    // 移动到缓存最前方
+    core.musicStatus.cachedBgms.unshift(name);
+}
+
+loader.prototype._preloadBgm = function (bgm) {
+    bgm.volume = 0;
+    bgm.play();
+}
+
+loader.prototype.freeBgm = function (name) {
+    name = core.getMappedName(name);
+    if (!core.material.bgms[name]) return;
+    // 从cachedBgms中删除
+    core.musicStatus.cachedBgms = core.musicStatus.cachedBgms.filter(function (t) {
+        return t != name;
+    });
+    // 清掉缓存
+    core.material.bgms[name].removeAttribute("src");
+    core.material.bgms[name].load();
+    core.material.bgms[name] = null;
+    if (name == core.musicStatus.playingBgm) {
+        core.musicStatus.playingBgm = null;
+    }
+    // 三秒后重新加载
+    setTimeout(function () {
+        core.loader.loadOneMusic(name);
+    }, 3000);
+}
\ No newline at end of file
diff --git a/libs/maps.js b/libs/maps.js
index 32d01cf3..fe9fd6bf 100644
--- a/libs/maps.js
+++ b/libs/maps.js
@@ -1,103 +1,133 @@
+"use strict";
+
 function maps() {
-    this.init();
+    this._init();
 }
 
-maps.prototype.init = function() {
+maps.prototype._init = function () {
     this.blocksInfo = maps_90f36752_8815_4be8_b32b_d7fad1d0542e;
     //delete(maps_90f36752_8815_4be8_b32b_d7fad1d0542e);
 }
 
+maps.prototype._setFloorSize = function (floorId) {
+    if (!floorId) {
+        core.floorIds.forEach(function (floorId) {
+            core.maps._setFloorSize(floorId);
+        });
+        return;
+    }
+    core.floors[floorId].width = core.floors[floorId].width || core.__SIZE__;
+    core.floors[floorId].height = core.floors[floorId].height || core.__SIZE__;
+}
+
+// ------ 加载地图与地图的存档读档（压缩与解压缩） ------ //
+
 ////// 加载某个楼层（从剧本或存档中） //////
 maps.prototype.loadFloor = function (floorId, map) {
     var floor = core.floors[floorId];
+    if (!map) map = floor.map;
+    if (map instanceof Array) {
+        map = {"map": map};
+    }
     var content = {};
-    content['floorId'] = floor.floorId;
-    content['name'] = floor.name;
-    content['title'] = floor.title;
-    content['canFlyTo'] = floor.canFlyTo;
-    if (!core.isset(map)) map=floor.map;
-    var mapIntoBlocks = function(map,maps,floor,floorId){
-        var blocks = [];
-        var mw = core.floors[floorId].width || 13;
-        var mh = core.floors[floorId].height || 13;
-        for (var i = 0; i < mh; i++) {
-            for (var j = 0; j < mw; j++) {
-                var block = maps.initBlock(j, i, (map[i]||[])[j]||0);
-                maps.addInfo(block);
-                maps.addEvent(block,j,i,floor.events[j+","+i])
-                maps.addChangeFloor(block,j,i,floor.changeFloor[j+","+i]);
-                if (core.isset(block.event)) blocks.push(block);
-            }
-        }
-        return blocks;
+    var notCopy = ["firstArrive", "eachArrive", "parallelDo", "map", "bgmap", "fgmap",
+        "events", "changeFloor", "afterBattle", "afterGetItem", "afterOpenDoor", "cannotMove"];
+    for (var name in floor) {
+        if (notCopy.indexOf(name) == -1 && floor[name] != null)
+            content[name] = core.clone(floor[name]);
     }
-    if (main.mode=='editor'){
-        main.editor.mapIntoBlocks = function(map,floor,floorId){
-            return mapIntoBlocks(map,core.maps,floor,floorId);
-        }
+    for (var name in map) {
+        if (notCopy.indexOf(name) == -1 && map[name] != null)
+            content[name] = core.clone(map[name]);
     }
+    map = this.decompressMap(map.map, floorId);
     // 事件处理
-    content['blocks'] = mapIntoBlocks(map,this,floor,floorId);
+    content['blocks'] = this._mapIntoBlocks(map, floor, floorId);
     return content;
 }
 
-////// 数字和ID的对应关系 //////
-maps.prototype.initBlock = function (x, y, id) {
-    var disable=null;
-    id = ""+id;
-    if (id.length>2) {
-        if (id.indexOf(":f")==id.length-2) {
-            id = id.substring(0, id.length - 2);
-            disable = false;
-        }
-        else if (id.indexOf(":t")==id.length-2) {
-            id = id.substring(0, id.length - 2);
-            disable = true;
+maps.prototype._mapIntoBlocks = function (map, floor, floorId) {
+    var blocks = [];
+    var mw = core.floors[floorId].width;
+    var mh = core.floors[floorId].height;
+    for (var i = 0; i < mh; i++) {
+        for (var j = 0; j < mw; j++) {
+            var block = this.initBlock(j, i, (map[i] || [])[j], true, floor);
+            if (block.id != 0 || block.event.trigger)
+                blocks.push(block);
         }
     }
-    id=parseInt(id);
-    var tmp = {'x': x, 'y': y, 'id': id};
-    if (disable!=null) tmp.disable = disable;
+    return blocks;
+}
 
-    if (id in this.blocksInfo) tmp.event = JSON.parse(JSON.stringify(this.blocksInfo[id]));
+////// 从ID获得数字 //////
+maps.prototype.getNumberById = function (id) {
+    for (var number in this.blocksInfo) {
+        if ((this.blocksInfo[number] || {}).id == id)
+            return parseInt(number) || 0;
+    }
+    // tilesets
+    if (/^X\d+$/.test(id)) {
+        if (core.icons.getTilesetOffset(id)) return parseInt(id.substring(1));
+    }
+    // 特殊ID
+    if (id == 'none') return 0;
+    if (id == 'airwall') return 17;
+    return 0;
+}
 
-    return tmp;
+////// 数字和ID的对应关系 //////
+maps.prototype.initBlock = function (x, y, id, addInfo, eventFloor) {
+    var disable = null;
+    id = "" + (id || 0);
+    if (id.endsWith(":f")) disable = true;
+    if (id.endsWith(":t")) disable = false;
+    id = parseInt(id);
+    var block = {'x': x, 'y': y, 'id': id};
+    if (disable != null) block.disable = disable;
+
+    if (id == 17) block.event = {"cls": "terrains", "id": "airwall", "noPass": true};
+    else if (id in this.blocksInfo) block.event = JSON.parse(JSON.stringify(this.blocksInfo[id]));
+    else if (core.icons.getTilesetOffset(id)) block.event = {"cls": "tileset", "id": "X" + id, "noPass": true};
+    else block.event = {'cls': 'terrains', 'id': 'none', 'noPass': false};
+
+    if (typeof block.event.noPass === 'string')
+        block.event.noPass = JSON.parse(block.event.noPass);
+
+    if (addInfo) this._addInfo(block);
+    if (eventFloor) {
+        this._addEvent(block, x, y, (eventFloor.events || {})[x + "," + y]);
+        var changeFloor = (eventFloor.changeFloor || {})[x + "," + y];
+        if (changeFloor) this._addEvent(block, x, y, {"trigger": "changeFloor", "data": changeFloor});
+    }
+    if (main.mode == 'editor') delete block.disable;
+    return block;
 }
 
 ////// 添加一些信息到block上 //////
-maps.prototype.addInfo = function (block) {
-    if (core.isset(block.event)) {
-        if (block.event.cls.indexOf("enemy")==0 && !core.isset(block.event.trigger)) {
-            block.event.trigger = 'battle';
-        }
-        if (block.event.cls == 'items' && !core.isset(block.event.trigger)) {
-            block.event.trigger = 'getItem';
-        }
-        if (!core.isset(block.event.noPass)) {
-            if (block.event.cls.indexOf("enemy")==0 || block.event.cls.indexOf("npc")==0 || block.event.cls=='terrains') {
-                block.event.noPass = true;
-            }
-        }
-        if (!core.isset(block.event.animate)) {
-            if (block.event.cls=='enemys' || block.event.cls=='npcs') {
-                block.event.animate = 2;
-            }
-            if (block.event.cls == 'animates' || block.event.cls == 'enemy48' || block.event.cls == 'npc48') {
-                block.event.animate = 4;
-            }
-        }
-        block.event.height = 32;
-        if (block.event.cls == 'enemy48' || block.event.cls == 'npc48')
-            block.event.height = 48;
+maps.prototype._addInfo = function (block) {
+    if (block.event.cls.indexOf("enemy") == 0 && !block.event.trigger) {
+        block.event.trigger = 'battle';
     }
+    if (block.event.cls == 'items' && !block.event.trigger) {
+        block.event.trigger = 'getItem';
+    }
+    if (block.event.noPass == null) {
+        if (block.event.cls != 'items') {
+            block.event.noPass = true;
+        }
+    }
+    if (block.event.animate == null) {
+        block.event.animate = core.icons._getAnimateFrames(block.event.cls, false);
+    }
+    block.event.height = 32;
+    if (block.event.cls == 'enemy48' || block.event.cls == 'npc48')
+        block.event.height = 48;
 }
 
 ////// 向该楼层添加剧本的自定义事件 //////
-maps.prototype.addEvent = function (block, x, y, event) {
-    if (!core.isset(event)) return;
-    if (!core.isset(block.event)) { // 本身是空地？
-        block.event = {'cls': 'terrains', 'id': 'none', 'noPass': false};
-    }
+maps.prototype._addEvent = function (block, x, y, event) {
+    if (!event) return;
     // event是字符串或数组？
     if (typeof event == "string") {
         event = {"data": [event]};
@@ -105,103 +135,143 @@ maps.prototype.addEvent = function (block, x, y, event) {
     else if (event instanceof Array) {
         event = {"data": event};
     }
-    if (!core.isset(event.data))
-        event.data = [];
-
-    // 覆盖noPass
-    if (core.isset(event.noPass))
-        block.event.noPass = event.noPass;
+    event.data = event.data || [];
 
     // 覆盖enable
-    if (!core.isset(block.disable) && core.isset(event.enable)) {
-        block.disable=!event.enable;
+    if (block.disable == null && event.enable != null) {
+        block.disable = !event.enable;
     }
-    // 覆盖trigger
-    if (!core.isset(block.event.trigger)) {
-        if (core.isset(event.trigger)) block.event.trigger=event.trigger;
-        else block.event.trigger='action';
+    // 覆盖animate
+    if (event.animate === false) {
+        block.event.animate = 1;
     }
-    else if (core.isset(event.trigger) && event.trigger!='checkBlock') {
-        block.event.trigger=event.trigger;
-    }
-    // 覆盖其他属性
+    // 覆盖所有属性
     for (var key in event) {
-        if (key!="disable" && key!="trigger" && key!="noPass" && core.isset(event[key])) {
-            block.event[key]=core.clone(event[key]);
+        if (key != "enable" && key != "animate" && event[key] != null) {
+            block.event[key] = core.clone(event[key]);
         }
     }
-}
-
-////// 向该楼层添加剧本的楼层转换事件 //////
-maps.prototype.addChangeFloor = function (block, x, y, event, ground) {
-    if (!core.isset(event)) return;
-    this.addEvent(block, x, y, {"trigger": "changeFloor", "data": event}, ground);
+    // 给无trigger的增加trigger:action
+    if (!block.event.trigger) {
+        block.event.trigger = 'action';
+    }
 }
 
 ////// 初始化所有地图 //////
-maps.prototype.initMaps = function (floorIds) {
+maps.prototype._initMaps = function () {
+    var floorIds = core.floorIds;
     var maps = {};
-    for (var i=0;i<floorIds.length;i++) {
+    for (var i = 0; i < floorIds.length; i++) {
         var floorId = floorIds[i];
         maps[floorId] = this.loadFloor(floorId);
     }
     return maps;
 }
 
+maps.prototype._initFloorMap = function (floorId) {
+    var map = core.clone(core.floors[floorId].map);
+
+    var mw = core.floors[floorId].width;
+    var mh = core.floors[floorId].height;
+
+    for (var x = 0; x < mh; x++) {
+        if (map[x] == null) map[x] = [];
+        for (var y = 0; y < mw; y++) {
+            if (map[x][y] == null) map[x][y] = 0;
+            // check "disable"
+            var event = core.floors[floorId].events[y + "," + x];
+            if (event && event.enable === false && main.mode == 'play') {
+                map[x][y] += ":f";
+            }
+        }
+    }
+
+    return map;
+}
+
+////// 压缩地图
+maps.prototype.compressMap = function (mapArr, floorId) {
+    var floorMap = this._initFloorMap(floorId);
+    if (core.utils.same(mapArr, floorMap)) return null;
+
+    var mw = core.floors[floorId].width;
+    var mh = core.floors[floorId].height;
+    for (var x = 0; x < mh; x++) {
+        if (core.utils.same(mapArr[x], floorMap[x])) {
+            // 没有改变的行直接删掉记成0
+            mapArr[x] = 0;
+        }
+        else {
+            for (var y = 0; y < mw; y++) {
+                if (mapArr[x][y] === floorMap[x][y]) {
+                    // 没有改变的数据记成-1
+                    mapArr[x][y] = -1;
+                }
+            }
+        }
+    }
+    return mapArr;
+}
+
+////// 解压缩地图
+maps.prototype.decompressMap = function (mapArr, floorId) {
+    var floorMap = this._initFloorMap(floorId);
+    if (!mapArr) return floorMap;
+
+    var mw = core.floors[floorId].width;
+    var mh = core.floors[floorId].height;
+    for (var x = 0; x < mh; x++) {
+        if (mapArr[x] === 0) {
+            mapArr[x] = floorMap[x];
+        }
+        else {
+            for (var y = 0; y < mw; y++) {
+                if (mapArr[x][y] === -1) {
+                    mapArr[x][y] = floorMap[x][y];
+                }
+            }
+        }
+    }
+    return mapArr;
+}
+
 ////// 将当前地图重新变成数字，以便于存档 //////
-maps.prototype.save = function(maps, floorId) {
-    if (!core.isset(floorId)) {
+maps.prototype.saveMap = function (floorId) {
+    var maps = core.status.maps;
+    if (!floorId) {
         var map = {};
         for (var id in maps) {
-            map[id] = this.save(maps, id);
-            // map.push(this.save(maps, id));
+            var obj = this.saveMap(id);
+            if (Object.keys(obj).length > 0) map[id] = obj;
         }
         return map;
     }
+    var map = maps[floorId], floor = core.floors[floorId];
+    var blocks = this._getMapArrayFromBlocks(map.blocks, floor.width, floor.height, true);
+    if (main.mode == 'editor') return blocks;
 
-    var thisFloor = maps[floorId];
-    var mw = core.floors[floorId].width || 13;
-    var mh = core.floors[floorId].height || 13;
-
-    var blocks = [];
-    for (var x=0;x<mw;x++) {
-        blocks[x]=[];
-        for (var y=0;y<mh;y++) {
-            blocks[x].push(0);
-        }
-    }
-    thisFloor.blocks.forEach(function (block) {
-        if (core.isset(block.disable)) {
-            if (!block.disable) blocks[block.y][block.x] = block.id+":t";
-            else blocks[block.y][block.x] = block.id+":f";
-        }
-        else blocks[block.y][block.x] = block.id;
-    });
-    return blocks;
+    var thisFloor = this._compressFloorData(map, floor);
+    var mapArr = this.compressMap(blocks, floorId);
+    if (mapArr != null) thisFloor.map = mapArr;
+    return thisFloor;
 }
 
-////// 更改地图画布的尺寸
-maps.prototype.resizeMap = function(floorId) {
-    floorId = floorId || core.status.floorId;
-    core.bigmap.width = core.floors[floorId].width || 13;
-    core.bigmap.height = core.floors[floorId].height || 13;
-    var cwidth = core.bigmap.width * 32;
-    var cheight = core.bigmap.height * 32;
-    core.bigmap.canvas.forEach(function(cn){
-        core.canvas[cn].canvas.setAttribute("width",cwidth);
-        core.canvas[cn].canvas.setAttribute("height",cheight);
-        core.canvas[cn].canvas.style.width = cwidth*core.domStyle.scale + "px";
-        core.canvas[cn].canvas.style.height = cheight*core.domStyle.scale + "px";
-        if(main.mode==='editor' && editor.isMobile){
-            core.canvas[cn].canvas.style.width = core.bigmap.width*32/416*96 + "vw";
-            core.canvas[cn].canvas.style.height = core.bigmap.height*32/416*96 + "vw";
+maps.prototype._compressFloorData = function (map, floor) {
+    var thisFloor = {};
+    for (var name in map) {
+        if (name != 'blocks') {
+            var floorData = floor[name];
+            if (!core.utils.same(map[name], floorData)) {
+                thisFloor[name] = core.clone(map[name]);
+            }
         }
-    });
+    }
+    return thisFloor;
 }
 
 ////// 将存档中的地图信息重新读取出来 //////
-maps.prototype.load = function (data, floorId) {
-    if (floorId == undefined) {
+maps.prototype.loadMap = function (data, floorId) {
+    if (!floorId) {
         var map = {};
         core.floorIds.forEach(function (id) {
             map[id] = core.maps.loadFloor(id, data[id]);
@@ -211,372 +281,913 @@ maps.prototype.load = function (data, floorId) {
     return this.loadFloor(floorId, data[floorId]);
 }
 
+////// 更改地图画布的尺寸
+maps.prototype.resizeMap = function (floorId) {
+    floorId = floorId || core.status.floorId;
+    if (!floorId) return;
+    core.bigmap.width = core.floors[floorId].width;
+    core.bigmap.height = core.floors[floorId].height;
+    var cwidth = core.bigmap.width * 32;
+    var cheight = core.bigmap.height * 32;
+    core.bigmap.canvas.forEach(function (cn) {
+        core.canvas[cn].canvas.setAttribute("width", cwidth);
+        core.canvas[cn].canvas.setAttribute("height", cheight);
+        core.canvas[cn].canvas.style.width = cwidth * core.domStyle.scale + "px";
+        core.canvas[cn].canvas.style.height = cheight * core.domStyle.scale + "px";
+        if (main.mode === 'editor' && editor.isMobile) {
+            core.canvas[cn].canvas.style.width = core.bigmap.width * 32 / core.__PIXELS__ * 96 + "vw";
+            core.canvas[cn].canvas.style.height = core.bigmap.height * 32 / core.__PIXELS__ * 96 + "vw";
+        }
+    });
+}
+
 ////// 将当前地图重新变成二维数组形式 //////
-maps.prototype.getMapArray = function (blockArray,width,height){
+maps.prototype.getMapArray = function (floorId, showDisable) {
+    floorId = floorId || core.status.floorId;
+    return this._getMapArrayFromBlocks(core.status.maps[floorId].blocks,
+        core.floors[floorId].width, core.floors[floorId].height, showDisable);
+}
+
+maps.prototype._getMapArrayFromBlocks = function (blockArray, width, height, showDisable) {
+    if (typeof blockArray == 'string') {
+        var floorId = blockArray;
+        blockArray = core.status.maps[floorId].blocks;
+        width = core.floors[floorId].width;
+        height = core.floors[floorId].height;
+    }
 
     var blocks = [];
-    for (var x=0;x<width;x++) {
-        blocks[x]=[];
-        for (var y=0;y<height;y++) {
-            blocks[x].push(0);
-        }
-    }
+    var allzero = [];
+    for (var y = 0; y < width; y++) allzero.push(0);
+    for (var x = 0; x < height; x++) blocks.push(core.clone(allzero));
+
     blockArray.forEach(function (block) {
-        if (!block.disable)
-            blocks[block.y][block.x] = block.id;
+        var x = block.x, y = block.y;
+        if (block.disable) {
+            if (showDisable) blocks[y][x] = block.id + ":f";
+        }
+        else {
+            blocks[y][x] = block.id;
+            if (showDisable && block.disable === false)
+                blocks[y][x] = block.id + ":t";
+        }
     });
     return blocks;
 }
 
+////// 以x,y的形式返回每个点的事件 //////
+maps.prototype.getMapBlocksObj = function (floorId, showDisable) {
+    floorId = floorId || core.status.floorId;
+    var obj = {};
+    core.status.maps[floorId].blocks.forEach(function (block) {
+        if (!block.disable || showDisable)
+            obj[block.x + "," + block.y] = block;
+    });
+    return obj;
+}
 
+////// 将背景前景层变成二维数组的形式 //////
+maps.prototype._getBgFgMapArray = function (name, floorId, noCache) {
+    floorId = floorId || core.status.floorId;
+    if (!floorId) return [];
+    var width = core.floors[floorId].width;
+    var height = core.floors[floorId].height;
+
+    if (!noCache && core.status[name + "maps"][floorId])
+        return core.status[name + "maps"][floorId];
+
+    var arr = core.clone(core.floors[floorId][name + "map"] || []);
+    if (main.mode == 'editor') arr = core.clone(editor[name + "map"]) || arr;
+    for (var x = 0; x < width; x++) {
+        for (var y = 0; y < height; y++) {
+            arr[y] = arr[y] || [];
+            var flag = "__" + name + "Map__" + floorId + "_" + x + "_" + y;
+            var vFlag = "__" + name + "Value__" + floorId + "_" + x + "_" + y;
+            if (core.hasFlag(flag)) arr[y][x] = 0;
+            else arr[y][x] = core.getFlag(vFlag, arr[y][x] || 0);
+            if (main.mode == 'editor') arr[y][x] = arr[y][x].idnum || arr[y][x] || 0;
+        }
+    }
+    if (core.status[name + "maps"])
+        core.status[name + "maps"][floorId] = core.clone(arr);
+    return arr;
+}
+
+maps.prototype.getBgMapArray = function (floorId, noCache) {
+    return this._getBgFgMapArray('bg', floorId, noCache);
+}
+
+maps.prototype.getFgMapArray = function (floorId, noCache) {
+    return this._getBgFgMapArray('fg', floorId, noCache);
+}
+
+maps.prototype._getBgFgNumber = function (name, x, y, floorId, noCache) {
+    if (x == null) x = core.getHeroLoc('x');
+    if (y == null) y = core.getHeroLoc('y');
+    return this._getBgFgMapArray(name, floorId, noCache)[y][x];
+}
+
+maps.prototype.getBgNumber = function (x, y, floorId, noCache) {
+    return this._getBgFgNumber('bg', x, y, floorId, noCache);
+}
+
+maps.prototype.getFgNumber = function (x, y, floorId, noCache) {
+    return this._getBgFgNumber('fg', x, y, floorId, noCache);
+}
+
+// ------ 当前能否朝某方向移动，能否瞬间移动 ------ //
+
+////// 生成全图的当前可移动信息 //////
+maps.prototype.generateMovableArray = function (floorId, x, y, direction) {
+    floorId = floorId || core.status.floorId;
+    if (!floorId) return null;
+    var width = core.floors[floorId].width, height = core.floors[floorId].height;
+    var bgArray = this.getBgMapArray(floorId),
+        fgArray = this.getFgMapArray(floorId),
+        eventArray = this.getMapArray(floorId);
+
+    var generate = function (x, y, direction) {
+        if (direction != null) {
+            return core.maps._canMoveHero_checkPoint(x, y, direction, floorId, {
+                bgArray: bgArray, fgArray: fgArray, eventArray: eventArray
+            });
+        }
+        return ["left", "down", "up", "right"].filter(function (direction) {
+            return core.maps._canMoveHero_checkPoint(x, y, direction, floorId, {
+                bgArray: bgArray, fgArray: fgArray, eventArray: eventArray
+            });
+        });
+    }
+
+    if (x != null && y != null) return generate(x, y, direction);
+    var array = [];
+    for (var x = 0; x < width; x++) {
+        array[x] = [];
+        for (var y = 0; y < height; y++) {
+            array[x][y] = generate(x, y);
+        }
+    }
+    return array;
+}
 
 ////// 勇士能否前往某方向 //////
-maps.prototype.canMoveHero = function(x,y,direction,floorId) {
-    if (!core.isset(x)) x=core.getHeroLoc('x');
-    if (!core.isset(y)) y=core.getHeroLoc('y');
-    if (!core.isset(direction)) direction=core.getHeroLoc('direction');
-    if (!core.isset(floorId)) floorId=core.status.floorId;
+maps.prototype.canMoveHero = function (x, y, direction, floorId) {
+    if (x == null) x = core.getHeroLoc('x');
+    if (y == null) y = core.getHeroLoc('y');
+    direction = direction || core.getHeroLoc('direction');
+    return this.generateMovableArray(floorId, x, y, direction);
+}
 
-    // 检查当前块的cannotMove
-    if (core.isset(core.floors[floorId].cannotMove)) {
-        var cannotMove = core.floors[floorId].cannotMove[x+","+y];
-        if (core.isset(cannotMove) && cannotMove instanceof Array && cannotMove.indexOf(direction)>=0)
-            return false;
-    }
+maps.prototype._canMoveHero_checkPoint = function (x, y, direction, floorId, extraData) {
+    // 1. 检查该点 cannotMove
+    if (core.inArray((core.floors[floorId].cannotMove || {})[x + "," + y], direction))
+        return false;
 
-    var nowBlock = core.getBlock(x,y,floorId);
-    if (nowBlock!=null){
-        nowId = nowBlock.block.event.id;
-        var nowIsArrow = nowId.slice(0, 5).toLowerCase() == 'arrow';
-        if(nowIsArrow){
-            var nowArrow = nowId.slice(5).toLowerCase();
-            if (direction != nowArrow) {
-                return false;
-            }
-        }
-    }
-    var scan = {
-        'up': {'x': 0, 'y': -1},
-        'left': {'x': -1, 'y': 0},
-        'down': {'x': 0, 'y': 1},
-        'right': {'x': 1, 'y': 0}
-    };
-    var nx = x+scan[direction].x, ny = y+scan[direction].y;
-    var nextBlock = core.getBlock(nx,ny);
-    if (nextBlock!=null){
-        nextId = nextBlock.block.event.id;
-        // 遇到单向箭头处理
-        var isArrow = nextId.slice(0, 5).toLowerCase() == 'arrow';
-        if(isArrow){
-            var nextArrow = nextId.slice(5).toLowerCase();
-            if ( (scan[direction].x + scan[nextArrow].x) == 0 && (scan[direction].y + scan[nextArrow].y) == 0 ) {
-                return false;
-            }
-        }
-    }
+    var nx = x + core.utils.scan[direction].x, ny = y + core.utils.scan[direction].y;
+    if (nx < 0 || ny < 0 || nx >= core.floors[floorId].width || ny >= core.floors[floorId].height)
+        return false;
 
-    // 检查将死的领域
-    if (floorId==core.status.floorId && core.status.hero.hp <= core.status.checkBlock.damage[nx+core.bigmap.width*ny]
-        && !core.flags.canGoDeadZone && core.getBlock(nx, ny)==null)
+    // 2. 检查该点素材的 cannotOut 和下一个点的 cannotIn
+    if (this._canMoveHero_checkCannotInOut([
+            extraData.bgArray[y][x], extraData.fgArray[y][x], extraData.eventArray[y][x]
+        ], "cannotOut", direction))
+        return false;
+    if (this._canMoveHero_checkCannotInOut([
+            extraData.bgArray[ny][nx], extraData.fgArray[ny][nx], extraData.eventArray[ny][nx]
+        ], "cannotIn", direction))
+        return false;
+
+    // 3. 检查是否能进将死的领域
+    if (floorId == core.status.floorId
+        && core.status.hero.hp <= (core.status.checkBlock.damage[nx + "," + ny]||0)
+        && !core.flags.canGoDeadZone && extraData.eventArray[ny][nx] == 0)
         return false;
 
     return true;
 }
 
+maps.prototype._canMoveHero_checkCannotInOut = function (number, name, direction) {
+    if (number instanceof Array) {
+        for (var x in number) {
+            if (this._canMoveHero_checkCannotInOut(number[x], name, direction))
+                return true;
+        }
+        return false;
+    }
+    return core.inArray((this.initBlock(0, 0, number).event || {})[name], direction);
+}
+
 ////// 能否瞬间移动 //////
-maps.prototype.canMoveDirectly = function (destX,destY) {
-
-    // 不可瞬间移动请返回0
-    if (!core.flags.enableMoveDirectly) return -1;
-
-    // 中毒状态：不能
-    if (core.hasFlag('poison')) return -1;
+maps.prototype.canMoveDirectly = function (destX, destY) {
+    if (!this._canMoveDirectly_checkGlobal()) return -1;
 
     var fromX = core.getHeroLoc('x'), fromY = core.getHeroLoc('y');
-    if (fromX==destX&&fromY==destY) return 0;
+    if (fromX == destX && fromY == destY) return 0;
+    // 检查起点事件
+    if (!this._canMoveDirectly_checkStartPoint(fromX, fromY)) return -1;
 
-    // 可以无视起点事件
-    var nowBlockId = core.getBlockId(fromX, fromY);
-    if ((nowBlockId!=null&&nowBlockId!='upFloor'&&nowBlockId!='downFloor')
-        ||core.status.checkBlock.damage[fromX+core.bigmap.width*fromY]>0)
-        return -1;
+    return this._canMoveDirectly_bfs(fromX, fromY, destX, destY);
+}
 
-    // BFS
-    var visited=[], queue=[];
-    visited[fromX+core.bigmap.width*fromY]=0;
-    queue.push(fromX+core.bigmap.width*fromY);
+maps.prototype._canMoveDirectly_checkGlobal = function () {
+    // 检查全塔是否禁止瞬间移动
+    if (!core.flags.enableMoveDirectly) return false;
+    // 检查该楼层是否不可瞬间移动
+    if (core.status.thisMap.cannotMoveDirectly) return false;
+    // flag:cannotMoveDirectly为true：不能
+    if (core.hasFlag('cannotMoveDirectly')) return false;
+    // 中毒状态：不能
+    if (core.hasFlag('poison')) return false;
 
-    var directions = [[-1,0],[1,0],[0,1],[0,-1]];
-    while (queue.length>0) {
-        var now=queue.shift(), nowX=parseInt(now%core.bigmap.width), nowY=parseInt(now/core.bigmap.width);
+    return true;
+}
 
-        for (var dir in directions) {
-            var nx=nowX+directions[dir][0], ny=nowY+directions[dir][1];
-            if (nx<0||nx>=core.bigmap.width||ny<0||ny>=core.bigmap.height||visited[nx+core.bigmap.width*ny]||core.getBlock(nx,ny)!=null||core.status.checkBlock.damage[nx+core.bigmap.width*ny]>0) continue;
-            visited[nx+core.bigmap.width*ny]=visited[nowX+core.bigmap.width*nowY]+1;
-            if (nx==destX&&ny==destY) return visited[nx+core.bigmap.width*ny];
-            queue.push(nx+core.bigmap.width*ny);
+maps.prototype._canMoveDirectly_checkStartPoint = function (sx, sy) {
+    if (core.status.checkBlock.damage[sx + "," + sy]) return false;
+    var block = core.getBlock(sx, sy);
+    if (block != null) {
+        // 只有起点是传送点才是能无视
+        return block.block.event.trigger == 'changeFloor';
+    }
+    return true;
+}
+
+maps.prototype._canMoveDirectly_bfs = function (sx, sy, ex, ey) {
+    var canMoveArray = this.generateMovableArray();
+    var blocksObj = this.getMapBlocksObj(core.status.floorId);
+    // 滑冰
+    var bgMap = this.getBgMapArray();
+
+    var visited = [], queue = [];
+    visited[sx + "," + sy] = 0;
+    queue.push(sx + "," + sy);
+
+    while (queue.length > 0) {
+        var now = queue.shift().split(","), x = parseInt(now[0]), y = parseInt(now[1]);
+        for (var direction in core.utils.scan) {
+            if (!core.inArray(canMoveArray[x][y], direction)) continue;
+            var nx = x + core.utils.scan[direction].x, ny = y + core.utils.scan[direction].y, nindex = nx + "," + ny;
+            if (visited[nindex]) continue;
+            if (bgMap[ny][nx] == 167) continue;
+            if (!this._canMoveDirectly_checkNextPoint(blocksObj, nx, ny)) continue;
+            visited[nindex] = visited[now] + 1;
+            if (nx == ex && ny == ey) return visited[nindex];
+            queue.push(nindex);
         }
     }
+
     return -1;
 }
 
-maps.prototype.drawBlock = function (block, animate, dx, dy) {
-    var cls = block.event.cls, height = block.event.height || 32;
-    var blockIcon = core.material.icons[cls][block.event.id];
-    var blockImage = core.material.images[cls];
-    animate=(animate||0)%(block.event.animate||1);
-    dx = dx || 0;
-    dy = dy || 0;
-    core.canvas.event.clearRect(block.x * 32 + dx, block.y * 32 + dy, 32, 32);
-    core.canvas.event.drawImage(blockImage, animate * 32, blockIcon * height + height-32, 32, 32, block.x * 32 + dx, block.y * 32 + dy, 32, 32);
-    if (height>32) {
-        core.canvas.event2.clearRect(block.x * 32 + dx, block.y * 32 + 32 - height + dy, 32, height-32)
-        core.canvas.event2.drawImage(blockImage, animate * 32, blockIcon * height, 32, height-32, block.x * 32 + dx, block.y*32 + 32 - height + dy, 32, height-32);
+maps.prototype._canMoveDirectly_checkNextPoint = function (blocksObj, x, y) {
+    var index = x + "," + y;
+    // 该点是否有事件
+    if (blocksObj[index]) return false;
+    // 是否存在阻激夹域伤害
+    if (core.status.checkBlock.damage[x + "," + y]) return false;
+    // 是否存在捕捉
+    if (core.status.checkBlock.ambush[x + "," + y]) return false;
+
+    return true;
+}
+
+////// 自动寻路找寻最优路径 //////
+maps.prototype.automaticRoute = function (destX, destY) {
+    var startX = core.getHeroLoc('x'), startY = core.getHeroLoc('y');
+    if (destX == startX && destY == startY) return [];
+    // BFS找寻最短路径
+    var route = this._automaticRoute_bfs(startX, startY, destX, destY);
+    if (route[destX+","+destY] == null) return [];
+    // 路径数组转换
+    var ans = [], nowX = destX, nowY = destY;
+    while (nowX != startX || nowY != startY) {
+        var dir = route[nowX + "," + nowY];
+        ans.push({'direction': dir, 'x': nowX, 'y': nowY});
+        nowX -= core.utils.scan[dir].x;
+        nowY -= core.utils.scan[dir].y;
     }
+    ans.reverse();
+    return ans;
+}
+
+maps.prototype._automaticRoute_bfs = function (startX, startY, destX, destY) {
+    var route = {}, canMoveArray = this.generateMovableArray();
+    // 使用优先队列
+    var queue = new PriorityQueue({comparator: function (a,b) { return a.depth - b.depth; }});
+    route[startX + "," + startY] = '';
+    queue.queue({depth: 0, x: startX, y: startY});
+    while (queue.length!=0) {
+        var curr = queue.dequeue(), deep = curr.depth, nowX = curr.x, nowY = curr.y;
+        for (var direction in core.utils.scan) {
+            if (!core.inArray(canMoveArray[nowX][nowY], direction)) continue;
+            var nx = nowX + core.utils.scan[direction].x;
+            var ny = nowY + core.utils.scan[direction].y;
+            if (nx<0 || nx>=core.bigmap.width || ny<0 || ny>=core.bigmap.height || route[nx+","+ny] != null) continue;
+            // 重点
+            if (nx == destX && ny == destY) {
+                route[nx+","+ny] = direction;
+                break;
+            }
+            // 不可通行
+            if (core.noPass(nx, ny)) continue;
+            route[nx+","+ny] = direction;
+            queue.queue({depth: deep + this._automaticRoute_deepAdd(nx, ny), x: nx, y: ny});
+        }
+        if (route[destX+","+destY] != null) break;
+    }
+    return route;
+}
+
+maps.prototype._automaticRoute_deepAdd = function (x, y) {
+    // 判定每个可通行点的损耗值，越高越应该绕路
+    var deepAdd = 1;
+    var block = core.getBlock(x,y);
+    if (block != null){
+        var id = block.block.event.id;
+        // 绕过亮灯
+        if (id == "light") deepAdd += 100;
+        // 绕过路障
+        if (id.endsWith("Net")) deepAdd += 100;
+        // 绕过血瓶
+        if (!core.flags.potionWhileRouting && id.endsWith("Potion")) deepAdd += 100;
+        // 绕过传送点
+        // if (block.block.event.trigger == 'changeFloor') deepAdd+=10;
+    }
+    // 绕过存在伤害的地方
+    deepAdd += (core.status.checkBlock.damage[x+","+y]||0) * 100;
+    // 绕过捕捉
+    if (core.status.checkBlock.ambush[x+","+y]) deepAdd += 1000;
+    return deepAdd;
+}
+
+// -------- 绘制地图，各层图块，楼层贴图，Autotile -------- //
+
+////// 绘制一个图块 //////
+maps.prototype.drawBlock = function (block, animate) {
+    if (block.event.id == 'none') return;
+    var redraw = animate != null;
+    if (!redraw) animate = 0;
+    var x = block.x, y = block.y;
+    // --- 在界面外的动画不绘制
+    if (redraw && block.event.animate > 1 &&
+        (32 * x < core.bigmap.offsetX - 64 || 32 * x > core.bigmap.offsetX + core.__PIXELS__ + 32
+            || 32 * y < core.bigmap.offsetY - 64 || 32 * y > core.bigmap.offsetY + core.__PIXELS__ + 32 + 16)) {
+        return;
+    }
+
+    var blockInfo = this.getBlockInfo(block);
+    if (blockInfo == null) return;
+    if (blockInfo.cls != 'tileset') blockInfo.posX = animate % block.event.animate;
+    if (!block.name)
+        this._drawBlockInfo(blockInfo, block.x, block.y);
+    else
+        this._drawBlockInfo_bgfg(blockInfo, block.name, block.x, block.y);
+}
+
+maps.prototype._drawBlockInfo = function (blockInfo, x, y) {
+    var image = blockInfo.image, posX = blockInfo.posX, posY = blockInfo.posY, height = blockInfo.height;
+
+    core.clearMap('event', x * 32, y * 32, 32, 32);
+    core.drawImage('event', image, posX * 32, posY * height + height - 32, 32, 32, x * 32, y * 32, 32, 32);
+    if (height > 32) {
+        core.clearMap('event2', x * 32, y * 32 + 32 - height, 32, height - 32)
+        core.drawImage('event2', image, posX * 32, posY * height, 32, height - 32, x * 32, y * 32 + 32 - height, 32, height - 32);
+    }
+}
+
+maps.prototype._drawBlockInfo_bgfg = function (blockInfo, name, x, y) {
+    var image = blockInfo.image, posX = blockInfo.posX, posY = blockInfo.posY, height = blockInfo.height;
+
+    core.clearMap(name, x * 32, y * 32 + 32 - height, 32, height);
+    if (name == 'bg') {
+        if (height > 32) {
+            core.clearMap('bg', x * 32, y * 32 - 32, 32, 32);
+            core.drawImage('bg', core.material.groundCanvas.canvas, x * 32, y * 32 - 32);
+        }
+        core.drawImage('bg', core.material.groundCanvas.canvas, x * 32, y * 32);
+    }
+    core.drawImage(name, image, posX * 32, posY * height, 32, height, x * 32, y * 32 + 32 - height, 32, height);
+}
+
+////// 生成groundPattern //////
+maps.prototype.generateGroundPattern = function (floorId) {
+    // 生成floorId层的groundPattern（盒子内的怪物动画）
+    var groundId = ((core.status.maps || core.floors)[floorId || core.status.floorId] || {}).defaultGround || "ground";
+    core.material.groundCanvas.clearRect(0, 0, 32, 32);
+    core.material.groundCanvas.drawImage(core.material.images.terrains, 0, 32 * core.material.icons.terrains[groundId], 32, 32, 0, 0, 32, 32);
+    core.material.groundPattern = core.material.groundCanvas.createPattern(core.material.groundCanvas.canvas, 'repeat');
+    // 如果需要用纯色可以直接将下面代码改成改成
+    // core.material.groundPattern = '#000000';
 }
 
 ////// 绘制某张地图 //////
-maps.prototype.drawMap = function (mapName, callback) {
+maps.prototype.drawMap = function (floorId, callback) {
+    floorId = floorId || core.status.floorId;
+    if (!floorId) {
+        if (callback) callback();
+        return;
+    }
     core.clearMap('all');
-    core.removeGlobalAnimate(null, null, true);
-    var drawBg = function(){
-        var groundId = core.floors[mapName].defaultGround || "ground";
-        var blockIcon = core.material.icons.terrains[groundId];
-        var blockImage = core.material.images.terrains;
-        
-        for (var x = 0; x < core.bigmap.width; x++) {
-            for (var y = 0; y < core.bigmap.height; y++) {
-                core.canvas.bg.drawImage(blockImage, 0, blockIcon * 32, 32, 32, x * 32, y * 32, 32, 32);
-            }
-        }
-
-        var images = [];
-        if (core.isset(core.floors[mapName].images)) {
-            images = core.floors[mapName].images;
-            if (typeof images == 'string') {
-                images = [[0, 0, images]];
-            }
-        }
-        images.forEach(function (t) {
-            var dx=parseInt(t[0]), dy=parseInt(t[1]), p=t[2];
-            if (core.isset(dx) && core.isset(dy) && core.isset(core.material.images.images[p])) {
-                var image = core.material.images.images[p];
-                if (!t[3]) {
-                    if (/.*\.gif/i.test(p) && main.mode=='play') {
-                        core.dom.gif.innerHTML = "";
-                        var gif = new Image();
-                        gif.src = core.material.images.images[p].src;
-                        gif.style.position = 'absolute';
-                        gif.style.left = (32*dx*core.domStyle.scale)+"px";
-                        gif.style.top = (32*dy*core.domStyle.scale)+"px";
-                        gif.style.width = core.material.images.images[p].width*core.domStyle.scale+"px";
-                        gif.style.height = core.material.images.images[p].height*core.domStyle.scale+"px";
-                        core.dom.gif.appendChild(gif);
-                    }
-                    else {
-                        core.canvas.bg.drawImage(image, 32*dx, 32*dy, image.width, image.height);
-                    }
-                }
-                else if (t[3]==1)
-                    core.canvas.event2.drawImage(image, 32*dx, 32*dy, image.width, image.height);
-                else if (t[3]==2) {
-                    core.canvas.event2.drawImage(image, 0, 0, image.width, image.height-32,
-                        32*dx, 32*dy, image.width, image.height-32);
-                    core.canvas.bg.drawImage(image, 0, image.height-32, image.width, 32,
-                        32*dx, 32*dy + image.height - 32, image.width, 32);
-                }
-            }
-        })
+    this.generateGroundPattern(floorId);
+    core.status.floorId = floorId;
+    core.status.thisMap = core.status.maps[floorId];
 
+    this._drawMap_drawAll();
+    if (core.status.curtainColor) {
+        core.fillRect('curtain', 0, 0, core.__PIXELS__, core.__PIXELS__,
+            core.arrayToRGBA(core.status.curtainColor));
     }
-    if (main.mode=='editor'){
-        main.editor.drawMapBg = function(){
-            core.clearMap('bg');
-            drawBg();
-        }
-    } else {
-        drawBg();
+    core.drawHero();
+    core.updateStatusBar();
+    if (callback) callback();
+}
+
+maps.prototype._drawMap_drawAll = function (floorId) {
+    floorId = floorId || core.status.floorId;
+    this.drawBg(floorId);
+    this.drawEvents(floorId);
+    this.drawFg(floorId);
+}
+
+maps.prototype._drawMap_drawBlockInfo = function (ctx, block, blockInfo, arr, onMap) {
+    if (blockInfo == null) return;
+    if (blockInfo.cls == 'autotile') { // Autotile单独处理
+        this._drawAutotile(ctx, arr, block, 32, 0, 0);
+        if (onMap) this.addGlobalAnimate(block);
+        return;
     }
+    if (!onMap) {
+        var height = blockInfo.height;
+        core.drawImage(ctx, blockInfo.image, 32 * blockInfo.posX, height * blockInfo.posY, 32, height, 32 * block.x, 32 * block.y + 32 - height, 32, height);
+        return;
+    }
+    this.drawBlock(block);
+    this.addGlobalAnimate(block);
+}
 
-    core.status.floorId = mapName;
-    core.status.thisMap = core.status.maps[mapName];
-    var drawEvent = function(){
-        var mapData = core.status.maps[core.status.floorId];
-        var mapBlocks = mapData.blocks;
+////// 绘制背景层 //////
+maps.prototype.drawBg = function (floorId, ctx) {
+    floorId = floorId || core.status.floorId;
+    var onMap = ctx == null;
+    if (onMap) {
+        ctx = core.canvas.bg;
+        core.clearMap(ctx);
+    }
+    core.maps._drawBg_drawBackground(floorId, ctx);
+    // ------ 调整这两行的顺序来控制是先绘制贴图还是先绘制背景图块；后绘制的覆盖先绘制的。
+    core.maps._drawFloorImages(floorId, ctx, 'bg');
+    core.maps._drawBgFgMap(floorId, ctx, 'bg', onMap);
+}
 
-        var mapArray = core.maps.getMapArray(mapBlocks,core.bigmap.width,core.bigmap.height);
-        for (var b = 0; b < mapBlocks.length; b++) {
-            // 事件启用
-            var block = mapBlocks[b];
-            if (core.isset(block.event) && !block.disable) {
-                if (block.event.cls == 'autotile') {
-                    core.drawAutotile(core.canvas.event, mapArray, block, 32, 0, 0);
-                }
-                else {
-                    if (block.event.id!='none') {
-                        core.drawBlock(block);
-                        core.addGlobalAnimate(block);
-                    }
-                }
+maps.prototype._drawBg_drawBackground = function (floorId, ctx) {
+    var width = core.floors[floorId].width, height = core.floors[floorId].height;
+    var groundId = (core.status.maps || core.floors)[floorId].defaultGround || "ground";
+    var yOffset = core.material.icons.terrains[groundId];
+    if (yOffset != null) {
+        for (var i = 0; i < width; i++) {
+            for (var j = 0; j < height; j++) {
+                ctx.drawImage(core.material.images.terrains, 0, yOffset * 32, 32, 32, i * 32, j * 32, 32, 32);
             }
         }
     }
+}
 
-    if (main.mode=='editor'){
-        main.editor.updateMap = function(){
-            core.removeGlobalAnimate(null, null, true);
-            core.clearMap('bg');
-            core.clearMap('event');
-            core.clearMap('event2');
-            drawBg();
-            drawEvent();
-            core.setGlobalAnimate(core.values.animateSpeed);
-        }
-    } else {
-        drawEvent();
-        core.setGlobalAnimate(core.values.animateSpeed);
-        core.drawHero();
-        core.updateStatusBar();
+////// 绘制事件层 //////
+maps.prototype.drawEvents = function (floorId, blocks, ctx) {
+    floorId = floorId || core.status.floorId;
+    if (!blocks) blocks = core.status.maps[floorId].blocks;
+    var arr = this._getMapArrayFromBlocks(blocks, core.floors[floorId].width, core.floors[floorId].height);
+    var onMap = ctx == null;
+    if (onMap) ctx = core.canvas.event;
+    blocks.filter(function (block) {
+        return block.event && !block.disable;
+    }).forEach(function (block) {
+        core.maps._drawMap_drawBlockInfo(ctx, block, core.maps.getBlockInfo(block), arr, onMap);
+    });
+    if (onMap) core.status.autotileAnimateObjs.map = core.clone(arr);
+}
+
+////// 绘制前景层 //////
+maps.prototype.drawFg = function (floorId, ctx) {
+    floorId = floorId || core.status.floorId;
+    var onMap = ctx == null;
+    if (onMap) ctx = core.canvas.fg;
+    // ------ 调整这两行的顺序来控制是先绘制贴图还是先绘制背景图块；后绘制的覆盖先绘制的。
+    this._drawFloorImages(floorId, ctx, 'fg');
+    this._drawBgFgMap(floorId, ctx, 'fg', onMap);
+}
+
+////// 实际的背景/前景图块的绘制 //////
+maps.prototype._drawBgFgMap = function (floorId, ctx, name, onMap) {
+    floorId = floorId || core.status.floorId;
+    if (!floorId) return;
+    var width = core.floors[floorId].width;
+    var height = core.floors[floorId].height;
+
+    if (!core.status[name + "maps"])
+        core.status[name + "maps"] = {};
+
+    var arr = this._getBgFgMapArray(name, floorId, true);
+    var eventArr = null;
+    if (main.mode == 'editor' && name == 'fg' && onMap) {
+        eventArr = this.getMapArray(floorId);
+    }
+
+    for (var x = 0; x < width; x++) {
+        for (var y = 0; y < height; y++) {
+            var block = this.initBlock(x, y, arr[y][x], true);
+            block.name = name;
+            var blockInfo = this.getBlockInfo(block);
+            if (!blockInfo) continue;
+            // --- 前景虚化
+            var blur = false, alpha;
+            if (eventArr != null && eventArr[y][x] != 0) {
+                blur = true;
+                alpha = ctx.globalAlpha;
+                ctx.globalAlpha = 0.6;
+            }
+            this._drawMap_drawBlockInfo(ctx, block, blockInfo, arr, onMap);
+            if (blur) ctx.globalAlpha = alpha;
+        }
+    }
+    if (onMap)
+        core.status.autotileAnimateObjs[name + "map"] = core.clone(arr);
+}
+
+////// 绘制楼层贴图 //////
+maps.prototype._drawFloorImages = function (floorId, ctx, name, images, currStatus) {
+    floorId = floorId || core.status.floorId;
+    if (!images) images = this._getFloorImages(floorId);
+    var redraw = currStatus != null;
+    if (!redraw) core.status.floorAnimateObjs = core.clone(images);
+    images.forEach(function (t) {
+        if (typeof t == 'string') t = [0, 0, t];
+        var dx = parseInt(t[0]), dy = parseInt(t[1]), imageName = t[2], frame = core.clamp(parseInt(t[4]), 1, 8);
+        imageName = core.getMappedName(imageName);
+        var image = core.material.images.images[imageName];
+        if (redraw && frame == 1) return; // 不重绘
+
+        if (core.isset(dx) && core.isset(dy) && image &&
+            !core.hasFlag("__floorImg__" + floorId + "_" + dx + "_" + dy)) {
+            var width = parseInt(image.width / frame), offsetX = (currStatus || 0) % frame * width;
+            if (/.*\.gif/i.test(imageName) && main.mode == 'play') {
+                if (redraw) return; // 忽略gif
+                this._drawFloorImages_gif(image, dx, dy);
+                return;
+            }
+            core.maps._drawFloorImage(ctx, name, t[3], image, offsetX, width, dx, dy, redraw);
+        }
+    });
+}
+
+maps.prototype._getFloorImages = function (floorId) {
+    floorId = floorId || core.status.floorId;
+    var images = [];
+    if ((core.status.maps || core.floors)[floorId].images) {
+        images = (core.status.maps || core.floors)[floorId].images;
+        if (typeof images == 'string') {
+            images = [[0, 0, images]];
+        }
+    }
+    return images;
+}
+
+maps.prototype._drawFloorImages_gif = function (image, dx, dy) {
+    core.dom.gif.innerHTML = "";
+    var gif = new Image();
+    gif.src = image.src;
+    gif.style.position = 'absolute';
+    gif.style.left = (dx * core.domStyle.scale) + "px";
+    gif.style.top = (dy * core.domStyle.scale) + "px";
+    gif.style.width = image.width * core.domStyle.scale + "px";
+    gif.style.height = image.height * core.domStyle.scale + "px";
+    core.dom.gif.appendChild(gif);
+    return;
+}
+
+maps.prototype._drawFloorImage = function (ctx, name, type, image, offsetX, width, dx, dy, redraw) {
+    var height = image.height;
+    var _draw = function () {
+        if (redraw) core.clearMap(ctx, dx, dy, width, height);
+        core.drawImage(ctx, image, offsetX, 0, width, height, dx, dy, width, height);
+    }
+    if (!type) {
+        if (name != 'bg') return;
+        return _draw();
+    }
+    if (type == 1) {
+        if (name != 'fg') return;
+        return _draw();
+    }
+    if (type == 2) {
+        if (name == 'bg') {
+            if (redraw) core.clearMap(ctx, dx, dy + height - 32, width, 32);
+            core.drawImage('bg', image, offsetX, height - 32, width, 32, dx, dy + height - 32, width, 32);
+        }
+        else if (name == 'fg') {
+            if (redraw) core.clearMap(ctx, dx, dy, width, height - 32);
+            core.drawImage('fg', image, offsetX, 0, width, height - 32, dx, dy, width, height - 32);
+        }
+        return;
     }
-    if (core.isset(callback))
-        callback();
 }
 
 ////// 绘制Autotile //////
-maps.prototype.drawAutotile = function(ctx, mapArr, block, size, left, top){
+maps.prototype._drawAutotile = function (ctx, mapArr, block, size, left, top, status) {
     var indexArrs = [ //16种组合的图块索引数组; // 将autotile分割成48块16*16的小块; 数组索引即对应各个小块
         //                                     +----+----+----+----+----+----+
-        [10,  9,  4, 3 ],  //0   bin:0000      | 1  | 2  | 3  | 4  | 5  | 6  |
-        [10,  9,  4, 13],  //1   bin:0001      +----+----+----+----+----+----+
-        [10,  9, 18, 3 ],  //2   bin:0010      | 7  | 8  | 9  | 10 | 11 | 12 |
-        [10,  9, 16, 15],  //3   bin:0011      +----+----+----+----+----+----+
-        [10, 43,  4, 3 ],  //4   bin:0100      | 13 | 14 | 15 | 16 | 17 | 18 |
-        [10, 31,  4, 25],  //5   bin:0101      +----+----+----+----+----+----+
-        [10,  7,  2, 3 ],  //6   bin:0110      | 19 | 20 | 21 | 22 | 23 | 24 |
-        [10, 31, 16, 5 ],  //7   bin:0111      +----+----+----+----+----+----+
-        [48,  9,  4, 3 ],  //8   bin:1000      | 25 | 26 | 27 | 28 | 29 | 30 |
-        [ 8,  9,  4, 1 ],  //9   bin:1001      +----+----+----+----+----+----+
-        [36,  9, 30, 3 ],  //10  bin:1010      | 31 | 32 | 33 | 34 | 35 | 36 |
-        [36,  9,  6, 15],  //11  bin:1011      +----+----+----+----+----+----+
-        [46, 45,  4, 3 ],  //12  bin:1100      | 37 | 38 | 39 | 40 | 41 | 42 |
-        [46, 11,  4, 25],  //13  bin:1101      +----+----+----+----+----+----+
-        [12, 45, 30, 3 ],  //14  bin:1110      | 43 | 44 | 45 | 46 | 47 | 48 |
+        [10, 9, 4, 3],  //0   bin:0000      | 1  | 2  | 3  | 4  | 5  | 6  |
+        [10, 9, 4, 13],  //1   bin:0001      +----+----+----+----+----+----+
+        [10, 9, 18, 3],  //2   bin:0010      | 7  | 8  | 9  | 10 | 11 | 12 |
+        [10, 9, 16, 15],  //3   bin:0011      +----+----+----+----+----+----+
+        [10, 43, 4, 3],  //4   bin:0100      | 13 | 14 | 15 | 16 | 17 | 18 |
+        [10, 31, 4, 25],  //5   bin:0101      +----+----+----+----+----+----+
+        [10, 7, 2, 3],  //6   bin:0110      | 19 | 20 | 21 | 22 | 23 | 24 |
+        [10, 31, 16, 5],  //7   bin:0111      +----+----+----+----+----+----+
+        [48, 9, 4, 3],  //8   bin:1000      | 25 | 26 | 27 | 28 | 29 | 30 |
+        [8, 9, 4, 1],  //9   bin:1001      +----+----+----+----+----+----+
+        [36, 9, 30, 3],  //10  bin:1010      | 31 | 32 | 33 | 34 | 35 | 36 |
+        [36, 9, 6, 15],  //11  bin:1011      +----+----+----+----+----+----+
+        [46, 45, 4, 3],  //12  bin:1100      | 37 | 38 | 39 | 40 | 41 | 42 |
+        [46, 11, 4, 25],  //13  bin:1101      +----+----+----+----+----+----+
+        [12, 45, 30, 3],  //14  bin:1110      | 43 | 44 | 45 | 46 | 47 | 48 |
         [34, 33, 28, 27]   //15  bin:1111      +----+----+----+----+----+----+
     ];
 
-    var drawBlockByIndex = function(ctx, dx, dy, autotileImg, index, size){ //index为autotile的图块索引1-48
-        var sx = 16*((index-1)%6), sy = 16*(~~((index-1)/6));
-        ctx.drawImage(autotileImg, sx, sy, 16, 16, dx, dy, size/2, size/2);
-    }
-    var getAutotileAroundId = function(currId, x, y) {
-        if(x<0 || y<0 || x>=mapArr[0].length || y>=mapArr.length) return 1;
-        else return mapArr[y][x]==currId ? 1:0;
-    }
-    var checkAround = function(x, y){ // 得到周围四个32*32块（周围每块都包含当前块的1/4，不清楚的话画下图你就明白）的数组索引
-        var currId = mapArr[y][x];
-        var pointBlock = [];
-        for(var i=0; i<4; i++){
-            var bsum = 0;
-            var offsetx = i%2, offsety = ~~(i/2);
-            for(var j=0; j<4; j++){
-                var mx = j%2, my = ~~(j/2);
-                var b = getAutotileAroundId(currId, x+offsetx+mx-1, y+offsety+my-1);
-                bsum += b*(Math.pow(2, 3-j));
-            }
-            pointBlock.push(bsum);
-        }
-        return pointBlock;
-    }
-    var getAutotileIndexs = function(x, y){
-        var indexArr = [];
-        var pointBlocks = checkAround(x, y);
-        for(var i=0; i<4; i++){
-            var arr = indexArrs[pointBlocks[i]]
-            indexArr.push(arr[3-i]);
-        }
-        return indexArr;
-    }
     // 开始绘制autotile
     var x = block.x, y = block.y;
-    var pieceIndexs = getAutotileIndexs(x, y);
+    var pieceIndexs = this._drawAutotile_getAutotileIndexs(x, y, mapArr, indexArrs);
 
     //修正四个边角的固定搭配
-    if(pieceIndexs[0] == 13){
-        if(pieceIndexs[1] == 16) pieceIndexs[1] = 14;
-        if(pieceIndexs[2] == 31) pieceIndexs[2] = 19;
+    if (pieceIndexs[0] == 13) {
+        if (pieceIndexs[1] == 16) pieceIndexs[1] = 14;
+        if (pieceIndexs[2] == 31) pieceIndexs[2] = 19;
     }
-    if(pieceIndexs[1] == 18){
-        if(pieceIndexs[0] == 15) pieceIndexs[0] = 17;
-        if(pieceIndexs[3] == 36) pieceIndexs[3] = 24;
+    if (pieceIndexs[1] == 18) {
+        if (pieceIndexs[0] == 15) pieceIndexs[0] = 17;
+        if (pieceIndexs[3] == 36) pieceIndexs[3] = 24;
     }
-    if(pieceIndexs[2] == 43){
-        if(pieceIndexs[0] == 25) pieceIndexs[0] = 37;
-        if(pieceIndexs[3] == 46) pieceIndexs[3] = 44;
+    if (pieceIndexs[2] == 43) {
+        if (pieceIndexs[0] == 25) pieceIndexs[0] = 37;
+        if (pieceIndexs[3] == 46) pieceIndexs[3] = 44;
     }
-    if(pieceIndexs[3] == 48){
-        if(pieceIndexs[1] == 30) pieceIndexs[1] = 42;
-        if(pieceIndexs[2] == 45) pieceIndexs[2] = 47;
+    if (pieceIndexs[3] == 48) {
+        if (pieceIndexs[1] == 30) pieceIndexs[1] = 42;
+        if (pieceIndexs[2] == 45) pieceIndexs[2] = 47;
     }
-    for(var i=0; i<4; i++){
+    for (var i = 0; i < 4; i++) {
         var index = pieceIndexs[i];
-        var dx = x*size + size/2*(i%2), dy = y*size + size/2*(~~(i/2));
-        drawBlockByIndex(ctx, dx+left, dy+top, core.material.images['autotile'][block.event.id], index, size);
+        var dx = x * size + size / 2 * (i % 2), dy = y * size + size / 2 * (~~(i / 2));
+        this._drawAutotile_drawBlockByIndex(ctx, dx + left, dy + top, core.material.images['autotile'][block.event.id], index, size, status);
     }
 }
 
+maps.prototype._drawAutotile_drawBlockByIndex = function (ctx, dx, dy, autotileImg, index, size, status) {
+    //index为autotile的图块索引1-48
+    var sx = 16 * ((index - 1) % 6), sy = 16 * (~~((index - 1) / 6));
+    status = status || 0;
+    status %= parseInt(autotileImg.width / 96);
+    ctx.drawImage(autotileImg, sx + 96 * status, sy, 16, 16, dx, dy, size / 2, size / 2);
+}
+
+maps.prototype._drawAutotile_getAutotileAroundId = function (currId, x, y, mapArr) {
+    if (x < 0 || y < 0 || x >= mapArr[0].length || y >= mapArr.length) return 1;
+    else return core.material.autotileEdges[currId].indexOf(mapArr[y][x]) >= 0;
+}
+
+maps.prototype._drawAutotile_checkAround = function (x, y, mapArr) {
+    // 得到周围四个32*32块（周围每块都包含当前块的1/4，不清楚的话画下图你就明白）的数组索引
+    var currId = mapArr[y][x];
+    var pointBlock = [];
+    for (var i = 0; i < 4; i++) {
+        var bsum = 0;
+        var offsetx = i % 2, offsety = ~~(i / 2);
+        for (var j = 0; j < 4; j++) {
+            var mx = j % 2, my = ~~(j / 2);
+            var b = this._drawAutotile_getAutotileAroundId(currId, x + offsetx + mx - 1, y + offsety + my - 1, mapArr);
+            bsum += b * (Math.pow(2, 3 - j));
+        }
+        pointBlock.push(bsum);
+    }
+    return pointBlock;
+}
+
+maps.prototype._drawAutotile_getAutotileIndexs = function (x, y, mapArr, indexArrs) {
+    var indexArr = [];
+    var pointBlocks = this._drawAutotile_checkAround(x, y, mapArr);
+    for (var i = 0; i < 4; i++) {
+        var arr = indexArrs[pointBlocks[i]]
+        indexArr.push(arr[3 - i]);
+    }
+    return indexArr;
+}
+
+maps.prototype._drawAutotileAnimate = function (block, animate) {
+    var x = block.x, y = block.y;
+    // ------ 界面外的动画不绘制
+    if (32 * x < core.bigmap.offsetX - 64 || 32 * x > core.bigmap.offsetX + core.__PIXELS__ + 32
+        || 32 * y < core.bigmap.offsetY - 64 || 32 * y > core.bigmap.offsetY + core.__PIXELS__ + 32 + 16) {
+        return;
+    }
+
+    var cv = block.name?core.canvas[block.name]:core.canvas.event;
+    cv.clearRect(32 * x, 32 * y, 32, 32);
+    if (block.name) {
+        if (block.name == 'bg')
+            core.drawImage('bg', core.material.groundCanvas.canvas, 32 * x, 32 * y);
+        this._drawAutotile(cv, core.status.autotileAnimateObjs[block.name+"map"], block, 32, 0, 0, animate);
+    }
+    else {
+        this._drawAutotile(cv, core.status.autotileAnimateObjs.map, block, 32, 0, 0, animate);
+    }
+}
+
+////// 为autotile判定边界 ////// 
+maps.prototype._makeAutotileEdges = function () {
+    var autotileIds = Object.keys(core.material.images.autotile);
+    core.material.autotileEdges = {};
+
+    var canvas = document.createElement("canvas"), ctx = canvas.getContext('2d');
+    canvas.width = canvas.height = 32;
+    ctx.mozImageSmoothingEnabled = false;
+    ctx.webkitImageSmoothingEnabled = false;
+    ctx.msImageSmoothingEnabled = false;
+    ctx.imageSmoothingEnabled = false;
+
+    autotileIds.forEach(function (t) {
+        var n = core.maps.getNumberById(t);
+        core.material.autotileEdges[n] = [n];
+
+        ctx.clearRect(0, 0, 32, 32);
+        ctx.drawImage(core.material.images.autotile[t], 0, 0, 32, 32, 0, 0, 32, 32);
+        var data = canvas.toDataURL("image/png");
+
+        autotileIds.forEach(function (t2) {
+            if (t == t2) return;
+            var n2 = core.maps.getNumberById(t2);
+
+            ctx.clearRect(0, 0, 32, 32);
+            ctx.drawImage(core.material.images.autotile[t2], 32, 0, 32, 32, 0, 0, 32, 32);
+            if (data == canvas.toDataURL("image/png")) {
+                core.material.autotileEdges[n].push(n2);
+            }
+        });
+    });
+}
+
+////// 绘制缩略图 //////
+// 此函数将绘制一个缩略图，floorId为目标floorId，blocks为地图的图块（可为null使用floorId对应默认的）
+// options为绘制选项（可为null），包括：
+//    heroLoc: 勇士位置；heroIcon：勇士图标（默认当前勇士）；damage：是否绘制显伤；flags：当前的flags（存读档时使用）
+// toDraw为要绘制到的信息（可为null，或为一个画布名），包括：
+//    ctx：要绘制到的画布（名）；x,y：起点横纵坐标（默认0）；size：大小（默认416/480）；
+//    all：是否绘制全图（默认false）；centerX,centerY：截取中心（默认为地图正中心）
+maps.prototype.drawThumbnail = function (floorId, blocks, options, toDraw) {
+    floorId = floorId || core.status.floorId;
+    if (!floorId) return;
+    // Step1：绘制到tempCanvas上
+    this._drawThumbnail_drawTempCanvas(floorId, blocks, options);
+    // Step2：从tempCanvas绘制到对应的画布上
+    this._drawThumbnail_drawToTarget(floorId, toDraw);
+}
+
+maps.prototype._drawThumbnail_drawTempCanvas = function (floorId, blocks, options) {
+    blocks = blocks || core.status.maps[floorId].blocks;
+    options = options || {}
+
+    var width = core.floors[floorId].width;
+    var height = core.floors[floorId].height;
+    // 绘制到tempCanvas上面
+    var tempCanvas = core.bigmap.tempCanvas;
+    var tempWidth = width * 32, tempHeight = height * 32;
+    tempCanvas.canvas.width = tempWidth;
+    tempCanvas.canvas.height = tempHeight;
+    tempCanvas.clearRect(0, 0, tempWidth, tempHeight);
+
+    // --- 暂存 flags
+    var hasHero = core.status.hero != null, flags = null;
+    if (options.flags) {
+        if (!hasHero) core.status.hero = {};
+        flags = core.status.hero.flags;
+        core.status.hero.flags = options.flags;
+    }
+
+    this._drawThumbnail_realDrawTempCanvas(floorId, blocks, options, tempCanvas);
+
+    // --- 恢复 flags
+    if (!hasHero) delete core.status.hero;
+    else if (flags != null) core.status.hero.flags = flags;
+}
+
+maps.prototype._drawThumbnail_realDrawTempCanvas = function (floorId, blocks, options, tempCanvas) {
+    // 缩略图：背景
+    this.drawBg(floorId, tempCanvas);
+    // 缩略图：事件
+    this.drawEvents(floorId, blocks, tempCanvas);
+    // 缩略图：勇士
+    if (options.heroLoc) {
+        options.heroIcon = options.heroIcon || core.getFlag("heroIcon", "hero.png");
+        options.heroIcon = core.getMappedName(options.heroIcon);
+        var icon = core.material.icons.hero[options.heroLoc.direction];
+        var height = core.material.images.images[options.heroIcon].height / 4;
+        tempCanvas.drawImage(core.material.images.images[options.heroIcon], icon.stop * 32, icon.loc * height, 32, height,
+            32 * options.heroLoc.x, 32 * options.heroLoc.y + 32 - height, 32, height);
+    }
+    // 缩略图：前景
+    this.drawFg(floorId, tempCanvas);
+    // 缩略图：显伤
+    if (options.damage)
+        core.control.updateDamage(floorId, tempCanvas);
+}
+
+maps.prototype._drawThumbnail_drawToTarget = function (floorId, toDraw) {
+    if (toDraw == null) return;
+    if (typeof toDraw == 'string' || toDraw.canvas) toDraw = {ctx: toDraw};
+    var ctx = core.getContextByName(toDraw.ctx);
+    if (ctx == null) return;
+    var x = toDraw.x || 0, y = toDraw.y || 0, size = toDraw.size || core.__PIXELS__;
+    var width = core.floors[floorId].width, height = core.floors[floorId].height;
+    var centerX = toDraw.centerX, centerY = toDraw.centerY;
+    if (centerX == null) centerX = Math.floor(width / 2);
+    if (centerY == null) centerY = Math.floor(height / 2);
+    var tempCanvas = core.bigmap.tempCanvas, tempWidth = 32 * width, tempHeight = 32 * height;
+
+    core.clearMap(ctx, x, y, size, size);
+    if (toDraw.all) {
+        // 绘制全景图
+        if (tempWidth <= tempHeight) {
+            var realHeight = size, realWidth = realHeight * tempWidth / tempHeight;
+            var side = (size - realWidth) / 2;
+            core.fillRect(ctx, x, y, side, realHeight, '#000000');
+            core.fillRect(ctx, x + size - side, y, side, realHeight);
+            ctx.drawImage(tempCanvas.canvas, 0, 0, tempWidth, tempHeight, x + side, y, realWidth, realHeight);
+        }
+        else {
+            var realWidth = size, realHeight = realWidth * tempHeight / tempWidth;
+            var side = (size - realHeight) / 2;
+            core.fillRect(ctx, x, y, realWidth, side, '#000000');
+            core.fillRect(ctx, x, y + size - side, realWidth, side);
+            ctx.drawImage(tempCanvas.canvas, 0, 0, tempWidth, tempHeight, x, y + side, realWidth, realHeight);
+        }
+    }
+    else {
+        // 只绘制可见窗口
+        var offsetX = core.clamp(centerX - core.__HALF_SIZE__, 0, width - core.__SIZE__),
+            offsetY = core.clamp(centerY - core.__HALF_SIZE__, 0, height - core.__SIZE__);
+        ctx.drawImage(tempCanvas.canvas, offsetX * 32, offsetY * 32, core.__PIXELS__, core.__PIXELS__, x, y, size, size);
+    }
+}
+
+// -------- 获得某个点的图块信息 -------- //
+
 ////// 某个点是否不可通行 //////
-maps.prototype.noPassExists = function (x, y, floorId) {
-    var block = core.getBlock(x,y,floorId);
-    if (block==null) return false;
-    return core.isset(block.block.event.noPass) && block.block.event.noPass;
-}
-
-////// 某个点是否在区域内且不可通行 //////
-maps.prototype.noPass = function (x, y) {
-    return x<0 || x>=core.bigmap.width || y<0 || y>=core.bigmap.height || this.noPassExists(x,y);
+maps.prototype.noPass = function (x, y, floorId) {
+    var block = core.getBlock(x, y, floorId);
+    if (block == null) return false;
+    return block.block.event.noPass;
 }
 
 ////// 某个点是否存在NPC //////
 maps.prototype.npcExists = function (x, y, floorId) {
-    var block = this.getBlock(x,y,floorId);
-    if (block==null) return false;
-    return block.block.event.cls.indexOf('npc')==0;
+    var block = this.getBlock(x, y, floorId);
+    if (block == null) return false;
+    return block.block.event.cls.indexOf('npc') == 0;
 }
 
 ////// 某个点是否存在（指定的）地形 //////
 maps.prototype.terrainExists = function (x, y, id, floorId) {
-    var block = this.getBlock(x,y,floorId);
-    if (block==null) return false;
-    return block.block.event.cls=='terrains' && (core.isset(id)?block.block.event.id==id:true);
+    var block = this.getBlock(x, y, floorId);
+    if (block == null) return false;
+    return block.block.event.cls == 'terrains' && (id ? block.block.event.id == id : true);
 }
 
 ////// 某个点是否存在楼梯 //////
 maps.prototype.stairExists = function (x, y, floorId) {
-    var block = this.getBlock(x,y,floorId);
-    if (block==null) return false;
-    return block.block.event.cls=='terrains' && (block.block.event.id=='upFloor' || block.block.event.id=='downFloor');
+    var block = this.getBlock(x, y, floorId);
+    if (block == null) return false;
+    return block.block.event.cls == 'terrains' && (block.block.event.id == 'upFloor' || block.block.event.id == 'downFloor');
 }
 
 ////// 当前位置是否在楼梯边 //////
-maps.prototype.nearStair = function() {
-    var x=core.getHeroLoc('x'), y=core.getHeroLoc('y');
-    return this.stairExists(x,y) || this.stairExists(x-1,y) || this.stairExists(x,y-1) || this.stairExists(x+1,y) || this.stairExists(x,y+1);
+maps.prototype.nearStair = function () {
+    var x = core.getHeroLoc('x'), y = core.getHeroLoc('y');
+    return this.stairExists(x, y) || this.stairExists(x - 1, y) || this.stairExists(x, y - 1) || this.stairExists(x + 1, y) || this.stairExists(x, y + 1);
 }
 
 ////// 某个点是否存在（指定的）怪物 //////
-maps.prototype.enemyExists = function (x, y, id,floorId) {
-    var block = this.getBlock(x,y,floorId);
-    if (block==null) return false;
-    return block.block.event.cls.indexOf('enemy')==0 && (core.isset(id)?block.block.event.id==id:true);
+maps.prototype.enemyExists = function (x, y, id, floorId) {
+    var block = this.getBlock(x, y, floorId);
+    if (block == null) return false;
+    return block.block.event.cls.indexOf('enemy') == 0 && (id ? block.block.event.id == id : true);
 }
 
 ////// 获得某个点的block //////
 maps.prototype.getBlock = function (x, y, floorId, showDisable) {
-    if (!core.isset(floorId)) floorId=core.status.floorId;
+    floorId = floorId || core.status.floorId;
+    if (!floorId) return null;
     var blocks = core.status.maps[floorId].blocks;
-    for (var n=0;n<blocks.length;n++) {
-        if (blocks[n].x==x && blocks[n].y==y && core.isset(blocks[n].event)) {
+    for (var n = 0; n < blocks.length; n++) {
+        if (blocks[n].x == x && blocks[n].y == y) {
             if (!showDisable && blocks[n].disable) return null;
             return {"index": n, "block": blocks[n]};
         }
@@ -587,306 +1198,132 @@ maps.prototype.getBlock = function (x, y, floorId, showDisable) {
 ////// 获得某个点的blockId //////
 maps.prototype.getBlockId = function (x, y, floorId, showDisable) {
     var block = core.getBlock(x, y, floorId, showDisable);
-    if (block == null) return null;
-    if (core.isset(block.block.event)) return block.block.event.id;
-    return null;
+    return block == null ? null : block.block.event.id;
 }
 
 ////// 获得某个点的blockCls //////
 maps.prototype.getBlockCls = function (x, y, floorId, showDisable) {
     var block = core.getBlock(x, y, floorId, showDisable);
-    if (block == null) return null;
-    if (core.isset(block.block.event)) return block.block.event.cls;
-    return null;
+    return block == null ? null : block.block.event.cls;
 }
 
-////// 显示移动某块的动画，达到{“type”:”move”}的效果 //////
-maps.prototype.moveBlock = function(x,y,steps,time,keep,callback) {
-    time = time || 500;
-
-    core.clearMap('route');
-
-    var block = core.getBlock(x,y);
-    if (block==null) {// 不存在
-        if (core.isset(callback)) callback();
-        return;
+////// 获得某个图块或素材的信息，包括 ID，cls，图片，坐标，faceIds 等等 //////
+maps.prototype.getBlockInfo = function (block) {
+    if (!block) return null;
+    if (typeof block == 'string') { // 参数是ID
+        block = this.getNumberById(block);
     }
-    var id = block.block.id;
+    if (typeof block == 'number') { // 参数是数字
+        if (block == 0) return null;
+        block = this.initBlock(0, 0, block, true);
+    }
+    var number = block.id, id = block.event.id, cls = block.event.cls,
+        image = null, posX = 0, posY = 0, animate = block.event.animate,
+        height = block.event.height || 32, faceIds = {};
 
-    core.status.replay.animate=true;
+    if (id == 'none') return null;
+    else if (id == 'airwall') {
+        if (!core.material.images.airwall) return null;
+        image = core.material.images.airwall;
+    }
+    else if (cls == 'tileset') {
+        var offset = core.icons.getTilesetOffset(id);
+        if (offset == null) return null;
+        posX = offset.x;
+        posY = offset.y;
+        image = core.material.images.tilesets[offset.image];
+    }
+    else if (cls == 'autotile') {
+        image = core.material.images.autotile[id];
+    }
+    else {
+        image = core.material.images[cls];
+        posY = core.material.icons[cls][id];
+        faceIds = block.event.faceIds || {};
+    }
 
-    // 需要删除该块
-    core.removeBlock(x,y);
-
-    core.clearMap('ui');
-    core.setAlpha('ui', 1.0);
-
-    block=block.block;
-    var blockIcon = core.material.icons[block.event.cls][block.event.id];
-    var blockImage = core.material.images[block.event.cls];
-    var height = block.event.height || 32;
-
-    var opacityVal = 1;
-    core.setOpacity('route', opacityVal);
-    core.canvas.route.drawImage(blockImage, 0, blockIcon * height, 32, height, block.x * 32, block.y * 32 +32 - height, 32, height);
-
-    // 要运行的轨迹：将steps展开
-    var moveSteps=[];
-    steps.forEach(function (e) {
-        if (typeof e=="string") {
-            moveSteps.push(e);
-        }
-        else {
-            if (!core.isset(e.value)) {
-                moveSteps.push(e.direction)
-            }
-            else {
-                for (var i=0;i<e.value;i++) {
-                    moveSteps.push(e.direction);
-                }
-            }
-        }
-    });
-
-    var nowX=32*x, nowY=32*y, step=0;
-    var scan = {
-        'up': {'x': 0, 'y': -1},
-        'left': {'x': -1, 'y': 0},
-        'down': {'x': 0, 'y': 1},
-        'right': {'x': 1, 'y': 0}
-    };
-
-    var animateValue = block.event.animate || 1;
-    var animateCurrent = 0;
-    var animateTime = 0;
-
-    var animate=window.setInterval(function() {
-
-        animateTime += time / 16 / core.status.replay.speed;
-        if (animateTime >= core.values.animateSpeed) {
-            animateCurrent++;
-            animateTime = 0;
-            if (animateCurrent>=animateValue) animateCurrent=0;
-        }
-
-        // 已经移动完毕，消失
-        if (moveSteps.length==0) {
-            if (keep) opacityVal=0;
-            else opacityVal -= 0.06;
-            core.setOpacity('route', opacityVal);
-            core.clearMap('route', nowX, nowY-height+32, 32, height);
-            core.canvas.route.drawImage(blockImage, animateCurrent * 32, blockIcon * height, 32, height, nowX, nowY-height+32, 32, height);
-            if (opacityVal<=0) {
-                clearInterval(animate);
-                core.clearMap('route');
-                core.setOpacity('route', 1);
-                // 不消失
-                if (keep) {
-                    core.setBlock(id, nowX/32, nowY/32);
-                    core.showBlock(nowX/32, nowY/32);
-                }
-                core.status.replay.animate=false;
-                if (core.isset(callback)) callback();
-            }
-        }
-        else {
-            // 移动中
-            step++;
-            nowX+=scan[moveSteps[0]].x*2;
-            nowY+=scan[moveSteps[0]].y*2;
-            core.clearMap('route', nowX-32, nowY-32, 96, 96);
-            // 绘制
-            core.canvas.route.drawImage(blockImage, animateCurrent * 32, blockIcon * height, 32, height, nowX, nowY-height+32, 32, height);
-            if (step==16) {
-                // 该移动完毕，继续
-                step=0;
-                moveSteps.shift();
-            }
-        }
-    }, time / 16 / core.status.replay.speed);
+    return {number: number, id: id, cls: cls, image: image, posX: posX, posY: posY, height: height, faceIds: faceIds, animate: animate};
 }
 
-////// 显示跳跃某块的动画，达到{"type":"jump"}的效果 //////
-maps.prototype.jumpBlock = function(sx,sy,ex,ey,time,keep,callback) {
-    time = time || 500;
-    core.clearMap('route');
-    var block = core.getBlock(sx,sy);
-    if (block==null) {
-        if (core.isset(callback)) callback();
-        return;
+////// 搜索某个图块出现的所有位置 //////
+maps.prototype.searchBlock = function (id, floorId, showDisable) {
+    if (typeof id == 'number') id = this.initBlock(0, 0, id).event.id;
+    floorId = floorId || core.status.floorId;
+    var result = [];
+    if (floorId instanceof Array) {
+        floorId.forEach(function (floorId) {
+            result = result.concat(core.searchBlock(id, floorId, showDisable));
+        });
+        return result;
     }
-    var id = block.block.id;
-
-    core.status.replay.animate=true;
-
-    // 需要删除该块
-    core.removeBlock(sx,sy);
-    core.clearMap('ui');
-    core.setAlpha('ui', 1.0);
-
-    block=block.block;
-    var blockIcon = core.material.icons[block.event.cls][block.event.id];
-    var blockImage = core.material.images[block.event.cls];
-    var height = block.event.height || 32;
-
-    var opacityVal = 1;
-    core.setOpacity('route', opacityVal);
-    core.canvas.route.drawImage(blockImage, 0, blockIcon * height, 32, height, block.x * 32, block.y * 32 +32 - height, 32, height);
-
-    core.playSound('jump.mp3');
-
-    var dx = ex-sx, dy=ey-sy, distance = Math.round(Math.sqrt(dx * dx + dy * dy));
-    var jump_peak = 6 + distance, jump_count = jump_peak * 2;
-    var currx = sx, curry = sy;
-
-    var drawX = function() {
-        return currx * 32;
+    for (var i = 0; i < core.status.maps[floorId].blocks.length; ++i) {
+        var block = core.status.maps[floorId].blocks[i];
+        if ((showDisable || !block.disable) && core.matchWildcard(id, block.event.id)) {
+            result.push({floorId: floorId, index: i, block: block, x: block.x, y: block.y});
+        }
     }
-
-    var drawY = function() {
-        var ret = curry * 32;
-        if(jump_count >= jump_peak){
-            var n = jump_count - jump_peak;
-        }else{
-            var n = jump_peak - jump_count;
-        }
-        return ret - (jump_peak * jump_peak - n * n) / 2;
-    }
-
-    var updateJump = function() {
-        jump_count--;
-        currx = (currx * jump_count + ex) / (jump_count + 1.0);
-        curry = (curry * jump_count + ey) / (jump_count + 1.0);
-    }
-
-    var animateValue = block.event.animate || 1;
-    var animateCurrent = 0;
-    var animateTime = 0;
-    var animate=window.setInterval(function() {
-
-        animateTime += time / 16 / core.status.replay.speed;
-        if (animateTime >= core.values.animateSpeed) {
-            animateCurrent++;
-            animateTime = 0;
-            if (animateCurrent >= animateValue) animateCurrent = 0;
-        }
-
-        if (jump_count>0) {
-            core.clearMap('route', drawX(), drawY()-height+32, 32, height);
-            updateJump();
-            core.canvas.route.drawImage(blockImage, animateCurrent * 32, blockIcon * height, 32, height, drawX(), drawY()-height+32, 32, height);
-        }
-        else {
-            if (keep) opacityVal=0;
-            else opacityVal -= 0.06;
-            core.setOpacity('route', opacityVal);
-            core.clearMap('route', drawX(), drawY()-height+32, 32, height);
-            core.canvas.route.drawImage(blockImage, animateCurrent * 32, blockIcon * height, 32, height, drawX(), drawY()-height+32, 32, height);
-            if (opacityVal<=0) {
-                clearInterval(animate);
-                core.clearMap('route');
-                core.setOpacity('route', 1);
-                if (keep) {
-                    core.setBlock(id, ex, ey);
-                    core.showBlock(ex, ey);
-                }
-                core.status.replay.animate=false;
-                if (core.isset(callback)) callback();
-            }
-        }
-
-    }, time / 16 / core.status.replay.speed);
+    return result;
 }
 
-////// 显示/隐藏某个块时的动画效果 //////
-maps.prototype.animateBlock = function (loc,type,time,callback) {
-    if (type!='hide') type='show';
-
-    core.clearMap('route');
-
-    if (typeof loc[0] == 'number' && typeof loc[1] == 'number')
-        loc = [loc];
-
-    var list = [];
-    loc.forEach(function (t) {
-        var block = core.getBlock(t[0],t[1],null,true);
-        if (block==null) return;
-        block=block.block;
-        list.push({
-            'x': t[0], 'y': t[1], 'height': block.event.height||32,
-            'blockIcon': core.material.icons[block.event.cls][block.event.id],
-            'blockImage': core.material.images[block.event.cls]
-        })
-    })
-
-    if (list.length==0) {
-        if (core.isset(callback)) callback();
-        return;
-    }
-
-    core.status.replay.animate=true;
-    var draw = function () {
-        list.forEach(function (t) {
-            core.canvas.route.drawImage(t.blockImage, 0, t.blockIcon*t.height, 32, t.height, t.x*32, t.y*32+32-t.height, 32, t.height);
-        })
-    }
-
-    var opacityVal = 0;
-    if (type=='hide') opacityVal=1;
-
-    core.setOpacity('route', opacityVal);
-    draw();
-
-    var animate = window.setInterval(function () {
-        if (type=='show') opacityVal += 0.1;
-        else opacityVal -= 0.1;
-        core.setOpacity('route', opacityVal);
-        if (opacityVal >=1 || opacityVal<=0) {
-            clearInterval(animate);
-            core.clearMap('route');
-            core.setOpacity('route', 1);
-            core.status.replay.animate=false;
-            if (core.isset(callback)) callback();
-        }
-    }, time / 10 / core.status.replay.speed);
-}
+// -------- 启用/禁用图块，楼层贴图 -------- //
 
 ////// 将某个块从禁用变成启用状态 //////
-maps.prototype.showBlock = function(x, y, floodId) {
-    floodId = floodId || core.status.floorId;
-    var block = core.getBlock(x,y,floodId,true);
-    if (block==null) return; // 不存在
-    block=block.block;
+maps.prototype.showBlock = function (x, y, floorId) {
+    floorId = floorId || core.status.floorId;
+    if (!floorId) return;
+    var block = core.getBlock(x, y, floorId, true);
+    if (block == null) return; // 不存在
+    block = block.block;
     // 本身是禁用事件，启用之
     if (block.disable) {
         block.disable = false;
         // 在本层，添加动画
-        if (floodId == core.status.floorId && core.isset(block.event)) {
+        if (floorId == core.status.floorId) {
             core.drawBlock(block);
             core.addGlobalAnimate(block);
-            core.syncGlobalAnimate();
         }
         core.updateStatusBar();
     }
 }
 
+////// 只隐藏但不删除某块 //////
+maps.prototype.hideBlock = function (x, y, floorId) {
+    floorId = floorId || core.status.floorId;
+    if (!floorId) return;
+
+    var block = core.getBlock(x, y, floorId, true);
+    if (block == null) return; // 不存在
+
+    // 删除动画，清除地图
+    if (floorId == core.status.floorId) {
+        core.removeGlobalAnimate(x, y);
+        core.clearMap('event', x * 32, y * 32, 32, 32);
+        var height = block.block.event.height || 32;
+        if (height > 32)
+            core.clearMap('event2', x * 32, y * 32 + 32 - height, 32, height - 32);
+    }
+
+    block.block.disable = true;
+    core.updateStatusBar();
+}
+
 ////// 将某个块从启用变成禁用状态 //////
 maps.prototype.removeBlock = function (x, y, floorId) {
     floorId = floorId || core.status.floorId;
+    if (!floorId) return;
 
-    var block = core.getBlock(x,y,floorId,true);
-    if (block==null) return; // 不存在
+    var block = core.getBlock(x, y, floorId, true);
+    if (block == null) return; // 不存在
 
-    var index=block.index;
+    var index = block.index;
 
     // 删除动画，清除地图
-    if (floorId==core.status.floorId) {
+    if (floorId == core.status.floorId) {
         core.removeGlobalAnimate(x, y);
-        core.canvas.event.clearRect(x * 32, y * 32, 32, 32);
-        var height = 32;
-        if (core.isset(block.block.event)) height=block.block.event.height||32;
-        if (height>32)
-            core.canvas.event2.clearRect(x * 32, y * 32 +32-height, 32, height-32);
+        core.clearMap('event', x * 32, y * 32, 32, 32);
+        var height = block.block.event.height || 32;
+        if (height > 32)
+            core.clearMap('event2', x * 32, y * 32 + 32 - height, 32, height - 32);
     }
 
     // 删除Index
@@ -894,199 +1331,647 @@ maps.prototype.removeBlock = function (x, y, floorId) {
     core.updateStatusBar();
 }
 
-////// 根据block的索引删除该块 //////
+////// 根据block的索引（尽可能）删除该块 //////
 maps.prototype.removeBlockById = function (index, floorId) {
+    floorId = floorId || core.status.floorId;
+    if (!floorId) return;
 
     var blocks = core.status.maps[floorId].blocks, block = blocks[index];
-    var x=block.x, y=block.y;
 
-    // 检查该点是否存在事件
-    var event = core.floors[floorId].events[x+","+y];
-    if (!core.isset(event))
-        event = core.floors[floorId].changeFloor[x+","+y];
-
-    // 检查是否存在重生
-    var isReborn = false;
-    if (core.isset(block.event) && block.event.cls.indexOf('enemy')==0
-        && core.enemys.hasSpecial(core.material.enemys[block.event.id].special, 23))
-        isReborn = true;
-
-    // 不存在事件，直接删除
-    if (!isReborn && !core.isset(event)) {
-        blocks.splice(index,1);
-        return;
+    if (this.canRemoveBlock(block, floorId)) { // 能否彻底删除该图块
+        blocks.splice(index, 1);
+    }
+    else {
+        block.disable = true;
     }
-    block.disable = true;
 }
 
 ////// 一次性删除多个block //////
 maps.prototype.removeBlockByIds = function (floorId, ids) {
-    ids.sort(function (a,b) {return b-a}).forEach(function (id) {
+    floorId = floorId || core.status.floorId;
+    if (!floorId) return;
+    ids.sort(function (a, b) {
+        return b - a
+    }).forEach(function (id) {
         core.removeBlockById(id, floorId);
     });
 }
 
+////// 能否彻底从地图中删除一个图块 //////
+maps.prototype.canRemoveBlock = function (block, floorId) {
+    var x = block.x, y = block.y;
+    // 检查该点是否存在事件
+    if (core.floors[floorId].events[x + "," + y] || core.floors[floorId].changeFloor[x + "," + y])
+        return false;
+    // 检查是否存在重生
+    if (block.event && block.event.cls.indexOf('enemy') == 0 && core.hasSpecial(block.event.id, 23))
+        return false;
+
+    return true;
+}
+
+////// 显示前景/背景地图 //////
+maps.prototype.showBgFgMap = function (name, loc, floorId, callback) {
+    this._triggerBgFgMap('show', name, loc, floorId, callback);
+}
+
+////// 隐藏前景/背景地图 //////
+maps.prototype.hideBgFgMap = function (name, loc, floorId, callback) {
+    this._triggerBgFgMap('hide', name, loc, floorId, callback);
+}
+
+////// 设置前景/背景地图的显示状态 //////
+maps.prototype._triggerBgFgMap = function (type, name, loc, floorId, callback) {
+    if (type != 'show') type = 'hide';
+    if (name != 'fg') name = 'bg';
+    if (typeof loc[0] == 'number' && typeof loc[1] == 'number')
+        loc = [loc];
+    floorId = floorId || core.status.floorId;
+    if (!floorId) return;
+
+    if (loc.length == 0) return;
+    loc.forEach(function (t) {
+        var x = t[0], y = t[1];
+        var flag = "__" + name + "Map__" + floorId + "_" + x + "_" + y;
+        if (type == 'hide') core.setFlag(flag, true);
+        else core.removeFlag(flag);
+    })
+    core.status[name + "maps"][floorId] = null;
+
+    if (floorId == core.status.floorId) {
+        core.drawMap(floorId, callback);
+    }
+    else {
+        if (callback) callback();
+    }
+}
+
+////// 显示一个楼层贴图 //////
+maps.prototype.showFloorImage = function (loc, floorId, callback) {
+    this._triggerFloorImage('show', loc, floorId, callback);
+}
+
+////// 隐藏一个楼层贴图 //////
+maps.prototype.hideFloorImage = function (loc, floorId, callback) {
+    this._triggerFloorImage('hide', loc, floorId, callback);
+}
+
+///// 设置贴图显示状态 //////
+maps.prototype._triggerFloorImage = function (type, loc, floorId, callback) {
+    if (type != 'show') type = 'hide';
+    if (typeof loc[0] == 'number' && typeof loc[1] == 'number')
+        loc = [loc];
+    floorId = floorId || core.status.floorId;
+    if (!floorId) return;
+
+    if (loc.length == 0) return;
+    loc.forEach(function (t) {
+        var x = t[0], y = t[1];
+        var flag = "__floorImg__" + floorId + "_" + x + "_" + y;
+        if (type == 'hide') core.setFlag(flag, true);
+        else core.removeFlag(flag);
+    })
+
+    if (floorId == core.status.floorId) {
+        core.drawMap(floorId, callback);
+    }
+    else {
+        if (callback) callback();
+    }
+}
+
 ////// 改变图块 //////
 maps.prototype.setBlock = function (number, x, y, floorId) {
     floorId = floorId || core.status.floorId;
-    if (!core.isset(number) || !core.isset(x) || !core.isset(y)) return;
-    if (x<0 || x>=core.bigmap.width || y<0 || y>=core.bigmap.height) return;
+    if (!floorId || number == null || x == null || y == null) return;
+    if (x < 0 || x >= core.floors[floorId].width || y < 0 || y >= core.floors[floorId].height) return;
+    if (typeof number == 'string') {
+        if (/^\d+$/.test(number)) number = parseInt(number);
+        else number = core.getNumberById(number);
+    }
 
-    var originBlock=core.getBlock(x,y,floorId,true);
-    var block = core.maps.initBlock(x,y,number);
-    core.maps.addInfo(block);
-    core.maps.addEvent(block,x,y,core.floors[floorId].events[x+","+y]);
-    core.maps.addChangeFloor(block,x,y,core.floors[floorId].changeFloor[x+","+y]);
-    if (core.isset(block.event)) {
-        if (originBlock==null) {
-            core.status.maps[floorId].blocks.push(block);
-        }
-        else {
-            originBlock.block.id = number;
-            originBlock.block.event = block.event;
-        }
-        if (floorId==core.status.floorId) {
-            core.drawMap(floorId);
+    var block = this.initBlock(x, y, number, true, core.floors[floorId]);
+    if (block.id == 0 && !block.event.trigger) {
+        // 转变图块为0且该点无事件，视为隐藏
+        core.removeBlock(x, y, floorId);
+        return;
+    }
+    var originBlock = core.getBlock(x, y, floorId, true);
+    if (floorId == core.status.floorId) {
+        core.removeGlobalAnimate(x, y);
+        core.clearMap('event', x * 32, y * 32, 32, 32);
+        if (originBlock != null) {
+            var height = (originBlock.block.event || {}).height || 32;
+            if (height > 32)
+                core.clearMap('event2', x * 32, y * 32 + 32 - height, 32, height - 32);
         }
     }
+    if (originBlock == null) {
+        core.status.maps[floorId].blocks.push(block);
+    }
+    else {
+        originBlock.block.id = number;
+        originBlock.block.event = block.event;
+        block = originBlock.block;
+    }
+    if (floorId == core.status.floorId && !block.disable) {
+        core.drawBlock(block);
+        core.addGlobalAnimate(block);
+        core.updateStatusBar();
+    }
 }
 
+////// 将地图中所有某个图块替换成另一个图块 //////
+maps.prototype.replaceBlock = function (fromNumber, toNumber, floorId) {
+    floorId = floorId || core.status.floorId;
+    if (floorId instanceof Array) {
+        floorId.forEach(function (floorId) {
+            core.replaceBlock(fromNumber, toNumber, floorId);
+        });
+        return;
+    }
+    var toBlock = this.initBlock(0, 0, toNumber, true);
+    core.status.maps[floorId].blocks.forEach(function (block) {
+        if (block.id == fromNumber) {
+            block.id = toNumber;
+            for (var one in toBlock.event) {
+                block.event[one] = core.clone(toBlock.event[one]);
+            }
+        }
+    });
+}
+
+////// 改变前景背景的图块 //////
+maps.prototype.setBgFgBlock = function (name, number, x, y, floorId) {
+    floorId = floorId || core.status.floorId;
+    if (!floorId || number == null || x == null || y == null) return;
+    if (x < 0 || x >= core.floors[floorId].width || y < 0 || y >= core.floors[floorId].height) return;
+    if (name != 'bg' && name != 'fg') return;
+    if (typeof number == 'string') {
+        if (/^\d+$/.test(number)) number = parseInt(number);
+        else number = core.getNumberById(number);
+    }
+
+    var vFlag = "__" + name + "Value__" + floorId + "_" + x + "_" + y;
+    core.setFlag(vFlag, number);
+    core.status[name + "maps"][floorId] = null;
+
+    if (floorId == core.status.floorId)
+        core.drawMap(floorId);
+}
+
+////// 重置地图 //////
+maps.prototype.resetMap = function (floorId) {
+    floorId = floorId || core.status.floorId;
+    if (!floorId) return;
+    if (typeof floorId == 'string') floorId = [floorId];
+    var needRefresh = false;
+    floorId.forEach(function (t) {
+        core.status.maps[t] = core.maps.loadFloor(t);
+        if (t == core.status.floorId) needRefresh = true;
+    });
+    if (needRefresh) this.drawMap();
+    core.drawTip("地图重置成功");
+}
+
+// -------- 移动/跳跃图块，图块的淡入淡出 -------- //
+
+////// 初始化独立的block canvas //////
+maps.prototype._initDetachedBlock = function (blockInfo, x, y, displayDamage) {
+    var headCanvas = null, bodyCanvas = '__body_' + x + "_" + y, damageCanvas = null;
+    // head
+    if (blockInfo.height > 32) {
+        headCanvas = "__head_" + x + "_" + y;
+        core.createCanvas(headCanvas, 0, 0, 32, blockInfo.height - 32, 55);
+    }
+    // body
+    core.createCanvas(bodyCanvas, 0, 0, 32, 32, 35);
+    // damage
+    var damage = null, damageColor = null;
+    if (blockInfo.cls.indexOf('enemy') == 0 && core.hasItem('book') && displayDamage) {
+        var damageString = core.enemys.getDamageString(blockInfo.id, x, y);
+        damage = damageString.damage;
+        damageColor = damageString.color;
+    }
+    if (damage != null) {
+        damageCanvas = "__damage_" + x + "_" + y;
+        var ctx = core.createCanvas(damageCanvas, 0, 0, 32, 32, 65);
+        ctx.textAlign = 'left';
+        ctx.font = "bold 11px Arial";
+        core.fillBoldText(ctx, damage, 1, 31, damageColor);
+        if (core.flags.displayCritical) {
+            var critical = core.enemys.nextCriticals(blockInfo.id);
+            if (critical.length > 0) critical = critical[0];
+            critical = core.formatBigNumber(critical[0], true);
+            if (critical == '???') critical = '?';
+            core.fillBoldText(ctx, critical, 1, 21, '#FFFFFF');
+        }
+    }
+    return {
+        "headCanvas": headCanvas,
+        "bodyCanvas": bodyCanvas,
+        "damageCanvas": damageCanvas
+    }
+}
+
+////// 移动独立的block canvas //////
+maps.prototype._moveDetachedBlock = function (blockInfo, nowX, nowY, opacity, canvases) {
+    var height = blockInfo.height, posX = blockInfo.posX, posY = blockInfo.posY, image = blockInfo.image;
+    var headCanvas = canvases.headCanvas, bodyCanvas = canvases.bodyCanvas, damageCanvas = canvases.damageCanvas;
+    if (headCanvas) {
+        core.dymCanvas[headCanvas].clearRect(0, 0, 32, height);
+        core.dymCanvas[headCanvas].drawImage(image, posX * 32, posY * height, 32, height - 32, 0, 0, 32, height - 32);
+        core.relocateCanvas(headCanvas, nowX - core.bigmap.offsetX, nowY + 32 - height - core.bigmap.offsetY);
+        core.setOpacity(headCanvas, opacity);
+    }
+    if (bodyCanvas) {
+        core.dymCanvas[bodyCanvas].clearRect(0, 0, 32, 32);
+        core.dymCanvas[bodyCanvas].drawImage(image, posX * 32, posY * height + height - 32, 32, 32, 0, 0, 32, 32);
+        core.relocateCanvas(bodyCanvas, nowX - core.bigmap.offsetX, nowY - core.bigmap.offsetY);
+        core.setOpacity(bodyCanvas, opacity);
+    }
+    if (damageCanvas) {
+        core.relocateCanvas(damageCanvas, nowX - core.bigmap.offsetX, nowY - core.bigmap.offsetY);
+        core.setOpacity(damageCanvas, opacity);
+    }
+}
+
+////// 删除独立的block canvas //////
+maps.prototype._deleteDetachedBlock = function (canvases) {
+    core.deleteCanvas(canvases.headCanvas);
+    core.deleteCanvas(canvases.bodyCanvas);
+    core.deleteCanvas(canvases.damageCanvas);
+}
+
+maps.prototype._getAndRemoveBlock = function (x, y) {
+    var block = core.getBlock(x, y);
+    if (block == null) return null;
+    block = block.block;
+    var blockInfo = this.getBlockInfo(block);
+    if (blockInfo == null) return;
+    core.removeBlock(x, y);
+    return [block, blockInfo];
+}
+
+////// 显示移动某块的动画，达到{“type”:”move”}的效果 //////
+maps.prototype.moveBlock = function (x, y, steps, time, keep, callback) {
+    time = time || 500;
+    var blockArr = this._getAndRemoveBlock(x, y);
+    if (blockArr == null) {
+        if (callback) callback();
+        return;
+    }
+    var block = blockArr[0], blockInfo = blockArr[1];
+    var moveSteps = (steps||[]).filter(function (t) {
+        return ['up','down','left','right','forward','backward'].indexOf(t)>=0;
+    });
+    var canvases = this._initDetachedBlock(blockInfo, x, y, block.event.animate !== false);
+    this._moveDetachedBlock(blockInfo, 32 * x, 32 * y, 1, canvases);
+
+    var moveInfo = {
+        x: x, y: y, px: 32 * x, py: 32 * y, opacity: 1, keep: keep, lastDirection: null, offset: 1,
+        moveSteps: moveSteps, step: 0, per_time: time / 16 / core.status.replay.speed
+    }
+    this._moveBlock_doMove(blockInfo, canvases, moveInfo, callback);
+}
+
+maps.prototype._moveBlock_doMove = function (blockInfo, canvases, moveInfo, callback) {
+    var animateTotal = core.icons._getAnimateFrames(blockInfo.cls, true), animateTime = 0;
+    var animate = window.setInterval(function () {
+        if (blockInfo.cls != 'tileset') {
+            animateTime += moveInfo.per_time;
+            if (animateTime > core.values.animateSpeed) {
+                animateTime = 0;
+                blockInfo.posX = (blockInfo.posX + 1) % animateTotal;
+            }
+        }
+        if (moveInfo.moveSteps.length != 0)
+            core.maps._moveBlock_moving(blockInfo, canvases, moveInfo);
+        else
+            core.maps._moveJumpBlock_finished(blockInfo, canvases, moveInfo, animate, callback);
+    }, moveInfo.per_time);
+
+    core.animateFrame.asyncId[animate] = true;
+}
+
+maps.prototype._moveBlock_updateDirection = function (blockInfo, moveInfo) {
+    moveInfo.offset = 1;
+    var direction = moveInfo.moveSteps[0];
+    if (moveInfo.lastDirection == null) {
+        for (var d in blockInfo.faceIds) {
+            if (blockInfo.faceIds[d] == blockInfo.id) {
+                moveInfo.lastDirection = d;
+                break;
+            }
+        }
+    }
+    if (direction == 'forward' || direction == 'backward') {
+        if (moveInfo.lastDirection == null) {
+            moveInfo.moveSteps.shift();
+            return false;
+        }
+        if (direction == 'backward')
+            moveInfo.offset = -1;
+        direction = moveInfo.lastDirection;
+    }
+    moveInfo.lastDirection = moveInfo.moveSteps[0] = direction;
+    moveInfo.x += core.utils.scan[direction].x * moveInfo.offset;
+    moveInfo.y += core.utils.scan[direction].y * moveInfo.offset;
+    // 根据faceIds修改朝向
+    var currid = blockInfo.faceIds[direction];
+    if (currid) {
+        var posY = core.material.icons[blockInfo.cls][currid];
+        if (posY != null) blockInfo.posY = posY;
+    }
+    return true;
+}
+
+maps.prototype._moveBlock_moving = function (blockInfo, canvases, moveInfo) {
+    if (moveInfo.step == 0) {
+        if (!this._moveBlock_updateDirection(blockInfo, moveInfo)) return;
+    }
+    var direction = moveInfo.moveSteps[0];
+    moveInfo.step++;
+    moveInfo.px += core.utils.scan[direction].x * 2 * moveInfo.offset;
+    moveInfo.py += core.utils.scan[direction].y * 2 * moveInfo.offset;
+    this._moveDetachedBlock(blockInfo, moveInfo.px, moveInfo.py, moveInfo.opacity, canvases);
+    if (moveInfo.step == 16) {
+        moveInfo.step = 0;
+        moveInfo.moveSteps.shift();
+    }
+}
+
+////// 显示跳跃某块的动画，达到{"type":"jump"}的效果 //////
+maps.prototype.jumpBlock = function (sx, sy, ex, ey, time, keep, callback) {
+    time = time || 500;
+    var blockArr = this._getAndRemoveBlock(sx, sy);
+    if (blockArr == null) {
+        if (callback) callback();
+        return;
+    }
+    var block = blockArr[0], blockInfo = blockArr[1];
+    var canvases = this._initDetachedBlock(blockInfo, sx, sy, block.event.animate !== false);
+    this._moveDetachedBlock(blockInfo, 32 * sx, 32 * sy, 1, canvases);
+    core.playSound('jump.mp3');
+    var jumpInfo = this.__generateJumpInfo(sx, sy, ex, ey, time);
+    jumpInfo.keep = keep;
+
+    this._jumpBlock_doJump(blockInfo, canvases, jumpInfo, callback);
+}
+
+maps.prototype.__generateJumpInfo = function (sx, sy, ex, ey, time) {
+    var dx = ex - sx, dy = ey - sy, distance = Math.round(Math.sqrt(dx * dx + dy * dy));
+    var jump_peak = 6 + distance, jump_count = jump_peak * 2;
+    time /= Math.max(core.status.replay.speed, 1)
+    return {
+        x: sx, y: sy, ex: ex, ey: ey, px: 32 * sx, py: 32 * sy, opacity: 1,
+        jump_peak: jump_peak, jump_count: jump_count,
+        step: 0, per_time: time / jump_count
+    };
+}
+
+maps.prototype._jumpBlock_doJump = function (blockInfo, canvases, jumpInfo, callback) {
+    var animate = window.setInterval(function () {
+        if (jumpInfo.jump_count > 0)
+            core.maps._jumpBlock_jumping(blockInfo, canvases, jumpInfo)
+        else
+            core.maps._moveJumpBlock_finished(blockInfo, canvases, jumpInfo, animate, callback);
+    }, jumpInfo.per_time);
+
+    core.animateFrame.asyncId[animate] = true;
+}
+
+maps.prototype.__updateJumpInfo = function (jumpInfo) {
+    jumpInfo.jump_count--;
+    jumpInfo.x = (jumpInfo.x * jumpInfo.jump_count + jumpInfo.ex) / (jumpInfo.jump_count + 1.0);
+    jumpInfo.y = (jumpInfo.y * jumpInfo.jump_count + jumpInfo.ey) / (jumpInfo.jump_count + 1.0);
+    jumpInfo.px = 32 * jumpInfo.x;
+    var delta = Math.abs(jumpInfo.jump_count - jumpInfo.jump_peak);
+    jumpInfo.py = 32 * jumpInfo.y - (jumpInfo.jump_peak * jumpInfo.jump_peak - delta * delta) / 2;
+}
+
+maps.prototype._jumpBlock_jumping = function (blockInfo, canvases, jumpInfo) {
+    this.__updateJumpInfo(jumpInfo);
+    core.maps._moveDetachedBlock(blockInfo, jumpInfo.px, jumpInfo.py, jumpInfo.opacity, canvases);
+}
+
+maps.prototype._moveJumpBlock_finished = function (blockInfo, canvases, info, animate, callback) {
+    if (info.keep) info.opacity = 0;
+    else info.opacity -= 0.06;
+    if (info.opacity <= 0) {
+        delete core.animateFrame.asyncId[animate];
+        clearInterval(animate);
+        this._deleteDetachedBlock(canvases);
+        // 不消失
+        if (info.keep) {
+            core.setBlock(blockInfo.number, info.x, info.y);
+            core.showBlock(info.x, info.y);
+        }
+        if (callback) callback();
+    }
+    else {
+        this._moveDetachedBlock(blockInfo, info.px, info.py, info.opacity, canvases);
+    }
+}
+
+////// 显示/隐藏某个块时的动画效果 //////
+maps.prototype.animateBlock = function (loc, type, time, callback) {
+    var isHide = type == 'hide';
+    if (typeof loc[0] == 'number' && typeof loc[1] == 'number')
+        loc = [loc];
+    // --- 检测所有是0的点
+    var list = this._animateBlock_getList(loc);
+    if (list.length == 0) {
+        if (callback) callback();
+        return;
+    }
+    this._animateBlock_drawList(list, isHide ? 1 : 0);
+    time /= Math.max(core.status.replay.speed, 1)
+    this._animateBlock_doAnimate(loc, list, isHide, 10 / time, callback);
+}
+
+maps.prototype._animateBlock_doAnimate = function (loc, list, isHide, delta, callback) {
+    var opacity = isHide ? 1 : 0;
+    var animate = setInterval(function () {
+        opacity += isHide ? -delta : delta;
+        core.maps._animateBlock_drawList(list, opacity);
+        if (opacity >= 1 || opacity <= 0) {
+            delete core.animateFrame.asyncId[animate];
+            clearInterval(animate);
+            list.forEach(function (t) {
+                if (t.blockInfo)
+                    core.maps._deleteDetachedBlock(t.canvases);
+            });
+            loc.forEach(function (t) {
+                if (isHide) core.removeBlock(t[0], t[1]);
+                else core.showBlock(t[0], t[1]);
+            });
+            if (callback) callback();
+        }
+    }, 10);
+
+    core.animateFrame.asyncId[animate] = true;
+}
+
+maps.prototype._animateBlock_getList = function (loc) {
+    var list = [];
+    loc.forEach(function (t) {
+        var block = core.getBlock(t[0], t[1], null, true);
+        if (block == null) return;
+        block = block.block;
+
+        var blockInfo = core.maps.getBlockInfo(block);
+        if (blockInfo == null) {
+            list.push({ 'x': t[0], 'y': t[1] });
+            return;
+        }
+        var canvases = core.maps._initDetachedBlock(blockInfo, t[0], t[1], block.event.displayDamage !== false);
+
+        list.push({
+            'x': t[0], 'y': t[1], 'blockInfo': blockInfo, 'canvases': canvases
+        });
+
+    });
+    return list;
+}
+
+maps.prototype._animateBlock_drawList = function (list, opacity) {
+    list.forEach(function (t) {
+        if (t.blockInfo)
+            core.maps._moveDetachedBlock(t.blockInfo, t.x * 32, t.y * 32, opacity, t.canvases);
+    });
+}
+
+// ------ 全局动画控制，动画绘制 ------ //
+
 ////// 添加一个全局动画 //////
-maps.prototype.addGlobalAnimate = function (b) {
-    if (main.mode=='editor' && main.editor.disableGlobalAnimate) return;
-    if (!core.isset(b.event) || !core.isset(b.event.animate) || b.event.animate==1) return;
-
-    var block = core.clone(b);
-    block.status = 0;
-
-    core.status.globalAnimateObjs.push(block);
-
+maps.prototype.addGlobalAnimate = function (block) {
+    if (!block.event || block.event.animate == null) return;
+    if (block.event.cls == 'autotile') {
+        var id = block.event.id, img = core.material.images.autotile[id];
+        if (!img || img.width == 96) return;
+        core.status.autotileAnimateObjs.blocks.push(block);
+    }
+    else {
+        if (!block.event.animate || block.event.animate == 1) return;
+        core.status.globalAnimateObjs.push(block);
+    }
 }
 
 ////// 删除一个或所有全局动画 //////
-maps.prototype.removeGlobalAnimate = function (x, y, all) {
-    if (main.mode=='editor' && main.editor.disableGlobalAnimate) return;
-
-    if (all) {
+maps.prototype.removeGlobalAnimate = function (x, y, name) {
+    // 没有定义xy，则全部删除
+    if (x == null || y == null) {
+        core.status.globalAnimateStatus = 0;
         core.status.globalAnimateObjs = [];
+        core.status.autotileAnimateObjs = {"blocks": [], "map": null, "bgmap": null, "fgmap": null};
+        core.status.floorAnimateObjs = [];
         return;
     }
 
-    for (var t = 0; t < core.status.globalAnimateObjs.length; t++) {
-        if (core.status.globalAnimateObjs[t].x == x && core.status.globalAnimateObjs[t].y == y) {
-            core.status.globalAnimateObjs.splice(t, 1);
-            return;
-        }
+    core.status.globalAnimateObjs = core.status.globalAnimateObjs.filter(function (block) {
+        return block.x != x || block.y != y || block.name != name;
+    });
+
+    // 检查Autotile
+    if (core.status.autotileAnimateObjs.blocks) {
+        core.status.autotileAnimateObjs.blocks = core.status.autotileAnimateObjs.blocks.filter(function (block) {
+            return block.x != x || block.y != y || block.name != name;
+        });
+        core.status.autotileAnimateObjs.map[y][x] = 0;
     }
-}
 
-////// 设置全局动画的显示效果 //////
-maps.prototype.setGlobalAnimate = function (speed) {
-    if (main.mode=='editor' && main.editor.disableGlobalAnimate) return;
-    core.syncGlobalAnimate();
-    core.animateFrame.speed = speed;
-    core.animateFrame.globalAnimate = true;
-}
-
-////// 同步所有的全局动画效果 //////
-maps.prototype.syncGlobalAnimate = function () {
-    core.status.globalAnimateObjs.forEach(function (t) {
-        t.status=0;
-    })
 }
 
 ////// 绘制UI层的box动画 //////
 maps.prototype.drawBoxAnimate = function () {
-    for (var a = 0; a < core.status.boxAnimateObjs.length; a++) {
-        var obj = core.status.boxAnimateObjs[a];
-        obj.status = ((obj.status||0)+1)%obj.animate;
+    core.status.boxAnimateObjs.forEach(function (obj) {
         core.clearMap('ui', obj.bgx, obj.bgy, obj.bgWidth, obj.bgHeight);
-        core.fillRect('ui', obj.bgx, obj.bgy, obj.bgWidth, obj.bgHeight, core.animateFrame.background);
-        core.canvas.ui.drawImage(obj.image, obj.status * 32, obj.pos,
+        core.fillRect('ui', obj.bgx, obj.bgy, obj.bgWidth, obj.bgHeight, core.material.groundPattern);
+        core.drawImage('ui', obj.image, core.status.globalAnimateStatus % obj.animate * 32, obj.pos,
             32, obj.height, obj.x, obj.y, 32, obj.height);
-    }
+    });
 }
 
 ////// 绘制动画 //////
 maps.prototype.drawAnimate = function (name, x, y, callback) {
+    name = core.getMappedName(name);
 
     // 正在播放录像：不显示动画
-    if (core.isset(core.status.replay) && core.status.replay.replaying) {
-        if (core.isset(callback)) callback();
-        return;
+    if (core.isReplaying()) {
+        if (callback) callback();
+        return -1;
     }
 
     // 检测动画是否存在
-    if (!core.isset(core.material.animates[name]) || !core.isset(x) || !core.isset(y)) {
-        if (core.isset(callback)) callback();
-        return;
+    if (!core.material.animates[name] || x == null || y == null) {
+        if (callback) callback();
+        return -1;
     }
 
-    // 清空animate层
-    clearInterval(core.interval.animateInterval);
-    core.clearMap('animate');
-
     // 开始绘制
-    var animate = core.material.animates[name];
-    var ratio = animate.ratio;
-    var centerX = 32*x+16, centerY = 32*y+16;
-    var index=0;
-
+    var animate = core.material.animates[name], centerX = 32 * x + 16, centerY = 32 * y + 16;
     // 播放音效
     core.playSound(animate.se);
 
-    var draw = function (index) {
-        core.clearMap('animate');
+    var id = setTimeout(null);
+    core.status.animateObjs.push({
+        "id": id,
+        "animate": animate,
+        "centerX": centerX,
+        "centerY": centerY,
+        "index": 0,
+        "callback": callback
+    });
 
-        var frame = animate.frames[index];
-        frame.forEach(function (t) {
-            var image = animate.images[t.index];
-            if (!core.isset(image)) return;
-            var realWidth = image.width * ratio * t.zoom / 100;
-            var realHeight = image.height * ratio * t.zoom / 100;
-            core.setAlpha('animate', t.opacity / 255);
-
-            var cx = centerX+t.x, cy=centerY+t.y;
-
-            if (!t.mirror && !t.angle) {
-                core.canvas.animate.drawImage(image, cx-realWidth/2 - core.bigmap.offsetX, cy-realHeight/2 - core.bigmap.offsetY, realWidth, realHeight);
-            }
-            else {
-                core.saveCanvas('animate');
-                core.canvas.animate.translate(cx,cy);
-                if (t.angle)
-                    core.canvas.animate.rotate(-t.angle*Math.PI/180);
-                if (t.mirror)
-                    core.canvas.animate.scale(-1,1);
-                core.canvas.animate.drawImage(image, -realWidth/2 - core.bigmap.offsetX, -realHeight/2 - core.bigmap.offsetY, realWidth, realHeight);
-                core.loadCanvas('animate');
-            }
-        })
-    }
-
-    draw(index++);
-
-    core.interval.animateInterval = setInterval(function (t) {
-        if (index == animate.frames.length) {
-            clearInterval(core.interval.animateInterval);
-            core.clearMap('animate');
-            core.setAlpha('animate', 1);
-            if (core.isset(callback)) callback();
-            return;
-        }
-        draw(index++);
-    }, 50);
+    return id;
 }
 
-maps.prototype.resetMap = function(floorId) {
-    var floorId = floorId||core.status.floorId;
-    core.status.maps[floorId] = this.loadFloor(floorId);
-    if (floorId==core.status.floorId) {
-        this.drawMap(floorId, function () {
-            core.drawTip("地图重置成功");
-        })
+////// 绘制动画的某一帧 //////
+maps.prototype._drawAnimateFrame = function (animate, centerX, centerY, index) {
+    var frame = animate.frames[index];
+    var ratio = animate.ratio;
+    frame.forEach(function (t) {
+        var image = animate.images[t.index];
+        if (!image) return;
+        var realWidth = image.width * ratio * t.zoom / 100;
+        var realHeight = image.height * ratio * t.zoom / 100;
+        core.setAlpha('animate', t.opacity / 255);
+
+        var cx = centerX + t.x, cy = centerY + t.y;
+
+        if (!t.mirror && !t.angle) {
+            core.drawImage('animate', image, cx - realWidth / 2 - core.bigmap.offsetX, cy - realHeight / 2 - core.bigmap.offsetY, realWidth, realHeight);
+        }
+        else {
+            core.saveCanvas('animate');
+            core.canvas.animate.translate(cx, cy);
+            if (t.angle)
+                core.canvas.animate.rotate(-t.angle * Math.PI / 180);
+            if (t.mirror)
+                core.canvas.animate.scale(-1, 1);
+            core.drawImage('animate', image, -realWidth / 2 - core.bigmap.offsetX, -realHeight / 2 - core.bigmap.offsetY, realWidth, realHeight);
+            core.loadCanvas('animate');
+        }
+        core.setAlpha('animate', 1);
+    })
+}
+
+////// 停止动画 //////
+maps.prototype.stopAnimate = function (id, doCallback) {
+    for (var i = 0; i < core.status.animateObjs.length; i++) {
+        var obj = core.status.animateObjs[i];
+        if (obj.id == id) {
+            if (doCallback) {
+                (function (callback) {
+                    setTimeout(function () {
+                        if (callback) callback();
+                    });
+                })(obj.callback);
+            }
+        }
     }
-    else {
-        core.drawTip(floorId+"地图重置成功");
-    }
-}
\ No newline at end of file
+    core.status.animateObjs = core.status.animateObjs.filter(function (x) { return x.id != id });
+    if (core.status.animateObjs.length == 0)
+        core.clearMap('animate');
+}
diff --git a/libs/thirdparty/localforage.min.js b/libs/thirdparty/localforage.min.js
new file mode 100644
index 00000000..46db4bfd
--- /dev/null
+++ b/libs/thirdparty/localforage.min.js
@@ -0,0 +1,7 @@
+/*!
+    localForage -- Offline Storage, Improved
+    Version 1.7.2
+    https://localforage.github.io/localForage
+    (c) 2013-2017 Mozilla, Apache License 2.0
+*/
+!function(a){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=a();else if("function"==typeof define&&define.amd)define([],a);else{var b;b="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this,b.localforage=a()}}(function(){return function a(b,c,d){function e(g,h){if(!c[g]){if(!b[g]){var i="function"==typeof require&&require;if(!h&&i)return i(g,!0);if(f)return f(g,!0);var j=new Error("Cannot find module '"+g+"'");throw j.code="MODULE_NOT_FOUND",j}var k=c[g]={exports:{}};b[g][0].call(k.exports,function(a){var c=b[g][1][a];return e(c||a)},k,k.exports,a,b,c,d)}return c[g].exports}for(var f="function"==typeof require&&require,g=0;g<d.length;g++)e(d[g]);return e}({1:[function(a,b,c){(function(a){"use strict";function c(){k=!0;for(var a,b,c=l.length;c;){for(b=l,l=[],a=-1;++a<c;)b[a]();c=l.length}k=!1}function d(a){1!==l.push(a)||k||e()}var e,f=a.MutationObserver||a.WebKitMutationObserver;if(f){var g=0,h=new f(c),i=a.document.createTextNode("");h.observe(i,{characterData:!0}),e=function(){i.data=g=++g%2}}else if(a.setImmediate||void 0===a.MessageChannel)e="document"in a&&"onreadystatechange"in a.document.createElement("script")?function(){var b=a.document.createElement("script");b.onreadystatechange=function(){c(),b.onreadystatechange=null,b.parentNode.removeChild(b),b=null},a.document.documentElement.appendChild(b)}:function(){setTimeout(c,0)};else{var j=new a.MessageChannel;j.port1.onmessage=c,e=function(){j.port2.postMessage(0)}}var k,l=[];b.exports=d}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],2:[function(a,b,c){"use strict";function d(){}function e(a){if("function"!=typeof a)throw new TypeError("resolver must be a function");this.state=s,this.queue=[],this.outcome=void 0,a!==d&&i(this,a)}function f(a,b,c){this.promise=a,"function"==typeof b&&(this.onFulfilled=b,this.callFulfilled=this.otherCallFulfilled),"function"==typeof c&&(this.onRejected=c,this.callRejected=this.otherCallRejected)}function g(a,b,c){o(function(){var d;try{d=b(c)}catch(b){return p.reject(a,b)}d===a?p.reject(a,new TypeError("Cannot resolve promise with itself")):p.resolve(a,d)})}function h(a){var b=a&&a.then;if(a&&("object"==typeof a||"function"==typeof a)&&"function"==typeof b)return function(){b.apply(a,arguments)}}function i(a,b){function c(b){f||(f=!0,p.reject(a,b))}function d(b){f||(f=!0,p.resolve(a,b))}function e(){b(d,c)}var f=!1,g=j(e);"error"===g.status&&c(g.value)}function j(a,b){var c={};try{c.value=a(b),c.status="success"}catch(a){c.status="error",c.value=a}return c}function k(a){return a instanceof this?a:p.resolve(new this(d),a)}function l(a){var b=new this(d);return p.reject(b,a)}function m(a){function b(a,b){function d(a){g[b]=a,++h!==e||f||(f=!0,p.resolve(j,g))}c.resolve(a).then(d,function(a){f||(f=!0,p.reject(j,a))})}var c=this;if("[object Array]"!==Object.prototype.toString.call(a))return this.reject(new TypeError("must be an array"));var e=a.length,f=!1;if(!e)return this.resolve([]);for(var g=new Array(e),h=0,i=-1,j=new this(d);++i<e;)b(a[i],i);return j}function n(a){function b(a){c.resolve(a).then(function(a){f||(f=!0,p.resolve(h,a))},function(a){f||(f=!0,p.reject(h,a))})}var c=this;if("[object Array]"!==Object.prototype.toString.call(a))return this.reject(new TypeError("must be an array"));var e=a.length,f=!1;if(!e)return this.resolve([]);for(var g=-1,h=new this(d);++g<e;)b(a[g]);return h}var o=a(1),p={},q=["REJECTED"],r=["FULFILLED"],s=["PENDING"];b.exports=e,e.prototype.catch=function(a){return this.then(null,a)},e.prototype.then=function(a,b){if("function"!=typeof a&&this.state===r||"function"!=typeof b&&this.state===q)return this;var c=new this.constructor(d);if(this.state!==s){g(c,this.state===r?a:b,this.outcome)}else this.queue.push(new f(c,a,b));return c},f.prototype.callFulfilled=function(a){p.resolve(this.promise,a)},f.prototype.otherCallFulfilled=function(a){g(this.promise,this.onFulfilled,a)},f.prototype.callRejected=function(a){p.reject(this.promise,a)},f.prototype.otherCallRejected=function(a){g(this.promise,this.onRejected,a)},p.resolve=function(a,b){var c=j(h,b);if("error"===c.status)return p.reject(a,c.value);var d=c.value;if(d)i(a,d);else{a.state=r,a.outcome=b;for(var e=-1,f=a.queue.length;++e<f;)a.queue[e].callFulfilled(b)}return a},p.reject=function(a,b){a.state=q,a.outcome=b;for(var c=-1,d=a.queue.length;++c<d;)a.queue[c].callRejected(b);return a},e.resolve=k,e.reject=l,e.all=m,e.race=n},{1:1}],3:[function(a,b,c){(function(b){"use strict";"function"!=typeof b.Promise&&(b.Promise=a(2))}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{2:2}],4:[function(a,b,c){"use strict";function d(a,b){if(!(a instanceof b))throw new TypeError("Cannot call a class as a function")}function e(){try{if("undefined"!=typeof indexedDB)return indexedDB;if("undefined"!=typeof webkitIndexedDB)return webkitIndexedDB;if("undefined"!=typeof mozIndexedDB)return mozIndexedDB;if("undefined"!=typeof OIndexedDB)return OIndexedDB;if("undefined"!=typeof msIndexedDB)return msIndexedDB}catch(a){return}}function f(){try{if(!ua)return!1;var a="undefined"!=typeof openDatabase&&/(Safari|iPhone|iPad|iPod)/.test(navigator.userAgent)&&!/Chrome/.test(navigator.userAgent)&&!/BlackBerry/.test(navigator.platform),b="function"==typeof fetch&&-1!==fetch.toString().indexOf("[native code");return(!a||b)&&"undefined"!=typeof indexedDB&&"undefined"!=typeof IDBKeyRange}catch(a){return!1}}function g(a,b){a=a||[],b=b||{};try{return new Blob(a,b)}catch(f){if("TypeError"!==f.name)throw f;for(var c="undefined"!=typeof BlobBuilder?BlobBuilder:"undefined"!=typeof MSBlobBuilder?MSBlobBuilder:"undefined"!=typeof MozBlobBuilder?MozBlobBuilder:WebKitBlobBuilder,d=new c,e=0;e<a.length;e+=1)d.append(a[e]);return d.getBlob(b.type)}}function h(a,b){b&&a.then(function(a){b(null,a)},function(a){b(a)})}function i(a,b,c){"function"==typeof b&&a.then(b),"function"==typeof c&&a.catch(c)}function j(a){return"string"!=typeof a&&(console.warn(a+" used as a key, but it is not a string."),a=String(a)),a}function k(){if(arguments.length&&"function"==typeof arguments[arguments.length-1])return arguments[arguments.length-1]}function l(a){for(var b=a.length,c=new ArrayBuffer(b),d=new Uint8Array(c),e=0;e<b;e++)d[e]=a.charCodeAt(e);return c}function m(a){return new va(function(b){var c=a.transaction(wa,Ba),d=g([""]);c.objectStore(wa).put(d,"key"),c.onabort=function(a){a.preventDefault(),a.stopPropagation(),b(!1)},c.oncomplete=function(){var a=navigator.userAgent.match(/Chrome\/(\d+)/),c=navigator.userAgent.match(/Edge\//);b(c||!a||parseInt(a[1],10)>=43)}}).catch(function(){return!1})}function n(a){return"boolean"==typeof xa?va.resolve(xa):m(a).then(function(a){return xa=a})}function o(a){var b=ya[a.name],c={};c.promise=new va(function(a,b){c.resolve=a,c.reject=b}),b.deferredOperations.push(c),b.dbReady?b.dbReady=b.dbReady.then(function(){return c.promise}):b.dbReady=c.promise}function p(a){var b=ya[a.name],c=b.deferredOperations.pop();if(c)return c.resolve(),c.promise}function q(a,b){var c=ya[a.name],d=c.deferredOperations.pop();if(d)return d.reject(b),d.promise}function r(a,b){return new va(function(c,d){if(ya[a.name]=ya[a.name]||B(),a.db){if(!b)return c(a.db);o(a),a.db.close()}var e=[a.name];b&&e.push(a.version);var f=ua.open.apply(ua,e);b&&(f.onupgradeneeded=function(b){var c=f.result;try{c.createObjectStore(a.storeName),b.oldVersion<=1&&c.createObjectStore(wa)}catch(c){if("ConstraintError"!==c.name)throw c;console.warn('The database "'+a.name+'" has been upgraded from version '+b.oldVersion+" to version "+b.newVersion+', but the storage "'+a.storeName+'" already exists.')}}),f.onerror=function(a){a.preventDefault(),d(f.error)},f.onsuccess=function(){c(f.result),p(a)}})}function s(a){return r(a,!1)}function t(a){return r(a,!0)}function u(a,b){if(!a.db)return!0;var c=!a.db.objectStoreNames.contains(a.storeName),d=a.version<a.db.version,e=a.version>a.db.version;if(d&&(a.version!==b&&console.warn('The database "'+a.name+"\" can't be downgraded from version "+a.db.version+" to version "+a.version+"."),a.version=a.db.version),e||c){if(c){var f=a.db.version+1;f>a.version&&(a.version=f)}return!0}return!1}function v(a){return new va(function(b,c){var d=new FileReader;d.onerror=c,d.onloadend=function(c){var d=btoa(c.target.result||"");b({__local_forage_encoded_blob:!0,data:d,type:a.type})},d.readAsBinaryString(a)})}function w(a){return g([l(atob(a.data))],{type:a.type})}function x(a){return a&&a.__local_forage_encoded_blob}function y(a){var b=this,c=b._initReady().then(function(){var a=ya[b._dbInfo.name];if(a&&a.dbReady)return a.dbReady});return i(c,a,a),c}function z(a){o(a);for(var b=ya[a.name],c=b.forages,d=0;d<c.length;d++){var e=c[d];e._dbInfo.db&&(e._dbInfo.db.close(),e._dbInfo.db=null)}return a.db=null,s(a).then(function(b){return a.db=b,u(a)?t(a):b}).then(function(d){a.db=b.db=d;for(var e=0;e<c.length;e++)c[e]._dbInfo.db=d}).catch(function(b){throw q(a,b),b})}function A(a,b,c,d){void 0===d&&(d=1);try{var e=a.db.transaction(a.storeName,b);c(null,e)}catch(e){if(d>0&&(!a.db||"InvalidStateError"===e.name||"NotFoundError"===e.name))return va.resolve().then(function(){if(!a.db||"NotFoundError"===e.name&&!a.db.objectStoreNames.contains(a.storeName)&&a.version<=a.db.version)return a.db&&(a.version=a.db.version+1),t(a)}).then(function(){return z(a).then(function(){A(a,b,c,d-1)})}).catch(c);c(e)}}function B(){return{forages:[],db:null,dbReady:null,deferredOperations:[]}}function C(a){function b(){return va.resolve()}var c=this,d={db:null};if(a)for(var e in a)d[e]=a[e];var f=ya[d.name];f||(f=B(),ya[d.name]=f),f.forages.push(c),c._initReady||(c._initReady=c.ready,c.ready=y);for(var g=[],h=0;h<f.forages.length;h++){var i=f.forages[h];i!==c&&g.push(i._initReady().catch(b))}var j=f.forages.slice(0);return va.all(g).then(function(){return d.db=f.db,s(d)}).then(function(a){return d.db=a,u(d,c._defaultConfig.version)?t(d):a}).then(function(a){d.db=f.db=a,c._dbInfo=d;for(var b=0;b<j.length;b++){var e=j[b];e!==c&&(e._dbInfo.db=d.db,e._dbInfo.version=d.version)}})}function D(a,b){var c=this;a=j(a);var d=new va(function(b,d){c.ready().then(function(){A(c._dbInfo,Aa,function(e,f){if(e)return d(e);try{var g=f.objectStore(c._dbInfo.storeName),h=g.get(a);h.onsuccess=function(){var a=h.result;void 0===a&&(a=null),x(a)&&(a=w(a)),b(a)},h.onerror=function(){d(h.error)}}catch(a){d(a)}})}).catch(d)});return h(d,b),d}function E(a,b){var c=this,d=new va(function(b,d){c.ready().then(function(){A(c._dbInfo,Aa,function(e,f){if(e)return d(e);try{var g=f.objectStore(c._dbInfo.storeName),h=g.openCursor(),i=1;h.onsuccess=function(){var c=h.result;if(c){var d=c.value;x(d)&&(d=w(d));var e=a(d,c.key,i++);void 0!==e?b(e):c.continue()}else b()},h.onerror=function(){d(h.error)}}catch(a){d(a)}})}).catch(d)});return h(d,b),d}function F(a,b,c){var d=this;a=j(a);var e=new va(function(c,e){var f;d.ready().then(function(){return f=d._dbInfo,"[object Blob]"===za.call(b)?n(f.db).then(function(a){return a?b:v(b)}):b}).then(function(b){A(d._dbInfo,Ba,function(f,g){if(f)return e(f);try{var h=g.objectStore(d._dbInfo.storeName);null===b&&(b=void 0);var i=h.put(b,a);g.oncomplete=function(){void 0===b&&(b=null),c(b)},g.onabort=g.onerror=function(){var a=i.error?i.error:i.transaction.error;e(a)}}catch(a){e(a)}})}).catch(e)});return h(e,c),e}function G(a,b){var c=this;a=j(a);var d=new va(function(b,d){c.ready().then(function(){A(c._dbInfo,Ba,function(e,f){if(e)return d(e);try{var g=f.objectStore(c._dbInfo.storeName),h=g.delete(a);f.oncomplete=function(){b()},f.onerror=function(){d(h.error)},f.onabort=function(){var a=h.error?h.error:h.transaction.error;d(a)}}catch(a){d(a)}})}).catch(d)});return h(d,b),d}function H(a){var b=this,c=new va(function(a,c){b.ready().then(function(){A(b._dbInfo,Ba,function(d,e){if(d)return c(d);try{var f=e.objectStore(b._dbInfo.storeName),g=f.clear();e.oncomplete=function(){a()},e.onabort=e.onerror=function(){var a=g.error?g.error:g.transaction.error;c(a)}}catch(a){c(a)}})}).catch(c)});return h(c,a),c}function I(a){var b=this,c=new va(function(a,c){b.ready().then(function(){A(b._dbInfo,Aa,function(d,e){if(d)return c(d);try{var f=e.objectStore(b._dbInfo.storeName),g=f.count();g.onsuccess=function(){a(g.result)},g.onerror=function(){c(g.error)}}catch(a){c(a)}})}).catch(c)});return h(c,a),c}function J(a,b){var c=this,d=new va(function(b,d){if(a<0)return void b(null);c.ready().then(function(){A(c._dbInfo,Aa,function(e,f){if(e)return d(e);try{var g=f.objectStore(c._dbInfo.storeName),h=!1,i=g.openCursor();i.onsuccess=function(){var c=i.result;if(!c)return void b(null);0===a?b(c.key):h?b(c.key):(h=!0,c.advance(a))},i.onerror=function(){d(i.error)}}catch(a){d(a)}})}).catch(d)});return h(d,b),d}function K(a){var b=this,c=new va(function(a,c){b.ready().then(function(){A(b._dbInfo,Aa,function(d,e){if(d)return c(d);try{var f=e.objectStore(b._dbInfo.storeName),g=f.openCursor(),h=[];g.onsuccess=function(){var b=g.result;if(!b)return void a(h);h.push(b.key),b.continue()},g.onerror=function(){c(g.error)}}catch(a){c(a)}})}).catch(c)});return h(c,a),c}function L(a,b){b=k.apply(this,arguments);var c=this.config();a="function"!=typeof a&&a||{},a.name||(a.name=a.name||c.name,a.storeName=a.storeName||c.storeName);var d,e=this;if(a.name){var f=a.name===c.name&&e._dbInfo.db,g=f?va.resolve(e._dbInfo.db):s(a).then(function(b){var c=ya[a.name],d=c.forages;c.db=b;for(var e=0;e<d.length;e++)d[e]._dbInfo.db=b;return b});d=a.storeName?g.then(function(b){if(b.objectStoreNames.contains(a.storeName)){var c=b.version+1;o(a);var d=ya[a.name],e=d.forages;b.close();for(var f=0;f<e.length;f++){var g=e[f];g._dbInfo.db=null,g._dbInfo.version=c}return new va(function(b,d){var e=ua.open(a.name,c);e.onerror=function(a){e.result.close(),d(a)},e.onupgradeneeded=function(){e.result.deleteObjectStore(a.storeName)},e.onsuccess=function(){var a=e.result;a.close(),b(a)}}).then(function(a){d.db=a;for(var b=0;b<e.length;b++){var c=e[b];c._dbInfo.db=a,p(c._dbInfo)}}).catch(function(b){throw(q(a,b)||va.resolve()).catch(function(){}),b})}}):g.then(function(b){o(a);var c=ya[a.name],d=c.forages;b.close();for(var e=0;e<d.length;e++){d[e]._dbInfo.db=null}return new va(function(b,c){var d=ua.deleteDatabase(a.name);d.onerror=d.onblocked=function(a){var b=d.result;b&&b.close(),c(a)},d.onsuccess=function(){var a=d.result;a&&a.close(),b(a)}}).then(function(a){c.db=a;for(var b=0;b<d.length;b++)p(d[b]._dbInfo)}).catch(function(b){throw(q(a,b)||va.resolve()).catch(function(){}),b})})}else d=va.reject("Invalid arguments");return h(d,b),d}function M(){return"function"==typeof openDatabase}function N(a){var b,c,d,e,f,g=.75*a.length,h=a.length,i=0;"="===a[a.length-1]&&(g--,"="===a[a.length-2]&&g--);var j=new ArrayBuffer(g),k=new Uint8Array(j);for(b=0;b<h;b+=4)c=Da.indexOf(a[b]),d=Da.indexOf(a[b+1]),e=Da.indexOf(a[b+2]),f=Da.indexOf(a[b+3]),k[i++]=c<<2|d>>4,k[i++]=(15&d)<<4|e>>2,k[i++]=(3&e)<<6|63&f;return j}function O(a){var b,c=new Uint8Array(a),d="";for(b=0;b<c.length;b+=3)d+=Da[c[b]>>2],d+=Da[(3&c[b])<<4|c[b+1]>>4],d+=Da[(15&c[b+1])<<2|c[b+2]>>6],d+=Da[63&c[b+2]];return c.length%3==2?d=d.substring(0,d.length-1)+"=":c.length%3==1&&(d=d.substring(0,d.length-2)+"=="),d}function P(a,b){var c="";if(a&&(c=Ua.call(a)),a&&("[object ArrayBuffer]"===c||a.buffer&&"[object ArrayBuffer]"===Ua.call(a.buffer))){var d,e=Ga;a instanceof ArrayBuffer?(d=a,e+=Ia):(d=a.buffer,"[object Int8Array]"===c?e+=Ka:"[object Uint8Array]"===c?e+=La:"[object Uint8ClampedArray]"===c?e+=Ma:"[object Int16Array]"===c?e+=Na:"[object Uint16Array]"===c?e+=Pa:"[object Int32Array]"===c?e+=Oa:"[object Uint32Array]"===c?e+=Qa:"[object Float32Array]"===c?e+=Ra:"[object Float64Array]"===c?e+=Sa:b(new Error("Failed to get type for BinaryArray"))),b(e+O(d))}else if("[object Blob]"===c){var f=new FileReader;f.onload=function(){var c=Ea+a.type+"~"+O(this.result);b(Ga+Ja+c)},f.readAsArrayBuffer(a)}else try{b(JSON.stringify(a))}catch(c){console.error("Couldn't convert value into a JSON string: ",a),b(null,c)}}function Q(a){if(a.substring(0,Ha)!==Ga)return JSON.parse(a);var b,c=a.substring(Ta),d=a.substring(Ha,Ta);if(d===Ja&&Fa.test(c)){var e=c.match(Fa);b=e[1],c=c.substring(e[0].length)}var f=N(c);switch(d){case Ia:return f;case Ja:return g([f],{type:b});case Ka:return new Int8Array(f);case La:return new Uint8Array(f);case Ma:return new Uint8ClampedArray(f);case Na:return new Int16Array(f);case Pa:return new Uint16Array(f);case Oa:return new Int32Array(f);case Qa:return new Uint32Array(f);case Ra:return new Float32Array(f);case Sa:return new Float64Array(f);default:throw new Error("Unkown type: "+d)}}function R(a,b,c,d){a.executeSql("CREATE TABLE IF NOT EXISTS "+b.storeName+" (id INTEGER PRIMARY KEY, key unique, value)",[],c,d)}function S(a){var b=this,c={db:null};if(a)for(var d in a)c[d]="string"!=typeof a[d]?a[d].toString():a[d];var e=new va(function(a,d){try{c.db=openDatabase(c.name,String(c.version),c.description,c.size)}catch(a){return d(a)}c.db.transaction(function(e){R(e,c,function(){b._dbInfo=c,a()},function(a,b){d(b)})},d)});return c.serializer=Va,e}function T(a,b,c,d,e,f){a.executeSql(c,d,e,function(a,g){g.code===g.SYNTAX_ERR?a.executeSql("SELECT name FROM sqlite_master WHERE type='table' AND name = ?",[b.storeName],function(a,h){h.rows.length?f(a,g):R(a,b,function(){a.executeSql(c,d,e,f)},f)},f):f(a,g)},f)}function U(a,b){var c=this;a=j(a);var d=new va(function(b,d){c.ready().then(function(){var e=c._dbInfo;e.db.transaction(function(c){T(c,e,"SELECT * FROM "+e.storeName+" WHERE key = ? LIMIT 1",[a],function(a,c){var d=c.rows.length?c.rows.item(0).value:null;d&&(d=e.serializer.deserialize(d)),b(d)},function(a,b){d(b)})})}).catch(d)});return h(d,b),d}function V(a,b){var c=this,d=new va(function(b,d){c.ready().then(function(){var e=c._dbInfo;e.db.transaction(function(c){T(c,e,"SELECT * FROM "+e.storeName,[],function(c,d){for(var f=d.rows,g=f.length,h=0;h<g;h++){var i=f.item(h),j=i.value;if(j&&(j=e.serializer.deserialize(j)),void 0!==(j=a(j,i.key,h+1)))return void b(j)}b()},function(a,b){d(b)})})}).catch(d)});return h(d,b),d}function W(a,b,c,d){var e=this;a=j(a);var f=new va(function(f,g){e.ready().then(function(){void 0===b&&(b=null);var h=b,i=e._dbInfo;i.serializer.serialize(b,function(b,j){j?g(j):i.db.transaction(function(c){T(c,i,"INSERT OR REPLACE INTO "+i.storeName+" (key, value) VALUES (?, ?)",[a,b],function(){f(h)},function(a,b){g(b)})},function(b){if(b.code===b.QUOTA_ERR){if(d>0)return void f(W.apply(e,[a,h,c,d-1]));g(b)}})})}).catch(g)});return h(f,c),f}function X(a,b,c){return W.apply(this,[a,b,c,1])}function Y(a,b){var c=this;a=j(a);var d=new va(function(b,d){c.ready().then(function(){var e=c._dbInfo;e.db.transaction(function(c){T(c,e,"DELETE FROM "+e.storeName+" WHERE key = ?",[a],function(){b()},function(a,b){d(b)})})}).catch(d)});return h(d,b),d}function Z(a){var b=this,c=new va(function(a,c){b.ready().then(function(){var d=b._dbInfo;d.db.transaction(function(b){T(b,d,"DELETE FROM "+d.storeName,[],function(){a()},function(a,b){c(b)})})}).catch(c)});return h(c,a),c}function $(a){var b=this,c=new va(function(a,c){b.ready().then(function(){var d=b._dbInfo;d.db.transaction(function(b){T(b,d,"SELECT COUNT(key) as c FROM "+d.storeName,[],function(b,c){var d=c.rows.item(0).c;a(d)},function(a,b){c(b)})})}).catch(c)});return h(c,a),c}function _(a,b){var c=this,d=new va(function(b,d){c.ready().then(function(){var e=c._dbInfo;e.db.transaction(function(c){T(c,e,"SELECT key FROM "+e.storeName+" WHERE id = ? LIMIT 1",[a+1],function(a,c){var d=c.rows.length?c.rows.item(0).key:null;b(d)},function(a,b){d(b)})})}).catch(d)});return h(d,b),d}function aa(a){var b=this,c=new va(function(a,c){b.ready().then(function(){var d=b._dbInfo;d.db.transaction(function(b){T(b,d,"SELECT key FROM "+d.storeName,[],function(b,c){for(var d=[],e=0;e<c.rows.length;e++)d.push(c.rows.item(e).key);a(d)},function(a,b){c(b)})})}).catch(c)});return h(c,a),c}function ba(a){return new va(function(b,c){a.transaction(function(d){d.executeSql("SELECT name FROM sqlite_master WHERE type='table' AND name <> '__WebKitDatabaseInfoTable__'",[],function(c,d){for(var e=[],f=0;f<d.rows.length;f++)e.push(d.rows.item(f).name);b({db:a,storeNames:e})},function(a,b){c(b)})},function(a){c(a)})})}function ca(a,b){b=k.apply(this,arguments);var c=this.config();a="function"!=typeof a&&a||{},a.name||(a.name=a.name||c.name,a.storeName=a.storeName||c.storeName);var d,e=this;return d=a.name?new va(function(b){var d;d=a.name===c.name?e._dbInfo.db:openDatabase(a.name,"","",0),b(a.storeName?{db:d,storeNames:[a.storeName]}:ba(d))}).then(function(a){return new va(function(b,c){a.db.transaction(function(d){function e(a){return new va(function(b,c){d.executeSql("DROP TABLE IF EXISTS "+a,[],function(){b()},function(a,b){c(b)})})}for(var f=[],g=0,h=a.storeNames.length;g<h;g++)f.push(e(a.storeNames[g]));va.all(f).then(function(){b()}).catch(function(a){c(a)})},function(a){c(a)})})}):va.reject("Invalid arguments"),h(d,b),d}function da(){try{return"undefined"!=typeof localStorage&&"setItem"in localStorage&&!!localStorage.setItem}catch(a){return!1}}function ea(a,b){var c=a.name+"/";return a.storeName!==b.storeName&&(c+=a.storeName+"/"),c}function fa(){var a="_localforage_support_test";try{return localStorage.setItem(a,!0),localStorage.removeItem(a),!1}catch(a){return!0}}function ga(){return!fa()||localStorage.length>0}function ha(a){var b=this,c={};if(a)for(var d in a)c[d]=a[d];return c.keyPrefix=ea(a,b._defaultConfig),ga()?(b._dbInfo=c,c.serializer=Va,va.resolve()):va.reject()}function ia(a){var b=this,c=b.ready().then(function(){for(var a=b._dbInfo.keyPrefix,c=localStorage.length-1;c>=0;c--){var d=localStorage.key(c);0===d.indexOf(a)&&localStorage.removeItem(d)}});return h(c,a),c}function ja(a,b){var c=this;a=j(a);var d=c.ready().then(function(){var b=c._dbInfo,d=localStorage.getItem(b.keyPrefix+a);return d&&(d=b.serializer.deserialize(d)),d});return h(d,b),d}function ka(a,b){var c=this,d=c.ready().then(function(){for(var b=c._dbInfo,d=b.keyPrefix,e=d.length,f=localStorage.length,g=1,h=0;h<f;h++){var i=localStorage.key(h);if(0===i.indexOf(d)){var j=localStorage.getItem(i);if(j&&(j=b.serializer.deserialize(j)),void 0!==(j=a(j,i.substring(e),g++)))return j}}});return h(d,b),d}function la(a,b){var c=this,d=c.ready().then(function(){var b,d=c._dbInfo;try{b=localStorage.key(a)}catch(a){b=null}return b&&(b=b.substring(d.keyPrefix.length)),b});return h(d,b),d}function ma(a){var b=this,c=b.ready().then(function(){for(var a=b._dbInfo,c=localStorage.length,d=[],e=0;e<c;e++){var f=localStorage.key(e);0===f.indexOf(a.keyPrefix)&&d.push(f.substring(a.keyPrefix.length))}return d});return h(c,a),c}function na(a){var b=this,c=b.keys().then(function(a){return a.length});return h(c,a),c}function oa(a,b){var c=this;a=j(a);var d=c.ready().then(function(){var b=c._dbInfo;localStorage.removeItem(b.keyPrefix+a)});return h(d,b),d}function pa(a,b,c){var d=this;a=j(a);var e=d.ready().then(function(){void 0===b&&(b=null);var c=b;return new va(function(e,f){var g=d._dbInfo;g.serializer.serialize(b,function(b,d){if(d)f(d);else try{localStorage.setItem(g.keyPrefix+a,b),e(c)}catch(a){"QuotaExceededError"!==a.name&&"NS_ERROR_DOM_QUOTA_REACHED"!==a.name||f(a),f(a)}})})});return h(e,c),e}function qa(a,b){if(b=k.apply(this,arguments),a="function"!=typeof a&&a||{},!a.name){var c=this.config();a.name=a.name||c.name,a.storeName=a.storeName||c.storeName}var d,e=this;return d=a.name?new va(function(b){b(a.storeName?ea(a,e._defaultConfig):a.name+"/")}).then(function(a){for(var b=localStorage.length-1;b>=0;b--){var c=localStorage.key(b);0===c.indexOf(a)&&localStorage.removeItem(c)}}):va.reject("Invalid arguments"),h(d,b),d}function ra(a,b){a[b]=function(){var c=arguments;return a.ready().then(function(){return a[b].apply(a,c)})}}function sa(){for(var a=1;a<arguments.length;a++){var b=arguments[a];if(b)for(var c in b)b.hasOwnProperty(c)&&($a(b[c])?arguments[0][c]=b[c].slice():arguments[0][c]=b[c])}return arguments[0]}var ta="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(a){return typeof a}:function(a){return a&&"function"==typeof Symbol&&a.constructor===Symbol&&a!==Symbol.prototype?"symbol":typeof a},ua=e();"undefined"==typeof Promise&&a(3);var va=Promise,wa="local-forage-detect-blob-support",xa=void 0,ya={},za=Object.prototype.toString,Aa="readonly",Ba="readwrite",Ca={_driver:"asyncStorage",_initStorage:C,_support:f(),iterate:E,getItem:D,setItem:F,removeItem:G,clear:H,length:I,key:J,keys:K,dropInstance:L},Da="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",Ea="~~local_forage_type~",Fa=/^~~local_forage_type~([^~]+)~/,Ga="__lfsc__:",Ha=Ga.length,Ia="arbf",Ja="blob",Ka="si08",La="ui08",Ma="uic8",Na="si16",Oa="si32",Pa="ur16",Qa="ui32",Ra="fl32",Sa="fl64",Ta=Ha+Ia.length,Ua=Object.prototype.toString,Va={serialize:P,deserialize:Q,stringToBuffer:N,bufferToString:O},Wa={_driver:"webSQLStorage",_initStorage:S,_support:M(),iterate:V,getItem:U,setItem:X,removeItem:Y,clear:Z,length:$,key:_,keys:aa,dropInstance:ca},Xa={_driver:"localStorageWrapper",_initStorage:ha,_support:da(),iterate:ka,getItem:ja,setItem:pa,removeItem:oa,clear:ia,length:na,key:la,keys:ma,dropInstance:qa},Ya=function(a,b){return a===b||"number"==typeof a&&"number"==typeof b&&isNaN(a)&&isNaN(b)},Za=function(a,b){for(var c=a.length,d=0;d<c;){if(Ya(a[d],b))return!0;d++}return!1},$a=Array.isArray||function(a){return"[object Array]"===Object.prototype.toString.call(a)},_a={},ab={},bb={INDEXEDDB:Ca,WEBSQL:Wa,LOCALSTORAGE:Xa},cb=[bb.INDEXEDDB._driver,bb.WEBSQL._driver,bb.LOCALSTORAGE._driver],db=["dropInstance"],eb=["clear","getItem","iterate","key","keys","length","removeItem","setItem"].concat(db),fb={description:"",driver:cb.slice(),name:"localforage",size:4980736,storeName:"keyvaluepairs",version:1},gb=function(){function a(b){d(this,a);for(var c in bb)if(bb.hasOwnProperty(c)){var e=bb[c],f=e._driver;this[c]=f,_a[f]||this.defineDriver(e)}this._defaultConfig=sa({},fb),this._config=sa({},this._defaultConfig,b),this._driverSet=null,this._initDriver=null,this._ready=!1,this._dbInfo=null,this._wrapLibraryMethodsWithReady(),this.setDriver(this._config.driver).catch(function(){})}return a.prototype.config=function(a){if("object"===(void 0===a?"undefined":ta(a))){if(this._ready)return new Error("Can't call config() after localforage has been used.");for(var b in a){if("storeName"===b&&(a[b]=a[b].replace(/\W/g,"_")),"version"===b&&"number"!=typeof a[b])return new Error("Database version must be a number.");this._config[b]=a[b]}return!("driver"in a&&a.driver)||this.setDriver(this._config.driver)}return"string"==typeof a?this._config[a]:this._config},a.prototype.defineDriver=function(a,b,c){var d=new va(function(b,c){try{var d=a._driver,e=new Error("Custom driver not compliant; see https://mozilla.github.io/localForage/#definedriver");if(!a._driver)return void c(e);for(var f=eb.concat("_initStorage"),g=0,i=f.length;g<i;g++){var j=f[g];if((!Za(db,j)||a[j])&&"function"!=typeof a[j])return void c(e)}(function(){for(var b=function(a){return function(){var b=new Error("Method "+a+" is not implemented by the current driver"),c=va.reject(b);return h(c,arguments[arguments.length-1]),c}},c=0,d=db.length;c<d;c++){var e=db[c];a[e]||(a[e]=b(e))}})();var k=function(c){_a[d]&&console.info("Redefining LocalForage driver: "+d),_a[d]=a,ab[d]=c,b()};"_support"in a?a._support&&"function"==typeof a._support?a._support().then(k,c):k(!!a._support):k(!0)}catch(a){c(a)}});return i(d,b,c),d},a.prototype.driver=function(){return this._driver||null},a.prototype.getDriver=function(a,b,c){var d=_a[a]?va.resolve(_a[a]):va.reject(new Error("Driver not found."));return i(d,b,c),d},a.prototype.getSerializer=function(a){var b=va.resolve(Va);return i(b,a),b},a.prototype.ready=function(a){var b=this,c=b._driverSet.then(function(){return null===b._ready&&(b._ready=b._initDriver()),b._ready});return i(c,a,a),c},a.prototype.setDriver=function(a,b,c){function d(){g._config.driver=g.driver()}function e(a){return g._extend(a),d(),g._ready=g._initStorage(g._config),g._ready}function f(a){return function(){function b(){for(;c<a.length;){var f=a[c];return c++,g._dbInfo=null,g._ready=null,g.getDriver(f).then(e).catch(b)}d();var h=new Error("No available storage method found.");return g._driverSet=va.reject(h),g._driverSet}var c=0;return b()}}var g=this;$a(a)||(a=[a]);var h=this._getSupportedDrivers(a),j=null!==this._driverSet?this._driverSet.catch(function(){return va.resolve()}):va.resolve();return this._driverSet=j.then(function(){var a=h[0];return g._dbInfo=null,g._ready=null,g.getDriver(a).then(function(a){g._driver=a._driver,d(),g._wrapLibraryMethodsWithReady(),g._initDriver=f(h)})}).catch(function(){d();var a=new Error("No available storage method found.");return g._driverSet=va.reject(a),g._driverSet}),i(this._driverSet,b,c),this._driverSet},a.prototype.supports=function(a){return!!ab[a]},a.prototype._extend=function(a){sa(this,a)},a.prototype._getSupportedDrivers=function(a){for(var b=[],c=0,d=a.length;c<d;c++){var e=a[c];this.supports(e)&&b.push(e)}return b},a.prototype._wrapLibraryMethodsWithReady=function(){for(var a=0,b=eb.length;a<b;a++)ra(this,eb[a])},a.prototype.createInstance=function(b){return new a(b)},a}(),hb=new gb;b.exports=hb},{3:3}]},{},[4])(4)});
\ No newline at end of file
diff --git a/libs/ui.js b/libs/ui.js
index 1f4fb301..6f990152 100644
--- a/libs/ui.js
+++ b/libs/ui.js
@@ -3,174 +3,256 @@
  * 包括：
  * 自动寻路、怪物手册、楼传器、存读档、菜单栏、NPC对话事件、等等
  */
+
+"use strict";
+
 function ui() {
-    this.init();
+    this._init();
+    // for convenience
+    this.SIZE = core.__SIZE__;
+    this.HSIZE = core.__HALF_SIZE__;
+    this.LAST = this.SIZE - 1;
+    this.PIXEL = core.__PIXELS__;
+    this.HPIXEL = this.PIXEL / 2;
 }
 
 // 初始化UI
-ui.prototype.init = function () {
+ui.prototype._init = function () {
     this.uidata = functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a.ui;
 }
 
 ////////////////// 地图设置
 
+ui.prototype.getContextByName = function (name) {
+    var canvas = name;
+    if (typeof name == 'string') {
+        if (core.canvas[name])
+            canvas = core.canvas[name];
+        else if (core.dymCanvas[name])
+            canvas = core.dymCanvas[name];
+    }
+    if (canvas && canvas.canvas) {
+        return canvas;
+    }
+    return null;
+}
+
 ////// 清除地图 //////
-ui.prototype.clearMap = function (map, x, y, width, height) {
-    if (map == 'all') {
+ui.prototype.clearMap = function (name, x, y, width, height) {
+    if (name == 'all') {
         for (var m in core.canvas) {
             core.canvas[m].clearRect(0, 0, core.bigmap.width*32, core.bigmap.height*32);
         }
         core.dom.gif.innerHTML = "";
+        core.removeGlobalAnimate();
     }
     else {
-        core.canvas[map].clearRect(x||0, y||0, width||core.bigmap.width*32, height||core.bigmap.height*32);
+        var ctx = this.getContextByName(name);
+        if (ctx) ctx.clearRect(x||0, y||0, width||ctx.canvas.width, height||ctx.canvas.height);
     }
 }
 
 ////// 在某个canvas上绘制一段文字 //////
-ui.prototype.fillText = function (map, text, x, y, style, font) {
-    if (core.isset(style)) {
-        core.setFillStyle(map, style);
-    }
-    if (core.isset(font)) {
-        core.setFont(map, font);
-    }
-    core.canvas[map].fillText(text, x, y);
+ui.prototype.fillText = function (name, text, x, y, style, font) {
+    if (style) core.setFillStyle(name, style);
+    if (font) core.setFont(name, font);
+    var ctx = this.getContextByName(name);
+    if (ctx) ctx.fillText(text, x, y);
+}
+
+////// 在某个canvas上绘制粗体 //////
+ui.prototype.fillBoldText = function (name, text, x, y, style, font) {
+    var ctx = this.getContextByName(name);
+    if (!ctx) return;
+    if (font) ctx.font = font;
+    if (!style) style = ctx.fillStyle;
+    ctx.fillStyle = '#000000';
+    ctx.fillText(text, x-1, y-1);
+    ctx.fillText(text, x-1, y+1);
+    ctx.fillText(text, x+1, y-1);
+    ctx.fillText(text, x+1, y+1);
+    ctx.fillStyle = style;
+    ctx.fillText(text, x, y);
 }
 
 ////// 在某个canvas上绘制一个矩形 //////
-ui.prototype.fillRect = function (map, x, y, width, height, style) {
-    if (core.isset(style)) {
-        core.setFillStyle(map, style);
-    }
-    core.canvas[map].fillRect(x, y, width, height);
+ui.prototype.fillRect = function (name, x, y, width, height, style) {
+    if (style) core.setFillStyle(name, style);
+    var ctx = this.getContextByName(name);
+    if (ctx) ctx.fillRect(x, y, width, height);
 }
 
 ////// 在某个canvas上绘制一个矩形的边框 //////
-ui.prototype.strokeRect = function (map, x, y, width, height, style, lineWidth) {
-    if (core.isset(style)) {
-        core.setStrokeStyle(map, style);
-    }
-    if (core.isset(lineWidth)) {
-        core.setLineWidth(map, lineWidth);
-    }
-    core.canvas[map].strokeRect(x, y, width, height);
+ui.prototype.strokeRect = function (name, x, y, width, height, style, lineWidth) {
+    if (style) core.setStrokeStyle(name, style);
+    if (lineWidth) core.setLineWidth(name, lineWidth);
+    var ctx = this.getContextByName(name);
+    if (ctx) ctx.strokeRect(x, y, width, height);
 }
 
 ////// 在某个canvas上绘制一条线 //////
-ui.prototype.drawLine = function (map, x1, y1, x2, y2, style, lineWidth) {
-    if (core.isset(style)) {
-        core.setStrokeStyle(map, style);
-    }
-    if (core.isset(lineWidth)) {
-        core.setLineWidth(map, lineWidth);
-    }
-    core.canvas[map].beginPath();
-    core.canvas[map].moveTo(x1, y1);
-    core.canvas[map].lineTo(x2, y2);
-    core.canvas[map].stroke();
+ui.prototype.drawLine = function (name, x1, y1, x2, y2, style, lineWidth) {
+    if (style) core.setStrokeStyle(name, style);
+    if (lineWidth != null) core.setLineWidth(name, lineWidth);
+    var ctx = this.getContextByName(name);
+    if (!ctx) return;
+    ctx.beginPath();
+    ctx.moveTo(x1, y1);
+    ctx.lineTo(x2, y2);
+    ctx.stroke();
 }
 
 ////// 在某个canvas上绘制一个箭头 //////
-ui.prototype.drawArrow = function (map, x1, y1, x2, y2, style, lineWidth) {
+ui.prototype.drawArrow = function (name, x1, y1, x2, y2, style, lineWidth) {
     if (x1==x2 && y1==y2) return;
-    if (core.isset(style)) {
-        core.setStrokeStyle(map, style);
-    }
-    if (core.isset(lineWidth)) {
-        core.setLineWidth(map, lineWidth);
-    }
+    if (style) core.setStrokeStyle(name, style);
+    if (lineWidth != null) core.setLineWidth(name, lineWidth);
+    var ctx = this.getContextByName(name);
+    if (!ctx) return;
     var head = 10;
     var dx = x2-x1, dy=y2-y1;
     var angle = Math.atan2(dy,dx);
-    core.canvas[map].beginPath();
-    core.canvas[map].moveTo(x1,y1);
-    core.canvas[map].lineTo(x2, y2);
-    core.canvas[map].lineTo(x2-head*Math.cos(angle-Math.PI/6),y2-head*Math.sin(angle-Math.PI/6));
-    core.canvas[map].moveTo(x2, y2);
-    core.canvas[map].lineTo(x2-head*Math.cos(angle+Math.PI/6),y2-head*Math.sin(angle+Math.PI/6));
-    core.canvas[map].stroke();
+    ctx.beginPath();
+    ctx.moveTo(x1,y1);
+    ctx.lineTo(x2, y2);
+    ctx.lineTo(x2-head*Math.cos(angle-Math.PI/6),y2-head*Math.sin(angle-Math.PI/6));
+    ctx.moveTo(x2, y2);
+    ctx.lineTo(x2-head*Math.cos(angle+Math.PI/6),y2-head*Math.sin(angle+Math.PI/6));
+    ctx.stroke();
 }
 
 ////// 设置某个canvas的文字字体 //////
-ui.prototype.setFont = function (map, font) {
-    core.canvas[map].font = font;
+ui.prototype.setFont = function (name, font) {
+    var ctx = this.getContextByName(name);
+    if (ctx) ctx.font = font;
 }
 
 ////// 设置某个canvas的线宽度 //////
-ui.prototype.setLineWidth = function (map, lineWidth) {
-    if (map == 'all') {
-        for (var m in core.canvas) {
-            core.canvas[m].lineWidth = lineWidth;
-        }
-    }
-    core.canvas[map].lineWidth = lineWidth;
+ui.prototype.setLineWidth = function (name, lineWidth) {
+    var ctx = this.getContextByName(name);
+    if (ctx) ctx.lineWidth = lineWidth;
 }
 
 ////// 保存某个canvas状态 //////
-ui.prototype.saveCanvas = function (map) {
-    core.canvas[map].save();
+ui.prototype.saveCanvas = function (name) {
+    var ctx = this.getContextByName(name);
+    if (ctx) ctx.save();
 }
 
 ////// 加载某个canvas状态 //////
-ui.prototype.loadCanvas = function (map) {
-    core.canvas[map].restore();
-}
-
-////// 设置某个canvas边框属性 //////
-ui.prototype.setStrokeStyle = function (map, style) {
-    if (map == 'all') {
-        for (var m in core.canvas) {
-            core.canvas[m].strokeStyle = style;
-        }
-    }
-    else {
-        core.canvas[map].strokeStyle = style;
-    }
+ui.prototype.loadCanvas = function (name) {
+    var ctx = this.getContextByName(name);
+    if (ctx) ctx.restore();
 }
 
 ////// 设置某个canvas的alpha值 //////
-ui.prototype.setAlpha = function (map, alpha) {
-    if (map == 'all') {
-        for (var m in core.canvas) {
-            core.canvas[m].globalAlpha = alpha;
-        }
-    }
-    else core.canvas[map].globalAlpha = alpha;
+ui.prototype.setAlpha = function (name, alpha) {
+    var ctx = this.getContextByName(name);
+    if (ctx) ctx.globalAlpha = alpha;
 }
 
-////// 设置某个canvas的透明度 //////
-ui.prototype.setOpacity = function (map, opacity) {
-    if (map == 'all') {
-        for (var m in core.canvas) {
-            core.canvas[m].canvas.style.opacity = opacity;
-        }
-    }
-    else core.canvas[map].canvas.style.opacity = opacity;
+////// 设置某个canvas的透明度；尽量不要使用本函数，而是全部换成setAlpha实现 //////
+ui.prototype.setOpacity = function (name, opacity) {
+    var ctx = this.getContextByName(name);
+    if (ctx) ctx.canvas.style.opacity = opacity;
 }
 
 ////// 设置某个canvas的绘制属性（如颜色等） //////
-ui.prototype.setFillStyle = function (map, style) {
-    if (map == 'all') {
-        for (var m in core.canvas) {
-            core.canvas[m].fillStyle = style;
-        }
-    }
-    else {
-        core.canvas[map].fillStyle = style;
-    }
+ui.prototype.setFillStyle = function (name, style) {
+    var ctx = this.getContextByName(name);
+    if (ctx) ctx.fillStyle = style;
 }
 
+////// 设置某个canvas边框属性 //////
+ui.prototype.setStrokeStyle = function (name, style) {
+    var ctx = this.getContextByName(name);
+    if (ctx) ctx.strokeStyle = style;
+}
 
+////// 设置某个canvas的对齐 //////
+ui.prototype.setTextAlign = function (name, align) {
+    var ctx = this.getContextByName(name);
+    if (ctx) ctx.textAlign = align;
+}
+
+////// 设置某个canvas的baseline //////
+ui.prototype.setTextBaseline = function (name, baseline) {
+    var ctx = this.getContextByName(name);
+    if (ctx) ctx.textBaseline = baseline;
+}
+
+////// 计算某段文字的宽度 //////
+ui.prototype.calWidth = function (name, text, font) {
+    var ctx = this.getContextByName(name);
+    if (ctx) {
+        if (font) ctx.font = font;
+        return ctx.measureText(text).width;
+    }
+    return 0;
+}
+
+////// 字符串自动换行的分割 //////
+ui.prototype.splitLines = function (name, text, maxWidth, font) {
+    var ctx = this.getContextByName(name);
+    if (!ctx) return;
+    if (font) core.setFont(name, font);
+
+    var contents = [];
+    var last = 0;
+    for (var i = 0; i < text.length; i++) {
+        if (text.charAt(i) == '\n') {
+            contents.push(text.substring(last, i));
+            last = i + 1;
+        }
+        else if (text.charAt(i) == '\\' && text.charAt(i + 1) == 'n') {
+            contents.push(text.substring(last, i));
+            last = i + 2;
+        }
+        else {
+            var toAdd = text.substring(last, i + 1);
+            var width = core.calWidth(name, toAdd);
+            if (maxWidth && width > maxWidth) {
+                contents.push(text.substring(last, i));
+                last = i;
+            }
+        }
+    }
+    contents.push(text.substring(last));
+    return contents;
+}
+
+////// 绘制一张图片 //////
+ui.prototype.drawImage = function (name, image, x, y, w, h, x1, y1, w1, h1) {
+    var ctx = this.getContextByName(name);
+    if (!ctx) return;
+    if (typeof image == 'string') {
+        image = core.getMappedName(image);
+        image = core.material.images.images[image];
+        if (!image) return;
+    }
+
+    // 只能接受2, 4, 8个参数
+    if (core.isset(x) && core.isset(y)) {
+        if (core.isset(w) && core.isset(h)) {
+            if (core.isset(x1) && core.isset(y1) && core.isset(w1) && core.isset(h1)) {
+                ctx.drawImage(image, x, y, w, h, x1, y1, w1, h1);
+                return;
+            }
+            ctx.drawImage(image, x, y, w, h);
+            return;
+        }
+        ctx.drawImage(image, x, y);
+        return;
+    }
+}
 
 ///////////////// UI绘制
 
 ////// 结束一切事件和绘制，关闭UI窗口，返回游戏进程 //////
 ui.prototype.closePanel = function () {
-    core.status.boxAnimateObjs = [];
-    clearInterval(core.status.event.interval);
-    core.clearMap('ui');
-    core.setAlpha('ui', 1.0);
+    this.clearUI();
+    core.maps.generateGroundPattern();
+    core.updateStatusBar();
     core.unLockControl();
     core.status.event.data = null;
     core.status.event.id = null;
@@ -179,55 +261,71 @@ ui.prototype.closePanel = function () {
     core.status.event.interval = null;
 }
 
+ui.prototype.clearUI = function () {
+    core.status.boxAnimateObjs = [];
+    if (core.dymCanvas._selector) core.deleteCanvas("_selector");
+    core.clearMap('ui');
+    core.setAlpha('ui', 1);
+}
+
 ////// 左上角绘制一段提示 //////
-ui.prototype.drawTip = function (text, itemIcon) {
-    var textX, textY, width, height, hide = false, opacityVal = 0;
+ui.prototype.drawTip = function (text, id) {
+    var textX, textY, width, height;
     clearInterval(core.interval.tipAnimate);
     core.setFont('data', "16px Arial");
-    core.setOpacity('data', 0);
-    core.canvas.data.textAlign = 'left';
-    if (!core.isset(itemIcon)) {
+    core.setTextAlign('data', 'left');
+    if (id != null) {
+        var info = core.getBlockInfo(id);
+        if (info == null || !info.image || info.height != 32) {
+            // 检查状态栏图标
+            if (core.statusBar.icons[id] instanceof Image) {
+                id = {image: core.statusBar.icons[id], posX: 0, posY: 0};
+            }
+            else id = null;
+        }
+        else id = info;
+    }
+    if (!id) {
         textX = 16;
         textY = 18;
-        width = textX + core.canvas.data.measureText(text).width + 16;
+        width = textX + core.calWidth('data', text) + 16;
         height = 42;
     }
     else {
         textX = 44;
         textY = 18;
-        width = textX + core.canvas.data.measureText(text).width + 8;
+        width = textX + core.calWidth('data', text) + 8;
         height = 42;
     }
+    this._drawTip_animate(text, id, textX, textY, width, height);
+}
+
+ui.prototype._drawTip_animate = function (text, info, textX, textY, width, height) {
+    var alpha = 0, hide = false;
     core.interval.tipAnimate = window.setInterval(function () {
-        if (hide) {
-            opacityVal -= 0.1;
-        }
-        else {
-            opacityVal += 0.1;
-        }
-        core.setOpacity('data', opacityVal);
-        core.clearMap('data', 5, 5, 400, height);
+        if (hide) alpha -= 0.1;
+        else alpha += 0.1;
+        core.clearMap('data', 5, 5, core.ui.PIXEL, height);
+        core.setAlpha('data', alpha);
         core.fillRect('data', 5, 5, width, height, '#000');
-        if (core.isset(itemIcon)) {
-            core.canvas.data.drawImage(core.material.images.items, 0, itemIcon * 32, 32, 32, 10, 8, 32, 32);
-        }
+        if (info)
+            core.drawImage('data', info.image, info.posX * 32, info.posY * 32, 32, 32, 10, 8, 32, 32);
         core.fillText('data', text, textX + 5, textY + 15, '#fff');
-        if (opacityVal > 0.6 || opacityVal < 0) {
+        core.setAlpha('data', 1);
+        if (alpha > 0.6 || alpha < 0) {
             if (hide) {
-                core.clearMap('data', 5, 5, 400, height);
-                core.setOpacity('data', 1);
+                core.clearMap('data', 5, 5, core.ui.PIXEL, height);
                 clearInterval(core.interval.tipAnimate);
                 return;
             }
             else {
-                if (!core.isset(core.timeout.getItemTipTimeout)) {
-                    core.timeout.getItemTipTimeout = window.setTimeout(function () {
+                if (!core.timeout.tipTimeout) {
+                    core.timeout.tipTimeout = window.setTimeout(function () {
                         hide = true;
-                        core.timeout.getItemTipTimeout = null;
+                        core.timeout.tipTimeout = null;
                     }, 750);
                 }
-                opacityVal = 0.6;
-                core.setOpacity('data', opacityVal);
+                alpha = 0.6;
             }
         }
     }, 30);
@@ -235,41 +333,12 @@ ui.prototype.drawTip = function (text, itemIcon) {
 
 ////// 地图中间绘制一段文字 //////
 ui.prototype.drawText = function (contents, callback) {
-    if (core.isset(contents)) {
-
-        // 合并
-        if ((core.isset(core.status.event)&&core.status.event.id=='action') || (core.isset(core.status.replay)&&core.status.replay.replaying)) {
-            core.insertAction(contents,null,null,callback);
-            return;
-        }
-
-        if (typeof contents == 'string') {
-            contents = [{'content': contents}];
-        }
-        else if (contents instanceof Object && core.isset(contents.content)) {
-            contents = [contents];
-        }
-        else if (!(contents instanceof Array)) {
-            core.drawTip("出错了");
-            console.log(contents);
-            return;
-        }
-
-        core.status.event = {'id': 'text', 'data': {'list': contents, 'callback': callback}};
-        core.lockControl();
-
-        // wait the hero to stop
-        core.stopAutomaticRoute();
-        setTimeout(function() {
-            core.drawText();
-        }, 30);
-        return;
-    }
+    if (contents != null) return this._drawText_setContent(contents, callback);
 
     if (core.status.event.data.list.length==0) {
         var callback = core.status.event.data.callback;
         core.ui.closePanel(false);
-        if (core.isset(callback)) callback();
+        if (callback) callback();
         return;
     }
 
@@ -278,529 +347,874 @@ ui.prototype.drawText = function (contents, callback) {
         core.ui.drawTextBox(data);
     else
         core.ui.drawTextBox(data.content, data.id);
-    // core.drawTextBox(content);
+}
+
+ui.prototype._drawText_setContent = function (contents, callback) {
+    // 合并进 insertAction
+    if ((core.status.event && core.status.event.id=='action') || core.isReplaying()) {
+        core.insertAction(contents,null,null,callback);
+        return;
+    }
+    if (!(contents instanceof Array)) contents = [contents];
+
+    core.status.event = {'id': 'text', 'data': {'list': contents, 'callback': callback}};
+    core.lockControl();
+
+    core.waitHeroToStop(core.drawText);
+    return;
+}
+
+////// 正则处理 \t[xx,yy] 问题
+ui.prototype._getTitleAndIcon = function (content) {
+    var title = null, image = null, icon = null, height = 32, animate = 1;
+    content = content.replace(/(\t|\\t)\[(([^\],]+),)?([^\],]+)\]/g, function (s0, s1, s2, s3, s4) {
+        if (s4) {
+            if (s4 == 'hero') {
+                title = core.status.hero.name;
+                image = core.material.images.hero;
+                icon = 0;
+                var w = core.material.icons.hero.width || 32;
+                height = 32 * core.material.icons.hero.height / w;
+            }
+            else if (s4.endsWith(".png")) {
+                s4 = core.getMappedName(s4);
+                image = core.material.images.images[s4];
+            }
+            else {
+                var blockInfo = core.getBlockInfo(s4);
+                if (blockInfo != null) {
+                    if (core.material.enemys[s4]) title = core.material.enemys[s4].name;
+                    image = blockInfo.image;
+                    icon = blockInfo.posY;
+                    height = blockInfo.height;
+                    animate = blockInfo.animate;
+                }
+                else title = s4;
+            }
+        }
+        if (s3) title = s3;
+        return "";
+    });
+    return {
+        content: content,
+        title: title,
+        image: image,
+        icon: icon,
+        height: height,
+        animate: animate
+    };
+}
+
+////// 正则处理 \b[up,xxx] 问题
+ui.prototype._getPosition = function (content) {
+    var pos = null, px = null, py = null;
+    if (core.status.event.id=='action') {
+        px = core.status.event.data.x;
+        py = core.status.event.data.y;
+    }
+    content = content.replace("\b", "\\b")
+        .replace(/\\b\[(up|center|down|hero|null)(,(hero|null|\d+,\d+|\d+))?]/g, function (s0, s1, s2, s3) {
+            pos = s1;
+            if (s3 == 'hero' || s1=='hero' && !s3) {
+                px = core.status.hero.loc.x;
+                py = core.status.hero.loc.y;
+            }
+            else if (s3 == 'null') {
+                px = py = null;
+            }
+            else if (s3) {
+                var str = s3.split(',');
+                px = py = null;
+                if (str.length == 1) {
+                    var follower = (core.status.hero.followers||[])[parseInt(str[0])-1];
+                    if (follower) {
+                        px = follower.x;
+                        py = follower.y;
+                    }
+                } else{
+                    px = parseInt(str[0]);
+                    py = parseInt(str[1]);
+                }
+            }
+            if(pos=='hero' || pos=='null'){
+                pos = py==null?'center':(py>=core.__HALF_SIZE__? 'up':'down'); 
+            }
+            return "";
+        });
+    return {content: content, position: pos, px: px, py: py};
+}
+
+////// 绘制选择光标
+ui.prototype.drawWindowSelector = function(background, x, y, w, h) {
+    if (typeof background == 'string')
+        background = core.material.images.images[background];
+    w = Math.round(w), h = Math.round(h);
+    var dstImage = core.ui.createCanvas("_selector", x, y, w, h, 165);
+    core.setOpacity("_selector", 0.8);
+    // back
+    dstImage.drawImage(background, 130, 66, 28, 28,  2,  2,w-4,h-4);
+    // corner
+    dstImage.drawImage(background, 128, 64,  2,  2,  0,  0,  2,  2);
+    dstImage.drawImage(background, 158, 64,  2,  2,w-2,  0,  2,  2);
+    dstImage.drawImage(background, 128, 94,  2,  2,  0,h-2,  2,  2);
+    dstImage.drawImage(background, 158, 94,  2,  2,w-2,h-2,  2,  2);
+    // border
+    dstImage.drawImage(background, 130, 64, 28,  2,  2,  0,w-4,  2);
+    dstImage.drawImage(background, 130, 94, 28,  2,  2,h-2,w-4,  2);
+    dstImage.drawImage(background, 128, 66,  2, 28,  0,  2,  2,h-4);
+    dstImage.drawImage(background, 158, 66,  2, 28,w-2,  2,  2,h-4);
+}
+
+////// 绘制 WindowSkin
+ui.prototype.drawWindowSkin = function(background, ctx, x, y, w, h, direction, px, py) {
+    background = background || core.status.textAttribute.background;
+    if (typeof background == 'string') {
+        background = core.getMappedName(background);
+        background = core.material.images.images[background];
+    }
+	// 仿RM窗口皮肤 ↓
+    var dstImage = core.getContextByName(ctx);
+    if (!dstImage) return;
+    // 绘制背景
+    dstImage.drawImage(background, 0, 0, 128, 128, x+2, y+2, w-4, h-4);
+    // 绘制边框
+    // 上方
+    dstImage.drawImage(background, 128, 0,     16,     16,      x,      y,     16,     16);
+    for (var dx = 0; dx < w - 64; dx += 32) {
+    dstImage.drawImage(background, 144, 0,     32,     16,x+dx+16,      y,     32,     16);
+    dstImage.drawImage(background, 144,48,     32,     16,x+dx+16, y+h-16,     32,     16);
+    }
+    dstImage.drawImage(background, 144, 0,w-dx-32,     16,x+dx+16,      y,w-dx-32,     16);
+    dstImage.drawImage(background, 144,48,w-dx-32,     16,x+dx+16, y+h-16,w-dx-32,     16);
+    dstImage.drawImage(background, 176, 0,     16,     16, x+w-16,      y,     16,     16);
+    // 左右
+    for (var dy = 0; dy < h - 64; dy += 32) {
+    dstImage.drawImage(background, 128,16,     16,     32,      x,y+dy+16,     16,     32);
+    dstImage.drawImage(background, 176,16,     16,     32, x+w-16,y+dy+16,     16,     32);
+    }
+    dstImage.drawImage(background, 128,16,     16,h-dy-32,      x,y+dy+16,     16,h-dy-32);
+    dstImage.drawImage(background, 176,16,     16,h-dy-32, x+w-16,y+dy+16,     16,h-dy-32);
+    // 下方
+    dstImage.drawImage(background, 128,48,     16,     16,      x, y+h-16,     16,     16);
+    dstImage.drawImage(background, 176,48,     16,     16, x+w-16, y+h-16,     16,     16);
+
+    // arrow
+    if(px != null && py != null){
+    	if(direction == 'up'){
+    		dstImage.drawImage(background,128,96,32,32,px,y+h-3,32,32);
+    	}else if(direction == 'down') {
+    		dstImage.drawImage(background,160,96,32,32,px,y-29,32,32);
+    	}
+    }
+    // 仿RM窗口皮肤 ↑
+}
+
+////// 绘制一个背景图，可绘制 winskin 或纯色背景；支持小箭头绘制
+ui.prototype.drawBackground = function (left, top, right, bottom, posInfo) {
+    posInfo = posInfo || {};
+    var px = posInfo.px == null ? null : posInfo.px * 32 - core.bigmap.offsetX;
+    var py = posInfo.py == null ? null : posInfo.py * 32 - core.bigmap.offsetY;
+    var xoffset = posInfo.xoffset || 0, yoffset = posInfo.yoffset || 0;
+    var background = core.status.textAttribute.background;
+
+    if (this._drawBackground_drawWindowSkin(background, left, top, right, bottom, posInfo.position, px, py))
+        return true;
+    if (typeof background == 'string') background = core.initStatus.textAttribute.background;
+    this._drawBackground_drawColor(background, left, top, right, bottom, posInfo.position, px, py, xoffset, yoffset);
+    return false;
+}
+
+ui.prototype._drawWindowSkin_getOpacity = function () {
+    return core.getFlag("__winskin_opacity__", 0.85);
+}
+
+ui.prototype._drawBackground_drawWindowSkin = function (background, left, top, right, bottom, position, px, py) {
+    if (typeof background == 'string' && core.material.images.images[background]) {
+        var image = core.material.images.images[background];
+        if (image.width==192 && image.height==128) {
+            core.setAlpha('ui', this._drawWindowSkin_getOpacity());
+            this.drawWindowSkin(image, 'ui', left, top, right - left, bottom - top, position, px, py);
+            core.setAlpha('ui', 1);
+            return true;
+        }
+    }
+    return false;
+}
+
+ui.prototype._drawBackground_drawColor = function (background, left, top, right, bottom, position, px, py, xoffset, yoffset) {
+    var alpha = background[3];
+    core.setAlpha('ui', alpha);
+    core.setStrokeStyle('ui', core.status.globalAttribute.borderColor);
+    core.setFillStyle('ui', core.arrayToRGB(background));
+    core.setLineWidth('ui', 2);
+    // 绘制
+    var ctx = core.canvas.ui;
+    ctx.beginPath();
+    ctx.moveTo(left, top);
+    // 上边缘三角
+    if (position == 'down' && px != null && py != null) {
+        ctx.lineTo(px + xoffset, top);
+        ctx.lineTo(px + 16, top - yoffset);
+        ctx.lineTo(px + 32 - xoffset, top);
+    }
+    ctx.lineTo(right, top);
+    ctx.lineTo(right, bottom);
+    // 下边缘三角
+    if (position == 'up' && px != null && py != null) {
+        ctx.lineTo(px + 32 - xoffset, bottom);
+        ctx.lineTo(px + 16, bottom + yoffset);
+        ctx.lineTo(px + xoffset, bottom);
+    }
+    ctx.lineTo(left, bottom);
+    ctx.closePath();
+    ctx.fill();
+    ctx.stroke();
+    core.setAlpha('ui', 1);
+}
+
+////// 计算有效文本框的宽度
+ui.prototype._calTextBoxWidth = function (ctx, content, min_width, max_width, font) {
+    // 无限长度自动换行
+    var allLines = core.splitLines(ctx, content, null, font);
+
+    // 如果不存在手动换行，尽量调成半行形式
+    if (allLines.length == 1) {
+        var w = core.calWidth(ctx, allLines[0]) + 10;
+        if (w<min_width*2.3) return core.clamp(w / 1.4, min_width, max_width);
+        if (w<max_width*2.2) return core.clamp(w / 2.4, min_width, max_width);
+        return core.clamp(w / 3.4, min_width, max_width);
+    }
+    // 存在手动换行：以最长的为准
+    else {
+        return core.clamp(allLines.reduce(function (pre, curr) {
+            return Math.max(pre, core.calWidth(ctx, curr) + 10);
+        }, 0), min_width, max_width);
+    }
+}
+
+////// 处理 \i[xxx] 的问题
+ui.prototype._getDrawableIconInfo = function (id) {
+    if (id && id.indexOf('flag:') === 0) {
+        id = core.getFlag(id.substring(5), id);
+    }
+    var image = null, icon = null;
+    ["terrains","animates","items","npcs","enemys"].forEach(function (v) {
+        if (core.material.icons[v][id] != null) {
+            image = core.material.images[v];
+            icon = core.material.icons[v][id];
+        }
+    });
+    if (image == null && id in core.statusBar.icons) {
+        image = core.statusBar.icons[id];
+        icon = 0;
+    }
+    return [image,icon];
+}
+
+ui.prototype._buildFont = function (fontSize, bold) {
+    var textAttribute = core.status.textAttribute || core.initStatus.textAttribute,
+        globalAttribute = core.status.globalAttribute || core.initStatus.globalAttribute;
+    if (bold == null) bold = textAttribute.bold;
+    return (bold?"bold ":"") + (fontSize || textAttribute.textfont) + "px " + globalAttribute.font;
+}
+
+////// 绘制一段文字到某个画布上面
+// ctx：要绘制到的画布
+// content：要绘制的内容；转义字符目前只允许留 \n, \r[...] 和 \i[...]
+// config：绘制配置项，目前暂时包含如下内容（均为可选）
+//         left, top：起始点位置；maxWidth：单行最大宽度；color：默认颜色；align：左中右
+//         fontSize：字体大小；lineHeight：行高；time：打字机间隔
+ui.prototype.drawTextContent = function (ctx, content, config) {
+    ctx = core.getContextByName(ctx);
+    if (!ctx) return;
+    // 设置默认配置项
+    var textAttribute = core.status.textAttribute || core.initStatus.textAttribute;
+    config = core.clone(config || {});
+    config.left = config.left || 0;
+    config.right = config.left + (config.maxWidth == null ? ctx.canvas.width : config.maxWidth);
+    config.top = config.top || 0;
+    config.color = config.color || core.arrayToRGBA(textAttribute.text);
+    if (config.bold == null) config.bold = textAttribute.bold;
+    config.align = config.align || textAttribute.align || "left";
+    config.fontSize = config.fontSize || textAttribute.textfont;
+    config.lineHeight = config.lineHeight || (config.fontSize * 1.3);
+    config.time = config.time || 0;
+
+    config.index = 0;
+    config.currcolor = config.color;
+    config.offsetX = 0;
+    config.offsetY = 0;
+    config.line = 0;
+    config.blocks = [];
+
+    // 创建一个新的临时画布
+    var tempCtx = core.bigmap.tempCanvas;
+    tempCtx.canvas.height = ctx.canvas.height;
+    tempCtx.canvas.width = ctx.canvas.width;
+    var _textBaseLine = tempCtx.textBaseline;
+    tempCtx.textBaseline = 'top';
+    tempCtx.font = this._buildFont(config.fontSize, config.bold);
+    tempCtx.fillStyle = config.color;
+    this._drawTextContent_draw(ctx, tempCtx, content, config);
+    tempCtx.textBaseline = _textBaseLine;
+}
+
+// 绘制的基本逻辑：
+// 1. 一个个字符绘制到对应画布上（靠左对齐）；这个过程中，记下来每个字对应的方块 [x, y, w, h]
+// 2. 每次换行时，计算当前行的宽度，然后如果是居中或者靠右对齐，则对当前行的每个小方块增加偏移量
+// 3. 实际绘制时，从临时画布直接将一个个小方块绘制到目标画布上，一次全部绘制，或者打字机效果一个个绘制
+ui.prototype._drawTextContent_draw = function (ctx, tempCtx, content, config) {
+    // Step 1: 绘制到tempCtx上，并记录下图块信息
+    while (this._drawTextContent_next(tempCtx, content, config));
+
+    // Step 2: 从tempCtx绘制到画布上
+    config.index = 0;
+    var _drawNext = function () {
+        if (config.index >= config.blocks.length) return false;
+        var block = config.blocks[config.index++];
+        ctx.drawImage(tempCtx.canvas, block.left, block.top, block.width, block.height,
+            config.left + block.left + block.marginLeft, config.top + block.top, block.width, block.height);
+        return true;
+    }
+    if (config.time == 0) {
+        while (_drawNext());
+    }
+    else {
+        core.status.event.interval = setInterval(function () {
+            if (!_drawNext()) {
+                clearInterval(core.status.event.interval);
+                core.status.event.interval = null;
+            }
+        }, config.time);
+    }
+}
+
+ui.prototype._drawTextContent_next = function (tempCtx, content, config) {
+    if (config.index >= content.length) {
+        this._drawTextContent_newLine(tempCtx, config);
+        return false;
+    }
+    // get next character
+    var ch = content.charAt(config.index++);
+    return this._drawTextContent_drawChar(tempCtx, content, config, ch);
+}
+
+// 绘制下一个字符
+ui.prototype._drawTextContent_drawChar = function (tempCtx, content, config, ch) {
+    // \n, \\n
+    if (ch == '\n' || (ch=='\\' && content.charAt(config.index)=='n')) {
+        this._drawTextContent_newLine(tempCtx, config);
+        if (ch=='\\') config.index++;
+        return this._drawTextContent_next(tempCtx, content, config);
+    }
+    // \r, \\r
+    if (ch == '\r' || (ch=='\\' && content.charAt(config.index)=='r')) {
+        if (ch == '\\') config.index++;
+        return this._drawTextContent_changeColor(tempCtx, content, config);
+    }
+    // \\i 绘制图标
+    if (ch == '\\' && content.charAt(config.index)=='i') {
+        return this._drawTextContent_drawIcon(tempCtx, content, config);
+    }
+    // 检查是不是自动换行
+    var charwidth = core.calWidth(tempCtx, ch);
+    if (config.maxWidth != null && config.offsetX + charwidth > config.maxWidth) {
+        this._drawTextContent_newLine(tempCtx, config);
+        config.index--;
+        return this._drawTextContent_next(tempCtx, content, config);
+    }
+    // 输出
+    var left = config.offsetX, top = config.offsetY + (config.lineHeight - config.fontSize) / 2;
+    core.fillText(tempCtx, ch, left, top);
+    config.blocks.push({left: config.offsetX, top: config.offsetY,
+        width: charwidth, height: config.lineHeight, line: config.line, marginLeft: 0});
+    config.offsetX += charwidth;
+    return true;
+}
+
+ui.prototype._drawTextContent_newLine = function (tempCtx, config) {
+    // 计算偏移量
+    var width = config.offsetX, totalWidth = config.right - config.left;
+    var marginLeft = 0;
+    if (config.align == 'center')
+        marginLeft = (totalWidth - width) / 2;
+    else if (config.align == 'right')
+        marginLeft = totalWidth - width;
+
+    config.blocks.forEach(function (b) {
+        if (b.line == config.line)
+            b.marginLeft = marginLeft;
+    });
+
+    config.offsetX = 0;
+    config.offsetY += config.lineHeight;
+    config.line++;
+}
+
+ui.prototype._drawTextContent_changeColor = function (tempCtx, content, config) {
+    // 检查是不是 []
+    var index = config.index, index2;
+    if (content.charAt(index) == '[' && ((index2=content.indexOf(']', index))>=0)) {
+        // 变色
+        var str = content.substring(index+1, index2);
+        if (str=="") tempCtx.fillStyle = config.color;
+        else tempCtx.fillStyle = str;
+        config.index = index2 + 1;
+    }
+    else tempCtx.fillStyle = config.color;
+    return this._drawTextContent_next(tempCtx, content, config);
+}
+
+ui.prototype._drawTextContent_drawIcon = function (tempCtx, content, config) {
+    // 绘制一个 \i 效果
+    var index = config.index, index2;
+    if (content.charAt(config.index+1) == '[' && ((index2=content.indexOf(']', index+1))>=0)) {
+        var str = content.substring(index+2, index2);
+        // --- 获得图标
+        var iconInfo = core.ui._getDrawableIconInfo(str), image = iconInfo[0], icon = iconInfo[1];
+        if (image == null) return this._drawTextContent_next(tempCtx, content, config);
+        // 检查自动换行
+        var width = config.fontSize + 2, left = config.offsetX + 2, top = config.offsetY + (config.lineHeight - width) / 2 - 1;
+        if (config.maxWidth != null && left + width > config.maxWidth) {
+            this._drawTextContent_newLine(tempCtx, config);
+            config.index--;
+            this._drawTextContent_next(tempCtx, content, config);
+        }
+        // 绘制到画布上
+        core.drawImage(tempCtx, image, 0, 32*icon, 32, 32, left, top, width, width);
+
+        config.blocks.push({left: left, top: config.offsetY,
+            width: config.lineHeight, height: config.lineHeight, line: config.line, marginLeft: 0});
+
+        config.offsetX += width + 6;
+        config.index = index2 + 1;
+        return true;
+    }
+    return this._drawTextContent_next(tempCtx, content, config);
+}
+
+ui.prototype._getRealContent = function (content) {
+    return content.replace(/(\r|\\r)(\[.*?])?/g, "").replace(/(\\i)(\[.*?])?/g, "占1");
 }
 
 ////// 绘制一个对话框 //////
-ui.prototype.drawTextBox = function(content) {
+ui.prototype.drawTextBox = function(content, showAll) {
+    if (core.status.event && core.status.event.id == 'action')
+        core.status.event.ui = content;
 
-    clearInterval(core.status.event.interval);
-
-    // 获得name, image, icon
-    var id=null, name=null, image=null, icon=null, iconHeight=32, animate=null;
-    if (content.indexOf("\t[")==0 || content.indexOf("\\t[")==0) {
-        var index = content.indexOf("]");
-        if (index>=0) {
-            var str=content.substring(2, index);
-            if (content.indexOf("\\t[")==0) str=content.substring(3, index);
-            content=content.substring(index+1);
-            var ss=str.split(",");
-            if (ss.length==1) {
-                // id
-                id=ss[0];
-                if (id=='hero') {
-                    name = core.status.hero.name;
-                }
-                else {
-                    if (core.isset(core.material.enemys[id])) {
-                        name = core.material.enemys[id].name;
-
-                        if (core.isset(core.material.icons.enemy48[id])) {
-                            image = core.material.images.enemy48;
-                            icon = core.material.icons.enemy48[id];
-                            iconHeight = 48;
-                            animate=4;
-                        }
-                        else {
-                            image = core.material.images.enemys;
-                            icon = core.material.icons.enemys[id];
-                            iconHeight = 32;
-                            animate=2;
-                        }
-                    }
-                    else {
-                        name=id;
-                        id='npc';
-                        image=null;
-                        icon=null;
-                    }
-                }
-            }
-            else {
-                name=ss[0];
-                id = 'npc';
-                if (ss[1]=='hero') {
-                    id = 'hero';
-                }
-                else if (core.isset(core.material.icons.npc48[ss[1]])) {
-                    image = core.material.images.npc48;
-                    icon = core.material.icons.npc48[ss[1]];
-                    iconHeight = 48;
-                    animate=4;
-                }
-                else if (core.isset(core.material.icons.npcs[ss[1]])){
-                    image = core.material.images.npcs;
-                    icon = core.material.icons.npcs[ss[1]];
-                    iconHeight = 32;
-                    animate=2;
-                }
-                else if (core.isset(core.material.icons.enemy48[ss[1]])) {
-                    image = core.material.images.enemy48;
-                    icon = core.material.icons.enemy48[ss[1]];
-                    iconHeight = 48;
-                    animate=4;
-                }
-                else if (core.isset(core.material.icons.enemys[ss[1]])) {
-                    image = core.material.images.enemys;
-                    icon = core.material.icons.enemys[ss[1]];
-                    iconHeight = 32;
-                    animate=2;
-                }
-            }
-        }
-    }
-
-    // 获得位置信息
-
-    var textAttribute = core.status.textAttribute || core.initStatus.textAttribute;
-
-    var position = textAttribute.position, px=null, py=null, ydelta=iconHeight-32;
-    if (content.indexOf("\b[")==0 || content.indexOf("\\b[")==0) {
-        var index = content.indexOf("]");
-        if (index>=0) {
-            var str = content.substring(2, index);
-            if (content.indexOf("\\b[")==0) str = content.substring(3, index);
-            content = content.substring(index + 1);
-
-            var ss=str.split(",");
-
-            if (ss[0]=='up' || ss[0]=='center' || ss[0]=='down') {
-                position=ss[0];
-                if (core.status.event.id=='action') {
-                    px = core.status.event.data.x;
-                    py = core.status.event.data.y;
-                }
-
-                if (ss.length>=2) {
-                    if (ss[1]=='hero') {
-                        px=core.getHeroLoc('x');
-                        py=core.getHeroLoc('y');
-                        ydelta = core.material.icons.hero.height-32;
-                    }
-                    else if (ss.length>=3) {
-                        px=parseInt(ss[1]);
-                        py=parseInt(ss[2]);
-                    }
-                }
-            }
-        }
-    }
+    this.clearUI();
 
     content = core.replaceText(content);
 
-    var background = core.canvas.ui.createPattern(core.material.ground, "repeat");
-    core.status.boxAnimateObjs = [];
-    core.clearMap('ui');
+    // Step 1: 获得标题信息和位置信息
+    var textAttribute = core.status.textAttribute;
+    var titleInfo = this._getTitleAndIcon(content);
+    var posInfo = this._getPosition(titleInfo.content);
+    if (posInfo.position != 'up' && posInfo.position != 'down') posInfo.px = posInfo.py = null;
+    if (!posInfo.position) posInfo.position = textAttribute.position;
+    content = this._drawTextBox_drawImages(posInfo.content);
 
-    // var contents = content.split('\n');
-    // var contents = core.splitLines('ui', content, );
-    var left=10, right=416-2*left;
-    var content_left = left + 25;
-    if (id=='hero' || core.isset(icon)) content_left=left+63;
+    // Step 2: 计算对话框的矩形位置
+    var hPos = this._drawTextBox_getHorizontalPosition(content, titleInfo, posInfo);
+    var vPos = this._drawTextBox_getVerticalPosition(content, titleInfo, posInfo, hPos.validWidth);
 
-    var validWidth = right-(content_left-left)-13;
-    var font = '16px Verdana';
-    if (textAttribute.bold) font = "bold "+font;
-    var contents = core.splitLines("ui", content, validWidth, font);
+    // Step 3: 绘制背景图
+    var pInfo = core.clone(posInfo);
+    pInfo.xoffset = hPos.xoffset; pInfo.yoffset = vPos.yoffset - 4;
+    var isWindowSkin = this.drawBackground(hPos.left, vPos.top, hPos.right, vPos.bottom, pInfo);
+    var alpha = isWindowSkin ? this._drawWindowSkin_getOpacity() : textAttribute.background[3];
 
-    var height = 20 + 21*(contents.length+1) + (id=='hero'?core.material.icons.hero.height-10:core.isset(name)?iconHeight-10:0);
+    // Step 4: 绘制标题、头像、动画
+    var content_top = this._drawTextBox_drawTitleAndIcon(titleInfo, hPos, vPos, alpha);
 
+    // Step 5: 绘制正文
+    this.drawTextContent('ui', content, {
+        left: hPos.content_left, top: content_top, maxWidth: hPos.validWidth,
+        lineHeight: vPos.lineHeight, time: (showAll || textAttribute.time<=0 || core.status.event.id!='action')?0:textAttribute.time
+    });
+}
 
-    var xoffset = 6, yoffset = 22;
+ui.prototype._drawTextBox_drawImages = function (content) {
+    return content.replace(/(\f|\\f)\[(.*?)]/g, function (text, sympol, str) {
+        var ss = str.split(",");
+        if (ss.length!=3 && ss.length!=5 && ss.length!=9) return "";
+        ss[0] = core.getMappedName(ss[0]);
+        var img = core.material.images.images[ss[0]];
+        if (!img) return "";
+        // 绘制
+        if (ss.length==3)
+            core.drawImage('ui', img, parseFloat(ss[1]), parseFloat(ss[2]));
+        else if (ss.length==5)
+            core.drawImage('ui', img, 0, 0, img.width, img.height, parseFloat(ss[1]), parseFloat(ss[2]), parseFloat(ss[3]), parseFloat(ss[4]));
+        else if (ss.length==9)
+            core.drawImage('ui', img, parseFloat(ss[1]), parseFloat(ss[2]), parseFloat(ss[3]), parseFloat(ss[4]), parseFloat(ss[5]), parseFloat(ss[6]), parseFloat(ss[7]), parseFloat(ss[8]));
+        return "";
+    });
+}
 
-    var top;
-    if (position=='center') {
-        top = parseInt((416 - height) / 2);
+ui.prototype._drawTextBox_getHorizontalPosition = function (content, titleInfo, posInfo) {
+    var realContent = this._getRealContent(content);
+    var paddingLeft = 25, paddingRight = 12;
+    if (posInfo.px != null && posInfo.py != null) paddingLeft = 20;
+    if (titleInfo.icon != null) paddingLeft = 62; // 15 + 32 + 15
+    else if (titleInfo.image) paddingLeft = 90; // 10 + 70 + 10
+    var left = 7 + 3 * (this.HSIZE - 6), right = this.PIXEL - left,
+        width = right - left, validWidth = width - paddingLeft - paddingRight;
+    // 对话框效果：改为动态计算
+    if (posInfo.px != null && posInfo.py != null) {
+        var min_width = 220 - paddingLeft, max_width = validWidth;
+        // 无行走图或头像，则可以适当缩小min_width
+        if (titleInfo.image == null) min_width = 160;
+        validWidth = this._calTextBoxWidth('ui', realContent, min_width, max_width, this._buildFont());
+        width = validWidth + paddingLeft + paddingRight;
+        left = core.clamp(32 * posInfo.px + 16 - width / 2 - core.bigmap.offsetX, left, right - width);
+        right = left + width;
     }
-    else if (position=='up') {
-        if (px==null || py==null) {
-            top = 5;
-        }
-        else {
-            top = 32 * py - height - ydelta - yoffset;
-        }
+    return { left: left, right: right, width: width, validWidth: validWidth, xoffset: 11, content_left: left + paddingLeft };
+}
+
+ui.prototype._drawTextBox_getVerticalPosition = function (content, titleInfo, posInfo, validWidth) {
+    var textAttribute = core.status.textAttribute || core.initStatus.textAttribute;
+    var lineHeight = textAttribute.textfont + 5;
+    var realContent = this._getRealContent(content);
+    var height = 30 + lineHeight * core.splitLines("ui", realContent, validWidth, this._buildFont()).length;
+    if (titleInfo.title) height += textAttribute.titlefont + 5;
+    if (titleInfo.icon != null) {
+        if (titleInfo.title) height = Math.max(height, titleInfo.height+50);
+        else height = Math.max(height, titleInfo.height + 30);
     }
-    else if (position=='down') {
-        if (px==null || py==null) {
-            top = 416 - height - 5;
-        }
-        else {
-            top = 32 * py + 32 + yoffset;
-        }
+    else if (titleInfo.image)
+        height = Math.max(height, 90);
+
+    var yoffset = 16;
+    var top = parseInt((this.PIXEL - height) / 2);
+    switch (posInfo.position) {
+        case 'center': top = parseInt((this.PIXEL - height) / 2); break;
+        case 'up':
+            if (posInfo.px==null || posInfo.py==null)
+                top = 5 + textAttribute.offset;
+            else
+                top = 32 * posInfo.py - height - (titleInfo.height - 32) - yoffset - core.bigmap.offsetY;
+            break;
+        case 'down':
+            if (posInfo.px==null || posInfo.py==null)
+                top = this.PIXEL - height - 5 - textAttribute.offset;
+            else {
+                top = 32 * posInfo.py + 32 + yoffset - core.bigmap.offsetY;
+            }
     }
 
-    // var left = 97, top = 64, right = 416 - 2 * left, bottom = 416 - 2 * top;
-    //core.setAlpha('ui', 0.85);
+    return { top: top, height: height, bottom: top + height, yoffset: yoffset, lineHeight: lineHeight };
+}
 
-    var borderColor = main.borderColor||"#FFFFFF";
-
-    core.setAlpha('ui', textAttribute.background[3]);
-    core.setFillStyle('ui', core.arrayToRGB(textAttribute.background));
-    core.setStrokeStyle('ui', borderColor);
-
-
-    core.fillRect('ui', left, top, right, height);
-    core.strokeRect('ui', left - 1, top - 1, right + 1, height + 1, borderColor, 2);
-
-    var xoffset = 9;
-
-    // draw triangle
-    if (position=='up' && core.isset(px) && core.isset(py)) {
-        core.canvas.ui.clearRect(32*px+xoffset, top+height-1, 32-2*xoffset, 2);
-        core.canvas.ui.beginPath();
-        core.canvas.ui.moveTo(32*px+xoffset-1, top+height-1);
-        core.canvas.ui.lineTo(32*px+16, top+height+yoffset-2);
-        core.canvas.ui.lineTo(32*px+32-xoffset+1, top+height-1);
-        core.canvas.ui.moveTo(32*px+xoffset-1, top+height-1);
-        core.canvas.ui.closePath();
-        core.canvas.ui.fill();
-        // core.canvas.ui.stroke();
-        // core.drawLine('ui', 32*px+4+1, top+height+1, 32*px + 28-1, top+height+1, core.arrayToRGB(textAttribute.background), 3);
-        core.drawLine('ui', 32*px+xoffset, top+height, 32*px+16, top+height+yoffset-2);
-        core.drawLine('ui', 32*px+32-xoffset, top+height, 32*px+16, top+height+yoffset-2);
-    }
-    if (position=='down' && core.isset(px) && core.isset(py)) {
-        core.canvas.ui.clearRect(32*px+xoffset, top-2, 32-2*xoffset, 3);
-        core.canvas.ui.beginPath();
-        core.canvas.ui.moveTo(32*px+xoffset-1, top+1);
-        core.canvas.ui.lineTo(32*px+16-1, top-yoffset+2);
-        core.canvas.ui.lineTo(32*px+32-xoffset-1, top+1);
-        core.canvas.ui.moveTo(32*px+xoffset-1, top+1);
-        core.canvas.ui.closePath();
-        core.canvas.ui.fill();
-        // core.canvas.ui.stroke();
-        // core.drawLine('ui', 32*px+4+1, top+height+1, 32*px + 28-1, top+height+1, core.arrayToRGB(textAttribute.background), 3);
-        core.drawLine('ui', 32*px+xoffset, top, 32*px+16, top-yoffset+2);
-        core.drawLine('ui', 32*px+32-xoffset, top, 32*px+16, top-yoffset+2);
-    }
-
-
-    // 名称
-    core.canvas.ui.textAlign = "left";
-
-    var content_top = top + 35;
-    if (core.isset(id)) {
-
-        content_top = top+57;
-        core.setAlpha('ui', textAttribute.title[3]);
+ui.prototype._drawTextBox_drawTitleAndIcon = function (titleInfo, hPos, vPos, alpha) {
+    core.setTextAlign('ui', 'left');
+    var textAttribute = core.status.textAttribute;
+    var content_top = vPos.top + 15;
+    var image_top = vPos.top + 15;
+    if (titleInfo.title != null) {
+        var titlefont = textAttribute.titlefont;
+        content_top += titlefont + 5;
+        image_top = vPos.top + 40;
         core.setFillStyle('ui', core.arrayToRGB(textAttribute.title));
         core.setStrokeStyle('ui', core.arrayToRGB(textAttribute.title));
 
-        if (id == 'hero') {
-            var heroHeight=core.material.icons.hero.height;
-            core.strokeRect('ui', left + 15 - 1, top + 40 - 1, 34, heroHeight+2, borderColor, 2);
-            core.fillText('ui', name, content_left, top + 30, null, 'bold 22px Verdana');
-            core.clearMap('ui', left + 15, top + 40, 32, heroHeight);
-            core.fillRect('ui', left + 15, top + 40, 32, heroHeight, background);
-            var heroIcon = core.material.icons.hero['down'];
-            core.canvas.ui.drawImage(core.material.images.hero, heroIcon.stop * 32, heroIcon.loc * heroHeight, 32, heroHeight, left+15, top+40, 32, heroHeight);
+        // --- title也要居中或者右对齐？
+        var title_width = core.calWidth('ui', titleInfo.title, this._buildFont(titlefont, true));
+        var title_left = hPos.content_left;
+        if (textAttribute.align == 'center')
+            title_left = hPos.left + (hPos.width - title_width) / 2;
+        else if (textAttribute.align == 'right')
+            title_left = hPos.right - title_width - 12;
+
+        core.fillText('ui', titleInfo.title, title_left, vPos.top + 8 + titlefont);
+    }
+    if (titleInfo.icon != null) {
+        core.setAlpha('ui', alpha);
+        core.strokeRect('ui', hPos.left + 15 - 1, image_top-1, 34, titleInfo.height + 2, null, 2);
+        core.setAlpha('ui', 1);
+        core.status.boxAnimateObjs = [];
+        // --- 勇士
+        if (titleInfo.image == core.material.images.hero) {
+            core.clearMap('ui', hPos.left + 15, image_top, 32, titleInfo.height);
+            core.fillRect('ui', hPos.left + 15, image_top, 32, titleInfo.height, core.material.groundPattern);
+            core.drawImage('ui', titleInfo.image, 0, 0, core.material.icons.hero.width || 32, core.material.icons.hero.height,
+                hPos.left + 15, image_top, 32, titleInfo.height);
         }
         else {
-            core.fillText('ui', name, content_left, top + 30, null, 'bold 22px Verdana');
-            if (core.isset(icon)) {
-
-                core.strokeRect('ui', left + 15 - 1, top + 40 - 1, 34, iconHeight + 2, borderColor, 2);
-                core.status.boxAnimateObjs = [];
-                core.status.boxAnimateObjs.push({
-                    'bgx': left + 15, 'bgy': top + 40, 'bgWidth': 32, 'bgHeight': iconHeight,
-                    'x': left+15, 'y': top+40, 'height': iconHeight, 'animate': animate,
-                    'image': image,
-                    'pos': icon*iconHeight
-                });
-
-                core.drawBoxAnimate();
-            }
+            core.status.boxAnimateObjs.push({
+                'bgx': hPos.left + 15, 'bgy': image_top, 'bgWidth': 32, 'bgHeight': titleInfo.height,
+                'x': hPos.left + 15, 'y': image_top, 'height': titleInfo.height, 'animate': titleInfo.animate,
+                'image': titleInfo.image, 'pos': titleInfo.icon * titleInfo.height
+            });
         }
+        core.drawBoxAnimate();
     }
+    if (titleInfo.image != null && titleInfo.icon == null) { // 头像图
+        core.drawImage('ui', titleInfo.image, 0, 0, titleInfo.image.width, titleInfo.image.height,
+            hPos.left+10, vPos.top+10, 70, 70);
+    }
+    return content_top;
+}
 
+ui.prototype._createTextCanvas = function (content, lineHeight) {
+    var realContent = this._getRealContent(content);
+    var lines = core.splitLines('ui', realContent, null, this._buildFont());
+    var width = this.PIXEL, height = lines.length * lineHeight;
+    var ctx = document.createElement('canvas').getContext('2d');
+    ctx.canvas.width = width;
+    ctx.canvas.height = height;
+    ctx.clearRect(0, 0, width, height);
+    return ctx;
+}
 
-    var drawContent = function (content) {
+////// 绘制滚动字幕 //////
+ui.prototype.drawScrollText = function (content, time, lineHeight, callback) {
+    content = core.replaceText(content || "");
+    lineHeight = lineHeight || 1.4;
+    time = time || 5000;
+    this.clearUI();
+    var offset = core.status.textAttribute.offset || 15;
+    lineHeight *= core.status.textAttribute.textfont;
+    var ctx = this._createTextCanvas(content, lineHeight);
+    var obj = { align: core.status.textAttribute.align, lineHeight: lineHeight };
+    if (obj.align == 'right') obj.left = this.PIXEL - offset;
+    else if (obj.align != 'center') obj.left = offset;
+    this.drawTextContent(ctx, content, obj);
+    this._drawScrollText_animate(ctx, time, callback);
+}
 
-        core.clearMap("ui", content_left, content_top - 18, validWidth,  top + height - content_top + 10);
-        core.setAlpha('ui', textAttribute.background[3]);
-        core.setFillStyle('ui', core.arrayToRGB(textAttribute.background));
-        core.fillRect("ui",  content_left, content_top - 18, validWidth,  top + height - content_top + 10);
-
-        core.setAlpha('ui', textAttribute.text[3]);
-        core.setFillStyle('ui', core.arrayToRGB(textAttribute.text));
-        var contents = core.splitLines("ui", content, validWidth, font);
-
-        for (var i=0;i<contents.length;i++) {
-            core.fillText('ui', contents[i], content_left, content_top + 21*i, null, font);
+ui.prototype._drawScrollText_animate = function (ctx, time, callback) {
+    // 开始绘制到UI上
+    time /= Math.max(core.status.replay.speed, 1)
+    var per_pixel = 1, height = ctx.canvas.height, per_time = time * per_pixel / (this.PIXEL+height);
+    var currH = this.PIXEL;
+    core.drawImage('ui', ctx.canvas, 0, currH);
+    var animate = setInterval(function () {
+        core.clearMap('ui');
+        currH -= per_pixel;
+        if (currH < -height) {
+            delete core.animateFrame.asyncId[animate];
+            clearInterval(animate);
+            if (core.isset(callback)) callback();
+            return;
         }
+        core.drawImage('ui', ctx.canvas, 0, currH);
+    }, per_time);
 
-    }
-
-    if (textAttribute.time<=0 || core.status.event.id!='action') {
-        drawContent(content);
-    }
-    else {
-        var index=0;
-        core.status.event.interval = setInterval(function () {
-            drawContent(content.substring(0, ++index));
-            if (index==content.length) {
-                clearInterval(core.status.event.interval);
-            }
-        }, textAttribute.time);
-    }
+    core.animateFrame.asyncId[animate] = true;
+}
 
+////// 文本图片化 //////
+ui.prototype.textImage = function (content, lineHeight) {
+    content = core.replaceText(content || "");
+    lineHeight = lineHeight || 1.4;
+    lineHeight *= core.status.textAttribute.textfont;
+    var ctx = this._createTextCanvas(content, lineHeight);
+    this.drawTextContent(ctx, content, { align: core.status.textAttribute.align, lineHeight: lineHeight });
+    return ctx.canvas;
 }
 
 ////// 绘制一个选项界面 //////
 ui.prototype.drawChoices = function(content, choices) {
-
-    var background = core.canvas.ui.createPattern(core.material.ground, "repeat");
-
-    core.clearMap('ui');
-    core.setAlpha('ui', 1);
-    core.setFillStyle('ui', background);
+    choices = core.clone(choices || []);
 
     core.status.event.ui = {"text": content, "choices": choices};
+    this.clearUI();
 
-    // Step 1: 计算长宽高
-    var length = choices.length;
-    var left=85, width = 416-2*left; // 宽度
-    // 高度
-    var height = 32*(length+2), bottom = 208+height/2;
-    if (length%2==0) bottom+=16;
-    var choice_top = bottom-height+56;
+    content = core.replaceText(content || "");
+    var titleInfo = this._getTitleAndIcon(content);
+    titleInfo.content = this._drawTextBox_drawImages(titleInfo.content);
+    var hPos = this._drawChoices_getHorizontalPosition(titleInfo, choices);
+    var vPos = this._drawChoices_getVerticalPosition(titleInfo, choices, hPos);
+    core.status.event.ui.offset = vPos.offset;
 
-    var id=null, name=null, image=null, icon=null, iconHeight=32, animate=null;
+    var isWindowSkin = this.drawBackground(hPos.left, vPos.top, hPos.right, vPos.bottom);
+    this._drawChoices_drawTitle(titleInfo, hPos, vPos);
+    this._drawChoices_drawChoices(choices, isWindowSkin, hPos, vPos);
+}
 
-    var contents = null;
-    var content_left = left + 15;
-
-    if (core.isset(content)) {
-        // 获得name, image, icon
-        if (content.indexOf("\t[")==0 || content.indexOf("\\t[")==0) {
-            var index = content.indexOf("]");
-            if (index>=0) {
-                var str=content.substring(2, index);
-                if (content.indexOf("\\t[")==0) str=content.substring(3, index);
-                content=content.substring(index+1);
-                var ss=str.split(",");
-                if (ss.length==1) {
-                    // id
-                    id=ss[0];
-                    if (id=='hero') {
-                        name = core.status.hero.name;
-                    }
-                    else {
-                        if (core.isset(core.material.enemys[id])) {
-                            name = core.material.enemys[id].name;
-
-                            if (core.isset(core.material.icons.enemy48[id])) {
-                                image = core.material.images.enemy48;
-                                icon = core.material.icons.enemy48[id];
-                                iconHeight = 48;
-                                animate=4;
-                            }
-                            else {
-                                image = core.material.images.enemys;
-                                icon = core.material.icons.enemys[id];
-                                iconHeight = 32;
-                                animate=2;
-                            }
-                        }
-                        else {
-                            name=id;
-                            id='npc';
-                            image=null;
-                            icon=null;
-                        }
-                    }
-                }
-                else {
-                    name=ss[0];
-                    id = 'npc';
-                    if (ss[1]=='hero') {
-                        id = 'hero';
-                    }
-                    else if (core.isset(core.material.icons.npc48[ss[1]])) {
-                        image = core.material.images.npc48;
-                        icon = core.material.icons.npc48[ss[1]];
-                        iconHeight = 48;
-                        animate=4;
-                    }
-                    else if (core.isset(core.material.icons.npcs[ss[1]])){
-                        image = core.material.images.npcs;
-                        icon = core.material.icons.npcs[ss[1]];
-                        iconHeight = 32;
-                        animate=2;
-                    }
-                    else if (core.isset(core.material.icons.enemy48[ss[1]])) {
-                        image = core.material.images.enemy48;
-                        icon = core.material.icons.enemy48[ss[1]];
-                        iconHeight = 48;
-                        animate=4;
-                    }
-                    else if (core.isset(core.material.icons.enemys[ss[1]])) {
-                        image = core.material.images.enemys;
-                        icon = core.material.icons.enemys[ss[1]];
-                        iconHeight = 32;
-                        animate=2;
-                    }
-                }
-            }
-        }
-        content = core.replaceText(content);
-
-        if (id=='hero' || core.isset(icon))
-            content_left = left+60;
-
-        contents = core.splitLines('ui', content, width-(content_left-left)-10, 'bold 15px Verdana');
-
-        // content部分高度
-        var cheight=0;
-        // 如果含有标题，标题高度
-        if (name!=null) cheight+=25;
-        cheight += contents.length*20;
-        height+=cheight;
-    }
-    var top = bottom-height;
-
-    var borderColor = main.borderColor||"#FFFFFF";
-
-    core.fillRect('ui', left, top, width, height, background);
-    core.strokeRect('ui', left - 1, top - 1, width + 1, height + 1, borderColor, 2);
-
-    // 如果有内容
-    if (core.isset(contents)) {
-
-        var content_top = top + 35;
-
-        if (core.isset(id)) {
-            core.canvas.ui.textAlign = "center";
-
-            content_top = top+55;
-            var title_offset = left+width/2;
-            // 动画
-            if (id=='hero' || core.isset(icon))
-                title_offset += 22;
-
-            if (id == 'hero') {
-                var heroHeight = core.material.icons.hero.height;
-                core.strokeRect('ui', left + 15 - 1, top + 30 - 1, 34, heroHeight+2, '#DDDDDD', 2);
-                core.fillText('ui', name, title_offset, top + 27, '#FFD700', 'bold 19px Verdana');
-                core.clearMap('ui', left + 15, top + 30, 32, heroHeight);
-                core.fillRect('ui', left + 15, top + 30, 32, heroHeight, background);
-                var heroIcon = core.material.icons.hero['down'];
-                core.canvas.ui.drawImage(core.material.images.hero, heroIcon.stop * 32, heroIcon.loc *heroHeight, 32, heroHeight, left+15, top+30, 32, heroHeight);
-            }
-            else {
-                core.fillText('ui', name, title_offset, top + 27, '#FFD700', 'bold 19px Verdana');
-                if (core.isset(icon)) {
-                    core.strokeRect('ui', left + 15 - 1, top + 30 - 1, 34, iconHeight + 2, '#DDDDDD', 2);
-                    core.status.boxAnimateObjs = [];
-                    core.status.boxAnimateObjs.push({
-                        'bgx': left + 15, 'bgy': top + 30, 'bgWidth': 32, 'bgHeight': iconHeight,
-                        'x': left+15, 'y': top+30, 'height': iconHeight, 'animate': animate,
-                        'image': image,
-                        'pos': icon*iconHeight
-                    });
-                    core.drawBoxAnimate();
-                }
-            }
-        }
-
-        core.canvas.ui.textAlign = "left";
-        for (var i=0;i<contents.length;i++) {
-            core.fillText('ui', contents[i], content_left, content_top, '#FFFFFF', 'bold 15px Verdana');
-            content_top+=20;
-        }
-    }
-
-    // 选项
-    core.canvas.ui.textAlign = "center";
+ui.prototype._drawChoices_getHorizontalPosition = function (titleInfo, choices) {
+    // 宽度计算：考虑选项的长度
+    var width = 246;
+    core.setFont('ui', this._buildFont(17, true));
     for (var i = 0; i < choices.length; i++) {
-        core.fillText('ui', core.replaceText(choices[i].text || choices[i]), 208, choice_top + 32 * i, "#FFFFFF", "bold 17px Verdana");
+        if (typeof choices[i] === 'string')
+            choices[i] = {"text": choices[i]};
+        choices[i].text = core.replaceText(choices[i].text);
+        choices[i].width = core.calWidth('ui', core.replaceText(choices[i].text));
+        if (choices[i].icon != null) choices[i].width += 28;
+        width = Math.max(width, choices[i].width+30);
+    }
+    var left = (this.PIXEL - width) / 2, right = left + width;
+    var content_left = left + (titleInfo.icon == null ? 15: 60), validWidth = right - content_left - 10;
+
+    return { left: left, right: right, width: width, content_left: content_left, validWidth: validWidth };
+}
+
+ui.prototype._drawChoices_getVerticalPosition = function (titleInfo, choices, hPos) {
+    var length = choices.length;
+    var height = 32 * (length + 2), bottom = this.HPIXEL + height / 2;
+    if (length % 2 == 0) bottom += 16;
+    var offset = 0;
+    var choice_top = bottom - height + 56;
+    if (titleInfo.content) {
+        var headHeight = 0;
+        var realContent = this._getRealContent(titleInfo.content);
+        var lines = core.splitLines('ui', realContent, hPos.validWidth, this._buildFont(15, true));
+        if (titleInfo.title) headHeight += 25;
+        headHeight += lines.length * 20;
+        height += headHeight;
+        if (bottom - height <= 32) {
+            offset = Math.floor(headHeight / 64);
+            bottom += 32 * offset;
+            choice_top += 32 * offset;
+        }
+    }
+    return {top: bottom - height, height: height, bottom: bottom, choice_top: choice_top, offset: offset };
+}
+
+ui.prototype._drawChoices_drawTitle = function (titleInfo, hPos, vPos) {
+    if (!titleInfo.content) return;
+    var content_top = vPos.top + 21;
+    if (titleInfo.title != null) {
+        core.setTextAlign('ui', 'center');
+
+        content_top = vPos.top + 41;
+        var title_offset = hPos.left+hPos.width/2;
+        // 动画
+
+        if (titleInfo.icon != null) {
+            title_offset += 12;
+            core.strokeRect('ui', hPos.left + 15 - 1, vPos.top + 30 - 1, 34, titleInfo.height + 2, '#DDDDDD', 2);
+            core.status.boxAnimateObjs = [];
+            core.status.boxAnimateObjs.push({
+                'bgx': hPos.left + 15, 'bgy': vPos.top + 30, 'bgWidth': 32, 'bgHeight': titleInfo.height,
+                'x': hPos.left + 15, 'y': vPos.top + 30, 'height': titleInfo.height, 'animate': titleInfo.animate,
+                'image': titleInfo.image, 'pos': titleInfo.icon * titleInfo.height
+            });
+            core.drawBoxAnimate();
+        };
+
+        core.fillText('ui', titleInfo.title, title_offset, vPos.top + 27,
+            core.arrayToRGBA(core.status.textAttribute.title), this._buildFont(19, true));
+    }
+
+    core.setTextAlign('ui', 'left');
+    this.drawTextContent('ui', titleInfo.content, {
+        left: hPos.content_left, top: content_top, maxWidth: hPos.validWidth,
+        fontSize: 15, lineHeight: 20, bold: true
+    });
+}
+
+ui.prototype._drawChoices_drawChoices = function (choices, isWindowSkin, hPos, vPos) {
+    // 选项
+    core.setTextAlign('ui', 'center');
+    core.setFont('ui', this._buildFont(17, true));
+    for (var i = 0; i < choices.length; i++) {
+        var color = choices[i].color || core.status.textAttribute.text;
+        if (color instanceof Array) color = core.arrayToRGBA(color);
+        core.setFillStyle('ui', color);
+        var offset = this.HPIXEL;
+        if (core.isset(choices[i].icon)) {
+            var iconInfo = this._getDrawableIconInfo(choices[i].icon), image = iconInfo[0], icon = iconInfo[1];
+            if (image != null) {
+                core.drawImage('ui', image, 0, 32 * icon, 32, 32,
+                    this.HPIXEL - choices[i].width/2, vPos.choice_top + 32*i - 17, 22, 22);
+                offset += 14;
+            }
+        }
+        core.fillText('ui', choices[i].text, offset, vPos.choice_top + 32 * i, color);
     }
 
     if (choices.length>0) {
-        if (!core.isset(core.status.event.selection)) core.status.event.selection=0;
-        while (core.status.event.selection<0) core.status.event.selection+=choices.length;
-        while (core.status.event.selection>=choices.length) core.status.event.selection-=choices.length;
-        var len = core.canvas.ui.measureText(core.replaceText(choices[core.status.event.selection].text || choices[core.status.event.selection])).width;
-        core.strokeRect('ui', 208-len/2-5, choice_top + 32 * core.status.event.selection - 20, len+10, 28, "#FFD700", 2);
+        core.status.event.selection = core.status.event.selection || 0;
+        while (core.status.event.selection < 0) core.status.event.selection += choices.length;
+        while (core.status.event.selection >= choices.length) core.status.event.selection -= choices.length;
+        var len = choices[core.status.event.selection].width;
+        if (isWindowSkin)
+            this.drawWindowSelector(core.status.textAttribute.background,
+                this.HPIXEL - len/2 - 5, vPos.choice_top + 32 * core.status.event.selection - 20, len + 10, 28);
+        else
+            core.strokeRect('ui', this.HPIXEL - len/2 - 5, vPos.choice_top + 32 * core.status.event.selection - 20,
+                len+10, 28, "#FFD700", 2);
     }
-    return;
 }
 
 ////// 绘制一个确认/取消的警告页面 //////
 ui.prototype.drawConfirmBox = function (text, yesCallback, noCallback) {
     core.lockControl();
+    text = core.replaceText(text || "");
 
-    core.status.event.id = 'confirmBox';
-    core.status.event.data = {'yes': yesCallback, 'no': noCallback};
-    core.status.event.ui = text;
+    // 处理自定义事件
+    if (core.status.event.id != 'action') {
+        core.status.event.id = 'confirmBox';
+        core.status.event.ui = text;
+        core.status.event.data = {'yes': yesCallback, 'no': noCallback};
+    }
 
-    if (!core.isset(core.status.event.selection) || core.status.event.selection>1) core.status.event.selection=1;
-    if (core.status.event.selection<0) core.status.event.selection=0;
+    if (core.status.event.selection != 0) core.status.event.selection = 1;
+    this.clearUI();
 
-    var background = core.canvas.ui.createPattern(core.material.ground, "repeat");
-    core.clearMap('ui');
-    core.setAlpha('ui', 1);
-    core.setFillStyle('ui', background);
-    core.setFont('ui', "bold 19px Verdana");
+    core.setFont('ui', this._buildFont(19, true));
+    var contents = text.split("\n");
+    var rect = this._drawConfirmBox_getRect(contents);
+    var isWindowSkin = this.drawBackground(rect.left, rect.top, rect.right, rect.bottom);
 
-    var contents = text.split('\n');
-    var lines = contents.length;
-    var max_length = 0;
+    core.setTextAlign('ui', 'center');
+    core.setFillStyle('ui', core.arrayToRGBA(core.status.textAttribute.text))
     for (var i in contents) {
-        max_length = Math.max(max_length, core.canvas.ui.measureText(contents[i]).width);
+        core.fillText('ui', contents[i], this.HPIXEL, rect.top + 50 + i*30);
     }
 
-    var left = Math.min(208 - 40 - parseInt(max_length / 2), 100);
-    var top = 140 - (lines-1)*30;
-    var right = 416 - 2 * left, bottom = 416 - 140 - top;
+    core.fillText('ui', "确定", this.HPIXEL - 38, rect.bottom - 35, null, this._buildFont(17, true));
+    core.fillText('ui', "取消", this.HPIXEL + 38, rect.bottom - 35);
+    var len=core.calWidth('ui', "确定");
+    var strokeLeft = this.HPIXEL + (76*core.status.event.selection-38) - parseInt(len/2) - 5;
 
-    var borderColor = main.borderColor||"#FFFFFF";
+    if (isWindowSkin)
+        this.drawWindowSelector(core.status.textAttribute.background, strokeLeft, rect.bottom-35-20, len+10, 28);
+    else
+        core.strokeRect('ui', strokeLeft, rect.bottom-35-20, len+10, 28, "#FFD700", 2);
 
-    if (core.isPlaying())
-        core.fillRect('ui', left, top, right, bottom, background);
-    if (core.isPlaying())
-        core.strokeRect('ui', left - 1, top - 1, right + 1, bottom + 1, borderColor, 2);
-    core.canvas.ui.textAlign = "center";
-    for (var i in contents) {
-        core.fillText('ui', contents[i], 208, top + 50 + i*30, "#FFFFFF");
-    }
+}
 
-    core.fillText('ui', "确定", 208 - 38, top + bottom - 35, "#FFFFFF", "bold 17px Verdana");
-    core.fillText('ui', "取消", 208 + 38, top + bottom - 35);
-
-    var len=core.canvas.ui.measureText("确定").width;
-    if (core.status.event.selection==0) {
-        core.strokeRect('ui', 208-38-parseInt(len/2)-5, top+bottom-35-20, len+10, 28, "#FFD700", 2);
-    }
-    if (core.status.event.selection==1) {
-        core.strokeRect('ui', 208+38-parseInt(len/2)-5, top+bottom-35-20, len+10, 28, "#FFD700", 2);
-    }
+ui.prototype._drawConfirmBox_getRect = function (contents) {
+    var max_width = contents.reduce(function (pre, curr) {
+        return Math.max(pre, core.calWidth('ui', curr));
+    }, 0);
+    var left = Math.min(this.HPIXEL - 40 - parseInt(max_width / 2), 100), right = this.PIXEL - left;
+    var top = this.HPIXEL - 68 - (contents.length-1)*30, bottom = this.HPIXEL + 68;
+    return { top: top, left: left, bottom: bottom, right: right, width: right - left, height: bottom - top };
+}
 
+////// 绘制等待界面 //////
+ui.prototype.drawWaiting = function(text) {
+    core.lockControl();
+    core.status.event.id = 'waiting';
+    core.clearUI();
+    text = core.replaceText(text || "");
+    var text_length = core.calWidth('ui', text, this._buildFont(19, true));
+    var width = Math.max(text_length + 80, 220), left = this.HPIXEL - parseInt(width / 2), right = left + width;
+    var top = this.HPIXEL - 48, height = 96, bottom = top + height;
+    this.drawBackground(left, top, right, bottom);
+    core.setTextAlign('ui', 'center');
+    core.fillText('ui', text, this.HPIXEL, top + 56, core.arrayToRGBA(core.status.textAttribute.text));
 }
 
 ////// 绘制系统设置界面 //////
 ui.prototype.drawSwitchs = function() {
     core.status.event.id = 'switchs';
-
     var choices = [
-        "背景音乐："+(core.musicStatus.bgmStatus ? "[ON]" : "[OFF]"),
-        "背景音效："+(core.musicStatus.soundStatus ? "[ON]" : "[OFF]"),
-        "战斗动画： "+(core.flags.battleAnimate ? "[ON]" : "[OFF]"),
+        "背景音乐： "+(core.musicStatus.bgmStatus ? "[ON]" : "[OFF]"),
+        "背景音效： "+(core.musicStatus.soundStatus ? "[ON]" : "[OFF]"),
+        "行走速度： "+parseInt(core.values.moveSpeed),
         "怪物显伤： "+(core.flags.displayEnemyDamage ? "[ON]" : "[OFF]"),
         "临界显伤： "+(core.flags.displayCritical ? "[ON]" : "[OFF]"),
         "领域显伤： "+(core.flags.displayExtraDamage ? "[ON]" : "[OFF]"),
-        "单击瞬移： "+(core.status.automaticRoute.clickMoveDirectly ? "[ON]" : "[OFF]"),
-        "下载离线版本",
+        "新版存档： "+(core.platform.useLocalForage ? "[ON]":"[OFF]"),
+        "单击瞬移： "+(!core.hasFlag("__noClickMove__") ? "[ON]":"[OFF]"),
+        "拓展键盘： "+(core.platform.extendKeyboard ? "[ON]":"[OFF]"),
         "返回主菜单"
     ];
     this.drawChoices(null, choices);
@@ -809,365 +1223,30 @@ ui.prototype.drawSwitchs = function() {
 ////// 绘制系统菜单栏 //////
 ui.prototype.drawSettings = function () {
     core.status.event.id = 'settings';
-
     this.drawChoices(null, [
-        "系统设置", "快捷商店", "浏览地图", "同步存档", "返回标题", "数据统计", "操作帮助", "关于本塔", "返回游戏"
+        "系统设置", "虚拟键盘", "浏览地图", "绘图模式", "同步存档", "游戏信息", "返回标题", "返回游戏"
     ]);
 }
 
 ////// 绘制快捷商店选择栏 //////
 ui.prototype.drawQuickShop = function () {
-
     core.status.event.id = 'selectShop';
-
-    var shopList = core.status.shops, keys = Object.keys(shopList);
-
-    var choices = [];
-    for (var i=0;i<keys.length;i++) {
-        choices.push(shopList[keys[i]].textInList);
-    }
+    var shopList = core.status.shops, keys = Object.keys(shopList).filter(function (shopId) {
+        return shopList[shopId].visited || !shopList[shopId].mustEnable
+    });
+    var choices = keys.map(function (shopId) {
+        return {"text": shopList[shopId].textInList, "color": shopList[shopId].visited?null:"#999999"};
+    });
     choices.push("返回游戏");
     this.drawChoices(null, choices);
 }
 
-////// 绘制战斗动画 //////
-ui.prototype.drawBattleAnimate = function(monsterId, callback) {
-
-    // UI层
-    core.lockControl();
-    if (!core.isset(core.status.event.id)) {
-        core.status.event = {'id': 'battle'};
-    }
-
-    var hero_hp = core.getStatus('hp'), hero_atk = core.getStatus('atk'), hero_def = core.getStatus('def'),
-        hero_mdef = core.getStatus('mdef');
-    var monster = core.material.enemys[monsterId];
-    var mon_hp = monster.hp, mon_atk = monster.atk, mon_def = monster.def, mon_money=monster.money, mon_exp = monster.experience, mon_special=monster.special;
-
-    var initDamage = 0; // 战前伤害
-
-    // 吸血
-    if (core.enemys.hasSpecial(mon_special, 11)) {
-        var vampireDamage = hero_hp * monster.value;
-
-        // 如果有神圣盾免疫吸血等可以在这里写
-
-        vampireDamage = Math.floor(vampireDamage);
-        // 加到自身
-        if (monster.add) // 如果加到自身
-            mon_hp += vampireDamage;
-
-        initDamage += vampireDamage;
-    }
-
-    hero_hp -= core.enemys.getExtraDamage(monster);
-
-    if (core.enemys.hasSpecial(mon_special, 10)) { // 模仿
-        mon_atk=hero_atk;
-        mon_def=hero_def;
-    }
-    if (core.enemys.hasSpecial(mon_special, 2)) hero_def=0; // 魔攻
-    if (core.enemys.hasSpecial(mon_special, 3) && mon_def<hero_atk) mon_def=hero_atk-1; // 坚固
-
-    // 实际操作
-    var turn = 0; // 0为勇士攻击
-    if (core.enemys.hasSpecial(mon_special, 1)) turn=1;
-
-    // 回合
-    var turns = 2;
-    if (core.enemys.hasSpecial(mon_special, 4)) turns=3;
-    if (core.enemys.hasSpecial(mon_special, 5)) turns=4;
-    if (core.enemys.hasSpecial(mon_special, 6)) turns=1+(monster.n||4);
-
-    // 初始伤害
-    if (core.enemys.hasSpecial(mon_special, 7)) initDamage+=Math.floor(core.values.breakArmor * hero_def);
-    if (core.enemys.hasSpecial(mon_special, 9)) initDamage+=Math.floor(core.values.purify * hero_mdef);
-    hero_mdef-=initDamage;
-    if (hero_mdef<0) {
-        hero_hp+=hero_mdef;
-        hero_mdef=0;
-    }
-
-    var specialTexts = core.enemys.getSpecialText(monsterId);
-
-    var background = core.canvas.ui.createPattern(core.material.ground, "repeat");
-
-    core.clearMap('ui');
-    var left=10, right=416-2*left;
-
-
-    // var lines = core.flags.enableExperience?5:4;
-    var lines = 3;
-    if (core.flags.enableMDef || core.flags.enableMoney || core.flags.enableExperience) lines=4;
-    if (core.flags.enableMoney && core.flags.enableExperience) lines=5;
-
-    var lineHeight = 60;
-    var height = lineHeight * lines + 50;
-
-    var top = (416-height)/2, bottom = height;
-
-    // var left = 97, top = 64, right = 416 - 2 * left, bottom = 416 - 2 * top;
-    core.setAlpha('ui', 0.85);
-    core.fillRect('ui', left, top, right, bottom, '#000000');
-    core.setAlpha('ui', 1);
-    core.strokeRect('ui', left - 1, top - 1, right + 1, bottom + 1, '#FFFFFF', 2);
-    core.clearMap('data');
-
-    clearInterval(core.interval.tipAnimate);
-    core.setAlpha('data', 1);
-    core.setOpacity('data', 1);
-    core.status.boxAnimateObjs = [];
-
-    var margin = 35;
-    var boxWidth = 40;
-    var monsterHeight = 32, animate=2;
-
-    var image = core.material.images.enemys, icon = core.material.icons.enemys;
-    if (core.isset(core.material.icons.enemy48[monsterId])) {
-        image = core.material.images.enemy48;
-        icon = core.material.icons.enemy48;
-        monsterHeight = 48;
-        animate=4;
-    }
-
-    // 方块
-    var heroHeight = core.material.icons.hero.height;
-    core.strokeRect('ui', left + margin - 1, top + margin - 1, boxWidth+2, heroHeight+boxWidth-32+2, '#FFD700', 2);
-    core.strokeRect('ui', left + right - margin - boxWidth - 1 , top+margin-1, boxWidth+2, monsterHeight+boxWidth-32+2);
-
-    // 名称
-    core.canvas.ui.textAlign='center';
-    core.fillText('ui', core.status.hero.name, left+margin+boxWidth/2, top+margin+heroHeight+40, '#FFD700', 'bold 22px Verdana');
-    core.fillText('ui', "怪物", left+right-margin-boxWidth/2, top+margin+monsterHeight+40);
-    for (var i=0, j=0; i<specialTexts.length;i++) {
-        if (specialTexts[i]!='') {
-            core.fillText('ui', specialTexts[i], left+right-margin-boxWidth/2, top+margin+monsterHeight+44+20*(++j), '#FF6A6A', '15px Verdana');
-        }
-    }
-
-    // 图标
-    core.clearMap('ui', left + margin, top + margin, boxWidth, heroHeight+boxWidth-32);
-    core.fillRect('ui', left + margin, top + margin, boxWidth, heroHeight+boxWidth-32, background);
-    var heroIcon = core.material.icons.hero['down'];
-    core.canvas.ui.drawImage(core.material.images.hero, heroIcon.stop * 32, heroIcon.loc *heroHeight, 32, heroHeight, left+margin+(boxWidth-32)/2, top+margin+(boxWidth-32)/2, 32, heroHeight);
-    // 怪物的
-    core.status.boxAnimateObjs = [];
-    core.status.boxAnimateObjs.push({
-        'bgx': left+right-margin-40, 'bgy': top+margin, 'bgWidth': boxWidth, 'bgHeight': monsterHeight+boxWidth-32,
-        'x': left + right - margin - 40 + (boxWidth-32)/2, 'y': top + margin + (boxWidth-32)/2, 'height': monsterHeight,
-        'image': image, 'pos': monsterHeight*icon[monsterId], 'animate': animate
-    })
-    core.drawBoxAnimate();
-    var lineWidth = 80;
-
-    var left_start = left + margin + boxWidth + 10;
-    var left_end = left_start+lineWidth;
-
-    var right_end = left+right-margin-boxWidth-10;
-    var right_start = right_end-lineWidth;
-
-    // 勇士的线
-    core.canvas.ui.textAlign='left';
-    var textTop = top+margin+10;
-    core.fillText('ui', "生命值", left_start, textTop, '#DDDDDD', '16px Verdana');
-    core.drawLine('ui', left_start, textTop+8, left_end, textTop+8, '#FFFFFF', 2);
-    core.canvas.data.textAlign='right';
-    core.fillText('data', hero_hp, left_end, textTop+26, '#DDDDDD', 'bold 16px Verdana');
-
-    textTop+=lineHeight;
-    core.canvas.ui.textAlign='left';
-    core.fillText('ui', "攻击", left_start, textTop, '#DDDDDD', '16px Verdana');
-    core.drawLine('ui', left_start, textTop+8, left_end, textTop+8, '#FFFFFF', 2);
-    core.canvas.ui.textAlign='right';
-    core.fillText('ui', hero_atk, left_end, textTop+26, '#DDDDDD', 'bold 16px Verdana');
-
-    textTop+=lineHeight;
-    core.canvas.ui.textAlign='left';
-    core.fillText('ui', "防御", left_start, textTop, '#DDDDDD', '16px Verdana');
-    core.drawLine('ui', left_start, textTop+8, left_end, textTop+8, '#FFFFFF', 2);
-    core.canvas.ui.textAlign='right';
-    core.fillText('ui', hero_def, left_end, textTop+26, '#DDDDDD', 'bold 16px Verdana');
-
-    if (core.flags.enableMDef) {
-        textTop += lineHeight;
-        core.canvas.ui.textAlign='left';
-        core.fillText('ui', "护盾", left_start, textTop, '#DDDDDD', '16px Verdana');
-        core.drawLine('ui', left_start, textTop + 8, left_end, textTop + 8, '#FFFFFF', 2);
-        core.canvas.data.textAlign='right';
-        core.fillText('data', hero_mdef, left_end, textTop+26, '#DDDDDD', 'bold 16px Verdana');
-    }
-
-    // 怪物的线
-    core.canvas.ui.textAlign='right';
-    var textTop = top+margin+10;
-    core.fillText('ui', "生命值", right_end, textTop, '#DDDDDD', '16px Verdana');
-    core.drawLine('ui', right_start, textTop+8, right_end, textTop+8, '#FFFFFF', 2);
-    core.canvas.data.textAlign='left';
-    core.fillText('data', mon_hp, right_start, textTop+26, '#DDDDDD', 'bold 16px Verdana');
-
-    textTop+=lineHeight;
-    core.canvas.ui.textAlign='right';
-    core.fillText('ui', "攻击", right_end, textTop, '#DDDDDD', '16px Verdana');
-    core.drawLine('ui', right_start, textTop+8, right_end, textTop+8, '#FFFFFF', 2);
-    core.canvas.ui.textAlign='left';
-    core.fillText('ui', mon_atk, right_start, textTop+26, '#DDDDDD', 'bold 16px Verdana');
-
-    textTop+=lineHeight;
-    core.canvas.ui.textAlign='right';
-    core.fillText('ui', "防御", right_end, textTop, '#DDDDDD', '16px Verdana');
-    core.drawLine('ui', right_start, textTop+8, right_end, textTop+8, '#FFFFFF', 2);
-    core.canvas.ui.textAlign='left';
-    core.fillText('ui', mon_def, right_start, textTop+26, '#DDDDDD', 'bold 16px Verdana');
-
-    if (core.flags.enableMoney) {
-        textTop += lineHeight;
-        core.canvas.ui.textAlign = 'right';
-        core.fillText('ui', "金币", right_end, textTop, '#DDDDDD', '16px Verdana');
-        core.drawLine('ui', right_start, textTop + 8, right_end, textTop + 8, '#FFFFFF', 2);
-        core.canvas.ui.textAlign = 'left';
-        core.fillText('ui', mon_money, right_start, textTop + 26, '#DDDDDD', 'bold 16px Verdana');
-    }
-
-    if (core.flags.enableExperience) {
-        textTop += lineHeight;
-        core.canvas.ui.textAlign='right';
-        core.fillText('ui', "经验", right_end, textTop, '#DDDDDD', '16px Verdana');
-        core.drawLine('ui', right_start, textTop + 8, right_end, textTop + 8, '#FFFFFF', 2);
-        core.canvas.ui.textAlign='left';
-        core.fillText('ui', mon_exp, right_start, textTop+26, '#DDDDDD', 'bold 16px Verdana');
-    }
-
-    core.canvas.ui.textAlign='left';
-    core.fillText("ui", "V", left_end+8, 208-15, "#FFFFFF", "italic bold 40px Verdana");
-
-    core.canvas.ui.textAlign='right';
-    core.fillText("ui", "S", right_start-8, 208+15, "#FFFFFF", "italic bold 40px Verdana");
-
-    var battleInterval = setInterval(function() {
-        core.playSound("attack.mp3");
-
-        if (turn==0) {
-            // 勇士攻击
-            core.drawLine('data', left + right - margin - boxWidth + 6, top+margin+monsterHeight+boxWidth-32-6,
-                left+right-margin-6, top+margin+6, '#FF0000', 4);
-            setTimeout(function() {
-                core.clearMap('data', left + right - margin - boxWidth, top+margin,
-                    boxWidth, boxWidth+monsterHeight-32);
-            }, 250);
-
-            if (hero_atk-mon_def>0)
-                mon_hp-=hero_atk-mon_def;
-            if (mon_hp<0) mon_hp=0;
-
-            // 更新怪物伤害
-            core.clearMap('data', right_start, top+margin+10, lineWidth, 40);
-            core.canvas.data.textAlign='left';
-            core.fillText('data', mon_hp, right_start, top+margin+10+26, '#DDDDDD', 'bold 16px Verdana');
-
-            // 反击
-            if (core.enemys.hasSpecial(mon_special, 8)) {
-                hero_mdef -= Math.floor(core.values.counterAttack * hero_atk);
-
-                if (hero_mdef<0) {
-                    hero_hp+=hero_mdef;
-                    hero_mdef=0;
-                }
-                // 更新勇士数据
-                core.clearMap('data', left_start, top+margin+10, lineWidth, 40);
-                core.canvas.data.textAlign='right';
-                core.fillText('data', hero_hp, left_end, top+margin+10+26, '#DDDDDD', 'bold 16px Verdana');
-
-                if (core.flags.enableMDef) {
-                    core.clearMap('data', left_start, top+margin+10+3*lineHeight, lineWidth, 40);
-                    core.fillText('data', hero_mdef, left_end, top+margin+10+26+3*lineHeight);
-                }
-
-            }
-
-        }
-        else {
-            // 怪物攻击
-            core.drawLine('data', left + margin + 6, top+margin+heroHeight+(boxWidth-32)-6,
-                left+margin+boxWidth-6, top+margin+6, '#FF0000', 4);
-            setTimeout(function() {
-                core.clearMap('data', left + margin, top+margin, boxWidth, heroHeight+boxWidth-32);
-            }, 250);
-
-            var per_damage = mon_atk-hero_def;
-            if (per_damage < 0) per_damage = 0;
-
-            hero_mdef-=per_damage;
-            if (hero_mdef<0) {
-                hero_hp+=hero_mdef;
-                hero_mdef=0;
-            }
-            // 更新勇士数据
-            core.clearMap('data', left_start, top+margin+10, lineWidth, 40);
-            core.canvas.data.textAlign='right';
-            core.fillText('data', hero_hp, left_end, top+margin+10+26, '#DDDDDD', 'bold 16px Verdana');
-
-            if (core.flags.enableMDef) {
-                core.clearMap('data', left_start, top+margin+10+3*lineHeight, lineWidth, 40);
-                core.fillText('data', hero_mdef, left_end, top+margin+10+26+3*lineHeight);
-            }
-
-        }
-        turn++;
-        if (turn>=turns) turn=0;
-
-        if (hero_hp<=0 || mon_hp<=0) {
-            // 战斗结束
-            clearInterval(battleInterval);
-            core.status.boxAnimateObjs = [];
-            core.clearMap('ui');
-            core.setAlpha('ui', 1.0);
-            core.clearMap('data');
-            if (core.status.event.id=='battle') {
-                core.unLockControl();
-                core.status.event.id=null;
-            }
-            if (core.isset(callback))
-                callback();
-            return;
-        }
-
-    }, 500);
-}
-
-////// 绘制等待界面 //////
-ui.prototype.drawWaiting = function(text) {
-
-    core.lockControl();
-    core.status.event.id = 'waiting';
-
-    var background = core.canvas.ui.createPattern(core.material.ground, "repeat");
-    core.clearMap('ui');
-    core.setAlpha('ui', 1);
-    core.setFillStyle('ui', background);
-
-    core.setFont('ui', 'bold 17px Verdana');
-    var text_length = core.canvas.ui.measureText(text).width;
-
-    var right = Math.max(text_length+50, 220);
-    var left = 208-parseInt(right/2), top = 208 - 32 - 16, bottom = 416 - 2 * top;
-
-    core.fillRect('ui', left, top, right, bottom, background);
-    core.strokeRect('ui', left - 1, top - 1, right + 1, bottom + 1, '#FFFFFF', 2);
-
-    core.canvas.ui.textAlign = "center";
-    core.fillText('ui', text, 208, top + 56, '#FFFFFF');
-
-}
-
 ////// 绘制存档同步界面 //////
 ui.prototype.drawSyncSave = function () {
-
     core.status.event.id = 'syncSave';
-
     this.drawChoices(null, [
-        "同步存档到服务器", "从服务器加载存档", "存档至本地文件", "从本地文件读档", "下载当前录像", "清空本地存档", "返回主菜单"
+        "同步存档到服务器", "从服务器加载存档", "存档至本地文件", "从本地文件读档", "回放和下载录像", "清空本地存档", "返回主菜单"
     ]);
-
 }
 
 ////// 绘制存档同步选择页面 //////
@@ -1198,697 +1277,993 @@ ui.prototype.drawReplay = function () {
     core.lockControl();
     core.status.event.id = 'replay';
     this.drawChoices(null, [
-        "从头回放录像", "从存档开始回放", "下载当前录像", "返回游戏"
+        "从头回放录像", "从存档开始回放", "接续播放剩余录像", "选择录像文件", "下载当前录像", "返回游戏"
+    ]);
+}
+
+ui.prototype.drawGameInfo = function () {
+    core.status.event.id = 'gameInfo';
+    this.drawChoices(null, [
+        "数据统计", "查看工程", "游戏主页", "操作帮助", "关于本塔","下载离线版本", "返回主菜单"
     ]);
 }
 
 ////// 绘制分页 //////
-ui.prototype.drawPagination = function (page, totalPage) {
+ui.prototype.drawPagination = function (page, totalPage, y) {
+    // if (totalPage<page) totalPage=page;
+    if (totalPage <= 1) return;
+    if (y == null) y = this.LAST;
 
-    core.setFont('ui', 'bold 15px Verdana');
     core.setFillStyle('ui', '#DDDDDD');
+    var length = core.calWidth('ui', page + " / " + page, this._buildFont(15, true));
 
-    var length = core.canvas.ui.measureText(page + " / " + page).width;
+    core.setTextAlign('ui', 'left');
+    core.fillText('ui', page + " / " + totalPage, parseInt((this.PIXEL - length) / 2), y*32+19);
 
-    core.canvas.ui.textAlign = 'left';
-    core.fillText('ui', page + " / " + totalPage, parseInt((416 - length) / 2), 403);
-
-    core.canvas.ui.textAlign = 'center';
+    core.setTextAlign('ui', 'center');
     if (page > 1)
-        core.fillText('ui', '上一页', 208 - 80, 403);
+        core.fillText('ui', '上一页', this.HPIXEL - 80, y*32+19);
     if (page < totalPage)
-        core.fillText('ui', '下一页', 208 + 80, 403);
-
-    // 退出
-    core.fillText('ui', '返回游戏', 370, 403);
-
+        core.fillText('ui', '下一页', this.HPIXEL + 80, y*32+19);
 }
 
 ////// 绘制键盘光标 //////
 ui.prototype.drawCursor = function () {
-
-    if (!core.isset(core.status.automaticRoute.cursorX))
-        core.status.automaticRoute.cursorX=core.getHeroLoc('x');
-    if (core.status.automaticRoute.cursorX<0) core.status.automaticRoute.cursorX=0;
-    if (core.status.automaticRoute.cursorX>12) core.status.automaticRoute.cursorX=12;
-    if (!core.isset(core.status.automaticRoute.cursorY))
-        core.status.automaticRoute.cursorY=core.getHeroLoc('y');
-    if (core.status.automaticRoute.cursorY<0) core.status.automaticRoute.cursorY=0;
-    if (core.status.automaticRoute.cursorY>12) core.status.automaticRoute.cursorY=12;
-
+    var automaticRoute = core.status.automaticRoute;
+    if (automaticRoute.cursorX == null)
+        automaticRoute.cursorX = core.getHeroLoc('x');
+    if (automaticRoute.cursorY == null)
+        automaticRoute.cursorY = core.getHeroLoc('y');
+    automaticRoute.cursorX = core.clamp(automaticRoute.cursorX, 0, this.LAST);
     core.status.event.id = 'cursor';
     core.lockControl();
-
-    core.clearMap('ui');
-    core.setAlpha('ui', 1);
-
+    core.clearUI();
     var width = 4;
-    core.strokeRect('ui', 32*core.status.automaticRoute.cursorX+width/2, 32*core.status.automaticRoute.cursorY+width/2,
+    core.strokeRect('ui', 32*automaticRoute.cursorX+width/2, 32*automaticRoute.cursorY+width/2,
         32-width, 32-width, '#FFD700', width);
 
 }
 
 ////// 绘制怪物手册 //////
 ui.prototype.drawBook = function (index) {
-
-    var enemys = core.enemys.getCurrentEnemys(core.floorIds[core.status.event.selection]);
-    var background = core.canvas.ui.createPattern(core.material.ground, "repeat");
-
-    clearInterval(core.interval.tipAnimate);
+    var floorId = core.floorIds[(core.status.event.ui||{}).index] || core.status.floorId;
+    var enemys = core.enemys.getCurrentEnemys(floorId);
+    core.clearUI();
     core.clearMap('data');
-    core.setOpacity('data', 1);
-
-    core.clearMap('ui');
+    // 生成groundPattern
+    core.maps.generateGroundPattern(floorId);
+    this._drawBook_drawBackground();
     core.setAlpha('ui', 1);
-    core.setFillStyle('ui', background);
-    core.fillRect('ui', 0, 0, 416, 416);
-
-    core.setAlpha('ui', 0.6);
-    core.setFillStyle('ui', '#000000');
-    core.fillRect('ui', 0, 0, 416, 416);
-
-    core.setAlpha('ui', 1);
-    core.canvas.ui.textAlign = 'left';
-    core.setFont('ui', 'bold 15px Verdana');
 
     if (enemys.length == 0) {
-        core.fillText('ui', "本层无怪物", 83, 222, '#999999', "bold 50px Verdana");
-        // 退出
-        core.canvas.ui.textAlign = 'center';
-        core.fillText('ui', '返回游戏', 370, 403,'#DDDDDD', 'bold 15px Verdana');
+        core.setTextAlign('ui', 'center');
+        core.fillText('ui', "本层无怪物", this.HPIXEL, this.HPIXEL + 14, '#999999', this._buildFont(50, true));
+        core.fillText('ui', '返回游戏', this.PIXEL - 46, this.PIXEL - 13,'#DDDDDD', this._buildFont(15, true));
         return;
     }
 
-    if (index<0) index=0;
-    if (index>=enemys.length) index=enemys.length-1;
-    var perpage = 6;
-    var page=parseInt(index/perpage)+1;
-    var totalPage = parseInt((enemys.length - 1) / perpage) + 1;
+    index = core.clamp(index, 0, enemys.length - 1);
     core.status.event.data = index;
-    var start = (page - 1) * perpage, end = Math.min(page * perpage, enemys.length);
+    var pageinfo = this._drawBook_pageinfo();
+    var perpage = pageinfo.per_page, page = parseInt(index / perpage) + 1, totalPage = Math.ceil(enemys.length / perpage);
 
-    enemys = enemys.slice(start, end);
-    core.status.boxAnimateObjs = [];
-    for (var i = 0; i < enemys.length; i++) {
-        // 边框
-        var enemy = enemys[i];
-        core.strokeRect('ui', 22, 62 * i + 22, 42, 42, '#DDDDDD', 2);
+    var start = (page - 1) * perpage;
+    enemys = enemys.slice(start, page * perpage);
 
-        var cls = 'enemys';
-        if (core.isset(core.material.icons.enemy48[enemy.id]))
-            cls = 'enemy48';
-        var height = cls=='enemy48'?48:32;
-        var animate = cls=='enemy48'?4:2;
+    for (var i = 0; i < enemys.length; i++)
+        this._drawBook_drawOne(floorId, i, enemys[i], pageinfo, index == start + i);
 
-        // 怪物
-        core.status.boxAnimateObjs.push({
-            'bgx': 22, 'bgy': 62 * i + 22, 'bgWidth': 42, 'bgHeight': 42,
-            'x': 27, 'y': 62 * i + 27, 'height': 32, 'animate': animate,
-            'image': core.material.images[cls],
-            'pos': core.material.icons[cls][enemy.id] * height
-        });
-
-        // 数据
-        core.canvas.ui.textAlign = "center";
-
-        if (enemy.special=='') {
-            core.fillText('ui', enemy.name, 115, 62 * i + 47, '#DDDDDD', 'bold 17px Verdana');
-        }
-        else {
-            core.fillText('ui', enemy.name, 115, 62 * i + 40, '#DDDDDD', 'bold 17px Verdana');
-            core.fillText('ui', enemy.special, 115, 62 * i + 62, '#FF6A6A', 'bold 15px Verdana');
-        }
-        core.canvas.ui.textAlign = "left";
-        core.fillText('ui', '生命', 165, 62 * i + 32, '#DDDDDD', '13px Verdana');
-        core.fillText('ui', core.formatBigNumber(enemy.hp), 195, 62 * i + 32, '#DDDDDD', 'bold 13px Verdana');
-        core.fillText('ui', '攻击', 255, 62 * i + 32, '#DDDDDD', '13px Verdana');
-        core.fillText('ui', core.formatBigNumber(enemy.atk), 285, 62 * i + 32, '#DDDDDD', 'bold 13px Verdana');
-        core.fillText('ui', '防御', 335, 62 * i + 32, '#DDDDDD', '13px Verdana');
-        core.fillText('ui', core.formatBigNumber(enemy.def), 365, 62 * i + 32, '#DDDDDD', 'bold 13px Verdana');
-
-        var expOffset = 165, line_cnt=0;
-        if (core.flags.enableMoney) {
-            core.fillText('ui', '金币', 165, 62 * i + 50, '#DDDDDD', '13px Verdana');
-            core.fillText('ui', core.formatBigNumber(enemy.money), 195, 62 * i + 50, '#DDDDDD', 'bold 13px Verdana');
-            expOffset = 255;
-            line_cnt++;
-        }
-
-        // 加点
-        if (core.flags.enableAddPoint) {
-            core.canvas.ui.textAlign = "left";
-            core.fillText('ui', '加点', expOffset, 62 * i + 50, '#DDDDDD', '13px Verdana');
-            core.fillText('ui', core.formatBigNumber(enemy.point), expOffset + 30, 62 * i + 50, '#DDDDDD', 'bold 13px Verdana');
-            expOffset = 255;
-            line_cnt++;
-        }
-
-        if (core.flags.enableExperience && line_cnt<2) {
-            core.canvas.ui.textAlign = "left";
-            core.fillText('ui', '经验', expOffset, 62 * i + 50, '#DDDDDD', '13px Verdana');
-            core.fillText('ui', core.formatBigNumber(enemy.experience), expOffset + 30, 62 * i + 50, '#DDDDDD', 'bold 13px Verdana');
-            line_cnt++;
-        }
-
-        var damageOffset = 281;
-        if (line_cnt==1) damageOffset=326;
-        if (line_cnt==2) damageOffset=361;
-
-        core.canvas.ui.textAlign = "center";
-        var damage = enemy.damage;
-
-        var color = '#FFFF00';
-        if (damage == null) {
-            damage = '无法战斗';
-            color = '#FF0000';
-        }
-        else {
-            if (damage >= core.status.hero.hp) color = '#FF0000';
-            if (damage<=0) color = '#00FF00';
-
-            damage = core.formatBigNumber(damage);
-            if (core.enemys.hasSpecial(core.material.enemys[enemy.id], 19))
-                damage += "+";
-        }
-        if (core.material.enemys[enemy.id].notBomb)
-            damage += "[b]";
-
-        core.fillText('ui', damage, damageOffset, 62 * i + 50, color, 'bold 13px Verdana');
-
-        core.canvas.ui.textAlign = "left";
-
-        core.fillText('ui', '临界', 165, 62 * i + 68, '#DDDDDD', '13px Verdana');
-        core.fillText('ui', core.formatBigNumber(enemy.critical), 195, 62 * i + 68, '#DDDDDD', 'bold 13px Verdana');
-        core.fillText('ui', '减伤', 255, 62 * i + 68, '#DDDDDD', '13px Verdana');
-        core.fillText('ui', core.formatBigNumber(enemy.criticalDamage), 285, 62 * i + 68, '#DDDDDD', 'bold 13px Verdana');
-        core.fillText('ui', '1防', 335, 62 * i + 68, '#DDDDDD', '13px Verdana');
-        core.fillText('ui', core.formatBigNumber(enemy.defDamage), 365, 62 * i + 68, '#DDDDDD', 'bold 13px Verdana');
-
-        if (index == start+i) {
-            core.strokeRect('ui', 10, 62 * i + 13, 416-10*2,  62, '#FFD700');
-        }
-
-    }
     core.drawBoxAnimate();
     this.drawPagination(page, totalPage);
+    core.setTextAlign('ui', 'center');
+    core.fillText('ui', '返回游戏', this.PIXEL - 46, this.PIXEL - 13,'#DDDDDD', this._buildFont(15, true));
+}
+
+ui.prototype._drawBook_pageinfo = function () {
+    var per_page = this.HSIZE; // 每页个数
+    var padding_top = 12; // 距离顶端像素
+    var per_height = (this.PIXEL - 32 - padding_top) / per_page;
+    return { per_page: per_page, padding_top: padding_top, per_height: per_height };
+}
+
+ui.prototype._drawBook_drawBackground = function () {
+    core.setAlpha('ui', 1);
+    core.setFillStyle('ui', core.material.groundPattern);
+    core.fillRect('ui', 0, 0, this.PIXEL, this.PIXEL);
+
+    core.setAlpha('ui', 0.6);
+    core.setFillStyle('ui', '#000000');
+    core.fillRect('ui', 0, 0, this.PIXEL, this.PIXEL);
+}
+
+ui.prototype._drawBook_drawOne = function (floorId, index, enemy, pageinfo, selected) {
+    // --- 区域规划：每个区域总高度默认为62，宽度为 PIXEL
+    var top = pageinfo.per_height * index + pageinfo.padding_top; // 最上面margin默认是12px
+    // 横向规划：
+    // 22 + 42 = 64 是头像框
+    this._drawBook_drawBox(index, enemy, top, pageinfo);
+    // 剩余 PIXEL - 64 的宽度，按照 10 : 9 : 8 : 8 的比例划分
+    var left = 64, total_width = this.PIXEL - left;
+    var name_width = total_width * 10 / 35;
+    this._drawBook_drawName(index, enemy, top, left, name_width);
+    this._drawBook_drawContent(index, enemy, top, left + name_width);
+    if (selected)
+        core.strokeRect('ui', 10, top + 1, this.PIXEL - 10 * 2, pageinfo.per_height, '#FFD700');
+}
+
+ui.prototype._drawBook_drawBox = function (index, enemy, top, pageinfo) {
+    // 横向：22+42；纵向：10 + 42 + 10（正好居中）；内部图像 32x32
+    var border_top = top + (pageinfo.per_height - 42) / 2, border_left = 22;
+    var img_top = border_top + 5, img_left = border_left + 5;
+    core.strokeRect('ui', 22, border_top, 42, 42, '#DDDDDD', 2);
+    var blockInfo = core.getBlockInfo(enemy.id);
+    core.status.boxAnimateObjs.push({
+        'bgx': border_left, 'bgy': border_top, 'bgWidth': 42, 'bgHeight': 42,
+        'x': img_left, 'y': img_top, 'height': 32, 'animate': blockInfo.animate,
+        'image': blockInfo.image, 'pos': blockInfo.posY * blockInfo.height
+    });
+}
+
+ui.prototype._drawBook_drawName = function (index, enemy, top, left, width) {
+    // 绘制第零列（名称和特殊属性）
+    // 如果需要添加自己的比如怪物的称号等，也可以在这里绘制
+    core.setTextAlign('ui', 'center');
+    if (enemy.specialText=='') {
+        core.fillText('ui', enemy.name, left + width / 2,
+            top + 35, '#DDDDDD', this._buildFont(17, true));
+    }
+    else {
+        core.fillText('ui', enemy.name, left + width / 2,
+            top + 28, '#DDDDDD', this._buildFont(17, true));
+        core.fillText('ui', enemy.specialText, left + width / 2,
+            top + 50, '#FF6A6A', this._buildFont(15, true));
+    }
+}
+
+ui.prototype._drawBook_drawContent = function (index, enemy, top, left) {
+    var width = this.PIXEL - left; // 9 : 8 : 8 划分三列
+    this._drawBook_drawRow1(index, enemy, top, left, width, top + 20);
+    this._drawBook_drawRow2(index, enemy, top, left, width, top + 38);
+    this._drawBook_drawRow3(index, enemy, top, left, width, top + 56);
+}
+
+ui.prototype._drawBook_drawRow1 = function (index, enemy, top, left, width, position) {
+    // 绘制第一行
+    core.setTextAlign('ui', 'left');
+    var b13 = this._buildFont(13, true), f13 = this._buildFont(13, false);
+    var col1 = left, col2 = left + width * 9 / 25, col3 = left + width * 17 / 25;
+    core.fillText('ui', '生命', col1, position, '#DDDDDD', f13);
+    core.fillText('ui', core.formatBigNumber(enemy.hp||0), col1 + 30, position, null, b13);
+    core.fillText('ui', '攻击', col2, position, null, f13);
+    core.fillText('ui', core.formatBigNumber(enemy.atk||0), col2 + 30, position, null, b13);
+    core.fillText('ui', '防御', col3, position, null, f13);
+    core.fillText('ui', core.formatBigNumber(enemy.def||0), col3 + 30, position, null, b13);
+}
+
+ui.prototype._drawBook_drawRow2 = function (index, enemy, top, left, width, position) {
+    // 绘制第二行
+    core.setTextAlign('ui', 'left');
+    var b13 = this._buildFont(13, true), f13 = this._buildFont(13, false);
+    var col1 = left, col2 = left + width * 9 / 25, col3 = left + width * 17 / 25;
+    // 获得第二行绘制的内容
+    var second_line = [];
+    if (core.flags.enableMoney) second_line.push(["金币", core.formatBigNumber(enemy.money || 0)]);
+    if (core.flags.enableAddPoint) second_line.push(["加点", core.formatBigNumber(enemy.point || 0)]);
+    if (core.flags.enableExperience) second_line.push(["经验", core.formatBigNumber(enemy.experience || 0)]);
+
+    var damage_offset = col1 + (this.PIXEL - col1) / 2 - 12;
+    // 第一列
+    if (second_line.length > 0) {
+        var one = second_line.shift();
+        core.fillText('ui', one[0], col1, position, '#DDDDDD', f13);
+        core.fillText('ui', one[1], col1 + 30, position, null, b13);
+        damage_offset = col2 + (this.PIXEL - col2) / 2 - 12;
+    }
+    // 第二列
+    if (second_line.length > 0) {
+        var one = second_line.shift();
+        core.fillText('ui', one[0], col2, position, '#DDDDDD', f13);
+        core.fillText('ui', one[1], col2 + 30, position, null, b13);
+        damage_offset = col3 + (this.PIXEL - col3) / 2 - 12;
+    }
+    // 忽略第三列，直接绘制伤害
+    this._drawBook_drawDamage(index, enemy, damage_offset, position);
+}
+
+ui.prototype._drawBook_drawRow3 = function (index, enemy, top, left, width, position) {
+    // 绘制第三行
+    core.setTextAlign('ui', 'left');
+    var b13 = this._buildFont(13, true), f13 = this._buildFont(13, false);
+    var col1 = left, col2 = left + width * 9 / 25, col3 = left + width * 17 / 25;
+    core.fillText('ui', '临界', col1, position, '#DDDDDD', f13);
+    core.fillText('ui', core.formatBigNumber(enemy.critical||0), col1 + 30, position, null, b13);
+    core.fillText('ui', '减伤', col2, position, null, f13);
+    core.fillText('ui', core.formatBigNumber(enemy.criticalDamage||0), col2 + 30, position, null, b13);
+    core.fillText('ui', '1防', col3, position, null, f13);
+    core.fillText('ui', core.formatBigNumber(enemy.defDamage||0), col3 + 30, position, null, b13);
+}
+
+ui.prototype._drawBook_drawDamage = function (index, enemy, offset, position) {
+    core.setTextAlign('ui', 'center');
+    var damage = enemy.damage, color = '#FFFF00';
+    if (damage == null) {
+        damage = '无法战斗';
+        color = '#FF0000';
+    }
+    else {
+        if (damage >= core.status.hero.hp) color = '#FF0000';
+        if (damage <= 0) color = '#00FF00';
+        damage = core.formatBigNumber(damage);
+        if (core.enemys.hasSpecial(enemy, 19)) damage += "+";
+        if (core.enemys.hasSpecial(enemy, 21)) damage += "-";
+        if (core.enemys.hasSpecial(enemy, 11)) damage += "^";
+    }
+    if (enemy.notBomb) damage += "[b]";
+    core.fillText('ui', damage, offset, position, color, this._buildFont(13, true));
 }
 
 ////// 绘制怪物属性的详细信息 //////
 ui.prototype.drawBookDetail = function (index) {
-    var enemys = core.enemys.getCurrentEnemys(core.floorIds[core.status.event.selection]);
-    if (enemys.length==0) return;
-    if (index<0) index=0;
-    if (index>=enemys.length) index=enemys.length-1;
-
-    var enemy = enemys[index];
-    var enemyId=enemy.id;
-    var hints=core.enemys.getSpecialHint(core.material.enemys[enemyId]);
-
-
-    if (hints.length==0)
-        hints.push("该怪物无特殊属性。");
-
-    hints.push("");
-    var criticals = core.enemys.nextCriticals(enemyId, 10).map(function (v) {
-        return v[0]+":"+v[1];
-    });
-    while (criticals[0]=='0:0') criticals.shift();
-    hints.push("临界表："+JSON.stringify(criticals))
-
-    var content=hints.join("\n");
-
+    var info = this._drawBookDetail_getInfo(index), enemy = info[0];
+    if (!enemy) return;
+    var content = info[1].join("\n");
     core.status.event.id = 'book-detail';
     clearInterval(core.interval.tipAnimate);
-
     core.clearMap('data');
-    core.setOpacity('data', 1);
 
-    var left=10, right=416-2*left;
-    var content_left = left + 25;
+    var left = 10, width = this.PIXEL - 2 * left, right = left + width;
+    var content_left = left + 25, validWidth = right - content_left - 13;
+    var contents = core.splitLines("data", content, validWidth, this._buildFont(16, false));
+    var height = Math.max(24 * contents.length + 55, 80), top = (this.PIXEL - height) / 2, bottom = top + height;
 
-    var validWidth = right-(content_left-left)-13;
-    var contents = core.splitLines("data", content, validWidth, '16px Verdana');
-
-    var height = 416 - 10 - Math.min(416-24*(contents.length+1)-65, 250);
-    var top = (416-height)/2, bottom = height;
-
-    // var left = 97, top = 64, right = 416 - 2 * left, bottom = 416 - 2 * top;
     core.setAlpha('data', 0.9);
-    core.fillRect('data', left, top, right, bottom, '#000000');
+    core.fillRect('data', left, top, width, height, '#000000');
     core.setAlpha('data', 1);
-    core.strokeRect('data', left - 1, top - 1, right + 1, bottom + 1, '#FFFFFF', 2);
+    core.strokeRect('data', left - 1, top - 1, width + 1, height + 1,
+        core.status.globalAttribute.borderColor, 2);
 
+    this._drawBookDetail_drawContent(enemy, contents, {top: top, content_left: content_left, bottom: bottom});
+}
+
+ui.prototype._drawBookDetail_getInfo = function (index) {
+    var floorId = core.floorIds[(core.status.event.ui||{}).index] || core.status.floorId;
+    var enemys = core.enemys.getCurrentEnemys(floorId);
+    if (enemys.length==0) return [];
+    index = core.clamp(index, 0, enemys.length - 1);
+    var enemy = enemys[index], enemyId = enemy.id;
+    var texts=core.enemys.getSpecialHint(enemyId);
+    if (texts.length == 0) texts.push("该怪物无特殊属性。");
+    texts.push("");
+    this._drawBookDetail_getTexts(enemy, floorId, texts);
+    return [enemy, texts];
+}
+
+ui.prototype._drawBookDetail_getTexts = function (enemy, floorId, texts) {
+    // --- 模仿临界计算器
+    this._drawBookDetail_mofang(enemy, texts);
+    // --- 吸血怪最低生命值
+    this._drawBookDetail_vampire(enemy, texts);
+    // --- 仇恨伤害
+    this._drawBookDetail_hatred(enemy, texts);
+    // --- 战斗回合数，临界表
+    this._drawBookDetail_turnAndCriticals(enemy, floorId, texts);
+}
+
+ui.prototype._drawBookDetail_mofang = function (enemy, texts) {
+    // 模仿临界计算器
+    if (core.enemys.hasSpecial(enemy.special, 10)) {
+        var hp = enemy.hp;
+        var delta = core.status.hero.atk - core.status.hero.def;
+        if (delta<hp && hp<=10000 && hp>0) {
+            texts.push("模仿临界计算器：（当前攻防差"+core.formatBigNumber(delta)+"）");
+            var u = [];
+            this._drawBookDetail_mofang_getArray(hp).forEach(function (t) {
+                if (u.length < 20) u.push(t);
+                else if (Math.abs(t[0]-delta)<Math.abs(u[0][0]-delta)) {
+                    u.shift();
+                    u.push(t);
+                }
+            });
+            texts.push(JSON.stringify(u.map(function (v) {
+                return core.formatBigNumber(v[0])+":"+v[1];
+            })));
+        }
+    }
+}
+
+ui.prototype._drawBookDetail_mofang_getArray = function (hp) {
+    var arr = [];
+    var last=0, start=0;
+    for (var i=1;i<hp;i++) {
+        var now=parseInt((hp-1)/i);
+        if (now!=last) {
+            if (last!=0) {
+                arr.push([start, last+"x"]);
+            }
+            last=now;
+            start=i;
+        }
+    }
+    if (last!=0) {
+        arr.push([start,"1x"]);
+        arr.push([hp,"0"]);
+    }
+    return arr;
+}
+
+ui.prototype._drawBookDetail_vampire = function (enemy, texts) {
+    if (core.enemys.hasSpecial(enemy.special, 11)) {
+        var damage = core.getDamage(enemy.id);
+        if (damage != null) {
+            // 二分HP
+            var start = 1, end = 100 * damage;
+            var nowHp = core.status.hero.hp;
+            while (start<end) {
+                var mid = Math.floor((start+end)/2);
+                core.status.hero.hp = mid;
+                if (core.canBattle(enemy.id)) end = mid;
+                else start = mid+1;
+            }
+            core.status.hero.hp = start;
+            if (core.canBattle(enemy.id)) {
+                texts.push("打死该怪物最低需要生命值："+core.formatBigNumber(start));
+            }
+            core.status.hero.hp = nowHp;
+        }
+    }
+}
+
+ui.prototype._drawBookDetail_hatred = function (enemy, texts) {
+    if (core.enemys.hasSpecial(enemy.special, 17)) {
+        texts.push("当前仇恨伤害值："+core.getFlag('hatred', 0));
+    }
+}
+
+ui.prototype._drawBookDetail_turnAndCriticals = function (enemy, floorId, texts) {
+    var damageInfo = core.getDamageInfo(enemy, null, null, null, floorId);
+    texts.push("战斗回合数："+((damageInfo||{}).turn||0));
+    // 临界表
+    var criticals = core.enemys.nextCriticals(enemy, 10, null, null, floorId).map(function (v) {
+        return core.formatBigNumber(v[0])+":"+core.formatBigNumber(v[1]);
+    });
+    while (criticals[0]=='0:0') criticals.shift();
+    texts.push("临界表："+JSON.stringify(criticals))
+}
+
+ui.prototype._drawBookDetail_drawContent = function (enemy, contents, pos) {
     // 名称
-    core.canvas.data.textAlign = "left";
-
-    core.fillText('data', enemy.name, content_left, top + 30, '#FFD700', 'bold 22px Verdana');
-    var content_top = top + 57;
+    core.setTextAlign('data', 'left');
+    core.fillText('data', enemy.name, pos.content_left, pos.top + 30, '#FFD700', this._buildFont(22, true));
+    var content_top = pos.top + 57;
 
     for (var i=0;i<contents.length;i++) {
-        // core.fillText('data', contents[i], content_left, content_top, '#FFFFFF', '16px Verdana');
         var text=contents[i];
         var index=text.indexOf("：");
         if (index>=0) {
             var x1 = text.substring(0, index+1);
-            core.fillText('data', x1, content_left, content_top, '#FF6A6A', 'bold 16px Verdana');
-            var len=core.canvas.data.measureText(x1).width;
-            core.fillText('data', text.substring(index+1), content_left+len, content_top, '#FFFFFF', '16px Verdana');
+            core.fillText('data', x1, pos.content_left, content_top, '#FF6A6A', this._buildFont(16, true));
+            var len=core.calWidth('data', x1);
+            core.fillText('data', text.substring(index+1), pos.content_left+len, content_top, '#FFFFFF', this._buildFont(16, false));
         }
         else {
-            core.fillText('data', contents[i], content_left, content_top, '#FFFFFF', '16px Verdana');
+            core.fillText('data', contents[i], pos.content_left, content_top, '#FFFFFF', this._buildFont(16, false));
         }
         content_top+=24;
     }
-
-    core.fillText('data', '<点击任意位置继续>', 270, top+height-13, '#CCCCCC', '13px Verdana');
 }
 
 ////// 绘制楼层传送器 //////
 ui.prototype.drawFly = function(page) {
-
-    if (page<0) page=0;
-    if (page>=core.status.hero.flyRange.length) page=core.status.hero.flyRange.length-1;
     core.status.event.data = page;
-
-    var floorId = core.status.hero.flyRange[page];
+    var floorId = core.floorIds[page];
     var title = core.status.maps[floorId].title;
-
     core.clearMap('ui');
     core.setAlpha('ui', 0.85);
-    core.fillRect('ui', 0, 0, 416, 416, '#000000');
+    core.fillRect('ui', 0, 0, this.PIXEL, this.PIXEL, '#000000');
     core.setAlpha('ui', 1);
-    core.canvas.ui.textAlign = 'center';
-    core.fillText('ui', '楼层跳跃', 208, 60, '#FFFFFF', "bold 28px Verdana");
-    core.fillText('ui', '返回游戏', 208, 403, '#FFFFFF', "bold 15px Verdana")
-    core.fillText('ui', title, 356, 247, '#FFFFFF', "bold 19px Verdana");
-    if (page<core.status.hero.flyRange.length-1) {
-        core.fillText('ui', '▲', 356, 247 - 64, '#FFFFFF', "17px Verdana");
-        core.fillText('ui', '▲', 356, 247 - 96, '#FFFFFF', "17px Verdana");
-        core.fillText('ui', '▲', 356, 247 - 96 - 7, '#FFFFFF', "17px Verdana");
+    core.setTextAlign('ui', 'center');
+    core.fillText('ui', '楼层跳跃', this.HPIXEL, 60, '#FFFFFF', this._buildFont(28, true));
+    core.fillText('ui', '返回游戏', this.HPIXEL, this.PIXEL - 13, null, this._buildFont(15, true))
+    core.fillText('ui', title, this.PIXEL - 60, this.HPIXEL + 39, null, this._buildFont(19, true));
+    var middle = this.HPIXEL + 39;
+    if (core.actions._getNextFlyFloor(1) != page) {
+        core.fillText('ui', '▲', this.PIXEL - 60, middle - 64, null, this._buildFont(17, false));
+        core.fillText('ui', '▲', this.PIXEL - 60, middle - 96);
+        core.fillText('ui', '▲', this.PIXEL - 60, middle - 96 - 7);
     }
-    if (page>0) {
-        core.fillText('ui', '▼', 356, 247 + 64, '#FFFFFF', "17px Verdana");
-        core.fillText('ui', '▼', 356, 247 + 96, '#FFFFFF', "17px Verdana");
-        core.fillText('ui', '▼', 356, 247 + 96 + 7, '#FFFFFF', "17px Verdana");
+    if (core.actions._getNextFlyFloor(-1) != page) {
+        core.fillText('ui', '▼', this.PIXEL - 60, middle + 64, null, this._buildFont(17, false));
+        core.fillText('ui', '▼', this.PIXEL - 60, middle + 96);
+        core.fillText('ui', '▼', this.PIXEL - 60, middle + 96 + 7);
     }
-    core.strokeRect('ui', 20, 100, 273, 273, '#FFFFFF', 2);
-    this.drawThumbnail(floorId, 'ui', core.status.maps[floorId].blocks, 20, 100, 273);
+    var size = this.PIXEL - 143;
+    core.strokeRect('ui', 20, 100, size, size, '#FFFFFF', 2);
+    core.drawThumbnail(floorId, null, null, {ctx: 'ui', x: 20, y: 100, size: size});
+}
+
+////// 绘制中心对称飞行器
+ui.prototype.drawCenterFly = function () {
+    core.lockControl();
+    core.status.event.id = 'centerFly';
+    var fillstyle = 'rgba(255,0,0,0.5)';
+    if (core.canUseItem('centerFly')) fillstyle = 'rgba(0,255,0,0.5)';
+    var toX = core.bigmap.width - 1 - core.getHeroLoc('x'), toY = core.bigmap.height - 1 - core.getHeroLoc('y');
+    core.drawThumbnail(null, null, {heroLoc: core.status.hero.loc, heroIcon: core.getFlag('heroIcon', "hero.png")},
+        {ctx: 'ui', centerX: toX, centerY: toY});
+    var offsetX = core.clamp(toX - core.__HALF_SIZE__, 0, core.bigmap.width - core.__SIZE__),
+        offsetY = core.clamp(toY - core.__HALF_SIZE__, 0, core.bigmap.height - core.__SIZE__);
+    core.fillRect('ui', (toX - offsetX) * 32, (toY - offsetY) * 32, 32, 32, fillstyle);
+    core.status.event.data = {"x": toX, "y": toY, "posX": toX - offsetX, "posY": toY - offsetY};
+    core.drawTip("请确认当前中心对称飞行器的位置");
+    return;
+}
+
+////// 绘制全局商店
+ui.prototype.drawShop = function (shopId) {
+    var shop = core.status.shops[shopId];
+    var actions = [], fromList = (core.status.event.data||{}).fromList, selection = core.status.event.selection;
+    if (core.status.event.data && core.status.event.data.actions) actions=core.status.event.data.actions;
+
+    core.ui.closePanel();
+    core.lockControl();
+    core.status.event.id = 'shop';
+    core.status.event.data = {'id': shopId, 'shop': shop, 'actions': actions, 'fromList': fromList};
+    core.status.event.selection = selection;
+
+    var times = shop.times, need=core.calValue(shop.need, null, null, times);
+    var content = "\t["+shop.name+","+shop.icon+"]" + core.replaceText(shop.text, need, times);
+    var use = shop.use=='experience'?'经验':'金币';
+    var choices = [];
+    for (var i=0;i<shop.choices.length;i++) {
+        var choice = shop.choices[i];
+        var text = core.replaceText(choice.text, need, times);
+        if (core.isset(choice.need))
+            text += "（"+core.calValue(choice.need, null, null, times)+use+"）";
+        choices.push({"text": text, "color":shop.visited?null:"#999999"});
+    }
+    choices.push("离开");
+    core.ui.drawChoices(content, choices);
 }
 
 ////// 绘制浏览地图界面 //////
 ui.prototype.drawMaps = function (index, x, y) {
     core.lockControl();
     core.status.event.id = 'viewMaps';
-
-    if (!core.isset(index)) {
-        core.status.event.data = null;
-        core.clearMap('ui');
-        core.setAlpha('ui', 1);
-
-        core.clearMap('animate');
-        core.setOpacity('animate', 0.4);
-        core.fillRect('animate', 0, 0, 416, 416, '#000000');
-
-        core.strokeRect('ui', 66, 2, 284, 60, "#FFD700", 4);
-        core.strokeRect('ui', 2, 66, 60, 284);
-        core.strokeRect('ui', 66, 416-62, 284, 60);
-        core.strokeRect('ui', 416-62, 66, 60, 284);
-        core.strokeRect('ui', 66, 66, 284, 92);
-        core.strokeRect('ui', 66, 32*8+2, 284, 92);
-        core.canvas.ui.textAlign = 'center';
-        core.fillText('ui', "上移地图 [W]", 208, 38, '#FFD700', '20px Arial');
-        core.fillText('ui', "下移地图 [S]", 208, 390);
-
-        var top = 150;
-        core.fillText('ui', "左", 32, top);
-        core.fillText('ui', "移", 32, top+32);
-        core.fillText('ui', "地", 32, top+32*2);
-        core.fillText('ui', "图", 32, top+32*3);
-        core.fillText('ui', "[A]", 32, top+32*4);
-        core.fillText('ui', "右", 384, top);
-        core.fillText('ui', "移", 384, top+32);
-        core.fillText('ui', "地", 384, top+32*2);
-        core.fillText('ui', "图", 384, top+32*3);
-        core.fillText('ui', "[D]", 384, top+32*4);
-
-        core.fillText('ui', "前张地图 [▲ / PGUP]", 208, 64+54);
-        core.fillText('ui', "后张地图 [▼ / PGDN]", 208, 32*8+54);
-
-        core.fillText('ui', "退出 [ESC / ENTER]", 208, 208+8);
-        core.fillText('ui', "[X] 可查看怪物手册", 285, 208+40, null, '13px Arial');
-        return;
-    }
-
-    core.clearMap('animate');
-    core.setOpacity('animate', 1);
-
-    if (core.isset(index.index)) {
-        x=index.x;
-        y=index.y;
-        index=index.index;
-    }
-
-    if (index<0) index=0;
-    if (index>=core.floorIds.length) index=core.floorIds.length-1;
-    var floorId = core.floorIds[index], mw = core.floors[floorId].width||13, mh = core.floors[floorId].height||13;
-    if (!core.isset(x)) x = parseInt(mw/2);
-    if (!core.isset(y)) y = parseInt(mh/2);
-    if (x<6) x=6;
-    if (x>mw-7) x=mw-7;
-    if (y<6) y=6;
-    if (y>mh-7) y=mh-7;
-
-    core.status.event.data = {"index": index, "x": x, "y": y};
-
+    this.clearUI();
+    if (index == null) return this._drawMaps_drawHint();
     clearTimeout(core.interval.tipAnimate);
-    core.clearMap('ui');
-    core.setAlpha('ui', 1);
-    this.drawThumbnail(floorId, 'ui', core.status.maps[floorId].blocks, 0, 0, 416, x, y);
-
+    core.status.checkBlock.cache = {};
+    var data = this._drawMaps_buildData(index, x, y);
+    core.drawThumbnail(data.floorId, null, {damage: data.damage},
+        {ctx: 'ui', centerX: data.x, centerY: data.y, all: data.all});
+    // 绘图
+    if (data.paint) {
+        var offsetX = 32 * (data.x - this.HSIZE), offsetY = 32 * (data.y - this.HSIZE);
+        var value = core.paint[data.floorId];
+        if (value) value = lzw_decode(value).split(",");
+        core.utils._decodeCanvas(value, 32 * data.mw, 32 * data.mh);
+        core.drawImage('ui', core.bigmap.tempCanvas.canvas, offsetX * 32, offsetY * 32,
+            this.PIXEL, this.PIXEL, 0, 0, this.PIXEL, this.PIXEL);
+    }
     core.clearMap('data');
-    core.setOpacity('data', 0.2);
-    core.canvas.data.textAlign = 'left';
+    core.setTextAlign('data', 'left');
     core.setFont('data', '16px Arial');
+    var text = core.status.maps[data.floorId].title;
+    if (!data.all && (data.mw>this.SIZE || data.mh>this.SIZE))
+        text+=" ["+(data.x-this.HSIZE)+","+(data.y-this.HSIZE)+"]";
+    var textX = 16, textY = 18, width = textX + core.calWidth('data', text) + 16, height = 42;
+    core.fillRect('data', 5, 5, width, height, 'rgba(0,0,0,0.4)');
+    core.fillText('data', text, textX + 5, textY + 15, 'rgba(255,255,255,0.6)');
+}
 
+ui.prototype._drawMaps_drawHint = function () {
+    core.fillRect('ui', 0, 0, this.PIXEL, this.PIXEL, 'rgba(0,0,0,0.4)');
+    core.setTextAlign('ui', 'center');
+    var stroke = function (left, top, width, height, fillStyle, lineWidth) {
+        core.strokeRect('ui', left*32+2, top*32+2, width*32-4, height*32-4, fillStyle, lineWidth);
+    }
+    var per = this.HSIZE - 4;
+    stroke(per, 0, 9, per, '#FFD700', 4); // up
+    stroke(0, per, per, 9); // left
+    stroke(per, this.SIZE - per, 9, per); // down
+    stroke(this.SIZE - per, per, per, 9); // right
+    stroke(per, per, 9, 3); // prev
+    stroke(per, this.SIZE - per - 3, 9, 3); // next
+    stroke(0, 0, per-1, per-1); // left top
+    stroke(this.SIZE-(per - 1), 0, per-1, per-1); // right top
+    stroke(0, this.SIZE-(per-1), per-1, per-1); // left bottom
 
-    var text = core.floors[floorId].title;
-    if (mw>13 || mh>13) text+=" ["+(x-6)+","+(y-6)+"]";
-    var textX = 16, textY = 18, width = textX + core.canvas.data.measureText(text).width + 16, height = 42;
-    core.fillRect('data', 5, 5, width, height, '#000');
-    core.setOpacity('data', 0.4);
-    core.fillText('data', text, textX + 5, textY + 15, '#fff');
+    core.setTextBaseline('ui', 'middle');
+    core.fillText('ui', "上移地图 [W]", this.HPIXEL, per * 16, '#FFD700', '20px Arial');
+    core.fillText('ui', "下移地图 [S]", this.HPIXEL, this.PIXEL - per * 16);
+    core.fillText('ui', 'V', (per-1)*16, (per-1)*16);
+    core.fillText('ui', 'Z', this.PIXEL - (per-1)*16, (per-1)*16);
+    core.fillText('ui', 'M', (per-1)*16, this.PIXEL - (per-1)*16);
 
+    var top = this.HPIXEL - 66, left = per * 16, right = this.PIXEL - left;
+    var lt = ["左", "移", "地", "图", "[A]"], rt = ["右", "移", "地", "图", "[D]"];
+    for (var i = 0; i < 5; ++i) {
+        core.fillText("ui", lt[i], left, top + 32 * i);
+        core.fillText("ui", rt[i], right, top + 32 * i);
+    }
+    core.fillText('ui', "前张地图 [▲ / PGUP]", this.HPIXEL, 32 * per + 48);
+    core.fillText('ui', "后张地图 [▼ / PGDN]", this.HPIXEL, this.PIXEL - (32 * per + 48));
+
+    core.fillText('ui', "退出 [ESC / ENTER]", this.HPIXEL, this.HPIXEL);
+    core.fillText('ui', "[X] 可查看怪物手册", this.HPIXEL + 77, this.HPIXEL + 32, null, '13px Arial');
+
+    core.setTextBaseline('ui', 'alphabetic');
+}
+
+ui.prototype._drawMaps_buildData = function (index, x, y) {
+    var damage = (core.status.event.data||{}).damage;
+    var paint =  (core.status.event.data||{}).paint;
+    var all = (core.status.event.data||{}).all;
+    if (index.damage != null) damage=index.damage;
+    if (index.paint != null) paint=index.paint;
+    if (index.all != null) all=index.all;
+    if (index.index != null) { x=index.x; y=index.y; index=index.index; }
+    index = core.clamp(index, 0, core.floorIds.length-1);
+    if (damage == null) damage = true; // 浏览地图默认开显伤好了
+
+    var floorId = core.floorIds[index], mw = core.floors[floorId].width, mh = core.floors[floorId].height;
+    if (x == null) x = parseInt(mw / 2);
+    if (y == null) y = parseInt(mh / 2);
+    x = core.clamp(x, this.HSIZE, mw - this.HSIZE - 1);
+    y = core.clamp(y, this.HSIZE, mh - this.HSIZE - 1);
+
+    core.status.event.data = {index: index, x: x, y: y, floorId: floorId, mw: mw, mh: mh,
+                              damage: damage, paint: paint, all: all };
+    return core.status.event.data;
 }
 
 ////// 绘制道具栏 //////
 ui.prototype.drawToolbox = function(index) {
+    var info = this._drawToolbox_getInfo(index);
+    this._drawToolbox_drawBackground();
 
-    var tools = Object.keys(core.status.hero.items.tools).sort();
-    var constants = Object.keys(core.status.hero.items.constants).sort();
-
-    if (!core.isset(index)) {
-        if (tools.length>0) index=0;
-        else if (constants.length>0) index=1000;
-        else index=0;
-    }
-
-    core.status.event.selection=index;
-
-    var selectId;
-    if (index<1000) {
-        if (index>=tools.length) index=Math.max(0, tools.length-1);
-        selectId = tools[index];
-    }
-    else {
-        if (index-1000>=constants.length) index=1000+Math.max(0, constants.length-1);
-        selectId = constants[index-1000];
-    }
-
-    var page = parseInt((index%1000)/12)+1;
-    var totalPage = Math.ceil(Math.max(tools.length, constants.length)/12);
-
-    if (!core.hasItem(selectId)) selectId=null;
-
-    core.status.event.data=selectId;
-
-    core.clearMap('ui');
-    core.setAlpha('ui', 0.85);
-    core.fillRect('ui', 0, 0, 416, 416, '#000000');
+    // 绘制线
     core.setAlpha('ui', 1);
-    core.setFillStyle('ui', '#DDDDDD');
     core.setStrokeStyle('ui', '#DDDDDD');
     core.canvas.ui.lineWidth = 2;
     core.canvas.ui.strokeWidth = 2;
+    core.setTextAlign('ui', 'right');
+    var line1 = this.PIXEL - 306;
+    this._drawToolbox_drawLine(line1, "消耗道具");
+    var line2 = this.PIXEL - 146;
+    this._drawToolbox_drawLine(line2, "永久道具");
 
-    var ydelta = 20;
+    this._drawToolbox_drawDescription(info, line1);
 
-    // 画线
+    this._drawToolbox_drawContent(info, line1, info.tools, info.toolsPage, true);
+    this.drawPagination(info.toolsPage, info.toolsTotalPage, this.LAST - 5);
+    this._drawToolbox_drawContent(info, line2, info.constants, info.constantsPage);
+    this.drawPagination(info.constantsPage, info.constantsTotalPage);
+
+    core.setTextAlign('ui', 'center');
+    core.fillText('ui', '[装备栏]', this.PIXEL - 46, 25, '#DDDDDD', this._buildFont(15, true));
+    core.fillText('ui', '返回游戏', this.PIXEL - 46, this.PIXEL - 13);
+}
+
+ui.prototype._drawToolbox_getInfo = function (index) {
+    // 设定eventdata
+    if (!core.status.event.data || core.status.event.data.toolsPage == null)
+        core.status.event.data = {"toolsPage":1, "constantsPage":1, "selectId":null}
+    // 获取物品列表
+    var tools = Object.keys(core.status.hero.items.tools).sort();
+    var constants = Object.keys(core.status.hero.items.constants).sort();
+    // 处理页数
+    var toolsPage = core.status.event.data.toolsPage;
+    var constantsPage = core.status.event.data.constantsPage;
+    var toolsTotalPage = Math.ceil(tools.length/this.LAST);
+    var constantsTotalPage = Math.ceil(constants.length/this.LAST);
+    // 处理index
+    if (index == null)
+        index = tools.length == 0 && constants.length > 0 ? this.LAST : 0;
+    core.status.event.selection=index;
+    // 确认选择对象
+    var select, selectId;
+    if (index<this.LAST) {
+        select = index + (toolsPage-1)*this.LAST;
+        if (select>=tools.length) select=Math.max(0, tools.length-1);
+        selectId = tools[select];
+    }
+    else {
+        select = index%this.LAST + (constantsPage-1)*this.LAST;
+        if (select>=constants.length) select=Math.max(0, constants.length-1);
+        selectId = constants[select];
+    }
+    if (!core.hasItem(selectId)) selectId=null;
+    core.status.event.data.selectId=selectId;
+    return {
+        index: index, tools: tools, constants: constants, toolsPage: toolsPage, constantsPage: constantsPage,
+        toolsTotalPage: toolsTotalPage, constantsTotalPage: constantsTotalPage, selectId: selectId
+    };
+}
+
+ui.prototype._drawToolbox_drawBackground = function () {
+    // 绘制
+    core.clearMap('ui');
+    core.setAlpha('ui', 0.85);
+    core.fillRect('ui', 0, 0, this.PIXEL, this.PIXEL, '#000000');
+}
+
+ui.prototype._drawToolbox_drawLine = function (yoffset, text) {
+    core.setFillStyle('ui', '#DDDDDD');
     core.canvas.ui.beginPath();
-    core.canvas.ui.moveTo(0, 130-ydelta);
-    core.canvas.ui.lineTo(416, 130-ydelta);
+    core.canvas.ui.moveTo(0, yoffset);
+    core.canvas.ui.lineTo(this.PIXEL, yoffset);
     core.canvas.ui.stroke();
     core.canvas.ui.beginPath();
-    core.canvas.ui.moveTo(416,129-ydelta);
-    core.canvas.ui.lineTo(416,105-ydelta);
-    core.canvas.ui.lineTo(416-72,105-ydelta);
-    core.canvas.ui.lineTo(416-102,129-ydelta);
+    core.canvas.ui.moveTo(this.PIXEL, yoffset-1);
+    core.canvas.ui.lineTo(this.PIXEL, yoffset-25);
+    core.canvas.ui.lineTo(this.PIXEL-72, yoffset-25);
+    core.canvas.ui.lineTo(this.PIXEL-102, yoffset-1);
     core.canvas.ui.fill();
+    core.fillText('ui', text, this.PIXEL - 5, yoffset-6, '#333333', this._buildFont(16, true));
+}
 
-    core.canvas.ui.beginPath();
-    core.canvas.ui.moveTo(0, 290-ydelta);
-    core.canvas.ui.lineTo(416, 290-ydelta);
-    core.canvas.ui.stroke();
-    core.canvas.ui.beginPath();
-    core.canvas.ui.moveTo(416,289-ydelta);
-    core.canvas.ui.lineTo(416,265-ydelta);
-    core.canvas.ui.lineTo(416-72,265-ydelta);
-    core.canvas.ui.lineTo(416-102,289-ydelta);
-    core.canvas.ui.fill();
+ui.prototype._drawToolbox_drawDescription = function (info, max_height) {
+    core.setTextAlign('ui', 'left');
+    if (!info.selectId) return;
+    var item=core.material.items[info.selectId];
+    core.fillText('ui', item.name, 10, 32, '#FFD700', this._buildFont(20, true))
+    var text = item.text||"该道具暂无描述。";
+    try {
+        // 检查能否eval
+        text = core.replaceText(text);
+    } catch (e) {}
+    var lines = core.splitLines('ui', text, this.PIXEL - 15, this._buildFont(17, false));
+    // --- 开始逐行绘制
+    var curr = 62, line_height = 25;
+    core.setFillStyle('ui', '#FFFFFF');
+    for (var i=0;i<lines.length;++i) {
+        core.fillText('ui', lines[i], 10, curr);
+        curr += line_height;
+        if (curr>=max_height) break;
+    }
+    if (curr < max_height) {
+        core.fillText('ui', '<继续点击该道具即可进行使用>', 10, curr, '#CCCCCC', this._buildFont(14, false));
+    }
+}
 
-    // 文字
-    core.canvas.ui.textAlign = 'right';
-    core.fillText('ui', "消耗道具", 411, 124-ydelta, '#333333', "bold 16px Verdana");
-    core.fillText('ui', "永久道具", 411, 284-ydelta);
+ui.prototype._drawToolbox_drawContent = function (info, line, items, page, drawCount) {
+    core.setTextAlign('ui', 'right');
+    for (var i = 0; i < this.LAST; i++) {
+        var item = items[this.LAST * (page - 1) + i];
+        if (!item) continue;
+        var yoffset = line + 54 * Math.floor(i / this.HSIZE) + 19;
+        var icon = core.material.icons.items[item], image = core.material.images.items;
+        core.drawImage('ui', image, 0, 32 * icon, 32, 32, 64 * (i % this.HSIZE) + 21, yoffset, 32, 32);
+        if (drawCount)
+            core.fillText('ui', core.itemCount(item), 64 * (i % this.HSIZE) + 56, yoffset + 33, '#FFFFFF', this._buildFont(14, true));
+        if (info.selectId == item)
+            core.strokeRect('ui', 64 * (i % this.HSIZE) + 17, yoffset - 4, 40, 40, '#FFD700');
+    }
+}
 
-    core.canvas.ui.textAlign = 'left';
-    // 描述
-    if (core.isset(selectId)) {
-        var item=core.material.items[selectId];
-        core.fillText('ui', item.name, 10, 32, '#FFD700', "bold 20px Verdana")
+////// 绘制装备界面 //////
+ui.prototype.drawEquipbox = function(index) {
+    var info = this._drawEquipbox_getInfo(index);
+    this._drawToolbox_drawBackground();
 
-        var text = item.text||"该道具暂无描述。";
-        var lines = core.splitLines('ui', text, 406, '17px Verdana');
+    core.setAlpha('ui', 1);
+    core.setStrokeStyle('ui', '#DDDDDD');
+    core.canvas.ui.lineWidth = 2;
+    core.canvas.ui.strokeWidth = 2;
+    core.setTextAlign('ui', 'right');
+    var line1 = this.PIXEL - 306;
+    this._drawToolbox_drawLine(line1, "当前装备");
+    var line2 = this.PIXEL - 146;
+    this._drawToolbox_drawLine(line2, "拥有装备");
 
-        core.fillText('ui', lines[0], 10, 62, '#FFFFFF', '17px Verdana');
+    this._drawEquipbox_description(info, line1);
 
-        if (lines.length==1) {
-            core.fillText('ui', '<继续点击该道具即可进行使用>', 10, 89, '#CCCCCC', '14px Verdana');
-        }
+    this._drawEquipbox_drawEquiped(info, line1);
+    this._drawToolbox_drawContent(info, line2, info.ownEquipment, info.page, true);
+    this.drawPagination(info.page, info.totalPage);
+
+    core.setTextAlign('ui', 'center');
+    core.fillText('ui', '[道具栏]', this.PIXEL - 46, 25, '#DDDDDD', this._buildFont(15, true));
+    core.fillText('ui', '返回游戏', this.PIXEL - 46, this.PIXEL - 13);
+}
+
+ui.prototype._drawEquipbox_getInfo = function (index) {
+    if (!core.status.event.data || core.status.event.data.page == null)
+        core.status.event.data = {"page":1, "selectId":null};
+    var allEquips = core.status.globalAttribute.equipName;
+    var equipLength = allEquips.length;
+    if (!core.status.hero.equipment) core.status.hero.equipment = [];
+    var equipEquipment = core.status.hero.equipment;
+    var ownEquipment = Object.keys(core.status.hero.items.equips).sort();
+    var page = core.status.event.data.page;
+    var totalPage = Math.ceil(ownEquipment.length / this.LAST);
+    // 处理index
+    if (index == null) {
+        if (equipLength > 0 && equipEquipment[0]) index = 0;
+        else if (ownEquipment.length > 0) index = this.LAST;
+        else index = 0;
+    }
+    if (index >= this.LAST && ownEquipment.length == 0) index = 0;
+    var selectId=null;
+    if (index < this.LAST) {
+        if (index >= equipLength) index=Math.max(0, equipLength - 1);
+        selectId = equipEquipment[index] || null;
+    }
+    else {
+        if (page == totalPage) index = Math.min(index, (ownEquipment.length+this.LAST-1)%this.LAST+this.LAST);
+        selectId = ownEquipment[index - this.LAST + (page - 1) * this.LAST];
+        if (!core.hasItem(selectId)) selectId=null;
+    }
+    core.status.event.selection=index;
+    core.status.event.data.selectId=selectId;
+    return { index: index, selectId: selectId, page: page, totalPage: totalPage, allEquips: allEquips,
+            equipLength: equipLength, equipEquipment: equipEquipment, ownEquipment: ownEquipment};
+}
+
+ui.prototype._drawEquipbox_description = function (info, max_height) {
+    core.setTextAlign('ui', 'left');
+    if (!info.selectId) return;
+    var equip=core.material.items[info.selectId];
+    // --- 标题
+    if (!equip.equip) equip.equip = {"type": 0};
+    var equipType = equip.equip.type, equipString;
+    if (typeof equipType === 'string') {
+        equipString = equipType || "未知部位";
+        equipType = core.items.getEquipTypeByName(equipType);
+    }
+    else equipString = info.allEquips[equipType] || "未知部位";
+    core.fillText('ui', equip.name + "（" + equipString + "）", 10, 32, '#FFD700', this._buildFont(20, true))
+    // --- 描述
+    var text = equip.text || "该装备暂无描述。";
+    try {
+        text = core.replaceText(text);
+    } catch (e) {}
+    var lines = core.splitLines('ui', text, this.PIXEL - 15, this._buildFont(17, false));
+    var curr = 62, line_height = 25;
+    core.setFillStyle('ui', '#FFFFFF');
+    for (var i = 0; i < lines.length; ++i) {
+        core.fillText('ui', lines[i], 10, curr);
+        curr += line_height;
+        if (curr >= max_height) break;
+    }
+    // --- 变化值
+    if (curr >= max_height) return;
+    this._drawEquipbox_drawStatusChanged(info, curr, equip, equipType);
+}
+
+ui.prototype._drawEquipbox_getStatusChanged = function (info, equip, equipType) {
+    var compare, differentMode = null;
+    if (info.index < this.LAST) compare = core.compareEquipment(null, info.selectId);
+    else {
+        if (equipType<0) differentMode = '<当前没有该装备的空位，请先卸下装备>';
         else {
-            var leftText = text.substring(lines[0].length);
-            core.fillText('ui', leftText, 10, 89, '#FFFFFF', '17px Verdana');
+            var last = core.material.items[info.equipEquipment[equipType]]||{};
+            if (last.equip && (last.equip.percentage || false) != (equip.equip.percentage || false))
+                differentMode = '<数值和比例模式之间的切换不显示属性变化>';
+            else
+                compare = core.compareEquipment(info.selectId, info.equipEquipment[equipType]);
         }
     }
-
-    core.canvas.ui.textAlign = 'right';
-    var images = core.material.images.items;
-    // 消耗道具
-
-    for (var i=0;i<12;i++) {
-        var tool=tools[12*(page-1)+i];
-        if (!core.isset(tool)) break;
-        var icon=core.material.icons.items[tool];
-        if (i<6) {
-            core.canvas.ui.drawImage(images, 0, icon*32, 32, 32, 16*(4*i+1)+5, 144+5-ydelta, 32, 32)
-            // 个数
-            core.fillText('ui', core.itemCount(tool), 16*(4*i+1)+40, 144+38-ydelta, '#FFFFFF', "bold 14px Verdana");
-            if (selectId == tool)
-                core.strokeRect('ui', 16*(4*i+1)+1, 144+1-ydelta, 40, 40, '#FFD700');
-        }
-        else {
-            core.canvas.ui.drawImage(images, 0, icon*32, 32, 32, 16*(4*(i-6)+1)+5, 144+64+5-ydelta, 32, 32)
-            // 个数
-            core.fillText('ui', core.itemCount(tool), 16*(4*(i-6)+1)+40, 144+64+38-ydelta, '#FFFFFF', "bold 14px Verdana");
-            if (selectId == tool)
-                core.strokeRect('ui', 16*(4*(i-6)+1)+1, 144+64+1-ydelta, 40, 40, '#FFD700');
-
-        }
+    if (differentMode != null) {
+        core.fillText('ui', differentMode, 10, y, '#CCCCCC', this._buildFont(14, false));
+        return;
     }
+    return compare;
+}
 
-    // 永久道具
-    for (var i=0;i<12;i++) {
-        var constant=constants[12*(page-1)+i];
-        if (!core.isset(constant)) break;
-        var icon=core.material.icons.items[constant];
-        if (i<6) {
-            core.canvas.ui.drawImage(images, 0, icon*32, 32, 32, 16*(4*i+1)+5, 304+5-ydelta, 32, 32)
+ui.prototype._drawEquipbox_drawStatusChanged = function (info, y, equip, equipType) {
+    var compare = this._drawEquipbox_getStatusChanged(info, equip, equipType);
+    if (compare == null) return;
+    var obj = { drawOffset: 10, y: y };
 
-            if (selectId == constant)
-                core.strokeRect('ui', 16*(4*i+1)+1, 304+1-ydelta, 40, 40, '#FFD700');
+    // --- 变化值...
+    core.setFont('ui', this._buildFont(14, true));
+    for (var name in compare) {
+        var img = core.statusBar.icons[name];
+        var text = core.getStatusName(name);
+        if (img && core.flags.iconInEquipbox) { // 绘制图标
+            core.drawImage('ui', img, 0, 0, 32, 32, obj.drawOffset, obj.y - 13, 16, 16);
+            obj.drawOffset += 20;
         }
-        else {
-            core.canvas.ui.drawImage(images, 0, icon*32, 32, 32, 16*(4*(i-6)+1)+5, 304+64+5-ydelta, 32, 32)
-            if (selectId == constant)
-                core.strokeRect('ui', 16*(4*(i-6)+1)+1, 304+64+1-ydelta, 40, 40, '#FFD700');
+        else { // 绘制文字
+            this._drawEquipbox_drawStatusChanged_draw(text + " ", '#CCCCCC', obj);
         }
+        var nowValue = core.getStatus(name) * core.getBuff(name), newValue = (nowValue + compare[name]) * core.getBuff(name);
+        if (equip.equip.percentage) {
+            var nowBuff = core.getBuff(name), newBuff = nowBuff + compare[name] / 100;
+            nowValue = Math.floor(nowBuff * core.getStatus(name));
+            newValue = Math.floor(newBuff * core.getStatus(name));
+        }
+        nowValue = core.formatBigNumber(nowValue);
+        newValue = core.formatBigNumber(newValue);
+        this._drawEquipbox_drawStatusChanged_draw(nowValue+"->", '#CCCCCC', obj);
+        this._drawEquipbox_drawStatusChanged_draw(newValue, compare[name]>0?'#00FF00':'#FF0000', obj);
+        obj.drawOffset += 8;
     }
+}
 
-    // 退出
-    this.drawPagination(page, totalPage);
-    core.canvas.ui.textAlign = 'center';
-    // core.fillText('ui', '删除道具', 370, 32,'#DDDDDD', 'bold 15px Verdana');
-    core.fillText('ui', '返回游戏', 370, 403,'#DDDDDD', 'bold 15px Verdana');
+ui.prototype._drawEquipbox_drawStatusChanged_draw = function (text, color, obj) {
+    var len = core.calWidth('ui', text);
+    if (obj.drawOffset + len >= core.__PIXELS__) { // 换行
+        obj.y += 19;
+        obj.drawOffset = 10;
+    }
+    core.fillText('ui', text, obj.drawOffset, obj.y, color);
+    obj.drawOffset += len;
+}
+
+ui.prototype._drawEquipbox_drawEquiped = function (info, line) {
+    core.setTextAlign('ui', 'center');
+    var per_line = this.HSIZE - 3, width = Math.floor(this.PIXEL / (per_line + 0.25));
+    // 当前装备
+    for (var i = 0; i < info.equipLength ; i++) {
+        var equipId = info.equipEquipment[i] || null;
+        // var offset_text = width * (i % per_line) + 56;
+        var offset_image = width * (i % per_line) + width * 2 / 3;
+        var offset_text = offset_image - (width - 32) / 2;
+        var y = line + 54 * Math.floor(i / per_line) + 19;
+        if (equipId) {
+            var icon = core.material.icons.items[equipId];
+            core.drawImage('ui', core.material.images.items, 0, 32 * icon, 32, 32, offset_image, y, 32, 32);
+        }
+        core.fillText('ui', info.allEquips[i] || "未知", offset_text, y + 27, '#FFFFFF', this._buildFont(16, true))
+        core.strokeRect('ui', offset_image - 4, y - 4, 40, 40, info.index==i?'#FFD700':"#FFFFFF");
+    }
 }
 
 ////// 绘制存档/读档界面 //////
-ui.prototype.drawSLPanel = function(index) {
-    if (!core.isset(index)) index=1;
-    if (index<0) index=0;
+ui.prototype.drawSLPanel = function(index, refresh) {
+    core.control._loadFavoriteSaves();
+    if (index == null) index = 1;
+    if (index < 0) index = 0;
 
     var page = parseInt(index/10), offset=index%10;
     var max_page = main.savePages || 30;
+    if(core.status.event.data && core.status.event.data.mode=='fav')
+        max_page = Math.ceil((core.saves.favorite||[]).length/5);
     if (page>=max_page) page=max_page - 1;
     if (offset>5) offset=5;
-    index=10*page+offset;
-
-    core.status.event.data=index;
-
-    core.clearMap('ui');
-    core.setAlpha('ui', 0.85);
-    core.fillRect('ui', 0, 0, 416, 416, '#000000');
-    core.setAlpha('ui', 1);
-    core.canvas.ui.textAlign = 'center';
-
-    var u=416/6, size=118;
-
-    var strokeColor = '#FFD700';
-    if (core.status.event.selection) strokeColor = '#FF6A6A';
-
-    var name=core.status.event.id=='save'?"存档":core.status.event.id=='load'?"读档":core.status.event.id=='replayLoad'?"回放":"";
-    for (var i=0;i<6;i++) {
-        var id=5*page+i;
-        var data=core.getLocalStorage(i==0?"autoSave":"save"+id, null);
-        if (i<3) {
-            core.fillText('ui', i==0?"自动存档":name+id, (2*i+1)*u, 35, '#FFFFFF', "bold 17px Verdana");
-            core.strokeRect('ui', (2*i+1)*u-size/2, 50, size, size, i==offset?strokeColor:'#FFFFFF', i==offset?6:2);
-            if (core.isset(data) && core.isset(data.floorId)) {
-                this.drawThumbnail(data.floorId, 'ui', core.maps.load(data.maps, data.floorId).blocks, (2*i+1)*u-size/2, 50, size, data.hero.loc.x, data.hero.loc.y, data.hero.loc, data.hero.flags.heroIcon||"hero.png");
-                core.fillText('ui', core.formatDate(new Date(data.time)), (2*i+1)*u, 65+size, '#FFFFFF', '10px Verdana');
-            }
-            else {
-                core.fillRect('ui', (2*i+1)*u-size/2, 50, size, size, '#333333', 2);
-                core.fillText('ui', '空', (2*i+1)*u, 117, '#FFFFFF', 'bold 30px Verdana');
-            }
-        }
-        else {
-            core.fillText('ui', name+id, (2*i-5)*u, 230, '#FFFFFF', "bold 17px Verdana");
-            core.strokeRect('ui', (2*i-5)*u-size/2, 245, size, size, i==offset?strokeColor:'#FFFFFF', i==offset?6:2);
-            if (core.isset(data) && core.isset(data.floorId)) {
-                this.drawThumbnail(data.floorId, 'ui', core.maps.load(data.maps, data.floorId).blocks, (2*i-5)*u-size/2, 245, size, data.hero.loc.x, data.hero.loc.y, data.hero.loc, data.hero.flags.heroIcon||"hero.png");
-                core.fillText('ui', core.formatDate(new Date(data.time)), (2*i-5)*u, 260+size, '#FFFFFF', '10px Verdana');
-            }
-            else {
-                core.fillRect('ui', (2*i-5)*u-size/2, 245, size, size, '#333333', 2);
-                core.fillText('ui', '空', (2*i-5)*u, 245+70, '#FFFFFF', 'bold 30px Verdana');
-            }
-        }
+    if (core.status.event.data && core.status.event.data.mode=='fav' && page == max_page - 1) {
+        offset = Math.min(offset, (core.saves.favorite||[]).length - 5 * page);
     }
-    this.drawPagination(page+1, max_page);
+
+    var last_page = -1;
+    var mode = 'all';
+    if (core.status.event.data) {
+        last_page = core.status.event.data.page;
+        mode = core.status.event.data.mode;
+    }
+    core.status.event.data={ 'page':page, 'offset':offset, 'mode':mode };
+    core.status.event.ui = core.status.event.ui || [];
+    if (refresh || page != last_page) {
+        core.status.event.ui = [];
+        this._drawSLPanel_loadSave(page, function () {
+            core.ui._drawSLPanel_draw(page, max_page);
+        });
+    }
+    else this._drawSLPanel_draw(page, max_page);
+}
+
+ui.prototype._drawSLPanel_draw = function (page, max_page) {
+    // --- 绘制背景
+    this._drawSLPanel_drawBackground();
+    // --- 绘制文字
+    core.ui.drawPagination(page+1, max_page);
+    core.setTextAlign('ui', 'center');
+    var bottom = this.PIXEL-13;
+    core.fillText('ui', '返回游戏', this.PIXEL-48, bottom, '#DDDDDD', this._buildFont(15, true));
 
     if (core.status.event.selection)
         core.setFillStyle('ui', '#FF6A6A');
     if (core.status.event.id=='save')
-        core.fillText('ui', '删除模式', 48, 403);
-    else
-        core.fillText('ui', '输入编号', 48, 403);
+        core.fillText('ui', '删除模式', 48, bottom);
+    else{
+        if(core.status.event.data.mode=='all'){
+            core.fillText('ui', '[E]显示收藏', 52, bottom);
+        }else{
+            core.fillText('ui', '[E]显示全部', 52, bottom);
+        }
+    }
+    // --- 绘制记录
+    this._drawSLPanel_drawRecords();
 }
 
-////// 绘制一个缩略图 //////
-ui.prototype.drawThumbnail = function(floorId, canvas, blocks, x, y, size, centerX, centerY, heroLoc, heroIcon) {
-
-    var mw = core.floors[floorId].width || 13;
-    var mh = core.floors[floorId].height || 13;
-    // 绘制到tempCanvas上面
-    var tempCanvas = core.bigmap.tempCanvas;
-    var tempWidth = mw*32, tempHeight = mh*32;
-    tempCanvas.canvas.width = tempWidth;
-    tempCanvas.canvas.height = tempHeight;
-    tempCanvas.clearRect(0, 0, tempWidth, tempHeight);
-
-    var groundId = core.floors[floorId].defaultGround || "ground";
-    var blockIcon = core.material.icons.terrains[groundId];
-    var blockImage = core.material.images.terrains;
-    // background
-    for (var i=0;i<mw;i++) {
-        for (var j=0;j<mh;j++) {
-            tempCanvas.drawImage(blockImage, 0, blockIcon * 32, 32, 32, i * 32, j * 32, 32, 32);
-        }
-    }
-    // background image
-    var images = [];
-    if (core.isset(core.floors[floorId].images)) {
-        images = core.floors[floorId].images;
-        if (typeof images == 'string') {
-            images = [[0, 0, images]];
-        }
-    }
-    images.forEach(function (t) {
-        var dx=parseInt(t[0]), dy=parseInt(t[1]), p=t[2];
-        if (core.isset(dx) && core.isset(dy) && core.isset(core.material.images.images[p])) {
-            var image = core.material.images.images[p];
-            if (!t[3])
-                tempCanvas.drawImage(image, 32 * dx, 32 * dy, image.width, image.height);
-            else if (t[3]==2)
-                tempCanvas.drawImage(image, 0, image.height-32, image.width, 32,
-                    32 * dx, 32 * dy + image.height - 32, image.width, 32);
-        }
-    })
-    // draw block
-    var mapArray = core.maps.getMapArray(blocks,mw,mh);
-    for (var b in blocks) {
-        var block = blocks[b];
-        if (core.isset(block.event) && !block.disable) {
-            if (block.event.cls == 'autotile') {
-                core.drawAutotile(tempCanvas, mapArray, block, 32, 0, 0);
-            }
-            else {
-                if (block.event.id!='none') {
-                    var blockIcon = core.material.icons[block.event.cls][block.event.id];
-                    var blockImage = core.material.images[block.event.cls];
-                    var height = block.event.height || 32;
-                    tempCanvas.drawImage(blockImage, 0, blockIcon * height, 32, height, 32*block.x, 32*block.y + 32 - height, 32, height);
-                }
-            }
-        }
-    }
-    // draw hero
-    if (core.isset(heroLoc)) {
-        if (!core.isset(core.material.images.images[heroIcon]))
-            heroIcon = "hero.png";
-        var icon = core.material.icons.hero[heroLoc.direction];
-        var height = core.material.images.images[heroIcon].height/4;
-        tempCanvas.drawImage(core.material.images.images[heroIcon], icon.stop * 32, icon.loc * height, 32, height, 32*heroLoc.x, 32*heroLoc.y+32-height, 32, height);
-    }
-    // draw fg
-    images.forEach(function (t) {
-        var dx=parseInt(t[0]), dy=parseInt(t[1]), p=t[2];
-        if (core.isset(dx) && core.isset(dy) && core.isset(core.material.images.images[p])) {
-            var image = core.material.images.images[p];
-            if (t[3]==1)
-                tempCanvas.drawImage(image, 32*dx, 32*dy, image.width, image.height);
-            else if (t[3]==2)
-                tempCanvas.drawImage(image, 0, 0, image.width, image.height-32,
-                    32*dx, 32*dy, image.width, image.height-32);
-        }
-    })
-
-    // draw to canvas
-    core.clearMap(canvas, x, y, size, size);
-    if (!core.isset(centerX)) centerX=parseInt(mw/2);
-    if (!core.isset(centerY)) centerY=parseInt(mh/2);
-
-    var offsetX = core.clamp(centerX-6, 0, mw-13), offsetY = core.clamp(centerY-6, 0, mh-13);
-    // offsetX~offsetX+12; offsetY~offsetY+12
-    core.canvas[canvas].drawImage(tempCanvas.canvas, offsetX*32, offsetY*32, 416, 416, x, y, size, size);
+ui.prototype._drawSLPanel_drawBackground = function() {
+    core.clearMap('ui');
+    core.setAlpha('ui', 0.85);
+    core.fillRect('ui', 0, 0, this.PIXEL, this.PIXEL, '#000000');//可改成背景图图
+    core.setAlpha('ui', 1);
 }
 
+ui.prototype._drawSLPanel_loadSave = function(page, callback) {
+    var ids = [0];
+    for (var i = 1; i <= 5; ++i) {
+        var id = 5 * page + i;
+        if(core.status.event.data.mode=='fav')
+            id = core.saves.favorite[id - 1]; // 因为favorite第一个不是自动存档 所以要偏移1
+        ids.push(id);
+    }
+    core.getSaves(ids, function (data) {
+        for (var i = 0; i < ids.length; ++i)
+            core.status.event.ui[i] = data[i];
+        core.saves.autosave.data = data[0];
+        callback();
+    });
+}
+
+// 在以x为中心轴 y为顶坐标 的位置绘制一条宽为size的记录 cho表示是否被选中 选中会加粗 highlight表示高亮标题 ✐
+ui.prototype._drawSLPanel_drawRecord = function(title, data, x, y, size, cho, highLight){
+    var strokeColor = '#FFD700';
+    if (core.status.event.selection) strokeColor = '#FF6A6A';
+    if (!data || !data.floorId) highLight = false;
+
+    core.fillText('ui', title, x, y, highLight?'#FFD700':'#FFFFFF', this._buildFont(17, true));
+    core.strokeRect('ui', x-size/2, y+15, size, size, cho?strokeColor:'#FFFFFF', cho?6:2);
+    if (data && data.floorId) {
+        core.drawThumbnail(data.floorId, core.maps.loadMap(data.maps, data.floorId).blocks, {
+            heroLoc: data.hero.loc, heroIcon: data.hero.flags.heroIcon, flags: data.hero.flags
+        }, {
+            ctx: 'ui', x: x-size/2, y: y+15, size: size, centerX: data.hero.loc.x, centerY: data.hero.loc.y
+        });
+        var v = core.formatBigNumber(data.hero.hp,true)+"/"+core.formatBigNumber(data.hero.atk,true)+"/"+core.formatBigNumber(data.hero.def,true);
+        var v2 = "/"+core.formatBigNumber(data.hero.mdef,true);
+        if (core.calWidth('ui', v + v2, this._buildFont(10, false)) <= size) v += v2;
+        core.fillText('ui', v, x, y+30+size, '#FFD700');
+        core.fillText('ui', core.formatDate(new Date(data.time)), x, y+43+size, data.hero.flags.__consoleOpened__?'#FF6A6A':'#FFFFFF');
+    }
+    else {
+        core.fillRect('ui', x-size/2, y+15, size, size, '#333333', 2);
+        core.fillText('ui', '空', x, parseInt(y+22+size/2), '#FFFFFF', this._buildFont(30,true));
+    } 
+}
+
+ui.prototype._drawSLPanel_drawRecords  = function (n) {
+    var page = core.status.event.data.page;
+    var offset = core.status.event.data.offset;
+    var u = Math.floor(this.PIXEL/6), size = Math.floor(this.PIXEL/3-20);
+    var name=core.status.event.id=='save'?"存档":core.status.event.id=='load'?"读档":"回放";
+
+    for (var i = 0; i < (n||6); i++){
+        var data = core.status.event.ui[i];
+        var id = 5 * page + i;
+        var highLight = (i>0&&core.saves.favorite.indexOf(id)>=0) || core.status.event.data.mode=='fav';
+        var title = (highLight?'★ ':'☆ ') + (core.saves.favoriteName[id] || (name + id));
+        if (i != 0 && core.status.event.data.mode=='fav') {
+            if (!data) break;
+            var real_id = core.saves.favorite[id - 1];
+            title = (core.saves.favoriteName[real_id] || (name + real_id)) + ' ✐';
+        }
+
+        var charSize = 32;// 字体占用像素范围
+        var topSpan = parseInt((this.PIXEL-charSize-2*(charSize*2 + size))/3);// Margin
+        var yTop1 = topSpan+parseInt(charSize/2) + 8;//文字的中心
+        var yTop2 = yTop1+charSize*2+size+topSpan;
+        if (i<3) {
+            this._drawSLPanel_drawRecord(i==0?"自动存档":title, data, (2*i+1)*u, yTop1, size, i==offset, highLight);
+        }
+        else {
+            this._drawSLPanel_drawRecord(title, data, (2*i-5)*u, yTop2, size, i==offset, highLight);
+        }
+    }
+};
+
 ui.prototype.drawKeyBoard = function () {
     core.lockControl();
     core.status.event.id = 'keyBoard';
+    core.clearUI();
 
-    core.clearMap('ui');
+    var width = 384, height = 320;
+    var left = (this.PIXEL - width) / 2, right = left + width;
+    var top = (this.PIXEL - height) / 2, bottom = top + height;
 
-    var left = 16, top = 48, right = 416 - 2 * left, bottom = 416 - 2 * top;
-    var background = core.canvas.ui.createPattern(core.material.ground, "repeat");
-    core.fillRect('ui', left, top, right, bottom, background);
-    core.strokeRect('ui', left - 1, top - 1, right + 1, bottom + 1, '#FFFFFF', 2);
-
-    core.canvas.ui.textAlign = "center";
-    core.fillText('ui', "虚拟键盘", 208, top+35, "#FFD700", "bold 22px Verdana");
-
-    core.setFont('ui', '17px Verdana');
-    core.setFillStyle('ui', '#FFFFFF');
-    var offset = 128-9;
+    var isWindowSkin = this.drawBackground(left, top, right, bottom);
+    core.setTextAlign('ui', 'center');
+    core.setFillStyle('ui', core.arrayToRGBA(core.status.textAttribute.title));
+    core.fillText('ui', '虚拟键盘', this.HPIXEL, top + 35, null, this._buildFont(22, true));
+    core.setFont('ui', this._buildFont(17, false));
+    core.setFillStyle('ui', core.arrayToRGBA(core.status.textAttribute.text));
+    var offset = this.HPIXEL - 89;
 
     var lines = [
         ["F1","F2","F3","F4","F5","F6","F7","F8","F9","10","11"],
@@ -1898,21 +2273,56 @@ ui.prototype.drawKeyBoard = function () {
         ["Z","X","C","V","B","N","M"],
         ["-","=","[","]","\\",";","'",",",".","/","`"],
         ["ES","TA","CA","SH","CT","AL","SP","BS","EN","DE"]
-    ]
+    ];
 
     lines.forEach(function (line) {
         for (var i=0;i<line.length;i++) {
-            core.fillText('ui', line[i], 48+32*i, offset);
+            core.fillText('ui', line[i], core.ui.HPIXEL + 32*(i-5), offset);
         }
         offset+=32;
     });
 
-    core.fillText("ui", "返回游戏", 416-80, offset-3, '#FFFFFF', 'bold 15px Verdana');
+    core.fillText("ui", "返回游戏", this.HPIXEL + 128, offset-3, '#FFFFFF', this._buildFont(15, true));
+
+    if (isWindowSkin)
+        this.drawWindowSelector(core.status.textAttribute.background, this.HPIXEL + 92, offset - 22, 72, 27);
+    else
+        core.strokeRect('ui', this.HPIXEL + 92, offset - 22, 72, 27, "#FFD700", 2);
+}
+
+////// 绘制状态栏 /////
+ui.prototype.drawStatusBar = function () {
+    this.uidata.drawStatusBar();
 }
 
 ////// 绘制“数据统计”界面 //////
-ui.prototype.drawStatistics = function () {
+ui.prototype.drawStatistics = function (floorIds) {
+    var obj = this._drawStatistics_buildObj();
+    if (typeof floorIds == 'string') floorIds = [floorIds];
+    (floorIds || core.floorIds).forEach(function (floorId) {
+        core.ui._drawStatistics_floorId(floorId, obj);
+    });
+    var statistics = core.status.hero.statistics;
+    core.drawText([
+        this._drawStatistics_generateText(obj, "全塔", obj.total),
+        this._drawStatistics_generateText(obj, "当前", obj.current),
+        "当前总步数："+core.status.hero.steps+"，当前游戏时长："+core.formatTime(statistics.currTime)
+        +"，总游戏时长"+core.formatTime(statistics.totalTime)
+        +"。\n瞬间移动次数："+statistics.moveDirectly+"，共计少走"+statistics.ignoreSteps+"步。"
+        +"\n\n总计通过血瓶恢复生命值为"+core.formatBigNumber(statistics.hp)+"点。\n\n"
+        +"总计打死了"+statistics.battle+"个怪物，得到了"+core.formatBigNumber(statistics.money)+"金币，"+core.formatBigNumber(statistics.experience)+"点经验。\n\n"
+        +"受到的总伤害为"+core.formatBigNumber(statistics.battleDamage+statistics.poisonDamage+statistics.extraDamage)
+        +"，其中战斗伤害"+core.formatBigNumber(statistics.battleDamage)+"点"
+        +(core.flags.enableDebuff?("，中毒伤害"+core.formatBigNumber(statistics.poisonDamage)+"点"):"")
+        +"，领域/夹击/阻击/血网伤害"+core.formatBigNumber(statistics.extraDamage)+"点。",
+        "\t[说明]1. 地图数据统计的效果仅模拟当前立刻获得该道具的效果。\n2. 不会计算“不可被浏览地图”的隐藏层的数据。\n" +
+        "3. 不会计算任何通过事件得到的道具（显示事件、改变图块、或直接增加道具等）。\n"+
+        "4. 在自定义道具（例如其他宝石）后，需在脚本编辑的drawStatistics中注册，不然不会进行统计。\n"+
+        "5. 所有统计信息仅供参考，如有错误，概不负责。"
+    ])
+}
 
+ui.prototype._drawStatistics_buildObj = function () {
     // 数据统计要统计如下方面：
     // 1. 当前全塔剩余下的怪物数量，总金币数，总经验数，总加点数
     // 2. 当前全塔剩余的黄蓝红铁门数量，和对应的钥匙数量
@@ -1920,157 +2330,135 @@ ui.prototype.drawStatistics = function () {
     // 4. 当前层的上述信息
     // 5. 当前已走的步数；瞬间移动的步数，瞬间移动的次数（和少走的步数）；游戏时长
     // 6. 当前已恢复的生命值；当前总伤害、战斗伤害、阻激夹域血网伤害、中毒伤害。
-
-
-    var total = {
+    var ori = this.uidata.drawStatistics();
+    var ids = ori.filter(function (e) {
+        return e.endsWith("Door") || core.material.items[e];
+    });
+    var cnt = {}, cls = {}, ext = {};
+    ids.forEach(function (e) {
+        if (e.endsWith("Door")) cls[e] = "doors";
+        else cls[e] = core.material.items[e].cls;
+        cnt[e] = 0;
+    })
+    var order = ["doors", "keys", "items", "tools", "constants", "equips"];
+    ids.sort(function (a, b) {
+        var c1 = order.indexOf(cls[a]), c2 = order.indexOf(cls[b]);
+        if (c1==c2) return ori.indexOf(a)-ori.indexOf(b);
+        return c1-c2;
+    });
+    var obj = {
         'monster': {
             'count': 0, 'money': 0, 'experience': 0, 'point': 0,
         },
-        'count': {
-            'yellowDoor': 0, 'blueDoor': 0, 'redDoor': 0, 'greenDoor': 0, 'steelDoor': 0,
-            'yellowKey': 0, 'blueKey': 0, 'redKey': 0, 'greenKey': 0, 'steelKey': 0,
-            'redJewel': 0, 'blueJewel': 0, 'greenJewel': 0, 'yellowJewel': 0,
-            'redPotion': 0, 'bluePotion': 0, 'greenPotion': 0, 'yellowPotion': 0, 'superPotion': 0,
-            'pickaxe': 0, 'bomb': 0, 'centerFly': 0,
-            'poisonWine': 0, 'weakWine': 0, 'curseWine': 0, 'superWine': 0,
-            'sword1': 0, 'sword2': 0, 'sword3': 0, 'sword4': 0, 'sword5': 0,
-            'shield1': 0, 'shield2': 0, 'shield3': 0, 'shield4': 0, 'shield5': 0,
-        },
+        'count': cnt,
         'add': {
             'hp': 0, 'atk': 0, 'def': 0, 'mdef': 0
         }
     };
-    var current = core.clone(total);
+    return {ids: ids, cls: cls, ext: ext, total: core.clone(obj), current: core.clone(obj)};
+}
 
-    core.floorIds.forEach(function (floorId) {
-        var floor=core.floors[floorId];
-        var blocks=core.status.maps[floorId].blocks;
-        // 隐藏层不给看
-        if (floor.cannotViewMap && floorId!=core.status.floorId) return;
+ui.prototype._drawStatistics_add = function (floorId, obj, x1, x2, value) {
+    obj.total[x1][x2] += value || 0;
+    if (floorId == core.status.floorId)
+        obj.current[x1][x2] += value || 0;
+}
 
-        blocks.forEach(function (block) {
-            if (!core.isset(block.event) || block.disable)
-                return;
-            var event = block.event;
-            if (event.cls.indexOf("enemy")==0) {
-                var enemyId = event.id, enemy = core.material.enemys[enemyId];
-                total.monster.money+=enemy.money||0;
-                total.monster.experience+=enemy.experience||0;
-                total.monster.point+=enemy.point||0;
-                total.monster.count++;
-                if (floorId==core.status.floorId) {
-                    current.monster.money+=enemy.money||0;
-                    current.monster.experience+=enemy.experience||0;
-                    current.monster.point+=enemy.point||0;
-                    current.monster.count++;
-                }
-            }
-            else {
-                var id = event.id;
-
-                var temp = core.clone(core.status.hero);
-
-                if (core.isset(total.count[id])) {
-                    var hp=0, atk=0, def=0, mdef=0;
-
-                    if (core.isset(core.material.items[id]) && core.material.items[id].cls=='items' && id!='superPotion') {
-                        var ratio = floor.item_ratio||1;
-                        if (core.isset(core.items.itemEffect[id])) {
-                            eval(core.items.itemEffect[id]);
-                        }
-                        hp = core.status.hero.hp - temp.hp;
-                        atk = core.status.hero.atk - temp.atk;
-                        def = core.status.hero.def - temp.def;
-                        mdef = core.status.hero.mdef - temp.mdef;
-                    }
-                    else {
-                        if (id.indexOf('sword')==0 && core.isset(core.values[id])) {
-                            var x = core.values[id];
-                            if (typeof x == 'number') x = {'atk': x};
-                            atk += x.atk||0;
-                            def += x.def||0;
-                            mdef += x.mdef||0;
-                        }
-                        if (id.indexOf('shield')==0 && core.isset(core.values[id])) {
-                            var x = core.values[id];
-                            if (typeof x == 'number') x = {'def': x};
-                            atk += x.atk||0;
-                            def += x.def||0;
-                            mdef += x.mdef||0;
-                        }
-                    }
-                    core.status.hero = core.clone(temp);
-                    total.count[id]++;
-                    total.add.hp+=hp;
-                    total.add.atk+=atk;
-                    total.add.def+=def;
-                    total.add.mdef+=mdef;
-                    if (floorId==core.status.floorId) {
-                        current.count[id]++;
-                        current.add.hp+=hp;
-                        current.add.atk+=atk;
-                        current.add.def+=def;
-                        current.add.mdef+=mdef;
-                    }
-                }
-            }
-        })
+ui.prototype._drawStatistics_floorId = function (floorId, obj) {
+    var floor = core.status.maps[floorId], blocks = floor.blocks;
+    // 隐藏层不给看
+    if (floor.cannotViewMap && floorId!=core.status.floorId) return;
+    blocks.forEach(function (block) {
+        if (block.disable) return;
+        var event = block.event;
+        if (event.cls.indexOf("enemy")==0) {
+            core.ui._drawStatistics_enemy(floorId, event.id, obj);
+        }
+        else {
+            var id = event.id;
+            if (obj.total.count[id] != null)
+                core.ui._drawStatistics_items(floorId, floor, id, obj);
+        }
     })
+}
 
-    var getText = function (type, data) {
-        var text = type+"地图中：\n";
-        text += "共有怪物"+data.monster.count+"个";
-        if (core.flags.enableMoney) text+="，总金币数"+data.monster.money;
-        if (core.flags.enableExperience) text+="，总经验数"+data.monster.experience;
-        if (core.flags.enableAddPoint) text+="，总加点数"+data.monster.point;
-        text+="。\n\n";
-        Object.keys(data.count).forEach(function (key) {
-            var value=data.count[key];
-            if (value>0) {
-                var name="";
-                if (key=='yellowDoor') name="黄门";
-                else if (key=='blueDoor') name="蓝门";
-                else if (key=='redDoor') name="红门";
-                else if (key=='greenDoor') name="绿门";
-                else if (key=='steelDoor') name="铁门";
-                else name=core.material.items[key].name;
-                if (core.isset(name)) {
-                    text+=name+value+"个；";
-                }
-            }
-        })
-        text+="\n\n";
-        text+="共加生命值"+core.formatBigNumber(data.add.hp)+"点，攻击"
-            +core.formatBigNumber(data.add.atk)+"点，防御"
-            +core.formatBigNumber(data.add.def)+"点，魔防"
-            +core.formatBigNumber(data.add.mdef)+"点。";
-        return text;
+ui.prototype._drawStatistics_enemy = function (floorId, id, obj) {
+    var enemy = core.material.enemys[id];
+    this._drawStatistics_add(floorId, obj, 'monster', 'money', enemy.money);
+    this._drawStatistics_add(floorId, obj, 'monster', 'experience', enemy.experience);
+    this._drawStatistics_add(floorId, obj, 'monster', 'point', enemy.point);
+    this._drawStatistics_add(floorId, obj, 'monster', 'count', 1);
+}
+
+ui.prototype._drawStatistics_items = function (floorId, floor, id, obj) {
+    var hp=0, atk=0, def=0, mdef=0;
+    if (obj.cls[id]=='items' && id!='superPotion') {
+        var temp = core.clone(core.status.hero);
+        core.setFlag("__statistics__", true);
+        var ratio = floor.item_ratio||1;
+        try { eval(core.items.itemEffect[id]); }
+        catch (e) {}
+        hp = core.status.hero.hp - temp.hp;
+        atk = core.status.hero.atk - temp.atk;
+        def = core.status.hero.def - temp.def;
+        mdef = core.status.hero.mdef - temp.mdef;
+        core.status.hero = temp;
     }
-
-    var formatTime = function (time) {
-        return core.setTwoDigits(parseInt(time/3600000))
-            +":"+core.setTwoDigits(parseInt(time/60000)%60)
-            +":"+core.setTwoDigits(parseInt(time/1000)%60);
+    else if (obj.cls[id]=='equips') {
+        var values = core.material.items[id].equip || {};
+        atk = values.atk || 0;
+        def = values.def || 0;
+        mdef = values.mdef || 0;
     }
+    if (id.indexOf('sword')==0 || id.indexOf('shield')==0 || obj.cls[id]=='equips') {
+        var t = "";
+        if (atk > 0) t += atk + "攻";
+        if (def > 0) t += def + "防";
+        if (mdef > 0) t += mdef + "魔防";
+        if (t != "") obj.ext[id] = t;
+    }
+    this._drawStatistics_add(floorId, obj, 'count', id, 1);
+    this._drawStatistics_add(floorId, obj, 'add', 'hp', hp);
+    this._drawStatistics_add(floorId, obj, 'add', 'atk', atk);
+    this._drawStatistics_add(floorId, obj, 'add', 'def', def);
+    this._drawStatistics_add(floorId, obj, 'add', 'mdef', mdef);
+}
 
-    var statistics = core.status.hero.statistics;
-    core.drawText([
-        getText("全塔", total),
-        getText("当前", current),
-        "当前总步数："+core.status.hero.steps+"，当前游戏时长："+formatTime(statistics.currTime)
-        +"，总游戏时长"+formatTime(statistics.totalTime)
-        +"。\n瞬间移动次数："+statistics.moveDirectly+"，共计少走"+statistics.ignoreSteps+"步。"
-        +"\n\n总计通过血瓶恢复生命值为"+core.formatBigNumber(statistics.hp)+"点。\n\n"
-        +"总计受到的伤害为"+core.formatBigNumber(statistics.battleDamage+statistics.poisonDamage+statistics.extraDamage)
-        +"，其中战斗伤害"+core.formatBigNumber(statistics.battleDamage)+"点"
-        +(core.flags.enableDebuff?("，中毒伤害"+core.formatBigNumber(statistics.poisonDamage)+"点"):"")
-        +"，领域/夹击/阻击/血网伤害"+core.formatBigNumber(statistics.extraDamage)+"点。",
-        "\t[说明]1. 地图数据统计的效果仅模拟当前立刻获得该道具的效果。\n2. 不会计算“不可被浏览地图”的隐藏层的数据。\n" +
-        "3. 不会计算任何通过事件得到的道具（显示事件、改变图块、或直接增加道具等）。\n"+
-        "4. 在自定义道具（例如其他宝石）后，需在ui.js的drawStatistics中注册，不然不会进行统计。\n"+
-        "5. 所有统计信息仅供参考，如有错误，概不负责。"
-    ])
+ui.prototype._drawStatistics_generateText = function (obj, type, data) {
+    var text = type+"地图中：\n";
+    text += "共有怪物"+data.monster.count+"个";
+    if (core.flags.enableMoney) text+="，总金币数"+data.monster.money;
+    if (core.flags.enableExperience) text+="，总经验数"+data.monster.experience;
+    if (core.flags.enableAddPoint) text+="，总加点数"+data.monster.point;
+    text+="。\n";
 
+    var prev = "";
+    obj.ids.forEach(function (key) {
+        var value = data.count[key];
+        if (value==0) return;
+        if (obj.cls[key] != prev) {
+            if (prev != "") text += "。";
+            text += "\n";
+        }
+        else text += "，";
+        prev = obj.cls[key];
+        text+=core.ui._drawStatistics_getName(key)+value+"个";
+        if (obj.ext[key])
+            text+="("+obj.ext[key]+")";
+    })
+    if (prev!="") text+="。";
+
+    text+="\n\n";
+    text+="共加生命值"+core.formatBigNumber(data.add.hp)+"点，攻击"
+        +core.formatBigNumber(data.add.atk)+"点，防御"
+        +core.formatBigNumber(data.add.def)+"点，魔防"
+        +core.formatBigNumber(data.add.mdef)+"点。";
+    return text;
+}
+
+ui.prototype._drawStatistics_getName = function (key) {
+    return {"yellowDoor": "黄门", "blueDoor": "蓝门", "redDoor": "红门", "greenDoor": "绿门",
+            "steelDoor": "铁门"}[key] || core.material.items[key].name;
 }
 
 ////// 绘制“关于”界面 //////
@@ -2078,35 +2466,154 @@ ui.prototype.drawAbout = function () {
     return this.uidata.drawAbout();
 }
 
-////// 绘制帮助页面 //////
-ui.prototype.drawHelp = function () {
-    core.drawText([
-        "\t[键盘快捷键列表]"+
-        "[CTRL] 跳过对话\n" +
-        "[Z] 转向\n" +
-        "[X] 打开/关闭怪物手册\n" +
-        "[G] 打开/关闭楼层传送器\n" +
-        "[A] 读取自动存档（回退）\n" +
-        "[S/D] 打开/关闭存/读档页面\n" +
-        "[K] 打开/关闭快捷商店选择列表\n" +
-        "[T] 打开/关闭工具栏\n" +
-        "[ESC] 打开/关闭系统菜单\n" +
-        // "[E] 显示光标\n" +
-        "[H] 打开帮助页面\n"+
-        "[R] 回放\n"+
-        "[SPACE] 轻按（仅在轻按开关打开时有效）\n" +
-        "[PgUp/PgDn] 浏览地图\n"+
-        "[1] 快捷使用破墙镐\n" +
-        "[2] 快捷使用炸弹/圣锤\n" +
-        "[3] 快捷使用中心对称飞行器",
-        "\t[鼠标操作]"+
-        "点状态栏中图标： 进行对应的操作\n"+
-        "点任意块： 寻路并移动\n"+
-        "点任意块并拖动： 指定寻路路线\n"+
-        "双击空地： 瞬间移动\n"+
-        "单击勇士： 转向\n"+
-        "双击勇士： 轻按（仅在轻按开关打开时有效）\n"+
-        "长按任意位置：跳过剧情对话或打开虚拟键盘\n"
-    ]);
+////// 绘制“画图”界面 //////
+ui.prototype.drawPaint = function () {
+    core.drawText(
+        "\t[进入绘图模式]你可以在此页面上任意进行绘图和标记操作。\nM键可以进入或退出此模式。\n\n"+
+        "绘图的内容会自动保存，且以页面为生命周期，和存读档无关，重新开始游戏或读档后绘制的内容仍有效，但刷新页面就会消失。\n"+
+        "你可以将绘制内容保存到文件，也可以从文件读取保存的绘制内容。\n"+
+        "浏览地图页面可以按楼传按钮或M键来开启/关闭该层的绘图显示。\n\n更多功能请详见文档-元件-绘图模式。",
+        this._drawPaint_draw
+    );
 }
 
+ui.prototype._drawPaint_draw = function () {
+    core.drawTip("打开绘图模式，现在可以任意在界面上绘图标记");
+
+    core.lockControl();
+    core.status.event.id = 'paint';
+    core.status.event.data = {"x": null, "y": null, "erase": false};
+
+    core.clearUI();
+    core.createCanvas('paint', -core.bigmap.offsetX, -core.bigmap.offsetY, 32*core.bigmap.width, 32*core.bigmap.height, 95);
+
+    // 将已有的内容绘制到route上
+    var value = core.paint[core.status.floorId];
+    if (core.isset(value)) value = lzw_decode(value).split(",");
+    core.utils._decodeCanvas(value, 32*core.bigmap.width, 32*core.bigmap.height);
+    core.drawImage('paint', core.bigmap.tempCanvas.canvas, 0, 0);
+
+    core.setLineWidth('paint', 3);
+    core.setStrokeStyle('paint', '#FF0000');
+
+    core.statusBar.image.keyboard.style.opacity = 0;
+    core.statusBar.image.shop.style.opacity = 0;
+
+    core.statusBar.image.book.src = core.statusBar.icons.paint.src;
+    core.statusBar.image.fly.src = core.statusBar.icons.erase.src;
+    core.statusBar.image.toolbox.src = core.statusBar.icons.empty.src;
+    core.statusBar.image.settings.src = core.statusBar.icons.exit.src;
+    core.statusBar.image.book.style.opacity = 1;
+    core.statusBar.image.fly.style.opacity = 1;
+}
+
+////// 绘制帮助页面 //////
+ui.prototype.drawHelp = function () {
+    core.clearUI();
+    if (core.material.images.keyboard) {
+        core.status.event.id = 'help';
+        core.lockControl();
+        core.setAlpha('ui', 1);
+        core.fillRect('ui', 0, 0, this.PIXEL, this.PIXEL, '#FFFFFF');
+        core.drawImage('ui', core.material.images.keyboard, 32 * (this.HSIZE - 6), 32 * (this.HSIZE - 6));
+    }
+    else {
+        core.drawText([
+            "\t[键盘快捷键列表]"+
+            "[CTRL] 跳过对话   [Z] 转向\n" +
+            "[X] 怪物手册   [G] 楼层传送\n" +
+            "[A] 读取自动存档   [S/D] 存读档页面\n" +
+            "[V] 快捷商店   [ESC] 系统菜单\n" +
+            "[T] 道具页面   [Q] 装备页面\n" +
+            "[B] 数据统计   [H] 帮助页面\n" +
+            "[R] 回放录像   [E] 显示光标\n" +
+            "[SPACE] 轻按   [M] 绘图模式\n" +
+            "[N] 返回标题页面   [P] 游戏主页\n" +
+            "[O] 查看工程   [F7] 打开debug穿墙模式\n" +
+            "[PgUp/PgDn] 浏览地图\n"+
+            "[1~4] 快捷使用破炸飞和其他道具\n"+
+            "[Alt+0~9] 快捷换装",
+            "\t[鼠标操作]"+
+            "点状态栏中图标： 进行对应的操作\n"+
+            "点任意块： 寻路并移动\n"+
+            "点任意块并拖动： 指定寻路路线\n"+
+            "双击空地： 瞬间移动\n"+
+            "单击勇士： 转向\n"+
+            "双击勇士： 轻按（仅在轻按开关打开时有效）\n"+
+            "长按任意位置：跳过剧情对话或打开虚拟键盘"
+        ]);
+    }
+}
+
+////// 动态canvas //////
+
+////// canvas创建 //////
+ui.prototype.createCanvas = function (name, x, y, width, height, z) {
+    // 如果画布已存在则直接调用
+    if (core.isset(core.dymCanvas[name])) {
+        this.relocateCanvas(name, x, y);
+        this.resizeCanvas(name, width, height);
+        core.dymCanvas[name].canvas.style.zIndex = z;
+        return core.dymCanvas[name];
+    }
+    var newCanvas = document.createElement("canvas");
+    newCanvas.id = name;
+    newCanvas.style.display = 'block';
+    newCanvas.width = width;
+    newCanvas.height = height;
+    newCanvas.setAttribute("_left", x);
+    newCanvas.setAttribute("_top", y);
+    newCanvas.style.width = width * core.domStyle.scale + 'px';
+    newCanvas.style.height = height * core.domStyle.scale + 'px';
+    newCanvas.style.left = x * core.domStyle.scale + 'px';
+    newCanvas.style.top = y * core.domStyle.scale + 'px';
+    newCanvas.style.zIndex = z;
+    newCanvas.style.position = 'absolute';
+    core.dymCanvas[name] = newCanvas.getContext('2d');
+    core.dom.gameDraw.appendChild(newCanvas);
+    return core.dymCanvas[name];
+}
+
+////// canvas重定位 //////
+ui.prototype.relocateCanvas = function (name, x, y) {
+    var ctx = core.dymCanvas[name];
+    if (!core.isset(ctx)) return null;
+    if (core.isset(x)) {
+        ctx.canvas.style.left = x * core.domStyle.scale + 'px';
+        ctx.canvas.setAttribute("_left", x);
+    }
+    if (core.isset(y)) {
+        ctx.canvas.style.top = y * core.domStyle.scale + 'px';
+        ctx.canvas.setAttribute("_top", y);
+    }
+    return ctx;
+}
+
+////// canvas重置 //////
+ui.prototype.resizeCanvas = function (name, width, height) {
+    var ctx = core.dymCanvas[name];
+    if (!core.isset(ctx)) return null;
+    if (core.isset(width)) {
+        ctx.canvas.width = width;
+        ctx.canvas.style.width = width * core.domStyle.scale + 'px';
+    }
+    if (core.isset(height)) {
+        ctx.canvas.height = height;
+        ctx.canvas.style.height = height * core.domStyle.scale + 'px';
+    }
+    return ctx;
+}
+////// canvas删除 //////
+ui.prototype.deleteCanvas = function (name) {
+    if (!core.isset(core.dymCanvas[name])) return null;
+    core.dom.gameDraw.removeChild(core.dymCanvas[name].canvas);
+    delete core.dymCanvas[name];
+}
+
+////// 删除所有动态canvas //////
+ui.prototype.deleteAllCanvas = function () {
+    Object.keys(core.dymCanvas).forEach(function (name) {
+        core.dom.gameDraw.removeChild(core.dymCanvas[name].canvas);
+        delete core.dymCanvas[name];
+    });
+}
diff --git a/libs/utils.js b/libs/utils.js
index 293a6d6b..b5107087 100644
--- a/libs/utils.js
+++ b/libs/utils.js
@@ -3,67 +3,82 @@ utils.js 工具类
 
  */
 
-function utils() {
+"use strict";
 
+function utils() {
+    this._init();
+    this.scan = {
+        'up': {'x': 0, 'y': -1},
+        'left': {'x': -1, 'y': 0},
+        'down': {'x': 0, 'y': 1},
+        'right': {'x': 1, 'y': 0}
+    };
 }
 
-utils.prototype.init = function () {
+utils.prototype._init = function () {
+    // 定义Object.assign
+    if (typeof Object.assign != "function") {
+        Object.assign = function (target, varArgs) { // .length of function is 2
+            if (target == null) { // TypeError if undefined or null
+                throw new TypeError('Cannot convert undefined or null to object');
+            }
+
+            var to = Object(target);
+
+            for (var index = 1; index < arguments.length; index++) {
+                var nextSource = arguments[index];
+
+                if (nextSource != null) { // Skip over if undefined or null
+                    for (var nextKey in nextSource) {
+                        // Avoid bugs when hasOwnProperty is shadowed
+                        if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
+                            to[nextKey] = nextSource[nextKey];
+                        }
+                    }
+                }
+            }
+            return to;
+        };
+    }
+    if (typeof String.prototype.endsWith != "function") {
+        String.prototype.endsWith = function (search, this_len) {
+            if (this_len === undefined || this_len > this.length) {
+                this_len = this.length;
+            }
+            return this.substring(this_len - search.length, this_len) === search;
+        };
+    }
+
 
 }
 
 ////// 将文字中的${和}（表达式）进行替换 //////
-utils.prototype.replaceText = function (text) {
-    return text.replace(/\${([^}]+)}/g, function (word, value) {
-        return core.calValue(value);
+utils.prototype.replaceText = function (text, need, times) {
+    return text.replace(/\${(.*?)}/g, function (word, value) {
+        return core.calValue(value, null, need, times);
     });
 }
 
 ////// 计算表达式的值 //////
-utils.prototype.calValue = function (value) {
-    if (typeof value == 'number') {
-        return value;
+utils.prototype.calValue = function (value, prefix, need, times) {
+    if (!core.isset(value)) return null;
+    if (typeof value === 'string') {
+        value = value.replace(/status:([a-zA-Z0-9_]+)/g, "core.getStatus('$1')");
+        value = value.replace(/item:([a-zA-Z0-9_]+)/g, "core.itemCount('$1')");
+        value = value.replace(/flag:([a-zA-Z0-9_\u4E00-\u9FCC]+)/g, "core.getFlag('$1', 0)");
+        value = value.replace(/switch:([a-zA-Z0-9_]+)/g, "core.getFlag('" + (prefix || ":f@x@y") + "@$1', 0)");
+        value = value.replace(/global:([a-zA-Z0-9_\u4E00-\u9FCC]+)/g, "core.getGlobal('$1', 0)");
+        return eval(value);
     }
     if (value instanceof Function) {
         return value();
     }
-    value=value.replace(/status:([\w\d_]+)/g, "core.getStatus('$1')");
-    value=value.replace(/item:([\w\d_]+)/g, "core.itemCount('$1')");
-    value=value.replace(/flag:([\w\d_]+)/g, "core.getFlag('$1', 0)");
-    return eval(value);
-}
-
-////// 字符串自动换行的分割 //////
-utils.prototype.splitLines = function(canvas, text, maxLength, font) {
-    if (core.isset(font)) core.setFont(canvas, font);
-
-    var contents = [];
-    var last = 0;
-    for (var i=0;i<text.length;i++) {
-
-        if (text.charAt(i)=='\n') {
-            contents.push(text.substring(last, i));
-            last=i+1;
-        }
-        else if (text.charAt(i)=='\\' && text.charAt(i+1)=='n') {
-            contents.push(text.substring(last, i));
-            last=i+2;
-        }
-        else {
-            var toAdd = text.substring(last, i+1);
-            var width = core.canvas[canvas].measureText(toAdd).width;
-            if (width>maxLength) {
-                contents.push(text.substring(last, i));
-                last=i;
-            }
-        }
-    }
-    contents.push(text.substring(last));
-    return contents;
+    return value;
 }
 
 ////// 向某个数组前插入另一个数组或元素 //////
-utils.prototype.unshift = function (a,b) {
-    if (!(a instanceof Array) || !core.isset(b)) return;
+utils.prototype.unshift = function (a, b) {
+    if (!(a instanceof Array) || b == null) return;
     if (b instanceof Array) {
         core.clone(b).reverse().forEach(function (e) {
             a.unshift(e);
@@ -73,15 +88,56 @@ utils.prototype.unshift = function (a,b) {
     return a;
 }
 
-////// 设置本地存储 //////
-utils.prototype.setLocalStorage = function(key, value) {
+////// 向某个数组后插入另一个数组或元素 //////
+utils.prototype.push = function (a, b) {
+    if (!(a instanceof Array) || b == null) return;
+    if (b instanceof Array) {
+        core.clone(b).forEach(function (e) {
+            a.push(e);
+        });
+    }
+    else a.push(b);
+    return a;
+}
+
+utils.prototype.decompress = function (value) {
     try {
-        var str = JSON.stringify(value);
-        var compressed = LZString.compress(str);
+        var output = lzw_decode(value);
+        if (output) return JSON.parse(output);
+    }
+    catch (e) {
+    }
+    try {
+        var output = LZString.decompress(value);
+        if (output) return JSON.parse(output);
+    }
+    catch (e) {
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch (e) {
+        main.log(e);
+    }
+    return null;
+}
+
+////// 设置本地存储 //////
+utils.prototype.setLocalStorage = function (key, value) {
+    try {
+        if (value == null) {
+            this.removeLocalStorage(key);
+            return;
+        }
+
+        var str = JSON.stringify(value).replace(/[\u007F-\uFFFF]/g, function (chr) {
+            return "\\u" + ("0000" + chr.charCodeAt(0).toString(16)).substr(-4)
+        });
+        var compressed = lzw_encode(str);
 
         // test if we can save to localStorage
         localStorage.setItem("__tmp__", compressed);
-        if (LZString.decompress(localStorage.getItem("__tmp__"))==str) {
+        if (lzw_decode(localStorage.getItem("__tmp__")) == str) {
             localStorage.setItem(core.firstData.name + "_" + key, compressed);
         }
         else {
@@ -89,57 +145,148 @@ utils.prototype.setLocalStorage = function(key, value) {
             localStorage.setItem(core.firstData.name + "_" + key, str);
         }
         localStorage.removeItem("__tmp__");
+
+        if (key == 'autoSave') core.saves.ids[0] = true;
+        else if (/^save\d+$/.test(key)) core.saves.ids[parseInt(key.substring(4))] = true;
+
         return true;
     }
     catch (e) {
-        console.log(e);
+        main.log(e);
         return false;
     }
 }
 
 ////// 获得本地存储 //////
-utils.prototype.getLocalStorage = function(key, defaultValue) {
-    try {
-        var value = localStorage.getItem(core.firstData.name+"_"+key);
-        if (core.isset(value)) {
-            var output = LZString.decompress(value);
-            if (core.isset(output) && output.length>0) {
-                try {
-                    return JSON.parse(output);
-                }
-                catch (ee) {}
-            }
-            return JSON.parse(value);
-        }
-        return defaultValue;
-    }
-    catch (e) {
-        console.log(e);
-        return defaultValue;
-    }
+utils.prototype.getLocalStorage = function (key, defaultValue) {
+    var res = this.decompress(localStorage.getItem(core.firstData.name + "_" + key));
+    return res == null ? defaultValue : res;
 }
 
 ////// 移除本地存储 //////
 utils.prototype.removeLocalStorage = function (key) {
-    localStorage.removeItem(core.firstData.name+"_"+key);
+    localStorage.removeItem(core.firstData.name + "_" + key);
+    if (key == 'autoSave') delete core.saves.ids[0];
+    else if (/^save\d+$/.test(key)) delete core.saves.ids[parseInt(key.substring(4))];
+}
+
+utils.prototype.setLocalForage = function (key, value, successCallback, errorCallback) {
+
+    if (!core.platform.useLocalForage) {
+        if (this.setLocalStorage(key, value)) {
+            if (successCallback) successCallback();
+        }
+        else {
+            if (errorCallback) errorCallback();
+        }
+        return;
+    }
+
+    if (value == null) {
+        this.removeLocalForage(key);
+        return;
+    }
+
+    // Save to localforage
+    var compressed = lzw_encode(JSON.stringify(value).replace(/[\u007F-\uFFFF]/g, function (chr) {
+        return "\\u" + ("0000" + chr.charCodeAt(0).toString(16)).substr(-4)
+    }));
+    localforage.setItem(core.firstData.name + "_" + key, compressed, function (err) {
+        if (err) {
+            if (errorCallback) errorCallback(err);
+        }
+        else {
+            if (key == 'autoSave') core.saves.ids[0] = true;
+            else if (/^save\d+$/.test(key)) core.saves.ids[parseInt(key.substring(4))] = true;
+            if (successCallback) successCallback();
+        }
+    });
+}
+
+utils.prototype.getLocalForage = function (key, defaultValue, successCallback, errorCallback) {
+
+    if (!core.platform.useLocalForage) {
+        var value = this.getLocalStorage(key, defaultValue);
+        if (successCallback) successCallback(value);
+        return;
+    }
+
+    localforage.getItem(core.firstData.name + "_" + key, function (err, value) {
+        if (err) {
+            if (errorCallback) errorCallback(err);
+        }
+        else {
+            if (!successCallback) return;
+            if (value != null) {
+                var res = core.utils.decompress(value);
+                successCallback(res == null ? defaultValue : res);
+                return;
+            }
+            successCallback(defaultValue);
+        }
+    })
+}
+
+utils.prototype.removeLocalForage = function (key, successCallback, errorCallback) {
+
+    if (!core.platform.useLocalForage) {
+        this.removeLocalStorage(key);
+        if (successCallback) successCallback();
+        return;
+    }
+
+    localforage.removeItem(core.firstData.name + "_" + key, function (err) {
+        if (err) {
+            if (errorCallback) errorCallback(err);
+        }
+        else {
+            if (key == 'autoSave') delete core.saves.ids[0];
+            else if (/^save\d+$/.test(key)) delete core.saves.ids[parseInt(key.substring(4))];
+            if (successCallback) successCallback();
+        }
+    })
+}
+
+utils.prototype.setGlobal = function (key, value) {
+    if (core.isReplaying()) return;
+    core.setLocalStorage(key, value);
+}
+
+utils.prototype.getGlobal = function (key, defaultValue) {
+    var value;
+    if (core.isReplaying()) {
+        // 不考虑key不一致的情况
+        var action = core.status.replay.toReplay.shift();
+        if (action.indexOf("input2:") == 0) {
+            value = JSON.parse(core.decodeBase64(action.substring(7)));
+        }
+        else {
+            core.control._replay_error(action);
+            return core.getLocalStorage(key, defaultValue);
+        }
+    }
+    else {
+        value = core.getLocalStorage(key, defaultValue);
+    }
+    core.status.route.push("input2:" + core.encodeBase64(JSON.stringify(value)));
+    return value;
 }
 
 ////// 深拷贝一个对象 //////
-utils.prototype.clone = function (data) {
-    if (!core.isset(data)) return data;
+utils.prototype.clone = function (data, filter, recursion) {
+    if (!core.isset(data)) return null;
     // date
     if (data instanceof Date) {
-        var copy=new Date();
+        var copy = new Date();
         copy.setTime(data.getTime());
         return copy;
     }
     // array
     if (data instanceof Array) {
-        var copy=[];
-        // for (var i=0;i<data.length;i++) {
+        var copy = [];
         for (var i in data) {
-            // copy.push(core.clone(data[i]));
-            copy[i] = core.clone(data[i]);
+            if (!filter || filter(i, data[i]))
+                copy[i] = core.clone(data[i], recursion?filter:null, recursion);
         }
         return copy;
     }
@@ -149,10 +296,10 @@ utils.prototype.clone = function (data) {
     }
     // object
     if (data instanceof Object) {
-        var copy={};
+        var copy = {};
         for (var i in data) {
-            if (data.hasOwnProperty(i))
-                copy[i]=core.clone(data[i]);
+            if (data.hasOwnProperty(i) && (!filter || filter(i, data[i])))
+                copy[i] = core.clone(data[i], recursion?filter:null, recursion);
         }
         return copy;
     }
@@ -160,50 +307,64 @@ utils.prototype.clone = function (data) {
 }
 
 ////// 裁剪图片 //////
-utils.prototype.cropImage = function (image, size) {
-    size = size||32;
+utils.prototype.splitImage = function (image, width, height) {
+    if (typeof image == "string") {
+        image = core.getMappedName(image);
+        image = core.material.images.images[image];
+    }
+    if (!image) return [];
+    width = width || 32;
+    height = height || width;
     var canvas = document.createElement("canvas");
     var context = canvas.getContext("2d");
-    canvas.width = size;
-    canvas.height = size;
+    canvas.width = width;
+    canvas.height = height;
     var ans = [];
-    for (var i=0;i<image.height;i+=size) {
-        context.drawImage(image, 0, i, size, size, 0, 0, size, size);
-        var img = new Image();
-        img.src = canvas.toDataURL("image/png");
-        ans.push(img);
-        context.clearRect(0,0,size,size);
+    for (var j = 0; j < image.height; j += height) {
+        for (var i = 0; i < image.width; i += width) {
+            context.drawImage(image, i, j, width, height, 0, 0, width, height);
+            var img = new Image();
+            img.src = canvas.toDataURL("image/png");
+            ans.push(img);
+            context.clearRect(0, 0, width, height);
+        }
     }
     return ans;
 }
 
 ////// 格式化时间为字符串 //////
-utils.prototype.formatDate = function(date) {
-    if (!core.isset(date)) return "";
-    return date.getFullYear()+"-"+core.setTwoDigits(date.getMonth()+1)+"-"+core.setTwoDigits(date.getDate())+" "
-        +core.setTwoDigits(date.getHours())+":"+core.setTwoDigits(date.getMinutes())+":"+core.setTwoDigits(date.getSeconds());
+utils.prototype.formatDate = function (date) {
+    if (!date) date = new Date();
+    return "" + date.getFullYear() + "-" + core.setTwoDigits(date.getMonth() + 1) + "-" + core.setTwoDigits(date.getDate()) + " "
+        + core.setTwoDigits(date.getHours()) + ":" + core.setTwoDigits(date.getMinutes()) + ":" + core.setTwoDigits(date.getSeconds());
 }
 
 ////// 格式化时间为最简字符串 //////
 utils.prototype.formatDate2 = function (date) {
-    if (!core.isset(date)) return "";
-    return date.getFullYear()+core.setTwoDigits(date.getMonth()+1)+core.setTwoDigits(date.getDate())
-        +core.setTwoDigits(date.getHours())+core.setTwoDigits(date.getMinutes())+core.setTwoDigits(date.getSeconds());
+    if (!date) date = new Date();
+    return "" + date.getFullYear() + core.setTwoDigits(date.getMonth() + 1) + core.setTwoDigits(date.getDate())
+        + core.setTwoDigits(date.getHours()) + core.setTwoDigits(date.getMinutes()) + core.setTwoDigits(date.getSeconds());
+}
+
+utils.prototype.formatTime = function (time) {
+    return core.setTwoDigits(parseInt(time/3600000))
+        +":"+core.setTwoDigits(parseInt(time/60000)%60)
+        +":"+core.setTwoDigits(parseInt(time/1000)%60);
 }
 
 ////// 两位数显示 //////
 utils.prototype.setTwoDigits = function (x) {
-    return parseInt(x)<10?"0"+x:x;
+    return parseInt(x) < 10 ? "0" + x : x;
 }
 
-utils.prototype.formatBigNumber = function (x) {
+utils.prototype.formatBigNumber = function (x, onMap) {
     x = Math.floor(parseFloat(x));
     if (!core.isset(x)) return '???';
 
-    var c = x<0?"-":"";
+    var c = x < 0 ? "-" : "";
     x = Math.abs(x);
 
-    if (x<=999999) return c + x;
+    if (x <= 99999 || (!onMap && x <= 999999)) return c + x;
 
     var all = [
         {"val": 1e20, "c": "g"},
@@ -213,148 +374,287 @@ utils.prototype.formatBigNumber = function (x) {
         {"val": 1e4, "c": "w"},
     ]
 
-    for (var i=0;i<all.length;i++) {
+    for (var i = 0; i < all.length; i++) {
         var one = all[i];
-        if (x>=10*one.val) {
-            var v = x/one.val;
-            return c + v.toFixed(Math.max(0, Math.floor(4-Math.log10(v+1)))) + one.c;
+        if (onMap) {
+            if (x >= one.val) {
+                var v = x / one.val;
+                return c + v.toFixed(Math.max(0, Math.floor(3 - Math.log10(v + 1)))) + one.c;
+            }
+        }
+        else {
+            if (x >= 10 * one.val) {
+                var v = x / one.val;
+                return c + v.toFixed(Math.max(0, Math.floor(4 - Math.log10(v + 1)))) + one.c;
+            }
         }
     }
 
-    return c+x;
+    return c + x;
 }
 
 ////// 数组转RGB //////
 utils.prototype.arrayToRGB = function (color) {
-    var nowR = parseInt(color[0])||0, nowG = parseInt(color[1])||0, nowB = parseInt(color[2])||0;
-    if (nowR<0) nowR=0; if (nowB<0) nowB=0;if (nowG<0) nowG=0;
-    if (nowR>255) nowR=255; if (nowB>255) nowB=255; if (nowG>255) nowG=255;
-    return "#"+((1<<24)+(nowR<<16)+(nowG<<8)+nowB).toString(16).slice(1);
+    var nowR = this.clamp(parseInt(color[0]), 0, 255), nowG = this.clamp(parseInt(color[1]), 0, 255),
+        nowB = this.clamp(parseInt(color[2]), 0, 255);
+    return "#" + ((1 << 24) + (nowR << 16) + (nowG << 8) + nowB).toString(16).slice(1);
+}
+
+utils.prototype.arrayToRGBA = function (color) {
+    if (color[3] == null) color[3] = 1;
+    var nowR = this.clamp(parseInt(color[0]), 0, 255), nowG = this.clamp(parseInt(color[1]), 0, 255),
+        nowB = this.clamp(parseInt(color[2]), 0, 255), nowA = this.clamp(parseFloat(color[3]), 0, 1);
+    return "rgba(" + nowR + "," + nowG + "," + nowB + "," + nowA + ")";
 }
 
 ////// 加密路线 //////
 utils.prototype.encodeRoute = function (route) {
-    var ans="";
-    var lastMove = "", cnt=0;
+    var ans = "", lastMove = "", cnt = 0;
 
     route.forEach(function (t) {
-        if (t=='up' || t=='down' || t=='left' || t=='right') {
-            if (t!=lastMove && cnt>0) {
-                ans+=lastMove.substring(0,1).toUpperCase();
-                if (cnt>1) ans+=cnt;
-                cnt=0;
+        if (t == 'up' || t == 'down' || t == 'left' || t == 'right') {
+            if (t != lastMove && cnt > 0) {
+                ans += lastMove.substring(0, 1).toUpperCase();
+                if (cnt > 1) ans += cnt;
+                cnt = 0;
             }
-            lastMove=t;
+            lastMove = t;
             cnt++;
         }
         else {
-            if (cnt>0) {
-                ans+=lastMove.substring(0,1).toUpperCase();
-                if (cnt>1) ans+=cnt;
-                cnt=0;
+            if (cnt > 0) {
+                ans += lastMove.substring(0, 1).toUpperCase();
+                if (cnt > 1) ans += cnt;
+                cnt = 0;
             }
-            if (t.indexOf('item:')==0)
-                ans+="I"+t.substring(5)+":";
-            else if (t.indexOf('fly:')==0)
-                ans+="F"+t.substring(4)+":";
-            else if (t.indexOf('choices:')==0)
-                ans+="C"+t.substring(8);
-            else if (t.indexOf('shop:')==0)
-                ans+="S"+t.substring(5);
-            else if (t=='turn')
-                ans+='T';
-            else if (t=='getNext')
-                ans+='G';
-            else if (t.indexOf('input:')==0)
-                ans+="P"+t.substring(6);
-            else if (t=='no')
-                ans+='N';
-            else if (t.indexOf('move:')==0)
-                ans+="M"+t.substring(5);
-            else if (t.indexOf('key:')==0)
-                ans+='K'+t.substring(4);
-            else if (t.indexOf('random:')==0)
-                ans+='X'+t.substring(7);
+            ans += core.utils._encodeRoute_encodeOne(t);
         }
     });
-    if (cnt>0) {
-        ans+=lastMove.substring(0,1).toUpperCase();
-        if (cnt>1) ans+=cnt;
+    if (cnt > 0) {
+        ans += lastMove.substring(0, 1).toUpperCase();
+        if (cnt > 1) ans += cnt;
     }
-    return ans;
+    return LZString.compressToBase64(ans);
+}
+
+utils.prototype._encodeRoute_id2number = function (id) {
+    var number = core.maps.getNumberById(id);
+    return number == 0 ? id : number;
+}
+
+utils.prototype._encodeRoute_encodeOne = function (t) {
+    if (t.indexOf('item:') == 0)
+        return "I" + this._encodeRoute_id2number(t.substring(5)) + ":";
+    else if (t.indexOf('unEquip:') == 0)
+        return "u" + t.substring(8);
+    else if (t.indexOf('equip:') == 0)
+        return "e" + this._encodeRoute_id2number(t.substring(6)) + ":";
+    else if (t.indexOf('fly:') == 0)
+        return "F" + t.substring(4) + ":";
+    else if (t.indexOf('choices:') == 0)
+        return "C" + t.substring(8);
+    else if (t.indexOf('shop:') == 0)
+        return "S" + t.substring(5);
+    else if (t == 'turn')
+        return 'T';
+    else if (t.indexOf('turn:') == 0)
+        return "t" + t.substring(5).substring(0, 1).toUpperCase() + ":";
+    else if (t == 'getNext')
+        return 'G';
+    else if (t.indexOf('input:') == 0)
+        return "P" + t.substring(6);
+    else if (t.indexOf('input2:') == 0)
+        return "Q" + t.substring(7) + ":";
+    else if (t == 'no')
+        return 'N';
+    else if (t.indexOf('move:') == 0)
+        return "M" + t.substring(5);
+    else if (t.indexOf('key:') == 0)
+        return 'K' + t.substring(4);
+    else if (t.indexOf('random:') == 0)
+        return 'X' + t.substring(7);
+    return '('+t+')';
 }
 
 ////// 解密路线 //////
 utils.prototype.decodeRoute = function (route) {
+    if (!route) return route;
 
-    if (!core.isset(route)) return route;
-
-    var ans=[], index=0;
-
-    var getNumber = function (noparse) {
-        var num="";
-        while (index<route.length && !isNaN(route.charAt(index))) {
-            num+=route.charAt(index++);
+    // 解压缩
+    try {
+        var v = LZString.decompressFromBase64(route);
+        if (v != null && /^[-_a-zA-Z0-9+\/=:()]*$/.test(v)) {
+            if (v != "" || route.length < 8)
+                route = v;
         }
-        if (num.length==0) num="1";
-        return core.isset(noparse)?num:parseInt(num);
-    }
-    var getString = function () {
-        var str="";
-        while (index<route.length && /\w/.test(route.charAt(index))) {
-            str+=route.charAt(index++);
-        }
-        index++;
-        return str;
+    } catch (e) {
     }
 
-    while (index<route.length) {
-        var c=route.charAt(index++);
-        var nxt=(c=='I'||c=='F'||c=='S')?getString():getNumber();
-
-        switch (c) {
-            case "U": for (var i=0;i<nxt;i++) ans.push("up"); break;
-            case "D": for (var i=0;i<nxt;i++) ans.push("down"); break;
-            case "L": for (var i=0;i<nxt;i++) ans.push("left"); break;
-            case "R": for (var i=0;i<nxt;i++) ans.push("right"); break;
-            case "I": ans.push("item:"+nxt); break;
-            case "F": ans.push("fly:"+nxt); break;
-            case "C": ans.push("choices:"+nxt); break;
-            case "S": ans.push("shop:"+nxt+":"+getNumber(true)); break;
-            case "T": ans.push("turn"); break;
-            case "G": ans.push("getNext"); break;
-            case "P": ans.push("input:"+nxt); break;
-            case "N": ans.push("no"); break;
-            case "M": ++index; ans.push("move:"+nxt+":"+getNumber()); break;
-            case "K": ans.push("key:"+nxt); break;
-            case "X": ans.push("random:"+nxt); break;
-        }
+    var decodeObj = {route: route, index: 0, ans: []};
+    while (decodeObj.index < decodeObj.route.length) {
+        this._decodeRoute_decodeOne(decodeObj, decodeObj.route.charAt(decodeObj.index++));
     }
-    return ans;
+    return decodeObj.ans;
 }
 
-////// 判断某对象是否不为undefined也不会null //////
-utils.prototype.isset = function (val) {
-    if (val == undefined || val == null || (typeof val=='number' && isNaN(val))) {
-        return false;
+utils.prototype._decodeRoute_getNumber = function (decodeObj, noparse) {
+    var num = "";
+    while (decodeObj.index < decodeObj.route.length && !isNaN(decodeObj.route.charAt(decodeObj.index))) {
+        num += decodeObj.route.charAt(decodeObj.index++);
     }
-    return true
+    if (num.length == 0) num = "1";
+    return noparse ? num : parseInt(num);
+}
+
+utils.prototype._decodeRoute_getString = function (decodeObj) {
+    var str = "";
+    while (decodeObj.index < decodeObj.route.length && decodeObj.route.charAt(decodeObj.index) != ':') {
+        str += decodeObj.route.charAt(decodeObj.index++);
+    }
+    decodeObj.index++;
+    return str;
+}
+
+utils.prototype._decodeRoute_number2id = function (number) {
+    if (/^\d+$/.test(number)) {
+        var info = core.maps.blocksInfo[number];
+        if (info) return info.id;
+    }
+    return number;
+}
+
+utils.prototype._decodeRoute_decodeOne = function (decodeObj, c) {
+    // --- 特殊处理自定义项
+    if (c == '(') {
+        var idx = decodeObj.route.indexOf(')', decodeObj.index);
+        if (idx >= 0) {
+            decodeObj.ans.push(decodeObj.route.substring(decodeObj.index, idx));
+            decodeObj.index = idx + 1;
+            return;
+        }
+    }
+    var nxt = (c == 'I' || c == 'e' || c == 'F' || c == 'S' || c == 'Q' || c == 't') ?
+        this._decodeRoute_getString(decodeObj) : this._decodeRoute_getNumber(decodeObj);
+
+    var mp = {"U": "up", "D": "down", "L": "left", "R": "right"};
+
+    switch (c) {
+        case "U":
+        case "D":
+        case "L":
+        case "R":
+            for (var i = 0; i < nxt; i++) decodeObj.ans.push(mp[c]);
+            break;
+        case "I":
+            decodeObj.ans.push("item:" + this._decodeRoute_number2id(nxt));
+            break;
+        case "u":
+            decodeObj.ans.push("unEquip:" + nxt);
+            break;
+        case "e":
+            decodeObj.ans.push("equip:" + this._decodeRoute_number2id(nxt));
+            break;
+        case "F":
+            decodeObj.ans.push("fly:" + nxt);
+            break;
+        case "C":
+            decodeObj.ans.push("choices:" + nxt);
+            break;
+        case "S":
+            decodeObj.ans.push("shop:" + nxt + ":" + this._decodeRoute_getNumber(decodeObj, true));
+            break;
+        case "T":
+            decodeObj.ans.push("turn");
+            break;
+        case "t":
+            decodeObj.ans.push("turn:" + mp[nxt]);
+            break;
+        case "G":
+            decodeObj.ans.push("getNext");
+            break;
+        case "P":
+            decodeObj.ans.push("input:" + nxt);
+            break;
+        case "Q":
+            decodeObj.ans.push("input2:" + nxt);
+            break;
+        case "N":
+            decodeObj.ans.push("no");
+            break;
+        case "M":
+            ++decodeObj.index;
+            decodeObj.ans.push("move:" + nxt + ":" + this._decodeRoute_getNumber(decodeObj));
+            break;
+        case "K":
+            decodeObj.ans.push("key:" + nxt);
+            break;
+        case "X":
+            decodeObj.ans.push("random:" + nxt);
+            break;
+    }
+}
+
+////// 判断某对象是否不为null也不为NaN //////
+utils.prototype.isset = function (val) {
+    return val != null && !(typeof val == 'number' && isNaN(val));
 }
 
 ////// 获得子数组 //////
 utils.prototype.subarray = function (a, b) {
-    if (!core.isset(a) || !core.isset(b) || !(a instanceof Array) || !(b instanceof Array) || a.length<b.length)
+    if (!(a instanceof Array) || !(b instanceof Array) || a.length < b.length)
         return null;
-    var na = core.clone(a), nb=core.clone(b);
-    while (nb.length>0) {
+    var na = core.clone(a), nb = core.clone(b);
+    while (nb.length > 0) {
         if (na.shift() != nb.shift()) return null;
     }
     return na;
 }
 
+utils.prototype.inArray = function (array, element) {
+    return (array instanceof Array) && array.indexOf(element) >= 0;
+}
+
 utils.prototype.clamp = function (x, a, b) {
-    var min=Math.min(a, b), max=Math.max(a, b);
-    return Math.min(Math.max(x||0, min), max);
+    var min = Math.min(a, b), max = Math.max(a, b);
+    return Math.min(Math.max(x || 0, min), max);
+}
+
+utils.prototype.getCookie = function (name) {
+    var match = document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'));
+    return match ? match[2] : null;
+}
+
+////// 设置statusBar的innerHTML，会自动斜体和放缩，也可以增加自定义css //////
+utils.prototype.setStatusBarInnerHTML = function (name, value, css) {
+    if (!core.statusBar[name]) return;
+    if (typeof value == 'number') value = this.formatBigNumber(value);
+    // 判定是否斜体
+    var italic = /^[-a-zA-Z0-9`~!@#$%^&*()_=+\[{\]}\\|;:'",<.>\/?]*$/.test(value);
+    var style = 'font-style: ' + (italic ? 'italic' : 'normal') + '; ';
+    // 判定是否需要缩放
+    var length = this.strlen(value) || 1;
+    style += 'font-size: ' + Math.min(1, 7 / length) + 'em; ';
+    if (css) style += css;
+    core.statusBar[name].innerHTML = "<span class='_status' style='" + style + "'>" + value + "</span>";
+}
+
+utils.prototype.strlen = function (str) {
+    var count = 0;
+    for (var i = 0, len = str.length; i < len; i++) {
+        count += str.charCodeAt(i) < 256 ? 1 : 2;
+    }
+    return count;
+};
+
+utils.prototype.reverseDirection = function (direction) {
+    direction = direction || core.getHeroLoc('direction');
+    return {"left":"right","right":"left","down":"up","up":"down"}[direction] || direction;
+}
+
+utils.prototype.matchWildcard = function (pattern, string) {
+    return new RegExp('^' + pattern.split(/\*+/).map(function (s) {
+        return s.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&');
+    }).join('.*') + '$').test(string);
 }
 
 ////// Base64加密 //////
@@ -366,66 +666,85 @@ utils.prototype.encodeBase64 = function (str) {
 
 ////// Base64解密 //////
 utils.prototype.decodeBase64 = function (str) {
-    return decodeURIComponent(atob(str).split('').map(function(c) {
+    return decodeURIComponent(atob(str).split('').map(function (c) {
         return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
     }).join(''));
 }
 
-utils.prototype.__init_seed = function () {
-    var rand = new Date().getTime()%34834795 + 3534;
-    rand = this.__next_rand(rand);
-    rand = this.__next_rand(rand);
-    rand = this.__next_rand(rand);
-    core.setFlag('seed', rand);
-    core.setFlag('rand', rand);
-}
-
-utils.prototype.__next_rand = function (_rand) {
-    _rand=(_rand%127773)*16807-~~(_rand/127773)*2836;
-    _rand+=_rand<0?2147483647:0;
-    return _rand;
+////// 任意进制转换 //////
+utils.prototype.convertBase = function (str, fromBase, toBase) {
+    var map = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ~`!@#$%^&*()_-+={}[]\\|:;<>,.?/";
+    if (fromBase == toBase) return str;
+    var len = str.length, ans = "";
+    var t = [];
+    for (var i = 0; i < len; i++) t[i] = map.indexOf(str.charAt(i));
+    t[len] = 0;
+    while (len > 0) {
+        for (var i = len; i >= 1; i--) {
+            t[i - 1] += t[i] % toBase * fromBase;
+            t[i] = parseInt(t[i] / toBase);
+        }
+        ans += map.charAt(t[0] % toBase);
+        t[0] = parseInt(t[0] / toBase);
+        while (len > 0 && t[len - 1] == 0) len--;
+    }
+    return ans;
 }
 
 utils.prototype.rand = function (num) {
-    var rand = core.getFlag('rand');
+    var rand = core.getFlag('__rand__');
     rand = this.__next_rand(rand);
-    core.setFlag('rand', rand);
-    var ans = rand/2147483647;
-    if (core.isset(num) && num>0)
-        return Math.floor(ans*num);
+    core.setFlag('__rand__', rand);
+    var ans = rand / 2147483647;
+    if (num && num > 0)
+        return Math.floor(ans * num);
     return ans;
 }
 
 ////// 生成随机数（录像方法） //////
 utils.prototype.rand2 = function (num) {
-    num = num||2147483648;
+    num = num || 2147483648;
 
     var value;
-    if (core.status.replay.replaying) {
+    if (core.isReplaying()) {
         var action = core.status.replay.toReplay.shift();
-        if (action.indexOf("random:")==0 ) {
-            value=parseInt(action.substring(7));
+        if (action.indexOf("random:") == 0) {
+            value = parseInt(action.substring(7));
         }
         else {
-            core.stopReplay();
-            core.drawTip("录像文件出错");
-            return;
+            core.control._replay_error(action);
+            return 0;
         }
     }
     else {
-        value = Math.floor(Math.random()*num);
+        value = Math.floor(Math.random() * num);
     }
-    core.status.route.push("random:"+value);
+    core.status.route.push("random:" + value);
     return value;
 }
 
+utils.prototype.__init_seed = function () {
+    var rand = new Date().getTime() % 34834795 + 3534;
+    rand = this.__next_rand(rand);
+    rand = this.__next_rand(rand);
+    rand = this.__next_rand(rand);
+    core.setFlag('__seed__', rand);
+    core.setFlag('__rand__', rand);
+}
+
+utils.prototype.__next_rand = function (_rand) {
+    _rand = (_rand % 127773) * 16807 - ~~(_rand / 127773) * 2836;
+    _rand += _rand < 0 ? 2147483647 : 0;
+    return _rand;
+}
+
 ////// 读取一个本地文件内容 //////
 utils.prototype.readFile = function (success, error, readType) {
 
     core.platform.successCallback = success;
     core.platform.errorCallback = error;
 
-    if (core.isset(window.jsinterface)) {
+    if (window.jsinterface) {
         window.jsinterface.readFile();
         return;
     }
@@ -433,29 +752,29 @@ utils.prototype.readFile = function (success, error, readType) {
     // step 0: 不为http/https，直接不支持
     if (!core.platform.isOnline) {
         alert("离线状态下不支持文件读取！");
-        if (core.isset(error)) error();
+        if (error) error();
         return;
     }
 
     // Step 1: 如果不支持FileReader，直接不支持
-    if (core.platform.fileReader==null) {
+    if (core.platform.fileReader == null) {
         alert("当前浏览器不支持FileReader！");
-        if (core.isset(error)) error();
+        if (error) error();
         return;
     }
 
-    if (core.platform.fileInput==null) {
+    if (core.platform.fileInput == null) {
         core.platform.fileInput = document.createElement("input");
         core.platform.fileInput.style.opacity = 0;
         core.platform.fileInput.type = 'file';
         core.platform.fileInput.onchange = function () {
             var files = core.platform.fileInput.files;
-            if (files.length==0) {
-                if (core.isset(core.platform.errorCallback))
+            if (files.length == 0) {
+                if (core.platform.errorCallback)
                     core.platform.errorCallback();
                 return;
             }
-            if(!readType)core.platform.fileReader.readAsText(core.platform.fileInput.files[0]);
+            if (!readType) core.platform.fileReader.readAsText(core.platform.fileInput.files[0]);
             else core.platform.fileReader.readAsDataURL(core.platform.fileInput.files[0]);
             core.platform.fileInput.value = '';
         }
@@ -466,33 +785,34 @@ utils.prototype.readFile = function (success, error, readType) {
 
 ////// 读取文件完毕 //////
 utils.prototype.readFileContent = function (content) {
-    var obj=null;
-    if(content.slice(0,4)==='data'){
-        if (core.isset(core.platform.successCallback))
+    var obj = null;
+    if (content.slice(0, 4) === 'data') {
+        if (core.platform.successCallback)
             core.platform.successCallback(content);
         return;
     }
     try {
-        obj=JSON.parse(content);
-        if (core.isset(obj)) {
-            if (core.isset(core.platform.successCallback))
+        obj = JSON.parse(content);
+        if (obj) {
+            if (core.platform.successCallback)
                 core.platform.successCallback(obj);
             return;
         }
     }
     catch (e) {
-        console.log(e);
+        main.log(e);
+        alert(e);
     }
-    alert("不是有效的JSON文件！");
+    // alert("不是有效的JSON文件！");
 
-    if (core.isset(core.platform.errorCallback))
+    if (core.platform.errorCallback)
         core.platform.errorCallback();
 }
 
 ////// 下载文件到本地 //////
 utils.prototype.download = function (filename, content) {
 
-    if (core.isset(window.jsinterface)) {
+    if (window.jsinterface) {
         window.jsinterface.download(filename, content);
         return;
     }
@@ -505,7 +825,12 @@ utils.prototype.download = function (filename, content) {
 
     // Step 1: 如果是iOS平台，直接不支持
     if (core.platform.isIOS) {
-        alert("iOS平台下不支持下载操作！");
+        if (core.copy(content)) {
+            alert("iOS平台下不支持直接下载文件！\n所有应下载内容已经复制到您的剪切板，请自行创建空白文件并粘贴。");
+        }
+        else {
+            alert("iOS平台下不支持下载操作！");
+        }
         return;
     }
 
@@ -527,15 +852,14 @@ utils.prototype.download = function (filename, content) {
         alert("你当前使用的是Safari浏览器，不支持直接下载文件。\n即将打开一个新窗口为应下载内容，请自行全选复制然后创建空白文件并粘贴。");
         var blob = new Blob([content], {type: 'text/plain;charset=utf-8'});
         var href = window.URL.createObjectURL(blob);
-        var opened=window.open(href, "_blank");
-        // if (!opened) window.location.href=href;
+        var opened = window.open(href, "_blank");
         window.URL.revokeObjectURL(href);
         return;
     }
 
     // Step 4: 下载
     var blob = new Blob([content], {type: 'text/plain;charset=utf-8'});
-    if(window.navigator.msSaveOrOpenBlob) {
+    if (window.navigator.msSaveOrOpenBlob) {
         window.navigator.msSaveBlob(blob, filename);
     }
     else {
@@ -553,8 +877,8 @@ utils.prototype.download = function (filename, content) {
 ////// 复制一段内容到剪切板 //////
 utils.prototype.copy = function (data) {
 
-    if (core.isset(window.jsinterface)) {
-        window.jsinterface.copy(filename, content);
+    if (window.jsinterface) {
+        window.jsinterface.copy(data);
         return true;
     }
 
@@ -586,16 +910,36 @@ utils.prototype.copy = function (data) {
     return successful;
 }
 
+////// 显示一段confirm //////
+utils.prototype.myconfirm = function (hint, yesCallback, noCallback) {
+    main.dom.inputDiv.style.display = 'block';
+    main.dom.inputMessage.innerHTML = hint.replace(/\n/g, '<br/>');
+    main.dom.inputBox.style.display = 'none';
+    main.dom.inputYes.focus();
+
+    core.platform.successCallback = yesCallback;
+    core.platform.errorCallback = noCallback;
+}
+
+////// 让用户输入一段文字 //////
+utils.prototype.myprompt = function (hint, value, callback) {
+    main.dom.inputDiv.style.display = 'block';
+    main.dom.inputMessage.innerHTML = hint.replace(/\n/g, '<br/>');
+    main.dom.inputBox.style.display = 'block';
+    main.dom.inputBox.value = value==null?"":value;
+    setTimeout(function () {
+        main.dom.inputBox.focus();
+    });
+
+    core.platform.successCallback = core.platform.errorCallback = callback;
+}
+
 ////// 动画显示某对象 //////
-utils.prototype.show = function (obj, speed, callback) {
-    if (!core.isset(speed)) {
-        obj.style.display = 'block';
-        return;
-    }
+utils.prototype.showWithAnimate = function (obj, speed, callback) {
     obj.style.display = 'block';
-    if (main.mode!='play'){
+    if (!speed && main.mode != 'play') {
         obj.style.opacity = 1;
-        if (core.isset(callback)) {callback();}
+        if (callback) callback();
         return;
     }
     obj.style.opacity = 0;
@@ -605,24 +949,19 @@ utils.prototype.show = function (obj, speed, callback) {
         obj.style.opacity = opacityVal;
         if (opacityVal > 1) {
             clearInterval(showAnimate);
-            if (core.isset(callback)) {
-                callback();
-            }
+            if (callback) callback();
         }
     }, speed);
 }
 
 ////// 动画使某对象消失 //////
-utils.prototype.hide = function (obj, speed, callback) {
-    if (!core.isset(speed)) {
+utils.prototype.hideWithAnimate = function (obj, speed, callback) {
+    if (!speed || main.mode != 'play') {
         obj.style.display = 'none';
+        if (callback) callback();
         return;
     }
-    if (main.mode!='play'){
-        obj.style.display = 'none';
-        if (core.isset(callback)) {callback();}
-        return;
-    }
+    obj.style.opacity = 1;
     var opacityVal = 1;
     var hideAnimate = window.setInterval(function () {
         opacityVal -= 0.03;
@@ -630,29 +969,128 @@ utils.prototype.hide = function (obj, speed, callback) {
         if (opacityVal < 0) {
             obj.style.display = 'none';
             clearInterval(hideAnimate);
-            if (core.isset(callback)) {
-                callback();
-            }
+            if (callback) callback();
         }
     }, speed);
 }
 
+utils.prototype._encodeCanvas = function (ctx) {
+    var list = [];
+    var width = ctx.canvas.width, height = ctx.canvas.height;
+    ctx.mozImageSmoothingEnabled = false;
+    ctx.webkitImageSmoothingEnabled = false;
+    ctx.msImageSmoothingEnabled = false;
+    ctx.imageSmoothingEnabled = false;
+
+    var imgData = ctx.getImageData(0, 0, width, height);
+    for (var i = 0; i < imgData.data.length; i += 4) {
+        list.push(Math.sign(imgData.data[i + 3]));
+    }
+    // compress 01 to array
+    var prev = 0, cnt = 0, arr = [];
+    for (var i = 0; i < list.length; i++) {
+        if (list[i] != prev) {
+            arr.push(cnt);
+            prev = list[i];
+            cnt = 0;
+        }
+        cnt++;
+    }
+    arr.push(cnt);
+    return arr;
+}
+
+////// 解析arr数组，并绘制到tempCanvas上 //////
+utils.prototype._decodeCanvas = function (arr, width, height) {
+    // 清空tempCanvas
+    var tempCanvas = core.bigmap.tempCanvas;
+    tempCanvas.canvas.width = width;
+    tempCanvas.canvas.height = height;
+    tempCanvas.clearRect(0, 0, width, height);
+
+    if (!arr) return null;
+    // to byte array
+    var curr = 0, list = [];
+    arr.forEach(function (x) {
+        for (var i = 0; i < x; i++) list.push(curr);
+        curr = 1 - curr;
+    })
+
+    var imgData = tempCanvas.getImageData(0, 0, width, height);
+    for (var i = 0; i < imgData.data.length; i += 4) {
+        var index = i / 4;
+        if (list[index]) {
+            imgData.data[i] = 255;
+            imgData.data[i + 3] = 255;
+        }
+    }
+    tempCanvas.putImageData(imgData, 0, 0);
+}
+
+utils.prototype.consoleOpened = function () {
+    if (!core.flags.checkConsole) return false;
+    if (window.Firebug && window.Firebug.chrome && window.Firebug.chrome.isInitialized)
+        return true;
+    if (!core.platform.isPC) return false;
+    var threshold = 160;
+    var zoom = Math.min(window.outerWidth / window.innerWidth, window.outerHeight / window.innerHeight);
+    return window.outerWidth - zoom * window.innerWidth > threshold
+        || window.outerHeight - zoom * window.innerHeight > threshold;
+}
+
+utils.prototype.hashCode = function (obj) {
+    if (typeof obj == 'string') {
+        var hash = 0, i, chr;
+        if (obj.length === 0) return hash;
+        for (i = 0; i < obj.length; i++) {
+            chr = obj.charCodeAt(i);
+            hash = ((hash << 5) - hash) + chr;
+            hash |= 0;
+        }
+        return hash;
+    }
+    return this.hashCode(JSON.stringify(obj).split("").sort().join(""));
+}
+
+utils.prototype.same = function (a, b) {
+    if (a == null && b == null) return true;
+    if (a == null || b == null) return false;
+    if (a === b) return true;
+    if (a instanceof Array && b instanceof Array) {
+        if (a.length != b.length) return false;
+        for (var i = 0; i < a.length; i++) {
+            if (!this.same(a[i], b[i])) return false;
+        }
+        return true;
+    }
+    if (a instanceof Object && b instanceof Object) {
+        for (var i in a) {
+            if (!this.same(a[i], b[i])) return false;
+        }
+        for (var i in b) {
+            if (!this.same(a[i], b[i])) return false;
+        }
+        return true;
+    }
+    return false;
+}
+
 utils.prototype._export = function (floorIds) {
-    if (!core.isset(floorIds)) floorIds = [core.status.floorId];
-    else if (floorIds=='all') floorIds = core.clone(core.floorIds);
+    if (!floorIds) floorIds = [core.status.floorId];
+    else if (floorIds == 'all') floorIds = core.clone(core.floorIds);
     else if (typeof floorIds == 'string') floorIds = [floorIds];
 
     var monsterMap = {};
 
     // map
-    var content = floorIds.length+"\n13 13\n\n";
+    var content = floorIds.length + "\n" + core.__SIZE__ + " " + core.__SIZE__ + "\n\n";
     floorIds.forEach(function (floorId) {
-        var arr = core.maps.getMapArray(core.status.maps[floorId].blocks);
+        var arr = core.maps._getMapArrayFromBlocks(core.status.maps[floorId].blocks);
         content += arr.map(function (x) {
             // check monster
             x.forEach(function (t) {
                 var block = core.maps.initBlock(null, null, t);
-                if (core.isset(block.event) && block.event.cls.indexOf("enemy")==0) {
+                if (block.event.cls.indexOf("enemy") == 0) {
                     monsterMap[t] = block.event.id;
                 }
             })
@@ -662,7 +1100,9 @@ utils.prototype._export = function (floorIds) {
 
     // values
     content += ["redJewel", "blueJewel", "greenJewel", "redPotion", "bluePotion",
-        "yellowPotion", "greenPotion", "sword1", "shield1"].map(function (x) {return core.values[x]}).join(" ") + "\n\n";
+        "yellowPotion", "greenPotion", "sword1", "shield1"].map(function (x) {
+        return core.values[x]
+    }).join(" ") + "\n\n";
 
     // monster
     content += Object.keys(monsterMap).length + "\n";
@@ -683,34 +1123,80 @@ utils.prototype._export = function (floorIds) {
 utils.prototype.http = function (type, url, formData, success, error, mimeType, responseType) {
     var xhr = new XMLHttpRequest();
     xhr.open(type, url, true);
-    if (core.isset(mimeType))
-        xhr.overrideMimeType(mimeType);
-    if (core.isset(responseType))
-        xhr.responseType = responseType;
-    xhr.onload = function(e) {
-        if (xhr.status==200) {
-            if (core.isset(success)) {
-                success(xhr.response);
-            }
+    if (mimeType) xhr.overrideMimeType(mimeType);
+    if (responseType) xhr.responseType = responseType;
+    xhr.onload = function (e) {
+        if (xhr.status == 200) {
+            if (success) success(xhr.response);
         }
         else {
-            if (core.isset(error))
-                error("HTTP "+xhr.status);
+            if (error) error("HTTP " + xhr.status);
         }
     };
     xhr.onabort = function () {
-        if (core.isset(error))
-            error("Abort");
+        if (error) error("Abort");
     }
-    xhr.ontimeout = function() {
-        if (core.isset(error))
-            error("Timeout");
+    xhr.ontimeout = function () {
+        if (error) error("Timeout");
     }
-    xhr.onerror = function() {
-        if (core.isset(error))
-            error("Error on Connection");
+    xhr.onerror = function () {
+        if (error) error("Error on Connection");
     }
-    if (core.isset(formData))
+    if (formData)
         xhr.send(formData);
     else xhr.send();
 }
+
+// LZW-compress
+// https://gist.github.com/revolunet/843889
+function lzw_encode(s) {
+    var dict = {};
+    var data = (s + "").split("");
+    var out = [];
+    var currChar;
+    var phrase = data[0];
+    var code = 256;
+    for (var i = 1; i < data.length; i++) {
+        currChar = data[i];
+        if (dict[phrase + currChar] != null) {
+            phrase += currChar;
+        }
+        else {
+            out.push(phrase.length > 1 ? dict[phrase] : phrase.charCodeAt(0));
+            dict[phrase + currChar] = code;
+            code++;
+            phrase = currChar;
+        }
+    }
+    out.push(phrase.length > 1 ? dict[phrase] : phrase.charCodeAt(0));
+    for (var i = 0; i < out.length; i++) {
+        out[i] = String.fromCharCode(out[i]);
+    }
+    return out.join("");
+}
+
+// Decompress an LZW-encoded string
+function lzw_decode(s) {
+    var dict = {};
+    var data = (s + "").split("");
+    var currChar = data[0];
+    var oldPhrase = currChar;
+    var out = [currChar];
+    var code = 256;
+    var phrase;
+    for (var i = 1; i < data.length; i++) {
+        var currCode = data[i].charCodeAt(0);
+        if (currCode < 256) {
+            phrase = data[i];
+        }
+        else {
+            phrase = dict[currCode] ? dict[currCode] : (oldPhrase + currChar);
+        }
+        out.push(phrase);
+        currChar = phrase.charAt(0);
+        dict[code] = oldPhrase + currChar;
+        code++;
+        oldPhrase = phrase;
+    }
+    return out.join("");
+}
diff --git a/main.js b/main.js
index dcb07fb5..5ecac76f 100644
--- a/main.js
+++ b/main.js
@@ -2,7 +2,7 @@ function main() {
 
     //------------------------ 用户修改内容 ------------------------//
 
-    this.version = "2.3.3"; // 游戏版本号；如果更改了游戏内容建议修改此version以免造成缓存问题。
+    this.version = "2.6.1"; // 游戏版本号；如果更改了游戏内容建议修改此version以免造成缓存问题。
 
     this.useCompress = false; // 是否使用压缩文件
     // 当你即将发布你的塔时，请使用“JS代码压缩工具”将所有js代码进行压缩，然后将这里的useCompress改为true。
@@ -14,7 +14,7 @@ function main() {
 
     this.isCompetition = false; // 是否是比赛模式
 
-    this.savePages = 100; // 存档页数，每页可存5个；默认为100页500个存档
+    this.savePages = 1000; // 存档页数，每页可存5个；默认为1000页5000个存档
 
     //------------------------ 用户修改内容 END ------------------------//
 
@@ -42,7 +42,6 @@ function main() {
         'gameCanvas': document.getElementsByClassName('gameCanvas'),
         'gif': document.getElementById('gif'),
         'gif2': document.getElementById('gif2'),
-        'curtain': document.getElementById('curtain'),
         'gameDraw': document.getElementById('gameDraw'),
         'startButtons': document.getElementById('startButtons'),
         'playGame': document.getElementById('playGame'),
@@ -51,24 +50,38 @@ function main() {
         'levelChooseButtons': document.getElementById('levelChooseButtons'),
         'data': document.getElementById('data'),
         'statusLabels': document.getElementsByClassName('statusLabel'),
+        'statusTexts': document.getElementsByClassName('statusText'),
         'floorCol': document.getElementById('floorCol'),
+        'nameCol': document.getElementById('nameCol'),
         'lvCol': document.getElementById('lvCol'),
         'hpmaxCol': document.getElementById('hpmaxCol'),
+        'hpCol': document.getElementById('hpCol'),
+        'manaCol': document.getElementById('manaCol'),
+        'atkCol': document.getElementById('atkCol'),
+        'defCol': document.getElementById('defCol'),
         'mdefCol': document.getElementById('mdefCol'),
         'moneyCol': document.getElementById('moneyCol'),
-        'expCol': document.getElementById('expCol'),
+        'experienceCol': document.getElementById('experienceCol'),
         'upCol': document.getElementById('upCol'),
         'keyCol': document.getElementById('keyCol'),
         'pzfCol': document.getElementById('pzfCol'),
         'debuffCol': document.getElementById('debuffCol'),
+        'skillCol': document.getElementById('skillCol'),
         'hard': document.getElementById('hard'),
+        'statusCanvas': document.getElementById('statusCanvas'),
+        'statusCanvasCtx': document.getElementById('statusCanvas').getContext('2d'),
+        'inputDiv': document.getElementById('inputDiv'),
+        'inputMessage': document.getElementById('inputMessage'),
+        'inputBox': document.getElementById('inputBox'),
+        'inputYes': document.getElementById('inputYes'),
+        'inputNo': document.getElementById('inputNo')
     };
     this.mode = 'play';
     this.loadList = [
         'loader', 'control', 'utils', 'items', 'icons', 'maps', 'enemys', 'events', 'actions', 'data', 'ui', 'core'
     ];
     this.pureData = [ 
-        "data","enemys","icons","maps","items","functions"
+        'data', 'enemys', 'icons', 'maps', 'items', 'functions', 'events', 'plugins'
     ];
     this.materials = [
         'animates', 'enemys', 'hero', 'items', 'npcs', 'terrains', 'enemy48', 'npc48'
@@ -77,25 +90,38 @@ function main() {
     this.statusBar = {
         'image': {
             'floor': document.getElementById('img-floor'),
+            'name': document.getElementById('img-name'),
             'lv': document.getElementById('img-lv'),
             'hpmax': document.getElementById('img-hpmax'),
             'hp': document.getElementById("img-hp"),
+            'mana': document.getElementById("img-mana"),
             'atk': document.getElementById("img-atk"),
             'def': document.getElementById("img-def"),
             'mdef': document.getElementById("img-mdef"),
             'money': document.getElementById("img-money"),
             'experience': document.getElementById("img-experience"),
             'up': document.getElementById("img-up"),
+            'skill': document.getElementById('img-skill'),
             'book': document.getElementById("img-book"),
             'fly': document.getElementById("img-fly"),
             'toolbox': document.getElementById("img-toolbox"),
-            'shop': document.getElementById("img-shop"),
+            'keyboard': document.getElementById("img-keyboard"),
+            'shop': document.getElementById('img-shop'),
             'save': document.getElementById("img-save"),
             'load': document.getElementById("img-load"),
-            'settings': document.getElementById("img-settings")
+            'settings': document.getElementById("img-settings"),
+            'btn1': document.getElementById("img-btn1"),
+            'btn2': document.getElementById("img-btn2"),
+            'btn3': document.getElementById("img-btn3"),
+            'btn4': document.getElementById("img-btn4"),
+            'btn5': document.getElementById("img-btn5"),
+            'btn6': document.getElementById("img-btn6"),
+            'btn7': document.getElementById("img-btn7"),
+            'btn8': document.getElementById("img-btn8"),
         },
         'icons': {
             'floor': 0,
+            'name': null,
             'lv': 1,
             'hpmax': 2,
             'hp': 3,
@@ -108,27 +134,46 @@ function main() {
             'book': 10,
             'fly': 11,
             'toolbox': 12,
-            'shop': 13,
-            'save': 14,
-            'load': 15,
-            'settings': 16,
-            'play': 17,
-            'pause': 18,
-            'stop': 19,
-            'speedDown': 20,
-            'speedUp': 21,
-            'rewind': 22,
+            'keyboard': 13,
+            'shop': 14,
+            'save': 15,
+            'load': 16,
+            'settings': 17,
+            'play': 18,
+            'pause': 19,
+            'stop': 20,
+            'speedDown': 21,
+            'speedUp': 22,
+            'rewind': 23,
+            'equipbox': 24,
+            'mana': 25,
+            'skill': 26,
+            'paint': 27,
+            'erase': 28,
+            'empty': 29,
+            'exit': 30,
+            'btn1': 31,
+            'btn2': 32,
+            'btn3': 33,
+            'btn4': 34,
+            'btn5': 35,
+            'btn6': 36,
+            'btn7': 37,
+            'btn8': 38
         },
         'floor': document.getElementById('floor'),
+        'name': document.getElementById('name'),
         'lv': document.getElementById('lv'),
         'hpmax': document.getElementById('hpmax'),
         'hp': document.getElementById('hp'),
+        'mana': document.getElementById('mana'),
         'atk': document.getElementById('atk'),
         'def': document.getElementById("def"),
         'mdef': document.getElementById('mdef'),
         'money': document.getElementById("money"),
         'experience': document.getElementById("experience"),
         'up': document.getElementById('up'),
+        'skill': document.getElementById('skill'),
         'yellowKey': document.getElementById("yellowKey"),
         'blueKey': document.getElementById("blueKey"),
         'redKey': document.getElementById("redKey"),
@@ -142,18 +187,18 @@ function main() {
     }
     this.floors = {}
     this.canvas = {};
+
+    this.__VERSION__ = "2.6.1";
+    this.__VERSION_CODE__ = 36;
 }
 
 main.prototype.init = function (mode, callback) {
     for (var i = 0; i < main.dom.gameCanvas.length; i++) {
         main.canvas[main.dom.gameCanvas[i].id] = main.dom.gameCanvas[i].getContext('2d');
     }
-    if (({"editor":0}).hasOwnProperty(mode)) {
-        main.mode = mode;
-        if (mode === 'editor')main.editor = {'disableGlobalAnimate':true};
-    }
+    main.mode = mode;
 
-    main.loaderJs('project', main.pureData, function(){
+    main.loadJs('project', main.pureData, function(){
         var mainData = data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.main;
         for(var ii in mainData)main[ii]=mainData[ii];
         
@@ -171,30 +216,30 @@ main.prototype.init = function (mode, callback) {
             main.dom.levelChooseButtons.appendChild(span);
         });
         
-        main.loaderJs('libs', main.loadList, function () {
+        main.loadJs('libs', main.loadList, function () {
             main.core = core;
 
             for (i = 0; i < main.loadList.length; i++) {
                 var name = main.loadList[i];
                 if (name === 'core') continue;
-                main.core[name] = new (eval(name))();
+                main.core[name] = new window[name]();
             }
 
-            main.loaderFloors(function() {
+            main.loadFloors(function() {
                 var coreData = {};
-                ["dom", "statusBar", "canvas", "images", "materials",
+                ["dom", "statusBar", "canvas", "images", "tilesets", "materials",
                 "animates", "bgms", "sounds", "floorIds", "floors"].forEach(function (t) {
                     coreData[t] = main[t];
                 })
                 main.core.init(coreData, callback);
-                main.core.resize(main.dom.body.clientWidth, main.dom.body.clientHeight);
+                main.core.resize();
             });
         });
     });
 }
 
 ////// 动态加载所有核心JS文件 //////
-main.prototype.loaderJs = function (dir, loadList, callback) {
+main.prototype.loadJs = function (dir, loadList, callback) {
 
     // 加载js
     main.setMainTipsText('正在加载核心js文件...')
@@ -230,7 +275,7 @@ main.prototype.loadMod = function (dir, modName, callback) {
 }
 
 ////// 动态加载所有楼层（剧本） //////
-main.prototype.loaderFloors = function (callback) {
+main.prototype.loadFloors = function (callback) {
 
     // 加载js
     main.setMainTipsText('正在加载楼层文件...')
@@ -271,30 +316,43 @@ main.prototype.setMainTipsText = function (text) {
     main.dom.mainTips.innerHTML = text;
 }
 
+main.prototype.log = function (e) {
+    if (e) {
+        if (main.core && main.core.platform && !main.core.platform.isPC) {
+            console.log((e.stack || e.toString()));
+        }
+        else {
+            console.log(e);
+        }
+    }
+}
+
 
 main.prototype.listen = function () {
 
 ////// 窗口大小变化时 //////
 window.onresize = function () {
     try {
-        main.core.resize(main.dom.body.clientWidth, main.dom.body.clientHeight);
-    }catch (e) {}
+        main.core.resize();
+    }catch (e) { main.log(e); }
 }
 
 ////// 在界面上按下某按键时 //////
 main.dom.body.onkeydown = function(e) {
     try {
-        if (main.core.isPlaying() || main.core.status.lockControl)
+        if (main.dom.inputDiv.style.display == 'block') return;
+        if (main.core && (main.core.isPlaying() || main.core.status.lockControl))
             main.core.onkeyDown(e);
-    } catch (ee) {}
+    } catch (ee) { main.log(ee); }
 }
 
 ////// 在界面上放开某按键时 //////
 main.dom.body.onkeyup = function(e) {
     try {
-        if (main.core.isPlaying() || main.core.status.lockControl)
+        if (main.dom.inputDiv.style.display == 'block') return;
+        if (main.core && (main.core.isPlaying() || main.core.status.lockControl))
             main.core.onkeyUp(e);
-    } catch (ee) {}
+    } catch (ee) { main.log(ee); }
 }
 
 ////// 开始选择时 //////
@@ -306,33 +364,27 @@ main.dom.body.onselectstart = function () {
 main.dom.data.onmousedown = function (e) {
     try {
         e.stopPropagation();
-        if(e.button==1){// 把鼠标中键绑定为ESC
-            core.keyUp(27);
-            return;
-        }
-        var loc = main.core.getClickLoc(e.clientX, e.clientY);
+        var loc = main.core.actions._getClickLoc(e.clientX, e.clientY);
         if (loc == null) return;
-        var x = parseInt(loc.x / loc.size), y = parseInt(loc.y / loc.size);
-        main.core.ondown(x, y);
-    } catch (ee) {}
+        main.core.ondown(loc);
+    } catch (ee) { main.log(ee); }
 }
 
 ////// 鼠标移动时 //////
 main.dom.data.onmousemove = function (e) {
     try {
         e.stopPropagation();
-        var loc = main.core.getClickLoc(e.clientX, e.clientY);
+        var loc = main.core.actions._getClickLoc(e.clientX, e.clientY);
         if (loc == null) return;
-        var x = parseInt(loc.x / loc.size), y = parseInt(loc.y / loc.size);
-        main.core.onmove(x, y);
-    }catch (ee) {}
+        main.core.onmove(loc);
+    }catch (ee) { main.log(ee); }
 }
 
 ////// 鼠标放开时 //////
 main.dom.data.onmouseup = function () {
     try {
         main.core.onup();
-    }catch (e) {}
+    }catch (e) { main.log(e); }
 }
 
 ////// 鼠标滑轮滚动时 //////
@@ -342,135 +394,255 @@ main.dom.data.onmousewheel = function(e) {
             main.core.onmousewheel(Math.sign(e.wheelDelta))
         else if (e.detail)
             main.core.onmousewheel(Math.sign(e.detail));
-    } catch (ee) {}
+    } catch (ee) { main.log(ee); }
 }
 
 ////// 手指在触摸屏开始触摸时 //////
 main.dom.data.ontouchstart = function (e) {
     try {
         e.preventDefault();
-        var loc = main.core.getClickLoc(e.targetTouches[0].clientX, e.targetTouches[0].clientY);
+        var loc = main.core.actions._getClickLoc(e.targetTouches[0].clientX, e.targetTouches[0].clientY);
         if (loc == null) return;
-        var x = parseInt(loc.x / loc.size), y = parseInt(loc.y / loc.size);
-        //main.core.onclick(x, y, []);
-        main.core.ondown(x, y);
-    }catch (ee) {}
+        main.core.ondown(loc);
+    }catch (ee) { main.log(ee); }
 }
 
 ////// 手指在触摸屏上移动时 //////
 main.dom.data.ontouchmove = function (e) {
     try {
         e.preventDefault();
-        var loc = main.core.getClickLoc(e.targetTouches[0].clientX, e.targetTouches[0].clientY);
+        var loc = main.core.actions._getClickLoc(e.targetTouches[0].clientX, e.targetTouches[0].clientY);
         if (loc == null) return;
-        var x = parseInt(loc.x / loc.size), y = parseInt(loc.y / loc.size);
-        main.core.onmove(x, y);
-    }catch (ee) {}
+        main.core.onmove(loc);
+    }catch (ee) { main.log(ee); }
 }
 
 ////// 手指离开触摸屏时 //////
-main.dom.data.ontouchend = function () {
+main.dom.data.ontouchend = function (e) {
     try {
+        e.preventDefault();
         main.core.onup();
     } catch (e) {
+        main.log(e);
     }
 }
 
 ////// 点击状态栏中的怪物手册时 //////
-main.statusBar.image.book.onclick = function () {
-    if (core.isset(core.status.replay) && core.status.replay.replaying) {
+main.statusBar.image.book.onclick = function (e) {
+    e.stopPropagation();
+
+    if (core.isReplaying()) {
         core.triggerReplay();
         return;
     }
 
+    if (main.core.isPlaying() && (core.status.event||{}).id=='paint') {
+        core.actions.setPaintMode('paint');
+        return;
+    }
+
     if (main.core.isPlaying())
         main.core.openBook(true);
 }
 
-////// 点击状态栏中的楼层传送器时 //////
-main.statusBar.image.fly.onclick = function () {
+////// 点击状态栏中的楼层传送器/装备栏时 //////
+main.statusBar.image.fly.onclick = function (e) {
+    e.stopPropagation();
 
-    if (core.isset(core.status.replay) && core.status.replay.replaying) {
+    // 播放录像时
+    if (core.isReplaying()) {
         core.stopReplay();
         return;
     }
 
-    if (main.core.isPlaying())
-        main.core.useFly(true);
+    // 绘图模式
+    if (main.core.isPlaying() && (core.status.event||{}).id=='paint') {
+        core.actions.setPaintMode('erase');
+        return;
+    }
+
+    if (main.core.isPlaying()) {
+        if (!main.core.flags.equipboxButton) {
+            main.core.useFly(true);
+        }
+        else {
+            main.core.openEquipbox(true)
+        }
+    }
 }
 
 ////// 点击状态栏中的工具箱时 //////
-main.statusBar.image.toolbox.onclick = function () {
+main.statusBar.image.toolbox.onclick = function (e) {
+    e.stopPropagation();
 
-    if (core.isset(core.status.replay) && core.status.replay.replaying) {
+    if (core.isReplaying()) {
         core.rewindReplay();
         return;
     }
 
-    if (main.core.isPlaying())
-        main.core.openToolbox(true);
+    if (main.core.isPlaying() && (core.status.event||{}).id=='paint') {
+        core.actions.clearPaint();
+        return;
+    }
+
+    if (main.core.isPlaying()) {
+        main.core.openToolbox(core.status.event.id != 'equipbox');
+    }
 }
 
-////// 点击状态栏中的快捷商店时 //////
-main.statusBar.image.shop.onclick = function () {
+////// 双击状态栏中的工具箱时 //////
+main.statusBar.image.toolbox.ondblclick = function (e) {
+    e.stopPropagation();
 
-    if (core.isset(core.status.replay) && core.status.replay.replaying) {
+    if (core.isReplaying()) {
+        return;
+    }
+
+    if (main.core.isPlaying())
+        main.core.openEquipbox(true);
+
+}
+
+////// 点击状态栏中的虚拟键盘时 //////
+main.statusBar.image.keyboard.onclick = function (e) {
+    e.stopPropagation();
+
+    if (core.isReplaying()) {
         core.bookReplay();
         return;
     }
 
+    if (main.core.isPlaying())
+        main.core.openKeyBoard(true);
+}
+
+////// 点击状态栏中的快捷商店键盘时 //////
+main.statusBar.image.shop.onclick = function (e) {
+    e.stopPropagation();
+
+    if (core.isReplaying()) {
+        core.viewMapReplay();
+        return;
+    }
+
     if (main.core.isPlaying())
         main.core.openQuickShop(true);
 }
 
-////// 点击状态栏中的存档按钮时 //////
-main.statusBar.image.save.onclick = function () {
+////// 点击金币时也可以开启虚拟键盘 //////
+main.statusBar.image.money.onclick = function (e) {
+    e.stopPropagation();
 
-    if (core.isset(core.status.replay) && core.status.replay.replaying) {
+    if (main.core.isPlaying())
+        main.core.openQuickShop(true);
+}
+
+////// 点击状态栏中的存档按钮时 //////
+main.statusBar.image.save.onclick = function (e) {
+    e.stopPropagation();
+
+    if (core.isReplaying()) {
         core.speedDownReplay();
         return;
     }
 
+    if (main.core.isPlaying() && (core.status.event||{}).id=='paint') {
+        core.actions.savePaint();
+        return;
+    }
+
     if (main.core.isPlaying())
         main.core.save(true);
 }
 
 ////// 点击状态栏中的读档按钮时 //////
-main.statusBar.image.load.onclick = function () {
+main.statusBar.image.load.onclick = function (e) {
+    e.stopPropagation();
 
-    if (core.isset(core.status.replay) && core.status.replay.replaying) {
+    if (core.isReplaying()) {
         core.speedUpReplay();
         return;
     }
 
+    if (main.core.isPlaying() && (core.status.event||{}).id=='paint') {
+        core.actions.loadPaint();
+        return;
+    }
+
     if (main.core.isPlaying())
         main.core.load(true);
 }
 
 ////// 点击状态栏中的系统菜单时 //////
-main.statusBar.image.settings.onclick = function () {
+main.statusBar.image.settings.onclick = function (e) {
+    e.stopPropagation();
 
-    if (core.isset(core.status.replay) && core.status.replay.replaying) {
+    if (core.isReplaying()) {
         core.saveReplay();
         return;
     }
 
+    if (main.core.isPlaying() && (core.status.event||{}).id=='paint') {
+        core.actions.exitPaint();
+        return;
+    }
+
     if (main.core.isPlaying())
         main.core.openSettings(true);
 }
 
+////// 点击工具栏时 //////
+main.dom.toolBar.onclick = function () {
+    if (core.isReplaying())
+        return;
+    main.core.control.setToolbarButton(!core.domStyle.toolbarBtn);
+}
+
+////// 手机端的按钮1-7 //////
+main.statusBar.image.btn1.onclick = function (e) {
+    e.stopPropagation();
+    main.core.onkeyUp({"keyCode": 49});
+};
+
+main.statusBar.image.btn2.onclick = function (e) {
+    e.stopPropagation();
+    main.core.onkeyUp({"keyCode": 50});
+};
+
+main.statusBar.image.btn3.onclick = function (e) {
+    e.stopPropagation();
+    main.core.onkeyUp({"keyCode": 51});
+};
+
+main.statusBar.image.btn4.onclick = function (e) {
+    e.stopPropagation();
+    main.core.onkeyUp({"keyCode": 52});
+};
+
+main.statusBar.image.btn5.onclick = function (e) {
+    e.stopPropagation();
+    main.core.onkeyUp({"keyCode": 53});
+};
+
+main.statusBar.image.btn6.onclick = function (e) {
+    e.stopPropagation();
+    main.core.onkeyUp({"keyCode": 54});
+};
+
+main.statusBar.image.btn7.onclick = function (e) {
+    e.stopPropagation();
+    main.core.onkeyUp({"keyCode": 55});
+};
+
+main.statusBar.image.btn8.onclick = function (e) {
+    e.stopPropagation();
+    main.core.onkeyUp({"keyCode": 56});
+};
+
 ////// 点击“开始游戏”时 //////
 main.dom.playGame.onclick = function () {
     main.dom.startButtons.style.display='none';
-
-    if (main.core.isset(main.core.musicStatus) && main.core.musicStatus.startDirectly
-        && main.core.musicStatus.bgmStatus) {
-        if (main.core.musicStatus.playingBgm==null
-            || core.material.bgms[main.core.musicStatus.playingBgm].paused) {
-            main.core.musicStatus.playingBgm=null;
-            main.core.playBgm(main.core.bgms[0]);
-        }
-    }
+    main.core.control.checkBgm();
 
     if (main.core.isset(main.core.flags.startDirectly) && main.core.flags.startDirectly) {
         core.events.startGame("");
@@ -482,59 +654,57 @@ main.dom.playGame.onclick = function () {
 
 ////// 点击“载入游戏”时 //////
 main.dom.loadGame.onclick = function() {
-
-    if (main.core.isset(main.core.musicStatus) && main.core.musicStatus.startDirectly
-        && main.core.musicStatus.bgmStatus) {
-        if (main.core.musicStatus.playingBgm==null
-            || core.material.bgms[main.core.musicStatus.playingBgm].paused) {
-            main.core.musicStatus.playingBgm=null;
-            main.core.playBgm(main.core.bgms[0]);
-        }
-    }
-
+    main.core.control.checkBgm();
     main.core.load();
 }
 
 ////// 点击“录像回放”时 //////
 main.dom.replayGame.onclick = function () {
-
-    if (main.core.isset(main.core.musicStatus) && main.core.musicStatus.startDirectly
-        && main.core.musicStatus.bgmStatus) {
-        if (main.core.musicStatus.playingBgm==null
-            || core.material.bgms[main.core.musicStatus.playingBgm].paused) {
-            main.core.musicStatus.playingBgm=null;
-            main.core.playBgm(main.core.bgms[0]);
-        }
-    }
-
-    core.readFile(function (obj) {
-        if (obj.name!=core.firstData.name) {
-            alert("存档和游戏不一致！");
-            return;
-        }
-        if (core.isset(obj.version) && obj.version!=core.firstData.version) {
-            // alert("游戏版本不一致！");
-            if (!confirm("游戏版本不一致！\n你仍然想播放录像吗？"))
-                return;
-        }
-        if (!core.isset(obj.route) || !core.isset(obj.hard)) {
-            alert("无效的录像！");
-            return;
-        }
-
-        core.dom.startPanel.style.display = 'none';
-        core.resetStatus(core.firstData.hero, obj.hard, core.firstData.floorId, null, core.initStatus.maps);
-        core.setFlag('seed', obj.seed);
-        core.setFlag('rand', obj.seed);
-        core.events.setInitData(obj.hard);
-        core.changeFloor(core.status.floorId, null, core.firstData.hero.loc, null, function() {
-            core.startReplay(core.decodeRoute(obj.route));
-        }, true);
-    }, function () {
-
-    })
+    main.core.control.checkBgm();
+    main.core.chooseReplayFile();
 }
 
+main.dom.musicBtn.onclick = function () {
+    try {
+        if (main.core)
+            main.core.triggerBgm();
+    } catch (e) {main.log(e);}
+}
+
+window.onblur = function () {
+    if (main.core && main.core.control) {
+        try {
+            main.core.control.checkAutosave();
+        } catch (e) {}
+    }
+}
+
+main.dom.inputYes.onclick = function () {
+    main.dom.inputDiv.style.display = 'none';
+    var func = core.platform.successCallback;
+    core.platform.successCallback = core.platform.errorCallback = null;
+    if (func) func(main.dom.inputBox.value);
+}
+
+main.dom.inputNo.onclick = function () {
+    main.dom.inputDiv.style.display = 'none';
+    var func = core.platform.errorCallback;
+    core.platform.successCallback = core.platform.errorCallback = null;
+    if (func) func(null);
+}
+
+main.dom.inputDiv.onkeyup = function (e) {
+    if (e.keyCode == 13) {
+        setTimeout(function () {
+            main.dom.inputYes.click();
+        }, 50);
+    }
+    else if (e.keyCode == 27) {
+        setTimeout(function () {
+            main.dom.inputNo.click();
+        }, 50);
+    }
+}
 
 }//listen end
 
diff --git a/project/data.js b/project/data.js
index e8af415f..aa989629 100644
--- a/project/data.js
+++ b/project/data.js
@@ -1,172 +1,422 @@
-data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d = 
-{
-	"main" : {
-		"floorIds" : [ 
-			"sample0", "sample1", "sample2", "sample3", "MT0"
-		],
-		"images" : [
-			"bg.jpg"
-		],
-		"animates" : [ 
-			"hand", "sword", "zone"
-		],
-		"bgms" : [ 
-			'bgm.mp3'
-		],
-		"sounds" : [ 
-			'floor.mp3', 'attack.mp3', 'door.mp3', 'item.mp3', 'zone.mp3', 'jump.mp3'
-		],
-		"startBackground" : "bg.jpg",
-		"startLogoStyle" : "color: black",
-		"levelChoose" : [["简单","Easy"],["普通","Normal"],["困难","Hard"],["噩梦","Hell"]],
-		"statusLeftBackground": "url(project/images/ground.png) repeat",
-		"statusTopBackground": "url(project/images/ground.png) repeat",
-		"toolsBackground": "url(project/images/ground.png) repeat",
-		"borderColor": "white"
-	},
-	"firstData" : {
-		"title": "魔塔样板",
-		"name": "template",
-		"version": "Ver 2.3.3",
-		"floorId": "sample0",
-		"hero": { 
-			"name": "阳光",
-			'lv': 1,
-			"hpmax": 9999,
-			"hp": 1000,
-			"atk": 100,
-			"def": 100,
-			"mdef": 100,
-			"money": 100,
-			"experience": 0,
-			"items": { 
-				"keys": {
-					"yellowKey": 0,
-					"blueKey": 0,
-					"redKey": 0
-				},
-				"constants": {},
-				"tools": {}
-			},
-			"flyRange": [],
-			"loc": {"direction": "up", "x": 6, "y": 10},
-			"flags": {},
-			"steps": 0,
-		},
-		"startText": [ 
-			"Hi，欢迎来到 HTML5 魔塔样板！\n\n本样板由艾之葵制作，可以让你在不会写任何代码\n的情况下也能做出属于自己的H5魔塔！",
-			"这里游戏开始时的剧情。\n定义在data.js的startText处。\n\n你可以在这里写上自己的内容。",
-			"赶快来试一试吧！"
-		],
-		"shops": [
-			{
-				"id": "moneyShop1",
-				"name": "贪婪之神",
-				"icon": "blueShop",
-				"textInList": "1F金币商店",
-				"use": "money",
-				"need": "20+10*times*(times+1)",
-				"text": "勇敢的武士啊，给我${need}金币就可以：",
-				"choices": [
-					{"text": "生命+800", "effect": "status:hp+=800"},
-					{"text": "攻击+4", "effect": "status:atk+=4"},
-					{"text": "防御+4", "effect": "status:def+=4"},
-					{"text": "魔防+10", "effect": "status:mdef+=10"}
-				]
-			},
-			{
-				"id": "expShop1",
-				"name": "经验之神",
-				"icon": "pinkShop",
-				"textInList": "1F经验商店",
-				"use": "experience",
-				"need": "-1",
-				"text": "勇敢的武士啊，给我若干经验就可以：",
-				"choices": [
-					{"text": "等级+1", "need": "100", "effect": "status:lv+=1;status:hp+=1000;status:atk+=7;status:def+=7"},
-					{"text": "攻击+5", "need": "30", "effect": "status:atk+=5"},
-					{"text": "防御+5", "need": "30", "effect": "status:def+=5"},
-				]
-			}
-		],
-		"levelUp": [ 
-		    {},
-		    {"need": 20, "name": "第二级", "effect": "status:hp+=2*(status:atk+status:def);status:atk+=10;status:def+=10"},
-		    {"need": 40, "effect": function () {
-			core.insertAction("恭喜升级！");
-			core.status.hero.hp *= 2;
-			core.status.hero.atk += 100;
-			core.status.hero.def += 100;
-		}},
-		]
-	},
-	
-	"values" : {
-		"lavaDamage": 100,
-		"poisonDamage": 10,
-		"weakValue": 20,
-		"redJewel": 3,
-		"blueJewel": 3,
-		"greenJewel": 5,
-		"redPotion": 100,
-		"bluePotion": 250,
-		"yellowPotion": 500,
-		"greenPotion": 800,
-		"sword0": 0,
-		"shield0": 0,
-		"sword1": 10,
-		"shield1": 10,
-		"sword2": 20,
-		"shield2": 20,
-		"sword3": 40,
-		"shield3": 40,
-		"sword4": 80,
-		"shield4": 80,
-		"sword5": 160,
-		"shield5": 160,
-		"moneyPocket": 500,
-		'breakArmor': 0.9,
-		'counterAttack': 0.1,
-		'purify': 3,
-		'hatred': 2,
-		'maxValidHp': null,
-		'animateSpeed': 300,
-	},
-	
-	"flags" : {
-		"enableFloor": true,
-		"enableLv": false,
-		"enableHPMax": false,
-		"enableMDef": true,
-		"enableMoney": true,
-		"enableExperience": false,
-		"enableLevelUp": false,
-		"enableKeys": true,
-		"enablePZF": false,
-		"enableDebuff": false,
-		"flyNearStair": true,
-		"pickaxeFourDirections": false,
-		"bombFourDirections": false,
-		"snowFourDirections": false,
-		"bigKeyIsBox": false,
-		"equipment": false,
-		"enableAddPoint": false,
-		"enableNegativeDamage": false,
-		"hatredDecrease": true,
-		"betweenAttackCeil": false,
-		"useLoop": false,
-		"startDirectly": false,
-		"canOpenBattleAnimate": true,
-		"showBattleAnimateConfirm": false,
-		"battleAnimate": false,
-		"displayEnemyDamage": true,
-		"displayCritical": true,
-		"displayExtraDamage": true,
-		"enableGentleClick": true,
-		"potionWhileRouting": false,
-		"enableViewMaps": true,
-		"portalWithoutTrigger": true,
-		"canGoDeadZone": false,
-		"enableMoveDirectly": true,
-	}
+var data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d = 
+{
+	"main": {
+		"floorIds": [
+			"sample0",
+			"sample1",
+			"sample2",
+			"sample3",
+			"MT0"
+		],
+		"images": [
+			"bg.jpg",
+			"winskin.png"
+		],
+		"tilesets": [
+			"magictower.png"
+		],
+		"animates": [
+			"hand",
+			"sword",
+			"zone"
+		],
+		"bgms": [
+			"bgm.mp3"
+		],
+		"sounds": [
+			"floor.mp3",
+			"attack.mp3",
+			"door.mp3",
+			"item.mp3",
+			"equip.mp3",
+			"zone.mp3",
+			"jump.mp3",
+			"pickaxe.mp3",
+			"bomb.mp3",
+			"centerFly.mp3"
+		],
+		"nameMap": {
+			"背景图.jpg": "bg.jpg",
+			"背景音乐.mp3": "bgm.mp3"
+		},
+		"startBackground": "bg.jpg",
+		"startLogoStyle": "color: black",
+		"levelChoose": [
+			[
+				"简单",
+				"Easy"
+			],
+			[
+				"普通",
+				"Normal"
+			],
+			[
+				"困难",
+				"Hard"
+			],
+			[
+				"噩梦",
+				"Hell"
+			]
+		],
+		"equipName": [
+			"武器",
+			"盾牌"
+		],
+		"startBgm": "bgm.mp3",
+		"statusLeftBackground": "url(project/images/ground.png) repeat",
+		"statusTopBackground": "url(project/images/ground.png) repeat",
+		"toolsBackground": "url(project/images/ground.png) repeat",
+		"borderColor": "#CCCCCC",
+		"statusBarColor": "white",
+		"hardLabelColor": "red",
+		"floorChangingBackground": "black",
+		"floorChangingTextColor": "white",
+		"font": "Verdana"
+	},
+	"firstData": {
+		"title": "魔塔样板",
+		"name": "template",
+		"version": "Ver 2.6.1",
+		"floorId": "sample0",
+		"hero": {
+			"name": "阳光",
+			"lv": 1,
+			"hpmax": 9999,
+			"hp": 1000,
+			"manamax": -1,
+			"mana": 0,
+			"atk": 100,
+			"def": 100,
+			"mdef": 0,
+			"money": 0,
+			"experience": 0,
+			"equipment": [],
+			"items": {
+				"keys": {
+					"yellowKey": 0,
+					"blueKey": 0,
+					"redKey": 0
+				},
+				"constants": {},
+				"tools": {},
+				"equips": {}
+			},
+			"loc": {
+				"direction": "up",
+				"x": 6,
+				"y": 10
+			},
+			"flags": {},
+			"steps": 0
+		},
+		"startCanvas": [
+			{
+				"type": "comment",
+				"text": "在这里可以用事件来自定义绘制标题界面的背景图等"
+			},
+			{
+				"type": "comment",
+				"text": "也可以直接切换到其他楼层（比如某个开始剧情楼层）进行操作。"
+			},
+			{
+				"type": "showImage",
+				"code": 1,
+				"image": "bg.jpg",
+				"loc": [
+					0,
+					0
+				],
+				"dw": 100,
+				"dh": 100,
+				"opacity": 1,
+				"time": 0
+			},
+			{
+				"type": "while",
+				"condition": "1",
+				"data": [
+					{
+						"type": "comment",
+						"text": "给用户提供选择项，这里简单的使用了choices事件"
+					},
+					{
+						"type": "comment",
+						"text": "也可以贴按钮图然后使用等待操作来完成"
+					},
+					{
+						"type": "choices",
+						"choices": [
+							{
+								"text": "开始游戏",
+								"action": [
+									{
+										"type": "comment",
+										"text": "检查bgm状态，下同"
+									},
+									{
+										"type": "function",
+										"function": "function(){\ncore.control.checkBgm()\n}"
+									},
+									{
+										"type": "if",
+										"condition": "core.flags.startDirectly",
+										"true": [
+											{
+												"type": "comment",
+												"text": "直接开始游戏，设置初始化数据"
+											},
+											{
+												"type": "function",
+												"function": "function(){\ncore.events.setInitData('')\n}"
+											}
+										],
+										"false": [
+											{
+												"type": "comment",
+												"text": "动态生成难度选择项"
+											},
+											{
+												"type": "function",
+												"function": "function(){\nvar choices = [];\nmain.levelChoose.forEach(function (one) {\n\tchoices.push({\"text\": one[0], \"action\": [\n\t\t{\"type\": \"function\", \"function\": \"function() { core.status.hard = '\"+one[1]+\"'; core.events.setInitData('\"+one[1]+\"'); }\"}\n\t]});\n})\ncore.insertAction({\"type\": \"choices\", \"choices\": choices});\n}"
+											}
+										]
+									},
+									{
+										"type": "hideImage",
+										"code": 1,
+										"time": 0
+									},
+									{
+										"type": "comment",
+										"text": "成功选择难度"
+									},
+									{
+										"type": "break"
+									}
+								]
+							},
+							{
+								"text": "读取存档",
+								"action": [
+									{
+										"type": "function",
+										"function": "function(){\ncore.control.checkBgm()\n}"
+									},
+									{
+										"type": "comment",
+										"text": "简单的使用“呼出读档界面”来处理"
+									},
+									{
+										"type": "callLoad"
+									}
+								]
+							},
+							{
+								"text": "回放录像",
+								"action": [
+									{
+										"type": "function",
+										"function": "function(){\ncore.control.checkBgm()\n}"
+									},
+									{
+										"type": "comment",
+										"text": "这段代码会弹框选择录像文件"
+									},
+									{
+										"type": "if",
+										"condition": "!core.isReplaying()",
+										"true": [
+											{
+												"type": "function",
+												"function": "function(){\ncore.chooseReplayFile()\n}"
+											}
+										],
+										"false": []
+									}
+								]
+							}
+						]
+					}
+				]
+			},
+			{
+				"type": "comment",
+				"text": "接下来会执行startText中的事件"
+			}
+		],
+		"startText": [
+			"Hi，欢迎来到 HTML5 魔塔样板！\n\n本样板由艾之葵制作，可以让你在不会写任何代码\n的情况下也能做出属于自己的H5魔塔！",
+			"这里游戏开始时的剧情。\n定义在data.js的startText处。\n\n你可以在这里写上自己的内容。",
+			"赶快来试一试吧！"
+		],
+		"shops": [
+			{
+				"id": "moneyShop1",
+				"name": "贪婪之神",
+				"icon": "blueShop",
+				"textInList": "1F金币商店",
+				"commonTimes": false,
+				"mustEnable": false,
+				"use": "money",
+				"need": "20+10*times*(times+1)",
+				"text": "勇敢的武士啊，给我${need}金币就可以：",
+				"choices": [
+					{
+						"text": "生命+800",
+						"effect": "status:hp+=800"
+					},
+					{
+						"text": "攻击+4",
+						"effect": "status:atk+=4"
+					},
+					{
+						"text": "防御+4",
+						"effect": "status:def+=4"
+					},
+					{
+						"text": "魔防+10",
+						"effect": "status:mdef+=10"
+					}
+				]
+			},
+			{
+				"id": "expShop1",
+				"name": "经验之神",
+				"icon": "pinkShop",
+				"textInList": "1F经验商店",
+				"commonTimes": false,
+				"mustEnable": false,
+				"use": "experience",
+				"need": "-1",
+				"text": "勇敢的武士啊，给我若干经验就可以：",
+				"choices": [
+					{
+						"text": "等级+1",
+						"need": "100",
+						"effect": "status:lv+=1;status:hp+=1000;status:atk+=7;status:def+=7"
+					},
+					{
+						"text": "攻击+5",
+						"need": "30",
+						"effect": "status:atk+=5"
+					},
+					{
+						"text": "防御+5",
+						"need": "30",
+						"effect": "status:def+=5"
+					}
+				]
+			},
+			{
+				"id": "keyShop1",
+				"textInList": "回收钥匙商店",
+				"mustEnable": false,
+				"commonEvent": "回收钥匙商店"
+			}
+		],
+		"levelUp": [
+			{
+				"need": "0",
+				"title": "",
+				"action": [
+					{
+						"type": "comment",
+						"text": "此处是初始等级，只需填写称号"
+					}
+				]
+			},
+			{
+				"need": "20",
+				"title": "第二级",
+				"action": [
+					{
+						"type": "setValue",
+						"name": "status:atk",
+						"value": "status:atk+10"
+					},
+					{
+						"type": "setValue",
+						"name": "status:def",
+						"value": "status:def+10"
+					}
+				]
+			},
+			{
+				"need": "40",
+				"title": "",
+				"action": [
+					{
+						"type": "tip",
+						"text": "恭喜升级"
+					}
+				]
+			}
+		]
+	},
+	"values": {
+		"lavaDamage": 100,
+		"poisonDamage": 10,
+		"weakValue": 20,
+		"redJewel": 3,
+		"blueJewel": 3,
+		"greenJewel": 5,
+		"redPotion": 100,
+		"bluePotion": 250,
+		"yellowPotion": 500,
+		"greenPotion": 800,
+		"breakArmor": 0.9,
+		"counterAttack": 0.1,
+		"purify": 3,
+		"hatred": 2,
+		"moveSpeed": 100,
+		"animateSpeed": 400,
+		"floorChangeTime": 800
+	},
+	"flags": {
+		"enableFloor": true,
+		"enableName": false,
+		"enableLv": false,
+		"enableHPMax": false,
+		"enableMana": false,
+		"enableMDef": true,
+		"enableMoney": true,
+		"enableExperience": false,
+		"enableLevelUp": false,
+		"levelUpLeftMode": false,
+		"enableKeys": true,
+		"enablePZF": false,
+		"enableDebuff": false,
+		"enableSkill": false,
+		"flyNearStair": true,
+		"pickaxeFourDirections": false,
+		"bombFourDirections": false,
+		"snowFourDirections": false,
+		"bigKeyIsBox": false,
+		"steelDoorWithoutKey": false,
+		"equipment": false,
+		"equipboxButton": false,
+		"iconInEquipbox": false,
+		"enableAddPoint": false,
+		"enableNegativeDamage": false,
+		"hatredDecrease": true,
+		"betweenAttackCeil": false,
+		"betweenAttackMax": false,
+		"useLoop": false,
+		"startUsingCanvas": false,
+		"startDirectly": false,
+		"statusCanvas": false,
+		"statusCanvasRowsOnMobile": 3,
+		"displayEnemyDamage": true,
+		"displayCritical": true,
+		"displayExtraDamage": true,
+		"enableGentleClick": true,
+		"potionWhileRouting": false,
+		"ignoreChangeFloor": true,
+		"canGoDeadZone": false,
+		"enableMoveDirectly": true,
+		"enableDisabledShop": true,
+		"disableShopOnDamage": false,
+		"checkConsole": false
+	}
 }
\ No newline at end of file
diff --git a/project/enemys.js b/project/enemys.js
index dc389a6d..680dc953 100644
--- a/project/enemys.js
+++ b/project/enemys.js
@@ -1,67 +1,67 @@
-enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80 = 
+var enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80 =
 {
-    'greenSlime': {'name': '绿头怪', 'hp': 100, 'atk': 120, 'def': 0, 'money': 1, 'experience': 1, 'point': 0, 'special': [1,5,7,8]},
-    'redSlime': {'name': '红头怪', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': [16,18], 'value': 10},
-    'blackSlime': {'name': '青头怪', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'slimelord': {'name': '怪王', 'hp': 100, 'atk': 120, 'def': 0, 'money': 10, 'experience': 0, 'point': 0, 'special': [1,9]},
-    'bat': {'name': '小蝙蝠', 'hp': 100, 'atk': 120, 'def': 0, 'money': 2, 'experience': 0, 'point': 0, 'special': 1},
-    'bigBat': {'name': '大蝙蝠', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'redBat': {'name': '红蝙蝠', 'hp': 100, 'atk': 120, 'def': 0, 'money': 5, 'experience': 0, 'point': 0, 'special': 4},
-    'vampire': {'name': '冥灵魔王', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'skeleton': {'name': '骷髅人', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'skeletonSoilder': {'name': '骷髅士兵', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'skeletonCaptain': {'name': '骷髅队长', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'ghostSkeleton': {'name': '冥队长', 'hp': 100, 'atk': 120, 'def': 0, 'money': 8, 'experience': 0, 'point': 0, 'special': 7},
-    'zombie': {'name': '兽人', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'zombieKnight': {'name': '兽人武士', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'rock': {'name': '石头人', 'hp': 100, 'atk': 120, 'def': 0, 'money': 4, 'experience': 0, 'point': 0, 'special': 3},
-    'slimeMan': {'name': '影子战士', 'hp': 100, 'atk': 0, 'def': 0, 'money': 11, 'experience': 0, 'point': 0, 'special': [10,21], 'atkValue': 2, 'defValue': 3}, // 退化怪可以在后面写atkValue和defValue表示退化的数值
-    'bluePriest': {'name': '初级法师', 'hp': 100, 'atk': 120, 'def': 0, 'money': 3, 'experience': 0, 'point': 1, 'special': 2},
-    'redPriest': {'name': '高级法师', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'brownWizard': {'name': '初级巫师', 'hp': 100, 'atk': 120, 'def': 0, 'money': 16, 'experience': 0, 'point': 0, 'special': 15, 'value': 100, 'range': 2}, // 领域怪需要加value表示领域伤害的数值；range可选，代表领域伤害的范围；不加默认为1
-    'redWizard': {'name': '高级巫师', 'hp': 1000, 'atk': 1200, 'def': 0, 'money': 160, 'experience': 0, 'point': 0, 'special': 15, 'value': 200, 'zoneSquare': true}, // zoneSquare可选，代表是否九宫格伤害，true为是九宫格伤害，false或不设置为十字伤害
-    'yellowGuard': {'name': '初级卫兵', 'hp': 100, 'atk': 120, 'def': 0, 'money': 10, 'experience': 0, 'point': 0, 'special': 0},
-    'blueGuard': {'name': '中级卫兵', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'redGuard': {'name': '高级卫兵', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'swordsman': {'name': '双手剑士', 'hp': 100, 'atk': 120, 'def': 0, 'money': 6, 'experience': 0, 'point': 0, 'special': [5,23]},
-    'soldier': {'name': '冥战士', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'yellowKnight': {'name': '金骑士', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'redKnight': {'name': '红骑士', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'darkKnight': {'name': '黑骑士', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'blackKing': {'name': '黑衣魔王', 'hp': 1000, 'atk': 500, 'def': 0, 'money': 1000, 'experience': 1000, 'point': 0, 'special': 0, 'notBomb': true}, // 加入 'notBomb': true 代表该怪物不可被炸弹或圣锤炸掉
-    'yellowKing': {'name': '黄衣魔王', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'greenKing': {'name': '青衣武士', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'blueKnight': {'name': '蓝骑士', 'hp': 100, 'atk': 120, 'def': 0, 'money': 9, 'experience': 0, 'point': 0, 'special': 8},
-    'goldSlime': {'name': '黄头怪', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'poisonSkeleton': {'name': '紫骷髅', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'poisonBat': {'name': '紫蝙蝠', 'hp': 100, 'atk': 120, 'def': 0, 'money': 14, 'experience': 0, 'point': 0, 'special': 13},
-    'steelRock': {'name': '铁面人', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'skeletonPriest': {'name': '骷髅法师', 'hp': 100, 'atk': 100, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 18, 'value': 20},
-    'skeletonKing': {'name': '骷髅王', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'skeletonWizard': {'name': '骷髅巫师', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'redSkeletonCaption': {'name': '骷髅武士', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'badHero': {'name': '迷失勇者', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'demon': {'name': '魔神武士', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'demonPriest': {'name': '魔神法师', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'goldHornSlime': {'name': '金角怪', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'redKing': {'name': '红衣魔王', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'whiteKing': {'name': '白衣武士', 'hp': 100, 'atk': 120, 'def': 0, 'money': 17, 'experience': 0, 'point': 0, 'special': 16},
-    'blackMagician': {'name': '黑暗大法师', 'hp': 100, 'atk': 120, 'def': 0, 'money': 12, 'experience': 0, 'point': 0, 'special': 11, 'value': 1/3, 'add': true, 'notBomb': true}, // 吸血怪需要在后面添加value代表吸血比例；添加add: true可以将吸血的伤害加到自身
-    'silverSlime': {'name': '银头怪', 'hp': 100, 'atk': 120, 'def': 0, 'money': 15, 'experience': 0, 'point': 0, 'special': 14},
-    'swordEmperor': {'name': '剑圣', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'whiteHornSlime': {'name': '尖角怪', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'badPrincess': {'name': '痛苦魔女', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'badFairy': {'name': '黑暗仙子', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'grayPriest': {'name': '中级法师', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'redSwordsman': {'name': '剑王', 'hp': 100, 'atk': 120, 'def': 0, 'money': 7, 'experience': 0, 'point': 0, 'special': 6, 'n': 8}, // 多连击需要在后面指定n代表是几连击
-    'whiteGhost': {'name': '水银战士', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'poisonZombie': {'name': '绿兽人', 'hp': 100, 'atk': 120, 'def': 0, 'money': 13, 'experience': 0, 'point': 0, 'special': 12},
-    'magicDragon': {'name': '魔龙', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'octopus': {'name': '血影', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'darkFairy': {'name': '仙子', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'greenKnight': {'name': '强盾骑士', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'angel': {'name': '天使', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'elemental': {'name': '元素生物', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-    'steelGuard': {'name': '铁守卫', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 18, 'value': 20},
-    'evilBat': {'name': '邪恶蝙蝠', 'hp': 1000, 'atk': 1, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': [2,3]},
+	"greenSlime": {"name":"绿头怪","hp":100,"atk":120,"def":0,"money":1,"experience":1,"point":0,"special":[1,5,7,8]},
+	"redSlime": {"name":"红头怪","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":[16,18],"value":10},
+	"blackSlime": {"name":"青头怪","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"slimelord": {"name":"怪王","hp":100,"atk":120,"def":0,"money":10,"experience":0,"point":0,"special":[1,9]},
+	"bat": {"name":"小蝙蝠","hp":100,"atk":120,"def":0,"money":2,"experience":0,"point":0,"special":1},
+	"bigBat": {"name":"大蝙蝠","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"redBat": {"name":"红蝙蝠","hp":100,"atk":120,"def":0,"money":5,"experience":0,"point":0,"special":4},
+	"vampire": {"name":"冥灵魔王","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"skeleton": {"name":"骷髅人","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"skeletonSoilder": {"name":"骷髅士兵","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"skeletonCaptain": {"name":"骷髅队长","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"ghostSkeleton": {"name":"冥队长","hp":100,"atk":120,"def":0,"money":8,"experience":0,"point":0,"special":7},
+	"zombie": {"name":"兽人","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"zombieKnight": {"name":"兽人武士","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"rock": {"name":"石头人","hp":100,"atk":120,"def":0,"money":4,"experience":0,"point":0,"special":3},
+	"slimeMan": {"name":"影子战士","hp":100,"atk":0,"def":0,"money":11,"experience":0,"point":0,"special":[10,21],"atkValue":2,"defValue":3},
+	"bluePriest": {"name":"初级法师","hp":100,"atk":120,"def":0,"money":3,"experience":0,"point":1,"special":2},
+	"redPriest": {"name":"高级法师","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"brownWizard": {"name":"初级巫师","hp":100,"atk":120,"def":0,"money":16,"experience":0,"point":0,"special":15,"value":100,"range":2},
+	"redWizard": {"name":"高级巫师","hp":1000,"atk":1200,"def":0,"money":160,"experience":0,"point":0,"special":15,"value":200,"zoneSquare":true},
+	"yellowGuard": {"name":"初级卫兵","hp":100,"atk":120,"def":0,"money":10,"experience":0,"point":0,"special":0},
+	"blueGuard": {"name":"中级卫兵","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"redGuard": {"name":"高级卫兵","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"swordsman": {"name":"双手剑士","hp":100,"atk":120,"def":0,"money":6,"experience":0,"point":0,"special":[5,23]},
+	"soldier": {"name":"冥战士","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"yellowKnight": {"name":"金骑士","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"redKnight": {"name":"红骑士","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"darkKnight": {"name":"黑骑士","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"blackKing": {"name":"黑衣魔王","hp":1000,"atk":500,"def":0,"money":1000,"experience":1000,"point":0,"special":0,"notBomb":true},
+	"yellowKing": {"name":"黄衣魔王","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"greenKing": {"name":"青衣武士","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"blueKnight": {"name":"蓝骑士","hp":100,"atk":120,"def":0,"money":9,"experience":0,"point":0,"special":8},
+	"goldSlime": {"name":"黄头怪","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"poisonSkeleton": {"name":"紫骷髅","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"poisonBat": {"name":"紫蝙蝠","hp":100,"atk":120,"def":0,"money":14,"experience":0,"point":0,"special":13},
+	"steelRock": {"name":"铁面人","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"skeletonPriest": {"name":"骷髅法师","hp":100,"atk":100,"def":0,"money":0,"experience":0,"point":0,"special":18,"value":20},
+	"skeletonKing": {"name":"骷髅王","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"skeletonWizard": {"name":"骷髅巫师","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"redSkeletonCaption": {"name":"骷髅武士","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"badHero": {"name":"迷失勇者","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"demon": {"name":"魔神武士","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"demonPriest": {"name":"魔神法师","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"goldHornSlime": {"name":"金角怪","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"redKing": {"name":"红衣魔王","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"whiteKing": {"name":"白衣武士","hp":100,"atk":120,"def":0,"money":17,"experience":0,"point":0,"special":16},
+	"blackMagician": {"name":"黑暗大法师","hp":100,"atk":120,"def":0,"money":12,"experience":0,"point":0,"special":11,"value":0.3333333333333333,"add":true,"notBomb":true},
+	"silverSlime": {"name":"银头怪","hp":100,"atk":120,"def":0,"money":15,"experience":0,"point":0,"special":14},
+	"swordEmperor": {"name":"剑圣","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"whiteHornSlime": {"name":"尖角怪","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"badPrincess": {"name":"痛苦魔女","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"badFairy": {"name":"黑暗仙子","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"grayPriest": {"name":"中级法师","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"redSwordsman": {"name":"剑王","hp":100,"atk":120,"def":0,"money":7,"experience":0,"point":0,"special":6,"n":8},
+	"whiteGhost": {"name":"水银战士","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"poisonZombie": {"name":"绿兽人","hp":100,"atk":120,"def":0,"money":13,"experience":0,"point":0,"special":12},
+	"magicDragon": {"name":"魔龙","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"octopus": {"name":"血影","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"darkFairy": {"name":"仙子","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"greenKnight": {"name":"强盾骑士","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"angel": {"name":"天使","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"elemental": {"name":"元素生物","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":0},
+	"steelGuard": {"name":"铁守卫","hp":0,"atk":0,"def":0,"money":0,"experience":0,"point":0,"special":18,"value":20},
+	"evilBat": {"name":"邪恶蝙蝠","hp":1000,"atk":1,"def":0,"money":0,"experience":0,"point":0,"special":[2,3]}
 }
\ No newline at end of file
diff --git a/project/events.js b/project/events.js
new file mode 100644
index 00000000..d8559846
--- /dev/null
+++ b/project/events.js
@@ -0,0 +1,336 @@
+var events_c12a15a8_c380_4b28_8144_256cba95f760 = 
+{
+	"commonEvent": {
+		"加点事件": [
+			{
+				"type": "comment",
+				"text": "通过传参，flag:arg1表示当前应该的加点数值"
+			},
+			{
+				"type": "choices",
+				"choices": [
+					{
+						"text": "攻击+${1*flag:arg1}",
+						"action": [
+							{
+								"type": "setValue",
+								"name": "status:atk",
+								"value": "status:atk+1*flag:arg1"
+							}
+						]
+					},
+					{
+						"text": "防御+${2*flag:arg1}",
+						"action": [
+							{
+								"type": "setValue",
+								"name": "status:def",
+								"value": "status:def+2*flag:arg1"
+							}
+						]
+					},
+					{
+						"text": "生命+${200*flag:arg1}",
+						"action": [
+							{
+								"type": "setValue",
+								"name": "status:hp",
+								"value": "status:hp+200*flag:arg1"
+							}
+						]
+					}
+				]
+			}
+		],
+		"毒衰咒处理": [
+			{
+				"type": "comment",
+				"text": "获得毒衰咒效果，flag:arg1为要获得的类型"
+			},
+			{
+				"type": "switch",
+				"condition": "flag:arg1",
+				"caseList": [
+					{
+						"case": "0",
+						"action": [
+							{
+								"type": "comment",
+								"text": "获得毒效果"
+							},
+							{
+								"type": "if",
+								"condition": "!flag:poison",
+								"true": [
+									{
+										"type": "setValue",
+										"name": "flag:poison",
+										"value": "true"
+									}
+								],
+								"false": []
+							}
+						]
+					},
+					{
+						"case": "1",
+						"action": [
+							{
+								"type": "comment",
+								"text": "获得衰效果"
+							},
+							{
+								"type": "if",
+								"condition": "!flag:weak",
+								"true": [
+									{
+										"type": "setValue",
+										"name": "flag:weak",
+										"value": "true"
+									},
+									{
+										"type": "if",
+										"condition": "core.values.weakValue>=1",
+										"true": [
+											{
+												"type": "comment",
+												"text": ">=1：直接扣数值"
+											},
+											{
+												"type": "addValue",
+												"name": "status:atk",
+												"value": "-core.values.weakValue"
+											},
+											{
+												"type": "addValue",
+												"name": "status:def",
+												"value": "-core.values.weakValue"
+											}
+										],
+										"false": [
+											{
+												"type": "comment",
+												"text": "<1：扣比例"
+											},
+											{
+												"type": "function",
+												"function": "function(){\ncore.addBuff('atk', -core.values.weakValue);\n}"
+											},
+											{
+												"type": "function",
+												"function": "function(){\ncore.addBuff('def', -core.values.weakValue);\n}"
+											}
+										]
+									}
+								],
+								"false": []
+							}
+						]
+					},
+					{
+						"case": "2",
+						"action": [
+							{
+								"type": "comment",
+								"text": "获得咒效果"
+							},
+							{
+								"type": "if",
+								"condition": "!flag:curse",
+								"true": [
+									{
+										"type": "setValue",
+										"name": "flag:curse",
+										"value": "true"
+									}
+								],
+								"false": []
+							}
+						]
+					}
+				]
+			}
+		],
+		"滑冰事件": [
+			{
+				"type": "comment",
+				"text": "公共事件：滑冰事件"
+			},
+			{
+				"type": "if",
+				"condition": "core.canMoveHero()",
+				"true": [
+					{
+						"type": "comment",
+						"text": "检测下一个点是否可通行"
+					},
+					{
+						"type": "setValue",
+						"name": "flag:nx",
+						"value": "core.nextX()"
+					},
+					{
+						"type": "setValue",
+						"name": "flag:ny",
+						"value": "core.nextY()"
+					},
+					{
+						"type": "if",
+						"condition": "core.noPass(flag:nx, flag:ny)",
+						"true": [
+							{
+								"type": "comment",
+								"text": "不可通行，触发下一个点的事件"
+							},
+							{
+								"type": "trigger",
+								"loc": [
+									"flag:nx",
+									"flag:ny"
+								]
+							}
+						],
+						"false": [
+							{
+								"type": "comment",
+								"text": "可通行，先移动到下个点，然后检查阻激夹域，并尝试触发该点事件"
+							},
+							{
+								"type": "moveHero",
+								"time": 80,
+								"steps": [
+									"forward"
+								]
+							},
+							{
+								"type": "function",
+								"function": "function(){\ncore.checkBlock();\n}"
+							},
+							{
+								"type": "comment",
+								"text": "【触发事件】如果该点存在事件则会立刻结束当前事件"
+							},
+							{
+								"type": "trigger",
+								"loc": [
+									"flag:nx",
+									"flag:ny"
+								]
+							},
+							{
+								"type": "comment",
+								"text": "如果该点不存在事件，则继续检测该点是否是滑冰点"
+							},
+							{
+								"type": "if",
+								"condition": "core.getBgNumber() == 167",
+								"true": [
+									{
+										"type": "function",
+										"function": "function(){\ncore.insertAction(\"滑冰事件\",null,null,null,true)\n}"
+									}
+								],
+								"false": []
+							}
+						]
+					}
+				],
+				"false": []
+			}
+		],
+		"回收钥匙商店": [
+			{
+				"type": "comment",
+				"text": "此事件在全局商店中被引用了(全局商店keyShop1)"
+			},
+			{
+				"type": "comment",
+				"text": "解除引用前勿删除此事件"
+			},
+			{
+				"type": "comment",
+				"text": "玩家在快捷列表（V键）中可以使用本公共事件"
+			},
+			{
+				"type": "while",
+				"condition": "1",
+				"data": [
+					{
+						"type": "choices",
+						"text": "\t[商人,woman]你有多余的钥匙想要出售吗？",
+						"choices": [
+							{
+								"text": "黄钥匙（10金币）",
+								"color": [
+									255,
+									255,
+									0,
+									1
+								],
+								"action": [
+									{
+										"type": "if",
+										"condition": "item:yellowKey >= 1",
+										"true": [
+											{
+												"type": "addValue",
+												"name": "item:yellowKey",
+												"value": "-1"
+											},
+											{
+												"type": "addValue",
+												"name": "status:money",
+												"value": "10"
+											}
+										],
+										"false": [
+											"\t[商人,woman]你没有黄钥匙！"
+										]
+									}
+								]
+							},
+							{
+								"text": "蓝钥匙（50金币）",
+								"color": [
+									0,
+									0,
+									255,
+									1
+								],
+								"action": [
+									{
+										"type": "if",
+										"condition": "item:blueKey >= 1",
+										"true": [
+											{
+												"type": "addValue",
+												"name": "item:blueKey",
+												"value": "-1"
+											},
+											{
+												"type": "addValue",
+												"name": "status:money",
+												"value": "50"
+											}
+										],
+										"false": [
+											"\t[商人,woman]你没有蓝钥匙！"
+										]
+									}
+								]
+							},
+							{
+								"text": "离开",
+								"action": [
+									{
+										"type": "exit"
+									}
+								]
+							}
+						]
+					}
+				]
+			}
+		]
+	}
+}
\ No newline at end of file
diff --git a/project/floors/MT0.js b/project/floors/MT0.js
index 0b5151b5..afcc0832 100644
--- a/project/floors/MT0.js
+++ b/project/floors/MT0.js
@@ -1,35 +1,41 @@
 main.floors.MT0=
 {
-    "floorId": "MT0",
-    "title": "主塔 0 层",
-    "name": "0",
-    "canFlyTo": true,
-    "canUseQuickShop": true,
-    "cannotViewMap": false,
-    "defaultGround": "ground",
-    "images": [],
-    "item_ratio": 1,
-    "map": [
-        [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-        [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-        [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-        [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-        [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-        [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-        [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-        [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-        [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-        [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-        [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-        [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-        [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0]
-    ],
-    "firstArrive": [],
-    "events": {},
-    "changeFloor": {},
-    "afterBattle": {},
-    "afterGetItem": {},
-    "afterOpenDoor": {},
-    "cannotMove": {},
-    "upFloor": null,
+"floorId": "MT0",
+"title": "主塔 0 层",
+"name": "0",
+"canFlyTo": true,
+"canUseQuickShop": true,
+"cannotViewMap": false,
+"defaultGround": "ground",
+"images": [],
+"item_ratio": 1,
+"map": [
+    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0]
+],
+"firstArrive": [],
+"parallelDo": "",
+"events": {},
+"changeFloor": {},
+"afterBattle": {},
+"afterGetItem": {},
+"afterOpenDoor": {},
+"cannotMove": {},
+"bgmap": [
+
+],
+"fgmap": [
+
+],
 }
\ No newline at end of file
diff --git a/project/floors/sample0.js b/project/floors/sample0.js
index 78e04a85..8ed705e3 100644
--- a/project/floors/sample0.js
+++ b/project/floors/sample0.js
@@ -1,120 +1,222 @@
-main.floors.sample0 = 
+main.floors.sample0=
 {
-    "floorId": "sample0", // 这里需要改楼层名，请和文件名及下面的floorId保持完全一致
-    // 楼层唯一标识符仅能由字母、数字、下划线组成，且不能由数字开头
-    // 推荐用法：第20层就用MT20，第38层就用MT38，地下6层就用MT_6（用下划线代替负号），隐藏3层用MT3h（h表示隐藏），等等
-    // 楼层唯一标识符，需要和名字完全一致
-    "title": "样板 0 层", // 楼层中文名
-    "name": "0", // 显示在状态栏中的层数
-    "canFlyTo": true, // 该楼能否被楼传器飞到（不能的话在该楼也不允许使用楼传器）
-    "canUseQuickShop": true, // 该层是否允许使用快捷商店
-    "defaultGround": "ground", // 默认地面的图块ID（terrains中）
-    "images": [], // 该层默认显示的所有图片；详细用法请查看文档“自定义素材”中的说明。
-    // "color": [0,0,0,0.3] // 该层的默认画面色调。本项可不写（代表无色调），如果写需要是一个RGBA数组。
-    // "weather": ["snow",5], // 该层的默认天气。本项可忽略表示晴天，如果写则第一项为"rain"或"snow"代表雨雪，第二项为1-10之间的数代表强度。
-    "bgm": "bgm.mp3", // 到达该层后默认播放的BGM。本项可忽略。
-    "item_ratio": 2, // 该层的宝石/血瓶倍率
-    "map": [ // 地图数据，需要是13x13，建议使用地图生成器来生成
-        [0,    0,    220,  0,    0,    20,   87,   3,    65,   64,   44,   43,   42],
-        [0,    246,  0,    246,  0,    20,   0,    3,    58,   59,   60,   61,   41],
-        [219,  0,    0,    0,    219,  20,   0,    3,    57,   26,   62,   63,   40],
-        [20,   20,   125,  20,   20,   20,   0,    3,    53,   54,   55,   56,   39],
-        [216,  247,  263,  235,  248,  6,    0,    3,    49,   50,   51,   52,   38],
-        [6,    6,    125,  6,    6,    6,    0,    1,    45,   46,   47,   48,   37],
-        [224,  254,  212,  262,  204,  5,    0,    1,    31,   32,   34,   33,   36],
-        [201,  261,  217,  264,  207,  5,    0,    1,    27,   28,   29,   30,   35],
-        [5,    5,    125,  5,    5,    5,    0,    1,    21,   22,   23,   24,   25],
-        [0,    0,    237,  0,    0,    0,    45,   1,    1,    1,    121,  1,    1],
-        [4,    4,    133,  4,    4,    4,    0,    0,    0,    0,    0,    85,   124],
-        [87,   11,   12,   13,   14,   4,    4,    2,    2,    2,    122,  2,    2],
-        [88,   89,   90,   91,   92,   93,   94,   2,    81,   82,   83,   84,   86],
+"floorId": "sample0",
+"title": "样板 0 层",
+"name": "0",
+"canFlyTo": true,
+"canUseQuickShop": true,
+"defaultGround": "ground",
+"images": [],
+"bgm": "bgm.mp3",
+"item_ratio": 1,
+"map": [
+    [  0,  0,220,  0,  0, 20, 87,  3, 65, 64, 44, 43, 42],
+    [  0,246,  0,246,  0, 20,  0,  3, 58, 59, 60, 61, 41],
+    [219,  0,  0,  0,219, 20,  0,  3, 57, 26, 62, 63, 40],
+    [ 20, 20,125, 20, 20, 20,  0,  3, 53, 54, 55, 56, 39],
+    [216,247,263,235,248,  6,  0,  3, 49, 50, 51, 52, 38],
+    [  6,  6,125,  6,  6,  6,  0,  1, 45, 46, 47, 48, 37],
+    [224,254,212,262,204,  5,  0,  1, 31, 32, 34, 33, 36],
+    [201,261,217,264,207,  5,  0,  1, 27, 28, 29, 30, 35],
+    [  5,  5,125,  5,  5,  5,  0,  1, 21, 22, 23, 24, 25],
+    [  0,  0,237,  0,  0,  0, 45,  1,  1,  1,121,  1,  1],
+    [  4,  4,133,  4,  4,  4,  0,  0,  0,  0,  0, 85,124],
+    [ 87, 11, 12, 13, 14,  4,  4,  2,  2,  2,122,  2,  2],
+    [ 88, 89, 90, 91, 92, 93, 94,  2, 81, 82, 83, 84, 86]
+],
+"firstArrive": [
+    {
+        "type": "setText",
+        "background": "winskin.png",
+        "time": 0
+    },
+    "\t[样板提示]首次到达某层可以触发 firstArrive 事件，该事件可类似于RMXP中的“自动执行脚本”。\n\n本事件支持一切的事件类型，常常用来触发对话，例如：",
+    "\t[hero]\b[up,hero]我是谁？我从哪来？我又要到哪去？",
+    "\t[仙子,fairy]你问我...？我也不知道啊...",
+    "本层主要对道具、门、怪物等进行介绍，有关事件的各种信息在下一层会有更为详细的说明。"
+],
+"events": {
+    "10,9": [
+        "\t[老人,man]这些是本样板支持的所有的道具。\n\n道具分为四类：items, constants, tools，equips。\nitems 为即捡即用类道具，例如宝石、血瓶、剑盾等。\nconstants 为永久道具，例如怪物手册、楼层传送器、幸运金币等。\ntools 为消耗类道具，例如破墙镐、炸弹、中心对称飞行器等。\nequips 为装备，例如剑盾等。",
+        "\t[老人,man]\b[up]有关道具效果，定义在items.js中。\n目前大多数道具已有默认行为，如有自定义的需求则需在items.js中修改代码。",
+        "\t[老人,man]\b[up]拾取道具结束后可触发 afterGetItem 事件。\n\n有关事件的各种信息在下一层会有更为详细的说明。",
+        {
+            "type": "hide",
+            "time": 500
+        }
     ],
-    "firstArrive": [ // 第一次到该楼层触发的事件
-        "\t[样板提示]首次到达某层可以触发 firstArrive 事件，该事件可类似于RMXP中的“自动执行脚本”。\n\n本事件支持一切的事件类型，常常用来触发对话，例如：",
-        "\t[hero]\b[up,hero]我是谁？我从哪来？我又要到哪去？",
-        "\t[仙子,fairy]你问我...？我也不知道啊...",
-        "本层主要对道具、门、怪物等进行介绍，有关事件的各种信息在下一层会有更为详细的说明。",
+    "10,11": [
+        "\t[老人,woman]这些是门，需要对应的钥匙打开。\n机关门必须使用特殊的开法。",
+        "\t[老人,woman]开门后可触发 afterOpenDoor 事件。\n\n有关事件的各种信息在下一层会有更为详细的说明。",
+        {
+            "type": "hide",
+            "time": 500
+        }
     ],
-    "events": { // 该楼的所有可能事件列表
-        "10,9": [ // 守着道具的老人
-            "\t[老人,man]这些是本样板支持的所有的道具。\n\n道具分为三类：items, constants, tools。\nitems 为即捡即用类道具，例如宝石、血瓶、剑盾等。\nconstants 为永久道具，例如怪物手册、楼层传送器、幸运金币等。\ntools 为消耗类道具，例如破墙镐、炸弹、中心对称飞行器等。\n\n后两类道具在工具栏中可以看到并使用。",
-            "\t[老人,man]\b[up]有关道具效果，定义在items.js中。\n目前大多数道具已有默认行为，如有自定义的需求则需在items.js中修改代码。",
-            "\t[老人,man]constants 和 tools 各最多只允许12种，多了会导致图标溢出。",
-            "\t[老人,man]\b[up]拾取道具结束后可触发 afterGetItem 事件。\n\n有关事件的各种信息在下一层会有更为详细的说明。",
-            {"type": "hide", "time": 500} // 消失
-        ],
-        "10,11": [ // 守着门的老人
-            "\t[老人,woman]这些是门，需要对应的钥匙打开。\n机关门必须使用特殊的开法。",
-            "\t[老人,woman]开门后可触发 afterOpenDoor 事件。\n\n有关事件的各种信息在下一层会有更为详细的说明。",
-            {"type": "hide", "time": 500}
-        ],
-        "2,10": [ // 守着楼梯、传送门、路障的老人
-            "\t[少女,npc0]这些是路障、楼梯、传送门。",
-            "\t[少女,npc0]血网的伤害数值、中毒后每步伤害数值、衰弱时攻防下降的数值，都在 data.js 内定义。\n\n路障同样会尽量被自动寻路绕过。",
-            "\t[少女,npc0]楼梯和传送门需要在changeFloor中定义目标楼层和位置，可参见样板里已有的的写法。",
-            {"type": "hide", "time": 500}
-        ],
-        "2,8": [ // 守着第一批怪物的老人
-            "\t[老人,magician]这些都是各种各样的怪物，所有怪物的数据都在enemys.js中设置。",
-            "\t[老人,magician]这批怪物分别为：普通、先攻、魔攻、坚固、2连击、3连击、4连击、破甲、反击、净化。",
-            "\t[老人,magician]打败怪物后可触发 afterBattle 事件。\n\n有关事件的各种信息在下一层会有更为详细的说明。",
-            {"type": "hide", "time": 500}
-        ],
-        "2,5": [ // 守着第二批怪物的老人
-            "\t[老人,magician]模仿、吸血、中毒、衰弱、诅咒。\n\n请注意吸血怪需要设置value为吸血数值，可参见样板中黑暗大法师的写法。",
-            {"type": "hide", "time": 500}
-        ],
-        "2,3": [ // 守着第三批怪物的老人
-            "\t[老人,magician]领域、夹击。\n请注意领域怪需要设置value为伤害数值，可参见样板中初级巫师的写法。",
-            "\t[老人,magician]夹击和领域同时发生时先计算领域，再夹击。\n自动寻路同样会尽量绕过你设置的这些点。",
-            {"type": "hide", "time": 500}
-        ],
-        "12,10": { // 隐藏的仙子
-            "enable": false, // enable: false代表初始时禁用事件
-            "data": [
-                "\t[仙子,fairy]只有楼上启用事件后，才能看到我并可以和我对话来触发事件。",
-                {"type": "hide", "time": 500}
-            ]
-        },
+    "2,10": [
+        "\t[少女,npc0]这些是路障、楼梯、传送门。",
+        "\t[少女,npc0]血网的伤害数值、中毒后每步伤害数值、衰弱时攻防下降的数值，都在 data.js 内定义。\n\n路障同样会尽量被自动寻路绕过。",
+        "\t[少女,npc0]楼梯和传送门需要在changeFloor中定义目标楼层和位置，可参见样板里已有的的写法。",
+        {
+            "type": "hide",
+            "time": 500
+        }
+    ],
+    "2,8": [
+        "\t[老人,magician]这些都是各种各样的怪物，所有怪物的数据都在enemys.js中设置。",
+        "\t[老人,magician]这批怪物分别为：普通、先攻、魔攻、坚固、2连击、3连击、4连击、破甲、反击、净化。",
+        "\t[老人,magician]打败怪物后可触发 afterBattle 事件。\n\n有关事件的各种信息在下一层会有更为详细的说明。",
+        {
+            "type": "hide",
+            "time": 500
+        }
+    ],
+    "2,5": [
+        "\t[老人,magician]模仿、吸血、中毒、衰弱、诅咒。\n\n请注意吸血怪需要设置value为吸血数值，可参见样板中黑暗大法师的写法。",
+        {
+            "type": "hide",
+            "time": 500
+        }
+    ],
+    "2,3": [
+        "\t[老人,magician]领域、夹击。\n请注意领域怪需要设置value为伤害数值，可参见样板中初级巫师的写法。",
+        "\t[老人,magician]夹击和领域同时发生时先计算领域，再夹击。\n自动寻路同样会尽量绕过你设置的这些点。",
+        {
+            "type": "hide",
+            "time": 500
+        }
+    ],
+    "12,10": {
+        "enable": false,
+        "data": [
+            "\t[仙子,fairy]只有楼上启用事件后，才能看到我并可以和我对话来触发事件。",
+            {
+                "type": "hide",
+                "time": 500
+            }
+        ]
+    }
+},
+"changeFloor": {
+    "6,0": {
+        "floorId": "sample1",
+        "stair": "downFloor"
     },
-    "changeFloor": { // 楼层转换事件；该事件不能和上面的events有冲突（同位置点），否则会被覆盖
-        "6,0": {"floorId": "sample1", "stair": "downFloor"}, // 目标点：sample1层的下楼梯位置
-        "0,11": {"floorId": "sample0", "loc": [0,12]}, // 目标点：sample0层的x=0,y=12位置
-        "0,12": {"floorId": "sample0", "stair": "upFloor"}, // 注意，目标层有多个楼梯的话，写stair可能会导致到达位置不确定。这时候推荐写loc指明目标点位置。
-        "1,12": {"floorId": "sample0", "loc": [1,12]},
-        "2,12": {"floorId": "sample0", "loc": [2,12]},
-        "3,12": {"floorId": "sample0", "loc": [6,1], "direction": "up"}, // 切换楼层后勇士面对上方
-        "4,12": {"floorId": "sample0", "loc": [0,9], "direction": "left", "time": 1000}, // 切换楼层后勇士面对左边，切换动画1000ms
-        "5,12": {"floorId": "sample0", "loc": [6,10], "time": 0, "portalWithoutTrigger": false}, // time=0表示无切换时间
-        "6,12": {"floorId": "sample0", "loc": [10,10], "direction": "left", "time": 1000},
+    "0,11": {
+        "floorId": "sample0",
+        "loc": [
+            0,
+            12
+        ]
     },
-    "afterBattle": { // 战斗后可能触发的事件列表
-        "2,6": ["\t[ghostSkeleton]不可能，你怎么可能打败我！\n（一个打败怪物触发的事件）"],
+    "0,12": {
+        "floorId": "sample0",
+        "stair": "upFloor"
     },
-    "afterGetItem": { // 获得道具后可能触发的事件列表
-        "11,8": ["由于状态栏放不下，绿钥匙和铁门钥匙均视为tools，放入工具栏中。\n碰到绿门和铁门仍然会自动使用开门。"],
-        "8,6": ["由于吸血和夹击等的存在，血瓶默认自动被绕路。\n你可以修改data.js中的系统Flag来设置这一项。"],
-        "8,7": ["如需修改消耗品的效果，请前往 data.js ，找到并修改values内对应的具体数值即可。\n如果有更高级的需求（如每个区域宝石数值变化），详见doc文档内的做法说明。"],
-        "10,7": ["在 data.js 的系统Flag中设置是否启用魔防。\n如果不启用魔防则不会在状态栏显示。"],
-        "9,5": [
-            "每层楼的 canFlyTo 决定了该楼层能否被飞到。\n\n不能被飞到的楼层也无法使用楼层传送器。",
-            "飞行的楼层顺序由 main.js 中 floorIds 加载顺序所决定。\n\n是否必须在楼梯边使用楼传器由 data.js 中的系统Flag所决定。"
+    "1,12": {
+        "floorId": "sample0",
+        "loc": [
+            1,
+            12
+        ]
+    },
+    "2,12": {
+        "floorId": "sample0",
+        "loc": [
+            2,
+            12
+        ]
+    },
+    "3,12": {
+        "floorId": "sample0",
+        "loc": [
+            6,
+            1
         ],
-        "10,5": ["破墙镐是破面前的墙壁还是四个方向的墙壁，由data.js中的系统Flag所决定。"],
-        "8,4": [
-            "炸弹是只能炸面前的怪物还是四个方向的怪物，由data.js中的系统Flag所决定。\n如只能炸前方怪物则和上面的圣锤等价。\n不能被炸的怪物在enemys中可以定义，可参见样板里黑衣魔王和黑暗大法师的写法。",
+        "direction": "up"
+    },
+    "4,12": {
+        "floorId": "sample0",
+        "loc": [
+            0,
+            9
         ],
-        "10,4": ["“上楼”和“下楼”的目标层由 main.js 的 floorIds顺序所决定。"],
-        "9,2": ["该道具默认是大黄门钥匙，如需改为钥匙盒直接修改 data.js 中的系统Flag即可。"],
-        "10,2": ["屠龙匕首目前未被定义，可能需要自行实现功能。\n有关如何实现一个道具功能参见doc文档。"],
+        "direction": "left",
+        "time": 1000
     },
-    "afterOpenDoor": { // 开完门后可能触发的事件列表
-        "11,12": ["你开了一个绿门，触发了一个afterOpenDoor事件"]
+    "5,12": {
+        "floorId": "sample0",
+        "loc": [
+            6,
+            10
+        ],
+        "time": 0,
+        "portalWithoutTrigger": false
     },
-    "cannotMove": { // 每个图块不可通行的方向
-        // 可以在这里定义每个点不能前往哪个方向，例如悬崖边不能跳下去
-        // "x,y": ["up", "left"], // (x,y)点不能往上和左走
+    "6,12": {
+        "floorId": "sample0",
+        "loc": [
+            10,
+            10
+        ],
+        "direction": "left",
+        "time": 1000
+    }
+},
+"afterBattle": {
+    "2,6": [
+        "\t[ghostSkeleton]不可能，你怎么可能打败我！\n（一个打败怪物触发的事件）"
+    ]
+},
+"afterGetItem": {
+    "11,8": [
+        "由于状态栏放不下，绿钥匙和铁门钥匙均视为tools，放入工具栏中。\n碰到绿门和铁门仍然会自动使用开门。"
+    ],
+    "8,6": [
+        "由于吸血和夹击等的存在，血瓶默认自动被绕路。\n你可以修改data.js中的系统Flag来设置这一项。"
+    ],
+    "8,7": [
+        "如需修改消耗品的效果，请前往 data.js ，找到并修改values内对应的具体数值即可。\n如果有更高级的需求（如每个区域宝石数值变化），详见doc文档内的做法说明。"
+    ],
+    "9,5": [
+        "每层楼的 canFlyTo 决定了该楼层能否被飞到。\n\n不能被飞到的楼层也无法使用楼层传送器。",
+        "飞行的楼层顺序由 main.js 中 floorIds 加载顺序所决定。\n\n是否必须在楼梯边使用楼传器由 data.js 中的系统Flag所决定。"
+    ],
+    "10,5": [
+        "破墙镐是破面前的墙壁还是四个方向的墙壁，由data.js中的系统Flag所决定。"
+    ],
+    "8,4": [
+        "炸弹是只能炸面前的怪物还是四个方向的怪物，由data.js中的系统Flag所决定。\n如只能炸前方怪物则和上面的圣锤等价。\n不能被炸的怪物在enemys中可以定义，可参见样板里黑衣魔王和黑暗大法师的写法。"
+    ],
+    "10,4": [
+        "“上楼”和“下楼”的目标层由 main.js 的 floorIds顺序所决定。"
+    ],
+    "9,2": [
+        "该道具默认是大黄门钥匙，如需改为钥匙盒直接修改 data.js 中的系统Flag即可。"
+    ],
+    "10,2": [
+        "屠龙匕首目前未被定义，可能需要自行实现功能。\n有关如何实现一个道具功能参见doc文档。"
+    ],
+    "12,7": [
+        "在 data.js 的系统Flag中设置是否启用装备栏。\n如果不启用则装备会直接增加属性。"
+    ],
+    "12,6": [
+        "在 data.js 的系统Flag中设置是否启用装备栏按钮。\n如果启用则装备栏按钮会替代楼传按钮。"
+    ],
+    "12,5": [
+        "装备的种类由全塔属性中的equipName决定,type的值就是该类型在equipName中的位次，例如默认情况下equiptype为0代表武器，同时只有type为0的装备的animate属性生效"
+    ]
+},
+"afterOpenDoor": {
+    "11,12": [
+        "你开了一个绿门，触发了一个afterOpenDoor事件"
+    ]
+},
+"cannotMove": {},
+"bgmap": [
 
-    },
+],
+"fgmap": [
 
-}
+],
+}
\ No newline at end of file
diff --git a/project/floors/sample1.js b/project/floors/sample1.js
index 87bbb9b2..92b3a0e8 100644
--- a/project/floors/sample1.js
+++ b/project/floors/sample1.js
@@ -1,340 +1,778 @@
-main.floors.sample1 = 
+main.floors.sample1=
 {
-    "floorId": "sample1", // 这里需要改楼层名，请和文件名及下面的floorId保持完全一致
-    // 楼层唯一标识符仅能由字母、数字、下划线组成，且不能由数字开头
-    // 推荐用法：第20层就用MT20，第38层就用MT38，地下6层就用MT_6（用下划线代替负号），隐藏3层用MT3h（h表示隐藏），等等
-    // 楼层唯一标识符，需要和名字完全一致
-    "title": "样板 1 层", // 楼层中文名
-    "name": "1", // 显示在状态栏中的层数
-    "canFlyTo": true, // 该楼能否被楼传器飞到（不能的话在该楼也不允许使用楼传器）
-    "canUseQuickShop": true, // 该层是否允许使用快捷商店
-    "defaultGround": "grass", // 默认地面的图块ID（terrains中）
-    "images": [[0,0,"bg.jpg",false]], // 该层默认显示的所有图片；详细用法请查看文档“自定义素材”中的说明。
-    // "color": [0,0,0,0.3] // 该层的默认画面色调。本项可不写（代表无色调），如果写需要是一个RGBA数组。
-    "weather": ["snow",6], // 该层的默认天气。本项可忽略表示晴天，如果写则第一项为"rain"或"snow"代表雨雪，第二项为1-10之间的数代表强度。
-    // "bgm": "bgm.mp3", // 到达该层后默认播放的BGM。本项可忽略。
-    "item_ratio": 1, // 该层的宝石/血瓶倍率
-    "map": [ // 地图数据，需要是13x13，建议使用地图生成器来生成
-        [  7,131,  8,152,  9,130, 10,152,166,165,132,165,166],
-        [  0,  0,  0,  0,  0,  0,  0,152,165,164,  0,162,165],
-        [152,152,152,152,121,152,152,152,  0,  0,229,  0,  0],
-        [ 43, 33, 44,151,  0,  0,  0,152,165,161,  0,163,165],
-        [ 21, 22, 21,151,  0,  0,  0,152,166,165,  0,165,166],
-        [151,245,151,151,  0, 87,  0,152,152,152, 85,153,153],
-        [  0,246,  0,151,  0,  0,  0,152,152,221,  0,221,153],
-        [246,  0,246,151,  0,  0,  0,121, 85,  0,  0,  0,153],
-        [151,246,151,151,  0,153,153,153,153,153,153,153,153],
-        [  0,  0,  0,  0,  0,  0,  0,164,  0,  0,163,  0,  0],
-        [  1,  1,  1,  1,  0, 20,  0,  0,  0,162,  0,161,  0],
-        [  1,  0,123,  1,  0, 20,124,  0,121,  0,122,  0,126],
-        [  1,  0,  0,  1, 88, 20, 86,  0,  0,  0,  0,  0,  0]
+"floorId": "sample1",
+"title": "样板 1 层",
+"name": "1",
+"canFlyTo": true,
+"canUseQuickShop": true,
+"defaultGround": "grass",
+"images": [
+    [
+        0,
+        0,
+        "bg.jpg",
+        0
+    ]
+],
+"weather": [
+    "snow",
+    6
+],
+"item_ratio": 1,
+"map": [
+    [  7,131,  8,152,  9,130, 10,152,166,165,132,165,166],
+    [  0,  0,  0,  0,  0,  0,  0,152,165,164,  0,162,165],
+    [152,152,152,152,121,152,152,152,  0,  0,229,  0,  0],
+    [ 43, 33, 44,151,  0,  0,  0,152,165,161,  0,163,165],
+    [ 21, 22, 21,151,  0,  0,  0,152,166,165,  0,165,166],
+    [151,245,151,151,  0, 87,  0,152,152,152, 85,153,153],
+    [  0,246,  0,151,  0,  0,  0,152,152,221,  0,221,153],
+    [246,  0,246,151,  0,  0,  0,121, 85,  0,  0,  0,153],
+    [151,246,151,151,  0,153,153,153,153,153,153,153,153],
+    [  0,  0,  0,  0,  0,  0,  0,164,  0,  0,163,  0,  0],
+    [  1,  1,  1,  1,  0, 20,  0,  0,  0,162,  0,161,  0],
+    [  1,  0,123,  1,  0, 20,124,  0,121,  0,122,  0,126],
+    [  1,  0,  0,  1, 88, 20, 86,  0,  0,  0,  0,  0,122]
+],
+"firstArrive": [],
+"events": {
+    "4,10": [
+        "\t[样板提示]本层楼将会对各类事件进行介绍。",
+        "左边是一个仿50层的陷阱做法，上方是商店、快捷商店的使用方法，右上是一个典型的杀怪开门的例子，右下是各类可能的NPC事件。",
+        "本样板目前支持的事件列表大致有：\ntext: 显示一段文字（比如你现在正在看到的）\ntip: 左上角显示提示\nshow: 使一个事件有效（可见、可被交互）\nhide: 使一个事件失效（不可见、不可被交互）\ntrigger: 触发另一个地点的事件\nanimate: 显示动画\nbattle: 强制和某怪物战斗\nopenDoor: 无需钥匙开门（例如机关门、暗墙）",
+        "openShop: 打开一个全局商店\ndisableShop: 禁用一个全局商店\nchangeFloor: 传送勇士到某层某位置\nchangePos: 传送勇士到当层某位置；转向\nshowImage: 显示图片\nsetFg: 更改画面色调\nsetWeather: 更改天气\nmove: 移动事件效果\nmoveHero: 移动勇士效果\nplayBgm: 播放某个背景音乐\npauseBgm: 暂停背景音乐\nresumeBgm: 恢复背景音乐的播放\nplaySound: 播放某个音频",
+        "if: 条件判断\nchoices: 提供选项\nsetValue: 设置勇士属性道具，或某个变量/flag\nupdate: 更新状态栏和地图显伤\nwin: 获得胜利（游戏通关）\nlose: 游戏失败\nsleep: 等待多少毫秒\nexit: 立刻结束当前事件\nrevisit: 立刻结束事件并重新触发\nfunction: 自定义JS脚本\n\n更多支持的事件还在编写中，欢迎您宝贵的意见。",
+        "有关各事件的样例，可参见本层一些NPC的写法。\n所有事件样例本层都有介绍。\n\n一个自定义事件处理完后，需要调用{\"type\": \"hide\"}该事件才不会再次出现。",
+        {
+            "type": "hide"
+        }
     ],
-    "firstArrive": [ // 第一次到该楼层触发的事件
-
+    "1,5": {
+        "enable": false,
+        "data": []
+    },
+    "1,6": {
+        "enable": false,
+        "data": []
+    },
+    "0,7": {
+        "enable": false,
+        "data": []
+    },
+    "2,7": {
+        "enable": false,
+        "data": []
+    },
+    "1,8": {
+        "enable": false,
+        "data": []
+    },
+    "1,7": [
+        {
+            "type": "show",
+            "loc": [
+                1,
+                5
+            ],
+            "time": 1500
+        },
+        {
+            "type": "sleep",
+            "time": 500
+        },
+        "\t[redKing]欢迎来到魔塔，你是第一百位挑战者。\n若你能打败我所有的手下，我就与你一对一的决斗。\n现在你必须接受我的安排。",
+        {
+            "type": "show",
+            "loc": [
+                [
+                    1,
+                    6
+                ],
+                [
+                    0,
+                    7
+                ],
+                [
+                    1,
+                    8
+                ],
+                [
+                    2,
+                    7
+                ]
+            ],
+            "time": 500
+        },
+        "\t[hero]什么？",
+        {
+            "type": "playSound",
+            "name": "attack.mp3"
+        },
+        {
+            "type": "setValue",
+            "name": "status:atk",
+            "value": "status:atk/10"
+        },
+        {
+            "type": "setValue",
+            "name": "status:def",
+            "value": "status:def/10"
+        },
+        {
+            "type": "hide",
+            "loc": [
+                [
+                    1,
+                    6
+                ],
+                [
+                    0,
+                    7
+                ],
+                [
+                    2,
+                    7
+                ],
+                [
+                    1,
+                    8
+                ]
+            ]
+        },
+        {
+            "type": "hide",
+            "loc": [
+                1,
+                5
+            ],
+            "time": 500
+        },
+        {
+            "type": "hide"
+        },
+        {
+            "type": "setCurtain",
+            "color": [
+                0,
+                0,
+                0
+            ],
+            "time": 1250
+        },
+        {
+            "type": "sleep",
+            "time": 700
+        },
+        {
+            "type": "changeFloor",
+            "floorId": "sample1",
+            "loc": [
+                1,
+                11
+            ],
+            "direction": "right",
+            "time": 1000
+        },
+        {
+            "type": "trigger",
+            "loc": [
+                2,
+                11
+            ]
+        }
     ],
-    "events": { // 该楼的所有可能事件列表
-
-        "4,10": [ // 走到中间时的提示
-            "\t[样板提示]本层楼将会对各类事件进行介绍。",
-            "左边是一个仿50层的陷阱做法，上方是商店、快捷商店的使用方法，右上是一个典型的杀怪开门的例子，右下是各类可能的NPC事件。",
-            "本样板目前支持的事件列表大致有：\ntext: 显示一段文字（比如你现在正在看到的）\ntip: 左上角显示提示\nshow: 使一个事件有效（可见、可被交互）\nhide: 使一个事件失效（不可见、不可被交互）\ntrigger: 触发另一个地点的事件\nanimate: 显示动画\nbattle: 强制和某怪物战斗\nopenDoor: 无需钥匙开门（例如机关门、暗墙）",
-            "openShop: 打开一个全局商店\ndisableShop: 禁用一个全局商店\nchangeFloor: 传送勇士到某层某位置\nchangePos: 传送勇士到当层某位置；转向\nshowImage: 显示图片\nsetFg: 更改画面色调\nsetWeather: 更改天气\nmove: 移动事件效果\nmoveHero: 移动勇士效果\nplayBgm: 播放某个背景音乐\npauseBgm: 暂停背景音乐\nresumeBgm: 恢复背景音乐的播放\nplaySound: 播放某个音频",
-            "if: 条件判断\nchoices: 提供选项\nsetValue: 设置勇士属性道具，或某个变量/flag\nupdate: 更新状态栏和地图显伤\nwin: 获得胜利（游戏通关）\nlose: 游戏失败\nsleep: 等待多少毫秒\nexit: 立刻结束当前事件\nrevisit: 立刻结束事件并重新触发\nfunction: 自定义JS脚本\n\n更多支持的事件还在编写中，欢迎您宝贵的意见。",
-            "有关各事件的样例，可参见本层一些NPC的写法。\n所有事件样例本层都有介绍。\n\n一个自定义事件处理完后，需要调用{\"type\": \"hide\"}该事件才不会再次出现。",
-            {"type": "hide"}
-        ],
-
-        /****** 左边仿50F陷阱事件 ******/
-        "1,5": {"enable": false}, // 这几个是白衣武士等怪物，起始时需要隐藏起来
-        "1,6": {"enable": false},
-        "0,7": {"enable": false},
-        "2,7": {"enable": false},
-        "1,8": {"enable": false},
-        "1,7": [ // 走到白衣武士中间，触发陷阱事件
-            {"type": "show", "loc": [1,5], "time": 1500}, // 显示红衣魔王，动画效果1500ms
-            {"type": "sleep", "time": 500}, // 等待500ms
-            "\t[redKing]欢迎来到魔塔，你是第一百位挑战者。\n若你能打败我所有的手下，我就与你一对一的决斗。\n现在你必须接受我的安排。",
-            {"type": "show", "loc": [[1,6],[0,7],[1,8],[2,7]], "time": 500}, // 显示四个白衣武士，每个动画效果500ms
-            "\t[hero]什么？",
-            {"type": "playSound", "name": "attack.mp3"}, // 播放战斗音频
-            {"type": "setValue", "name": "status:atk", "value": "status:atk/10"}, // 勇士的攻防变成原来的十分之一
-            {"type": "setValue", "name": "status:def", "value": "status:def/10"},
-            {"type": "hide", "loc": [[1,6],[0,7],[2,7],[1,8]]}, // 直接隐藏四个白衣武士，没有动画效果
-            {"type": "hide", "loc": [1,5], "time": 500}, // 隐藏红衣魔王，动画500ms
-            {"type": "hide"}, // 隐藏本事件
-            {"type": "setFg", "color": [0,0,0], "time": 1250}, // 渐变为白色
-            {"type": "sleep", "time": 700},
-            {"type": "changeFloor", "floorId": "sample1", "loc": [1,11], "direction": "right", "time": 1000}, // 楼层切换。changeFloor必须指定floorId和loc。
-            // 备注：这里也可以下面的这种写法：
-            // {"type": "changePos", "loc": [1,11]}
-            // 使用这种写法将不会有“楼层切换动画”，而是直接让勇士到达本层的loc位置。
-            {"type": "trigger", "loc": [2,11]} // 立刻直接触发另一个事件（也就是下面的小偷事件）；当前事件会被立刻结束
-        ],
-        "2,11": [ // 小偷事件
-            "\t[杰克,thief]喂！醒醒！快醒醒！",
-            {"type": "setFg", "time": 1500}, // 渐变回来
-            "\t[hero]额，我这是在什么地方？",
-            "\t[杰克,thief]你被魔王抓了起来扔进了监狱，和我关在了一起，但是幸运的是我在昨天刚刚挖好一条越狱的暗道！",
-            {"type": "openDoor", "loc": [3,11]}, // 开门或墙必须指定门/墙的名称，否则不会执行
-            {"type": "sleep", "time": 300}, // 等待300ms
-            "\t[杰克,thief]我先走了，祝你好运！",
-            {"type": "move", "time": 750, "steps": [ // 动画移动效果，time为每步事件（毫秒），steps是个数组指定了移动的方位
-                {"direction": "right", "value": 2}, // 向右移动两步，再向下移动一步，并消失
-                "down" // 如果该方向只移动一步，可以直接这样简写。 这种写法等价于： {"direction":"down","value":1}
-            ]},
-            // 调用move事件后，hide事件也会被自动调用，因此无需再手动调用 {"type":"hide"} 来隐藏本事件了
-            "上面是个move事件，可以对NPC等进行移动。\n详见样板中小偷事件的写法。",
-            "\t[hero]怎么跑的这么快..."
-        ],
-
-        /****** 上方商店事件相关 ******/
-        "4,2": [ // 商店门前的老人
-            "\t[老人,man]本塔的商店有两类，全局商店和非全局商店。\n\n所谓非全局商店，就类似于右下角那个卖钥匙的老人一样，一定要碰到才能触发事件。\n\n而全局商店，则能在快捷商店中直接使用。",
-            "\t[老人,man]要注册一个全局商店，你需要在 data.js 中，找到 shops，并在内添加你的商店信息。",
-            "\t[老人,man]商店信息添加后，可以在需要的事件处调用{\"type\": \"openShop\"}来打开你添加的全局商店。",
-            "\t[老人,man]在上面的例子里，左边是一个仿50层的金币商店，右边是一个仿24层的经验商店。\n\n商店被访问后即可在快捷商店中进行使用。",
-            "\t[老人,man]如果你需要在某层暂时禁用快捷商店，可以在data.js中设置cannotUseQuickShop。\n如果需要永久禁用商店，请使用{\"type\":\"disableShop\"}",
-            {"type": "hide", "time": 500}
-        ],
-        "1,0": [ // 金币商店
-            // 打开商店前，你也可以添加自己的剧情
-            // 例如，通过if来事件来判断是不是第一次访问商店，是的则显示一段文字（类似宿命的华音那样）
-            {"type": "openShop", "id": "moneyShop1"} // 这里的id要和data.js中你定义的商店ID完全一致
-            // 调用openShop事件后，所有当前事件都会被结束（同exit事件），然后打开一个全局商店
-        ],
-        "5,0": [ // 经验商店
-            {"type": "openShop", "id": "expShop1"}
-        ],
-
-
-
-        /****** 右边陷阱、战斗相关 ******/
-        "7,7": [ // 门口老人的提示
-            "\t[老人,man]这是一个典型的杀怪开门、强制战斗事件。",
-            {"type": "hide"} // 不显示动画，直接消失
-        ],
-        "8,7": {"enable": false}, // 门口的机关门，初始时是禁用状态
-        "9,7": [ // 当你刚进去后，触发机关门
-            {"type": "show", "loc": [8,7]}, // 显示机关门
-            {"type": "hide"} // 该事件消失
-        ],
-        // 注意：初级卫兵打死后的开门事件是在 afterBattle 中调用
-        "10,4": [ // 开门后走进去的事件：强制战斗
-            "\t[blackKing]你终于还是来了。",
-            "\t[hero]放开我们的公主！",
-            "\t[blackKing]如果我不愿意呢？",
-            "\t[hero]无需多说，拔剑吧！",
-            {"type": "battle", "id": "blackKing"}, // 强制战斗
-            // 如果战斗失败直接死亡，不会继续触发接下来的剧情。
-            {"type": "hide", "loc": [10,2]}, // 战斗后需要手动使怪物消失；战斗后不会引发afterBattle事件。
-            {"type": "openDoor", "loc": [8,7]}, // 开门口的机关门
-            "\t[blackKing]没想到你已经变得这么强大了... 算你厉害。\n公主就交给你了，请好好对她。",
-            {"type": "hide"} // 隐藏本事件
-        ],
-        "10,0": [ // 公主事件
-            "\t[hero]公主，我来救你了~",
-            "\t[公主,princess]快救我出去！我受够这里了！",
-            "\t[hero]公主别怕，我们走吧~",
-            {"type": "win", "reason": "救出公主"} // 获得胜利。此事件将显示获胜界面，并结束游戏。
-            // 该事件将直接调用events.js中的win()函数；如需修改获胜界面内容可前往修改。
-            // 下面这个是失败事件，同样会直接调用events.js中的lose()函数；如需修改失败界面内容可以前往修改。
-            // {"type": "lose", "reason": "救了假公主"}
-        ],
-
-
-
-        /****** 右下各种NPC事件相关 ******/
-        "6,12": {"enable":false}, // 仙子下面的铁门，初始时是禁用的
-        "6,11": [ // 仙子事件
-            "\t[仙子,fairy]通过调用 {\"type\": \"show\"} 可以使隐藏的事件显示出来。\n比如我下面这个机关门。",
-            {"type": "show", "loc": [6,12]}, // 使隐藏的铁门显示出来
-            "\t[仙子,fairy]通过调用 {\"type\": \"openDoor\"} 可以无需钥匙打开一扇门或暗墙。",
-            {"type": "openDoor", "loc": [6,12]}, // 开门
-            "\t[仙子,fairy]同时，也可以对其它层进行操作，比如楼下的机关门，现在已经为你打开了。",
-            {"type": "openDoor", "loc": [11,10], "floorId": "sample0"}, // 打开其它层的门，需要指定floorId
-            "\t[仙子,fairy]如果 show 或 hide 指定了 time 参数，则以动画效果显示，指定的参数作为消失时间（毫秒）来计算。",
-            "\t[仙子,fairy]现在到楼下来找我吧~",
-            {"type": "show", "loc": [12,10], "floorId": "sample0"}, // 显示其它层的事件，需要指定其floorId
-            {"type": "hide", "time": 500}
-        ],
-        "8,11": [ // 老人事件，勇士状态的显示与变化
-            {"type": "setValue", "name": "flag:man_times", "value": "flag:man_times+1"}, // 设置这个老人的访问次数
-            "\t[老人,man]在文字中使用${' ${ '}和 } 可以计算并显示一个表达式的结果。\n",
-            "\t[老人,man]例如：\n你的当前攻击力是${status:atk}，防御力是${status:def}。\n攻防和的十倍是${10*(status:atk+status:def)}，攻防之积是${status:atk*status:def}。\n你有${item:yellowKey}把黄钥匙，${item:blueKey}把蓝钥匙，${item:redKey}把红钥匙。\n你有${item:pickaxe}个破，${item:bomb}个炸，${item:centerFly}个飞。\n这是你第${flag:man_times}次和我对话。",
-            "\t[老人,man]同时，你也可以通过{\"type\": \"setValue\"}来设置一个勇士的属性、道具，或某个Flag。",
-            "\t[老人,man]例如：\n现在我将让你的攻防提升50%，再将攻防和的十倍加到生命值上。",
-            {"type": "setValue", "name": "status:atk", "value": "status:atk*1.5"}, // 攻击提升50%；注意不要加${}
-            {"type": "setValue", "name": "status:def", "value": "status:def*1.5"}, // 防御提升50%；注意不要加${}
-            {"type": "setValue", "name": "status:hp", "value": "status:hp+10*(status:atk+status:def)"}, //生命提升攻防和的十倍
-            "\t[老人,man]再送你500金币，1000经验，1破2炸3飞！",
-            {"type": "setValue", "name": "status:money", "value": "status:money+500"},
-            {"type": "setValue", "name": "status:experience", "value": "status:experience+1000"},
-            {"type": "setValue", "name": "item:pickaxe", "value": "item:pickaxe+1"}, // 1破
-            {"type": "setValue", "name": "item:bomb", "value": "item:bomb+2"}, // 2炸
-            {"type": "setValue", "name": "item:centerFly", "value": "item:centerFly+3"}, // 3飞
-            "\t[老人,man]status:xxx 代表勇士的某个属性。\n其中xxx可取hp, atk, def, mdef, money,experience这几项。\n\nitem:xxx 代表勇士的某个道具的个数。\nxxx为道具ID，具体可参见items.js中的定义。\n\nflag:xxx 代表某个自定义Flag或变量。\nxxx为Flag/变量名，可以自行定义，由字母、数字和下划线组成。\n未定义过而直接取用的Flag默认值为false。",
-            // 如果老人不消失，则不要调用 {"type": "hide"}
-            "\t[老人,man]你现在可以重新和我进行对话，进一步看到属性值的改变。"
-        ],
-        "10,11": [ // 商人事件，if语句和choices语句的写法
-            // 这部分逻辑相对比较长，细心看，很容易看懂的。
-            {"type": "if", "condition": "flag:woman_times==0", // 条件判断：是否从未访问过此商人。
-                "true": [ // 如果从未访问过该商人，显示一段文字
-                    "\t[老人,woman]这是个很复杂的例子，它将教会你如何使用if 语句进行条件判断，以及 choices 提供选项来供用户进行选择。",
-                    "\t[老人,woman]第一次访问我将显示这段文字；从第二次开始将会向你出售钥匙。\n钥匙价格将随着访问次数递增。\n当合计出售了七把钥匙后，将送你一把大黄门钥匙，并消失不再出现。",
-                    "\t[老人,woman]这部分的逻辑比较长，请细心看样板的写法，是很容易看懂并理解的。"
-                    // 第一次访问结束
-                ],
-                "false": [ // 如果已经访问过该商人
-                    {"type": "if", "condition": "flag:woman_times==8", // 条件判断：是否已经出售七把钥匙
-                        "true": [ // 如果已经出售过七把钥匙，则直接结束
-                            "\t[老人,woman]你购买的钥匙已经够多了，再继续卖给你的话我会有危险的。",
-                            "\t[老人,woman]看在你贡献给我这么多钱的份上，送你一把大黄门钥匙吧，希望你能好好用它。",
-                            {"type": "setValue", "name": "item:bigKey", "value": "item:bigKey+1"}, // 获得一把大黄门钥匙
-                            "\t[老人,woman]我先走了，拜拜~",
-                            {"type":"hide", "time": 500}, // 消失
-                            {"type":"exit"} // 立刻结束当前事件。下面的 setValue 和 revisit 都不会再执行。
-                        ],
-                        "false": [ // 否则，显示选择页面
-                            {"type": "choices", "text": "\t[老人,woman]少年，你需要钥匙吗？\n我这里有大把的！", // 显示一个选择页面
-                                "choices": [ // 提供四个选项：黄钥匙、蓝钥匙、红钥匙、离开。前三个选项显示需要的金额
-                                    {"text": "黄钥匙（${9+flag:woman_times}金币）", "action": [ // 第一个选项，黄钥匙
-                                        // 选择该选项的执行内容
-                                        // 条件判断：钱够不够
-                                        {"type": "if", "condition": "status:money>=9+flag:woman_times",
+    "2,11": [
+        "\t[杰克,thief]喂！醒醒！快醒醒！",
+        {
+            "type": "setCurtain",
+            "time": 1500
+        },
+        "\t[hero]额，我这是在什么地方？",
+        "\t[杰克,thief]你被魔王抓了起来扔进了监狱，和我关在了一起，但是幸运的是我在昨天刚刚挖好一条越狱的暗道！",
+        {
+            "type": "openDoor",
+            "loc": [
+                3,
+                11
+            ]
+        },
+        {
+            "type": "sleep",
+            "time": 300
+        },
+        "\t[杰克,thief]我先走了，祝你好运！",
+        {
+            "type": "move",
+            "time": 750,
+            "steps": [
+                "right",
+                "right",
+                "down"
+            ]
+        },
+        "上面是个move事件，可以对NPC等进行移动。\n详见样板中小偷事件的写法。",
+        "\t[hero]怎么跑的这么快..."
+    ],
+    "4,2": [
+        "\t[老人,man]本塔的商店有两类，全局商店和非全局商店。\n\n所谓非全局商店，就类似于右下角那个卖钥匙的老人一样，一定要碰到才能触发事件。\n\n而全局商店，则能在快捷商店中直接使用。",
+        "\t[老人,man]要注册一个全局商店，你需要在 data.js 中，找到 shops，并在内添加你的商店信息。",
+        "\t[老人,man]商店信息添加后，可以在需要的事件处调用{\"type\": \"openShop\"}来打开你添加的全局商店。",
+        "\t[老人,man]在上面的例子里，左边是一个仿50层的金币商店，右边是一个仿24层的经验商店。\n\n商店被访问后即可在快捷商店中进行使用。",
+        "\t[老人,man]如果你需要在某层暂时禁用快捷商店，可以在data.js中设置cannotUseQuickShop。\n如果需要永久禁用商店，请使用{\"type\":\"disableShop\"}",
+        {
+            "type": "hide",
+            "time": 500
+        }
+    ],
+    "1,0": [
+        {
+            "type": "openShop",
+            "id": "moneyShop1"
+        }
+    ],
+    "5,0": [
+        {
+            "type": "openShop",
+            "id": "expShop1"
+        }
+    ],
+    "7,7": [
+        "\t[老人,man]这是一个典型的杀怪开门、强制战斗事件。",
+        {
+            "type": "hide"
+        }
+    ],
+    "8,7": {
+        "enable": false,
+        "data": []
+    },
+    "9,7": [
+        {
+            "type": "show",
+            "loc": [
+                8,
+                7
+            ]
+        },
+        {
+            "type": "hide"
+        }
+    ],
+    "10,4": [
+        "\t[blackKing]你终于还是来了。",
+        "\t[hero]放开我们的公主！",
+        "\t[blackKing]如果我不愿意呢？",
+        "\t[hero]无需多说，拔剑吧！",
+        {
+            "type": "battle",
+            "id": "blackKing"
+        },
+        {
+            "type": "hide",
+            "loc": [
+                10,
+                2
+            ]
+        },
+        {
+            "type": "openDoor",
+            "loc": [
+                8,
+                7
+            ]
+        },
+        "\t[blackKing]没想到你已经变得这么强大了... 算你厉害。\n公主就交给你了，请好好对她。",
+        {
+            "type": "hide"
+        }
+    ],
+    "10,0": [
+        "\t[hero]公主，我来救你了~",
+        "\t[公主,princess]快救我出去！我受够这里了！",
+        "\t[hero]公主别怕，我们走吧~",
+        {
+            "type": "win",
+            "reason": "救出公主"
+        }
+    ],
+    "6,12": {
+        "enable": false,
+        "data": []
+    },
+    "6,11": [
+        "\t[仙子,fairy]通过调用 {\"type\": \"show\"} 可以使隐藏的事件显示出来。\n比如我下面这个机关门。",
+        {
+            "type": "show",
+            "loc": [
+                6,
+                12
+            ]
+        },
+        "\t[仙子,fairy]通过调用 {\"type\": \"openDoor\"} 可以无需钥匙打开一扇门或暗墙。",
+        {
+            "type": "openDoor",
+            "loc": [
+                6,
+                12
+            ]
+        },
+        "\t[仙子,fairy]同时，也可以对其它层进行操作，比如楼下的机关门，现在已经为你打开了。",
+        {
+            "type": "openDoor",
+            "loc": [
+                11,
+                10
+            ],
+            "floorId": "sample0"
+        },
+        "\t[仙子,fairy]如果 show 或 hide 指定了 time 参数，则以动画效果显示，指定的参数作为消失时间（毫秒）来计算。",
+        "\t[仙子,fairy]现在到楼下来找我吧~",
+        {
+            "type": "show",
+            "loc": [
+                12,
+                10
+            ],
+            "floorId": "sample0"
+        },
+        {
+            "type": "hide",
+            "time": 500
+        }
+    ],
+    "8,11": [
+        {
+            "type": "setValue",
+            "name": "flag:man_times",
+            "value": "flag:man_times+1"
+        },
+        "\t[老人,man]在文字中使用${' ${ '}和 } 可以计算并显示一个表达式的结果。\n",
+        "\t[老人,man]例如：\n你的当前攻击力是${status:atk}，防御力是${status:def}。\n攻防和的十倍是${10*(status:atk+status:def)}，攻防之积是${status:atk*status:def}。\n你有${item:yellowKey}把黄钥匙，${item:blueKey}把蓝钥匙，${item:redKey}把红钥匙。\n你有${item:pickaxe}个破，${item:bomb}个炸，${item:centerFly}个飞。\n这是你第${flag:man_times}次和我对话。",
+        "\t[老人,man]同时，你也可以通过{\"type\": \"setValue\"}来设置一个勇士的属性、道具，或某个Flag。",
+        "\t[老人,man]例如：\n现在我将让你的攻防提升50%，再将攻防和的十倍加到生命值上。",
+        {
+            "type": "setValue",
+            "name": "status:atk",
+            "value": "status:atk*1.5"
+        },
+        {
+            "type": "setValue",
+            "name": "status:def",
+            "value": "status:def*1.5"
+        },
+        {
+            "type": "setValue",
+            "name": "status:hp",
+            "value": "status:hp+10*(status:atk+status:def)"
+        },
+        "\t[老人,man]再送你500金币，1000经验，1破2炸3飞！",
+        {
+            "type": "setValue",
+            "name": "status:money",
+            "value": "status:money+500"
+        },
+        {
+            "type": "setValue",
+            "name": "status:experience",
+            "value": "status:experience+1000"
+        },
+        {
+            "type": "setValue",
+            "name": "item:pickaxe",
+            "value": "item:pickaxe+1"
+        },
+        {
+            "type": "setValue",
+            "name": "item:bomb",
+            "value": "item:bomb+2"
+        },
+        {
+            "type": "setValue",
+            "name": "item:centerFly",
+            "value": "item:centerFly+3"
+        },
+        "\t[老人,man]status:xxx 代表勇士的某个属性。\n其中xxx可取hp, atk, def, mdef, money,experience这几项。\n\nitem:xxx 代表勇士的某个道具的个数。\nxxx为道具ID，具体可参见items.js中的定义。\n\nflag:xxx 代表某个自定义Flag或变量。\nxxx为Flag/变量名，可以自行定义，由字母、数字和下划线组成。\n未定义过而直接取用的Flag默认值为false。",
+        "\t[老人,man]你现在可以重新和我进行对话，进一步看到属性值的改变。"
+    ],
+    "10,11": [
+        {
+            "type": "if",
+            "condition": "flag:woman_times==0",
+            "true": [
+                "\t[老人,woman]这是个很复杂的例子，它将教会你如何使用if 语句进行条件判断，以及 choices 提供选项来供用户进行选择。",
+                "\t[老人,woman]第一次访问我将显示这段文字；从第二次开始将会向你出售钥匙。\n钥匙价格将随着访问次数递增。\n当合计出售了七把钥匙后，将送你一把大黄门钥匙，并消失不再出现。",
+                "\t[老人,woman]这部分的逻辑比较长，请细心看样板的写法，是很容易看懂并理解的。"
+            ],
+            "false": [
+                {
+                    "type": "if",
+                    "condition": "flag:woman_times==8",
+                    "true": [
+                        "\t[老人,woman]你购买的钥匙已经够多了，再继续卖给你的话我会有危险的。",
+                        "\t[老人,woman]看在你贡献给我这么多钱的份上，送你一把大黄门钥匙吧，希望你能好好用它。",
+                        {
+                            "type": "setValue",
+                            "name": "item:bigKey",
+                            "value": "item:bigKey+1"
+                        },
+                        "\t[老人,woman]我先走了，拜拜~",
+                        {
+                            "type": "hide",
+                            "time": 500
+                        },
+                        {
+                            "type": "exit"
+                        }
+                    ],
+                    "false": [
+                        {
+                            "type": "choices",
+                            "text": "\t[老人,woman]少年，你需要钥匙吗？\n我这里有大把的！",
+                            "choices": [
+                                {
+                                    "text": "黄钥匙（${9+flag:woman_times}金币）",
+                                    "action": [
+                                        {
+                                            "type": "if",
+                                            "condition": "status:money>=9+flag:woman_times",
                                             "true": [
-                                                {"type": "setValue", "name": "status:money", "value": "status:money-(9+flag:woman_times)"}, // 扣减金钱
-                                                {"type": "setValue", "name": "item:yellowKey", "value": "item:yellowKey+1"}, // 增加黄钥匙
-                                                // 然后会继续执行下面的setValue来增加商人访问次数
+                                                {
+                                                    "type": "setValue",
+                                                    "name": "status:money",
+                                                    "value": "status:money-(9+flag:woman_times)"
+                                                },
+                                                {
+                                                    "type": "setValue",
+                                                    "name": "item:yellowKey",
+                                                    "value": "item:yellowKey+1"
+                                                }
                                             ],
                                             "false": [
                                                 "\t[老人,woman]你的金钱不足！",
-                                                {"type": "revisit"} // 直接重新访问；不执行下面的setValue来增加访问次数
+                                                {
+                                                    "type": "revisit"
+                                                }
                                             ]
                                         }
-                                    ]},
-                                    {"text": "蓝钥匙（${18+2*flag:woman_times}金币）", "action": [ // 第二个选项：蓝钥匙
-                                        // 逻辑和上面黄钥匙完全相同，不赘述
-                                        {"type": "if", "condition": "status:money>=18+2*flag:woman_times",
+                                    ]
+                                },
+                                {
+                                    "text": "蓝钥匙（${18+2*flag:woman_times}金币）",
+                                    "action": [
+                                        {
+                                            "type": "if",
+                                            "condition": "status:money>=18+2*flag:woman_times",
                                             "true": [
-                                                {"type": "setValue", "name": "status:money", "value": "status:money-(18+2*flag:woman_times)"},
-                                                {"type": "setValue", "name": "item:blueKey", "value": "item:blueKey+1"},
+                                                {
+                                                    "type": "setValue",
+                                                    "name": "status:money",
+                                                    "value": "status:money-(18+2*flag:woman_times)"
+                                                },
+                                                {
+                                                    "type": "setValue",
+                                                    "name": "item:blueKey",
+                                                    "value": "item:blueKey+1"
+                                                }
                                             ],
                                             "false": [
                                                 "\t[老人,woman]你的金钱不足！",
-                                                {"type": "revisit"}
+                                                {
+                                                    "type": "revisit"
+                                                }
                                             ]
                                         }
-                                    ]},
-                                    {"text": "红钥匙（${36+4*flag:woman_times}金币）", "action": [ // 第三个选项：红钥匙
-                                        // 逻辑和上面黄钥匙完全相同，不赘述
-                                        {"type": "if", "condition": "status:money>=36+4*flag:woman_times",
+                                    ]
+                                },
+                                {
+                                    "text": "红钥匙（${36+4*flag:woman_times}金币）",
+                                    "action": [
+                                        {
+                                            "type": "if",
+                                            "condition": "status:money>=36+4*flag:woman_times",
                                             "true": [
-                                                {"type": "setValue", "name": "status:money", "value": "status:money-(36+4*flag:woman_times)"},
-                                                {"type": "setValue", "name": "item:redKey", "value": "item:redKey+1"},
+                                                {
+                                                    "type": "setValue",
+                                                    "name": "status:money",
+                                                    "value": "status:money-(36+4*flag:woman_times)"
+                                                },
+                                                {
+                                                    "type": "setValue",
+                                                    "name": "item:redKey",
+                                                    "value": "item:redKey+1"
+                                                }
                                             ],
                                             "false": [
                                                 "\t[老人,woman]你的金钱不足！",
-                                                {"type": "revisit"}
+                                                {
+                                                    "type": "revisit"
+                                                }
                                             ]
                                         }
-                                    ]},
-                                    {"text": "离开", "action": [ // 第四个选项：离开
-                                        {"type": "exit"} // 立刻结束当前事件
-                                    ]}
-                                ]
-                            }
-                        ]
-                    }
-                ]
-            },
-            {"type": "setValue", "name": "flag:woman_times", "value": "flag:woman_times+1"}, // 增加该商人的访问次数。
-            {"type": "revisit"} // 立即重新开始这个事件
-        ],
-        "12,11": [ // 自定义事件的老人
-            "\t[老人,womanMagician]使用 {\"type\":\"function\"} 可以写自定义的JS脚本。\n本塔支持的所有主要API会在doc文档内给出。",
-            "\t[老人,womanMagician]例如这个例子：即将弹出一个输入窗口，然后会将你的输入结果直接加到你的攻击力上。",
-            /*
-            {"type": "function", "function": function() { // 自己写JS脚本并执行
-
-                // 注意一下prompt对于录像是如何处理的
-                var value;
-                if (core.status.replay.replaying) {
-                    var action = core.status.replay.toReplay.shift();
-                    if (action.indexOf("input:")==0 ) {
-                        value=parseInt(action.substring(6));
-                    }
-                    else {
-                        core.stopReplay();
-                        core.drawTip("录像文件出错");
-                        return;
-                    }
+                                    ]
+                                },
+                                {
+                                    "text": "离开",
+                                    "action": [
+                                        {
+                                            "type": "exit"
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    ]
                 }
-                else {
-                    value = prompt("请输入你要加攻击力的数值：");
+            ]
+        },
+        {
+            "type": "setValue",
+            "name": "flag:woman_times",
+            "value": "flag:woman_times+1"
+        },
+        {
+            "type": "revisit"
+        }
+    ],
+    "12,11": [
+        "\t[老人,womanMagician]使用 {\"type\":\"function\"} 可以写自定义的JS脚本。\n本塔支持的所有主要API会在doc文档内给出。",
+        "\t[老人,womanMagician]例如这个例子：即将弹出一个输入窗口，然后会将你的输入结果直接加到你的攻击力上。",
+        {
+            "type": "input",
+            "text": "请输入你要加攻击力的数值："
+        },
+        {
+            "type": "if",
+            "condition": "flag:input>0",
+            "true": [
+                {
+                    "type": "setValue",
+                    "name": "status:atk",
+                    "value": "status:atk+flag:input"
+                },
+                {
+                    "type": "tip",
+                    "text": "操作成功，攻击+${flag:input}"
+                },
+                "操作成功，攻击+${flag:input}"
+            ],
+            "false": []
+        },
+        "\t[老人,womanMagician]具体可参见样板中本事件的写法。"
+    ],
+    "10,12": null,
+    "12,12": [
+        {
+            "type": "switch",
+            "condition": "flag:woman_times",
+            "caseList": [
+                {
+                    "case": "0",
+                    "action": [
+                        "\t[老人,woman]现在使用switch改写这个例子"
+                    ]
+                },
+                {
+                    "case": "8",
+                    "action": [
+                        "\t[老人,woman]你购买的钥匙已经够多了，再继续卖给你的话我会有危险的。",
+                        "\t[老人,woman]看在你贡献给我这么多钱的份上，送你一把大黄门钥匙吧，希望你能好好用它。",
+                        {
+                            "type": "setValue",
+                            "name": "item:bigKey",
+                            "value": "item:bigKey+1"
+                        },
+                        "\t[老人,woman]我先走了，拜拜~",
+                        {
+                            "type": "hide",
+                            "time": 500
+                        },
+                        {
+                            "type": "exit"
+                        }
+                    ]
+                },
+                {
+                    "case": "default",
+                    "action": [
+                        {
+                            "type": "comment",
+                            "text": "当没有符合的值的场合执行此事件"
+                        },
+                        {
+                            "type": "choices",
+                            "text": "\t[老人,woman]少年，你需要钥匙吗？\n我这里有大把的！",
+                            "choices": [
+                                {
+                                    "text": "黄钥匙（${9+flag:woman_times}金币）",
+                                    "action": [
+                                        {
+                                            "type": "if",
+                                            "condition": "status:money>=9+flag:woman_times",
+                                            "true": [
+                                                {
+                                                    "type": "setValue",
+                                                    "name": "status:money",
+                                                    "value": "status:money-(9+flag:woman_times)"
+                                                },
+                                                {
+                                                    "type": "setValue",
+                                                    "name": "item:yellowKey",
+                                                    "value": "item:yellowKey+1"
+                                                }
+                                            ],
+                                            "false": [
+                                                "\t[老人,woman]你的金钱不足！",
+                                                {
+                                                    "type": "revisit"
+                                                }
+                                            ]
+                                        }
+                                    ]
+                                },
+                                {
+                                    "text": "蓝钥匙（${18+2*flag:woman_times}金币）",
+                                    "action": [
+                                        {
+                                            "type": "if",
+                                            "condition": "status:money>=18+2*flag:woman_times",
+                                            "true": [
+                                                {
+                                                    "type": "setValue",
+                                                    "name": "status:money",
+                                                    "value": "status:money-(18+2*flag:woman_times)"
+                                                },
+                                                {
+                                                    "type": "setValue",
+                                                    "name": "item:blueKey",
+                                                    "value": "item:blueKey+1"
+                                                }
+                                            ],
+                                            "false": [
+                                                "\t[老人,woman]你的金钱不足！",
+                                                {
+                                                    "type": "revisit"
+                                                }
+                                            ]
+                                        }
+                                    ]
+                                },
+                                {
+                                    "text": "红钥匙（${36+4*flag:woman_times}金币）",
+                                    "action": [
+                                        {
+                                            "type": "if",
+                                            "condition": "status:money>=36+4*flag:woman_times",
+                                            "true": [
+                                                {
+                                                    "type": "setValue",
+                                                    "name": "status:money",
+                                                    "value": "status:money-(36+4*flag:woman_times)"
+                                                },
+                                                {
+                                                    "type": "setValue",
+                                                    "name": "item:redKey",
+                                                    "value": "item:redKey+1"
+                                                }
+                                            ],
+                                            "false": [
+                                                "\t[老人,woman]你的金钱不足！",
+                                                {
+                                                    "type": "revisit"
+                                                }
+                                            ]
+                                        }
+                                    ]
+                                },
+                                {
+                                    "text": "离开",
+                                    "action": [
+                                        {
+                                            "type": "exit"
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    ]
                 }
-                value = parseInt(value)||0;
-                core.status.route.push("input:"+value);
-
-                if (value>0) { // 检查
-                    core.setStatus("atk", core.getStatus("atk")+value);
-                    // core.updateStatusBar(); // 和下面的 {"type": "update"} 等价，立即更新状态栏和地图显伤
-                    core.drawTip("操作成功，攻击+"+value); // 左上角气泡提示
-                    core.events.insertAction([ // 往当前事件列表前插入两条事件
-                        {"type": "update"}, // 更新状态栏和地图显伤
-                        "操作成功，攻击+"+value // 对话框提示
-                    ]);
-                }
-            }},
-            */
-            {"type": "input", "text": "请输入你要加攻击力的数值："},
-            {"type": "if", "condition": "flag:input>0",
-                "true": [
-                    {"type": "setValue", "name": "status:atk", "value": "status:atk+flag:input"},
-                    {"type": "tip", "text": "操作成功，攻击+${flag:input}"},
-                    "操作成功，攻击+${flag:input}"
-                ],
-                "false": [
-
-                ]
-            },
-            "\t[老人,womanMagician]具体可参见样板中本事件的写法。"
+            ]
+        },
+        {
+            "type": "setValue",
+            "name": "flag:woman_times",
+            "value": "flag:woman_times+1"
+        },
+        {
+            "type": "revisit"
+        }
+    ]
+},
+"changeFloor": {
+    "4,12": {
+        "floorId": "sample0",
+        "loc": [
+            6,
+            0
         ]
     },
-    "changeFloor": { // 楼层转换事件；该事件不能和上面的events有冲突（同位置点），否则会被覆盖
-        "4,12": {"floorId": "sample0", "loc": [6,0]}, // 由于楼下有多个上楼梯，所以需指定位置而不是简单地写"stair": "upFloor"
-        "5,5": {"floorId": "sample2", "stair": "downFloor", "direction": "up"}
+    "5,5": {
+        "floorId": "sample2",
+        "stair": "downFloor",
+        "direction": "up"
     },
-    "afterBattle": { // 战斗后可能触发的事件列表
-        "9,6": [ // 初级卫兵1
-            {"type": "setValue", "name": "flag:door", "value": "flag:door+1"}, // 将"door"这个自定义flag加一
-            {"type": "if", "condition": "flag:door==2", // 一个条件判断事件，条件是"door"这个flag值等于2
-                "true": [ // 如果条件成立：打开机关门
-                    {"type": "openDoor", "loc": [10,5]}
-                ],
-                "false": [] // 如果条件不成立则无事件触发
-            },
-        ],
-        "11,6": [ // 初级卫兵2；注意由于打怪顺序问题，可能都得写一遍。
-            {"type": "setValue", "name": "flag:door", "value": "flag:door+1"}, // 将"door"这个自定义flag加一
-            {"type": "if", "condition": "flag:door==2", // 一个条件判断事件，条件是"door"这个flag值等于2
-                "true": [ // 如果条件成立：打开机关门
-                    {"type": "openDoor", "loc": [10,5]}
-                ],
-                "false": [] // 如果条件不成立则无事件触发
-            },
-        ],
-    },
-    "afterGetItem": { // 获得道具后可能触发的事件列表
+    "10,12": null
+},
+"afterBattle": {
+    "9,6": [
+        {
+            "type": "setValue",
+            "name": "flag:door",
+            "value": "flag:door+1"
+        },
+        {
+            "type": "if",
+            "condition": "flag:door==2",
+            "true": [
+                {
+                    "type": "openDoor",
+                    "loc": [
+                        10,
+                        5
+                    ]
+                }
+            ],
+            "false": []
+        }
+    ],
+    "11,6": [
+        {
+            "type": "setValue",
+            "name": "flag:door",
+            "value": "flag:door+1"
+        },
+        {
+            "type": "if",
+            "condition": "flag:door==2",
+            "true": [
+                {
+                    "type": "openDoor",
+                    "loc": [
+                        10,
+                        5
+                    ]
+                }
+            ],
+            "false": []
+        }
+    ]
+},
+"afterGetItem": {},
+"afterOpenDoor": {},
+"cannotMove": {},
+"bgmap": [
 
-    },
-    "afterOpenDoor": { // 开完门后可能触发的事件列表
-
-    },
-    "cannotMove": { // 每个图块不可通行的方向
-        // 可以在这里定义每个点不能前往哪个方向，例如悬崖边不能跳下去
-        // "x,y": ["up", "left"], // (x,y)点不能往上和左走
-
-    },
-}
+],
+"fgmap": [
 
+],
+}
\ No newline at end of file
diff --git a/project/floors/sample2.js b/project/floors/sample2.js
index 1298edef..7ae07530 100644
--- a/project/floors/sample2.js
+++ b/project/floors/sample2.js
@@ -10,41 +10,63 @@ main.floors.sample2=
 "images": [],
 "item_ratio": 1,
 "map": [
-    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-    [  0,  0,  1,  121,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-    [  0,  0,  1,  0,  0,  0,202,  0,  0,  0,  0,  0,  0, 0,  0,  1,  0,  0,  0,202,  0,  0,  0,  0,  0,  0],
-    [  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-    [  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-    [  0,  0,  1,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0, 0,  0,  1,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0],
-    [  0,  0,  0,  0,  0,  1,  0,  0,  1,  0,  0,  0,  0, 0,  0,  0,  0,  0,  1,  0,  0,  1,  0,  0,  0,  0],
-    [  0,  0,  0,  0,  1,  1, 45,  0,  1,  0,202,202,  0, 0,  0,  0,  0,  1,  1,  0,  0,  1,  0,202,202,  0],
-    [  0,  0,  0,  1,  1,  0,  0,  0,  1,  0,  0,  0,  0, 0,  0,  0,  1,  1,  0,  0,  0,  1,  0,  0,  0,  0],
-    [  0,  0,  0,  0,  0,  0, 88,  0,  1,  0,  0,  0,  0, 0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0],
-    [  0,  0,  0,  0,  0,202,  0,  0,  0,  0,  0,  0,  0, 0,  0,  0,  0,  0,202,  0,  0,  0,  0,  0,  0,  0],
-    [  0,  0,  0,  0,  0,  0,  0,  87,  0,  0,  0,  0,  122, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-    [  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-    [  0,  0,  1,  0,  0,  0,202,  0,  0,  0,  0,  0,  0, 0,  0,  1,  0,  0,  0,202,  0,  0,  0,  0,  0,  0],
-    [  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-    [  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-    [  0,  0,  1,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0, 0,  0,  1,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0],
-    [  0,  0,  0,  0,  0,  1,  0,  0,  1,  0,  0,  0,  0, 0,  0,  0,  0,  0,  1,  0,  0,  1,  0,  0,  0,  0],
-    [  0,  0,  0,  0,  1,  1,  0,  0,  1,  0,202,202,  0, 0,  0,  0,  0,  1,  1,  0,  0,  1,  0,202,202,  0],
-    [  0,  0,  0,  1,  1,  0,  0,  0,  1,  0,  0,  0,  0, 0,  0,  0,  1,  1,  0,  0,  0,  1,  0,  0,  0,  0],
-    [  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0, 0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0],
-    [  0,  0,  0,  0,  0,202,  0,  0,  0,  0,  0,  0,  0, 0,  0,  0,  0,  0,202,  0,  0,  0,  0,  0,  0,  0],
-    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0]
+    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  1,121,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  1,  0,  0,  0,202,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,202,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  1,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,  1,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  1,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  1,  1, 45,  0,  1,  0,202,202,  0,  0,  0,  0,  0,  1,  1,  0,  0,  1,  0,202,202,  0],
+    [  0,  0,  0,  1,  1,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  1,  1,  0,  0,  0,  1,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,  0, 88,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,202,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,202,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,  0,  0, 87,  0,  0,  0,  0,122,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  1,  0,  0,  0,202,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,202,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  1,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,  1,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  1,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  1,  1,  0,  0,  1,  0,202,202,  0,  0,  0,  0,  0,  1,  1,  0,  0,  1,  0,202,202,  0],
+    [  0,  0,  0,  1,  1,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  1,  1,  0,  0,  0,  1,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,202,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,202,  0,  0,  0,  0,  0,  0,  0],
+    [  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0]
 ],
-"width":26,
-"height":26,
+"width": 26,
+"height": 26,
 "firstArrive": [],
-"events": {"3,2":["123"],"12,12":["234"]},
-"changeFloor": {"6,10": {"floorId": "sample1", "stair": "upFloor"}, "7,12": {"floorId": "sample3", "stair": "downFloor"}},
+"events": {
+    "3,2": [
+        "123"
+    ],
+    "12,12": [
+        "234"
+    ]
+},
+"changeFloor": {
+    "6,10": {
+        "floorId": "sample1",
+        "stair": "upFloor"
+    },
+    "7,12": {
+        "floorId": "sample3",
+        "stair": "downFloor"
+    }
+},
 "afterBattle": {},
 "afterGetItem": {},
 "afterOpenDoor": {},
 "cannotMove": {},
 "upFloor": null,
+"bgmap": [
+
+],
+"fgmap": [
+
+],
 }
\ No newline at end of file
diff --git a/project/floors/sample3.js b/project/floors/sample3.js
index 57acd0d2..e115ba5f 100644
--- a/project/floors/sample3.js
+++ b/project/floors/sample3.js
@@ -1,409 +1,1005 @@
-main.floors.sample3 =
+main.floors.sample3=
 {
-    "floorId": "sample3", // 这里需要改楼层名，请和文件名及下面的floorId保持完全一致
-    // 楼层唯一标识符仅能由字母、数字、下划线组成，且不能由数字开头
-    // 推荐用法：第20层就用MT20，第38层就用MT38，地下6层就用MT_6（用下划线代替负号），隐藏3层用MT3h（h表示隐藏），等等
-    // 楼层唯一标识符，需要和名字完全一致
-    "title": "主塔 40 层", // 楼层中文名
-    "name": "40", // 显示在状态栏中的层数
-    "canFlyTo": false, // 该楼能否被楼传器飞到（不能的话在该楼也不允许使用楼传器）
-    "canUseQuickShop": true, // 该层是否允许使用快捷商店
-    "defaultGround": "snowGround", // 默认地面的图块ID（terrains中）
-    "images": [], // // 该层默认显示的所有图片；详细用法请查看文档“自定义素材”中的说明。
-    "color": [255,0,0,0.3], // 该层的默认画面色调。本项可不写（代表无色调），如果写需要是一个RGBA数组。
-    "weather": ["rain",10], // 该层的默认天气。本项可忽略表示晴天，如果写则第一项为"rain"或"snow"代表雨雪，第二项为1-10之间的数代表强度。
-    "bgm": "bgm.mp3", // 到达该层后默认播放的BGM。本项可忽略。
-    "item_ratio": 1, // 该层的宝石/血瓶倍率
-    "map": [ // 地图数据，需要是13x13，建议使用地图生成器来生成
-        [  5,  5,  5,  5,  5,  5, 87,  5,  5,  5,  5,  5,  5],
-        [  5,  4,  4,  4,  4,  1,  0,  1,  4,  4,  4,  4,  5],
-        [  5,  4,  4,  4,  4,  1, 85,  1,  4,  4,  4,  4,  5],
-        [  5,  4,  4,  4,247,  1,247,  1,247,  4,  4,  4,  5],
-        [  5,  4,  4,  4,  1,247,247,247,  1,  4,  4,  4,  5],
-        [  5,  4,  4,  4,  1,247, 30,247,  1,  4,  4,  4,  5],
-        [  5,  4,  4,  4,247,  1,124,  1,247,  4,  4,  4,  5],
-        [  5,  4,  4,  4,  4,  1,123,  1,  4,  4,  4,  4,  5],
-        [  5,  4,  4,  4,  4,  1,  0,  1,  4,  4,  4,  4,  5],
-        [  5,  4,  4,  4,  4,  1,  0,  1,  4,  4,  4,  4,  5],
-        [  5,  4,  4,  4,  4,  4,  0,  4,  4,  4,  4,  4,  5],
-        [  5,  4,  4,  4,  4,  4, 85,  4,  4,  4,  4,  4,  5],
-        [  5,  5,  5,  5,  5,  5, 88,  5,  5,  5,  5,  5,  5]
-    ],
-    "firstArrive": [ // 第一次到该楼层触发的事件
-        "\t[实战！]本楼将尝试复刻《宿命的旋律》40F剧情。"
-    ],
-    "events": { // 该楼的所有可能事件列表
-
-        "6,11": {"enable": false}, // 下楼梯口的机关门，初始处于关闭状态
-        "6,10": [ // 进入陷阱后关门
-            {"type": "playSound", "name": "door.mp3"},
-            {"type": "show", "loc": [6,11]}, // 显示机关门
-            {"type": "hide"}, // 隐藏该事件
-            {"type": "trigger", "loc": [6,7]}, // 直接引发"6,7"处的事件，即下面的杰克
-            // 请再次注意"trigger"会立刻结束当前事件，因此"type":"hide"需要在trigger前调用
-        ],
-        "6,7": [ // 杰克事件
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]杰克，你究竟是什么人？",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[杰克,thief]……",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]我们……是朋友对吧？\n是朋友就应该相互信任对吧？",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[杰克,thief]……事到如今也没有什么好隐瞒的了。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[杰克,thief]没错，我就是这一切的背后主谋。",
-            {"type": "move", "steps": [ // 移动到黑暗大法师的位置；使用move会自动调用hide进行隐藏，无需再手动调用
-                    {"direction": "up", "value": 3}
-                ], "time": 1000},
-            {"type": "show", "loc": [6,4], "time": 1000}, // 显示黑暗大法师
-            {"type": "sleep", "time": 500}, // 等待500毫秒
-            // 下面是黑暗大法师的事件
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]我的真名为——黑暗大法师，第四区域的头目。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]呵呵，不知道为什么，我竟然对事情走到现在这一步毫不感觉意外。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]以杰克的名义利用了你这么久，真是抱歉啊。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]真正的杰克现在在哪里？",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]盗贼杰克这个人类从未存在过，他只是我用来接近你的一副皮囊而已。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]……这样啊，呵呵。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]为什么你看上去丝毫不生气？",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]多亏了鬼帝，我现在的脾气好得连我自己都害怕。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]说起来我还得好好感谢你呢，如果没有杰克……你的帮助，我早就死在第一区域了。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]不论你的目的如何，你的所作所为都是对我有利的。不是吗？",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]能够如此淡定的面对背叛，看来跟五年前相比，你确实成长了很多啊。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]五年前？……黑暗大法师，在这之前，我们好像素未谋面吧？",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]五年前那场屠城你应该这一生都不会忘记吧。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]很不巧，那场屠城的主谋，也是我。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]……",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]这么说，击中我双亲的那道紫色闪电，也就是你释放的吧……",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]你的双亲？这种事情我怎么可能会记得？\n你难道在踩死蚂蚁的时候还会一只只记下他们的样子吗？",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]老 子 要 你 的 命",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]你应该对我心怀感激才对，如果不是那时的我看出了你隐藏的稀有勇者体质，你绝对不可能活到今天。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]在暗中动手脚让你通过勇者选拔的人也是我，我一直一直在暗中引导你走到今天这一步。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]是我救赎了一无是处的你。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]为什么只有我一个人活了下来！！！！",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]为什么偏偏是我！！！！",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]我刚才不是说过了吗？因为我看出了你有稀有勇者体质啊。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]你刚刚跟鬼帝交过手，应该已经很清楚这稀有勇者体质意味着什么了吧？",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]……就因为我有这种体质，就不得不背负如此残酷的宿命吗？",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]愚蠢！这意味着只要我对你加以引导跟培养，你就能成为这世间实力最强的存在！",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]……所以，你究竟想利用我干什么？",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]我利用你干的事情，你不是已经完成了吗？",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]……你说什么？",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]不知不觉间，你已经在我的指引下跟鬼帝正面交手并且杀掉了他啊。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]就连我跟鬼帝的对决……也是被你安排好了的？",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]你们两个一个是人类勇者，一个是魔物勇者，迟早会有交手的一天。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]我只不过是操纵了一系列的连锁事件让这一天提早了数十年到来而已。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]……你这样做对谁有好处？他可是你们魔物世界的救世主啊。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]一个惧怕征战，爱好和平的懦夫，也配叫救世主？",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]获得了力量，却只会被动挨打而不主动向人类世界出击，龟缩在第二区域惶惶度日，他根本就不配拥有稀有勇者体质。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]为了不让这种人霸占着积累多年的庞大灵魂能量无作为，我设计让你杀掉了他。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]你没有辜负我的期待，成功战胜了那个废物，现在你体内累积的灵魂能量……也就是魔力，已经达到了能跟魔王匹敌的地步。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]……是吗？现在的我能与魔王匹敌？",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]不止如此，你现在的力量之强就算是统治世界也是绰绰有余！",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]怎么样？要不要加入我的麾下，跟随我去征战人类世界？",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]能与魔王匹敌的话，也就是说。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]我 现 在 对 付 你 这 种 杂 碎 也 绰 绰 有 余 吧 ？",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]……什么？！",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[blackMagician]等一下！别冲动！你先等我把这利害关系理一理——",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]你给老子闭嘴。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]老子什么都不想听。",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]老子现在想做的事情只有一件——",
-            {"type": "playSound", "name": "item.mp3"},
-            "\t[hero]剁掉你的头，把它放回我双亲的墓前。",
-            {"type": "update"} // 本事件剧情结束，更新地图显伤
-        ],
-        "6,4": { // 黑暗大法师战斗事件
-            "enable": false, // 初始时是禁用状态
-            // 打败后将触发afterBattle事件
+"floorId": "sample3",
+"title": "主塔 40 层",
+"name": "40",
+"canFlyTo": false,
+"canUseQuickShop": true,
+"defaultGround": "snowGround",
+"images": [],
+"color": [
+    255,
+    0,
+    0,
+    0.3
+],
+"weather": [
+    "rain",
+    10
+],
+"bgm": "bgm.mp3",
+"item_ratio": 1,
+"map": [
+    [  5,  5,  5,  5,  5,  5, 87,  5,  5,  5,  5,  5,  5],
+    [  5,  4,  4,  4,  4,  1,  0,  1,  4,  4,  4,  4,  5],
+    [  5,  4,  4,  4,  4,  1, 85,  1,  4,  4,  4,  4,  5],
+    [  5,  4,  4,  4,247,  1,247,  1,247,  4,  4,  4,  5],
+    [  5,  4,  4,  4,  1,247,247,247,  1,  4,  4,  4,  5],
+    [  5,  4,  4,  4,  1,247, 30,247,  1,  4,  4,  4,  5],
+    [  5,  4,  4,  4,247,  1,124,  1,247,  4,  4,  4,  5],
+    [  5,  4,  4,  4,  4,  1,123,  1,  4,  4,  4,  4,  5],
+    [  5,  4,  4,  4,  4,  1,  0,  1,  4,  4,  4,  4,  5],
+    [  5,  4,  4,  4,  4,  1,  0,  1,  4,  4,  4,  4,  5],
+    [  5,  4,  4,  4,  4,  4,  0,  4,  4,  4,  4,  4,  5],
+    [  5,  4,  4,  4,  4,  4, 85,  4,  4,  4,  4,  4,  5],
+    [  5,  5,  5,  5,  5,  5, 88,  5,  5,  5,  5,  5,  5]
+],
+"firstArrive": [
+    "\t[实战！]本楼将尝试复刻《宿命的旋律》40F剧情。"
+],
+"events": {
+    "6,11": {
+        "enable": false,
+        "data": []
+    },
+    "6,10": [
+        {
+            "type": "playSound",
+            "name": "door.mp3"
         },
-        "5,4": {"enable":false}, // 大法师的分身们，初始时禁用状态
-        "7,4": {"enable":false}, // 大法师的分身们，初始时禁用状态
-        "5,5": {"enable":false}, // 大法师的分身们，初始时禁用状态
-        "7,5": {"enable":false}, // 大法师的分身们，初始时禁用状态
-        "6,3": { // 大法师本尊
-            "trigger": "action", // 注意：这里要写 trigger:action ，来覆盖掉系统默认的battle事件。
-            "enable":false,
-            "data": [
-                "\t[blackMagician]听不进去人话的蠢货，就要用疼痛来管教！",
-                {"type": "changePos", "direction": "up"},
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[blackMagician]出来吧！禁忌——紫电凶杀阵！",
-                {"type": "show", "loc": [[4,3],[4,6],[8,6],[8,3]], "time": 500}, // 依次显示四个角的法师
-                {"type": "sleep", "time": 500},
-                "\t[blackMagician]感受绝望吧！冥顽不化的蠢货！",
-                /*
-                {"type": "hide", "loc": [4,3], "time": 150}, // 由于没有动画效果，暂时使用“闪一下”表示
-                {"type": "show", "loc": [4,3], "time": 150},
-                {"type": "hide", "loc": [4,6], "time": 150}, // 由于没有动画效果，暂时使用“闪一下”表示
-                {"type": "show", "loc": [4,6], "time": 150},
-                {"type": "hide", "loc": [8,6], "time": 150}, // 由于没有动画效果，暂时使用“闪一下”表示
-                {"type": "show", "loc": [8,6], "time": 150},
-                {"type": "hide", "loc": [8,3], "time": 150}, // 由于没有动画效果，暂时使用“闪一下”表示
-                {"type": "show", "loc": [8,3], "time": 150},
-                */
-                {"type": "animate", "name": "yongchang", "loc": [4,3]},
-                {"type": "animate", "name": "yongchang", "loc": [4,6]},
-                {"type": "animate", "name": "yongchang", "loc": [8,6]},
-                {"type": "animate", "name": "yongchang", "loc": [8,3]},
-                {"type": "sleep", "time": 200},
-                {"type": "playSound", "name": "attack.mp3"}, // 播放攻击音效
-                {"type": "animate", "name": "thunder", "loc": "hero"},
-                {"type": "sleep", "time": 200},
-                "\t[hero]唔……！！（吐血）",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[blackMagician]我的魔力可是充足的很啊！我会一直折磨到你屈服于我为止！",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[blackMagician]人类！好好感受吧！当初你们施加于我的痛苦！如今我要百倍奉还！",
-                {"type": "show", "loc": [6,6], "time": 1000}, // 显示妖精
-                {"type": "sleep", "time": 700},
-                {"type": "trigger", "loc": [6,6]} // 立刻触发妖精事件
+        {
+            "type": "show",
+            "loc": [
+                6,
+                11
             ]
         },
-        "4,3": { // 四个角的大法师，
-            "trigger": "action",
-            "displayDamage": false,
-            "enable":false
+        {
+            "type": "hide"
         },
-        "8,3": { // 四个角的大法师，
-            "trigger": "action",
-            "displayDamage": false,
-            "enable":false
-        },
-        "4,6": { // 四个角的大法师，
-            "trigger": "action",
-            "displayDamage": false,
-            "enable":false
-        },
-        "8,6": { // 四个角的大法师，
-            "trigger": "action",
-            "displayDamage": false,
-            "enable":false
-        },
-
-        "6,6": { // 妖精
-            "enable":false, // 初始时禁用状态
-            "data": [ // 妖精事件
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[hero]…妖精…小姐……是你吗？",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[小妖精,fairy]不要绝望，也不要悲伤。",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[小妖精,fairy]你从来都不是独自一人在前进。",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[小妖精,fairy]咱一直，一直都在注视着你。",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[小妖精,fairy]耍小聪明的你、笨笨的你呆呆的你、胆小的你、勇敢的你帅气的你……全部全部都是你。",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[小妖精,fairy]所以放心吧，无论发生什么，咱都会陪伴在你身边的。",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[小妖精,fairy]因为你要是离开我的话，立刻就会死掉吧？",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[hero]…妖精…小姐……其实一直以来，我都非常感激你……",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[小妖精,fairy]笨蛋！都这种时候了就不要作出像是临终遗言的发言了啊！！",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[小妖精,fairy]喂！那边穿衣品味差到极点的黑暗大法师，别左顾右盼说的就是你！你应该知道咱的身份吧？\n还不速速退下！",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[blackMagician]可恶…多管闲事的妖精族…明明只要再让他承受一点疼痛来瓦解他的意志力，我的计划就成功了！",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[小妖精,fairy]哼哼哼~抱歉哦，这个笨蛋的意志力可不像你想象的那么薄弱哦！",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[blackMagician]不甘心！我不甘心！妖精公主又如何！\n只要是阻挡我的，不管是谁我都要铲除！",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[小妖精,fairy]终于露出狐狸尾巴了，其实咱早就看出你有谋反的念头。你的计划就是拉拢这家伙入伙然后推翻魔王对魔塔的统治对吧？",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[blackMagician]呵呵呵……那个昏庸的魔王，掌握着那么庞大的魔物军队却只知道固守魔塔，而不主动侵略人类世界扩张领土！",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[blackMagician]我实在是看不过眼，所以我才决定把这个具备稀有勇者体质的家伙培养成新一任魔王！\n来让这个世界的势力重新洗牌！",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[小妖精,fairy]你觉得一个满脑子想着回家种田的废柴勇者会成为改变世界的魔王？你晃晃脑袋试试，是不是能听到大海的声音？",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[blackMagician]恼人至极的妖精族！呵呵呵……我干脆一不做二不休，连你也一块收拾了吧！",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[小妖精,fairy]别小瞧咱！咱好歹也是妖精族里实力数一数二的存在！",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[blackMagician]只会耍嘴皮子的恼人苍蝇！我倒要看看一块焦炭会不会说话！\n——招雷弹！！",
-                /*
-                {"type": "hide", "loc": [4,3], "time": 150}, // 由于没有动画效果，暂时使用“闪一下”表示
-                {"type": "show", "loc": [4,3], "time": 150},
-                {"type": "hide", "loc": [4,6], "time": 150}, // 由于没有动画效果，暂时使用“闪一下”表示
-                {"type": "show", "loc": [4,6], "time": 150},
-                {"type": "hide", "loc": [8,6], "time": 150}, // 由于没有动画效果，暂时使用“闪一下”表示
-                {"type": "show", "loc": [8,6], "time": 150},
-                {"type": "hide", "loc": [8,3], "time": 150}, // 由于没有动画效果，暂时使用“闪一下”表示
-                {"type": "show", "loc": [8,3], "time": 150},
-                */
-                {"type": "animate", "name": "yongchang", "loc": [4,3]},
-                {"type": "animate", "name": "yongchang", "loc": [4,6]},
-                {"type": "animate", "name": "yongchang", "loc": [8,6]},
-                {"type": "animate", "name": "yongchang", "loc": [8,3]},
-                {"type": "playSound", "name": "attack.mp3"}, // 播放攻击音效
-                /*
-                {"type": "hide", "loc": [6,6], "time": 150}, // 妖精也闪一下表示收到了伤害
-                {"type": "show", "loc": [6,6], "time": 150}, // 妖精也闪一下表示收到了伤害
-                */
-                {"type": "animate", "name": "thunder", "loc": [6,6]},
-                {"type": "sleep", "time": 500}, // 等待500毫秒
-                "\t[小妖精,fairy]切，这点伤痛跟他刚才经历的身心地狱相比根本就不算什么。",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[blackMagician]哼！翅膀都被烧焦了还要嘴硬？你难不成真以为我不会对你动真格？",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[hero]……你这混蛋！给我离她远点！！",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[小妖精,fairy]！…你现在受了很严重的致命伤，乱动什么？\n乖。别怕，这里有咱顶着！",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[小妖精,fairy]对了，咱再问你一遍，你是很珍惜自己性命的对吧？",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[hero]！…等等…妖精小姐，你不会是……？",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[小妖精,fairy]喂，黑暗大法师，你作为魔塔里最博学多识的蠢货，应该对咱妖精族的特殊能力再清楚不过吧？",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[blackMagician]什么？！难不成你是想！！不可能……\n就为了一个渺小的人类，不可理喻！！",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[小妖精,fairy]哼哼哼！你害怕的表情可真美味！",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[小妖精,fairy]不过比起这个，咱更期待你吃到“妖精自灭冲击”之后的死状哦！~",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[blackMagician]不！！不应该是这样的！我完美的计划竟然会被一只小小的妖精破坏！",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[hero]不要！……千万不要！……为了我这种人……唔！",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[小妖精,fairy]笨蛋，动都动不了了就不要强撑着站起来了啊。",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[小妖精,fairy]真是的，都到最后一刻了，你这家伙好歹也让咱省点心吧。",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[小妖精,fairy]那么，再见了……我的勇者大人。",
-                {"type": "move", "time": 700, "steps": [ // 向上移动三个，撞上黑暗大大法师；本事件的hide会自动被调用
-                        {"direction": "up", "value": 3}
-                    ]},
-                {"type": "playSound", "name": "attack.mp3"}, // 播放攻击音效
-                {"type": "sleep", "time": 200},
-                "\t[blackMagician]不可能！！！！！",
-                {"type": "hide", "loc": [6,3]}, // 法师消失
-                {"type": "hide", "loc": [4,3]}, // 四个分身消失
-                {"type": "hide", "loc": [4,6]},
-                {"type": "hide", "loc": [8,6]},
-                {"type": "hide", "loc": [8,3]},
-                {"type": "changeFloor", "floorId": "sample3", "loc": [6,6], "direction": "up", "time": 1000}, // 更换勇士地点，合计1秒
-                {"type": "show", "loc": [6,5]}, // 显示黄宝石
-                {"type": "sleep", "time": 200}, // 等待200毫秒
-                {"type": "playSound", "name": "item.mp3"},
-                {"type": "sleep", "time": 200}, // 等待200毫秒
-                "\t[hero]…妖精…小姐……",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[hero]……妖精小姐！",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[hero]是梦吗？……不对，为什么我在流泪？",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[hero]这颗漂亮的宝石是……？",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[hero]我全都想起来了……妖精小姐为了我……\n牺牲了自己的性命。",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[hero]在这颗宝石上，我能感受到你的温度……\n熟悉而又令人安心，这就是你最后留给我的东西吗……",
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[hero]好温暖……",
-                {"type": "setValue", "name": "item:yellowJewel", "value": "1"}, // 获得1个黄宝石
-                {"type": "hide", "loc": [6,5]}, // 隐藏黄宝石
-                {"type": "playSound", "name": "item.mp3"},
-                "\t[hero]……",
-                {"type": "openDoor", "loc": [6,2]}, // 开门
-                {"type": "openDoor", "loc": [6,11]}
+        {
+            "type": "trigger",
+            "loc": [
+                6,
+                7
             ]
-        },
-        "6,5": { // 黄宝石
-            "enable": false
         }
+    ],
+    "6,7": [
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]杰克，你究竟是什么人？",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[杰克,thief]……",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]我们……是朋友对吧？\n是朋友就应该相互信任对吧？",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[杰克,thief]……事到如今也没有什么好隐瞒的了。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[杰克,thief]没错，我就是这一切的背后主谋。",
+        {
+            "type": "move",
+            "steps": [
+                {
+                    "direction": "up",
+                    "value": 3
+                }
+            ],
+            "time": 1000
+        },
+        {
+            "type": "show",
+            "loc": [
+                6,
+                4
+            ],
+            "time": 1000
+        },
+        {
+            "type": "sleep",
+            "time": 500
+        },
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]我的真名为——黑暗大法师，第四区域的头目。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]呵呵，不知道为什么，我竟然对事情走到现在这一步毫不感觉意外。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]以杰克的名义利用了你这么久，真是抱歉啊。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]真正的杰克现在在哪里？",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]盗贼杰克这个人类从未存在过，他只是我用来接近你的一副皮囊而已。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]……这样啊，呵呵。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]为什么你看上去丝毫不生气？",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]多亏了鬼帝，我现在的脾气好得连我自己都害怕。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]说起来我还得好好感谢你呢，如果没有杰克……你的帮助，我早就死在第一区域了。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]不论你的目的如何，你的所作所为都是对我有利的。不是吗？",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]能够如此淡定的面对背叛，看来跟五年前相比，你确实成长了很多啊。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]五年前？……黑暗大法师，在这之前，我们好像素未谋面吧？",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]五年前那场屠城你应该这一生都不会忘记吧。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]很不巧，那场屠城的主谋，也是我。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]……",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]这么说，击中我双亲的那道紫色闪电，也就是你释放的吧……",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]你的双亲？这种事情我怎么可能会记得？\n你难道在踩死蚂蚁的时候还会一只只记下他们的样子吗？",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]老 子 要 你 的 命",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]你应该对我心怀感激才对，如果不是那时的我看出了你隐藏的稀有勇者体质，你绝对不可能活到今天。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]在暗中动手脚让你通过勇者选拔的人也是我，我一直一直在暗中引导你走到今天这一步。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]是我救赎了一无是处的你。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]为什么只有我一个人活了下来！！！！",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]为什么偏偏是我！！！！",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]我刚才不是说过了吗？因为我看出了你有稀有勇者体质啊。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]你刚刚跟鬼帝交过手，应该已经很清楚这稀有勇者体质意味着什么了吧？",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]……就因为我有这种体质，就不得不背负如此残酷的宿命吗？",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]愚蠢！这意味着只要我对你加以引导跟培养，你就能成为这世间实力最强的存在！",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]……所以，你究竟想利用我干什么？",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]我利用你干的事情，你不是已经完成了吗？",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]……你说什么？",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]不知不觉间，你已经在我的指引下跟鬼帝正面交手并且杀掉了他啊。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]就连我跟鬼帝的对决……也是被你安排好了的？",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]你们两个一个是人类勇者，一个是魔物勇者，迟早会有交手的一天。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]我只不过是操纵了一系列的连锁事件让这一天提早了数十年到来而已。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]……你这样做对谁有好处？他可是你们魔物世界的救世主啊。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]一个惧怕征战，爱好和平的懦夫，也配叫救世主？",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]获得了力量，却只会被动挨打而不主动向人类世界出击，龟缩在第二区域惶惶度日，他根本就不配拥有稀有勇者体质。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]为了不让这种人霸占着积累多年的庞大灵魂能量无作为，我设计让你杀掉了他。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]你没有辜负我的期待，成功战胜了那个废物，现在你体内累积的灵魂能量……也就是魔力，已经达到了能跟魔王匹敌的地步。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]……是吗？现在的我能与魔王匹敌？",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]不止如此，你现在的力量之强就算是统治世界也是绰绰有余！",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]怎么样？要不要加入我的麾下，跟随我去征战人类世界？",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]能与魔王匹敌的话，也就是说。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]我 现 在 对 付 你 这 种 杂 碎 也 绰 绰 有 余 吧 ？",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]……什么？！",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[blackMagician]等一下！别冲动！你先等我把这利害关系理一理——",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]你给老子闭嘴。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]老子什么都不想听。",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]老子现在想做的事情只有一件——",
+        {
+            "type": "playSound",
+            "name": "item.mp3"
+        },
+        "\t[hero]剁掉你的头，把它放回我双亲的墓前。",
+        {
+            "type": "update"
+        }
+    ],
+    "6,4": {
+        "enable": false,
+        "data": []
+    },
+    "5,4": {
+        "enable": false,
+        "data": []
+    },
+    "7,4": {
+        "enable": false,
+        "data": []
+    },
+    "5,5": {
+        "enable": false,
+        "data": []
+    },
+    "7,5": {
+        "enable": false,
+        "data": []
+    },
+    "6,3": {
+        "trigger": "action",
+        "enable": false,
+        "data": [
+            "\t[blackMagician]听不进去人话的蠢货，就要用疼痛来管教！",
+            {
+                "type": "changePos",
+                "direction": "up"
+            },
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[blackMagician]出来吧！禁忌——紫电凶杀阵！",
+            {
+                "type": "show",
+                "loc": [
+                    [
+                        4,
+                        3
+                    ],
+                    [
+                        4,
+                        6
+                    ],
+                    [
+                        8,
+                        6
+                    ],
+                    [
+                        8,
+                        3
+                    ]
+                ],
+                "time": 500
+            },
+            {
+                "type": "sleep",
+                "time": 500
+            },
+            "\t[blackMagician]感受绝望吧！冥顽不化的蠢货！",
+            {
+                "type": "animate",
+                "name": "yongchang",
+                "loc": [
+                    4,
+                    3
+                ]
+            },
+            {
+                "type": "animate",
+                "name": "yongchang",
+                "loc": [
+                    4,
+                    6
+                ]
+            },
+            {
+                "type": "animate",
+                "name": "yongchang",
+                "loc": [
+                    8,
+                    6
+                ]
+            },
+            {
+                "type": "animate",
+                "name": "yongchang",
+                "loc": [
+                    8,
+                    3
+                ]
+            },
+            {
+                "type": "sleep",
+                "time": 200
+            },
+            {
+                "type": "playSound",
+                "name": "attack.mp3"
+            },
+            {
+                "type": "animate",
+                "name": "thunder",
+                "loc": "hero"
+            },
+            {
+                "type": "sleep",
+                "time": 200
+            },
+            "\t[hero]唔……！！（吐血）",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[blackMagician]我的魔力可是充足的很啊！我会一直折磨到你屈服于我为止！",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[blackMagician]人类！好好感受吧！当初你们施加于我的痛苦！如今我要百倍奉还！",
+            {
+                "type": "show",
+                "loc": [
+                    6,
+                    6
+                ],
+                "time": 1000
+            },
+            {
+                "type": "sleep",
+                "time": 700
+            },
+            {
+                "type": "trigger",
+                "loc": [
+                    6,
+                    6
+                ]
+            }
+        ]
+    },
+    "4,3": {
+        "trigger": "action",
+        "displayDamage": false,
+        "enable": false,
+        "data": []
+    },
+    "8,3": {
+        "trigger": "action",
+        "displayDamage": false,
+        "enable": false,
+        "data": []
+    },
+    "4,6": {
+        "trigger": "action",
+        "displayDamage": false,
+        "enable": false,
+        "data": []
+    },
+    "8,6": {
+        "trigger": "action",
+        "displayDamage": false,
+        "enable": false,
+        "data": []
+    },
+    "6,6": {
+        "enable": false,
+        "data": [
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[hero]…妖精…小姐……是你吗？",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[小妖精,fairy]不要绝望，也不要悲伤。",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[小妖精,fairy]你从来都不是独自一人在前进。",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[小妖精,fairy]咱一直，一直都在注视着你。",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[小妖精,fairy]耍小聪明的你、笨笨的你呆呆的你、胆小的你、勇敢的你帅气的你……全部全部都是你。",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[小妖精,fairy]所以放心吧，无论发生什么，咱都会陪伴在你身边的。",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[小妖精,fairy]因为你要是离开我的话，立刻就会死掉吧？",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[hero]…妖精…小姐……其实一直以来，我都非常感激你……",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[小妖精,fairy]笨蛋！都这种时候了就不要作出像是临终遗言的发言了啊！！",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[小妖精,fairy]喂！那边穿衣品味差到极点的黑暗大法师，别左顾右盼说的就是你！你应该知道咱的身份吧？\n还不速速退下！",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[blackMagician]可恶…多管闲事的妖精族…明明只要再让他承受一点疼痛来瓦解他的意志力，我的计划就成功了！",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[小妖精,fairy]哼哼哼~抱歉哦，这个笨蛋的意志力可不像你想象的那么薄弱哦！",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[blackMagician]不甘心！我不甘心！妖精公主又如何！\n只要是阻挡我的，不管是谁我都要铲除！",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[小妖精,fairy]终于露出狐狸尾巴了，其实咱早就看出你有谋反的念头。你的计划就是拉拢这家伙入伙然后推翻魔王对魔塔的统治对吧？",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[blackMagician]呵呵呵……那个昏庸的魔王，掌握着那么庞大的魔物军队却只知道固守魔塔，而不主动侵略人类世界扩张领土！",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[blackMagician]我实在是看不过眼，所以我才决定把这个具备稀有勇者体质的家伙培养成新一任魔王！\n来让这个世界的势力重新洗牌！",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[小妖精,fairy]你觉得一个满脑子想着回家种田的废柴勇者会成为改变世界的魔王？你晃晃脑袋试试，是不是能听到大海的声音？",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[blackMagician]恼人至极的妖精族！呵呵呵……我干脆一不做二不休，连你也一块收拾了吧！",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[小妖精,fairy]别小瞧咱！咱好歹也是妖精族里实力数一数二的存在！",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[blackMagician]只会耍嘴皮子的恼人苍蝇！我倒要看看一块焦炭会不会说话！\n——招雷弹！！",
+            {
+                "type": "animate",
+                "name": "yongchang",
+                "loc": [
+                    4,
+                    3
+                ]
+            },
+            {
+                "type": "animate",
+                "name": "yongchang",
+                "loc": [
+                    4,
+                    6
+                ]
+            },
+            {
+                "type": "animate",
+                "name": "yongchang",
+                "loc": [
+                    8,
+                    6
+                ]
+            },
+            {
+                "type": "animate",
+                "name": "yongchang",
+                "loc": [
+                    8,
+                    3
+                ]
+            },
+            {
+                "type": "playSound",
+                "name": "attack.mp3"
+            },
+            {
+                "type": "animate",
+                "name": "thunder",
+                "loc": [
+                    6,
+                    6
+                ]
+            },
+            {
+                "type": "sleep",
+                "time": 500
+            },
+            "\t[小妖精,fairy]切，这点伤痛跟他刚才经历的身心地狱相比根本就不算什么。",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[blackMagician]哼！翅膀都被烧焦了还要嘴硬？你难不成真以为我不会对你动真格？",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[hero]……你这混蛋！给我离她远点！！",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[小妖精,fairy]！…你现在受了很严重的致命伤，乱动什么？\n乖。别怕，这里有咱顶着！",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[小妖精,fairy]对了，咱再问你一遍，你是很珍惜自己性命的对吧？",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[hero]！…等等…妖精小姐，你不会是……？",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[小妖精,fairy]喂，黑暗大法师，你作为魔塔里最博学多识的蠢货，应该对咱妖精族的特殊能力再清楚不过吧？",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[blackMagician]什么？！难不成你是想！！不可能……\n就为了一个渺小的人类，不可理喻！！",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[小妖精,fairy]哼哼哼！你害怕的表情可真美味！",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[小妖精,fairy]不过比起这个，咱更期待你吃到“妖精自灭冲击”之后的死状哦！~",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[blackMagician]不！！不应该是这样的！我完美的计划竟然会被一只小小的妖精破坏！",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[hero]不要！……千万不要！……为了我这种人……唔！",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[小妖精,fairy]笨蛋，动都动不了了就不要强撑着站起来了啊。",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[小妖精,fairy]真是的，都到最后一刻了，你这家伙好歹也让咱省点心吧。",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[小妖精,fairy]那么，再见了……我的勇者大人。",
+            {
+                "type": "move",
+                "time": 700,
+                "steps": [
+                    {
+                        "direction": "up",
+                        "value": 3
+                    }
+                ]
+            },
+            {
+                "type": "playSound",
+                "name": "attack.mp3"
+            },
+            {
+                "type": "sleep",
+                "time": 200
+            },
+            "\t[blackMagician]不可能！！！！！",
+            {
+                "type": "hide",
+                "loc": [
+                    6,
+                    3
+                ]
+            },
+            {
+                "type": "hide",
+                "loc": [
+                    4,
+                    3
+                ]
+            },
+            {
+                "type": "hide",
+                "loc": [
+                    4,
+                    6
+                ]
+            },
+            {
+                "type": "hide",
+                "loc": [
+                    8,
+                    6
+                ]
+            },
+            {
+                "type": "hide",
+                "loc": [
+                    8,
+                    3
+                ]
+            },
+            {
+                "type": "changeFloor",
+                "floorId": "sample3",
+                "loc": [
+                    6,
+                    6
+                ],
+                "direction": "up",
+                "time": 1000
+            },
+            {
+                "type": "show",
+                "loc": [
+                    6,
+                    5
+                ]
+            },
+            {
+                "type": "sleep",
+                "time": 200
+            },
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            {
+                "type": "sleep",
+                "time": 200
+            },
+            "\t[hero]…妖精…小姐……",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[hero]……妖精小姐！",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[hero]是梦吗？……不对，为什么我在流泪？",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[hero]这颗漂亮的宝石是……？",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[hero]我全都想起来了……妖精小姐为了我……\n牺牲了自己的性命。",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[hero]在这颗宝石上，我能感受到你的温度……\n熟悉而又令人安心，这就是你最后留给我的东西吗……",
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[hero]好温暖……",
+            {
+                "type": "setValue",
+                "name": "item:yellowJewel",
+                "value": "1"
+            },
+            {
+                "type": "hide",
+                "loc": [
+                    6,
+                    5
+                ]
+            },
+            {
+                "type": "playSound",
+                "name": "item.mp3"
+            },
+            "\t[hero]……",
+            {
+                "type": "openDoor",
+                "loc": [
+                    6,
+                    2
+                ]
+            },
+            {
+                "type": "openDoor",
+                "loc": [
+                    6,
+                    11
+                ]
+            }
+        ]
+    },
+    "6,5": {
+        "enable": false,
+        "data": []
+    }
+},
+"changeFloor": {
+    "6,0": {
+        "floorId": "sample3",
+        "stair": "upFloor"
+    },
+    "6,12": {
+        "floorId": "sample2",
+        "stair": "upFloor"
+    }
+},
+"afterBattle": {
+    "6,4": [
+        "\t[blackMagician]天真！你以为这样就能战胜我吗？",
+        {
+            "type": "show",
+            "loc": [
+                7,
+                5
+            ],
+            "time": 500
+        },
+        {
+            "type": "update"
+        }
+    ],
+    "7,5": [
+        "\t[blackMagician]你打败的不过是我众多分身中的其中一个而已。",
+        {
+            "type": "show",
+            "loc": [
+                5,
+                4
+            ],
+            "time": 500
+        },
+        {
+            "type": "update"
+        }
+    ],
+    "5,4": [
+        "\t[blackMagician]你的身体已经伤痕累累了，可我还留有着九成多的魔力。",
+        {
+            "type": "show",
+            "loc": [
+                5,
+                5
+            ],
+            "time": 500
+        },
+        {
+            "type": "update"
+        }
+    ],
+    "5,5": [
+        "\t[blackMagician]顽固的家伙！放弃抵抗吧！",
+        {
+            "type": "show",
+            "loc": [
+                7,
+                4
+            ],
+            "time": 500
+        },
+        {
+            "type": "update"
+        }
+    ],
+    "7,4": [
+        "\t[blackMagician]哈哈哈哈！我的灵魂远比你想象的强大！\n我即是永恒！",
+        {
+            "type": "show",
+            "loc": [
+                6,
+                3
+            ],
+            "time": 500
+        },
+        {
+            "type": "trigger",
+            "loc": [
+                6,
+                3
+            ]
+        }
+    ]
+},
+"afterGetItem": {},
+"afterOpenDoor": {},
+"cannotMove": {},
+"bgmap": [
 
-    },
-    "changeFloor": { // 楼层转换事件；该事件不能和上面的events有冲突（同位置点），否则会被覆盖
-        "6,0": {"floorId": "sample3", "stair": "upFloor"},
-        "6,12": {"floorId": "sample2", "stair": "upFloor"}
-    },
-    "afterBattle": { // 战斗后可能触发的事件列表
-        "6,4": [ // 和黑暗大法师战斗结束
-            "\t[blackMagician]天真！你以为这样就能战胜我吗？",
-            {"type": "show", "loc": [7,5], "time": 500},
-            {"type": "update"}, // 更新地图显伤
-        ],
-        "7,5": [ // 和分身1的战斗
-            "\t[blackMagician]你打败的不过是我众多分身中的其中一个而已。",
-            {"type": "show", "loc": [5,4], "time": 500},
-            {"type": "update"}, // 更新地图显伤
-        ],
-        "5,4": [ // 和分身2的战斗
-            "\t[blackMagician]你的身体已经伤痕累累了，可我还留有着九成多的魔力。",
-            {"type": "show", "loc": [5,5], "time": 500},
-            {"type": "update"}, // 更新地图显伤
-        ],
-        "5,5": [ // 和分身3的战斗
-            "\t[blackMagician]顽固的家伙！放弃抵抗吧！",
-            {"type": "show", "loc": [7,4], "time": 500},
-            {"type": "update"}, // 更新地图显伤
-        ],
-        "7,4": [ // 和分身4的战斗
-            "\t[blackMagician]哈哈哈哈！我的灵魂远比你想象的强大！\n我即是永恒！",
-            {"type": "show", "loc": [6,3], "time": 500},
-            {"type": "trigger", "loc": [6,3]} // 显示大法师本尊
-        ],
-    },
-    "afterGetItem": { // 获得道具后可能触发的事件列表
+],
+"fgmap": [
 
-    },
-    "afterOpenDoor": { // 开完门后可能触发的事件列表
-
-    },
-    "cannotMove": { // 每个图块不可通行的方向
-        // 可以在这里定义每个点不能前往哪个方向，例如悬崖边不能跳下去
-        // "x,y": ["up", "left"], // (x,y)点不能往上和左走
-
-    },
-}
+],
+}
\ No newline at end of file
diff --git a/project/functions.js b/project/functions.js
index 74b7c227..13cf4cfc 100644
--- a/project/functions.js
+++ b/project/functions.js
@@ -1,63 +1,91 @@
-functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = 
+var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = 
 {
-"events":{
-////// 游戏开始前的一些初始化操作 //////
-"initGame": function() {
-	// 游戏开始前的一些初始化操作
+    "events": {
+        "resetGame": function (hero, hard, floorId, maps, values) {
+	// 重置整个游戏；此函数将在游戏开始时，或者每次读档时最先被调用
+	// hero：勇士信息；hard：难度；floorId：当前楼层ID；maps：地图信息；values：全局数值信息
 
-	// 根据flag来对道具进行修改
-	if (core.flags.bigKeyIsBox)
-		core.material.items.bigKey = {'cls': 'items', 'name': '钥匙盒'};
-	// 面前的墙？四周的墙？
-	if (core.flags.pickaxeFourDirections)
-		core.material.items.pickaxe.text = "可以破坏勇士四周的墙";
-	if (core.flags.bombFourDirections)
-		core.material.items.bomb.text = "可以炸掉勇士四周的怪物";
-	if (core.flags.snowFourDirections)
-		core.material.items.bomb.text = "可以将四周的熔岩变成平地";
-	if (core.flags.equipment) {
-		core.material.items.sword1.cls = 'constants';
-		core.material.items.sword2.cls = 'constants';
-		core.material.items.sword3.cls = 'constants';
-		core.material.items.sword4.cls = 'constants';
-		core.material.items.sword5.cls = 'constants';
-		core.material.items.shield1.cls = 'constants';
-		core.material.items.shield2.cls = 'constants';
-		core.material.items.shield3.cls = 'constants';
-		core.material.items.shield4.cls = 'constants';
-		core.material.items.shield5.cls = 'constants';
-	}
+	// 清除游戏数据
+	// 这一步会清空状态栏和全部画布内容，并删除所有动态创建的画布
+	core.clearStatus();
+	// 初始化status
+	core.status = core.clone(core.initStatus, function (name) {
+		return name != 'hero' && name != 'maps';
+	});
+	core.status.played = true;
+	// 初始化人物，图标，统计信息
+	core.status.hero = core.clone(hero);
+	core.events.setHeroIcon(core.getFlag('heroIcon', 'hero.png'), true);
+	core.control._initStatistics(core.animateFrame.totalTime);
+	core.status.hero.statistics.totalTime = core.animateFrame.totalTime =
+		Math.max(core.status.hero.statistics.totalTime, core.animateFrame.totalTime);
+	core.status.hero.statistics.start = null;
+	// 初始难度
+	core.status.hard = hard || "";
+	// 初始化地图
+	core.status.floorId = floorId;
+	core.status.maps = maps;
+	// 初始化怪物和道具
+	core.material.enemys = core.enemys.getEnemys();
+	core.material.items = core.items.getItems();
+	core.items._resetItems();
+	// 初始化全局数值和全局开关
+	core.values = core.clone(core.data.values);
+	for (var key in values || {})
+		core.values[key] = values[key];
+	core.flags = core.clone(core.data.flags);
+	var globalFlags = core.getFlag("globalFlags", {});
+	for (var key in globalFlags)
+		core.flags[key] = globalFlags[key];
+	core._init_sys_flags();
+	// 初始化界面，状态栏等
+	core.resize();
+	core.updateGlobalAttribute();
+	// 状态栏是否显示
+	if (core.hasFlag('hideStatusBar'))
+		core.hideStatusBar(core.hasFlag('showToolbox'));
+	else
+		core.showStatusBar();
+	// 隐藏右下角的音乐按钮
+	core.dom.musicBtn.style.display = 'none';
 },
-////// 不同难度分别设置初始属性 //////
-"setInitData":function (hard) {
+        "setInitData": function () {
 	// 不同难度分别设置初始属性
-	if (hard=='Easy') { // 简单难度
+	if (core.status.hard == 'Easy') { // 简单难度
 		core.setFlag('hard', 1); // 可以用flag:hard来获得当前难度
 		// 可以在此设置一些初始福利，比如设置初始生命值可以调用：
 		// core.setStatus("hp", 10000);
 		// 赠送一把黄钥匙可以调用
 		// core.setItem("yellowKey", 1);
 	}
-	if (hard=='Normal') { // 普通难度
+	if (core.status.hard == 'Normal') { // 普通难度
 		core.setFlag('hard', 2); // 可以用flag:hard来获得当前难度
 	}
-	if (hard=='Hard') { // 困难难度
+	if (core.status.hard == 'Hard') { // 困难难度
 		core.setFlag('hard', 3); // 可以用flag:hard来获得当前难度
 	}
-	if (hard=='Hell') { // 噩梦难度
+	if (core.status.hard == 'Hell') { // 噩梦难度
 		core.setFlag('hard', 4); // 可以用flag:hard来获得当前难度
 	}
-	core.events.afterLoadData();
+
+	// 设置已经到过的楼层
+	core.setFlag("__visited__", {});
+
+	core.updateEnemys();
 },
-////// 游戏获胜事件 //////
-"win" : function(reason, norank) {
+        "win": function(reason, norank) {
 	// 游戏获胜事件 
 	core.ui.closePanel();
-	var replaying = core.status.replay.replaying;
-	core.stopReplay();
+	var replaying = core.isReplaying();
+	if (replaying) core.stopReplay();
 	core.waitHeroToStop(function() {
-		core.removeGlobalAnimate(0,0,true);
 		core.clearMap('all'); // 清空全地图
+		core.deleteAllCanvas(); // 删除所有创建的画布
+		core.dom.gif2.innerHTML = "";
+		// 请注意：
+		// 成绩统计时是按照hp进行上传并排名，因此光在这里改${status:hp}是无效的
+		// 如需按照其他的的分数统计方式，请先将hp设置为你的得分
+		// core.setStatus('hp', ...);
 		core.drawText([
 			"\t[" + (reason||"恭喜通关") + "]你的分数是${status:hp}。"
 		], function () {
@@ -65,11 +93,10 @@ functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a =
 		})
 	});
 },
-////// 游戏失败事件 //////
-"lose" : function(reason) {
+        "lose": function(reason) {
 	// 游戏失败事件
 	core.ui.closePanel();
-	var replaying = core.status.replay.replaying;
+	var replaying = core.isReplaying();
 	core.stopReplay();
 	core.waitHeroToStop(function() {
 		core.drawText([
@@ -79,102 +106,214 @@ functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a =
 		});
 	})
 },
-////// 转换楼层结束的事件 //////
-"afterChangeFloor" : function (floorId) {
-	// 转换楼层结束的事件
-	if (!core.hasFlag("visited_"+floorId)) {
-		core.insertAction(core.floors[floorId].firstArrive);
-		core.setFlag("visited_"+floorId, true);
+        "changingFloor": function (floorId, heroLoc, fromLoad) {
+	// 正在切换楼层过程中执行的操作；此函数的执行时间是“屏幕完全变黑“的那一刻
+	// floorId为要切换到的楼层ID；heroLoc表示勇士切换到的位置；fromLoad表示是否是从读档造成的切换
+
+	// ---------- 此时还没有进行切换，当前floorId还是原来的 ---------- //
+	var currentId = core.status.floorId || null; // 获得当前的floorId，可能为null
+	// 可以对currentId进行判定，比如删除某些自定义图层等
+	// if (currentId == 'MT0') {
+	//     core.deleteAllCanvas();
+	// }
+	
+	// 重置画布尺寸
+	core.maps.resizeMap(floorId);
+	// 检查重生怪并重置
+	if (!fromLoad) {
+		core.status.maps[floorId].blocks.forEach(function(block) {
+			if (block.disable && core.enemys.hasSpecial(block.event.id, 23)) {
+				block.disable = false;
+			}
+		});
+	}
+	// 设置勇士的位置
+	core.status.hero.loc = heroLoc;
+	core.control.gatherFollowers();
+
+	// ---------- 重绘新地图；这一步将会设置core.status.floorId ---------- //
+	core.drawMap(floorId);
+	
+	// 切换楼层BGM
+	if (core.status.maps[floorId].bgm) {
+		var bgm = core.status.maps[floorId].bgm;
+		if (bgm instanceof Array) bgm = bgm[0];
+		core.playBgm(bgm);
+	}
+	// 更改画面色调
+	var color = core.getFlag('__color__', null);
+	if (!color && core.status.maps[floorId].color)
+		color = core.status.maps[floorId].color;
+	core.clearMap('curtain');
+	core.status.curtainColor = color;
+	if (color) core.fillRect('curtain', 0, 0, core.__PIXELS__, core.__PIXELS__, core.arrayToRGBA(color));
+	// 更改天气
+	var weather = core.getFlag('__weather__', null);
+	if (!weather && core.status.maps[floorId].weather)
+		weather = core.status.maps[floorId].weather;
+	if (weather)
+		core.setWeather(weather[0], weather[1]);
+	else core.setWeather();
+
+	// ...可以新增一些其他内容，比如创建个画布在右上角显示什么内容等等
+
+},
+        "afterChangeFloor": function (floorId, fromLoad) {
+	// 转换楼层结束的事件；此函数会在整个楼层切换完全结束后再执行
+	// floorId是切换到的楼层；fromLoad若为true则代表是从读档行为造成的楼层切换
+
+	// 如果是读档，则进行检查（是否需要恢复事件）
+	if (fromLoad) {
+		core.events.recoverEvents(core.getFlag("__events__"));
+		core.removeFlag("__events__");
+	} else {
+		// 每次抵达楼层执行的事件
+		core.insertAction(core.floors[floorId].eachArrive);
+
+		// 首次抵达楼层时执行的事件（后插入，先执行）
+		if (!core.hasVisitedFloor(floorId)) {
+			core.insertAction(core.floors[floorId].firstArrive);
+			core.visitFloor(floorId);
+		}
 	}
 },
-////// 加点事件 //////
-"addPoint" : function (enemy) {
-	// 加点事件
-	var point = enemy.point;
-	if (!core.flags.enableAddPoint || !core.isset(point) || point<=0) return [];
+        "flyTo": function (toId, callback) {
+	// 楼层传送器的使用，从当前楼层飞往toId
+	// 如果不能飞行请返回false
 
-	// 加点，返回一个choices事件
-	return [
-		{"type": "choices",
-			"choices": [
-				{"text": "攻击+"+(1*point), "action": [
-					{"type": "setValue", "name": "status:atk", "value": "status:atk+"+(1*point)}
-				]},
-				{"text": "防御+"+(2*point), "action": [
-					{"type": "setValue", "name": "status:def", "value": "status:def+"+(2*point)}
-				]},
-				{"text": "生命+"+(200*point), "action": [
-					{"type": "setValue", "name": "status:hp", "value": "status:hp+"+(200*point)}
-				]},
-			]
-		}
-	];
+	var fromId = core.status.floorId;
+
+	// 检查能否飞行
+	if (!core.status.maps[fromId].canFlyTo || !core.status.maps[toId].canFlyTo) {
+		core.drawTip("无法飞往" + core.status.maps[toId].title + "！");
+		return false;
+	}
+
+	// 获得两个楼层的索引，以决定是上楼梯还是下楼梯
+	var fromIndex = core.floorIds.indexOf(fromId),
+		toIndex = core.floorIds.indexOf(toId);
+	var stair = fromIndex <= toIndex ? "downFloor" : "upFloor";
+	// 地下层：同层传送至上楼梯
+	if (fromIndex == toIndex && core.status.maps[fromId].underGround) stair = "upFloor";
+	// 记录录像
+	core.status.route.push("fly:" + toId);
+	// 传送
+	core.ui.closePanel();
+	core.changeFloor(toId, stair, null, null, callback);
+
+	return true;
 },
-////// 战斗结束后触发的事件 //////
-"afterBattle" : function(enemyId,x,y,callback) {
+        "beforeBattle": function (enemyId, x, y) {
+	// 战斗前触发的事件，可以加上一些战前特效（详见下面支援的例子）
+	// 此函数在“检测能否战斗和自动存档”【之后】执行。如果需要更早的战前事件，请在插件中覆重写 core.events.doSystemEvent 函数。
+	// 返回true则将继续战斗，返回false将不再战斗。
+
+	// ------ 支援技能 ------ //
+	if (x != null && y != null) {
+		var index = x + "," + y,
+			cache = core.status.checkBlock.cache[index] || {},
+			guards = cache.guards || [];
+		// 如果存在支援怪
+		if (guards.length > 0) {
+			// 记录flag，当前要参与支援的怪物
+			core.setFlag("__guards__" + x + "_" + y, guards);
+			var actions = [];
+			// 增加支援的特效动画（图块跳跃）
+			guards.forEach(function (g) {
+				core.push(actions, { "type": "jump", "from": [g[0], g[1]], "to": [x, y], "time": 300, "keep": false, "async": true });
+			});
+			core.push(actions, [
+				{ "type": "waitAsync" }, // 等待所有异步事件执行完毕
+				{ "type": "trigger", "loc": [x, y] } // 重要！重新触发本点事件（即重新触发战斗）
+			]);
+			core.insertAction(actions);
+			return false;
+		}
+	}
+
+	return true;
+},
+        "afterBattle": function (enemyId, x, y, callback) {
 	// 战斗结束后触发的事件
 
 	var enemy = core.material.enemys[enemyId];
 
-	var damage = core.enemys.getDamage(enemyId);
-	if (damage == null) damage = core.status.hero.hp+1;
+	// 播放战斗音效和动画
+	var equipAnimate = 'hand',
+		equipId = (core.status.hero.equipment || [])[0];
+	if (equipId && (core.material.items[equipId].equip || {}).animate)
+		equipAnimate = core.material.items[equipId].equip.animate;
+	// 检查equipAnimate是否存在SE，如果不存在则使用默认音效
+	if (!(core.material.animates[equipAnimate] || {}).se)
+		core.playSound('attack.mp3');
+	// 强制战斗的战斗动画
+	core.drawAnimate(equipAnimate, x != null ? x : core.getHeroLoc('x'), y != null ? y : core.getHeroLoc('y'));
+
+	var damage = core.enemys.getDamage(enemyId, x, y);
+	if (damage == null) damage = core.status.hero.hp + 1;
 
 	// 扣减体力值
 	core.status.hero.hp -= damage;
 
 	// 记录
 	core.status.hero.statistics.battleDamage += damage;
+	core.status.hero.statistics.battle++;
 
-	if (core.status.hero.hp<=0) {
-		core.status.hero.hp=0;
+	if (core.status.hero.hp <= 0) {
+		core.status.hero.hp = 0;
 		core.updateStatusBar();
 		core.events.lose('战斗失败');
 		return;
 	}
-	// 获得金币和经验
-	var money = enemy.money;
-	if (core.hasItem('coin')) money *= 2;
-	if (core.hasFlag('curse')) money=0;
-	core.status.hero.money += money;
-	var experience =enemy.experience;
-	if (core.hasFlag('curse')) experience=0;
-	core.status.hero.experience += experience;
-	var hint = "打败 " + enemy.name;
-	if (core.flags.enableMoney)
-		hint += "，金币+" + money;
-	if (core.flags.enableExperience)
-		hint += "，经验+" + experience;
-	core.drawTip(hint);
 
 	// 删除该块
-	if (core.isset(x) && core.isset(y)) {
+	var guards = []; // 支援
+	if (x != null && y != null) {
 		core.removeBlock(x, y);
+		guards = core.getFlag("__guards__" + x + "_" + y, []);
+		core.removeFlag("__guards__" + x + "_" + y);
 	}
 
-	// 毒衰咒的处理
+	// 获得金币和经验
+	var money = guards.reduce(function (curr, g) {
+		return curr + core.material.enemys[g[2]].money;
+	}, enemy.money);
+	if (core.hasItem('coin')) money *= 2;
+	if (core.hasFlag('curse')) money = 0;
+	core.status.hero.money += money;
+	core.status.hero.statistics.money += money;
+
+	var experience = guards.reduce(function (curr, g) {
+		return curr + core.material.enemys[g[2]].experience;
+	}, enemy.experience);
+	if (core.hasFlag('curse')) experience = 0;
+	core.status.hero.experience += experience;
+	core.status.hero.statistics.experience += experience;
+
+	var hint = "打败 " + enemy.name;
+	if (core.flags.enableMoney) hint += "，金币+" + money;
+	if (core.flags.enableExperience) hint += "，经验+" + experience;
+	core.drawTip(hint);
+
+	// 事件的处理
+	var todo = [];
+
 	var special = enemy.special;
 	// 中毒
-	if (core.enemys.hasSpecial(special, 12) && !core.hasFlag('poison')) {
-		core.setFlag('poison', true);
+	if (core.enemys.hasSpecial(special, 12)) {
+		core.push(todo, [{ "type": "insert", "name": "毒衰咒处理", "args": [0] }]);
 	}
 	// 衰弱
-	if (core.enemys.hasSpecial(special, 13) && !core.hasFlag('weak')) {
-		core.setFlag('weak', true);
-		var weakValue = core.values.weakValue;
-		var weakAtk = weakValue>=1?weakValue:Math.floor(weakValue*core.status.hero.atk);
-		var weakDef = weakValue>=1?weakValue:Math.floor(weakValue*core.status.hero.def);
-		core.setFlag('weakAtk', weakAtk);
-		core.setFlag('weakDef', weakDef);
-		core.status.hero.atk-=weakAtk;
-		core.status.hero.def-=weakDef;
+	if (core.enemys.hasSpecial(special, 13)) {
+		core.push(todo, [{ "type": "insert", "name": "毒衰咒处理", "args": [1] }]);
 	}
 	// 诅咒
-	if (core.enemys.hasSpecial(special, 14) && !core.hasFlag('curse')) {
-		core.setFlag('curse', true);
+	if (core.enemys.hasSpecial(special, 14)) {
+		core.push(todo, [{ "type": "insert", "name": "毒衰咒处理", "args": [2] }]);
 	}
 	// 仇恨属性：减半
 	if (core.flags.hatredDecrease && core.enemys.hasSpecial(special, 17)) {
-		core.setFlag('hatred', parseInt(core.getFlag('hatred', 0)/2));
+		core.setFlag('hatred', Math.floor(core.getFlag('hatred', 0) / 2));
 	}
 	// 自爆
 	if (core.enemys.hasSpecial(special, 19)) {
@@ -182,99 +321,92 @@ functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a =
 	}
 	// 退化
 	if (core.enemys.hasSpecial(special, 21)) {
-		core.status.hero.atk -= (enemy.atkValue||0);
-		core.status.hero.def -= (enemy.defValue||0);
-		if (core.status.hero.atk<0) core.status.hero.atk=0;
-		if (core.status.hero.def<0) core.status.hero.def=0;
+		core.status.hero.atk -= (enemy.atkValue || 0);
+		core.status.hero.def -= (enemy.defValue || 0);
+		if (core.status.hero.atk < 0) core.status.hero.atk = 0;
+		if (core.status.hero.def < 0) core.status.hero.def = 0;
 	}
 	// 增加仇恨值
-	core.setFlag('hatred', core.getFlag('hatred',0)+core.values.hatred);
+	core.setFlag('hatred', core.getFlag('hatred', 0) + core.values.hatred);
+
+	// 战后的技能处理，比如扣除魔力值
+	if (core.flags.enableSkill) {
+		// 检测当前开启的技能类型
+		var skill = core.getFlag('skill', 0);
+		if (skill == 1) { // 技能1：二倍斩
+			core.status.hero.mana -= 5; // 扣除5点魔力值
+		}
+		// 关闭技能
+		core.setFlag('skill', 0);
+		core.setFlag('skillName', '无');
+	}
 	core.updateStatusBar();
 
-
-	// 事件的处理
-	var todo = [];
-	// 如果不为阻击，且该点存在，且有事件
-	if (!core.enemys.hasSpecial(special, 18) && core.isset(x) && core.isset(y)) {
-		var event = core.floors[core.status.floorId].afterBattle[x+","+y];
-		if (core.isset(event)) {
-			// 插入事件
-			core.unshift(todo, event);
-		}
-	}
 	// 如果有加点
 	var point = core.material.enemys[enemyId].point;
-	if (core.isset(point) && point>0) {
-		core.unshift(todo, core.events.addPoint(core.material.enemys[enemyId]));
+	if (core.flags.enableAddPoint && point > 0) {
+		core.push(todo, [{ "type": "insert", "name": "加点事件", "args": [point] }]);
 	}
 
+	// 如果该点存在事件 -- V2.5.4 以后阻击怪也可以有战后事件了
+	core.push(todo, core.floors[core.status.floorId].afterBattle[x + "," + y]);
+
 	// 在这里增加其他的自定义事件需求
 	/*
 	if (enemyId=='xxx') {
-	    core.unshift(todo, [
-	        {"type": "...", ...},
-        ]);
+		core.push(todo, [
+			{"type": "...", ...},
+		]);
 	}
 	*/
 
 	// 如果事件不为空，将其插入
-	if (todo.length>0) {
-		core.events.insertAction(todo,x,y);
-	}
+	if (todo.length > 0) core.insertAction(todo, x, y);
 
 	// 如果已有事件正在处理中
-	if (core.status.event.id == null) {
+	if (core.status.event.id == null)
 		core.continueAutomaticRoute();
-	}
-	else {
+	else
 		core.clearContinueAutomaticRoute();
-	}
-	if (core.isset(callback)) callback();
+
+	if (callback) callback();
 
 },
-////// 开一个门后触发的事件 //////
-"afterOpenDoor" : function(doorId,x,y,callback) {
+        "afterOpenDoor": function (doorId, x, y, callback) {
 	// 开一个门后触发的事件
-	
+
 	var todo = [];
-	if (core.isset(x) && core.isset(y)) {
-		var event = core.floors[core.status.floorId].afterOpenDoor[x+","+y];
-		if (core.isset(event)) {
-			core.unshift(todo, event);
-		}
-	}
+	var event = core.floors[core.status.floorId].afterOpenDoor[x + "," + y];
+	if (event) core.unshift(todo, event);
 
-	if (todo.length>0) {
-		core.events.insertAction(todo,x,y);
-	}
+	if (todo.length > 0) core.insertAction(todo, x, y);
 
-	if (core.status.event.id == null) {
+	if (core.status.event.id == null)
 		core.continueAutomaticRoute();
-	}
-	else {
+	else
 		core.clearContinueAutomaticRoute();
-	}
-	if (core.isset(callback)) callback();
+
+	if (callback) callback();
 },
-////// 改变亮灯之后，可以触发的事件 //////
-"afterChangeLight" : function(x,y) {
+        "afterGetItem": function (itemId, x, y, callback) {
+	// 获得一个道具后触发的事件
+	core.playSound('item.mp3');
+
+	var todo = [];
+	var event = core.floors[core.status.floorId].afterGetItem[x + "," + y];
+	if (event) core.unshift(todo, event);
+
+	if (todo.length > 0) core.insertAction(todo, x, y);
+
+	if (callback) callback();
+},
+        "afterChangeLight": function(x,y) {
 	// 改变亮灯之后，可以触发的事件
 
 },
-////// 推箱子后的事件 //////
-"afterPushBox" : function () {
+        "afterPushBox": function () {
 	// 推箱子后的事件
-
-	var noBoxLeft = function () {
-		// 地图上是否还存在未推到的箱子，如果不存在则返回true，存在则返回false
-		for (var i=0;i<core.status.thisMap.blocks.length;i++) {
-			var block=core.status.thisMap.blocks[i];
-			if (core.isset(block.event) && block.event.id=='box') return false;
-		}
-		return true;
-	}
-
-	if (noBoxLeft()) {
+	if (core.searchBlock('box').length == 0) {
 		// 可以通过if语句来进行开门操作
 		/*
 		if (core.status.floorId=='xxx') { // 在某个楼层
@@ -285,8 +417,7 @@ functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a =
 		*/
 	}
 },
-////// 使用炸弹/圣锤后的事件 //////
-"afterUseBomb" : function () {
+        "afterUseBomb": function () {
 	// 使用炸弹/圣锤后的事件
 
 	// 这是一个使用炸弹也能开门的例子
@@ -301,21 +432,21 @@ functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a =
 	*/
 
 },
-////// 即将存档前可以执行的操作 //////
-"beforeSaveData" : function(data) {
-	// 即将存档前可以执行的操作
+        "canUseQuickShop": function(shopId) {
+	// 当前能否使用某个快捷商店
+	// shopId：快捷商店ID
+	// 如果返回一个字符串，表示不能，字符串为不能使用的提示
+	// 返回null代表可以使用
 
-},
-////// 读档事件后，载入事件前，可以执行的操作 //////
-"afterLoadData" : function(data) {
-	// 读档事件后，载入事件前，可以执行的操作
-	// 怪物数据的动态修改迁移到了“脚本编辑 - updateEnemys”中，详见文档说明
+	// 检查当前楼层的canUseQuickShop选项是否为false
+	if (core.status.thisMap.canUseQuickShop === false)
+		return '当前楼层不能使用快捷商店。';
 
-	core.enemys.updateEnemys();
+	return null;
 }
-},
-"enemys": {
-"getSpecials" : function() {
+    },
+    "enemys": {
+        "getSpecials": function () {
 	// 获得怪物的特殊属性，每一行定义一个特殊属性。
 	// 分为三项，第一项为该特殊属性的数字，第二项为特殊属性的名字，第三项为特殊属性的描述
 	// 可以直接写字符串，也可以写个function将怪物传进去
@@ -325,47 +456,191 @@ functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a =
 		[3, "坚固", "勇士每回合最多只能对怪物造成1点伤害"],
 		[4, "2连击", "怪物每回合攻击2次"],
 		[5, "3连击", "怪物每回合攻击3次"],
-		[6, function(enemy) {return (enemy.n||4)+"连击";}, function(enemy) {return "怪物每回合攻击"+(enemy.n||4)+"次";}],
-		[7, "破甲", "战斗前，怪物附加角色防御的"+Math.floor(100*core.values.breakArmor||0)+"%作为伤害"],
-		[8, "反击", "战斗时，怪物每回合附加角色攻击的"+Math.floor(100*core.values.counterAttack||0)+"%作为伤害，无视角色防御"],
-		[9, "净化", "战斗前，怪物附加勇士魔防的"+core.values.purify+"倍作为伤害"],
+		[6, function (enemy) { return (enemy.n || 4) + "连击"; }, function (enemy) { return "怪物每回合攻击" + (enemy.n || 4) + "次"; }],
+		[7, "破甲", "战斗前，怪物附加角色防御的" + Math.floor(100 * core.values.breakArmor || 0) + "%作为伤害"],
+		[8, "反击", "战斗时，怪物每回合附加角色攻击的" + Math.floor(100 * core.values.counterAttack || 0) + "%作为伤害，无视角色防御"],
+		[9, "净化", "战斗前，怪物附加勇士魔防的" + core.values.purify + "倍作为伤害"],
 		[10, "模仿", "怪物的攻防和勇士攻防相等"],
-		[11, "吸血", function (enemy) {return "战斗前，怪物首先吸取角色的"+Math.floor(100*enemy.value||0)+"%生命作为伤害"+(enemy.add?"，并把伤害数值加到自身生命上":"");}],
-		[12, "中毒", "战斗后，勇士陷入中毒状态，每一步损失生命"+core.values.poisonDamage+"点"],
-		[13, "衰弱", "战斗后，勇士陷入衰弱状态，攻防暂时下降"+(core.values.weakValue>=1?core.values.weakValue+"点":parseInt(core.values.weakValue*100)+"%")],
+		[11, "吸血", function (enemy) { return "战斗前，怪物首先吸取角色的" + Math.floor(100 * enemy.value || 0) + "%生命（约" + Math.floor((enemy.value || 0) * core.getStatus('hp')) + "点）作为伤害" + (enemy.add ? "，并把伤害数值加到自身生命上" : ""); }],
+		[12, "中毒", "战斗后，勇士陷入中毒状态，每一步损失生命" + core.values.poisonDamage + "点"],
+		[13, "衰弱", "战斗后，勇士陷入衰弱状态，攻防暂时下降" + (core.values.weakValue >= 1 ? core.values.weakValue + "点" : parseInt(core.values.weakValue * 100) + "%")],
 		[14, "诅咒", "战斗后，勇士陷入诅咒状态，战斗无法获得金币和经验"],
-		[15, "领域", function (enemy) {return "经过怪物周围"+(enemy.range||1)+"格时自动减生命"+(enemy.value||0)+"点";}],
+		[15, "领域", function (enemy) { return "经过怪物周围" + (enemy.zoneSquare ? "九宫格" : "十字") + "范围内" + (enemy.range || 1) + "格时自动减生命" + (enemy.value || 0) + "点"; }],
 		[16, "夹击", "经过两只相同的怪物中间，勇士生命值变成一半"],
-		[17, "仇恨", "战斗前，怪物附加之前积累的仇恨值作为伤害"+(core.flags.hatredDecrease?"；战斗后，释放一半的仇恨值":"")+"。（每杀死一个怪物获得"+(core.values.hatred||0)+"点仇恨值）"],
-		[18, "阻击", function (enemy) {return "经过怪物的十字领域时自动减生命"+(enemy.value||0)+"点，同时怪物后退一格";}],
+		[17, "仇恨", "战斗前，怪物附加之前积累的仇恨值作为伤害" + (core.flags.hatredDecrease ? "；战斗后，释放一半的仇恨值" : "") + "。（每杀死一个怪物获得" + (core.values.hatred || 0) + "点仇恨值）"],
+		[18, "阻击", function (enemy) { return "经过怪物的十字领域时自动减生命" + (enemy.value || 0) + "点，同时怪物后退一格"; }],
 		[19, "自爆", "战斗后勇士的生命值变成1"],
 		[20, "无敌", "勇士无法打败怪物，除非拥有十字架"],
-		[21, "退化", function (enemy) {return "战斗后勇士永久下降"+(enemy.atkValue||0)+"点攻击和"+(enemy.defValue||0)+"点防御";}],
-		[22, "固伤", function (enemy) {return "战斗前，怪物对勇士造成"+(enemy.damage||0)+"点固定伤害，无视勇士魔防。";}],
+		[21, "退化", function (enemy) { return "战斗后勇士永久下降" + (enemy.atkValue || 0) + "点攻击和" + (enemy.defValue || 0) + "点防御"; }],
+		[22, "固伤", function (enemy) { return "战斗前，怪物对勇士造成" + (enemy.damage || 0) + "点固定伤害，无视勇士魔防。"; }],
 		[23, "重生", "怪物被击败后，角色转换楼层则怪物将再次出现"],
-		[24, "激光", function (enemy) {return "经过怪物同行或同列时自动减生命"+(enemy.value||0)+"点";}]
+		[24, "激光", function (enemy) { return "经过怪物同行或同列时自动减生命" + (enemy.value || 0) + "点"; }],
+		[25, "光环", function (enemy) { return "同楼层所有怪物生命提升" + (enemy.value || 0) + "%，攻击提升" + (enemy.atkValue || 0) + "%，防御提升" + (enemy.defValue || 0) + "%，" + (enemy.add ? "可叠加" : "不可叠加"); }],
+		[26, "支援", "当周围一圈的怪物受到攻击时将上前支援，并组成小队战斗。"],
+		[27, "捕捉", "当走到怪物周围十字时会强制进行战斗。"]
 	];
 },
-"getDamageInfo" : function (enemy, hero_hp, hero_atk, hero_def, hero_mdef) {
-	// 获得战斗伤害信息（实际伤害计算函数）
+        "getEnemyInfo": function (enemy, hero, x, y, floorId) {
+	// 获得某个怪物变化后的数据；该函数将被伤害计算和怪物手册使用
+	// 例如：坚固、模仿、仿攻等等
+	// 
+	// 参数说明：
+	// enemy：该怪物信息
+	// hero_hp,hero_atk,hero_def,hero_mdef：勇士的生命攻防魔防数据
+	// x,y：该怪物的坐标（查看手册和强制战斗时为undefined）
+	// floorId：该怪物所在的楼层
+	// 后面三个参数主要是可以在光环等效果上可以适用（也可以按需制作部分范围光环效果）
+	floorId = floorId || core.status.floorId;
+	var hero_hp = core.getRealStatusOrDefault(hero, 'hp'),
+		hero_atk = core.getRealStatusOrDefault(hero, 'atk'),
+		hero_def = core.getRealStatusOrDefault(hero, 'def'),
+		hero_mdef = core.getRealStatusOrDefault(hero, 'mdef');
+
+	var mon_hp = enemy.hp,
+		mon_atk = enemy.atk,
+		mon_def = enemy.def,
+		mon_special = enemy.special;
+	var mon_money = enemy.money,
+		mon_experience = enemy.experience,
+		mon_point = enemy.point;
+	// 模仿
+	if (core.hasSpecial(mon_special, 10)) {
+		mon_atk = hero_atk;
+		mon_def = hero_def;
+	}
+	// 坚固
+	if (core.hasSpecial(mon_special, 3) && mon_def < hero_atk - 1) {
+		mon_def = hero_atk - 1;
+	}
+
+	// 光环检查
+	// 从V2.5.4开始，对光环效果增加缓存，以解决多次重复计算的问题，从而大幅提升运行效率。
+	// 检查当前楼层所有光环怪物（数字25）
+	var hp_buff = 0,
+		atk_buff = 0,
+		def_buff = 0,
+		cnt = 0;
+	// ------ 支援 ------
+	var guards = [];
+	// 检查光环缓存
+	var index = x != null && y != null ? (x + "," + y) : "floor";
+	if (!core.status.checkBlock) core.status.checkBlock = {};
+	if (!core.status.checkBlock.cache) core.status.checkBlock.cache = {};
+	var cache = core.status.checkBlock.cache[index];
+	if (!cache) {
+		// 没有该点的缓存，则遍历每个图块
+		core.status.maps[floorId].blocks.forEach(function (block) {
+			if (!block.disable) {
+				// 获得该图块的ID
+				var id = block.event.id,
+					enemy = core.material.enemys[id];
+				// 检查是不是怪物，且是否拥有该特殊属性
+				if (enemy && core.hasSpecial(enemy.special, 25)) {
+					// 检查是否可叠加
+					if (enemy.add || cnt == 0) {
+						hp_buff += enemy.value || 0;
+						atk_buff += enemy.atkValue || 0;
+						def_buff += enemy.defValue || 0;
+						cnt++;
+					}
+				}
+				// 检查【支援】技能
+				if (enemy && core.hasSpecial(enemy.special, 26) &&
+					// 检查支援条件，坐标存在，距离为1，且不能是自己
+					// 其他类型的支援怪，比如十字之类的话.... 看着做是一样的
+					x != null && y != null && Math.abs(block.x - x) <= 1 && Math.abs(block.y - y) <= 1 && !(x == block.x && y == block.y)) {
+					// 记录怪物的x,y，ID
+					guards.push([block.x, block.y, id]);
+				}
+
+				// TODO：如果有其他类型光环怪物在这里仿照添加检查
+			}
+		});
+
+		core.status.checkBlock.cache[index] = { "hp_buff": hp_buff, "atk_buff": atk_buff, "def_buff": def_buff, "guards": guards };
+	} else {
+		// 直接使用缓存数据
+		hp_buff = cache.hp_buff;
+		atk_buff = cache.atk_buff;
+		def_buff = cache.def_buff;
+		guards = cache.guards;
+	}
+
+	// 增加比例；如果要增加数值可以直接在这里修改
+	mon_hp *= (1 + hp_buff / 100);
+	mon_atk *= (1 + atk_buff / 100);
+	mon_def *= (1 + def_buff / 100);
+
+
+	// TODO：可以在这里新增其他的怪物数据变化
+	// 比如仿攻（怪物攻击不低于勇士攻击）：
+	// if (core.hasSpecial(mon_special, 27) && mon_atk < hero_atk) {
+	//     mon_atk = hero_atk;
+	// }
+	// 也可以按需增加各种自定义内容（比如幻塔的魔杖效果等）
+
+	return {
+		"hp": Math.floor(mon_hp),
+		"atk": Math.floor(mon_atk),
+		"def": Math.floor(mon_def),
+		"money": Math.floor(mon_money),
+		"experience": Math.floor(mon_experience),
+		"point": Math.floor(mon_point),
+		"special": mon_special,
+		"guards": guards, // 返回支援情况
+	};
+},
+        "getDamageInfo": function (enemy, hero, x, y, floorId) {
+	// 获得战斗伤害信息（实际伤害计算函数）
+	// 
+	// 参数说明：
+	// enemy：该怪物信息
+	// hero：勇士的当前数据；如果对应项不存在则会从core.status.hero中取。
+	// x,y：该怪物的坐标（查看手册和强制战斗时为undefined）
+	// floorId：该怪物所在的楼层
+	// 后面三个参数主要是可以在光环等效果上可以适用
+	floorId = floorId || core.status.floorId;
+
+	var hero_hp = core.getRealStatusOrDefault(hero, 'hp'),
+		hero_atk = core.getRealStatusOrDefault(hero, 'atk'),
+		hero_def = core.getRealStatusOrDefault(hero, 'def'),
+		hero_mdef = core.getRealStatusOrDefault(hero, 'mdef'),
+		origin_hero_hp = hero_hp,
+		origin_hero_atk = hero_atk,
+		origin_hero_def = hero_def;
 
-	// 怪物生命，怪物攻击、防御、特殊属性
-	var mon_hp = enemy.hp, mon_atk = enemy.atk, mon_def = enemy.def, mon_special = enemy.special;
 	// 勇士的负属性都按0计算
-	hero_hp=Math.max(0, hero_hp); hero_atk=Math.max(0, hero_atk); hero_def=Math.max(0, hero_def); hero_mdef=Math.max(0, hero_mdef);
+	hero_hp = Math.max(0, hero_hp);
+	hero_atk = Math.max(0, hero_atk);
+	hero_def = Math.max(0, hero_def);
+	hero_mdef = Math.max(0, hero_mdef);
+
+	// 怪物的各项数据
+	// 对坚固模仿等处理扔到了脚本编辑-getEnemyInfo之中
+	var enemyInfo = core.enemys.getEnemyInfo(enemy, hero, x, y, floorId);
+	var mon_hp = enemyInfo.hp,
+		mon_atk = enemyInfo.atk,
+		mon_def = enemyInfo.def,
+		mon_special = enemyInfo.special;
+
+	// 技能的处理
+	if (core.getFlag('skill', 0) == 1) { // 开启了技能1：二倍斩
+		hero_atk *= 2; // 计算时攻击力翻倍	
+	}
 
 	// 如果是无敌属性，且勇士未持有十字架
-	if (this.hasSpecial(mon_special, 20) && !core.hasItem("cross"))
+	if (core.hasSpecial(mon_special, 20) && !core.hasItem("cross"))
 		return null; // 不可战斗
 
 	// 战前造成的额外伤害（可被魔防抵消）
 	var init_damage = 0;
 
 	// 吸血
-	if (this.hasSpecial(mon_special, 11)) {
+	if (core.hasSpecial(mon_special, 11)) {
 		var vampire_damage = hero_hp * enemy.value;
 
 		// 如果有神圣盾免疫吸血等可以在这里写
+		// 也可以用hasItem和hasEquip来判定装备
 		// if (core.hasFlag('shield5')) vampire_damage = 0;
 
 		vampire_damage = Math.floor(vampire_damage) || 0;
@@ -376,49 +651,73 @@ functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a =
 		init_damage += vampire_damage;
 	}
 
-	// 模仿
-	if (this.hasSpecial(mon_special, 10)) {
-		mon_atk = hero_atk;
-		mon_def = hero_def;
-	}
-	// 坚固
-	if (this.hasSpecial(mon_special, 3) && mon_def < hero_atk - 1)
-		mon_def = hero_atk - 1;
-
-	// 检查是否破防；否则直接返回不可战斗
-	if (hero_atk <= mon_def) return null;
-
 	// 每回合怪物对勇士造成的战斗伤害
 	var per_damage = mon_atk - hero_def;
 	// 魔攻：战斗伤害就是怪物攻击力
-	if (this.hasSpecial(mon_special, 2)) per_damage = mon_atk;
+	if (core.hasSpecial(mon_special, 2)) per_damage = mon_atk;
 	// 战斗伤害不能为负值
 	if (per_damage < 0) per_damage = 0;
 
 	// 2连击 & 3连击 & N连击
-	if (this.hasSpecial(mon_special, 4)) per_damage *= 2;
-	if (this.hasSpecial(mon_special, 5)) per_damage *= 3;
-	if (this.hasSpecial(mon_special, 6)) per_damage *= (enemy.n||4);
+	if (core.hasSpecial(mon_special, 4)) per_damage *= 2;
+	if (core.hasSpecial(mon_special, 5)) per_damage *= 3;
+	if (core.hasSpecial(mon_special, 6)) per_damage *= (enemy.n || 4);
 
 	// 每回合的反击伤害；反击是按照勇士的攻击次数来计算回合
 	var counterDamage = 0;
-	if (this.hasSpecial(mon_special, 8)) counterDamage += Math.floor(core.values.counterAttack * hero_atk);
+	if (core.hasSpecial(mon_special, 8)) counterDamage += Math.floor(core.values.counterAttack * hero_atk);
 
 	// 先攻
-	if (this.hasSpecial(mon_special, 1)) init_damage += per_damage;
+	if (core.hasSpecial(mon_special, 1)) init_damage += per_damage;
 
 	// 破甲
-	if (this.hasSpecial(mon_special, 7))
+	if (core.hasSpecial(mon_special, 7))
 		init_damage += Math.floor(core.values.breakArmor * hero_def);
 
 	// 净化
-	if (this.hasSpecial(mon_special, 9))
+	if (core.hasSpecial(mon_special, 9))
 		init_damage += Math.floor(core.values.purify * hero_mdef);
 
 	// 勇士每回合对怪物造成的伤害
-	var hero_per_damage = hero_atk - mon_def;
+	var hero_per_damage = Math.max(hero_atk - mon_def, 0);
+
+	// 如果没有破防，则不可战斗
+	if (hero_per_damage <= 0) return null;
+
 	// 勇士的攻击回合数；为怪物生命除以每回合伤害向上取整
 	var turn = Math.ceil(mon_hp / hero_per_damage);
+
+	// ------ 支援 ----- //
+	// 这个递归最好想明白为什么，flag:extra_turn是怎么用的
+	var guards = core.getFlag("__guards__" + x + "_" + y, enemyInfo.guards);
+	var guard_before_current_enemy = false; // ------ 支援怪是先打(true)还是后打(false)？
+	turn += core.getFlag("__extraTurn__", 0);
+	if (guards.length > 0) {
+		if (!guard_before_current_enemy) { // --- 先打当前怪物，记录当前回合数
+			core.setFlag("__extraTurn__", turn);
+		}
+		// 获得那些怪物组成小队战斗
+		for (var i = 0; i < guards.length; i++) {
+			var gx = guards[i][0],
+				gy = guards[i][1],
+				gid = guards[i][2];
+			// 递归计算支援怪伤害信息，这里不传x,y保证不会重复调用
+			// 这里的mdef传0，因为护盾应该只会被计算一次
+			var info = core.enemys.getDamageInfo(core.material.enemys[gid], { hp: origin_hero_hp, atk: origin_hero_atk, def: origin_hero_def, mdef: 0 });
+			if (info == null) { // 小队中任何一个怪物不可战斗，直接返回null
+				return null;
+			}
+			// 已经进行的回合数
+			core.setFlag("__extraTurn__", info.turn);
+			init_damage += info.damage;
+		}
+		if (guard_before_current_enemy) { // --- 先打支援怪物，增加当前回合数
+			turn += core.getFlag("__extraTurn__", 0);
+		}
+	}
+	core.removeFlag("__extraTurn__");
+	// ------ 支援END ------ //
+
 	// 最终伤害：初始伤害 + 怪物对勇士造成的伤害 + 反击伤害
 	var damage = init_damage + (turn - 1) * per_damage + turn * counterDamage;
 	// 再扣去魔防
@@ -426,21 +725,23 @@ functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a =
 
 	// 检查是否允许负伤
 	if (!core.flags.enableNegativeDamage)
-		damage=Math.max(0, damage);
+		damage = Math.max(0, damage);
 
 	return {
-		"mon_hp": mon_hp,
-		"mon_atk": mon_atk,
-		"mon_def": mon_def,
-		"init_damage": init_damage,
-		"per_damage": per_damage,
-		"hero_per_damage": hero_per_damage,
-		"turn": turn,
-		"damage": damage
+		"mon_hp": Math.floor(mon_hp),
+		"mon_atk": Math.floor(mon_atk),
+		"mon_def": Math.floor(mon_def),
+		"init_damage": Math.floor(init_damage),
+		"per_damage": Math.floor(per_damage),
+		"hero_per_damage": Math.floor(hero_per_damage),
+		"turn": Math.floor(turn),
+		"damage": Math.floor(damage)
 	};
 },
-"updateEnemys" : function () {
+        "updateEnemys": function () {
 	// 更新怪物数据，可以在这里对怪物属性和数据进行动态更新，详见文档——事件——怪物数据的动态修改
+	// 此函数执行时间：重新开始游戏、读档后、通过事件调用“更新怪物数据”时
+
 	// 比如下面这个例子，如果flag:xxx为真，则将绿头怪的攻击设为100，金币设为20
 	/*
 	if (core.hasFlag('xxx')) {
@@ -448,22 +749,674 @@ functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a =
 		core.material.enemys.greenSlime.money = 20;
 	}
 	*/
-	// 别忘了在事件中调用“更新怪物数据”事件！
 }
-},
-"ui":{
-////// 绘制“关于”界面 //////
-"drawAbout" : function() {
-	// 绘制“关于”界面
-	if (!core.isPlaying()) {
-		core.status.event = {'id': null, 'data': null};
-		core.dom.startPanel.style.display = 'none';
+    },
+    "actions": {
+        "onKeyUp": function (keyCode, altKey) {
+	// 键盘按键处理，可以在这里自定义快捷键列表
+	// keyCode：当前按键的keyCode（每个键的keyCode自行百度）
+	// altKey：Alt键是否被按下，为true代表同时按下了Alt键
+	// 可以在这里任意增加或编辑每个按键的行为
+
+	// 如果处于正在行走状态，则不处理
+	if (core.isMoving())
+		return;
+
+	// Alt+0~9，快捷换上套装
+	if (altKey && keyCode >= 48 && keyCode <= 57) {
+		core.items.quickLoadEquip(keyCode - 48);
+		return;
 	}
+
+	// 根据keyCode值来执行对应操作
+	switch (keyCode) {
+	case 27: // ESC：打开菜单栏
+		core.openSettings(true);
+		break;
+	case 88: // X：使用怪物手册
+		core.openBook(true);
+		break;
+	case 71: // G：使用楼传器
+		core.useFly(true);
+		break;
+	case 65: // A：读取自动存档（回退）
+		core.doSL("autoSave", "load");
+		break;
+	case 83: // S：存档
+		core.save(true);
+		break;
+	case 68: // D：读档
+		core.load(true);
+		break;
+	case 69: // E：打开光标
+		core.ui.drawCursor();
+		break;
+	case 84: // T：打开道具栏
+		core.openToolbox(true);
+		break;
+	case 81: // Q：打开装备栏
+		core.openEquipbox(true);
+		break;
+	case 90: // Z：转向
+		core.turnHero();
+		break;
+	case 75:
+	case 86: // V：打开快捷商店列表
+		core.openQuickShop(true);
+		break;
+	case 32: // SPACE：轻按
+		core.getNextItem();
+		break;
+	case 82: // R：回放录像
+		core.actions._clickSyncSave_replay();
+		break;
+	case 33:
+	case 34: // PgUp/PgDn：浏览地图
+		core.ui.drawMaps();
+		break;
+	case 77: // M：绘图模式
+		core.ui.drawPaint();
+		break;
+	case 66: // B：打开数据统计
+		core.ui.drawStatistics();
+		break;
+	case 72: // H：打开帮助页面
+		core.ui.drawHelp();
+		break;
+	case 78: // N：重新开始
+		core.confirmRestart();
+		break;
+	case 79: // O：查看工程
+		core.actions._clickGameInfo_openProject();
+		break;
+	case 80: // P：游戏主页
+		core.actions._clickGameInfo_openComments();
+		break;
+	case 49: // 快捷键1: 破
+		if (core.hasItem('pickaxe')) {
+			if (core.canUseItem('pickaxe')) {
+				core.status.route.push("key:49"); // 将按键记在录像中
+				core.useItem('pickaxe', true); // 第二个参数true代表该次使用道具是被按键触发的，使用过程不计入录像
+			} else {
+				core.drawTip('当前不能使用破墙镐');
+			}
+		}
+		break;
+	case 50: // 快捷键2: 炸
+		if (core.hasItem('bomb')) {
+			if (core.canUseItem('bomb')) {
+				core.status.route.push("key:50"); // 将按键记在录像中
+				core.useItem('bomb', true); // 第二个参数true代表该次使用道具是被按键触发的，使用过程不计入录像
+			} else {
+				core.drawTip('当前不能使用炸弹');
+			}
+		} else if (core.hasItem('hammer')) {
+			if (core.canUseItem('hammer')) {
+				core.status.route.push("key:50"); // 将按键记在录像中
+				core.useItem('hammer', true); // 第二个参数true代表该次使用道具是被按键触发的，使用过程不计入录像
+			} else {
+				core.drawTip('当前不能使用圣锤');
+			}
+
+		}
+		break;
+	case 51: // 快捷键3: 飞
+		if (core.hasItem('centerFly')) {
+			core.ui.drawCenterFly();
+		}
+		break;
+	case 52: // 快捷键4：破冰/冰冻/地震/上下楼器/... 其他道具依次判断
+		{
+			var list = ["icePickaxe", "snow", "earthquake", "upFly", "downFly", "jumpShoes", "lifeWand", "poisonWine", "weakWine", "curseWine", "superWine"];
+			for (var i = 0; i < list.length; i++) {
+				var itemId = list[i];
+				if (core.canUseItem(itemId)) {
+					core.status.route.push("key:52");
+					core.useItem(itemId, true);
+					break;
+				}
+			}
+		}
+		break;
+	case 55: // 快捷键7：绑定为轻按，方便手机版操作
+		core.getNextItem();
+		break;
+	case 118: // F7：开启debug模式
+		core.debug();
+		break;
+	case 87: // W：开启技能“二倍斩”
+		// 检测是否拥有“二倍斩”这个技能道具
+		if (core.hasItem('skill1')) {
+			core.status.route.push("key:87");
+			core.useItem('skill1', true);
+		}
+		break;
+	// 在这里可以任意新增或编辑已有的快捷键内容
+	/*
+	case 0: // 使用该按键的keyCode
+		// 还可以再判定altKey是否被按下，即 if (altKey) { ...
+
+		// ... 在这里写你要执行脚本
+		// **强烈建议所有新增的自定义快捷键均能给个对应的道具可点击，以方便手机端的行为**
+		if (core.hasItem('...')) {
+			core.status.route.push("key:0");
+			core.useItem('...', true); // 增加true代表该使用道具不计入录像
+		}
+
+		break;
+	*/
+	}
+
+}
+    },
+    "control": {
+        "saveData": function () {
+	// 存档操作，此函数应该返回“具体要存档的内容”
+
+	// 勇士和hash值（防改存档文件来作弊）
+	var hero = core.clone(core.status.hero),
+		hashCode = core.utils.hashCode(hero);
+	// 差异化存储values
+	var values = {};
+	for (var key in core.values) {
+		if (!core.same(core.values[key], core.data.values[key]))
+			values[key] = core.clone(core.values[key]);
+	}
+
+	// 要存档的内容
+	var data = {
+		'floorId': core.status.floorId,
+		'hero': hero,
+		'hard': core.status.hard,
+		'maps': core.maps.saveMap(),
+		'route': core.encodeRoute(core.status.route),
+		'values': values,
+		'shops': {},
+		'version': core.firstData.version,
+		"time": new Date().getTime(),
+		"hashCode": hashCode
+	};
+	// 设置商店次数
+	for (var shopId in core.status.shops) {
+		data.shops[shopId] = {
+			'times': core.status.shops[shopId].times || 0,
+			'visited': core.status.shops[shopId].visited || false
+		};
+	}
+
+	return data;
+},
+        "loadData": function (data, callback) {
+	// 读档操作；从存储中读取了内容后的行为
+
+	// 重置游戏和路线
+	core.resetGame(data.hero, data.hard, data.floorId, core.maps.loadMap(data.maps), data.values);
+	core.status.route = core.decodeRoute(data.route);
+	// 加载商店信息
+	for (var shopId in core.status.shops) {
+		if (data.shops[shopId]) {
+			core.status.shops[shopId].times = data.shops[shopId].times;
+			core.status.shops[shopId].visited = data.shops[shopId].visited;
+		}
+	}
+	// 文字属性，全局属性
+	core.status.textAttribute = core.getFlag('textAttribute', core.status.textAttribute);
+	var toAttribute = core.getFlag('globalAttribute', core.status.globalAttribute);
+	if (!core.same(toAttribute, core.status.globalAttribute)) {
+		core.status.globalAttribute = toAttribute;
+		core.updateGlobalAttribute();
+	}
+	// 重置音量
+	core.events.setVolume(core.getFlag("__volume__", 1), 0);
+	// 加载勇士图标
+	var icon = core.getFlag("heroIcon", "hero.png");
+	icon = core.getMappedName(icon);
+	if (core.material.images.images[icon]) {
+		core.material.images.hero.src = core.material.images.images[icon].src;
+		core.material.icons.hero.width = core.material.images.images[icon].width / 4;
+		core.material.icons.hero.height = core.material.images.images[icon].height / 4;
+	}
+	// 刷新怪物数据
+	core.updateEnemys();
+
+	// TODO：增加自己的一些读档处理
+
+	// 切换到对应的楼层
+	core.changeFloor(data.floorId, null, data.hero.loc, 0, function () {
+		// TODO：可以在这里设置读档后播放BGM
+		// if (core.getFlag("bgm", 0)==1) core.playBgm("bgm.mp3");
+
+		if (callback) callback();
+	}, true);
+},
+        "updateStatusBar": function () {
+	// 更新状态栏
+
+	// 检查等级
+	core.events.checkLvUp();
+
+	// 检查HP上限
+	if (core.flags.enableHPMax) {
+		core.setStatus('hp', Math.min(core.getStatus('hpmax'), core.getStatus('hp')));
+	}
+
+	// 设置楼层名
+	if (core.status.floorId) {
+		core.setStatusBarInnerHTML('floor', core.status.maps[core.status.floorId].name);
+	}
+
+	// 设置勇士名字和图标
+	core.setStatusBarInnerHTML('name', core.getStatus('name'));
+	// 设置等级名称
+	core.setStatusBarInnerHTML('lv', core.getLvName());
+
+	// 设置生命上限、生命值、攻防魔防金币和经验值
+	var statusList = ['hpmax', 'hp', 'mana', 'atk', 'def', 'mdef', 'money', 'experience'];
+	statusList.forEach(function (item) {
+		// 向下取整
+		core.status.hero[item] = Math.floor(core.status.hero[item]);
+		// 大数据格式化
+		core.setStatusBarInnerHTML(item, core.getRealStatus(item));
+	});
+
+	// 设置魔力值
+	if (core.flags.enableMana) {
+		// status:manamax 只有在非负时才生效。
+		if (core.status.hero.manamax != null && core.status.hero.manamax >= 0) {
+			core.status.hero.mana = Math.min(core.status.hero.mana, core.status.hero.manamax);
+			core.setStatusBarInnerHTML('mana', core.status.hero.mana + "/" + core.status.hero.manamax);
+		}
+		else {
+			core.setStatusBarInnerHTML("mana", core.status.hero.mana);
+		}
+	}
+	// 设置技能栏
+	if (core.flags.enableSkill) {
+		// 可以用flag:skill表示当前开启的技能类型，flag:skillName显示技能名；详见文档-个性化-技能塔的支持
+		core.setStatusBarInnerHTML('skill', core.getFlag('skillName', '无'));
+	}
+
+	// 可以在这里添加自己额外的状态栏信息，比如想攻击显示 +0.5 可以这么写：
+	// if (core.hasFlag('halfAtk')) core.setStatusBarInnerHTML('atk', core.statusBar.atk.innerText + "+0.5");
+
+	// 如果是自定义添加的状态栏，也需要在这里进行设置显示的数值
+
+	// 进阶
+	if (core.flags.enableLevelUp && core.status.hero.lv < core.firstData.levelUp.length) {
+		var need = core.calValue(core.firstData.levelUp[core.status.hero.lv].need);
+		if (core.flags.levelUpLeftMode)
+			core.setStatusBarInnerHTML('up', core.formatBigNumber(need - core.getStatus('experience')) || "");
+		else
+			core.setStatusBarInnerHTML('up', core.formatBigNumber(need) || "");
+	} else core.setStatusBarInnerHTML('up', "");
+
+	// 钥匙
+	var keys = ['yellowKey', 'blueKey', 'redKey'];
+	keys.forEach(function (key) {
+		core.setStatusBarInnerHTML(key, core.setTwoDigits(core.itemCount(key)));
+	});
+	// 毒衰咒
+	if (core.flags.enableDebuff) {
+		core.setStatusBarInnerHTML('poison', core.hasFlag('poison') ? "毒" : "");
+		core.setStatusBarInnerHTML('weak', core.hasFlag('weak') ? "衰" : "");
+		core.setStatusBarInnerHTML('curse', core.hasFlag('curse') ? "咒" : "");
+	}
+	// 破炸飞
+	if (core.flags.enablePZF) {
+		core.setStatusBarInnerHTML('pickaxe', "破" + core.itemCount('pickaxe'));
+		core.setStatusBarInnerHTML('bomb', "炸" + core.itemCount('bomb'));
+		core.setStatusBarInnerHTML('fly', "飞" + core.itemCount('centerFly'));
+	}
+
+	// 难度
+	core.statusBar.hard.innerHTML = core.status.hard;
+	// 自定义状态栏绘制
+	core.drawStatusBar();
+
+	// 更新阻激夹域的伤害值
+	core.updateCheckBlock();
+	// 更新全地图显伤
+	core.updateDamage();
+},
+        "updateCheckBlock": function (floorId) {
+	// 领域、夹击、阻击等的伤害值计算
+	floorId = floorId || core.status.floorId;
+	if (!floorId || !core.status.maps) return;
+
+	var width = core.floors[floorId].width,
+		height = core.floors[floorId].height;
+	var blocks = core.getMapBlocksObj(floorId);
+
+	var damage = {}, // 每个点的伤害值
+		type = {}, // 每个点的伤害类型
+		snipe = {}, // 每个点的阻击怪信息
+		ambush = {}; // 每个点的捕捉信息
+
+	// 计算血网和领域、阻击、激光的伤害，计算捕捉信息
+	for (var loc in blocks) {
+		var block = blocks[loc],
+			x = block.x,
+			y = block.y,
+			id = block.event.id,
+			enemy = core.material.enemys[id];
+
+		// 血网
+		if (id == 'lavaNet' && block.event.trigger == 'passNet' && !core.hasItem('shoes')) {
+			damage[loc] = (damage[loc] || 0) + core.values.lavaDamage;
+			type[loc] = "血网伤害";
+		}
+
+		// 领域
+		// 如果要防止领域伤害，可以直接简单的将 flag:no_zone 设为true
+		if (enemy && core.hasSpecial(enemy.special, 15) && !core.hasFlag('no_zone')) {
+			// 领域范围，默认为1
+			var range = enemy.range || 1;
+			// 是否是九宫格领域
+			var zoneSquare = false;
+			if (enemy.zoneSquare != null) zoneSquare = enemy.zoneSquare;
+			// 在范围内进行搜索，增加领域伤害值
+			for (var dx = -range; dx <= range; dx++) {
+				for (var dy = -range; dy <= range; dy++) {
+					if (dx == 0 && dy == 0) continue;
+					var nx = x + dx,
+						ny = y + dy,
+						currloc = nx + "," + ny;
+					if (nx < 0 || nx >= width || ny < 0 || ny >= height) continue;
+					// 如果是十字领域，则还需要满足 |dx|+|dy|<=range
+					if (!zoneSquare && Math.abs(dx) + Math.abs(dy) > range) continue;
+					damage[currloc] = (damage[currloc] || 0) + (enemy.value || 0);
+					type[currloc] = "领域伤害";
+				}
+			}
+		}
+
+		// 阻击
+		// 如果要防止阻击伤害，可以直接简单的将 flag:no_snipe 设为true
+		if (enemy && core.hasSpecial(enemy.special, 18) && !core.hasFlag('no_snipe')) {
+			for (var dir in core.utils.scan) {
+				var nx = x + core.utils.scan[dir].x,
+					ny = y + core.utils.scan[dir].y,
+					currloc = nx + "," + ny;
+				if (nx < 0 || nx >= width || ny < 0 || ny >= height) continue;
+				damage[currloc] = (damage[currloc] || 0) + (enemy.value || 0);
+				type[currloc] = "阻击伤害";
+
+				var rdir = core.reverseDirection(dir);
+				// 检查下一个点是否存在事件（从而判定是否移动）
+				var rnx = x + core.utils.scan[rdir].x,
+					rny = y + core.utils.scan[rdir].y;
+				if (rnx >= 0 && rnx < width && rny >= 0 && rny < height && core.getBlock(rnx, rny, floorId) == null) {
+					snipe[currloc] = (snipe[currloc] || []).concat([
+						[x, y, id, rdir]
+					]);
+				}
+			}
+		}
+
+		// 激光
+		// 如果要防止激光伤害，可以直接简单的将 flag:no_laser 设为true
+		if (enemy && core.hasSpecial(enemy.special, 24) && !core.hasFlag("no_laser")) {
+			for (var nx = 0; nx < width; nx++) {
+				var currloc = nx + "," + y;
+				if (nx != x) {
+					damage[currloc] = (damage[currloc] || 0) + (enemy.value || 0);
+					type[currloc] = "激光伤害";
+				}
+			}
+			for (var ny = 0; ny < height; ny++) {
+				var currloc = x + "," + ny;
+				if (ny != y) {
+					damage[currloc] = (damage[currloc] || 0) + (enemy.value || 0);
+					type[currloc] = "激光伤害";
+				}
+			}
+		}
+
+		// 捕捉
+		// 如果要防止捕捉效果，可以直接简单的将 flag:no_ambush 设为true
+		if (enemy && core.enemys.hasSpecial(enemy.special, 27)) {
+			// 给周围格子加上【捕捉】记号
+			for (var dir in core.utils.scan) {
+				var nx = x + core.utils.scan[dir].x,
+					ny = y + core.utils.scan[dir].y,
+					currloc = nx + "," + ny;
+				if (nx < 0 || nx >= width || ny < 0 || ny >= height) continue;
+				ambush[currloc] = (ambush[currloc] || []).concat([
+					[x, y, id, dir]
+				]);
+			}
+		}
+	}
+
+	// 更新夹击伤害
+	// 如果要防止夹击伤害，可以简单的将 flag:no_betweenAttack 设为true
+	if (!core.hasFlag('no_betweenAttack')) {
+		for (var x = 0; x < width; x++) {
+			for (var y = 0; y < height; y++) {
+				var loc = x + "," + y;
+				// 夹击怪物的ID
+				var enemyId = null;
+				// 检查左右夹击
+				var leftBlock = blocks[(x - 1) + "," + y],
+					rightBlock = blocks[(x + 1) + "," + y];
+				if (leftBlock && rightBlock && leftBlock.id == rightBlock.id) {
+					if (core.hasSpecial(leftBlock.event.id, 16))
+						enemyId = leftBlock.event.id;
+				}
+				// 检查上下夹击
+				var topBlock = blocks[x + "," + (y - 1)],
+					bottomBlock = blocks[x + "," + (y + 1)];
+				if (topBlock && bottomBlock && topBlock.id == bottomBlock.id) {
+					if (core.hasSpecial(topBlock.event.id, 16))
+						enemyId = topBlock.event.id;
+				}
+
+				if (enemyId != null) {
+					var leftHp = core.status.hero.hp - (damage[loc] || 0);
+					if (leftHp > 1) {
+						// 上整/下整
+						var value = Math.floor((leftHp + (core.flags.betweenAttackCeil ? 1 : 0)) / 2);
+						// 是否不超过怪物伤害值
+						if (core.flags.betweenAttackMax) {
+							var enemyDamage = core.getDamage(enemyId, x, y, floorId);
+							if (enemyDamage != null && enemyDamage < value)
+								value = enemyDamage;
+						}
+						damage[loc] = (damage[loc] || 0) + value;
+						type[loc] = "夹击伤害";
+					}
+				}
+			}
+		}
+	}
+
+	core.status.checkBlock = {
+		damage: damage,
+		type: type,
+		snipe: snipe,
+		ambush: ambush,
+		cache: {} // clear cache
+	};
+},
+        "moveOneStep": function (x, y) {
+	// 勇士每走一步后执行的操作，x,y为要移动到的坐标。
+	// 这个函数执行在“刚走完”的时候，即还没有检查该点的事件和领域伤害等。
+	// 请注意：瞬间移动不会执行该函数。如果要控制能否瞬间移动有三种方法：
+	// 1. 将全塔属性中的cannotMoveDirectly这个开关勾上，即可在全塔中全程禁止使用瞬移。
+	// 2, 将楼层属性中的cannotMoveDirectly这个开关勾上，即禁止在该层楼使用瞬移。
+	// 3. 将flag:cannotMoveDirectly置为true，即可使用flag控制在某段剧情范围内禁止瞬移。
+
+	// 设置当前坐标，增加步数
+	core.setHeroLoc('x', x, true);
+	core.setHeroLoc('y', y, true);
+	core.status.hero.steps++;
+	// 更新跟随者状态，并绘制
+	core.updateFollowers();
+	core.drawHero();
+	// 检查中毒状态的扣血和死亡
+	if (core.hasFlag('poison')) {
+		core.status.hero.statistics.poisonDamage += core.values.poisonDamage;
+		core.status.hero.hp -= core.values.poisonDamage;
+		if (core.status.hero.hp <= 0) {
+			core.status.hero.hp = 0;
+			core.updateStatusBar();
+			core.events.lose();
+			return;
+		}
+	}
+	// 如需强行终止行走可以在这里条件判定：
+	// core.stopAutomaticRoute();
+
+	core.updateStatusBar();
+},
+        "moveDirectly": function (x, y) {
+	// 瞬间移动；x,y为要瞬间移动的点
+	// 返回true代表成功瞬移，false代表没有成功瞬移
+
+	// 判定能否瞬移到该点
+	var ignoreSteps = core.canMoveDirectly(x, y);
+	if (ignoreSteps >= 0) {
+		core.clearMap('hero');
+		// 获得勇士最后的朝向
+		var lastDirection = core.status.route[core.status.route.length - 1];
+		if (['left', 'right', 'up', 'down'].indexOf(lastDirection) >= 0)
+			core.setHeroLoc('direction', lastDirection);
+		// 设置坐标，并绘制
+		core.setHeroLoc('x', x);
+		core.setHeroLoc('y', y);
+		core.drawHero();
+		// 记录录像
+		core.status.route.push("move:" + x + ":" + y);
+		// 统计信息
+		core.status.hero.statistics.moveDirectly++;
+		core.status.hero.statistics.ignoreSteps += ignoreSteps;
+		return true;
+	}
+	return false;
+},
+        "parallelDo": function (timestamp) {
+	// 并行事件处理，可以在这里写任何需要并行处理的脚本或事件
+	// 该函数将被系统反复执行，每次执行间隔视浏览器或设备性能而定，一般约为16.6ms一次
+	// 参数timestamp为“从游戏资源加载完毕到当前函数执行时”的时间差，以毫秒为单位
+
+	// 检查当前是否处于游戏开始状态
+	if (!core.isPlaying()) return;
+
+	// 执行当前楼层的并行事件处理
+	if (core.status.floorId) {
+		try {
+			eval(core.floors[core.status.floorId].parallelDo);
+		} catch (e) {
+			main.log(e);
+		}
+	}
+
+	// 下面是一个并行事件开门的样例
+	/*
+	// 如果某个flag为真
+	if (core.hasFlag("xxx")) {
+	    // 千万别忘了将该flag清空！否则下次仍然会执行这段代码。
+	    core.removeFlag("xxx");
+	    // 使用insertAction来插入若干自定义事件执行
+	    core.insertAction([
+	        {"type":"openDoor", "loc":[0,0], "floorId": "MT0"}
+	    ])
+	    // 也可以写任意其他的脚本代码
+	}
+	*/
+}
+    },
+    "ui": {
+        "drawStatusBar": function () {
+	// 自定义绘制状态栏，需要开启状态栏canvas化
+
+	// 如果是非状态栏canvas化，直接返回
+	if (!core.flags.statusCanvas) return;
+	var canvas = core.dom.statusCanvas,
+		ctx = core.dom.statusCanvasCtx;
+	// 清空状态栏
+	ctx.clearRect(0, 0, canvas.width, canvas.height);
+	// 如果是隐藏状态栏模式，直接返回
+	if (!core.domStyle.showStatusBar) return;
+
+	// 作为样板，只绘制楼层、生命、攻击、防御、魔防、金币、钥匙这七个内容
+	// 需要其他的请自行进行修改；横竖屏都需要进行适配绘制。
+	// （可以使用Chrome浏览器开控制台来模拟手机上的竖屏模式的显示效果，具体方式自行百度）
+	// 横屏模式下的画布大小是 129*416
+	// 竖屏模式下的画布大小是 416*(32*rows+9) 其中rows为状态栏行数，即全塔属性中statusCanvasRowsOnMobile值
+	// 可以使用 core.domStyle.isVertical 来判定当前是否是竖屏模式
+
+	ctx.fillStyle = core.status.globalAttribute.statusBarColor || core.initStatus.globalAttribute.statusBarColor;
+	ctx.font = 'italic bold 18px Verdana';
+
+	// 距离左侧边框6像素，上侧边框9像素，行距约为39像素
+	var leftOffset = 6,
+		topOffset = 9,
+		lineHeight = 39;
+	if (core.domStyle.isVertical) { // 竖屏模式，行高32像素
+		leftOffset = 6;
+		topOffset = 6;
+		lineHeight = 32;
+	}
+
+	var toDraw = ["floor", "hp", "atk", "def", "mdef", "money"];
+	for (var index = 0; index < toDraw.length; index++) {
+		// 绘制下一个数据
+		var name = toDraw[index];
+		// 图片大小25x25
+		ctx.drawImage(core.statusBar.icons[name], leftOffset, topOffset, 25, 25);
+		// 文字内容
+		var text = (core.statusBar[name] || {}).innerText || " ";
+		// 斜体判定：如果不是纯数字和字母，斜体会非常难看，需要取消
+		if (!/^[-a-zA-Z0-9`~!@#$%^&*()_=+\[{\]}\\|;:'",<.>\/?]*$/.test(text))
+			ctx.font = 'bold 18px Verdana';
+		// 绘制文字
+		ctx.fillText(text, leftOffset + 36, topOffset + 20);
+		ctx.font = 'italic bold 18px Verdana';
+		// 计算下一个绘制的坐标
+		if (core.domStyle.isVertical) {
+			// 竖屏模式
+			if (index % 3 != 2) leftOffset += 131;
+			else {
+				leftOffset = 6;
+				topOffset += lineHeight;
+			}
+		} else {
+			// 横屏模式
+			topOffset += lineHeight;
+		}
+	}
+	// 绘制三色钥匙
+	ctx.fillStyle = '#FFCCAA';
+	ctx.fillText(core.statusBar.yellowKey.innerText, leftOffset + 5, topOffset + 20);
+	ctx.fillStyle = '#AAAADD';
+	ctx.fillText(core.statusBar.blueKey.innerText, leftOffset + 40, topOffset + 20);
+	ctx.fillStyle = '#FF8888';
+	ctx.fillText(core.statusBar.redKey.innerText, leftOffset + 75, topOffset + 20);
+},
+        "drawStatistics": function () {
+	// 浏览地图时参与的统计项目
+	
+	return [
+		'yellowDoor', 'blueDoor', 'redDoor', 'greenDoor', 'steelDoor',
+		'yellowKey', 'blueKey', 'redKey', 'greenKey', 'steelKey',
+		'redJewel', 'blueJewel', 'greenJewel', 'yellowJewel',
+		'redPotion', 'bluePotion', 'greenPotion', 'yellowPotion', 'superPotion',
+		'pickaxe', 'bomb', 'centerFly', 'icePickaxe', 'snow',
+		'earthquake', 'upFly', 'downFly', 'jumpShoes', 'lifeWand',
+		'poisonWine', 'weakWine', 'curseWine', 'superWine',
+		'sword1', 'sword2', 'sword3', 'sword4', 'sword5',
+		'shield1', 'shield2', 'shield3', 'shield4', 'shield5',
+		// 在这里可以增加新的ID来进行统计个数，只能增加道具ID
+	];
+},
+        "drawAbout": function() {
+	// 绘制“关于”界面
+	core.ui.closePanel();
 	core.lockControl();
 	core.status.event.id = 'about';
 
-	core.clearMap('ui');
-	var left = 48, top = 36, right = 416 - 2 * left, bottom = 416 - 2 * top;
+	var left = 48, top = 36, right = core.__PIXELS__ - 2 * left, bottom = core.__PIXELS__ - 2 * top;
 
 	core.setAlpha('ui', 0.85);
 	core.fillRect('ui', left, top, right, bottom, '#000000');
@@ -473,66 +1426,13 @@ functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a =
 	var text_start = left + 24;
 
 	// 名称
-	core.canvas.ui.textAlign = "left";
-	core.fillText('ui', "HTML5 魔塔样板", text_start, top+35, "#FFD700", "bold 22px Verdana");
-	core.fillText('ui', "版本： "+core.firstData.version, text_start, top + 80, "#FFFFFF", "bold 17px Verdana");
+	core.setTextAlign('ui', 'left');
+	var globalFont = (core.status.globalAttribute||core.initStatus.globalAttribute).font;
+	core.fillText('ui', "HTML5 魔塔样板", text_start, top+35, "#FFD700", "bold 22px "+globalFont);
+	core.fillText('ui', "版本： "+main.__VERSION__, text_start, top + 80, "#FFFFFF", "bold 17px "+globalFont);
 	core.fillText('ui', "作者： 艾之葵", text_start, top + 112);
 	core.fillText('ui', 'HTML5魔塔交流群：539113091', text_start, top+112+32);
 	// TODO: 写自己的“关于”页面，每次增加32像素即可
 }
-},
-"plugins": {
-"plugin": function () {
-	////// 插件编写，可以在这里写自己额外需要执行的脚本 //////
-
-	// 在这里写的代码，在所有模块加载完毕后，游戏开始前会被执行
-	console.log("插件编写测试");
-	// 可以写一些其他的被直接执行的代码
-
-
-	// 在这里写所有需要自定义的函数
-	// 写法必须是 this.xxx = function (args) { ...
-	// 如果不写this的话，函数将无法被外部所访问
-	this.test  = function () {
-		console.log("插件函数执行测试");
-	}
-
-	var _useEquipment = function (itemId, name, type) { // 具体的装备使用效果
-		if (itemId.indexOf(name)==0) {
-			var now=core.getFlag(name, name+"0");
-
-			if (typeof core.values[now] == 'number') {
-				core.status.hero[type] -= core.values[now];
-			}
-			else {
-				core.status.hero.atk -= core.values[now].atk || 0;
-				core.status.hero.def -= core.values[now].def || 0;
-				core.status.hero.mdef -= core.values[now].mdef || 0;
-			}
-
-			if (typeof core.values[itemId] == 'number') {
-				core.status.hero[type] += core.values[itemId];
-			}
-			else {
-				core.status.hero.atk += core.values[itemId].atk || 0;
-				core.status.hero.def += core.values[itemId].def || 0;
-				core.status.hero.mdef += core.values[itemId].mdef || 0;
-			}
-
-			core.setItem(now, 1);
-			core.setItem(itemId, 0);
-			core.setFlag(name, itemId);
-			core.drawTip("已装备"+core.material.items[itemId].name);
-		}
-	}
-
-	this.useEquipment = function (itemId) { // 使用装备
-		_useEquipment(itemId, "sword", "atk");
-		_useEquipment(itemId, "shield", "def");
-	}
-	
-	// 可以在任何地方（如afterXXX或自定义脚本事件）调用函数，方法为  core.plugin.xxx();
-
-}
-}
+    }
 }
\ No newline at end of file
diff --git a/project/icons.js b/project/icons.js
index 2d7e35df..e9d0ae7c 100644
--- a/project/icons.js
+++ b/project/icons.js
@@ -1,247 +1,271 @@
-icons_4665ee12_3a1f_44a4_bea3_0fccba634dc1 = 
+var icons_4665ee12_3a1f_44a4_bea3_0fccba634dc1 = 
 {
-        'hero': {
-            'down': {'loc': 0, 'stop': 0, 'leftFoot': 1, 'rightFoot': 3},
-            'left': {'loc': 1, 'stop': 0, 'leftFoot': 1, 'rightFoot': 3},
-            'right': {'loc': 2, 'stop': 0, 'leftFoot': 1, 'rightFoot': 3},
-            'up': {'loc': 3, 'stop': 0, 'leftFoot': 1, 'rightFoot': 3}
-        },
-        'terrains': {
-            'ground': 0,
-            'grass': 1,
-            'grass2': 2,
-            'yellowWall': 3,
-            'whiteWall': 4,
-            'blueWall': 5,
-            'snowGround': 6,
-            'ground2': 7,
-            'ground3': 8,
-            'ground4': 9,
-            'sand': 10,
-            'ground5': 11,
-            'yellowWall2': 12,
-            'whiteWall2': 13,
-            'blueWall2': 14,
-            'blockWall': 15,
-            'grayWall': 16,
-            'white': 17,
-            'ground6': 18,
-            'soil': 19,
-            'ground7': 20,
-            'ground8': 21,
-            'ice': 22,
-            'downFloor': 23,
-            'upFloor': 24,
-            'yellowDoor': 25,
-            'blueDoor': 26,
-            'redDoor': 27,
-            'greenDoor': 28,
-            'specialDoor': 29,
-            'steelDoor': 30,
-            'blueShop-left': 31,
-            'blueShop-right': 32,
-            'pinkShop-left': 33,
-            'pinkShop-right': 34,
-            'arrowUp': 35,
-            'arrowDown': 36,
-            'arrowLeft': 37,
-            'arrowRight': 38,
-            'light': 39,
-            'darkLight': 40,
-            'ski': 41,
-            'flower': 42,
-            'box': 43,
-            'boxed': 44
-        },
-        'animates': {
-            'star': 0,
-            'lava': 1,
-            'blueWater': 2,
-            'water': 3,
-            'yellowDoor': 4,
-            'blueDoor': 5,
-            'redDoor': 6,
-            'greenDoor': 7,
-            'specialDoor': 8,
-            'steelDoor': 9,
-            'yellowWallDoor': 10,
-            'whiteWallDoor': 11,
-            'blueWallDoor': 12,
-            'lavaDoor': 13,
-            'starDoor': 14,
-            'starPortal': 15,
-            'fire': 16,
-            'portal': 17,
-            'switch': 18,
-            'lavaNet': 19,
-            'poisonNet': 20,
-            'weakNet': 21,
-            'curseNet': 22,
-            'downPortal': 23,
-            'leftPortal': 24,
-            'rightPortal': 25,
-            'upPortal': 26,
-        },
-        'npcs': {
-            'man': 0,
-            'woman': 1,
-            'thief': 2,
-            'fairy': 3,
-            'magician': 4,
-            'womanMagician': 5,
-            'oldMan': 6,
-            'child': 7,
-            'wood': 8,
-            'pinkShop': 9,
-            'blueShop': 10,
-            'princess': 11,
-            'wlt': 12,
-            'wt': 13,
-            'wrt': 14,
-            'wl': 15,
-            'wc': 16,
-            'wr': 17,
-            'wlb': 18,
-            'wrb': 19,
-            'dlt': 20,
-            'dt': 21,
-            'drt': 22,
-            'dl': 23,
-            'dc': 24,
-            'dr': 25,
-            'dlb': 26,
-            'drb': 27,
-        },
-        'npc48': {
-            'npc0': 0,
-            'npc1': 1,
-            'npc2': 2,
-            'npc3': 3,
-            'npc4': 4,
-        },
-        'enemys': {
-            'greenSlime': 0,
-            'redSlime': 1,
-            'blackSlime': 2,
-            'slimelord': 3,
-            'bat': 4,
-            'bigBat': 5,
-            'redBat': 6,
-            'vampire': 7,
-            'skeleton': 8,
-            'skeletonSoilder': 9,
-            'skeletonCaptain': 10,
-            'ghostSkeleton': 11,
-            'zombie': 12,
-            'zombieKnight': 13,
-            'rock': 14,
-            'slimeMan': 15,
-            'bluePriest': 16,
-            'redPriest': 17,
-            'brownWizard': 18,
-            'redWizard': 19,
-            'yellowGuard': 20,
-            'blueGuard': 21,
-            'redGuard': 22,
-            'swordsman': 23,
-            'soldier': 24,
-            'yellowKnight': 25,
-            'redKnight': 26,
-            'darkKnight': 27,
-            'blackKing': 28,
-            'yellowKing': 29,
-            'greenKing': 30,
-            'blueKnight': 31,
-            'goldSlime': 32,
-            'poisonSkeleton': 33,
-            'poisonBat': 34,
-            'steelRock': 35,
-            'skeletonPriest': 36,
-            'skeletonKing': 37,
-            'skeletonWizard': 38,
-            'redSkeletonCaption': 39,
-            'badHero': 40,
-            'demon': 41,
-            'demonPriest': 42,
-            'goldHornSlime': 43,
-            'redKing': 44,
-            'whiteKing': 45,
-            'blackMagician': 46,
-            'silverSlime': 47,
-            'swordEmperor': 48,
-            'whiteHornSlime': 49,
-            'badPrincess': 50,
-            'badFairy': 51,
-            'grayPriest': 52,
-            'redSwordsman': 53,
-            'whiteGhost': 54,
-            'poisonZombie': 55,
-            'magicDragon': 56,
-            'octopus': 57,
-            'darkFairy': 58,
-            'greenKnight': 59,
-        },
-        'enemy48': {
-            'angel': 0,
-            'elemental': 1,
-            'steelGuard': 2,
-            'evilBat': 3,
-        },
-        'items': {
-            'yellowKey': 0,
-            'blueKey': 1,
-            'redKey': 2,
-            'greenKey': 3,
-            'steelKey': 4,
-            'bigKey': 6,
-            'redJewel': 16,
-            'blueJewel': 17,
-            'greenJewel': 18,
-            'yellowJewel': 19,
-            'redPotion': 20,
-            'bluePotion': 21,
-            'greenPotion': 22,
-            'yellowPotion': 23,
-            'lifeWand': 33,
-            'sword0': 60,
-            'sword1': 50,
-            'sword2': 51,
-            'sword3': 52,
-            'sword4': 53,
-            'sword5': 54,
-            'shield0': 61,
-            'shield1': 55,
-            'shield2': 56,
-            'shield3': 57,
-            'shield4': 58,
-            'shield5': 59,
-            'book': 9,
-            'fly': 12,
-            'pickaxe': 45,
-            'icePickaxe': 44,
-            'bomb': 43,
-            'centerFly': 13,
-            'upFly': 15,
-            'downFly': 14,
-            'coin': 11,
-            'snow': 41,
-            'cross': 40,
-            'superPotion': 29,
-            'earthquake': 8,
-            'poisonWine': 24,
-            'weakWine': 25,
-            'curseWine': 27,
-            'superWine': 28,
-            'knife': 42,
-            'moneyPocket': 46,
-            'shoes': 47,
-            'hammer': 48,
-            'jumpShoes': 49
-        },
-        'autotile': { // 所有的Autotile列表；后面的index简单取0即可
-            'autotile': 0,
-            'autotile1': 0,
-            'autotile2': 0,
-            'autotile3': 0,
-        }
+	"hero": {
+		"down": {
+			"loc": 0,
+			"stop": 0,
+			"leftFoot": 1,
+			"rightFoot": 3
+		},
+		"left": {
+			"loc": 1,
+			"stop": 0,
+			"leftFoot": 1,
+			"rightFoot": 3
+		},
+		"right": {
+			"loc": 2,
+			"stop": 0,
+			"leftFoot": 1,
+			"rightFoot": 3
+		},
+		"up": {
+			"loc": 3,
+			"stop": 0,
+			"leftFoot": 1,
+			"rightFoot": 3
+		},
+		"width": 32,
+		"height": 48
+	},
+	"terrains": {
+		"ground": 0,
+		"grass": 1,
+		"grass2": 2,
+		"yellowWall": 3,
+		"whiteWall": 4,
+		"blueWall": 5,
+		"snowGround": 6,
+		"ground2": 7,
+		"ground3": 8,
+		"ground4": 9,
+		"sand": 10,
+		"ground5": 11,
+		"yellowWall2": 12,
+		"whiteWall2": 13,
+		"blueWall2": 14,
+		"blockWall": 15,
+		"grayWall": 16,
+		"white": 17,
+		"ground6": 18,
+		"soil": 19,
+		"ground7": 20,
+		"ground8": 21,
+		"ice": 22,
+		"downFloor": 23,
+		"upFloor": 24,
+		"yellowDoor": 25,
+		"blueDoor": 26,
+		"redDoor": 27,
+		"greenDoor": 28,
+		"specialDoor": 29,
+		"steelDoor": 30,
+		"blueShop-left": 31,
+		"blueShop-right": 32,
+		"pinkShop-left": 33,
+		"pinkShop-right": 34,
+		"arrowUp": 35,
+		"arrowDown": 36,
+		"arrowLeft": 37,
+		"arrowRight": 38,
+		"light": 39,
+		"darkLight": 40,
+		"ski": 41,
+		"flower": 42,
+		"box": 43,
+		"boxed": 44
+	},
+	"animates": {
+		"star": 0,
+		"lava": 1,
+		"blueWater": 2,
+		"water": 3,
+		"yellowDoor": 4,
+		"blueDoor": 5,
+		"redDoor": 6,
+		"greenDoor": 7,
+		"specialDoor": 8,
+		"steelDoor": 9,
+		"yellowWall": 10,
+		"whiteWall": 11,
+		"blueWall": 12,
+		"crystalUp": 13,
+		"crystalBottom": 14,
+		"starPortal": 15,
+		"fire": 16,
+		"portal": 17,
+		"switch": 18,
+		"lavaNet": 19,
+		"poisonNet": 20,
+		"weakNet": 21,
+		"curseNet": 22,
+		"downPortal": 23,
+		"leftPortal": 24,
+		"rightPortal": 25,
+		"upPortal": 26
+	},
+	"npcs": {
+		"man": 0,
+		"woman": 1,
+		"thief": 2,
+		"fairy": 3,
+		"magician": 4,
+		"womanMagician": 5,
+		"oldMan": 6,
+		"child": 7,
+		"wood": 8,
+		"pinkShop": 9,
+		"blueShop": 10,
+		"princess": 11,
+		"wlt": 12,
+		"wt": 13,
+		"wrt": 14,
+		"wl": 15,
+		"wc": 16,
+		"wr": 17,
+		"wlb": 18,
+		"wrb": 19,
+		"dlt": 20,
+		"dt": 21,
+		"drt": 22,
+		"dl": 23,
+		"dc": 24,
+		"dr": 25,
+		"dlb": 26,
+		"drb": 27
+	},
+	"npc48": {
+		"npc0": 0,
+		"npc1": 1,
+		"npc2": 2,
+		"npc3": 3,
+		"npc4": 4
+	},
+	"enemys": {
+		"greenSlime": 0,
+		"redSlime": 1,
+		"blackSlime": 2,
+		"slimelord": 3,
+		"bat": 4,
+		"bigBat": 5,
+		"redBat": 6,
+		"vampire": 7,
+		"skeleton": 8,
+		"skeletonSoilder": 9,
+		"skeletonCaptain": 10,
+		"ghostSkeleton": 11,
+		"zombie": 12,
+		"zombieKnight": 13,
+		"rock": 14,
+		"slimeMan": 15,
+		"bluePriest": 16,
+		"redPriest": 17,
+		"brownWizard": 18,
+		"redWizard": 19,
+		"yellowGuard": 20,
+		"blueGuard": 21,
+		"redGuard": 22,
+		"swordsman": 23,
+		"soldier": 24,
+		"yellowKnight": 25,
+		"redKnight": 26,
+		"darkKnight": 27,
+		"blackKing": 28,
+		"yellowKing": 29,
+		"greenKing": 30,
+		"blueKnight": 31,
+		"goldSlime": 32,
+		"poisonSkeleton": 33,
+		"poisonBat": 34,
+		"steelRock": 35,
+		"skeletonPriest": 36,
+		"skeletonKing": 37,
+		"skeletonWizard": 38,
+		"redSkeletonCaption": 39,
+		"badHero": 40,
+		"demon": 41,
+		"demonPriest": 42,
+		"goldHornSlime": 43,
+		"redKing": 44,
+		"whiteKing": 45,
+		"blackMagician": 46,
+		"silverSlime": 47,
+		"swordEmperor": 48,
+		"whiteHornSlime": 49,
+		"badPrincess": 50,
+		"badFairy": 51,
+		"grayPriest": 52,
+		"redSwordsman": 53,
+		"whiteGhost": 54,
+		"poisonZombie": 55,
+		"magicDragon": 56,
+		"octopus": 57,
+		"darkFairy": 58,
+		"greenKnight": 59
+	},
+	"enemy48": {
+		"angel": 0,
+		"elemental": 1,
+		"steelGuard": 2,
+		"evilBat": 3
+	},
+	"items": {
+		"yellowKey": 0,
+		"blueKey": 1,
+		"redKey": 2,
+		"greenKey": 3,
+		"steelKey": 4,
+		"bigKey": 6,
+		"redJewel": 16,
+		"blueJewel": 17,
+		"greenJewel": 18,
+		"yellowJewel": 19,
+		"redPotion": 20,
+		"bluePotion": 21,
+		"greenPotion": 22,
+		"yellowPotion": 23,
+		"lifeWand": 33,
+		"sword0": 60,
+		"sword1": 50,
+		"sword2": 51,
+		"sword3": 52,
+		"sword4": 53,
+		"sword5": 54,
+		"shield0": 61,
+		"shield1": 55,
+		"shield2": 56,
+		"shield3": 57,
+		"shield4": 58,
+		"shield5": 59,
+		"book": 9,
+		"fly": 12,
+		"pickaxe": 45,
+		"icePickaxe": 44,
+		"bomb": 43,
+		"centerFly": 13,
+		"upFly": 15,
+		"downFly": 14,
+		"coin": 11,
+		"snow": 41,
+		"cross": 40,
+		"superPotion": 29,
+		"earthquake": 8,
+		"poisonWine": 24,
+		"weakWine": 25,
+		"curseWine": 27,
+		"superWine": 28,
+		"knife": 42,
+		"moneyPocket": 46,
+		"shoes": 47,
+		"hammer": 48,
+		"jumpShoes": 49,
+		"skill1": 30,
+		"wand": 10
+	},
+	"autotile": {
+		"autotile": 0,
+		"autotile1": 0,
+		"autotile2": 0,
+		"autotile3": 0
+	}
 }
\ No newline at end of file
diff --git a/project/images/airwall.png b/project/images/airwall.png
new file mode 100644
index 00000000..e1607d65
Binary files /dev/null and b/project/images/airwall.png differ
diff --git a/project/images/animates.png b/project/images/animates.png
index f6245285..3a901cb8 100644
Binary files a/project/images/animates.png and b/project/images/animates.png differ
diff --git a/project/images/autotile1.png b/project/images/autotile1.png
index 2dacd883..37a0b271 100644
Binary files a/project/images/autotile1.png and b/project/images/autotile1.png differ
diff --git a/project/images/fog.png b/project/images/fog.png
new file mode 100644
index 00000000..313311d4
Binary files /dev/null and b/project/images/fog.png differ
diff --git a/project/images/icons.png b/project/images/icons.png
index dbd9658b..557b4808 100644
Binary files a/project/images/icons.png and b/project/images/icons.png differ
diff --git a/project/images/keyboard.png b/project/images/keyboard.png
new file mode 100644
index 00000000..c2b9d241
Binary files /dev/null and b/project/images/keyboard.png differ
diff --git a/project/images/magictower.png b/project/images/magictower.png
new file mode 100644
index 00000000..8e0a90d3
Binary files /dev/null and b/project/images/magictower.png differ
diff --git a/project/images/winskin.png b/project/images/winskin.png
new file mode 100644
index 00000000..f3144531
Binary files /dev/null and b/project/images/winskin.png differ
diff --git a/project/items.js b/project/items.js
index 05fc0df0..bc656898 100644
--- a/project/items.js
+++ b/project/items.js
@@ -1,4 +1,4 @@
-items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a = 
+var items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a = 
 {
 	"items": {
 		"yellowKey": {
@@ -15,85 +15,158 @@ items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a =
 		},
 		"redJewel": {
 			"cls": "items",
-			"name": "红宝石"
+			"name": "红宝石",
+			"text": "'，攻击+'+core.values.redJewel"
 		},
 		"blueJewel": {
 			"cls": "items",
-			"name": "蓝宝石"
+			"name": "蓝宝石",
+			"text": "'，防御+'+core.values.blueJewel"
 		},
 		"greenJewel": {
 			"cls": "items",
-			"name": "绿宝石"
+			"name": "绿宝石",
+			"text": "'，魔防+'+core.values.greenJewel"
 		},
 		"yellowJewel": {
 			"cls": "items",
-			"name": "黄宝石"
+			"name": "黄宝石",
+			"text": "可以进行加点"
 		},
 		"redPotion": {
 			"cls": "items",
-			"name": "红血瓶"
+			"name": "红血瓶",
+			"text": "'，生命+'+core.values.redPotion"
 		},
 		"bluePotion": {
 			"cls": "items",
-			"name": "蓝血瓶"
+			"name": "蓝血瓶",
+			"text": "'，生命+'+core.values.bluePotion"
 		},
 		"yellowPotion": {
 			"cls": "items",
-			"name": "黄血瓶"
+			"name": "黄血瓶",
+			"text": "'生命+'+core.values.yellowPotion"
 		},
 		"greenPotion": {
 			"cls": "items",
-			"name": "绿血瓶"
+			"name": "绿血瓶",
+			"text": "'，生命+'+core.values.greenPotion"
+		},
+		"sword0": {
+			"cls": "items",
+			"name": "破旧的剑",
+			"text": "一把已经生锈的剑",
+			"equip": {
+				"type": 0,
+				"atk": 0,
+				"animate": "sword"
+			}
 		},
 		"sword1": {
 			"cls": "items",
 			"name": "铁剑",
-			"text": "一把很普通的铁剑"
+			"text": "一把很普通的铁剑",
+			"equip": {
+				"type": 0,
+				"atk": 10,
+				"animate": "sword"
+			}
 		},
 		"sword2": {
 			"cls": "items",
 			"name": "银剑",
-			"text": "一把很普通的银剑"
+			"text": "一把很普通的银剑",
+			"equip": {
+				"type": 0,
+				"atk": 20,
+				"animate": "sword"
+			}
 		},
 		"sword3": {
 			"cls": "items",
 			"name": "骑士剑",
-			"text": "一把很普通的骑士剑"
+			"text": "一把很普通的骑士剑",
+			"equip": {
+				"type": 0,
+				"atk": 40,
+				"animate": "sword"
+			}
 		},
 		"sword4": {
 			"cls": "items",
 			"name": "圣剑",
-			"text": "一把很普通的圣剑"
+			"text": "一把很普通的圣剑",
+			"equip": {
+				"type": 0,
+				"atk": 80,
+				"animate": "sword"
+			}
 		},
 		"sword5": {
 			"cls": "items",
 			"name": "神圣剑",
-			"text": "一把很普通的神圣剑"
+			"text": "一把很普通的神圣剑",
+			"equip": {
+				"type": 0,
+				"atk": 100,
+				"animate": "sword"
+			}
+		},
+		"shield0": {
+			"cls": "items",
+			"name": "破旧的盾",
+			"text": "一个很破旧的铁盾",
+			"equip": {
+				"type": 1,
+				"def": 0
+			}
 		},
 		"shield1": {
 			"cls": "items",
 			"name": "铁盾",
-			"text": "一个很普通的铁盾"
+			"text": "一个很普通的铁盾",
+			"equip": {
+				"type": 1,
+				"def": 10
+			}
 		},
 		"shield2": {
 			"cls": "items",
 			"name": "银盾",
-			"text": "一个很普通的银盾"
+			"text": "一个很普通的银盾",
+			"equip": {
+				"type": 1,
+				"def": 20
+			}
 		},
 		"shield3": {
 			"cls": "items",
 			"name": "骑士盾",
-			"text": "一个很普通的骑士盾"
+			"text": "一个很普通的骑士盾",
+			"equip": {
+				"type": 1,
+				"def": 40
+			}
 		},
 		"shield4": {
 			"cls": "items",
 			"name": "圣盾",
-			"text": "一个很普通的圣盾"
+			"text": "一个很普通的圣盾",
+			"equip": {
+				"type": 1,
+				"def": 80
+			}
 		},
 		"shield5": {
 			"cls": "items",
 			"name": "神圣盾",
-			"text": "一个很普通的神圣盾"
+			"text": "一个很普通的神圣盾",
+			"equip": {
+				"type": 1,
+				"def": 100,
+				"mdef": 100
+			}
 		},
 		"superPotion": {
 			"cls": "items",
@@ -103,16 +176,6 @@ items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a =
 			"cls": "items",
 			"name": "金钱袋"
 		},
-		"sword0": {
-			"cls": "constants",
-			"name": "空剑",
-			"text": "使用可脱掉当前装备的剑。"
-		},
-		"shield0": {
-			"cls": "constants",
-			"name": "空盾",
-			"text": "使用可脱掉当前装备的盾。"
-		},
 		"book": {
 			"cls": "constants",
 			"name": "怪物手册",
@@ -121,7 +184,8 @@ items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a =
 		"fly": {
 			"cls": "constants",
 			"name": "楼层传送器",
-			"text": "可以自由往来去过的楼层"
+			"text": "可以自由往来去过的楼层",
+			"hideInReplay": true
 		},
 		"coin": {
 			"cls": "constants",
@@ -232,6 +296,16 @@ items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a =
 			"cls": "tools",
 			"name": "跳跃靴",
 			"text": "能跳跃到前方两格处"
+		},
+		"skill1": {
+			"cls": "constants",
+			"name": "技能：二倍斩",
+			"text": "可以打开或关闭主动技能二倍斩",
+			"hideInReplay": true
+		},
+		"wand": {
+			"cls": "items",
+			"name": "新物品"
 		}
 	},
 	"itemEffect": {
@@ -243,19 +317,21 @@ items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a =
 		"bluePotion": "core.status.hero.hp += core.values.bluePotion * ratio",
 		"yellowPotion": "core.status.hero.hp += core.values.yellowPotion * ratio",
 		"greenPotion": "core.status.hero.hp += core.values.greenPotion * ratio",
-		"sword1": "core.status.hero.atk += core.values.sword1",
-		"sword2": "core.status.hero.atk += core.values.sword2",
-		"sword3": "core.status.hero.atk += core.values.sword3",
-		"sword4": "core.status.hero.atk += core.values.sword4",
-		"sword5": "core.status.hero.atk += core.values.sword5",
-		"shield1": "core.status.hero.def += core.values.shield1",
-		"shield2": "core.status.hero.def += core.values.shield2",
-		"shield3": "core.status.hero.def += core.values.shield3",
-		"shield4": "core.status.hero.def += core.values.shield4",
-		"shield5": "core.status.hero.def += core.values.shield5",
+		"sword0": "core.status.hero.atk += 0",
+		"sword1": "core.status.hero.atk += 10",
+		"sword2": "core.status.hero.atk += 20",
+		"sword3": "core.status.hero.atk += 40",
+		"sword4": "core.status.hero.atk += 80",
+		"sword5": "core.status.hero.atk += 100",
+		"shield0": "core.status.hero.def += 0",
+		"shield1": "core.status.hero.def += 10",
+		"shield2": "core.status.hero.def += 20",
+		"shield3": "core.status.hero.def += 40",
+		"shield4": "core.status.hero.def += 80",
+		"shield5": "core.status.hero.def += 100;core.status.hero.mdef += 100",
 		"bigKey": "core.status.hero.items.keys.yellowKey++;core.status.hero.items.keys.blueKey++;core.status.hero.items.keys.redKey++;",
 		"superPotion": "core.status.hero.hp *= 2",
-		"moneyPocket": "core.status.hero.money += core.values.moneyPocket"
+		"moneyPocket": "core.status.hero.money += 500"
 	},
 	"itemEffectTip": {
 		"redJewel": "'，攻击+'+core.values.redJewel * ratio",
@@ -266,83 +342,79 @@ items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a =
 		"bluePotion": "'，生命+'+core.values.bluePotion * ratio",
 		"yellowPotion": "'，生命+'+core.values.yellowPotion * ratio",
 		"greenPotion": "'，生命+'+core.values.greenPotion * ratio",
-		"sword1": "'，攻击+'+core.values.sword1",
-		"sword2": "'，攻击+'+core.values.sword2",
-		"sword3": "'，攻击+'+core.values.sword3",
-		"sword4": "'，攻击+'+core.values.sword4",
-		"sword5": "'，攻击+'+core.values.sword5",
-		"shield1": "'，防御+'+core.values.shield1",
-		"shield2": "'，防御+'+core.values.shield2",
-		"shield3": "'，防御+'+core.values.shield3",
-		"shield4": "'，防御+'+core.values.shield4",
-		"shield5": "'，防御+'+core.values.shield5",
+		"sword0": "'，攻击+0'",
+		"sword1": "'，攻击+10'",
+		"sword2": "'，攻击+20'",
+		"sword3": "'，攻击+40'",
+		"sword4": "'，攻击+80'",
+		"sword5": "'，攻击+100'",
+		"shield0": "'，防御+0'",
+		"shield1": "'，防御+10'",
+		"shield2": "'，防御+20'",
+		"shield3": "'，防御+40'",
+		"shield4": "'，防御+80'",
+		"shield5": "'，防御+100，魔防+100'",
 		"bigKey": "'，全钥匙+1'",
 		"superPotion": "'，生命值翻倍'",
-		"moneyPocket": "'，金币+'+core.values.moneyPocket"
+		"moneyPocket": "'，金币+500'"
 	},
 	"useItemEffect": {
 		"book": "core.ui.drawBook(0);",
-		"fly": "core.ui.drawFly(core.status.hero.flyRange.indexOf(core.status.floorId));",
-		"earthquake": "core.removeBlockByIds(core.status.floorId, core.status.event.data);\ncore.drawMap(core.status.floorId, function () {\n    core.drawTip(core.material.items[itemId].name + '使用成功');\n});",
-		"pickaxe": "core.removeBlockByIds(core.status.floorId, core.status.event.data);\ncore.drawMap(core.status.floorId, function () {\n    core.drawTip(core.material.items[itemId].name + '使用成功');\n});",
-		"icePickaxe": "core.removeBlockByIds(core.status.floorId, core.status.event.data);\ncore.drawMap(core.status.floorId, function () {\n    core.drawTip(core.material.items[itemId].name + '使用成功');\n});",
-		"snow": "core.removeBlockByIds(core.status.floorId, core.status.event.data);\ncore.drawMap(core.status.floorId, function () {\n    core.drawTip(core.material.items[itemId].name + '使用成功');\n});",
-		"bigKey": "core.removeBlockByIds(core.status.floorId, core.status.event.data);\ncore.drawMap(core.status.floorId, function () {\n    core.drawTip(core.material.items[itemId].name + '使用成功');\n});",
-		"bomb": "core.removeBlockByIds(core.status.floorId, core.status.event.data);\ncore.drawMap(core.status.floorId, function () {\n    core.drawTip(core.material.items[itemId].name + '使用成功');\n    core.events.afterUseBomb();\n});",
-		"hammer": "core.removeBlockByIds(core.status.floorId, core.status.event.data);\ncore.drawMap(core.status.floorId, function () {\n    core.drawTip(core.material.items[itemId].name + '使用成功');\n    core.events.afterUseBomb();\n});",
-		"centerFly": "core.clearMap('hero');\ncore.setHeroLoc('x', (core.bigmap.width||13)-1-core.getHeroLoc('x'));\ncore.setHeroLoc('y', (core.bigmap.height||13)-1-core.getHeroLoc('y'));\ncore.drawHero();\ncore.drawTip(core.material.items[itemId].name + '使用成功');",
-		"upFly": "var loc = {'direction': core.status.hero.loc.direction, 'x': core.status.event.data.x, 'y': core.status.event.data.y};\ncore.changeFloor(core.status.event.data.id, null, loc, null, function (){\n    core.drawTip(core.material.items[itemId].name + '使用成功');\n    core.replay();\n});",
-		"downFly": "var loc = {'direction': core.status.hero.loc.direction, 'x': core.status.event.data.x, 'y': core.status.event.data.y};\ncore.changeFloor(core.status.event.data.id, null, loc, null, function (){\n    core.drawTip(core.material.items[itemId].name + '使用成功');\n    core.replay();\n});",
-		"poisonWine": "core.setFlag('poison', false);",
-		"weakWine": "core.setFlag('weak', false);\ncore.status.hero.atk += core.getFlag('weakAtk', core.values.weakValue);\ncore.status.hero.def += core.getFlag('weakDef', core.values.weakValue);",
-		"curseWine": "core.setFlag('curse', false);",
-		"superWine": "core.setFlag('poison', false);\nif (core.hasFlag('weak')) {\n    core.setFlag('weak', false);\n    core.status.hero.atk += core.getFlag('weakAtk', core.values.weakValue);\n    core.status.hero.def += core.getFlag('weakDef', core.values.weakValue);\n}\ncore.setFlag('curse', false);",
-		"sword0": "core.plugin.useEquipment(itemId)",
-		"sword1": "core.plugin.useEquipment(itemId)",
-		"sword2": "core.plugin.useEquipment(itemId)",
-		"sword3": "core.plugin.useEquipment(itemId)",
-		"sword4": "core.plugin.useEquipment(itemId)",
-		"sword5": "core.plugin.useEquipment(itemId)",
-		"shield0": "core.plugin.useEquipment(itemId)",
-		"shield1": "core.plugin.useEquipment(itemId)",
-		"shield2": "core.plugin.useEquipment(itemId)",
-		"shield3": "core.plugin.useEquipment(itemId)",
-		"shield4": "core.plugin.useEquipment(itemId)",
-		"shield5": "core.plugin.useEquipment(itemId)",
-		"lifeWand": "core.insertAction([\n\t{\"type\": \"input\", \"text\": \"请输入生命魔杖使用次数：(0-${item:lifeWand})\"},\n\t{\"type\": \"if\", \"condition\": \"flag:input<=item:lifeWand\",\n\t\t\"true\": [\n\t\t\t{\"type\": \"setValue\", \"name\": \"item:lifeWand\", \"value\": \"item:lifeWand-flag:input\"},\n\t\t\t{\"type\": \"setValue\", \"name\": \"status:hp\", \"value\": \"status:hp+flag:input*100\"},\n\t\t\t\"成功使用${flag:input}次生命魔杖，恢复${flag:input*100}点生命。\"\n\t\t],\n\t\t\"false\": [\"输入不合法！\"]\n\t},\n]);\ncore.setItem('lifeWand', core.itemCount('lifeWand')+1);",
-		"jumpShoes": "core.insertAction({\"type\":\"jumpHero\",\"loc\":[core.nextX(2),core.nextY(2)]});"
+		"fly": "core.ui.drawFly(core.floorIds.indexOf(core.status.floorId));",
+		"earthquake": "core.removeBlockByIds(core.status.floorId, core.status.event.ui);\ncore.drawMap(core.status.floorId, function () {\n\tcore.drawTip(core.material.items[itemId].name + '使用成功');\n});",
+		"pickaxe": "core.playSound('pickaxe.mp3');\ncore.removeBlockByIds(core.status.floorId, core.status.event.ui);\ncore.drawMap(core.status.floorId, function () {\n\tcore.drawTip(core.material.items[itemId].name + '使用成功');\n});",
+		"icePickaxe": "core.removeBlockByIds(core.status.floorId, core.status.event.ui);\ncore.drawMap(core.status.floorId, function () {\n\tcore.drawTip(core.material.items[itemId].name + '使用成功');\n});",
+		"snow": "core.removeBlockByIds(core.status.floorId, core.status.event.ui);\ncore.drawMap(core.status.floorId, function () {\n\tcore.drawTip(core.material.items[itemId].name + '使用成功');\n});",
+		"bigKey": "core.removeBlockByIds(core.status.floorId, core.status.event.ui);\ncore.drawMap(core.status.floorId, function () {\n\tcore.drawTip(core.material.items[itemId].name + '使用成功');\n});",
+		"bomb": "core.playSound('bomb.mp3');\ncore.removeBlockByIds(core.status.floorId, core.status.event.ui);\ncore.drawMap(core.status.floorId, function () {\n\tcore.drawTip(core.material.items[itemId].name + '使用成功');\n\tcore.events.afterUseBomb();\n});",
+		"hammer": "core.playSound('bomb.mp3');\ncore.removeBlockByIds(core.status.floorId, core.status.event.ui);\ncore.drawMap(core.status.floorId, function () {\n\tcore.drawTip(core.material.items[itemId].name + '使用成功');\n\tcore.events.afterUseBomb();\n});",
+		"centerFly": "core.playSound('centerFly.mp3');\ncore.clearMap('hero');\ncore.setHeroLoc('x', core.bigmap.width-1-core.getHeroLoc('x'));\ncore.setHeroLoc('y', core.bigmap.height-1-core.getHeroLoc('y'));\ncore.drawHero();\ncore.drawTip(core.material.items[itemId].name + '使用成功');",
+		"upFly": "var loc = {'direction': core.status.hero.loc.direction, 'x': core.status.event.ui.x, 'y': core.status.event.ui.y};\nif (core.status.event.id == 'action') {\n\tcore.insertAction([\n\t\t{\"type\": \"changeFloor\", \"loc\": [loc.x, loc.y], \"direction\": loc.direction, \"floorId\": core.status.event.ui.id},\n\t\t{\"type\": \"tip\", \"text\": core.material.items[itemId].name + '使用成功'}\n\t]);\n}\nelse {\n\tcore.changeFloor(core.status.event.ui.id, null, loc, null, function (){\n\tcore.drawTip(core.material.items[itemId].name + '使用成功');\n\t\tcore.replay();\n\t});\n}",
+		"downFly": "var loc = {'direction': core.status.hero.loc.direction, 'x': core.status.event.ui.x, 'y': core.status.event.ui.y};\nif (core.status.event.id == 'action') {\n\tcore.insertAction([\n\t\t{\"type\": \"changeFloor\", \"loc\": [loc.x, loc.y], \"direction\": loc.direction, \"floorId\": core.status.event.ui.id},\n\t\t{\"type\": \"tip\", \"text\": core.material.items[itemId].name + '使用成功'}\n\t]);\n}\nelse {\n\tcore.changeFloor(core.status.event.ui.id, null, loc, null, function (){\n\tcore.drawTip(core.material.items[itemId].name + '使用成功');\n\t\tcore.replay();\n\t});\n}\n",
+		"poisonWine": "core.removeFlag('poison');",
+		"weakWine": "core.removeFlag('weak');\nif (core.values.weakValue>=1) { // >=1：直接扣数值\n\tcore.status.hero.atk += core.values.weakValue;\n\tcore.status.hero.def += core.values.weakValue;\n}\nelse { // <1：扣比例\n\tcore.addBuff(\"atk\", core.values.weakValue);\n\tcore.addBuff(\"def\", core.values.weakValue);\n}",
+		"curseWine": "core.removeFlag('curse');",
+		"superWine": "core.removeFlag('poison');\nif (core.hasFlag('weak')) {\n\tcore.removeFlag('weak');\n\tif (core.values.weakValue>=1) { // >=1：直接扣数值\n\t\tcore.status.hero.atk += core.values.weakValue;\n\t\tcore.status.hero.def += core.values.weakValue;\n\t}\n\telse { // <1：扣比例\n\t\tcore.addBuff(\"atk\", core.values.weakValue);\n\t\tcore.addBuff(\"def\", core.values.weakValue);\n\t}\n}\ncore.removeFlag('curse');",
+		"lifeWand": "core.insertAction([\n\t{\"type\": \"input\", \"text\": \"请输入生命魔杖使用次数：(0-${item:lifeWand})\"},\n\t{\"type\": \"if\", \"condition\": \"flag:input<=item:lifeWand\",\n\t\t\"true\": [\n\t\t\t{\"type\": \"setValue\", \"name\": \"item:lifeWand\", \"value\": \"item:lifeWand-flag:input\"},\n\t\t\t{\"type\": \"setValue\", \"name\": \"status:hp\", \"value\": \"status:hp+flag:input*100\"},\n\t\t\t\"成功使用${flag:input}次生命魔杖，恢复${flag:input*100}点生命。\"\n\t\t],\n\t\t\"false\": [\"输入不合法！\"]\n\t},\n]);\ncore.addItem('lifeWand', 1);",
+		"jumpShoes": "core.insertAction({\"type\":\"jumpHero\",\"loc\":[core.nextX(2),core.nextY(2)]});",
+		"redPotion": "core.status.hero.hp += core.values.redPotion",
+		"bluePotion": "core.status.hero.hp += core.values.bluePotion",
+		"greenPotion": "core.status.hero.hp += core.values.greenPotion",
+		"yellowPotion": "core.status.hero.hp += core.values.yellowPotion",
+		"redJewel": "core.status.hero.atk += core.values.redJewel",
+		"blueJewel": "core.status.hero.def += core.values.blueJewel",
+		"greenJewel": "core.status.hero.mdef += core.values.greenJewel",
+		"yellowJewel": "core.insertAction([\n\t{\"type\": \"choices\", \"choices\": [\n\t\t{\"text\": \"攻击+1\", \"action\": [\n\t\t\t{\"type\": \"setValue\", \"name\": \"status:atk\", \"value\": \"status:atk+1\"}\n\t\t]},\n\t\t{\"text\": \"防御+2\", \"action\": [\n\t\t\t{\"type\": \"setValue\", \"name\": \"status:def\", \"value\": \"status:def+2\"}\n\t\t]},\n\t\t{\"text\": \"生命+200\", \"action\": [\n\t\t\t{\"type\": \"setValue\", \"name\": \"status:hp\", \"value\": \"status:hp+200\"}\n\t\t]},\n\t]}\n]);",
+		"skill1": "// 二倍斩的flag:skill为1\nif (core.getFlag('skill', 0)==0) { // 判断当前是否已经开了技能\n\tif (core.getStatus('mana')>=5) { // 这里要写当前能否开技能的条件判断，比如魔力值至少要多少\n\t\tcore.setFlag('skill', 1); // 开技能1\n\t\tcore.setFlag('skillName', '二倍斩'); // 设置技能名\n\t}\n\telse {\n\t\tcore.drawTip(\"魔力不足，无法开启技能\");\n\t}\n}\nelse { // 关闭技能\n\tcore.setFlag('skill', 0); // 关闭技能状态\n\tcore.setFlag('skillName', '无');\n}"
 	},
 	"canUseItemEffect": {
 		"book": "true",
-		"fly": "core.status.hero.flyRange.indexOf(core.status.floorId)>=0",
-		"pickaxe": "var able=false;\nvar ids = [], id2s = [];\nfor (var i in core.status.thisMap.blocks) {\n\tvar block = core.status.thisMap.blocks[i];\n\tif (core.isset(block.event) && !block.disable && Math.abs(block.x-core.status.hero.loc.x)+Math.abs(block.y-core.status.hero.loc.y)<=1\n\t\t&& (block.event.id == 'yellowWall' || block.event.id=='whiteWall' || block.event.id=='blueWall')) // 能破哪些墙\n\t{\n\t\t// 四个方向\n\t\tif (core.flags.pickaxeFourDirections || (block.x == core.nextX() && block.y == core.nextY()))\n\t\t\tids.push(i);\n\t\telse id2s.push(i);\n\t}\n}\nif (ids.length>0) {\n\tcore.status.event.data = ids;\n\table=true;\n}\nelse if (id2s.length==1) {\n\tcore.status.event.data = id2s;\n\table=true;\n}\nable",
-		"icePickaxe": "var able=false;\nfor (var i in core.status.thisMap.blocks) {\n\tvar block = core.status.thisMap.blocks[i];\n\tif (core.isset(block.event) && !block.disable && block.x==core.nextX() && block.y==core.nextY() && block.event.id=='ice') {\n\t\tcore.status.event.data = [i];\n\t\table=true;\n\t}\n}\nable",
-		"bomb": "var able=false;\nvar ids = [], id2s = [];\nfor (var i in core.status.thisMap.blocks) {\n\tvar block = core.status.thisMap.blocks[i];\n\tif (core.isset(block.event) && !block.disable && block.event.cls.indexOf('enemy')==0 && Math.abs(block.x-core.status.hero.loc.x)+Math.abs(block.y-core.status.hero.loc.y)<=1) {\n\t\tvar enemy = core.material.enemys[block.event.id];\n\t\tif (core.isset(enemy) && enemy.notBomb) continue;\n\t\tif (core.flags.bombFourDirections || (block.x==core.nextX() && block.y==core.nextY()))\n\t\t\tids.push(i);\n\t\telse\n\t\t\tid2s.push(i);\n\t}\n}\nif (ids.length>0) {\n\tcore.status.event.data = ids;\n\table=true;\n}\nelse if (id2s.length==1) {\n\tcore.status.event.data = id2s;\n\table=true;\n}\nable",
-		"hammer": "var able=false;\nvar ids = [], id2s = [];\nfor (var i in core.status.thisMap.blocks) {\n\tvar block = core.status.thisMap.blocks[i];\n\tif (core.isset(block.event) && !block.disable && block.event.cls.indexOf('enemy')==0 && \n\t\tMath.abs(block.x-core.status.hero.loc.x)+Math.abs(block.y-core.status.hero.loc.y)<=1) {\n\t\tvar enemy = core.material.enemys[block.event.id];\n\t\tif (core.isset(enemy) && enemy.notBomb) continue;\n\t\tif (block.x==core.nextX() && block.y==core.nextY())\n\t\t\tids.push(i);\n\t\telse\n\t\t\tid2s.push(i);\n\t}\n}\nif (ids.length>0) {\n\tcore.status.event.data = ids;\n\table=true;\n}\nelse if (id2s.length==1) {\n\tcore.status.event.data = id2s;\n\table=true;\n}\nable",
-		"earthquake": "var able=false;\nvar ids = [];\nfor (var i in core.status.thisMap.blocks) {\n    var block = core.status.thisMap.blocks[i];\n    if (core.isset(block.event) && !block.disable && (block.event.id == 'yellowWall' || block.event.id == 'blueWall' || block.event.id == 'whiteWall')) // 能炸的墙壁\n        ids.push(i);\n}\nif (ids.length>0) {\n    core.status.event.data = ids;\n    able=true;\n}\nable",
-		"centerFly": "var toX = (core.bigmap.width||13)-1-core.getHeroLoc('x'), toY = (core.bigmap.height||13)-1-core.getHeroLoc('y');\ncore.getBlockId(toX, toY) == null",
-		"upFly": "var able=false;\nvar floorId = core.status.floorId, index = core.floorIds.indexOf(floorId);\nif (index<core.floorIds.length-1) {\n\tvar toId = core.floorIds[index+1], toX = core.getHeroLoc('x'), toY = core.getHeroLoc('y');\n\tvar mw = core.floors[toId].width||13, mh = core.floors[toId].height||13;\n\tif (toX>=0 && toX<mw && toY>=0 && toY<mh && core.getBlock(toX, toY, toId)==null) {\n\t\tcore.status.event.data = {'id': toId, 'x': toX, 'y': toY};\n\t\table=true;\n\t}\n}\nable",
-		"downFly": "var able=false;\nvar floorId = core.status.floorId, index = core.floorIds.indexOf(floorId);\nif (index>0) {\n\tvar toId = core.floorIds[index-1], toX = core.getHeroLoc('x'), toY = core.getHeroLoc('y');\n\tvar mw = core.floors[toId].width||13, mh = core.floors[toId].height||13;\n\tif (toX>=0 && toX<mw && toY>=0 && toY<mh && core.getBlock(toX, toY, toId)==null) {\n\t\tcore.status.event.data = {'id': toId, 'x': toX, 'y': toY};\n\t\table=true;\n\t}\n}\nable",
-		"snow": "var able=false;\nvar ids = [], id2s = [];\nfor (var i in core.status.thisMap.blocks) {\n\tvar block = core.status.thisMap.blocks[i];\n\tif (core.isset(block.event) && !block.disable && block.event.id == 'lava' && Math.abs(block.x-core.status.hero.loc.x)+Math.abs(block.y-core.status.hero.loc.y)<=1) {\n\t\tif (core.flags.snowFourDirections || (block.x == core.nextX() && block.y == core.nextY()))\n\t\t\tids.push(i);\n\t\telse id2s.push(i);\n\t}\n}\nif (ids.length>0) {\n\tcore.status.event.data = ids;\n\table=true;\n}\nelse if (id2s.length==1) {\n\tcore.status.event.data = id2s;\n\table=true;\n}\nable",
-		"bigKey": "var able=false;\nvar ids = [];\nfor (var i in core.status.thisMap.blocks) {\n    var block = core.status.thisMap.blocks[i];\n    if (core.isset(block.event) && !block.disable && block.event.id == 'yellowDoor') {\n        ids.push(i);\n    }\n}\nif (ids.length>0) {\n    core.status.event.data = ids;\n    able=true;\n}\nable",
-		"poisonWine": "core.hasFlag('poison')",
-		"weakWine": "core.hasFlag('weak')",
-		"curseWine": "core.hasFlag('curse')",
-		"superWine": "core.hasFlag('poison') || core.hasFlag('weak') || core.hasFlag('curse')",
-		"sword0": "true",
-		"sword1": "true",
-		"sword2": "true",
-		"sword3": "true",
-		"sword4": "true",
-		"sword5": "true",
-		"shield0": "true",
-		"shield1": "true",
-		"shield2": "true",
-		"shield3": "true",
-		"shield4": "true",
-		"shiled5": "true",
-		"shield5": "true",
+		"fly": "(function () {\n\treturn core.status.maps[core.status.floorId].canFlyTo;\n})();",
+		"pickaxe": "(function() {\n\tvar ids = [], id2s = [];\n\tfor (var i in core.status.thisMap.blocks) {\n\t\tvar block = core.status.thisMap.blocks[i];\n\t\tif (!block.disable && core.nearHero(block.x, block.y) && \n\t\t\t(block.event.canBreak || block.event.id == 'yellowWall' || block.event.id=='whiteWall' || block.event.id=='blueWall')) { // 能破哪些墙\n\t\t\t// 四个方向\n\t\t\tif (core.flags.pickaxeFourDirections || (block.x == core.nextX() && block.y == core.nextY()))\n\t\t\t\tids.push(i);\n\t\t\telse id2s.push(i);\n\t\t}\n\t}\n\tif (ids.length>0) {\n\t\tcore.status.event.ui = ids;\n\t\treturn true;\n\t}\n\telse if (id2s.length==1) {\n\t\tcore.status.event.ui = id2s;\n\t\treturn true;\n\t}\n\treturn false;\n})();",
+		"icePickaxe": "(function() {\n\tfor (var i in core.status.thisMap.blocks) {\n\t\tvar block = core.status.thisMap.blocks[i];\n\t\tif (!block.disable && block.x==core.nextX() && block.y==core.nextY() && block.event.id=='ice') {\n\t\t\tcore.status.event.ui = [i];\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn false;\n})();",
+		"bomb": "(function () {\n\tvar ids = [], id2s = [];\n\tfor (var i in core.status.thisMap.blocks) {\n\t\tvar block = core.status.thisMap.blocks[i];\n\t\tif (!block.disable && block.event.cls.indexOf('enemy')==0 && core.nearHero(block.x, block.y)) {\n\t\t\tvar enemy = core.material.enemys[block.event.id];\n\t\t\tif (core.isset(enemy) && enemy.notBomb) continue;\n\t\t\tif (core.flags.bombFourDirections || (block.x==core.nextX() && block.y==core.nextY()))\n\t\t\t\tids.push(i);\n\t\t\telse\n\t\t\t\tid2s.push(i);\n\t\t}\n\t}\n\tif (ids.length>0) {\n\t\tcore.status.event.ui = ids;\n\t\treturn true;\n\t}\n\tif (id2s.length==1) {\n\t\tcore.status.event.ui = id2s;\n\t\treturn true;\n\t}\n\treturn false;\n})();",
+		"hammer": "(function() {\n\tvar ids = [], id2s = [];\n\tfor (var i in core.status.thisMap.blocks) {\n\t\tvar block = core.status.thisMap.blocks[i];\n\t\tif (!block.disable && block.event.cls.indexOf('enemy')==0 && core.nearHero(block.x, block.y)) {\n\t\t\tvar enemy = core.material.enemys[block.event.id];\n\t\t\tif (core.isset(enemy) && enemy.notBomb) continue;\n\t\t\tif (block.x==core.nextX() && block.y==core.nextY())\n\t\t\t\tids.push(i);\n\t\t\telse\n\t\t\t\tid2s.push(i);\n\t\t}\n\t}\n\tif (ids.length>0) {\n\t\tcore.status.event.ui = ids;\n\t\treturn true;\n\t}\n\telse if (id2s.length==1) {\n\t\tcore.status.event.ui = id2s;\n\t\treturn true;\n\t}\n\treturn false;\n})();",
+		"earthquake": "(function () {\n\tvar able=false;\n\tvar ids = [];\n\tfor (var i in core.status.thisMap.blocks) {\n\t\tvar block = core.status.thisMap.blocks[i];\n\t\tif (!block.disable &&\n\t\t\t(block.event.canBreak || block.event.id == 'yellowWall' || block.event.id == 'blueWall' || block.event.id == 'whiteWall')) { // 能炸的墙壁\n\t\t\tids.push(i);\n\t\t}\n\t}\n\tif (ids.length>0) {\n\t\tcore.status.event.ui = ids;\n\t\table=true;\n\t}\n\treturn able;\n})();",
+		"centerFly": "(function () {\n\tvar toX = core.bigmap.width-1-core.getHeroLoc('x'), toY = core.bigmap.height-1-core.getHeroLoc('y');\n\tvar id = core.getBlockId(toX, toY);\n\treturn id == null;\n})();",
+		"upFly": "(function() {\n\tvar floorId = core.status.floorId, index = core.floorIds.indexOf(floorId);\n\tif (index<core.floorIds.length-1) {\n\t\tvar toId = core.floorIds[index+1], toX = core.getHeroLoc('x'), toY = core.getHeroLoc('y');\n\t\tvar mw = core.floors[toId].width, mh = core.floors[toId].height;\n\t\tif (toX>=0 && toX<mw && toY>=0 && toY<mh && core.getBlock(toX, toY, toId)==null) {\n\t\t\tcore.status.event.ui = {'id': toId, 'x': toX, 'y': toY};\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn false;\n})();",
+		"downFly": "(function() {\n\tvar floorId = core.status.floorId, index = core.floorIds.indexOf(floorId);\n\tif (index>0) {\n\t\tvar toId = core.floorIds[index-1], toX = core.getHeroLoc('x'), toY = core.getHeroLoc('y');\n\t\tvar mw = core.floors[toId].width, mh = core.floors[toId].height;\n\t\tif (toX>=0 && toX<mw && toY>=0 && toY<mh && core.getBlock(toX, toY, toId)==null) {\n\t\t\tcore.status.event.ui = {'id': toId, 'x': toX, 'y': toY};\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn false;\n})();",
+		"snow": "(function () {\n\tvar ids = [], id2s = [];\n\tfor (var i in core.status.thisMap.blocks) {\n\t\tvar block = core.status.thisMap.blocks[i];\n\t\tif (!block.disable && block.event.id == 'lava' && core.nearHero(block.x, block.y)) {\n\t\t\tif (core.flags.snowFourDirections || (block.x == core.nextX() && block.y == core.nextY()))\n\t\t\t\tids.push(i);\n\t\t\telse id2s.push(i);\n\t\t}\n\t}\n\tif (ids.length>0) {\n\t\tcore.status.event.ui = ids;\n\t\treturn true;\n\t}\n\tif (id2s.length==1) {\n\t\tcore.status.event.ui = id2s;\n\t\treturn true;\n\t}\n\treturn false;\n})();",
+		"bigKey": "(function() {\n\tvar able=false, ids = [];\n\tfor (var i in core.status.thisMap.blocks) {\n\t\tvar block = core.status.thisMap.blocks[i];\n\t\tif (!block.disable && block.event.id == 'yellowDoor') {\n\t\t\tids.push(i);\n\t\t}\n\t}\n\tif (ids.length>0) {\n\t\tcore.status.event.ui = ids;\n\t\table=true;\n\t}\n\treturn able;\n})();",
+		"poisonWine": "core.hasFlag('poison');",
+		"weakWine": "core.hasFlag('weak');",
+		"curseWine": "core.hasFlag('curse');",
+		"superWine": "(function() {\n\treturn core.hasFlag('poison') || core.hasFlag('weak') || core.hasFlag('curse');\n})();",
 		"lifeWand": "true",
-		"jumpShoes": "var nx=core.nextX(2),ny=core.nextY(2);nx>=0&&nx<core.bigmap.width&&ny>=0&&ny<core.bigmap.height&&core.getBlock(nx,ny)==null"
-	}
+		"jumpShoes": "(function() {\n\tvar nx=core.nextX(2), ny=core.nextY(2);\n\treturn nx>=0 && nx<core.bigmap.width && ny>=0 && ny<core.bigmap.height && core.getBlockId(nx,ny)==null;\n})();",
+		"redPotion": "true",
+		"bluePotion": "true",
+		"greenPotion": "true",
+		"yellowPotion": "true",
+		"redJewel": "true",
+		"blueJewel": "true",
+		"greenJewel": "true",
+		"yellowJewel": "true",
+		"skill1": "true"
+	},
+	"equipCondition": {}
 }
\ No newline at end of file
diff --git a/project/maps.js b/project/maps.js
index afaaaa8c..d631d0ba 100644
--- a/project/maps.js
+++ b/project/maps.js
@@ -1,227 +1,199 @@
-maps_90f36752_8815_4be8_b32b_d7fad1d0542e = 
+var maps_90f36752_8815_4be8_b32b_d7fad1d0542e = 
 {
-    ////////////////////////// 地形部分 //////////////////////////
-
-    // 0-20 地形
-    '1':{'cls': 'terrains', 'id': 'yellowWall'}, // 黄墙
-    '2':{'cls': 'terrains', 'id': 'whiteWall'}, // 白墙
-    '3':{'cls': 'terrains', 'id': 'blueWall'}, // 蓝墙
-    '4':{'cls': 'animates', 'id': 'star', 'noPass': true}, // 星空
-    '5':{'cls': 'animates', 'id': 'lava', 'noPass': true}, // 岩浆
-    '6':{'cls': 'terrains', 'id': 'ice'}, // 冰面
-    '7':{'cls': 'terrains', 'id': 'blueShop-left'}, // 蓝色商店左
-    '8':{'cls': 'terrains', 'id': 'blueShop-right'}, // 蓝色商店右
-    '9':{'cls': 'terrains', 'id': 'pinkShop-left'}, // 粉色商店左
-    '10':{'cls': 'terrains', 'id': 'pinkShop-right'}, // 粉色商店左
-    '11':{'cls': 'animates', 'id': 'lavaNet', 'noPass': false, 'trigger': 'passNet'}, // 血网
-    '12':{'cls': 'animates', 'id': 'poisonNet', 'noPass': false, 'trigger': 'passNet'}, // 毒网
-    '13':{'cls': 'animates', 'id': 'weakNet', 'noPass': false, 'trigger': 'passNet'}, // 衰网
-    '14':{'cls': 'animates', 'id': 'curseNet', 'noPass': false, 'trigger': 'passNet'}, // 咒网
-    '15':{'cls': 'animates', 'id': 'blueWater', 'noPass': true}, // 水
-    '16':{'cls': 'animates', 'id': 'water', 'noPass': true}, // 水
-    // 在这里添加更多地形
-    // 如果空位不足，可以从180以后开始继续放，只要不和现有的数字冲突即可
-
-    // Autotile
-    '20':{'cls': 'autotile', 'id': 'autotile', 'noPass': true}, // autotile
-    // 更多的autotile从151到160等，只要不和现有的数字冲突即可
-    '151':{'cls': 'autotile', 'id': 'autotile1', 'noPass': true},
-    '152':{'cls': 'autotile', 'id': 'autotile2', 'noPass': true},
-    '153':{'cls': 'autotile', 'id': 'autotile3', 'noPass': true},
-
-    ////////////////////////// 物品部分 //////////////////////////
-
-    // 21-80 物品
-    '21':{'cls': 'items', 'id': 'yellowKey'}, // 黄钥匙
-    '22':{'cls': 'items', 'id': 'blueKey'}, // 蓝钥匙
-    '23':{'cls': 'items', 'id': 'redKey'}, // 红钥匙
-    '24':{'cls': 'items', 'id': 'greenKey'}, // 绿钥匙
-    '25':{'cls': 'items', 'id': 'steelKey'}, // 铁门钥匙
-    '26':{'cls': 'items', 'id': 'bigKey'}, // 大黄门钥匙（钥匙盒）
-    '27':{'cls': 'items', 'id': 'redJewel'}, // 红宝石
-    '28':{'cls': 'items', 'id': 'blueJewel'}, // 蓝宝石
-    '29':{'cls': 'items', 'id': 'greenJewel'}, // 绿宝石
-    '30':{'cls': 'items', 'id': 'yellowJewel'}, // 黄宝石
-    '31':{'cls': 'items', 'id': 'redPotion'}, // 红血瓶
-    '32':{'cls': 'items', 'id': 'bluePotion'}, // 蓝血瓶
-    '33':{'cls': 'items', 'id': 'greenPotion'}, // 绿血瓶
-    '34':{'cls': 'items', 'id': 'yellowPotion'}, // 黄血瓶
-    '35':{'cls': 'items', 'id': 'sword1'}, // 铁剑
-    '36':{'cls': 'items', 'id': 'shield1'}, // 铁盾
-    '37':{'cls': 'items', 'id': 'sword2'}, // 银剑
-    '38':{'cls': 'items', 'id': 'shield2'}, // 银盾
-    '39':{'cls': 'items', 'id': 'sword3'}, // 骑士剑
-    '40':{'cls': 'items', 'id': 'shield3'}, // 骑士盾
-    '41':{'cls': 'items', 'id': 'sword4'}, // 圣剑
-    '42':{'cls': 'items', 'id': 'shield4'}, // 圣盾
-    '43':{'cls': 'items', 'id': 'sword5'}, // 神圣剑
-    '44':{'cls': 'items', 'id': 'shield5'}, // 神圣盾
-    '45':{'cls': 'items', 'id': 'book'}, // 怪物手册
-    '46':{'cls': 'items', 'id': 'fly'}, // 楼层传送器
-    '47':{'cls': 'items', 'id': 'pickaxe'}, // 破墙镐
-    '48':{'cls': 'items', 'id': 'icePickaxe'}, // 破冰镐
-    '49':{'cls': 'items', 'id': 'bomb'}, // 炸弹
-    '50':{'cls': 'items', 'id': 'centerFly'}, // 中心对称
-    '51':{'cls': 'items', 'id': 'upFly'}, // 上楼器
-    '52':{'cls': 'items', 'id': 'downFly'}, // 下楼器
-    '53':{'cls': 'items', 'id': 'coin'}, // 幸运金币
-    '54':{'cls': 'items', 'id': 'snow'}, // 冰冻徽章
-    '55':{'cls': 'items', 'id': 'cross'}, // 十字架
-    '56':{'cls': 'items', 'id': 'superPotion'}, // 圣水
-    '57':{'cls': 'items', 'id': 'earthquake'}, // 地震卷轴
-    '58':{'cls': 'items', 'id': 'poisonWine'}, // 解毒药水
-    '59':{'cls': 'items', 'id': 'weakWine'}, // 解衰药水
-    '60':{'cls': 'items', 'id': 'curseWine'}, // 解咒药水
-    '61':{'cls': 'items', 'id': 'superWine'}, // 万能药水
-    '62':{'cls': 'items', 'id': 'knife'}, // 屠龙匕首
-    '63':{'cls': 'items', 'id': 'moneyPocket'}, // 金钱袋
-    '64':{'cls': 'items', 'id': 'shoes'}, // 绿鞋
-    '65':{'cls': 'items', 'id': 'hammer'}, // 圣锤
-    '66':{'cls': 'items', 'id': 'sword0'}, // 空剑
-    '67':{'cls': 'items', 'id': 'shield0'}, // 空盾
-    '68':{'cls': 'items', 'id': 'lifeWand'}, // 生命魔杖
-    '69':{'cls': 'items', 'id': 'jumpShoes'}, // 生命魔杖
-
-
-    ////////////////////////// 门、楼梯、传送点部分 //////////////////////////
-
-    // 81-100 门
-    '81':{'cls': 'terrains', 'id': 'yellowDoor', 'trigger': 'openDoor'}, // 黄门
-    '82':{'cls': 'terrains', 'id': 'blueDoor', 'trigger': 'openDoor'}, // 蓝门
-    '83':{'cls': 'terrains', 'id': 'redDoor', 'trigger': 'openDoor'}, // 红门
-    '84':{'cls': 'terrains', 'id': 'greenDoor', 'trigger': 'openDoor'}, // 绿门
-    '85':{'cls': 'terrains', 'id': 'specialDoor', 'trigger': 'openDoor'}, // 机关门左
-    '86':{'cls': 'terrains', 'id': 'steelDoor', 'trigger': 'openDoor'}, // 铁门
-    '87':{'cls': 'terrains', 'id': 'upFloor', 'noPass': false}, // 上楼梯
-    '88':{'cls': 'terrains', 'id': 'downFloor', 'noPass': false}, // 下楼梯
-    '89':{'cls': 'animates', 'id': 'portal', 'noPass': false}, // 传送门
-    '90':{'cls': 'animates', 'id': 'starPortal', 'noPass': false}, // 星空传送门
-    '91':{'cls': 'animates', 'id': 'upPortal', 'noPass': false}, // 上箭头
-    '92':{'cls': 'animates', 'id': 'leftPortal', 'noPass': false}, // 左箭头
-    '93':{'cls': 'animates', 'id': 'downPortal', 'noPass': false}, // 下箭头
-    '94':{'cls': 'animates', 'id': 'rightPortal', 'noPass': false}, // 右箭头
-
-
-    ////////////////////////// NPC部分 //////////////////////////
-
-    // 121-150 NPC
-    '121':{'cls': 'npcs', 'id': 'man'},
-    '122':{'cls': 'npcs', 'id': 'woman'},
-    '123':{'cls': 'npcs', 'id': 'thief'},
-    '124':{'cls': 'npcs', 'id': 'fairy'},
-    '125':{'cls': 'npcs', 'id': 'magician'},
-    '126':{'cls': 'npcs', 'id': 'womanMagician'},
-    '127':{'cls': 'npcs', 'id': 'oldMan'},
-    '128':{'cls': 'npcs', 'id': 'child'},
-    '129':{'cls': 'npcs', 'id': 'wood'},
-    '130':{'cls': 'npcs', 'id': 'pinkShop'},
-    '131':{'cls': 'npcs', 'id': 'blueShop'},
-    '132':{'cls': 'npcs', 'id': 'princess'},
-    '133': {'cls': 'npc48', 'id': 'npc0'},
-    '134': {'cls': 'npc48', 'id': 'npc1'},
-    '135': {'cls': 'npc48', 'id': 'npc2'},
-    '136': {'cls': 'npc48', 'id': 'npc3'},
-    '137': {'cls': 'npc48', 'id': 'npc4'},
-    
-    '181': {'cls': 'npcs', 'id': 'wlt'},
-    '182': {'cls': 'npcs', 'id': 'wt'},
-    '183': {'cls': 'npcs', 'id': 'wrt'},
-    '184': {'cls': 'npcs', 'id': 'wl'},
-    '185': {'cls': 'npcs', 'id': 'wc'},
-    '186': {'cls': 'npcs', 'id': 'wr'},
-    '187': {'cls': 'npcs', 'id': 'wlb'},
-    '188': {'cls': 'npcs', 'id': 'wrb'},
-    '189': {'cls': 'npcs', 'id': 'dlt'},
-    '190': {'cls': 'npcs', 'id': 'dt'},
-    '191': {'cls': 'npcs', 'id': 'drt'},
-    '192': {'cls': 'npcs', 'id': 'dl'},
-    '193': {'cls': 'npcs', 'id': 'dc'},
-    '194': {'cls': 'npcs', 'id': 'dr'},
-    '195': {'cls': 'npcs', 'id': 'dlb'},
-    '196': {'cls': 'npcs', 'id': 'drb'},
-
-    ////////////////////////// 其他部分 //////////////////////////
-
-    // 171-200 其他（单向箭头、灯、箱子等等）
-    '161':{'cls': 'terrains', 'id': 'arrowUp', 'noPass': false}, // 单向上箭头
-    '162':{'cls': 'terrains', 'id': 'arrowDown', 'noPass': false}, // 单向下箭头
-    '163':{'cls': 'terrains', 'id': 'arrowLeft', 'noPass': false}, // 单向左箭头
-    '164':{'cls': 'terrains', 'id': 'arrowRight', 'noPass': false}, // 单向右箭头
-    '165':{'cls': 'terrains', 'id': 'light', 'trigger': 'changeLight', 'noPass': false}, // 灯
-    '166':{'cls': 'terrains', 'id': 'darkLight', 'noPass': true}, // 暗灯
-    '167':{'cls': 'terrains', 'id': 'ski', 'trigger': 'ski', 'noPass': false}, // 滑冰
-    '168':{'cls': 'terrains', 'id': 'flower', 'noPass': false}, // 花
-    '169':{'cls': 'terrains', 'id': 'box', 'trigger': 'pushBox', 'noPass': true}, // 箱子
-    '170':{'cls': 'terrains', 'id': 'boxed', 'trigger': 'pushBox', 'noPass': true}, // 完成的箱子
-
-    ////////////////////////// 怪物部分 //////////////////////////
-
-    // 201-300 怪物
-    '201':{'cls': 'enemys', 'id': 'greenSlime'},
-    '202':{'cls': 'enemys', 'id': 'redSlime'},
-    '203':{'cls': 'enemys', 'id': 'blackSlime'},
-    '204':{'cls': 'enemys', 'id': 'slimelord'},
-    '205':{'cls': 'enemys', 'id': 'bat'},
-    '206':{'cls': 'enemys', 'id': 'bigBat'},
-    '207':{'cls': 'enemys', 'id': 'redBat'},
-    '208':{'cls': 'enemys', 'id': 'vampire'},
-    '209':{'cls': 'enemys', 'id': 'skeleton'},
-    '210':{'cls': 'enemys', 'id': 'skeletonSoilder'},
-    '211':{'cls': 'enemys', 'id': 'skeletonCaptain'},
-    '212':{'cls': 'enemys', 'id': 'ghostSkeleton'},
-    '213':{'cls': 'enemys', 'id': 'zombie'},
-    '214':{'cls': 'enemys', 'id': 'zombieKnight'},
-    '215':{'cls': 'enemys', 'id': 'rock'},
-    '216':{'cls': 'enemys', 'id': 'slimeMan'},
-    '217':{'cls': 'enemys', 'id': 'bluePriest'},
-    '218':{'cls': 'enemys', 'id': 'redPriest'},
-    '219':{'cls': 'enemys', 'id': 'brownWizard'},
-    '220':{'cls': 'enemys', 'id': 'redWizard'},
-    '221':{'cls': 'enemys', 'id': 'yellowGuard'},
-    '222':{'cls': 'enemys', 'id': 'blueGuard'},
-    '223':{'cls': 'enemys', 'id': 'redGuard'},
-    '224':{'cls': 'enemys', 'id': 'swordsman'},
-    '225':{'cls': 'enemys', 'id': 'soldier'},
-    '226':{'cls': 'enemys', 'id': 'yellowKnight'},
-    '227':{'cls': 'enemys', 'id': 'redKnight'},
-    '228':{'cls': 'enemys', 'id': 'darkKnight'},
-    '229':{'cls': 'enemys', 'id': 'blackKing'},
-    '230':{'cls': 'enemys', 'id': 'yellowKing'},
-    '231':{'cls': 'enemys', 'id': 'greenKing'},
-    '232':{'cls': 'enemys', 'id': 'blueKnight'},
-    '233':{'cls': 'enemys', 'id': 'goldSlime'},
-    '234':{'cls': 'enemys', 'id': 'poisonSkeleton'},
-    '235':{'cls': 'enemys', 'id': 'poisonBat'},
-    '236':{'cls': 'enemys', 'id': 'steelRock'},
-    '237':{'cls': 'enemys', 'id': 'skeletonPriest'},
-    '238':{'cls': 'enemys', 'id': 'skeletonKing'},
-    '239':{'cls': 'enemys', 'id': 'skeletonWizard'},
-    '240':{'cls': 'enemys', 'id': 'redSkeletonCaption'},
-    '241':{'cls': 'enemys', 'id': 'badHero'},
-    '242':{'cls': 'enemys', 'id': 'demon'},
-    '243':{'cls': 'enemys', 'id': 'demonPriest'},
-    '244':{'cls': 'enemys', 'id': 'goldHornSlime'},
-    '245':{'cls': 'enemys', 'id': 'redKing'},
-    '246':{'cls': 'enemys', 'id': 'whiteKing'},
-    '247':{'cls': 'enemys', 'id': 'blackMagician'},
-    '248':{'cls': 'enemys', 'id': 'silverSlime'},
-    '249':{'cls': 'enemys', 'id': 'swordEmperor'},
-    '250':{'cls': 'enemys', 'id': 'whiteHornSlime'},
-    '251':{'cls': 'enemys', 'id': 'badPrincess'},
-    '252':{'cls': 'enemys', 'id': 'badFairy'},
-    '253':{'cls': 'enemys', 'id': 'grayPriest'},
-    '254':{'cls': 'enemys', 'id': 'redSwordsman'},
-    '255':{'cls': 'enemys', 'id': 'whiteGhost'},
-    '256':{'cls': 'enemys', 'id': 'poisonZombie'},
-    '257':{'cls': 'enemys', 'id': 'magicDragon'},
-    '258':{'cls': 'enemys', 'id': 'octopus'},
-    '259':{'cls': 'enemys', 'id': 'darkFairy'},
-    '260':{'cls': 'enemys', 'id': 'greenKnight'},
-
-    '261':{'cls': 'enemy48', 'id': 'angel'},
-    '262':{'cls': 'enemy48', 'id': 'elemental'},
-    '263':{'cls': 'enemy48', 'id': 'steelGuard'},
-    '264':{'cls': 'enemy48', 'id': 'evilBat'},
-
-    ////////////////////////// 待定... //////////////////////////
+	"1": {"cls":"terrains","id":"yellowWall","canBreak":true},
+	"2": {"cls":"terrains","id":"whiteWall","canBreak":true},
+	"3": {"cls":"terrains","id":"blueWall","canBreak":true},
+	"4": {"cls":"animates","id":"star","noPass":true},
+	"5": {"cls":"animates","id":"lava","noPass":true},
+	"6": {"cls":"terrains","id":"ice"},
+	"7": {"cls":"terrains","id":"blueShop-left"},
+	"8": {"cls":"terrains","id":"blueShop-right"},
+	"9": {"cls":"terrains","id":"pinkShop-left"},
+	"10": {"cls":"terrains","id":"pinkShop-right"},
+	"11": {"cls":"animates","id":"lavaNet","noPass":false,"trigger":"passNet"},
+	"12": {"cls":"animates","id":"poisonNet","noPass":false,"trigger":"passNet"},
+	"13": {"cls":"animates","id":"weakNet","noPass":false,"trigger":"passNet"},
+	"14": {"cls":"animates","id":"curseNet","noPass":false,"trigger":"passNet"},
+	"15": {"cls":"animates","id":"blueWater","noPass":true},
+	"16": {"cls":"animates","id":"water","noPass":true},
+	"20": {"cls":"autotile","id":"autotile","noPass":true},
+	"21": {"cls":"items","id":"yellowKey"},
+	"22": {"cls":"items","id":"blueKey"},
+	"23": {"cls":"items","id":"redKey"},
+	"24": {"cls":"items","id":"greenKey"},
+	"25": {"cls":"items","id":"steelKey"},
+	"26": {"cls":"items","id":"bigKey"},
+	"27": {"cls":"items","id":"redJewel"},
+	"28": {"cls":"items","id":"blueJewel"},
+	"29": {"cls":"items","id":"greenJewel"},
+	"30": {"cls":"items","id":"yellowJewel"},
+	"31": {"cls":"items","id":"redPotion"},
+	"32": {"cls":"items","id":"bluePotion"},
+	"33": {"cls":"items","id":"greenPotion"},
+	"34": {"cls":"items","id":"yellowPotion"},
+	"35": {"cls":"items","id":"sword1"},
+	"36": {"cls":"items","id":"shield1"},
+	"37": {"cls":"items","id":"sword2"},
+	"38": {"cls":"items","id":"shield2"},
+	"39": {"cls":"items","id":"sword3"},
+	"40": {"cls":"items","id":"shield3"},
+	"41": {"cls":"items","id":"sword4"},
+	"42": {"cls":"items","id":"shield4"},
+	"43": {"cls":"items","id":"sword5"},
+	"44": {"cls":"items","id":"shield5"},
+	"45": {"cls":"items","id":"book"},
+	"46": {"cls":"items","id":"fly"},
+	"47": {"cls":"items","id":"pickaxe"},
+	"48": {"cls":"items","id":"icePickaxe"},
+	"49": {"cls":"items","id":"bomb"},
+	"50": {"cls":"items","id":"centerFly"},
+	"51": {"cls":"items","id":"upFly"},
+	"52": {"cls":"items","id":"downFly"},
+	"53": {"cls":"items","id":"coin"},
+	"54": {"cls":"items","id":"snow"},
+	"55": {"cls":"items","id":"cross"},
+	"56": {"cls":"items","id":"superPotion"},
+	"57": {"cls":"items","id":"earthquake"},
+	"58": {"cls":"items","id":"poisonWine"},
+	"59": {"cls":"items","id":"weakWine"},
+	"60": {"cls":"items","id":"curseWine"},
+	"61": {"cls":"items","id":"superWine"},
+	"62": {"cls":"items","id":"knife"},
+	"63": {"cls":"items","id":"moneyPocket"},
+	"64": {"cls":"items","id":"shoes"},
+	"65": {"cls":"items","id":"hammer"},
+	"68": {"cls":"items","id":"lifeWand"},
+	"69": {"cls":"items","id":"jumpShoes"},
+	"70": {"cls":"items","id":"sword0"},
+	"71": {"cls":"items","id":"shield0"},
+	"72": {"cls":"items","id":"skill1"},
+	"73": {"cls":"items","id":"wand"},
+	"81": {"cls":"terrains","id":"yellowDoor","trigger":"openDoor"},
+	"82": {"cls":"terrains","id":"blueDoor","trigger":"openDoor"},
+	"83": {"cls":"terrains","id":"redDoor","trigger":"openDoor"},
+	"84": {"cls":"terrains","id":"greenDoor","trigger":"openDoor"},
+	"85": {"cls":"terrains","id":"specialDoor","trigger":"openDoor"},
+	"86": {"cls":"terrains","id":"steelDoor","trigger":"openDoor"},
+	"87": {"cls":"terrains","id":"upFloor","noPass":false},
+	"88": {"cls":"terrains","id":"downFloor","noPass":false},
+	"89": {"cls":"animates","id":"portal","noPass":false},
+	"90": {"cls":"animates","id":"starPortal","noPass":false},
+	"91": {"cls":"animates","id":"upPortal","noPass":false},
+	"92": {"cls":"animates","id":"leftPortal","noPass":false},
+	"93": {"cls":"animates","id":"downPortal","noPass":false},
+	"94": {"cls":"animates","id":"rightPortal","noPass":false},
+	"101": {"cls":"animates","id":"crystalUp"},
+	"102": {"cls":"animates","id":"crystalBottom"},
+	"103": {"cls":"animates","id":"fire"},
+	"104": {"cls":"animates","id":"switch"},
+	"121": {"cls":"npcs","id":"man"},
+	"122": {"cls":"npcs","id":"woman"},
+	"123": {"cls":"npcs","id":"thief"},
+	"124": {"cls":"npcs","id":"fairy"},
+	"125": {"cls":"npcs","id":"magician"},
+	"126": {"cls":"npcs","id":"womanMagician"},
+	"127": {"cls":"npcs","id":"oldMan"},
+	"128": {"cls":"npcs","id":"child"},
+	"129": {"cls":"npcs","id":"wood"},
+	"130": {"cls":"npcs","id":"pinkShop"},
+	"131": {"cls":"npcs","id":"blueShop"},
+	"132": {"cls":"npcs","id":"princess"},
+	"133": {"cls":"npc48","id":"npc0"},
+	"134": {"cls":"npc48","id":"npc1"},
+	"135": {"cls":"npc48","id":"npc2"},
+	"136": {"cls":"npc48","id":"npc3"},
+	"137": {"cls":"npc48","id":"npc4"},
+	"151": {"cls":"autotile","id":"autotile1","noPass":true},
+	"152": {"cls":"autotile","id":"autotile2","noPass":true},
+	"153": {"cls":"autotile","id":"autotile3","noPass":true},
+	"161": {"cls":"terrains","id":"arrowUp","noPass":false,"cannotOut":["left","right","down"],"cannotIn":["down"]},
+	"162": {"cls":"terrains","id":"arrowDown","noPass":false,"cannotOut":["left","right","up"],"cannotIn":["up"]},
+	"163": {"cls":"terrains","id":"arrowLeft","noPass":false,"cannotOut":["up","down","right"],"cannotIn":["right"]},
+	"164": {"cls":"terrains","id":"arrowRight","noPass":false,"cannotOut":["up","down","left"],"cannotIn":["left"]},
+	"165": {"cls":"terrains","id":"light","trigger":"changeLight","noPass":false},
+	"166": {"cls":"terrains","id":"darkLight","noPass":true},
+	"167": {"cls":"terrains","id":"ski","trigger":"ski","noPass":false},
+	"168": {"cls":"terrains","id":"flower","noPass":false},
+	"169": {"cls":"terrains","id":"box","trigger":"pushBox","noPass":true},
+	"170": {"cls":"terrains","id":"boxed","trigger":"pushBox","noPass":true},
+	"181": {"cls":"npcs","id":"wlt"},
+	"182": {"cls":"npcs","id":"wt"},
+	"183": {"cls":"npcs","id":"wrt"},
+	"184": {"cls":"npcs","id":"wl"},
+	"185": {"cls":"npcs","id":"wc"},
+	"186": {"cls":"npcs","id":"wr"},
+	"187": {"cls":"npcs","id":"wlb"},
+	"188": {"cls":"npcs","id":"wrb"},
+	"189": {"cls":"npcs","id":"dlt"},
+	"190": {"cls":"npcs","id":"dt"},
+	"191": {"cls":"npcs","id":"drt"},
+	"192": {"cls":"npcs","id":"dl"},
+	"193": {"cls":"npcs","id":"dc"},
+	"194": {"cls":"npcs","id":"dr"},
+	"195": {"cls":"npcs","id":"dlb"},
+	"196": {"cls":"npcs","id":"drb"},
+	"201": {"cls":"enemys","id":"greenSlime"},
+	"202": {"cls":"enemys","id":"redSlime"},
+	"203": {"cls":"enemys","id":"blackSlime"},
+	"204": {"cls":"enemys","id":"slimelord"},
+	"205": {"cls":"enemys","id":"bat"},
+	"206": {"cls":"enemys","id":"bigBat"},
+	"207": {"cls":"enemys","id":"redBat"},
+	"208": {"cls":"enemys","id":"vampire"},
+	"209": {"cls":"enemys","id":"skeleton"},
+	"210": {"cls":"enemys","id":"skeletonSoilder"},
+	"211": {"cls":"enemys","id":"skeletonCaptain"},
+	"212": {"cls":"enemys","id":"ghostSkeleton"},
+	"213": {"cls":"enemys","id":"zombie"},
+	"214": {"cls":"enemys","id":"zombieKnight"},
+	"215": {"cls":"enemys","id":"rock"},
+	"216": {"cls":"enemys","id":"slimeMan"},
+	"217": {"cls":"enemys","id":"bluePriest"},
+	"218": {"cls":"enemys","id":"redPriest"},
+	"219": {"cls":"enemys","id":"brownWizard"},
+	"220": {"cls":"enemys","id":"redWizard"},
+	"221": {"cls":"enemys","id":"yellowGuard"},
+	"222": {"cls":"enemys","id":"blueGuard"},
+	"223": {"cls":"enemys","id":"redGuard"},
+	"224": {"cls":"enemys","id":"swordsman"},
+	"225": {"cls":"enemys","id":"soldier"},
+	"226": {"cls":"enemys","id":"yellowKnight"},
+	"227": {"cls":"enemys","id":"redKnight"},
+	"228": {"cls":"enemys","id":"darkKnight"},
+	"229": {"cls":"enemys","id":"blackKing"},
+	"230": {"cls":"enemys","id":"yellowKing"},
+	"231": {"cls":"enemys","id":"greenKing"},
+	"232": {"cls":"enemys","id":"blueKnight"},
+	"233": {"cls":"enemys","id":"goldSlime"},
+	"234": {"cls":"enemys","id":"poisonSkeleton"},
+	"235": {"cls":"enemys","id":"poisonBat"},
+	"236": {"cls":"enemys","id":"steelRock"},
+	"237": {"cls":"enemys","id":"skeletonPriest"},
+	"238": {"cls":"enemys","id":"skeletonKing"},
+	"239": {"cls":"enemys","id":"skeletonWizard"},
+	"240": {"cls":"enemys","id":"redSkeletonCaption"},
+	"241": {"cls":"enemys","id":"badHero"},
+	"242": {"cls":"enemys","id":"demon"},
+	"243": {"cls":"enemys","id":"demonPriest"},
+	"244": {"cls":"enemys","id":"goldHornSlime"},
+	"245": {"cls":"enemys","id":"redKing"},
+	"246": {"cls":"enemys","id":"whiteKing"},
+	"247": {"cls":"enemys","id":"blackMagician"},
+	"248": {"cls":"enemys","id":"silverSlime"},
+	"249": {"cls":"enemys","id":"swordEmperor"},
+	"250": {"cls":"enemys","id":"whiteHornSlime"},
+	"251": {"cls":"enemys","id":"badPrincess"},
+	"252": {"cls":"enemys","id":"badFairy"},
+	"253": {"cls":"enemys","id":"grayPriest"},
+	"254": {"cls":"enemys","id":"redSwordsman"},
+	"255": {"cls":"enemys","id":"whiteGhost"},
+	"256": {"cls":"enemys","id":"poisonZombie"},
+	"257": {"cls":"enemys","id":"magicDragon"},
+	"258": {"cls":"enemys","id":"octopus"},
+	"259": {"cls":"enemys","id":"darkFairy"},
+	"260": {"cls":"enemys","id":"greenKnight"},
+	"261": {"cls":"enemy48","id":"angel"},
+	"262": {"cls":"enemy48","id":"elemental"},
+	"263": {"cls":"enemy48","id":"steelGuard"},
+	"264": {"cls":"enemy48","id":"evilBat"}
 }
\ No newline at end of file
diff --git a/project/plugins.js b/project/plugins.js
new file mode 100644
index 00000000..d09e9944
--- /dev/null
+++ b/project/plugins.js
@@ -0,0 +1,88 @@
+var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 = 
+{
+    "init": function () {
+
+	console.log("插件编写测试");
+
+	// 可以写一些直接执行的代码
+	// 在这里写的代码将会在【资源加载前】被执行，此时图片等资源尚未被加载。
+	// 请勿在这里对包括bgm，图片等资源进行操作。
+
+
+	this._afterLoadResources = function () {
+		// 本函数将在所有资源加载完毕后，游戏开启前被执行
+		// 可以在这个函数里面对资源进行一些操作，比如切分图片等。
+
+		// 这是一个将assets.png拆分成若干个32x32像素的小图片并保存的样例。
+		// var arr = core.splitImage("assets.png", 32, 32);
+		// for (var i = 0; i < arr.length; i++) {
+		//     core.material.images.images["asset"+i+".png"] = arr[i];
+		// }
+
+	}
+
+	// 可以在任何地方（如afterXXX或自定义脚本事件）调用函数，方法为 core.plugin.xxx();
+	// 从V2.6开始，插件中用this.XXX方式定义的函数也会被转发到core中，详见文档-脚本-函数的转发。
+},
+    "drawLight": function () {
+
+	// 绘制灯光/漆黑层效果。调用方式 core.plugin.drawLight(...)
+	// 【参数说明】
+	// name：必填，要绘制到的画布名；可以是一个系统画布，或者是个自定义画布；如果不存在则创建
+	// color：可选，只能是一个0~1之间的数，为不透明度的值。不填则默认为0.9。
+	// lights：可选，一个数组，定义了每个独立的灯光。
+	//        其中每一项是三元组 [x,y,r] x和y分别为该灯光的横纵坐标，r为该灯光的半径。
+	// lightDec：可选，0到1之间，光从多少百分比才开始衰减（在此范围内保持全亮），不设置默认为0。
+	//        比如lightDec为0.5代表，每个灯光部分内圈50%的范围全亮，50%以后才开始快速衰减。
+	// 【调用样例】
+	// core.plugin.drawLight('curtain'); // 在curtain层绘制全图不透明度0.9，等价于更改画面色调为[0,0,0,0.9]。
+	// core.plugin.drawLight('ui', 0.95, [[25,11,46]]); // 在ui层绘制全图不透明度0.95，其中在(25,11)点存在一个半径为46的灯光效果。
+	// core.plugin.drawLight('test', 0.2, [[25,11,46,0.1]]); // 创建一个test图层，不透明度0.2，其中在(25,11)点存在一个半径为46的灯光效果，灯光中心不透明度0.1。
+	// core.plugin.drawLight('test2', 0.9, [[25,11,46],[105,121,88],[301,221,106]]); // 创建test2图层，且存在三个灯光效果，分别是中心(25,11)半径46，中心(105,121)半径88，中心(301,221)半径106。
+	// core.plugin.drawLight('xxx', 0.3, [[25,11,46],[105,121,88,0.2]], 0.4); // 存在两个灯光效果，它们在内圈40%范围内保持全亮，且40%后才开始衰减。
+	this.drawLight = function (name, color, lights, lightDec) {
+
+		// 清空色调层；也可以修改成其它层比如animate/weather层，或者用自己创建的canvas
+		var ctx = core.getContextByName(name);
+		if (ctx == null) {
+			if (typeof name == 'string')
+				ctx = core.createCanvas(name, 0, 0, core.__PIXELS__, core.__PIXELS__, 98);
+			else return;
+		}
+
+		ctx.mozImageSmoothingEnabled = false;
+		ctx.webkitImageSmoothingEnabled = false;
+		ctx.msImageSmoothingEnabled = false;
+		ctx.imageSmoothingEnabled = false;
+
+		core.clearMap(name);
+		// 绘制色调层，默认不透明度
+		if (color == null) color = 0.9;
+		ctx.fillStyle = "rgba(0,0,0," + color + ")";
+		ctx.fillRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+
+		lightDec = core.clamp(lightDec, 0, 1);
+
+		// 绘制每个灯光效果
+		ctx.globalCompositeOperation = 'destination-out';
+		lights.forEach(function (light) {
+			// 坐标，半径，中心不透明度
+			var x = light[0],
+				y = light[1],
+				r = light[2];
+			// 计算衰减距离
+			var decDistance = parseInt(r * lightDec);
+			// 正方形区域的直径和左上角坐标
+			var grd = ctx.createRadialGradient(x, y, decDistance, x, y, r);
+			grd.addColorStop(0, "rgba(0,0,0,1)");
+			grd.addColorStop(1, "rgba(0,0,0,0)");
+			ctx.beginPath();
+			ctx.fillStyle = grd;
+			ctx.arc(x, y, r, 0, 2 * Math.PI);
+			ctx.fill();
+		});
+		ctx.globalCompositeOperation = 'source-over';
+		// 可以在任何地方（如afterXXX或自定义脚本事件）调用函数，方法为  core.plugin.xxx();
+	}
+}
+}
\ No newline at end of file
diff --git a/project/sounds/bomb.mp3 b/project/sounds/bomb.mp3
new file mode 100644
index 00000000..bf65b83a
Binary files /dev/null and b/project/sounds/bomb.mp3 differ
diff --git a/project/sounds/centerFly.mp3 b/project/sounds/centerFly.mp3
new file mode 100644
index 00000000..82467631
Binary files /dev/null and b/project/sounds/centerFly.mp3 differ
diff --git a/project/sounds/equip.mp3 b/project/sounds/equip.mp3
new file mode 100644
index 00000000..5d821780
Binary files /dev/null and b/project/sounds/equip.mp3 differ
diff --git a/project/sounds/pickaxe.mp3 b/project/sounds/pickaxe.mp3
new file mode 100644
index 00000000..be59c534
Binary files /dev/null and b/project/sounds/pickaxe.mp3 differ
diff --git a/styles.css b/styles.css
index 05637e6c..a1d6649e 100644
--- a/styles.css
+++ b/styles.css
@@ -21,7 +21,16 @@
     position: fixed;
     top: 10px;
     left: 10px;
-    z-index: 320;
+    z-index: 370;
+}
+
+#musicBtn {
+    position: fixed;
+    bottom: 3px;
+    right: 3px;
+    cursor: pointer;
+    z-index: 400;
+    display: none;
 }
 
 #startPanel {
@@ -32,7 +41,7 @@
     left: 0;
     background-color: #fff;
     overflow: hidden;
-    z-index: 250;
+    z-index: 300;
 }
 
 #startTop {
@@ -42,7 +51,7 @@
     top: 0;
     left: 0;
     background-color: #000;
-    z-index: 300;
+    z-index: 350;
 }
 
 #startTopProgressBar {
@@ -70,6 +79,15 @@
     z-index: 15;
 }
 
+#startTopHint {
+    color: #66CCFF;
+    position: absolute;
+    bottom: 0;
+    left: 5%;
+    z-index: 15;
+    font-size: 18px;
+}
+
 #startBackground {
     position:absolute;
     top:50%;
@@ -77,12 +95,12 @@
     height: 100%;
     width: auto;
     transform:translate(-50%,-50%);
-    z-index: 210;
+    z-index: 260;
 }
 
 #startLogo {
     position: absolute;
-    z-index: 240;
+    z-index: 290;
     left: 0;
     right: 0;
     margin-left: auto;
@@ -95,7 +113,7 @@
 
 #startTitle {
     position: absolute;
-    z-index: 230;
+    z-index: 280;
 }
 
 #startButtonGroup {
@@ -106,7 +124,7 @@
     background-color: #000;
     opacity: 0.85;
     display: none;
-    z-index: 260;
+    z-index: 310;
     bottom: 0;
     margin-bottom: 7%;
 }
@@ -133,16 +151,14 @@
 }
 
 #floorMsgGroup {
-    /* width: 100%;
-    height: 100%; */
-    /* top: 0;
-    right: 0; */
+    top: 3px;
+    right: 3px;
     position: absolute;
     text-align: center;
     display: none;
     color: #fff;
     background-color: #000;
-    z-index: 180;
+    z-index: 230;
 }
 
 #logoLabel {
@@ -170,13 +186,17 @@
     -moz-box-sizing: border-box;
     -webkit-box-sizing: border-box;
     background: url(project/images/ground.png) repeat;
-    z-index: 135;
+    z-index: 185;
     display: none;
+    top: 0;
+    left: 0;
+    padding: 3px;
 }
 #statusBar .status{
     position: relative;
     display: block;
     float: left;
+    width: 100%;
 }
 .status img{
     vertical-align: middle;
@@ -185,7 +205,6 @@
     max-height: 1.6em;
 }
 #statusBar span{
-    color: white;
     font: bold italic 1.1em Verdana;
 }
 #statusBar p {
@@ -200,11 +219,13 @@
 #toolBar {
     position: absolute;
     background: url(project/images/ground.png) repeat;
-    z-index: 160;
+    z-index: 210;
     box-sizing: border-box;
     -moz-box-sizing: border-box;
     -webkit-box-sizing: border-box;
     display: none;
+    left: 0;
+    padding: 3px;
 }
 #toolBar .tools{
     position: relative;
@@ -220,6 +241,7 @@ p#hard {
     font: bold normal 1.1em "Arial Black";
     text-align: center;
     margin: 0 6px 6px 0;
+    word-break: keep-all;
 }
 
 span#poison, span#weak, span#curse, span#pickaxe, span#bomb, span#fly {
@@ -227,6 +249,10 @@ span#poison, span#weak, span#curse, span#pickaxe, span#bomb, span#fly {
     font-size: 1em;
 }
 
+p#name {
+    font-style: normal;
+}
+
 .gameCanvas {
     position: absolute;
     box-sizing: border-box;
@@ -246,18 +272,11 @@ span#poison, span#weak, span#curse, span#pickaxe, span#bomb, span#fly {
     overflow: hidden;
 }
 
-#curtain {
-    z-index: 100;
-    position: absolute;
-    opacity: 0;
-    background: #000000;
-}
-
 #gameDraw {
     position: absolute;
     background: #000000;
     overflow: hidden;
-    z-index: 135;
+    z-index: 185;
 }
 
 #bg {
@@ -280,30 +299,70 @@ span#poison, span#weak, span#curse, span#pickaxe, span#bomb, span#fly {
     z-index: 60;
 }
 
+#damage {
+    z-index: 65;
+}
+
 #animate {
     z-index: 70;
 }
 
-#weather {
-    z-index: 80;
-}
-
-#route {
-    z-index: 105;
+#curtain {
+    z-index: 125;
 }
 
 #ui {
-    z-index: 110;
+    z-index: 140;
 }
 
 #data {
-    z-index: 120;
+    z-index: 170;
 }
 
-.clearfix:before,
-.clearfix:after {
-   content: ".";
-   display: block;
-   height: 0;
-   visibility: hidden;
+#inputDiv {
+    display: none;
+    width: 100%;
+    height: 100%;
+    position: fixed;
+    top: 0;
+    left: 0;
+    background: rgba(127,127,127,0.6);
+    z-index: 2000
+}
+
+#inputDialog {
+    position: fixed;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -60%);
+    background: white;
+    width: 250px;
+    min-height: 50px;
+    max-height: 250px;
+}
+
+#inputMessage {
+    word-wrap: break-word;
+    text-align: left;
+    margin-left: 8%;
+    margin-right: 5%;
+}
+
+#inputBox {
+    margin-left: 8%;
+    width: 80%;
+    margin-bottom: 10px;
+    padding: 5px 3px;
+    border: 1px solid;
+    background: #F0F0F0;
+}
+
+#inputYes {
+    margin-bottom: 15px;
+    margin-left: 8%;
+}
+
+#inputNo {
+    float:right;
+    margin-right: 10%;
 }
\ No newline at end of file
diff --git a/启动服务.exe b/启动服务.exe
index 3bd6b51a..f426d69b 100644
Binary files a/启动服务.exe and b/启动服务.exe differ
diff --git a/常用工具/JS代码压缩工具.exe b/常用工具/JS代码压缩工具.exe
index 318afa28..f0447910 100644
Binary files a/常用工具/JS代码压缩工具.exe and b/常用工具/JS代码压缩工具.exe differ
diff --git a/常用工具/RM动画导出器.exe b/常用工具/RM动画导出器.exe
index 53123a46..b894a786 100644
Binary files a/常用工具/RM动画导出器.exe and b/常用工具/RM动画导出器.exe differ
diff --git a/常用工具/便捷PS工具.exe b/常用工具/便捷PS工具.exe
index 422d76fa..90959cf0 100644
Binary files a/常用工具/便捷PS工具.exe and b/常用工具/便捷PS工具.exe differ
diff --git a/常用工具/地图生成器.exe b/常用工具/地图生成器.exe
index 98510404..46d48547 100644
Binary files a/常用工具/地图生成器.exe and b/常用工具/地图生成器.exe differ
diff --git a/常用工具/怪物数据导出器.exe b/常用工具/怪物数据导出器.exe
index 2e6a2780..493a5465 100644
Binary files a/常用工具/怪物数据导出器.exe and b/常用工具/怪物数据导出器.exe differ
diff --git a/更新说明.txt b/更新说明.txt
index 5fa96440..c66b427b 100644
--- a/更新说明.txt
+++ b/更新说明.txt
@@ -1,12 +1,243 @@
-HTML5魔塔样板V2.3.4
+HTML5魔塔样板V2.6.1
+
+区域优化的录像播放功能，R键使用
+强制战斗可以指定怪物坐标，将自动隐藏并执行该点战后事件
+flag:xxx也支持中文，例如 flag:2楼机关门
+增加文件名映射，可以用中文映射到某个图片或bgm文件并使用
+勇士宽度可以超过32（例如48x48的勇士行走图）
+现在允许修改floorId和图块ID了（在表格下方）
+增加事件：自动存档，返回标题界面；部分事件优化
+商店长按空格可以连续加点
+增设global:xxx使用全局存储，可被录像支持
+支持\b[hero]和\b[null,x,y]来自动调整上下方向
+支持\t[yellowKey]等只显示图标而没有标题
+编辑器中前景层对于有事件的点半透明显示
+存档改成1000页，长按上下页可快速翻页
+录像播放初始默认暂停，N键可以单步执行
+增设本地API文档，部分API和事件的优化
+所有已知的bug修复，大量细节优化
+
+-----------------------------------------------------------------------
+
+HTML5魔塔样板V2.6
+
+拆分整个项目，大幅重构代码，新增大量API
+重写文档，尤其是脚本和API列表
+现在可以对编辑器的表格的结构进行配置
+可以收藏和高亮存档
+独立出来的插件编写
+新增事件：关门、显示确认框、后置循环处理
+剧情文本的绘制可以设置居中选项
+选项框的绘制可以增加图标
+增加公共事件版的全局商店
+公共事件现在可以传入参数
+重写滑冰事件，现在滑冰在背景层了
+将输入框改成自定义实现，避免部分设备不支持
+状态栏文字可以自动放缩
+显示图片和对话框立绘可以裁剪图片
+修复所有已知bug，大量细节优化
+
+-----------------------------------------------------------------------
+
+HTML5魔塔样板V2.5.5
+
+现在编辑器修改地图后可以直接读档生效，无需再重置地图或回放录像
+存档方式优化，大幅降低单个存档的占用空间
+脚本编辑器增加代码格式化的选项
+事件和脚本编辑器中Ctrl+S可以进行保存
+显示选择项提供颜色控制
+事件的移动勇士增加前进和后退两个操作
+事件编辑器的下拉框增加滚动条
+通关后将询问是否进行评分
+录像播放失败后可以回退到上个节点
+修复已知的所有Bug，大量细节优化
+
+-----------------------------------------------------------------------
+
+HTML5魔塔样板V2.5.4
+
+发布15x15的版本
+独立出来的公共事件
+支持多重装备（一个装备可以装到多个孔上）
+工具栏按钮增添至8个，快捷商店和虚拟键盘同时显示
+点击状态栏的金币图标也可以打开快捷商店
+等待事件提供flag:px和flag:py在0~415之间
+事件：呼出存读档界面；呼出怪物手册
+事件：使用道具，暂停背景音乐，暂停所有音效
+type:trigger可以触发系统事件
+独立开关
+贴图也可以支持帧动画了
+图块内置颜色选择器
+标题界面增加音乐按钮
+等待事件可被Ctrl（长按）跳过
+部分Bug修复，大量细节优化，性能进一步得到提升
+
+-----------------------------------------------------------------------
+
+HTML5魔塔样板V2.5.3
+
+标题界面事件化；现在可以用事件流来处理标题界面了
+动态canvas管理；无限图层，可以任意创建图层并使用
+状态栏canvas化，可以自行对状态栏进行绘制
+手机端新增1-7按钮，可点工具栏进行切换
+事件编辑器可以查看最近使用图块和搜索图块
+事件编辑器中增加增加颜色选择器
+对话框里`\f`可以自带立绘效果
+图片相关事件全部修改为动态canvas实现
+新增事件：滚动字幕
+新增事件：等待所有异步事件执行完毕
+新增事件：画面闪烁
+BGM缓存管理；新增事件：预加载BGM
+新增天气：雾
+每次到达楼层执行的事件`eachArrive`
+可以控制某些图块无全局动画效果
+背景/前景层的素材可以全局动画/动态Autotile效果
+可以为每个装备单独设置是否按比例增加
+地图编辑器中选中点高亮；双击选中素材；WASD平移大地图
+修复所有Bug，部分代码重构，大量细节优化
+
+-----------------------------------------------------------------------
+
+HTML5魔塔样板V2.5.2
+
+怪物和NPC的行走图和朝向问题（详见文档）
+可以引入WindowSkin作为对话框的背景素材
+允许使用\t[标题,1.png]来绘制大头像图
+对话框的宽度可以根据文本长度自动调整
+\r[red]可以动态调整剧情文本的颜色
+升级事件改用事件编辑器完成
+每层楼都增添该层的并行事件处理
+新增快捷键：N返回标题；P游戏主页；O打开工程
+新增事件：设置全局属性或全局数值
+新增事件：隐藏/显示状态栏
+道具可以设置是否在回放时绘制道具栏或直接使用
+可以同时异步移动/跳跃勇士和多个NPC
+可以同时异步移动两张或以上的图片了
+追加素材一次可以追加多个
+菜单栏中新增虚拟键盘的弹出
+修复所有已知Bug；部分细节优化
+
+-----------------------------------------------------------------------
+
+HTML5魔塔样板V2.5.1
+
+新增事件type:insert，可以插入另一个地点的事件执行（公共事件）
+可以使用\r来控制剧情文本部分文字的颜色
+新增事件type:switch，多重分歧
+绘制前景/背景层时淡化其他图层
+追加素材的自动调整（如白底、不规范的素材）
+浏览地图时：左上角/V开启显伤；右上角/Z查看当前层大地图
+允许在受到领域夹击等伤害后禁用快捷商店
+升级的扣除模式，即不显示经验值，只显示升级的所需剩余值
+装备增加可装备条件判定
+选项界面可以使用1-9快速选择
+未开启状态的快捷商店用灰色显示
+修复不能在背景/前景层绘图的Bug
+部分其他细节优化
+
+-----------------------------------------------------------------------
+
+HTML5魔塔样板V2.5
+
+添加绘图模式支持；可以用户手动绘图和保存
+内置主动技能：二倍斩的支持，可以仿照制作其他主动技能
+将按键处理移动到脚本编辑中
+Alt+0\~9保存和读取当前套装
+图块属性的cannotOut和cannotIn控制可通行方向（来造成悬崖效果）
+支持动态Autotile自动元件（仅在事件层有效）
+允许快捷商店使用共用的times
+未启用的快捷商店可以隐藏或预览
+开始剧情startText可以执行任意事件
+对话窗口可以任意调节位置（上中下、距离顶部/底部的像素值）
+楼层转换界面可以设置背景图片文字颜色等
+数据统计进行分段描写，剑盾显示数值
+现在可以在事件编辑器中注释内容了
+存读档界面显示该存档的属性
+F7键可以开启debug模式
+R键可以从本地选取录像文件从头播放
+吸血属性的显伤增加^；仇恨怪显示仇恨伤害
+4键默认使用破冰稿或冰冻徽章或地震卷轴或上下楼器等等
+血瓶的道具化选项；黄宝石增加加点选项
+破炸飞增加默认音效
+修复单击瞬移的拖动打怪问题
+其他细节优化
+
+-----------------------------------------------------------------------
+
+HTML5魔塔样板V2.4.4
+
+tilesets可以设置图块属性（如可通行状态）
+追加素材时可以更改图片色调
+防作弊手段的进一步加强：打开控制台则禁止上传成绩
+图块属性增加“是否可被破震”的选项
+模仿怪物内置模仿临界计算器
+部分其他细节优化
+
+-----------------------------------------------------------------------
+
+HTML5魔塔样板V2.4.3
+
+并行事件处理
+事件：设置楼层属性
+增加光环属性，还可以制作区域光环效果
+将部分代码移动到脚本编辑中
+（怪物属性获取、楼层传送、数据统计等）
+事件改变天气或画面色调，读档后仍有效
+Autotile自动元件的新增和注册
+状态栏可以显示角色名字
+浏览地图可以显伤
+图片淡入淡出和移动图片可以将其保留
+双击道具栏图标直接进入装备栏
+可以设置剧情文本的字体大小
+录像播放可以最高24倍速
+1-6键快速设置录像播放速度；滚轮加减速
+进一步加强防作弊机制
+部分其他细节优化
+
+-----------------------------------------------------------------------
+
+HTML5魔塔样板V2.4.2
+
+允许导入tilesets直接使用，无需PS和注册
+tilesets的素材允许以矩形方式整体绘制
+Alt+0~9保存素材，Ctrl+0~9快速选中
+增加了透明块的支持
+装备允许按照百分比增加属性
+多动画的同时播放
+修复了打开存读档页面时闪屏的问题
+修复了cannotMove仍然能轻按和瞬移的问题
+所有已知Bug修复，部分代码重构和细节优化
+
+-----------------------------------------------------------------------
+
+HTML5魔塔样板V2.4.1
+
+增加背景层和前景层的图块绘制，多层图块可叠加
+背景层/前景层图块的显示、隐藏、修改等事件
+专门的装备页面（Q键开启）；装备系统大改造
+灯光和漆黑层效果，通过插件函数方式给出
+将状态栏更新和阻激夹域的计算移动到脚本编辑中
+增加控制免疫阻激夹域的flag:no_zone等
+打字机效果时点击显示全部文字
+修复更改画面色调的Bug
+修复更改剧情文本属性后读档恢复原样的问题
+部分细节优化
+
+-----------------------------------------------------------------------
+
+HTML5魔塔样板V2.4
 
 大地图的支持
-修复超大数值领域导致自动寻路卡死的问题
+突破了5M的存档空间大小限制
+可以隐藏和显示楼层贴图
+事件：接收用户文本输入
 同点多事件的颜色块绘制
 录像播放时可以按PgUp/PgDn浏览地图
+录像播放时对于瞬间移动绘制箭头
+增加激光属性
 可以在读档时E键直接指定编号
 破炸飞可以在状态栏显示个数
-部分细节优化
+部分细节优化，所有已知Bug修复
 
 -----------------------------------------------------------------------