@ix-xs/node-comfort 2.0.0 → 2.1.0

package/src/Id.js

@@ -1,27 +1,33 @@
 "use strict";
 
 /**
- * Unique ids: UUID v4 and v7, ULID, nanoid-style ids, Snowflakes, tokens
- * and short codes. All of them use the secure random generator of
- * `node:crypto`, with no bias.
+ * Unique ids: UUID v4, v5 and v7, ULID, ObjectId, nanoid-style ids,
+ * Snowflakes, tokens and short codes. Random ones use the secure generator
+ * of `node:crypto`, with no bias.
  *
  * @example
- * id.uuidv7();  // "0190a5c4-7c1e-7b2a-9f3e-1c2d3e4f5a6b", sorts by creation time
- * id.nano();    // "V1StGXR8_Z5jdHi6B-myT"
- * id.code();    // "K7QF9X"
- * id.token(32); // for API keys and reset links
+ * id.uuidv7();         // "0190a5c4-7c1e-7b2a-9f3e-1c2d3e4f5a6b", sorts by creation time
+ * id.nano();           // "V1StGXR8_Z5jdHi6B-myT"
+ * id.prefixed("user"); // "user_7Hq2mXc0LrT9aZ4bWk1PdE8s"
+ * id.code();           // "K7QF9X"
+ * id.token(32);        // for API keys and reset links
  */
 
 /** @type {typeof import("node:crypto") | undefined} */
 let _nodeCrypto;
 const _crypto = () => (_nodeCrypto ??= require("node:crypto"));
-const nodeCrypto = require("./Crypto.js");
 
 /**
  * Encodings for `token()`.
  * @typedef {"hex" | "base64" | "base64url" | "base58" | "base32"} TokenEncoding
  */
 
+/**
+ * A namespace for `uuidv5()`: one of the four standard ones, or any UUID of
+ * your own.
+ * @typedef {"dns" | "url" | "oid" | "x500" | (string & {})} UUIDNamespace
+ */
+
 /**
  * Options for `snowflake()` and `parseSnowflake()`.
  * @typedef {object} SnowflakeOptions
@@ -42,32 +48,98 @@ const nodeCrypto = require("./Crypto.js");
 
 const NANO_ALPHABET = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
 const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const BASE62_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+const CODE_ALPHABET = "ABCDEFGHJKMNPQRSTUVWXYZ23456789";
 const CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
 const DISCORD_EPOCH = 1420070400000;
+const MAX_TIME = 2 ** 48 - 1;
+
+/** @type {Record<string, string>} */
+const NAMESPACES = {
+  dns: "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
+  url: "6ba7b811-9dad-11d1-80b4-00c04fd430c8",
+  oid: "6ba7b812-9dad-11d1-80b4-00c04fd430c8",
+  x500: "6ba7b814-9dad-11d1-80b4-00c04fd430c8",
+};
 
-/** @type {Record<string, number>} */
-const _counters = {};
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const UUID_V7 = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const ULID = /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/i;
+const OBJECT_ID = /^[0-9a-f]{24}$/i;
+
+/** @type {string[]} */
+const HEX = [];
+for (let i = 0; i < 256; i++) HEX.push(i.toString(16).padStart(2, "0"));
+
+// Asking the system for random bytes is slow, so they are fetched 4 KB at a
+// time and handed out from there.
+const POOL_SIZE = 4096;
+/** @type {Buffer | undefined} */
+let _pool;
+let _poolAt = POOL_SIZE;
+
+/**
+ * Reserves `count` fresh random bytes in the pool.
+ * @param {number} count At most `POOL_SIZE`.
+ * @returns {number} Where they start.
+ */
+const _take = (count) => {
+  if (_poolAt + count > POOL_SIZE) {
+    _crypto().randomFillSync((_pool ??= Buffer.allocUnsafeSlow(POOL_SIZE)));
+    _poolAt = 0;
+  }
+  const at = _poolAt;
+  _poolAt += count;
+  return at;
+};
 
 /**
- * Secure random characters, with rejection sampling so there's no bias.
- * @param {string} alphabet
  * @param {number} size
- * @returns {string}
+ * @param {string} what
+ */
+const _checkSize = (size, what) => {
+  if (!Number.isInteger(size) || size < 0) throw new RangeError(`${what} must be a whole number, 0 or more, got ${size}`);
+};
+
+/** @type {Map<string, (size: number) => string>} */
+const _samplers = new Map();
+
+/**
+ * A function that draws random characters from an alphabet. Bytes that fall
+ * outside the alphabet are thrown away, so every character is as likely as
+ * the others.
+ *
+ * @param {string} alphabet
+ * @returns {(size: number) => string}
  */
