@nostrwatch/utils 0.2.0

package/dist/browser/node_modules/.pnpm/@jridgewell_sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sourcemap-codec.esm.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs"],"sourcesContent":["// src/vlq.ts\nvar comma = \",\".charCodeAt(0);\nvar semicolon = \";\".charCodeAt(0);\nvar chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\nvar intToChar = new Uint8Array(64);\nvar charToInt = new Uint8Array(128);\nfor (let i = 0; i < chars.length; i++) {\n  const c = chars.charCodeAt(i);\n  intToChar[i] = c;\n  charToInt[c] = i;\n}\nfunction decodeInteger(reader, relative) {\n  let value = 0;\n  let shift = 0;\n  let integer = 0;\n  do {\n    const c = reader.next();\n    integer = charToInt[c];\n    value |= (integer & 31) << shift;\n    shift += 5;\n  } while (integer & 32);\n  const shouldNegate = value & 1;\n  value >>>= 1;\n  if (shouldNegate) {\n    value = -2147483648 | -value;\n  }\n  return relative + value;\n}\nfunction encodeInteger(builder, num, relative) {\n  let delta = num - relative;\n  delta = delta < 0 ? -delta << 1 | 1 : delta << 1;\n  do {\n    let clamped = delta & 31;\n    delta >>>= 5;\n    if (delta > 0) clamped |= 32;\n    builder.write(intToChar[clamped]);\n  } while (delta > 0);\n  return num;\n}\nfunction hasMoreVlq(reader, max) {\n  if (reader.pos >= max) return false;\n  return reader.peek() !== comma;\n}\n\n// src/strings.ts\nvar bufLength = 1024 * 16;\nvar td = typeof TextDecoder !== \"undefined\" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== \"undefined\" ? {\n  decode(buf) {\n    const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);\n    return out.toString();\n  }\n} : {\n  decode(buf) {\n    let out = \"\";\n    for (let i = 0; i < buf.length; i++) {\n      out += String.fromCharCode(buf[i]);\n    }\n    return out;\n  }\n};\nvar StringWriter = class {\n  constructor() {\n    this.pos = 0;\n    this.out = \"\";\n    this.buffer = new Uint8Array(bufLength);\n  }\n  write(v) {\n    const { buffer } = this;\n    buffer[this.pos++] = v;\n    if (this.pos === bufLength) {\n      this.out += td.decode(buffer);\n      this.pos = 0;\n    }\n  }\n  flush() {\n    const { buffer, out, pos } = this;\n    return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;\n  }\n};\nvar StringReader = class {\n  constructor(buffer) {\n    this.pos = 0;\n    this.buffer = buffer;\n  }\n  next() {\n    return this.buffer.charCodeAt(this.pos++);\n  }\n  peek() {\n    return this.buffer.charCodeAt(this.pos);\n  }\n  indexOf(char) {\n    const { buffer, pos } = this;\n    const idx = buffer.indexOf(char, pos);\n    return idx === -1 ? buffer.length : idx;\n  }\n};\n\n// src/scopes.ts\nvar EMPTY = [];\nfunction decodeOriginalScopes(input) {\n  const { length } = input;\n  const reader = new StringReader(input);\n  const scopes = [];\n  const stack = [];\n  let line = 0;\n  for (; reader.pos < length; reader.pos++) {\n    line = decodeInteger(reader, line);\n    const column = decodeInteger(reader, 0);\n    if (!hasMoreVlq(reader, length)) {\n      const last = stack.pop();\n      last[2] = line;\n      last[3] = column;\n      continue;\n    }\n    const kind = decodeInteger(reader, 0);\n    const fields = decodeInteger(reader, 0);\n    const hasName = fields & 1;\n    const scope = hasName ? [line, column, 0, 0, kind, decodeInteger(reader, 0)] : [line, column, 0, 0, kind];\n    let vars = EMPTY;\n    if (hasMoreVlq(reader, length)) {\n      vars = [];\n      do {\n        const varsIndex = decodeInteger(reader, 0);\n        vars.push(varsIndex);\n      } while (hasMoreVlq(reader, length));\n    }\n    scope.vars = vars;\n    scopes.push(scope);\n    stack.push(scope);\n  }\n  return scopes;\n}\nfunction encodeOriginalScopes(scopes) {\n  const writer = new StringWriter();\n  for (let i = 0; i < scopes.length; ) {\n    i = _encodeOriginalScopes(scopes, i, writer, [0]);\n  }\n  return writer.flush();\n}\nfunction _encodeOriginalScopes(scopes, index, writer, state) {\n  const scope = scopes[index];\n  const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope;\n  if (index > 0) writer.write(comma);\n  state[0] = encodeInteger(writer, startLine, state[0]);\n  encodeInteger(writer, startColumn, 0);\n  encodeInteger(writer, kind, 0);\n  const fields = scope.length === 6 ? 1 : 0;\n  encodeInteger(writer, fields, 0);\n  if (scope.length === 6) encodeInteger(writer, scope[5], 0);\n  for (const v of vars) {\n    encodeInteger(writer, v, 0);\n  }\n  for (index++; index < scopes.length; ) {\n    const next = scopes[index];\n    const { 0: l, 1: c } = next;\n    if (l > endLine || l === endLine && c >= endColumn) {\n      break;\n    }\n    index = _encodeOriginalScopes(scopes, index, writer, state);\n  }\n  writer.write(comma);\n  state[0] = encodeInteger(writer, endLine, state[0]);\n  encodeInteger(writer, endColumn, 0);\n  return index;\n}\nfunction decodeGeneratedRanges(input) {\n  const { length } = input;\n  const reader = new StringReader(input);\n  const ranges = [];\n  const stack = [];\n  let genLine = 0;\n  let definitionSourcesIndex = 0;\n  let definitionScopeIndex = 0;\n  let callsiteSourcesIndex = 0;\n  let callsiteLine = 0;\n  let callsiteColumn = 0;\n  let bindingLine = 0;\n  let bindingColumn = 0;\n  do {\n    const semi = reader.indexOf(\";\");\n    let genColumn = 0;\n    for (; reader.pos < semi; reader.pos++) {\n      genColumn = decodeInteger(reader, genColumn);\n      if (!hasMoreVlq(reader, semi)) {\n        const last = stack.pop();\n        last[2] = genLine;\n        last[3] = genColumn;\n        continue;\n      }\n      const fields = decodeInteger(reader, 0);\n      const hasDefinition = fields & 1;\n      const hasCallsite = fields & 2;\n      const hasScope = fields & 4;\n      let callsite = null;\n      let bindings = EMPTY;\n      let range;\n      if (hasDefinition) {\n        const defSourcesIndex = decodeInteger(reader, definitionSourcesIndex);\n        definitionScopeIndex = decodeInteger(\n          reader,\n          definitionSourcesIndex === defSourcesIndex ? definitionScopeIndex : 0\n        );\n        definitionSourcesIndex = defSourcesIndex;\n        range = [genLine, genColumn, 0, 0, defSourcesIndex, definitionScopeIndex];\n      } else {\n        range = [genLine, genColumn, 0, 0];\n      }\n      range.isScope = !!hasScope;\n      if (hasCallsite) {\n        const prevCsi = callsiteSourcesIndex;\n        const prevLine = callsiteLine;\n        callsiteSourcesIndex = decodeInteger(reader, callsiteSourcesIndex);\n        const sameSource = prevCsi === callsiteSourcesIndex;\n        callsiteLine = decodeInteger(reader, sameSource ? callsiteLine : 0);\n        callsiteColumn = decodeInteger(\n          reader,\n          sameSource && prevLine === callsiteLine ? callsiteColumn : 0\n        );\n        callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn];\n      }\n      range.callsite = callsite;\n      if (hasMoreVlq(reader, semi)) {\n        bindings = [];\n        do {\n          bindingLine = genLine;\n          bindingColumn = genColumn;\n          const expressionsCount = decodeInteger(reader, 0);\n          let expressionRanges;\n          if (expressionsCount < -1) {\n            expressionRanges = [[decodeInteger(reader, 0)]];\n            for (let i = -1; i > expressionsCount; i--) {\n              const prevBl = bindingLine;\n              bindingLine = decodeInteger(reader, bindingLine);\n              bindingColumn = decodeInteger(reader, bindingLine === prevBl ? bindingColumn : 0);\n              const expression = decodeInteger(reader, 0);\n              expressionRanges.push([expression, bindingLine, bindingColumn]);\n            }\n          } else {\n            expressionRanges = [[expressionsCount]];\n          }\n          bindings.push(expressionRanges);\n        } while (hasMoreVlq(reader, semi));\n      }\n      range.bindings = bindings;\n      ranges.push(range);\n      stack.push(range);\n    }\n    genLine++;\n    reader.pos = semi + 1;\n  } while (reader.pos < length);\n  return ranges;\n}\nfunction encodeGeneratedRanges(ranges) {\n  if (ranges.length === 0) return \"\";\n  const writer = new StringWriter();\n  for (let i = 0; i < ranges.length; ) {\n    i = _encodeGeneratedRanges(ranges, i, writer, [0, 0, 0, 0, 0, 0, 0]);\n  }\n  return writer.flush();\n}\nfunction _encodeGeneratedRanges(ranges, index, writer, state) {\n  const range = ranges[index];\n  const {\n    0: startLine,\n    1: startColumn,\n    2: endLine,\n    3: endColumn,\n    isScope,\n    callsite,\n    bindings\n  } = range;\n  if (state[0] < startLine) {\n    catchupLine(writer, state[0], startLine);\n    state[0] = startLine;\n    state[1] = 0;\n  } else if (index > 0) {\n    writer.write(comma);\n  }\n  state[1] = encodeInteger(writer, range[1], state[1]);\n  const fields = (range.length === 6 ? 1 : 0) | (callsite ? 2 : 0) | (isScope ? 4 : 0);\n  encodeInteger(writer, fields, 0);\n  if (range.length === 6) {\n    const { 4: sourcesIndex, 5: scopesIndex } = range;\n    if (sourcesIndex !== state[2]) {\n      state[3] = 0;\n    }\n    state[2] = encodeInteger(writer, sourcesIndex, state[2]);\n    state[3] = encodeInteger(writer, scopesIndex, state[3]);\n  }\n  if (callsite) {\n    const { 0: sourcesIndex, 1: callLine, 2: callColumn } = range.callsite;\n    if (sourcesIndex !== state[4]) {\n      state[5] = 0;\n      state[6] = 0;\n    } else if (callLine !== state[5]) {\n      state[6] = 0;\n    }\n    state[4] = encodeInteger(writer, sourcesIndex, state[4]);\n    state[5] = encodeInteger(writer, callLine, state[5]);\n    state[6] = encodeInteger(writer, callColumn, state[6]);\n  }\n  if (bindings) {\n    for (const binding of bindings) {\n      if (binding.length > 1) encodeInteger(writer, -binding.length, 0);\n      const expression = binding[0][0];\n      encodeInteger(writer, expression, 0);\n      let bindingStartLine = startLine;\n      let bindingStartColumn = startColumn;\n      for (let i = 1; i < binding.length; i++) {\n        const expRange = binding[i];\n        bindingStartLine = encodeInteger(writer, expRange[1], bindingStartLine);\n        bindingStartColumn = encodeInteger(writer, expRange[2], bindingStartColumn);\n        encodeInteger(writer, expRange[0], 0);\n      }\n    }\n  }\n  for (index++; index < ranges.length; ) {\n    const next = ranges[index];\n    const { 0: l, 1: c } = next;\n    if (l > endLine || l === endLine && c >= endColumn) {\n      break;\n    }\n    index = _encodeGeneratedRanges(ranges, index, writer, state);\n  }\n  if (state[0] < endLine) {\n    catchupLine(writer, state[0], endLine);\n    state[0] = endLine;\n    state[1] = 0;\n  } else {\n    writer.write(comma);\n  }\n  state[1] = encodeInteger(writer, endColumn, state[1]);\n  return index;\n}\nfunction catchupLine(writer, lastLine, line) {\n  do {\n    writer.write(semicolon);\n  } while (++lastLine < line);\n}\n\n// src/sourcemap-codec.ts\nfunction decode(mappings) {\n  const { length } = mappings;\n  const reader = new StringReader(mappings);\n  const decoded = [];\n  let genColumn = 0;\n  let sourcesIndex = 0;\n  let sourceLine = 0;\n  let sourceColumn = 0;\n  let namesIndex = 0;\n  do {\n    const semi = reader.indexOf(\";\");\n    const line = [];\n    let sorted = true;\n    let lastCol = 0;\n    genColumn = 0;\n    while (reader.pos < semi) {\n      let seg;\n      genColumn = decodeInteger(reader, genColumn);\n      if (genColumn < lastCol) sorted = false;\n      lastCol = genColumn;\n      if (hasMoreVlq(reader, semi)) {\n        sourcesIndex = decodeInteger(reader, sourcesIndex);\n        sourceLine = decodeInteger(reader, sourceLine);\n        sourceColumn = decodeInteger(reader, sourceColumn);\n        if (hasMoreVlq(reader, semi)) {\n          namesIndex = decodeInteger(reader, namesIndex);\n          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];\n        } else {\n          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];\n        }\n      } else {\n        seg = [genColumn];\n      }\n      line.push(seg);\n      reader.pos++;\n    }\n    if (!sorted) sort(line);\n    decoded.push(line);\n    reader.pos = semi + 1;\n  } while (reader.pos <= length);\n  return decoded;\n}\nfunction sort(line) {\n  line.sort(sortComparator);\n}\nfunction sortComparator(a, b) {\n  return a[0] - b[0];\n}\nfunction encode(decoded) {\n  const writer = new StringWriter();\n  let sourcesIndex = 0;\n  let sourceLine = 0;\n  let sourceColumn = 0;\n  let namesIndex = 0;\n  for (let i = 0; i < decoded.length; i++) {\n    const line = decoded[i];\n    if (i > 0) writer.write(semicolon);\n    if (line.length === 0) continue;\n    let genColumn = 0;\n    for (let j = 0; j < line.length; j++) {\n      const segment = line[j];\n      if (j > 0) writer.write(comma);\n      genColumn = encodeInteger(writer, segment[0], genColumn);\n      if (segment.length === 1) continue;\n      sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);\n      sourceLine = encodeInteger(writer, segment[2], sourceLine);\n      sourceColumn = encodeInteger(writer, segment[3], sourceColumn);\n      if (segment.length === 4) continue;\n      namesIndex = encodeInteger(writer, segment[4], namesIndex);\n    }\n  }\n  return writer.flush();\n}\nexport {\n  decode,\n  decodeGeneratedRanges,\n  decodeOriginalScopes,\n  encode,\n  encodeGeneratedRanges,\n  encodeOriginalScopes\n};\n//# sourceMappingURL=sourcemap-codec.mjs.map\n"],"names":["comma","charCodeAt","semicolon","chars","intToChar","Uint8Array","charToInt","i","c","encodeInteger","builder","num","relative","delta","clamped","write","td","TextDecoder","Buffer","decode","buf","from","buffer","byteOffset","byteLength","toString","out","length","String","fromCharCode","StringWriter","constructor","this","pos","v","flush","subarray","encode","decoded","writer","sourcesIndex","sourceLine","sourceColumn","namesIndex","line","genColumn","j","segment"],"mappings":"AACA,IAAIA,EAAQ,IAAIC,WAAW,GACvBC,EAAY,IAAID,WAAW,GAC3BE,EAAQ,mEACRC,EAAY,IAAIC,WAAW,IAC3BC,EAAY,IAAID,WAAW,KAC/B,IAAK,IAAIE,EAAI,EAAGA,EAAIJ,GAAcI,IAAK,CACrC,MAAMC,EAAIL,EAAMF,WAAWM,GAC3BH,EAAUG,GAAKC,EACfF,EAAUE,GAAKD,CACjB,CAkBA,SAASE,cAAcC,EAASC,EAAKC,GACnC,IAAIC,EAAQF,EAAMC,EAClBC,EAAQA,EAAQ,GAAKA,GAAS,EAAI,EAAIA,GAAS,EAC/C,EAAG,CACD,IAAIC,EAAkB,GAARD,EACdA,KAAW,EACPA,EAAQ,IAAGC,GAAW,IAC1BJ,EAAQK,MAAMX,EAAUU,GACzB,OAAQD,EAAQ,GACjB,OAAOF,CACT,CAOA,IACIK,EAA4B,oBAAhBC,YAA8C,IAAIA,YAAkC,oBAAXC,OAAyB,CAChHC,OAAOC,GACOF,OAAOG,KAAKD,EAAIE,OAAQF,EAAIG,WAAYH,EAAII,YAC7CC,YAEX,CACF,MAAAN,CAAOC,GACL,IAAIM,EAAM,GACV,IAAK,IAAInB,EAAI,EAAGA,EAAIa,EAAIO,OAAQpB,IAC9BmB,GAAOE,OAAOC,aAAaT,EAAIb,IAEjC,OAAOmB,CACX,GAEII,EAAe,MACjB,WAAAC,GACEC,KAAKC,IAAM,EACXD,KAAKN,IAAM,GACXM,KAAKV,OAAS,IAAIjB,WAnBN,MAoBhB,CACE,KAAAU,CAAMmB,GACJ,MAAMZ,OAAEA,GAAWU,KACnBV,EAAOU,KAAKC,OAASC,EAvBT,QAwBRF,KAAKC,MACPD,KAAKN,KAAOV,EAAGG,OAAOG,GACtBU,KAAKC,IAAM,EAEjB,CACE,KAAAE,GACE,MAAMb,OAAEA,EAAMI,IAAEA,EAAGO,IAAEA,GAAQD,KAC7B,OAAOC,EAAM,EAAIP,EAAMV,EAAGG,OAAOG,EAAOc,SAAS,EAAGH,IAAQP,CAChE,GAwTA,SAASW,OAAOC,GACd,MAAMC,EAAS,IAAIT,EACnB,IAAIU,EAAe,EACfC,EAAa,EACbC,EAAe,EACfC,EAAa,EACjB,IAAK,IAAIpC,EAAI,EAAGA,EAAI+B,EAAQX,OAAQpB,IAAK,CACvC,MAAMqC,EAAON,EAAQ/B,GAErB,GADIA,EAAI,GAAGgC,EAAOxB,MAAMb,GACJ,IAAhB0C,EAAKjB,OAAc,SACvB,IAAIkB,EAAY,EAChB,IAAK,IAAIC,EAAI,EAAGA,EAAIF,EAAKjB,OAAQmB,IAAK,CACpC,MAAMC,EAAUH,EAAKE,GACjBA,EAAI,GAAGP,EAAOxB,MAAMf,GACxB6C,EAAYpC,cAAc8B,EAAQQ,EAAQ,GAAIF,GACvB,IAAnBE,EAAQpB,SACZa,EAAe/B,cAAc8B,EAAQQ,EAAQ,GAAIP,GACjDC,EAAahC,cAAc8B,EAAQQ,EAAQ,GAAIN,GAC/CC,EAAejC,cAAc8B,EAAQQ,EAAQ,GAAIL,GAC1B,IAAnBK,EAAQpB,SACZgB,EAAalC,cAAc8B,EAAQQ,EAAQ,GAAIJ,IACrD,CACA,CACE,OAAOJ,EAAOJ,OAChB","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/_shortw_utils.amd.js

