@incodetech/core 0.0.0-dev-20260610-8787196e → 0.0.0-dev-20260610-e5b4c4d5

package/dist/canvas-SKcRBxsk.esm.js

@@ -0,0 +1,230 @@
+//#region ../infra/src/media/canvas.ts
+/**
+* Class representing a canvas element for image capture and manipulation.
+*/
+var IncodeCanvas = class IncodeCanvas {
+	/**
+	* Creates an {@link IncodeCanvas} from a raw {@link ImageData} frame.
+	* @param imageData - Frame pixels in RGBA format
+	* @returns An {@link IncodeCanvas} containing the provided pixels
+	*/
+	static fromImageData(imageData) {
+		const canvas = document.createElement("canvas");
+		canvas.width = imageData.width;
+		canvas.height = imageData.height;
+		const context = canvas.getContext("2d", { willReadFrequently: true });
+		if (!context) return new IncodeCanvas(canvas);
+		if ("putImageData" in context) context.putImageData(imageData, 0, 0);
+		return new IncodeCanvas(canvas);
+	}
+	/**
+	* Create a new canvas element.
+	* @param canvas_ - The canvas element to clone.
+	*/
+	constructor(canvas_) {
+		this.base64Image = null;
+		this.blobData = null;
+		this.canvas = document.createElement("canvas");
+		this.canvas.width = canvas_.width;
+		this.canvas.height = canvas_.height;
+		const context = this.canvas.getContext("2d");
+		if (context) context.drawImage(canvas_, 0, 0);
+	}
+	/**
+	* Check if the current canvas is valid.
+	*/
+	checkCanvas() {
+		return this.canvas && this.canvas.width > 1 && this.canvas.height > 1;
+	}
+	/**
+	* Disposes of resources, including revoking object URLs to prevent memory leaks.
+	*/
+	dispose() {
+		if (this.blobData?.url) {
+			URL.revokeObjectURL(this.blobData.url);
+			this.blobData = null;
+		}
+		this.base64Image = null;
+	}
+	/**
+	* Release the data stored by IncodeCanvas.
+	*/
+	release() {
+		if (!this.checkCanvas()) return;
+		this.canvas.width = 1;
+		this.canvas.height = 1;
+		this.canvas.getContext("2d")?.clearRect(0, 0, 1, 1);
+		this.base64Image = null;
+		if (this.blobData?.url) URL.revokeObjectURL(this.blobData.url);
+		this.blobData = null;
+	}
+	/**
+	* Revokes the object URL if one exists, preventing memory leaks.
+	* Use this when you no longer need the preview image URL.
+	*/
+	revokeObjectURL() {
+		if (this.blobData?.url) {
+			URL.revokeObjectURL(this.blobData.url);
+			this.blobData = {
+				...this.blobData,
+				url: ""
+			};
+		}
+	}
+	/**
+	* Get the width of the canvas.
+	*/
+	width() {
+		if (!this.checkCanvas()) return null;
+		return this.canvas.width;
+	}
+	/**
+	* Get the height of the canvas.
+	*/
+	height() {
+		if (!this.checkCanvas()) return null;
+		return this.canvas.height;
+	}
+	/**
+	* Set the width of the canvas.
+	*/
+	setWidth(width) {
+		if (!this.checkCanvas()) return;
+		this.canvas.width = width;
+	}
+	/**
+	* Set the height of the canvas.
+	*/
+	setHeight(height) {
+		if (!this.checkCanvas()) return;
+		this.canvas.height = height;
+	}
+	/**
+	* Clone the current canvas.
+	*/
+	clone() {
+		if (!this.checkCanvas()) return null;
+		const cloned = new IncodeCanvas(this.canvas);
+		cloned.setBase64Image(this.base64Image);
+		return cloned;
+	}
+	/**
+	* Deep clone the current IncodeCanvas including blob data.
+	*/
+	async deepClone() {
+		const cloned = this.clone();
+		if (!cloned) return null;
+		if (this.blobData) await cloned.setBlobData(this.blobData);
+		return cloned;
+	}
+	/**
+	* Returns the drawing context on the canvas.
+	*/
+	getContext(contextId, contextAttributes) {
+		if (!this.checkCanvas()) return null;
+		const context = this.canvas.getContext(contextId, contextAttributes);
+		return context instanceof CanvasRenderingContext2D ? context : null;
+	}
+	/**
+	* Retrieves the image data from the canvas.
+	*/
+	getImageData() {
+		if (!this.checkCanvas()) return null;
+		const context = this.canvas.getContext("2d", { willReadFrequently: true });
+		if (!context) return null;
+		return context.getImageData(0, 0, this.canvas.width, this.canvas.height);
+	}
+	/**
+	* Updates the base64 representation of the current canvas image.
+	*/
+	updateBase64Image(jpegQuality = 1) {
+		if (!this.checkCanvas()) return;
+		this.base64Image = this.canvas.toDataURL("image/jpeg", jpegQuality);
+	}
+	/**
+	* Converts the current canvas element to a base64 string.
+	*/
+	getBase64Image(jpegQuality = 1, includeDataURLPrefix = false) {
+		if (!this.checkCanvas()) return null;
+		if (this.base64Image === null) this.updateBase64Image(jpegQuality);
+		const base64Image = this.base64Image;
+		if (base64Image === null) return null;
+		if (includeDataURLPrefix) return base64Image;
+		const commaIndex = base64Image.indexOf(",");
+		if (commaIndex === -1) return base64Image;
+		return base64Image.slice(commaIndex + 1);
+	}
+	/**
+	* Sets the base64 representation of the current canvas image.
+	*/
+	setBase64Image(base64Image) {
+		this.base64Image = base64Image;
+	}
+	/**
+	* Updates the Blob representation of the current canvas image.
+	*/
+	updateBlob(jpegQuality = 1, includeDataURLPrefix = false) {
+		if (!this.checkCanvas()) return;
+		if (this.base64Image === null) this.updateBase64Image(jpegQuality);
+		const base64 = this.getBase64Image(jpegQuality, includeDataURLPrefix);
+		if (base64) this.blobData = IncodeCanvas.base64ToBlob(base64);
+	}
+	/**
+	* Converts a base64 string to a Blob and creates a URL for it.
+	*/
+	static base64ToBlob(base64) {
+		try {
+			const binary = atob(base64);
+			const array = [];
+			for (let i = 0; i < binary.length; i++) array.push(binary.charCodeAt(i));
+			const blob = new Blob([new Uint8Array(array)]);
+			return {
+				blob,
+				url: URL.createObjectURL(blob)
+			};
+		} catch (error) {
+			console.error("Failed to convert base64 string to Blob:", error);
+		}
+		return null;
+	}
+	/**
+	* Retrieves the Blob data and its URL from the current canvas.
+	*/
+	getBlobData(jpegQuality = 1, includeDataURLPrefix = false) {
+		if (!this.checkCanvas()) return null;
+		if (this.blobData === null) this.updateBlob(jpegQuality, includeDataURLPrefix);
+		return this.blobData;
+	}
+	/**
+	* Sets the Blob data of the current canvas image.
+	*/
+	async setBlobData(blobData) {
+		const blobDataArrayBuffer = await blobData.blob.arrayBuffer();
+		this.blobData = {
+			blob: new Blob([blobDataArrayBuffer], { type: blobData.blob.type }),
+			url: blobData.url
+		};
+	}
+	/**
+	* Returns a resized canvas according to video element size.
+	*/
+	getResizedCanvas(videoElementWidth, videoElementHeight) {
+		if (!this.checkCanvas()) return null;
+		const cameraOffsetX = Math.abs(videoElementWidth - window.innerWidth);
+		const resized = new IncodeCanvas(document.createElement("canvas"));
+		const canvasHeight = this.height();
+		if (!canvasHeight) return null;
+		const ratio = canvasHeight / videoElementHeight;
+		const newWidth = window.innerWidth;
+		const newHeight = window.innerHeight;
+		resized.setWidth(newWidth);
+		resized.setHeight(newHeight);
+		const context = resized.getContext("2d");
+		if (!context) return null;
+		context.drawImage(this.canvas, ratio * cameraOffsetX / 2, 0, ratio * newWidth, ratio * newHeight, 0, 0, newWidth, newHeight);
+		return resized;
+	}
+};
+
+//#endregion
+export { IncodeCanvas as t };

