@pallasoft/ps-utilities 2.6.0 → 2.8.0

package/dist/common/amount-service.d.ts

@@ -0,0 +1,5 @@
+export declare class AmountService {
+    static normalise(raw: string): string;
+    static toNumber(raw: string): number;
+    static isAmount(raw: string): boolean;
+}

package/dist/common/amount-service.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmountService = void 0;
+var amount_config_1 = require("./constants/amount-config");
+var AmountService = /** @class */ (function () {
+    function AmountService() {
+    }
+    AmountService.normalise = function (raw) {
+        var trimmed = raw.trim();
+        var isBracketed = trimmed.startsWith(amount_config_1.AmountConfig.openBracket) && trimmed.endsWith(amount_config_1.AmountConfig.closeBracket);
+        var isNegative = isBracketed || trimmed.startsWith(amount_config_1.AmountConfig.minus);
+        var kept = trimmed.replace(amount_config_1.AmountConfig.disallowed, '');
+        var pointIndex = kept.indexOf(amount_config_1.AmountConfig.point);
+        var digits = pointIndex === -1
+            ? kept
+            : "".concat(kept.slice(0, pointIndex + 1)).concat(kept
+                .slice(pointIndex + 1)
+                .split(amount_config_1.AmountConfig.point)
+                .join(''));
+        if (digits === '')
+            return isNegative && !isBracketed ? amount_config_1.AmountConfig.minus : '';
+        return isNegative ? "".concat(amount_config_1.AmountConfig.minus).concat(digits) : digits;
+    };
+    AmountService.toNumber = function (raw) {
+        var normalised = AmountService.normalise(raw);
+        var parsed = Number(normalised);
+        return normalised === '' || !Number.isFinite(parsed) ? 0 : parsed;
+    };
+    AmountService.isAmount = function (raw) {
+        var normalised = AmountService.normalise(raw);
+        return (normalised !== '' && normalised !== amount_config_1.AmountConfig.minus && Number.isFinite(Number(normalised)));
+    };
+    return AmountService;
+}());
+exports.AmountService = AmountService;

package/dist/common/constants/amount-config.d.ts

@@ -0,0 +1,7 @@
+export declare const AmountConfig: {
+    readonly closeBracket: ")";
+    readonly disallowed: RegExp;
+    readonly minus: "-";
+    readonly openBracket: "(";
+    readonly point: ".";
+};

package/dist/common/constants/amount-config.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmountConfig = void 0;
+exports.AmountConfig = {
+    closeBracket: ')',
+    disallowed: /[^0-9.]/g,
+    minus: '-',
+    openBracket: '(',
+    point: '.',
+};

package/dist/common/constants/index.d.ts

@@ -1 +1,7 @@
+export * from './amount-config';
 export * from './email-preview-config';
+export * from './phone-config';
+export * from './postal-code-formats';
+export * from './signed-token-config';
+export * from './user-token-config';
+export * from './validation-config';

package/dist/common/constants/index.js

@@ -14,4 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./amount-config"), exports);
 __exportStar(require("./email-preview-config"), exports);
+__exportStar(require("./phone-config"), exports);
+__exportStar(require("./postal-code-formats"), exports);
+__exportStar(require("./signed-token-config"), exports);
+__exportStar(require("./user-token-config"), exports);
+__exportStar(require("./validation-config"), exports);

package/dist/common/constants/phone-config.d.ts

@@ -0,0 +1,6 @@
+export declare const PhoneConfig: {
+    readonly defaultCountry: "CA";
+    readonly displayNamesType: "region";
+    readonly locale: "en";
+    readonly plus: "+";
+};

package/dist/common/constants/phone-config.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhoneConfig = void 0;
+exports.PhoneConfig = {
+    defaultCountry: 'CA',
+    displayNamesType: 'region',
+    locale: 'en',
+    plus: '+',
+};

package/dist/common/constants/postal-code-formats.d.ts

@@ -0,0 +1,5 @@
+import type { PostalCodeFormatData } from '../../models/postal-code-format-data';
+export declare const PostalCodeFormats: Record<string, PostalCodeFormatData>;
+export declare const PostalCodeConfig: {
+    readonly fallbackAllowed: RegExp;
+};

