@carno.js/core 0.2.11 → 1.0.2

package/dist/route/JITCompiler.js

@@ -1,245 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compileRouteHandler = compileRouteHandler;
-exports.compileValidatedHandler = compileValidatedHandler;
-const TEXT_HEADERS = Object.freeze({
-    'Content-Type': 'text/html'
-});
-const JSON_HEADERS = Object.freeze({
-    'Content-Type': 'application/json'
-});
-function isBodyInitResult(result) {
-    if (!result) {
-        return false;
-    }
-    if (result instanceof ReadableStream) {
-        return true;
-    }
-    if (result instanceof Blob || result instanceof ArrayBuffer) {
-        return true;
-    }
-    if (ArrayBuffer.isView(result)) {
-        return true;
-    }
-    return result instanceof FormData || result instanceof URLSearchParams;
-}
-/**
- * Cria handler inline com response building integrado.
- * Usado quando não há parâmetros.
- */
-function createInlineResponseHandler(handler, isAsync) {
-    if (isAsync) {
-        return async (c) => {
-            const r = await handler();
-            const s = c.getResponseStatus() || 200;
-            if (typeof r === 'string')
-                return new Response(r, { status: s, headers: TEXT_HEADERS });
-            if (r instanceof Response)
-                return r;
-            if (r == null)
-                return new Response('', { status: s, headers: TEXT_HEADERS });
-            if (typeof r === 'number' || typeof r === 'boolean') {
-                return new Response(String(r), { status: s, headers: TEXT_HEADERS });
-            }
-            if (isBodyInitResult(r)) {
-                return new Response(r, { status: s });
-            }
-            return new Response(JSON.stringify(r), { status: s, headers: JSON_HEADERS });
-        };
-    }
-    return (c) => {
-        const r = handler();
-        const s = c.getResponseStatus() || 200;
-        if (typeof r === 'string')
-            return new Response(r, { status: s, headers: TEXT_HEADERS });
-        if (r instanceof Response)
-            return r;
-        if (r == null)
-            return new Response('', { status: s, headers: TEXT_HEADERS });
-        if (typeof r === 'number' || typeof r === 'boolean') {
-            return new Response(String(r), { status: s, headers: TEXT_HEADERS });
-        }
-        if (isBodyInitResult(r)) {
-            return new Response(r, { status: s });
-        }
-        return new Response(JSON.stringify(r), { status: s, headers: JSON_HEADERS });
-    };
-}
-function escapeKey(key) {
-    return key.replace(/['\"\\]/g, '\\$&');
-}
-/**
- * Gera expressão de acesso a parâmetro inline.
- * Otimizado para evitar chamadas de função quando possível.
- */
-function buildArgExpression(param) {
-    const key = param.key ? escapeKey(param.key) : undefined;
-    switch (param.type) {
-        case 'param':
-            return key ? `c.param['${key}']` : 'c.param';
-        case 'query':
-            return key ? `c.query['${key}']` : 'c.query';
-        case 'body':
-            return key ? `c.body['${key}']` : 'c.body';
-        case 'headers':
-            return key ? `c.headers.get('${key}')` : 'c.headers';
-        case 'req':
-            return 'c.req';
-        case 'locals':
-            return 'c.locals';
-        default:
-            return 'undefined';
-    }
-}
-/**
- * Compila route handler em função otimizada.
- *
- * Estratégias de otimização:
- * - Inline de acesso a parâmetros
- * - Bind do handler no compile time
- * - Código gerado monomórfico
- * - Sem overhead de resolvers array
- */
-/**
- * Compila route handler em função otimizada que retorna Response inline.
- *
- * Estratégias de otimização:
- * - Inline de acesso a parâmetros
- * - Inline de response building (elimina executeFastPath)
- * - Bind do handler no compile time
- * - Código gerado monomórfico
- * - Headers pré-frozen para otimização V8
- */
-function compileRouteHandler(instance, methodName, paramInfos) {
-    const handler = instance[methodName].bind(instance);
-    if (paramInfos.length === 0) {
-        return createInlineResponseHandler(handler, false);
-    }
-    const hasDIParam = paramInfos.some((p) => p.type === 'di');
-    if (hasDIParam) {
-        return createFallbackHandler(handler, paramInfos);
-    }
-    const hasBodyParam = paramInfos.some((p) => p.type === 'body');
-    const argExpressions = paramInfos.map(buildArgExpression);
-    const argsCode = argExpressions.join(',');
-    if (hasBodyParam) {
-        const code = `return async function(c){
-await c.getBody();
-const r=await h(${argsCode});
-const s=c.getResponseStatus()||200;
-if(typeof r==='string')return new Response(r,{status:s,headers:TH});
-if(r instanceof Response)return r;
-if(r==null)return new Response('',{status:s,headers:TH});
-if(typeof r==='number'||typeof r==='boolean')return new Response(String(r),{status:s,headers:TH});
-if(isBI(r))return new Response(r,{status:s});
-return new Response(JSON.stringify(r),{status:s,headers:JH});
-}`;
-        return new Function('h', 'TH', 'JH', 'isBI', code)(handler, TEXT_HEADERS, JSON_HEADERS, isBodyInitResult);
-    }
-    const code = `return function(c){
-const r=h(${argsCode});
-const s=c.getResponseStatus()||200;
-if(typeof r==='string')return new Response(r,{status:s,headers:TH});
-if(r instanceof Response)return r;
-if(r==null)return new Response('',{status:s,headers:TH});
-if(typeof r==='number'||typeof r==='boolean')return new Response(String(r),{status:s,headers:TH});
-if(isBI(r))return new Response(r,{status:s});
-return new Response(JSON.stringify(r),{status:s,headers:JH});
-}`;
-    return new Function('h', 'TH', 'JH', 'isBI', code)(handler, TEXT_HEADERS, JSON_HEADERS, isBodyInitResult);
-}
-/**
- * Handler fallback para casos com DI.
- */
-function createFallbackHandler(handler, paramInfos) {
-    return (ctx) => {
-        const args = resolveArgs(paramInfos, ctx);
-        return handler(...args);
-    };
-}
-/**
- * Resolve argumentos para fallback handler.
- */
-function resolveArgs(paramInfos, ctx) {
-    const args = new Array(paramInfos.length);
-    let i = 0;
-    for (const param of paramInfos) {
-        args[i++] = resolveArg(param, ctx);
-    }
-    return args;
-}
-/**
- * Resolve um argumento individual.
- */
-function resolveArg(param, ctx) {
-    switch (param.type) {
-        case 'param':
-            return param.key ? ctx.param[param.key] : ctx.param;
-        case 'query':
-            return param.key ? ctx.query[param.key] : ctx.query;
-        case 'body':
-            return param.key ? ctx.body[param.key] : ctx.body;
-        case 'headers':
-            return param.key ? ctx.headers.get(param.key) : ctx.headers;
-        case 'req':
-            return ctx.req;
-        case 'locals':
-            return ctx.locals;
-        default:
-            return undefined;
-    }
-}
-/**
- * Compila handler com validação inline.
- */
-function compileValidatedHandler(instance, methodName, paramInfos, validatorAdapter) {
-    const handler = instance[methodName].bind(instance);
-    const hasBodyParam = paramInfos.some((p) => p.type === 'body');
-    if (paramInfos.length === 0) {
-        return createInlineResponseHandler(handler, false);
-    }
-    const { argAssignments, argList, tokenParams, tokenValues, } = buildValidatedArgs(paramInfos);
-    if (hasBodyParam) {
-        const code = `return async function(c){\nawait c.getBody();\n${argAssignments}\nconst r=await h(${argList});\nconst s=c.getResponseStatus()||200;\nif(typeof r==='string')return new Response(r,{status:s,headers:TH});\nif(r instanceof Response)return r;\nif(r==null)return new Response('',{status:s,headers:TH});\nif(typeof r==='number'||typeof r==='boolean')return new Response(String(r),{status:s,headers:TH});\nif(isBI(r))return new Response(r,{status:s});\nreturn new Response(JSON.stringify(r),{status:s,headers:JH});\n}`;
-        return new Function('h', 'va', ...tokenParams, 'TH', 'JH', 'isBI', code)(handler, validatorAdapter, ...tokenValues, TEXT_HEADERS, JSON_HEADERS, isBodyInitResult);
-    }
-    const code = `return function(c){\n${argAssignments}\nconst r=h(${argList});\nconst s=c.getResponseStatus()||200;\nif(typeof r==='string')return new Response(r,{status:s,headers:TH});\nif(r instanceof Response)return r;\nif(r==null)return new Response('',{status:s,headers:TH});\nif(typeof r==='number'||typeof r==='boolean')return new Response(String(r),{status:s,headers:TH});\nif(isBI(r))return new Response(r,{status:s});\nreturn new Response(JSON.stringify(r),{status:s,headers:JH});\n}`;
-    return new Function('h', 'va', ...tokenParams, 'TH', 'JH', 'isBI', code)(handler, validatorAdapter, ...tokenValues, TEXT_HEADERS, JSON_HEADERS, isBodyInitResult);
-}
-function buildValidatedArgs(paramInfos) {
-    const assignments = [];
-    const args = [];
-    const tokenParams = [];
-    const tokenValues = [];
-    let index = 0;
-    for (const param of paramInfos) {
-        const argName = `a${index}`;
-        const argExpr = buildArgExpression(param);
-        const tokenName = getTokenParamName(param, index, tokenParams, tokenValues);
-        const valueExpr = buildValidatedExpression(argExpr, tokenName);
-        assignments.push(`const ${argName}=${valueExpr};`);
-        args.push(argName);
-        index += 1;
-    }
-    return {
-        argAssignments: assignments.join('\n'),
-        argList: args.join(','),
-        tokenParams,
-        tokenValues,
-    };
-}
-function buildValidatedExpression(argExpr, tokenName) {
-    if (!tokenName) {
-        return argExpr;
-    }
-    return `va.validateAndTransform(${tokenName}, ${argExpr})`;
-}
-function getTokenParamName(param, index, tokenParams, tokenValues) {
-    if (!param.needsValidation || !param.token) {
-        return null;
-    }
-    const tokenName = `t${index}`;
-    tokenParams.push(tokenName);
-    tokenValues.push(param.token);
-    return tokenName;
-}

package/dist/route/Matcher.d.ts

@@ -1,11 +0,0 @@
-import { TokenRouteWithProvider, TokenRouteWithProviderMap } from "../container";
-import { Context } from "../domain";
-interface ParsedUrl {
-    pathname: string;
-}
-declare class Matcher {
-    match(request: Request, routes: TokenRouteWithProviderMap, context: Context): TokenRouteWithProvider;
-    identifyRoute(route: TokenRouteWithProvider, url: ParsedUrl, context: Context): boolean;
-}
-export declare const RouteResolver: Matcher;
-export {};

package/dist/route/Matcher.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouteResolver = void 0;
-function parseUrl(request) {
-    const url = request.url;
-    const startIndex = url.indexOf('/', 12);
-    const queryIndex = url.indexOf('?', startIndex);
-    if (queryIndex === -1) {
-        return { pathname: startIndex === -1 ? '/' : url.slice(startIndex) };
-    }
-    return { pathname: url.slice(startIndex, queryIndex) };
-}
-class Matcher {
-    match(request, routes, context) {
-        const method = request.method.toLowerCase();
-        if (!routes) {
-            throw new Error(`Method not allowed for ${request.url}`);
-        }
-        const routeMethod = routes.get(method);
-        const url = parseUrl(request);
-        const route = routeMethod?.find((route) => this.identifyRoute(route, url, context));
-        if (!route) {
-            throw new Error('Method not allowed');
-        }
-        return route;
-    }
-    identifyRoute(route, url, context) {
-        const urlPath = url.pathname.split('/');
-        const routePathSegments = route.path.split('/');
-        if (urlPath.length !== routePathSegments.length) {
-            return false;
-        }
-        return routePathSegments.every((path, index) => {
-            if (path === '*') {
-                return true;
-            }
-            if (path.startsWith(':')) {
-                context.setParam({
-                    ...context.param,
-                    [path.replace(':', '')]: urlPath[index]
-                });
-                return true;
-            }
-            return path === urlPath[index];
-        });
-    }
-}
-exports.RouteResolver = new Matcher();

package/dist/route/ParamResolverFactory.d.ts

@@ -1,14 +0,0 @@
-import type { Context } from '../domain/Context';
-export type ParamDecoratorType = 'body' | 'query' | 'param' | 'headers' | 'req' | 'locals';
-export interface ParamDecoratorMeta {
-    fun: (context: Context, data?: any) => any;
-    param?: any;
-    type?: ParamDecoratorType;
-}
-export interface ParamInfo {
-    type: ParamDecoratorType | 'di';
-    key?: string;
-    needsValidation: boolean;
-    token?: any;
-}
-export declare function analyzeParamDecorator(decoratorMeta: ParamDecoratorMeta | undefined, token: any): ParamInfo;

package/dist/route/ParamResolverFactory.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.analyzeParamDecorator = analyzeParamDecorator;
-const ValidationCache_1 = require("../utils/ValidationCache");
-function analyzeParamDecorator(decoratorMeta, token) {
-    if (!decoratorMeta) {
-        return { type: 'di', needsValidation: false, token };
-    }
-    const paramType = resolveParamType(decoratorMeta);
-    const key = decoratorMeta.param;
-    const needsValidation = typeof token === 'function' && (0, ValidationCache_1.isValidatable)(token);
-    if (paramType) {
-        return {
-            type: paramType,
-            key,
-            needsValidation,
-            token,
-        };
-    }
-    return { type: 'di', needsValidation: false, token };
-}
-function resolveParamType(decoratorMeta) {
-    if (decoratorMeta.type) {
-        return decoratorMeta.type;
-    }
-    return inferTypeFromSource(decoratorMeta.fun);
-}
-function inferTypeFromSource(resolver) {
-    const funcStr = resolver.toString();
-    if (funcStr.includes('context.body')) {
-        return 'body';
-    }
-    if (funcStr.includes('context.query')) {
-        return 'query';
-    }
-    if (funcStr.includes('context.param')) {
-        return 'param';
-    }
-    if (funcStr.includes('context.headers')) {
-        return 'headers';
-    }
-    if (funcStr.includes('context.req')) {
-        return 'req';
-    }
-    if (funcStr.includes('context.locals')) {
-        return 'locals';
-    }
-    return null;
-}

package/dist/route/RouteCompiler.d.ts

@@ -1,28 +0,0 @@
-import type { TokenRouteWithProvider } from '../container/ContainerConfiguration';
-import type { ValidatorAdapter } from '../validation/ValidatorAdapter';
-import type { Container } from '../container/container';
-import { ProviderScope } from '../domain/provider-scope';
-import { type CompiledRoute } from './CompiledRoute';
-export interface RouteCompilerOptions {
-    container: Container;
-    controllerScopes: Map<any, ProviderScope>;
-    validatorAdapter: ValidatorAdapter;
-    hasOnRequestHook: boolean;
-    hasOnResponseHook: boolean;
-}
-export declare class RouteCompiler {
-    private container;
-    private controllerScopes;
-    private validatorAdapter;
-    private hasOnRequestHook;
-    private hasOnResponseHook;
-    constructor(options: RouteCompilerOptions);
-    compile(route: TokenRouteWithProvider): CompiledRoute | null;
-    private classifyRoute;
-    private analyzeMethodParams;
-    private createSimpleRoute;
-    private createStandardRouteWithInstance;
-    private createStandardRoute;
-    private createComplexRoute;
-    private createFallbackRoute;
-}

package/dist/route/RouteCompiler.js

@@ -1,157 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouteCompiler = void 0;
-const provider_scope_1 = require("../domain/provider-scope");
-const Metadata_1 = require("../domain/Metadata");
-const getMethodArgTypes_1 = require("../utils/getMethodArgTypes");
-const CompiledRoute_1 = require("./CompiledRoute");
-const ParamResolverFactory_1 = require("./ParamResolverFactory");
-const JITCompiler_1 = require("./JITCompiler");
-class RouteCompiler {
-    constructor(options) {
-        this.container = options.container;
-        this.controllerScopes = options.controllerScopes;
-        this.validatorAdapter = options.validatorAdapter;
-        this.hasOnRequestHook = options.hasOnRequestHook;
-        this.hasOnResponseHook = options.hasOnResponseHook;
-    }
-    compile(route) {
-        if (!route || !route.provider) {
-            return null;
-        }
-        const provider = this.container.get(route.provider);
-        if (!provider) {
-            return this.createFallbackRoute(route);
-        }
-        const scope = this.controllerScopes.get(provider.token);
-        const isSingleton = scope === provider_scope_1.ProviderScope.SINGLETON;
-        const instance = isSingleton ? provider.instance : null;
-        if (!instance) {
-            return this.createStandardRoute(route, provider);
-        }
-        const paramInfos = this.analyzeMethodParams(instance, route.methodName);
-        const routeType = this.classifyRoute(route, paramInfos, isSingleton);
-        if (routeType === CompiledRoute_1.RouteType.SIMPLE) {
-            return this.createSimpleRoute(route, instance, paramInfos);
-        }
-        if (routeType === CompiledRoute_1.RouteType.STANDARD) {
-            return this.createStandardRouteWithInstance(route, instance, paramInfos);
-        }
-        return this.createComplexRoute(route, paramInfos);
-    }
-    classifyRoute(route, paramInfos, isSingleton) {
-        if (!isSingleton) {
-            return CompiledRoute_1.RouteType.COMPLEX;
-        }
-        const hasMiddlewares = route.middlewares.length > 0;
-        const hasDIParams = paramInfos.some((p) => p.type === 'di');
-        const hasHooks = this.hasOnRequestHook || this.hasOnResponseHook;
-        if (hasMiddlewares || hasDIParams || hasHooks) {
-            return CompiledRoute_1.RouteType.STANDARD;
-        }
-        return CompiledRoute_1.RouteType.SIMPLE;
-    }
-    analyzeMethodParams(instance, methodName) {
-        const argTypes = (0, getMethodArgTypes_1.getMethodArgTypes)(instance, methodName);
-        const decoratorMetas = Metadata_1.Metadata.getParamDecoratorFunc(instance, methodName);
-        return argTypes.map((token, index) => {
-            const meta = decoratorMetas?.[index];
-            return (0, ParamResolverFactory_1.analyzeParamDecorator)(meta, token);
-        });
-    }
-    createSimpleRoute(route, instance, paramInfos) {
-        const hasValidation = paramInfos.some((p) => p.needsValidation);
-        const validationIndices = paramInfos
-            .map((p, i) => (p.needsValidation ? i : -1))
-            .filter((i) => i >= 0);
-        const hasBodyParam = paramInfos.some((p) => p.type === 'body');
-        let boundHandler;
-        if (hasValidation) {
-            boundHandler = (0, JITCompiler_1.compileValidatedHandler)(instance, route.methodName, paramInfos, this.validatorAdapter);
-        }
-        else {
-            boundHandler = (0, JITCompiler_1.compileRouteHandler)(instance, route.methodName, paramInfos);
-        }
-        return {
-            routeType: CompiledRoute_1.RouteType.SIMPLE,
-            controllerInstance: instance,
-            boundHandler,
-            paramResolvers: [],
-            needsLocalsContainer: false,
-            hasMiddlewares: false,
-            hasValidation,
-            validationIndices,
-            isAsync: hasBodyParam,
-            original: route,
-        };
-    }
-    createStandardRouteWithInstance(route, instance, paramInfos) {
-        const hasValidation = paramInfos.some((p) => p.needsValidation);
-        const validationIndices = paramInfos
-            .map((p, i) => (p.needsValidation ? i : -1))
-            .filter((i) => i >= 0);
-        const hasDIParams = paramInfos.some((p) => p.type === 'di');
-        const hasBodyParam = paramInfos.some((p) => p.type === 'body');
-        const hasMiddlewares = route.middlewares.length > 0;
-        const needsLocalsContainer = hasDIParams || hasMiddlewares;
-        return {
-            routeType: CompiledRoute_1.RouteType.STANDARD,
-            controllerInstance: instance,
-            boundHandler: null,
-            paramResolvers: [],
-            needsLocalsContainer,
-            hasMiddlewares,
-            hasValidation,
-            validationIndices,
-            isAsync: hasBodyParam || hasDIParams,
-            original: route,
-        };
-    }
-    createStandardRoute(route, provider) {
-        return {
-            routeType: CompiledRoute_1.RouteType.STANDARD,
-            controllerInstance: null,
-            boundHandler: null,
-            paramResolvers: [],
-            needsLocalsContainer: true,
-            hasMiddlewares: route.middlewares.length > 0,
-            hasValidation: false,
-            validationIndices: [],
-            isAsync: true,
-            original: route,
-        };
-    }
-    createComplexRoute(route, paramInfos) {
-        const hasValidation = paramInfos.some((p) => p.needsValidation);
-        const validationIndices = paramInfos
-            .map((p, i) => (p.needsValidation ? i : -1))
-            .filter((i) => i >= 0);
-        return {
-            routeType: CompiledRoute_1.RouteType.COMPLEX,
-            controllerInstance: null,
-            boundHandler: null,
-            paramResolvers: [],
-            needsLocalsContainer: true,
-            hasMiddlewares: route.middlewares.length > 0,
-            hasValidation,
-            validationIndices,
-            isAsync: true,
-            original: route,
-        };
-    }
-    createFallbackRoute(route) {
-        return {
-            routeType: CompiledRoute_1.RouteType.COMPLEX,
-            controllerInstance: null,
-            boundHandler: null,
-            paramResolvers: [],
-            needsLocalsContainer: true,
-            hasMiddlewares: route.middlewares.length > 0,
-            hasValidation: false,
-            validationIndices: [],
-            isAsync: true,
-            original: route,
-        };
-    }
-}
-exports.RouteCompiler = RouteCompiler;

package/dist/route/RouteExecutor.d.ts

@@ -1,12 +0,0 @@
-import { InjectorService, TokenRouteWithProvider } from "../container";
-import { Context, LocalsContainer } from "../domain";
-import type { CompiledRoute } from "./CompiledRoute";
-declare class Router {
-    private readonly textHeaders;
-    executeRoute(routeStore: CompiledRoute | TokenRouteWithProvider, injector: InjectorService, context: Context, locals: LocalsContainer): Promise<Response>;
-    mountResponse(result: unknown, context: Context): Response;
-    private isNativeResponse;
-    private isBodyInit;
-}
-export declare const RouteExecutor: Router;
-export {};

package/dist/route/RouteExecutor.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouteExecutor = void 0;
-const events_1 = require("../events");
-class Router {
-    constructor() {
-        this.textHeaders = { "Content-Type": "text/html" };
-    }
-    async executeRoute(routeStore, injector, context, locals) {
-        const isCompiled = routeStore.routeType !== undefined;
-        const tokenRoute = isCompiled
-            ? routeStore.original
-            : routeStore;
-        const controllerInstance = isCompiled
-            ? routeStore.controllerInstance
-            : null;
-        const controller = controllerInstance
-            ?? injector.resolveControllerInstance(tokenRoute.provider, locals);
-        if (!controller[tokenRoute.methodName]) {
-            throw new Error("Controller not found");
-        }
-        const result = await injector.invokeRoute(tokenRoute, context, locals, controller);
-        if (injector.hasOnResponseHook()) {
-            await injector.callHook(events_1.EventType.OnResponse, { context, result });
-        }
-        const status = context.getResponseStatus() || 200;
-        if (result instanceof Response) {
-            return result;
-        }
-        if (result === null || result === undefined) {
-            return new Response("", { status, headers: this.textHeaders });
-        }
-        const resultType = typeof result;
-        if (resultType === "string") {
-            return new Response(result, { status, headers: this.textHeaders });
-        }
-        if (resultType === "number" || resultType === "boolean") {
-            return new Response(String(result), { status, headers: this.textHeaders });
-        }
-        if (this.isBodyInit(result)) {
-            return new Response(result, { status });
-        }
-        return Response.json(result, { status });
-    }
-    mountResponse(result, context) {
-        const status = context.getResponseStatus() || 200;
-        if (this.isNativeResponse(result)) {
-            return result;
-        }
-        if (result === null || result === undefined) {
-            return new Response("", { status, headers: this.textHeaders });
-        }
-        const resultType = typeof result;
-        if (resultType === "string") {
-            return new Response(result, { status, headers: this.textHeaders });
-        }
-        if (resultType === "number" || resultType === "boolean") {
-            return new Response(String(result), { status, headers: this.textHeaders });
-        }
-        if (this.isBodyInit(result)) {
-            return new Response(result, { status });
-        }
-        return Response.json(result, { status });
-    }
-    isNativeResponse(result) {
-        return result instanceof Response;
-    }
-    isBodyInit(result) {
-        if (!result) {
-            return false;
-        }
-        if (result instanceof ReadableStream) {
-            return true;
-        }
-        if (result instanceof Blob || result instanceof ArrayBuffer) {
-            return true;
-        }
-        if (ArrayBuffer.isView(result)) {
-            return true;
-        }
-        return result instanceof FormData || result instanceof URLSearchParams;
-    }
-}
-exports.RouteExecutor = new Router();

package/dist/route/memoirist.d.ts

@@ -1,31 +0,0 @@
-export interface FindResult<T> {
-    store: T;
-    params: Record<string, any>;
-}
-export interface ParamNode<T> {
-    paramName: string | null;
-    names: Map<T, string>;
-    store: T | null;
-    inert: Node<T> | null;
-}
-export interface Node<T> {
-    part: string;
-    store: T | null;
-    inert: Map<number, Node<T>> | null;
-    params: ParamNode<T> | null;
-    wildcardStore: T | null;
-}
-export declare class Memoirist<T> {
-    root: Record<string, Node<T>>;
-    history: [string, string, T][];
-    private routeCache;
-    private static regex;
-    add(method: string, path: string, store: T): FindResult<T>['store'];
-    find(method: string, url: string): FindResult<T> | null;
-    updateStore(method: string, path: string, oldStore: T, newStore: T): boolean;
-    private invalidateCache;
-    private updateHistoryStore;
-    private normalizePath;
-    private findNode;
-}
-export default Memoirist;