@@ -0,0 +1,3 @@
+define(["exports","../../../../../@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/hmac.amd","../../../../../@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/utils.amd","./abstract/weierstrass.amd"],(function(e,s,t,a){"use strict";
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */function getHash(e){return{hash:e,hmac:(a,...n)=>s.hmac(e,a,t.concatBytes(...n)),randomBytes:t.randomBytes}}e.createCurve=function createCurve(e,s){const create=s=>a.weierstrass({...e,...getHash(s)});return Object.freeze({...create(s),create:create})},e.getHash=getHash}));
+//# sourceMappingURL=_shortw_utils.amd.js.map

package/dist/browser/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/_shortw_utils.amd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_shortw_utils.amd.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+curves@1.2.0/node_modules/@noble/curves/esm/_shortw_utils.js"],"sourcesContent":["/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { hmac } from '@noble/hashes/hmac';\nimport { concatBytes, randomBytes } from '@noble/hashes/utils';\nimport { weierstrass } from './abstract/weierstrass.js';\n// connects noble-curves to noble-hashes\nexport function getHash(hash) {\n    return {\n        hash,\n        hmac: (key, ...msgs) => hmac(hash, key, concatBytes(...msgs)),\n        randomBytes,\n    };\n}\nexport function createCurve(curveDef, defHash) {\n    const create = (hash) => weierstrass({ ...curveDef, ...getHash(hash) });\n    return Object.freeze({ ...create(defHash), create });\n}\n//# sourceMappingURL=_shortw_utils.js.map"],"names":["getHash","hash","hmac","key","msgs","concatBytes","randomBytes","createCurve","curveDef","defHash","create","weierstrass","Object","freeze"],"mappings":";sEAKO,SAASA,QAAQC,GACpB,MAAO,CACHA,OACAC,KAAM,CAACC,KAAQC,IAASF,EAAAA,KAAKD,EAAME,EAAKE,EAAAA,eAAeD,IAC/DE,YAAQA,EAAWA,YAEnB,eACO,SAASC,YAAYC,EAAUC,GAClC,MAAMC,OAAUT,GAASU,cAAY,IAAKH,KAAaR,QAAQC,KAC/D,OAAOW,OAAOC,OAAO,IAAKH,OAAOD,GAAUC,eAC/C","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/_shortw_utils.esm.js

@@ -0,0 +1,4 @@
+import{hmac as e}from"../../../../../@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/hmac.esm.js";import{randomBytes as s,concatBytes as r}from"../../../../../@noble_hashes@1.3.2/node_modules/@noble/hashes/esm/utils.esm.js";import{weierstrass as t}from"./abstract/weierstrass.esm.js";
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function getHash(t){return{hash:t,hmac:(s,...o)=>e(t,s,r(...o)),randomBytes:s}}function createCurve(e,s){const create=s=>t({...e,...getHash(s)});return Object.freeze({...create(s),create:create})}export{createCurve,getHash};
+//# sourceMappingURL=_shortw_utils.esm.js.map

package/dist/browser/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/_shortw_utils.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_shortw_utils.esm.js","sources":["../../../../../../../../../../../node_modules/.pnpm/@noble+curves@1.2.0/node_modules/@noble/curves/esm/_shortw_utils.js"],"sourcesContent":["/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { hmac } from '@noble/hashes/hmac';\nimport { concatBytes, randomBytes } from '@noble/hashes/utils';\nimport { weierstrass } from './abstract/weierstrass.js';\n// connects noble-curves to noble-hashes\nexport function getHash(hash) {\n    return {\n        hash,\n        hmac: (key, ...msgs) => hmac(hash, key, concatBytes(...msgs)),\n        randomBytes,\n    };\n}\nexport function createCurve(curveDef, defHash) {\n    const create = (hash) => weierstrass({ ...curveDef, ...getHash(hash) });\n    return Object.freeze({ ...create(defHash), create });\n}\n//# sourceMappingURL=_shortw_utils.js.map"],"names":["getHash","hash","hmac","key","msgs","concatBytes","randomBytes","createCurve","curveDef","defHash","create","weierstrass","Object","freeze"],"mappings":";;AAKO,SAASA,QAAQC,GACpB,MAAO,CACHA,OACAC,KAAM,CAACC,KAAQC,IAASF,EAAKD,EAAME,EAAKE,KAAeD,IACvDE,cAER,CACO,SAASC,YAAYC,EAAUC,GAClC,MAAMC,OAAUT,GAASU,EAAY,IAAKH,KAAaR,QAAQC,KAC/D,OAAOW,OAAOC,OAAO,IAAKH,OAAOD,GAAUC,eAC/C","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/abstract/curve.amd.js

@@ -0,0 +1,3 @@
+define(["exports","./modular.amd","./utils.amd"],(function(e,t,n){"use strict";
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */const i=BigInt(0),d=BigInt(1);e.validateBasic=function validateBasic(e){return t.validateField(e.Fp),n.validateObject(e,{n:"bigint",h:"bigint",Gx:"field",Gy:"field"},{nBitLength:"isSafeInteger",nByteLength:"isSafeInteger"}),Object.freeze({...t.nLength(e.n,e.nBitLength),...e,p:e.Fp.ORDER})},e.wNAF=function wNAF(e,t){const constTimeNegate=(e,t)=>{const n=t.negate();return e?n:t},opts=e=>({windows:Math.ceil(t/e)+1,windowSize:2**(e-1)});return{constTimeNegate:constTimeNegate,unsafeLadder(t,n){let o=e.ZERO,r=t;for(;n>i;)n&d&&(o=o.add(r)),r=r.double(),n>>=d;return o},precomputeWindow(e,t){const{windows:n,windowSize:i}=opts(t),d=[];let o=e,r=o;for(let e=0;e<n;e++){r=o,d.push(r);for(let e=1;e<i;e++)r=r.add(o),d.push(r);o=r.double()}return d},wNAF(t,n,i){const{windows:o,windowSize:r}=opts(t);let s=e.ZERO,a=e.BASE;const c=BigInt(2**t-1),u=2**t,l=BigInt(t);for(let e=0;e<o;e++){const t=e*r;let o=Number(i&c);i>>=l,o>r&&(o-=u,i+=d);const w=t,f=t+Math.abs(o)-1,g=e%2!=0,h=o<0;0===o?a=a.add(constTimeNegate(g,n[w])):s=s.add(constTimeNegate(h,n[f]))}return{p:s,f:a}},wNAFCached(e,t,n,i){const d=e._WINDOW_SIZE||1;let o=t.get(e);return o||(o=this.precomputeWindow(e,d),1!==d&&t.set(e,i(o))),this.wNAF(d,o,n)}}}}));
+//# sourceMappingURL=curve.amd.js.map

package/dist/browser/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/abstract/curve.amd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"curve.amd.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/@noble+curves@1.2.0/node_modules/@noble/curves/esm/abstract/curve.js"],"sourcesContent":["/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// Abelian group utilities\nimport { validateField, nLength } from './modular.js';\nimport { validateObject } from './utils.js';\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\n// Elliptic curve multiplication of Point by scalar. Fragile.\n// Scalars should always be less than curve order: this should be checked inside of a curve itself.\n// Creates precomputation tables for fast multiplication:\n// - private scalar is split by fixed size windows of W bits\n// - every window point is collected from window's table & added to accumulator\n// - since windows are different, same point inside tables won't be accessed more than once per calc\n// - each multiplication is 'Math.ceil(CURVE_ORDER / 𝑊) + 1' point additions (fixed for any scalar)\n// - +1 window is neccessary for wNAF\n// - wNAF reduces table size: 2x less memory + 2x faster generation, but 10% slower multiplication\n// TODO: Research returning 2d JS array of windows, instead of a single window. This would allow\n// windows to be in different memory locations\nexport function wNAF(c, bits) {\n    const constTimeNegate = (condition, item) => {\n        const neg = item.negate();\n        return condition ? neg : item;\n    };\n    const opts = (W) => {\n        const windows = Math.ceil(bits / W) + 1; // +1, because\n        const windowSize = 2 ** (W - 1); // -1 because we skip zero\n        return { windows, windowSize };\n    };\n    return {\n        constTimeNegate,\n        // non-const time multiplication ladder\n        unsafeLadder(elm, n) {\n            let p = c.ZERO;\n            let d = elm;\n            while (n > _0n) {\n                if (n & _1n)\n                    p = p.add(d);\n                d = d.double();\n                n >>= _1n;\n            }\n            return p;\n        },\n        /**\n         * Creates a wNAF precomputation window. Used for caching.\n         * Default window size is set by `utils.precompute()` and is equal to 8.\n         * Number of precomputed points depends on the curve size:\n         * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:\n         * - 𝑊 is the window size\n         * - 𝑛 is the bitlength of the curve order.\n         * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.\n         * @returns precomputed point tables flattened to a single array\n         */\n        precomputeWindow(elm, W) {\n            const { windows, windowSize } = opts(W);\n            const points = [];\n            let p = elm;\n            let base = p;\n            for (let window = 0; window < windows; window++) {\n                base = p;\n                points.push(base);\n                // =1, because we skip zero\n                for (let i = 1; i < windowSize; i++) {\n                    base = base.add(p);\n                    points.push(base);\n                }\n                p = base.double();\n            }\n            return points;\n        },\n        /**\n         * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.\n         * @param W window size\n         * @param precomputes precomputed tables\n         * @param n scalar (we don't check here, but should be less than curve order)\n         * @returns real and fake (for const-time) points\n         */\n        wNAF(W, precomputes, n) {\n            // TODO: maybe check that scalar is less than group order? wNAF behavious is undefined otherwise\n            // But need to carefully remove other checks before wNAF. ORDER == bits here\n            const { windows, windowSize } = opts(W);\n            let p = c.ZERO;\n            let f = c.BASE;\n            const mask = BigInt(2 ** W - 1); // Create mask with W ones: 0b1111 for W=4 etc.\n            const maxNumber = 2 ** W;\n            const shiftBy = BigInt(W);\n            for (let window = 0; window < windows; window++) {\n                const offset = window * windowSize;\n                // Extract W bits.\n                let wbits = Number(n & mask);\n                // Shift number by W bits.\n                n >>= shiftBy;\n                // If the bits are bigger than max size, we'll split those.\n                // +224 => 256 - 32\n                if (wbits > windowSize) {\n                    wbits -= maxNumber;\n                    n += _1n;\n                }\n                // This code was first written with assumption that 'f' and 'p' will never be infinity point:\n                // since each addition is multiplied by 2 ** W, it cannot cancel each other. However,\n                // there is negate now: it is possible that negated element from low value\n                // would be the same as high element, which will create carry into next window.\n                // It's not obvious how this can fail, but still worth investigating later.\n                // Check if we're onto Zero point.\n                // Add random point inside current window to f.\n                const offset1 = offset;\n                const offset2 = offset + Math.abs(wbits) - 1; // -1 because we skip zero\n                const cond1 = window % 2 !== 0;\n                const cond2 = wbits < 0;\n                if (wbits === 0) {\n                    // The most important part for const-time getPublicKey\n                    f = f.add(constTimeNegate(cond1, precomputes[offset1]));\n                }\n                else {\n                    p = p.add(constTimeNegate(cond2, precomputes[offset2]));\n                }\n            }\n            // JIT-compiler should not eliminate f here, since it will later be used in normalizeZ()\n            // Even if the variable is still unused, there are some checks which will\n            // throw an exception, so compiler needs to prove they won't happen, which is hard.\n            // At this point there is a way to F be infinity-point even if p is not,\n            // which makes it less const-time: around 1 bigint multiply.\n            return { p, f };\n        },\n        wNAFCached(P, precomputesMap, n, transform) {\n            // @ts-ignore\n            const W = P._WINDOW_SIZE || 1;\n            // Calculate precomputes on a first run, reuse them after\n            let comp = precomputesMap.get(P);\n            if (!comp) {\n                comp = this.precomputeWindow(P, W);\n                if (W !== 1) {\n                    precomputesMap.set(P, transform(comp));\n                }\n            }\n            return this.wNAF(W, comp, n);\n        },\n    };\n}\nexport function validateBasic(curve) {\n    validateField(curve.Fp);\n    validateObject(curve, {\n        n: 'bigint',\n        h: 'bigint',\n        Gx: 'field',\n        Gy: 'field',\n    }, {\n        nBitLength: 'isSafeInteger',\n        nByteLength: 'isSafeInteger',\n    });\n    // Set defaults\n    return Object.freeze({\n        ...nLength(curve.n, curve.nBitLength),\n        ...curve,\n        ...{ p: curve.Fp.ORDER },\n    });\n}\n//# sourceMappingURL=curve.js.map"],"names":["_0n","BigInt","_1n","validateBasic","curve","validateField","Fp","validateObject","n","h","Gx","Gy","nBitLength","nByteLength","Object","freeze","nLength","p","ORDER","wNAF","c","bits","constTimeNegate","condition","item","neg","negate","opts","W","windows","Math","ceil","windowSize","unsafeLadder","elm","ZERO","d","add","double","precomputeWindow","points","base","window","push","i","precomputes","f","BASE","mask","maxNumber","shiftBy","offset","wbits","Number","offset1","offset2","abs","cond1","cond2","wNAFCached","P","precomputesMap","transform","_WINDOW_SIZE","comp","get","this","set"],"mappings":";sEAIA,MAAMA,EAAMC,OAAO,GACbC,EAAMD,OAAO,mBAoIZ,SAASE,cAAcC,GAY1B,OAXAC,EAAaA,cAACD,EAAME,IACpBC,EAAAA,eAAeH,EAAO,CAClBI,EAAG,SACHC,EAAG,SACHC,GAAI,QACJC,GAAI,SACL,CACCC,WAAY,gBACZC,YAAa,kBAGVC,OAAOC,OAAO,IACdC,EAAOA,QAACZ,EAAMI,EAAGJ,EAAMQ,eACvBR,EACEa,EAAGb,EAAME,GAAGY,OAEzB,SAzIO,SAASC,KAAKC,EAAGC,GACpB,MAAMC,gBAAkB,CAACC,EAAWC,KAChC,MAAMC,EAAMD,EAAKE,SACjB,OAAOH,EAAYE,EAAMD,CAAI,EAE3BG,KAAQC,IAGH,CAAEC,QAFOC,KAAKC,KAAKV,EAAOO,GAAK,EAEpBI,WADC,IAAMJ,EAAI,KAGjC,MAAO,CACHN,gCAEA,YAAAW,CAAaC,EAAK1B,GACd,IAAIS,EAAIG,EAAEe,KACNC,EAAIF,EACR,KAAO1B,EAAIR,GACHQ,EAAIN,IACJe,EAAIA,EAAEoB,IAAID,IACdA,EAAIA,EAAEE,SACN9B,IAAMN,EAEV,OAAOe,CACV,EAWD,gBAAAsB,CAAiBL,EAAKN,GAClB,MAAMC,QAAEA,EAAOG,WAAEA,GAAeL,KAAKC,GAC/BY,EAAS,GACf,IAAIvB,EAAIiB,EACJO,EAAOxB,EACX,IAAK,IAAIyB,EAAS,EAAGA,EAASb,EAASa,IAAU,CAC7CD,EAAOxB,EACPuB,EAAOG,KAAKF,GAEZ,IAAK,IAAIG,EAAI,EAAGA,EAAIZ,EAAYY,IAC5BH,EAAOA,EAAKJ,IAAIpB,GAChBuB,EAAOG,KAAKF,GAEhBxB,EAAIwB,EAAKH,QACzB,CACY,OAAOE,CACV,EAQD,IAAArB,CAAKS,EAAGiB,EAAarC,GAGjB,MAAMqB,QAAEA,EAAOG,WAAEA,GAAeL,KAAKC,GACrC,IAAIX,EAAIG,EAAEe,KACNW,EAAI1B,EAAE2B,KACV,MAAMC,EAAO/C,OAAO,GAAK2B,EAAI,GACvBqB,EAAY,GAAKrB,EACjBsB,EAAUjD,OAAO2B,GACvB,IAAK,IAAIc,EAAS,EAAGA,EAASb,EAASa,IAAU,CAC7C,MAAMS,EAAST,EAASV,EAExB,IAAIoB,EAAQC,OAAO7C,EAAIwC,GAEvBxC,IAAM0C,EAGFE,EAAQpB,IACRoB,GAASH,EACTzC,GAAKN,GAST,MAAMoD,EAAUH,EACVI,EAAUJ,EAASrB,KAAK0B,IAAIJ,GAAS,EACrCK,EAAQf,EAAS,GAAM,EACvBgB,EAAQN,EAAQ,EACR,IAAVA,EAEAN,EAAIA,EAAET,IAAIf,gBAAgBmC,EAAOZ,EAAYS,KAG7CrC,EAAIA,EAAEoB,IAAIf,gBAAgBoC,EAAOb,EAAYU,IAEjE,CAMY,MAAO,CAAEtC,IAAG6B,IACf,EACD,UAAAa,CAAWC,EAAGC,EAAgBrD,EAAGsD,GAE7B,MAAMlC,EAAIgC,EAAEG,cAAgB,EAE5B,IAAIC,EAAOH,EAAeI,IAAIL,GAO9B,OANKI,IACDA,EAAOE,KAAK3B,iBAAiBqB,EAAGhC,GACtB,IAANA,GACAiC,EAAeM,IAAIP,EAAGE,EAAUE,KAGjCE,KAAK/C,KAAKS,EAAGoC,EAAMxD,EAC7B,EAET","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/abstract/curve.esm.js

@@ -0,0 +1,4 @@
+import{validateField as t,nLength as e}from"./modular.esm.js";import{validateObject as n}from"./utils.esm.js";
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const i=BigInt(0),o=BigInt(1);function wNAF(t,e){const constTimeNegate=(t,e)=>{const n=e.negate();return t?n:e},opts=t=>({windows:Math.ceil(e/t)+1,windowSize:2**(t-1)});return{constTimeNegate:constTimeNegate,unsafeLadder(e,n){let r=t.ZERO,s=e;for(;n>i;)n&o&&(r=r.add(s)),s=s.double(),n>>=o;return r},precomputeWindow(t,e){const{windows:n,windowSize:i}=opts(e),o=[];let r=t,s=r;for(let t=0;t<n;t++){s=r,o.push(s);for(let t=1;t<i;t++)s=s.add(r),o.push(s);r=s.double()}return o},wNAF(e,n,i){const{windows:r,windowSize:s}=opts(e);let d=t.ZERO,a=t.BASE;const c=BigInt(2**e-1),u=2**e,w=BigInt(e);for(let t=0;t<r;t++){const e=t*s;let r=Number(i&c);i>>=w,r>s&&(r-=u,i+=o);const l=e,f=e+Math.abs(r)-1,g=t%2!=0,p=r<0;0===r?a=a.add(constTimeNegate(g,n[l])):d=d.add(constTimeNegate(p,n[f]))}return{p:d,f:a}},wNAFCached(t,e,n,i){const o=t._WINDOW_SIZE||1;let r=e.get(t);return r||(r=this.precomputeWindow(t,o),1!==o&&e.set(t,i(r))),this.wNAF(o,r,n)}}}function validateBasic(i){return t(i.Fp),n(i,{n:"bigint",h:"bigint",Gx:"field",Gy:"field"},{nBitLength:"isSafeInteger",nByteLength:"isSafeInteger"}),Object.freeze({...e(i.n,i.nBitLength),...i,p:i.Fp.ORDER})}export{validateBasic,wNAF};
+//# sourceMappingURL=curve.esm.js.map

