nappup 1.9.1 → 2.0.1

package/src/helpers/bech32.js

@@ -1,131 +0,0 @@
-const ALPHABET = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l'
-
-const ALPHABET_MAP = {}
-for (let z = 0; z < ALPHABET.length; z++) {
-  const x = ALPHABET.charAt(z)
-  ALPHABET_MAP[x] = z
-}
-
-function polymod (values) {
-  const GEN = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]
-  let chk = 1
-  for (let p = 0; p < values.length; ++p) {
-    const top = chk >> 25
-    chk = (chk & 0x1ffffff) << 5 ^ values[p]
-    for (let i = 0; i < 5; ++i) {
-      if ((top >> i) & 1) {
-        chk ^= GEN[i]
-      }
-    }
-  }
-  return chk
-}
-
-function hrpExpand (hrp) {
-  const ret = []
-  for (let p = 0; p < hrp.length; ++p) {
-    ret.push(hrp.charCodeAt(p) >> 5)
-  }
-  ret.push(0)
-  for (let p = 0; p < hrp.length; ++p) {
-    ret.push(hrp.charCodeAt(p) & 31)
-  }
-  return ret
-}
-
-function verifyChecksum (hrp, data) {
-  return polymod(hrpExpand(hrp).concat(data)) === 1
-}
-
-function createChecksum (hrp, data) {
-  const values = hrpExpand(hrp).concat(data).concat([0, 0, 0, 0, 0, 0])
-  const mod = polymod(values) ^ 1
-  const ret = []
-  for (let p = 0; p < 6; ++p) {
-    ret.push((mod >> 5 * (5 - p)) & 31)
-  }
-  return ret
-}
-
-export function encode (hrp, data) {
-  const combined = data.concat(createChecksum(hrp, data))
-  let ret = hrp + '1'
-  for (let p = 0; p < combined.length; ++p) {
-    ret += ALPHABET.charAt(combined[p])
-  }
-  return ret
-}
-
-export function decode (bechString, limit = 90) {
-  let p
-  let hasLower = false
-  let hasUpper = false
-  for (p = 0; p < bechString.length; ++p) {
-    if (bechString.charCodeAt(p) < 33 || bechString.charCodeAt(p) > 126) {
-      return null
-    }
-    if (bechString.charCodeAt(p) >= 97 && bechString.charCodeAt(p) <= 122) {
-      hasLower = true
-    }
-    if (bechString.charCodeAt(p) >= 65 && bechString.charCodeAt(p) <= 90) {
-      hasUpper = true
-    }
-  }
-  if (hasLower && hasUpper) {
-    return null
-  }
-  bechString = bechString.toLowerCase()
-  const pos = bechString.lastIndexOf('1')
-  if (pos < 1 || pos + 7 > bechString.length || bechString.length > limit) {
-    return null
-  }
-  const hrp = bechString.substring(0, pos)
-  const data = []
-  for (p = pos + 1; p < bechString.length; ++p) {
-    const d = ALPHABET_MAP[bechString.charAt(p)]
-    if (d === undefined) {
-      return null
-    }
-    data.push(d)
-  }
-  if (!verifyChecksum(hrp, data)) {
-    return null
-  }
-  return { hrp, data: data.slice(0, data.length - 6) }
-}
-
-export function toWords (data) {
-  let value = 0
-  let bits = 0
-  const maxV = 31
-  const result = []
-  for (let i = 0; i < data.length; ++i) {
-    value = (value << 8) | data[i]
-    bits += 8
-    while (bits >= 5) {
-      bits -= 5
-      result.push((value >> bits) & maxV)
-    }
-  }
-  if (bits > 0) {
-    result.push((value << (5 - bits)) & maxV)
-  }
-  return result
-}
-
-export function fromWords (data) {
-  let value = 0
-  let bits = 0
-  const maxV = 255
-  const result = []
-  for (let i = 0; i < data.length; ++i) {
-    const element = data[i]
-    value = (value << 5) | element
-    bits += 5
-    while (bits >= 8) {
-      bits -= 8
-      result.push((value >> bits) & maxV)
-    }
-  }
-  return result
-}

