@nodii/onboarding 0.0.1 → 0.1.0

package/dist/signup-client-BL5DfarJ.d.ts

@@ -0,0 +1,392 @@
+import { z } from 'zod/v3';
+import { T as TerminalStage } from './model-ESLSEbi0.js';
+import { e as ConsentSubmitDocument } from './controller-BQb62D0N.js';
+import { C as ContactFormValues } from './schema-BrXb9gnh.js';
+
+/**
+ * Submit client for POST /api/v1/public/onboarding/leads.
+ *
+ * Contract per D540 + hub REST interface 8686dd33:
+ *   - Idempotency-Key header REQUIRED (uuid v4, generated ONCE per logical
+ *     submission, REUSED on retries — same key = exactly-once delivery).
+ *   - Outgoing payload validated through leadsWireSchema (STRICT — unknown
+ *     keys rejected, matching additionalProperties:false) BEFORE any fetch.
+ *   - botToken in request body (D537).
+ *   - Response: { accepted: true } on 200/202 (empty/non-JSON 2xx body is
+ *     treated as acceptance; a JSON body that does not confirm acceptance
+ *     throws OnboardingServerError — see parseSuccessBody).
+ *   - 403 bot_challenge_failed  → throw OnboardingBotChallengeError (no retry)
+ *   - 409 spec_stale (D540)     → throw OnboardingSpecStaleError (no retry)
+ *   - 422                       → throw OnboardingValidationError (no retry)
+ *   - 429                       → throw OnboardingRateLimitError (no auto-retry)
+ *   - 5xx                       → retry with SAME idempotency key, capped backoff
+ *   - network error             → retry with SAME idempotency key, capped backoff
+ *
+ * Max retries: 3 attempts total (1 initial + 2 retries).
+ * Backoff: 1s, 2s (capped at 2 retries).
+ */
+
+/**
+ * A bot token, or a provider that mints a FRESH one per attempt.
+ *
+ * reCAPTCHA tokens are SINGLE-USE — the server consumes them at siteverify.
+ * If a 5xx happens AFTER the token was consumed, resending the same token on
+ * retry gets 403. Pass a provider function to mint a fresh token per attempt;
+ * a bare string is back-compat but the caller then OWNS that risk.
+ */
+type BotTokenSource = string | (() => string | Promise<string>);
+declare function resolveBotToken(source: BotTokenSource): Promise<string>;
+interface LeadsSubmitOptions {
+    baseUrl: string;
+    /**
+     * reCAPTCHA token (D537), or a provider called ONCE PER ATTEMPT to mint a
+     * fresh token (recommended — tokens are single-use; a fixed string on a
+     * retried request risks 403 after the first attempt consumed it).
+     */
+    botToken?: BotTokenSource;
+    /**
+     * Stable idempotency key for this submission. Generate ONCE with
+     * `generateIdempotencyKey()` and pass the same key for retries.
+     * The server chains this key through to D538 for exactly-once delivery.
+     */
+    idempotencyKey: string;
+    /** Optional custom fetch implementation (defaults to global fetch). */
+    fetch?: typeof globalThis.fetch;
+    /**
+     * Per-attempt request timeout in ms (default 15s). A stalled intake aborts
+     * with OnboardingNetworkError so the widget re-enables instead of hanging.
+     */
+    timeoutMs?: number;
+    /** Optional onAttempt callback for observability (attempt number, 1-based). */
+    onAttempt?: (attempt: number) => void;
+}
+interface LeadsSubmitResult {
+    accepted: true;
+}
+/**
+ * Generate a stable idempotency key for one logical submission.
+ * Uses the Web Crypto API (available in all modern browsers + Bun/Node >= 19).
+ * Call ONCE per user submission, pass the SAME key on retries.
+ */
+declare function generateIdempotencyKey(): string;
+/**
+ * Compute a stable fingerprint of the outgoing lead payload, EXCLUDING
+ * botToken (which is fresh per attempt by design).
+ *
+ * The widget uses this to decide whether a resubmission is a RETRY of the
+ * same logical submission (same fingerprint → reuse the Idempotency-Key)
+ * or a NEW logical submission (fingerprint changed because the user edited
+ * fields → mint a NEW key). This mirrors the server's D538 payload-match
+ * guard: same key + different payload is INVALID_ARGUMENT server-side.
+ *
+ * FNV-1a 32-bit over a stable JSON serialization of [name, email, phone,
+ * message]. Collision risk is irrelevant here — a collision only means an
+ * unnecessary key reuse across two submissions from the same browser tab.
+ */
+declare function computePayloadFingerprint(values: ContactFormValues): string;
+/**
+ * Submit a contact-form lead to the onboarding intake.
+ *
+ * The outgoing payload is validated through leadsWireSchema in STRICT mode
+ * before any network I/O — unknown keys are rejected client-side, exactly
+ * mirroring the server's additionalProperties:false.
+ *
+ * Handles retry semantics: 5xx and network errors are retried up to
+ * MAX_ATTEMPTS total, always with the SAME idempotencyKey to guarantee
+ * exactly-once server-side processing (D538 idempotency chain).
+ *
+ * 403, 409, 422 and 429 are NOT retried — caller handles them.
+ *
+ * @throws {OnboardingValidationError} if the payload fails the strict wire
+ *   schema (unknown keys, constraint violations) — thrown BEFORE any fetch
+ * @throws {OnboardingBotChallengeError} on 403, or if the bot-token provider
+ *   throws (reCAPTCHA unreachable) on any attempt
+ * @throws {OnboardingConflictError} on 409 (leads has no spec_stale concept)
+ * @throws {OnboardingRateLimitError} on 429
+ * @throws {OnboardingServerError} on 5xx after all retries exhausted, or on
+ *   a 2xx whose JSON body does not confirm acceptance
+ * @throws {OnboardingNetworkError} on network failure OR timeout after all
+ *   retries exhausted
+ * @throws {OnboardingValidationError} on 422 (server-side re-validation)
+ */
+declare function submitLead(values: ContactFormValues, options: LeadsSubmitOptions): Promise<LeadsSubmitResult>;
+
+/**
+ * Submit client for POST /api/v1/public/onboarding/submit (D540 §2).
+ *
+ * Contract per the LOCKED hub REST interface (PublicOnboardingSubmitRequest):
+ *   - Body: { specVersion, answers, selectedServices?, botToken,
+ *             consent:{tosAccepted:true, privacyAccepted:true},
+ *             credentials:{email, displayName?}, organisationName?, subdomain }
+ *     additionalProperties: false — validated STRICTLY client-side before
+ *     any fetch (unknown keys are rejected, not stripped).
+ *   - Idempotency-Key header REQUIRED (same D538 discipline as leads:
+ *     stable across retries of the SAME payload; the widget mints a new
+ *     key when the payload fingerprint changes).
+ *   - specVersion policy is reject-stale: 409 → OnboardingSpecStaleError
+ *     carrying the server's current version. The CALLER refetches the spec
+ *     and surfaces re-validation to the user — NEVER silent auto-resubmit.
+ *   - Response: { accepted:true, terminalStage, verificationEmailSent? }.
+ *
+ * Success-body rule for /submit (DIFFERENT from /leads, deliberately):
+ * the response carries REQUIRED routing data (terminalStage decides what
+ * the UI shows next), so a 2xx with an empty/unparseable/garbage body is
+ * an OnboardingServerError — the SDK will not fabricate a terminal stage.
+ * (/leads tolerates body-less 2xx because its only signal IS the status.)
+ */
+
+/**
+ * STRICT wire schema for ONE element of the D543 §4 consent.documents array.
+ * `accepted` is const-true (an unaccepted doc is never sent — the consent
+ * controller omits it), and `evidence` carries only the gate-relevant flags.
+ */
+declare const consentSubmitDocumentSchema: z.ZodObject<{
+    legalDocumentId: z.ZodString;
+    versionNo: z.ZodNumber;
+    accepted: z.ZodLiteral<true>;
+    evidence: z.ZodObject<{
+        scrolled_to_end: z.ZodOptional<z.ZodBoolean>;
+        opened: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        opened?: boolean | undefined;
+        scrolled_to_end?: boolean | undefined;
+    }, {
+        opened?: boolean | undefined;
+        scrolled_to_end?: boolean | undefined;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    legalDocumentId: string;
+    versionNo: number;
+    accepted: true;
+    evidence: {
+        opened?: boolean | undefined;
+        scrolled_to_end?: boolean | undefined;
+    };
+}, {
+    legalDocumentId: string;
+    versionNo: number;
+    accepted: true;
+    evidence: {
+        opened?: boolean | undefined;
+        scrolled_to_end?: boolean | undefined;
+    };
+}>;
+/**
+ * STRICT wire schema — mirrors PublicOnboardingSubmitRequest exactly
+ * (additionalProperties: false; consent booleans are const-true; passwordless
+ * per D1010, with the workspace subdomain required by D836).
+ *
+ * D543 §4: `consent` extends from booleans to a per-document array. The
+ * `documents` array is AUTHORITATIVE (the server re-validates it); the
+ * `tosAccepted`/`privacyAccepted` booleans are kept as a DERIVED convenience
+ * (D543 "kept as a derived convenience only"). `documents` is OPTIONAL on the
+ * wire for backward-compat — a pre-ConsentPack onboarder serves no consentPack
+ * and submits the booleans alone (D543 "pre-ConsentPack submits still parse").
+ */
+declare const signupWireSchema: z.ZodObject<{
+    specVersion: z.ZodString;
+    answers: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    selectedServices: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    botToken: z.ZodOptional<z.ZodString>;
+    consent: z.ZodObject<{
+        tosAccepted: z.ZodLiteral<true>;
+        privacyAccepted: z.ZodLiteral<true>;
+        documents: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            legalDocumentId: z.ZodString;
+            versionNo: z.ZodNumber;
+            accepted: z.ZodLiteral<true>;
+            evidence: z.ZodObject<{
+                scrolled_to_end: z.ZodOptional<z.ZodBoolean>;
+                opened: z.ZodOptional<z.ZodBoolean>;
+            }, "strict", z.ZodTypeAny, {
+                opened?: boolean | undefined;
+                scrolled_to_end?: boolean | undefined;
+            }, {
+                opened?: boolean | undefined;
+                scrolled_to_end?: boolean | undefined;
+            }>;
+        }, "strict", z.ZodTypeAny, {
+            legalDocumentId: string;
+            versionNo: number;
+            accepted: true;
+            evidence: {
+                opened?: boolean | undefined;
+                scrolled_to_end?: boolean | undefined;
+            };
+        }, {
+            legalDocumentId: string;
+            versionNo: number;
+            accepted: true;
+            evidence: {
+                opened?: boolean | undefined;
+                scrolled_to_end?: boolean | undefined;
+            };
+        }>, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        tosAccepted: true;
+        privacyAccepted: true;
+        documents?: {
+            legalDocumentId: string;
+            versionNo: number;
+            accepted: true;
+            evidence: {
+                opened?: boolean | undefined;
+                scrolled_to_end?: boolean | undefined;
+            };
+        }[] | undefined;
+    }, {
+        tosAccepted: true;
+        privacyAccepted: true;
+        documents?: {
+            legalDocumentId: string;
+            versionNo: number;
+            accepted: true;
+            evidence: {
+                opened?: boolean | undefined;
+                scrolled_to_end?: boolean | undefined;
+            };
+        }[] | undefined;
+    }>;
+    credentials: z.ZodObject<{
+        email: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        email: string;
+        displayName?: string | undefined;
+    }, {
+        email: string;
+        displayName?: string | undefined;
+    }>;
+    organisationName: z.ZodOptional<z.ZodString>;
+    subdomain: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    specVersion: string;
+    credentials: {
+        email: string;
+        displayName?: string | undefined;
+    };
+    subdomain: string;
+    answers: Record<string, unknown>;
+    consent: {
+        tosAccepted: true;
+        privacyAccepted: true;
+        documents?: {
+            legalDocumentId: string;
+            versionNo: number;
+            accepted: true;
+            evidence: {
+                opened?: boolean | undefined;
+                scrolled_to_end?: boolean | undefined;
+            };
+        }[] | undefined;
+    };
+    botToken?: string | undefined;
+    organisationName?: string | undefined;
+    selectedServices?: string[] | undefined;
+}, {
+    specVersion: string;
+    credentials: {
+        email: string;
+        displayName?: string | undefined;
+    };
+    subdomain: string;
+    answers: Record<string, unknown>;
+    consent: {
+        tosAccepted: true;
+        privacyAccepted: true;
+        documents?: {
+            legalDocumentId: string;
+            versionNo: number;
+            accepted: true;
+            evidence: {
+                opened?: boolean | undefined;
+                scrolled_to_end?: boolean | undefined;
+            };
+        }[] | undefined;
+    };
+    botToken?: string | undefined;
+    organisationName?: string | undefined;
+    selectedServices?: string[] | undefined;
+}>;
+type SignupWirePayload = z.infer<typeof signupWireSchema>;
+/** The payload the caller assembles (botToken attached by the transport). */
+interface SignupSubmitBody {
+    specVersion: string;
+    answers: Record<string, unknown>;
+    selectedServices?: string[];
+    /**
+     * D543 §4 consent. `documents` (the per-doc array) is authoritative when
+     * present; the booleans are the derived convenience. `documents` is omitted
+     * for a pre-ConsentPack onboarder (backward-compat).
+     */
+    consent: {
+        tosAccepted: true;
+        privacyAccepted: true;
+        documents?: ConsentSubmitDocument[];
+    };
+    credentials: {
+        email: string;
+        displayName?: string;
+    };
+    organisationName?: string;
+    subdomain: string;
+}
+interface SignupSubmitOptions {
+    baseUrl: string;
+    /**
+     * reCAPTCHA token (D537), or a provider called ONCE PER ATTEMPT to mint a
+     * fresh token. Tokens are single-use (consumed at siteverify), so a fixed
+     * string on a retried request risks 403 after the first attempt consumed
+     * it — pass a provider for retry-safe recovery.
+     */
+    botToken?: BotTokenSource;
+    /** Stable idempotency key — same discipline as submitLead. */
+    idempotencyKey: string;
+    fetch?: typeof globalThis.fetch;
+    /**
+     * Per-attempt request timeout in ms (default 15s). A stalled intake aborts
+     * with OnboardingNetworkError so the widget re-enables instead of hanging.
+     */
+    timeoutMs?: number;
+    onAttempt?: (attempt: number) => void;
+}
+interface SignupSubmitResult {
+    accepted: true;
+    /** Stage the existing engine landed the applicant at (D540 §2). */
+    terminalStage: TerminalStage;
+    verificationEmailSent?: boolean;
+}
+/**
+ * Stable fingerprint of a signup submission, EXCLUDING botToken (fresh per
+ * attempt by design). Same role as computePayloadFingerprint for leads:
+ * same fingerprint ⇒ retry (reuse the Idempotency-Key); changed
+ * fingerprint ⇒ new logical submission (mint a new key) — mirroring the
+ * server's D538 payload-match guard.
+ */
+declare function computeSignupFingerprint(body: SignupSubmitBody): string;
+/**
+ * Submit a full signup to the onboarding intake.
+ *
+ * @throws {OnboardingValidationError} strict wire-schema failure — BEFORE any fetch
+ * @throws {OnboardingBotChallengeError} on 403, or if the bot-token provider
+ *   throws (reCAPTCHA unreachable) on any attempt
+ * @throws {OnboardingSpecStaleError} on 409 with code:"spec_stale" (caller
+ *   refetches spec); carries the server's currentSpecVersion
+ * @throws {OnboardingConsentStaleError} on 409 with code:"consent_stale"
+ *   (D543 §4 — a required legal doc changed; caller refetches spec + requires
+ *   re-acceptance of the changed docs, NEVER auto-accepts); carries
+ *   staleDocuments
+ * @throws {OnboardingConsentIncompleteError} on 400 with
+ *   code:"consent_incomplete" (D543 §4 — server found a required doc missing/
+ *   unaccepted/evidence-insufficient)
+ * @throws {OnboardingConflictError} on a 409 that is NOT spec_stale/consent_stale
+ * @throws {OnboardingRateLimitError} on 429
+ * @throws {OnboardingValidationError} on 422 (server re-validation) or a
+ *   generic 400 that is NOT consent_incomplete
+ * @throws {OnboardingServerError} on 5xx after retries, or a 2xx without
+ *   the required {accepted:true, terminalStage} body
+ * @throws {OnboardingNetworkError} on network failure OR timeout after retries
+ */
+declare function submitSignup(body: SignupSubmitBody, options: SignupSubmitOptions): Promise<SignupSubmitResult>;
+
+export { type BotTokenSource as B, type LeadsSubmitOptions as L, type SignupSubmitBody as S, type LeadsSubmitResult as a, type SignupSubmitOptions as b, type SignupSubmitResult as c, type SignupWirePayload as d, computePayloadFingerprint as e, computeSignupFingerprint as f, consentSubmitDocumentSchema as g, generateIdempotencyKey as h, submitLead as i, submitSignup as j, resolveBotToken as r, signupWireSchema as s };