package/dist/browser/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/abstract/curve.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"curve.esm.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/@noble+curves@1.2.0/node_modules/@noble/curves/esm/abstract/curve.js"],"sourcesContent":["/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// Abelian group utilities\nimport { validateField, nLength } from './modular.js';\nimport { validateObject } from './utils.js';\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\n// Elliptic curve multiplication of Point by scalar. Fragile.\n// Scalars should always be less than curve order: this should be checked inside of a curve itself.\n// Creates precomputation tables for fast multiplication:\n// - private scalar is split by fixed size windows of W bits\n// - every window point is collected from window's table & added to accumulator\n// - since windows are different, same point inside tables won't be accessed more than once per calc\n// - each multiplication is 'Math.ceil(CURVE_ORDER / 𝑊) + 1' point additions (fixed for any scalar)\n// - +1 window is neccessary for wNAF\n// - wNAF reduces table size: 2x less memory + 2x faster generation, but 10% slower multiplication\n// TODO: Research returning 2d JS array of windows, instead of a single window. This would allow\n// windows to be in different memory locations\nexport function wNAF(c, bits) {\n    const constTimeNegate = (condition, item) => {\n        const neg = item.negate();\n        return condition ? neg : item;\n    };\n    const opts = (W) => {\n        const windows = Math.ceil(bits / W) + 1; // +1, because\n        const windowSize = 2 ** (W - 1); // -1 because we skip zero\n        return { windows, windowSize };\n    };\n    return {\n        constTimeNegate,\n        // non-const time multiplication ladder\n        unsafeLadder(elm, n) {\n            let p = c.ZERO;\n            let d = elm;\n            while (n > _0n) {\n                if (n & _1n)\n                    p = p.add(d);\n                d = d.double();\n                n >>= _1n;\n            }\n            return p;\n        },\n        /**\n         * Creates a wNAF precomputation window. Used for caching.\n         * Default window size is set by `utils.precompute()` and is equal to 8.\n         * Number of precomputed points depends on the curve size:\n         * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:\n         * - 𝑊 is the window size\n         * - 𝑛 is the bitlength of the curve order.\n         * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.\n         * @returns precomputed point tables flattened to a single array\n         */\n        precomputeWindow(elm, W) {\n            const { windows, windowSize } = opts(W);\n            const points = [];\n            let p = elm;\n            let base = p;\n            for (let window = 0; window < windows; window++) {\n                base = p;\n                points.push(base);\n                // =1, because we skip zero\n                for (let i = 1; i < windowSize; i++) {\n                    base = base.add(p);\n                    points.push(base);\n                }\n                p = base.double();\n            }\n            return points;\n        },\n        /**\n         * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.\n         * @param W window size\n         * @param precomputes precomputed tables\n         * @param n scalar (we don't check here, but should be less than curve order)\n         * @returns real and fake (for const-time) points\n         */\n        wNAF(W, precomputes, n) {\n            // TODO: maybe check that scalar is less than group order? wNAF behavious is undefined otherwise\n            // But need to carefully remove other checks before wNAF. ORDER == bits here\n            const { windows, windowSize } = opts(W);\n            let p = c.ZERO;\n            let f = c.BASE;\n            const mask = BigInt(2 ** W - 1); // Create mask with W ones: 0b1111 for W=4 etc.\n            const maxNumber = 2 ** W;\n            const shiftBy = BigInt(W);\n            for (let window = 0; window < windows; window++) {\n                const offset = window * windowSize;\n                // Extract W bits.\n                let wbits = Number(n & mask);\n                // Shift number by W bits.\n                n >>= shiftBy;\n                // If the bits are bigger than max size, we'll split those.\n                // +224 => 256 - 32\n                if (wbits > windowSize) {\n                    wbits -= maxNumber;\n                    n += _1n;\n                }\n                // This code was first written with assumption that 'f' and 'p' will never be infinity point:\n                // since each addition is multiplied by 2 ** W, it cannot cancel each other. However,\n                // there is negate now: it is possible that negated element from low value\n                // would be the same as high element, which will create carry into next window.\n                // It's not obvious how this can fail, but still worth investigating later.\n                // Check if we're onto Zero point.\n                // Add random point inside current window to f.\n                const offset1 = offset;\n                const offset2 = offset + Math.abs(wbits) - 1; // -1 because we skip zero\n                const cond1 = window % 2 !== 0;\n                const cond2 = wbits < 0;\n                if (wbits === 0) {\n                    // The most important part for const-time getPublicKey\n                    f = f.add(constTimeNegate(cond1, precomputes[offset1]));\n                }\n                else {\n                    p = p.add(constTimeNegate(cond2, precomputes[offset2]));\n                }\n            }\n            // JIT-compiler should not eliminate f here, since it will later be used in normalizeZ()\n            // Even if the variable is still unused, there are some checks which will\n            // throw an exception, so compiler needs to prove they won't happen, which is hard.\n            // At this point there is a way to F be infinity-point even if p is not,\n            // which makes it less const-time: around 1 bigint multiply.\n            return { p, f };\n        },\n        wNAFCached(P, precomputesMap, n, transform) {\n            // @ts-ignore\n            const W = P._WINDOW_SIZE || 1;\n            // Calculate precomputes on a first run, reuse them after\n            let comp = precomputesMap.get(P);\n            if (!comp) {\n                comp = this.precomputeWindow(P, W);\n                if (W !== 1) {\n                    precomputesMap.set(P, transform(comp));\n                }\n            }\n            return this.wNAF(W, comp, n);\n        },\n    };\n}\nexport function validateBasic(curve) {\n    validateField(curve.Fp);\n    validateObject(curve, {\n        n: 'bigint',\n        h: 'bigint',\n        Gx: 'field',\n        Gy: 'field',\n    }, {\n        nBitLength: 'isSafeInteger',\n        nByteLength: 'isSafeInteger',\n    });\n    // Set defaults\n    return Object.freeze({\n        ...nLength(curve.n, curve.nBitLength),\n        ...curve,\n        ...{ p: curve.Fp.ORDER },\n    });\n}\n//# sourceMappingURL=curve.js.map"],"names":["_0n","BigInt","_1n","wNAF","c","bits","constTimeNegate","condition","item","neg","negate","opts","W","windows","Math","ceil","windowSize","unsafeLadder","elm","n","p","ZERO","d","add","double","precomputeWindow","points","base","window","push","i","precomputes","f","BASE","mask","maxNumber","shiftBy","offset","wbits","Number","offset1","offset2","abs","cond1","cond2","wNAFCached","P","precomputesMap","transform","_WINDOW_SIZE","comp","get","this","set","validateBasic","curve","validateField","Fp","validateObject","h","Gx","Gy","nBitLength","nByteLength","Object","freeze","nLength","ORDER"],"mappings":";;AAIA,MAAMA,EAAMC,OAAO,GACbC,EAAMD,OAAO,GAYZ,SAASE,KAAKC,EAAGC,GACpB,MAAMC,gBAAkB,CAACC,EAAWC,KAChC,MAAMC,EAAMD,EAAKE,SACjB,OAAOH,EAAYE,EAAMD,CAAI,EAE3BG,KAAQC,IAGH,CAAEC,QAFOC,KAAKC,KAAKV,EAAOO,GAAK,EAEpBI,WADC,IAAMJ,EAAI,KAGjC,MAAO,CACHN,gCAEA,YAAAW,CAAaC,EAAKC,GACd,IAAIC,EAAIhB,EAAEiB,KACNC,EAAIJ,EACR,KAAOC,EAAInB,GACHmB,EAAIjB,IACJkB,EAAIA,EAAEG,IAAID,IACdA,EAAIA,EAAEE,SACNL,IAAMjB,EAEV,OAAOkB,CACV,EAWD,gBAAAK,CAAiBP,EAAKN,GAClB,MAAMC,QAAEA,EAAOG,WAAEA,GAAeL,KAAKC,GAC/Bc,EAAS,GACf,IAAIN,EAAIF,EACJS,EAAOP,EACX,IAAK,IAAIQ,EAAS,EAAGA,EAASf,EAASe,IAAU,CAC7CD,EAAOP,EACPM,EAAOG,KAAKF,GAEZ,IAAK,IAAIG,EAAI,EAAGA,EAAId,EAAYc,IAC5BH,EAAOA,EAAKJ,IAAIH,GAChBM,EAAOG,KAAKF,GAEhBP,EAAIO,EAAKH,QACzB,CACY,OAAOE,CACV,EAQD,IAAAvB,CAAKS,EAAGmB,EAAaZ,GAGjB,MAAMN,QAAEA,EAAOG,WAAEA,GAAeL,KAAKC,GACrC,IAAIQ,EAAIhB,EAAEiB,KACNW,EAAI5B,EAAE6B,KACV,MAAMC,EAAOjC,OAAO,GAAKW,EAAI,GACvBuB,EAAY,GAAKvB,EACjBwB,EAAUnC,OAAOW,GACvB,IAAK,IAAIgB,EAAS,EAAGA,EAASf,EAASe,IAAU,CAC7C,MAAMS,EAAST,EAASZ,EAExB,IAAIsB,EAAQC,OAAOpB,EAAIe,GAEvBf,IAAMiB,EAGFE,EAAQtB,IACRsB,GAASH,EACThB,GAAKjB,GAST,MAAMsC,EAAUH,EACVI,EAAUJ,EAASvB,KAAK4B,IAAIJ,GAAS,EACrCK,EAAQf,EAAS,GAAM,EACvBgB,EAAQN,EAAQ,EACR,IAAVA,EAEAN,EAAIA,EAAET,IAAIjB,gBAAgBqC,EAAOZ,EAAYS,KAG7CpB,EAAIA,EAAEG,IAAIjB,gBAAgBsC,EAAOb,EAAYU,IAEjE,CAMY,MAAO,CAAErB,IAAGY,IACf,EACD,UAAAa,CAAWC,EAAGC,EAAgB5B,EAAG6B,GAE7B,MAAMpC,EAAIkC,EAAEG,cAAgB,EAE5B,IAAIC,EAAOH,EAAeI,IAAIL,GAO9B,OANKI,IACDA,EAAOE,KAAK3B,iBAAiBqB,EAAGlC,GACtB,IAANA,GACAmC,EAAeM,IAAIP,EAAGE,EAAUE,KAGjCE,KAAKjD,KAAKS,EAAGsC,EAAM/B,EAC7B,EAET,CACO,SAASmC,cAAcC,GAY1B,OAXAC,EAAcD,EAAME,IACpBC,EAAeH,EAAO,CAClBpC,EAAG,SACHwC,EAAG,SACHC,GAAI,QACJC,GAAI,SACL,CACCC,WAAY,gBACZC,YAAa,kBAGVC,OAAOC,OAAO,IACdC,EAAQX,EAAMpC,EAAGoC,EAAMO,eACvBP,EACEnC,EAAGmC,EAAME,GAAGU,OAEzB","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/abstract/modular.amd.js

@@ -0,0 +1,3 @@
+define(["exports","./utils.amd"],(function(t,e){"use strict";
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */const n=BigInt(0),r=BigInt(1),o=BigInt(2),i=BigInt(3),s=BigInt(4),u=BigInt(5),l=BigInt(8);function mod(t,e){const r=t%e;return r>=n?r:e+r}function pow(t,e,o){if(o<=n||e<n)throw new Error("Expected power/modulo > 0");if(o===r)return n;let i=r;for(;e>n;)e&r&&(i=i*t%o),t=t*t%o,e>>=r;return i}function invert(t,e){if(t===n||e<=n)throw new Error(`invert: expected positive integers, got n=${t} mod=${e}`);let o=mod(t,e),i=e,s=n,u=r;for(;o!==n;){const t=i%o,e=s-u*(i/o);i=o,o=t,s=u,u=e}if(i!==r)throw new Error("invert: does not exist");return mod(s,e)}function tonelliShanks(t){const e=(t-r)/o;let i,u,l;for(i=t-r,u=0;i%o===n;i/=o,u++);for(l=o;l<t&&pow(l,e,t)!==t-r;l++);if(1===u){const e=(t+r)/s;return function tonelliFast(t,n){const r=t.pow(n,e);if(!t.eql(t.sqr(r),n))throw new Error("Cannot find square root");return r}}const d=(i+r)/o;return function tonelliSlow(t,n){if(t.pow(n,e)===t.neg(t.ONE))throw new Error("Cannot find square root");let o=u,s=t.pow(t.mul(t.ONE,l),i),c=t.pow(n,d),f=t.pow(n,i);for(;!t.eql(f,t.ONE);){if(t.eql(f,t.ZERO))return t.ZERO;let e=1;for(let n=t.sqr(f);e<o&&!t.eql(n,t.ONE);e++)n=t.sqr(n);const n=t.pow(s,r<<BigInt(o-e-1));s=t.sqr(n),c=t.mul(c,n),f=t.mul(f,s),o=e}return c}}function FpSqrt(t){if(t%s===i){const e=(t+r)/s;return function sqrt3mod4(t,n){const r=t.pow(n,e);if(!t.eql(t.sqr(r),n))throw new Error("Cannot find square root");return r}}if(t%l===u){const e=(t-u)/l;return function sqrt5mod8(t,n){const r=t.mul(n,o),i=t.pow(r,e),s=t.mul(n,i),u=t.mul(t.mul(s,o),i),l=t.mul(s,t.sub(u,t.ONE));if(!t.eql(t.sqr(l),n))throw new Error("Cannot find square root");return l}}return tonelliShanks(t)}BigInt(9),BigInt(16);const d=["create","isValid","is0","neg","inv","sqrt","sqr","eql","add","sub","mul","pow","div","addN","subN","mulN","sqrN"];function FpPow(t,e,o){if(o<n)throw new Error("Expected power > 0");if(o===n)return t.ONE;if(o===r)return e;let i=t.ONE,s=e;for(;o>n;)o&r&&(i=t.mul(i,s)),s=t.sqr(s),o>>=r;return i}function FpInvertBatch(t,e){const n=new Array(e.length),r=e.reduce(((e,r,o)=>t.is0(r)?e:(n[o]=e,t.mul(e,r))),t.ONE),o=t.inv(r);return e.reduceRight(((e,r,o)=>t.is0(r)?e:(n[o]=t.mul(e,n[o]),t.mul(e,r))),o),n}function nLength(t,e){const n=void 0!==e?e:t.toString(2).length;return{nBitLength:n,nByteLength:Math.ceil(n/8)}}function getFieldBytesLength(t){if("bigint"!=typeof t)throw new Error("field order must be bigint");const e=t.toString(2).length;return Math.ceil(e/8)}function getMinHashLength(t){const e=getFieldBytesLength(t);return e+Math.ceil(e/2)}t.Field=function Field(t,o,i=!1,s={}){if(t<=n)throw new Error(`Expected Field ORDER > 0, got ${t}`);const{nBitLength:u,nByteLength:l}=nLength(t,o);if(l>2048)throw new Error("Field lengths over 2048 bytes are not supported");const d=FpSqrt(t),c=Object.freeze({ORDER:t,BITS:u,BYTES:l,MASK:e.bitMask(u),ZERO:n,ONE:r,create:e=>mod(e,t),isValid:e=>{if("bigint"!=typeof e)throw new Error("Invalid field element: expected bigint, got "+typeof e);return n<=e&&e<t},is0:t=>t===n,isOdd:t=>(t&r)===r,neg:e=>mod(-e,t),eql:(t,e)=>t===e,sqr:e=>mod(e*e,t),add:(e,n)=>mod(e+n,t),sub:(e,n)=>mod(e-n,t),mul:(e,n)=>mod(e*n,t),pow:(t,e)=>FpPow(c,t,e),div:(e,n)=>mod(e*invert(n,t),t),sqrN:t=>t*t,addN:(t,e)=>t+e,subN:(t,e)=>t-e,mulN:(t,e)=>t*e,inv:e=>invert(e,t),sqrt:s.sqrt||(t=>d(c,t)),invertBatch:t=>FpInvertBatch(c,t),cmov:(t,e,n)=>n?e:t,toBytes:t=>i?e.numberToBytesLE(t,l):e.numberToBytesBE(t,l),fromBytes:t=>{if(t.length!==l)throw new Error(`Fp.fromBytes: expected ${l}, got ${t.length}`);return i?e.bytesToNumberLE(t):e.bytesToNumberBE(t)}});return Object.freeze(c)},t.FpInvertBatch=FpInvertBatch,t.FpPow=FpPow,t.FpSqrt=FpSqrt,t.getFieldBytesLength=getFieldBytesLength,t.getMinHashLength=getMinHashLength,t.invert=invert,t.mapHashToField=function mapHashToField(t,n,o=!1){const i=t.length,s=getFieldBytesLength(n),u=getMinHashLength(n);if(i<16||i<u||i>1024)throw new Error(`expected ${u}-1024 bytes of input, got ${i}`);const l=mod(o?e.bytesToNumberBE(t):e.bytesToNumberLE(t),n-r)+r;return o?e.numberToBytesLE(l,s):e.numberToBytesBE(l,s)},t.mod=mod,t.nLength=nLength,t.pow=pow,t.pow2=function pow2(t,e,r){let o=t;for(;e-- >n;)o*=o,o%=r;return o},t.tonelliShanks=tonelliShanks,t.validateField=function validateField(t){const n=d.reduce(((t,e)=>(t[e]="function",t)),{ORDER:"bigint",MASK:"bigint",BYTES:"isSafeInteger",BITS:"isSafeInteger"});return e.validateObject(t,n)}}));
+//# sourceMappingURL=modular.amd.js.map

