superjs-core 0.1.0

package/dist/core/index.js

@@ -0,0 +1,272 @@
+// src/core/index.ts
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function getType(value) {
+  return Object.prototype.toString.call(value);
+}
+function clone(value, seen) {
+  if (value === null || typeof value !== "object") return value;
+  if (seen.has(value)) return seen.get(value);
+  const tag = getType(value);
+  if (tag === "[object Date]") {
+    const cloned = new Date(value.getTime());
+    seen.set(value, cloned);
+    return cloned;
+  }
+  if (tag === "[object RegExp]") {
+    const regExp = value;
+    const cloned = new RegExp(regExp.source, regExp.flags);
+    cloned.lastIndex = regExp.lastIndex;
+    seen.set(value, cloned);
+    return cloned;
+  }
+  if (tag === "[object Map]") {
+    const cloned = /* @__PURE__ */ new Map();
+    seen.set(value, cloned);
+    value.forEach((v, k) => {
+      cloned.set(clone(k, seen), clone(v, seen));
+    });
+    return cloned;
+  }
+  if (tag === "[object Set]") {
+    const cloned = /* @__PURE__ */ new Set();
+    seen.set(value, cloned);
+    value.forEach((v) => {
+      cloned.add(clone(v, seen));
+    });
+    return cloned;
+  }
+  if (Array.isArray(value)) {
+    const cloned = [];
+    seen.set(value, cloned);
+    for (let i = 0; i < value.length; i++) {
+      cloned[i] = clone(value[i], seen);
+    }
+    return cloned;
+  }
+  if (tag === "[object Object]") {
+    const cloned = {};
+    seen.set(value, cloned);
+    const keys = Object.keys(value);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      cloned[key] = clone(value[key], seen);
+    }
+    return cloned;
+  }
+  return value;
+}
+function deepClone(value) {
+  const seen = /* @__PURE__ */ new WeakMap();
+  return clone(value, seen);
+}
+function deepMerge(...objects) {
+  const result = {};
+  for (let i = 0; i < objects.length; i++) {
+    const obj = objects[i];
+    if (obj === null || obj === void 0) continue;
+    const keys = Object.keys(obj);
+    for (let j = 0; j < keys.length; j++) {
+      const key = keys[j];
+      const val = obj[key];
+      const existing = result[key];
+      if (val !== void 0 && isPlainObject(val) && isPlainObject(existing)) {
+        result[key] = deepMerge(
+          existing,
+          val
+        );
+      } else if (val !== void 0) {
+        result[key] = val;
+      }
+    }
+  }
+  return result;
+}
+function debounce(fn, wait, options) {
+  const { leading = false, trailing = true, maxWait } = options ?? {};
+  let timer = null;
+  let maxTimer = null;
+  let lastArgs = null;
+  let lastCallTime = null;
+  let lastInvokeTime = 0;
+  function invoke(time) {
+    lastInvokeTime = time;
+    if (lastArgs) {
+      fn(...lastArgs);
+      lastArgs = null;
+    }
+  }
+  function startTimer(waitTime) {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      const now = Date.now();
+      if (lastArgs && trailing) {
+        invoke(now);
+      }
+      timer = null;
+      lastCallTime = null;
+    }, waitTime);
+  }
+  function startMaxTimer() {
+    if (maxWait === void 0 || maxTimer) return;
+    maxTimer = setTimeout(() => {
+      if (lastArgs) {
+        invoke(Date.now());
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        lastCallTime = null;
+      }
+    }, maxWait);
+  }
+  function clearAllTimers() {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (maxTimer) {
+      clearTimeout(maxTimer);
+      maxTimer = null;
+    }
+  }
+  function shouldInvoke(time) {
+    if (lastCallTime === null) return true;
+    const timeSinceLastCall = time - lastCallTime;
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    return timeSinceLastCall >= wait || maxWait !== void 0 && timeSinceLastInvoke >= maxWait;
+  }
+  const debounced = function(...args) {
+    const time = Date.now();
+    const isInvoking = shouldInvoke(time);
+    lastArgs = args;
+    lastCallTime = time;
+    if (isInvoking && !timer && leading) {
+      invoke(time);
+    }
+    if (!timer) {
+      startTimer(wait);
+      if (maxWait !== void 0) {
+        startMaxTimer();
+      }
+    }
+  };
+  debounced.cancel = () => {
+    clearAllTimers();
+    lastArgs = null;
+    lastCallTime = null;
+    lastInvokeTime = 0;
+  };
+  debounced.flush = () => {
+    if (timer && lastArgs) {
+      invoke(Date.now());
+      clearAllTimers();
+      lastCallTime = null;
+    }
+  };
+  return debounced;
+}
+function throttle(fn, wait) {
+  let lastTime = 0;
+  let timer = null;
+  let lastArgs = null;
+  const throttled = function(...args) {
+    const now = Date.now();
+    const remaining = wait - (now - lastTime);
+    if (remaining <= 0) {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      lastTime = now;
+      lastArgs = null;
+      fn.apply(this, args);
+    } else {
+      lastArgs = args;
+      if (!timer) {
+        timer = setTimeout(() => {
+          lastTime = Date.now();
+          timer = null;
+          if (lastArgs) {
+            fn.apply(this, lastArgs);
+            lastArgs = null;
+          }
+        }, remaining);
+      }
+    }
+  };
+  return throttled;
+}
+function memoize(fn, resolver) {
+  const cache = /* @__PURE__ */ new Map();
+  const memoized = function(...args) {
+    const key = resolver ? resolver(...args) : String(args[0]);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = fn.apply(this, args);
+    cache.set(key, result);
+    return result;
+  };
+  memoized.cache = cache;
+  return memoized;
+}
+function retry(fn, options) {
+  const {
+    attempts = 3,
+    baseDelay = 1e3,
+    maxDelay = 3e4,
+    shouldRetry = () => true
+  } = options ?? {};
+  let attempt = 0;
+  const execute = () => {
+    attempt++;
+    return fn().catch((error) => {
+      if (attempt >= attempts || !shouldRetry(error)) {
+        throw error;
+      }
+      const delay = Math.min(
+        baseDelay * Math.pow(2, attempt - 1) + Math.random() * baseDelay,
+        maxDelay
+      );
+      return new Promise((resolve) => {
+        setTimeout(() => {
+          resolve(execute());
+        }, delay);
+      });
+    });
+  };
+  return execute();
+}
+function noop() {
+  return void 0;
+}
+function identity(value) {
+  return value;
+}
+function once(fn) {
+  let called = false;
+  let result;
+  return function(...args) {
+    if (!called) {
+      called = true;
+      result = fn.apply(this, args);
+    }
+    return result;
+  };
+}
+export {
+  debounce,
+  deepClone,
+  deepMerge,
+  identity,
+  memoize,
+  noop,
+  once,
+  retry,
+  throttle
+};
+//# sourceMappingURL=index.js.map

