libp2r2p 0.2.0 → 0.4.0

package/README.md

@@ -174,3 +174,70 @@ clearing is asynchronous too: `await messenger.clearChannel(channelPubkey)`.
 Use explicit subpath imports for bundle size. The package root re-exports the
 main messenger API for convenience, but applications that only need one piece
 should import that subpath directly.
+
+## Internationalization
+
+The dependency-free `libp2r2p/i18n` subpath exposes locale detection and a
+small translator suitable for keeping each component's translations beside
+that component. Translation keys are literal strings, not dotted paths.
+
+```js
+import { getT } from 'libp2r2p/i18n'
+
+const t = getT({
+  'Allow {{size}}': {
+    en: 'Allow {{size}}',
+    'pt-BR': 'Permitir {{size}}'
+  },
+  'Delete {{count}} items': {
+    en: {
+      one: 'Delete {{count}} item',
+      other: 'Delete {{count}} items'
+    }
+  }
+})
+
+t('Allow {{size}}', { size: '10 MiB' })
+```
+
+`getCurrentDeviceLocale()` prefers the locale resolved by `Intl`, then browser
+language hints, and preserves the full canonical BCP 47 locale. `getT()`
+matches exact and compatible language variants, falls back to English and then
+to the key itself, interpolates `{{name}}` values, and uses `Intl.PluralRules`
+when a locale value supplies plural forms. Missing interpolation values remain
+visible in the returned string.
+
+Catalog validation is opt-in. `validateLocales()` can be used independently,
+or `getT()` can validate once when creating the translator:
+
+```js
+import { getT, validateLocales } from 'libp2r2p/i18n'
+
+const validation = {
+  requiredLocales: ['en', 'pt-BR'],
+  referenceLocale: 'en',
+  requireReferenceKey: true
+}
+
+validateLocales(locales, validation)
+const t = getT(locales, { validation })
+```
+
+Validation checks catalog structure, required locales, plural `other` forms,
+and placeholder parity across every translation. `requireReferenceKey` also
+requires the reference locale's string, or its plural `other` form, to equal
+the literal translation key. Without `validation`, sparse catalogs continue
+to use the normal locale fallback behavior.
+
+## Binary encodings
+
+Base16, Base36, Base62, Base64/Base64URL, and Base93 helpers are available
+through their matching `libp2r2p/<encoding>` subpaths. Base36 exposes both a
+binary-safe variable-width codec and the canonical 32-byte/50-character
+NsiteBase36 representation from NIP-5A. Base62 uses the same case-sensitive
+alphabet as app NIP-19 entities; its default byte mode preserves leading zero
+bytes, while integer mode supports fixed-width identifiers.
+
+In NIP-5A, "no padding" means that no separate padding character such as `=`
+is used. Leading `0` digits are nevertheless required to make every Nsite
+Base36 value exactly 50 characters long.

package/base16/index.js

@@ -5,8 +5,13 @@ export function bytesToBase16 (bytes) {
 }
 
 export function base16ToBytes (base16) {
+  if (typeof base16 !== 'string') throw new TypeError('Base16 value should be a string')
+  if (base16.length % 2 !== 0) throw new Error('Invalid Base16 length')
+  if (!/^[0-9a-f]*$/i.test(base16)) throw new Error('Invalid Base16 character')
   const out = new Uint8Array(base16.length / 2)
-  for (let i = 0; i < out.length; i++) out[i] = parseInt(base16.slice(i * 2, i * 2 + 2), 16)
+  for (let i = 0; i < out.length; i++) {
+    out[i] = Number.parseInt(base16.slice(i * 2, i * 2 + 2), 16)
+  }
   return out
 }
 

package/base36/index.js