package/dist/browser/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/abstract/modular.amd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modular.amd.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/@noble+curves@1.2.0/node_modules/@noble/curves/esm/abstract/modular.js"],"sourcesContent":["/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// Utilities for modular arithmetics and finite fields\nimport { bitMask, numberToBytesBE, numberToBytesLE, bytesToNumberBE, bytesToNumberLE, ensureBytes, validateObject, } from './utils.js';\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3);\n// prettier-ignore\nconst _4n = BigInt(4), _5n = BigInt(5), _8n = BigInt(8);\n// prettier-ignore\nconst _9n = BigInt(9), _16n = BigInt(16);\n// Calculates a modulo b\nexport function mod(a, b) {\n    const result = a % b;\n    return result >= _0n ? result : b + result;\n}\n/**\n * Efficiently raise num to power and do modular division.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n * @example\n * pow(2n, 6n, 11n) // 64n % 11n == 9n\n */\n// TODO: use field version && remove\nexport function pow(num, power, modulo) {\n    if (modulo <= _0n || power < _0n)\n        throw new Error('Expected power/modulo > 0');\n    if (modulo === _1n)\n        return _0n;\n    let res = _1n;\n    while (power > _0n) {\n        if (power & _1n)\n            res = (res * num) % modulo;\n        num = (num * num) % modulo;\n        power >>= _1n;\n    }\n    return res;\n}\n// Does x ^ (2 ^ power) mod p. pow2(30, 4) == 30 ^ (2 ^ 4)\nexport function pow2(x, power, modulo) {\n    let res = x;\n    while (power-- > _0n) {\n        res *= res;\n        res %= modulo;\n    }\n    return res;\n}\n// Inverses number over modulo\nexport function invert(number, modulo) {\n    if (number === _0n || modulo <= _0n) {\n        throw new Error(`invert: expected positive integers, got n=${number} mod=${modulo}`);\n    }\n    // Euclidean GCD https://brilliant.org/wiki/extended-euclidean-algorithm/\n    // Fermat's little theorem \"CT-like\" version inv(n) = n^(m-2) mod m is 30x slower.\n    let a = mod(number, modulo);\n    let b = modulo;\n    // prettier-ignore\n    let x = _0n, y = _1n, u = _1n, v = _0n;\n    while (a !== _0n) {\n        // JIT applies optimization if those two lines follow each other\n        const q = b / a;\n        const r = b % a;\n        const m = x - u * q;\n        const n = y - v * q;\n        // prettier-ignore\n        b = a, a = r, x = u, y = v, u = m, v = n;\n    }\n    const gcd = b;\n    if (gcd !== _1n)\n        throw new Error('invert: does not exist');\n    return mod(x, modulo);\n}\n/**\n * Tonelli-Shanks square root search algorithm.\n * 1. https://eprint.iacr.org/2012/685.pdf (page 12)\n * 2. Square Roots from 1; 24, 51, 10 to Dan Shanks\n * Will start an infinite loop if field order P is not prime.\n * @param P field order\n * @returns function that takes field Fp (created from P) and number n\n */\nexport function tonelliShanks(P) {\n    // Legendre constant: used to calculate Legendre symbol (a | p),\n    // which denotes the value of a^((p-1)/2) (mod p).\n    // (a | p) ≡ 1    if a is a square (mod p)\n    // (a | p) ≡ -1   if a is not a square (mod p)\n    // (a | p) ≡ 0    if a ≡ 0 (mod p)\n    const legendreC = (P - _1n) / _2n;\n    let Q, S, Z;\n    // Step 1: By factoring out powers of 2 from p - 1,\n    // find q and s such that p - 1 = q*(2^s) with q odd\n    for (Q = P - _1n, S = 0; Q % _2n === _0n; Q /= _2n, S++)\n        ;\n    // Step 2: Select a non-square z such that (z | p) ≡ -1 and set c ≡ zq\n    for (Z = _2n; Z < P && pow(Z, legendreC, P) !== P - _1n; Z++)\n        ;\n    // Fast-path\n    if (S === 1) {\n        const p1div4 = (P + _1n) / _4n;\n        return function tonelliFast(Fp, n) {\n            const root = Fp.pow(n, p1div4);\n            if (!Fp.eql(Fp.sqr(root), n))\n                throw new Error('Cannot find square root');\n            return root;\n        };\n    }\n    // Slow-path\n    const Q1div2 = (Q + _1n) / _2n;\n    return function tonelliSlow(Fp, n) {\n        // Step 0: Check that n is indeed a square: (n | p) should not be ≡ -1\n        if (Fp.pow(n, legendreC) === Fp.neg(Fp.ONE))\n            throw new Error('Cannot find square root');\n        let r = S;\n        // TODO: will fail at Fp2/etc\n        let g = Fp.pow(Fp.mul(Fp.ONE, Z), Q); // will update both x and b\n        let x = Fp.pow(n, Q1div2); // first guess at the square root\n        let b = Fp.pow(n, Q); // first guess at the fudge factor\n        while (!Fp.eql(b, Fp.ONE)) {\n            if (Fp.eql(b, Fp.ZERO))\n                return Fp.ZERO; // https://en.wikipedia.org/wiki/Tonelli%E2%80%93Shanks_algorithm (4. If t = 0, return r = 0)\n            // Find m such b^(2^m)==1\n            let m = 1;\n            for (let t2 = Fp.sqr(b); m < r; m++) {\n                if (Fp.eql(t2, Fp.ONE))\n                    break;\n                t2 = Fp.sqr(t2); // t2 *= t2\n            }\n            // NOTE: r-m-1 can be bigger than 32, need to convert to bigint before shift, otherwise there will be overflow\n            const ge = Fp.pow(g, _1n << BigInt(r - m - 1)); // ge = 2^(r-m-1)\n            g = Fp.sqr(ge); // g = ge * ge\n            x = Fp.mul(x, ge); // x *= ge\n            b = Fp.mul(b, g); // b *= g\n            r = m;\n        }\n        return x;\n    };\n}\nexport function FpSqrt(P) {\n    // NOTE: different algorithms can give different roots, it is up to user to decide which one they want.\n    // For example there is FpSqrtOdd/FpSqrtEven to choice root based on oddness (used for hash-to-curve).\n    // P ≡ 3 (mod 4)\n    // √n = n^((P+1)/4)\n    if (P % _4n === _3n) {\n        // Not all roots possible!\n        // const ORDER =\n        //   0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaabn;\n        // const NUM = 72057594037927816n;\n        const p1div4 = (P + _1n) / _4n;\n        return function sqrt3mod4(Fp, n) {\n            const root = Fp.pow(n, p1div4);\n            // Throw if root**2 != n\n            if (!Fp.eql(Fp.sqr(root), n))\n                throw new Error('Cannot find square root');\n            return root;\n        };\n    }\n    // Atkin algorithm for q ≡ 5 (mod 8), https://eprint.iacr.org/2012/685.pdf (page 10)\n    if (P % _8n === _5n) {\n        const c1 = (P - _5n) / _8n;\n        return function sqrt5mod8(Fp, n) {\n            const n2 = Fp.mul(n, _2n);\n            const v = Fp.pow(n2, c1);\n            const nv = Fp.mul(n, v);\n            const i = Fp.mul(Fp.mul(nv, _2n), v);\n            const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));\n            if (!Fp.eql(Fp.sqr(root), n))\n                throw new Error('Cannot find square root');\n            return root;\n        };\n    }\n    // P ≡ 9 (mod 16)\n    if (P % _16n === _9n) {\n        // NOTE: tonelli is too slow for bls-Fp2 calculations even on start\n        // Means we cannot use sqrt for constants at all!\n        //\n        // const c1 = Fp.sqrt(Fp.negate(Fp.ONE)); //  1. c1 = sqrt(-1) in F, i.e., (c1^2) == -1 in F\n        // const c2 = Fp.sqrt(c1);                //  2. c2 = sqrt(c1) in F, i.e., (c2^2) == c1 in F\n        // const c3 = Fp.sqrt(Fp.negate(c1));     //  3. c3 = sqrt(-c1) in F, i.e., (c3^2) == -c1 in F\n        // const c4 = (P + _7n) / _16n;           //  4. c4 = (q + 7) / 16        # Integer arithmetic\n        // sqrt = (x) => {\n        //   let tv1 = Fp.pow(x, c4);             //  1. tv1 = x^c4\n        //   let tv2 = Fp.mul(c1, tv1);           //  2. tv2 = c1 * tv1\n        //   const tv3 = Fp.mul(c2, tv1);         //  3. tv3 = c2 * tv1\n        //   let tv4 = Fp.mul(c3, tv1);           //  4. tv4 = c3 * tv1\n        //   const e1 = Fp.equals(Fp.square(tv2), x); //  5.  e1 = (tv2^2) == x\n        //   const e2 = Fp.equals(Fp.square(tv3), x); //  6.  e2 = (tv3^2) == x\n        //   tv1 = Fp.cmov(tv1, tv2, e1); //  7. tv1 = CMOV(tv1, tv2, e1)  # Select tv2 if (tv2^2) == x\n        //   tv2 = Fp.cmov(tv4, tv3, e2); //  8. tv2 = CMOV(tv4, tv3, e2)  # Select tv3 if (tv3^2) == x\n        //   const e3 = Fp.equals(Fp.square(tv2), x); //  9.  e3 = (tv2^2) == x\n        //   return Fp.cmov(tv1, tv2, e3); //  10.  z = CMOV(tv1, tv2, e3)  # Select the sqrt from tv1 and tv2\n        // }\n    }\n    // Other cases: Tonelli-Shanks algorithm\n    return tonelliShanks(P);\n}\n// Little-endian check for first LE bit (last BE bit);\nexport const isNegativeLE = (num, modulo) => (mod(num, modulo) & _1n) === _1n;\n// prettier-ignore\nconst FIELD_FIELDS = [\n    'create', 'isValid', 'is0', 'neg', 'inv', 'sqrt', 'sqr',\n    'eql', 'add', 'sub', 'mul', 'pow', 'div',\n    'addN', 'subN', 'mulN', 'sqrN'\n];\nexport function validateField(field) {\n    const initial = {\n        ORDER: 'bigint',\n        MASK: 'bigint',\n        BYTES: 'isSafeInteger',\n        BITS: 'isSafeInteger',\n    };\n    const opts = FIELD_FIELDS.reduce((map, val) => {\n        map[val] = 'function';\n        return map;\n    }, initial);\n    return validateObject(field, opts);\n}\n// Generic field functions\n/**\n * Same as `pow` but for Fp: non-constant-time.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n */\nexport function FpPow(f, num, power) {\n    // Should have same speed as pow for bigints\n    // TODO: benchmark!\n    if (power < _0n)\n        throw new Error('Expected power > 0');\n    if (power === _0n)\n        return f.ONE;\n    if (power === _1n)\n        return num;\n    let p = f.ONE;\n    let d = num;\n    while (power > _0n) {\n        if (power & _1n)\n            p = f.mul(p, d);\n        d = f.sqr(d);\n        power >>= _1n;\n    }\n    return p;\n}\n/**\n * Efficiently invert an array of Field elements.\n * `inv(0)` will return `undefined` here: make sure to throw an error.\n */\nexport function FpInvertBatch(f, nums) {\n    const tmp = new Array(nums.length);\n    // Walk from first to last, multiply them by each other MOD p\n    const lastMultiplied = nums.reduce((acc, num, i) => {\n        if (f.is0(num))\n            return acc;\n        tmp[i] = acc;\n        return f.mul(acc, num);\n    }, f.ONE);\n    // Invert last element\n    const inverted = f.inv(lastMultiplied);\n    // Walk from last to first, multiply them by inverted each other MOD p\n    nums.reduceRight((acc, num, i) => {\n        if (f.is0(num))\n            return acc;\n        tmp[i] = f.mul(acc, tmp[i]);\n        return f.mul(acc, num);\n    }, inverted);\n    return tmp;\n}\nexport function FpDiv(f, lhs, rhs) {\n    return f.mul(lhs, typeof rhs === 'bigint' ? invert(rhs, f.ORDER) : f.inv(rhs));\n}\n// This function returns True whenever the value x is a square in the field F.\nexport function FpIsSquare(f) {\n    const legendreConst = (f.ORDER - _1n) / _2n; // Integer arithmetic\n    return (x) => {\n        const p = f.pow(x, legendreConst);\n        return f.eql(p, f.ZERO) || f.eql(p, f.ONE);\n    };\n}\n// CURVE.n lengths\nexport function nLength(n, nBitLength) {\n    // Bit size, byte size of CURVE.n\n    const _nBitLength = nBitLength !== undefined ? nBitLength : n.toString(2).length;\n    const nByteLength = Math.ceil(_nBitLength / 8);\n    return { nBitLength: _nBitLength, nByteLength };\n}\n/**\n * Initializes a finite field over prime. **Non-primes are not supported.**\n * Do not init in loop: slow. Very fragile: always run a benchmark on a change.\n * Major performance optimizations:\n * * a) denormalized operations like mulN instead of mul\n * * b) same object shape: never add or remove keys\n * * c) Object.freeze\n * @param ORDER prime positive bigint\n * @param bitLen how many bits the field consumes\n * @param isLE (def: false) if encoding / decoding should be in little-endian\n * @param redef optional faster redefinitions of sqrt and other methods\n */\nexport function Field(ORDER, bitLen, isLE = false, redef = {}) {\n    if (ORDER <= _0n)\n        throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);\n    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen);\n    if (BYTES > 2048)\n        throw new Error('Field lengths over 2048 bytes are not supported');\n    const sqrtP = FpSqrt(ORDER);\n    const f = Object.freeze({\n        ORDER,\n        BITS,\n        BYTES,\n        MASK: bitMask(BITS),\n        ZERO: _0n,\n        ONE: _1n,\n        create: (num) => mod(num, ORDER),\n        isValid: (num) => {\n            if (typeof num !== 'bigint')\n                throw new Error(`Invalid field element: expected bigint, got ${typeof num}`);\n            return _0n <= num && num < ORDER; // 0 is valid element, but it's not invertible\n        },\n        is0: (num) => num === _0n,\n        isOdd: (num) => (num & _1n) === _1n,\n        neg: (num) => mod(-num, ORDER),\n        eql: (lhs, rhs) => lhs === rhs,\n        sqr: (num) => mod(num * num, ORDER),\n        add: (lhs, rhs) => mod(lhs + rhs, ORDER),\n        sub: (lhs, rhs) => mod(lhs - rhs, ORDER),\n        mul: (lhs, rhs) => mod(lhs * rhs, ORDER),\n        pow: (num, power) => FpPow(f, num, power),\n        div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),\n        // Same as above, but doesn't normalize\n        sqrN: (num) => num * num,\n        addN: (lhs, rhs) => lhs + rhs,\n        subN: (lhs, rhs) => lhs - rhs,\n        mulN: (lhs, rhs) => lhs * rhs,\n        inv: (num) => invert(num, ORDER),\n        sqrt: redef.sqrt || ((n) => sqrtP(f, n)),\n        invertBatch: (lst) => FpInvertBatch(f, lst),\n        // TODO: do we really need constant cmov?\n        // We don't have const-time bigints anyway, so probably will be not very useful\n        cmov: (a, b, c) => (c ? b : a),\n        toBytes: (num) => (isLE ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES)),\n        fromBytes: (bytes) => {\n            if (bytes.length !== BYTES)\n                throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes.length}`);\n            return isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);\n        },\n    });\n    return Object.freeze(f);\n}\nexport function FpSqrtOdd(Fp, elm) {\n    if (!Fp.isOdd)\n        throw new Error(`Field doesn't have isOdd`);\n    const root = Fp.sqrt(elm);\n    return Fp.isOdd(root) ? root : Fp.neg(root);\n}\nexport function FpSqrtEven(Fp, elm) {\n    if (!Fp.isOdd)\n        throw new Error(`Field doesn't have isOdd`);\n    const root = Fp.sqrt(elm);\n    return Fp.isOdd(root) ? Fp.neg(root) : root;\n}\n/**\n * \"Constant-time\" private key generation utility.\n * Same as mapKeyToField, but accepts less bytes (40 instead of 48 for 32-byte field).\n * Which makes it slightly more biased, less secure.\n * @deprecated use mapKeyToField instead\n */\nexport function hashToPrivateScalar(hash, groupOrder, isLE = false) {\n    hash = ensureBytes('privateHash', hash);\n    const hashLen = hash.length;\n    const minLen = nLength(groupOrder).nByteLength + 8;\n    if (minLen < 24 || hashLen < minLen || hashLen > 1024)\n        throw new Error(`hashToPrivateScalar: expected ${minLen}-1024 bytes of input, got ${hashLen}`);\n    const num = isLE ? bytesToNumberLE(hash) : bytesToNumberBE(hash);\n    return mod(num, groupOrder - _1n) + _1n;\n}\n/**\n * Returns total number of bytes consumed by the field element.\n * For example, 32 bytes for usual 256-bit weierstrass curve.\n * @param fieldOrder number of field elements, usually CURVE.n\n * @returns byte length of field\n */\nexport function getFieldBytesLength(fieldOrder) {\n    if (typeof fieldOrder !== 'bigint')\n        throw new Error('field order must be bigint');\n    const bitLength = fieldOrder.toString(2).length;\n    return Math.ceil(bitLength / 8);\n}\n/**\n * Returns minimal amount of bytes that can be safely reduced\n * by field order.\n * Should be 2^-128 for 128-bit curve such as P256.\n * @param fieldOrder number of field elements, usually CURVE.n\n * @returns byte length of target hash\n */\nexport function getMinHashLength(fieldOrder) {\n    const length = getFieldBytesLength(fieldOrder);\n    return length + Math.ceil(length / 2);\n}\n/**\n * \"Constant-time\" private key generation utility.\n * Can take (n + n/2) or more bytes of uniform input e.g. from CSPRNG or KDF\n * and convert them into private scalar, with the modulo bias being negligible.\n * Needs at least 48 bytes of input for 32-byte private key.\n * https://research.kudelskisecurity.com/2020/07/28/the-definitive-guide-to-modulo-bias-and-how-to-avoid-it/\n * FIPS 186-5, A.2 https://csrc.nist.gov/publications/detail/fips/186/5/final\n * RFC 9380, https://www.rfc-editor.org/rfc/rfc9380#section-5\n * @param hash hash output from SHA3 or a similar function\n * @param groupOrder size of subgroup - (e.g. secp256k1.CURVE.n)\n * @param isLE interpret hash bytes as LE num\n * @returns valid private scalar\n */\nexport function mapHashToField(key, fieldOrder, isLE = false) {\n    const len = key.length;\n    const fieldLen = getFieldBytesLength(fieldOrder);\n    const minLen = getMinHashLength(fieldOrder);\n    // No small numbers: need to understand bias story. No huge numbers: easier to detect JS timings.\n    if (len < 16 || len < minLen || len > 1024)\n        throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);\n    const num = isLE ? bytesToNumberBE(key) : bytesToNumberLE(key);\n    // `mod(x, 11)` can sometimes produce 0. `mod(x, 10) + 1` is the same, but no 0\n    const reduced = mod(num, fieldOrder - _1n) + _1n;\n    return isLE ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);\n}\n//# sourceMappingURL=modular.js.map"],"names":["_0n","BigInt","_1n","_2n","_3n","_4n","_5n","_8n","mod","a","b","result","pow","num","power","modulo","Error","res","invert","number","x","u","r","m","tonelliShanks","P","legendreC","Q","S","Z","p1div4","tonelliFast","Fp","n","root","eql","sqr","Q1div2","tonelliSlow","neg","ONE","g","mul","ZERO","t2","ge","FpSqrt","sqrt3mod4","c1","sqrt5mod8","n2","v","nv","i","sub","FIELD_FIELDS","FpPow","f","p","d","FpInvertBatch","nums","tmp","Array","length","lastMultiplied","reduce","acc","is0","inverted","inv","reduceRight","nLength","nBitLength","_nBitLength","undefined","toString","nByteLength","Math","ceil","getFieldBytesLength","fieldOrder","bitLength","getMinHashLength","Field","ORDER","bitLen","isLE","redef","BITS","BYTES","sqrtP","Object","freeze","MASK","bitMask","create","isValid","isOdd","lhs","rhs","add","div","sqrN","addN","subN","mulN","sqrt","invertBatch","lst","cmov","c","toBytes","numberToBytesLE","numberToBytesBE","fromBytes","bytes","bytesToNumberLE","bytesToNumberBE","mapHashToField","key","len","fieldLen","minLen","reduced","pow2","validateField","field","opts","map","val","validateObject"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/abstract/modular.esm.js

