@wener/utils 1.1.51 → 1.1.53

package/lib/crypto/pem/pem.test.js

@@ -0,0 +1,104 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    }
+    else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function (key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function (sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    }
+    else {
+        ownKeys(Object(source)).forEach(function (key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+import { expect, test } from "vitest";
+import { ArrayBuffers } from "../../io/ArrayBuffers.js";
+import { PEM } from "./pem.js";
+var decode = PEM.decode, encode = PEM.encode;
+test("pem", function () {
+    var pem = "-----BEGIN RSA PRIVATE KEY-----\nProc-Type: 4,ENCRYPTED\nDEK-Info: DES-EDE3-CBC,ABC\n\nMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw\nMDAwMDAwMDAwMDAwMDAwMA==\n-----END RSA PRIVATE KEY-----\n";
+    var input = "Nice\n".concat(pem, "Hello\n");
+    var out = {
+        block: {
+            type: "RSA PRIVATE KEY",
+            header: {
+                "Proc-Type": "4,ENCRYPTED",
+                "DEK-Info": "DES-EDE3-CBC,ABC"
+            },
+            bytes: ArrayBuffers.from("0".repeat(64))
+        },
+        head: "Nice\n",
+        tail: "Hello\n"
+    };
+    expect(decode(input)).toEqual(out);
+    expect(encode(out.block)).toBe(pem);
+});
+test("cases", function () {
+    for (var _i = 0, _iter = [
+        {
+            type: "RSA PRIVATE KEY",
+            bytes: "Hello"
+        },
+        {
+            type: "RSA PRIVATE KEY",
+            header: {
+                Name: "N-:1/=",
+                Age: "1234"
+            },
+            bytes: ArrayBuffers.from("Nice")
+        }
+    ]; _i < _iter.length; _i++) {
+        var b = _iter[_i];
+        var s = encode(b);
+        var act = decode(s);
+        expect(_object_spread_props(_object_spread({}, act.block), {
+            bytes: ArrayBuffers.toString(act.block.bytes)
+        })).toStrictEqual(_object_spread_props(_object_spread({
+            header: {}
+        }, b), {
+            bytes: ArrayBuffers.toString(b.bytes)
+        }));
+        expect(s).matchSnapshot();
+    }
+});

package/lib/crypto/randomUUIDv7.js

@@ -1,3 +1 @@
 // https://github.com/LiosK/uuidv7/blob/main/src/index.ts
-
-//# sourceMappingURL=randomUUIDv7.js.map

package/lib/crypto/ulid.js

@@ -1,16 +1,50 @@
-import { getRandomValues } from '../web/getRandomValues.js';
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length)
+        len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++)
+        arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr))
+        return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+        return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o)
+        return;
+    if (typeof o === "string")
+        return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor)
+        n = o.constructor.name;
+    if (n === "Map" || n === "Set")
+        return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+        return _array_like_to_array(o, minLen);
+}
+import { getRandomValues } from "../web/getRandomValues.js";
 function createError(message) {
-    const err = new Error(message);
-    err.source = 'ulid';
+    var err = new Error(message);
+    err.source = "ulid";
     return err;
 }
 // These values should NEVER change. If
 // they do, we're no longer making ulids!
