hydrogen-sfdgspsdmq-test1 0.0.1-security → 2024.1.12

package/dist/development/index.cjs

@@ -0,0 +1,3708 @@
+'use strict';
+
+var hydrogenReact = require('@shopify/hydrogen-react');
+var react = require('react');
+var react$1 = require('@remix-run/react');
+var jsxRuntime = require('react/jsx-runtime');
+var cspBuilder = require('content-security-policy-builder');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var cspBuilder__default = /*#__PURE__*/_interopDefault(cspBuilder);
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/seo/log-seo-tags.ts
+var log_seo_tags_exports = {};
+__export(log_seo_tags_exports, {
+  default: () => Logger,
+  logSeoTags: () => logSeoTags
+});
+function Logger({ headTags }) {
+  logSeoTags(headTags);
+  return null;
+}
+function logSeoTags(headTags) {
+  console.log(" ");
+  console.log("%cSEO Meta Tags", `${titleStyle}`);
+  console.log(" ");
+  headTags.forEach((tag) => {
+    if (tag.tag === "script") {
+      console.log(`%c\u2022 JSON LD `, headingStyle);
+      if (tag.children) {
+        try {
+          console.table(JSON.parse(tag.children), ["name", "content"]);
+        } catch {
+          console.log(tag.children);
+        }
+      }
+    } else {
+      console.log(`%c\u2022 ${tag.tag} `, headingStyle);
+      if (tag.children) {
+        if (typeof tag.children === "string") {
+          console.log(`\u21B3 ${tag.children}`);
+        } else {
+          try {
+            Object.entries(JSON.parse(tag.children)).map(
+              ([key, val]) => console.log(`\u21B3 ${val}`)
+            );
+          } catch {
+            console.log(tag.children);
+          }
+        }
+      }
+      if (tag.props.property === "og:image:url") {
+        const urlKey = tag.props.content;
+        fetchImage(urlKey).then((image) => {
+          const imageStyle = `font-size: 400px; padding: 10px; background: white url(${image}) no-repeat center; background-size: contain;`;
+          console.log(`%c\u2022 Share image preview`, headingStyle);
+          console.log("%c  ", imageStyle);
+          console.log(`\u21B3 ${urlKey}`);
+        }).catch((err) => {
+          console.error(err);
+        });
+      }
+      Object.entries(tag.props).map(([key, val]) => {
+        console.log(`\u21B3 ${key} \u2192 ${val}`);
+      });
+    }
+    console.log(" ");
+  });
+}
+async function fetchImage(url) {
+  const result = await fetch(url);
+  const data = await result.blob();
+  const buff = await data.arrayBuffer();
+  const base64String = arrayBufferToBase64(buff);
+  return `data:image/png;base64,${base64String}`;
+}
+function arrayBufferToBase64(buffer) {
+  let binary = "";
+  const bytes = new Uint8Array(buffer);
+  const len = bytes.byteLength;
+  for (let index = 0; index < len; index++) {
+    binary += String.fromCharCode(bytes[index]);
+  }
+  return btoa(binary);
+}
+var headingStyle, titleStyle;
+var init_log_seo_tags = __esm({
+  "src/seo/log-seo-tags.ts"() {
+    headingStyle = "text-transform: uppercase;";
+    titleStyle = "text-transform: uppercase; font-weight: bold; text-transform: uppercase;font-weight: bold";
+  }
+});
+
+// src/utils/hash.ts
+function hashKey(queryKey) {
+  const rawKeys = Array.isArray(queryKey) ? queryKey : [queryKey];
+  let hash = "";
+  for (const key of rawKeys) {
+    if (key != null) {
+      if (typeof key === "object") {
+        hash += JSON.stringify(key);
+      } else {
+        hash += key.toString();
+      }
+    }
+  }
+  return encodeURIComponent(hash);
+}
+
+// src/cache/strategies.ts
+var PUBLIC = "public";
+var PRIVATE = "private";
+var NO_STORE = "no-store";
+var optionMapping = {
+  maxAge: "max-age",
+  staleWhileRevalidate: "stale-while-revalidate",
+  sMaxAge: "s-maxage",
+  staleIfError: "stale-if-error"
+};
+function generateCacheControlHeader(cacheOptions) {
+  const cacheControl = [];
+  Object.keys(cacheOptions).forEach((key) => {
+    if (key === "mode") {
+      cacheControl.push(cacheOptions[key]);
+    } else if (optionMapping[key]) {
+      cacheControl.push(
+        `${optionMapping[key]}=${cacheOptions[key]}`
+      );
+    }
+  });
+  return cacheControl.join(", ");
+}
+function CacheNone() {
+  return {
+    mode: NO_STORE
+  };
+}
+function guardExpirableModeType(overrideOptions) {
+  if (overrideOptions?.mode && overrideOptions?.mode !== PUBLIC && overrideOptions?.mode !== PRIVATE) {
+    throw Error("'mode' must be either 'public' or 'private'");
+  }
+}
+function CacheShort(overrideOptions) {
+  guardExpirableModeType(overrideOptions);
+  return {
+    mode: PUBLIC,
+    maxAge: 1,
+    staleWhileRevalidate: 9,
+    ...overrideOptions
+  };
+}
+function CacheLong(overrideOptions) {
+  guardExpirableModeType(overrideOptions);
+  return {
+    mode: PUBLIC,
+    maxAge: 3600,
+    // 1 hour
+    staleWhileRevalidate: 82800,
+    // 23 Hours
+    ...overrideOptions
+  };
+}
+function CacheDefault(overrideOptions) {
+  guardExpirableModeType(overrideOptions);
+  return {
+    mode: PUBLIC,
+    maxAge: 1,
+    staleWhileRevalidate: 86399,
+    // 1 second less than 24 hours
+    ...overrideOptions
+  };
+}
+function CacheCustom(overrideOptions) {
+  return overrideOptions;
+}
+
+// src/utils/parse-json.ts
+function parseJSON(json) {
+  if (String(json).includes("__proto__"))
+    return JSON.parse(json, noproto);
+  return JSON.parse(json);
+}
+function noproto(k, v) {
+  if (k !== "__proto__")
+    return v;
+}
+function getCacheControlSetting(userCacheOptions, options) {
+  if (userCacheOptions && options) {
+    return {
+      ...userCacheOptions,
+      ...options
+    };
+  } else {
+    return userCacheOptions || CacheDefault();
+  }
+}
+function generateDefaultCacheControlHeader(userCacheOptions) {
+  return generateCacheControlHeader(getCacheControlSetting(userCacheOptions));
+}
+async function getItem(cache, request) {
+  if (!cache)
+    return;
+  const response = await cache.match(request);
+  if (!response) {
+    return;
+  }
+  return response;
+}
+async function setItem(cache, request, response, userCacheOptions) {
+  if (!cache)
+    return;
+  const cacheControl = getCacheControlSetting(userCacheOptions);
+  const paddedCacheControlString = generateDefaultCacheControlHeader(
+    getCacheControlSetting(cacheControl, {
+      maxAge: (cacheControl.maxAge || 0) + (cacheControl.staleWhileRevalidate || 0)
+    })
+  );
+  const cacheControlString = generateDefaultCacheControlHeader(
+    getCacheControlSetting(cacheControl)
+  );
+  response.headers.set("cache-control", paddedCacheControlString);
+  response.headers.set("real-cache-control", cacheControlString);
+  response.headers.set("cache-put-date", (/* @__PURE__ */ new Date()).toUTCString());
+  await cache.put(request, response);
+}
+async function deleteItem(cache, request) {
+  if (!cache)
+    return;
+  await cache.delete(request);
+}
+function calculateAge(response, responseDate) {
+  const cacheControl = response.headers.get("real-cache-control");
+  let responseMaxAge = 0;
+  if (cacheControl) {
+    const maxAgeMatch = cacheControl.match(/max-age=(\d*)/);
+    if (maxAgeMatch && maxAgeMatch.length > 1) {
+      responseMaxAge = parseFloat(maxAgeMatch[1]);
+    }
+  }
+  const ageInMs = (/* @__PURE__ */ new Date()).valueOf() - new Date(responseDate).valueOf();
+  return [ageInMs / 1e3, responseMaxAge];
+}
+function isStale(request, response) {
+  const responseDate = response.headers.get("cache-put-date");
+  if (!responseDate) {
+    return false;
+  }
+  const [age, responseMaxAge] = calculateAge(response, responseDate);
+  const result = age > responseMaxAge;
+  return result;
+}
+var CacheAPI = {
+  get: getItem,
+  set: setItem,
+  delete: deleteItem,
+  generateDefaultCacheControlHeader,
+  isStale
+};
+
+// src/cache/sub-request.ts
+function getKeyUrl(key) {
+  return `https://shopify.dev/?${key}`;
+}
+function getCacheOption(userCacheOptions) {
+  return userCacheOptions || CacheDefault();
+}
+async function getItemFromCache(cache, key) {
+  if (!cache)
+    return;
+  const url = getKeyUrl(key);
+  const request = new Request(url);
+  const response = await CacheAPI.get(cache, request);
+  if (!response) {
+    return;
+  }
+  const text = await response.text();
+  try {
+    return [parseJSON(text), response];
+  } catch {
+    return [text, response];
+  }
+}
+async function setItemInCache(cache, key, value, userCacheOptions) {
+  if (!cache)
+    return;
+  const url = getKeyUrl(key);
+  const request = new Request(url);
+  const response = new Response(JSON.stringify(value));
+  await CacheAPI.set(
+    cache,
+    request,
+    response,
+    getCacheOption(userCacheOptions)
+  );
+}
+function isStale2(key, response) {
+  return CacheAPI.isStale(new Request(getKeyUrl(key)), response);
+}
+
+// src/cache/fetch.ts
+function toSerializableResponse(body, response) {
+  return [
+    body,
+    {
+      status: response.status,
+      statusText: response.statusText,
+      headers: Array.from(response.headers.entries())
+    }
+  ];
+}
+function fromSerializableResponse([body, init]) {
+  return [body, new Response(body, init)];
+}
+var checkGraphQLErrors = (body, response) => !body?.errors && response.status < 400;
+var swrLock = /* @__PURE__ */ new Set();
+async function runWithCache(cacheKey, actionFn, {
+  strategy = CacheShort(),
+  cacheInstance,
+  shouldCacheResult = () => true,
+  waitUntil,
+  debugInfo
+}) {
+  const startTime = Date.now();
+  const key = hashKey([
+    // '__HYDROGEN_CACHE_ID__', // TODO purgeQueryCacheOnBuild
+    ...typeof cacheKey === "string" ? [cacheKey] : cacheKey
+  ]);
+  let debugData;
+  const addDebugData = (info) => {
+    debugData = {
+      displayName: info.displayName,
+      url: info.response?.url,
+      responseInit: {
+        status: info.response?.status || 0,
+        statusText: info.response?.statusText || "",
+        headers: Array.from(info.response?.headers.entries() || [])
+      }
+    };
+  };
+  const logSubRequestEvent2 = ({
+    result: result2,
+    cacheStatus,
+    overrideStartTime
+  }) => {
+    globalThis.__H2O_LOG_EVENT?.({
+      eventType: "subrequest",
+      startTime: overrideStartTime || startTime,
+      cacheStatus,
+      responsePayload: result2 && result2[0] || result2,
+      responseInit: result2 && result2[1] || debugData?.responseInit,
+      cache: {
+        status: cacheStatus,
+        strategy: generateCacheControlHeader(strategy || {}),
+        key
+      },
+      waitUntil,
+      ...debugInfo,
+      url: debugData?.url || debugInfo?.url || getKeyUrl(key),
+      displayName: debugInfo?.displayName || debugData?.displayName
+    });
+  } ;
+  if (!cacheInstance || !strategy || strategy.mode === NO_STORE) {
+    const result2 = await actionFn({ addDebugData });
+    logSubRequestEvent2?.({ result: result2 });
+    return result2;
+  }
+  const cachedItem = await getItemFromCache(cacheInstance, key);
+  if (cachedItem) {
+    const [cachedResult, cacheInfo] = cachedItem;
+    const cacheStatus = isStale2(key, cacheInfo) ? "STALE" : "HIT";
+    if (!swrLock.has(key) && cacheStatus === "STALE") {
+      swrLock.add(key);
+      const revalidatingPromise = Promise.resolve().then(async () => {
+        const revalidateStartTime = Date.now();
+        try {
+          const result2 = await actionFn({ addDebugData });
+          if (shouldCacheResult(result2)) {
+            await setItemInCache(cacheInstance, key, result2, strategy);
+            logSubRequestEvent2?.({
+              result: result2,
+              cacheStatus: "PUT",
+              overrideStartTime: revalidateStartTime
+            });
+          }
+        } catch (error) {
+          if (error.message) {
+            error.message = "SWR in sub-request failed: " + error.message;
+          }
+          console.error(error);
+        } finally {
+          swrLock.delete(key);
+        }
+      });
+      waitUntil?.(revalidatingPromise);
+    }
+    logSubRequestEvent2?.({
+      result: cachedResult,
+      cacheStatus
+    });
+    return cachedResult;
+  }
+  const result = await actionFn({ addDebugData });
+  logSubRequestEvent2?.({
+    result,
+    cacheStatus: "MISS"
+  });
+  if (shouldCacheResult(result)) {
+    const setItemInCachePromise = Promise.resolve().then(async () => {
+      const putStartTime = Date.now();
+      await setItemInCache(cacheInstance, key, result, strategy);
+      logSubRequestEvent2?.({
+        result,
+        cacheStatus: "PUT",
+        overrideStartTime: putStartTime
+      });
+    });
+    waitUntil?.(setItemInCachePromise);
+  }
+  return result;
+}
+async function fetchWithServerCache(url, requestInit, {
+  cacheInstance,
+  cache: cacheOptions,
+  cacheKey = [url, requestInit],
+  shouldCacheResponse = () => true,
+  waitUntil,
+  returnType = "json",
+  debugInfo
+} = {}) {
+  if (!cacheOptions && (!requestInit.method || requestInit.method === "GET")) {
+    cacheOptions = CacheShort();
+  }
+  return runWithCache(
+    cacheKey,
+    async () => {
+      const response = await fetch(url, requestInit);
+      let data;
+      try {
+        data = await response[returnType]();
+      } catch {
+        try {
+          data = await response.text();
+        } catch {
+          return toSerializableResponse("", response);
+        }
+      }
+      return toSerializableResponse(data, response);
+    },
+    {
+      cacheInstance,
+      waitUntil,
+      strategy: cacheOptions ?? null,
+      debugInfo,
+      shouldCacheResult: (result) => shouldCacheResponse(...fromSerializableResponse(result))
+    }
+  ).then(fromSerializableResponse);
+}
+
+// src/constants.ts
+var STOREFRONT_REQUEST_GROUP_ID_HEADER = "Custom-Storefront-Request-Group-ID";
+var STOREFRONT_ACCESS_TOKEN_HEADER = "X-Shopify-Storefront-Access-Token";
+var SDK_VARIANT_HEADER = "X-SDK-Variant";
+var SDK_VARIANT_SOURCE_HEADER = "X-SDK-Variant-Source";
+var SDK_VERSION_HEADER = "X-SDK-Version";
+
+// src/utils/uuid.ts
+function generateUUID() {
+  if (typeof crypto !== "undefined" && !!crypto.randomUUID) {
+    return crypto.randomUUID();
+  } else {
+    return `weak-${Math.random().toString(16).substring(2)}`;
+  }
+}
+
+// src/utils/warning.ts
+var warnings = /* @__PURE__ */ new Set();
+var warnOnce = (string) => {
+  if (!warnings.has(string)) {
+    console.warn(string);
+    warnings.add(string);
+  }
+};
+
+// src/version.ts
+var LIB_VERSION = "2024.1.6";
+
+// src/utils/graphql.ts
+function minifyQuery(string) {
+  return string.replace(/\s*#.*$/gm, "").replace(/\s+/gm, " ").trim();
+}
+var IS_QUERY_RE = /(^|}\s)query[\s({]/im;
+var IS_MUTATION_RE = /(^|}\s)mutation[\s({]/im;
+function assertQuery(query, callerName) {
+  if (!IS_QUERY_RE.test(query)) {
+    throw new Error(`[h2:error:${callerName}] Can only execute queries`);
+  }
+}
+function assertMutation(query, callerName) {
+  if (!IS_MUTATION_RE.test(query)) {
+    throw new Error(`[h2:error:${callerName}] Can only execute mutations`);
+  }
+}
+var GraphQLError = class extends Error {
+  /**
+   * If an error can be associated to a particular point in the requested
+   * GraphQL document, it should contain a list of locations.
+   */
+  locations;
+  /**
+   * If an error can be associated to a particular field in the GraphQL result,
+   * it _must_ contain an entry with the key `path` that details the path of
+   * the response field which experienced the error. This allows clients to
+   * identify whether a null result is intentional or caused by a runtime error.
+   */
+  path;
+  /**
+   * Reserved for implementors to extend the protocol however they see fit,
+   * and hence there are no additional restrictions on its contents.
+   */
+  extensions;
+  constructor(message, options = {}) {
+    const h2Prefix = options.clientOperation ? `[h2:error:${options.clientOperation}] ` : "";
+    const enhancedMessage = h2Prefix + message + (options.requestId ? ` - Request ID: ${options.requestId}` : "");
+    super(enhancedMessage);
+    this.name = "GraphQLError";
+    this.extensions = options.extensions;
+    this.locations = options.locations;
+    this.path = options.path;
+    this.stack = options.stack || void 0;
+    try {
+      this.cause = JSON.stringify({
+        ...typeof options.cause === "object" ? options.cause : {},
+        requestId: options.requestId,
+        ...{
+          path: options.path,
+          extensions: options.extensions,
+          graphql: h2Prefix && options.query && {
+            query: options.query,
+            variables: JSON.stringify(options.queryVariables)
+          }
+        }
+      });
+    } catch {
+      if (options.cause)
+        this.cause = options.cause;
+    }
+  }
+  get [Symbol.toStringTag]() {
+    return this.name;
+  }
+  /**
+   * Note: `toString()` is internally used by `console.log(...)` / `console.error(...)`
+   * when ingesting logs in Oxygen production. Therefore, we want to make sure that
+   * the error message is as informative as possible instead of `[object Object]`.
+   */
+  toString() {
+    let result = `${this.name}: ${this.message}`;
+    if (this.path) {
+      try {
+        result += ` | path: ${JSON.stringify(this.path)}`;
+      } catch {
+      }
+    }
+    if (this.extensions) {
+      try {
+        result += ` | extensions: ${JSON.stringify(this.extensions)}`;
+      } catch {
+      }
+    }
+    result += "\n";
+    if (this.stack) {
+      result += `${this.stack.slice(this.stack.indexOf("\n") + 1)}
+`;
+    }
+    return result;
+  }
+  /**
+   * Note: toJSON` is internally used by `JSON.stringify(...)`.
+   * The most common scenario when this error instance is going to be stringified is
+   * when it's passed to Remix' `json` and `defer` functions: e.g. `defer({promise: storefront.query(...)})`.
+   * In this situation, we don't want to expose private error information to the browser so we only
+   * do it in development.
+   */
+  toJSON() {
+    const formatted = { name: "Error", message: "" };
+    {
+      formatted.name = this.name;
+      formatted.message = "Development: " + this.message;
+      if (this.path)
+        formatted.path = this.path;
+      if (this.locations)
+        formatted.locations = this.locations;
+      if (this.extensions)
+        formatted.extensions = this.extensions;
+    }
+    return formatted;
+  }
+};
+function throwErrorWithGqlLink({
+  url,
+  response,
+  errors,
+  type,
+  query,
+  queryVariables,
+  ErrorConstructor = Error,
+  client = "storefront"
+}) {
+  const errorMessage = (typeof errors === "string" ? errors : errors?.map?.((error) => error.message).join("\n")) || `URL: ${url}
+API response error: ${response.status}`;
+  const gqlError = new GraphQLError(errorMessage, {
+    query,
+    queryVariables,
+    cause: { errors },
+    clientOperation: `${client}.${type}`,
+    requestId: response.headers.get("x-request-id")
+  });
+  throw new ErrorConstructor(gqlError.message, { cause: gqlError.cause });
+}
+
+// src/utils/callsites.ts
+function withSyncStack(promise, options = {}) {
+  const syncError = new Error();
+  const getSyncStack = (message, name = "Error") => {
+    const syncStack = (syncError.stack ?? "").split("\n").slice(3 + (options.stackOffset ?? 0)).join("\n").replace(/ at loader(\d+) \(/, (all, m1) => all.replace(m1, ""));
+    return `${name}: ${message}
+` + syncStack;
+  };
+  return promise.then((result) => {
+    if (result?.errors && Array.isArray(result.errors)) {
+      const logErrors = typeof options.logErrors === "function" ? options.logErrors : () => options.logErrors ?? false;
+      result.errors.forEach((error) => {
+        if (error) {
+          error.stack = getSyncStack(error.message, error.name);
+          if (logErrors(error))
+            console.error(error);
+        }
+      });
+    }
+    return result;
+  }).catch((error) => {
+    if (error)
+      error.stack = getSyncStack(error.message, error.name);
+    throw error;
+  });
+}
+var getCallerStackLine = (stackOffset = 0) => {
+  let stackInfo = void 0;
+  const original = Error.prepareStackTrace;
+  Error.prepareStackTrace = (_, callsites) => {
+    const cs = callsites[2 + stackOffset];
+    stackInfo = cs && {
+      file: cs.getFileName() ?? void 0,
+      func: cs.getFunctionName() ?? void 0,
+      line: cs.getLineNumber() ?? void 0,
+      column: cs.getColumnNumber() ?? void 0
+    };
+    return "";
+  };
+  const err = { stack: "" };
+  Error.captureStackTrace(err);
+  err.stack;
+  Error.prepareStackTrace = original;
+  return stackInfo;
+} ;
+
+// src/storefront.ts
+var defaultI18n = { language: "EN", country: "US" };
+function createStorefrontClient(options) {
+  const {
+    storefrontHeaders,
+    cache,
+    waitUntil,
+    i18n,
+    storefrontId,
+    logErrors = true,
+    ...clientOptions
+  } = options;
+  const H2_PREFIX_WARN = "[h2:warn:createStorefrontClient] ";
+  if (!cache) {
+    warnOnce(
+      H2_PREFIX_WARN + "Storefront API client created without a cache instance. This may slow down your sub-requests."
+    );
+  }
+  const {
+    getPublicTokenHeaders,
+    getPrivateTokenHeaders,
+    getStorefrontApiUrl,
+    getShopifyDomain
+  } = hydrogenReact.createStorefrontClient(clientOptions);
+  const getHeaders = clientOptions.privateStorefrontToken ? getPrivateTokenHeaders : getPublicTokenHeaders;
+  const defaultHeaders = getHeaders({
+    contentType: "json",
+    buyerIp: storefrontHeaders?.buyerIp || ""
+  });
+  defaultHeaders[STOREFRONT_REQUEST_GROUP_ID_HEADER] = storefrontHeaders?.requestGroupId || generateUUID();
+  if (storefrontId)
+    defaultHeaders[hydrogenReact.SHOPIFY_STOREFRONT_ID_HEADER] = storefrontId;
+  defaultHeaders["user-agent"] = `Hydrogen ${LIB_VERSION}`;
+  if (storefrontHeaders && storefrontHeaders.cookie) {
+    const cookies = hydrogenReact.getShopifyCookies(storefrontHeaders.cookie ?? "");
+    if (cookies[hydrogenReact.SHOPIFY_Y])
+      defaultHeaders[hydrogenReact.SHOPIFY_STOREFRONT_Y_HEADER] = cookies[hydrogenReact.SHOPIFY_Y];
+    if (cookies[hydrogenReact.SHOPIFY_S])
+      defaultHeaders[hydrogenReact.SHOPIFY_STOREFRONT_S_HEADER] = cookies[hydrogenReact.SHOPIFY_S];
+  }
+  const cacheKeyHeader = JSON.stringify({
+    "content-type": defaultHeaders["content-type"],
+    "user-agent": defaultHeaders["user-agent"],
+    [SDK_VARIANT_HEADER]: defaultHeaders[SDK_VARIANT_HEADER],
+    [SDK_VARIANT_SOURCE_HEADER]: defaultHeaders[SDK_VARIANT_SOURCE_HEADER],
+    [SDK_VERSION_HEADER]: defaultHeaders[SDK_VERSION_HEADER],
+    [STOREFRONT_ACCESS_TOKEN_HEADER]: defaultHeaders[STOREFRONT_ACCESS_TOKEN_HEADER]
+  });
+  async function fetchStorefrontApi({
+    query,
+    mutation,
+    variables,
+    cache: cacheOptions,
+    headers = [],
+    storefrontApiVersion,
+    displayName,
+    stackInfo
+  }) {
+    const userHeaders = headers instanceof Headers ? Object.fromEntries(headers.entries()) : Array.isArray(headers) ? Object.fromEntries(headers) : headers;
+    query = query ?? mutation;
+    const queryVariables = { ...variables };
+    if (i18n) {
+      if (!variables?.country && /\$country/.test(query)) {
+        queryVariables.country = i18n.country;
+      }
+      if (!variables?.language && /\$language/.test(query)) {
+        queryVariables.language = i18n.language;
+      }
+    }
+    const url = getStorefrontApiUrl({ storefrontApiVersion });
+    const graphqlData = JSON.stringify({ query, variables: queryVariables });
+    const requestInit = {
+      method: "POST",
+      headers: { ...defaultHeaders, ...userHeaders },
+      body: graphqlData
+    };
+    const cacheKey = [
+      url,
+      requestInit.method,
+      cacheKeyHeader,
+      requestInit.body
+    ];
+    const [body, response] = await fetchWithServerCache(url, requestInit, {
+      cacheInstance: mutation ? void 0 : cache,
+      cache: cacheOptions || CacheDefault(),
+      cacheKey,
+      shouldCacheResponse: checkGraphQLErrors,
+      waitUntil,
+      debugInfo: {
+        url,
+        graphql: graphqlData,
+        requestId: requestInit.headers[STOREFRONT_REQUEST_GROUP_ID_HEADER],
+        purpose: storefrontHeaders?.purpose,
+        stackInfo,
+        displayName
+      }
+    });
+    const errorOptions = {
+      url,
+      response,
+      type: mutation ? "mutation" : "query",
+      query,
+      queryVariables,
+      errors: void 0
+    };
+    if (!response.ok) {
+      let errors2;
+      try {
+        errors2 = parseJSON(body);
+      } catch (_e) {
+        errors2 = [{ message: body }];
+      }
+      throwErrorWithGqlLink({ ...errorOptions, errors: errors2 });
+    }
+    const { data, errors } = body;
+    const gqlErrors = errors?.map(
+      ({ message, ...rest }) => new GraphQLError(message, {
+        ...rest,
+        clientOperation: `storefront.${errorOptions.type}`,
+        requestId: response.headers.get("x-request-id"),
+        queryVariables,
+        query
+      })
+    );
+    return formatAPIResult(data, gqlErrors);
+  }
+  return {
+    storefront: {
+      /**
+       * Sends a GraphQL query to the Storefront API.
+       *
+       * Example:
+       *
+       * ```js
+       * async function loader ({context: {storefront}}) {
+       *   const data = await storefront.query('query { ... }', {
+       *     variables: {},
+       *     cache: storefront.CacheLong()
+       *   });
+       * }
+       * ```
+       */
+      query(query, options2) {
+        query = minifyQuery(query);
+        assertQuery(query, "storefront.query");
+        const stackOffset = getStackOffset?.(query);
+        return withSyncStack(
+          fetchStorefrontApi({
+            ...options2,
+            query,
+            stackInfo: getCallerStackLine?.(stackOffset)
+          }),
+          { stackOffset, logErrors }
+        );
+      },
+      /**
+       * Sends a GraphQL mutation to the Storefront API.
+       *
+       * Example:
+       *
+       * ```js
+       * async function loader ({context: {storefront}}) {
+       *   await storefront.mutate('mutation { ... }', {
+       *     variables: {},
+       *   });
+       * }
+       * ```
+       */
+      mutate(mutation, options2) {
+        mutation = minifyQuery(mutation);
+        assertMutation(mutation, "storefront.mutate");
+        const stackOffset = getStackOffset?.(mutation);
+        return withSyncStack(
+          fetchStorefrontApi({
+            ...options2,
+            mutation,
+            stackInfo: getCallerStackLine?.(stackOffset)
+          }),
+          { stackOffset, logErrors }
+        );
+      },
+      cache,
+      CacheNone,
+      CacheLong,
+      CacheShort,
+      CacheCustom,
+      generateCacheControlHeader,
+      getPublicTokenHeaders,
+      getPrivateTokenHeaders,
+      getShopifyDomain,
+      getApiUrl: getStorefrontApiUrl,
+      /**
+       * @deprecated
+       * Wether it's a GraphQL error returned in the Storefront API response.
+       *
+       * Example:
+       *
+       * ```js
+       * async function loader ({context: {storefront}}) {
+       *   try {
+       *     await storefront.query(...);
+       *   } catch(error) {
+       *     if (storefront.isApiError(error)) {
+       *       // ...
+       *     }
+       *
+       *     throw error;
+       *   }
+       * }
+       * ```
+       */
+      isApiError: (error) => {
+        {
+          warnOnce(
+            "`isApiError` is deprecated. An `errors` object would be returned from the API if there is an error."
+          );
+        }
+        return false;
+      },
+      i18n: i18n ?? defaultI18n
+    }
+  };
+}
+var getStackOffset = (query) => {
+  let stackOffset = 0;
+  if (/fragment CartApi(Query|Mutation) on Cart/.test(query)) {
+    stackOffset = 1;
+  }
+  return stackOffset;
+} ;
+function formatAPIResult(data, errors) {
+  return {
+    ...data,
+    ...errors && { errors }
+  };
+}
+
+// src/utils/request.ts
+function getHeader(request, key) {
+  const value = request.headers?.get?.(key) ?? request.headers?.[key];
+  return typeof value === "string" ? value : null;
+}
+function getDebugHeaders(request) {
+  return {
+    requestId: request ? getHeader(request, "request-id") : void 0,
+    purpose: request ? getHeader(request, "purpose") : void 0
+  };
+}
+
+// src/with-cache.ts
+function createWithCache({
+  cache,
+  waitUntil,
+  request
+}) {
+  return function withCache(cacheKey, strategy, actionFn) {
+    return runWithCache(cacheKey, actionFn, {
+      strategy,
+      cacheInstance: cache,
+      waitUntil,
+      debugInfo: {
+        ...getDebugHeaders(request),
+        stackInfo: getCallerStackLine?.()
+      }
+    });
+  };
+}
+
+// src/cache/in-memory.ts
+var InMemoryCache = class {
+  #store;
+  constructor() {
+    this.#store = /* @__PURE__ */ new Map();
+  }
+  add(request) {
+    throw new Error("Method not implemented. Use `put` instead.");
+  }
+  addAll(requests) {
+    throw new Error("Method not implemented. Use `put` instead.");
+  }
+  matchAll(request, options) {
+    throw new Error("Method not implemented. Use `match` instead.");
+  }
+  async put(request, response) {
+    if (request.method !== "GET") {
+      throw new TypeError("Cannot cache response to non-GET request.");
+    }
+    if (response.status === 206) {
+      throw new TypeError(
+        "Cannot cache response to a range request (206 Partial Content)."
+      );
+    }
+    if (response.headers.get("vary")?.includes("*")) {
+      throw new TypeError("Cannot cache response with 'Vary: *' header.");
+    }
+    this.#store.set(request.url, {
+      body: new Uint8Array(await response.arrayBuffer()),
+      status: response.status,
+      headers: [...response.headers],
+      timestamp: Date.now()
+    });
+  }
+  async match(request) {
+    if (request.method !== "GET")
+      return;
+    const match = this.#store.get(request.url);
+    if (!match) {
+      return;
+    }
+    const { body, timestamp, ...metadata } = match;
+    const headers = new Headers(metadata.headers);
+    const cacheControl = headers.get("cache-control") || headers.get("real-cache-control") || "";
+    const maxAge = parseInt(
+      cacheControl.match(/max-age=(\d+)/)?.[1] || "0",
+      10
+    );
+    const swr = parseInt(
+      cacheControl.match(/stale-while-revalidate=(\d+)/)?.[1] || "0",
+      10
+    );
+    const age = (Date.now() - timestamp) / 1e3;
+    const isMiss = age > maxAge + swr;
+    if (isMiss) {
+      this.#store.delete(request.url);
+      return;
+    }
+    const isStale3 = age > maxAge;
+    headers.set("cache", isStale3 ? "STALE" : "HIT");
+    headers.set("date", new Date(timestamp).toUTCString());
+    return new Response(body, {
+      status: metadata.status ?? 200,
+      headers
+    });
+  }
+  async delete(request) {
+    if (this.#store.has(request.url)) {
+      this.#store.delete(request.url);
+      return true;
+    }
+    return false;
+  }
+  keys(request) {
+    const cacheKeys = [];
+    for (const url of this.#store.keys()) {
+      if (!request || request.url === url) {
+        cacheKeys.push(new Request(url));
+      }
+    }
+    return Promise.resolve(cacheKeys);
+  }
+};
+
+// src/utils/get-redirect-url.ts
+function getRedirectUrl(requestUrl) {
+  if (!requestUrl)
+    return;
+  const { pathname, search } = new URL(requestUrl);
+  const redirectFrom = pathname + search;
+  const searchParams = new URLSearchParams(search);
+  const redirectTo = searchParams.get("return_to") || searchParams.get("redirect");
+  if (redirectTo) {
+    if (isLocalPath(requestUrl, redirectTo)) {
+      return redirectTo;
+    } else {
+      console.warn(
+        `Cross-domain redirects are not supported. Tried to redirect from ${redirectFrom} to ${redirectTo}`
+      );
+    }
+  }
+}
+function isLocalPath(requestUrl, redirectUrl) {
+  try {
+    return new URL(requestUrl).origin === new URL(redirectUrl, requestUrl).origin;
+  } catch (e) {
+    return false;
+  }
+}
+
+// src/routing/redirect.ts
+async function storefrontRedirect(options) {
+  const {
+    storefront,
+    request,
+    noAdminRedirect,
+    response = new Response("Not Found", { status: 404 })
+  } = options;
+  const url = new URL(request.url);
+  const isSoftNavigation = url.searchParams.has("_data");
+  url.searchParams.delete("_data");
+  const redirectFrom = url.toString().replace(url.origin, "");
+  if (url.pathname === "/admin" && !noAdminRedirect) {
+    return createRedirectResponse(
+      `${storefront.getShopifyDomain()}/admin`,
+      isSoftNavigation
+    );
+  }
+  try {
+    const { urlRedirects } = await storefront.query(REDIRECT_QUERY, {
+      variables: { query: "path:" + redirectFrom }
+    });
+    const location = urlRedirects?.edges?.[0]?.node?.target;
+    if (location) {
+      return createRedirectResponse(location, isSoftNavigation);
+    }
+    const redirectTo = getRedirectUrl(request.url);
+    if (redirectTo) {
+      return createRedirectResponse(redirectTo, isSoftNavigation);
+    }
+  } catch (error) {
+    console.error(
+      `Failed to fetch redirects from Storefront API for route ${redirectFrom}`,
+      error
+    );
+  }
+  return response;
+}
+function createRedirectResponse(location, isSoftNavigation) {
+  if (isSoftNavigation) {
+    return new Response(null, {
+      status: 200,
+      headers: { "X-Remix-Redirect": location, "X-Remix-Status": "302" }
+    });
+  } else {
+    return new Response(null, {
+      status: 302,
+      headers: { location }
+    });
+  }
+}
+var REDIRECT_QUERY = `#graphql
+  query redirects($query: String) {
+    urlRedirects(first: 1, query: $query) {
+      edges {
+        node {
+          target
+        }
+      }
+    }
+  }
+`;
+
+// src/routing/graphiql.ts
+var graphiqlLoader = async function graphiqlLoader2({
+  request,
+  context
+}) {
+  const storefront = context.storefront;
+  const customerAccount = context.customerAccount;
+  const url = new URL(request.url);
+  if (!storefront) {
+    throw new Error(
+      `GraphiQL: Hydrogen's storefront client must be injected in the loader context.`
+    );
+  }
+  const schemas = {};
+  if (storefront) {
+    const authHeader = "X-Shopify-Storefront-Access-Token";
+    schemas.storefront = {
+      name: "Storefront API",
+      authHeader,
+      accessToken: storefront.getPublicTokenHeaders()[authHeader],
+      apiUrl: storefront.getApiUrl(),
+      icon: "SF"
+    };
+  }
+  if (customerAccount) {
+    const customerAccountSchema = await (await fetch(url.origin + "/graphiql/customer-account.schema.json")).json();
+    const accessToken = await customerAccount.getAccessToken();
+    if (customerAccountSchema) {
+      schemas["customer-account"] = {
+        name: "Customer Account API",
+        value: customerAccountSchema,
+        authHeader: "Authorization",
+        accessToken,
+        apiUrl: customerAccount.getApiUrl(),
+        icon: "CA"
+      };
+    }
+  }
+  const favicon = `https://avatars.githubusercontent.com/u/12972006?s=48&v=4`;
+  const html = String.raw;
+  return new Response(
+    html`
+      <!DOCTYPE html>
+      <html lang="en">
+        <head>
+          <title>GraphiQL</title>
+          <link rel="icon" type="image/x-icon" href="${favicon}" />
+          <style>
+            body {
+              height: 100%;
+              margin: 0;
+              width: 100%;
+              overflow: hidden;
+              background-color: hsl(219, 29%, 18%);
+            }
+
+            #graphiql {
+              height: 100vh;
+            }
+
+            #graphiql > .placeholder {
+              color: slategray;
+              width: fit-content;
+              margin: 40px auto;
+              font-family: Arial;
+            }
+
+            .graphiql-api-toolbar-label {
+              position: absolute;
+              bottom: -6px;
+              right: -4px;
+              font-size: 8px;
+            }
+          </style>
+
+          <script
+            crossorigin
+            src="https://unpkg.com/react@18/umd/react.development.js"
+          ></script>
+          <script
+            crossorigin
+            src="https://unpkg.com/react-dom@18/umd/react-dom.development.js"
+          ></script>
+          <link
+            rel="stylesheet"
+            href="https://unpkg.com/graphiql@3/graphiql.min.css"
+          />
+          <link
+            rel="stylesheet"
+            href="https://unpkg.com/@graphiql/plugin-explorer/dist/style.css"
+          />
+        </head>
+
+        <body>
+          <div id="graphiql">
+            <div class="placeholder">Loading GraphiQL...</div>
+          </div>
+
+          <script
+            src="https://unpkg.com/graphiql@3/graphiql.min.js"
+            type="application/javascript"
+            crossorigin="anonymous"
+          ></script>
+          <script
+            src="https://unpkg.com/@graphiql/plugin-explorer/dist/index.umd.js"
+            type="application/javascript"
+            crossorigin="anonymous"
+          ></script>
+
+          <script>
+            const windowUrl = new URL(document.URL);
+            const startingSchemaKey =
+              windowUrl.searchParams.get('schema') || 'storefront';
+
+            let query = '{ shop { name } }';
+            if (windowUrl.searchParams.has('query')) {
+              query = decodeURIComponent(
+                windowUrl.searchParams.get('query') ?? query,
+              );
+            }
+
+            // Prettify query
+            query = GraphiQL.GraphQL.print(GraphiQL.GraphQL.parse(query));
+
+            let variables;
+            if (windowUrl.searchParams.has('variables')) {
+              variables = decodeURIComponent(
+                windowUrl.searchParams.get('variables') ?? '',
+              );
+            }
+
+            // Prettify variables
+            if (variables) {
+              variables = JSON.stringify(JSON.parse(variables), null, 2);
+            }
+
+            const schemas = ${JSON.stringify(schemas)};
+            let lastActiveTabIndex = -1;
+            let lastTabAmount = -1;
+
+            const root = ReactDOM.createRoot(
+              document.getElementById('graphiql'),
+            );
+
+            root.render(React.createElement(RootWrapper));
+
+            const TAB_STATE_KEY = 'graphiql:tabState';
+            const storage = {
+              getTabState: () =>
+                JSON.parse(localStorage.getItem(TAB_STATE_KEY)),
+              setTabState: (state) =>
+                localStorage.setItem(TAB_STATE_KEY, JSON.stringify(state)),
+            };
+
+            let nextSchemaKey;
+
+            function RootWrapper() {
+              const [activeSchema, setActiveSchema] =
+                React.useState(startingSchemaKey);
+
+              const schema = schemas[activeSchema];
+              if (!schema) {
+                throw new Error('No schema found for ' + activeSchema);
+              }
+
+              const keys = Object.keys(schemas);
+
+              return React.createElement(
+                GraphiQL,
+                {
+                  fetcher: GraphiQL.createFetcher({
+                    url: schema.apiUrl,
+                    headers: {[schema.authHeader]: schema.accessToken},
+                  }),
+                  defaultEditorToolsVisibility: true,
+                  query,
+                  variables,
+                  schema: schema.value,
+                  plugins: [GraphiQLPluginExplorer.explorerPlugin()],
+                  onTabChange: (state) => {
+                    const {activeTabIndex, tabs} = state;
+                    const activeTab = tabs[activeTabIndex];
+
+                    if (
+                      activeTabIndex === lastActiveTabIndex &&
+                      lastTabAmount === tabs.length
+                    ) {
+                      if (
+                        nextSchemaKey &&
+                        activeTab &&
+                        activeTab.schemaKey !== nextSchemaKey
+                      ) {
+                        activeTab.schemaKey = nextSchemaKey;
+                        nextSchemaKey = undefined;
+
+                        // Sync state to localStorage. GraphiQL resets the state
+                        // asynchronously, so we need to do it in a timeout.
+                        storage.setTabState(state);
+                        setTimeout(() => storage.setTabState(state), 500);
+                      }
+
+                      // React rerrendering, skip
+                      return;
+                    }
+
+                    if (activeTab) {
+                      if (!activeTab.schemaKey) {
+                        // Creating a new tab
+                        if (lastTabAmount < tabs.length) {
+                          activeTab.schemaKey = activeSchema;
+                          storage.setTabState(state);
+                        }
+                      }
+
+                      const nextSchema = activeTab.schemaKey || 'storefront';
+
+                      if (nextSchema !== activeSchema) {
+                        setActiveSchema(nextSchema);
+                      }
+                    }
+
+                    lastActiveTabIndex = activeTabIndex;
+                    lastTabAmount = tabs.length;
+                  },
+                  toolbar: {
+                    additionalComponent: function () {
+                      const schema = schemas[activeSchema];
+
+                      return React.createElement(
+                        GraphiQL.React.ToolbarButton,
+                        {
+                          onClick: () => {
+                            const activeKeyIndex = keys.indexOf(activeSchema);
+                            nextSchemaKey =
+                              keys[(activeKeyIndex + 1) % keys.length];
+
+                            // This triggers onTabChange
+                            if (nextSchemaKey) setActiveSchema(nextSchemaKey);
+                          },
+                          label: 'Toggle between different API schemas',
+                        },
+                        React.createElement(
+                          'div',
+                          {
+                            key: 'api-wrapper',
+                            className: 'graphiql-toolbar-icon',
+                            style: {position: 'relative', fontWeight: 'bolder'},
+                          },
+                          [
+                            React.createElement(
+                              'div',
+                              {key: 'icon', style: {textAlign: 'center'}},
+                              [
+                                schema.icon,
+                                React.createElement(
+                                  'div',
+                                  {
+                                    key: 'icon-label',
+                                    className: 'graphiql-api-toolbar-label',
+                                  },
+                                  'API',
+                                ),
+                              ],
+                            ),
+                          ],
+                        ),
+                      );
+                    },
+                  },
+                },
+                [
+                  React.createElement(
+                    GraphiQL.Logo,
+                    {
+                      key: 'Logo replacement',
+                    },
+                    [
+                      React.createElement(
+                        'div',
+                        {
+                          key: 'Logo wrapper',
+                          style: {display: 'flex', alignItems: 'center'},
+                        },
+                        [
+                          React.createElement(
+                            'div',
+                            {
+                              key: 'api',
+                              className: 'graphiql-logo',
+                              style: {
+                                paddingRight: 0,
+                                whiteSpace: 'nowrap',
+                              },
+                            },
+                            [schema.name],
+                          ),
+                          React.createElement(GraphiQL.Logo, {key: 'logo'}),
+                        ],
+                      ),
+                    ],
+                  ),
+                ],
+              );
+            }
+          </script>
+        </body>
+      </html>
+    `,
+    { status: 200, headers: { "content-type": "text/html" } }
+  );
+};
+
+// src/seo/escape.ts
+var ESCAPE_LOOKUP = {
+  "&": "\\u0026",
+  ">": "\\u003e",
+  "<": "\\u003c",
+  "\u2028": "\\u2028",
+  "\u2029": "\\u2029"
+};
+var ESCAPE_REGEX = /[&><\u2028\u2029]/g;
+function escapeHtml(html) {
+  return html.replace(ESCAPE_REGEX, (match) => ESCAPE_LOOKUP[match]);
+}
+
+// src/seo/generate-seo-tags.ts
+var ERROR_PREFIX = "Error in SEO input: ";
+var schema = {
+  title: {
+    validate: (value) => {
+      if (typeof value !== "string") {
+        throw new Error(ERROR_PREFIX.concat("`title` should be a string"));
+      }
+      if (typeof value === "string" && value.length > 120) {
+        throw new Error(
+          ERROR_PREFIX.concat(
+            "`title` should not be longer than 120 characters"
+          )
+        );
+      }
+      return value;
+    }
+  },
+  description: {
+    validate: (value) => {
+      if (typeof value !== "string") {
+        throw new Error(
+          ERROR_PREFIX.concat("`description` should be a string")
+        );
+      }
+      if (typeof value === "string" && value.length > 155) {
+        throw new Error(
+          ERROR_PREFIX.concat(
+            "`description` should not be longer than 155 characters"
+          )
+        );
+      }
+      return value;
+    }
+  },
+  url: {
+    validate: (value) => {
+      if (typeof value !== "string") {
+        throw new Error(ERROR_PREFIX.concat("`url` should be a string"));
+      }
+      if (typeof value === "string" && !value.startsWith("http")) {
+        throw new Error(ERROR_PREFIX.concat("`url` should be a valid URL"));
+      }
+      return value;
+    }
+  },
+  handle: {
+    validate: (value) => {
+      if (typeof value !== "string") {
+        throw new Error(ERROR_PREFIX.concat("`handle` should be a string"));
+      }
+      if (typeof value === "string" && !value.startsWith("@")) {
+        throw new Error(ERROR_PREFIX.concat("`handle` should start with `@`"));
+      }
+      return value;
+    }
+  }
+};
+function generateSeoTags(seoInput) {
+  const tagResults = [];
+  for (const seoKey of Object.keys(seoInput)) {
+    switch (seoKey) {
+      case "title": {
+        const content = validate(schema.title, seoInput.title);
+        const title = renderTitle(seoInput?.titleTemplate, content);
+        if (!title) {
+          break;
+        }
+        tagResults.push(
+          generateTag("title", { title }),
+          generateTag("meta", { property: "og:title", content: title }),
+          generateTag("meta", { name: "twitter:title", content: title })
+        );
+        break;
+      }
+      case "description": {
+        const content = validate(schema.description, seoInput.description);
+        if (!content) {
+          break;
+        }
+        tagResults.push(
+          generateTag("meta", {
+            name: "description",
+            content
+          }),
+          generateTag("meta", {
+            property: "og:description",
+            content
+          }),
+          generateTag("meta", {
+            name: "twitter:description",
+            content
+          })
+        );
+        break;
+      }
+      case "url": {
+        const content = validate(schema.url, seoInput.url);
+        if (!content) {
+          break;
+        }
+        const urlWithoutParams = content.split("?")[0];
+        const urlWithoutTrailingSlash = urlWithoutParams.replace(/\/$/, "");
+        tagResults.push(
+          generateTag("link", {
+            rel: "canonical",
+            href: urlWithoutTrailingSlash
+          }),
+          generateTag("meta", {
+            property: "og:url",
+            content: urlWithoutTrailingSlash
+          })
+        );
+        break;
+      }
+      case "handle": {
+        const content = validate(schema.handle, seoInput.handle);
+        if (!content) {
+          break;
+        }
+        tagResults.push(
+          generateTag("meta", { name: "twitter:site", content }),
+          generateTag("meta", { name: "twitter:creator", content })
+        );
+        break;
+      }
+      case "media": {
+        let content;
+        const values = ensureArray(seoInput.media);
+        for (const media of values) {
+          if (typeof media === "string") {
+            tagResults.push(
+              generateTag("meta", { name: "og:image", content: media })
+            );
+          }
+          if (media && typeof media === "object") {
+            const type = media.type || "image";
+            const normalizedMedia = media ? {
+              url: media?.url,
+              secure_url: media?.url,
+              type: inferMimeType(media.url),
+              width: media?.width,
+              height: media?.height,
+              alt: media?.altText
+            } : {};
+            for (const key of Object.keys(normalizedMedia)) {
+              if (normalizedMedia[key]) {
+                content = normalizedMedia[key];
+                tagResults.push(
+                  generateTag(
+                    "meta",
+                    {
+                      property: `og:${type}:${key}`,
+                      content
+                    },
+                    normalizedMedia.url
+                  )
+                );
+              }
+            }
+          }
+        }
+        break;
+      }
+      case "jsonLd": {
+        const jsonLdBlocks = ensureArray(seoInput.jsonLd);
+        let index = 0;
+        for (const block of jsonLdBlocks) {
+          if (typeof block !== "object") {
+            continue;
+          }
+          const tag = generateTag(
+            "script",
+            {
+              type: "application/ld+json",
+              children: JSON.stringify(block, (k, value) => {
+                return typeof value === "string" ? escapeHtml(value) : value;
+              })
+            },
+            // @ts-expect-error
+            `json-ld-${block?.["@type"] || block?.name || index++}`
+          );
+          tagResults.push(tag);
+        }
+        break;
+      }
+      case "alternates": {
+        const alternates = ensureArray(seoInput.alternates);
+        for (const alternate of alternates) {
+          if (!alternate) {
+            continue;
+          }
+          const { language, url, default: defaultLang } = alternate;
+          const hrefLang = language ? `${language}${defaultLang ? "-default" : ""}` : void 0;
+          tagResults.push(
+            generateTag("link", {
+              rel: "alternate",
+              hrefLang,
+              href: url
+            })
+          );
+        }
+        break;
+      }
+      case "robots": {
+        if (!seoInput.robots) {
+          break;
+        }
+        const {
+          maxImagePreview,
+          maxSnippet,
+          maxVideoPreview,
+          noArchive,
+          noFollow,
+          noImageIndex,
+          noIndex,
+          noSnippet,
+          noTranslate,
+          unavailableAfter
+        } = seoInput.robots;
+        const robotsParams = [
+          noArchive && "noarchive",
+          noImageIndex && "noimageindex",
+          noSnippet && "nosnippet",
+          noTranslate && `notranslate`,
+          maxImagePreview && `max-image-preview:${maxImagePreview}`,
+          maxSnippet && `max-snippet:${maxSnippet}`,
+          maxVideoPreview && `max-video-preview:${maxVideoPreview}`,
+          unavailableAfter && `unavailable_after:${unavailableAfter}`
+        ];
+        let robotsParam = (noIndex ? "noindex" : "index") + "," + (noFollow ? "nofollow" : "follow");
+        for (let param of robotsParams) {
+          if (param) {
+            robotsParam += `,${param}`;
+          }
+        }
+        tagResults.push(
+          generateTag("meta", { name: "robots", content: robotsParam })
+        );
+        break;
+      }
+    }
+  }
+  return tagResults.flat().sort((a, b) => a.key.localeCompare(b.key));
+}
+function generateTag(tagName, input, group) {
+  const tag = { tag: tagName, props: {}, key: "" };
+  if (tagName === "title") {
+    tag.children = input.title;
+    tag.key = generateKey(tag);
+    return tag;
+  }
+  if (tagName === "script") {
+    tag.children = typeof input.children === "string" ? input.children : "";
+    tag.key = generateKey(tag, group);
+    delete input.children;
+    tag.props = input;
+    return tag;
+  }
+  tag.props = input;
+  Object.keys(tag.props).forEach(
+    (key) => !tag.props[key] && delete tag.props[key]
+  );
+  tag.key = generateKey(tag, group);
+  return tag;
+}
+function generateKey(tag, group) {
+  const { tag: tagName, props } = tag;
+  if (tagName === "title") {
+    return "0-title";
+  }
+  if (tagName === "meta") {
+    const priority = props.content === group && typeof props.property === "string" && !props.property.endsWith("secure_url") && "0";
+    const groupName = [group, priority];
+    return [tagName, ...groupName, props.property || props.name].filter((x) => x).join("-");
+  }
+  if (tagName === "link") {
+    const key = [tagName, props.rel, props.hrefLang || props.media].filter((x) => x).join("-");
+    return key.replace(/\s+/g, "-");
+  }
+  if (tagName === "script") {
+    return `${tagName}-${group}`;
+  }
+  return `${tagName}-${props.type}`;
+}
+function renderTitle(template, title) {
+  if (!title) {
+    return void 0;
+  }
+  if (!template) {
+    return title;
+  }
+  if (typeof template === "function") {
+    return template(title);
+  }
+  return template.replace("%s", title ?? "");
+}
+function inferMimeType(url) {
+  const ext = url && url.split(".").pop();
+  switch (ext) {
+    case "svg":
+      return "image/svg+xml";
+    case "png":
+      return "image/png";
+    case "gif":
+      return "image/gif";
+    case "swf":
+      return "application/x-shockwave-flash";
+    case "mp3":
+      return "audio/mpeg";
+    case "jpg":
+    case "jpeg":
+    default:
+      return "image/jpeg";
+  }
+}
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function validate(schema2, data) {
+  try {
+    return schema2.validate(data);
+  } catch (error) {
+    console.warn(error.message);
+    return data;
+  }
+}
+
+// src/seo/seo.ts
+var SeoLogger = react.lazy(() => Promise.resolve().then(() => (init_log_seo_tags(), log_seo_tags_exports)));
+function Seo({ debug }) {
+  const matches = react$1.useMatches();
+  const location = react$1.useLocation();
+  const seoConfig = react.useMemo(() => {
+    return matches.flatMap((match) => {
+      const { handle, ...routeMatch } = match;
+      const routeData = { ...routeMatch, ...location };
+      const handleSeo = handle?.seo;
+      const loaderSeo = routeMatch?.data?.seo;
+      if (!handleSeo && !loaderSeo) {
+        return [];
+      }
+      if (handleSeo) {
+        return recursivelyInvokeOrReturn(handleSeo, routeData);
+      } else {
+        return [loaderSeo];
+      }
+    }).reduce((acc, current) => {
+      Object.keys(current).forEach(
+        (key) => !current[key] && delete current[key]
+      );
+      const { jsonLd } = current;
+      if (!jsonLd) {
+        return { ...acc, ...current };
+      }
+      if (!acc?.jsonLd) {
+        return { ...acc, ...current, jsonLd: [jsonLd] };
+      } else {
+        if (Array.isArray(jsonLd)) {
+          return {
+            ...acc,
+            ...current,
+            jsonLd: [...acc.jsonLd, ...jsonLd]
+          };
+        } else {
+          return {
+            ...acc,
+            ...current,
+            jsonLd: [...acc.jsonLd, jsonLd]
+          };
+        }
+      }
+    }, {});
+  }, [matches, location]);
+  const { html, loggerMarkup } = react.useMemo(() => {
+    const headTags = generateSeoTags(seoConfig);
+    const html2 = headTags.map((tag) => {
+      if (tag.tag === "script") {
+        return react.createElement(tag.tag, {
+          ...tag.props,
+          key: tag.key,
+          dangerouslySetInnerHTML: { __html: tag.children }
+        });
+      }
+      return react.createElement(tag.tag, { ...tag.props, key: tag.key }, tag.children);
+    });
+    const loggerMarkup2 = react.createElement(
+      react.Suspense,
+      { fallback: null },
+      react.createElement(SeoLogger, { headTags })
+    );
+    return { html: html2, loggerMarkup: loggerMarkup2 };
+  }, [seoConfig]);
+  return react.createElement(react.Fragment, null, html, debug && loggerMarkup);
+}
+function recursivelyInvokeOrReturn(value, ...rest) {
+  if (value instanceof Function) {
+    return recursivelyInvokeOrReturn(value(...rest), ...rest);
+  }
+  let result = {};
+  if (Array.isArray(value)) {
+    result = value.reduce((acc, item) => {
+      return [...acc, recursivelyInvokeOrReturn(item)];
+    }, []);
+    return result;
+  }
+  if (value instanceof Object) {
+    const entries = Object.entries(value);
+    entries.forEach(([key, val]) => {
+      result[key] = recursivelyInvokeOrReturn(val, ...rest);
+    });
+    return result;
+  }
+  return value;
+}
+function Pagination({
+  connection,
+  children = () => {
+    console.warn("<Pagination> requires children to work properly");
+    return null;
+  }
+}) {
+  const transition = react$1.useNavigation();
+  const isLoading = transition.state === "loading";
+  const {
+    endCursor,
+    hasNextPage,
+    hasPreviousPage,
+    nextPageUrl,
+    nodes,
+    previousPageUrl,
+    startCursor
+  } = usePagination(connection);
+  const state = react.useMemo(
+    () => ({
+      pageInfo: {
+        endCursor,
+        hasPreviousPage,
+        hasNextPage,
+        startCursor
+      },
+      nodes
+    }),
+    [endCursor, hasNextPage, hasPreviousPage, startCursor, nodes]
+  );
+  const NextLink = react.useMemo(
+    () => react.forwardRef(function NextLink2(props, ref) {
+      return hasNextPage ? react.createElement(react$1.Link, {
+        preventScrollReset: true,
+        ...props,
+        to: nextPageUrl,
+        state,
+        replace: true,
+        ref
+      }) : null;
+    }),
+    [hasNextPage, nextPageUrl, state]
+  );
+  const PreviousLink = react.useMemo(
+    () => react.forwardRef(function PrevLink(props, ref) {
+      return hasPreviousPage ? react.createElement(react$1.Link, {
+        preventScrollReset: true,
+        ...props,
+        to: previousPageUrl,
+        state,
+        replace: true,
+        ref
+      }) : null;
+    }),
+    [hasPreviousPage, previousPageUrl, state]
+  );
+  return children({
+    state,
+    hasNextPage,
+    hasPreviousPage,
+    isLoading,
+    nextPageUrl,
+    nodes,
+    previousPageUrl,
+    NextLink,
+    PreviousLink
+  });
+}
+function getParamsWithoutPagination(paramsString) {
+  const params = new URLSearchParams(paramsString);
+  params.delete("cursor");
+  params.delete("direction");
+  return params.toString();
+}
+function makeError(prop) {
+  throw new Error(
+    `The Pagination component requires ${"`" + prop + "`"} to be a part of your query. See the guide on how to setup your query to include ${"`" + prop + "`"}: https://shopify.dev/docs/custom-storefronts/hydrogen/data-fetching/pagination#setup-the-paginated-query`
+  );
+}
+function usePagination(connection) {
+  if (!connection.pageInfo) {
+    makeError("pageInfo");
+  }
+  if (typeof connection.pageInfo.startCursor === "undefined") {
+    makeError("pageInfo.startCursor");
+  }
+  if (typeof connection.pageInfo.endCursor === "undefined") {
+    makeError("pageInfo.endCursor");
+  }
+  if (typeof connection.pageInfo.hasNextPage === "undefined") {
+    makeError("pageInfo.hasNextPage");
+  }
+  if (typeof connection.pageInfo.hasPreviousPage === "undefined") {
+    makeError("pageInfo.hasPreviousPage");
+  }
+  const navigate = react$1.useNavigate();
+  const { state, search, pathname } = react$1.useLocation();
+  const params = new URLSearchParams(search);
+  const direction = params.get("direction");
+  const isPrevious = direction === "previous";
+  const nodes = react.useMemo(() => {
+    if (!globalThis?.window?.__hydrogenHydrated || !state || !state?.nodes) {
+      return hydrogenReact.flattenConnection(connection);
+    }
+    if (isPrevious) {
+      return [...hydrogenReact.flattenConnection(connection), ...state.nodes];
+    } else {
+      return [...state.nodes, ...hydrogenReact.flattenConnection(connection)];
+    }
+  }, [state, connection]);
+  const currentPageInfo = react.useMemo(() => {
+    const hydrogenHydrated = globalThis?.window?.__hydrogenHydrated;
+    let pageStartCursor = !hydrogenHydrated || state?.pageInfo?.startCursor === void 0 ? connection.pageInfo.startCursor : state.pageInfo.startCursor;
+    let pageEndCursor = !hydrogenHydrated || state?.pageInfo?.endCursor === void 0 ? connection.pageInfo.endCursor : state.pageInfo.endCursor;
+    let previousPageExists = !hydrogenHydrated || state?.pageInfo?.hasPreviousPage === void 0 ? connection.pageInfo.hasPreviousPage : state.pageInfo.hasPreviousPage;
+    let nextPageExists = !hydrogenHydrated || state?.pageInfo?.hasNextPage === void 0 ? connection.pageInfo.hasNextPage : state.pageInfo.hasNextPage;
+    if (state?.nodes) {
+      if (isPrevious) {
+        pageStartCursor = connection.pageInfo.startCursor;
+        previousPageExists = connection.pageInfo.hasPreviousPage;
+      } else {
+        pageEndCursor = connection.pageInfo.endCursor;
+        nextPageExists = connection.pageInfo.hasNextPage;
+      }
+    }
+    return {
+      startCursor: pageStartCursor,
+      endCursor: pageEndCursor,
+      hasPreviousPage: previousPageExists,
+      hasNextPage: nextPageExists
+    };
+  }, [
+    isPrevious,
+    state,
+    connection.pageInfo.hasNextPage,
+    connection.pageInfo.hasPreviousPage,
+    connection.pageInfo.startCursor,
+    connection.pageInfo.endCursor
+  ]);
+  const urlRef = react.useRef({
+    params: getParamsWithoutPagination(search),
+    pathname
+  });
+  react.useEffect(() => {
+    window.__hydrogenHydrated = true;
+  }, []);
+  react.useEffect(() => {
+    if (
+      // If the URL changes (independent of pagination params)
+      // then reset the pagination params in the URL
+      getParamsWithoutPagination(search) !== urlRef.current.params || pathname !== urlRef.current.pathname
+    ) {
+      urlRef.current = {
+        pathname,
+        params: getParamsWithoutPagination(search)
+      };
+      navigate(`${pathname}?${getParamsWithoutPagination(search)}`, {
+        replace: true,
+        preventScrollReset: true,
+        state: { nodes: void 0, pageInfo: void 0 }
+      });
+    }
+  }, [pathname, search]);
+  const previousPageUrl = react.useMemo(() => {
+    const params2 = new URLSearchParams(search);
+    params2.set("direction", "previous");
+    currentPageInfo.startCursor && params2.set("cursor", currentPageInfo.startCursor);
+    return `?${params2.toString()}`;
+  }, [search, currentPageInfo.startCursor]);
+  const nextPageUrl = react.useMemo(() => {
+    const params2 = new URLSearchParams(search);
+    params2.set("direction", "next");
+    currentPageInfo.endCursor && params2.set("cursor", currentPageInfo.endCursor);
+    return `?${params2.toString()}`;
+  }, [search, currentPageInfo.endCursor]);
+  return { ...currentPageInfo, previousPageUrl, nextPageUrl, nodes };
+}
+function getPaginationVariables(request, options = { pageBy: 20 }) {
+  if (typeof request?.url === "undefined") {
+    throw new Error(
+      "getPaginationVariables must be called with the Request object passed to your loader function"
+    );
+  }
+  const { pageBy } = options;
+  const searchParams = new URLSearchParams(new URL(request.url).search);
+  const cursor = searchParams.get("cursor") ?? void 0;
+  const direction = searchParams.get("direction") === "previous" ? "previous" : "next";
+  const isPrevious = direction === "previous";
+  const prevPage = {
+    last: pageBy,
+    startCursor: cursor ?? null
+  };
+  const nextPage = {
+    first: pageBy,
+    endCursor: cursor ?? null
+  };
+  const variables = isPrevious ? prevPage : nextPage;
+  return variables;
+}
+
+// src/customer/constants.ts
+var DEFAULT_CUSTOMER_API_VERSION = "2024-01";
+var USER_AGENT = `Shopify Hydrogen ${LIB_VERSION}`;
+var CUSTOMER_API_CLIENT_ID = "30243aa5-17c1-465a-8493-944bcc4e88aa";
+var CUSTOMER_ACCOUNT_SESSION_KEY = "customerAccount";
+
+// src/customer/BadRequest.ts
+var BadRequest = class extends Response {
+  constructor(message, helpMessage, headers) {
+    if (helpMessage && true) {
+      console.error("Customer Account API Error: " + helpMessage);
+    }
+    super(`Bad request: ${message}`, { status: 400, headers });
+  }
+};
+
+// src/customer/auth.helpers.ts
+var logSubRequestEvent = ({
+  url,
+  response,
+  startTime,
+  query,
+  variables,
+  ...debugInfo
+}) => {
+  globalThis.__H2O_LOG_EVENT?.({
+    ...debugInfo,
+    eventType: "subrequest",
+    url,
+    startTime,
+    graphql: query ? JSON.stringify({ query, variables, schema: "customer-account" }) : void 0,
+    responseInit: {
+      status: response.status || 0,
+      statusText: response.statusText || "",
+      headers: Array.from(response.headers.entries() || [])
+    }
+  });
+} ;
+function redirect(path, options = {}) {
+  const headers = options.headers ? new Headers(options.headers) : new Headers({});
+  headers.set("location", path);
+  return new Response(null, { status: options.status || 302, headers });
+}
+async function refreshToken({
+  session,
+  customerAccountId,
+  customerAccountUrl,
+  origin,
+  debugInfo
+}) {
+  const newBody = new URLSearchParams();
+  const customerAccount = session.get(CUSTOMER_ACCOUNT_SESSION_KEY);
+  const refreshToken2 = customerAccount?.refreshToken;
+  if (!refreshToken2)
+    throw new BadRequest(
+      "Unauthorized",
+      "No refreshToken found in the session. Make sure your session is configured correctly and passed to `createCustomerAccountClient`."
+    );
+  newBody.append("grant_type", "refresh_token");
+  newBody.append("refresh_token", refreshToken2);
+  newBody.append("client_id", customerAccountId);
+  const headers = {
+    "content-type": "application/x-www-form-urlencoded",
+    "User-Agent": USER_AGENT,
+    Origin: origin
+  };
+  const startTime = (/* @__PURE__ */ new Date()).getTime();
+  const url = `${customerAccountUrl}/auth/oauth/token`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: newBody
+  });
+  logSubRequestEvent?.({
+    displayName: "Customer Account API: access token refresh",
+    url,
+    startTime,
+    response,
+    ...debugInfo
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Response(text, {
+      status: response.status,
+      headers: {
+        "Content-Type": "text/html; charset=utf-8"
+      }
+    });
+  }
+  const { access_token, expires_in, id_token, refresh_token } = await response.json();
+  const accessToken = await exchangeAccessToken(
+    access_token,
+    customerAccountId,
+    customerAccountUrl,
+    origin,
+    debugInfo
+  );
+  session.set(CUSTOMER_ACCOUNT_SESSION_KEY, {
+    accessToken,
+    // Store the date in future the token expires, separated by two minutes
+    expiresAt: new Date((/* @__PURE__ */ new Date()).getTime() + (expires_in - 120) * 1e3).getTime() + "",
+    refreshToken: refresh_token,
+    idToken: id_token
+  });
+}
+function clearSession(session) {
+  session.unset(CUSTOMER_ACCOUNT_SESSION_KEY);
+}
+async function checkExpires({
+  locks,
+  expiresAt,
+  session,
+  customerAccountId,
+  customerAccountUrl,
+  origin,
+  debugInfo
+}) {
+  if (parseInt(expiresAt, 10) - 1e3 < (/* @__PURE__ */ new Date()).getTime()) {
+    try {
+      if (!locks.refresh)
+        locks.refresh = refreshToken({
+          session,
+          customerAccountId,
+          customerAccountUrl,
+          origin,
+          debugInfo
+        });
+      await locks.refresh;
+      delete locks.refresh;
+    } catch (error) {
+      clearSession(session);
+      if (error && error.status !== 401) {
+        throw error;
+      } else {
+        throw new BadRequest(
+          "Unauthorized",
+          "Login before querying the Customer Account API.",
+          {
+            "Set-Cookie": await session.commit()
+          }
+        );
+      }
+    }
+  }
+}
+async function generateCodeVerifier() {
+  const rando = generateRandomCode();
+  return base64UrlEncode(rando);
+}
+async function generateCodeChallenge(codeVerifier) {
+  const digestOp = await crypto.subtle.digest(
+    { name: "SHA-256" },
+    new TextEncoder().encode(codeVerifier)
+  );
+  const hash = convertBufferToString(digestOp);
+  return base64UrlEncode(hash);
+}
+function generateRandomCode() {
+  const array = new Uint8Array(32);
+  crypto.getRandomValues(array);
+  return String.fromCharCode.apply(null, Array.from(array));
+}
+function base64UrlEncode(str) {
+  const base64 = btoa(str);
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function convertBufferToString(hash) {
+  const uintArray = new Uint8Array(hash);
+  const numberArray = Array.from(uintArray);
+  return String.fromCharCode(...numberArray);
+}
+async function generateState() {
+  const timestamp = Date.now().toString();
+  const randomString = Math.random().toString(36).substring(2);
+  return timestamp + randomString;
+}
+async function exchangeAccessToken(authAccessToken, customerAccountId, customerAccountUrl, origin, debugInfo) {
+  const clientId = customerAccountId;
+  if (!authAccessToken)
+    throw new BadRequest(
+      "Unauthorized",
+      "oAuth access token was not provided during token exchange."
+    );
+  const body = new URLSearchParams();
+  body.append("grant_type", "urn:ietf:params:oauth:grant-type:token-exchange");
+  body.append("client_id", clientId);
+  body.append("audience", CUSTOMER_API_CLIENT_ID);
+  body.append("subject_token", authAccessToken);
+  body.append(
+    "subject_token_type",
+    "urn:ietf:params:oauth:token-type:access_token"
+  );
+  body.append("scopes", "https://api.customers.com/auth/customer.graphql");
+  const headers = {
+    "content-type": "application/x-www-form-urlencoded",
+    "User-Agent": USER_AGENT,
+    Origin: origin
+  };
+  const startTime = (/* @__PURE__ */ new Date()).getTime();
+  const url = `${customerAccountUrl}/auth/oauth/token`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body
+  });
+  logSubRequestEvent?.({
+    displayName: "Customer Account API: access token exchange",
+    url,
+    startTime,
+    response,
+    ...debugInfo
+  });
+  const data = await response.json();
+  if (data.error) {
+    throw new BadRequest(data.error_description);
+  }
+  return data.access_token;
+}
+function getNonce(token) {
+  return decodeJwt(token).payload.nonce;
+}
+function decodeJwt(token) {
+  const [header, payload, signature] = token.split(".");
+  const decodedHeader = JSON.parse(atob(header));
+  const decodedPayload = JSON.parse(atob(payload));
+  return {
+    header: decodedHeader,
+    payload: decodedPayload,
+    signature
+  };
+}
+
+// src/csp/nonce.ts
+function generateNonce() {
+  return toHexString(randomUint8Array());
+}
+function randomUint8Array() {
+  try {
+    return crypto.getRandomValues(new Uint8Array(16));
+  } catch (e) {
+    return new Uint8Array(16).map(() => Math.random() * 255 | 0);
+  }
+}
+function toHexString(byteArray) {
+  return Array.from(byteArray, function(byte) {
+    return ("0" + (byte & 255).toString(16)).slice(-2);
+  }).join("");
+}
+
+// src/customer/customer.ts
+var DEFAULT_LOGIN_URL = "/account/login";
+var DEFAULT_AUTH_URL = "/account/authorize";
+var DEFAULT_REDIRECT_PATH = "/account";
+function defaultAuthStatusHandler(request) {
+  if (!request.url)
+    return DEFAULT_LOGIN_URL;
+  const { pathname } = new URL(request.url);
+  const redirectTo = DEFAULT_LOGIN_URL + `?${new URLSearchParams({ return_to: pathname }).toString()}`;
+  return redirect(redirectTo);
+}
+function createCustomerAccountClient({
+  session,
+  customerAccountId,
+  customerAccountUrl,
+  customerApiVersion = DEFAULT_CUSTOMER_API_VERSION,
+  request,
+  waitUntil,
+  authUrl = DEFAULT_AUTH_URL,
+  customAuthStatusHandler,
+  logErrors = true
+}) {
+  if (customerApiVersion !== DEFAULT_CUSTOMER_API_VERSION) {
+    console.warn(
+      `[h2:warn:createCustomerAccountClient] You are using Customer Account API version ${customerApiVersion} when this version of Hydrogen was built for ${DEFAULT_CUSTOMER_API_VERSION}.`
+    );
+  }
+  if (!customerAccountId || !customerAccountUrl) {
+    console.warn(
+      "[h2:warn:createCustomerAccountClient] `customerAccountId` and `customerAccountUrl` need to be provided to use Customer Account API. Mock.shop doesn't automatically supply these variables.\nUse `npx shopify hydrogen env pull` to link your store credentials."
+    );
+  }
+  if (!request?.url) {
+    throw new Error(
+      "[h2:error:createCustomerAccountClient] The request object does not contain a URL."
+    );
+  }
+  const authStatusHandler = customAuthStatusHandler ? customAuthStatusHandler : () => defaultAuthStatusHandler(request);
+  const requestUrl = new URL(request.url);
+  const origin = requestUrl.protocol === "http:" ? requestUrl.origin.replace("http", "https") : requestUrl.origin;
+  const redirectUri = authUrl.startsWith("/") ? origin + authUrl : authUrl;
+  const customerAccountApiUrl = `${customerAccountUrl}/account/customer/api/${customerApiVersion}/graphql`;
+  const locks = {};
+  async function fetchCustomerAPI({
+    query,
+    type,
+    variables = {}
+  }) {
+    const accessToken = await getAccessToken();
+    if (!accessToken) {
+      throw authStatusHandler();
+    }
+    const stackInfo = getCallerStackLine?.();
+    const startTime = (/* @__PURE__ */ new Date()).getTime();
+    const response = await fetch(customerAccountApiUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": USER_AGENT,
+        Origin: origin,
+        Authorization: accessToken
+      },
+      body: JSON.stringify({ query, variables })
+    });
+    logSubRequestEvent?.({
+      url: customerAccountApiUrl,
+      startTime,
+      response,
+      waitUntil,
+      stackInfo,
+      query,
+      variables,
+      ...getDebugHeaders(request)
+    });
+    const body = await response.text();
+    const errorOptions = {
+      url: customerAccountApiUrl,
+      response,
+      type,
+      query,
+      queryVariables: variables,
+      errors: void 0,
+      client: "customer"
+    };
+    if (!response.ok) {
+      if (response.status === 401) {
+        clearSession(session);
+        const authFailResponse = authStatusHandler();
+        if (authFailResponse instanceof Response) {
+          authFailResponse.headers.set("Set-Cookie", await session.commit());
+        }
+        throw authFailResponse;
+      }
+      let errors;
+      try {
+        errors = parseJSON(body);
+      } catch (_e) {
+        errors = [{ message: body }];
+      }
+      throwErrorWithGqlLink({ ...errorOptions, errors });
+    }
+    try {
+      const APIresponse = parseJSON(body);
+      const { errors } = APIresponse;
+      const gqlErrors = errors?.map(
+        ({ message, ...rest }) => new GraphQLError(message, {
+          ...rest,
+          clientOperation: `customerAccount.${errorOptions.type}`,
+          requestId: response.headers.get("x-request-id"),
+          queryVariables: variables,
+          query
+        })
+      );
+      return { ...APIresponse, ...errors && { errors: gqlErrors } };
+    } catch (e) {
+      throwErrorWithGqlLink({ ...errorOptions, errors: [{ message: body }] });
+    }
+  }
+  async function isLoggedIn() {
+    const customerAccount = session.get(CUSTOMER_ACCOUNT_SESSION_KEY);
+    const accessToken = customerAccount?.accessToken;
+    const expiresAt = customerAccount?.expiresAt;
+    if (!accessToken || !expiresAt)
+      return false;
+    const stackInfo = getCallerStackLine?.();
+    try {
+      await checkExpires({
+        locks,
+        expiresAt,
+        session,
+        customerAccountId,
+        customerAccountUrl,
+        origin,
+        debugInfo: {
+          waitUntil,
+          stackInfo,
+          ...getDebugHeaders(request)
+        }
+      });
+    } catch {
+      return false;
+    }
+    return true;
+  }
+  async function handleAuthStatus() {
+    if (!await isLoggedIn()) {
+      throw authStatusHandler();
+    }
+  }
+  async function getAccessToken() {
+    const hasAccessToken = await isLoggedIn();
+    if (hasAccessToken)
+      return session.get(CUSTOMER_ACCOUNT_SESSION_KEY)?.accessToken;
+  }
+  return {
+    login: async () => {
+      const loginUrl = new URL(customerAccountUrl + "/auth/oauth/authorize");
+      const state = await generateState();
+      const nonce = await generateNonce();
+      loginUrl.searchParams.set("client_id", customerAccountId);
+      loginUrl.searchParams.set("scope", "openid email");
+      loginUrl.searchParams.append("response_type", "code");
+      loginUrl.searchParams.append("redirect_uri", redirectUri);
+      loginUrl.searchParams.set(
+        "scope",
+        "openid email https://api.customers.com/auth/customer.graphql"
+      );
+      loginUrl.searchParams.append("state", state);
+      loginUrl.searchParams.append("nonce", nonce);
+      const verifier = await generateCodeVerifier();
+      const challenge = await generateCodeChallenge(verifier);
+      session.set(CUSTOMER_ACCOUNT_SESSION_KEY, {
+        ...session.get(CUSTOMER_ACCOUNT_SESSION_KEY),
+        codeVerifier: verifier,
+        state,
+        nonce,
+        redirectPath: getRedirectUrl(request.url) || getHeader(request, "Referer") || DEFAULT_REDIRECT_PATH
+      });
+      loginUrl.searchParams.append("code_challenge", challenge);
+      loginUrl.searchParams.append("code_challenge_method", "S256");
+      return redirect(loginUrl.toString(), {
+        headers: {
+          "Set-Cookie": await session.commit()
+        }
+      });
+    },
+    logout: async () => {
+      const idToken = session.get(CUSTOMER_ACCOUNT_SESSION_KEY)?.idToken;
+      clearSession(session);
+      return redirect(
+        `${customerAccountUrl}/auth/logout?id_token_hint=${idToken}`,
+        {
+          status: 302,
+          headers: {
+            "Set-Cookie": await session.commit()
+          }
+        }
+      );
+    },
+    isLoggedIn,
+    handleAuthStatus,
+    getAccessToken,
+    getApiUrl: () => customerAccountApiUrl,
+    mutate(mutation, options) {
+      mutation = minifyQuery(mutation);
+      assertMutation(mutation, "customer.mutate");
+      return withSyncStack(
+        fetchCustomerAPI({ query: mutation, type: "mutation", ...options }),
+        { logErrors }
+      );
+    },
+    query(query, options) {
+      query = minifyQuery(query);
+      assertQuery(query, "customer.query");
+      return withSyncStack(
+        fetchCustomerAPI({ query, type: "query", ...options }),
+        { logErrors }
+      );
+    },
+    authorize: async () => {
+      const code = requestUrl.searchParams.get("code");
+      const state = requestUrl.searchParams.get("state");
+      if (!code || !state) {
+        clearSession(session);
+        throw new BadRequest(
+          "Unauthorized",
+          "No code or state parameter found in the redirect URL.",
+          {
+            "Set-Cookie": await session.commit()
+          }
+        );
+      }
+      if (session.get(CUSTOMER_ACCOUNT_SESSION_KEY)?.state !== state) {
+        clearSession(session);
+        throw new BadRequest(
+          "Unauthorized",
+          "The session state does not match the state parameter. Make sure that the session is configured correctly and passed to `createCustomerAccountClient`.",
+          {
+            "Set-Cookie": await session.commit()
+          }
+        );
+      }
+      const clientId = customerAccountId;
+      const body = new URLSearchParams();
+      body.append("grant_type", "authorization_code");
+      body.append("client_id", clientId);
+      body.append("redirect_uri", redirectUri);
+      body.append("code", code);
+      const codeVerifier = session.get(
+        CUSTOMER_ACCOUNT_SESSION_KEY
+      )?.codeVerifier;
+      if (!codeVerifier)
+        throw new BadRequest(
+          "Unauthorized",
+          "No code verifier found in the session. Make sure that the session is configured correctly and passed to `createCustomerAccountClient`."
+        );
+      body.append("code_verifier", codeVerifier);
+      const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+        "User-Agent": USER_AGENT,
+        Origin: origin
+      };
+      const stackInfo = getCallerStackLine?.();
+      const startTime = (/* @__PURE__ */ new Date()).getTime();
+      const url = `${customerAccountUrl}/auth/oauth/token`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body
+      });
+      logSubRequestEvent?.({
+        url,
+        displayName: "Customer Account API: authorize",
+        startTime,
+        response,
+        waitUntil,
+        stackInfo,
+        ...getDebugHeaders(request)
+      });
+      if (!response.ok) {
+        throw new Response(await response.text(), {
+          status: response.status,
+          headers: {
+            "Content-Type": "text/html; charset=utf-8"
+          }
+        });
+      }
+      const { access_token, expires_in, id_token, refresh_token } = await response.json();
+      const sessionNonce = session.get(CUSTOMER_ACCOUNT_SESSION_KEY)?.nonce;
+      const responseNonce = await getNonce(id_token);
+      if (sessionNonce !== responseNonce) {
+        throw new BadRequest(
+          "Unauthorized",
+          `Returned nonce does not match: ${sessionNonce} !== ${responseNonce}`
+        );
+      }
+      const customerAccessToken = await exchangeAccessToken(
+        access_token,
+        customerAccountId,
+        customerAccountUrl,
+        origin,
+        {
+          waitUntil,
+          stackInfo,
+          ...getDebugHeaders(request)
+        }
+      );
+      const redirectPath = session.get(
+        CUSTOMER_ACCOUNT_SESSION_KEY
+      )?.redirectPath;
+      session.set(CUSTOMER_ACCOUNT_SESSION_KEY, {
+        accessToken: customerAccessToken,
+        expiresAt: new Date(
+          (/* @__PURE__ */ new Date()).getTime() + (expires_in - 120) * 1e3
+        ).getTime() + "",
+        refreshToken: refresh_token,
+        idToken: id_token,
+        redirectPath: void 0
+      });
+      return redirect(redirectPath || DEFAULT_REDIRECT_PATH, {
+        headers: {
+          "Set-Cookie": await session.commit()
+        }
+      });
+    }
+  };
+}
+
+// src/changelogHandler.ts
+var DEFAULT_GITHUB_CHANGELOG_URL = "https://raw.githubusercontent.com/Shopify/hydrogen/main/docs/changelog.json";
+async function changelogHandler({
+  request,
+  changelogUrl
+}) {
+  new URL(request.url).searchParams;
+  const GITHUB_CHANGELOG_URL = changelogUrl || DEFAULT_GITHUB_CHANGELOG_URL;
+  return fetch(GITHUB_CHANGELOG_URL);
+}
+var INPUT_NAME = "cartFormInput";
+function CartForm({
+  children,
+  action,
+  inputs,
+  route,
+  fetcherKey
+}) {
+  const fetcher = react$1.useFetcher({ key: fetcherKey });
+  return /* @__PURE__ */ jsxRuntime.jsxs(fetcher.Form, { action: route || "", method: "post", children: [
+    (action || inputs) && /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        type: "hidden",
+        name: INPUT_NAME,
+        value: JSON.stringify({ action, inputs })
+      }
+    ),
+    typeof children === "function" ? children(fetcher) : children
+  ] });
+}
+CartForm.INPUT_NAME = INPUT_NAME;
+CartForm.ACTIONS = {
+  AttributesUpdateInput: "AttributesUpdateInput",
+  BuyerIdentityUpdate: "BuyerIdentityUpdate",
+  Create: "Create",
+  DiscountCodesUpdate: "DiscountCodesUpdate",
+  LinesAdd: "LinesAdd",
+  LinesRemove: "LinesRemove",
+  LinesUpdate: "LinesUpdate",
+  NoteUpdate: "NoteUpdate",
+  SelectedDeliveryOptionsUpdate: "SelectedDeliveryOptionsUpdate",
+  MetafieldsSet: "MetafieldsSet",
+  MetafieldDelete: "MetafieldDelete"
+};
+function getFormInput(formData) {
+  const data = {};
+  for (const pair of formData.entries()) {
+    const key = pair[0];
+    const values = formData.getAll(key);
+    data[key] = values.length > 1 ? values : pair[1];
+  }
+  const { cartFormInput, ...otherData } = data;
+  const { action, inputs } = cartFormInput ? JSON.parse(String(cartFormInput)) : {};
+  return {
+    action,
+    inputs: {
+      ...inputs,
+      ...otherData
+    }
+  };
+}
+CartForm.getFormInput = getFormInput;
+
+// src/cart/queries/cart-fragments.ts
+var USER_ERROR_FRAGMENT = `#graphql
+  fragment CartApiError on CartUserError {
+    message
+    field
+    code
+  }
+`;
+var MINIMAL_CART_FRAGMENT = `#graphql
+  fragment CartApiMutation on Cart {
+    id
+    totalQuantity
+  }
+`;
+
+// src/cart/queries/cartCreateDefault.ts
+function cartCreateDefault(options) {
+  return async (input, optionalParams) => {
+    const { cartId, ...restOfOptionalParams } = optionalParams || {};
+    const { cartCreate, errors } = await options.storefront.mutate(CART_CREATE_MUTATION(options.cartFragment), {
+      variables: {
+        input,
+        ...restOfOptionalParams
+      }
+    });
+    return formatAPIResult(cartCreate, errors);
+  };
+}
+var CART_CREATE_MUTATION = (cartFragment = MINIMAL_CART_FRAGMENT) => `#graphql
+  mutation cartCreate(
+    $input: CartInput!
+    $country: CountryCode = ZZ
+    $language: LanguageCode
+  ) @inContext(country: $country, language: $language) {
+    cartCreate(input: $input) {
+      cart {
+        ...CartApiMutation
+        checkoutUrl
+      }
+      userErrors {
+        ...CartApiError
+      }
+    }
+  }
+  ${cartFragment}
+  ${USER_ERROR_FRAGMENT}
+`;
+
+// src/cart/queries/cartGetDefault.ts
+function cartGetDefault({
+  storefront,
+  customerAccount,
+  getCartId,
+  cartFragment
+}) {
+  return async (cartInput) => {
+    const cartId = getCartId();
+    if (!cartId)
+      return null;
+    const [isCustomerLoggedIn, { cart, errors }] = await Promise.all([
+      customerAccount ? customerAccount.isLoggedIn() : false,
+      storefront.query(CART_QUERY(cartFragment), {
+        variables: {
+          cartId,
+          ...cartInput
+        },
+        cache: storefront.CacheNone()
+      })
+    ]);
+    return formatAPIResult(
+      addCustomerLoggedInParam(isCustomerLoggedIn, cart),
+      errors
+    );
+  };
+}
+function addCustomerLoggedInParam(isCustomerLoggedIn, cart) {
+  if (isCustomerLoggedIn && cart && cart.checkoutUrl) {
+    const finalCheckoutUrl = new URL(cart.checkoutUrl);
+    finalCheckoutUrl.searchParams.set("logged_in", "true");
+    cart.checkoutUrl = finalCheckoutUrl.toString();
+  }
+  return cart;
+}
+var CART_QUERY = (cartFragment = DEFAULT_CART_FRAGMENT) => `#graphql
+  query CartQuery(
+    $cartId: ID!
+    $numCartLines: Int = 100
+    $country: CountryCode = ZZ
+    $language: LanguageCode
+  ) @inContext(country: $country, language: $language) {
+    cart(id: $cartId) {
+      ...CartApiQuery
+    }
+  }
+
+  ${cartFragment}
+`;
+var DEFAULT_CART_FRAGMENT = `#graphql
+  fragment CartApiQuery on Cart {
+    id
+    checkoutUrl
+    totalQuantity
+    buyerIdentity {
+      countryCode
+      customer {
+        id
+        email
+        firstName
+        lastName
+        displayName
+      }
+      email
+      phone
+    }
+    lines(first: $numCartLines) {
+      edges {
+        node {
+          id
+          quantity
+          attributes {
+            key
+            value
+          }
+          cost {
+            totalAmount {
+              amount
+              currencyCode
+            }
+            amountPerQuantity {
+              amount
+              currencyCode
+            }
+            compareAtAmountPerQuantity {
+              amount
+              currencyCode
+            }
+          }
+          merchandise {
+            ... on ProductVariant {
+              id
+              availableForSale
+              compareAtPrice {
+                ...CartApiMoney
+              }
+              price {
+                ...CartApiMoney
+              }
+              requiresShipping
+              title
+              image {
+                ...CartApiImage
+              }
+              product {
+                handle
+                title
+                id
+              }
+              selectedOptions {
+                name
+                value
+              }
+            }
+          }
+        }
+      }
+    }
+    cost {
+      subtotalAmount {
+        ...CartApiMoney
+      }
+      totalAmount {
+        ...CartApiMoney
+      }
+      totalDutyAmount {
+        ...CartApiMoney
+      }
+      totalTaxAmount {
+        ...CartApiMoney
+      }
+    }
+    note
+    attributes {
+      key
+      value
+    }
+    discountCodes {
+      applicable
+      code
+    }
+  }
+
+  fragment CartApiMoney on MoneyV2 {
+    currencyCode
+    amount
+  }
+
+  fragment CartApiImage on Image {
+    id
+    url
+    altText
+    width
+    height
+  }
+`;
+
+// src/cart/queries/cartLinesAddDefault.ts
+function cartLinesAddDefault(options) {
+  return async (lines, optionalParams) => {
+    const { cartLinesAdd, errors } = await options.storefront.mutate(CART_LINES_ADD_MUTATION(options.cartFragment), {
+      variables: {
+        cartId: options.getCartId(),
+        lines,
+        ...optionalParams
+      }
+    });
+    return formatAPIResult(cartLinesAdd, errors);
+  };
+}
+var CART_LINES_ADD_MUTATION = (cartFragment = MINIMAL_CART_FRAGMENT) => `#graphql
+  mutation cartLinesAdd(
+    $cartId: ID!
+    $lines: [CartLineInput!]!
+    $country: CountryCode = ZZ
+    $language: LanguageCode
+  ) @inContext(country: $country, language: $language) {
+    cartLinesAdd(cartId: $cartId, lines: $lines) {
+      cart {
+        ...CartApiMutation
+      }
+      userErrors {
+        ...CartApiError
+      }
+    }
+  }
+
+  ${cartFragment}
+  ${USER_ERROR_FRAGMENT}
+`;
+
+// src/cart/queries/cartLinesUpdateDefault.ts
+function cartLinesUpdateDefault(options) {
+  return async (lines, optionalParams) => {
+    const { cartLinesUpdate, errors } = await options.storefront.mutate(CART_LINES_UPDATE_MUTATION(options.cartFragment), {
+      variables: {
+        cartId: options.getCartId(),
+        lines,
+        ...optionalParams
+      }
+    });
+    return formatAPIResult(cartLinesUpdate, errors);
+  };
+}
+var CART_LINES_UPDATE_MUTATION = (cartFragment = MINIMAL_CART_FRAGMENT) => `#graphql
+  mutation cartLinesUpdate(
+    $cartId: ID!
+    $lines: [CartLineUpdateInput!]!
+    $language: LanguageCode
+    $country: CountryCode
+  ) @inContext(country: $country, language: $language) {
+    cartLinesUpdate(cartId: $cartId, lines: $lines) {
+      cart {
+        ...CartApiMutation
+      }
+      userErrors {
+        ...CartApiError
+      }
+    }
+  }
+
+  ${cartFragment}
+  ${USER_ERROR_FRAGMENT}
+`;
+
+// src/cart/queries/cartLinesRemoveDefault.ts
+function cartLinesRemoveDefault(options) {
+  return async (lineIds, optionalParams) => {
+    const { cartLinesRemove, errors } = await options.storefront.mutate(CART_LINES_REMOVE_MUTATION(options.cartFragment), {
+      variables: {
+        cartId: options.getCartId(),
+        lineIds,
+        ...optionalParams
+      }
+    });
+    return formatAPIResult(cartLinesRemove, errors);
+  };
+}
+var CART_LINES_REMOVE_MUTATION = (cartFragment = MINIMAL_CART_FRAGMENT) => `#graphql
+  mutation cartLinesRemove(
+    $cartId: ID!
+    $lineIds: [ID!]!
+    $language: LanguageCode
+    $country: CountryCode
+  ) @inContext(country: $country, language: $language) {
+    cartLinesRemove(cartId: $cartId, lineIds: $lineIds) {
+      cart {
+        ...CartApiMutation
+      }
+      userErrors {
+        ...CartApiError
+      }
+    }
+  }
+
+  ${cartFragment}
+  ${USER_ERROR_FRAGMENT}
+`;
+
+// src/cart/queries/cartDiscountCodesUpdateDefault.ts
+function cartDiscountCodesUpdateDefault(options) {
+  return async (discountCodes, optionalParams) => {
+    const uniqueCodes = discountCodes.filter((value, index, array) => {
+      return array.indexOf(value) === index;
+    });
+    const { cartDiscountCodesUpdate, errors } = await options.storefront.mutate(CART_DISCOUNT_CODE_UPDATE_MUTATION(options.cartFragment), {
+      variables: {
+        cartId: options.getCartId(),
+        discountCodes: uniqueCodes,
+        ...optionalParams
+      }
+    });
+    return formatAPIResult(cartDiscountCodesUpdate, errors);
+  };
+}
+var CART_DISCOUNT_CODE_UPDATE_MUTATION = (cartFragment = MINIMAL_CART_FRAGMENT) => `#graphql
+  mutation cartDiscountCodesUpdate(
+    $cartId: ID!
+    $discountCodes: [String!]
+    $language: LanguageCode
+    $country: CountryCode
+  ) @inContext(country: $country, language: $language) {
+    cartDiscountCodesUpdate(cartId: $cartId, discountCodes: $discountCodes) {
+      cart {
+        ...CartApiMutation
+      }
+      userErrors {
+        ...CartApiError
+      }
+    }
+  }
+  ${cartFragment}
+  ${USER_ERROR_FRAGMENT}
+`;
+
+// src/cart/queries/cartBuyerIdentityUpdateDefault.ts
+function cartBuyerIdentityUpdateDefault(options) {
+  return async (buyerIdentity, optionalParams) => {
+    const { cartBuyerIdentityUpdate, errors } = await options.storefront.mutate(CART_BUYER_IDENTITY_UPDATE_MUTATION(options.cartFragment), {
+      variables: {
+        cartId: options.getCartId(),
+        buyerIdentity,
+        ...optionalParams
+      }
+    });
+    return formatAPIResult(cartBuyerIdentityUpdate, errors);
+  };
+}
+var CART_BUYER_IDENTITY_UPDATE_MUTATION = (cartFragment = MINIMAL_CART_FRAGMENT) => `#graphql
+  mutation cartBuyerIdentityUpdate(
+    $cartId: ID!
+    $buyerIdentity: CartBuyerIdentityInput!
+    $language: LanguageCode
+    $country: CountryCode
+  ) @inContext(country: $country, language: $language) {
+    cartBuyerIdentityUpdate(cartId: $cartId, buyerIdentity: $buyerIdentity) {
+      cart {
+        ...CartApiMutation
+      }
+      userErrors {
+        ...CartApiError
+      }
+    }
+  }
+  ${cartFragment}
+  ${USER_ERROR_FRAGMENT}
+`;
+
+// src/cart/queries/cartNoteUpdateDefault.ts
+function cartNoteUpdateDefault(options) {
+  return async (note, optionalParams) => {
+    const { cartNoteUpdate, errors } = await options.storefront.mutate(CART_NOTE_UPDATE_MUTATION(options.cartFragment), {
+      variables: {
+        cartId: options.getCartId(),
+        note,
+        ...optionalParams
+      }
+    });
+    return formatAPIResult(cartNoteUpdate, errors);
+  };
+}
+var CART_NOTE_UPDATE_MUTATION = (cartFragment = MINIMAL_CART_FRAGMENT) => `#graphql
+  mutation cartNoteUpdate(
+    $cartId: ID!
+    $note: String
+    $language: LanguageCode
+    $country: CountryCode
+  ) @inContext(country: $country, language: $language) {
+    cartNoteUpdate(cartId: $cartId, note: $note) {
+      cart {
+        ...CartApiMutation
+      }
+      userErrors {
+        ...CartApiError
+      }
+    }
+  }
+  ${cartFragment}
+  ${USER_ERROR_FRAGMENT}
+`;
+
+// src/cart/queries/cartSelectedDeliveryOptionsUpdateDefault.ts
+function cartSelectedDeliveryOptionsUpdateDefault(options) {
+  return async (selectedDeliveryOptions, optionalParams) => {
+    const { cartSelectedDeliveryOptionsUpdate, errors } = await options.storefront.mutate(CART_SELECTED_DELIVERY_OPTIONS_UPDATE_MUTATION(options.cartFragment), {
+      variables: {
+        cartId: options.getCartId(),
+        selectedDeliveryOptions,
+        ...optionalParams
+      }
+    });
+    return formatAPIResult(cartSelectedDeliveryOptionsUpdate, errors);
+  };
+}
+var CART_SELECTED_DELIVERY_OPTIONS_UPDATE_MUTATION = (cartFragment = MINIMAL_CART_FRAGMENT) => `#graphql
+  mutation cartSelectedDeliveryOptionsUpdate(
+    $cartId: ID!
+    $selectedDeliveryOptions: [CartSelectedDeliveryOptionInput!]!
+    $language: LanguageCode
+    $country: CountryCode
+  ) @inContext(country: $country, language: $language) {
+    cartSelectedDeliveryOptionsUpdate(cartId: $cartId, selectedDeliveryOptions: $selectedDeliveryOptions) {
+      cart {
+        ...CartApiMutation
+      }
+      userErrors {
+        ...CartApiError
+      }
+    }
+  }
+  ${cartFragment}
+  ${USER_ERROR_FRAGMENT}
+`;
+
+// src/cart/queries/cartAttributesUpdateDefault.ts
+function cartAttributesUpdateDefault(options) {
+  return async (attributes, optionalParams) => {
+    const { cartAttributesUpdate, errors } = await options.storefront.mutate(CART_ATTRIBUTES_UPDATE_MUTATION(options.cartFragment), {
+      variables: {
+        cartId: optionalParams?.cartId || options.getCartId(),
+        attributes
+      }
+    });
+    return formatAPIResult(cartAttributesUpdate, errors);
+  };
+}
+var CART_ATTRIBUTES_UPDATE_MUTATION = (cartFragment = MINIMAL_CART_FRAGMENT) => `#graphql
+  mutation cartAttributesUpdate(
+    $cartId: ID!
+    $attributes: [AttributeInput!]!
+  ) {
+    cartAttributesUpdate(cartId: $cartId, attributes: $attributes) {
+      cart {
+        ...CartApiMutation
+      }
+      userErrors {
+        ...CartApiError
+      }
+    }
+  }
+  ${cartFragment}
+  ${USER_ERROR_FRAGMENT}
+`;
+
+// src/cart/queries/cartMetafieldsSetDefault.ts
+function cartMetafieldsSetDefault(options) {
+  return async (metafields, optionalParams) => {
+    const ownerId = optionalParams?.cartId || options.getCartId();
+    const metafieldsWithOwnerId = metafields.map(
+      (metafield) => ({
+        ...metafield,
+        ownerId
+      })
+    );
+    const { cartMetafieldsSet, errors } = await options.storefront.mutate(CART_METAFIELD_SET_MUTATION(), {
+      variables: { metafields: metafieldsWithOwnerId }
+    });
+    return formatAPIResult(
+      {
+        cart: {
+          id: ownerId
+        },
+        ...cartMetafieldsSet
+      },
+      errors
+    );
+  };
+}
+var CART_METAFIELD_SET_MUTATION = () => `#graphql
+  mutation cartMetafieldsSet(
+    $metafields: [CartMetafieldsSetInput!]!
+    $language: LanguageCode
+    $country: CountryCode
+  ) @inContext(country: $country, language: $language) {
+    cartMetafieldsSet(metafields: $metafields) {
+      userErrors {
+        code
+        elementIndex
+        field
+        message
+      }
+    }
+  }
+`;
+
+// src/cart/queries/cartMetafieldDeleteDefault.ts
+function cartMetafieldDeleteDefault(options) {
+  return async (key, optionalParams) => {
+    const ownerId = optionalParams?.cartId || options.getCartId();
+    const { cartMetafieldDelete, errors } = await options.storefront.mutate(CART_METAFIELD_DELETE_MUTATION(), {
+      variables: {
+        input: {
+          ownerId,
+          key
+        }
+      }
+    });
+    return formatAPIResult(
+      {
+        cart: {
+          id: ownerId
+        },
+        ...cartMetafieldDelete
+      },
+      errors
+    );
+  };
+}
+var CART_METAFIELD_DELETE_MUTATION = () => `#graphql
+  mutation cartMetafieldDelete(
+    $input: CartMetafieldDeleteInput!
+  ) {
+    cartMetafieldDelete(input: $input) {
+      userErrors {
+        code
+        field
+        message
+      }
+    }
+  }
+`;
+
+// ../../node_modules/worktop/cookie/index.mjs
+var g = /* @__PURE__ */ new Set([
+  "domain",
+  "path",
+  "max-age",
+  "expires",
+  "samesite",
+  "secure",
+  "httponly"
+]);
+function u(a) {
+  let r = {}, e, t, n = 0, m = a.split(/;\s*/g), s, i;
+  for (; n < m.length; n++)
+    if (t = m[n], e = t.indexOf("="), ~e) {
+      if (s = t.substring(0, e++).trim(), i = t.substring(e).trim(), i[0] === '"' && (i = i.substring(1, i.length - 1)), ~i.indexOf("%"))
+        try {
+          i = decodeURIComponent(i);
+        } catch (f) {
+        }
+      g.has(t = s.toLowerCase()) ? t === "expires" ? r.expires = new Date(i) : t === "max-age" ? r.maxage = +i : r[t] = i : r[s] = i;
+    } else
+      (s = t.trim().toLowerCase()) && (s === "httponly" || s === "secure") && (r[s] = true);
+  return r;
+}
+function l(a, r, e = {}) {
+  let t = a + "=" + encodeURIComponent(r);
+  return e.expires && (t += "; Expires=" + new Date(e.expires).toUTCString()), e.maxage != null && e.maxage >= 0 && (t += "; Max-Age=" + (e.maxage | 0)), e.domain && (t += "; Domain=" + e.domain), e.path && (t += "; Path=" + e.path), e.samesite && (t += "; SameSite=" + e.samesite), (e.secure || e.samesite === "None") && (t += "; Secure"), e.httponly && (t += "; HttpOnly"), t;
+}
+
+// src/cart/cartGetIdDefault.ts
+var cartGetIdDefault = (requestHeaders) => {
+  const cookies = u(requestHeaders.get("Cookie") || "");
+  return () => {
+    return cookies.cart ? `gid://shopify/Cart/${cookies.cart}` : void 0;
+  };
+};
+
+// src/cart/cartSetIdDefault.ts
+var cartSetIdDefault = (cookieOptions) => {
+  return (cartId) => {
+    const headers = new Headers();
+    headers.append(
+      "Set-Cookie",
+      l("cart", cartId.split("/").pop() || "", {
+        path: "/",
+        ...cookieOptions
+      })
+    );
+    return headers;
+  };
+};
+
+// src/cart/createCartHandler.ts
+function createCartHandler(options) {
+  const {
+    getCartId,
+    setCartId,
+    storefront,
+    customerAccount,
+    cartQueryFragment,
+    cartMutateFragment
+  } = options;
+  const mutateOptions = {
+    storefront,
+    getCartId,
+    cartFragment: cartMutateFragment
+  };
+  const cartId = getCartId();
+  const cartCreate = cartCreateDefault(mutateOptions);
+  const methods = {
+    get: cartGetDefault({
+      storefront,
+      customerAccount,
+      getCartId,
+      cartFragment: cartQueryFragment
+    }),
+    getCartId,
+    setCartId,
+    create: cartCreate,
+    addLines: async (lines, optionalParams) => {
+      return cartId || optionalParams?.cartId ? await cartLinesAddDefault(mutateOptions)(lines, optionalParams) : await cartCreate({ lines }, optionalParams);
+    },
+    updateLines: cartLinesUpdateDefault(mutateOptions),
+    removeLines: cartLinesRemoveDefault(mutateOptions),
+    updateDiscountCodes: async (discountCodes, optionalParams) => {
+      return cartId || optionalParams?.cartId ? await cartDiscountCodesUpdateDefault(mutateOptions)(
+        discountCodes,
+        optionalParams
+      ) : await cartCreate({ discountCodes }, optionalParams);
+    },
+    updateBuyerIdentity: async (buyerIdentity, optionalParams) => {
+      return cartId || optionalParams?.cartId ? await cartBuyerIdentityUpdateDefault(mutateOptions)(
+        buyerIdentity,
+        optionalParams
+      ) : await cartCreate({ buyerIdentity }, optionalParams);
+    },
+    updateNote: async (note, optionalParams) => {
+      return cartId || optionalParams?.cartId ? await cartNoteUpdateDefault(mutateOptions)(note, optionalParams) : await cartCreate({ note }, optionalParams);
+    },
+    updateSelectedDeliveryOption: cartSelectedDeliveryOptionsUpdateDefault(mutateOptions),
+    updateAttributes: async (attributes, optionalParams) => {
+      return cartId || optionalParams?.cartId ? await cartAttributesUpdateDefault(mutateOptions)(
+        attributes,
+        optionalParams
+      ) : await cartCreate({ attributes }, optionalParams);
+    },
+    setMetafields: async (metafields, optionalParams) => {
+      return cartId || optionalParams?.cartId ? await cartMetafieldsSetDefault(mutateOptions)(
+        metafields,
+        optionalParams
+      ) : await cartCreate({ metafields }, optionalParams);
+    },
+    deleteMetafield: cartMetafieldDeleteDefault(mutateOptions)
+  };
+  if ("customMethods" in options) {
+    return {
+      ...methods,
+      ...options.customMethods ?? {}
+    };
+  } else {
+    return methods;
+  }
+}
+function VariantSelector({
+  handle,
+  options = [],
+  variants: _variants = [],
+  productPath = "products",
+  children
+}) {
+  const variants = _variants instanceof Array ? _variants : hydrogenReact.flattenConnection(_variants);
+  const { searchParams, path, alreadyOnProductPage } = useVariantPath(
+    handle,
+    productPath
+  );
+  const optionsWithOnlyOneValue = options.filter(
+    (option) => option?.values?.length === 1
+  );
+  return react.createElement(
+    react.Fragment,
+    null,
+    ...react.useMemo(() => {
+      return options.filter((option) => option?.values?.length > 1).map((option) => {
+        let activeValue;
+        let availableValues = [];
+        for (let value of option.values) {
+          const clonedSearchParams = new URLSearchParams(
+            alreadyOnProductPage ? searchParams : void 0
+          );
+          clonedSearchParams.set(option.name, value);
+          optionsWithOnlyOneValue.forEach((option2) => {
+            clonedSearchParams.set(option2.name, option2.values[0]);
+          });
+          const variant = variants.find(
+            (variant2) => variant2?.selectedOptions?.every(
+              (selectedOption) => clonedSearchParams.get(selectedOption?.name) === selectedOption?.value
+            )
+          );
+          const currentParam = searchParams.get(option.name);
+          const calculatedActiveValue = currentParam ? (
+            // If a URL parameter exists for the current option, check if it equals the current value
+            currentParam === value
+          ) : false;
+          if (calculatedActiveValue) {
+            activeValue = value;
+          }
+          const searchString = "?" + clonedSearchParams.toString();
+          availableValues.push({
+            value,
+            isAvailable: variant ? variant.availableForSale : true,
+            to: path + searchString,
+            search: searchString,
+            isActive: calculatedActiveValue
+          });
+        }
+        return children({
+          option: {
+            name: option.name,
+            value: activeValue,
+            values: availableValues
+          }
+        });
+      });
+    }, [options, variants, children])
+  );
+}
+var getSelectedProductOptions = (request) => {
+  if (typeof request?.url === "undefined")
+    throw new TypeError(`Expected a Request instance, got ${typeof request}`);
+  const searchParams = new URL(request.url).searchParams;
+  const selectedOptions = [];
+  searchParams.forEach((value, name) => {
+    selectedOptions.push({ name, value });
+  });
+  return selectedOptions;
+};
+function useVariantPath(handle, productPath) {
+  const { pathname, search } = react$1.useLocation();
+  return react.useMemo(() => {
+    const match = /(\/[a-zA-Z]{2}-[a-zA-Z]{2}\/)/g.exec(pathname);
+    const isLocalePathname = match && match.length > 0;
+    productPath = productPath.startsWith("/") ? productPath.substring(1) : productPath;
+    const path = isLocalePathname ? `${match[0]}${productPath}/${handle}` : `/${productPath}/${handle}`;
+    const searchParams = new URLSearchParams(search);
+    return {
+      searchParams,
+      // If the current pathname matches the product page, we need to make sure
+      // that we append to the current search params. Otherwise all the search
+      // params can be generated new.
+      alreadyOnProductPage: path === pathname,
+      path
+    };
+  }, [pathname, search, handle, productPath]);
+}
+var NonceContext = react.createContext(void 0);
+var NonceProvider = NonceContext.Provider;
+var useNonce = () => react.useContext(NonceContext);
+function createContentSecurityPolicy(directives = {}) {
+  const nonce = generateNonce();
+  const header = createCSPHeader(nonce, directives);
+  const Provider = ({ children }) => {
+    return react.createElement(NonceProvider, { value: nonce }, children);
+  };
+  return {
+    nonce,
+    header,
+    NonceProvider: Provider
+  };
+}
+function createCSPHeader(nonce, directives = {}) {
+  const nonceString = `'nonce-${nonce}'`;
+  const styleSrc = ["'self'", "'unsafe-inline'", "https://cdn.shopify.com"];
+  const connectSrc = ["'self'", "https://monorail-edge.shopifysvc.com"];
+  const defaultSrc = [
+    "'self'",
+    nonceString,
+    "https://cdn.shopify.com",
+    // Used for the Customer Account API
+    "https://shopify.com"
+  ];
+  const defaultDirectives = {
+    baseUri: ["'self'"],
+    defaultSrc,
+    frameAncestors: ["none"],
+    styleSrc,
+    connectSrc
+  };
+  {
+    defaultDirectives.styleSrc = [...styleSrc, "http://localhost:*"];
+    defaultDirectives.defaultSrc = [...defaultSrc, "http://localhost:*"];
+    defaultDirectives.connectSrc = [
+      ...connectSrc,
+      "http://localhost:*",
+      // For HMR:
+      "ws://localhost:*",
+      "ws://127.0.0.1:*"
+    ];
+  }
+  const combinedDirectives = Object.assign({}, defaultDirectives, directives);
+  for (const key in defaultDirectives) {
+    if (directives[key]) {
+      combinedDirectives[key] = addCspDirective(
+        directives[key],
+        defaultDirectives[key]
+      );
+    }
+  }
+  if (combinedDirectives.scriptSrc instanceof Array && !combinedDirectives.scriptSrc.includes(nonceString)) {
+    combinedDirectives.scriptSrc.push(nonceString);
+  } else if (combinedDirectives.defaultSrc instanceof Array && !combinedDirectives.defaultSrc.includes(nonceString)) {
+    combinedDirectives.defaultSrc.push(nonceString);
+  }
+  return cspBuilder__default.default({
+    directives: combinedDirectives
+  });
+}
+function addCspDirective(currentValue, value) {
+  const normalizedValue = typeof value === "string" ? [value] : value;
+  const normalizedCurrentValue = Array.isArray(currentValue) ? currentValue : [String(currentValue)];
+  const newValue = Array.isArray(normalizedValue) ? [...normalizedCurrentValue, ...normalizedValue] : normalizedValue;
+  return newValue;
+}
+var Script = react.forwardRef(
+  (props, ref) => {
+    const nonce = useNonce();
+    return /* @__PURE__ */ jsxRuntime.jsx("script", { suppressHydrationWarning: true, ...props, nonce, ref });
+  }
+);
+function useOptimisticData(identifier) {
+  const fetchers = react$1.useFetchers();
+  const data = {};
+  for (const { formData } of fetchers) {
+    if (formData?.get("optimistic-identifier") === identifier) {
+      try {
+        if (formData.has("optimistic-data")) {
+          const dataInForm = JSON.parse(
+            String(formData.get("optimistic-data"))
+          );
+          Object.assign(data, dataInForm);
+        }
+      } catch {
+      }
+    }
+  }
+  return data;
+}
+function OptimisticInput({ id, data }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx("input", { type: "hidden", name: "optimistic-identifier", value: id }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        type: "hidden",
+        name: "optimistic-data",
+        value: JSON.stringify(data)
+      }
+    )
+  ] });
+}
+function ShopPayButton(props) {
+  return /* @__PURE__ */ jsxRuntime.jsx(hydrogenReact.ShopPayButton, { channel: "hydrogen", ...props });
+}
+//! @see: https://shopify.dev/docs/api/storefront/latest/mutations/cartCreate
+//! @see https://shopify.dev/docs/api/storefront/latest/queries/cart
+//! @see: https://shopify.dev/docs/api/storefront/latest/mutations/cartLinesAdd
+//! @see: https://shopify.dev/docs/api/storefront/latest/mutations/cartLinesUpdate
+//! @see: https://shopify.dev/docs/api/storefront/latest/mutations/cartLinesRemove
+//! @see https://shopify.dev/docs/api/storefront/latest/mutations/cartDiscountCodesUpdate
+//! @see https://shopify.dev/docs/api/storefront/latest/mutations/cartBuyerIdentityUpdate
+//! @see https://shopify.dev/docs/api/storefront/latest/mutations/cartNoteUpdate
+//! @see https://shopify.dev/docs/api/storefront/latest/mutations/cartSelectedDeliveryOptionsUpdate
+//! @see https://shopify.dev/docs/api/storefront/latest/mutations/cartMetafieldsSet
+//! @see https://shopify.dev/docs/api/storefront/2024-01/mutations/cartMetafieldDelete
+
+Object.defineProperty(exports, 'AnalyticsEventName', {
+  enumerable: true,
+  get: function () { return hydrogenReact.AnalyticsEventName; }
+});
+Object.defineProperty(exports, 'AnalyticsPageType', {
+  enumerable: true,
+  get: function () { return hydrogenReact.AnalyticsPageType; }
+});
+Object.defineProperty(exports, 'ExternalVideo', {
+  enumerable: true,
+  get: function () { return hydrogenReact.ExternalVideo; }
+});
+Object.defineProperty(exports, 'IMAGE_FRAGMENT', {
+  enumerable: true,
+  get: function () { return hydrogenReact.IMAGE_FRAGMENT; }
+});
+Object.defineProperty(exports, 'Image', {
+  enumerable: true,
+  get: function () { return hydrogenReact.Image; }
+});
+Object.defineProperty(exports, 'MediaFile', {
+  enumerable: true,
+  get: function () { return hydrogenReact.MediaFile; }
+});
+Object.defineProperty(exports, 'ModelViewer', {
+  enumerable: true,
+  get: function () { return hydrogenReact.ModelViewer; }
+});
+Object.defineProperty(exports, 'Money', {
+  enumerable: true,
+  get: function () { return hydrogenReact.Money; }
+});
+Object.defineProperty(exports, 'ShopifySalesChannel', {
+  enumerable: true,
+  get: function () { return hydrogenReact.ShopifySalesChannel; }
+});
+Object.defineProperty(exports, 'Video', {
+  enumerable: true,
+  get: function () { return hydrogenReact.Video; }
+});
+Object.defineProperty(exports, 'customerAccountApiCustomScalars', {
+  enumerable: true,
+  get: function () { return hydrogenReact.customerAccountApiCustomScalars; }
+});
+Object.defineProperty(exports, 'flattenConnection', {
+  enumerable: true,
+  get: function () { return hydrogenReact.flattenConnection; }
+});
+Object.defineProperty(exports, 'getClientBrowserParameters', {
+  enumerable: true,
+  get: function () { return hydrogenReact.getClientBrowserParameters; }
+});
+Object.defineProperty(exports, 'getShopifyCookies', {
+  enumerable: true,
+  get: function () { return hydrogenReact.getShopifyCookies; }
+});
+Object.defineProperty(exports, 'parseGid', {
+  enumerable: true,
+  get: function () { return hydrogenReact.parseGid; }
+});
+Object.defineProperty(exports, 'parseMetafield', {
+  enumerable: true,
+  get: function () { return hydrogenReact.parseMetafield; }
+});
+Object.defineProperty(exports, 'sendShopifyAnalytics', {
+  enumerable: true,
+  get: function () { return hydrogenReact.sendShopifyAnalytics; }
+});
+Object.defineProperty(exports, 'storefrontApiCustomScalars', {
+  enumerable: true,
+  get: function () { return hydrogenReact.storefrontApiCustomScalars; }
+});
+Object.defineProperty(exports, 'useLoadScript', {
+  enumerable: true,
+  get: function () { return hydrogenReact.useLoadScript; }
+});
+Object.defineProperty(exports, 'useMoney', {
+  enumerable: true,
+  get: function () { return hydrogenReact.useMoney; }
+});
+Object.defineProperty(exports, 'useShopifyCookies', {
+  enumerable: true,
+  get: function () { return hydrogenReact.useShopifyCookies; }
+});
+exports.CacheCustom = CacheCustom;
+exports.CacheLong = CacheLong;
+exports.CacheNone = CacheNone;
+exports.CacheShort = CacheShort;
+exports.CartForm = CartForm;
+exports.InMemoryCache = InMemoryCache;
+exports.OptimisticInput = OptimisticInput;
+exports.Pagination = Pagination;
+exports.Script = Script;
+exports.Seo = Seo;
+exports.ShopPayButton = ShopPayButton;
+exports.VariantSelector = VariantSelector;
+exports.cartAttributesUpdateDefault = cartAttributesUpdateDefault;
+exports.cartBuyerIdentityUpdateDefault = cartBuyerIdentityUpdateDefault;
+exports.cartCreateDefault = cartCreateDefault;
+exports.cartDiscountCodesUpdateDefault = cartDiscountCodesUpdateDefault;
+exports.cartGetDefault = cartGetDefault;
+exports.cartGetIdDefault = cartGetIdDefault;
+exports.cartLinesAddDefault = cartLinesAddDefault;
+exports.cartLinesRemoveDefault = cartLinesRemoveDefault;
+exports.cartLinesUpdateDefault = cartLinesUpdateDefault;
+exports.cartMetafieldDeleteDefault = cartMetafieldDeleteDefault;
+exports.cartMetafieldsSetDefault = cartMetafieldsSetDefault;
+exports.cartNoteUpdateDefault = cartNoteUpdateDefault;
+exports.cartSelectedDeliveryOptionsUpdateDefault = cartSelectedDeliveryOptionsUpdateDefault;
+exports.cartSetIdDefault = cartSetIdDefault;
+exports.changelogHandler = changelogHandler;
+exports.createCartHandler = createCartHandler;
+exports.createContentSecurityPolicy = createContentSecurityPolicy;
+exports.createCustomerAccountClient = createCustomerAccountClient;
+exports.createStorefrontClient = createStorefrontClient;
+exports.createWithCache = createWithCache;
+exports.formatAPIResult = formatAPIResult;
+exports.generateCacheControlHeader = generateCacheControlHeader;
+exports.getPaginationVariables = getPaginationVariables;
+exports.getSelectedProductOptions = getSelectedProductOptions;
+exports.graphiqlLoader = graphiqlLoader;
+exports.storefrontRedirect = storefrontRedirect;
+exports.useNonce = useNonce;
+exports.useOptimisticData = useOptimisticData;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.cjs.map