@idonatedev/idonate-sdk 1.1.0-dev13 → 1.1.0-dev14

package/dist/esm/tokenize/Tokenizer.d.ts

@@ -0,0 +1,37 @@
+import { CardData, BankAccountData, PaymentData, PaymentToken, ValidationResult, TokenizerEvent, TokenizerStylingComplete, CardType, PaymentGateway, TokenizerContainer, PaymentMethodMode } from './types';
+import ConfigHandler from '../config-handler';
+export declare abstract class Tokenizer {
+    protected mode: PaymentMethodMode;
+    protected eventHandlers: Map<TokenizerEvent, Set<(data?: any) => void>>;
+    abstract tokenize(paymentData: PaymentData): Promise<PaymentToken>;
+    abstract validate(): Promise<ValidationResult>;
+    abstract clear(): void;
+    abstract focus(field: 'cardNumber' | 'cvv' | 'expiry' | 'routingNumber' | 'accountNumber'): void;
+    abstract destroy(): void;
+    abstract hasToken(): boolean;
+    abstract getToken(): PaymentToken | null;
+    abstract get tokenizationMode(): 'auto' | 'manual';
+    getMode(): PaymentMethodMode;
+    on(event: TokenizerEvent, handler: (data?: any) => void): void;
+    off(event: TokenizerEvent, handler: (data?: any) => void): void;
+    protected emit(event: TokenizerEvent, data?: any): void;
+    protected isCardData(data: PaymentData): data is CardData;
+    protected isBankAccountData(data: PaymentData): data is BankAccountData;
+    protected normalizeCardType(providerCardType: string): CardType;
+    protected addExpiryFormatter(expiryEl: HTMLInputElement): void;
+    protected parseExpiry(expiryEl?: HTMLInputElement): {
+        month: string;
+        year: string;
+    } | null;
+    protected applyInputStyles(element: HTMLElement, styles: TokenizerStylingComplete, position?: 'left' | 'middle' | 'right'): void;
+    protected generateFieldIds(containerId: string): {
+        numberId: string;
+        expiryId: string;
+        cvvId: string;
+    };
+    static create(gateway: PaymentGateway, container: TokenizerContainer, config: {
+        organizationId: string;
+        embedId: string;
+        clientConfig: ConfigHandler;
+    }): Promise<Tokenizer>;
+}

package/dist/esm/tokenize/Tokenizer.js