@@ -0,0 +1,4 @@
+import{numberToBytesLE as t,numberToBytesBE as e,bitMask as n,bytesToNumberLE as r,bytesToNumberBE as o,validateObject as i}from"./utils.esm.js";
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const s=BigInt(0),u=BigInt(1),l=BigInt(2),d=BigInt(3),f=BigInt(4),c=BigInt(5),g=BigInt(8);function mod(t,e){const n=t%e;return n>=s?n:e+n}function pow(t,e,n){if(n<=s||e<s)throw new Error("Expected power/modulo > 0");if(n===u)return s;let r=u;for(;e>s;)e&u&&(r=r*t%n),t=t*t%n,e>>=u;return r}function pow2(t,e,n){let r=t;for(;e-- >s;)r*=r,r%=n;return r}function invert(t,e){if(t===s||e<=s)throw new Error(`invert: expected positive integers, got n=${t} mod=${e}`);let n=mod(t,e),r=e,o=s,i=u;for(;n!==s;){const t=r%n,e=o-i*(r/n);r=n,n=t,o=i,i=e}if(r!==u)throw new Error("invert: does not exist");return mod(o,e)}function tonelliShanks(t){const e=(t-u)/l;let n,r,o;for(n=t-u,r=0;n%l===s;n/=l,r++);for(o=l;o<t&&pow(o,e,t)!==t-u;o++);if(1===r){const e=(t+u)/f;return function tonelliFast(t,n){const r=t.pow(n,e);if(!t.eql(t.sqr(r),n))throw new Error("Cannot find square root");return r}}const i=(n+u)/l;return function tonelliSlow(t,s){if(t.pow(s,e)===t.neg(t.ONE))throw new Error("Cannot find square root");let l=r,d=t.pow(t.mul(t.ONE,o),n),f=t.pow(s,i),c=t.pow(s,n);for(;!t.eql(c,t.ONE);){if(t.eql(c,t.ZERO))return t.ZERO;let e=1;for(let n=t.sqr(c);e<l&&!t.eql(n,t.ONE);e++)n=t.sqr(n);const n=t.pow(d,u<<BigInt(l-e-1));d=t.sqr(n),f=t.mul(f,n),c=t.mul(c,d),l=e}return f}}function FpSqrt(t){if(t%f===d){const e=(t+u)/f;return function sqrt3mod4(t,n){const r=t.pow(n,e);if(!t.eql(t.sqr(r),n))throw new Error("Cannot find square root");return r}}if(t%g===c){const e=(t-c)/g;return function sqrt5mod8(t,n){const r=t.mul(n,l),o=t.pow(r,e),i=t.mul(n,o),s=t.mul(t.mul(i,l),o),u=t.mul(i,t.sub(s,t.ONE));if(!t.eql(t.sqr(u),n))throw new Error("Cannot find square root");return u}}return tonelliShanks(t)}BigInt(9),BigInt(16);const h=["create","isValid","is0","neg","inv","sqrt","sqr","eql","add","sub","mul","pow","div","addN","subN","mulN","sqrN"];function validateField(t){const e=h.reduce(((t,e)=>(t[e]="function",t)),{ORDER:"bigint",MASK:"bigint",BYTES:"isSafeInteger",BITS:"isSafeInteger"});return i(t,e)}function FpPow(t,e,n){if(n<s)throw new Error("Expected power > 0");if(n===s)return t.ONE;if(n===u)return e;let r=t.ONE,o=e;for(;n>s;)n&u&&(r=t.mul(r,o)),o=t.sqr(o),n>>=u;return r}function FpInvertBatch(t,e){const n=new Array(e.length),r=e.reduce(((e,r,o)=>t.is0(r)?e:(n[o]=e,t.mul(e,r))),t.ONE),o=t.inv(r);return e.reduceRight(((e,r,o)=>t.is0(r)?e:(n[o]=t.mul(e,n[o]),t.mul(e,r))),o),n}function nLength(t,e){const n=void 0!==e?e:t.toString(2).length;return{nBitLength:n,nByteLength:Math.ceil(n/8)}}function Field(i,l,d=!1,f={}){if(i<=s)throw new Error(`Expected Field ORDER > 0, got ${i}`);const{nBitLength:c,nByteLength:g}=nLength(i,l);if(g>2048)throw new Error("Field lengths over 2048 bytes are not supported");const h=FpSqrt(i),w=Object.freeze({ORDER:i,BITS:c,BYTES:g,MASK:n(c),ZERO:s,ONE:u,create:t=>mod(t,i),isValid:t=>{if("bigint"!=typeof t)throw new Error("Invalid field element: expected bigint, got "+typeof t);return s<=t&&t<i},is0:t=>t===s,isOdd:t=>(t&u)===u,neg:t=>mod(-t,i),eql:(t,e)=>t===e,sqr:t=>mod(t*t,i),add:(t,e)=>mod(t+e,i),sub:(t,e)=>mod(t-e,i),mul:(t,e)=>mod(t*e,i),pow:(t,e)=>FpPow(w,t,e),div:(t,e)=>mod(t*invert(e,i),i),sqrN:t=>t*t,addN:(t,e)=>t+e,subN:(t,e)=>t-e,mulN:(t,e)=>t*e,inv:t=>invert(t,i),sqrt:f.sqrt||(t=>h(w,t)),invertBatch:t=>FpInvertBatch(w,t),cmov:(t,e,n)=>n?e:t,toBytes:n=>d?t(n,g):e(n,g),fromBytes:t=>{if(t.length!==g)throw new Error(`Fp.fromBytes: expected ${g}, got ${t.length}`);return d?r(t):o(t)}});return Object.freeze(w)}function getFieldBytesLength(t){if("bigint"!=typeof t)throw new Error("field order must be bigint");const e=t.toString(2).length;return Math.ceil(e/8)}function getMinHashLength(t){const e=getFieldBytesLength(t);return e+Math.ceil(e/2)}function mapHashToField(n,i,s=!1){const l=n.length,d=getFieldBytesLength(i),f=getMinHashLength(i);if(l<16||l<f||l>1024)throw new Error(`expected ${f}-1024 bytes of input, got ${l}`);const c=mod(s?o(n):r(n),i-u)+u;return s?t(c,d):e(c,d)}export{Field,FpInvertBatch,FpPow,FpSqrt,getFieldBytesLength,getMinHashLength,invert,mapHashToField,mod,nLength,pow,pow2,tonelliShanks,validateField};
+//# sourceMappingURL=modular.esm.js.map

package/dist/browser/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/abstract/modular.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modular.esm.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/@noble+curves@1.2.0/node_modules/@noble/curves/esm/abstract/modular.js"],"sourcesContent":["/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// Utilities for modular arithmetics and finite fields\nimport { bitMask, numberToBytesBE, numberToBytesLE, bytesToNumberBE, bytesToNumberLE, ensureBytes, validateObject, } from './utils.js';\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3);\n// prettier-ignore\nconst _4n = BigInt(4), _5n = BigInt(5), _8n = BigInt(8);\n// prettier-ignore\nconst _9n = BigInt(9), _16n = BigInt(16);\n// Calculates a modulo b\nexport function mod(a, b) {\n    const result = a % b;\n    return result >= _0n ? result : b + result;\n}\n/**\n * Efficiently raise num to power and do modular division.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n * @example\n * pow(2n, 6n, 11n) // 64n % 11n == 9n\n */\n// TODO: use field version && remove\nexport function pow(num, power, modulo) {\n    if (modulo <= _0n || power < _0n)\n        throw new Error('Expected power/modulo > 0');\n    if (modulo === _1n)\n        return _0n;\n    let res = _1n;\n    while (power > _0n) {\n        if (power & _1n)\n            res = (res * num) % modulo;\n        num = (num * num) % modulo;\n        power >>= _1n;\n    }\n    return res;\n}\n// Does x ^ (2 ^ power) mod p. pow2(30, 4) == 30 ^ (2 ^ 4)\nexport function pow2(x, power, modulo) {\n    let res = x;\n    while (power-- > _0n) {\n        res *= res;\n        res %= modulo;\n    }\n    return res;\n}\n// Inverses number over modulo\nexport function invert(number, modulo) {\n    if (number === _0n || modulo <= _0n) {\n        throw new Error(`invert: expected positive integers, got n=${number} mod=${modulo}`);\n    }\n    // Euclidean GCD https://brilliant.org/wiki/extended-euclidean-algorithm/\n    // Fermat's little theorem \"CT-like\" version inv(n) = n^(m-2) mod m is 30x slower.\n    let a = mod(number, modulo);\n    let b = modulo;\n    // prettier-ignore\n    let x = _0n, y = _1n, u = _1n, v = _0n;\n    while (a !== _0n) {\n        // JIT applies optimization if those two lines follow each other\n        const q = b / a;\n        const r = b % a;\n        const m = x - u * q;\n        const n = y - v * q;\n        // prettier-ignore\n        b = a, a = r, x = u, y = v, u = m, v = n;\n    }\n    const gcd = b;\n    if (gcd !== _1n)\n        throw new Error('invert: does not exist');\n    return mod(x, modulo);\n}\n/**\n * Tonelli-Shanks square root search algorithm.\n * 1. https://eprint.iacr.org/2012/685.pdf (page 12)\n * 2. Square Roots from 1; 24, 51, 10 to Dan Shanks\n * Will start an infinite loop if field order P is not prime.\n * @param P field order\n * @returns function that takes field Fp (created from P) and number n\n */\nexport function tonelliShanks(P) {\n    // Legendre constant: used to calculate Legendre symbol (a | p),\n    // which denotes the value of a^((p-1)/2) (mod p).\n    // (a | p) ≡ 1    if a is a square (mod p)\n    // (a | p) ≡ -1   if a is not a square (mod p)\n    // (a | p) ≡ 0    if a ≡ 0 (mod p)\n    const legendreC = (P - _1n) / _2n;\n    let Q, S, Z;\n    // Step 1: By factoring out powers of 2 from p - 1,\n    // find q and s such that p - 1 = q*(2^s) with q odd\n    for (Q = P - _1n, S = 0; Q % _2n === _0n; Q /= _2n, S++)\n        ;\n    // Step 2: Select a non-square z such that (z | p) ≡ -1 and set c ≡ zq\n    for (Z = _2n; Z < P && pow(Z, legendreC, P) !== P - _1n; Z++)\n        ;\n    // Fast-path\n    if (S === 1) {\n        const p1div4 = (P + _1n) / _4n;\n        return function tonelliFast(Fp, n) {\n            const root = Fp.pow(n, p1div4);\n            if (!Fp.eql(Fp.sqr(root), n))\n                throw new Error('Cannot find square root');\n            return root;\n        };\n    }\n    // Slow-path\n    const Q1div2 = (Q + _1n) / _2n;\n    return function tonelliSlow(Fp, n) {\n        // Step 0: Check that n is indeed a square: (n | p) should not be ≡ -1\n        if (Fp.pow(n, legendreC) === Fp.neg(Fp.ONE))\n            throw new Error('Cannot find square root');\n        let r = S;\n        // TODO: will fail at Fp2/etc\n        let g = Fp.pow(Fp.mul(Fp.ONE, Z), Q); // will update both x and b\n        let x = Fp.pow(n, Q1div2); // first guess at the square root\n        let b = Fp.pow(n, Q); // first guess at the fudge factor\n        while (!Fp.eql(b, Fp.ONE)) {\n            if (Fp.eql(b, Fp.ZERO))\n                return Fp.ZERO; // https://en.wikipedia.org/wiki/Tonelli%E2%80%93Shanks_algorithm (4. If t = 0, return r = 0)\n            // Find m such b^(2^m)==1\n            let m = 1;\n            for (let t2 = Fp.sqr(b); m < r; m++) {\n                if (Fp.eql(t2, Fp.ONE))\n                    break;\n                t2 = Fp.sqr(t2); // t2 *= t2\n            }\n            // NOTE: r-m-1 can be bigger than 32, need to convert to bigint before shift, otherwise there will be overflow\n            const ge = Fp.pow(g, _1n << BigInt(r - m - 1)); // ge = 2^(r-m-1)\n            g = Fp.sqr(ge); // g = ge * ge\n            x = Fp.mul(x, ge); // x *= ge\n            b = Fp.mul(b, g); // b *= g\n            r = m;\n        }\n        return x;\n    };\n}\nexport function FpSqrt(P) {\n    // NOTE: different algorithms can give different roots, it is up to user to decide which one they want.\n    // For example there is FpSqrtOdd/FpSqrtEven to choice root based on oddness (used for hash-to-curve).\n    // P ≡ 3 (mod 4)\n    // √n = n^((P+1)/4)\n    if (P % _4n === _3n) {\n        // Not all roots possible!\n        // const ORDER =\n        //   0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaabn;\n        // const NUM = 72057594037927816n;\n        const p1div4 = (P + _1n) / _4n;\n        return function sqrt3mod4(Fp, n) {\n            const root = Fp.pow(n, p1div4);\n            // Throw if root**2 != n\n            if (!Fp.eql(Fp.sqr(root), n))\n                throw new Error('Cannot find square root');\n            return root;\n        };\n    }\n    // Atkin algorithm for q ≡ 5 (mod 8), https://eprint.iacr.org/2012/685.pdf (page 10)\n    if (P % _8n === _5n) {\n        const c1 = (P - _5n) / _8n;\n        return function sqrt5mod8(Fp, n) {\n            const n2 = Fp.mul(n, _2n);\n            const v = Fp.pow(n2, c1);\n            const nv = Fp.mul(n, v);\n            const i = Fp.mul(Fp.mul(nv, _2n), v);\n            const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));\n            if (!Fp.eql(Fp.sqr(root), n))\n                throw new Error('Cannot find square root');\n            return root;\n        };\n    }\n    // P ≡ 9 (mod 16)\n    if (P % _16n === _9n) {\n        // NOTE: tonelli is too slow for bls-Fp2 calculations even on start\n        // Means we cannot use sqrt for constants at all!\n        //\n        // const c1 = Fp.sqrt(Fp.negate(Fp.ONE)); //  1. c1 = sqrt(-1) in F, i.e., (c1^2) == -1 in F\n        // const c2 = Fp.sqrt(c1);                //  2. c2 = sqrt(c1) in F, i.e., (c2^2) == c1 in F\n        // const c3 = Fp.sqrt(Fp.negate(c1));     //  3. c3 = sqrt(-c1) in F, i.e., (c3^2) == -c1 in F\n        // const c4 = (P + _7n) / _16n;           //  4. c4 = (q + 7) / 16        # Integer arithmetic\n        // sqrt = (x) => {\n        //   let tv1 = Fp.pow(x, c4);             //  1. tv1 = x^c4\n        //   let tv2 = Fp.mul(c1, tv1);           //  2. tv2 = c1 * tv1\n        //   const tv3 = Fp.mul(c2, tv1);         //  3. tv3 = c2 * tv1\n        //   let tv4 = Fp.mul(c3, tv1);           //  4. tv4 = c3 * tv1\n        //   const e1 = Fp.equals(Fp.square(tv2), x); //  5.  e1 = (tv2^2) == x\n        //   const e2 = Fp.equals(Fp.square(tv3), x); //  6.  e2 = (tv3^2) == x\n        //   tv1 = Fp.cmov(tv1, tv2, e1); //  7. tv1 = CMOV(tv1, tv2, e1)  # Select tv2 if (tv2^2) == x\n        //   tv2 = Fp.cmov(tv4, tv3, e2); //  8. tv2 = CMOV(tv4, tv3, e2)  # Select tv3 if (tv3^2) == x\n        //   const e3 = Fp.equals(Fp.square(tv2), x); //  9.  e3 = (tv2^2) == x\n        //   return Fp.cmov(tv1, tv2, e3); //  10.  z = CMOV(tv1, tv2, e3)  # Select the sqrt from tv1 and tv2\n        // }\n    }\n    // Other cases: Tonelli-Shanks algorithm\n    return tonelliShanks(P);\n}\n// Little-endian check for first LE bit (last BE bit);\nexport const isNegativeLE = (num, modulo) => (mod(num, modulo) & _1n) === _1n;\n// prettier-ignore\nconst FIELD_FIELDS = [\n    'create', 'isValid', 'is0', 'neg', 'inv', 'sqrt', 'sqr',\n    'eql', 'add', 'sub', 'mul', 'pow', 'div',\n    'addN', 'subN', 'mulN', 'sqrN'\n];\nexport function validateField(field) {\n    const initial = {\n        ORDER: 'bigint',\n        MASK: 'bigint',\n        BYTES: 'isSafeInteger',\n        BITS: 'isSafeInteger',\n    };\n    const opts = FIELD_FIELDS.reduce((map, val) => {\n        map[val] = 'function';\n        return map;\n    }, initial);\n    return validateObject(field, opts);\n}\n// Generic field functions\n/**\n * Same as `pow` but for Fp: non-constant-time.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n */\nexport function FpPow(f, num, power) {\n    // Should have same speed as pow for bigints\n    // TODO: benchmark!\n    if (power < _0n)\n        throw new Error('Expected power > 0');\n    if (power === _0n)\n        return f.ONE;\n    if (power === _1n)\n        return num;\n    let p = f.ONE;\n    let d = num;\n    while (power > _0n) {\n        if (power & _1n)\n            p = f.mul(p, d);\n        d = f.sqr(d);\n        power >>= _1n;\n    }\n    return p;\n}\n/**\n * Efficiently invert an array of Field elements.\n * `inv(0)` will return `undefined` here: make sure to throw an error.\n */\nexport function FpInvertBatch(f, nums) {\n    const tmp = new Array(nums.length);\n    // Walk from first to last, multiply them by each other MOD p\n    const lastMultiplied = nums.reduce((acc, num, i) => {\n        if (f.is0(num))\n            return acc;\n        tmp[i] = acc;\n        return f.mul(acc, num);\n    }, f.ONE);\n    // Invert last element\n    const inverted = f.inv(lastMultiplied);\n    // Walk from last to first, multiply them by inverted each other MOD p\n    nums.reduceRight((acc, num, i) => {\n        if (f.is0(num))\n            return acc;\n        tmp[i] = f.mul(acc, tmp[i]);\n        return f.mul(acc, num);\n    }, inverted);\n    return tmp;\n}\nexport function FpDiv(f, lhs, rhs) {\n    return f.mul(lhs, typeof rhs === 'bigint' ? invert(rhs, f.ORDER) : f.inv(rhs));\n}\n// This function returns True whenever the value x is a square in the field F.\nexport function FpIsSquare(f) {\n    const legendreConst = (f.ORDER - _1n) / _2n; // Integer arithmetic\n    return (x) => {\n        const p = f.pow(x, legendreConst);\n        return f.eql(p, f.ZERO) || f.eql(p, f.ONE);\n    };\n}\n// CURVE.n lengths\nexport function nLength(n, nBitLength) {\n    // Bit size, byte size of CURVE.n\n    const _nBitLength = nBitLength !== undefined ? nBitLength : n.toString(2).length;\n    const nByteLength = Math.ceil(_nBitLength / 8);\n    return { nBitLength: _nBitLength, nByteLength };\n}\n/**\n * Initializes a finite field over prime. **Non-primes are not supported.**\n * Do not init in loop: slow. Very fragile: always run a benchmark on a change.\n * Major performance optimizations:\n * * a) denormalized operations like mulN instead of mul\n * * b) same object shape: never add or remove keys\n * * c) Object.freeze\n * @param ORDER prime positive bigint\n * @param bitLen how many bits the field consumes\n * @param isLE (def: false) if encoding / decoding should be in little-endian\n * @param redef optional faster redefinitions of sqrt and other methods\n */\nexport function Field(ORDER, bitLen, isLE = false, redef = {}) {\n    if (ORDER <= _0n)\n        throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);\n    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen);\n    if (BYTES > 2048)\n        throw new Error('Field lengths over 2048 bytes are not supported');\n    const sqrtP = FpSqrt(ORDER);\n    const f = Object.freeze({\n        ORDER,\n        BITS,\n        BYTES,\n        MASK: bitMask(BITS),\n        ZERO: _0n,\n        ONE: _1n,\n        create: (num) => mod(num, ORDER),\n        isValid: (num) => {\n            if (typeof num !== 'bigint')\n                throw new Error(`Invalid field element: expected bigint, got ${typeof num}`);\n            return _0n <= num && num < ORDER; // 0 is valid element, but it's not invertible\n        },\n        is0: (num) => num === _0n,\n        isOdd: (num) => (num & _1n) === _1n,\n        neg: (num) => mod(-num, ORDER),\n        eql: (lhs, rhs) => lhs === rhs,\n        sqr: (num) => mod(num * num, ORDER),\n        add: (lhs, rhs) => mod(lhs + rhs, ORDER),\n        sub: (lhs, rhs) => mod(lhs - rhs, ORDER),\n        mul: (lhs, rhs) => mod(lhs * rhs, ORDER),\n        pow: (num, power) => FpPow(f, num, power),\n        div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),\n        // Same as above, but doesn't normalize\n        sqrN: (num) => num * num,\n        addN: (lhs, rhs) => lhs + rhs,\n        subN: (lhs, rhs) => lhs - rhs,\n        mulN: (lhs, rhs) => lhs * rhs,\n        inv: (num) => invert(num, ORDER),\n        sqrt: redef.sqrt || ((n) => sqrtP(f, n)),\n        invertBatch: (lst) => FpInvertBatch(f, lst),\n        // TODO: do we really need constant cmov?\n        // We don't have const-time bigints anyway, so probably will be not very useful\n        cmov: (a, b, c) => (c ? b : a),\n        toBytes: (num) => (isLE ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES)),\n        fromBytes: (bytes) => {\n            if (bytes.length !== BYTES)\n                throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes.length}`);\n            return isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);\n        },\n    });\n    return Object.freeze(f);\n}\nexport function FpSqrtOdd(Fp, elm) {\n    if (!Fp.isOdd)\n        throw new Error(`Field doesn't have isOdd`);\n    const root = Fp.sqrt(elm);\n    return Fp.isOdd(root) ? root : Fp.neg(root);\n}\nexport function FpSqrtEven(Fp, elm) {\n    if (!Fp.isOdd)\n        throw new Error(`Field doesn't have isOdd`);\n    const root = Fp.sqrt(elm);\n    return Fp.isOdd(root) ? Fp.neg(root) : root;\n}\n/**\n * \"Constant-time\" private key generation utility.\n * Same as mapKeyToField, but accepts less bytes (40 instead of 48 for 32-byte field).\n * Which makes it slightly more biased, less secure.\n * @deprecated use mapKeyToField instead\n */\nexport function hashToPrivateScalar(hash, groupOrder, isLE = false) {\n    hash = ensureBytes('privateHash', hash);\n    const hashLen = hash.length;\n    const minLen = nLength(groupOrder).nByteLength + 8;\n    if (minLen < 24 || hashLen < minLen || hashLen > 1024)\n        throw new Error(`hashToPrivateScalar: expected ${minLen}-1024 bytes of input, got ${hashLen}`);\n    const num = isLE ? bytesToNumberLE(hash) : bytesToNumberBE(hash);\n    return mod(num, groupOrder - _1n) + _1n;\n}\n/**\n * Returns total number of bytes consumed by the field element.\n * For example, 32 bytes for usual 256-bit weierstrass curve.\n * @param fieldOrder number of field elements, usually CURVE.n\n * @returns byte length of field\n */\nexport function getFieldBytesLength(fieldOrder) {\n    if (typeof fieldOrder !== 'bigint')\n        throw new Error('field order must be bigint');\n    const bitLength = fieldOrder.toString(2).length;\n    return Math.ceil(bitLength / 8);\n}\n/**\n * Returns minimal amount of bytes that can be safely reduced\n * by field order.\n * Should be 2^-128 for 128-bit curve such as P256.\n * @param fieldOrder number of field elements, usually CURVE.n\n * @returns byte length of target hash\n */\nexport function getMinHashLength(fieldOrder) {\n    const length = getFieldBytesLength(fieldOrder);\n    return length + Math.ceil(length / 2);\n}\n/**\n * \"Constant-time\" private key generation utility.\n * Can take (n + n/2) or more bytes of uniform input e.g. from CSPRNG or KDF\n * and convert them into private scalar, with the modulo bias being negligible.\n * Needs at least 48 bytes of input for 32-byte private key.\n * https://research.kudelskisecurity.com/2020/07/28/the-definitive-guide-to-modulo-bias-and-how-to-avoid-it/\n * FIPS 186-5, A.2 https://csrc.nist.gov/publications/detail/fips/186/5/final\n * RFC 9380, https://www.rfc-editor.org/rfc/rfc9380#section-5\n * @param hash hash output from SHA3 or a similar function\n * @param groupOrder size of subgroup - (e.g. secp256k1.CURVE.n)\n * @param isLE interpret hash bytes as LE num\n * @returns valid private scalar\n */\nexport function mapHashToField(key, fieldOrder, isLE = false) {\n    const len = key.length;\n    const fieldLen = getFieldBytesLength(fieldOrder);\n    const minLen = getMinHashLength(fieldOrder);\n    // No small numbers: need to understand bias story. No huge numbers: easier to detect JS timings.\n    if (len < 16 || len < minLen || len > 1024)\n        throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);\n    const num = isLE ? bytesToNumberBE(key) : bytesToNumberLE(key);\n    // `mod(x, 11)` can sometimes produce 0. `mod(x, 10) + 1` is the same, but no 0\n    const reduced = mod(num, fieldOrder - _1n) + _1n;\n    return isLE ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);\n}\n//# sourceMappingURL=modular.js.map"],"names":["_0n","BigInt","_1n","_2n","_3n","_4n","_5n","_8n","mod","a","b","result","pow","num","power","modulo","Error","res","pow2","x","invert","number","u","r","m","tonelliShanks","P","legendreC","Q","S","Z","p1div4","tonelliFast","Fp","n","root","eql","sqr","Q1div2","tonelliSlow","neg","ONE","g","mul","ZERO","t2","ge","FpSqrt","sqrt3mod4","c1","sqrt5mod8","n2","v","nv","i","sub","FIELD_FIELDS","validateField","field","opts","reduce","map","val","ORDER","MASK","BYTES","BITS","validateObject","FpPow","f","p","d","FpInvertBatch","nums","tmp","Array","length","lastMultiplied","acc","is0","inverted","inv","reduceRight","nLength","nBitLength","_nBitLength","undefined","toString","nByteLength","Math","ceil","Field","bitLen","isLE","redef","sqrtP","Object","freeze","bitMask","create","isValid","isOdd","lhs","rhs","add","div","sqrN","addN","subN","mulN","sqrt","invertBatch","lst","cmov","c","toBytes","numberToBytesLE","numberToBytesBE","fromBytes","bytes","bytesToNumberLE","bytesToNumberBE","getFieldBytesLength","fieldOrder","bitLength","getMinHashLength","mapHashToField","key","len","fieldLen","minLen","reduced"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/abstract/utils.amd.js

