libram 0.8.28 → 0.8.30

package/dist/resources/2011/StompingBoots.js

@@ -0,0 +1,57 @@
+import { familiarWeight, useFamiliar, weightAdjustment } from "kolmafia";
+import { have as _have, isCurrentFamiliar } from "../../lib";
+import { get } from "../../property";
+import { $familiar } from "../../template-string";
+const familiar = $familiar `Pair of Stomping Boots`;
+/**
+ * @returns whether the player has the Pair of Stomping Boots in their terrarium
+ */
+export function have() {
+    return _have(familiar);
+}
+/**
+ * @returns number of free runaways that have already been used today
+ * @see Bandersnatch with which the Stomping Boots shares a counter
+ */
+export function getRunaways() {
+    return get("_banderRunaways");
+}
+/**
+ * @param considerWeightAdjustment Include familiar weight modifiers
+ * @returns total number of free runaways that the player can get from their Stomping Boots
+ */
+export function getMaxRunaways(considerWeightAdjustment = true) {
+    const weightBuffs = considerWeightAdjustment ? weightAdjustment() : 0;
+    return Math.floor((familiarWeight(familiar) + weightBuffs) / 5);
+}
+/**
+ * @param considerWeightAdjustment Whether to consider weight adjustment in free run calculation
+ * @returns the number of remaining free runaways the player can get from their Stomping Boots
+ */
+export function getRemainingRunaways(considerWeightAdjustment = true) {
+    return Math.max(0, getMaxRunaways(considerWeightAdjustment) - getRunaways());
+}
+/**
+ * @param considerWeightAdjustment Include familiar weight modifiers
+ * @returns whether the player could use their Stomping Boots to get a free run in theory
+ */
+export function couldRunaway(considerWeightAdjustment = true) {
+    return have() && getRemainingRunaways(considerWeightAdjustment) > 0;
+}
+/**
+ * @returns whether the player can use their Stomping Boots to get a free run right now
+ */
+export function canRunaway() {
+    return isCurrentFamiliar(familiar) && couldRunaway();
+}
+/**
+ * Prepare a Stomping Boots runaway.
+ *
+ * This will take your Stomping Boots with you.
+ * If any of those steps fail, it will return false.
+ *
+ * @returns Success
+ */
+export function prepareRunaway() {
+    return useFamiliar(familiar);
+}

package/dist/resources/2012/RainDoh.d.ts

@@ -0,0 +1,25 @@
+import { Monster } from "kolmafia";
+/**
+ * See whether the player has a Rain-Doh item in some form
+ *
+ * @returns Whether the player has any Rain-Doh item
+ */
+export declare function have(): boolean;
+/**
+ * Get Rain-Doh black box copies made today
+ *
+ * @returns Number of Rain-Doh black box copies made
+ */
+export declare function getRainDohBlackBoxCopiesMade(): number;
+/**
+ * Get the current Rain-doh box monster
+ *
+ * @returns Current Rain-doh box monster
+ */
+export declare function getRainDohBlackBoxMonster(): Monster | null;
+/**
+ * Use the Rain-Doh box full of monster (i.e. fight the monster probably)
+ *
+ * @returns Success
+ */
+export declare function useRainDohBlackBox(): boolean;

package/dist/resources/2012/RainDoh.js

@@ -0,0 +1,37 @@
+import { use } from "kolmafia";
+import { getFoldGroup, have as haveItem } from "../../lib";
+import { get } from "../../property";
+import { $item } from "../../template-string";
+const box = $item `Rain-Doh black box`;
+/**
+ * See whether the player has a Rain-Doh item in some form
+ *
+ * @returns Whether the player has any Rain-Doh item
+ */
+export function have() {
+    return getFoldGroup(box).some((item) => haveItem(item));
+}
+/**
+ * Get Rain-Doh black box copies made today
+ *
+ * @returns Number of Rain-Doh black box copies made
+ */
+export function getRainDohBlackBoxCopiesMade() {
+    return Math.max(0, get("_raindohCopiesMade"));
+}
+/**
+ * Get the current Rain-doh box monster
+ *
+ * @returns Current Rain-doh box monster
+ */
+export function getRainDohBlackBoxMonster() {
+    return get("rainDohMonster");
+}
+/**
+ * Use the Rain-Doh box full of monster (i.e. fight the monster probably)
+ *
+ * @returns Success
+ */
+export function useRainDohBlackBox() {
+    return use(box);
+}