@@ -0,0 +1,114 @@
+import { base16ToBytes, bytesToBase16 } from '../base16/index.js'
+
+export const BASE36_ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz'
+
+const BASE = BigInt(BASE36_ALPHABET.length)
+const LEADER = BASE36_ALPHABET[0]
+const CHAR_MAP = new Map(
+  [...BASE36_ALPHABET].map((character, index) => [character, BigInt(index)])
+)
+const NSITE_BYTE_LENGTH = 32
+const NSITE_TEXT_LENGTH = 50
+const MAX_NSITE_VALUE = (1n << 256n) - 1n
+
+function bytesToInteger (bytes) {
+  let number = 0n
+  for (const byte of bytes) number = (number << 8n) + BigInt(byte)
+  return number
+}
+
+function integerToBase36 (number) {
+  let result = ''
+  while (number > 0n) {
+    result = BASE36_ALPHABET[Number(number % BASE)] + result
+    number /= BASE
+  }
+  return result || LEADER
+}
+
+function parseBase36Integer (value) {
+  let number = 0n
+  for (const character of value) {
+    const digit = CHAR_MAP.get(character)
+    if (digit === undefined) throw new Error('Invalid Base36 character: ' + character)
+    number = number * BASE + digit
+  }
+  return number
+}
+
+function integerToMinimalBytes (number) {
+  if (number === 0n) return new Uint8Array([0])
+  const bytes = []
+  while (number > 0n) {
+    bytes.unshift(Number(number & 0xffn))
+    number >>= 8n
+  }
+  return Uint8Array.from(bytes)
+}
+
+// A binary-safe Base36 codec. Every leading zero byte is represented by a
+// leading zero character, making arbitrary byte arrays round-trip exactly.
+export function bytesToBase36 (bytes) {
+  if (bytes.length === 0) return ''
+
+  const number = bytesToInteger(bytes)
+  let result = number === 0n ? '' : integerToBase36(number)
+  let leadingZeros = 0
+  while (leadingZeros < bytes.length && bytes[leadingZeros] === 0) leadingZeros++
+  result = LEADER.repeat(leadingZeros) + result
+  return result
+}
+
+export function base36ToBytes (value) {
+  if (typeof value !== 'string') throw new TypeError('Base36 value should be a string')
+  if (value.length === 0) return new Uint8Array()
+
+  let leadingZeros = 0
+  while (value[leadingZeros] === LEADER) leadingZeros++
+  const number = parseBase36Integer(value)
+  const suffix = number === 0n ? new Uint8Array() : integerToMinimalBytes(number)
+  const result = new Uint8Array(leadingZeros + suffix.length)
+  result.set(suffix, leadingZeros)
+  return result
+}
+
+export function base16ToBase36 (value) {
+  return bytesToBase36(base16ToBytes(value))
+}
+
+export function base36ToBase16 (value) {
+  return bytesToBase16(base36ToBytes(value))
+}
+
+// NIP-5A treats a raw 32-byte value as one unsigned integer and represents it
+// as exactly 50 lowercase Base36 digits. Its leading zeros are numeric width,
+// not zero-byte markers as they are in the binary-safe codec above.
+export function bytesToNsiteBase36 (bytes) {
+  if (bytes.length !== NSITE_BYTE_LENGTH) {
+    throw new Error('Nsite Base36 input should be ' + NSITE_BYTE_LENGTH + ' bytes')
+  }
+  return integerToBase36(bytesToInteger(bytes)).padStart(NSITE_TEXT_LENGTH, LEADER)
+}
+
+export function nsiteBase36ToBytes (value) {
+  if (typeof value !== 'string') throw new TypeError('Nsite Base36 value should be a string')
+  if (value.length !== NSITE_TEXT_LENGTH) {
+    throw new Error('Nsite Base36 value should be ' + NSITE_TEXT_LENGTH + ' characters')
+  }
+  if (!/^[0-9a-z]+$/.test(value)) throw new Error('Invalid Nsite Base36 character')
+
+  const number = parseBase36Integer(value)
+  if (number > MAX_NSITE_VALUE) throw new Error('Nsite Base36 value exceeds 32 bytes')
+  const bytes = integerToMinimalBytes(number)
+  const result = new Uint8Array(NSITE_BYTE_LENGTH)
+  if (number !== 0n) result.set(bytes, NSITE_BYTE_LENGTH - bytes.length)
+  return result
+}
+
+export function base16ToNsiteBase36 (value) {
+  return bytesToNsiteBase36(base16ToBytes(value))
+}
+
+export function nsiteBase36ToBase16 (value) {
+  return bytesToBase16(nsiteBase36ToBytes(value))
+}

package/base62/index.js