package/dist/spec/index.d.ts

@@ -0,0 +1,17 @@
+export { F as FIELD_KEY_PATTERN, O as OnboarderTier, a as OnboardingSpec, P as PiiClass, S as SpecField, b as SpecStage, c as SpecStep, T as TerminalStage, o as onboardingSpecSchema, s as specFieldSchema, d as specStepSchema, v as validateOnboardingSpec } from '../model-ESLSEbi0.js';
+export { A as ACCEPTANCE_LEVELS, a as AcceptanceLevel, C as ConsentDocType, b as ConsentDocument, c as ConsentPack, D as DOC_TYPES, d as acceptanceLevelSchema, e as consentDocKey, f as consentDocumentSchema, g as consentPackSchema } from '../model-mnjAEtKe.js';
+export { O as OnboardingSpecCache, S as SpecFetchOptions, a as SpecFieldDiff, d as defaultSpecCache, b as diffSpecFields, f as fetchOnboardingSpec } from '../client-CqE2dF9A.js';
+import 'zod/v3';
+
+interface PinStateResult {
+    pin: string;
+    stateIso: string | null;
+}
+declare function fetchPinState(options: {
+    baseUrl: string;
+    pin: string;
+    fetch?: typeof globalThis.fetch;
+    timeoutMs?: number;
+}): Promise<PinStateResult>;
+
+export { type PinStateResult, fetchPinState };

