@bgord/bun 1.6.7 → 1.7.0

package/src/shield-auth.strategy.ts

@@ -0,0 +1,42 @@
+// TODO: tests
+
+import type { betterAuth } from "better-auth";
+import type hono from "hono";
+import { createMiddleware } from "hono/factory";
+import { HTTPException } from "hono/http-exception";
+
+export const ShieldAuthStrategyError = new HTTPException(403, { message: "access_denied_auth_shield" });
+
+export class ShieldAuthStrategy {
+  constructor(private readonly Auth: ReturnType<typeof betterAuth>) {}
+
+  attach = createMiddleware(async (c: hono.Context, next: hono.Next) => {
+    const session = await this.Auth.api.getSession({ headers: c.req.raw.headers });
+
+    if (!session) {
+      c.set("user", null);
+      c.set("session", null);
+
+      return next();
+    }
+
+    c.set("user", session.user);
+    c.set("session", session.session);
+
+    return next();
+  });
+
+  verify = createMiddleware(async (c: hono.Context, next: hono.Next) => {
+    const user = c.get("user");
+
+    if (!user) throw ShieldAuthStrategyError;
+    return next();
+  });
+
+  reverse = createMiddleware(async (c: hono.Context, next: hono.Next) => {
+    const user = c.get("user");
+
+    if (user) throw ShieldAuthStrategyError;
+    return next();
+  });
+}

package/src/shield-basic-auth.strategy.ts

@@ -0,0 +1,17 @@
+import { basicAuth } from "hono/basic-auth";
+import { createMiddleware } from "hono/factory";
+import type { BasicAuthPasswordType } from "./basic-auth-password.vo";
+import type { BasicAuthUsernameType } from "./basic-auth-username.vo";
+import type { ShieldStrategy } from "./shield.strategy";
+
+type ShieldBasicAuthConfigType = { username: BasicAuthUsernameType; password: BasicAuthPasswordType };
+
+export class ShieldBasicAuthStrategy implements ShieldStrategy {
+  private readonly basicAuth;
+
+  constructor(config: ShieldBasicAuthConfigType) {
+    this.basicAuth = basicAuth(config);
+  }
+
+  verify = createMiddleware(async (c, next) => this.basicAuth(c, next));
+}

package/src/shield-captcha-hcaptcha-local.strategy.ts

@@ -0,0 +1,24 @@
+import hcaptcha from "hcaptcha";
+import { createMiddleware } from "hono/factory";
+import { HTTPException } from "hono/http-exception";
+import type { HCaptchaSecretKeyType } from "./hcaptcha-secret-key.vo";
+import type { ShieldStrategy } from "./shield.strategy";
+
+export const AccessDeniedHcaptchaLocalError = new HTTPException(403, {
+  message: "access_denied_hcaptcha_local",
+});
+
+export class ShieldCaptchaHcaptchaLocalStrategy implements ShieldStrategy {
+  constructor(private readonly secretKey: HCaptchaSecretKeyType) {}
+
+  verify = createMiddleware(async (_c, next) => {
+    try {
+      const result = await hcaptcha.verify(this.secretKey, "10000000-aaaa-bbbb-cccc-000000000001");
+
+      if (!result?.success) throw AccessDeniedHcaptchaLocalError;
+      return next();
+    } catch {
+      throw AccessDeniedHcaptchaLocalError;
+    }
+  });
+}

package/src/shield-captcha-hcaptcha.strategy.ts

@@ -0,0 +1,24 @@
+import hcaptcha from "hcaptcha";
+import { createMiddleware } from "hono/factory";
+import { HTTPException } from "hono/http-exception";
+import type { HCaptchaSecretKeyType } from "./hcaptcha-secret-key.vo";
+import type { ShieldStrategy } from "./shield.strategy";
+
+export const AccessDeniedHcaptchaError = new HTTPException(403, { message: "access_denied_hcaptcha" });
+
+export class ShieldCaptchaHcaptchaStrategy implements ShieldStrategy {
+  constructor(private readonly secretKey: HCaptchaSecretKeyType) {}
+
+  verify = createMiddleware(async (c, next) => {
+    try {
+      const form = await c.req.formData();
+      const hcaptchaTokenFormData = form.get("h-captcha-response")?.toString() as string;
+      const result = await hcaptcha.verify(this.secretKey, hcaptchaTokenFormData);
+
+      if (!result?.success) throw AccessDeniedHcaptchaError;
+      return next();
+    } catch {
+      throw AccessDeniedHcaptchaError;
+    }
+  });
+}

