text: /**
  🔝
  @file direction in dialog
  @summary provides a variable with player direction
  @license MIT
  @author Sean S. LeBlanc
  @version 20.1.0
  @requires Bitsy 7.12
  
  
  @description
  Provides a variable "playerDirection" that can be accessed in dialog
  The value will be one of:
  	- "up"
  	- "down"
  	- "left"
  	- "right"
  Depending on the last input from the player.
  
  Note that the variable will describe the direction the player moved,
  so if they're interacting with a sprite, the opposite will be the direction from which they came
  i.e. if the player moves into a sprite from the left, the variable will be "right"
  
  HOW TO USE:
  Copy-paste into a script tag after the bitsy source
  */
  (function (bitsy) {
  'use strict';
  
  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
  
  bitsy = bitsy || /*#__PURE__*/_interopDefaultLegacy(bitsy);
  
  /**
   * 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.
   * ```js
   * inject(/(some string)/,'injected before $1 injected after');
   * ```
   * @param searcher Regex to search and replace
   * @param replacer Replacer string/fn
   */
  function inject(searcher, replacer) {
      // 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];
          if (!scriptTag.textContent)
              continue;
          var matchesSearch = scriptTag.textContent.search(searcher) !== -1;
          var isCurrentScript = scriptTag === document.currentScript;
          if (matchesSearch && !isCurrentScript) {
              code = scriptTag.textContent;
              break;
          }
      }
      // error-handling
      if (!code || !scriptTag) {
          throw new Error('Couldn\'t find "' + searcher + '" in script tags');
      }
      // modify the content
      code = code.replace(searcher, replacer);
      // 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 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;
      });
  }
  // Ex: inject(/(names.sprite.set\( name, id \);)/, '$1console.dir(names)');
  /** test */
  function kitsyInject(searcher, replacer) {
      if (!kitsy.queuedInjectScripts.some(function (script) {
          return searcher.toString() === script.searcher.toString() && replacer === script.replacer;
      })) {
          kitsy.queuedInjectScripts.push({
              searcher: searcher,
              replacer: replacer,
          });
      }
      else {
          console.warn('Ignored duplicate inject');
      }
  }
  // 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$1(targetFuncName, beforeFn) {
      kitsy.queuedBeforeScripts[targetFuncName] = kitsy.queuedBeforeScripts[targetFuncName] || [];
      kitsy.queuedBeforeScripts[targetFuncName].push(beforeFn);
  }
  // Ex: after('load_game', function run() { alert('Loaded!'); });
  function after(targetFuncName, afterFn) {
      kitsy.queuedAfterScripts[targetFuncName] = kitsy.queuedAfterScripts[targetFuncName] || [];
      kitsy.queuedAfterScripts[targetFuncName].push(afterFn);
  }
  function applyInjects() {
      kitsy.queuedInjectScripts.forEach(function (injectScript) {
          inject(injectScript.searcher, injectScript.replacer);
      });
  }
  function applyHooks(root) {
      var allHooks = unique(Object.keys(kitsy.queuedBeforeScripts).concat(Object.keys(kitsy.queuedAfterScripts)));
      allHooks.forEach(applyHook.bind(this, root || window));
  }
  function applyHook(root, functionName) {
      var functionNameSegments = functionName.split('.');
      var obj = root;
      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(kitsy.queuedBeforeScripts[functionName] || []);
      // then original
      if (superFn) {
          functions.push(superFn);
      }
      // then afters
      functions = functions.concat(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)));
              }
              // run synchronously
              returnVal = functions[i++].apply(this, args);
              if (returnVal && returnVal.length) {
                  args = returnVal;
              }
              return runBefore.apply(this, args);
          }
          return runBefore.apply(this, arguments);
      };
  }
  /**
  @file kitsy-script-toolkit
  @summary Monkey-patching toolkit to make it easier and cleaner to run code before and after functions or to inject new code into script tags
  @license WTFPL (do WTF you want)
  @author Original by mildmojo; modified by Sean S. LeBlanc
  @version 20.1.0
  @requires Bitsy 7.12
  
  */
  var kitsy = (window.kitsy = window.kitsy || {
      queuedInjectScripts: [],
      queuedBeforeScripts: {},
      queuedAfterScripts: {},
      inject: kitsyInject,
      before: before$1,
      after,
      /**
       * Applies all queued `inject` calls.
       *
       * An object that instantiates an class modified via injection will still refer to the original class,
       * so make sure to reinitialize globals that refer to injected scripts before calling `applyHooks`.
       */
      applyInjects,
      /** Apples all queued `before`/`after` calls. */
      applyHooks,
  });
  
  var hooked = kitsy.hooked;
  if (!hooked) {
  	kitsy.hooked = true;
  	var oldStartFunc = bitsy.startExportedGame;
  	bitsy.startExportedGame = function doAllInjections() {
  		// Only do this once.
  		bitsy.startExportedGame = oldStartFunc;
  
  		// Rewrite scripts
  		kitsy.applyInjects();
  
  		// 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();
  		bitsy.renderer = new bitsy.TileRenderer(bitsy.tilesize);
  
  		// Hook everything
  		kitsy.applyHooks();
  
  		// reset callbacks using hacked functions
  		bitsy.bitsyOnUpdate(bitsy.update);
  		bitsy.bitsyOnQuit(bitsy.stopGame);
  		bitsy.bitsyOnLoad(bitsy.load_game);
  
  		// Start the game
  		bitsy.startExportedGame.apply(this, arguments);
  	};
  }
  
  /** @see kitsy.inject */
  kitsy.inject;
  /** @see kitsy.before */
  var before = kitsy.before;
  /** @see kitsy.after */
  kitsy.after;
  
  
  
  var keys = {};
  keys[bitsy.Direction.Up] = 'up';
  keys[bitsy.Direction.Down] = 'down';
  keys[bitsy.Direction.Left] = 'left';
  keys[bitsy.Direction.Right] = 'right';
  keys[bitsy.Direction.None] = null;
  
  before('startDialog', function () {
  	var direction = keys[bitsy.curPlayerDirection];
  	if (direction) {
  		bitsy.scriptInterpreter.SetVariable('playerDirection', direction);
  	}
  });
  
  })(window);
  