@gravito/core 1.6.1 → 2.0.0

package/dist/adapters/bun/BunRequest.d.ts

@@ -0,0 +1,31 @@
+import type { GravitoRequest, ValidationTarget } from '../../http/types';
+/**
+ * Bun-optimized implementation of GravitoRequest.
+ * @internal
+ */
+export declare class BunRequest implements GravitoRequest {
+    readonly raw: Request;
+    private _url;
+    private _params;
+    private _query;
+    private _validated;
+    constructor(raw: Request, params?: Record<string, string>);
+    setParams(params: Record<string, string>): void;
+    get url(): string;
+    get method(): string;
+    get path(): string;
+    param(name: string): string | undefined;
+    params(): Record<string, string>;
+    query(name: string): string | undefined;
+    queries(): Record<string, string | string[]>;
+    header(name: string): string | undefined;
+    header(): Record<string, string>;
+    json<T = unknown>(): Promise<T>;
+    text(): Promise<string>;
+    formData(): Promise<FormData>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    parseBody<T = unknown>(): Promise<T>;
+    setValidated(target: ValidationTarget, data: unknown): void;
+    valid<T = unknown>(target: ValidationTarget): T;
+    private parseQuery;
+}

package/dist/adapters/bun/BunWebSocketHandler.d.ts

@@ -0,0 +1,48 @@
+/**
+ * WebSocket 路由管理器
+ *
+ * 負責註冊和分發 WebSocket 事件到相應的路由處理器
+ */
+export interface WebSocketRouteHandlers {
+    open?: (ws: unknown) => void | Promise<void>;
+    message?: (ws: unknown, data: string | Buffer | Uint8Array) => void | Promise<void>;
+    close?: (ws: unknown, code: number, reason: string) => void | Promise<void>;
+    drain?: (ws: unknown) => void | Promise<void>;
+}
+export declare class BunWebSocketHandler {
+    private routes;
+    /**
+     * 註冊 WebSocket 路由
+     */
+    register(path: string, handlers: WebSocketRouteHandlers): void;
+    /**
+     * 檢查是否有該路由
+     * 支援精確匹配和 wildcard 匹配
+     */
+    hasRoute(path: string): boolean;
+    /**
+     * 檢查是否有任何已註冊的路由
+     */
+    hasAnyRoute(): boolean;
+    /**
+     * 將 handlers 轉換為 Bun.serve websocket config
+     */
+    toHandler(): {
+        open?: (ws: unknown) => void | Promise<void>;
+        message?: (ws: unknown, data: string | Buffer | Uint8Array) => void | Promise<void>;
+        close?: (ws: unknown, code: number, reason: string) => void | Promise<void>;
+        drain?: (ws: unknown) => void | Promise<void>;
+    };
+    /**
+     * 尋找符合路徑的 handler
+     * 優先精確匹配，再 wildcard 匹配
+     */
+    private findHandler;
+    /**
+     * 路徑匹配邏輯
+     * 支援：
+     * - 精確匹配：/chat
+     * - Wildcard：/api/*, /api*
+     */
+    private matchesPath;
+}

package/dist/adapters/bun/RadixNode.d.ts

@@ -0,0 +1,19 @@
+import type { HttpMethod } from '../../http/types';
+import { NodeType, type RouteHandler } from './types';
+/**
+ * Node in the Radix Router tree.
+ * @internal
+ */
+export declare class RadixNode {
+    segment: string;
+    type: NodeType;
+    children: Map<string, RadixNode>;
+    paramChild: RadixNode | null;
+    wildcardChild: RadixNode | null;
+    handlers: Map<HttpMethod, RouteHandler[]>;
+    paramName: string | null;
+    regex: RegExp | null;
+    constructor(segment?: string, type?: NodeType);
+    toJSON(): any;
+    static fromJSON(json: any): RadixNode;
+}

package/dist/adapters/bun/RadixRouter.d.ts

@@ -0,0 +1,32 @@
+import type { HttpMethod } from '../../http/types';
+import { type RouteHandler, type RouteMatch } from './types';
+/**
+ * High-performance Radix Tree Router for Bun
+ */
+export declare class RadixRouter {
+    private root;
+    private globalConstraints;
+    private routeCache;
+    /**
+     * Add a generic parameter constraint
+     */
+    where(param: string, regex: RegExp): void;
+    /**
+     * Register a route
+     */
+    add(method: HttpMethod, path: string, handlers: RouteHandler[]): void;
+    /**
+     * Match a request
+     */
+    match(method: string, path: string): RouteMatch | null;
+    private matchRecursive;
+    private splitPath;
+    /**
+     * Serialize the router to a JSON string
+     */
+    serialize(): string;
+    /**
+     * Restore a router from a serialized JSON string
+     */
+    static fromSerialized(json: string): RadixRouter;
+}