package/dist/common/constants/postal-code-formats.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostalCodeConfig = exports.PostalCodeFormats = void 0;
+exports.PostalCodeFormats = {
+    CA: { allowed: /[^A-Z0-9]/g, groups: [3, 3], separator: ' ' },
+    GB: { allowed: /[^A-Z0-9]/g, groups: [], separator: ' ' },
+    IN: { allowed: /[^0-9]/g, groups: [6], separator: '' },
+    NL: { allowed: /[^A-Z0-9]/g, groups: [4, 2], separator: ' ' },
+    US: { allowed: /[^0-9]/g, groups: [5, 4], separator: '-' },
+};
+exports.PostalCodeConfig = {
+    fallbackAllowed: /[^A-Z0-9 -]/g,
+};

package/dist/common/constants/signed-token-config.d.ts

@@ -0,0 +1,17 @@
+export declare const SignedTokenConfig: {
+    readonly algorithm: "ES256";
+    readonly type: "JWT";
+    readonly keyAlgorithm: {
+        readonly name: "ECDSA";
+        readonly namedCurve: "P-256";
+    };
+    readonly signAlgorithm: {
+        readonly name: "ECDSA";
+        readonly hash: "SHA-256";
+    };
+    readonly privateKeyFormat: "pkcs8";
+    readonly publicKeyFormat: "spki";
+    readonly separator: ".";
+    readonly partCount: 3;
+    readonly keyCacheLimit: 20;
+};

package/dist/common/constants/signed-token-config.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignedTokenConfig = void 0;
+exports.SignedTokenConfig = {
+    algorithm: 'ES256',
+    type: 'JWT',
+    keyAlgorithm: { name: 'ECDSA', namedCurve: 'P-256' },
+    signAlgorithm: { name: 'ECDSA', hash: 'SHA-256' },
+    privateKeyFormat: 'pkcs8',
+    publicKeyFormat: 'spki',
+    separator: '.',
+    partCount: 3,
+    keyCacheLimit: 20,
+};

package/dist/common/constants/user-token-config.d.ts

@@ -0,0 +1,6 @@
+export declare const UserTokenConfig: {
+    readonly defaultLifetimeSeconds: 60;
+    readonly maxLifetimeSeconds: 120;
+    readonly clockSkewSeconds: 5;
+    readonly millisecondsPerSecond: 1000;
+};

package/dist/common/constants/user-token-config.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserTokenConfig = void 0;
+exports.UserTokenConfig = {
+    defaultLifetimeSeconds: 60,
+    maxLifetimeSeconds: 120,
+    clockSkewSeconds: 5,
+    millisecondsPerSecond: 1000,
+};

package/dist/common/constants/validation-config.d.ts

@@ -0,0 +1,8 @@
+export declare const ValidationConfig: {
+    readonly email: RegExp;
+    readonly webProtocols: readonly ["http:", "https:"];
+    readonly hostSeparator: ".";
+    readonly urlProtocol: "https://";
+    readonly urlProtocolPattern: RegExp;
+    readonly uuid: RegExp;
+};

package/dist/common/constants/validation-config.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationConfig = void 0;
+exports.ValidationConfig = {
+    email: /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/,
+    webProtocols: ['http:', 'https:'],
+    hostSeparator: '.',
+    urlProtocol: 'https://',
+    urlProtocolPattern: /^[a-z][a-z0-9+.-]*:\/\//i,
+    uuid: /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+};

package/dist/common/index.d.ts

@@ -1,12 +1,18 @@
+export * from './amount-service';
 export * from './color-service';
 export * from './constants';
 export * from './crypto-service';
+export * from './date-service';
 export * from './email-preview-service';
 export * from './encrypted-fields-service';
 export * from './envelope-crypto-service';
-export * from './date-service';
 export * from './number-format-service';
+export * from './phone-service';
+export * from './postal-code-service';
 export * from './recaptcha-service';
-export * from './url-service';
+export * from './signed-token-service';
 export * from './string-service';
 export * from './transform-service';
+export * from './url-service';
+export * from './user-token-service';
+export * from './validation-service';

package/dist/common/index.js

@@ -14,15 +14,21 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./amount-service"), exports);
 __exportStar(require("./color-service"), exports);
 __exportStar(require("./constants"), exports);
 __exportStar(require("./crypto-service"), exports);
