@tyno/tyno 2.1.3

package/src/index.ts

@@ -0,0 +1,29 @@
+export { Application as Tyno } from './application.ts';
+export { Request, Request as req } from './request/index.ts';
+export { BodyParser, MultipartParser } from './request/index.ts';
+export type { UploadedFile, MultipartResult } from './request/index.ts';
+export { Response, Response as response, Response as res } from './response.ts';
+export { SSEStream } from './response/sse.ts';
+export { compose, normalizeResponse } from './compose.ts';
+export { requestStore } from './context.ts';
+export { default as request } from './request-global.ts';
+export { cache as Cache, cache } from './cache-facade.ts';
+export { Router } from './router/index.ts';
+export type { RouterOptions } from './router/index.ts';
+export { AppError, HttpError, createError, BadRequest, Unauthorized, Forbidden, NotFound, Conflict, PayloadTooLarge, TooManyRequests, InternalServerError, RuntimeError, isRuntimeError } from './errors/index.ts';
+export type { AppErrorOptions } from './errors/index.ts';
+export { cors } from './middlewares/cors.ts';
+export type { CorsOptions } from './middlewares/cors.ts';
+export { serveStatic } from './middlewares/static.ts';
+export type { StaticOptions } from './middlewares/static.ts';
+export { compress } from './middlewares/compress.ts';
+export type { CompressOptions } from './middlewares/compress.ts';
+export { requestId } from './middlewares/request-id.ts';
+export type { RequestIdOptions } from './middlewares/request-id.ts';
+export { CacheManager } from './cache/index.ts';
+export { MemoryDriver, FileDriver, RedisDriver } from './cache/index.ts';
+export type { CacheDriver, CacheConfig } from './cache/types.ts';
+export { lookupMime, MIME_TYPES } from './mime.ts';
+export { asErrorMiddleware } from './compose.ts';
+export { IS_ERROR_MIDDLEWARE } from './types.ts';
+export type { AnyMiddleware, Middleware, TerminalMiddleware, ErrorMiddleware, NextFunction, TynoRequest, ResponseBody, Headers, CookieOptions, BodyOptions, BodyParserConfig, ListenOptions, InjectOptions, InjectResult, ApplicationOptions, InitializerFn } from './types.ts';

package/src/middlewares/compress.ts