package/dist/adapters/bun/index.d.ts

@@ -0,0 +1,7 @@
+export * from './BunContext';
+export * from './BunNativeAdapter';
+export * from './BunRequest';
+export * from './BunWebSocketHandler';
+export * from './RadixNode';
+export * from './RadixRouter';
+export * from './types';

package/dist/adapters/bun/types.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Route Handler type (simplified for internal use)
+ * In the full framework this will align with GravitoHandler
+ */
+export type RouteHandler = Function;
+/**
+ * Route Match Result
+ */
+export interface RouteMatch {
+    handlers: RouteHandler[];
+    params: Record<string, string>;
+}
+/**
+ * Radix Node Type
+ */
+export declare enum NodeType {
+    STATIC = 0,
+    PARAM = 1,
+    WILDCARD = 2
+}

package/dist/adapters/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview Adapters Module
+ *
+ * Export all adapter-related types and implementations.
+ *
+ * @module @gravito/core/adapters
+ * @since 2.0.0
+ */
+export * from './bun';
+export { GravitoEngineAdapter } from './GravitoEngineAdapter';
+export type { AdapterConfig, AdapterFactory, HttpAdapter, RouteDefinition, } from './types';
+export { isHttpAdapter } from './types';

package/dist/adapters/types.d.ts

