@pokewallet/sdk 0.0.0-stage → 0.1.3

package/dist/index.cjs

@@ -0,0 +1,956 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AmbiguousSetError: () => AmbiguousSetError,
+  AuthError: () => AuthError,
+  BadRequestError: () => BadRequestError,
+  FeatureNotEnabledError: () => FeatureNotEnabledError,
+  GAME_CODES: () => GAME_CODES,
+  GameUnavailableError: () => GameUnavailableError,
+  NetworkError: () => NetworkError,
+  NotFoundError: () => NotFoundError,
+  PlanRequiredError: () => PlanRequiredError,
+  PokeWallet: () => PokeWallet,
+  PokeWalletError: () => PokeWalletError,
+  RateLimitError: () => RateLimitError,
+  ServerError: () => ServerError,
+  UnavailableError: () => UnavailableError,
+  VERSION: () => VERSION,
+  ValidationError: () => ValidationError,
+  imageUrl: () => imageUrl,
+  paginate: () => paginate
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var PokeWalletError = class extends Error {
+  status;
+  /** Parsed JSON body of the answer, when there was one. */
+  body;
+  /** The `error` field of the body, when present. */
+  code;
+  constructor(init) {
+    const code = bodyString(init.body, "error");
+    super(init.message ?? bodyString(init.body, "message") ?? code ?? `HTTP ${init.status}`);
+    this.name = new.target.name;
+    this.status = init.status;
+    this.body = init.body;
+    this.code = code;
+  }
+};
+var ValidationError = class extends RangeError {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+var NetworkError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "NetworkError";
+  }
+};
+var BadRequestError = class extends PokeWalletError {
+};
+var AuthError = class extends PokeWalletError {
+};
+var PlanRequiredError = class extends PokeWalletError {
+  redeemUrl;
+  upgradeUrl;
+  constructor(init) {
+    super(init);
+    this.redeemUrl = bodyString(init.body, "redeem_url");
+    this.upgradeUrl = bodyString(init.body, "upgrade_url");
+  }
+};
+var FeatureNotEnabledError = class extends PokeWalletError {
+  contactUrl;
+  constructor(init) {
+    super(init);
+    this.contactUrl = bodyString(init.body, "contact_url");
+  }
+};
+var NotFoundError = class extends PokeWalletError {
+  didYouMean;
+  suggestions;
+  constructor(init) {
+    super(init);
+    this.didYouMean = bodyString(init.body, "did_you_mean");
+    const s = init.body?.suggestions;
+    this.suggestions = Array.isArray(s) ? s : [];
+  }
+};
+var GameUnavailableError = class extends NotFoundError {
+};
+var AmbiguousSetError = class extends PokeWalletError {
+  matches;
+  constructor(init) {
+    super({ ...init, message: init.message ?? "Several sets match this code: pick one by setId" });
+    this.matches = init.matches;
+  }
+};
+var RateLimitError = class extends PokeWalletError {
+  limits;
+  /** Seconds, from the `Retry-After` header, when present. */
+  retryAfter;
+  constructor(init) {
+    super(init);
+    this.retryAfter = init.retryAfter;
+    const l = init.body?.limits;
+    this.limits = { hourly: toWindow(l?.hourly), daily: toWindow(l?.daily) };
+  }
+};
+var UnavailableError = class extends PokeWalletError {
+  retryAfter;
+  constructor(init) {
+    super(init);
+    this.retryAfter = init.retryAfter;
+  }
+};
+var ServerError = class extends PokeWalletError {
+};
+function bodyString(body, key) {
+  const v = body?.[key];
+  return typeof v === "string" ? v : void 0;
+}
+function toWindow(v) {
+  if (!v || typeof v !== "object") return void 0;
+  const w = v;
+  if (typeof w.limit !== "number" || typeof w.used !== "number" || typeof w.remaining !== "number") return void 0;
+  return { limit: w.limit, used: w.used, remaining: w.remaining };
+}
+
+// src/error-map.ts
+var str = (v) => typeof v === "string" ? v : typeof v === "number" ? String(v) : null;
+function toSetMatches(body) {
+  const raw = body?.matches;
+  if (!Array.isArray(raw)) return [];
+  return raw.map((m) => ({
+    setId: str(m.set_id) ?? "",
+    setCode: str(m.set_code),
+    name: str(m.name),
+    language: str(m.language),
+    releaseDate: str(m.release_date)
+  }));
+}
+function isDisambiguation(body) {
+  return !!body && typeof body === "object" && body.disambiguation === true;
+}
+function ambiguousSetError(status, body) {
+  return new AmbiguousSetError({ status, body, matches: toSetMatches(body) });
+}
+function errorFromResponse(ctx) {
+  const { status, body, retryAfter, gameRoute } = ctx;
+  const init = { status, body };
+  const code = body?.error;
+  if (status === 300 || status === 409 && isDisambiguation(body) || status === 409 && code === "Ambiguous set code") {
+    return ambiguousSetError(status, body);
+  }
+  switch (status) {
+    case 400:
+      return new BadRequestError(init);
+    case 401:
+      return new AuthError(init);
+    case 403:
+      return code === "Feature not enabled" ? new FeatureNotEnabledError(init) : new PlanRequiredError(init);
+    case 404:
+      return gameRoute && code === "Endpoint not found" ? new GameUnavailableError(init) : new NotFoundError(init);
+    case 429:
+      return new RateLimitError({ ...init, retryAfter });
+    case 503:
+      return new UnavailableError({ ...init, retryAfter });
+    default:
+      return status >= 500 ? new ServerError(init) : new PokeWalletError(init);
+  }
+}
+
+// src/version.ts
+var VERSION = "0.1.3";
+var DEFAULT_BASE_URL = "https://api.pokewallet.io";
+var DEFAULT_USER_AGENT = `pokewallet-sdk-ts/${VERSION}`;
+
+// src/http.ts
+var GAME_PREFIX = /^\/(mtg|ygo|cfv|dbs|fab|dgm|swu|lor|rft|cpk)\//;
+var KEY_REQUIRED = "An API key is required: pass apiKey or set POKEWALLET_API_KEY";
+function readKey(options) {
+  const env = globalThis.process?.env;
+  const key = (options.apiKey ?? env?.POKEWALLET_API_KEY ?? "").trim();
+  if (!key) return void 0;
+  if (!key.startsWith("pk_")) throw new ValidationError('API keys start with "pk_"');
+  return key;
+}
+function parseRetryAfter(value, now = Date.now()) {
+  if (value == null || value.trim() === "") return void 0;
+  const n = Number(value);
+  if (Number.isFinite(n) && n >= 0) return n;
+  const t = Date.parse(value);
+  return Number.isNaN(t) ? void 0 : Math.max(0, Math.ceil((t - now) / 1e3));
+}
+function num(h, name) {
+  const v = h.get(name);
+  if (v == null) return null;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : null;
+}
+function exhausted(err) {
+  return [err.limits.hourly, err.limits.daily].some((w) => w !== void 0 && w.remaining <= 0);
+}
+var HttpClient = class {
+  /** Quota counters of the most recent answer that carried them. */
+  lastRateLimit = null;
+  #key;
+  baseUrl;
+  userAgent;
+  fetchImpl;
+  maxRetries;
+  capSeconds;
+  timeoutMs;
+  sleep;
+  constructor(options = {}) {
+    this.#key = readKey(options);
+    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.userAgent = options.userAgent ?? DEFAULT_USER_AGENT;
+    const g = globalThis;
+    const f = options.fetch ?? (g.fetch ? g.fetch.bind(globalThis) : void 0);
+    if (!f) throw new ValidationError("No fetch available: pass options.fetch (Node 18+ has one built in)");
+    this.fetchImpl = f;
+    this.maxRetries = options.maxRetries ?? 2;
+    this.capSeconds = options.retryAfterCapSeconds ?? 30;
+    this.timeoutMs = options.timeoutMs ?? 3e4;
+    this.sleep = options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  }
+  url(path, query) {
+    const qs = new URLSearchParams();
+    for (const [k, v] of Object.entries(query ?? {})) if (v !== void 0 && v !== null) qs.set(k, String(v));
+    const s = qs.toString();
+    return `${this.baseUrl}${path}${s ? `?${s}` : ""}`;
+  }
+  /**
+   * GET `path` and return the parsed JSON body; throws a typed error otherwise. `isPublic`
+   * marks the two endpoints the server answers without a key; everything else needs one.
+   * `accept` lets a caller treat a non-2xx body as data (see `health()`).
+   */
+  async get(path, query, options = {}) {
+    if (this.#key === void 0 && !options.isPublic) throw new ValidationError(KEY_REQUIRED);
+    const url = this.url(path, query);
+    for (let attempt = 0; ; attempt++) {
+      const res = await this.send(url);
+      const body = parseJson(this.#redact(await res.text()));
+      this.trackQuota(res.headers);
+      if (res.status >= 200 && res.status < 300) return body;
+      if (options.accept?.(body)) return body;
+      const retryAfter = parseRetryAfter(res.headers.get("retry-after"));
+      const err = errorFromResponse({ status: res.status, body, retryAfter, gameRoute: GAME_PREFIX.test(path) });
+      if (attempt < this.maxRetries && this.shouldRetry(err, retryAfter)) {
+        await this.sleep((retryAfter ?? 1) * 1e3);
+        continue;
+      }
+      throw err;
+    }
+  }
+  shouldRetry(err, retryAfter) {
+    if (err.status === 429) {
+      return retryAfter !== void 0 && retryAfter <= this.capSeconds && !exhausted(err);
+    }
+    if (err.status === 503) return (retryAfter ?? 1) <= this.capSeconds;
+    return false;
+  }
+  async send(url) {
+    try {
+      return await this.fetchImpl(url, {
+        method: "GET",
+        headers: {
+          ...this.#key === void 0 ? {} : { "X-API-Key": this.#key },
+          "User-Agent": this.userAgent,
+          Accept: "application/json"
+        },
+        signal: AbortSignal.timeout(this.timeoutMs)
+      });
+    } catch (cause) {
+      throw new NetworkError("Request failed before an answer arrived", { cause: this.#scrubError(cause) });
+    }
+  }
+  /** Masked form: the only representation of this object that logging or serializing can reach. */
+  toJSON() {
+    return { baseUrl: this.baseUrl, userAgent: this.userAgent, apiKey: this.#key === void 0 ? null : "pk_***" };
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return `HttpClient ${JSON.stringify(this.toJSON())}`;
+  }
+  #redact(text) {
+    return this.#key === void 0 ? text : text.split(this.#key).join("pk_***");
+  }
+  /** A copy of a thrown value with the key removed from its message, stack and string fields. */
+  #scrubError(cause) {
+    if (!(cause instanceof Error)) return typeof cause === "string" ? this.#redact(cause) : void 0;
+    const copy = new Error(this.#redact(cause.message));
+    copy.name = cause.name;
+    if (cause.stack) copy.stack = this.#redact(cause.stack);
+    const code = cause.code;
+    if (typeof code === "string") copy.code = code;
+    return copy;
+  }
+  trackQuota(h) {
+    const info = {
+      limitHour: num(h, "x-ratelimit-limit-hour"),
+      remainingHour: num(h, "x-ratelimit-remaining-hour"),
+      limitDay: num(h, "x-ratelimit-limit-day"),
+      remainingDay: num(h, "x-ratelimit-remaining-day")
+    };
+    if (Object.values(info).some((v) => v !== null)) this.lastRateLimit = info;
+  }
+};
+function parseJson(text) {
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { error: text.slice(0, 200) };
+  }
+}
+
+// src/types.ts
+var GAME_CODES = ["mtg", "ygo", "cfv", "dbs", "fab", "dgm", "swu", "lor", "rft", "cpk"];
+
+// src/images.ts
+function imageUrl(id, options = {}) {
+  const clean = id.trim();
+  if (!clean) throw new ValidationError("id is required");
+  const base = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const game = GAME_CODES.find((g) => clean.toLowerCase().startsWith(`${g}_`));
+  const path = game ? `/${game}/images/${encodeURIComponent(clean)}` : `/images/${encodeURIComponent(clean)}`;
+  const qs = new URLSearchParams();
+  if (!game) {
+    if (options.size) qs.set("size", options.size);
+    if (options.lang) qs.set("lang", options.lang);
+    if (options.set) qs.set("set", options.set);
+  }
+  const s = qs.toString();
+  return `${base}${path}${s ? `?${s}` : ""}`;
+}
+
+// src/normalize/common.ts
+var rec = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+var arr = (v) => Array.isArray(v) ? v : [];
+function str2(v) {
+  if (typeof v === "string") return v;
+  if (typeof v === "number" && Number.isFinite(v)) return String(v);
+  return null;
+}
+function num2(v) {
+  if (typeof v === "number") return Number.isFinite(v) ? v : null;
+  if (typeof v === "string" && v.trim() !== "") {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+}
+var NUMERIC_ID = /^-?\d+$/;
+function setPair(code, id) {
+  const c = str2(code);
+  const i = str2(id);
+  if (i === null && c !== null && NUMERIC_ID.test(c)) return { id: c, code: null };
+  return { id: i, code: c };
+}
+function setRef(name, code, id) {
+  return { ...setPair(code, id), name: str2(name) };
+}
+
+// src/normalize/misc.ts
+function strings(v) {
+  const out = {};
+  for (const [k, val] of Object.entries(rec(v))) if (typeof val === "string") out[k] = val;
+  return out;
+}
+function normalizeGames(raw) {
+  return arr(rec(raw).data).map((item) => {
+    const g = rec(item);
+    const code = str2(g.code);
+    if (code === null || !GAME_CODES.includes(code)) return null;
+    return { code, name: str2(g.name) ?? code, endpoints: strings(g.endpoints), proEndpoints: strings(g.pro_endpoints), raw: item };
+  }).filter((g) => g !== null);
+}
+function isHealthReport(body) {
+  return typeof rec(body).status === "string";
+}
+function normalizeHealth(raw) {
+  const r = rec(raw);
+  const checks = {};
+  for (const [name, value] of Object.entries(rec(r.checks))) {
+    const c = rec(value);
+    checks[name] = { status: str2(c.status) ?? "unknown", message: str2(c.message), responseTime: num2(c.responseTime) };
+  }
+  return {
+    status: str2(r.status) ?? "unknown",
+    timestamp: str2(r.timestamp),
+    version: str2(r.version),
+    checks,
+    responseTime: num2(r.responseTime),
+    region: str2(r.region),
+    message: str2(r.message),
+    raw
+  };
+}
+
+// src/normalize/prices.ts
+function tcgPrice(v, variant) {
+  const r = rec(v);
+  return {
+    variant: str2(variant ?? r.sub_type_name ?? r.variant),
+    low: num2(r.low_price),
+    mid: num2(r.mid_price),
+    high: num2(r.high_price),
+    market: num2(r.market_price),
+    directLow: num2(r.direct_low_price),
+    updatedAt: str2(r.updated_at),
+    raw: v
+  };
+}
+function cardmarketPrice(v, variant) {
+  const r = rec(v);
+  return {
+    variant: str2(variant ?? r.variant_type ?? r.variant),
+    avg: num2(r.avg),
+    low: num2(r.low),
+    trend: num2(r.trend),
+    avg1: num2(r.avg1),
+    avg7: num2(r.avg7),
+    avg30: num2(r.avg30),
+    updatedAt: str2(r.updated_at),
+    raw: v
+  };
+}
+
+// src/normalize/card.ts
+var KNOWN = /* @__PURE__ */ new Set([
+  "name",
+  "clean_name",
+  "set_name",
+  "set_code",
+  "set_id",
+  "card_number",
+  "rarity",
+  "card_type",
+  "product_type",
+  "variants",
+  "card_text"
+]);
+function normalizeCard(raw, ctx) {
+  const r = rec(raw);
+  const info = rec(r.card_info);
+  const tcg = r.tcgplayer ? rec(r.tcgplayer) : null;
+  const cm = r.cardmarket ? rec(r.cardmarket) : null;
+  const pair = ctx ?? { setId: setPair(info.set_code, info.set_id).id, setCode: setPair(info.set_code, info.set_id).code };
+  return {
+    id: str2(r.id) ?? "",
+    name: str2(info.name) ?? "",
+    cleanName: str2(info.clean_name),
+    number: str2(info.card_number),
+    rarity: str2(info.rarity),
+    cardType: str2(info.card_type),
+    productType: str2(info.product_type),
+    text: str2(info.card_text),
+    variants: arr(info.variants).filter((v) => typeof v === "string"),
+    setId: pair.setId,
+    setCode: pair.setCode,
+    setName: str2(info.set_name),
+    tcgplayer: tcg ? { url: str2(tcg.url), prices: arr(tcg.prices).map((p) => tcgPrice(p)) } : null,
+    cardmarket: cm ? { productName: str2(cm.product_name), url: str2(cm.product_url), prices: arr(cm.prices).map((p) => cardmarketPrice(p)) } : null,
+    info: extras(info),
+    raw
+  };
+}
+function extras(info) {
+  const out = {};
+  for (const [k, v] of Object.entries(info)) if (!KNOWN.has(k)) out[k] = v;
+  return out;
+}
+function normalizeOpCard(raw, ctx) {
+  const r = rec(raw);
+  const tcg = r.tcgplayer ? rec(r.tcgplayer) : null;
+  const cm = r.cardmarket ? rec(r.cardmarket) : null;
+  const finish = r.sub_type_name;
+  const info = {};
+  for (const [k, v] of Object.entries(r)) if (k.startsWith("ext_")) info[k] = v;
+  return {
+    id: str2(r.id) ?? "",
+    name: str2(r.name) ?? "",
+    cleanName: str2(r.clean_name),
+    number: str2(r.card_number),
+    rarity: str2(r.rarity),
+    cardType: str2(r.card_type),
+    productType: null,
+    text: str2(r.ext_description),
+    variants: typeof finish === "string" ? [finish] : [],
+    setId: ctx?.setId ?? null,
+    setCode: ctx?.setCode ?? null,
+    setName: null,
+    tcgplayer: tcg ? { url: str2(tcg.url), prices: tcg.prices ? [tcgPrice(tcg.prices, finish)] : [] } : null,
+    cardmarket: cm ? { productName: str2(cm.product_name), url: str2(cm.product_url), prices: cm.prices ? [cardmarketPrice(cm.prices, finish)] : [] } : null,
+    info,
+    raw
+  };
+}
+
+// src/normalize/pro.ts
+var DAYS = [7, 14, 30, 60, 120];
+function normalizeSetPrices(raw) {
+  const r = rec(raw);
+  const pair = setPair(r.set_code, r.set_id ?? r.group_id);
+  const rows = arr(r.data).map((d) => {
+    const row = rec(d);
+    return {
+      id: str2(row.id) ?? "",
+      number: str2(row.card_number),
+      name: str2(row.name) ?? "",
+      variant: str2(row.variant),
+      productType: str2(row.product_type),
+      tcgplayer: row.tcgplayer ? tcgPrice(row.tcgplayer, row.variant) : null,
+      cardmarket: row.cardmarket ? cardmarketPrice(row.cardmarket, row.variant) : null
+    };
+  });
+  return { source: str2(r.source) ?? "both", setId: pair.id, setCode: pair.code, rows, total: num2(r.total) ?? rows.length, raw };
+}
+function priceStats(v) {
+  if (!v || typeof v !== "object") return null;
+  const s = rec(v);
+  const top = s.most_expensive ? rec(s.most_expensive) : null;
+  return {
+    avg: num2(s.avg_market_price ?? s.avg_price),
+    min: num2(s.min_price),
+    max: num2(s.max_price),
+    mostExpensive: top ? { id: str2(top.id), name: str2(top.name), price: num2(top.price) } : null,
+    trendDirection: str2(s.trend_direction)
+  };
+}
+function normalizeStatistics(raw) {
+  const r = rec(raw);
+  const info = rec(r.set_info);
+  const stats = rec(r.price_statistics);
+  const rarity = {};
+  for (const [k, v] of Object.entries(rec(r.rarity_breakdown))) rarity[k] = num2(v) ?? 0;
+  return {
+    set: { ...setRef(info.name, info.set_code, info.set_id), totalCards: num2(info.total_cards) },
+    tcgplayer: priceStats(stats.tcgplayer),
+    cardmarket: priceStats(stats.cardmarket),
+    rarityBreakdown: rarity,
+    raw
+  };
+}
+function normalizeCompletionValue(raw) {
+  const r = rec(raw);
+  const info = rec(r.set_info);
+  const cost = rec(r.completion_cost);
+  const t = cost.tcgplayer ? rec(cost.tcgplayer) : null;
+  const c = cost.cardmarket ? rec(cost.cardmarket) : null;
+  const byRarity = {};
+  for (const [k, v] of Object.entries(rec(r.breakdown_by_rarity))) {
+    byRarity[k] = { count: num2(rec(v).count) ?? 0, totalCost: num2(rec(v).total_cost) };
+  }
+  return {
+    set: { ...setRef(info.name, info.set_code, info.set_id), totalCards: num2(info.total_cards) },
+    tcgplayer: t ? { currency: str2(t.currency), low: num2(t.low_estimate), market: num2(t.market_estimate), high: num2(t.high_estimate) } : null,
+    cardmarket: c ? { currency: str2(c.currency), low: num2(c.low_estimate), avg: num2(c.avg_estimate), trend: num2(c.trend_estimate) } : null,
+    byRarity,
+    note: str2(cost.note),
+    raw
+  };
+}
+function pct(v) {
+  const s = str2(v);
+  return s === null ? null : num2(s.replace("%", "").replace("+", ""));
+}
+function normalizeTrending(raw) {
+  return arr(rec(raw).trending_sets).map((item) => {
+    const s = rec(item);
+    const cm = rec(s.cardmarket);
+    return {
+      set: setRef(s.set_name, s.set_code, s.set_id),
+      cardCount: num2(s.card_count),
+      change: str2(cm.price_change),
+      changePct: pct(cm.price_change),
+      avgPriceCurrent: num2(cm.avg_price_current),
+      avgPricePrevious: num2(cm.avg_price_previous),
+      topMovers: arr(cm.top_movers).map((m) => ({ name: str2(rec(m).name), change: str2(rec(m).change) })),
+      raw: item
+    };
+  });
+}
+function normalizeTopCards(raw) {
+  return arr(rec(raw).top_cards).map((item) => {
+    const c = rec(item);
+    const info = rec(c.card_info);
+    const pair = setPair(info.set_code, info.set_id);
+    return {
+      id: str2(c.id) ?? "",
+      name: str2(info.name) ?? "",
+      number: str2(info.card_number),
+      rarity: str2(info.rarity),
+      setName: str2(info.set_name),
+      setId: pair.id,
+      setCode: pair.code,
+      price: num2(c.current_price),
+      change7d: str2(c.change_7d),
+      raw: item
+    };
+  });
+}
+function historySide(v) {
+  const variants = v && typeof v === "object" ? rec(rec(v).variants) : null;
+  if (!variants) return null;
+  const out = {};
+  for (const [name, data] of Object.entries(variants)) {
+    const d = rec(data);
+    const current = {};
+    for (const [k, val] of Object.entries(rec(d.current))) current[k] = num2(val);
+    const price = {};
+    const change = {};
+    for (const day of DAYS) {
+      price[day] = num2(d[`price_${day}d`]);
+      change[day] = str2(d[`change_${day}d`]);
+    }
+    out[name] = { price, change, current, lastUpdated: str2(d.last_updated) };
+  }
+  return out;
+}
+function normalizePriceHistory(raw) {
+  const r = rec(raw);
+  return { id: str2(r.id) ?? "", name: str2(r.card_name), tcgplayer: historySide(r.tcgplayer), cardmarket: historySide(r.cardmarket), raw };
+}
+
+// src/normalize/sets.ts
+function normalizeSet(raw) {
+  const r = rec(raw);
+  return {
+    id: str2(r.set_id) ?? str2(r.group_id) ?? "",
+    code: str2(r.set_code),
+    name: str2(r.name) ?? str2(r.set_name) ?? "",
+    language: str2(r.language),
+    releaseDate: str2(r.release_date),
+    cardCount: num2(r.card_count ?? r.total_cards),
+    sealedCount: num2(r.sealed_count),
+    raw
+  };
+}
+
+// src/pagination.ts
+function makePage(items, meta) {
+  const totalPages = meta.limit > 0 ? Math.ceil(meta.total / meta.limit) : 0;
+  return { items, page: meta.page, limit: meta.limit, total: meta.total, totalPages };
+}
+async function* paginate(fetchPage, options = {}) {
+  let page = options.startPage ?? 1;
+  let yielded = 0;
+  for (; ; ) {
+    const res = await fetchPage(page);
+    for (const item of res.items) {
+      if (options.maxItems !== void 0 && yielded >= options.maxItems) return;
+      yield item;
+      yielded++;
+    }
+    if (res.items.length === 0 || page >= res.totalPages) return;
+    page++;
+  }
+}
+
+// src/validation.ts
+function checkPage(page) {
+  if (page === void 0) return void 0;
+  if (!Number.isInteger(page) || page < 1) throw new ValidationError(`page must be an integer >= 1 (got ${page})`);
+  return page;
+}
+function checkLimit(limit, max) {
+  if (limit === void 0) return void 0;
+  if (!Number.isInteger(limit) || limit < 1 || limit > max) {
+    throw new ValidationError(`limit must be an integer between 1 and ${max} (got ${limit})`);
+  }
+  return limit;
+}
+function checkPeriod(period) {
+  if (period !== void 0 && period !== "7d") throw new ValidationError(`period ${period} is not available (only 7d)`);
+  return "7d";
+}
+function checkVariant(variant) {
+  if (variant === void 0) return void 0;
+  if (variant !== "normal" && variant !== "foil") throw new ValidationError(`variant must be normal or foil (got ${variant})`);
+  return variant;
+}
+function checkText(name, value, min = 1) {
+  if (typeof value !== "string" || value.trim().length < min) {
+    throw new ValidationError(`${name} must be at least ${min} character${min === 1 ? "" : "s"} long`);
+  }
+  return value.trim();
+}
+function seg(value) {
+  return encodeURIComponent(checkText("id", value));
+}
+
+// src/worlds/world.ts
+var LIMITS = { search: 100, set: 200, trending: 50, topCards: 100 };
+
+// src/worlds/card-world.ts
+var CardWorld = class {
+  constructor(http, config) {
+    this.http = http;
+    this.config = config;
+  }
+  http;
+  config;
+  path(rest) {
+    return `${this.config.prefix}${rest}`;
+  }
+  async search(q, options = {}) {
+    const body = rec(
+      await this.http.get(this.path("/search"), {
+        q: checkText("q", q, this.config.minQuery),
+        page: checkPage(options.page),
+        limit: checkLimit(options.limit, LIMITS.search)
+      })
+    );
+    const p = rec(body.pagination);
+    const items = arr(body.results).map((c) => normalizeCard(c));
+    const page = makePage(items, { page: num2(p.page) ?? 1, limit: num2(p.limit) ?? items.length, total: num2(p.total) ?? items.length });
+    return { ...page, truncated: rec(body.metadata).truncated === true };
+  }
+  searchAll(q, options = {}) {
+    return paginate((page) => this.search(q, { page, limit: options.limit }), { maxItems: options.maxItems });
+  }
+  async card(id) {
+    return normalizeCard(await this.http.get(this.path(`/cards/${seg(id)}`)));
+  }
+  async sets(options = {}) {
+    const body = rec(await this.http.get(this.path("/sets"), { language: options.language }));
+    return arr(body.data).map(normalizeSet);
+  }
+  async set(code, options = {}) {
+    const body = rec(
+      await this.http.get(this.path(`/sets/${seg(code)}`), {
+        page: checkPage(options.page),
+        limit: checkLimit(options.limit, LIMITS.set),
+        language: options.language
+      })
+    );
+    if (isDisambiguation(body)) throw ambiguousSetError(200, body);
+    const set = normalizeSet(body.set);
+    const ctx = { setId: set.id || null, setCode: set.code };
+    const items = arr(body.cards).map((c) => normalizeCard(c, ctx));
+    const p = rec(body.pagination);
+    const page = makePage(items, { page: num2(p.page) ?? 1, limit: num2(p.limit) ?? items.length, total: num2(p.total) ?? items.length });
+    return { ...page, set };
+  }
+  setCards(code, options = {}) {
+    return paginate((page) => this.set(code, { page, limit: options.limit, language: options.language }), {
+      maxItems: options.maxItems
+    });
+  }
+  async prices(code, options = {}) {
+    return normalizeSetPrices(await this.http.get(this.path(`/prices/${seg(code)}`), { source: options.source }));
+  }
+  async statistics(code, options = {}) {
+    return normalizeStatistics(await this.http.get(this.path(`/sets/${seg(code)}/statistics`), { variant: checkVariant(options.variant) }));
+  }
+  async completionValue(code) {
+    return normalizeCompletionValue(await this.http.get(this.path(`/sets/${seg(code)}/completion-value`)));
+  }
+  async trending(options = {}) {
+    const period = checkPeriod(options.period);
+    return normalizeTrending(await this.http.get(this.path("/sets/trending"), { period, limit: checkLimit(options.limit, LIMITS.trending) }));
+  }
+  async topCards(options = {}) {
+    return normalizeTopCards(
+      await this.http.get(this.path("/analytics/top-cards"), {
+        metric: options.metric,
+        source: options.source,
+        limit: checkLimit(options.limit, LIMITS.topCards)
+      })
+    );
+  }
+};
+
+// src/worlds/onepiece-world.ts
+var NUMERIC_ID2 = /^-?\d+$/;
+var OnePieceWorld = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  async search(q, options = {}) {
+    const body = rec(
+      await this.http.get("/op/search", {
+        q: checkText("q", q),
+        page: checkPage(options.page),
+        limit: checkLimit(options.limit, LIMITS.search)
+      })
+    );
+    const items = arr(body.data).map((c) => normalizeOpCard(c));
+    const page = makePage(items, { page: num2(body.page) ?? 1, limit: num2(body.limit) ?? items.length, total: num2(body.total) ?? items.length });
+    return { ...page, truncated: false };
+  }
+  searchAll(q, options = {}) {
+    return paginate((page) => this.search(q, { page, limit: options.limit }), { maxItems: options.maxItems });
+  }
+  async card(id) {
+    return normalizeOpCard(await this.http.get(`/op/cards/${seg(id)}`));
+  }
+  async sets(options = {}) {
+    const body = rec(await this.http.get("/op/sets", { language: options.language }));
+    return arr(body.data).map(normalizeSet);
+  }
+  /** `options.language` is ignored: One Piece maps a code to its first matching set. */
+  async set(code, options = {}) {
+    const body = rec(
+      await this.http.get(`/op/sets/${seg(code)}`, {
+        page: checkPage(options.page),
+        limit: checkLimit(options.limit, LIMITS.set)
+      })
+    );
+    const set = normalizeSet(body.set);
+    const ctx = { setId: set.id || null, setCode: set.code };
+    const items = arr(body.data).map((c) => normalizeOpCard(c, ctx));
+    const page = makePage(items, { page: num2(body.page) ?? 1, limit: num2(body.limit) ?? items.length, total: num2(body.total) ?? items.length });
+    return { ...page, set };
+  }
+  setCards(code, options = {}) {
+    return paginate((page) => this.set(code, { page, limit: options.limit }), { maxItems: options.maxItems });
+  }
+  /** The set goes in the query here (`group_id` for numeric ids, `set_code` otherwise). */
+  async prices(code, options = {}) {
+    if (options.source !== void 0) throw new ValidationError("source is not supported for One Piece prices");
+    const c = checkText("code", code);
+    const query = NUMERIC_ID2.test(c) ? { group_id: c } : { set_code: c };
+    return normalizeSetPrices(await this.http.get("/op/prices", query));
+  }
+  async statistics(code, options = {}) {
+    return normalizeStatistics(await this.http.get(`/op/sets/${seg(code)}/statistics`, { variant: checkVariant(options.variant) }));
+  }
+  async completionValue(code) {
+    return normalizeCompletionValue(await this.http.get(`/op/sets/${seg(code)}/completion-value`));
+  }
+  async trending(options = {}) {
+    const period = checkPeriod(options.period);
+    return normalizeTrending(await this.http.get("/op/sets/trending", { period, limit: checkLimit(options.limit, LIMITS.trending) }));
+  }
+  async topCards(options = {}) {
+    return normalizeTopCards(
+      await this.http.get("/op/analytics/top-cards", {
+        metric: options.metric,
+        source: options.source,
+        limit: checkLimit(options.limit, LIMITS.topCards)
+      })
+    );
+  }
+};
+
+// src/worlds/pokemon-world.ts
+var PokemonWorld = class extends CardWorld {
+  constructor(http) {
+    super(http, { prefix: "", minQuery: 1 });
+  }
+  /**
+   * Card by id, or by plain card number together with `setCode` (`card('086/078', { setCode: 'SV8a' })`).
+   * Ids from `search` and `set` are the safest input.
+   */
+  async card(id, options = {}) {
+    const body = await this.http.get(this.path(`/cards/${seg(id)}`), { set_code: options.setCode });
+    if (isDisambiguation(body)) throw ambiguousSetError(200, body);
+    return normalizeCard(body);
+  }
+  /** Price snapshots at 7/14/30/60/120 days, per finish (not a time series). Pro or trial. */
+  async priceHistory(id) {
+    return normalizePriceHistory(await this.http.get(`/cards/${seg(id)}/price-history`));
+  }
+};
+
+// src/client.ts
+var PokeWallet = class {
+  pokemon;
+  onepiece;
+  games;
+  #http;
+  #baseUrl;
+  constructor(options = {}) {
+    this.#http = new HttpClient(options);
+    this.#baseUrl = options.baseUrl;
+    this.pokemon = new PokemonWorld(this.#http);
+    this.onepiece = new OnePieceWorld(this.#http);
+    const games = {};
+    for (const code of GAME_CODES) {
+      games[code] = new CardWorld(this.#http, { prefix: `/${code}`, minQuery: 2 });
+    }
+    this.games = games;
+  }
+  /** Quota counters from the most recent answer, or null before the first call. */
+  get lastRateLimit() {
+    return this.#http.lastRateLimit;
+  }
+  /** The world for a game code known only at runtime. */
+  game(code) {
+    return this.games[code];
+  }
+  /**
+   * Service status. Works without a key; the header is sent only when a key is set.
+   *
+   * The API answers 503 with a full report when a critical service is down. That report is
+   * information, not a failure: it is returned like a 200, with `status: 'unhealthy'` and the
+   * failing `checks`, and is never retried. A 503 without a report (for example an error page
+   * from the edge) still throws `UnavailableError`.
+   */
+  async health() {
+    return normalizeHealth(await this.#http.get("/health", void 0, { isPublic: true, accept: isHealthReport }));
+  }
+  /** The ten games with their route maps. Works without a key. */
+  async listGames() {
+    return normalizeGames(await this.#http.get("/games", void 0, { isPublic: true }));
+  }
+  toJSON() {
+    return { client: this.#http.toJSON() };
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return `PokeWallet ${JSON.stringify(this.toJSON())}`;
+  }
+  /** See {@link imageUrl}: the URL still needs the API key header. */
+  imageUrl(id, options = {}) {
+    return imageUrl(id, { ...options, baseUrl: this.#baseUrl });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AmbiguousSetError,
+  AuthError,
+  BadRequestError,
+  FeatureNotEnabledError,
+  GAME_CODES,
+  GameUnavailableError,
+  NetworkError,
+  NotFoundError,
+  PlanRequiredError,
+  PokeWallet,
+  PokeWalletError,
+  RateLimitError,
+  ServerError,
+  UnavailableError,
+  VERSION,
+  ValidationError,
+  imageUrl,
+  paginate
+});
+//# sourceMappingURL=index.cjs.map