package/dist/resources/2012/ReagnimatedGnome.d.ts

@@ -0,0 +1,31 @@
+import { Item } from "kolmafia";
+/**
+ * @returns Whether the player has a Reagnimated Gnome in their terrarium
+ */
+export declare function have(): boolean;
+export declare const bodyParts: {
+    readonly ears: Item;
+    readonly lung: Item;
+    readonly elbow: Item;
+    readonly kgnee: Item;
+    readonly foot: Item;
+};
+export declare type BodyPart = keyof typeof bodyParts;
+/**
+ * @returns Reagnimated Gnome parts that have already been retrieved from the arena
+ */
+export declare function chosenParts(): Item[];
+/**
+ * Fetch Reagnimated Gnome part from the arena
+ *
+ * @param part Reagnimated Gnome body part
+ * @returns Success
+ */
+export declare function choosePart(part: BodyPart): boolean;
+/**
+ * Calculate expected adventures from a given combat for a Reagnimated Gnome at a given weight
+ *
+ * @param weight Weight with which to calculuate
+ * @returns Expected adventures
+ */
+export declare function expectedAdvsPerCombat(weight: number): number;

package/dist/resources/2012/ReagnimatedGnome.js

@@ -0,0 +1,46 @@
+import { runChoice, visitUrl } from "kolmafia";
+import { have as _have } from "../../lib";
+import { $familiar, $item } from "../../template-string";
+/**
+ * @returns Whether the player has a Reagnimated Gnome in their terrarium
+ */
+export function have() {
+    return _have($familiar `Reagnimated Gnome`);
+}
+export const bodyParts = {
+    ears: $item `gnomish swimmer's ears`,
+    lung: $item `gnomish coal miner's lung`,
+    elbow: $item `gnomish tennis elbow`,
+    kgnee: $item `gnomish housemaid's kgnee`,
+    foot: $item `gnomish athlete's foot`,
+};
+/**
+ * @returns Reagnimated Gnome parts that have already been retrieved from the arena
+ */
+export function chosenParts() {
+    return Object.values(bodyParts).filter((part) => _have(part));
+}
+/**
+ * Fetch Reagnimated Gnome part from the arena
+ *
+ * @param part Reagnimated Gnome body part
+ * @returns Success
+ */
+export function choosePart(part) {
+    if (!have())
+        return false;
+    if (_have(bodyParts[part]))
+        return true;
+    visitUrl("arena.php");
+    runChoice(4);
+    return chosenParts().includes(bodyParts[part]);
+}
+/**
+ * Calculate expected adventures from a given combat for a Reagnimated Gnome at a given weight
+ *
+ * @param weight Weight with which to calculuate
+ * @returns Expected adventures
+ */
+export function expectedAdvsPerCombat(weight) {
+    return Math.min(0.01 + (weight / 1000) * 0.99, 1);
+}

package/dist/resources/2012/Resolutions.d.ts

@@ -0,0 +1,9 @@
+import { Item } from "kolmafia";
+/**
+ * @returns Whether the player can Summon Resolutions
+ */
+export declare function have(): boolean;
+/**
+ * @returns Map containing the chance of an item to be summoned
+ */
+export declare function expected(): Map<Item, number>;

package/dist/resources/2012/Resolutions.js