package/dist/consent.d.ts

@@ -1,4 +1,4 @@
-import "./Manager-Dh6pC-6V.js";
-import "./Actor-Ds20AUDY.js";
-import { a as ConsentActor, c as ConsentConfig, i as createConsentManagerFromActor, n as ConsentState, o as consentMachine, r as createConsentManager, s as ConsentCheckbox, t as ConsentManager } from "./consentManager-CHV12fjQ.js";
+import "./Manager-BHn8wH8K.js";
+import "./Actor-Y0_Fj-KL.js";
+import { a as ConsentActor, c as ConsentConfig, i as createConsentManagerFromActor, n as ConsentState, o as consentMachine, r as createConsentManager, s as ConsentCheckbox, t as ConsentManager } from "./consentManager-66SjOJ7U.js";
 export { type ConsentActor, type ConsentCheckbox, type ConsentConfig, type ConsentManager, type ConsentState, consentMachine, createConsentManager, createConsentManagerFromActor };

package/dist/consent.esm.js

@@ -1,8 +1,8 @@
-import "./api-YxPMtty2.esm.js";
-import "./events-Bsw1l0pH.esm.js";
-import "./endpoints-BPHddOTi.esm.js";
-import "./xstate.esm-CWoFJOio.esm.js";
-import { t as consentMachine } from "./consentStateMachine-CUOuuC7d.esm.js";
-import { n as createConsentManagerFromActor, t as createConsentManager } from "./consentManager-D0NGejCx.esm.js";
+import "./api-CESGtpbH.esm.js";
+import "./events-Dvvriq9l.esm.js";
+import "./endpoints-zEf_JIJU.esm.js";
+import "./xstate.esm-C9wncMQa.esm.js";
+import { t as consentMachine } from "./consentStateMachine-CUVp1kKY.esm.js";
+import { n as createConsentManagerFromActor, t as createConsentManager } from "./consentManager-DOufCKTj.esm.js";
 
 export { consentMachine, createConsentManager, createConsentManagerFromActor };