package/src/shield-captcha-recaptcha.strategy.ts

@@ -0,0 +1,49 @@
+import * as tools from "@bgord/tools";
+import { createMiddleware } from "hono/factory";
+import { HTTPException } from "hono/http-exception";
+import type { RecaptchaSecretKeyType } from "./recaptcha-secret-key.vo";
+import type { ShieldStrategy } from "./shield.strategy";
+
+export type RecaptchaVerifierConfigType = { secretKey: RecaptchaSecretKeyType };
+export type RecaptchaResultType = { success: boolean; score: number };
+
+export const AccessDeniedRecaptchaError = new HTTPException(403, { message: "access_denied_recaptcha" });
+
+export class ShieldCaptchaRecaptchaStrategy implements ShieldStrategy {
+  private static readonly URL = tools.UrlWithoutSlash.parse(
+    "https://www.google.com/recaptcha/api/siteverify",
+  );
+
+  constructor(private readonly config: RecaptchaVerifierConfigType) {}
+
+  verify = createMiddleware(async (c, next) => {
+    try {
+      const header = c.req.header("x-recaptcha-token");
+      const query = c.req.query("recaptchaToken");
+      const form = (await c.req.formData()).get("g-recaptcha-response")?.toString();
+
+      const token = header ?? query ?? form;
+
+      if (!token) throw AccessDeniedRecaptchaError;
+
+      // cSpell:ignore remoteip
+      const remoteip = c.req.header("x-forwarded-for") ?? "";
+
+      const params = new URLSearchParams({ secret: this.config.secretKey, response: token, remoteip });
+
+      const response = await fetch(ShieldCaptchaRecaptchaStrategy.URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: params,
+      });
+
+      const result: RecaptchaResultType = await response.json();
+
+      if (!result.success || result.score < 0.5) throw AccessDeniedRecaptchaError;
+
+      await next();
+    } catch {
+      throw AccessDeniedRecaptchaError;
+    }
+  });
+}

package/src/shield-noop.strategy.ts

@@ -0,0 +1,6 @@
+import { createMiddleware } from "hono/factory";
+import type { ShieldStrategy } from "./shield.strategy";
+
+export class ShieldNoopStrategy implements ShieldStrategy {
+  verify = createMiddleware(async (_c, next) => next());
+}

package/src/shield-rate-limit.strategy.ts

@@ -0,0 +1,41 @@
+import * as tools from "@bgord/tools";
+import { createMiddleware } from "hono/factory";
+import { HTTPException } from "hono/http-exception";
+import type { CacheResolverStrategy } from "./cache-resolver.strategy";
+import type { CacheSubjectResolver } from "./cache-subject-resolver.vo";
+import type { ClockPort } from "./clock.port";
+import type { ShieldStrategy } from "./shield.strategy";
+
+type ShieldRateLimitOptionsType = {
+  enabled: boolean;
+  resolver: CacheSubjectResolver;
+  window: tools.Duration;
+};
+
+type Dependencies = { Clock: ClockPort; CacheResolver: CacheResolverStrategy };
+
+export const TooManyRequestsError = new HTTPException(429, { message: "app.too_many_requests" });
+
+export class ShieldRateLimitStrategy implements ShieldStrategy {
+  constructor(
+    private readonly options: ShieldRateLimitOptionsType,
+    private readonly deps: Dependencies,
+  ) {}
+
+  verify = createMiddleware(async (c, next) => {
+    if (!this.options.enabled) return next();
+
+    const subject = await this.options.resolver.resolve(c);
+
+    const limiter = await this.deps.CacheResolver.resolve(
+      subject.hex,
+      async () => new tools.RateLimiter(this.options.window),
+    );
+
+    const result = limiter.verify(this.deps.Clock.now());
+
+    if (!result.allowed) throw TooManyRequestsError;
+
+    return next();
+  });
+}

package/src/shield-security.strategy.ts