@@ -0,0 +1,235 @@
+/**
+ * @fileoverview HTTP Adapter Interface for Gravito Framework
+ *
+ * This module defines the contract that all HTTP adapters must implement.
+ * By programming to this interface, Gravito can swap out the underlying
+ * HTTP engine without changing application code.
+ *
+ * @module @gravito/core/adapters
+ * @since 2.0.0
+ */
+import type { GravitoContext, GravitoErrorHandler, GravitoHandler, GravitoMiddleware, GravitoNotFoundHandler, GravitoVariables, HttpMethod } from '../http/types';
+/**
+ * Configuration options for HTTP adapters
+ */
+export interface AdapterConfig {
+    /**
+     * Base path prefix for all routes
+     * @default ''
+     */
+    basePath?: string;
+    /**
+     * Whether to enable strict routing (trailing slashes matter)
+     * @default false
+     */
+    strictRouting?: boolean;
+    /**
+     * Custom options passed to the underlying HTTP engine
+     */
+    engineOptions?: Record<string, unknown>;
+}
+/**
+ * Route definition structure
+ */
+export interface RouteDefinition {
+    method: HttpMethod;
+    path: string;
+    handlers: (GravitoHandler | GravitoMiddleware)[];
+    name?: string;
+    middleware?: GravitoMiddleware[];
+}
+/**
+ * HttpAdapter - The core interface for HTTP engine abstraction
+ *
+ * Any HTTP engine (Photon, Express, Fastify, custom Bun implementation)
+ * must implement this interface to be usable with Gravito.
+ *
+ * @typeParam V - Context variables type
+ *
+ * @example
+ * ```typescript
+ * // Using the default Photon adapter
+ * import { PhotonAdapter } from '@gravito/core/adapters'
+ *
+ * const core = new PlanetCore({
+ *   adapter: new PhotonAdapter()
+ * })
+ *
+ * // Using a custom adapter
+ * import { BunNativeAdapter } from '@gravito/adapter-bun'
+ *
+ * const core = new PlanetCore({
+ *   adapter: new BunNativeAdapter()
+ * })
+ * ```
+ */
+export interface HttpAdapter<V extends GravitoVariables = GravitoVariables> {
+    /**
+     * Adapter name for identification
+     * @example 'photon', 'bun-native', 'express'
+     */
+    readonly name: string;
+    /**
+     * Adapter version
+     */
+    readonly version: string;
+    /**
+     * Access the underlying native HTTP engine instance.
+     *
+     * ⚠️ WARNING: Using this ties your code to a specific adapter.
+     *
+     * @example
+     * ```typescript
+     * // For Photon adapter
+     * const photonApp = adapter.native as Photon
+     *
+     * // For custom Bun adapter
+     * const bunApp = adapter.native as BunApp
+     * ```
+     */
+    readonly native: unknown;
+    /**
+     * Register a route with the adapter
+     *
+     * @param method - HTTP method
+     * @param path - Route path (may include parameters like ':id')
+     * @param handlers - One or more handlers for this route (handlers or middleware)
+     */
+    route(method: HttpMethod, path: string, ...handlers: (GravitoHandler<V> | GravitoMiddleware<V>)[]): void;
+    /**
+     * Register multiple routes at once
+     *
+     * @param routes - Array of route definitions
+     */
+    routes(routes: RouteDefinition[]): void;
+    /**
+     * Register a middleware for a path
+     *
+     * @param path - Path pattern to match
+     * @param middleware - One or more middleware functions
+     */
+    use(path: string, ...middleware: GravitoMiddleware<V>[]): void;
+    /**
+     * Register a global middleware (applied to all routes)
+     *
+     * @param middleware - Middleware function
+     */
+    useGlobal(...middleware: GravitoMiddleware<V>[]): void;
+    /**
+     * Register a scoped middleware for Orbit-level isolation
+     *
+     * Unlike regular `use()`, this method enforces stricter scoping rules:
+     * - REJECTS '*' wildcard paths (prevents global middleware in Orbits)
+     * - ENFORCES that all middleware paths must include the scope prefix
+     * - Throws error if attempting to register global middleware within an Orbit scope
+     *
+     * This is designed to prevent accidental middleware cross-contamination
+     * when multiple Orbits are mounted to a single PlanetCore instance.
+     *
+     * @param scope - The scope/path prefix (e.g., '/api', '/blog')
+     * @param path - Path pattern to match (cannot be '*')
+     * @param middleware - One or more middleware functions
+     * @throws {Error} If path is '*' when in Orbit scope
+     * @since 2.3.0
+     *
+     * @example
+     * ```typescript
+     * // Correct: Scoped to specific path
+     * adapter.useScoped('/api', '/users/*', authMiddleware)
+     *
+     * // Error: Cannot use wildcard in Orbit scope
+     * adapter.useScoped('/api', '*', loggerMiddleware)
+     * ```
+     */
+    useScoped(scope: string, path: string, ...middleware: GravitoMiddleware<V>[]): void;
+    /**
+     * Mount a sub-adapter at a path
+     *
+     * @param path - Mount path
+     * @param subAdapter - The adapter to mount
+     */
+    mount(path: string, subAdapter: HttpAdapter<V>): void;
+    /**
+     * Set the error handler
+     *
+     * @param handler - Error handler function
+     */
+    onError(handler: GravitoErrorHandler<V>): void;
+    /**
+     * Set the not-found handler
+     *
+     * @param handler - Not-found handler function
+     */
+    onNotFound(handler: GravitoNotFoundHandler<V>): void;
+    /**
+     * The main fetch handler for serving requests.
+     *
+     * This is compatible with `Bun.serve()`, Cloudflare Workers,
+     * and other fetch-based runtimes.
+     *
+     * @param request - Incoming HTTP request
+     * @param server - Optional server context (Bun.Server, etc.)
+     * @returns HTTP response
+     *
+     * @example
+     * ```typescript
+     * // With Bun.serve
+     * Bun.serve({
+     *   port: 3000,
+     *   fetch: adapter.fetch
+     * })
+     * ```
+     */
+    fetch(request: Request, server?: unknown): Response | Promise<Response>;
+    /**
+     * Predictive Route Warming (JIT Optimization)
+     *
+     * Simulates requests to specified routes to trigger JIT compilation (FTL)
+     * before real traffic arrives.
+     *
+     * @param paths List of paths to warm up (e.g. ['/api/users', '/health'])
+     * @since 2.1.0
+     */
+    warmup?(paths: string[]): Promise<void>;
+    /**
+     * WebSocket Handler for Bun.serve
+     *
+     * @since 2.2.0
+     */
+    websocket?: {
+        open?(ws: unknown): void | Promise<void>;
+        message?(ws: unknown, message: string | Buffer | Uint8Array): void | Promise<void>;
+        close?(ws: unknown, code: number, message: string): void | Promise<void>;
+        drain?(ws: unknown): void | Promise<void>;
+        [key: string]: unknown;
+    };
+    /**
+     * Initialize the adapter
+     *
+     * Called during PlanetCore.boot()
+     */
+    init?(): void | Promise<void>;
+    /**
+     * Cleanup resources
+     *
+     * Called during graceful shutdown
+     */
+    shutdown?(): void | Promise<void>;
+    /**
+     * Create a GravitoContext from a raw request.
+     *
+     * This is used internally for testing and advanced scenarios.
+     *
+     * @param request - Raw HTTP request
+     * @returns Gravito context
+     */
+    createContext(request: Request): GravitoContext<V>;
+}
+/**
+ * Factory function type for creating adapters
+ */
+export type AdapterFactory<V extends GravitoVariables = GravitoVariables> = (config?: AdapterConfig) => HttpAdapter<V>;
+/**
+ * Check if a value is an HttpAdapter
+ */
+export declare function isHttpAdapter(value: unknown): value is HttpAdapter;

