hanzio 1.2.0 → 2.1.0

package/dist/src/jwt/index.js

@@ -1,110 +1,156 @@
+import {
+  utf8Encode2,
+  utf8Decode2,
+  encodeBase64Url2,
+  decodeBase64Url2,
+  getSubtleCrypto
+} from "../../index-rp5pqghz.js";
+import {
+  isRecord2
+} from "../../index-8r2vdzjg.js";
+
 // src/jwt/index.ts
-var BYTE_CHUNK_SIZE = 32768;
-var textEncoder = new TextEncoder;
-var textDecoder = new TextDecoder;
-async function jwtSign(payload, secret) {
-  const header = encodeJson({ alg: "HS256" });
-  const body = encodeJson({
-    ...payload,
-    iat: Math.floor(Date.now() / 1000)
-  });
-  const data = `${header}.${body}`;
-  const signature = await sign(data, secret);
-  return `${data}.${encodeBase64Url(signature)}`;
+class JwtVerifyError extends Error {
+  code;
+  constructor(code) {
+    super(`JWT verification failed: ${code}`);
+    this.name = "JwtVerifyError";
+    this.code = code;
+  }
 }
-async function jwtVerify(token, secret) {
+var HASHES = {
+  HS256: "SHA-256",
+  HS384: "SHA-384",
+  HS512: "SHA-512"
+};
+var ALGORITHMS = Object.keys(HASHES);
+var BASE64URL = /^[A-Za-z0-9_-]*$/;
+var KEY_CACHE_LIMIT = 100;
+async function jwtSign(payload, secret, options = {}) {
+  const {
+    expiresIn,
+    notBefore,
+    issuer,
+    audience,
+    algorithm = "HS256"
+  } = options;
+  if (!Object.hasOwn(HASHES, algorithm)) {
+    throw new TypeError(`Unsupported JWT algorithm: ${algorithm}`);
+  }
+  const now = Math.floor(Date.now() / 1000);
+  const claims = { ...payload, iat: now };
+  if (expiresIn !== undefined)
+    claims.exp = now + toSeconds(expiresIn);
+  if (notBefore !== undefined)
+    claims.nbf = now + toSeconds(notBefore);
+  if (issuer !== undefined)
+    claims.iss = issuer;
+  if (audience !== undefined)
+    claims.aud = audience;
+  const data = `${encodeJson({ alg: algorithm, typ: "JWT" })}.${encodeJson(claims)}`;
+  const key = await getKey(secret, algorithm, "sign");
+  const signature = await getSubtleCrypto().sign("HMAC", key, utf8Encode2(data));
+  return `${data}.${encodeBase64Url2(signature)}`;
+}
+async function jwtVerify(token, secret, options) {
   try {
-    const parts = token.split(".");
-    if (parts.length !== 3)
-      return null;
-    const [encodedHeader, encodedPayload, encodedSignature] = parts;
-    const header = decodeJson(encodedHeader);
-    if (!isJwtHeader(header))
-      return null;
-    const data = `${encodedHeader}.${encodedPayload}`;
-    const signature = decodeBase64Url(encodedSignature);
-    const isValid = await verify(data, signature, secret);
-    if (!isValid)
-      return null;
-    const payload = decodeJson(encodedPayload);
-    if (!isJwtPayload(payload) || !isTimeValid(payload))
-      return null;
-    return payload;
+    const result = await jwtVerifyResult(token, secret, options);
+    return result.ok ? result.data : null;
   } catch (_error) {
     return null;
   }
 }
-async function sign(data, secret) {
-  const key = await getKey(secret, ["sign"]);
-  return await getSubtleCrypto().sign("HMAC", key, encodeText(data));
-}
-async function verify(data, signature, secret) {
-  const key = await getKey(secret, ["verify"]);
-  return await getSubtleCrypto().verify("HMAC", key, signature, encodeText(data));
-}
-async function getKey(secret, usages) {
-  return await getSubtleCrypto().importKey("raw", encodeText(secret), {
-    name: "HMAC",
-    hash: "SHA-256"
-  }, false, usages);
-}
-function encodeJson(value) {
-  return encodeBase64Url(encodeText(JSON.stringify(value)));
-}
-function decodeJson(value) {
-  return JSON.parse(textDecoder.decode(decodeBase64Url(value)));
-}
-function encodeBase64Url(value) {
-  const bytes = value instanceof ArrayBuffer ? new Uint8Array(value) : value;
-  return btoa(bytesToBinaryString(bytes)).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
-}
-function decodeBase64Url(value) {
-  const base64 = value.replaceAll("-", "+").replaceAll("_", "/");
-  const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
-  return binaryStringToBytes(atob(padded)).buffer;
-}
-function encodeText(value) {
-  return toArrayBuffer(textEncoder.encode(value));
-}
-function toArrayBuffer(bytes) {
-  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-}
-function bytesToBinaryString(bytes) {
-  let binary = "";
-  for (let offset = 0;offset < bytes.length; offset += BYTE_CHUNK_SIZE) {
-    binary += String.fromCharCode(...bytes.subarray(offset, offset + BYTE_CHUNK_SIZE));
+async function jwtVerifyResult(token, secret, options = {}) {
+  const { leewaySec = 0, issuer, audience, algorithms = ALGORITHMS } = options;
+  const decoded = jwtDecode(token);
+  if (!decoded)
+    return fail("malformed");
+  const { alg } = decoded.header;
+  if (!Object.hasOwn(HASHES, alg) || !algorithms.includes(alg)) {
+    return fail("unsupported_alg");
   }
-  return binary;
-}
-function binaryStringToBytes(binary) {
-  const bytes = new Uint8Array(binary.length);
-  for (let index = 0;index < binary.length; index += 1) {
-    bytes[index] = binary.charCodeAt(index);
+  const lastDot = token.lastIndexOf(".");
+  let signature;
+  try {
+    signature = decodeBase64Url2(token.slice(lastDot + 1));
+  } catch (_error) {
+    return fail("malformed");
+  }
+  const key = await getKey(secret, alg, "verify");
+  const isValid = await getSubtleCrypto().verify("HMAC", key, signature, utf8Encode2(token.slice(0, lastDot)));
+  if (!isValid)
+    return fail("invalid_signature");
+  const { payload } = decoded;
+  const { exp, nbf } = payload;
+  if (exp !== undefined && typeof exp !== "number")
+    return fail("malformed");
+  if (nbf !== undefined && typeof nbf !== "number")
+    return fail("malformed");
+  const now = Math.floor(Date.now() / 1000);
+  if (exp !== undefined && now >= exp + leewaySec)
+    return fail("expired");
+  if (nbf !== undefined && now + leewaySec < nbf)
+    return fail("not_yet_valid");
+  if (issuer !== undefined && payload.iss !== issuer) {
+    return fail("invalid_issuer");
   }
-  return bytes;
+  if (audience !== undefined) {
+    const { aud } = payload;
+    const matches = Array.isArray(aud) ? aud.includes(audience) : aud === audience;
+    if (!matches)
+      return fail("invalid_audience");
+  }
+  return { ok: true, data: payload, error: null };
 }
-function getSubtleCrypto() {
-  const subtle = globalThis.crypto?.subtle;
-  if (!subtle) {
-    throw new Error("Web Crypto is not available in this runtime");
+function jwtDecode(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3 || !parts.every((part) => BASE64URL.test(part))) {
+    return null;
+  }
+  try {
+    const header = decodeJson(parts[0]);
+    const payload = decodeJson(parts[1]);
+    if (!isRecord2(header) || typeof header.alg !== "string")
+      return null;
+    if (!isRecord2(payload))
+      return null;
+    return { header, payload };
+  } catch (_error) {
+    return null;
   }
-  return subtle;
 }
-function isJwtHeader(value) {
-  return typeof value === "object" && value !== null && "alg" in value && value.alg === "HS256";
+function fail(code) {
+  return { ok: false, data: null, error: new JwtVerifyError(code) };
 }
-function isJwtPayload(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function toSeconds(value) {
+  if (!Number.isFinite(value)) {
+    throw new TypeError(`Expected a finite number of seconds, got ${value}`);
+  }
+  return Math.floor(value);
+}
+var keyCache = new Map;
+function getKey(secret, algorithm, usage) {
+  const cacheKey = `${algorithm}:${usage}:${secret}`;
+  const cached = keyCache.get(cacheKey);
+  if (cached)
+    return cached;
+  if (keyCache.size >= KEY_CACHE_LIMIT)
+    keyCache.clear();
+  const key = getSubtleCrypto().importKey("raw", utf8Encode2(secret), { name: "HMAC", hash: HASHES[algorithm] }, false, [usage]);
+  keyCache.set(cacheKey, key);
+  key.catch(() => keyCache.delete(cacheKey));
+  return key;
 }
-function isTimeValid(payload) {
-  const now = Math.floor(Date.now() / 1000);
-  if (typeof payload.exp === "number" && now >= payload.exp)
-    return false;
-  if (typeof payload.nbf === "number" && now < payload.nbf)
-    return false;
-  return true;
+function encodeJson(value) {
+  return encodeBase64Url2(utf8Encode2(JSON.stringify(value)));
+}
+function decodeJson(value) {
+  return JSON.parse(utf8Decode2(decodeBase64Url2(value)));
 }
 export {
+  JwtVerifyError,
+  jwtDecode,
   jwtSign,
-  jwtVerify
+  jwtVerify,
+  jwtVerifyResult
 };

package/dist/src/p-queue/index.js

@@ -1,439 +1,11 @@
-// src/p-queue/index.ts
-class TimeoutError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "TimeoutError";
-  }
-}
-
-class PriorityQueue {
-  #queue = [];
-  enqueue(run, options = {}) {
-    const element = {
-      priority: options.priority ?? 0,
-      id: options.id,
-      run
-    };
-    const index = this.#queue.findIndex((item) => item.priority < element.priority);
-    if (index === -1) {
-      this.#queue.push(element);
-      return;
-    }
-    this.#queue.splice(index, 0, element);
-  }
-  dequeue() {
-    return this.#queue.shift()?.run;
-  }
-  filter(options) {
-    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((item) => item.id === id);
-    if (index === -1) {
-      throw new ReferenceError(`No promise function with the id "${id}" exists in the queue.`);
-    }
-    const [item] = this.#queue.splice(index, 1);
-    this.enqueue(item.run, { ...item, priority });
-  }
-  remove(id) {
-    const index = this.#queue.findIndex((item) => item.id === id);
-    if (index !== -1) {
-      this.#queue.splice(index, 1);
-    }
-  }
-  get size() {
-    return this.#queue.length;
-  }
-}
-
-class PQueue {
-  #listeners = new Map;
-  #queue;
-  #queueClass;
-  #pending = 0;
-  #concurrency;
-  #isPaused;
-  #intervalCap;
-  #interval;
-  #carryoverIntervalCount;
-  #strict;
-  #intervalCount = 0;
-  #intervalEnd = 0;
-  #intervalTimer;
-  #strictTimestamps = [];
-  #rateLimited = false;
-  #idCounter = 1n;
-  #runningTasks = new Map;
-  timeout;
-  constructor(options = {}) {
-    const {
-      concurrency = Number.POSITIVE_INFINITY,
-      autoStart = true,
-      queueClass = PriorityQueue,
-      intervalCap = Number.POSITIVE_INFINITY,
-      interval = 0,
-      carryoverIntervalCount,
-      carryoverConcurrencyCount,
-      strict = false,
-      timeout
-    } = options;
-    if (!(typeof concurrency === "number" && concurrency >= 1)) {
-      throw new TypeError("Expected `concurrency` to be a number from 1 and up");
-    }
-    if (!(typeof intervalCap === "number" && intervalCap >= 1)) {
-      throw new TypeError("Expected `intervalCap` to be a number from 1 and up");
-    }
-    if (!(typeof interval === "number" && Number.isFinite(interval) && interval >= 0)) {
-      throw new TypeError("Expected `interval` to be a finite number >= 0");
-    }
-    if (strict && interval === 0) {
-      throw new TypeError("The `strict` option requires a non-zero `interval`");
-    }
-    if (strict && intervalCap === Number.POSITIVE_INFINITY) {
-      throw new TypeError("The `strict` option requires a finite `intervalCap`");
-    }
-    if (timeout !== undefined && !(Number.isFinite(timeout) && timeout > 0)) {
-      throw new TypeError("Expected `timeout` to be a positive finite number");
-    }
-    this.#queueClass = queueClass;
-    this.#queue = new queueClass;
-    this.#concurrency = concurrency;
-    this.#isPaused = !autoStart;
-    this.#intervalCap = intervalCap;
-    this.#interval = interval;
-    this.#carryoverIntervalCount = carryoverIntervalCount ?? carryoverConcurrencyCount ?? false;
-    this.#strict = strict;
-    this.timeout = timeout;
-  }
-  on(event, listener) {
-    const listeners = this.#listeners.get(event) ?? new Set;
-    listeners.add(listener);
-    this.#listeners.set(event, listeners);
-    return this;
-  }
-  off(event, listener) {
-    this.#listeners.get(event)?.delete(listener);
-    return this;
-  }
-  emit(event, ...arguments_) {
-    const listeners = this.#listeners.get(event);
-    if (!listeners || listeners.size === 0) {
-      return false;
-    }
-    for (const listener of [...listeners]) {
-      listener(...arguments_);
-    }
-    return true;
-  }
-  get concurrency() {
-    return this.#concurrency;
-  }
-  set concurrency(newConcurrency) {
-    if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) {
-      throw new TypeError("Expected `concurrency` to be a number from 1 and up");
-    }
-    this.#concurrency = newConcurrency;
-    this.#processQueue();
-  }
-  get size() {
-    return this.#queue.size;
-  }
-  sizeBy(options) {
-    return this.#queue.filter(options).length;
-  }
-  get pending() {
-    return this.#pending;
-  }
-  get isPaused() {
-    return this.#isPaused;
-  }
-  get isRateLimited() {
-    this.#updateRateLimitState();
-    return this.#rateLimited;
-  }
-  get isSaturated() {
-    return this.#pending >= this.#concurrency && this.#queue.size > 0 || this.isRateLimited && this.#queue.size > 0;
-  }
-  get runningTasks() {
-    return [...this.#runningTasks.values()].map((task) => ({ ...task }));
-  }
-  setPriority(id, priority) {
-    if (typeof priority !== "number" || !Number.isFinite(priority)) {
-      throw new TypeError("Expected `priority` to be a finite number");
-    }
-    this.#queue.setPriority(id, priority);
-  }
-  async add(function_, options = {}) {
-    const taskOptions = {
-      timeout: this.timeout,
-      ...options,
-      id: options.id ?? (this.#idCounter++).toString()
-    };
-    return new Promise((resolve, reject) => {
-      const taskSymbol = Symbol(taskOptions.id);
-      let didRun = false;
-      let queuedAbortHandler;
-      let runningAbortHandler;
-      const cleanupQueuedAbort = () => {
-        if (queuedAbortHandler) {
-          taskOptions.signal?.removeEventListener("abort", queuedAbortHandler);
-          queuedAbortHandler = undefined;
-        }
-      };
-      const run = async () => {
-        didRun = true;
-        cleanupQueuedAbort();
-        this.#pending++;
-        this.#runningTasks.set(taskSymbol, {
-          id: taskOptions.id,
-          priority: taskOptions.priority ?? 0,
-          startTime: Date.now(),
-          timeout: taskOptions.timeout
-        });
-        try {
-          taskOptions.signal?.throwIfAborted();
-          const operation = Promise.resolve(function_({ signal: taskOptions.signal }));
-          const result = await this.#withTimeoutAndAbort(operation, taskOptions, (listener) => {
-            runningAbortHandler = listener;
-          });
-          resolve(result);
-          this.emit("completed", result);
-        } catch (error) {
-          reject(error);
-          this.emit("error", error);
-        } finally {
-          if (runningAbortHandler) {
-            taskOptions.signal?.removeEventListener("abort", runningAbortHandler);
-          }
-          this.#runningTasks.delete(taskSymbol);
-          queueMicrotask(() => {
-            this.#next();
-          });
-        }
-      };
-      if (taskOptions.signal?.aborted) {
-        reject(taskOptions.signal.reason);
-        return;
-      }
-      if (taskOptions.signal) {
-        queuedAbortHandler = () => {
-          if (didRun) {
-            return;
-          }
-          this.#queue.remove?.(taskOptions.id);
-          reject(taskOptions.signal?.reason);
-          this.emit("next");
-          this.#tryToStartAnother();
-        };
-        taskOptions.signal.addEventListener("abort", queuedAbortHandler, {
-          once: true
-        });
-      }
-      this.#queue.enqueue(run, taskOptions);
-      this.emit("add");
-      this.#processQueue();
-    });
-  }
-  async addAll(functions, options) {
-    return Promise.all(functions.map(async (function_) => this.add(function_, options)));
-  }
-  start() {
-    if (!this.#isPaused) {
-      return this;
-    }
-    this.#isPaused = false;
-    this.#processQueue();
-    return this;
-  }
-  pause() {
-    this.#isPaused = true;
-  }
-  clear() {
-    this.#queue = new this.#queueClass;
-    this.#clearIntervalTimer();
-    this.#updateRateLimitState();
-    this.emit("empty");
-    if (this.#pending === 0) {
-      this.emit("idle");
-    }
-    this.emit("next");
-  }
-  async onEmpty() {
-    if (this.#queue.size === 0) {
-      return;
-    }
-    await this.#onEvent("empty");
-  }
-  async onIdle() {
-    if (this.#queue.size === 0 && this.#pending === 0) {
-      return;
-    }
-    await this.#onEvent("idle");
-  }
-  async onPendingZero() {
-    if (this.#pending === 0) {
-      return;
-    }
-    await this.#onEvent("pendingZero");
-  }
-  async onRateLimit() {
-    if (this.isRateLimited) {
-      return;
-    }
-    await this.#onEvent("rateLimit");
-  }
-  async onRateLimitCleared() {
-    if (!this.isRateLimited) {
-      return;
-    }
-    await this.#onEvent("rateLimitCleared");
-  }
-  onError() {
-    return new Promise((_resolve, reject) => {
-      const listener = (error) => {
-        this.off("error", listener);
-        reject(error);
-      };
-      this.on("error", listener);
-    });
-  }
-  async onSizeLessThan(limit) {
-    if (this.#queue.size < limit) {
-      return;
-    }
-    await this.#onEvent("next", () => this.#queue.size < limit);
-  }
-  async#onEvent(event, filter) {
-    return new Promise((resolve) => {
-      const listener = () => {
-        if (filter && !filter()) {
-          return;
-        }
-        this.off(event, listener);
-        resolve();
-      };
-      this.on(event, listener);
-    });
-  }
-  async#withTimeoutAndAbort(operation, options, setAbortListener) {
-    const races = [operation];
-    let timeoutId;
-    if (options.timeout) {
-      races.push(new Promise((_resolve, reject) => {
-        timeoutId = setTimeout(() => {
-          reject(new TimeoutError(`Task timed out after ${options.timeout}ms`));
-        }, options.timeout);
-      }));
-    }
-    if (options.signal) {
-      races.push(new Promise((_resolve, reject) => {
-        const listener = () => {
-          reject(options.signal?.reason);
-        };
-        setAbortListener(listener);
-        options.signal?.addEventListener("abort", listener, { once: true });
-      }));
-    }
-    try {
-      return await Promise.race(races);
-    } finally {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-    }
-  }
-  #next() {
-    this.#pending--;
-    if (this.#pending === 0) {
-      this.emit("pendingZero");
-    }
-    this.#processQueue();
-    this.emit("next");
-  }
-  #processQueue() {
-    while (this.#tryToStartAnother()) {}
-    this.#updateRateLimitState();
-  }
-  #tryToStartAnother() {
-    if (this.#queue.size === 0) {
-      this.#clearIntervalTimer();
-      this.emit("empty");
-      if (this.#pending === 0) {
-        this.emit("idle");
-      }
-      return false;
-    }
-    if (this.#isPaused || this.#pending >= this.#concurrency || !this.#doesIntervalAllowAnother()) {
-      return false;
-    }
-    const job = this.#queue.dequeue();
-    if (!job) {
-      return false;
-    }
-    this.#consumeIntervalSlot();
-    this.emit("active");
-    job();
-    return true;
-  }
-  #doesIntervalAllowAnother() {
-    if (this.#intervalCap === Number.POSITIVE_INFINITY || this.#interval === 0) {
-      return true;
-    }
-    const now = Date.now();
-    if (this.#strict) {
-      this.#strictTimestamps = this.#strictTimestamps.filter((timestamp) => now - timestamp < this.#interval);
-      if (this.#strictTimestamps.length < this.#intervalCap) {
-        return true;
-      }
-      this.#scheduleIntervalResume(this.#interval - (now - this.#strictTimestamps[0]));
-      return false;
-    }
-    if (this.#intervalEnd === 0 || now >= this.#intervalEnd) {
-      this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
-      this.#intervalEnd = now + this.#interval;
-    }
-    if (this.#intervalCount < this.#intervalCap) {
-      return true;
-    }
-    this.#scheduleIntervalResume(this.#intervalEnd - now);
-    return false;
-  }
-  #consumeIntervalSlot() {
-    if (this.#intervalCap === Number.POSITIVE_INFINITY || this.#interval === 0) {
-      return;
-    }
-    if (this.#strict) {
-      this.#strictTimestamps.push(Date.now());
-      return;
-    }
-    this.#intervalCount++;
-  }
-  #scheduleIntervalResume(delay) {
-    if (this.#intervalTimer) {
-      return;
-    }
-    this.#intervalTimer = setTimeout(() => {
-      this.#intervalTimer = undefined;
-      this.#processQueue();
-    }, Math.max(0, delay));
-  }
-  #clearIntervalTimer() {
-    if (this.#intervalTimer) {
-      clearTimeout(this.#intervalTimer);
-      this.#intervalTimer = undefined;
-    }
-  }
-  #updateRateLimitState() {
-    const previous = this.#rateLimited;
-    const isRateLimited = this.#queue.size > 0 && this.#intervalCap !== Number.POSITIVE_INFINITY && this.#interval > 0 && !this.#doesIntervalAllowAnother();
-    this.#rateLimited = isRateLimited;
-    if (previous !== isRateLimited) {
-      this.emit(isRateLimited ? "rateLimit" : "rateLimitCleared");
-    }
-  }
-}
+import {
+  TimeoutError2,
+  PriorityQueue2,
+  PQueue2
+} from "../../index-pwt0dz63.js";
 export {
-  PriorityQueue,
-  TimeoutError,
-  PQueue as default
+  PQueue2 as PQueue,
+  PriorityQueue2 as PriorityQueue,
+  TimeoutError2 as TimeoutError,
+  PQueue2 as default
 };