@happyvertical/accounting 0.74.8

package/dist/chunks/index-DO-cM79R.js

@@ -0,0 +1,772 @@
+import { randomUUID, createHmac, timingSafeEqual } from "node:crypto";
+class StripeProvider {
+  type = "stripe";
+  options;
+  fetchImpl;
+  customers;
+  invoices;
+  vendors;
+  bills;
+  payments;
+  audit;
+  webhooks;
+  billing;
+  constructor(options) {
+    this.options = {
+      timeout: 3e4,
+      maxRetries: 3,
+      apiBaseUrl: "https://api.stripe.com",
+      webhookTolerance: 300,
+      ...options
+    };
+    this.fetchImpl = options.fetch || fetch;
+    this.customers = new StripeCustomerOperations(this);
+    this.invoices = new StripeInvoiceOperations(this);
+    this.vendors = new UnsupportedVendorOperations();
+    this.bills = new UnsupportedBillOperations();
+    this.payments = new StripePaymentOperations(this);
+    this.audit = new StripeAuditOperations(this);
+    this.webhooks = new StripeWebhookOperations(this.options);
+    this.billing = new StripeBillingOperationsImpl(this);
+  }
+  async request(method, endpoint, params) {
+    const timeout = this.options.timeout || 3e4;
+    const maxRetries = this.options.maxRetries || 3;
+    const idempotencyKey = method === "POST" ? `sdk-${randomUUID()}` : null;
+    let lastError = null;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      try {
+        const url = this.buildUrl(endpoint, method === "GET" ? params : {});
+        const body = method === "POST" && params ? encodeStripeForm(params).toString() : void 0;
+        const headers = {
+          Authorization: `Bearer ${this.options.secretKey}`,
+          Accept: "application/json"
+        };
+        if (method === "POST") {
+          headers["Content-Type"] = "application/x-www-form-urlencoded";
+          if (idempotencyKey) {
+            headers["Idempotency-Key"] = idempotencyKey;
+          }
+        }
+        if (this.options.apiVersion) {
+          headers["Stripe-Version"] = this.options.apiVersion;
+        }
+        const response = await this.fetchImpl(url, {
+          method,
+          headers,
+          body,
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          const error = new Error(
+            `Stripe API error (${response.status}): ${errorText}`
+          );
+          if (response.status < 500 && response.status !== 429) {
+            throw error;
+          }
+          lastError = error;
+        } else {
+          const text = await response.text();
+          return text ? JSON.parse(text) : {};
+        }
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        const statusMatch = lastError.message.match(
+          /Stripe API error \((\d+)\)/
+        );
+        if (statusMatch) {
+          const status = Number.parseInt(statusMatch[1], 10);
+          if (status >= 400 && status < 500 && status !== 429) {
+            throw lastError;
+          }
+        }
+      } finally {
+        clearTimeout(timeoutId);
+      }
+      if (attempt < maxRetries) {
+        await sleep(2 ** attempt * 500);
+      }
+    }
+    throw lastError || new Error("Stripe request failed after retries");
+  }
+  buildUrl(endpoint, params) {
+    const baseUrl = this.options.apiBaseUrl || "https://api.stripe.com";
+    const url = new URL(endpoint, baseUrl);
+    if (params && Object.keys(params).length > 0) {
+      for (const [key, value] of encodeStripeForm(params).entries()) {
+        url.searchParams.append(key, value);
+      }
+    }
+    return url.toString();
+  }
+}
+class StripeCustomerOperations {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  async push(customer) {
+    const response = await this.provider.request(
+      "POST",
+      "/v1/customers",
+      mapCustomerToStripe(customer)
+    );
+    return {
+      action: "created",
+      externalId: response.id,
+      syncedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  async pull(externalId) {
+    const customer = await this.provider.request(
+      "GET",
+      `/v1/customers/${encodeURIComponent(externalId)}`
+    );
+    return mapStripeCustomer(customer);
+  }
+  async list(options = {}) {
+    const response = await this.provider.request("GET", "/v1/customers", mapListOptions(options));
+    return response.data.map(mapStripeCustomer);
+  }
+  async sync(customer) {
+    if (!customer.externalId) {
+      return this.push(customer);
+    }
+    await this.provider.request(
+      "POST",
+      `/v1/customers/${encodeURIComponent(customer.externalId)}`,
+      mapCustomerToStripe(customer)
+    );
+    return {
+      action: "updated",
+      externalId: customer.externalId,
+      syncedAt: /* @__PURE__ */ new Date()
+    };
+  }
+}
+class StripeInvoiceOperations {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  async push(invoice) {
+    if (!invoice.customerExternalId) {
+      throw new Error("Stripe invoices require customerExternalId");
+    }
+    for (const lineItem of invoice.lineItems) {
+      await this.provider.request("POST", "/v1/invoiceitems", {
+        customer: invoice.customerExternalId,
+        currency: invoice.currency || "usd",
+        description: lineItem.description,
+        quantity: lineItem.quantity,
+        unit_amount_decimal: String(Math.round(lineItem.unitPrice * 100)),
+        metadata: normalizeMetadata({
+          local_sku: lineItem.sku,
+          local_discount: lineItem.discount,
+          local_tax_rate: lineItem.taxRate
+        })
+      });
+    }
+    const response = await this.provider.request(
+      "POST",
+      "/v1/invoices",
+      mapInvoiceToStripe(invoice)
+    );
+    return {
+      action: "created",
+      externalId: response.id,
+      syncedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  async pull(externalId) {
+    const invoice = await this.provider.request(
+      "GET",
+      `/v1/invoices/${encodeURIComponent(externalId)}`
+    );
+    return mapStripeInvoice(invoice);
+  }
+  async list(options = {}) {
+    const response = await this.provider.request("GET", "/v1/invoices", mapListOptions(options));
+    return response.data.map(mapStripeInvoice);
+  }
+  async sync(invoice) {
+    if (!invoice.externalId) {
+      return this.push(invoice);
+    }
+    await this.provider.request(
+      "POST",
+      `/v1/invoices/${encodeURIComponent(invoice.externalId)}`,
+      mapInvoiceUpdateToStripe(invoice)
+    );
+    return {
+      action: "updated",
+      externalId: invoice.externalId,
+      syncedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  async send(externalId) {
+    await this.provider.request(
+      "POST",
+      `/v1/invoices/${encodeURIComponent(externalId)}/send`
+    );
+  }
+  async void(externalId) {
+    await this.provider.request(
+      "POST",
+      `/v1/invoices/${encodeURIComponent(externalId)}/void`
+    );
+  }
+}
+class StripePaymentOperations {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  async pull(externalId) {
+    const paymentIntent = await this.provider.request(
+      "GET",
+      `/v1/payment_intents/${encodeURIComponent(externalId)}`
+    );
+    return mapStripePaymentIntent(paymentIntent);
+  }
+  async list(options = {}) {
+    const response = await this.provider.request("GET", "/v1/payment_intents", mapListOptions(options));
+    return response.data.map(mapStripePaymentIntent);
+  }
+}
+class StripeBillingOperationsImpl {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  async createCheckoutSession(input) {
+    const response = await this.provider.request(
+      "POST",
+      "/v1/checkout/sessions",
+      mapCheckoutSessionToStripe(input)
+    );
+    return {
+      externalId: response.id,
+      url: response.url || null,
+      customerExternalId: response.customer || void 0,
+      subscriptionExternalId: response.subscription || void 0,
+      paymentIntentExternalId: response.payment_intent || void 0,
+      raw: response
+    };
+  }
+  async createCustomerPortalSession(input) {
+    const response = await this.provider.request(
+      "POST",
+      "/v1/billing_portal/sessions",
+      {
+        customer: input.customerExternalId,
+        return_url: input.returnUrl,
+        configuration: input.configurationExternalId
+      }
+    );
+    return {
+      externalId: response.id,
+      url: response.url,
+      raw: response
+    };
+  }
+  async retrieveSubscriptionStatus(subscriptionExternalId) {
+    const subscription = await this.provider.request(
+      "GET",
+      `/v1/subscriptions/${encodeURIComponent(subscriptionExternalId)}`
+    );
+    return mapStripeSubscription(subscription);
+  }
+  async listCustomerSubscriptions(customerExternalId) {
+    const response = await this.provider.request("GET", "/v1/subscriptions", {
+      customer: customerExternalId,
+      status: "all",
+      limit: 100
+    });
+    return response.data.map(mapStripeSubscription);
+  }
+}
+class UnsupportedVendorOperations {
+  async push(_vendor) {
+    throw new Error("Stripe does not support vendor operations");
+  }
+  async pull(_externalId) {
+    throw new Error("Stripe does not support vendor operations");
+  }
+  async list(_options) {
+    throw new Error("Stripe does not support vendor operations");
+  }
+  async sync(_vendor) {
+    throw new Error("Stripe does not support vendor operations");
+  }
+}
+class UnsupportedBillOperations {
+  async push(_bill) {
+    throw new Error("Stripe does not support bill operations");
+  }
+  async pull(_externalId) {
+    throw new Error("Stripe does not support bill operations");
+  }
+  async list(_options) {
+    throw new Error("Stripe does not support bill operations");
+  }
+  async sync(_bill) {
+    throw new Error("Stripe does not support bill operations");
+  }
+}
+class StripeAuditOperations {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  async reconcileCustomers(locals) {
+    const externals = await this.provider.customers.list({ limit: 100 });
+    return reconcileRecords("stripe", locals, externals, compareCustomer);
+  }
+  async reconcileInvoices(locals, dateRange) {
+    const externals = await this.provider.invoices.list({
+      limit: 100,
+      startDate: dateRange?.start,
+      endDate: dateRange?.end
+    });
+    return reconcileRecords("stripe", locals, externals, compareInvoice);
+  }
+  async reconcileVendors(_locals) {
+    throw new Error("Stripe does not support vendor operations");
+  }
+  async reconcileBills(_locals) {
+    throw new Error("Stripe does not support bill operations");
+  }
+  async reconcilePayments(locals, dateRange) {
+    const externals = await this.provider.payments.list({
+      limit: 100,
+      startDate: dateRange?.start,
+      endDate: dateRange?.end
+    });
+    return reconcileRecords("stripe", locals, externals, comparePayment);
+  }
+}
+class StripeWebhookOperations {
+  constructor(options) {
+    this.options = options;
+  }
+  verify(payload, signature, secret) {
+    const endpointSecret = secret || this.options.webhookSecret;
+    if (!endpointSecret) {
+      throw new Error(
+        "Stripe webhook secret not provided. Pass it as the secret parameter or configure webhookSecret in options."
+      );
+    }
+    const parsed = parseStripeSignatureHeader(signature);
+    if (!parsed.timestamp || parsed.signatures.length === 0) {
+      return false;
+    }
+    const tolerance = this.options.webhookTolerance ?? 300;
+    const timestamp = Number.parseInt(parsed.timestamp, 10);
+    if (!Number.isFinite(timestamp) || Math.abs(Date.now() / 1e3 - timestamp) > tolerance) {
+      return false;
+    }
+    const signedPayload = `${parsed.timestamp}.${payload}`;
+    const expected = createHmac("sha256", endpointSecret).update(signedPayload).digest("hex");
+    return parsed.signatures.some(
+      (value) => constantTimeEqualHex(value, expected)
+    );
+  }
+  parse(payload) {
+    let event;
+    try {
+      event = JSON.parse(payload);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown JSON parse error";
+      throw new Error(`Invalid Stripe webhook payload: ${message}`);
+    }
+    const resource = event?.data?.object;
+    return {
+      type: event?.type || "unknown",
+      provider: "stripe",
+      timestamp: unixToDate(event?.created) || /* @__PURE__ */ new Date(),
+      payload: event,
+      resourceType: mapStripeResourceType(
+        resource?.object || void 0,
+        event?.type || void 0
+      ),
+      resourceId: typeof resource?.id === "string" ? resource.id : void 0
+    };
+  }
+}
+function encodeStripeForm(params) {
+  const form = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    appendStripeFormValue(form, key, value);
+  }
+  return form;
+}
+function appendStripeFormValue(form, key, value) {
+  if (value === void 0 || value === null) {
+    return;
+  }
+  if (value instanceof Date) {
+    form.append(key, String(toUnixSeconds(value)));
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => {
+      appendStripeFormValue(form, `${key}[${index}]`, item);
+    });
+    return;
+  }
+  if (typeof value === "object") {
+    for (const [childKey, childValue] of Object.entries(value)) {
+      appendStripeFormValue(form, `${key}[${childKey}]`, childValue);
+    }
+    return;
+  }
+  form.append(key, String(value));
+}
+function mapCustomerToStripe(customer) {
+  const stripeCustomer = {
+    name: customer.name,
+    email: customer.email,
+    phone: customer.phone,
+    address: customer.billingAddress ? {
+      line1: customer.billingAddress.street1,
+      line2: customer.billingAddress.street2,
+      city: customer.billingAddress.city,
+      state: customer.billingAddress.state,
+      postal_code: customer.billingAddress.postalCode,
+      country: customer.billingAddress.country
+    } : void 0,
+    metadata: normalizeMetadata({
+      local_id: customer.id,
+      payment_terms: customer.paymentTerms,
+      ...customer.metadata
+    })
+  };
+  if (customer.taxExempt !== void 0) {
+    stripeCustomer.tax_exempt = customer.taxExempt ? "exempt" : "none";
+  }
+  return stripeCustomer;
+}
+function mapInvoiceToStripe(invoice) {
+  return {
+    customer: invoice.customerExternalId,
+    collection_method: "send_invoice",
+    due_date: invoice.dueDate,
+    auto_advance: false,
+    pending_invoice_items_behavior: "include",
+    metadata: normalizeMetadata({
+      local_id: invoice.id,
+      invoice_number: invoice.invoiceNumber,
+      reference: invoice.reference,
+      memo: invoice.memo,
+      tax_amount: invoice.taxAmount,
+      subtotal: invoice.subtotal,
+      total_amount: invoice.totalAmount,
+      ...invoice.metadata
+    })
+  };
+}
+function mapInvoiceUpdateToStripe(invoice) {
+  return {
+    due_date: invoice.dueDate,
+    metadata: normalizeMetadata({
+      local_id: invoice.id,
+      invoice_number: invoice.invoiceNumber,
+      reference: invoice.reference,
+      memo: invoice.memo,
+      ...invoice.metadata
+    })
+  };
+}
+function mapCheckoutSessionToStripe(input) {
+  return {
+    mode: input.mode || "subscription",
+    success_url: input.successUrl,
+    cancel_url: input.cancelUrl,
+    customer: input.customerExternalId,
+    customer_email: input.customerExternalId ? void 0 : input.customerEmail,
+    client_reference_id: input.clientReferenceId,
+    allow_promotion_codes: input.allowPromotionCodes,
+    line_items: input.lineItems.map(mapCheckoutLineItem),
+    metadata: normalizeMetadata(input.metadata || {})
+  };
+}
+function mapCheckoutLineItem(lineItem) {
+  if (lineItem.price) {
+    return {
+      price: lineItem.price,
+      quantity: lineItem.quantity || 1
+    };
+  }
+  if (!lineItem.priceData) {
+    throw new Error("Stripe checkout line item requires price or priceData");
+  }
+  const productData = lineItem.priceData.product ? void 0 : { name: lineItem.priceData.productName || "Subscription" };
+  return {
+    quantity: lineItem.quantity || 1,
+    price_data: {
+      currency: lineItem.priceData.currency,
+      unit_amount: lineItem.priceData.unitAmount,
+      product: lineItem.priceData.product,
+      product_data: productData,
+      recurring: lineItem.priceData.recurring ? {
+        interval: lineItem.priceData.recurring.interval,
+        interval_count: lineItem.priceData.recurring.intervalCount
+      } : void 0
+    }
+  };
+}
+function mapListOptions(options) {
+  return {
+    limit: options.limit,
+    starting_after: typeof options.offset === "string" ? options.offset : void 0,
+    created: {
+      gte: options.startDate,
+      lte: options.endDate
+    },
+    status: options.status
+  };
+}
+function mapStripeCustomer(customer) {
+  return {
+    externalId: customer.id,
+    provider: "stripe",
+    syncedAt: /* @__PURE__ */ new Date(),
+    name: customer.name || "",
+    email: customer.email || void 0,
+    phone: customer.phone || void 0,
+    billingAddress: customer.address ? {
+      street1: customer.address.line1 || void 0,
+      street2: customer.address.line2 || void 0,
+      city: customer.address.city || void 0,
+      state: customer.address.state || void 0,
+      postalCode: customer.address.postal_code || void 0,
+      country: customer.address.country || void 0
+    } : void 0,
+    balance: customer.balance === null || customer.balance === void 0 ? void 0 : centsToMoney(customer.balance),
+    currency: customer.currency || void 0,
+    raw: customer
+  };
+}
+function mapStripeInvoice(invoice) {
+  return {
+    externalId: invoice.id,
+    provider: "stripe",
+    syncedAt: /* @__PURE__ */ new Date(),
+    invoiceNumber: invoice.number || invoice.id,
+    customerExternalId: typeof invoice.customer === "string" ? invoice.customer : invoice.customer?.id || "",
+    issueDate: unixToDate(invoice.created) || /* @__PURE__ */ new Date(),
+    dueDate: unixToDate(invoice.due_date) || unixToDate(invoice.created) || /* @__PURE__ */ new Date(),
+    subtotal: centsToMoney(invoice.subtotal || 0),
+    taxAmount: centsToMoney(invoice.tax || 0),
+    totalAmount: centsToMoney(invoice.total || 0),
+    amountPaid: centsToMoney(invoice.amount_paid || 0),
+    balance: centsToMoney(invoice.amount_remaining || 0),
+    status: mapStripeInvoiceStatus(invoice.status, invoice.due_date),
+    currency: invoice.currency || "usd",
+    raw: invoice
+  };
+}
+function mapStripePaymentIntent(paymentIntent) {
+  return {
+    externalId: paymentIntent.id,
+    provider: "stripe",
+    syncedAt: /* @__PURE__ */ new Date(),
+    amount: centsToMoney(paymentIntent.amount || 0),
+    currency: paymentIntent.currency || "usd",
+    paidAt: unixToDate(paymentIntent.created) || /* @__PURE__ */ new Date(),
+    method: paymentIntent.payment_method_types?.[0],
+    transactionId: paymentIntent.latest_charge || paymentIntent.id,
+    invoiceExternalIds: paymentIntent.invoice ? [paymentIntent.invoice] : void 0,
+    status: mapStripePaymentStatus(paymentIntent.status),
+    raw: paymentIntent
+  };
+}
+function mapStripeSubscription(subscription) {
+  return {
+    externalId: subscription.id,
+    status: subscription.status,
+    customerExternalId: typeof subscription.customer === "string" ? subscription.customer : subscription.customer.id,
+    currentPeriodStart: unixToDate(subscription.current_period_start),
+    currentPeriodEnd: unixToDate(subscription.current_period_end),
+    cancelAtPeriodEnd: Boolean(subscription.cancel_at_period_end),
+    canceledAt: unixToDate(subscription.canceled_at),
+    trialEnd: unixToDate(subscription.trial_end),
+    raw: subscription
+  };
+}
+function mapStripeInvoiceStatus(status, dueDate) {
+  switch (status) {
+    case "draft":
+      return "draft";
+    case "paid":
+      return "paid";
+    case "void":
+      return "voided";
+    case "open":
+      if (dueDate && dueDate * 1e3 < Date.now()) {
+        return "overdue";
+      }
+      return "sent";
+    default:
+      return "sent";
+  }
+}
+function mapStripePaymentStatus(status) {
+  switch (status) {
+    case "succeeded":
+      return "completed";
+    case "processing":
+    case "requires_action":
+    case "requires_capture":
+    case "requires_confirmation":
+      return "pending";
+    case "canceled":
+    case "requires_payment_method":
+      return "failed";
+    default:
+      return "pending";
+  }
+}
+function mapStripeResourceType(object, eventType) {
+  if (object === "customer" || eventType?.startsWith("customer.")) {
+    return "customer";
+  }
+  if (object === "invoice" || eventType?.startsWith("invoice.")) {
+    return "invoice";
+  }
+  if (object === "payment_intent" || object === "charge" || eventType?.startsWith("payment_intent.") || eventType?.startsWith("charge.")) {
+    return "payment";
+  }
+  return void 0;
+}
+function normalizeMetadata(metadata) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(metadata)) {
+    if (value !== void 0 && value !== null) {
+      normalized[key] = String(value);
+    }
+  }
+  return normalized;
+}
+function parseStripeSignatureHeader(signature) {
+  const parts = signature.split(",").map((part) => part.trim());
+  const parsed = {
+    signatures: []
+  };
+  for (const part of parts) {
+    const separatorIndex = part.indexOf("=");
+    if (separatorIndex === -1) {
+      continue;
+    }
+    const key = part.slice(0, separatorIndex);
+    const value = part.slice(separatorIndex + 1);
+    if (key === "t") {
+      parsed.timestamp = value;
+    }
+    if (key === "v1" && value) {
+      parsed.signatures.push(value);
+    }
+  }
+  return parsed;
+}
+function constantTimeEqualHex(left, right) {
+  try {
+    const leftBuffer = Buffer.from(left, "hex");
+    const rightBuffer = Buffer.from(right, "hex");
+    return leftBuffer.length === rightBuffer.length && timingSafeEqual(leftBuffer, rightBuffer);
+  } catch {
+    return false;
+  }
+}
+function reconcileRecords(provider, locals, externals, compare) {
+  const externalById = new Map(
+    externals.map((external) => [external.externalId, external])
+  );
+  const matched = [];
+  const discrepancies = [];
+  const localOnly = [];
+  const seenExternalIds = /* @__PURE__ */ new Set();
+  for (const local of locals) {
+    const external = local.externalId ? externalById.get(local.externalId) : void 0;
+    if (!external) {
+      localOnly.push(local);
+      continue;
+    }
+    seenExternalIds.add(external.externalId);
+    const differences = compare(local, external);
+    if (differences.length === 0) {
+      matched.push({ local, external, status: "identical" });
+    } else {
+      discrepancies.push({ local, external, differences });
+    }
+  }
+  const externalOnly = externals.filter(
+    (external) => !seenExternalIds.has(external.externalId)
+  );
+  return {
+    provider,
+    auditedAt: /* @__PURE__ */ new Date(),
+    matched,
+    localOnly,
+    externalOnly,
+    discrepancies,
+    summary: {
+      total: locals.length + externalOnly.length,
+      matched: matched.length,
+      localOnly: localOnly.length,
+      externalOnly: externalOnly.length,
+      discrepancies: discrepancies.length
+    }
+  };
+}
+function compareCustomer(local, external) {
+  const customer = external;
+  return [
+    compareField("name", local.name, customer.name),
+    compareField("email", local.email, customer.email)
+  ].filter((diff) => Boolean(diff));
+}
+function compareInvoice(local, external) {
+  const invoice = external;
+  return [
+    compareField("totalAmount", local.totalAmount, invoice.totalAmount),
+    compareField("currency", local.currency || "usd", invoice.currency)
+  ].filter((diff) => Boolean(diff));
+}
+function comparePayment(local, external) {
+  const payment = external;
+  return [
+    compareField("amount", local.amount, payment.amount),
+    compareField("currency", local.currency || "usd", payment.currency)
+  ].filter((diff) => Boolean(diff));
+}
+function compareField(field, localValue, externalValue) {
+  if (valuesEqual(localValue, externalValue)) {
+    return null;
+  }
+  return { field, localValue, externalValue };
+}
+function valuesEqual(left, right) {
+  if (left === right) {
+    return true;
+  }
+  if (typeof left === "number" && typeof right === "number") {
+    return Math.abs(left - right) < 0.01;
+  }
+  return false;
+}
+function centsToMoney(cents) {
+  return cents / 100;
+}
+function toUnixSeconds(date) {
+  return Math.floor(date.getTime() / 1e3);
+}
+function unixToDate(value) {
+  return value === null || value === void 0 ? void 0 : new Date(value * 1e3);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export {
+  StripeProvider
+};
+//# sourceMappingURL=index-DO-cM79R.js.map