@@ -0,0 +1,71 @@
+import { createMiddleware } from "hono/factory";
+import type { ContentfulStatusCode } from "hono/utils/http-status";
+import { ClientFromHono } from "./client-from-hono.adapter";
+import { SecurityContext } from "./security-context.vo";
+import type { SecurityPolicy } from "./security-policy.vo";
+import type { ShieldStrategy } from "./shield.strategy";
+import type { SleeperPort } from "./sleeper.port";
+
+type Dependencies = { Sleeper: SleeperPort };
+
+export const ShieldSecurityAdapterError = {
+  Unhandled: "shield.security.adapter.error.unhandled",
+  MissingPolicies: "shield.security.adapter.error.missing.policies",
+  MaxPolicies: "shield.security.adapter.error.max.policies",
+};
+
+export class ShieldSecurityStrategy implements ShieldStrategy {
+  constructor(
+    private readonly policies: SecurityPolicy[],
+    private readonly deps: Dependencies,
+  ) {
+    if (policies.length === 0) throw new Error(ShieldSecurityAdapterError.MissingPolicies);
+    if (policies.length > 5) throw new Error(ShieldSecurityAdapterError.MaxPolicies);
+  }
+
+  verify = createMiddleware(async (c, next) => {
+    for (const policy of this.policies) {
+      const violation = await policy.rule.isViolated(c);
+
+      if (!violation) continue;
+
+      const context = new SecurityContext(policy.rule.name, ClientFromHono.translate(c), c.get("user")?.id);
+
+      const action = await policy.countermeasure.execute(context);
+
+      switch (action.kind) {
+        case "allow":
+          return next();
+
+        case "deny":
+          return c.text(action.reason, action.response.status as ContentfulStatusCode);
+
+        case "mirage":
+          return c.json({}, action.response.status as ContentfulStatusCode);
+
+        case "delay": {
+          await this.deps.Sleeper.wait(action.duration);
+
+          switch (action.after.kind) {
+            case "allow":
+              return next();
+
+            case "deny":
+              return c.text(action.after.reason, action.after.response.status as ContentfulStatusCode);
+
+            case "mirage":
+              return c.json({}, action.after.response.status as ContentfulStatusCode);
+
+            case "delay":
+              throw new Error(ShieldSecurityAdapterError.Unhandled);
+
+            default:
+              throw new Error(ShieldSecurityAdapterError.Unhandled);
+          }
+        }
+      }
+    }
+
+    return next();
+  });
+}

package/src/shield-timeout.strategy.ts

@@ -0,0 +1,19 @@
+import type * as tools from "@bgord/tools";
+import { createMiddleware } from "hono/factory";
+import { HTTPException } from "hono/http-exception";
+import { timeout } from "hono/timeout";
+import type { ShieldStrategy } from "./shield.strategy";
+
+export const RequestTimeoutError = new HTTPException(408, { message: "request_timeout_error" });
+
+type ShieldTimeoutConfigType = { duration: tools.Duration };
+
+export class ShieldTimeoutStrategy implements ShieldStrategy {
+  private readonly timeout;
+
+  constructor(config: ShieldTimeoutConfigType) {
+    this.timeout = timeout(config.duration.ms, RequestTimeoutError);
+  }
+
+  verify = createMiddleware(async (c, next) => this.timeout(c, next));
+}

package/src/shield.strategy.ts

@@ -0,0 +1,5 @@
+import type { MiddlewareHandler } from "hono";
+
+export interface ShieldStrategy {
+  verify: MiddlewareHandler;
+}

package/src/sleeper-noop.adapter.ts

@@ -0,0 +1,5 @@
+import type { SleeperPort } from "./sleeper.port";
+
+export class SleeperNoopAdapter implements SleeperPort {
+  async wait() {}
+}

package/src/sleeper-system.adapter.ts

@@ -0,0 +1,8 @@
+import type * as tools from "@bgord/tools";
+import type { SleeperPort } from "./sleeper.port";
+
+export class SleeperSystemAdapter implements SleeperPort {
+  async wait(duration: tools.Duration) {
+    await Bun.sleep(duration.ms);
+  }
+}

package/src/sleeper.port.ts

@@ -0,0 +1,5 @@
+import type * as tools from "@bgord/tools";
+
+export interface SleeperPort {
+  wait(duration: tools.Duration): Promise<void>;
+}

