@wener/common 1.0.4 → 2.0.1

package/lib/password/PHC.js

@@ -1,31 +1,44 @@
-import { ArrayBuffers } from "@wener/utils";
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+import { ArrayBuffers } from '@wener/utils';
 (function(PHC) {
     // https://github.com/simonepri/phc-format/blob/master/index.js
-    const idRegex = /^[a-z0-9-]{1,32}$/;
-    const nameRegex = /^[a-z0-9-]{1,32}$/;
-    const valueRegex = /^[a-zA-Z0-9/+.-]+$/;
-    const b64Regex = /^([a-zA-Z0-9/+.-]+|)$/;
-    const decimalRegex = /^((-)?[1-9]\d*|0)$/;
-    const versionRegex = /^v=(\d+)$/;
-    const fromBase64 = ArrayBuffers.fromBase64;
-    const toBase64 = ArrayBuffers.toBase64;
-    const isBuffer = (v)=>{
-        return v instanceof Uint8Array;
+    var idRegex = /^[a-z0-9-]{1,32}$/;
+    var nameRegex = /^[a-z0-9-]{1,32}$/;
+    var valueRegex = /^[a-zA-Z0-9/+.-]+$/;
+    var b64Regex = /^([a-zA-Z0-9/+.-]+|)$/;
+    var decimalRegex = /^((-)?[1-9]\d*|0)$/;
+    var versionRegex = /^v=(\d+)$/;
+    var fromBase64 = ArrayBuffers.fromBase64;
+    var toBase64 = ArrayBuffers.toBase64;
+    var isBuffer = function(v) {
+        return _instanceof(v, Uint8Array);
     };
     function objToKeyVal(obj) {
-        return objectKeys(obj).map((k)=>[
+        return objectKeys(obj).map(function(k) {
+            return [
                 k,
                 obj[k]
-            ].join('=')).join(',');
+            ].join('=');
+        }).join(',');
     }
     function keyValtoObj(str) {
-        const obj = {};
-        str.split(',').forEach((ps)=>{
-            const pss = ps.split('=');
+        var obj = {};
+        str.split(',').forEach(function(ps) {
+            var pss = ps.split('=');
             if (pss.length < 2) {
-                throw new TypeError(`params must be in the format name=value`);
+                throw new TypeError("params must be in the format name=value");
             }
-            const key = pss.shift();
+            var key = pss.shift();
             if (key !== undefined) {
                 obj[key] = pss.join('=');
             }
@@ -37,13 +50,15 @@ import { ArrayBuffers } from "@wener/utils";
     }
     function objectValues(object) {
         if (typeof Object.values === 'function') return Object.values(object);
-        return objectKeys(object).map((k)=>object[k]);
+        return objectKeys(object).map(function(k) {
+            return object[k];
+        });
     }
     function serialize(opts) {
-        const fields = [
+        var fields = [
             ''
         ];
-        if (typeof opts !== 'object' || opts === null) {
+        if ((typeof opts === "undefined" ? "undefined" : _type_of(opts)) !== 'object' || opts === null) {
             throw new TypeError('opts must be an object');
         }
         // Identifier Validation
@@ -51,41 +66,47 @@ import { ArrayBuffers } from "@wener/utils";
             throw new TypeError('id must be a string');
         }
         if (!idRegex.test(opts.id)) {
-            throw new TypeError(`id must satisfy ${idRegex}`);
+            throw new TypeError("id must satisfy ".concat(idRegex));
         }
         fields.push(opts.id);
         if (typeof opts.version !== 'undefined') {
             if (typeof opts.version !== 'number' || opts.version < 0 || !Number.isInteger(opts.version)) {
                 throw new TypeError('version must be a positive integer number');
             }
-            fields.push(`v=${opts.version}`);
+            fields.push("v=".concat(opts.version));
         }
         // Parameters Validation
         if (typeof opts.params !== 'undefined') {
-            if (typeof opts.params !== 'object' || opts.params === null) {
+            if (_type_of(opts.params) !== 'object' || opts.params === null) {
                 throw new TypeError('params must be an object');
             }
-            const pk = objectKeys(opts.params);
-            if (!pk.every((p)=>nameRegex.test(p.toString()))) {
-                throw new TypeError(`params names must satisfy ${nameRegex}`);
+            var pk = objectKeys(opts.params);
+            if (!pk.every(function(p) {
+                return nameRegex.test(p.toString());
+            })) {
+                throw new TypeError("params names must satisfy ".concat(nameRegex));
             }
             // Convert Numbers into Numeric Strings and Buffers into B64 encoded strings.
-            pk.forEach((k)=>{
-                const value = opts.params[k];
+            pk.forEach(function(k) {
+                var value = opts.params[k];
                 if (typeof value === 'number') {
                     opts.params[k] = value.toString();
-                } else if (value instanceof Uint8Array) {
+                } else if (_instanceof(value, Uint8Array)) {
                     opts.params[k] = toBase64(value).split('=')[0];
                 }
             });
-            const pv = objectValues(opts.params);
-            if (!pv.every((v)=>typeof v === 'string')) {
+            var pv = objectValues(opts.params);
+            if (!pv.every(function(v) {
+                return typeof v === 'string';
+            })) {
                 throw new TypeError('params values must be strings');
             }
-            if (!pv.every((v)=>valueRegex.test(v))) {
-                throw new TypeError(`params values must satisfy ${valueRegex}`);
+            if (!pv.every(function(v) {
+                return valueRegex.test(v);
+            })) {
+                throw new TypeError("params values must satisfy ".concat(valueRegex));
             }
-            const strpar = objToKeyVal(opts.params);
+            var strpar = objToKeyVal(opts.params);
             fields.push(strpar);
         }
         if (typeof opts.salt !== 'undefined') {
@@ -103,7 +124,7 @@ import { ArrayBuffers } from "@wener/utils";
             }
         }
         // Create the PHC formatted string
-        const phcstr = fields.join('$');
+        var phcstr = fields.join('$');
         return phcstr;
     }
     /**
@@ -118,58 +139,63 @@ import { ArrayBuffers } from "@wener/utils";
         if (phcstr[0] !== '$') {
             throw new TypeError('pchstr must contain a $ as first char');
         }
-        const fields = phcstr.split('$');
+        var fields = phcstr.split('$');
         // Remove first empty $
         fields.shift();
         // Parse Fields
-        let maxf = 5;
+        var maxf = 5;
         if (!versionRegex.test(fields[1])) maxf--;
         if (fields.length > maxf) {
-            throw new TypeError(`pchstr contains too many fileds: ${fields.length}/${maxf}`);
+            throw new TypeError("pchstr contains too many fileds: ".concat(fields.length, "/").concat(maxf));
         }
         // Parse Identifier
-        const id = fields.shift();
+        var id = fields.shift();
         if (!id || !idRegex.test(id)) {
-            throw new TypeError(`id must satisfy ${idRegex}`);
+            throw new TypeError("id must satisfy ".concat(idRegex));
         }
-        let version;
+        var version;
         // Parse Version
         if (fields[0] && versionRegex.test(fields[0])) {
-            const versionMatch = fields.shift()?.match(versionRegex);
+            var _fields_shift;
+            var versionMatch = (_fields_shift = fields.shift()) === null || _fields_shift === void 0 ? void 0 : _fields_shift.match(versionRegex);
             version = versionMatch ? parseInt(versionMatch[1], 10) : undefined;
         }
-        let hash;
-        let salt;
+        var hash;
+        var salt;
         if (fields[fields.length - 1] && b64Regex.test(fields[fields.length - 1])) {
             if (fields.length > 1 && b64Regex.test(fields[fields.length - 2])) {
                 // Parse Hash
-                const hashStr = fields.pop();
+                var hashStr = fields.pop();
                 if (hashStr) hash = fromBase64(hashStr);
                 // Parse Salt
-                const saltStr = fields.pop();
+                var saltStr = fields.pop();
                 if (saltStr !== undefined) salt = fromBase64(saltStr);
             } else {
                 // Parse Salt
-                const saltStr = fields.pop();
-                if (saltStr !== undefined) salt = fromBase64(saltStr);
+                var saltStr1 = fields.pop();
+                if (saltStr1 !== undefined) salt = fromBase64(saltStr1);
             }
         }
         // Parse Parameters
-        let params;
+        var params;
         if (fields.length > 0) {
-            const parstr = fields.pop();
+            var parstr = fields.pop();
             if (parstr) {
                 params = keyValtoObj(parstr);
-                if (!Object.keys(params).every((p)=>nameRegex.test(p))) {
-                    throw new TypeError(`params names must satisfy ${nameRegex}}`);
+                if (!Object.keys(params).every(function(p) {
+                    return nameRegex.test(p);
+                })) {
+                    throw new TypeError("params names must satisfy ".concat(nameRegex, "}"));
                 }
-                const pv = Object.values(params);
-                if (!pv.every((v)=>valueRegex.test(String(v)))) {
-                    throw new TypeError(`params values must satisfy ${valueRegex}`);
+                var pv = Object.values(params);
+                if (!pv.every(function(v) {
+                    return valueRegex.test(String(v));
+                })) {
+                    throw new TypeError("params values must satisfy ".concat(valueRegex));
                 }
                 // Convert Decimal Strings into Numbers
-                Object.keys(params).forEach((k)=>{
-                    const value = params[k];
+                Object.keys(params).forEach(function(k) {
+                    var value = params[k];
                     if (typeof value === 'string' && decimalRegex.test(value)) {
                         params[k] = parseInt(value, 10);
                     }
@@ -177,11 +203,11 @@ import { ArrayBuffers } from "@wener/utils";
             }
         }
         if (fields.length > 0) {
-            throw new TypeError(`pchstr contains unrecognized fileds: ${fields}`);
+            throw new TypeError("pchstr contains unrecognized fileds: ".concat(fields));
         }
         // Build the output object
-        const phcobj = {
-            id
+        var phcobj = {
+            id: id
         };
         if (version !== undefined) phcobj.version = version;
         if (params) phcobj.params = params;
@@ -196,5 +222,3 @@ import { ArrayBuffers } from "@wener/utils";
 	 */ PHC.deserialize = deserialize;
 })(PHC || (PHC = {}));
 export var PHC;
-
-//# sourceMappingURL=PHC.js.map