@@ -0,0 +1,101 @@
+import zlib from 'node:zlib';
+import { Transform } from 'node:stream';
+import { Response } from '../response.ts';
+import type { Middleware, TynoRequest, NextFunction } from '../types.ts';
+
+export interface CompressOptions {
+    /** 最小压缩字节数，低于此阈值不压缩（默认 1024） */
+    threshold?: number;
+    /** 压缩级别 1-9，默认 Z_DEFAULT_COMPRESSION */
+    level?: number;
+    /** 自定义过滤：返回 true 表示需要压缩 */
+    filter?: (contentType: string) => boolean;
+}
+
+// 默认不压缩的类型（已压缩或二进制格式）
+const defaultNoCompress = /^(?:image|video|audio|font|application\/(?:zip|gzip|tar|wasm|octet-stream))/;
+
+/** 异步 gzip 压缩 */
+function gzipAsync(buf: Buffer, level: number): Promise<Buffer> {
+    return new Promise((resolve, reject) => {
+        zlib.gzip(buf, { level }, (err, result) => err ? reject(err) : resolve(result));
+    });
+}
+
+/** 异步 deflate 压缩 */
+function deflateAsync(buf: Buffer, level: number): Promise<Buffer> {
+    return new Promise((resolve, reject) => {
+        zlib.deflate(buf, { level }, (err, result) => err ? reject(err) : resolve(result));
+    });
+}
+
+/**
+ * 响应压缩中间件，根据 Accept-Encoding 自动选择 gzip/deflate 压缩。
+ * 支持普通响应（异步压缩）和流式响应（Transform 流包装）。
+ *
+ * @example
+ * app.use(compress());                          // 默认配置
+ * app.use(compress({ threshold: 2048 }));       // 自定义阈值
+ */
+export function compress(options: CompressOptions = {}): Middleware {
+    const threshold = options.threshold ?? 1024;
+    const level = options.level ?? zlib.constants.Z_DEFAULT_COMPRESSION;
+
+    return async (req: TynoRequest, next: NextFunction): Promise<unknown> => {
+        const res = await next();
+
+        if (!(res instanceof Response)) return res;
+
+        // 检查客户端是否支持压缩
+        const acceptEncoding = (req.header('accept-encoding') || '').toLowerCase();
+        const useGzip = acceptEncoding.includes('gzip');
+        const useDeflate = !useGzip && acceptEncoding.includes('deflate');
+        if (!useGzip && !useDeflate) return res;
+
+        // 检查是否需要压缩（通过 Content-Type 过滤）
+        const contentType = res.get('Content-Type') || '';
+        const shouldCompress = options.filter
+            ? options.filter(contentType)
+            : !defaultNoCompress.test(contentType);
+        if (!shouldCompress) return res;
+
+        const encoding = useGzip ? 'gzip' : 'deflate';
+        const body = res.body;
+
+        // 流式响应：用 Transform 流包装
+        if (body != null && typeof (body as NodeJS.ReadableStream).pipe === 'function') {
+            const transform = useGzip
+                ? zlib.createGzip({ level })
+                : zlib.createDeflate({ level });
+            res.body = (body as NodeJS.ReadableStream).pipe(transform);
+            res.set('Content-Encoding', encoding);
+            res.headers['Transfer-Encoding'] = 'chunked';
+            delete res.headers['Content-Length'];
+            addVary(res);
+            return res;
+        }
+
+        // 普通响应：异步压缩
+        if (body == null) return res;
+        const raw = Buffer.isBuffer(body) ? body : Buffer.from(String(body));
+        if (raw.length < threshold) return res;
+
+        const compressed = useGzip
+            ? await gzipAsync(raw, level)
+            : await deflateAsync(raw, level);
+
+        res.set('Content-Encoding', encoding);
+        res.set('Content-Length', compressed.length);
+        res.body = compressed;
+        addVary(res);
+
+        return res;
+    };
+}
+
+function addVary(res: Response): void {
+    const vary = res.get('Vary') || '';
+    if (!vary.includes('Accept-Encoding')) {
+        res.set('Vary', vary ? `${vary}, Accept-Encoding` : 'Accept-Encoding');
+    }
+}

package/src/middlewares/cors.ts

@@ -0,0 +1,57 @@
+import { Response } from '../response.ts';
+import type { TynoRequest, NextFunction, Middleware } from '../types.ts';
+
+export interface CorsOptions {
+    origin?: string | string[] | ((origin: string | undefined) => string);
+    allowMethods?: string[];
+    allowHeaders?: string[];
+    exposeHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number | null;
+}
+
+export function cors(options: CorsOptions = {}): Middleware {
+    const {
+        origin = '*',
+        allowMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
+        allowHeaders = [],
+        exposeHeaders = [],
+        credentials = false,
+        maxAge = null
+    } = options;
+
+    const allowMethodsStr = allowMethods.join(', ');
+    const allowHeadersStr = allowHeaders.join(', ');
+    const exposeHeadersStr = exposeHeaders.join(', ');
+
+    function resolveOrigin(requestOrigin: string | undefined): string {
+        if (origin === '*') return credentials ? (requestOrigin || '*') : '*';
+        if (typeof origin === 'function') return origin(requestOrigin);
+        if (Array.isArray(origin)) return origin.includes(requestOrigin || '') ? (requestOrigin || '') : '';
+        return origin === requestOrigin ? (requestOrigin || '') : '';
+    }
+
+    return async (req: TynoRequest, next: NextFunction): Promise<unknown> => {
+        const requestOrigin = req.header('origin') as string | undefined;
+        const originValue = resolveOrigin(requestOrigin);
+
+        if (req.method === 'OPTIONS') {
+            const headers: Record<string, string> = {};
+            if (originValue) headers['Access-Control-Allow-Origin'] = originValue;
+            headers['Access-Control-Allow-Methods'] = allowMethodsStr;
+            if (allowHeadersStr) headers['Access-Control-Allow-Headers'] = allowHeadersStr;
+            if (exposeHeadersStr) headers['Access-Control-Expose-Headers'] = exposeHeadersStr;
+            if (credentials) headers['Access-Control-Allow-Credentials'] = 'true';
+            if (maxAge != null) headers['Access-Control-Max-Age'] = String(maxAge);
+            return new Response(204, headers, null);
+        }
+
+        const res = await next();
+        if (res instanceof Response) {
+            if (originValue) res.headers['Access-Control-Allow-Origin'] = originValue;
+            if (credentials) res.headers['Access-Control-Allow-Credentials'] = 'true';
+            if (exposeHeadersStr) res.headers['Access-Control-Expose-Headers'] = exposeHeadersStr;
+        }
+        return res;
+    };
+}

