@occluze/tether 0.6.7 → 0.7.0

package/dist/tether.account-pages.js

@@ -5,7 +5,7 @@
       __defProp(target, name, { get: all[name], enumerable: true });
   };
 
-  // src/account-pages.js
+  // src/account-pages.ts
   var account_pages_exports = {};
   __export(account_pages_exports, {
     addresses: () => addresses,
@@ -15,578 +15,864 @@
     requestReturn: () => requestReturn,
     saveAddress: () => saveAddress,
     setup: () => setup,
+    showUnavailable: () => showUnavailable,
     subscriptionAction: () => subscriptionAction,
     subscriptions: () => subscriptions,
     updateProfile: () => updateProfile
   });
 
-  // tether-core:config.js
-  var m = window.Tether.__core["config.js"];
-  var { DEFAULTS, cfg, configure, isConfigured, log, reportError, 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:dom.ts
+  var m2 = 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] = m2;
 
-  // tether-core:dom.js
-  var m3 = window.Tether.__core["dom.js"];
-  var { attr, busy, cdnUrl, dataKey, emit, formatDate, formatMoney, formatPercent, get, has, hasTemplate, imageUrl, notifyLayoutChanged, parseJSONAttr, productUrl, qsa, readText, repeat, repeatKeyed, sameImage, scoped, sel, setImage, setSelected, setText, setTextTracked, show, toAttributes, watchImages } = m3;
+  // tether-core:client.ts
+  var m3 = window.Tether.__core["client.ts"];
+  var [endpoint, gql, orNull, shaped, TetherError] = m3;
 
