zeed 1.2.2 → 1.3.0

package/dist/common/uuid.d.cts

@@ -1,194 +1,2 @@
-/**
- * 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
- */
-declare function uuidBytes(): Uint8Array;
-/**
- * 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)
- */
-declare function uuidB62(bytes?: Uint8Array): string;
-/**
- * Encode raw UUID bytes to a Base62 string.
- *
- * @param bytes - 16-byte UUID as Uint8Array
- * @returns Base62-encoded string
- */
-declare function uuidEncodeB62(bytes: Uint8Array): string;
-/**
- * Decode a Base62-encoded UUID string into raw bytes.
- *
- * @param uuid - Base62 string
- * @returns 16-byte Uint8Array
- */
-declare function uuidDecodeB62(uuid: string): Uint8Array;
-/**
- * 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)
- */
-declare function uuidB32(bytes?: Uint8Array): string;
-/**
- * Encode raw UUID bytes to a Base32 string.
- *
- * @param bytes - 16-byte UUID as Uint8Array
- * @returns Base32-encoded string
- */
-declare function uuidEncodeB32(bytes: Uint8Array): string;
-/**
- * Decode a Base32-encoded UUID string into raw bytes.
- *
- * @param uuid - Base32 string
- * @returns 16-byte Uint8Array
- */
-declare function uuidDecodeB32(uuid: string): Uint8Array;
-/**
- * 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
- */
-declare function uuidv4(): string;
-/**
- * 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)
- */
-declare function uuidEncodeV4(bytes: Uint8Array): string;
-/**
- * Decode a UUID v4 string (hex with dashes) into raw bytes.
- *
- * @param uuid - UUID string
- * @returns 16-byte Uint8Array
- */
-declare function uuidDecodeV4(uuid: string): Uint8Array;
-/**
- * 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
- */
-declare function suidBytes(): Uint8Array;
-/**
- * Create a sortable unique identifier (SUID) and return it encoded using the
- * currently configured UUID encoding.
- *
- * @returns encoded SUID string
- */
-declare function suid(): string;
-/**
- * Extract the creation Date from an encoded SUID string.
- *
- * @param id - encoded SUID
- * @returns Date corresponding to the timestamp component of the SUID
- */
-declare function suidDate(id: string): Date;
-/**
- * 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
- */
-declare function suidBytesDate(id: Uint8Array): Date;
-/**
- * Generate a 32-bit unsigned integer from 4 random bytes.
- *
- * @returns a random 32-bit unsigned integer
- */
-declare function uuid32bit(): number;
-declare const mapModes: {
-    base62: {
-        uuid: typeof uuidB62;
-        uuidDecode: typeof uuidDecodeB62;
-        uuidEncode: typeof uuidEncodeB62;
-    };
-    base32: {
-        uuid: typeof uuidB32;
-        uuidDecode: typeof uuidDecodeB32;
-        uuidEncode: typeof uuidEncodeB32;
-    };
-    uuidv4: {
-        uuid: typeof uuidv4;
-        uuidDecode: typeof uuidDecodeV4;
-        uuidEncode: typeof uuidEncodeV4;
-    };
-    test: {
-        uuid: () => string;
-        uuidDecode: (id: string) => Uint8Array;
-        uuidEncode: (bin: Uint8Array) => string;
-    };
-};
-/**
- * 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
- */
-declare function setUuidDefaultEncoding(mode?: keyof typeof mapModes, sorted?: boolean): void;
-/**
- * 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
- */
-declare function uuid(): string;
-/**
- * Decode an encoded identifier according to the current encoding mode into
- * raw bytes.
- *
- * @param uuid - encoded identifier string
- * @returns raw 16-byte Uint8Array
- */
-declare function uuidDecode(uuid: string): Uint8Array;
-/**
- * Encode raw UUID bytes using the current encoding mode.
- *
- * @param bytes - 16-byte Uint8Array
- * @returns encoded identifier string
- */
-declare function uuidEncode(bytes: Uint8Array): string;
-/**
- * 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
- */
-declare function uuidIsValid(uuid: string): boolean;
-/**
- * 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
- */
-declare function uname(name?: string): string;
-/** Reset the counter used by `uname` for the given name. */
-declare function unameReset(name?: string): void;
-/**
- * Quick global incremental id generator.
- *
- * Returns strings like 'id-0', 'id-1', ... using a single global counter.
- */
-declare function qid(): string;
-
-export { qid, setUuidDefaultEncoding, suid, suidBytes, suidBytesDate, suidDate, uname, unameReset, uuid, uuid32bit, uuidB32, uuidB62, uuidBytes, uuidDecode, uuidDecodeB32, uuidDecodeB62, uuidDecodeV4, uuidEncode, uuidEncodeB32, uuidEncodeB62, uuidEncodeV4, uuidIsValid, uuidv4 };
+import { C as uuidv4, S as uuidIsValid, _ as uuidDecodeV4, a as suidBytesDate, b as uuidEncodeB62, c as unameReset, d as uuidB32, f as uuidB62, g as uuidDecodeB62, h as uuidDecodeB32, i as suidBytes, l as uuid, m as uuidDecode, n as setUuidDefaultEncoding, o as suidDate, p as uuidBytes, r as suid, s as uname, t as qid, u as uuid32bit, v as uuidEncode, x as uuidEncodeV4, y as uuidEncodeB32 } from "../uuid-Cusm2nIK.cjs";
+export { qid, setUuidDefaultEncoding, suid, suidBytes, suidBytesDate, suidDate, uname, unameReset, uuid, uuid32bit, uuidB32, uuidB62, uuidBytes, uuidDecode, uuidDecodeB32, uuidDecodeB62, uuidDecodeV4, uuidEncode, uuidEncodeB32, uuidEncodeB62, uuidEncodeV4, uuidIsValid, uuidv4 };