@@ -0,0 +1,127 @@
+import { base16ToBytes, bytesToBase16 } from '../base16/index.js'
+
+export const BASE62_ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+
+const BASE = BigInt(BASE62_ALPHABET.length)
+const LEADER = BASE62_ALPHABET[0]
+const CHAR_MAP = new Map(
+  [...BASE62_ALPHABET].map((character, index) => [character, BigInt(index)])
+)
+
+function readOptions (options, allowedKeys) {
+  if (options === undefined) return {}
+  if (!options || typeof options !== 'object' || Array.isArray(options)) {
+    throw new TypeError('Base62 options should be an object')
+  }
+  for (const key of Object.keys(options)) {
+    if (!allowedKeys.includes(key)) throw new Error('Unknown Base62 option: ' + key)
+  }
+  return options
+}
+
+function readMode (mode = 'bytes') {
+  if (mode !== 'bytes' && mode !== 'integer') throw new Error('Invalid Base62 mode: ' + mode)
+  return mode
+}
+
+function readLength (value, name, defaultValue, minimum = 0) {
+  if (value === undefined) return defaultValue
+  if (!Number.isSafeInteger(value) || value < minimum) {
+    const qualifier = minimum === 0 ? 'non-negative' : 'positive'
+    throw new RangeError('Base62 ' + name + ' should be a ' + qualifier + ' safe integer')
+  }
+  return value
+}
+
+function bytesToInteger (bytes) {
+  let number = 0n
+  for (const byte of bytes) number = (number << 8n) + BigInt(byte)
+  return number
+}
+
+function integerToBase62 (number) {
+  let result = ''
+  while (number > 0n) {
+    result = BASE62_ALPHABET[Number(number % BASE)] + result
+    number /= BASE
+  }
+  return result || LEADER
+}
+
+function parseBase62Integer (value) {
+  let number = 0n
+  for (const character of value) {
+    const digit = CHAR_MAP.get(character)
+    if (digit === undefined) throw new Error('Invalid Base62 character: ' + character)
+    number = number * BASE + digit
+  }
+  return number
+}
+
+function integerToMinimalBytes (number) {
+  if (number === 0n) return new Uint8Array([0])
+  const bytes = []
+  while (number > 0n) {
+    bytes.unshift(Number(number & 0xffn))
+    number >>= 8n
+  }
+  return Uint8Array.from(bytes)
+}
+
+// Byte mode preserves every leading zero byte. Integer mode treats the input
+// as an unsigned big-endian value and supports fixed-width textual output.
+export function bytesToBase62 (bytes, options) {
+  const { mode: rawMode, minLength: rawMinLength } = readOptions(options, ['mode', 'minLength'])
+  const mode = readMode(rawMode)
+  if (mode === 'bytes' && rawMinLength !== undefined) {
+    throw new Error('Base62 minLength requires integer mode')
+  }
+  if (mode === 'integer') {
+    if (bytes.length === 0) throw new Error('Base62 integer input should not be empty')
+    const minLength = readLength(rawMinLength, 'minLength', 0)
+    return integerToBase62(bytesToInteger(bytes)).padStart(minLength, LEADER)
+  }
+  if (bytes.length === 0) return ''
+
+  const number = bytesToInteger(bytes)
+  let result = number === 0n ? '' : integerToBase62(number)
+  let leadingZeros = 0
+  while (leadingZeros < bytes.length && bytes[leadingZeros] === 0) leadingZeros++
+  result = LEADER.repeat(leadingZeros) + result
+  return result
+}
+
+export function base62ToBytes (value, options) {
+  if (typeof value !== 'string') throw new TypeError('Base62 value should be a string')
+  const { mode: rawMode, byteLength: rawByteLength } = readOptions(options, ['mode', 'byteLength'])
+  const mode = readMode(rawMode)
+  if (mode === 'bytes' && rawByteLength !== undefined) {
+    throw new Error('Base62 byteLength requires integer mode')
+  }
+  if (mode === 'integer') {
+    if (value.length === 0) throw new Error('Base62 integer value should not be empty')
+    const byteLength = readLength(rawByteLength, 'byteLength', undefined, 1)
+    const bytes = integerToMinimalBytes(parseBase62Integer(value))
+    if (byteLength === undefined) return bytes
+    if (bytes.length > byteLength) throw new Error('Base62 integer exceeds ' + byteLength + ' bytes')
+    const result = new Uint8Array(byteLength)
+    result.set(bytes, byteLength - bytes.length)
+    return result
+  }
+
+  let leadingZeros = 0
+  while (value[leadingZeros] === LEADER) leadingZeros++
+  const number = parseBase62Integer(value)
+  const suffix = number === 0n ? new Uint8Array() : integerToMinimalBytes(number)
+  const result = new Uint8Array(leadingZeros + suffix.length)
+  result.set(suffix, leadingZeros)
+  return result
+}
+
+export function base16ToBase62 (value, options) {
+  return bytesToBase62(base16ToBytes(value), options)
+}
+
+export function base62ToBase16 (value, options) {
+  return bytesToBase16(base62ToBytes(value, options))
+}

