core-mb 1.0.0

package/coverage/sorter.js

@@ -0,0 +1,210 @@
+/* eslint-disable */
+var addSorting = (function() {
+    'use strict';
+    var cols,
+        currentSort = {
+            index: 0,
+            desc: false
+        };
+
+    // returns the summary table element
+    function getTable() {
+        return document.querySelector('.coverage-summary');
+    }
+    // returns the thead element of the summary table
+    function getTableHeader() {
+        return getTable().querySelector('thead tr');
+    }
+    // returns the tbody element of the summary table
+    function getTableBody() {
+        return getTable().querySelector('tbody');
+    }
+    // returns the th element for nth column
+    function getNthColumn(n) {
+        return getTableHeader().querySelectorAll('th')[n];
+    }
+
+    function onFilterInput() {
+        const searchValue = document.getElementById('fileSearch').value;
+        const rows = document.getElementsByTagName('tbody')[0].children;
+
+        // Try to create a RegExp from the searchValue. If it fails (invalid regex),
+        // it will be treated as a plain text search
+        let searchRegex;
+        try {
+            searchRegex = new RegExp(searchValue, 'i'); // 'i' for case-insensitive
+        } catch (error) {
+            searchRegex = null;
+        }
+
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            let isMatch = false;
+
+            if (searchRegex) {
+                // If a valid regex was created, use it for matching
+                isMatch = searchRegex.test(row.textContent);
+            } else {
+                // Otherwise, fall back to the original plain text search
+                isMatch = row.textContent
+                    .toLowerCase()
+                    .includes(searchValue.toLowerCase());
+            }
+
+            row.style.display = isMatch ? '' : 'none';
+        }
+    }
+
+    // loads the search box
+    function addSearchBox() {
+        var template = document.getElementById('filterTemplate');
+        var templateClone = template.content.cloneNode(true);
+        templateClone.getElementById('fileSearch').oninput = onFilterInput;
+        template.parentElement.appendChild(templateClone);
+    }
+
+    // loads all columns
+    function loadColumns() {
+        var colNodes = getTableHeader().querySelectorAll('th'),
+            colNode,
+            cols = [],
+            col,
+            i;
+
+        for (i = 0; i < colNodes.length; i += 1) {
+            colNode = colNodes[i];
+            col = {
+                key: colNode.getAttribute('data-col'),
+                sortable: !colNode.getAttribute('data-nosort'),
+                type: colNode.getAttribute('data-type') || 'string'
+            };
+            cols.push(col);
+            if (col.sortable) {
+                col.defaultDescSort = col.type === 'number';
+                colNode.innerHTML =
+                    colNode.innerHTML + '<span class="sorter"></span>';
+            }
+        }
+        return cols;
+    }
+    // attaches a data attribute to every tr element with an object
+    // of data values keyed by column name
+    function loadRowData(tableRow) {
+        var tableCols = tableRow.querySelectorAll('td'),
+            colNode,
+            col,
+            data = {},
+            i,
+            val;
+        for (i = 0; i < tableCols.length; i += 1) {
+            colNode = tableCols[i];
+            col = cols[i];
+            val = colNode.getAttribute('data-value');
+            if (col.type === 'number') {
+                val = Number(val);
+            }
+            data[col.key] = val;
+        }
+        return data;
+    }
+    // loads all row data
+    function loadData() {
+        var rows = getTableBody().querySelectorAll('tr'),
+            i;
+
+        for (i = 0; i < rows.length; i += 1) {
+            rows[i].data = loadRowData(rows[i]);
+        }
+    }
+    // sorts the table using the data for the ith column
+    function sortByIndex(index, desc) {
+        var key = cols[index].key,
+            sorter = function(a, b) {
+                a = a.data[key];
+                b = b.data[key];
+                return a < b ? -1 : a > b ? 1 : 0;
+            },
+            finalSorter = sorter,
+            tableBody = document.querySelector('.coverage-summary tbody'),
+            rowNodes = tableBody.querySelectorAll('tr'),
+            rows = [],
+            i;
+
+        if (desc) {
+            finalSorter = function(a, b) {
+                return -1 * sorter(a, b);
+            };
+        }
+
+        for (i = 0; i < rowNodes.length; i += 1) {
+            rows.push(rowNodes[i]);
+            tableBody.removeChild(rowNodes[i]);
+        }
+
+        rows.sort(finalSorter);
+
+        for (i = 0; i < rows.length; i += 1) {
+            tableBody.appendChild(rows[i]);
+        }
+    }
+    // removes sort indicators for current column being sorted
+    function removeSortIndicators() {
+        var col = getNthColumn(currentSort.index),
+            cls = col.className;
+
+        cls = cls.replace(/ sorted$/, '').replace(/ sorted-desc$/, '');
+        col.className = cls;
+    }
+    // adds sort indicators for current column being sorted
+    function addSortIndicators() {
+        getNthColumn(currentSort.index).className += currentSort.desc
+            ? ' sorted-desc'
+            : ' sorted';
+    }
+    // adds event listeners for all sorter widgets
+    function enableUI() {
+        var i,
+            el,
+            ithSorter = function ithSorter(i) {
+                var col = cols[i];
+
+                return function() {
+                    var desc = col.defaultDescSort;
+
+                    if (currentSort.index === i) {
+                        desc = !currentSort.desc;
+                    }
+                    sortByIndex(i, desc);
+                    removeSortIndicators();
+                    currentSort.index = i;
+                    currentSort.desc = desc;
+                    addSortIndicators();
+                };
+            };
+        for (i = 0; i < cols.length; i += 1) {
+            if (cols[i].sortable) {
+                // add the click event handler on the th so users
+                // dont have to click on those tiny arrows
+                el = getNthColumn(i).querySelector('.sorter').parentElement;
+                if (el.addEventListener) {
+                    el.addEventListener('click', ithSorter(i));
+                } else {
+                    el.attachEvent('onclick', ithSorter(i));
+                }
+            }
+        }
+    }
+    // adds sorting functionality to the UI
+    return function() {
+        if (!getTable()) {
+            return;
+        }
+        cols = loadColumns();
+        loadData();
+        addSearchBox();
+        addSortIndicators();
+        enableUI();
+    };
+})();
+
+window.addEventListener('load', addSorting);

