zeed 1.2.4 → 1.3.1

package/dist/common/uuid.mjs

@@ -0,0 +1,285 @@
+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

package/dist/common/uuid.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid.mjs","names":[],"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/convert-CUvWJlCJ.d.mts

@@ -0,0 +1,23 @@
+//#region src/common/data/convert.d.ts
+/** Like Number.parseFloat, but returning `undefined` instead of `NaN` */
+declare function parseFloat(value: any): number | undefined;
+/** Like Number.parseInt, but returning `undefined` instead of `NaN` */
+declare function parseInt(value: any, radix?: number): number | undefined;
+declare function stringToBoolean(value?: string, defaultValue?: boolean): boolean;
+declare function stringToInteger(value?: string, defaultValue?: number): number;
+declare function stringToFloat(value?: string, defaultValue?: number): number;
+/** `true` is a number != 0, a string stating `true`. Otherwise false. */
+declare function valueToBoolean(value?: any, defaultValue?: boolean): boolean;
+/** Explicitly has to have a `false` value to become `false`, otherwise `true` */
+declare function valueToBooleanNotFalse(value?: any, defaultValue?: boolean): boolean;
+declare function valueToInteger(value?: any, defaultValue?: number): number;
+declare function valueToFloat(value?: any, defaultValue?: number): number;
+declare function valueToString(value?: any, defaultValue?: string): string;
+declare const toFloat: typeof valueToFloat;
+declare const toInt: typeof valueToInteger;
+declare const toString: typeof valueToString;
+declare const toBool: typeof valueToBoolean;
+declare function fixBrokenUtf8String(brokenString: string): string;
+//#endregion
+export { stringToFloat as a, toFloat as c, valueToBoolean as d, valueToBooleanNotFalse as f, valueToString as h, stringToBoolean as i, toInt as l, valueToInteger as m, parseFloat as n, stringToInteger as o, valueToFloat as p, parseInt as r, toBool as s, fixBrokenUtf8String as t, toString as u };
+//# sourceMappingURL=convert-CUvWJlCJ.d.mts.map

package/dist/convert-DI3Ak8iz.d.cts

@@ -0,0 +1,23 @@
+//#region src/common/data/convert.d.ts
+/** Like Number.parseFloat, but returning `undefined` instead of `NaN` */
+declare function parseFloat(value: any): number | undefined;
+/** Like Number.parseInt, but returning `undefined` instead of `NaN` */
+declare function parseInt(value: any, radix?: number): number | undefined;
+declare function stringToBoolean(value?: string, defaultValue?: boolean): boolean;
+declare function stringToInteger(value?: string, defaultValue?: number): number;
+declare function stringToFloat(value?: string, defaultValue?: number): number;
+/** `true` is a number != 0, a string stating `true`. Otherwise false. */
+declare function valueToBoolean(value?: any, defaultValue?: boolean): boolean;
+/** Explicitly has to have a `false` value to become `false`, otherwise `true` */
+declare function valueToBooleanNotFalse(value?: any, defaultValue?: boolean): boolean;
+declare function valueToInteger(value?: any, defaultValue?: number): number;
+declare function valueToFloat(value?: any, defaultValue?: number): number;
+declare function valueToString(value?: any, defaultValue?: string): string;
+declare const toFloat: typeof valueToFloat;
+declare const toInt: typeof valueToInteger;
+declare const toString: typeof valueToString;
+declare const toBool: typeof valueToBoolean;
+declare function fixBrokenUtf8String(brokenString: string): string;
+//#endregion
+export { stringToFloat as a, toFloat as c, valueToBoolean as d, valueToBooleanNotFalse as f, valueToString as h, stringToBoolean as i, toInt as l, valueToInteger as m, parseFloat as n, stringToInteger as o, valueToFloat as p, parseInt as r, toBool as s, fixBrokenUtf8String as t, toString as u };
+//# sourceMappingURL=convert-DI3Ak8iz.d.cts.map