package/base64/index.js

@@ -3,6 +3,9 @@
 // base64 is useful for WebAuthn credential IDs and URL/query-string material.
 
 export function bytesToBase64 (bytes) {
+  if (typeof Buffer === 'function' && typeof Buffer.from === 'function') {
+    return Buffer.from(bytes).toString('base64')
+  }
   let s = ''
   for (let i = 0; i < bytes.length; i++) s += String.fromCharCode(bytes[i])
   return btoa(s)

package/i18n/index.js

@@ -0,0 +1,235 @@
+const DEFAULT_LOCALE = 'en'
+const INTERPOLATION_RE = /{{\s*([A-Za-z0-9_.-]+)\s*}}/g
+
+function assertLocales (locales) {
+  if (!locales || typeof locales !== 'object' || Array.isArray(locales)) {
+    throw new TypeError('locales should be an object')
+  }
+}
+
+function placeholderSignature (value) {
+  return [...String(value).matchAll(INTERPOLATION_RE)]
+    .map(match => match[1])
+    .sort()
+    .join(',')
+}
+
+function validateTranslationValue (key, locale, value, expectedPlaceholders) {
+  if (typeof value === 'string') {
+    if (placeholderSignature(value) !== expectedPlaceholders) {
+      throw new Error(`placeholder mismatch for "${key}" (${locale})`)
+    }
+    return
+  }
+
+  if (!value || typeof value !== 'object' || Array.isArray(value) || typeof value.other !== 'string') {
+    throw new TypeError(`translation for "${key}" (${locale}) should be a string or plural object with an other form`)
+  }
+
+  for (const form of Object.values(value)) {
+    if (typeof form !== 'string') {
+      throw new TypeError(`plural forms for "${key}" (${locale}) should be strings`)
+    }
+    if (placeholderSignature(form) !== expectedPlaceholders) {
+      throw new Error(`placeholder mismatch for "${key}" (${locale})`)
+    }
+  }
+}
+
+export function validateLocales (locales, options = {}) {
+  assertLocales(locales)
+  if (!options || typeof options !== 'object' || Array.isArray(options)) {
+    throw new TypeError('validation options should be an object')
+  }
+  const {
+    requiredLocales = [],
+    referenceLocale = DEFAULT_LOCALE,
+    requireReferenceKey = false
+  } = options
+  if (!Array.isArray(requiredLocales) || requiredLocales.some(locale => typeof locale !== 'string' || !locale)) {
+    throw new TypeError('requiredLocales should be an array of non-empty strings')
+  }
+  if (typeof referenceLocale !== 'string' || !referenceLocale) {
+    throw new TypeError('referenceLocale should be a non-empty string')
+  }
+
+  for (const [key, translations] of Object.entries(locales)) {
+    if (!translations || typeof translations !== 'object' || Array.isArray(translations)) {
+      throw new TypeError(`translations for "${key}" should be an object`)
+    }
+
+    for (const locale of requiredLocales) {
+      if (!Object.prototype.hasOwnProperty.call(translations, locale)) {
+        throw new Error(`missing translation for "${key}" (${locale})`)
+      }
+    }
+
+    const expectedPlaceholders = placeholderSignature(key)
+    for (const [locale, value] of Object.entries(translations)) {
+      validateTranslationValue(key, locale, value, expectedPlaceholders)
+    }
+
+    if (requireReferenceKey) {
+      if (!Object.prototype.hasOwnProperty.call(translations, referenceLocale)) {
+        throw new Error(`missing reference translation for "${key}" (${referenceLocale})`)
+      }
+      const reference = translations[referenceLocale]
+      const referenceValue = typeof reference === 'string' ? reference : reference.other
+      if (referenceValue !== key) {
+        throw new Error(`reference translation should match key "${key}" (${referenceLocale})`)
+      }
+    }
+  }
+
+  return locales
+}
+
+function canonicalizeLocale (locale) {
+  if (typeof locale !== 'string' || !locale.trim()) return null
+  const value = locale.trim().replace(/_/g, '-')
+  try {
+    return Intl.getCanonicalLocales(value)[0] ?? null
+  } catch {
+    return null
+  }
+}
+
+function getIntlLocale () {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().locale
+  } catch {
+    return null
+  }
+}
+
+function getNavigator () {
+  try {
+    return globalThis.navigator
+  } catch {
+    return null
+  }
+}
+
+export function getCurrentDeviceLocale () {
+  const navigator = getNavigator()
+  const candidates = [
+    getIntlLocale(),
+    navigator?.language,
+    navigator?.languages?.[0],
+    DEFAULT_LOCALE
+  ]
+
+  for (const candidate of candidates) {
+    const locale = canonicalizeLocale(candidate)
+    if (locale) return locale
+  }
+  return DEFAULT_LOCALE
+}
+
+function localeLanguage (locale) {
+  try {
+    return new Intl.Locale(locale).language
+  } catch {
+    return locale.split('-')[0].toLowerCase()
+  }
+}
+
+function preferredChineseLocale (locale) {
+  if (localeLanguage(locale) !== 'zh') return null
+  try {
+    const { script, region } = new Intl.Locale(locale)
+    if (script === 'Hant' || ['TW', 'HK', 'MO'].includes(region)) return 'zh-TW'
+    return 'zh-CN'
+  } catch {
+    return /(?:^|-)(?:hant|tw|hk|mo)(?:-|$)/i.test(locale) ? 'zh-TW' : 'zh-CN'
+  }
+}
+
+function localeCandidates (translations, requestedLocale, fallbackLocale) {
+  const keys = Object.keys(translations)
+  const canonicalKeys = new Map()
+  for (const key of keys) {
+    const canonical = canonicalizeLocale(key)
+    if (canonical && !canonicalKeys.has(canonical.toLowerCase())) {
+      canonicalKeys.set(canonical.toLowerCase(), { key, canonical })
+    }
+  }
+
+  const result = []
+  const seen = new Set()
+  const add = locale => {
+    const canonical = canonicalizeLocale(locale)
+    const match = canonical && canonicalKeys.get(canonical.toLowerCase())
+    if (match && !seen.has(match.key)) {
+      seen.add(match.key)
+      result.push(match)
+    }
+  }
+  const addCompatible = locale => {
+    const canonical = canonicalizeLocale(locale)
+    if (!canonical) return
+    add(canonical)
+    add(preferredChineseLocale(canonical))
+    const language = localeLanguage(canonical)
+    const match = [...canonicalKeys.values()].find(candidate => localeLanguage(candidate.canonical) === language)
+    if (match) add(match.canonical)
+  }
+
+  addCompatible(requestedLocale)
+  addCompatible(fallbackLocale)
+  addCompatible(DEFAULT_LOCALE)
+  return result
+}
+
+function selectPlural (forms, locale, values) {
+  if (!forms || typeof forms !== 'object' || Array.isArray(forms)) return null
+  const count = Number(values?.count)
+  if (!Number.isFinite(count)) return null
+
+  let category = 'other'
+  try {
+    category = new Intl.PluralRules(locale).select(count)
+  } catch {}
+  const value = forms[category] ?? forms.other
+  return typeof value === 'string' ? value : null
+}
+
+function selectTemplate (translations, requestedLocale, fallbackLocale, values) {
+  if (!translations || typeof translations !== 'object' || Array.isArray(translations)) return null
+  for (const { key, canonical } of localeCandidates(translations, requestedLocale, fallbackLocale)) {
+    const value = translations[key]
+    if (typeof value === 'string') return value
+    const plural = selectPlural(value, canonical, values)
+    if (plural !== null) return plural
+  }
+  return null
+}
+
+function interpolate (template, values) {
+  const source = String(template)
+  if (!values || typeof values !== 'object') return source
+  return source.replace(INTERPOLATION_RE, (token, name) => (
+    Object.prototype.hasOwnProperty.call(values, name)
+      ? String(values[name])
+      : token
+  ))
+}
+
+export function getT (locales, {
+  locale = getCurrentDeviceLocale(),
+  fallbackLocale = DEFAULT_LOCALE,
+  validation
+} = {}) {
+  assertLocales(locales)
+  if (validation !== undefined) validateLocales(locales, validation)
+
+  const requestedLocale = canonicalizeLocale(locale) ?? DEFAULT_LOCALE
+  const canonicalFallback = canonicalizeLocale(fallbackLocale) ?? DEFAULT_LOCALE
+
+  return function t (key, values) {
+    if (typeof key !== 'string') throw new TypeError('translation key should be a string')
+    const translations = Object.prototype.hasOwnProperty.call(locales, key) ? locales[key] : null
+    const template = selectTemplate(translations, requestedLocale, canonicalFallback, values) ?? key
+    return interpolate(template, values)
+  }
+}

