@koloseum/utils 0.2.28 → 0.3.0

package/dist/utils.js

@@ -1,2019 +0,0 @@
-import { v4 as uuidv4 } from "uuid";
-import { error as svelteError } from "@sveltejs/kit";
-import { FunctionsFetchError, FunctionsHttpError, FunctionsRelayError } from "@supabase/supabase-js";
-import Bowser from "bowser";
-import validator from "validator";
-/* HELPERS */
-const parsePgInterval = (await import("postgres-interval")).default;
-const sanitize = (await import("sanitize-html")).default;
-const { trim, escape, isMobilePhone, isURL } = validator;
-const { KenyaAdministrativeDivisions } = (await import("kenya-administrative-divisions")).default;
-/* DUMMY DATA */
-export const Data = {
-    /**
-     * A generic authenticated user.
-     * @param {string} id - The user ID; defaults to a random UUID
-     * @param {Date} date - The date and time; defaults to the current date and time
-     * @param {string} phone - The phone number; defaults to a generic Kenyan phone number
-     * @param {string} identityId - A default identity ID; defaults to a random UUID
-     * @returns A generic authenticated user.
-     */
-    authenticatedUser: (id = uuidv4(), date = new Date(), phone = "254111222333", identityId = uuidv4()) => {
-        // Convert date to ISO string
-        const time = date.toISOString();
-        // User data
-        return {
-            id,
-            aud: "authenticated",
-            role: "authenticated",
-            email: "",
-            phone,
-            phone_confirmed_at: time,
-            confirmation_sent_at: time,
-            confirmed_at: time,
-            last_sign_in_at: time,
-            app_metadata: {
-                person_data: { player_id: "KP1234567", first_name: "John", last_name: "Test", pseudonym: "JDtest" },
-                provider: "phone",
-                providers: ["phone"],
-                roles: ["player", "backroom_superuser"]
-            },
-            user_metadata: {
-                email_verified: false,
-                phone_verified: false,
-                sub: id,
-                backroom: {
-                    welcome_notification_sent: true
-                },
-                players: {
-                    welcome_notification_sent: true
-                }
-            },
-            identities: [
-                {
-                    identity_id: identityId,
-                    id,
-                    user_id: id,
-                    identity_data: {
-                        email_verified: false,
-                        phone_verified: false,
-                        sub: id
-                    },
-                    provider: "phone",
-                    last_sign_in_at: time,
-                    created_at: time,
-                    updated_at: time
-                }
-            ],
-            created_at: time,
-            updated_at: time,
-            is_anonymous: false
-        };
-    }
-};
-/* STATUS MESSAGES */
-export const Status = {
-    /**
-     * A generic error message.
-     */
-    ERROR: "An unexpected error occurred. Kindly try again.",
-    /**
-     * A generic loading message.
-     */
-    LOADING: "Please wait…",
-    /**
-     * A generic password reset request message.
-     */
-    PASSWORD_RESET_REQUESTED: "If the provided email address is registered, you will receive a password reset link shortly."
-};
-/* UTILITY FUNCTIONS */
-export const Utility = {
-    /**
-     * Calls a Supabase Edge function.
-     * @param {boolean} browser - Whether the function is being called in the browser
-     * @param {SupabaseClient<Database>} supabase - The Supabase client
-     * @param {string} path - The path to the Edge function
-     * @param {FunctionInvokeOptions} [options] - The options to use for the function invocation; defaults to `{ method: "GET" }`
-     * @returns The response from the Edge function
-     */
-    callEdgeFunction: async (browser, supabase, path, options = { method: "GET" }) => {
-        try {
-            // Only add Origin header in browser environment
-            if (browser)
-                options.headers = { ...options.headers, Origin: window.location.origin };
-            // Fetch response with additional options for better cross-origin handling
-            const { data, error } = await supabase.functions.invoke(path, options);
-            // Handle different error types
-            if (error) {
-                // Define context
-                const context = {};
-                // Define error code and message
-                const code = Number(error.context?.status) || 500;
-                let message = error.context?.statusText || Status.ERROR;
-                // Handle HTTP errors
-                if (error instanceof FunctionsHttpError) {
-                    try {
-                        // Get content type header safely
-                        const contentType = error.context?.headers?.get("content-type") || "";
-                        // If content type is JSON, get error data
-                        if (contentType.includes("application/json")) {
-                            try {
-                                const errorData = await error.context.json();
-                                message = errorData.message || message;
-                                // Assign attempt ID to context if present
-                                if (path.includes("verify-id") && errorData.attemptId)
-                                    context.attemptId = errorData.attemptId;
-                            }
-                            catch (jsonError) {
-                                console.error("Failed to parse JSON error response:", jsonError);
-                            }
-                        }
-                        // If content type is plain text, get error message
-                        else if (contentType.includes("text/plain")) {
-                            try {
-                                message = await error.context.text();
-                            }
-                            catch (textError) {
-                                console.error("Failed to parse text error response:", textError);
-                            }
-                        }
-                    }
-                    catch (parseError) {
-                        console.error("Failed to parse error response:", parseError);
-                    }
-                }
-                // Handle relay and fetch errors
-                else if (error instanceof FunctionsRelayError || error instanceof FunctionsFetchError)
-                    message = error.message;
-                // Return error
-                return { code: code, error: message, context };
-            }
-            // Return response
-            return { code: 200, data };
-        }
-        catch (unexpectedError) {
-            console.error("Unexpected error:", unexpectedError);
-            return { code: 500, error: Status.ERROR };
-        }
-    },
-    /**
-     * Capitalises a given word.
-     * @param {string} word - The word to be capitalised
-     * @returns The capitalised word
-     */
-    capitalise: (word) => word.charAt(0).toUpperCase() +
-        word
-            .slice(1)
-            .split("")
-            .map((c) => c.toLowerCase())
-            .join(""),
-    /**
-     * Cleans a URL by removing the protocol and trailing slashes.
-     * @param {string} url - The URL to clean
-     * @returns {string} The cleaned URL
-     */
-    cleanUrl: (url) => url.replace(/^https?:\/\//, "").replace(/\/+$/, ""),
-    /**
-     * Returns a custom error object.
-     * @param {number} code - The error code; defaults to `500` if not provided or invalid
-     * @param {string} message - The error message
-     * @returns An object with the error `code` and `message`
-     */
-    customError: (code, message) => !code || code < 400 || code > 599 ? { code: 500, message: Status.ERROR } : { code, message },
-    /**
-     * A regular expression for E.164 phone numbers.
-     *
-     * - Source: https://www.twilio.com/docs/glossary/what-e164
-     */
-    e164Regex: /^\+?[1-9]\d{1,14}$/,
-    /**
-     * Formats a date in the format DD/MM/YYYY (by default) or YYYY-MM-DD (for client).
-     * @param {string} date - Date to be formatted
-     * @param {boolean} forClient - Specify whether the data is for displaying on the client; defaults to `false`
-     * @returns The formatted date string, or `null` if invalid input or in case of an error
-     */
-    formatDate: (date, forClient = false) => {
-        // Return null if no date is provided
-        if (date === "" || typeof date !== "string")
-            return null;
-        // Handle input
-        try {
-            // Parse date string
-            const parsedDate = Date.parse(date);
-            // Return null if date string is not parseable
-            if (isNaN(parsedDate))
-                return null;
-            // Use the Intl.DateTimeFormat with explicit options to ensure correct formatting
-            const formattedDate = new Intl.DateTimeFormat(forClient ? "fr-CA" : "en-KE", {
-                day: "2-digit",
-                month: "2-digit",
-                year: "numeric",
-                timeZone: "Africa/Nairobi"
-            }).format(parsedDate);
-            // Return formatted date string
-            return formattedDate;
-        }
-        catch (error) {
-            console.error(error);
-            return null;
-        }
-    },
-    /**
-     * Formats a social media platform for display.
-     * @param {SocialMediaPlatform} platform - The social media platform to be formatted
-     * @returns The formatted social media platform string
-     */
-    formatSocialMediaPlatform: (platform) => {
-        const platforms = ["facebook", "instagram", "kick", "tiktok", "twitch", "twitter", "youtube"];
-        if (!platforms.includes(platform))
-            return "";
-        if (platform === "tiktok")
-            return "TikTok";
-        if (platform === "twitter")
-            return "X (formerly Twitter)";
-        if (platform === "youtube")
-            return "YouTube";
-        return Utility.capitalise(platform);
-    },
-    /**
-     * Returns an age in years given a birth date.
-     * @param {Date | string | number | null} dateOfBirth - The date of birth
-     * @returns The age in years, or `NaN` if the input is invalid
-     */
-    getAge: (dateOfBirth) => {
-        // Return NaN if no date is provided
-        if (!dateOfBirth)
-            return NaN;
-        // Validate and process date of birth
-        let birthDate;
-        if (dateOfBirth instanceof Date) {
-            if (isNaN(dateOfBirth.getTime()))
-                return NaN;
-            birthDate = dateOfBirth;
-        }
-        else if (typeof dateOfBirth === "string") {
-            if (dateOfBirth === "" || isNaN(Date.parse(dateOfBirth)))
-                return NaN;
-            // Format date of birth if it's a string
-            const formattedDate = Utility.formatDate(dateOfBirth, true);
-            if (!formattedDate)
-                return NaN;
-            birthDate = new Date(formattedDate);
-        }
-        else if (typeof dateOfBirth === "number") {
-            if (isNaN(dateOfBirth))
-                return NaN;
-            birthDate = new Date(dateOfBirth);
-        }
-        else {
-            return NaN;
-        }
-        // Validate the final date object
-        if (isNaN(birthDate.getTime()))
-            return NaN;
-        // Calculate age
-        const currentDate = new Date();
-        const monthDiff = currentDate.getMonth() - birthDate.getMonth();
-        let age = currentDate.getFullYear() - birthDate.getFullYear();
-        // Return age
-        return monthDiff < 0 || (monthDiff === 0 && currentDate.getDate() < birthDate.getDate()) ? --age : age;
-    },
-    /**
-     * Formats a date as a locale-specific string.
-     * @param {Date | string | number | null} date - Date to be formatted
-     * @param {boolean} withTime - Specify whether the date should include time; defaults to `false`
-     * @param {string} timeZone - The time zone to use for formatting; defaults to `Africa/Nairobi`
-     * @returns The formatted date string, or an empty string if invalid input
-     */
-    getDateString: (date, withTime = false, timeZone = "Africa/Nairobi") => {
-        // Return empty string if no date is provided
-        if (!date)
-            return "";
-        // Validate date to format
-        let dateToFormat;
-        if (date instanceof Date) {
-            if (isNaN(date.getTime()))
-                return "";
-            dateToFormat = date;
-        }
-        else if (typeof date === "string" || typeof date === "number") {
-            if (typeof date === "string" && (date === "" || isNaN(Date.parse(date))))
-                return "";
-            if (typeof date === "number" && isNaN(date))
-                return "";
-            dateToFormat = new Date(date);
-        }
-        else
-            return "";
-        // Validate the final date object
-        if (isNaN(dateToFormat.getTime()))
-            return "";
-        // Format date
-        return dateToFormat.toLocaleString("en-KE", {
-            timeZone,
-            year: "numeric",
-            month: "long",
-            day: "numeric",
-            hour: withTime ? "numeric" : undefined,
-            minute: withTime ? "2-digit" : undefined,
-            hour12: withTime ? true : undefined
-        });
-    },
-    /**
-     * Formats an identity type for display.
-     * @param {IdentityType} identityType - The identity type to be formatted
-     * @returns The formatted identity type string
-     */
-    getIdentityTypeString: (identityType) => {
-        if (identityType === "national")
-            return "National ID";
-        if (identityType === "alien")
-            return "Alien ID";
-        if (identityType === "passport")
-            return "Passport";
-        if (identityType === "driver_licence")
-            return "Driver's licence";
-        return "";
-    },
-    /**
-     * Returns a list of all counties in Kenya.
-     * @param {"name" | "code"} sortBy - The field to sort the counties by, i.e. `name` or `code`; defaults to `name`
-     * @returns {Promise<County[]>} A list of objects with the county `name`, `code`, and a list of `subCounties`
-     */
-    getKenyaCounties: async (sortBy = "name") => {
-        // Create Kenya administrative divisions instance
-        const kenyaAdmin = new KenyaAdministrativeDivisions();
-        // Get all counties
-        const countiesData = await kenyaAdmin.getAll();
-        // Format counties
-        const counties = countiesData.map((county) => {
-            // Get list of sub-counties
-            const subCounties = [];
-            for (const subCounty of county.constituencies)
-                subCounties.push(subCounty.constituency_name);
-            subCounties.sort();
-            // Format county name and add to list
-            const countyName = county.county_name.split(" ");
-            let name = county.county_name;
-            if (countyName.length > 1)
-                name = countyName.map((word) => Utility.capitalise(word)).join(" ");
-            // Return county
-            return { name, code: county.county_code, subCounties };
-        });
-        // Return sorted counties
-        return counties.sort((a, b) => (sortBy === "name" ? a.name.localeCompare(b.name) : a.code - b.code));
-    },
-    /**
-     * Formats a date to an ISO string in Kenyan time, i.e. `Africa/Nairobi` (UTC+3).
-     * @param {Date | string | number | null} date - The date to format
-     * @returns {string} The formatted date in ISO string format, or an empty string if invalid input
-     */
-    getKenyanISOString: (date) => {
-        // Return empty string if no date is provided or input is invalid
-        if (!date || (typeof date !== "string" && typeof date !== "number" && !(date instanceof Date)))
-            return "";
-        // Get locale string to format
-        const dateObj = date instanceof Date ? date : new Date(date);
-        const localeString = dateObj.toLocaleString("sv-SE", {
-            timeZone: "Africa/Nairobi"
-        });
-        // Return formatted string
-        return localeString.replace(" ", "T") + "+03:00";
-    },
-    /**
-     * Returns the URL for a menu item based on the slug.
-     * @param {string} base - The base URL
-     * @param {string} slug - The slug of the menu item
-     * @returns {string} The URL for the menu item
-     */
-    getMenuItemUrl: (base, slug) => {
-        // Validate base URL
-        if (typeof base !== "string")
-            return "";
-        // Format base URL
-        if (base === "/")
-            base = "";
-        if (base.charAt(base.length - 1) === "/")
-            base = base.slice(0, -1);
-        // Return URL
-        return `${base}${slug === "/" ? slug : typeof slug === "string" ? `/${slug}` : ""}`;
-    },
-    /**
-     * Returns the parent URL for a given base URL.
-     * @param {string} base - The base URL
-     * @returns {string} The parent URL
-     */
-    getParentUrl: (base) => {
-        // Validate input
-        if (typeof base !== "string")
-            return "";
-        // Return parent URL
-        return base.replace(/\/$/, "").split("/").slice(0, -1).join("/") || "/";
-    },
-    /**
-     * Returns a pronoun given pronouns and a type.
-     * @param {PronounsItem | null} pronouns - The pronouns to be formatted
-     * @param {"subject" | "object" | "possessive" | "reflexive"} type - The type of pronoun to be returned
-     * @param {Sex} sex - The user's sex; defaults to `undefined`
-     * @returns The formatted pronoun, or `null` if the input is invalid
-     */
-    getPronoun: (pronouns, type, sex) => {
-        // Get pronoun from pronouns item
-        if (pronouns) {
-            // Return subject pronoun
-            if (type === "subject") {
-                if (pronouns === "he/him/his/himself")
-                    return "he";
-                if (pronouns === "she/her/hers/herself")
-                    return "she";
-                if (pronouns === "they/them/their/themself")
-                    return "they";
-                if (pronouns === "name_only")
-                    return "";
-            }
-            // Return object pronoun
-            else if (type === "object") {
-                if (pronouns === "he/him/his/himself")
-                    return "him";
-                if (pronouns === "she/her/hers/herself")
-                    return "her";
-                if (pronouns === "they/them/their/themself")
-                    return "them";
-                if (pronouns === "name_only")
-                    return "";
-            }
-            // Return possessive pronoun
-            else if (type === "possessive") {
-                if (pronouns === "he/him/his/himself")
-                    return "his";
-                if (pronouns === "she/her/hers/herself")
-                    return "her";
-                if (pronouns === "they/them/their/themself")
-                    return "their";
-                if (pronouns === "name_only")
-                    return "";
-            }
-            // Return reflexive pronoun
-            else if (type === "reflexive") {
-                if (pronouns === "he/him/his/himself")
-                    return "himself";
-                if (pronouns === "she/her/hers/herself")
-                    return "herself";
-                if (pronouns === "they/them/their/themself")
-                    return "themself";
-                if (pronouns === "name_only")
-                    return "";
-            }
-        }
-        // Assume pronoun for sex if no pronouns are provided
-        else if (sex) {
-            // Return subject pronoun
-            if (type === "subject") {
-                if (sex === "male" || sex === "intersex_man")
-                    return "he";
-                if (sex === "female" || sex === "intersex_woman")
-                    return "she";
-                return "they";
-            }
-            // Return object pronoun
-            else if (type === "object") {
-                if (sex === "male" || sex === "intersex_man")
-                    return "him";
-                if (sex === "female" || sex === "intersex_woman")
-                    return "her";
-                return "them";
-            }
-            // Return possessive pronoun
-            else if (type === "possessive") {
-                if (sex === "male" || sex === "intersex_man")
-                    return "his";
-                if (sex === "female" || sex === "intersex_woman")
-                    return "her";
-                return "their";
-            }
-            // Return reflexive pronoun
-            else if (type === "reflexive") {
-                if (sex === "male" || sex === "intersex_man")
-                    return "himself";
-                if (sex === "female" || sex === "intersex_woman")
-                    return "herself";
-                return "themself";
-            }
-        }
-        // Return null
-        return null;
-    },
-    /**
-     * Returns the redirect URL for a given URI.
-     * @param {string} uri - The URI to get the redirect URL for, i.e. `microserviceGroup:path` (e.g. `players:fgc/tournaments`)
-     * @param {"development" | "production"} env - The environment to use for the redirect URL; defaults to `production`
-     * @returns {string} An object with the redirect `url`, or an `error` if any occurs
-     */
-    getRedirectUrl: (uri, env = "production") => {
-        // Get microservice groups
-        const microserviceGroups = ["public", "players", "lounges", "backroom"];
-        // Extract microservice group and path from URI
-        let [microserviceGroup, path] = uri.split(":");
-        if (!microserviceGroup || !path)
-            return { error: Utility.customError(400, "URI is invalid.") };
-        if (!microserviceGroups.includes(microserviceGroup))
-            return { error: Utility.customError(400, "Microservice group is invalid.") };
-        // Initialise port number for local development
-        let port;
-        // Return redirect URL for Public microservices
-        if (microserviceGroup === "public") {
-            // Initialise subdomain for production
-            let subdomain = "";
-            // Handle Authentication microservice
-            if (path.startsWith("auth")) {
-                subdomain = "auth.";
-                port = 5173;
-                path = path.replace("auth", "");
-            }
-            // Handle Legal microservice
-            else if (path.startsWith("legal")) {
-                subdomain = "legal.";
-                port = 5174;
-                path = path.replace("legal", "");
-            }
-            // Handle Landing microservice
-            else if (path.startsWith("landing")) {
-                port = 5184;
-                path = path.replace("landing", "");
-            }
-            // Return redirect URL
-            return {
-                url: env === "production"
-                    ? `https://${subdomain}koloseum.ke${path || ""}`
-                    : `http://127.0.0.1:${port}${path || ""}`
-            };
-        }
-        // Handle Players microservices
-        if (microserviceGroup === "players") {
-            if (path.startsWith("account")) {
-                port = 5175;
-                if (env === "development")
-                    path = path.replace("account", "");
-            }
-            if (path.startsWith("fgc")) {
-                port = 5178;
-                if (env === "development")
-                    path = path.replace("fgc", "");
-            }
-            if (path.startsWith("commerce")) {
-                port = 5179;
-                if (env === "development")
-                    path = path.replace("commerce", "");
-            }
-        }
-        // Handle Lounges microservices
-        if (microserviceGroup === "lounges") {
-            if (path.startsWith("branches")) {
-                port = 5181;
-                if (env === "development")
-                    path = path.replace("branches", "");
-            }
-            if (path.startsWith("staff")) {
-                port = 5182;
-                if (env === "development")
-                    path = path.replace("staff", "");
-            }
-        }
-        // Handle Backroom microservices
-        if (microserviceGroup === "backroom") {
-            if (path.startsWith("compliance")) {
-                port = 5176;
-                if (env === "development")
-                    path = path.replace("compliance", "");
-            }
-            if (path.startsWith("competitions")) {
-                port = 5177;
-                if (env === "development")
-                    path = path.replace("competitions", "");
-            }
-            if (path.startsWith("commerce")) {
-                port = 5180;
-                if (env === "development")
-                    path = path.replace("commerce", "");
-            }
-            if (path.startsWith("staff")) {
-                port = 5183;
-                if (env === "development")
-                    path = path.replace("staff", "");
-            }
-        }
-        // Return redirect URL
-        return {
-            url: env === "production"
-                ? `https://${microserviceGroup}.koloseum.ke/${path || ""}`
-                : `http://127.0.0.1:${port}${path || ""}`
-        };
-    },
-    /**
-     * Generate a SuprSend notification inbox configuration object for a user.
-     * @param {string} userId - The user ID to generate the configuration for.
-     * @param {string} publicApiKey - The public API key to use for SuprSend.
-     * @returns The SuprSend notification inbox configuration object.
-     */
-    getSuprSendInboxConfig: (userId, publicApiKey) => ({
-        distinctId: userId,
-        publicApiKey,
-        inbox: {
-            stores: [
-                { storeId: "all", label: "Inbox", query: { archived: false } },
-                { storeId: "archived", label: "Archived", query: { archived: true } }
-            ],
-            theme: {
-                bell: {
-                    color: "var(--color-accent)"
-                },
-                badge: {
-                    backgroundColor: "var(--color-primary)",
-                    color: "var(--color-primary-content)"
-                },
-                header: {
-                    container: {
-                        backgroundColor: "var(--color-base-100)",
-                        borderColor: "var(--color-base-200)"
-                    },
-                    headerText: {
-                        color: "var(--color-neutral)"
-                    },
-                    markAllReadText: {
-                        color: "var(--color-accent)"
-                    }
-                },
-                tabs: {
-                    color: "var(--color-primary)",
-                    unselectedColor: "var(--color-accent)",
-                    bottomColor: "var(--color-primary)",
-                    badgeColor: "var(--color-base-200)",
-                    badgeText: "var(--color-accent)"
-                },
-                notificationsContainer: {
-                    container: {
-                        backgroundColor: "var(--color-base-100)",
-                        borderColor: "var(--color-base-200)",
-                        height: "75vh",
-                        marginTop: "0.75rem"
-                    },
-                    noNotificationsText: {
-                        color: "var(--color-warning)"
-                    },
-                    noNotificationsSubtext: {
-                        color: "var(--color-neutral)"
-                    },
-                    loader: {
-                        color: "var(--color-primary)"
-                    }
-                },
-                notification: {
-                    container: {
-                        borderColor: "var(--color-base-200)",
-                        readBackgroundColor: "var(--color-base-100)",
-                        unreadBackgroundColor: "var(--color-base-150)",
-                        hoverBackgroundColor: "var(--color-base-200)"
-                    },
-                    headerText: {
-                        color: "var(--color-secondary)"
-                    },
-                    bodyText: {
-                        color: "var(--color-neutral)",
-                        linkColor: "var(--color-secondary)"
-                    },
-                    unseenDot: {
-                        backgroundColor: "var(--color-warning)"
-                    },
-                    createdOnText: {
-                        color: "var(--color-accent)"
-                    },
-                    subtext: {
-                        color: "var(--color-neutral)"
-                    },
-                    expiresText: {
-                        color: "var(--color-warning)",
-                        expiringBackgroundColor: "var(--color-warning)",
-                        expiringColor: "var(--color-neutral)"
-                    },
-                    actions: [
-                        {
-                            text: {
-                                color: "var(--color-primary-content)"
-                            },
-                            container: {
-                                backgroundColor: "var(--color-primary)",
-                                hoverBackgroundColor: "var(--color-secondary)",
-                                border: "unset"
-                            }
-                        },
-                        {
-                            text: {
-                                color: "var(--color-primary-content)"
-                            },
-                            container: {
-                                backgroundColor: "var(--color-primary)",
-                                hoverBackgroundColor: "var(--color-secondary)",
-                                border: "unset"
-                            }
-                        }
-                    ],
-                    actionsMenuIcon: {
-                        hoverBackgroundColor: "var(--color-base-200)",
-                        color: "var(--color-neutral)"
-                    },
-                    actionsMenu: {
-                        backgroundColor: "var(--color-base-100)",
-                        borderColor: "var(--color-base-200)"
-                    },
-                    actionsMenuItem: {
-                        hoverBackgroundColor: "var(--color-base-200)"
-                    },
-                    actionsMenuItemIcon: {
-                        color: "var(--color-accent)"
-                    },
-                    actionsMenuItemText: {
-                        color: "var(--color-neutral)"
-                    }
-                }
-            }
-        },
-        toast: {
-            theme: {
-                container: {
-                    backgroundColor: "var(--color-base-100)",
-                    borderColor: "var(--color-base-200)"
-                },
-                headerText: {
-                    color: "var(--color-primary)"
-                },
-                bodyText: {
-                    color: "var(--color-neutral)"
-                }
-            }
-        }
-    }),
-    /**
-     * Handles the click event for pronouns checkboxes.
-     * @param {MouseEvent} e - The click event
-     * @param {PronounsCheckboxes} checkboxes - The pronouns checkboxes
-     */
-    handlePronounsCheckboxClick: (e, checkboxes) => {
-        const target = e.target;
-        if (target.value === "none") {
-            for (let checkbox of Object.values(checkboxes))
-                if (checkbox && checkbox !== target && checkbox.checked) {
-                    e.preventDefault();
-                    return;
-                }
-            for (let checkbox of Object.values(checkboxes))
-                if (checkbox && checkbox !== target) {
-                    checkbox.checked = false;
-                    checkbox.disabled = !checkbox.disabled;
-                }
-        }
-        else {
-            if (checkboxes.none?.checked) {
-                e.preventDefault();
-                return;
-            }
-            if (target.value === "male" || target.value === "female") {
-                const oppositeIndex = target.value === "male" ? "female" : "male";
-                const oppositeCheckbox = checkboxes[oppositeIndex];
-                if (oppositeCheckbox?.checked) {
-                    e.preventDefault();
-                    return;
-                }
-                if (oppositeCheckbox) {
-                    oppositeCheckbox.checked = false;
-                    oppositeCheckbox.disabled = !oppositeCheckbox.disabled;
-                }
-                if (checkboxes.none) {
-                    checkboxes.none.checked = false;
-                    if (!checkboxes.neutral?.checked)
-                        checkboxes.none.disabled = !checkboxes.none.disabled;
-                }
-            }
-            else {
-                if (checkboxes.none) {
-                    checkboxes.none.checked = false;
-                    if (checkboxes.neutral && !checkboxes.male?.checked && !checkboxes.female?.checked)
-                        checkboxes.none.disabled = checkboxes.neutral.checked;
-                }
-            }
-        }
-    },
-    /**
-     * Checks if a user is authorised to access a microservice.
-     * @param {SupabaseClient<Database>} supabase - The Supabase client.
-     * @param {UserWithCustomMetadata} user - The user to check.
-     * @param {Object} options - The options for the function.
-     * @param {MicroserviceGroup} options.microserviceGroup - The microservice group.
-     * @param {Microservice<MicroserviceGroup> | string} options.microservice - The microservice.
-     * @param {string} options.playersUrl - The URL to the Players microservice.
-     * @param {(role: string) => string} options.requestedPermission - A function that returns the requested permission for a given role.
-     * @returns {Promise<{ isAuthorised?: boolean; redirect?: { code: number; url: string }; error?: CustomError }>} The result of the function.
-     */
-    isUserAuthorised: async (supabase, user, options) => {
-        // Destructure options
-        const { microserviceGroup, microservice, playersUrl } = options;
-        // Return true if microservice group is public
-        if (microserviceGroup === "public")
-            return { isAuthorised: true };
-        // Validate user metadata and app metadata
-        if (!user.user_metadata || !user.app_metadata)
-            return { error: Utility.customError(400, "User metadata is required.") };
-        // Get user's roles and the role prefix
-        const roles = [];
-        const rolePrefix = microserviceGroup === "backroom" ? "backroom" : microserviceGroup.slice(0, -1);
-        for (const role of user.app_metadata.roles) {
-            if (role === "player") {
-                if (microserviceGroup === "players")
-                    roles.push(role);
-                else
-                    continue;
-            }
-            if (role.startsWith(`${rolePrefix}_`))
-                roles.push(role.replace(`${rolePrefix}_`, ""));
-        }
-        // Redirect to Players microservices if user does not have any roles for the microservice group
-        if (roles.length === 0 && microserviceGroup !== "players") {
-            // Return error if Players URL is not provided
-            if (!playersUrl)
-                return { error: Utility.customError(400, "Players URL is required.") };
-            // Redirect to Players microservices
-            return { redirect: { code: 307, url: playersUrl } };
-        }
-        // Destructure role
-        const [role] = roles;
-        // Define condition variables
-        const isPlayer = microserviceGroup === "players" && role === "player";
-        const isSuperuser = (microserviceGroup === "backroom" || microserviceGroup === "lounges") && role === "superuser";
-        let isAuthorised = false;
-        // Grant access if Player (accessing Players microservices), superuser, or account microservice
-        if (isPlayer || isSuperuser || microservice === "account")
-            isAuthorised = true;
-        // Evaluate access
-        else if (microserviceGroup !== "players") {
-            // Return error if requested permission is not provided
-            if (!options.requestedPermission)
-                return { error: Utility.customError(400, "Requested permission is required.") };
-            // Get user's role and requested app permission
-            const requestedPermission = options.requestedPermission(role);
-            // Check if user has the requested permission
-            const { data, error: isAuthorisedError } = await supabase
-                .schema("compliance")
-                .rpc("authorise", { requested_permission: requestedPermission });
-            if (isAuthorisedError)
-                return Utility.parsePostgrestError(isAuthorisedError);
-            // Assign result of authorisation check
-            isAuthorised = data;
-        }
-        // If user has completed Player registration
-        if (roles.includes("player")) {
-            // Prepare person data
-            let personData = {};
-            if (user.app_metadata.person_data) {
-                const { first_name: firstName, last_name: lastName, pseudonym } = user.app_metadata.person_data;
-                personData = { firstName, lastName, phone: user.phone, pseudonym };
-            }
-            // Validate SuprSend subscriber
-            const { code, error: validationError } = await Utility.callEdgeFunction(false, supabase, `suprsend/validate-subscriber?user-id=${user.id}`, { method: "POST", headers: { "Content-Type": "application/json" }, body: personData });
-            if (validationError)
-                return { error: Utility.customError(code, validationError) };
-            // Send welcome notification if not already sent
-            const { error: welcomeError } = await Utility.sendWelcomeNotification(supabase, user, microserviceGroup);
-            if (welcomeError)
-                return { error: welcomeError };
-        }
-        // Return result
-        return { isAuthorised };
-    },
-    /**
-     * A reference of microservices available on the platform, represented as an object with each user group (i.e. `public`, `players`, `lounges`, and `backroom`) having its own array of microservices. Each microservice in a list is an object with the following properties:
-     * - `name`: The name of the microservice.
-     * - `description`: A description of the microservice.
-     * - `slug`: The slug of the microservice.
-     * - `features`: An array of features that the microservice has.
-     * - `roles`: An array of roles attached to the microservice.
-     */
-    microservices: {
-        backroom: [
-            {
-                name: "Compliance",
-                description: "Management of compliance and regulatory adherence for Players and Lounges.",
-                slug: "compliance",
-                features: [
-                    {
-                        name: "Players",
-                        description: "Search, review, and manage Player data.",
-                        slug: "players",
-                        tabs: [
-                            {
-                                name: "Profile",
-                                description: "Review basic Player data.",
-                                root: true
-                            },
-                            {
-                                name: "Documents",
-                                description: "Review Player documents.",
-                                slug: "documents"
-                            },
-                            {
-                                name: "Data updates",
-                                description: "Review Player data updates.",
-                                slug: "data-updates",
-                                tabs: [
-                                    {
-                                        name: "Requests",
-                                        description: "Review Player data update requests.",
-                                        root: true
-                                    },
-                                    {
-                                        name: "History",
-                                        description: "Review Player data update history.",
-                                        slug: "history"
-                                    }
-                                ]
-                            },
-                            {
-                                name: "Credits",
-                                description: "Review Koloseum Credits data for the Player.",
-                                slug: "credits",
-                                tabs: [
-                                    {
-                                        name: "Transactions",
-                                        description: "Review Player transactions with Koloseum Credits.",
-                                        root: true
-                                    },
-                                    {
-                                        name: "Transfers",
-                                        description: "Review Player transfers with Koloseum Credits.",
-                                        slug: "transfers"
-                                    },
-                                    {
-                                        name: "Subscriptions",
-                                        description: "Review Player subscriptions with Koloseum Credits.",
-                                        slug: "subscriptions"
-                                    }
-                                ]
-                            },
-                            {
-                                name: "Misconduct",
-                                description: "Review Player reports and sanctions.",
-                                slug: "misconduct",
-                                tabs: [
-                                    {
-                                        name: "Reports",
-                                        description: "Review Player reports.",
-                                        root: true
-                                    },
-                                    {
-                                        name: "Sanctions",
-                                        description: "Review Player sanctions.",
-                                        slug: "sanctions"
-                                    }
-                                ]
-                            },
-                            {
-                                name: "Points / KXP",
-                                description: "Review Koloseum Experience Points (KXP) transactions for the Player.",
-                                slug: "points"
-                            }
-                        ]
-                    },
-                    {
-                        name: "Lounges",
-                        description: "Search, review, and manage Lounge data.",
-                        slug: "lounges",
-                        tabs: [
-                            {
-                                name: "Profile",
-                                description: "Review basic Lounge data.",
-                                root: true
-                            },
-                            {
-                                name: "Documents",
-                                description: "Review Lounge documents.",
-                                slug: "documents"
-                            },
-                            {
-                                name: "Staff",
-                                description: "Search, review, and manage Lounge staff data.",
-                                slug: "staff"
-                            },
-                            {
-                                name: "Branches",
-                                description: "Review Lounge branches.",
-                                slug: "branches",
-                                tabs: [
-                                    {
-                                        name: "Profile",
-                                        description: "Review basic Lounge branch data.",
-                                        root: true
-                                    },
-                                    {
-                                        name: "Amenities",
-                                        description: "Review Lounge branch amenities.",
-                                        slug: "amenities"
-                                    },
-                                    {
-                                        name: "Staff",
-                                        description: "Search, review, and manage Lounge branchstaff data.",
-                                        slug: "staff"
-                                    }
-                                ]
-                            },
-                            {
-                                name: "Data updates",
-                                description: "Review Lounge data updates.",
-                                slug: "data-updates",
-                                tabs: [
-                                    {
-                                        name: "Requests",
-                                        description: "Review Lounge data update requests.",
-                                        root: true
-                                    },
-                                    {
-                                        name: "History",
-                                        description: "Review Lounge data update history.",
-                                        slug: "history"
-                                    }
-                                ]
-                            },
-                            {
-                                name: "Credits",
-                                description: "Review Koloseum Credits data for the Lounge.",
-                                slug: "credits",
-                                tabs: [
-                                    {
-                                        name: "Transactions",
-                                        description: "Review Lounge transactions with Koloseum Credits.",
-                                        root: true
-                                    },
-                                    {
-                                        name: "Transfers",
-                                        description: "Review Lounge transfers with Koloseum Credits.",
-                                        slug: "transfers"
-                                    },
-                                    {
-                                        name: "Subscriptions",
-                                        description: "Review Lounge subscriptions with Koloseum Credits.",
-                                        slug: "subscriptions"
-                                    }
-                                ]
-                            },
-                            {
-                                name: "Misconduct",
-                                description: "Review Lounge reports and sanctions.",
-                                slug: "misconduct",
-                                tabs: [
-                                    {
-                                        name: "Reports",
-                                        description: "Review Lounge reports.",
-                                        root: true
-                                    },
-                                    {
-                                        name: "Sanctions",
-                                        description: "Review Lounge sanctions.",
-                                        slug: "sanctions"
-                                    }
-                                ]
-                            },
-                            {
-                                name: "Points / KXP",
-                                description: "Review Koloseum Experience Points (KXP) transactions for the Lounge.",
-                                slug: "points"
-                            }
-                        ]
-                    }
-                ],
-                roles: [
-                    {
-                        name: "Compliance",
-                        slug: "compliance",
-                        root: true
-                    },
-                    {
-                        name: "Players",
-                        slug: "players",
-                        featureSlugs: ["players"]
-                    },
-                    {
-                        name: "Lounges",
-                        slug: "lounges",
-                        featureSlugs: ["lounges"]
-                    }
-                ]
-            },
-            {
-                name: "Competitions",
-                description: "Management of competitions data and live events across Markets.",
-                slug: "competitions",
-                features: [
-                    {
-                        name: "Ma Esto",
-                        description: "Manage football esports data for Ma Esto.",
-                        slug: "fbl"
-                    },
-                    {
-                        name: "Savanna FGC",
-                        description: "Manage fighting games esports data for Savanna FGC.",
-                        slug: "fgc",
-                        tabs: [
-                            {
-                                name: "Savanna Circuit",
-                                description: "Manage competition data for the Savanna Circuit.",
-                                slug: "league",
-                                tabs: [
-                                    {
-                                        name: "Rankings",
-                                        description: "Manage rankings for any Savanna Circuit season.",
-                                        root: true
-                                    },
-                                    {
-                                        name: "Tournaments",
-                                        description: "Manage tournaments for any Savanna Circuit season.",
-                                        slug: "tournaments",
-                                        tabs: [
-                                            {
-                                                name: "Events",
-                                                description: "Manage events for any Savanna Circuit tournament.",
-                                                root: true
-                                            },
-                                            {
-                                                name: "Tickets",
-                                                description: "Manage tickets for any Savanna Circuit tournament.",
-                                                slug: "tickets"
-                                            },
-                                            {
-                                                name: "Settings",
-                                                description: "Manage settings for any Savanna Circuit tournament.",
-                                                slug: "settings"
-                                            }
-                                        ]
-                                    },
-                                    {
-                                        name: "Settings",
-                                        description: "Manage settings for any Savanna Circuit season.",
-                                        slug: "settings"
-                                    }
-                                ]
-                            },
-                            {
-                                name: "Savanna Fight Night",
-                                description: "Manage competition data for Savanna Fight Night.",
-                                slug: "challenges"
-                            }
-                        ]
-                    },
-                    {
-                        name: "Hit List",
-                        description: "Manage battle royale esports data for Hit List.",
-                        slug: "bryl"
-                    }
-                ],
-                roles: [
-                    {
-                        name: "Competitions",
-                        slug: "competitions",
-                        root: true
-                    },
-                    {
-                        name: "Ma Esto",
-                        slug: "fbl",
-                        featureSlugs: ["fbl"]
-                    },
-                    {
-                        name: "Savanna FGC",
-                        slug: "fgc",
-                        featureSlugs: ["fgc"]
-                    },
-                    {
-                        name: "Hit List",
-                        slug: "bryl",
-                        featureSlugs: ["bryl"]
-                    }
-                ]
-            },
-            {
-                name: "KLSM",
-                description: "Management of game and console trades between users.",
-                slug: "commerce",
-                features: [],
-                roles: [
-                    {
-                        name: "Commerce",
-                        slug: "commerce",
-                        root: true
-                    }
-                ]
-            },
-            {
-                name: "Staff",
-                description: "Management of Backroom staff authorisation.",
-                slug: "staff",
-                features: [
-                    {
-                        name: "Roles",
-                        description: "Review and manage Backroom roles.",
-                        slug: "roles"
-                    },
-                    {
-                        name: "Users",
-                        description: "Review and manage Backroom users.",
-                        slug: "users"
-                    }
-                ],
-                roles: [
-                    {
-                        name: "Human Resources",
-                        slug: "hr",
-                        root: true
-                    }
-                ]
-            }
-        ],
-        players: [
-            {
-                name: "Sessions",
-                description: "Track your gaming sessions at registered lounges.",
-                slug: "sessions",
-                features: [],
-                roles: null
-            },
-            {
-                name: "KLSM",
-                description: "Trade used games and consoles with other users at affordable prices.",
-                slug: "commerce",
-                features: [],
-                roles: null
-            },
-            {
-                name: "Savanna FGC",
-                description: "Check out the latest news and competitions from Savanna FGC.",
-                slug: "fgc",
-                features: [
-                    {
-                        name: "Home",
-                        description: "Learn more about the Savanna Circuit.",
-                        root: true
-                    },
-                    {
-                        name: "Rules",
-                        description: "Review the rules and regulations of the Savanna Circuit.",
-                        slug: "rules"
-                    },
-                    {
-                        name: "Tournaments",
-                        description: "Review and join upcoming tournaments on the Savanna Circuit.",
-                        slug: "tournaments"
-                    }
-                ],
-                roles: null
-            },
-            {
-                name: "Account",
-                description: "Review Player account settings and preferences.",
-                slug: "account",
-                features: [
-                    {
-                        name: "Personal",
-                        description: "Review and manage your personal information.",
-                        slug: "personal"
-                    },
-                    {
-                        name: "Gaming & Socials",
-                        description: "Review and manage your gaming and social media information.",
-                        slug: "gaming-socials"
-                    },
-                    {
-                        name: "Notifications",
-                        description: "Review and manage your notification preferences.",
-                        slug: "notifications"
-                    },
-                    {
-                        name: "Security",
-                        description: "Review and manage your security preferences.",
-                        slug: "security"
-                    },
-                    {
-                        name: "Lounges",
-                        description: "Review your access to Lounges microservices.",
-                        slug: "lounges"
-                    },
-                    {
-                        name: "Backroom",
-                        description: "Review your access to Backroom microservices.",
-                        slug: "backroom"
-                    }
-                ],
-                roles: null
-            }
-        ]
-    },
-    /**
-     * The minimum birth date (from today's date) for a user who is a minor, i.e. `YYYY-MM-DD`
-     */
-    minimumMinorBirthDate: (() => {
-        const today = new Date();
-        const tomorrow = new Date();
-        tomorrow.setUTCDate(today.getDate() + 1);
-        const tomorrow18YearsAgo = tomorrow.getFullYear() - 18;
-        tomorrow.setFullYear(tomorrow18YearsAgo);
-        return tomorrow.toISOString().split("T")[0];
-    })(),
-    /**
-     * Check if a page is active based on the slug and microservice.
-     * @param page - The current page object.
-     * @param slug - The slug of the page to check.
-     * @param microservice - The microservice to check against.
-     * @param base - The base path of the application; defaults to an empty string.
-     * @returns `true` if the page is active, `false` otherwise.
-     */
-    pageIsActive: (page, slug, microservice, base = "") => {
-        // Return true if microservice is provided and matches slug
-        if (microservice)
-            return slug === microservice;
-        // Remove trailing slash from base for consistency
-        const cleanBase = base.replace(/\/$/, "");
-        // Match exactly the base path if slug is falsy (i.e. root microservice feature)
-        if (!slug)
-            return page.url.pathname === cleanBase || page.url.pathname === `${cleanBase}/`;
-        // Match exact or subpath otherwise
-        const target = `${cleanBase}/${slug}`;
-        return page.url.pathname === target || page.url.pathname.startsWith(`${target}/`);
-    },
-    /**
-     * Paginates an array.
-     * @template T - The type of array items; defaults to `any`
-     * @param {T[]} array - The array to paginate
-     * @param {number} page - The page number
-     * @param {number} pageSize - The number of items per page; defaults to 10
-     * @returns {Object} The paginated array and total number of pages
-     */
-    paginateArray: (array, page, pageSize = 10) => {
-        // Define variables
-        const startIndex = (page - 1) * pageSize;
-        const endIndex = startIndex + pageSize;
-        const totalPages = Math.ceil(array.length / pageSize);
-        // Paginate items
-        const paginatedItems = array.slice(startIndex, endIndex);
-        // Return data
-        return { paginatedItems, totalPages };
-    },
-    /**
-     * Parses a `CustomError` object within a page/layout server load function and returns an error to be thrown.
-     * @param {CustomError} error - The error object
-     * @returns A new `Error` object if the error is unexpected, or a Svelte error otherwise
-     */
-    parseLoadError: (error) => error.code === 500 ? new Error(error.message) : svelteError(error.code, { message: error.message }),
-    /**
-     * Parses a Postgres interval string and returns a string in the specified format.
-     * @param {string} interval - The interval string to parse
-     * @param {"postgres" | "iso" | "iso-short"} type - The format to return the interval in; defaults to `postgres`
-     * @returns A string in the specified format
-     */
-    parsePostgresInterval: (interval, type = "postgres") => {
-        // Return null if interval is falsy
-        if (!interval)
-            return null;
-        // Parse interval and return in the specified format
-        const { toPostgres, toISOString, toISOStringShort } = parsePgInterval(interval);
-        if (type === "postgres")
-            return toPostgres();
-        if (type === "iso")
-            return toISOString();
-        if (type === "iso-short")
-            return toISOStringShort();
-        // Return null if type is invalid
-        return null;
-    },
-    /**
-     * Parses a `PostgrestError` object and returns a custom error object if any has occurred.
-     * @param {PostgrestError | null} postgrestError - The `PostgrestError` object, or `null` if no error occurred
-     * @param {boolean} clientSafe - Whether to clamp 5xx errors down to 422 to prevent Sentry from capturing them as unhandled; defaults to `true`
-     * @returns An object with an `error` if any has occurred
-     */
-    parsePostgrestError: (postgrestError, clientSafe = true) => {
-        // Return undefined if no error occurred
-        let error;
-        if (!postgrestError)
-            return { error };
-        // Get custom error code from hint
-        const customErrorCode = Number(postgrestError.hint);
-        // Clamp 5xx errors down to 422 to prevent Sentry from capturing them as unhandled; see https://koloseum-technologies.sentry.io/issues/6766267685/
-        let statusCode = clientSafe ? (customErrorCode >= 500 ? 422 : customErrorCode) : customErrorCode;
-        // Return custom error if hint is a number between 400 and 599
-        if (!isNaN(customErrorCode) && customErrorCode >= 400 && customErrorCode <= 599) {
-            error = Utility.customError(statusCode, postgrestError.message);
-            return { error };
-        }
-        // Map Postgrest error codes to custom error codes
-        const errorMap = [
-            { code: "08", status: 503 },
-            { code: "09", status: 500 },
-            { code: "0L", status: 403 },
-            { code: "0P", status: 403 },
-            { code: "23503", status: 409 },
-            { code: "23505", status: 409 },
-            { code: "25006", status: 405 },
-            { code: "25", status: 500 },
-            { code: "28", status: 403 },
-            { code: "2D", status: 500 },
-            { code: "38", status: 500 },
-            { code: "39", status: 500 },
-            { code: "3B", status: 500 },
-            { code: "40", status: 500 },
-            { code: "53400", status: 500 },
-            { code: "53", status: 503 },
-            { code: "54", status: 500 },
-            { code: "55", status: 500 },
-            { code: "57", status: 500 },
-            { code: "58", status: 500 },
-            { code: "F0", status: 500 },
-            { code: "HV", status: 500 },
-            { code: "P0001", status: 400 },
-            { code: "P0", status: 500 },
-            { code: "XX", status: 500 },
-            { code: "42883", status: 404 },
-            { code: "42P01", status: 404 },
-            { code: "42P17", status: 500 },
-            { code: "42501", status: 403 }
-        ];
-        // Return custom error if Postgrest error code is found
-        for (const { code, status } of errorMap)
-            if (postgrestError.code === code || postgrestError.code.startsWith(code)) {
-                statusCode = clientSafe ? (status >= 500 ? 422 : status) : status;
-                error = Utility.customError(statusCode, Status.ERROR);
-                return { error };
-            }
-        // Return generic error
-        error = Utility.customError(clientSafe ? 422 : 500, Status.ERROR);
-        return { error };
-    },
-    /**
-     * A regular expression for user passwords to match during authentication. It covers the following rules:
-     * - at least 8 characters long
-     * - at least one digit
-     * - at least one lowercase letter
-     * - at least one uppercase letter
-     * - at least one symbol
-     */
-    passwordRegex: /^(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[!@#$%^&*()-_+=|{}[\]:;'<>,.?/~]).{8,}$/,
-    /**
-     * Returns a regular expression for a Koloseum platform ID.
-     * @param {string} type - The type of platform ID to return
-     * @returns A regular expression for the platform ID, or `null` if the type is invalid
-     */
-    platformIdRegex: (type) => {
-        if (type === "lounge")
-            return /^KL\d{7}$/;
-        if (type === "loungeBranch")
-            return /^KLB\d{7}$/;
-        if (type === "player")
-            return /^KP\d{7}$/;
-        return null;
-    },
-    /**
-     * Sanitises any potential HTML injected into user input.
-     * @param {string} input - The input to be sanitised
-     * @returns A sanitised string, or an empty string if the input is invalid
-     */
-    sanitiseHtml: (input) => typeof input !== "string" ? "" : sanitize(input, { allowedTags: [], allowedAttributes: {} }),
-    /**
-     * Sends a welcome notification to a new user.
-     * @param {SupabaseClient<Database>} supabase - The Supabase client
-     * @param {UserWithCustomMetadata} user - The user to send the notification to
-     * @param {MicroserviceGroup} microserviceGroup - The microservice group the user belongs to
-     * @returns An object with an `error` if any has occurred
-     */
-    sendWelcomeNotification: async (supabase, user, microserviceGroup) => {
-        // Backroom
-        if (microserviceGroup === "backroom" && !user.user_metadata.backroom?.welcome_notification_sent) {
-            // Use atomic update with timestamp to prevent race conditions
-            const currentTime = new Date().toISOString();
-            const { data: updatedUser, error: updateError } = await supabase.auth.updateUser({
-                data: {
-                    backroom: {
-                        ...user.user_metadata.backroom,
-                        welcome_notification_sent: true,
-                        welcome_notification_timestamp: currentTime
-                    }
-                }
-            });
-            if (updateError)
-                return { error: Utility.customError(updateError.status ?? 500, updateError.message) };
-            // Only send notification if flag was successfully updated
-            const updatedBackroom = updatedUser.user?.user_metadata?.backroom;
-            if (updatedBackroom?.welcome_notification_sent === true &&
-                updatedBackroom?.welcome_notification_timestamp === currentTime) {
-                // Define SuprSend workflow body
-                const workflowBody = {
-                    name: "welcome-to-backroom",
-                    template: "welcome-to-backroom",
-                    notification_category: "system",
-                    users: [
-                        {
-                            distinct_id: user.id,
-                            $skip_create: true
-                        }
-                    ]
-                };
-                // Send welcome notification
-                const { code, error: workflowError } = await Utility.callEdgeFunction(false, supabase, `suprsend/trigger-workflow?user-id=${user.id}`, { method: "POST", headers: { "Content-Type": "application/json" }, body: workflowBody });
-                // If notification fails, revert the flag and return error
-                if (workflowError) {
-                    await supabase.auth.updateUser({
-                        data: {
-                            backroom: {
-                                ...user.user_metadata.backroom,
-                                welcome_notification_sent: false,
-                                welcome_notification_timestamp: undefined
-                            }
-                        }
-                    });
-                    return { error: Utility.customError(code, workflowError) };
-                }
-                // Update user object in memory
-                user.user_metadata.backroom = updatedBackroom;
-            }
-        }
-        // Return empty object
-        return {};
-    },
-    /**
-     * A regular expression for social media handles, without a leading slash or @ character.
-     *
-     * - Source: https://stackoverflow.com/a/74579651
-     */
-    socialMediaHandleRegex: /^([A-Za-z0-9_.]{3,25})$/gm,
-    /**
-     * Validates address data submitted in a form and returns the validated data.
-     * @param {FormData} formData - The submitted form data
-     * @returns An object with the validated `address`, or an `error` if any has occurred
-     */
-    validateAddress: async (formData) => {
-        // Create Kenya administrative divisions instance
-        const kenyaAdmin = new KenyaAdministrativeDivisions();
-        // Building name
-        let buildingName = formData.get("building-name");
-        if (!buildingName)
-            return { error: Utility.customError(400, "Building name is required.") };
-        buildingName = Utility.sanitiseHtml(trim(escape(buildingName)));
-        // Unit number
-        let unitNumber = formData.get("unit-number") || undefined;
-        if (unitNumber) {
-            unitNumber = Utility.sanitiseHtml(trim(escape(unitNumber)));
-            if (unitNumber === "")
-                unitNumber = undefined;
-        }
-        // Street name
-        let streetName = formData.get("street-name");
-        if (!streetName)
-            return { error: Utility.customError(400, "Street name is required.") };
-        streetName = Utility.sanitiseHtml(trim(escape(streetName)));
-        // P.O. box and postal code
-        let boxNumber = formData.get("box-number") || undefined;
-        let postalCode = formData.get("postal-code") || undefined;
-        if (boxNumber) {
-            boxNumber = Utility.sanitiseHtml(trim(escape(boxNumber)));
-            if (boxNumber === "")
-                boxNumber = undefined;
-            if (boxNumber && !postalCode)
-                return { error: Utility.customError(400, "Postal code is required.") };
-        }
-        if (postalCode) {
-            postalCode = Utility.sanitiseHtml(trim(escape(postalCode)));
-            if (postalCode === "")
-                postalCode = undefined;
-            if (postalCode && !boxNumber)
-                return { error: Utility.customError(400, "P.O. box is required.") };
-        }
-        // Town
-        let town = formData.get("town");
-        if (!town)
-            return { error: Utility.customError(400, "City/town is required.") };
-        town = Utility.sanitiseHtml(trim(escape(town)));
-        // County
-        let county = undefined;
-        const countyCode = Number(formData.get("county-code"));
-        if (isNaN(countyCode))
-            return { error: Utility.customError(400, "County is invalid.") };
-        if (!countyCode)
-            return { error: Utility.customError(400, "County is required.") };
-        const counties = await kenyaAdmin.getAll();
-        if (!counties || counties.length === 0)
-            return { error: Utility.customError(400, "County is invalid.") };
-        const countyData = counties.find(({ county_code }) => county_code === countyCode);
-        if (!countyData)
-            return { error: Utility.customError(400, "County is invalid.") };
-        const { county_name, constituencies } = countyData;
-        county = county_name;
-        // Sub-county
-        let subCounty = formData.get("sub-county") || undefined;
-        if (subCounty) {
-            subCounty = Utility.sanitiseHtml(trim(escape(subCounty)));
-            if (subCounty === "")
-                subCounty = undefined;
-            else {
-                // Check if constituencies exists and is an array before mapping
-                if (!constituencies || !Array.isArray(constituencies))
-                    return { error: Utility.customError(400, "Sub-county data is unavailable.") };
-                // Get list of sub-counties
-                const subCounties = constituencies.map(({ constituency_name: name }) => name);
-                if (!subCounties.includes(subCounty))
-                    return { error: Utility.customError(400, "Sub-county is invalid.") };
-            }
-        }
-        // Additional information
-        let additionalInfo = formData.get("address-additional-info") || undefined;
-        if (additionalInfo) {
-            additionalInfo = Utility.sanitiseHtml(trim(escape(additionalInfo)));
-            if (additionalInfo === "")
-                additionalInfo = undefined;
-        }
-        // Create address object
-        const address = {
-            buildingName,
-            unitNumber,
-            streetName,
-            town,
-            subCounty,
-            county,
-            additionalInfo
-        };
-        // Return data
-        return { address };
-    },
-    /**
-     * Validates an E.164 phone number.
-     * @param {string} phoneNumber - The phone number to be validated
-     * @param {"any" | MobilePhoneLocale | MobilePhoneLocale[]} [locale="any"] - The locale(s) to validate the phone number against
-     * @returns `true` if the phone number is valid; `false` otherwise
-     */
-    validateE164: (phoneNumber, locale = "en-KE") => isMobilePhone(phoneNumber, locale) && Boolean(phoneNumber.match(Utility.e164Regex)),
-    /**
-     * Validates a social media handle.
-     * @param {string} handle - The social media handle to be validated
-     * @returns `true` if the handle is valid; `false` otherwise
-     */
-    validateSocialMediaHandle: (handle) => !isURL(handle, { require_protocol: false }) &&
-        !handle.startsWith("@") &&
-        Boolean(handle.match(Utility.socialMediaHandleRegex))
-};
-/* CACHE FUNCTIONS */
-export const Cache = {
-    /**
-     * Delete cached data from Valkey.
-     * @param valkey - The Valkey client instance
-     * @param cachePrefix - The cache prefix
-     * @param key - The cache key
-     */
-    deleteData: async (valkey, cachePrefix, key) => {
-        try {
-            await valkey.del(`${cachePrefix}${key}`);
-        }
-        catch (error) {
-            console.error("Cache delete error:", error);
-        }
-    },
-    /**
-     * Generate cache key with consistent formatting
-     * @param prefix - The key prefix
-     * @param params - Additional parameters to include in the key
-     * @returns The formatted cache key
-     */
-    generateDataKey: (prefix, ...params) => `${prefix}:${params.join(":")}`,
-    /**
-     * Get cached data from Valkey.
-     * @param valkey - The Valkey client instance
-     * @param cachePrefix - The cache prefix
-     * @param key - The cache key
-     * @returns The cached data, or `null` if not found
-     */
-    getData: async (valkey, cachePrefix, key) => {
-        try {
-            const cached = await valkey.get(`${cachePrefix}${key}`);
-            return cached ? JSON.parse(cached) : null;
-        }
-        catch (error) {
-            console.error("Cache get error:", error);
-            return null;
-        }
-    },
-    /**
-     * Invalidate cache by pattern
-     * @param valkey - The Valkey client instance
-     * @param cachePrefix - The cache prefix
-     * @param pattern - The pattern to match keys against (e.g., "app-config*")
-     */
-    invalidateDataByPattern: async (valkey, cachePrefix, pattern) => {
-        try {
-            const keys = await valkey.keys(`${cachePrefix}${pattern}`);
-            if (keys.length > 0)
-                await valkey.del(...keys);
-        }
-        catch (error) {
-            console.error("Cache pattern invalidation error:", error);
-        }
-    },
-    /**
-     * Set data in Valkey cache.
-     * @param valkey - The Valkey client instance
-     * @param cachePrefix - The cache prefix
-     * @param key - The cache key
-     * @param data - The data to cache
-     * @param ttl - The time to live in seconds; defaults to 1 hour
-     */
-    setData: async (valkey, cachePrefix, key, data, ttl = 3600) => {
-        try {
-            await valkey.setex(`${cachePrefix}${key}`, ttl, JSON.stringify(data));
-        }
-        catch (error) {
-            console.error("Cache set error:", error);
-        }
-    }
-};
-/* BROWSER COMPATIBILITY FUNCTIONS */
-export const Browser = {
-    /**
-     * Checks if a specific feature is supported by the browser.
-     * @param feature - The feature to check
-     * @param browserName - The name of the browser
-     * @param browserVersion - The version of the browser
-     * @returns `true` if the feature is supported, `false` otherwise
-     */
-    checkFeatureSupport: (feature, browserName, browserVersion) => {
-        // Feature support matrix based on browser versions
-        const featureSupport = {
-            optionalChaining: {
-                Chrome: 80,
-                Firefox: 74,
-                Safari: 13.4,
-                Edge: 80,
-                Opera: 80
-            },
-            nullishCoalescing: {
-                Chrome: 80,
-                Firefox: 72,
-                Safari: 13.4,
-                Edge: 80,
-                Opera: 80
-            },
-            fetch: {
-                Chrome: 42,
-                Firefox: 39,
-                Safari: 10.1,
-                Edge: 14,
-                Opera: 29
-            },
-            es6Modules: {
-                Chrome: 61,
-                Firefox: 60,
-                Safari: 10.1,
-                Edge: 16,
-                Opera: 48
-            },
-            asyncAwait: {
-                Chrome: 55,
-                Firefox: 52,
-                Safari: 10.1,
-                Edge: 14,
-                Opera: 42
-            }
-        };
-        const featureMatrix = featureSupport[feature];
-        if (!featureMatrix)
-            return true; // Unknown feature, assume supported
-        const minVersion = featureMatrix[browserName];
-        if (!minVersion)
-            return true; // Unknown browser, assume supported
-        return browserVersion >= minVersion;
-    },
-    /**
-     * Gets detailed browser information for debugging.
-     */
-    getDetailedInfo: () => {
-        if (typeof window === "undefined") {
-            return {
-                browser: "Server-side rendering",
-                os: "Unknown",
-                platform: "Unknown",
-                engine: "Unknown",
-                userAgent: "Unknown"
-            };
-        }
-        const browser = Bowser.getParser(window.navigator.userAgent);
-        return {
-            browser: `${browser.getBrowserName()} ${browser.getBrowserVersion()}`,
-            os: `${browser.getOSName()} ${browser.getOSVersion()}`,
-            platform: browser.getPlatformType(),
-            engine: browser.getEngineName(),
-            userAgent: window.navigator.userAgent
-        };
-    },
-    /**
-     * Gets comprehensive browser information using Bowser.
-     */
-    getInfo: () => {
-        if (typeof window === "undefined") {
-            return {
-                name: "server",
-                version: 0,
-                isOldSafari: false,
-                isIOS: false,
-                supportsOptionalChaining: true,
-                supportsNullishCoalescing: true,
-                supportsFetch: true
-            };
-        }
-        const browser = Bowser.getParser(window.navigator.userAgent);
-        const browserName = browser.getBrowserName();
-        const browserVersion = parseFloat(browser.getBrowserVersion() || "0");
-        const osName = browser.getOSName();
-        const isIOS = osName === "iOS";
-        const isSafari = browserName === "Safari";
-        const isOldSafari = isSafari && browserVersion < 13.4;
-        return {
-            name: browserName,
-            version: browserVersion,
-            isOldSafari,
-            isIOS,
-            supportsOptionalChaining: Browser.checkFeatureSupport("optionalChaining", browserName, browserVersion),
-            supportsNullishCoalescing: Browser.checkFeatureSupport("nullishCoalescing", browserName, browserVersion),
-            supportsFetch: Browser.checkFeatureSupport("fetch", browserName, browserVersion)
-        };
-    },
-    /**
-     * Gets specific browser recommendations based on the detected browser.
-     */
-    getRecommendations: () => {
-        if (typeof window === "undefined")
-            return {
-                title: "Browser compatibility issue",
-                message: "Browser detection is not available on theserver.",
-                recommendations: [],
-                critical: false
-            };
-        const browser = Bowser.getParser(window.navigator.userAgent);
-        const browserName = browser.getBrowserName();
-        const browserVersion = browser.getBrowserVersion();
-        // Internet Explorer
-        if (browserName === "Internet Explorer") {
-            return {
-                title: "Unsupported browser",
-                message: "Internet Explorer is not supported. Please use a modern browser.",
-                recommendations: [
-                    "Download and install Microsoft Edge",
-                    "Use an alternative such as Chrome or Firefox (or Safari on Mac)"
-                ],
-                critical: true
-            };
-        }
-        // Apple Safari
-        if (browserName === "Safari" && parseFloat(browserVersion || "0") < 13.4) {
-            return {
-                title: "Browser compatibility issue",
-                message: `You're using Safari ${browserVersion || "Unknown"}, which doesn't support modern web features.`,
-                recommendations: [
-                    "Update to Safari 13.4 or later",
-                    "Use Chrome or Firefox as an alternative",
-                    "Update your iOS device to the latest version"
-                ],
-                critical: true
-            };
-        }
-        // Google Chrome
-        if (browserName === "Chrome" && parseFloat(browserVersion || "0") < 80) {
-            return {
-                title: "Outdated browser",
-                message: `You're using Chrome ${browserVersion || "Unknown"}, which may not support all features.`,
-                recommendations: ["Update Chrome to version 80 or later", "Enable automatic updates in Chrome settings"],
-                critical: false
-            };
-        }
-        // Mozilla Firefox
-        if (browserName === "Firefox" && parseFloat(browserVersion || "0") < 80) {
-            return {
-                title: "Outdated browser",
-                message: `You're using Firefox ${browserVersion || "Unknown"}, which may not support all features.`,
-                recommendations: ["Update Firefox to version 80 or later", "Enable automatic updates in Firefox settings"],
-                critical: false
-            };
-        }
-        // Microsoft Edge
-        if (browserName === "Edge" && parseFloat(browserVersion || "0") < 80) {
-            return {
-                title: "Outdated browser",
-                message: `You're using Edge ${browserVersion || "Unknown"}, which may not support all features.`,
-                recommendations: ["Update Edge to version 80 or later", "Enable automatic updates in Edge settings"],
-                critical: false
-            };
-        }
-        // For unknown or very old browsers
-        if (browserName === "Unknown" || parseFloat(browserVersion || "0") < 50) {
-            return {
-                title: "Unrecognised browser",
-                message: "Your browser may not be fully supported. For the best experience, please use a modern browser.",
-                recommendations: ["Use Chrome, Firefox or Edge (latest version)", "Use Safari 13.4+ (on Mac/iOS)"],
-                critical: true
-            };
-        }
-        // Default for modern browsers
-        return {
-            title: "Browser compatibility issue",
-            message: "Your browser may not fully support this application.",
-            recommendations: [
-                "Update your browser to the latest version",
-                "Clear your browser cache and cookies",
-                "Disable browser extensions temporarily",
-                "Try a different modern browser"
-            ],
-            critical: false
-        };
-    },
-    /**
-     * Checks if the current browser is compatible with the application.
-     */
-    isBrowserCompatible: () => {
-        if (typeof window === "undefined")
-            return true;
-        const browser = Bowser.getParser(window.navigator.userAgent);
-        const browserName = browser.getBrowserName();
-        const browserVersion = parseFloat(browser.getBrowserVersion() || "0");
-        // Define minimum supported versions
-        const minVersions = {
-            "Internet Explorer": 0, // Not supported at all
-            Safari: 13.4,
-            Chrome: 80,
-            Firefox: 80,
-            Edge: 80,
-            Opera: 80
-        };
-        // Internet Explorer is never compatible
-        if (browserName === "Internet Explorer") {
-            return false;
-        }
-        // Check if browser version meets minimum requirements
-        const minVersion = minVersions[browserName];
-        if (minVersion && browserVersion < minVersion) {
-            return false;
-        }
-        // Check for critical modern features
-        return (Browser.checkFeatureSupport("optionalChaining", browserName, browserVersion) &&
-            Browser.checkFeatureSupport("nullishCoalescing", browserName, browserVersion) &&
-            Browser.checkFeatureSupport("fetch", browserName, browserVersion) &&
-            Browser.checkFeatureSupport("es6Modules", browserName, browserVersion) &&
-            Browser.checkFeatureSupport("asyncAwait", browserName, browserVersion));
-    },
-    /**
-     * Checks if the browser is Internet Explorer.
-     */
-    isInternetExplorer: () => {
-        if (typeof window === "undefined")
-            return false;
-        const browser = Bowser.getParser(window.navigator.userAgent);
-        return browser.getBrowserName() === "Internet Explorer";
-    },
-    /**
-     * Checks if the browser is iOS Safari.
-     */
-    isIOSSafari: () => {
-        if (typeof window === "undefined")
-            return false;
-        const browser = Bowser.getParser(window.navigator.userAgent);
-        return browser.getOSName() === "iOS" && browser.getBrowserName() === "Safari";
-    },
-    /**
-     * Checks if the browser is a legacy version that needs updating.
-     */
-    isLegacyBrowser: () => {
-        if (typeof window === "undefined")
-            return false;
-        const browser = Bowser.getParser(window.navigator.userAgent);
-        const browserName = browser.getBrowserName();
-        const browserVersion = parseFloat(browser.getBrowserVersion() || "0");
-        // Legacy browser thresholds
-        const legacyThresholds = {
-            "Internet Explorer": 0, // All versions are legacy
-            Safari: 13.4,
-            Chrome: 80,
-            Firefox: 80,
-            Edge: 80,
-            Opera: 80
-        };
-        const threshold = legacyThresholds[browserName];
-        return threshold ? browserVersion < threshold : false;
-    },
-    /**
-     * Checks if the browser is an old version of Safari.
-     */
-    isOldSafari: () => {
-        if (typeof window === "undefined")
-            return false;
-        const browser = Bowser.getParser(window.navigator.userAgent);
-        const browserName = browser.getBrowserName();
-        const browserVersion = parseFloat(browser.getBrowserVersion() || "0");
-        return browserName === "Safari" && browserVersion < 13.4;
-    }
-};