package/dist/aes.helper.d.ts

@@ -0,0 +1,6 @@
+export type PhoneCipherRecord = {
+    ciphertext: string;
+    iv: string;
+    authTag: string;
+    hmacIndex: string;
+};

package/dist/aes.helper.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto = __importStar(require("crypto"));
+const aesKeyB64 = process.env.PHONE_AES_KEY;
+const hmacKeyB64 = process.env.PHONE_HMAC_KEY;
+if (!aesKeyB64 || !hmacKeyB64) {
+    throw new Error("PHONE_AES_KEY and PHONE_HMAC_KEY must be set (base64-encoded).");
+}
+const aesKey = Buffer.from(aesKeyB64, "base64");
+const hmacKey = Buffer.from(hmacKeyB64, "base64");
+/** Normalize to a consistent representation (approx. E.164-like):
+ * - Keep leading '+' if present
+ * - Remove spaces, dashes, parentheses
+ * - Remove any non-digit characters except leading '+'
+ * - You can adapt to your locale/validation as needed
+ */
+function normalize(phoneRaw) {
+    if (!phoneRaw)
+        return "";
+    const trimmed = phoneRaw.trim();
+    const hasPlus = trimmed.startsWith("+");
+    const digitsOnly = trimmed.replace(/[^\d]/g, "");
+    return hasPlus ? `+${digitsOnly}` : digitsOnly; // store either "+855123..." or "0123..."
+}
+/** Create an HMAC index for lookups without revealing the number.
+ * Store this alongside the encrypted data and index it in the DB.
+ */
+function hmacIndex(phoneRaw) {
+    const normalized = normalize(phoneRaw);
+    const h = crypto.createHmac("sha256", hmacKey);
+    h.update(normalized, "utf8");
+    return h.digest("base64");
+}
+/** Encrypt a phone number using AES-256-GCM.
+ * Returns base64-encoded ciphertext, iv and authTag suitable for storage.
+ */
+function encrypt(phoneRaw) {
+    const normalized = normalize(phoneRaw);
+    // 12-byte IV is recommended for GCM
+    const iv = crypto.randomBytes(12);
+    const cipher = crypto.createCipheriv("aes-256-gcm", aesKey, iv);
+    // Optional: bind additional data (AAD), e.g., tenant ID to prevent cross-tenant swaps
+    // cipher.setAAD(Buffer.from(tenantId, 'utf8'));
+    const ciphertextBuf = Buffer.concat([
+        cipher.update(normalized, "utf8"),
+        cipher.final(),
+    ]);
+    const authTag = cipher.getAuthTag();
+    return {
+        ciphertext: ciphertextBuf.toString("base64"),
+        iv: iv.toString("base64"),
+        authTag: authTag.toString("base64"),
+        hmacIndex: hmacIndex(normalized),
+    };
+}
+/** Decrypt a previously stored record. Throws if tampered.
+ * Returns the normalized phone string.
+ */
+function decrypt(record) {
+    const iv = Buffer.from(record.iv, "base64");
+    const authTag = Buffer.from(record.authTag, "base64");
+    const ciphertext = Buffer.from(record.ciphertext, "base64");
+    const decipher = crypto.createDecipheriv("aes-256-gcm", aesKey, iv);
+    // If you used setAAD on encrypt, you MUST set the same AAD here
+    // decipher.setAAD(Buffer.from(tenantId, 'utf8'));
+    decipher.setAuthTag(authTag);
+    const plaintext = Buffer.concat([
+        decipher.update(ciphertext),
+        decipher.final(),
+    ]).toString("utf8");
+    return plaintext; // normalized phone
+}