package/index.js

@@ -1,6 +1,8 @@
 export * from './private-messenger/index.js'
 
 export * as base16 from './base16/index.js'
+export * as base36 from './base36/index.js'
+export * as base62 from './base62/index.js'
 export * as base64 from './base64/index.js'
 export * as contentKey from './content-key/index.js'
 export * as contentKeyEvent from './content-key/event/index.js'
@@ -8,6 +10,7 @@ export * as doubleDh from './double-dh/index.js'
 export * as ecdh from './ecdh/index.js'
 export * as idb from './idb/index.js'
 export * as idbQueue from './idb-queue/index.js'
+export * as i18n from './i18n/index.js'
 export * as key from './key/index.js'
 export * as network from './network/index.js'
 export * as nip19 from './nip19/index.js'

package/nip19/index.js

@@ -1,15 +1,9 @@
 import { bech32 } from '@scure/base'
+import { BASE62_ALPHABET, base62ToBytes, bytesToBase62 } from '../base62/index.js'
 
 const MAX_ENTITY_SIZE = 5000
 const MAX_TLV_VALUE_SIZE = 255
 const NOSTR_APP_D_TAG_MAX_LENGTH = 260
-const BASE62_ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
-const BASE62_BASE = BigInt(BASE62_ALPHABET.length)
-const BASE62_LEADER = BASE62_ALPHABET[0]
-const BASE62_CHAR_MAP = new Map(
-  [...BASE62_ALPHABET].map((character, index) => [character, BigInt(index)])
-)
-
 export const NAPP_ENTITY_REGEX = new RegExp(
   `^\\+{1,3}[${BASE62_ALPHABET}]{48,${MAX_ENTITY_SIZE}}$`
 )