@@ -0,0 +1,3 @@
+define(["exports"],(function(e){"use strict";
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */const t=BigInt(0),r=BigInt(1),n=BigInt(2),u8a=e=>e instanceof Uint8Array,o=Array.from({length:256},((e,t)=>t.toString(16).padStart(2,"0")));function bytesToHex(e){if(!u8a(e))throw new Error("Uint8Array expected");let t="";for(let r=0;r<e.length;r++)t+=o[e[r]];return t}function numberToHexUnpadded(e){const t=e.toString(16);return 1&t.length?`0${t}`:t}function hexToNumber(e){if("string"!=typeof e)throw new Error("hex string expected, got "+typeof e);return BigInt(""===e?"0":`0x${e}`)}function hexToBytes(e){if("string"!=typeof e)throw new Error("hex string expected, got "+typeof e);const t=e.length;if(t%2)throw new Error("padded hex string expected, got unpadded hex of length "+t);const r=new Uint8Array(t/2);for(let t=0;t<r.length;t++){const n=2*t,o=e.slice(n,n+2),i=Number.parseInt(o,16);if(Number.isNaN(i)||i<0)throw new Error("Invalid byte sequence");r[t]=i}return r}function numberToBytesBE(e,t){return hexToBytes(e.toString(16).padStart(2*t,"0"))}function concatBytes(...e){const t=new Uint8Array(e.reduce(((e,t)=>e+t.length),0));let r=0;return e.forEach((e=>{if(!u8a(e))throw new Error("Uint8Array expected");t.set(e,r),r+=e.length})),t}const u8n=e=>new Uint8Array(e),u8fr=e=>Uint8Array.from(e);const i={bigint:e=>"bigint"==typeof e,function:e=>"function"==typeof e,boolean:e=>"boolean"==typeof e,string:e=>"string"==typeof e,stringOrUint8Array:e=>"string"==typeof e||e instanceof Uint8Array,isSafeInteger:e=>Number.isSafeInteger(e),array:e=>Array.isArray(e),field:(e,t)=>t.Fp.isValid(e),hash:e=>"function"==typeof e&&Number.isSafeInteger(e.outputLen)};e.bitGet=function bitGet(e,t){return e>>BigInt(t)&r},e.bitLen=function bitLen(e){let n;for(n=0;e>t;e>>=r,n+=1);return n},e.bitMask=e=>(n<<BigInt(e-1))-r,e.bitSet=(e,n,o)=>e|(o?r:t)<<BigInt(n),e.bytesToHex=bytesToHex,e.bytesToNumberBE=function bytesToNumberBE(e){return hexToNumber(bytesToHex(e))},e.bytesToNumberLE=function bytesToNumberLE(e){if(!u8a(e))throw new Error("Uint8Array expected");return hexToNumber(bytesToHex(Uint8Array.from(e).reverse()))},e.concatBytes=concatBytes,e.createHmacDrbg=function createHmacDrbg(e,t,r){if("number"!=typeof e||e<2)throw new Error("hashLen must be a number");if("number"!=typeof t||t<2)throw new Error("qByteLen must be a number");if("function"!=typeof r)throw new Error("hmacFn must be a function");let n=u8n(e),o=u8n(e),i=0;const reset=()=>{n.fill(1),o.fill(0),i=0},h=(...e)=>r(o,n,...e),reseed=(e=u8n())=>{o=h(u8fr([0]),e),n=h(),0!==e.length&&(o=h(u8fr([1]),e),n=h())},gen=()=>{if(i++>=1e3)throw new Error("drbg: tried 1000 values");let e=0;const r=[];for(;e<t;){n=h();const t=n.slice();r.push(t),e+=n.length}return concatBytes(...r)};return(e,t)=>{let r;for(reset(),reseed(e);!(r=t(gen()));)reseed();return reset(),r}},e.ensureBytes=function ensureBytes(e,t,r){let n;if("string"==typeof t)try{n=hexToBytes(t)}catch(r){throw new Error(`${e} must be valid hex string, got "${t}". Cause: ${r}`)}else{if(!u8a(t))throw new Error(`${e} must be hex string or Uint8Array`);n=Uint8Array.from(t)}const o=n.length;if("number"==typeof r&&o!==r)throw new Error(`${e} expected ${r} bytes, got ${o}`);return n},e.equalBytes=function equalBytes(e,t){if(e.length!==t.length)return!1;for(let r=0;r<e.length;r++)if(e[r]!==t[r])return!1;return!0},e.hexToBytes=hexToBytes,e.hexToNumber=hexToNumber,e.numberToBytesBE=numberToBytesBE,e.numberToBytesLE=function numberToBytesLE(e,t){return numberToBytesBE(e,t).reverse()},e.numberToHexUnpadded=numberToHexUnpadded,e.numberToVarBytesBE=function numberToVarBytesBE(e){return hexToBytes(numberToHexUnpadded(e))},e.utf8ToBytes=function utf8ToBytes(e){if("string"!=typeof e)throw new Error("utf8ToBytes expected string, got "+typeof e);return new Uint8Array((new TextEncoder).encode(e))},e.validateObject=function validateObject(e,t,r={}){const checkField=(t,r,n)=>{const o=i[r];if("function"!=typeof o)throw new Error(`Invalid validator "${r}", expected function`);const s=e[t];if(!(n&&void 0===s||o(s,e)))throw new Error(`Invalid param ${String(t)}=${s} (${typeof s}), expected ${r}`)};for(const[e,r]of Object.entries(t))checkField(e,r,!1);for(const[e,t]of Object.entries(r))checkField(e,t,!0);return e}}));
+//# sourceMappingURL=utils.amd.js.map

package/dist/browser/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/abstract/utils.amd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.amd.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/@noble+curves@1.2.0/node_modules/@noble/curves/esm/abstract/utils.js"],"sourcesContent":["/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// 100 lines of code in the file are duplicated from noble-hashes (utils).\n// This is OK: `abstract` directory does not use noble-hashes.\n// User may opt-in into using different hashing library. This way, noble-hashes\n// won't be included into their bundle.\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\nconst _2n = BigInt(2);\nconst u8a = (a) => a instanceof Uint8Array;\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n/**\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes) {\n    if (!u8a(bytes))\n        throw new Error('Uint8Array expected');\n    // pre-caching improves the speed 6x\n    let hex = '';\n    for (let i = 0; i < bytes.length; i++) {\n        hex += hexes[bytes[i]];\n    }\n    return hex;\n}\nexport function numberToHexUnpadded(num) {\n    const hex = num.toString(16);\n    return hex.length & 1 ? `0${hex}` : hex;\n}\nexport function hexToNumber(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    // Big Endian\n    return BigInt(hex === '' ? '0' : `0x${hex}`);\n}\n/**\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    const len = hex.length;\n    if (len % 2)\n        throw new Error('padded hex string expected, got unpadded hex of length ' + len);\n    const array = new Uint8Array(len / 2);\n    for (let i = 0; i < array.length; i++) {\n        const j = i * 2;\n        const hexByte = hex.slice(j, j + 2);\n        const byte = Number.parseInt(hexByte, 16);\n        if (Number.isNaN(byte) || byte < 0)\n            throw new Error('Invalid byte sequence');\n        array[i] = byte;\n    }\n    return array;\n}\n// BE: Big Endian, LE: Little Endian\nexport function bytesToNumberBE(bytes) {\n    return hexToNumber(bytesToHex(bytes));\n}\nexport function bytesToNumberLE(bytes) {\n    if (!u8a(bytes))\n        throw new Error('Uint8Array expected');\n    return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));\n}\nexport function numberToBytesBE(n, len) {\n    return hexToBytes(n.toString(16).padStart(len * 2, '0'));\n}\nexport function numberToBytesLE(n, len) {\n    return numberToBytesBE(n, len).reverse();\n}\n// Unpadded, rarely used\nexport function numberToVarBytesBE(n) {\n    return hexToBytes(numberToHexUnpadded(n));\n}\n/**\n * Takes hex string or Uint8Array, converts to Uint8Array.\n * Validates output length.\n * Will throw error for other types.\n * @param title descriptive title for an error e.g. 'private key'\n * @param hex hex string or Uint8Array\n * @param expectedLength optional, will compare to result array's length\n * @returns\n */\nexport function ensureBytes(title, hex, expectedLength) {\n    let res;\n    if (typeof hex === 'string') {\n        try {\n            res = hexToBytes(hex);\n        }\n        catch (e) {\n            throw new Error(`${title} must be valid hex string, got \"${hex}\". Cause: ${e}`);\n        }\n    }\n    else if (u8a(hex)) {\n        // Uint8Array.from() instead of hash.slice() because node.js Buffer\n        // is instance of Uint8Array, and its slice() creates **mutable** copy\n        res = Uint8Array.from(hex);\n    }\n    else {\n        throw new Error(`${title} must be hex string or Uint8Array`);\n    }\n    const len = res.length;\n    if (typeof expectedLength === 'number' && len !== expectedLength)\n        throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);\n    return res;\n}\n/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays) {\n    const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));\n    let pad = 0; // walk through each item, ensure they have proper type\n    arrays.forEach((a) => {\n        if (!u8a(a))\n            throw new Error('Uint8Array expected');\n        r.set(a, pad);\n        pad += a.length;\n    });\n    return r;\n}\nexport function equalBytes(b1, b2) {\n    // We don't care about timing attacks here\n    if (b1.length !== b2.length)\n        return false;\n    for (let i = 0; i < b1.length; i++)\n        if (b1[i] !== b2[i])\n            return false;\n    return true;\n}\n/**\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error(`utf8ToBytes expected string, got ${typeof str}`);\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n// Bit operations\n/**\n * Calculates amount of bits in a bigint.\n * Same as `n.toString(2).length`\n */\nexport function bitLen(n) {\n    let len;\n    for (len = 0; n > _0n; n >>= _1n, len += 1)\n        ;\n    return len;\n}\n/**\n * Gets single bit at position.\n * NOTE: first bit position is 0 (same as arrays)\n * Same as `!!+Array.from(n.toString(2)).reverse()[pos]`\n */\nexport function bitGet(n, pos) {\n    return (n >> BigInt(pos)) & _1n;\n}\n/**\n * Sets single bit at position.\n */\nexport const bitSet = (n, pos, value) => {\n    return n | ((value ? _1n : _0n) << BigInt(pos));\n};\n/**\n * Calculate mask for N bits. Not using ** operator with bigints because of old engines.\n * Same as BigInt(`0b${Array(i).fill('1').join('')}`)\n */\nexport const bitMask = (n) => (_2n << BigInt(n - 1)) - _1n;\n// DRBG\nconst u8n = (data) => new Uint8Array(data); // creates Uint8Array\nconst u8fr = (arr) => Uint8Array.from(arr); // another shortcut\n/**\n * Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n * @returns function that will call DRBG until 2nd arg returns something meaningful\n * @example\n *   const drbg = createHmacDRBG<Key>(32, 32, hmac);\n *   drbg(seed, bytesToKey); // bytesToKey must return Key or undefined\n */\nexport function createHmacDrbg(hashLen, qByteLen, hmacFn) {\n    if (typeof hashLen !== 'number' || hashLen < 2)\n        throw new Error('hashLen must be a number');\n    if (typeof qByteLen !== 'number' || qByteLen < 2)\n        throw new Error('qByteLen must be a number');\n    if (typeof hmacFn !== 'function')\n        throw new Error('hmacFn must be a function');\n    // Step B, Step C: set hashLen to 8*ceil(hlen/8)\n    let v = u8n(hashLen); // Minimal non-full-spec HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n    let k = u8n(hashLen); // Steps B and C of RFC6979 3.2: set hashLen, in our case always same\n    let i = 0; // Iterations counter, will throw when over 1000\n    const reset = () => {\n        v.fill(1);\n        k.fill(0);\n        i = 0;\n    };\n    const h = (...b) => hmacFn(k, v, ...b); // hmac(k)(v, ...values)\n    const reseed = (seed = u8n()) => {\n        // HMAC-DRBG reseed() function. Steps D-G\n        k = h(u8fr([0x00]), seed); // k = hmac(k || v || 0x00 || seed)\n        v = h(); // v = hmac(k || v)\n        if (seed.length === 0)\n            return;\n        k = h(u8fr([0x01]), seed); // k = hmac(k || v || 0x01 || seed)\n        v = h(); // v = hmac(k || v)\n    };\n    const gen = () => {\n        // HMAC-DRBG generate() function\n        if (i++ >= 1000)\n            throw new Error('drbg: tried 1000 values');\n        let len = 0;\n        const out = [];\n        while (len < qByteLen) {\n            v = h();\n            const sl = v.slice();\n            out.push(sl);\n            len += v.length;\n        }\n        return concatBytes(...out);\n    };\n    const genUntil = (seed, pred) => {\n        reset();\n        reseed(seed); // Steps D-G\n        let res = undefined; // Step H: grind until k is in [1..n-1]\n        while (!(res = pred(gen())))\n            reseed();\n        reset();\n        return res;\n    };\n    return genUntil;\n}\n// Validating curves and fields\nconst validatorFns = {\n    bigint: (val) => typeof val === 'bigint',\n    function: (val) => typeof val === 'function',\n    boolean: (val) => typeof val === 'boolean',\n    string: (val) => typeof val === 'string',\n    stringOrUint8Array: (val) => typeof val === 'string' || val instanceof Uint8Array,\n    isSafeInteger: (val) => Number.isSafeInteger(val),\n    array: (val) => Array.isArray(val),\n    field: (val, object) => object.Fp.isValid(val),\n    hash: (val) => typeof val === 'function' && Number.isSafeInteger(val.outputLen),\n};\n// type Record<K extends string | number | symbol, T> = { [P in K]: T; }\nexport function validateObject(object, validators, optValidators = {}) {\n    const checkField = (fieldName, type, isOptional) => {\n        const checkVal = validatorFns[type];\n        if (typeof checkVal !== 'function')\n            throw new Error(`Invalid validator \"${type}\", expected function`);\n        const val = object[fieldName];\n        if (isOptional && val === undefined)\n            return;\n        if (!checkVal(val, object)) {\n            throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);\n        }\n    };\n    for (const [fieldName, type] of Object.entries(validators))\n        checkField(fieldName, type, false);\n    for (const [fieldName, type] of Object.entries(optValidators))\n        checkField(fieldName, type, true);\n    return object;\n}\n// validate type tests\n// const o: { a: number; b: number; c: number } = { a: 1, b: 5, c: 6 };\n// const z0 = validateObject(o, { a: 'isSafeInteger' }, { c: 'bigint' }); // Ok!\n// // Should fail type-check\n// const z1 = validateObject(o, { a: 'tmp' }, { c: 'zz' });\n// const z2 = validateObject(o, { a: 'isSafeInteger' }, { c: 'zz' });\n// const z3 = validateObject(o, { test: 'boolean', z: 'bug' });\n// const z4 = validateObject(o, { a: 'boolean', z: 'bug' });\n//# sourceMappingURL=utils.js.map"],"names":["_0n","BigInt","_1n","_2n","u8a","a","Uint8Array","hexes","Array","from","length","_","i","toString","padStart","bytesToHex","bytes","Error","hex","numberToHexUnpadded","num","hexToNumber","hexToBytes","len","array","j","hexByte","slice","byte","Number","parseInt","isNaN","numberToBytesBE","n","concatBytes","arrays","r","reduce","sum","pad","forEach","set","u8n","data","u8fr","arr","validatorFns","bigint","val","function","boolean","string","stringOrUint8Array","isSafeInteger","isArray","field","object","Fp","isValid","hash","outputLen","bitGet","pos","bitLen","value","bytesToNumberBE","bytesToNumberLE","reverse","createHmacDrbg","hashLen","qByteLen","hmacFn","v","k","reset","fill","h","b","reseed","seed","gen","out","sl","push","pred","res","ensureBytes","title","expectedLength","e","equalBytes","b1","b2","numberToBytesLE","numberToVarBytesBE","utf8ToBytes","str","TextEncoder","encode","validateObject","validators","optValidators","checkField","fieldName","type","isOptional","checkVal","undefined","String","Object","entries"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/abstract/utils.esm.js

