@senrijs/senri 0.0.0-stage → 0.2.0

package/dist/src/logger.js

@@ -0,0 +1,110 @@
+const C = {
+    reset: "\x1b[0m",
+    dim: "\x1b[2m",
+    bold: "\x1b[1m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+};
+const METHOD_COLOR = {
+    GET: C.green,
+    POST: C.cyan,
+    PUT: C.yellow,
+    DELETE: C.red,
+    PATCH: C.magenta,
+};
+// ログには、届いたままのパスを出す(c.path はデコード済みで、不正なリクエストだと 400 を投げるため)
+// Bun は不正な Host のとき req.url を相対 URL にするので、URL として読めなければそのまま出す
+function rawPath(req) {
+    try {
+        return new URL(req.url).pathname;
+    }
+    catch {
+        return req.url;
+    }
+}
+export function logger(options = {}) {
+    const format = options.format ?? "pretty";
+    const color = options.color ?? true;
+    const slow = options.slow ?? 500;
+    const paint = (code, text) => color ? `${code}${text}${C.reset}` : text;
+    function statusColor(status) {
+        if (status >= 500)
+            return C.red;
+        if (status >= 400)
+            return C.yellow;
+        if (status >= 300)
+            return C.cyan;
+        return C.green;
+    }
+    function pinoLevel(status) {
+        if (status >= 500)
+            return 50;
+        if (status >= 400)
+            return 40;
+        return 30;
+    }
+    // 名前付きの関数にしておくと、ダッシュボードなどで "logger" と表示できる
+    return async function logger(c, next) {
+        const start = Date.now();
+        const res = await next();
+        const ms = Date.now() - start;
+        const method = c.req.method;
+        const path = rawPath(c.req);
+        // pino 形式のエラー(エラーがなければ undefined)
+        const err = c.error instanceof Error
+            ? { type: c.error.name, message: c.error.message, stack: c.error.stack }
+            : c.error !== undefined
+                ? { message: String(c.error) }
+                : undefined;
+        if (format === "json") {
+            console.log(JSON.stringify({
+                level: pinoLevel(res.status),
+                time: Date.now(),
+                req: { method, url: path },
+                res: { statusCode: res.status },
+                responseTime: ms,
+                err,
+                msg: err ? "request errored" : "request completed",
+            }));
+            return;
+        }
+        const time = new Date().toTimeString().slice(0, 8);
+        console.log([
+            paint(C.dim, time),
+            paint(METHOD_COLOR[method] ?? C.bold, method.padEnd(7)),
+            path.padEnd(24),
+            paint(statusColor(res.status), String(res.status)),
+            paint(ms > slow ? C.red : C.dim, `${ms}ms`.padStart(6)),
+        ].join(" "));
+        // エラーがあったら、その下に赤で詳細を出す
+        if (err) {
+            console.log(paint(C.red, `  ${err.stack ?? err.message}`));
+        }
+    };
+}
+const ACCENT = "\x1b[38;2;227;65;43m";
+export function showRoutes(app, url, 
+// note: URL の横に薄く出す補足(serve() は、ポートをどこから決めたかを出す)
+options = {}) {
+    const color = options.color ?? true;
+    const paint = (code, text) => color ? `${code}${text}${C.reset}` : text;
+    // パスのアルファベット順 → 同じパスならメソッド順
+    const list = [...app.routeList()].sort((a, b) => a.path.localeCompare(b.path) || a.method.localeCompare(b.method));
+    // ":id" みたいなパラメーター部分だけ色を付ける
+    const highlight = (path) => path
+        .split("/")
+        .map((seg) => (seg.startsWith(":") ? paint(C.cyan, seg) : seg))
+        .join("/");
+    console.log("");
+    const note = options.note ? `  ${paint(C.dim, `(${options.note})`)}` : "";
+    console.log(`  ${paint(C.bold, "senr")}${paint(ACCENT, "/")}  ${paint(C.green, "ready")}  ${url}${note}`);
+    console.log("");
+    for (const r of list) {
+        console.log(`    ${paint(METHOD_COLOR[r.method] ?? C.bold, r.method.padEnd(7))} ${highlight(r.path)}`);
+    }
+    console.log("");
+}

package/dist/src/matcher.d.ts

@@ -0,0 +1,16 @@
+import type { Route } from "./router.ts";
+export type Leaf = Route[];
+export type Match = {
+    leaf: Leaf;
+    values: string[];
+};
+export type Matcher = {
+    add(route: Route): void;
+    staticLeaf(path: string): Leaf | undefined;
+    match(segments: readonly string[]): Match[];
+    first(segments: readonly string[], method: string): {
+        route: Route;
+        values: string[];
+    } | null;
+};
+export declare function createMatcher(): Matcher;

package/dist/src/matcher.js

@@ -0,0 +1,86 @@
+const node = () => ({ statics: null, param: null, leaf: null });
+const NO_VALUES = [];
+export function createMatcher() {
+    const root = node();
+    // パラメーターのないルートだけ。キーは "/users/me" の形(c.path と同じ)
+    const statics = new Map();
+    const leafOf = (route) => {
+        let n = root;
+        for (const segment of route.segments) {
+            if (segment.startsWith(":")) {
+                n = n.param ??= node();
+            }
+            else {
+                n.statics ??= new Map();
+                let child = n.statics.get(segment);
+                if (!child)
+                    n.statics.set(segment, (child = node()));
+                n = child;
+            }
+        }
+        return (n.leaf ??= []);
+    };
+    const walk = (n, segments, i, values, out) => {
+        if (i === segments.length) {
+            if (n.leaf)
+                out.push({ leaf: n.leaf, values: values.length > 0 ? values.slice() : NO_VALUES });
+            return;
+        }
+        const segment = segments[i];
+        const next = n.statics?.get(segment);
+        if (next)
+            walk(next, segments, i + 1, values, out);
+        if (n.param) {
+            values.push(segment);
+            walk(n.param, segments, i + 1, values, out);
+            values.pop();
+        }
+    };
+    // walk と同じ順番でたどり、メソッドが合うルートを見つけたらそこで止める
+    const seek = (n, segments, i, method, values) => {
+        if (i === segments.length) {
+            if (n.leaf) {
+                for (const route of n.leaf)
+                    if (route.method === method)
+                        return route;
+            }
+            return null;
+        }
+        const segment = segments[i];
+        const next = n.statics?.get(segment);
+        if (next) {
+            const found = seek(next, segments, i + 1, method, values);
+            if (found)
+                return found;
+        }
+        if (n.param) {
+            values.push(segment);
+            const found = seek(n.param, segments, i + 1, method, values);
+            if (found)
+                return found;
+            values.pop();
+        }
+        return null;
+    };
+    return {
+        add(route) {
+            const leaf = leafOf(route);
+            leaf.push(route);
+            if (!route.segments.some((s) => s.startsWith(":")))
+                statics.set("/" + route.segments.join("/"), leaf);
+        },
+        staticLeaf(path) {
+            return statics.get(path);
+        },
+        match(segments) {
+            const out = [];
+            walk(root, segments, 0, [], out);
+            return out;
+        },
+        first(segments, method) {
+            const values = [];
+            const route = seek(root, segments, 0, method, values);
+            return route ? { route, values } : null;
+        },
+    };
+}

package/dist/src/middleware/body-limit.d.ts

@@ -0,0 +1,6 @@
+import type { Context, HandlerResult, Middleware } from "../context.ts";
+export type BodyLimitOptions = {
+    maxSize: number;
+    onError?: (c: Context) => HandlerResult | Promise<HandlerResult>;
+};
+export declare function bodyLimit(options: BodyLimitOptions): Middleware;

package/dist/src/middleware/body-limit.js

@@ -0,0 +1,47 @@
+import { HttpError } from "../errors.js";
+export function bodyLimit(options) {
+    const max = options.maxSize;
+    if (typeof max !== "number" || !Number.isFinite(max) || max < 0) {
+        throw new Error(`bodyLimit(): maxSize には 0 以上のバイト数を指定してください(${String(max)})`);
+    }
+    const tooLarge = (c) => options.onError ? options.onError(c) : new Response("413 Content Too Large", { status: 413 });
+    return async function bodyLimit(c, next) {
+        const body = c.req.body;
+        if (body === null)
+            return next();
+        // Content-Length があれば、読む前に決められる(ランタイムが、それより長いボディは受け取らない)
+        const length = c.req.headers.get("content-length");
+        if (length !== null) {
+            // 数字でない値(ふつうはランタイムの HTTP パーサーがはじく)は、長さが分からないので通さない
+            if (!/^\s*\d+\s*$/.test(length))
+                return new Response("400 Bad Request", { status: 400 });
+            return Number(length) > max ? tooLarge(c) : next();
+        }
+        // ない(チャンク転送など)ときは、読みながら数える。超えたらストリームをエラーにして、それ以上は読まない
+        let exceeded = false;
+        let size = 0;
+        const reader = body.getReader();
+        const limited = new ReadableStream({
+            async pull(controller) {
+                const { done, value } = await reader.read();
+                if (done)
+                    return controller.close();
+                size += value.byteLength;
+                if (size > max) {
+                    exceeded = true;
+                    controller.error(new HttpError(413, "413 Content Too Large"));
+                    await reader.cancel();
+                    return;
+                }
+                controller.enqueue(value);
+            },
+            cancel(reason) {
+                return reader.cancel(reason);
+            },
+        });
+        c.req = new Request(c.req, { body: limited, duplex: "half" });
+        const res = await next();
+        // ハンドラーがエラーを握りつぶしていても、超えていたら 413 にする
+        return exceeded ? tooLarge(c) : res;
+    };
+}

package/dist/src/middleware/cors.d.ts

@@ -0,0 +1,10 @@
+import type { Context, Middleware } from "../context.ts";
+export type CorsOptions = {
+    origin?: string | readonly string[] | ((origin: string, c: Context) => boolean | string | null | undefined);
+    allowMethods?: readonly string[];
+    allowHeaders?: readonly string[];
+    exposeHeaders?: readonly string[];
+    credentials?: boolean;
+    maxAge?: number;
+};
+export declare function cors(options?: CorsOptions): Middleware;

package/dist/src/middleware/cors.js

@@ -0,0 +1,79 @@
+import { appendVary, editable } from "./response.js";
+const DEFAULT_METHODS = ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH", "QUERY"];
+export function cors(options = {}) {
+    const origin = options.origin ?? "*";
+    if (options.credentials && origin === "*") {
+        throw new Error('cors(): credentials: true のときは origin: "*" は使えません。許可するオリジンを指定してください');
+    }
+    const methods = (options.allowMethods ?? DEFAULT_METHODS).join(", ");
+    const expose = options.exposeHeaders?.join(", ");
+    // "*" 以外は、リクエストのオリジンによって答えが変わるので Vary: Origin が要る
+    const varies = origin !== "*";
+    const allowOrigin = (requestOrigin, c) => {
+        if (origin === "*")
+            return "*";
+        if (typeof origin === "string")
+            return origin === requestOrigin ? origin : null;
+        if (typeof origin === "function") {
+            const result = origin(requestOrigin, c);
+            return result === true ? requestOrigin : typeof result === "string" ? result : null;
+        }
+        return origin.includes(requestOrigin) ? requestOrigin : null;
+    };
+    return async function cors(c, next) {
+        const requestOrigin = c.req.headers.get("origin");
+        if (requestOrigin === null) {
+            if (!varies)
+                return next();
+            // 許可するオリジンがリクエストで変わるなら、Origin のないレスポンスにも Vary: Origin を付ける
+            // (付けないと、共有キャッシュが CORS ヘッダーのないこのレスポンスを、ほかのオリジンにも返してしまう)
+            const downstream = await next();
+            if (downstream.status < 200)
+                return downstream;
+            const res = editable(downstream);
+            appendVary(res.headers, "Origin");
+            return res;
+        }
+        const allowed = allowOrigin(requestOrigin, c);
+        // プリフライト(本番のリクエストの前に、ブラウザが「送ってよいか」を OPTIONS で聞いてくるもの)には、ここで答える
+        const requestMethod = c.req.headers.get("access-control-request-method");
+        if (c.req.method === "OPTIONS" && requestMethod !== null) {
+            const headers = new Headers();
+            if (varies)
+                appendVary(headers, "Origin");
+            if (allowed !== null) {
+                headers.set("access-control-allow-origin", allowed);
+                headers.set("access-control-allow-methods", methods);
+                if (options.allowHeaders) {
+                    headers.set("access-control-allow-headers", options.allowHeaders.join(", "));
+                }
+                else {
+                    const requested = c.req.headers.get("access-control-request-headers");
+                    if (requested)
+                        headers.set("access-control-allow-headers", requested);
+                    appendVary(headers, "Access-Control-Request-Headers");
+                }
+                if (options.credentials)
+                    headers.set("access-control-allow-credentials", "true");
+                if (options.maxAge !== undefined)
+                    headers.set("access-control-max-age", String(Math.floor(options.maxAge)));
+            }
+            return new Response(null, { status: 204, headers });
+        }
+        const downstream = await next();
+        // 101(WebSocket のアップグレード)などは作り直すと壊れるので触らない(finalize() と同じ)
+        if (downstream.status < 200)
+            return downstream;
+        const res = editable(downstream);
+        if (varies)
+            appendVary(res.headers, "Origin");
+        if (allowed !== null) {
+            res.headers.set("access-control-allow-origin", allowed);
+            if (options.credentials)
+                res.headers.set("access-control-allow-credentials", "true");
+            if (expose)
+                res.headers.set("access-control-expose-headers", expose);
+        }
+        return res;
+    };
+}

package/dist/src/middleware/response.d.ts

@@ -0,0 +1,2 @@
+export declare function editable(res: Response): Response;
+export declare function appendVary(headers: Headers, ...names: string[]): void;

package/dist/src/middleware/response.js

@@ -0,0 +1,28 @@
+// 標準ミドルウェアが、next() のあとでレスポンスのヘッダーを足すときに使う
+// ヘッダーを変更できるレスポンスにする
+// fetch() や Response.redirect() の Response はヘッダーを変更できないので、そのときだけ作り直す
+export function editable(res) {
+    try {
+        // 同じ値を入れ直すだけ。変更できなければここで TypeError になる
+        res.headers.set("vary", res.headers.get("vary") ?? "");
+        if (res.headers.get("vary") === "")
+            res.headers.delete("vary");
+        return res;
+    }
+    catch {
+        return new Response(res.body, { status: res.status, statusText: res.statusText, headers: new Headers(res.headers) });
+    }
+}
+// Vary に足す(すでにあれば足さない。* なら何もしない)
+export function appendVary(headers, ...names) {
+    const current = headers.get("vary");
+    if (current?.trim() === "*")
+        return;
+    const list = current ? current.split(",").map((v) => v.trim()).filter(Boolean) : [];
+    for (const name of names) {
+        if (!list.some((v) => v.toLowerCase() === name.toLowerCase()))
+            list.push(name);
+    }
+    if (list.length > 0)
+        headers.set("vary", list.join(", "));
+}

package/dist/src/middleware/secure-headers.d.ts

@@ -0,0 +1,19 @@
+import type { Middleware } from "../context.ts";
+type HeaderValue = string | boolean;
+export type SecureHeadersOptions = {
+    contentSecurityPolicy?: HeaderValue;
+    crossOriginEmbedderPolicy?: HeaderValue;
+    crossOriginOpenerPolicy?: HeaderValue;
+    crossOriginResourcePolicy?: HeaderValue;
+    originAgentCluster?: HeaderValue;
+    referrerPolicy?: HeaderValue;
+    strictTransportSecurity?: HeaderValue;
+    xContentTypeOptions?: HeaderValue;
+    xDnsPrefetchControl?: HeaderValue;
+    xDownloadOptions?: HeaderValue;
+    xFrameOptions?: HeaderValue;
+    xPermittedCrossDomainPolicies?: HeaderValue;
+    xXssProtection?: HeaderValue;
+};
+export declare function secureHeaders(options?: SecureHeadersOptions): Middleware;
+export {};

package/dist/src/middleware/secure-headers.js

@@ -0,0 +1,46 @@
+import { editable } from "./response.js";
+// [オプション名, ヘッダー名, 既定の値(null なら既定では付けない)]
+const HEADERS = [
+    ["contentSecurityPolicy", "content-security-policy", null],
+    ["crossOriginEmbedderPolicy", "cross-origin-embedder-policy", null],
+    ["crossOriginOpenerPolicy", "cross-origin-opener-policy", "same-origin"],
+    ["crossOriginResourcePolicy", "cross-origin-resource-policy", "same-origin"],
+    ["originAgentCluster", "origin-agent-cluster", "?1"],
+    ["referrerPolicy", "referrer-policy", "no-referrer"],
+    ["strictTransportSecurity", "strict-transport-security", "max-age=15552000; includeSubDomains"],
+    ["xContentTypeOptions", "x-content-type-options", "nosniff"],
+    ["xDnsPrefetchControl", "x-dns-prefetch-control", "off"],
+    ["xDownloadOptions", "x-download-options", "noopen"],
+    ["xFrameOptions", "x-frame-options", "SAMEORIGIN"],
+    ["xPermittedCrossDomainPolicies", "x-permitted-cross-domain-policies", "none"],
+    ["xXssProtection", "x-xss-protection", "0"],
+];
+export function secureHeaders(options = {}) {
+    const headers = [];
+    for (const [key, name, fallback] of HEADERS) {
+        const value = options[key];
+        if (value === false)
+            continue;
+        if (typeof value === "string")
+            headers.push([name, value]);
+        else if (fallback !== null)
+            headers.push([name, fallback]);
+        else if (value === true) {
+            throw new Error(`secureHeaders(): ${key} には既定の値がないので、文字列で指定してください`);
+        }
+    }
+    return async function secureHeaders(c, next) {
+        // next() のあとでレスポンスに足す。ハンドラーが Response に付けたものは上書きしない
+        // (c.header() で付けたものは、このあと finalize() で入るので、そちらが勝つ)
+        const downstream = await next();
+        // 101(WebSocket のアップグレード)などは作り直すと壊れるので触らない(finalize() と同じ)
+        if (downstream.status < 200)
+            return downstream;
+        const res = editable(downstream);
+        for (const [name, value] of headers) {
+            if (!res.headers.has(name))
+                res.headers.set(name, value);
+        }
+        return res;
+    };
+}

package/dist/src/router.d.ts

@@ -0,0 +1,30 @@
+import type { Handler } from "./context.ts";
+export type Route = {
+    path: string;
+    segments: string[];
+    paramNames: string[];
+    method: string;
+    handler: Handler;
+};
+type Segment<Path extends string> = Path extends `${infer Head}/${infer Rest}` ? Head | Segment<Rest> : Path;
+type ParamName<S extends string> = S extends `:${infer Name}` ? Name : never;
+export type ExtractParams<Path extends string> = string extends Path ? Record<string, string> : {
+    [K in ParamName<Segment<Path>>]: string;
+};
+export type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type RouteTable<K extends string, V extends object = any> = {
+    [Key in K]: Key extends `${string} ${infer Path}` ? Handler<Simplify<ExtractParams<Path>>, V> : 'ルートの書き方が違います。"GET /hello" のように、メソッドとパスの間にスペースを入れてください';
+};
+export declare function splitPattern(pattern: string): string[];
+export declare function splitPath(pathname: string): string[];
+export declare function requestPathname(req: Request): string;
+export declare function matchPath(pattern: readonly string[], path: readonly string[]): Record<string, string> | null;
+export declare function routeShape(segments: readonly string[]): string;
+export declare function checkParamNames(path: string, segments: readonly string[]): void;
+export declare function normalizeMethod(method: string): string;
+export declare function allowedMethods(routes: readonly Route[]): string;
+export declare function startsWithSegments(path: readonly string[], prefix: readonly string[]): boolean;
+export declare function compareRoutes(a: Route, b: Route): number;
+export {};

package/dist/src/router.js

@@ -0,0 +1,177 @@
+import { HttpError, senriError } from "./errors.js";
+// ルートのパターン("/users/:id")を分割する。末尾スラッシュや連続スラッシュは無視
+export function splitPattern(pattern) {
+    return pattern.split("/").filter(Boolean);
+}
+// リクエストのパス(URL の pathname)を分割して、セグメントごとにデコードする
+// - 末尾スラッシュや連続スラッシュは無視する("/a//b/" は "/a/b" と同じ)
+// - "/" ごとに分割してからデコードするので、%2F が区切りと混ざることはないが、
+//   紛らわしいので %2F(デコードすると "/" を含む)は 400 にする
+// - デコードすると "." や ".." になるものは、パストラバーサルの元なので 400 にする
+//   (ふつうは "%2E%2E" も含めて URL の仕様で解決済みなので、ここは念のための防御)
+export function splitPath(pathname) {
+    const segments = [];
+    for (const raw of pathname.split("/")) {
+        if (raw === "")
+            continue;
+        // "%" がなければデコードしても同じなので、しない(ほとんどのリクエストはこちら)
+        // デコードしなければ "/" は含まれない(split で分けたので)
+        let segment = raw;
+        if (raw.includes("%")) {
+            try {
+                segment = decodeURIComponent(raw);
+            }
+            catch {
+                throw new HttpError(400, "400 Bad Request");
+            }
+            if (segment.includes("/"))
+                throw new HttpError(400, "400 Bad Request");
+        }
+        if (segment === "." || segment === "..") {
+            throw new HttpError(400, "400 Bad Request");
+        }
+        segments.push(segment);
+    }
+    return segments;
+}
+// URL の区切り文字や空白を含む Host は、ふつうのクライアントは送らない
+const BAD_HOST = /[\s/?#@\\]/;
+// リクエストの pathname を取り出す。おかしなリクエストは HttpError(400) にする
+// - ランタイムが Host ヘッダーをつないで URL を作ることがある(Deno)。
+//   "Host: x/admin#" だと http://x/admin#/public になり、パスが /admin にすり替わるので弾く
+// - Bun は Host が不正だと req.url を "/public" のような相対 URL にするので、new URL() が失敗する
+// - 速さのため、ふつうは new URL() を使わず req.url の文字列から切り出す。
+//   ただし Deno は req.url を正規化しない("/a/../b" のまま来る)ので、"." のセグメント・%2e・\ を含むときだけ
+//   new URL() に任せて、URL の仕様どおりに解決させる(どちらで取り出しても、同じ結果になるようにしている)
+export function requestPathname(req) {
+    const host = req.headers.get("host");
+    if (host !== null && BAD_HOST.test(host)) {
+        throw new HttpError(400, "400 Bad Request");
+    }
+    const url = req.url;
+    const scheme = url.indexOf("://");
+    if (scheme !== -1) {
+        const start = url.indexOf("/", scheme + 3);
+        if (start === -1)
+            return "/";
+        // "?" か "#" までがパス。1回の走査で、new URL() に任せるべきもの("/." と "%2e" と "\")も探す
+        let needsUrl = false;
+        let i = start;
+        for (; i < url.length; i++) {
+            const ch = url.charCodeAt(i);
+            if (ch === 63 || ch === 35)
+                break; // "?" "#"
+            if (ch === 92)
+                needsUrl = true; // "\"
+            else if (ch === 46 && url.charCodeAt(i - 1) === 47)
+                needsUrl = true; // "/."
+            else if (ch === 37 && url.charCodeAt(i + 1) === 50 && (url.charCodeAt(i + 2) | 32) === 101)
+                needsUrl = true; // "%2e" "%2E"
+        }
+        if (!needsUrl)
+            return url.slice(start, i);
+    }
+    try {
+        return new URL(url).pathname;
+    }
+    catch {
+        throw new HttpError(400, "400 Bad Request");
+    }
+}
+export function matchPath(pattern, path) {
+    // 個数が違ったら一致しない
+    if (pattern.length !== path.length) {
+        return null;
+    }
+    // 1個ずつ比較する
+    const params = {};
+    for (let i = 0; i < pattern.length; i++) {
+        const p = pattern[i];
+        const actual = path[i];
+        if (p.startsWith(":")) {
+            params[p.slice(1)] = actual;
+        }
+        else if (p !== actual) {
+            return null;
+        }
+    }
+    return params;
+}
+// パターンの「形」。パラメーター名は区別しない("/users/:id" と "/users/:name" は同じ "users/:")
+export function routeShape(segments) {
+    return segments.map((s) => (s.startsWith(":") ? ":" : s)).join("/");
+}
+// パラメーター名が空だったり、1つのパターンで2回使われていたりしたらエラー
+// (2回目の値で1回目が黙って上書きされてしまうので)
+export function checkParamNames(path, segments) {
+    const seen = new Set();
+    for (const s of segments) {
+        if (!s.startsWith(":"))
+            continue;
+        const name = s.slice(1);
+        if (name === "") {
+            throw senriError("param_empty", `Empty parameter name: ${path}`);
+        }
+        if (seen.has(name)) {
+            throw senriError("param_twice", `Parameter "${name}" used twice: ${path}`);
+        }
+        seen.add(name);
+    }
+}
+// メソッド名に使える文字(RFC 9110 の token)
+const METHOD = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+// 登録するメソッド名を確かめて、大文字にする("propfind" → "PROPFIND")
+// - CONNECT はプロキシ用、TRACE / TRACK はリクエストをそのまま返すので Cookie を盗む攻撃(XST)に使われる。どれも扱わない
+// - "ALL" は app.all() の印として使っているので、app.on() からは登録させない
+export function normalizeMethod(method) {
+    if (!METHOD.test(method))
+        throw senriError("method_invalid", `Invalid method: ${JSON.stringify(method)}`);
+    const upper = method.toUpperCase();
+    if (upper === "CONNECT" || upper === "TRACE" || upper === "TRACK") {
+        throw senriError("method_unsupported", `${upper} is not supported`);
+    }
+    return upper;
+}
+// Allow ヘッダーに入れるメソッドの一覧("GET, HEAD, POST, OPTIONS")
+// GET があれば HEAD も使える(GET にフォールバックするので)。OPTIONS はいつでも使える
+export function allowedMethods(routes) {
+    const methods = [];
+    for (const r of routes) {
+        if (!methods.includes(r.method))
+            methods.push(r.method);
+        if (r.method === "GET" && !methods.includes("HEAD"))
+            methods.push("HEAD");
+    }
+    if (!methods.includes("OPTIONS"))
+        methods.push("OPTIONS");
+    return methods.join(", ");
+}
+// path の先頭が prefix と一致するか。セグメント単位で比べるので "/admin" は "/administrator" にはマッチしない
+// プレフィックスの ":id" のようなパラメーターは、どんなセグメントにも合う(matchPath と同じ判定)
+export function startsWithSegments(path, prefix) {
+    if (path.length < prefix.length)
+        return false;
+    return prefix.every((p, i) => p.startsWith(":") || p === path[i]);
+}
+// sort 用の比較関数。どの2つを比べても答えが矛盾しない(=並び順が一意に決まる)ようにする
+export function compareRoutes(a, b) {
+    const aParts = a.segments;
+    const bParts = b.segments;
+    // まずセグメント数で分ける。数が違うルート同士はそもそも同じパスにマッチしないので、
+    // ここで順番を決めてしまっても優先順位には影響しない
+    // (以前はここで 0 = 「同じ」と答えていたため、sort の結果が登録順に左右されていた)
+    if (aParts.length !== bParts.length) {
+        return aParts.length - bParts.length;
+    }
+    for (let i = 0; i < aParts.length; i++) {
+        const aIsParam = aParts[i].startsWith(":");
+        const bIsParam = bParts[i].startsWith(":");
+        // aがパラメータでbがパラメータでない場合、bを優先する
+        if (aIsParam && !bIsParam)
+            return 1;
+        // aがパラメータでなくbがパラメータの場合、aを優先する
+        if (!aIsParam && bIsParam)
+            return -1;
+    }
+    return 0;
+}