@@ -0,0 +1,146 @@
+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());
+    });
+};
+import { formatExpiryInput, parseExpiryDate, addFocusHandlers, getConnectedBorderRadius, } from './tokenizer-utils';
+export class Tokenizer {
+    constructor() {
+        this.mode = 'credit_card';
+        this.eventHandlers = new Map();
+    }
+    getMode() {
+        return this.mode;
+    }
+    on(event, handler) {
+        if (!this.eventHandlers.has(event)) {
+            this.eventHandlers.set(event, new Set());
+        }
+        this.eventHandlers.get(event).add(handler);
+    }
+    off(event, handler) {
+        const handlers = this.eventHandlers.get(event);
+        if (handlers) {
+            handlers.delete(handler);
+        }
+    }
+    emit(event, data) {
+        const handlers = this.eventHandlers.get(event);
+        if (handlers) {
+            handlers.forEach((handler) => {
+                try {
+                    handler(data);
+                }
+                catch (error) {
+                }
+            });
+        }
+    }
+    isCardData(data) {
+        return this.mode === 'credit_card';
+    }
+    isBankAccountData(data) {
+        return this.mode === 'bank_account';
+    }
+    normalizeCardType(providerCardType) {
+        const normalized = providerCardType.toLowerCase().replace(/[\s-_]/g, '');
+        const mappings = {
+            visa: 'visa',
+            mastercard: 'mastercard',
+            master: 'mastercard',
+            americanexpress: 'amex',
+            amex: 'amex',
+            discover: 'discover',
+            dinersclub: 'diners',
+            diners: 'diners',
+            jcb: 'jcb',
+        };
+        return mappings[normalized] || 'unknown';
+    }
+    addExpiryFormatter(expiryEl) {
+        if (!expiryEl)
+            return;
+        expiryEl.addEventListener('input', (e) => {
+            const target = e.target;
+            target.value = formatExpiryInput(target.value);
+            this.emit('change', { field: 'expiry' });
+        });
+        expiryEl.addEventListener('keypress', (e) => {
+            const char = String.fromCharCode(e.which);
+            if (!/[0-9\/]/.test(char) && e.which !== 8) {
+                e.preventDefault();
+            }
+        });
+    }
+    parseExpiry(expiryEl) {
+        if (!(expiryEl === null || expiryEl === void 0 ? void 0 : expiryEl.value))
+            return null;
+        return parseExpiryDate(expiryEl.value);
+    }
+    applyInputStyles(element, styles, position) {
+        const inputStyles = styles.input;
+        const isConnected = styles.container.gap === '0';
+        Object.assign(element.style, {
+            height: inputStyles.height,
+            padding: inputStyles.padding,
+            fontSize: inputStyles.fontSize,
+            fontFamily: inputStyles.fontFamily,
+            backgroundColor: inputStyles.backgroundColor,
+            color: inputStyles.color,
+            boxSizing: 'border-box',
+            width: '100%',
+            transition: inputStyles.transition,
+        });
+        if (isConnected && position) {
+            element.style.borderTop = inputStyles.border;
+            element.style.borderBottom = inputStyles.border;
+            switch (position) {
+                case 'left':
+                    element.style.borderLeft = inputStyles.border;
+                    element.style.borderRight = 'none';
+                    break;
+                case 'middle':
+                    element.style.borderLeft = inputStyles.border;
+                    element.style.borderRight = 'none';
+                    break;
+                case 'right':
+                    element.style.borderLeft = inputStyles.border;
+                    element.style.borderRight = inputStyles.border;
+                    break;
+            }
+            element.style.borderRadius = getConnectedBorderRadius(inputStyles.borderRadius, position, true);
+        }
+        else {
+            element.style.border = inputStyles.border;
+            element.style.borderRadius = inputStyles.borderRadius;
+        }
+        addFocusHandlers(element, styles);
+    }
+    generateFieldIds(containerId) {
+        return {
+            numberId: `${containerId}-card-number`,
+            expiryId: `${containerId}-expiry`,
+            cvvId: `${containerId}-cvv`,
+        };
+    }
+    static create(gateway, container, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (gateway.backend_name) {
+                case 'spreedly': {
+                    const { SpreedlyTokenizer } = yield import('./SpreedlyTokenizer');
+                    return SpreedlyTokenizer.create(gateway, container, config);
+                }
+                case 'card_connect': {
+                    const { CardConnectTokenizer } = yield import('./CardConnectTokenizer');
+                    return CardConnectTokenizer.create(gateway, container, config);
+                }
+                default:
+                    throw new Error(`Unsupported payment backend: ${gateway.backend_name}`);
+            }
+        });
+    }
+}

package/dist/esm/tokenize/iats.d.ts

@@ -0,0 +1,3 @@
+export declare function tokenizePaymentBankCanada(bankNumber: string, transitNumber: string, accountNumber: string, accountType: string, processId: string, relayUrl: string, gatewayId: string, contact: any, address: any): Promise<string>;
+export declare function tokenizePaymentBankUs(): void;
+export declare function tokenizePaymentCard(): void;

package/dist/esm/tokenize/iats.js