package/src/slower.middleware.ts

@@ -1,10 +1,13 @@
 import type * as tools from "@bgord/tools";
 import { createMiddleware } from "hono/factory";
+import type { SleeperPort } from "./sleeper.port";
+
+type Dependencies = { Sleeper: SleeperPort };
 
 export class Slower {
-  static handle = (offset: tools.Duration) =>
+  static handle = (offset: tools.Duration, deps: Dependencies) =>
     createMiddleware(async (_c, next) => {
-      await Bun.sleep(offset.ms);
+      await deps.Sleeper.wait(offset);
 
       return next();
     });

package/src/stopwatch.service.ts

@@ -0,0 +1,30 @@
+import type * as tools from "@bgord/tools";
+import type { ClockPort } from "./clock.port";
+
+type Dependencies = { Clock: ClockPort };
+
+export const StopwatchError = { AlreadyStopped: "stopwatch.already.stopped" };
+
+enum StopwatchState {
+  started = "started",
+  stopped = "stopped",
+}
+
+export type StopwatchResultType = tools.Duration;
+
+export class Stopwatch {
+  private state: StopwatchState = StopwatchState.started;
+  private readonly start: tools.Timestamp;
+
+  constructor(private readonly deps: Dependencies) {
+    this.start = deps.Clock.now();
+  }
+
+  stop(): StopwatchResultType {
+    if (this.state === StopwatchState.stopped) throw new Error(StopwatchError.AlreadyStopped);
+
+    this.state = StopwatchState.stopped;
+
+    return this.deps.Clock.now().difference(this.start);
+  }
+}

package/src/time-zone-offset.middleware.ts

@@ -4,11 +4,20 @@ import { createMiddleware } from "hono/factory";
 export type TimeZoneOffsetVariables = { timeZoneOffset: tools.Duration };
 
 export class TimeZoneOffset {
-  static TIME_ZONE_OFFSET_HEADER_NAME = "time-zone-offset";
+  static readonly TIME_ZONE_OFFSET_HEADER_NAME = "time-zone-offset";
+
+  static readonly DEFAULT = tools.Duration.Minutes(0);
 
   static attach = createMiddleware(async (c, next) => {
-    const offset = tools.TimeZoneOffsetValue.parse(c.req.header(TimeZoneOffset.TIME_ZONE_OFFSET_HEADER_NAME));
-    c.set("timeZoneOffset", tools.Duration.Minutes(offset));
+    const header = c.req.header(TimeZoneOffset.TIME_ZONE_OFFSET_HEADER_NAME);
+
+    if (!header) c.set("timeZoneOffset", TimeZoneOffset.DEFAULT);
+    if (Number.isNaN(Number(header))) c.set("timeZoneOffset", TimeZoneOffset.DEFAULT);
+
+    const offset = tools.TimeZoneOffsetValue.safeParse(header);
+
+    if (!offset.success) c.set("timeZoneOffset", TimeZoneOffset.DEFAULT);
+    else c.set("timeZoneOffset", tools.Duration.Minutes(offset.data));
 
     await next();
   });

package/src/timekeeper-google.adapter.ts

@@ -7,12 +7,13 @@ export class TimekeeperGoogleAdapter implements TimekeeperPort {
   async get(signal?: AbortSignal) {
     try {
       const response = await fetch(TimekeeperGoogleAdapter.URL, { signal });
+
       if (!response.ok) return null;
 
       const date = response.headers.get("Date");
-      if (!date) return null;
 
-      return tools.Timestamp.fromNumber(new Date(date).getTime());
+      if (!date) return null;
+      return tools.Timestamp.fromDateLike(date);
     } catch (error) {
       return null;
     }

package/src/timeout-cancellable-runner-bare.adapter.ts

@@ -0,0 +1,35 @@
+import type * as tools from "@bgord/tools";
+import {
+  TimeoutCancellableError,
+  type TimeoutCancellableRunnerPort,
+} from "./timeout-cancellable-runner.port";
+
+export class TimeoutCancellableRunnerBare implements TimeoutCancellableRunnerPort {
+  async cancellable<T>(action: (signal: AbortSignal) => Promise<T>, timeout: tools.Duration): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
+      const controller = new AbortController();
+
+      const reason = new Error(TimeoutCancellableError.Exceeded);
+
+      const canceller = setTimeout(() => {
+        controller.abort(reason);
+        reject(reason);
+      }, timeout.ms);
+
+      // Promise.resolve.then used to prevent the initial action(controller.signal) call
+      // from throwing before the resulting work-promise is run by promise.then.
+      const promise: Promise<T> = Promise.resolve().then(() => action(controller.signal));
+
+      promise.then(
+        (value) => {
+          clearTimeout(canceller);
+          resolve(value);
+        },
+        (error) => {
+          clearTimeout(canceller);
+          reject(error);
+        },
+      );
+    });
+  }
+}

package/src/timeout-cancellable-runner-noop.adapter.ts

@@ -0,0 +1,9 @@
+import type { TimeoutCancellableRunnerPort } from "./timeout-cancellable-runner.port";
+
+export class TimeoutCancellableRunnerNoop implements TimeoutCancellableRunnerPort {
+  async cancellable<T>(action: (signal: AbortSignal) => Promise<T>): Promise<T> {
+    const controller = new AbortController();
+
+    return action(controller.signal);
+  }
+}

package/src/timeout-cancellable-runner.port.ts

@@ -0,0 +1,7 @@
+import type * as tools from "@bgord/tools";
+
+export const TimeoutCancellableError = { Exceeded: "timeout.cancellable.exceeded" };
+
+export interface TimeoutCancellableRunnerPort {
+  cancellable<T>(action: (signal: AbortSignal) => Promise<T>, timeout: tools.Duration): Promise<T>;
+}

package/src/timeout-runner-bare.adapter.ts

@@ -0,0 +1,23 @@
+import type * as tools from "@bgord/tools";
+import { TimeoutError, type TimeoutRunnerPort } from "./timeout-runner.port";
+
+export class TimeoutRunnerBareAdapter implements TimeoutRunnerPort {
+  async run<T>(action: Promise<T>, timeout: tools.Duration): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
+      const reason = new Error(TimeoutError.Exceeded);
+
+      const canceller = setTimeout(() => reject(reason), timeout.ms);
+
+      action.then(
+        (value) => {
+          clearTimeout(canceller);
+          resolve(value);
+        },
+        (error) => {
+          clearTimeout(canceller);
+          reject(error);
+        },
+      );
+    });
+  }
+}

