@purespectrum1/purescore-client 0.7.0

package/lib/domain/services/behavioural-biometrics/touch-behavior.d.ts

@@ -0,0 +1,125 @@
+import { SwipeGesture, SwipeMovement, TouchBehaviorBiometrics } from '../../protocols/services/behavioural-biometrics/touch-behavior';
+import { BehaviouralBiometricsOptions } from '../../protocols/services/device-identifier';
+/**
+ * TouchBehavior class for capturing and analyzing touch/gesture behavioral signals.
+ *
+ * This class tracks various touchscreen interactions including:
+ * - Touch pressure (force sensitivity)
+ * - Swipe gestures (speed, angle, length)
+ * - Finger size/contact area
+ */
+export declare class TouchBehavior {
+    private pressureData;
+    private touchSizes;
+    private swipeGestures;
+    private swipeMovements;
+    private touchSwipeStart;
+    private touchLastPosition;
+    private pointerSwipeStart;
+    private pointerLastPosition;
+    private isTracking;
+    private useTouchForSwipes;
+    private minSwipeLength;
+    private maxSwipeDuration;
+    private pointerDownHandler;
+    private pointerMoveHandler;
+    private pointerUpHandler;
+    private pointerCancelHandler;
+    private touchStartHandler;
+    private touchMoveHandler;
+    private touchEndHandler;
+    constructor();
+    /**
+     * Starts tracking touch behavior.
+     */
+    startTracking(options?: BehaviouralBiometricsOptions): void;
+    /**
+     * Stops tracking touch behavior without clearing collected data.
+     */
+    stopTracking(): void;
+    /**
+     * Returns true if this tracker currently has its DOM listeners attached
+     * (i.e., it is actively collecting touch/pointer events).
+     */
+    hasActiveListeners(): boolean;
+    /**
+     * Snapshot of the raw event buffers this tracker has accumulated.
+     * Used to persist state across page reloads / SSR navigations.
+     */
+    getState(): {
+        pressureData: number[];
+        touchSizes: Array<{
+            radiusX: number;
+            radiusY: number;
+        }>;
+        swipeGestures: SwipeGesture[];
+        swipeMovements: SwipeMovement[];
+    };
+    /**
+     * Restores raw event buffers from a previously captured snapshot. Transient
+     * mid-gesture state (swipe-start maps, last positions) is intentionally not
+     * restored — it is only meaningful within a single continuous interaction.
+     */
+    restoreState(state: {
+        pressureData?: number[];
+        touchSizes?: Array<{
+            radiusX: number;
+            radiusY: number;
+        }>;
+        swipeGestures?: SwipeGesture[];
+        swipeMovements?: SwipeMovement[];
+    }): void;
+    /**
+     * Resets all collected touch behavioral data.
+     */
+    resetData(): void;
+    private handlePointerDown;
+    private handlePointerMove;
+    /**
+     * Handles pointer up events and calculates swipe metrics.
+     */
+    private handlePointerUp;
+    /**
+     * Handles pointer cancel events (non-touch devices only).
+     */
+    private handlePointerCancel;
+    /**
+     * Handles touch start events.
+     */
+    private handleTouchStart;
+    /**
+     * touchmove - track the latest position so we know where the finger is.
+     */
+    private handleTouchMove;
+    /**
+     * touchend - finalize the swipe using the real touchend coordinates.
+     * This always fires, even if the browser took over scrolling.
+     */
+    private handleTouchEnd;
+    /**
+     * Records a swipe from start data to the given end coordinates.
+     */
+    private recordSwipe;
+    /**
+     * Finalizes a pointer-based swipe (non-touch devices only).
+     */
+    private finalizePointerSwipe;
+    /**
+     * Gets the complete touch behavioral biometrics.
+     */
+    getTouchBehaviorBiometrics(): TouchBehaviorBiometrics;
+    /**
+     * Returns all recorded swipe movements with direction and coordinates.
+     */
+    getSwipeMovements(): SwipeMovement[];
+    private calculateAngle;
+    private calculateDirection;
+    private getPressureData;
+    private getSwipeMetrics;
+    private getFingerSizeData;
+    private isPointerSupported;
+    private isTouchSupported;
+    private isTrackablePointer;
+    private isPointerPressureSupported;
+    private isPointerSizeSupported;
+}