package/src/helpers/nip19.js

@@ -1,112 +0,0 @@
-import { bytesToBase16, base16ToBytes } from '#helpers/base16.js'
-import { bytesToBase62, base62ToBytes, BASE62_ALPHABET } from '#helpers/base62.js'
-import { encode as bech32Encode, decode as bech32Decode, toWords, fromWords } from '#helpers/bech32.js'
-import { isNostrAppDTagSafe } from '#helpers/app.js'
-
-const MAX_SIZE = 5000
-export const NAPP_ENTITY_REGEX = new RegExp(`^\\+{1,3}[${BASE62_ALPHABET}]{48,${MAX_SIZE}}$`)
-const textEncoder = new TextEncoder()
-const textDecoder = new TextDecoder()
-
-const kindByChannel = {
-  main: 35128,
-  next: 35129,
-  draft: 35130
-}
-const channelByKind = Object.fromEntries(
-  Object.entries(kindByChannel).map(([k, v]) => [v, k])
-)
-const prefixByChannel = {
-  main: '+',
-  next: '++',
-  draft: '+++'
-}
-const channelByPrefix = Object.fromEntries(
-  Object.entries(prefixByChannel).map(([k, v]) => [v, k])
-)
-export function appEncode (ref) {
-  if (!isNostrAppDTagSafe(ref.dTag)) { throw new Error('Invalid deduplication tag') }
-  const channel = ref.channel ? (prefixByChannel[ref.channel] && ref.channel) : channelByKind[ref.kind]
-  if (!channel) throw new Error('Wrong channel')
-  const tlv = toTlv([
-    [textEncoder.encode(ref.dTag)], // type 0 (the array index)
-    (ref.relays || []).map(url => textEncoder.encode(url)), // type 1
-    [base16ToBytes(ref.pubkey)] // type 2
-  ])
-  const base62 = bytesToBase62(tlv)
-  const prefix = prefixByChannel[channel]
-  return `${prefix}${base62}`
-}
-
-export function appDecode (entity) {
-  const prefix = entity.match(/^\+*/)[0]
-  const channel = channelByPrefix[prefix]
-  if (!channel) throw new Error('Invalid channel')
-  const base62 = entity.slice(prefix.length)
-  const tlv = tlvToObj(base62ToBytes(base62))
-  if (!tlv[0]?.[0]) throw new Error('Missing deduplication tag')
-  if (!tlv[2]?.[0]) throw new Error('Missing author pubkey')
-  if (tlv[2][0].length !== 32) throw new Error('Author pubkey should be 32 bytes')
-  const dTag = textDecoder.decode(tlv[0][0])
-  if (!isNostrAppDTagSafe(dTag)) { throw new Error('Invalid deduplication tag') }
-
-  return {
-    dTag,
-    pubkey: bytesToBase16(tlv[2][0]),
-    kind: kindByChannel[channel],
-    channel,
-    relays: tlv[1] ? tlv[1].map(url => textDecoder.decode(url)) : []
-  }
-}
-
-export function nsecEncode (hex) {
-  const bytes = base16ToBytes(hex)
-  const words = toWords(bytes)
-  return bech32Encode('nsec', words)
-}
-
-export function nsecDecode (nsec) {
-  const decoded = bech32Decode(nsec, MAX_SIZE)
-  if (!decoded) throw new Error('Invalid nsec')
-  const { hrp, data } = decoded
-  if (hrp !== 'nsec') throw new Error('Invalid nsec')
-  const bytes = fromWords(data)
-  if (bytes.length !== 32) throw new Error('Invalid nsec length')
-  return bytesToBase16(new Uint8Array(bytes))
-}
-
-function toTlv (tlvConfig) {
-  const arrays = []
-  tlvConfig
-    .map((v, i) => [i, v])
-    .reverse() // if the first type is 0, entity always starts with the '0' char
-    .forEach(([type, values]) => {
-      // just non-empty values will be included
-      values.forEach(v => {
-        if (v.length > 255) throw new Error('Value is too big')
-        const array = new Uint8Array(v.length + 2)
-        array.set([type], 0) // t
-        array.set([v.length], 1) // l
-        array.set(v, 2) // v
-        arrays.push(array)
-      })
-    })
-  return new Uint8Array(arrays.reduce((r, v) => [...r, ...v]))
-}
-
-// { 0: [t0v0], 1: [t1v0, t1v2], 3: [t3v0] }
-function tlvToObj (tlv) {
-  const ret = {}
-  let rest = tlv
-  let t, l, v
-  while (rest.length > 0) {
-    t = rest[0]
-    l = rest[1]
-    v = rest.slice(2, 2 + l)
-    rest = rest.slice(2 + l)
-    if (v.length < l) throw new Error(`not enough data to read on TLV ${t}`)
-    ret[t] ??= []
-    ret[t].push(v)
-  }
-  return ret
-}