package/dist/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/index.ts"],"sourcesContent":["export interface DebounceOptions {\n  leading?: boolean\n  trailing?: boolean\n  maxWait?: number\n}\n\nexport interface DebouncedFunction<T extends (...args: unknown[]) => unknown> {\n  (...args: Parameters<T>): void\n  cancel(): void\n  flush(): void\n}\n\nexport interface MemoizedFunction<T extends (...args: unknown[]) => unknown> {\n  (...args: Parameters<T>): ReturnType<T>\n  cache: Map<string, ReturnType<T>>\n}\n\nexport interface RetryOptions {\n  attempts?: number\n  baseDelay?: number\n  maxDelay?: number\n  shouldRetry?: (error: unknown) => boolean\n}\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  if (value === null || typeof value !== 'object') return false\n  const proto = Object.getPrototypeOf(value)\n  return proto === Object.prototype || proto === null\n}\n\nfunction getType(value: unknown): string {\n  return Object.prototype.toString.call(value)\n}\n\nfunction clone<T>(value: T, seen: WeakMap<object, unknown>): T {\n  if (value === null || typeof value !== 'object') return value\n\n  if (seen.has(value as object)) return seen.get(value as object) as T\n\n  const tag = getType(value)\n\n  if (tag === '[object Date]') {\n    const cloned = new Date((value as unknown as Date).getTime())\n    seen.set(value as object, cloned)\n    return cloned as unknown as T\n  }\n\n  if (tag === '[object RegExp]') {\n    const regExp = value as unknown as RegExp\n    const cloned = new RegExp(regExp.source, regExp.flags)\n    cloned.lastIndex = regExp.lastIndex\n    seen.set(value as object, cloned)\n    return cloned as unknown as T\n  }\n\n  if (tag === '[object Map]') {\n    const cloned = new Map<unknown, unknown>()\n    seen.set(value as object, cloned)\n    ;(value as unknown as Map<unknown, unknown>).forEach((v, k) => {\n      cloned.set(clone(k, seen), clone(v, seen))\n    })\n    return cloned as unknown as T\n  }\n\n  if (tag === '[object Set]') {\n    const cloned = new Set<unknown>()\n    seen.set(value as object, cloned)\n    ;(value as unknown as Set<unknown>).forEach(v => {\n      cloned.add(clone(v, seen))\n    })\n    return cloned as unknown as T\n  }\n\n  if (Array.isArray(value)) {\n    const cloned: unknown[] = []\n    seen.set(value as object, cloned)\n    for (let i = 0; i < value.length; i++) {\n      cloned[i] = clone(value[i], seen)\n    }\n    return cloned as unknown as T\n  }\n\n  if (tag === '[object Object]') {\n    const cloned: Record<string, unknown> = {}\n    seen.set(value as object, cloned)\n    const keys = Object.keys(value as Record<string, unknown>)\n    for (let i = 0; i < keys.length; i++) {\n      const key = keys[i]!\n      cloned[key] = clone((value as Record<string, unknown>)[key], seen)\n    }\n    return cloned as unknown as T\n  }\n\n  return value\n}\n\n/**\n * Deep clone a value, supporting objects, arrays, Date, RegExp, Map, Set,\n * and cyclic references.\n *\n * @param value - The value to clone.\n * @returns A deep copy of the input value.\n */\nexport function deepClone<T>(value: T): T {\n  const seen = new WeakMap<object, unknown>()\n  return clone(value, seen)\n}\n\n/**\n * Deep merge multiple objects. Arrays are overwritten, not concatenated.\n * `null` and `undefined` source objects are skipped.\n *\n * @param objects - The objects to merge.\n * @returns A new object with merged properties.\n */\nexport function deepMerge<T extends Record<string, unknown>>(...objects: Partial<T>[]): T {\n  const result = {} as T\n\n  for (let i = 0; i < objects.length; i++) {\n    const obj = objects[i]\n    if (obj === null || obj === undefined) continue\n\n    const keys = Object.keys(obj) as (keyof T)[]\n    for (let j = 0; j < keys.length; j++) {\n      const key = keys[j]!\n      const val = obj[key]\n      const existing = result[key]\n\n      if (val !== undefined && isPlainObject(val) && isPlainObject(existing)) {\n        result[key] = deepMerge(\n          existing as Record<string, unknown>,\n          val as Record<string, unknown>\n        ) as T[keyof T]\n      } else if (val !== undefined) {\n        result[key] = val as T[keyof T]\n      }\n    }\n  }\n\n  return result\n}\n\n/**\n * Creates a debounced function that delays invoking `fn` until after `wait`\n * milliseconds have elapsed since the last invocation. Supports leading,\n * trailing, and maxWait options. The returned function also has `.cancel()`\n * and `.flush()` methods.\n *\n * @param fn - The function to debounce.\n * @param wait - The number of milliseconds to delay.\n * @param options - Optional configuration.\n * @returns A debounced function with `.cancel()` and `.flush()`.\n */\nexport function debounce<T extends (...args: unknown[]) => unknown>(\n  fn: T,\n  wait: number,\n  options?: DebounceOptions\n): DebouncedFunction<T> {\n  const { leading = false, trailing = true, maxWait } = options ?? {}\n\n  let timer: ReturnType<typeof setTimeout> | null = null\n  let maxTimer: ReturnType<typeof setTimeout> | null = null\n  let lastArgs: Parameters<T> | null = null\n  let lastCallTime: number | null = null\n  let lastInvokeTime = 0\n\n  function invoke(time: number): void {\n    lastInvokeTime = time\n    if (lastArgs) {\n      fn(...lastArgs)\n      lastArgs = null\n    }\n  }\n\n  function startTimer(waitTime: number): void {\n    if (timer) clearTimeout(timer)\n    timer = setTimeout(() => {\n      const now = Date.now()\n      if (lastArgs && trailing) {\n        invoke(now)\n      }\n      timer = null\n      lastCallTime = null\n    }, waitTime)\n  }\n\n  function startMaxTimer(): void {\n    if (maxWait === undefined || maxTimer) return\n    maxTimer = setTimeout(() => {\n      if (lastArgs) {\n        invoke(Date.now())\n        if (timer) {\n          clearTimeout(timer)\n          timer = null\n        }\n        lastCallTime = null\n      }\n    }, maxWait)\n  }\n\n  function clearAllTimers(): void {\n    if (timer) {\n      clearTimeout(timer)\n      timer = null\n    }\n    if (maxTimer) {\n      clearTimeout(maxTimer)\n      maxTimer = null\n    }\n  }\n\n  function shouldInvoke(time: number): boolean {\n    if (lastCallTime === null) return true\n    const timeSinceLastCall = time - lastCallTime\n    const timeSinceLastInvoke = time - lastInvokeTime\n    return (\n      timeSinceLastCall >= wait ||\n      (maxWait !== undefined && timeSinceLastInvoke >= maxWait)\n    )\n  }\n\n  const debounced = function (this: unknown, ...args: Parameters<T>): void {\n    const time = Date.now()\n    const isInvoking = shouldInvoke(time)\n\n    lastArgs = args\n    lastCallTime = time\n\n    if (isInvoking && !timer && leading) {\n      invoke(time)\n    }\n\n    if (!timer) {\n      startTimer(wait)\n      if (maxWait !== undefined) {\n        startMaxTimer()\n      }\n    }\n  } as DebouncedFunction<T>\n\n  debounced.cancel = (): void => {\n    clearAllTimers()\n    lastArgs = null\n    lastCallTime = null\n    lastInvokeTime = 0\n  }\n\n  debounced.flush = (): void => {\n    if (timer && lastArgs) {\n      invoke(Date.now())\n      clearAllTimers()\n      lastCallTime = null\n    }\n  }\n\n  return debounced\n}\n\n/**\n * Creates a throttled function that only invokes `fn` at most once per\n * `wait` milliseconds.\n *\n * @param fn - The function to throttle.\n * @param wait - The number of milliseconds to throttle invocations to.\n * @returns A throttled function.\n */\nexport function throttle<T extends (...args: unknown[]) => unknown>(\n  fn: T,\n  wait: number\n): (...args: Parameters<T>) => void {\n  let lastTime = 0\n  let timer: ReturnType<typeof setTimeout> | null = null\n  let lastArgs: Parameters<T> | null = null\n\n  const throttled = function (this: unknown, ...args: Parameters<T>): void {\n    const now = Date.now()\n    const remaining = wait - (now - lastTime)\n\n    if (remaining <= 0) {\n      if (timer) {\n        clearTimeout(timer)\n        timer = null\n      }\n      lastTime = now\n      lastArgs = null\n      fn.apply(this, args)\n    } else {\n      lastArgs = args\n      if (!timer) {\n        timer = setTimeout(() => {\n          lastTime = Date.now()\n          timer = null\n          if (lastArgs) {\n            fn.apply(this, lastArgs)\n            lastArgs = null\n          }\n        }, remaining)\n      }\n    }\n  }\n\n  return throttled\n}\n\n/**\n * Creates a memoized version of `fn`. Uses a `Map` cache keyed by the\n * first argument by default, or by a custom `resolver` function.\n *\n * @param fn - The function to memoize.\n * @param resolver - Optional function to determine the cache key.\n * @returns The memoized function with a `.cache` property.\n */\nexport function memoize<T extends (...args: unknown[]) => unknown>(\n  fn: T,\n  resolver?: (...args: Parameters<T>) => string\n): MemoizedFunction<T> {\n  const cache = new Map<string, ReturnType<T>>()\n\n  const memoized = function (this: unknown, ...args: Parameters<T>): ReturnType<T> {\n    const key = resolver ? resolver(...args) : String(args[0])\n    if (cache.has(key)) {\n      return cache.get(key) as ReturnType<T>\n    }\n    const result = fn.apply(this, args) as ReturnType<T>\n    cache.set(key, result)\n    return result\n  }\n\n  memoized.cache = cache\n\n  return memoized as MemoizedFunction<T>\n}\n\n/**\n * Retries an async function with exponential backoff and jitter.\n *\n * @param fn - The async function to retry.\n * @param options - Retry configuration.\n * @returns A promise that resolves with the function result.\n */\nexport function retry<T>(\n  fn: () => Promise<T>,\n  options?: RetryOptions\n): Promise<T> {\n  const {\n    attempts = 3,\n    baseDelay = 1000,\n    maxDelay = 30000,\n    shouldRetry = () => true,\n  } = options ?? {}\n\n  let attempt = 0\n\n  const execute = (): Promise<T> => {\n    attempt++\n    return fn().catch((error: unknown) => {\n      if (attempt >= attempts || !shouldRetry(error)) {\n        throw error\n      }\n\n      const delay = Math.min(\n        baseDelay * Math.pow(2, attempt - 1) + Math.random() * baseDelay,\n        maxDelay\n      )\n\n      return new Promise<T>(resolve => {\n        setTimeout(() => {\n          resolve(execute())\n        }, delay)\n      })\n    })\n  }\n\n  return execute()\n}\n\n/**\n * A no-operation function that returns `undefined`.\n */\nexport function noop(): void {\n  return undefined\n}\n\n/**\n * Returns the given value unchanged.\n *\n * @param value - The value to return.\n * @returns The same value.\n */\nexport function identity<T>(value: T): T {\n  return value\n}\n\n/**\n * Creates a function that invokes `fn` only once. Subsequent calls return\n * the result of the first invocation.\n *\n * @param fn - The function to wrap.\n * @returns A function that runs only once.\n */\nexport function once<T extends (...args: unknown[]) => unknown>(\n  fn: T\n): (...args: Parameters<T>) => ReturnType<T> {\n  let called = false\n  let result: ReturnType<T>\n\n  return function (this: unknown, ...args: Parameters<T>): ReturnType<T> {\n    if (!called) {\n      called = true\n      result = fn.apply(this, args) as ReturnType<T>\n    }\n    return result\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/crypto/index.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Simple hash function using the djb2 algorithm.
+ * Fast, non-cryptographic — suitable for hashtables, not security.
+ *
+ * @param str - The string to hash.
+ * @returns A 32-bit integer hash.
+ */
+declare function hash(str: string): number;
+/**
+ * Produces a deterministic hex hash from a string.
+ * NOT actual MD5 — use for cache keys / deterministic IDs.
+ *
+ * @param str - The string to hash.
+ * @returns A 32-character hex string.
+ */
+declare function simpleHash(str: string): string;
+/**
+ * Generates random bytes as a hex string.
+ *
+ * @param size - Number of random bytes (default 16).
+ * @returns A hex string of length `size * 2`.
+ */
+declare function randomHex(size?: number): string;
+/**
+ * Encodes a string to base64. Works in both Node.js and browser.
+ * Handles UTF-8 characters correctly.
+ *
+ * @param str - The string to encode.
+ * @returns The base64-encoded string.
+ */
+declare function base64Encode(str: string): string;
+/**
+ * Decodes a base64-encoded string. Works in both Node.js and browser.
+ *
+ * @param str - The base64 string to decode.
+ * @returns The decoded string.
+ */
+declare function base64Decode(str: string): string;
+/**
+ * Generates a cryptographically random token string.
+ *
+ * @param bytes - Number of random bytes (default 32 → 64-char hex).
+ * @returns A hex string suitable for API keys, reset tokens, etc.
+ */
+declare function generateToken(bytes?: number): string;
+/**
+ * Generates a numeric OTP of the given length.
+ *
+ * @param length - Number of digits (default 6).
+ * @returns A numeric string of the specified length.
+ */
+declare function generateOTP(length?: number): string;
+/**
+ * Simple XOR cipher — symmetrical, for light obfuscation only.
+ * NOT real encryption.
+ *
+ * @param str - The input string.
+ * @param key - The cipher key.
+ * @returns The XOR-transformed string.
+ */
+declare function xorCipher(str: string, key: string): string;
+/**
+ * Computes a simple checksum (CRC-like) for file integrity checks.
+ *
+ * @param input - The input string.
+ * @returns An 8-character hex checksum.
+ */
+declare function checksum(input: string): string;
+/**
+ * Constant-time string comparison to prevent timing attacks.
+ *
+ * @param a - First string.
+ * @param b - Second string.
+ * @returns Whether the strings are equal.
+ */
+declare function constantTimeEqual(a: string, b: string): boolean;
+
+export { base64Decode, base64Encode, checksum, constantTimeEqual, generateOTP, generateToken, hash, randomHex, simpleHash, xorCipher };

package/dist/crypto/index.js

@@ -0,0 +1,147 @@
+// src/crypto/index.ts
+function hash(str) {
+  let h = 5381;
+  for (let i = 0; i < str.length; i++) {
+    h = (h << 5) + h + str.charCodeAt(i) | 0;
+  }
+  return h >>> 0;
+}
+function simpleHash(str) {
+  let h1 = 1732584193;
+  let h2 = 4023233417;
+  let h3 = 2562383102;
+  let h4 = 271733878;
+  for (let i = 0; i < str.length; i++) {
+    const c = str.charCodeAt(i);
+    h1 = h1 + c | 0;
+    h2 = h2 + (c << 3) + i | 0;
+    h3 = h3 ^ c | 0;
+    h4 = h4 + (c << 5) + (c << 1) | 0;
+  }
+  const toHex = (n) => (n >>> 0).toString(16).padStart(8, "0");
+  return toHex(h1) + toHex(h2) + toHex(h3) + toHex(h4);
+}
+function getRandomBytes(size) {
+  const bytes = new Uint8Array(size);
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < size; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  return bytes;
+}
+function randomHex(size = 16) {
+  const bytes = getRandomBytes(size);
+  let result = "";
+  for (let i = 0; i < bytes.length; i++) {
+    result += bytes[i].toString(16).padStart(2, "0");
+  }
+  return result;
+}
+function utf8ToBytes(str) {
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(str);
+  }
+  const bytes = new Uint8Array(str.length);
+  for (let i = 0; i < str.length; i++) {
+    bytes[i] = str.charCodeAt(i);
+  }
+  return bytes;
+}
+function bytesToUtf8(bytes) {
+  if (typeof TextDecoder !== "undefined") {
+    return new TextDecoder().decode(bytes);
+  }
+  let result = "";
+  for (let i = 0; i < bytes.length; i++) {
+    result += String.fromCharCode(bytes[i]);
+  }
+  return result;
+}
+function bytesToBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  if (typeof btoa === "function") {
+    return btoa(binary);
+  }
+  return Buffer.from(binary, "latin1").toString("base64");
+}
+function base64ToBytes(str) {
+  let binary;
+  if (typeof atob === "function") {
+    binary = atob(str);
+  } else {
+    binary = Buffer.from(str, "base64").toString("latin1");
+  }
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function base64Encode(str) {
+  const bytes = utf8ToBytes(str);
+  return bytesToBase64(bytes);
+}
+function base64Decode(str) {
+  const bytes = base64ToBytes(str);
+  return bytesToUtf8(bytes);
+}
+function generateToken(bytes = 32) {
+  return randomHex(bytes);
+}
+function generateOTP(length = 6) {
+  const bytes = getRandomBytes(length);
+  let otp = "";
+  for (let i = 0; i < length; i++) {
+    otp += (bytes[i] % 10).toString();
+  }
+  return otp;
+}
+function xorCipher(str, key) {
+  let result = "";
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i) ^ key.charCodeAt(i % key.length);
+    result += String.fromCharCode(code);
+  }
+  return result;
+}
+function checksum(input) {
+  let crc = 4294967295;
+  for (let i = 0; i < input.length; i++) {
+    crc ^= input.charCodeAt(i);
+    for (let j = 0; j < 8; j++) {
+      if (crc & 1) {
+        crc = crc >>> 1 ^ 3988292384;
+      } else {
+        crc = crc >>> 1;
+      }
+    }
+  }
+  return ((crc ^ 4294967295) >>> 0).toString(16).padStart(8, "0");
+}
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let result = 0;
+  for (let i = 0; i < a.length; i++) {
+    result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return result === 0;
+}
+export {
+  base64Decode,
+  base64Encode,
+  checksum,
+  constantTimeEqual,
+  generateOTP,
+  generateToken,
+  hash,
+  randomHex,
+  simpleHash,
+  xorCipher
+};
+//# sourceMappingURL=index.js.map