package/lib/domain/services/behavioural-biometrics/touch-behavior.js

@@ -0,0 +1,413 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TouchBehavior = void 0;
+/**
+ * TouchBehavior class for capturing and analyzing touch/gesture behavioral signals.
+ *
+ * This class tracks various touchscreen interactions including:
+ * - Touch pressure (force sensitivity)
+ * - Swipe gestures (speed, angle, length)
+ * - Finger size/contact area
+ */
+class TouchBehavior {
+    constructor() {
+        this.pressureData = [];
+        this.touchSizes = [];
+        this.swipeGestures = [];
+        this.swipeMovements = [];
+        // Touch-based swipe tracking (primary on touch devices)
+        this.touchSwipeStart = new Map();
+        this.touchLastPosition = new Map();
+        // Pointer-based swipe tracking (used only on non-touch-pointer devices)
+        this.pointerSwipeStart = new Map();
+        this.pointerLastPosition = new Map();
+        this.isTracking = false;
+        this.useTouchForSwipes = false;
+        this.minSwipeLength = 15;
+        this.maxSwipeDuration = 2000;
+        this.pointerDownHandler = this.handlePointerDown.bind(this);
+        this.pointerMoveHandler = this.handlePointerMove.bind(this);
+        this.pointerUpHandler = this.handlePointerUp.bind(this);
+        this.pointerCancelHandler = this.handlePointerCancel.bind(this);
+        this.touchStartHandler = this.handleTouchStart.bind(this);
+        this.touchMoveHandler = this.handleTouchMove.bind(this);
+        this.touchEndHandler = this.handleTouchEnd.bind(this);
+    }
+    /**
+     * Starts tracking touch behavior.
+     */
+    startTracking(options) {
+        var _a, _b;
+        if (this.isTracking || typeof window === 'undefined' || typeof document === 'undefined') {
+            return;
+        }
+        this.minSwipeLength = (_a = options === null || options === void 0 ? void 0 : options.minSwipeLength) !== null && _a !== void 0 ? _a : 15;
+        this.maxSwipeDuration = (_b = options === null || options === void 0 ? void 0 : options.maxSwipeDuration) !== null && _b !== void 0 ? _b : 2000;
+        this.isTracking = true;
+        this.useTouchForSwipes = this.isTouchSupported();
+        // Reset data
+        this.resetData();
+        if (this.isPointerSupported()) {
+            document.addEventListener('pointerdown', this.pointerDownHandler, { passive: true });
+            document.addEventListener('pointermove', this.pointerMoveHandler, { passive: true });
+            // Only listen for pointerup/cancel for swipe tracking on non-touch devices
+            if (!this.useTouchForSwipes) {
+                document.addEventListener('pointerup', this.pointerUpHandler, { passive: true });
+                document.addEventListener('pointercancel', this.pointerCancelHandler, { passive: true });
+            }
+        }
+        if (this.useTouchForSwipes) {
+            document.addEventListener('touchstart', this.touchStartHandler, { passive: true });
+            document.addEventListener('touchmove', this.touchMoveHandler, { passive: true });
+            document.addEventListener('touchend', this.touchEndHandler, { passive: true });
+        }
+    }
+    /**
+     * Stops tracking touch behavior without clearing collected data.
+     */
+    stopTracking() {
+        if (!this.isTracking)
+            return;
+        this.isTracking = false;
+        document.removeEventListener('pointerdown', this.pointerDownHandler);
+        document.removeEventListener('pointermove', this.pointerMoveHandler);
+        document.removeEventListener('pointerup', this.pointerUpHandler);
+        document.removeEventListener('pointercancel', this.pointerCancelHandler);
+        document.removeEventListener('touchstart', this.touchStartHandler);
+        document.removeEventListener('touchmove', this.touchMoveHandler);
+        document.removeEventListener('touchend', this.touchEndHandler);
+    }
+    /**
+     * Returns true if this tracker currently has its DOM listeners attached
+     * (i.e., it is actively collecting touch/pointer events).
+     */
+    hasActiveListeners() {
+        return this.isTracking;
+    }
+    /**
+     * Snapshot of the raw event buffers this tracker has accumulated.
+     * Used to persist state across page reloads / SSR navigations.
+     */
+    getState() {
+        return {
+            pressureData: this.pressureData,
+            touchSizes: this.touchSizes,
+            swipeGestures: this.swipeGestures,
+            swipeMovements: this.swipeMovements,
+        };
+    }
+    /**
+     * Restores raw event buffers from a previously captured snapshot. Transient
+     * mid-gesture state (swipe-start maps, last positions) is intentionally not
+     * restored — it is only meaningful within a single continuous interaction.
+     */
+    restoreState(state) {
+        if (state.pressureData)
+            this.pressureData = state.pressureData;
+        if (state.touchSizes)
+            this.touchSizes = state.touchSizes;
+        if (state.swipeGestures)
+            this.swipeGestures = state.swipeGestures;
+        if (state.swipeMovements)
+            this.swipeMovements = state.swipeMovements;
+    }
+    /**
+     * Resets all collected touch behavioral data.
+     */
+    resetData() {
+        this.pressureData = [];
+        this.touchSizes = [];
+        this.swipeGestures = [];
+        this.swipeMovements = [];
+        this.touchSwipeStart.clear();
+        this.touchLastPosition.clear();
+        this.pointerSwipeStart.clear();
+        this.pointerLastPosition.clear();
+    }
+    handlePointerDown(event) {
+        if (!this.isTracking)
+            return;
+        if (!this.isTrackablePointer(event))
+            return;
+        // Collect pressure data
+        if (this.isPointerPressureSupported(event)) {
+            this.pressureData.push(event.pressure);
+        }
+        // Collect finger size data
+        if (this.isPointerSizeSupported(event)) {
+            this.touchSizes.push({
+                radiusX: (event.width || 0) / 2,
+                radiusY: (event.height || 0) / 2
+            });
+        }
+        // Track swipe start only on non-touch-pointer devices
+        if (!this.useTouchForSwipes) {
+            this.pointerSwipeStart.set(event.pointerId, {
+                x: event.clientX,
+                y: event.clientY,
+                time: Date.now()
+            });
+        }
+    }
+    handlePointerMove(event) {
+        if (!this.isTracking)
+            return;
+        if (!this.isTrackablePointer(event))
+            return;
+        // Collect pressure data
+        if (this.isPointerPressureSupported(event)) {
+            this.pressureData.push(event.pressure);
+        }
+        // Collect finger size data
+        if (this.isPointerSizeSupported(event)) {
+            this.touchSizes.push({
+                radiusX: (event.width || 0) / 2,
+                radiusY: (event.height || 0) / 2
+            });
+        }
+        // Track last position only on non-touch-pointer devices
+        if (!this.useTouchForSwipes) {
+            this.pointerLastPosition.set(event.pointerId, { x: event.clientX, y: event.clientY });
+        }
+    }
+    /**
+     * Handles pointer up events and calculates swipe metrics.
+     */
+    handlePointerUp(event) {
+        if (!this.isTracking)
+            return;
+        if (!this.isTrackablePointer(event))
+            return;
+        this.finalizePointerSwipe(event.pointerId, event.clientX, event.clientY, false);
+    }
+    /**
+     * Handles pointer cancel events (non-touch devices only).
+     */
+    handlePointerCancel(event) {
+        if (!this.isTracking)
+            return;
+        this.finalizePointerSwipe(event.pointerId, event.clientX, event.clientY, true);
+    }
+    /**
+     * Handles touch start events.
+     */
+    handleTouchStart(event) {
+        if (!this.isTracking)
+            return;
+        for (let i = 0; i < event.changedTouches.length; i++) {
+            const touch = event.changedTouches[i];
+            this.touchSwipeStart.set(touch.identifier, {
+                x: touch.clientX,
+                y: touch.clientY,
+                time: Date.now()
+            });
+        }
+    }
+    /**
+     * touchmove - track the latest position so we know where the finger is.
+     */
+    handleTouchMove(event) {
+        if (!this.isTracking)
+            return;
+        for (let i = 0; i < event.changedTouches.length; i++) {
+            const touch = event.changedTouches[i];
+            this.touchLastPosition.set(touch.identifier, {
+                x: touch.clientX,
+                y: touch.clientY
+            });
+        }
+    }
+    /**
+     * touchend - finalize the swipe using the real touchend coordinates.
+     * This always fires, even if the browser took over scrolling.
+     */
+    handleTouchEnd(event) {
+        if (!this.isTracking)
+            return;
+        for (let i = 0; i < event.changedTouches.length; i++) {
+            const touch = event.changedTouches[i];
+            const touchId = touch.identifier;
+            const endX = touch.clientX;
+            const endY = touch.clientY;
+            const startData = this.touchSwipeStart.get(touchId);
+            if (startData) {
+                this.recordSwipe(startData, endX, endY);
+                this.touchSwipeStart.delete(touchId);
+                this.touchLastPosition.delete(touchId);
+            }
+        }
+    }
+    /**
+     * Records a swipe from start data to the given end coordinates.
+     */
+    recordSwipe(startData, endX, endY) {
+        const endTime = Date.now();
+        const deltaX = endX - startData.x;
+        const deltaY = endY - startData.y;
+        const duration = endTime - startData.time;
+        const length = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+        if (length >= this.minSwipeLength && duration <= this.maxSwipeDuration) {
+            const speed = length / duration;
+            const angle = this.calculateAngle(deltaX, deltaY);
+            const swipe = {
+                speed,
+                angle,
+                length,
+                duration,
+                timestamp: startData.time
+            };
+            this.swipeGestures.push(swipe);
+            const movement = {
+                direction: this.calculateDirection(deltaX, deltaY),
+                start: [startData.x, startData.y],
+                end: [endX, endY]
+            };
+            this.swipeMovements.push(movement);
+        }
+    }
+    /**
+     * Finalizes a pointer-based swipe (non-touch devices only).
+     */
+    finalizePointerSwipe(pointerId, endX, endY, useLastPosAsFallback) {
+        const startData = this.pointerSwipeStart.get(pointerId);
+        if (!startData)
+            return;
+        const lastPos = this.pointerLastPosition.get(pointerId);
+        const resolvedEndX = (useLastPosAsFallback && endX === 0 && endY === 0 && lastPos) ? lastPos.x : endX;
+        const resolvedEndY = (useLastPosAsFallback && endX === 0 && endY === 0 && lastPos) ? lastPos.y : endY;
+        this.recordSwipe(startData, resolvedEndX, resolvedEndY);
+        this.pointerSwipeStart.delete(pointerId);
+        this.pointerLastPosition.delete(pointerId);
+    }
+    // --- Biometrics output ---
+    /**
+     * Gets the complete touch behavioral biometrics.
+     */
+    getTouchBehaviorBiometrics() {
+        return {
+            pressure: this.getPressureData(),
+            swipe: this.getSwipeMetrics(),
+            fingerSize: this.getFingerSizeData()
+        };
+    }
+    /**
+     * Returns all recorded swipe movements with direction and coordinates.
+     */
+    getSwipeMovements() {
+        return this.swipeMovements;
+    }
+    // --- Helper methods ---
+    calculateAngle(deltaX, deltaY) {
+        let angle = Math.atan2(deltaY, deltaX) * (180 / Math.PI);
+        if (angle < 0) {
+            angle += 360;
+        }
+        return angle;
+    }
+    calculateDirection(deltaX, deltaY) {
+        if (Math.abs(deltaX) >= Math.abs(deltaY)) {
+            return deltaX > 0 ? 'right' : 'left';
+        }
+        else {
+            return deltaY > 0 ? 'down' : 'up';
+        }
+    }
+    getPressureData() {
+        if (this.pressureData.length === 0) {
+            return {
+                averagePressure: null,
+                maxPressure: null,
+                minPressure: null,
+                pressureVariability: null,
+            };
+        }
+        const sum = this.pressureData.reduce((a, b) => a + b, 0);
+        const avg = sum / this.pressureData.length;
+        const max = Math.max(...this.pressureData);
+        const min = Math.min(...this.pressureData);
+        const variance = this.pressureData.reduce((acc, val) => acc + Math.pow(val - avg, 2), 0) / this.pressureData.length;
+        const stdDev = Math.sqrt(variance);
+        return {
+            averagePressure: avg,
+            maxPressure: max,
+            minPressure: min,
+            pressureVariability: stdDev
+        };
+    }
+    getSwipeMetrics() {
+        if (this.swipeGestures.length === 0) {
+            return {
+                averageSpeed: null,
+                averageAngle: null,
+                averageLength: null,
+                averageDuration: null,
+                speedVariability: null,
+                angleVariability: null,
+                swipeCount: 0,
+                swipes: []
+            };
+        }
+        const speeds = this.swipeGestures.map(s => s.speed);
+        const angles = this.swipeGestures.map(s => s.angle);
+        const lengths = this.swipeGestures.map(s => s.length);
+        const durations = this.swipeGestures.map(s => s.duration);
+        const avgSpeed = speeds.reduce((a, b) => a + b, 0) / speeds.length;
+        const avgAngle = angles.reduce((a, b) => a + b, 0) / angles.length;
+        const avgLength = lengths.reduce((a, b) => a + b, 0) / lengths.length;
+        const avgDuration = durations.reduce((a, b) => a + b, 0) / durations.length;
+        const speedVariance = speeds.reduce((acc, val) => acc + Math.pow(val - avgSpeed, 2), 0) / speeds.length;
+        const angleVariance = angles.reduce((acc, val) => acc + Math.pow(val - avgAngle, 2), 0) / angles.length;
+        return {
+            averageSpeed: avgSpeed,
+            averageAngle: avgAngle,
+            averageLength: avgLength,
+            averageDuration: avgDuration,
+            speedVariability: Math.sqrt(speedVariance),
+            angleVariability: Math.sqrt(angleVariance),
+            swipeCount: this.swipeGestures.length,
+            swipes: this.swipeMovements
+        };
+    }
+    getFingerSizeData() {
+        if (this.touchSizes.length === 0) {
+            return {
+                averageTouchRadius: null,
+                maxTouchRadius: null,
+                minTouchRadius: null,
+                sizeVariability: null,
+                averageTouchArea: null,
+            };
+        }
+        const radii = this.touchSizes.map(t => (t.radiusX + t.radiusY) / 2);
+        const areas = this.touchSizes.map(t => t.radiusX * t.radiusY);
+        const avgRadius = radii.reduce((a, b) => a + b, 0) / radii.length;
+        const maxRadius = Math.max(...radii);
+        const minRadius = Math.min(...radii);
+        const avgArea = areas.reduce((a, b) => a + b, 0) / areas.length;
+        const variance = radii.reduce((acc, val) => acc + Math.pow(val - avgRadius, 2), 0) / radii.length;
+        return {
+            averageTouchRadius: avgRadius,
+            maxTouchRadius: maxRadius,
+            minTouchRadius: minRadius,
+            sizeVariability: Math.sqrt(variance),
+            averageTouchArea: avgArea,
+        };
+    }
+    isPointerSupported() {
+        return 'PointerEvent' in window && 'onpointerdown' in window;
+    }
+    isTouchSupported() {
+        return 'ontouchstart' in window || navigator.maxTouchPoints > 0;
+    }
+    isTrackablePointer(pointer) {
+        return pointer.pointerType === 'touch' || pointer.pointerType === 'pen';
+    }
+    isPointerPressureSupported(pointer) {
+        return typeof pointer.pressure === 'number' && pointer.pressure > 0;
+    }
+    isPointerSizeSupported(pointer) {
+        return typeof pointer.width === 'number' && typeof pointer.height === 'number' &&
+            (pointer.width > 0 || pointer.height > 0);
+    }
+}
+exports.TouchBehavior = TouchBehavior;

