@graphql-hive/gateway-runtime 2.1.0 → 2.1.1-alpha-e43a6c1917d3c195bc31b20b3caee2b0deaa9c7b

package/dist/index.js

@@ -19,13 +19,27 @@ import { wrapSchema, schemaFromExecutor } from '@graphql-tools/wrap';
 import { useCSRFPrevention } from '@graphql-yoga/plugin-csrf-prevention';
 import { useDeferStream } from '@graphql-yoga/plugin-defer-stream';
 import { usePersistedOperations } from '@graphql-yoga/plugin-persisted-operations';
-import { AsyncDisposableStack } from '@whatwg-node/disposablestack';
+import require$$1__default, { AsyncDisposableStack } from '@whatwg-node/disposablestack';
 export * from '@whatwg-node/disposablestack';
-import { handleMaybePromise, iterateAsync } from '@whatwg-node/promise-helpers';
+import require$$4, { handleMaybePromise, iterateAsync } from '@whatwg-node/promise-helpers';
 import { useCookies } from '@whatwg-node/server-plugin-cookies';
 import { print, visit, visitWithTypeInfo, getArgumentValues, getNamedType, isIntrospectionType, isListType, isCompositeType, getOperationAST, isSchema, parse, buildASTSchema, buildSchema } from 'graphql';
 import { isAsyncIterable as isAsyncIterable$1, useReadinessCheck, useExecutionCancellation, createYoga, chain, mergeSchemas } from 'graphql-yoga';
 import { DEFAULT_UPLINKS, fetchSupergraphSdlFromManagedFederation } from '@graphql-tools/federation';
+import require$$0$2 from 'node:buffer';
+import require$$1$4 from 'node:fs';
+import require$$2$1 from 'node:url';
+import require$$0$1 from 'node:stream';
+import require$$1$2 from 'node:tls';
+import require$$0$3 from 'node:http';
+import require$$1$1 from 'node:util';
+import require$$0 from 'node:events';
+import require$$3 from 'node:stream/promises';
+import require$$1$3 from 'node:https';
+import require$$0$5 from 'node:zlib';
+import require$$0$4 from 'tslib';
+import require$$2 from 'node:crypto';
+import require$$3$1 from 'crypto';
 import { useApolloUsageReport } from '@graphql-yoga/plugin-apollo-usage-report';
 import { useHive } from '@graphql-hive/yoga';
 import { useContentEncoding as useContentEncoding$1 } from '@whatwg-node/server';
@@ -72,6 +86,4837 @@ function isDebug() {
   return getEnvBool("DEBUG");
 }
 