@@ -178,45 +172,6 @@ export function nfileDecode (entity) {
   return result
 }
 
-function bytesToBase62 (bytes) {
-  if (bytes.length === 0) return ''
-  let number = 0n
-  for (const byte of bytes) number = (number << 8n) + BigInt(byte)
-
-  let result = ''
-  if (number === 0n) return BASE62_LEADER
-  while (number > 0n) {
-    result = BASE62_ALPHABET[Number(number % BASE62_BASE)] + result
-    number /= BASE62_BASE
-  }
-  for (const byte of bytes) {
-    if (byte !== 0) break
-    result = BASE62_LEADER + result
-  }
-  return result
-}
-
-function base62ToBytes (value) {
-  if (typeof value !== 'string') throw new TypeError('Base62 value should be a string')
-  let leadingZeros = 0
-  while (value[leadingZeros] === BASE62_LEADER) leadingZeros++
-
-  let number = 0n
-  for (const character of value) {
-    const digit = BASE62_CHAR_MAP.get(character)
-    if (digit === undefined) throw new Error(`Invalid Base62 character: ${character}`)
-    number = number * BASE62_BASE + digit
-  }
-  const suffix = []
-  while (number > 0n) {
-    suffix.unshift(Number(number & 0xffn))
-    number >>= 8n
-  }
-  const result = new Uint8Array(leadingZeros + suffix.length)
-  result.set(suffix, leadingZeros)
-  return result
-}
-
 function isNostrAppDTagSafe (value) {
   return typeof value === 'string' && value.length <= NOSTR_APP_D_TAG_MAX_LENGTH
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2r2p",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Peer-to-relay-to-peer",
   "keywords": [
     "p2r2p",
@@ -13,6 +13,8 @@
   "sideEffects": false,
   "files": [
     "base16",
+    "base36",
+    "base62",
     "base64",
     "base93",
     "content-key",
@@ -20,6 +22,7 @@
     "ecdh",
     "idb",
     "idb-queue",
+    "i18n",
     "index.js",
     "key",
     "network",
@@ -40,6 +43,8 @@
   "exports": {
     ".": "./index.js",
     "./base16": "./base16/index.js",
+    "./base36": "./base36/index.js",
+    "./base62": "./base62/index.js",
     "./base64": "./base64/index.js",
     "./base93": "./base93/index.js",
     "./content-key": "./content-key/index.js",
@@ -48,6 +53,7 @@
     "./ecdh": "./ecdh/index.js",
     "./idb": "./idb/index.js",
     "./idb-queue": "./idb-queue/index.js",
+    "./i18n": "./i18n/index.js",
     "./key": "./key/index.js",
     "./network": "./network/index.js",
     "./nip19": "./nip19/index.js",