package/src/services/GEMINI.md

@@ -1,9 +0,0 @@
-# src/services folder
-
-- Place services here. Services are multi-step functionality that make the code more
-readable than if placing every step together on a single function.
-
-## General Instructions:
-
-- Use object-oriented programming paradigm.
-- Each file default exports one class or singleton.

package/src/services/base93-decoder.js

@@ -1,107 +0,0 @@
-// https://github.com/ticlo/arrow-code/blob/master/src/base93.ts
-// https://github.com/ticlo/arrow-code/blob/master/LICENSE - Apache 2.0
-
-// JSON-safe (space included; " and \ excluded)
-const BASE93_ALPHABET =
-  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&'()*+,-./:;<=>?@[]^_`{|}~ "
-
-const DECODING_TABLE = (() => {
-  const out = new Int16Array(128)
-  out.fill(93) // sentinel = invalid
-  for (let i = 0; i < 93; i++) out[BASE93_ALPHABET.charCodeAt(i)] = i
-  return out
-})()
-
-/**
- * Decode Base93 string to Uint8Array
- * @param {string} str - The Base93 encoded string to decode
- * @param {number} [offset=0] - The starting position in the string
- * @param {number} [length=-1] - The number of characters to decode, or -1 for all remaining
- * @returns {Uint8Array} The decoded bytes
- */
-export function decode (str, offset = 0, length = -1) {
-  let end = offset + length
-  if (length < 0 || end > str.length) end = str.length
-
-  // Over-allocate; we’ll trim at the end
-  const out = new Uint8Array(Math.ceil((end - offset) * 7 / 8))
-
-  let dbq = 0
-  let dn = 0
-  let dv = -1
-  let pos = 0
-
-  for (let i = offset; i < end; i++) {
-    const code = str.charCodeAt(i)
-    if (code > 126) continue // ignore non-ASCII
-    const v = DECODING_TABLE[code]
-    if (v === 93) continue // ignore invalids
-    if (dv === -1) {
-      dv = v
-    } else {
-      const t = dv + v * 93
-      dv = -1
-      dbq |= t << dn
-      dn += ((t & 0x1fff) > 456 ? 13 : 14)
-      while (dn > 7) {
-        out[pos++] = dbq & 0xff
-        dbq >>>= 8
-        dn -= 8
-      }
-    }
-  }
-
-  if (dv !== -1) {
-    out[pos++] = (dbq | (dv << dn)) & 0xff
-  }
-  return out.subarray(0, pos)
-}
-
-export default class Base93Decoder {
-  constructor (source, { mimeType = '', preferTextStreamDecoding = false } = {}) {
-    this.sourceIterator = source?.[Symbol.iterator]?.() || source?.[Symbol.asyncIterator]?.() || source()
-    this.asTextStream = preferTextStreamDecoding && mimeType.startsWith('text/')
-    if (this.asTextStream) this.textDecoder = new TextDecoder()
-  }
-
-  // decoder generator
-  * [Symbol.iterator] (base93String) {
-    if (this.asTextStream) {
-      while (base93String) {
-        // stream=true avoids cutting a multi-byte character
-        base93String = yield this.textDecoder.decode(decode(base93String), { stream: true })
-      }
-    } else {
-      while (base93String) {
-        base93String = yield decode(base93String)
-      }
-    }
-  }
-
-  // Gets the decoded data.
-  getDecoded () { return iteratorToStream(this, this.sourceIterator) }
-}
-
-function iteratorToStream (decoder, sourceIterator) {
-  return new ReadableStream({
-    decoderIterator: null,
-    async start (controller) {
-      const { value: chunk, done } = await sourceIterator.next()
-      if (done) return controller.close()
-
-      // Pass first chunk when instantiating the decoder generator
-      this.decoderIterator = decoder[Symbol.iterator](chunk)
-      const { value } = this.decoderIterator.next()
-      if (value) controller.enqueue(value)
-    },
-    async pull (controller) {
-      if (!this.decoderIterator) return
-
-      const { value: chunk, done: sourceDone } = await sourceIterator.next()
-      const { value, done } = this.decoderIterator.next(chunk)
-
-      if (value) controller.enqueue(value)
-      if (done || sourceDone) controller.close()
-    }
-  })
-}