-const ENCODING = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'; // Crockford's Base32
-const ENCODING_LEN = ENCODING.length;
-const TIME_MAX = Math.pow(2, 48) - 1;
-const TIME_LEN = 10;
-const RANDOM_LEN = 16;
+var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"; // Crockford's Base32
+var ENCODING_LEN = ENCODING.length;
+var TIME_MAX = Math.pow(2, 48) - 1;
+var TIME_LEN = 10;
+var RANDOM_LEN = 16;
 /**
  * check give {@link str} is a valid ulid
  */ export function isULID(str) {
@@ -27,16 +61,16 @@ function replaceCharAt(str, index, char) {
     return str.substr(0, index) + char + str.substr(index + 1);
 }
 function incrementBase32(str) {
-    let done;
-    let index = str.length;
-    let char;
-    let charIndex;
-    const maxCharIndex = ENCODING_LEN - 1;
-    while(!done && index-- >= 0){
+    var done;
+    var index = str.length;
+    var char;
+    var charIndex;
+    var maxCharIndex = ENCODING_LEN - 1;
+    while (!done && index-- >= 0) {
         char = str[index];
         charIndex = ENCODING.indexOf(char);
         if (charIndex === -1) {
-            throw createError('incorrectly encoded string');
+            throw createError("incorrectly encoded string");
         }
         if (charIndex === maxCharIndex) {
             str = replaceCharAt(str, index, ENCODING[0]);
@@ -44,13 +78,13 @@ function incrementBase32(str) {
         }
         done = replaceCharAt(str, index, ENCODING[charIndex + 1]);
     }
-    if (typeof done === 'string') {
+    if (typeof done === "string") {
         return done;
     }
-    throw createError('cannot increment this string');
+    throw createError("cannot increment this string");
 }
 function randomChar(prng) {
-    let rand = Math.floor(prng() * ENCODING_LEN);
+    var rand = Math.floor(prng() * ENCODING_LEN);
     if (rand === ENCODING_LEN) {
         rand = ENCODING_LEN - 1;
     }
@@ -58,20 +92,20 @@ function randomChar(prng) {
 }
 function encodeTime(now, len) {
     if (isNaN(now)) {
-        throw new Error(`${now} must be a number`);
+        throw new Error("".concat(now, " must be a number"));
     }
     if (now > TIME_MAX) {
-        throw createError(`cannot encode time greater than ${TIME_MAX}`);
+        throw createError("cannot encode time greater than ".concat(TIME_MAX));
     }
     if (now < 0) {
-        throw createError('time must be positive');
+        throw createError("time must be positive");
     }
     if (!Number.isInteger(now)) {
-        throw createError('time must be an integer');
+        throw createError("time must be an integer");
     }
-    let mod;
-    let str = '';
-    for(; len > 0; len--){
+    var mod;
+    var str = "";
+    for (; len > 0; len--) {
         mod = now % ENCODING_LEN;
         str = ENCODING.charAt(mod) + str;
         now = (now - mod) / ENCODING_LEN;
@@ -79,8 +113,8 @@ function encodeTime(now, len) {
     return str;
 }
 function encodeRandom(len, prng) {
-    let str = '';
-    for(; len > 0; len--){
+    var str = "";
+    for (; len > 0; len--) {
         str = randomChar(prng) + str;
     }
     return str;
@@ -91,17 +125,17 @@ function encodeRandom(len, prng) {
  * @throws ULIDError
  */ export function parseULID(id) {
     if (id.length !== TIME_LEN + RANDOM_LEN) {
-        throw createError('malformed ulid');
+        throw createError("malformed ulid");
     }
-    const time = id.substr(0, TIME_LEN).split('').reverse().reduce((carry, char, index)=>{
-        const encodingIndex = ENCODING.indexOf(char);
+    var time = id.substr(0, TIME_LEN).split("").reverse().reduce(function (carry, char, index) {
+        var encodingIndex = ENCODING.indexOf(char);
         if (encodingIndex === -1) {
-            throw createError('invalid character found: ' + char);
+            throw createError("invalid character found: " + char);
         }
         return carry += encodingIndex * Math.pow(ENCODING_LEN, index);
     }, 0);
     if (time > TIME_MAX) {
-        throw createError('malformed ulid, timestamp too large');
+        throw createError("malformed ulid, timestamp too large");
     }
     return {
         timestamp: time,
@@ -109,45 +143,47 @@ function encodeRandom(len, prng) {
     };
 }
 function createPrng() {
-    return ()=>{
-        const buffer = new Uint8Array(1);
+    return function () {
+        var buffer = new Uint8Array(1);
         getRandomValues(buffer);
-        return buffer[0] / 0xff;
+        return buffer[0] / 255;
     };
 }
 /**
  * create a ulid generator
- */ export function createULID({ monotonic = true, random = createPrng(), now = Date.now } = {}) {
+ */ export function createULID() {
+    var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, _ref_monotonic = _ref.monotonic, monotonic = _ref_monotonic === void 0 ? true : _ref_monotonic, _ref_random = _ref.random, random = _ref_random === void 0 ? createPrng() : _ref_random, _ref_now = _ref.now, now = _ref_now === void 0 ? Date.now : _ref_now;
     if (!monotonic) {
         return function ulid(seedTime) {
-            seedTime ||= now();
+            seedTime || (seedTime = now());
             return encodeTime(seedTime, TIME_LEN) + encodeRandom(RANDOM_LEN, random);
         };
     }
-    let lastTime = 0;
-    let lastRandom;
+    var lastTime = 0;
+    var lastRandom;
     return function ulid(seedTime) {
-        seedTime ||= now();
+        seedTime || (seedTime = now());
         if (seedTime <= lastTime && lastRandom) {
-            const incrementedRandom = lastRandom = incrementBase32(lastRandom);
+            var incrementedRandom = lastRandom = incrementBase32(lastRandom);
             return encodeTime(lastTime, TIME_LEN) + incrementedRandom;
         }
         lastTime = seedTime;
-        const newRandom = lastRandom = encodeRandom(RANDOM_LEN, random);
+        var newRandom = lastRandom = encodeRandom(RANDOM_LEN, random);
         return encodeTime(seedTime, TIME_LEN) + newRandom;
     };
 }
 /**
  * default monotonic ulid generator
- */ export let ulid = (...args)=>{
+ */ export var ulid = function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+    }
     if (_real) {
-        return _real(...args);
+        return _real.apply(void 0, _to_consumable_array(args));
     }
     // delay initialize crypto
     _real = createULID();
     ulid = _real;
-    return _real(...args);
+    return _real.apply(void 0, _to_consumable_array(args));
 };
-let _real;
-
-//# sourceMappingURL=ulid.js.map
+var _real;

package/lib/crypto/ulid.test.js

@@ -0,0 +1,115 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length)
+        len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++)
+        arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr))
+        return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null)
+        return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+            _arr.push(_s.value);
+            if (i && _arr.length === i)
+                break;
+        }
+    }
+    catch (err) {
+        _d = true;
+        _e = err;
+    }
+    finally {
+        try {
+            if (!_n && _i["return"] != null)
+                _i["return"]();
+        }
+        finally {
+            if (_d)
+                throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o)
+        return;
+    if (typeof o === "string")
+        return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor)
+        n = o.constructor.name;
+    if (n === "Map" || n === "Set")
+        return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+        return _array_like_to_array(o, minLen);
+}
+import { expect, test } from "vitest";
+import { randomUUID } from "../web/randomUUID.js";
+import { createULID, isULID, parseULID, ulid } from "./ulid.js";
+test("isULID", function () {
+    for (var _i = 0, _iter = [
+        [
+            undefined,
+            false
+        ],
+        [
+            null,
+            false
+        ],
+        [
+            "",
+            false
+        ],
+        [
+            randomUUID(),
+            false
+        ],
+        [
+            ulid(),
+            true
+        ]
+    ]; _i < _iter.length; _i++) {
+        var _iter__i = _sliced_to_array(_iter[_i], 2), a = _iter__i[0], b = _iter__i[1];
+        expect(isULID(a), "".concat(a, " -> ").concat(b)).toEqual(b);
+    }
+});
+test("ulid", function () {
+    // monotonic
+    {
+        var lastTime = 0;
+        var ulid = createULID({
+            now: function () {
+                lastTime || (lastTime = Date.now());
+                return lastTime;
+            }
+        });
+        var ulid1 = ulid();
+        expect(parseULID(ulid1).timestamp).toBe(lastTime);
+        expect(isULID(ulid1), ulid1).toBeTruthy();
+        var ulid2 = ulid();
+        expect(ulid1 < ulid2).toBeTruthy();
+        expect(isULID(ulid2), ulid2).toBeTruthy();
+        expect(parseULID(ulid2).timestamp).toBe(lastTime);
+    }
+    {
+        var next = createULID();
+        expect(isULID(next().toLowerCase())).toBeTruthy();
+        expect(isULID("ttttttttttrrrrrrrrrrrrrrrr")).toBeTruthy();
+    }
+});

package/lib/emitter/types.js

@@ -1,3 +1 @@
 export { };
-
-//# sourceMappingURL=types.js.map