@incodetech/core 2.1.1 → 2.2.0-rc.1

package/dist/flowServices-b0Pd4F1K.esm.js

@@ -0,0 +1,620 @@
+import { E as updateFeatureManagementUser } from "./feature-management-DS_Nj5Gg.esm.js";
+import { r as getToken, t as api } from "./api-Bx3gKW_y.esm.js";
+import { c as getStandaloneFlowPolicy, i as initializeSession, r as getSessionFingerprintResult } from "./sessionInitializer-DNgRpf5Y.esm.js";
+import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { r as toIncodeApiError } from "./apiError-oiEnJIlk.esm.js";
+import "./session-DeR_I24J.esm.js";
+import { i as toEkycConfig } from "./ekycUtils-Dew1rBG0.esm.js";
+//#region src/modules/flow/dashboardConfig.ts
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function mergeDashboardConfig(dashboardConfig, localConfig) {
+	if (!isPlainObject(dashboardConfig) || !isPlainObject(localConfig)) return localConfig === void 0 ? dashboardConfig : localConfig;
+	const result = { ...dashboardConfig };
+	for (const [key, localValue] of Object.entries(localConfig)) {
+		if (localValue === void 0) continue;
+		const dashboardValue = result[key];
+		result[key] = isPlainObject(dashboardValue) && isPlainObject(localValue) ? mergeDashboardConfig(dashboardValue, localValue) : localValue;
+	}
+	return result;
+}
+//#endregion
+//#region src/modules/ekyb/ekybConstants.ts
+/**
+* Countries available in all environments.
+* Sorted alphabetically by display name.
+*/
+const SUPPORTED_COUNTRIES = [
+	"BR",
+	"CN",
+	"FR",
+	"DE",
+	"IL",
+	"IT",
+	"MX",
+	"ES",
+	"GB",
+	"US"
+];
+/**
+* Additional countries available only in dev/staging environments.
+*/
+const DEV_ONLY_COUNTRIES = [
+	"CM",
+	"KE",
+	"NG"
+];
+/**
+* Union of all recognized country codes (prod + dev).
+*/
+const ALL_COUNTRIES = [...SUPPORTED_COUNTRIES, ...DEV_ONLY_COUNTRIES];
+const ALL_COUNTRIES_SET = new Set(ALL_COUNTRIES);
+function isSupportedCountry(code) {
+	return ALL_COUNTRIES_SET.has(code);
+}
+const FIELD_ORDER = [
+	"name-user_input",
+	"taxId-user_input",
+	"street-user_input",
+	"houseNo-user_input",
+	"address2-user_input",
+	"city-user_input",
+	"state-user_input",
+	"postalCode-user_input"
+];
+const FIELD_NAME_MAPPING = {
+	"name-user_input": "businessName",
+	"street-user_input": "street",
+	"houseNo-user_input": "houseNo",
+	"address2-user_input": "addressLine2",
+	"city-user_input": "city",
+	"state-user_input": "state",
+	"postalCode-user_input": "postalCode",
+	"taxId-user_input": "taxId"
+};
+const COUNTRIES_WITH_CNPJ_VALIDATION = ["BR"];
+const BUSINESS_NAME_OPTIONAL_COUNTRIES = [];
+const ADDRESS_FULLY_OPTIONAL_COUNTRIES = [
+	"BR",
+	"GB",
+	"FR"
+];
+const ADDRESS_FIELDS = [
+	"street",
+	"houseNo",
+	"addressLine2",
+	"city",
+	"state",
+	"postalCode"
+];
+const ALL_COUNTRIES_OPTIONAL_FIELDS = ["ubo"];
+const UBO_FIELD_LABELS = {
+	name: "ekyb.uboName",
+	surname: "ekyb.uboSurname"
+};
+const INVALID_CNPJ_PATTERNS = [
+	"00000000000000",
+	"11111111111111",
+	"22222222222222",
+	"33333333333333",
+	"44444444444444",
+	"55555555555555",
+	"66666666666666",
+	"77777777777777",
+	"88888888888888",
+	"99999999999999"
+];
+const CNPJ_FIRST_DIGIT_FACTORS = [
+	5,
+	4,
+	3,
+	2,
+	9,
+	8,
+	7,
+	6,
+	5,
+	4,
+	3,
+	2
+];
+const CNPJ_SECOND_DIGIT_FACTORS = [
+	6,
+	5,
+	4,
+	3,
+	2,
+	9,
+	8,
+	7,
+	6,
+	5,
+	4,
+	3,
+	2
+];
+//#endregion
+//#region src/modules/ekyb/ekybUtils.ts
+/**
+* Normalizes any supported eKYB config input into a manager-ready `EkybConfig`.
+*
+* Accepts either:
+*  - A manager-ready `EkybConfig` (with `flowId` or `verificationFields`) →
+*    returned unchanged.
+*  - A raw backend `EkybFlowConfig` (with `*Source` companions) → stripped to
+*    the four `check*` fields the manager consumes.
+*
+* Idempotent: `toEkybConfig(toEkybConfig(x))` equals `toEkybConfig(x)`.
+*/
+function toEkybConfig(config) {
+	if (config.flowId || config.verificationFields) return config;
+	return {
+		checkBusinessName: config.checkBusinessName,
+		checkAddress: config.checkAddress,
+		checkTaxId: config.checkTaxId,
+		checkUniqueBeneficialOwner: config.checkUniqueBeneficialOwner
+	};
+}
+/** Sorts modules based on a custom order; items not in order maintain relative position */
+function sortModulesByOrder(modules, customOrder) {
+	return [...modules].sort((a, b) => {
+		const indexA = customOrder.indexOf(a);
+		const indexB = customOrder.indexOf(b);
+		if (indexA !== -1 && indexB !== -1) return indexA - indexB;
+		if (indexA !== -1) return -1;
+		if (indexB !== -1) return 1;
+		return 0;
+	});
+}
+/** Determines if a field is optional for the given country */
+function isFieldOptional(fieldName, countryCode) {
+	if (ALL_COUNTRIES_OPTIONAL_FIELDS.includes(fieldName)) return true;
+	if (fieldName === "businessName") return BUSINESS_NAME_OPTIONAL_COUNTRIES.includes(countryCode);
+	if (fieldName === "addressLine2") return true;
+	if (ADDRESS_FIELDS.includes(fieldName)) return false;
+	if (fieldName === "taxId") return false;
+	return false;
+}
+/** Checks if at least one address field has a non-empty value */
+function hasAtLeastOneAddressField(formData) {
+	return ADDRESS_FIELDS.some((field) => {
+		const value = formData[field];
+		return value !== void 0 && value.trim() !== "";
+	});
+}
+/** Returns false for countries where address is fully optional */
+function requiresAddressValidation(countryCode) {
+	return !ADDRESS_FULLY_OPTIONAL_COUNTRIES.includes(countryCode);
+}
+//#endregion
+//#region src/modules/video-selfie/videoSelfieSteps.ts
+/** Steps that use the rear (environment) camera; everything else uses the front (user) camera. */
+const REAR_CAMERA_STEPS = [
+	"frontId",
+	"backId",
+	"poa"
+];
+/**
+* The camera facing mode a given step should use. ID and proof-of-address steps
+* use the rear camera; selfie / questions / speech use the front camera.
+*/
+function facingModeForStep(step) {
+	return REAR_CAMERA_STEPS.includes(step) ? "environment" : "user";
+}
+/**
+* Resolves the ordered list of active capture steps from the module config.
+* The order mirrors V1 `getVideoSelfieModules`: the rear-camera document steps
+* (`frontId` → `backId` → `poa`) run first, then the front-camera steps
+* (`selfie` → `questions` → `speech`). This keeps the user from flipping the
+* device between front and rear cameras mid-session. `selfie` is always present;
+* the document and voice-consent steps are gated by their config flags.
+*
+* Both ID sides are captured whenever `checkIdScan` is on (a normal two-sided ID
+* scan) — mirroring V1, which gated `back` on `checkIdScan`, not on the compare
+* flags. `compareBackIdEnabled`/`compareBackOcrEnabled` only decide whether the
+* captured back is *validated* against the backend (see `validateIdFrame` in
+* `videoSelfieStepDetector`); with both off the back is captured passively on
+* the first well-framed frame.
+*/
+function resolveVideoSelfieSteps(config) {
+	const steps = [];
+	if (config.checkIdScan) {
+		steps.push("frontId");
+		steps.push("backId");
+	}
+	if (config.checkDocumentScan) steps.push("poa");
+	steps.push("selfie");
+	if (config.checkVoiceConsent) {
+		if ((config.voiceConsentQuestions ?? 0) > 0) steps.push("questions");
+		steps.push("speech");
+	}
+	return steps;
+}
+/**
+* The WASM pipelines a Video Selfie session loads. The selfie step always runs
+* face detection (`videoSelfie`); the ID steps run the simplified ID-capture
+* pipeline (`videoSelfieId`), gated by `checkIdScan`. Used both for the
+* flow-level eager warmup ({@link getRequiredWasmPipelines}) and the
+* tutorial-time lazy warmup (`warmupVideoSelfieWasm`).
+*/
+function videoSelfieWasmPipelines(config) {
+	const pipelines = ["videoSelfie"];
+	if (config.checkIdScan) pipelines.push("videoSelfieId");
+	return pipelines;
+}
+//#endregion
+//#region src/modules/flow/flowUtils.ts
+function enrichFlowModuleConfig(module, flow) {
+	const config = {
+		...module.configuration,
+		ds: flow.ds
+	};
+	if (module.key === "ID" || module.key === "TUTORIAL_ID" || module.key === "SECOND_ID" || module.key === "SELFIE") return {
+		...config,
+		ageAssurance: config.ageAssurance ?? flow.ageAssurance
+	};
+	return config;
+}
+function resolveFlowModuleConfig(module, flow) {
+	const config = enrichFlowModuleConfig(module, flow);
+	if (module.key === "EXTERNAL_VERIFICATION") return { ...toEkycConfig(module.configuration) };
+	if (module.key === "EKYB") return { ...toEkybConfig(module.configuration) };
+	if (module.key === "ID_OCR") return {
+		...config,
+		secondId: config.secondId ?? flow.flowModules.some((candidate) => candidate.key === "SECOND_ID"),
+		flowId: flow.flowId
+	};
+	if (module.key === "SECOND_ID") return {
+		...config,
+		isSecondId: true
+	};
+	if (module.key === "ADDRESS") return {
+		...config,
+		processingType: "addressStatement"
+	};
+	if (module.key === "MANDATORY_CONSENT" || module.key === "ML_CONSENT") return {
+		...config,
+		type: module.key === "ML_CONSENT" ? "ML" : "MANDATORY"
+	};
+	if (module.key === "AE_SIGNATURE" || module.key === "QE_SIGNATURE") return {
+		uploadDocument: module.configuration.uploadDocument,
+		downloadDocument: module.configuration.downloadDocument
+	};
+	if (module.key === "DYNAMIC_FORMS") return { screens: module.configuration.screens.map((formScreen) => ({
+		title: formScreen.title,
+		hideTitle: formScreen.hideTitle,
+		questions: formScreen.questions.map((question) => ({
+			questionId: question.questionId,
+			question: question.question,
+			inputType: question.inputType,
+			isOptional: question.isOptional,
+			overrides: question.overrides ?? void 0,
+			isPredefined: question.isPredefined,
+			options: question.options,
+			prefillSource: question.prefillSource,
+			editable: question.editable
+		}))
+	})) };
+	return config;
+}
+const WASM_MODULE_PIPELINES = {
+	SELFIE: "selfie",
+	AUTHENTICATION: "selfie",
+	FACE_MATCH: "selfie",
+	ID: "idCapture",
+	TUTORIAL_ID: "idCapture",
+	SECOND_ID: "idCapture"
+};
+const FACE_MODULES_WITH_ON_DEVICE_VARIANT = /* @__PURE__ */ new Set(["SELFIE", "AUTHENTICATION"]);
+function isOnDeviceFaceModule(module) {
+	if (!FACE_MODULES_WITH_ON_DEVICE_VARIANT.has(module.key)) return false;
+	return module.configuration?.onDeviceFaceResultsSubmissionEnabled === true;
+}
+function isVideoOnboardingModule(module) {
+	return module.key === "VIDEO_ONBOARDING";
+}
+/**
+* Analyzes a flow configuration and returns the WASM pipelines needed.
+* Use this to conditionally warmup WASM only when required by the flow.
+*
+* Modules with `onDeviceFaceResultsSubmissionEnabled: true` (currently SELFIE
+* and AUTHENTICATION) select the 6-model `'onDeviceSelfie'` bundle instead of
+* the default 4-model `'selfie'` bundle.
+*
+* @param flow - The flow configuration from /omni/onboarding/flow
+* @returns Array of WASM pipelines needed (e.g., ['selfie', 'idCapture'])
+*
+* @example
+* ```typescript
+* const pipelines = getRequiredWasmPipelines(flow);
+* if (pipelines.length > 0) {
+*   warmupWasm({ ...wasmConfig, pipelines });
+* }
+* ```
+*/
+function getRequiredWasmPipelines(flow) {
+	const pipelines = /* @__PURE__ */ new Set();
+	for (const module of flow.flowModules) {
+		if (isOnDeviceFaceModule(module)) {
+			pipelines.add("onDeviceSelfie");
+			continue;
+		}
+		if (isVideoOnboardingModule(module)) {
+			for (const p of videoSelfieWasmPipelines(module.configuration)) pipelines.add(p);
+			continue;
+		}
+		const pipeline = WASM_MODULE_PIPELINES[module.key];
+		if (pipeline) pipelines.add(pipeline);
+	}
+	return [...pipelines];
+}
+/**
+* Normalizes flow modules by expanding TUTORIAL_ID into ID + SECOND_ID
+* based on configuration flags. Matches legacy flowService behavior.
+*
+* - TUTORIAL_ID becomes ID (with same config)
+* - If secondId: true, adds SECOND_ID module with isSecondId: true
+* - thirdId is deprecated and ignored; the flow continues to the next step
+* - Bare ID following TUTORIAL_ID is dropped (already merged)
+*/
+function normalizeFlowModules(flow, options = {}) {
+	let modules = normalizeIdModules(flow.flowModules);
+	modules = normalizeCpfModules(modules, options);
+	modules = dropWatchlistBusinessIfEkyb(modules);
+	modules = dropSelfieIfVideoSelfieUsesAsSelfie(modules);
+	if (shouldInjectRedirect(flow, modules, options)) modules = addRedirect(flow, modules, options);
+	return modules;
+}
+/**
+* Drops WATCHLIST_BUSINESS when EKYB is present in the same flow.
+* The EKYB module performs a superset of the watchlist-for-business check,
+* so running both would be redundant.
+*/
+function dropWatchlistBusinessIfEkyb(modules) {
+	if (!hasModule(modules, "EKYB")) return modules;
+	return modules.filter((m) => m.key !== "WATCHLIST_BUSINESS");
+}
+/**
+* Drops standalone SELFIE modules when a VIDEO_ONBOARDING module has
+* `useAsSelfie: true`. The video-selfie sequence captures the onboarding selfie
+* itself (its own `selfie` step), so a separate SELFIE step would be redundant.
+* Only SELFIE is removed (not AUTHENTICATION / FACE_MATCH). Mirrors legacy
+* flowService `removeSelfie`.
+*/
+function dropSelfieIfVideoSelfieUsesAsSelfie(modules) {
+	if (!modules.some((m) => m.key === "VIDEO_ONBOARDING" && m.configuration.useAsSelfie === true)) return modules;
+	return modules.filter((m) => m.key !== "SELFIE");
+}
+function normalizeIdModules(modules) {
+	return modules.flatMap((module, idx, arr) => {
+		if (module.key === "TUTORIAL_ID") {
+			const idConfig = module.configuration;
+			const result = [{
+				key: "ID",
+				configuration: idConfig
+			}];
+			if (idConfig.secondId) result.push({
+				key: "SECOND_ID",
+				configuration: {
+					...idConfig,
+					isSecondId: true
+				}
+			});
+			return result;
+		}
+		const prev = arr[idx - 1];
+		if (module.key === "ID" && prev?.key === "TUTORIAL_ID") return [];
+		return [module];
+	});
+}
+function normalizeCpfModules(modules, options) {
+	if (options.useCPF !== true) return modules;
+	return modules.map((module) => {
+		if (module.key !== "ID_OCR") return module;
+		return {
+			key: "ID_OCR",
+			configuration: {
+				...module.configuration,
+				cpfOnly: true
+			}
+		};
+	});
+}
+function shouldInjectRedirect(flow, modules, options) {
+	return options.isDesktop === true && flow.redirectDesktopToMobile === true && !hasModule(modules, "REDIRECT_TO_MOBILE");
+}
+function addRedirect(flow, modules, options) {
+	return [{
+		key: "REDIRECT_TO_MOBILE",
+		configuration: {
+			flowId: flow.flowId,
+			disableSmsOption: flow.disableSmsOption ?? false,
+			addContinueToDesktop: flow.addContinueToDesktop ?? false,
+			qrPhishingResistance: flow.qrPhishingResistance ?? false,
+			authHint: options.authHint,
+			lang: options.lang
+		}
+	}, ...modules];
+}
+function hasModule(modules, key) {
+	return modules.some((module) => module.key === key);
+}
+//#endregion
+//#region src/modules/flow/flowServices.ts
+let dashboardFlowCache;
+var FlowSessionFinishedError = class extends Error {
+	constructor() {
+		super("This verification session has already been completed and can no longer be reopened.");
+		this.moduleErrorCode = "SESSION_FINISHED";
+		this.name = "FlowSessionFinishedError";
+	}
+};
+const REGULATION_TYPES = [
+	"US",
+	"Worldwide",
+	"Other",
+	"US_Illinois",
+	"US_Texas",
+	"US_California",
+	"US_Washington"
+];
+const REGULATION_TYPE_ALIASES = {
+	us: "US",
+	worldwide: "Worldwide",
+	worldwide_consent: "Worldwide",
+	other: "Other",
+	us_illinois: "US_Illinois",
+	usillinois: "US_Illinois",
+	us_texas: "US_Texas",
+	ustexas: "US_Texas",
+	us_california: "US_California",
+	uscalifornia: "US_California",
+	us_washington: "US_Washington",
+	uswashington: "US_Washington"
+};
+function toRegulationType(value) {
+	if (!value) return "Other";
+	if (REGULATION_TYPES.includes(value)) return value;
+	const normalized = value.trim().toLowerCase().replace(/[\s-]+/g, "_");
+	return REGULATION_TYPE_ALIASES[normalized] ?? "Other";
+}
+function prependMandatoryConsent(flow) {
+	if (flow.mandatoryConsentCheck === false) return flow;
+	const fingerprintResult = getSessionFingerprintResult();
+	if (!fingerprintResult?.showMandatoryConsent) return flow;
+	if (flow.flowModules.find((module) => module.key === "MANDATORY_CONSENT")) return flow;
+	const mandatoryConsentModule = {
+		key: "MANDATORY_CONSENT",
+		configuration: { consentType: toRegulationType(fingerprintResult.regulationType) }
+	};
+	return {
+		...flow,
+		flowModules: [mandatoryConsentModule, ...flow.flowModules]
+	};
+}
+function requireActiveToken() {
+	const token = getToken();
+	if (!token) throw new Error("Standalone module configuration requires an active Flow session");
+	return token;
+}
+async function assertSessionCanStart(flow, signal) {
+	if (flow.enableMultipleOnboardings) return;
+	let data;
+	try {
+		data = (await api.get(endpoints.onboardingStatus, { signal })).data;
+	} catch (error) {
+		toIncodeApiError(endpoints.onboardingStatus, error);
+	}
+	if (data.onboardingStatus === "ONBOARDING_FINISHED") throw new FlowSessionFinishedError();
+}
+function validateRawFlow(data) {
+	if (!data || typeof data.flowId !== "string" || data.flowId.length === 0) throw new Error("No Flow is configured for the active session");
+	if (!Array.isArray(data.flowModules)) throw new Error("No Flow is configured for the active session");
+	return data;
+}
+async function fetchRawDashboardFlow() {
+	try {
+		return validateRawFlow((await api.get(endpoints.flow)).data);
+	} catch (error) {
+		toIncodeApiError(endpoints.flow, error);
+	}
+}
+function createAbortError() {
+	const error = /* @__PURE__ */ new Error("The operation was aborted");
+	error.name = "AbortError";
+	return error;
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw createAbortError();
+}
+function waitForSharedPromise(promise, signal) {
+	if (!signal) return promise;
+	if (signal.aborted) return Promise.reject(createAbortError());
+	return new Promise((resolve, reject) => {
+		const onAbort = () => reject(createAbortError());
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then((value) => {
+			signal.removeEventListener("abort", onAbort);
+			resolve(value);
+		}, (error) => {
+			signal.removeEventListener("abort", onAbort);
+			reject(error);
+		});
+	});
+}
+function preloadDashboardFlow(signal) {
+	const token = requireActiveToken();
+	if (dashboardFlowCache?.token === token) return waitForSharedPromise(dashboardFlowCache.promise, signal);
+	const request = fetchRawDashboardFlow();
+	const cache = {
+		token,
+		promise: request
+	};
+	const promise = request.catch((error) => {
+		if (dashboardFlowCache === cache) dashboardFlowCache = void 0;
+		throw error;
+	});
+	cache.promise = promise;
+	dashboardFlowCache = cache;
+	return waitForSharedPromise(promise, signal);
+}
+function resetDashboardFlowCache() {
+	dashboardFlowCache = void 0;
+}
+async function normalizeDashboardFlow(rawFlow, options, signal) {
+	throwIfAborted(signal);
+	await initializeSession({ signal }).catch(() => void 0);
+	throwIfAborted(signal);
+	await updateFeatureManagementUser({ customIDs: { flow_id: rawFlow.flowId } });
+	throwIfAborted(signal);
+	const flow = prependMandatoryConsent(rawFlow);
+	const normalizedModules = normalizeFlowModules(flow, options);
+	throwIfAborted(signal);
+	return {
+		...flow,
+		flowModules: normalizedModules
+	};
+}
+const getFlow = async (signal, options = {}) => {
+	throwIfAborted(signal);
+	const rawFlow = await preloadDashboardFlow(signal);
+	throwIfAborted(signal);
+	await assertSessionCanStart(rawFlow, signal);
+	throwIfAborted(signal);
+	return normalizeDashboardFlow(rawFlow, options, signal);
+};
+function getResolverModuleKeys(moduleKey) {
+	if (moduleKey === "TUTORIAL_ID") return ["ID"];
+	if (moduleKey === "GOVT_VALIDATION_PROVISIONING") return ["GOVT_VALIDATION_PROVISIONING", "INE_VALIDATION"];
+	if (moduleKey === "DOCUMENT_CAPTURE") return ["DOCUMENT_CAPTURE", "ADDRESS"];
+	if (moduleKey === "MANDATORY_CONSENT") return ["MANDATORY_CONSENT", "ML_CONSENT"];
+	return [moduleKey];
+}
+async function resolveDashboardModuleConfig(options) {
+	const flowPolicy = getStandaloneFlowPolicy();
+	if (options.config !== void 0 && !flowPolicy.mergeConfig) return options.config;
+	if (!flowPolicy.enabled) throw new Error("Flow-backed module configuration is disabled; provide config or manager");
+	let flow;
+	try {
+		throwIfAborted(options.signal);
+		const rawFlow = await preloadDashboardFlow(options.signal);
+		throwIfAborted(options.signal);
+		flow = await normalizeDashboardFlow(rawFlow, { isDesktop: options.moduleKey === "REDIRECT_TO_MOBILE" }, options.signal);
+		throwIfAborted(options.signal);
+	} catch (error) {
+		if (error instanceof Error && error.name === "AbortError") throw error;
+		throw new Error("Standalone module configuration requires an active Flow session");
+	}
+	const moduleKeys = getResolverModuleKeys(options.moduleKey);
+	const occurrence = options.occurrence ?? 0;
+	const module = flow.flowModules.filter((module) => moduleKeys.includes(module.key))[occurrence];
+	if (!module) throw new Error(`Module "${options.moduleKey}" is not enabled in the active Flow`);
+	const flowConfig = resolveFlowModuleConfig(module, flow);
+	if (flowPolicy.mergeConfig) return mergeDashboardConfig(flowConfig, options.config);
+	return flowConfig;
+}
+//#endregion
+export { FIELD_NAME_MAPPING as C, UBO_FIELD_LABELS as D, SUPPORTED_COUNTRIES as E, isSupportedCountry as O, DEV_ONLY_COUNTRIES as S, INVALID_CNPJ_PATTERNS as T, ADDRESS_FIELDS as _, enrichFlowModuleConfig as a, CNPJ_SECOND_DIGIT_FACTORS as b, resolveFlowModuleConfig as c, videoSelfieWasmPipelines as d, hasAtLeastOneAddressField as f, toEkybConfig as g, sortModulesByOrder as h, resolveDashboardModuleConfig as i, mergeDashboardConfig as k, facingModeForStep as l, requiresAddressValidation as m, preloadDashboardFlow as n, getRequiredWasmPipelines as o, isFieldOptional as p, resetDashboardFlowCache as r, normalizeFlowModules as s, getFlow as t, resolveVideoSelfieSteps as u, ALL_COUNTRIES as v, FIELD_ORDER as w, COUNTRIES_WITH_CNPJ_VALIDATION as x, CNPJ_FIRST_DIGIT_FACTORS as y };

