@q9labsai/chalk-client 4.0.0

package/dist/server/index.cjs

@@ -0,0 +1,551 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ChalkAPIError: () => ChalkAPIError,
+  ChalkServerOnlyError: () => ChalkServerOnlyError,
+  createChalkServerClient: () => createChalkServerClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/access/base64-url.ts
+function decodeBase64Url(value) {
+  const base64 = value.replaceAll("-", "+").replaceAll("_", "/").padEnd(Math.ceil(value.length / 4) * 4, "=");
+  const bytes = Uint8Array.from(globalThis.atob(base64), (character) => character.charCodeAt(0));
+  return new TextDecoder().decode(bytes);
+}
+
+// src/access/episode-diagnostic-credential.ts
+var INTAKE_PATH = "/_internal/episode-diagnostic-events";
+var RFC3339_ZONED = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
+function parseEpisodeDiagnosticCredential(value) {
+  if (!isRecord(value)) return null;
+  const token = value.token;
+  const expiresAt = value.expires_at;
+  const generation = value.generation;
+  const intakePath = value.intake_path;
+  if (typeof token !== "string" || !validDiagnosticCredential(token)) return null;
+  if (!isRFC3339Zoned(expiresAt)) return null;
+  if (!Number.isSafeInteger(generation) || generation < 1) return null;
+  if (intakePath !== INTAKE_PATH) return null;
+  return Object.freeze({ token, expiresAt, generation, intakePath });
+}
+function validDiagnosticCredential(token) {
+  const segments = token.split(".");
+  if (segments.length !== 3) return false;
+  try {
+    const payload = JSON.parse(decodeBase64Url(segments[1] ?? ""));
+    return isRecord(payload) && payload.aud === "chalk-diagnostics";
+  } catch {
+    return false;
+  }
+}
+function isRFC3339Zoned(value) {
+  if (typeof value !== "string") return false;
+  const match = RFC3339_ZONED.exec(value);
+  if (!match) return false;
+  return validTimestampFields(match) && Number.isFinite(Date.parse(value));
+}
+function validTimestampFields(match) {
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const hour = Number(match[4]);
+  const minute = Number(match[5]);
+  const second = Number(match[6]);
+  const zone = match[7] ?? "";
+  return validCalendarDate(year, month, day) && validClockTime(hour, minute, second) && validZoneOffset(zone);
+}
+function inRange(value, min, max) {
+  return value >= min && value <= max;
+}
+function validCalendarDate(year, month, day) {
+  return inRange(month, 1, 12) && inRange(day, 1, daysInMonth(year, month));
+}
+function validClockTime(hour, minute, second) {
+  return inRange(hour, 0, 23) && inRange(minute, 0, 59) && inRange(second, 0, 59);
+}
+function validZoneOffset(zone) {
+  if (zone === "Z") return true;
+  return inRange(Number(zone.slice(1, 3)), 0, 23) && inRange(Number(zone.slice(4, 6)), 0, 59);
+}
+function daysInMonth(year, month) {
+  if (month === 2) return isLeapYear(year) ? 29 : 28;
+  return [4, 6, 9, 11].includes(month) ? 30 : 31;
+}
+function isLeapYear(year) {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/access/grant.ts
+var accessGrantBrand = /* @__PURE__ */ Symbol("AccessGrant");
+var AccessGrantError = class extends TypeError {
+  code = "access.invalid";
+  constructor(message = "Access grant is invalid") {
+    super(message);
+    this.name = "AccessGrantError";
+  }
+};
+function parseParsedAccessGrant(value) {
+  if (!isRecord2(value)) throw new AccessGrantError();
+  const subject = parseSubject(value.subject);
+  const diagnostics = parseEpisodeDiagnosticCredential(value.diagnostics);
+  return {
+    subject,
+    sync: parseSyncAccess(value.sync),
+    media: parseMediaAccess(value.media),
+    diagnostics: diagnostics?.generation === subject.participantGeneration ? diagnostics : null
+  };
+}
+function parseAccessGrant(value) {
+  return accessGrantFromParsed(parseParsedAccessGrant(value));
+}
+function accessGrantFromParsed(value) {
+  return Object.freeze({
+    subject: {
+      tenant_id: value.subject.tenantId,
+      space_id: value.subject.spaceId,
+      episode_id: value.subject.episodeId,
+      participant_id: value.subject.participantId,
+      participant_generation: value.subject.participantGeneration
+    },
+    sync: { token: value.sync.token, expires_at: value.sync.expiresAt },
+    media: {
+      token: value.media.token,
+      expires_at: value.media.expiresAt,
+      provider: value.media.provider,
+      client_payload: { ...value.media.clientPayload }
+    },
+    ...value.diagnostics ? {
+      diagnostics: {
+        token: value.diagnostics.token,
+        expires_at: value.diagnostics.expiresAt,
+        generation: value.diagnostics.generation,
+        intake_path: value.diagnostics.intakePath
+      }
+    } : {},
+    [accessGrantBrand]: "AccessGrant"
+  });
+}
+function parseSubject(value) {
+  if (!isRecord2(value)) throw new AccessGrantError();
+  return {
+    tenantId: requireNonEmptyString(value.tenant_id),
+    spaceId: requireNonEmptyString(value.space_id),
+    episodeId: requireNonEmptyString(value.episode_id),
+    participantId: requireNonEmptyString(value.participant_id),
+    participantGeneration: requirePositiveInteger(value.participant_generation)
+  };
+}
+function requirePositiveInteger(value) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) throw new AccessGrantError();
+  return value;
+}
+function parseSyncAccess(value) {
+  if (!isRecord2(value)) throw new AccessGrantError();
+  return {
+    token: requireCredential(value.token, "chalk-sync"),
+    expiresAt: requireDateTime(value.expires_at ?? value.expiresAt)
+  };
+}
+function parseMediaAccess(value) {
+  if (!isRecord2(value) || value.provider !== "cloudflare_sfu" || !isRecord2(value.client_payload ?? value.clientPayload)) throw new AccessGrantError();
+  const payload = value.client_payload ?? value.clientPayload;
+  return {
+    token: requireCredential(value.token, "chalk-media"),
+    expiresAt: requireDateTime(value.expires_at ?? value.expiresAt),
+    provider: value.provider,
+    clientPayload: {
+      connectionId: requireNonEmptyString(payload.connectionId),
+      stunServer: requireNonEmptyString(payload.stunServer)
+    }
+  };
+}
+function requireCredential(value, audience) {
+  const token = requireNonEmptyString(value);
+  const segments = token.split(".");
+  if (segments.length !== 3) throw new AccessGrantError();
+  let payload;
+  try {
+    payload = JSON.parse(decodeBase64Url(segments[1] ?? ""));
+  } catch {
+    throw new AccessGrantError();
+  }
+  if (!isRecord2(payload) || payload.aud !== audience) throw new AccessGrantError();
+  return token;
+}
+function requireDateTime(value) {
+  const dateTime = requireNonEmptyString(value);
+  if (!Number.isFinite(Date.parse(dateTime))) throw new AccessGrantError();
+  return dateTime;
+}
+function requireNonEmptyString(value) {
+  if (typeof value !== "string" || value.trim().length === 0) throw new AccessGrantError();
+  return value;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/server/errors.ts
+var safeCodePattern = /^[a-z][a-z0-9_]{0,63}$/u;
+var safeRequestIdPattern = /^[A-Za-z0-9._:-]{1,128}$/u;
+var ChalkAPIError = class extends Error {
+  code;
+  requestId;
+  retryable;
+  status;
+  constructor(input) {
+    super(messageFor(input.code, input.status));
+    this.name = "ChalkAPIError";
+    this.code = input.code;
+    this.status = input.status;
+    this.retryable = input.retryable;
+    this.requestId = input.requestId;
+  }
+};
+var ChalkServerOnlyError = class extends Error {
+  constructor() {
+    super("The Chalk server client is available only in Node.js runtimes.");
+    this.name = "ChalkServerOnlyError";
+  }
+};
+function errorCode(value) {
+  return safeErrorCode(errorCodeValue(value));
+}
+function requestId(headers) {
+  return safeRequestId(headers.get("x-request-id") ?? headers.get("x-chalk-request-id"));
+}
+function errorCodeValue(value) {
+  if (!isRecord3(value)) return void 0;
+  if (!isRecord3(value.error)) return void 0;
+  return value.error.code;
+}
+function safeErrorCode(value) {
+  if (typeof value !== "string") return "request_failed";
+  if (!safeCodePattern.test(value)) return "request_failed";
+  return value;
+}
+function safeRequestId(value) {
+  if (value === null) return void 0;
+  if (!safeRequestIdPattern.test(value)) return void 0;
+  return value;
+}
+function messageFor(code, status) {
+  if (code === "network_error") return "The Chalk API could not be reached.";
+  if (code === "invalid_response") return "The Chalk API returned an invalid response.";
+  return status > 0 ? `The Chalk API request failed with HTTP ${status}.` : "The Chalk API request failed.";
+}
+function isRecord3(value) {
+  if (typeof value !== "object") return false;
+  if (value === null) return false;
+  return !Array.isArray(value);
+}
+
+// src/server/transport.ts
+var retryableStatuses = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+var maxRetries = 2;
+function createServerRequester(options, apiKey, apiBaseURL, fetchImplementation) {
+  return (input) => {
+    const suppliedKey = input.idempotency?.idempotencyKey;
+    const attempt = {
+      apiBaseURL,
+      apiKey,
+      fetch: fetchImplementation,
+      idempotencyKey: idempotencyKey(input.retry, suppliedKey),
+      input,
+      options,
+      retries: retryCount(input.retry, suppliedKey)
+    };
+    return performAttempt(attempt, 0);
+  };
+}
+async function performAttempt(attempt, index) {
+  const response = await fetchAttempt(attempt, index);
+  if (response.status === attempt.input.expectedStatus) return decodeSuccess(response);
+  if (canRetryResponse(response, attempt.retries, index)) return retryResponse(response, attempt, index);
+  throw await responseError(response);
+}
+async function fetchAttempt(attempt, index) {
+  try {
+    return await attempt.fetch(requestURL(attempt), requestInit(attempt));
+  } catch {
+    return retryTransport(attempt, index);
+  }
+}
+async function retryTransport(attempt, index) {
+  if (index >= attempt.retries) throw new ChalkAPIError({ code: "network_error", retryable: true, status: 0 });
+  await retryDelay(index);
+  return fetchAttempt(attempt, index + 1);
+}
+async function retryResponse(response, attempt, index) {
+  await discard(response);
+  await retryDelay(index);
+  return performAttempt(attempt, index + 1);
+}
+async function decodeSuccess(response) {
+  if (response.status === 204) return void 0;
+  try {
+    return await response.json();
+  } catch {
+    throw new ChalkAPIError({ code: "invalid_response", requestId: requestId(response.headers), retryable: false, status: response.status });
+  }
+}
+function canRetryResponse(response, retries, index) {
+  if (index >= retries) return false;
+  return retryableStatuses.has(response.status);
+}
+function requestURL(attempt) {
+  return new URL(attempt.input.path.replace(/^\/+/u, ""), attempt.apiBaseURL);
+}
+function requestInit(attempt) {
+  return {
+    method: attempt.input.method,
+    headers: requestHeaders(attempt.options, attempt.apiKey, attempt.input.body !== void 0, attempt.idempotencyKey),
+    ...serializedBody(attempt.input.body)
+  };
+}
+function serializedBody(body) {
+  if (body === void 0) return {};
+  return { body: JSON.stringify(body) };
+}
+function requestHeaders(options, apiKey, hasBody, idempotencyKeyValue) {
+  const headers = new Headers(options.headers);
+  setContentType(headers, hasBody);
+  setTelemetryHeaders(headers, options);
+  setOptionalHeader(headers, "idempotency-key", idempotencyKeyValue);
+  headers.set("authorization", `Bearer ${apiKey}`);
+  return headers;
+}
+function setContentType(headers, hasBody) {
+  if (hasBody) headers.set("content-type", "application/json");
+}
+function setTelemetryHeaders(headers, options) {
+  if (!options.telemetry) return;
+  headers.set("x-chalk-journey-id", options.telemetry.journeyId);
+  headers.set("traceparent", options.telemetry.traceparent);
+  setOptionalHeader(headers, "tracestate", options.telemetry.tracestate);
+}
+function setOptionalHeader(headers, name, value) {
+  if (value !== void 0) headers.set(name, value);
+}
+async function responseError(response) {
+  return new ChalkAPIError({ code: errorCode(await errorBody(response)), requestId: requestId(response.headers), retryable: retryableStatuses.has(response.status), status: response.status });
+}
+async function errorBody(response) {
+  try {
+    return await response.json();
+  } catch {
+    return void 0;
+  }
+}
+function idempotencyKey(mode, suppliedKey) {
+  if (mode !== "caller_idempotency") return void 0;
+  return suppliedKey ?? globalThis.crypto.randomUUID();
+}
+function retryCount(mode, suppliedKey) {
+  if (mode === "always") return maxRetries;
+  if (mode === "caller_idempotency") return suppliedKey === void 0 ? 0 : maxRetries;
+  return 0;
+}
+async function discard(response) {
+  try {
+    await response.arrayBuffer();
+  } catch {
+  }
+}
+function retryDelay(attempt) {
+  const ceiling = Math.min(400, 50 * 2 ** attempt);
+  return new Promise((resolve) => setTimeout(resolve, Math.floor(Math.random() * (ceiling + 1))));
+}
+
+// src/server/client.ts
+function createChalkServerClient(options) {
+  const apiKey = required(options.apiKey, "apiKey");
+  const tenantId = required(options.tenantId, "tenantId");
+  const apiBaseURL = normalizedBaseURL(options.apiBaseURL);
+  const fetchImplementation = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+  if (typeof fetchImplementation !== "function") throw new TypeError("A fetch implementation is required");
+  const tenantPath = `/v1/tenants/${segment(tenantId)}`;
+  const request = createServerRequester(options, apiKey, apiBaseURL, fetchImplementation);
+  return {
+    spaces: {
+      create: (input) => request({ method: "POST", path: `${tenantPath}/spaces`, body: createSpaceRequest(input), expectedStatus: 201, retry: "never" })
+    },
+    episodes: {
+      create: (spaceId, input, idempotency) => request({ method: "POST", path: `${tenantPath}/spaces/${segment(spaceId)}/episodes`, body: createEpisodeRequest(input), expectedStatus: 201, idempotency, retry: "caller_idempotency" }),
+      end: (spaceId, episodeId, idempotency) => request({ method: "POST", path: `${tenantPath}/spaces/${segment(spaceId)}/episodes/${segment(episodeId)}/end`, expectedStatus: 202, idempotency, retry: "caller_idempotency" })
+    },
+    participants: {
+      admit: async (spaceId, episodeId, input, idempotency) => {
+        const lifecycle = await request({
+          method: "POST",
+          path: `${tenantPath}/spaces/${segment(spaceId)}/episodes/${segment(episodeId)}/participants`,
+          body: participantAdmissionRequest(input),
+          expectedStatus: 201,
+          idempotency,
+          retry: "caller_idempotency"
+        });
+        return participantLifecycle(lifecycle);
+      },
+      issueAccess: async (spaceId, episodeId, participantId, input) => {
+        const access = await request({
+          method: "POST",
+          path: `${tenantPath}/spaces/${segment(spaceId)}/episodes/${segment(episodeId)}/participants/${segment(participantId)}/access-grant`,
+          body: accessGrantRequest(input),
+          expectedStatus: 201,
+          retry: input.replaceMediaConnection === true ? "never" : "always"
+        });
+        return accessGrant(access);
+      },
+      remove: (spaceId, episodeId, participantId, input, idempotency) => request({
+        method: "POST",
+        path: `${tenantPath}/spaces/${segment(spaceId)}/episodes/${segment(episodeId)}/participants/${segment(participantId)}/remove`,
+        body: participantRemovalRequest(input),
+        expectedStatus: 202,
+        idempotency,
+        retry: "caller_idempotency"
+      })
+    },
+    apiKeys: {
+      create: (input) => request({ method: "POST", path: `${tenantPath}/api-keys`, body: apiKeyCreateRequest(input), expectedStatus: 201, retry: "never" }),
+      list: (input) => request({ method: "GET", path: `${tenantPath}/api-keys${apiKeyQuery(input)}`, expectedStatus: 200, retry: "always" }),
+      rotate: (apiKeyId, input) => request({ method: "POST", path: `${tenantPath}/api-keys/${segment(apiKeyId)}/rotate`, body: { expires_at: input?.expiresAt }, expectedStatus: 200, retry: "never" }),
+      revoke: (apiKeyId) => request({ method: "DELETE", path: `${tenantPath}/api-keys/${segment(apiKeyId)}`, expectedStatus: 204, retry: "always" })
+    }
+  };
+}
+function createSpaceRequest(input) {
+  return {
+    default_episode_duration_seconds: input.defaultEpisodeDurationSeconds,
+    linger_window_seconds: input.lingerWindowSeconds,
+    maximum_episode_duration_seconds: input.maximumEpisodeDurationSeconds,
+    media_plane: input.mediaPlane,
+    name: input.name,
+    slug: input.slug,
+    ...input.admissionPolicy === void 0 ? {} : { admission_policy: input.admissionPolicy },
+    ...input.metadata === void 0 ? {} : { metadata: input.metadata },
+    ...input.recurringPolicy === void 0 ? {} : { recurring_policy: input.recurringPolicy }
+  };
+}
+function createEpisodeRequest(input) {
+  return {
+    ...input.metadata === void 0 ? {} : { metadata: input.metadata },
+    ...input.startedAt === void 0 ? {} : { started_at: input.startedAt }
+  };
+}
+function participantAdmissionRequest(input) {
+  return {
+    name: input.name,
+    role: input.role,
+    ...input.identityId === void 0 ? {} : { identity_id: input.identityId },
+    ...input.metadata === void 0 ? {} : { metadata: input.metadata },
+    ...input.participantId === void 0 ? {} : { participant_id: input.participantId }
+  };
+}
+function accessGrantRequest(input) {
+  return {
+    participant_generation: input.participantGeneration,
+    replace_media_connection: input.replaceMediaConnection ?? false,
+    ...input.currentMediaToken ? { current_media_token: input.currentMediaToken } : {}
+  };
+}
+function participantRemovalRequest(input) {
+  return { participant_generation: input.participantGeneration };
+}
+function apiKeyCreateRequest(input) {
+  return { expires_at: input.expiresAt, name: input.name, scopes: [...input.scopes] };
+}
+function apiKeyQuery(input) {
+  const query = new URLSearchParams();
+  setQueryValue(query, "cursor", input?.cursor);
+  setQueryValue(query, "page_size", input?.pageSize);
+  return prefixedQuery(query.toString());
+}
+function setQueryValue(query, name, value) {
+  if (value !== void 0) query.set(name, String(value));
+}
+function prefixedQuery(value) {
+  if (value === "") return "";
+  return `?${value}`;
+}
+function required(value, name) {
+  const normalized = value.trim();
+  if (!normalized) throw new TypeError(`${name} is required`);
+  return normalized;
+}
+function normalizedBaseURL(value) {
+  const url = new URL(value);
+  url.pathname = `${url.pathname.replace(/\/+$/u, "")}/`;
+  url.search = "";
+  url.hash = "";
+  return url.toString();
+}
+function segment(value) {
+  return encodeURIComponent(required(value, "identifier"));
+}
+function participantLifecycle(value) {
+  const { access, ...lifecycle } = value;
+  if (access === void 0) return lifecycle;
+  return { ...lifecycle, access: access === null ? null : accessGrant(access) };
+}
+function accessGrant(value) {
+  const payload = cloudflareClientPayload(value.media);
+  return parseAccessGrant({
+    subject: {
+      tenant_id: value.subject.tenant_id,
+      space_id: requiredResponseID(value.subject.space_id),
+      episode_id: requiredResponseID(value.subject.episode_id),
+      participant_id: requiredResponseID(value.subject.participant_id),
+      participant_generation: value.subject.participant_generation
+    },
+    sync: value.sync,
+    media: {
+      token: value.media.token,
+      expires_at: value.media.expires_at,
+      provider: "cloudflare_sfu",
+      client_payload: payload
+    }
+  });
+}
+function cloudflareClientPayload(media) {
+  const { connectionId, stunServer } = media.client_payload;
+  if (media.provider !== "cloudflare_sfu" || typeof connectionId !== "string" || typeof stunServer !== "string") {
+    throw invalidResponse(201);
+  }
+  return { connectionId, stunServer };
+}
+function requiredResponseID(value) {
+  if (!value) throw invalidResponse(201);
+  return value;
+}
+function invalidResponse(status) {
+  return new ChalkAPIError({ code: "invalid_response", retryable: false, status });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChalkAPIError,
+  ChalkServerOnlyError,
+  createChalkServerClient
+});

