libram 0.4.0 → 0.4.1

package/dist/combat.d.ts

@@ -100,9 +100,10 @@ export declare class Macro {
      * Conditionally add a step to a macro based on a condition evaluated at the time of building the macro.
      * @param condition The JS condition.
      * @param ifTrue Continuation to add if the condition is true.
+     * @param ifFalse Optional input to turn this into an if...else statement.
      * @returns {Macro} This object itself.
      */
-    externalIf(condition: boolean, ifTrue: string | Macro): this;
+    externalIf(condition: boolean, ifTrue: string | Macro, ifFalse?: string | Macro): this;
     /**
      * Create a new macro with a condition evaluated at the time of building the macro.
      * @param condition The JS condition.

package/dist/combat.js

@@ -273,10 +273,11 @@ var Macro = /*#__PURE__*/function () {
      * Conditionally add a step to a macro based on a condition evaluated at the time of building the macro.
      * @param condition The JS condition.
      * @param ifTrue Continuation to add if the condition is true.
+     * @param ifFalse Optional input to turn this into an if...else statement.
      * @returns {Macro} This object itself.
      */
-    function externalIf(condition, ifTrue) {
-      return condition ? this.step(ifTrue) : this;
+    function externalIf(condition, ifTrue, ifFalse) {
+      if (condition) return this.step(ifTrue);else if (ifFalse) return this.step(ifFalse);else return this;
     }
     /**
      * Create a new macro with a condition evaluated at the time of building the macro.

package/dist/diet/index.d.ts

@@ -0,0 +1,16 @@
+export declare class MenuItem {
+    item: Item;
+    maximum?: number;
+    additionalValue?: number;
+    size: number;
+    static seasoning: MenuItem;
+    static mayoflex: MenuItem;
+    static fork: MenuItem;
+    static mug: MenuItem;
+    constructor(item: Item, maximum?: number, additionalValue?: number, size?: number);
+    toString(): string;
+    price(): number;
+}
+declare type Organ = "food" | "booze" | "spleen item";
+export declare function planDiet(mpa: number, menu: MenuItem[], organCapacities?: [Organ, number | null][]): [Item[], number][];
+export {};

package/dist/diet/index.js

@@ -0,0 +1,439 @@
+"use strict";
+
+require("core-js/modules/es.symbol.js");
+
+require("core-js/modules/es.symbol.description.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.planDiet = planDiet;
+exports.MenuItem = void 0;
+
+require("core-js/modules/es.array.map.js");
+
+require("core-js/modules/es.regexp.exec.js");
+
+require("core-js/modules/es.string.split.js");
+
+require("core-js/modules/es.array.iterator.js");
+
+require("core-js/modules/es.object.to-string.js");
+
+require("core-js/modules/es.regexp.to-string.js");
+
+require("core-js/modules/es.array.filter.js");
+
+require("core-js/modules/es.array.includes.js");
+
+require("core-js/modules/es.array.sort.js");
+
+require("core-js/modules/es.string.includes.js");
+
+require("core-js/modules/es.array.concat.js");
+
+require("core-js/modules/es.array.slice.js");
+
+require("core-js/modules/es.array.find.js");
+
+var _kolmafia = require("kolmafia");
+
+var _knapsack3 = require("./knapsack");
+
+var _lib = require("../lib");
+
+var _templateString = require("../template-string");
+
+var _utils = require("../utils");
+
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8, _templateObject9, _templateObject10, _templateObject11, _templateObject12, _templateObject13, _templateObject14, _templateObject15, _templateObject16, _templateObject17, _templateObject18, _templateObject19, _templateObject20;
+
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+// TODO: Include other consumption modifiers.
+function expectedAdventures(item) {
+  var forkMug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  if (item.adventures === "") return 0;
+
+  var _item$adventures$spli = item.adventures.split(/[-–—]/).map(s => parseInt(s)),
+      _item$adventures$spli2 = _slicedToArray(_item$adventures$spli, 2),
+      min = _item$adventures$spli2[0],
+      recordedMax = _item$adventures$spli2[1];
+
+  var max = recordedMax !== null && recordedMax !== void 0 ? recordedMax : min;
+
+  var interpolated = _toConsumableArray(new Array(max - min + 1).keys()).map(n => n + min);
+
+  return (0, _utils.sum)(interpolated, n => Math.floor(n * (forkMug ? 1.3 : 1))) / interpolated.length;
+} // Assuming list is already sorted, count adjacent items.
+// Effectively run-length encoding.
+
+
+function aggregate(list, isEqual) {
+  var aggregatedList = [];
+
+  var _iterator = _createForOfIteratorHelper(list),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var item = _step.value;
+
+      if (aggregatedList.length === 0) {
+        aggregatedList.push([item, 1]);
+      } else {
+        var last = aggregatedList[aggregatedList.length - 1];
+
+        var _last = _slicedToArray(last, 1),
+            lastItem = _last[0];
+
+        if (isEqual(item, lastItem)) {
+          last[1]++;
+        } else {
+          aggregatedList.push([item, 1]);
+        }
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return aggregatedList;
+}
+
+var MenuItem = /*#__PURE__*/function () {
+  function MenuItem(item, maximum, additionalValue, size) {
+    _classCallCheck(this, MenuItem);
+
+    _defineProperty(this, "item", void 0);
+
+    _defineProperty(this, "maximum", void 0);
+
+    _defineProperty(this, "additionalValue", void 0);
+
+    _defineProperty(this, "size", void 0);
+
+    this.item = item;
+    this.maximum = maximum;
+    this.additionalValue = additionalValue;
+    var typ = (0, _kolmafia.itemType)(this.item);
+    this.size = (size !== null && size !== void 0 ? size : typ === "food") ? this.item.fullness : typ === "booze" ? this.item.inebriety : typ === "spleen item" ? this.item.spleen : 0;
+  }
+
+  _createClass(MenuItem, [{
+    key: "toString",
+    value: function toString() {
+      return this.item.toString();
+    }
+  }, {
+    key: "price",
+    value: function price() {
+      return (0, _kolmafia.npcPrice)(this.item) > 0 ? (0, _kolmafia.npcPrice)(this.item) : (0, _kolmafia.mallPrice)(this.item);
+    }
+  }]);
+
+  return MenuItem;
+}();
+
+exports.MenuItem = MenuItem;
+
+_defineProperty(MenuItem, "seasoning", new MenuItem((0, _templateString.$item)(_templateObject17 || (_templateObject17 = _taggedTemplateLiteral(["Special Seasoning"])))));
+
+_defineProperty(MenuItem, "mayoflex", new MenuItem((0, _templateString.$item)(_templateObject18 || (_templateObject18 = _taggedTemplateLiteral(["Mayoflex"])))));
+
+_defineProperty(MenuItem, "fork", new MenuItem((0, _templateString.$item)(_templateObject19 || (_templateObject19 = _taggedTemplateLiteral(["Ol' Scratch's salad fork"])))));
+
+_defineProperty(MenuItem, "mug", new MenuItem((0, _templateString.$item)(_templateObject20 || (_templateObject20 = _taggedTemplateLiteral(["Frosty's frosty mug"])))));
+
+var DietPlanner = /*#__PURE__*/function () {
+  function DietPlanner(mpa, menu) {
+    _classCallCheck(this, DietPlanner);
+
+    _defineProperty(this, "mpa", void 0);
+
+    _defineProperty(this, "menu", void 0);
+
+    _defineProperty(this, "checkFork", void 0);
+
+    _defineProperty(this, "checkMug", void 0);
+
+    _defineProperty(this, "useSeasoning", void 0);
+
+    _defineProperty(this, "useMayoflex", void 0);
+
+    _defineProperty(this, "spleenValue", 0);
+
+    this.mpa = mpa;
+    this.checkFork = menu.some(item => item.item === MenuItem.fork.item);
+    this.checkMug = menu.some(item => item.item === MenuItem.mug.item);
+    this.useSeasoning = menu.some(item => item.item === (0, _templateString.$item)(_templateObject || (_templateObject = _taggedTemplateLiteral(["Special Seasoning"]))));
+    this.useMayoflex = (0, _kolmafia.getWorkshed)() === (0, _templateString.$item)(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["portable Mayo Clinic"]))) && menu.some(item => item.item === (0, _templateString.$item)(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["Mayoflex"]))));
+    this.menu = menu.filter(item => ["food", "booze", "spleen item"].includes((0, _kolmafia.itemType)(item.item)));
+
+    if (menu.length > 100) {
+      (0, _kolmafia.mallPrices)("food");
+      (0, _kolmafia.mallPrices)("booze");
+    }
+
+    var spleenItems = menu.filter(item => (0, _kolmafia.itemType)(item.item) === "spleen item");
+    spleenItems.sort((x, y) => -(this.consumptionValue(x) / x.item.spleen - this.consumptionValue(y) / y.item.spleen));
+
+    if (spleenItems.length > 0) {
+      this.spleenValue = this.consumptionValue(spleenItems[0]) / spleenItems[0].item.spleen;
+    }
+  }
+
+  _createClass(DietPlanner, [{
+    key: "consumptionValue",
+    value: function consumptionValue(menuItem) {
+      return this.consumptionHelpersAndValue(menuItem)[1];
+    }
+  }, {
+    key: "consumptionHelpersAndValue",
+    value: function consumptionHelpersAndValue(menuItem) {
+      var _menuItem$additionalV, _menuItem$additionalV2;
+
+      var additionalAdventures = 0;
+      var helpers = [];
+
+      if (this.useMayoflex && (0, _kolmafia.itemType)(menuItem.item) === "food" && this.mpa > (0, _kolmafia.npcPrice)((0, _templateString.$item)(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["Mayoflex"]))))) {
+        helpers.push(MenuItem.mayoflex);
+        additionalAdventures++;
+      }
+
+      if (this.useSeasoning && (0, _kolmafia.itemType)(menuItem.item) === "food" && this.mpa > (0, _kolmafia.mallPrice)((0, _templateString.$item)(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["Special Seasoning"]))))) {
+        helpers.push(MenuItem.seasoning);
+        additionalAdventures++;
+      }
+
+      var forkMug = (0, _kolmafia.itemType)(menuItem.item) === "food" ? MenuItem.fork : (0, _kolmafia.itemType)(menuItem.item) === "booze" ? MenuItem.mug : null;
+      var forkMugPrice = forkMug ? forkMug.price() : Infinity;
+      var valueRaw = (expectedAdventures(menuItem.item, false) + additionalAdventures) * this.mpa - (0, _kolmafia.mallPrice)(menuItem.item) + ((_menuItem$additionalV = menuItem.additionalValue) !== null && _menuItem$additionalV !== void 0 ? _menuItem$additionalV : 0);
+      var valueForkMug = (expectedAdventures(menuItem.item, true) + additionalAdventures) * this.mpa - (0, _kolmafia.mallPrice)(menuItem.item) - forkMugPrice + ((_menuItem$additionalV2 = menuItem.additionalValue) !== null && _menuItem$additionalV2 !== void 0 ? _menuItem$additionalV2 : 0);
+      var valueSpleen = (0, _templateString.$items)(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["jar of fermented pickle juice, extra-greasy slider"]))).includes(menuItem.item) ? 5 * this.spleenValue : 0;
+      return forkMug && valueForkMug > valueRaw ? [[].concat(helpers, [forkMug, menuItem]), valueForkMug + valueSpleen] : [[].concat(helpers, [menuItem]), valueRaw + valueSpleen];
+    }
+  }, {
+    key: "planOrgan",
+    value: function planOrgan(organ, capacity) {
+      // print(`Plan ${organ} < ${capacity}`);
+      var submenu = this.menu.filter(item => (0, _kolmafia.itemType)(item.item) === organ);
+      var knapsackValues = submenu.map(menuItem => [].concat(_toConsumableArray(this.consumptionHelpersAndValue(menuItem)), [menuItem.size, menuItem.maximum]));
+
+      var _knapsack = (0, _knapsack3.knapsack)(knapsackValues, capacity),
+          _knapsack2 = _slicedToArray(_knapsack, 2),
+          value = _knapsack2[0],
+          menuItemList = _knapsack2[1];
+
+      var itemList = menuItemList.map(menuItems => menuItems.map(menuItem => menuItem.item)); // print(
+      //   `Items: ${itemList.length} ${([] as Item[])
+      //     .concat(...itemList)
+      //     .map((item) => item.name)
+      //     .join(", ")}`
+      // );
+
+      return [value, aggregate(itemList, (x, y) => x.every((elem, index) => elem === y[index]))];
+    }
+  }, {
+    key: "planOrgans",
+    value: function planOrgans(organCapacities) {
+      var _ref5;
+
+      var valuePlans = organCapacities.map(_ref => {
+        var _ref2 = _slicedToArray(_ref, 2),
+            organ = _ref2[0],
+            capacity = _ref2[1];
+
+        return this.planOrgan(organ, capacity);
+      });
+      return [(0, _utils.sum)(valuePlans, _ref3 => {
+        var _ref4 = _slicedToArray(_ref3, 1),
+            value = _ref4[0];
+
+        return value;
+      }), (_ref5 = []).concat.apply(_ref5, _toConsumableArray(valuePlans.map(_ref6 => {
+        var _ref7 = _slicedToArray(_ref6, 2),
+            plan = _ref7[1];
+
+        return plan;
+      })))];
+    }
+  }, {
+    key: "planOrgansWithTrials",
+    value: function planOrgansWithTrials(organCapacities, trialItems) {
+      if (trialItems.length === 0) {
+        return this.planOrgans(organCapacities);
+      }
+
+      var organCapacitiesWithMap = new Map(organCapacities);
+
+      var _trialItems$ = _slicedToArray(trialItems[0], 2),
+          trialItem = _trialItems$[0],
+          organSizes = _trialItems$[1]; // print(`TRYING ${trialItem.item.name}`);
+
+
+      var _iterator2 = _createForOfIteratorHelper(organSizes),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _step2$value = _slicedToArray(_step2.value, 2),
+              organ = _step2$value[0],
+              size = _step2$value[1];
+
+          var current = organCapacitiesWithMap.get(organ);
+
+          if (current !== undefined) {
+            organCapacitiesWithMap.set(organ, current - size);
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+
+      var organCapacitiesWith = _toConsumableArray(organCapacitiesWithMap);
+
+      var _this$planOrgansWithT = this.planOrgansWithTrials(organCapacities, trialItems.slice(1)),
+          _this$planOrgansWithT2 = _slicedToArray(_this$planOrgansWithT, 2),
+          valueWithout = _this$planOrgansWithT2[0],
+          planWithout = _this$planOrgansWithT2[1];
+
+      var _this$planOrgansWithT3 = this.planOrgansWithTrials(organCapacitiesWith, trialItems.slice(1)),
+          _this$planOrgansWithT4 = _slicedToArray(_this$planOrgansWithT3, 2),
+          valueWith = _this$planOrgansWithT4[0],
+          planWith = _this$planOrgansWithT4[1];
+
+      var _this$consumptionHelp = this.consumptionHelpersAndValue(trialItem),
+          _this$consumptionHelp2 = _slicedToArray(_this$consumptionHelp, 2),
+          helpers = _this$consumptionHelp2[0],
+          value = _this$consumptionHelp2[1];
+
+      (0, _kolmafia.print)("".concat(new Array(5 - trialItems.length).join(">"), " ").concat(valueWithout > valueWith + value ? "WITHOUT" : "WITH", " ").concat(trialItem.item, " ").concat(value.toFixed(0), ": ").concat(valueWithout.toFixed(0), " vs. ").concat((valueWith + value).toFixed(0)));
+      return valueWithout > valueWith + value ? [valueWithout, planWithout] : [valueWith, [].concat(_toConsumableArray(planWith), [[helpers.map(menuItem => menuItem.item), 1]])];
+    }
+  }]);
+
+  return DietPlanner;
+}(); // [item, fullness, inebriety]
+
+
+var interactingItems = [[(0, _templateString.$item)(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["spice melange"]))), [["food", -3], ["booze", -3]]], [(0, _templateString.$item)(_templateObject8 || (_templateObject8 = _taggedTemplateLiteral(["Ultra Mega Sour Ball"]))), [["food", -3], ["booze", -3]]], [(0, _templateString.$item)(_templateObject9 || (_templateObject9 = _taggedTemplateLiteral(["The Plumber's mushroom stew"]))), [["food", 3], ["booze", -1]]], [(0, _templateString.$item)(_templateObject10 || (_templateObject10 = _taggedTemplateLiteral(["The Mad Liquor"]))), [["food", -1], ["booze", 3]]], [(0, _templateString.$item)(_templateObject11 || (_templateObject11 = _taggedTemplateLiteral(["Doc Clock's thyme cocktail"]))), [["food", -2], ["booze", 4]]], [(0, _templateString.$item)(_templateObject12 || (_templateObject12 = _taggedTemplateLiteral(["Mr. Burnsger"]))), [["food", 4], ["booze", -2]]]];
+
+function planDiet(mpa, menu) {
+  var _resolvedOrganCapacit;
+
+  var organCapacities = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [["food", null], ["booze", null], ["spleen item", null]];
+  var dietPlanner = new DietPlanner(mpa, menu);
+  (0, _kolmafia.print)("MENU:");
+
+  var _iterator3 = _createForOfIteratorHelper(menu),
+      _step3;
+
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var menuItem = _step3.value;
+
+      var _dietPlanner$consumpt = dietPlanner.consumptionHelpersAndValue(menuItem),
+          _dietPlanner$consumpt2 = _slicedToArray(_dietPlanner$consumpt, 2),
+          helpers = _dietPlanner$consumpt2[0],
+          value = _dietPlanner$consumpt2[1];
+
+      (0, _kolmafia.print)("".concat(menuItem.item.name, ": ").concat(helpers.join(", "), " ").concat(value));
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+
+  var resolvedOrganCapacities = organCapacities.map(_ref8 => {
+    var _ref9 = _slicedToArray(_ref8, 2),
+        organ = _ref9[0],
+        size = _ref9[1];
+
+    return [organ, size !== null && size !== void 0 ? size : organ === "food" ? (0, _kolmafia.fullnessLimit)() - (0, _kolmafia.myFullness)() + ((0, _lib.have)((0, _templateString.$item)(_templateObject13 || (_templateObject13 = _taggedTemplateLiteral(["distention pill"])))) ? 1 : 0) : organ === "booze" ? (0, _kolmafia.inebrietyLimit)() + ((0, _lib.have)((0, _templateString.$item)(_templateObject14 || (_templateObject14 = _taggedTemplateLiteral(["synthetic dog hair pill"])))) ? 1 : 0) : organ === "spleen item" ? (0, _kolmafia.spleenLimit)() - (0, _kolmafia.mySpleenUse)() : 0];
+  });
+  var allItems = new Map(menu.map(menuItem => [menuItem.item, menuItem]));
+  var includedInteractingItems = interactingItems.map(_ref10 => {
+    var _ref11 = _slicedToArray(_ref10, 2),
+        item = _ref11[0],
+        sizes = _ref11[1];
+
+    return [allItems.get(item), sizes];
+  }).filter(_ref12 => {
+    var _ref13 = _slicedToArray(_ref12, 1),
+        menuItem = _ref13[0];
+
+    return menuItem;
+  }); // print(
+  //   `included interacting: ${includedInteractingItems
+  //     .map(([menuItem]) => menuItem.item.name)
+  //     .join(", ")}`
+  // );
+
+  var _dietPlanner$planOrga = dietPlanner.planOrgansWithTrials(resolvedOrganCapacities.filter(_ref14 => {
+    var _ref15 = _slicedToArray(_ref14, 1),
+        organ = _ref15[0];
+
+    return ["food", "booze"].includes(organ);
+  }), includedInteractingItems),
+      _dietPlanner$planOrga2 = _slicedToArray(_dietPlanner$planOrga, 2),
+      planFoodBooze = _dietPlanner$planOrga2[1];
+
+  var additionalSpleen = (0, _utils.sum)(planFoodBooze, _ref16 => {
+    var _ref17 = _slicedToArray(_ref16, 2),
+        items = _ref17[0],
+        number = _ref17[1];
+
+    return items.includes((0, _templateString.$item)(_templateObject15 || (_templateObject15 = _taggedTemplateLiteral(["jar of fermented pickle juice"])))) || items.includes((0, _templateString.$item)(_templateObject16 || (_templateObject16 = _taggedTemplateLiteral(["extra-greasy slider"])))) ? 5 * number : 0;
+  });
+
+  var _ref18 = (_resolvedOrganCapacit = resolvedOrganCapacities.find(_ref20 => {
+    var _ref21 = _slicedToArray(_ref20, 1),
+        organ = _ref21[0];
+
+    return organ === "spleen item";
+  })) !== null && _resolvedOrganCapacit !== void 0 ? _resolvedOrganCapacit : ["spleen item", 0],
+      _ref19 = _slicedToArray(_ref18, 2),
+      availableSpleen = _ref19[1];
+
+  var _dietPlanner$planOrga3 = dietPlanner.planOrgan("spleen item", availableSpleen + additionalSpleen),
+      _dietPlanner$planOrga4 = _slicedToArray(_dietPlanner$planOrga3, 2),
+      planSpleen = _dietPlanner$planOrga4[1];
+
+  return [].concat(_toConsumableArray(planFoodBooze), _toConsumableArray(planSpleen));
+}