package/src/timeout-runner-error.adapter.ts

@@ -0,0 +1,8 @@
+import type * as tools from "@bgord/tools";
+import { TimeoutError, type TimeoutRunnerPort } from "./timeout-runner.port";
+
+export class TimeoutRunnerErrorAdapter implements TimeoutRunnerPort {
+  async run<T>(_action: Promise<T>, _timeout: tools.Duration): Promise<T> {
+    throw new Error(TimeoutError.Exceeded);
+  }
+}

package/src/timeout-runner-monitor.adapter.ts

@@ -0,0 +1,24 @@
+import type * as tools from "@bgord/tools";
+import type { LoggerPort } from "./logger.port";
+import type { TimeoutRunnerPort } from "./timeout-runner.port";
+
+type Dependencies = { Logger: LoggerPort };
+
+export class TimeoutRunnerMonitorAdapter implements TimeoutRunnerPort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async run<T>(action: Promise<T>, timeout: tools.Duration): Promise<T> {
+    const monitor = setTimeout(
+      () =>
+        this.deps.Logger.warn({
+          message: "Timeout",
+          component: "infra",
+          operation: "timeout_monitor",
+          metadata: { timeoutMs: timeout.ms },
+        }),
+      timeout.ms,
+    );
+
+    return action.finally(() => clearTimeout(monitor));
+  }
+}

package/src/timeout-runner-noop.adapter.ts

@@ -0,0 +1,8 @@
+import type * as tools from "@bgord/tools";
+import type { TimeoutRunnerPort } from "./timeout-runner.port";
+
+export class TimeoutRunnerNoopAdapter implements TimeoutRunnerPort {
+  async run<T>(action: Promise<T>, _timeout: tools.Duration): Promise<T> {
+    return action;
+  }
+}

package/src/timeout-runner.port.ts