@@ -0,0 +1,48 @@
+import { v4 as uuidv4 } from 'uuid';
+export function tokenizePaymentBankCanada(bankNumber, transitNumber, accountNumber, accountType, processId, relayUrl, gatewayId, contact, address) {
+    const newPaymentId = uuidv4();
+    let streetAddress = address.address1;
+    if (address.address2) {
+        streetAddress += '\n' + address.address2;
+    }
+    const payload = {
+        IATS_DPM_ProcessOption: 'TOKEN',
+        IATS_DPM_RecurringOn: 'FALSE',
+        IATS_DPM_ProcessID: processId,
+        IATS_DPM_RelayURL: relayUrl,
+        IATS_DPM_ClientDefined_PaymentId: newPaymentId,
+        IATS_DPM_ClientDefined_GatewayId: gatewayId,
+        IATS_DPM_Title: contact.salutation,
+        IATS_DPM_FirstName: contact.firstName,
+        IATS_DPM_LastName: contact.lastName,
+        IATS_DPM_Address: streetAddress,
+        IATS_DPM_City: address.city,
+        IATS_DPM_Province: address.state,
+        IATS_DPM_Country: address.country,
+        IATS_DPM_ZipCode: address.zip,
+        IATS_DPM_Phone: contact.primaryPhone,
+        IATS_DPM_EMAIL: contact.email,
+        IATS_DPM_AccountNumber: bankNumber + transitNumber + accountNumber,
+        IATS_DPM_MOP: 'ACHEFT',
+        IATS_DPM_AccountType: accountType,
+    };
+    const formData = new FormData();
+    for (const [key, value] of Object.entries(payload)) {
+        formData.append(key, value);
+    }
+    return fetch('https://www.iatspayments.com/netgate/IATSDPMProcess.aspx', {
+        method: 'POST',
+        mode: 'no-cors',
+        body: formData,
+    }).then((response) => {
+        return response.text().then(() => {
+            return newPaymentId;
+        });
+    });
+}
+export function tokenizePaymentBankUs() {
+    throw new Error('US Bank Tokenization Not Yet Implemented');
+}
+export function tokenizePaymentCard() {
+    throw new Error('Card Tokenization Not Yet Implemented');
+}

package/dist/esm/tokenize/index.d.ts

@@ -0,0 +1,6 @@
+import * as iats from './iats';
+export { Tokenizer } from './Tokenizer';
+export { SpreedlyTokenizer } from './SpreedlyTokenizer';
+export { CardConnectTokenizer } from './CardConnectTokenizer';
+export { PaymentMethodType, PaymentGateway, TokenizerContainer, TokenizerStyling, CardData, PaymentData, PaymentToken, CardType, TokenizerEvent, ValidationState, ValidationResult, ValidationError, TokenizationError, } from './types';
+export { iats };

package/dist/esm/tokenize/index.js

@@ -0,0 +1,6 @@
+import * as iats from './iats';
+export { Tokenizer } from './Tokenizer';
+export { SpreedlyTokenizer } from './SpreedlyTokenizer';
+export { CardConnectTokenizer } from './CardConnectTokenizer';
+export { TokenizationError, } from './types';
+export { iats };

package/dist/esm/tokenize/spreedly-secure.d.ts

@@ -0,0 +1,8 @@
+import ConfigHandler from '../config-handler';
+export interface SpreedlySecurityArgs {
+    nonce: string;
+    timestamp: string;
+    certificate_token: string;
+    signature: string;
+}
+export declare function fetchSpreedlySecurityArgs(config: ConfigHandler, organizationId: string, embedId: string): Promise<SpreedlySecurityArgs>;

package/dist/esm/tokenize/spreedly-secure.js

@@ -0,0 +1,40 @@
+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());
+    });
+};
+export function fetchSpreedlySecurityArgs(config, organizationId, embedId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!config.enableSpreedlySecureTokenization) {
+            throw new Error('Secure tokenization is not enabled');
+        }
+        const makeRequest = () => __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(`${config.embedApiBaseUrl}/spreedly/security-args`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    organization_id: organizationId,
+                    embed_id: embedId,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`Security args request failed: ${response.status}`);
+            }
+            return response.json();
+        });
+        try {
+            return yield makeRequest();
+        }
+        catch (error) {
+            if (error instanceof TypeError && error.message.includes('fetch')) {
+                yield new Promise((resolve) => setTimeout(resolve, 1000));
+                return makeRequest();
+            }
+            throw error;
+        }
+    });
+}

package/dist/esm/tokenize/styles.d.ts

@@ -0,0 +1,4 @@
+import { TokenizerStyling, TokenizerStylingComplete } from './types';
+export declare const DEFAULT_UNIFIED_STYLES: TokenizerStylingComplete;
+export declare function mergeStyles(defaults: TokenizerStylingComplete, userStyles?: TokenizerStyling): TokenizerStylingComplete;
+export declare function getContainerStylesForLayout(baseStyles: TokenizerStylingComplete, layout?: 'single-line' | 'two-line'): TokenizerStylingComplete;

