hanzio 1.2.0 → 2.0.0

package/dist/index-k9yx6bne.js

@@ -0,0 +1,89 @@
+// src/cache/createCache.ts
+function createCache2(options = {}) {
+  const {
+    defaultTtlMs,
+    staleMarginMs: defaultStaleMarginMs = 0,
+    maxEntries,
+    now = Date.now
+  } = options;
+  const store = new Map;
+  const fill = (entry, value, startedAt, setOptions = {}) => {
+    const { ttlMs = defaultTtlMs, staleMarginMs = defaultStaleMarginMs } = setOptions;
+    const ttl = typeof ttlMs === "function" ? ttlMs(value) : ttlMs;
+    entry.value = value;
+    entry.hasValue = true;
+    entry.expiresAt = ttl === undefined ? undefined : startedAt + ttl;
+    entry.refreshAt = entry.expiresAt === undefined ? undefined : entry.expiresAt - staleMarginMs;
+    return entry;
+  };
+  const isExpired = (entry) => entry.expiresAt !== undefined && entry.expiresAt <= now();
+  const hasFreshValue = (entry) => entry?.hasValue === true && !isExpired(entry);
+  const touch = (key, entry) => {
+    store.delete(key);
+    store.set(key, entry);
+    if (maxEntries !== undefined) {
+      while (store.size > maxEntries) {
+        store.delete(store.keys().next().value);
+      }
+    }
+  };
+  const read = (key) => {
+    const entry = store.get(key);
+    if (!entry)
+      return;
+    if (isExpired(entry) && !entry.inflight) {
+      store.delete(key);
+      return;
+    }
+    touch(key, entry);
+    return entry;
+  };
+  return {
+    async getOrSet(key, fn, setOptions) {
+      const existing = read(key);
+      if (existing?.inflight)
+        return existing.inflight;
+      const isStale = existing?.refreshAt !== undefined && existing.refreshAt <= now();
+      if (existing?.hasValue && !isStale)
+        return existing.value;
+      const entry = existing ?? { hasValue: false };
+      const startedAt = now();
+      const promise = (async () => fn())();
+      entry.inflight = promise;
+      touch(key, entry);
+      try {
+        const value = await promise;
+        fill(entry, value, startedAt, setOptions);
+        return value;
+      } catch (error) {
+        if (!hasFreshValue(entry) && store.get(key) === entry) {
+          store.delete(key);
+        }
+        throw error;
+      } finally {
+        entry.inflight = undefined;
+      }
+    },
+    get(key) {
+      const entry = read(key);
+      return hasFreshValue(entry) ? entry?.value : undefined;
+    },
+    has(key) {
+      return hasFreshValue(read(key));
+    },
+    set(key, value, setOptions) {
+      touch(key, fill({ hasValue: false }, value, now(), setOptions));
+    },
+    delete(key) {
+      store.delete(key);
+    },
+    clear() {
+      store.clear();
+    },
+    get size() {
+      return store.size;
+    }
+  };
+}
+
+export { createCache2 };

package/dist/index-kj1phgrx.js

