text: /**
  🔀
  @file logic-operators-extended
  @summary adds conditional logic operators
  @version 13.3.6
  @author @mildmojo
  
  @description
  Adds conditional logic operators:
    - !== (not equal to)
    - && (and)
    - || (or)
    - &&! (and not)
    - ||! (or not)
  
  Examples: candlecount > 5 && haslighter == 1
            candlecount > 5 && papercount > 1 && isIndoors
            haslighter == 1 || hasmatches == 1
            candlecount > 5 && candlecount !== 666
            candlecount > 5 &&! droppedlighter
            droppedlighter ||! hasmatches
  
  NOTE: The combining operators (&&, ||, &&!, ||!) have lower precedence than
        all other math and comparison operators, so it might be hard to write
        tests that mix and match these new operators and have them evaluate
        correctly. If you're using multiple `&&` and `||` operators in one
        condition, be sure to test every possibility to make sure it behaves
        the way you want.
  */
  (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 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;
  	});
  }
  
  /**
  
  @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)
  @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();
  	if (
  		!kitsy.queuedInjectScripts.some(function (script) {
  			return searchRegex.toString() === script.searchRegex.toString() && replaceString === script.replaceString;
  		})
  	) {
  		kitsy.queuedInjectScripts.push({
  			searchRegex: searchRegex,
  			replaceString: replaceString,
  		});
  	} else {
  		console.warn('Ignored duplicate inject');
  	}
  }
  
  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();
  }
  
  
  
  function andExp(environment, left, right, onReturn) {
  	right.Eval(environment, function (rVal) {
  		left.Eval(environment, function (lVal) {
  			onReturn(lVal && rVal);
  		});
  	});
  }
  
  function orExp(environment, left, right, onReturn) {
  	right.Eval(environment, function (rVal) {
  		left.Eval(environment, function (lVal) {
  			onReturn(lVal || rVal);
  		});
  	});
  }
  
  function notEqExp(environment, left, right, onReturn) {
  	right.Eval(environment, function (rVal) {
  		left.Eval(environment, function (lVal) {
  			onReturn(lVal !== rVal);
  		});
  	});
  }
  
  function andNotExp(environment, left, right, onReturn) {
  	right.Eval(environment, function (rVal) {
  		left.Eval(environment, function (lVal) {
  			onReturn(lVal && !rVal);
  		});
  	});
  }
  
  function orNotExp(environment, left, right, onReturn) {
  	right.Eval(environment, function (rVal) {
  		left.Eval(environment, function (lVal) {
  			onReturn(lVal || !rVal);
  		});
  	});
  }
  
  inject$1(/(operatorMap\.set\("-", subExp\);)/, `
  	$1
  	operatorMap.set("&&", ${andExp.toString()});
  	operatorMap.set("||", ${orExp.toString()});
  	operatorMap.set("&&!", ${andNotExp.toString()});
  	operatorMap.set("||!", ${orNotExp.toString()});
  	operatorMap.set("!==", ${notEqExp.toString()});
  `);
  inject$1(
  	/(var operatorSymbols = \[.+\];)/,
  	'$1operatorSymbols.unshift("!==", "&&", "||", "&&!", "||!");',
  );
  // End of logic operators mod
  
  }(window));
  