zeed 1.3.0 → 1.4.0

package/dist/common/uuid.cjs

@@ -1,2 +1,308 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./time.cjs`),t=require(`../bin-Ce3i6ABn.cjs`),n=require(`./crypto/crypto.cjs`),r=require(`./data/basex.cjs`);function i(){return n.randomUint8Array(16)}function a(e=i()){return r.encodeBase62(e,22)}function o(e){return r.encodeBase62(e,22)}function s(e){return r.decodeBase62(e,16)}function c(e=i()){return r.encodeBase32(e,26)}function l(e){return r.encodeBase32(e,26)}function u(e){return r.decodeBase32(e,16)}function d(){if(typeof crypto<`u`&&crypto.randomUUID!=null)return crypto.randomUUID();let e=n.randomUint8Array(16);return e[6]=e[6]&15|64,e[8]=e[8]&63|128,f(e)}function f(e){let n=t._(e);return`${n.slice(0,8)}-${n.slice(8,12)}-${n.slice(12,16)}-${n.slice(16,20)}-${n.slice(20)}`}function p(e){return t.u(e.replace(/-/g,``))}const m=16e11;function h(e){let t=new Uint8Array(6);for(let n=5;n>=0;n--)t[n]=e&255,e=Math.floor(e/256);return t}function g(){let t=e.getTimestamp()-m,r=new Uint8Array(16);return r.set(h(t),0),r.set(n.randomUint8Array(10),6),r}function _(){return D(g())}function v(e){return y(E(e))}function y(e){return new Date(m+e.slice(0,6).reduce((e,t)=>e*256+t,0))}function b(){let e=n.randomUint8Array(4);return new DataView(e.buffer,e.byteOffset,e.byteLength).getUint32(0,!1)}const x={base62:{uuid:a,uuidDecode:s,uuidEncode:o},base32:{uuid:c,uuidDecode:u,uuidEncode:l},uuidv4:{uuid:d,uuidDecode:p,uuidEncode:f},test:{uuid:()=>A(`test`),uuidDecode:e=>t.v(e),uuidEncode:e=>t.r(e)}};let S=`base62`,C=!1;function w(e,t=!1){e===`test`&&j(`test`),S=e??`base62`,C=t}function T(){return x[S].uuid(C?g():i())}function E(e){return x[S].uuidDecode(e)}function D(e){return x[S].uuidEncode(e)}function O(e){try{return E(e).length===16}catch{}return!1}const k={};function A(e=`id`){return k[e]??=0,`${e}-${k[e]++}`}function j(e=`id`){k[e]=0}let M=0;function N(){return`id-${M++}`}exports.qid=N,exports.setUuidDefaultEncoding=w,exports.suid=_,exports.suidBytes=g,exports.suidBytesDate=y,exports.suidDate=v,exports.uname=A,exports.unameReset=j,exports.uuid=T,exports.uuid32bit=b,exports.uuidB32=c,exports.uuidB62=a,exports.uuidBytes=i,exports.uuidDecode=E,exports.uuidDecodeB32=u,exports.uuidDecodeB62=s,exports.uuidDecodeV4=p,exports.uuidEncode=D,exports.uuidEncodeB32=l,exports.uuidEncodeB62=o,exports.uuidEncodeV4=f,exports.uuidIsValid=O,exports.uuidv4=d;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_common_time = require('./time.cjs');
+const require_bin = require('../bin-Ddaz2lxM.cjs');
+const require_common_crypto_crypto = require('./crypto/crypto.cjs');
+const require_common_data_basex = require('./data/basex.cjs');
+
+//#region src/common/uuid.ts
+const uuidBytesLength = 16;
+/**
+* Generate raw UUID bytes (128 bits / 16 bytes).
+*
+* Uses a cryptographically secure random source provided by
+* `randomUint8Array`.
+*
+* @returns Uint8Array of length 16 with random bytes
+*/
+function uuidBytes() {
+	return require_common_crypto_crypto.randomUint8Array(uuidBytesLength);
+}
+/**
+* Create a Base62-encoded UUID string from the provided bytes or a newly
+* generated random UUID. The result is a compact, URL-safe identifier.
+*
+* @param bytes - optional 16-byte Uint8Array; if omitted a new random UUID is generated
+* @returns Base62 string representation (22 characters)
+*/
+function uuidB62(bytes = uuidBytes()) {
+	return require_common_data_basex.encodeBase62(bytes, 22);
+}
+/**
+* Encode raw UUID bytes to a Base62 string.
+*
+* @param bytes - 16-byte UUID as Uint8Array
+* @returns Base62-encoded string
+*/
+function uuidEncodeB62(bytes) {
+	return require_common_data_basex.encodeBase62(bytes, 22);
+}
+/**
+* Decode a Base62-encoded UUID string into raw bytes.
+*
+* @param uuid - Base62 string
+* @returns 16-byte Uint8Array
+*/
+function uuidDecodeB62(uuid) {
+	return require_common_data_basex.decodeBase62(uuid, uuidBytesLength);
+}
+/**
+* Create a Base32-encoded UUID string from bytes or a new random UUID.
+*
+* @param bytes - optional 16-byte Uint8Array; if omitted a new random UUID is generated
+* @returns Base32 string representation (26 characters)
+*/
+function uuidB32(bytes = uuidBytes()) {
+	return require_common_data_basex.encodeBase32(bytes, 26);
+}
+/**
+* Encode raw UUID bytes to a Base32 string.
+*
+* @param bytes - 16-byte UUID as Uint8Array
+* @returns Base32-encoded string
+*/
+function uuidEncodeB32(bytes) {
+	return require_common_data_basex.encodeBase32(bytes, 26);
+}
+/**
+* Decode a Base32-encoded UUID string into raw bytes.
+*
+* @param uuid - Base32 string
+* @returns 16-byte Uint8Array
+*/
+function uuidDecodeB32(uuid) {
+	return require_common_data_basex.decodeBase32(uuid, uuidBytesLength);
+}
+/**
+* Generate a UUID v4 string.
+*
+* Uses the native `crypto.randomUUID()` if available; otherwise falls back to
+* a random-based implementation using `randomUint8Array`.
+*
+* @returns UUID v4 string in standard 8-4-4-4-12 hex format
+*/
+function uuidv4() {
+	if (typeof crypto !== "undefined" && crypto.randomUUID != null) return crypto.randomUUID();
+	const bytes = require_common_crypto_crypto.randomUint8Array(16);
+	bytes[6] = bytes[6] & 15 | 64;
+	bytes[8] = bytes[8] & 63 | 128;
+	return uuidEncodeV4(bytes);
+}
+/**
+* Encode 16 raw bytes as a UUID v4 formatted string (hex with dashes).
+*
+* @param bytes - 16-byte Uint8Array
+* @returns UUID string (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)
+*/
+function uuidEncodeV4(bytes) {
+	const id = require_bin.toHex(bytes);
+	return `${id.slice(0, 8)}-${id.slice(8, 12)}-${id.slice(12, 16)}-${id.slice(16, 20)}-${id.slice(20)}`;
+}
+/**
+* Decode a UUID v4 string (hex with dashes) into raw bytes.
+*
+* @param uuid - UUID string
+* @returns 16-byte Uint8Array
+*/
+function uuidDecodeV4(uuid) {
+	return require_bin.fromHex(uuid.replace(/-/g, ""));
+}
+/**
+* Sortable unique ID
+* Inspired by https://github.com/rsms/go-uuid
+*
+* Bytes 0-5:  Current time in miliseconds from 2021-06-01T00:00:00Z
+* Bytes 6-15: Random
+*/
+const ReferenceDateInMS = 16e11;
+function longToByteArray(long) {
+	const byteArray = new Uint8Array(6);
+	for (let i = 5; i >= 0; i--) {
+		byteArray[i] = long & 255;
+		long = Math.floor(long / 256);
+	}
+	return byteArray;
+}
+/**
+* Create a sortable unique identifier (SUID) as raw bytes.
+*
+* The first 6 bytes encode a millisecond timestamp offset from an internal
+* reference date to allow lexicographic sorting by creation time. The
+* remaining 10 bytes are random.
+*
+* @returns 16-byte Uint8Array where bytes 0-5 are timestamp and 6-15 are random
+*/
+function suidBytes() {
+	const ms = require_common_time.getTimestamp() - ReferenceDateInMS;
+	const out = new Uint8Array(16);
+	out.set(longToByteArray(ms), 0);
+	out.set(require_common_crypto_crypto.randomUint8Array(10), 6);
+	return out;
+}
+/**
+* Create a sortable unique identifier (SUID) and return it encoded using the
+* currently configured UUID encoding.
+*
+* @returns encoded SUID string
+*/
+function suid() {
+	return uuidEncode(suidBytes());
+}
+/**
+* Extract the creation Date from an encoded SUID string.
+*
+* @param id - encoded SUID
+* @returns Date corresponding to the timestamp component of the SUID
+*/
+function suidDate(id) {
+	return suidBytesDate(uuidDecode(id));
+}
+/**
+* Extract the creation Date from raw SUID bytes.
+*
+* @param id - 16-byte SUID as Uint8Array
+* @returns Date corresponding to the timestamp encoded in bytes 0-5
+*/
+function suidBytesDate(id) {
+	return new Date(ReferenceDateInMS + id.slice(0, 6).reduce((acc, byte) => acc * 256 + byte, 0));
+}
+/**
+* Generate a 32-bit unsigned integer from 4 random bytes.
+*
+* @returns a random 32-bit unsigned integer
+*/
+function uuid32bit() {
+	const bytes = require_common_crypto_crypto.randomUint8Array(4);
+	return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(0, false);
+}
+const mapModes = {
+	base62: {
+		uuid: uuidB62,
+		uuidDecode: uuidDecodeB62,
+		uuidEncode: uuidEncodeB62
+	},
+	base32: {
+		uuid: uuidB32,
+		uuidDecode: uuidDecodeB32,
+		uuidEncode: uuidEncodeB32
+	},
+	uuidv4: {
+		uuid: uuidv4,
+		uuidDecode: uuidDecodeV4,
+		uuidEncode: uuidEncodeV4
+	},
+	test: {
+		uuid: () => uname("test"),
+		uuidDecode: (id) => require_bin.toUint8Array(id),
+		uuidEncode: (bin) => require_bin.Uint8ArrayToString(bin)
+	}
+};
+let _mode = "base62";
+let _sorted = false;
+/**
+* Configure the default encoding and whether generated IDs should be
+* lexicographically sortable.
+*
+* @param mode - encoding mode ('base62' | 'base32' | 'uuidv4' | 'test')
+* @param sorted - when true, `uuid()` will prefer sortable SUIDs
+*/
+function setUuidDefaultEncoding(mode, sorted = false) {
+	if (mode === "test") unameReset("test");
+	_mode = mode ?? "base62";
+	_sorted = sorted;
+}
+/**
+* Generate an identifier using the current encoding mode.
+*
+* If the default encoding is configured with `sorted=true`, this returns a
+* sortable SUID; otherwise a random UUID is returned.
+*
+* @returns encoded identifier string
+*/
+function uuid() {
+	return mapModes[_mode].uuid(_sorted ? suidBytes() : uuidBytes());
+}
+/**
+* Decode an encoded identifier according to the current encoding mode into
+* raw bytes.
+*
+* @param uuid - encoded identifier string
+* @returns raw 16-byte Uint8Array
+*/
+function uuidDecode(uuid) {
+	return mapModes[_mode].uuidDecode(uuid);
+}
+/**
+* Encode raw UUID bytes using the current encoding mode.
+*
+* @param bytes - 16-byte Uint8Array
+* @returns encoded identifier string
+*/
+function uuidEncode(bytes) {
+	return mapModes[_mode].uuidEncode(bytes);
+}
+/**
+* Validate an encoded identifier by attempting to decode it and checking
+* for the expected byte length.
+*
+* @param uuid - encoded identifier string
+* @returns true when valid and decodes to 16 bytes
+*/
+function uuidIsValid(uuid) {
+	try {
+		return uuidDecode(uuid).length === uuidBytesLength;
+	} catch (err) {}
+	return false;
+}
+const _unameCounters = {};
+/**
+* Simple counter-based unique name generator.
+*
+* Returns strings like 'name-0', 'name-1', ... and increments an internal
+* counter per `name`.
+*
+* @param name - base name for the counter (default: 'id')
+* @returns generated unique name
+*/
+function uname(name = "id") {
+	_unameCounters[name] ??= 0;
+	return `${name}-${_unameCounters[name]++}`;
+}
+/** Reset the counter used by `uname` for the given name. */
+function unameReset(name = "id") {
+	_unameCounters[name] = 0;
+}
+let _qid = 0;
+/**
+* Quick global incremental id generator.
+*
+* Returns strings like 'id-0', 'id-1', ... using a single global counter.
+*/
+function qid() {
+	return `id-${_qid++}`;
+}
+
+//#endregion
+exports.qid = qid;
+exports.setUuidDefaultEncoding = setUuidDefaultEncoding;
+exports.suid = suid;
+exports.suidBytes = suidBytes;
+exports.suidBytesDate = suidBytesDate;
+exports.suidDate = suidDate;
+exports.uname = uname;
+exports.unameReset = unameReset;
+exports.uuid = uuid;
+exports.uuid32bit = uuid32bit;
+exports.uuidB32 = uuidB32;
+exports.uuidB62 = uuidB62;
+exports.uuidBytes = uuidBytes;
+exports.uuidDecode = uuidDecode;
+exports.uuidDecodeB32 = uuidDecodeB32;
+exports.uuidDecodeB62 = uuidDecodeB62;
+exports.uuidDecodeV4 = uuidDecodeV4;
+exports.uuidEncode = uuidEncode;
+exports.uuidEncodeB32 = uuidEncodeB32;
+exports.uuidEncodeB62 = uuidEncodeB62;
+exports.uuidEncodeV4 = uuidEncodeV4;
+exports.uuidIsValid = uuidIsValid;
+exports.uuidv4 = uuidv4;
 //# sourceMappingURL=uuid.cjs.map

package/dist/common/uuid.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"uuid.cjs","names":["randomUint8Array","encodeBase62","decodeBase62","encodeBase32","decodeBase32","toHex","fromHex","getTimestamp","toUint8Array","Uint8ArrayToString"],"sources":["../../src/common/uuid.ts"],"sourcesContent":["import { randomUint8Array } from './crypto'\nimport { decodeBase32, decodeBase62, encodeBase32, encodeBase62 } from './data/basex'\nimport { fromHex, toHex, toUint8Array, Uint8ArrayToString } from './data/bin'\nimport { getTimestamp } from './time'\n\n// 128 bit UUID\n\nconst uuidBytesLength = 16\n\n/**\n * Generate raw UUID bytes (128 bits / 16 bytes).\n *\n * Uses a cryptographically secure random source provided by\n * `randomUint8Array`.\n *\n * @returns Uint8Array of length 16 with random bytes\n */\nexport function uuidBytes(): Uint8Array {\n  return randomUint8Array(uuidBytesLength)\n}\n\n// Base62\n\n/**\n * Create a Base62-encoded UUID string from the provided bytes or a newly\n * generated random UUID. The result is a compact, URL-safe identifier.\n *\n * @param bytes - optional 16-byte Uint8Array; if omitted a new random UUID is generated\n * @returns Base62 string representation (22 characters)\n */\nexport function uuidB62(bytes: Uint8Array = uuidBytes()): string {\n  return encodeBase62(bytes, 22)\n}\n\n/**\n * Encode raw UUID bytes to a Base62 string.\n *\n * @param bytes - 16-byte UUID as Uint8Array\n * @returns Base62-encoded string\n */\nexport function uuidEncodeB62(bytes: Uint8Array): string {\n  return encodeBase62(bytes, 22)\n}\n\n/**\n * Decode a Base62-encoded UUID string into raw bytes.\n *\n * @param uuid - Base62 string\n * @returns 16-byte Uint8Array\n */\nexport function uuidDecodeB62(uuid: string): Uint8Array {\n  return decodeBase62(uuid, uuidBytesLength)\n}\n\n// Base32\n\n/**\n * Create a Base32-encoded UUID string from bytes or a new random UUID.\n *\n * @param bytes - optional 16-byte Uint8Array; if omitted a new random UUID is generated\n * @returns Base32 string representation (26 characters)\n */\nexport function uuidB32(bytes: Uint8Array = uuidBytes()): string {\n  return encodeBase32(bytes, 26)\n}\n\n/**\n * Encode raw UUID bytes to a Base32 string.\n *\n * @param bytes - 16-byte UUID as Uint8Array\n * @returns Base32-encoded string\n */\nexport function uuidEncodeB32(bytes: Uint8Array): string {\n  return encodeBase32(bytes, 26)\n}\n\n/**\n * Decode a Base32-encoded UUID string into raw bytes.\n *\n * @param uuid - Base32 string\n * @returns 16-byte Uint8Array\n */\nexport function uuidDecodeB32(uuid: string): Uint8Array {\n  return decodeBase32(uuid, uuidBytesLength)\n}\n\n// UUIDv4\n\n// https://stackoverflow.com/a/2117523/140927\nconst pattern = '10000000-1000-4000-8000-100000000000' // String([1e7] + -1e3 + -4e3 + -8e3 + -1e11)\n\n/**\n * Generate a UUID v4 string.\n *\n * Uses the native `crypto.randomUUID()` if available; otherwise falls back to\n * a random-based implementation using `randomUint8Array`.\n *\n * @returns UUID v4 string in standard 8-4-4-4-12 hex format\n */\nexport function uuidv4(): string {\n  if (typeof crypto !== 'undefined' && crypto.randomUUID != null)\n    return crypto.randomUUID() // native!\n\n  // Fallback: generate 16 random bytes, set version and variant bits per RFC-4122\n  const bytes = randomUint8Array(16)\n  bytes[6] = (bytes[6] & 0x0F) | 0x40 // version 4\n  bytes[8] = (bytes[8] & 0x3F) | 0x80 // variant\n  return uuidEncodeV4(bytes)\n}\n\n/**\n * Encode 16 raw bytes as a UUID v4 formatted string (hex with dashes).\n *\n * @param bytes - 16-byte Uint8Array\n * @returns UUID string (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)\n */\nexport function uuidEncodeV4(bytes: Uint8Array): string {\n  const id = toHex(bytes)\n  return `${id.slice(0, 8)}-${id.slice(8, 12)}-${id.slice(12, 16)}-${id.slice(16, 20)}-${id.slice(20)}` // 10000000 - 1000 - 4000 - 8000 - 100000000000\n}\n\n/**\n * Decode a UUID v4 string (hex with dashes) into raw bytes.\n *\n * @param uuid - UUID string\n * @returns 16-byte Uint8Array\n */\nexport function uuidDecodeV4(uuid: string): Uint8Array {\n  return fromHex(uuid.replace(/-/g, ''))\n}\n\n// Sortable UID\n\n// https://github.com/segmentio/ksuid\n// https://pkg.go.dev/github.com/rsms/go-uuid\n\n/**\n * Sortable unique ID\n * Inspired by https://github.com/rsms/go-uuid\n *\n * Bytes 0-5:  Current time in miliseconds from 2021-06-01T00:00:00Z\n * Bytes 6-15: Random\n */\n\n// 1622505600000 //  new Date('2021-06-01T00:00:00Z').getTime()\nconst ReferenceDateInMS = 1600000000000\n\n// 6 bytes will stay valid until end of time: new Date(1622505600000 + 0xffffffffffff) === Date Sun Jan 01 10941 06:31:50 GMT+0100 (Central European Standard Time)\n\nfunction longToByteArray(long: number) {\n  const byteArray = new Uint8Array(6)\n  for (let i = 5; i >= 0; i--) {\n    byteArray[i] = long & 0xFF\n    long = Math.floor(long / 256)\n  }\n  return byteArray\n}\n\n// function byteArrayToLong(byteArray: number[]): number {\n//   var value = 0\n//   for (var i = byteArray.length - 1; i >= 0; i--) {\n//     value = value * 256 + byteArray[i]\n//   }\n//   return value\n// }\n\n/**\n * Create a sortable unique identifier (SUID) as raw bytes.\n *\n * The first 6 bytes encode a millisecond timestamp offset from an internal\n * reference date to allow lexicographic sorting by creation time. The\n * remaining 10 bytes are random.\n *\n * @returns 16-byte Uint8Array where bytes 0-5 are timestamp and 6-15 are random\n */\nexport function suidBytes(): Uint8Array {\n  const ms = getTimestamp() - ReferenceDateInMS\n  const out = new Uint8Array(16)\n  out.set(longToByteArray(ms), 0)\n  out.set(randomUint8Array(10), 6)\n  return out\n}\n\n/**\n * Create a sortable unique identifier (SUID) and return it encoded using the\n * currently configured UUID encoding.\n *\n * @returns encoded SUID string\n */\nexport function suid(): string {\n  return uuidEncode(suidBytes())\n}\n\n/**\n * Extract the creation Date from an encoded SUID string.\n *\n * @param id - encoded SUID\n * @returns Date corresponding to the timestamp component of the SUID\n */\nexport function suidDate(id: string): Date {\n  return suidBytesDate(uuidDecode(id))\n}\n\n/**\n * Extract the creation Date from raw SUID bytes.\n *\n * @param id - 16-byte SUID as Uint8Array\n * @returns Date corresponding to the timestamp encoded in bytes 0-5\n */\nexport function suidBytesDate(id: Uint8Array): Date {\n  return new Date(\n    ReferenceDateInMS + id.slice(0, 6).reduce((acc, byte) => acc * 256 + byte, 0),\n  )\n}\n\n// 32 bit UUID\n\n/**\n * Generate a 32-bit unsigned integer from 4 random bytes.\n *\n * @returns a random 32-bit unsigned integer\n */\nexport function uuid32bit(): number {\n  const bytes = randomUint8Array(4)\n  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)\n  return view.getUint32(0, false)\n}\n\n// Global Settings\n\nconst mapModes = {\n  base62: {\n    uuid: uuidB62,\n    uuidDecode: uuidDecodeB62,\n    uuidEncode: uuidEncodeB62,\n  },\n  base32: {\n    uuid: uuidB32,\n    uuidDecode: uuidDecodeB32,\n    uuidEncode: uuidEncodeB32,\n  },\n  uuidv4: {\n    uuid: uuidv4,\n    uuidDecode: uuidDecodeV4,\n    uuidEncode: uuidEncodeV4,\n  },\n  test: {\n    uuid: (): string => uname('test'),\n    uuidDecode: (id: string): Uint8Array => toUint8Array(id),\n    uuidEncode: (bin: Uint8Array): string => Uint8ArrayToString(bin),\n  },\n}\n\nlet _mode: keyof typeof mapModes = 'base62'\nlet _sorted = false\n\n/**\n * Configure the default encoding and whether generated IDs should be\n * lexicographically sortable.\n *\n * @param mode - encoding mode ('base62' | 'base32' | 'uuidv4' | 'test')\n * @param sorted - when true, `uuid()` will prefer sortable SUIDs\n */\nexport function setUuidDefaultEncoding(mode?: keyof typeof mapModes, sorted = false) {\n  if (mode === 'test')\n    unameReset('test')\n\n  _mode = mode ?? 'base62'\n  _sorted = sorted\n}\n\n/**\n * Generate an identifier using the current encoding mode.\n *\n * If the default encoding is configured with `sorted=true`, this returns a\n * sortable SUID; otherwise a random UUID is returned.\n *\n * @returns encoded identifier string\n */\nexport function uuid(): string {\n  return mapModes[_mode].uuid(_sorted ? suidBytes() : uuidBytes())\n}\n\n/**\n * Decode an encoded identifier according to the current encoding mode into\n * raw bytes.\n *\n * @param uuid - encoded identifier string\n * @returns raw 16-byte Uint8Array\n */\nexport function uuidDecode(uuid: string): Uint8Array {\n  return mapModes[_mode].uuidDecode(uuid)\n}\n\n/**\n * Encode raw UUID bytes using the current encoding mode.\n *\n * @param bytes - 16-byte Uint8Array\n * @returns encoded identifier string\n */\nexport function uuidEncode(bytes: Uint8Array): string {\n  return mapModes[_mode].uuidEncode(bytes)\n}\n\n/**\n * Validate an encoded identifier by attempting to decode it and checking\n * for the expected byte length.\n *\n * @param uuid - encoded identifier string\n * @returns true when valid and decodes to 16 bytes\n */\nexport function uuidIsValid(uuid: string): boolean {\n  try {\n    const bin = uuidDecode(uuid)\n    return bin.length === uuidBytesLength\n  }\n  catch (err) {\n    // log.warn('Invalid ID:', uuid)\n  }\n  return false\n}\n\n// Simple Counters\n\nconst _unameCounters: Record<string, number> = {}\n\n/**\n * Simple counter-based unique name generator.\n *\n * Returns strings like 'name-0', 'name-1', ... and increments an internal\n * counter per `name`.\n *\n * @param name - base name for the counter (default: 'id')\n * @returns generated unique name\n */\nexport function uname(name = 'id'): string {\n  _unameCounters[name] ??= 0\n\n  return `${name}-${_unameCounters[name]++}`\n}\n\n/** Reset the counter used by `uname` for the given name. */\nexport function unameReset(name = 'id') {\n  _unameCounters[name] = 0\n}\n\nlet _qid = 0\n\n/**\n * Quick global incremental id generator.\n *\n * Returns strings like 'id-0', 'id-1', ... using a single global counter.\n */\nexport function qid(): string {\n  return `id-${_qid++}`\n}\n"],"mappings":"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"}
+{"version":3,"file":"uuid.cjs","names":["randomUint8Array","encodeBase62","decodeBase62","encodeBase32","decodeBase32","toHex","fromHex","getTimestamp","toUint8Array","Uint8ArrayToString"],"sources":["../../src/common/uuid.ts"],"sourcesContent":["import { randomUint8Array } from './crypto'\nimport { decodeBase32, decodeBase62, encodeBase32, encodeBase62 } from './data/basex'\nimport { fromHex, toHex, toUint8Array, Uint8ArrayToString } from './data/bin'\nimport { getTimestamp } from './time'\n\n// 128 bit UUID\n\nconst uuidBytesLength = 16\n\n/**\n * Generate raw UUID bytes (128 bits / 16 bytes).\n *\n * Uses a cryptographically secure random source provided by\n * `randomUint8Array`.\n *\n * @returns Uint8Array of length 16 with random bytes\n */\nexport function uuidBytes(): Uint8Array {\n  return randomUint8Array(uuidBytesLength)\n}\n\n// Base62\n\n/**\n * Create a Base62-encoded UUID string from the provided bytes or a newly\n * generated random UUID. The result is a compact, URL-safe identifier.\n *\n * @param bytes - optional 16-byte Uint8Array; if omitted a new random UUID is generated\n * @returns Base62 string representation (22 characters)\n */\nexport function uuidB62(bytes: Uint8Array = uuidBytes()): string {\n  return encodeBase62(bytes, 22)\n}\n\n/**\n * Encode raw UUID bytes to a Base62 string.\n *\n * @param bytes - 16-byte UUID as Uint8Array\n * @returns Base62-encoded string\n */\nexport function uuidEncodeB62(bytes: Uint8Array): string {\n  return encodeBase62(bytes, 22)\n}\n\n/**\n * Decode a Base62-encoded UUID string into raw bytes.\n *\n * @param uuid - Base62 string\n * @returns 16-byte Uint8Array\n */\nexport function uuidDecodeB62(uuid: string): Uint8Array {\n  return decodeBase62(uuid, uuidBytesLength)\n}\n\n// Base32\n\n/**\n * Create a Base32-encoded UUID string from bytes or a new random UUID.\n *\n * @param bytes - optional 16-byte Uint8Array; if omitted a new random UUID is generated\n * @returns Base32 string representation (26 characters)\n */\nexport function uuidB32(bytes: Uint8Array = uuidBytes()): string {\n  return encodeBase32(bytes, 26)\n}\n\n/**\n * Encode raw UUID bytes to a Base32 string.\n *\n * @param bytes - 16-byte UUID as Uint8Array\n * @returns Base32-encoded string\n */\nexport function uuidEncodeB32(bytes: Uint8Array): string {\n  return encodeBase32(bytes, 26)\n}\n\n/**\n * Decode a Base32-encoded UUID string into raw bytes.\n *\n * @param uuid - Base32 string\n * @returns 16-byte Uint8Array\n */\nexport function uuidDecodeB32(uuid: string): Uint8Array {\n  return decodeBase32(uuid, uuidBytesLength)\n}\n\n// UUIDv4\n\n// https://stackoverflow.com/a/2117523/140927\nconst pattern = '10000000-1000-4000-8000-100000000000' // String([1e7] + -1e3 + -4e3 + -8e3 + -1e11)\n\n/**\n * Generate a UUID v4 string.\n *\n * Uses the native `crypto.randomUUID()` if available; otherwise falls back to\n * a random-based implementation using `randomUint8Array`.\n *\n * @returns UUID v4 string in standard 8-4-4-4-12 hex format\n */\nexport function uuidv4(): string {\n  if (typeof crypto !== 'undefined' && crypto.randomUUID != null)\n    return crypto.randomUUID() // native!\n\n  // Fallback: generate 16 random bytes, set version and variant bits per RFC-4122\n  const bytes = randomUint8Array(16)\n  bytes[6] = (bytes[6] & 0x0F) | 0x40 // version 4\n  bytes[8] = (bytes[8] & 0x3F) | 0x80 // variant\n  return uuidEncodeV4(bytes)\n}\n\n/**\n * Encode 16 raw bytes as a UUID v4 formatted string (hex with dashes).\n *\n * @param bytes - 16-byte Uint8Array\n * @returns UUID string (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)\n */\nexport function uuidEncodeV4(bytes: Uint8Array): string {\n  const id = toHex(bytes)\n  return `${id.slice(0, 8)}-${id.slice(8, 12)}-${id.slice(12, 16)}-${id.slice(16, 20)}-${id.slice(20)}` // 10000000 - 1000 - 4000 - 8000 - 100000000000\n}\n\n/**\n * Decode a UUID v4 string (hex with dashes) into raw bytes.\n *\n * @param uuid - UUID string\n * @returns 16-byte Uint8Array\n */\nexport function uuidDecodeV4(uuid: string): Uint8Array {\n  return fromHex(uuid.replace(/-/g, ''))\n}\n\n// Sortable UID\n\n// https://github.com/segmentio/ksuid\n// https://pkg.go.dev/github.com/rsms/go-uuid\n\n/**\n * Sortable unique ID\n * Inspired by https://github.com/rsms/go-uuid\n *\n * Bytes 0-5:  Current time in miliseconds from 2021-06-01T00:00:00Z\n * Bytes 6-15: Random\n */\n\n// 1622505600000 //  new Date('2021-06-01T00:00:00Z').getTime()\nconst ReferenceDateInMS = 1600000000000\n\n// 6 bytes will stay valid until end of time: new Date(1622505600000 + 0xffffffffffff) === Date Sun Jan 01 10941 06:31:50 GMT+0100 (Central European Standard Time)\n\nfunction longToByteArray(long: number) {\n  const byteArray = new Uint8Array(6)\n  for (let i = 5; i >= 0; i--) {\n    byteArray[i] = long & 0xFF\n    long = Math.floor(long / 256)\n  }\n  return byteArray\n}\n\n// function byteArrayToLong(byteArray: number[]): number {\n//   var value = 0\n//   for (var i = byteArray.length - 1; i >= 0; i--) {\n//     value = value * 256 + byteArray[i]\n//   }\n//   return value\n// }\n\n/**\n * Create a sortable unique identifier (SUID) as raw bytes.\n *\n * The first 6 bytes encode a millisecond timestamp offset from an internal\n * reference date to allow lexicographic sorting by creation time. The\n * remaining 10 bytes are random.\n *\n * @returns 16-byte Uint8Array where bytes 0-5 are timestamp and 6-15 are random\n */\nexport function suidBytes(): Uint8Array {\n  const ms = getTimestamp() - ReferenceDateInMS\n  const out = new Uint8Array(16)\n  out.set(longToByteArray(ms), 0)\n  out.set(randomUint8Array(10), 6)\n  return out\n}\n\n/**\n * Create a sortable unique identifier (SUID) and return it encoded using the\n * currently configured UUID encoding.\n *\n * @returns encoded SUID string\n */\nexport function suid(): string {\n  return uuidEncode(suidBytes())\n}\n\n/**\n * Extract the creation Date from an encoded SUID string.\n *\n * @param id - encoded SUID\n * @returns Date corresponding to the timestamp component of the SUID\n */\nexport function suidDate(id: string): Date {\n  return suidBytesDate(uuidDecode(id))\n}\n\n/**\n * Extract the creation Date from raw SUID bytes.\n *\n * @param id - 16-byte SUID as Uint8Array\n * @returns Date corresponding to the timestamp encoded in bytes 0-5\n */\nexport function suidBytesDate(id: Uint8Array): Date {\n  return new Date(\n    ReferenceDateInMS + id.slice(0, 6).reduce((acc, byte) => acc * 256 + byte, 0),\n  )\n}\n\n// 32 bit UUID\n\n/**\n * Generate a 32-bit unsigned integer from 4 random bytes.\n *\n * @returns a random 32-bit unsigned integer\n */\nexport function uuid32bit(): number {\n  const bytes = randomUint8Array(4)\n  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)\n  return view.getUint32(0, false)\n}\n\n// Global Settings\n\nconst mapModes = {\n  base62: {\n    uuid: uuidB62,\n    uuidDecode: uuidDecodeB62,\n    uuidEncode: uuidEncodeB62,\n  },\n  base32: {\n    uuid: uuidB32,\n    uuidDecode: uuidDecodeB32,\n    uuidEncode: uuidEncodeB32,\n  },\n  uuidv4: {\n    uuid: uuidv4,\n    uuidDecode: uuidDecodeV4,\n    uuidEncode: uuidEncodeV4,\n  },\n  test: {\n    uuid: (): string => uname('test'),\n    uuidDecode: (id: string): Uint8Array => toUint8Array(id),\n    uuidEncode: (bin: Uint8Array): string => Uint8ArrayToString(bin),\n  },\n}\n\nlet _mode: keyof typeof mapModes = 'base62'\nlet _sorted = false\n\n/**\n * Configure the default encoding and whether generated IDs should be\n * lexicographically sortable.\n *\n * @param mode - encoding mode ('base62' | 'base32' | 'uuidv4' | 'test')\n * @param sorted - when true, `uuid()` will prefer sortable SUIDs\n */\nexport function setUuidDefaultEncoding(mode?: keyof typeof mapModes, sorted = false) {\n  if (mode === 'test')\n    unameReset('test')\n\n  _mode = mode ?? 'base62'\n  _sorted = sorted\n}\n\n/**\n * Generate an identifier using the current encoding mode.\n *\n * If the default encoding is configured with `sorted=true`, this returns a\n * sortable SUID; otherwise a random UUID is returned.\n *\n * @returns encoded identifier string\n */\nexport function uuid(): string {\n  return mapModes[_mode].uuid(_sorted ? suidBytes() : uuidBytes())\n}\n\n/**\n * Decode an encoded identifier according to the current encoding mode into\n * raw bytes.\n *\n * @param uuid - encoded identifier string\n * @returns raw 16-byte Uint8Array\n */\nexport function uuidDecode(uuid: string): Uint8Array {\n  return mapModes[_mode].uuidDecode(uuid)\n}\n\n/**\n * Encode raw UUID bytes using the current encoding mode.\n *\n * @param bytes - 16-byte Uint8Array\n * @returns encoded identifier string\n */\nexport function uuidEncode(bytes: Uint8Array): string {\n  return mapModes[_mode].uuidEncode(bytes)\n}\n\n/**\n * Validate an encoded identifier by attempting to decode it and checking\n * for the expected byte length.\n *\n * @param uuid - encoded identifier string\n * @returns true when valid and decodes to 16 bytes\n */\nexport function uuidIsValid(uuid: string): boolean {\n  try {\n    const bin = uuidDecode(uuid)\n    return bin.length === uuidBytesLength\n  }\n  catch (err) {\n    // log.warn('Invalid ID:', uuid)\n  }\n  return false\n}\n\n// Simple Counters\n\nconst _unameCounters: Record<string, number> = {}\n\n/**\n * Simple counter-based unique name generator.\n *\n * Returns strings like 'name-0', 'name-1', ... and increments an internal\n * counter per `name`.\n *\n * @param name - base name for the counter (default: 'id')\n * @returns generated unique name\n */\nexport function uname(name = 'id'): string {\n  _unameCounters[name] ??= 0\n\n  return `${name}-${_unameCounters[name]++}`\n}\n\n/** Reset the counter used by `uname` for the given name. */\nexport function unameReset(name = 'id') {\n  _unameCounters[name] = 0\n}\n\nlet _qid = 0\n\n/**\n * Quick global incremental id generator.\n *\n * Returns strings like 'id-0', 'id-1', ... using a single global counter.\n */\nexport function qid(): string {\n  return `id-${_qid++}`\n}\n"],"mappings":"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"}

package/dist/common/uuid.mjs

@@ -1,2 +1,285 @@
-import{getTimestamp as e}from"./time.mjs";import{_ as t,r as n,u as r,v as i}from"../bin-SPdenYkw.mjs";import{randomUint8Array as a}from"./crypto/crypto.mjs";import{decodeBase32 as o,decodeBase62 as s,encodeBase32 as c,encodeBase62 as l}from"./data/basex.mjs";function u(){return a(16)}function d(e=u()){return l(e,22)}function f(e){return l(e,22)}function p(e){return s(e,16)}function m(e=u()){return c(e,26)}function h(e){return c(e,26)}function g(e){return o(e,16)}function _(){if(typeof crypto<`u`&&crypto.randomUUID!=null)return crypto.randomUUID();let e=a(16);return e[6]=e[6]&15|64,e[8]=e[8]&63|128,v(e)}function v(e){let n=t(e);return`${n.slice(0,8)}-${n.slice(8,12)}-${n.slice(12,16)}-${n.slice(16,20)}-${n.slice(20)}`}function y(e){return r(e.replace(/-/g,``))}const b=16e11;function x(e){let t=new Uint8Array(6);for(let n=5;n>=0;n--)t[n]=e&255,e=Math.floor(e/256);return t}function S(){let t=e()-b,n=new Uint8Array(16);return n.set(x(t),0),n.set(a(10),6),n}function C(){return N(S())}function w(e){return T(M(e))}function T(e){return new Date(b+e.slice(0,6).reduce((e,t)=>e*256+t,0))}function E(){let e=a(4);return new DataView(e.buffer,e.byteOffset,e.byteLength).getUint32(0,!1)}const D={base62:{uuid:d,uuidDecode:p,uuidEncode:f},base32:{uuid:m,uuidDecode:g,uuidEncode:h},uuidv4:{uuid:_,uuidDecode:y,uuidEncode:v},test:{uuid:()=>I(`test`),uuidDecode:e=>i(e),uuidEncode:e=>n(e)}};let O=`base62`,k=!1;function A(e,t=!1){e===`test`&&L(`test`),O=e??`base62`,k=t}function j(){return D[O].uuid(k?S():u())}function M(e){return D[O].uuidDecode(e)}function N(e){return D[O].uuidEncode(e)}function P(e){try{return M(e).length===16}catch{}return!1}const F={};function I(e=`id`){return F[e]??=0,`${e}-${F[e]++}`}function L(e=`id`){F[e]=0}let R=0;function z(){return`id-${R++}`}export{z as qid,A as setUuidDefaultEncoding,C as suid,S as suidBytes,T as suidBytesDate,w as suidDate,I as uname,L as unameReset,j as uuid,E as uuid32bit,m as uuidB32,d as uuidB62,u as uuidBytes,M as uuidDecode,g as uuidDecodeB32,p as uuidDecodeB62,y as uuidDecodeV4,N as uuidEncode,h as uuidEncodeB32,f as uuidEncodeB62,v as uuidEncodeV4,P as uuidIsValid,_ as uuidv4};
+import { getTimestamp } from "./time.mjs";
+import { _ as toHex, r as Uint8ArrayToString, u as fromHex, v as toUint8Array } from "../bin-BAoS4qtm.mjs";
+import { randomUint8Array } from "./crypto/crypto.mjs";
+import { decodeBase32, decodeBase62, encodeBase32, encodeBase62 } from "./data/basex.mjs";
+
+//#region src/common/uuid.ts
+const uuidBytesLength = 16;
+/**
+* Generate raw UUID bytes (128 bits / 16 bytes).
+*
+* Uses a cryptographically secure random source provided by
+* `randomUint8Array`.
+*
+* @returns Uint8Array of length 16 with random bytes
+*/
+function uuidBytes() {
+	return randomUint8Array(uuidBytesLength);
+}
+/**
+* Create a Base62-encoded UUID string from the provided bytes or a newly
+* generated random UUID. The result is a compact, URL-safe identifier.
+*
+* @param bytes - optional 16-byte Uint8Array; if omitted a new random UUID is generated
+* @returns Base62 string representation (22 characters)
+*/
+function uuidB62(bytes = uuidBytes()) {
+	return encodeBase62(bytes, 22);
+}
+/**
+* Encode raw UUID bytes to a Base62 string.
+*
+* @param bytes - 16-byte UUID as Uint8Array
+* @returns Base62-encoded string
+*/
+function uuidEncodeB62(bytes) {
+	return encodeBase62(bytes, 22);
+}
+/**
+* Decode a Base62-encoded UUID string into raw bytes.
+*
+* @param uuid - Base62 string
+* @returns 16-byte Uint8Array
+*/
+function uuidDecodeB62(uuid) {
+	return decodeBase62(uuid, uuidBytesLength);
+}
+/**
+* Create a Base32-encoded UUID string from bytes or a new random UUID.
+*
+* @param bytes - optional 16-byte Uint8Array; if omitted a new random UUID is generated
+* @returns Base32 string representation (26 characters)
+*/
+function uuidB32(bytes = uuidBytes()) {
+	return encodeBase32(bytes, 26);
+}
+/**
+* Encode raw UUID bytes to a Base32 string.
+*
+* @param bytes - 16-byte UUID as Uint8Array
+* @returns Base32-encoded string
+*/
+function uuidEncodeB32(bytes) {
+	return encodeBase32(bytes, 26);
+}
+/**
+* Decode a Base32-encoded UUID string into raw bytes.
+*
+* @param uuid - Base32 string
+* @returns 16-byte Uint8Array
+*/
+function uuidDecodeB32(uuid) {
+	return decodeBase32(uuid, uuidBytesLength);
+}
+/**
+* Generate a UUID v4 string.
+*
+* Uses the native `crypto.randomUUID()` if available; otherwise falls back to
+* a random-based implementation using `randomUint8Array`.
+*
+* @returns UUID v4 string in standard 8-4-4-4-12 hex format
+*/
+function uuidv4() {
+	if (typeof crypto !== "undefined" && crypto.randomUUID != null) return crypto.randomUUID();
+	const bytes = randomUint8Array(16);
+	bytes[6] = bytes[6] & 15 | 64;
+	bytes[8] = bytes[8] & 63 | 128;
+	return uuidEncodeV4(bytes);
+}
+/**
+* Encode 16 raw bytes as a UUID v4 formatted string (hex with dashes).
+*
+* @param bytes - 16-byte Uint8Array
+* @returns UUID string (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)
+*/
+function uuidEncodeV4(bytes) {
+	const id = toHex(bytes);
+	return `${id.slice(0, 8)}-${id.slice(8, 12)}-${id.slice(12, 16)}-${id.slice(16, 20)}-${id.slice(20)}`;
+}
+/**
+* Decode a UUID v4 string (hex with dashes) into raw bytes.
+*
+* @param uuid - UUID string
+* @returns 16-byte Uint8Array
+*/
+function uuidDecodeV4(uuid) {
+	return fromHex(uuid.replace(/-/g, ""));
+}
+/**
+* Sortable unique ID
+* Inspired by https://github.com/rsms/go-uuid
+*
+* Bytes 0-5:  Current time in miliseconds from 2021-06-01T00:00:00Z
+* Bytes 6-15: Random
+*/
+const ReferenceDateInMS = 16e11;
+function longToByteArray(long) {
+	const byteArray = new Uint8Array(6);
+	for (let i = 5; i >= 0; i--) {
+		byteArray[i] = long & 255;
+		long = Math.floor(long / 256);
+	}
+	return byteArray;
+}
+/**
+* Create a sortable unique identifier (SUID) as raw bytes.
+*
+* The first 6 bytes encode a millisecond timestamp offset from an internal
+* reference date to allow lexicographic sorting by creation time. The
+* remaining 10 bytes are random.
+*
+* @returns 16-byte Uint8Array where bytes 0-5 are timestamp and 6-15 are random
+*/
+function suidBytes() {
+	const ms = getTimestamp() - ReferenceDateInMS;
+	const out = new Uint8Array(16);
+	out.set(longToByteArray(ms), 0);
+	out.set(randomUint8Array(10), 6);
+	return out;
+}
+/**
+* Create a sortable unique identifier (SUID) and return it encoded using the
+* currently configured UUID encoding.
+*
+* @returns encoded SUID string
+*/
+function suid() {
+	return uuidEncode(suidBytes());
+}
+/**
+* Extract the creation Date from an encoded SUID string.
+*
+* @param id - encoded SUID
+* @returns Date corresponding to the timestamp component of the SUID
+*/
+function suidDate(id) {
+	return suidBytesDate(uuidDecode(id));
+}
+/**
+* Extract the creation Date from raw SUID bytes.
+*
+* @param id - 16-byte SUID as Uint8Array
+* @returns Date corresponding to the timestamp encoded in bytes 0-5
+*/
+function suidBytesDate(id) {
+	return new Date(ReferenceDateInMS + id.slice(0, 6).reduce((acc, byte) => acc * 256 + byte, 0));
+}
+/**
+* Generate a 32-bit unsigned integer from 4 random bytes.
+*
+* @returns a random 32-bit unsigned integer
+*/
+function uuid32bit() {
+	const bytes = randomUint8Array(4);
+	return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(0, false);
+}
+const mapModes = {
+	base62: {
+		uuid: uuidB62,
+		uuidDecode: uuidDecodeB62,
+		uuidEncode: uuidEncodeB62
+	},
+	base32: {
+		uuid: uuidB32,
+		uuidDecode: uuidDecodeB32,
+		uuidEncode: uuidEncodeB32
+	},
+	uuidv4: {
+		uuid: uuidv4,
+		uuidDecode: uuidDecodeV4,
+		uuidEncode: uuidEncodeV4
+	},
+	test: {
+		uuid: () => uname("test"),
+		uuidDecode: (id) => toUint8Array(id),
+		uuidEncode: (bin) => Uint8ArrayToString(bin)
+	}
+};
+let _mode = "base62";
+let _sorted = false;
+/**
+* Configure the default encoding and whether generated IDs should be
+* lexicographically sortable.
+*
+* @param mode - encoding mode ('base62' | 'base32' | 'uuidv4' | 'test')
+* @param sorted - when true, `uuid()` will prefer sortable SUIDs
+*/
+function setUuidDefaultEncoding(mode, sorted = false) {
+	if (mode === "test") unameReset("test");
+	_mode = mode ?? "base62";
+	_sorted = sorted;
+}
+/**
+* Generate an identifier using the current encoding mode.
+*
+* If the default encoding is configured with `sorted=true`, this returns a
+* sortable SUID; otherwise a random UUID is returned.
+*
+* @returns encoded identifier string
+*/
+function uuid() {
+	return mapModes[_mode].uuid(_sorted ? suidBytes() : uuidBytes());
+}
+/**
+* Decode an encoded identifier according to the current encoding mode into
+* raw bytes.
+*
+* @param uuid - encoded identifier string
+* @returns raw 16-byte Uint8Array
+*/
+function uuidDecode(uuid) {
+	return mapModes[_mode].uuidDecode(uuid);
+}
+/**
+* Encode raw UUID bytes using the current encoding mode.
+*
+* @param bytes - 16-byte Uint8Array
+* @returns encoded identifier string
+*/
+function uuidEncode(bytes) {
+	return mapModes[_mode].uuidEncode(bytes);
+}
+/**
+* Validate an encoded identifier by attempting to decode it and checking
+* for the expected byte length.
+*
+* @param uuid - encoded identifier string
+* @returns true when valid and decodes to 16 bytes
+*/
+function uuidIsValid(uuid) {
+	try {
+		return uuidDecode(uuid).length === uuidBytesLength;
+	} catch (err) {}
+	return false;
+}
+const _unameCounters = {};
+/**
+* Simple counter-based unique name generator.
+*
+* Returns strings like 'name-0', 'name-1', ... and increments an internal
+* counter per `name`.
+*
+* @param name - base name for the counter (default: 'id')
+* @returns generated unique name
+*/
+function uname(name = "id") {
+	_unameCounters[name] ??= 0;
+	return `${name}-${_unameCounters[name]++}`;
+}
+/** Reset the counter used by `uname` for the given name. */
+function unameReset(name = "id") {
+	_unameCounters[name] = 0;
+}
+let _qid = 0;
+/**
+* Quick global incremental id generator.
+*
+* Returns strings like 'id-0', 'id-1', ... using a single global counter.
+*/
+function qid() {
+	return `id-${_qid++}`;
+}
+
+//#endregion
+export { qid, setUuidDefaultEncoding, suid, suidBytes, suidBytesDate, suidDate, uname, unameReset, uuid, uuid32bit, uuidB32, uuidB62, uuidBytes, uuidDecode, uuidDecodeB32, uuidDecodeB62, uuidDecodeV4, uuidEncode, uuidEncodeB32, uuidEncodeB62, uuidEncodeV4, uuidIsValid, uuidv4 };
 //# sourceMappingURL=uuid.mjs.map