package/dist/esm/tokenize/styles.js

@@ -0,0 +1,46 @@
+export const DEFAULT_UNIFIED_STYLES = {
+    input: {
+        height: '40px',
+        padding: '10px 12px',
+        fontSize: '14px',
+        fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+        color: '#333',
+        backgroundColor: 'white',
+        border: '1px solid #ccc',
+        borderRadius: '4px',
+        boxSizing: 'border-box',
+        width: '100%',
+        transition: 'all 0.15s ease-in-out',
+    },
+    focus: {
+        borderColor: '#007bff',
+        outline: 'none',
+        boxShadow: '0 0 0 2px rgba(0, 123, 255, 0.25)',
+    },
+    error: {
+        borderColor: '#dc3545',
+    },
+    container: {
+        display: 'flex',
+        gap: '1rem',
+        alignItems: 'center',
+        flexWrap: 'nowrap',
+        rowGap: '1rem',
+    },
+};
+export function mergeStyles(defaults, userStyles) {
+    if (!userStyles)
+        return defaults;
+    return {
+        input: Object.assign(Object.assign({}, defaults.input), userStyles.input),
+        focus: Object.assign(Object.assign({}, defaults.focus), userStyles.focus),
+        error: Object.assign(Object.assign({}, defaults.error), userStyles.error),
+        container: Object.assign(Object.assign({}, defaults.container), userStyles.container),
+    };
+}
+export function getContainerStylesForLayout(baseStyles, layout = 'single-line') {
+    if (layout === 'two-line') {
+        return Object.assign(Object.assign({}, baseStyles), { container: Object.assign(Object.assign({}, baseStyles.container), { flexWrap: 'wrap', rowGap: baseStyles.container.rowGap || baseStyles.container.gap }) });
+    }
+    return baseStyles;
+}

package/dist/esm/tokenize/tokenizer-constants.d.ts

@@ -0,0 +1,62 @@
+export declare const INIT_TIMEOUT = 10000;
+export declare const TOKENIZE_TIMEOUT = 30000;
+export declare const FIELD_FLEX: {
+    readonly cardNumber: {
+        readonly flex: "1 1 60%";
+        readonly minWidth: "150px";
+    };
+    readonly expiry: {
+        readonly flex: "0 1 20%";
+        readonly minWidth: "70px";
+    };
+    readonly cvv: {
+        readonly flex: "0 1 20%";
+        readonly minWidth: "60px";
+    };
+};
+export declare const BANK_FIELD_FLEX: {
+    readonly routingNumber: {
+        readonly flex: "0 1 30%";
+        readonly minWidth: "100px";
+    };
+    readonly accountNumber: {
+        readonly flex: "1 1 45%";
+        readonly minWidth: "120px";
+    };
+    readonly accountType: {
+        readonly flex: "0 1 25%";
+        readonly minWidth: "90px";
+    };
+};
+export declare const CANADIAN_BANK_FIELD_FLEX: {
+    readonly institutionNumber: {
+        readonly flex: "0 1 15%";
+        readonly minWidth: "60px";
+    };
+    readonly transitNumber: {
+        readonly flex: "0 1 20%";
+        readonly minWidth: "80px";
+    };
+    readonly accountNumber: {
+        readonly flex: "1 1 40%";
+        readonly minWidth: "110px";
+    };
+    readonly accountType: {
+        readonly flex: "0 1 25%";
+        readonly minWidth: "90px";
+    };
+};
+export declare const PLACEHOLDERS: {
+    readonly cardNumber: "Card Number *";
+    readonly expiry: "MM/YY *";
+    readonly cvv: "CVV *";
+};
+export declare const FIELD_CONSTRAINTS: {
+    readonly expiry: {
+        readonly maxLength: 5;
+        readonly pattern: RegExp;
+    };
+    readonly cvv: {
+        readonly maxLength: 4;
+    };
+};