package/dist/diet/knapsack.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Solve the knapsack problem.
+ * @param values Array of {[item, value, weight, maximum]} tuples for knapsack parameter.
+ * @param capacity Capacity of knapsack.
+ * @returns Tuple {[totalValue, items]} of selected items and total value of those items.
+ */
+export declare function knapsack<T>(values: [T, number, number, number?][], capacity: number): [number, T[]];

package/dist/diet/knapsack.js

@@ -0,0 +1,116 @@
+"use strict";
+
+require("core-js/modules/es.symbol.js");
+
+require("core-js/modules/es.symbol.description.js");
+
+require("core-js/modules/es.object.to-string.js");
+
+require("core-js/modules/es.array.iterator.js");
+
+require("core-js/modules/es.array.slice.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.knapsack = knapsack;
+
+require("core-js/modules/es.array.sort.js");
+
+require("core-js/modules/es.array.concat.js");
+
+require("core-js/modules/es.array.map.js");
+
+require("core-js/modules/es.array.fill.js");
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+/**
+ * Solve the knapsack problem.
+ * @param values Array of {[item, value, weight, maximum]} tuples for knapsack parameter.
+ * @param capacity Capacity of knapsack.
+ * @returns Tuple {[totalValue, items]} of selected items and total value of those items.
+ */
+function knapsack(values, capacity) {
+  var _ref;
+
+  // Sort values by weight.
+  var valuesSorted = _toConsumableArray(values).sort((x, y) => x[2] - y[2]); // Convert the problem into 0/1 knapsack - just include as many copies as possible of each item.
+
+
+  var values01 = (_ref = []).concat.apply(_ref, _toConsumableArray(valuesSorted.map(_ref2 => {
+    var _ref3 = _slicedToArray(_ref2, 4),
+        thing = _ref3[0],
+        value = _ref3[1],
+        weight = _ref3[2],
+        maximum = _ref3[3];
+
+    var maxQuantity = maximum !== null && maximum !== void 0 ? maximum : Math.floor(capacity / weight);
+    return new Array(maxQuantity).fill([thing, value, weight]);
+  })));
+
+  var memoizationTable = new Array(values01.length);
+
+  for (var i = 0; i < values01.length; i++) {
+    memoizationTable[i] = new Array(capacity).fill(null);
+  }
+
+  return bestSolution(memoizationTable, values01, values01.length - 1, capacity);
+}
+/**
+ * Find the best solution to a knapsack subproblem.
+ * @param memoizationTable Memoization table for dynamic programming approach.
+ * @param values Array of {[item, value, weight, maximum]} tuples for knapsack parameter.
+ * @param currentIndex Current index into values array - only add items before this index.
+ * @param remainingCapacity Remaining capacity of knapsack.
+ * @returns
+ */
+
+
+function bestSolution(memoizationTable, values, currentIndex, remainingCapacity) {
+  // If we've used all our capacity, this solution is no good.
+  if (remainingCapacity < 0) return [-Infinity, []];
+  if (remainingCapacity === 0 || currentIndex < 0) return [0, []];
+  var memoized = memoizationTable[currentIndex][remainingCapacity - 1];
+  if (memoized !== null) return memoized;
+
+  var _values$currentIndex = _slicedToArray(values[currentIndex], 3),
+      item = _values$currentIndex[0],
+      value = _values$currentIndex[1],
+      weight = _values$currentIndex[2];
+
+  var _bestSolution = bestSolution(memoizationTable, values, currentIndex - 1, remainingCapacity - weight),
+      _bestSolution2 = _slicedToArray(_bestSolution, 2),
+      valueIncludeRest = _bestSolution2[0],
+      itemsInclude = _bestSolution2[1];
+
+  var valueInclude = valueIncludeRest + value;
+
+  var _bestSolution3 = bestSolution(memoizationTable, values, currentIndex - 1, remainingCapacity),
+      _bestSolution4 = _slicedToArray(_bestSolution3, 2),
+      valueExclude = _bestSolution4[0],
+      itemsExclude = _bestSolution4[1]; // Pick the better of the two options between including/excluding.
+
+
+  var result = valueInclude > valueExclude ? [valueInclude, [].concat(_toConsumableArray(itemsInclude), [item])] : [valueExclude, itemsExclude];
+  memoizationTable[currentIndex][remainingCapacity - 1] = result;
+  return result;
+}

package/dist/lib.d.ts

@@ -222,6 +222,12 @@ export declare type Player = {
  * @returns Object containing id and name of player
  */
 export declare function getPlayerFromIdOrName(idOrName: number | string): Player;
+/**
+ * Return the step as a number for a given quest property.
+ *
+ * @param questName Name of quest property to check.
+ */
+export declare function questStep(questName: string): number;
 export declare class EnsureError extends Error {
     constructor(cause: Item | Familiar | Effect);
 }
@@ -243,3 +249,17 @@ export declare const Environment: {
     readonly Underwater: "underwater";
 };
 export declare type EnvironmentType = typeof Environment[keyof typeof Environment];
+/**
+ * Returns the weight-coefficient of any leprechaunning that this familiar may find itself doing
+ * Assumes the familiar is nude and thus fails for hatrack & pantsrack
+ * For the Mutant Cactus Bud, returns the efficacy-multiplier instead
+ * @param familiar The familiar whose leprechaun multiplier you're interested in
+ */
+export declare function findLeprechaunMultiplier(familiar: Familiar): number;
+/**
+ * Returns the weight-coefficient of any baby gravy fairying that this familiar may find itself doing
+ * Assumes the familiar is nude and thus fails for hatrack & pantsrack
+ * For the Mutant Fire Ant, returns the efficacy-multiplier instead
+ * @param familiar The familiar whose fairy multiplier you're interested in
+ */
+export declare function findFairyMultiplier(familiar: Familiar): number;