@dooboostore/simple-boot-http-server 1.0.16 → 1.0.18

package/dist/cjs/index.js

@@ -0,0 +1,1756 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BadRequestError: () => BadRequestError,
+  CONNECT: () => CONNECT,
+  CacheFilter: () => CacheFilter,
+  CrossDomainHeaderEndPoint: () => CrossDomainHeaderEndPoint,
+  DELETE: () => DELETE,
+  ForbiddenError: () => ForbiddenError,
+  GET: () => GET,
+  HEAD: () => HEAD,
+  HeaderData: () => HeaderData,
+  HeaderEndPoint: () => HeaderEndPoint,
+  HttpError: () => HttpError,
+  HttpHeaders: () => HttpHeaders,
+  HttpMethod: () => HttpMethod,
+  HttpServerOption: () => HttpServerOption,
+  HttpStatus: () => HttpStatus,
+  HttpStatusFilter: () => HttpStatusFilter,
+  InjectSituationType: () => InjectSituationType,
+  InternalServerError: () => InternalServerError,
+  Mimes: () => Mimes,
+  NotFoundError: () => NotFoundError,
+  OPTIONS: () => OPTIONS,
+  OpenApi3Filter: () => OpenApi3Filter,
+  PATCH: () => PATCH,
+  POST: () => POST,
+  PUT: () => PUT,
+  PatchJson: () => PatchJson,
+  ReqFormUrlBody: () => ReqFormUrlBody,
+  ReqHeader: () => ReqHeader,
+  ReqJsonBody: () => ReqJsonBody,
+  ReqMultipartFormBody: () => ReqMultipartFormBody,
+  RequestResponse: () => RequestResponse,
+  RequestResponseChain: () => RequestResponseChain,
+  Resource: () => Resource,
+  ResourceFilter: () => ResourceFilter,
+  ResourceResolver: () => ResourceResolver,
+  SessionManager: () => SessionManager,
+  SimpleBootHttpServer: () => SimpleBootHttpServer,
+  TRACE: () => TRACE,
+  ThrowFilter: () => ThrowFilter,
+  UnauthorizedError: () => UnauthorizedError,
+  UrlMapping: () => UrlMapping,
+  UrlMappingSituationType: () => UrlMappingSituationType,
+  getCONNECT: () => getCONNECT,
+  getCONNECTS: () => getCONNECTS,
+  getDELETE: () => getDELETE,
+  getDELETES: () => getDELETES,
+  getGET: () => getGET,
+  getGETS: () => getGETS,
+  getHEAD: () => getHEAD,
+  getHEADS: () => getHEADS,
+  getOPTIONS: () => getOPTIONS,
+  getOPTIONSS: () => getOPTIONSS,
+  getPATCH: () => getPATCH,
+  getPATCHS: () => getPATCHS,
+  getPOST: () => getPOST,
+  getPOSTS: () => getPOSTS,
+  getPUT: () => getPUT,
+  getPUTS: () => getPUTS,
+  getTRACE: () => getTRACE,
+  getTRACES: () => getTRACES,
+  getUrlMapping: () => getUrlMapping,
+  getUrlMappings: () => getUrlMappings
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/SimpleBootHttpServer.ts
+var import_SimpleApplication = require("@dooboostore/simple-boot/SimpleApplication");
+
+// src/option/HttpServerOption.ts
+var import_SimOption = require("@dooboostore/simple-boot/SimOption");
+var HttpServerOption = class _HttpServerOption extends import_SimOption.SimOption {
+  static {
+    this.DEFAULT_PORT = 8081;
+  }
+  static {
+    this.DEFAULT_HOSTNAME = "127.0.0.1";
+  }
+  constructor({ serverOption, listen, filters, requestEndPoints, closeEndPoints, errorEndPoints, sessionOption, globalAdvice, fileUploadTempPath, noSuchRouteEndPointMappingThrow, transactionManagerFactory } = {}, initSimOption) {
+    super(initSimOption);
+    this.serverOption = serverOption;
+    this.listen = Object.assign({ port: _HttpServerOption.DEFAULT_PORT, hostname: _HttpServerOption.DEFAULT_HOSTNAME }, listen);
+    this.filters = filters;
+    this.requestEndPoints = requestEndPoints;
+    this.closeEndPoints = closeEndPoints;
+    this.errorEndPoints = errorEndPoints;
+    this.sessionOption = Object.assign({ key: "SBSESSIONID", expiredTime: 1e3 * 60 * 30 }, sessionOption);
+    this.globalAdvice = globalAdvice;
+    this.fileUploadTempPath = fileUploadTempPath;
+    this.noSuchRouteEndPointMappingThrow = noSuchRouteEndPointMappingThrow;
+    this.transactionManagerFactory = transactionManagerFactory;
+  }
+  get hostname() {
+    return this.listen.hostname;
+  }
+  get port() {
+    return this.listen.port;
+  }
+  get protocol() {
+    return this.isSecure ? "https" : "http";
+  }
+  get address() {
+    return `${this.protocol}://${this.hostname}:${this.port}`;
+  }
+  get isSecure() {
+    return this.serverOption && "key" in this.serverOption && "cert" in this.serverOption;
+  }
+};
+
+// src/SimpleBootHttpServer.ts
+var import_http = require("http");
+var import_https = require("https");
+
+// src/codes/HttpHeaders.ts
+var HttpHeaders = /* @__PURE__ */ ((HttpHeaders2) => {
+  HttpHeaders2["ContentLength"] = "Content-Length";
+  HttpHeaders2["ContentType"] = "Content-Type";
+  HttpHeaders2["ContentEncoding"] = "Content-Encoding";
+  HttpHeaders2["Accept"] = "Accept";
+  HttpHeaders2["Authorization"] = "Authorization";
+  HttpHeaders2["CacheControl"] = "Cache-Control";
+  HttpHeaders2["Connection"] = "Connection";
+  HttpHeaders2["Date"] = "Date";
+  HttpHeaders2["Host"] = "Host";
+  HttpHeaders2["Pragma"] = "Pragma";
+  HttpHeaders2["Trailer"] = "Trailer";
+  HttpHeaders2["TransferEncoding"] = "Transfer-Encoding";
+  HttpHeaders2["Upgrade"] = "Upgrade";
+  HttpHeaders2["Via"] = "Via";
+  HttpHeaders2["Warning"] = "Warning";
+  HttpHeaders2["AcceptCharset"] = "Accept-Charset";
+  HttpHeaders2["AcceptEncoding"] = "Accept-Encoding";
+  HttpHeaders2["AcceptLanguage"] = "Accept-Language";
+  HttpHeaders2["AccessControlAllowOrigin"] = "Access-Control-Allow-Origin";
+  HttpHeaders2["AccessControlAllowMethods"] = "Access-Control-Allow-Methods";
+  HttpHeaders2["AccessControlAllowHeaders"] = "Access-Control-Allow-Headers";
+  HttpHeaders2["AccessControlExposeHeaders"] = "Access-Control-Expose-Headers";
+  HttpHeaders2["Expect"] = "Expect";
+  HttpHeaders2["From"] = "From";
+  HttpHeaders2["MaxForwards"] = "Max-Forwards";
+  HttpHeaders2["Referer"] = "Referer";
+  HttpHeaders2["UserAgent"] = "User-Agent";
+  HttpHeaders2["Cookie"] = "Cookie";
+  HttpHeaders2["SetCookie"] = "Set-Cookie";
+  HttpHeaders2["Cookie2"] = "Cookie2";
+  HttpHeaders2["SetCookie2"] = "Set-Cookie2";
+  HttpHeaders2["Location"] = "Location";
+  HttpHeaders2["IfModifiedSince"] = "If-Modified-Since";
+  HttpHeaders2["IfUnmodifiedSince"] = "If-Unmodified-Since";
+  HttpHeaders2["IfMatch"] = "If-Match";
+  HttpHeaders2["IfNoneMatch"] = "If-None-Match";
+  HttpHeaders2["IfRange"] = "If-Range";
+  HttpHeaders2["Allow"] = "Allow";
+  HttpHeaders2["Server"] = "Server";
+  return HttpHeaders2;
+})(HttpHeaders || {});
+
+// src/models/RequestResponse.ts
+var import_Intent = require("@dooboostore/simple-boot/intent/Intent");
+var import_url = require("url");
+var import_buffer = require("buffer");
+
+// src/models/datas/body/ReqFormUrlBody.ts
+var ReqFormUrlBody = class {
+};
+
+// src/models/datas/body/ReqJsonBody.ts
+var ReqJsonBody = class {
+};
+
+// src/models/datas/ReqHeader.ts
+var ReqHeader = class {
+};
+
+// src/models/RequestResponse.ts
+var import_node_gzip = require("node-gzip");
+var import_FileUtils = require("@dooboostore/core-node/file/FileUtils");
+var import_ConvertUtils = require("@dooboostore/core/convert/ConvertUtils");
+var import_ConvertUtils2 = require("@dooboostore/core-node/convert/ConvertUtils");
+var RequestResponse = class _RequestResponse {
+  // protected sessionManager?: SessionManager;
+  // constructor(req: IncomingMessage, res: ServerResponse);
+  // constructor(req: RequestResponse);
+  // constructor(req: IncomingMessage, res: ServerResponse, sessionManager?: SessionManager);
+  // constructor(req: IncomingMessage | RequestResponse, res?: ServerResponse, sessionManager?: SessionManager) {
+  //   // this.req = req;
+  //   // this.res = res;
+  //   if (req instanceof RequestResponse) {
+  //     this.req = req.req;
+  //     this.res = req.res;
+  //     this.sessionManager = req.sessionManager;
+  //   } else {
+  //     this.req = req;
+  //     this.res = res!;
+  //     this.sessionManager = sessionManager;
+  //   }
+  // }
+  constructor(req, res, config) {
+    if (req instanceof _RequestResponse) {
+      this.req = req.req;
+      this.res = req.res;
+      this.config = config;
+    } else {
+      this.req = req;
+      this.res = res;
+      this.config = config;
+    }
+  }
+  get reqSocket() {
+    return this.req.socket;
+  }
+  get reqCookieMap() {
+    let cookies = this.reqHeader("Cookie" /* Cookie */) ?? "";
+    if (Array.isArray(cookies)) {
+      cookies = cookies.join(";");
+    }
+    const map = /* @__PURE__ */ new Map();
+    cookies.split(";").map((it) => it.trim().split("=")).forEach((it) => {
+      map.set(it[0], it[1]);
+    });
+    return map;
+  }
+  reqCookieGet(key) {
+    return this.reqCookieMap.get(key);
+  }
+  get reqRemoteAddress() {
+    const ipHeader = this.req.headers["x-forwarded-for"];
+    let ip = this.req.socket.remoteAddress;
+    if (Array.isArray(ipHeader)) {
+      ip = ipHeader.join(",").split(",").shift();
+    } else if (typeof ipHeader === "string") {
+      ip = ipHeader.split(",").shift();
+    }
+    return ip;
+  }
+  get reqUrlObject() {
+    return new import_url.URL(this.reqUrl, `${this.reqSocket ? "https://" : "http"}${this.reqHost ?? "localhost"}`);
+  }
+  get reqUrlPathName() {
+    return this.reqUrlObj().pathname ?? "";
+  }
+  get reqUrl() {
+    return this.req.url ?? "";
+  }
+  reqUrlObj(config) {
+    return new import_url.URL(`${config?.scheme ?? "http"}://${config?.host ? config?.host : this.reqHeaderFirst("Host" /* Host */) ?? "localhost"}${this.req.url ?? ""}`);
+  }
+  get reqUrlSearchParamTuples() {
+    return Array.from(this.reqUrlObj().searchParams);
+  }
+  get reqUrlSearchParams() {
+    return this.reqUrlObj().searchParams;
+  }
+  get reqUrlSearchParamsObj() {
+    const entries = this.reqUrlObj().searchParams;
+    return import_ConvertUtils.ConvertUtils.toObject(entries);
+  }
+  get reqPathSearchParamUrl() {
+    const reqUrlObj = this.reqUrlObj();
+    return reqUrlObj.pathname + (reqUrlObj.searchParams.toString() ? "?" + reqUrlObj.searchParams.toString() : "");
+  }
+  get reqReadable() {
+    return this.req.readable;
+  }
+  get reqIntent() {
+    return new import_Intent.Intent(this.reqPathSearchParamUrl);
+  }
+  reqHasContentTypeHeader(mime3) {
+    return (this.reqHeaderFirst("Content-Type" /* ContentType */) ?? "").toLowerCase().indexOf(mime3.toLocaleLowerCase()) > -1;
+  }
+  reqHasAcceptHeader(mime3) {
+    return (this.reqHeaderFirst("Accept" /* Accept */) ?? "").toLowerCase().indexOf(mime3.toLocaleLowerCase()) > -1;
+  }
+  reqBodyData() {
+    return new Promise((resolve, reject) => {
+      if (this.reqReadable) {
+        const data = [];
+        this.req.on("data", (chunk) => data.push(chunk));
+        this.req.on("error", (err) => reject(err));
+        this.req.on("end", () => {
+          this.reqBodyChunk = import_buffer.Buffer.concat(data);
+          resolve(this.reqBodyChunk);
+        });
+      } else {
+        resolve(this.reqBodyChunk ?? import_buffer.Buffer.alloc(0));
+      }
+    });
+  }
+  resBodyData() {
+    return this.resWriteChunk;
+  }
+  async reqBodyMultipartFormDataObject() {
+    const m = await this.reqBodyMultipartFormData();
+    const formData = {};
+    for (const it of m) {
+      if (it.isFile) {
+        formData[it.name] = await import_FileUtils.FileUtils.writeFile(it.value, { originalName: it.filename });
+      } else {
+        const target = formData[it.name];
+        if (Array.isArray(target)) {
+          target.push(it.value);
+        } else if (typeof target === "string") {
+          formData[it.name] = [target, it.value];
+        } else {
+          formData[it.name] = it.value;
+        }
+      }
+    }
+    ;
+    return formData;
+  }
+  reqBodyMultipartFormData() {
+    return new Promise((resolve, reject) => {
+      const contentTypeHeader = this.req.headers["content-type"];
+      if (!contentTypeHeader || !contentTypeHeader.startsWith("multipart/form-data")) {
+        return reject(new Error("Invalid Content-Type. Expected multipart/form-data."));
+      }
+      const boundaryMatch = contentTypeHeader.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
+      if (!boundaryMatch) {
+        return reject(new Error("Boundary not found in Content-Type header."));
+      }
+      const boundary = boundaryMatch[1] || boundaryMatch[2];
+      if (!boundary) {
+        return reject(new Error("Failed to extract boundary."));
+      }
+      const boundaryBuffer = import_buffer.Buffer.from(`--${boundary}`);
+      const crlfBuffer = import_buffer.Buffer.from("\r\n");
+      const doubleCrlfBuffer = import_buffer.Buffer.from("\r\n\r\n");
+      const chunks = [];
+      let totalLength = 0;
+      this.req.on("data", (chunk) => {
+        chunks.push(chunk);
+        totalLength += chunk.length;
+      });
+      this.req.on("error", (err) => {
+        reject(err);
+      });
+      this.req.on("end", () => {
+        if (totalLength === 0) {
+          return resolve([]);
+        }
+        const fullBuffer = import_buffer.Buffer.concat(chunks, totalLength);
+        const parsedParts = [];
+        let currentPosition = 0;
+        let boundaryStartIndex = fullBuffer.indexOf(boundaryBuffer, currentPosition);
+        if (boundaryStartIndex === -1) {
+          return reject(new Error("Initial boundary not found."));
+        }
+        currentPosition = boundaryStartIndex + boundaryBuffer.length;
+        if (fullBuffer.slice(currentPosition, currentPosition + crlfBuffer.length).equals(crlfBuffer)) {
+          currentPosition += crlfBuffer.length;
+        }
+        while (currentPosition < fullBuffer.length) {
+          const nextBoundaryIndex = fullBuffer.indexOf(boundaryBuffer, currentPosition);
+          if (nextBoundaryIndex === -1) {
+            break;
+          }
+          let partEndIndex = nextBoundaryIndex;
+          if (partEndIndex > crlfBuffer.length && fullBuffer.slice(partEndIndex - crlfBuffer.length, partEndIndex).equals(crlfBuffer)) {
+            partEndIndex -= crlfBuffer.length;
+          }
+          const partBuffer = fullBuffer.slice(currentPosition, partEndIndex);
+          const headerBodySeparatorIndex = partBuffer.indexOf(doubleCrlfBuffer);
+          if (headerBodySeparatorIndex === -1) {
+            console.warn("Skipping malformed part: no header/body separator found.");
+            currentPosition = nextBoundaryIndex + boundaryBuffer.length;
+            if (fullBuffer.slice(currentPosition, currentPosition + crlfBuffer.length).equals(crlfBuffer)) {
+              currentPosition += crlfBuffer.length;
+            }
+            if (fullBuffer.slice(currentPosition, currentPosition + 2).toString() === "--") break;
+            continue;
+          }
+          const headerBuffer = partBuffer.slice(0, headerBodySeparatorIndex);
+          const bodyBuffer = partBuffer.slice(headerBodySeparatorIndex + doubleCrlfBuffer.length);
+          const headersStr = headerBuffer.toString("utf-8");
+          const headers = {};
+          headersStr.split("\r\n").forEach((line) => {
+            const colonIndex = line.indexOf(":");
+            if (colonIndex > 0) {
+              const key = line.substring(0, colonIndex).trim().toLowerCase();
+              const value = line.substring(colonIndex + 1).trim();
+              headers[key] = value;
+            }
+          });
+          const contentDisposition = headers["content-disposition"];
+          if (!contentDisposition) {
+            console.warn("Skipping part: no Content-Disposition header.");
+            currentPosition = nextBoundaryIndex + boundaryBuffer.length;
+            if (fullBuffer.slice(currentPosition, currentPosition + crlfBuffer.length).equals(crlfBuffer)) {
+              currentPosition += crlfBuffer.length;
+            }
+            if (fullBuffer.slice(currentPosition, currentPosition + 2).toString() === "--") break;
+            continue;
+          }
+          const nameMatch = contentDisposition.match(/name="([^"]+)"/i);
+          const filenameMatch = contentDisposition.match(/filename="([^"]+)"/i);
+          const name = nameMatch ? nameMatch[1] : null;
+          const filename = filenameMatch ? filenameMatch[1] : null;
+          const contentType = headers["content-type"] || null;
+          if (name) {
+            const isFile = !!filename;
+            const multipartData = {
+              name,
+              isFile,
+              // filename이 있으면 파일로 간주
+              filename,
+              contentType,
+              value: isFile ? bodyBuffer : bodyBuffer.toString("utf-8")
+            };
+            parsedParts.push(multipartData);
+          } else {
+            console.warn("Skipping part: 'name' not found in Content-Disposition.");
+          }
+          currentPosition = nextBoundaryIndex + boundaryBuffer.length;
+          if (fullBuffer.slice(currentPosition, currentPosition + crlfBuffer.length).equals(crlfBuffer)) {
+            currentPosition += crlfBuffer.length;
+          }
+          if (fullBuffer.slice(currentPosition, currentPosition + 2).toString() === "--") {
+            break;
+          }
+        }
+        resolve(parsedParts);
+      });
+    });
+  }
+  async reqBodyStringData() {
+    const data = (await this.reqBodyData()).toString();
+    return data;
+  }
+  async reqBodyJsonData() {
+    return JSON.parse(await this.reqBodyStringData());
+  }
+  async reqBodyFormUrlData() {
+    const data = await this.reqBodyStringData();
+    const formData = {};
+    Array.from(new import_url.URLSearchParams(data).entries()).forEach(([k, v]) => {
+      const target = formData[k];
+      if (Array.isArray(target)) {
+        target.push(v);
+      } else if (typeof target === "string") {
+        formData[k] = [target, v];
+      } else {
+        formData[k] = v;
+      }
+    });
+    return formData;
+  }
+  async reqBodyReqFormUrlBody() {
+    const data = await this.reqBodyFormUrlData();
+    return Object.assign(new ReqFormUrlBody(), data);
+  }
+  async reqBodyReqJsonBody() {
+    const data = await this.reqBodyStringData();
+    return Object.assign(new ReqJsonBody(), data ? JSON.parse(data) : {});
+  }
+  // reqBodyReqMultipartFormBody(): Promise<ReqMultipartFormBody> {
+  //   return this.reqBodyMultipartFormData().then(it => new ReqMultipartFormBody(it))
+  // }
+  resBodyJsonData() {
+    const data = import_ConvertUtils2.ConvertUtils.toString(this.resBodyData());
+    return data ? JSON.parse(data) : null;
+  }
+  resBodyStringData() {
+    return import_ConvertUtils2.ConvertUtils.toString(this.resBodyData());
+  }
+  reqMethod() {
+    return this.req.method?.toUpperCase();
+  }
+  reqHeader(key) {
+    return this.req.headers[key.toLowerCase()];
+  }
+  get reqHost() {
+    return this.reqHeaderFirst("Host" /* Host */);
+  }
+  get reqHeaderObj() {
+    const h = new ReqHeader();
+    Object.entries(this.req.headers).forEach(([k, v]) => {
+      h[k] = v;
+    });
+    return h;
+  }
+  reqHeaderFirst(key, defaultValue) {
+    const header = this.req.headers[key.toLowerCase()];
+    if (header && Array.isArray(header)) {
+      return header[0] ?? defaultValue;
+    } else {
+      return header ?? defaultValue;
+    }
+  }
+  reqAuthorizationHeader() {
+    return this.reqHeaderFirst("Authorization" /* Authorization */);
+  }
+  reqRefreshTokenHeader() {
+    return this.reqHeaderFirst("Authorization" /* Authorization */);
+  }
+  // eslint-disable-next-line no-dupe-class-members
+  resStatusCode(code) {
+    if (code) {
+      this.res.statusCode = code;
+      return new RequestResponseChain(this.req, this.res, this.config, this.res.statusCode);
+    } else {
+      return this.res.statusCode;
+    }
+  }
+  resHeader(key) {
+    return this.res.getHeader(key.toLowerCase());
+  }
+  resHeaderFirst(key, defaultValue) {
+    const header = this.res.getHeader(key.toLowerCase());
+    if (header && Array.isArray(header)) {
+      return header[0] ?? defaultValue;
+    } else {
+      return header ?? defaultValue;
+    }
+  }
+  async reqSession() {
+    if (this.config.sessionManager) {
+      return (await this.config.sessionManager.session(this)).dataSet.data;
+    } else {
+      return Promise.reject(new Error("Not SessionManager"));
+    }
+  }
+  reqSessionSet(key, value) {
+    this.reqSession[key] = value;
+  }
+  reqSessionGet(key) {
+    const session = this.reqSession;
+    if (session) {
+      return session[key];
+    }
+  }
+  resSetStatusCode(statusCode) {
+    this.res.statusCode = statusCode;
+    return this.createRequestResponseChain(this.res.statusCode);
+  }
+  // resEnd() {
+  //     this.res.end();
+  // }
+  // eslint-disable-next-line no-undef
+  resWrite(chunk, encoding = "utf8") {
+    this.resWriteChunk = chunk;
+    return this.createRequestResponseChain(this.resWriteChunk);
+  }
+  // eslint-disable-next-line no-undef
+  resWriteJson(chunk, encoding = "utf8") {
+    return this.resWrite(JSON.stringify(chunk), encoding);
+  }
+  resSetHeader(key, value) {
+    return this.createRequestResponseChain(this.res.setHeader(key.toLowerCase(), value));
+  }
+  resAddHeader(key, value) {
+    const existingValue = this.res.getHeader(key.toLowerCase());
+    const newValue = Array.isArray(existingValue) ? existingValue.concat(value) : existingValue ? [existingValue.toString(), ...[].concat(value)] : value;
+    return this.createRequestResponseChain(this.res.setHeader(key.toLowerCase(), newValue));
+  }
+  resSetHeaders(headers) {
+    Object.entries(headers).forEach(([key, value]) => this.resSetHeader(key, value));
+    return this.createRequestResponseChain();
+  }
+  resAddHeaders(headers) {
+    Object.entries(headers).forEach(([key, value]) => this.resAddHeader(key, value));
+    return this.createRequestResponseChain();
+  }
+  // 마지막 종료될때 타는거.
+  async resEndChunk() {
+    const encoding = this.reqHeaderFirst("Accept-Encoding" /* AcceptEncoding */);
+    let data = this.resWriteChunk;
+    if (encoding?.includes("gzip")) {
+      data = await (0, import_node_gzip.gzip)(data);
+      this.resSetHeader("Content-Encoding" /* ContentEncoding */, "gzip");
+    }
+    this.res.end(data);
+  }
+  async resEnd(chunk) {
+    this.resWriteChunk = chunk ?? this.resWriteChunk;
+    if (this.req.readable) {
+      await this.reqBodyData();
+      await this.resEndChunk();
+    } else {
+      await this.resEndChunk();
+    }
+  }
+  // writeContinue(callback?: () => void) {
+  //     this.res.writeContinue(callback);
+  //     return new RequestResponseChain(this.req, this.res);
+  // }
+  // reqWrite(chunk?: any) {
+  //     this.resWriteChunk = chunk;
+  //     // this.res.write(chunk);
+  //     return this.createRequestResponseChain();
+  // }
+  resWriteHead(statusCode, headers) {
+    return this.createRequestResponseChain(this.res.writeHead(statusCode, headers));
+  }
+  resWriteHeadEnd(statusCode, headers) {
+    this.createRequestResponseChain(this.res.writeHead(statusCode, headers));
+    this.res.end();
+  }
+  resIsDone() {
+    return this.res.finished || this.res.writableEnded || this.res.headersSent;
+  }
+  createRequestResponseChain(data) {
+    const requestResponseChain = new RequestResponseChain(this.req, this.res, this.config, data);
+    requestResponseChain.resWriteChunk = this.resWriteChunk;
+    requestResponseChain.reqBodyChunk = this.reqBodyChunk;
+    return requestResponseChain;
+  }
+  // res.on("readable", () => {
+  //     console.log('readable???')
+  // });
+  // res.on('complete', function (details) {
+  //     var size = details.req.bytes;
+  //     console.log('complete-->', size)
+  // });
+  // res.on('finish', function() {
+  //     console.log('finish??');
+  // });
+  // res.on('end', () => {
+  //     console.log('end--?')
+  // });
+};
+var RequestResponseChain = class extends RequestResponse {
+  constructor(req, res, config, result) {
+    super(req, res, config);
+    this.result = result;
+  }
+};
+
+// src/decorators/MethodMapping.ts
+var import_reflect_metadata = require("reflect-metadata");
+var import_ReflectUtils = require("@dooboostore/core/reflect/ReflectUtils");
+
+// src/codes/HttpMethod.ts
+var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
+  HttpMethod2["GET"] = "GET";
+  HttpMethod2["POST"] = "POST";
+  HttpMethod2["PUT"] = "PUT";
+  HttpMethod2["DELETE"] = "DELETE";
+  HttpMethod2["PATCH"] = "PATCH";
+  HttpMethod2["HEAD"] = "HEAD";
+  HttpMethod2["OPTIONS"] = "OPTIONS";
+  HttpMethod2["TRACE"] = "TRACE";
+  HttpMethod2["CONNECT"] = "CONNECT";
+  return HttpMethod2;
+})(HttpMethod || {});
+
+// src/decorators/MethodMapping.ts
+var UrlMappingSituationType = /* @__PURE__ */ ((UrlMappingSituationType2) => {
+  UrlMappingSituationType2["REQ_JSON_BODY"] = "SIMPLE_BOOT_HTTP_SERVER://URLMAPPING/REQ_JSON_BODY";
+  UrlMappingSituationType2["REQ_FORM_URL_BODY"] = "SIMPLE_BOOT_HTTP_SERVER://URLMAPPING/REQ_FORM_URL_BODY";
+  return UrlMappingSituationType2;
+})(UrlMappingSituationType || {});
+var MappingMetadataKey = Symbol("MappingMetadataKey");
+var process2 = (config, target, propertyKey, descriptor) => {
+  const saveMappingConfigs = import_ReflectUtils.ReflectUtils.getMetadata(MappingMetadataKey, target.constructor) ?? [];
+  saveMappingConfigs.push({ propertyKey, config });
+  import_ReflectUtils.ReflectUtils.defineMetadata(MappingMetadataKey, saveMappingConfigs, target.constructor);
+  import_ReflectUtils.ReflectUtils.defineMetadata(MappingMetadataKey, config, target, propertyKey);
+};
+function UrlMapping(configOrtarget, propertyKey, descriptor) {
+  if (propertyKey && descriptor) {
+    process2({ method: "GET" /* GET */ }, configOrtarget, propertyKey, descriptor);
+  } else {
+    return (target, propertyKey2, descriptor2) => {
+      process2(configOrtarget, target, propertyKey2, descriptor2);
+    };
+  }
+}
+var getUrlMapping = (target, propertyKey) => {
+  return import_ReflectUtils.ReflectUtils.getMetadata(MappingMetadataKey, target, propertyKey);
+};
+var getUrlMappings = (target) => {
+  if (target !== null && void 0 !== target && typeof target === "object") {
+    target = target.constructor;
+  }
+  return import_ReflectUtils.ReflectUtils.getMetadata(MappingMetadataKey, target);
+};
+function GET(configOrTarget, propertyKey, descriptor) {
+  if (propertyKey && descriptor) {
+    process2({ method: "GET" /* GET */ }, configOrTarget, propertyKey, descriptor);
+  } else {
+    return (target, propertyKey2, descriptor2) => {
+      configOrTarget.method = "GET" /* GET */;
+      process2(configOrTarget, target, propertyKey2, descriptor2);
+    };
+  }
+}
+var getGET = (target, propertyKey) => {
+  return getUrlMapping(target, propertyKey);
+};
+var getGETS = (target) => {
+  return getUrlMappings(target)?.filter((it) => it.config?.method.toUpperCase() === "GET" /* GET */);
+};
+function POST(configOrTarget, propertyKey, descriptor) {
+  if (propertyKey && descriptor) {
+    process2({ method: "POST" /* POST */ }, configOrTarget, propertyKey, descriptor);
+  } else {
+    return (target, propertyKey2, descriptor2) => {
+      configOrTarget.method = "POST" /* POST */;
+      process2(configOrTarget, target, propertyKey2, descriptor2);
+    };
+  }
+}
+var getPOST = (target, propertyKey) => {
+  return getUrlMapping(target, propertyKey);
+};
+var getPOSTS = (target) => {
+  return getUrlMappings(target)?.filter((it) => it.config?.method.toUpperCase() === "POST" /* POST */);
+};
+function DELETE(configOrTarget, propertyKey, descriptor) {
+  if (propertyKey && descriptor) {
+    process2({ method: "DELETE" /* DELETE */ }, configOrTarget, propertyKey, descriptor);
+  } else {
+    return (target, propertyKey2, descriptor2) => {
+      configOrTarget.method = "DELETE" /* DELETE */;
+      process2(configOrTarget, target, propertyKey2, descriptor2);
+    };
+  }
+}
+var getDELETE = (target, propertyKey) => {
+  return getUrlMapping(target, propertyKey);
+};
+var getDELETES = (target) => {
+  return getUrlMappings(target)?.filter((it) => it.config?.method.toUpperCase() === "DELETE" /* DELETE */);
+};
+function PUT(configOrTarget, propertyKey, descriptor) {
+  if (propertyKey && descriptor) {
+    process2({ method: "PUT" /* PUT */ }, configOrTarget, propertyKey, descriptor);
+  } else {
+    return (target, propertyKey2, descriptor2) => {
+      configOrTarget.method = "PUT" /* PUT */;
+      process2(configOrTarget, target, propertyKey2, descriptor2);
+    };
+  }
+}
+var getPUT = (target, propertyKey) => {
+  return getUrlMapping(target, propertyKey);
+};
+var getPUTS = (target) => {
+  return getUrlMappings(target)?.filter((it) => it.config?.method.toUpperCase() === "PUT" /* PUT */);
+};
+function PATCH(configOrTarget, propertyKey, descriptor) {
+  if (propertyKey && descriptor) {
+    process2({ method: "PATCH" /* PATCH */ }, configOrTarget, propertyKey, descriptor);
+  } else {
+    return (target, propertyKey2, descriptor2) => {
+      configOrTarget.method = "PATCH" /* PATCH */;
+      process2(configOrTarget, target, propertyKey2, descriptor2);
+    };
+  }
+}
+var getPATCH = (target, propertyKey) => {
+  return getUrlMapping(target, propertyKey);
+};
+var getPATCHS = (target) => {
+  return getUrlMappings(target)?.filter((it) => it.config?.method.toUpperCase() === "GET" /* GET */);
+};
+function OPTIONS(configOrTarget, propertyKey, descriptor) {
+  if (propertyKey && descriptor) {
+    process2({ method: "OPTIONS" /* OPTIONS */ }, configOrTarget, propertyKey, descriptor);
+  } else {
+    return (target, propertyKey2, descriptor2) => {
+      configOrTarget.method = "OPTIONS" /* OPTIONS */;
+      process2(configOrTarget, target, propertyKey2, descriptor2);
+    };
+  }
+}
+var getOPTIONS = (target, propertyKey) => {
+  return getUrlMapping(target, propertyKey);
+};
+var getOPTIONSS = (target) => {
+  return getUrlMappings(target)?.filter((it) => it.config?.method.toUpperCase() === "OPTIONS" /* OPTIONS */);
+};
+function HEAD(configOrTarget, propertyKey, descriptor) {
+  if (propertyKey && descriptor) {
+    process2({ method: "HEAD" /* HEAD */ }, configOrTarget, propertyKey, descriptor);
+  } else {
+    return (target, propertyKey2, descriptor2) => {
+      configOrTarget.method = "HEAD" /* HEAD */;
+      process2(configOrTarget, target, propertyKey2, descriptor2);
+    };
+  }
+}
+var getHEAD = (target, propertyKey) => {
+  return getUrlMapping(target, propertyKey);
+};
+var getHEADS = (target) => {
+  return getUrlMappings(target)?.filter((it) => it.config?.method.toUpperCase() === "GET" /* GET */);
+};
+function TRACE(configOrTarget, propertyKey, descriptor) {
+  if (propertyKey && descriptor) {
+    process2({ method: "TRACE" /* TRACE */ }, configOrTarget, propertyKey, descriptor);
+  } else {
+    return (target, propertyKey2, descriptor2) => {
+      configOrTarget.method = "TRACE" /* TRACE */;
+      process2(configOrTarget, target, propertyKey2, descriptor2);
+    };
+  }
+}
+var getTRACE = (target, propertyKey) => {
+  return getUrlMapping(target, propertyKey);
+};
+var getTRACES = (target) => {
+  return getUrlMappings(target)?.filter((it) => it.config?.method.toUpperCase() === "TRACE" /* TRACE */);
+};
+function CONNECT(configOrTarget, propertyKey, descriptor) {
+  if (propertyKey && descriptor) {
+    process2({ method: "CONNECT" /* CONNECT */ }, configOrTarget, propertyKey, descriptor);
+  } else {
+    return (target, propertyKey2, descriptor2) => {
+      configOrTarget.method = "CONNECT" /* CONNECT */;
+      process2(configOrTarget, target, propertyKey2, descriptor2);
+    };
+  }
+}
+var getCONNECT = (target, propertyKey) => {
+  return getUrlMapping(target, propertyKey);
+};
+var getCONNECTS = (target) => {
+  return getUrlMappings(target)?.filter((it) => it.config?.method.toUpperCase() === "CONNECT" /* CONNECT */);
+};
+
+// src/codes/HttpStatus.ts
+var HttpStatus = /* @__PURE__ */ ((HttpStatus2) => {
+  HttpStatus2[HttpStatus2["Ok"] = 200] = "Ok";
+  HttpStatus2[HttpStatus2["MovedPermanently"] = 301] = "MovedPermanently";
+  HttpStatus2[HttpStatus2["Found"] = 302] = "Found";
+  HttpStatus2[HttpStatus2["SeeOther"] = 303] = "SeeOther";
+  HttpStatus2[HttpStatus2["NotModified"] = 304] = "NotModified";
+  HttpStatus2[HttpStatus2["TemporaryRedirect"] = 307] = "TemporaryRedirect";
+  HttpStatus2[HttpStatus2["PermanentRedirect"] = 308] = "PermanentRedirect";
+  HttpStatus2[HttpStatus2["BadRequest"] = 400] = "BadRequest";
+  HttpStatus2[HttpStatus2["Unauthorized"] = 401] = "Unauthorized";
+  HttpStatus2[HttpStatus2["Forbidden"] = 403] = "Forbidden";
+  HttpStatus2[HttpStatus2["NotFound"] = 404] = "NotFound";
+  HttpStatus2[HttpStatus2["InternalServerError"] = 500] = "InternalServerError";
+  HttpStatus2[HttpStatus2["NotImplemented"] = 501] = "NotImplemented";
+  HttpStatus2[HttpStatus2["BadGateway"] = 502] = "BadGateway";
+  HttpStatus2[HttpStatus2["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+  HttpStatus2[HttpStatus2["GatewayTimeout"] = 504] = "GatewayTimeout";
+  HttpStatus2[HttpStatus2["HttpVersionNotSupported"] = 505] = "HttpVersionNotSupported";
+  return HttpStatus2;
+})(HttpStatus || {});
+
+// src/codes/Mimes.ts
+var Mimes = /* @__PURE__ */ ((Mimes2) => {
+  Mimes2["ApplicationJson"] = "application/json";
+  Mimes2["ApplicationOctetStream"] = "application/octet-stream";
+  Mimes2["ApplicationXml"] = "application/xml";
+  Mimes2["ApplicationJsonPatch"] = "application/json-patch+json";
+  Mimes2["ApplicationXWwwFormUrlencoded"] = "application/x-www-form-urlencoded";
+  Mimes2["TextPlain"] = "text/plain";
+  Mimes2["TextHtml"] = "text/html";
+  Mimes2["All"] = "*/*";
+  Mimes2["TextCss"] = "text/css";
+  Mimes2["TextJavascript"] = "text/javascript";
+  Mimes2["TextXml"] = "text/xml";
+  Mimes2["TextXslt"] = "text/xslt";
+  Mimes2["TextXmlDtd"] = "text/xml-dtd";
+  Mimes2["TextPlainUtf8"] = "text/plain; charset=utf-8";
+  Mimes2["ImagePng"] = "image/png";
+  Mimes2["ImageGif"] = "image/gif";
+  Mimes2["ImageJpeg"] = "image/jpeg";
+  Mimes2["ImageSvg"] = "image/svg+xml";
+  Mimes2["ImageBmp"] = "image/bmp";
+  Mimes2["ImageTiff"] = "image/tiff";
+  Mimes2["ImagePdf"] = "application/pdf";
+  Mimes2["ImageXBmp"] = "image/x-bmp";
+  Mimes2["ImageXpixmap"] = "image/x-xpixmap";
+  Mimes2["ImageXxbm"] = "image/x-xbm";
+  Mimes2["MultipartFormData"] = "multipart/form-data";
+  return Mimes2;
+})(Mimes || {});
+
+// src/SimpleBootHttpServer.ts
+var import_ExceptionDecorator = require("@dooboostore/simple-boot/decorators/exception/ExceptionDecorator");
+var import_Inject = require("@dooboostore/simple-boot/decorators/inject/Inject");
+var import_ReflectUtils2 = require("@dooboostore/core/reflect/ReflectUtils");
+var import_RouterModule = require("@dooboostore/simple-boot/route/RouterModule");
+
+// src/models/datas/body/ReqMultipartFormBody.ts
+var ReqMultipartFormBody = class {
+  constructor(field = []) {
+    this.field = field;
+  }
+};
+
+// src/SimpleBootHttpServer.ts
+var import_Validation = require("@dooboostore/simple-boot/decorators/validate/Validation");
+var import_ValidException = require("@dooboostore/simple-boot/errors/ValidException");
+
+// src/errors/HttpError.ts
+var HttpError = class {
+  constructor({ status, message = "HttpError" }) {
+    this.name = "Error";
+    this.message = message;
+    this.status = status;
+  }
+};
+
+// src/SimpleBootHttpServer.ts
+var import_Router = require("@dooboostore/simple-boot/decorators/route/Router");
+var import_url2 = require("url");
+
+// src/session/SessionManager.ts
+var import_RandomUtils = require("@dooboostore/core/random/RandomUtils");
+var SessionManager = class {
+  constructor(option) {
+    this.option = option;
+    this.sessions = /* @__PURE__ */ new Map();
+    this.sessionOption = option.sessionOption;
+    setInterval(async () => {
+      const uuids = await this.getSessionUUIDs();
+      for (const uuid of uuids) {
+        const dataSet = await this.getSessionDataSet(uuid);
+        if (dataSet && this.isExpired(dataSet.access)) {
+          await this.deleteSession(uuid);
+        }
+      }
+    }, this.sessionOption.expiredTime);
+  }
+  async getSessionUUIDs() {
+    if (this.sessionOption.provider?.uuids) {
+      return this.sessionOption.provider.uuids();
+    } else {
+      return Array.from(this.sessions.keys());
+    }
+  }
+  async deleteSession(uuid) {
+    if (this.sessionOption.provider?.delete) {
+      this.sessionOption.provider.delete(uuid);
+    } else {
+      this.sessions.delete(uuid);
+    }
+  }
+  async getSessionDataSet(uuid) {
+    if (this.sessionOption.provider?.get) {
+      return this.sessionOption.provider.get(uuid);
+    } else {
+      return this.sessions.get(uuid);
+    }
+  }
+  async setSessionDataSet(uuid, dataSet) {
+    if (this.sessionOption.provider?.set) {
+      this.sessionOption.provider.set(uuid, dataSet);
+    } else {
+      this.sessions.set(uuid, dataSet);
+    }
+  }
+  isExpired(access, now = Date.now()) {
+    return now - access >= this.option.sessionOption.expiredTime;
+  }
+  makeUUID() {
+    return import_RandomUtils.RandomUtils.uuid("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
+  }
+  async session(rrOrUUID) {
+    let uuid;
+    if (rrOrUUID instanceof RequestResponse) {
+      uuid = rrOrUUID.reqCookieGet(this.sessionOption.key) ?? this.makeUUID();
+    } else if (typeof rrOrUUID === "string") {
+      uuid = rrOrUUID;
+    } else {
+      uuid = this.makeUUID();
+    }
+    let dataSet = await this.getSessionDataSet(uuid);
+    const now = Date.now();
+    if (dataSet) {
+      if (this.isExpired(dataSet.access, now)) {
+        delete dataSet.data;
+      }
+      dataSet.access = now;
+    } else {
+      dataSet = {
+        access: now
+      };
+    }
+    await this.setSessionDataSet(uuid, dataSet);
+    return { uuid, dataSet };
+  }
+};
+
+// src/inject/InjectSituationType.ts
+var InjectSituationType;
+((InjectSituationType2) => {
+  InjectSituationType2.TransactionManager = Symbol("TransactionManager");
+})(InjectSituationType || (InjectSituationType = {}));
+
+// src/SimpleBootHttpServer.ts
+var SimpleBootHttpServer = class extends import_SimpleApplication.SimpleApplication {
+  constructor(option = new HttpServerOption()) {
+    super(option);
+    this.option = option;
+    this.sessionManager = new SessionManager(this.option);
+  }
+  run(otherInstanceSim) {
+    const simstanceManager = super.run(otherInstanceSim);
+    const targets = [...this.option.closeEndPoints ?? [], ...this.option.errorEndPoints ?? [], ...this.option.requestEndPoints ?? [], ...this.option.filters ?? []];
+    Promise.all(targets.map((it) => typeof it === "function" ? this.simstanceManager.getOrNewSim({ target: it }) : it).map((it) => it.onInit(this))).then((it) => {
+      this.startServer();
+    });
+    return simstanceManager;
+  }
+  startServer() {
+    if (this.option.serverOption && "key" in this.option.serverOption && "cert" in this.option.serverOption) {
+      this.server = new import_https.Server(this.option.serverOption);
+      const httpServer = new import_http.Server();
+      httpServer.on("request", (req, res) => {
+        res.writeHead(301, { Location: `https://${req.headers.host}${req.url}` });
+        res.end();
+      });
+      httpServer.listen(80, this.option.listen.hostname, () => {
+        console.log("HTTP redirect server running on port 80");
+      });
+    } else if (this.option.serverOption) {
+      this.server = new import_http.Server(this.option.serverOption);
+    } else {
+      this.server = new import_http.Server();
+    }
+    this.server.on("request", async (req, res) => {
+      const transactionManager = this.option.transactionManagerFactory ? await this.option.transactionManagerFactory() : void 0;
+      res.on("close", async () => {
+        if (this.option.closeEndPoints) {
+          for (const it of this.option.closeEndPoints) {
+            try {
+              const execute = typeof it === "function" ? this.simstanceManager.getOrNewSim({ target: it }) : it;
+              const endPoint = execute?.endPoint(rr, this);
+              if (endPoint instanceof Promise) {
+                await endPoint;
+              }
+            } catch (e) {
+            }
+          }
+        }
+        if (!rr.resIsDone()) {
+          rr.resEnd();
+        }
+      });
+      res.on("error", async () => {
+        if (this.option.errorEndPoints) {
+          for (const it of this.option.errorEndPoints) {
+            try {
+              const execute = typeof it === "function" ? this.simstanceManager.getOrNewSim({ target: it }) : it;
+              const endPoint = execute?.endPoint(rr, this);
+              if (endPoint instanceof Promise) {
+                await endPoint;
+              }
+            } catch (e) {
+            }
+          }
+        }
+        if (!rr.resIsDone()) {
+          rr.resEnd();
+        }
+      });
+      const rr = new RequestResponse(req, res, { sessionManager: this.sessionManager, option: this.option });
+      rr.resSetHeader("Server" /* Server */, "simple-boot-http-server");
+      const cookie = rr.reqCookieGet(this.option.sessionOption.key);
+      if (!cookie) {
+        const session = await this.sessionManager.session();
+        rr.resSetHeader("Set-Cookie" /* SetCookie */, `${this.option.sessionOption.key}=${session.uuid}; Path=/; HttpOnly`);
+      }
+      const otherStorage = /* @__PURE__ */ new Map();
+      otherStorage.set(RequestResponse, rr);
+      otherStorage.set(import_http.IncomingMessage, req);
+      otherStorage.set(import_http.ServerResponse, res);
+      try {
+        transactionManager?.try();
+        if (this.option.requestEndPoints) {
+          for (const it of this.option.requestEndPoints) {
+            try {
+              const execute = typeof it === "function" ? this.simstanceManager.getOrNewSim({ target: it }) : it;
+              execute?.endPoint(rr, this);
+            } catch (e) {
+            }
+          }
+        }
+        const filter = {
+          carrier: /* @__PURE__ */ new Map(),
+          filters: []
+        };
+        for (let i = 0; this.option.filters && i < this.option.filters.length; i++) {
+          const it = this.option.filters[i];
+          const execute = typeof it === "function" ? this.simstanceManager.getOrNewSim({ target: it }) : it;
+          let sw = true;
+          if (execute?.proceedBefore) {
+            sw = await execute.proceedBefore({ rr, app: this, carrier: filter.carrier });
+            filter.filters.push({ filter: execute, sw });
+          }
+          if (!sw) {
+            break;
+          }
+        }
+        if (!rr.resIsDone()) {
+          const routerModule = await super.routing(rr.reqIntent);
+          otherStorage.set(import_RouterModule.RouterModule, routerModule);
+          const moduleInstance = routerModule?.getModuleInstance?.();
+          let methods = [];
+          if (routerModule && moduleInstance) {
+            if (routerModule.propertyKeys) {
+              const map = routerModule.propertyKeys?.map((it) => {
+                return { propertyKey: it, config: getUrlMapping(moduleInstance, it) };
+              });
+              methods.push(...map ?? []);
+            } else {
+              methods.push(...getUrlMappings(moduleInstance).filter((it) => !(0, import_Router.getRoute)(moduleInstance, it.propertyKey)) ?? []);
+            }
+            if (rr.reqMethod()?.toUpperCase() === "OPTIONS" /* OPTIONS */.toUpperCase()) {
+              rr.resSetHeader("Allow" /* Allow */, methods.map((it) => it.config.method).join(", "));
+              rr.resStatusCode(200 /* Ok */);
+            }
+            methods = methods.filter((it) => it && it.propertyKey && it.config && rr.reqMethod()?.toUpperCase() === it.config.method.toUpperCase());
+            methods.sort((a, b) => {
+              return (b.config?.req?.contentType?.length ?? 0) + (b.config?.req?.accept?.length ?? 0) - ((a.config?.req?.contentType?.length ?? 0) + (a.config?.req?.accept?.length ?? 0));
+            });
+            methods = methods.filter((it) => it.config?.req?.contentType ? !!it.config?.req?.contentType?.find((sit) => rr.reqHasContentTypeHeader(sit)) : true).filter((it) => it.config?.req?.accept ? !!it.config?.req?.accept?.find((sit) => rr.reqHasAcceptHeader(sit)) : true);
+            if (methods[0]) {
+              const it = methods[0];
+              const paramTypes = import_ReflectUtils2.ReflectUtils.getParameterTypes(moduleInstance, it.propertyKey);
+              const injects = (0, import_Inject.getInject)(moduleInstance, it.propertyKey);
+              const validIndexs = (0, import_Validation.getValidIndex)(moduleInstance, it.propertyKey);
+              if (injects) {
+                const isJson = injects.find((it2) => it2.config?.situationType === "SIMPLE_BOOT_HTTP_SERVER://URLMAPPING/REQ_JSON_BODY" /* REQ_JSON_BODY */);
+                const isFormUrl = injects.find((it2) => it2.config?.situationType === "SIMPLE_BOOT_HTTP_SERVER://URLMAPPING/REQ_FORM_URL_BODY" /* REQ_FORM_URL_BODY */);
+                const isTransactionManager = injects.find((it2) => it2.config?.situationType === InjectSituationType.TransactionManager);
+                const siturationContainers = new import_Inject.SituationTypeContainers();
+                if (isJson) {
+                  let data2 = await rr.reqBodyJsonData();
+                  if (isJson.type) {
+                    data2 = Object.assign(new isJson.type(), data2);
+                  }
+                  if (validIndexs.includes(isJson.index)) {
+                    const inValid = (0, import_Validation.execValidationInValid)(data2);
+                    if ((inValid?.length ?? 0) > 0) {
+                      throw new import_ValidException.ValidException(inValid);
+                    }
+                  }
+                  siturationContainers.push(new import_Inject.SituationTypeContainer({
+                    situationType: "SIMPLE_BOOT_HTTP_SERVER://URLMAPPING/REQ_JSON_BODY" /* REQ_JSON_BODY */,
+                    data: data2
+                  }));
+                }
+                if (isFormUrl) {
+                  let data2 = await rr.reqBodyFormUrlData();
+                  if (isFormUrl.type) {
+                    data2 = Object.assign(new isFormUrl.type(), data2);
+                  }
+                  if (validIndexs.includes(isFormUrl.index)) {
+                    const inValid = (0, import_Validation.execValidationInValid)(data2);
+                    if ((inValid?.length ?? 0) > 0) {
+                      throw new import_ValidException.ValidException(inValid);
+                    }
+                  }
+                  siturationContainers.push(new import_Inject.SituationTypeContainer({ situationType: "SIMPLE_BOOT_HTTP_SERVER://URLMAPPING/REQ_FORM_URL_BODY" /* REQ_FORM_URL_BODY */, data: data2 }));
+                }
+                if (isTransactionManager && isTransactionManager.type && transactionManager && transactionManager.hasTransaction(isTransactionManager.type)) {
+                  let data2 = await transactionManager.getTransaction(isTransactionManager.type);
+                  if (data2) {
+                    data2 = await data2.try(isTransactionManager.config.argument);
+                    siturationContainers.push(new import_Inject.SituationTypeContainer({ situationType: InjectSituationType.TransactionManager, data: data2, index: isTransactionManager.index }));
+                  }
+                }
+                if (siturationContainers.length) {
+                  otherStorage.set(import_Inject.SituationTypeContainers, siturationContainers);
+                }
+              }
+              for (const paramType of paramTypes) {
+                if (paramType === ReqFormUrlBody) {
+                  otherStorage.set(ReqFormUrlBody, await rr.reqBodyReqFormUrlBody());
+                } else if (paramType === ReqJsonBody) {
+                  otherStorage.set(ReqJsonBody, await rr.reqBodyReqJsonBody());
+                } else if (paramType === import_url2.URLSearchParams) {
+                  otherStorage.set(import_url2.URLSearchParams, rr.reqUrlSearchParams);
+                } else if (paramType === ReqMultipartFormBody) {
+                  otherStorage.set(ReqMultipartFormBody, rr.reqBodyMultipartFormData());
+                } else if (paramType === ReqHeader) {
+                  otherStorage.set(ReqHeader, rr.reqHeaderObj);
+                }
+              }
+              let data = await this.simstanceManager.executeBindParameterSimPromise({
+                target: moduleInstance,
+                targetKey: it.propertyKey
+              }, otherStorage);
+              if (it.config?.resolver) {
+                const execute = typeof it.config.resolver === "function" ? this.simstanceManager.getOrNewSim({ target: it.config.resolver }) : it.config.resolver;
+                data = await execute?.resolve?.(data, rr);
+              }
+              const status = it.config?.res?.status ?? 200 /* Ok */;
+              const headers = it.config?.res?.header ?? {};
+              if (it.config?.res?.contentType) {
+                headers["Content-Type" /* ContentType */] = it.config?.res?.contentType;
+              }
+              if ((it.config?.res?.contentType?.toLowerCase().indexOf("application/json" /* ApplicationJson */.toLowerCase()) ?? -1) > -1) {
+                data = JSON.stringify(data);
+              } else if (data && typeof data === "object") {
+                data = JSON.stringify(data);
+              }
+              rr.resSetHeaders(headers);
+              rr.resSetStatusCode(status);
+              rr.resWrite(data);
+            }
+          }
+          if (this.option.noSuchRouteEndPointMappingThrow && methods.length <= 0 && rr.reqMethod()?.toUpperCase() !== "OPTIONS" /* OPTIONS */) {
+            throw this.option.noSuchRouteEndPointMappingThrow(rr);
+          }
+        }
+        for (const it of filter.filters.reverse()) {
+          if (it.filter?.proceedAfter && !await it.filter.proceedAfter({ rr, app: this, before: it.sw, carrier: filter.carrier })) {
+            break;
+          }
+        }
+      } catch (e) {
+        transactionManager?.catch(e);
+        rr.resStatusCode(e instanceof HttpError ? e.status : 500 /* InternalServerError */);
+        const execute = typeof this.option.globalAdvice === "function" ? this.simstanceManager.getOrNewSim(this.option.globalAdvice) : this.option.globalAdvice;
+        if (!execute) {
+          rr.resEnd();
+          return;
+        }
+        if (e && typeof e === "object") {
+          otherStorage.set(e.constructor, e);
+          otherStorage.set(import_Inject.SituationTypeContainer, new import_Inject.SituationTypeContainer({
+            situationType: import_ExceptionDecorator.ExceptionHandlerSituationType.ERROR_OBJECT,
+            data: e
+          }));
+        }
+        const target = (0, import_ExceptionDecorator.targetExceptionHandler)(execute, e);
+        if (target) {
+          await this.simstanceManager.executeBindParameterSimPromise({
+            target: execute,
+            targetKey: target.propertyKey
+          }, otherStorage);
+        }
+      } finally {
+        transactionManager?.finally();
+      }
+      if (!rr.resIsDone()) {
+        rr.resEnd();
+      }
+    });
+    this.server.listen(this.option.listen.port, this.option.listen.hostname, this.option.listen.backlog, () => {
+      this.option.listen.listeningListener?.(this, this.server);
+    });
+  }
+};
+
+// src/endpoints/CrossDomainHeaderEndPoint.ts
+var CrossDomainHeaderEndPoint = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /*
+      rr.resSetHeader("Access-Control-Allow-Origin", "*")
+      rr.resSetHeader("Access-Control-Allow-Methods", "DELETE, POST, GET, OPTIONS")
+      rr.resSetHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Requested-With")
+   */
+  async endPoint(rr, app) {
+    if (this.config?.accessControlAllowOrigin) {
+      rr.resSetHeader("Access-Control-Allow-Origin" /* AccessControlAllowOrigin */, Array.isArray(this.config.accessControlAllowOrigin) ? this.config.accessControlAllowOrigin.join(", ") : this.config.accessControlAllowOrigin);
+    }
+    if (this.config?.accessControlAllowMethods) {
+      rr.resSetHeader("Access-Control-Allow-Methods" /* AccessControlAllowMethods */, Array.isArray(this.config.accessControlAllowMethods) ? this.config.accessControlAllowMethods.join(", ") : this.config.accessControlAllowMethods);
+    }
+    if (this.config?.accessControlAllowHeaders) {
+      rr.resSetHeader("Access-Control-Allow-Headers" /* AccessControlAllowHeaders */, Array.isArray(this.config.accessControlAllowHeaders) ? this.config.accessControlAllowHeaders.join(", ") : this.config.accessControlAllowHeaders);
+    }
+    if (this.config?.accessControlExposeHeaders) {
+      rr.resSetHeader("Access-Control-Expose-Headers" /* AccessControlExposeHeaders */, Array.isArray(this.config.accessControlExposeHeaders) ? this.config.accessControlExposeHeaders.join(", ") : this.config.accessControlExposeHeaders);
+    }
+  }
+  async onInit(app) {
+  }
+};
+
+// src/endpoints/HeaderEndPoint.ts
+var HeaderEndPoint = class {
+  constructor(headers) {
+    this.headers = headers;
+  }
+  async endPoint(rr, app) {
+    if (this.headers) {
+      rr.resSetHeaders(this.headers);
+    }
+  }
+  async onInit(app) {
+  }
+};
+
+// src/errors/BadRequestError.ts
+var BadRequestError = class extends HttpError {
+  constructor({ status = 400 /* BadRequest */, message = "Bad Request" } = {}) {
+    super({ status, message });
+  }
+};
+
+// src/errors/ForbiddenError.ts
+var ForbiddenError = class extends HttpError {
+  constructor({ status = 403 /* Forbidden */, message = "Forbidden" } = {}) {
+    super({ status, message });
+  }
+};
+
+// src/errors/InternalServerError.ts
+var InternalServerError = class extends HttpError {
+  constructor({ status = 500 /* InternalServerError */, message = "Internal Server Error" } = {}) {
+    super({ status, message });
+  }
+};
+
+// src/errors/NotFoundError.ts
+var NotFoundError = class extends HttpError {
+  constructor({ status = 404 /* NotFound */, message = "Not Found" } = {}) {
+    super({ status, message });
+  }
+};
+
+// src/errors/UnauthorizedError.ts
+var UnauthorizedError = class extends HttpError {
+  constructor({ status = 401 /* Unauthorized */, message = "Unauthorized" } = {}) {
+    super({ status, message });
+  }
+};
+
+// src/filters/CacheFilter.ts
+var import_FileUtils2 = require("@dooboostore/core-node/file/FileUtils");
+var import_ConvertUtils3 = require("@dooboostore/core-node/convert/ConvertUtils");
+var import_RandomUtils2 = require("@dooboostore/core/random/RandomUtils");
+var CacheFilter = class _CacheFilter {
+  constructor(config) {
+    this.config = config;
+    this.storage = /* @__PURE__ */ new Map();
+    if (config.config.cacheDir && config.config.startUpClean) {
+      import_FileUtils2.FileUtils.deleteSync(config.config.cacheDir, { options: { recursive: true } });
+    }
+  }
+  static {
+    this.CARRIER_KEY_NAME = "_CARRIER_CACHE_FILTER_KEY_NAME";
+  }
+  async onInit(app) {
+  }
+  async proceedBefore({ rr, app, carrier }) {
+    const filter = this.config.filter?.(rr, app);
+    if (!filter) {
+      return true;
+    }
+    if (this.config.config.cacheDir) {
+      import_FileUtils2.FileUtils.mkdirSync(this.config.config.cacheDir, { recursive: true });
+    }
+    if (!this.cacheConfig && this.config.config.cacheDir) {
+      try {
+        this.cacheConfig = JSON.parse(import_ConvertUtils3.ConvertUtils.toString(import_FileUtils2.FileUtils.readSync([this.config.config.cacheDir, "cacheConfig.json"], { option: { encoding: "utf-8" } })));
+      } catch (e) {
+      }
+    }
+    const date = (/* @__PURE__ */ new Date()).toISOString();
+    this.cacheConfig ??= {
+      createDate: date,
+      updateDate: date,
+      // accessDate: date,
+      caches: {}
+    };
+    this.cacheConfig.createDate ??= date;
+    this.cacheConfig.updateDate ??= date;
+    this.cacheConfig.caches ??= {};
+    const rkey = this.config.key(rr, app);
+    const sessionData = { key: rkey.key, lifeTime: rkey.lifeTime ?? this.config.config.lifeTime, isUpdate: false, responseHeaders: rkey.responseHeaders };
+    const cache = this.cacheConfig.caches[sessionData.key];
+    if (cache) {
+      const existes = this.config.config.cacheDir ? import_FileUtils2.FileUtils.existsSync(cache.path) : this.storage.has(cache.path);
+      const diffTime = Date.now() - cache.createTime;
+      if (!existes || diffTime > cache.lifeTime) {
+        delete this.cacheConfig[sessionData.key];
+        this.deleteChunk(cache.path);
+        sessionData.isUpdate = true;
+      } else {
+        rr.resSetHeaders({
+          ...cache.responseHeader,
+          cacheFilter: `true;remainTime=${cache.lifeTime - diffTime}`
+        });
+        try {
+          const chunk = this.getChunk(cache.path);
+          await rr.resEnd(chunk);
+        } catch (e) {
+          console.log("--------e", e);
+        }
+      }
+    } else {
+      sessionData.isUpdate = true;
+    }
+    carrier.set(_CacheFilter.CARRIER_KEY_NAME, sessionData);
+    return sessionData.isUpdate;
+  }
+  deleteChunk(path3) {
+    if (this.config.config.cacheDir && import_FileUtils2.FileUtils.existsSync(path3)) {
+      import_FileUtils2.FileUtils.deleteFileSync(path3);
+    } else if (this.storage.has(path3)) {
+      this.storage.delete(path3);
+    }
+  }
+  getChunk(path3) {
+    return this.config.config.cacheDir ? import_FileUtils2.FileUtils.readSync(path3) : this.storage.get(path3);
+  }
+  async proceedAfter({ rr, app, carrier }) {
+    const sessionData = carrier.get(_CacheFilter.CARRIER_KEY_NAME);
+    if (sessionData && sessionData.isUpdate) {
+      try {
+        if (this.config.config.cacheDir) {
+          import_FileUtils2.FileUtils.mkdirSync([this.config.config.cacheDir, "caches"], { recursive: true });
+        }
+        const resBody = rr.resBodyData();
+        if (!resBody) {
+          return true;
+        }
+        let p = void 0;
+        const destFileUUID = import_RandomUtils2.RandomUtils.uuid4();
+        p = this.writeChunk(destFileUUID, resBody);
+        const updateDateNow = Date.now();
+        const updateDate = new Date(updateDateNow).toISOString();
+        this.cacheConfig.createDate ??= updateDate;
+        this.cacheConfig.updateDate = updateDate;
+        const responseHeaders = {};
+        sessionData.responseHeaders?.map((it) => it.toLowerCase()).forEach((it) => {
+          responseHeaders[it] = rr.resHeader(it);
+        });
+        this.cacheConfig.caches[sessionData.key] = {
+          path: p,
+          createTime: updateDateNow,
+          lifeTime: sessionData.lifeTime,
+          responseHeader: responseHeaders
+        };
+        if (this.config.config.cacheDir) {
+          import_FileUtils2.FileUtils.write(JSON.stringify(this.cacheConfig), { path: [this.config.config.cacheDir, "cacheConfig.json"] });
+        }
+      } catch (e) {
+        console.log("---", e);
+      }
+    }
+    return true;
+  }
+  writeChunk(destFileUUID, resBody) {
+    if (this.config.config.cacheDir) {
+      return import_FileUtils2.FileUtils.write(resBody, { path: [this.config.config.cacheDir, "caches", destFileUUID] });
+    } else {
+      this.storage.set(destFileUUID, resBody);
+      return destFileUUID;
+    }
+  }
+};
+
+// src/filters/HttpStatusFilter.ts
+var HttpStatusFilter = class {
+  constructor(httpStatus) {
+    this.httpStatus = httpStatus;
+  }
+  async proceedBefore({ rr, app }) {
+    rr.resStatusCode(this.httpStatus);
+    rr.resEnd();
+    return false;
+  }
+  async proceedAfter({ rr, app }) {
+    return true;
+  }
+  async onInit(app) {
+  }
+};
+
+// src/filters/OpenApi3Filter.ts
+var DefulatData = {
+  openapi: "3.0.1",
+  info: {
+    title: "SimpleBootHttpServer OpenApi3",
+    description: "SimpleBootHttpServer OpenApi3"
+  }
+};
+var OpenApi3Filter = class {
+  constructor(config, openApiConfig) {
+    this.config = config;
+    this.openApiConfig = Object.assign(Object.assign({}, DefulatData), openApiConfig ?? {});
+  }
+  async onInit(app) {
+  }
+  async proceedBefore({ rr, app }) {
+    if (rr.reqUrl === this.config.path) {
+      const map = app.routerManager.routingMap();
+      const data = {
+        paths: {}
+      };
+      Object.entries(map).filter(([k, v]) => typeof v !== "string").forEach(([k, v]) => {
+        const method = data.paths[k] = {};
+        getUrlMappings(v)?.forEach((it) => {
+          method[it.config.method] = {
+            summary: it.propertyKey,
+            description: it.propertyKey
+            // operationId: it.operationId,
+            // parameters: it.parameters,
+            // responses: it.responses,
+          };
+        });
+      });
+      rr.resWriteJson(Object.assign(Object.assign({}, this.openApiConfig), data)).resStatusCode(200 /* Ok */).resEnd();
+      return false;
+    }
+    return true;
+  }
+  async proceedAfter({ rr, app }) {
+    return true;
+  }
+};
+
+// src/filters/ResourceFilter.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_mime_types = __toESM(require("mime-types"), 1);
+var ResourceFilter = class {
+  constructor(resourceDistPath, resourceRegex = []) {
+    this.resourceDistPath = resourceDistPath;
+    this.resourceRegex = resourceRegex;
+  }
+  async onInit(app) {
+  }
+  async proceedBefore({ rr, app }) {
+    const url = (rr.reqUrlPathName ?? "").replace(/\.\./g, "");
+    const urlObj = rr.reqUrlObject;
+    let sw = true;
+    const regExps = this.resourceRegex.filter((it) => {
+      if (it instanceof RegExp) {
+        return it.test(url);
+      }
+      if (typeof it === "string") {
+        return RegExp(it).test(url);
+      }
+      if (typeof it === "function") {
+        return it(rr, app);
+      }
+      if (typeof it === "object" && "request" in it) {
+        if (typeof it.request === "function") {
+          return it.request(rr, app);
+        }
+        return RegExp(it.request).test(url);
+      }
+    });
+    for (const it of regExps) {
+      const resourcePath = import_path.default.join(this.resourceDistPath, typeof it === "object" && "dist" in it ? it.dist : urlObj.pathname);
+      sw = false;
+      if (import_fs.default.existsSync(resourcePath)) {
+        rr.resStatusCode(200 /* Ok */);
+        rr.resSetHeader("Content-Type" /* ContentType */, import_mime_types.default.lookup(resourcePath).toString());
+        await rr.resEnd(import_fs.default.readFileSync(resourcePath));
+        break;
+      } else {
+        rr.resStatusCode(404 /* NotFound */);
+        await rr.resEnd();
+        break;
+      }
+      sw = false;
+    }
+    return sw;
+  }
+  async proceedAfter({ rr, app }) {
+    return true;
+  }
+};
+
+// src/filters/ThrowFilter.ts
+var ThrowFilter = class {
+  constructor(error) {
+    this.error = error;
+  }
+  async onInit(app) {
+  }
+  async proceedBefore({ rr, app }) {
+    return true;
+  }
+  async proceedAfter({ rr, app }) {
+    const sw = rr.resIsDone();
+    if (!sw) {
+      throw this.error;
+    }
+    ;
+    return false;
+  }
+};
+
+// src/models/datas/HeaderData.ts
+var HeaderData = class {
+  constructor(header, data) {
+    this.header = header;
+    this.data = data;
+  }
+};
+
+// src/models/datas/Resource.ts
+var import_fs2 = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+var import_mime_types2 = __toESM(require("mime-types"), 1);
+var Resource = class {
+  constructor(path3, rootPath = process.cwd()) {
+    this.path = path3;
+    this.rootPath = rootPath;
+  }
+  get absolutePath() {
+    if (this.path instanceof RequestResponse) {
+      return import_path2.default.join(this.rootPath, this.path.reqUrlObj().pathname);
+    } else if (this.path instanceof URL) {
+      return import_path2.default.join(this.rootPath, this.path.pathname);
+    } else {
+      return import_path2.default.join(this.rootPath, this.path);
+    }
+  }
+  get conTentType() {
+    return import_mime_types2.default.lookup(this.absolutePath).toString();
+  }
+  get data() {
+    const promise = new Promise((resolve, reject) => {
+      import_fs2.default.readFile("", (error, fileBuffer) => {
+        if (error) {
+          reject(error);
+        }
+        const fileContent = fileBuffer.toString();
+        resolve(fileContent);
+      });
+    });
+    return promise;
+  }
+  async write(rr) {
+    rr.resStatusCode(200 /* Ok */);
+    rr.resSetHeader("Content-Type" /* ContentType */, this.conTentType);
+    await rr.resEnd(import_fs2.default.readFileSync(this.absolutePath));
+  }
+};
+
+// src/models/method/patch/PatchJson.ts
+var import_fast_json_patch = __toESM(require("fast-json-patch"), 1);
+var PatchJson = class {
+  constructor(patch) {
+    this.patch = patch;
+  }
+  apply(obj) {
+    obj = import_fast_json_patch.default.applyPatch(obj, this.patch).newDocument;
+    return obj;
+  }
+};
+
+// src/resolvers/ResourceResolver.ts
+var import_SimDecorator = require("@dooboostore/simple-boot/decorators/SimDecorator");
+var ResourceResolver = class {
+  resolve(data, rr) {
+    return new Resource(data ?? rr).write(rr);
+  }
+};
+ResourceResolver = __decorateClass([
+  import_SimDecorator.Sim
+], ResourceResolver);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BadRequestError,
+  CONNECT,
+  CacheFilter,
+  CrossDomainHeaderEndPoint,
+  DELETE,
+  ForbiddenError,
+  GET,
+  HEAD,
+  HeaderData,
+  HeaderEndPoint,
+  HttpError,
+  HttpHeaders,
+  HttpMethod,
+  HttpServerOption,
+  HttpStatus,
+  HttpStatusFilter,
+  InjectSituationType,
+  InternalServerError,
+  Mimes,
+  NotFoundError,
+  OPTIONS,
+  OpenApi3Filter,
+  PATCH,
+  POST,
+  PUT,
+  PatchJson,
+  ReqFormUrlBody,
+  ReqHeader,
+  ReqJsonBody,
+  ReqMultipartFormBody,
+  RequestResponse,
+  RequestResponseChain,
+  Resource,
+  ResourceFilter,
+  ResourceResolver,
+  SessionManager,
+  SimpleBootHttpServer,
+  TRACE,
+  ThrowFilter,
+  UnauthorizedError,
+  UrlMapping,
+  UrlMappingSituationType,
+  getCONNECT,
+  getCONNECTS,
+  getDELETE,
+  getDELETES,
+  getGET,
+  getGETS,
+  getHEAD,
+  getHEADS,
+  getOPTIONS,
+  getOPTIONSS,
+  getPATCH,
+  getPATCHS,
+  getPOST,
+  getPOSTS,
+  getPUT,
+  getPUTS,
+  getTRACE,
+  getTRACES,
+  getUrlMapping,
+  getUrlMappings
+});
+//# sourceMappingURL=index.js.map