package/lib/domain/services/device-fingerprint/audio.d.ts

@@ -0,0 +1,14 @@
+export declare const enum DefaultFingerprint {
+    /** The browser doesn't support audio context */
+    NotSupported = -1,
+    /** An unexpected timeout has happened */
+    Timeout = -2
+}
+export declare class AudioFingerprint {
+    private AudioContext;
+    getAudioFingerprint(): Promise<number>;
+    private setAudioParam;
+    private renderAudio;
+    private generateHash;
+    private makeErrorFormat;
+}

package/lib/domain/services/device-fingerprint/audio.js

@@ -0,0 +1,109 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AudioFingerprint = void 0;
+// Define the AudioFingerprint class
+// Based on FingerprintJs(Ref: https://fingerprint.com/blog/audio-fingerprinting/)
+class AudioFingerprint {
+    constructor() {
+        this.AudioContext = window.OfflineAudioContext;
+    }
+    getAudioFingerprint() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.AudioContext) {
+                return -1 /* DefaultFingerprint.NotSupported */;
+            }
+            const hashFromIndex = 4500;
+            const hashToIndex = 5000;
+            const context = new this.AudioContext(1, hashToIndex, 44100);
+            const oscillator = context.createOscillator();
+            oscillator.type = 'triangle';
+            this.setAudioParam(context, oscillator.frequency, 10000);
+            const compressor = context.createDynamicsCompressor();
+            this.setAudioParam(context, compressor.threshold, -50);
+            this.setAudioParam(context, compressor.knee, 40);
+            this.setAudioParam(context, compressor.ratio, 12);
+            this.setAudioParam(context, compressor.reduction, -20);
+            this.setAudioParam(context, compressor.attack, 0);
+            this.setAudioParam(context, compressor.release, 0.25);
+            oscillator.connect(compressor);
+            compressor.connect(context.destination);
+            oscillator.start(0);
+            let buffer;
+            try {
+                buffer = yield this.renderAudio(context);
+            }
+            catch (error) {
+                if (error.name === "timeout" /* ErrorsName.Timeout */ || error.name === "suspended" /* ErrorsName.Suspended */) {
+                    return -2 /* DefaultFingerprint.Timeout */;
+                }
+                throw error;
+            }
+            finally {
+                oscillator.disconnect();
+                compressor.disconnect();
+            }
+            return this.generateHash(buffer.getChannelData(0).subarray(hashFromIndex, hashToIndex));
+        });
+    }
+    setAudioParam(context, param, value) {
+        const isAudioParam = (value) => {
+            return (value !== null &&
+                typeof value === 'object' &&
+                'setValueAtTime' in value &&
+                typeof value.setValueAtTime === 'function');
+        };
+        if (isAudioParam(param)) {
+            param.setValueAtTime(value, context.currentTime);
+        }
+    }
+    renderAudio(context) {
+        const resumeTriesMaxCount = 3;
+        const resumeRetryDelay = 250;
+        const runningTimeout = 500;
+        return new Promise((resolve, reject) => {
+            context.oncomplete = (event) => resolve(event.renderedBuffer);
+            let resumeTriesLeft = resumeTriesMaxCount;
+            const tryResume = () => {
+                context.startRendering();
+                switch (context.state) {
+                    case 'running':
+                        setTimeout(() => reject(this.makeErrorFormat("timeout" /* ErrorsName.Timeout */)), runningTimeout);
+                        break;
+                    case 'suspended':
+                        // Retry if suspended
+                        resumeTriesLeft--;
+                        if (resumeTriesLeft > 0) {
+                            setTimeout(tryResume, resumeRetryDelay);
+                        }
+                        else {
+                            reject(this.makeErrorFormat("suspended" /* ErrorsName.Suspended */));
+                        }
+                        break;
+                }
+            };
+            tryResume();
+        });
+    }
+    generateHash(signal) {
+        let hash = 0;
+        for (let i = 0; i < signal.length; ++i) {
+            hash += Math.abs(signal[i]);
+        }
+        return hash;
+    }
+    makeErrorFormat(name) {
+        const error = new Error(name);
+        error.name = name;
+        return error;
+    }
+}
+exports.AudioFingerprint = AudioFingerprint;

package/lib/domain/services/device-fingerprint/canvas.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Generates a canvas fingerprint, which is a technique used to identify browsers based on their unique rendering of a canvas element.
+ */
+export declare class Canvas {
+    getCanvasFingerprint(): string;
+    /**
+      * Checks if the browser supports the canvas element and successfully returns a 2D context.
+      */
+    private _isCanvasSupported;
+}