@@ -0,0 +1,28 @@
+import { have as _have } from "../../lib";
+import { $item, $skill } from "../../template-string";
+const summonSkill = $skill `Summon Resolutions`;
+const commonChance = 0.98 / 6;
+const rareChance = 0.02 / 3;
+const libramExpected = new Map([
+    [$item `resolution: be feistier`, commonChance],
+    [$item `resolution: be happier`, commonChance],
+    [$item `resolution: be sexier`, commonChance],
+    [$item `resolution: be smarter`, commonChance],
+    [$item `resolution: be stronger`, commonChance],
+    [$item `resolution: be wealthier`, commonChance],
+    [$item `resolution: be kinder`, rareChance],
+    [$item `resolution: be luckier`, rareChance],
+    [$item `resolution: be more adventurous`, rareChance],
+]);
+/**
+ * @returns Whether the player can Summon Resolutions
+ */
+export function have() {
+    return _have(summonSkill);
+}
+/**
+ * @returns Map containing the chance of an item to be summoned
+ */
+export function expected() {
+    return libramExpected;
+}

package/dist/resources/2013/Florist.d.ts

@@ -0,0 +1,81 @@
+import { Location } from "kolmafia";
+import { EnvironmentType } from "../../lib";
+import { Modifiers } from "../../modifier";
+declare type SpecialFlowerAbility = "Delevels Enemy" | "Blocks Attacks" | "Poison";
+declare class Flower {
+    name: string;
+    id: number;
+    environment: EnvironmentType;
+    modifier: Modifiers | SpecialFlowerAbility;
+    territorial: boolean;
+    constructor(name: string, id: number, environment: EnvironmentType, modifier: Modifiers | SpecialFlowerAbility, territorial?: boolean);
+    private static visit;
+    static plantNamesInZone(location?: Location): string[];
+    static plantsInZone(location?: Location): Flower[];
+    static modifiersInZone(location?: Location): Modifiers;
+    isPlantedHere(location?: Location): boolean;
+    available(location?: Location): boolean;
+    dig(): boolean;
+    plant(): boolean;
+}
+/**
+ * @returns Whether or not the Florist is currently available
+ */
+export declare function have(): boolean;
+/**
+ * @param location The location to check
+ * @returns an array of the Flowers in that location
+ */
+export declare function flowersIn(location: Location): Flower[];
+/**
+ * @param location The location to check
+ * @returns an array of the Flowers we can plant in that location
+ */
+export declare function flowersAvailableFor(location?: Location): Flower[];
+/**
+ * @param location The location to check
+ * @returns `true` if the location has 3 flowers in it; `false` otherwise
+ */
+export declare function isFull(location?: Location): boolean;
+export declare const RabidDogwood: Flower;
+export declare const Rutabeggar: Flower;
+export declare const RadishRadish: Flower;
+export declare const Artichoker: Flower;
+export declare const SmokeRa: Flower;
+export declare const SkunkCabbage: Flower;
+export declare const DeadlyCinnamon: Flower;
+export declare const CeleryStalker: Flower;
+export declare const LettuceSpray: Flower;
+export declare const SeltzerWatercress: Flower;
+export declare const WarLily: Flower;
+export declare const StealingMagnolia: Flower;
+export declare const CannedSpinach: Flower;
+export declare const Impatiens: Flower;
+export declare const SpiderPlant: Flower;
+export declare const RedFern: Flower;
+export declare const BamBoo: Flower;
+export declare const ArcticMoss: Flower;
+export declare const AloeGuvnor: Flower;
+export declare const PitcherPlant: Flower;
+export declare const BlusteryPuffball: Flower;
+export declare const HornOfPlenty: Flower;
+export declare const WizardsWig: Flower;
+export declare const ShuffleTruffle: Flower;
+export declare const DisLichen: Flower;
+export declare const LooseMorels: Flower;
+export declare const FoulToadstool: Flower;
+export declare const Chillterelle: Flower;
+export declare const Portlybella: Flower;
+export declare const MaxHeadshroom: Flower;
+export declare const Spankton: Flower;
+export declare const Kelptomaniac: Flower;
+export declare const Crookweed: Flower;
+export declare const ElectricEelgrass: Flower;
+export declare const Duckweed: Flower;
+export declare const OrcaOrchid: Flower;
+export declare const Sargassum: Flower;
+export declare const SubSeaRose: Flower;
+export declare const Snori: Flower;
+export declare const UpSeaDaisy: Flower;
+export declare const all: readonly Flower[];
+export {};

