vafast 0.3.2 → 0.3.4

package/dist/utils/index.js

@@ -1,23 +1,834 @@
+// src/utils/parsers.ts
+import qs from "qs";
+import cookie from "cookie";
+async function parseBody(req) {
+  const contentType = req.headers.get("content-type") || "";
+  if (contentType.includes("application/json")) {
+    return await req.json();
+  }
+  if (contentType.includes("application/x-www-form-urlencoded")) {
+    const text2 = await req.text();
+    return Object.fromEntries(new URLSearchParams(text2));
+  }
+  return await req.text();
+}
+function extractQueryString(url) {
+  const qIndex = url.indexOf("?");
+  if (qIndex === -1) return "";
+  const hashIndex = url.indexOf("#", qIndex);
+  return hashIndex === -1 ? url.substring(qIndex + 1) : url.substring(qIndex + 1, hashIndex);
+}
+function parseQuery(req) {
+  const queryString = extractQueryString(req.url);
+  if (!queryString) return {};
+  return qs.parse(queryString);
+}
+function parseQueryFast(req) {
+  const queryString = extractQueryString(req.url);
+  if (!queryString) return {};
+  const result = /* @__PURE__ */ Object.create(null);
+  const pairs = queryString.split("&");
+  for (const pair of pairs) {
+    const eqIndex = pair.indexOf("=");
+    if (eqIndex === -1) {
+      result[decodeURIComponent(pair)] = "";
+    } else {
+      const key = decodeURIComponent(pair.substring(0, eqIndex));
+      const value = decodeURIComponent(pair.substring(eqIndex + 1));
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function parseHeaders(req) {
+  const headers = /* @__PURE__ */ Object.create(null);
+  req.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  return headers;
+}
+function getHeader(req, name) {
+  return req.headers.get(name);
+}
+function parseCookies(req) {
+  const cookieHeader = req.headers.get("cookie");
+  if (!cookieHeader) return {};
+  try {
+    const parsed = cookie.parse(cookieHeader);
+    const result = {};
+    for (const [key, value] of Object.entries(parsed)) {
+      if (value !== void 0 && value !== null) {
+        result[key] = value;
+      }
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+function parseCookiesFast(req) {
+  const cookieHeader = req.headers.get("cookie");
+  if (!cookieHeader) return {};
+  const result = /* @__PURE__ */ Object.create(null);
+  const pairs = cookieHeader.split(";");
+  for (const pair of pairs) {
+    const trimmed = pair.trim();
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex > 0) {
+      const key = trimmed.substring(0, eqIndex).trim();
+      const value = trimmed.substring(eqIndex + 1).trim();
+      result[key] = value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
+    }
+  }
+  return result;
+}
+function getCookie(req, name) {
+  const cookieHeader = req.headers.get("cookie");
+  if (!cookieHeader) return null;
+  const prefix = `${name}=`;
+  const pairs = cookieHeader.split(";");
+  for (const pair of pairs) {
+    const trimmed = pair.trim();
+    if (trimmed.startsWith(prefix)) {
+      const value = trimmed.substring(prefix.length).trim();
+      return value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
+    }
+  }
+  return null;
+}
+
+// src/utils/go-await.ts
+function goAwait(promise) {
+  return promise.then((data) => [null, data]).catch((err) => [err instanceof Error ? err : new Error(String(err)), void 0]);
+}
+
+// src/utils/response.ts
+function json(data, status = 200, headers = {}) {
+  const body = JSON.stringify(data);
+  if (Object.keys(headers).length === 0) {
+    return new Response(body, {
+      status,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  const h = new Headers({
+    "Content-Type": "application/json",
+    ...headers
+  });
+  return new Response(body, {
+    status,
+    headers: h
+  });
+}
+function redirect(location, status = 302) {
+  return new Response(null, {
+    status,
+    headers: {
+      Location: location
+    }
+  });
+}
+function text(content, status = 200, headers = {}) {
+  const h = new Headers({
+    "Content-Type": "text/plain; charset=utf-8",
+    ...headers
+  });
+  return new Response(content, {
+    status,
+    headers: h
+  });
+}
+function html(content, status = 200, headers = {}) {
+  const h = new Headers({
+    "Content-Type": "text/html; charset=utf-8",
+    ...headers
+  });
+  return new Response(content, {
+    status,
+    headers: h
+  });
+}
+function empty(status = 204, headers = {}) {
+  return new Response(null, {
+    status,
+    headers
+  });
+}
+function stream(stream2, status = 200, headers = {}) {
+  const h = new Headers({
+    "Content-Type": "application/octet-stream",
+    ...headers
+  });
+  return new Response(stream2, {
+    status,
+    headers: h
+  });
+}
+
+// src/utils/validators/schema-validators-ultra.ts
+import { TypeCompiler } from "@sinclair/typebox/compiler";
+var SCHEMA_FLAGS = {
+  BODY: 1 << 0,
+  // 1
+  QUERY: 1 << 1,
+  // 2
+  PARAMS: 1 << 2,
+  // 4
+  HEADERS: 1 << 3,
+  // 8
+  COOKIES: 1 << 4
+  // 16
+};
+var ultraSchemaCache = /* @__PURE__ */ new Map();
+var schemaCacheHits = /* @__PURE__ */ new Map();
+var errorPool = [];
+var ERROR_POOL_SIZE = 200;
+var errorMessagePool = /* @__PURE__ */ new Map();
+var commonMessages = [
+  "\u8BF7\u6C42\u4F53\u9A8C\u8BC1\u5931\u8D25",
+  "Query\u53C2\u6570\u9A8C\u8BC1\u5931\u8D25",
+  "\u8DEF\u5F84\u53C2\u6570\u9A8C\u8BC1\u5931\u8D25",
+  "\u8BF7\u6C42\u5934\u9A8C\u8BC1\u5931\u8D25",
+  "Cookie\u9A8C\u8BC1\u5931\u8D25",
+  "\u7C7B\u578B\u9A8C\u8BC1\u5931\u8D25",
+  "Schema\u7F16\u8BD1\u5931\u8D25",
+  "\u672A\u77E5\u9519\u8BEF"
+];
+commonMessages.forEach((msg) => errorMessagePool.set(msg, msg));
+for (let i = 0; i < ERROR_POOL_SIZE; i++) {
+  errorPool.push(new Error());
+}
+var errorPoolIndex = 0;
+function getErrorFromPool(message) {
+  const error = errorPool[errorPoolIndex];
+  error.message = message;
+  errorPoolIndex = (errorPoolIndex + 1) % ERROR_POOL_SIZE;
+  return error;
+}
+function getPooledString(key) {
+  let pooled = errorMessagePool.get(key);
+  if (!pooled) {
+    pooled = key;
+    errorMessagePool.set(key, key);
+  }
+  return pooled;
+}
+function getUltraSchemaCompiler(schema) {
+  let compiler = ultraSchemaCache.get(schema);
+  if (compiler) {
+    schemaCacheHits.set(schema, (schemaCacheHits.get(schema) || 0) + 1);
+    return compiler;
+  }
+  try {
+    compiler = TypeCompiler.Compile(schema);
+    ultraSchemaCache.set(schema, compiler);
+    return compiler;
+  } catch (error) {
+    return null;
+  }
+}
+function getSchemaFlags(config) {
+  let flags = 0;
+  if (config.body) flags |= SCHEMA_FLAGS.BODY;
+  if (config.query) flags |= SCHEMA_FLAGS.QUERY;
+  if (config.params) flags |= SCHEMA_FLAGS.PARAMS;
+  if (config.headers) flags |= SCHEMA_FLAGS.HEADERS;
+  if (config.cookies) flags |= SCHEMA_FLAGS.COOKIES;
+  return flags;
+}
+function validateSchemaUltra(schema, data, context) {
+  if (!schema) return data;
+  try {
+    let compiler = ultraSchemaCache.get(schema);
+    if (!compiler) {
+      try {
+        compiler = TypeCompiler.Compile(schema);
+        ultraSchemaCache.set(schema, compiler);
+      } catch (error) {
+        const message = getPooledString(`${context}\u9A8C\u8BC1\u5931\u8D25: Schema\u7F16\u8BD1\u5931\u8D25`);
+        throw getErrorFromPool(message);
+      }
+    }
+    const result = compiler.Check(data);
+    if (!result) {
+      const message = getPooledString(`${context}\u9A8C\u8BC1\u5931\u8D25`);
+      throw getErrorFromPool(message);
+    }
+    return data;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("\u9A8C\u8BC1\u5931\u8D25")) {
+      throw error;
+    }
+    const message = getPooledString(
+      `${context}\u9A8C\u8BC1\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`
+    );
+    throw getErrorFromPool(message);
+  }
+}
+function validateAllSchemasUltra(config, data) {
+  const flags = getSchemaFlags(config);
+  if (flags & SCHEMA_FLAGS.BODY) {
+    validateSchemaUltra(config.body, data.body, "\u8BF7\u6C42\u4F53");
+  }
+  if (flags & SCHEMA_FLAGS.QUERY) {
+    validateSchemaUltra(config.query, data.query, "Query\u53C2\u6570");
+  }
+  if (flags & SCHEMA_FLAGS.PARAMS) {
+    validateSchemaUltra(config.params, data.params, "\u8DEF\u5F84\u53C2\u6570");
+  }
+  if (flags & SCHEMA_FLAGS.HEADERS) {
+    validateSchemaUltra(config.headers, data.headers, "\u8BF7\u6C42\u5934");
+  }
+  if (flags & SCHEMA_FLAGS.COOKIES) {
+    validateSchemaUltra(config.cookies, data.cookies, "Cookie");
+  }
+  return data;
+}
+function precompileSchemasUltra(config) {
+  const flags = getSchemaFlags(config);
+  if (flags & SCHEMA_FLAGS.BODY && config.body) {
+    getUltraSchemaCompiler(config.body);
+  }
+  if (flags & SCHEMA_FLAGS.QUERY && config.query) {
+    getUltraSchemaCompiler(config.query);
+  }
+  if (flags & SCHEMA_FLAGS.PARAMS && config.params) {
+    getUltraSchemaCompiler(config.params);
+  }
+  if (flags & SCHEMA_FLAGS.HEADERS && config.headers) {
+    getUltraSchemaCompiler(config.headers);
+  }
+  if (flags & SCHEMA_FLAGS.COOKIES && config.cookies) {
+    getUltraSchemaCompiler(config.cookies);
+  }
+}
+
+// src/utils/create-handler.ts
+function autoResponse(result) {
+  if (result instanceof Response) {
+    return result;
+  }
+  if (result === null || result === void 0) {
+    return new Response(null, { status: 204 });
+  }
+  if (typeof result === "string") {
+    return new Response(result, {
+      headers: { "Content-Type": "text/plain; charset=utf-8" }
+    });
+  }
+  if (typeof result === "number" || typeof result === "boolean") {
+    return new Response(String(result), {
+      headers: { "Content-Type": "text/plain; charset=utf-8" }
+    });
+  }
+  if (typeof result === "object") {
+    const obj = result;
+    if ("data" in obj && ("status" in obj || "headers" in obj)) {
+      const { data, status = 200, headers = {} } = obj;
+      if (data === null || data === void 0) {
+        return new Response(null, {
+          status: status === 200 ? 204 : status,
+          headers
+        });
+      }
+      if (typeof data === "string" || typeof data === "number" || typeof data === "boolean") {
+        return new Response(String(data), {
+          status,
+          headers: {
+            "Content-Type": "text/plain; charset=utf-8",
+            ...headers
+          }
+        });
+      }
+      return json(data, status, headers);
+    }
+    return json(result);
+  }
+  return new Response(null, { status: 204 });
+}
+function handleValidationError(error) {
+  return json(
+    {
+      success: false,
+      error: "Validation Error",
+      message: error.message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    400
+  );
+}
+function handleInternalError(error) {
+  return json(
+    {
+      success: false,
+      error: "Internal Error",
+      message: error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"
+    },
+    500
+  );
+}
+function isHandler(value) {
+  return typeof value === "function";
+}
+function createHandler(schemaOrHandler, maybeHandler) {
+  const hasSchema = !isHandler(schemaOrHandler);
+  const schema = hasSchema ? schemaOrHandler : {};
+  const handler = hasSchema ? maybeHandler : schemaOrHandler;
+  if (schema.body || schema.query || schema.params || schema.headers || schema.cookies) {
+    precompileSchemasUltra(schema);
+  }
+  return async (req) => {
+    try {
+      const query = parseQuery(req);
+      const headers = parseHeaders(req);
+      const cookies = parseCookies(req);
+      const params = req.params || {};
+      let body = void 0;
+      if (req.method !== "GET" && req.method !== "HEAD") {
+        const [, parsedBody] = await goAwait(parseBody(req));
+        body = parsedBody;
+      }
+      const data = { body, query, params, headers, cookies };
+      if (schema.body || schema.query || schema.params || schema.headers || schema.cookies) {
+        validateAllSchemasUltra(schema, data);
+      }
+      const result = await handler({
+        req,
+        body,
+        query,
+        params,
+        headers,
+        cookies
+      });
+      return autoResponse(result);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("\u9A8C\u8BC1\u5931\u8D25")) {
+        return handleValidationError(error);
+      }
+      return handleInternalError(error);
+    }
+  };
+}
+function createHandlerWithExtra(schemaOrHandler, maybeHandler) {
+  const hasSchema = !isHandler(schemaOrHandler);
+  const schema = hasSchema ? schemaOrHandler : {};
+  const handler = hasSchema ? maybeHandler : schemaOrHandler;
+  if (schema.body || schema.query || schema.params || schema.headers || schema.cookies) {
+    precompileSchemasUltra(schema);
+  }
+  return async (req) => {
+    try {
+      const query = parseQuery(req);
+      const headers = parseHeaders(req);
+      const cookies = parseCookies(req);
+      const params = req.params || {};
+      let body = void 0;
+      if (req.method !== "GET" && req.method !== "HEAD") {
+        const [, parsedBody] = await goAwait(parseBody(req));
+        body = parsedBody;
+      }
+      const data = { body, query, params, headers, cookies };
+      if (schema.body || schema.query || schema.params || schema.headers || schema.cookies) {
+        validateAllSchemasUltra(schema, data);
+      }
+      const extras = req.__locals ?? {};
+      const result = await handler({
+        req,
+        body,
+        query,
+        params,
+        headers,
+        cookies,
+        ...extras
+      });
+      return autoResponse(result);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("\u9A8C\u8BC1\u5931\u8D25")) {
+        return handleValidationError(error);
+      }
+      return handleInternalError(error);
+    }
+  };
+}
+function simpleHandler(handler) {
+  return async (req) => {
+    try {
+      const result = await handler({ req });
+      return autoResponse(result);
+    } catch (error) {
+      return handleInternalError(error);
+    }
+  };
+}
+
+// src/utils/base64url.ts
+function base64urlEncode(str) {
+  return btoa(str).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+function base64urlDecode(str) {
+  const pad = str.length % 4 === 0 ? "" : "=".repeat(4 - str.length % 4);
+  const base64 = str.replace(/-/g, "+").replace(/_/g, "/") + pad;
+  return atob(base64);
+}
+
+// src/utils/handle.ts
+function setLocals(req, extras) {
+  const target = req;
+  target.__locals = { ...target.__locals ?? {}, ...extras };
+}
+function getLocals(req) {
+  const target = req;
+  return target.__locals ?? {};
+}
+
+// src/utils/request-validator.ts
+async function parseRequest(request, params) {
+  const requestData = {
+    body: void 0,
+    query: parseQuery(request),
+    params: params || {},
+    headers: parseHeaders(request),
+    cookies: parseCookies(request)
+  };
+  if (request.method !== "GET" && request.method !== "HEAD") {
+    requestData.body = await parseBody(request);
+  }
+  return requestData;
+}
+function validateRequest(config, requestData) {
+  try {
+    const validatedData = validateAllSchemasUltra(config, requestData);
+    return {
+      success: true,
+      data: validatedData
+    };
+  } catch (error) {
+    return {
+      success: false,
+      errors: [
+        {
+          field: "unknown",
+          message: error instanceof Error ? error.message : "\u9A8C\u8BC1\u5931\u8D25"
+        }
+      ]
+    };
+  }
+}
+async function parseAndValidateRequest(request, config, params) {
+  try {
+    const requestData = await parseRequest(request, params);
+    return validateRequest(config, requestData);
+  } catch (error) {
+    return {
+      success: false,
+      errors: [
+        {
+          field: "unknown",
+          message: error instanceof Error ? error.message : "\u8BF7\u6C42\u89E3\u6790\u5931\u8D25"
+        }
+      ]
+    };
+  }
+}
+function createRequestValidator(config) {
+  return async (request, params) => {
+    return parseAndValidateRequest(request, config, params);
+  };
+}
+
+// src/utils/html-renderer.ts
+var HtmlRenderer = class {
+  /**
+   * 生成基础HTML模板
+   */
+  static generateBaseHtml(content, context, clientScriptPath = "/client.js") {
+    return `
+      <!doctype html>
+      <html>
+        <head>
+          <meta charset="utf-8">
+          <title>Vafast SSR App</title>
+          <meta name="viewport" content="width=device-width, initial-scale=1">
+        </head>
+        <body>
+          <div id="app">${content}</div>
+          <script>
+            window.__ROUTE_INFO__ = {
+              params: ${JSON.stringify(context.params || {})},
+              query: ${JSON.stringify(context.query || {})},
+              pathname: '${context.pathname}'
+            };
+          </script>
+          <script type="module" src="${clientScriptPath}"></script>
+        </body>
+      </html>
+    `;
+  }
+  /**
+   * 生成Vue组件HTML
+   */
+  static generateVueHtml(content, context, clientScriptPath = "/client.js") {
+    return this.generateBaseHtml(content, context, clientScriptPath);
+  }
+  /**
+   * 生成React组件HTML
+   */
+  static generateReactHtml(content, context, clientScriptPath = "/client.js") {
+    return `
+      <!doctype html>
+      <html>
+        <head>
+          <meta charset="utf-8">
+          <title>Vafast SSR App</title>
+          <meta name="viewport" content="width=device-width, initial-scale=1">
+        </head>
+        <body>
+          <div id="root">${content}</div>
+          <script>
+            window.__ROUTE_INFO__ = {
+              params: ${JSON.stringify(context.params || {})},
+              query: ${JSON.stringify(context.query || {})},
+              pathname: '${context.pathname}'
+            };
+          </script>
+          <script type="module" src="${clientScriptPath}"></script>
+        </body>
+      </html>
+    `;
+  }
+};
+
+// src/utils/dependency-manager.ts
+var DependencyManager = class {
+  dependencyCache = /* @__PURE__ */ new Map();
+  /**
+   * 按需获取框架依赖
+   */
+  async getFrameworkDeps(framework) {
+    if (this.dependencyCache.has(framework)) {
+      return this.dependencyCache.get(framework);
+    }
+    console.log(`\u{1F4E6} \u6309\u9700\u52A0\u8F7D ${framework} \u4F9D\u8D56...`);
+    try {
+      let deps;
+      switch (framework) {
+        case "vue":
+          deps = await Promise.all([
+            import("vue"),
+            import("@vue/server-renderer")
+          ]);
+          break;
+        case "react":
+          deps = await Promise.all([
+            import("react"),
+            import("react-dom/server")
+          ]);
+          break;
+        default:
+          throw new Error(`\u4E0D\u652F\u6301\u7684\u6846\u67B6: ${framework}`);
+      }
+      this.dependencyCache.set(framework, deps);
+      console.log(`\u2705 ${framework} \u4F9D\u8D56\u52A0\u8F7D\u5B8C\u6210`);
+      return deps;
+    } catch (error) {
+      console.error(`\u274C ${framework} \u4F9D\u8D56\u52A0\u8F7D\u5931\u8D25:`, error);
+      throw error;
+    }
+  }
+  /**
+   * 检测组件类型
+   */
+  detectComponentType(component) {
+    if (component.render && typeof component.render === "function") {
+      return "vue";
+    }
+    if (component.$$typeof) {
+      return "react";
+    }
+    return "vue";
+  }
+  /**
+   * 清除缓存
+   */
+  clearCache() {
+    this.dependencyCache.clear();
+    console.log("\u{1F9F9} \u4F9D\u8D56\u7F13\u5B58\u5DF2\u6E05\u9664");
+  }
+  /**
+   * 获取缓存状态
+   */
+  getCacheStatus() {
+    const status = {};
+    for (const [framework] of this.dependencyCache) {
+      status[framework] = true;
+    }
+    return status;
+  }
+};
+
+// src/utils/validators/validators.ts
+import { Type } from "@sinclair/typebox";
+import { TypeCompiler as TypeCompiler2 } from "@sinclair/typebox/compiler";
+var compilerCache = /* @__PURE__ */ new WeakMap();
+function getCompiledValidator(schema) {
+  let compiler = compilerCache.get(schema);
+  if (!compiler) {
+    compiler = TypeCompiler2.Compile(schema);
+    compilerCache.set(schema, compiler);
+  }
+  return compiler;
+}
+function precompileSchemas(schemas) {
+  for (const schema of schemas) {
+    getCompiledValidator(schema);
+  }
+}
+function validateSchema(schema, data) {
+  try {
+    const compiler = getCompiledValidator(schema);
+    if (compiler.Check(data)) {
+      return {
+        success: true,
+        data
+      };
+    }
+    const errors = [];
+    const errorIterator = compiler.Errors(data);
+    for (const error of errorIterator) {
+      errors.push({
+        path: error.path,
+        message: error.message,
+        code: "VALIDATION_FAILED",
+        value: error.value,
+        schema: error.schema
+      });
+    }
+    return {
+      success: false,
+      errors
+    };
+  } catch (error) {
+    return {
+      success: false,
+      errors: [
+        {
+          path: "",
+          message: error instanceof Error ? error.message : "Unknown validation error",
+          code: "VALIDATION_EXCEPTION",
+          value: data
+        }
+      ]
+    };
+  }
+}
+function createValidator(schema) {
+  const compiler = getCompiledValidator(schema);
+  return (data) => {
+    if (compiler.Check(data)) {
+      return { success: true, data };
+    }
+    const errors = [];
+    for (const error of compiler.Errors(data)) {
+      errors.push({
+        path: error.path,
+        message: error.message,
+        code: "VALIDATION_FAILED",
+        value: error.value,
+        schema: error.schema
+      });
+    }
+    return { success: false, errors };
+  };
+}
+function validateFast(schema, data) {
+  const compiler = getCompiledValidator(schema);
+  return compiler.Check(data);
+}
+function getValidatorCacheStats() {
+  return {
+    cacheType: "WeakMap",
+    note: "WeakMap \u4E0D\u652F\u6301 size \u5C5E\u6027\uFF0C\u7F13\u5B58\u4F1A\u968F Schema \u5BF9\u8C61\u81EA\u52A8\u6E05\u7406"
+  };
+}
+export {
+  DependencyManager,
+  HtmlRenderer,
+  base64urlDecode,
+  base64urlEncode,
+  createHandler,
+  createHandlerWithExtra,
+  createRequestValidator,
+  createValidator,
+  empty,
+  getCookie,
+  getHeader,
+  getLocals,
+  getValidatorCacheStats,
+  goAwait,
+  html,
+  json,
+  parseAndValidateRequest,
+  parseBody,
+  parseCookies,
+  parseCookiesFast,
+  parseHeaders,
+  parseQuery,
+  parseQueryFast,
+  parseRequest,
+  precompileSchemas,
+  redirect,
+  setLocals,
+  simpleHandler,
+  stream,
+  text,
+  validateFast,
+  validateRequest,
+  validateSchema
+};
 /**
- * 工具函数模块导出
+ * Go 风格的错误处理工具
+ * 将 Promise 转换为 [Error | null, T | undefined] 格式
+ *
+ * @author Framework Team
+ * @version 1.0.0
+ * @license MIT
  */
-// 处理器工厂
-export { createHandler, createHandlerWithExtra, simpleHandler, } from "./create-handler";
-// 请求解析
-export { parseBody, parseQuery, parseQueryFast, parseHeaders, getHeader, parseCookies, parseCookiesFast, getCookie, } from "./parsers";
-// 响应工具
-export { json, text, html, redirect, empty, stream } from "./response";
-// Go 风格错误处理
-export { goAwait } from "./go-await";
-// Base64 编码
-export { base64urlEncode, base64urlDecode } from "./base64url";
-// 请求上下文
-export { setLocals, getLocals } from "./handle";
-// 请求验证
-export { parseRequest, validateRequest, parseAndValidateRequest, createRequestValidator, } from "./request-validator";
-// HTML 渲染 (SSR)
-export { HtmlRenderer } from "./html-renderer";
-// 依赖管理
-export { DependencyManager } from "./dependency-manager";
-// 验证器（JIT 编译）
-export { validateSchema, createValidator, validateFast, precompileSchemas, getValidatorCacheStats, } from "./validators/validators";
+/**
+ * 超优化版Schema验证器 v5.0.0
+ *
+ * 使用经过验证的优化技术，确保极致性能
+ * - 内联函数调用
+ * - 预编译缓存优化
+ * - 内存池优化
+ * - 位运算优化
+ * - 类型特化优化
+ * - 循环展开优化
+ * - 位掩码优化
+ * - 字符串池优化
+ * - 内联缓存优化
+ * - 内存对齐优化
+ *
+ * @author Framework Team
+ * @version 5.0.0
+ * @license MIT
+ */
+/**
+ * 类型安全的路由处理器工厂
+ *
+ * 非柯里化设计，API 更简洁
+ *
+ * @author Framework Team
+ * @version 3.0.0
+ * @license MIT
+ */
+/**
+ * 请求解析和验证器
+ *
+ * 解析handler的req参数，使用Ultra验证器进行验证，
+ * 并类型安全地返回解析出来的值
+ *
+ * @author Framework Team
+ * @version 1.0.0
+ * @license MIT
+ */
+//# sourceMappingURL=index.js.map