text: /**
  🚪
  @file exit-from-dialog
  @summary exit to another room from dialog, including conditionals
  @license WTFPL (do WTF you want)
  @version 8.0.1
  @requires Bitsy Version: 7.0
  @author @mildmojo
  
  @description
  Lets you exit to another room from dialog (including inside conditionals).
  
  Note: Bitsy has a built-in implementation of exit-from-dialog as of 7.0;
  before using this, you may want to check if it fulfills your needs.
  
  Use it to make an invisible sprite that acts as a conditional exit, use it to warp
  somewhere after a conversation, use it to put a guard at your gate who only
  lets you in once you're disguised, use it to require payment before the
  ferryman will take you across the river.
  
  Using the (exit) function in any part of a series of dialog will make the
  game exit to the new room after the dialog is finished. Using (exitNow) will
  immediately warp to the new room, but the current dialog will continue.
  
  Usage:
  	(exit "<room name>,<x>,<y>,<transition_effect>")
  	(exitNow "<room name>,<x>,<y>,<transition_effect>")
  
  Parameter notes:
  	- Every paramater is optional
  	- If you omit the room, it will use the current room
  	- If you omit the x or y, it will use the current position
  	- x and y can be written as relative coordinates (e.g. +3, -4, +0)
  	- available transitions at time of writing: fade_w, fade_b, wave, tunnel, slide_u, slide_d, slide_l, slide_r
  
  Examples:
  	(exit "FinalRoom,8,4")
  	(exit "FinalRoom,8,4,tunnel")
  	(exit "FinalRoom")
  	(exit "FinalRoom,+0,+0,tunnel")
  	(exit ",+1,+1")
  
  HOW TO USE:
  1. Copy-paste this script into a new script tag after the Bitsy source code.
     It should appear *before* any other mods that handle loading your game
     data so it executes *after* them (last-in first-out).
  
  NOTE:
  This uses parentheses "()" instead of curly braces "{}" around function
  calls because the Bitsy editor's fancy dialog window strips unrecognized
  curly-brace functions from dialog text. To keep from losing data, write
  these function calls with parentheses like the examples above.
  */
  (function (bitsy) {
  'use strict';
  
  bitsy = bitsy && Object.prototype.hasOwnProperty.call(bitsy, 'default') ? bitsy['default'] : bitsy;
  
  /**
  @file utils
  @summary miscellaneous bitsy utilities
  @author Sean S. LeBlanc
  */
  
  /*
  Helper used to replace code in a script tag based on a search regex
  To inject code without erasing original string, using capturing groups; e.g.
  	inject(/(some string)/,'injected before $1 injected after')
  */
  function inject(searchRegex, replaceString) {
  	// find the relevant script tag
  	var scriptTags = document.getElementsByTagName('script');
  	var scriptTag;
  	var code;
  	for (var i = 0; i < scriptTags.length; ++i) {
  		scriptTag = scriptTags[i];
  		var matchesSearch = scriptTag.textContent.search(searchRegex) !== -1;
  		var isCurrentScript = scriptTag === document.currentScript;
  		if (matchesSearch && !isCurrentScript) {
  			code = scriptTag.textContent;
  			break;
  		}
  	}
  
  	// error-handling
  	if (!code) {
  		throw new Error('Couldn\'t find "' + searchRegex + '" in script tags');
  	}
  
  	// modify the content
  	code = code.replace(searchRegex, replaceString);
  
  	// replace the old script tag with a new one using our modified code
  	var newScriptTag = document.createElement('script');
  	newScriptTag.textContent = code;
  	scriptTag.insertAdjacentElement('afterend', newScriptTag);
  	scriptTag.remove();
  }
  
  /**
   * Helper for getting room by name or id
   * @param {string} name id or name of room to return
   * @return {string} room, or undefined if it doesn't exist
   */
  function getRoom(name) {
  	var id = Object.prototype.hasOwnProperty.call(bitsy.room, name) ? name : bitsy.names.room.get(name);
  	return bitsy.room[id];
  }
  
  /**
   * Helper for getting an array with unique elements
   * @param  {Array} array Original array
   * @return {Array}       Copy of array, excluding duplicates
   */
  function unique(array) {
  	return array.filter(function (item, idx) {
  		return array.indexOf(item) === idx;
  	});
  }
  
  /**
   * Helper for parsing parameters that may be relative to another value
   * e.g.
   * - getRelativeNumber('1', 5) -> 1
   * - getRelativeNumber('+1', 5) -> 6
   * - getRelativeNumber('-1', 5) -> 4
   * - getRelativeNumber('', 5) -> 5
   * @param {string} value absolute or relative string to parse
   * @param {number} relativeTo value to use as fallback if none is provided, and as base for relative value
   * @return {number} resulting absolute or relative number
   */
  function getRelativeNumber(value, relativeTo) {
  	var v = (value || value === 0 ? value : relativeTo);
  	if (typeof v === 'string' && (v.startsWith('+') || v.startsWith('-'))) {
  		return relativeTo + Number(v);
  	}
  	return Number(v);
  }
  
  /**
  
  @file kitsy-script-toolkit
  @summary makes it easier and cleaner to run code before and after Bitsy functions or to inject new code into Bitsy script tags
  @license WTFPL (do WTF you want)
  @version 4.0.1
  @requires Bitsy Version: 4.5, 4.6
  @author @mildmojo
  
  @description
  HOW TO USE:
    import {before, after, inject, addDialogTag, addDeferredDialogTag} from "./helpers/kitsy-script-toolkit";
  
    before(targetFuncName, beforeFn);
    after(targetFuncName, afterFn);
    inject(searchRegex, replaceString);
    addDialogTag(tagName, dialogFn);
    addDeferredDialogTag(tagName, dialogFn);
  
    For more info, see the documentation at:
    https://github.com/seleb/bitsy-hacks/wiki/Coding-with-kitsy
  */
  
  
  // Ex: inject(/(names.sprite.set\( name, id \);)/, '$1console.dir(names)');
  function inject$1(searchRegex, replaceString) {
  	var kitsy = kitsyInit();
  	kitsy.queuedInjectScripts.push({
  		searchRegex: searchRegex,
  		replaceString: replaceString
  	});
  }
  
  // Ex: before('load_game', function run() { alert('Loading!'); });
  //     before('show_text', function run(text) { return text.toUpperCase(); });
  //     before('show_text', function run(text, done) { done(text.toUpperCase()); });
  function before(targetFuncName, beforeFn) {
  	var kitsy = kitsyInit();
  	kitsy.queuedBeforeScripts[targetFuncName] = kitsy.queuedBeforeScripts[targetFuncName] || [];
  	kitsy.queuedBeforeScripts[targetFuncName].push(beforeFn);
  }
  
  // Ex: after('load_game', function run() { alert('Loaded!'); });
  function after(targetFuncName, afterFn) {
  	var kitsy = kitsyInit();
  	kitsy.queuedAfterScripts[targetFuncName] = kitsy.queuedAfterScripts[targetFuncName] || [];
  	kitsy.queuedAfterScripts[targetFuncName].push(afterFn);
  }
  
  function kitsyInit() {
  	// return already-initialized kitsy
  	if (bitsy.kitsy) {
  		return bitsy.kitsy;
  	}
  
  	// Initialize kitsy
  	bitsy.kitsy = {
  		queuedInjectScripts: [],
  		queuedBeforeScripts: {},
  		queuedAfterScripts: {}
  	};
  
  	var oldStartFunc = bitsy.startExportedGame;
  	bitsy.startExportedGame = function doAllInjections() {
  		// Only do this once.
  		bitsy.startExportedGame = oldStartFunc;
  
  		// Rewrite scripts and hook everything up.
  		doInjects();
  		applyAllHooks();
  
  		// Start the game
  		bitsy.startExportedGame.apply(this, arguments);
  	};
  
  	return bitsy.kitsy;
  }
  
  
  function doInjects() {
  	bitsy.kitsy.queuedInjectScripts.forEach(function (injectScript) {
  		inject(injectScript.searchRegex, injectScript.replaceString);
  	});
  	_reinitEngine();
  }
  
  function applyAllHooks() {
  	var allHooks = unique(Object.keys(bitsy.kitsy.queuedBeforeScripts).concat(Object.keys(bitsy.kitsy.queuedAfterScripts)));
  	allHooks.forEach(applyHook);
  }
  
  function applyHook(functionName) {
  	var functionNameSegments = functionName.split('.');
  	var obj = bitsy;
  	while (functionNameSegments.length > 1) {
  		obj = obj[functionNameSegments.shift()];
  	}
  	var lastSegment = functionNameSegments[0];
  	var superFn = obj[lastSegment];
  	var superFnLength = superFn ? superFn.length : 0;
  	var functions = [];
  	// start with befores
  	functions = functions.concat(bitsy.kitsy.queuedBeforeScripts[functionName] || []);
  	// then original
  	if (superFn) {
  		functions.push(superFn);
  	}
  	// then afters
  	functions = functions.concat(bitsy.kitsy.queuedAfterScripts[functionName] || []);
  
  	// overwrite original with one which will call each in order
  	obj[lastSegment] = function () {
  		var returnVal;
  		var args = [].slice.call(arguments);
  		var i = 0;
  
  		function runBefore() {
  			// All outta functions? Finish
  			if (i === functions.length) {
  				return returnVal;
  			}
  
  			// Update args if provided.
  			if (arguments.length > 0) {
  				args = [].slice.call(arguments);
  			}
  
  			if (functions[i].length > superFnLength) {
  				// Assume funcs that accept more args than the original are
  				// async and accept a callback as an additional argument.
  				return functions[i++].apply(this, args.concat(runBefore.bind(this)));
  			} else {
  				// run synchronously
  				returnVal = functions[i++].apply(this, args);
  				if (returnVal && returnVal.length) {
  					args = returnVal;
  				}
  				return runBefore.apply(this, args);
  			}
  		}
  
  		return runBefore.apply(this, arguments);
  	};
  }
  
  function _reinitEngine() {
  	// recreate the script and dialog objects so that they'll be
  	// referencing the code with injections instead of the original
  	bitsy.scriptModule = new bitsy.Script();
  	bitsy.scriptInterpreter = bitsy.scriptModule.CreateInterpreter();
  
  	bitsy.dialogModule = new bitsy.Dialog();
  	bitsy.dialogRenderer = bitsy.dialogModule.CreateRenderer();
  	bitsy.dialogBuffer = bitsy.dialogModule.CreateBuffer();
  }
  
  // Rewrite custom functions' parentheses to curly braces for Bitsy's
  // interpreter. Unescape escaped parentheticals, too.
  function convertDialogTags(input, tag) {
  	return input
  		.replace(new RegExp('\\\\?\\((' + tag + '(\\s+(".+?"|.+?))?)\\\\?\\)', 'g'), function (match, group) {
  			if (match.substr(0, 1) === '\\') {
  				return '(' + group + ')'; // Rewrite \(tag "..."|...\) to (tag "..."|...)
  			}
  			return '{' + group + '}'; // Rewrite (tag "..."|...) to {tag "..."|...}
  		});
  }
  
  
  function addDialogFunction(tag, fn) {
  	var kitsy = kitsyInit();
  	kitsy.dialogFunctions = kitsy.dialogFunctions || {};
  	if (kitsy.dialogFunctions[tag]) {
  		throw new Error('The dialog function "' + tag + '" already exists.');
  	}
  
  	// Hook into game load and rewrite custom functions in game data to Bitsy format.
  	before('parseWorld', function (game_data) {
  		return [convertDialogTags(game_data, tag)];
  	});
  
  	kitsy.dialogFunctions[tag] = fn;
  }
  
  function injectDialogTag(tag, code) {
  	inject$1(
  		/(var functionMap = new Map\(\);[^]*?)(this.HasFunction)/m,
  		'$1\nfunctionMap.set("' + tag + '", ' + code + ');\n$2'
  	);
  }
  
  /**
   * Adds a custom dialog tag which executes the provided function.
   * For ease-of-use with the bitsy editor, tags can be written as
   * (tagname "parameters") in addition to the standard {tagname "parameters"}
   * 
   * Function is executed immediately when the tag is reached.
   *
   * @param {string}   tag Name of tag
   * @param {Function} fn  Function to execute, with signature `function(environment, parameters, onReturn){}`
   *                       environment: provides access to SetVariable/GetVariable (among other things, see Environment in the bitsy source for more info)
   *                       parameters: array containing parameters as string in first element (i.e. `parameters[0]`)
   *                       onReturn: function to call with return value (just call `onReturn(null);` at the end of your function if your tag doesn't interact with the logic system)
   */
  function addDialogTag(tag, fn) {
  	addDialogFunction(tag, fn);
  	injectDialogTag(tag, 'kitsy.dialogFunctions["' + tag + '"]');
  }
  
  /**
   * Adds a custom dialog tag which executes the provided function.
   * For ease-of-use with the bitsy editor, tags can be written as
   * (tagname "parameters") in addition to the standard {tagname "parameters"}
   * 
   * Function is executed after the dialog box.
   *
   * @param {string}   tag Name of tag
   * @param {Function} fn  Function to execute, with signature `function(environment, parameters){}`
   *                       environment: provides access to SetVariable/GetVariable (among other things, see Environment in the bitsy source for more info)
   *                       parameters: array containing parameters as string in first element (i.e. `parameters[0]`)
   */
  function addDeferredDialogTag(tag, fn) {
  	addDialogFunction(tag, fn);
  	bitsy.kitsy.deferredDialogFunctions = bitsy.kitsy.deferredDialogFunctions || {};
  	var deferred = bitsy.kitsy.deferredDialogFunctions[tag] = [];
  	injectDialogTag(tag, 'function(e, p, o){ kitsy.deferredDialogFunctions["' + tag + '"].push({e:e,p:p}); o(null); }');
  	// Hook into the dialog finish event and execute the actual function
  	after('onExitDialog', function () {
  		while (deferred.length) {
  			var args = deferred.shift();
  			bitsy.kitsy.dialogFunctions[tag](args.e, args.p, args.o);
  		}
  	});
  	// Hook into the game reset and make sure data gets cleared
  	after('clearGameData', function () {
  		deferred.length = 0;
  	});
  }
  
  /**
   * Adds two custom dialog tags which execute the provided function,
   * one with the provided tagname executed after the dialog box,
   * and one suffixed with 'Now' executed immediately when the tag is reached.
   *
   * i.e. helper for the (exit)/(exitNow) pattern.
   *
   * @param {string}   tag Name of tag
   * @param {Function} fn  Function to execute, with signature `function(environment, parameters){}`
   *                       environment: provides access to SetVariable/GetVariable (among other things, see Environment in the bitsy source for more info)
   *                       parameters: array containing parameters as string in first element (i.e. `parameters[0]`)
   */
  function addDualDialogTag(tag, fn) {
  	addDialogTag(tag + 'Now', function (environment, parameters, onReturn) {
  		fn(environment, parameters);
  		onReturn(null);
  	});
  	addDeferredDialogTag(tag, fn);
  }
  
  
  
  // Implement the dialog functions
  addDualDialogTag('exit', function (environment, parameters) {
  	var exit = getExitParams(parameters);
  	if (!exit) {
  		return;
  	}
  	bitsy.movePlayerThroughExit(exit);
  });
  
  function getExitParams(parameters) {
  	var p = bitsy.player();
  	var params = parameters[0].split(',');
  	var roomName = params[0];
  	var x = params[1];
  	var y = params[2];
  	var transitionEffect = params[3];
  	var room = getRoom(roomName);
  
  	if (!room) {
  		room = bitsy.room[p.room];
  	}
  
  	x = getRelativeNumber(x, p.x);
  	y = getRelativeNumber(y, p.y);
  
  	return {
  		dest: {
  			room: room.id,
  			x,
  			y,
  		},
  		transition_effect: transitionEffect,
  	};
  }
  // End of (exit) dialog function mod
  
  }(window));
  