@hypequery/serve 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./types.js";
+export * from "./server.js";
+export * from "./router.js";
+export * from "./endpoint.js";
+export * from "./openapi.js";
+export * from "./docs-ui.js";
+export * from "./auth.js";
+export * from "./client-config.js";
+export * from "./adapters/node.js";
+export * from "./adapters/fetch.js";
+export * from "./adapters/vercel.js";
+export * from "./dev.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,12 @@
+export * from "./types.js";
+export * from "./server.js";
+export * from "./router.js";
+export * from "./endpoint.js";
+export * from "./openapi.js";
+export * from "./docs-ui.js";
+export * from "./auth.js";
+export * from "./client-config.js";
+export * from "./adapters/node.js";
+export * from "./adapters/fetch.js";
+export * from "./adapters/vercel.js";
+export * from "./dev.js";

package/dist/openapi.d.ts

@@ -0,0 +1,3 @@
+import type { OpenApiDocument, OpenApiOptions, ServeEndpoint } from "./types.js";
+export declare const buildOpenApiDocument: (endpoints: ServeEndpoint<any, any, any, any>[], options?: OpenApiOptions) => OpenApiDocument;
+//# sourceMappingURL=openapi.d.ts.map

package/dist/openapi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../src/openapi.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAqLjF,eAAO,MAAM,oBAAoB,GAC/B,WAAW,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,EAC9C,UAAU,cAAc,KACvB,eAyCF,CAAC"}

package/dist/openapi.js