+__exportStar(require("./date-service"), exports);
 __exportStar(require("./email-preview-service"), exports);
 __exportStar(require("./encrypted-fields-service"), exports);
 __exportStar(require("./envelope-crypto-service"), exports);
-__exportStar(require("./date-service"), exports);
 __exportStar(require("./number-format-service"), exports);
+__exportStar(require("./phone-service"), exports);
+__exportStar(require("./postal-code-service"), exports);
 __exportStar(require("./recaptcha-service"), exports);
-__exportStar(require("./url-service"), exports);
+__exportStar(require("./signed-token-service"), exports);
 __exportStar(require("./string-service"), exports);
 __exportStar(require("./transform-service"), exports);
+__exportStar(require("./url-service"), exports);
+__exportStar(require("./user-token-service"), exports);
+__exportStar(require("./validation-service"), exports);

package/dist/common/phone-service.d.ts

@@ -0,0 +1,14 @@
+import { type CountryCode } from 'libphonenumber-js';
+import type { PhoneCountryData } from '../models/phone-country-data';
+import type { PhoneDisplayData } from '../models/phone-display-data';
+export declare class PhoneService {
+    static isCountry(code: string): code is CountryCode;
+    static countries(preferred: string, locale?: string): PhoneCountryData[];
+    static display(value: string, fallbackCountry: string): PhoneDisplayData;
+    static format(national: string, country: string): string;
+    static formatForDisplay(value: string, country: string): string;
+    static toStored(national: string, country: string): string;
+    static isValid(national: string, country: string): boolean;
+    static callingCode(country: string): string;
+    private static parse;
+}

package/dist/common/phone-service.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhoneService = void 0;
+var libphonenumber_js_1 = require("libphonenumber-js");
+var phone_config_1 = require("./constants/phone-config");
+var PhoneService = /** @class */ (function () {
+    function PhoneService() {
+    }
+    PhoneService.isCountry = function (code) {
+        return (0, libphonenumber_js_1.getCountries)().includes(code);
+    };
+    PhoneService.countries = function (preferred, locale) {
+        if (locale === void 0) { locale = phone_config_1.PhoneConfig.locale; }
+        var names = new Intl.DisplayNames([locale], { type: phone_config_1.PhoneConfig.displayNamesType });
+        var options = (0, libphonenumber_js_1.getCountries)().map(function (code) {
+            var name = names.of(code);
+            return {
+                callingCode: (0, libphonenumber_js_1.getCountryCallingCode)(code),
+                code: code,
+                label: name !== undefined ? name : code,
+            };
+        });
+        return options.sort(function (left, right) {
+            if (left.code === preferred)
+                return -1;
+            if (right.code === preferred)
+                return 1;
+            return left.label.localeCompare(right.label);
+        });
+    };
+    PhoneService.display = function (value, fallbackCountry) {
+        var parsed = value.startsWith(phone_config_1.PhoneConfig.plus)
+            ? (0, libphonenumber_js_1.parsePhoneNumberFromString)(value)
+            : undefined;
+        if (parsed !== undefined && parsed.country !== undefined)
+            return { country: parsed.country, national: parsed.formatNational() };
+        return { country: fallbackCountry, national: value };
+    };
+    PhoneService.format = function (national, country) {
+        if (!PhoneService.isCountry(country))
+            return national;
+        return new libphonenumber_js_1.AsYouType(country).input(national);
+    };
+    PhoneService.formatForDisplay = function (value, country) {
+        var parsed = PhoneService.parse(value, country);
+        if (parsed === undefined || !parsed.isValid())
+            return value.trim();
+        return parsed.country === country ? parsed.formatNational() : parsed.formatInternational();
+    };
+    PhoneService.toStored = function (national, country) {
+        var trimmed = national.trim();
+        if (trimmed === '' || !PhoneService.isCountry(country))
+            return trimmed;
+        var parsed = (0, libphonenumber_js_1.parsePhoneNumberFromString)(trimmed, country);
+        return parsed !== undefined ? parsed.number : trimmed;
+    };
+    PhoneService.isValid = function (national, country) {
+        if (national.trim() === '')
+            return true;
+        var parsed = PhoneService.parse(national, country);
+        return parsed !== undefined && parsed.isValid();
+    };
+    PhoneService.callingCode = function (country) {
+        return PhoneService.isCountry(country) ? (0, libphonenumber_js_1.getCountryCallingCode)(country) : '';
+    };
+    PhoneService.parse = function (value, country) {
+        var trimmed = value.trim();
+        if (trimmed === '')
+            return undefined;
+        if (trimmed.startsWith(phone_config_1.PhoneConfig.plus))
+            return (0, libphonenumber_js_1.parsePhoneNumberFromString)(trimmed);
+        return PhoneService.isCountry(country)
+            ? (0, libphonenumber_js_1.parsePhoneNumberFromString)(trimmed, country)
+            : undefined;
+    };
+    return PhoneService;
+}());
+exports.PhoneService = PhoneService;