package/dist/resources/2013/Florist.js

@@ -0,0 +1,245 @@
+import { floristAvailable, getFloristPlants, runChoice, visitUrl, } from "kolmafia";
+import { mergeModifiers } from "../../modifier";
+import { get } from "../../property";
+import { $location } from "../../template-string";
+import { notNull } from "../../utils";
+class Flower {
+    name;
+    id;
+    environment;
+    modifier;
+    territorial;
+    constructor(name, id, environment, modifier, territorial = false) {
+        this.name = name;
+        this.id = id;
+        this.environment = environment;
+        this.modifier = modifier;
+        this.territorial = territorial;
+    }
+    static visit() {
+        visitUrl("place.php?whichplace=forestvillage&action=fv_friar");
+    }
+    static plantNamesInZone(location = get("lastAdventure") ?? $location.none) {
+        return getFloristPlants()[location.toString()] ?? [];
+    }
+    static plantsInZone(location = get("lastAdventure") ?? $location.none) {
+        return this.plantNamesInZone(location)
+            .map((flowerName) => toFlower(flowerName))
+            .filter(notNull);
+    }
+    static modifiersInZone(location = get("lastAdventure") ?? $location.none) {
+        const plants = this.plantsInZone(location);
+        if (!plants)
+            return {};
+        const modifiers = plants
+            .map((plant) => plant.modifier)
+            .map((modifier) => (typeof modifier === "string" ? {} : modifier));
+        return mergeModifiers(...modifiers);
+    }
+    isPlantedHere(location = get("lastAdventure") ?? $location.none) {
+        const plantedHere = Flower.plantNamesInZone(location)?.includes(this.name);
+        return plantedHere !== undefined && plantedHere;
+    }
+    available(location = get("lastAdventure") ?? $location.none) {
+        return (this.environment === location.environment &&
+            !get("_floristPlantsUsed").includes(this.name) &&
+            !this.isPlantedHere(location));
+    }
+    dig() {
+        if (!this.isPlantedHere())
+            return false;
+        const flowers = Flower.plantNamesInZone();
+        if (!flowers[2])
+            return false;
+        const plantNumber = flowers.indexOf(this.name);
+        Flower.visit();
+        runChoice(2, `plnti=${plantNumber}`);
+        return !this.isPlantedHere();
+    }
+    plant() {
+        if (this.isPlantedHere())
+            return true;
+        if (isFull())
+            return false;
+        Flower.visit();
+        runChoice(1, `plant=${this.id}`);
+        return this.isPlantedHere();
+    }
+}
+/**
+ * @returns Whether or not the Florist is currently available
+ */
+export function have() {
+    return floristAvailable();
+}
+/**
+ * Internal function used to convert strings to Flower instances
+ *
+ * @param name The flower name
+ * @returns a Flower instance
+ */
+function toFlower(name) {
+    return all.find((flower) => name === flower.name) ?? null;
+}
+/**
+ * @param location The location to check
+ * @returns an array of the Flowers in that location
+ */
+export function flowersIn(location) {
+    const returnValue = [];
+    Flower.plantNamesInZone(location)
+        .map(toFlower)
+        .forEach((flower) => {
+        if (flower)
+            returnValue.push(flower);
+    });
+    return returnValue;
+}
+/**
+ * @param location The location to check
+ * @returns an array of the Flowers we can plant in that location
+ */
+export function flowersAvailableFor(location = get("lastAdventure") ?? $location.none) {
+    return all.filter((flower) => flower.available(location));
+}
+/**
+ * @param location The location to check
+ * @returns `true` if the location has 3 flowers in it; `false` otherwise
+ */
+export function isFull(location = get("lastAdventure") ?? $location.none) {
+    return flowersIn(location).length === 3;
+}
+export const RabidDogwood = new Flower("Rabid Dogwood", 1, "outdoor", {
+    "Monster Level": 30,
+}, true);
+export const Rutabeggar = new Flower("Rutabeggar", 2, "outdoor", {
+    "Item Drop": 25,
+}, true);
+export const RadishRadish = new Flower("Rad-ish Radish", 3, "outdoor", { "Moxie Experience": 5 }, true);
+export const Artichoker = new Flower("Artichoker", 4, "outdoor", "Delevels Enemy");
+export const SmokeRa = new Flower("Smoke-ra", 5, "outdoor", "Blocks Attacks");
+export const SkunkCabbage = new Flower("Skunk Cabbage", 6, "outdoor", {
+    "Stench Damage": 12.5,
+});
+export const DeadlyCinnamon = new Flower("Deadly Cinnamon", 7, "outdoor", {
+    "Hot Damage": 12.5,
+});
+export const CeleryStalker = new Flower("Celery Stalker", 8, "outdoor", {
+    "Spooky Damage": 12.5,
+});
+export const LettuceSpray = new Flower("Lettus Spray", 9, "outdoor", {
+    "HP Regen Min": 10,
+    "HP Regen Max": 29,
+});
+export const SeltzerWatercress = new Flower("Seltzer Watercress", 10, "outdoor", { "MP Regen Min": 5, "MP Regen Max": 15 });
+export const WarLily = new Flower("War Lily", 11, "indoor", { "Monster Level": 30 }, true);
+export const StealingMagnolia = new Flower("Stealing Magnolia", 12, "indoor", { "Item Drop": 25 }, true);
+export const CannedSpinach = new Flower("Canned Spinach", 13, "indoor", { "Muscle Experience": 5 }, true);
+export const Impatiens = new Flower("Impatiens", 14, "indoor", {
+    Initiative: 25,
+});
+export const SpiderPlant = new Flower("Spider Plant", 15, "indoor", "Poison");
+export const RedFern = new Flower("Red Fern", 16, "indoor", "Delevels Enemy");
+export const BamBoo = new Flower("BamBOO!", 17, "indoor", {
+    "Spooky Damage": 12.5,
+});
+export const ArcticMoss = new Flower("Arctic Moss", 18, "indoor", {
+    "Cold Damage": 12.5,
+});
+export const AloeGuvnor = new Flower("Aloe Guv'nor", 19, "indoor", {
+    "HP Regen Min": 10,
+    "HP Regen Max": 30,
+});
+export const PitcherPlant = new Flower("Pitcher Plant", 20, "indoor", {
+    "MP Regen Min": 5,
+    "MP Regen Max": 15,
+});
+export const BlusteryPuffball = new Flower("Blustery Puffball", 21, "underground", { "Monster Level": 30 }, true);
+export const HornOfPlenty = new Flower("Horn of Plenty", 22, "underground", { "Item Drop": 25 }, true);
+export const WizardsWig = new Flower("Wizard's Wig", 23, "underground", { "Mysticality Experience": 5 }, true);
+export const ShuffleTruffle = new Flower("Shuffle Truffle", 24, "underground", {
+    Initiative: 25,
+});
+export const DisLichen = new Flower("Dis Lichen", 25, "underground", "Delevels Enemy");
+export const LooseMorels = new Flower("Loose Morels", 26, "underground", {
+    "Sleaze Damage": 12.5,
+});
+export const FoulToadstool = new Flower("Foul Toadstool", 27, "underground", {
+    "Stench Damage": 12.5,
+});
+export const Chillterelle = new Flower("Chillterelle", 28, "underground", {
+    "Cold Damage": 12.5,
+});
+export const Portlybella = new Flower("Portlybella", 29, "underground", {
+    "HP Regen Min": 10,
+    "HP Regen Max": 30,
+});
+export const MaxHeadshroom = new Flower("Max Headshroom", 30, "underground", {
+    "MP Regen Min": 5,
+    "MP Regen Max": 15,
+});
+export const Spankton = new Flower("Spankton", 31, "underwater", "Delevels Enemy", true);
+export const Kelptomaniac = new Flower("Kelptomaniac", 32, "underwater", { "Item Drop": 40 }, true);
+export const Crookweed = new Flower("Crookweed", 33, "underwater", { "Meat Drop": 60 }, true);
+export const ElectricEelgrass = new Flower("Electric Eelgrass", 34, "underwater", "Blocks Attacks");
+export const Duckweed = new Flower("Duckweed", 35, "underwater", "Blocks Attacks");
+export const OrcaOrchid = new Flower("Orca Orchid", 36, "underwater", {
+    "Weapon Damage": 12.5,
+});
+export const Sargassum = new Flower("Sargassum", 37, "underwater", {
+    "Stench Damage": 12.5,
+});
+export const SubSeaRose = new Flower("Sub-Sea Rose", 38, "underwater", {
+    "Cold Damage": 12.5,
+});
+export const Snori = new Flower("Snori", 39, "underwater", {
+    "HP Regen Min": 20,
+    "HP Regen Max": 30,
+    "MP Regen Min": 10,
+    "MP Regen Max": 20,
+});
+export const UpSeaDaisy = new Flower("Up Sea Daisy", 40, "underwater", {
+    Experience: 30,
+});
+export const all = Object.freeze([
+    RabidDogwood,
+    Rutabeggar,
+    RadishRadish,
+    Artichoker,
+    SmokeRa,
+    SkunkCabbage,
+    DeadlyCinnamon,
+    CeleryStalker,
+    LettuceSpray,
+    SeltzerWatercress,
+    WarLily,
+    StealingMagnolia,
+    CannedSpinach,
+    Impatiens,
+    SpiderPlant,
+    RedFern,
+    BamBoo,
+    ArcticMoss,
+    AloeGuvnor,
+    PitcherPlant,
+    BlusteryPuffball,
+    HornOfPlenty,
+    WizardsWig,
+    ShuffleTruffle,
+    DisLichen,
+    LooseMorels,
+    FoulToadstool,
+    Chillterelle,
+    Portlybella,
+    MaxHeadshroom,
+    Spankton,
+    Kelptomaniac,
+    Crookweed,
+    ElectricEelgrass,
+    Duckweed,
+    OrcaOrchid,
+    Sargassum,
+    SubSeaRose,
+    Snori,
+    UpSeaDaisy,
+]);

