@stripe/link-sdk 0.2.0

package/dist/index.js

@@ -0,0 +1,773 @@
+// src/errors.ts
+import { ZodError, prettifyError } from "zod";
+var LinkSdkError = class extends Error {
+  code;
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = new.target.name;
+    this.code = options?.code ?? "sdk_error";
+  }
+};
+var LinkResponseError = class extends LinkSdkError {
+  status;
+  constructor(operation, status, options) {
+    const detail = options?.cause instanceof ZodError ? `: ${prettifyError(options.cause)}` : options?.cause instanceof Error ? `: ${options.cause.message}` : "";
+    super(
+      `Invalid response while attempting to ${operation} (${status})${detail}`,
+      { code: "invalid_response", cause: options?.cause }
+    );
+    this.status = status;
+  }
+};
+var LinkConfigurationError = class extends LinkSdkError {
+  constructor(message, options) {
+    super(message, { code: "configuration_error", ...options });
+  }
+};
+var LinkTransportError = class extends LinkSdkError {
+  constructor(message, options) {
+    super(message, { code: "transport_error", ...options });
+  }
+};
+var LinkApiError = class extends LinkSdkError {
+  status;
+  rawBody;
+  details;
+  constructor(message, options) {
+    super(message, { code: options.code ?? "api_error", cause: options.cause });
+    this.status = options.status;
+    this.rawBody = options.rawBody;
+    this.details = options.details;
+  }
+};
+
+// src/config.ts
+var DEFAULT_API_BASE_URL = "https://api.link.com";
+function createDefaultHeadersFetch(baseFetch, defaultHeaders) {
+  return ((input, init) => {
+    const headers = new Headers(init?.headers);
+    for (const [key, value] of Object.entries(defaultHeaders)) {
+      if (!headers.has(key)) {
+        headers.set(key, value);
+      }
+    }
+    return baseFetch(input, { ...init, headers });
+  });
+}
+function createDefaultLogger() {
+  return {
+    debug() {
+    }
+  };
+}
+function resolveLinkSdkConfig(options, defaults = {}) {
+  const verbose = options.verbose ?? false;
+  const logger = options.logger ?? createDefaultLogger();
+  if (options.accessToken !== void 0 && options.getAccessToken !== void 0) {
+    throw new LinkConfigurationError(
+      "Pass either `accessToken` or `getAccessToken`, not both."
+    );
+  }
+  let getAccessToken;
+  let canRefreshAccessToken;
+  if (options.accessToken !== void 0) {
+    if (options.accessToken.trim().length === 0) {
+      throw new LinkConfigurationError("`accessToken` cannot be empty.");
+    }
+    const accessToken = options.accessToken;
+    getAccessToken = () => accessToken;
+    canRefreshAccessToken = false;
+  } else if (typeof options.getAccessToken === "function") {
+    getAccessToken = options.getAccessToken;
+    canRefreshAccessToken = true;
+  } else {
+    throw new LinkConfigurationError(
+      "Pass `accessToken` or `getAccessToken` to the Link client."
+    );
+  }
+  const apiBaseUrl = options.apiBaseUrl ?? defaults.apiBaseUrl ?? DEFAULT_API_BASE_URL;
+  const spendRequestBaseUrl = options.spendRequestBaseUrl ?? defaults.spendRequestBaseUrl ?? apiBaseUrl;
+  const baseFetch = options.fetch ?? globalThis.fetch;
+  const effectiveFetch = options.defaultHeaders && Object.keys(options.defaultHeaders).length > 0 ? createDefaultHeadersFetch(baseFetch, options.defaultHeaders) : baseFetch;
+  return {
+    verbose,
+    getAccessToken,
+    canRefreshAccessToken,
+    fetch: effectiveFetch,
+    apiBaseUrl,
+    spendRequestBaseUrl,
+    logger
+  };
+}
+function requireFetchImplementation(config) {
+  if (!config.fetch) {
+    throw new LinkConfigurationError(
+      "No fetch implementation available. Pass `fetch` in Link SDK options."
+    );
+  }
+  return config.fetch;
+}
+
+// src/resources/base.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function extractErrorMessage(data, rawBody) {
+  if (isRecord(data)) {
+    if (typeof data.error === "string") {
+      return data.error;
+    }
+    if (isRecord(data.error)) {
+      const nested = data.error;
+      if (typeof nested.message === "string") {
+        return nested.message;
+      }
+      if (typeof nested.code === "string") {
+        return nested.code;
+      }
+    }
+    if (typeof data.message === "string") {
+      return data.message;
+    }
+  }
+  return rawBody || "unknown error";
+}
+var BaseResource = class {
+  verbose;
+  getAccessToken;
+  canRefreshAccessToken;
+  fetchImpl;
+  endpoint;
+  logger;
+  constructor(options, endpointPath, base = "api") {
+    const config = resolveLinkSdkConfig(options);
+    this.verbose = config.verbose;
+    this.getAccessToken = config.getAccessToken;
+    this.canRefreshAccessToken = config.canRefreshAccessToken;
+    this.fetchImpl = requireFetchImplementation(config);
+    const baseUrl = base === "spend" ? config.spendRequestBaseUrl : config.apiBaseUrl;
+    this.endpoint = `${baseUrl}${endpointPath}`;
+    this.logger = config.logger;
+  }
+  async rawFetch(opts) {
+    if (this.verbose) {
+      this.logger.debug(`> ${opts.method} ${opts.url}`);
+    }
+    let response;
+    try {
+      const init = {
+        method: opts.method,
+        ...opts.headers !== void 0 && { headers: opts.headers },
+        ...opts.body !== void 0 && { body: opts.body },
+        ...opts.signal !== void 0 && { signal: opts.signal }
+      };
+      response = await this.fetchImpl(opts.url, init);
+    } catch (error) {
+      throw new LinkTransportError(
+        `Request failed: ${opts.method} ${opts.url}`,
+        { cause: error }
+      );
+    }
+    const rawBody = await response.text();
+    let data = null;
+    try {
+      data = JSON.parse(rawBody);
+    } catch {
+    }
+    if (this.verbose) {
+      this.logger.debug(`< ${response.status} ${response.statusText}`);
+    }
+    return { status: response.status, data, rawBody };
+  }
+  async apiFetch(opts) {
+    const token = await this.getAccessToken();
+    const authedOpts = {
+      ...opts,
+      headers: {
+        ...opts.headers,
+        Authorization: `Bearer ${token}`
+      }
+    };
+    const res = await this.rawFetch(authedOpts);
+    if (res.status === 401 && this.canRefreshAccessToken) {
+      const refreshedToken = await this.getAccessToken({ forceRefresh: true });
+      authedOpts.headers.Authorization = `Bearer ${refreshedToken}`;
+      return this.rawFetch(authedOpts);
+    }
+    return res;
+  }
+  throwApiError(operation, status, data, rawBody, cause) {
+    const msg = extractErrorMessage(data, rawBody);
+    throw new LinkApiError(`Failed to ${operation} (${status}): ${msg}`, {
+      status,
+      rawBody,
+      details: data,
+      cause
+    });
+  }
+  parseResponse(operation, status, parser) {
+    try {
+      return parser();
+    } catch (error) {
+      throw new LinkResponseError(operation, status, { cause: error });
+    }
+  }
+};
+
+// src/resources/balances.ts
+import { z } from "zod";
+var currencyAmountsSchema = z.record(z.string(), z.number());
+var balanceSchema = z.looseObject({
+  source_id: z.string(),
+  type: z.enum(["cash", "credit"]),
+  cash: z.looseObject({ available: currencyAmountsSchema }).nullable().optional(),
+  credit: z.looseObject({ used: currencyAmountsSchema }).nullable().optional(),
+  current: z.number(),
+  currency: z.string(),
+  as_of: z.string()
+});
+var balancesPageSchema = z.looseObject({
+  data: z.array(balanceSchema),
+  has_more: z.boolean().optional()
+});
+var BalancesResource = class extends BaseResource {
+  constructor(options) {
+    super(options, "/balances");
+  }
+  buildUrl(params) {
+    const url = new URL(this.endpoint);
+    if (params.sources !== void 0) {
+      for (const source of params.sources) {
+        url.searchParams.append("sources[]", source);
+      }
+    }
+    if (params.limit !== void 0) {
+      url.searchParams.set("limit", String(params.limit));
+    }
+    if (params.starting_after !== void 0) {
+      url.searchParams.set("starting_after", params.starting_after);
+    }
+    if (params.ending_before !== void 0) {
+      url.searchParams.set("ending_before", params.ending_before);
+    }
+    return url.toString();
+  }
+  async list(params = {}) {
+    const { status, data, rawBody } = await this.apiFetch({
+      method: "GET",
+      url: this.buildUrl(params)
+    });
+    if (status < 200 || status >= 300) {
+      this.throwApiError("list balances", status, data, rawBody);
+    }
+    return this.parseResponse(
+      "list balances",
+      status,
+      () => balancesPageSchema.parse(data)
+    );
+  }
+};
+
+// src/resources/payment-methods.ts
+import { z as z2 } from "zod";
+var paymentMethodSchema = z2.looseObject({
+  id: z2.string(),
+  type: z2.string(),
+  is_default: z2.boolean()
+});
+var paymentMethodsResponseSchema = z2.looseObject({
+  payment_details: z2.array(paymentMethodSchema)
+});
+var PaymentMethodsResource = class extends BaseResource {
+  constructor(options) {
+    super(options, "/payment-details");
+  }
+  async list() {
+    const { status, data, rawBody } = await this.apiFetch({
+      method: "GET",
+      url: this.endpoint
+    });
+    if (status < 200 || status >= 300) {
+      this.throwApiError("list payment methods", status, data, rawBody);
+    }
+    return this.parseResponse(
+      "list payment methods",
+      status,
+      () => paymentMethodsResponseSchema.parse(data).payment_details
+    );
+  }
+};
+
+// src/resources/report.ts
+import { z as z3 } from "zod";
+var reportRecordSchema = z3.looseObject({
+  object: z3.string(),
+  created_at: z3.string(),
+  domain: z3.string(),
+  outcome: z3.string(),
+  spend_request_id: z3.string(),
+  status: z3.string()
+});
+var ReportResource = class extends BaseResource {
+  constructor(options) {
+    super(options, "/agent_observations");
+  }
+  async create(params) {
+    const { status, data, rawBody } = await this.apiFetch({
+      method: "POST",
+      url: this.endpoint,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(params)
+    });
+    if (status < 200 || status >= 300) {
+      this.throwApiError("create report", status, data, rawBody);
+    }
+    return this.parseResponse(
+      "create report",
+      status,
+      () => reportRecordSchema.parse(data)
+    );
+  }
+};
+
+// src/resources/shipping-address.ts
+import { z as z4 } from "zod";
+var shippingAddressSchema = z4.looseObject({
+  id: z4.string(),
+  is_default: z4.boolean(),
+  nickname: z4.string().nullable(),
+  address: z4.looseObject({}).nullable()
+});
+var shippingAddressesResponseSchema = z4.looseObject({
+  shipping_addresses: z4.array(shippingAddressSchema)
+});
+var ShippingAddressResource = class extends BaseResource {
+  constructor(options) {
+    super(options, "/shipping_addresses");
+  }
+  async list() {
+    const { status, data, rawBody } = await this.apiFetch({
+      method: "GET",
+      url: this.endpoint
+    });
+    if (status < 200 || status >= 300) {
+      this.throwApiError("list shipping addresses", status, data, rawBody);
+    }
+    return this.parseResponse(
+      "list shipping addresses",
+      status,
+      () => shippingAddressesResponseSchema.parse(data).shipping_addresses
+    );
+  }
+};
+
+// src/resources/sources.ts
+import { z as z5 } from "zod";
+var nullableRecordSchema = z5.record(z5.string(), z5.unknown()).nullable().optional();
+var sourceSchema = z5.looseObject({
+  id: z5.string().nullable().optional(),
+  name: z5.string().nullable().optional(),
+  type: z5.string().nullable().optional(),
+  capabilities: nullableRecordSchema,
+  external_connection: nullableRecordSchema,
+  granted_actions: z5.array(z5.string()).nullable().optional(),
+  bank_account: nullableRecordSchema,
+  card: nullableRecordSchema
+});
+var sourcesPageSchema = z5.looseObject({
+  data: z5.array(sourceSchema),
+  has_more: z5.boolean().optional()
+});
+var SourcesResource = class extends BaseResource {
+  constructor(options) {
+    super(options, "/sources");
+  }
+  buildUrl(params) {
+    const url = new URL(this.endpoint);
+    if (params.limit !== void 0) {
+      url.searchParams.set("limit", String(params.limit));
+    }
+    if (params.starting_after !== void 0) {
+      url.searchParams.set("starting_after", params.starting_after);
+    }
+    if (params.ending_before !== void 0) {
+      url.searchParams.set("ending_before", params.ending_before);
+    }
+    return url.toString();
+  }
+  async list(params = {}) {
+    const { status, data, rawBody } = await this.apiFetch({
+      method: "GET",
+      url: this.buildUrl(params)
+    });
+    if (status < 200 || status >= 300) {
+      this.throwApiError("list sources", status, data, rawBody);
+    }
+    return this.parseResponse(
+      "list sources",
+      status,
+      () => sourcesPageSchema.parse(data)
+    );
+  }
+};
+
+// src/resources/spend-request.ts
+import { z as z6 } from "zod";
+var sharedPaymentTokenSchema = z6.union([
+  z6.string().transform((id) => ({ id })),
+  z6.looseObject({ id: z6.string() })
+]);
+var spendRequestSchema = z6.looseObject({
+  id: z6.string(),
+  payment_details: z6.string().optional(),
+  status: z6.string(),
+  line_items: z6.array(z6.unknown()).optional(),
+  totals: z6.array(z6.unknown()).optional(),
+  created_at: z6.string(),
+  updated_at: z6.string(),
+  shared_payment_token: sharedPaymentTokenSchema.nullable().optional()
+});
+var spendRequestsResponseSchema = z6.looseObject({
+  data: z6.array(spendRequestSchema)
+});
+var requestApprovalResponseSchema = z6.looseObject({
+  id: z6.string(),
+  approval_link: z6.string()
+}).transform(({ approval_link, ...response }) => ({
+  ...response,
+  approval_url: approval_link
+}));
+var duplicateSpendRequestErrorSchema = z6.looseObject({
+  error: z6.looseObject({
+    duplicate_spend_request: z6.unknown().optional()
+  })
+});
+function parseSpendRequest(value) {
+  return spendRequestSchema.parse(value);
+}
+function getDuplicateSpendRequest(error) {
+  if (!(error instanceof LinkApiError)) return null;
+  const details = duplicateSpendRequestErrorSchema.safeParse(error.details);
+  if (!details.success) return null;
+  const duplicate = spendRequestSchema.safeParse(
+    details.data.error.duplicate_spend_request
+  );
+  return duplicate.success ? duplicate.data : null;
+}
+var SpendRequestResource = class extends BaseResource {
+  constructor(options) {
+    super(options, "/spend_requests", "spend");
+  }
+  async list(opts) {
+    const url = opts?.includeHistory ? `${this.endpoint}?include_history=true` : this.endpoint;
+    const { status, data, rawBody } = await this.apiFetch({
+      method: "GET",
+      url
+    });
+    if (status < 200 || status >= 300) {
+      this.throwApiError("list spend requests", status, data, rawBody);
+    }
+    return this.parseResponse(
+      "list spend requests",
+      status,
+      () => spendRequestsResponseSchema.parse(data).data
+    );
+  }
+  async create(params) {
+    const { approve, ...body } = params;
+    const url = approve ? `${this.endpoint}/create_delegated` : this.endpoint;
+    const { status, data, rawBody } = await this.apiFetch({
+      method: "POST",
+      url,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (status < 200 || status >= 300) {
+      this.throwApiError("create spend request", status, data, rawBody);
+    }
+    return this.parseResponse(
+      "create spend request",
+      status,
+      () => parseSpendRequest(data)
+    );
+  }
+  async update(id, params) {
+    const { status, data, rawBody } = await this.apiFetch({
+      method: "POST",
+      url: `${this.endpoint}/${id}`,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(params)
+    });
+    if (status < 200 || status >= 300) {
+      this.throwApiError("update spend request", status, data, rawBody);
+    }
+    return this.parseResponse(
+      "update spend request",
+      status,
+      () => parseSpendRequest(data)
+    );
+  }
+  async cancel(id) {
+    const { status, data, rawBody } = await this.apiFetch({
+      method: "POST",
+      url: `${this.endpoint}/${id}/cancel`
+    });
+    if (status < 200 || status >= 300) {
+      this.throwApiError("cancel spend request", status, data, rawBody);
+    }
+    return this.parseResponse(
+      "cancel spend request",
+      status,
+      () => parseSpendRequest(data)
+    );
+  }
+  async requestApproval(id) {
+    const { status, data, rawBody } = await this.apiFetch({
+      method: "POST",
+      url: `${this.endpoint}/${id}/request_approval`
+    });
+    if (status < 200 || status >= 300) {
+      this.throwApiError("request approval", status, data, rawBody);
+    }
+    return this.parseResponse(
+      "request approval",
+      status,
+      () => requestApprovalResponseSchema.parse(data)
+    );
+  }
+  async retrieve(id, opts) {
+    const url = new URL(`${this.endpoint}/${id}`);
+    if (opts?.include?.length) {
+      url.searchParams.set("include", opts.include.join(","));
+    }
+    const { status, data, rawBody } = await this.apiFetch({
+      method: "GET",
+      url: url.toString()
+    });
+    if (status === 404) return null;
+    if (status < 200 || status >= 300) {
+      this.throwApiError("retrieve spend request", status, data, rawBody);
+    }
+    return this.parseResponse(
+      "retrieve spend request",
+      status,
+      () => parseSpendRequest(data)
+    );
+  }
+};
+
+// src/resources/transactions.ts
+import { z as z7 } from "zod";
+var transactionSchema = z7.looseObject({
+  id: z7.string(),
+  source_id: z7.string().nullable(),
+  amount: z7.number(),
+  currency: z7.string(),
+  created_date: z7.string(),
+  description: z7.string(),
+  origin: z7.enum(["link", "external_connection"]),
+  category: z7.string().nullable(),
+  status: z7.string()
+});
+var transactionsPageSchema = z7.union([
+  z7.array(transactionSchema).transform((data) => ({ data })),
+  z7.looseObject({
+    data: z7.array(transactionSchema),
+    has_more: z7.boolean().optional()
+  })
+]);
+var TransactionsResource = class extends BaseResource {
+  constructor(options) {
+    super(options, "/transactions");
+  }
+  buildUrl(params) {
+    const url = new URL(this.endpoint);
+    if (params.limit !== void 0) {
+      url.searchParams.set("limit", String(params.limit));
+    }
+    if (params.starting_after !== void 0) {
+      url.searchParams.set("starting_after", params.starting_after);
+    }
+    if (params.ending_before !== void 0) {
+      url.searchParams.set("ending_before", params.ending_before);
+    }
+    if (params.start_date !== void 0) {
+      url.searchParams.set("date_start", params.start_date);
+    }
+    if (params.end_date !== void 0) {
+      url.searchParams.set("date_end", params.end_date);
+    }
+    if (params.category !== void 0) {
+      url.searchParams.set("category", params.category);
+    }
+    if (params.origin !== void 0) {
+      url.searchParams.set("origin", params.origin);
+    }
+    if (params.sources !== void 0) {
+      for (const source of params.sources) {
+        url.searchParams.append("sources[]", source);
+      }
+    }
+    return url.toString();
+  }
+  async list(params = {}) {
+    const { status, data, rawBody } = await this.apiFetch({
+      method: "GET",
+      url: this.buildUrl(params)
+    });
+    if (status < 200 || status >= 300) {
+      this.throwApiError("list transactions", status, data, rawBody);
+    }
+    return this.parseResponse(
+      "list transactions",
+      status,
+      () => transactionsPageSchema.parse(data)
+    );
+  }
+};
+
+// src/resources/user-info.ts
+import { z as z8 } from "zod";
+var userInfoSchema = z8.looseObject({
+  email: z8.string().nullable().optional(),
+  name: z8.string().nullable().optional(),
+  first_name: z8.string().nullable().optional(),
+  last_name: z8.string().nullable().optional(),
+  phone: z8.string().nullable().optional()
+}).transform(({ email, name, first_name, last_name, phone }) => ({
+  email: email ?? null,
+  name: name ?? null,
+  first_name: first_name ?? null,
+  last_name: last_name ?? null,
+  phone: phone ?? null
+}));
+var UserInfoResource = class extends BaseResource {
+  constructor(options) {
+    super(options, "/userinfo");
+  }
+  async retrieve() {
+    const { status, data, rawBody } = await this.apiFetch({
+      method: "GET",
+      url: this.endpoint
+    });
+    if (status < 200 || status >= 300) {
+      this.throwApiError("retrieve user info", status, data, rawBody);
+    }
+    return this.parseResponse(
+      "retrieve user info",
+      status,
+      () => userInfoSchema.parse(data)
+    );
+  }
+};
+
+// src/resources/web-bot-auth.ts
+import { z as z9 } from "zod";
+var EXPIRY_BUFFER_MS = 3e4;
+var webBotAuthBlockSchema = z9.looseObject({
+  signature: z9.string(),
+  signature_input: z9.string(),
+  signature_agent: z9.string(),
+  authority: z9.string(),
+  expires_at: z9.string()
+});
+var webBotAuthResponseSchema = z9.looseObject({
+  web_bot_auth: webBotAuthBlockSchema
+});
+var WebBotAuthResource = class extends BaseResource {
+  cache = /* @__PURE__ */ new Map();
+  constructor(options) {
+    super(options, "/web_bot_auth/sign");
+  }
+  async signUrl(url) {
+    let authority;
+    try {
+      authority = new URL(url).hostname;
+    } catch (error) {
+      throw new LinkSdkError(`Invalid URL: ${url}`, { cause: error });
+    }
+    const cached = this.cache.get(authority);
+    if (cached && Date.now() < cached.expiresAt - EXPIRY_BUFFER_MS) {
+      return cached.block;
+    }
+    const { status, data, rawBody } = await this.apiFetch({
+      method: "POST",
+      url: this.endpoint,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ url })
+    });
+    if (status < 200 || status >= 300) {
+      this.throwApiError("get web bot auth headers", status, data, rawBody);
+    }
+    const webBotAuth = this.parseResponse(
+      "get web bot auth headers",
+      status,
+      () => webBotAuthResponseSchema.parse(data).web_bot_auth
+    );
+    const expiresAt = Date.parse(webBotAuth.expires_at);
+    if (Number.isNaN(expiresAt)) {
+      throw new LinkSdkError(
+        `Credentials response has invalid expires_at: ${webBotAuth.expires_at}`
+      );
+    }
+    this.cache.set(authority, { block: webBotAuth, expiresAt });
+    return webBotAuth;
+  }
+};
+
+// src/client.ts
+var Link = class {
+  spendRequests;
+  paymentMethods;
+  shippingAddresses;
+  userInfo;
+  transactions;
+  sources;
+  balances;
+  webBotAuth;
+  reports;
+  constructor(options) {
+    this.spendRequests = new SpendRequestResource(options);
+    this.paymentMethods = new PaymentMethodsResource(options);
+    this.shippingAddresses = new ShippingAddressResource(options);
+    this.userInfo = new UserInfoResource(options);
+    this.transactions = new TransactionsResource(options);
+    this.sources = new SourcesResource(options);
+    this.balances = new BalancesResource(options);
+    this.webBotAuth = new WebBotAuthResource(options);
+    this.reports = new ReportResource(options);
+  }
+};
+var client_default = Link;
+
+// src/resources/interfaces.ts
+var REPORT_OUTCOMES = ["success", "blocked", "abandoned"];
+var REPORT_TAGS = [
+  "stripe_checkout",
+  "captcha",
+  "anti_bot_script",
+  "cdn_block",
+  "waf_block",
+  "dns_block",
+  "rate_limited",
+  "login_required",
+  "3ds_challenge",
+  "page_inaccessible",
+  "timeout",
+  "site_error",
+  "payment_declined",
+  "other"
+];
+export {
+  Link,
+  LinkApiError,
+  LinkConfigurationError,
+  LinkResponseError,
+  LinkSdkError,
+  LinkTransportError,
+  REPORT_OUTCOMES,
+  REPORT_TAGS,
+  client_default as default,
+  getDuplicateSpendRequest
+};
+//# sourceMappingURL=index.js.map