+function commonjsRequire(path) {
+	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+
+function isNextJs() {
+  return Object.keys(globalThis).some(key => key.startsWith('__NEXT'))
+}
+
+var shouldSkipPonyfill$2 = function shouldSkipPonyfill() {
+  if (globalThis.Deno) {
+    return true
+  }
+  if (globalThis.Bun) {
+    return true
+  }
+  if (isNextJs()) {
+    return true
+  }
+  return false
+};
+
+var urlpattern;
+var hasRequiredUrlpattern;
+
+function requireUrlpattern () {
+	if (hasRequiredUrlpattern) return urlpattern;
+	hasRequiredUrlpattern = 1;
+var U=Object.defineProperty;var Re=Object.getOwnPropertyDescriptor;var Ee=Object.getOwnPropertyNames;var Oe=Object.prototype.hasOwnProperty;var a=(e,t)=>U(e,"name",{value:t,configurable:true});var ke=(e,t)=>{for(var r in t)U(e,r,{get:t[r],enumerable:true});},Te=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of Ee(t))!Oe.call(e,o)&&o!==r&&U(e,o,{get:()=>t[o],enumerable:!(n=Re(t,o))||n.enumerable});return e};var Ae=e=>Te(U({},"__esModule",{value:true}),e);var He={};ke(He,{URLPattern:()=>M});urlpattern=Ae(He);var P=class{type=3;name="";prefix="";value="";suffix="";modifier=3;constructor(t,r,n,o,l,f){this.type=t,this.name=r,this.prefix=n,this.value=o,this.suffix=l,this.modifier=f;}hasCustomName(){return this.name!==""&&typeof this.name!="number"}};a(P,"Part");var ye=/[$_\p{ID_Start}]/u,we=/[$_\u200C\u200D\p{ID_Continue}]/u,F=".*";function Ce(e,t){return (t?/^[\x00-\xFF]*$/:/^[\x00-\x7F]*$/).test(e)}a(Ce,"isASCII");function W(e,t=false){let r=[],n=0;for(;n<e.length;){let o=e[n],l=a(function(f){if(!t)throw new TypeError(f);r.push({type:"INVALID_CHAR",index:n,value:e[n++]});},"ErrorOrInvalid");if(o==="*"){r.push({type:"ASTERISK",index:n,value:e[n++]});continue}if(o==="+"||o==="?"){r.push({type:"OTHER_MODIFIER",index:n,value:e[n++]});continue}if(o==="\\"){r.push({type:"ESCAPED_CHAR",index:n++,value:e[n++]});continue}if(o==="{"){r.push({type:"OPEN",index:n,value:e[n++]});continue}if(o==="}"){r.push({type:"CLOSE",index:n,value:e[n++]});continue}if(o===":"){let f="",s=n+1;for(;s<e.length;){let i=e.substr(s,1);if(s===n+1&&ye.test(i)||s!==n+1&&we.test(i)){f+=e[s++];continue}break}if(!f){l(`Missing parameter name at ${n}`);continue}r.push({type:"NAME",index:n,value:f}),n=s;continue}if(o==="("){let f=1,s="",i=n+1,c=false;if(e[i]==="?"){l(`Pattern cannot start with "?" at ${i}`);continue}for(;i<e.length;){if(!Ce(e[i],false)){l(`Invalid character '${e[i]}' at ${i}.`),c=true;break}if(e[i]==="\\"){s+=e[i++]+e[i++];continue}if(e[i]===")"){if(f--,f===0){i++;break}}else if(e[i]==="("&&(f++,e[i+1]!=="?")){l(`Capturing groups are not allowed at ${i}`),c=true;break}s+=e[i++];}if(c)continue;if(f){l(`Unbalanced pattern at ${n}`);continue}if(!s){l(`Missing pattern at ${n}`);continue}r.push({type:"REGEX",index:n,value:s}),n=i;continue}r.push({type:"CHAR",index:n,value:e[n++]});}return r.push({type:"END",index:n,value:""}),r}a(W,"lexer");function _(e,t={}){let r=W(e);t.delimiter??="/#?",t.prefixes??="./";let n=`[^${x(t.delimiter)}]+?`,o=[],l=0,f=0,i=new Set,c=a(u=>{if(f<r.length&&r[f].type===u)return r[f++].value},"tryConsume"),h=a(()=>c("OTHER_MODIFIER")??c("ASTERISK"),"tryConsumeModifier"),p=a(u=>{let d=c(u);if(d!==void 0)return d;let{type:g,index:y}=r[f];throw new TypeError(`Unexpected ${g} at ${y}, expected ${u}`)},"mustConsume"),A=a(()=>{let u="",d;for(;d=c("CHAR")??c("ESCAPED_CHAR");)u+=d;return u},"consumeText"),be=a(u=>u,"DefaultEncodePart"),N=t.encodePart||be,H="",v=a(u=>{H+=u;},"appendToPendingFixedValue"),D=a(()=>{H.length&&(o.push(new P(3,"","",N(H),"",3)),H="");},"maybeAddPartFromPendingFixedValue"),Z=a((u,d,g,y,B)=>{let m=3;switch(B){case "?":m=1;break;case "*":m=0;break;case "+":m=2;break}if(!d&&!g&&m===3){v(u);return}if(D(),!d&&!g){if(!u)return;o.push(new P(3,"","",N(u),"",m));return}let S;g?g==="*"?S=F:S=g:S=n;let k=2;S===n?(k=1,S=""):S===F&&(k=0,S="");let E;if(d?E=d:g&&(E=l++),i.has(E))throw new TypeError(`Duplicate name '${E}'.`);i.add(E),o.push(new P(k,E,N(u),S,N(y),m));},"addPart");for(;f<r.length;){let u=c("CHAR"),d=c("NAME"),g=c("REGEX");if(!d&&!g&&(g=c("ASTERISK")),d||g){let m=u??"";t.prefixes.indexOf(m)===-1&&(v(m),m=""),D();let S=h();Z(m,d,g,"",S);continue}let y=u??c("ESCAPED_CHAR");if(y){v(y);continue}if(c("OPEN")){let m=A(),S=c("NAME"),k=c("REGEX");!S&&!k&&(k=c("ASTERISK"));let E=A();p("CLOSE");let Pe=h();Z(m,S,k,E,Pe);continue}D(),p("END");}return o}a(_,"parse");function x(e){return e.replace(/([.+*?^${}()[\]|/\\])/g,"\\$1")}a(x,"escapeString");function q(e){return e&&e.ignoreCase?"ui":"u"}a(q,"flags");function J(e,t,r){return z(_(e,r),t,r)}a(J,"stringToRegexp");function T(e){switch(e){case 0:return "*";case 1:return "?";case 2:return "+";case 3:return ""}}a(T,"modifierToString");function z(e,t,r={}){r.delimiter??="/#?",r.prefixes??="./",r.sensitive??=false,r.strict??=false,r.end??=true,r.start??=true,r.endsWith="";let n=r.start?"^":"";for(let s of e){if(s.type===3){s.modifier===3?n+=x(s.value):n+=`(?:${x(s.value)})${T(s.modifier)}`;continue}t&&t.push(s.name);let i=`[^${x(r.delimiter)}]+?`,c=s.value;if(s.type===1?c=i:s.type===0&&(c=F),!s.prefix.length&&!s.suffix.length){s.modifier===3||s.modifier===1?n+=`(${c})${T(s.modifier)}`:n+=`((?:${c})${T(s.modifier)})`;continue}if(s.modifier===3||s.modifier===1){n+=`(?:${x(s.prefix)}(${c})${x(s.suffix)})`,n+=T(s.modifier);continue}n+=`(?:${x(s.prefix)}`,n+=`((?:${c})(?:`,n+=x(s.suffix),n+=x(s.prefix),n+=`(?:${c}))*)${x(s.suffix)})`,s.modifier===0&&(n+="?");}let o=`[${x(r.endsWith)}]|$`,l=`[${x(r.delimiter)}]`;if(r.end)return r.strict||(n+=`${l}?`),r.endsWith.length?n+=`(?=${o})`:n+="$",new RegExp(n,q(r));r.strict||(n+=`(?:${l}(?=${o}))?`);let f=false;if(e.length){let s=e[e.length-1];s.type===3&&s.modifier===3&&(f=r.delimiter.indexOf(s)>-1);}return f||(n+=`(?=${l}|${o})`),new RegExp(n,q(r))}a(z,"partsToRegexp");var b={delimiter:"",prefixes:"",sensitive:true,strict:true},Q={delimiter:".",prefixes:"",sensitive:true,strict:true},ee={delimiter:"/",prefixes:"/",sensitive:true,strict:true};function te(e,t){return e.length?e[0]==="/"?true:!t||e.length<2?false:(e[0]=="\\"||e[0]=="{")&&e[1]=="/":false}a(te,"isAbsolutePathname");function re(e,t){return e.startsWith(t)?e.substring(t.length,e.length):e}a(re,"maybeStripPrefix");function Le(e,t){return e.endsWith(t)?e.substr(0,e.length-t.length):e}a(Le,"maybeStripSuffix");function j(e){return !e||e.length<2?false:e[0]==="["||(e[0]==="\\"||e[0]==="{")&&e[1]==="["}a(j,"treatAsIPv6Hostname");var ne=["ftp","file","http","https","ws","wss"];function $(e){if(!e)return  true;for(let t of ne)if(e.test(t))return  true;return  false}a($,"isSpecialScheme");function se(e,t){if(e=re(e,"#"),t||e==="")return e;let r=new URL("https://example.com");return r.hash=e,r.hash?r.hash.substring(1,r.hash.length):""}a(se,"canonicalizeHash");function ie(e,t){if(e=re(e,"?"),t||e==="")return e;let r=new URL("https://example.com");return r.search=e,r.search?r.search.substring(1,r.search.length):""}a(ie,"canonicalizeSearch");function ae(e,t){return t||e===""?e:j(e)?V(e):G(e)}a(ae,"canonicalizeHostname");function oe(e,t){if(t||e==="")return e;let r=new URL("https://example.com");return r.password=e,r.password}a(oe,"canonicalizePassword");function ce(e,t){if(t||e==="")return e;let r=new URL("https://example.com");return r.username=e,r.username}a(ce,"canonicalizeUsername");function le(e,t,r){if(r||e==="")return e;if(t&&!ne.includes(t))return new URL(`${t}:${e}`).pathname;let n=e[0]=="/";return e=new URL(n?e:"/-"+e,"https://example.com").pathname,n||(e=e.substring(2,e.length)),e}a(le,"canonicalizePathname");function fe(e,t,r){return K(t)===e&&(e=""),r||e===""?e:Y(e)}a(fe,"canonicalizePort");function he(e,t){return e=Le(e,":"),t||e===""?e:w(e)}a(he,"canonicalizeProtocol");function K(e){switch(e){case "ws":case "http":return "80";case "wws":case "https":return "443";case "ftp":return "21";default:return ""}}a(K,"defaultPortForProtocol");function w(e){if(e==="")return e;if(/^[-+.A-Za-z0-9]*$/.test(e))return e.toLowerCase();throw new TypeError(`Invalid protocol '${e}'.`)}a(w,"protocolEncodeCallback");function ue(e){if(e==="")return e;let t=new URL("https://example.com");return t.username=e,t.username}a(ue,"usernameEncodeCallback");function de(e){if(e==="")return e;let t=new URL("https://example.com");return t.password=e,t.password}a(de,"passwordEncodeCallback");function G(e){if(e==="")return e;if(/[\t\n\r #%/:<>?@[\]^\\|]/g.test(e))throw new TypeError(`Invalid hostname '${e}'`);let t=new URL("https://example.com");return t.hostname=e,t.hostname}a(G,"hostnameEncodeCallback");function V(e){if(e==="")return e;if(/[^0-9a-fA-F[\]:]/g.test(e))throw new TypeError(`Invalid IPv6 hostname '${e}'`);return e.toLowerCase()}a(V,"ipv6HostnameEncodeCallback");function Y(e){if(e===""||/^[0-9]*$/.test(e)&&parseInt(e)<=65535)return e;throw new TypeError(`Invalid port '${e}'.`)}a(Y,"portEncodeCallback");function pe(e){if(e==="")return e;let t=new URL("https://example.com");return t.pathname=e[0]!=="/"?"/-"+e:e,e[0]!=="/"?t.pathname.substring(2,t.pathname.length):t.pathname}a(pe,"standardURLPathnameEncodeCallback");function ge(e){return e===""?e:new URL(`data:${e}`).pathname}a(ge,"pathURLPathnameEncodeCallback");function me(e){if(e==="")return e;let t=new URL("https://example.com");return t.search=e,t.search.substring(1,t.search.length)}a(me,"searchEncodeCallback");function Se(e){if(e==="")return e;let t=new URL("https://example.com");return t.hash=e,t.hash.substring(1,t.hash.length)}a(Se,"hashEncodeCallback");var C=class{#i;#n=[];#t={};#e=0;#s=1;#l=0;#o=0;#d=0;#p=0;#g=false;constructor(t){this.#i=t;}get result(){return this.#t}parse(){for(this.#n=W(this.#i,true);this.#e<this.#n.length;this.#e+=this.#s){if(this.#s=1,this.#n[this.#e].type==="END"){if(this.#o===0){this.#b(),this.#f()?this.#r(9,1):this.#h()?this.#r(8,1):this.#r(7,0);continue}else if(this.#o===2){this.#u(5);continue}this.#r(10,0);break}if(this.#d>0)if(this.#A())this.#d-=1;else continue;if(this.#T()){this.#d+=1;continue}switch(this.#o){case 0:this.#P()&&this.#u(1);break;case 1:if(this.#P()){this.#C();let t=7,r=1;this.#E()?(t=2,r=3):this.#g&&(t=2),this.#r(t,r);}break;case 2:this.#S()?this.#u(3):(this.#x()||this.#h()||this.#f())&&this.#u(5);break;case 3:this.#O()?this.#r(4,1):this.#S()&&this.#r(5,1);break;case 4:this.#S()&&this.#r(5,1);break;case 5:this.#y()?this.#p+=1:this.#w()&&(this.#p-=1),this.#k()&&!this.#p?this.#r(6,1):this.#x()?this.#r(7,0):this.#h()?this.#r(8,1):this.#f()&&this.#r(9,1);break;case 6:this.#x()?this.#r(7,0):this.#h()?this.#r(8,1):this.#f()&&this.#r(9,1);break;case 7:this.#h()?this.#r(8,1):this.#f()&&this.#r(9,1);break;case 8:this.#f()&&this.#r(9,1);break;}}this.#t.hostname!==void 0&&this.#t.port===void 0&&(this.#t.port="");}#r(t,r){switch(this.#o){case 0:break;case 1:this.#t.protocol=this.#c();break;case 2:break;case 3:this.#t.username=this.#c();break;case 4:this.#t.password=this.#c();break;case 5:this.#t.hostname=this.#c();break;case 6:this.#t.port=this.#c();break;case 7:this.#t.pathname=this.#c();break;case 8:this.#t.search=this.#c();break;case 9:this.#t.hash=this.#c();break;}this.#o!==0&&t!==10&&([1,2,3,4].includes(this.#o)&&[6,7,8,9].includes(t)&&(this.#t.hostname??=""),[1,2,3,4,5,6].includes(this.#o)&&[8,9].includes(t)&&(this.#t.pathname??=this.#g?"/":""),[1,2,3,4,5,6,7].includes(this.#o)&&t===9&&(this.#t.search??="")),this.#R(t,r);}#R(t,r){this.#o=t,this.#l=this.#e+r,this.#e+=r,this.#s=0;}#b(){this.#e=this.#l,this.#s=0;}#u(t){this.#b(),this.#o=t;}#m(t){return t<0&&(t=this.#n.length-t),t<this.#n.length?this.#n[t]:this.#n[this.#n.length-1]}#a(t,r){let n=this.#m(t);return n.value===r&&(n.type==="CHAR"||n.type==="ESCAPED_CHAR"||n.type==="INVALID_CHAR")}#P(){return this.#a(this.#e,":")}#E(){return this.#a(this.#e+1,"/")&&this.#a(this.#e+2,"/")}#S(){return this.#a(this.#e,"@")}#O(){return this.#a(this.#e,":")}#k(){return this.#a(this.#e,":")}#x(){return this.#a(this.#e,"/")}#h(){if(this.#a(this.#e,"?"))return  true;if(this.#n[this.#e].value!=="?")return  false;let t=this.#m(this.#e-1);return t.type!=="NAME"&&t.type!=="REGEX"&&t.type!=="CLOSE"&&t.type!=="ASTERISK"}#f(){return this.#a(this.#e,"#")}#T(){return this.#n[this.#e].type=="OPEN"}#A(){return this.#n[this.#e].type=="CLOSE"}#y(){return this.#a(this.#e,"[")}#w(){return this.#a(this.#e,"]")}#c(){let t=this.#n[this.#e],r=this.#m(this.#l).index;return this.#i.substring(r,t.index)}#C(){let t={};Object.assign(t,b),t.encodePart=w;let r=J(this.#c(),void 0,t);this.#g=$(r);}};a(C,"Parser");var X=["protocol","username","password","hostname","port","pathname","search","hash"],O="*";function xe(e,t){if(typeof e!="string")throw new TypeError("parameter 1 is not of type 'string'.");let r=new URL(e,t);return {protocol:r.protocol.substring(0,r.protocol.length-1),username:r.username,password:r.password,hostname:r.hostname,port:r.port,pathname:r.pathname,search:r.search!==""?r.search.substring(1,r.search.length):void 0,hash:r.hash!==""?r.hash.substring(1,r.hash.length):void 0}}a(xe,"extractValues");function R(e,t){return t?I(e):e}a(R,"processBaseURLString");function L(e,t,r){let n;if(typeof t.baseURL=="string")try{n=new URL(t.baseURL),t.protocol===void 0&&(e.protocol=R(n.protocol.substring(0,n.protocol.length-1),r)),!r&&t.protocol===void 0&&t.hostname===void 0&&t.port===void 0&&t.username===void 0&&(e.username=R(n.username,r)),!r&&t.protocol===void 0&&t.hostname===void 0&&t.port===void 0&&t.username===void 0&&t.password===void 0&&(e.password=R(n.password,r)),t.protocol===void 0&&t.hostname===void 0&&(e.hostname=R(n.hostname,r)),t.protocol===void 0&&t.hostname===void 0&&t.port===void 0&&(e.port=R(n.port,r)),t.protocol===void 0&&t.hostname===void 0&&t.port===void 0&&t.pathname===void 0&&(e.pathname=R(n.pathname,r)),t.protocol===void 0&&t.hostname===void 0&&t.port===void 0&&t.pathname===void 0&&t.search===void 0&&(e.search=R(n.search.substring(1,n.search.length),r)),t.protocol===void 0&&t.hostname===void 0&&t.port===void 0&&t.pathname===void 0&&t.search===void 0&&t.hash===void 0&&(e.hash=R(n.hash.substring(1,n.hash.length),r));}catch{throw new TypeError(`invalid baseURL '${t.baseURL}'.`)}if(typeof t.protocol=="string"&&(e.protocol=he(t.protocol,r)),typeof t.username=="string"&&(e.username=ce(t.username,r)),typeof t.password=="string"&&(e.password=oe(t.password,r)),typeof t.hostname=="string"&&(e.hostname=ae(t.hostname,r)),typeof t.port=="string"&&(e.port=fe(t.port,e.protocol,r)),typeof t.pathname=="string"){if(e.pathname=t.pathname,n&&!te(e.pathname,r)){let o=n.pathname.lastIndexOf("/");o>=0&&(e.pathname=R(n.pathname.substring(0,o+1),r)+e.pathname);}e.pathname=le(e.pathname,e.protocol,r);}return typeof t.search=="string"&&(e.search=ie(t.search,r)),typeof t.hash=="string"&&(e.hash=se(t.hash,r)),e}a(L,"applyInit");function I(e){return e.replace(/([+*?:{}()\\])/g,"\\$1")}a(I,"escapePatternString");function Ie(e){return e.replace(/([.+*?^${}()[\]|/\\])/g,"\\$1")}a(Ie,"escapeRegexpString");function Ne(e,t){t.delimiter??="/#?",t.prefixes??="./",t.sensitive??=false,t.strict??=false,t.end??=true,t.start??=true,t.endsWith="";let r=".*",n=`[^${Ie(t.delimiter)}]+?`,o=/[$_\u200C\u200D\p{ID_Continue}]/u,l="";for(let f=0;f<e.length;++f){let s=e[f];if(s.type===3){if(s.modifier===3){l+=I(s.value);continue}l+=`{${I(s.value)}}${T(s.modifier)}`;continue}let i=s.hasCustomName(),c=!!s.suffix.length||!!s.prefix.length&&(s.prefix.length!==1||!t.prefixes.includes(s.prefix)),h=f>0?e[f-1]:null,p=f<e.length-1?e[f+1]:null;if(!c&&i&&s.type===1&&s.modifier===3&&p&&!p.prefix.length&&!p.suffix.length)if(p.type===3){let A=p.value.length>0?p.value[0]:"";c=o.test(A);}else c=!p.hasCustomName();if(!c&&!s.prefix.length&&h&&h.type===3){let A=h.value[h.value.length-1];c=t.prefixes.includes(A);}c&&(l+="{"),l+=I(s.prefix),i&&(l+=`:${s.name}`),s.type===2?l+=`(${s.value})`:s.type===1?i||(l+=`(${n})`):s.type===0&&(!i&&(!h||h.type===3||h.modifier!==3||c||s.prefix!=="")?l+="*":l+=`(${r})`),s.type===1&&i&&s.suffix.length&&o.test(s.suffix[0])&&(l+="\\"),l+=I(s.suffix),c&&(l+="}"),s.modifier!==3&&(l+=T(s.modifier));}return l}a(Ne,"partsToPattern");var M=class{#i;#n={};#t={};#e={};#s={};#l=false;constructor(t={},r,n){try{let o;if(typeof r=="string"?o=r:n=r,typeof t=="string"){let i=new C(t);if(i.parse(),t=i.result,o===void 0&&typeof t.protocol!="string")throw new TypeError("A base URL must be provided for a relative constructor string.");t.baseURL=o;}else {if(!t||typeof t!="object")throw new TypeError("parameter 1 is not of type 'string' and cannot convert to dictionary.");if(o)throw new TypeError("parameter 1 is not of type 'string'.")}typeof n>"u"&&(n={ignoreCase:!1});let l={ignoreCase:n.ignoreCase===!0},f={pathname:O,protocol:O,username:O,password:O,hostname:O,port:O,search:O,hash:O};this.#i=L(f,t,!0),K(this.#i.protocol)===this.#i.port&&(this.#i.port="");let s;for(s of X){if(!(s in this.#i))continue;let i={},c=this.#i[s];switch(this.#t[s]=[],s){case "protocol":Object.assign(i,b),i.encodePart=w;break;case "username":Object.assign(i,b),i.encodePart=ue;break;case "password":Object.assign(i,b),i.encodePart=de;break;case "hostname":Object.assign(i,Q),j(c)?i.encodePart=V:i.encodePart=G;break;case "port":Object.assign(i,b),i.encodePart=Y;break;case "pathname":$(this.#n.protocol)?(Object.assign(i,ee,l),i.encodePart=pe):(Object.assign(i,b,l),i.encodePart=ge);break;case "search":Object.assign(i,b,l),i.encodePart=me;break;case "hash":Object.assign(i,b,l),i.encodePart=Se;break}try{this.#s[s]=_(c,i),this.#n[s]=z(this.#s[s],this.#t[s],i),this.#e[s]=Ne(this.#s[s],i),this.#l=this.#l||this.#s[s].some(h=>h.type===2);}catch{throw new TypeError(`invalid ${s} pattern '${this.#i[s]}'.`)}}}catch(o){throw new TypeError(`Failed to construct 'URLPattern': ${o.message}`)}}get[Symbol.toStringTag](){return "URLPattern"}test(t={},r){let n={pathname:"",protocol:"",username:"",password:"",hostname:"",port:"",search:"",hash:""};if(typeof t!="string"&&r)throw new TypeError("parameter 1 is not of type 'string'.");if(typeof t>"u")return  false;try{typeof t=="object"?n=L(n,t,!1):n=L(n,xe(t,r),!1);}catch{return  false}let o;for(o of X)if(!this.#n[o].exec(n[o]))return  false;return  true}exec(t={},r){let n={pathname:"",protocol:"",username:"",password:"",hostname:"",port:"",search:"",hash:""};if(typeof t!="string"&&r)throw new TypeError("parameter 1 is not of type 'string'.");if(typeof t>"u")return;try{typeof t=="object"?n=L(n,t,!1):n=L(n,xe(t,r),!1);}catch{return null}let o={};r?o.inputs=[t,r]:o.inputs=[t];let l;for(l of X){let f=this.#n[l].exec(n[l]);if(!f)return null;let s={};for(let[i,c]of this.#t[l].entries())if(typeof c=="string"||typeof c=="number"){let h=f[i+1];s[c]=h;}o[l]={input:n[l]??"",groups:s};}return o}static compareComponent(t,r,n){let o=a((i,c)=>{for(let h of ["type","modifier","prefix","value","suffix"]){if(i[h]<c[h])return  -1;if(i[h]===c[h])continue;return 1}return 0},"comparePart"),l=new P(3,"","","","",3),f=new P(0,"","","","",3),s=a((i,c)=>{let h=0;for(;h<Math.min(i.length,c.length);++h){let p=o(i[h],c[h]);if(p)return p}return i.length===c.length?0:o(i[h]??l,c[h]??l)},"comparePartList");return !r.#e[t]&&!n.#e[t]?0:r.#e[t]&&!n.#e[t]?s(r.#s[t],[f]):!r.#e[t]&&n.#e[t]?s([f],n.#s[t]):s(r.#s[t],n.#s[t])}get protocol(){return this.#e.protocol}get username(){return this.#e.username}get password(){return this.#e.password}get hostname(){return this.#e.hostname}get port(){return this.#e.port}get pathname(){return this.#e.pathname}get search(){return this.#e.search}get hash(){return this.#e.hash}get hasRegExpGroups(){return this.#l}};a(M,"URLPattern");
+	return urlpattern;
+}
+
+var urlpatternPolyfill;
+var hasRequiredUrlpatternPolyfill;
+
+function requireUrlpatternPolyfill () {
+	if (hasRequiredUrlpatternPolyfill) return urlpatternPolyfill;
+	hasRequiredUrlpatternPolyfill = 1;
+	const { URLPattern } = requireUrlpattern();
+
+	urlpatternPolyfill = { URLPattern };
+
+	if (!globalThis.URLPattern) {
+	  globalThis.URLPattern = URLPattern;
+	}
+	return urlpatternPolyfill;
+}
+
+var cjs = {};
+
+var fetch = {};
+
+var fetchCurl = {};
+
+var Response = {};
+
+var Body = {};
+
+var main = {exports: {}};
+
+var sbmh;
+var hasRequiredSbmh;
+
+function requireSbmh () {
+	if (hasRequiredSbmh) return sbmh;
+	hasRequiredSbmh = 1;
+
+	/**
+	 * Copyright Brian White. All rights reserved.
+	 *
+	 * @see https://github.com/mscdex/streamsearch
+	 *
+	 * Permission is hereby granted, free of charge, to any person obtaining a copy
+	 * of this software and associated documentation files (the "Software"), to
+	 * deal in the Software without restriction, including without limitation the
+	 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+	 * sell copies of the Software, and to permit persons to whom the Software is
+	 * furnished to do so, subject to the following conditions:
+	 *
+	 * The above copyright notice and this permission notice shall be included in
+	 * all copies or substantial portions of the Software.
+	 *
+	 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+	 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+	 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+	 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+	 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+	 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+	 * IN THE SOFTWARE.
+	 *
+	 * Based heavily on the Streaming Boyer-Moore-Horspool C++ implementation
+	 * by Hongli Lai at: https://github.com/FooBarWidget/boyer-moore-horspool
+	 */
+
+	const { EventEmitter } = require$$0;
+	const { inherits } = require$$1$1;
+
+	function SBMH (needle) {
+	  if (typeof needle === 'string') {
+	    needle = Buffer.from(needle);
+	  }
+
+	  if (!Buffer.isBuffer(needle)) {
+	    throw new TypeError('The needle has to be a String or a Buffer.')
+	  }
+
+	  const needleLength = needle.length;
+	  const needleLastCharIndex = needleLength - 1;
+
+	  if (needleLength === 0) {
+	    throw new Error('The needle cannot be an empty String/Buffer.')
+	  }
+
+	  if (needleLength > 256) {
+	    throw new Error('The needle cannot have a length bigger than 256.')
+	  }
+
+	  this.maxMatches = Infinity;
+	  this.matches = 0;
+
+	  this._occ = new Uint8Array(256)
+	    .fill(needleLength); // Initialize occurrence table.
+	  this._lookbehind_size = 0;
+	  this._needle = needle;
+	  this._bufpos = 0;
+
+	  this._lookbehind = Buffer.alloc(needleLastCharIndex);
+
+	  // Populate occurrence table with analysis of the needle,
+	  // ignoring last letter.
+	  for (var i = 0; i < needleLastCharIndex; ++i) { // eslint-disable-line no-var
+	    this._occ[needle[i]] = needleLastCharIndex - i;
+	  }
+	}
+	inherits(SBMH, EventEmitter);
+
+	SBMH.prototype.reset = function () {
+	  this._lookbehind_size = 0;
+	  this.matches = 0;
+	  this._bufpos = 0;
+	};
+
+	SBMH.prototype.push = function (chunk, pos) {
+	  if (!Buffer.isBuffer(chunk)) {
+	    chunk = Buffer.from(chunk, 'binary');
+	  }
+	  const chlen = chunk.length;
+	  this._bufpos = pos || 0;
+	  let r;
+	  while (r !== chlen && this.matches < this.maxMatches) { r = this._sbmh_feed(chunk); }
+	  return r
+	};
+
+	SBMH.prototype._sbmh_feed = function (data) {
+	  const len = data.length;
+	  const needle = this._needle;
+	  const needleLength = needle.length;
+	  const needleLastCharIndex = needleLength - 1;
+	  const needleLastChar = needle[needleLastCharIndex];
+
+	  // Positive: points to a position in `data`
+	  //           pos == 3 points to data[3]
+	  // Negative: points to a position in the lookbehind buffer
+	  //           pos == -2 points to lookbehind[lookbehind_size - 2]
+	  let pos = -this._lookbehind_size;
+	  let ch;
+
+	  if (pos < 0) {
+	    // Lookbehind buffer is not empty. Perform Boyer-Moore-Horspool
+	    // search with character lookup code that considers both the
+	    // lookbehind buffer and the current round's haystack data.
+	    //
+	    // Loop until
+	    //   there is a match.
+	    // or until
+	    //   we've moved past the position that requires the
+	    //   lookbehind buffer. In this case we switch to the
+	    //   optimized loop.
+	    // or until
+	    //   the character to look at lies outside the haystack.
+	    while (pos < 0 && pos <= len - needleLength) {
+	      ch = data[pos + needleLastCharIndex];
+
+	      if (
+	        ch === needleLastChar &&
+	        this._sbmh_memcmp(data, pos, needleLastCharIndex)
+	      ) {
+	        this._lookbehind_size = 0;
+	        ++this.matches;
+	        this.emit('info', true);
+	        return (this._bufpos = pos + needleLength)
+	      }
+
+	      pos += this._occ[ch];
+	    }
+
+	    // No match.
+
+	    while (pos < 0 && !this._sbmh_memcmp(data, pos, len - pos)) {
+	      // There's too few data for Boyer-Moore-Horspool to run,
+	      // so let's use a different algorithm to skip as much as
+	      // we can.
+	      // Forward pos until
+	      //   the trailing part of lookbehind + data
+	      //   looks like the beginning of the needle
+	      // or until
+	      //   pos == 0
+	      ++pos;
+	    }
+
+	    if (pos >= 0) {
+	      // Discard lookbehind buffer.
+	      this.emit('info', false, this._lookbehind, 0, this._lookbehind_size);
+	      this._lookbehind_size = 0;
+	    } else {
+	      // Cut off part of the lookbehind buffer that has
+	      // been processed and append the entire haystack
+	      // into it.
+	      const bytesToCutOff = this._lookbehind_size + pos;
+	      if (bytesToCutOff > 0) {
+	        // The cut off data is guaranteed not to contain the needle.
+	        this.emit('info', false, this._lookbehind, 0, bytesToCutOff);
+	      }
+
+	      this._lookbehind_size -= bytesToCutOff;
+	      this._lookbehind.copy(this._lookbehind, 0, bytesToCutOff, this._lookbehind_size);
+
+	      data.copy(this._lookbehind, this._lookbehind_size);
+	      this._lookbehind_size += len;
+
+	      this._bufpos = len;
+	      return len
+	    }
+	  }
+
+	  // Lookbehind buffer is now empty. We only need to check if the
+	  // needle is in the haystack.
+	  pos = data.indexOf(needle, pos + this._bufpos);
+
+	  if (pos !== -1) {
+	    ++this.matches;
+	    if (pos === 0) { this.emit('info', true); } else { this.emit('info', true, data, this._bufpos, pos); }
+	    return (this._bufpos = pos + needleLength)
+	  }
+
+	  pos = len - needleLastCharIndex;
+	  if (pos < 0) {
+	    pos = 0;
+	  }
+
+	  // There was no match. If there's trailing haystack data that we cannot
+	  // match yet using the Boyer-Moore-Horspool algorithm (because the trailing
+	  // data is less than the needle size) then match using a modified
+	  // algorithm that starts matching from the beginning instead of the end.
+	  // Whatever trailing data is left after running this algorithm is added to
+	  // the lookbehind buffer.
+	  while (
+	    pos !== len &&
+	    (
+	      data[pos] !== needle[0] ||
+	      Buffer.compare(
+	        data.subarray(pos + 1, len),
+	        needle.subarray(1, len - pos)
+	      ) !== 0
+	    )
+	  ) {
+	    ++pos;
+	  }
+
+	  if (pos !== len) {
+	    data.copy(this._lookbehind, 0, pos, len);
+	    this._lookbehind_size = len - pos;
+	  }
+
+	  // Everything until pos is guaranteed not to contain needle data.
+	  if (pos !== 0) { this.emit('info', false, data, this._bufpos, pos); }
+
+	  this._bufpos = len;
+	  return len
+	};
+
+	SBMH.prototype._sbmh_lookup_char = function (data, pos) {
+	  return pos < 0
+	    ? this._lookbehind[this._lookbehind_size + pos]
+	    : data[pos]
+	};
+
+	SBMH.prototype._sbmh_memcmp = function (data, pos, len) {
+	  for (var i = 0; i < len; ++i) { // eslint-disable-line no-var
+	    if (this._sbmh_lookup_char(data, pos + i) !== this._needle[i]) { return false }
+	  }
+	  return true
+	};
+
+	sbmh = SBMH;
+	return sbmh;
+}
+
+var PartStream_1;
+var hasRequiredPartStream;
+
+function requirePartStream () {
+	if (hasRequiredPartStream) return PartStream_1;
+	hasRequiredPartStream = 1;
+
+	const inherits = require$$1$1.inherits;
+	const ReadableStream = require$$0$1.Readable;
+
+	function PartStream (opts) {
+	  ReadableStream.call(this, opts);
+	}
+	inherits(PartStream, ReadableStream);
+
+	PartStream.prototype._read = function (n) {};
+
+	PartStream_1 = PartStream;
+	return PartStream_1;
+}
+
+var getLimit;
+var hasRequiredGetLimit;
+
+function requireGetLimit () {
+	if (hasRequiredGetLimit) return getLimit;
+	hasRequiredGetLimit = 1;
+
+	getLimit = function getLimit (limits, name, defaultLimit) {
+	  if (
+	    !limits ||
+	    limits[name] === undefined ||
+	    limits[name] === null
+	  ) { return defaultLimit }
+
+	  if (
+	    typeof limits[name] !== 'number' ||
+	    isNaN(limits[name])
+	  ) { throw new TypeError('Limit ' + name + ' is not a valid number') }
+
+	  return limits[name]
+	};
+	return getLimit;
+}
+
+var HeaderParser_1;
+var hasRequiredHeaderParser;
+
+function requireHeaderParser () {
+	if (hasRequiredHeaderParser) return HeaderParser_1;
+	hasRequiredHeaderParser = 1;
+
+	const EventEmitter = require$$0.EventEmitter;
+	const inherits = require$$1$1.inherits;
+	const getLimit = requireGetLimit();
+
+	const StreamSearch = requireSbmh();
+
+	const B_DCRLF = Buffer.from('\r\n\r\n');
+	const RE_CRLF = /\r\n/g;
+	const RE_HDR = /^([^:]+):[ \t]?([\x00-\xFF]+)?$/; // eslint-disable-line no-control-regex
+
+	function HeaderParser (cfg) {
+	  EventEmitter.call(this);
+
+	  cfg = cfg || {};
+	  const self = this;
+	  this.nread = 0;
+	  this.maxed = false;
+	  this.npairs = 0;
+	  this.maxHeaderPairs = getLimit(cfg, 'maxHeaderPairs', 2000);
+	  this.maxHeaderSize = getLimit(cfg, 'maxHeaderSize', 80 * 1024);
+	  this.buffer = '';
+	  this.header = {};
+	  this.finished = false;
+	  this.ss = new StreamSearch(B_DCRLF);
+	  this.ss.on('info', function (isMatch, data, start, end) {
+	    if (data && !self.maxed) {
+	      if (self.nread + end - start >= self.maxHeaderSize) {
+	        end = self.maxHeaderSize - self.nread + start;
+	        self.nread = self.maxHeaderSize;
+	        self.maxed = true;
+	      } else { self.nread += (end - start); }
+
+	      self.buffer += data.toString('binary', start, end);
+	    }
+	    if (isMatch) { self._finish(); }
+	  });
+	}
+	inherits(HeaderParser, EventEmitter);
+
+	HeaderParser.prototype.push = function (data) {
+	  const r = this.ss.push(data);
+	  if (this.finished) { return r }
+	};
+
+	HeaderParser.prototype.reset = function () {
+	  this.finished = false;
+	  this.buffer = '';
+	  this.header = {};
+	  this.ss.reset();
+	};
+
+	HeaderParser.prototype._finish = function () {
+	  if (this.buffer) { this._parseHeader(); }
+	  this.ss.matches = this.ss.maxMatches;
+	  const header = this.header;
+	  this.header = {};
+	  this.buffer = '';
+	  this.finished = true;
+	  this.nread = this.npairs = 0;
+	  this.maxed = false;
+	  this.emit('header', header);
+	};
+
+	HeaderParser.prototype._parseHeader = function () {
+	  if (this.npairs === this.maxHeaderPairs) { return }
+
+	  const lines = this.buffer.split(RE_CRLF);
+	  const len = lines.length;
+	  let m, h;
+
+	  for (var i = 0; i < len; ++i) { // eslint-disable-line no-var
+	    if (lines[i].length === 0) { continue }
+	    if (lines[i][0] === '\t' || lines[i][0] === ' ') {
+	      // folded header content
+	      // RFC2822 says to just remove the CRLF and not the whitespace following
+	      // it, so we follow the RFC and include the leading whitespace ...
+	      if (h) {
+	        this.header[h][this.header[h].length - 1] += lines[i];
+	        continue
+	      }
+	    }
+
+	    const posColon = lines[i].indexOf(':');
+	    if (
+	      posColon === -1 ||
+	      posColon === 0
+	    ) {
+	      return
+	    }
+	    m = RE_HDR.exec(lines[i]);
+	    h = m[1].toLowerCase();
+	    this.header[h] = this.header[h] || [];
+	    this.header[h].push((m[2] || ''));
+	    if (++this.npairs === this.maxHeaderPairs) { break }
+	  }
+	};
+
+	HeaderParser_1 = HeaderParser;
+	return HeaderParser_1;
+}
+
+var Dicer_1;
+var hasRequiredDicer;
+
+function requireDicer () {
+	if (hasRequiredDicer) return Dicer_1;
+	hasRequiredDicer = 1;
+
+	const WritableStream = require$$0$1.Writable;
+	const inherits = require$$1$1.inherits;
+
+	const StreamSearch = requireSbmh();
+
+	const PartStream = requirePartStream();
+	const HeaderParser = requireHeaderParser();
+
+	const DASH = 45;
+	const B_ONEDASH = Buffer.from('-');
+	const B_CRLF = Buffer.from('\r\n');
+	const EMPTY_FN = function () {};
+
+	function Dicer (cfg) {
+	  if (!(this instanceof Dicer)) { return new Dicer(cfg) }
+	  WritableStream.call(this, cfg);
+
+	  if (!cfg || (!cfg.headerFirst && typeof cfg.boundary !== 'string')) { throw new TypeError('Boundary required') }
+
+	  if (typeof cfg.boundary === 'string') { this.setBoundary(cfg.boundary); } else { this._bparser = undefined; }
+
+	  this._headerFirst = cfg.headerFirst;
+
+	  this._dashes = 0;
+	  this._parts = 0;
+	  this._finished = false;
+	  this._realFinish = false;
+	  this._isPreamble = true;
+	  this._justMatched = false;
+	  this._firstWrite = true;
+	  this._inHeader = true;
+	  this._part = undefined;
+	  this._cb = undefined;
+	  this._ignoreData = false;
+	  this._partOpts = { highWaterMark: cfg.partHwm };
+	  this._pause = false;
+
+	  const self = this;
+	  this._hparser = new HeaderParser(cfg);
+	  this._hparser.on('header', function (header) {
+	    self._inHeader = false;
+	    self._part.emit('header', header);
+	  });
+	}
+	inherits(Dicer, WritableStream);
+
+	Dicer.prototype.emit = function (ev) {
+	  if (ev === 'finish' && !this._realFinish) {
+	    if (!this._finished) {
+	      const self = this;
+	      process.nextTick(function () {
+	        self.emit('error', new Error('Unexpected end of multipart data'));
+	        if (self._part && !self._ignoreData) {
+	          const type = (self._isPreamble ? 'Preamble' : 'Part');
+	          self._part.emit('error', new Error(type + ' terminated early due to unexpected end of multipart data'));
+	          self._part.push(null);
+	          process.nextTick(function () {
+	            self._realFinish = true;
+	            self.emit('finish');
+	            self._realFinish = false;
+	          });
+	          return
+	        }
+	        self._realFinish = true;
+	        self.emit('finish');
+	        self._realFinish = false;
+	      });
+	    }
+	  } else { WritableStream.prototype.emit.apply(this, arguments); }
+	};
+
+	Dicer.prototype._write = function (data, encoding, cb) {
+	  // ignore unexpected data (e.g. extra trailer data after finished)
+	  if (!this._hparser && !this._bparser) { return cb() }
+
+	  if (this._headerFirst && this._isPreamble) {
+	    if (!this._part) {
+	      this._part = new PartStream(this._partOpts);
+	      if (this.listenerCount('preamble') !== 0) { this.emit('preamble', this._part); } else { this._ignore(); }
+	    }
+	    const r = this._hparser.push(data);
+	    if (!this._inHeader && r !== undefined && r < data.length) { data = data.slice(r); } else { return cb() }
+	  }
+
+	  // allows for "easier" testing
+	  if (this._firstWrite) {
+	    this._bparser.push(B_CRLF);
+	    this._firstWrite = false;
+	  }
+
+	  this._bparser.push(data);
+
+	  if (this._pause) { this._cb = cb; } else { cb(); }
+	};
+
+	Dicer.prototype.reset = function () {
+	  this._part = undefined;
+	  this._bparser = undefined;
+	  this._hparser = undefined;
+	};
+
+	Dicer.prototype.setBoundary = function (boundary) {
+	  const self = this;
+	  this._bparser = new StreamSearch('\r\n--' + boundary);
+	  this._bparser.on('info', function (isMatch, data, start, end) {
+	    self._oninfo(isMatch, data, start, end);
+	  });
+	};
+
+	Dicer.prototype._ignore = function () {
+	  if (this._part && !this._ignoreData) {
+	    this._ignoreData = true;
+	    this._part.on('error', EMPTY_FN);
+	    // we must perform some kind of read on the stream even though we are
+	    // ignoring the data, otherwise node's Readable stream will not emit 'end'
+	    // after pushing null to the stream
+	    this._part.resume();
+	  }
+	};
+
+	Dicer.prototype._oninfo = function (isMatch, data, start, end) {
+	  let buf; const self = this; let i = 0; let r; let shouldWriteMore = true;
+
+	  if (!this._part && this._justMatched && data) {
+	    while (this._dashes < 2 && (start + i) < end) {
+	      if (data[start + i] === DASH) {
+	        ++i;
+	        ++this._dashes;
+	      } else {
+	        if (this._dashes) { buf = B_ONEDASH; }
+	        this._dashes = 0;
+	        break
+	      }
+	    }
+	    if (this._dashes === 2) {
+	      if ((start + i) < end && this.listenerCount('trailer') !== 0) { this.emit('trailer', data.slice(start + i, end)); }
+	      this.reset();
+	      this._finished = true;
+	      // no more parts will be added
+	      if (self._parts === 0) {
+	        self._realFinish = true;
+	        self.emit('finish');
+	        self._realFinish = false;
+	      }
+	    }
+	    if (this._dashes) { return }
+	  }
+	  if (this._justMatched) { this._justMatched = false; }
+	  if (!this._part) {
+	    this._part = new PartStream(this._partOpts);
+	    this._part._read = function (n) {
+	      self._unpause();
+	    };
+	    if (this._isPreamble && this.listenerCount('preamble') !== 0) {
+	      this.emit('preamble', this._part);
+	    } else if (this._isPreamble !== true && this.listenerCount('part') !== 0) {
+	      this.emit('part', this._part);
+	    } else {
+	      this._ignore();
+	    }
+	    if (!this._isPreamble) { this._inHeader = true; }
+	  }
+	  if (data && start < end && !this._ignoreData) {
+	    if (this._isPreamble || !this._inHeader) {
+	      if (buf) { shouldWriteMore = this._part.push(buf); }
+	      shouldWriteMore = this._part.push(data.slice(start, end));
+	      if (!shouldWriteMore) { this._pause = true; }
+	    } else if (!this._isPreamble && this._inHeader) {
+	      if (buf) { this._hparser.push(buf); }
+	      r = this._hparser.push(data.slice(start, end));
+	      if (!this._inHeader && r !== undefined && r < end) { this._oninfo(false, data, start + r, end); }
+	    }
+	  }
+	  if (isMatch) {
+	    this._hparser.reset();
+	    if (this._isPreamble) { this._isPreamble = false; } else {
+	      if (start !== end) {
+	        ++this._parts;
+	        this._part.on('end', function () {
+	          if (--self._parts === 0) {
+	            if (self._finished) {
+	              self._realFinish = true;
+	              self.emit('finish');
+	              self._realFinish = false;
+	            } else {
+	              self._unpause();
+	            }
+	          }
+	        });
+	      }
+	    }
+	    this._part.push(null);
+	    this._part = undefined;
+	    this._ignoreData = false;
+	    this._justMatched = true;
+	    this._dashes = 0;
+	  }
+	};
+
+	Dicer.prototype._unpause = function () {
+	  if (!this._pause) { return }
+
+	  this._pause = false;
+	  if (this._cb) {
+	    const cb = this._cb;
+	    this._cb = undefined;
+	    cb();
+	  }
+	};
+
+	Dicer_1 = Dicer;
+	return Dicer_1;
+}
+
+var decodeText_1;
+var hasRequiredDecodeText;
+
+function requireDecodeText () {
+	if (hasRequiredDecodeText) return decodeText_1;
+	hasRequiredDecodeText = 1;
+
+	// Node has always utf-8
+	const utf8Decoder = new TextDecoder('utf-8');
+	const textDecoders = new Map([
+	  ['utf-8', utf8Decoder],
+	  ['utf8', utf8Decoder]
+	]);
+
+	function getDecoder (charset) {
+	  let lc;
+	  while (true) {
+	    switch (charset) {
+	      case 'utf-8':
+	      case 'utf8':
+	        return decoders.utf8
+	      case 'latin1':
+	      case 'ascii': // TODO: Make these a separate, strict decoder?
+	      case 'us-ascii':
+	      case 'iso-8859-1':
+	      case 'iso8859-1':
+	      case 'iso88591':
+	      case 'iso_8859-1':
+	      case 'windows-1252':
+	      case 'iso_8859-1:1987':
+	      case 'cp1252':
+	      case 'x-cp1252':
+	        return decoders.latin1
+	      case 'utf16le':
+	      case 'utf-16le':
+	      case 'ucs2':
+	      case 'ucs-2':
+	        return decoders.utf16le
+	      case 'base64':
+	        return decoders.base64
+	      default:
+	        if (lc === undefined) {
+	          lc = true;
+	          charset = charset.toLowerCase();
+	          continue
+	        }
+	        return decoders.other.bind(charset)
+	    }
+	  }
+	}
+
+	const decoders = {
+	  utf8: (data, sourceEncoding) => {
+	    if (data.length === 0) {
+	      return ''
+	    }
+	    if (typeof data === 'string') {
+	      data = Buffer.from(data, sourceEncoding);
+	    }
+	    return data.utf8Slice(0, data.length)
+	  },
+
+	  latin1: (data, sourceEncoding) => {
+	    if (data.length === 0) {
+	      return ''
+	    }
+	    if (typeof data === 'string') {
+	      return data
+	    }
+	    return data.latin1Slice(0, data.length)
+	  },
+
+	  utf16le: (data, sourceEncoding) => {
+	    if (data.length === 0) {
+	      return ''
+	    }
+	    if (typeof data === 'string') {
+	      data = Buffer.from(data, sourceEncoding);
+	    }
+	    return data.ucs2Slice(0, data.length)
+	  },
+
+	  base64: (data, sourceEncoding) => {
+	    if (data.length === 0) {
+	      return ''
+	    }
+	    if (typeof data === 'string') {
+	      data = Buffer.from(data, sourceEncoding);
+	    }
+	    return data.base64Slice(0, data.length)
+	  },
+
+	  other: (data, sourceEncoding) => {
+	    if (data.length === 0) {
+	      return ''
+	    }
+	    if (typeof data === 'string') {
+	      data = Buffer.from(data, sourceEncoding);
+	    }
+
+	    if (textDecoders.has(this.toString())) {
+	      try {
+	        return textDecoders.get(this).decode(data)
+	      } catch {}
+	    }
+	    return typeof data === 'string'
+	      ? data
+	      : data.toString()
+	  }
+	};
+
+	function decodeText (text, sourceEncoding, destEncoding) {
+	  if (text) {
+	    return getDecoder(destEncoding)(text, sourceEncoding)
+	  }
+	  return text
+	}
+
+	decodeText_1 = decodeText;
+	return decodeText_1;
+}
+
+/* eslint-disable object-property-newline */
+
+var parseParams_1;
+var hasRequiredParseParams;
+
+function requireParseParams () {
+	if (hasRequiredParseParams) return parseParams_1;
+	hasRequiredParseParams = 1;
+
+	const decodeText = requireDecodeText();
+
+	const RE_ENCODED = /%[a-fA-F0-9][a-fA-F0-9]/g;
+
+	const EncodedLookup = {
+	  '%00': '\x00', '%01': '\x01', '%02': '\x02', '%03': '\x03', '%04': '\x04',
+	  '%05': '\x05', '%06': '\x06', '%07': '\x07', '%08': '\x08', '%09': '\x09',
+	  '%0a': '\x0a', '%0A': '\x0a', '%0b': '\x0b', '%0B': '\x0b', '%0c': '\x0c',
+	  '%0C': '\x0c', '%0d': '\x0d', '%0D': '\x0d', '%0e': '\x0e', '%0E': '\x0e',
+	  '%0f': '\x0f', '%0F': '\x0f', '%10': '\x10', '%11': '\x11', '%12': '\x12',
+	  '%13': '\x13', '%14': '\x14', '%15': '\x15', '%16': '\x16', '%17': '\x17',
+	  '%18': '\x18', '%19': '\x19', '%1a': '\x1a', '%1A': '\x1a', '%1b': '\x1b',
+	  '%1B': '\x1b', '%1c': '\x1c', '%1C': '\x1c', '%1d': '\x1d', '%1D': '\x1d',
+	  '%1e': '\x1e', '%1E': '\x1e', '%1f': '\x1f', '%1F': '\x1f', '%20': '\x20',
+	  '%21': '\x21', '%22': '\x22', '%23': '\x23', '%24': '\x24', '%25': '\x25',
+	  '%26': '\x26', '%27': '\x27', '%28': '\x28', '%29': '\x29', '%2a': '\x2a',
+	  '%2A': '\x2a', '%2b': '\x2b', '%2B': '\x2b', '%2c': '\x2c', '%2C': '\x2c',
+	  '%2d': '\x2d', '%2D': '\x2d', '%2e': '\x2e', '%2E': '\x2e', '%2f': '\x2f',
+	  '%2F': '\x2f', '%30': '\x30', '%31': '\x31', '%32': '\x32', '%33': '\x33',
+	  '%34': '\x34', '%35': '\x35', '%36': '\x36', '%37': '\x37', '%38': '\x38',
+	  '%39': '\x39', '%3a': '\x3a', '%3A': '\x3a', '%3b': '\x3b', '%3B': '\x3b',
+	  '%3c': '\x3c', '%3C': '\x3c', '%3d': '\x3d', '%3D': '\x3d', '%3e': '\x3e',
+	  '%3E': '\x3e', '%3f': '\x3f', '%3F': '\x3f', '%40': '\x40', '%41': '\x41',
+	  '%42': '\x42', '%43': '\x43', '%44': '\x44', '%45': '\x45', '%46': '\x46',
+	  '%47': '\x47', '%48': '\x48', '%49': '\x49', '%4a': '\x4a', '%4A': '\x4a',
+	  '%4b': '\x4b', '%4B': '\x4b', '%4c': '\x4c', '%4C': '\x4c', '%4d': '\x4d',
+	  '%4D': '\x4d', '%4e': '\x4e', '%4E': '\x4e', '%4f': '\x4f', '%4F': '\x4f',
+	  '%50': '\x50', '%51': '\x51', '%52': '\x52', '%53': '\x53', '%54': '\x54',
+	  '%55': '\x55', '%56': '\x56', '%57': '\x57', '%58': '\x58', '%59': '\x59',
+	  '%5a': '\x5a', '%5A': '\x5a', '%5b': '\x5b', '%5B': '\x5b', '%5c': '\x5c',
+	  '%5C': '\x5c', '%5d': '\x5d', '%5D': '\x5d', '%5e': '\x5e', '%5E': '\x5e',
+	  '%5f': '\x5f', '%5F': '\x5f', '%60': '\x60', '%61': '\x61', '%62': '\x62',
+	  '%63': '\x63', '%64': '\x64', '%65': '\x65', '%66': '\x66', '%67': '\x67',
+	  '%68': '\x68', '%69': '\x69', '%6a': '\x6a', '%6A': '\x6a', '%6b': '\x6b',
+	  '%6B': '\x6b', '%6c': '\x6c', '%6C': '\x6c', '%6d': '\x6d', '%6D': '\x6d',
+	  '%6e': '\x6e', '%6E': '\x6e', '%6f': '\x6f', '%6F': '\x6f', '%70': '\x70',
+	  '%71': '\x71', '%72': '\x72', '%73': '\x73', '%74': '\x74', '%75': '\x75',
+	  '%76': '\x76', '%77': '\x77', '%78': '\x78', '%79': '\x79', '%7a': '\x7a',
+	  '%7A': '\x7a', '%7b': '\x7b', '%7B': '\x7b', '%7c': '\x7c', '%7C': '\x7c',
+	  '%7d': '\x7d', '%7D': '\x7d', '%7e': '\x7e', '%7E': '\x7e', '%7f': '\x7f',
+	  '%7F': '\x7f', '%80': '\x80', '%81': '\x81', '%82': '\x82', '%83': '\x83',
+	  '%84': '\x84', '%85': '\x85', '%86': '\x86', '%87': '\x87', '%88': '\x88',
+	  '%89': '\x89', '%8a': '\x8a', '%8A': '\x8a', '%8b': '\x8b', '%8B': '\x8b',
+	  '%8c': '\x8c', '%8C': '\x8c', '%8d': '\x8d', '%8D': '\x8d', '%8e': '\x8e',
+	  '%8E': '\x8e', '%8f': '\x8f', '%8F': '\x8f', '%90': '\x90', '%91': '\x91',
+	  '%92': '\x92', '%93': '\x93', '%94': '\x94', '%95': '\x95', '%96': '\x96',
+	  '%97': '\x97', '%98': '\x98', '%99': '\x99', '%9a': '\x9a', '%9A': '\x9a',
+	  '%9b': '\x9b', '%9B': '\x9b', '%9c': '\x9c', '%9C': '\x9c', '%9d': '\x9d',
+	  '%9D': '\x9d', '%9e': '\x9e', '%9E': '\x9e', '%9f': '\x9f', '%9F': '\x9f',
+	  '%a0': '\xa0', '%A0': '\xa0', '%a1': '\xa1', '%A1': '\xa1', '%a2': '\xa2',
+	  '%A2': '\xa2', '%a3': '\xa3', '%A3': '\xa3', '%a4': '\xa4', '%A4': '\xa4',
+	  '%a5': '\xa5', '%A5': '\xa5', '%a6': '\xa6', '%A6': '\xa6', '%a7': '\xa7',
+	  '%A7': '\xa7', '%a8': '\xa8', '%A8': '\xa8', '%a9': '\xa9', '%A9': '\xa9',
+	  '%aa': '\xaa', '%Aa': '\xaa', '%aA': '\xaa', '%AA': '\xaa', '%ab': '\xab',
+	  '%Ab': '\xab', '%aB': '\xab', '%AB': '\xab', '%ac': '\xac', '%Ac': '\xac',
+	  '%aC': '\xac', '%AC': '\xac', '%ad': '\xad', '%Ad': '\xad', '%aD': '\xad',
+	  '%AD': '\xad', '%ae': '\xae', '%Ae': '\xae', '%aE': '\xae', '%AE': '\xae',
+	  '%af': '\xaf', '%Af': '\xaf', '%aF': '\xaf', '%AF': '\xaf', '%b0': '\xb0',
+	  '%B0': '\xb0', '%b1': '\xb1', '%B1': '\xb1', '%b2': '\xb2', '%B2': '\xb2',
+	  '%b3': '\xb3', '%B3': '\xb3', '%b4': '\xb4', '%B4': '\xb4', '%b5': '\xb5',
+	  '%B5': '\xb5', '%b6': '\xb6', '%B6': '\xb6', '%b7': '\xb7', '%B7': '\xb7',
+	  '%b8': '\xb8', '%B8': '\xb8', '%b9': '\xb9', '%B9': '\xb9', '%ba': '\xba',
+	  '%Ba': '\xba', '%bA': '\xba', '%BA': '\xba', '%bb': '\xbb', '%Bb': '\xbb',
+	  '%bB': '\xbb', '%BB': '\xbb', '%bc': '\xbc', '%Bc': '\xbc', '%bC': '\xbc',
+	  '%BC': '\xbc', '%bd': '\xbd', '%Bd': '\xbd', '%bD': '\xbd', '%BD': '\xbd',
+	  '%be': '\xbe', '%Be': '\xbe', '%bE': '\xbe', '%BE': '\xbe', '%bf': '\xbf',
+	  '%Bf': '\xbf', '%bF': '\xbf', '%BF': '\xbf', '%c0': '\xc0', '%C0': '\xc0',
+	  '%c1': '\xc1', '%C1': '\xc1', '%c2': '\xc2', '%C2': '\xc2', '%c3': '\xc3',
+	  '%C3': '\xc3', '%c4': '\xc4', '%C4': '\xc4', '%c5': '\xc5', '%C5': '\xc5',
+	  '%c6': '\xc6', '%C6': '\xc6', '%c7': '\xc7', '%C7': '\xc7', '%c8': '\xc8',
+	  '%C8': '\xc8', '%c9': '\xc9', '%C9': '\xc9', '%ca': '\xca', '%Ca': '\xca',
+	  '%cA': '\xca', '%CA': '\xca', '%cb': '\xcb', '%Cb': '\xcb', '%cB': '\xcb',
+	  '%CB': '\xcb', '%cc': '\xcc', '%Cc': '\xcc', '%cC': '\xcc', '%CC': '\xcc',
+	  '%cd': '\xcd', '%Cd': '\xcd', '%cD': '\xcd', '%CD': '\xcd', '%ce': '\xce',
+	  '%Ce': '\xce', '%cE': '\xce', '%CE': '\xce', '%cf': '\xcf', '%Cf': '\xcf',
+	  '%cF': '\xcf', '%CF': '\xcf', '%d0': '\xd0', '%D0': '\xd0', '%d1': '\xd1',
+	  '%D1': '\xd1', '%d2': '\xd2', '%D2': '\xd2', '%d3': '\xd3', '%D3': '\xd3',
+	  '%d4': '\xd4', '%D4': '\xd4', '%d5': '\xd5', '%D5': '\xd5', '%d6': '\xd6',
+	  '%D6': '\xd6', '%d7': '\xd7', '%D7': '\xd7', '%d8': '\xd8', '%D8': '\xd8',
+	  '%d9': '\xd9', '%D9': '\xd9', '%da': '\xda', '%Da': '\xda', '%dA': '\xda',
+	  '%DA': '\xda', '%db': '\xdb', '%Db': '\xdb', '%dB': '\xdb', '%DB': '\xdb',
+	  '%dc': '\xdc', '%Dc': '\xdc', '%dC': '\xdc', '%DC': '\xdc', '%dd': '\xdd',
+	  '%Dd': '\xdd', '%dD': '\xdd', '%DD': '\xdd', '%de': '\xde', '%De': '\xde',
+	  '%dE': '\xde', '%DE': '\xde', '%df': '\xdf', '%Df': '\xdf', '%dF': '\xdf',
+	  '%DF': '\xdf', '%e0': '\xe0', '%E0': '\xe0', '%e1': '\xe1', '%E1': '\xe1',
+	  '%e2': '\xe2', '%E2': '\xe2', '%e3': '\xe3', '%E3': '\xe3', '%e4': '\xe4',
+	  '%E4': '\xe4', '%e5': '\xe5', '%E5': '\xe5', '%e6': '\xe6', '%E6': '\xe6',
+	  '%e7': '\xe7', '%E7': '\xe7', '%e8': '\xe8', '%E8': '\xe8', '%e9': '\xe9',
+	  '%E9': '\xe9', '%ea': '\xea', '%Ea': '\xea', '%eA': '\xea', '%EA': '\xea',
+	  '%eb': '\xeb', '%Eb': '\xeb', '%eB': '\xeb', '%EB': '\xeb', '%ec': '\xec',
+	  '%Ec': '\xec', '%eC': '\xec', '%EC': '\xec', '%ed': '\xed', '%Ed': '\xed',
+	  '%eD': '\xed', '%ED': '\xed', '%ee': '\xee', '%Ee': '\xee', '%eE': '\xee',
+	  '%EE': '\xee', '%ef': '\xef', '%Ef': '\xef', '%eF': '\xef', '%EF': '\xef',
+	  '%f0': '\xf0', '%F0': '\xf0', '%f1': '\xf1', '%F1': '\xf1', '%f2': '\xf2',
+	  '%F2': '\xf2', '%f3': '\xf3', '%F3': '\xf3', '%f4': '\xf4', '%F4': '\xf4',
+	  '%f5': '\xf5', '%F5': '\xf5', '%f6': '\xf6', '%F6': '\xf6', '%f7': '\xf7',
+	  '%F7': '\xf7', '%f8': '\xf8', '%F8': '\xf8', '%f9': '\xf9', '%F9': '\xf9',
+	  '%fa': '\xfa', '%Fa': '\xfa', '%fA': '\xfa', '%FA': '\xfa', '%fb': '\xfb',
+	  '%Fb': '\xfb', '%fB': '\xfb', '%FB': '\xfb', '%fc': '\xfc', '%Fc': '\xfc',
+	  '%fC': '\xfc', '%FC': '\xfc', '%fd': '\xfd', '%Fd': '\xfd', '%fD': '\xfd',
+	  '%FD': '\xfd', '%fe': '\xfe', '%Fe': '\xfe', '%fE': '\xfe', '%FE': '\xfe',
+	  '%ff': '\xff', '%Ff': '\xff', '%fF': '\xff', '%FF': '\xff'
+	};
+
+	function encodedReplacer (match) {
+	  return EncodedLookup[match]
+	}
+
+	const STATE_KEY = 0;
+	const STATE_VALUE = 1;
+	const STATE_CHARSET = 2;
+	const STATE_LANG = 3;
+
+	function parseParams (str) {
+	  const res = [];
+	  let state = STATE_KEY;
+	  let charset = '';
+	  let inquote = false;
+	  let escaping = false;
+	  let p = 0;
+	  let tmp = '';
+	  const len = str.length;
+
+	  for (var i = 0; i < len; ++i) { // eslint-disable-line no-var
+	    const char = str[i];
+	    if (char === '\\' && inquote) {
+	      if (escaping) { escaping = false; } else {
+	        escaping = true;
+	        continue
+	      }
+	    } else if (char === '"') {
+	      if (!escaping) {
+	        if (inquote) {
+	          inquote = false;
+	          state = STATE_KEY;
+	        } else { inquote = true; }
+	        continue
+	      } else { escaping = false; }
+	    } else {
+	      if (escaping && inquote) { tmp += '\\'; }
+	      escaping = false;
+	      if ((state === STATE_CHARSET || state === STATE_LANG) && char === "'") {
+	        if (state === STATE_CHARSET) {
+	          state = STATE_LANG;
+	          charset = tmp.substring(1);
+	        } else { state = STATE_VALUE; }
+	        tmp = '';
+	        continue
+	      } else if (state === STATE_KEY &&
+	        (char === '*' || char === '=') &&
+	        res.length) {
+	        state = char === '*'
+	          ? STATE_CHARSET
+	          : STATE_VALUE;
+	        res[p] = [tmp, undefined];
+	        tmp = '';
+	        continue
+	      } else if (!inquote && char === ';') {
+	        state = STATE_KEY;
+	        if (charset) {
+	          if (tmp.length) {
+	            tmp = decodeText(tmp.replace(RE_ENCODED, encodedReplacer),
+	              'binary',
+	              charset);
+	          }
+	          charset = '';
+	        } else if (tmp.length) {
+	          tmp = decodeText(tmp, 'binary', 'utf8');
+	        }
+	        if (res[p] === undefined) { res[p] = tmp; } else { res[p][1] = tmp; }
+	        tmp = '';
+	        ++p;
+	        continue
+	      } else if (!inquote && (char === ' ' || char === '\t')) { continue }
+	    }
+	    tmp += char;
+	  }
+	  if (charset && tmp.length) {
+	    tmp = decodeText(tmp.replace(RE_ENCODED, encodedReplacer),
+	      'binary',
+	      charset);
+	  } else if (tmp) {
+	    tmp = decodeText(tmp, 'binary', 'utf8');
+	  }
+
+	  if (res[p] === undefined) {
+	    if (tmp) { res[p] = tmp; }
+	  } else { res[p][1] = tmp; }
+
+	  return res
+	}
+
+	parseParams_1 = parseParams;
+	return parseParams_1;
+}
+
+var basename;
+var hasRequiredBasename;
+
+function requireBasename () {
+	if (hasRequiredBasename) return basename;
+	hasRequiredBasename = 1;
+
+	basename = function basename (path) {
+	  if (typeof path !== 'string') { return '' }
+	  for (var i = path.length - 1; i >= 0; --i) { // eslint-disable-line no-var
+	    switch (path.charCodeAt(i)) {
+	      case 0x2F: // '/'
+	      case 0x5C: // '\'
+	        path = path.slice(i + 1);
+	        return (path === '..' || path === '.' ? '' : path)
+	    }
+	  }
+	  return (path === '..' || path === '.' ? '' : path)
+	};
+	return basename;
+}
+
+var multipart;
+var hasRequiredMultipart;
+
+function requireMultipart () {
+	if (hasRequiredMultipart) return multipart;
+	hasRequiredMultipart = 1;
+
+	// TODO:
+	//  * support 1 nested multipart level
+	//    (see second multipart example here:
+	//     http://www.w3.org/TR/html401/interact/forms.html#didx-multipartform-data)
+	//  * support limits.fieldNameSize
+	//     -- this will require modifications to utils.parseParams
+
+	const { Readable } = require$$0$1;
+	const { inherits } = require$$1$1;
+
+	const Dicer = requireDicer();
+
+	const parseParams = requireParseParams();
+	const decodeText = requireDecodeText();
+	const basename = requireBasename();
+	const getLimit = requireGetLimit();
+
+	const RE_BOUNDARY = /^boundary$/i;
+	const RE_FIELD = /^form-data$/i;
+	const RE_CHARSET = /^charset$/i;
+	const RE_FILENAME = /^filename$/i;
+	const RE_NAME = /^name$/i;
+
+	Multipart.detect = /^multipart\/form-data/i;
+	function Multipart (boy, cfg) {
+	  let i;
+	  let len;
+	  const self = this;
+	  let boundary;
+	  const limits = cfg.limits;
+	  const isPartAFile = cfg.isPartAFile || ((fieldName, contentType, fileName) => (contentType === 'application/octet-stream' || fileName !== undefined));
+	  const parsedConType = cfg.parsedConType || [];
+	  const defCharset = cfg.defCharset || 'utf8';
+	  const preservePath = cfg.preservePath;
+	  const fileOpts = { highWaterMark: cfg.fileHwm };
+
+	  for (i = 0, len = parsedConType.length; i < len; ++i) {
+	    if (Array.isArray(parsedConType[i]) &&
+	      RE_BOUNDARY.test(parsedConType[i][0])) {
+	      boundary = parsedConType[i][1];
+	      break
+	    }
+	  }
+
+	  function checkFinished () {
+	    if (nends === 0 && finished && !boy._done) {
+	      finished = false;
+	      self.end();
+	    }
+	  }
+
+	  if (typeof boundary !== 'string') { throw new Error('Multipart: Boundary not found') }
+
+	  const fieldSizeLimit = getLimit(limits, 'fieldSize', 1 * 1024 * 1024);
+	  const fileSizeLimit = getLimit(limits, 'fileSize', Infinity);
+	  const filesLimit = getLimit(limits, 'files', Infinity);
+	  const fieldsLimit = getLimit(limits, 'fields', Infinity);
+	  const partsLimit = getLimit(limits, 'parts', Infinity);
+	  const headerPairsLimit = getLimit(limits, 'headerPairs', 2000);
+	  const headerSizeLimit = getLimit(limits, 'headerSize', 80 * 1024);
+
+	  let nfiles = 0;
+	  let nfields = 0;
+	  let nends = 0;
+	  let curFile;
+	  let curField;
+	  let finished = false;
+
+	  this._needDrain = false;
+	  this._pause = false;
+	  this._cb = undefined;
+	  this._nparts = 0;
+	  this._boy = boy;
+
+	  const parserCfg = {
+	    boundary,
+	    maxHeaderPairs: headerPairsLimit,
+	    maxHeaderSize: headerSizeLimit,
+	    partHwm: fileOpts.highWaterMark,
+	    highWaterMark: cfg.highWaterMark
+	  };
+
+	  this.parser = new Dicer(parserCfg);
+	  this.parser.on('drain', function () {
+	    self._needDrain = false;
+	    if (self._cb && !self._pause) {
+	      const cb = self._cb;
+	      self._cb = undefined;
+	      cb();
+	    }
+	  }).on('part', function onPart (part) {
+	    if (++self._nparts > partsLimit) {
+	      self.parser.removeListener('part', onPart);
+	      self.parser.on('part', skipPart);
+	      boy.hitPartsLimit = true;
+	      boy.emit('partsLimit');
+	      return skipPart(part)
+	    }
+
+	    // hack because streams2 _always_ doesn't emit 'end' until nextTick, so let
+	    // us emit 'end' early since we know the part has ended if we are already
+	    // seeing the next part
+	    if (curField) {
+	      const field = curField;
+	      field.emit('end');
+	      field.removeAllListeners('end');
+	    }
+
+	    part.on('header', function (header) {
+	      let contype;
+	      let fieldname;
+	      let parsed;
+	      let charset;
+	      let encoding;
+	      let filename;
+	      let nsize = 0;
+
+	      if (header['content-type']) {
+	        parsed = parseParams(header['content-type'][0]);
+	        if (parsed[0]) {
+	          contype = parsed[0].toLowerCase();
+	          for (i = 0, len = parsed.length; i < len; ++i) {
+	            if (RE_CHARSET.test(parsed[i][0])) {
+	              charset = parsed[i][1].toLowerCase();
+	              break
+	            }
+	          }
+	        }
+	      }
+
+	      if (contype === undefined) { contype = 'text/plain'; }
+	      if (charset === undefined) { charset = defCharset; }
+
+	      if (header['content-disposition']) {
+	        parsed = parseParams(header['content-disposition'][0]);
+	        if (!RE_FIELD.test(parsed[0])) { return skipPart(part) }
+	        for (i = 0, len = parsed.length; i < len; ++i) {
+	          if (RE_NAME.test(parsed[i][0])) {
+	            fieldname = parsed[i][1];
+	          } else if (RE_FILENAME.test(parsed[i][0])) {
+	            filename = parsed[i][1];
+	            if (!preservePath) { filename = basename(filename); }
+	          }
+	        }
+	      } else { return skipPart(part) }
+
+	      if (header['content-transfer-encoding']) { encoding = header['content-transfer-encoding'][0].toLowerCase(); } else { encoding = '7bit'; }
+
+	      let onData,
+	        onEnd;
+
+	      if (isPartAFile(fieldname, contype, filename)) {
+	        // file/binary field
+	        if (nfiles === filesLimit) {
+	          if (!boy.hitFilesLimit) {
+	            boy.hitFilesLimit = true;
+	            boy.emit('filesLimit');
+	          }
+	          return skipPart(part)
+	        }
+
+	        ++nfiles;
+
+	        if (boy.listenerCount('file') === 0) {
+	          self.parser._ignore();
+	          return
+	        }
+
+	        ++nends;
+	        const file = new FileStream(fileOpts);
+	        curFile = file;
+	        file.on('end', function () {
+	          --nends;
+	          self._pause = false;
+	          checkFinished();
+	          if (self._cb && !self._needDrain) {
+	            const cb = self._cb;
+	            self._cb = undefined;
+	            cb();
+	          }
+	        });
+	        file._read = function (n) {
+	          if (!self._pause) { return }
+	          self._pause = false;
+	          if (self._cb && !self._needDrain) {
+	            const cb = self._cb;
+	            self._cb = undefined;
+	            cb();
+	          }
+	        };
+	        boy.emit('file', fieldname, file, filename, encoding, contype);
+
+	        onData = function (data) {
+	          if ((nsize += data.length) > fileSizeLimit) {
+	            const extralen = fileSizeLimit - nsize + data.length;
+	            if (extralen > 0) { file.push(data.slice(0, extralen)); }
+	            file.truncated = true;
+	            file.bytesRead = fileSizeLimit;
+	            part.removeAllListeners('data');
+	            file.emit('limit');
+	            return
+	          } else if (!file.push(data)) { self._pause = true; }
+
+	          file.bytesRead = nsize;
+	        };
+
+	        onEnd = function () {
+	          curFile = undefined;
+	          file.push(null);
+	        };
+	      } else {
+	        // non-file field
+	        if (nfields === fieldsLimit) {
+	          if (!boy.hitFieldsLimit) {
+	            boy.hitFieldsLimit = true;
+	            boy.emit('fieldsLimit');
+	          }
+	          return skipPart(part)
+	        }
+
+	        ++nfields;
+	        ++nends;
+	        let buffer = '';
+	        let truncated = false;
+	        curField = part;
+
+	        onData = function (data) {
+	          if ((nsize += data.length) > fieldSizeLimit) {
+	            const extralen = (fieldSizeLimit - (nsize - data.length));
+	            buffer += data.toString('binary', 0, extralen);
+	            truncated = true;
+	            part.removeAllListeners('data');
+	          } else { buffer += data.toString('binary'); }
+	        };
+
+	        onEnd = function () {
+	          curField = undefined;
+	          if (buffer.length) { buffer = decodeText(buffer, 'binary', charset); }
+	          boy.emit('field', fieldname, buffer, false, truncated, encoding, contype);
+	          --nends;
+	          checkFinished();
+	        };
+	      }
+
+	      /* As of node@2efe4ab761666 (v0.10.29+/v0.11.14+), busboy had become
+	         broken. Streams2/streams3 is a huge black box of confusion, but
+	         somehow overriding the sync state seems to fix things again (and still
+	         seems to work for previous node versions).
+	      */
+	      part._readableState.sync = false;
+
+	      part.on('data', onData);
+	      part.on('end', onEnd);
+	    }).on('error', function (err) {
+	      if (curFile) { curFile.emit('error', err); }
+	    });
+	  }).on('error', function (err) {
+	    boy.emit('error', err);
+	  }).on('finish', function () {
+	    finished = true;
+	    checkFinished();
+	  });
+	}
+
+	Multipart.prototype.write = function (chunk, cb) {
+	  const r = this.parser.write(chunk);
+	  if (r && !this._pause) {
+	    cb();
+	  } else {
+	    this._needDrain = !r;
+	    this._cb = cb;
+	  }
+	};
+
+	Multipart.prototype.end = function () {
+	  const self = this;
+
+	  if (self.parser.writable) {
+	    self.parser.end();
+	  } else if (!self._boy._done) {
+	    process.nextTick(function () {
+	      self._boy._done = true;
+	      self._boy.emit('finish');
+	    });
+	  }
+	};
+
+	function skipPart (part) {
+	  part.resume();
+	}
+
+	function FileStream (opts) {
+	  Readable.call(this, opts);
+
+	  this.bytesRead = 0;
+
+	  this.truncated = false;
+	}
+
+	inherits(FileStream, Readable);
+
+	FileStream.prototype._read = function (n) {};
+
+	multipart = Multipart;
+	return multipart;
+}
+
+var Decoder_1;
+var hasRequiredDecoder;
+
+function requireDecoder () {
+	if (hasRequiredDecoder) return Decoder_1;
+	hasRequiredDecoder = 1;
+
+	const RE_PLUS = /\+/g;
+
+	const HEX = [
+	  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
+	  0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	  0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+	];
+
+	function Decoder () {
+	  this.buffer = undefined;
+	}
+	Decoder.prototype.write = function (str) {
+	  // Replace '+' with ' ' before decoding
+	  str = str.replace(RE_PLUS, ' ');
+	  let res = '';
+	  let i = 0; let p = 0; const len = str.length;
+	  for (; i < len; ++i) {
+	    if (this.buffer !== undefined) {
+	      if (!HEX[str.charCodeAt(i)]) {
+	        res += '%' + this.buffer;
+	        this.buffer = undefined;
+	        --i; // retry character
+	      } else {
+	        this.buffer += str[i];
+	        ++p;
+	        if (this.buffer.length === 2) {
+	          res += String.fromCharCode(parseInt(this.buffer, 16));
+	          this.buffer = undefined;
+	        }
+	      }
+	    } else if (str[i] === '%') {
+	      if (i > p) {
+	        res += str.substring(p, i);
+	        p = i;
+	      }
+	      this.buffer = '';
+	      ++p;
+	    }
+	  }
+	  if (p < len && this.buffer === undefined) { res += str.substring(p); }
+	  return res
+	};
+	Decoder.prototype.reset = function () {
+	  this.buffer = undefined;
+	};
+
+	Decoder_1 = Decoder;
+	return Decoder_1;
+}
+
+var urlencoded;
+var hasRequiredUrlencoded;
+
+function requireUrlencoded () {
+	if (hasRequiredUrlencoded) return urlencoded;
+	hasRequiredUrlencoded = 1;
+
+	const Decoder = requireDecoder();
+	const decodeText = requireDecodeText();
+	const getLimit = requireGetLimit();
+
+	const RE_CHARSET = /^charset$/i;
+
+	UrlEncoded.detect = /^application\/x-www-form-urlencoded/i;
+	function UrlEncoded (boy, cfg) {
+	  const limits = cfg.limits;
+	  const parsedConType = cfg.parsedConType;
+	  this.boy = boy;
+
+	  this.fieldSizeLimit = getLimit(limits, 'fieldSize', 1 * 1024 * 1024);
+	  this.fieldNameSizeLimit = getLimit(limits, 'fieldNameSize', 100);
+	  this.fieldsLimit = getLimit(limits, 'fields', Infinity);
+
+	  let charset;
+	  for (var i = 0, len = parsedConType.length; i < len; ++i) { // eslint-disable-line no-var
+	    if (Array.isArray(parsedConType[i]) &&
+	        RE_CHARSET.test(parsedConType[i][0])) {
+	      charset = parsedConType[i][1].toLowerCase();
+	      break
+	    }
+	  }
+
+	  if (charset === undefined) { charset = cfg.defCharset || 'utf8'; }
+
+	  this.decoder = new Decoder();
+	  this.charset = charset;
+	  this._fields = 0;
+	  this._state = 'key';
+	  this._checkingBytes = true;
+	  this._bytesKey = 0;
+	  this._bytesVal = 0;
+	  this._key = '';
+	  this._val = '';
+	  this._keyTrunc = false;
+	  this._valTrunc = false;
+	  this._hitLimit = false;
+	}
+
+	UrlEncoded.prototype.write = function (data, cb) {
+	  if (this._fields === this.fieldsLimit) {
+	    if (!this.boy.hitFieldsLimit) {
+	      this.boy.hitFieldsLimit = true;
+	      this.boy.emit('fieldsLimit');
+	    }
+	    return cb()
+	  }
+
+	  let idxeq; let idxamp; let i; let p = 0; const len = data.length;
+
+	  while (p < len) {
+	    if (this._state === 'key') {
+	      idxeq = idxamp = undefined;
+	      for (i = p; i < len; ++i) {
+	        if (!this._checkingBytes) { ++p; }
+	        if (data[i] === 0x3D/* = */) {
+	          idxeq = i;
+	          break
+	        } else if (data[i] === 0x26/* & */) {
+	          idxamp = i;
+	          break
+	        }
+	        if (this._checkingBytes && this._bytesKey === this.fieldNameSizeLimit) {
+	          this._hitLimit = true;
+	          break
+	        } else if (this._checkingBytes) { ++this._bytesKey; }
+	      }
+
+	      if (idxeq !== undefined) {
+	        // key with assignment
+	        if (idxeq > p) { this._key += this.decoder.write(data.toString('binary', p, idxeq)); }
+	        this._state = 'val';
+
+	        this._hitLimit = false;
+	        this._checkingBytes = true;
+	        this._val = '';
+	        this._bytesVal = 0;
+	        this._valTrunc = false;
+	        this.decoder.reset();
+
+	        p = idxeq + 1;
+	      } else if (idxamp !== undefined) {
+	        // key with no assignment
+	        ++this._fields;
+	        let key; const keyTrunc = this._keyTrunc;
+	        if (idxamp > p) { key = (this._key += this.decoder.write(data.toString('binary', p, idxamp))); } else { key = this._key; }
+
+	        this._hitLimit = false;
+	        this._checkingBytes = true;
+	        this._key = '';
+	        this._bytesKey = 0;
+	        this._keyTrunc = false;
+	        this.decoder.reset();
+
+	        if (key.length) {
+	          this.boy.emit('field', decodeText(key, 'binary', this.charset),
+	            '',
+	            keyTrunc,
+	            false);
+	        }
+
+	        p = idxamp + 1;
+	        if (this._fields === this.fieldsLimit) { return cb() }
+	      } else if (this._hitLimit) {
+	        // we may not have hit the actual limit if there are encoded bytes...
+	        if (i > p) { this._key += this.decoder.write(data.toString('binary', p, i)); }
+	        p = i;
+	        if ((this._bytesKey = this._key.length) === this.fieldNameSizeLimit) {
+	          // yep, we actually did hit the limit
+	          this._checkingBytes = false;
+	          this._keyTrunc = true;
+	        }
+	      } else {
+	        if (p < len) { this._key += this.decoder.write(data.toString('binary', p)); }
+	        p = len;
+	      }
+	    } else {
+	      idxamp = undefined;
+	      for (i = p; i < len; ++i) {
+	        if (!this._checkingBytes) { ++p; }
+	        if (data[i] === 0x26/* & */) {
+	          idxamp = i;
+	          break
+	        }
+	        if (this._checkingBytes && this._bytesVal === this.fieldSizeLimit) {
+	          this._hitLimit = true;
+	          break
+	        } else if (this._checkingBytes) { ++this._bytesVal; }
+	      }
+
+	      if (idxamp !== undefined) {
+	        ++this._fields;
+	        if (idxamp > p) { this._val += this.decoder.write(data.toString('binary', p, idxamp)); }
+	        this.boy.emit('field', decodeText(this._key, 'binary', this.charset),
+	          decodeText(this._val, 'binary', this.charset),
+	          this._keyTrunc,
+	          this._valTrunc);
+	        this._state = 'key';
+
+	        this._hitLimit = false;
+	        this._checkingBytes = true;
+	        this._key = '';
+	        this._bytesKey = 0;
+	        this._keyTrunc = false;
+	        this.decoder.reset();
+
+	        p = idxamp + 1;
+	        if (this._fields === this.fieldsLimit) { return cb() }
+	      } else if (this._hitLimit) {
+	        // we may not have hit the actual limit if there are encoded bytes...
+	        if (i > p) { this._val += this.decoder.write(data.toString('binary', p, i)); }
+	        p = i;
+	        if ((this._val === '' && this.fieldSizeLimit === 0) ||
+	            (this._bytesVal = this._val.length) === this.fieldSizeLimit) {
+	          // yep, we actually did hit the limit
+	          this._checkingBytes = false;
+	          this._valTrunc = true;
+	        }
+	      } else {
+	        if (p < len) { this._val += this.decoder.write(data.toString('binary', p)); }
+	        p = len;
+	      }
+	    }
+	  }
+	  cb();
+	};
+
+	UrlEncoded.prototype.end = function () {
+	  if (this.boy._done) { return }
+
+	  if (this._state === 'key' && this._key.length > 0) {
+	    this.boy.emit('field', decodeText(this._key, 'binary', this.charset),
+	      '',
+	      this._keyTrunc,
+	      false);
+	  } else if (this._state === 'val') {
+	    this.boy.emit('field', decodeText(this._key, 'binary', this.charset),
+	      decodeText(this._val, 'binary', this.charset),
+	      this._keyTrunc,
+	      this._valTrunc);
+	  }
+	  this.boy._done = true;
+	  this.boy.emit('finish');
+	};
+
+	urlencoded = UrlEncoded;
+	return urlencoded;
+}
+
+var hasRequiredMain;
+
+function requireMain () {
+	if (hasRequiredMain) return main.exports;
+	hasRequiredMain = 1;
+
+	const WritableStream = require$$0$1.Writable;
+	const { inherits } = require$$1$1;
+	const Dicer = requireDicer();
+
+	const MultipartParser = requireMultipart();
+	const UrlencodedParser = requireUrlencoded();
+	const parseParams = requireParseParams();
+
+	function Busboy (opts) {
+	  if (!(this instanceof Busboy)) { return new Busboy(opts) }
+
+	  if (typeof opts !== 'object') {
+	    throw new TypeError('Busboy expected an options-Object.')
+	  }
+	  if (typeof opts.headers !== 'object') {
+	    throw new TypeError('Busboy expected an options-Object with headers-attribute.')
+	  }
+	  if (typeof opts.headers['content-type'] !== 'string') {
+	    throw new TypeError('Missing Content-Type-header.')
+	  }
+
+	  const {
+	    headers,
+	    ...streamOptions
+	  } = opts;
+
+	  this.opts = {
+	    autoDestroy: false,
+	    ...streamOptions
+	  };
+	  WritableStream.call(this, this.opts);
+
+	  this._done = false;
+	  this._parser = this.getParserByHeaders(headers);
+	  this._finished = false;
+	}
+	inherits(Busboy, WritableStream);
+
+	Busboy.prototype.emit = function (ev) {
+	  if (ev === 'finish') {
+	    if (!this._done) {
+	      this._parser?.end();
+	      return
+	    } else if (this._finished) {
+	      return
+	    }
+	    this._finished = true;
+	  }
+	  WritableStream.prototype.emit.apply(this, arguments);
+	};
+
+	Busboy.prototype.getParserByHeaders = function (headers) {
+	  const parsed = parseParams(headers['content-type']);
+
+	  const cfg = {
+	    defCharset: this.opts.defCharset,
+	    fileHwm: this.opts.fileHwm,
+	    headers,
+	    highWaterMark: this.opts.highWaterMark,
+	    isPartAFile: this.opts.isPartAFile,
+	    limits: this.opts.limits,
+	    parsedConType: parsed,
+	    preservePath: this.opts.preservePath
+	  };
+
+	  if (MultipartParser.detect.test(parsed[0])) {
+	    return new MultipartParser(this, cfg)
+	  }
+	  if (UrlencodedParser.detect.test(parsed[0])) {
+	    return new UrlencodedParser(this, cfg)
+	  }
+	  throw new Error('Unsupported Content-Type.')
+	};
+
+	Busboy.prototype._write = function (chunk, encoding, cb) {
+	  this._parser.write(chunk, cb);
+	};
+
+	main.exports = Busboy;
+	main.exports.default = Busboy;
+	main.exports.Busboy = Busboy;
+
+	main.exports.Dicer = Dicer;
+	return main.exports;
+}
+
+var Blob = {};
+
+var ReadableStream = {};
+
+var utils = {};
+
+var hasRequiredUtils;
+
+function requireUtils () {
+	if (hasRequiredUtils) return utils;
+	hasRequiredUtils = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.fakePromise = void 0;
+		exports.getHeadersObj = getHeadersObj;
+		exports.defaultHeadersSerializer = defaultHeadersSerializer;
+		exports.isArrayBufferView = isArrayBufferView;
+		exports.isNodeReadable = isNodeReadable;
+		exports.isIterable = isIterable;
+		exports.shouldRedirect = shouldRedirect;
+		exports.pipeThrough = pipeThrough;
+		exports.endStream = endStream;
+		exports.safeWrite = safeWrite;
+		const node_events_1 = require$$0;
+		function isHeadersInstance(obj) {
+		    return obj?.forEach != null;
+		}
+		function getHeadersObj(headers) {
+		    if (headers == null || !isHeadersInstance(headers)) {
+		        return headers;
+		    }
+		    // @ts-expect-error - `headersInit` is not a public property
+		    if (headers.headersInit && !headers._map && !isHeadersInstance(headers.headersInit)) {
+		        // @ts-expect-error - `headersInit` is not a public property
+		        return headers.headersInit;
+		    }
+		    return Object.fromEntries(headers.entries());
+		}
+		function defaultHeadersSerializer(headers, onContentLength) {
+		    const headerArray = [];
+		    headers.forEach((value, key) => {
+		        if (onContentLength && key === 'content-length') {
+		            onContentLength(value);
+		        }
+		        headerArray.push(`${key}: ${value}`);
+		    });
+		    return headerArray;
+		}
+		var promise_helpers_1 = require$$4;
+		Object.defineProperty(exports, "fakePromise", { enumerable: true, get: function () { return promise_helpers_1.fakePromise; } });
+		function isArrayBufferView(obj) {
+		    return obj != null && obj.buffer != null && obj.byteLength != null && obj.byteOffset != null;
+		}
+		function isNodeReadable(obj) {
+		    return obj != null && obj.pipe != null;
+		}
+		function isIterable(value) {
+		    return value?.[Symbol.iterator] != null;
+		}
+		function shouldRedirect(status) {
+		    return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
+		}
+		function pipeThrough({ src, dest, signal, onError, }) {
+		    if (onError) {
+		        // listen for errors on the destination stream if necessary. if the readable
+		        // stream (src) emits an error, the writable destination (dest) will be
+		        // destroyed with that error (see below)
+		        dest.once('error', onError);
+		    }
+		    src.once('error', (e) => {
+		        // if the readable stream (src) emits an error during pipe, the writable
+		        // destination (dest) is not closed automatically. that needs to be
+		        // done manually. the readable stream is closed when error is emitted,
+		        // so only the writable destination needs to be destroyed
+		        dest.destroy(e);
+		    });
+		    dest.once('close', () => {
+		        // if the writable destination (dest) is closed, the readable stream (src)
+		        // is not closed automatically. that needs to be done manually
+		        if (!src.destroyed) {
+		            src.destroy();
+		        }
+		    });
+		    if (signal) {
+		        // this is faster than `import('node:signal').addAbortSignal(signal, src)`
+		        const srcRef = new WeakRef(src);
+		        const signalRef = new WeakRef(signal);
+		        function cleanup() {
+		            signalRef.deref()?.removeEventListener('abort', onAbort);
+		            srcRef.deref()?.removeListener('end', cleanup);
+		            srcRef.deref()?.removeListener('error', cleanup);
+		            srcRef.deref()?.removeListener('close', cleanup);
+		        }
+		        function onAbort() {
+		            srcRef.deref()?.destroy(new AbortError());
+		            cleanup();
+		        }
+		        signal.addEventListener('abort', onAbort, { once: true });
+		        // this is faster than `import('node:signal').finished(src, cleanup)`
+		        src.once('end', cleanup);
+		        src.once('error', cleanup);
+		        src.once('close', cleanup);
+		    }
+		    src.pipe(dest, { end: true /* already default */ });
+		}
+		function endStream(stream) {
+		    // @ts-expect-error Avoid arguments adaptor trampoline https://v8.dev/blog/adaptor-frame
+		    return stream.end(null, null, null);
+		}
+		function safeWrite(chunk, stream) {
+		    const result = stream.write(chunk);
+		    if (!result) {
+		        return (0, node_events_1.once)(stream, 'drain');
+		    }
+		}
+		// https://github.com/nodejs/node/blob/f692878dec6354c0a82241f224906981861bc840/lib/internal/errors.js#L961-L973
+		class AbortError extends Error {
+		    constructor(message = 'The operation was aborted', options = undefined) {
+		        super(message, options);
+		        this.name = 'AbortError';
+		    }
+		} 
+	} (utils));
+	return utils;
+}
+
+var hasRequiredReadableStream;
+
+function requireReadableStream () {
+	if (hasRequiredReadableStream) return ReadableStream;
+	hasRequiredReadableStream = 1;
+	Object.defineProperty(ReadableStream, "__esModule", { value: true });
+	ReadableStream.PonyfillReadableStream = void 0;
+	const node_buffer_1 = require$$0$2;
+	const node_events_1 = require$$0;
+	const node_stream_1 = require$$0$1;
+	const promises_1 = require$$3;
+	const promise_helpers_1 = require$$4;
+	const utils_js_1 = requireUtils();
+	function createController(desiredSize, readable) {
+	    let chunks = [];
+	    let _closed = false;
+	    let flushed = false;
+	    return {
+	        desiredSize,
+	        enqueue(chunk) {
+	            const buf = typeof chunk === 'string' ? node_buffer_1.Buffer.from(chunk) : chunk;
+	            if (!flushed) {
+	                chunks.push(buf);
+	            }
+	            else {
+	                readable.push(buf);
+	            }
+	        },
+	        close() {
+	            if (chunks.length > 0) {
+	                this._flush();
+	            }
+	            readable.push(null);
+	            _closed = true;
+	        },
+	        error(error) {
+	            if (chunks.length > 0) {
+	                this._flush();
+	            }
+	            readable.destroy(error);
+	        },
+	        get _closed() {
+	            return _closed;
+	        },
+	        _flush() {
+	            flushed = true;
+	            if (chunks.length > 0) {
+	                const concatenated = chunks.length > 1 ? node_buffer_1.Buffer.concat(chunks) : chunks[0];
+	                readable.push(concatenated);
+	                chunks = [];
+	            }
+	        },
+	    };
+	}
+	function isNodeReadable(obj) {
+	    return obj?.read != null;
+	}
+	function isReadableStream(obj) {
+	    return obj?.getReader != null;
+	}
+	class PonyfillReadableStream {
+	    readable;
+	    constructor(underlyingSource) {
+	        if (underlyingSource instanceof PonyfillReadableStream && underlyingSource.readable != null) {
+	            this.readable = underlyingSource.readable;
+	        }
+	        else if (isNodeReadable(underlyingSource)) {
+	            this.readable = underlyingSource;
+	        }
+	        else if (isReadableStream(underlyingSource)) {
+	            this.readable = node_stream_1.Readable.fromWeb(underlyingSource);
+	        }
+	        else {
+	            let started = false;
+	            let ongoing = false;
+	            const handleStart = (desiredSize) => {
+	                if (!started) {
+	                    const controller = createController(desiredSize, this.readable);
+	                    started = true;
+	                    return (0, promise_helpers_1.handleMaybePromise)(() => underlyingSource?.start?.(controller), () => {
+	                        controller._flush();
+	                        if (controller._closed) {
+	                            return false;
+	                        }
+	                        return true;
+	                    });
+	                }
+	                return true;
+	            };
+	            const readImpl = (desiredSize) => {
+	                return (0, promise_helpers_1.handleMaybePromise)(() => handleStart(desiredSize), shouldContinue => {
+	                    if (!shouldContinue) {
+	                        return;
+	                    }
+	                    const controller = createController(desiredSize, this.readable);
+	                    return (0, promise_helpers_1.handleMaybePromise)(() => underlyingSource?.pull?.(controller), () => {
+	                        controller._flush();
+	                        ongoing = false;
+	                    });
+	                });
+	            };
+	            this.readable = new node_stream_1.Readable({
+	                read(desiredSize) {
+	                    if (ongoing) {
+	                        return;
+	                    }
+	                    ongoing = true;
+	                    return readImpl(desiredSize);
+	                },
+	                destroy(err, callback) {
+	                    if (underlyingSource?.cancel) {
+	                        try {
+	                            const res$ = underlyingSource.cancel(err);
+	                            if (res$?.then) {
+	                                return res$.then(() => {
+	                                    callback(null);
+	                                }, err => {
+	                                    callback(err);
+	                                });
+	                            }
+	                        }
+	                        catch (err) {
+	                            callback(err);
+	                            return;
+	                        }
+	                    }
+	                    callback(null);
+	                },
+	            });
+	        }
+	    }
+	    cancel(reason) {
+	        this.readable.destroy(reason);
+	        // @ts-expect-error - we know it is void
+	        return (0, node_events_1.once)(this.readable, 'close');
+	    }
+	    locked = false;
+	    getReader(_options) {
+	        const iterator = this.readable[Symbol.asyncIterator]();
+	        this.locked = true;
+	        const thisReadable = this.readable;
+	        return {
+	            read() {
+	                return iterator.next();
+	            },
+	            releaseLock: () => {
+	                if (iterator.return) {
+	                    const retResult$ = iterator.return();
+	                    if (retResult$.then) {
+	                        retResult$.then(() => {
+	                            this.locked = false;
+	                        });
+	                        return;
+	                    }
+	                }
+	                this.locked = false;
+	            },
+	            cancel: reason => {
+	                if (iterator.return) {
+	                    const retResult$ = iterator.return(reason);
+	                    if (retResult$.then) {
+	                        return retResult$.then(() => {
+	                            this.locked = false;
+	                        });
+	                    }
+	                }
+	                this.locked = false;
+	                return (0, utils_js_1.fakePromise)();
+	            },
+	            get closed() {
+	                return Promise.race([
+	                    (0, node_events_1.once)(thisReadable, 'end'),
+	                    (0, node_events_1.once)(thisReadable, 'error').then(err => Promise.reject(err)),
+	                ]);
+	            },
+	        };
+	    }
+	    [Symbol.asyncIterator]() {
+	        const iterator = this.readable[Symbol.asyncIterator]();
+	        return {
+	            [Symbol.asyncIterator]() {
+	                return this;
+	            },
+	            next: () => iterator.next(),
+	            return: () => {
+	                if (!this.readable.destroyed) {
+	                    this.readable.destroy();
+	                }
+	                return iterator.return?.() || (0, utils_js_1.fakePromise)({ done: true, value: undefined });
+	            },
+	            throw: (err) => {
+	                if (!this.readable.destroyed) {
+	                    this.readable.destroy(err);
+	                }
+	                return iterator.throw?.(err) || (0, utils_js_1.fakePromise)({ done: true, value: undefined });
+	            },
+	        };
+	    }
+	    tee() {
+	        throw new Error('Not implemented');
+	    }
+	    async pipeToWriter(writer) {
+	        try {
+	            for await (const chunk of this) {
+	                await writer.write(chunk);
+	            }
+	            await writer.close();
+	        }
+	        catch (err) {
+	            await writer.abort(err);
+	        }
+	    }
+	    pipeTo(destination) {
+	        if (isPonyfillWritableStream(destination)) {
+	            return (0, promises_1.pipeline)(this.readable, destination.writable, {
+	                end: true,
+	            });
+	        }
+	        else {
+	            const writer = destination.getWriter();
+	            return this.pipeToWriter(writer);
+	        }
+	    }
+	    pipeThrough({ writable, readable, }) {
+	        this.pipeTo(writable).catch(err => {
+	            this.readable.destroy(err);
+	        });
+	        if (isPonyfillReadableStream(readable)) {
+	            readable.readable.once('error', err => this.readable.destroy(err));
+	            readable.readable.once('finish', () => this.readable.push(null));
+	            readable.readable.once('close', () => this.readable.push(null));
+	        }
+	        return readable;
+	    }
+	    static [Symbol.hasInstance](instance) {
+	        return isReadableStream(instance);
+	    }
+	    static from(iterable) {
+	        return new PonyfillReadableStream(node_stream_1.Readable.from(iterable));
+	    }
+	    [Symbol.toStringTag] = 'ReadableStream';
+	}
+	ReadableStream.PonyfillReadableStream = PonyfillReadableStream;
+	function isPonyfillReadableStream(obj) {
+	    return obj?.readable != null;
+	}
+	function isPonyfillWritableStream(obj) {
+	    return obj?.writable != null;
+	}
+	return ReadableStream;
+}
+
+var hasRequiredBlob;
+
+function requireBlob () {
+	if (hasRequiredBlob) return Blob;
+	hasRequiredBlob = 1;
+	Object.defineProperty(Blob, "__esModule", { value: true });
+	Blob.PonyfillBlob = void 0;
+	Blob.hasBufferMethod = hasBufferMethod;
+	Blob.hasArrayBufferMethod = hasArrayBufferMethod;
+	Blob.hasBytesMethod = hasBytesMethod;
+	Blob.hasTextMethod = hasTextMethod;
+	Blob.hasSizeProperty = hasSizeProperty;
+	Blob.hasStreamMethod = hasStreamMethod;
+	Blob.hasBlobSignature = hasBlobSignature;
+	Blob.isArrayBuffer = isArrayBuffer;
+	/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
+	/* eslint-disable @typescript-eslint/ban-ts-comment */
+	const node_buffer_1 = require$$0$2;
+	const ReadableStream_js_1 = requireReadableStream();
+	const utils_js_1 = requireUtils();
+	function getBlobPartAsBuffer(blobPart) {
+	    if (typeof blobPart === 'string') {
+	        return node_buffer_1.Buffer.from(blobPart);
+	    }
+	    else if (node_buffer_1.Buffer.isBuffer(blobPart)) {
+	        return blobPart;
+	    }
+	    else if ((0, utils_js_1.isArrayBufferView)(blobPart)) {
+	        return node_buffer_1.Buffer.from(blobPart.buffer, blobPart.byteOffset, blobPart.byteLength);
+	    }
+	    else {
+	        return node_buffer_1.Buffer.from(blobPart);
+	    }
+	}
+	function hasBufferMethod(obj) {
+	    return obj != null && obj.buffer != null && typeof obj.buffer === 'function';
+	}
+	function hasArrayBufferMethod(obj) {
+	    return obj != null && obj.arrayBuffer != null && typeof obj.arrayBuffer === 'function';
+	}
+	function hasBytesMethod(obj) {
+	    return obj != null && obj.bytes != null && typeof obj.bytes === 'function';
+	}
+	function hasTextMethod(obj) {
+	    return obj != null && obj.text != null && typeof obj.text === 'function';
+	}
+	function hasSizeProperty(obj) {
+	    return obj != null && typeof obj.size === 'number';
+	}
+	function hasStreamMethod(obj) {
+	    return obj != null && obj.stream != null && typeof obj.stream === 'function';
+	}
+	function hasBlobSignature(obj) {
+	    return obj != null && obj[Symbol.toStringTag] === 'Blob';
+	}
+	function isArrayBuffer(obj) {
+	    return obj != null && obj.byteLength != null && obj.slice != null;
+	}
+	// Will be removed after v14 reaches EOL
+	// Needed because v14 doesn't have .stream() implemented
+	class PonyfillBlob {
+	    blobParts;
+	    type;
+	    encoding;
+	    _size = null;
+	    constructor(blobParts = [], options) {
+	        this.blobParts = blobParts;
+	        this.type = options?.type || 'application/octet-stream';
+	        this.encoding = options?.encoding || 'utf8';
+	        this._size = options?.size || null;
+	        if (blobParts.length === 1 && hasBlobSignature(blobParts[0])) {
+	            return blobParts[0];
+	        }
+	    }
+	    _buffer = null;
+	    buffer() {
+	        if (this._buffer) {
+	            return (0, utils_js_1.fakePromise)(this._buffer);
+	        }
+	        if (this.blobParts.length === 1) {
+	            const blobPart = this.blobParts[0];
+	            if (hasBufferMethod(blobPart)) {
+	                return blobPart.buffer().then(buf => {
+	                    this._buffer = buf;
+	                    return this._buffer;
+	                });
+	            }
+	            if (hasBytesMethod(blobPart)) {
+	                return blobPart.bytes().then(bytes => {
+	                    this._buffer = node_buffer_1.Buffer.from(bytes);
+	                    return this._buffer;
+	                });
+	            }
+	            if (hasArrayBufferMethod(blobPart)) {
+	                return blobPart.arrayBuffer().then(arrayBuf => {
+	                    this._buffer = node_buffer_1.Buffer.from(arrayBuf, undefined, blobPart.size);
+	                    return this._buffer;
+	                });
+	            }
+	            this._buffer = getBlobPartAsBuffer(blobPart);
+	            return (0, utils_js_1.fakePromise)(this._buffer);
+	        }
+	        const jobs = [];
+	        const bufferChunks = this.blobParts.map((blobPart, i) => {
+	            if (hasBufferMethod(blobPart)) {
+	                jobs.push(blobPart.buffer().then(buf => {
+	                    bufferChunks[i] = buf;
+	                }));
+	                return undefined;
+	            }
+	            else if (hasArrayBufferMethod(blobPart)) {
+	                jobs.push(blobPart.arrayBuffer().then(arrayBuf => {
+	                    bufferChunks[i] = node_buffer_1.Buffer.from(arrayBuf, undefined, blobPart.size);
+	                }));
+	                return undefined;
+	            }
+	            else if (hasBytesMethod(blobPart)) {
+	                jobs.push(blobPart.bytes().then(bytes => {
+	                    bufferChunks[i] = node_buffer_1.Buffer.from(bytes);
+	                }));
+	                return undefined;
+	            }
+	            else {
+	                return getBlobPartAsBuffer(blobPart);
+	            }
+	        });
+	        if (jobs.length > 0) {
+	            return Promise.all(jobs).then(() => node_buffer_1.Buffer.concat(bufferChunks, this._size || undefined));
+	        }
+	        return (0, utils_js_1.fakePromise)(node_buffer_1.Buffer.concat(bufferChunks, this._size || undefined));
+	    }
+	    arrayBuffer() {
+	        if (this._buffer) {
+	            // @ts-ignore - Mismatch between Buffer and ArrayBuffer
+	            return (0, utils_js_1.fakePromise)(this._buffer);
+	        }
+	        if (this.blobParts.length === 1) {
+	            if (isArrayBuffer(this.blobParts[0])) {
+	                return (0, utils_js_1.fakePromise)(this.blobParts[0]);
+	            }
+	            if (hasArrayBufferMethod(this.blobParts[0])) {
+	                return this.blobParts[0].arrayBuffer();
+	            }
+	        }
+	        // @ts-ignore - Mismatch between Buffer and ArrayBuffer
+	        return this.buffer();
+	    }
+	    bytes() {
+	        if (this._buffer) {
+	            return (0, utils_js_1.fakePromise)(this._buffer);
+	        }
+	        if (this.blobParts.length === 1) {
+	            if (node_buffer_1.Buffer.isBuffer(this.blobParts[0])) {
+	                this._buffer = this.blobParts[0];
+	                return (0, utils_js_1.fakePromise)(this._buffer);
+	            }
+	            if (this.blobParts[0] instanceof Uint8Array) {
+	                this._buffer = node_buffer_1.Buffer.from(this.blobParts[0]);
+	                return (0, utils_js_1.fakePromise)(this._buffer);
+	            }
+	            if (hasBytesMethod(this.blobParts[0])) {
+	                return this.blobParts[0].bytes();
+	            }
+	            if (hasBufferMethod(this.blobParts[0])) {
+	                return this.blobParts[0].buffer();
+	            }
+	        }
+	        return this.buffer();
+	    }
+	    _text = null;
+	    text() {
+	        if (this._text) {
+	            return (0, utils_js_1.fakePromise)(this._text);
+	        }
+	        if (this.blobParts.length === 1) {
+	            const blobPart = this.blobParts[0];
+	            if (typeof blobPart === 'string') {
+	                this._text = blobPart;
+	                return (0, utils_js_1.fakePromise)(this._text);
+	            }
+	            if (hasTextMethod(blobPart)) {
+	                return blobPart.text().then(text => {
+	                    this._text = text;
+	                    return this._text;
+	                });
+	            }
+	            const buf = getBlobPartAsBuffer(blobPart);
+	            this._text = buf.toString(this.encoding);
+	            return (0, utils_js_1.fakePromise)(this._text);
+	        }
+	        return this.buffer().then(buf => {
+	            this._text = buf.toString(this.encoding);
+	            return this._text;
+	        });
+	    }
+	    _json = null;
+	    json() {
+	        if (this._json) {
+	            return (0, utils_js_1.fakePromise)(this._json);
+	        }
+	        return this.text().then(text => {
+	            this._json = JSON.parse(text);
+	            return this._json;
+	        });
+	    }
+	    _formData = null;
+	    formData() {
+	        if (this._formData) {
+	            return (0, utils_js_1.fakePromise)(this._formData);
+	        }
+	        throw new Error('Not implemented');
+	    }
+	    get size() {
+	        if (this._size == null) {
+	            this._size = 0;
+	            for (const blobPart of this.blobParts) {
+	                if (typeof blobPart === 'string') {
+	                    this._size += node_buffer_1.Buffer.byteLength(blobPart);
+	                }
+	                else if (hasSizeProperty(blobPart)) {
+	                    this._size += blobPart.size;
+	                }
+	                else if ((0, utils_js_1.isArrayBufferView)(blobPart)) {
+	                    this._size += blobPart.byteLength;
+	                }
+	            }
+	        }
+	        return this._size;
+	    }
+	    stream() {
+	        if (this.blobParts.length === 1) {
+	            const blobPart = this.blobParts[0];
+	            if (hasStreamMethod(blobPart)) {
+	                return blobPart.stream();
+	            }
+	            const buf = getBlobPartAsBuffer(blobPart);
+	            return new ReadableStream_js_1.PonyfillReadableStream({
+	                start: controller => {
+	                    controller.enqueue(buf);
+	                    controller.close();
+	                },
+	            });
+	        }
+	        if (this._buffer != null) {
+	            return new ReadableStream_js_1.PonyfillReadableStream({
+	                start: controller => {
+	                    controller.enqueue(this._buffer);
+	                    controller.close();
+	                },
+	            });
+	        }
+	        let blobPartIterator;
+	        return new ReadableStream_js_1.PonyfillReadableStream({
+	            start: controller => {
+	                if (this.blobParts.length === 0) {
+	                    controller.close();
+	                    return;
+	                }
+	                blobPartIterator = this.blobParts[Symbol.iterator]();
+	            },
+	            pull: controller => {
+	                const { value: blobPart, done } = blobPartIterator.next();
+	                if (done) {
+	                    controller.close();
+	                    return;
+	                }
+	                if (blobPart) {
+	                    if (hasBufferMethod(blobPart)) {
+	                        return blobPart.buffer().then(buf => {
+	                            controller.enqueue(buf);
+	                        });
+	                    }
+	                    if (hasBytesMethod(blobPart)) {
+	                        return blobPart.bytes().then(bytes => {
+	                            const buf = node_buffer_1.Buffer.from(bytes);
+	                            controller.enqueue(buf);
+	                        });
+	                    }
+	                    if (hasArrayBufferMethod(blobPart)) {
+	                        return blobPart.arrayBuffer().then(arrayBuffer => {
+	                            const buf = node_buffer_1.Buffer.from(arrayBuffer, undefined, blobPart.size);
+	                            controller.enqueue(buf);
+	                        });
+	                    }
+	                    const buf = getBlobPartAsBuffer(blobPart);
+	                    controller.enqueue(buf);
+	                }
+	            },
+	        });
+	    }
+	    slice() {
+	        throw new Error('Not implemented');
+	    }
+	}
+	Blob.PonyfillBlob = PonyfillBlob;
+	return Blob;
+}
+
+var File = {};
+
+var hasRequiredFile;
+
+function requireFile () {
+	if (hasRequiredFile) return File;
+	hasRequiredFile = 1;
+	Object.defineProperty(File, "__esModule", { value: true });
+	File.PonyfillFile = void 0;
+	const Blob_js_1 = requireBlob();
+	class PonyfillFile extends Blob_js_1.PonyfillBlob {
+	    name;
+	    lastModified;
+	    constructor(fileBits, name, options) {
+	        super(fileBits, options);
+	        this.name = name;
+	        this.lastModified = options?.lastModified || Date.now();
+	    }
+	    webkitRelativePath = '';
+	}
+	File.PonyfillFile = PonyfillFile;
+	return File;
+}
+
+var FormData = {};
+
+var IteratorObject = {};
+
+var hasRequiredIteratorObject;
+
+function requireIteratorObject () {
+	if (hasRequiredIteratorObject) return IteratorObject;
+	hasRequiredIteratorObject = 1;
+	Object.defineProperty(IteratorObject, "__esModule", { value: true });
+	IteratorObject.PonyfillIteratorObject = void 0;
+	const node_util_1 = require$$1$1;
+	const disposablestack_1 = require$$1__default;
+	const utils_js_1 = requireUtils();
+	class PonyfillIteratorObject {
+	    iterableIterator;
+	    [Symbol.toStringTag] = 'IteratorObject';
+	    constructor(iterableIterator, className) {
+	        this.iterableIterator = iterableIterator;
+	        this[Symbol.toStringTag] = className;
+	    }
+	    *map(callbackfn) {
+	        let index = 0;
+	        for (const value of this.iterableIterator) {
+	            yield callbackfn(value, index++);
+	        }
+	        return undefined;
+	    }
+	    *filter(callbackfn) {
+	        let index = 0;
+	        for (const value of this.iterableIterator) {
+	            if (callbackfn(value, index++)) {
+	                yield value;
+	            }
+	        }
+	        return undefined;
+	    }
+	    reduce(callbackfn, initialValue) {
+	        let index = 0;
+	        let accumulator = initialValue;
+	        for (const value of this.iterableIterator) {
+	            accumulator = callbackfn(accumulator, value, index++);
+	        }
+	        return accumulator;
+	    }
+	    forEach(callbackfn) {
+	        let index = 0;
+	        for (const value of this.iterableIterator) {
+	            callbackfn(value, index++);
+	        }
+	    }
+	    *take(limit) {
+	        let index = 0;
+	        for (const value of this.iterableIterator) {
+	            if (index >= limit) {
+	                break;
+	            }
+	            yield value;
+	            index++;
+	        }
+	        return undefined;
+	    }
+	    *drop(count) {
+	        let index = 0;
+	        for (const value of this.iterableIterator) {
+	            if (index >= count) {
+	                yield value;
+	            }
+	            index++;
+	        }
+	        return undefined;
+	    }
+	    *flatMap(callback) {
+	        let index = 0;
+	        for (const value of this.iterableIterator) {
+	            const iteratorOrIterable = callback(value, index++);
+	            if ((0, utils_js_1.isIterable)(iteratorOrIterable)) {
+	                for (const innerValue of iteratorOrIterable) {
+	                    yield innerValue;
+	                }
+	            }
+	            else {
+	                for (const innerValue of {
+	                    [Symbol.iterator]: () => iteratorOrIterable,
+	                }) {
+	                    yield innerValue;
+	                }
+	            }
+	        }
+	        return undefined;
+	    }
+	    some(predicate) {
+	        let index = 0;
+	        for (const value of this.iterableIterator) {
+	            if (predicate(value, index++)) {
+	                return true;
+	            }
+	        }
+	        return false;
+	    }
+	    every(predicate) {
+	        let index = 0;
+	        for (const value of this.iterableIterator) {
+	            if (!predicate(value, index++)) {
+	                return false;
+	            }
+	        }
+	        return true;
+	    }
+	    find(predicate) {
+	        let index = 0;
+	        for (const value of this.iterableIterator) {
+	            if (predicate(value, index++)) {
+	                return value;
+	            }
+	        }
+	        return undefined;
+	    }
+	    toArray() {
+	        return Array.from(this.iterableIterator);
+	    }
+	    [disposablestack_1.DisposableSymbols.dispose]() {
+	        this.iterableIterator.return?.();
+	    }
+	    next(...[value]) {
+	        return this.iterableIterator.next(value);
+	    }
+	    [Symbol.iterator]() {
+	        return this;
+	    }
+	    [Symbol.for('nodejs.util.inspect.custom')]() {
+	        const record = {};
+	        this.forEach((value, key) => {
+	            const inspectedValue = (0, node_util_1.inspect)(value);
+	            record[key] = inspectedValue.includes(',')
+	                ? inspectedValue.split(',').map(el => el.trim())
+	                : inspectedValue;
+	        });
+	        return `${this[Symbol.toStringTag]} ${(0, node_util_1.inspect)(record)}`;
+	    }
+	}
+	IteratorObject.PonyfillIteratorObject = PonyfillIteratorObject;
+	return IteratorObject;
+}
+
+var hasRequiredFormData;
+
+function requireFormData () {
+	if (hasRequiredFormData) return FormData;
+	hasRequiredFormData = 1;
+	Object.defineProperty(FormData, "__esModule", { value: true });
+	FormData.PonyfillFormData = void 0;
+	FormData.getStreamFromFormData = getStreamFromFormData;
+	const node_buffer_1 = require$$0$2;
+	const IteratorObject_js_1 = requireIteratorObject();
+	const ReadableStream_js_1 = requireReadableStream();
+	class PonyfillFormData {
+	    map = new Map();
+	    append(name, value, fileName) {
+	        let values = this.map.get(name);
+	        if (!values) {
+	            values = [];
+	            this.map.set(name, values);
+	        }
+	        const entry = isBlob(value)
+	            ? getNormalizedFile(name, value, fileName)
+	            : value;
+	        values.push(entry);
+	    }
+	    delete(name) {
+	        this.map.delete(name);
+	    }
+	    get(name) {
+	        const values = this.map.get(name);
+	        return values ? values[0] : null;
+	    }
+	    getAll(name) {
+	        return this.map.get(name) || [];
+	    }
+	    has(name) {
+	        return this.map.has(name);
+	    }
+	    set(name, value, fileName) {
+	        const entry = isBlob(value)
+	            ? getNormalizedFile(name, value, fileName)
+	            : value;
+	        this.map.set(name, [entry]);
+	    }
+	    [Symbol.iterator]() {
+	        return this._entries();
+	    }
+	    *_entries() {
+	        for (const [key, values] of this.map) {
+	            for (const value of values) {
+	                yield [key, value];
+	            }
+	        }
+	    }
+	    entries() {
+	        return new IteratorObject_js_1.PonyfillIteratorObject(this._entries(), 'FormDataIterator');
+	    }
+	    _keys() {
+	        return this.map.keys();
+	    }
+	    keys() {
+	        return new IteratorObject_js_1.PonyfillIteratorObject(this._keys(), 'FormDataIterator');
+	    }
+	    *_values() {
+	        for (const values of this.map.values()) {
+	            for (const value of values) {
+	                yield value;
+	            }
+	        }
+	    }
+	    values() {
+	        return new IteratorObject_js_1.PonyfillIteratorObject(this._values(), 'FormDataIterator');
+	    }
+	    forEach(callback) {
+	        for (const [key, value] of this) {
+	            callback(value, key, this);
+	        }
+	    }
+	}
+	FormData.PonyfillFormData = PonyfillFormData;
+	function getStreamFromFormData(formData, boundary = '---') {
+	    let entriesIterator;
+	    let sentInitialHeader = false;
+	    let currentAsyncIterator;
+	    let hasBefore = false;
+	    function handleNextEntry(controller) {
+	        const { done, value } = entriesIterator.next();
+	        if (done) {
+	            controller.enqueue(node_buffer_1.Buffer.from(`\r\n--${boundary}--\r\n`));
+	            return controller.close();
+	        }
+	        if (hasBefore) {
+	            controller.enqueue(node_buffer_1.Buffer.from(`\r\n--${boundary}\r\n`));
+	        }
+	        if (value) {
+	            const [key, blobOrString] = value;
+	            if (typeof blobOrString === 'string') {
+	                controller.enqueue(node_buffer_1.Buffer.from(`Content-Disposition: form-data; name="${key}"\r\n\r\n`));
+	                controller.enqueue(node_buffer_1.Buffer.from(blobOrString));
+	            }
+	            else {
+	                let filenamePart = '';
+	                if (blobOrString.name) {
+	                    filenamePart = `; filename="${blobOrString.name}"`;
+	                }
+	                controller.enqueue(node_buffer_1.Buffer.from(`Content-Disposition: form-data; name="${key}"${filenamePart}\r\n`));
+	                controller.enqueue(node_buffer_1.Buffer.from(`Content-Type: ${blobOrString.type || 'application/octet-stream'}\r\n\r\n`));
+	                const entryStream = blobOrString.stream();
+	                // @ts-expect-error - ReadableStream is async iterable
+	                currentAsyncIterator = entryStream[Symbol.asyncIterator]();
+	            }
+	            hasBefore = true;
+	        }
+	    }
+	    return new ReadableStream_js_1.PonyfillReadableStream({
+	        start: () => {
+	            entriesIterator = formData.entries();
+	        },
+	        pull: controller => {
+	            if (!sentInitialHeader) {
+	                sentInitialHeader = true;
+	                return controller.enqueue(node_buffer_1.Buffer.from(`--${boundary}\r\n`));
+	            }
+	            if (currentAsyncIterator) {
+	                return currentAsyncIterator.next().then(({ done, value }) => {
+	                    if (done) {
+	                        currentAsyncIterator = undefined;
+	                    }
+	                    if (value) {
+	                        return controller.enqueue(value);
+	                    }
+	                    else {
+	                        return handleNextEntry(controller);
+	                    }
+	                });
+	            }
+	            return handleNextEntry(controller);
+	        },
+	        cancel: err => {
+	            entriesIterator?.return?.(err);
+	            currentAsyncIterator?.return?.(err);
+	        },
+	    });
+	}
+	function getNormalizedFile(name, blob, fileName) {
+	    Object.defineProperty(blob, 'name', {
+	        configurable: true,
+	        enumerable: true,
+	        value: fileName || blob.name || name,
+	    });
+	    return blob;
+	}
+	function isBlob(value) {
+	    return value?.arrayBuffer != null;
+	}
+	return FormData;
+}
+
+var hasRequiredBody;
+
+function requireBody () {
+	if (hasRequiredBody) return Body;
+	hasRequiredBody = 1;
+	Object.defineProperty(Body, "__esModule", { value: true });
+	Body.PonyfillBody = void 0;
+	/* eslint-disable @typescript-eslint/ban-ts-comment */
+	const node_buffer_1 = require$$0$2;
+	const node_stream_1 = require$$0$1;
+	const busboy_1 = requireMain();
+	const promise_helpers_1 = require$$4;
+	const Blob_js_1 = requireBlob();
+	const File_js_1 = requireFile();
+	const FormData_js_1 = requireFormData();
+	const ReadableStream_js_1 = requireReadableStream();
+	const utils_js_1 = requireUtils();
+	var BodyInitType;
+	(function (BodyInitType) {
+	    BodyInitType["ReadableStream"] = "ReadableStream";
+	    BodyInitType["Blob"] = "Blob";
+	    BodyInitType["FormData"] = "FormData";
+	    BodyInitType["String"] = "String";
+	    BodyInitType["Readable"] = "Readable";
+	    BodyInitType["Buffer"] = "Buffer";
+	    BodyInitType["AsyncIterable"] = "AsyncIterable";
+	})(BodyInitType || (BodyInitType = {}));
+	class PonyfillBody {
+	    bodyInit;
+	    options;
+	    bodyUsed = false;
+	    contentType = null;
+	    contentLength = null;
+	    constructor(bodyInit, options = {}) {
+	        this.bodyInit = bodyInit;
+	        this.options = options;
+	        const { bodyFactory, contentType, contentLength, bodyType, buffer } = processBodyInit(bodyInit);
+	        this._bodyFactory = bodyFactory;
+	        this.contentType = contentType;
+	        this.contentLength = contentLength;
+	        this.bodyType = bodyType;
+	        this._buffer = buffer;
+	        this._signal = options.signal;
+	    }
+	    bodyType;
+	    _bodyFactory = () => null;
+	    _generatedBody = null;
+	    _buffer;
+	    _signal;
+	    generateBody() {
+	        if (this._generatedBody?.readable?.destroyed && this._buffer) {
+	            this._generatedBody.readable = node_stream_1.Readable.from(this._buffer);
+	        }
+	        if (this._generatedBody) {
+	            return this._generatedBody;
+	        }
+	        const body = this._bodyFactory();
+	        this._generatedBody = body;
+	        return body;
+	    }
+	    handleContentLengthHeader(forceSet = false) {
+	        const contentTypeInHeaders = this.headers.get('content-type');
+	        if (!contentTypeInHeaders) {
+	            if (this.contentType) {
+	                this.headers.set('content-type', this.contentType);
+	            }
+	        }
+	        else {
+	            this.contentType = contentTypeInHeaders;
+	        }
+	        const contentLengthInHeaders = this.headers.get('content-length');
+	        if (forceSet && this.bodyInit == null && !contentLengthInHeaders) {
+	            this.contentLength = 0;
+	            this.headers.set('content-length', '0');
+	        }
+	        if (!contentLengthInHeaders) {
+	            if (this.contentLength) {
+	                this.headers.set('content-length', this.contentLength.toString());
+	            }
+	        }
+	        else {
+	            this.contentLength = parseInt(contentLengthInHeaders, 10);
+	        }
+	    }
+	    get body() {
+	        const _body = this.generateBody();
+	        if (_body != null) {
+	            const ponyfillReadableStream = _body;
+	            const readable = _body.readable;
+	            return new Proxy(_body.readable, {
+	                get(_, prop) {
+	                    if (prop in ponyfillReadableStream) {
+	                        const ponyfillReadableStreamProp = ponyfillReadableStream[prop];
+	                        if (typeof ponyfillReadableStreamProp === 'function') {
+	                            return ponyfillReadableStreamProp.bind(ponyfillReadableStream);
+	                        }
+	                        return ponyfillReadableStreamProp;
+	                    }
+	                    if (prop in readable) {
+	                        const readableProp = readable[prop];
+	                        if (typeof readableProp === 'function') {
+	                            return readableProp.bind(readable);
+	                        }
+	                        return readableProp;
+	                    }
+	                },
+	            });
+	        }
+	        return null;
+	    }
+	    _chunks = null;
+	    _doCollectChunksFromReadableJob() {
+	        if (this.bodyType === BodyInitType.AsyncIterable) {
+	            if (Array.fromAsync) {
+	                return (0, promise_helpers_1.handleMaybePromise)(() => Array.fromAsync(this.bodyInit), chunks => {
+	                    this._chunks = chunks;
+	                    return this._chunks;
+	                });
+	            }
+	            const iterator = this.bodyInit[Symbol.asyncIterator]();
+	            const chunks = [];
+	            const collectValue = () => (0, promise_helpers_1.handleMaybePromise)(() => iterator.next(), ({ value, done }) => {
+	                if (value) {
+	                    chunks.push(value);
+	                }
+	                if (!done) {
+	                    return collectValue();
+	                }
+	                this._chunks = chunks;
+	                return this._chunks;
+	            });
+	            return collectValue();
+	        }
+	        const _body = this.generateBody();
+	        if (!_body) {
+	            this._chunks = [];
+	            return (0, utils_js_1.fakePromise)(this._chunks);
+	        }
+	        if (_body.readable.destroyed) {
+	            return (0, utils_js_1.fakePromise)((this._chunks = []));
+	        }
+	        const chunks = [];
+	        return new Promise((resolve, reject) => {
+	            _body.readable.on('data', chunk => {
+	                chunks.push(chunk);
+	            });
+	            _body.readable.once('error', reject);
+	            _body.readable.once('end', () => {
+	                resolve((this._chunks = chunks));
+	            });
+	        });
+	    }
+	    _collectChunksFromReadable() {
+	        if (this._chunks) {
+	            return (0, utils_js_1.fakePromise)(this._chunks);
+	        }
+	        this._chunks ||= this._doCollectChunksFromReadableJob();
+	        return this._chunks;
+	    }
+	    _blob = null;
+	    blob() {
+	        if (this._blob) {
+	            return (0, utils_js_1.fakePromise)(this._blob);
+	        }
+	        if (this.bodyType === BodyInitType.String) {
+	            this._text = this.bodyInit;
+	            this._blob = new Blob_js_1.PonyfillBlob([this._text], {
+	                type: this.contentType || 'text/plain;charset=UTF-8',
+	                size: this.contentLength,
+	            });
+	        }
+	        if (this.bodyType === BodyInitType.Blob) {
+	            this._blob = this.bodyInit;
+	            return (0, utils_js_1.fakePromise)(this._blob);
+	        }
+	        if (this._buffer) {
+	            this._blob = new Blob_js_1.PonyfillBlob([this._buffer], {
+	                type: this.contentType || '',
+	                size: this.contentLength,
+	            });
+	            return (0, utils_js_1.fakePromise)(this._blob);
+	        }
+	        return (0, utils_js_1.fakePromise)((0, promise_helpers_1.handleMaybePromise)(() => this._collectChunksFromReadable(), chunks => {
+	            this._blob = new Blob_js_1.PonyfillBlob(chunks, {
+	                type: this.contentType || '',
+	                size: this.contentLength,
+	            });
+	            return this._blob;
+	        }));
+	    }
+	    _formData = null;
+	    formData(opts) {
+	        if (this._formData) {
+	            return (0, utils_js_1.fakePromise)(this._formData);
+	        }
+	        if (this.bodyType === BodyInitType.FormData) {
+	            this._formData = this.bodyInit;
+	            return (0, utils_js_1.fakePromise)(this._formData);
+	        }
+	        this._formData = new FormData_js_1.PonyfillFormData();
+	        const _body = this.generateBody();
+	        if (_body == null) {
+	            return (0, utils_js_1.fakePromise)(this._formData);
+	        }
+	        const formDataLimits = {
+	            ...this.options.formDataLimits,
+	            ...opts?.formDataLimits,
+	        };
+	        return new Promise((resolve, reject) => {
+	            const stream = this.body?.readable;
+	            if (!stream) {
+	                return reject(new Error('No stream available'));
+	            }
+	            // form data file that is currently being processed, it's
+	            // important to keep track of it in case the stream ends early
+	            let currFile = null;
+	            const bb = new busboy_1.Busboy({
+	                headers: {
+	                    'content-length': typeof this.contentLength === 'number'
+	                        ? this.contentLength.toString()
+	                        : this.contentLength || '',
+	                    'content-type': this.contentType || '',
+	                },
+	                limits: formDataLimits,
+	                defCharset: 'utf-8',
+	            });
+	            if (this._signal) {
+	                (0, node_stream_1.addAbortSignal)(this._signal, bb);
+	            }
+	            let completed = false;
+	            const complete = (err) => {
+	                if (completed)
+	                    return;
+	                completed = true;
+	                stream.unpipe(bb);
+	                bb.destroy();
+	                if (currFile) {
+	                    currFile.destroy();
+	                    currFile = null;
+	                }
+	                if (err) {
+	                    reject(err);
+	                }
+	                else {
+	                    // no error occured, this is a successful end/complete/finish
+	                    resolve(this._formData);
+	                }
+	            };
+	            // we dont need to listen to the stream close event because bb will close or error when necessary
+	            // stream.on('close', complete);
+	            // stream can be aborted, for example
+	            stream.on('error', complete);
+	            bb.on('field', (name, value, fieldnameTruncated, valueTruncated) => {
+	                if (fieldnameTruncated) {
+	                    return complete(new Error(`Field name size exceeded: ${formDataLimits?.fieldNameSize} bytes`));
+	                }
+	                if (valueTruncated) {
+	                    return complete(new Error(`Field value size exceeded: ${formDataLimits?.fieldSize} bytes`));
+	                }
+	                this._formData.set(name, value);
+	            });
+	            bb.on('file', (name, fileStream, filename, _transferEncoding, mimeType) => {
+	                currFile = fileStream;
+	                const chunks = [];
+	                fileStream.on('data', chunk => {
+	                    chunks.push(chunk);
+	                });
+	                fileStream.on('error', complete);
+	                fileStream.on('limit', () => {
+	                    complete(new Error(`File size limit exceeded: ${formDataLimits?.fileSize} bytes`));
+	                });
+	                fileStream.on('close', () => {
+	                    if (fileStream.truncated) {
+	                        complete(new Error(`File size limit exceeded: ${formDataLimits?.fileSize} bytes`));
+	                    }
+	                    currFile = null;
+	                    const file = new File_js_1.PonyfillFile(chunks, filename, { type: mimeType });
+	                    this._formData.set(name, file);
+	                });
+	            });
+	            bb.on('fieldsLimit', () => {
+	                complete(new Error(`Fields limit exceeded: ${formDataLimits?.fields}`));
+	            });
+	            bb.on('filesLimit', () => {
+	                complete(new Error(`Files limit exceeded: ${formDataLimits?.files}`));
+	            });
+	            bb.on('partsLimit', () => {
+	                complete(new Error(`Parts limit exceeded: ${formDataLimits?.parts}`));
+	            });
+	            bb.on('end', complete);
+	            bb.on('finish', complete);
+	            bb.on('close', complete);
+	            bb.on('error', complete);
+	            stream.pipe(bb);
+	        });
+	    }
+	    buffer() {
+	        if (this._buffer) {
+	            return (0, utils_js_1.fakePromise)(this._buffer);
+	        }
+	        if (this._text) {
+	            this._buffer = node_buffer_1.Buffer.from(this._text, 'utf-8');
+	            return (0, utils_js_1.fakePromise)(this._buffer);
+	        }
+	        if (this.bodyType === BodyInitType.String) {
+	            return this.text().then(text => {
+	                this._text = text;
+	                this._buffer = node_buffer_1.Buffer.from(text, 'utf-8');
+	                return this._buffer;
+	            });
+	        }
+	        if (this.bodyType === BodyInitType.Blob) {
+	            if ((0, Blob_js_1.hasBufferMethod)(this.bodyInit)) {
+	                return this.bodyInit.buffer().then(buf => {
+	                    this._buffer = buf;
+	                    return this._buffer;
+	                });
+	            }
+	            if ((0, Blob_js_1.hasBytesMethod)(this.bodyInit)) {
+	                return this.bodyInit.bytes().then(bytes => {
+	                    this._buffer = node_buffer_1.Buffer.from(bytes);
+	                    return this._buffer;
+	                });
+	            }
+	            if ((0, Blob_js_1.hasArrayBufferMethod)(this.bodyInit)) {
+	                return this.bodyInit.arrayBuffer().then(buf => {
+	                    this._buffer = node_buffer_1.Buffer.from(buf, undefined, buf.byteLength);
+	                    return this._buffer;
+	                });
+	            }
+	        }
+	        return (0, utils_js_1.fakePromise)((0, promise_helpers_1.handleMaybePromise)(() => this._collectChunksFromReadable(), chunks => {
+	            if (chunks.length === 1) {
+	                this._buffer = chunks[0];
+	                return this._buffer;
+	            }
+	            this._buffer = node_buffer_1.Buffer.concat(chunks);
+	            return this._buffer;
+	        }));
+	    }
+	    bytes() {
+	        return this.buffer();
+	    }
+	    arrayBuffer() {
+	        // @ts-ignore - Mismatch between Buffer and ArrayBuffer
+	        return this.buffer();
+	    }
+	    _json = null;
+	    json() {
+	        if (this._json) {
+	            return (0, utils_js_1.fakePromise)(this._json);
+	        }
+	        return this.text().then(text => {
+	            try {
+	                this._json = JSON.parse(text);
+	            }
+	            catch (e) {
+	                if (e instanceof SyntaxError) {
+	                    e.message += `, "${text}" is not valid JSON`;
+	                }
+	                throw e;
+	            }
+	            return this._json;
+	        });
+	    }
+	    _text = null;
+	    text() {
+	        if (this._text) {
+	            return (0, utils_js_1.fakePromise)(this._text);
+	        }
+	        if (this.bodyType === BodyInitType.String) {
+	            this._text = this.bodyInit;
+	            return (0, utils_js_1.fakePromise)(this._text);
+	        }
+	        return this.buffer().then(buffer => {
+	            this._text = buffer.toString('utf-8');
+	            return this._text;
+	        });
+	    }
+	}
+	Body.PonyfillBody = PonyfillBody;
+	function processBodyInit(bodyInit) {
+	    if (bodyInit == null) {
+	        return {
+	            bodyFactory: () => null,
+	            contentType: null,
+	            contentLength: null,
+	        };
+	    }
+	    if (typeof bodyInit === 'string') {
+	        const contentLength = node_buffer_1.Buffer.byteLength(bodyInit);
+	        return {
+	            bodyType: BodyInitType.String,
+	            contentType: 'text/plain;charset=UTF-8',
+	            contentLength,
+	            bodyFactory() {
+	                const readable = node_stream_1.Readable.from(node_buffer_1.Buffer.from(bodyInit, 'utf-8'));
+	                return new ReadableStream_js_1.PonyfillReadableStream(readable);
+	            },
+	        };
+	    }
+	    if (node_buffer_1.Buffer.isBuffer(bodyInit)) {
+	        const buffer = bodyInit;
+	        return {
+	            bodyType: BodyInitType.Buffer,
+	            contentType: null,
+	            contentLength: bodyInit.length,
+	            buffer: bodyInit,
+	            bodyFactory() {
+	                const readable = node_stream_1.Readable.from(buffer);
+	                const body = new ReadableStream_js_1.PonyfillReadableStream(readable);
+	                return body;
+	            },
+	        };
+	    }
+	    if ((0, utils_js_1.isArrayBufferView)(bodyInit)) {
+	        const buffer = node_buffer_1.Buffer.from(bodyInit.buffer, bodyInit.byteOffset, bodyInit.byteLength);
+	        return {
+	            bodyType: BodyInitType.Buffer,
+	            contentLength: bodyInit.byteLength,
+	            contentType: null,
+	            buffer,
+	            bodyFactory() {
+	                const readable = node_stream_1.Readable.from(buffer);
+	                const body = new ReadableStream_js_1.PonyfillReadableStream(readable);
+	                return body;
+	            },
+	        };
+	    }
+	    if (bodyInit instanceof ReadableStream_js_1.PonyfillReadableStream && bodyInit.readable != null) {
+	        const readableStream = bodyInit;
+	        return {
+	            bodyType: BodyInitType.ReadableStream,
+	            bodyFactory: () => readableStream,
+	            contentType: null,
+	            contentLength: null,
+	        };
+	    }
+	    if (isBlob(bodyInit)) {
+	        const blob = bodyInit;
+	        return {
+	            bodyType: BodyInitType.Blob,
+	            contentType: bodyInit.type,
+	            contentLength: bodyInit.size,
+	            bodyFactory() {
+	                return blob.stream();
+	            },
+	        };
+	    }
+	    if (bodyInit instanceof ArrayBuffer) {
+	        const contentLength = bodyInit.byteLength;
+	        const buffer = node_buffer_1.Buffer.from(bodyInit, undefined, bodyInit.byteLength);
+	        return {
+	            bodyType: BodyInitType.Buffer,
+	            contentType: null,
+	            contentLength,
+	            buffer,
+	            bodyFactory() {
+	                const readable = node_stream_1.Readable.from(buffer);
+	                const body = new ReadableStream_js_1.PonyfillReadableStream(readable);
+	                return body;
+	            },
+	        };
+	    }
+	    if (bodyInit instanceof node_stream_1.Readable) {
+	        return {
+	            bodyType: BodyInitType.Readable,
+	            contentType: null,
+	            contentLength: null,
+	            bodyFactory() {
+	                const body = new ReadableStream_js_1.PonyfillReadableStream(bodyInit);
+	                return body;
+	            },
+	        };
+	    }
+	    if (isURLSearchParams(bodyInit)) {
+	        const contentType = 'application/x-www-form-urlencoded;charset=UTF-8';
+	        return {
+	            bodyType: BodyInitType.String,
+	            contentType,
+	            contentLength: null,
+	            bodyFactory() {
+	                const body = new ReadableStream_js_1.PonyfillReadableStream(node_stream_1.Readable.from(bodyInit.toString()));
+	                return body;
+	            },
+	        };
+	    }
+	    if (isFormData(bodyInit)) {
+	        const boundary = Math.random().toString(36).substr(2);
+	        const contentType = `multipart/form-data; boundary=${boundary}`;
+	        return {
+	            bodyType: BodyInitType.FormData,
+	            contentType,
+	            contentLength: null,
+	            bodyFactory() {
+	                return (0, FormData_js_1.getStreamFromFormData)(bodyInit, boundary);
+	            },
+	        };
+	    }
+	    if (isReadableStream(bodyInit)) {
+	        return {
+	            contentType: null,
+	            contentLength: null,
+	            bodyFactory() {
+	                return new ReadableStream_js_1.PonyfillReadableStream(bodyInit);
+	            },
+	        };
+	    }
+	    if (bodyInit[Symbol.iterator] || bodyInit[Symbol.asyncIterator]) {
+	        return {
+	            contentType: null,
+	            contentLength: null,
+	            bodyType: BodyInitType.AsyncIterable,
+	            bodyFactory() {
+	                const readable = node_stream_1.Readable.from(bodyInit);
+	                return new ReadableStream_js_1.PonyfillReadableStream(readable);
+	            },
+	        };
+	    }
+	    throw new Error('Unknown body type');
+	}
+	function isFormData(value) {
+	    return value?.forEach != null;
+	}
+	function isBlob(value) {
+	    return value?.stream != null && typeof value.stream === 'function';
+	}
+	function isURLSearchParams(value) {
+	    return value?.sort != null;
+	}
+	function isReadableStream(value) {
+	    return value?.getReader != null;
+	}
+	return Body;
+}
+
+var Headers = {};
+
+var hasRequiredHeaders;
+
+function requireHeaders () {
+	if (hasRequiredHeaders) return Headers;
+	hasRequiredHeaders = 1;
+	Object.defineProperty(Headers, "__esModule", { value: true });
+	Headers.PonyfillHeaders = void 0;
+	Headers.isHeadersLike = isHeadersLike;
+	const node_util_1 = require$$1$1;
+	const IteratorObject_js_1 = requireIteratorObject();
+	function isHeadersLike(headers) {
+	    return headers?.get && headers?.forEach;
+	}
+	class PonyfillHeaders {
+	    headersInit;
+	    _map;
+	    objectNormalizedKeysOfHeadersInit = [];
+	    objectOriginalKeysOfHeadersInit = [];
+	    _setCookies;
+	    constructor(headersInit) {
+	        this.headersInit = headersInit;
+	    }
+	    // perf: we don't need to build `this.map` for Requests, as we can access the headers directly
+	    _get(key) {
+	        const normalized = key.toLowerCase();
+	        if (normalized === 'set-cookie' && this._setCookies?.length) {
+	            return this._setCookies.join(', ');
+	        }
+	        // If the map is built, reuse it
+	        if (this._map) {
+	            return this._map.get(normalized) || null;
+	        }
+	        // If the map is not built, try to get the value from the this.headersInit
+	        if (this.headersInit == null) {
+	            return null;
+	        }
+	        if (Array.isArray(this.headersInit)) {
+	            const found = this.headersInit.filter(([headerKey]) => headerKey.toLowerCase() === normalized);
+	            if (found.length === 0) {
+	                return null;
+	            }
+	            if (found.length === 1) {
+	                return found[0][1];
+	            }
+	            return found.map(([, value]) => value).join(', ');
+	        }
+	        else if (isHeadersLike(this.headersInit)) {
+	            return this.headersInit.get(normalized);
+	        }
+	        else {
+	            const initValue = this.headersInit[key] || this.headersInit[normalized];
+	            if (initValue != null) {
+	                return initValue;
+	            }
+	            if (!this.objectNormalizedKeysOfHeadersInit.length) {
+	                Object.keys(this.headersInit).forEach(k => {
+	                    this.objectOriginalKeysOfHeadersInit.push(k);
+	                    this.objectNormalizedKeysOfHeadersInit.push(k.toLowerCase());
+	                });
+	            }
+	            const index = this.objectNormalizedKeysOfHeadersInit.indexOf(normalized);
+	            if (index === -1) {
+	                return null;
+	            }
+	            const originalKey = this.objectOriginalKeysOfHeadersInit[index];
+	            return this.headersInit[originalKey];
+	        }
+	    }
+	    // perf: Build the map of headers lazily, only when we need to access all headers or write to it.
+	    // I could do a getter here, but I'm too lazy to type `getter`.
+	    getMap() {
+	        if (!this._map) {
+	            this._setCookies ||= [];
+	            if (this.headersInit != null) {
+	                if (Array.isArray(this.headersInit)) {
+	                    this._map = new Map();
+	                    for (const [key, value] of this.headersInit) {
+	                        const normalizedKey = key.toLowerCase();
+	                        if (normalizedKey === 'set-cookie') {
+	                            this._setCookies.push(value);
+	                            continue;
+	                        }
+	                        this._map.set(normalizedKey, value);
+	                    }
+	                }
+	                else if (isHeadersLike(this.headersInit)) {
+	                    this._map = new Map();
+	                    this.headersInit.forEach((value, key) => {
+	                        if (key === 'set-cookie') {
+	                            this._setCookies ||= [];
+	                            this._setCookies.push(value);
+	                            return;
+	                        }
+	                        this._map.set(key, value);
+	                    });
+	                }
+	                else {
+	                    this._map = new Map();
+	                    for (const initKey in this.headersInit) {
+	                        const initValue = this.headersInit[initKey];
+	                        if (initValue != null) {
+	                            const normalizedKey = initKey.toLowerCase();
+	                            if (normalizedKey === 'set-cookie') {
+	                                this._setCookies ||= [];
+	                                this._setCookies.push(initValue);
+	                                continue;
+	                            }
+	                            this._map.set(normalizedKey, initValue);
+	                        }
+	                    }
+	                }
+	            }
+	            else {
+	                this._map = new Map();
+	            }
+	        }
+	        return this._map;
+	    }
+	    append(name, value) {
+	        const key = name.toLowerCase();
+	        if (key === 'set-cookie') {
+	            this._setCookies ||= [];
+	            this._setCookies.push(value);
+	            return;
+	        }
+	        const existingValue = this.getMap().get(key);
+	        const finalValue = existingValue ? `${existingValue}, ${value}` : value;
+	        this.getMap().set(key, finalValue);
+	    }
+	    get(name) {
+	        const value = this._get(name);
+	        if (value == null) {
+	            return null;
+	        }
+	        return value.toString();
+	    }
+	    has(name) {
+	        const key = name.toLowerCase();
+	        if (key === 'set-cookie') {
+	            return !!this._setCookies?.length;
+	        }
+	        return !!this._get(name); // we might need to check if header exists and not just check if it's not nullable
+	    }
+	    set(name, value) {
+	        const key = name.toLowerCase();
+	        if (key === 'set-cookie') {
+	            this._setCookies = [value];
+	            return;
+	        }
+	        if (!this._map && this.headersInit != null) {
+	            if (Array.isArray(this.headersInit)) {
+	                const found = this.headersInit.find(([headerKey]) => headerKey.toLowerCase() === key);
+	                if (found) {
+	                    found[1] = value;
+	                }
+	                else {
+	                    this.headersInit.push([key, value]);
+	                }
+	                return;
+	            }
+	            else if (isHeadersLike(this.headersInit)) {
+	                this.headersInit.set(key, value);
+	                return;
+	            }
+	            else {
+	                this.headersInit[key] = value;
+	                return;
+	            }
+	        }
+	        this.getMap().set(key, value);
+	    }
+	    delete(name) {
+	        const key = name.toLowerCase();
+	        if (key === 'set-cookie') {
+	            this._setCookies = [];
+	            return;
+	        }
+	        this.getMap().delete(key);
+	    }
+	    forEach(callback) {
+	        this._setCookies?.forEach(setCookie => {
+	            callback(setCookie, 'set-cookie', this);
+	        });
+	        if (!this._map) {
+	            if (this.headersInit) {
+	                if (Array.isArray(this.headersInit)) {
+	                    this.headersInit.forEach(([key, value]) => {
+	                        callback(value, key, this);
+	                    });
+	                    return;
+	                }
+	                if (isHeadersLike(this.headersInit)) {
+	                    this.headersInit.forEach(callback);
+	                    return;
+	                }
+	                Object.entries(this.headersInit).forEach(([key, value]) => {
+	                    if (value != null) {
+	                        callback(value, key, this);
+	                    }
+	                });
+	            }
+	            return;
+	        }
+	        this.getMap().forEach((value, key) => {
+	            callback(value, key, this);
+	        });
+	    }
+	    *_keys() {
+	        if (this._setCookies?.length) {
+	            yield 'set-cookie';
+	        }
+	        if (!this._map) {
+	            if (this.headersInit) {
+	                if (Array.isArray(this.headersInit)) {
+	                    yield* this.headersInit.map(([key]) => key)[Symbol.iterator]();
+	                    return;
+	                }
+	                if (isHeadersLike(this.headersInit)) {
+	                    yield* this.headersInit.keys();
+	                    return;
+	                }
+	                yield* Object.keys(this.headersInit)[Symbol.iterator]();
+	                return;
+	            }
+	        }
+	        yield* this.getMap().keys();
+	    }
+	    keys() {
+	        return new IteratorObject_js_1.PonyfillIteratorObject(this._keys(), 'HeadersIterator');
+	    }
+	    *_values() {
+	        if (this._setCookies?.length) {
+	            yield* this._setCookies;
+	        }
+	        if (!this._map) {
+	            if (this.headersInit) {
+	                if (Array.isArray(this.headersInit)) {
+	                    yield* this.headersInit.map(([, value]) => value)[Symbol.iterator]();
+	                    return;
+	                }
+	                if (isHeadersLike(this.headersInit)) {
+	                    yield* this.headersInit.values();
+	                    return;
+	                }
+	                yield* Object.values(this.headersInit)[Symbol.iterator]();
+	                return;
+	            }
+	        }
+	        yield* this.getMap().values();
+	    }
+	    values() {
+	        return new IteratorObject_js_1.PonyfillIteratorObject(this._values(), 'HeadersIterator');
+	    }
+	    *_entries() {
+	        if (this._setCookies?.length) {
+	            yield* this._setCookies.map(cookie => ['set-cookie', cookie]);
+	        }
+	        if (!this._map) {
+	            if (this.headersInit) {
+	                if (Array.isArray(this.headersInit)) {
+	                    yield* this.headersInit;
+	                    return;
+	                }
+	                if (isHeadersLike(this.headersInit)) {
+	                    yield* this.headersInit.entries();
+	                    return;
+	                }
+	                yield* Object.entries(this.headersInit);
+	                return;
+	            }
+	        }
+	        yield* this.getMap().entries();
+	    }
+	    entries() {
+	        return new IteratorObject_js_1.PonyfillIteratorObject(this._entries(), 'HeadersIterator');
+	    }
+	    getSetCookie() {
+	        if (!this._setCookies) {
+	            this.getMap();
+	        }
+	        return this._setCookies;
+	    }
+	    [Symbol.iterator]() {
+	        return this.entries();
+	    }
+	    [Symbol.for('nodejs.util.inspect.custom')]() {
+	        const record = {};
+	        this.forEach((value, key) => {
+	            if (key === 'set-cookie') {
+	                record['set-cookie'] = this._setCookies || [];
+	            }
+	            else {
+	                record[key] = value?.includes(',') ? value.split(',').map(el => el.trim()) : value;
+	            }
+	        });
+	        return `Headers ${(0, node_util_1.inspect)(record)}`;
+	    }
+	}
+	Headers.PonyfillHeaders = PonyfillHeaders;
+	return Headers;
+}
+
+var hasRequiredResponse;
+
+function requireResponse () {
+	if (hasRequiredResponse) return Response;
+	hasRequiredResponse = 1;
+	Object.defineProperty(Response, "__esModule", { value: true });
+	Response.PonyfillResponse = void 0;
+	const node_http_1 = require$$0$3;
+	const Body_js_1 = requireBody();
+	const Headers_js_1 = requireHeaders();
+	const JSON_CONTENT_TYPE = 'application/json; charset=utf-8';
+	class PonyfillResponse extends Body_js_1.PonyfillBody {
+	    headers;
+	    constructor(body, init) {
+	        super(body || null, init);
+	        this.headers =
+	            init?.headers && (0, Headers_js_1.isHeadersLike)(init.headers)
+	                ? init.headers
+	                : new Headers_js_1.PonyfillHeaders(init?.headers);
+	        this.status = init?.status || 200;
+	        this.statusText = init?.statusText || node_http_1.STATUS_CODES[this.status] || 'OK';
+	        this.url = init?.url || '';
+	        this.redirected = init?.redirected || false;
+	        this.type = init?.type || 'default';
+	        this.handleContentLengthHeader();
+	    }
+	    get ok() {
+	        return this.status >= 200 && this.status < 300;
+	    }
+	    status;
+	    statusText;
+	    url;
+	    redirected;
+	    type;
+	    clone() {
+	        return this;
+	    }
+	    static error() {
+	        return new PonyfillResponse(null, {
+	            status: 500,
+	            statusText: 'Internal Server Error',
+	        });
+	    }
+	    static redirect(url, status = 302) {
+	        if (status < 300 || status > 399) {
+	            throw new RangeError('Invalid status code');
+	        }
+	        return new PonyfillResponse(null, {
+	            headers: {
+	                location: url,
+	            },
+	            status,
+	        });
+	    }
+	    static json(data, init) {
+	        const bodyInit = JSON.stringify(data);
+	        if (!init) {
+	            init = {
+	                headers: {
+	                    'content-type': JSON_CONTENT_TYPE,
+	                    'content-length': Buffer.byteLength(bodyInit).toString(),
+	                },
+	            };
+	        }
+	        else if (!init.headers) {
+	            init.headers = {
+	                'content-type': JSON_CONTENT_TYPE,
+	                'content-length': Buffer.byteLength(bodyInit).toString(),
+	            };
+	        }
+	        else if ((0, Headers_js_1.isHeadersLike)(init.headers)) {
+	            if (!init.headers.has('content-type')) {
+	                init.headers.set('content-type', JSON_CONTENT_TYPE);
+	            }
+	            if (!init.headers.has('content-length')) {
+	                init.headers.set('content-length', Buffer.byteLength(bodyInit).toString());
+	            }
+	        }
+	        else if (Array.isArray(init.headers)) {
+	            let contentTypeExists = false;
+	            let contentLengthExists = false;
+	            for (const [key] of init.headers) {
+	                if (contentLengthExists && contentTypeExists) {
+	                    break;
+	                }
+	                if (!contentTypeExists && key.toLowerCase() === 'content-type') {
+	                    contentTypeExists = true;
+	                }
+	                else if (!contentLengthExists && key.toLowerCase() === 'content-length') {
+	                    contentLengthExists = true;
+	                }
+	            }
+	            if (!contentTypeExists) {
+	                init.headers.push(['content-type', JSON_CONTENT_TYPE]);
+	            }
+	            if (!contentLengthExists) {
+	                init.headers.push(['content-length', Buffer.byteLength(bodyInit).toString()]);
+	            }
+	        }
+	        else if (typeof init.headers === 'object') {
+	            if (init.headers?.['content-type'] == null) {
+	                init.headers['content-type'] = JSON_CONTENT_TYPE;
+	            }
+	            if (init.headers?.['content-length'] == null) {
+	                init.headers['content-length'] = Buffer.byteLength(bodyInit).toString();
+	            }
+	        }
+	        return new PonyfillResponse(bodyInit, init);
+	    }
+	    [Symbol.toStringTag] = 'Response';
+	}
+	Response.PonyfillResponse = PonyfillResponse;
+	return Response;
+}
+
+var hasRequiredFetchCurl;
+
+function requireFetchCurl () {
+	if (hasRequiredFetchCurl) return fetchCurl;
+	hasRequiredFetchCurl = 1;
+	Object.defineProperty(fetchCurl, "__esModule", { value: true });
+	fetchCurl.fetchCurl = fetchCurl$1;
+	const node_stream_1 = require$$0$1;
+	const node_tls_1 = require$$1$2;
+	const promise_helpers_1 = require$$4;
+	const Response_js_1 = requireResponse();
+	const utils_js_1 = requireUtils();
+	function fetchCurl$1(fetchRequest) {
+	    const { Curl, CurlFeature, CurlPause, CurlProgressFunc } = globalThis['libcurl'];
+	    const curlHandle = new Curl();
+	    curlHandle.enable(CurlFeature.NoDataParsing);
+	    curlHandle.setOpt('URL', fetchRequest.url);
+	    if (process.env.NODE_TLS_REJECT_UNAUTHORIZED === '0') {
+	        curlHandle.setOpt('SSL_VERIFYPEER', false);
+	    }
+	    if (process.env.NODE_EXTRA_CA_CERTS) {
+	        curlHandle.setOpt('CAINFO', process.env.NODE_EXTRA_CA_CERTS);
+	    }
+	    else {
+	        curlHandle.setOpt('CAINFO_BLOB', node_tls_1.rootCertificates.join('\n'));
+	    }
+	    curlHandle.enable(CurlFeature.StreamResponse);
+	    let signal;
+	    if (fetchRequest._signal === null) {
+	        signal = undefined;
+	    }
+	    else if (fetchRequest._signal) {
+	        signal = fetchRequest._signal;
+	    }
+	    curlHandle.setStreamProgressCallback(function () {
+	        return signal?.aborted ? (process.env.DEBUG ? CurlProgressFunc.Continue : 1) : 0;
+	    });
+	    if (fetchRequest['bodyType'] === 'String') {
+	        curlHandle.setOpt('POSTFIELDS', fetchRequest['bodyInit']);
+	    }
+	    else {
+	        const nodeReadable = (fetchRequest.body != null
+	            ? (0, utils_js_1.isNodeReadable)(fetchRequest.body)
+	                ? fetchRequest.body
+	                : node_stream_1.Readable.from(fetchRequest.body)
+	            : null);
+	        if (nodeReadable) {
+	            curlHandle.setOpt('UPLOAD', true);
+	            curlHandle.setUploadStream(nodeReadable);
+	        }
+	    }
+	    if (process.env.DEBUG) {
+	        curlHandle.setOpt('VERBOSE', true);
+	    }
+	    curlHandle.setOpt('TRANSFER_ENCODING', false);
+	    curlHandle.setOpt('HTTP_TRANSFER_DECODING', true);
+	    curlHandle.setOpt('FOLLOWLOCATION', fetchRequest.redirect === 'follow');
+	    curlHandle.setOpt('MAXREDIRS', 20);
+	    curlHandle.setOpt('ACCEPT_ENCODING', '');
+	    curlHandle.setOpt('CUSTOMREQUEST', fetchRequest.method);
+	    const headersSerializer = fetchRequest.headersSerializer || utils_js_1.defaultHeadersSerializer;
+	    let size;
+	    const curlHeaders = headersSerializer(fetchRequest.headers, value => {
+	        size = Number(value);
+	    });
+	    if (size != null) {
+	        curlHandle.setOpt('INFILESIZE', size);
+	    }
+	    curlHandle.setOpt('HTTPHEADER', curlHeaders);
+	    curlHandle.enable(CurlFeature.NoHeaderParsing);
+	    const deferredPromise = (0, promise_helpers_1.createDeferredPromise)();
+	    let streamResolved;
+	    function onAbort() {
+	        if (curlHandle.isOpen) {
+	            try {
+	                curlHandle.pause(CurlPause.Recv);
+	            }
+	            catch (e) {
+	                deferredPromise.reject(e);
+	            }
+	        }
+	    }
+	    signal?.addEventListener('abort', onAbort, { once: true });
+	    curlHandle.once('end', function endListener() {
+	        try {
+	            curlHandle.close();
+	        }
+	        catch (e) {
+	            deferredPromise.reject(e);
+	        }
+	        signal?.removeEventListener('abort', onAbort);
+	    });
+	    curlHandle.once('error', function errorListener(error) {
+	        if (streamResolved && !streamResolved.closed && !streamResolved.destroyed) {
+	            streamResolved.destroy(error);
+	        }
+	        else {
+	            if (error.message === 'Operation was aborted by an application callback') {
+	                error.message = 'The operation was aborted.';
+	            }
+	            deferredPromise.reject(error);
+	        }
+	        try {
+	            curlHandle.close();
+	        }
+	        catch (e) {
+	            deferredPromise.reject(e);
+	        }
+	    });
+	    curlHandle.once('stream', function streamListener(stream, status, headersBuf) {
+	        const outputStream = stream.pipe(new node_stream_1.PassThrough(), {
+	            end: true,
+	        });
+	        const headersFlat = headersBuf
+	            .toString('utf8')
+	            .split(/\r?\n|\r/g)
+	            .filter(headerFilter => {
+	            if (headerFilter && !headerFilter.startsWith('HTTP/')) {
+	                if (fetchRequest.redirect === 'error' &&
+	                    headerFilter.toLowerCase().includes('location') &&
+	                    (0, utils_js_1.shouldRedirect)(status)) {
+	                    if (!stream.destroyed) {
+	                        stream.resume();
+	                    }
+	                    outputStream.destroy();
+	                    deferredPromise.reject(new Error('redirect is not allowed'));
+	                }
+	                return true;
+	            }
+	            return false;
+	        });
+	        const headersInit = headersFlat.map(headerFlat => headerFlat.split(/:\s(.+)/).slice(0, 2));
+	        const ponyfillResponse = new Response_js_1.PonyfillResponse(outputStream, {
+	            status,
+	            headers: headersInit,
+	            url: curlHandle.getInfo(Curl.info.REDIRECT_URL)?.toString() || fetchRequest.url,
+	            redirected: Number(curlHandle.getInfo(Curl.info.REDIRECT_COUNT)) > 0,
+	        });
+	        deferredPromise.resolve(ponyfillResponse);
+	        streamResolved = outputStream;
+	    });
+	    setImmediate(() => {
+	        curlHandle.perform();
+	    });
+	    return deferredPromise.promise;
+	}
+	return fetchCurl;
+}
+
+var fetchNodeHttp = {};
+
+var Request = {};
+
+var URL$2 = {};
+
+var hasRequiredURL;
+
+function requireURL () {
+	if (hasRequiredURL) return URL$2;
+	hasRequiredURL = 1;
+	Object.defineProperty(URL$2, "__esModule", { value: true });
+	URL$2.PonyfillURL = void 0;
+	const tslib_1 = require$$0$4;
+	const node_buffer_1 = tslib_1.__importDefault(require$$0$2);
+	const node_crypto_1 = require$$2;
+	const NativeURL = globalThis.URL;
+	class URL extends NativeURL {
+	    // This part is only needed to handle `PonyfillBlob` objects
+	    static blobRegistry = new Map();
+	    static createObjectURL(blob) {
+	        const blobUrl = `blob:whatwgnode:${(0, node_crypto_1.randomUUID)()}`;
+	        this.blobRegistry.set(blobUrl, blob);
+	        return blobUrl;
+	    }
+	    static revokeObjectURL(url) {
+	        if (!this.blobRegistry.has(url)) {
+	            NativeURL.revokeObjectURL(url);
+	        }
+	        else {
+	            this.blobRegistry.delete(url);
+	        }
+	    }
+	    static getBlobFromURL(url) {
+	        return (this.blobRegistry.get(url) || node_buffer_1.default?.resolveObjectURL?.(url));
+	    }
+	}
+	URL$2.PonyfillURL = URL;
+	return URL$2;
+}
+
+var hasRequiredRequest;
+
+function requireRequest () {
+	if (hasRequiredRequest) return Request;
+	hasRequiredRequest = 1;
+	Object.defineProperty(Request, "__esModule", { value: true });
+	Request.PonyfillRequest = void 0;
+	const node_http_1 = require$$0$3;
+	const node_https_1 = require$$1$3;
+	const Body_js_1 = requireBody();
+	const Headers_js_1 = requireHeaders();
+	const URL_js_1 = requireURL();
+	function isRequest(input) {
+	    return input[Symbol.toStringTag] === 'Request';
+	}
+	function isURL(obj) {
+	    return obj?.href != null;
+	}
+	class PonyfillRequest extends Body_js_1.PonyfillBody {
+	    constructor(input, options) {
+	        let _url;
+	        let _parsedUrl;
+	        let bodyInit = null;
+	        let requestInit;
+	        if (typeof input === 'string') {
+	            _url = input;
+	        }
+	        else if (isURL(input)) {
+	            _parsedUrl = input;
+	        }
+	        else if (isRequest(input)) {
+	            if (input._parsedUrl) {
+	                _parsedUrl = input._parsedUrl;
+	            }
+	            else if (input._url) {
+	                _url = input._url;
+	            }
+	            else {
+	                _url = input.url;
+	            }
+	            bodyInit = input.body;
+	            requestInit = input;
+	        }
+	        if (options != null) {
+	            bodyInit = options.body || null;
+	            requestInit = options;
+	        }
+	        super(bodyInit, requestInit);
+	        this._url = _url;
+	        this._parsedUrl = _parsedUrl;
+	        this.cache = requestInit?.cache || 'default';
+	        this.credentials = requestInit?.credentials || 'same-origin';
+	        this.headers =
+	            requestInit?.headers && (0, Headers_js_1.isHeadersLike)(requestInit.headers)
+	                ? requestInit.headers
+	                : new Headers_js_1.PonyfillHeaders(requestInit?.headers);
+	        this.integrity = requestInit?.integrity || '';
+	        this.keepalive = requestInit?.keepalive != null ? requestInit?.keepalive : false;
+	        this.method = requestInit?.method?.toUpperCase() || 'GET';
+	        this.mode = requestInit?.mode || 'cors';
+	        this.redirect = requestInit?.redirect || 'follow';
+	        this.referrer = requestInit?.referrer || 'about:client';
+	        this.referrerPolicy = requestInit?.referrerPolicy || 'no-referrer';
+	        this.headersSerializer = requestInit?.headersSerializer;
+	        this.duplex = requestInit?.duplex || 'half';
+	        this.destination = 'document';
+	        this.priority = 'auto';
+	        if (this.method !== 'GET' && this.method !== 'HEAD') {
+	            this.handleContentLengthHeader(true);
+	        }
+	        if (requestInit?.agent != null) {
+	            const protocol = _parsedUrl?.protocol || _url || this.url;
+	            if (requestInit.agent === false) {
+	                this.agent = false;
+	            }
+	            else if (protocol.startsWith('http:') && requestInit.agent instanceof node_http_1.Agent) {
+	                this.agent = requestInit.agent;
+	            }
+	            else if (protocol.startsWith('https:') && requestInit.agent instanceof node_https_1.Agent) {
+	                this.agent = requestInit.agent;
+	            }
+	        }
+	    }
+	    headersSerializer;
+	    cache;
+	    credentials;
+	    destination;
+	    headers;
+	    integrity;
+	    keepalive;
+	    method;
+	    mode;
+	    priority;
+	    redirect;
+	    referrer;
+	    referrerPolicy;
+	    _url;
+	    get signal() {
+	        this._signal ||= new AbortController().signal;
+	        return this._signal;
+	    }
+	    get url() {
+	        if (this._url == null) {
+	            if (this._parsedUrl) {
+	                this._url = this._parsedUrl.toString();
+	            }
+	            else {
+	                throw new TypeError('Invalid URL');
+	            }
+	        }
+	        return this._url;
+	    }
+	    _parsedUrl;
+	    get parsedUrl() {
+	        if (this._parsedUrl == null) {
+	            if (this._url != null) {
+	                this._parsedUrl = new URL_js_1.PonyfillURL(this._url, 'http://localhost');
+	            }
+	            else {
+	                throw new TypeError('Invalid URL');
+	            }
+	        }
+	        return this._parsedUrl;
+	    }
+	    duplex;
+	    agent;
+	    clone() {
+	        return this;
+	    }
+	    [Symbol.toStringTag] = 'Request';
+	}
+	Request.PonyfillRequest = PonyfillRequest;
+	return Request;
+}
+
+var hasRequiredFetchNodeHttp;
+
+function requireFetchNodeHttp () {
+	if (hasRequiredFetchNodeHttp) return fetchNodeHttp;
+	hasRequiredFetchNodeHttp = 1;
+	Object.defineProperty(fetchNodeHttp, "__esModule", { value: true });
+	fetchNodeHttp.fetchNodeHttp = fetchNodeHttp$1;
+	const node_http_1 = require$$0$3;
+	const node_https_1 = require$$1$3;
+	const node_stream_1 = require$$0$1;
+	const node_zlib_1 = require$$0$5;
+	const promise_helpers_1 = require$$4;
+	const Request_js_1 = requireRequest();
+	const Response_js_1 = requireResponse();
+	const URL_js_1 = requireURL();
+	const utils_js_1 = requireUtils();
+	function getRequestFnForProtocol(url) {
+	    if (url.startsWith('http:')) {
+	        return node_http_1.request;
+	    }
+	    else if (url.startsWith('https:')) {
+	        return node_https_1.request;
+	    }
+	    throw new Error(`Unsupported protocol: ${url.split(':')[0] || url}`);
+	}
+	function fetchNodeHttp$1(fetchRequest) {
+	    return new Promise((resolve, reject) => {
+	        try {
+	            const requestFn = getRequestFnForProtocol(fetchRequest.parsedUrl?.protocol || fetchRequest.url);
+	            const headersSerializer = fetchRequest.headersSerializer || utils_js_1.getHeadersObj;
+	            const nodeHeaders = headersSerializer(fetchRequest.headers);
+	            if (nodeHeaders['accept-encoding'] == null) {
+	                nodeHeaders['accept-encoding'] = 'gzip, deflate, br';
+	            }
+	            let signal;
+	            if (fetchRequest._signal == null) {
+	                signal = undefined;
+	            }
+	            else if (fetchRequest._signal) {
+	                signal = fetchRequest._signal;
+	            }
+	            let nodeRequest;
+	            // If it is our ponyfilled Request, it should have `parsedUrl` which is a `URL` object
+	            if (fetchRequest.parsedUrl) {
+	                nodeRequest = requestFn(fetchRequest.parsedUrl, {
+	                    method: fetchRequest.method,
+	                    headers: nodeHeaders,
+	                    signal,
+	                    agent: fetchRequest.agent,
+	                });
+	            }
+	            else {
+	                nodeRequest = requestFn(fetchRequest.url, {
+	                    method: fetchRequest.method,
+	                    headers: nodeHeaders,
+	                    signal,
+	                    agent: fetchRequest.agent,
+	                });
+	            }
+	            nodeRequest.once('error', reject);
+	            nodeRequest.once('response', nodeResponse => {
+	                let outputStream;
+	                const contentEncoding = nodeResponse.headers['content-encoding'];
+	                switch (contentEncoding) {
+	                    case 'x-gzip':
+	                    case 'gzip':
+	                        outputStream = (0, node_zlib_1.createGunzip)();
+	                        break;
+	                    case 'x-deflate':
+	                    case 'deflate':
+	                        outputStream = (0, node_zlib_1.createInflate)();
+	                        break;
+	                    case 'x-deflate-raw':
+	                    case 'deflate-raw':
+	                        outputStream = (0, node_zlib_1.createInflateRaw)();
+	                        break;
+	                    case 'br':
+	                        outputStream = (0, node_zlib_1.createBrotliDecompress)();
+	                        break;
+	                }
+	                if (nodeResponse.headers.location && (0, utils_js_1.shouldRedirect)(nodeResponse.statusCode)) {
+	                    if (fetchRequest.redirect === 'error') {
+	                        const redirectError = new Error('Redirects are not allowed');
+	                        reject(redirectError);
+	                        nodeResponse.resume();
+	                        return;
+	                    }
+	                    if (fetchRequest.redirect === 'follow') {
+	                        const redirectedUrl = new URL_js_1.PonyfillURL(nodeResponse.headers.location, fetchRequest.parsedUrl || fetchRequest.url);
+	                        const redirectResponse$ = fetchNodeHttp$1(new Request_js_1.PonyfillRequest(redirectedUrl, fetchRequest));
+	                        resolve(redirectResponse$.then(redirectResponse => {
+	                            redirectResponse.redirected = true;
+	                            return redirectResponse;
+	                        }));
+	                        nodeResponse.resume();
+	                        return;
+	                    }
+	                }
+	                outputStream ||= new node_stream_1.PassThrough();
+	                (0, utils_js_1.pipeThrough)({
+	                    src: nodeResponse,
+	                    dest: outputStream,
+	                    signal,
+	                    onError: e => {
+	                        if (!nodeResponse.destroyed) {
+	                            nodeResponse.destroy(e);
+	                        }
+	                        if (!outputStream.destroyed) {
+	                            outputStream.destroy(e);
+	                        }
+	                        reject(e);
+	                    },
+	                });
+	                const statusCode = nodeResponse.statusCode || 200;
+	                let statusText = nodeResponse.statusMessage || node_http_1.STATUS_CODES[statusCode];
+	                if (statusText == null) {
+	                    statusText = '';
+	                }
+	                const ponyfillResponse = new Response_js_1.PonyfillResponse(outputStream || nodeResponse, {
+	                    status: statusCode,
+	                    statusText,
+	                    headers: nodeResponse.headers,
+	                    url: fetchRequest.url,
+	                    signal,
+	                });
+	                resolve(ponyfillResponse);
+	            });
+	            if (fetchRequest['_buffer'] != null) {
+	                (0, promise_helpers_1.handleMaybePromise)(() => (0, utils_js_1.safeWrite)(fetchRequest['_buffer'], nodeRequest), () => (0, utils_js_1.endStream)(nodeRequest), reject);
+	            }
+	            else {
+	                const nodeReadable = (fetchRequest.body != null
+	                    ? (0, utils_js_1.isNodeReadable)(fetchRequest.body)
+	                        ? fetchRequest.body
+	                        : node_stream_1.Readable.from(fetchRequest.body)
+	                    : null);
+	                if (nodeReadable) {
+	                    nodeReadable.pipe(nodeRequest);
+	                }
+	                else {
+	                    (0, utils_js_1.endStream)(nodeRequest);
+	                }
+	            }
+	        }
+	        catch (e) {
+	            reject(e);
+	        }
+	    });
+	}
+	return fetchNodeHttp;
+}
+
+var hasRequiredFetch;
+
+function requireFetch () {
+	if (hasRequiredFetch) return fetch;
+	hasRequiredFetch = 1;
+	Object.defineProperty(fetch, "__esModule", { value: true });
+	fetch.fetchPonyfill = fetchPonyfill;
+	const node_buffer_1 = require$$0$2;
+	const node_fs_1 = require$$1$4;
+	const node_url_1 = require$$2$1;
+	const fetchCurl_js_1 = requireFetchCurl();
+	const fetchNodeHttp_js_1 = requireFetchNodeHttp();
+	const Request_js_1 = requireRequest();
+	const Response_js_1 = requireResponse();
+	const URL_js_1 = requireURL();
+	const utils_js_1 = requireUtils();
+	const BASE64_SUFFIX = ';base64';
+	async function getResponseForFile(url) {
+	    const path = (0, node_url_1.fileURLToPath)(url);
+	    try {
+	        await node_fs_1.promises.access(path, node_fs_1.promises.constants.R_OK);
+	        const stats = await node_fs_1.promises.stat(path, {
+	            bigint: true,
+	        });
+	        const readable = (0, node_fs_1.createReadStream)(path);
+	        return new Response_js_1.PonyfillResponse(readable, {
+	            status: 200,
+	            statusText: 'OK',
+	            headers: {
+	                'content-type': 'application/octet-stream',
+	                'last-modified': stats.mtime.toUTCString(),
+	            },
+	        });
+	    }
+	    catch (err) {
+	        if (err.code === 'ENOENT') {
+	            return new Response_js_1.PonyfillResponse(null, {
+	                status: 404,
+	                statusText: 'Not Found',
+	            });
+	        }
+	        else if (err.code === 'EACCES') {
+	            return new Response_js_1.PonyfillResponse(null, {
+	                status: 403,
+	                statusText: 'Forbidden',
+	            });
+	        }
+	        throw err;
+	    }
+	}
+	function getResponseForDataUri(url) {
+	    const [mimeType = 'text/plain', ...datas] = url.substring(5).split(',');
+	    const data = decodeURIComponent(datas.join(','));
+	    if (mimeType.endsWith(BASE64_SUFFIX)) {
+	        const buffer = node_buffer_1.Buffer.from(data, 'base64url');
+	        const realMimeType = mimeType.slice(0, -BASE64_SUFFIX.length);
+	        return new Response_js_1.PonyfillResponse(buffer, {
+	            status: 200,
+	            statusText: 'OK',
+	            headers: {
+	                'content-type': realMimeType,
+	            },
+	        });
+	    }
+	    return new Response_js_1.PonyfillResponse(data, {
+	        status: 200,
+	        statusText: 'OK',
+	        headers: {
+	            'content-type': mimeType,
+	        },
+	    });
+	}
+	function getResponseForBlob(url) {
+	    const blob = URL_js_1.PonyfillURL.getBlobFromURL(url);
+	    if (!blob) {
+	        throw new TypeError('Invalid Blob URL');
+	    }
+	    return new Response_js_1.PonyfillResponse(blob, {
+	        status: 200,
+	        headers: {
+	            'content-type': blob.type,
+	            'content-length': blob.size.toString(),
+	        },
+	    });
+	}
+	function isURL(obj) {
+	    return obj != null && obj.href != null;
+	}
+	function fetchPonyfill(info, init) {
+	    if (typeof info === 'string' || isURL(info)) {
+	        const ponyfillRequest = new Request_js_1.PonyfillRequest(info, init);
+	        return fetchPonyfill(ponyfillRequest);
+	    }
+	    const fetchRequest = info;
+	    if (fetchRequest.url.startsWith('data:')) {
+	        const response = getResponseForDataUri(fetchRequest.url);
+	        return (0, utils_js_1.fakePromise)(response);
+	    }
+	    if (fetchRequest.url.startsWith('file:')) {
+	        const response = getResponseForFile(fetchRequest.url);
+	        return response;
+	    }
+	    if (fetchRequest.url.startsWith('blob:')) {
+	        const response = getResponseForBlob(fetchRequest.url);
+	        return (0, utils_js_1.fakePromise)(response);
+	    }
+	    if (globalThis.libcurl && !fetchRequest.agent) {
+	        return (0, fetchCurl_js_1.fetchCurl)(fetchRequest);
+	    }
+	    return (0, fetchNodeHttp_js_1.fetchNodeHttp)(fetchRequest);
+	}
+	return fetch;
+}
+
+var TextEncoderDecoder = {};
+
+var hasRequiredTextEncoderDecoder;
+
+function requireTextEncoderDecoder () {
+	if (hasRequiredTextEncoderDecoder) return TextEncoderDecoder;
+	hasRequiredTextEncoderDecoder = 1;
+	Object.defineProperty(TextEncoderDecoder, "__esModule", { value: true });
+	TextEncoderDecoder.PonyfillTextDecoder = TextEncoderDecoder.PonyfillTextEncoder = void 0;
+	TextEncoderDecoder.PonyfillBtoa = PonyfillBtoa;
+	const node_buffer_1 = require$$0$2;
+	const utils_js_1 = requireUtils();
+	class PonyfillTextEncoder {
+	    encoding;
+	    constructor(encoding = 'utf-8') {
+	        this.encoding = encoding;
+	    }
+	    encode(input) {
+	        return node_buffer_1.Buffer.from(input, this.encoding);
+	    }
+	    encodeInto(source, destination) {
+	        const buffer = this.encode(source);
+	        const copied = buffer.copy(destination);
+	        return {
+	            read: copied,
+	            written: copied,
+	        };
+	    }
+	}
+	TextEncoderDecoder.PonyfillTextEncoder = PonyfillTextEncoder;
+	class PonyfillTextDecoder {
+	    encoding;
+	    fatal = false;
+	    ignoreBOM = false;
+	    constructor(encoding = 'utf-8', options) {
+	        this.encoding = encoding;
+	        if (options) {
+	            this.fatal = options.fatal || false;
+	            this.ignoreBOM = options.ignoreBOM || false;
+	        }
+	    }
+	    decode(input) {
+	        if (node_buffer_1.Buffer.isBuffer(input)) {
+	            return input.toString(this.encoding);
+	        }
+	        if ((0, utils_js_1.isArrayBufferView)(input)) {
+	            return node_buffer_1.Buffer.from(input.buffer, input.byteOffset, input.byteLength).toString(this.encoding);
+	        }
+	        return node_buffer_1.Buffer.from(input).toString(this.encoding);
+	    }
+	}
+	TextEncoderDecoder.PonyfillTextDecoder = PonyfillTextDecoder;
+	function PonyfillBtoa(input) {
+	    return node_buffer_1.Buffer.from(input, 'binary').toString('base64');
+	}
+	return TextEncoderDecoder;
+}
+
+var URLSearchParams = {};
+
+var hasRequiredURLSearchParams;
+
+function requireURLSearchParams () {
+	if (hasRequiredURLSearchParams) return URLSearchParams;
+	hasRequiredURLSearchParams = 1;
+	Object.defineProperty(URLSearchParams, "__esModule", { value: true });
+	URLSearchParams.PonyfillURLSearchParams = void 0;
+	URLSearchParams.PonyfillURLSearchParams = globalThis.URLSearchParams;
+	return URLSearchParams;
+}
+
+var WritableStream = {};
+
+var hasRequiredWritableStream;
+
+function requireWritableStream () {
+	if (hasRequiredWritableStream) return WritableStream;
+	hasRequiredWritableStream = 1;
+	Object.defineProperty(WritableStream, "__esModule", { value: true });
+	WritableStream.PonyfillWritableStream = void 0;
+	const node_events_1 = require$$0;
+	const node_stream_1 = require$$0$1;
+	const promise_helpers_1 = require$$4;
+	const utils_js_1 = requireUtils();
+	class PonyfillWritableStream {
+	    writable;
+	    constructor(underlyingSink) {
+	        if (underlyingSink instanceof node_stream_1.Writable) {
+	            this.writable = underlyingSink;
+	        }
+	        else if (underlyingSink) {
+	            const writable = new node_stream_1.Writable({
+	                write(chunk, _encoding, callback) {
+	                    try {
+	                        const result = underlyingSink.write?.(chunk, controller);
+	                        if (result instanceof Promise) {
+	                            result.then(() => {
+	                                callback();
+	                            }, err => {
+	                                callback(err);
+	                            });
+	                        }
+	                        else {
+	                            callback();
+	                        }
+	                    }
+	                    catch (err) {
+	                        callback(err);
+	                    }
+	                },
+	                final(callback) {
+	                    const result = underlyingSink.close?.();
+	                    if (result instanceof Promise) {
+	                        result.then(() => {
+	                            callback();
+	                        }, err => {
+	                            callback(err);
+	                        });
+	                    }
+	                    else {
+	                        callback();
+	                    }
+	                },
+	            });
+	            this.writable = writable;
+	            const abortCtrl = new AbortController();
+	            const controller = {
+	                signal: abortCtrl.signal,
+	                error(e) {
+	                    writable.destroy(e);
+	                },
+	            };
+	            writable.once('error', err => abortCtrl.abort(err));
+	            writable.once('close', () => abortCtrl.abort());
+	        }
+	        else {
+	            this.writable = new node_stream_1.Writable();
+	        }
+	    }
+	    getWriter() {
+	        const writable = this.writable;
+	        return {
+	            get closed() {
+	                return (0, node_events_1.once)(writable, 'close');
+	            },
+	            get desiredSize() {
+	                return writable.writableLength;
+	            },
+	            get ready() {
+	                return (0, node_events_1.once)(writable, 'drain');
+	            },
+	            releaseLock() {
+	                // no-op
+	            },
+	            write(chunk) {
+	                const promise = (0, utils_js_1.fakePromise)();
+	                if (chunk == null) {
+	                    return promise;
+	                }
+	                return promise.then(() => (0, utils_js_1.safeWrite)(chunk, writable));
+	            },
+	            close() {
+	                if (!writable.errored && writable.closed) {
+	                    return (0, utils_js_1.fakePromise)();
+	                }
+	                if (writable.errored) {
+	                    return (0, promise_helpers_1.fakeRejectPromise)(writable.errored);
+	                }
+	                return (0, utils_js_1.fakePromise)().then(() => (0, utils_js_1.endStream)(writable));
+	            },
+	            abort(reason) {
+	                writable.destroy(reason);
+	                return (0, node_events_1.once)(writable, 'close');
+	            },
+	        };
+	    }
+	    close() {
+	        if (!this.writable.errored && this.writable.closed) {
+	            return (0, utils_js_1.fakePromise)();
+	        }
+	        if (this.writable.errored) {
+	            return (0, promise_helpers_1.fakeRejectPromise)(this.writable.errored);
+	        }
+	        return (0, utils_js_1.fakePromise)().then(() => (0, utils_js_1.endStream)(this.writable));
+	    }
+	    abort(reason) {
+	        this.writable.destroy(reason);
+	        return (0, node_events_1.once)(this.writable, 'close');
+	    }
+	    locked = false;
+	}
+	WritableStream.PonyfillWritableStream = PonyfillWritableStream;
+	return WritableStream;
+}
+
+var TransformStream = {};
+
+var hasRequiredTransformStream;
+
+function requireTransformStream () {
+	if (hasRequiredTransformStream) return TransformStream;
+	hasRequiredTransformStream = 1;
+	Object.defineProperty(TransformStream, "__esModule", { value: true });
+	TransformStream.PonyfillTransformStream = void 0;
+	const node_stream_1 = require$$0$1;
+	const ReadableStream_js_1 = requireReadableStream();
+	const utils_js_1 = requireUtils();
+	const WritableStream_js_1 = requireWritableStream();
+	class PonyfillTransformStream {
+	    transform;
+	    writable;
+	    readable;
+	    constructor(transformer) {
+	        if (transformer instanceof node_stream_1.Transform) {
+	            this.transform = transformer;
+	        }
+	        else if (transformer) {
+	            const controller = {
+	                enqueue(chunk) {
+	                    transform.push(chunk);
+	                },
+	                error(reason) {
+	                    transform.destroy(reason);
+	                },
+	                terminate() {
+	                    (0, utils_js_1.endStream)(transform);
+	                },
+	                get desiredSize() {
+	                    return transform.writableLength;
+	                },
+	            };
+	            const transform = new node_stream_1.Transform({
+	                read() { },
+	                write(chunk, _encoding, callback) {
+	                    try {
+	                        const result = transformer.transform?.(chunk, controller);
+	                        if (result instanceof Promise) {
+	                            result.then(() => {
+	                                callback();
+	                            }, err => {
+	                                callback(err);
+	                            });
+	                        }
+	                        else {
+	                            callback();
+	                        }
+	                    }
+	                    catch (err) {
+	                        callback(err);
+	                    }
+	                },
+	                final(callback) {
+	                    try {
+	                        const result = transformer.flush?.(controller);
+	                        if (result instanceof Promise) {
+	                            result.then(() => {
+	                                callback();
+	                            }, err => {
+	                                callback(err);
+	                            });
+	                        }
+	                        else {
+	                            callback();
+	                        }
+	                    }
+	                    catch (err) {
+	                        callback(err);
+	                    }
+	                },
+	            });
+	            this.transform = transform;
+	        }
+	        else {
+	            this.transform = new node_stream_1.Transform();
+	        }
+	        this.writable = new WritableStream_js_1.PonyfillWritableStream(this.transform);
+	        this.readable = new ReadableStream_js_1.PonyfillReadableStream(this.transform);
+	    }
+	}
+	TransformStream.PonyfillTransformStream = PonyfillTransformStream;
+	return TransformStream;
+}
+
+var CompressionStream = {};
+
+var hasRequiredCompressionStream;
+
+function requireCompressionStream () {
+	if (hasRequiredCompressionStream) return CompressionStream;
+	hasRequiredCompressionStream = 1;
+	Object.defineProperty(CompressionStream, "__esModule", { value: true });
+	CompressionStream.PonyfillCompressionStream = void 0;
+	const node_zlib_1 = require$$0$5;
+	const TransformStream_js_1 = requireTransformStream();
+	class PonyfillCompressionStream extends TransformStream_js_1.PonyfillTransformStream {
+	    static supportedFormats = globalThis.process?.version?.startsWith('v2')
+	        ? ['gzip', 'deflate', 'br']
+	        : ['gzip', 'deflate', 'deflate-raw', 'br'];
+	    constructor(compressionFormat) {
+	        switch (compressionFormat) {
+	            case 'x-gzip':
+	            case 'gzip':
+	                super((0, node_zlib_1.createGzip)());
+	                break;
+	            case 'x-deflate':
+	            case 'deflate':
+	                super((0, node_zlib_1.createDeflate)());
+	                break;
+	            case 'deflate-raw':
+	                super((0, node_zlib_1.createDeflateRaw)());
+	                break;
+	            case 'br':
+	                super((0, node_zlib_1.createBrotliCompress)());
+	                break;
+	            default:
+	                throw new Error(`Unsupported compression format: ${compressionFormat}`);
+	        }
+	    }
+	}
+	CompressionStream.PonyfillCompressionStream = PonyfillCompressionStream;
+	return CompressionStream;
+}
+
+var DecompressionStream = {};
+
+var hasRequiredDecompressionStream;
+
+function requireDecompressionStream () {
+	if (hasRequiredDecompressionStream) return DecompressionStream;
+	hasRequiredDecompressionStream = 1;
+	Object.defineProperty(DecompressionStream, "__esModule", { value: true });
+	DecompressionStream.PonyfillDecompressionStream = void 0;
+	const node_zlib_1 = require$$0$5;
+	const TransformStream_js_1 = requireTransformStream();
+	class PonyfillDecompressionStream extends TransformStream_js_1.PonyfillTransformStream {
+	    static supportedFormats = globalThis.process?.version?.startsWith('v2')
+	        ? ['gzip', 'deflate', 'br']
+	        : ['gzip', 'deflate', 'deflate-raw', 'br'];
+	    constructor(compressionFormat) {
+	        switch (compressionFormat) {
+	            case 'x-gzip':
+	            case 'gzip':
+	                super((0, node_zlib_1.createGunzip)());
+	                break;
+	            case 'x-deflate':
+	            case 'deflate':
+	                super((0, node_zlib_1.createInflate)());
+	                break;
+	            case 'deflate-raw':
+	                super((0, node_zlib_1.createInflateRaw)());
+	                break;
+	            case 'br':
+	                super((0, node_zlib_1.createBrotliDecompress)());
+	                break;
+	            default:
+	                throw new TypeError(`Unsupported compression format: '${compressionFormat}'`);
+	        }
+	    }
+	}
+	DecompressionStream.PonyfillDecompressionStream = PonyfillDecompressionStream;
+	return DecompressionStream;
+}
+
+var TextEncoderDecoderStream = {};
+
+var hasRequiredTextEncoderDecoderStream;
+
+function requireTextEncoderDecoderStream () {
+	if (hasRequiredTextEncoderDecoderStream) return TextEncoderDecoderStream;
+	hasRequiredTextEncoderDecoderStream = 1;
+	Object.defineProperty(TextEncoderDecoderStream, "__esModule", { value: true });
+	TextEncoderDecoderStream.PonyfillTextEncoderStream = TextEncoderDecoderStream.PonyfillTextDecoderStream = void 0;
+	const TextEncoderDecoder_js_1 = requireTextEncoderDecoder();
+	const TransformStream_js_1 = requireTransformStream();
+	class PonyfillTextDecoderStream extends TransformStream_js_1.PonyfillTransformStream {
+	    textDecoder;
+	    constructor(encoding, options) {
+	        super({
+	            transform: (chunk, controller) => controller.enqueue(this.textDecoder.decode(chunk, { stream: true })),
+	        });
+	        this.textDecoder = new TextEncoderDecoder_js_1.PonyfillTextDecoder(encoding, options);
+	    }
+	    get encoding() {
+	        return this.textDecoder.encoding;
+	    }
+	    get fatal() {
+	        return this.textDecoder.fatal;
+	    }
+	    get ignoreBOM() {
+	        return this.textDecoder.ignoreBOM;
+	    }
+	}
+	TextEncoderDecoderStream.PonyfillTextDecoderStream = PonyfillTextDecoderStream;
+	class PonyfillTextEncoderStream extends TransformStream_js_1.PonyfillTransformStream {
+	    textEncoder;
+	    constructor(encoding) {
+	        super({
+	            transform: (chunk, controller) => controller.enqueue(this.textEncoder.encode(chunk)),
+	        });
+	        this.textEncoder = new TextEncoderDecoder_js_1.PonyfillTextEncoder(encoding);
+	    }
+	    get encoding() {
+	        return this.textEncoder.encoding;
+	    }
+	    encode(input) {
+	        return this.textEncoder.encode(input);
+	    }
+	}
+	TextEncoderDecoderStream.PonyfillTextEncoderStream = PonyfillTextEncoderStream;
+	return TextEncoderDecoderStream;
+}
+
+var hasRequiredCjs;
+
+function requireCjs () {
+	if (hasRequiredCjs) return cjs;
+	hasRequiredCjs = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.TextEncoderStream = exports.TextDecoderStream = exports.IteratorObject = exports.DecompressionStream = exports.CompressionStream = exports.TransformStream = exports.WritableStream = exports.URLSearchParams = exports.URL = exports.btoa = exports.TextDecoder = exports.TextEncoder = exports.Blob = exports.FormData = exports.File = exports.ReadableStream = exports.Response = exports.Request = exports.Body = exports.Headers = exports.fetch = void 0;
+		var fetch_js_1 = requireFetch();
+		Object.defineProperty(exports, "fetch", { enumerable: true, get: function () { return fetch_js_1.fetchPonyfill; } });
+		var Headers_js_1 = requireHeaders();
+		Object.defineProperty(exports, "Headers", { enumerable: true, get: function () { return Headers_js_1.PonyfillHeaders; } });
+		var Body_js_1 = requireBody();
+		Object.defineProperty(exports, "Body", { enumerable: true, get: function () { return Body_js_1.PonyfillBody; } });
+		var Request_js_1 = requireRequest();
+		Object.defineProperty(exports, "Request", { enumerable: true, get: function () { return Request_js_1.PonyfillRequest; } });
+		var Response_js_1 = requireResponse();
+		Object.defineProperty(exports, "Response", { enumerable: true, get: function () { return Response_js_1.PonyfillResponse; } });
+		var ReadableStream_js_1 = requireReadableStream();
+		Object.defineProperty(exports, "ReadableStream", { enumerable: true, get: function () { return ReadableStream_js_1.PonyfillReadableStream; } });
+		var File_js_1 = requireFile();
+		Object.defineProperty(exports, "File", { enumerable: true, get: function () { return File_js_1.PonyfillFile; } });
+		var FormData_js_1 = requireFormData();
+		Object.defineProperty(exports, "FormData", { enumerable: true, get: function () { return FormData_js_1.PonyfillFormData; } });
+		var Blob_js_1 = requireBlob();
+		Object.defineProperty(exports, "Blob", { enumerable: true, get: function () { return Blob_js_1.PonyfillBlob; } });
+		var TextEncoderDecoder_js_1 = requireTextEncoderDecoder();
+		Object.defineProperty(exports, "TextEncoder", { enumerable: true, get: function () { return TextEncoderDecoder_js_1.PonyfillTextEncoder; } });
+		Object.defineProperty(exports, "TextDecoder", { enumerable: true, get: function () { return TextEncoderDecoder_js_1.PonyfillTextDecoder; } });
+		Object.defineProperty(exports, "btoa", { enumerable: true, get: function () { return TextEncoderDecoder_js_1.PonyfillBtoa; } });
+		var URL_js_1 = requireURL();
+		Object.defineProperty(exports, "URL", { enumerable: true, get: function () { return URL_js_1.PonyfillURL; } });
+		var URLSearchParams_js_1 = requireURLSearchParams();
+		Object.defineProperty(exports, "URLSearchParams", { enumerable: true, get: function () { return URLSearchParams_js_1.PonyfillURLSearchParams; } });
+		var WritableStream_js_1 = requireWritableStream();
+		Object.defineProperty(exports, "WritableStream", { enumerable: true, get: function () { return WritableStream_js_1.PonyfillWritableStream; } });
+		var TransformStream_js_1 = requireTransformStream();
+		Object.defineProperty(exports, "TransformStream", { enumerable: true, get: function () { return TransformStream_js_1.PonyfillTransformStream; } });
+		var CompressionStream_js_1 = requireCompressionStream();
+		Object.defineProperty(exports, "CompressionStream", { enumerable: true, get: function () { return CompressionStream_js_1.PonyfillCompressionStream; } });
+		var DecompressionStream_js_1 = requireDecompressionStream();
+		Object.defineProperty(exports, "DecompressionStream", { enumerable: true, get: function () { return DecompressionStream_js_1.PonyfillDecompressionStream; } });
+		var IteratorObject_js_1 = requireIteratorObject();
+		Object.defineProperty(exports, "IteratorObject", { enumerable: true, get: function () { return IteratorObject_js_1.PonyfillIteratorObject; } });
+		var TextEncoderDecoderStream_js_1 = requireTextEncoderDecoderStream();
+		Object.defineProperty(exports, "TextDecoderStream", { enumerable: true, get: function () { return TextEncoderDecoderStream_js_1.PonyfillTextDecoderStream; } });
+		Object.defineProperty(exports, "TextEncoderStream", { enumerable: true, get: function () { return TextEncoderDecoderStream_js_1.PonyfillTextEncoderStream; } }); 
+	} (cjs));
+	return cjs;
+}
+
+const shouldSkipPonyfill$1 = shouldSkipPonyfill$2;
+let newNodeFetch;
+
+var createNodePonyfill$1 = function createNodePonyfill(opts = {}) {
+  const ponyfills = {};
+  
+  ponyfills.URLPattern = globalThis.URLPattern;
+
+  // We call this previously to patch `Bun`
+  if (!ponyfills.URLPattern) {
+    const urlPatternModule = requireUrlpatternPolyfill();
+    ponyfills.URLPattern = urlPatternModule.URLPattern;
+  }
+
+  if (opts.skipPonyfill || shouldSkipPonyfill$1()) {
+    return {
+      fetch: globalThis.fetch,
+      Headers: globalThis.Headers,
+      Request: globalThis.Request,
+      Response: globalThis.Response,
+      FormData: globalThis.FormData,
+      ReadableStream: globalThis.ReadableStream,
+      WritableStream: globalThis.WritableStream,
+      TransformStream: globalThis.TransformStream,
+      CompressionStream: globalThis.CompressionStream,
+      DecompressionStream: globalThis.DecompressionStream,
+      TextDecoderStream: globalThis.TextDecoderStream,
+      TextEncoderStream: globalThis.TextEncoderStream,
+      Blob: globalThis.Blob,
+      File: globalThis.File,
+      crypto: globalThis.crypto,
+      btoa: globalThis.btoa,
+      TextEncoder: globalThis.TextEncoder,
+      TextDecoder: globalThis.TextDecoder,
+      URLPattern: ponyfills.URLPattern,
+      URL: globalThis.URL,
+      URLSearchParams: globalThis.URLSearchParams
+    };
+  }
+
+  newNodeFetch ||= requireCjs();
+
+  ponyfills.fetch = newNodeFetch.fetch;
+  ponyfills.Request = newNodeFetch.Request;
+  ponyfills.Response = newNodeFetch.Response;
+  ponyfills.Headers = newNodeFetch.Headers;
+  ponyfills.FormData = newNodeFetch.FormData;
+  ponyfills.ReadableStream = newNodeFetch.ReadableStream;
+
+  ponyfills.URL = newNodeFetch.URL;
+  ponyfills.URLSearchParams = newNodeFetch.URLSearchParams;
+
+  ponyfills.WritableStream = newNodeFetch.WritableStream;
+  ponyfills.TransformStream = newNodeFetch.TransformStream;
+  ponyfills.CompressionStream = newNodeFetch.CompressionStream;
+  ponyfills.DecompressionStream = newNodeFetch.DecompressionStream;
+  ponyfills.TextDecoderStream = newNodeFetch.TextDecoderStream;
+  ponyfills.TextEncoderStream = newNodeFetch.TextEncoderStream;
+
+  ponyfills.Blob = newNodeFetch.Blob;
+  ponyfills.File = newNodeFetch.File;
+  ponyfills.crypto = globalThis.crypto;
+  ponyfills.btoa = newNodeFetch.btoa;
+  ponyfills.TextEncoder = newNodeFetch.TextEncoder;
+  ponyfills.TextDecoder = newNodeFetch.TextDecoder;
+
+  if (opts.formDataLimits) {
+    ponyfills.Body = class Body extends newNodeFetch.Body {
+      constructor(body, userOpts) {
+        super(body, {
+          formDataLimits: opts.formDataLimits,
+          ...userOpts,
+        });
+      }
+    };
+    ponyfills.Request = class Request extends newNodeFetch.Request {
+      constructor(input, userOpts) {
+        super(input, {
+          formDataLimits: opts.formDataLimits,
+          ...userOpts,
+        });
+      }
+    };
+    ponyfills.Response = class Response extends newNodeFetch.Response {
+      constructor(body, userOpts) {
+        super(body, {
+          formDataLimits: opts.formDataLimits,
+          ...userOpts,
+        });
+      }
+    };
+  }
+
+  if (!ponyfills.crypto) {
+    const cryptoModule = require$$3$1;
+    ponyfills.crypto = cryptoModule.webcrypto;
+  }
+
+  return ponyfills;
+};
+
+const createNodePonyfill = createNodePonyfill$1;
+const shouldSkipPonyfill = shouldSkipPonyfill$2;
+const ponyfills = createNodePonyfill();
+
+if (!shouldSkipPonyfill()) {
+  try {
+    const nodelibcurlName = 'node-libcurl';
+    globalThis.libcurl = globalThis.libcurl || commonjsRequire(nodelibcurlName);
+  } catch (e) { }
+}
+
+ponyfills.fetch;
+ponyfills.Headers;
+ponyfills.Request;
+ponyfills.Response;
+ponyfills.FormData;
+ponyfills.ReadableStream;
+ponyfills.WritableStream;
+ponyfills.TransformStream;
+ponyfills.CompressionStream;
+ponyfills.DecompressionStream;
+ponyfills.TextDecoderStream;
+ponyfills.TextEncoderStream;
+ponyfills.Blob;
+ponyfills.File;
+ponyfills.crypto;
+ponyfills.btoa;
+ponyfills.TextEncoder;
+ponyfills.TextDecoder;
+ponyfills.URLPattern;
+var URL$1 = ponyfills.URL;
+ponyfills.URLSearchParams;
+
 function checkIfDataSatisfiesSelectionSet(selectionSet, data) {
   if (Array.isArray(data)) {
     return data.every(
@@ -327,6 +5172,33 @@ function getDirectiveNameForFederationDirective({
   }
   return normalizedDirectiveName;
 }
+const specs = [
+  function extractPersistedOperationIdByApolloSpec(params) {
+    if (params.extensions != null && typeof params.extensions === "object" && params.extensions?.["persistedQuery"] != null && typeof params.extensions?.["persistedQuery"] === "object" && params.extensions?.["persistedQuery"]?.["version"] === 1 && typeof params.extensions?.["persistedQuery"]?.["sha256Hash"] === "string") {
+      return params.extensions?.["persistedQuery"]?.["sha256Hash"];
+    }
+    return null;
+  },
+  function extractPersistedOperationIdByHiveSpec(params, request, _context) {
+    if ("documentId" in params && typeof params.documentId === "string") {
+      return params.documentId;
+    }
+    const documentId = new URL$1(request.url).searchParams.get("documentId");
+    if (documentId) {
+      return documentId;
+    }
+    return null;
+  }
+];
+const defaultExtractPersistedOperationId = function defaultExtractPersistedOperationId2(params, request, context) {
+  for (const spec of specs) {
+    const id = spec(params, request, context);
+    if (id) {
+      return id;
+    }
+  }
+  return null;
+};
 
 const defaultLoadedPlacePrefix = "GraphOS Managed Federation";
 function decideMaxRetries({
@@ -1986,6 +6858,7 @@ function createGatewayRuntime(config) {
     });
   } else if (config.persistedDocuments && "getPersistedOperation" in config.persistedDocuments) {
     const plugin = usePersistedOperations({
+      extractPersistedOperationId: defaultExtractPersistedOperationId,
       ...configContext,
       ...config.persistedDocuments
     });