@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-TWM6DLYF.js

@@ -0,0 +1,371 @@
+'use strict';
+
+var chunkAHNR3BXI_js = require('./chunk-AHNR3BXI.js');
+
+// src/avatars/draw.ts
+var INK = [31, 26, 28], WHITE = [255, 255, 255], BLACK = [0, 0, 0], MOUTH = [122, 44, 52], BLUSH = [224, 106, 106], DEVICE = [201, 207, 214], COMIC_STROKE = 1.8, COMIC_STROKE_SMALL = 2.6, PRECISION = 100, BYTE_MAX = 255, HEX_RADIX = 16, MULBERRY_STEP = 1831565813, LUMA_R = 0.2126, LUMA_G = 0.7152, LUMA_B = 0.0722, HIGHLIGHT = 0.16, HIGHLIGHT_DARK = 0.1, SHADOW = 0.22, SHADOW_DARK = 0.06, DEPIGMENTED = [241, 216, 200], SCLERA = [251, 248, 244], UNIT = 4294967296;
+function round(value) {
+  return Math.round(value * (100)) / (100);
+}
+function hex(colour) {
+  let out = "#";
+  for (let channel of colour) {
+    let value = Math.max(0, Math.min((255), Math.round(channel)));
+    out += (value < (16) ? "0" : "") + value.toString((16));
+  }
+  return out;
+}
+function mix(a, b, t) {
+  return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];
+}
+function shade(colour, t) {
+  return mix(colour, BLACK, t);
+}
+function tint(colour, t) {
+  return mix(colour, WHITE, t);
+}
+function luminance(colour) {
+  return ((0.2126) * colour[0] + (0.7152) * colour[1] + (0.0722) * colour[2]) / (255);
+}
+function random(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state + (1831565813) >>> 0;
+    let t = state;
+    return t = Math.imul(t ^ t >>> 15, t | 1), t ^= t + Math.imul(t ^ t >>> 7, t | 61), ((t ^ t >>> 14) >>> 0) / (4294967296);
+  };
+}
+var Canvas = class {
+  constructor(style, small) {
+    this.style = style;
+    this.small = small;
+    this.defs = [];
+    this.body = [];
+    this.gradients = 0;
+  }
+  paint(colour, tip = null) {
+    if (this.style === "comic") return hex(colour);
+    let id = `g${this.gradients++}`;
+    if (tip !== null)
+      this.defs.push(
+        `<linearGradient id="${id}" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="${hex(tint(colour, 0.12))}"/><stop offset="0.6" stop-color="${hex(colour)}"/><stop offset="1" stop-color="${hex(tip)}"/></linearGradient>`
+      );
+    else {
+      let light = luminance(colour), lift = tint(colour, (0.16) + (0.1) * (1 - light)), fall = shade(colour, (0.06) + (0.22) * light);
+      this.defs.push(
+        `<radialGradient id="${id}" cx="0.35" cy="0.3" r="0.8"><stop offset="0" stop-color="${hex(lift)}"/><stop offset="0.55" stop-color="${hex(colour)}"/><stop offset="1" stop-color="${hex(fall)}"/></radialGradient>`
+      );
+    }
+    return `url(#${id})`;
+  }
+  ink() {
+    return this.style !== "comic" ? "" : ` stroke="${hex(INK)}" stroke-width="${this.small ? (2.6) : (1.8)}" stroke-linejoin="round"`;
+  }
+  clip(id, shape) {
+    this.defs.push(`<clipPath id="${id}">${shape}</clipPath>`);
+  }
+  add(element) {
+    this.body.push(element);
+  }
+  svg(size) {
+    let defs = this.defs.length === 0 ? "" : `<defs>${this.defs.join("")}</defs>`;
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" width="${size}" height="${size}">${defs}${this.body.join("")}</svg>`;
+  }
+};
+function hairBack(canvas, face, head, fill) {
+  if (!face.covered) {
+    if (face.hairShape === "afro") {
+      let r = head.rx + 5 + face.hairVolume * 9;
+      canvas.add(
+        `<circle cx="50" cy="${round(36)}" r="${round(r)}" fill="${fill}"${canvas.ink()}/>`
+      );
+      return;
+    }
+    if (face.hairShape === "long") {
+      let drop = round(63 + face.hairLength * 22), w = round(head.rx + 4);
+      canvas.add(
+        `<path d="M ${50 - w} 39 Q ${50 - w - 3} ${drop - 8} ${50 - w + 4} ${drop} L ${50 + w - 4} ${drop} Q ${50 + w + 3} ${drop - 8} ${50 + w} 39 Z" fill="${fill}"${canvas.ink()}/>`
+      );
+    }
+  }
+}
+function torso(canvas, face) {
+  canvas.add(
+    `<path d="M 12 100 C 14 80 31 73 50 73 C 69 73 86 80 88 100 Z" fill="${canvas.paint(face.outfit)}"${canvas.ink()}/>`
+  ), canvas.add(
+    `<rect x="42" y="60" width="16" height="15" rx="5" fill="${canvas.paint(shade(face.skin, 0.14))}"/>`
+  );
+}
+function ears(canvas, face, head, skin) {
+  for (let side of [-1, 1])
+    canvas.add(
+      `<ellipse cx="${round(50 + side * (head.rx - 0.5))}" cy="48" rx="4" ry="6" fill="${skin}"${canvas.ink()}/>`
+    );
+  if (face.hearing === null) return;
+  let sides = face.hearing === "both" || face.hearing === "centre" ? [-1, 1] : face.hearing === "left" ? [-1] : [1];
+  for (let side of sides)
+    canvas.add(
+      `<path d="M ${round(50 + side * (head.rx + 2))} 42 q ${side * 4} 2 ${side * 2} 9" fill="none" stroke="${hex(DEVICE)}" stroke-width="2.4" stroke-linecap="round"/>`
+    );
+}
+function headShape(canvas, face, head, skin) {
+  let ellipse = `<ellipse cx="50" cy="45" rx="${round(head.rx)}" ry="${round(head.ry)}"/>`;
+  if (canvas.clip("head", ellipse), canvas.add(
+    `<ellipse cx="50" cy="45" rx="${round(head.rx)}" ry="${round(head.ry)}" fill="${skin}"${canvas.ink()}/>`
+  ), canvas.style === "comic" && canvas.add(
+    `<ellipse cx="${round(50 + head.rx * 0.45)}" cy="${round(45 + head.ry * 0.35)}" rx="${round(head.rx * 0.75)}" ry="${round(head.ry * 0.7)}" fill="${hex(shade(face.skin, (0.06) + 0.08 * luminance(face.skin)))}" clip-path="url(#head)"/>`
+  ), face.patches > 0) {
+    let next = random(face.seed), patch = hex(mix(face.skin, DEPIGMENTED, 0.8));
+    for (let i = 0; i < face.patches; i++) {
+      let x = 50 + (next() - 0.5) * head.rx * 1.6, y = 45 + (next() - 0.5) * head.ry * 1.6, r = 2 + next() * 4;
+      canvas.add(
+        `<ellipse cx="${round(x)}" cy="${round(y)}" rx="${round(r * 1.3)}" ry="${round(r)}" fill="${patch}" clip-path="url(#head)"/>`
+      );
+    }
+  }
+}
+function capPath(head, lift, hairline, part) {
+  let left = round(50 - head.rx - lift), right = round(50 + head.rx + lift), top = round(head.ry + lift), side = round(43), line = round(45 - head.ry * hairline);
+  return `M ${left} ${side} A ${round(head.rx + lift)} ${top} 0 0 1 ${right} ${side} Q ${round(50 + part)} ${line} ${left} ${side} Z`;
+}
+function hairFront(canvas, face, head, fill) {
+  if (face.covered) {
+    let wrap = canvas.paint(face.accent);
+    canvas.add(`<path d="${capPath(head, 5, 0.25, 0)}" fill="${wrap}"${canvas.ink()}/>`), canvas.add(
+      `<ellipse cx="56" cy="${round(45 - head.ry - 4)}" rx="9" ry="6" fill="${wrap}"${canvas.ink()}/>`
+    );
+    return;
+  }
+  switch (face.hairShape) {
+    case "bald":
+      return;
+    case "crop":
+      canvas.add(`<path d="${capPath(head, 0.8, 0.62, 0)}" fill="${fill}" opacity="0.92"/>`);
+      return;
+    case "cap":
+    case "long":
+      canvas.add(`<path d="${capPath(head, 3, 0.5, -7)}" fill="${fill}"${canvas.ink()}/>`);
+      return;
+    case "curls": {
+      canvas.add(`<path d="${capPath(head, 3, 0.5, 0)}" fill="${fill}"${canvas.ink()}/>`);
+      let count = 7;
+      for (let i = 0; i < count; i++) {
+        let angle = Math.PI * (0.1 + 0.8 * i / (count - 1)), x = 50 - Math.cos(angle) * (head.rx + 2), y = 41 - Math.sin(angle) * (head.ry + 1);
+        canvas.add(
+          `<circle cx="${round(x)}" cy="${round(y)}" r="${round(4 + face.coily * 2)}" fill="${fill}"${canvas.ink()}/>`
+        );
+      }
+      return;
+    }
+    case "afro":
+      canvas.add(`<path d="${capPath(head, 2, 0.66, 0)}" fill="${fill}"/>`);
+      return;
+    case "buns": {
+      canvas.add(`<path d="${capPath(head, 2.5, 0.5, 0)}" fill="${fill}"${canvas.ink()}/>`);
+      let two = face.seed % 2 === 1, spots = two ? [-11, 11] : [0];
+      for (let dx of spots)
+        canvas.add(
+          `<circle cx="${50 + dx}" cy="${round(45 - head.ry - (two ? 1 : 5))}" r="${two ? 7 : 9}" fill="${fill}"${canvas.ink()}/>`
+        );
+    }
+  }
+}
+function brows(canvas, face, head) {
+  let y = round(45 - head.ry * 0.24), width = round(Math.min(3.6, 1.5 + face.brows * 0.5)), colour = hex(shade(face.hair, 0.1));
+  for (let side of [-1, 1]) {
+    let raised = face.pose === "playful" && side === 1 ? -2 : 0, arch = face.pose === "cool" ? 0.5 : 1.8, x = 50 + side * 8 * face.width;
+    canvas.add(
+      `<path d="M ${round(x - 4.5)} ${y + raised} Q ${round(x)} ${round(y - arch + raised)} ${round(x + 4.5)} ${y + raised}" fill="none" stroke="${colour}" stroke-width="${width}" stroke-linecap="round"/>`
+    );
+  }
+}
+function eyes(canvas, face) {
+  let pupil = hex(shade(face.eye, 0.6));
+  for (let side of [-1, 1]) {
+    let x = round(50 + side * 8 * face.width);
+    if (face.pose === "playful" && side === -1) {
+      canvas.add(
+        `<path d="M ${x - 3} 44 Q ${x} 41 ${x + 3} 44" fill="none" stroke="${pupil}" stroke-width="1.8" stroke-linecap="round"/>`
+      );
+      continue;
+    }
+    let ry = face.pose === "cool" ? 2 : 3.2;
+    canvas.small || canvas.add(`<ellipse cx="${x}" cy="44" rx="3.6" ry="${ry + 0.7}" fill="${hex(SCLERA)}"/>`), canvas.style === "toon_3d" && !canvas.small ? (canvas.add(`<ellipse cx="${x}" cy="44" rx="3" ry="${ry + 0.3}" fill="${hex(face.eye)}"/>`), canvas.add(`<ellipse cx="${x}" cy="44" rx="1.6" ry="${round(ry * 0.6)}" fill="${pupil}"/>`)) : canvas.add(`<ellipse cx="${x}" cy="44" rx="2.6" ry="${ry}" fill="${pupil}"/>`), canvas.small || canvas.add(`<circle cx="${x - 0.9}" cy="${44 - 1.1}" r="0.9" fill="#ffffff"/>`);
+  }
+}
+function glasses(canvas, face) {
+  if (!face.glasses) return;
+  let frame = hex(INK), width = canvas.small ? 2 : 1.4;
+  for (let side of [-1, 1]) {
+    let x = round(50 + side * 8 * face.width - 6.5);
+    canvas.add(
+      `<rect x="${x}" y="39" width="13" height="10" rx="3" fill="#ffffff" fill-opacity="0.15" stroke="${frame}" stroke-width="${width}"/>`
+    );
+  }
+  canvas.add(
+    `<path d="M ${round(50 - 8 * face.width + 6.5)} 43 Q 50 41 ${round(50 + 8 * face.width - 6.5)} 43" fill="none" stroke="${frame}" stroke-width="${width}"/>`
+  );
+}
+function facialHair(canvas, face, head) {
+  if (face.facialHair <= 0) return;
+  let colour = hex(face.hair), jaw = round(45 + head.ry);
+  if (face.facialHair === 1) {
+    canvas.add(
+      `<path d="M ${round(50 - head.rx + 2)} 49 Q 50 ${jaw + 6} ${round(50 + head.rx - 2)} 49 Q 50 ${jaw - 4} ${round(50 - head.rx + 2)} 49 Z" fill="${colour}" opacity="0.3" clip-path="url(#head)"/>`
+    );
+    return;
+  }
+  canvas.add(
+    `<path d="M 43 55 Q 50 52 57 55 Q 50 ${45 + 9.5} 43 55 Z" fill="${colour}" stroke="${colour}" stroke-width="1.6" stroke-linejoin="round"/>`
+  ), face.facialHair !== 2 && canvas.add(
+    `<path d="M ${round(50 - head.rx + 1)} 47 Q ${round(50 - head.rx + 2)} ${jaw + 4} 50 ${jaw + 5} Q ${round(50 + head.rx - 2)} ${jaw + 4} ${round(50 + head.rx - 1)} 47 Q 50 67 ${round(50 - head.rx + 1)} 47 Z" fill="${colour}"${canvas.ink()}/>`
+  );
+}
+function features(canvas, face) {
+  let nose = hex(shade(face.skin, 0.3));
+  canvas.small || canvas.add(
+    `<path d="M 49 48 Q ${50 + 2.5} 51 ${50 - 1.5} 52" fill="none" stroke="${nose}" stroke-width="1.2" stroke-linecap="round"/>`
+  );
+  let lip = hex(mix(face.skin, MOUTH, 0.6)), y = 57;
+  switch (face.pose) {
+    case "warm":
+      canvas.add(
+        `<path d="M 44 ${y - 1} Q 50 ${y + 5} 56 ${y - 1}" fill="none" stroke="${lip}" stroke-width="1.8" stroke-linecap="round"/>`
+      );
+      break;
+    case "playful":
+      canvas.add(
+        `<path d="M 43 ${y - 1} Q 50 ${y + 8} 57 ${y - 1} Z" fill="${hex(shade(MOUTH, 0.25))}" stroke="${lip}" stroke-width="1.2" stroke-linejoin="round"/>`
+      ), canvas.add(
+        `<path d="M 45 ${y - 0.4} L 55 ${y - 0.4} L 54 ${y + 1.6} L 46 ${y + 1.6} Z" fill="#ffffff"/>`
+      );
+      break;
+    case "cool":
+      canvas.add(
+        `<path d="M 45 ${y + 1} Q 51 ${y + 2} 56 ${y - 1}" fill="none" stroke="${lip}" stroke-width="1.8" stroke-linecap="round"/>`
+      );
+      break;
+    default:
+      canvas.add(
+        `<path d="M 45 ${y} Q 50 ${y + 2} 55 ${y}" fill="none" stroke="${lip}" stroke-width="1.8" stroke-linecap="round"/>`
+      );
+  }
+  if (canvas.style === "toon_3d" && (face.pose === "warm" || face.pose === "playful")) {
+    let blush = hex(mix(face.skin, BLUSH, 0.35));
+    for (let side of [-1, 1])
+      canvas.add(
+        `<ellipse cx="${round(50 + side * 12 * face.width)}" cy="52" rx="4" ry="2.4" fill="${blush}" opacity="0.5"/>`
+      );
+  }
+}
+function avatarSvg(face, options) {
+  let canvas = new Canvas(options.style, options.size < 36), head = { rx: 21 * face.width, ry: 25 * face.length };
+  options.backdrop !== false && canvas.add(`<circle cx="50" cy="50" r="50" fill="${hex(face.backdrop)}"/>`);
+  let hair = canvas.paint(face.hair, face.hairTip);
+  hairBack(canvas, face, head, hair), torso(canvas, face);
+  let skin = canvas.paint(face.skin);
+  return ears(canvas, face, head, skin), headShape(canvas, face, head, skin), hairFront(canvas, face, head, hair), brows(canvas, face, head), eyes(canvas, face), glasses(canvas, face), facialHair(canvas, face, head), features(canvas, face), canvas.svg(Math.max(1, Math.round(options.size)));
+}
+function avatarSvgUri(svg) {
+  return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
+}
+
+// src/avatars/source.ts
+var RENDER_SIZES = [64, 128, 320, 512], RENDER_PENDING_HEADER = "x-avatar-render", RENDER_PENDING_VALUE = "pending", RENDER_PENDING_RETRY_MS = 5e3, RENDER_PENDING_TRIES = 6, MAX_KEPT_RENDERS = 256, DEFAULT_PIXEL_RATIO = 2, IDLE = { status: "idle", src: null }, LOADING = { status: "loading", src: null }, PENDING = { status: "pending", src: null }, FAILED = { status: "failed", src: null };
+function browserPorts() {
+  return {
+    fetch: (url) => fetch(url),
+    objectUrl: (blob) => URL.createObjectURL(blob),
+    revoke: (url) => URL.revokeObjectURL(url),
+    later: (run, ms) => {
+      setTimeout(run, ms);
+    }
+  };
+}
+var AvatarRenderCache = class {
+  constructor(ports = null) {
+    this.states = /* @__PURE__ */ new Map();
+    this.tries = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Set();
+    this.subscribe = (listener) => (this.listeners.add(listener), () => {
+      this.listeners.delete(listener);
+    });
+    this.ports = ports;
+  }
+  state(url) {
+    return url === null ? FAILED : this.states.get(url) ?? IDLE;
+  }
+  request(url) {
+    this.state(url).status === "idle" && this.load(url);
+  }
+  clear() {
+    let ports = this.ports;
+    for (let state of this.states.values()) state.src !== null && ports?.revoke(state.src);
+    this.states.clear(), this.tries.clear(), this.notify();
+  }
+  load(url) {
+    let ports = this.ports ?? (this.ports = browserPorts());
+    this.set(url, LOADING), ports.fetch(url).then(
+      async (response) => {
+        if (!response.ok) return this.set(url, FAILED);
+        if (response.headers.get(RENDER_PENDING_HEADER) === RENDER_PENDING_VALUE)
+          return this.pending(url);
+        this.tries.delete(url), this.set(url, { status: "ready", src: ports.objectUrl(await response.blob()) });
+      },
+      () => this.set(url, FAILED)
+    );
+  }
+  pending(url) {
+    let tries = (this.tries.get(url) ?? 0) + 1;
+    this.tries.set(url, tries), this.set(url, PENDING), !(tries >= (6)) && this.ports?.later(() => {
+      this.state(url).status === "pending" && this.load(url);
+    }, (5e3));
+  }
+  set(url, state) {
+    let before = this.states.get(url);
+    for (before?.src !== null && before?.src !== void 0 && before.src !== state.src && this.ports?.revoke(before.src), this.states.delete(url), this.states.set(url, state); this.states.size > (256); ) {
+      let oldest = this.states.entries().next();
+      if (oldest.done === true) break;
+      let [key, value] = oldest.value;
+      value.src !== null && this.ports?.revoke(value.src), this.states.delete(key), this.tries.delete(key);
+    }
+    this.notify();
+  }
+  notify() {
+    for (let listener of this.listeners) listener();
+  }
+}, avatarRenders = new AvatarRenderCache();
+function renderSize(size, pixelRatio = (2)) {
+  let pixels = Math.ceil(size * pixelRatio);
+  return RENDER_SIZES.find((entry) => entry >= pixels) ?? RENDER_SIZES[RENDER_SIZES.length - 1];
+}
+function avatarRenderUrl(source, apiBase, options) {
+  if (source.hash === "") return null;
+  try {
+    let url = new URL(
+      `v1/avatars/${encodeURIComponent(source.hash)}/${options.kind ?? "portrait"}`,
+      apiBase.endsWith("/") ? apiBase : `${apiBase}/`
+    );
+    return url.searchParams.set("style", options.style), url.searchParams.set("size", String(renderSize(options.size, options.pixelRatio))), url.href;
+  } catch {
+    return null;
+  }
+}
+function drawnAvatarUri(source, options) {
+  let face = chunkAHNR3BXI_js.avatarFace(source);
+  return face === null ? null : avatarSvgUri(avatarSvg(face, options));
+}
+
+exports.AvatarRenderCache = AvatarRenderCache;
+exports.MAX_KEPT_RENDERS = (256);
+exports.RENDER_PENDING_HEADER = RENDER_PENDING_HEADER;
+exports.RENDER_PENDING_RETRY_MS = (5e3);
+exports.RENDER_PENDING_TRIES = (6);
+exports.RENDER_PENDING_VALUE = RENDER_PENDING_VALUE;
+exports.RENDER_SIZES = RENDER_SIZES;
+exports.avatarRenderUrl = avatarRenderUrl;
+exports.avatarRenders = avatarRenders;
+exports.avatarSvg = avatarSvg;
+exports.avatarSvgUri = avatarSvgUri;
+exports.drawnAvatarUri = drawnAvatarUri;
+exports.renderSize = renderSize;

