dependabot[bot]
a24c74ee75
* build(deps-dev): bump listhen from 1.1.2 to 1.2.2 Bumps [listhen](https://github.com/unjs/listhen) from 1.1.2 to 1.2.2. - [Release notes](https://github.com/unjs/listhen/releases) - [Changelog](https://github.com/unjs/listhen/blob/main/CHANGELOG.md) - [Commits](https://github.com/unjs/listhen/compare/v1.1.2...v1.2.2) --- updated-dependencies: - dependency-name: listhen dependency-type: direct:development update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com> * Rebuild mockserver with new dependencies --------- Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Iain Sproat <68657+iainsproat@users.noreply.github.com>
3872 lines
109 KiB
JavaScript
Generated
3872 lines
109 KiB
JavaScript
Generated
export const id = 683;
|
|
export const ids = [683];
|
|
export const modules = {
|
|
|
|
/***/ 3683:
|
|
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
|
|
|
|
// ESM COMPAT FLAG
|
|
__webpack_require__.r(__webpack_exports__);
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
"H3Error": () => (/* binding */ H3Error),
|
|
"H3Event": () => (/* binding */ H3Event),
|
|
"H3Headers": () => (/* binding */ H3Headers),
|
|
"H3Response": () => (/* binding */ H3Response),
|
|
"MIMES": () => (/* binding */ MIMES),
|
|
"appendCorsHeaders": () => (/* binding */ appendCorsHeaders),
|
|
"appendCorsPreflightHeaders": () => (/* binding */ appendCorsPreflightHeaders),
|
|
"appendHeader": () => (/* binding */ appendHeader),
|
|
"appendHeaders": () => (/* binding */ appendHeaders),
|
|
"appendResponseHeader": () => (/* binding */ appendResponseHeader),
|
|
"appendResponseHeaders": () => (/* binding */ appendResponseHeaders),
|
|
"assertMethod": () => (/* binding */ assertMethod),
|
|
"callNodeListener": () => (/* binding */ callNodeListener),
|
|
"clearResponseHeaders": () => (/* binding */ clearResponseHeaders),
|
|
"clearSession": () => (/* binding */ clearSession),
|
|
"createApp": () => (/* binding */ createApp),
|
|
"createAppEventHandler": () => (/* binding */ createAppEventHandler),
|
|
"createError": () => (/* binding */ createError),
|
|
"createEvent": () => (/* binding */ createEvent),
|
|
"createRouter": () => (/* binding */ createRouter),
|
|
"defaultContentType": () => (/* binding */ defaultContentType),
|
|
"defineEventHandler": () => (/* binding */ defineEventHandler),
|
|
"defineLazyEventHandler": () => (/* binding */ defineLazyEventHandler),
|
|
"defineNodeListener": () => (/* binding */ defineNodeListener),
|
|
"defineNodeMiddleware": () => (/* binding */ defineNodeMiddleware),
|
|
"deleteCookie": () => (/* binding */ deleteCookie),
|
|
"dynamicEventHandler": () => (/* binding */ dynamicEventHandler),
|
|
"eventHandler": () => (/* binding */ eventHandler),
|
|
"fetchWithEvent": () => (/* binding */ fetchWithEvent),
|
|
"fromNodeMiddleware": () => (/* binding */ fromNodeMiddleware),
|
|
"getCookie": () => (/* binding */ getCookie),
|
|
"getHeader": () => (/* binding */ getHeader),
|
|
"getHeaders": () => (/* binding */ getHeaders),
|
|
"getMethod": () => (/* binding */ getMethod),
|
|
"getProxyRequestHeaders": () => (/* binding */ getProxyRequestHeaders),
|
|
"getQuery": () => (/* binding */ dist_getQuery),
|
|
"getRequestHeader": () => (/* binding */ getRequestHeader),
|
|
"getRequestHeaders": () => (/* binding */ getRequestHeaders),
|
|
"getRequestHost": () => (/* binding */ getRequestHost),
|
|
"getRequestPath": () => (/* binding */ getRequestPath),
|
|
"getRequestProtocol": () => (/* binding */ getRequestProtocol),
|
|
"getRequestURL": () => (/* binding */ getRequestURL),
|
|
"getResponseHeader": () => (/* binding */ getResponseHeader),
|
|
"getResponseHeaders": () => (/* binding */ getResponseHeaders),
|
|
"getResponseStatus": () => (/* binding */ getResponseStatus),
|
|
"getResponseStatusText": () => (/* binding */ getResponseStatusText),
|
|
"getRouterParam": () => (/* binding */ getRouterParam),
|
|
"getRouterParams": () => (/* binding */ getRouterParams),
|
|
"getSession": () => (/* binding */ getSession),
|
|
"getValidatedQuery": () => (/* binding */ getValidatedQuery),
|
|
"handleCacheHeaders": () => (/* binding */ handleCacheHeaders),
|
|
"handleCors": () => (/* binding */ handleCors),
|
|
"isCorsOriginAllowed": () => (/* binding */ isCorsOriginAllowed),
|
|
"isError": () => (/* binding */ isError),
|
|
"isEvent": () => (/* binding */ isEvent),
|
|
"isEventHandler": () => (/* binding */ isEventHandler),
|
|
"isMethod": () => (/* binding */ isMethod),
|
|
"isPreflightRequest": () => (/* binding */ isPreflightRequest),
|
|
"isStream": () => (/* binding */ isStream),
|
|
"isWebResponse": () => (/* binding */ isWebResponse),
|
|
"lazyEventHandler": () => (/* binding */ lazyEventHandler),
|
|
"parseCookies": () => (/* binding */ parseCookies),
|
|
"promisifyNodeListener": () => (/* binding */ promisifyNodeListener),
|
|
"proxyRequest": () => (/* binding */ proxyRequest),
|
|
"readBody": () => (/* binding */ readBody),
|
|
"readFormData": () => (/* binding */ readFormData),
|
|
"readMultipartFormData": () => (/* binding */ readMultipartFormData),
|
|
"readRawBody": () => (/* binding */ readRawBody),
|
|
"readValidatedBody": () => (/* binding */ readValidatedBody),
|
|
"removeResponseHeader": () => (/* binding */ removeResponseHeader),
|
|
"sanitizeStatusCode": () => (/* binding */ sanitizeStatusCode),
|
|
"sanitizeStatusMessage": () => (/* binding */ sanitizeStatusMessage),
|
|
"sealSession": () => (/* binding */ sealSession),
|
|
"send": () => (/* binding */ send),
|
|
"sendError": () => (/* binding */ sendError),
|
|
"sendNoContent": () => (/* binding */ sendNoContent),
|
|
"sendProxy": () => (/* binding */ sendProxy),
|
|
"sendRedirect": () => (/* binding */ sendRedirect),
|
|
"sendStream": () => (/* binding */ sendStream),
|
|
"sendWebResponse": () => (/* binding */ sendWebResponse),
|
|
"serveStatic": () => (/* binding */ serveStatic),
|
|
"setCookie": () => (/* binding */ setCookie),
|
|
"setHeader": () => (/* binding */ setHeader),
|
|
"setHeaders": () => (/* binding */ setHeaders),
|
|
"setResponseHeader": () => (/* binding */ setResponseHeader),
|
|
"setResponseHeaders": () => (/* binding */ setResponseHeaders),
|
|
"setResponseStatus": () => (/* binding */ setResponseStatus),
|
|
"splitCookiesString": () => (/* binding */ splitCookiesString),
|
|
"toEventHandler": () => (/* binding */ toEventHandler),
|
|
"toNodeListener": () => (/* binding */ toNodeListener),
|
|
"toPlainHandler": () => (/* binding */ toPlainHandler),
|
|
"toWebHandler": () => (/* binding */ toWebHandler),
|
|
"unsealSession": () => (/* binding */ unsealSession),
|
|
"updateSession": () => (/* binding */ updateSession),
|
|
"use": () => (/* binding */ use),
|
|
"useBase": () => (/* binding */ useBase),
|
|
"useSession": () => (/* binding */ useSession),
|
|
"writeEarlyHints": () => (/* binding */ writeEarlyHints)
|
|
});
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/listhen/node_modules/h3/node_modules/ufo/dist/index.mjs
|
|
const n = /[^\0-\x7E]/;
|
|
const t = /[\x2E\u3002\uFF0E\uFF61]/g;
|
|
const o = {
|
|
overflow: "Overflow Error",
|
|
"not-basic": "Illegal Input",
|
|
"invalid-input": "Invalid Input"
|
|
};
|
|
const e = Math.floor;
|
|
const r = String.fromCharCode;
|
|
function s(n2) {
|
|
throw new RangeError(o[n2]);
|
|
}
|
|
const c = function(n2, t2) {
|
|
return n2 + 22 + 75 * (n2 < 26) - ((t2 != 0) << 5);
|
|
};
|
|
const u = function(n2, t2, o2) {
|
|
let r2 = 0;
|
|
for (n2 = o2 ? e(n2 / 700) : n2 >> 1, n2 += e(n2 / t2); n2 > 455; r2 += 36) {
|
|
n2 = e(n2 / 35);
|
|
}
|
|
return e(r2 + 36 * n2 / (n2 + 38));
|
|
};
|
|
function toASCII(o2) {
|
|
return function(n2, o3) {
|
|
const e2 = n2.split("@");
|
|
let r2 = "";
|
|
e2.length > 1 && (r2 = e2[0] + "@", n2 = e2[1]);
|
|
const s2 = function(n3, t2) {
|
|
const o4 = [];
|
|
let e3 = n3.length;
|
|
for (; e3--; ) {
|
|
o4[e3] = t2(n3[e3]);
|
|
}
|
|
return o4;
|
|
}((n2 = n2.replace(t, ".")).split("."), o3).join(".");
|
|
return r2 + s2;
|
|
}(o2, function(t2) {
|
|
return n.test(t2) ? "xn--" + function(n2) {
|
|
const t3 = [];
|
|
const o3 = (n2 = function(n3) {
|
|
const t4 = [];
|
|
let o4 = 0;
|
|
const e2 = n3.length;
|
|
for (; o4 < e2; ) {
|
|
const r2 = n3.charCodeAt(o4++);
|
|
if (r2 >= 55296 && r2 <= 56319 && o4 < e2) {
|
|
const e3 = n3.charCodeAt(o4++);
|
|
(64512 & e3) == 56320 ? t4.push(((1023 & r2) << 10) + (1023 & e3) + 65536) : (t4.push(r2), o4--);
|
|
} else {
|
|
t4.push(r2);
|
|
}
|
|
}
|
|
return t4;
|
|
}(n2)).length;
|
|
let f = 128;
|
|
let i = 0;
|
|
let l = 72;
|
|
for (const o4 of n2) {
|
|
o4 < 128 && t3.push(r(o4));
|
|
}
|
|
const h = t3.length;
|
|
let p = h;
|
|
for (h && t3.push("-"); p < o3; ) {
|
|
let o4 = 2147483647;
|
|
for (const t4 of n2) {
|
|
t4 >= f && t4 < o4 && (o4 = t4);
|
|
}
|
|
const a = p + 1;
|
|
o4 - f > e((2147483647 - i) / a) && s("overflow"), i += (o4 - f) * a, f = o4;
|
|
for (const o5 of n2) {
|
|
if (o5 < f && ++i > 2147483647 && s("overflow"), o5 == f) {
|
|
let n3 = i;
|
|
for (let o6 = 36; ; o6 += 36) {
|
|
const s2 = o6 <= l ? 1 : o6 >= l + 26 ? 26 : o6 - l;
|
|
if (n3 < s2) {
|
|
break;
|
|
}
|
|
const u2 = n3 - s2;
|
|
const f2 = 36 - s2;
|
|
t3.push(r(c(s2 + u2 % f2, 0))), n3 = e(u2 / f2);
|
|
}
|
|
t3.push(r(c(n3, 0))), l = u(i, a, p == h), i = 0, ++p;
|
|
}
|
|
}
|
|
++i, ++f;
|
|
}
|
|
return t3.join("");
|
|
}(t2) : t2;
|
|
});
|
|
}
|
|
|
|
const HASH_RE = /#/g;
|
|
const AMPERSAND_RE = /&/g;
|
|
const SLASH_RE = /\//g;
|
|
const EQUAL_RE = /=/g;
|
|
const IM_RE = /\?/g;
|
|
const PLUS_RE = /\+/g;
|
|
const ENC_CARET_RE = /%5e/gi;
|
|
const ENC_BACKTICK_RE = /%60/gi;
|
|
const ENC_CURLY_OPEN_RE = /%7b/gi;
|
|
const ENC_PIPE_RE = /%7c/gi;
|
|
const ENC_CURLY_CLOSE_RE = /%7d/gi;
|
|
const ENC_SPACE_RE = /%20/gi;
|
|
const ENC_SLASH_RE = /%2f/gi;
|
|
const ENC_ENC_SLASH_RE = /%252f/gi;
|
|
function encode(text) {
|
|
return encodeURI("" + text).replace(ENC_PIPE_RE, "|");
|
|
}
|
|
function encodeHash(text) {
|
|
return encode(text).replace(ENC_CURLY_OPEN_RE, "{").replace(ENC_CURLY_CLOSE_RE, "}").replace(ENC_CARET_RE, "^");
|
|
}
|
|
function encodeQueryValue(input) {
|
|
return encode(typeof input === "string" ? input : JSON.stringify(input)).replace(PLUS_RE, "%2B").replace(ENC_SPACE_RE, "+").replace(HASH_RE, "%23").replace(AMPERSAND_RE, "%26").replace(ENC_BACKTICK_RE, "`").replace(ENC_CARET_RE, "^");
|
|
}
|
|
function encodeQueryKey(text) {
|
|
return encodeQueryValue(text).replace(EQUAL_RE, "%3D");
|
|
}
|
|
function encodePath(text) {
|
|
return encode(text).replace(HASH_RE, "%23").replace(IM_RE, "%3F").replace(ENC_ENC_SLASH_RE, "%2F").replace(AMPERSAND_RE, "%26").replace(PLUS_RE, "%2B");
|
|
}
|
|
function encodeParam(text) {
|
|
return encodePath(text).replace(SLASH_RE, "%2F");
|
|
}
|
|
function decode(text = "") {
|
|
try {
|
|
return decodeURIComponent("" + text);
|
|
} catch {
|
|
return "" + text;
|
|
}
|
|
}
|
|
function decodePath(text) {
|
|
return decode(text.replace(ENC_SLASH_RE, "%252F"));
|
|
}
|
|
function decodeQueryValue(text) {
|
|
return decode(text.replace(PLUS_RE, " "));
|
|
}
|
|
function encodeHost(name = "") {
|
|
return toASCII(name);
|
|
}
|
|
|
|
function parseQuery(parametersString = "") {
|
|
const object = {};
|
|
if (parametersString[0] === "?") {
|
|
parametersString = parametersString.slice(1);
|
|
}
|
|
for (const parameter of parametersString.split("&")) {
|
|
const s = parameter.match(/([^=]+)=?(.*)/) || [];
|
|
if (s.length < 2) {
|
|
continue;
|
|
}
|
|
const key = decode(s[1]);
|
|
if (key === "__proto__" || key === "constructor") {
|
|
continue;
|
|
}
|
|
const value = decodeQueryValue(s[2] || "");
|
|
if (typeof object[key] !== "undefined") {
|
|
if (Array.isArray(object[key])) {
|
|
object[key].push(value);
|
|
} else {
|
|
object[key] = [object[key], value];
|
|
}
|
|
} else {
|
|
object[key] = value;
|
|
}
|
|
}
|
|
return object;
|
|
}
|
|
function encodeQueryItem(key, value) {
|
|
if (typeof value === "number" || typeof value === "boolean") {
|
|
value = String(value);
|
|
}
|
|
if (!value) {
|
|
return encodeQueryKey(key);
|
|
}
|
|
if (Array.isArray(value)) {
|
|
return value.map((_value) => `${encodeQueryKey(key)}=${encodeQueryValue(_value)}`).join("&");
|
|
}
|
|
return `${encodeQueryKey(key)}=${encodeQueryValue(value)}`;
|
|
}
|
|
function stringifyQuery(query) {
|
|
return Object.keys(query).filter((k) => query[k] !== void 0).map((k) => encodeQueryItem(k, query[k])).join("&");
|
|
}
|
|
|
|
class $URL {
|
|
constructor(input = "") {
|
|
this.query = {};
|
|
if (typeof input !== "string") {
|
|
throw new TypeError(
|
|
`URL input should be string received ${typeof input} (${input})`
|
|
);
|
|
}
|
|
const parsed = parseURL(input);
|
|
this.protocol = decode(parsed.protocol);
|
|
this.host = decode(parsed.host);
|
|
this.auth = decode(parsed.auth);
|
|
this.pathname = decodePath(parsed.pathname);
|
|
this.query = parseQuery(parsed.search);
|
|
this.hash = decode(parsed.hash);
|
|
}
|
|
get hostname() {
|
|
return parseHost(this.host).hostname;
|
|
}
|
|
get port() {
|
|
return parseHost(this.host).port || "";
|
|
}
|
|
get username() {
|
|
return parseAuth(this.auth).username;
|
|
}
|
|
get password() {
|
|
return parseAuth(this.auth).password || "";
|
|
}
|
|
get hasProtocol() {
|
|
return this.protocol.length;
|
|
}
|
|
get isAbsolute() {
|
|
return this.hasProtocol || this.pathname[0] === "/";
|
|
}
|
|
get search() {
|
|
const q = stringifyQuery(this.query);
|
|
return q.length > 0 ? "?" + q : "";
|
|
}
|
|
get searchParams() {
|
|
const p = new URLSearchParams();
|
|
for (const name in this.query) {
|
|
const value = this.query[name];
|
|
if (Array.isArray(value)) {
|
|
for (const v of value) {
|
|
p.append(name, v);
|
|
}
|
|
} else {
|
|
p.append(
|
|
name,
|
|
typeof value === "string" ? value : JSON.stringify(value)
|
|
);
|
|
}
|
|
}
|
|
return p;
|
|
}
|
|
get origin() {
|
|
return (this.protocol ? this.protocol + "//" : "") + encodeHost(this.host);
|
|
}
|
|
get fullpath() {
|
|
return encodePath(this.pathname) + this.search + encodeHash(this.hash);
|
|
}
|
|
get encodedAuth() {
|
|
if (!this.auth) {
|
|
return "";
|
|
}
|
|
const { username, password } = parseAuth(this.auth);
|
|
return encodeURIComponent(username) + (password ? ":" + encodeURIComponent(password) : "");
|
|
}
|
|
get href() {
|
|
const auth = this.encodedAuth;
|
|
const originWithAuth = (this.protocol ? this.protocol + "//" : "") + (auth ? auth + "@" : "") + encodeHost(this.host);
|
|
return this.hasProtocol && this.isAbsolute ? originWithAuth + this.fullpath : this.fullpath;
|
|
}
|
|
append(url) {
|
|
if (url.hasProtocol) {
|
|
throw new Error("Cannot append a URL with protocol");
|
|
}
|
|
Object.assign(this.query, url.query);
|
|
if (url.pathname) {
|
|
this.pathname = withTrailingSlash(this.pathname) + withoutLeadingSlash(url.pathname);
|
|
}
|
|
if (url.hash) {
|
|
this.hash = url.hash;
|
|
}
|
|
}
|
|
toJSON() {
|
|
return this.href;
|
|
}
|
|
toString() {
|
|
return this.href;
|
|
}
|
|
}
|
|
|
|
function isRelative(inputString) {
|
|
return ["./", "../"].some((string_) => inputString.startsWith(string_));
|
|
}
|
|
const PROTOCOL_STRICT_REGEX = /^\w{2,}:([/\\]{1,2})/;
|
|
const PROTOCOL_REGEX = /^\w{2,}:([/\\]{2})?/;
|
|
const PROTOCOL_RELATIVE_REGEX = /^([/\\]\s*){2,}[^/\\]/;
|
|
function hasProtocol(inputString, opts = {}) {
|
|
if (typeof opts === "boolean") {
|
|
opts = { acceptRelative: opts };
|
|
}
|
|
if (opts.strict) {
|
|
return PROTOCOL_STRICT_REGEX.test(inputString);
|
|
}
|
|
return PROTOCOL_REGEX.test(inputString) || (opts.acceptRelative ? PROTOCOL_RELATIVE_REGEX.test(inputString) : false);
|
|
}
|
|
const TRAILING_SLASH_RE = /\/$|\/\?/;
|
|
function hasTrailingSlash(input = "", queryParameters = false) {
|
|
if (!queryParameters) {
|
|
return input.endsWith("/");
|
|
}
|
|
return TRAILING_SLASH_RE.test(input);
|
|
}
|
|
function withoutTrailingSlash(input = "", queryParameters = false) {
|
|
if (!queryParameters) {
|
|
return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || "/";
|
|
}
|
|
if (!hasTrailingSlash(input, true)) {
|
|
return input || "/";
|
|
}
|
|
const [s0, ...s] = input.split("?");
|
|
return (s0.slice(0, -1) || "/") + (s.length > 0 ? `?${s.join("?")}` : "");
|
|
}
|
|
function withTrailingSlash(input = "", queryParameters = false) {
|
|
if (!queryParameters) {
|
|
return input.endsWith("/") ? input : input + "/";
|
|
}
|
|
if (hasTrailingSlash(input, true)) {
|
|
return input || "/";
|
|
}
|
|
const [s0, ...s] = input.split("?");
|
|
return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "");
|
|
}
|
|
function hasLeadingSlash(input = "") {
|
|
return input.startsWith("/");
|
|
}
|
|
function withoutLeadingSlash(input = "") {
|
|
return (hasLeadingSlash(input) ? input.slice(1) : input) || "/";
|
|
}
|
|
function withLeadingSlash(input = "") {
|
|
return hasLeadingSlash(input) ? input : "/" + input;
|
|
}
|
|
function cleanDoubleSlashes(input = "") {
|
|
return input.split("://").map((string_) => string_.replace(/\/{2,}/g, "/")).join("://");
|
|
}
|
|
function withBase(input, base) {
|
|
if (isEmptyURL(base) || hasProtocol(input)) {
|
|
return input;
|
|
}
|
|
const _base = withoutTrailingSlash(base);
|
|
if (input.startsWith(_base)) {
|
|
return input;
|
|
}
|
|
return joinURL(_base, input);
|
|
}
|
|
function withoutBase(input, base) {
|
|
if (isEmptyURL(base)) {
|
|
return input;
|
|
}
|
|
const _base = withoutTrailingSlash(base);
|
|
if (!input.startsWith(_base)) {
|
|
return input;
|
|
}
|
|
const trimmed = input.slice(_base.length);
|
|
return trimmed[0] === "/" ? trimmed : "/" + trimmed;
|
|
}
|
|
function withQuery(input, query) {
|
|
const parsed = parseURL(input);
|
|
const mergedQuery = { ...parseQuery(parsed.search), ...query };
|
|
parsed.search = stringifyQuery(mergedQuery);
|
|
return stringifyParsedURL(parsed);
|
|
}
|
|
function getQuery(input) {
|
|
return parseQuery(parseURL(input).search);
|
|
}
|
|
function isEmptyURL(url) {
|
|
return !url || url === "/";
|
|
}
|
|
function isNonEmptyURL(url) {
|
|
return url && url !== "/";
|
|
}
|
|
function joinURL(base, ...input) {
|
|
let url = base || "";
|
|
for (const index of input.filter((url2) => isNonEmptyURL(url2))) {
|
|
url = url ? withTrailingSlash(url) + withoutLeadingSlash(index) : index;
|
|
}
|
|
return url;
|
|
}
|
|
function withHttp(input) {
|
|
return withProtocol(input, "http://");
|
|
}
|
|
function withHttps(input) {
|
|
return withProtocol(input, "https://");
|
|
}
|
|
function withoutProtocol(input) {
|
|
return withProtocol(input, "");
|
|
}
|
|
function withProtocol(input, protocol) {
|
|
const match = input.match(PROTOCOL_REGEX);
|
|
if (!match) {
|
|
return protocol + input;
|
|
}
|
|
return protocol + input.slice(match[0].length);
|
|
}
|
|
function createURL(input) {
|
|
return new $URL(input);
|
|
}
|
|
function normalizeURL(input) {
|
|
return createURL(input).toString();
|
|
}
|
|
function resolveURL(base, ...input) {
|
|
const url = createURL(base);
|
|
for (const index of input.filter((url2) => isNonEmptyURL(url2))) {
|
|
url.append(createURL(index));
|
|
}
|
|
return url.toString();
|
|
}
|
|
function isSamePath(p1, p2) {
|
|
return decode(withoutTrailingSlash(p1)) === decode(withoutTrailingSlash(p2));
|
|
}
|
|
function isEqual(a, b, options = {}) {
|
|
if (!options.trailingSlash) {
|
|
a = withTrailingSlash(a);
|
|
b = withTrailingSlash(b);
|
|
}
|
|
if (!options.leadingSlash) {
|
|
a = withLeadingSlash(a);
|
|
b = withLeadingSlash(b);
|
|
}
|
|
if (!options.encoding) {
|
|
a = decode(a);
|
|
b = decode(b);
|
|
}
|
|
return a === b;
|
|
}
|
|
|
|
function parseURL(input = "", defaultProto) {
|
|
if (!hasProtocol(input, { acceptRelative: true })) {
|
|
return defaultProto ? parseURL(defaultProto + input) : parsePath(input);
|
|
}
|
|
const [protocol = "", auth, hostAndPath = ""] = (input.replace(/\\/g, "/").match(/([^/:]+:)?\/\/([^/@]+@)?(.*)/) || []).splice(1);
|
|
const [host = "", path = ""] = (hostAndPath.match(/([^#/?]*)(.*)?/) || []).splice(1);
|
|
const { pathname, search, hash } = parsePath(
|
|
path.replace(/\/(?=[A-Za-z]:)/, "")
|
|
);
|
|
return {
|
|
protocol,
|
|
auth: auth ? auth.slice(0, Math.max(0, auth.length - 1)) : "",
|
|
host,
|
|
pathname,
|
|
search,
|
|
hash
|
|
};
|
|
}
|
|
function parsePath(input = "") {
|
|
const [pathname = "", search = "", hash = ""] = (input.match(/([^#?]*)(\?[^#]*)?(#.*)?/) || []).splice(1);
|
|
return {
|
|
pathname,
|
|
search,
|
|
hash
|
|
};
|
|
}
|
|
function parseAuth(input = "") {
|
|
const [username, password] = input.split(":");
|
|
return {
|
|
username: decode(username),
|
|
password: decode(password)
|
|
};
|
|
}
|
|
function parseHost(input = "") {
|
|
const [hostname, port] = (input.match(/([^/:]*):?(\d+)?/) || []).splice(1);
|
|
return {
|
|
hostname: decode(hostname),
|
|
port
|
|
};
|
|
}
|
|
function stringifyParsedURL(parsed) {
|
|
const fullpath = parsed.pathname + (parsed.search ? (parsed.search.startsWith("?") ? "" : "?") + parsed.search : "") + parsed.hash;
|
|
if (!parsed.protocol) {
|
|
return fullpath;
|
|
}
|
|
return parsed.protocol + "//" + (parsed.auth ? parsed.auth + "@" : "") + parsed.host + fullpath;
|
|
}
|
|
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/cookie-es/dist/index.mjs
|
|
const fieldContentRegExp = /^[\u0009\u0020-\u007E\u0080-\u00FF]+$/;
|
|
function parse(str, options) {
|
|
if (typeof str !== "string") {
|
|
throw new TypeError("argument str must be a string");
|
|
}
|
|
const obj = {};
|
|
const opt = options || {};
|
|
const dec = opt.decode || dist_decode;
|
|
let index = 0;
|
|
while (index < str.length) {
|
|
const eqIdx = str.indexOf("=", index);
|
|
if (eqIdx === -1) {
|
|
break;
|
|
}
|
|
let endIdx = str.indexOf(";", index);
|
|
if (endIdx === -1) {
|
|
endIdx = str.length;
|
|
} else if (endIdx < eqIdx) {
|
|
index = str.lastIndexOf(";", eqIdx - 1) + 1;
|
|
continue;
|
|
}
|
|
const key = str.slice(index, eqIdx).trim();
|
|
if (void 0 === obj[key]) {
|
|
let val = str.slice(eqIdx + 1, endIdx).trim();
|
|
if (val.codePointAt(0) === 34) {
|
|
val = val.slice(1, -1);
|
|
}
|
|
obj[key] = tryDecode(val, dec);
|
|
}
|
|
index = endIdx + 1;
|
|
}
|
|
return obj;
|
|
}
|
|
function serialize(name, value, options) {
|
|
const opt = options || {};
|
|
const enc = opt.encode || dist_encode;
|
|
if (typeof enc !== "function") {
|
|
throw new TypeError("option encode is invalid");
|
|
}
|
|
if (!fieldContentRegExp.test(name)) {
|
|
throw new TypeError("argument name is invalid");
|
|
}
|
|
const encodedValue = enc(value);
|
|
if (encodedValue && !fieldContentRegExp.test(encodedValue)) {
|
|
throw new TypeError("argument val is invalid");
|
|
}
|
|
let str = name + "=" + encodedValue;
|
|
if (void 0 !== opt.maxAge && opt.maxAge !== null) {
|
|
const maxAge = opt.maxAge - 0;
|
|
if (Number.isNaN(maxAge) || !Number.isFinite(maxAge)) {
|
|
throw new TypeError("option maxAge is invalid");
|
|
}
|
|
str += "; Max-Age=" + Math.floor(maxAge);
|
|
}
|
|
if (opt.domain) {
|
|
if (!fieldContentRegExp.test(opt.domain)) {
|
|
throw new TypeError("option domain is invalid");
|
|
}
|
|
str += "; Domain=" + opt.domain;
|
|
}
|
|
if (opt.path) {
|
|
if (!fieldContentRegExp.test(opt.path)) {
|
|
throw new TypeError("option path is invalid");
|
|
}
|
|
str += "; Path=" + opt.path;
|
|
}
|
|
if (opt.expires) {
|
|
if (!isDate(opt.expires) || Number.isNaN(opt.expires.valueOf())) {
|
|
throw new TypeError("option expires is invalid");
|
|
}
|
|
str += "; Expires=" + opt.expires.toUTCString();
|
|
}
|
|
if (opt.httpOnly) {
|
|
str += "; HttpOnly";
|
|
}
|
|
if (opt.secure) {
|
|
str += "; Secure";
|
|
}
|
|
if (opt.priority) {
|
|
const priority = typeof opt.priority === "string" ? opt.priority.toLowerCase() : opt.priority;
|
|
switch (priority) {
|
|
case "low":
|
|
str += "; Priority=Low";
|
|
break;
|
|
case "medium":
|
|
str += "; Priority=Medium";
|
|
break;
|
|
case "high":
|
|
str += "; Priority=High";
|
|
break;
|
|
default:
|
|
throw new TypeError("option priority is invalid");
|
|
}
|
|
}
|
|
if (opt.sameSite) {
|
|
const sameSite = typeof opt.sameSite === "string" ? opt.sameSite.toLowerCase() : opt.sameSite;
|
|
switch (sameSite) {
|
|
case true:
|
|
str += "; SameSite=Strict";
|
|
break;
|
|
case "lax":
|
|
str += "; SameSite=Lax";
|
|
break;
|
|
case "strict":
|
|
str += "; SameSite=Strict";
|
|
break;
|
|
case "none":
|
|
str += "; SameSite=None";
|
|
break;
|
|
default:
|
|
throw new TypeError("option sameSite is invalid");
|
|
}
|
|
}
|
|
return str;
|
|
}
|
|
function isDate(val) {
|
|
return Object.prototype.toString.call(val) === "[object Date]" || val instanceof Date;
|
|
}
|
|
function tryDecode(str, decode2) {
|
|
try {
|
|
return decode2(str);
|
|
} catch {
|
|
return str;
|
|
}
|
|
}
|
|
function dist_decode(str) {
|
|
return str.includes("%") ? decodeURIComponent(str) : str;
|
|
}
|
|
function dist_encode(val) {
|
|
return encodeURIComponent(val);
|
|
}
|
|
|
|
|
|
|
|
// EXTERNAL MODULE: ./node_modules/radix3/dist/index.mjs
|
|
var dist = __webpack_require__(1642);
|
|
// EXTERNAL MODULE: ./node_modules/destr/dist/index.mjs
|
|
var destr_dist = __webpack_require__(1996);
|
|
// EXTERNAL MODULE: ./node_modules/defu/dist/defu.mjs
|
|
var defu = __webpack_require__(6922);
|
|
// EXTERNAL MODULE: external "node:crypto"
|
|
var external_node_crypto_ = __webpack_require__(6005);
|
|
;// CONCATENATED MODULE: ./node_modules/uncrypto/dist/crypto.node.mjs
|
|
|
|
|
|
const subtle = external_node_crypto_.webcrypto?.subtle || {};
|
|
const randomUUID = () => {
|
|
return external_node_crypto_.randomUUID();
|
|
};
|
|
const getRandomValues = (array) => {
|
|
return external_node_crypto_.webcrypto.getRandomValues(array);
|
|
};
|
|
const _crypto = {
|
|
randomUUID,
|
|
getRandomValues,
|
|
subtle
|
|
};
|
|
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/listhen/node_modules/iron-webcrypto/dist/index.js
|
|
// node_modules/.pnpm/@aws-sdk+util-base64@3.310.0/node_modules/@aws-sdk/util-base64/dist-es/constants.browser.js
|
|
var alphabetByEncoding = {};
|
|
var alphabetByValue = new Array(64);
|
|
for (let i = 0, start = "A".charCodeAt(0), limit = "Z".charCodeAt(0); i + start <= limit; i++) {
|
|
const char = String.fromCharCode(i + start);
|
|
alphabetByEncoding[char] = i;
|
|
alphabetByValue[i] = char;
|
|
}
|
|
for (let i = 0, start = "a".charCodeAt(0), limit = "z".charCodeAt(0); i + start <= limit; i++) {
|
|
const char = String.fromCharCode(i + start);
|
|
const index = i + 26;
|
|
alphabetByEncoding[char] = index;
|
|
alphabetByValue[index] = char;
|
|
}
|
|
for (let i = 0; i < 10; i++) {
|
|
alphabetByEncoding[i.toString(10)] = i + 52;
|
|
const char = i.toString(10);
|
|
const index = i + 52;
|
|
alphabetByEncoding[char] = index;
|
|
alphabetByValue[index] = char;
|
|
}
|
|
alphabetByEncoding["+"] = 62;
|
|
alphabetByValue[62] = "+";
|
|
alphabetByEncoding["/"] = 63;
|
|
alphabetByValue[63] = "/";
|
|
var bitsPerLetter = 6;
|
|
var bitsPerByte = 8;
|
|
var maxLetterValue = 63;
|
|
|
|
// node_modules/.pnpm/@aws-sdk+util-base64@3.310.0/node_modules/@aws-sdk/util-base64/dist-es/fromBase64.browser.js
|
|
var fromBase64 = (input) => {
|
|
let totalByteLength = input.length / 4 * 3;
|
|
if (input.slice(-2) === "==") {
|
|
totalByteLength -= 2;
|
|
} else if (input.slice(-1) === "=") {
|
|
totalByteLength--;
|
|
}
|
|
const out = new ArrayBuffer(totalByteLength);
|
|
const dataView = new DataView(out);
|
|
for (let i = 0; i < input.length; i += 4) {
|
|
let bits = 0;
|
|
let bitLength = 0;
|
|
for (let j = i, limit = i + 3; j <= limit; j++) {
|
|
if (input[j] !== "=") {
|
|
if (!(input[j] in alphabetByEncoding)) {
|
|
throw new TypeError(`Invalid character ${input[j]} in base64 string.`);
|
|
}
|
|
bits |= alphabetByEncoding[input[j]] << (limit - j) * bitsPerLetter;
|
|
bitLength += bitsPerLetter;
|
|
} else {
|
|
bits >>= bitsPerLetter;
|
|
}
|
|
}
|
|
const chunkOffset = i / 4 * 3;
|
|
bits >>= bitLength % bitsPerByte;
|
|
const byteLength = Math.floor(bitLength / bitsPerByte);
|
|
for (let k = 0; k < byteLength; k++) {
|
|
const offset = (byteLength - k - 1) * bitsPerByte;
|
|
dataView.setUint8(chunkOffset + k, (bits & 255 << offset) >> offset);
|
|
}
|
|
}
|
|
return new Uint8Array(out);
|
|
};
|
|
|
|
// node_modules/.pnpm/@aws-sdk+util-base64@3.310.0/node_modules/@aws-sdk/util-base64/dist-es/toBase64.browser.js
|
|
function toBase64(input) {
|
|
let str = "";
|
|
for (let i = 0; i < input.length; i += 3) {
|
|
let bits = 0;
|
|
let bitLength = 0;
|
|
for (let j = i, limit = Math.min(i + 3, input.length); j < limit; j++) {
|
|
bits |= input[j] << (limit - j - 1) * bitsPerByte;
|
|
bitLength += bitsPerByte;
|
|
}
|
|
const bitClusterCount = Math.ceil(bitLength / bitsPerLetter);
|
|
bits <<= bitClusterCount * bitsPerLetter - bitLength;
|
|
for (let k = 1; k <= bitClusterCount; k++) {
|
|
const offset = (bitClusterCount - k) * bitsPerLetter;
|
|
str += alphabetByValue[(bits & maxLetterValue << offset) >> offset];
|
|
}
|
|
str += "==".slice(0, 4 - bitClusterCount);
|
|
}
|
|
return str;
|
|
}
|
|
|
|
// src/index.ts
|
|
var stringToBuffer = (value) => {
|
|
return new TextEncoder().encode(value);
|
|
};
|
|
var bufferToString = (value) => {
|
|
return new TextDecoder().decode(value);
|
|
};
|
|
var base64urlEncode = (value) => toBase64(value instanceof Uint8Array ? value : stringToBuffer(value)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
|
|
var base64urlDecode = (value) => fromBase64(
|
|
value.replace(/-/g, "+").replace(/_/g, "/") + Array((4 - value.length % 4) % 4 + 1).join("=")
|
|
);
|
|
var defaults = {
|
|
encryption: { saltBits: 256, algorithm: "aes-256-cbc", iterations: 1, minPasswordlength: 32 },
|
|
integrity: { saltBits: 256, algorithm: "sha256", iterations: 1, minPasswordlength: 32 },
|
|
ttl: 0,
|
|
timestampSkewSec: 60,
|
|
localtimeOffsetMsec: 0
|
|
};
|
|
var clone = (options) => ({
|
|
...options,
|
|
encryption: { ...options.encryption },
|
|
integrity: { ...options.integrity }
|
|
});
|
|
var algorithms = {
|
|
"aes-128-ctr": { keyBits: 128, ivBits: 128, name: "AES-CTR" },
|
|
"aes-256-cbc": { keyBits: 256, ivBits: 128, name: "AES-CBC" },
|
|
sha256: { keyBits: 256, name: "SHA-256" }
|
|
};
|
|
var macFormatVersion = "2";
|
|
var macPrefix = `Fe26.${macFormatVersion}`;
|
|
var randomBytes = (_crypto, size) => {
|
|
const bytes = new Uint8Array(size);
|
|
_crypto.getRandomValues(bytes);
|
|
return bytes;
|
|
};
|
|
var randomBits = (_crypto, bits) => {
|
|
if (bits < 1)
|
|
throw Error("Invalid random bits count");
|
|
const bytes = Math.ceil(bits / 8);
|
|
return randomBytes(_crypto, bytes);
|
|
};
|
|
var pbkdf2 = async (_crypto, password, salt, iterations, keyLength, hash) => {
|
|
const passwordBuffer = stringToBuffer(password);
|
|
const importedKey = await _crypto.subtle.importKey("raw", passwordBuffer, "PBKDF2", false, [
|
|
"deriveBits"
|
|
]);
|
|
const saltBuffer = stringToBuffer(salt);
|
|
const params = { name: "PBKDF2", hash, salt: saltBuffer, iterations };
|
|
const derivation = await _crypto.subtle.deriveBits(params, importedKey, keyLength * 8);
|
|
return derivation;
|
|
};
|
|
var generateKey = async (_crypto, password, options) => {
|
|
if (!password?.length)
|
|
throw new Error("Empty password");
|
|
if (options == null || typeof options !== "object")
|
|
throw new Error("Bad options");
|
|
if (!(options.algorithm in algorithms))
|
|
throw new Error(`Unknown algorithm: ${options.algorithm}`);
|
|
const algorithm = algorithms[options.algorithm];
|
|
const result = {};
|
|
const hmac = options.hmac ?? false;
|
|
const id = hmac ? { name: "HMAC", hash: algorithm.name } : { name: algorithm.name };
|
|
const usage = hmac ? ["sign", "verify"] : ["encrypt", "decrypt"];
|
|
if (typeof password === "string") {
|
|
if (password.length < options.minPasswordlength)
|
|
throw new Error(
|
|
`Password string too short (min ${options.minPasswordlength} characters required)`
|
|
);
|
|
let { salt = "" } = options;
|
|
if (!salt) {
|
|
const { saltBits = 0 } = options;
|
|
if (!saltBits)
|
|
throw new Error("Missing salt and saltBits options");
|
|
const randomSalt = randomBits(_crypto, saltBits);
|
|
salt = [...new Uint8Array(randomSalt)].map((x) => x.toString(16).padStart(2, "0")).join("");
|
|
}
|
|
const derivedKey = await pbkdf2(
|
|
_crypto,
|
|
password,
|
|
salt,
|
|
options.iterations,
|
|
algorithm.keyBits / 8,
|
|
"SHA-1"
|
|
);
|
|
const importedEncryptionKey = await _crypto.subtle.importKey(
|
|
"raw",
|
|
derivedKey,
|
|
id,
|
|
false,
|
|
usage
|
|
);
|
|
result.key = importedEncryptionKey;
|
|
result.salt = salt;
|
|
} else {
|
|
if (password.length < algorithm.keyBits / 8)
|
|
throw new Error("Key buffer (password) too small");
|
|
result.key = await _crypto.subtle.importKey("raw", password, id, false, usage);
|
|
result.salt = "";
|
|
}
|
|
if (options.iv)
|
|
result.iv = options.iv;
|
|
else if ("ivBits" in algorithm)
|
|
result.iv = randomBits(_crypto, algorithm.ivBits);
|
|
return result;
|
|
};
|
|
var encrypt = async (_crypto, password, options, data) => {
|
|
const key = await generateKey(_crypto, password, options);
|
|
const textBuffer = stringToBuffer(data);
|
|
const encrypted = await _crypto.subtle.encrypt(
|
|
{ name: algorithms[options.algorithm].name, iv: key.iv },
|
|
key.key,
|
|
textBuffer
|
|
);
|
|
return { encrypted: new Uint8Array(encrypted), key };
|
|
};
|
|
var decrypt = async (_crypto, password, options, data) => {
|
|
const key = await generateKey(_crypto, password, options);
|
|
const decrypted = await _crypto.subtle.decrypt(
|
|
{ name: algorithms[options.algorithm].name, iv: key.iv },
|
|
key.key,
|
|
typeof data === "string" ? stringToBuffer(data) : data
|
|
);
|
|
return bufferToString(new Uint8Array(decrypted));
|
|
};
|
|
var hmacWithPassword = async (_crypto, password, options, data) => {
|
|
const key = await generateKey(_crypto, password, { ...options, hmac: true });
|
|
const textBuffer = stringToBuffer(data);
|
|
const signed = await _crypto.subtle.sign({ name: "HMAC" }, key.key, textBuffer);
|
|
const digest = base64urlEncode(new Uint8Array(signed));
|
|
return { digest, salt: key.salt };
|
|
};
|
|
var normalizePassword = (password) => {
|
|
if (typeof password === "string" || password instanceof Uint8Array)
|
|
return { encryption: password, integrity: password };
|
|
if ("secret" in password)
|
|
return { id: password.id, encryption: password.secret, integrity: password.secret };
|
|
return { id: password.id, encryption: password.encryption, integrity: password.integrity };
|
|
};
|
|
var seal = async (_crypto, object, password, options) => {
|
|
if (!password)
|
|
throw Error("Empty password");
|
|
const opts = clone(options);
|
|
const now = Date.now() + (opts.localtimeOffsetMsec || 0);
|
|
const objectString = JSON.stringify(object);
|
|
const pass = normalizePassword(password);
|
|
const { id = "" } = pass;
|
|
if (id && !/^\w+$/.test(id))
|
|
throw new Error("Invalid password id");
|
|
const { encrypted, key } = await encrypt(_crypto, pass.encryption, opts.encryption, objectString);
|
|
const encryptedB64 = base64urlEncode(new Uint8Array(encrypted));
|
|
const iv = base64urlEncode(key.iv);
|
|
const expiration = opts.ttl ? now + opts.ttl : "";
|
|
const macBaseString = `${macPrefix}*${id}*${key.salt}*${iv}*${encryptedB64}*${expiration}`;
|
|
const mac = await hmacWithPassword(_crypto, pass.integrity, opts.integrity, macBaseString);
|
|
const sealed = `${macBaseString}*${mac.salt}*${mac.digest}`;
|
|
return sealed;
|
|
};
|
|
var fixedTimeComparison = (a, b) => {
|
|
let mismatch = a.length === b.length ? 0 : 1;
|
|
if (mismatch)
|
|
b = a;
|
|
for (let i = 0; i < a.length; i += 1)
|
|
mismatch |= a.charCodeAt(i) ^ b.charCodeAt(i);
|
|
return mismatch === 0;
|
|
};
|
|
var unseal = async (_crypto, sealed, password, options) => {
|
|
if (!password)
|
|
throw Error("Empty password");
|
|
const opts = clone(options);
|
|
const now = Date.now() + (opts.localtimeOffsetMsec || 0);
|
|
const parts = sealed.split("*");
|
|
if (parts.length !== 8)
|
|
throw new Error("Incorrect number of sealed components");
|
|
const prefix = parts[0];
|
|
let passwordId = parts[1];
|
|
const encryptionSalt = parts[2];
|
|
const encryptionIv = parts[3];
|
|
const encryptedB64 = parts[4];
|
|
const expiration = parts[5];
|
|
const hmacSalt = parts[6];
|
|
const hmac = parts[7];
|
|
const macBaseString = `${prefix}*${passwordId}*${encryptionSalt}*${encryptionIv}*${encryptedB64}*${expiration}`;
|
|
if (macPrefix !== prefix)
|
|
throw new Error("Wrong mac prefix");
|
|
if (expiration) {
|
|
if (!/^\d+$/.exec(expiration))
|
|
throw new Error("Invalid expiration");
|
|
const exp = parseInt(expiration, 10);
|
|
if (exp <= now - opts.timestampSkewSec * 1e3)
|
|
throw new Error("Expired seal");
|
|
}
|
|
if (typeof password === "undefined" || typeof password === "string" && password.length === 0)
|
|
throw new Error("Empty password");
|
|
let pass = "";
|
|
passwordId = passwordId || "default";
|
|
if (typeof password === "string" || password instanceof Uint8Array)
|
|
pass = password;
|
|
else if (!(passwordId in password))
|
|
throw new Error(`Cannot find password: ${passwordId}`);
|
|
else
|
|
pass = password[passwordId];
|
|
pass = normalizePassword(pass);
|
|
const macOptions = opts.integrity;
|
|
macOptions.salt = hmacSalt;
|
|
const mac = await hmacWithPassword(_crypto, pass.integrity, macOptions, macBaseString);
|
|
if (!fixedTimeComparison(mac.digest, hmac))
|
|
throw new Error("Bad hmac value");
|
|
const encrypted = base64urlDecode(encryptedB64);
|
|
const decryptOptions = opts.encryption;
|
|
decryptOptions.salt = encryptionSalt;
|
|
decryptOptions.iv = base64urlDecode(encryptionIv);
|
|
const decrypted = await decrypt(_crypto, pass.encryption, decryptOptions, encrypted);
|
|
if (decrypted)
|
|
return JSON.parse(decrypted);
|
|
return null;
|
|
};
|
|
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/unenv/runtime/_internal/utils.mjs
|
|
function rawHeaders(headers) {
|
|
const rawHeaders2 = [];
|
|
for (const key in headers) {
|
|
if (Array.isArray(headers[key])) {
|
|
for (const h of headers[key]) {
|
|
rawHeaders2.push(key, h);
|
|
}
|
|
} else {
|
|
rawHeaders2.push(key, headers[key]);
|
|
}
|
|
}
|
|
return rawHeaders2;
|
|
}
|
|
function mergeFns(...functions) {
|
|
return function(...args) {
|
|
for (const fn of functions) {
|
|
fn(...args);
|
|
}
|
|
};
|
|
}
|
|
function notImplemented(name) {
|
|
return () => {
|
|
throw new Error(`[unenv] ${name} is not implemented yet!`);
|
|
};
|
|
}
|
|
function notImplementedClass(name) {
|
|
return class {
|
|
constructor() {
|
|
throw new Error(`[unenv] ${name} is not implemented yet!`);
|
|
}
|
|
};
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/unenv/runtime/node/events/_events.mjs
|
|
const R = typeof Reflect === "object" ? Reflect : null;
|
|
const ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args) {
|
|
return Function.prototype.apply.call(target, receiver, args);
|
|
};
|
|
let ReflectOwnKeys;
|
|
if (R && typeof R.ownKeys === "function") {
|
|
ReflectOwnKeys = R.ownKeys;
|
|
} else if (Object.getOwnPropertySymbols) {
|
|
ReflectOwnKeys = function ReflectOwnKeys2(target) {
|
|
return [
|
|
...Object.getOwnPropertyNames(target),
|
|
...Object.getOwnPropertySymbols(target)
|
|
];
|
|
};
|
|
} else {
|
|
ReflectOwnKeys = function ReflectOwnKeys2(target) {
|
|
return Object.getOwnPropertyNames(target);
|
|
};
|
|
}
|
|
function ProcessEmitWarning(warning) {
|
|
if (console && console.warn) {
|
|
console.warn(warning);
|
|
}
|
|
}
|
|
const NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) {
|
|
return value !== value;
|
|
};
|
|
function EventEmitter() {
|
|
EventEmitter.init.call(this);
|
|
}
|
|
EventEmitter.EventEmitter = EventEmitter;
|
|
EventEmitter.prototype._events = void 0;
|
|
EventEmitter.prototype._eventsCount = 0;
|
|
EventEmitter.prototype._maxListeners = void 0;
|
|
let defaultMaxListeners = 10;
|
|
function checkListener(listener) {
|
|
if (typeof listener !== "function") {
|
|
throw new TypeError(
|
|
'The "listener" argument must be of type Function. Received type ' + typeof listener
|
|
);
|
|
}
|
|
}
|
|
Object.defineProperty(EventEmitter, "defaultMaxListeners", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return defaultMaxListeners;
|
|
},
|
|
set: function(arg) {
|
|
if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
|
|
throw new RangeError(
|
|
'The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + "."
|
|
);
|
|
}
|
|
defaultMaxListeners = arg;
|
|
}
|
|
});
|
|
EventEmitter.init = function() {
|
|
if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
|
|
this._events = /* @__PURE__ */ Object.create(null);
|
|
this._eventsCount = 0;
|
|
}
|
|
this._maxListeners = this._maxListeners || void 0;
|
|
};
|
|
EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
|
|
if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {
|
|
throw new RangeError(
|
|
'The value of "n" is out of range. It must be a non-negative number. Received ' + n + "."
|
|
);
|
|
}
|
|
this._maxListeners = n;
|
|
return this;
|
|
};
|
|
function _getMaxListeners(that) {
|
|
if (that._maxListeners === void 0) {
|
|
return EventEmitter.defaultMaxListeners;
|
|
}
|
|
return that._maxListeners;
|
|
}
|
|
EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
|
|
return _getMaxListeners(this);
|
|
};
|
|
EventEmitter.prototype.emit = function emit(type) {
|
|
const args = [];
|
|
for (let i = 1; i < arguments.length; i++) {
|
|
args.push(arguments[i]);
|
|
}
|
|
let doError = type === "error";
|
|
const events = this._events;
|
|
if (events !== void 0) {
|
|
doError = doError && events.error === void 0;
|
|
} else if (!doError) {
|
|
return false;
|
|
}
|
|
if (doError) {
|
|
let er;
|
|
if (args.length > 0) {
|
|
er = args[0];
|
|
}
|
|
if (er instanceof Error) {
|
|
throw er;
|
|
}
|
|
const err = new Error(
|
|
"Unhandled error." + (er ? " (" + er.message + ")" : "")
|
|
);
|
|
err.context = er;
|
|
throw err;
|
|
}
|
|
const handler = events[type];
|
|
if (handler === void 0) {
|
|
return false;
|
|
}
|
|
if (typeof handler === "function") {
|
|
ReflectApply(handler, this, args);
|
|
} else {
|
|
const len = handler.length;
|
|
const listeners2 = arrayClone(handler, len);
|
|
for (let i = 0; i < len; ++i) {
|
|
ReflectApply(listeners2[i], this, args);
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
function _addListener(target, type, listener, prepend) {
|
|
let m;
|
|
let events;
|
|
let existing;
|
|
checkListener(listener);
|
|
events = target._events;
|
|
if (events === void 0) {
|
|
events = target._events = /* @__PURE__ */ Object.create(null);
|
|
target._eventsCount = 0;
|
|
} else {
|
|
if (events.newListener !== void 0) {
|
|
target.emit(
|
|
"newListener",
|
|
type,
|
|
// eslint-disable-next-line unicorn/prefer-logical-operator-over-ternary
|
|
listener.listener ? listener.listener : listener
|
|
);
|
|
events = target._events;
|
|
}
|
|
existing = events[type];
|
|
}
|
|
if (existing === void 0) {
|
|
existing = events[type] = listener;
|
|
++target._eventsCount;
|
|
} else {
|
|
if (typeof existing === "function") {
|
|
existing = events[type] = prepend ? [listener, existing] : [existing, listener];
|
|
} else if (prepend) {
|
|
existing.unshift(listener);
|
|
} else {
|
|
existing.push(listener);
|
|
}
|
|
m = _getMaxListeners(target);
|
|
if (m > 0 && existing.length > m && !existing.warned) {
|
|
existing.warned = true;
|
|
const w = new Error(
|
|
"Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit"
|
|
);
|
|
w.name = "MaxListenersExceededWarning";
|
|
w.emitter = target;
|
|
w.type = type;
|
|
w.count = existing.length;
|
|
ProcessEmitWarning(w);
|
|
}
|
|
}
|
|
return target;
|
|
}
|
|
EventEmitter.prototype.addListener = function addListener(type, listener) {
|
|
return _addListener(this, type, listener, false);
|
|
};
|
|
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
|
|
EventEmitter.prototype.prependListener = function prependListener(type, listener) {
|
|
return _addListener(this, type, listener, true);
|
|
};
|
|
function onceWrapper() {
|
|
if (!this.fired) {
|
|
this.target.removeListener(this.type, this.wrapFn);
|
|
this.fired = true;
|
|
if (arguments.length === 0) {
|
|
return this.listener.call(this.target);
|
|
}
|
|
return this.listener.apply(this.target, arguments);
|
|
}
|
|
}
|
|
function _onceWrap(target, type, listener) {
|
|
const state = { fired: false, wrapFn: void 0, target, type, listener };
|
|
const wrapped = onceWrapper.bind(state);
|
|
wrapped.listener = listener;
|
|
state.wrapFn = wrapped;
|
|
return wrapped;
|
|
}
|
|
EventEmitter.prototype.once = function once2(type, listener) {
|
|
checkListener(listener);
|
|
this.on(type, _onceWrap(this, type, listener));
|
|
return this;
|
|
};
|
|
EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {
|
|
checkListener(listener);
|
|
this.prependListener(type, _onceWrap(this, type, listener));
|
|
return this;
|
|
};
|
|
EventEmitter.prototype.removeListener = function removeListener(type, listener) {
|
|
let position, i, originalListener;
|
|
checkListener(listener);
|
|
const events = this._events;
|
|
if (events === void 0) {
|
|
return this;
|
|
}
|
|
const list = events[type];
|
|
if (list === void 0) {
|
|
return this;
|
|
}
|
|
if (list === listener || list.listener === listener) {
|
|
if (--this._eventsCount === 0) {
|
|
this._events = /* @__PURE__ */ Object.create(null);
|
|
} else {
|
|
delete events[type];
|
|
if (events.removeListener) {
|
|
this.emit("removeListener", type, list.listener || listener);
|
|
}
|
|
}
|
|
} else if (typeof list !== "function") {
|
|
position = -1;
|
|
for (i = list.length - 1; i >= 0; i--) {
|
|
if (list[i] === listener || list[i].listener === listener) {
|
|
originalListener = list[i].listener;
|
|
position = i;
|
|
break;
|
|
}
|
|
}
|
|
if (position < 0) {
|
|
return this;
|
|
}
|
|
if (position === 0) {
|
|
list.shift();
|
|
} else {
|
|
spliceOne(list, position);
|
|
}
|
|
if (list.length === 1) {
|
|
events[type] = list[0];
|
|
}
|
|
if (events.removeListener !== void 0) {
|
|
this.emit("removeListener", type, originalListener || listener);
|
|
}
|
|
}
|
|
return this;
|
|
};
|
|
EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
|
|
EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
|
|
let i;
|
|
const events = this._events;
|
|
if (events === void 0) {
|
|
return this;
|
|
}
|
|
if (events.removeListener === void 0) {
|
|
if (arguments.length === 0) {
|
|
this._events = /* @__PURE__ */ Object.create(null);
|
|
this._eventsCount = 0;
|
|
} else if (events[type] !== void 0) {
|
|
if (--this._eventsCount === 0) {
|
|
this._events = /* @__PURE__ */ Object.create(null);
|
|
} else {
|
|
delete events[type];
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
if (arguments.length === 0) {
|
|
const keys = Object.keys(events);
|
|
let key;
|
|
for (i = 0; i < keys.length; ++i) {
|
|
key = keys[i];
|
|
if (key === "removeListener") {
|
|
continue;
|
|
}
|
|
this.removeAllListeners(key);
|
|
}
|
|
this.removeAllListeners("removeListener");
|
|
this._events = /* @__PURE__ */ Object.create(null);
|
|
this._eventsCount = 0;
|
|
return this;
|
|
}
|
|
const listeners2 = events[type];
|
|
if (typeof listeners2 === "function") {
|
|
this.removeListener(type, listeners2);
|
|
} else if (listeners2 !== void 0) {
|
|
for (i = listeners2.length - 1; i >= 0; i--) {
|
|
this.removeListener(type, listeners2[i]);
|
|
}
|
|
}
|
|
return this;
|
|
};
|
|
function _listeners(target, type, unwrap) {
|
|
const events = target._events;
|
|
if (events === void 0) {
|
|
return [];
|
|
}
|
|
const evlistener = events[type];
|
|
if (evlistener === void 0) {
|
|
return [];
|
|
}
|
|
if (typeof evlistener === "function") {
|
|
return unwrap ? [evlistener.listener || evlistener] : [evlistener];
|
|
}
|
|
return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
|
|
}
|
|
EventEmitter.prototype.listeners = function listeners(type) {
|
|
return _listeners(this, type, true);
|
|
};
|
|
EventEmitter.prototype.rawListeners = function rawListeners(type) {
|
|
return _listeners(this, type, false);
|
|
};
|
|
EventEmitter.listenerCount = function(emitter, type) {
|
|
return typeof emitter.listenerCount === "function" ? emitter.listenerCount(type) : listenerCount.call(emitter, type);
|
|
};
|
|
EventEmitter.prototype.listenerCount = listenerCount;
|
|
function listenerCount(type) {
|
|
const events = this._events;
|
|
if (events !== void 0) {
|
|
const evlistener = events[type];
|
|
if (typeof evlistener === "function") {
|
|
return 1;
|
|
} else if (evlistener !== void 0) {
|
|
return evlistener.length;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
EventEmitter.prototype.eventNames = function eventNames() {
|
|
return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
|
|
};
|
|
function arrayClone(arr, n) {
|
|
const copy = new Array(n);
|
|
for (let i = 0; i < n; ++i) {
|
|
copy[i] = arr[i];
|
|
}
|
|
return copy;
|
|
}
|
|
function spliceOne(list, index) {
|
|
for (; index + 1 < list.length; index++) {
|
|
list[index] = list[index + 1];
|
|
}
|
|
list.pop();
|
|
}
|
|
function unwrapListeners(arr) {
|
|
const ret = Array.from({ length: arr.length });
|
|
for (let i = 0; i < ret.length; ++i) {
|
|
ret[i] = arr[i].listener || arr[i];
|
|
}
|
|
return ret;
|
|
}
|
|
function once(emitter, name) {
|
|
return new Promise(function(resolve, reject) {
|
|
function errorListener(err) {
|
|
emitter.removeListener(name, resolver);
|
|
reject(err);
|
|
}
|
|
function resolver() {
|
|
if (typeof emitter.removeListener === "function") {
|
|
emitter.removeListener("error", errorListener);
|
|
}
|
|
resolve(Array.prototype.slice.call(arguments));
|
|
}
|
|
eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
|
|
if (name !== "error") {
|
|
addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
|
|
}
|
|
});
|
|
}
|
|
function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
|
|
if (typeof emitter.on === "function") {
|
|
eventTargetAgnosticAddListener(emitter, "error", handler, flags);
|
|
}
|
|
}
|
|
function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
|
|
if (typeof emitter.on === "function") {
|
|
if (flags.once) {
|
|
emitter.once(name, listener);
|
|
} else {
|
|
emitter.on(name, listener);
|
|
}
|
|
} else if (typeof emitter.addEventListener === "function") {
|
|
emitter.addEventListener(name, function wrapListener(arg) {
|
|
if (flags.once) {
|
|
emitter.removeEventListener(name, wrapListener);
|
|
}
|
|
listener(arg);
|
|
});
|
|
} else {
|
|
throw new TypeError(
|
|
'The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter
|
|
);
|
|
}
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/unenv/runtime/node/events/index.mjs
|
|
|
|
const events_EventEmitter = EventEmitter;
|
|
const events_once = once;
|
|
/* harmony default export */ const events = ({
|
|
EventEmitter: events_EventEmitter,
|
|
once: events_once
|
|
});
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/unenv/runtime/node/stream/readable.mjs
|
|
|
|
class Readable extends events_EventEmitter {
|
|
readableEncoding = null;
|
|
readableEnded = true;
|
|
readableFlowing = false;
|
|
readableHighWaterMark = 0;
|
|
readableLength = 0;
|
|
readableObjectMode = false;
|
|
readableAborted = false;
|
|
readableDidRead = false;
|
|
closed = false;
|
|
errored = null;
|
|
readable = false;
|
|
destroyed = false;
|
|
static from(_iterable, options) {
|
|
return new Readable(options);
|
|
}
|
|
constructor(_opts) {
|
|
super();
|
|
}
|
|
_read(_size) {
|
|
}
|
|
read(_size) {
|
|
}
|
|
setEncoding(_encoding) {
|
|
return this;
|
|
}
|
|
pause() {
|
|
return this;
|
|
}
|
|
resume() {
|
|
return this;
|
|
}
|
|
isPaused() {
|
|
return true;
|
|
}
|
|
unpipe(_destination) {
|
|
return this;
|
|
}
|
|
unshift(_chunk, _encoding) {
|
|
}
|
|
wrap(_oldStream) {
|
|
return this;
|
|
}
|
|
push(_chunk, _encoding) {
|
|
return false;
|
|
}
|
|
_destroy(_error, _callback) {
|
|
this.removeAllListeners();
|
|
}
|
|
destroy(error) {
|
|
this.destroyed = true;
|
|
this._destroy(error);
|
|
return this;
|
|
}
|
|
pipe(_destenition, _options) {
|
|
return {};
|
|
}
|
|
async *[Symbol.asyncIterator]() {
|
|
}
|
|
compose(stream, options) {
|
|
throw new Error("[h3] Method not implemented.");
|
|
}
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/unenv/runtime/node/stream/writable.mjs
|
|
|
|
class Writable extends events_EventEmitter {
|
|
writable = true;
|
|
writableEnded = false;
|
|
writableFinished = false;
|
|
writableHighWaterMark = 0;
|
|
writableLength = 0;
|
|
writableObjectMode = false;
|
|
writableCorked = 0;
|
|
closed = false;
|
|
errored = null;
|
|
writableNeedDrain = false;
|
|
destroyed = false;
|
|
_data;
|
|
_encoding = "utf-8";
|
|
constructor(_opts) {
|
|
super();
|
|
}
|
|
pipe(_destenition, _options) {
|
|
return {};
|
|
}
|
|
_write(chunk, encoding, callback) {
|
|
if (this.writableEnded) {
|
|
if (callback) {
|
|
callback();
|
|
}
|
|
return;
|
|
}
|
|
if (this._data === void 0) {
|
|
this._data = chunk;
|
|
} else {
|
|
const a = typeof this._data === "string" ? Buffer.from(this._data, this._encoding || encoding || "utf8") : this._data;
|
|
const b = typeof chunk === "string" ? Buffer.from(chunk, encoding || this._encoding || "utf8") : chunk;
|
|
this._data = Buffer.concat([a, b]);
|
|
}
|
|
this._encoding = encoding;
|
|
if (callback) {
|
|
callback();
|
|
}
|
|
}
|
|
_writev(_chunks, _callback) {
|
|
}
|
|
_destroy(_error, _callback) {
|
|
}
|
|
_final(_callback) {
|
|
}
|
|
write(chunk, arg2, arg3) {
|
|
const encoding = typeof arg2 === "string" ? this._encoding : "utf-8";
|
|
const cb = typeof arg2 === "function" ? arg2 : typeof arg3 === "function" ? arg3 : void 0;
|
|
this._write(chunk, encoding, cb);
|
|
return true;
|
|
}
|
|
setDefaultEncoding(_encoding) {
|
|
return this;
|
|
}
|
|
end(arg1, arg2, arg3) {
|
|
const callback = typeof arg1 === "function" ? arg1 : typeof arg2 === "function" ? arg2 : typeof arg3 === "function" ? arg3 : void 0;
|
|
if (this.writableEnded) {
|
|
if (callback) {
|
|
callback();
|
|
}
|
|
return this;
|
|
}
|
|
const data = arg1 === callback ? void 0 : arg1;
|
|
if (data) {
|
|
const encoding = arg2 === callback ? void 0 : arg2;
|
|
this.write(data, encoding, callback);
|
|
}
|
|
this.writableEnded = true;
|
|
this.writableFinished = true;
|
|
this.emit("close");
|
|
this.emit("finish");
|
|
return this;
|
|
}
|
|
cork() {
|
|
}
|
|
uncork() {
|
|
}
|
|
destroy(_error) {
|
|
this.destroyed = true;
|
|
delete this._data;
|
|
this.removeAllListeners();
|
|
return this;
|
|
}
|
|
compose(stream, options) {
|
|
throw new Error("[h3] Method not implemented.");
|
|
}
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/unenv/runtime/node/stream/duplex.mjs
|
|
|
|
|
|
|
|
const Duplex = class {
|
|
allowHalfOpen = true;
|
|
_destroy;
|
|
constructor(readable = new Readable(), writable = new Writable()) {
|
|
Object.assign(this, readable);
|
|
Object.assign(this, writable);
|
|
this._destroy = mergeFns(readable._destroy, writable._destroy);
|
|
}
|
|
};
|
|
Object.assign(Duplex.prototype, Readable.prototype);
|
|
Object.assign(Duplex.prototype, Writable.prototype);
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/unenv/runtime/node/net/socket.mjs
|
|
|
|
class Socket extends Duplex {
|
|
bufferSize = 0;
|
|
bytesRead = 0;
|
|
bytesWritten = 0;
|
|
connecting = false;
|
|
destroyed = false;
|
|
pending = false;
|
|
localAddress = "";
|
|
localPort = 0;
|
|
remoteAddress = "";
|
|
remoteFamily = "";
|
|
remotePort = 0;
|
|
readyState = "readOnly";
|
|
constructor(_options) {
|
|
super();
|
|
}
|
|
write(_buffer, _arg1, _arg2) {
|
|
return false;
|
|
}
|
|
connect(_arg1, _arg2, _arg3) {
|
|
return this;
|
|
}
|
|
end(_arg1, _arg2, _arg3) {
|
|
return this;
|
|
}
|
|
setEncoding(_encoding) {
|
|
return this;
|
|
}
|
|
pause() {
|
|
return this;
|
|
}
|
|
resume() {
|
|
return this;
|
|
}
|
|
setTimeout(_timeout, _callback) {
|
|
return this;
|
|
}
|
|
setNoDelay(_noDelay) {
|
|
return this;
|
|
}
|
|
setKeepAlive(_enable, _initialDelay) {
|
|
return this;
|
|
}
|
|
address() {
|
|
return {};
|
|
}
|
|
unref() {
|
|
return this;
|
|
}
|
|
ref() {
|
|
return this;
|
|
}
|
|
resetAndDestroy() {
|
|
const err = new Error("ERR_SOCKET_CLOSED");
|
|
err.code = "ERR_SOCKET_CLOSED";
|
|
this.destroy(err);
|
|
return this;
|
|
}
|
|
}
|
|
class SocketAddress {
|
|
address;
|
|
family;
|
|
port;
|
|
flowlabel;
|
|
constructor(options) {
|
|
this.address = options.address;
|
|
this.family = options.family;
|
|
this.port = options.port;
|
|
this.flowlabel = options.flowlabel;
|
|
}
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/unenv/runtime/node/http/_request.mjs
|
|
|
|
|
|
|
|
class IncomingMessage extends Readable {
|
|
aborted = false;
|
|
httpVersion = "1.1";
|
|
httpVersionMajor = 1;
|
|
httpVersionMinor = 1;
|
|
complete = true;
|
|
connection;
|
|
socket;
|
|
headers = {};
|
|
trailers = {};
|
|
method = "GET";
|
|
url = "/";
|
|
statusCode = 200;
|
|
statusMessage = "";
|
|
closed = false;
|
|
errored = null;
|
|
readable = false;
|
|
constructor(socket) {
|
|
super();
|
|
this.socket = this.connection = socket || new Socket();
|
|
}
|
|
get rawHeaders() {
|
|
return rawHeaders(this.headers);
|
|
}
|
|
get rawTrailers() {
|
|
return [];
|
|
}
|
|
setTimeout(_msecs, _callback) {
|
|
return this;
|
|
}
|
|
get headersDistinct() {
|
|
return _distinct(this.headers);
|
|
}
|
|
get trailersDistinct() {
|
|
return _distinct(this.trailers);
|
|
}
|
|
}
|
|
function _distinct(obj) {
|
|
const d = {};
|
|
for (const [key, value] of Object.entries(obj)) {
|
|
if (key) {
|
|
d[key] = (Array.isArray(value) ? value : [value]).filter(
|
|
Boolean
|
|
);
|
|
}
|
|
}
|
|
return d;
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/unenv/runtime/node/http/_response.mjs
|
|
|
|
class ServerResponse extends Writable {
|
|
statusCode = 200;
|
|
statusMessage = "";
|
|
upgrading = false;
|
|
chunkedEncoding = false;
|
|
shouldKeepAlive = false;
|
|
useChunkedEncodingByDefault = false;
|
|
sendDate = false;
|
|
finished = false;
|
|
headersSent = false;
|
|
strictContentLength = false;
|
|
connection = null;
|
|
socket = null;
|
|
req;
|
|
_headers = {};
|
|
constructor(req) {
|
|
super();
|
|
this.req = req;
|
|
}
|
|
assignSocket(socket) {
|
|
socket._httpMessage = this;
|
|
this.socket = socket;
|
|
this.connection = socket;
|
|
this.emit("socket", socket);
|
|
this._flush();
|
|
}
|
|
_flush() {
|
|
this.flushHeaders();
|
|
}
|
|
detachSocket(_socket) {
|
|
}
|
|
writeContinue(_callback) {
|
|
}
|
|
writeHead(statusCode, arg1, arg2) {
|
|
if (statusCode) {
|
|
this.statusCode = statusCode;
|
|
}
|
|
if (typeof arg1 === "string") {
|
|
this.statusMessage = arg1;
|
|
arg1 = void 0;
|
|
}
|
|
const headers = arg2 || arg1;
|
|
if (headers) {
|
|
if (Array.isArray(headers)) {
|
|
} else {
|
|
for (const key in headers) {
|
|
this.setHeader(key, headers[key]);
|
|
}
|
|
}
|
|
}
|
|
this.headersSent = true;
|
|
return this;
|
|
}
|
|
writeProcessing() {
|
|
}
|
|
setTimeout(_msecs, _callback) {
|
|
return this;
|
|
}
|
|
appendHeader(name, value) {
|
|
name = name.toLowerCase();
|
|
const current = this._headers[name];
|
|
const all = [
|
|
...Array.isArray(current) ? current : [current],
|
|
...Array.isArray(value) ? value : [value]
|
|
].filter(Boolean);
|
|
this._headers[name] = all.length > 1 ? all : all[0];
|
|
return this;
|
|
}
|
|
setHeader(name, value) {
|
|
this._headers[name.toLowerCase()] = value;
|
|
return this;
|
|
}
|
|
getHeader(name) {
|
|
return this._headers[name.toLowerCase()];
|
|
}
|
|
getHeaders() {
|
|
return this._headers;
|
|
}
|
|
getHeaderNames() {
|
|
return Object.keys(this._headers);
|
|
}
|
|
hasHeader(name) {
|
|
return name.toLowerCase() in this._headers;
|
|
}
|
|
removeHeader(name) {
|
|
delete this._headers[name.toLowerCase()];
|
|
}
|
|
addTrailers(_headers) {
|
|
}
|
|
flushHeaders() {
|
|
}
|
|
writeEarlyHints(_headers, cb) {
|
|
if (typeof cb === "function") {
|
|
cb();
|
|
}
|
|
}
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/listhen/node_modules/h3/dist/index.mjs
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function useBase(base, handler) {
|
|
base = withoutTrailingSlash(base);
|
|
if (!base || base === "/") {
|
|
return handler;
|
|
}
|
|
return eventHandler(async (event) => {
|
|
event.node.req.originalUrl = event.node.req.originalUrl || event.node.req.url || "/";
|
|
const _path = event._path || event.node.req.url || "/";
|
|
event._path = withoutBase(event.path || "/", base);
|
|
event.node.req.url = event._path;
|
|
try {
|
|
return await handler(event);
|
|
} finally {
|
|
event._path = event.node.req.url = _path;
|
|
}
|
|
});
|
|
}
|
|
|
|
class H3Error extends Error {
|
|
constructor(message, opts = {}) {
|
|
super(message, opts);
|
|
this.statusCode = 500;
|
|
this.fatal = false;
|
|
this.unhandled = false;
|
|
if (opts.cause && !this.cause) {
|
|
this.cause = opts.cause;
|
|
}
|
|
}
|
|
toJSON() {
|
|
const obj = {
|
|
message: this.message,
|
|
statusCode: sanitizeStatusCode(this.statusCode, 500)
|
|
};
|
|
if (this.statusMessage) {
|
|
obj.statusMessage = sanitizeStatusMessage(this.statusMessage);
|
|
}
|
|
if (this.data !== void 0) {
|
|
obj.data = this.data;
|
|
}
|
|
return obj;
|
|
}
|
|
}
|
|
H3Error.__h3_error__ = true;
|
|
function createError(input) {
|
|
if (typeof input === "string") {
|
|
return new H3Error(input);
|
|
}
|
|
if (isError(input)) {
|
|
return input;
|
|
}
|
|
const err = new H3Error(input.message ?? input.statusMessage ?? "", {
|
|
cause: input.cause || input
|
|
});
|
|
if ("stack" in input) {
|
|
try {
|
|
Object.defineProperty(err, "stack", {
|
|
get() {
|
|
return input.stack;
|
|
}
|
|
});
|
|
} catch {
|
|
try {
|
|
err.stack = input.stack;
|
|
} catch {
|
|
}
|
|
}
|
|
}
|
|
if (input.data) {
|
|
err.data = input.data;
|
|
}
|
|
if (input.statusCode) {
|
|
err.statusCode = sanitizeStatusCode(input.statusCode, err.statusCode);
|
|
} else if (input.status) {
|
|
err.statusCode = sanitizeStatusCode(input.status, err.statusCode);
|
|
}
|
|
if (input.statusMessage) {
|
|
err.statusMessage = input.statusMessage;
|
|
} else if (input.statusText) {
|
|
err.statusMessage = input.statusText;
|
|
}
|
|
if (err.statusMessage) {
|
|
const originalMessage = err.statusMessage;
|
|
const sanitizedMessage = sanitizeStatusMessage(err.statusMessage);
|
|
if (sanitizedMessage !== originalMessage) {
|
|
console.warn(
|
|
"[h3] Please prefer using `message` for longer error messages instead of `statusMessage`. In the future, `statusMessage` will be sanitized by default."
|
|
);
|
|
}
|
|
}
|
|
if (input.fatal !== void 0) {
|
|
err.fatal = input.fatal;
|
|
}
|
|
if (input.unhandled !== void 0) {
|
|
err.unhandled = input.unhandled;
|
|
}
|
|
return err;
|
|
}
|
|
function sendError(event, error, debug) {
|
|
if (event.handled) {
|
|
return;
|
|
}
|
|
const h3Error = isError(error) ? error : createError(error);
|
|
const responseBody = {
|
|
statusCode: h3Error.statusCode,
|
|
statusMessage: h3Error.statusMessage,
|
|
stack: [],
|
|
data: h3Error.data
|
|
};
|
|
if (debug) {
|
|
responseBody.stack = (h3Error.stack || "").split("\n").map((l) => l.trim());
|
|
}
|
|
if (event.handled) {
|
|
return;
|
|
}
|
|
const _code = Number.parseInt(h3Error.statusCode);
|
|
setResponseStatus(event, _code, h3Error.statusMessage);
|
|
event.node.res.setHeader("content-type", MIMES.json);
|
|
event.node.res.end(JSON.stringify(responseBody, void 0, 2));
|
|
}
|
|
function isError(input) {
|
|
return input?.constructor?.__h3_error__ === true;
|
|
}
|
|
|
|
function dist_parse(multipartBodyBuffer, boundary) {
|
|
let lastline = "";
|
|
let state = 0 /* INIT */;
|
|
let buffer = [];
|
|
const allParts = [];
|
|
let currentPartHeaders = [];
|
|
for (let i = 0; i < multipartBodyBuffer.length; i++) {
|
|
const prevByte = i > 0 ? multipartBodyBuffer[i - 1] : null;
|
|
const currByte = multipartBodyBuffer[i];
|
|
const newLineChar = currByte === 10 || currByte === 13;
|
|
if (!newLineChar) {
|
|
lastline += String.fromCodePoint(currByte);
|
|
}
|
|
const newLineDetected = currByte === 10 && prevByte === 13;
|
|
if (0 /* INIT */ === state && newLineDetected) {
|
|
if ("--" + boundary === lastline) {
|
|
state = 1 /* READING_HEADERS */;
|
|
}
|
|
lastline = "";
|
|
} else if (1 /* READING_HEADERS */ === state && newLineDetected) {
|
|
if (lastline.length > 0) {
|
|
const i2 = lastline.indexOf(":");
|
|
if (i2 > 0) {
|
|
const name = lastline.slice(0, i2).toLowerCase();
|
|
const value = lastline.slice(i2 + 1).trim();
|
|
currentPartHeaders.push([name, value]);
|
|
}
|
|
} else {
|
|
state = 2 /* READING_DATA */;
|
|
buffer = [];
|
|
}
|
|
lastline = "";
|
|
} else if (2 /* READING_DATA */ === state) {
|
|
if (lastline.length > boundary.length + 4) {
|
|
lastline = "";
|
|
}
|
|
if ("--" + boundary === lastline) {
|
|
const j = buffer.length - lastline.length;
|
|
const part = buffer.slice(0, j - 1);
|
|
allParts.push(process(part, currentPartHeaders));
|
|
buffer = [];
|
|
currentPartHeaders = [];
|
|
lastline = "";
|
|
state = 3 /* READING_PART_SEPARATOR */;
|
|
} else {
|
|
buffer.push(currByte);
|
|
}
|
|
if (newLineDetected) {
|
|
lastline = "";
|
|
}
|
|
} else if (3 /* READING_PART_SEPARATOR */ === state && newLineDetected) {
|
|
state = 1 /* READING_HEADERS */;
|
|
}
|
|
}
|
|
return allParts;
|
|
}
|
|
function process(data, headers) {
|
|
const dataObj = {};
|
|
const contentDispositionHeader = headers.find((h) => h[0] === "content-disposition")?.[1] || "";
|
|
for (const i of contentDispositionHeader.split(";")) {
|
|
const s = i.split("=");
|
|
if (s.length !== 2) {
|
|
continue;
|
|
}
|
|
const key = (s[0] || "").trim();
|
|
if (key === "name" || key === "filename") {
|
|
const _value = (s[1] || "").trim().replace(/"/g, "");
|
|
dataObj[key] = Buffer.from(_value, "latin1").toString("utf8");
|
|
}
|
|
}
|
|
const contentType = headers.find((h) => h[0] === "content-type")?.[1] || "";
|
|
if (contentType) {
|
|
dataObj.type = contentType;
|
|
}
|
|
dataObj.data = Buffer.from(data);
|
|
return dataObj;
|
|
}
|
|
|
|
async function validateData(data, fn) {
|
|
try {
|
|
const res = await fn(data);
|
|
if (res === false) {
|
|
throw createValidationError();
|
|
}
|
|
if (res === true) {
|
|
return data;
|
|
}
|
|
return res ?? data;
|
|
} catch (error) {
|
|
throw createValidationError(error);
|
|
}
|
|
}
|
|
function createValidationError(validateError) {
|
|
throw createError({
|
|
status: 400,
|
|
message: validateError.message || "Validation Failed",
|
|
...validateError
|
|
});
|
|
}
|
|
|
|
function dist_getQuery(event) {
|
|
return getQuery(event.path || "");
|
|
}
|
|
function getValidatedQuery(event, validate) {
|
|
const query = dist_getQuery(event);
|
|
return validateData(query, validate);
|
|
}
|
|
function getRouterParams(event) {
|
|
return event.context.params || {};
|
|
}
|
|
function getRouterParam(event, name) {
|
|
const params = getRouterParams(event);
|
|
return params[name];
|
|
}
|
|
function getMethod(event, defaultMethod = "GET") {
|
|
return (event.node.req.method || defaultMethod).toUpperCase();
|
|
}
|
|
function isMethod(event, expected, allowHead) {
|
|
if (allowHead && event.method === "HEAD") {
|
|
return true;
|
|
}
|
|
if (typeof expected === "string") {
|
|
if (event.method === expected) {
|
|
return true;
|
|
}
|
|
} else if (expected.includes(event.method)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function assertMethod(event, expected, allowHead) {
|
|
if (!isMethod(event, expected, allowHead)) {
|
|
throw createError({
|
|
statusCode: 405,
|
|
statusMessage: "HTTP method is not allowed."
|
|
});
|
|
}
|
|
}
|
|
function getRequestHeaders(event) {
|
|
const _headers = {};
|
|
for (const key in event.node.req.headers) {
|
|
const val = event.node.req.headers[key];
|
|
_headers[key] = Array.isArray(val) ? val.filter(Boolean).join(", ") : val;
|
|
}
|
|
return _headers;
|
|
}
|
|
const getHeaders = getRequestHeaders;
|
|
function getRequestHeader(event, name) {
|
|
const headers = getRequestHeaders(event);
|
|
const value = headers[name.toLowerCase()];
|
|
return value;
|
|
}
|
|
const getHeader = getRequestHeader;
|
|
function getRequestHost(event, opts = {}) {
|
|
if (opts.xForwardedHost) {
|
|
const xForwardedHost = event.node.req.headers["x-forwarded-host"];
|
|
if (xForwardedHost) {
|
|
return xForwardedHost;
|
|
}
|
|
}
|
|
return event.node.req.headers.host || "localhost";
|
|
}
|
|
function getRequestProtocol(event, opts = {}) {
|
|
if (opts.xForwardedProto !== false && event.node.req.headers["x-forwarded-proto"] === "https") {
|
|
return "https";
|
|
}
|
|
return event.node.req.connection.encrypted ? "https" : "http";
|
|
}
|
|
const DOUBLE_SLASH_RE = /[/\\]{2,}/g;
|
|
function getRequestPath(event) {
|
|
const path = event._originalPath;
|
|
if (path.includes("?")) {
|
|
const [basePath, query] = path.split("?");
|
|
return basePath.replace(DOUBLE_SLASH_RE, "/") + "?" + query;
|
|
} else {
|
|
return path.replace(DOUBLE_SLASH_RE, "/");
|
|
}
|
|
}
|
|
function getRequestURL(event, opts = {}) {
|
|
const host = getRequestHost(event, opts);
|
|
const protocol = getRequestProtocol(event);
|
|
const path = getRequestPath(event);
|
|
return new URL(path, `${protocol}://${host}`);
|
|
}
|
|
|
|
const RawBodySymbol = Symbol.for("h3RawBody");
|
|
const ParsedBodySymbol = Symbol.for("h3ParsedBody");
|
|
const PayloadMethods$2 = ["PATCH", "POST", "PUT", "DELETE"];
|
|
function readRawBody(event, encoding = "utf8") {
|
|
assertMethod(event, PayloadMethods$2);
|
|
const _rawBody = event.node.req[RawBodySymbol] || event.node.req.body;
|
|
if (_rawBody) {
|
|
const promise2 = Promise.resolve(_rawBody).then((_resolved) => {
|
|
if (Buffer.isBuffer(_resolved)) {
|
|
return _resolved;
|
|
}
|
|
if (_resolved.constructor === Object) {
|
|
return Buffer.from(JSON.stringify(_resolved));
|
|
}
|
|
return Buffer.from(_resolved);
|
|
});
|
|
return encoding ? promise2.then((buff) => buff.toString(encoding)) : promise2;
|
|
}
|
|
if (!Number.parseInt(event.node.req.headers["content-length"] || "")) {
|
|
return Promise.resolve(void 0);
|
|
}
|
|
const promise = event.node.req[RawBodySymbol] = new Promise(
|
|
(resolve, reject) => {
|
|
const bodyData = [];
|
|
event.node.req.on("error", (err) => {
|
|
reject(err);
|
|
}).on("data", (chunk) => {
|
|
bodyData.push(chunk);
|
|
}).on("end", () => {
|
|
resolve(Buffer.concat(bodyData));
|
|
});
|
|
}
|
|
);
|
|
const result = encoding ? promise.then((buff) => buff.toString(encoding)) : promise;
|
|
return result;
|
|
}
|
|
async function readBody(event, options = {}) {
|
|
const request = event.node.req;
|
|
if (ParsedBodySymbol in request) {
|
|
return request[ParsedBodySymbol];
|
|
}
|
|
const contentType = request.headers["content-type"] || "";
|
|
const body = await readRawBody(event);
|
|
let parsed;
|
|
if (contentType === "application/json") {
|
|
parsed = _parseJSON(body, options.strict ?? true);
|
|
} else if (contentType.startsWith("application/x-www-form-urlencoded")) {
|
|
parsed = _parseURLEncodedBody(body);
|
|
} else if (contentType.startsWith("text/")) {
|
|
parsed = body;
|
|
} else {
|
|
parsed = _parseJSON(body, options.strict ?? false);
|
|
}
|
|
request[ParsedBodySymbol] = parsed;
|
|
return parsed;
|
|
}
|
|
async function readValidatedBody(event, validate) {
|
|
const _body = await readBody(event, { strict: true });
|
|
return validateData(_body, validate);
|
|
}
|
|
async function readMultipartFormData(event) {
|
|
const contentType = getRequestHeader(event, "content-type");
|
|
if (!contentType || !contentType.startsWith("multipart/form-data")) {
|
|
return;
|
|
}
|
|
const boundary = contentType.match(/boundary=([^;]*)(;|$)/i)?.[1];
|
|
if (!boundary) {
|
|
return;
|
|
}
|
|
const body = await readRawBody(event, false);
|
|
if (!body) {
|
|
return;
|
|
}
|
|
return dist_parse(body, boundary);
|
|
}
|
|
async function readFormData(event) {
|
|
return await event.request.formData();
|
|
}
|
|
function _parseJSON(body = "", strict) {
|
|
if (!body) {
|
|
return void 0;
|
|
}
|
|
try {
|
|
return (0,destr_dist/* default */.ZP)(body, { strict });
|
|
} catch {
|
|
throw createError({
|
|
statusCode: 400,
|
|
statusMessage: "Bad Request",
|
|
message: "Invalid JSON body"
|
|
});
|
|
}
|
|
}
|
|
function _parseURLEncodedBody(body) {
|
|
const form = new URLSearchParams(body);
|
|
const parsedForm = /* @__PURE__ */ Object.create(null);
|
|
for (const [key, value] of form.entries()) {
|
|
if (key in parsedForm) {
|
|
if (!Array.isArray(parsedForm[key])) {
|
|
parsedForm[key] = [parsedForm[key]];
|
|
}
|
|
parsedForm[key].push(value);
|
|
} else {
|
|
parsedForm[key] = value;
|
|
}
|
|
}
|
|
return parsedForm;
|
|
}
|
|
|
|
function handleCacheHeaders(event, opts) {
|
|
const cacheControls = ["public", ...opts.cacheControls || []];
|
|
let cacheMatched = false;
|
|
if (opts.maxAge !== void 0) {
|
|
cacheControls.push(`max-age=${+opts.maxAge}`, `s-maxage=${+opts.maxAge}`);
|
|
}
|
|
if (opts.modifiedTime) {
|
|
const modifiedTime = new Date(opts.modifiedTime);
|
|
const ifModifiedSince = event.node.req.headers["if-modified-since"];
|
|
event.node.res.setHeader("last-modified", modifiedTime.toUTCString());
|
|
if (ifModifiedSince && new Date(ifModifiedSince) >= opts.modifiedTime) {
|
|
cacheMatched = true;
|
|
}
|
|
}
|
|
if (opts.etag) {
|
|
event.node.res.setHeader("etag", opts.etag);
|
|
const ifNonMatch = event.node.req.headers["if-none-match"];
|
|
if (ifNonMatch === opts.etag) {
|
|
cacheMatched = true;
|
|
}
|
|
}
|
|
event.node.res.setHeader("cache-control", cacheControls.join(", "));
|
|
if (cacheMatched) {
|
|
event.node.res.statusCode = 304;
|
|
if (!event.handled) {
|
|
event.node.res.end();
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
const MIMES = {
|
|
html: "text/html",
|
|
json: "application/json"
|
|
};
|
|
|
|
const DISALLOWED_STATUS_CHARS = /[^\u0009\u0020-\u007E]/g;
|
|
function sanitizeStatusMessage(statusMessage = "") {
|
|
return statusMessage.replace(DISALLOWED_STATUS_CHARS, "");
|
|
}
|
|
function sanitizeStatusCode(statusCode, defaultStatusCode = 200) {
|
|
if (!statusCode) {
|
|
return defaultStatusCode;
|
|
}
|
|
if (typeof statusCode === "string") {
|
|
statusCode = Number.parseInt(statusCode, 10);
|
|
}
|
|
if (statusCode < 100 || statusCode > 999) {
|
|
return defaultStatusCode;
|
|
}
|
|
return statusCode;
|
|
}
|
|
|
|
function parseCookies(event) {
|
|
return parse(event.node.req.headers.cookie || "");
|
|
}
|
|
function getCookie(event, name) {
|
|
return parseCookies(event)[name];
|
|
}
|
|
function setCookie(event, name, value, serializeOptions) {
|
|
const cookieStr = serialize(name, value, {
|
|
path: "/",
|
|
...serializeOptions
|
|
});
|
|
let setCookies = event.node.res.getHeader("set-cookie");
|
|
if (!Array.isArray(setCookies)) {
|
|
setCookies = [setCookies];
|
|
}
|
|
setCookies = setCookies.filter((cookieValue) => {
|
|
return cookieValue && !cookieValue.startsWith(name + "=");
|
|
});
|
|
event.node.res.setHeader("set-cookie", [...setCookies, cookieStr]);
|
|
}
|
|
function deleteCookie(event, name, serializeOptions) {
|
|
setCookie(event, name, "", {
|
|
...serializeOptions,
|
|
maxAge: 0
|
|
});
|
|
}
|
|
function splitCookiesString(cookiesString) {
|
|
if (Array.isArray(cookiesString)) {
|
|
return cookiesString.flatMap((c) => splitCookiesString(c));
|
|
}
|
|
if (typeof cookiesString !== "string") {
|
|
return [];
|
|
}
|
|
const cookiesStrings = [];
|
|
let pos = 0;
|
|
let start;
|
|
let ch;
|
|
let lastComma;
|
|
let nextStart;
|
|
let cookiesSeparatorFound;
|
|
const skipWhitespace = () => {
|
|
while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
|
|
pos += 1;
|
|
}
|
|
return pos < cookiesString.length;
|
|
};
|
|
const notSpecialChar = () => {
|
|
ch = cookiesString.charAt(pos);
|
|
return ch !== "=" && ch !== ";" && ch !== ",";
|
|
};
|
|
while (pos < cookiesString.length) {
|
|
start = pos;
|
|
cookiesSeparatorFound = false;
|
|
while (skipWhitespace()) {
|
|
ch = cookiesString.charAt(pos);
|
|
if (ch === ",") {
|
|
lastComma = pos;
|
|
pos += 1;
|
|
skipWhitespace();
|
|
nextStart = pos;
|
|
while (pos < cookiesString.length && notSpecialChar()) {
|
|
pos += 1;
|
|
}
|
|
if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
|
|
cookiesSeparatorFound = true;
|
|
pos = nextStart;
|
|
cookiesStrings.push(cookiesString.slice(start, lastComma));
|
|
start = pos;
|
|
} else {
|
|
pos = lastComma + 1;
|
|
}
|
|
} else {
|
|
pos += 1;
|
|
}
|
|
}
|
|
if (!cookiesSeparatorFound || pos >= cookiesString.length) {
|
|
cookiesStrings.push(cookiesString.slice(start, cookiesString.length));
|
|
}
|
|
}
|
|
return cookiesStrings;
|
|
}
|
|
|
|
const defer = typeof setImmediate === "undefined" ? (fn) => fn() : setImmediate;
|
|
function send(event, data, type) {
|
|
if (type) {
|
|
defaultContentType(event, type);
|
|
}
|
|
return new Promise((resolve) => {
|
|
defer(() => {
|
|
if (!event.handled) {
|
|
event.node.res.end(data);
|
|
}
|
|
resolve();
|
|
});
|
|
});
|
|
}
|
|
function sendNoContent(event, code = 204) {
|
|
event.node.res.statusCode = sanitizeStatusCode(code, 204);
|
|
if (event.node.res.statusCode === 204) {
|
|
event.node.res.removeHeader("content-length");
|
|
}
|
|
if (!event.handled) {
|
|
event.node.res.end();
|
|
}
|
|
}
|
|
function setResponseStatus(event, code, text) {
|
|
if (code) {
|
|
event.node.res.statusCode = sanitizeStatusCode(
|
|
code,
|
|
event.node.res.statusCode
|
|
);
|
|
}
|
|
if (text) {
|
|
event.node.res.statusMessage = sanitizeStatusMessage(text);
|
|
}
|
|
}
|
|
function getResponseStatus(event) {
|
|
return event.node.res.statusCode;
|
|
}
|
|
function getResponseStatusText(event) {
|
|
return event.node.res.statusMessage;
|
|
}
|
|
function defaultContentType(event, type) {
|
|
if (type && !event.node.res.getHeader("content-type")) {
|
|
event.node.res.setHeader("content-type", type);
|
|
}
|
|
}
|
|
function sendRedirect(event, location, code = 302) {
|
|
event.node.res.statusCode = sanitizeStatusCode(
|
|
code,
|
|
event.node.res.statusCode
|
|
);
|
|
event.node.res.setHeader("location", location);
|
|
const encodedLoc = location.replace(/"/g, "%22");
|
|
const html = `<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0; url=${encodedLoc}"></head></html>`;
|
|
return send(event, html, MIMES.html);
|
|
}
|
|
function getResponseHeaders(event) {
|
|
return event.node.res.getHeaders();
|
|
}
|
|
function getResponseHeader(event, name) {
|
|
return event.node.res.getHeader(name);
|
|
}
|
|
function setResponseHeaders(event, headers) {
|
|
for (const [name, value] of Object.entries(headers)) {
|
|
event.node.res.setHeader(name, value);
|
|
}
|
|
}
|
|
const setHeaders = setResponseHeaders;
|
|
function setResponseHeader(event, name, value) {
|
|
event.node.res.setHeader(name, value);
|
|
}
|
|
const setHeader = setResponseHeader;
|
|
function appendResponseHeaders(event, headers) {
|
|
for (const [name, value] of Object.entries(headers)) {
|
|
appendResponseHeader(event, name, value);
|
|
}
|
|
}
|
|
const appendHeaders = appendResponseHeaders;
|
|
function appendResponseHeader(event, name, value) {
|
|
let current = event.node.res.getHeader(name);
|
|
if (!current) {
|
|
event.node.res.setHeader(name, value);
|
|
return;
|
|
}
|
|
if (!Array.isArray(current)) {
|
|
current = [current.toString()];
|
|
}
|
|
event.node.res.setHeader(name, [...current, value]);
|
|
}
|
|
const appendHeader = appendResponseHeader;
|
|
function clearResponseHeaders(event, headerNames) {
|
|
if (headerNames && headerNames.length > 0) {
|
|
for (const name of headerNames) {
|
|
removeResponseHeader(event, name);
|
|
}
|
|
} else {
|
|
for (const [name] of Object.entries(getResponseHeaders(event))) {
|
|
removeResponseHeader(event, name);
|
|
}
|
|
}
|
|
}
|
|
function removeResponseHeader(event, name) {
|
|
return event.node.res.removeHeader(name);
|
|
}
|
|
function isStream(data) {
|
|
if (!data || typeof data !== "object") {
|
|
return false;
|
|
}
|
|
if (typeof data.pipe === "function" && typeof data._read === "function") {
|
|
return true;
|
|
}
|
|
if (typeof data.pipeTo === "function") {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isWebResponse(data) {
|
|
return typeof Response !== "undefined" && data instanceof Response;
|
|
}
|
|
function sendStream(event, stream) {
|
|
if (!stream || typeof stream !== "object") {
|
|
throw new Error("[h3] Invalid stream provided.");
|
|
}
|
|
event.node.res._data = stream;
|
|
if (!event.node.res.socket) {
|
|
event._handled = true;
|
|
return Promise.resolve();
|
|
}
|
|
if ("pipeTo" in stream) {
|
|
return stream.pipeTo(
|
|
new WritableStream({
|
|
write(chunk) {
|
|
event.node.res.write(chunk);
|
|
}
|
|
})
|
|
).then(() => {
|
|
event.node.res.end();
|
|
});
|
|
}
|
|
if ("pipe" in stream && "_read" in stream) {
|
|
return new Promise((resolve, reject) => {
|
|
stream.pipe(event.node.res);
|
|
stream.on("end", () => {
|
|
event.node.res.end();
|
|
resolve();
|
|
});
|
|
stream.on("error", (error) => {
|
|
reject(error);
|
|
});
|
|
});
|
|
}
|
|
throw new Error("[h3] Invalid or incompatible stream provided.");
|
|
}
|
|
const noop = () => {
|
|
};
|
|
function writeEarlyHints(event, hints, cb = noop) {
|
|
if (!event.node.res.socket) {
|
|
cb();
|
|
return;
|
|
}
|
|
if (typeof hints === "string" || Array.isArray(hints)) {
|
|
hints = { link: hints };
|
|
}
|
|
if (hints.link) {
|
|
hints.link = Array.isArray(hints.link) ? hints.link : hints.link.split(",");
|
|
}
|
|
const headers = Object.entries(hints).map(
|
|
(e) => [e[0].toLowerCase(), e[1]]
|
|
);
|
|
if (headers.length === 0) {
|
|
cb();
|
|
return;
|
|
}
|
|
let hint = "HTTP/1.1 103 Early Hints";
|
|
if (hints.link) {
|
|
hint += `\r
|
|
Link: ${hints.link.join(", ")}`;
|
|
}
|
|
for (const [header, value] of headers) {
|
|
if (header === "link") {
|
|
continue;
|
|
}
|
|
hint += `\r
|
|
${header}: ${value}`;
|
|
}
|
|
if (event.node.res.socket) {
|
|
event.node.res.socket.write(
|
|
`${hint}\r
|
|
\r
|
|
`,
|
|
"utf8",
|
|
cb
|
|
);
|
|
} else {
|
|
cb();
|
|
}
|
|
}
|
|
function sendWebResponse(event, response) {
|
|
for (const [key, value] of response.headers) {
|
|
if (key === "set-cookie") {
|
|
event.node.res.appendHeader(key, splitCookiesString(value));
|
|
} else {
|
|
event.node.res.setHeader(key, value);
|
|
}
|
|
}
|
|
if (response.status) {
|
|
event.node.res.statusCode = sanitizeStatusCode(
|
|
response.status,
|
|
event.node.res.statusCode
|
|
);
|
|
}
|
|
if (response.statusText) {
|
|
event.node.res.statusMessage = sanitizeStatusMessage(response.statusText);
|
|
}
|
|
if (response.redirected) {
|
|
event.node.res.setHeader("location", response.url);
|
|
}
|
|
if (!response.body) {
|
|
event.node.res.end();
|
|
return;
|
|
}
|
|
return sendStream(event, response.body);
|
|
}
|
|
|
|
function resolveCorsOptions(options = {}) {
|
|
const defaultOptions = {
|
|
origin: "*",
|
|
methods: "*",
|
|
allowHeaders: "*",
|
|
exposeHeaders: "*",
|
|
credentials: false,
|
|
maxAge: false,
|
|
preflight: {
|
|
statusCode: 204
|
|
}
|
|
};
|
|
return (0,defu/* defu */.ob)(options, defaultOptions);
|
|
}
|
|
function isPreflightRequest(event) {
|
|
const origin = getRequestHeader(event, "origin");
|
|
const accessControlRequestMethod = getRequestHeader(
|
|
event,
|
|
"access-control-request-method"
|
|
);
|
|
return event.method === "OPTIONS" && !!origin && !!accessControlRequestMethod;
|
|
}
|
|
function isCorsOriginAllowed(origin, options) {
|
|
const { origin: originOption } = options;
|
|
if (!origin || !originOption || originOption === "*" || originOption === "null") {
|
|
return true;
|
|
}
|
|
if (Array.isArray(originOption)) {
|
|
return originOption.some((_origin) => {
|
|
if (_origin instanceof RegExp) {
|
|
return _origin.test(origin);
|
|
}
|
|
return origin === _origin;
|
|
});
|
|
}
|
|
return originOption(origin);
|
|
}
|
|
function createOriginHeaders(event, options) {
|
|
const { origin: originOption } = options;
|
|
const origin = getRequestHeader(event, "origin");
|
|
if (!origin || !originOption || originOption === "*") {
|
|
return { "access-control-allow-origin": "*" };
|
|
}
|
|
if (typeof originOption === "string") {
|
|
return { "access-control-allow-origin": originOption, vary: "origin" };
|
|
}
|
|
return isCorsOriginAllowed(origin, options) ? { "access-control-allow-origin": origin, vary: "origin" } : {};
|
|
}
|
|
function createMethodsHeaders(options) {
|
|
const { methods } = options;
|
|
if (!methods) {
|
|
return {};
|
|
}
|
|
if (methods === "*") {
|
|
return { "access-control-allow-methods": "*" };
|
|
}
|
|
return methods.length > 0 ? { "access-control-allow-methods": methods.join(",") } : {};
|
|
}
|
|
function createCredentialsHeaders(options) {
|
|
const { credentials } = options;
|
|
if (credentials) {
|
|
return { "access-control-allow-credentials": "true" };
|
|
}
|
|
return {};
|
|
}
|
|
function createAllowHeaderHeaders(event, options) {
|
|
const { allowHeaders } = options;
|
|
if (!allowHeaders || allowHeaders === "*" || allowHeaders.length === 0) {
|
|
const header = getRequestHeader(event, "access-control-request-headers");
|
|
return header ? {
|
|
"access-control-allow-headers": header,
|
|
vary: "access-control-request-headers"
|
|
} : {};
|
|
}
|
|
return {
|
|
"access-control-allow-headers": allowHeaders.join(","),
|
|
vary: "access-control-request-headers"
|
|
};
|
|
}
|
|
function createExposeHeaders(options) {
|
|
const { exposeHeaders } = options;
|
|
if (!exposeHeaders) {
|
|
return {};
|
|
}
|
|
if (exposeHeaders === "*") {
|
|
return { "access-control-expose-headers": exposeHeaders };
|
|
}
|
|
return { "access-control-expose-headers": exposeHeaders.join(",") };
|
|
}
|
|
function appendCorsPreflightHeaders(event, options) {
|
|
appendHeaders(event, createOriginHeaders(event, options));
|
|
appendHeaders(event, createCredentialsHeaders(options));
|
|
appendHeaders(event, createExposeHeaders(options));
|
|
appendHeaders(event, createMethodsHeaders(options));
|
|
appendHeaders(event, createAllowHeaderHeaders(event, options));
|
|
}
|
|
function appendCorsHeaders(event, options) {
|
|
appendHeaders(event, createOriginHeaders(event, options));
|
|
appendHeaders(event, createCredentialsHeaders(options));
|
|
appendHeaders(event, createExposeHeaders(options));
|
|
}
|
|
|
|
function handleCors(event, options) {
|
|
const _options = resolveCorsOptions(options);
|
|
if (isPreflightRequest(event)) {
|
|
appendCorsPreflightHeaders(event, options);
|
|
sendNoContent(event, _options.preflight.statusCode);
|
|
return true;
|
|
}
|
|
appendCorsHeaders(event, options);
|
|
return false;
|
|
}
|
|
|
|
const PayloadMethods$1 = /* @__PURE__ */ new Set(["PATCH", "POST", "PUT", "DELETE"]);
|
|
const ignoredHeaders = /* @__PURE__ */ new Set([
|
|
"transfer-encoding",
|
|
"connection",
|
|
"keep-alive",
|
|
"upgrade",
|
|
"expect",
|
|
"host"
|
|
]);
|
|
async function proxyRequest(event, target, opts = {}) {
|
|
let body;
|
|
let duplex;
|
|
if (PayloadMethods$1.has(event.method)) {
|
|
if (opts.streamRequest) {
|
|
body = event.body;
|
|
duplex = "half";
|
|
} else {
|
|
body = await readRawBody(event, false).catch(() => void 0);
|
|
}
|
|
}
|
|
const method = opts.fetchOptions?.method || event.method;
|
|
const fetchHeaders = mergeHeaders(
|
|
getProxyRequestHeaders(event),
|
|
opts.fetchOptions?.headers,
|
|
opts.headers
|
|
);
|
|
return sendProxy(event, target, {
|
|
...opts,
|
|
fetchOptions: {
|
|
method,
|
|
body,
|
|
duplex,
|
|
...opts.fetchOptions,
|
|
headers: fetchHeaders
|
|
}
|
|
});
|
|
}
|
|
async function sendProxy(event, target, opts = {}) {
|
|
const response = await _getFetch(opts.fetch)(target, {
|
|
headers: opts.headers,
|
|
ignoreResponseError: true,
|
|
// make $ofetch.raw transparent
|
|
...opts.fetchOptions
|
|
});
|
|
event.node.res.statusCode = sanitizeStatusCode(
|
|
response.status,
|
|
event.node.res.statusCode
|
|
);
|
|
event.node.res.statusMessage = sanitizeStatusMessage(response.statusText);
|
|
const cookies = [];
|
|
for (const [key, value] of response.headers.entries()) {
|
|
if (key === "content-encoding") {
|
|
continue;
|
|
}
|
|
if (key === "content-length") {
|
|
continue;
|
|
}
|
|
if (key === "set-cookie") {
|
|
cookies.push(...splitCookiesString(value));
|
|
continue;
|
|
}
|
|
event.node.res.setHeader(key, value);
|
|
}
|
|
if (cookies.length > 0) {
|
|
event.node.res.setHeader(
|
|
"set-cookie",
|
|
cookies.map((cookie) => {
|
|
if (opts.cookieDomainRewrite) {
|
|
cookie = rewriteCookieProperty(
|
|
cookie,
|
|
opts.cookieDomainRewrite,
|
|
"domain"
|
|
);
|
|
}
|
|
if (opts.cookiePathRewrite) {
|
|
cookie = rewriteCookieProperty(
|
|
cookie,
|
|
opts.cookiePathRewrite,
|
|
"path"
|
|
);
|
|
}
|
|
return cookie;
|
|
})
|
|
);
|
|
}
|
|
if (opts.onResponse) {
|
|
await opts.onResponse(event, response);
|
|
}
|
|
if (response._data !== void 0) {
|
|
return response._data;
|
|
}
|
|
if (event.handled) {
|
|
return;
|
|
}
|
|
if (opts.sendStream === false) {
|
|
const data = new Uint8Array(await response.arrayBuffer());
|
|
return event.node.res.end(data);
|
|
}
|
|
if (response.body) {
|
|
for await (const chunk of response.body) {
|
|
event.node.res.write(chunk);
|
|
}
|
|
}
|
|
return event.node.res.end();
|
|
}
|
|
function getProxyRequestHeaders(event) {
|
|
const headers = /* @__PURE__ */ Object.create(null);
|
|
const reqHeaders = getRequestHeaders(event);
|
|
for (const name in reqHeaders) {
|
|
if (!ignoredHeaders.has(name)) {
|
|
headers[name] = reqHeaders[name];
|
|
}
|
|
}
|
|
return headers;
|
|
}
|
|
function fetchWithEvent(event, req, init, options) {
|
|
return _getFetch(options?.fetch)(req, {
|
|
...init,
|
|
context: init?.context || event.context,
|
|
headers: {
|
|
...getProxyRequestHeaders(event),
|
|
...init?.headers
|
|
}
|
|
});
|
|
}
|
|
function _getFetch(_fetch) {
|
|
if (_fetch) {
|
|
return _fetch;
|
|
}
|
|
if (globalThis.fetch) {
|
|
return globalThis.fetch;
|
|
}
|
|
throw new Error(
|
|
"fetch is not available. Try importing `node-fetch-native/polyfill` for Node.js."
|
|
);
|
|
}
|
|
function rewriteCookieProperty(header, map, property) {
|
|
const _map = typeof map === "string" ? { "*": map } : map;
|
|
return header.replace(
|
|
new RegExp(`(;\\s*${property}=)([^;]+)`, "gi"),
|
|
(match, prefix, previousValue) => {
|
|
let newValue;
|
|
if (previousValue in _map) {
|
|
newValue = _map[previousValue];
|
|
} else if ("*" in _map) {
|
|
newValue = _map["*"];
|
|
} else {
|
|
return match;
|
|
}
|
|
return newValue ? prefix + newValue : "";
|
|
}
|
|
);
|
|
}
|
|
function mergeHeaders(defaults, ...inputs) {
|
|
const _inputs = inputs.filter(Boolean);
|
|
if (_inputs.length === 0) {
|
|
return defaults;
|
|
}
|
|
const merged = new Headers(defaults);
|
|
for (const input of _inputs) {
|
|
for (const [key, value] of Object.entries(input)) {
|
|
if (value !== void 0) {
|
|
merged.set(key, value);
|
|
}
|
|
}
|
|
}
|
|
return merged;
|
|
}
|
|
|
|
const DEFAULT_NAME = "h3";
|
|
const DEFAULT_COOKIE = {
|
|
path: "/",
|
|
secure: true,
|
|
httpOnly: true
|
|
};
|
|
async function useSession(event, config) {
|
|
const sessionName = config.name || DEFAULT_NAME;
|
|
await getSession(event, config);
|
|
const sessionManager = {
|
|
get id() {
|
|
return event.context.sessions?.[sessionName]?.id;
|
|
},
|
|
get data() {
|
|
return event.context.sessions?.[sessionName]?.data || {};
|
|
},
|
|
update: async (update) => {
|
|
await updateSession(event, config, update);
|
|
return sessionManager;
|
|
},
|
|
clear: async () => {
|
|
await clearSession(event, config);
|
|
return sessionManager;
|
|
}
|
|
};
|
|
return sessionManager;
|
|
}
|
|
async function getSession(event, config) {
|
|
const sessionName = config.name || DEFAULT_NAME;
|
|
if (!event.context.sessions) {
|
|
event.context.sessions = /* @__PURE__ */ Object.create(null);
|
|
}
|
|
if (event.context.sessions[sessionName]) {
|
|
return event.context.sessions[sessionName];
|
|
}
|
|
const session = {
|
|
id: "",
|
|
createdAt: 0,
|
|
data: /* @__PURE__ */ Object.create(null)
|
|
};
|
|
event.context.sessions[sessionName] = session;
|
|
let sealedSession;
|
|
if (config.sessionHeader !== false) {
|
|
const headerName = typeof config.sessionHeader === "string" ? config.sessionHeader.toLowerCase() : `x-${sessionName.toLowerCase()}-session`;
|
|
const headerValue = event.node.req.headers[headerName];
|
|
if (typeof headerValue === "string") {
|
|
sealedSession = headerValue;
|
|
}
|
|
}
|
|
if (!sealedSession) {
|
|
sealedSession = getCookie(event, sessionName);
|
|
}
|
|
if (sealedSession) {
|
|
const unsealed = await unsealSession(event, config, sealedSession).catch(
|
|
() => {
|
|
}
|
|
);
|
|
Object.assign(session, unsealed);
|
|
}
|
|
if (!session.id) {
|
|
session.id = config.generateId?.() ?? (config.crypto || _crypto).randomUUID();
|
|
session.createdAt = Date.now();
|
|
await updateSession(event, config);
|
|
}
|
|
return session;
|
|
}
|
|
async function updateSession(event, config, update) {
|
|
const sessionName = config.name || DEFAULT_NAME;
|
|
const session = event.context.sessions?.[sessionName] || await getSession(event, config);
|
|
if (typeof update === "function") {
|
|
update = update(session.data);
|
|
}
|
|
if (update) {
|
|
Object.assign(session.data, update);
|
|
}
|
|
if (config.cookie !== false) {
|
|
const sealed = await sealSession(event, config);
|
|
setCookie(event, sessionName, sealed, {
|
|
...DEFAULT_COOKIE,
|
|
expires: config.maxAge ? new Date(session.createdAt + config.maxAge * 1e3) : void 0,
|
|
...config.cookie
|
|
});
|
|
}
|
|
return session;
|
|
}
|
|
async function sealSession(event, config) {
|
|
const sessionName = config.name || DEFAULT_NAME;
|
|
const session = event.context.sessions?.[sessionName] || await getSession(event, config);
|
|
const sealed = await seal(config.crypto || _crypto, session, config.password, {
|
|
...defaults,
|
|
ttl: config.maxAge ? config.maxAge * 1e3 : 0,
|
|
...config.seal
|
|
});
|
|
return sealed;
|
|
}
|
|
async function unsealSession(_event, config, sealed) {
|
|
const unsealed = await unseal(
|
|
config.crypto || _crypto,
|
|
sealed,
|
|
config.password,
|
|
{
|
|
...defaults,
|
|
ttl: config.maxAge ? config.maxAge * 1e3 : 0,
|
|
...config.seal
|
|
}
|
|
);
|
|
if (config.maxAge) {
|
|
const age = Date.now() - (unsealed.createdAt || Number.NEGATIVE_INFINITY);
|
|
if (age > config.maxAge * 1e3) {
|
|
throw new Error("Session expired!");
|
|
}
|
|
}
|
|
return unsealed;
|
|
}
|
|
async function clearSession(event, config) {
|
|
const sessionName = config.name || DEFAULT_NAME;
|
|
if (event.context.sessions?.[sessionName]) {
|
|
delete event.context.sessions[sessionName];
|
|
}
|
|
await setCookie(event, sessionName, "", {
|
|
...DEFAULT_COOKIE,
|
|
...config.cookie
|
|
});
|
|
}
|
|
|
|
async function serveStatic(event, options) {
|
|
if (event.method !== "GET" && event.method !== "HEAD") {
|
|
if (!options.fallthrough) {
|
|
throw createError({
|
|
statusMessage: "Method Not Allowed",
|
|
statusCode: 405
|
|
});
|
|
}
|
|
return false;
|
|
}
|
|
const originalId = decodePath(
|
|
withLeadingSlash(withoutTrailingSlash(parseURL(event.path).pathname))
|
|
);
|
|
const acceptEncodings = parseAcceptEncoding(
|
|
getRequestHeader(event, "accept-encoding"),
|
|
options.encodings
|
|
);
|
|
if (acceptEncodings.length > 1) {
|
|
setResponseHeader(event, "vary", "accept-encoding");
|
|
}
|
|
let id = originalId;
|
|
let meta;
|
|
const _ids = idSearchPaths(
|
|
originalId,
|
|
acceptEncodings,
|
|
options.indexNames || ["/index.html"]
|
|
);
|
|
for (const _id of _ids) {
|
|
const _meta = await options.getMeta(_id);
|
|
if (_meta) {
|
|
meta = _meta;
|
|
id = _id;
|
|
break;
|
|
}
|
|
}
|
|
if (!meta) {
|
|
if (!options.fallthrough) {
|
|
throw createError({
|
|
statusMessage: "Cannot find static asset " + id,
|
|
statusCode: 404
|
|
});
|
|
}
|
|
return false;
|
|
}
|
|
const ifNotMatch = meta.etag && getRequestHeader(event, "if-none-match") === meta.etag;
|
|
if (ifNotMatch) {
|
|
setResponseStatus(event, 304, "Not Modified");
|
|
return send(event, "");
|
|
}
|
|
if (meta.mtime) {
|
|
const mtimeDate = new Date(meta.mtime);
|
|
const ifModifiedSinceH = getRequestHeader(event, "if-modified-since");
|
|
if (ifModifiedSinceH && new Date(ifModifiedSinceH) >= mtimeDate) {
|
|
setResponseStatus(event, 304, "Not Modified");
|
|
return send(event, null);
|
|
}
|
|
if (!getResponseHeader(event, "last-modified")) {
|
|
setResponseHeader(event, "last-modified", mtimeDate.toUTCString());
|
|
}
|
|
}
|
|
if (meta.type && !getResponseHeader(event, "content-type")) {
|
|
setResponseHeader(event, "content-type", meta.type);
|
|
}
|
|
if (meta.etag && !getResponseHeader(event, "etag")) {
|
|
setResponseHeader(event, "etag", meta.etag);
|
|
}
|
|
if (meta.encoding && !getResponseHeader(event, "content-encoding")) {
|
|
setResponseHeader(event, "content-encoding", meta.encoding);
|
|
}
|
|
if (meta.size !== void 0 && meta.size > 0 && !getResponseHeader(event, "content-length")) {
|
|
setResponseHeader(event, "content-length", meta.size);
|
|
}
|
|
if (event.method === "HEAD") {
|
|
return send(event, null);
|
|
}
|
|
const contents = await options.getContents(id);
|
|
return isStream(contents) ? sendStream(event, contents) : send(event, contents);
|
|
}
|
|
function parseAcceptEncoding(header, encodingMap) {
|
|
if (!encodingMap || !header) {
|
|
return [];
|
|
}
|
|
return String(header || "").split(",").map((e) => encodingMap[e.trim()]).filter(Boolean);
|
|
}
|
|
function idSearchPaths(id, encodings, indexNames) {
|
|
const ids = [];
|
|
for (const suffix of ["", ...indexNames]) {
|
|
for (const encoding of [...encodings, ""]) {
|
|
ids.push(`${id}${suffix}${encoding}`);
|
|
}
|
|
}
|
|
return ids;
|
|
}
|
|
|
|
const PayloadMethods = /* @__PURE__ */ new Set([
|
|
"PATCH",
|
|
"POST",
|
|
"PUT",
|
|
"DELETE"
|
|
]);
|
|
class H3Event {
|
|
constructor(req, res) {
|
|
this["__is_event__"] = true;
|
|
this.context = {};
|
|
// Response
|
|
this._handled = false;
|
|
this.node = { req, res };
|
|
}
|
|
get _originalPath() {
|
|
return this.node.req.originalUrl || this.node.req.url || "/";
|
|
}
|
|
get _hasBody() {
|
|
return PayloadMethods.has(this.method);
|
|
}
|
|
get path() {
|
|
return this._path || this.node.req.url || "/";
|
|
}
|
|
get url() {
|
|
if (!this._url) {
|
|
this._url = getRequestURL(this);
|
|
}
|
|
return this._url;
|
|
}
|
|
get handled() {
|
|
return this._handled || this.node.res.writableEnded || this.node.res.headersSent;
|
|
}
|
|
get method() {
|
|
if (!this._method) {
|
|
this._method = (this.node.req.method || "GET").toUpperCase();
|
|
}
|
|
return this._method;
|
|
}
|
|
get headers() {
|
|
if (!this._headers) {
|
|
this._headers = _normalizeNodeHeaders(this.node.req.headers);
|
|
}
|
|
return this._headers;
|
|
}
|
|
/** @deprecated Please use `event.node.req` instead. **/
|
|
get req() {
|
|
return this.node.req;
|
|
}
|
|
/** @deprecated Please use `event.node.res` instead. **/
|
|
get res() {
|
|
return this.node.res;
|
|
}
|
|
get body() {
|
|
if (!this._hasBody) {
|
|
return void 0;
|
|
}
|
|
if (this._body === void 0) {
|
|
this._body = new ReadableStream({
|
|
start: (controller) => {
|
|
this.node.req.on("data", (chunk) => {
|
|
controller.enqueue(chunk);
|
|
});
|
|
this.node.req.on("end", () => {
|
|
controller.close();
|
|
});
|
|
this.node.req.on("error", (err) => {
|
|
controller.error(err);
|
|
});
|
|
}
|
|
});
|
|
}
|
|
return this._body;
|
|
}
|
|
/** @experimental */
|
|
get request() {
|
|
if (!this._request) {
|
|
this._request = new Request(this.url, {
|
|
// @ts-ignore Undici option
|
|
duplex: "half",
|
|
method: this.method,
|
|
headers: this.headers,
|
|
body: this.body
|
|
});
|
|
}
|
|
return this._request;
|
|
}
|
|
respondWith(response) {
|
|
return Promise.resolve(response).then(
|
|
(_response) => sendWebResponse(this, _response)
|
|
);
|
|
}
|
|
}
|
|
function isEvent(input) {
|
|
return "__is_event__" in input;
|
|
}
|
|
function createEvent(req, res) {
|
|
return new H3Event(req, res);
|
|
}
|
|
function _normalizeNodeHeaders(nodeHeaders) {
|
|
const headers = new Headers();
|
|
for (const [name, value] of Object.entries(nodeHeaders)) {
|
|
if (Array.isArray(value)) {
|
|
for (const item of value) {
|
|
headers.append(name, item);
|
|
}
|
|
} else if (value) {
|
|
headers.set(name, value);
|
|
}
|
|
}
|
|
return headers;
|
|
}
|
|
|
|
function defineEventHandler(handler) {
|
|
handler.__is_handler__ = true;
|
|
return handler;
|
|
}
|
|
const eventHandler = defineEventHandler;
|
|
function isEventHandler(input) {
|
|
return "__is_handler__" in input;
|
|
}
|
|
function toEventHandler(input, _, _route) {
|
|
if (!isEventHandler(input)) {
|
|
console.warn(
|
|
"[h3] Implicit event handler conversion is deprecated. Use `eventHandler()` or `fromNodeMiddleware()` to define event handlers.",
|
|
_route && _route !== "/" ? `
|
|
Route: ${_route}` : "",
|
|
`
|
|
Handler: ${input}`
|
|
);
|
|
}
|
|
return input;
|
|
}
|
|
function dynamicEventHandler(initial) {
|
|
let current = initial;
|
|
const wrapper = eventHandler((event) => {
|
|
if (current) {
|
|
return current(event);
|
|
}
|
|
});
|
|
wrapper.set = (handler) => {
|
|
current = handler;
|
|
};
|
|
return wrapper;
|
|
}
|
|
function defineLazyEventHandler(factory) {
|
|
let _promise;
|
|
let _resolved;
|
|
const resolveHandler = () => {
|
|
if (_resolved) {
|
|
return Promise.resolve(_resolved);
|
|
}
|
|
if (!_promise) {
|
|
_promise = Promise.resolve(factory()).then((r) => {
|
|
const handler = r.default || r;
|
|
if (typeof handler !== "function") {
|
|
throw new TypeError(
|
|
"Invalid lazy handler result. It should be a function:",
|
|
handler
|
|
);
|
|
}
|
|
_resolved = toEventHandler(r.default || r);
|
|
return _resolved;
|
|
});
|
|
}
|
|
return _promise;
|
|
};
|
|
return eventHandler((event) => {
|
|
if (_resolved) {
|
|
return _resolved(event);
|
|
}
|
|
return resolveHandler().then((handler) => handler(event));
|
|
});
|
|
}
|
|
const lazyEventHandler = defineLazyEventHandler;
|
|
|
|
class H3Headers {
|
|
constructor(init) {
|
|
if (!init) {
|
|
this._headers = {};
|
|
} else if (Array.isArray(init)) {
|
|
this._headers = Object.fromEntries(
|
|
init.map(([key, value]) => [key.toLowerCase(), value])
|
|
);
|
|
} else if (init && "append" in init) {
|
|
this._headers = Object.fromEntries(init.entries());
|
|
} else {
|
|
this._headers = Object.fromEntries(
|
|
Object.entries(init).map(([key, value]) => [key.toLowerCase(), value])
|
|
);
|
|
}
|
|
}
|
|
[Symbol.iterator]() {
|
|
return this.entries();
|
|
}
|
|
entries() {
|
|
throw Object.entries(this._headers)[Symbol.iterator]();
|
|
}
|
|
keys() {
|
|
return Object.keys(this._headers)[Symbol.iterator]();
|
|
}
|
|
values() {
|
|
throw Object.values(this._headers)[Symbol.iterator]();
|
|
}
|
|
append(name, value) {
|
|
const _name = name.toLowerCase();
|
|
this.set(_name, [this.get(_name), value].filter(Boolean).join(", "));
|
|
}
|
|
delete(name) {
|
|
delete this._headers[name.toLowerCase()];
|
|
}
|
|
get(name) {
|
|
return this._headers[name.toLowerCase()];
|
|
}
|
|
has(name) {
|
|
return name.toLowerCase() in this._headers;
|
|
}
|
|
set(name, value) {
|
|
this._headers[name.toLowerCase()] = String(value);
|
|
}
|
|
forEach(callbackfn) {
|
|
for (const [key, value] of Object.entries(this._headers)) {
|
|
callbackfn(value, key, this);
|
|
}
|
|
}
|
|
}
|
|
|
|
class H3Response {
|
|
constructor(body = null, init = {}) {
|
|
// TODO: yet to implement
|
|
this.body = null;
|
|
this.type = "default";
|
|
this.bodyUsed = false;
|
|
this.headers = new H3Headers(init.headers);
|
|
this.status = init.status ?? 200;
|
|
this.statusText = init.statusText || "";
|
|
this.redirected = !!init.status && [301, 302, 307, 308].includes(init.status);
|
|
this._body = body;
|
|
this.url = "";
|
|
this.ok = this.status < 300 && this.status > 199;
|
|
}
|
|
clone() {
|
|
return new H3Response(this.body, {
|
|
headers: this.headers,
|
|
status: this.status,
|
|
statusText: this.statusText
|
|
});
|
|
}
|
|
arrayBuffer() {
|
|
return Promise.resolve(this._body);
|
|
}
|
|
blob() {
|
|
return Promise.resolve(this._body);
|
|
}
|
|
formData() {
|
|
return Promise.resolve(this._body);
|
|
}
|
|
json() {
|
|
return Promise.resolve(this._body);
|
|
}
|
|
text() {
|
|
return Promise.resolve(this._body);
|
|
}
|
|
}
|
|
|
|
function createApp(options = {}) {
|
|
const stack = [];
|
|
const handler = createAppEventHandler(stack, options);
|
|
const app = {
|
|
// @ts-ignore
|
|
use: (arg1, arg2, arg3) => use(app, arg1, arg2, arg3),
|
|
handler,
|
|
stack,
|
|
options
|
|
};
|
|
return app;
|
|
}
|
|
function use(app, arg1, arg2, arg3) {
|
|
if (Array.isArray(arg1)) {
|
|
for (const i of arg1) {
|
|
use(app, i, arg2, arg3);
|
|
}
|
|
} else if (Array.isArray(arg2)) {
|
|
for (const i of arg2) {
|
|
use(app, arg1, i, arg3);
|
|
}
|
|
} else if (typeof arg1 === "string") {
|
|
app.stack.push(
|
|
normalizeLayer({ ...arg3, route: arg1, handler: arg2 })
|
|
);
|
|
} else if (typeof arg1 === "function") {
|
|
app.stack.push(
|
|
normalizeLayer({ ...arg2, route: "/", handler: arg1 })
|
|
);
|
|
} else {
|
|
app.stack.push(normalizeLayer({ ...arg1 }));
|
|
}
|
|
return app;
|
|
}
|
|
function createAppEventHandler(stack, options) {
|
|
const spacing = options.debug ? 2 : void 0;
|
|
return eventHandler(async (event) => {
|
|
event.node.req.originalUrl = event.node.req.originalUrl || event.node.req.url || "/";
|
|
const _reqPath = event._path || event.node.req.url || "/";
|
|
let _layerPath;
|
|
if (options.onRequest) {
|
|
await options.onRequest(event);
|
|
}
|
|
for (const layer of stack) {
|
|
if (layer.route.length > 1) {
|
|
if (!_reqPath.startsWith(layer.route)) {
|
|
continue;
|
|
}
|
|
_layerPath = _reqPath.slice(layer.route.length) || "/";
|
|
} else {
|
|
_layerPath = _reqPath;
|
|
}
|
|
if (layer.match && !layer.match(_layerPath, event)) {
|
|
continue;
|
|
}
|
|
event._path = _layerPath;
|
|
event.node.req.url = _layerPath;
|
|
const val = await layer.handler(event);
|
|
const _body = val === void 0 ? void 0 : await val;
|
|
if (_body !== void 0) {
|
|
const _response = { body: _body };
|
|
if (options.onBeforeResponse) {
|
|
await options.onBeforeResponse(event, _response);
|
|
}
|
|
await handleHandlerResponse(event, val, spacing);
|
|
if (options.onAfterResponse) {
|
|
await options.onAfterResponse(event, _response);
|
|
}
|
|
return;
|
|
}
|
|
if (event.handled) {
|
|
if (options.onAfterResponse) {
|
|
await options.onAfterResponse(event, void 0);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
if (!event.handled) {
|
|
throw createError({
|
|
statusCode: 404,
|
|
statusMessage: `Cannot find any path matching ${event.path || "/"}.`
|
|
});
|
|
}
|
|
if (options.onAfterResponse) {
|
|
await options.onAfterResponse(event, void 0);
|
|
}
|
|
});
|
|
}
|
|
function normalizeLayer(input) {
|
|
let handler = input.handler;
|
|
if (handler.handler) {
|
|
handler = handler.handler;
|
|
}
|
|
if (input.lazy) {
|
|
handler = lazyEventHandler(handler);
|
|
} else if (!isEventHandler(handler)) {
|
|
handler = toEventHandler(handler, void 0, input.route);
|
|
}
|
|
return {
|
|
route: withoutTrailingSlash(input.route),
|
|
match: input.match,
|
|
handler
|
|
};
|
|
}
|
|
function handleHandlerResponse(event, val, jsonSpace) {
|
|
if (val === null) {
|
|
event.node.res.statusCode = 204;
|
|
return send(event);
|
|
}
|
|
if (val) {
|
|
if (isWebResponse(val)) {
|
|
return sendWebResponse(event, val);
|
|
}
|
|
if (isStream(val)) {
|
|
return sendStream(event, val);
|
|
}
|
|
if (val.buffer) {
|
|
return send(event, val);
|
|
}
|
|
if (val.arrayBuffer && typeof val.arrayBuffer === "function") {
|
|
return val.arrayBuffer().then((arrayBuffer) => {
|
|
return send(event, Buffer.from(arrayBuffer), val.type);
|
|
});
|
|
}
|
|
if (val instanceof Error) {
|
|
throw createError(val);
|
|
}
|
|
if (typeof val.end === "function") {
|
|
return true;
|
|
}
|
|
}
|
|
const valType = typeof val;
|
|
if (valType === "string") {
|
|
return send(event, val, MIMES.html);
|
|
}
|
|
if (valType === "object" || valType === "boolean" || valType === "number") {
|
|
return send(event, JSON.stringify(val, void 0, jsonSpace), MIMES.json);
|
|
}
|
|
if (valType === "bigint") {
|
|
return send(event, val.toString(), MIMES.json);
|
|
}
|
|
throw createError({
|
|
statusCode: 500,
|
|
statusMessage: `[h3] Cannot send ${valType} as response.`
|
|
});
|
|
}
|
|
|
|
const RouterMethods = [
|
|
"connect",
|
|
"delete",
|
|
"get",
|
|
"head",
|
|
"options",
|
|
"post",
|
|
"put",
|
|
"trace",
|
|
"patch"
|
|
];
|
|
function createRouter(opts = {}) {
|
|
const _router = (0,dist/* createRouter */.p7)({});
|
|
const routes = {};
|
|
let _matcher;
|
|
const router = {};
|
|
const addRoute = (path, handler, method) => {
|
|
let route = routes[path];
|
|
if (!route) {
|
|
routes[path] = route = { handlers: {} };
|
|
_router.insert(path, route);
|
|
}
|
|
if (Array.isArray(method)) {
|
|
for (const m of method) {
|
|
addRoute(path, handler, m);
|
|
}
|
|
} else {
|
|
route.handlers[method] = toEventHandler(handler, void 0, path);
|
|
}
|
|
return router;
|
|
};
|
|
router.use = router.add = (path, handler, method) => addRoute(path, handler, method || "all");
|
|
for (const method of RouterMethods) {
|
|
router[method] = (path, handle) => router.add(path, handle, method);
|
|
}
|
|
router.handler = eventHandler((event) => {
|
|
let path = event.path || "/";
|
|
const qIndex = path.indexOf("?");
|
|
if (qIndex !== -1) {
|
|
path = path.slice(0, Math.max(0, qIndex));
|
|
}
|
|
const matched = _router.lookup(path);
|
|
if (!matched || !matched.handlers) {
|
|
if (opts.preemptive || opts.preemtive) {
|
|
throw createError({
|
|
statusCode: 404,
|
|
name: "Not Found",
|
|
statusMessage: `Cannot find any route matching ${event.path || "/"}.`
|
|
});
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
const method = (event.node.req.method || "get").toLowerCase();
|
|
let handler = matched.handlers[method] || matched.handlers.all;
|
|
if (!handler) {
|
|
if (!_matcher) {
|
|
_matcher = (0,dist/* toRouteMatcher */.F2)(_router);
|
|
}
|
|
const _matches = _matcher.matchAll(path).reverse();
|
|
for (const _match of _matches) {
|
|
if (_match.handlers[method]) {
|
|
handler = _match.handlers[method];
|
|
matched.handlers[method] = matched.handlers[method] || handler;
|
|
break;
|
|
}
|
|
if (_match.handlers.all) {
|
|
handler = _match.handlers.all;
|
|
matched.handlers.all = matched.handlers.all || handler;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!handler) {
|
|
if (opts.preemptive || opts.preemtive) {
|
|
throw createError({
|
|
statusCode: 405,
|
|
name: "Method Not Allowed",
|
|
statusMessage: `Method ${method} is not allowed on this route.`
|
|
});
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
const params = matched.params || {};
|
|
event.context.params = params;
|
|
return Promise.resolve(handler(event)).then((res) => {
|
|
if (res === void 0 && (opts.preemptive || opts.preemtive)) {
|
|
setResponseStatus(event, 204);
|
|
return "";
|
|
}
|
|
return res;
|
|
});
|
|
});
|
|
return router;
|
|
}
|
|
|
|
const defineNodeListener = (handler) => handler;
|
|
const defineNodeMiddleware = (middleware) => middleware;
|
|
function fromNodeMiddleware(handler) {
|
|
if (isEventHandler(handler)) {
|
|
return handler;
|
|
}
|
|
if (typeof handler !== "function") {
|
|
throw new TypeError(
|
|
"Invalid handler. It should be a function:",
|
|
handler
|
|
);
|
|
}
|
|
return eventHandler((event) => {
|
|
return callNodeListener(
|
|
handler,
|
|
event.node.req,
|
|
event.node.res
|
|
);
|
|
});
|
|
}
|
|
function toNodeListener(app) {
|
|
const toNodeHandle = async function(req, res) {
|
|
const event = createEvent(req, res);
|
|
try {
|
|
await app.handler(event);
|
|
} catch (_error) {
|
|
const error = createError(_error);
|
|
if (!isError(_error)) {
|
|
error.unhandled = true;
|
|
}
|
|
if (app.options.onError) {
|
|
await app.options.onError(error, event);
|
|
}
|
|
if (event.handled) {
|
|
return;
|
|
}
|
|
if (error.unhandled || error.fatal) {
|
|
console.error("[h3]", error.fatal ? "[fatal]" : "[unhandled]", error);
|
|
}
|
|
await sendError(event, error, !!app.options.debug);
|
|
}
|
|
};
|
|
return toNodeHandle;
|
|
}
|
|
function promisifyNodeListener(handler) {
|
|
return function(req, res) {
|
|
return callNodeListener(handler, req, res);
|
|
};
|
|
}
|
|
function callNodeListener(handler, req, res) {
|
|
const isMiddleware = handler.length > 2;
|
|
return new Promise((resolve, reject) => {
|
|
const next = (err) => {
|
|
if (isMiddleware) {
|
|
res.off("close", next);
|
|
res.off("error", next);
|
|
}
|
|
return err ? reject(createError(err)) : resolve(void 0);
|
|
};
|
|
try {
|
|
const returned = handler(req, res, next);
|
|
if (isMiddleware && returned === void 0) {
|
|
res.once("close", next);
|
|
res.once("error", next);
|
|
} else {
|
|
resolve(returned);
|
|
}
|
|
} catch (error) {
|
|
next(error);
|
|
}
|
|
});
|
|
}
|
|
|
|
function toPlainHandler(app) {
|
|
const handler = (request) => {
|
|
return _handlePlainRequest(app, request);
|
|
};
|
|
return handler;
|
|
}
|
|
async function _handlePlainRequest(app, request) {
|
|
const path = request.path;
|
|
const method = (request.method || "GET").toUpperCase();
|
|
const headers = new Headers(request.headers);
|
|
const nodeReq = new IncomingMessage();
|
|
const nodeRes = new ServerResponse(nodeReq);
|
|
nodeReq.method = method;
|
|
nodeReq.url = path;
|
|
nodeReq.headers = Object.fromEntries(headers.entries());
|
|
const event = createEvent(nodeReq, nodeRes);
|
|
event._method = method;
|
|
event._path = path;
|
|
event._headers = headers;
|
|
if (request.body) {
|
|
event._body = request.body;
|
|
}
|
|
if (request._eventOverrides) {
|
|
Object.assign(event, request._eventOverrides);
|
|
}
|
|
if (request.context) {
|
|
Object.assign(event.context, request.context);
|
|
}
|
|
try {
|
|
await app.handler(event);
|
|
} catch (_error) {
|
|
const error = createError(_error);
|
|
if (!isError(_error)) {
|
|
error.unhandled = true;
|
|
}
|
|
if (app.options.onError) {
|
|
await app.options.onError(error, event);
|
|
}
|
|
if (!event.handled) {
|
|
if (error.unhandled || error.fatal) {
|
|
console.error("[h3]", error.fatal ? "[fatal]" : "[unhandled]", error);
|
|
}
|
|
await sendError(event, error, !!app.options.debug);
|
|
}
|
|
}
|
|
return {
|
|
status: nodeRes.statusCode,
|
|
statusText: nodeRes.statusMessage,
|
|
headers: _normalizeUnenvHeaders(nodeRes._headers),
|
|
body: nodeRes._data
|
|
};
|
|
}
|
|
function _normalizeUnenvHeaders(input) {
|
|
const headers = [];
|
|
const cookies = [];
|
|
for (const _key in input) {
|
|
const key = _key.toLowerCase();
|
|
if (key === "set-cookie") {
|
|
cookies.push(
|
|
...splitCookiesString(input["set-cookie"])
|
|
);
|
|
continue;
|
|
}
|
|
const value = input[key];
|
|
if (Array.isArray(value)) {
|
|
for (const _value of value) {
|
|
headers.push([key, _value]);
|
|
}
|
|
} else if (value !== void 0) {
|
|
headers.push([key, String(value)]);
|
|
}
|
|
}
|
|
if (cookies.length > 0) {
|
|
for (const cookie of cookies) {
|
|
headers.push(["set-cookie", cookie]);
|
|
}
|
|
}
|
|
return headers;
|
|
}
|
|
|
|
function toWebHandler(app) {
|
|
const webHandler = (request, context) => {
|
|
return _handleWebRequest(app, request, context);
|
|
};
|
|
return webHandler;
|
|
}
|
|
async function _handleWebRequest(app, request, context) {
|
|
const url = new URL(request.url);
|
|
const res = await _handlePlainRequest(app, {
|
|
_eventOverrides: {
|
|
_request: request,
|
|
_url: url
|
|
},
|
|
context,
|
|
method: request.method,
|
|
path: url.pathname + url.search,
|
|
headers: request.headers,
|
|
body: request.body
|
|
});
|
|
return new Response(res.body, {
|
|
status: res.status,
|
|
statusText: res.statusText,
|
|
headers: res.headers
|
|
});
|
|
}
|
|
|
|
|
|
|
|
|
|
/***/ })
|
|
|
|
};
|
|
|
|
//# sourceMappingURL=683.index.js.map
|