package/dist/binary/BinaryUtils.d.ts

@@ -0,0 +1,105 @@
+/**
+ * BinaryUtils - 統一的二進制轉換工具類
+ *
+ * 支援 Bun 原生 API 優化，並提供 Node.js 回退路徑。
+ * 設計為 isomorphic，可在 Bun 和 Node.js 環境中運行。
+ * @public
+ */
+/**
+ * BinaryUtils - 提供統一的二進制轉換、編碼、壓縮工具
+ * 所有方法均為靜態方法，可直接呼叫
+ * @public
+ */
+export declare class BinaryUtils {
+    /**
+     * 將各種資料類型轉換為 Uint8Array
+     * @param data - 輸入資料（Blob、Buffer、string、ArrayBuffer 或 Uint8Array）
+     * @returns Uint8Array
+     * @public
+     */
+    static toUint8Array(data: Blob | Buffer | string | ArrayBuffer | Uint8Array): Promise<Uint8Array>;
+    /**
+     * 將各種資料類型轉換為 ArrayBuffer
+     * @param data - 輸入資料
+     * @returns ArrayBuffer
+     * @public
+     */
+    static toArrayBuffer(data: Blob | Buffer | string | Uint8Array | ArrayBuffer): Promise<ArrayBuffer>;
+    /**
+     * 將 Uint8Array 編碼為 Base64 字串
+     * 在 Bun 環境中使用原生 toBase64()，否則使用 Buffer
+     * @param data - 輸入的 Uint8Array
+     * @returns Base64 字串
+     * @public
+     */
+    static toBase64(data: Uint8Array): string;
+    /**
+     * 將 Base64 字串解碼為 Uint8Array
+     * @param base64 - Base64 字串
+     * @returns Uint8Array
+     * @public
+     */
+    static fromBase64(base64: string): Uint8Array;
+    /**
+     * 將 Uint8Array 編碼為 Base64URL 字串（URL 安全，無填充）
+     * @param data - 輸入的 Uint8Array
+     * @returns Base64URL 字串
+     * @public
+     */
+    static toBase64Url(data: Uint8Array): string;
+    /**
+     * 將 Base64URL 字串解碼為 Uint8Array
+     * @param base64url - Base64URL 字串
+     * @returns Uint8Array
+     * @public
+     */
+    static fromBase64Url(base64url: string): Uint8Array;
+    /**
+     * 將 Uint8Array 編碼為十六進制字串
+     * 在 Bun 環境中使用原生 toHex()，否則使用 Buffer
+     * @param data - 輸入的 Uint8Array
+     * @returns 十六進制字串（小寫）
+     * @public
+     */
+    static toHex(data: Uint8Array): string;
+    /**
+     * 將十六進制字串解碼為 Uint8Array
+     * @param hex - 十六進制字串
+     * @returns Uint8Array
+     * @throws {TypeError} 如果輸入不是有效的十六進制字串
+     * @public
+     */
+    static fromHex(hex: string): Uint8Array;
+    /**
+     * 使用 gzip 壓縮資料
+     * 在 Bun 環境中使用原生 Bun.gzipSync()，在 Node.js 中使用 zlib
+     * @param data - 輸入資料
+     * @param level - 壓縮等級（0-9），預設為 6
+     * @returns 壓縮後的 Uint8Array
+     * @public
+     */
+    static gzip(data: Uint8Array, level?: number): Promise<Uint8Array>;
+    /**
+     * 解壓縮 gzip 資料
+     * 在 Bun 環境中使用原生 Bun.gunzipSync()，在 Node.js 中使用 zlib
+     * @param data - gzip 壓縮的 Uint8Array
+     * @returns 解壓縮後的 Uint8Array
+     * @public
+     */
+    static gunzip(data: Uint8Array): Promise<Uint8Array>;
+    /**
+     * 將 ReadableStream<Uint8Array> 讀取為 Uint8Array
+     * 在 Bun 環境中使用原生 Bun.readableStreamToBytes()，否則手動讀取 chunks
+     * @param stream - 輸入的 ReadableStream
+     * @returns Uint8Array
+     * @public
+     */
+    static readableStreamToBytes(stream: ReadableStream<Uint8Array>): Promise<Uint8Array>;
+    /**
+     * 將 ReadableStream<Uint8Array> 讀取為 ArrayBuffer
+     * @param stream - 輸入的 ReadableStream
+     * @returns ArrayBuffer
+     * @public
+     */
+    static readableStreamToArrayBuffer(stream: ReadableStream<Uint8Array>): Promise<ArrayBuffer>;
+}