package/dist/chunk-U63OC4TQ.js

@@ -0,0 +1,30 @@
+'use strict';
+
+// src/game/ecs/memory.ts
+function heapArray(scalar, length) {
+  switch (scalar) {
+    case "f32":
+      return new Float32Array(length);
+    case "f64":
+      return new Float64Array(length);
+    case "i8":
+      return new Int8Array(length);
+    case "i16":
+      return new Int16Array(length);
+    case "i32":
+      return new Int32Array(length);
+    case "u8":
+      return new Uint8Array(length);
+    case "u16":
+      return new Uint16Array(length);
+    case "u32":
+      return new Uint32Array(length);
+  }
+}
+var HEAP_MEMORY = {
+  allocate(scalar, length) {
+    return heapArray(scalar, length);
+  }
+};
+
+exports.HEAP_MEMORY = HEAP_MEMORY;

package/dist/{chunk-L5GKVQVJ.js → chunk-U6BVSJZ6.js}

@@ -49,8 +49,7 @@ var ISO3_TO_COUNTRY_CODE = {
   VNM: "VN",
   ZAF: "ZA",
   ZMB: "ZM"
-};
-var CURRENCY_TO_COUNTRY_CODE = {
+}, CURRENCY_TO_COUNTRY_CODE = {
   AED: "AE",
   AOA: "AO",
   AUD: "AU",
@@ -96,84 +95,53 @@ var CURRENCY_TO_COUNTRY_CODE = {
   VND: "VN",
   ZAR: "ZA",
   ZMW: "ZM"
-};
-var CURRENCY_TO_CANDIDATE_COUNTRIES = {
+}, CURRENCY_TO_CANDIDATE_COUNTRIES = {
   EUR: ["DE", "FR", "IT", "ES", "NL", "BE", "AT", "PT", "IE", "FI", "GR"],
   USD: ["US", "EC", "PA", "SV"],
   XOF: ["SN", "CI", "BF", "ML", "NE", "TG", "BJ", "GW"],
   XAF: ["CM", "GA", "CG", "TD", "CF", "GQ"]
 };
 function normalizeCountryCode(value) {
-  const normalized = value?.trim().toUpperCase();
-  if (!normalized) {
-    return void 0;
-  }
-  if (normalized.length === 2) {
-    return normalized;
-  }
-  return ISO3_TO_COUNTRY_CODE[normalized];
+  let normalized = value?.trim().toUpperCase();
+  if (normalized)
+    return normalized.length === 2 ? normalized : ISO3_TO_COUNTRY_CODE[normalized];
 }
 function parsePhoneCandidate(value, country) {
   try {
     return country ? libphonenumberJs.parsePhoneNumberFromString(value, country) : libphonenumberJs.parsePhoneNumberFromString(value);
   } catch {
-    return void 0;
+    return;
   }
 }
 function resolvePhoneCountryCode(options = {}) {
-  const explicitCountry = normalizeCountryCode(options.country);
-  if (explicitCountry) {
+  let explicitCountry = normalizeCountryCode(options.country);
+  if (explicitCountry)
     return explicitCountry;
-  }
-  const currency = options.currency?.trim().toUpperCase();
-  if (!currency) {
-    return void 0;
-  }
-  return CURRENCY_TO_COUNTRY_CODE[currency];
+  let currency = options.currency?.trim().toUpperCase();
+  if (currency)
+    return CURRENCY_TO_COUNTRY_CODE[currency];
 }
 function normalizePhoneToE164(raw, options = {}) {
-  const trimmed = raw.trim();
-  if (!trimmed) {
+  let trimmed = raw.trim();
+  if (!trimmed)
     return null;
-  }
-  const country = resolvePhoneCountryCode(options);
-  const digits = trimmed.replace(/\D/g, "");
-  const internationalDigits = digits.startsWith("00") ? digits.slice(2) : digits;
-  const attempts = [];
-  const seen = /* @__PURE__ */ new Set();
+  let country = resolvePhoneCountryCode(options), digits = trimmed.replace(/\D/g, ""), internationalDigits = digits.startsWith("00") ? digits.slice(2) : digits, attempts = [], seen = /* @__PURE__ */ new Set();
   function addAttempt(value, nextCountry) {
-    const key = `${nextCountry || ""}:${value}`;
-    if (seen.has(key)) {
-      return;
-    }
-    seen.add(key);
-    attempts.push({ value, country: nextCountry });
-  }
-  if (country) {
-    addAttempt(trimmed, country);
-  }
-  addAttempt(trimmed);
-  if (country && digits) {
-    addAttempt(digits, country);
-  }
-  if (internationalDigits) {
-    addAttempt(`+${internationalDigits}`);
+    let key = `${nextCountry || ""}:${value}`;
+    seen.has(key) || (seen.add(key), attempts.push({ value, country: nextCountry }));
   }
-  const currency = options.currency?.trim().toUpperCase();
+  country && addAttempt(trimmed, country), addAttempt(trimmed), country && digits && addAttempt(digits, country), internationalDigits && addAttempt(`+${internationalDigits}`);
+  let currency = options.currency?.trim().toUpperCase();
   if (currency) {
-    const candidates = CURRENCY_TO_CANDIDATE_COUNTRIES[currency];
-    if (candidates) {
-      for (const candidate of candidates) {
-        addAttempt(trimmed, candidate);
-        if (digits) addAttempt(digits, candidate);
-      }
-    }
+    let candidates = CURRENCY_TO_CANDIDATE_COUNTRIES[currency];
+    if (candidates)
+      for (let candidate of candidates)
+        addAttempt(trimmed, candidate), digits && addAttempt(digits, candidate);
   }
-  for (const attempt of attempts) {
-    const parsed = parsePhoneCandidate(attempt.value, attempt.country);
-    if (parsed?.isValid()) {
+  for (let attempt of attempts) {
+    let parsed = parsePhoneCandidate(attempt.value, attempt.country);
+    if (parsed?.isValid())
       return parsed.format("E.164");
-    }
   }
   return null;
 }