{"version":3,"file":"pseudo-shuffle-browser.cjs","sources":["../src/fe1-browser.ts","../src/pseudo-shuffle-browser.ts"],"sourcesContent":["/**\n * Browser-compatible FE1 Format Preserving Encryption implementation\n * Based on node-fe1-fpe but using Web Crypto API instead of Node.js crypto\n */\n\n// BigInt buffer conversion utilities\nfunction toBigIntBE(buffer: Uint8Array): bigint {\n  let result = 0n;\n  for (let i = 0; i < buffer.length; i++) {\n    result = (result << 8n) | BigInt(buffer[i]);\n  }\n  return result;\n}\n\nfunction toBufferBE(value: bigint, length: number): Uint8Array {\n  const buffer = new Uint8Array(length);\n  let num = value;\n  for (let i = length - 1; i >= 0; i--) {\n    buffer[i] = Number(num & 0xFFn);\n    num = num >> 8n;\n  }\n  return buffer;\n}\n\nfunction encode(long: bigint): Uint8Array {\n  return toBufferBE(long, 8);\n}\n\nfunction toBeBytes(num: number | bigint): Uint8Array {\n  // Ensure num is a valid integer before converting to BigInt\n  if (typeof num === 'number') {\n    if (!Number.isFinite(num) || !Number.isInteger(num)) {\n      throw new Error(`Invalid number for BigInt conversion: ${num}`);\n    }\n  }\n  return toBufferBE(BigInt(num), 8);\n}\n\nfunction assureBigInt(n: number | bigint): bigint {\n  if (typeof n === 'bigint') return n;\n  if (typeof n === 'number') {\n    if (!Number.isFinite(n) || !Number.isInteger(n)) {\n      throw new Error(`Invalid number for BigInt conversion: ${n}`);\n    }\n  }\n  return BigInt(n);\n}\n\n// String to UTF-16LE buffer conversion\nfunction stringToUtf16LE(str: string): Uint8Array {\n  const buffer = new Uint8Array(str.length * 2);\n  for (let i = 0; i < str.length; i++) {\n    const charCode = str.charCodeAt(i);\n    buffer[i * 2] = charCode & 0xFF;\n    buffer[i * 2 + 1] = (charCode >> 8) & 0xFF;\n  }\n  return buffer;\n}\n\n// Prime factorization\nconst factorCache: { [key: string]: [bigint, bigint] } = {};\n\nclass PrimeGenerator {\n  private markedNotPrimeMap: { [key: number]: number[] } = {};\n  private seq = 1;\n\n  next(): number {\n    while (true) {\n      this.seq += 1;\n      if (!this.markedNotPrimeMap[this.seq]) {\n        this.markedNotPrimeMap[this.seq ** 2] = [this.seq];\n        return this.seq;\n      }\n      const primes = this.markedNotPrimeMap[this.seq];\n      primes.forEach((prime) => {\n        const nextMultipleOfPrime = prime + this.seq;\n        if (this.markedNotPrimeMap[nextMultipleOfPrime]) {\n          this.markedNotPrimeMap[nextMultipleOfPrime].push(prime);\n        } else {\n          this.markedNotPrimeMap[nextMultipleOfPrime] = [prime];\n        }\n      });\n      delete this.markedNotPrimeMap[this.seq];\n    }\n  }\n}\n\nfunction factor(n: bigint): [bigint, bigint] {\n  const primes = new PrimeGenerator();\n  let a = 1n;\n  let b = 1n;\n  let p: bigint;\n\n  for (let k = 0n; n > 1n; k++) {\n    p = BigInt(primes.next());\n    if (n % p === 0n) {\n      while (n % p === 0n) {\n        b *= p;\n        if (a < b) {\n          [a, b] = [b, a];\n        }\n        n /= p;\n      }\n    }\n  }\n\n  if (a <= 1 || b <= 1) {\n    throw new Error('Could not factor n for use in FPE, prime numbers cannot be used as modulus');\n  }\n\n  return [a, b];\n}\n\nfunction getCachedFactor(num: number | bigint): [bigint, bigint] {\n  const key = String(num);\n  if (factorCache[key] === undefined) {\n    factorCache[key] = factor(assureBigInt(num));\n  }\n  return factorCache[key];\n}\n\n// HMAC-SHA256 implementation using Web Crypto API\nasync function hmacSha256(key: Uint8Array, data: Uint8Array): Promise<Uint8Array> {\n  // Ensure proper ArrayBuffer type for Web Crypto API\n  const keyBuffer = new Uint8Array(key);\n  const dataBuffer = new Uint8Array(data);\n  \n  const cryptoKey = await crypto.subtle.importKey(\n    'raw',\n    keyBuffer,\n    { name: 'HMAC', hash: 'SHA-256' },\n    false,\n    ['sign']\n  );\n  const signature = await crypto.subtle.sign('HMAC', cryptoKey, dataBuffer);\n  return new Uint8Array(signature);\n}\n\n// Concatenate multiple Uint8Arrays\nfunction concatBuffers(...buffers: Uint8Array[]): Uint8Array {\n  const totalLength = buffers.reduce((sum, buf) => sum + buf.length, 0);\n  const result = new Uint8Array(totalLength);\n  let offset = 0;\n  for (const buf of buffers) {\n    result.set(buf, offset);\n    offset += buf.length;\n  }\n  return result;\n}\n\nclass FPEEncryptor {\n  private keyByte: Uint8Array;\n  private macNT: Uint8Array | null = null;\n\n  constructor(key: string | Uint8Array) {\n    this.keyByte = typeof key === 'string' ? stringToUtf16LE(key) : key;\n    // macNT will be initialized asynchronously\n  }\n\n  async initialize(modulus: bigint, tweak: string | Uint8Array): Promise<void> {\n    const nBin = encode(modulus);\n    const tweakByte = typeof tweak === 'string' ? stringToUtf16LE(tweak) : tweak;\n    \n    const data = concatBuffers(\n      toBeBytes(nBin.length),\n      nBin,\n      toBeBytes(tweakByte.length),\n      tweakByte\n    );\n    \n    this.macNT = await hmacSha256(this.keyByte, data);\n  }\n\n  async format(roundNumber: number, r: bigint): Promise<bigint> {\n    if (!this.macNT) {\n      throw new Error('FPEEncryptor not initialized');\n    }\n    \n    const rBin = encode(r);\n    const data = concatBuffers(\n      this.macNT,\n      toBeBytes(roundNumber),\n      toBeBytes(rBin.length),\n      rBin\n    );\n    \n    const mac = await hmacSha256(this.keyByte, data);\n    return toBigIntBE(mac);\n  }\n}\n\n/**\n * Generic Z_n FPE encryption, FE1 scheme.\n */\nexport async function encrypt(\n  modulus: number,\n  subject: number,\n  key: string | Uint8Array,\n  tweak: string | Uint8Array,\n  rounds: number = 3\n): Promise<number> {\n  if (!Number.isInteger(rounds) || rounds < 1) {\n    throw Error('Parameter <round> must be a positive integer.');\n  }\n\n  const modulusBigInt = assureBigInt(modulus);\n  const cipher = new FPEEncryptor(key);\n  await cipher.initialize(modulusBigInt, tweak);\n  \n  const [firstFactor, secondFactor] = getCachedFactor(modulus);\n\n  let right: bigint;\n  let x = BigInt(subject);\n\n  for (let i = 0; i < rounds; i++) {\n    right = x % secondFactor;\n    const formatResult = await cipher.format(i, right);\n    x = (firstFactor * right) + ((formatResult + x / secondFactor) % firstFactor);\n  }\n\n  return Number(x);\n}\n\n/**\n * Generic Z_n FPE decryption, FE1 scheme.\n */\nexport async function decrypt(\n  modulus: number,\n  cryptedSubject: number,\n  key: string | Uint8Array,\n  tweak: string | Uint8Array,\n  rounds: number = 3\n): Promise<number> {\n  if (!Number.isInteger(rounds) || rounds < 1) {\n    throw Error('Parameter <round> must be a positive integer.');\n  }\n\n  const modulusBigInt = assureBigInt(modulus);\n  const cipher = new FPEEncryptor(key);\n  await cipher.initialize(modulusBigInt, tweak);\n  \n  const [firstFactor, secondFactor] = getCachedFactor(modulus);\n\n  let modulu: bigint;\n  let right: bigint;\n  let left: bigint;\n  let x = BigInt(cryptedSubject);\n\n  for (let i = rounds - 1; i >= 0; i--) {\n    right = x / firstFactor;\n    const formatResult = await cipher.format(i, right);\n    modulu = (formatResult - (x % firstFactor)) % firstFactor;\n    left = modulu > 0n ? firstFactor - modulu : -modulu;\n    x = (secondFactor * left) + right;\n  }\n\n  return Number(x);\n}\n\nexport default { encrypt, decrypt };\n","import * as fe1 from \"./fe1-browser\";\n\nexport interface IPsuedoShuffleOption {\n  /**\n   * The starting value of the shuffleable range.\n   */\n  min: number;\n  /**\n   * The ending value of the shuffleable range.\n   *\n   * Algorithm can be applied only when the difference\n   * between the min and max values is at least 4.\n   */\n  max: number;\n  /**\n   * The index value to be shuffled.\n   */\n  index: number;\n  /**\n   * The private key used to encrypt the index value.\n   *\n   * If not specified, the default value is used.\n   * (**Default value:** `psuedo-shuffle`)\n   */\n  privateKey?: string;\n  /**\n   * The public key used to encrypt the index value.\n   *\n   * If not specified, the default value is used.\n   * (**Default value:** `psuedo-shuffle`)\n   */\n  publicKey?: string;\n}\n\nconst defaultKey = \"psuedo-shuffle\";\n\nexport const encode = async ({\n  index,\n  min,\n  max,\n  privateKey = defaultKey,\n  publicKey = defaultKey,\n}: IPsuedoShuffleOption): Promise<number> => {\n  // Validate inputs\n  if (!Number.isFinite(index) || !Number.isInteger(index)) {\n    throw new Error(`Invalid index: ${index}. Must be a finite integer.`);\n  }\n  if (!Number.isFinite(min) || !Number.isInteger(min)) {\n    throw new Error(`Invalid min: ${min}. Must be a finite integer.`);\n  }\n  if (!Number.isFinite(max) || !Number.isInteger(max)) {\n    throw new Error(`Invalid max: ${max}. Must be a finite integer.`);\n  }\n  if (min >= max) {\n    throw new Error(`Invalid range: min (${min}) must be less than max (${max}).`);\n  }\n\n  // Algorithm can be applied only when the difference\n  // between the min and max values is at least 4.\n  if (max - min < 3) return index;\n\n  // Algorithms can only be applied when the\n  // range difference between min and max is prime number.\n  // Therefore, when the range difference is not prime number,\n  // the algorithm is applied while leaving the last index intact.\n  if ((max - min) % 2 === 0) {\n    const middle = Math.ceil(min + (max - min) / 2);\n    if (index === middle) return max;\n    if (index === max) index = middle;\n    --max;\n  }\n\n  // Algorithm does not apply to index\n  // values that are not in the range.\n  if (index < min || index > max) return index;\n\n  return (\n    (await fe1.encrypt(\n      max - min + 1,\n      index - min,\n      privateKey,\n      publicKey\n    )) + min\n  );\n};\n\nexport const decode = async ({\n  index,\n  min,\n  max,\n  privateKey = defaultKey,\n  publicKey = defaultKey,\n}: IPsuedoShuffleOption): Promise<number> => {\n  // Validate inputs\n  if (!Number.isFinite(index) || !Number.isInteger(index)) {\n    throw new Error(`Invalid index: ${index}. Must be a finite integer.`);\n  }\n  if (!Number.isFinite(min) || !Number.isInteger(min)) {\n    throw new Error(`Invalid min: ${min}. Must be a finite integer.`);\n  }\n  if (!Number.isFinite(max) || !Number.isInteger(max)) {\n    throw new Error(`Invalid max: ${max}. Must be a finite integer.`);\n  }\n  if (min >= max) {\n    throw new Error(`Invalid range: min (${min}) must be less than max (${max}).`);\n  }\n\n  // Algorithm can be applied only when the difference\n  // between the min and max values is at least 4.\n  if (max - min < 3) return index;\n\n  // Algorithms can only be applied when the\n  // range difference between min and max is prime number.\n  // Therefore, when the range difference is not prime number,\n  // the algorithm is applied while leaving the last index intact.\n\n  const isNonPrime = (max - min) % 2 === 0;\n  if (isNonPrime) {\n    if (index > max - 1) {\n      return Math.ceil(min + (max - min) / 2);\n    }\n    --max;\n  }\n\n  // Algorithm does not apply to index\n  // values that are not in the range.\n  if (index < min || index > max) return index;\n\n  if (isNonPrime) {\n    if (\n      index ===\n      (await encode({\n        index: Math.ceil(min + (max - min) / 2),\n        max,\n        min,\n        privateKey,\n        publicKey,\n      }))\n    )\n      return max + 1;\n  }\n  return (\n    (await fe1.decrypt(\n      max - min + 1,\n      index - min,\n      privateKey,\n      publicKey\n    )) + min\n  );\n};\n"],"names":["pact","state","value","s","_Pact","o","_settle","bind","v","then","observer","prototype","onFulfilled","onRejected","result","this","callback","e","_this","thenable","toBigIntBE","buffer","i","length","BigInt","toBufferBE","Uint8Array","num","Number","encode","long","toBeBytes","isFinite","isInteger","Error","assureBigInt","n","stringToUtf16LE","str","charCode","charCodeAt","hmacSha256","key","data","keyBuffer","dataBuffer","Promise","resolve","crypto","subtle","importKey","name","hash","cryptoKey","sign","signature","reject","factorCache","PrimeGenerator","markedNotPrimeMap","seq","next","Math","pow","forEach","prime","nextMultipleOfPrime","push","getCachedFactor","String","undefined","p","primes","a","b","k","_ref","factor","concatBuffers","_step","buffers","slice","call","arguments","totalLength","reduce","sum","buf","offset","_iterator","_createForOfIteratorHelperLoose","done","set","FPEEncryptor","keyByte","macNT","_proto2","initialize","modulus","tweak","_this2","nBin","tweakByte","_hmacSha","format","roundNumber","r","_this3","rBin","defaultKey","index","min","max","_ref$privateKey","privateKey","_ref$publicKey","publicKey","middle","ceil","subject","rounds","modulusBigInt","cipher","_temp2","x","right","_getCachedFactor","firstFactor","secondFactor","_temp","_for","formatResult","fe1","_fe1$encrypt","_ref2","_ref2$privateKey","_ref2$publicKey","_temp3","_exit","_result","cryptedSubject","_temp4","modulu","_getCachedFactor2","_fe1$decrypt","isNonPrime","_encode"],"mappings":"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"}