package/dist/binary/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Binary utilities module for @gravito/core
+ * @packageDocumentation
+ */
+export { BinaryUtils } from './BinaryUtils';

package/dist/cli/queue-commands.d.ts

@@ -0,0 +1,6 @@
+import type { CommandKernel } from '../CommandKernel';
+import type { QueueDashboard } from '../observability/QueueDashboard';
+/**
+ * Register queue management commands with CommandKernel
+ */
+export declare function registerQueueCommands(kernel: CommandKernel, dashboard: QueueDashboard): void;

package/dist/compat/async-local-storage.browser.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Browser-safe AsyncLocalStorage mock
+ */
+export declare class AsyncLocalStorage<T> {
+    private store;
+    run<R>(store: T, fn: () => R): R;
+    getStore(): T | undefined;
+    disable(): void;
+}

package/dist/compat/async-local-storage.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Universal AsyncLocalStorage wrapper.
+ * Automatically switches between node:async_hooks and a browser mock.
+ */
+export declare const AsyncLocalStorage: {
+    new <_T>(): any;
+};

package/dist/compat/crypto.browser.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Browser-safe crypto mock
+ */
+export declare const randomUUID: () => string;
+export declare const randomBytes: (size: number) => Buffer;

package/dist/compat/crypto.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Universal Crypto wrapper.
+ * Automatically switches between node:crypto and globalThis.crypto.
+ */
+export declare const randomUUID: () => string;
+export declare const randomBytes: (size: number) => any;

package/dist/compat.cjs

@@ -1,18 +1,49 @@
-"use strict";
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
   return to;
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
 
 // src/compat.ts
-var compat_exports = {};
-module.exports = __toCommonJS(compat_exports);
+var exports_compat = {};
+module.exports = __toCommonJS(exports_compat);
+})
+
+//# debugId=13536C28A77644A064756E2164756E21

package/dist/compat.cjs.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "13536C28A77644A064756E2164756E21",
+  "names": []
+}

package/dist/compat.d.ts

@@ -1 +1,23 @@
-export { C as ContentfulStatusCode, e as Context, e as GravitoContext, c as GravitoErrorHandler, a as GravitoHandler, b as GravitoMiddleware, g as GravitoNext, d as GravitoNotFoundHandler, f as GravitoRequest, G as GravitoVariables, a as Handler, H as HttpMethod, b as MiddlewareHandler, g as Next, S as StatusCode, V as ValidationTarget, G as Variables } from './compat-CI8hiulX.js';
+/**
+ * @fileoverview Type Compatibility Layer
+ *
+ * This module provides type aliases for backward compatibility with
+ * code that directly imports from Photon. Users can gradually migrate
+ * to the Gravito abstractions.
+ *
+ * @module @gravito/core/compat
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * // Before (Photon-coupled):
+ * import type { Context, MiddlewareHandler } from '@gravito/photon'
+ *
+ * // After (Gravito abstraction):
+ * import type { GravitoContext, GravitoMiddleware } from '@gravito/core'
+ *
+ * // Or using compat aliases during migration:
+ * import type { Context, MiddlewareHandler } from '@gravito/core/compat'
+ * ```
+ */
+export type { ContentfulStatusCode, GravitoContext as Context, GravitoContext, GravitoErrorHandler, GravitoHandler as Handler, GravitoHandler, GravitoMiddleware as MiddlewareHandler, GravitoMiddleware, GravitoNext as Next, GravitoNext, GravitoNotFoundHandler, GravitoRequest, GravitoVariables as Variables, GravitoVariables, HttpMethod, StatusCode, ValidationTarget, } from './http/types';

package/dist/compat.js

@@ -0,0 +1,3 @@
+// @bun
+
+//# debugId=3ADB5C7D268C6CEC64756E2164756E21

package/dist/compat.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "3ADB5C7D268C6CEC64756E2164756E21",
+  "names": []
+}