package/dist/resources/2013/JungMan.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @returns Whether we `have` the Jung Man
+ */
+export declare function have(): boolean;
+export declare enum Jar {
+    SUSPICIOUS_GUY = "susguy",
+    GOURD_CAPTAIN = "gourdcaptain",
+    CRACKPOT_MYSTIC = "mystic",
+    OLD_MAN = "oldman",
+    PRETENTIOUS_ARTIST = "artist",
+    MEATSMITH = "meatsmith",
+    JICK = "jick"
+}
+export declare const JAR_ITEMS: {
+    susguy: import("kolmafia").Item;
+    gourdcaptain: import("kolmafia").Item;
+    mystic: import("kolmafia").Item;
+    oldman: import("kolmafia").Item;
+    artist: import("kolmafia").Item;
+    meatsmith: import("kolmafia").Item;
+    jick: import("kolmafia").Item;
+};
+/**
+ * @returns Whether we can currently make a Jick jar
+ */
+export declare function canJickJar(): boolean;
+/**
+ * Tries to make a psychoanalytic jar with the chosen target
+ *
+ * @param jar The character of Loathing to psychoanalyze
+ * @returns Whether we successfully crafted the jar
+ */
+export declare function makeJar(jar: Jar): boolean;

package/dist/resources/2013/JungMan.js