@@ -0,0 +1,169 @@
+// src/string/index.ts
+function extractNumber2(value, options = {}) {
+  const { decimalSeparator = "." } = options;
+  const decimal = decimalSeparator === "." ? "\\." : ",";
+  const thousands = decimalSeparator === "." ? "," : "\\.";
+  const token = value?.match(new RegExp(`-?(?:\\d+(?:(?:${thousands}|\\s)\\d{3}(?!\\d))*(?:${decimal}\\d+)?|${decimal}\\d+)`))?.[0];
+  if (!token)
+    return;
+  const parsedNumber = Number.parseFloat(token.replace(/\s/g, "").replaceAll(decimalSeparator === "." ? "," : ".", "").replace(decimalSeparator, "."));
+  return Number.isNaN(parsedNumber) ? undefined : parsedNumber;
+}
+function generateId2(input) {
+  const data = normalizeIdInput(input);
+  let hash = 0;
+  for (let index = 0;index < data.length; index++) {
+    const char = data.charCodeAt(index);
+    hash = (hash << 5) - hash + char;
+    hash |= 0;
+  }
+  return Math.abs(hash).toString(16).padStart(8, "0");
+}
+async function sha256Id2(input, length = 16) {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(normalizeIdInput(input)));
+  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, length);
+}
+var UNDECOMPOSED_LETTERS = {
+  æ: "ae",
+  Æ: "AE",
+  ø: "o",
+  Ø: "O",
+  œ: "oe",
+  Œ: "OE",
+  ß: "ss",
+  ẞ: "SS",
+  đ: "d",
+  Đ: "D",
+  ł: "l",
+  Ł: "L",
+  þ: "th",
+  Þ: "TH",
+  ð: "d",
+  Ð: "D"
+};
+function stripAccents(value) {
+  return value.normalize("NFKD").replace(/\p{M}/gu, "").replace(/[æøœßđłþðÆØŒẞĐŁÞÐ]/g, (letter) => UNDECOMPOSED_LETTERS[letter] ?? "");
+}
+function slugify2(value, options = {}) {
+  const { separator = "-", lowercase = true, maxLength } = options;
+  const slug = stripAccents(value).replace(/&/g, " and ").replace(/[\s\-_/,:;·]+/g, " ").replace(/[^a-zA-Z0-9 ]/g, "").trim().split(/ +/).join(separator);
+  const cased = lowercase ? slug.toLowerCase() : slug;
+  if (maxLength === undefined || cased.length <= maxLength)
+    return cased;
+  return cased.slice(0, maxLength).replace(/[^a-zA-Z0-9]+$/, "");
+}
+function stableStringify2(value) {
+  return JSON.stringify(value, (_key, item) => {
+    if (typeof item === "bigint")
+      return `${item}n`;
+    if (item instanceof Map)
+      return { $map: [...item.entries()] };
+    if (item instanceof Set)
+      return { $set: [...item] };
+    if (item && typeof item === "object" && !Array.isArray(item)) {
+      const record = item;
+      return Object.fromEntries(Object.keys(record).sort().map((key) => [key, record[key]]));
+    }
+    return item;
+  }) ?? "undefined";
+}
+function truncate2(text, maxLength, options = {}) {
+  const { ellipsis = "…", wordBoundary = false } = options;
+  const characters = graphemes(text);
+  if (characters.length <= maxLength)
+    return text;
+  const ellipsisCharacters = graphemes(ellipsis);
+  const room = maxLength - ellipsisCharacters.length;
+  if (room <= 0)
+    return ellipsisCharacters.slice(0, maxLength).join("");
+  let cut = characters.slice(0, room).join("");
+  if (wordBoundary && !/^\s/.test(characters[room] ?? "")) {
+    const lastSpace = cut.search(/\s\S*$/);
+    if (lastSpace > 0)
+      cut = cut.slice(0, lastSpace);
+  }
+  return cut.trimEnd() + ellipsis;
+}
+function normalizeWhitespace2(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function escapeRegExp2(text) {
+  return text.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&").replace(/-/g, "\\x2d");
+}
+function foldForSearch2(text) {
+  return stripAccents(text).toLowerCase();
+}
+function matchesSearch2(query, ...fields) {
+  const haystack = foldForSearch2(fields.filter(Boolean).join(`
+`));
+  return foldForSearch2(query).split(/\s+/).every((term) => haystack.includes(term));
+}
+var HAS_LETTER = /\p{L}/u;
+function initials2(name, options = {}) {
+  const { max = 2 } = options;
+  const trimmed = name?.trim() ?? "";
+  const source = /^[^\s@]+@[^\s@]+$/.test(trimmed) ? (trimmed.split("@")[0] ?? "").replace(/\+.*$/, "").replace(/[._-]+/g, " ") : trimmed;
+  const words = source.split(/\s+/).filter((word) => HAS_LETTER.test(word));
+  const first = words[0];
+  if (!first)
+    return "";
+  if (words.length === 1)
+    return fromFirstLetter(first, max).toUpperCase();
+  const head = words.slice(0, Math.max(1, max - 1));
+  const picked = words.length > max ? [...head, words.at(-1) ?? first].slice(0, max) : words;
+  return picked.map((word) => fromFirstLetter(word, 1)).join("").toUpperCase();
+}
+function safeJsonParse2(text) {
+  try {
+    return { ok: true, data: JSON.parse(text), error: null };
+  } catch (error) {
+    return { ok: false, data: null, error };
+  }
+}
+function fromFirstLetter(word, count) {
+  const characters = graphemes(word);
+  const start = characters.findIndex((character) => HAS_LETTER.test(character));
+  if (start === -1)
+    return "";
+  return characters.slice(start, start + count).join("");
+}
+var segmenter;
+function graphemes(text) {
+  if (typeof Intl === "undefined" || !("Segmenter" in Intl))
+    return [...text];
+  segmenter ??= new Intl.Segmenter;
+  return Array.from(segmenter.segment(text), ({ segment }) => segment);
+}
+function normalizeIdInput(input) {
+  if (input === undefined)
+    return "undefined";
+  if (input === null)
+    return "null";
+  if (typeof input === "string") {
+    return safeDecodeURIComponent(input).split("&").sort().join("&");
+  }
+  if (typeof input === "number" || typeof input === "boolean") {
+    return input.toString();
+  }
+  return JSON.stringify(sortJsonValue(input));
+}
+function sortJsonValue(value) {
+  if (value === undefined)
+    return null;
+  if (Array.isArray(value)) {
+    return value.map((item) => sortJsonValue(item));
+  }
+  if (typeof value === "object" && value !== null) {
+    return Object.fromEntries(Object.entries(value).filter(([, itemValue]) => itemValue !== undefined).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)).map(([key, itemValue]) => [key, sortJsonValue(itemValue)]));
+  }
+  return value;
+}
+function safeDecodeURIComponent(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+export { extractNumber2, generateId2, sha256Id2, slugify2, stableStringify2, truncate2, normalizeWhitespace2, escapeRegExp2, foldForSearch2, matchesSearch2, initials2, safeJsonParse2 };

package/dist/index-mnkcfyx8.js

@@ -0,0 +1,78 @@
+// src/url/index.ts
+function buildQueryString2(params, options = {}) {
+  const pairs = [];
+  for (const [key, value] of Object.entries(params)) {
+    const values = Array.isArray(value) ? value : [value];
+    for (const item of values) {
+      if (item != null)
+        pairs.push([key, String(item)]);
+    }
+  }
+  if (options.encode === false) {
+    return pairs.map(([key, value]) => `${key}=${value}`).join("&");
+  }
+  return new URLSearchParams(pairs).toString();
+}
+function replacePathParams2(path, params = {}) {
+  return path.replace(/:([A-Za-z_]\w*)/g, (_, key) => {
+    const value = params[key];
+    if (value === undefined) {
+      throw new Error(`Missing required path parameter: ${key}`);
+    }
+    return encodeURIComponent(String(value));
+  });
+}
+function buildUrl2(base, path = "", options = {}) {
+  const joined = path ? `${trimTrailingSlash2(base)}/${path.replace(/^\/+/, "")}` : base;
+  const url = replacePathParams2(joined, options.params);
+  const query = options.query ? buildQueryString2(options.query) : "";
+  if (!query)
+    return url;
+  return `${url}${url.includes("?") ? "&" : "?"}${query}`;
+}
+function normalizeDomain2(input) {
+  const trimmed = input.trim();
+  const withScheme = /^[a-z][a-z\d+.-]*:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+  return new URL(withScheme).origin;
+}
+function getDomainFaviconUrl2(domainOrUrl, size = 128) {
+  let domain = domainOrUrl;
+  try {
+    if (/^[a-z][a-z\d+.-]*:\/\//i.test(domainOrUrl)) {
+      domain = new URL(domainOrUrl).hostname;
+    }
+  } catch {}
+  return `https://www.google.com/s2/favicons?domain=${encodeURIComponent(domain)}&sz=${size}`;
+}
+function trimTrailingSlash2(url) {
+  return url.replace(/\/+$/, "");
+}
+function ensureLeadingSlash2(path) {
+  return path.startsWith("/") ? path : `/${path}`;
+}
+function buildMailto2(options) {
+  const { to, cc, bcc, subject, body } = options;
+  const headers = Object.entries({
+    cc: cc && recipients(cc),
+    bcc: bcc && recipients(bcc),
+    subject: subject && encodeURIComponent(subject),
+    body: body && encodeURIComponent(body.replace(/\r?\n/g, `\r
+`))
+  }).filter(([, value]) => value).map(([key, value]) => `${key}=${value}`).join("&");
+  return `mailto:${to ? recipients(to) : ""}${headers ? `?${headers}` : ""}`;
+}
+function recipients(value) {
+  return (typeof value === "string" ? [value] : value).map((address) => encodeURIComponent(address.trim()).replace(/%40/g, "@")).join(",");
+}
+function parseRetryAfter2(value, now = Date.now()) {
+  const trimmed = value?.trim();
+  if (!trimmed)
+    return;
+  if (/^-?\d*\.?\d+$/.test(trimmed)) {
+    return Math.max(0, Number(trimmed) * 1000);
+  }
+  const date = Date.parse(trimmed);
+  return Number.isNaN(date) ? undefined : Math.max(0, date - now);
+}
+
+export { buildQueryString2, replacePathParams2, buildUrl2, normalizeDomain2, getDomainFaviconUrl2, trimTrailingSlash2, ensureLeadingSlash2, buildMailto2, parseRetryAfter2 };

package/dist/{p-queue/index.js → index-pwt0dz63.js}

@@ -1,12 +1,12 @@
 // src/p-queue/index.ts
-class TimeoutError extends Error {
+class TimeoutError2 extends Error {
   constructor(message) {
     super(message);
     this.name = "TimeoutError";
   }
 }
 
-class PriorityQueue {
+class PriorityQueue2 {
   #queue = [];
   enqueue(run, options = {}) {
     const element = {
@@ -28,7 +28,7 @@ class PriorityQueue {
     return this.#queue.filter((item) => Object.entries(options).every(([key, value]) => item[key] === value)).map((item) => item.run);
   }
   setPriority(id, priority) {
-    const index = this.#queue.findIndex((item2) => item2.id === id);
+    const index = this.#queue.findIndex((item) => item.id === id);
     if (index === -1) {
       throw new ReferenceError(`No promise function with the id "${id}" exists in the queue.`);
     }
@@ -46,7 +46,7 @@ class PriorityQueue {
   }
 }
 
-class PQueue {
+class PQueue2 {
   #listeners = new Map;
   #queue;
   #queueClass;
@@ -69,7 +69,7 @@ class PQueue {
     const {
       concurrency = Number.POSITIVE_INFINITY,
       autoStart = true,
-      queueClass = PriorityQueue,
+      queueClass = PriorityQueue2,
       intervalCap = Number.POSITIVE_INFINITY,
       interval = 0,
       carryoverIntervalCount,
@@ -321,7 +321,7 @@ class PQueue {
     if (options.timeout) {
       races.push(new Promise((_resolve, reject) => {
         timeoutId = setTimeout(() => {
-          reject(new TimeoutError(`Task timed out after ${options.timeout}ms`));
+          reject(new TimeoutError2(`Task timed out after ${options.timeout}ms`));
         }, options.timeout);
       }));
     }
@@ -432,8 +432,4 @@ class PQueue {
     }
   }
 }
-export {
-  PQueue as default,
-  TimeoutError,
-  PriorityQueue
-};
+export { TimeoutError2, PriorityQueue2, PQueue2 };

package/dist/index-rp5pqghz.js

@@ -0,0 +1,157 @@
+// src/crypto/encoding.ts
+var BYTE_CHUNK_SIZE = 32768;
+var BASE64 = /^[A-Za-z0-9+/]*={0,2}$/;
+var BASE64URL = /^[A-Za-z0-9_-]*={0,2}$/;
+var HEX = /^(?:[0-9a-fA-F]{2})*$/;
+var textEncoder = new TextEncoder;
+var textDecoder = new TextDecoder;
+function utf8Encode2(value) {
+  return textEncoder.encode(value);
+}
+function utf8Decode2(bytes) {
+  return textDecoder.decode(bytes);
+}
+function encodeBase642(bytes) {
+  const view = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+  let binary = "";
+  for (let offset = 0;offset < view.length; offset += BYTE_CHUNK_SIZE) {
+    binary += String.fromCharCode(...view.subarray(offset, offset + BYTE_CHUNK_SIZE));
+  }
+  return btoa(binary);
+}
+function decodeBase642(value) {
+  if (!BASE64.test(value))
+    throw new TypeError("Invalid base64 string");
+  const unpadded = value.replace(/=+$/, "");
+  if (unpadded.length % 4 === 1)
+    throw new TypeError("Invalid base64 string");
+  const binary = atob(unpadded.padEnd(Math.ceil(unpadded.length / 4) * 4, "="));
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0;index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes;
+}
+function encodeBase64Url2(bytes) {
+  return encodeBase642(bytes).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function decodeBase64Url2(value) {
+  if (!BASE64URL.test(value))
+    throw new TypeError("Invalid base64url string");
+  return decodeBase642(value.replaceAll("-", "+").replaceAll("_", "/"));
+}
+function bytesToHex2(bytes) {
+  const view = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+  let hex = "";
+  for (const byte of view)
+    hex += byte.toString(16).padStart(2, "0");
+  return hex;
+}
+function hexToBytes2(value) {
+  if (!HEX.test(value))
+    throw new TypeError("Invalid hex string");
+  const bytes = new Uint8Array(value.length / 2);
+  for (let index = 0;index < bytes.length; index += 1) {
+    bytes[index] = Number.parseInt(value.slice(index * 2, index * 2 + 2), 16);
+  }
+  return bytes;
+}
+function toBytes(data) {
+  if (typeof data === "string")
+    return utf8Encode2(data);
+  return data instanceof Uint8Array ? new Uint8Array(data) : new Uint8Array(data.slice(0));
+}
+
+// src/crypto/hash.ts
+var HMAC_ALGORITHMS = ["SHA-256", "SHA-384", "SHA-512"];
+var RANDOM_CHUNK_SIZE = 65536;
+var ENCODERS = {
+  hex: bytesToHex2,
+  base64: encodeBase642,
+  base64url: encodeBase64Url2
+};
+var DECODERS = { hex: hexToBytes2, base64: decodeBase642, base64url: decodeBase64Url2 };
+function safeEqual2(a, b) {
+  const left = typeof a === "string" ? utf8Encode2(a) : a;
+  const right = typeof b === "string" ? utf8Encode2(b) : b;
+  const length = Math.max(left.length, right.length);
+  let diff = left.length ^ right.length;
+  for (let index = 0;index < length; index += 1) {
+    diff |= (left[index] ?? 0) ^ (right[index] ?? 0);
+  }
+  return diff === 0;
+}
+function randomBytes2(byteLength) {
+  if (!Number.isSafeInteger(byteLength) || byteLength < 0) {
+    throw new RangeError("byteLength must be a non-negative integer");
+  }
+  const cryptoApi = globalThis.crypto;
+  if (!cryptoApi?.getRandomValues) {
+    throw new Error("Web Crypto is not available in this runtime");
+  }
+  const bytes = new Uint8Array(byteLength);
+  for (let offset = 0;offset < byteLength; offset += RANDOM_CHUNK_SIZE) {
+    cryptoApi.getRandomValues(bytes.subarray(offset, offset + RANDOM_CHUNK_SIZE));
+  }
+  return bytes;
+}
+function randomToken2(byteLength = 32) {
+  if (!Number.isSafeInteger(byteLength) || byteLength < 1) {
+    throw new RangeError("byteLength must be a positive integer");
+  }
+  return encodeBase64Url2(randomBytes2(byteLength));
+}
+async function sha2562(data) {
+  return new Uint8Array(await getSubtleCrypto().digest("SHA-256", toBytes(data)));
+}
+async function sha256Hex2(data) {
+  return bytesToHex2(await sha2562(data));
+}
+async function hmacSign2(secret, data, options = {}) {
+  const { algorithm = "SHA-256", encoding = "hex" } = options;
+  assertEncoding(encoding);
+  const key = await importHmacKey(secret, algorithm, "sign");
+  const signature = await getSubtleCrypto().sign("HMAC", key, toBytes(data));
+  return ENCODERS[encoding](new Uint8Array(signature));
+}
+async function verifyHmacSignature2(secret, data, signature, options = {}) {
+  const { algorithm = "SHA-256", encoding = "hex", prefix } = options;
+  assertEncoding(encoding);
+  const key = await importHmacKey(secret, algorithm, "verify");
+  let encoded = signature;
+  if (prefix !== undefined) {
+    if (!signature.startsWith(prefix))
+      return false;
+    encoded = signature.slice(prefix.length);
+  }
+  let received;
+  try {
+    received = DECODERS[encoding](encoded);
+  } catch (_error) {
+    return false;
+  }
+  return getSubtleCrypto().verify("HMAC", key, received, toBytes(data));
+}
+function importHmacKey(secret, algorithm, usage) {
+  if (!HMAC_ALGORITHMS.includes(algorithm)) {
+    throw new TypeError(`Unsupported HMAC algorithm: ${algorithm}`);
+  }
+  const keyBytes = toBytes(secret);
+  if (keyBytes.length === 0)
+    throw new TypeError("HMAC secret must not be empty");
+  return getSubtleCrypto().importKey("raw", keyBytes, { name: "HMAC", hash: algorithm }, false, [usage]);
+}
+function assertEncoding(encoding) {
+  if (!Object.hasOwn(ENCODERS, encoding)) {
+    throw new TypeError(`Unsupported signature encoding: ${encoding}`);
+  }
+}
+function getSubtleCrypto() {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) {
+    throw new Error("Web Crypto is not available in this runtime");
+  }
+  return subtle;
+}
+
+export { utf8Encode2, utf8Decode2, encodeBase642, decodeBase642, encodeBase64Url2, decodeBase64Url2, bytesToHex2, hexToBytes2, toBytes, safeEqual2, randomBytes2, randomToken2, sha2562, sha256Hex2, hmacSign2, verifyHmacSignature2, getSubtleCrypto };

package/dist/index-srt06xd2.js

@@ -0,0 +1,15 @@
+// src/secrets/errors.ts
+class SecretLoadError2 extends Error {
+  code;
+  operation;
+  status;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "SecretLoadError";
+    this.code = code;
+    this.operation = details.operation;
+    this.status = details.status;
+  }
+}
+
+export { SecretLoadError2 };