-  // server/src/account-ops.js
-  var MONEY = "amount currencyCode";
-  var ADDRESS = "id firstName lastName company address1 address2 city province zoneCode zip country countryCode phoneNumber formatted";
-  var Q = {
-    order: `query TetherOrder($id:ID!){order(id:$id){id name number processedAt cancelledAt financialStatus fulfillmentStatus statusPageUrl requiresShipping totalPrice{${MONEY}}subtotal{${MONEY}}totalShipping{${MONEY}}totalTax{${MONEY}}shippingAddress{${ADDRESS}}billingAddress{${ADDRESS}}lineItems(first:50){nodes{id name title variantTitle quantity sku image{url altText}price{${MONEY}}totalPrice{${MONEY}}suggestedReturnReasonDefinitions(first:10){nodes{id name handle}}}}fulfillments(first:10){nodes{id status createdAt estimatedDeliveryAt latestShipmentStatus trackingInformation{company number url}}}returnInformation{returnableLineItems(first:50){nodes{quantity lineItem{id}}}}returns(first:10){nodes{id status}}}}`,
-    addresses: `query TetherAddresses{customer{defaultAddress{id}addresses(first:20){nodes{${ADDRESS}}}}}`,
-    subscriptions: `query TetherSubscriptions{customer{subscriptionContracts(first:20,reverse:true){nodes{id status nextBillingDate currencyCode deliveryPrice{${MONEY}}deliveryPolicy{interval intervalCount{count}}lines(first:20){nodes{id name title variantTitle quantity sku currentPrice{${MONEY}}lineDiscountedPrice{${MONEY}}image{url altText}}}upcomingBillingCycles(first:3){nodes{cycleIndex skipped billingAttemptExpectedDate}}}}}}`,
-    contract: `query TetherContract($id:ID!){customer{subscriptionContract(id:$id){id status upcomingBillingCycles(first:3){nodes{cycleIndex skipped}}}}}`
-  };
-  var M = {
-    profile: "mutation TetherProfile($input: CustomerUpdateInput!) { customerUpdate(input: $input) { customer { firstName lastName } userErrors { field message } } }",
-    addressCreate: `mutation TetherAddressCreate($address:CustomerAddressInput!,$default:Boolean){customerAddressCreate(address:$address,defaultAddress:$default){customerAddress{${ADDRESS}}userErrors{field message}}}`,
-    addressUpdate: `mutation TetherAddressUpdate($id:ID!,$address:CustomerAddressInput,$default:Boolean){customerAddressUpdate(addressId:$id,address:$address,defaultAddress:$default){customerAddress{${ADDRESS}}userErrors{field message}}}`,
-    addressDelete: "mutation TetherAddressDelete($id: ID!) { customerAddressDelete(addressId: $id) { deletedAddressId userErrors { field message } } }",
-    pause: "mutation TetherPause($id: ID!) { subscriptionContractPause(subscriptionContractId: $id) { contract { id status } userErrors { field message } } }",
-    resume: "mutation TetherResume($id: ID!) { subscriptionContractActivate(subscriptionContractId: $id) { contract { id status } userErrors { field message } } }",
-    cancel: "mutation TetherCancel($id: ID!) { subscriptionContractCancel(subscriptionContractId: $id) { contract { id status } userErrors { field message } } }",
-    skip: "mutation TetherSkip($input: SubscriptionBillingCycleInput!) { subscriptionBillingCycleSkip(billingCycleInput: $input) { billingCycle { cycleIndex skipped } userErrors { field message } } }",
-    unskip: "mutation TetherUnskip($input: SubscriptionBillingCycleInput!) { subscriptionBillingCycleUnskip(billingCycleInput: $input) { billingCycle { cycleIndex skipped } userErrors { field message } } }",
-    returnRequest: "mutation TetherReturn($orderId: ID!, $lines: [RequestedLineItemInput!]!) { orderRequestReturn(orderId: $orderId, requestedLineItems: $lines) { return { id status } userErrors { field message } } }"
-  };
-  var InputError = class extends Error {
-  };
-  var gid = (type) => new RegExp(`^gid://shopify/${type}/\\d+(\\?[\\w=&.-]{1,80})?$`);
-  var IDS = {
-    Order: gid("Order"),
-    CustomerAddress: gid("CustomerAddress"),
-    SubscriptionContract: gid("SubscriptionContract"),
-    LineItem: gid("LineItem"),
-    ReturnReasonDefinition: gid("ReturnReasonDefinition")
-  };
-  function idOf(type, value) {
-    const v = /^\d{1,20}$/.test(String(value ?? "")) ? `gid://shopify/${type}/${value}` : String(value ?? "");
-    if (!IDS[type].test(v)) throw new InputError(`${type} id`);
-    return v;
-  }
-  var text = (v, max = 255) => {
-    if (v == null || v === "") return void 0;
-    if (typeof v !== "string" && typeof v !== "number") throw new InputError("text");
-    const s = String(v).replace(/[\u0000-\u001f\u007f]/g, "").trim();
-    if (s.length > max) throw new InputError("too long");
-    return s;
-  };
-  var ADDRESS_FIELDS = ["firstName", "lastName", "company", "address1", "address2", "city", "zip", "zoneCode", "phoneNumber"];
-  function addressInput(a = {}, { clear = false } = {}) {
-    if (!a || typeof a !== "object" || Array.isArray(a)) throw new InputError("address");
-    const out = {};
-    ADDRESS_FIELDS.forEach((k) => {
-      const v = text(a[k]);
-      if (v !== void 0) out[k] = v;
-      else if (clear && k in a && (a[k] === "" || a[k] === null)) out[k] = "";
-    });
-    if (a.countryCode != null && a.countryCode !== "") {
-      const c = String(a.countryCode).toUpperCase();
-      if (!/^[A-Z]{2}$/.test(c)) throw new InputError("countryCode");
-      out.countryCode = c;
-    }
-    return out;
-  }
-  var userErrors = (payload) => {
-    const errs = payload?.userErrors || [];
-    if (errs.length) {
-      const e = new InputError(errs.map((x) => x.message).join(" | "));
-      e.userErrors = errs;
-      throw e;
-    }
-    return payload;
-  };
-  var ops = {
-    async order(ask, { id }) {
-      const data = await ask(Q.order, { id: idOf("Order", id) });
-      return { order: data?.order || null };
-    },
-    async profile(ask, { firstName, lastName }) {
-      const input = {};
-      if (firstName !== void 0) input.firstName = text(firstName, 100) ?? "";
-      if (lastName !== void 0) input.lastName = text(lastName, 100) ?? "";
-      if (!Object.keys(input).length) throw new InputError("nothing to change");
-      const p = userErrors((await ask(M.profile, { input }))?.customerUpdate);
-      return { customer: p.customer };
-    },
-    async addresses(ask) {
-      const c = (await ask(Q.addresses, {}))?.customer;
-      const def = c?.defaultAddress?.id || null;
-      return { addresses: (c?.addresses?.nodes || []).map((a) => ({ ...a, isDefault: a.id === def })) };
-    },
-    async saveAddress(ask, { id, address, isDefault }) {
-      const a = addressInput(address || {}, { clear: Boolean(id) });
-      const def = isDefault === true ? true : void 0;
-      const p = id ? userErrors((await ask(M.addressUpdate, { id: idOf("CustomerAddress", id), address: Object.keys(a).length ? a : null, default: def ?? null }))?.customerAddressUpdate) : userErrors((await ask(M.addressCreate, { address: a, default: def ?? false }))?.customerAddressCreate);
-      return { address: p.customerAddress };
-    },
-    async deleteAddress(ask, { id }) {
-      const p = userErrors((await ask(M.addressDelete, { id: idOf("CustomerAddress", id) }))?.customerAddressDelete);
-      return { deleted: p.deletedAddressId };
+  // server/src/shared/account-routes.ts
+  var OPERATION_ROUTES = {
+    order: { name: "order", method: "GET", path: "/order", fields: { id: true } },
+    addresses: { name: "addresses", method: "GET", path: "/addresses", fields: {} },
+    subscriptions: { name: "subscriptions", method: "GET", path: "/subscriptions", fields: {} },
+    profile: { name: "profile", method: "POST", path: "/profile", fields: { firstName: true, lastName: true } },
+    saveAddress: {
+      name: "saveAddress",
+      method: "POST",
+      path: "/address",
+      fields: { id: true, address: true, isDefault: true }
     },
-    async subscriptions(ask) {
-      return { subscriptions: (await ask(Q.subscriptions, {}))?.customer?.subscriptionContracts?.nodes || [] };
-    },
-    async subscription(ask, { id, action }) {
-      if (!["pause", "resume", "skip", "unskip", "cancel"].includes(action)) throw new InputError("action");
-      const contractId = idOf("SubscriptionContract", id);
-      const contract = (await ask(Q.contract, { id: contractId }))?.customer?.subscriptionContract;
-      if (!contract) {
-        const e = new InputError("not found");
-        e.status = 404;
-        throw e;
-      }
-      if (action === "skip" || action === "unskip") {
-        const cycles = contract.upcomingBillingCycles?.nodes || [];
-        const cycle = action === "skip" ? cycles.find((c) => !c.skipped) : cycles.find((c) => c.skipped);
-        if (!cycle) throw new InputError(action === "skip" ? "no upcoming delivery to skip" : "nothing skipped");
-        const p2 = userErrors((await ask(M[action], { input: { contractId, selector: { index: cycle.cycleIndex } } }))?.[action === "skip" ? "subscriptionBillingCycleSkip" : "subscriptionBillingCycleUnskip"]);
-        return { billingCycle: p2.billingCycle };
-      }
-      const name = { pause: "subscriptionContractPause", resume: "subscriptionContractActivate", cancel: "subscriptionContractCancel" }[action];
-      const p = userErrors((await ask(M[action], { id: contractId }))?.[name]);
-      return { contract: p.contract };
-    },
-    async requestReturn(ask, { orderId, lines: lines2 }) {
-      const oid = idOf("Order", orderId);
-      if (!Array.isArray(lines2) || !lines2.length || lines2.length > 50) throw new InputError("lines");
-      const requested = lines2.map((l) => {
-        const q = Number(l?.quantity);
-        if (!Number.isInteger(q) || q < 1 || q > 1e3) throw new InputError("quantity");
-        const out = { lineItemId: idOf("LineItem", l.lineItemId), quantity: q };
-        if (l.reasonId) out.returnReasonDefinitionId = idOf("ReturnReasonDefinition", l.reasonId);
-        const note = text(l.note, 300);
-        if (note) out.customerNote = note;
-        return out;
-      });
-      const p = userErrors((await ask(M.returnRequest, { orderId: oid, lines: requested }))?.orderRequestReturn);
-      return { return: p.return };
-    }
+    deleteAddress: { name: "deleteAddress", method: "POST", path: "/address/delete", fields: { id: true } },
+    subscription: { name: "subscription", method: "POST", path: "/subscription", fields: { id: true, action: true } },
+    requestReturn: { name: "requestReturn", method: "POST", path: "/return", fields: { orderId: true, lines: true } }
   };
+  var ROUTE_BY_REQUEST = new Map(
+    Object.values(OPERATION_ROUTES).map((route) => [
+      `${route.method} ${route.path}`,
+      { ...route, fields: Object.keys(route.fields) }
+    ])
+  );
+  function operationRequest(name, input) {
+    const route = OPERATION_ROUTES[name];
+    if (route.method === "POST") return { method: "POST", path: route.path };
+    const values = input;
+    const query = new URLSearchParams();
+    for (const fieldName of Object.keys(route.fields)) {
+      const value = values[fieldName];
+      if (typeof value === "string" || typeof value === "number") query.set(fieldName, String(value));
+    }
+    const search = query.toString();
+    return { method: "GET", path: search ? `${route.path}?${search}` : route.path };
+  }
 
-  // src/account-pages.js
-  var ctx = null;
-  var bound = false;
-  function setup(c) {
-    ctx = c;
+  // server/src/shared/json.ts
+  function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
   }
-  var https = (u) => {
-    try {
-      return new URL(u).protocol === "https:";
-    } catch {
-      return false;
-    }
-  };
-  var date = (s) => {
-    try {
-      return new Date(s).toLocaleDateString(cfg.locale || void 0);
-    } catch {
-      return s;
-    }
-  };
-  var ROUTE = {
-    order: (i) => ["GET", `/order?id=${encodeURIComponent(i.id)}`],
-    addresses: () => ["GET", "/addresses"],
-    subscriptions: () => ["GET", "/subscriptions"],
-    profile: () => ["POST", "/profile"],
-    saveAddress: () => ["POST", "/address"],
-    deleteAddress: () => ["POST", "/address/delete"],
-    subscription: () => ["POST", "/subscription"],
-    requestReturn: () => ["POST", "/return"]
-  };
-  async function run(name, input = {}) {
-    const { server, serverFetch, query } = ctx;
-    if (server()) {
-      const [method, path] = ROUTE[name](input);
-      const data = await serverFetch(path, method === "POST" ? { method, body: input } : {});
-      if (data.loggedIn === false) throw new TetherError("Not logged in", { code: "NOT_LOGGED_IN", status: 401 });
-      return data;
+  function field(value, key) {
+    return isRecord(value) ? value[key] : void 0;
+  }
+  function asList(value) {
+    return Array.isArray(value) ? value : [];
+  }
+  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);
+
+  // 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"))
+  });
+
+  // src/account/answers.ts
+  var unexpected = (what) => new TetherError(`Customer accounts: the answer has no ${what}`);
+  function requiredId(value, what) {
+    const id = textOrNull(value);
+    if (!id) throw unexpected(what);
+    return id;
+  }
+
+  // src/account/page-answers.ts
+  function toMailingAddress(value) {
+    const text = (name) => textOrNull(field(value, name));
+    return {
+      id: text("id"),
+      firstName: text("firstName"),
+      lastName: text("lastName"),
+      company: text("company"),
+      address1: text("address1"),
+      address2: text("address2"),
+      city: text("city"),
+      province: text("province"),
+      zoneCode: text("zoneCode"),
+      zip: text("zip"),
+      country: text("country"),
+      countryCode: text("countryCode"),
+      phoneNumber: text("phoneNumber"),
+      formatted: textList(field(value, "formatted"))
+    };
+  }
+  var mailingAddressOrNull = (value) => isRecord(value) ? toMailingAddress(value) : null;
+  var toAccountAddress = (value) => ({
+    ...toMailingAddress(value),
+    id: requiredId(field(value, "id"), "address id")
+  });
+  var toCustomerAddresses = (value) => listOf(value, (address) => ({ ...toAccountAddress(address), isDefault: field(address, "isDefault") === true }));
+  var toOrderDetailLine = (value) => ({
+    ...toOrderLine(value),
+    id: requiredId(field(value, "id"), "line item id"),
+    name: textOrNull(field(value, "name")),
+    sku: textOrNull(field(value, "sku")),
+    price: moneyOrNull(field(value, "price")),
+    totalPrice: moneyOrNull(field(value, "totalPrice")),
+    suggestedReturnReasonDefinitions: nodesOf(field(value, "suggestedReturnReasonDefinitions"), (reason) => ({
+      id: requiredId(field(reason, "id"), "return reason id"),
+      name: textOrNull(field(reason, "name")),
+      handle: textOrNull(field(reason, "handle"))
+    }))
+  });
+  var toFulfillment = (value) => ({
+    id: textOrNull(field(value, "id")),
+    status: textOrNull(field(value, "status")),
+    createdAt: textOrNull(field(value, "createdAt")),
+    estimatedDeliveryAt: textOrNull(field(value, "estimatedDeliveryAt")),
+    latestShipmentStatus: textOrNull(field(value, "latestShipmentStatus")),
+    trackingInformation: listOf(field(value, "trackingInformation"), (tracking) => ({
+      company: textOrNull(field(tracking, "company")),
+      number: textOrNull(field(tracking, "number")),
+      url: textOrNull(field(tracking, "url"))
+    }))
+  });
+  function toReturnableLine(value) {
+    const lineId = textOrNull(field(field(value, "lineItem"), "id"));
+    return { quantity: countOrZero(field(value, "quantity")), lineItem: lineId === null ? null : { id: lineId } };
+  }
+  function toReturnInformation(value) {
+    if (!isRecord(value)) return null;
+    return { returnableLineItems: nodesOf(value["returnableLineItems"], toReturnableLine) };
+  }
+  function toOrderDetail(value) {
+    if (!isRecord(value)) return null;
+    const text = (name) => textOrNull(value[name]);
+    const money = (name) => moneyOrNull(value[name]);
+    const requiresShipping = value["requiresShipping"];
+    return {
+      id: requiredId(value["id"], "order id"),
+      name: text("name"),
+      number: numberOrNull(value["number"]),
+      processedAt: text("processedAt"),
+      cancelledAt: text("cancelledAt"),
+      financialStatus: text("financialStatus"),
+      fulfillmentStatus: text("fulfillmentStatus"),
+      statusPageUrl: text("statusPageUrl"),
+      requiresShipping: typeof requiresShipping === "boolean" ? requiresShipping : null,
+      totalPrice: money("totalPrice"),
+      subtotal: money("subtotal"),
+      totalShipping: money("totalShipping"),
+      totalTax: money("totalTax"),
+      shippingAddress: mailingAddressOrNull(value["shippingAddress"]),
+      billingAddress: mailingAddressOrNull(value["billingAddress"]),
+      lineItems: nodesOf(value["lineItems"], toOrderDetailLine),
+      fulfillments: nodesOf(value["fulfillments"], toFulfillment),
+      returnInformation: toReturnInformation(value["returnInformation"]),
+      returns: nodesOf(value["returns"], toReturn)
+    };
+  }
+  var toSubscriptionLine = (value) => ({
+    id: textOrNull(field(value, "id")),
+    name: textOrNull(field(value, "name")),
+    title: textOrNull(field(value, "title")),
+    variantTitle: textOrNull(field(value, "variantTitle")),
+    quantity: countOrZero(field(value, "quantity")),
+    sku: textOrNull(field(value, "sku")),
+    currentPrice: moneyOrNull(field(value, "currentPrice")),
+    lineDiscountedPrice: moneyOrNull(field(value, "lineDiscountedPrice")),
+    image: imageOrNull(field(value, "image"))
+  });
+  var toBillingCycle = (value) => ({
+    cycleIndex: numberOrNull(field(value, "cycleIndex")),
+    skipped: field(value, "skipped") === true,
+    billingAttemptExpectedDate: textOrNull(field(value, "billingAttemptExpectedDate"))
+  });
+  function toDeliveryPolicy(value) {
+    if (!isRecord(value)) return null;
+    const intervalCount = value["intervalCount"];
+    return {
+      interval: textOrNull(value["interval"]),
+      intervalCount: isRecord(intervalCount) ? { count: countOrZero(intervalCount["count"]) } : null
+    };
+  }
+  var toSubscriptionContract = (value) => ({
+    id: requiredId(field(value, "id"), "subscription id"),
+    status: textOrNull(field(value, "status")),
+    nextBillingDate: textOrNull(field(value, "nextBillingDate")),
+    currencyCode: textOrNull(field(value, "currencyCode")),
+    deliveryPrice: moneyOrNull(field(value, "deliveryPrice")),
+    deliveryPolicy: toDeliveryPolicy(field(value, "deliveryPolicy")),
+    lines: nodesOf(field(value, "lines"), toSubscriptionLine),
+    upcomingBillingCycles: nodesOf(field(value, "upcomingBillingCycles"), toBillingCycle)
+  });
+  var toSubscriptionContracts = (value) => listOf(value, toSubscriptionContract);
+  function toSubscriptionChange(result) {
+    const { contract, billingCycle } = result;
+    if (isRecord(contract)) {
+      return { contract: { id: textOrNull(contract["id"]), status: textOrNull(contract["status"]) } };
     }
-    try {
-      return await ops[name]((q, v) => query(q, v), input);
-    } catch (err) {
-      if (err instanceof InputError) throw new TetherError(err.message, { code: "INVALID", userErrors: err.userErrors });
-      throw err;
+    if (isRecord(billingCycle)) {
+      const { cycleIndex, skipped } = toBillingCycle(billingCycle);
+      return { billingCycle: { cycleIndex, skipped } };
     }
+    throw unexpected("changed subscription");
+  }
+  function toReturn(value) {
+    return { id: requiredId(field(value, "id"), "return id"), status: textOrNull(field(value, "status")) };
   }
-  var changed = (what) => {
-    ctx.reset();
+  var toDeletedId = (value) => requiredId(value, "deleted address id");
+  var toProfile = (value) => ({
+    firstName: textOrNull(field(value, "firstName")),
+    lastName: textOrNull(field(value, "lastName"))
+  });
+
+  // src/account/operations.ts
+  var context = null;
+  function setup(shared) {
+    context = shared;
+  }
+  function pagesContext() {
+    if (!context) throw new Error("account-pages: loaded without the account part");
+    return context;
+  }
+  async function run(name, input) {
+    const { serverFetch } = pagesContext();
+    const { method, path } = operationRequest(name, input);
+    const answer = await serverFetch(path, method === "POST" ? { method, body: input } : {});
+    if (answer.kind === "logged-out") throw new TetherError("Not logged in", { code: "NOT_LOGGED_IN", status: 401 });
+    return answer.data;
+  }
+  function changed(what) {
+    pagesContext().reset();
     emit("account-updated", { what });
-  };
-  var order = (id) => run("order", { id }).then((r) => r.order);
-  var updateProfile = ({ firstName, lastName } = {}) => run("profile", { firstName, lastName }).then((r) => {
+  }
+  async function order(id) {
+    const result = await run("order", { id });
+    return toOrderDetail(result["order"]);
+  }
+  async function updateProfile({
+    firstName,
+    lastName
+  } = {}) {
+    const result = await run("profile", { firstName, lastName });
     changed("profile");
-    return r.customer;
-  });
-  var addresses = () => run("addresses").then((r) => r.addresses);
-  var saveAddress = (address, { id, isDefault } = {}) => run("saveAddress", { id, address, isDefault }).then((r) => {
+    return toProfile(result["customer"]);
+  }
+  async function addresses() {
+    const result = await run("addresses", {});
+    return toCustomerAddresses(result["addresses"]);
+  }
+  async function saveAddress(address, { id, isDefault } = {}) {
+    const result = await run("saveAddress", { id, address, isDefault });
     changed("addresses");
-    return r.address;
-  });
-  var deleteAddress = (id) => run("deleteAddress", { id }).then((r) => {
+    return toAccountAddress(result["address"]);
+  }
+  async function deleteAddress(id) {
+    const result = await run("deleteAddress", { id });
     changed("addresses");
-    return r.deleted;
-  });
-  var subscriptions = () => run("subscriptions").then((r) => r.subscriptions);
-  var subscriptionAction = (id, action) => run("subscription", { id, action }).then((r) => {
+    return toDeletedId(result["deleted"]);
+  }
+  async function subscriptions() {
+    const result = await run("subscriptions", {});
+    return toSubscriptionContracts(result["subscriptions"]);
+  }
+  async function subscriptionAction(id, action) {
+    const result = await run("subscription", { id, action });
     changed("subscriptions");
-    return r;
-  });
-  var requestReturn = (orderId, lines2) => run("requestReturn", { orderId, lines: lines2 }).then((r) => {
+    return toSubscriptionChange(result);
+  }
+  async function requestReturn(orderId, lines) {
+    const result = await run("requestReturn", { orderId, lines });
     changed("orders");
-    return r.return;
-  });
-  var lower = (v) => v ? String(v).toLowerCase().replace(/_/g, " ") : "";
-  var lines = (a) => (a?.formatted || []).join(", ");
-  var showIn = (root, name, conds) => qsa(root, sel(name)).forEach((el) => {
-    const k = get(el, name);
-    if (k in conds) show(el, Boolean(conds[k]));
+    return toReturn(result["return"]);
+  }
+
+  // tether-core:shopify-values.ts
+  var m4 = window.Tether.__core["shopify-values.ts"];
+  var [isHttpsUrl] = m4;
+
+  // src/account/markup.ts
+  function showIn(root, name, conditions) {
+    qsa(root, sel(name)).forEach((el) => {
+      const key = get(el, name) ?? "";
+      if (Object.hasOwn(conditions, key)) show(el, conditions[key] === true);
+    });
+  }
+  var bindsIn = (row, name) => qsa(row, sel(name)).concat(row.matches(sel(name)) ? [row] : []);
+  var enumText = (value) => value ? value.toLowerCase().replace(/_/g, " ") : "";
+  var addressText = (address) => (address?.formatted ?? []).join(", ");
+  var ownValue = (values, key) => Object.hasOwn(values, key) ? values[key] : void 0;
+
+  // src/account/order-lines.ts
+  var lineTexts = (line, returnable) => ({
+    title: line.title || line.name || "",
+    "variant-title": line.variantTitle || "",
+    quantity: String(line.quantity),
+    price: formatMoney(line.price),
+    total: formatMoney(line.totalPrice),
+    sku: line.sku || "",
+    returnable: returnable === null ? void 0 : String(returnable)
   });
-  var showGlobal = (root, conds) => showIn(root, "show", conds);
-  function fillLines(box, items, returnable = null) {
-    repeat(box, items, (row, l) => {
-      const can = returnable ? returnable.get(l.id) || 0 : 0;
-      row.dataset.tetherLine = l.id;
-      qsa(row, sel("order-line")).concat(row.matches(sel("order-line")) ? [row] : []).forEach((el) => {
-        const k = get(el, "order-line");
-        if (k === "image") {
-          if (l.image) setImage(el, l.image.url, l.image.altText || l.title);
-          return;
-        }
-        const v = { title: l.title || l.name, "variant-title": l.variantTitle || "", quantity: String(l.quantity), price: l.price ? formatMoney(l.price) : "", total: l.totalPrice ? formatMoney(l.totalPrice) : "", sku: l.sku || "", returnable: String(can) }[k];
-        if (v != null) setText(el, v);
-      });
-      showIn(row, "order-line-show", { returnable: can > 0 });
-      qsa(row, sel("return-quantity")).forEach((input) => {
-        input.max = String(can);
-        input.min = "0";
-        if (!input.value) input.value = "0";
-        input.disabled = can < 1;
+  var isInput = (el) => el.tagName === "INPUT";
+  function fillReturnControls(row, line, returnable) {
+    showIn(row, "order-line-show", { returnable: returnable > 0 });
+    qsa(row, sel("return-quantity")).forEach((input) => {
+      if (!isInput(input)) return;
+      input.max = String(returnable);
+      input.min = "0";
+      if (!input.value) input.value = "0";
+      input.disabled = returnable < 1;
+    });
+    qsa(row, `select${sel("return-reason")}`).forEach((select) => {
+      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));
       });
-      qsa(row, `select${sel("return-reason")}`).forEach((select) => {
-        const reasons = l.suggestedReturnReasonDefinitions?.nodes || [];
-        if (select.dataset.tetherFilled !== l.id) {
-          select.dataset.tetherFilled = l.id;
-          reasons.forEach((r) => select.appendChild(new Option(r.name, r.id)));
+    });
+  }
+  function fillLines(box, lines, returns) {
+    repeat(box, lines, (row, line) => {
+      const id = line.id;
+      const returnable = returns && id ? returns.get(id) ?? 0 : null;
+      if (id) row.dataset["tetherLine"] = id;
+      const texts = lineTexts(line, returnable);
+      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 || "");
+          return;
         }
+        const text = ownValue(texts, key);
+        if (text !== void 0) setText(el, text);
       });
+      if (id && returnable !== null) fillReturnControls(row, { ...line, id }, returnable);
     });
   }
-  var SCOPE = { order: sel("order") };
-  async function renderOrder(el) {
+
+  // src/account/order-page.ts
+  function orderKey(el) {
     const raw = get(el, "order") || "";
-    const key = raw.startsWith("url:") ? new URL(window.location.href).searchParams.get(raw.slice(4) || "id") : raw;
-    const state = (s) => el.setAttribute(attr("order-state"), s);
-    if (!key) {
-      state("not-found");
-      showIn(el, "order-show", { "not-found": true });
-      return;
-    }
-    state("loading");
-    showIn(el, "order-show", { loading: true, ready: false, "not-found": false, error: false });
-    let o;
-    try {
-      o = await order(key);
-    } catch (err) {
-      reportError(err, "order");
-      state("error");
-      showIn(el, "order-show", { loading: false, error: true });
-      return;
-    }
-    if (!o) {
-      state("not-found");
-      showIn(el, "order-show", { loading: false, "not-found": true });
-      return;
-    }
-    el.dataset.tetherOrderId = o.id;
-    const returnable = new Map((o.returnInformation?.returnableLineItems?.nodes || []).map((r) => [r.lineItem?.id, r.quantity]));
-    const ships = o.fulfillments?.nodes || [];
-    qsa(el, sel("order-bind")).forEach((b) => {
-      const k = get(b, "order-bind");
-      if (k === "url") {
-        if (https(o.statusPageUrl)) b.setAttribute("href", o.statusPageUrl);
+    if (!raw.startsWith("url:")) return raw;
+    return new URL(window.location.href).searchParams.get(raw.slice("url:".length) || "id");
+  }
+  function showOrderState(el, state) {
+    el.setAttribute(attr("order-state"), state);
+    showIn(el, "order-show", {
+      loading: state === "loading",
+      ready: false,
+      "not-found": state === "not-found",
+      error: state === "error"
+    });
+  }
+  var orderTexts = (detail) => ({
+    name: detail.name ?? "",
+    date: formatDate(detail.processedAt),
+    total: formatMoney(detail.totalPrice),
+    subtotal: formatMoney(detail.subtotal),
+    shipping: formatMoney(detail.totalShipping),
+    tax: formatMoney(detail.totalTax),
+    status: enumText(detail.financialStatus),
+    fulfillment: enumText(detail.fulfillmentStatus),
+    "shipping-address": addressText(detail.shippingAddress),
+    "billing-address": addressText(detail.billingAddress),
+    items: detail.lineItems.nodes.map((line) => `${String(line.quantity)}\xD7 ${line.title || line.name || ""}`).join(", "),
+    cancelled: formatDate(detail.cancelledAt)
+  });
+  function fillFulfillment(row, fulfillment) {
+    const tracking = fulfillment.trackingInformation[0];
+    const texts = {
+      status: enumText(fulfillment.latestShipmentStatus || fulfillment.status),
+      date: formatDate(fulfillment.createdAt),
+      eta: formatDate(fulfillment.estimatedDeliveryAt),
+      company: tracking?.company || "",
+      number: tracking?.number || ""
+    };
+    bindsIn(row, "fulfillment-bind").forEach((el) => {
+      const key = get(el, "fulfillment-bind") ?? "";
+      if (key === "url") {
+        const url = tracking?.url ?? null;
+        const linked = url !== null && isHttpsUrl(url);
+        if (linked) el.setAttribute("href", url);
+        show(el, linked);
         return;
       }
-      const v = {
-        name: o.name,
-        date: date(o.processedAt),
-        total: formatMoney(o.totalPrice),
-        subtotal: o.subtotal ? formatMoney(o.subtotal) : "",
-        shipping: o.totalShipping ? formatMoney(o.totalShipping) : "",
-        tax: o.totalTax ? formatMoney(o.totalTax) : "",
-        status: lower(o.financialStatus),
-        fulfillment: lower(o.fulfillmentStatus),
-        "shipping-address": lines(o.shippingAddress),
-        "billing-address": lines(o.billingAddress),
-        items: (o.lineItems?.nodes || []).map((l) => `${l.quantity}\xD7 ${l.title || l.name}`).join(", "),
-        cancelled: o.cancelledAt ? date(o.cancelledAt) : ""
-      }[k];
-      if (v != null) setText(b, v);
+      const text = ownValue(texts, key);
+      if (text !== void 0) setText(el, text);
     });
-    qsa(el, sel("order-lines")).forEach((box) => fillLines(box, o.lineItems?.nodes || [], returnable));
-    qsa(el, sel("order-fulfillments")).forEach((box) => repeat(box, ships, (row, f) => {
-      const t = f.trackingInformation?.[0] || {};
-      qsa(row, sel("fulfillment-bind")).concat(row.matches(sel("fulfillment-bind")) ? [row] : []).forEach((b) => {
-        const k = get(b, "fulfillment-bind");
-        if (k === "url") {
-          const ok = https(t.url);
-          if (ok) b.setAttribute("href", t.url);
-          show(b, ok);
-          return;
-        }
-        const v = { status: lower(f.latestShipmentStatus || f.status), date: date(f.createdAt), eta: f.estimatedDeliveryAt ? date(f.estimatedDeliveryAt) : "", company: t.company || "", number: t.number || "" }[k];
-        if (v != null) setText(b, v);
-      });
-    }));
+  }
+  function fillOrder(el, detail) {
+    const returnable = new Map(
+      (detail.returnInformation?.returnableLineItems.nodes ?? []).map((entry) => [
+        entry.lineItem?.id ?? "",
+        entry.quantity
+      ])
+    );
+    const shipments = detail.fulfillments.nodes;
+    const texts = orderTexts(detail);
+    qsa(el, sel("order-bind")).forEach((bind) => {
+      const key = get(bind, "order-bind") ?? "";
+      if (key === "url") {
+        const statusPage = detail.statusPageUrl;
+        if (statusPage !== null && isHttpsUrl(statusPage)) bind.setAttribute("href", statusPage);
+        return;
+      }
+      const text = ownValue(texts, key);
+      if (text !== void 0) setText(bind, text);
+    });
+    qsa(el, sel("order-lines")).forEach((box) => {
+      fillLines(box, detail.lineItems.nodes, returnable);
+    });
+    qsa(el, sel("order-fulfillments")).forEach((box) => {
+      repeat(box, shipments, fillFulfillment);
+    });
+    const returnRequested = el.dataset["tetherReturned"] === "1";
     showIn(el, "order-show", {
       loading: false,
       ready: true,
       error: false,
       "not-found": false,
-      cancelled: Boolean(o.cancelledAt),
-      shipped: ships.length > 0,
-      returnable: [...returnable.values()].some((q) => q > 0),
-      "has-returns": el.dataset.tetherReturned !== "1" && (o.returns?.nodes || []).length > 0,
-      "return-requested": el.dataset.tetherReturned === "1"
+      cancelled: Boolean(detail.cancelledAt),
+      shipped: shipments.length > 0,
+      returnable: [...returnable.values()].some((quantity) => quantity > 0),
+      "has-returns": !returnRequested && detail.returns.nodes.length > 0,
+      "return-requested": returnRequested
     });
-    state("ready");
+    el.setAttribute(attr("order-state"), "ready");
   }
-  async function renderProfile(form) {
-    const c = await ctx.customer().catch(() => null);
-    if (!c) return;
-    ["firstName", "lastName"].forEach((n) => {
-      const i = form.elements?.[n];
-      if (i && !i.dataset.tetherTouched) i.value = c[n] || "";
+  async function renderOrder(el) {
+    const key = orderKey(el);
+    if (!key) {
+      el.setAttribute(attr("order-state"), "not-found");
+      showIn(el, "order-show", { "not-found": true });
+      return;
+    }
+    showOrderState(el, "loading");
+    let detail;
+    try {
+      detail = await order(key);
+    } catch (error) {
+      reportError(error, "order");
+      showOrderState(el, "error");
+      return;
+    }
+    if (!detail) {
+      showOrderState(el, "not-found");
+      return;
+    }
+    el.dataset["tetherOrderId"] = detail.id;
+    fillOrder(el, detail);
+  }
+
+  // src/account/addresses-view.ts
+  var shown = [];
+  var shownAddress = (id) => shown.find((address) => address.id === id);
+  var addressTexts = (address) => ({
+    formatted: addressText(address),
+    name: [address.firstName, address.lastName].filter(Boolean).join(" "),
+    company: address.company || "",
+    address1: address.address1 || "",
+    address2: address.address2 || "",
+    city: address.city || "",
+    zip: address.zip || "",
+    province: address.province || "",
+    country: address.country || "",
+    phone: address.phoneNumber || ""
+  });
+  function fillAddress(row, address) {
+    row.dataset["tetherAddress"] = address.id;
+    const texts = addressTexts(address);
+    bindsIn(row, "address-bind").forEach((el) => {
+      const text = ownValue(texts, get(el, "address-bind") ?? "");
+      if (text !== void 0) setText(el, text);
     });
+    showIn(row, "address-show", { default: address.isDefault, "not-default": !address.isDefault });
   }
-  var addressCache = null;
   async function renderAddresses(root) {
     const boxes = qsa(root, sel("addresses"));
     if (!boxes.length) return;
-    showGlobal(root, { "addresses-loading": true, "addresses-empty": false });
+    showIn(root, "show", { "addresses-loading": true, "addresses-empty": false });
     let list;
     try {
-      list = addressCache = await addresses();
-    } catch (err) {
-      reportError(err, "addresses");
-      showGlobal(root, { "addresses-loading": false, "addresses-error": true });
+      list = await addresses();
+    } catch (error) {
+      reportError(error, "addresses");
+      showIn(root, "show", { "addresses-loading": false, "addresses-error": true });
       return;
     }
-    showGlobal(root, { "addresses-loading": false, "addresses-empty": list.length === 0, "addresses-error": false });
-    boxes.forEach((box) => repeat(box, list, (row, a) => {
-      row.dataset.tetherAddress = a.id;
-      qsa(row, sel("address-bind")).concat(row.matches(sel("address-bind")) ? [row] : []).forEach((b) => {
-        const v = { formatted: lines(a), name: [a.firstName, a.lastName].filter(Boolean).join(" "), company: a.company || "", address1: a.address1 || "", address2: a.address2 || "", city: a.city || "", zip: a.zip || "", province: a.province || "", country: a.country || "", phone: a.phoneNumber || "" }[get(b, "address-bind")];
-        if (v != null) setText(b, v);
-      });
-      showIn(row, "address-show", { default: a.isDefault, "not-default": !a.isDefault });
-    }));
+    shown = list;
+    showIn(root, "show", { "addresses-loading": false, "addresses-empty": list.length === 0, "addresses-error": false });
+    boxes.forEach((box) => {
+      repeat(box, list, fillAddress);
+    });
   }
-  var SUB_ACTIONS = ["pause", "resume", "skip", "unskip", "cancel"];
-  function subConds(c) {
-    const next = c.upcomingBillingCycles?.nodes?.[0];
-    const st = c.status;
+
+  // src/account/subscriptions-view.ts
+  function conditionsOf(contract) {
+    const next = contract.upcomingBillingCycles.nodes[0];
+    const status = contract.status;
+    const active = status === "ACTIVE";
     return {
-      active: st === "ACTIVE",
-      paused: st === "PAUSED",
-      cancelled: st === "CANCELLED",
-      expired: st === "EXPIRED",
-      failed: st === "FAILED",
+      active,
+      paused: status === "PAUSED",
+      cancelled: status === "CANCELLED",
+      expired: status === "EXPIRED",
+      failed: status === "FAILED",
       skipped: Boolean(next?.skipped),
-      "can-pause": st === "ACTIVE",
-      "can-resume": st === "PAUSED" || st === "FAILED",
-      "can-skip": st === "ACTIVE" && Boolean(next) && !next.skipped,
-      "can-unskip": st === "ACTIVE" && Boolean(next?.skipped),
-      "can-cancel": st === "ACTIVE" || st === "PAUSED" || st === "FAILED"
+      "can-pause": active,
+      "can-resume": status === "PAUSED" || status === "FAILED",
+      "can-skip": active && next !== void 0 && !next.skipped,
+      "can-unskip": active && Boolean(next?.skipped),
+      "can-cancel": active || status === "PAUSED" || status === "FAILED"
     };
   }
+  function intervalText(contract) {
+    const unit = enumText(contract.deliveryPolicy?.interval);
+    if (!unit) return "";
+    const count = contract.deliveryPolicy?.intervalCount?.count ?? 1;
+    return count <= 1 ? unit : `${String(count)} ${unit}s`;
+  }
+  function contractTexts(contract) {
+    const lines = contract.lines.nodes;
+    const total = lines.reduce((sum, line) => sum + Number.parseFloat(line.lineDiscountedPrice?.amount ?? "0"), 0);
+    return {
+      status: enumText(contract.status),
+      next: formatDate(contract.nextBillingDate),
+      interval: intervalText(contract),
+      products: lines.map((line) => `${String(line.quantity)}\xD7 ${line.title ?? ""}`).join(", "),
+      total: formatMoney(
+        lines.length && contract.currencyCode ? { amount: String(total), currencyCode: contract.currencyCode } : null
+      ),
+      delivery: formatMoney(contract.deliveryPrice)
+    };
+  }
+  function fillLine(row, line) {
+    const texts = {
+      title: line.title ?? "",
+      "variant-title": line.variantTitle || "",
+      quantity: String(line.quantity),
+      price: formatMoney(line.currentPrice)
+    };
+    bindsIn(row, "subscription-line").forEach((el) => {
+      const key = get(el, "subscription-line") ?? "";
+      if (key === "image") {
+        if (line.image) setImage(el, line.image.url, line.image.altText || line.title || "");
+        return;
+      }
+      const text = ownValue(texts, key);
+      if (text !== void 0) setText(el, text);
+    });
+  }
+  function fillContract(row, contract) {
+    row.dataset["tetherSubscription"] = contract.id;
+    row.setAttribute(attr("subscription-status"), enumText(contract.status));
+    const texts = contractTexts(contract);
+    qsa(row, sel("subscription-bind")).forEach((el) => {
+      const text = ownValue(texts, get(el, "subscription-bind") ?? "");
+      if (text !== void 0) setText(el, text);
+    });
+    qsa(row, sel("subscription-lines")).forEach((box) => {
+      repeat(box, contract.lines.nodes, fillLine);
+    });
+    const conditions = conditionsOf(contract);
+    showIn(row, "subscription-show", conditions);
+    qsa(row, sel("subscription-action")).forEach((button) => {
+      const allowed = ownValue(conditions, `can-${get(button, "subscription-action") ?? ""}`) === true;
+      if ("disabled" in button) button.disabled = !allowed;
+      button.classList.toggle("is-disabled", !allowed);
+    });
+  }
   async function renderSubscriptions(root) {
     const boxes = qsa(root, sel("subscriptions"));
     if (!boxes.length) return;
-    showGlobal(root, { "subscriptions-loading": true, "subscriptions-empty": false });
+    showIn(root, "show", { "subscriptions-loading": true, "subscriptions-empty": false });
     let list;
     try {
       list = await subscriptions();
-    } catch (err) {
-      reportError(err, "subscriptions");
-      showGlobal(root, { "subscriptions-loading": false, "subscriptions-error": true });
+    } catch (error) {
+      reportError(error, "subscriptions");
+      showIn(root, "show", { "subscriptions-loading": false, "subscriptions-error": true });
       return;
     }
-    showGlobal(root, { "subscriptions-loading": false, "subscriptions-empty": list.length === 0, "subscriptions-error": false });
-    boxes.forEach((box) => repeat(box, list, (row, c) => {
-      row.dataset.tetherSubscription = c.id;
-      row.setAttribute(attr("subscription-status"), lower(c.status));
-      const ls = c.lines?.nodes || [];
-      const n = c.deliveryPolicy?.intervalCount?.count || 1;
-      const unit = lower(c.deliveryPolicy?.interval);
-      const total = ls.reduce((sum, l) => sum + parseFloat(l.lineDiscountedPrice?.amount || 0), 0);
-      qsa(row, sel("subscription-bind")).forEach((b) => {
-        const k = get(b, "subscription-bind");
-        const v = {
-          status: lower(c.status),
-          next: c.nextBillingDate ? date(c.nextBillingDate) : "",
-          interval: unit ? n === 1 ? unit : `${n} ${unit}s` : "",
-          products: ls.map((l) => `${l.quantity}\xD7 ${l.title}`).join(", "),
-          total: ls.length ? formatMoney({ amount: String(total), currencyCode: c.currencyCode }) : "",
-          delivery: c.deliveryPrice ? formatMoney(c.deliveryPrice) : ""
-        }[k];
-        if (v != null) setText(b, v);
-      });
-      qsa(row, sel("subscription-lines")).forEach((lb) => repeat(lb, ls, (lr, l) => {
-        qsa(lr, sel("subscription-line")).concat(lr.matches(sel("subscription-line")) ? [lr] : []).forEach((b) => {
-          const k = get(b, "subscription-line");
-          if (k === "image") {
-            if (l.image) setImage(b, l.image.url, l.image.altText || l.title);
-            return;
-          }
-          const v = { title: l.title, "variant-title": l.variantTitle || "", quantity: String(l.quantity), price: formatMoney(l.currentPrice) }[k];
-          if (v != null) setText(b, v);
-        });
-      }));
-      const conds = subConds(c);
-      showIn(row, "subscription-show", conds);
-      qsa(row, sel("subscription-action")).forEach((btn) => {
-        const a = get(btn, "subscription-action");
-        const ok = conds[`can-${a}`];
-        btn.disabled = !ok;
-        btn.classList.toggle("is-disabled", !ok);
-      });
-    }));
+    showIn(root, "show", {
+      "subscriptions-loading": false,
+      "subscriptions-empty": list.length === 0,
+      "subscriptions-error": false
+    });
+    boxes.forEach((box) => {
+      repeat(box, list, fillContract);
+    });
   }
-  async function renderPages(root = document) {
-    if (!bound) {
-      bound = true;
-      bindPages();
+
+  // src/account/page-events.ts
+  var SUBSCRIPTION_ACTIONS = ["pause", "resume", "skip", "unskip", "cancel"];
+  var isSubscriptionAction = (value) => SUBSCRIPTION_ACTIONS.some((action) => action === value);
+  var isField = (el) => el instanceof window.HTMLInputElement || el instanceof window.HTMLSelectElement || el instanceof window.HTMLTextAreaElement;
+  var isForm = (el) => el instanceof window.HTMLFormElement;
+  function fieldsOf(form) {
+    const fields = {};
+    for (const field2 of form.elements) {
+      if (!isField(field2)) continue;
+      if (!field2.name || field2.type === "submit" || field2.type === "button" || field2.type === "checkbox") continue;
+      fields[field2.name] = field2.value;
     }
-    await Promise.all([
-      ...qsa(root, sel("order")).map((el) => renderOrder(el)),
-      ...qsa(root, sel("profile-form")).map((f) => renderProfile(f)),
-      renderAddresses(root),
-      renderSubscriptions(root)
-    ]);
+    return fields;
   }
-  var fieldsOf = (form) => Object.fromEntries([...form.elements].filter((i) => i.name && i.type !== "submit" && i.type !== "button" && i.type !== "checkbox").map((i) => [i.name, i.value]));
-  async function act(el, fn, { error } = {}) {
-    if (el.getAttribute("aria-busy") === "true") return void 0;
+  function customerMessage(error) {
+    const userErrors = error instanceof TetherError ? error.userErrors ?? [] : [];
+    const message = userErrors.map((userError) => userError.message).join(" ");
+    if (message) return message;
+    const text = error instanceof Error && error.message ? error.message : "Something went wrong";
+    return text.replace(/^Customer accounts: /, "");
+  }
+  async function act(el, change) {
+    if (el.getAttribute("aria-busy") === "true") return "busy";
     el.classList.add("is-busy");
     el.setAttribute("aria-busy", "true");
     el.setAttribute(attr("form-state"), "pending");
-    qsa(el, sel("form-error")).forEach((e) => setText(e, ""));
+    const errorBoxes = qsa(el, sel("form-error"));
+    errorBoxes.forEach((box) => {
+      setText(box, "");
+    });
     try {
-      const out = await fn();
+      await change();
       el.setAttribute(attr("form-state"), "saved");
-      return out;
-    } catch (err) {
+      return "saved";
+    } catch (error) {
       el.setAttribute(attr("form-state"), "error");
-      const msg = err?.userErrors?.map((u) => u.message).join(" ") || err?.message || "Something went wrong";
-      qsa(el, sel("form-error")).forEach((e) => setText(e, msg.replace(/^Customer accounts: /, "")));
-      if (error) reportError(err, error);
-      return void 0;
+      errorBoxes.forEach((box) => {
+        setText(box, customerMessage(error));
+      });
+      return "error";
     } finally {
       el.classList.remove("is-busy");
       el.removeAttribute("aria-busy");
     }
   }
-  function bindPages() {
-    document.addEventListener("submit", (e) => {
-      const f = e.target;
-      if (f.matches?.(sel("profile-form"))) {
-        e.preventDefault();
-        act(f, async () => {
-          await updateProfile(fieldsOf(f));
-          await ctx.bindCustomer?.(document);
-        });
-      } else if (f.matches?.(sel("address-form"))) {
-        e.preventDefault();
-        const id = f.dataset.tetherAddressId || void 0;
-        const isDefault = Boolean(f.elements?.isDefault?.checked);
-        act(f, async () => {
-          await saveAddress(fieldsOf(f), { id, isDefault });
-          f.reset();
-          delete f.dataset.tetherAddressId;
-          await renderAddresses(document);
-        });
+  var confirmed = (button) => {
+    const question = get(button, "confirm");
+    return !question || window.confirm(question);
+  };
+  var addressFormReset = (form) => {
+    form.reset();
+    delete form.dataset["tetherAddressId"];
+  };
+  function onSubmit(event) {
+    const form = event.target;
+    if (!(form instanceof window.HTMLFormElement)) return;
+    if (form.matches(sel("profile-form"))) {
+      event.preventDefault();
+      void act(form, async () => {
+        await updateProfile(fieldsOf(form));
+        await pagesContext().bindCustomer(document);
+      });
+    } else if (form.matches(sel("address-form"))) {
+      event.preventDefault();
+      const id = form.dataset["tetherAddressId"];
+      const box = form.elements.namedItem("isDefault");
+      const isDefault = box instanceof window.HTMLInputElement && box.checked;
+      void act(form, async () => {
+        await saveAddress(fieldsOf(form), { id, isDefault });
+        addressFormReset(form);
+        await renderAddresses(document);
+      });
+    }
+  }
+  function editAddress(id) {
+    const address = shownAddress(id);
+    const form = document.querySelector(sel("address-form"));
+    if (!address || !form || !isForm(form)) return;
+    form.dataset["tetherAddressId"] = address.id;
+    const valuesByName = { ...address };
+    for (const field2 of form.elements) {
+      if (!isField(field2)) continue;
+      if (field2.name === "isDefault") {
+        if (field2 instanceof window.HTMLInputElement) field2.checked = address.isDefault;
+      } else if (field2.name && Object.hasOwn(valuesByName, field2.name)) {
+        const value = valuesByName[field2.name];
+        field2.value = typeof value === "string" ? value : "";
       }
-    }, true);
-    document.addEventListener("input", (e) => {
-      if (e.target.closest?.(sel("profile-form"))) e.target.dataset.tetherTouched = "1";
+    }
+    form.scrollIntoView({ block: "nearest" });
+  }
+  function onAddressClick(event, target) {
+    const row = target.closest("[data-tether-address]");
+    const id = row instanceof window.HTMLElement ? row.dataset["tetherAddress"] : void 0;
+    if (target.closest(sel("address-new"))) {
+      const form = document.querySelector(sel("address-form"));
+      if (form && isForm(form)) addressFormReset(form);
+      return true;
+    }
+    if (!(row instanceof window.HTMLElement) || !id) return false;
+    const deleteButton = target.closest(sel("address-delete"));
+    if (deleteButton) {
+      event.preventDefault();
+      if (!confirmed(deleteButton)) return true;
+      void act(row, async () => {
+        await deleteAddress(id);
+        await renderAddresses(document);
+      });
+    } else if (target.closest(sel("address-default"))) {
+      event.preventDefault();
+      void act(row, async () => {
+        await saveAddress(null, { id, isDefault: true });
+        await renderAddresses(document);
+      });
+    } else if (target.closest(sel("address-edit"))) {
+      event.preventDefault();
+      editAddress(id);
+    } else {
+      return false;
+    }
+    return true;
+  }
+  function onSubscriptionAction(button) {
+    const row = button.closest("[data-tether-subscription]");
+    const action = get(button, "subscription-action");
+    const disabled = "disabled" in button && button.disabled === true || button.classList.contains("is-disabled");
+    if (!(row instanceof window.HTMLElement) || !isSubscriptionAction(action) || disabled || !confirmed(button)) return;
+    const id = row.dataset["tetherSubscription"] ?? "";
+    row.setAttribute(attr("subscription-state"), "pending");
+    void act(row, async () => {
+      await subscriptionAction(id, action);
+      await renderSubscriptions(document);
+    }).then((outcome) => {
+      const state = outcome === "error" ? "error" : "done";
+      qsa(document, "[data-tether-subscription]").filter((candidate) => candidate === row || candidate.dataset["tetherSubscription"] === id).forEach((candidate) => {
+        candidate.setAttribute(attr("subscription-state"), state);
+      });
     });
-    document.addEventListener("click", (e) => {
-      const t = e.target;
-      const row = t.closest?.("[data-tether-address]");
-      const confirmOk = (btn2) => {
-        const q = get(btn2, "confirm");
-        return !q || window.confirm(q);
-      };
-      let btn;
-      if ((btn = t.closest?.(sel("address-delete"))) && row) {
-        e.preventDefault();
-        if (confirmOk(btn)) act(row, async () => {
-          await deleteAddress(row.dataset.tetherAddress);
-          await renderAddresses(document);
-        });
-      } else if ((btn = t.closest?.(sel("address-default"))) && row) {
-        e.preventDefault();
-        act(row, async () => {
-          await saveAddress(null, { id: row.dataset.tetherAddress, isDefault: true });
-          await renderAddresses(document);
-        });
-      } else if ((btn = t.closest?.(sel("address-edit"))) && row) {
-        e.preventDefault();
-        const a = (addressCache || []).find((x) => x.id === row.dataset.tetherAddress);
-        const f = document.querySelector(sel("address-form"));
-        if (a && f) {
-          f.dataset.tetherAddressId = a.id;
-          [...f.elements].forEach((i) => {
-            if (i.name && i.name in a) i.value = a[i.name] ?? "";
-            if (i.name === "isDefault") i.checked = a.isDefault;
-          });
-          f.scrollIntoView?.({ block: "nearest" });
-        }
-      } else if (btn = t.closest?.(sel("address-new"))) {
-        const f = document.querySelector(sel("address-form"));
-        if (f) {
-          f.reset();
-          delete f.dataset.tetherAddressId;
-        }
-      } else if (btn = t.closest?.(sel("subscription-action"))) {
-        e.preventDefault();
-        const sub = btn.closest("[data-tether-subscription]");
-        const a = get(btn, "subscription-action");
-        if (!sub || !SUB_ACTIONS.includes(a) || btn.disabled || !confirmOk(btn)) return;
-        const id = sub.dataset.tetherSubscription;
-        sub.setAttribute(attr("subscription-state"), "pending");
-        act(sub, async () => {
-          await subscriptionAction(id, a);
-          await renderSubscriptions(document);
-        }).then(() => {
-          const state = sub.getAttribute(attr("form-state")) === "error" ? "error" : "done";
-          qsa(document, "[data-tether-subscription]").filter((r) => r === sub || r.dataset.tetherSubscription === id).forEach((r) => r.setAttribute(attr("subscription-state"), state));
-        });
-      } else if (btn = t.closest?.(sel("order-return"))) {
-        e.preventDefault();
-        const scope = btn.closest(SCOPE.order);
-        if (!scope?.dataset.tetherOrderId) return;
-        const req = qsa(scope, "[data-tether-line]").map((r) => ({
-          lineItemId: r.dataset.tetherLine,
-          quantity: parseInt(r.querySelector(sel("return-quantity"))?.value || "0", 10),
-          reasonId: r.querySelector(sel("return-reason"))?.value || void 0,
-          note: r.querySelector(sel("return-note"))?.value || void 0
-        })).filter((l) => l.quantity > 0);
-        if (!req.length || !confirmOk(btn)) return;
-        act(scope, async () => {
-          await requestReturn(scope.dataset.tetherOrderId, req);
-          scope.dataset.tetherReturned = "1";
-          await renderOrder(scope);
-        });
+  }
+  function returnLineOf(row) {
+    const quantity = row.querySelector(sel("return-quantity"));
+    const reason = row.querySelector(sel("return-reason"));
+    const note = row.querySelector(sel("return-note"));
+    const valueOf = (field2) => field2 && "value" in field2 && typeof field2.value === "string" ? field2.value : "";
+    const line = {
+      lineItemId: row.dataset["tetherLine"] ?? "",
+      quantity: Number.parseInt(valueOf(quantity) || "0", 10)
+    };
+    const reasonId = valueOf(reason);
+    if (reasonId) line.reasonId = reasonId;
+    const noteText = valueOf(note);
+    if (noteText) line.note = noteText;
+    return line;
+  }
+  function onReturnRequest(button) {
+    const scope = button.closest(sel("order"));
+    if (!(scope instanceof window.HTMLElement)) return;
+    const orderId = scope.dataset["tetherOrderId"];
+    if (!orderId) return;
+    const lines = qsa(scope, "[data-tether-line]").map(returnLineOf).filter((line) => line.quantity > 0);
+    if (!lines.length || !confirmed(button)) return;
+    void act(scope, async () => {
+      await requestReturn(orderId, lines);
+      scope.dataset["tetherReturned"] = "1";
+      await renderOrder(scope);
+    });
+  }
+  function onClick(event) {
+    const target = event.target;
+    if (!(target instanceof window.Element)) return;
+    if (onAddressClick(event, target)) return;
+    const subscriptionButton = target.closest(sel("subscription-action"));
+    if (subscriptionButton instanceof window.HTMLElement) {
+      event.preventDefault();
+      onSubscriptionAction(subscriptionButton);
+      return;
+    }
+    const returnButton = target.closest(sel("order-return"));
+    if (returnButton instanceof window.HTMLElement) {
+      event.preventDefault();
+      onReturnRequest(returnButton);
+    }
+  }
+  function listenToPages() {
+    document.addEventListener("submit", onSubmit, true);
+    document.addEventListener("input", (event) => {
+      const target = event.target;
+      if (target instanceof window.HTMLElement && target.closest(sel("profile-form"))) {
+        target.dataset["tetherTouched"] = "1";
       }
     });
+    document.addEventListener("click", onClick);
+  }
+
+  // src/account-pages.ts
+  var PROFILE_FIELDS = ["firstName", "lastName"];
+  async function renderProfile(form) {
+    if (!(form instanceof window.HTMLFormElement)) return;
+    let customer;
+    try {
+      customer = await pagesContext().customer();
+    } catch (error) {
+      reportError(error, "account");
+      return;
+    }
+    if (!customer) return;
+    const fields = form.elements;
+    PROFILE_FIELDS.forEach((name) => {
+      const input = fields.namedItem(name);
+      const isTextField = input instanceof window.HTMLInputElement || input instanceof window.HTMLTextAreaElement;
+      if (isTextField && !input.dataset["tetherTouched"]) input.value = customer[name] ?? "";
+    });
+  }
+  var listening = false;
+  async function renderPages(root = document) {
+    if (!listening) {
+      listening = true;
+      listenToPages();
+    }
+    await Promise.all([
+      ...qsa(root, sel("order")).map((el) => renderOrder(el)),
+      ...qsa(root, sel("profile-form")).map((form) => renderProfile(form)),
+      renderAddresses(root),
+      renderSubscriptions(root)
+    ]);
+  }
+  function showUnavailable(root) {
+    qsa(root, sel("order")).forEach((el) => {
+      showOrderState(el, "error");
+    });
+    showIn(root, "show", {
+      "addresses-loading": false,
+      "addresses-error": true,
+      "subscriptions-loading": false,
+      "subscriptions-error": true
+    });
   }
 
-  // src/parts/account-pages.js
-  window.Tether.__parts["account-pages"] = account_pages_exports;
+  // src/parts/account-pages.ts
+  var { Tether } = window;
+  if (!Tether) throw new Error("tether.account-pages.js runs after the Tether script, which loads it");
+  Tether.__parts["account-pages"] = account_pages_exports;
 })();