@@ -0,0 +1,189 @@
+import { zodToJsonSchema } from "zod-to-json-schema";
+const ERROR_SCHEMA = {
+    type: "object",
+    properties: {
+        error: {
+            type: "object",
+            properties: {
+                type: { type: "string" },
+                message: { type: "string" },
+                details: { type: "object" },
+            },
+            required: ["type", "message"],
+        },
+    },
+    required: ["error"],
+};
+const dereferenceSchema = (schema) => {
+    if (!schema || typeof schema !== "object") {
+        return schema;
+    }
+    if (schema.$ref && schema.definitions) {
+        const refKey = String(schema.$ref).split("/").pop();
+        if (refKey && schema.definitions[refKey]) {
+            return schema.definitions[refKey];
+        }
+    }
+    return schema;
+};
+const removeDefinitions = (schema) => {
+    if (!schema || typeof schema !== "object") {
+        return schema;
+    }
+    // Handle arrays
+    if (Array.isArray(schema)) {
+        return schema.map(item => removeDefinitions(item));
+    }
+    // If this schema has a $ref and definitions, inline the definition
+    if (schema.$ref && schema.definitions) {
+        const refKey = String(schema.$ref).split("/").pop();
+        if (refKey && schema.definitions[refKey]) {
+            const resolved = schema.definitions[refKey];
+            delete schema.$ref;
+            delete schema.definitions;
+            return removeDefinitions({ ...schema, ...resolved });
+        }
+    }
+    // Remove definitions property if it exists
+    const { definitions: _definitions, $ref: _ref, ...rest } = schema;
+    // Recursively clean nested objects and arrays
+    const result = {};
+    for (const [key, value] of Object.entries(rest)) {
+        if (Array.isArray(value)) {
+            result[key] = value.map(item => typeof item === "object" && item !== null ? removeDefinitions(item) : item);
+        }
+        else if (typeof value === "object" && value !== null) {
+            result[key] = removeDefinitions(value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+};
+const toJsonSchema = (schema, name) => {
+    if (!schema) {
+        return { type: "object" };
+    }
+    const jsonSchema = zodToJsonSchema(schema, {
+        target: "openApi3",
+        name,
+        $refStrategy: "none",
+    });
+    return removeDefinitions(jsonSchema);
+};
+const toQueryParameters = (schema, name) => {
+    if (!schema) {
+        return [];
+    }
+    const jsonSchema = dereferenceSchema(toJsonSchema(schema, name));
+    if (!jsonSchema || typeof jsonSchema !== "object") {
+        return [];
+    }
+    const schemaType = jsonSchema.type;
+    const isObjectType = schemaType === "object" || (Array.isArray(schemaType) && schemaType.includes("object"));
+    if (!isObjectType || typeof jsonSchema.properties !== "object") {
+        return [];
+    }
+    const properties = jsonSchema.properties;
+    const requiredSet = new Set(Array.isArray(jsonSchema.required) ? jsonSchema.required : []);
+    return Object.entries(properties).map(([key, value]) => ({
+        name: key,
+        in: "query",
+        required: requiredSet.has(key),
+        schema: value,
+    }));
+};
+const toOperation = (endpoint, nameSuffix) => {
+    const operation = {
+        operationId: endpoint.key,
+        summary: endpoint.metadata.summary,
+        description: endpoint.metadata.description,
+        tags: endpoint.metadata.tags.length ? endpoint.metadata.tags : undefined,
+        responses: {
+            200: {
+                description: "Successful response",
+                content: {
+                    "application/json": {
+                        schema: toJsonSchema(endpoint.outputSchema, `${endpoint.key}${nameSuffix}`),
+                    },
+                },
+            },
+            default: {
+                description: "Error response",
+                content: {
+                    "application/json": {
+                        schema: ERROR_SCHEMA,
+                    },
+                },
+            },
+        },
+    };
+    const queryParameters = endpoint.method === "GET"
+        ? toQueryParameters(endpoint.inputSchema, `${endpoint.key}Query`)
+        : [];
+    if (queryParameters.length > 0) {
+        operation.parameters = queryParameters;
+    }
+    else if (endpoint.inputSchema) {
+        operation.requestBody = {
+            required: true,
+            content: {
+                "application/json": {
+                    schema: toJsonSchema(endpoint.inputSchema, `${endpoint.key}Request`),
+                },
+            },
+        };
+    }
+    if (endpoint.metadata.requiresAuth) {
+        operation.security = [{ ApiKeyAuth: [] }];
+    }
+    return operation;
+};
+const normalizeInfo = (options) => {
+    const info = options?.info;
+    return {
+        title: info?.title ?? "hypequery API",
+        version: options?.version ?? "1.0.0",
+        description: info?.description,
+        termsOfService: info?.termsOfService,
+        contact: info?.contact,
+        license: info?.license,
+    };
+};
+export const buildOpenApiDocument = (endpoints, options) => {
+    var _a;
+    const document = {
+        openapi: "3.1.0",
+        info: normalizeInfo(options),
+        servers: options?.servers ?? [],
+        paths: {},
+    };
+    let needsSecurityScheme = false;
+    for (const endpoint of endpoints) {
+        if (endpoint.metadata.visibility && endpoint.metadata.visibility !== "public") {
+            continue;
+        }
+        const path = endpoint.metadata.path || "/";
+        const method = endpoint.method.toLowerCase();
+        const pathItem = ((_a = document.paths)[path] ?? (_a[path] = {}));
+        const operation = toOperation(endpoint, "Response");
+        if (endpoint.metadata.requiresAuth) {
+            needsSecurityScheme = true;
+        }
+        pathItem[method] = operation;
+    }
+    if (needsSecurityScheme) {
+        document.components = {
+            ...(document.components ?? {}),
+            securitySchemes: {
+                ApiKeyAuth: {
+                    type: "apiKey",
+                    name: "Authorization",
+                    in: "header",
+                },
+            },
+        };
+    }
+    return document;
+};

package/dist/queries.d.ts

@@ -0,0 +1,3 @@
+import type { AuthContext, ServeQueriesMap } from "./types.js";
+export declare const defineQueries: <TContext extends Record<string, unknown> = Record<string, unknown>, TAuth extends AuthContext = AuthContext, const TQueries extends ServeQueriesMap<TContext, TAuth> = ServeQueriesMap<TContext, TAuth>>(queries: TQueries) => TQueries;
+//# sourceMappingURL=queries.d.ts.map

package/dist/queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../src/queries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE/D,eAAO,MAAM,aAAa,GACxB,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClE,KAAK,SAAS,WAAW,GAAG,WAAW,EACvC,KAAK,CAAC,QAAQ,SAAS,eAAe,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,eAAe,CAAC,QAAQ,EAAE,KAAK,CAAC,EAE1F,SAAS,QAAQ,KAChB,QAAmB,CAAC"}

package/dist/queries.js

@@ -0,0 +1 @@
+export const defineQueries = (queries) => queries;

package/dist/query.d.ts

@@ -0,0 +1,4 @@
+import type { ZodTypeAny } from "zod";
+import type { AuthContext, SchemaOutput, ServeQueryConfig } from "./types.js";
+export declare const defineQuery: <TInputSchema extends ZodTypeAny | undefined = undefined, TOutputSchema extends ZodTypeAny = ZodTypeAny, TContext extends Record<string, unknown> = Record<string, unknown>, TAuth extends AuthContext = AuthContext, TResult = SchemaOutput<TOutputSchema>>(definition: ServeQueryConfig<TInputSchema, TOutputSchema, TContext, TAuth, TResult>) => ServeQueryConfig<TInputSchema, TOutputSchema, TContext, TAuth, TResult>;
+//# sourceMappingURL=query.d.ts.map

package/dist/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AAEtC,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE9E,eAAO,MAAM,WAAW,GACtB,YAAY,SAAS,UAAU,GAAG,SAAS,GAAG,SAAS,EACvD,aAAa,SAAS,UAAU,GAAG,UAAU,EAC7C,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClE,KAAK,SAAS,WAAW,GAAG,WAAW,EACvC,OAAO,GAAG,YAAY,CAAC,aAAa,CAAC,EAErC,YAAY,gBAAgB,CAAC,YAAY,EAAE,aAAa,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC,KAClF,gBAAgB,CAAC,YAAY,EAAE,aAAa,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAe,CAAC"}

package/dist/query.js

@@ -0,0 +1 @@
+export const defineQuery = (definition) => definition;

package/dist/router.d.ts

@@ -0,0 +1,13 @@
+import type { EndpointRegistry, HttpMethod, ServeEndpoint } from "./types.js";
+export declare const normalizeRoutePath: (path: string) => string;
+export declare const applyBasePath: (basePath: string, path: string) => string;
+export declare class ServeRouter implements EndpointRegistry {
+    private readonly basePath;
+    private routes;
+    constructor(basePath?: string);
+    list(): ServeEndpoint<any, any, any, any, any>[];
+    register(endpoint: ServeEndpoint<any, any, any, any>): void;
+    match(method: HttpMethod, path: string): ServeEndpoint<any, any, any, any, any> | null;
+    markRoutesRequireAuth(): void;
+}
+//# sourceMappingURL=router.d.ts.map

package/dist/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAI9E,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,WAG9C,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,UAAU,MAAM,EAAE,MAAM,MAAM,WAM3D,CAAC;AAEF,qBAAa,WAAY,YAAW,gBAAgB;IAGtC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAFrC,OAAO,CAAC,MAAM,CAA2C;gBAE5B,QAAQ,SAAK;IAE1C,IAAI;IAIJ,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;IAuBpD,KAAK,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM;IAStC,qBAAqB;CAetB"}

package/dist/router.js

@@ -0,0 +1,56 @@
+const trimSlashes = (value) => value.replace(/^\/+|\/+$/g, "");
+export const normalizeRoutePath = (path) => {
+    const trimmed = trimSlashes(path || "/");
+    return `/${trimmed}`.replace(/\/+/g, "/").replace(/\/$/, trimmed ? "" : "/");
+};
+export const applyBasePath = (basePath, path) => {
+    const parts = [trimSlashes(basePath ?? ""), trimSlashes(path)]
+        .filter(Boolean)
+        .join("/");
+    const combined = parts ? `/${parts}` : "/";
+    return combined.replace(/\/+/g, "/").replace(/\/$/, combined === "/" ? "/" : "");
+};
+export class ServeRouter {
+    constructor(basePath = "") {
+        this.basePath = basePath;
+        this.routes = [];
+    }
+    list() {
+        return [...this.routes];
+    }
+    register(endpoint) {
+        const path = endpoint.metadata.path || "/";
+        const normalizedPath = applyBasePath(this.basePath, path);
+        const method = endpoint.method;
+        const existing = this.routes.find((route) => route.metadata.path === normalizedPath && route.method === method);
+        if (existing) {
+            throw new Error(`Route already registered for ${method} ${normalizedPath}`);
+        }
+        this.routes.push({
+            ...endpoint,
+            metadata: {
+                ...endpoint.metadata,
+                path: normalizedPath,
+                method,
+            },
+        });
+    }
+    match(method, path) {
+        const normalizedPath = normalizeRoutePath(path);
+        return (this.routes.find((route) => route.method === method && route.metadata.path === normalizedPath) ?? null);
+    }
+    markRoutesRequireAuth() {
+        this.routes = this.routes.map((route) => {
+            if (route.metadata.requiresAuth === false) {
+                return route;
+            }
+            return {
+                ...route,
+                metadata: {
+                    ...route.metadata,
+                    requiresAuth: true,
+                },
+            };
+        });
+    }
+}

package/dist/sdk-generator.d.ts

@@ -0,0 +1,7 @@
+export interface GenerateSdkOptions {
+    input: string;
+    output: string;
+    clientName?: string;
+}
+export declare const generateSdkClient: (options: GenerateSdkOptions) => Promise<void>;
+//# sourceMappingURL=sdk-generator.d.ts.map

package/dist/sdk-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk-generator.d.ts","sourceRoot":"","sources":["../src/sdk-generator.ts"],"names":[],"mappings":"AAuHA,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAuBD,eAAO,MAAM,iBAAiB,GAAU,SAAS,kBAAkB,kBAalE,CAAC"}

package/dist/sdk-generator.js

@@ -0,0 +1,143 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import openapiTS, { astToString } from "openapi-typescript";
+const TEMPLATE_CLIENT = (clientName) => [
+    'import type { paths } from "./types";',
+    '',
+    'type FetchImpl = typeof fetch;',
+    '',
+    'type ExtractJsonResponse<T> = T extends { responses: infer Responses }',
+    '  ? Responses extends Record<string, any>',
+    '    ? Responses[200] extends { content: { "application/json": infer R } }',
+    '      ? R',
+    '      : Responses[201] extends { content: { "application/json": infer R } }',
+    '        ? R',
+    '        : unknown',
+    '    : unknown',
+    '  : unknown;',
+    '',
+    'type ExtractBody<T> = T extends { requestBody: { content: { "application/json": infer Body } } }',
+    '  ? Body',
+    '  : undefined;',
+    '',
+    'type ExtractQuery<T> = T extends { parameters: { query: infer Params } }',
+    '  ? Params',
+    '  : undefined;',
+    '',
+    'type RequestOptions<Path extends keyof paths, Method extends keyof paths[Path]> = {',
+    '  path: Path;',
+    '  method: Method;',
+    '  query?: ExtractQuery<paths[Path][Method]>;',
+    '  body?: ExtractBody<paths[Path][Method]>;',
+    '  headers?: Record<string, string>;',
+    '  fetch?: FetchImpl;',
+    '} & Omit<RequestInit, "body" | "method">;',
+    '',
+    'interface ClientConfig {',
+    '  baseUrl: string;',
+    '  headers?: Record<string, string>;',
+    '  fetch?: FetchImpl;',
+    '}',
+    '',
+    'const encodeQueryValue = (value: unknown) =>',
+    '  Array.isArray(value)',
+    '    ? value.map((v) => encodeURIComponent(String(v))).join(",")',
+    '    : encodeURIComponent(String(value));',
+    '',
+    'const buildUrl = (baseUrl: string, path: string, query?: Record<string, unknown>) => {',
+    '  const url = new URL(path, baseUrl);',
+    '',
+    '  if (query) {',
+    '    Object.entries(query).forEach(([key, value]) => {',
+    '      if (value === undefined || value === null) {',
+    '        return;',
+    '      }',
+    '',
+    '      if (Array.isArray(value)) {',
+    '        value.forEach((entry) => url.searchParams.append(key, String(entry)));',
+    '      } else if (typeof value === "object") {',
+    '        url.searchParams.append(key, encodeQueryValue(JSON.stringify(value)));',
+    '      } else {',
+    '        url.searchParams.append(key, encodeQueryValue(value));',
+    '      }',
+    '    });',
+    '  }',
+    '',
+    '  return url;',
+    '};',
+    '',
+    `export class ${clientName} {`,
+    '  constructor(private readonly config: ClientConfig) {}',
+    '',
+    '  async request<Path extends keyof paths, Method extends keyof paths[Path]>(',
+    '    options: RequestOptions<Path, Method>',
+    '  ): Promise<ExtractJsonResponse<paths[Path][Method]>> {',
+    '    const target = buildUrl(this.config.baseUrl, options.path as string, options.query);',
+    '    const fetchImpl = options.fetch ?? this.config.fetch ?? globalThis.fetch;',
+    '',
+    '    if (!fetchImpl) {',
+    '      throw new Error("No fetch implementation available. Provide one via config.fetch.");',
+    '    }',
+    '',
+    '    const headers = {',
+    '      "content-type": "application/json",',
+    '      ...(this.config.headers ?? {}),',
+    '      ...(options.headers ?? {}),',
+    '    };',
+    '',
+    '    const response = await fetchImpl(target.toString(), {',
+    '      ...options,',
+    '      method: options.method as string,',
+    '      headers,',
+    '      body: options.body !== undefined ? JSON.stringify(options.body) : undefined,',
+    '    });',
+    '',
+    '    if (!response.ok) {',
+    '      const errorText = await response.text();',
+    '      throw new Error(`Request failed with status ${response.status}: ${errorText}`);',
+    '    }',
+    '',
+    '    const text = await response.text();',
+    '    if (!text) {',
+    '      return undefined as ExtractJsonResponse<paths[Path][Method]>;',
+    '    }',
+    '',
+    '    return JSON.parse(text);',
+    '  }',
+    '}',
+    '',
+    `export const createClient = (config: ClientConfig) => new ${clientName}(config);`,
+    '',
+].join("\n");
+const TEMPLATE_INDEX = `export * from "./client";
+export * from "./types";
+`;
+const isHttpUrl = (value) => /^https?:\/\//i.test(value);
+const loadDocument = async (input) => {
+    if (isHttpUrl(input)) {
+        const response = await fetch(input);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch OpenAPI spec from ${input}: ${response.status}`);
+        }
+        return response.json();
+    }
+    const absolutePath = isAbsolute(input) ? input : resolve(process.cwd(), input);
+    const contents = await readFile(absolutePath, "utf8");
+    return JSON.parse(contents);
+};
+const writeFileSafe = async (filePath, contents) => {
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, contents, "utf8");
+};
+export const generateSdkClient = async (options) => {
+    const document = await loadDocument(options.input);
+    const typesAst = await openapiTS(document, {
+        exportType: true,
+    });
+    const types = astToString(typesAst);
+    const outputDir = isAbsolute(options.output) ? options.output : resolve(process.cwd(), options.output);
+    const clientName = options.clientName ?? "HypeQueryClient";
+    await writeFileSafe(join(outputDir, "types.ts"), types);
+    await writeFileSafe(join(outputDir, "client.ts"), TEMPLATE_CLIENT(clientName));
+    await writeFileSafe(join(outputDir, "index.ts"), TEMPLATE_INDEX);
+};

package/dist/server.d.ts

@@ -0,0 +1,9 @@
+import type { AuthContext, ServeBuilder, ServeConfig, ServeContextFactory, ServeEndpointMap, ServeInitializer, ServeQueriesMap } from "./types.js";
+export declare const defineServe: <TContext extends Record<string, unknown> = Record<string, unknown>, TAuth extends AuthContext = AuthContext, const TQueries extends ServeQueriesMap<TContext, TAuth> = ServeQueriesMap<TContext, TAuth>>(config: ServeConfig<TContext, TAuth, TQueries>) => ServeBuilder<ServeEndpointMap<TQueries, TContext, TAuth>, TContext, TAuth>;
+type InferInitializerContext<TFactory, TAuth extends AuthContext> = TFactory extends ServeContextFactory<infer TContext, TAuth> ? TContext : never;
+type ServeInitializerOptions<TFactory extends ServeContextFactory<any, TAuth>, TAuth extends AuthContext> = Omit<ServeConfig<InferInitializerContext<TFactory, TAuth>, TAuth, ServeQueriesMap<InferInitializerContext<TFactory, TAuth>, TAuth>>, "queries" | "context"> & {
+    context: TFactory;
+};
+export declare const initServe: <TFactory extends ServeContextFactory<any, TAuth>, TAuth extends AuthContext = AuthContext>(options: ServeInitializerOptions<TFactory, TAuth>) => ServeInitializer<InferInitializerContext<TFactory, TAuth>, TAuth>;
+export {};
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,WAAW,EAaX,YAAY,EACZ,WAAW,EACX,mBAAmB,EAEnB,gBAAgB,EAEhB,gBAAgB,EAGhB,eAAe,EAShB,MAAM,YAAY,CAAC;AAqiBpB,eAAO,MAAM,WAAW,GACtB,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClE,KAAK,SAAS,WAAW,GAAG,WAAW,EACvC,KAAK,CAAC,QAAQ,SAAS,eAAe,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,eAAe,CAAC,QAAQ,EAAE,KAAK,CAAC,EAE1F,QAAQ,WAAW,CAAC,QAAQ,EAAE,KAAK,EAAE,QAAQ,CAAC,KAC7C,YAAY,CAAC,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,QAAQ,EAAE,KAAK,CA2L3E,CAAC;AA6BF,KAAK,uBAAuB,CAC1B,QAAQ,EACR,KAAK,SAAS,WAAW,IACvB,QAAQ,SAAS,mBAAmB,CAAC,MAAM,QAAQ,EAAE,KAAK,CAAC,GAAG,QAAQ,GAAG,KAAK,CAAC;AAEnF,KAAK,uBAAuB,CAC1B,QAAQ,SAAS,mBAAmB,CAAC,GAAG,EAAE,KAAK,CAAC,EAChD,KAAK,SAAS,WAAW,IACvB,IAAI,CACN,WAAW,CACT,uBAAuB,CAAC,QAAQ,EAAE,KAAK,CAAC,EACxC,KAAK,EACL,eAAe,CAAC,uBAAuB,CAAC,QAAQ,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,CACjE,EACD,SAAS,GAAG,SAAS,CACtB,GAAG;IAAE,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;AAQ1B,eAAO,MAAM,SAAS,GACpB,QAAQ,SAAS,mBAAmB,CAAC,GAAG,EAAE,KAAK,CAAC,EAChD,KAAK,SAAS,WAAW,GAAG,WAAW,EACvC,SAAS,uBAAuB,CAAC,QAAQ,EAAE,KAAK,CAAC,KAAG,gBAAgB,CACpE,uBAAuB,CAAC,QAAQ,EAAE,KAAK,CAAC,EACxC,KAAK,CAsBN,CAAC"}