package/src/services/base93-encoder.js

@@ -1,96 +0,0 @@
-// https://github.com/ticlo/arrow-code/blob/master/src/base93.ts
-// https://github.com/ticlo/arrow-code/blob/master/LICENSE - Apache 2.0
-
-// JSON-safe (space included; " and \ excluded)
-const BASE93_ALPHABET =
-  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&'()*+,-./:;<=>?@[]^_`{|}~ "
-const ENCODING_TABLE = (() => {
-  const out = new Uint16Array(93)
-  for (let i = 0; i < 93; i++) out[i] = BASE93_ALPHABET.charCodeAt(i)
-  return out
-})()
-
-function codesToString (codes, len) {
-  const CHUNK = 16384 // 16k chars per slice
-  let s = ''
-  for (let i = 0; i < len; i += CHUNK) {
-    const end = i + CHUNK < len ? i + CHUNK : len
-    s += String.fromCharCode.apply(
-      null,
-      Array.prototype.slice.call(codes, i, end)
-    )
-  }
-  return s
-}
-
-export default class Base93Encoder {
-  constructor (prefix = '') {
-    // bit reservoir
-    this._ebq = 0 // queued bits
-    this._en = 0  // number of bits in ebq
-
-    // output parts
-    this._parts = []
-    this._finished = false
-
-    if (prefix) this._parts.push(prefix)
-  }
-
-  // Stream bytes; keeps reservoir across calls.
-  update (bytes) {
-    if (this._finished) throw new Error('Encoder already finalized.')
-    const src = bytes instanceof Uint8Array ? bytes : Uint8Array.from(bytes)
-
-    // Over-allocate for this update; we’ll trim to 'pos'
-    const outCodes = new Uint16Array(Math.ceil(src.length * 8 / 6.5) + 4)
-    let pos = 0
-
-    let ebq = this._ebq
-    let en = this._en
-    let ev = 0
-
-    for (let i = 0; i < src.length; i++) {
-      ebq |= (src[i] & 0xff) << en
-      en += 8
-      if (en > 13) {
-        ev = ebq & 0x1fff
-        if (ev > 456) {
-          ebq >>>= 13
-          en -= 13
-        } else {
-          ev = ebq & 0x3fff
-          ebq >>>= 14
-          en -= 14
-        }
-        outCodes[pos++] = ENCODING_TABLE[ev % 93]
-        outCodes[pos++] = ENCODING_TABLE[(ev / 93) | 0]
-      }
-    }
-
-    // persist reservoir
-    this._ebq = ebq
-    this._en = en
-
-    if (pos) this._parts.push(codesToString(outCodes, pos))
-    return this
-  }
-
-  // Finalize on first call: flush trailing partial block, join, lock.
-  getEncoded () {
-    if (!this._finished) {
-      if (this._en > 0) {
-        const outCodes = new Uint16Array(2)
-        let pos = 0
-        outCodes[pos++] = ENCODING_TABLE[this._ebq % 93]
-        if (this._en > 7 || this._ebq > 92) {
-          outCodes[pos++] = ENCODING_TABLE[(this._ebq / 93) | 0]
-        }
-        this._parts.push(codesToString(outCodes, pos))
-      }
-      this._finished = true
-      this._ebq = 0
-      this._en = 0
-    }
-    return this._parts.join('')
-  }
-}