@occluze/tether 0.6.8 → 0.7.1

package/dist/tether.account.js

@@ -1,4 +1,3 @@
-"use strict";
 (() => {
   var __defProp = Object.defineProperty;
   var __export = (target, all) => {
@@ -6,21 +5,18 @@
       __defProp(target, name, { get: all[name], enumerable: true });
   };
 
-  // src/account.js
+  // src/account.ts
   var account_exports = {};
   __export(account_exports, {
     addresses: () => addresses,
     customer: () => customer,
     deleteAddress: () => deleteAddress,
-    getToken: () => getToken,
-    handleCallback: () => handleCallback,
     isLoggedIn: () => isLoggedIn,
     login: () => login,
     logout: () => logout,
     mountAccount: () => mountAccount,
     order: () => order,
     orders: () => orders,
-    query: () => query2,
     render: () => render,
     requestReturn: () => requestReturn,
     saveAddress: () => saveAddress,
@@ -29,412 +25,193 @@
     updateProfile: () => updateProfile
   });
 
-  // tether-core:config.js
-  var m = window.Tether.__core["config.js"];
-  var { DEFAULTS, cfg, configure, isConfigured, log, reportError, resolveConfig, toMetafieldIdentifier, warn } = m;
+  // tether-core:config.ts
+  var m = window.Tether.__core["config.ts"];
+  var [cfg, isConfigured, log, MARKET_SOURCES, parseMarkets, reportError, warn] = m;
 
-  // tether-core:client.js
-  var m2 = window.Tether.__core["client.js"];
-  var { TetherError, endpoint, gql, request, unwrap, withContext } = m2;
+  // tether-core:client.ts
+  var m2 = window.Tether.__core["client.ts"];
+  var [endpoint, gql, orNull, shaped, TetherError] = m2;
 
-  // tether-core:dom.js
-  var m3 = window.Tether.__core["dom.js"];
-  var { attr, busy, cdnUrl, emit, formatDate, formatMoney, formatPercent, get, has, hasTemplate, imageUrl, notifyLayoutChanged, parseJSONAttr, productUrl, qsa, repeat, repeatKeyed, sameImage, scoped, sel, setImage, setSelected, setStoreHtml, setText, setTextTracked, show, toAttributes, watchImages } = m3;
+  // tether-core:dom.ts
+  var m3 = window.Tether.__core["dom.ts"];
+  var [ANALYTICS_EVENTS, attr, attributesFromJson, emit, formatDate, formatMoney, get, has, hasTemplate, isOwnEvent, parseJSONAttr, productUrl, qsa, repeat, sel, setImage, setText, show] = m3;
 
-  // tether-core:cart.js
-  var m4 = window.Tether.__core["cart.js"];
-  var { Cart, trapFocus } = m4;
+  // tether-core:cart.ts
+  var m4 = window.Tether.__core["cart.ts"];
+  var [Cart] = m4;
 
-  // tether-core:lazy.js
-  var m5 = window.Tether.__core["lazy.js"];
-  var { coreModules, loadPart } = m5;
+  // tether-core:lazy.ts
+  var m5 = window.Tether.__core["lazy.ts"];
+  var [loadPart] = m5;
 
-  // server/src/shared/account-documents.js
-  var MONEY = "amount currencyCode";
-  var CUSTOMER_QUERY = "query TetherCustomer { customer { id firstName lastName displayName emailAddress { emailAddress } defaultAddress { formatted } } }";
-  var ORDERS_QUERY = `query TetherOrders($first:Int!){customer{orders(first:$first,sortKey:PROCESSED_AT,reverse:true){nodes{id name processedAt financialStatus fulfillmentStatus statusPageUrl totalPrice{${MONEY}}lineItems(first:20){nodes{title variantTitle quantity image{url altText}}}}}}}`;
-
-  // server/src/shared/base64url.js
-  function toBase64Url(bytes) {
-    return btoa(String.fromCharCode(...new Uint8Array(bytes))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  // server/src/shared/json.ts
+  function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+  }
+  function field(value, key) {
+    return isRecord(value) ? value[key] : void 0;
   }
-  function fromBase64Url(text) {
-    const base64 = text.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(text.length / 4) * 4, "=");
-    return Uint8Array.from(atob(base64), (char) => char.charCodeAt(0));
+  function asList(value) {
+    return Array.isArray(value) ? value : [];
   }
-  function randomToken(bytes = 32) {
-    return toBase64Url(crypto.getRandomValues(new Uint8Array(bytes)));
+  function textOrNull(value) {
+    return typeof value === "string" && value !== "" ? value : null;
   }
+  var numberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+  var countOrZero = (value) => numberOrNull(value) ?? 0;
+  var listOf = (value, read) => asList(value).map((item) => read(item));
+  var nodesOf = (connection, read) => ({
+    nodes: listOf(field(connection, "nodes"), read)
+  });
+  var textList = (value) => listOf(value, textOrNull).filter((line) => line !== null);
 
-  // src/account/shared.js
-  var sessionKey = () => `${cfg.prefix}:account:${cfg.domain}`;
-  var pendingLoginKey = () => `${cfg.prefix}:account-login:${cfg.domain}`;
-  var hintKey = () => `${cfg.prefix}:account-hint:${cfg.domain}`;
-  var sessionArea = () => cfg.account?.remember ? "local" : "session";
-  var storageOf = (area) => area === "local" ? window.localStorage : window.sessionStorage;
-  function readJsonIfAllowed(area, key) {
-    try {
-      return JSON.parse(storageOf(area).getItem(key) ?? "null");
-    } catch {
-      return null;
-    }
+  // server/src/shared/error-message.ts
+  function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
   }
-  function writeJsonIfAllowed(area, key, value) {
+
+  // src/storage.ts
+  function setStored(key, value, area = "localStorage") {
     try {
-      if (value === null) storageOf(area).removeItem(key);
-      else storageOf(area).setItem(key, JSON.stringify(value));
+      window[area].setItem(key, value);
     } catch {
     }
   }
-  function setLoginHint(loggedIn) {
-    writeJsonIfAllowed("local", hintKey(), loggedIn ? 1 : null);
-  }
-  var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-  var textOrNull = (value) => typeof value === "string" ? value : null;
-  async function readJsonObjectOrEmpty(response) {
-    let json;
+  function removeStored(key, area = "localStorage") {
     try {
-      json = await response.json();
+      window[area].removeItem(key);
     } catch {
-      return {};
     }
-    return isRecord(json) ? json : {};
-  }
-  function navigate(url) {
-    const replacement = cfg.account?.navigate;
-    if (replacement) replacement(url);
-    else window.location.assign(url);
   }
-  var loginLanguage = (locale) => locale || cfg.account?.locale || (cfg.locale || "").split("-")[0] || "";
-  var loginCountry = () => cfg.country ? cfg.country.toUpperCase() : "";
 
-  // src/account/shopify-auth.js
-  var DEFAULT_TOKEN_SECONDS = 3600;
-  var endpoints = null;
-  async function wellKnown(document2) {
-    const shop = cfg.account?.shopDomain || cfg.domain;
-    const response = await fetch(`https://${shop}/.well-known/${document2}`);
-    if (!response.ok) {
-      throw new TetherError(`Customer accounts: ${document2} answered ${response.status}`, { status: response.status });
+  // src/account-marks.ts
+  var hintKey = () => `${cfg.prefix}:account-hint:${cfg.domain}`;
+  var isLoginOutcome = (value) => value === "in" || value === "expired" || value === "error";
+
+  // server/src/shared/account-orders.ts
+  function moneyOrNull(value) {
+    const amount = textOrNull(field(value, "amount"));
+    const currencyCode = textOrNull(field(value, "currencyCode"));
+    return amount === null || currencyCode === null ? null : { amount, currencyCode };
+  }
+  function imageOrNull(value) {
+    const url = textOrNull(field(value, "url"));
+    return url === null ? null : { url, altText: textOrNull(field(value, "altText")) };
+  }
+  var toOrderLine = (value) => ({
+    title: textOrNull(field(value, "title")),
+    variantTitle: textOrNull(field(value, "variantTitle")),
+    quantity: countOrZero(field(value, "quantity")),
+    image: imageOrNull(field(value, "image"))
+  });
+  var toAccountOrder = (value, id) => ({
+    id,
+    name: textOrNull(field(value, "name")),
+    processedAt: textOrNull(field(value, "processedAt")),
+    financialStatus: textOrNull(field(value, "financialStatus")),
+    fulfillmentStatus: textOrNull(field(value, "fulfillmentStatus")),
+    statusPageUrl: textOrNull(field(value, "statusPageUrl")),
+    totalPrice: moneyOrNull(field(value, "totalPrice")),
+    lineItems: nodesOf(field(value, "lineItems"), toOrderLine)
+  });
+  function readOrders(value) {
+    const orders2 = [];
+    for (const item of asList(value)) {
+      const id = textOrNull(field(item, "id"));
+      if (id === null) return { kind: "missing-id" };
+      orders2.push(toAccountOrder(item, id));
     }
-    const json = (
-      /** @type {unknown} */
-      await response.json()
-    );
-    return isRecord(json) ? json : {};
+    return { kind: "read", orders: orders2 };
   }
-  function endpointIn(json, name) {
-    const url = textOrNull(json[name]);
-    if (!url) throw new TetherError(`Customer accounts: Shopify named no ${name}`);
-    return url;
-  }
-  async function discover() {
-    if (endpoints) return endpoints;
-    const [openid, api] = await Promise.all([wellKnown("openid-configuration"), wellKnown("customer-account-api")]);
-    endpoints = {
-      issuer: endpointIn(openid, "issuer"),
-      authorizationEndpoint: endpointIn(openid, "authorization_endpoint"),
-      tokenEndpoint: endpointIn(openid, "token_endpoint"),
-      endSessionEndpoint: endpointIn(openid, "end_session_endpoint"),
-      graphql: endpointIn(api, "graphql_api")
-    };
-    return endpoints;
-  }
-  async function requestToken(params) {
-    const { tokenEndpoint } = await discover();
-    const response = await fetch(cfg.account?.tokenUrl || tokenEndpoint, {
-      method: "POST",
-      body: new URLSearchParams(params)
-    });
-    const data = await readJsonObjectOrEmpty(response);
-    const access = textOrNull(data["access_token"]);
-    if (!response.ok || !access) {
-      const ended = response.status === 400 || response.status === 401;
-      throw new TetherError(`Customer accounts: token ${response.status} ${textOrNull(data["error"]) ?? ""}`.trim(), {
-        status: response.status,
-        code: ended ? "SESSION_ENDED" : "TOKEN_FAILED"
-      });
-    }
+
+  // src/account/answers.ts
+  var unexpected = (what) => new TetherError(`Customer accounts: the answer has no ${what}`);
+  function toAccountCustomer(value) {
+    const customer2 = isRecord(value) ? value : {};
+    const id = textOrNull(customer2["id"]);
+    const email = textOrNull(customer2["email"]);
+    const address = customer2["address"];
     return {
-      access,
-      refresh: textOrNull(data["refresh_token"]) || null,
-      idToken: textOrNull(data["id_token"]) || null,
-      expiresInSeconds: Number(data["expires_in"]) || DEFAULT_TOKEN_SECONDS
+      ...id === null ? {} : { id },
+      firstName: textOrNull(customer2["firstName"]),
+      lastName: textOrNull(customer2["lastName"]),
+      displayName: textOrNull(customer2["displayName"]),
+      emailAddress: email === null ? null : { emailAddress: email },
+      defaultAddress: Array.isArray(address) ? { formatted: textList(address) } : null
     };
   }
-  function idTokenClaims(idToken) {
-    const payload = idToken.split(".")[1];
-    if (!payload) return null;
-    let claims;
-    try {
-      claims = JSON.parse(new TextDecoder().decode(fromBase64Url(payload)));
-    } catch {
-      return null;
-    }
-    return isRecord(claims) ? claims : null;
-  }
-  function answersLogin(idToken, { nonce, issuer, client }) {
-    const claims = idToken ? idTokenClaims(idToken) : null;
-    if (!claims) return false;
-    const audience = claims["aud"];
-    const audiences = Array.isArray(audience) ? audience : [audience];
-    const expiresAt = claims["exp"];
-    return claims["nonce"] === nonce && claims["iss"] === issuer && audiences.includes(client) && typeof expiresAt === "number" && expiresAt * 1e3 >= Date.now();
+  function toAccountOrders(value) {
+    const reading = readOrders(value);
+    if (reading.kind === "missing-id") throw unexpected("order id");
+    return reading.orders;
   }
-
-  // src/account/browser-session.js
-  var REFRESH_MARGIN_SECONDS = 120;
-  var LOGIN_TIMEOUT_MS = 10 * 60 * 1e3;
-  var session = null;
-  var customerProfile = null;
-  var refreshing = null;
-  function toSession(value) {
-    if (!isRecord(value)) return null;
-    const access = value["access"];
-    const expiresAt = value["expiresAt"];
-    if (typeof access !== "string" || typeof expiresAt !== "number") return null;
-    return { access, expiresAt, refresh: textOrNull(value["refresh"]), idToken: textOrNull(value["idToken"]) };
-  }
-  function toPendingLogin(value) {
-    if (!isRecord(value)) return null;
-    const { state, nonce, verifier, redirect, returnTo, at } = value;
-    if (typeof state !== "string" || typeof nonce !== "string" || typeof verifier !== "string") return null;
-    if (typeof redirect !== "string" || typeof returnTo !== "string" || typeof at !== "number") return null;
-    return { state, nonce, verifier, redirect, returnTo, at };
-  }
-  var currentSession = () => session ?? toSession(readJsonIfAllowed(sessionArea(), sessionKey()));
-  var accessToken = () => session?.access ?? null;
-  var hasBrowserLogin = () => Boolean(session && (session.refresh || session.access && session.expiresAt > Date.now()));
-  function clientId() {
-    const id = cfg.account?.clientId;
-    if (!id) throw new TetherError("Customer accounts: set account.clientId", { code: "NOT_CONFIGURED" });
-    return id;
-  }
-  var sha256 = async (text) => toBase64Url(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text)));
-  async function browserLoginRedirect({ returnTo, locale }) {
-    const client = clientId();
-    const endpoints2 = await discover();
-    const pending = {
-      state: randomToken(),
-      nonce: randomToken(),
-      verifier: randomToken(),
-      redirect: cfg.account?.callbackUrl || `${window.location.origin}${window.location.pathname}`,
-      returnTo,
-      at: Date.now()
-    };
-    writeJsonIfAllowed("session", pendingLoginKey(), pending);
-    const url = new URL(endpoints2.authorizationEndpoint);
-    const params = {
-      client_id: client,
-      scope: "openid email customer-account-api:full",
-      response_type: "code",
-      redirect_uri: pending.redirect,
-      state: pending.state,
-      nonce: pending.nonce,
-      code_challenge: await sha256(pending.verifier),
-      code_challenge_method: "S256"
+  function toUserError(value) {
+    const message = textOrNull(field(value, "message"));
+    if (message === null) return null;
+    const fieldPath = field(value, "field");
+    return {
+      message,
+      field: Array.isArray(fieldPath) ? textList(fieldPath) : null,
+      code: textOrNull(field(value, "code"))
     };
-    const language = loginLanguage(locale);
-    if (language) params["locale"] = language;
-    const country = loginCountry();
-    if (country) params["region_country"] = country;
-    Object.entries(params).forEach(([name, value]) => {
-      url.searchParams.set(name, value);
-    });
-    navigate(url.toString());
   }
-  function keep(answer, previous) {
-    session = {
-      access: answer.access,
-      expiresAt: Date.now() + Math.max(0, answer.expiresInSeconds - REFRESH_MARGIN_SECONDS) * 1e3,
-      refresh: answer.refresh ?? previous?.refresh ?? null,
-      idToken: answer.idToken ?? previous?.idToken ?? null
-    };
-    writeJsonIfAllowed(sessionArea(), sessionKey(), session);
-  }
-  async function handleCallback() {
-    const params = new URLSearchParams(window.location.search);
-    const pending = toPendingLogin(readJsonIfAllowed("session", pendingLoginKey()));
-    if (!pending || !params.has("code") && !params.has("error") || params.get("state") !== pending.state) return false;
-    writeJsonIfAllowed("session", pendingLoginKey(), null);
-    const clean = new URL(window.location.href);
-    ["code", "state", "iss", "error", "error_description"].forEach((name) => {
-      clean.searchParams.delete(name);
-    });
-    window.history.replaceState(window.history.state, "", clean);
-    const error = params.get("error");
-    if (error !== null) {
-      emit("account-error", { error });
-      return false;
-    }
-    if (Date.now() - pending.at > LOGIN_TIMEOUT_MS) {
-      throw new TetherError("Customer accounts: the login took too long, please try again");
-    }
-    const client = clientId();
-    const answer = await requestToken({
-      grant_type: "authorization_code",
-      client_id: client,
-      redirect_uri: pending.redirect,
-      code: params.get("code") ?? "",
-      code_verifier: pending.verifier
-    });
-    const { issuer } = await discover();
-    if (!answersLogin(answer.idToken, { nonce: pending.nonce, issuer, client })) {
-      throw new TetherError("Customer accounts: the login answer did not check out (nonce/issuer/audience)");
-    }
-    keep(answer, null);
-    await linkCart();
-    emit("account-login", {});
-    const back = pending.returnTo ? new URL(pending.returnTo, window.location.href) : null;
-    if (back?.origin === window.location.origin && back.href !== clean.href) navigate(back.href);
-    return true;
-  }
-  function endSession() {
-    session = null;
-    customerProfile = null;
-    writeJsonIfAllowed(sessionArea(), sessionKey(), null);
-    Cart.setCustomer({ accessToken: null });
-  }
-  async function refresh(expired) {
-    try {
-      const answer = await requestToken({
-        grant_type: "refresh_token",
-        client_id: clientId(),
-        refresh_token: expired.refresh ?? ""
-      });
-      keep(answer, expired);
-      await linkCart();
-    } catch (error) {
-      if (error instanceof TetherError && error.code === "SESSION_ENDED") endSession();
-      else throw error;
+  var toUserErrors = (value) => listOf(value, toUserError).filter((error) => error !== null);
+
+  // src/account/server-client.ts
+  var known = null;
+  function serverBase() {
+    const server = cfg.account?.server;
+    if (!server) {
+      throw new TetherError("Customer accounts need the Worker: set account.server", { code: "NOT_CONFIGURED" });
     }
+    return new URL(server, window.location.href).href.replace(/\/$/, "");
   }
-  async function getToken() {
-    session = currentSession();
-    if (!session) return null;
-    if (session.access && session.expiresAt > Date.now()) return session.access;
-    if (!session.refresh) {
-      endSession();
-      return null;
-    }
-    const expired = session;
-    refreshing ?? (refreshing = refresh(expired).finally(() => {
-      refreshing = null;
-    }));
-    await refreshing;
-    return accessToken();
+  function setLoginHint(loggedIn) {
+    if (loggedIn) setStored(hintKey(), "1");
+    else removeStored(hintKey());
   }
-  async function linkCart() {
-    const token = accessToken();
-    Cart.setCustomer({ accessToken: token });
-    if (!Cart.id() || !token) return;
+  async function fetchFromWorker(url, init) {
     try {
-      await Cart.setBuyerIdentity({ customerAccessToken: token }, { create: false });
+      return await fetch(url, init);
     } catch (error) {
-      reportError(error, "account cart");
+      throw new TetherError(`Network error: ${messageOf(error)}`, {
+        code: "NETWORK"
+      });
     }
   }
-  async function unlinkCart() {
-    if (!Cart.id()) return;
+  async function readJsonObjectOrEmpty(response) {
+    let json;
     try {
-      await Cart.setBuyerIdentity({ customerAccessToken: null }, { create: false });
-    } catch (error) {
-      reportError(error, "account cart unlink");
-      writeJsonIfAllowed("local", cfg.storageKey, null);
-    }
-  }
-  async function browserLogout(returnTo) {
-    const idToken = currentSession()?.idToken ?? null;
-    await unlinkCart();
-    endSession();
-    emit("account-logout", {});
-    if (!idToken) return "stayed";
-    const url = new URL((await discover()).endSessionEndpoint);
-    url.searchParams.set("id_token_hint", idToken);
-    url.searchParams.set("post_logout_redirect_uri", returnTo);
-    navigate(url.toString());
-    return "redirected";
-  }
-  async function query(document2, variables = {}) {
-    const token = await getToken();
-    if (!token) throw new TetherError("Not logged in", { code: "NOT_LOGGED_IN" });
-    const { graphql } = await discover();
-    const send = (accessToken2) => fetch(graphql, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", Authorization: accessToken2 },
-      body: JSON.stringify({ query: document2, variables })
-    });
-    let response = await send(token);
-    if (response.status === 401 && session?.refresh) {
-      session.expiresAt = 0;
-      response = await send(await getToken() ?? "");
-    }
-    const json = await readJsonObjectOrEmpty(response);
-    const errors = Array.isArray(json["errors"]) ? json["errors"] : [];
-    if (!response.ok || errors.length) {
-      const messages = errors.map((error) => isRecord(error) ? textOrNull(error["message"]) : null).filter(Boolean);
-      throw new TetherError(messages.join(" | ") || `Customer accounts: ${response.status}`, {
-        status: response.status
-      });
+      json = await response.json();
+    } catch {
+      return {};
     }
-    return (
-      /** @type {T} */
-      json["data"]
-    );
-  }
-  async function browserCustomer() {
-    if (customerProfile) return customerProfile;
-    const data = await query(CUSTOMER_QUERY);
-    customerProfile = data.customer;
-    return customerProfile;
-  }
-  function forgetBrowserCustomer() {
-    customerProfile = null;
-  }
-
-  // src/account/server-client.js
-  var known = null;
-  function serverBase() {
-    const server = cfg.account?.server;
-    if (!server) return "";
-    return new URL(server, window.location.href).href.replace(/\/$/, "");
+    return isRecord(json) ? json : {};
   }
   async function serverFetch(path, { method = "GET", body } = {}) {
     const init = { method, credentials: "include" };
     if (method === "POST") init.headers = { "Content-Type": "application/json", "X-Tether-Account": "1" };
     if (body) init.body = JSON.stringify(body);
-    const response = await fetch(`${serverBase()}${path}`, init);
+    const response = await fetchFromWorker(`${serverBase()}${path}`, init);
     if (response.status === 401) return { kind: "logged-out" };
     const data = await readJsonObjectOrEmpty(response);
     if (!response.ok) {
       const reason = textOrNull(data["error"]) ?? String(response.status);
-      const userErrors = Array.isArray(data["userErrors"]) ? (
-        // The Worker sends Shopify's own `userErrors` list unchanged.
-        /** @type {UserError[]} */
-        data["userErrors"]
-      ) : void 0;
+      const userErrors = toUserErrors(data["userErrors"]);
       throw new TetherError(`Customer accounts: ${reason}`, {
         status: response.status,
-        ...userErrors && { userErrors }
+        ...userErrors.length > 0 && { userErrors },
+        // The Worker marks refused input (a 400, or a 404 for a contract that isn't the customer's) with `code`.
+        ...data["code"] === "INVALID" && { code: "INVALID" }
       });
     }
     return { kind: "answer", data };
   }
-  function toServerCustomer(value) {
-    const customer2 = isRecord(value) ? value : {};
-    const address = customer2["address"];
-    return {
-      firstName: textOrNull(customer2["firstName"]),
-      lastName: textOrNull(customer2["lastName"]),
-      displayName: textOrNull(customer2["displayName"]),
-      email: textOrNull(customer2["email"]),
-      address: Array.isArray(address) ? address.filter((line) => typeof line === "string") : null
-    };
-  }
   async function serverLogin() {
     if (!known) {
       const answer = await serverFetch("/me");
-      known = answer.kind === "answer" && answer.data["loggedIn"] === true ? { loggedIn: true, customer: toServerCustomer(answer.data["customer"]) } : { loggedIn: false };
+      known = answer.kind === "answer" && answer.data["loggedIn"] === true ? { loggedIn: true, customer: toAccountCustomer(answer.data["customer"]) } : { loggedIn: false };
     }
     setLoginHint(known.loggedIn);
     return known;
@@ -443,13 +220,18 @@
   function forgetServerLogin() {
     known = null;
   }
+  function navigate(url) {
+    const replacement = cfg.account?.navigate;
+    if (replacement) replacement(url);
+    else window.location.assign(url);
+  }
+  var loginLanguage = (locale) => locale || cfg.account?.locale || (cfg.locale || "").split("-")[0] || "";
   function serverLoginRedirect({ returnTo, locale }) {
     const url = new URL(`${serverBase()}/login`);
     url.searchParams.set("returnTo", returnTo);
     const language = loginLanguage(locale);
     if (language) url.searchParams.set("locale", language);
-    const country = loginCountry();
-    if (country) url.searchParams.set("country", country);
+    if (cfg.country) url.searchParams.set("country", cfg.country.toUpperCase());
     navigate(url.toString());
   }
   async function serverCheckoutUrl() {
@@ -457,9 +239,7 @@
     if (!(await serverLogin()).loggedIn || !cartId) return null;
     const answer = await serverFetch("/cart", { method: "POST", body: { cartId } });
     if (answer.kind === "logged-out") return null;
-    const url = textOrNull(answer.data["checkoutUrl"]);
-    if (!url) return null;
-    return `${url}${url.includes("?") ? "&" : "?"}logged_in=true`;
+    return textOrNull(answer.data["checkoutUrl"]);
   }
   async function serverLogout(returnTo) {
     const answer = await serverFetch("/logout", { method: "POST", body: { returnTo, cartId: Cart.id() } });
@@ -472,29 +252,11 @@
     return "redirected";
   }
 
-  // tether-core:shopify-values.js
-  var m6 = window.Tether.__core["shopify-values.js"];
-  var { STORE_ENV_NAMES, formatMoney: formatMoney2, isHttpsUrl, isSecretShopifyToken, productKey, productUrl: productUrl2 } = m6;
-
-  // src/account-links.js
-  function localDate(iso) {
-    try {
-      return new Date(iso).toLocaleDateString(cfg.locale);
-    } catch (error) {
-      if (error instanceof RangeError) return iso;
-      throw error;
-    }
-  }
-  function orderUrl(order2) {
-    const template = cfg.account?.orderUrl;
-    if (template) {
-      const numericId = order2.id.split("/").pop()?.split("?")[0] ?? "";
-      return template.replace("{id}", encodeURIComponent(numericId));
-    }
-    return isHttpsUrl(order2.statusPageUrl) ? order2.statusPageUrl ?? null : null;
-  }
+  // tether-core:shopify-values.ts
+  var m6 = window.Tether.__core["shopify-values.ts"];
+  var [isHttpsUrl] = m6;
 
-  // src/account/markup.js
+  // src/account/markup.ts
   function showIn(root, name, conditions) {
     qsa(root, sel(name)).forEach((el) => {
       const key = get(el, name) ?? "";
@@ -504,9 +266,9 @@
   var bindsIn = (row, name) => qsa(row, sel(name)).concat(row.matches(sel(name)) ? [row] : []);
   var ownValue = (values, key) => Object.hasOwn(values, key) ? values[key] : void 0;
 
-  // src/account/order-lines.js
+  // src/account/order-lines.ts
   var lineTexts = (line, returnable) => ({
-    title: line.title || line.name,
+    title: line.title || line.name || "",
     "variant-title": line.variantTitle || "",
     quantity: String(line.quantity),
     price: formatMoney(line.price),
@@ -528,7 +290,7 @@
       if (select.dataset["tetherFilled"] === line.id) return;
       select.dataset["tetherFilled"] = line.id;
       (line.suggestedReturnReasonDefinitions?.nodes ?? []).forEach((reason) => {
-        select.appendChild(new Option(reason.name, reason.id));
+        select.appendChild(new Option(reason.name ?? "", reason.id));
       });
     });
   }
@@ -541,7 +303,7 @@
       bindsIn(row, "order-line").forEach((el) => {
         const key = get(el, "order-line") ?? "";
         if (key === "image") {
-          if (line.image) setImage(el, line.image.url, line.image.altText || line.title);
+          if (line.image) setImage(el, line.image.url, line.image.altText || line.title || "");
           return;
         }
         const text = ownValue(texts, key);
@@ -551,15 +313,28 @@
     });
   }
 
-  // src/account/order-list.js
+  // src/account/order-list.ts
   var DEFAULT_ORDER_COUNT = 10;
+  var MAX_ORDER_COUNT = 50;
+  var isOrderCount = (value) => typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= MAX_ORDER_COUNT;
+  function listLimit(limit) {
+    const asked = Number.parseInt(limit || String(DEFAULT_ORDER_COUNT), 10) || DEFAULT_ORDER_COUNT;
+    return Math.min(Math.max(asked, 1), MAX_ORDER_COUNT);
+  }
+  var numericId = (gid) => gid.replace(/\?.*$/, "").replace(/^.*\//, "");
+  function orderUrl(order2) {
+    const template = cfg.account?.orderUrl;
+    if (template) return template.replaceAll("{id}", encodeURIComponent(numericId(order2.id)));
+    const statusPage = order2.statusPageUrl;
+    return statusPage !== null && isHttpsUrl(statusPage) ? statusPage : null;
+  }
   var orderTexts = (order2) => ({
-    name: order2.name,
-    date: localDate(order2.processedAt),
+    name: order2.name ?? "",
+    date: formatDate(order2.processedAt),
     total: formatMoney(order2.totalPrice),
     status: order2.financialStatus?.toLowerCase(),
     fulfillment: order2.fulfillmentStatus?.toLowerCase(),
-    items: order2.lineItems.nodes.map((line) => `${line.quantity}\xD7 ${line.title}`).join(", ")
+    items: order2.lineItems.nodes.map((line) => `${String(line.quantity)}\xD7 ${line.title ?? ""}`).join(", ")
   });
   function fillOrder(node, order2) {
     const lines = order2.lineItems.nodes;
@@ -589,80 +364,70 @@
     const first = lists[0];
     if (!first) return;
     showIn(root, "show", { "orders-loading": true, "orders-empty": false });
-    const limit = Number.parseInt(get(first, "limit") || String(DEFAULT_ORDER_COUNT), 10) || DEFAULT_ORDER_COUNT;
-    const orders2 = await loadOrders(limit).catch((error) => {
+    const limit = listLimit(get(first, "limit"));
+    let orders2;
+    try {
+      orders2 = await loadOrders(limit);
+    } catch (error) {
       reportError(error, "orders");
-      return null;
-    });
+      orders2 = null;
+    }
     showIn(root, "show", { "orders-loading": false, "orders-empty": orders2?.length === 0 });
     lists.forEach((list) => {
       repeat(list, orders2 ?? [], fillOrder);
     });
   }
 
-  // src/account.js
+  // src/account.ts
   var PAGE_ATTRIBUTES = ["order", "addresses", "subscriptions", "profile-form", "address-form"];
-  function isLoggedIn() {
-    return serverBase() ? isServerLoggedIn() : hasBrowserLogin();
-  }
-  async function login({ returnTo = window.location.href, locale } = {}) {
-    if (serverBase()) serverLoginRedirect({ returnTo, locale });
-    else await browserLoginRedirect({ returnTo, locale });
-  }
-  async function query2(document2, variables = {}) {
-    if (serverBase()) {
-      throw new TetherError("Customer accounts in server mode only answer customer() and orders()", {
-        code: "NOT_ALLOWED"
-      });
-    }
-    return query(document2, variables);
+  var isLoggedIn = isServerLoggedIn;
+  function login({
+    returnTo = window.location.href,
+    locale
+  } = {}) {
+    return new Promise((resolve) => {
+      serverLoginRedirect({ returnTo, locale });
+      resolve();
+    });
   }
   async function customer() {
-    if (!serverBase()) return browserCustomer();
     const me = await serverLogin();
-    if (!me.loggedIn) return null;
-    return {
-      ...me.customer,
-      emailAddress: { emailAddress: me.customer.email },
-      defaultAddress: { formatted: me.customer.address }
-    };
+    return me.loggedIn ? me.customer : null;
   }
-  async function orders({ first = 10 } = {}) {
-    if (serverBase()) {
-      const answer = await serverFetch(`/orders?first=${first}`);
-      if (answer.kind === "logged-out") return [];
-      const list = answer.data["orders"];
-      return Array.isArray(list) ? (
-        /** @type {AccountOrder[]} */
-        list
-      ) : [];
+  async function orders({ first = DEFAULT_ORDER_COUNT } = {}) {
+    if (!isOrderCount(first)) {
+      throw new TetherError(`Customer accounts: orders() takes first from 1 to ${String(MAX_ORDER_COUNT)}`, {
+        code: "INVALID"
+      });
     }
-    const data = await query(ORDERS_QUERY, { first });
-    return data.customer?.orders.nodes ?? [];
+    const answer = await serverFetch(`/orders?${new URLSearchParams({ first: String(first) }).toString()}`);
+    return answer.kind === "logged-out" ? [] : toAccountOrders(answer.data["orders"]);
   }
-  async function logout({ returnTo = cfg.account?.logoutUrl || `${window.location.origin}/` } = {}) {
-    const outcome = serverBase() ? await serverLogout(returnTo) : await browserLogout(returnTo);
-    if (outcome === "stayed") await render(document);
+  async function logout({
+    returnTo = cfg.account?.logoutUrl || `${window.location.origin}/`
+  } = {}) {
+    if (await serverLogout(returnTo) === "stayed") await render(document);
   }
   async function loginState() {
     try {
-      if (serverBase()) return (await serverLogin()).loggedIn ? { kind: "logged-in" } : { kind: "logged-out" };
-      if (hasBrowserLogin() || await getToken()) return { kind: "logged-in" };
-      return { kind: "logged-out" };
+      return (await serverLogin()).loggedIn ? { kind: "logged-in" } : { kind: "logged-out" };
     } catch (error) {
       return { kind: "unknown", error };
     }
   }
   var usesPages = (root) => PAGE_ATTRIBUTES.some((name) => qsa(root, sel(name)).length > 0);
   function linkShopifyPages(root) {
-    const account = cfg.account;
     qsa(root, sel("account-link")).forEach((link) => {
-      const page = get(link, "account-link");
-      const subscriptions2 = account?.subscriptionsUrl;
-      const url = page === "payment" && (account?.paymentUrl || subscriptions2) || page === "subscriptions" && subscriptions2;
-      link.setAttribute("href", url || `https://${cfg.domain}/account`);
+      link.setAttribute("href", shopifyPageUrl(get(link, "account-link")));
     });
   }
+  function shopifyPageUrl(page) {
+    const account = cfg.account;
+    const fallback = `https://${cfg.domain}/account`;
+    if (page === "payment") return account?.paymentUrl || account?.subscriptionsUrl || fallback;
+    if (page === "subscriptions") return account?.subscriptionsUrl || fallback;
+    return fallback;
+  }
   async function render(root = document) {
     const state = await loginState();
     if (state.kind === "unknown") reportError(state.error, "account");
@@ -687,16 +452,20 @@
   async function bindCustomer(root) {
     const binds = qsa(root, sel("account-bind"));
     if (!binds.length) return;
-    const profile = await customer().catch((error) => {
+    let profile;
+    try {
+      profile = await customer();
+    } catch (error) {
       reportError(error, "account");
-      return null;
-    });
+      return;
+    }
+    if (!profile) return;
     const texts = {
-      "first-name": profile?.firstName,
-      "last-name": profile?.lastName,
-      name: profile?.displayName,
-      email: profile?.emailAddress?.emailAddress,
-      address: profile?.defaultAddress?.formatted?.join(", ")
+      "first-name": profile.firstName,
+      "last-name": profile.lastName,
+      name: profile.displayName,
+      email: profile.emailAddress?.emailAddress,
+      address: profile.defaultAddress?.formatted.join(", ")
     };
     binds.forEach((el) => {
       const text = ownValue(texts, get(el, "account-bind") ?? "");
@@ -706,17 +475,7 @@
   var pagesPart = null;
   function pages() {
     pagesPart ?? (pagesPart = loadPart("account-pages").then((part) => {
-      part.setup({
-        serverBase,
-        serverFetch,
-        query: query2,
-        customer,
-        bindCustomer,
-        reset: () => {
-          forgetBrowserCustomer();
-          forgetServerLogin();
-        }
-      });
+      part.setup({ serverFetch, customer, bindCustomer, reset: forgetServerLogin });
       return part;
     }));
     return pagesPart;
@@ -744,46 +503,48 @@
       });
     }
   }
-  function startServerMode() {
+  function finishServerLogin() {
     const url = new URL(window.location.href);
-    if (url.searchParams.get("account")) {
-      url.searchParams.delete("account");
-      window.history.replaceState(window.history.state, "", url);
-      emit("account-login", {});
-    }
-    Cart.setCustomer({ beforeCheckout: serverCheckoutUrl });
-  }
-  async function startBrowserMode() {
-    try {
-      await handleCallback();
-    } catch (error) {
-      reportError(error, "login");
-    }
-    if (Cart.customerAccessToken) return;
-    try {
-      const accessToken2 = await getToken();
-      if (accessToken2) Cart.setCustomer({ accessToken: accessToken2 });
-    } catch (error) {
-      reportError(error, "account");
+    const outcome = url.searchParams.get("account");
+    if (!isLoginOutcome(outcome)) return;
+    url.searchParams.delete("account");
+    window.history.replaceState(window.history.state, "", url);
+    switch (outcome) {
+      case "in":
+        emit("account-login", {});
+        break;
+      case "expired":
+      case "error":
+        emit("account-error", { error: outcome });
+        break;
     }
   }
   var started = false;
   async function mountAccount(root = document) {
-    if (!started) {
-      started = true;
-      document.addEventListener("click", onClick);
-      if (serverBase()) startServerMode();
-      else await startBrowserMode();
-      log("account", isLoggedIn() ? "logged in" : "logged out");
+    if (started) {
+      await render(root);
+      return;
     }
+    started = true;
+    document.addEventListener("click", onClick);
+    finishServerLogin();
+    Cart.setCheckoutResolver(serverCheckoutUrl);
     await render(root);
+    log("account", isLoggedIn() ? "logged in" : "logged out");
+  }
+
+  // src/part-registry.ts
+  function isTetherInternals(value) {
+    return isRecord(value) && isRecord(value["__core"]) && isRecord(value["__parts"]);
+  }
+  function registerPart(name, part) {
+    const tether = Reflect.get(window, "Tether");
+    if (!isTetherInternals(tether)) {
+      throw new Error(`tether.${name}.js runs after the Tether script, which loads it, and needs its window.Tether`);
+    }
+    tether.__parts[name] = part;
   }
 
-  // src/parts/account.js
-  var { Tether } = (
-    /** @type {Window & { Tether?: { __parts: Record<string, unknown> } }} */
-    window
-  );
-  if (!Tether) throw new Error("tether.account.js runs after the Tether script, which loads it");
-  Tether.__parts["account"] = account_exports;
+  // src/parts/account.ts
+  registerPart("account", account_exports);
 })();