package/dist/server/index.d.cts

@@ -0,0 +1,3 @@
+export { createChalkServerClient } from "./client.cjs";
+export { ChalkAPIError, ChalkServerOnlyError } from "./errors.cjs";
+export type { APIKey, APIKeyList, APIKeyWithSecret, AdmitParticipantInput, ChalkIdempotencyOptions, ChalkServerClient, ChalkServerClientOptions, ChalkServerHeaders, ChalkServerTelemetry, CreateAPIKeyInput, CreateEpisodeInput, CreateSpaceInput, Episode, EpisodeEnd, IssueAccessGrantInput, ListAPIKeysInput, AccessGrant, ParticipantLifecycle, ParticipantRemoval, RemoveParticipantInput, RotateAPIKeyInput, Space, } from "./types.cjs";

package/dist/server/index.d.ts

@@ -0,0 +1,4 @@
+export { createChalkServerClient } from "./client.js";
+export { ChalkAPIError, ChalkServerOnlyError } from "./errors.js";
+export type { APIKey, APIKeyList, APIKeyWithSecret, AdmitParticipantInput, ChalkIdempotencyOptions, ChalkServerClient, ChalkServerClientOptions, ChalkServerHeaders, ChalkServerTelemetry, CreateAPIKeyInput, CreateEpisodeInput, CreateSpaceInput, Episode, EpisodeEnd, IssueAccessGrantInput, ListAPIKeysInput, AccessGrant, ParticipantLifecycle, ParticipantRemoval, RemoveParticipantInput, RotateAPIKeyInput, Space, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAClE,YAAY,EACV,MAAM,EACN,UAAU,EACV,gBAAgB,EAChB,qBAAqB,EACrB,uBAAuB,EACvB,iBAAiB,EACjB,wBAAwB,EACxB,kBAAkB,EAClB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,OAAO,EACP,UAAU,EACV,qBAAqB,EACrB,gBAAgB,EAChB,WAAW,EACX,oBAAoB,EACpB,kBAAkB,EAClB,sBAAsB,EACtB,iBAAiB,EACjB,KAAK,GACN,MAAM,YAAY,CAAC"}