@juspay/shooter 1.9.1 → 1.9.3

package/build/server/index.js

@@ -1,7 +1,7 @@
-import { D as DevalueError, i as is_primitive, g as get_type, a as is_plain_object, e as enumerable_symbols, s as stringify_key, b as stringify_string, v as valid_array_indices, c as browser, u as uneval } from './chunks/index-BHoOpAe1.js';
+import { U as UNDEFINED, N as NAN, P as POSITIVE_INFINITY, a as NEGATIVE_INFINITY, b as NEGATIVE_ZERO, S as SPARSE, i as is_valid_array_len, M as MAX_ARRAY_INDEX, c as is_valid_array_index, H as HOLE, D as DevalueError, d as is_primitive, g as get_type, e as is_plain_object, f as enumerable_symbols, s as stringify_key, h as stringify_string, v as valid_array_indices, j as browser, u as uneval } from './chunks/index-DMikC9Qy.js';
 import { H as HttpError, j as json, t as text, S as SvelteKitError, R as Redirect, e as error, A as ActionFailure } from './chunks/index-CoD1IJuy.js';
-import { w as with_request_store, t as text_decoder, b as base64_decode, r as root, d as decode_pathname, n as normalize_path, a as disable_search, c as decode_params, v as validate_layout_server_exports, e as validate_layout_exports, f as validate_page_server_exports, g as validate_page_exports, h as text_encoder, i as resolve, m as make_trackable, j as get_relative_path, k as base64_encode } from './chunks/root-CW7Ox2wn.js';
-import { w as writable, r as readable } from './chunks/index2-CKh4I94n.js';
+import { w as with_request_store, t as text_decoder, b as base64_decode, r as root, d as decode_pathname, n as normalize_path, a as disable_search, c as decode_params, v as validate_layout_server_exports, e as validate_layout_exports, f as validate_page_server_exports, g as validate_page_exports, h as text_encoder, i as resolve, m as make_trackable, j as get_relative_path, k as base64_encode } from './chunks/root-DhBbA8QD.js';
+import { w as writable, r as readable } from './chunks/index2-BTTf6mSG.js';
 import { s as set_private_env, a as set_public_env, p as public_env } from './chunks/shared-server-DaWdgxVh.js';
 
 /**
@@ -38,83 +38,41 @@ const SVELTE_KIT_ASSETS = "/_svelte_kit_assets";
 const ENDPOINT_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
 const MUTATIVE_METHODS = ["POST", "PUT", "PATCH", "DELETE"];
 const PAGE_METHODS = ["GET", "POST", "HEAD"];
-function encode64(arraybuffer) {
-  const dv = new DataView(arraybuffer);
-  let binaryString = "";
-  for (let i = 0; i < arraybuffer.byteLength; i++) {
-    binaryString += String.fromCharCode(dv.getUint8(i));
-  }
-  return binaryToAscii(binaryString);
-}
-function decode64(string) {
-  const binaryString = asciiToBinary(string);
-  const arraybuffer = new ArrayBuffer(binaryString.length);
-  const dv = new DataView(arraybuffer);
-  for (let i = 0; i < arraybuffer.byteLength; i++) {
-    dv.setUint8(i, binaryString.charCodeAt(i));
-  }
-  return arraybuffer;
-}
-const KEY_STRING = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-function asciiToBinary(data) {
-  if (data.length % 4 === 0) {
-    data = data.replace(/==?$/, "");
-  }
-  let output = "";
-  let buffer = 0;
-  let accumulatedBits = 0;
-  for (let i = 0; i < data.length; i++) {
-    buffer <<= 6;
-    buffer |= KEY_STRING.indexOf(data[i]);
-    accumulatedBits += 6;
-    if (accumulatedBits === 24) {
-      output += String.fromCharCode((buffer & 16711680) >> 16);
-      output += String.fromCharCode((buffer & 65280) >> 8);
-      output += String.fromCharCode(buffer & 255);
-      buffer = accumulatedBits = 0;
-    }
-  }
-  if (accumulatedBits === 12) {
-    buffer >>= 4;
-    output += String.fromCharCode(buffer);
-  } else if (accumulatedBits === 18) {
-    buffer >>= 2;
-    output += String.fromCharCode((buffer & 65280) >> 8);
-    output += String.fromCharCode(buffer & 255);
-  }
-  return output;
-}
-function binaryToAscii(str) {
-  let out = "";
-  for (let i = 0; i < str.length; i += 3) {
-    const groupsOfSix = [void 0, void 0, void 0, void 0];
-    groupsOfSix[0] = str.charCodeAt(i) >> 2;
-    groupsOfSix[1] = (str.charCodeAt(i) & 3) << 4;
-    if (str.length > i + 1) {
-      groupsOfSix[1] |= str.charCodeAt(i + 1) >> 4;
-      groupsOfSix[2] = (str.charCodeAt(i + 1) & 15) << 2;
-    }
-    if (str.length > i + 2) {
-      groupsOfSix[2] |= str.charCodeAt(i + 2) >> 6;
-      groupsOfSix[3] = str.charCodeAt(i + 2) & 63;
-    }
-    for (let j = 0; j < groupsOfSix.length; j++) {
-      if (typeof groupsOfSix[j] === "undefined") {
-        out += "=";
-      } else {
-        out += KEY_STRING[groupsOfSix[j]];
-      }
-    }
+function encode_native(array_buffer) {
+  return new Uint8Array(array_buffer).toBase64();
+}
+function decode_native(base64) {
+  return Uint8Array.fromBase64(base64).buffer;
+}
+function encode_buffer(array_buffer) {
+  return Buffer.from(array_buffer).toString("base64");
+}
+function decode_buffer(base64) {
+  return Uint8Array.from(Buffer.from(base64, "base64")).buffer;
+}
+function encode_legacy(array_buffer) {
+  const array = new Uint8Array(array_buffer);
+  let binary = "";
+  const chunk_size = 32768;
+  for (let i = 0; i < array.length; i += chunk_size) {
+    const chunk = array.subarray(i, i + chunk_size);
+    binary += String.fromCharCode.apply(null, chunk);
+  }
+  return btoa(binary);
+}
+function decode_legacy(base64) {
+  const binary_string = atob(base64);
+  const len = binary_string.length;
+  const array = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    array[i] = binary_string.charCodeAt(i);
   }
-  return out;
+  return array.buffer;
 }
-const UNDEFINED = -1;
-const HOLE = -2;
-const NAN = -3;
-const POSITIVE_INFINITY = -4;
-const NEGATIVE_INFINITY = -5;
-const NEGATIVE_ZERO = -6;
-const SPARSE = -7;
+const native = typeof Uint8Array.fromBase64 === "function";
+const buffer = typeof process === "object" && process.versions?.node !== void 0;
+const encode64 = native ? encode_native : buffer ? encode_buffer : encode_legacy;
+const decode64 = native ? decode_native : buffer ? decode_buffer : decode_legacy;
 function parse(serialized, revivers) {
   return unflatten(JSON.parse(serialized), revivers);
 }
@@ -181,13 +139,14 @@ function unflatten(parsed, revivers) {
           case "RegExp":
             hydrated[index] = new RegExp(value[1], value[2]);
             break;
-          case "Object":
-            const object = Object(value[1]);
-            if (Object.hasOwn(object, "__proto__")) {
-              throw new Error("Cannot parse an object with a `__proto__` property");
+          case "Object": {
+            const wrapped_index = value[1];
+            if (typeof values[wrapped_index] === "object" && values[wrapped_index][0] !== "BigInt") {
+              throw new Error("Invalid input");
             }
-            hydrated[index] = object;
+            hydrated[index] = Object(hydrate(wrapped_index));
             break;
+          }
           case "BigInt":
             hydrated[index] = BigInt(value[1]);
             break;
@@ -206,19 +165,20 @@ function unflatten(parsed, revivers) {
           case "Uint8ClampedArray":
           case "Int16Array":
           case "Uint16Array":
+          case "Float16Array":
           case "Int32Array":
           case "Uint32Array":
           case "Float32Array":
           case "Float64Array":
           case "BigInt64Array":
-          case "BigUint64Array": {
+          case "BigUint64Array":
+          case "DataView": {
             if (values[value[1]][0] !== "ArrayBuffer") {
               throw new Error("Invalid data");
             }
             const TypedArrayConstructor = globalThis[type];
-            const buffer = hydrate(value[1]);
-            const typedArray = new TypedArrayConstructor(buffer);
-            hydrated[index] = value[2] !== void 0 ? typedArray.subarray(value[2], value[3]) : typedArray;
+            const buffer2 = hydrate(value[1]);
+            hydrated[index] = value[2] !== void 0 ? new TypedArrayConstructor(buffer2, value[2], value[3]) : new TypedArrayConstructor(buffer2);
             break;
           }
           case "ArrayBuffer": {
@@ -257,18 +217,21 @@ function unflatten(parsed, revivers) {
         }
       } else if (value[0] === SPARSE) {
         const len = value[1];
-        if (!Number.isInteger(len) || len < 0) {
+        if (!is_valid_array_len(len)) {
           throw new Error("Invalid input");
         }
-        const array = new Array(len);
+        const array = [];
         hydrated[index] = array;
+        array[MAX_ARRAY_INDEX] = void 0;
+        delete array[MAX_ARRAY_INDEX];
         for (let i = 2; i < value.length; i += 2) {
           const idx = value[i];
-          if (!Number.isInteger(idx) || idx < 0 || idx >= len) {
+          if (!is_valid_array_index(idx) || idx >= len) {
             throw new Error("Invalid input");
           }
           array[idx] = hydrate(value[i + 1]);
         }
+        array.length = len;
       } else {
         const array = new Array(value.length);
         hydrated[index] = array;
@@ -294,6 +257,10 @@ function unflatten(parsed, revivers) {
   return hydrate(0);
 }
 function stringify$1(value, reducers) {
+  const stringified = run(false, value, reducers);
+  return typeof stringified === "string" ? stringified : `[${stringified.join(",")}]`;
+}
+function run(async, value, reducers) {
   const stringified = [];
   const indexes = /* @__PURE__ */ new Map();
   const custom = [];