package/dist/date.helper.js

@@ -0,0 +1 @@
+"use strict";

package/dist/document.helper.js

@@ -0,0 +1 @@
+"use strict";

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./security.helper";

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./security.helper"), exports);

package/dist/logging.helper.js

@@ -0,0 +1 @@
+"use strict";

package/dist/money.helper.js

@@ -0,0 +1 @@
+"use strict";

package/dist/phone.number.helper.d.ts

@@ -0,0 +1,7 @@
+/** Normalize to a consistent representation (approx. E.164-like):
+ * - Keep leading '+' if present
+ * - Remove spaces, dashes, parentheses
+ * - Remove any non-digit characters except leading '+'
+ * - You can adapt to your locale/validation as needed
+ */
+export declare function normalize(phoneRaw: string): string;

package/dist/phone.number.helper.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalize = normalize;
+/** Normalize to a consistent representation (approx. E.164-like):
+ * - Keep leading '+' if present
+ * - Remove spaces, dashes, parentheses
+ * - Remove any non-digit characters except leading '+'
+ * - You can adapt to your locale/validation as needed
+ */
+function normalize(phoneRaw) {
+    if (!phoneRaw)
+        return "";
+    const trimmed = phoneRaw.trim();
+    const hasPlus = trimmed.startsWith("+");
+    const digitsOnly = trimmed.replace(/[^\d]/g, "");
+    return hasPlus ? `+${digitsOnly}` : digitsOnly; // store either "+855123..." or "0123..."
+}

package/dist/security.helper.d.ts

@@ -0,0 +1,16 @@
+export type PhoneCipherRecord = {
+    ciphertext: string;
+    iv: string;
+    authTag: string;
+    hmacIndex: string;
+};
+/** Encrypt a phone number using AES-256-GCM.
+ * Returns base64-encoded ciphertext, iv and authTag suitable for storage.
+ */
+export declare function encrypt(phoneRaw: string): Omit<PhoneCipherRecord, "hmacIndex"> & {
+    hmacIndex: string;
+};
+/** Decrypt a previously stored record. Throws if tampered.
+ * Returns the normalized phone string.
+ */
+export declare function decrypt(record: Pick<PhoneCipherRecord, "ciphertext" | "iv" | "authTag">): string;

package/dist/security.helper.js