package/src/middlewares/error-page.ts

@@ -0,0 +1,89 @@
+import { Response } from '../response.ts';
+import { AppError } from '../errors/index.ts';
+import type { TynoRequest, NextFunction, ErrorMiddleware } from '../types.ts';
+
+export interface ErrorPageOptions {
+    dev?: boolean;
+    json?: boolean;
+}
+
+/**
+ * 创建错误页处理函数（供 Application debug 模式内部使用）。
+ * 开发环境下返回包含错误堆栈的格式化页面，生产环境仅返回简洁错误信息。
+ */
+export function createErrorPageHandler(options: ErrorPageOptions = {}): ErrorMiddleware {
+    const isDev = options.dev ?? process.env.NODE_ENV !== 'production';
+
+    return async (err: unknown, req: TynoRequest, _next: NextFunction): Promise<unknown> => {
+        const e = err as Record<string, unknown>;
+        const status = (e.status as number) || 500;
+        const isAppError = err instanceof AppError;
+        const shouldExpose = isAppError ? (err as AppError).expose : false;
+
+        const accept = (req.header('accept') || '').toLowerCase();
+        const wantsJson = options.json ?? !accept.includes('text/html');
+
+        if (wantsJson) {
+            const body: Record<string, unknown> = {
+                error: (isDev || shouldExpose) ? (e.message as string || 'Internal Server Error') : 'Internal Server Error',
+                status
+            };
+            if (isDev) {
+                body.stack = e.stack;
+                body.name = e.name;
+                if (isAppError && (err as AppError).code != null) body.code = (err as AppError).code;
+                if (e.cause) body.cause = (e.cause as Error).message;
+            } else if (isAppError && (err as AppError).code != null) {
+                body.code = (err as AppError).code;
+            }
+            return Response.json(body, status);
+        }
+
+        const message = (isDev || shouldExpose) ? (e.message as string || 'Internal Server Error') : 'Internal Server Error';
+        const stackHtml = isDev && e.stack
+            ? `<div class="stack"><h3>Stack Trace</h3><pre>${escapeHtml(String(e.stack))}</pre></div>` : '';
+        const causeHtml = isDev && e.cause
+            ? `<div class="cause"><h3>Caused By</h3><pre>${escapeHtml((e.cause as Error).message)}</pre></div>` : '';
+        const codeInfo = isAppError && (err as AppError).code != null ? ` [${(err as AppError).code}]` : '';
+
+        const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>${status} ${escapeHtml(message)}</title>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, monospace; background: #1a1a2e; color: #e0e0e0; padding: 40px; }
+  .container { max-width: 900px; margin: 0 auto; }
+  .status { font-size: 72px; font-weight: 700; color: ${status < 500 ? '#f0ad4e' : '#e74c3c'}; }
+  .message { font-size: 24px; margin: 10px 0 30px; color: #ccc; }
+  .stack pre, .cause pre { background: #0d1117; border: 1px solid #30363d; border-radius: 6px; padding: 16px; overflow-x: auto; font-size: 13px; line-height: 1.6; color: #f8f8f2; }
+  .meta { display: flex; gap: 20px; flex-wrap: wrap; margin: 20px 0; }
+  .meta-item { background: #16213e; padding: 10px 16px; border-radius: 6px; font-size: 14px; }
+  .meta-label { color: #7f8c8d; font-size: 12px; text-transform: uppercase; }
+  .meta-value { color: #e0e0e0; font-weight: 600; }
+</style>
+</head>
+<body>
+<div class="container">
+  <div class="status">${status}</div>
+  <div class="message">${escapeHtml(message)}${codeInfo}</div>
+  <div class="meta">
+    <div class="meta-item"><div class="meta-label">Method</div><div class="meta-value">${escapeHtml(req.method || '')}</div></div>
+    <div class="meta-item"><div class="meta-label">Path</div><div class="meta-value">${escapeHtml(req.path || '')}</div></div>
+    ${req.requestId ? `<div class="meta-item"><div class="meta-label">Request ID</div><div class="meta-value">${escapeHtml(String(req.requestId))}</div></div>` : ''}
+  </div>
+  ${stackHtml}
+  ${causeHtml}
+</div>
+</body>
+</html>`;
+
+        return new Response(status, { 'Content-Type': 'text/html; charset=utf-8' }, html);
+    };
+}
+
+function escapeHtml(s: string): string {
+    return String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;');
+}

package/src/middlewares/index.ts

@@ -0,0 +1,9 @@
+// 内置中间件导出
+export { cors } from './cors.ts';
+export type { CorsOptions } from './cors.ts';
+export { serveStatic } from './static.ts';
+export type { StaticOptions } from './static.ts';
+export { compress } from './compress.ts';
+export type { CompressOptions } from './compress.ts';
+export { requestId } from './request-id.ts';
+export type { RequestIdOptions } from './request-id.ts';

package/src/middlewares/request-id.ts

@@ -0,0 +1,47 @@
+import crypto from 'node:crypto';
+import { Response } from '../response.ts';
+import type { TynoRequest, NextFunction, Middleware } from '../types.ts';
+
+export interface RequestIdOptions {
+    /** 响应头名称，默认 X-Request-Id */
+    header?: string;
+    /** 是否从请求头读取已有 ID（默认 true） */
+    readFromHeader?: boolean;
+    /** 请求头名称（默认同 header） */
+    requestHeader?: string;
+}
+
+/**
+ * 请求 ID 中间件。
+ * 自动为每个请求生成唯一 ID（UUID v4），或从请求头读取已有 ID。
+ * ID 会注入到 req.requestId 并写入响应头，贯穿全链路日志。
+ */
+export function requestId(options: RequestIdOptions = {}): Middleware {
+    const headerName = options.header || 'X-Request-Id';
+    const readFromHeader = options.readFromHeader !== false;
+    const requestHeader = options.requestHeader || headerName.toLowerCase();
+
+    return async (req: TynoRequest, next: NextFunction): Promise<unknown> => {
+        let id: string;
+
+        if (readFromHeader) {
+            const existing = req.header(requestHeader);
+            id = existing || crypto.randomUUID();
+        } else {
+            id = crypto.randomUUID();
+        }
+
+        // 注入到请求上下文
+        req.requestId = id;
+
+        // 执行下游
+        const res = await next();
+
+        // 写入响应头
+        if (res instanceof Response) {
+            res.headers[headerName] = id;
+        }
+
+        return res;
+    };
+}

package/src/middlewares/static.ts

@@ -0,0 +1,138 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { Response } from '../response.ts';
+import { HttpError } from '../errors/index.ts';
+import { lookupMime } from '../mime.ts';
+import type { TynoRequest, NextFunction, Middleware } from '../types.ts';
+
+export interface StaticOptions {
+    prefix?: string;
+    index?: string;
+    maxAge?: number;
+    etag?: boolean;
+}
+
+export function serveStatic(rootDir: string, options: StaticOptions = {}): Middleware {
+    const root = path.resolve(rootDir);
+    const prefix = options.prefix || '';
+    const indexFile = options.index ?? 'index.html';
+    const maxAge = options.maxAge ?? 0;
+    const enableEtag = options.etag !== false;
+
+    return async (req: TynoRequest, next: NextFunction): Promise<unknown> => {
+        if (req.method !== 'GET' && req.method !== 'HEAD') return next();
+
+        let urlPath: string = req.path;
+        if (prefix) {
+            if (!urlPath.startsWith(prefix)) return next();
+            urlPath = urlPath.slice(prefix.length) || '/';
+        }
+
+        let relPath: string;
+        try { relPath = decodeURIComponent(urlPath); } catch { return next(); }
+        const filePath = path.normalize(path.join(root, relPath));
+        if (!filePath.startsWith(root)) throw new HttpError(403, 'Forbidden');
+
+        let stat: fs.Stats;
+        try {
+            stat = await fs.promises.stat(filePath);
+        } catch (e: unknown) {
+            const err = e as NodeJS.ErrnoException;
+            if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return next();
+            throw e;
+        }
+
+        if (stat.isDirectory()) {
+            const indexFilePath = path.join(filePath, indexFile);
+            try {
+                stat = await fs.promises.stat(indexFilePath);
+                return buildFileResponse(indexFilePath, stat, req, maxAge, enableEtag);
+            } catch { return next(); }
+        }
+
+        return buildFileResponse(filePath, stat, req, maxAge, enableEtag);
+    };
+}
+
+function buildFileResponse(filePath: string, stat: fs.Stats, req: TynoRequest, maxAge: number, enableEtag: boolean): Response {
+    const ext = path.extname(filePath).slice(1);
+    const type = lookupMime(ext);
+    const etag = enableEtag ? `"${stat.size.toString(16)}-${stat.mtimeMs.toString(16)}"` : null;
+
+    // Range 请求处理
+    const rangeHeader = req.header('range');
+    if (rangeHeader && stat.size > 0) {
+        return buildRangeResponse(filePath, stat, type, etag, rangeHeader);
+    }
+
+    // 条件请求 304
+    if (etag && req.header('if-none-match') === etag) {
+        return new Response(304, {}, null);
+    }
+
+    const headers: Record<string, string | number> = {
+        'Content-Type': type,
+        'Content-Length': stat.size,
+        'Cache-Control': `public, max-age=${maxAge}`,
+        'Last-Modified': stat.mtime.toUTCString(),
+        'Accept-Ranges': 'bytes'
+    };
+    if (etag) headers['ETag'] = etag;
+
+    const body = req.method === 'HEAD' ? null : fs.createReadStream(filePath);
+    return new Response(200, headers, body);
+}
+
+/**
+ * 处理 Range 请求，返回 206 Partial Content。
+ * 支持格式：
+ *   bytes=start-end   — 指定范围
+ *   bytes=start-      — 从 start 到末尾
+ *   bytes=-suffix     — 最后 suffix 个字节
+ */
+function buildRangeResponse(filePath: string, stat: fs.Stats, type: string, etag: string | null, rangeHeader: string): Response {
+    const total = stat.size;
+    const match = rangeHeader.match(/bytes=(\d*)-(\d*)/i);
+
+    if (!match) {
+        // 非法 Range，返回 416
+        return new Response(416, {
+            'Content-Type': type,
+            'Content-Range': `bytes */${total}`
+        }, 'Range Not Satisfiable');
+    }
+
+    let start: number;
+    let end: number;
+
+    if (match[1] === '' && match[2] !== '') {
+        // bytes=-suffix → 最后 suffix 字节
+        const suffix = parseInt(match[2], 10);
+        start = Math.max(0, total - suffix);
+        end = total - 1;
+    } else {
+        start = match[1] ? parseInt(match[1], 10) : 0;
+        end = match[2] ? Math.min(parseInt(match[2], 10), total - 1) : total - 1;
+    }
+
+    if (start > end || start >= total) {
+        return new Response(416, {
+            'Content-Type': type,
+            'Content-Range': `bytes */${total}`
+        }, 'Range Not Satisfiable');
+    }
+
+    const length = end - start + 1;
+    const headers: Record<string, string | number> = {
+        'Content-Type': type,
+        'Content-Length': length,
+        'Content-Range': `bytes ${start}-${end}/${total}`,
+        'Cache-Control': 'public, max-age=3600',
+        'Accept-Ranges': 'bytes'
+    };
+    if (etag) headers['ETag'] = etag;
+
+    const body = fs.createReadStream(filePath, { start, end });
+    return new Response(206, headers, body);
+}
+

package/src/mime.ts

@@ -0,0 +1,38 @@
+/** 常见 MIME 类型映射 */
+export const MIME_TYPES: Record<string, string> = {
+    html: 'text/html; charset=utf-8',
+    htm: 'text/html; charset=utf-8',
+    css: 'text/css; charset=utf-8',
+    js: 'application/javascript; charset=utf-8',
+    mjs: 'application/javascript; charset=utf-8',
+    json: 'application/json; charset=utf-8',
+    txt: 'text/plain; charset=utf-8',
+    xml: 'application/xml; charset=utf-8',
+    svg: 'image/svg+xml',
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    webp: 'image/webp',
+    ico: 'image/x-icon',
+    bmp: 'image/bmp',
+    pdf: 'application/pdf',
+    zip: 'application/zip',
+    gz: 'application/gzip',
+    tar: 'application/x-tar',
+    mp3: 'audio/mpeg',
+    mp4: 'video/mp4',
+    webm: 'video/webm',
+    woff: 'font/woff',
+    woff2: 'font/woff2',
+    ttf: 'font/ttf',
+    otf: 'font/otf',
+    csv: 'text/csv; charset=utf-8',
+    md: 'text/markdown; charset=utf-8',
+    wasm: 'application/wasm'
+};
+
+/** 根据扩展名获取 MIME 类型，未知则返回 application/octet-stream */
+export function lookupMime(ext: string): string {
+    return MIME_TYPES[ext.toLowerCase()] || 'application/octet-stream';
+}

package/src/request/body-parser.ts

@@ -0,0 +1,61 @@
+import type { IncomingMessage } from 'node:http';
+import { HttpError } from '../errors/index.ts';
+import type { BodyParserConfig } from '../types.ts';
+
+/** 将 '1mb' / '1024' 等字符串解析为字节数 */
+export function parseLimit(s: number | string): number {
+    if (typeof s === 'number') return s;
+    const m = /^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/i.exec(s);
+    if (!m) return 1024 * 1024;
+    const n = parseFloat(m[1]);
+    const unit = (m[2] || '').toLowerCase();
+    const mult = unit === 'b' ? 1 : unit === 'kb' ? 1024 : unit === 'mb' ? 1024 * 1024 : unit === 'gb' ? 1024 * 1024 * 1024 : 1;
+    return Math.floor(n * mult);
+}
+
+/**
+ * 读取原始请求体到 Buffer，带大小限制。
+ * 超限时立即销毁连接（不再接收数据），抛出 413 错误。
+ */
+export async function readRawBody(req: IncomingMessage, limit: number): Promise<Buffer> {
+    const chunks: Buffer[] = [];
+    let size = 0;
+    for await (const rawChunk of req as AsyncIterable<Buffer>) {
+        const chunk = Buffer.isBuffer(rawChunk) ? rawChunk : Buffer.from(rawChunk as string | Buffer);
+        size += chunk.length;
+        if (size > limit) {
+            req.destroy();  // 立即终止连接，不再接收后续数据
+            throw new HttpError(413, 'Payload Too Large');
+        }
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+}
+
+/**
+ * BodyParser：解析 JSON / URL-encoded / 文本请求体。
+ */
+export class BodyParser {
+    private limit: number;
+
+    constructor(config: BodyParserConfig = {}) {
+        this.limit = parseLimit(config.limit ?? '1mb');
+    }
+
+    /**
+     * 解析请求体，根据 Content-Type 自动选择解析方式。
+     */
+    async parse(req: IncomingMessage): Promise<unknown> {
+        const contentType = ((req.headers['content-type'] as string) || '').toLowerCase();
+        const raw = await readRawBody(req, this.limit);
+
+        if (contentType.includes('application/json')) {
+            try { return JSON.parse(raw.toString()); }
+            catch { return raw.toString(); }
+        }
+        if (contentType.includes('application/x-www-form-urlencoded')) {
+            return Object.fromEntries(new URLSearchParams(raw.toString()));
+        }
+        return raw.toString();
+    }
+}