@@ -304,14 +271,17 @@ function stringify$1(value, reducers) {
   }
   const keys = [];
   let p = 0;
-  function flatten(thing) {
+  function flatten(thing, index2) {
     if (thing === void 0) return UNDEFINED;
     if (Number.isNaN(thing)) return NAN;
     if (thing === Infinity) return POSITIVE_INFINITY;
     if (thing === -Infinity) return NEGATIVE_INFINITY;
     if (thing === 0 && 1 / thing < 0) return NEGATIVE_ZERO;
-    if (indexes.has(thing)) return indexes.get(thing);
-    const index2 = p++;
+    if (indexes.has(thing)) return (
+      /** @type {number} */
+      indexes.get(thing)
+    );
+    index2 ??= p++;
     indexes.set(thing, index2);
     for (const { key, fn } of custom) {
       const value2 = fn(thing);
@@ -322,20 +292,29 @@ function stringify$1(value, reducers) {
     }
     if (typeof thing === "function") {
       throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
+    } else if (typeof thing === "symbol") {
+      throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
     }
     let str = "";
     if (is_primitive(thing)) {
       str = stringify_primitive(thing);
+    } else if (typeof thing.then === "function") {
+      {
+        throw new DevalueError(
+          `Cannot stringify a Promise or thenable — use stringifyAsync instead`,
+          keys,
+          thing,
+          value
+        );
+      }
     } else {
       const type = get_type(thing);
       switch (type) {
         case "Number":
         case "String":
         case "Boolean":
-          str = `["Object",${stringify_primitive(thing)}]`;
-          break;
         case "BigInt":
-          str = `["BigInt",${thing}]`;
+          str = `["Object",${flatten(thing.valueOf())}]`;
           break;
         case "Date":
           const valid = !isNaN(thing.getDate());
@@ -399,9 +378,7 @@ function stringify$1(value, reducers) {
         case "Map":
           str = '["Map"';
           for (const [key, value2] of thing) {
-            keys.push(
-              `.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`
-            );
+            keys.push(`.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`);
             str += `,${flatten(key)},${flatten(value2)}`;
             keys.pop();
           }
@@ -412,19 +389,18 @@ function stringify$1(value, reducers) {
         case "Uint8ClampedArray":
         case "Int16Array":
         case "Uint16Array":
+        case "Float16Array":
         case "Int32Array":
         case "Uint32Array":
         case "Float32Array":
         case "Float64Array":
         case "BigInt64Array":
-        case "BigUint64Array": {
+        case "BigUint64Array":
+        case "DataView": {
           const typedArray = thing;
           str = '["' + type + '",' + flatten(typedArray.buffer);
-          const a = thing.byteOffset;
-          const b = a + thing.byteLength;
-          if (a > 0 || b !== typedArray.buffer.byteLength) {
-            const m = +/(\d+)/.exec(type)[1] / 8;
-            str += `,${a / m},${b / m}`;
+          if (typedArray.byteLength !== typedArray.buffer.byteLength) {
+            str += `,${typedArray.byteOffset},${typedArray.length}`;
           }
           str += "]";
           break;
@@ -447,20 +423,10 @@ function stringify$1(value, reducers) {
           break;
         default:
           if (!is_plain_object(thing)) {
-            throw new DevalueError(
-              `Cannot stringify arbitrary non-POJOs`,
-              keys,
-              thing,
-              value
-            );
+            throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys, thing, value);
           }
           if (enumerable_symbols(thing).length > 0) {
-            throw new DevalueError(
-              `Cannot stringify POJOs with symbolic keys`,
-              keys,
-              thing,
-              value
-            );
+            throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys, thing, value);
           }
           if (Object.getPrototypeOf(thing) === null) {
             str = '["null"';
@@ -505,12 +471,11 @@ function stringify$1(value, reducers) {
   }
   const index = flatten(value);
   if (index < 0) return `${index}`;
-  return `[${stringified.join(",")}]`;
+  return stringified;
 }
 function stringify_primitive(thing) {
   const type = typeof thing;
   if (type === "string") return stringify_string(thing);
-  if (thing instanceof String) return stringify_string(thing.toString());
   if (thing === void 0) return UNDEFINED.toString();
   if (thing === 0 && 1 / thing < 0) return NEGATIVE_ZERO.toString();
   if (type === "bigint") return `["BigInt","${thing}"]`;
@@ -607,13 +572,13 @@ async function deserialize_binary_form(request) {
       chunks2.push(chunk);
       cursor += chunk.byteLength;
     }
-    const buffer = new Uint8Array(length);
+    const buffer2 = new Uint8Array(length);
     cursor = 0;
     for (const chunk of chunks2) {
-      buffer.set(chunk, cursor);
+      buffer2.set(chunk, cursor);
       cursor += chunk.byteLength;
     }
-    return buffer;
+    return buffer2;
   }
   const header = await get_buffer(0, HEADER_BYTES);
   if (!header) throw deserialize_error("too short");
@@ -1322,7 +1287,7 @@ const options = {
 		<div class="error">
 			<span class="status">` + status + '</span>\n			<div class="message">\n				<h1>' + message + "</h1>\n			</div>\n		</div>\n	</body>\n</html>\n"
   },
-  version_hash: "1viglpw"
+  version_hash: "1h07asd"
 };
 async function get_hooks() {
   let handle;
@@ -4200,98 +4165,121 @@ function redirect_json_response(redirect) {
     }
   );
 }
-var cookie = {};
-var hasRequiredCookie;
-function requireCookie() {
-  if (hasRequiredCookie) return cookie;
-  hasRequiredCookie = 1;
-  cookie.parse = parse;
-  cookie.serialize = serialize;
-  var __toString = Object.prototype.toString;
-  var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
-  function parse(str, options2) {
-    if (typeof str !== "string") {
-      throw new TypeError("argument str must be a string");
-    }
-    var obj = {};
-    var opt = options2 || {};
-    var dec = opt.decode || decode;
-    var index = 0;
-    while (index < str.length) {
-      var eqIdx = str.indexOf("=", index);
-      if (eqIdx === -1) {
+var dist = {};
+var hasRequiredDist;
+function requireDist() {
+  if (hasRequiredDist) return dist;
+  hasRequiredDist = 1;
+  Object.defineProperty(dist, "__esModule", { value: true });
+  dist.parseCookie = parseCookie;
+  dist.parse = parseCookie;
+  dist.stringifyCookie = stringifyCookie;
+  dist.stringifySetCookie = stringifySetCookie;
+  dist.serialize = stringifySetCookie;
+  dist.parseSetCookie = parseSetCookie2;
+  dist.stringifySetCookie = stringifySetCookie;
+  dist.serialize = stringifySetCookie;
+  const cookieNameRegExp = /^[\u0021-\u003A\u003C\u003E-\u007E]+$/;
+  const cookieValueRegExp = /^[\u0021-\u003A\u003C-\u007E]*$/;
+  const domainValueRegExp = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
+  const pathValueRegExp = /^[\u0020-\u003A\u003D-\u007E]*$/;
+  const maxAgeRegExp = /^-?\d+$/;
+  const __toString = Object.prototype.toString;
+  const NullObject = /* @__PURE__ */ (() => {
+    const C = function() {
+    };
+    C.prototype = /* @__PURE__ */ Object.create(null);
+    return C;
+  })();
+  function parseCookie(str, options2) {
+    const obj = new NullObject();
+    const len = str.length;
+    if (len < 2)
+      return obj;
+    const dec = options2?.decode || decode;
+    let index = 0;
+    do {
+      const eqIdx = eqIndex(str, index, len);
+      if (eqIdx === -1)
         break;
-      }
-      var endIdx = str.indexOf(";", index);
-      if (endIdx === -1) {
-        endIdx = str.length;
-      } else if (endIdx < eqIdx) {
+      const endIdx = endIndex(str, index, len);
+      if (eqIdx > endIdx) {
         index = str.lastIndexOf(";", eqIdx - 1) + 1;
         continue;
       }
-      var key2 = str.slice(index, eqIdx).trim();
-      if (void 0 === obj[key2]) {
-        var val = str.slice(eqIdx + 1, endIdx).trim();
-        if (val.charCodeAt(0) === 34) {
-          val = val.slice(1, -1);
-        }
-        obj[key2] = tryDecode(val, dec);
+      const key2 = valueSlice(str, index, eqIdx);
+      if (obj[key2] === void 0) {
+        obj[key2] = dec(valueSlice(str, eqIdx + 1, endIdx));
       }
       index = endIdx + 1;
-    }
+    } while (index < len);
     return obj;
   }
-  function serialize(name, val, options2) {
-    var opt = options2 || {};
-    var enc = opt.encode || encode2;
-    if (typeof enc !== "function") {
-      throw new TypeError("option encode is invalid");
+  function stringifyCookie(cookie, options2) {
+    const enc = options2?.encode || encodeURIComponent;
+    const cookieStrings = [];
+    for (const name of Object.keys(cookie)) {
+      const val = cookie[name];
+      if (val === void 0)
+        continue;
+      if (!cookieNameRegExp.test(name)) {
+        throw new TypeError(`cookie name is invalid: ${name}`);
+      }
+      const value = enc(val);
+      if (!cookieValueRegExp.test(value)) {
+        throw new TypeError(`cookie val is invalid: ${val}`);
+      }
+      cookieStrings.push(`${name}=${value}`);
     }
-    if (!fieldContentRegExp.test(name)) {
-      throw new TypeError("argument name is invalid");
+    return cookieStrings.join("; ");
+  }
+  function stringifySetCookie(_name, _val, _opts) {
+    const cookie = typeof _name === "object" ? _name : { ..._opts, name: _name, value: String(_val) };
+    const options2 = typeof _val === "object" ? _val : _opts;
+    const enc = options2?.encode || encodeURIComponent;
+    if (!cookieNameRegExp.test(cookie.name)) {
+      throw new TypeError(`argument name is invalid: ${cookie.name}`);
     }
-    var value = enc(val);
-    if (value && !fieldContentRegExp.test(value)) {
-      throw new TypeError("argument val is invalid");
+    const value = cookie.value ? enc(cookie.value) : "";
+    if (!cookieValueRegExp.test(value)) {
+      throw new TypeError(`argument val is invalid: ${cookie.value}`);
     }
-    var str = name + "=" + value;
-    if (null != opt.maxAge) {
-      var maxAge = opt.maxAge - 0;
-      if (isNaN(maxAge) || !isFinite(maxAge)) {
-        throw new TypeError("option maxAge is invalid");
+    let str = cookie.name + "=" + value;
+    if (cookie.maxAge !== void 0) {
+      if (!Number.isInteger(cookie.maxAge)) {
+        throw new TypeError(`option maxAge is invalid: ${cookie.maxAge}`);
       }
-      str += "; Max-Age=" + Math.floor(maxAge);
+      str += "; Max-Age=" + cookie.maxAge;
     }
-    if (opt.domain) {
-      if (!fieldContentRegExp.test(opt.domain)) {
-        throw new TypeError("option domain is invalid");
+    if (cookie.domain) {
+      if (!domainValueRegExp.test(cookie.domain)) {
+        throw new TypeError(`option domain is invalid: ${cookie.domain}`);
       }
-      str += "; Domain=" + opt.domain;
+      str += "; Domain=" + cookie.domain;
     }
-    if (opt.path) {
-      if (!fieldContentRegExp.test(opt.path)) {
-        throw new TypeError("option path is invalid");
+    if (cookie.path) {
+      if (!pathValueRegExp.test(cookie.path)) {
+        throw new TypeError(`option path is invalid: ${cookie.path}`);
       }
-      str += "; Path=" + opt.path;
+      str += "; Path=" + cookie.path;
     }
-    if (opt.expires) {
-      var expires = opt.expires;
-      if (!isDate(expires) || isNaN(expires.valueOf())) {
-        throw new TypeError("option expires is invalid");
+    if (cookie.expires) {
+      if (!isDate(cookie.expires) || !Number.isFinite(cookie.expires.valueOf())) {
+        throw new TypeError(`option expires is invalid: ${cookie.expires}`);
       }
-      str += "; Expires=" + expires.toUTCString();
+      str += "; Expires=" + cookie.expires.toUTCString();
     }
-    if (opt.httpOnly) {
+    if (cookie.httpOnly) {
       str += "; HttpOnly";
     }
-    if (opt.secure) {
+    if (cookie.secure) {
       str += "; Secure";
     }
-    if (opt.partitioned) {
+    if (cookie.partitioned) {
       str += "; Partitioned";
     }
-    if (opt.priority) {
-      var priority = typeof opt.priority === "string" ? opt.priority.toLowerCase() : opt.priority;
+    if (cookie.priority) {
+      const priority = typeof cookie.priority === "string" ? cookie.priority.toLowerCase() : void 0;
       switch (priority) {
         case "low":
           str += "; Priority=Low";
@@ -4303,49 +4291,130 @@ function requireCookie() {
           str += "; Priority=High";
           break;
         default:
-          throw new TypeError("option priority is invalid");
+          throw new TypeError(`option priority is invalid: ${cookie.priority}`);
       }
     }
-    if (opt.sameSite) {
-      var sameSite = typeof opt.sameSite === "string" ? opt.sameSite.toLowerCase() : opt.sameSite;
+    if (cookie.sameSite) {
+      const sameSite = typeof cookie.sameSite === "string" ? cookie.sameSite.toLowerCase() : cookie.sameSite;
       switch (sameSite) {
         case true:
+        case "strict":
           str += "; SameSite=Strict";
           break;
         case "lax":
           str += "; SameSite=Lax";
           break;
-        case "strict":
-          str += "; SameSite=Strict";
-          break;
         case "none":
           str += "; SameSite=None";
           break;
         default:
-          throw new TypeError("option sameSite is invalid");
+          throw new TypeError(`option sameSite is invalid: ${cookie.sameSite}`);
       }
     }
     return str;
   }
-  function decode(str) {
-    return str.indexOf("%") !== -1 ? decodeURIComponent(str) : str;
+  function parseSetCookie2(str, options2) {
+    const dec = options2?.decode || decode;
+    const len = str.length;
+    const endIdx = endIndex(str, 0, len);
+    const eqIdx = eqIndex(str, 0, endIdx);
+    const setCookie = eqIdx === -1 ? { name: "", value: dec(valueSlice(str, 0, endIdx)) } : {
+      name: valueSlice(str, 0, eqIdx),
+      value: dec(valueSlice(str, eqIdx + 1, endIdx))
+    };
+    let index = endIdx + 1;
+    while (index < len) {
+      const endIdx2 = endIndex(str, index, len);
+      const eqIdx2 = eqIndex(str, index, endIdx2);
+      const attr = eqIdx2 === -1 ? valueSlice(str, index, endIdx2) : valueSlice(str, index, eqIdx2);
+      const val = eqIdx2 === -1 ? void 0 : valueSlice(str, eqIdx2 + 1, endIdx2);
+      switch (attr.toLowerCase()) {
+        case "httponly":
+          setCookie.httpOnly = true;
+          break;
+        case "secure":
+          setCookie.secure = true;
+          break;
+        case "partitioned":
+          setCookie.partitioned = true;
+          break;
+        case "domain":
+          setCookie.domain = val;
+          break;
+        case "path":
+          setCookie.path = val;
+          break;
+        case "max-age":
+          if (val && maxAgeRegExp.test(val))
+            setCookie.maxAge = Number(val);
+          break;
+        case "expires":
+          if (!val)
+            break;
+          const date = new Date(val);
+          if (Number.isFinite(date.valueOf()))
+            setCookie.expires = date;
+          break;
+        case "priority":
+          if (!val)
+            break;
+          const priority = val.toLowerCase();
+          if (priority === "low" || priority === "medium" || priority === "high") {
+            setCookie.priority = priority;
+          }
+          break;
+        case "samesite":
+          if (!val)
+            break;
+          const sameSite = val.toLowerCase();
+          if (sameSite === "lax" || sameSite === "strict" || sameSite === "none") {
+            setCookie.sameSite = sameSite;
+          }
+          break;
+      }
+      index = endIdx2 + 1;
+    }
+    return setCookie;
   }
-  function encode2(val) {
-    return encodeURIComponent(val);
+  function endIndex(str, min, len) {
+    const index = str.indexOf(";", min);
+    return index === -1 ? len : index;
   }
-  function isDate(val) {
-    return __toString.call(val) === "[object Date]" || val instanceof Date;
+  function eqIndex(str, min, max) {
+    const index = str.indexOf("=", min);
+    return index < max ? index : -1;
   }
-  function tryDecode(str, decode2) {
+  function valueSlice(str, min, max) {
+    let start = min;
+    let end = max;
+    do {
+      const code = str.charCodeAt(start);
+      if (code !== 32 && code !== 9)
+        break;
+    } while (++start < end);
+    while (end > start) {
+      const code = str.charCodeAt(end - 1);
+      if (code !== 32 && code !== 9)
+        break;
+      end--;
+    }
+    return str.slice(start, end);
+  }
+  function decode(str) {
+    if (str.indexOf("%") === -1)
+      return str;
     try {
-      return decode2(str);
+      return decodeURIComponent(str);
     } catch (e) {
       return str;
     }
   }
-  return cookie;
+  function isDate(val) {
+    return __toString.call(val) === "[object Date]";
+  }
+  return dist;
 }
-var cookieExports = requireCookie();
+var distExports = /* @__PURE__ */ requireDist();
 const INVALID_COOKIE_CHARACTER_REGEX = /[\x00-\x1F\x7F()<>@,;:"/[\]?={} \t]/;
 function validate_options(options2) {
   if (options2?.path === void 0) {
@@ -4357,7 +4426,7 @@ function generate_cookie_key(domain, path, name) {
 }
 function get_cookies(request, url) {
   const header = request.headers.get("cookie") ?? "";
-  const initial_cookies = cookieExports.parse(header, { decode: (value) => value });
+  const initial_cookies = distExports.parse(header, { decode: (value) => value });
   let normalized_url;
   const new_cookies = /* @__PURE__ */ new Map();
   const defaults = {
@@ -4381,15 +4450,15 @@ function get_cookies(request, url) {
       if (best_match) {
         return best_match.options.maxAge === 0 ? void 0 : best_match.value;
       }
-      const req_cookies = cookieExports.parse(header, { decode: opts?.decode });
-      const cookie2 = req_cookies[name];
-      return cookie2;
+      const req_cookies = distExports.parse(header, { decode: opts?.decode });
+      const cookie = req_cookies[name];
+      return cookie;
     },
     /**
      * @param {import('cookie').CookieParseOptions} [opts]
      */
     getAll(opts) {
-      const cookies2 = cookieExports.parse(header, { decode: opts?.decode });
+      const cookies2 = distExports.parse(header, { decode: opts?.decode });
       const lookup = /* @__PURE__ */ new Map();
       for (const c of new_cookies.values()) {
         if (domain_matches(url.hostname, c.options.domain) && path_matches(url.pathname, c.options.path)) {
@@ -4443,7 +4512,7 @@ function get_cookies(request, url) {
         }
         path = resolve(normalized_url, path);
       }
-      return cookieExports.serialize(name, value, { ...defaults, ...options2, path });
+      return distExports.serialize(name, value, { ...defaults, ...options2, path });
     }
   };
   function get_cookie_header(destination, header2) {
@@ -4451,14 +4520,14 @@ function get_cookies(request, url) {
       // cookies sent by the user agent have lowest precedence
       ...initial_cookies
     };
-    for (const cookie2 of new_cookies.values()) {
-      if (!domain_matches(destination.hostname, cookie2.options.domain)) continue;
-      if (!path_matches(destination.pathname, cookie2.options.path)) continue;
-      const encoder = cookie2.options.encode || encodeURIComponent;
-      combined_cookies[cookie2.name] = encoder(cookie2.value);
+    for (const cookie of new_cookies.values()) {
+      if (!domain_matches(destination.hostname, cookie.options.domain)) continue;
+      if (!path_matches(destination.pathname, cookie.options.path)) continue;
+      const encoder = cookie.options.encode || encodeURIComponent;
+      combined_cookies[cookie.name] = encoder(cookie.value);
     }
     if (header2) {
-      const parsed = cookieExports.parse(header2, { decode: (value) => value });
+      const parsed = distExports.parse(header2, { decode: (value) => value });
       for (const name in parsed) {
         combined_cookies[name] = parsed[name];
       }
@@ -4476,8 +4545,8 @@ function get_cookies(request, url) {
       path = resolve(normalized_url, path);
     }
     const cookie_key = generate_cookie_key(options2.domain, path, name);
-    const cookie2 = { name, value, options: { ...options2, path } };
-    new_cookies.set(cookie_key, cookie2);
+    const cookie = { name, value, options: { ...options2, path } };
+    new_cookies.set(cookie_key, cookie);
   }
   function set_trailing_slash(trailing_slash) {
     normalized_url = normalize_path(url.pathname, trailing_slash);
@@ -4500,10 +4569,10 @@ function path_matches(path, constraint) {
 function add_cookies_to_headers(headers2, cookies) {
   for (const new_cookie of cookies) {
     const { name, value, options: options2 } = new_cookie;
-    headers2.append("set-cookie", cookieExports.serialize(name, value, options2));
+    headers2.append("set-cookie", distExports.serialize(name, value, options2));
     if (options2.path.endsWith(".html")) {
       const path = add_data_suffix(options2.path);
-      headers2.append("set-cookie", cookieExports.serialize(name, value, { ...options2, path }));
+      headers2.append("set-cookie", distExports.serialize(name, value, { ...options2, path }));
     }
   }
 }
@@ -4541,9 +4610,9 @@ function parseString(setCookieValue, options2) {
       e
     );
   }
-  var cookie2 = createNullObj();
-  cookie2.name = name;
-  cookie2.value = value;
+  var cookie = createNullObj();
+  cookie.name = name;
+  cookie.value = value;
   parts.forEach(function(part) {
     var sides = part.split("=");
     var key2 = sides.shift().trimLeft().toLowerCase();
@@ -4552,23 +4621,23 @@ function parseString(setCookieValue, options2) {
     }
     var value2 = sides.join("=");
     if (key2 === "expires") {
-      cookie2.expires = new Date(value2);
+      cookie.expires = new Date(value2);
     } else if (key2 === "max-age") {
       var n = parseInt(value2, 10);
-      if (!Number.isNaN(n)) cookie2.maxAge = n;
+      if (!Number.isNaN(n)) cookie.maxAge = n;
     } else if (key2 === "secure") {
-      cookie2.secure = true;
+      cookie.secure = true;
     } else if (key2 === "httponly") {
-      cookie2.httpOnly = true;
+      cookie.httpOnly = true;
     } else if (key2 === "samesite") {
-      cookie2.sameSite = value2;
+      cookie.sameSite = value2;
     } else if (key2 === "partitioned") {
-      cookie2.partitioned = true;
+      cookie.partitioned = true;
     } else if (key2) {
-      cookie2[key2] = value2;
+      cookie[key2] = value2;
     }
   });
-  return cookie2;
+  return cookie;
 }
 function parseNameValuePair(nameValuePairStr) {
   var name = "";
@@ -4627,9 +4696,9 @@ function parseSetCookie(input, options2) {
   } else {
     var cookies = createNullObj();
     return input.reduce(function(cookies2, str) {
-      var cookie2 = parseString(str, options2);
-      if (cookie2 && !isForbiddenKey(cookie2.name)) {
-        cookies2[cookie2.name] = cookie2;
+      var cookie = parseString(str, options2);
+      if (cookie && !isForbiddenKey(cookie.name)) {
+        cookies2[cookie.name] = cookie;
       }
       return cookies2;
     }, cookies);
@@ -4718,8 +4787,8 @@ function create_fetch({ event, options: options2, manifest, state, get_cookie_he
         const decoded = decodeURIComponent(url.pathname);
         if (url.origin !== event.url.origin || base && decoded !== base && !decoded.startsWith(`${base}/`)) {
           if (`.${url.hostname}`.endsWith(`.${event.url.hostname}`) && credentials !== "omit") {
-            const cookie2 = get_cookie_header(url, request.headers.get("cookie"));
-            if (cookie2) request.headers.set("cookie", cookie2);
+            const cookie = get_cookie_header(url, request.headers.get("cookie"));
+            if (cookie) request.headers.set("cookie", cookie);
           }
           return fetch(request);
         }
@@ -4751,9 +4820,9 @@ function create_fetch({ event, options: options2, manifest, state, get_cookie_he
           return await fetch(request);
         }
         if (credentials !== "omit") {
-          const cookie2 = get_cookie_header(url, request.headers.get("cookie"));
-          if (cookie2) {
-            request.headers.set("cookie", cookie2);
+          const cookie = get_cookie_header(url, request.headers.get("cookie"));
+          if (cookie) {
+            request.headers.set("cookie", cookie);
           }
           const authorization = event.request.headers.get("authorization");
           if (authorization && !request.headers.has("authorization")) {