package/dist/geolocation.d.ts

@@ -1,5 +1,2 @@
-import "./StateMachine-D5WO6lHS.js";
-import "./Manager-goNPc_h_.js";
-import "./Actor-BwgmOPkb.js";
-import { n as GeolocationState, o as geolocationMachine, r as createGeolocationManager, s as GeolocationConfig, t as GeolocationManager } from "./geolocationManager-DaHYFkVO.js";
+import { n as GeolocationState, o as geolocationMachine, r as createGeolocationManager, s as GeolocationConfig, t as GeolocationManager } from "./geolocationManager-Cz744E5S.js";
 export { type GeolocationConfig, type GeolocationManager, type GeolocationState, createGeolocationManager, geolocationMachine };

package/dist/geolocation.esm.js

@@ -1,9 +1,3 @@
-import "./api-DsbUi7TO.esm.js";
-import "./events-1wxZ97yf.esm.js";
-import "./endpoints-CwrFQfW7.esm.js";
-import "./platform-0Ot-bF_a.esm.js";
-import "./xstate.esm-nY3M5UYm.esm.js";
-import { t as createGeolocationManager } from "./geolocationManager-CF6-NizA.esm.js";
-import { t as geolocationMachine } from "./geolocationStateMachine-CD2XJs1b.esm.js";
-
-export { createGeolocationManager, geolocationMachine };
+import { t as createGeolocationManager } from "./geolocationManager-DGwnL5lg.esm.js";
+import { t as geolocationMachine } from "./geolocationStateMachine-il6jz5DZ.esm.js";
+export { createGeolocationManager, geolocationMachine };