package/dist/crypto-C8VaLy62.d.cts

@@ -0,0 +1,24 @@
+import { t as BinInput } from "./bin-types-DD2CqRPc.cjs";
+
+//#region src/common/crypto/crypto.d.ts
+/** Get random bytes using window.crypto if available. Else use a poor fallback solution. */
+declare function randomUint8Array(length?: number): Uint8Array;
+declare const CRYPTO_DEFAULT_HASH_ALG = "SHA-256";
+declare const CRYPTO_DEFAULT_ALG = "AES-GCM";
+declare const CRYPTO_DEFAULT_DERIVE_ALG = "PBKDF2";
+declare const CRYPTO_DEFAULT_DERIVE_ITERATIONS = 100000;
+declare const CRYPTO_DEFAULT_IV_LENGTH = 12;
+declare function digest(message: BinInput, algorithm?: AlgorithmIdentifier): Promise<Uint8Array>;
+declare function deriveKeyPbkdf2(secret: BinInput, opt?: {
+  iterations?: number;
+  salt?: BinInput;
+}): Promise<CryptoKey>;
+declare function deriveKeyPbkdf2CBC(secret: BinInput, opt?: {
+  iterations?: number;
+  salt?: BinInput;
+}): Promise<CryptoKey>;
+declare function encrypt(data: Uint8Array, key: CryptoKey): Promise<Uint8Array>;
+declare function decrypt(data: Uint8Array, key: CryptoKey): Promise<Uint8Array>;
+//#endregion
+export { CRYPTO_DEFAULT_IV_LENGTH as a, deriveKeyPbkdf2CBC as c, randomUint8Array as d, CRYPTO_DEFAULT_HASH_ALG as i, digest as l, CRYPTO_DEFAULT_DERIVE_ALG as n, decrypt as o, CRYPTO_DEFAULT_DERIVE_ITERATIONS as r, deriveKeyPbkdf2 as s, CRYPTO_DEFAULT_ALG as t, encrypt as u };
+//# sourceMappingURL=crypto-C8VaLy62.d.cts.map

package/dist/crypto-CyTV7Qce.d.cts

@@ -0,0 +1,6 @@
+//#region src/node/crypto.d.ts
+declare function setupWebCrypto(): void;
+declare function getWebCrypto(): Promise<Crypto>;
+//#endregion
+export { setupWebCrypto as n, getWebCrypto as t };
+//# sourceMappingURL=crypto-CyTV7Qce.d.cts.map

package/dist/crypto-D4uSzFEL.d.mts

@@ -0,0 +1,24 @@
+import { t as BinInput } from "./bin-types-CKGKqfwj.mjs";
+
+//#region src/common/crypto/crypto.d.ts
+/** Get random bytes using window.crypto if available. Else use a poor fallback solution. */
+declare function randomUint8Array(length?: number): Uint8Array;
+declare const CRYPTO_DEFAULT_HASH_ALG = "SHA-256";
+declare const CRYPTO_DEFAULT_ALG = "AES-GCM";
+declare const CRYPTO_DEFAULT_DERIVE_ALG = "PBKDF2";
+declare const CRYPTO_DEFAULT_DERIVE_ITERATIONS = 100000;
+declare const CRYPTO_DEFAULT_IV_LENGTH = 12;
+declare function digest(message: BinInput, algorithm?: AlgorithmIdentifier): Promise<Uint8Array>;
+declare function deriveKeyPbkdf2(secret: BinInput, opt?: {
+  iterations?: number;
+  salt?: BinInput;
+}): Promise<CryptoKey>;
+declare function deriveKeyPbkdf2CBC(secret: BinInput, opt?: {
+  iterations?: number;
+  salt?: BinInput;
+}): Promise<CryptoKey>;
+declare function encrypt(data: Uint8Array, key: CryptoKey): Promise<Uint8Array>;
+declare function decrypt(data: Uint8Array, key: CryptoKey): Promise<Uint8Array>;
+//#endregion
+export { CRYPTO_DEFAULT_IV_LENGTH as a, deriveKeyPbkdf2CBC as c, randomUint8Array as d, CRYPTO_DEFAULT_HASH_ALG as i, digest as l, CRYPTO_DEFAULT_DERIVE_ALG as n, decrypt as o, CRYPTO_DEFAULT_DERIVE_ITERATIONS as r, deriveKeyPbkdf2 as s, CRYPTO_DEFAULT_ALG as t, encrypt as u };
+//# sourceMappingURL=crypto-D4uSzFEL.d.mts.map