package/dist/common/postal-code-service.d.ts

@@ -0,0 +1,5 @@
+export declare class PostalCodeService {
+    static format(raw: string, country: string): string;
+    static maxLength(country: string): number | undefined;
+    static isValid(raw: string, country: string): boolean;
+}

package/dist/common/postal-code-service.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostalCodeService = void 0;
+var postal_code_formats_1 = require("./constants/postal-code-formats");
+var PostalCodeService = /** @class */ (function () {
+    function PostalCodeService() {
+    }
+    PostalCodeService.format = function (raw, country) {
+        var upper = raw.toUpperCase();
+        var format = postal_code_formats_1.PostalCodeFormats[country];
+        if (format === undefined)
+            return upper.replace(postal_code_formats_1.PostalCodeConfig.fallbackAllowed, '');
+        var compact = upper.replace(format.allowed, '');
+        if (format.groups.length === 0)
+            return upper.replace(postal_code_formats_1.PostalCodeConfig.fallbackAllowed, '');
+        var parts = [];
+        var cursor = 0;
+        for (var _i = 0, _a = format.groups; _i < _a.length; _i++) {
+            var size = _a[_i];
+            if (cursor >= compact.length)
+                break;
+            parts.push(compact.slice(cursor, cursor + size));
+            cursor += size;
+        }
+        return parts.join(format.separator);
+    };
+    PostalCodeService.maxLength = function (country) {
+        var format = postal_code_formats_1.PostalCodeFormats[country];
+        if (format === undefined || format.groups.length === 0)
+            return undefined;
+        return (format.groups.reduce(function (sum, size) { return sum + size; }, 0) +
+            format.separator.length * (format.groups.length - 1));
+    };
+    PostalCodeService.isValid = function (raw, country) {
+        var format = postal_code_formats_1.PostalCodeFormats[country];
+        if (raw.trim() === '' || format === undefined || format.groups.length === 0)
+            return true;
+        return PostalCodeService.format(raw, country).length === PostalCodeService.maxLength(country);
+    };
+    return PostalCodeService;
+}());
+exports.PostalCodeService = PostalCodeService;

package/dist/common/signed-token-service.d.ts

@@ -0,0 +1,19 @@
+import type { SignedTokenKeyPair } from '../models/signed-token-key-pair';
+export declare class SignedTokenService {
+    private static _textEncoder;
+    private static _textDecoder;
+    private static _privateKeys;
+    private static _publicKeys;
+    static generateKeyPair(): Promise<SignedTokenKeyPair>;
+    static sign<Claims extends object>(claims: Claims, privateKey: string): Promise<string>;
+    static verify<Claims extends object>(token: string, publicKeys: string[]): Promise<Claims | null>;
+    private static _privateKey;
+    private static _publicKey;
+    private static _remember;
+    private static _encodeJson;
+    private static _decodeJson;
+    private static _toBase64;
+    private static _fromBase64;
+    private static _toBase64Url;
+    private static _fromBase64Url;
+}

package/dist/common/signed-token-service.js

