stitchkit 0.45.0 → 0.46.0

package/dist/{index-w0mec79h.js → index-zwqty9zf.js}

@@ -2,14 +2,12 @@ import {
   assertCorsConfig,
   corsHeaders,
   corsPreflightResponse
-} from "./index-6jypn22c.js";
-import {
-  isWithinDir
-} from "./index-x3fcszf8.js";
+} from "./index-r1qp4rve.js";
 import {
   AppError,
   __require,
   badRequest,
+  callRuntimeHandler,
   errorCode,
   extractIp,
   getClientInfo,
@@ -29,8 +27,9 @@ import {
   setRequestEndpoint,
   setRequestError,
   typedEntries,
-  validateDeclaredOutput
-} from "./index-yh0p5ddn.js";
+  validateDeclaredOutput,
+  zodIssues
+} from "./index-5s8b7z6q.js";
 
 // src/server/multipart.ts
 var DEFAULT_MAX_UPLOAD_BYTES = 25 * 1024 * 1024;
@@ -85,244 +84,6 @@ async function parseMultipart(req, fileField, fieldsSchema, maxBytes = DEFAULT_M
   return { file, fields: fieldsSchema ? fieldsSchema.parse(fields) : fields };
 }
 
-// src/server/router.ts
-import { readFile, stat } from "node:fs/promises";
-import { resolve } from "node:path";
-
-// src/server/mime.ts
-import { extname } from "node:path";
-var MIME_BY_EXT = {
-  ".html": "text/html; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".js": "text/javascript; charset=utf-8",
-  ".mjs": "text/javascript; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".avif": "image/avif",
-  ".ico": "image/x-icon",
-  ".woff2": "font/woff2",
-  ".txt": "text/plain; charset=utf-8",
-  ".wasm": "application/wasm",
-  ".mp4": "video/mp4",
-  ".webm": "video/webm",
-  ".mov": "video/quicktime",
-  ".ogv": "video/ogg",
-  ".mp3": "audio/mpeg",
-  ".m4a": "audio/mp4",
-  ".wav": "audio/wav",
-  ".flac": "audio/flac",
-  ".oga": "audio/ogg",
-  ".ogg": "audio/ogg",
-  ".pdf": "application/pdf",
-  ".zip": "application/zip"
-};
-function mimeForPath(path) {
-  return MIME_BY_EXT[extname(path).toLowerCase()] ?? "application/octet-stream";
-}
-
-// src/server/router.ts
-function joinPath(...parts) {
-  const joined = parts.filter(Boolean).map((part) => part.replace(/^\/+|\/+$/g, "")).filter(Boolean).join("/");
-  return `/${joined}`;
-}
-function matchSegments(patternSegments, requestSegments) {
-  const wildcardSegment = patternSegments.at(-1);
-  const wildcardName = wildcardSegment?.startsWith("*") ? wildcardSegment.slice(1) : null;
-  const prefixLength = wildcardName ? patternSegments.length - 1 : patternSegments.length;
-  if (wildcardName) {
-    if (requestSegments.length < prefixLength)
-      return null;
-  } else if (patternSegments.length !== requestSegments.length) {
-    return null;
-  }
-  const params = {};
-  for (const [i, pattern] of patternSegments.slice(0, prefixLength).entries()) {
-    const actual = requestSegments[i];
-    if (actual === undefined)
-      return null;
-    if (pattern.startsWith(":")) {
-      params[pattern.slice(1)] = decodeURIComponent(actual);
-    } else if (pattern !== actual) {
-      return null;
-    }
-  }
-  if (wildcardName) {
-    params[wildcardName] = requestSegments.slice(prefixLength).map(decodeURIComponent).join("/");
-  }
-  return params;
-}
-function segmentRank(segment) {
-  if (segment?.startsWith("*"))
-    return 2;
-  if (segment?.startsWith(":"))
-    return 1;
-  return 0;
-}
-function buildRouteMap(groups) {
-  const map = new Map;
-  for (const { prefix, service, hooks } of groups) {
-    for (const [, method] of Object.entries(service.methods)) {
-      if (method.expose && !method.expose.includes("HTTP"))
-        continue;
-      const servicePath = joinPath("/", service.prefix, method.path === "/" ? "" : method.path);
-      const fullPath = prefix ? joinPath(prefix, servicePath) : servicePath;
-      const segments = fullPath.split("/").filter(Boolean);
-      const entries = map.get(method.method) ?? [];
-      entries.push({ method, pattern: fullPath, segments, groupHooks: hooks });
-      map.set(method.method, entries);
-    }
-  }
-  for (const [, entries] of map) {
-    entries.sort((a, b) => {
-      const len = Math.min(a.segments.length, b.segments.length);
-      for (let i = 0;i < len; i++) {
-        const rankDifference = segmentRank(a.segments[i]) - segmentRank(b.segments[i]);
-        if (rankDifference !== 0)
-          return rankDifference;
-      }
-      return a.segments.length - b.segments.length;
-    });
-  }
-  return map;
-}
-function matchRoute(routeMap, httpMethod, pathname) {
-  const entries = routeMap.get(httpMethod);
-  if (!entries)
-    return null;
-  const requestSegments = pathname.split("/").filter(Boolean);
-  for (const entry of entries) {
-    const pathParams = matchSegments(entry.segments, requestSegments);
-    if (pathParams) {
-      return {
-        method: entry.method,
-        pathParams,
-        groupHooks: entry.groupHooks
-      };
-    }
-  }
-  return null;
-}
-function allowedMethods(routeMap, pathname) {
-  const requestSegments = pathname.split("/").filter(Boolean);
-  const methods = [];
-  for (const [method, entries] of routeMap) {
-    for (const entry of entries) {
-      if (matchSegments(entry.segments, requestSegments)) {
-        methods.push(method);
-        break;
-      }
-    }
-  }
-  return methods;
-}
-function validateRoutes(routeMap) {
-  for (const [method, entries] of routeMap) {
-    const seen = new Map;
-    for (const entry of entries) {
-      parseTrailingWildcard(entry.pattern);
-      const normalized = entry.segments.map((s) => s.startsWith(":") ? ":param" : s.startsWith("*") ? "*wildcard" : s).join("/");
-      const key = `${method} /${normalized}`;
-      const existing = seen.get(key);
-      if (existing) {
-        throw new Error(`Duplicate route: ${method} ${entry.pattern} conflicts with ${existing}`);
-      }
-      seen.set(key, entry.pattern);
-    }
-  }
-}
-function findShadowedRoutes(routeMap, rawRoutes) {
-  if (!rawRoutes || rawRoutes.length === 0)
-    return [];
-  const shadowed = [];
-  for (const [httpMethod, entries] of routeMap) {
-    for (const entry of entries) {
-      const probe = `/${entry.segments.map((segment) => {
-        if (segment.startsWith(":"))
-          return "__param__";
-        if (segment.startsWith("*"))
-          return "__wildcard__";
-        return segment;
-      }).join("/")}`;
-      const match = matchRawRoute(rawRoutes, httpMethod, probe);
-      if (!match)
-        continue;
-      shadowed.push({
-        pattern: `${httpMethod} ${entry.pattern}`,
-        endpoint: `${entry.method.serviceName}.${entry.method.key}`,
-        rawRoute: `${match.route.method} ${match.route.path}`,
-        scope: entry.method.scope
-      });
-    }
-  }
-  return shadowed;
-}
-function matchRawRoute(rawRoutes, httpMethod, pathname) {
-  for (const route of rawRoutes) {
-    if (route.method !== "ALL" && route.method !== httpMethod)
-      continue;
-    if (parseTrailingWildcard(route.path)) {
-      const routeSegs = route.path.split("/").filter(Boolean);
-      const pathSegs = pathname.split("/").filter(Boolean);
-      const params = matchSegments(routeSegs, pathSegs);
-      if (params)
-        return { route, params };
-      continue;
-    }
-    if (route.path.includes("/:")) {
-      const routeSegs = route.path.split("/").filter(Boolean);
-      const pathSegs = pathname.split("/").filter(Boolean);
-      const params = matchSegments(routeSegs, pathSegs);
-      if (params)
-        return { route, params };
-      continue;
-    }
-    if (route.path === pathname)
-      return { route, params: {} };
-  }
-  return null;
-}
-function validateRawRoutes(rawRoutes) {
-  for (const route of rawRoutes ?? [])
-    parseTrailingWildcard(route.path);
-}
-function staticRoute(prefix, dir) {
-  const cleanPrefix = prefix.replace(/\/+$/, "");
-  const root = resolve(dir.replace(/\/+$/, ""));
-  return {
-    method: "GET",
-    path: `${cleanPrefix}/*filePath`,
-    handler: async (req) => {
-      const pathname = new URL(req.url).pathname;
-      let rel;
-      try {
-        rel = decodeURIComponent(pathname.slice(cleanPrefix.length)).replace(/^\/+/, "");
-      } catch {
-        return new Response("Bad request", { status: 400 });
-      }
-      const target = resolve(root, rel);
-      if (!isWithinDir(root, target)) {
-        return new Response("Forbidden", { status: 403 });
-      }
-      const info = await stat(target).catch(() => null);
-      if (!info?.isFile()) {
-        return new Response("Not found", { status: 404 });
-      }
-      const body = await readFile(target);
-      return new Response(body, {
-        headers: {
-          "Content-Type": mimeForPath(target),
-          "X-Content-Type-Options": "nosniff"
-        }
-      });
-    }
-  };
-}
-
 // src/server/request-body.ts
 function assertJsonBodyLimit(maxBytes, owner) {
   if (maxBytes !== undefined && (!Number.isSafeInteger(maxBytes) || maxBytes <= 0)) {
@@ -662,6 +423,172 @@ function applyResponseMetadata(target, metadata, endpointIdentity) {
   }
 }
 
+// src/server/router.ts
+function joinPath(...parts) {
+  const joined = parts.filter(Boolean).map((part) => part.replace(/^\/+|\/+$/g, "")).filter(Boolean).join("/");
+  return `/${joined}`;
+}
+function matchSegments(patternSegments, requestSegments) {
+  const wildcardSegment = patternSegments.at(-1);
+  const wildcardName = wildcardSegment?.startsWith("*") ? wildcardSegment.slice(1) : null;
+  const prefixLength = wildcardName ? patternSegments.length - 1 : patternSegments.length;
+  if (wildcardName) {
+    if (requestSegments.length < prefixLength)
+      return null;
+  } else if (patternSegments.length !== requestSegments.length) {
+    return null;
+  }
+  const params = {};
+  for (const [i, pattern] of patternSegments.slice(0, prefixLength).entries()) {
+    const actual = requestSegments[i];
+    if (actual === undefined)
+      return null;
+    if (pattern.startsWith(":")) {
+      params[pattern.slice(1)] = decodeURIComponent(actual);
+    } else if (pattern !== actual) {
+      return null;
+    }
+  }
+  if (wildcardName) {
+    params[wildcardName] = requestSegments.slice(prefixLength).map(decodeURIComponent).join("/");
+  }
+  return params;
+}
+function segmentRank(segment) {
+  if (segment?.startsWith("*"))
+    return 2;
+  if (segment?.startsWith(":"))
+    return 1;
+  return 0;
+}
+function buildRouteMap(groups) {
+  const map = new Map;
+  for (const { prefix, service, hooks } of groups) {
+    for (const [, method] of Object.entries(service.methods)) {
+      if (method.expose && !method.expose.includes("HTTP"))
+        continue;
+      const servicePath = joinPath("/", service.prefix, method.path === "/" ? "" : method.path);
+      const fullPath = prefix ? joinPath(prefix, servicePath) : servicePath;
+      const segments = fullPath.split("/").filter(Boolean);
+      const entries = map.get(method.method) ?? [];
+      entries.push({ method, pattern: fullPath, segments, groupHooks: hooks });
+      map.set(method.method, entries);
+    }
+  }
+  for (const [, entries] of map) {
+    entries.sort((a, b) => {
+      const len = Math.min(a.segments.length, b.segments.length);
+      for (let i = 0;i < len; i++) {
+        const rankDifference = segmentRank(a.segments[i]) - segmentRank(b.segments[i]);
+        if (rankDifference !== 0)
+          return rankDifference;
+      }
+      return a.segments.length - b.segments.length;
+    });
+  }
+  return map;
+}
+function matchRoute(routeMap, httpMethod, pathname) {
+  const entries = routeMap.get(httpMethod);
+  if (!entries)
+    return null;
+  const requestSegments = pathname.split("/").filter(Boolean);
+  for (const entry of entries) {
+    const pathParams = matchSegments(entry.segments, requestSegments);
+    if (pathParams) {
+      return {
+        method: entry.method,
+        pathParams,
+        groupHooks: entry.groupHooks
+      };
+    }
+  }
+  return null;
+}
+function allowedMethods(routeMap, pathname) {
+  const requestSegments = pathname.split("/").filter(Boolean);
+  const methods = [];
+  for (const [method, entries] of routeMap) {
+    for (const entry of entries) {
+      if (matchSegments(entry.segments, requestSegments)) {
+        methods.push(method);
+        break;
+      }
+    }
+  }
+  return methods;
+}
+function validateRoutes(routeMap) {
+  for (const [method, entries] of routeMap) {
+    const seen = new Map;
+    for (const entry of entries) {
+      parseTrailingWildcard(entry.pattern);
+      const normalized = entry.segments.map((s) => s.startsWith(":") ? ":param" : s.startsWith("*") ? "*wildcard" : s).join("/");
+      const key = `${method} /${normalized}`;
+      const existing = seen.get(key);
+      if (existing) {
+        throw new Error(`Duplicate route: ${method} ${entry.pattern} conflicts with ${existing}`);
+      }
+      seen.set(key, entry.pattern);
+    }
+  }
+}
+function findShadowedRoutes(routeMap, rawRoutes) {
+  if (!rawRoutes || rawRoutes.length === 0)
+    return [];
+  const shadowed = [];
+  for (const [httpMethod, entries] of routeMap) {
+    for (const entry of entries) {
+      const probe = `/${entry.segments.map((segment) => {
+        if (segment.startsWith(":"))
+          return "__param__";
+        if (segment.startsWith("*"))
+          return "__wildcard__";
+        return segment;
+      }).join("/")}`;
+      const match = matchRawRoute(rawRoutes, httpMethod, probe);
+      if (!match)
+        continue;
+      shadowed.push({
+        pattern: `${httpMethod} ${entry.pattern}`,
+        endpoint: `${entry.method.serviceName}.${entry.method.key}`,
+        rawRoute: `${match.route.method} ${match.route.path}`,
+        scope: entry.method.scope
+      });
+    }
+  }
+  return shadowed;
+}
+function matchRawRoute(rawRoutes, httpMethod, pathname) {
+  for (const route of rawRoutes) {
+    if (route.method !== "ALL" && route.method !== httpMethod)
+      continue;
+    if (parseTrailingWildcard(route.path)) {
+      const routeSegs = route.path.split("/").filter(Boolean);
+      const pathSegs = pathname.split("/").filter(Boolean);
+      const params = matchSegments(routeSegs, pathSegs);
+      if (params)
+        return { route, params };
+      continue;
+    }
+    if (route.path.includes("/:")) {
+      const routeSegs = route.path.split("/").filter(Boolean);
+      const pathSegs = pathname.split("/").filter(Boolean);
+      const params = matchSegments(routeSegs, pathSegs);
+      if (params)
+        return { route, params };
+      continue;
+    }
+    if (route.path === pathname)
+      return { route, params: {} };
+  }
+  return null;
+}
+function validateRawRoutes(rawRoutes) {
+  for (const route of rawRoutes ?? [])
+    parseTrailingWildcard(route.path);
+}
+
 // src/server/create.ts
 var BODY_METHODS = new Set(["POST", "PUT", "PATCH", "DELETE"]);
 function createHandler(config) {
@@ -1018,6 +945,9 @@ function implement(contract, handlers) {
   const groupScope = contract.meta.scope ?? "public";
   for (const [key, endpoint] of typedEntries(contract.endpoints)) {
     const typedHandler = handlers[key];
+    if (typeof typedHandler !== "function") {
+      throw new Error(`[stitchkit] implement: missing handler for "${contract.meta.prefix}.${String(key)}"`);
+    }
     methods[String(key)] = {
       method: endpoint.method,
       path: endpoint.path,
@@ -1042,7 +972,7 @@ function implement(contract, handlers) {
       rawBody: endpoint.rawBody,
       responseMeta: endpoint.responseMeta,
       contentType: "contentType" in endpoint ? endpoint.contentType : undefined,
-      handler: (ctx) => typedHandler(ctx)
+      handler: (ctx) => callRuntimeHandler(typedHandler, ctx)
     };
   }
   return {
@@ -1056,9 +986,25 @@ function createImplement() {
   return (contract, handlers) => implement(contract, handlers);
 }
 
-// src/realtime/socket.ts
+// src/realtime/rejection.ts
 import { z } from "zod";
-var AcknowledgementCallbackSchema = z.function();
+function realtimeContractViolation(options) {
+  const issues = options.cause instanceof z.ZodError ? zodIssues(options.cause) : undefined;
+  const reason = options.reason.replaceAll("-", " ");
+  const error = new AppError("REALTIME_CONTRACT_VIOLATION", `Realtime event "${options.event}" (${options.direction}, ${options.phase}): ${reason}`, 500, {
+    event: options.event,
+    direction: options.direction,
+    phase: options.phase,
+    reason: options.reason,
+    fault: options.fault,
+    ...issues !== undefined && { issues }
+  });
+  if (options.cause !== undefined)
+    error.cause = options.cause;
+  return { ...options, error };
+}
+
+// src/realtime/socket.ts
 function method(target, name) {
   const value = Reflect.get(target, name);
   if (typeof value !== "function") {
@@ -1077,15 +1023,26 @@ function splitWireArguments(definition, args) {
     acknowledgement: (...callbackArgs) => Reflect.apply(acknowledgement, undefined, callbackArgs)
   };
 }
-function eventDefinition(registry, event) {
+function eventDefinition(registry, event, direction) {
   const definition = registry[event];
-  if (!definition)
-    throw new Error(`Unknown realtime event "${event}"`);
+  if (!definition) {
+    throw realtimeContractViolation({
+      event,
+      direction,
+      phase: "arguments",
+      reason: "unknown-event",
+      fault: "local"
+    }).error;
+  }
   return definition;
 }
-function reportRejected(rejected, hook) {
+function reportRejected(rejected, hook, logger) {
   if (!hook) {
-    console.error(`[stitchkit] rejected realtime ${rejected.direction} event "${rejected.event}" (${rejected.phase})`, rejected.error);
+    if (logger) {
+      logger.warn(rejected.error.message, rejected.error.details);
+      return;
+    }
+    console.warn(`[stitchkit] rejected realtime ${rejected.direction} event "${rejected.event}" (${rejected.phase})`, rejected.error);
     return;
   }
   Promise.resolve(hook(rejected)).catch((error) => {
@@ -1099,36 +1056,35 @@ function createValidatedRealtimeSocket({
   inboundDirection,
   outboundDirection,
   onRejected,
+  logger,
   subscribe
 }) {
-  const onTarget = method(target, "on");
-  const offTarget = subscribe ? undefined : method(target, "off");
   const emitTarget = method(target, "emit");
   return {
     on: (event, handler) => {
-      const definition = eventDefinition(inbound, event);
+      const definition = eventDefinition(inbound, event, inboundDirection);
       const wrapped = (...wireArgs) => {
         const { values, acknowledgement } = splitWireArguments(definition, wireArgs);
         const parsed = definition.args.safeParse(values);
         if (!parsed.success) {
-          reportRejected({
+          reportRejected(realtimeContractViolation({
             event,
             direction: inboundDirection,
             phase: "arguments",
-            error: parsed.error
-          }, onRejected);
+            reason: "invalid-arguments",
+            fault: "peer",
+            cause: parsed.error
+          }), onRejected, logger);
           return;
         }
         if (definition.ack && !acknowledgement) {
-          const callback = AcknowledgementCallbackSchema.safeParse(undefined);
-          if (!callback.success) {
-            reportRejected({
-              event,
-              direction: inboundDirection,
-              phase: "acknowledgement",
-              error: callback.error
-            }, onRejected);
-          }
+          reportRejected(realtimeContractViolation({
+            event,
+            direction: inboundDirection,
+            phase: "acknowledgement",
+            reason: "missing-acknowledgement",
+            fault: "peer"
+          }), onRejected, logger);
           return;
         }
         const applicationArgs = [...parsed.data];
@@ -1137,12 +1093,14 @@ function createValidatedRealtimeSocket({
             const ack = definition.ack?.safeParse(value);
             if (!ack?.success) {
               if (ack) {
-                reportRejected({
+                reportRejected(realtimeContractViolation({
                   event,
                   direction: outboundDirection,
                   phase: "acknowledgement",
-                  error: ack.error
-                }, onRejected);
+                  reason: "invalid-acknowledgement-value",
+                  fault: "local",
+                  cause: ack.error
+                }), onRejected, logger);
               }
               return;
             }
@@ -1153,30 +1111,50 @@ function createValidatedRealtimeSocket({
       };
       if (subscribe)
         return subscribe(event, wrapped);
+      const onTarget = method(target, "on");
+      const offTarget = method(target, "off");
       onTarget(event, wrapped);
       return () => {
-        offTarget?.(event, wrapped);
+        offTarget(event, wrapped);
       };
     },
     emit: (event, ...args) => {
-      const definition = eventDefinition(outbound, event);
+      const definition = eventDefinition(outbound, event, outboundDirection);
       const { values, acknowledgement } = splitWireArguments(definition, args);
-      const parsed = definition.args.parse(values);
+      const parsed = definition.args.safeParse(values);
+      if (!parsed.success) {
+        throw realtimeContractViolation({
+          event,
+          direction: outboundDirection,
+          phase: "arguments",
+          reason: "invalid-arguments",
+          fault: "local",
+          cause: parsed.error
+        }).error;
+      }
       if (definition.ack && !acknowledgement) {
-        AcknowledgementCallbackSchema.parse(undefined);
+        throw realtimeContractViolation({
+          event,
+          direction: outboundDirection,
+          phase: "acknowledgement",
+          reason: "missing-acknowledgement",
+          fault: "local"
+        }).error;
       }
-      const wireArgs = [...parsed];
+      const wireArgs = [...parsed.data];
       if (definition.ack && acknowledgement) {
         wireArgs.push((value) => {
           const ack = definition.ack?.safeParse(value);
           if (!ack?.success) {
             if (ack) {
-              reportRejected({
+              reportRejected(realtimeContractViolation({
                 event,
                 direction: inboundDirection,
                 phase: "acknowledgement",
-                error: ack.error
-              }, onRejected);
+                reason: "invalid-acknowledgement-value",
+                fault: "peer",
+                cause: ack.error
+              }), onRejected, logger);
             }
             return;
           }
@@ -1196,7 +1174,8 @@ function bindRealtimeServer(contract, handle, options = {}) {
     outbound: contract.serverToClient,
     inboundDirection: "server-inbound",
     outboundDirection: "server-outbound",
-    onRejected: options.onRejected
+    onRejected: options.onRejected,
+    logger: options.logger
   });
   const broadcast = outbound(handle.io);
   return {
@@ -1208,7 +1187,8 @@ function bindRealtimeServer(contract, handle, options = {}) {
           outbound: contract.serverToClient,
           inboundDirection: "server-inbound",
           outboundDirection: "server-outbound",
-          onRejected: options.onRejected
+          onRejected: options.onRejected,
+          logger: options.logger
         });
         handler({
           raw,
@@ -1372,4 +1352,4 @@ function socketIoLane(websocket) {
   });
 }
 
-export { parseMultipart, mimeForPath, staticRoute, createHandler, implement, createImplement, bindRealtimeServer, webSocketLane, composeWebSocketHandlers, createSocketIOServer, socketIoLane };
+export { parseMultipart, createHandler, implement, createImplement, bindRealtimeServer, webSocketLane, composeWebSocketHandlers, createSocketIOServer, socketIoLane };

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export type { RealtimeClient, RealtimeClientOptions, SocketEventMap, SocketIOCli
 export { createRealtimeClient, createSocketIOClient } from './browser/socket-io';
 export { type ParseSSEOptions, parseSSE } from './browser/stream';
 export * from './contract';
+export type { StitchLogger } from './logger';
 export { childSpan, createTraceContext, formatTraceparent, parseTraceparent, type TraceContext, } from './observability/trace';
 export * from './realtime';
 export { createRetainedTopics, type RetainedTopics } from './retained';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,wBAAwB,EACxB,YAAY,EACZ,aAAa,EACb,mBAAmB,EACnB,uBAAuB,EACvB,gBAAgB,EAChB,iBAAiB,EACjB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,gBAAgB,GACtB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,QAAQ,EACR,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,mBAAmB,GACzB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EACV,cAAc,EACd,qBAAqB,EACrB,cAAc,EACd,cAAc,EACd,oBAAoB,GACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AACjF,OAAO,EAAE,KAAK,eAAe,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAClE,cAAc,YAAY,CAAC;AAG3B,OAAO,EACL,SAAS,EACT,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,YAAY,GAClB,MAAM,uBAAuB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,oBAAoB,EAAE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,wBAAwB,EACxB,YAAY,EACZ,aAAa,EACb,mBAAmB,EACnB,uBAAuB,EACvB,gBAAgB,EAChB,iBAAiB,EACjB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,gBAAgB,GACtB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,QAAQ,EACR,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,mBAAmB,GACzB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EACV,cAAc,EACd,qBAAqB,EACrB,cAAc,EACd,cAAc,EACd,oBAAoB,GACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AACjF,OAAO,EAAE,KAAK,eAAe,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAClE,cAAc,YAAY,CAAC;AAC3B,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAG7C,OAAO,EACL,SAAS,EACT,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,YAAY,GAClB,MAAM,uBAAuB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,oBAAoB,EAAE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC"}