@@ -0,0 +1,94 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encrypt = encrypt;
+exports.decrypt = decrypt;
+const crypto = __importStar(require("crypto"));
+const phone_number_helper_1 = require("./phone.number.helper");
+const aesKeyB64 = process.env.PHONE_AES_KEY;
+const hmacKeyB64 = process.env.PHONE_HMAC_KEY;
+if (!aesKeyB64 || !hmacKeyB64) {
+    throw new Error("PHONE_AES_KEY and PHONE_HMAC_KEY must be set (base64-encoded).");
+}
+const aesKey = Buffer.from(aesKeyB64, "base64");
+const hmacKey = Buffer.from(hmacKeyB64, "base64");
+/** Create an HMAC index for lookups without revealing the number.
+ * Store this alongside the encrypted data and index it in the DB.
+ */
+function hmacIndex(phoneRaw) {
+    const normalized = (0, phone_number_helper_1.normalize)(phoneRaw);
+    const h = crypto.createHmac("sha256", hmacKey);
+    h.update(normalized, "utf8");
+    return h.digest("base64");
+}
+/** Encrypt a phone number using AES-256-GCM.
+ * Returns base64-encoded ciphertext, iv and authTag suitable for storage.
+ */
+function encrypt(phoneRaw) {
+    const normalized = (0, phone_number_helper_1.normalize)(phoneRaw);
+    // 12-byte IV is recommended for GCM
+    const iv = crypto.randomBytes(12);
+    const cipher = crypto.createCipheriv("aes-256-gcm", aesKey, iv);
+    // Optional: bind additional data (AAD), e.g., tenant ID to prevent cross-tenant swaps
+    // cipher.setAAD(Buffer.from(tenantId, 'utf8'));
+    const ciphertextBuf = Buffer.concat([
+        cipher.update(normalized, "utf8"),
+        cipher.final(),
+    ]);
+    const authTag = cipher.getAuthTag();
+    return {
+        ciphertext: ciphertextBuf.toString("base64"),
+        iv: iv.toString("base64"),
+        authTag: authTag.toString("base64"),
+        hmacIndex: hmacIndex(normalized),
+    };
+}
+/** Decrypt a previously stored record. Throws if tampered.
+ * Returns the normalized phone string.
+ */
+function decrypt(record) {
+    const iv = Buffer.from(record.iv, "base64");
+    const authTag = Buffer.from(record.authTag, "base64");
+    const ciphertext = Buffer.from(record.ciphertext, "base64");
+    const decipher = crypto.createDecipheriv("aes-256-gcm", aesKey, iv);
+    // If you used setAAD on encrypt, you MUST set the same AAD here
+    // decipher.setAAD(Buffer.from(tenantId, 'utf8'));
+    decipher.setAuthTag(authTag);
+    const plaintext = Buffer.concat([
+        decipher.update(ciphertext),
+        decipher.final(),
+    ]).toString("utf8");
+    return plaintext; // normalized phone
+}

package/dist/validation.helper.js

@@ -0,0 +1 @@
+"use strict";

package/jest.config.js

@@ -0,0 +1,17 @@
+module.exports = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+  setupFiles: ["<rootDir>/jest.setup.ts"],
+  collectCoverage: true, // enable coverage
+  coverageDirectory: "coverage", // output folder
+  coverageReporters: ["text", "lcov", "html"], // text in terminal + HTML report
+  testMatch: ["**/*.spec.ts"], // only run *.spec.ts files
+  reporters: [
+    "default",
+    ["jest-html-reporter", {
+      pageTitle: "Test Report",
+      outputPath: "test-report.html",
+      includeFailureMsg: true
+    }]
+  ]
+};

package/jest.setup.ts

@@ -0,0 +1,2 @@
+import * as dotenv from "dotenv";
+dotenv.config();

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "core-mb",
+  "version": "1.0.0",
+  "description": "Core utility functions for the MB ecosystem in TypeScript",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "coverage": "jest --coverage --ci"
+  },
+  "keywords": [
+    "core",
+    "mb",
+    "ecosystem",
+    "utility",
+    "typescript"
+  ],
+  "author": "Marco Bytes",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^20.19.11",
+    "dotenv": "^17.2.1",
+    "jest": "^30.0.5",
+    "jest-html-reporter": "^4.3.0",
+    "ts-jest": "^29.4.1",
+    "typescript": "^5.9.2"
+  }
+}

package/src/aes.helper.ts