@@ -0,0 +1,3 @@
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const e=BigInt(0),t=BigInt(1),r=BigInt(2),u8a=e=>e instanceof Uint8Array,n=Array.from({length:256},((e,t)=>t.toString(16).padStart(2,"0")));function bytesToHex(e){if(!u8a(e))throw new Error("Uint8Array expected");let t="";for(let r=0;r<e.length;r++)t+=n[e[r]];return t}function numberToHexUnpadded(e){const t=e.toString(16);return 1&t.length?`0${t}`:t}function hexToNumber(e){if("string"!=typeof e)throw new Error("hex string expected, got "+typeof e);return BigInt(""===e?"0":`0x${e}`)}function hexToBytes(e){if("string"!=typeof e)throw new Error("hex string expected, got "+typeof e);const t=e.length;if(t%2)throw new Error("padded hex string expected, got unpadded hex of length "+t);const r=new Uint8Array(t/2);for(let t=0;t<r.length;t++){const n=2*t,o=e.slice(n,n+2),i=Number.parseInt(o,16);if(Number.isNaN(i)||i<0)throw new Error("Invalid byte sequence");r[t]=i}return r}function bytesToNumberBE(e){return hexToNumber(bytesToHex(e))}function bytesToNumberLE(e){if(!u8a(e))throw new Error("Uint8Array expected");return hexToNumber(bytesToHex(Uint8Array.from(e).reverse()))}function numberToBytesBE(e,t){return hexToBytes(e.toString(16).padStart(2*t,"0"))}function numberToBytesLE(e,t){return numberToBytesBE(e,t).reverse()}function numberToVarBytesBE(e){return hexToBytes(numberToHexUnpadded(e))}function ensureBytes(e,t,r){let n;if("string"==typeof t)try{n=hexToBytes(t)}catch(r){throw new Error(`${e} must be valid hex string, got "${t}". Cause: ${r}`)}else{if(!u8a(t))throw new Error(`${e} must be hex string or Uint8Array`);n=Uint8Array.from(t)}const o=n.length;if("number"==typeof r&&o!==r)throw new Error(`${e} expected ${r} bytes, got ${o}`);return n}function concatBytes(...e){const t=new Uint8Array(e.reduce(((e,t)=>e+t.length),0));let r=0;return e.forEach((e=>{if(!u8a(e))throw new Error("Uint8Array expected");t.set(e,r),r+=e.length})),t}function equalBytes(e,t){if(e.length!==t.length)return!1;for(let r=0;r<e.length;r++)if(e[r]!==t[r])return!1;return!0}function utf8ToBytes(e){if("string"!=typeof e)throw new Error("utf8ToBytes expected string, got "+typeof e);return new Uint8Array((new TextEncoder).encode(e))}function bitLen(r){let n;for(n=0;r>e;r>>=t,n+=1);return n}function bitGet(e,r){return e>>BigInt(r)&t}const bitSet=(r,n,o)=>r|(o?t:e)<<BigInt(n),bitMask=e=>(r<<BigInt(e-1))-t,u8n=e=>new Uint8Array(e),u8fr=e=>Uint8Array.from(e);function createHmacDrbg(e,t,r){if("number"!=typeof e||e<2)throw new Error("hashLen must be a number");if("number"!=typeof t||t<2)throw new Error("qByteLen must be a number");if("function"!=typeof r)throw new Error("hmacFn must be a function");let n=u8n(e),o=u8n(e),i=0;const reset=()=>{n.fill(1),o.fill(0),i=0},h=(...e)=>r(o,n,...e),reseed=(e=u8n())=>{o=h(u8fr([0]),e),n=h(),0!==e.length&&(o=h(u8fr([1]),e),n=h())},gen=()=>{if(i++>=1e3)throw new Error("drbg: tried 1000 values");let e=0;const r=[];for(;e<t;){n=h();const t=n.slice();r.push(t),e+=n.length}return concatBytes(...r)};return(e,t)=>{let r;for(reset(),reseed(e);!(r=t(gen()));)reseed();return reset(),r}}const o={bigint:e=>"bigint"==typeof e,function:e=>"function"==typeof e,boolean:e=>"boolean"==typeof e,string:e=>"string"==typeof e,stringOrUint8Array:e=>"string"==typeof e||e instanceof Uint8Array,isSafeInteger:e=>Number.isSafeInteger(e),array:e=>Array.isArray(e),field:(e,t)=>t.Fp.isValid(e),hash:e=>"function"==typeof e&&Number.isSafeInteger(e.outputLen)};function validateObject(e,t,r={}){const checkField=(t,r,n)=>{const i=o[r];if("function"!=typeof i)throw new Error(`Invalid validator "${r}", expected function`);const s=e[t];if(!(n&&void 0===s||i(s,e)))throw new Error(`Invalid param ${String(t)}=${s} (${typeof s}), expected ${r}`)};for(const[e,r]of Object.entries(t))checkField(e,r,!1);for(const[e,t]of Object.entries(r))checkField(e,t,!0);return e}export{bitGet,bitLen,bitMask,bitSet,bytesToHex,bytesToNumberBE,bytesToNumberLE,concatBytes,createHmacDrbg,ensureBytes,equalBytes,hexToBytes,hexToNumber,numberToBytesBE,numberToBytesLE,numberToHexUnpadded,numberToVarBytesBE,utf8ToBytes,validateObject};
+//# sourceMappingURL=utils.esm.js.map

package/dist/browser/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/abstract/utils.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.esm.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/@noble+curves@1.2.0/node_modules/@noble/curves/esm/abstract/utils.js"],"sourcesContent":["/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// 100 lines of code in the file are duplicated from noble-hashes (utils).\n// This is OK: `abstract` directory does not use noble-hashes.\n// User may opt-in into using different hashing library. This way, noble-hashes\n// won't be included into their bundle.\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\nconst _2n = BigInt(2);\nconst u8a = (a) => a instanceof Uint8Array;\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n/**\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes) {\n    if (!u8a(bytes))\n        throw new Error('Uint8Array expected');\n    // pre-caching improves the speed 6x\n    let hex = '';\n    for (let i = 0; i < bytes.length; i++) {\n        hex += hexes[bytes[i]];\n    }\n    return hex;\n}\nexport function numberToHexUnpadded(num) {\n    const hex = num.toString(16);\n    return hex.length & 1 ? `0${hex}` : hex;\n}\nexport function hexToNumber(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    // Big Endian\n    return BigInt(hex === '' ? '0' : `0x${hex}`);\n}\n/**\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    const len = hex.length;\n    if (len % 2)\n        throw new Error('padded hex string expected, got unpadded hex of length ' + len);\n    const array = new Uint8Array(len / 2);\n    for (let i = 0; i < array.length; i++) {\n        const j = i * 2;\n        const hexByte = hex.slice(j, j + 2);\n        const byte = Number.parseInt(hexByte, 16);\n        if (Number.isNaN(byte) || byte < 0)\n            throw new Error('Invalid byte sequence');\n        array[i] = byte;\n    }\n    return array;\n}\n// BE: Big Endian, LE: Little Endian\nexport function bytesToNumberBE(bytes) {\n    return hexToNumber(bytesToHex(bytes));\n}\nexport function bytesToNumberLE(bytes) {\n    if (!u8a(bytes))\n        throw new Error('Uint8Array expected');\n    return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));\n}\nexport function numberToBytesBE(n, len) {\n    return hexToBytes(n.toString(16).padStart(len * 2, '0'));\n}\nexport function numberToBytesLE(n, len) {\n    return numberToBytesBE(n, len).reverse();\n}\n// Unpadded, rarely used\nexport function numberToVarBytesBE(n) {\n    return hexToBytes(numberToHexUnpadded(n));\n}\n/**\n * Takes hex string or Uint8Array, converts to Uint8Array.\n * Validates output length.\n * Will throw error for other types.\n * @param title descriptive title for an error e.g. 'private key'\n * @param hex hex string or Uint8Array\n * @param expectedLength optional, will compare to result array's length\n * @returns\n */\nexport function ensureBytes(title, hex, expectedLength) {\n    let res;\n    if (typeof hex === 'string') {\n        try {\n            res = hexToBytes(hex);\n        }\n        catch (e) {\n            throw new Error(`${title} must be valid hex string, got \"${hex}\". Cause: ${e}`);\n        }\n    }\n    else if (u8a(hex)) {\n        // Uint8Array.from() instead of hash.slice() because node.js Buffer\n        // is instance of Uint8Array, and its slice() creates **mutable** copy\n        res = Uint8Array.from(hex);\n    }\n    else {\n        throw new Error(`${title} must be hex string or Uint8Array`);\n    }\n    const len = res.length;\n    if (typeof expectedLength === 'number' && len !== expectedLength)\n        throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);\n    return res;\n}\n/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays) {\n    const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));\n    let pad = 0; // walk through each item, ensure they have proper type\n    arrays.forEach((a) => {\n        if (!u8a(a))\n            throw new Error('Uint8Array expected');\n        r.set(a, pad);\n        pad += a.length;\n    });\n    return r;\n}\nexport function equalBytes(b1, b2) {\n    // We don't care about timing attacks here\n    if (b1.length !== b2.length)\n        return false;\n    for (let i = 0; i < b1.length; i++)\n        if (b1[i] !== b2[i])\n            return false;\n    return true;\n}\n/**\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error(`utf8ToBytes expected string, got ${typeof str}`);\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n// Bit operations\n/**\n * Calculates amount of bits in a bigint.\n * Same as `n.toString(2).length`\n */\nexport function bitLen(n) {\n    let len;\n    for (len = 0; n > _0n; n >>= _1n, len += 1)\n        ;\n    return len;\n}\n/**\n * Gets single bit at position.\n * NOTE: first bit position is 0 (same as arrays)\n * Same as `!!+Array.from(n.toString(2)).reverse()[pos]`\n */\nexport function bitGet(n, pos) {\n    return (n >> BigInt(pos)) & _1n;\n}\n/**\n * Sets single bit at position.\n */\nexport const bitSet = (n, pos, value) => {\n    return n | ((value ? _1n : _0n) << BigInt(pos));\n};\n/**\n * Calculate mask for N bits. Not using ** operator with bigints because of old engines.\n * Same as BigInt(`0b${Array(i).fill('1').join('')}`)\n */\nexport const bitMask = (n) => (_2n << BigInt(n - 1)) - _1n;\n// DRBG\nconst u8n = (data) => new Uint8Array(data); // creates Uint8Array\nconst u8fr = (arr) => Uint8Array.from(arr); // another shortcut\n/**\n * Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n * @returns function that will call DRBG until 2nd arg returns something meaningful\n * @example\n *   const drbg = createHmacDRBG<Key>(32, 32, hmac);\n *   drbg(seed, bytesToKey); // bytesToKey must return Key or undefined\n */\nexport function createHmacDrbg(hashLen, qByteLen, hmacFn) {\n    if (typeof hashLen !== 'number' || hashLen < 2)\n        throw new Error('hashLen must be a number');\n    if (typeof qByteLen !== 'number' || qByteLen < 2)\n        throw new Error('qByteLen must be a number');\n    if (typeof hmacFn !== 'function')\n        throw new Error('hmacFn must be a function');\n    // Step B, Step C: set hashLen to 8*ceil(hlen/8)\n    let v = u8n(hashLen); // Minimal non-full-spec HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n    let k = u8n(hashLen); // Steps B and C of RFC6979 3.2: set hashLen, in our case always same\n    let i = 0; // Iterations counter, will throw when over 1000\n    const reset = () => {\n        v.fill(1);\n        k.fill(0);\n        i = 0;\n    };\n    const h = (...b) => hmacFn(k, v, ...b); // hmac(k)(v, ...values)\n    const reseed = (seed = u8n()) => {\n        // HMAC-DRBG reseed() function. Steps D-G\n        k = h(u8fr([0x00]), seed); // k = hmac(k || v || 0x00 || seed)\n        v = h(); // v = hmac(k || v)\n        if (seed.length === 0)\n            return;\n        k = h(u8fr([0x01]), seed); // k = hmac(k || v || 0x01 || seed)\n        v = h(); // v = hmac(k || v)\n    };\n    const gen = () => {\n        // HMAC-DRBG generate() function\n        if (i++ >= 1000)\n            throw new Error('drbg: tried 1000 values');\n        let len = 0;\n        const out = [];\n        while (len < qByteLen) {\n            v = h();\n            const sl = v.slice();\n            out.push(sl);\n            len += v.length;\n        }\n        return concatBytes(...out);\n    };\n    const genUntil = (seed, pred) => {\n        reset();\n        reseed(seed); // Steps D-G\n        let res = undefined; // Step H: grind until k is in [1..n-1]\n        while (!(res = pred(gen())))\n            reseed();\n        reset();\n        return res;\n    };\n    return genUntil;\n}\n// Validating curves and fields\nconst validatorFns = {\n    bigint: (val) => typeof val === 'bigint',\n    function: (val) => typeof val === 'function',\n    boolean: (val) => typeof val === 'boolean',\n    string: (val) => typeof val === 'string',\n    stringOrUint8Array: (val) => typeof val === 'string' || val instanceof Uint8Array,\n    isSafeInteger: (val) => Number.isSafeInteger(val),\n    array: (val) => Array.isArray(val),\n    field: (val, object) => object.Fp.isValid(val),\n    hash: (val) => typeof val === 'function' && Number.isSafeInteger(val.outputLen),\n};\n// type Record<K extends string | number | symbol, T> = { [P in K]: T; }\nexport function validateObject(object, validators, optValidators = {}) {\n    const checkField = (fieldName, type, isOptional) => {\n        const checkVal = validatorFns[type];\n        if (typeof checkVal !== 'function')\n            throw new Error(`Invalid validator \"${type}\", expected function`);\n        const val = object[fieldName];\n        if (isOptional && val === undefined)\n            return;\n        if (!checkVal(val, object)) {\n            throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);\n        }\n    };\n    for (const [fieldName, type] of Object.entries(validators))\n        checkField(fieldName, type, false);\n    for (const [fieldName, type] of Object.entries(optValidators))\n        checkField(fieldName, type, true);\n    return object;\n}\n// validate type tests\n// const o: { a: number; b: number; c: number } = { a: 1, b: 5, c: 6 };\n// const z0 = validateObject(o, { a: 'isSafeInteger' }, { c: 'bigint' }); // Ok!\n// // Should fail type-check\n// const z1 = validateObject(o, { a: 'tmp' }, { c: 'zz' });\n// const z2 = validateObject(o, { a: 'isSafeInteger' }, { c: 'zz' });\n// const z3 = validateObject(o, { test: 'boolean', z: 'bug' });\n// const z4 = validateObject(o, { a: 'boolean', z: 'bug' });\n//# sourceMappingURL=utils.js.map"],"names":["_0n","BigInt","_1n","_2n","u8a","a","Uint8Array","hexes","Array","from","length","_","i","toString","padStart","bytesToHex","bytes","Error","hex","numberToHexUnpadded","num","hexToNumber","hexToBytes","len","array","j","hexByte","slice","byte","Number","parseInt","isNaN","bytesToNumberBE","bytesToNumberLE","reverse","numberToBytesBE","n","numberToBytesLE","numberToVarBytesBE","ensureBytes","title","expectedLength","res","e","concatBytes","arrays","r","reduce","sum","pad","forEach","set","equalBytes","b1","b2","utf8ToBytes","str","TextEncoder","encode","bitLen","bitGet","pos","bitSet","value","bitMask","u8n","data","u8fr","arr","createHmacDrbg","hashLen","qByteLen","hmacFn","v","k","reset","fill","h","b","reseed","seed","gen","out","sl","push","pred","validatorFns","bigint","val","function","boolean","string","stringOrUint8Array","isSafeInteger","isArray","field","object","Fp","isValid","hash","outputLen","validateObject","validators","optValidators","checkField","fieldName","type","isOptional","checkVal","undefined","String","Object","entries"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/browser/node_modules/.pnpm/@noble_curves@1.2.0/node_modules/@noble/curves/esm/abstract/weierstrass.amd.js