@@ -0,0 +1,233 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignedTokenService = void 0;
+var signed_token_config_1 = require("./constants/signed-token-config");
+var SignedTokenService = /** @class */ (function () {
+    function SignedTokenService() {
+    }
+    SignedTokenService.generateKeyPair = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var pair, privateKey, publicKey;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, crypto.subtle.generateKey(signed_token_config_1.SignedTokenConfig.keyAlgorithm, true, [
+                            'sign',
+                            'verify',
+                        ])];
+                    case 1:
+                        pair = (_a.sent());
+                        return [4 /*yield*/, crypto.subtle.exportKey(signed_token_config_1.SignedTokenConfig.privateKeyFormat, pair.privateKey)];
+                    case 2:
+                        privateKey = _a.sent();
+                        return [4 /*yield*/, crypto.subtle.exportKey(signed_token_config_1.SignedTokenConfig.publicKeyFormat, pair.publicKey)];
+                    case 3:
+                        publicKey = _a.sent();
+                        return [2 /*return*/, {
+                                privateKey: this._toBase64(new Uint8Array(privateKey)),
+                                publicKey: this._toBase64(new Uint8Array(publicKey)),
+                            }];
+                }
+            });
+        });
+    };
+    SignedTokenService.sign = function (claims, privateKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var header, signingInput, signature, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        header = {
+                            alg: signed_token_config_1.SignedTokenConfig.algorithm,
+                            typ: signed_token_config_1.SignedTokenConfig.type,
+                        };
+                        signingInput = "".concat(this._encodeJson(header)).concat(signed_token_config_1.SignedTokenConfig.separator).concat(this._encodeJson(claims));
+                        _b = (_a = crypto.subtle).sign;
+                        _c = [signed_token_config_1.SignedTokenConfig.signAlgorithm];
+                        return [4 /*yield*/, this._privateKey(privateKey)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, _c.concat([_d.sent(), this._textEncoder.encode(signingInput)]))];
+                    case 2:
+                        signature = _d.sent();
+                        return [2 /*return*/, "".concat(signingInput).concat(signed_token_config_1.SignedTokenConfig.separator).concat(this._toBase64Url(new Uint8Array(signature)))];
+                }
+            });
+        });
+    };
+    SignedTokenService.verify = function (token, publicKeys) {
+        return __awaiter(this, void 0, void 0, function () {
+            var parts, encodedHeader, encodedClaims, encodedSignature, header, signature, signingInput, _i, publicKeys_1, publicKey, key, isValid;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        parts = token.split(signed_token_config_1.SignedTokenConfig.separator);
+                        if (parts.length !== signed_token_config_1.SignedTokenConfig.partCount)
+                            return [2 /*return*/, null];
+                        encodedHeader = parts[0], encodedClaims = parts[1], encodedSignature = parts[2];
+                        header = this._decodeJson(encodedHeader);
+                        if (header === null ||
+                            header.alg !== signed_token_config_1.SignedTokenConfig.algorithm ||
+                            header.typ !== signed_token_config_1.SignedTokenConfig.type)
+                            return [2 /*return*/, null];
+                        signature = this._fromBase64Url(encodedSignature);
+                        if (signature === null)
+                            return [2 /*return*/, null];
+                        signingInput = this._textEncoder.encode("".concat(encodedHeader).concat(signed_token_config_1.SignedTokenConfig.separator).concat(encodedClaims));
+                        _i = 0, publicKeys_1 = publicKeys;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < publicKeys_1.length)) return [3 /*break*/, 5];
+                        publicKey = publicKeys_1[_i];
+                        return [4 /*yield*/, this._publicKey(publicKey).catch(function () { return null; })];
+                    case 2:
+                        key = _a.sent();
+                        if (key === null)
+                            return [3 /*break*/, 4];
+                        return [4 /*yield*/, crypto.subtle
+                                .verify(signed_token_config_1.SignedTokenConfig.signAlgorithm, key, signature, signingInput)
+                                .catch(function () { return false; })];
+                    case 3:
+                        isValid = _a.sent();
+                        if (isValid)
+                            return [2 /*return*/, this._decodeJson(encodedClaims)];
+                        _a.label = 4;
+                    case 4:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 5: return [2 /*return*/, null];
+                }
+            });
+        });
+    };
+    SignedTokenService._privateKey = function (privateKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cached, key;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        cached = this._privateKeys.get(privateKey);
+                        if (cached !== undefined)
+                            return [2 /*return*/, cached];
+                        return [4 /*yield*/, crypto.subtle.importKey(signed_token_config_1.SignedTokenConfig.privateKeyFormat, this._fromBase64(privateKey), signed_token_config_1.SignedTokenConfig.keyAlgorithm, false, ['sign'])];
+                    case 1:
+                        key = _a.sent();
+                        this._remember(this._privateKeys, privateKey, key);
+                        return [2 /*return*/, key];
+                }
+            });
+        });
+    };
+    SignedTokenService._publicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cached, key;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        cached = this._publicKeys.get(publicKey);
+                        if (cached !== undefined)
+                            return [2 /*return*/, cached];
+                        return [4 /*yield*/, crypto.subtle.importKey(signed_token_config_1.SignedTokenConfig.publicKeyFormat, this._fromBase64(publicKey), signed_token_config_1.SignedTokenConfig.keyAlgorithm, false, ['verify'])];
+                    case 1:
+                        key = _a.sent();
+                        this._remember(this._publicKeys, publicKey, key);
+                        return [2 /*return*/, key];
+                }
+            });
+        });
+    };
+    SignedTokenService._remember = function (cache, source, key) {
+        if (cache.size >= signed_token_config_1.SignedTokenConfig.keyCacheLimit) {
+            var oldest = cache.keys().next().value;
+            if (oldest !== undefined)
+                cache.delete(oldest);
+        }
+        cache.set(source, key);
+    };
+    SignedTokenService._encodeJson = function (value) {
+        return this._toBase64Url(this._textEncoder.encode(JSON.stringify(value)));
+    };
+    SignedTokenService._decodeJson = function (encoded) {
+        var bytes = this._fromBase64Url(encoded);
+        if (bytes === null)
+            return null;
+        try {
+            var value = JSON.parse(this._textDecoder.decode(bytes));
+            return typeof value === 'object' && value !== null && !Array.isArray(value)
+                ? value
+                : null;
+        }
+        catch (_a) {
+            return null;
+        }
+    };
+    SignedTokenService._toBase64 = function (bytes) {
+        var binary = '';
+        for (var index = 0; index < bytes.length; index += 1) {
+            binary += String.fromCharCode(bytes[index]);
+        }
+        return btoa(binary);
+    };
+    SignedTokenService._fromBase64 = function (value) {
+        var binary = atob(value.trim());
+        var bytes = new Uint8Array(binary.length);
+        for (var index = 0; index < binary.length; index += 1) {
+            bytes[index] = binary.charCodeAt(index);
+        }
+        return bytes;
+    };
+    SignedTokenService._toBase64Url = function (bytes) {
+        return this._toBase64(bytes).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+    };
+    SignedTokenService._fromBase64Url = function (value) {
+        if (!/^[A-Za-z0-9_-]*$/.test(value))
+            return null;
+        var base64 = value.replace(/-/g, '+').replace(/_/g, '/');
+        var padding = base64.length % 4 === 0 ? '' : '='.repeat(4 - (base64.length % 4));
+        try {
+            return this._fromBase64("".concat(base64).concat(padding));
+        }
+        catch (_a) {
+            return null;
+        }
+    };
+    SignedTokenService._textEncoder = new TextEncoder();
+    SignedTokenService._textDecoder = new TextDecoder();
+    SignedTokenService._privateKeys = new Map();
+    SignedTokenService._publicKeys = new Map();
+    return SignedTokenService;
+}());
+exports.SignedTokenService = SignedTokenService;