package/dist/esm/tokenize/tokenizer-constants.js

@@ -0,0 +1,62 @@
+export const INIT_TIMEOUT = 10000;
+export const TOKENIZE_TIMEOUT = 30000;
+export const FIELD_FLEX = {
+    cardNumber: {
+        flex: '1 1 60%',
+        minWidth: '150px',
+    },
+    expiry: {
+        flex: '0 1 20%',
+        minWidth: '70px',
+    },
+    cvv: {
+        flex: '0 1 20%',
+        minWidth: '60px',
+    },
+};
+export const BANK_FIELD_FLEX = {
+    routingNumber: {
+        flex: '0 1 30%',
+        minWidth: '100px',
+    },
+    accountNumber: {
+        flex: '1 1 45%',
+        minWidth: '120px',
+    },
+    accountType: {
+        flex: '0 1 25%',
+        minWidth: '90px',
+    },
+};
+export const CANADIAN_BANK_FIELD_FLEX = {
+    institutionNumber: {
+        flex: '0 1 15%',
+        minWidth: '60px',
+    },
+    transitNumber: {
+        flex: '0 1 20%',
+        minWidth: '80px',
+    },
+    accountNumber: {
+        flex: '1 1 40%',
+        minWidth: '110px',
+    },
+    accountType: {
+        flex: '0 1 25%',
+        minWidth: '90px',
+    },
+};
+export const PLACEHOLDERS = {
+    cardNumber: 'Card Number *',
+    expiry: 'MM/YY *',
+    cvv: 'CVV *',
+};
+export const FIELD_CONSTRAINTS = {
+    expiry: {
+        maxLength: 5,
+        pattern: /^\d{0,2}\/?\d{0,2}$/,
+    },
+    cvv: {
+        maxLength: 4,
+    },
+};

package/dist/esm/tokenize/tokenizer-utils.d.ts

@@ -0,0 +1,19 @@
+import { TokenizerStylingComplete } from './types';
+export declare function parseExpiryDate(value: string): {
+    month: string;
+    year: string;
+} | null;
+export declare function formatExpiryInput(value: string): string;
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, errorMessage: string): Promise<T>;
+export declare function getConnectedBorderRadius(baseRadius: string, position: 'left' | 'middle' | 'right', isConnected: boolean): string;
+export declare function addFocusHandlers(element: HTMLElement, styles: TokenizerStylingComplete, onFocus?: () => void, onBlur?: () => void): void;
+export declare function createFieldContainer(id: string, flex: string, minWidth?: string, maxWidth?: string): HTMLDivElement;
+export declare function createInputElement(id: string, type: string, placeholder: string, maxLength?: number): HTMLInputElement;
+export declare function validateRoutingNumber(routingNumber: string): boolean;
+export declare function validateAccountNumber(accountNumber: string): boolean;
+export declare function maskAccountNumber(accountNumber: string): string;
+export declare function createAccountTypeSelect(id: string): HTMLSelectElement;
+export declare function validateInstitutionNumber(institutionNumber: string): boolean;
+export declare function validateTransitNumber(transitNumber: string): boolean;
+export declare function validateCanadianAccountNumber(accountNumber: string): boolean;
+export declare function formatCanadianRoutingNumber(institutionNumber: string, transitNumber: string): string;

package/dist/esm/tokenize/tokenizer-utils.js