package/dist/spec/index.js

@@ -0,0 +1,5 @@
+export { FIELD_KEY_PATTERN, OnboardingSpecCache, defaultSpecCache, diffSpecFields, fetchOnboardingSpec, fetchPinState, onboardingSpecSchema, specFieldSchema, specStepSchema, validateOnboardingSpec } from '../chunk-F75ZJERM.js';
+export { ACCEPTANCE_LEVELS, DOC_TYPES, acceptanceLevelSchema, consentDocKey, consentDocumentSchema, consentPackSchema } from '../chunk-U56GQITG.js';
+import '../chunk-XJTJPBJB.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/spec/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/submit/index.d.ts

@@ -0,0 +1,42 @@
+export { B as BotTokenSource, L as LeadsSubmitOptions, a as LeadsSubmitResult, S as SignupSubmitBody, b as SignupSubmitOptions, c as SignupSubmitResult, d as SignupWirePayload, e as computePayloadFingerprint, f as computeSignupFingerprint, g as consentSubmitDocumentSchema, h as generateIdempotencyKey, r as resolveBotToken, s as signupWireSchema, i as submitLead, j as submitSignup } from '../signup-client-BL5DfarJ.js';
+export { O as OnboardingBotChallengeError, a as OnboardingConflictError, b as OnboardingConsentIncompleteError, c as OnboardingConsentStaleError, d as OnboardingError, e as OnboardingErrorKind, f as OnboardingNetworkError, g as OnboardingRateLimitError, h as OnboardingServerError, i as OnboardingSpecInvalidError, j as OnboardingSpecStaleError, k as OnboardingSubdomainTakenError, l as OnboardingValidationError, S as StaleConsentDocument } from '../errors-vJkye4a0.js';
+import 'zod/v3';
+import '../model-ESLSEbi0.js';
+import '../controller-BQb62D0N.js';
+import '../model-mnjAEtKe.js';
+import '../schema-BrXb9gnh.js';
+
+/**
+ * Shared HTTP helper: fetch bounded by a timeout via AbortController.
+ *
+ * Every SDK wire call (spec fetch, leads submit, signup submit) MUST be
+ * bounded — the widgets flip to a disabled/"Sending…"/"Loading…" state
+ * BEFORE the await, so an intake that accepts the connection and then stalls
+ * would otherwise hang the UI forever. On timeout the fetch is aborted and a
+ * typed OnboardingNetworkError is raised by the caller (which maps abort/
+ * network failures uniformly).
+ */
+/** Default per-request timeout. Generous enough for a slow-but-alive intake. */
+declare const DEFAULT_REQUEST_TIMEOUT_MS = 15000;
+interface TimeoutFetchOptions extends RequestInit {
+    /** Per-request timeout in ms. Default DEFAULT_REQUEST_TIMEOUT_MS. */
+    timeoutMs?: number;
+    /** The fetch implementation to use (defaults to globalThis.fetch). */
+    fetchImpl?: typeof globalThis.fetch;
+}
+/**
+ * fetch() with a hard timeout. Aborts the request when the deadline elapses;
+ * the resulting AbortError propagates to the caller (who wraps it as an
+ * OnboardingNetworkError). A caller-supplied `signal` is respected too — if
+ * either the caller aborts OR the timeout fires, the request is aborted.
+ */
+declare function fetchWithTimeout(url: string, options?: TimeoutFetchOptions): Promise<Response>;
+/**
+ * Run a promise with a timeout. On timeout, rejects with `onTimeout()`'s
+ * error. Used to bound calls that don't take an AbortSignal (grecaptcha
+ * .execute()). The underlying op is NOT cancelled (grecaptcha has no abort),
+ * but the caller no longer waits on it — the widget re-enables.
+ */
+declare function withTimeout<T>(op: Promise<T>, timeoutMs: number, onTimeout: () => Error): Promise<T>;
+
+export { DEFAULT_REQUEST_TIMEOUT_MS, fetchWithTimeout, withTimeout };