package/dist/common/user-token-service.d.ts

@@ -0,0 +1,11 @@
+import type { UserTokenClaims } from '../models/user-token-claims';
+import type { UserTokenIssueOptions } from '../models/user-token-issue-options';
+import type { UserTokenRequest } from '../models/user-token-request';
+import type { UserTokenSubject } from '../models/user-token-subject';
+import type { UserTokenVerifyOptions } from '../models/user-token-verify-options';
+export declare class UserTokenService {
+    static issue(subject: UserTokenSubject, request: UserTokenRequest, options: UserTokenIssueOptions): Promise<string>;
+    static verify(token: string, request: UserTokenRequest, options: UserTokenVerifyOptions): Promise<UserTokenClaims | null>;
+    private static _isWellFormed;
+    private static _now;
+}

package/dist/common/user-token-service.js

@@ -0,0 +1,115 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserTokenService = void 0;
+var user_token_config_1 = require("./constants/user-token-config");
+var signed_token_service_1 = require("./signed-token-service");
+var UserTokenService = /** @class */ (function () {
+    function UserTokenService() {
+    }
+    UserTokenService.issue = function (subject, request, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var issuedAt, lifetime, claims;
+            return __generator(this, function (_a) {
+                issuedAt = this._now();
+                lifetime = typeof options.lifetimeSeconds === 'number'
+                    ? Math.min(options.lifetimeSeconds, user_token_config_1.UserTokenConfig.maxLifetimeSeconds)
+                    : user_token_config_1.UserTokenConfig.defaultLifetimeSeconds;
+                claims = {
+                    iss: options.issuer,
+                    aud: options.audience,
+                    sub: subject.id,
+                    email: subject.email.trim().toLowerCase(),
+                    name: subject.displayName,
+                    htm: request.method.toUpperCase(),
+                    htu: request.path,
+                    iat: issuedAt,
+                    exp: issuedAt + lifetime,
+                    jti: crypto.randomUUID(),
+                };
+                return [2 /*return*/, signed_token_service_1.SignedTokenService.sign(claims, options.privateKey)];
+            });
+        });
+    };
+    UserTokenService.verify = function (token, request, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var claims, now, maxLifetime;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, signed_token_service_1.SignedTokenService.verify(token, options.publicKeys)];
+                    case 1:
+                        claims = _a.sent();
+                        if (claims === null || !this._isWellFormed(claims))
+                            return [2 /*return*/, null];
+                        now = this._now();
+                        maxLifetime = typeof options.maxLifetimeSeconds === 'number'
+                            ? options.maxLifetimeSeconds
+                            : user_token_config_1.UserTokenConfig.maxLifetimeSeconds;
+                        if (claims.iss !== options.issuer ||
+                            claims.aud !== options.audience ||
+                            claims.htm !== request.method.toUpperCase() ||
+                            claims.htu !== request.path ||
+                            claims.iat > now + user_token_config_1.UserTokenConfig.clockSkewSeconds ||
+                            claims.exp <= now - user_token_config_1.UserTokenConfig.clockSkewSeconds ||
+                            claims.exp - claims.iat > maxLifetime)
+                            return [2 /*return*/, null];
+                        return [2 /*return*/, claims];
+                }
+            });
+        });
+    };
+    UserTokenService._isWellFormed = function (claims) {
+        return (typeof claims.iss === 'string' &&
+            typeof claims.aud === 'string' &&
+            typeof claims.sub === 'string' &&
+            typeof claims.email === 'string' &&
+            claims.email !== '' &&
+            typeof claims.name === 'string' &&
+            typeof claims.htm === 'string' &&
+            typeof claims.htu === 'string' &&
+            typeof claims.iat === 'number' &&
+            typeof claims.exp === 'number' &&
+            typeof claims.jti === 'string' &&
+            claims.jti !== '');
+    };
+    UserTokenService._now = function () {
+        return Math.floor(Date.now() / user_token_config_1.UserTokenConfig.millisecondsPerSecond);
+    };
+    return UserTokenService;
+}());
+exports.UserTokenService = UserTokenService;

