Добавил скриншоты адаптивной верстки

node_modules/.bin/json-server

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../json-server/lib/bin.js" "$@"
+else 
+  exec node  "$basedir/../json-server/lib/bin.js" "$@"
+fi

node_modules/.bin/json-server.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\json-server\lib\bin.js" %*

node_modules/.bin/json-server.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../json-server/lib/bin.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../json-server/lib/bin.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../json-server/lib/bin.js" $args
+  } else {
+    & "node$exe"  "$basedir/../json-server/lib/bin.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/.bin/npm-run-all

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../npm-run-all/bin/npm-run-all/index.js" "$@"
+else 
+  exec node  "$basedir/../npm-run-all/bin/npm-run-all/index.js" "$@"
+fi

node_modules/.bin/npm-run-all.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\npm-run-all\bin\npm-run-all\index.js" %*

node_modules/.bin/npm-run-all.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../npm-run-all/bin/npm-run-all/index.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../npm-run-all/bin/npm-run-all/index.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../npm-run-all/bin/npm-run-all/index.js" $args
+  } else {
+    & "node$exe"  "$basedir/../npm-run-all/bin/npm-run-all/index.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/.bin/pidtree

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../pidtree/bin/pidtree.js" "$@"
+else 
+  exec node  "$basedir/../pidtree/bin/pidtree.js" "$@"
+fi

node_modules/.bin/pidtree.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\pidtree\bin\pidtree.js" %*

node_modules/.bin/pidtree.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../pidtree/bin/pidtree.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../pidtree/bin/pidtree.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../pidtree/bin/pidtree.js" $args
+  } else {
+    & "node$exe"  "$basedir/../pidtree/bin/pidtree.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/.bin/run-p

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../npm-run-all/bin/run-p/index.js" "$@"
+else 
+  exec node  "$basedir/../npm-run-all/bin/run-p/index.js" "$@"
+fi

node_modules/.bin/run-p.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\npm-run-all\bin\run-p\index.js" %*

node_modules/.bin/run-p.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../npm-run-all/bin/run-p/index.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../npm-run-all/bin/run-p/index.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../npm-run-all/bin/run-p/index.js" $args
+  } else {
+    & "node$exe"  "$basedir/../npm-run-all/bin/run-p/index.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/.bin/run-s

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../npm-run-all/bin/run-s/index.js" "$@"
+else 
+  exec node  "$basedir/../npm-run-all/bin/run-s/index.js" "$@"
+fi

node_modules/.bin/run-s.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\npm-run-all\bin\run-s\index.js" %*

node_modules/.bin/run-s.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../npm-run-all/bin/run-s/index.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../npm-run-all/bin/run-s/index.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../npm-run-all/bin/run-s/index.js" $args
+  } else {
+    & "node$exe"  "$basedir/../npm-run-all/bin/run-s/index.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/.vite/deps/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

node_modules/@eslint-community/eslint-utils/index.d.mts

@@ -0,0 +1,217 @@
+import * as eslint from 'eslint';
+import { Rule, AST } from 'eslint';
+import * as estree from 'estree';
+
+declare const READ: unique symbol;
+declare const CALL: unique symbol;
+declare const CONSTRUCT: unique symbol;
+declare const ESM: unique symbol;
+declare class ReferenceTracker {
+    constructor(globalScope: Scope$2, options?: {
+        mode?: "legacy" | "strict" | undefined;
+        globalObjectNames?: string[] | undefined;
+    } | undefined);
+    private variableStack;
+    private globalScope;
+    private mode;
+    private globalObjectNames;
+    iterateGlobalReferences<T>(traceMap: TraceMap$2<T>): IterableIterator<TrackedReferences$2<T>>;
+    iterateCjsReferences<T_1>(traceMap: TraceMap$2<T_1>): IterableIterator<TrackedReferences$2<T_1>>;
+    iterateEsmReferences<T_2>(traceMap: TraceMap$2<T_2>): IterableIterator<TrackedReferences$2<T_2>>;
+    iteratePropertyReferences<T_3>(node: Expression, traceMap: TraceMap$2<T_3>): IterableIterator<TrackedReferences$2<T_3>>;
+    private _iterateVariableReferences;
+    private _iteratePropertyReferences;
+    private _iterateLhsReferences;
+    private _iterateImportReferences;
+}
+declare namespace ReferenceTracker {
+    export { READ };
+    export { CALL };
+    export { CONSTRUCT };
+    export { ESM };
+}
+type Scope$2 = eslint.Scope.Scope;
+type Expression = estree.Expression;
+type TraceMap$2<T> = TraceMap$1<T>;
+type TrackedReferences$2<T> = TrackedReferences$1<T>;
+
+type StaticValue$2 = StaticValueProvided$1 | StaticValueOptional$1;
+type StaticValueProvided$1 = {
+    optional?: undefined;
+    value: unknown;
+};
+type StaticValueOptional$1 = {
+    optional?: true;
+    value: undefined;
+};
+type ReferenceTrackerOptions$1 = {
+    globalObjectNames?: string[];
+    mode?: "legacy" | "strict";
+};
+type TraceMap$1<T = unknown> = {
+    [i: string]: TraceMapObject<T>;
+};
+type TraceMapObject<T> = {
+    [i: string]: TraceMapObject<T>;
+    [CALL]?: T;
+    [CONSTRUCT]?: T;
+    [READ]?: T;
+    [ESM]?: boolean;
+};
+type TrackedReferences$1<T> = {
+    info: T;
+    node: Rule.Node;
+    path: string[];
+    type: typeof CALL | typeof CONSTRUCT | typeof READ;
+};
+type HasSideEffectOptions$1 = {
+    considerGetters?: boolean;
+    considerImplicitTypeConversion?: boolean;
+};
+type PunctuatorToken<Value extends string> = AST.Token & {
+    type: "Punctuator";
+    value: Value;
+};
+type ArrowToken$1 = PunctuatorToken<"=>">;
+type CommaToken$1 = PunctuatorToken<",">;
+type SemicolonToken$1 = PunctuatorToken<";">;
+type ColonToken$1 = PunctuatorToken<":">;
+type OpeningParenToken$1 = PunctuatorToken<"(">;
+type ClosingParenToken$1 = PunctuatorToken<")">;
+type OpeningBracketToken$1 = PunctuatorToken<"[">;
+type ClosingBracketToken$1 = PunctuatorToken<"]">;
+type OpeningBraceToken$1 = PunctuatorToken<"{">;
+type ClosingBraceToken$1 = PunctuatorToken<"}">;
+
+declare function findVariable(initialScope: Scope$1, nameOrNode: string | Identifier): Variable | null;
+type Scope$1 = eslint.Scope.Scope;
+type Variable = eslint.Scope.Variable;
+type Identifier = estree.Identifier;
+
+declare function getFunctionHeadLocation(node: FunctionNode$1, sourceCode: SourceCode$2): SourceLocation | null;
+type SourceCode$2 = eslint.SourceCode;
+type FunctionNode$1 = estree.Function;
+type SourceLocation = estree.SourceLocation;
+
+declare function getFunctionNameWithKind(node: FunctionNode, sourceCode?: eslint.SourceCode | undefined): string;
+type FunctionNode = estree.Function;
+
+declare function getInnermostScope(initialScope: Scope, node: Node$4): Scope;
+type Scope = eslint.Scope.Scope;
+type Node$4 = estree.Node;
+
+declare function getPropertyName(node: MemberExpression | MethodDefinition | Property | PropertyDefinition, initialScope?: eslint.Scope.Scope | undefined): string | null | undefined;
+type MemberExpression = estree.MemberExpression;
+type MethodDefinition = estree.MethodDefinition;
+type Property = estree.Property;
+type PropertyDefinition = estree.PropertyDefinition;
+
+declare function getStaticValue(node: Node$3, initialScope?: eslint.Scope.Scope | null | undefined): StaticValue$1 | null;
+type StaticValue$1 = StaticValue$2;
+type Node$3 = estree.Node;
+
+declare function getStringIfConstant(node: Node$2, initialScope?: eslint.Scope.Scope | null | undefined): string | null;
+type Node$2 = estree.Node;
+
+declare function hasSideEffect(node: Node$1, sourceCode: SourceCode$1, options?: HasSideEffectOptions$1 | undefined): boolean;
+type Node$1 = estree.Node;
+type SourceCode$1 = eslint.SourceCode;
+
+declare function isArrowToken(token: CommentOrToken): token is ArrowToken$1;
+declare function isCommaToken(token: CommentOrToken): token is CommaToken$1;
+declare function isSemicolonToken(token: CommentOrToken): token is SemicolonToken$1;
+declare function isColonToken(token: CommentOrToken): token is ColonToken$1;
+declare function isOpeningParenToken(token: CommentOrToken): token is OpeningParenToken$1;
+declare function isClosingParenToken(token: CommentOrToken): token is ClosingParenToken$1;
+declare function isOpeningBracketToken(token: CommentOrToken): token is OpeningBracketToken$1;
+declare function isClosingBracketToken(token: CommentOrToken): token is ClosingBracketToken$1;
+declare function isOpeningBraceToken(token: CommentOrToken): token is OpeningBraceToken$1;
+declare function isClosingBraceToken(token: CommentOrToken): token is ClosingBraceToken$1;
+declare function isCommentToken(token: CommentOrToken): token is estree.Comment;
+declare function isNotArrowToken(arg0: CommentOrToken): boolean;
+declare function isNotCommaToken(arg0: CommentOrToken): boolean;
+declare function isNotSemicolonToken(arg0: CommentOrToken): boolean;
+declare function isNotColonToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningParenToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingParenToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningBracketToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingBracketToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningBraceToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingBraceToken(arg0: CommentOrToken): boolean;
+declare function isNotCommentToken(arg0: CommentOrToken): boolean;
+type Token = eslint.AST.Token;
+type Comment = estree.Comment;
+type CommentOrToken = Comment | Token;
+
+declare function isParenthesized(timesOrNode: Node | number, nodeOrSourceCode: Node | SourceCode, optionalSourceCode?: eslint.SourceCode | undefined): boolean;
+type Node = estree.Node;
+type SourceCode = eslint.SourceCode;
+
+declare class PatternMatcher {
+    constructor(pattern: RegExp, options?: {
+        escaped?: boolean | undefined;
+    } | undefined);
+    execAll(str: string): IterableIterator<RegExpExecArray>;
+    test(str: string): boolean;
+    [Symbol.replace](str: string, replacer: string | ((...strs: string[]) => string)): string;
+}
+
+declare namespace _default {
+    export { CALL };
+    export { CONSTRUCT };
+    export { ESM };
+    export { findVariable };
+    export { getFunctionHeadLocation };
+    export { getFunctionNameWithKind };
+    export { getInnermostScope };
+    export { getPropertyName };
+    export { getStaticValue };
+    export { getStringIfConstant };
+    export { hasSideEffect };
+    export { isArrowToken };
+    export { isClosingBraceToken };
+    export { isClosingBracketToken };
+    export { isClosingParenToken };
+    export { isColonToken };
+    export { isCommaToken };
+    export { isCommentToken };
+    export { isNotArrowToken };
+    export { isNotClosingBraceToken };
+    export { isNotClosingBracketToken };
+    export { isNotClosingParenToken };
+    export { isNotColonToken };
+    export { isNotCommaToken };
+    export { isNotCommentToken };
+    export { isNotOpeningBraceToken };
+    export { isNotOpeningBracketToken };
+    export { isNotOpeningParenToken };
+    export { isNotSemicolonToken };
+    export { isOpeningBraceToken };
+    export { isOpeningBracketToken };
+    export { isOpeningParenToken };
+    export { isParenthesized };
+    export { isSemicolonToken };
+    export { PatternMatcher };
+    export { READ };
+    export { ReferenceTracker };
+}
+
+type StaticValue = StaticValue$2;
+type StaticValueOptional = StaticValueOptional$1;
+type StaticValueProvided = StaticValueProvided$1;
+type ReferenceTrackerOptions = ReferenceTrackerOptions$1;
+type TraceMap<T> = TraceMap$1<T>;
+type TrackedReferences<T> = TrackedReferences$1<T>;
+type HasSideEffectOptions = HasSideEffectOptions$1;
+type ArrowToken = ArrowToken$1;
+type CommaToken = CommaToken$1;
+type SemicolonToken = SemicolonToken$1;
+type ColonToken = ColonToken$1;
+type OpeningParenToken = OpeningParenToken$1;
+type ClosingParenToken = ClosingParenToken$1;
+type OpeningBracketToken = OpeningBracketToken$1;
+type ClosingBracketToken = ClosingBracketToken$1;
+type OpeningBraceToken = OpeningBraceToken$1;
+type ClosingBraceToken = ClosingBraceToken$1;
+
+export { ArrowToken, CALL, CONSTRUCT, ClosingBraceToken, ClosingBracketToken, ClosingParenToken, ColonToken, CommaToken, ESM, HasSideEffectOptions, OpeningBraceToken, OpeningBracketToken, OpeningParenToken, PatternMatcher, READ, ReferenceTracker, ReferenceTrackerOptions, SemicolonToken, StaticValue, StaticValueOptional, StaticValueProvided, TraceMap, TrackedReferences, _default as default, findVariable, getFunctionHeadLocation, getFunctionNameWithKind, getInnermostScope, getPropertyName, getStaticValue, getStringIfConstant, hasSideEffect, isArrowToken, isClosingBraceToken, isClosingBracketToken, isClosingParenToken, isColonToken, isCommaToken, isCommentToken, isNotArrowToken, isNotClosingBraceToken, isNotClosingBracketToken, isNotClosingParenToken, isNotColonToken, isNotCommaToken, isNotCommentToken, isNotOpeningBraceToken, isNotOpeningBracketToken, isNotOpeningParenToken, isNotSemicolonToken, isOpeningBraceToken, isOpeningBracketToken, isOpeningParenToken, isParenthesized, isSemicolonToken };

node_modules/@eslint-community/eslint-utils/index.d.ts

@@ -0,0 +1,217 @@
+import * as eslint from 'eslint';
+import { Rule, AST } from 'eslint';
+import * as estree from 'estree';
+
+declare const READ: unique symbol;
+declare const CALL: unique symbol;
+declare const CONSTRUCT: unique symbol;
+declare const ESM: unique symbol;
+declare class ReferenceTracker {
+    constructor(globalScope: Scope$2, options?: {
+        mode?: "legacy" | "strict" | undefined;
+        globalObjectNames?: string[] | undefined;
+    } | undefined);
+    private variableStack;
+    private globalScope;
+    private mode;
+    private globalObjectNames;
+    iterateGlobalReferences<T>(traceMap: TraceMap$2<T>): IterableIterator<TrackedReferences$2<T>>;
+    iterateCjsReferences<T_1>(traceMap: TraceMap$2<T_1>): IterableIterator<TrackedReferences$2<T_1>>;
+    iterateEsmReferences<T_2>(traceMap: TraceMap$2<T_2>): IterableIterator<TrackedReferences$2<T_2>>;
+    iteratePropertyReferences<T_3>(node: Expression, traceMap: TraceMap$2<T_3>): IterableIterator<TrackedReferences$2<T_3>>;
+    private _iterateVariableReferences;
+    private _iteratePropertyReferences;
+    private _iterateLhsReferences;
+    private _iterateImportReferences;
+}
+declare namespace ReferenceTracker {
+    export { READ };
+    export { CALL };
+    export { CONSTRUCT };
+    export { ESM };
+}
+type Scope$2 = eslint.Scope.Scope;
+type Expression = estree.Expression;
+type TraceMap$2<T> = TraceMap$1<T>;
+type TrackedReferences$2<T> = TrackedReferences$1<T>;
+
+type StaticValue$2 = StaticValueProvided$1 | StaticValueOptional$1;
+type StaticValueProvided$1 = {
+    optional?: undefined;
+    value: unknown;
+};
+type StaticValueOptional$1 = {
+    optional?: true;
+    value: undefined;
+};
+type ReferenceTrackerOptions$1 = {
+    globalObjectNames?: string[];
+    mode?: "legacy" | "strict";
+};
+type TraceMap$1<T = unknown> = {
+    [i: string]: TraceMapObject<T>;
+};
+type TraceMapObject<T> = {
+    [i: string]: TraceMapObject<T>;
+    [CALL]?: T;
+    [CONSTRUCT]?: T;
+    [READ]?: T;
+    [ESM]?: boolean;
+};
+type TrackedReferences$1<T> = {
+    info: T;
+    node: Rule.Node;
+    path: string[];
+    type: typeof CALL | typeof CONSTRUCT | typeof READ;
+};
+type HasSideEffectOptions$1 = {
+    considerGetters?: boolean;
+    considerImplicitTypeConversion?: boolean;
+};
+type PunctuatorToken<Value extends string> = AST.Token & {
+    type: "Punctuator";
+    value: Value;
+};
+type ArrowToken$1 = PunctuatorToken<"=>">;
+type CommaToken$1 = PunctuatorToken<",">;
+type SemicolonToken$1 = PunctuatorToken<";">;
+type ColonToken$1 = PunctuatorToken<":">;
+type OpeningParenToken$1 = PunctuatorToken<"(">;
+type ClosingParenToken$1 = PunctuatorToken<")">;
+type OpeningBracketToken$1 = PunctuatorToken<"[">;
+type ClosingBracketToken$1 = PunctuatorToken<"]">;
+type OpeningBraceToken$1 = PunctuatorToken<"{">;
+type ClosingBraceToken$1 = PunctuatorToken<"}">;
+
+declare function findVariable(initialScope: Scope$1, nameOrNode: string | Identifier): Variable | null;
+type Scope$1 = eslint.Scope.Scope;
+type Variable = eslint.Scope.Variable;
+type Identifier = estree.Identifier;
+
+declare function getFunctionHeadLocation(node: FunctionNode$1, sourceCode: SourceCode$2): SourceLocation | null;
+type SourceCode$2 = eslint.SourceCode;
+type FunctionNode$1 = estree.Function;
+type SourceLocation = estree.SourceLocation;
+
+declare function getFunctionNameWithKind(node: FunctionNode, sourceCode?: eslint.SourceCode | undefined): string;
+type FunctionNode = estree.Function;
+
+declare function getInnermostScope(initialScope: Scope, node: Node$4): Scope;
+type Scope = eslint.Scope.Scope;
+type Node$4 = estree.Node;
+
+declare function getPropertyName(node: MemberExpression | MethodDefinition | Property | PropertyDefinition, initialScope?: eslint.Scope.Scope | undefined): string | null | undefined;
+type MemberExpression = estree.MemberExpression;
+type MethodDefinition = estree.MethodDefinition;
+type Property = estree.Property;
+type PropertyDefinition = estree.PropertyDefinition;
+
+declare function getStaticValue(node: Node$3, initialScope?: eslint.Scope.Scope | null | undefined): StaticValue$1 | null;
+type StaticValue$1 = StaticValue$2;
+type Node$3 = estree.Node;
+
+declare function getStringIfConstant(node: Node$2, initialScope?: eslint.Scope.Scope | null | undefined): string | null;
+type Node$2 = estree.Node;
+
+declare function hasSideEffect(node: Node$1, sourceCode: SourceCode$1, options?: HasSideEffectOptions$1 | undefined): boolean;
+type Node$1 = estree.Node;
+type SourceCode$1 = eslint.SourceCode;
+
+declare function isArrowToken(token: CommentOrToken): token is ArrowToken$1;
+declare function isCommaToken(token: CommentOrToken): token is CommaToken$1;
+declare function isSemicolonToken(token: CommentOrToken): token is SemicolonToken$1;
+declare function isColonToken(token: CommentOrToken): token is ColonToken$1;
+declare function isOpeningParenToken(token: CommentOrToken): token is OpeningParenToken$1;
+declare function isClosingParenToken(token: CommentOrToken): token is ClosingParenToken$1;
+declare function isOpeningBracketToken(token: CommentOrToken): token is OpeningBracketToken$1;
+declare function isClosingBracketToken(token: CommentOrToken): token is ClosingBracketToken$1;
+declare function isOpeningBraceToken(token: CommentOrToken): token is OpeningBraceToken$1;
+declare function isClosingBraceToken(token: CommentOrToken): token is ClosingBraceToken$1;
+declare function isCommentToken(token: CommentOrToken): token is estree.Comment;
+declare function isNotArrowToken(arg0: CommentOrToken): boolean;
+declare function isNotCommaToken(arg0: CommentOrToken): boolean;
+declare function isNotSemicolonToken(arg0: CommentOrToken): boolean;
+declare function isNotColonToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningParenToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingParenToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningBracketToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingBracketToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningBraceToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingBraceToken(arg0: CommentOrToken): boolean;
+declare function isNotCommentToken(arg0: CommentOrToken): boolean;
+type Token = eslint.AST.Token;
+type Comment = estree.Comment;
+type CommentOrToken = Comment | Token;
+
+declare function isParenthesized(timesOrNode: Node | number, nodeOrSourceCode: Node | SourceCode, optionalSourceCode?: eslint.SourceCode | undefined): boolean;
+type Node = estree.Node;
+type SourceCode = eslint.SourceCode;
+
+declare class PatternMatcher {
+    constructor(pattern: RegExp, options?: {
+        escaped?: boolean | undefined;
+    } | undefined);
+    execAll(str: string): IterableIterator<RegExpExecArray>;
+    test(str: string): boolean;
+    [Symbol.replace](str: string, replacer: string | ((...strs: string[]) => string)): string;
+}
+
+declare namespace _default {
+    export { CALL };
+    export { CONSTRUCT };
+    export { ESM };
+    export { findVariable };
+    export { getFunctionHeadLocation };
+    export { getFunctionNameWithKind };
+    export { getInnermostScope };
+    export { getPropertyName };
+    export { getStaticValue };
+    export { getStringIfConstant };
+    export { hasSideEffect };
+    export { isArrowToken };
+    export { isClosingBraceToken };
+    export { isClosingBracketToken };
+    export { isClosingParenToken };
+    export { isColonToken };
+    export { isCommaToken };
+    export { isCommentToken };
+    export { isNotArrowToken };
+    export { isNotClosingBraceToken };
+    export { isNotClosingBracketToken };
+    export { isNotClosingParenToken };
+    export { isNotColonToken };
+    export { isNotCommaToken };
+    export { isNotCommentToken };
+    export { isNotOpeningBraceToken };
+    export { isNotOpeningBracketToken };
+    export { isNotOpeningParenToken };
+    export { isNotSemicolonToken };
+    export { isOpeningBraceToken };
+    export { isOpeningBracketToken };
+    export { isOpeningParenToken };
+    export { isParenthesized };
+    export { isSemicolonToken };
+    export { PatternMatcher };
+    export { READ };
+    export { ReferenceTracker };
+}
+
+type StaticValue = StaticValue$2;
+type StaticValueOptional = StaticValueOptional$1;
+type StaticValueProvided = StaticValueProvided$1;
+type ReferenceTrackerOptions = ReferenceTrackerOptions$1;
+type TraceMap<T> = TraceMap$1<T>;
+type TrackedReferences<T> = TrackedReferences$1<T>;
+type HasSideEffectOptions = HasSideEffectOptions$1;
+type ArrowToken = ArrowToken$1;
+type CommaToken = CommaToken$1;
+type SemicolonToken = SemicolonToken$1;
+type ColonToken = ColonToken$1;
+type OpeningParenToken = OpeningParenToken$1;
+type ClosingParenToken = ClosingParenToken$1;
+type OpeningBracketToken = OpeningBracketToken$1;
+type ClosingBracketToken = ClosingBracketToken$1;
+type OpeningBraceToken = OpeningBraceToken$1;
+type ClosingBraceToken = ClosingBraceToken$1;
+
+export { ArrowToken, CALL, CONSTRUCT, ClosingBraceToken, ClosingBracketToken, ClosingParenToken, ColonToken, CommaToken, ESM, HasSideEffectOptions, OpeningBraceToken, OpeningBracketToken, OpeningParenToken, PatternMatcher, READ, ReferenceTracker, ReferenceTrackerOptions, SemicolonToken, StaticValue, StaticValueOptional, StaticValueProvided, TraceMap, TrackedReferences, _default as default, findVariable, getFunctionHeadLocation, getFunctionNameWithKind, getInnermostScope, getPropertyName, getStaticValue, getStringIfConstant, hasSideEffect, isArrowToken, isClosingBraceToken, isClosingBracketToken, isClosingParenToken, isColonToken, isCommaToken, isCommentToken, isNotArrowToken, isNotClosingBraceToken, isNotClosingBracketToken, isNotClosingParenToken, isNotColonToken, isNotCommaToken, isNotCommentToken, isNotOpeningBraceToken, isNotOpeningBracketToken, isNotOpeningParenToken, isNotSemicolonToken, isOpeningBraceToken, isOpeningBracketToken, isOpeningParenToken, isParenthesized, isSemicolonToken };

node_modules/@pkgr/core/index.d.cts

@@ -0,0 +1,3 @@
+import * as core from './lib/index.js'
+
+export = core

node_modules/@polka/url/build.js

@@ -0,0 +1,49 @@
+const qs = require('querystring');
+
+/**
+ * @typedef ParsedURL
+ * @type {import('.').ParsedURL}
+ */
+
+/**
+ * @typedef Request
+ * @property {string} url
+ * @property {ParsedURL} _parsedUrl
+ */
+
+/**
+ * @param {Request} req
+ * @returns {ParsedURL|void}
+ */
+function parse(req) {
+	let raw = req.url;
+	if (raw == null) return;
+
+	let prev = req._parsedUrl;
+	if (prev && prev.raw === raw) return prev;
+
+	let pathname=raw, search='', query, hash;
+
+	if (raw.length > 1) {
+		let idx = raw.indexOf('#', 1);
+
+		if (idx !== -1) {
+			hash = raw.substring(idx);
+			pathname = raw.substring(0, idx);
+		}
+
+		idx = pathname.indexOf('?', 1);
+
+		if (idx !== -1) {
+			search = pathname.substring(idx);
+			pathname = pathname.substring(0, idx);
+			if (search.length > 1) {
+				query = qs.parse(search.substring(1));
+			}
+		}
+	}
+
+	return req._parsedUrl = { pathname, search, query, hash, raw };
+}
+
+exports.parse = parse;

node_modules/@polka/url/build.mjs

@@ -0,0 +1,47 @@
+import * as qs from 'node:querystring';
+
+/**
+ * @typedef ParsedURL
+ * @type {import('.').ParsedURL}
+ */
+
+/**
+ * @typedef Request
+ * @property {string} url
+ * @property {ParsedURL} _parsedUrl
+ */
+
+/**
+ * @param {Request} req
+ * @returns {ParsedURL|void}
+ */
+export function parse(req) {
+	let raw = req.url;
+	if (raw == null) return;
+
+	let prev = req._parsedUrl;
+	if (prev && prev.raw === raw) return prev;
+
+	let pathname=raw, search='', query, hash;
+
+	if (raw.length > 1) {
+		let idx = raw.indexOf('#', 1);
+
+		if (idx !== -1) {
+			hash = raw.substring(idx);
+			pathname = raw.substring(0, idx);
+		}
+
+		idx = pathname.indexOf('?', 1);
+
+		if (idx !== -1) {
+			search = pathname.substring(idx);
+			pathname = pathname.substring(0, idx);
+			if (search.length > 1) {
+				query = qs.parse(search.substring(1));
+			}
+		}
+	}
+
+	return req._parsedUrl = { pathname, search, query, hash, raw };
+}

node_modules/@polka/url/index.d.ts

@@ -0,0 +1,11 @@
+import type { IncomingMessage } from 'http';
+
+export interface ParsedURL {
+	pathname: string;
+	search: string;
+	query: Record<string, string | string[]> | undefined;
+	hash: string | undefined;
+	raw: string;
+}
+
+export function parse(req: IncomingMessage): ParsedURL;

node_modules/@polka/url/package.json

@@ -0,0 +1,30 @@
+{
+  "version": "1.0.0-next.29",
+  "name": "@polka/url",
+  "repository": "lukeed/polka",
+  "description": "Super fast, memoized `req.url` parser",
+  "module": "build.mjs",
+  "types": "index.d.ts",
+  "main": "build.js",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./build.mjs",
+      "require": "./build.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "build.*",
+    "index.d.*"
+  ],
+  "author": {
+    "name": "Luke Edwards",
+    "email": "luke@lukeed.com",
+    "url": "https://lukeed.com"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

node_modules/@polka/url/readme.md

@@ -0,0 +1,68 @@
+# @polka/url [![npm](https://badgen.now.sh/npm/v/@polka/url)](https://npmjs.org/package/@polka/url) [![licenses](https://licenses.dev/b/npm/%40polka%2Furl)](https://licenses.dev/npm/%40polka%2Furl)
+
+> Super fast, memoized `req.url` parser; _not_ limited to [Polka][polka]!
+
+Parses the `url` from a [`IncomingMessage`](https://nodejs.org/api/http.html#http_class_http_incomingmessage) request. The returned object will always only contain the following keys: `search`, `query`, `pathname`, and `raw`.
+
+> **Note:** This library does not process `protocol`, `hostname`, `port`, etc.<br>This is because the incoming `req.url` value only begins with the path information.
+
+Parsed requests will be mutated with a `_parsedUrl` key, containing the returned output. This is used for future memoization, avoiding the need to fully parse the same `url` value multiple times.
+
+## Install
+
+```
+$ npm install --save @polka/url
+```
+
+## Usage
+
+```js
+const parse = require('@polka/url');
+
+let req = {
+  url: '/foo/bar?fizz=buzz'
+};
+let output = parse(req);
+//=> {
+//=>   pathname: '/foo/bar',
+//=>   raw: '/foo/bar?fizz=buzz',
+//=>   search: '?fizz=buzz',
+//=>   query: {
+//=>     fizz: 'buzz'
+//=>   },
+//=> }
+
+// Attaches result for future memoization
+assert.deepEqual(output, req._parsedUrl); //=> true
+```
+
+## API
+
+### url(req)
+Returns: `Object` or `undefined`
+
+> **Important:** The `req` must have a `url` key, otherwise `undefined` will be returned.<br>If no input is provided at all, a `TypeError` will be thrown.
+
+#### req
+Type: `IncomingMessage` or `{ url: string }`
+
+The incoming HTTP request (`req`) or a plain `Object` with a `url` key.
+
+> **Note:** In Node.js servers, the [`req.url`](https://nodejs.org/api/http.html#http_message_url) begins with a pathname & does not include a `hash`.
+
+
+## Benchmarks
+
+Check out the [`bench`](/bench) directory for in-depth benchmark results and comparisons.
+
+
+## Support
+
+Any issues or questions can be sent to the [Polka][polka] repository.<br>However, please specify that your inquiry is about `@polka/url` specifically.
+
+
+## License
+
+MIT © [Luke Edwards](https://lukeed.com)
+
+[polka]: https://github.com/lukeed/polka

node_modules/@rolldown/pluginutils/LICENSE

@@ -0,0 +1,25 @@
+MIT License
+
+Copyright (c) 2024-present VoidZero Inc. & Contributors
+
+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.
+
+end of terms and conditions
+
+The licenses of externally maintained libraries from which parts of the Software is derived are listed [here](https://github.com/rolldown/rolldown/blob/main/THIRD-PARTY-LICENSE).

node_modules/@rolldown/pluginutils/dist/index.cjs

@@ -0,0 +1,256 @@
+"use strict";
+
+//#region src/utils.ts
+const postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+	return url.replace(postfixRE, "");
+}
+function extractQueryWithoutFragment(url) {
+	const questionMarkIndex = url.indexOf("?");
+	if (questionMarkIndex === -1) return "";
+	const fragmentIndex = url.indexOf("#", questionMarkIndex);
+	if (fragmentIndex === -1) return url.substring(questionMarkIndex);
+	else return url.substring(questionMarkIndex, fragmentIndex);
+}
+
+//#endregion
+//#region src/composable-filters.ts
+var And = class {
+	kind;
+	args;
+	constructor(...args) {
+		if (args.length === 0) throw new Error("`And` expects at least one operand");
+		this.args = args;
+		this.kind = "and";
+	}
+};
+var Or = class {
+	kind;
+	args;
+	constructor(...args) {
+		if (args.length === 0) throw new Error("`Or` expects at least one operand");
+		this.args = args;
+		this.kind = "or";
+	}
+};
+var Not = class {
+	kind;
+	expr;
+	constructor(expr) {
+		this.expr = expr;
+		this.kind = "not";
+	}
+};
+var Id = class {
+	kind;
+	pattern;
+	params;
+	constructor(pattern, params) {
+		this.pattern = pattern;
+		this.kind = "id";
+		this.params = params ?? { cleanUrl: false };
+	}
+};
+var ModuleType = class {
+	kind;
+	pattern;
+	constructor(pattern) {
+		this.pattern = pattern;
+		this.kind = "moduleType";
+	}
+};
+var Code = class {
+	kind;
+	pattern;
+	constructor(expr) {
+		this.pattern = expr;
+		this.kind = "code";
+	}
+};
+var Query = class {
+	kind;
+	key;
+	pattern;
+	constructor(key, pattern) {
+		this.pattern = pattern;
+		this.key = key;
+		this.kind = "query";
+	}
+};
+var Include = class {
+	kind;
+	expr;
+	constructor(expr) {
+		this.expr = expr;
+		this.kind = "include";
+	}
+};
+var Exclude = class {
+	kind;
+	expr;
+	constructor(expr) {
+		this.expr = expr;
+		this.kind = "exclude";
+	}
+};
+function and(...args) {
+	return new And(...args);
+}
+function or(...args) {
+	return new Or(...args);
+}
+function not(expr) {
+	return new Not(expr);
+}
+function id(pattern, params) {
+	return new Id(pattern, params);
+}
+function moduleType(pattern) {
+	return new ModuleType(pattern);
+}
+function code(pattern) {
+	return new Code(pattern);
+}
+function query(key, pattern) {
+	return new Query(key, pattern);
+}
+function include(expr) {
+	return new Include(expr);
+}
+function exclude(expr) {
+	return new Exclude(expr);
+}
+/**
+* convert a queryObject to FilterExpression like
+* ```js
+*   and(query(k1, v1), query(k2, v2))
+* ```
+* @param queryFilterObject The query filter object needs to be matched.
+* @returns a `And` FilterExpression
+*/
+function queries(queryFilter) {
+	let arr = Object.entries(queryFilter).map(([key, value]) => {
+		return new Query(key, value);
+	});
+	return and(...arr);
+}
+function interpreter(exprs, code$1, id$1, moduleType$1) {
+	let arr = [];
+	if (Array.isArray(exprs)) arr = exprs;
+	else arr = [exprs];
+	return interpreterImpl(arr, code$1, id$1, moduleType$1);
+}
+function interpreterImpl(expr, code$1, id$1, moduleType$1, ctx = {}) {
+	let hasInclude = false;
+	for (const e of expr) switch (e.kind) {
+		case "include": {
+			hasInclude = true;
+			if (exprInterpreter(e.expr, code$1, id$1, moduleType$1, ctx)) return true;
+			break;
+		}
+		case "exclude": {
+			if (exprInterpreter(e.expr, code$1, id$1, moduleType$1)) return false;
+			break;
+		}
+	}
+	return !hasInclude;
+}
+function exprInterpreter(expr, code$1, id$1, moduleType$1, ctx = {}) {
+	switch (expr.kind) {
+		case "and": return expr.args.every((e) => exprInterpreter(e, code$1, id$1, moduleType$1, ctx));
+		case "or": return expr.args.some((e) => exprInterpreter(e, code$1, id$1, moduleType$1, ctx));
+		case "not": return !exprInterpreter(expr.expr, code$1, id$1, moduleType$1, ctx);
+		case "id": {
+			if (id$1 === void 0) throw new Error("`id` is required for `id` expression");
+			if (expr.params.cleanUrl) id$1 = cleanUrl(id$1);
+			return typeof expr.pattern === "string" ? id$1 === expr.pattern : expr.pattern.test(id$1);
+		}
+		case "moduleType": {
+			if (moduleType$1 === void 0) throw new Error("`moduleType` is required for `moduleType` expression");
+			return moduleType$1 === expr.pattern;
+		}
+		case "code": {
+			if (code$1 === void 0) throw new Error("`code` is required for `code` expression");
+			return typeof expr.pattern === "string" ? code$1.includes(expr.pattern) : expr.pattern.test(code$1);
+		}
+		case "query": {
+			if (id$1 === void 0) throw new Error("`id` is required for `Query` expression");
+			if (!ctx.urlSearchParamsCache) {
+				let queryString = extractQueryWithoutFragment(id$1);
+				ctx.urlSearchParamsCache = new URLSearchParams(queryString);
+			}
+			let urlParams = ctx.urlSearchParamsCache;
+			if (typeof expr.pattern === "boolean") if (expr.pattern) return urlParams.has(expr.key);
+			else return !urlParams.has(expr.key);
+			else if (typeof expr.pattern === "string") return urlParams.get(expr.key) === expr.pattern;
+			else return expr.pattern.test(urlParams.get(expr.key) ?? "");
+		}
+		default: throw new Error(`Expression ${JSON.stringify(expr)} is not expected.`);
+	}
+}
+
+//#endregion
+//#region src/simple-filters.ts
+/**
+* Constructs a RegExp that matches the exact string specified.
+*
+* This is useful for plugin hook filters.
+*
+* @param str the string to match.
+* @param flags flags for the RegExp.
+*/
+function exactRegex(str, flags) {
+	return new RegExp(`^${escapeRegex(str)}$`, flags);
+}
+/**
+* Constructs a RegExp that matches a value that has the specified prefix.
+*
+* This is useful for plugin hook filters.
+*
+* @param str the string to match.
+* @param flags flags for the RegExp.
+*/
+function prefixRegex(str, flags) {
+	return new RegExp(`^${escapeRegex(str)}`, flags);
+}
+const escapeRegexRE = /[-/\\^$*+?.()|[\]{}]/g;
+function escapeRegex(str) {
+	return str.replace(escapeRegexRE, "\\$&");
+}
+function makeIdFiltersToMatchWithQuery(input) {
+	if (!Array.isArray(input)) return makeIdFilterToMatchWithQuery(
+		// Array.isArray cannot narrow the type
+		// https://github.com/microsoft/TypeScript/issues/17002
+		input
+);
+	return input.map((i) => makeIdFilterToMatchWithQuery(i));
+}
+function makeIdFilterToMatchWithQuery(input) {
+	if (typeof input === "string") return `${input}{?*,}`;
+	return makeRegexIdFilterToMatchWithQuery(input);
+}
+function makeRegexIdFilterToMatchWithQuery(input) {
+	return new RegExp(
+		// replace `$` with `(?:\?.*)?$` (ignore `\$`)
+		input.source.replace(/(?<!\\)\$/g, "(?:\\?.*)?$"),
+		input.flags
+);
+}
+
+//#endregion
+exports.and = and;
+exports.code = code;
+exports.exactRegex = exactRegex;
+exports.exclude = exclude;
+exports.exprInterpreter = exprInterpreter;
+exports.id = id;
+exports.include = include;
+exports.interpreter = interpreter;
+exports.interpreterImpl = interpreterImpl;
+exports.makeIdFiltersToMatchWithQuery = makeIdFiltersToMatchWithQuery;
+exports.moduleType = moduleType;
+exports.not = not;
+exports.or = or;
+exports.prefixRegex = prefixRegex;
+exports.queries = queries;
+exports.query = query;

node_modules/@rolldown/pluginutils/dist/index.d.cts

@@ -0,0 +1,116 @@
+//#region src/composable-filters.d.ts
+type StringOrRegExp = string | RegExp;
+type PluginModuleType = "js" | "jsx" | "ts" | "tsx" | "json" | "text" | "base64" | "dataurl" | "binary" | "empty" | (string & {});
+type FilterExpressionKind = FilterExpression["kind"];
+type FilterExpression = And | Or | Not | Id | ModuleType | Code | Query;
+type TopLevelFilterExpression = Include | Exclude;
+declare class And {
+  kind: "and";
+  args: FilterExpression[];
+  constructor(...args: FilterExpression[]);
+}
+declare class Or {
+  kind: "or";
+  args: FilterExpression[];
+  constructor(...args: FilterExpression[]);
+}
+declare class Not {
+  kind: "not";
+  expr: FilterExpression;
+  constructor(expr: FilterExpression);
+}
+interface QueryFilterObject {
+  [key: string]: StringOrRegExp | boolean;
+}
+interface IdParams {
+  cleanUrl?: boolean;
+}
+declare class Id {
+  kind: "id";
+  pattern: StringOrRegExp;
+  params: IdParams;
+  constructor(pattern: StringOrRegExp, params?: IdParams);
+}
+declare class ModuleType {
+  kind: "moduleType";
+  pattern: PluginModuleType;
+  constructor(pattern: PluginModuleType);
+}
+declare class Code {
+  kind: "code";
+  pattern: StringOrRegExp;
+  constructor(expr: StringOrRegExp);
+}
+declare class Query {
+  kind: "query";
+  key: string;
+  pattern: StringOrRegExp | boolean;
+  constructor(key: string, pattern: StringOrRegExp | boolean);
+}
+declare class Include {
+  kind: "include";
+  expr: FilterExpression;
+  constructor(expr: FilterExpression);
+}
+declare class Exclude {
+  kind: "exclude";
+  expr: FilterExpression;
+  constructor(expr: FilterExpression);
+}
+declare function and(...args: FilterExpression[]): And;
+declare function or(...args: FilterExpression[]): Or;
+declare function not(expr: FilterExpression): Not;
+declare function id(pattern: StringOrRegExp, params?: IdParams): Id;
+declare function moduleType(pattern: PluginModuleType): ModuleType;
+declare function code(pattern: StringOrRegExp): Code;
+declare function query(key: string, pattern: StringOrRegExp | boolean): Query;
+declare function include(expr: FilterExpression): Include;
+declare function exclude(expr: FilterExpression): Exclude;
+/**
+* convert a queryObject to FilterExpression like
+* ```js
+*   and(query(k1, v1), query(k2, v2))
+* ```
+* @param queryFilterObject The query filter object needs to be matched.
+* @returns a `And` FilterExpression
+*/
+declare function queries(queryFilter: QueryFilterObject): And;
+declare function interpreter(exprs: TopLevelFilterExpression | TopLevelFilterExpression[], code?: string, id?: string, moduleType?: PluginModuleType): boolean;
+interface InterpreterCtx {
+  urlSearchParamsCache?: URLSearchParams;
+}
+declare function interpreterImpl(expr: TopLevelFilterExpression[], code?: string, id?: string, moduleType?: PluginModuleType, ctx?: InterpreterCtx): boolean;
+declare function exprInterpreter(expr: FilterExpression, code?: string, id?: string, moduleType?: PluginModuleType, ctx?: InterpreterCtx): boolean;
+
+//#endregion
+//#region src/simple-filters.d.ts
+/**
+* Constructs a RegExp that matches the exact string specified.
+*
+* This is useful for plugin hook filters.
+*
+* @param str the string to match.
+* @param flags flags for the RegExp.
+*/
+declare function exactRegex(str: string, flags?: string): RegExp;
+/**
+* Constructs a RegExp that matches a value that has the specified prefix.
+*
+* This is useful for plugin hook filters.
+*
+* @param str the string to match.
+* @param flags flags for the RegExp.
+*/
+declare function prefixRegex(str: string, flags?: string): RegExp;
+type WidenString<T> = T extends string ? string : T;
+/**
+* Converts a id filter to match with an id with a query.
+*
+* @param input the id filters to convert.
+*/
+declare function makeIdFiltersToMatchWithQuery<T extends string | RegExp>(input: T): WidenString<T>;
+declare function makeIdFiltersToMatchWithQuery<T extends string | RegExp>(input: readonly T[]): WidenString<T>[];
+declare function makeIdFiltersToMatchWithQuery(input: string | RegExp | readonly (string | RegExp)[]): string | RegExp | (string | RegExp)[];
+
+//#endregion
+export { FilterExpression, FilterExpressionKind, QueryFilterObject, TopLevelFilterExpression, and, code, exactRegex, exclude, exprInterpreter, id, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query };

node_modules/@rolldown/pluginutils/dist/index.d.ts

@@ -0,0 +1,116 @@
+//#region src/composable-filters.d.ts
+type StringOrRegExp = string | RegExp;
+type PluginModuleType = "js" | "jsx" | "ts" | "tsx" | "json" | "text" | "base64" | "dataurl" | "binary" | "empty" | (string & {});
+type FilterExpressionKind = FilterExpression["kind"];
+type FilterExpression = And | Or | Not | Id | ModuleType | Code | Query;
+type TopLevelFilterExpression = Include | Exclude;
+declare class And {
+  kind: "and";
+  args: FilterExpression[];
+  constructor(...args: FilterExpression[]);
+}
+declare class Or {
+  kind: "or";
+  args: FilterExpression[];
+  constructor(...args: FilterExpression[]);
+}
+declare class Not {
+  kind: "not";
+  expr: FilterExpression;
+  constructor(expr: FilterExpression);
+}
+interface QueryFilterObject {
+  [key: string]: StringOrRegExp | boolean;
+}
+interface IdParams {
+  cleanUrl?: boolean;
+}
+declare class Id {
+  kind: "id";
+  pattern: StringOrRegExp;
+  params: IdParams;
+  constructor(pattern: StringOrRegExp, params?: IdParams);
+}
+declare class ModuleType {
+  kind: "moduleType";
+  pattern: PluginModuleType;
+  constructor(pattern: PluginModuleType);
+}
+declare class Code {
+  kind: "code";
+  pattern: StringOrRegExp;
+  constructor(expr: StringOrRegExp);
+}
+declare class Query {
+  kind: "query";
+  key: string;
+  pattern: StringOrRegExp | boolean;
+  constructor(key: string, pattern: StringOrRegExp | boolean);
+}
+declare class Include {
+  kind: "include";
+  expr: FilterExpression;
+  constructor(expr: FilterExpression);
+}
+declare class Exclude {
+  kind: "exclude";
+  expr: FilterExpression;
+  constructor(expr: FilterExpression);
+}
+declare function and(...args: FilterExpression[]): And;
+declare function or(...args: FilterExpression[]): Or;
+declare function not(expr: FilterExpression): Not;
+declare function id(pattern: StringOrRegExp, params?: IdParams): Id;
+declare function moduleType(pattern: PluginModuleType): ModuleType;
+declare function code(pattern: StringOrRegExp): Code;
+declare function query(key: string, pattern: StringOrRegExp | boolean): Query;
+declare function include(expr: FilterExpression): Include;
+declare function exclude(expr: FilterExpression): Exclude;
+/**
+* convert a queryObject to FilterExpression like
+* ```js
+*   and(query(k1, v1), query(k2, v2))
+* ```
+* @param queryFilterObject The query filter object needs to be matched.
+* @returns a `And` FilterExpression
+*/
+declare function queries(queryFilter: QueryFilterObject): And;
+declare function interpreter(exprs: TopLevelFilterExpression | TopLevelFilterExpression[], code?: string, id?: string, moduleType?: PluginModuleType): boolean;
+interface InterpreterCtx {
+  urlSearchParamsCache?: URLSearchParams;
+}
+declare function interpreterImpl(expr: TopLevelFilterExpression[], code?: string, id?: string, moduleType?: PluginModuleType, ctx?: InterpreterCtx): boolean;
+declare function exprInterpreter(expr: FilterExpression, code?: string, id?: string, moduleType?: PluginModuleType, ctx?: InterpreterCtx): boolean;
+
+//#endregion
+//#region src/simple-filters.d.ts
+/**
+* Constructs a RegExp that matches the exact string specified.
+*
+* This is useful for plugin hook filters.
+*
+* @param str the string to match.
+* @param flags flags for the RegExp.
+*/
+declare function exactRegex(str: string, flags?: string): RegExp;
+/**
+* Constructs a RegExp that matches a value that has the specified prefix.
+*
+* This is useful for plugin hook filters.
+*
+* @param str the string to match.
+* @param flags flags for the RegExp.
+*/
+declare function prefixRegex(str: string, flags?: string): RegExp;
+type WidenString<T> = T extends string ? string : T;
+/**
+* Converts a id filter to match with an id with a query.
+*
+* @param input the id filters to convert.
+*/
+declare function makeIdFiltersToMatchWithQuery<T extends string | RegExp>(input: T): WidenString<T>;
+declare function makeIdFiltersToMatchWithQuery<T extends string | RegExp>(input: readonly T[]): WidenString<T>[];
+declare function makeIdFiltersToMatchWithQuery(input: string | RegExp | readonly (string | RegExp)[]): string | RegExp | (string | RegExp)[];
+
+//#endregion
+export { FilterExpression, FilterExpressionKind, QueryFilterObject, TopLevelFilterExpression, and, code, exactRegex, exclude, exprInterpreter, id, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query };

node_modules/@rolldown/pluginutils/dist/index.js

@@ -0,0 +1,239 @@
+//#region src/utils.ts
+const postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+	return url.replace(postfixRE, "");
+}
+function extractQueryWithoutFragment(url) {
+	const questionMarkIndex = url.indexOf("?");
+	if (questionMarkIndex === -1) return "";
+	const fragmentIndex = url.indexOf("#", questionMarkIndex);
+	if (fragmentIndex === -1) return url.substring(questionMarkIndex);
+	else return url.substring(questionMarkIndex, fragmentIndex);
+}
+
+//#endregion
+//#region src/composable-filters.ts
+var And = class {
+	kind;
+	args;
+	constructor(...args) {
+		if (args.length === 0) throw new Error("`And` expects at least one operand");
+		this.args = args;
+		this.kind = "and";
+	}
+};
+var Or = class {
+	kind;
+	args;
+	constructor(...args) {
+		if (args.length === 0) throw new Error("`Or` expects at least one operand");
+		this.args = args;
+		this.kind = "or";
+	}
+};
+var Not = class {
+	kind;
+	expr;
+	constructor(expr) {
+		this.expr = expr;
+		this.kind = "not";
+	}
+};
+var Id = class {
+	kind;
+	pattern;
+	params;
+	constructor(pattern, params) {
+		this.pattern = pattern;
+		this.kind = "id";
+		this.params = params ?? { cleanUrl: false };
+	}
+};
+var ModuleType = class {
+	kind;
+	pattern;
+	constructor(pattern) {
+		this.pattern = pattern;
+		this.kind = "moduleType";
+	}
+};
+var Code = class {
+	kind;
+	pattern;
+	constructor(expr) {
+		this.pattern = expr;
+		this.kind = "code";
+	}
+};
+var Query = class {
+	kind;
+	key;
+	pattern;
+	constructor(key, pattern) {
+		this.pattern = pattern;
+		this.key = key;
+		this.kind = "query";
+	}
+};
+var Include = class {
+	kind;
+	expr;
+	constructor(expr) {
+		this.expr = expr;
+		this.kind = "include";
+	}
+};
+var Exclude = class {
+	kind;
+	expr;
+	constructor(expr) {
+		this.expr = expr;
+		this.kind = "exclude";
+	}
+};
+function and(...args) {
+	return new And(...args);
+}
+function or(...args) {
+	return new Or(...args);
+}
+function not(expr) {
+	return new Not(expr);
+}
+function id(pattern, params) {
+	return new Id(pattern, params);
+}
+function moduleType(pattern) {
+	return new ModuleType(pattern);
+}
+function code(pattern) {
+	return new Code(pattern);
+}
+function query(key, pattern) {
+	return new Query(key, pattern);
+}
+function include(expr) {
+	return new Include(expr);
+}
+function exclude(expr) {
+	return new Exclude(expr);
+}
+/**
+* convert a queryObject to FilterExpression like
+* ```js
+*   and(query(k1, v1), query(k2, v2))
+* ```
+* @param queryFilterObject The query filter object needs to be matched.
+* @returns a `And` FilterExpression
+*/
+function queries(queryFilter) {
+	let arr = Object.entries(queryFilter).map(([key, value]) => {
+		return new Query(key, value);
+	});
+	return and(...arr);
+}
+function interpreter(exprs, code$1, id$1, moduleType$1) {
+	let arr = [];
+	if (Array.isArray(exprs)) arr = exprs;
+	else arr = [exprs];
+	return interpreterImpl(arr, code$1, id$1, moduleType$1);
+}
+function interpreterImpl(expr, code$1, id$1, moduleType$1, ctx = {}) {
+	let hasInclude = false;
+	for (const e of expr) switch (e.kind) {
+		case "include": {
+			hasInclude = true;
+			if (exprInterpreter(e.expr, code$1, id$1, moduleType$1, ctx)) return true;
+			break;
+		}
+		case "exclude": {
+			if (exprInterpreter(e.expr, code$1, id$1, moduleType$1)) return false;
+			break;
+		}
+	}
+	return !hasInclude;
+}
+function exprInterpreter(expr, code$1, id$1, moduleType$1, ctx = {}) {
+	switch (expr.kind) {
+		case "and": return expr.args.every((e) => exprInterpreter(e, code$1, id$1, moduleType$1, ctx));
+		case "or": return expr.args.some((e) => exprInterpreter(e, code$1, id$1, moduleType$1, ctx));
+		case "not": return !exprInterpreter(expr.expr, code$1, id$1, moduleType$1, ctx);
+		case "id": {
+			if (id$1 === void 0) throw new Error("`id` is required for `id` expression");
+			if (expr.params.cleanUrl) id$1 = cleanUrl(id$1);
+			return typeof expr.pattern === "string" ? id$1 === expr.pattern : expr.pattern.test(id$1);
+		}
+		case "moduleType": {
+			if (moduleType$1 === void 0) throw new Error("`moduleType` is required for `moduleType` expression");
+			return moduleType$1 === expr.pattern;
+		}
+		case "code": {
+			if (code$1 === void 0) throw new Error("`code` is required for `code` expression");
+			return typeof expr.pattern === "string" ? code$1.includes(expr.pattern) : expr.pattern.test(code$1);
+		}
+		case "query": {
+			if (id$1 === void 0) throw new Error("`id` is required for `Query` expression");
+			if (!ctx.urlSearchParamsCache) {
+				let queryString = extractQueryWithoutFragment(id$1);
+				ctx.urlSearchParamsCache = new URLSearchParams(queryString);
+			}
+			let urlParams = ctx.urlSearchParamsCache;
+			if (typeof expr.pattern === "boolean") if (expr.pattern) return urlParams.has(expr.key);
+			else return !urlParams.has(expr.key);
+			else if (typeof expr.pattern === "string") return urlParams.get(expr.key) === expr.pattern;
+			else return expr.pattern.test(urlParams.get(expr.key) ?? "");
+		}
+		default: throw new Error(`Expression ${JSON.stringify(expr)} is not expected.`);
+	}
+}
+
+//#endregion
+//#region src/simple-filters.ts
+/**
+* Constructs a RegExp that matches the exact string specified.
+*
+* This is useful for plugin hook filters.
+*
+* @param str the string to match.
+* @param flags flags for the RegExp.
+*/
+function exactRegex(str, flags) {
+	return new RegExp(`^${escapeRegex(str)}$`, flags);
+}
+/**
+* Constructs a RegExp that matches a value that has the specified prefix.
+*
+* This is useful for plugin hook filters.
+*
+* @param str the string to match.
+* @param flags flags for the RegExp.
+*/
+function prefixRegex(str, flags) {
+	return new RegExp(`^${escapeRegex(str)}`, flags);
+}
+const escapeRegexRE = /[-/\\^$*+?.()|[\]{}]/g;
+function escapeRegex(str) {
+	return str.replace(escapeRegexRE, "\\$&");
+}
+function makeIdFiltersToMatchWithQuery(input) {
+	if (!Array.isArray(input)) return makeIdFilterToMatchWithQuery(
+		// Array.isArray cannot narrow the type
+		// https://github.com/microsoft/TypeScript/issues/17002
+		input
+);
+	return input.map((i) => makeIdFilterToMatchWithQuery(i));
+}
+function makeIdFilterToMatchWithQuery(input) {
+	if (typeof input === "string") return `${input}{?*,}`;
+	return makeRegexIdFilterToMatchWithQuery(input);
+}
+function makeRegexIdFilterToMatchWithQuery(input) {
+	return new RegExp(
+		// replace `$` with `(?:\?.*)?$` (ignore `\$`)
+		input.source.replace(/(?<!\\)\$/g, "(?:\\?.*)?$"),
+		input.flags
+);
+}
+
+//#endregion
+export { and, code, exactRegex, exclude, exprInterpreter, id, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query };

node_modules/@rolldown/pluginutils/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@rolldown/pluginutils",
+  "version": "1.0.0-beta.9",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rolldown/rolldown.git",
+    "directory": "packages/pluginutils"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/picomatch": "^4.0.0",
+    "picomatch": "^4.0.2",
+    "tsdown": "0.11.11",
+    "vitest": "^3.0.1"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest --typecheck"
+  }
+}

node_modules/@rollup/rollup-win32-x64-msvc/README.md

@@ -0,0 +1,3 @@
+# `@rollup/rollup-win32-x64-msvc`
+
+This is the **x86_64-pc-windows-msvc** binary for `rollup`

node_modules/@tinyhttp/accepts/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 v 1 r t l
+
+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.

node_modules/@tinyhttp/accepts/README.md

@@ -0,0 +1,117 @@
+# @tinyhttp/accepts
+
+> [`accepts`](https://github.com/jshttp/accepts) rewrite in TypeScript.
+
+Higher level content negotiation based on
+[negotiator](https://www.npmjs.com/package/negotiator). Extracted from
+[koa](https://www.npmjs.com/package/koa) for general use.
+
+In addition to negotiator, it allows:
+
+- Allows types as an array or arguments list, ie
+  `(['text/html', 'application/json'])` as well as
+  `('text/html', 'application/json')`.
+- Allows type shorthands such as `json`.
+- Returns `false` when no types match
+- Treats non-existent headers as `*`
+
+## Install
+
+```sh
+pnpm i @tinyhttp/accepts
+```
+
+## API
+
+```ts
+import { Accepts } from '@tinyhttp/accepts'
+```
+
+### accepts(req)
+
+Create a new `Accepts` object for the given `req`.
+
+#### `.charset(charsets)`
+
+Return the first accepted charset. If nothing in `charsets` is accepted, then
+`false` is returned.
+
+#### `.charsets()`
+
+Return the charsets that the request accepts, in the order of the client's
+preference (most preferred first).
+
+#### `.encoding(encodings)`
+
+Return the first accepted encoding. If nothing in `encodings` is accepted, then
+`false` is returned.
+
+#### `.encodings()`
+
+Return the encodings that the request accepts, in the order of the client's
+preference (most preferred first).
+
+#### `.language(languages)`
+
+Return the first accepted language. If nothing in `languages` is accepted, then
+`false` is returned.
+
+#### `.languages()`
+
+Return the languages that the request accepts, in the order of the client's
+preference (most preferred first).
+
+#### `.type(types)`
+
+Return the first accepted type (and it is returned as the same text as what
+appears in the `types` array). If nothing in `types` is accepted, then `false`
+is returned.
+
+The `types` array can contain full MIME types or file extensions. Any value that
+is not a full MIME types is passed to `require('mime-types').lookup`.
+
+#### `.types()`
+
+Return the types that the request accepts, in the order of the client's
+preference (most preferred first).
+
+## Example
+
+This simple example shows how to use `accepts` to return a different typed
+respond body based on what the client wants to accept. The server lists it's
+preferences in order and will get back the best match between the client and
+server.
+
+```ts
+import Accepts from '@tinyhttp/accepts'
+import { createServer } from 'node:http'
+
+createServer((req, res) => {
+  const accept = new Accepts(req)
+
+  // the order of this list is significant; should be server preferred order
+  switch (accept.type(['json', 'html'])) {
+    case 'json':
+      res.setHeader('Content-Type', 'application/json')
+      res.write('{"hello":"world!"}')
+      break
+    case 'html':
+      res.setHeader('Content-Type', 'text/html')
+      res.write('<b>hello, world!</b>')
+      break
+    default:
+      // the fallback is text/plain, so no need to specify it above
+      res.setHeader('Content-Type', 'text/plain')
+      res.write('hello, world!')
+      break
+  }
+
+  res.end()
+}).listen(3000)
+```
+
+You can test this out with the cURL program:
+
+```sh
+curl -I -H 'Accept: text/html' http://localhost:3000/
+```

node_modules/@tinyhttp/accepts/dist/index.d.ts

@@ -0,0 +1,48 @@
+import type { IncomingMessage as I, IncomingHttpHeaders } from 'node:http';
+import Negotiator from 'negotiator';
+export declare class Accepts {
+    headers: IncomingHttpHeaders;
+    negotiator: Negotiator;
+    constructor(req: Pick<I, 'headers'>);
+    /**
+     * Check if the given `type(s)` is acceptable, returning the best match when true, otherwise `false`, in which case you should respond with 406 "Not Acceptable".
+     *
+     * The `type` value may be a single mime type string such as "application/json", the extension name such as "json" or an array `["json", "html", "text/plain"]`. When a list or array is given the _best_ match, if any is returned. When no types are given as arguments, returns all types accepted by the client in the preference order.
+     */
+    types(types: string | string[], ...args: string[]): string[] | string | false;
+    get type(): (types: string | string[], ...args: string[]) => string[] | string | false;
+    /**
+     * Return accepted encodings or best fit based on `encodings`.
+     *
+     * Given `Accept-Encoding: gzip, deflate`
+     * an array sorted by quality is returned:
+     *
+     *     ['gzip', 'deflate']
+     */
+    encodings(encodings: string | string[], ...args: string[]): string | string[] | boolean;
+    get encoding(): (encodings: string | string[], ...args: string[]) => string | string[] | boolean;
+    /**
+     * Return accepted charsets or best fit based on `charsets`.
+     *
+     * Given `Accept-Charset: utf-8, iso-8859-1;q=0.2, utf-7;q=0.5`
+     * an array sorted by quality is returned:
+     *
+     *     ['utf-8', 'utf-7', 'iso-8859-1']
+     */
+    charsets(charsets?: string | string[], ...args: string[]): string | string[] | boolean;
+    get charset(): (charsets: string | string[], ...args: string[]) => string | string[] | boolean;
+    /**
+     * Return accepted languages or best fit based on `langs`.
+     *
+     * Given `Accept-Language: en;q=0.8, es, pt`
+     * an array sorted by quality is returned:
+     *
+     *     ['es', 'pt', 'en']
+     *
+     */
+    languages(languages: string | string[], ...args: string[]): string | string[] | boolean;
+    get lang(): (languages: string | string[], ...args: string[]) => string | string[] | boolean;
+    get langs(): (languages: string | string[], ...args: string[]) => string | string[] | boolean;
+    get language(): (languages: string | string[], ...args: string[]) => string | string[] | boolean;
+}
+//# sourceMappingURL=index.d.ts.map

node_modules/@tinyhttp/accepts/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,IAAI,CAAC,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAA;AAE1E,OAAO,UAAU,MAAM,YAAY,CAAA;AAMnC,qBAAa,OAAO;IAClB,OAAO,EAAE,mBAAmB,CAAA;IAC5B,UAAU,EAAE,UAAU,CAAA;gBACV,GAAG,EAAE,IAAI,CAAC,CAAC,EAAE,SAAS,CAAC;IAInC;;;;OAIG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,GAAG,KAAK;IA0B7E,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,GAAG,MAAM,GAAG,KAAK,CAErF;IACD;;;;;;;OAOG;IACH,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO;IAevF,IAAI,QAAQ,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAE/F;IACD;;;;;;;OAOG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO;IAetF,IAAI,OAAO,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAE7F;IACD;;;;;;;;OAQG;IACH,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO;IAevF,IAAI,IAAI,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAE3F;IACD,IAAI,KAAK,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAE5F;IACD,IAAI,QAAQ,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAE/F;CACF"}

node_modules/@tinyhttp/accepts/dist/index.js

@@ -0,0 +1,117 @@
+import mime from 'mime';
+import Negotiator from 'negotiator';
+const extToMime = (type) => (type.indexOf('/') === -1 ? mime.getType(type) : type);
+const validMime = (type) => typeof type === 'string';
+export class Accepts {
+    constructor(req) {
+        this.headers = req.headers;
+        this.negotiator = new Negotiator(req);
+    }
+    /**
+     * Check if the given `type(s)` is acceptable, returning the best match when true, otherwise `false`, in which case you should respond with 406 "Not Acceptable".
+     *
+     * The `type` value may be a single mime type string such as "application/json", the extension name such as "json" or an array `["json", "html", "text/plain"]`. When a list or array is given the _best_ match, if any is returned. When no types are given as arguments, returns all types accepted by the client in the preference order.
+     */
+    types(types, ...args) {
+        let mimeTypes = [];
+        // support flattened arguments
+        if (types && !Array.isArray(types)) {
+            mimeTypes = [types, ...args];
+        }
+        else if (types) {
+            mimeTypes = [...types, ...args];
+        }
+        // no types, return all requested types
+        if (!mimeTypes || mimeTypes.length === 0) {
+            return this.negotiator.mediaTypes();
+        }
+        // no accept header, return first given type
+        if (!this.headers.accept) {
+            return mimeTypes[0];
+        }
+        const mimes = mimeTypes.map(extToMime);
+        const accepts = this.negotiator.mediaTypes(mimes.filter(validMime));
+        const [first] = accepts;
+        return first ? mimeTypes[mimes.indexOf(first)] : false;
+    }
+    get type() {
+        return this.types;
+    }
+    /**
+     * Return accepted encodings or best fit based on `encodings`.
+     *
+     * Given `Accept-Encoding: gzip, deflate`
+     * an array sorted by quality is returned:
+     *
+     *     ['gzip', 'deflate']
+     */
+    encodings(encodings, ...args) {
+        let _encodings = encodings;
+        // support flattened arguments
+        if (_encodings && !Array.isArray(_encodings)) {
+            _encodings = [_encodings, ...args];
+        }
+        // no encodings, return all requested encodings
+        if (!_encodings || _encodings.length === 0) {
+            return this.negotiator.encodings();
+        }
+        return this.negotiator.encodings(_encodings)[0] || false;
+    }
+    get encoding() {
+        return this.encodings;
+    }
+    /**
+     * Return accepted charsets or best fit based on `charsets`.
+     *
+     * Given `Accept-Charset: utf-8, iso-8859-1;q=0.2, utf-7;q=0.5`
+     * an array sorted by quality is returned:
+     *
+     *     ['utf-8', 'utf-7', 'iso-8859-1']
+     */
+    charsets(charsets, ...args) {
+        let _charsets = charsets;
+        // support flattened arguments
+        if (_charsets && !Array.isArray(_charsets)) {
+            _charsets = [_charsets, ...args];
+        }
+        // no charsets, return all requested charsets
+        if (!_charsets || _charsets.length === 0) {
+            return this.negotiator.charsets();
+        }
+        return this.negotiator.charsets(_charsets)[0] || false;
+    }
+    get charset() {
+        return this.charsets;
+    }
+    /**
+     * Return accepted languages or best fit based on `langs`.
+     *
+     * Given `Accept-Language: en;q=0.8, es, pt`
+     * an array sorted by quality is returned:
+     *
+     *     ['es', 'pt', 'en']
+     *
+     */
+    languages(languages, ...args) {
+        let _languages = languages;
+        // support flattened arguments
+        if (_languages && !Array.isArray(_languages)) {
+            _languages = [_languages, ...args];
+        }
+        // no languages, return all requested languages
+        if (!_languages || _languages.length === 0) {
+            return this.negotiator.languages();
+        }
+        return this.negotiator.languages(_languages)[0] || false;
+    }
+    get lang() {
+        return this.languages;
+    }
+    get langs() {
+        return this.languages;
+    }
+    get language() {
+        return this.languages;
+    }
+}
+//# sourceMappingURL=index.js.map

node_modules/@tinyhttp/accepts/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

node_modules/@tinyhttp/accepts/node_modules/.bin/mime

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../mime/bin/cli.js" "$@"
+else 
+  exec node  "$basedir/../mime/bin/cli.js" "$@"
+fi

node_modules/@tinyhttp/accepts/node_modules/.bin/mime.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\mime\bin\cli.js" %*

node_modules/@tinyhttp/accepts/node_modules/.bin/mime.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../mime/bin/cli.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../mime/bin/cli.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../mime/bin/cli.js" $args
+  } else {
+    & "node$exe"  "$basedir/../mime/bin/cli.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/@tinyhttp/accepts/node_modules/mime/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Robert Kieffer
+
+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.

node_modules/@tinyhttp/accepts/node_modules/mime/README.md

@@ -0,0 +1,143 @@
+<!--
+  -- This file is auto-generated from src/README_js.md. Changes should be made there.
+  -->
+# Mime
+
+[![NPM downloads](https://img.shields.io/npm/dm/mime)](https://www.npmjs.com/package/mime)
+[![Mime CI](https://github.com/broofa/mime/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/broofa/mime/actions/workflows/ci.yml?query=branch%3Amain)
+
+An API for MIME type information.
+
+- All `mime-db` types
+- Compact and dependency-free [![mime's badge](https://deno.bundlejs.com/?q=mime&badge)](https://bundlejs.com/?q=mime)
+- Full TS support
+
+
+> [!Note]
+> `mime@4` is now `latest`.  If you're upgrading from `mime@3`, note the following:
+> * `mime@4` is API-compatible with `mime@3`, with ~~one~~ two exceptions:
+>   * Direct imports of `mime` properties [no longer supported](https://github.com/broofa/mime/issues/295)
+>   * `mime.define()` cannot be called on the default `mime` object
+> * ESM module support is required.   [ESM Module FAQ](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c).
+> * Requires an [ES2020](https://caniuse.com/?search=es2020) or newer runtime
+> * Built-in Typescript types (`@types/mime` no longer needed)
+
+## Installation
+
+```bash
+npm install mime
+```
+
+## Quick Start
+
+For the full version (800+ MIME types, 1,000+ extensions):
+
+```javascript
+import mime from 'mime';
+
+mime.getType('txt');                    // ⇨ 'text/plain'
+mime.getExtension('text/plain');        // ⇨ 'txt'
+```
+
+### Lite Version [![mime/lite's badge](https://deno.bundlejs.com/?q=mime/lite&badge)](https://bundlejs.com/?q=mime/lite)
+
+`mime/lite` is a drop-in `mime` replacement, stripped of unofficial ("`prs.*`", "`x-*`", "`vnd.*`") types:
+
+```javascript
+import mime from 'mime/lite';
+```
+
+## API
+
+### `mime.getType(pathOrExtension)`
+
+Get mime type for the given file path or extension. E.g.
+
+```javascript
+mime.getType('js');             // ⇨ 'text/javascript'
+mime.getType('json');           // ⇨ 'application/json'
+
+mime.getType('txt');            // ⇨ 'text/plain'
+mime.getType('dir/text.txt');   // ⇨ 'text/plain'
+mime.getType('dir\\text.txt');  // ⇨ 'text/plain'
+mime.getType('.text.txt');      // ⇨ 'text/plain'
+mime.getType('.txt');           // ⇨ 'text/plain'
+```
+
+`null` is returned in cases where an extension is not detected or recognized
+
+```javascript
+mime.getType('foo/txt');        // ⇨ null
+mime.getType('bogus_type');     // ⇨ null
+```
+
+### `mime.getExtension(type)`
+
+Get file extension for the given mime type. Charset options (often included in Content-Type headers) are ignored.
+
+```javascript
+mime.getExtension('text/plain');               // ⇨ 'txt'
+mime.getExtension('application/json');         // ⇨ 'json'
+mime.getExtension('text/html; charset=utf8');  // ⇨ 'html'
+```
+
+### `mime.getAllExtensions(type)`
+
+> [!Note]
+> New in `mime@4`
+
+Get all file extensions for the given mime type.
+
+```javascript --run default
+mime.getAllExtensions('image/jpeg'); // ⇨ Set(3) { 'jpeg', 'jpg', 'jpe' }
+```
+
+## Custom `Mime` instances
+
+The default `mime` objects are immutable.  Custom, mutable versions can be created as follows...
+### new Mime(type map [, type map, ...])
+
+Create a new, custom mime instance.  For example, to create a mutable version of the default `mime` instance:
+
+```javascript
+import { Mime } from 'mime/lite';
+
+import standardTypes from 'mime/types/standard.js';
+import otherTypes from 'mime/types/other.js';
+
+const mime = new Mime(standardTypes, otherTypes);
+```
+
+Each argument is passed to the `define()` method, below. For example `new Mime(standardTypes, otherTypes)` is synonomous with `new Mime().define(standardTypes).define(otherTypes)`
+
+### `mime.define(type map [, force = false])`
+
+> [!Note]
+> Only available on custom `Mime` instances
+
+Define MIME type -> extensions.
+
+Attempting to map a type to an already-defined extension will `throw` unless the `force` argument is set to `true`.
+
+```javascript
+mime.define({'text/x-abc': ['abc', 'abcd']});
+
+mime.getType('abcd');            // ⇨ 'text/x-abc'
+mime.getExtension('text/x-abc')  // ⇨ 'abc'
+```
+
+## Command Line
+
+### Extension -> type
+
+```bash
+$ mime scripts/jquery.js
+text/javascript
+```
+
+### Type -> extension
+
+```bash
+$ mime -r image/jpeg
+jpeg
+```

node_modules/@tinyhttp/accepts/node_modules/mime/bin/cli.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+
+// Thin wrapper around mime
+import mime_cli from '../dist/src/mime_cli.js';
+
+await mime_cli();

node_modules/@tinyhttp/accepts/node_modules/mime/dist/src/Mime.d.ts

@@ -0,0 +1,17 @@
+type TypeMap = {
+    [key: string]: string[];
+};
+export default class Mime {
+    #private;
+    constructor(...args: TypeMap[]);
+    define(typeMap: TypeMap, force?: boolean): this;
+    getType(path: string): string | null;
+    getExtension(type: string): string | null;
+    getAllExtensions(type: string): Set<string> | null;
+    _freeze(): this;
+    _getTestState(): {
+        types: Map<string, string>;
+        extensions: Map<string, string>;
+    };
+}
+export {};

node_modules/@tinyhttp/accepts/node_modules/mime/dist/src/Mime.js

@@ -0,0 +1,85 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Mime_extensionToType, _Mime_typeToExtension, _Mime_typeToExtensions;
+class Mime {
+    constructor(...args) {
+        _Mime_extensionToType.set(this, new Map());
+        _Mime_typeToExtension.set(this, new Map());
+        _Mime_typeToExtensions.set(this, new Map());
+        for (const arg of args) {
+            this.define(arg);
+        }
+    }
+    define(typeMap, force = false) {
+        for (let [type, extensions] of Object.entries(typeMap)) {
+            type = type.toLowerCase();
+            extensions = extensions.map((ext) => ext.toLowerCase());
+            if (!__classPrivateFieldGet(this, _Mime_typeToExtensions, "f").has(type)) {
+                __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").set(type, new Set());
+            }
+            const allExtensions = __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").get(type);
+            let first = true;
+            for (let extension of extensions) {
+                const starred = extension.startsWith('*');
+                extension = starred ? extension.slice(1) : extension;
+                allExtensions?.add(extension);
+                if (first) {
+                    __classPrivateFieldGet(this, _Mime_typeToExtension, "f").set(type, extension);
+                }
+                first = false;
+                if (starred)
+                    continue;
+                const currentType = __classPrivateFieldGet(this, _Mime_extensionToType, "f").get(extension);
+                if (currentType && currentType != type && !force) {
+                    throw new Error(`"${type} -> ${extension}" conflicts with "${currentType} -> ${extension}". Pass \`force=true\` to override this definition.`);
+                }
+                __classPrivateFieldGet(this, _Mime_extensionToType, "f").set(extension, type);
+            }
+        }
+        return this;
+    }
+    getType(path) {
+        if (typeof path !== 'string')
+            return null;
+        const last = path.replace(/^.*[/\\]/, '').toLowerCase();
+        const ext = last.replace(/^.*\./, '').toLowerCase();
+        const hasPath = last.length < path.length;
+        const hasDot = ext.length < last.length - 1;
+        if (!hasDot && hasPath)
+            return null;
+        return __classPrivateFieldGet(this, _Mime_extensionToType, "f").get(ext) ?? null;
+    }
+    getExtension(type) {
+        if (typeof type !== 'string')
+            return null;
+        type = type?.split?.(';')[0];
+        return ((type && __classPrivateFieldGet(this, _Mime_typeToExtension, "f").get(type.trim().toLowerCase())) ?? null);
+    }
+    getAllExtensions(type) {
+        if (typeof type !== 'string')
+            return null;
+        return __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").get(type.toLowerCase()) ?? null;
+    }
+    _freeze() {
+        this.define = () => {
+            throw new Error('define() not allowed for built-in Mime objects. See https://github.com/broofa/mime/blob/main/README.md#custom-mime-instances');
+        };
+        Object.freeze(this);
+        for (const extensions of __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").values()) {
+            Object.freeze(extensions);
+        }
+        return this;
+    }
+    _getTestState() {
+        return {
+            types: __classPrivateFieldGet(this, _Mime_extensionToType, "f"),
+            extensions: __classPrivateFieldGet(this, _Mime_typeToExtension, "f"),
+        };
+    }
+}
+_Mime_extensionToType = new WeakMap(), _Mime_typeToExtension = new WeakMap(), _Mime_typeToExtensions = new WeakMap();
+export default Mime;
+//# sourceMappingURL=Mime.js.map

node_modules/@tinyhttp/accepts/node_modules/mime/dist/src/Mime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Mime.js","sourceRoot":"","sources":["../../src/Mime.ts"],"names":[],"mappings":"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"}

node_modules/@tinyhttp/accepts/node_modules/mime/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+import Mime from './Mime.js';
+export { default as Mime } from './Mime.js';
+declare const _default: Mime;
+export default _default;

node_modules/@tinyhttp/accepts/node_modules/mime/dist/src/index.js

@@ -0,0 +1,6 @@
+import otherTypes from '../types/other.js';
+import standardTypes from '../types/standard.js';
+import Mime from './Mime.js';
+export { default as Mime } from './Mime.js';
+export default new Mime(standardTypes, otherTypes)._freeze();
+//# sourceMappingURL=index.js.map

node_modules/@tinyhttp/accepts/node_modules/mime/dist/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,mBAAmB,CAAC;AAC3C,OAAO,aAAa,MAAM,sBAAsB,CAAC;AACjD,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,WAAW,CAAC;AAE5C,eAAe,IAAI,IAAI,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC,OAAO,EAAE,CAAC"}

node_modules/@tinyhttp/accepts/node_modules/mime/dist/src/index_lite.d.ts

@@ -0,0 +1,4 @@
+import Mime from './Mime.js';
+export { default as Mime } from './Mime.js';
+declare const _default: Mime;
+export default _default;

node_modules/@tinyhttp/accepts/node_modules/mime/dist/src/index_lite.js

@@ -0,0 +1,5 @@
+import standardTypes from '../types/standard.js';
+import Mime from './Mime.js';
+export { default as Mime } from './Mime.js';
+export default new Mime(standardTypes)._freeze();
+//# sourceMappingURL=index_lite.js.map

node_modules/@tinyhttp/accepts/node_modules/mime/dist/src/index_lite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index_lite.js","sourceRoot":"","sources":["../../src/index_lite.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,MAAM,sBAAsB,CAAC;AACjD,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,WAAW,CAAC;AAE5C,eAAe,IAAI,IAAI,CAAC,aAAa,CAAC,CAAC,OAAO,EAAE,CAAC"}

node_modules/@tinyhttp/accepts/node_modules/mime/dist/src/mime_cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export default function (): Promise<void>;

node_modules/@tinyhttp/accepts/node_modules/mime/dist/src/mime_cli.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import mime from './index.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export default async function () {
+    process.title = 'mime';
+    const json = await fs.readFile(path.join(__dirname, '../../package.json'), 'utf-8');
+    const pkg = JSON.parse(json);
+    const args = process.argv.splice(2);
+    if (args.includes('--version') ||
+        args.includes('-v') ||
+        args.includes('--v')) {
+        console.log(pkg.version);
+        process.exit(0);
+    }
+    else if (args.includes('--name') ||
+        args.includes('-n') ||
+        args.includes('--n')) {
+        console.log(pkg.name);
+        process.exit(0);
+    }
+    else if (args.includes('--help') ||
+        args.includes('-h') ||
+        args.includes('--h')) {
+        console.log(pkg.name + ' - ' + pkg.description + '\n');
+        console.log(`Usage:
+
+  mime [flags] [path_or_extension]
+
+  Flags:
+    --help, -h                     Show this message
+    --version, -v                  Display the version
+    --name, -n                     Print the name of the program
+    --reverse, -r                  Print the extension of the mime type
+
+  Note: the command will exit after it executes if a command is specified
+  The path_or_extension is the path to the file or the extension of the file.
+
+  Examples:
+    mime --help
+    mime --version
+    mime --name
+    mime -v
+    mime --reverse application/text
+    mime src/log.js
+    mime new.py
+    mime foo.sh
+  `);
+        process.exit(0);
+    }
+    else if (args.includes('--reverse') || args.includes('-r')) {
+        const mimeType = args[args.length - 1];
+        const extension = mime.getExtension(mimeType);
+        if (!extension)
+            process.exit(1);
+        process.stdout.write(extension + '\n');
+        process.exit(0);
+    }
+    const file = args[0];
+    const type = mime.getType(file);
+    if (!type)
+        process.exit(1);
+    process.stdout.write(type + '\n');
+}
+//# sourceMappingURL=mime_cli.js.map

node_modules/@tinyhttp/accepts/node_modules/mime/dist/src/mime_cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mime_cli.js","sourceRoot":"","sources":["../../src/mime_cli.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAClC,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,IAAI,MAAM,YAAY,CAAC;AAE9B,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAE/D,MAAM,CAAC,OAAO,CAAC,KAAK;IAClB,OAAO,CAAC,KAAK,GAAG,MAAM,CAAC;IAMvB,MAAM,IAAI,GAAG,MAAM,EAAE,CAAC,QAAQ,CAC5B,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,oBAAoB,CAAC,EAC1C,OAAO,CACR,CAAC;IACF,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAE7B,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IAEpC,IACE,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC;QAC1B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;QACnB,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EACpB,CAAC;QACD,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QACzB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;SAAM,IACL,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC;QACvB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;QACnB,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EACpB,CAAC;QACD,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACtB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;SAAM,IACL,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC;QACvB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;QACnB,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EACpB,CAAC;QACD,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,GAAG,KAAK,GAAG,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;QACvD,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;GAsBb,CAAC,CAAC;QACD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;SAAM,IAAI,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7D,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACvC,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QAE9C,IAAI,CAAC,SAAS;YAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAEhC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;QACvC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAED,MAAM,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IACrB,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhC,IAAI,CAAC,IAAI;QAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAE3B,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC;AACpC,CAAC"}

node_modules/@tinyhttp/accepts/node_modules/mime/dist/types/other.d.ts

@@ -0,0 +1,4 @@
+declare const types: {
+    [key: string]: string[];
+};
+export default types;

node_modules/@tinyhttp/accepts/node_modules/mime/dist/types/standard.d.ts

@@ -0,0 +1,4 @@
+declare const types: {
+    [key: string]: string[];
+};
+export default types;

node_modules/@tinyhttp/accepts/node_modules/mime/package.json

@@ -0,0 +1,76 @@
+{
+  "author": {
+    "name": "Robert Kieffer",
+    "url": "http://github.com/broofa",
+    "email": "robert@broofa.com"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=16"
+  },
+  "main": "./dist/src/index.js",
+  "exports": {
+    ".": "./dist/src/index.js",
+    "./lite": "./dist/src/index_lite.js",
+    "./types/standard.js": "./dist/types/standard.js",
+    "./types/other.js": "./dist/types/other.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "bin",
+    "dist/src",
+    "dist/types",
+    "src",
+    "types"
+  ],
+  "bin": {
+    "mime": "bin/cli.js"
+  },
+  "contributors": [],
+  "description": "A comprehensive library for mime-type mapping",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/mime-db": "1.*",
+    "@types/mime-types": "2.1.4",
+    "@types/node": "20.14.10",
+    "@typescript-eslint/eslint-plugin": "7.15.0",
+    "@typescript-eslint/parser": "7.15.0",
+    "chalk": "5.3.0",
+    "mime-score": "2.0.4",
+    "mime-types": "2.1.35",
+    "prettier": "3.3.2",
+    "runmd": "1.3.9",
+    "standard-version": "9.5.0",
+    "typescript": "5.5.3"
+  },
+  "scripts": {
+    "build": "npm run build:clean && tsc",
+    "build:clean": "rm -fr dist",
+    "build:types": "node dist/scripts/build.js",
+    "build:watch": "npm run build:clean && tsc --watch",
+    "lint": "prettier -c .",
+    "lint:fix": "prettier -w .",
+    "prepublishOnly": "npm run build && npm run build:types && npm test",
+    "release": "# `standard-version --dry-run` is the command you're after",
+    "test": "npm run build && node --test && ./test/exports_test.sh",
+    "test:watch": "clear && node --enable-source-maps --test --watch test"
+  },
+  "keywords": [
+    "extension",
+    "file",
+    "mime",
+    "mime-db",
+    "mimetypes",
+    "util"
+  ],
+  "name": "mime",
+  "repository": {
+    "url": "https://github.com/broofa/mime",
+    "type": "git"
+  },
+  "version": "4.0.4",
+  "funding": [
+    "https://github.com/sponsors/broofa"
+  ],
+  "packageManager": "npm@10.8.1+sha256.b8807aebb9656758e2872fa6e7c564b506aa2faa9297439a478d471d2fe32483"
+}

node_modules/@tinyhttp/accepts/node_modules/mime/src/Mime.ts

@@ -0,0 +1,137 @@
+type TypeMap = { [key: string]: string[] };
+
+export default class Mime {
+  #extensionToType = new Map<string, string>();
+  #typeToExtension = new Map<string, string>();
+  #typeToExtensions = new Map<string, Set<string>>();
+
+  constructor(...args: TypeMap[]) {
+    for (const arg of args) {
+      this.define(arg);
+    }
+  }
+
+  /**
+   * Define mimetype -> extension mappings.  Each key is a mime-type that maps
+   * to an array of extensions associated with the type.  The first extension is
+   * used as the default extension for the type.
+   *
+   * e.g. mime.define({'audio/ogg', ['oga', 'ogg', 'spx']});
+   *
+   * If a mapping for an extension has already been defined an error will be
+   * thrown unless the `force` argument is set to `true`.
+   *
+   * e.g. mime.define({'audio/wav', ['wav']}, {'audio/x-wav', ['*wav']});
+   */
+  define(typeMap: TypeMap, force = false) {
+    for (let [type, extensions] of Object.entries(typeMap)) {
+      // Lowercase thingz
+      type = type.toLowerCase();
+      extensions = extensions.map((ext) => ext.toLowerCase());
+
+      if (!this.#typeToExtensions.has(type)) {
+        this.#typeToExtensions.set(type, new Set<string>());
+      }
+      const allExtensions = this.#typeToExtensions.get(type);
+
+      let first = true;
+      for (let extension of extensions) {
+        const starred = extension.startsWith('*');
+
+        extension = starred ? extension.slice(1) : extension;
+
+        // Add to list of extensions for the type
+        allExtensions?.add(extension);
+
+        if (first) {
+          // Map type to default extension (first in list)
+          this.#typeToExtension.set(type, extension);
+        }
+        first = false;
+
+        // Starred types are not eligible to be the default extension
+        if (starred) continue;
+
+        // Map extension to type
+        const currentType = this.#extensionToType.get(extension);
+        if (currentType && currentType != type && !force) {
+          throw new Error(
+            `"${type} -> ${extension}" conflicts with "${currentType} -> ${extension}". Pass \`force=true\` to override this definition.`,
+          );
+        }
+        this.#extensionToType.set(extension, type);
+      }
+    }
+
+    return this;
+  }
+
+  /**
+   * Get mime type associated with an extension
+   */
+  getType(path: string) {
+    if (typeof path !== 'string') return null;
+
+    // Remove chars preceeding `/` or `\`
+    const last = path.replace(/^.*[/\\]/, '').toLowerCase();
+
+    // Remove chars preceeding '.'
+    const ext = last.replace(/^.*\./, '').toLowerCase();
+
+    const hasPath = last.length < path.length;
+    const hasDot = ext.length < last.length - 1;
+
+    // Extension-less file?
+    if (!hasDot && hasPath) return null;
+
+    return this.#extensionToType.get(ext) ?? null;
+  }
+
+  /**
+   * Get default file extension associated with a mime type
+   */
+  getExtension(type: string) {
+    if (typeof type !== 'string') return null;
+
+    // Remove http header parameter(s) (specifically, charset)
+    type = type?.split?.(';')[0];
+
+    return (
+      (type && this.#typeToExtension.get(type.trim().toLowerCase())) ?? null
+    );
+  }
+
+  /**
+   * Get all file extensions associated with a mime type
+   */
+  getAllExtensions(type: string) {
+    if (typeof type !== 'string') return null;
+
+    return this.#typeToExtensions.get(type.toLowerCase()) ?? null;
+  }
+
+  //
+  // Private API, for internal use only.  These APIs may change at any time
+  //
+
+  _freeze() {
+    this.define = () => {
+      throw new Error('define() not allowed for built-in Mime objects. See https://github.com/broofa/mime/blob/main/README.md#custom-mime-instances');
+    };
+
+    Object.freeze(this);
+
+    for (const extensions of this.#typeToExtensions.values()) {
+      Object.freeze(extensions);
+    }
+
+    return this;
+  }
+
+  _getTestState() {
+    return {
+      types: this.#extensionToType,
+      extensions: this.#typeToExtension,
+    };
+  }
+}

node_modules/@tinyhttp/accepts/node_modules/mime/src/index.ts

@@ -0,0 +1,7 @@
+import otherTypes from '../types/other.js';
+import standardTypes from '../types/standard.js';
+import Mime from './Mime.js';
+
+export { default as Mime } from './Mime.js';
+
+export default new Mime(standardTypes, otherTypes)._freeze();

node_modules/@tinyhttp/accepts/node_modules/mime/src/index_lite.ts

@@ -0,0 +1,6 @@
+import standardTypes from '../types/standard.js';
+import Mime from './Mime.js';
+
+export { default as Mime } from './Mime.js';
+
+export default new Mime(standardTypes)._freeze();

node_modules/@tinyhttp/accepts/node_modules/mime/src/mime_cli.ts

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import mime from './index.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export default async function () {
+  process.title = 'mime';
+
+  // TODO: Use json imports to access package.json once "import attributes" are
+  // a real, stable thing.
+  //
+  // See https://github.com/tc39/proposal-import-attributes
+  const json = await fs.readFile(
+    path.join(__dirname, '../../package.json'),
+    'utf-8',
+  );
+  const pkg = JSON.parse(json);
+
+  const args = process.argv.splice(2);
+
+  if (
+    args.includes('--version') ||
+    args.includes('-v') ||
+    args.includes('--v')
+  ) {
+    console.log(pkg.version);
+    process.exit(0);
+  } else if (
+    args.includes('--name') ||
+    args.includes('-n') ||
+    args.includes('--n')
+  ) {
+    console.log(pkg.name);
+    process.exit(0);
+  } else if (
+    args.includes('--help') ||
+    args.includes('-h') ||
+    args.includes('--h')
+  ) {
+    console.log(pkg.name + ' - ' + pkg.description + '\n');
+    console.log(`Usage:
+
+  mime [flags] [path_or_extension]
+
+  Flags:
+    --help, -h                     Show this message
+    --version, -v                  Display the version
+    --name, -n                     Print the name of the program
+    --reverse, -r                  Print the extension of the mime type
+
+  Note: the command will exit after it executes if a command is specified
+  The path_or_extension is the path to the file or the extension of the file.
+
+  Examples:
+    mime --help
+    mime --version
+    mime --name
+    mime -v
+    mime --reverse application/text
+    mime src/log.js
+    mime new.py
+    mime foo.sh
+  `);
+    process.exit(0);
+  } else if (args.includes('--reverse') || args.includes('-r')) {
+    const mimeType = args[args.length - 1];
+    const extension = mime.getExtension(mimeType);
+
+    if (!extension) process.exit(1);
+
+    process.stdout.write(extension + '\n');
+    process.exit(0);
+  }
+
+  const file = args[0];
+  const type = mime.getType(file);
+
+  if (!type) process.exit(1);
+
+  process.stdout.write(type + '\n');
+}

node_modules/@tinyhttp/accepts/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@tinyhttp/accepts",
+  "description": "accepts rewrite in TypeScript",
+  "version": "2.2.3",
+  "license": "MIT",
+  "homepage": "https://tinyhttp.v1rtl.site",
+  "funding": {
+    "type": "individual",
+    "url": "https://github.com/tinyhttp/tinyhttp?sponsor=1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tinyhttp/tinyhttp.git",
+    "directory": "packages/cookie-signature"
+  },
+  "engines": {
+    "node": ">=12.20.0"
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/negotiator": "^0.6.3"
+  },
+  "dependencies": {
+    "mime": "4.0.4",
+    "negotiator": "^0.6.3"
+  },
+  "scripts": {
+    "build": "tsc"
+  }
+}

node_modules/@tinyhttp/app/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 v 1 r t l
+
+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.

node_modules/@tinyhttp/app/README.md

@@ -0,0 +1,25 @@
+# @tinyhttp/app
+
+The core of tinyhttp. Contains the `App`, `Request` and `Response`. Additionally, it provides special tinyhttp-specific types.
+
+## Install
+
+```sh
+pnpm i @tinyhttp/app
+```
+
+## Example
+
+```ts
+import { App } from '@tinyhttp/app'
+import type { Request, Response, NextFunction } from '@tinyhttp/app'
+
+new App()
+  .use((req: Request, res: Response, next: NextFunction) => {
+    console.log('Did a request')
+    next()
+  })
+  .get('/', (_, res) => res.send('<h1>Hello World</h1>'))
+  .get('/page/:page', (req, res) => res.send(`You opened ${req.params.page}`))
+  .listen(3000)
+```

node_modules/@tinyhttp/app/dist/app.d.ts

@@ -0,0 +1,55 @@
+import { type Server } from 'node:http';
+import type { Handler, Middleware, NextFunction, UseMethodParams } from '@tinyhttp/router';
+import { Router } from '@tinyhttp/router';
+import type { TemplateEngineOptions } from './index.js';
+import type { ErrorHandler } from './onError.js';
+import type { Request } from './request.js';
+import type { Response } from './response.js';
+import type { AppConstructor, AppInterface, AppRenderOptions, AppSettings, TemplateEngine } from './types.js';
+/**
+ * `App` class - the starting point of tinyhttp app.
+ *
+ * With the `App` you can:
+ * * use routing methods and `.use(...)`
+ * * set no match (404) and error (500) handlers
+ * * configure template engines
+ * * store data in locals
+ * * listen the http server on a specified port
+ *
+ * In case you use TypeScript, you can pass custom types to this class because it is also a generic class.
+ *
+ * Example:
+ *
+ * ```ts
+ * interface CoolReq extends Request {
+ *  genericsAreDope: boolean
+ * }
+ *
+ * const app = App<any, CoolReq, Response>()
+ * ```
+ */
+export declare class App<Req extends Request = Request, Res extends Response = Response> extends Router<App, Req, Res> implements AppInterface<Req, Res> {
+    #private;
+    middleware: Middleware<Req, Res>[];
+    locals: Record<string, unknown>;
+    noMatchHandler: Handler;
+    onError: ErrorHandler;
+    settings: AppSettings;
+    engines: Record<string, TemplateEngine>;
+    applyExtensions?: Handler;
+    attach: (req: Req, res: Res, next?: NextFunction) => void;
+    cache: Record<string, unknown>;
+    constructor(options?: AppConstructor<Req, Res>);
+    set<K extends keyof AppSettings>(setting: K, value: AppSettings[K]): this;
+    enable<K extends keyof AppSettings>(setting: K): this;
+    enabled<K extends keyof AppSettings>(setting: K): boolean;
+    disable<K extends keyof AppSettings>(setting: K): this;
+    path(): any;
+    engine<RenderOptions extends TemplateEngineOptions = TemplateEngineOptions>(ext: string, fn: TemplateEngine<RenderOptions>): this;
+    render<RenderOptions extends TemplateEngineOptions = TemplateEngineOptions>(name: string, data?: Record<string, unknown>, options?: AppRenderOptions<RenderOptions>, cb?: (err: unknown, html?: unknown) => void): void;
+    use(...args: UseMethodParams<Req, Res, AppInterface<any, any>>): this;
+    route(path: string): App<any, any>;
+    handler<RenderOptions extends TemplateEngineOptions = TemplateEngineOptions>(req: Req, res: Res, next?: NextFunction): void;
+    listen(port?: number, cb?: () => void, host?: string): Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+}
+//# sourceMappingURL=app.d.ts.map

node_modules/@tinyhttp/app/dist/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../src/app.ts"],"names":[],"mappings":"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"}

node_modules/@tinyhttp/app/dist/app.js

@@ -0,0 +1,323 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _App_instances, _App_find;
+import { createServer } from 'node:http';
+import { getPathname } from '@tinyhttp/req';
+import { Router, pushMiddleware } from '@tinyhttp/router';
+import { parse as rg } from 'regexparam';
+import { extendMiddleware } from './extend.js';
+import { onErrorHandler } from './onError.js';
+import { getURLParams } from './request.js';
+import { View } from './view.js';
+/**
+ * Add leading slash if not present (e.g. path -> /path, /path -> /path)
+ * @param x
+ */
+const lead = (x) => (x.charCodeAt(0) === 47 ? x : `/${x}`);
+const trail = (x) => (x.charCodeAt(x.length - 1) === 47 ? x.substring(0, x.length - 1) : x);
+const mount = (fn) => (fn instanceof App ? fn.attach : fn);
+const applyHandler = (h) => async (req, res, next) => {
+    try {
+        if (h[Symbol.toStringTag] === 'AsyncFunction') {
+            await h(req, res, next);
+        }
+        else
+            h(req, res, next);
+    }
+    catch (e) {
+        next === null || next === void 0 ? void 0 : next(e);
+    }
+};
+/**
+ * `App` class - the starting point of tinyhttp app.
+ *
+ * With the `App` you can:
+ * * use routing methods and `.use(...)`
+ * * set no match (404) and error (500) handlers
+ * * configure template engines
+ * * store data in locals
+ * * listen the http server on a specified port
+ *
+ * In case you use TypeScript, you can pass custom types to this class because it is also a generic class.
+ *
+ * Example:
+ *
+ * ```ts
+ * interface CoolReq extends Request {
+ *  genericsAreDope: boolean
+ * }
+ *
+ * const app = App<any, CoolReq, Response>()
+ * ```
+ */
+export class App extends Router {
+    constructor(options = {}) {
+        super();
+        _App_instances.add(this);
+        this.middleware = [];
+        this.locals = {};
+        this.engines = {};
+        this.onError = (options === null || options === void 0 ? void 0 : options.onError) || onErrorHandler;
+        // @ts-expect-error typescript is not smart enough to understand "this" ts(2345)
+        this.noMatchHandler = (options === null || options === void 0 ? void 0 : options.noMatchHandler) || this.onError.bind(this, { code: 404 });
+        this.settings = {
+            view: View,
+            xPoweredBy: true,
+            views: `${process.cwd()}/views`,
+            'view cache': process.env.NODE_ENV === 'production',
+            'trust proxy': 0,
+            ...options.settings
+        };
+        if (options.applyExtensions)
+            this.applyExtensions = options === null || options === void 0 ? void 0 : options.applyExtensions;
+        const boundHandler = this.handler.bind(this);
+        this.attach = (req, res, next) => setImmediate(boundHandler, req, res, next);
+        this.cache = {};
+    }
+    set(setting, value) {
+        this.settings[setting] = value;
+        return this;
+    }
+    enable(setting) {
+        this.settings[setting] = true;
+        return this;
+    }
+    enabled(setting) {
+        return Boolean(this.settings[setting]);
+    }
+    disable(setting) {
+        this.settings[setting] = false;
+        return this;
+    }
+    path() {
+        return this.parent ? this.parent.path() + this.mountpath : '';
+    }
+    engine(ext, fn) {
+        this.engines[ext[0] === '.' ? ext : `.${ext}`] = fn;
+        return this;
+    }
+    render(name, data = {}, options = {}, cb = () => { }) {
+        let view;
+        const { _locals, ...opts } = options;
+        let locals = this.locals;
+        if (_locals)
+            locals = { ...locals, ..._locals };
+        locals = { ...locals, ...data };
+        if (opts.cache == null)
+            opts.cache = this.enabled('view cache');
+        if (opts.cache) {
+            view = this.cache[name];
+        }
+        if (!view) {
+            const ViewClass = this.settings.view || View;
+            try {
+                view = new ViewClass(name, {
+                    defaultEngine: this.settings['view engine'],
+                    root: this.settings.views,
+                    engines: this.engines
+                });
+            }
+            catch (err) {
+                return cb(err);
+            }
+            if (opts.cache) {
+                this.cache[name] = view;
+            }
+        }
+        try {
+            view.render(opts, locals, cb);
+        }
+        catch (err) {
+            cb(err);
+        }
+    }
+    use(...args) {
+        var _a;
+        const base = args[0];
+        const fns = args.slice(1).flat();
+        let pathArray = [];
+        if (typeof base === 'function' || base instanceof App) {
+            fns.unshift(base);
+        }
+        else {
+            // if base is not an array of paths, then convert it to an array.
+            let basePaths = [];
+            if (Array.isArray(base))
+                basePaths = base;
+            else if (typeof base === 'string')
+                basePaths = [base];
+            basePaths = basePaths.filter((element) => {
+                if (typeof element === 'string') {
+                    pathArray.push(element);
+                    return false;
+                }
+                return true;
+            });
+            fns.unshift(...basePaths);
+        }
+        pathArray = pathArray.length ? pathArray.map((path) => lead(path)) : ['/'];
+        const mountpath = pathArray.join(', ');
+        let regex;
+        for (const fn of fns) {
+            if (fn instanceof App) {
+                for (const path of pathArray) {
+                    regex = rg(path, true);
+                    fn.mountpath = mountpath;
+                    this.apps[path] = fn;
+                    // @ts-expect-error typescript is not smart enough to understand "this" ts(2345)
+                    fn.parent = this;
+                }
+            }
+        }
+        for (const path of pathArray) {
+            const handlerPaths = [];
+            const handlerFunctions = [];
+            const handlerPathBase = path === '/' ? '' : lead(path);
+            for (const fn of fns) {
+                if (fn instanceof App && ((_a = fn.middleware) === null || _a === void 0 ? void 0 : _a.length)) {
+                    for (const mw of fn.middleware) {
+                        handlerPaths.push(handlerPathBase + lead(mw.path));
+                        handlerFunctions.push(fn);
+                    }
+                }
+                else {
+                    handlerPaths.push('');
+                    handlerFunctions.push(fn);
+                }
+            }
+            pushMiddleware(this.middleware)({
+                path,
+                regex,
+                type: 'mw',
+                handler: mount(handlerFunctions[0]),
+                handlers: handlerFunctions.slice(1).map(mount),
+                fullPaths: handlerPaths
+            });
+        }
+        return this;
+    }
+    route(path) {
+        const app = new App({ settings: this.settings });
+        this.use(path, app);
+        return app;
+    }
+    handler(req, res, next) {
+        /* Set X-Powered-By header */
+        const { xPoweredBy } = this.settings;
+        if (xPoweredBy)
+            res.setHeader('X-Powered-By', typeof xPoweredBy === 'string' ? xPoweredBy : 'tinyhttp');
+        // @ts-expect-error typescript is not smart enough to understand "this" ts(2345)
+        const exts = this.applyExtensions || extendMiddleware(this);
+        let mw = [
+            {
+                handler: exts,
+                type: 'mw',
+                path: '/'
+            }
+        ];
+        req.baseUrl = '';
+        const handle = (mw, pathname) => async (req, res, next) => {
+            var _a;
+            const { path, handler, regex } = mw;
+            let params;
+            try {
+                params = regex ? getURLParams(regex, pathname) : {};
+            }
+            catch (e) {
+                console.error(e);
+                if (e instanceof URIError)
+                    return res.sendStatus(400);
+                throw e;
+            }
+            let prefix = path;
+            if (regex) {
+                for (const key of regex.keys) {
+                    if (key === 'wild') {
+                        prefix = prefix.replace('*', params.wild);
+                    }
+                    else {
+                        prefix = prefix.replace(`:${key}`, params[key]);
+                    }
+                }
+            }
+            req.params = { ...req.params, ...params };
+            if (mw.type === 'mw') {
+                req.url = lead(req.originalUrl.substring(prefix.length));
+                req.baseUrl = trail(req.originalUrl.substring(0, prefix.length));
+            }
+            if (!req.path)
+                req.path = pathname;
+            if ((_a = this.settings) === null || _a === void 0 ? void 0 : _a.enableReqRoute)
+                req.route = mw;
+            await applyHandler(handler)(req, res, next);
+        };
+        let idx = 0;
+        const loop = () => {
+            req.originalUrl = req.baseUrl + req.url;
+            const pathname = getPathname(req.url);
+            const matched = __classPrivateFieldGet(this, _App_instances, "m", _App_find).call(this, pathname).filter((x) => (req.method === 'HEAD' || (x.method ? x.method === req.method : true)) && !mw.includes(x));
+            if (matched.length && matched[0] !== null) {
+                if (idx !== 0) {
+                    idx = mw.length;
+                    req.params = {};
+                }
+                mw = [
+                    ...mw,
+                    ...matched,
+                    {
+                        type: 'mw',
+                        handler: (req, res, next) => {
+                            if (req.method === 'HEAD') {
+                                res.statusCode = 204;
+                                return res.end('');
+                            }
+                            next === null || next === void 0 ? void 0 : next();
+                        },
+                        path: '/'
+                    }
+                ];
+            }
+            else if (this.parent == null) {
+                mw.push({
+                    handler: this.noMatchHandler,
+                    type: 'route',
+                    path: '/'
+                });
+            }
+            void handle(mw[idx++], pathname)(req, res, next);
+        };
+        const parentNext = next;
+        next = (err) => {
+            if (err != null) {
+                // @ts-expect-error The 'this' context of type 'this' is not assignable to method's 'this' of type 'App<Request, Response<unknown>>' ts(2345)
+                return this.onError(err, req, res);
+            }
+            if (res.writableEnded)
+                return;
+            if (idx >= mw.length) {
+                if (parentNext != null)
+                    parentNext();
+                return;
+            }
+            loop();
+        };
+        loop();
+    }
+    listen(port, cb, host) {
+        return createServer().on('request', this.attach).listen(port, host, cb);
+    }
+}
+_App_instances = new WeakSet(), _App_find = function _App_find(url) {
+    return this.middleware.filter((m) => {
+        m.regex = m.regex || rg(m.path, m.type === 'mw');
+        let fullPathRegex;
+        m.fullPath && typeof m.fullPath === 'string'
+            ? (fullPathRegex = rg(m.fullPath, m.type === 'mw'))
+            : (fullPathRegex = null);
+        return m.regex.pattern.test(url) && (m.type === 'mw' && fullPathRegex ? fullPathRegex.pattern.test(url) : true);
+    });
+};
+//# sourceMappingURL=app.js.map

node_modules/@tinyhttp/app/dist/extend.d.ts

@@ -0,0 +1,8 @@
+import type { App } from './app.js';
+import type { Handler } from './index.js';
+import type { TemplateEngineOptions } from './types.js';
+/**
+ * Extends Request and Response objects with custom properties and methods
+ */
+export declare const extendMiddleware: <EngineOptions extends TemplateEngineOptions = TemplateEngineOptions>(app: App) => Handler;
+//# sourceMappingURL=extend.d.ts.map

node_modules/@tinyhttp/app/dist/extend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extend.d.ts","sourceRoot":"","sources":["../src/extend.ts"],"names":[],"mappings":"AAkCA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AACnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AAKzC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAEvD;;GAEG;AACH,eAAO,MAAM,gBAAgB,GAAI,aAAa,SAAS,qBAAqB,+BAA+B,GAAG,KA+DtG,OAAO,CAAA"}

node_modules/@tinyhttp/app/dist/extend.js

@@ -0,0 +1,64 @@
+import { compile } from '@tinyhttp/proxy-addr';
+import { checkIfXMLHttpRequest, getAccepts, getAcceptsCharsets, getAcceptsEncodings, getAcceptsLanguages, getFreshOrStale, getQueryParams, getRangeFromHeader, getRequestHeader, reqIs } from '@tinyhttp/req';
+import { append, attachment, clearCookie, download, formatResponse, getResponseHeader, json, redirect, send, sendFile, sendStatus, setContentType, setCookie, setHeader, setLinksHeader, setLocationHeader, setVaryHeader, status } from '@tinyhttp/res';
+import { getSubdomains } from './request.js';
+import { getHost, getIP, getIPs, getProtocol } from './request.js';
+import { renderTemplate } from './response.js';
+/**
+ * Extends Request and Response objects with custom properties and methods
+ */
+export const extendMiddleware = (app) => ((req, res, next) => {
+    const { settings } = app;
+    res.get = getResponseHeader(res);
+    req.get = getRequestHeader(req);
+    if (settings === null || settings === void 0 ? void 0 : settings.bindAppToReqRes) {
+        req.app = app;
+        res.app = app;
+    }
+    if (settings === null || settings === void 0 ? void 0 : settings.networkExtensions) {
+        let trust = (settings === null || settings === void 0 ? void 0 : settings['trust proxy']) || 0;
+        if (trust && typeof trust !== 'function') {
+            trust = compile(trust);
+            settings['trust proxy'] = trust;
+        }
+        req.protocol = getProtocol(req, trust);
+        req.secure = req.protocol === 'https';
+        const host = getHost(req, trust);
+        req.hostname = host === null || host === void 0 ? void 0 : host.hostname;
+        req.port = host === null || host === void 0 ? void 0 : host.port;
+        req.subdomains = getSubdomains(req, trust, settings.subdomainOffset);
+        req.ip = getIP(req, trust);
+        req.ips = getIPs(req, trust);
+    }
+    req.query = getQueryParams(req.url);
+    req.is = reqIs(req);
+    req.range = getRangeFromHeader(req);
+    req.accepts = getAccepts(req);
+    req.acceptsCharsets = getAcceptsCharsets(req);
+    req.acceptsEncodings = getAcceptsEncodings(req);
+    req.acceptsLanguages = getAcceptsLanguages(req);
+    req.xhr = checkIfXMLHttpRequest(req);
+    res.header = res.set = setHeader(res);
+    res.send = send(req, res);
+    res.json = json(res);
+    res.status = status(res);
+    res.sendStatus = sendStatus(req, res);
+    res.sendFile = sendFile(req, res);
+    res.type = setContentType(res);
+    res.location = setLocationHeader(req, res);
+    res.links = setLinksHeader(res);
+    res.vary = setVaryHeader(res);
+    res.cookie = setCookie(req, res);
+    res.clearCookie = clearCookie(req, res);
+    res.render = renderTemplate(req, res, app);
+    res.format = formatResponse(req, res, next);
+    res.redirect = redirect(req, res, next);
+    res.attachment = attachment(res);
+    res.download = download(req, res);
+    res.append = append(res);
+    res.locals = res.locals || Object.create(null);
+    Object.defineProperty(req, 'fresh', { get: getFreshOrStale.bind(null, req, res), configurable: true });
+    req.stale = !req.fresh;
+    next();
+});
+//# sourceMappingURL=extend.js.map

node_modules/@tinyhttp/app/dist/extend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extend.js","sourceRoot":"","sources":["../src/extend.ts"],"names":[],"mappings":"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"}

node_modules/@tinyhttp/app/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { App } from './app.js';
+export * from './request.js';
+export * from './response.js';
+export { extendMiddleware } from './extend.js';
+export { onErrorHandler, type ErrorHandler } from './onError.js';
+export { View } from './view.js';
+export type { AppSettings, TemplateEngineOptions, TemplateEngine, AppConstructor } from './types.js';
+import type { Middleware, NextFunction, AsyncHandler as RAsyncHandler, Handler as RHandler, SyncHandler as RSyncHandler } from '@tinyhttp/router';
+import type { Request } from './request.js';
+import type { Response } from './response.js';
+export type Handler = RHandler<Request, Response>;
+export type AsyncHandler = RAsyncHandler<Request, Response>;
+export type SyncHandler = RSyncHandler<Request, Response>;
+export type { NextFunction, Middleware, Request, Response };
+//# sourceMappingURL=index.d.ts.map

node_modules/@tinyhttp/app/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAC9B,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA;AAC7B,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,EAAE,cAAc,EAAE,KAAK,YAAY,EAAE,MAAM,cAAc,CAAA;AAChE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAEhC,YAAY,EAAE,WAAW,EAAE,qBAAqB,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAEpG,OAAO,KAAK,EACV,UAAU,EACV,YAAY,EACZ,YAAY,IAAI,aAAa,EAC7B,OAAO,IAAI,QAAQ,EACnB,WAAW,IAAI,YAAY,EAC5B,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAE7C,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;AACjD,MAAM,MAAM,YAAY,GAAG,aAAa,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;AAC3D,MAAM,MAAM,WAAW,GAAG,YAAY,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;AACzD,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAA"}

node_modules/@tinyhttp/app/dist/index.js

@@ -0,0 +1,7 @@
+export { App } from './app.js';
+export * from './request.js';
+export * from './response.js';
+export { extendMiddleware } from './extend.js';
+export { onErrorHandler } from './onError.js';
+export { View } from './view.js';
+//# sourceMappingURL=index.js.map

node_modules/@tinyhttp/app/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAC9B,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA;AAC7B,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,EAAE,cAAc,EAAqB,MAAM,cAAc,CAAA;AAChE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA"}

node_modules/@tinyhttp/app/dist/onError.d.ts

@@ -0,0 +1,7 @@
+import type { NextFunction } from '@tinyhttp/router';
+import type { App } from './app.js';
+import type { Request } from './request.js';
+import type { Response } from './response.js';
+export type ErrorHandler = (this: App, err: any, req: Request, res: Response, next?: NextFunction) => void;
+export declare const onErrorHandler: ErrorHandler;
+//# sourceMappingURL=onError.d.ts.map

node_modules/@tinyhttp/app/dist/onError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onError.d.ts","sourceRoot":"","sources":["../src/onError.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AACnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAE7C,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,YAAY,KAAK,IAAI,CAAA;AAE1G,eAAO,MAAM,cAAc,EAAE,YAU5B,CAAA"}

node_modules/@tinyhttp/app/dist/onError.js

@@ -0,0 +1,15 @@
+import { STATUS_CODES } from 'node:http';
+export const onErrorHandler = function (err, _req, res) {
+    if (this.onError === onErrorHandler && this.parent)
+        return this.parent.onError(err, _req, res);
+    if (err instanceof Error)
+        console.error(err);
+    const code = err.code in STATUS_CODES ? err.code : err.status;
+    if (typeof err === 'string' || Buffer.isBuffer(err))
+        res.writeHead(500).end(err);
+    else if (code in STATUS_CODES)
+        res.writeHead(code).end(STATUS_CODES[code]);
+    else
+        res.writeHead(500).end(err.message);
+};
+//# sourceMappingURL=onError.js.map

node_modules/@tinyhttp/app/dist/onError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"onError.js","sourceRoot":"","sources":["../src/onError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAQxC,MAAM,CAAC,MAAM,cAAc,GAAiB,UAAqB,GAAQ,EAAE,IAAa,EAAE,GAAa;IACrG,IAAI,IAAI,CAAC,OAAO,KAAK,cAAc,IAAI,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,CAAA;IAE9F,IAAI,GAAG,YAAY,KAAK;QAAE,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;IAE5C,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,IAAI,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAA;IAE7D,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC;QAAE,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;SAC3E,IAAI,IAAI,IAAI,YAAY;QAAE,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAA;;QACrE,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;AAC1C,CAAC,CAAA"}

node_modules/@tinyhttp/app/dist/request.d.ts

@@ -0,0 +1,59 @@
+import type { IncomingHttpHeaders, IncomingMessage } from 'node:http';
+import type { ParsedUrlQuery } from 'node:querystring';
+import { type Trust } from '@tinyhttp/proxy-addr';
+import type { Options, Ranges } from 'header-range-parser';
+import type { Middleware } from '@tinyhttp/router';
+import type { App } from './app.js';
+import type { Socket } from 'node:net';
+import type { TLSSocket } from 'node:tls';
+import type { URLParams } from '@tinyhttp/req';
+export { getURLParams } from '@tinyhttp/req';
+export type Host = {
+    hostname: string;
+    port?: number;
+};
+export declare const getProtocol: (req: Request, trust: Trust) => Protocol;
+export declare const getHost: (req: Request, trust: Trust) => Host | undefined;
+export declare const getIP: (req: Pick<Request, "headers" | "connection" | "socket">, trust: Trust) => string | undefined;
+export declare const getIPs: (req: Pick<Request, "headers" | "connection" | "socket">, trust: Trust) => string[] | undefined;
+export declare const getSubdomains: (req: Request, trust: Trust, subdomainOffset?: number) => string[];
+export type Connection = IncomingMessage['socket'] & {
+    encrypted: boolean;
+};
+export type Protocol = 'http' | 'https' | string;
+export type { URLParams };
+type AcceptsReturns = string | boolean | string[];
+export interface Request extends IncomingMessage {
+    originalUrl: string;
+    path: string;
+    url: string;
+    baseUrl: string;
+    query: ParsedUrlQuery;
+    params: URLParams;
+    connection: Connection;
+    socket: TLSSocket | Socket;
+    route?: Middleware;
+    protocol: Protocol;
+    secure: boolean;
+    xhr: boolean;
+    hostname?: string;
+    port?: number;
+    ip?: string;
+    ips?: string[];
+    subdomains?: string[];
+    get: <HeaderName extends string>(header: HeaderName) => IncomingHttpHeaders[HeaderName];
+    range: (size: number, options?: Options) => -1 | -2 | -3 | Ranges | undefined;
+    accepts: (...types: string[]) => AcceptsReturns;
+    acceptsEncodings: (...encodings: string[]) => AcceptsReturns;
+    acceptsCharsets: (...charsets: string[]) => AcceptsReturns;
+    acceptsLanguages: (...languages: string[]) => AcceptsReturns;
+    is: (...types: string[]) => string | boolean;
+    cookies?: any;
+    signedCookies?: any;
+    secret?: string | string[];
+    fresh?: boolean;
+    stale?: boolean;
+    body?: any;
+    app?: App;
+}
+//# sourceMappingURL=request.d.ts.map

node_modules/@tinyhttp/app/dist/request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../src/request.ts"],"names":[],"mappings":"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"}

node_modules/@tinyhttp/app/dist/request.js

@@ -0,0 +1,85 @@
+import { all, compile, proxyaddr as proxyAddr } from '@tinyhttp/proxy-addr';
+import { isIP } from 'node:net';
+export { getURLParams } from '@tinyhttp/req';
+const trustRemoteAddress = ({ socket }, trust) => {
+    const val = socket.remoteAddress;
+    if (typeof trust !== 'function')
+        trust = compile(trust);
+    return trust(val, 0);
+};
+export const getProtocol = (req, trust) => {
+    const proto = `http${req.secure ? 's' : ''}`;
+    if (!trustRemoteAddress(req, trust))
+        return proto;
+    const header = req.headers['X-Forwarded-Proto'] || proto;
+    const index = header.indexOf(',');
+    return index !== -1 ? header.substring(0, index).trim() : header.trim();
+};
+const normalizeHostString = (host) => decodeURIComponent(host).toLowerCase().normalize();
+const getAuthorityHeaderHostString = (req) => {
+    const authority = req.get(':authority');
+    if (Array.isArray(authority))
+        return undefined;
+    if (Array.isArray(authority) || !authority)
+        return undefined;
+    const index = authority.indexOf('@');
+    if (index === -1)
+        return normalizeHostString(authority);
+    return normalizeHostString(authority.substring(index + 1));
+};
+const getForwardedHeaderHostString = (req) => {
+    const forwardedHost = req.get('x-forwarded-host');
+    if (Array.isArray(forwardedHost))
+        return undefined;
+    if (!forwardedHost)
+        return undefined;
+    return normalizeHostString(forwardedHost);
+};
+const getDefaultHeaderHostString = (req) => {
+    const host = req.get('host');
+    if (!host || host.indexOf(',') !== -1)
+        return undefined;
+    if (host.indexOf(',') !== -1)
+        return undefined;
+    return normalizeHostString(host);
+};
+const getHostString = (req, trust) => {
+    var _a;
+    if (trustRemoteAddress(req, trust)) {
+        const forwardedHost = getForwardedHeaderHostString(req);
+        if (forwardedHost)
+            return forwardedHost;
+    }
+    const authorityHost = getAuthorityHeaderHostString(req);
+    const defaultHost = getDefaultHeaderHostString(req);
+    if (authorityHost && defaultHost) {
+        if (authorityHost !== defaultHost)
+            throw new Error('Request `:authority` pseudo-header does not agree with `Host` header');
+        return authorityHost;
+    }
+    return (_a = authorityHost !== null && authorityHost !== void 0 ? authorityHost : defaultHost) !== null && _a !== void 0 ? _a : undefined;
+};
+export const getHost = (req, trust) => {
+    const host = getHostString(req, trust);
+    if (!host)
+        return undefined;
+    // IPv6 literal support
+    const index = host.indexOf(':', host[0] === '[' ? host.indexOf(']') + 1 : 0);
+    if (index === -1)
+        return { hostname: host };
+    const hostname = host.substring(0, index);
+    const port = Number(host.substring(index + 1));
+    if (Number.isNaN(port))
+        throw new TypeError('Port number is NaN, therefore Host is malformed');
+    return { hostname, port };
+};
+export const getIP = (req, trust) => proxyAddr(req, trust).replace(/^.*:/, ''); // striping the redundant prefix addeded by OS to IPv4 address
+export const getIPs = (req, trust) => all(req, trust);
+export const getSubdomains = (req, trust, subdomainOffset = 2) => {
+    const host = getHost(req, trust);
+    if (!(host === null || host === void 0 ? void 0 : host.hostname))
+        return [];
+    const subdomains = isIP(host.hostname) ? [host.hostname] : host.hostname.split('.').reverse();
+    return subdomains.slice(subdomainOffset);
+};
+//# sourceMappingURL=request.js.map

node_modules/@tinyhttp/app/dist/request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.js","sourceRoot":"","sources":["../src/request.ts"],"names":[],"mappings":"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"}

node_modules/@tinyhttp/app/dist/response.d.ts

@@ -0,0 +1,44 @@
+import type { OutgoingHttpHeaders, ServerResponse } from 'node:http';
+import type { SerializeOptions } from '@tinyhttp/cookie';
+import type { DownloadOptions, FormatProps, SendFileOptions } from '@tinyhttp/res';
+import type { App } from './app.js';
+import type { Request } from './request.js';
+import type { AppRenderOptions, TemplateEngineOptions } from './types.js';
+export declare const renderTemplate: <O extends TemplateEngineOptions = TemplateEngineOptions>(_req: Request, res: Response, app: App) => (file: string, data?: Record<string, unknown>, options?: AppRenderOptions<O>) => Response;
+export interface Response<B = unknown> extends ServerResponse {
+    header(field: string | Record<string, unknown>, val?: string | any[]): Response<B>;
+    set(field: string | Record<string, unknown>, val?: string | any[]): Response<B>;
+    get<HeaderName extends string>(field: HeaderName): OutgoingHttpHeaders[HeaderName];
+    send(body: B): Response<B>;
+    sendFile(path: string, options?: SendFileOptions, cb?: (err?: unknown) => void): Response<B>;
+    json(body: B): Response<B>;
+    status(status: number): Response<B>;
+    sendStatus(statusCode: number): Response<B>;
+    cookie(name: string, value: string | Record<string, unknown>, options?: SerializeOptions & Partial<{
+        signed: boolean;
+    }>): Response<B>;
+    clearCookie(name: string, options?: SerializeOptions): Response<B>;
+    location(url: string): Response<B>;
+    links(links: {
+        [key: string]: string;
+    }): Response<B>;
+    render<O extends TemplateEngineOptions = TemplateEngineOptions>(file: string, data?: Record<string, any>, options?: AppRenderOptions<O>): Response<B>;
+    vary(field: string): Response<B>;
+    format(obj: FormatProps): Response<B>;
+    redirect(url: string, status?: number): Response<B>;
+    type(type: string): Response<B>;
+    download(path: string, filename: string, options?: DownloadOptions, cb?: (err?: unknown) => void): Response<B>;
+    attachment(filename?: string): Response<B>;
+    app?: App;
+    locals: Record<string, any>;
+    /**
+     * Send JSON response with JSONP callback support.
+     *
+     * To enable this method, install the `@tinyhttp/jsonp` package and attach the method to `res.jsonp` property.
+     *
+     * @param obj Response object
+     */
+    jsonp(obj: any): Response<B>;
+    append(field: string, value: any): Response<B>;
+}
+//# sourceMappingURL=response.d.ts.map

node_modules/@tinyhttp/app/dist/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../src/response.ts"],"names":[],"mappings":"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"}

node_modules/@tinyhttp/app/dist/response.js

@@ -0,0 +1,9 @@
+export const renderTemplate = (_req, res, app) => (file, data, options) => {
+    app.render(file, data ? { ...res.locals, ...data } : res.locals, options, (err, html) => {
+        if (err)
+            throw err;
+        res.send(html);
+    });
+    return res;
+};
+//# sourceMappingURL=response.js.map

node_modules/@tinyhttp/app/dist/response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.js","sourceRoot":"","sources":["../src/response.ts"],"names":[],"mappings":"AAOA,MAAM,CAAC,MAAM,cAAc,GACzB,CAA0D,IAAa,EAAE,GAAa,EAAE,GAAQ,EAAE,EAAE,CACpG,CAAC,IAAY,EAAE,IAA8B,EAAE,OAA6B,EAAY,EAAE;IACxF,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,GAAY,EAAE,IAAa,EAAE,EAAE;QACxG,IAAI,GAAG;YAAE,MAAM,GAAG,CAAA;QAClB,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAChB,CAAC,CAAC,CAAA;IACF,OAAO,GAAG,CAAA;AACZ,CAAC,CAAA"}

node_modules/@tinyhttp/app/dist/types.d.ts

@@ -0,0 +1,108 @@
+import type { Server } from 'node:http';
+import type { Trust } from '@tinyhttp/proxy-addr';
+import type { Handler, NextFunction, RouterInterface, UseMethodParams } from '@tinyhttp/router';
+import type { ErrorHandler } from './onError.js';
+import type { Request } from './request.js';
+import type { Response } from './response.js';
+import type { View } from './view.js';
+/**
+ * tinyhttp App has a few settings for toggling features
+ */
+export type AppSettings = Partial<{
+    networkExtensions: boolean;
+    subdomainOffset: number;
+    bindAppToReqRes: boolean;
+    xPoweredBy: string | boolean;
+    enableReqRoute: boolean;
+    views: string | string[];
+    view: typeof View;
+    'view cache': boolean;
+    'view engine': string;
+    'trust proxy': Trust;
+}>;
+export type TemplateEngineOptions = {
+    [key: string]: unknown;
+    cache?: boolean;
+};
+/**
+ * Function that processes the template
+ */
+export type TemplateEngine<O extends TemplateEngineOptions = TemplateEngineOptions> = (path: string, locals: Record<string, unknown>, opts: AppRenderOptions<O>, cb: (err: Error | null, html: unknown) => void) => void;
+export type AppRenderOptions<O extends TemplateEngineOptions = TemplateEngineOptions> = O & Partial<{
+    cache: boolean;
+    ext: string;
+    viewsFolder: string;
+    _locals: Record<string, unknown>;
+}>;
+export type AppConstructor<Req extends Request = Request, Res extends Response = Response> = Partial<{
+    noMatchHandler: Handler<Req, Res>;
+    onError: ErrorHandler;
+    settings: AppSettings;
+    applyExtensions: Handler<Req, Res>;
+    new (options: AppConstructor<Req, Res>): AppInterface<Req, Res>;
+}>;
+export interface AppInterface<Req extends Request, Res extends Response> extends RouterInterface<AppInterface<Req, Res>, Req, Res> {
+    /**
+     * Set app setting
+     * @param setting setting name
+     * @param value setting value
+     */
+    set<K extends keyof AppSettings>(setting: K, value: AppSettings[K]): AppInterface<Req, Res>;
+    /**
+     * Enable app setting
+     * @param setting Setting name
+     */
+    enable<K extends keyof AppSettings>(setting: K): AppInterface<Req, Res>;
+    /**
+     * Check if setting is enabled
+     * @param setting Setting name
+     * @returns
+     */
+    enabled<K extends keyof AppSettings>(setting: K): boolean;
+    /**
+     * Disable app setting
+     * @param setting Setting name
+     */
+    disable<K extends keyof AppSettings>(setting: K): AppInterface<Req, Res>;
+    /**
+     * Return the app's absolute pathname
+     * based on the parent(s) that have
+     * mounted it.
+     *
+     * For example if the application was
+     * mounted as `"/admin"`, which itself
+     * was mounted as `"/blog"` then the
+     * return value would be `"/blog/admin"`.
+     *
+     */
+    path(): string;
+    /**
+     * Register a template engine with extension
+     */
+    engine<RenderOptions extends TemplateEngineOptions = TemplateEngineOptions>(ext: string, fn: TemplateEngine<RenderOptions>): AppInterface<Req, Res>;
+    /**
+     * Render a template
+     * @param name What to render
+     * @param data data that is passed to a template
+     * @param options Template engine options
+     * @param cb Callback that consumes error and html
+     */
+    render<RenderOptions extends TemplateEngineOptions = TemplateEngineOptions>(name: string, data: Record<string, unknown>, options: AppRenderOptions<RenderOptions>, cb: (err: unknown, html?: unknown) => void): void;
+    use(...args: UseMethodParams<Req, Res, AppInterface<any, any>>): AppInterface<Req, Res>;
+    route(path: string): AppInterface<Req, Res>;
+    /**
+     * Extends Req / Res objects, pushes 404 and 500 handlers, dispatches middleware
+     * @param req Req object
+     * @param res Res object
+     * @param next 'Next' function
+     */
+    handler(req: Req, res: Res, next?: NextFunction): void;
+    /**
+     * Creates HTTP server and dispatches middleware
+     * @param port server listening port
+     * @param cb callback to be invoked after server starts listening
+     * @param host server listening host
+     */
+    listen(port?: number, cb?: () => void, host?: string): Server;
+}
+//# sourceMappingURL=types.d.ts.map

node_modules/@tinyhttp/app/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

node_modules/@tinyhttp/app/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

node_modules/@tinyhttp/app/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

node_modules/@tinyhttp/app/dist/view.d.ts

@@ -0,0 +1,38 @@
+/*!
+ * Ported from https://github.com/expressjs/express/blob/master/lib/view.js
+ * express
+ * Copyright(c) 2009-2013 TJ Holowaychuk
+ * Copyright(c) 2013 Roman Shtylman
+ * Copyright(c) 2014-2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+import type { TemplateEngine, TemplateEngineOptions } from './types.js';
+/**
+ * Initialize a new `View` with the given `name`.
+ *
+ * Options:
+ *
+ *   - `defaultEngine` the default template engine name
+ *   - `engines` template engine require() cache
+ *   - `root` root path for view lookup
+ *
+ * @param name
+ * @param options
+ * @public
+ */
+export declare class View<RenderOptions extends TemplateEngineOptions = TemplateEngineOptions> {
+    #private;
+    ext?: string;
+    defaultEngine?: string;
+    name: string;
+    engine: TemplateEngine<RenderOptions>;
+    path: string;
+    root: string | string[];
+    constructor(name: string, opts?: Partial<{
+        defaultEngine: string;
+        root: string | string[];
+        engines: Record<string, TemplateEngine<RenderOptions>>;
+    }>);
+    render(options: RenderOptions, data: Record<string, unknown>, cb: (err: Error | null, html: unknown) => void): void;
+}
+//# sourceMappingURL=view.d.ts.map