@@ -0,0 +1,139 @@
+export function parseExpiryDate(value) {
+    const parts = value.split('/');
+    if (parts.length !== 2)
+        return null;
+    const month = parts[0];
+    const year = parts[1];
+    if (month.length !== 2 || year.length !== 2)
+        return null;
+    return {
+        month,
+        year: '20' + year,
+    };
+}
+export function formatExpiryInput(value) {
+    let digits = value.replace(/\D/g, '');
+    digits = digits.substring(0, 4);
+    if (digits.length >= 2) {
+        return digits.substring(0, 2) + '/' + digits.substring(2, 4);
+    }
+    return digits;
+}
+export function withTimeout(promise, timeoutMs, errorMessage) {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(() => reject(new Error(errorMessage)), timeoutMs)),
+    ]);
+}
+export function getConnectedBorderRadius(baseRadius, position, isConnected) {
+    if (!isConnected)
+        return baseRadius;
+    switch (position) {
+        case 'left':
+            return `${baseRadius} 0 0 ${baseRadius}`;
+        case 'middle':
+            return '0';
+        case 'right':
+            return `0 ${baseRadius} ${baseRadius} 0`;
+        default:
+            return baseRadius;
+    }
+}
+export function addFocusHandlers(element, styles, onFocus, onBlur) {
+    element.addEventListener('focus', () => {
+        if (styles.focus) {
+            Object.assign(element.style, styles.focus);
+        }
+        onFocus === null || onFocus === void 0 ? void 0 : onFocus();
+    });
+    element.addEventListener('blur', () => {
+        element.style.borderColor = '';
+        element.style.outline = 'none';
+        element.style.boxShadow = 'none';
+        onBlur === null || onBlur === void 0 ? void 0 : onBlur();
+    });
+}
+export function createFieldContainer(id, flex, minWidth, maxWidth) {
+    const div = document.createElement('div');
+    div.id = id;
+    div.style.flex = flex;
+    div.style.display = 'flex';
+    if (minWidth)
+        div.style.minWidth = minWidth;
+    if (maxWidth)
+        div.style.maxWidth = maxWidth;
+    return div;
+}
+export function createInputElement(id, type, placeholder, maxLength) {
+    const input = document.createElement('input');
+    input.id = id;
+    input.type = type;
+    input.placeholder = placeholder;
+    if (maxLength)
+        input.maxLength = maxLength;
+    return input;
+}
+export function validateRoutingNumber(routingNumber) {
+    const cleaned = routingNumber.replace(/\D/g, '');
+    if (cleaned.length !== 9) {
+        return false;
+    }
+    const digits = cleaned.split('').map(Number);
+    const checksum = (digits[0] * 3 +
+        digits[1] * 7 +
+        digits[2] * 1 +
+        digits[3] * 3 +
+        digits[4] * 7 +
+        digits[5] * 1 +
+        digits[6] * 3 +
+        digits[7] * 7 +
+        digits[8] * 1) %
+        10;
+    return checksum === 0;
+}
+export function validateAccountNumber(accountNumber) {
+    const cleaned = accountNumber.replace(/\D/g, '');
+    if (cleaned.length < 4 || cleaned.length > 17) {
+        return false;
+    }
+    return /^\d+$/.test(cleaned);
+}
+export function maskAccountNumber(accountNumber) {
+    const cleaned = accountNumber.replace(/\D/g, '');
+    if (cleaned.length <= 4) {
+        return cleaned;
+    }
+    const lastFour = cleaned.slice(-4);
+    const masked = '*'.repeat(cleaned.length - 4) + lastFour;
+    return masked;
+}
+export function createAccountTypeSelect(id) {
+    const select = document.createElement('select');
+    select.id = id;
+    const checkingOption = document.createElement('option');
+    checkingOption.value = 'checking';
+    checkingOption.text = 'Checking';
+    const savingsOption = document.createElement('option');
+    savingsOption.value = 'savings';
+    savingsOption.text = 'Savings';
+    select.appendChild(checkingOption);
+    select.appendChild(savingsOption);
+    return select;
+}
+export function validateInstitutionNumber(institutionNumber) {
+    const cleaned = institutionNumber.replace(/\D/g, '');
+    return cleaned.length === 3;
+}
+export function validateTransitNumber(transitNumber) {
+    const cleaned = transitNumber.replace(/\D/g, '');
+    return cleaned.length === 5;
+}
+export function validateCanadianAccountNumber(accountNumber) {
+    const cleaned = accountNumber.replace(/\D/g, '');
+    return cleaned.length >= 7;
+}
+export function formatCanadianRoutingNumber(institutionNumber, transitNumber) {
+    const institution = institutionNumber.replace(/\D/g, '').padStart(3, '0');
+    const transit = transitNumber.replace(/\D/g, '').padStart(5, '0');
+    return '0' + institution + transit;
+}