timeback 0.0.0-alpha.2 → 0.1.1

package/dist/server/adapters/solid-start.d.ts

@@ -0,0 +1,61 @@
+/**
+ * SolidStart Adapter
+ *
+ * Adapts Timeback handlers for SolidStart.
+ * Uses file-based API routes with SolidStart's APIEvent.
+ */
+import type { SolidStartHandlerOptions, SolidStartHandlers, TimebackInput } from './types';
+/**
+ * Convert Timeback instance to SolidStart route handlers.
+ *
+ * SolidStart uses file-based routing with API routes exporting HTTP method handlers.
+ * This function creates handlers compatible with SolidStart's APIEvent.
+ *
+ * Accepts either the full Timeback instance or just the handlers:
+ * - `toSolidStartHandler(timeback)`
+ * - `toSolidStartHandler(timeback.handle)`
+ *
+ * @param input - Timeback instance or handlers
+ * @returns Object with HTTP method handlers for SolidStart
+ *
+ * @example
+ * ```typescript
+ * // src/routes/api/timeback/[...path].ts
+ * import { timeback } from '~/lib/timeback'
+ * import { toSolidStartHandler } from 'timeback/solid-start'
+ *
+ * export const { GET, POST } = toSolidStartHandler(timeback)
+ * ```
+ */
+export declare function toSolidStartHandler(input: TimebackInput): SolidStartHandlers;
+/**
+ * SolidStart middleware handler for Timeback.
+ *
+ * This provides a middleware-style handler that can intercept requests
+ * before they reach file-based routes.
+ *
+ * @param options - Handler options
+ * @returns Response from Timeback or undefined to continue to next handler
+ *
+ * @example
+ * ```typescript
+ * // src/middleware.ts
+ * import { createMiddleware } from '@solidjs/start/middleware'
+ * import { timeback } from './lib/timeback'
+ * import { solidStartHandler } from 'timeback/solid-start'
+ *
+ * export default createMiddleware({
+ *   onRequest: [
+ *     async (event) => {
+ *       const response = await solidStartHandler({
+ *         timeback,
+ *         event,
+ *       })
+ *       if (response) return response
+ *     }
+ *   ]
+ * })
+ * ```
+ */
+export declare function solidStartHandler(options: SolidStartHandlerOptions): Response | Promise<Response> | undefined;
+//# sourceMappingURL=solid-start.d.ts.map

package/dist/server/adapters/solid-start.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solid-start.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/solid-start.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAM1F;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa,GAAG,kBAAkB,CA0C5E;AA2BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,wBAAwB,GAC/B,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,GAAG,SAAS,CA0C1C"}

package/dist/server/adapters/solid-start.js