package/dist/crypto/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/crypto/index.ts"],"sourcesContent":["/**\n * Simple hash function using the djb2 algorithm.\n * Fast, non-cryptographic — suitable for hashtables, not security.\n *\n * @param str - The string to hash.\n * @returns A 32-bit integer hash.\n */\nexport function hash(str: string): number {\n  let h = 5381\n  for (let i = 0; i < str.length; i++) {\n    h = ((h << 5) + h + str.charCodeAt(i)) | 0\n  }\n  return h >>> 0\n}\n\n/**\n * Produces a deterministic hex hash from a string.\n * NOT actual MD5 — use for cache keys / deterministic IDs.\n *\n * @param str - The string to hash.\n * @returns A 32-character hex string.\n */\nexport function simpleHash(str: string): string {\n  let h1 = 0x67452301\n  let h2 = 0xefcdab89\n  let h3 = 0x98badcfe\n  let h4 = 0x10325476\n\n  for (let i = 0; i < str.length; i++) {\n    const c = str.charCodeAt(i)\n    h1 = (h1 + c) | 0\n    h2 = (h2 + (c << 3) + i) | 0\n    h3 = (h3 ^ c) | 0\n    h4 = (h4 + (c << 5) + (c << 1)) | 0\n  }\n\n  const toHex = (n: number): string => (n >>> 0).toString(16).padStart(8, '0')\n  return toHex(h1) + toHex(h2) + toHex(h3) + toHex(h4)\n}\n\nfunction getRandomBytes(size: number): Uint8Array {\n  const bytes = new Uint8Array(size)\n  if (typeof crypto !== 'undefined' && typeof crypto.getRandomValues === 'function') {\n    crypto.getRandomValues(bytes)\n  } else {\n    for (let i = 0; i < size; i++) {\n      bytes[i] = Math.floor(Math.random() * 256)\n    }\n  }\n  return bytes\n}\n\n/**\n * Generates random bytes as a hex string.\n *\n * @param size - Number of random bytes (default 16).\n * @returns A hex string of length `size * 2`.\n */\nexport function randomHex(size: number = 16): string {\n  const bytes = getRandomBytes(size)\n  let result = ''\n  for (let i = 0; i < bytes.length; i++) {\n    result += bytes[i]!.toString(16).padStart(2, '0')\n  }\n  return result\n}\n\nfunction utf8ToBytes(str: string): Uint8Array {\n  if (typeof TextEncoder !== 'undefined') {\n    return new TextEncoder().encode(str)\n  }\n  const bytes = new Uint8Array(str.length)\n  for (let i = 0; i < str.length; i++) {\n    bytes[i] = str.charCodeAt(i)\n  }\n  return bytes\n}\n\nfunction bytesToUtf8(bytes: Uint8Array): string {\n  if (typeof TextDecoder !== 'undefined') {\n    return new TextDecoder().decode(bytes)\n  }\n  let result = ''\n  for (let i = 0; i < bytes.length; i++) {\n    result += String.fromCharCode(bytes[i]!)\n  }\n  return result\n}\n\nfunction bytesToBase64(bytes: Uint8Array): string {\n  let binary = ''\n  for (let i = 0; i < bytes.length; i++) {\n    binary += String.fromCharCode(bytes[i]!)\n  }\n  if (typeof btoa === 'function') {\n    return btoa(binary)\n  }\n  return Buffer.from(binary, 'latin1').toString('base64')\n}\n\nfunction base64ToBytes(str: string): Uint8Array {\n  let binary: string\n  if (typeof atob === 'function') {\n    binary = atob(str)\n  } else {\n    binary = Buffer.from(str, 'base64').toString('latin1')\n  }\n  const bytes = new Uint8Array(binary.length)\n  for (let i = 0; i < binary.length; i++) {\n    bytes[i] = binary.charCodeAt(i)\n  }\n  return bytes\n}\n\n/**\n * Encodes a string to base64. Works in both Node.js and browser.\n * Handles UTF-8 characters correctly.\n *\n * @param str - The string to encode.\n * @returns The base64-encoded string.\n */\nexport function base64Encode(str: string): string {\n  const bytes = utf8ToBytes(str)\n  return bytesToBase64(bytes)\n}\n\n/**\n * Decodes a base64-encoded string. Works in both Node.js and browser.\n *\n * @param str - The base64 string to decode.\n * @returns The decoded string.\n */\nexport function base64Decode(str: string): string {\n  const bytes = base64ToBytes(str)\n  return bytesToUtf8(bytes)\n}\n\n/**\n * Generates a cryptographically random token string.\n *\n * @param bytes - Number of random bytes (default 32 → 64-char hex).\n * @returns A hex string suitable for API keys, reset tokens, etc.\n */\nexport function generateToken(bytes: number = 32): string {\n  return randomHex(bytes)\n}\n\n/**\n * Generates a numeric OTP of the given length.\n *\n * @param length - Number of digits (default 6).\n * @returns A numeric string of the specified length.\n */\nexport function generateOTP(length: number = 6): string {\n  const bytes = getRandomBytes(length)\n  let otp = ''\n  for (let i = 0; i < length; i++) {\n    otp += (bytes[i]! % 10).toString()\n  }\n  return otp\n}\n\n/**\n * Simple XOR cipher — symmetrical, for light obfuscation only.\n * NOT real encryption.\n *\n * @param str - The input string.\n * @param key - The cipher key.\n * @returns The XOR-transformed string.\n */\nexport function xorCipher(str: string, key: string): string {\n  let result = ''\n  for (let i = 0; i < str.length; i++) {\n    const code = str.charCodeAt(i) ^ key.charCodeAt(i % key.length)\n    result += String.fromCharCode(code)\n  }\n  return result\n}\n\n/**\n * Computes a simple checksum (CRC-like) for file integrity checks.\n *\n * @param input - The input string.\n * @returns An 8-character hex checksum.\n */\nexport function checksum(input: string): string {\n  let crc = 0xffffffff\n  for (let i = 0; i < input.length; i++) {\n    crc ^= input.charCodeAt(i)\n    for (let j = 0; j < 8; j++) {\n      if (crc & 1) {\n        crc = (crc >>> 1) ^ 0xedb88320\n      } else {\n        crc = crc >>> 1\n      }\n    }\n  }\n  return ((crc ^ 0xffffffff) >>> 0).toString(16).padStart(8, '0')\n}\n\n/**\n * Constant-time string comparison to prevent timing attacks.\n *\n * @param a - First string.\n * @param b - Second string.\n * @returns Whether the strings are equal.\n */\nexport function constantTimeEqual(a: string, b: string): boolean {\n  if (a.length !== b.length) return false\n  let result = 0\n  for (let i = 0; i < a.length; i++) {\n    result |= a.charCodeAt(i) ^ b.charCodeAt(i)\n  }\n  return result === 0\n}\n"],"mappings":"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","names":[]}