@@ -0,0 +1,69 @@
+import { haveFamiliar, visitUrl } from "kolmafia";
+import { get } from "../../property";
+import { $familiar, $item } from "../../template-string";
+const familiar = $familiar `Angry Jung Man`;
+/**
+ * @returns Whether we `have` the Jung Man
+ */
+export function have() {
+    return haveFamiliar(familiar);
+}
+export var Jar;
+(function (Jar) {
+    Jar["SUSPICIOUS_GUY"] = "susguy";
+    Jar["GOURD_CAPTAIN"] = "gourdcaptain";
+    Jar["CRACKPOT_MYSTIC"] = "mystic";
+    Jar["OLD_MAN"] = "oldman";
+    Jar["PRETENTIOUS_ARTIST"] = "artist";
+    Jar["MEATSMITH"] = "meatsmith";
+    Jar["JICK"] = "jick";
+})(Jar || (Jar = {}));
+const PLACES = {
+    [Jar.PRETENTIOUS_ARTIST]: ["place", "town_wrong"],
+    [Jar.GOURD_CAPTAIN]: ["place", "town_right"],
+    [Jar.CRACKPOT_MYSTIC]: ["shop", "mystic"],
+    [Jar.OLD_MAN]: ["place", "sea_oldman"],
+    [Jar.MEATSMITH]: ["shop", "meatsmith"],
+    [Jar.JICK]: ["showplayer", "1"],
+    [Jar.SUSPICIOUS_GUY]: ["tavern"],
+};
+export const JAR_ITEMS = {
+    [Jar.SUSPICIOUS_GUY]: $item `jar of psychoses (The Suspicious-Looking Guy)`,
+    [Jar.GOURD_CAPTAIN]: $item `jar of psychoses (The Captain of the Gourd)`,
+    [Jar.CRACKPOT_MYSTIC]: $item `jar of psychoses (The Crackpot Mystic)`,
+    [Jar.OLD_MAN]: $item `jar of psychoses (The Old Man)`,
+    [Jar.PRETENTIOUS_ARTIST]: $item `jar of psychoses (The Pretentious Artist)`,
+    [Jar.MEATSMITH]: $item `jar of psychoses (The Meatsmith)`,
+    [Jar.JICK]: $item `jar of psychoses (Jick)`,
+};
+function getJungUrl(jar) {
+    const [page, answer] = PLACES[jar];
+    const question = page === "showplayer" ? "who" : `which${page}`;
+    const params = [
+        ["action", "jung"],
+        ["whichperson", jar],
+    ];
+    if (answer)
+        params.push([question, answer]);
+    return `${page}.php?${params.map((pair) => pair.join("=")).join("&")}`;
+}
+/**
+ * @returns Whether we can currently make a Jick jar
+ */
+export function canJickJar() {
+    if (get("_jickJarAvailable") === "unknown")
+        visitUrl("showplayer.php?who=1");
+    return get("_jickJarAvailable") === "true" && !get("_psychoJarFilled");
+}
+/**
+ * Tries to make a psychoanalytic jar with the chosen target
+ *
+ * @param jar The character of Loathing to psychoanalyze
+ * @returns Whether we successfully crafted the jar
+ */
+export function makeJar(jar) {
+    if (jar === Jar.JICK && !canJickJar())
+        return false;
+    const result = visitUrl(getJungUrl(jar));
+    return result.includes("You open up the jar and look into the patient's eyes.");
+}

package/dist/resources/2013/PulledTaffy.d.ts

@@ -0,0 +1,9 @@
+import { Item } from "kolmafia";
+/**
+ * @returns true if the player can Summon Taffy
+ */
+export declare function have(): boolean;
+/**
+ * @returns map containing the chance of an item to be summoned
+ */
+export declare function expected(): Map<Item, number>;