package/dist/crypto-LT7EC5_d.d.mts

@@ -0,0 +1,6 @@
+//#region src/node/crypto.d.ts
+declare function setupWebCrypto(): void;
+declare function getWebCrypto(): Promise<Crypto>;
+//#endregion
+export { setupWebCrypto as n, getWebCrypto as t };
+//# sourceMappingURL=crypto-LT7EC5_d.d.mts.map

package/dist/csv-Ci2ysFZB.d.cts

@@ -0,0 +1,14 @@
+//#region src/common/csv.d.ts
+declare function csvStringify(data: any[], opt?: {
+  separator?: string;
+  addBom?: boolean;
+}): string;
+declare function csvParse(raw: string, opt?: {
+  separator?: string;
+}): any[][];
+declare function csvParseToObjects(raw: string, opt?: {
+  separator?: string;
+}): any[];
+//#endregion
+export { csvParseToObjects as n, csvStringify as r, csvParse as t };
+//# sourceMappingURL=csv-Ci2ysFZB.d.cts.map

package/dist/csv-jl8exttU.d.mts

@@ -0,0 +1,14 @@
+//#region src/common/csv.d.ts
+declare function csvStringify(data: any[], opt?: {
+  separator?: string;
+  addBom?: boolean;
+}): string;
+declare function csvParse(raw: string, opt?: {
+  separator?: string;
+}): any[][];
+declare function csvParseToObjects(raw: string, opt?: {
+  separator?: string;
+}): any[];
+//#endregion
+export { csvParseToObjects as n, csvStringify as r, csvParse as t };
+//# sourceMappingURL=csv-jl8exttU.d.mts.map

package/dist/datauri-C6rpkUjx.d.mts

@@ -0,0 +1,9 @@
+//#region src/common/data/datauri.d.ts
+declare function dataUriToUint8Array(dataUri: string): Uint8Array | undefined;
+declare function dataUriToMimeType(dataUri: string): string | undefined;
+declare function dataUriToBlob(dataUri: string): Blob | undefined;
+declare function blobToDataUri(blob: Blob): Promise<string | undefined>;
+declare function Uint8ArrayToDataUri(bin: Uint8Array, type?: string): string;
+//#endregion
+export { dataUriToUint8Array as a, dataUriToMimeType as i, blobToDataUri as n, dataUriToBlob as r, Uint8ArrayToDataUri as t };
+//# sourceMappingURL=datauri-C6rpkUjx.d.mts.map

package/dist/datauri-PjKRmgtN.d.cts

@@ -0,0 +1,9 @@
+//#region src/common/data/datauri.d.ts
+declare function dataUriToUint8Array(dataUri: string): Uint8Array | undefined;
+declare function dataUriToMimeType(dataUri: string): string | undefined;
+declare function dataUriToBlob(dataUri: string): Blob | undefined;
+declare function blobToDataUri(blob: Blob): Promise<string | undefined>;
+declare function Uint8ArrayToDataUri(bin: Uint8Array, type?: string): string;
+//#endregion
+export { dataUriToUint8Array as a, dataUriToMimeType as i, blobToDataUri as n, dataUriToBlob as r, Uint8ArrayToDataUri as t };
+//# sourceMappingURL=datauri-PjKRmgtN.d.cts.map