package/dist/common/validation-service.d.ts

@@ -0,0 +1,7 @@
+export declare class ValidationService {
+    static isEmail(value: string): boolean;
+    static withProtocol(value: string): string;
+    static isWebUrl(value: string): boolean;
+    static isPhone(value: string, country: string): boolean;
+    static isUuid(value: string): boolean;
+}

package/dist/common/validation-service.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationService = void 0;
+var validation_config_1 = require("./constants/validation-config");
+var phone_service_1 = require("./phone-service");
+var ValidationService = /** @class */ (function () {
+    function ValidationService() {
+    }
+    ValidationService.isEmail = function (value) {
+        return validation_config_1.ValidationConfig.email.test(value.trim());
+    };
+    ValidationService.withProtocol = function (value) {
+        var trimmed = value.trim();
+        if (trimmed === '' || validation_config_1.ValidationConfig.urlProtocolPattern.test(trimmed))
+            return trimmed;
+        return "".concat(validation_config_1.ValidationConfig.urlProtocol).concat(trimmed);
+    };
+    ValidationService.isWebUrl = function (value) {
+        try {
+            var url_1 = new URL(ValidationService.withProtocol(value));
+            return (validation_config_1.ValidationConfig.webProtocols.some(function (protocol) { return protocol === url_1.protocol; }) &&
+                url_1.hostname.includes(validation_config_1.ValidationConfig.hostSeparator));
+        }
+        catch (_a) {
+            return false;
+        }
+    };
+    ValidationService.isPhone = function (value, country) {
+        return value.trim() !== '' && phone_service_1.PhoneService.isValid(value, country);
+    };
+    ValidationService.isUuid = function (value) {
+        return validation_config_1.ValidationConfig.uuid.test(value.trim());
+    };
+    return ValidationService;
+}());
+exports.ValidationService = ValidationService;