package/dist/common/uuid.d.mts

@@ -0,0 +1,2 @@
+import { C as uuidv4, S as uuidIsValid, _ as uuidDecodeV4, a as suidBytesDate, b as uuidEncodeB62, c as unameReset, d as uuidB32, f as uuidB62, g as uuidDecodeB62, h as uuidDecodeB32, i as suidBytes, l as uuid, m as uuidDecode, n as setUuidDefaultEncoding, o as suidDate, p as uuidBytes, r as suid, s as uname, t as qid, u as uuid32bit, v as uuidEncode, x as uuidEncodeV4, y as uuidEncodeB32 } from "../uuid-ININPGKB.mjs";
+export { qid, setUuidDefaultEncoding, suid, suidBytes, suidBytesDate, suidDate, uname, unameReset, uuid, uuid32bit, uuidB32, uuidB62, uuidBytes, uuidDecode, uuidDecodeB32, uuidDecodeB62, uuidDecodeV4, uuidEncode, uuidEncodeB32, uuidEncodeB62, uuidEncodeV4, uuidIsValid, uuidv4 };

package/dist/common/uuid.mjs

@@ -0,0 +1,2 @@
+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};
+//# 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

package/dist/day-Db1kbQMd.d.cts

@@ -0,0 +1,206 @@
+//#region src/common/data/day.d.ts
+/**
+ * Enable test mode for date functions by forcing "today" to a fixed day value.
+ *
+ * Use a numeric DayValue like 20000101 (YYYYMMDD). This is intended for tests
+ * to make date-based logic deterministic. Call with no args to reset.
+ *
+ * @param ts - day to use as "today" in YYYYMMDD format (default: 20000101)
+ */
+declare function setDayTest(ts?: number): void;
+/**
+ * @deprecated use TIME_DAY_MS
+ * Number of milliseconds in one calendar day (24 * 60 * 60 * 1000). */
+declare const DAY_MS = 86400000;
+/** DayValue is a numeric date encoded as YYYYMMDD (for example 20250907). */
+type DayValue = number;
+/**
+ * Accepted inputs for day conversion helpers.
+ * - DayValue or number: a YYYYMMDD numeric value
+ * - string: a date string (parsed by digits)
+ * - Date: JavaScript Date
+ * - [year, month?, day?]: numeric parts
+ */
+type DayInput = DayValue | number | string | Date | [number, number?, number?];
+/**
+ * Extract the year (YYYY) from a DayValue.
+ *
+ * @param day - day as YYYYMMDD
+ * @returns year as number (e.g. 2025)
+ */
+declare function dayYear(day: DayValue): DayValue;
+/**
+ * Extract the month (1-12) from a DayValue.
+ *
+ * @param day - day as YYYYMMDD
+ * @returns month number (1-12)
+ */
+declare function dayMonth(day: DayValue): DayValue;
+/**
+ * Extract the day of month (1-31) from a DayValue.
+ *
+ * @param day - day as YYYYMMDD
+ * @returns day of month (1-31)
+ */
+declare function dayDay(day: DayValue): DayValue;
+/**
+ * Split a DayValue into [year, month, day].
+ *
+ * @param day - day as YYYYMMDD
+ * @returns tuple [year, month, day]
+ */
+declare function dayToParts(day: DayValue): [number, number, number];
+/**
+ * Convert a DayValue to a JavaScript Date.
+ *
+ * By default returns a local Date at midnight for the day. If `utc` is true
+ * the returned Date represents midnight UTC for that day.
+ *
+ * @param day - day as YYYYMMDD
+ * @param utc - whether to construct the Date in UTC (default: false)
+ * @returns Date object for the given day
+ */
+declare function dayToDate(day: DayValue, utc?: boolean): Date;
+/**
+ * Return today's day as a DayValue (YYYYMMDD).
+ *
+ * If test mode has been enabled via `setDayTest` this returns the forced
+ * value instead. Otherwise it uses the current local date.
+ */
+declare function dayFromToday(): DayValue;
+/**
+ * Convert multiple input types to a DayValue (YYYYMMDD).
+ *
+ * Supports numbers (DayValue), strings, Date objects and [year, month?, day?]
+ * tuples. Returns undefined for invalid or unsupported values.
+ *
+ * @param value - input to convert
+ * @param utc - when converting from Date, interpret as UTC if true
+ */
+declare function dayFromAny(value: DayInput, utc?: boolean): DayValue | undefined;
+/** Convert a DayValue to a Date at midnight UTC. */
+declare function dayToDateUTC(day: DayValue): Date;
+/**
+ * @deprecated use dayToDateUTC
+ *
+ * Kept for backwards compatibility; returns a Date for midnight UTC.
+ */
+declare function dayToDateGMT(day: DayValue): Date;
+/**
+ * Convert a JavaScript Date to a DayValue (YYYYMMDD).
+ *
+ * If `utc` is true the function uses the ISO string representation to
+ * calculate the day in UTC. Otherwise it uses local date components.
+ */
+declare function dayFromDate(date: Date, utc?: boolean): DayValue;
+/** Convert a Date to DayValue using UTC. */
+declare function dayFromDateUTC(date: Date): DayValue;
+/** @deprecated use dayFromDateUTC */
+/**
+ * Deprecated: use `dayFromDateUTC`.
+ *
+ * Kept for backwards compatibility; converts a Date to a UTC DayValue.
+ */
+declare function dayFromDateGMT(date: Date): DayValue;
+/**
+ * Convert a DayValue to a UNIX timestamp in seconds. Returns seconds since
+ * epoch for midnight of the given day. Defaults to UTC.
+ */
+declare function dayToTimestampSeconds(day: DayValue, utc?: boolean): number;
+/**
+ * Convert a DayValue to a timestamp in milliseconds for midnight of that day.
+ * Defaults to UTC when constructing the Date.
+ */
+declare function dayToTimestamp(day: DayValue, utc?: boolean): number;
+/**
+ * Convert a timestamp in milliseconds to a DayValue. The timestamp is turned
+ * into a Date and then converted; `utc` controls interpretation.
+ */
+declare function dayFromTimestamp(ms: number, utc?: boolean): DayValue;
+/**
+ * Convert a UNIX timestamp in seconds to a DayValue.
+ *
+ * @param ms - seconds since epoch
+ */
+declare function dayFromTimestampSeconds(ms: number, utc?: boolean): DayValue;
+/**
+ * Format a DayValue as a string with an optional separator.
+ *
+ * Example: dayToString(20250907) -> "2025-09-07"
+ */
+declare function dayToString(day: DayValue, sep?: string): string;
+/**
+ * Build a DayValue from numeric parts. Returns undefined for invalid parts.
+ *
+ * @param year - full year (e.g. 2025)
+ * @param month - 1-12 (default 1)
+ * @param day - 1-31 (default 1)
+ */
+declare function dayFromParts(year: number, month?: number, day?: number): DayValue | undefined;
+/**
+ * Parse a string into a DayValue by extracting up to 8 digits (YYYYMMDD).
+ * Returns undefined for invalid results.
+ *
+ * Example:
+ * dayValue === dayFromString(String(dayValue))
+ */
+declare function dayFromString(value: string): DayValue | undefined;
+/**
+ * Return the first day of the month for the given DayValue. An optional
+ * `offset` (positive or negative) moves the result by months.
+ *
+ * @param day - source DayValue
+ * @param offset - months to offset (default 0)
+ */
+declare function dayMonthStart(day: DayValue, offset?: number): DayValue;
+/**
+ * Return the day offset by whole months, keeping the day-of-month when possible.
+ * If the target month has fewer days, the result is clamped to the last day.
+ *
+ * @param day - source DayValue
+ * @param offset - months to offset (positive or negative)
+ */
+declare function dayMonthOffset(day: DayValue, offset: number): DayValue;
+/**
+ * Return the first day of the year for the given DayValue. `offset` moves
+ * the year by the given amount.
+ */
+declare function dayYearStart(day: DayValue, offset?: number): DayValue;
+/**
+ * Return the day offset by whole years, keeping month and day when possible.
+ * If the target month has fewer days, the result is clamped to the last day.
+ *
+ * @param day - source DayValue
+ * @param offset - years to offset (positive or negative)
+ */
+declare function dayYearOffset(day: DayValue, offset: number): DayValue;
+/** Return number of days in a given month. Month is 1-12. */
+declare function dayDaysInMonth(year: number, month: number): number;
+/**
+ * Offset a DayValue by a number of days. Uses timestamp math to avoid local
+ * DST issues.
+ *
+ * @param day - source DayValue
+ * @param offset - days to add (negative to subtract)
+ */
+declare function dayOffset(day: DayValue, offset: number): DayValue;
+/**
+ * Compute the difference in whole days between two DayValues (right - left).
+ */
+declare function dayDiff(left: DayValue, right: DayValue): number;
+/**
+ * Return an array of DayValues from left to right (inclusive).
+ *
+ * If `right` is omitted it defaults to today. If `left` is negative it is
+ * interpreted as an offset relative to `right` (e.g. -7 means the last 7 days).
+ */
+declare function dayRange(left: DayValue, right?: DayValue): number[];
+/** Iterator, see dayRange */
+/**
+ * Generator that yields DayValues from left to right (inclusive). Same rules
+ * as `dayRange` regarding defaults and negative left values.
+ */
+declare function dayIterator(left: DayValue, right?: DayValue): Generator<number, number[], unknown>;
+//#endregion
+export { dayYearOffset as A, dayToDateGMT as C, dayToTimestamp as D, dayToString as E, setDayTest as M, dayToTimestampSeconds as O, dayToDate as S, dayToParts as T, dayMonth as _, dayDaysInMonth as a, dayOffset as b, dayFromDate as c, dayFromParts as d, dayFromString as f, dayIterator as g, dayFromToday as h, dayDay as i, dayYearStart as j, dayYear as k, dayFromDateGMT as l, dayFromTimestampSeconds as m, DayInput as n, dayDiff as o, dayFromTimestamp as p, DayValue as r, dayFromAny as s, DAY_MS as t, dayFromDateUTC as u, dayMonthOffset as v, dayToDateUTC as w, dayRange as x, dayMonthStart as y };
+//# sourceMappingURL=day-Db1kbQMd.d.cts.map