package/dist/submit/index.js

@@ -0,0 +1,6 @@
+import '../chunk-Z4PA6C2Z.js';
+export { computePayloadFingerprint, computeSignupFingerprint, consentSubmitDocumentSchema, generateIdempotencyKey, resolveBotToken, signupWireSchema, submitLead, submitSignup } from '../chunk-BMQINH6O.js';
+import '../chunk-SIMLMQPT.js';
+export { DEFAULT_REQUEST_TIMEOUT_MS, OnboardingBotChallengeError, OnboardingConflictError, OnboardingConsentIncompleteError, OnboardingConsentStaleError, OnboardingError, OnboardingNetworkError, OnboardingRateLimitError, OnboardingServerError, OnboardingSpecInvalidError, OnboardingSpecStaleError, OnboardingSubdomainTakenError, OnboardingValidationError, fetchWithTimeout, withTimeout } from '../chunk-XJTJPBJB.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/submit/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/viewer/index.d.ts

@@ -0,0 +1,4 @@
+export { C as ConsentDocumentViewerOptions, a as ConsentDocumentViewerResult, b as _resetPdfWorkerState, r as renderConsentDocument } from '../index-Dqfa890U.js';
+import '../controller-BQb62D0N.js';
+import '../model-mnjAEtKe.js';
+import 'zod/v3';

package/dist/viewer/index.js

@@ -0,0 +1,5 @@
+export { _resetPdfWorkerState, renderConsentDocument } from '../chunk-LVJM4CTG.js';
+import '../chunk-SEKNVHD3.js';
+import '../chunk-XJTJPBJB.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/viewer/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}