@turnipxenon/pineapple 2.2.1 → 2.3.1

package/.svelte-kit/output/server/chunks/DialogManagerStore.js

@@ -0,0 +1,1269 @@
+import { w as writable } from "./index.js";
+import { p as noop, q as assign, r as identity } from "./ssr.js";
+import { c as cubicOut } from "./index3.js";
+import { B as BROWSER } from "./prod-ssr.js";
+const is_client = typeof window !== "undefined";
+let now = is_client ? () => window.performance.now() : () => Date.now();
+let raf = is_client ? (cb) => requestAnimationFrame(cb) : noop;
+const tasks = /* @__PURE__ */ new Set();
+function run_tasks(now2) {
+  tasks.forEach((task) => {
+    if (!task.c(now2)) {
+      tasks.delete(task);
+      task.f();
+    }
+  });
+  if (tasks.size !== 0)
+    raf(run_tasks);
+}
+function loop(callback) {
+  let task;
+  if (tasks.size === 0)
+    raf(run_tasks);
+  return {
+    promise: new Promise((fulfill) => {
+      tasks.add(task = { c: callback, f: fulfill });
+    }),
+    abort() {
+      tasks.delete(task);
+    }
+  };
+}
+const browser = BROWSER;
+const createNewMapStore = () => {
+  return {
+    // dumb storage if not in browser
+    length: 0,
+    setItem: (key, value) => {
+    },
+    getItem: (key) => {
+      return null;
+    },
+    clear: () => {
+    },
+    key: (index) => {
+      return null;
+    },
+    removeItem: (key) => {
+    }
+  };
+};
+var DialogState = /* @__PURE__ */ ((DialogState2) => {
+  DialogState2[DialogState2["Invisible"] = 0] = "Invisible";
+  DialogState2[DialogState2["Visible"] = 1] = "Visible";
+  DialogState2[DialogState2["Busy"] = 2] = "Busy";
+  return DialogState2;
+})(DialogState || {});
+function is_date(obj) {
+  return Object.prototype.toString.call(obj) === "[object Date]";
+}
+function get_interpolator(a, b) {
+  if (a === b || a !== a)
+    return () => a;
+  const type = typeof a;
+  if (type !== typeof b || Array.isArray(a) !== Array.isArray(b)) {
+    throw new Error("Cannot interpolate values of different type");
+  }
+  if (Array.isArray(a)) {
+    const arr = b.map((bi, i) => {
+      return get_interpolator(a[i], bi);
+    });
+    return (t) => arr.map((fn) => fn(t));
+  }
+  if (type === "object") {
+    if (!a || !b)
+      throw new Error("Object cannot be null");
+    if (is_date(a) && is_date(b)) {
+      a = a.getTime();
+      b = b.getTime();
+      const delta = b - a;
+      return (t) => new Date(a + t * delta);
+    }
+    const keys = Object.keys(b);
+    const interpolators = {};
+    keys.forEach((key) => {
+      interpolators[key] = get_interpolator(a[key], b[key]);
+    });
+    return (t) => {
+      const result = {};
+      keys.forEach((key) => {
+        result[key] = interpolators[key](t);
+      });
+      return result;
+    };
+  }
+  if (type === "number") {
+    const delta = b - a;
+    return (t) => a + t * delta;
+  }
+  throw new Error(`Cannot interpolate ${type} values`);
+}
+function tweened(value, defaults = {}) {
+  const store = writable(value);
+  let task;
+  let target_value = value;
+  function set(new_value, opts) {
+    if (value == null) {
+      store.set(value = new_value);
+      return Promise.resolve();
+    }
+    target_value = new_value;
+    let previous_task = task;
+    let started = false;
+    let {
+      delay = 0,
+      duration = 400,
+      easing = identity,
+      interpolate = get_interpolator
+    } = assign(assign({}, defaults), opts);
+    if (duration === 0) {
+      if (previous_task) {
+        previous_task.abort();
+        previous_task = null;
+      }
+      store.set(value = target_value);
+      return Promise.resolve();
+    }
+    const start = now() + delay;
+    let fn;
+    task = loop((now2) => {
+      if (now2 < start)
+        return true;
+      if (!started) {
+        fn = interpolate(value, new_value);
+        if (typeof duration === "function")
+          duration = duration(value, new_value);
+        started = true;
+      }
+      if (previous_task) {
+        previous_task.abort();
+        previous_task = null;
+      }
+      const elapsed = now2 - start;
+      if (elapsed > /** @type {number} */
+      duration) {
+        store.set(value = new_value);
+        return false;
+      }
+      store.set(value = fn(easing(elapsed / duration)));
+      return true;
+    });
+    return task.promise;
+  }
+  return {
+    set,
+    update: (fn, opts) => set(fn(target_value, value), opts),
+    subscribe: store.subscribe
+  };
+}
+var PortraitType = /* @__PURE__ */ ((PortraitType2) => {
+  PortraitType2["AresHappy"] = "AresHappy";
+  PortraitType2["AresDisappointed"] = "AresDisappointed";
+  PortraitType2["AresBlushing"] = "AresBlushing";
+  PortraitType2["AresLetsGo"] = "AresLetsGo";
+  PortraitType2["AresMad"] = "AresMad";
+  PortraitType2["AresNeutral"] = "AresNeutral";
+  PortraitType2["AresSlightlyMad"] = "AresSlightlyMad";
+  PortraitType2["AresSurprised"] = "AresSurprised";
+  PortraitType2["AresYay"] = "AresYay";
+  return PortraitType2;
+})(PortraitType || {});
+const AresHappy = "/_app/immutable/assets/ares_happy.Cz9WhdwO.webp";
+const AresBlushing = "/_app/immutable/assets/ares_blushing.B6Q0SsBp.webp";
+const AresDisappointed = "/_app/immutable/assets/ares_disappointed.LOpkh7Q7.webp";
+const AresLetsGo = "/_app/immutable/assets/ares_lets_go.BxjJjKUv.webp";
+const AresMad = "/_app/immutable/assets/ares_mad.DofDLDmM.webp";
+const AresNeutral = "/_app/immutable/assets/ares_neutral.Hp923t8N.webp";
+const AresSlightlyMad = "/_app/immutable/assets/ares_slightly_mad.DdwOp6J5.webp";
+const AresSurprised = "/_app/immutable/assets/ares_surprised.BxbNH_w8.webp";
+const AresYay = "/_app/immutable/assets/ares_yay.EM2SNr0e.webp";
+var IfMode = /* @__PURE__ */ ((IfMode2) => {
+  IfMode2[IfMode2["Search"] = 0] = "Search";
+  IfMode2[IfMode2["Ignore"] = 1] = "Ignore";
+  IfMode2[IfMode2["Evaluated"] = 2] = "Evaluated";
+  IfMode2[IfMode2["EvaluateNext"] = 3] = "EvaluateNext";
+  return IfMode2;
+})(IfMode || {});
+class BehaviorState {
+  ifModeStack = [IfMode.Search];
+  ignoreJumps = false;
+}
+var BehaviorStatus = /* @__PURE__ */ ((BehaviorStatus2) => {
+  BehaviorStatus2[BehaviorStatus2["Running"] = 0] = "Running";
+  BehaviorStatus2[BehaviorStatus2["Success"] = 1] = "Success";
+  BehaviorStatus2[BehaviorStatus2["Failure"] = 2] = "Failure";
+  return BehaviorStatus2;
+})(BehaviorStatus || {});
+var OperatorType = /* @__PURE__ */ ((OperatorType2) => {
+  OperatorType2[OperatorType2["Unary"] = 0] = "Unary";
+  OperatorType2[OperatorType2["Binary"] = 1] = "Binary";
+  return OperatorType2;
+})(OperatorType || {});
+class OperatorLogicNode {
+  process(nodeArgs) {
+    const currentOperands = [];
+    switch (this.getOperatorType()) {
+      case 0:
+        currentOperands.unshift(nodeArgs.initState.operandStack.pop());
+        break;
+      case 1:
+        currentOperands.unshift(nodeArgs.initState.operandStack.pop());
+        currentOperands.unshift(nodeArgs.initState.operandStack.pop());
+        break;
+      default:
+        console.error(`Unimplemented operator type: ${this.getOperatorType()}`);
+        break;
+    }
+    this.doOperation(currentOperands, nodeArgs);
+    return {
+      nextState: nodeArgs.initState,
+      status: BehaviorStatus.Success
+    };
+  }
+}
+class EqualityOperator extends OperatorLogicNode {
+  doOperation = (currentOperands, nodeArgs) => {
+    nodeArgs.initState.operandStack.push(String(currentOperands[0] === currentOperands[1]));
+  };
+  getOperatorType = () => {
+    return OperatorType.Binary;
+  };
+  getToken = () => {
+    return "==";
+  };
+}
+class InequalityOperator extends OperatorLogicNode {
+  doOperation = (currentOperands, nodeArgs) => {
+    nodeArgs.initState.operandStack.push(String(currentOperands[0] !== currentOperands[1]));
+  };
+  getOperatorType = () => {
+    return OperatorType.Binary;
+  };
+  getToken = () => {
+    return "!=";
+  };
+}
+class GreaterThanOperator extends OperatorLogicNode {
+  doOperation = (currentOperands, nodeArgs) => {
+    nodeArgs.initState.operandStack.push(
+      String(Number(currentOperands[0]) > Number(currentOperands[1]))
+    );
+  };
+  getOperatorType = () => {
+    return OperatorType.Binary;
+  };
+  getToken = () => {
+    return ">";
+  };
+}
+class GreaterThanEqualOperator extends OperatorLogicNode {
+  doOperation = (currentOperands, nodeArgs) => {
+    nodeArgs.initState.operandStack.push(
+      String(Number(currentOperands[0]) >= Number(currentOperands[1]))
+    );
+  };
+  getOperatorType = () => {
+    return OperatorType.Binary;
+  };
+  getToken = () => {
+    return ">=";
+  };
+}
+class LessThanOperator extends OperatorLogicNode {
+  doOperation = (currentOperands, nodeArgs) => {
+    nodeArgs.initState.operandStack.push(
+      String(Number(currentOperands[0]) < Number(currentOperands[1]))
+    );
+  };
+  getOperatorType = () => {
+    return OperatorType.Binary;
+  };
+  getToken = () => {
+    return "<";
+  };
+}
+class LessThanEqualOperator extends OperatorLogicNode {
+  doOperation = (currentOperands, nodeArgs) => {
+    nodeArgs.initState.operandStack.push(
+      String(Number(currentOperands[0]) <= Number(currentOperands[1]))
+    );
+  };
+  getOperatorType = () => {
+    return OperatorType.Binary;
+  };
+  getToken = () => {
+    return "<=";
+  };
+}
+class BTreeUtils {
+  /**
+   * peek the top of a stack object with the assumption it's not an empty stack
+   * todo: add possible protection like an assertion
+   * @param stack
+   * @return top of the stack
+   */
+  peek = (stack) => {
+    return stack[stack.length - 1];
+  };
+  removeQuotes = (value) => {
+    return value.replace(/^"/, "").replace(/"$/, "");
+  };
+  simplifyToken = (oldToken) => {
+    if (oldToken[0] == "$") {
+      const value = localStorage.getItem(oldToken);
+      if (value) {
+        return value;
+      }
+      console.error(`Value obtained in local storage false: ${oldToken}`);
+      return "";
+    }
+    return btreeUtils.removeQuotes(oldToken);
+  };
+  isTrue = (value) => {
+    return value.trim().toLowerCase() === "true";
+  };
+  isFalse = (value) => {
+    return value.trim().toLowerCase() === "false";
+  };
+}
+const btreeUtils = new BTreeUtils();
+class NegationOperator extends OperatorLogicNode {
+  doOperation = (currentOperands, nodeArgs) => {
+    nodeArgs.initState.operandStack.push(String(!btreeUtils.isTrue(currentOperands[0])));
+  };
+  getOperatorType = () => {
+    return OperatorType.Unary;
+  };
+  getToken = () => {
+    return "!";
+  };
+}
+class AndOperator extends OperatorLogicNode {
+  doOperation = (currentOperands, nodeArgs) => {
+    nodeArgs.initState.operandStack.push(
+      String(btreeUtils.isTrue(currentOperands[0]) && btreeUtils.isTrue(currentOperands[1]))
+    );
+  };
+  getOperatorType = () => {
+    return OperatorType.Binary;
+  };
+  getToken = () => {
+    return "&&";
+  };
+}
+class OrOperator extends OperatorLogicNode {
+  doOperation = (currentOperands, nodeArgs) => {
+    nodeArgs.initState.operandStack.push(
+      String(btreeUtils.isTrue(currentOperands[0]) || btreeUtils.isTrue(currentOperands[1]))
+    );
+  };
+  getOperatorType = () => {
+    return OperatorType.Binary;
+  };
+  getToken = () => {
+    return "||";
+  };
+}
+class XorOperator extends OperatorLogicNode {
+  doOperation = (currentOperands, nodeArgs) => {
+    const A = btreeUtils.isTrue(currentOperands[0]);
+    const B = btreeUtils.isTrue(currentOperands[1]);
+    nodeArgs.initState.operandStack.push(String(!(A && B || A || B)));
+  };
+  getOperatorType = () => {
+    return OperatorType.Binary;
+  };
+  getToken = () => {
+    return "^";
+  };
+}
+class AddOperator extends OperatorLogicNode {
+  doOperation = (currentOperands, nodeArgs) => {
+    nodeArgs.initState.operandStack.push(
+      String(Number(currentOperands[0]) + Number(currentOperands[1]))
+    );
+  };
+  getOperatorType = () => {
+    return OperatorType.Binary;
+  };
+  getToken = () => {
+    return "+";
+  };
+}
+class MinusOperator extends OperatorLogicNode {
+  doOperation = (currentOperands, nodeArgs) => {
+    nodeArgs.initState.operandStack.push(
+      String(Number(currentOperands[0]) - Number(currentOperands[1]))
+    );
+  };
+  getOperatorType = () => {
+    return OperatorType.Binary;
+  };
+  getToken = () => {
+    return "-";
+  };
+}
+class MultiplicationOperator extends OperatorLogicNode {
+  doOperation = (currentOperands, nodeArgs) => {
+    nodeArgs.initState.operandStack.push(
+      String(Number(currentOperands[0]) * Number(currentOperands[1]))
+    );
+  };
+  getOperatorType = () => {
+    return OperatorType.Binary;
+  };
+  getToken = () => {
+    return "*";
+  };
+}
+class DivisionOperator extends OperatorLogicNode {
+  doOperation = (currentOperands, nodeArgs) => {
+    nodeArgs.initState.operandStack.push(
+      String(Number(currentOperands[0]) / Number(currentOperands[1]))
+    );
+  };
+  getOperatorType = () => {
+    return OperatorType.Binary;
+  };
+  getToken = () => {
+    return "/";
+  };
+}
+class RemainderDivisionOperator extends OperatorLogicNode {
+  doOperation = (currentOperands, nodeArgs) => {
+    nodeArgs.initState.operandStack.push(
+      String(Number(currentOperands[0]) % Number(currentOperands[1]))
+    );
+  };
+  getOperatorType = () => {
+    return OperatorType.Binary;
+  };
+  getToken = () => {
+    return "%";
+  };
+}
+class OperatorMap {
+  _operatorLogicMap = /* @__PURE__ */ new Map();
+  constructor() {
+    [
+      new EqualityOperator(),
+      new InequalityOperator(),
+      new GreaterThanOperator(),
+      new GreaterThanEqualOperator(),
+      new LessThanOperator(),
+      new LessThanEqualOperator(),
+      new NegationOperator(),
+      new AndOperator(),
+      new OrOperator(),
+      new XorOperator(),
+      new AddOperator(),
+      new MinusOperator(),
+      new MultiplicationOperator(),
+      new DivisionOperator(),
+      new RemainderDivisionOperator()
+    ].forEach((operatorLogic) => {
+      this._operatorLogicMap.set(operatorLogic.getToken(), operatorLogic);
+    });
+  }
+  get = (operator) => {
+    return this._operatorLogicMap.get(operator);
+  };
+  exists = (operator) => {
+    return this.get(operator) !== void 0;
+  };
+}
+const operatorMap = new OperatorMap();
+class OperatorNode {
+  process(nodeArgs) {
+    if (!operatorMap.exists(nodeArgs.token)) {
+      return {
+        nextState: nodeArgs.initState,
+        status: BehaviorStatus.Failure
+      };
+    }
+    const logic = operatorMap.get(nodeArgs.token);
+    if (logic === void 0) {
+      console.error(`Unimplemented operator: ${nodeArgs.token}`);
+      return {
+        nextState: nodeArgs.initState,
+        status: BehaviorStatus.Failure
+      };
+    }
+    logic.process(nodeArgs);
+    return {
+      nextState: nodeArgs.initState,
+      status: BehaviorStatus.Success
+    };
+  }
+}
+class OperandNode {
+  process(nodeArgs) {
+    nodeArgs.initState.operandStack.push(btreeUtils.simplifyToken(nodeArgs.token));
+    return {
+      nextState: nodeArgs.initState,
+      status: BehaviorStatus.Success
+    };
+  }
+}
+class SelectorNode {
+  nodeList;
+  constructor(nodeList) {
+    this.nodeList = nodeList;
+  }
+  process(nodeArgs) {
+    let finalResult = this.defaultResult();
+    for (const node of this.nodeList) {
+      const currentResult = node.process(nodeArgs);
+      if (currentResult.status !== BehaviorStatus.Failure) {
+        finalResult = currentResult;
+        break;
+      }
+    }
+    return finalResult;
+  }
+}
+class ExpressionSelectorNode extends SelectorNode {
+  constructor(nodeList) {
+    super(nodeList);
+  }
+  defaultResult = () => {
+    return {
+      nextState: {
+        operandStack: []
+      },
+      status: BehaviorStatus.Failure
+    };
+  };
+}
+class CommandLogicNode {
+  // do side effects on to the result instead
+  process(nodeArgs) {
+    const currentOperands = nodeArgs.initState.operandStack.slice(
+      nodeArgs.initState.operandStack.length - this.getArgumentCount(),
+      nodeArgs.initState.operandStack.length
+    );
+    nodeArgs.initState.operandStack = nodeArgs.initState.operandStack.slice(
+      0,
+      nodeArgs.initState.operandStack.length - this.getArgumentCount()
+    );
+    if (currentOperands.length !== this.getArgumentCount()) {
+      console.error(`Insufficient operands/arguments found for command ${this.getToken()}`);
+      console.error(`Arguments found instead: ${currentOperands}`);
+      console.error(`Error occurred at token: ${nodeArgs.token}`);
+    } else {
+      this.doOperation(currentOperands, nodeArgs);
+    }
+    return {
+      nextState: nodeArgs.initState,
+      status: BehaviorStatus.Success
+    };
+  }
+}
+class RandomRangeCommand extends CommandLogicNode {
+  /**
+   * From: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random#getting_a_random_integer_between_two_values
+   */
+  getRandomInt = (min, max) => {
+    min = Math.ceil(min);
+    max = Math.floor(max);
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+  };
+  doOperation = (currentOperands, nodeArgs) => {
+    nodeArgs.initState.operandStack.push(
+      String(this.getRandomInt(Number(currentOperands[0]), Number(currentOperands[1])))
+    );
+  };
+  getArgumentCount = () => {
+    return 2;
+  };
+  getToken = () => {
+    return "#random_range";
+  };
+}
+class VisitedCountCommand extends CommandLogicNode {
+  doOperation = (currentOperands, nodeArgs) => {
+    const value = Number(dialogVariableStore.getItem(`+${currentOperands[0]}`));
+    if (isNaN(value) || value === 0) {
+      nodeArgs.initState.operandStack.push("0");
+    } else {
+      nodeArgs.initState.operandStack.push(String(value));
+    }
+  };
+  getArgumentCount = () => {
+    return 1;
+  };
+  getToken = () => {
+    return "#visited_count";
+  };
+}
+class VisitedCommand extends CommandLogicNode {
+  visitedCountCommand = new VisitedCountCommand();
+  doOperation = (currentOperands, nodeArgs) => {
+    this.visitedCountCommand.process(nodeArgs);
+    const value = Number(nodeArgs.initState.operandStack.pop());
+    if (isNaN(value) || value === 0) {
+      nodeArgs.initState.operandStack.push("false");
+    } else {
+      nodeArgs.initState.operandStack.push("true");
+    }
+  };
+  getArgumentCount = () => {
+    return 0;
+  };
+  getToken = () => {
+    return "#visited";
+  };
+}
+class CommandMap {
+  _commandMap = /* @__PURE__ */ new Map();
+  constructor() {
+    [new RandomRangeCommand(), new VisitedCountCommand(), new VisitedCommand()].forEach(
+      (commandLogic) => {
+        this._commandMap.set(commandLogic.getToken(), commandLogic);
+      }
+    );
+  }
+  get = (command) => {
+    return this._commandMap.get(command);
+  };
+  exists = (command) => {
+    return this.get(command) !== void 0;
+  };
+}
+const commandMap = new CommandMap();
+class CommandExpressionNode {
+  process(nodeArgs) {
+    const commandNode = commandMap.get(nodeArgs.token);
+    if (commandNode === void 0) {
+      if (nodeArgs.token.startsWith("#")) {
+        console.error(`Unimplemented command: ${nodeArgs.token}`);
+      }
+      return {
+        nextState: nodeArgs.initState,
+        status: BehaviorStatus.Failure
+      };
+    }
+    commandNode.process(nodeArgs);
+    return {
+      nextState: nodeArgs.initState,
+      status: BehaviorStatus.Success
+    };
+  }
+}
+class ExpressionEvaluator {
+  evaluatorTree = new ExpressionSelectorNode([
+    new OperatorNode(),
+    new CommandExpressionNode(),
+    new OperandNode()
+  ]);
+  // from https://stackoverflow.com/a/175787/17836168
+  isNumeric = (str) => {
+    return (
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      !isNaN(str) && // use type coercion to parse the _entirety_ of the string (`parseFloat` alone does not do this)...
+      !isNaN(parseFloat(str))
+    );
+  };
+  getPrecedence = (token) => {
+    switch (token) {
+      case "&&":
+      case "||":
+      case "^":
+        return 1;
+      case "==":
+      case "!=":
+        return 2;
+      case "<":
+      case ">":
+      case ">=":
+      case "<=":
+        return 3;
+      case "+":
+      case "-":
+        return 4;
+      case "*":
+      case "/":
+      case "%":
+        return 3;
+      case "!":
+        return 4;
+      case "(":
+      case ")":
+        return 0;
+      default:
+        return -1;
+    }
+  };
+  evaluateFreeform = (line, prefix) => {
+    {
+      return [];
+    }
+  };
+  /**
+   * evaluates a yarn if or elseif statement
+   * @param line is the current line being evaluated
+   * @param prefix is either "<<if" or "<<elseif"
+   */
+  evaluate = (line, prefix) => {
+    {
+      return false;
+    }
+  };
+}
+const expressionEvaluator = new ExpressionEvaluator();
+class IfNode {
+  process(nodeArgs) {
+    if (!nodeArgs.line.startsWith("<<if")) {
+      return {
+        renderedLine: "",
+        nextState: nodeArgs.initState,
+        status: BehaviorStatus.Failure
+      };
+    }
+    const currentIfMode = btreeUtils.peek(nodeArgs.initState.ifModeStack);
+    if ([IfMode.EvaluateNext, IfMode.Ignore].includes(currentIfMode)) {
+      console.log("Skipping if node because");
+      nodeArgs.initState.ifModeStack.push(IfMode.Ignore);
+      return {
+        renderedLine: "",
+        nextState: nodeArgs.initState,
+        status: BehaviorStatus.Success
+      };
+    }
+    if (expressionEvaluator.evaluate(nodeArgs.line, "<<if")) {
+      nodeArgs.initState.ifModeStack.push(IfMode.Evaluated);
+    } else {
+      nodeArgs.initState.ifModeStack.push(IfMode.EvaluateNext);
+    }
+    return {
+      renderedLine: "",
+      nextState: nodeArgs.initState,
+      status: BehaviorStatus.Success
+    };
+  }
+}
+class EndIfNode {
+  process(nodeArgs) {
+    if (!nodeArgs.line.startsWith("<<endif>>")) {
+      return {
+        nextState: nodeArgs.initState,
+        renderedLine: "",
+        status: BehaviorStatus.Failure
+      };
+    }
+    nodeArgs.initState.ifModeStack.pop();
+    return {
+      nextState: nodeArgs.initState,
+      renderedLine: "",
+      status: BehaviorStatus.Success
+    };
+  }
+}
+class ElseNode {
+  process(nodeArgs) {
+    if (!nodeArgs.line.startsWith("<<else>>")) {
+      return {
+        nextState: nodeArgs.initState,
+        renderedLine: "",
+        status: BehaviorStatus.Failure
+      };
+    }
+    const currentIfMode = btreeUtils.peek(nodeArgs.initState.ifModeStack);
+    switch (currentIfMode) {
+      case IfMode.Search:
+        console.error("Syntax error found in yarn dialog!");
+        console.error(`Check out line ${nodeArgs.lineIndex + 1}: ${nodeArgs.line}`);
+        break;
+      case IfMode.Ignore:
+        break;
+      case IfMode.Evaluated:
+        nodeArgs.initState.ifModeStack.pop();
+        nodeArgs.initState.ifModeStack.push(IfMode.Ignore);
+        break;
+      case IfMode.EvaluateNext:
+        nodeArgs.initState.ifModeStack.pop();
+        nodeArgs.initState.ifModeStack.push(IfMode.Evaluated);
+        break;
+      default:
+        console.error("Unimplemented if state!");
+        console.error(`Check out line ${nodeArgs.lineIndex + 1}: ${nodeArgs.line}`);
+        break;
+    }
+    return {
+      nextState: nodeArgs.initState,
+      renderedLine: "",
+      status: BehaviorStatus.Success
+    };
+  }
+}
+class ElseIfNode {
+  process(nodeArgs) {
+    if (!nodeArgs.line.startsWith("<<elseif")) {
+      return {
+        nextState: nodeArgs.initState,
+        renderedLine: "",
+        status: BehaviorStatus.Failure
+      };
+    }
+    const currentIfMode = btreeUtils.peek(nodeArgs.initState.ifModeStack);
+    switch (currentIfMode) {
+      case IfMode.Search:
+        console.error("Syntax error found in yarn dialog!");
+        console.error(`Check out line ${nodeArgs.lineIndex + 1}: ${nodeArgs.line}`);
+        break;
+      case IfMode.Ignore:
+        break;
+      case IfMode.Evaluated:
+        nodeArgs.initState.ifModeStack.pop();
+        nodeArgs.initState.ifModeStack.push(IfMode.Ignore);
+        break;
+      case IfMode.EvaluateNext:
+        if (expressionEvaluator.evaluate(nodeArgs.line, "<<elseif")) {
+          nodeArgs.initState.ifModeStack.pop();
+          nodeArgs.initState.ifModeStack.push(IfMode.Evaluated);
+        }
+        break;
+      default:
+        console.error("Unimplemented if state!");
+        console.error(`Check out line ${nodeArgs.lineIndex + 1}: ${nodeArgs.line}`);
+        break;
+    }
+    return {
+      nextState: nodeArgs.initState,
+      renderedLine: "",
+      status: BehaviorStatus.Success
+    };
+  }
+}
+class SetVariableNode {
+  process(nodeArgs) {
+    if (!nodeArgs.line.startsWith("<<set")) {
+      return {
+        nextState: nodeArgs.initState,
+        renderedLine: "",
+        status: BehaviorStatus.Failure
+      };
+    }
+    const setValuePair = nodeArgs.line.split("=");
+    const key = setValuePair[0].slice("<<set ".length).trim();
+    setValuePair.shift();
+    const preValue = setValuePair.join("=").trim();
+    const value = expressionEvaluator.evaluateFreeform(preValue, "");
+    dialogVariableStore.setItem(key, btreeUtils.peek(value));
+    return {
+      nextState: nodeArgs.initState,
+      renderedLine: "",
+      status: BehaviorStatus.Success
+    };
+  }
+}
+class IgnoreGuardNode {
+  process(nodeArgs) {
+    const currentIfMode = btreeUtils.peek(nodeArgs.initState.ifModeStack);
+    if ([IfMode.Ignore, IfMode.EvaluateNext].includes(currentIfMode)) {
+      return {
+        nextState: nodeArgs.initState,
+        renderedLine: "",
+        status: BehaviorStatus.Success
+      };
+    }
+    return {
+      nextState: nodeArgs.initState,
+      renderedLine: "",
+      status: BehaviorStatus.Failure
+    };
+  }
+}
+class NormalLineProcessorNode {
+  process(nodeArgs) {
+    const renderedLine = nodeArgs.line.split("{$").map((token, index) => {
+      if (index == 0) {
+        return token;
+      }
+      return token.split("}").map((varToken, index2) => {
+        if (index2 == 0 && browser) {
+          const varValue = localStorage.getItem(`$${varToken}`);
+          if (varValue !== null) {
+            return varValue;
+          }
+          console.warn(
+            `Null variable in yarn: ${varToken}. Make sure that all variables were set before using them.`
+          );
+        }
+        return varToken;
+      }).join("");
+    }).join("");
+    return {
+      nextState: nodeArgs.initState,
+      renderedLine,
+      status: BehaviorStatus.Success
+    };
+  }
+}
+class LineSelectorNode extends SelectorNode {
+  constructor(nodeList) {
+    super(nodeList);
+  }
+  defaultResult = () => {
+    return {
+      nextState: new BehaviorState(),
+      renderedLine: "",
+      status: BehaviorStatus.Failure
+    };
+  };
+}
+class LineCommentNode {
+  process(nodeArgs) {
+    if (!nodeArgs.line.startsWith("//")) {
+      return {
+        renderedLine: "",
+        nextState: nodeArgs.initState,
+        status: BehaviorStatus.Failure
+      };
+    }
+    return {
+      renderedLine: "",
+      nextState: nodeArgs.initState,
+      status: BehaviorStatus.Success
+    };
+  }
+}
+class DeclareCommand {
+  setVariableNode = new SetVariableNode();
+  process(nodeArgs) {
+    if (!nodeArgs.line.startsWith("<<declare")) {
+      return {
+        renderedLine: "",
+        nextState: nodeArgs.initState,
+        status: BehaviorStatus.Failure
+      };
+    }
+    const setValuePair = nodeArgs.line.split("=");
+    const key = setValuePair[0].slice("<<declare ".length).trim();
+    if (localStorage.getItem(key) !== null) {
+      return {
+        renderedLine: "",
+        nextState: nodeArgs.initState,
+        status: BehaviorStatus.Success
+      };
+    }
+    setValuePair.shift();
+    const preValue = setValuePair.join("=").split(" as ");
+    preValue.pop();
+    const value = preValue.join(" as ");
+    const result = this.setVariableNode.process({
+      initState: nodeArgs.initState,
+      line: `<<set ${key} = ${value}>>`,
+      // faking the line lol
+      lineIndex: nodeArgs.lineIndex
+    });
+    return {
+      nextState: result.nextState,
+      renderedLine: "",
+      status: BehaviorStatus.Success
+    };
+  }
+}
+class JumpCommand {
+  setVariableNode = new SetVariableNode();
+  process(nodeArgs) {
+    if (!nodeArgs.line.startsWith("<<jump")) {
+      return {
+        renderedLine: "",
+        nextState: nodeArgs.initState,
+        status: BehaviorStatus.Failure
+      };
+    }
+    if (nodeArgs.initState.ignoreJumps) {
+      return {
+        nextState: nodeArgs.initState,
+        renderedLine: "",
+        status: BehaviorStatus.Success
+      };
+    }
+    const choiceName = nodeArgs.line.slice("<<jump ".length, nodeArgs.line.length - ">>".length).replace(/^\{/, "").replace(/}$/, "");
+    const dialogChoice = dialogManager.dialogMessageMap.get(btreeUtils.simplifyToken(choiceName));
+    if (dialogChoice !== void 0) {
+      dialogManager.setDialogChoice(dialogChoice);
+    } else {
+      console.error(
+        `Unknown jump node at line ${nodeArgs.lineIndex + 1}: ${choiceName} or ${btreeUtils.simplifyToken(choiceName)}`
+      );
+    }
+    return {
+      nextState: nodeArgs.initState,
+      renderedLine: "",
+      status: BehaviorStatus.Success
+    };
+  }
+}
+class IgnoreJumpNode {
+  process(nodeArgs) {
+    if (!nodeArgs.line.startsWith("// ignore jumps")) {
+      return {
+        renderedLine: "",
+        nextState: nodeArgs.initState,
+        status: BehaviorStatus.Failure
+      };
+    }
+    nodeArgs.initState.ignoreJumps = true;
+    return {
+      renderedLine: "",
+      nextState: nodeArgs.initState,
+      status: BehaviorStatus.Success
+    };
+  }
+}
+class UnvisitCommand {
+  process(nodeArgs) {
+    if (!nodeArgs.line.startsWith("<<unvisit") || !browser) {
+      return {
+        renderedLine: "",
+        nextState: nodeArgs.initState,
+        status: BehaviorStatus.Failure
+      };
+    }
+    const nodeName = nodeArgs.line.slice("<<unvisit ".length, nodeArgs.line.length - ">>".length).replace(/^\{/, "").replace(/}$/, "");
+    const key = `+${nodeName}`;
+    dialogVariableStore.removeItem(key);
+    return {
+      nextState: nodeArgs.initState,
+      renderedLine: "",
+      status: BehaviorStatus.Success
+    };
+  }
+}
+class DialogProcessor {
+  processingTree = new LineSelectorNode([
+    /*region comment based formats*/
+    new IgnoreJumpNode(),
+    // must be prioritized above line comment node
+    new LineCommentNode(),
+    /*endregion commend based formats*/
+    new EndIfNode(),
+    new ElseIfNode(),
+    new ElseNode(),
+    new IfNode(),
+    new IgnoreGuardNode(),
+    /*region commands*/
+    new SetVariableNode(),
+    new DeclareCommand(),
+    new JumpCommand(),
+    new UnvisitCommand(),
+    /*endregion commands*/
+    new NormalLineProcessorNode()
+  ]);
+  /**
+   * process the dialog line by line and return a presentable string
+   * @param dialogDetail
+   */
+  processDialog = (dialogDetail) => {
+    {
+      return "";
+    }
+  };
+}
+class DialogManager {
+  dialogMessageMap = /* @__PURE__ */ new Map();
+  dialogMessageList = [];
+  fullCurrentMessage = defaultDialogMessage[0].textContent;
+  currentMessageMeta = defaultDialogMessage[0];
+  currentMessage = writable("");
+  currentIndex = 0;
+  previousTimestamp = 0;
+  isDoneTransition = false;
+  currentPortrait = writable();
+  portraitMap = /* @__PURE__ */ new Map();
+  currentState = DialogState.Visible;
+  hidePercent = tweened(100, {
+    duration: 400,
+    easing: cubicOut
+  });
+  // 100 = 100%
+  skipNextActiveTime = 0;
+  dialogProcessor = new DialogProcessor();
+  // for queueing actions
+  _setDialogChoiceQueue = [];
+  _setDialogChoiceMutex = false;
+  onSetDialogListeners = [];
+  constructor() {
+    enableDialogueOverlay.subscribe((value) => {
+      if (value) {
+        this.hidePercent.set(0);
+        this.setDialogToDefault();
+      } else {
+        this.hidePercent.set(100);
+        this.setDialogTree([{ textContent: "" }]);
+      }
+    });
+  }
+  /**
+   * when users interact with the dialog, they can skip the transition like in a game
+   * note that there is a cool down to this, check out skipNextActiveTime
+   */
+  skipAnimation = () => {
+    if (this.previousTimestamp > this.skipNextActiveTime && this.currentState == DialogState.Visible && !this.isDoneTransition) {
+      this.currentIndex = this.fullCurrentMessage.length - 1;
+      this.currentMessage.update(() => this.fullCurrentMessage.slice(0, this.currentIndex));
+    }
+  };
+  /**
+   * hides or shows the dialog UI
+   * @param shouldEnable
+   */
+  enableDialog = (shouldEnable) => {
+    enableDialogueOverlay.update(() => shouldEnable);
+  };
+  /**
+   * sets the possible dialog that might appear on the Dialog UI
+   * note that it overwrites the previous tree and does not append on it due to the possibility
+   * of node name conflicts
+   * @param newMessageList
+   */
+  setDialogTree = (newMessageList) => {
+    this.dialogMessageList = newMessageList;
+    this.dialogMessageMap.clear();
+    newMessageList.map((value) => {
+      if (value.dialogId) {
+        this.dialogMessageMap.set(value.dialogId, value);
+      }
+    });
+    if (this.portraitMap.size == 0) {
+      this.portraitMap.set(PortraitType.AresHappy.toString(), AresHappy);
+      this.portraitMap.set(PortraitType.AresBlushing.toString(), AresBlushing);
+      this.portraitMap.set(PortraitType.AresDisappointed.toString(), AresDisappointed);
+      this.portraitMap.set(PortraitType.AresLetsGo.toString(), AresLetsGo);
+      this.portraitMap.set(PortraitType.AresMad.toString(), AresMad);
+      this.portraitMap.set(PortraitType.AresNeutral.toString(), AresNeutral);
+      this.portraitMap.set(PortraitType.AresSlightlyMad.toString(), AresSlightlyMad);
+      this.portraitMap.set(PortraitType.AresSurprised.toString(), AresSurprised);
+      this.portraitMap.set(PortraitType.AresYay.toString(), AresYay);
+    }
+    this.setDialogChoice(newMessageList[0]);
+  };
+  /**
+   * Remember to call this before SetDialogTree
+   * and unsubscribe during onDestroy
+   * @param callback
+   */
+  subscribeToSetDialogChoice = (callback) => {
+    this.onSetDialogListeners.push(callback);
+  };
+  /**
+   * Remember to call this during onDestroy
+   * @param callback
+   * todo: double check if this works???
+   */
+  unsubscribeToSetDialogChoice = (callback) => {
+    const index = this.onSetDialogListeners.indexOf(callback);
+    if (index > -1) {
+      this.onSetDialogListeners.splice(index, 1);
+    }
+  };
+  /**
+   * Sets the next dialog to show depending on which special choice a href link the user
+   * has interacted with
+   * @param newMessage
+   *
+   * you can listen to this!
+   */
+  setDialogChoice = (newMessage) => {
+    if (!newMessage || !newMessage.textContent) {
+      return;
+    }
+    this._setDialogChoiceQueue.push(newMessage);
+    if (!this._setDialogChoiceMutex) {
+      this._setDialogChoiceMutex = true;
+      this._setDialogChoice();
+    }
+  };
+  _setDialogChoice = () => {
+    const newMessage = this._setDialogChoiceQueue.shift();
+    if (newMessage === void 0) {
+      this._setDialogChoiceMutex = false;
+      this.onSetDialogListeners.forEach((listener) => {
+        listener(this.currentMessageMeta);
+      });
+      return;
+    }
+    this.currentMessageMeta = newMessage;
+    let portraitValue = AresHappy;
+    if (this.currentMessageMeta.portraitType) {
+      portraitValue = this.portraitMap.get(this.currentMessageMeta.portraitType);
+    }
+    if (portraitValue) {
+      this.currentPortrait.update(() => portraitValue);
+    }
+    this.fullCurrentMessage = this.dialogProcessor.processDialog(this.currentMessageMeta);
+    this.currentMessage.update(() => "");
+    this.currentIndex = 0;
+    this.skipNextActiveTime = this.previousTimestamp + 1e3;
+    this.isDoneTransition = false;
+    if (this.currentMessageMeta.dialogId) {
+      const key = `+${this.currentMessageMeta.dialogId}`;
+      const value = Number(dialogVariableStore.getItem(key));
+      if (isNaN(value)) {
+        dialogVariableStore.setItem(key, "1");
+      } else {
+        dialogVariableStore.setItem(key, `${value + 1}`);
+      }
+    }
+    this._setDialogChoice();
+  };
+  setDialogToDefault = () => {
+    this.setDialogTree(defaultDialogMessage);
+  };
+  /**
+   * updates the information and detail frame by frame
+   * you can think of this like the main game loop
+   *
+   * @param timestamp
+   *
+   * todo: this might be too big we might want to refactor this method for better readability
+   * ISSUE #81 https://github.com/TurnipXenon/pineapple/issues/81
+   */
+  update = (timestamp) => {
+    if (this.currentState == DialogState.Invisible || this.currentState == DialogState.Busy) {
+      window.requestAnimationFrame(this.update);
+      return;
+    }
+    if (!this.isDoneTransition && this.currentIndex > this.fullCurrentMessage.length) {
+      const elementList = document.getElementsByClassName("dialog-choice");
+      for (const el of elementList) {
+        el.addEventListener("click", (event) => {
+          const choice = el.classList[0].split("-")[1];
+          this.setDialogChoice(this.dialogMessageMap.get(choice));
+        });
+      }
+      this.isDoneTransition = true;
+    }
+    if (this.currentIndex > this.fullCurrentMessage.length || this.previousTimestamp + updateRate > timestamp) {
+      window.requestAnimationFrame(this.update);
+      return;
+    }
+    this.previousTimestamp = timestamp;
+    while (this.fullCurrentMessage[this.currentIndex] == "<" && this.currentIndex + 1 < this.fullCurrentMessage.length) {
+      this.currentIndex = this.fullCurrentMessage.indexOf(">", this.currentIndex) + 1;
+      this.currentIndex = Math.min(this.currentIndex, this.fullCurrentMessage.length - 1);
+    }
+    this.currentMessage.update(() => this.fullCurrentMessage.slice(0, this.currentIndex));
+    ++this.currentIndex;
+    window.requestAnimationFrame(this.update);
+  };
+}
+const enableDialogueOverlay = writable(true);
+const dialogVariableStore = createNewMapStore();
+const updateRate = 40 / 1e3;
+const defaultDialogMessage = [
+  {
+    textContent: `<p>Have you drank water? Or perhaps, you've checked out <a target="_blank" class="external-link" href="http://crouton.net">one of the best webpages</a> out there?`
+  }
+];
+const dialogManager = new DialogManager();
+export {
+  AresHappy as A,
+  PortraitType as P,
+  dialogManager as d,
+  enableDialogueOverlay as e
+};