@@ -0,0 +1,101 @@
+import * as crypto from "crypto";
+
+export type PhoneCipherRecord = {
+  // Base64 strings suitable for storage in text columns
+  ciphertext: string; // Encrypted phone number
+  iv: string; // Initialization Vector (nonce) for GCM (12 bytes recommended)
+  authTag: string; // Authentication tag returned by GCM (ensures integrity)
+  hmacIndex: string; // HMAC-SHA256(phoneNormalized) for search/dedup
+};
+
+const aesKeyB64 = process.env.PHONE_AES_KEY;
+const hmacKeyB64 = process.env.PHONE_HMAC_KEY;
+
+if (!aesKeyB64 || !hmacKeyB64) {
+  throw new Error(
+    "PHONE_AES_KEY and PHONE_HMAC_KEY must be set (base64-encoded)."
+  );
+}
+
+const aesKey = Buffer.from(aesKeyB64, "base64");
+const hmacKey = Buffer.from(hmacKeyB64, "base64");
+
+/** Normalize to a consistent representation (approx. E.164-like):
+ * - Keep leading '+' if present
+ * - Remove spaces, dashes, parentheses
+ * - Remove any non-digit characters except leading '+'
+ * - You can adapt to your locale/validation as needed
+ */
+function normalize(phoneRaw: string): string {
+  if (!phoneRaw) return "";
+  const trimmed = phoneRaw.trim();
+  const hasPlus = trimmed.startsWith("+");
+  const digitsOnly = trimmed.replace(/[^\d]/g, "");
+  return hasPlus ? `+${digitsOnly}` : digitsOnly; // store either "+855123..." or "0123..."
+}
+
+/** Create an HMAC index for lookups without revealing the number.
+ * Store this alongside the encrypted data and index it in the DB.
+ */
+function hmacIndex(phoneRaw: string): string {
+  const normalized = normalize(phoneRaw);
+  const h = crypto.createHmac("sha256", hmacKey);
+  h.update(normalized, "utf8");
+  return h.digest("base64");
+}
+
+/** Encrypt a phone number using AES-256-GCM.
+ * Returns base64-encoded ciphertext, iv and authTag suitable for storage.
+ */
+function encrypt(
+  phoneRaw: string
+): Omit<PhoneCipherRecord, "hmacIndex"> & { hmacIndex: string } {
+  const normalized = normalize(phoneRaw);
+
+  // 12-byte IV is recommended for GCM
+  const iv = crypto.randomBytes(12);
+
+  const cipher = crypto.createCipheriv("aes-256-gcm", aesKey, iv);
+
+  // Optional: bind additional data (AAD), e.g., tenant ID to prevent cross-tenant swaps
+  // cipher.setAAD(Buffer.from(tenantId, 'utf8'));
+
+  const ciphertextBuf = Buffer.concat([
+    cipher.update(normalized, "utf8"),
+    cipher.final(),
+  ]);
+
+  const authTag = cipher.getAuthTag();
+
+  return {
+    ciphertext: ciphertextBuf.toString("base64"),
+    iv: iv.toString("base64"),
+    authTag: authTag.toString("base64"),
+    hmacIndex: hmacIndex(normalized),
+  };
+}
+
+/** Decrypt a previously stored record. Throws if tampered.
+ * Returns the normalized phone string.
+ */
+function decrypt(
+  record: Pick<PhoneCipherRecord, "ciphertext" | "iv" | "authTag">
+): string {
+  const iv = Buffer.from(record.iv, "base64");
+  const authTag = Buffer.from(record.authTag, "base64");
+  const ciphertext = Buffer.from(record.ciphertext, "base64");
+
+  const decipher = crypto.createDecipheriv("aes-256-gcm", aesKey, iv);
+
+  // If you used setAAD on encrypt, you MUST set the same AAD here
+  // decipher.setAAD(Buffer.from(tenantId, 'utf8'));
+
+  decipher.setAuthTag(authTag);
+
+  const plaintext = Buffer.concat([
+    decipher.update(ciphertext),
+    decipher.final(),
+  ]).toString("utf8");
+
+  return plaintext; // normalized phone
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./security.helper"