astro-routify 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Alex Mora
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,244 @@
+# astro-routify
+
+**A high-performance API router for [Astro](https://astro.build/) built on a Trie matcher.**  
+Define API routes using clean, flat structures — no folders or boilerplate logic.
+
+---
+
+## ⚡️ Quickstart
+
+```ts
+// src/pages/api/index.ts
+import { defineRoute, defineRouter, HttpMethod, ok } from "astro-routify";
+
+export const GET = defineRouter([
+  defineRoute(HttpMethod.GET, "/ping", () => ok("pong")),
+  defineRoute(HttpMethod.GET, "/users/:id", ({ params }) => ok({ id: params.id }))
+]);
+```
+
+Or to handle everything in a single place:
+
+```ts
+import { RouterBuilder, defineRoute, HttpMethod, ok } from "astro-routify";
+
+const builder = new RouterBuilder();
+builder.register([
+  defineRoute(HttpMethod.GET, "/ping", () => ok("pong")),
+  defineRoute(HttpMethod.POST, "/submit", async ({ request }) => {
+    const body = await request.json();
+    return ok({ received: body });
+  })
+]);
+
+export const ALL = builder.build(); // catch-all
+```
+
+---
+
+## 🚀 Features
+
+- ⚡ Fully compatible with Astro’s native APIContext — no extra setup needed.
+- 🧩 Use middleware, access cookies, headers, and request bodies exactly as you would in a normal Astro endpoints.
+
+- ✅ Flat-file, code-based routing (no folders required)
+- ✅ Dynamic segments (`:id`)
+- ✅ ALL-mode for monolithic routing (`RouterBuilder`)
+- ✅ Built-in response helpers (`ok`, `created`, etc.)
+- ✅ Trie-based matcher for fast route lookup
+- ✅ Fully typed — no magic strings
+
+---
+
+## 🧠 Core Concepts
+
+### `defineRoute()`
+
+Declare a single route:
+
+```ts
+defineRoute(HttpMethod.GET, "/users/:id", ({ params }) => {
+  return ok({ userId: params.id });
+});
+```
+
+### `defineRouter()`
+
+Group multiple routes under one HTTP method handler:
+
+```ts
+export const GET = defineRouter([
+  defineRoute(HttpMethod.GET, "/health", () => ok("ok"))
+]);
+```
+
+> 🧠 `defineRouter()` supports all HTTP methods — but Astro only executes the method you export (`GET`, `POST`, etc.)
+
+### `RouterBuilder` (Catch-All)
+
+Designed specifically for `ALL`:
+
+```ts
+const builder = new RouterBuilder();
+builder.register([
+  defineRoute(HttpMethod.GET, "/info", () => ok({ app: "astro-routify" }))
+]);
+export const ALL = builder.build();
+```
+
+---
+
+## 🔁 Response Helpers
+
+Avoid boilerplate `new Response(JSON.stringify(...))`:
+
+```ts
+ok(data);                // 200 OK
+created(data);           // 201 Created
+noContent();             // 204
+notFound("Missing");     // 404
+internalError(err);      // 500
+```
+
+---
+
+## 🔍 Param Matching
+
+Any route param like `:id` is extracted into `ctx.params`:
+
+```ts
+defineRoute(HttpMethod.GET, "/items/:id", ({ params }) => {
+  return ok({ itemId: params.id });
+});
+```
+
+---
+
+## 🤯 Why Use astro-routify?
+
+### ❌ Without it
+
+```ts
+// src/pages/api/[...slug].ts
+export const GET = async ({request}) => {
+    const url = new URL(request.url);
+    const path = url.pathname;
+
+    if (path.startsWith('/api/users/')) {
+        // Try to extract ID
+        const id = path.split('/').pop();
+        return new Response(JSON.stringify({id}), {
+            status: 200,
+            headers: {'Content-Type': 'application/json'},
+        });
+    }
+
+    if (path === '/api/users') {
+        return new Response(JSON.stringify([{id: 1}, {id: 2}]), {
+            status: 200,
+            headers: {'Content-Type': 'application/json'},
+        });
+    }
+
+
+    if (path === '/api/ping') {
+        return new Response(JSON.stringify({pong: true}), {
+            status: 200,
+            headers: {'Content-Type': 'application/json'}
+        });
+    }
+
+
+    return new Response('Not Found', {status: 404});
+};
+```
+
+### 📁 And then there's folder hell...
+
+```
+src/
+├─ pages/
+│  ├─ api/
+│  │  ├─ users/
+│  │  │  ├─ index.ts       // GET all users
+│  │  │  ├─ [id]/
+│  │  │  │  ├─ index.ts    // GET / POST / DELETE for a user
+│  │  ├─ ping.ts
+```
+
+### ✅ With `astro-routify`
+
+```ts
+//src/pages/api/[...slug].ts
+export const ALL = defineRouter([
+  defineRoute(HttpMethod.GET, "/ping", () => ok({ pong: true })),
+  defineRoute(HttpMethod.GET, "/users/:id", ({ params }) => ok({ id: params.id }))
+]);
+```
+
+---
+
+## 📈 Performance
+
+`astro-routify` uses a Trie structure for fast route and method matching.  
+It’s optimized for real-world route hierarchies, and avoids nested `if` chains.
+
+## 🧪 Benchmarks
+
+Realistic and synthetic benchmarks using `vitest bench`.
+
+### 🖥 Benchmark Machine
+
+Tests ran on a mid-range development setup:
+
+- **CPU**: Intel Core i5-7600K @ 3.80GHz (4 cores)
+- **RAM**: 16 GB DDR4
+- **GPU**: NVIDIA GeForce GTX 1080 (8 GB)
+- **OS**: Windows 10 Pro 64-bit
+- **Node.js**: v20.x
+- **Benchmark Tool**: [Vitest Bench](https://vitest.dev/guide/benchmarks.html)
+
+Results may vary slightly on different hardware.
+
+
+### 🔬 Realistic route shapes (5000 registered routes):
+
+```
+✓ RouteTrie performance - realistic route shapes
+
+ · Static route lookup (5000)                         1,819,681 req/sec
+ · Param route: /users/:userId                        1,708,264 req/sec
+ · Nested param route: /users/:id/orders/:oid         1,326,324 req/sec
+ · Blog route: /blog/:year/:month/:slug               1,220,882 req/sec
+ · Nonexistent path                                   1,621,934 req/sec
+```
+
+### 📈 Route scaling test:
+
+```
+✓ RouteTrie performance
+
+ · Lookup in SMALL (100 routes)                       1,948,385 req/sec
+ · Lookup in MEDIUM (1000 routes)                     1,877,248 req/sec
+ · Lookup in LARGE (10000 routes)                     1,908,279 req/sec
+ · Lookup non-existent route in LARGE                 1,962,051 req/sec
+```
+
+> ⚡ Performance stays consistently fast even with 10k+ routes
+---
+
+## 🛠 Designed to Scale
+
+While focused on simplicity and speed today, `astro-routify` is designed to evolve — enabling more advanced routing patterns in the future.
+
+---
+
+## 📜 License
+
+MIT — © 2025 [Alex Mora](https://github.com/oamm)
+
+---
+
+## ☕ Support
+
+If this project helps you, consider [buying me a coffee](https://coff.ee/alex_mora). Every drop keeps the code flowing!

package/dist/core/HttpMethod.d.ts

@@ -0,0 +1,13 @@
+export declare enum HttpMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "DELETE",
+    PATCH = "PATCH",
+    OPTIONS = "OPTIONS"
+}
+export declare const ALLOWED_HTTP_METHODS: Set<string>;
+/**
+ * Normalises an incoming method string and throws if it is unsupported.
+ */
+export declare function normalizeMethod(method: string): HttpMethod;

package/dist/core/HttpMethod.js

@@ -0,0 +1,20 @@
+export var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["GET"] = "GET";
+    HttpMethod["POST"] = "POST";
+    HttpMethod["PUT"] = "PUT";
+    HttpMethod["DELETE"] = "DELETE";
+    HttpMethod["PATCH"] = "PATCH";
+    HttpMethod["OPTIONS"] = "OPTIONS";
+})(HttpMethod || (HttpMethod = {}));
+export const ALLOWED_HTTP_METHODS = new Set(Object.values(HttpMethod));
+/**
+ * Normalises an incoming method string and throws if it is unsupported.
+ */
+export function normalizeMethod(method) {
+    const upper = method.toUpperCase();
+    if (!ALLOWED_HTTP_METHODS.has(upper)) {
+        throw new Error(`Unsupported HTTP method: ${method}`);
+    }
+    return upper;
+}

package/dist/core/RouteTrie.d.ts

@@ -0,0 +1,14 @@
+import { HttpMethod } from './HttpMethod';
+import type { Handler } from './defineHandler';
+interface RouteMatch {
+    handler: Handler | null;
+    allowed?: HttpMethod[];
+    params: Record<string, string | undefined>;
+}
+export declare class RouteTrie {
+    private readonly root;
+    insert(path: string, method: HttpMethod, handler: Handler): void;
+    find(path: string, method: HttpMethod): RouteMatch;
+    private segmentize;
+}
+export {};

package/dist/core/RouteTrie.js

@@ -0,0 +1,56 @@
+export class RouteTrie {
+    constructor() {
+        this.root = { children: new Map(), handlers: new Map() };
+    }
+    insert(path, method, handler) {
+        const segments = this.segmentize(path);
+        let node = this.root;
+        for (const segment of segments) {
+            if (segment.startsWith(':')) {
+                if (!node.paramChild) {
+                    node.paramChild = {
+                        children: new Map(),
+                        handlers: new Map(),
+                        paramName: segment.slice(1),
+                    };
+                }
+                node = node.paramChild;
+            }
+            else {
+                if (!node.children.has(segment)) {
+                    node.children.set(segment, { children: new Map(), handlers: new Map() });
+                }
+                node = node.children.get(segment);
+            }
+        }
+        node.handlers.set(method, handler);
+    }
+    find(path, method) {
+        const segments = this.segmentize(path);
+        let node = this.root;
+        const params = {};
+        for (const segment of segments) {
+            if (node?.children.has(segment)) {
+                node = node.children.get(segment);
+            }
+            else if (node?.paramChild) {
+                params[node.paramChild.paramName] = segment;
+                node = node.paramChild;
+            }
+            else {
+                return { handler: null, params };
+            }
+        }
+        if (!node)
+            return { handler: null, params };
+        const handler = node.handlers.get(method) ?? null;
+        return {
+            handler,
+            allowed: handler ? undefined : [...node.handlers.keys()],
+            params,
+        };
+    }
+    segmentize(path) {
+        return path.replace(/(^\/|\/$)/g, '').split('/');
+    }
+}

package/dist/core/RouterBuilder.d.ts

@@ -0,0 +1,8 @@
+import type { Route } from './defineRoute';
+import { type RouterOptions } from './defineRouter';
+export declare class RouterBuilder {
+    private routes;
+    register(route: Route): void;
+    register(routes: Route[]): void;
+    build(options?: RouterOptions): import("astro").APIRoute;
+}

package/dist/core/RouterBuilder.js

@@ -0,0 +1,17 @@
+import { defineRouter } from './defineRouter';
+export class RouterBuilder {
+    constructor() {
+        this.routes = [];
+    }
+    register(routeOrRoutes) {
+        if (Array.isArray(routeOrRoutes)) {
+            this.routes.push(...routeOrRoutes);
+        }
+        else {
+            this.routes.push(routeOrRoutes);
+        }
+    }
+    build(options) {
+        return defineRouter(this.routes, options);
+    }
+}

package/dist/core/defineHandler.d.ts

@@ -0,0 +1,4 @@
+import type { APIContext, APIRoute } from 'astro';
+import { type ResultResponse } from './responseHelpers';
+export type Handler = (ctx: APIContext) => Promise<ResultResponse | Response> | ResultResponse | Response;
+export declare function defineHandler(handler: Handler): APIRoute;

package/dist/core/defineHandler.js

@@ -0,0 +1,30 @@
+import { internalError, toAstroResponse } from './responseHelpers';
+function logRequest(ctx) {
+    const { method, url } = ctx.request;
+    console.info(`[astro-routify] → ${method} ${new URL(url).pathname}`);
+}
+function logResponse(status, start) {
+    console.info(`[astro-routify] ← responded ${status} in ${Math.round(performance.now() - start)}ms`);
+}
+export function defineHandler(handler) {
+    return async (ctx) => {
+        const start = performance.now();
+        try {
+            logRequest(ctx);
+            const result = await handler(ctx);
+            if (result instanceof Response) {
+                logResponse(result.status, start);
+                return result;
+            }
+            const finalResponse = toAstroResponse(result);
+            logResponse(finalResponse.status, start);
+            return finalResponse;
+        }
+        catch (err) {
+            console.error('[astro-routify] handler error', err);
+            const res = toAstroResponse(internalError(err));
+            logResponse(res.status, start);
+            return res;
+        }
+    };
+}

package/dist/core/defineRoute.d.ts

@@ -0,0 +1,9 @@
+import { HttpMethod } from './HttpMethod';
+import type { Handler } from './defineHandler';
+export interface Route {
+    method: HttpMethod;
+    path: string;
+    handler: Handler;
+}
+export declare function defineRoute(route: Route): Route;
+export declare function defineRoute(method: HttpMethod, path: string, handler: Handler): Route;

package/dist/core/defineRoute.js

@@ -0,0 +1,18 @@
+import { ALLOWED_HTTP_METHODS } from './HttpMethod';
+export function defineRoute(methodOrRoute, maybePath, maybeHandler) {
+    if (typeof methodOrRoute === 'object') {
+        validateRoute(methodOrRoute);
+        return methodOrRoute;
+    }
+    const route = { method: methodOrRoute, path: maybePath, handler: maybeHandler };
+    validateRoute(route);
+    return route;
+}
+function validateRoute({ method, path }) {
+    if (!path.startsWith('/')) {
+        throw new Error(`Route path must start with '/': ${path}`);
+    }
+    if (!ALLOWED_HTTP_METHODS.has(method)) {
+        throw new Error(`Unsupported HTTP method in route: ${method}`);
+    }
+}

package/dist/core/defineRouter.d.ts

@@ -0,0 +1,8 @@
+import type { APIRoute } from 'astro';
+import { notFound } from './responseHelpers';
+import type { Route } from './defineRoute';
+export interface RouterOptions {
+    /** Custom 404 handler */
+    onNotFound?: () => ReturnType<typeof notFound>;
+}
+export declare function defineRouter(routes: Route[], options?: RouterOptions): APIRoute;

package/dist/core/defineRouter.js

@@ -0,0 +1,27 @@
+import { defineHandler } from './defineHandler';
+import { methodNotAllowed, notFound, toAstroResponse } from './responseHelpers';
+import { RouteTrie } from './RouteTrie';
+import { normalizeMethod } from './HttpMethod';
+export function defineRouter(routes, options = {}) {
+    const trie = new RouteTrie();
+    for (const route of routes) {
+        trie.insert(route.path, route.method, route.handler);
+    }
+    // Wrap every user handler through defineHandler for uniform logging & error handling
+    return async (ctx) => {
+        const path = new URL(ctx.request.url).pathname.replace(/^\/api/, '');
+        const method = normalizeMethod(ctx.request.method);
+        const { handler, allowed, params } = trie.find(path, method);
+        if (!handler) {
+            // No handler for this method – but maybe other methods exist → 405
+            if (allowed && allowed.length) {
+                return toAstroResponse(methodNotAllowed('Method Not Allowed', {
+                    Allow: allowed.join(', '),
+                }));
+            }
+            const notFoundHandler = options.onNotFound ? options.onNotFound() : notFound('Not Found');
+            return toAstroResponse(notFoundHandler);
+        }
+        return defineHandler(handler)({ ...ctx, params: { ...ctx.params, ...params } });
+    };
+}

package/dist/core/responseHelpers.d.ts

@@ -0,0 +1,17 @@
+import { HeadersInit } from "undici";
+export interface ResultResponse<T = unknown> {
+    body?: T;
+    status: number;
+    headers?: HeadersInit;
+}
+export declare const ok: <T>(body: T, headers?: HeadersInit) => ResultResponse<T>;
+export declare const created: <T>(body: T, headers?: HeadersInit) => ResultResponse<T>;
+export declare const noContent: (headers?: HeadersInit) => ResultResponse<undefined>;
+export declare const notModified: (headers?: HeadersInit) => ResultResponse<undefined>;
+export declare const badRequest: <T = string>(body?: T, headers?: HeadersInit) => ResultResponse<T>;
+export declare const unauthorized: <T = string>(body?: T, headers?: HeadersInit) => ResultResponse<T>;
+export declare const forbidden: <T = string>(body?: T, headers?: HeadersInit) => ResultResponse<T>;
+export declare const notFound: <T = string>(body?: T, headers?: HeadersInit) => ResultResponse<T>;
+export declare const methodNotAllowed: <T = string>(body?: T, headers?: HeadersInit) => ResultResponse<T>;
+export declare const internalError: (err: unknown, headers?: HeadersInit) => ResultResponse<string>;
+export declare function toAstroResponse(result: ResultResponse | undefined): Response;

package/dist/core/responseHelpers.js

@@ -0,0 +1,30 @@
+function createResponse(status, body, headers) {
+    return { status, body, headers };
+}
+export const ok = (body, headers) => createResponse(200, body, headers);
+export const created = (body, headers) => createResponse(201, body, headers);
+export const noContent = (headers) => createResponse(204, undefined, headers);
+export const notModified = (headers) => createResponse(304, undefined, headers);
+export const badRequest = (body = 'Bad Request', headers) => createResponse(400, body, headers);
+export const unauthorized = (body = 'Unauthorized', headers) => createResponse(401, body, headers);
+export const forbidden = (body = 'Forbidden', headers) => createResponse(403, body, headers);
+export const notFound = (body = 'Not Found', headers) => createResponse(404, body, headers);
+export const methodNotAllowed = (body = 'Method Not Allowed', headers) => createResponse(405, body, headers);
+export const internalError = (err, headers) => createResponse(500, err instanceof Error ? err.message : String(err), headers);
+export function toAstroResponse(result) {
+    if (!result)
+        return new Response(null, { status: 204 });
+    const { status, body, headers } = result;
+    if (body === undefined || body === null) {
+        return new Response(null, { status, headers });
+    }
+    const isObject = typeof body === 'object' || Array.isArray(body);
+    const finalHeaders = {
+        ...(headers ?? {}),
+        ...(isObject ? { 'Content-Type': 'application/json; charset=utf-8' } : {}),
+    };
+    return new Response(isObject ? JSON.stringify(body) : body, {
+        status,
+        headers: finalHeaders,
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,73 @@
+import * as astro from 'astro';
+import { APIContext, APIRoute } from 'astro';
+import { HeadersInit } from 'undici';
+
+declare enum HttpMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "DELETE",
+    PATCH = "PATCH",
+    OPTIONS = "OPTIONS"
+}
+declare const ALLOWED_HTTP_METHODS: Set<string>;
+/**
+ * Normalises an incoming method string and throws if it is unsupported.
+ */
+declare function normalizeMethod(method: string): HttpMethod;
+
+interface ResultResponse<T = unknown> {
+    body?: T;
+    status: number;
+    headers?: HeadersInit;
+}
+declare const ok: <T>(body: T, headers?: HeadersInit) => ResultResponse<T>;
+declare const created: <T>(body: T, headers?: HeadersInit) => ResultResponse<T>;
+declare const noContent: (headers?: HeadersInit) => ResultResponse<undefined>;
+declare const notModified: (headers?: HeadersInit) => ResultResponse<undefined>;
+declare const badRequest: <T = string>(body?: T, headers?: HeadersInit) => ResultResponse<T>;
+declare const unauthorized: <T = string>(body?: T, headers?: HeadersInit) => ResultResponse<T>;
+declare const forbidden: <T = string>(body?: T, headers?: HeadersInit) => ResultResponse<T>;
+declare const notFound: <T = string>(body?: T, headers?: HeadersInit) => ResultResponse<T>;
+declare const methodNotAllowed: <T = string>(body?: T, headers?: HeadersInit) => ResultResponse<T>;
+declare const internalError: (err: unknown, headers?: HeadersInit) => ResultResponse<string>;
+declare function toAstroResponse(result: ResultResponse | undefined): Response;
+
+type Handler = (ctx: APIContext) => Promise<ResultResponse | Response> | ResultResponse | Response;
+declare function defineHandler(handler: Handler): APIRoute;
+
+interface Route {
+    method: HttpMethod;
+    path: string;
+    handler: Handler;
+}
+declare function defineRoute(route: Route): Route;
+declare function defineRoute(method: HttpMethod, path: string, handler: Handler): Route;
+
+interface RouterOptions {
+    /** Custom 404 handler */
+    onNotFound?: () => ReturnType<typeof notFound>;
+}
+declare function defineRouter(routes: Route[], options?: RouterOptions): APIRoute;
+
+interface RouteMatch {
+    handler: Handler | null;
+    allowed?: HttpMethod[];
+    params: Record<string, string | undefined>;
+}
+declare class RouteTrie {
+    private readonly root;
+    insert(path: string, method: HttpMethod, handler: Handler): void;
+    find(path: string, method: HttpMethod): RouteMatch;
+    private segmentize;
+}
+
+declare class RouterBuilder {
+    private routes;
+    register(route: Route): void;
+    register(routes: Route[]): void;
+    build(options?: RouterOptions): astro.APIRoute;
+}
+
+export { ALLOWED_HTTP_METHODS, HttpMethod, RouteTrie, RouterBuilder, badRequest, created, defineHandler, defineRoute, defineRouter, forbidden, internalError, methodNotAllowed, noContent, normalizeMethod, notFound, notModified, ok, toAstroResponse, unauthorized };
+export type { Handler, ResultResponse, Route, RouterOptions };

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from './core/defineRoute';
+export * from './core/defineRouter';
+export * from './core/defineHandler';
+export * from './core/RouteTrie';
+export * from './core/HttpMethod';
+export * from './core/responseHelpers';
+export * from './core/RouterBuilder';

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "astro-routify",
+  "version": "1.0.0",
+  "description": "A high-performance API router for Astro using a Trie-based matcher.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "astro",
+    "router",
+    "api-router",
+    "typescript",
+    "routing",
+    "astrojs",
+    "esm",
+    "trie"
+  ],
+  "author": "Alex Mora",
+  "license": "MIT",
+  "peerDependencies": {
+    "astro": "^4.0.0 || ^5.0.0"
+  },
+  "devDependencies": {
+    "rimraf": "^6.0.1",
+    "rollup": "^4.45.0",
+    "rollup-plugin-dts": "^6.2.1",
+    "typescript": "^5.3.3",
+    "undici": "^7.11.0",
+    "vitest": "^3.2.4"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:oamm/astro-routify.git"
+  },
+  "bugs": {
+    "url": "https://github.com/oamm/astro-routify/issues"
+  },
+  "homepage": "https://github.com/oamm/astro-routify#readme",
+  "scripts": {
+    "build": "tsc --project tsconfig.json",
+    "types:bundle": "rollup -c rollup.config.mjs",
+    "clean": "rimraf dist",
+    "dev": "tsc --watch --project tsconfig.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "bench": "vitest bench run bench/"
+  }
+}