package/dist/{consentManager-CHV12fjQ.d.ts → consentManager-66SjOJ7U.d.ts}

@@ -1,6 +1,6 @@
-import { t as Manager } from "./Manager-Dh6pC-6V.js";
-import { t as ActorRefFrom } from "./Actor-Ds20AUDY.js";
-import * as xstate1484 from "xstate";
+import { t as Manager } from "./Manager-BHn8wH8K.js";
+import { t as ActorRefFrom } from "./Actor-Y0_Fj-KL.js";
+import * as xstate740 from "xstate";
 
 //#region src/modules/consent/types.d.ts
 type ConsentConfig = {
@@ -37,7 +37,7 @@ type ConsentContext = {
 type ConsentInput = {
   config: ConsentConfig;
 };
-declare const consentMachine: xstate1484.StateMachine<ConsentContext, {
+declare const consentMachine: xstate740.StateMachine<ConsentContext, {
   type: "LOAD";
 } | {
   type: "TOGGLE_CHECKBOX";
@@ -49,55 +49,55 @@ declare const consentMachine: xstate1484.StateMachine<ConsentContext, {
 } | {
   type: "RESET";
 }, {
-  [x: string]: xstate1484.ActorRefFromLogic<xstate1484.PromiseActorLogic<FetchCombinedConsentResponse, {
+  [x: string]: xstate740.ActorRefFromLogic<xstate740.PromiseActorLogic<FetchCombinedConsentResponse, {
     consentId: string;
     language?: string;
-  }, xstate1484.EventObject>> | xstate1484.ActorRefFromLogic<xstate1484.PromiseActorLogic<void, {
+  }, xstate740.EventObject>> | xstate740.ActorRefFromLogic<xstate740.PromiseActorLogic<void, {
     languageConsentId: string;
     checkboxes: ConsentCheckbox[];
-  }, xstate1484.EventObject>> | undefined;
-}, xstate1484.Values<{
+  }, xstate740.EventObject>> | undefined;
+}, xstate740.Values<{
   fetchConsent: {
     src: "fetchConsent";
-    logic: xstate1484.PromiseActorLogic<FetchCombinedConsentResponse, {
+    logic: xstate740.PromiseActorLogic<FetchCombinedConsentResponse, {
       consentId: string;
       language?: string;
-    }, xstate1484.EventObject>;
+    }, xstate740.EventObject>;
     id: string | undefined;
   };
   submitConsent: {
     src: "submitConsent";
-    logic: xstate1484.PromiseActorLogic<void, {
+    logic: xstate740.PromiseActorLogic<void, {
       languageConsentId: string;
       checkboxes: ConsentCheckbox[];
-    }, xstate1484.EventObject>;
+    }, xstate740.EventObject>;
     id: string | undefined;
   };
-}>, xstate1484.Values<{
-  clearError: {
-    type: "clearError";
-    params: xstate1484.NonReducibleUnknown;
-  };
+}>, xstate740.Values<{
   setError: {
     type: "setError";
-    params: xstate1484.NonReducibleUnknown;
+    params: xstate740.NonReducibleUnknown;
+  };
+  clearError: {
+    type: "clearError";
+    params: xstate740.NonReducibleUnknown;
   };
   resetContext: {
     type: "resetContext";
-    params: xstate1484.NonReducibleUnknown;
+    params: xstate740.NonReducibleUnknown;
   };
   setConsentData: {
     type: "setConsentData";
-    params: xstate1484.NonReducibleUnknown;
+    params: xstate740.NonReducibleUnknown;
   };
   toggleCheckbox: {
     type: "toggleCheckbox";
-    params: xstate1484.NonReducibleUnknown;
+    params: xstate740.NonReducibleUnknown;
   };
 }>, {
   type: "canSubmit";
   params: unknown;
-}, never, "error" | "idle" | "finished" | "loading" | "submitting" | "display", string, ConsentInput, xstate1484.NonReducibleUnknown, xstate1484.EventObject, xstate1484.MetaObject, {
+}, never, "error" | "idle" | "finished" | "loading" | "display" | "submitting", string, ConsentInput, xstate740.NonReducibleUnknown, xstate740.EventObject, xstate740.MetaObject, {
   readonly id: "consent";
   readonly initial: "idle";
   readonly context: ({
@@ -106,73 +106,73 @@ declare const consentMachine: xstate1484.StateMachine<ConsentContext, {
     spawn: {
       <TSrc extends "fetchConsent" | "submitConsent">(logic: TSrc, ...[options]: ({
         src: "fetchConsent";
-        logic: xstate1484.PromiseActorLogic<FetchCombinedConsentResponse, {
+        logic: xstate740.PromiseActorLogic<FetchCombinedConsentResponse, {
           consentId: string;
           language?: string;
-        }, xstate1484.EventObject>;
+        }, xstate740.EventObject>;
         id: string | undefined;
       } extends infer T ? T extends {
         src: "fetchConsent";
-        logic: xstate1484.PromiseActorLogic<FetchCombinedConsentResponse, {
+        logic: xstate740.PromiseActorLogic<FetchCombinedConsentResponse, {
           consentId: string;
           language?: string;
-        }, xstate1484.EventObject>;
+        }, xstate740.EventObject>;
         id: string | undefined;
       } ? T extends {
         src: TSrc;
-      } ? xstate1484.ConditionalRequired<[options?: ({
+      } ? xstate740.ConditionalRequired<[options?: ({
         id?: T["id"] | undefined;
         systemId?: string;
-        input?: xstate1484.InputFrom<T["logic"]> | undefined;
+        input?: xstate740.InputFrom<T["logic"]> | undefined;
         syncSnapshot?: boolean;
-      } & { [K in xstate1484.RequiredActorOptions<T>]: unknown }) | undefined], xstate1484.IsNotNever<xstate1484.RequiredActorOptions<T>>> : never : never : never) | ({
+      } & { [K in xstate740.RequiredActorOptions<T>]: unknown }) | undefined], xstate740.IsNotNever<xstate740.RequiredActorOptions<T>>> : never : never : never) | ({
         src: "submitConsent";
-        logic: xstate1484.PromiseActorLogic<void, {
+        logic: xstate740.PromiseActorLogic<void, {
           languageConsentId: string;
           checkboxes: ConsentCheckbox[];
-        }, xstate1484.EventObject>;
+        }, xstate740.EventObject>;
         id: string | undefined;
       } extends infer T_1 ? T_1 extends {
         src: "submitConsent";
-        logic: xstate1484.PromiseActorLogic<void, {
+        logic: xstate740.PromiseActorLogic<void, {
           languageConsentId: string;
           checkboxes: ConsentCheckbox[];
-        }, xstate1484.EventObject>;
+        }, xstate740.EventObject>;
         id: string | undefined;
       } ? T_1 extends {
         src: TSrc;
-      } ? xstate1484.ConditionalRequired<[options?: ({
+      } ? xstate740.ConditionalRequired<[options?: ({
         id?: T_1["id"] | undefined;
         systemId?: string;
-        input?: xstate1484.InputFrom<T_1["logic"]> | undefined;
+        input?: xstate740.InputFrom<T_1["logic"]> | undefined;
         syncSnapshot?: boolean;
-      } & { [K_1 in xstate1484.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate1484.IsNotNever<xstate1484.RequiredActorOptions<T_1>>> : never : never : never)): xstate1484.ActorRefFromLogic<xstate1484.GetConcreteByKey<xstate1484.Values<{
+      } & { [K_1 in xstate740.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate740.IsNotNever<xstate740.RequiredActorOptions<T_1>>> : never : never : never)): xstate740.ActorRefFromLogic<xstate740.GetConcreteByKey<xstate740.Values<{
         fetchConsent: {
           src: "fetchConsent";
-          logic: xstate1484.PromiseActorLogic<FetchCombinedConsentResponse, {
+          logic: xstate740.PromiseActorLogic<FetchCombinedConsentResponse, {
             consentId: string;
             language?: string;
-          }, xstate1484.EventObject>;
+          }, xstate740.EventObject>;
           id: string | undefined;
         };
         submitConsent: {
           src: "submitConsent";
-          logic: xstate1484.PromiseActorLogic<void, {
+          logic: xstate740.PromiseActorLogic<void, {
             languageConsentId: string;
             checkboxes: ConsentCheckbox[];
-          }, xstate1484.EventObject>;
+          }, xstate740.EventObject>;
           id: string | undefined;
         };
       }>, "src", TSrc>["logic"]>;
-      <TLogic extends xstate1484.AnyActorLogic>(src: TLogic, ...[options]: xstate1484.ConditionalRequired<[options?: ({
+      <TLogic extends xstate740.AnyActorLogic>(src: TLogic, ...[options]: xstate740.ConditionalRequired<[options?: ({
         id?: never;
         systemId?: string;
-        input?: xstate1484.InputFrom<TLogic> | undefined;
+        input?: xstate740.InputFrom<TLogic> | undefined;
         syncSnapshot?: boolean;
-      } & { [K in xstate1484.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate1484.IsNotNever<xstate1484.RequiredLogicInput<TLogic>>>): xstate1484.ActorRefFromLogic<TLogic>;
+      } & { [K in xstate740.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate740.IsNotNever<xstate740.RequiredLogicInput<TLogic>>>): xstate740.ActorRefFromLogic<TLogic>;
     };
     input: ConsentInput;
-    self: xstate1484.ActorRef<xstate1484.MachineSnapshot<ConsentContext, {
+    self: xstate740.ActorRef<xstate740.MachineSnapshot<ConsentContext, {
       type: "LOAD";
     } | {
       type: "TOGGLE_CHECKBOX";
@@ -183,7 +183,7 @@ declare const consentMachine: xstate1484.StateMachine<ConsentContext, {
       type: "RETRY";
     } | {
       type: "RESET";
-    }, Record<string, xstate1484.AnyActorRef | undefined>, xstate1484.StateValue, string, unknown, any, any>, {
+    }, Record<string, xstate740.AnyActorRef | undefined>, xstate740.StateValue, string, unknown, any, any>, {
       type: "LOAD";
     } | {
       type: "TOGGLE_CHECKBOX";
@@ -194,7 +194,7 @@ declare const consentMachine: xstate1484.StateMachine<ConsentContext, {
       type: "RETRY";
     } | {
       type: "RESET";
-    }, xstate1484.AnyEventObject>;
+    }, xstate740.AnyEventObject>;
   }) => {
     config: ConsentConfig;
     title: string;
@@ -232,7 +232,7 @@ declare const consentMachine: xstate1484.StateMachine<ConsentContext, {
           } | {
             type: "RESET";
           };
-          self: xstate1484.ActorRef<xstate1484.MachineSnapshot<ConsentContext, {
+          self: xstate740.ActorRef<xstate740.MachineSnapshot<ConsentContext, {
             type: "LOAD";
           } | {
             type: "TOGGLE_CHECKBOX";
@@ -243,7 +243,7 @@ declare const consentMachine: xstate1484.StateMachine<ConsentContext, {
             type: "RETRY";
           } | {
             type: "RESET";
-          }, Record<string, xstate1484.AnyActorRef>, xstate1484.StateValue, string, unknown, any, any>, {
+          }, Record<string, xstate740.AnyActorRef>, xstate740.StateValue, string, unknown, any, any>, {
             type: "LOAD";
           } | {
             type: "TOGGLE_CHECKBOX";
@@ -254,7 +254,7 @@ declare const consentMachine: xstate1484.StateMachine<ConsentContext, {
             type: "RETRY";
           } | {
             type: "RESET";
-          }, xstate1484.AnyEventObject>;
+          }, xstate740.AnyEventObject>;
         }) => {
           consentId: string;
           language: string | undefined;
@@ -304,7 +304,7 @@ declare const consentMachine: xstate1484.StateMachine<ConsentContext, {
           } | {
             type: "RESET";
           };
-          self: xstate1484.ActorRef<xstate1484.MachineSnapshot<ConsentContext, {
+          self: xstate740.ActorRef<xstate740.MachineSnapshot<ConsentContext, {
             type: "LOAD";
           } | {
             type: "TOGGLE_CHECKBOX";
@@ -315,7 +315,7 @@ declare const consentMachine: xstate1484.StateMachine<ConsentContext, {
             type: "RETRY";
           } | {
             type: "RESET";
-          }, Record<string, xstate1484.AnyActorRef>, xstate1484.StateValue, string, unknown, any, any>, {
+          }, Record<string, xstate740.AnyActorRef>, xstate740.StateValue, string, unknown, any, any>, {
             type: "LOAD";
           } | {
             type: "TOGGLE_CHECKBOX";
@@ -326,7 +326,7 @@ declare const consentMachine: xstate1484.StateMachine<ConsentContext, {
             type: "RETRY";
           } | {
             type: "RESET";
-          }, xstate1484.AnyEventObject>;
+          }, xstate740.AnyEventObject>;
         }) => {
           languageConsentId: string;
           checkboxes: ConsentCheckbox[];

package/dist/{consentManager-D0NGejCx.esm.js → consentManager-DOufCKTj.esm.js}

@@ -1,6 +1,6 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Bsw1l0pH.esm.js";
-import { c as createManager, s as createActor } from "./xstate.esm-CWoFJOio.esm.js";
-import { t as consentMachine } from "./consentStateMachine-CUOuuC7d.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
+import { c as createManager, s as createActor } from "./xstate.esm-C9wncMQa.esm.js";
+import { t as consentMachine } from "./consentStateMachine-CUVp1kKY.esm.js";
 
 //#region src/modules/consent/consentActor.ts
 function createConsentActor(options) {

package/dist/{consentStateMachine-CUOuuC7d.esm.js → consentStateMachine-CUVp1kKY.esm.js}

@@ -1,6 +1,6 @@
-import { t as api } from "./api-YxPMtty2.esm.js";
-import { t as endpoints } from "./endpoints-BPHddOTi.esm.js";
-import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-CWoFJOio.esm.js";
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { t as endpoints } from "./endpoints-zEf_JIJU.esm.js";
+import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
 
 //#region src/modules/consent/consentServices.ts
 async function fetchCombinedConsent(consentId, language, signal) {

package/dist/cpf-ocr.d.ts

@@ -1,6 +1,6 @@
-import "./Manager-Dh6pC-6V.js";
-import "./Actor-Ds20AUDY.js";
-import { a as CpfOcrActor, i as createCpfOcrManagerFromActor, n as CpfOcrState, o as cpfOcrMachine, r as createCpfOcrManager, t as CpfOcrManager } from "./cpfOcrManager-BR_dJaKV.js";
+import "./Manager-BHn8wH8K.js";
+import "./Actor-Y0_Fj-KL.js";
+import { a as CpfOcrActor, i as createCpfOcrManagerFromActor, n as CpfOcrState, o as cpfOcrMachine, r as createCpfOcrManager, t as CpfOcrManager } from "./cpfOcrManager-DVSJov4W.js";
 
 //#region src/modules/cpf-ocr/cpfOcrUtils.d.ts
 declare function formatCPF(value: string): string;

package/dist/cpf-ocr.esm.js

@@ -1,8 +1,8 @@
-import "./api-YxPMtty2.esm.js";
-import "./events-Bsw1l0pH.esm.js";
-import "./endpoints-BPHddOTi.esm.js";
-import "./xstate.esm-CWoFJOio.esm.js";
-import { a as isValidCPF, i as formatCPF, n as createCpfOcrManagerFromActor, r as cpfOcrMachine, t as createCpfOcrManager } from "./cpfOcrManager-9ciXe_XT.esm.js";
-import "./cpf-COPPtEoQ.esm.js";
+import "./api-CESGtpbH.esm.js";
+import "./events-Dvvriq9l.esm.js";
+import "./endpoints-zEf_JIJU.esm.js";
+import "./xstate.esm-C9wncMQa.esm.js";
+import { a as isValidCPF, i as formatCPF, n as createCpfOcrManagerFromActor, r as cpfOcrMachine, t as createCpfOcrManager } from "./cpfOcrManager-Bm5OlZSa.esm.js";
+import "./cpf-BRzggV8G.esm.js";
 
 export { cpfOcrMachine, createCpfOcrManager, createCpfOcrManagerFromActor, formatCPF, isValidCPF };

package/dist/{cpfOcrManager-9ciXe_XT.esm.js → cpfOcrManager-Bm5OlZSa.esm.js}

@@ -1,8 +1,8 @@
-import { t as api } from "./api-YxPMtty2.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Bsw1l0pH.esm.js";
-import { t as endpoints } from "./endpoints-BPHddOTi.esm.js";
-import { a as fromPromise, c as createManager, r as assign, s as createActor, t as setup } from "./xstate.esm-CWoFJOio.esm.js";
-import { t as validateCPF } from "./cpf-COPPtEoQ.esm.js";
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
+import { t as endpoints } from "./endpoints-zEf_JIJU.esm.js";
+import { a as fromPromise, c as createManager, r as assign, s as createActor, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
+import { t as validateCPF } from "./cpf-BRzggV8G.esm.js";
 
 //#region src/modules/cpf-ocr/cpfOcrServices.ts
 async function fetchCpfOcrData(signal) {