package/dist/index.d.ts

@@ -3,5 +3,15 @@ import * as CommonNamespace from './common';
 export declare const Common: typeof CommonNamespace;
 export declare const Client: typeof ClientNamespace;
 export type { EmailPreviewInput } from './models/email-preview-input';
+export type { SignedTokenHeader } from './models/signed-token-header';
+export type { SignedTokenKeyPair } from './models/signed-token-key-pair';
+export type { UserTokenClaims } from './models/user-token-claims';
+export type { UserTokenIssueOptions } from './models/user-token-issue-options';
+export type { UserTokenRequest } from './models/user-token-request';
+export type { UserTokenSubject } from './models/user-token-subject';
+export type { UserTokenVerifyOptions } from './models/user-token-verify-options';
 export type { EncryptedFieldsSpec } from './common/encrypted-fields-service';
 export type { DataKeyPair } from './common/envelope-crypto-service';
+export type { PhoneCountryData } from './models/phone-country-data';
+export type { PhoneDisplayData } from './models/phone-display-data';
+export type { PostalCodeFormatData } from './models/postal-code-format-data';

package/dist/models/phone-country-data.d.ts

@@ -0,0 +1,5 @@
+export interface PhoneCountryData {
+    callingCode: string;
+    code: string;
+    label: string;
+}

package/dist/models/phone-country-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/phone-display-data.d.ts

@@ -0,0 +1,4 @@
+export interface PhoneDisplayData {
+    country: string;
+    national: string;
+}

package/dist/models/phone-display-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/postal-code-format-data.d.ts

@@ -0,0 +1,5 @@
+export interface PostalCodeFormatData {
+    allowed: RegExp;
+    groups: number[];
+    separator: string;
+}

package/dist/models/postal-code-format-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/signed-token-header.d.ts

@@ -0,0 +1,4 @@
+export interface SignedTokenHeader {
+    alg: string;
+    typ: string;
+}

package/dist/models/signed-token-header.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/signed-token-key-pair.d.ts

@@ -0,0 +1,4 @@
+export interface SignedTokenKeyPair {
+    privateKey: string;
+    publicKey: string;
+}

package/dist/models/signed-token-key-pair.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/user-token-claims.d.ts

@@ -0,0 +1,12 @@
+export interface UserTokenClaims {
+    iss: string;
+    aud: string;
+    sub: string;
+    email: string;
+    name: string;
+    htm: string;
+    htu: string;
+    iat: number;
+    exp: number;
+    jti: string;
+}

package/dist/models/user-token-claims.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/user-token-issue-options.d.ts

@@ -0,0 +1,6 @@
+export interface UserTokenIssueOptions {
+    issuer: string;
+    audience: string;
+    privateKey: string;
+    lifetimeSeconds?: number;
+}

package/dist/models/user-token-issue-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/user-token-request.d.ts

@@ -0,0 +1,4 @@
+export interface UserTokenRequest {
+    method: string;
+    path: string;
+}

package/dist/models/user-token-request.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/user-token-subject.d.ts

@@ -0,0 +1,5 @@
+export interface UserTokenSubject {
+    id: string;
+    email: string;
+    displayName: string;
+}

package/dist/models/user-token-subject.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/user-token-verify-options.d.ts

@@ -0,0 +1,6 @@
+export interface UserTokenVerifyOptions {
+    issuer: string;
+    audience: string;
+    publicKeys: string[];
+    maxLifetimeSeconds?: number;
+}

package/dist/models/user-token-verify-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pallasoft/ps-utilities",
-	"version": "2.6.0",
+	"version": "2.8.0",
 	"private": false,
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
@@ -69,7 +69,8 @@
 	"dependencies": {
 		"@esbuild-plugins/tsconfig-paths": "^0.1.2",
 		"dayjs": "^1.11.19",
-		"esbuild": "^0.27.0"
+		"esbuild": "^0.27.0",
+		"libphonenumber-js": "^1.13.14"
 	},
 	"publishConfig": {
 		"access": "public",