landlord-ts 1.0.2

package/dist/chunk-I6ETCO5F.js

@@ -0,0 +1,803 @@
+// src/card/mana-cost.ts
+var R_BITS = 1;
+var G_BITS = 2;
+var B_BITS = 4;
+var U_BITS = 8;
+var W_BITS = 16;
+var C_BITS = 32;
+function emptyManaCost() {
+  return { bits: 0, r: 0, w: 0, b: 0, u: 0, g: 0, c: 0 };
+}
+function manaCostFromRgbuwc(r, g, b, u, w, c) {
+  return {
+    bits: calculateSignature(r, g, b, u, w, c),
+    r,
+    w,
+    b,
+    u,
+    g,
+    c
+  };
+}
+function manaCostCmc(cost) {
+  return cost.r + cost.w + cost.b + cost.u + cost.g + cost.c;
+}
+function updateManaCostBits(cost) {
+  return {
+    ...cost,
+    bits: calculateSignature(cost.r, cost.g, cost.b, cost.u, cost.w, cost.c)
+  };
+}
+function calculateSignature(r, g, b, u, w, c) {
+  return Math.min(1, r) << 0 & R_BITS | Math.min(1, g) << 1 & G_BITS | Math.min(1, b) << 2 & B_BITS | Math.min(1, u) << 3 & U_BITS | Math.min(1, w) << 4 & W_BITS | Math.min(1, c) << 5 & C_BITS;
+}
+function manaColorFromStr(color) {
+  switch (color.charAt(0)) {
+    case "B":
+      return 2 /* Black */;
+    case "U":
+      return 3 /* Blue */;
+    case "G":
+      return 1 /* Green */;
+    case "R":
+      return 0 /* Red */;
+    case "W":
+      return 4 /* White */;
+    default:
+      return 5 /* Colorless */;
+  }
+}
+function applyColor(cost, color, count) {
+  switch (color) {
+    case 2 /* Black */:
+      cost.b += count;
+      break;
+    case 3 /* Blue */:
+      cost.u += count;
+      break;
+    case 1 /* Green */:
+      cost.g += count;
+      break;
+    case 0 /* Red */:
+      cost.r += count;
+      break;
+    case 4 /* White */:
+      cost.w += count;
+      break;
+    case 5 /* Colorless */:
+      cost.c += count;
+      break;
+  }
+}
+function manaCostKey(cost) {
+  return `${cost.r},${cost.g},${cost.b},${cost.u},${cost.w},${cost.c},${cost.bits}`;
+}
+function compareManaCost(a, b) {
+  if (a.bits !== b.bits) return a.bits - b.bits;
+  if (a.r !== b.r) return a.r - b.r;
+  if (a.w !== b.w) return a.w - b.w;
+  if (a.b !== b.b) return a.b - b.b;
+  if (a.u !== b.u) return a.u - b.u;
+  if (a.g !== b.g) return a.g - b.g;
+  return a.c - b.c;
+}
+function manaCostsFromStr(manaCostStr) {
+  const symbolStack = manaCostSymbolsFromStr(manaCostStr);
+  const results = /* @__PURE__ */ new Map();
+  manaCostsFromStrRecur(results, emptyManaCost(), symbolStack, 0);
+  return [...results.values()].sort(compareManaCost);
+}
+function manaCostsFromStrRecur(results, current, symbolStack, idx) {
+  if (symbolStack.length <= idx) {
+    const updated = updateManaCostBits(current);
+    results.set(manaCostKey(updated), updated);
+    return;
+  }
+  const [leftSym, rightSym] = symbolStack[idx];
+  const left = {
+    bits: 0,
+    r: leftSym.r + current.r,
+    g: leftSym.g + current.g,
+    b: leftSym.b + current.b,
+    u: leftSym.u + current.u,
+    w: leftSym.w + current.w,
+    c: leftSym.c + current.c
+  };
+  manaCostsFromStrRecur(results, left, symbolStack, idx + 1);
+  if (rightSym) {
+    const right = {
+      bits: 0,
+      r: rightSym.r + current.r,
+      g: rightSym.g + current.g,
+      b: rightSym.b + current.b,
+      u: rightSym.u + current.u,
+      w: rightSym.w + current.w,
+      c: rightSym.c + current.c
+    };
+    manaCostsFromStrRecur(results, right, symbolStack, idx + 1);
+  }
+}
+function manaCostSymbolsFromStr(manaCostStr) {
+  let sigil = "";
+  const symbolStack = [];
+  let shouldPushRight = false;
+  let idx = 0;
+  for (const ch of manaCostStr) {
+    switch (ch) {
+      case "{": {
+        sigil = "";
+        symbolStack.push([emptyManaCost(), null]);
+        idx = symbolStack.length - 1;
+        shouldPushRight = false;
+        break;
+      }
+      case "/":
+      case "\\": {
+        const color = manaColorFromStr(sigil);
+        const count = Number.parseInt(sigil, 10);
+        const n = Number.isFinite(count) ? count : 1;
+        const cost = emptyManaCost();
+        applyColor(cost, color, n);
+        symbolStack[idx][0] = cost;
+        shouldPushRight = true;
+        sigil = "";
+        break;
+      }
+      case "}": {
+        const color = manaColorFromStr(sigil);
+        const count = Number.parseInt(sigil, 10);
+        const n = Number.isFinite(count) ? count : 1;
+        const cost = emptyManaCost();
+        applyColor(cost, color, n);
+        if (shouldPushRight) {
+          symbolStack[idx][1] = cost;
+        } else {
+          symbolStack[idx][0] = cost;
+        }
+        sigil = "";
+        break;
+      }
+      default:
+        sigil += ch;
+        break;
+    }
+  }
+  return symbolStack;
+}
+
+// src/card/types.ts
+var CardKind = /* @__PURE__ */ ((CardKind2) => {
+  CardKind2["BasicLand"] = "BasicLand";
+  CardKind2["TapLand"] = "TapLand";
+  CardKind2["CheckLand"] = "CheckLand";
+  CardKind2["ShockLand"] = "ShockLand";
+  CardKind2["FastLand"] = "FastLand";
+  CardKind2["SlowLand"] = "SlowLand";
+  CardKind2["BattleLand"] = "BattleLand";
+  CardKind2["TurnLand"] = "TurnLand";
+  CardKind2["SurveilLand"] = "SurveilLand";
+  CardKind2["BounceLand"] = "BounceLand";
+  CardKind2["TriomeLand"] = "TriomeLand";
+  CardKind2["CyclingLand"] = "CyclingLand";
+  CardKind2["PainLand"] = "PainLand";
+  CardKind2["FetchLand"] = "FetchLand";
+  CardKind2["CanopyLand"] = "CanopyLand";
+  CardKind2["PathwayLand"] = "PathwayLand";
+  CardKind2["OtherLand"] = "OtherLand";
+  CardKind2["ForcedLand"] = "ForcedLand";
+  CardKind2["Creature"] = "Creature";
+  CardKind2["Spell"] = "Spell";
+  CardKind2["Enchantment"] = "Enchantment";
+  CardKind2["Instant"] = "Instant";
+  CardKind2["Planeswalker"] = "Planeswalker";
+  CardKind2["Sorcery"] = "Sorcery";
+  CardKind2["Artifact"] = "Artifact";
+  CardKind2["Unknown"] = "Unknown";
+  return CardKind2;
+})(CardKind || {});
+var Rarity = /* @__PURE__ */ ((Rarity2) => {
+  Rarity2["Common"] = "common";
+  Rarity2["Uncommon"] = "uncommon";
+  Rarity2["Rare"] = "rare";
+  Rarity2["Mythic"] = "mythic";
+  Rarity2["Special"] = "special";
+  Rarity2["Bonus"] = "bonus";
+  Rarity2["Other"] = "other";
+  return Rarity2;
+})(Rarity || {});
+function cloneCard(card) {
+  return {
+    ...card,
+    manaCost: { ...card.manaCost },
+    allManaCosts: card.allManaCosts.map((c) => ({ ...c })),
+    basicLandTypes: card.basicLandTypes ?? 0,
+    checkTypes: card.checkTypes ?? 0,
+    manaPerTap: card.manaPerTap ?? 1
+  };
+}
+function isLandKind(kind) {
+  return kind === "BasicLand" /* BasicLand */ || kind === "ShockLand" /* ShockLand */ || kind === "CheckLand" /* CheckLand */ || kind === "TapLand" /* TapLand */ || kind === "FastLand" /* FastLand */ || kind === "SlowLand" /* SlowLand */ || kind === "BattleLand" /* BattleLand */ || kind === "TurnLand" /* TurnLand */ || kind === "SurveilLand" /* SurveilLand */ || kind === "BounceLand" /* BounceLand */ || kind === "TriomeLand" /* TriomeLand */ || kind === "CyclingLand" /* CyclingLand */ || kind === "PainLand" /* PainLand */ || kind === "FetchLand" /* FetchLand */ || kind === "CanopyLand" /* CanopyLand */ || kind === "PathwayLand" /* PathwayLand */ || kind === "OtherLand" /* OtherLand */ || kind === "ForcedLand" /* ForcedLand */;
+}
+function isLand(card) {
+  return isLandKind(card.kind);
+}
+function hashCardName(name) {
+  let hash = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  for (let i = 0; i < name.length; i++) {
+    hash ^= BigInt(name.charCodeAt(i));
+    hash = BigInt.asUintN(64, hash * prime);
+  }
+  return Number(hash & 0x1fffffffffffffn);
+}
+function parseRarity(raw) {
+  switch (raw.toLowerCase()) {
+    case "common":
+      return "common" /* Common */;
+    case "uncommon":
+      return "uncommon" /* Uncommon */;
+    case "rare":
+      return "rare" /* Rare */;
+    case "mythic":
+      return "mythic" /* Mythic */;
+    case "special":
+      return "special" /* Special */;
+    case "bonus":
+      return "bonus" /* Bonus */;
+    default:
+      return "other" /* Other */;
+  }
+}
+function parseSetCode(raw) {
+  return raw.toLowerCase();
+}
+
+// src/card/land-types.ts
+var BasicLandType = {
+  Plains: 1 << 0,
+  Island: 1 << 1,
+  Swamp: 1 << 2,
+  Mountain: 1 << 3,
+  Forest: 1 << 4
+};
+var TYPE_NAME_TO_BIT = [
+  ["plains", BasicLandType.Plains],
+  ["island", BasicLandType.Island],
+  ["swamp", BasicLandType.Swamp],
+  ["mountain", BasicLandType.Mountain],
+  ["forest", BasicLandType.Forest]
+];
+function basicLandTypesFromTypeLine(typeLine) {
+  const lower = typeLine.toLowerCase();
+  let bits = 0;
+  for (const [name, bit] of TYPE_NAME_TO_BIT) {
+    if (lower.includes(name)) bits |= bit;
+  }
+  return bits;
+}
+function basicLandTypeCount(typeLine) {
+  const bits = basicLandTypesFromTypeLine(typeLine);
+  let n = 0;
+  for (let b = bits; b !== 0; b >>= 1) n += b & 1;
+  return n;
+}
+function checkTypesFromOracleText(oracleText) {
+  const lower = oracleText.toLowerCase();
+  const idx = lower.indexOf("unless you control");
+  if (idx === -1) return 0;
+  const clause = lower.slice(idx);
+  let bits = 0;
+  for (const [name, bit] of TYPE_NAME_TO_BIT) {
+    if (clause.includes(name)) bits |= bit;
+  }
+  return bits;
+}
+function normalizeOracleForEtb(oracleText) {
+  return oracleText.toLowerCase().replace(/enters the battlefield tapped/g, "enters tapped").replace(/\s+/g, " ").trim();
+}
+
+// src/card/mana-color-count.ts
+function newManaColorCount() {
+  return {
+    total: 0,
+    b: 0,
+    u: 0,
+    g: 0,
+    r: 0,
+    w: 0,
+    c: 0,
+    wu: 0,
+    wb: 0,
+    ub: 0,
+    ur: 0,
+    br: 0,
+    bg: 0,
+    rg: 0,
+    rw: 0,
+    gw: 0,
+    gu: 0
+  };
+}
+function countManaColor(mcc, card) {
+  mcc.total += 1;
+  mcc.u += card.u;
+  mcc.r += card.r;
+  mcc.b += card.b;
+  mcc.g += card.g;
+  mcc.w += card.w;
+  mcc.c += card.c;
+  const key = `${card.r},${card.g},${card.b},${card.u},${card.w}`;
+  switch (key) {
+    case "1,1,0,0,0":
+      mcc.rg += 1;
+      break;
+    case "1,0,1,0,0":
+      mcc.br += 1;
+      break;
+    case "1,0,0,1,0":
+      mcc.ur += 1;
+      break;
+    case "1,0,0,0,1":
+      mcc.rw += 1;
+      break;
+    case "0,1,1,0,0":
+      mcc.bg += 1;
+      break;
+    case "0,1,0,1,0":
+      mcc.gu += 1;
+      break;
+    case "0,1,0,0,1":
+      mcc.gw += 1;
+      break;
+    case "0,0,1,1,0":
+      mcc.ub += 1;
+      break;
+    case "0,0,1,0,1":
+      mcc.wb += 1;
+      break;
+    case "0,0,0,1,1":
+      mcc.wu += 1;
+      break;
+  }
+}
+
+// src/mulligan/types.ts
+function createMulberry32(seed) {
+  let t = seed >>> 0;
+  return {
+    genRange(min, max) {
+      t = t + 1831565813 >>> 0;
+      let r = Math.imul(t ^ t >>> 15, 1 | t);
+      r ^= r + Math.imul(r ^ r >>> 7, 61 | r);
+      const u = ((r ^ r >>> 14) >>> 0) / 4294967296;
+      return min + Math.floor(u * (max - min));
+    }
+  };
+}
+function createEntropyRng() {
+  return createMulberry32(Math.random() * 4294967295 >>> 0);
+}
+function partialShuffle(slice, rng, amount) {
+  const n = Math.min(amount, slice.length);
+  for (let i = 0; i < n; i++) {
+    const j = rng.genRange(i, slice.length);
+    const tmp = slice[i];
+    slice[i] = slice[j];
+    slice[j] = tmp;
+  }
+  return slice.slice(0, n);
+}
+
+// src/bipartite.ts
+function maximumBipartiteMatching(edges, mCount, nCount, seen, matches) {
+  let matchCount = 0;
+  for (let i = 0; i < matches.length; i++) matches[i] = -1;
+  for (let m = 0; m < mCount; m++) {
+    for (let i = 0; i < seen.length; i++) seen[i] = false;
+    if (recursiveFindMatch(edges, nCount, m, seen, matches)) {
+      matchCount += 1;
+    }
+  }
+  return matchCount;
+}
+function recursiveFindMatch(edges, nCount, m, seen, matches) {
+  for (let n = 0; n < nCount; n++) {
+    const i = nCount * m + n;
+    if (edges[i] !== 0 && !seen[n]) {
+      seen[n] = true;
+      const prior = matches[n];
+      const available = prior < 0 || recursiveFindMatch(edges, nCount, prior, seen, matches);
+      if (available) {
+        matches[n] = m;
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// src/hand.ts
+function simCardFromCard(card) {
+  return {
+    hash: card.hash,
+    kind: card.kind,
+    manaCost: { ...card.manaCost },
+    basicLandTypes: card.basicLandTypes ?? 0,
+    checkTypes: card.checkTypes ?? 0,
+    manaPerTap: card.manaPerTap ?? 1
+  };
+}
+var PlayOrder = /* @__PURE__ */ ((PlayOrder2) => {
+  PlayOrder2["First"] = "First";
+  PlayOrder2["Second"] = "Second";
+  return PlayOrder2;
+})(PlayOrder || {});
+function newScratch(maxLandCount, maxPipCount) {
+  return {
+    lands: [],
+    edges: new Array(maxLandCount * maxPipCount).fill(0),
+    seen: new Array(maxLandCount).fill(false),
+    matches: new Array(maxLandCount).fill(-1)
+  };
+}
+function handFromOpeningAndDraws(opening, draws, startingHandSize = 7) {
+  const cards = [];
+  for (const card of opening) cards.push(simCardFromCard(card));
+  for (const card of draws) cards.push(simCardFromCard(card));
+  const openingHandSize = opening.length;
+  return {
+    cards,
+    startingHandSize,
+    openingHandSize,
+    mulliganCount: startingHandSize - openingHandSize
+  };
+}
+function handFromMulligan(mulligan, rng, deck, draws) {
+  return mulligan.simulateHand(rng, deck, draws);
+}
+function handOpening(hand) {
+  return hand.cards.slice(0, hand.openingHandSize);
+}
+function handDraws(hand, drawCount) {
+  return hand.cards.slice(hand.openingHandSize, hand.openingHandSize + drawCount);
+}
+function handOpeningWithDraws(hand, drawCount) {
+  return hand.cards.slice(0, hand.openingHandSize + drawCount);
+}
+function countInOpeningWithDraws(hand, drawCount, predicate) {
+  let count = 0;
+  for (const card of handOpeningWithDraws(hand, drawCount)) {
+    if (predicate(card)) count += 1;
+  }
+  return count;
+}
+function autoTapByTurn(hand, goal, turn, playOrder) {
+  const scratch = newScratch(30, 8);
+  return autoTapWithScratch(hand, simCardFromCard(goal), turn, playOrder, scratch);
+}
+function playCmcAutoTap(hand, goal) {
+  return autoTapByTurn(hand, goal, Math.max(1, goal.turn), "First" /* First */);
+}
+function drawCmcAutoTap(hand, goal) {
+  return autoTapByTurn(hand, goal, Math.max(1, goal.turn), "Second" /* Second */);
+}
+function isAlwaysAvailableKind(kind) {
+  return kind === "BasicLand" /* BasicLand */ || kind === "OtherLand" /* OtherLand */ || kind === "ForcedLand" /* ForcedLand */ || kind === "ShockLand" /* ShockLand */ || kind === "PainLand" /* PainLand */ || kind === "FetchLand" /* FetchLand */ || kind === "CanopyLand" /* CanopyLand */ || kind === "PathwayLand" /* PathwayLand */;
+}
+function isConditionalEtbKind(kind) {
+  return kind === "TapLand" /* TapLand */ || kind === "CheckLand" /* CheckLand */ || kind === "FastLand" /* FastLand */ || kind === "SlowLand" /* SlowLand */ || kind === "BattleLand" /* BattleLand */ || kind === "TurnLand" /* TurnLand */ || kind === "SurveilLand" /* SurveilLand */ || kind === "BounceLand" /* BounceLand */ || kind === "TriomeLand" /* TriomeLand */ || kind === "CyclingLand" /* CyclingLand */;
+}
+function pushLandColumns(lands, card) {
+  const copies = card.manaPerTap ?? 1;
+  for (let k = 0; k < copies; k++) lands.push(card);
+}
+function availableTurnForLand(card, playTurn, otherLands, boardTypes, basicsOnBoard = 0) {
+  switch (card.kind) {
+    case "TapLand" /* TapLand */:
+    case "SurveilLand" /* SurveilLand */:
+    case "BounceLand" /* BounceLand */:
+    case "TriomeLand" /* TriomeLand */:
+    case "CyclingLand" /* CyclingLand */:
+      return playTurn + 1;
+    case "CheckLand" /* CheckLand */: {
+      const unlocked = (boardTypes & card.checkTypes) !== 0;
+      return unlocked ? playTurn : playTurn + 1;
+    }
+    case "FastLand" /* FastLand */:
+      return otherLands <= 2 ? playTurn : playTurn + 1;
+    case "SlowLand" /* SlowLand */:
+      return otherLands >= 2 ? playTurn : playTurn + 1;
+    case "BattleLand" /* BattleLand */:
+      return basicsOnBoard >= 2 ? playTurn : playTurn + 1;
+    case "TurnLand" /* TurnLand */:
+      return playTurn <= 3 ? playTurn : playTurn + 1;
+    default:
+      return playTurn;
+  }
+}
+function scheduleLandPlays(openingHand, drawn, playOrder) {
+  const candidates = [];
+  let openingLandIdx = 0;
+  for (const card of openingHand) {
+    if (!isLandKind(card.kind)) continue;
+    openingLandIdx += 1;
+    candidates.push({ card, earliest: openingLandIdx });
+  }
+  for (let drawIdx = 0; drawIdx < drawn.length; drawIdx++) {
+    const card = drawn[drawIdx];
+    if (!isLandKind(card.kind)) continue;
+    const earliest = playOrder === "First" /* First */ ? drawIdx + 2 : drawIdx + 1;
+    candidates.push({ card, earliest });
+  }
+  const scheduled = [];
+  let lastPlayTurn = 0;
+  for (const { card, earliest } of candidates) {
+    const playTurn = Math.max(earliest, lastPlayTurn + 1);
+    scheduled.push({ card, playTurn });
+    lastPlayTurn = playTurn;
+  }
+  return scheduled;
+}
+function autoTapWithScratch(hand, goal, turn, playOrder, scratch) {
+  const drawCount = playOrder === "First" /* First */ ? turn - 1 : turn;
+  const openingHand = handOpening(hand);
+  const drawn = handDraws(hand, drawCount);
+  let inOpeningHand = false;
+  let inDrawHand = false;
+  for (const card of openingHand) {
+    if (card.hash === goal.hash) inOpeningHand = true;
+  }
+  for (const card of drawn) {
+    if (card.hash === goal.hash) inDrawHand = true;
+  }
+  const scheduled = scheduleLandPlays(openingHand, drawn, playOrder);
+  scratch.lands.length = 0;
+  let boardTypes = 0;
+  let basicsOnBoard = 0;
+  for (let i = 0; i < scheduled.length; i++) {
+    const { card, playTurn } = scheduled[i];
+    const otherLands = i;
+    if (isAlwaysAvailableKind(card.kind)) {
+      pushLandColumns(scratch.lands, card);
+    } else if (isConditionalEtbKind(card.kind)) {
+      const availableTurn = availableTurnForLand(
+        card,
+        playTurn,
+        otherLands,
+        boardTypes,
+        basicsOnBoard
+      );
+      if (availableTurn <= turn) pushLandColumns(scratch.lands, card);
+    } else {
+      pushLandColumns(scratch.lands, card);
+    }
+    boardTypes |= card.basicLandTypes;
+    if (card.kind === "BasicLand" /* BasicLand */) basicsOnBoard += 1;
+  }
+  const pipCount = goal.manaCost.r + goal.manaCost.g + goal.manaCost.b + goal.manaCost.u + goal.manaCost.w + goal.manaCost.c;
+  const landCount = scratch.lands.length;
+  if (landCount < pipCount) {
+    return { paid: false, cmc: false, inOpeningHand, inDrawHand };
+  }
+  const edgeLen = pipCount * landCount;
+  if (scratch.edges.length !== edgeLen) {
+    scratch.edges = new Array(edgeLen).fill(0);
+  } else {
+    scratch.edges.fill(0);
+  }
+  if (scratch.seen.length !== landCount) {
+    scratch.seen = new Array(landCount).fill(false);
+  }
+  if (scratch.matches.length !== landCount) {
+    scratch.matches = new Array(landCount).fill(-1);
+  }
+  let row = 0;
+  for (let m = 0; m < goal.manaCost.r; m++, row++) {
+    for (let n = 0; n < landCount; n++) {
+      scratch.edges[landCount * row + n] = scratch.lands[n].manaCost.r;
+    }
+  }
+  for (let m = 0; m < goal.manaCost.g; m++, row++) {
+    for (let n = 0; n < landCount; n++) {
+      scratch.edges[landCount * row + n] = scratch.lands[n].manaCost.g;
+    }
+  }
+  for (let m = 0; m < goal.manaCost.b; m++, row++) {
+    for (let n = 0; n < landCount; n++) {
+      scratch.edges[landCount * row + n] = scratch.lands[n].manaCost.b;
+    }
+  }
+  for (let m = 0; m < goal.manaCost.u; m++, row++) {
+    for (let n = 0; n < landCount; n++) {
+      scratch.edges[landCount * row + n] = scratch.lands[n].manaCost.u;
+    }
+  }
+  for (let m = 0; m < goal.manaCost.w; m++, row++) {
+    for (let n = 0; n < landCount; n++) {
+      scratch.edges[landCount * row + n] = scratch.lands[n].manaCost.w;
+    }
+  }
+  for (let m = 0; m < goal.manaCost.c; m++, row++) {
+    for (let n = 0; n < landCount; n++) {
+      scratch.edges[landCount * row + n] = 1;
+    }
+  }
+  const pipsPaid = maximumBipartiteMatching(
+    scratch.edges,
+    pipCount,
+    landCount,
+    scratch.seen,
+    scratch.matches
+  );
+  return {
+    paid: pipsPaid === pipCount,
+    cmc: true,
+    inOpeningHand,
+    inDrawHand
+  };
+}
+
+// src/mulligan/london.ts
+var STARTING_HAND_SIZE = 7;
+function londonNever() {
+  return {
+    startingHandSize: STARTING_HAND_SIZE,
+    mulliganDownTo: STARTING_HAND_SIZE,
+    mulliganOnLands: /* @__PURE__ */ new Set(),
+    acceptableHandList: []
+  };
+}
+function londonSimulateHand(self, rng, deck, draws) {
+  const deckSize = deck.length;
+  const startingHandSize = Math.min(self.startingHandSize, deckSize);
+  const mulliganDownTo = Math.min(self.mulliganDownTo, startingHandSize);
+  const maxMulliganRounds = startingHandSize - mulliganDownTo + 1;
+  const cardsToDraw = Math.min(startingHandSize + draws + maxMulliganRounds, deckSize);
+  const indexRange = Array.from({ length: deckSize }, (_, i) => i);
+  const mustKeepCardIndices = [];
+  const seenCardHashes = /* @__PURE__ */ new Set();
+  for (let round = 0; round < maxMulliganRounds; round++) {
+    const shuffledIndices2 = partialShuffle(indexRange.slice(), rng, cardsToDraw);
+    const shuffledDeck2 = shuffledIndices2.map((i) => deck[i]);
+    const startingHand = shuffledDeck2.slice(0, startingHandSize);
+    const isLastRound = round === maxMulliganRounds - 1;
+    let landCount = 0;
+    for (const c of startingHand) {
+      if (isLand(c)) landCount += 1;
+    }
+    const sufficientLandCount = !self.mulliganOnLands.has(landCount);
+    if (!isLastRound && !sufficientLandCount) continue;
+    let foundAcceptableHand = false;
+    for (const acceptableHand of self.acceptableHandList) {
+      mustKeepCardIndices.length = 0;
+      seenCardHashes.clear();
+      for (let i = 0; i < startingHand.length; i++) {
+        const card = startingHand[i];
+        if (seenCardHashes.has(card.hash)) continue;
+        if (acceptableHand.has(card.hash)) mustKeepCardIndices.push(i);
+        seenCardHashes.add(card.hash);
+      }
+      foundAcceptableHand = mustKeepCardIndices.length === acceptableHand.size;
+      if (foundAcceptableHand) break;
+    }
+    const disregardFoundAcceptableHand = self.acceptableHandList.length === 0;
+    const keep = isLastRound || sufficientLandCount && (disregardFoundAcceptableHand || foundAcceptableHand);
+    if (!keep) continue;
+    const openingHandSize = startingHandSize - round;
+    let landsSaved = 0;
+    for (let i = 0; i < startingHand.length; i++) {
+      const card = startingHand[i];
+      if (!isLandKind(card.kind)) continue;
+      const needMoreLands = self.mulliganOnLands.has(landsSaved) && landsSaved < openingHandSize;
+      if (needMoreLands) {
+        mustKeepCardIndices.push(i);
+        landsSaved += 1;
+      } else {
+        break;
+      }
+    }
+    mustKeepCardIndices.sort((a, b) => a - b);
+    {
+      let w = 0;
+      for (let r = 0; r < mustKeepCardIndices.length; r++) {
+        if (r === 0 || mustKeepCardIndices[r] !== mustKeepCardIndices[r - 1]) {
+          mustKeepCardIndices[w++] = mustKeepCardIndices[r];
+        }
+      }
+      mustKeepCardIndices.length = w;
+    }
+    for (let i = 0; i < mustKeepCardIndices.length; i++) {
+      const mustKeepI = mustKeepCardIndices[i];
+      const tmp = shuffledDeck2[i];
+      shuffledDeck2[i] = shuffledDeck2[mustKeepI];
+      shuffledDeck2[mustKeepI] = tmp;
+    }
+    let discardCount = 0;
+    for (let i = openingHandSize; i < startingHandSize; i++) {
+      const j = cardsToDraw - 1 - discardCount;
+      const tmp = shuffledDeck2[i];
+      shuffledDeck2[i] = shuffledDeck2[j];
+      shuffledDeck2[j] = tmp;
+      discardCount += 1;
+    }
+    return handFromOpeningAndDraws(
+      shuffledDeck2.slice(0, openingHandSize),
+      shuffledDeck2.slice(openingHandSize),
+      startingHandSize
+    );
+  }
+  const shuffledIndices = partialShuffle(indexRange.slice(), rng, cardsToDraw);
+  const shuffledDeck = shuffledIndices.map((i) => deck[i]);
+  return handFromOpeningAndDraws(
+    shuffledDeck.slice(0, startingHandSize),
+    shuffledDeck.slice(startingHandSize),
+    startingHandSize
+  );
+}
+function asLondonMulligan(london) {
+  return {
+    simulateHand: (rng, deck, draws) => londonSimulateHand(london, rng, deck, draws)
+  };
+}
+
+// src/mulligan/never.ts
+var STARTING_HAND_SIZE2 = 7;
+function newNever() {
+  return { startingHandSize: STARTING_HAND_SIZE2 };
+}
+function neverSimulateHand(self, rng, deck, draws) {
+  const deckLen = deck.length;
+  const cardsToDraw = Math.min(deckLen, self.startingHandSize + draws);
+  const startingHandSize = Math.min(deckLen, self.startingHandSize);
+  const indexRange = Array.from({ length: deckLen }, (_, i) => i);
+  const shuffledIndices = partialShuffle(indexRange, rng, cardsToDraw);
+  const shuffledDeck = shuffledIndices.map((i) => deck[i]);
+  return handFromOpeningAndDraws(
+    shuffledDeck.slice(0, startingHandSize),
+    shuffledDeck.slice(startingHandSize),
+    startingHandSize
+  );
+}
+function asNeverMulligan(n = newNever()) {
+  return {
+    simulateHand: (rng, deck, draws) => neverSimulateHand(n, rng, deck, draws)
+  };
+}
+
+export {
+  emptyManaCost,
+  manaCostFromRgbuwc,
+  manaCostCmc,
+  manaCostsFromStr,
+  CardKind,
+  Rarity,
+  cloneCard,
+  isLandKind,
+  isLand,
+  hashCardName,
+  parseRarity,
+  parseSetCode,
+  BasicLandType,
+  basicLandTypesFromTypeLine,
+  basicLandTypeCount,
+  checkTypesFromOracleText,
+  normalizeOracleForEtb,
+  newManaColorCount,
+  countManaColor,
+  createMulberry32,
+  createEntropyRng,
+  PlayOrder,
+  newScratch,
+  handFromOpeningAndDraws,
+  handFromMulligan,
+  handOpening,
+  countInOpeningWithDraws,
+  autoTapByTurn,
+  playCmcAutoTap,
+  drawCmcAutoTap,
+  availableTurnForLand,
+  autoTapWithScratch,
+  londonNever,
+  asLondonMulligan,
+  asNeverMulligan
+};