@@ -0,0 +1,551 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/shared/constants.ts
+var ROUTES = {
+  ACTIVITY: "/activity",
+  IDENTITY: {
+    SIGNIN: "/identity/signin",
+    SIGNOUT: "/identity/signout",
+    CALLBACK: "/identity/callback"
+  },
+  USER: {
+    ME: "/user/me"
+  }
+};
+
+// ../internal/logger/src/debug.ts
+var patterns = null;
+var debugAll = false;
+var debugEnvSet = false;
+function patternToRegex(pattern) {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  const regexStr = escaped.replace(/\*/g, ".*");
+  return new RegExp(`^${regexStr}$`);
+}
+function parseDebugEnv() {
+  if (patterns !== null)
+    return;
+  patterns = [];
+  if (typeof process === "undefined" || !process.env?.DEBUG) {
+    debugEnvSet = false;
+    return;
+  }
+  debugEnvSet = true;
+  const debugValue = process.env.DEBUG.trim();
+  if (debugValue === "1" || debugValue === "true" || debugValue === "*") {
+    debugAll = true;
+    return;
+  }
+  const parts = debugValue.split(",").map((p) => p.trim()).filter(Boolean);
+  for (const part of parts) {
+    if (part.startsWith("-")) {
+      patterns.push({
+        regex: patternToRegex(part.slice(1)),
+        exclude: true
+      });
+    } else {
+      patterns.push({
+        regex: patternToRegex(part),
+        exclude: false
+      });
+    }
+  }
+  const hasInclude = patterns.some((p) => !p.exclude);
+  if (!hasInclude && patterns.length > 0) {
+    debugAll = true;
+  }
+}
+function shouldShowDebug(scope) {
+  parseDebugEnv();
+  if (!debugEnvSet) {
+    return true;
+  }
+  if (debugAll) {
+    if (scope) {
+      for (const pattern of patterns) {
+        if (pattern.exclude && pattern.regex.test(scope)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  if (!scope) {
+    return false;
+  }
+  for (const pattern of patterns) {
+    if (pattern.exclude && pattern.regex.test(scope)) {
+      return false;
+    }
+  }
+  for (const pattern of patterns) {
+    if (!pattern.exclude && pattern.regex.test(scope)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// ../internal/logger/src/env.ts
+function isBrowser() {
+  return typeof globalThis !== "undefined" && "window" in globalThis;
+}
+function detectEnvironment() {
+  if (isBrowser()) {
+    return "browser";
+  }
+  if (typeof process !== "undefined" && process.env) {
+    if (process.env["NODE_ENV"] === "test" || process.env["BUN_ENV"] === "test") {
+      return "test";
+    }
+    if (false) {}
+    if (process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.CIRCLECI || process.env.JENKINS_URL || process.env.BUILDKITE) {
+      return "ci";
+    }
+  }
+  return "terminal";
+}
+
+// ../internal/logger/src/formatters/terminal.ts
+var nodeInspect;
+if (!isBrowser()) {
+  try {
+    const util = await import("node:util");
+    nodeInspect = util.inspect;
+  } catch {}
+}
+var colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m"
+};
+function getLevelColor(level) {
+  switch (level) {
+    case "debug":
+      return colors.blue;
+    case "info":
+      return colors.cyan;
+    case "warn":
+      return colors.yellow;
+    case "error":
+      return colors.red;
+  }
+}
+function getConsoleMethod(level) {
+  switch (level) {
+    case "debug":
+      return console.debug;
+    case "info":
+      return console.info;
+    case "warn":
+      return console.warn;
+    case "error":
+      return console.error;
+  }
+}
+function formatContext(context) {
+  if (nodeInspect) {
+    return nodeInspect(context, {
+      depth: null,
+      colors: true,
+      breakLength: 80,
+      compact: false
+    });
+  }
+  return JSON.stringify(context, null, 2);
+}
+var terminalFormatter = (entry) => {
+  const levelColor = getLevelColor(entry.level);
+  const consoleMethod = getConsoleMethod(entry.level);
+  const levelUpper = entry.level.toUpperCase().padEnd(5);
+  const isoString = entry.timestamp.toISOString().replace(/\.\d{3}Z$/, "");
+  const timestamp = `${colors.dim}[${isoString}]${colors.reset}`;
+  const level = `${levelColor}${levelUpper}${colors.reset}`;
+  const scope = entry.scope ? `${colors.bold}[${entry.scope}]${colors.reset} ` : "";
+  const prefix = `${timestamp} ${level} ${scope}${entry.message}`;
+  if (entry.context && Object.keys(entry.context).length > 0) {
+    consoleMethod(prefix, formatContext(entry.context));
+  } else {
+    consoleMethod(prefix);
+  }
+};
+// ../internal/logger/src/formatters/ci.ts
+var LEVEL_PREFIX = {
+  debug: "[DEBUG]",
+  info: "[INFO]",
+  warn: "[WARN]",
+  error: "[ERROR]"
+};
+function formatContext2(context) {
+  return Object.entries(context).map(([key, value]) => `${key}=${formatValue(value)}`).join(" ");
+}
+function formatValue(value) {
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number")
+    return String(value);
+  if (typeof value === "boolean")
+    return String(value);
+  if (value === null)
+    return "null";
+  if (value === undefined)
+    return "undefined";
+  return JSON.stringify(value);
+}
+var ciFormatter = (entry) => {
+  const parts = [];
+  parts.push(entry.timestamp.toISOString());
+  parts.push(LEVEL_PREFIX[entry.level]);
+  if (entry.scope) {
+    parts.push(`[${entry.scope}]`);
+  }
+  parts.push(entry.message);
+  if (entry.context && Object.keys(entry.context).length > 0) {
+    parts.push(formatContext2(entry.context));
+  }
+  console.log(parts.join(" "));
+};
+// ../internal/logger/src/formatters/production.ts
+var productionFormatter = (entry) => {
+  const output = {
+    timestamp: entry.timestamp.toISOString(),
+    level: entry.level,
+    ...entry.scope && { scope: entry.scope },
+    msg: entry.message
+  };
+  if (entry.context && Object.keys(entry.context).length > 0) {
+    Object.assign(output, entry.context);
+  }
+  console.log(JSON.stringify(output));
+};
+// ../internal/logger/src/formatters/browser.ts
+var LEVEL_STYLES = {
+  debug: "color: gray",
+  info: "color: #0ea5e9",
+  warn: "color: #f59e0b",
+  error: "color: #ef4444; font-weight: bold"
+};
+var LEVEL_METHODS = {
+  debug: "log",
+  info: "info",
+  warn: "warn",
+  error: "error"
+};
+var browserFormatter = (entry) => {
+  const method = LEVEL_METHODS[entry.level];
+  const style = LEVEL_STYLES[entry.level];
+  const prefix = entry.scope ? `[${entry.scope}]` : "";
+  const label = `%c${prefix} ${entry.message}`;
+  if (entry.context && Object.keys(entry.context).length > 0) {
+    console[method](label, style, entry.context);
+  } else {
+    console[method](label, style);
+  }
+};
+// ../internal/logger/src/logger.ts
+var LOG_LEVELS = ["debug", "info", "warn", "error"];
+function getFormatter(env) {
+  switch (env) {
+    case "terminal":
+      return terminalFormatter;
+    case "ci":
+      return ciFormatter;
+    case "production":
+      return productionFormatter;
+    case "browser":
+      return browserFormatter;
+    case "test":
+      return () => {};
+  }
+}
+function getDefaultMinLevel() {
+  if (typeof process !== "undefined" && process.env?.DEBUG) {
+    return "debug";
+  }
+  return "info";
+}
+function shouldLog(level, minLevel) {
+  return LOG_LEVELS.indexOf(level) >= LOG_LEVELS.indexOf(minLevel);
+}
+
+class Logger {
+  scope;
+  minLevel;
+  environment;
+  formatter;
+  defaultContext;
+  constructor(options = {}) {
+    this.scope = options.scope;
+    this.minLevel = options.minLevel ?? getDefaultMinLevel();
+    this.defaultContext = options.defaultContext ?? {};
+    this.environment = options.environment ?? detectEnvironment();
+    this.formatter = getFormatter(this.environment);
+  }
+  child(scope) {
+    const childScope = this.scope ? `${this.scope}:${scope}` : scope;
+    return new Logger({
+      scope: childScope,
+      minLevel: this.minLevel,
+      environment: this.environment,
+      defaultContext: { ...this.defaultContext }
+    });
+  }
+  withContext(context) {
+    return new Logger({
+      scope: this.scope,
+      minLevel: this.minLevel,
+      environment: this.environment,
+      defaultContext: { ...this.defaultContext, ...context }
+    });
+  }
+  debug(message, context) {
+    this.log("debug", message, context);
+  }
+  info(message, context) {
+    this.log("info", message, context);
+  }
+  warn(message, context) {
+    this.log("warn", message, context);
+  }
+  error(message, context) {
+    this.log("error", message, context);
+  }
+  log(level, message, context) {
+    if (level === "debug" && !shouldShowDebug(this.scope)) {
+      return;
+    }
+    if (!shouldLog(level, this.minLevel)) {
+      return;
+    }
+    const entry = {
+      level,
+      message,
+      scope: this.scope,
+      context: context || Object.keys(this.defaultContext).length > 0 ? { ...this.defaultContext, ...context } : undefined,
+      timestamp: new Date
+    };
+    this.formatter(entry);
+  }
+}
+function createLogger(options = {}) {
+  return new Logger(options);
+}
+// src/server/lib/logger.ts
+function isDebug() {
+  try {
+    const debug = typeof process === "undefined" ? undefined : process.env.DEBUG;
+    return debug === "1" || debug === "true";
+  } catch {
+    return false;
+  }
+}
+function createScopedLogger(scope) {
+  return createLogger({
+    scope: `timeback:${scope}`,
+    minLevel: isDebug() ? "debug" : "warn"
+  });
+}
+var ssoLog = createScopedLogger("sso");
+var oidcLog = createScopedLogger("oidc");
+
+// src/server/lib/oidc.ts
+var discoveryCache = new Map;
+async function fetchDiscoveryDocument(issuer) {
+  const cached = discoveryCache.get(issuer);
+  if (cached) {
+    return cached;
+  }
+  const url = `${issuer}/.well-known/openid-configuration`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    oidcLog.error("Discovery fetch failed", { status: response.status });
+    throw new Error(`Failed to fetch OIDC discovery: ${response.statusText}`);
+  }
+  const doc = await response.json();
+  oidcLog.debug("Fetched OIDC discovery document", {
+    authEndpoint: doc.authorization_endpoint,
+    tokenEndpoint: doc.token_endpoint
+  });
+  discoveryCache.set(issuer, doc);
+  return doc;
+}
+function getIssuer(env) {
+  switch (env) {
+    case "production":
+      return "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_3uhuoRM3R";
+    case "staging":
+      return "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_5EUwTP9XD";
+    case "local":
+      throw new Error("Local environment is not yet supported for OIDC");
+  }
+}
+async function buildAuthorizationUrl(params) {
+  const discovery = await fetchDiscoveryDocument(params.issuer);
+  const url = new URL(discovery.authorization_endpoint);
+  url.searchParams.set("response_type", "code");
+  url.searchParams.set("client_id", params.clientId);
+  url.searchParams.set("redirect_uri", params.redirectUri);
+  url.searchParams.set("scope", "openid profile email");
+  url.searchParams.set("state", params.state);
+  return url.toString();
+}
+async function exchangeCodeForTokens(params) {
+  const discovery = await fetchDiscoveryDocument(params.issuer);
+  const response = await fetch(discovery.token_endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: params.clientId,
+      client_secret: params.clientSecret,
+      code: params.code,
+      redirect_uri: params.redirectUri
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    oidcLog.error("Token exchange failed", { status: response.status, body: text });
+    throw new Error(`Token exchange failed: ${response.status} ${text}`);
+  }
+  const tokens = await response.json();
+  oidcLog.debug("Received tokens from IdP", { expiresIn: tokens.expires_in });
+  return tokens;
+}
+async function getUserInfo(params) {
+  const discovery = await fetchDiscoveryDocument(params.issuer);
+  const response = await fetch(discovery.userinfo_endpoint, {
+    headers: {
+      Authorization: `Bearer ${params.accessToken}`
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`UserInfo request failed: ${response.statusText}`);
+  }
+  return response.json();
+}
+// src/server/lib/utils.ts
+function jsonResponse(data, status = 200, headers) {
+  const responseHeaders = new Headers(headers);
+  responseHeaders.set("Content-Type", "application/json");
+  return new Response(JSON.stringify(data), { status, headers: responseHeaders });
+}
+function redirectResponse(url, headers) {
+  const responseHeaders = new Headers(headers);
+  responseHeaders.set("Location", url);
+  return new Response(null, { status: 302, headers: responseHeaders });
+}
+function encodeBase64Url(data) {
+  const json = JSON.stringify(data);
+  return btoa(json).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function decodeBase64Url(encoded) {
+  const padded = encoded.replace(/-/g, "+").replace(/_/g, "/");
+  const json = atob(padded);
+  return JSON.parse(json);
+}
+// src/server/adapters/utils.ts
+function getHandlers(input) {
+  return "handle" in input ? input.handle : input;
+}
+
+// src/server/adapters/solid-start.ts
+function toSolidStartHandler(input) {
+  const handle = getHandlers(input);
+  const routeHandler = (event) => {
+    const url = new URL(event.request.url);
+    const path = url.pathname;
+    const method = event.request.method;
+    if (method === "GET") {
+      if (path.endsWith(ROUTES.IDENTITY.SIGNIN)) {
+        return handle.identity.signIn(event.request);
+      }
+      if (path.endsWith(ROUTES.IDENTITY.CALLBACK)) {
+        return handle.identity.callback(event.request);
+      }
+      if (path.endsWith(ROUTES.IDENTITY.SIGNOUT)) {
+        return handle.identity.signOut();
+      }
+      if (path.endsWith(ROUTES.USER.ME)) {
+        return handle.user.me(event.request);
+      }
+    }
+    if (method === "POST") {
+      if (path.endsWith(ROUTES.ACTIVITY)) {
+        return handle.activity(event.request);
+      }
+    }
+    return jsonResponse({ error: "Not found" }, 404);
+  };
+  return {
+    GET: routeHandler,
+    POST: routeHandler,
+    PUT: routeHandler,
+    DELETE: routeHandler,
+    PATCH: routeHandler
+  };
+}
+function isTimebackPath(pathname, basePath) {
+  const normalizedBase = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+  return pathname.startsWith(`${normalizedBase}/`) || pathname === normalizedBase || pathname.endsWith(ROUTES.IDENTITY.SIGNIN) || pathname.endsWith(ROUTES.IDENTITY.CALLBACK) || pathname.endsWith(ROUTES.IDENTITY.SIGNOUT) || pathname.endsWith(ROUTES.ACTIVITY) || pathname.endsWith(ROUTES.USER.ME);
+}
+function solidStartHandler(options) {
+  const { timeback, event, basePath = "/api/timeback", callbackPath } = options;
+  const request = event.request;
+  const url = new URL(request.url);
+  const handle = getHandlers(timeback);
+  const path = url.pathname;
+  const method = request.method;
+  if (callbackPath && path === callbackPath && method === "GET") {
+    return handle.identity.callback(request);
+  }
+  if (!isTimebackPath(path, basePath)) {
+    return;
+  }
+  if (method === "GET") {
+    if (path.endsWith(ROUTES.IDENTITY.SIGNIN)) {
+      return handle.identity.signIn(request);
+    }
+    if (path.endsWith(ROUTES.IDENTITY.CALLBACK)) {
+      return handle.identity.callback(request);
+    }
+    if (path.endsWith(ROUTES.IDENTITY.SIGNOUT)) {
+      return handle.identity.signOut();
+    }
+    if (path.endsWith(ROUTES.USER.ME)) {
+      return handle.user.me(request);
+    }
+  }
+  if (method === "POST") {
+    if (path.endsWith(ROUTES.ACTIVITY)) {
+      return handle.activity(request);
+    }
+  }
+  return;
+}
+export {
+  toSolidStartHandler,
+  solidStartHandler
+};

package/dist/server/adapters/svelte-kit.d.ts

@@ -0,0 +1,82 @@
+/**
+ * SvelteKit Adapter
+ *
+ * Adapts Timeback handlers for SvelteKit.
+ * Supports both hooks-based (recommended) and route-based approaches.
+ */
+import type { SvelteKitHandlerOptions, SvelteKitHandlers, SvelteKitRequestEvent, TimebackInput } from './types';
+/**
+ * SvelteKit server hook handler for Timeback.
+ *
+ * This is the **recommended** approach for SvelteKit integration.
+ * It intercepts requests at the hooks level, providing deeper integration
+ * with SvelteKit's request lifecycle.
+ *
+ * @param options - Handler options
+ * @returns Response from either Timeback or the resolve chain
+ *
+ * @example
+ * ```typescript
+ * // hooks.server.ts
+ * import { timeback } from '$lib/timeback'
+ * import { svelteKitHandler } from 'timeback/svelte-kit'
+ * import { building } from '$app/environment'
+ *
+ * export async function handle({ event, resolve }) {
+ *   return svelteKitHandler({
+ *     timeback,
+ *     event,
+ *     resolve,
+ *     building,
+ *   })
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // hooks.server.ts - with session in event.locals
+ * import { timeback } from '$lib/timeback'
+ * import { svelteKitHandler } from 'timeback/svelte-kit'
+ * import { building } from '$app/environment'
+ *
+ * export async function handle({ event, resolve }) {
+ *   // Optionally populate event.locals with user session
+ *   // const session = await getSessionFromCookie(event.cookies)
+ *   // if (session) {
+ *   //   event.locals.user = session.user
+ *   // }
+ *
+ *   return svelteKitHandler({
+ *     timeback,
+ *     event,
+ *     resolve,
+ *     building,
+ *   })
+ * }
+ * ```
+ */
+export declare function svelteKitHandler<TEvent extends SvelteKitRequestEvent>(options: SvelteKitHandlerOptions<TEvent>): Promise<Response>;
+/**
+ * Convert Timeback instance to SvelteKit route handlers.
+ *
+ * This is an **alternative** approach using SvelteKit's route handlers.
+ * Use this if you prefer explicit route files over hooks.
+ *
+ * Accepts either the full Timeback instance or just the handlers:
+ * - `toSvelteKitHandler(timeback)`
+ * - `toSvelteKitHandler(timeback.handle)`
+ *
+ * @param input - Timeback instance or handlers
+ * @returns Object with HTTP method handlers for SvelteKit
+ *
+ * @example
+ * ```typescript
+ * // src/routes/api/timeback/[...path]/+server.ts
+ * import { timeback } from '$lib/timeback'
+ * import { toSvelteKitHandler } from 'timeback/svelte-kit'
+ *
+ * export const { GET, POST } = toSvelteKitHandler(timeback)
+ * ```
+ */
+export declare function toSvelteKitHandler(input: TimebackInput): SvelteKitHandlers;
+//# sourceMappingURL=svelte-kit.d.ts.map

package/dist/server/adapters/svelte-kit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svelte-kit.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/svelte-kit.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EACX,uBAAuB,EACvB,iBAAiB,EACjB,qBAAqB,EAErB,aAAa,EACb,MAAM,SAAS,CAAA;AA2BhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,SAAS,qBAAqB,EAC1E,OAAO,EAAE,uBAAuB,CAAC,MAAM,CAAC,GACtC,OAAO,CAAC,QAAQ,CAAC,CA4EnB;AAMD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa,GAAG,iBAAiB,CAgB1E"}