-const _random = (alphabet, size) => {
-  const len = alphabet.length;
+const _sampler = (alphabet) => {
+  const known = _samplers.get(alphabet);
+  if (known) return known;
+  const len = typeof alphabet === "string" ? alphabet.length : 0;
   if (len < 2 || len > 256) throw new RangeError("The alphabet must contain between 2 and 256 characters");
-  const mask = (2 << Math.floor(Math.log2(len - 1))) - 1;
-  const step = Math.ceil((1.6 * mask * size) / len);
-  let out = "";
-  while (out.length < size) {
-    const bytes = _crypto().randomBytes(step);
-    for (let i = 0; i < step && out.length < size; i++) {
-      const index = bytes[i] & mask;
-      if (index < len) out += alphabet[index];
+  const mask = (2 << (31 - Math.clz32((len - 1) | 1))) - 1;
+  /** @type {(size: number) => string} */
+  const sample = (size) => {
+    _checkSize(size, "The size");
+    let out = "";
+    let left = size;
+    while (left > 0) {
+      const count = Math.min(left, POOL_SIZE);
+      const at = _take(count);
+      const pool = /** @type {Buffer} */ (_pool);
+      for (let i = at; i < at + count; i++) {
+        const index = pool[i] & mask;
+        if (index < len) {
+          out += alphabet[index];
+          left--;
+        }
+      }
     }
-  }
-  return out;
+    return out;
+  };
+  if (_samplers.size >= 100) _samplers.clear();
+  _samplers.set(alphabet, sample);
+  return sample;
 };
 
 /**
@@ -104,7 +176,7 @@ const _base32 = (buffer) => {
   let value = 0;
   let out = "";
   for (const byte of buffer) {
-    value = (value << 8) | byte;
+    value = ((value << 8) | byte) & 0xffff;
     bits += 8;
     while (bits >= 5) {
       out += CROCKFORD[(value >>> (bits - 5)) & 31];
@@ -115,6 +187,18 @@ const _base32 = (buffer) => {
   return out;
 };
 
+/**
+ * @param {number | Date | undefined} time
+ * @param {string} what
+ * @returns {number | undefined}
+ */
+const _time = (time, what) => {
+  if (time === undefined) return undefined;
+  const ms = +time;
+  if (!Number.isInteger(ms) || ms < 0 || ms > MAX_TIME) throw new RangeError(`${what}: the time must be a date or a timestamp in ms, got ${String(time)}`);
+  return ms;
+};
+
 /**
  * A random UUID (version 4). For ids that sort by date, see `uuidv7()`.
  *
@@ -127,14 +211,41 @@ function uuid() {
   return _crypto().randomUUID();
 }
 
+/**
+ * A UUID v5: the same name in the same namespace always gives the same id.
+ * Use it to derive a stable id from something you already have, like a URL
+ * or an email, without storing a mapping.
+ *
+ * @example
+ * id.uuidv5("example.com", "dns");          // "cfbff0d1-9375-5685-968c-48ce8b15ae17", every time
+ * id.uuidv5("https://example.com/a", "url");
+ * id.uuidv5("ada@example.com", MY_APP_NAMESPACE); // any UUID works as a namespace
+ *
+ * @param {string | Buffer | Uint8Array} name
+ * @param {UUIDNamespace} namespace `"dns"`, `"url"`, `"oid"`, `"x500"` or a UUID.
+ * @returns {string}
+ */
+function uuidv5(name, namespace) {
+  const space = Object.hasOwn(NAMESPACES, namespace) ? NAMESPACES[namespace] : namespace;
+  if (typeof space !== "string" || !UUID.test(space)) {
+    throw new TypeError(`uuidv5(): the namespace must be "dns", "url", "oid", "x500" or a UUID, got ${String(namespace)}`);
+  }
+  const bytes = _crypto().createHash("sha1").update(Buffer.from(space.replace(/-/g, ""), "hex")).update(name).digest();
+  bytes[6] = (bytes[6] & 0x0f) | 0x50;
+  bytes[8] = (bytes[8] & 0x3f) | 0x80;
+  const hex = bytes.toString("hex", 0, 16);
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
 let _v7LastMs = 0;
 let _v7Counter = 0;
+let _v7Head = "";
 
 /**
  * A UUID v7: it starts with a timestamp, so ids sort by creation time.
  * That keeps database indexes compact, which makes them great primary
  * keys. Ids from the same process always increase, even within a
- * millisecond.
+ * millisecond, and even if the system clock steps back.
  *
  * @example
  * id.uuidv7();               // "0190a5c4-7c1e-7b2a-9f3e-1c2d3e4f5a6b"
@@ -143,66 +254,108 @@ let _v7Counter = 0;
  * @returns {string}
  */
 function uuidv7() {
-  let now = Date.now();
-  if (now <= _v7LastMs) {
-    _v7Counter++;
-    if (_v7Counter > 0xfff) {
-      _v7Counter = 0;
-      _v7LastMs++;
-    }
-    now = _v7LastMs;
+  const now = Date.now();
+  const at = _take(10);
+  const pool = /** @type {Buffer} */ (_pool);
+  if (now > _v7LastMs || _v7Counter === 0xfff) {
+    // A new millisecond, or the counter is used up and we borrow the next one.
+    _v7LastMs = now > _v7LastMs ? now : _v7LastMs + 1;
+    _v7Counter = ((pool[at + 8] << 8) | pool[at + 9]) & 0x7ff;
+    const time = _v7LastMs.toString(16).padStart(12, "0");
+    _v7Head = `${time.slice(0, 8)}-${time.slice(8)}-7`;
   } else {
-    _v7LastMs = now;
-    _v7Counter = _crypto().randomInt(0, 0x800);
+    _v7Counter++;
   }
-  const bytes = _crypto().randomBytes(16);
-  bytes.writeUIntBE(now, 0, 6);
-  bytes[6] = 0x70 | ((_v7Counter >> 8) & 0x0f);
-  bytes[7] = _v7Counter & 0xff;
-  bytes[8] = 0x80 | (bytes[8] & 0x3f);
-  const hex = bytes.toString("hex");
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+  return (
+    `${_v7Head}${HEX[_v7Counter >> 8][1]}${HEX[_v7Counter & 0xff]}-${HEX[0x80 | (pool[at] & 0x3f)]}${HEX[pool[at + 1]]}-` +
+    HEX[pool[at + 2]] + HEX[pool[at + 3]] + HEX[pool[at + 4]] + HEX[pool[at + 5]] + HEX[pool[at + 6]] + HEX[pool[at + 7]]
+  );
 }
 
 let _ulidLastMs = -1;
-/** @type {number[]} */
-let _ulidLastRandom = [];
+let _ulidHead = "";
+const _ulidRandom = new Uint8Array(16);
+
+/**
+ * @param {number} ms
+ * @returns {string}
+ */
+const _ulidTime = (ms) => {
+  let head = "";
+  let left = ms;
+  for (let i = 0; i < 10; i++) {
+    head = CROCKFORD[left % 32] + head;
+    left = Math.floor(left / 32);
+  }
+  return head;
+};
 
 /**
  * A ULID: 26 URL-safe characters that sort by creation time. Ids made in
  * the same millisecond still increase.
  *
  * @example
- * id.ulid();                       // "01HQ3Z8K9V3N5W7Y2XJ4T6R8PB"
- * id.ulid(Date.UTC(2024, 0, 1));   // for a given time
+ * id.ulid();                     // "01HQ3Z8K9V3N5W7Y2XJ4T6R8PB"
+ * id.ulid(Date.UTC(2024, 0, 1)); // for a given time
  *
- * @param {number} [time] Timestamp to encode, in ms. Defaults to now.
+ * @param {number | Date} [time] The moment to encode. Defaults to now.
  * @returns {string}
+ * @throws {RangeError} If the time is not a valid timestamp.
  */
 function ulid(time) {
-  const now = time ?? Date.now();
-  /** @type {number[]} */
-  let random;
-  if (time === undefined && now === _ulidLastMs) {
-    random = [..._ulidLastRandom];
-    let i = random.length - 1;
-    while (i >= 0 && random[i] === 31) random[i--] = 0;
-    if (i < 0) throw new RangeError("ULID overflow: too many ids in the same millisecond");
-    random[i]++;
-  } else {
-    random = [..._crypto().randomBytes(16)].map((b) => b & 31);
+  const given = _time(time, "ulid()");
+  if (given !== undefined) {
+    const at = _take(16);
+    const pool = /** @type {Buffer} */ (_pool);
+    let out = _ulidTime(given);
+    for (let i = at; i < at + 16; i++) out += CROCKFORD[pool[i] & 31];
+    return out;
   }
-  if (time === undefined) {
+  const now = Date.now();
+  if (now > _ulidLastMs) {
     _ulidLastMs = now;
-    _ulidLastRandom = random;
+    _ulidHead = _ulidTime(now);
+    const at = _take(16);
+    const pool = /** @type {Buffer} */ (_pool);
+    for (let i = 0; i < 16; i++) _ulidRandom[i] = pool[at + i] & 31;
+  } else {
+    // Same millisecond, or the clock stepped back: count up from the last id.
+    let i = 15;
+    while (i >= 0 && _ulidRandom[i] === 31) _ulidRandom[i--] = 0;
+    if (i < 0) throw new RangeError("ULID overflow: too many ids in the same millisecond");
+    _ulidRandom[i]++;
   }
-  let t = now;
-  let head = "";
-  for (let i = 0; i < 10; i++) {
-    head = CROCKFORD[t % 32] + head;
-    t = Math.floor(t / 32);
+  let out = _ulidHead;
+  for (let i = 0; i < 16; i++) out += CROCKFORD[_ulidRandom[i]];
+  return out;
+}
+
+let _oidProcess = "";
+let _oidCounter = 0;
+
+/**
+ * A MongoDB-style ObjectId: 24 hex characters that start with the time, in
+ * seconds, and increase within the process.
+ *
+ * @example
+ * id.objectId();                           // "65f2a9c47b1e4d0c9a3f2b10"
+ * id.timestamp(id.objectId());             // when it was created, to the second
+ * id.objectId(new Date("2024-01-01"));     // for a given time
+ *
+ * @param {number | Date} [time] The moment to encode. Defaults to now.
+ * @returns {string}
+ * @throws {RangeError} If the time is not a valid timestamp.
+ */
+function objectId(time) {
+  if (!_oidProcess) {
+    const at = _take(8);
+    const pool = /** @type {Buffer} */ (_pool);
+    for (let i = at; i < at + 5; i++) _oidProcess += HEX[pool[i]];
+    _oidCounter = (pool[at + 5] << 16) | (pool[at + 6] << 8) | pool[at + 7];
   }
-  return head + random.map((v) => CROCKFORD[v]).join("");
+  const seconds = Math.floor((_time(time, "objectId()") ?? Date.now()) / 1000) % 2 ** 32;
+  _oidCounter = (_oidCounter + 1) & 0xffffff;
+  return seconds.toString(16).padStart(8, "0") + _oidProcess + HEX[_oidCounter >> 16] + HEX[(_oidCounter >> 8) & 0xff] + HEX[_oidCounter & 0xff];
 }
 
 /**
@@ -219,7 +372,7 @@ function ulid(time) {
  * @returns {string}
  */
 function nano(size = 21, alphabet = NANO_ALPHABET) {
-  return _random(alphabet, size);
+  return _sampler(alphabet)(size);
 }
 
 /**
@@ -234,8 +387,26 @@ function nano(size = 21, alphabet = NANO_ALPHABET) {
  * @returns {(size?: number) => string}
  */
 function customAlphabet(alphabet, size = 21) {
-  _random(alphabet, 1);
-  return (length = size) => _random(alphabet, length);
+  const sample = _sampler(alphabet);
+  return (length = size) => sample(length);
+}
+
+/**
+ * A random id with a prefix that says what it identifies, like Stripe's
+ * `cus_...` and `sub_...`. A glance at a log line or a support ticket tells
+ * you what kind of thing the id points to.
+ *
+ * @example
+ * id.prefixed("user");      // "user_7Hq2mXc0LrT9aZ4bWk1PdE8s"
+ * id.prefixed("inv", 12);   // "inv_Q0f8ZrT1bK4m"
+ *
+ * @param {string} prefix
+ * @param {number} [size=24] How many random characters come after the prefix (letters and digits).
+ * @returns {string}
+ */
+function prefixed(prefix, size = 24) {
+  if (typeof prefix !== "string" || !prefix) throw new TypeError("prefixed(): the prefix must be a non-empty string");
+  return `${prefix}_${_sampler(BASE62_ALPHABET)(size)}`;
 }
 
 /**
@@ -251,6 +422,8 @@ function customAlphabet(alphabet, size = 21) {
  * @returns {string}
  */
 function token(bytes = 32, encoding = "hex") {
+  _checkSize(bytes, "The number of bytes");
+  // Tokens are secrets: their bytes never sit in the shared pool.
   const buffer = _crypto().randomBytes(bytes);
   if (encoding === "base58") return _base58(buffer);
   if (encoding === "base32") return _base32(buffer);
@@ -269,8 +442,8 @@ function token(bytes = 32, encoding = "hex") {
  * @param {string} [alphabet="ABCDEFGHJKMNPQRSTUVWXYZ23456789"]
  * @returns {string}
  */
-function code(length = 6, alphabet = "ABCDEFGHJKMNPQRSTUVWXYZ23456789") {
-  return _random(alphabet, length);
+function code(length = 6, alphabet = CODE_ALPHABET) {
+  return _sampler(alphabet)(length);
 }
 
 let _snowflakeLastMs = 0;
@@ -285,6 +458,7 @@ let _snowflakeIncrement = 0;
  *
  * @param {SnowflakeOptions} [options]
  * @returns {string}
+ * @throws {RangeError} If the epoch is in the future.
  */
 function snowflake(options = {}) {
   const epoch = options.epoch ?? DISCORD_EPOCH;
@@ -297,9 +471,9 @@ function snowflake(options = {}) {
     _snowflakeLastMs = now;
     _snowflakeIncrement = 0;
   }
-  const worker = BigInt((options.workerId ?? 0) & 31);
-  const proc = BigInt((options.processId ?? process.pid) & 31);
-  return ((BigInt(now - epoch) << 22n) | (worker << 17n) | (proc << 12n) | BigInt(_snowflakeIncrement)).toString();
+  if (!(now >= epoch)) throw new RangeError(`snowflake(): the epoch must be a timestamp in the past, got ${epoch}`);
+  const low = (((options.workerId ?? 0) & 31) << 17) | (((options.processId ?? process.pid) & 31) << 12) | _snowflakeIncrement;
+  return ((BigInt(now - epoch) << 22n) | BigInt(low)).toString();
 }
 
 /**
@@ -311,42 +485,49 @@ function snowflake(options = {}) {
  * @param {string | bigint} id
  * @param {SnowflakeOptions} [options] Use the epoch it was created with.
  * @returns {ParsedSnowflake}
+ * @throws {TypeError} If the id is not a string of digits or a bigint.
  */
 function parseSnowflake(id, options = {}) {
+  if (typeof id !== "bigint" && !(typeof id === "string" && /^\d{1,20}$/.test(id))) {
+    throw new TypeError(`parseSnowflake(): expected a string of digits or a bigint, got ${typeof id === "string" ? JSON.stringify(id) : typeof id}`);
+  }
   const value = BigInt(id);
+  if (value < 0n) throw new TypeError("parseSnowflake(): a Snowflake can't be negative");
+  const low = Number(value & 0x3fffffn);
   const timestamp = Number(value >> 22n) + (options.epoch ?? DISCORD_EPOCH);
   return {
     date: new Date(timestamp),
     timestamp,
-    workerId: Number((value >> 17n) & 31n),
-    processId: Number((value >> 12n) & 31n),
-    increment: Number(value & 0xfffn),
+    workerId: (low >> 17) & 31,
+    processId: (low >> 12) & 31,
+    increment: low & 0xfff,
   };
 }
 
 /**
- * When a ULID or a UUID v7 was created.
+ * When a UUID v7, a ULID or an ObjectId was created.
  *
  * @example
- * id.timestamp(id.ulid()); // now
- * id.timestamp(id.uuid()); // undefined, v4 has no time in it
+ * id.timestamp(id.ulid());     // now
+ * id.timestamp(id.objectId()); // now, to the second
+ * id.timestamp(id.uuid());     // undefined, v4 has no time in it
  *
  * @param {string} value
  * @returns {Date | undefined}
  */
 function timestamp(value) {
   const s = String(value);
-  if (/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(s)) {
-    return new Date(parseInt(s.replace(/-/g, "").slice(0, 12), 16));
-  }
-  if (/^[0-7][0-9A-HJKMNP-TV-Z]{25}$/i.test(s)) {
-    let ms = 0;
-    for (const char of s.slice(0, 10).toUpperCase()) ms = ms * 32 + CROCKFORD.indexOf(char);
-    return new Date(ms);
-  }
-  return undefined;
+  if (s.length === 36) return UUID_V7.test(s) ? new Date(parseInt(s.slice(0, 8) + s.slice(9, 13), 16)) : undefined;
+  if (s.length === 24) return OBJECT_ID.test(s) ? new Date(parseInt(s.slice(0, 8), 16) * 1000) : undefined;
+  if (s.length !== 26 || !ULID.test(s)) return undefined;
+  let ms = 0;
+  for (let i = 0; i < 10; i++) ms = ms * 32 + CROCKFORD.indexOf(s[i].toUpperCase());
+  return new Date(ms);
 }
 
+/** @type {Map<string, number>} */
+const _counters = new Map();
+
 /**
  * Readable sequential ids like `"user-1"`, `"user-2"`, counted per prefix.
  * Only unique within the current process; handy in logs and tests.
@@ -359,8 +540,9 @@ function timestamp(value) {
  * @returns {string}
  */
 function seq(prefix = "") {
-  _counters[prefix] = (_counters[prefix] ?? 0) + 1;
-  return prefix ? `${prefix}-${_counters[prefix]}` : String(_counters[prefix]);
+  const next = (_counters.get(prefix) ?? 0) + 1;
+  _counters.set(prefix, next);
+  return prefix ? `${prefix}-${next}` : String(next);
 }
 
 /**
@@ -372,7 +554,7 @@ function seq(prefix = "") {
  * @returns {string}
  */
 function hash(value, options) {
-  return nodeCrypto.hash(value, options);
+  return require("./Crypto.js").hash(value, options);
 }
 
 /**
@@ -385,7 +567,7 @@ function hash(value, options) {
  * @returns {string}
  */
 function hmac(value, secret, options) {
-  return nodeCrypto.hmac(value, secret, options);
+  return require("./Crypto.js").hmac(value, secret, options);
 }
 
 /**
@@ -397,15 +579,18 @@ function hmac(value, secret, options) {
  * @returns {boolean}
  */
 function safeEqual(a, b) {
-  return nodeCrypto.safeEqual(a, b);
+  return require("./Crypto.js").safeEqual(a, b);
 }
 
 module.exports = {
   uuid,
+  uuidv5,
   uuidv7,
   ulid,
+  objectId,
   nano,
   customAlphabet,
+  prefixed,
   token,
   code,
   snowflake,