@@ -0,0 +1,7 @@
+import type * as tools from "@bgord/tools";
+
+export const TimeoutError = { Exceeded: "timeout.exceeded" };
+
+export interface TimeoutRunnerPort {
+  run<T>(action: Promise<T>, timeout: tools.Duration): Promise<T>;
+}

package/src/translations.service.ts

@@ -1,13 +1,13 @@
 import { createFactory } from "hono/factory";
+import type { FileReaderJsonPort } from "./file-reader-json.port";
 import { I18n, type TranslationsSupportedLanguagesType } from "./i18n.service";
-import type { JsonFileReaderPort } from "./json-file-reader.port";
 import type { LoggerPort } from "./logger.port";
 
 const handler = createFactory();
 
 type Config = TranslationsSupportedLanguagesType;
 
-type Dependencies = { JsonFileReader: JsonFileReaderPort; Logger: LoggerPort };
+type Dependencies = { JsonFileReader: FileReaderJsonPort; Logger: LoggerPort };
 
 export class Translations {
   static build = (config: Config, deps: Dependencies) =>

package/src/uptime.service.ts

@@ -7,7 +7,7 @@ export type UptimeResultType = {
 };
 
 export class Uptime {
-  private static readonly rounding = new tools.RoundToNearest();
+  private static readonly rounding = new tools.RoundingToNearestStrategy();
 
   static get(clock: ClockPort): UptimeResultType {
     const duration = tools.Duration.Seconds(Uptime.rounding.round(process.uptime()));

package/src/visitor-id-client.strategy.ts

@@ -0,0 +1,20 @@
+import type { Client } from "./client.vo";
+import type { HashContentStrategy } from "./hash-content.strategy";
+import type { VisitorIdStrategy } from "./visitor-id.strategy";
+
+type Dependencies = { HashContent: HashContentStrategy };
+
+export class VisitorIdClientStrategy implements VisitorIdStrategy {
+  constructor(
+    private readonly client: Client,
+    private readonly deps: Dependencies,
+  ) {}
+
+  async get() {
+    const { ip, ua } = this.client.toJSON();
+
+    const value = `${ip}|${ua}`;
+
+    return this.deps.HashContent.hash(value);
+  }
+}

package/src/visitor-id.strategy.ts

@@ -0,0 +1,5 @@
+import type { Hash } from "./hash.vo";
+
+export interface VisitorIdStrategy {
+  get(): Promise<Hash>;
+}

package/dist/cache-resolver-simple.adapter.d.ts

@@ -1,19 +0,0 @@
-import type { CacheRepositoryPort } from "./cache-repository.port";
-import { type CacheResolverPort, CacheSourceEnum } from "./cache-resolver.port";
-import type { Hash } from "./hash.vo";
-type Dependencies = {
-    CacheRepository: CacheRepositoryPort;
-};
-export declare class CacheResolverSimpleAdapter implements CacheResolverPort {
-    private readonly deps;
-    constructor(deps: Dependencies);
-    resolve<T>(subject: Hash, producer: () => Promise<T>): Promise<T>;
-    resolveWithContext<T>(subject: Hash, producer: () => Promise<T>): Promise<{
-        value: T;
-        source: CacheSourceEnum;
-    }>;
-    flush(): Promise<void>;
-    get ttl(): import("@bgord/tools").Duration;
-}
-export {};
-//# sourceMappingURL=cache-resolver-simple.adapter.d.ts.map

package/dist/cache-resolver-simple.adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache-resolver-simple.adapter.d.ts","sourceRoot":"","sources":["../src/cache-resolver-simple.adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAAE,KAAK,iBAAiB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAChF,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEtC,KAAK,YAAY,GAAG;IAAE,eAAe,EAAE,mBAAmB,CAAA;CAAE,CAAC;AAE7D,qBAAa,0BAA2B,YAAW,iBAAiB;IACtD,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,YAAY;IAEzC,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAMjE,kBAAkB,CAAC,CAAC,EACxB,OAAO,EAAE,IAAI,EACb,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACzB,OAAO,CAAC;QAAE,KAAK,EAAE,CAAC,CAAC;QAAC,MAAM,EAAE,eAAe,CAAA;KAAE,CAAC;IAW3C,KAAK;IAIX,IAAI,GAAG,oCAEN;CACF"}