meterflow 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MeterFlow
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,89 @@
+# meterflow
+
+Official Node.js SDK for [MeterFlow](https://meterflow.com) — usage-based billing, credit management, and metering.
+
+## Requirements
+
+- Node.js ≥ 18
+
+## Installation
+
+```bash
+npm install meterflow
+```
+
+## Quick start
+
+```typescript
+import { MeterFlow } from "meterflow";
+
+const client = new MeterFlow({ apiKey: "mf_live_your_api_key" });
+
+// Grant credits to a customer
+await client.credits.grant({
+  customer_external_id: "customer_123",
+  amount: 100,
+  description: "Welcome credits",
+});
+
+// Record a usage event
+await client.usage.record({
+  customer_external_id: "customer_123",
+  meter_name: "api_calls",
+  quantity: 1,
+});
+
+// Check credit balance
+const balance = await client.credits.balance("customer_123");
+console.log(balance.balance);
+```
+
+## Configuration
+
+```typescript
+const client = new MeterFlow({
+  apiKey: "mf_live_your_api_key",   // required; mf_live_* or mf_test_*
+  baseUrl: "https://api.meterflow.com/api/v1",  // optional override
+  timeout: 30_000,                  // ms; default 30 s
+  retries: 3,                       // default 3; 0 to disable
+});
+```
+
+## Resources
+
+| Resource | Methods |
+|---|---|
+| `client.credits` | `grant`, `deduct`, `balance`, `transactions` |
+| `client.usage` | `record`, `recordBatch`, `summary` |
+| `client.subscriptions` | `create`, `list`, `get`, `update`, `delete` |
+| `client.plans` | `list`, `get` |
+
+## Webhook verification
+
+```typescript
+import { verifyWebhook } from "meterflow";
+
+const isValid = verifyWebhook(rawBody, req.headers["x-meterflow-signature"], webhookSecret);
+```
+
+## Error handling
+
+```typescript
+import { MeterFlowError, InsufficientCreditsError, RateLimitError } from "meterflow";
+
+try {
+  await client.credits.deduct({ customer_external_id: "cust_1", amount: 999 });
+} catch (err) {
+  if (err instanceof InsufficientCreditsError) {
+    console.log("Not enough credits");
+  } else if (err instanceof RateLimitError) {
+    console.log(`Rate limited, retry after ${err.retryAfter}s`);
+  } else if (err instanceof MeterFlowError) {
+    console.log(`Request ID for support: ${err.requestId}`);
+  }
+}
+```
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,32 @@
+import { CreditsResource } from "./resources/credits";
+import { UsageResource } from "./resources/usage";
+import { SubscriptionsResource } from "./resources/subscriptions";
+import { PlansResource } from "./resources/plans";
+export interface MeterFlowOptions {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+    retries?: number;
+    fetch?: typeof globalThis.fetch;
+}
+export interface RequestOptions {
+    body?: unknown;
+    query?: Record<string, string | number | boolean>;
+    idempotencyKey?: string;
+    timeout?: number;
+}
+export declare class MeterFlow {
+    readonly options: Required<MeterFlowOptions>;
+    private _credits?;
+    private _usage?;
+    private _subscriptions?;
+    private _plans?;
+    constructor(options: MeterFlowOptions);
+    get credits(): CreditsResource;
+    get usage(): UsageResource;
+    get subscriptions(): SubscriptionsResource;
+    get plans(): PlansResource;
+    /** @internal — used by resource classes only; not part of the public API */
+    request<T>(method: string, path: string, opts?: RequestOptions): Promise<T>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAElD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACjC;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;IAClD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,SAAS;IACpB,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,gBAAgB,CAAC,CAAC;IAE7C,OAAO,CAAC,QAAQ,CAAC,CAAkB;IACnC,OAAO,CAAC,MAAM,CAAC,CAAgB;IAC/B,OAAO,CAAC,cAAc,CAAC,CAAwB;IAC/C,OAAO,CAAC,MAAM,CAAC,CAAgB;gBAEnB,OAAO,EAAE,gBAAgB;IAarC,IAAI,OAAO,IAAI,eAAe,CAE7B;IAED,IAAI,KAAK,IAAI,aAAa,CAEzB;IAED,IAAI,aAAa,IAAI,qBAAqB,CAEzC;IAED,IAAI,KAAK,IAAI,aAAa,CAEzB;IAED,4EAA4E;IAC5E,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,CAAC,CAAC;CAG5E"}

package/dist/errors.d.ts

@@ -0,0 +1,30 @@
+export declare class MeterFlowError extends Error {
+    readonly errorType: string;
+    readonly requestId: string | undefined;
+    readonly statusCode: number | undefined;
+    readonly retryable: boolean;
+    constructor(message: string, errorType: string, retryable: boolean, requestId?: string, statusCode?: number);
+}
+export declare class AuthError extends MeterFlowError {
+    constructor(message: string, requestId?: string, statusCode?: number);
+}
+export declare class NotFoundError extends MeterFlowError {
+    constructor(message: string, requestId?: string);
+}
+export declare class InsufficientCreditsError extends MeterFlowError {
+    constructor(message: string, requestId?: string);
+}
+export declare class ConflictError extends MeterFlowError {
+    constructor(message: string, requestId?: string);
+}
+export declare class ValidationError extends MeterFlowError {
+    constructor(message: string, requestId?: string);
+}
+export declare class RateLimitError extends MeterFlowError {
+    readonly retryAfter: number | undefined;
+    constructor(message: string, retryAfter?: number, requestId?: string);
+}
+export declare class ServerError extends MeterFlowError {
+    constructor(message: string, requestId?: string, statusCode?: number);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,cAAe,SAAQ,KAAK;IACvC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;gBAEhB,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;CAQ5G;AAED,qBAAa,SAAU,SAAQ,cAAc;gBAC/B,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,UAAU,SAAM;CAIlE;AAED,qBAAa,aAAc,SAAQ,cAAc;gBACnC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM;CAIhD;AAED,qBAAa,wBAAyB,SAAQ,cAAc;gBAC9C,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM;CAIhD;AAED,qBAAa,aAAc,SAAQ,cAAc;gBACnC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM;CAIhD;AAED,qBAAa,eAAgB,SAAQ,cAAc;gBACrC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM;CAIhD;AAED,qBAAa,cAAe,SAAQ,cAAc;IAChD,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;gBAE5B,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM;CAKrE;AAED,qBAAa,WAAY,SAAQ,cAAc;gBACjC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,UAAU,SAAM;CAIlE"}

package/dist/index.cjs

@@ -0,0 +1,358 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AuthError: () => AuthError,
+  ConflictError: () => ConflictError,
+  InsufficientCreditsError: () => InsufficientCreditsError,
+  MeterFlow: () => MeterFlow,
+  MeterFlowError: () => MeterFlowError,
+  NotFoundError: () => NotFoundError,
+  RateLimitError: () => RateLimitError,
+  ServerError: () => ServerError,
+  ValidationError: () => ValidationError,
+  verifyWebhook: () => verifyWebhook
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var MeterFlowError = class extends Error {
+  errorType;
+  requestId;
+  statusCode;
+  retryable;
+  constructor(message, errorType, retryable2, requestId, statusCode) {
+    super(message);
+    this.name = "MeterFlowError";
+    this.errorType = errorType;
+    this.retryable = retryable2;
+    this.requestId = requestId;
+    this.statusCode = statusCode;
+  }
+};
+var AuthError = class extends MeterFlowError {
+  constructor(message, requestId, statusCode = 401) {
+    super(message, "auth_error", false, requestId, statusCode);
+    this.name = "AuthError";
+  }
+};
+var NotFoundError = class extends MeterFlowError {
+  constructor(message, requestId) {
+    super(message, "not_found", false, requestId, 404);
+    this.name = "NotFoundError";
+  }
+};
+var InsufficientCreditsError = class extends MeterFlowError {
+  constructor(message, requestId) {
+    super(message, "insufficient_credits", false, requestId, 402);
+    this.name = "InsufficientCreditsError";
+  }
+};
+var ConflictError = class extends MeterFlowError {
+  constructor(message, requestId) {
+    super(message, "conflict", false, requestId, 409);
+    this.name = "ConflictError";
+  }
+};
+var ValidationError = class extends MeterFlowError {
+  constructor(message, requestId) {
+    super(message, "validation_error", false, requestId, 422);
+    this.name = "ValidationError";
+  }
+};
+var RateLimitError = class extends MeterFlowError {
+  retryAfter;
+  constructor(message, retryAfter, requestId) {
+    super(message, "rate_limit", true, requestId, 429);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var ServerError = class extends MeterFlowError {
+  constructor(message, requestId, statusCode = 500) {
+    super(message, "server_error", true, requestId, statusCode);
+    this.name = "ServerError";
+  }
+};
+
+// src/utils/retry.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retryable(fn, opts, shouldRetry = () => true) {
+  let lastError;
+  for (let attempt = 0; attempt <= opts.retries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      const isLast = attempt === opts.retries;
+      if (isLast || !shouldRetry(err)) {
+        throw err;
+      }
+      let delayMs;
+      if (err instanceof RateLimitError && err.retryAfter != null) {
+        delayMs = err.retryAfter * 1e3;
+      } else {
+        const baseMs = Math.min(1e3 * Math.pow(opts.factor, attempt), opts.maxDelayMs);
+        delayMs = opts.jitter ? baseMs * (0.75 + Math.random() * 0.5) : baseMs;
+      }
+      await sleep(delayMs);
+    }
+  }
+  throw lastError;
+}
+
+// src/utils/http.ts
+var SDK_VERSION = "0.1.0";
+function buildUrl(baseUrl, path, query) {
+  const url = new URL(path, baseUrl.endsWith("/") ? baseUrl : baseUrl + "/");
+  if (query) {
+    for (const [key, value] of Object.entries(query)) {
+      url.searchParams.set(key, String(value));
+    }
+  }
+  return url.toString();
+}
+function buildHeaders(options, opts) {
+  const headers = {
+    Authorization: `Bearer ${options.apiKey}`,
+    "User-Agent": `meterflow-node/${SDK_VERSION}`,
+    Accept: "application/json"
+  };
+  if (opts?.body !== void 0) {
+    headers["Content-Type"] = "application/json";
+  }
+  if (opts?.idempotencyKey) {
+    headers["Idempotency-Key"] = opts.idempotencyKey;
+  }
+  return headers;
+}
+async function parseErrorBody(response) {
+  try {
+    const json = await response.json();
+    if (typeof json["detail"] === "string") return json["detail"];
+    return JSON.stringify(json);
+  } catch {
+    return response.statusText || `HTTP ${response.status}`;
+  }
+}
+function mapResponseError(status, message, requestId, response) {
+  if (status === 401 || status === 403) return new AuthError(message, requestId, status);
+  if (status === 402) return new InsufficientCreditsError(message, requestId);
+  if (status === 404) return new NotFoundError(message, requestId);
+  if (status === 409) return new ConflictError(message, requestId);
+  if (status === 422) return new ValidationError(message, requestId);
+  if (status === 429) {
+    const retryAfterRaw = response.headers.get("Retry-After");
+    const retryAfter = retryAfterRaw != null ? parseInt(retryAfterRaw, 10) : void 0;
+    return new RateLimitError(message, Number.isFinite(retryAfter) ? retryAfter : void 0, requestId);
+  }
+  if (status >= 500) return new ServerError(message, requestId, status);
+  return new MeterFlowError(message, "request_error", false, requestId, status);
+}
+async function httpRequest(options, method, path, opts) {
+  const url = buildUrl(options.baseUrl, path, opts?.query);
+  const headers = buildHeaders(options, opts);
+  const body = opts?.body !== void 0 ? JSON.stringify(opts.body) : void 0;
+  const timeoutMs = opts?.timeout ?? options.timeout;
+  return retryable(
+    async () => {
+      const signal = AbortSignal.timeout(timeoutMs);
+      const fetchInit = { method, headers, signal };
+      if (body !== void 0) fetchInit.body = body;
+      const response = await options.fetch(url, fetchInit);
+      const requestId = response.headers.get("x-request-id") ?? void 0;
+      if (!response.ok) {
+        const message = await parseErrorBody(response);
+        throw mapResponseError(response.status, message, requestId, response);
+      }
+      if (response.status === 204 || response.headers.get("content-length") === "0") {
+        return void 0;
+      }
+      return await response.json();
+    },
+    { retries: options.retries, factor: 2, jitter: true, maxDelayMs: 1e4 },
+    (err) => {
+      if (err instanceof MeterFlowError) return err.retryable;
+      return true;
+    }
+  );
+}
+
+// src/resources/credits.ts
+var CreditsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  grant(body, opts) {
+    return this.client.request("POST", "credits/grant", {
+      body,
+      ...opts?.idempotencyKey !== void 0 && { idempotencyKey: opts.idempotencyKey }
+    });
+  }
+  deduct(body, opts) {
+    return this.client.request("POST", "credits/deduct", {
+      body,
+      ...opts?.idempotencyKey !== void 0 && { idempotencyKey: opts.idempotencyKey }
+    });
+  }
+  balance(customerId) {
+    return this.client.request("GET", `credits/${encodeURIComponent(customerId)}/balance`);
+  }
+  transactions(customerId, query) {
+    return this.client.request("GET", `credits/${encodeURIComponent(customerId)}/transactions`, {
+      ...query !== void 0 && { query }
+    });
+  }
+};
+
+// src/resources/usage.ts
+var UsageResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  record(body, opts) {
+    return this.client.request("POST", "usage/events", {
+      body,
+      ...opts?.idempotencyKey !== void 0 && { idempotencyKey: opts.idempotencyKey }
+    });
+  }
+  recordBatch(events, opts) {
+    return this.client.request("POST", "usage/events/batch", {
+      body: { events },
+      ...opts?.idempotencyKey !== void 0 && { idempotencyKey: opts.idempotencyKey }
+    });
+  }
+  summary(customerId, query) {
+    return this.client.request("GET", `usage/${encodeURIComponent(customerId)}`, {
+      ...query !== void 0 && { query }
+    });
+  }
+};
+
+// src/resources/subscriptions.ts
+var SubscriptionsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  create(body, opts) {
+    return this.client.request("POST", "subscriptions", {
+      body,
+      ...opts?.idempotencyKey !== void 0 && { idempotencyKey: opts.idempotencyKey }
+    });
+  }
+  list(query) {
+    return this.client.request("GET", "subscriptions", {
+      ...query !== void 0 && { query }
+    });
+  }
+  get(subscriptionId) {
+    return this.client.request("GET", `subscriptions/${encodeURIComponent(subscriptionId)}`);
+  }
+  update(subscriptionId, body, opts) {
+    return this.client.request("PATCH", `subscriptions/${encodeURIComponent(subscriptionId)}`, {
+      body,
+      ...opts?.idempotencyKey !== void 0 && { idempotencyKey: opts.idempotencyKey }
+    });
+  }
+  delete(subscriptionId) {
+    return this.client.request("DELETE", `subscriptions/${encodeURIComponent(subscriptionId)}`);
+  }
+};
+
+// src/resources/plans.ts
+var PlansResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  list(query) {
+    return this.client.request("GET", "plans", {
+      ...query !== void 0 && { query }
+    });
+  }
+  get(planId, query) {
+    return this.client.request("GET", `plans/${encodeURIComponent(planId)}`, {
+      ...query !== void 0 && { query }
+    });
+  }
+};
+
+// src/client.ts
+var MeterFlow = class {
+  options;
+  _credits;
+  _usage;
+  _subscriptions;
+  _plans;
+  constructor(options) {
+    if (!options.apiKey.startsWith("mf_live_") && !options.apiKey.startsWith("mf_test_")) {
+      throw new Error("apiKey must start with mf_live_ or mf_test_");
+    }
+    this.options = {
+      apiKey: options.apiKey,
+      baseUrl: options.baseUrl ?? "https://api.meterflow.com/api/v1",
+      timeout: options.timeout ?? 3e4,
+      retries: options.retries ?? 3,
+      fetch: options.fetch ?? globalThis.fetch
+    };
+  }
+  get credits() {
+    return this._credits ??= new CreditsResource(this);
+  }
+  get usage() {
+    return this._usage ??= new UsageResource(this);
+  }
+  get subscriptions() {
+    return this._subscriptions ??= new SubscriptionsResource(this);
+  }
+  get plans() {
+    return this._plans ??= new PlansResource(this);
+  }
+  /** @internal — used by resource classes only; not part of the public API */
+  request(method, path, opts) {
+    return httpRequest(this.options, method, path, opts);
+  }
+};
+
+// src/utils/webhook-verify.ts
+var import_crypto = require("crypto");
+function verifyWebhook(rawBody, signature, secret) {
+  const body = typeof rawBody === "string" ? Buffer.from(rawBody, "utf8") : rawBody;
+  const expected = (0, import_crypto.createHmac)("sha256", secret).update(body).digest("hex");
+  const expectedBuf = Buffer.from(expected, "utf8");
+  const actualBuf = Buffer.from(signature, "utf8");
+  if (expectedBuf.length !== actualBuf.length) return false;
+  return (0, import_crypto.timingSafeEqual)(expectedBuf, actualBuf);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthError,
+  ConflictError,
+  InsufficientCreditsError,
+  MeterFlow,
+  MeterFlowError,
+  NotFoundError,
+  RateLimitError,
+  ServerError,
+  ValidationError,
+  verifyWebhook
+});

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { MeterFlow } from "./client";
+export { verifyWebhook } from "./utils/webhook-verify";
+export { MeterFlowError, AuthError, NotFoundError, InsufficientCreditsError, ConflictError, ValidationError, RateLimitError, ServerError, } from "./errors";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EACL,cAAc,EACd,SAAS,EACT,aAAa,EACb,wBAAwB,EACxB,aAAa,EACb,eAAe,EACf,cAAc,EACd,WAAW,GACZ,MAAM,UAAU,CAAC"}