@@ -0,0 +1,3 @@
+define(["exports","./modular.amd","./utils.amd","./curve.amd"],(function(t,e,r,n){"use strict";
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */const{bytesToNumberBE:i,hexToBytes:o}=r,s={Err:class DERErr extends Error{constructor(t=""){super(t)}},_parseInt(t){const{Err:e}=s;if(t.length<2||2!==t[0])throw new e("Invalid signature integer tag");const r=t[1],n=t.subarray(2,r+2);if(!r||n.length!==r)throw new e("Invalid signature integer: wrong length");if(128&n[0])throw new e("Invalid signature integer: negative");if(0===n[0]&&!(128&n[1]))throw new e("Invalid signature integer: unnecessary leading zero");return{d:i(n),l:t.subarray(r+2)}},toSig(t){const{Err:e}=s,r="string"==typeof t?o(t):t;if(!(r instanceof Uint8Array))throw new Error("ui8a expected");let n=r.length;if(n<2||48!=r[0])throw new e("Invalid signature tag");if(r[1]!==n-2)throw new e("Invalid signature: incorrect length");const{d:i,l:a}=s._parseInt(r.subarray(2)),{d:u,l:l}=s._parseInt(a);if(l.length)throw new e("Invalid signature: left bytes after parsing");return{r:i,s:u}},hexFromSig(t){const slice=t=>8&Number.parseInt(t[0],16)?"00"+t:t,h=t=>{const e=t.toString(16);return 1&e.length?`0${e}`:e},e=slice(h(t.s)),r=slice(h(t.r)),n=e.length/2,i=r.length/2,o=h(n),s=h(i);return`30${h(i+n+4)}02${s}${r}02${o}${e}`}},a=BigInt(0),u=BigInt(1);BigInt(2);const l=BigInt(3);function weierstrassPoints(t){const i=function validatePointOpts(t){const e=n.validateBasic(t);r.validateObject(e,{a:"field",b:"field"},{allowedPrivateKeyLengths:"array",wrapPrivateKey:"boolean",isTorsionFree:"function",clearCofactor:"function",allowInfinityPoint:"boolean",fromBytes:"function",toBytes:"function"});const{endo:i,Fp:o,a:s}=e;if(i){if(!o.eql(s,o.ZERO))throw new Error("Endomorphism can only be defined for Koblitz curves that have a=0");if("object"!=typeof i||"bigint"!=typeof i.beta||"function"!=typeof i.splitScalar)throw new Error("Expected endomorphism with beta: bigint and splitScalar: function")}return Object.freeze({...e})}(t),{Fp:o}=i,s=i.toBytes||((t,e,n)=>{const i=e.toAffine();return r.concatBytes(Uint8Array.from([4]),o.toBytes(i.x),o.toBytes(i.y))}),c=i.fromBytes||(t=>{const e=t.subarray(1);return{x:o.fromBytes(e.subarray(0,o.BYTES)),y:o.fromBytes(e.subarray(o.BYTES,2*o.BYTES))}});function weierstrassEquation(t){const{a:e,b:r}=i,n=o.sqr(t),s=o.mul(n,t);return o.add(o.add(s,o.mul(t,e)),r)}if(!o.eql(o.sqr(i.Gy),weierstrassEquation(i.Gx)))throw new Error("bad generator point: equation left != right");function isWithinCurveOrder(t){return"bigint"==typeof t&&a<t&&t<i.n}function assertGE(t){if(!isWithinCurveOrder(t))throw new Error("Expected valid bigint: 0 < bigint < curve.n")}function normPrivateKeyToScalar(t){const{allowedPrivateKeyLengths:n,nByteLength:o,wrapPrivateKey:s,n:a}=i;if(n&&"bigint"!=typeof t){if(t instanceof Uint8Array&&(t=r.bytesToHex(t)),"string"!=typeof t||!n.includes(t.length))throw new Error("Invalid key");t=t.padStart(2*o,"0")}let u;try{u="bigint"==typeof t?t:r.bytesToNumberBE(r.ensureBytes("private key",t,o))}catch(e){throw new Error(`private key must be ${o} bytes, hex or bigint, not ${typeof t}`)}return s&&(u=e.mod(u,a)),assertGE(u),u}const d=new Map;function assertPrjPoint(t){if(!(t instanceof Point))throw new Error("ProjectivePoint expected")}class Point{constructor(t,e,r){if(this.px=t,this.py=e,this.pz=r,null==t||!o.isValid(t))throw new Error("x required");if(null==e||!o.isValid(e))throw new Error("y required");if(null==r||!o.isValid(r))throw new Error("z required")}static fromAffine(t){const{x:e,y:r}=t||{};if(!t||!o.isValid(e)||!o.isValid(r))throw new Error("invalid affine point");if(t instanceof Point)throw new Error("projective point not allowed");const is0=t=>o.eql(t,o.ZERO);return is0(e)&&is0(r)?Point.ZERO:new Point(e,r,o.ONE)}get x(){return this.toAffine().x}get y(){return this.toAffine().y}static normalizeZ(t){const e=o.invertBatch(t.map((t=>t.pz)));return t.map(((t,r)=>t.toAffine(e[r]))).map(Point.fromAffine)}static fromHex(t){const e=Point.fromAffine(c(r.ensureBytes("pointHex",t)));return e.assertValidity(),e}static fromPrivateKey(t){return Point.BASE.multiply(normPrivateKeyToScalar(t))}_setWindowSize(t){this._WINDOW_SIZE=t,d.delete(this)}assertValidity(){if(this.is0()){if(i.allowInfinityPoint&&!o.is0(this.py))return;throw new Error("bad point: ZERO")}const{x:t,y:e}=this.toAffine();if(!o.isValid(t)||!o.isValid(e))throw new Error("bad point: x or y not FE");const r=o.sqr(e),n=weierstrassEquation(t);if(!o.eql(r,n))throw new Error("bad point: equation left != right");if(!this.isTorsionFree())throw new Error("bad point: not in prime-order subgroup")}hasEvenY(){const{y:t}=this.toAffine();if(o.isOdd)return!o.isOdd(t);throw new Error("Field doesn't support isOdd")}equals(t){assertPrjPoint(t);const{px:e,py:r,pz:n}=this,{px:i,py:s,pz:a}=t,u=o.eql(o.mul(e,a),o.mul(i,n)),l=o.eql(o.mul(r,a),o.mul(s,n));return u&&l}negate(){return new Point(this.px,o.neg(this.py),this.pz)}double(){const{a:t,b:e}=i,r=o.mul(e,l),{px:n,py:s,pz:a}=this;let u=o.ZERO,c=o.ZERO,d=o.ZERO,f=o.mul(n,n),y=o.mul(s,s),m=o.mul(a,a),w=o.mul(n,s);return w=o.add(w,w),d=o.mul(n,a),d=o.add(d,d),u=o.mul(t,d),c=o.mul(r,m),c=o.add(u,c),u=o.sub(y,c),c=o.add(y,c),c=o.mul(u,c),u=o.mul(w,u),d=o.mul(r,d),m=o.mul(t,m),w=o.sub(f,m),w=o.mul(t,w),w=o.add(w,d),d=o.add(f,f),f=o.add(d,f),f=o.add(f,m),f=o.mul(f,w),c=o.add(c,f),m=o.mul(s,a),m=o.add(m,m),f=o.mul(m,w),u=o.sub(u,f),d=o.mul(m,y),d=o.add(d,d),d=o.add(d,d),new Point(u,c,d)}add(t){assertPrjPoint(t);const{px:e,py:r,pz:n}=this,{px:s,py:a,pz:u}=t;let c=o.ZERO,d=o.ZERO,f=o.ZERO;const y=i.a,m=o.mul(i.b,l);let w=o.mul(e,s),p=o.mul(r,a),g=o.mul(n,u),E=o.add(e,r),b=o.add(s,a);E=o.mul(E,b),b=o.add(w,p),E=o.sub(E,b),b=o.add(e,n);let B=o.add(s,u);return b=o.mul(b,B),B=o.add(w,g),b=o.sub(b,B),B=o.add(r,n),c=o.add(a,u),B=o.mul(B,c),c=o.add(p,g),B=o.sub(B,c),f=o.mul(y,b),c=o.mul(m,g),f=o.add(c,f),c=o.sub(p,f),f=o.add(p,f),d=o.mul(c,f),p=o.add(w,w),p=o.add(p,w),g=o.mul(y,g),b=o.mul(m,b),p=o.add(p,g),g=o.sub(w,g),g=o.mul(y,g),b=o.add(b,g),w=o.mul(p,b),d=o.add(d,w),w=o.mul(B,b),c=o.mul(E,c),c=o.sub(c,w),w=o.mul(E,p),f=o.mul(B,f),f=o.add(f,w),new Point(c,d,f)}subtract(t){return this.add(t.negate())}is0(){return this.equals(Point.ZERO)}wNAF(t){return y.wNAFCached(this,d,t,(t=>{const e=o.invertBatch(t.map((t=>t.pz)));return t.map(((t,r)=>t.toAffine(e[r]))).map(Point.fromAffine)}))}multiplyUnsafe(t){const e=Point.ZERO;if(t===a)return e;if(assertGE(t),t===u)return this;const{endo:r}=i;if(!r)return y.unsafeLadder(this,t);let{k1neg:n,k1:s,k2neg:l,k2:c}=r.splitScalar(t),d=e,f=e,m=this;for(;s>a||c>a;)s&u&&(d=d.add(m)),c&u&&(f=f.add(m)),m=m.double(),s>>=u,c>>=u;return n&&(d=d.negate()),l&&(f=f.negate()),f=new Point(o.mul(f.px,r.beta),f.py,f.pz),d.add(f)}multiply(t){assertGE(t);let e,r,n=t;const{endo:s}=i;if(s){const{k1neg:t,k1:i,k2neg:a,k2:u}=s.splitScalar(n);let{p:l,f:c}=this.wNAF(i),{p:d,f:f}=this.wNAF(u);l=y.constTimeNegate(t,l),d=y.constTimeNegate(a,d),d=new Point(o.mul(d.px,s.beta),d.py,d.pz),e=l.add(d),r=c.add(f)}else{const{p:t,f:i}=this.wNAF(n);e=t,r=i}return Point.normalizeZ([e,r])[0]}multiplyAndAddUnsafe(t,e,r){const n=Point.BASE,mul=(t,e)=>e!==a&&e!==u&&t.equals(n)?t.multiply(e):t.multiplyUnsafe(e),i=mul(this,e).add(mul(t,r));return i.is0()?void 0:i}toAffine(t){const{px:e,py:r,pz:n}=this,i=this.is0();null==t&&(t=i?o.ONE:o.inv(n));const s=o.mul(e,t),a=o.mul(r,t),u=o.mul(n,t);if(i)return{x:o.ZERO,y:o.ZERO};if(!o.eql(u,o.ONE))throw new Error("invZ was invalid");return{x:s,y:a}}isTorsionFree(){const{h:t,isTorsionFree:e}=i;if(t===u)return!0;if(e)return e(Point,this);throw new Error("isTorsionFree() has not been declared for the elliptic curve")}clearCofactor(){const{h:t,clearCofactor:e}=i;return t===u?this:e?e(Point,this):this.multiplyUnsafe(i.h)}toRawBytes(t=!0){return this.assertValidity(),s(Point,this,t)}toHex(t=!0){return r.bytesToHex(this.toRawBytes(t))}}Point.BASE=new Point(i.Gx,i.Gy,o.ONE),Point.ZERO=new Point(o.ZERO,o.ONE,o.ZERO);const f=i.nBitLength,y=n.wNAF(Point,i.endo?Math.ceil(f/2):f);return{CURVE:i,ProjectivePoint:Point,normPrivateKeyToScalar:normPrivateKeyToScalar,weierstrassEquation:weierstrassEquation,isWithinCurveOrder:isWithinCurveOrder}}BigInt(4),t.DER=s,t.weierstrass=function weierstrass(t){const i=function validateOpts(t){const e=n.validateBasic(t);return r.validateObject(e,{hash:"hash",hmac:"function",randomBytes:"function"},{bits2int:"function",bits2int_modN:"function",lowS:"boolean"}),Object.freeze({lowS:!0,...e})}(t),{Fp:o,n:l}=i,c=o.BYTES+1,d=2*o.BYTES+1;function modN(t){return e.mod(t,l)}function invN(t){return e.invert(t,l)}const{ProjectivePoint:f,normPrivateKeyToScalar:y,weierstrassEquation:m,isWithinCurveOrder:w}=weierstrassPoints({...i,toBytes(t,e,n){const i=e.toAffine(),s=o.toBytes(i.x),a=r.concatBytes;return n?a(Uint8Array.from([e.hasEvenY()?2:3]),s):a(Uint8Array.from([4]),s,o.toBytes(i.y))},fromBytes(t){const e=t.length,n=t[0],i=t.subarray(1);if(e!==c||2!==n&&3!==n){if(e===d&&4===n){return{x:o.fromBytes(i.subarray(0,o.BYTES)),y:o.fromBytes(i.subarray(o.BYTES,2*o.BYTES))}}throw new Error(`Point of length ${e} was invalid. Expected ${c} compressed bytes or ${d} uncompressed bytes`)}{const t=r.bytesToNumberBE(i);if(!function isValidFieldElement(t){return a<t&&t<o.ORDER}(t))throw new Error("Point is not on curve");const e=m(t);let s=o.sqrt(e);return!(1&~n)!==((s&u)===u)&&(s=o.neg(s)),{x:t,y:s}}}}),numToNByteStr=t=>r.bytesToHex(r.numberToBytesBE(t,i.nByteLength));function isBiggerThanHalfOrder(t){return t>l>>u}const slcNum=(t,e,n)=>r.bytesToNumberBE(t.slice(e,n));class Signature{constructor(t,e,r){this.r=t,this.s=e,this.recovery=r,this.assertValidity()}static fromCompact(t){const e=i.nByteLength;return t=r.ensureBytes("compactSignature",t,2*e),new Signature(slcNum(t,0,e),slcNum(t,e,2*e))}static fromDER(t){const{r:e,s:n}=s.toSig(r.ensureBytes("DER",t));return new Signature(e,n)}assertValidity(){if(!w(this.r))throw new Error("r must be 0 < r < CURVE.n");if(!w(this.s))throw new Error("s must be 0 < s < CURVE.n")}addRecoveryBit(t){return new Signature(this.r,this.s,t)}recoverPublicKey(t){const{r:e,s:n,recovery:s}=this,a=E(r.ensureBytes("msgHash",t));if(null==s||![0,1,2,3].includes(s))throw new Error("recovery id invalid");const u=2===s||3===s?e+i.n:e;if(u>=o.ORDER)throw new Error("recovery id 2 or 3 invalid");const l=1&s?"03":"02",c=f.fromHex(l+numToNByteStr(u)),d=invN(u),y=modN(-a*d),m=modN(n*d),w=f.BASE.multiplyAndAddUnsafe(c,y,m);if(!w)throw new Error("point at infinify");return w.assertValidity(),w}hasHighS(){return isBiggerThanHalfOrder(this.s)}normalizeS(){return this.hasHighS()?new Signature(this.r,modN(-this.s),this.recovery):this}toDERRawBytes(){return r.hexToBytes(this.toDERHex())}toDERHex(){return s.hexFromSig({r:this.r,s:this.s})}toCompactRawBytes(){return r.hexToBytes(this.toCompactHex())}toCompactHex(){return numToNByteStr(this.r)+numToNByteStr(this.s)}}const p={isValidPrivateKey(t){try{return y(t),!0}catch(t){return!1}},normPrivateKeyToScalar:y,randomPrivateKey:()=>{const t=e.getMinHashLength(i.n);return e.mapHashToField(i.randomBytes(t),i.n)},precompute:(t=8,e=f.BASE)=>(e._setWindowSize(t),e.multiply(BigInt(3)),e)};function isProbPub(t){const e=t instanceof Uint8Array,r="string"==typeof t,n=(e||r)&&t.length;return e?n===c||n===d:r?n===2*c||n===2*d:t instanceof f}const g=i.bits2int||function(t){const e=r.bytesToNumberBE(t),n=8*t.length-i.nBitLength;return n>0?e>>BigInt(n):e},E=i.bits2int_modN||function(t){return modN(g(t))},b=r.bitMask(i.nBitLength);function int2octets(t){if("bigint"!=typeof t)throw new Error("bigint expected");if(!(a<=t&&t<b))throw new Error(`bigint expected < 2^${i.nBitLength}`);return r.numberToBytesBE(t,i.nByteLength)}function prepSig(t,e,n=B){if(["recovered","canonical"].some((t=>t in n)))throw new Error("sign() legacy options not supported");const{hash:s,randomBytes:l}=i;let{lowS:c,prehash:d,extraEntropy:m}=n;null==c&&(c=!0),t=r.ensureBytes("msgHash",t),d&&(t=r.ensureBytes("prehashed msgHash",s(t)));const p=E(t),b=y(e),v=[int2octets(b),int2octets(p)];if(null!=m){const t=!0===m?l(o.BYTES):m;v.push(r.ensureBytes("extraEntropy",t))}const P=r.concatBytes(...v),S=p;return{seed:P,k2sig:function k2sig(t){const e=g(t);if(!w(e))return;const r=invN(e),n=f.BASE.multiply(e).toAffine(),i=modN(n.x);if(i===a)return;const o=modN(r*modN(S+i*b));if(o===a)return;let s=(n.x===i?0:2)|Number(n.y&u),l=o;return c&&isBiggerThanHalfOrder(o)&&(l=function normalizeS(t){return isBiggerThanHalfOrder(t)?modN(-t):t}(o),s^=1),new Signature(i,l,s)}}}const B={lowS:i.lowS,prehash:!1},v={lowS:i.lowS,prehash:!1};return f.BASE._setWindowSize(8),{CURVE:i,getPublicKey:function getPublicKey(t,e=!0){return f.fromPrivateKey(t).toRawBytes(e)},getSharedSecret:function getSharedSecret(t,e,r=!0){if(isProbPub(t))throw new Error("first arg must be private key");if(!isProbPub(e))throw new Error("second arg must be public key");return f.fromHex(e).multiply(y(t)).toRawBytes(r)},sign:function sign(t,e,n=B){const{seed:o,k2sig:s}=prepSig(t,e,n),a=i;return r.createHmacDrbg(a.hash.outputLen,a.nByteLength,a.hmac)(o,s)},verify:function verify(t,e,n,o=v){const a=t;if(e=r.ensureBytes("msgHash",e),n=r.ensureBytes("publicKey",n),"strict"in o)throw new Error("options.strict was renamed to lowS");const{lowS:u,prehash:l}=o;let c,d;try{if("string"==typeof a||a instanceof Uint8Array)try{c=Signature.fromDER(a)}catch(t){if(!(t instanceof s.Err))throw t;c=Signature.fromCompact(a)}else{if("object"!=typeof a||"bigint"!=typeof a.r||"bigint"!=typeof a.s)throw new Error("PARSE");{const{r:t,s:e}=a;c=new Signature(t,e)}}d=f.fromHex(n)}catch(t){if("PARSE"===t.message)throw new Error("signature must be Signature instance, Uint8Array or hex string");return!1}if(u&&c.hasHighS())return!1;l&&(e=i.hash(e));const{r:y,s:m}=c,w=E(e),p=invN(m),g=modN(w*p),b=modN(y*p),B=f.BASE.multiplyAndAddUnsafe(d,g,b)?.toAffine();return!!B&&modN(B.x)===y},ProjectivePoint:f,Signature:Signature,utils:p}},t.weierstrassPoints=weierstrassPoints}));
+//# sourceMappingURL=weierstrass.amd.js.map