@airgap/coinlib-core 0.13.11-beta.1 → 0.13.11-beta.3

package/dependencies/src/idna-uts46-hx-3.4.0/index.d.ts

@@ -0,0 +1,6 @@
+export function toUnicode(domain: string, options?: { useStd3ASCII: boolean }): string
+export function toAscii(domain: string, options?: { transitional: boolean; useStd3ASCII: boolean; verifyDnsLength: boolean }): string
+
+export function convert(domains: string): { IDN: string; PC: string }
+export function convert(domains: string[]): { IDN: string[]; PC: string[] }
+export function convert(domains: string | string[]): { IDN: string | string[]; PC: string | string[] }

package/dependencies/src/idna-uts46-hx-3.4.0/uts46.js

@@ -0,0 +1,170 @@
+;(function (root, factory) {
+  /* istanbul ignore next */
+  // eslint-disable-next-line no-undef
+  if (typeof define === 'function' && define.amd) {
+    // eslint-disable-next-line no-undef
+    define(['punycode', './idna-map'], function (punycode, idnaMap) {
+      return factory(punycode, idnaMap)
+    })
+  } else if (typeof exports === 'object') {
+    // eslint-disable-next-line node/no-deprecated-api
+    module.exports = factory(require('../punycode-2.1.1/punycode'), require('./idna-map'))
+  } else {
+    root.uts46 = factory(root.punycode, root.idna_map)
+  }
+})(this, function (punycode, idnaMap) {
+  function mapLabel(label, useStd3ASCII, transitional) {
+    const mapped = []
+    const chars = punycode.ucs2.decode(label)
+    for (let i = 0; i < chars.length; i++) {
+      const cp = chars[i]
+      const ch = punycode.ucs2.encode([chars[i]])
+      const composite = idnaMap.mapChar(cp)
+      const flags = composite >> 23
+      const kind = (composite >> 21) & 3
+      const index = (composite >> 5) & 0xffff
+      const length = composite & 0x1f
+      const value = idnaMap.mapStr.substr(index, length)
+      if (kind === 0 || (useStd3ASCII && flags & 1)) {
+        throw new Error('Illegal char ' + ch)
+      } else if (kind === 1) {
+        mapped.push(value)
+      } else if (kind === 2) {
+        mapped.push(transitional ? value : ch)
+        /* istanbul ignore next */
+      } else if (kind === 3) {
+        mapped.push(ch)
+      }
+    }
+
+    const newLabel = mapped.join('').normalize('NFC')
+    return newLabel
+  }
+
+  function process(domain, transitional, useStd3ASCII) {
+    /* istanbul ignore if */
+    if (useStd3ASCII === undefined) {
+      useStd3ASCII = false
+    }
+    const mappedIDNA = mapLabel(domain, useStd3ASCII, transitional)
+
+    // Step 3. Break
+    let labels = mappedIDNA.split('.')
+
+    // Step 4. Convert/Validate
+    labels = labels.map(function (label) {
+      if (label.startsWith('xn--')) {
+        label = punycode.decode(label.substring(4))
+        validateLabel(label, useStd3ASCII, false)
+      } else {
+        validateLabel(label, useStd3ASCII, transitional)
+      }
+      return label
+    })
+
+    return labels.join('.')
+  }
+
+  function validateLabel(label, useStd3ASCII, transitional) {
+    // 2. The label must not contain a U+002D HYPHEN-MINUS character in both the
+    // third position and fourth positions.
+    if (label[2] === '-' && label[3] === '-') {
+      throw new Error('Failed to validate ' + label)
+    }
+
+    // 3. The label must neither begin nor end with a U+002D HYPHEN-MINUS
+    // character.
+    if (label.startsWith('-') || label.endsWith('-')) {
+      throw new Error('Failed to validate ' + label)
+    }
+
+    // 4. The label must not contain a U+002E ( . ) FULL STOP.
+    // this should nerver happen as label is chunked internally by this character
+    /* istanbul ignore if */
+    if (label.includes('.')) {
+      throw new Error('Failed to validate ' + label)
+    }
+
+    if (mapLabel(label, useStd3ASCII, transitional) !== label) {
+      throw new Error('Failed to validate ' + label)
+    }
+
+    // 5. The label must not begin with a combining mark, that is:
+    // General_Category=Mark.
+    const ch = label.codePointAt(0)
+    if (idnaMap.mapChar(ch) & (0x2 << 23)) {
+      throw new Error('Label contains illegal character: ' + ch)
+    }
+  }
+
+  function toAscii(domain, options) {
+    if (options === undefined) {
+      options = {}
+    }
+    const transitional = 'transitional' in options ? options.transitional : true
+    const useStd3ASCII = 'useStd3ASCII' in options ? options.useStd3ASCII : false
+    const verifyDnsLength = 'verifyDnsLength' in options ? options.verifyDnsLength : false
+    const labels = process(domain, transitional, useStd3ASCII).split('.')
+    const asciiLabels = labels.map(punycode.toASCII)
+    const asciiString = asciiLabels.join('.')
+    let i
+    if (verifyDnsLength) {
+      if (asciiString.length < 1 || asciiString.length > 253) {
+        throw new Error('DNS name has wrong length: ' + asciiString)
+      }
+      for (i = 0; i < asciiLabels.length; i++) {
+        // for .. of replacement
+        const label = asciiLabels[i]
+        if (label.length < 1 || label.length > 63) {
+          throw new Error('DNS label has wrong length: ' + label)
+        }
+      }
+    }
+    return asciiString
+  }
+
+  function convert(domains) {
+    const isArrayInput = Array.isArray(domains)
+    if (!isArrayInput) {
+      domains = [domains]
+    }
+    const results = { IDN: [], PC: [] }
+    domains.forEach((domain) => {
+      let pc, tmp
+      try {
+        pc = toAscii(domain, {
+          transitional: !domain.match(/\.(?:be|ca|de|fr|pm|re|swiss|tf|wf|yt)\.?$/)
+        })
+        tmp = {
+          PC: pc,
+          IDN: toUnicode(pc)
+        }
+      } catch (e) {
+        tmp = {
+          PC: domain,
+          IDN: domain
+        }
+      }
+      results.PC.push(tmp.PC)
+      results.IDN.push(tmp.IDN)
+    })
+    if (isArrayInput) {
+      return results
+    }
+    return { IDN: results.IDN[0], PC: results.PC[0] }
+  }
+
+  function toUnicode(domain, options) {
+    if (options === undefined) {
+      options = {}
+    }
+    const useStd3ASCII = 'useStd3ASCII' in options ? options.useStd3ASCII : false
+    return process(domain, false, useStd3ASCII)
+  }
+
+  return {
+    toUnicode: toUnicode,
+    toAscii: toAscii,
+    convert: convert
+  }
+})

package/dependencies/src/ieee754-1.1.13/index.js

@@ -0,0 +1,84 @@
+exports.read = function (buffer, offset, isLE, mLen, nBytes) {
+  var e, m
+  var eLen = (nBytes * 8) - mLen - 1
+  var eMax = (1 << eLen) - 1
+  var eBias = eMax >> 1
+  var nBits = -7
+  var i = isLE ? (nBytes - 1) : 0
+  var d = isLE ? -1 : 1
+  var s = buffer[offset + i]
+
+  i += d
+
+  e = s & ((1 << (-nBits)) - 1)
+  s >>= (-nBits)
+  nBits += eLen
+  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}
+
+  m = e & ((1 << (-nBits)) - 1)
+  e >>= (-nBits)
+  nBits += mLen
+  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}
+
+  if (e === 0) {
+    e = 1 - eBias
+  } else if (e === eMax) {
+    return m ? NaN : ((s ? -1 : 1) * Infinity)
+  } else {
+    m = m + Math.pow(2, mLen)
+    e = e - eBias
+  }
+  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
+}
+
+exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
+  var e, m, c
+  var eLen = (nBytes * 8) - mLen - 1
+  var eMax = (1 << eLen) - 1
+  var eBias = eMax >> 1
+  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
+  var i = isLE ? 0 : (nBytes - 1)
+  var d = isLE ? 1 : -1
+  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
+
+  value = Math.abs(value)
+
+  if (isNaN(value) || value === Infinity) {
+    m = isNaN(value) ? 1 : 0
+    e = eMax
+  } else {
+    e = Math.floor(Math.log(value) / Math.LN2)
+    if (value * (c = Math.pow(2, -e)) < 1) {
+      e--
+      c *= 2
+    }
+    if (e + eBias >= 1) {
+      value += rt / c
+    } else {
+      value += rt * Math.pow(2, 1 - eBias)
+    }
+    if (value * c >= 2) {
+      e++
+      c /= 2
+    }
+
+    if (e + eBias >= eMax) {
+      m = 0
+      e = eMax
+    } else if (e + eBias >= 1) {
+      m = ((value * c) - 1) * Math.pow(2, mLen)
+      e = e + eBias
+    } else {
+      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
+      e = 0
+    }
+  }
+
+  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
+
+  e = (e << mLen) | m
+  eLen += mLen
+  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
+
+  buffer[offset + i - d] |= s * 128
+}

package/dependencies/src/inherits-2.0.4/inherits.js

@@ -0,0 +1,9 @@
+try {
+  var util = require('util');
+  /* istanbul ignore next */
+  if (typeof util.inherits !== 'function') throw '';
+  module.exports = util.inherits;
+} catch (e) {
+  /* istanbul ignore next */
+  module.exports = require('./inherits_browser.js');
+}

package/dependencies/src/inherits-2.0.4/inherits_browser.js

@@ -0,0 +1,27 @@
+if (typeof Object.create === 'function') {
+  // implementation from standard node.js 'util' module
+  module.exports = function inherits(ctor, superCtor) {
+    if (superCtor) {
+      ctor.super_ = superCtor
+      ctor.prototype = Object.create(superCtor.prototype, {
+        constructor: {
+          value: ctor,
+          enumerable: false,
+          writable: true,
+          configurable: true
+        }
+      })
+    }
+  };
+} else {
+  // old school shim for old browsers
+  module.exports = function inherits(ctor, superCtor) {
+    if (superCtor) {
+      ctor.super_ = superCtor
+      var TempCtor = function () {}
+      TempCtor.prototype = superCtor.prototype
+      ctor.prototype = new TempCtor()
+      ctor.prototype.constructor = ctor
+    }
+  }
+}

package/dependencies/src/is-buffer-2.0.3/index.js

@@ -0,0 +1,11 @@
+/*!
+ * Determine if an object is a Buffer
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+
+module.exports = function isBuffer (obj) {
+  return obj != null && obj.constructor != null &&
+    typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
+}

package/dependencies/src/is-hex-prefixed-1.0.0/src/index.js

@@ -0,0 +1,13 @@
+/**
+ * Returns a `Boolean` on whether or not the a `String` starts with '0x'
+ * @param {String} str the string input value
+ * @return {Boolean} a boolean if it is or is not hex prefixed
+ * @throws if the str input is not a string
+ */
+module.exports = function isHexPrefixed(str) {
+  if (typeof str !== 'string') {
+    throw new Error("[is-hex-prefixed] value must be type 'string', is currently type " + (typeof str) + ", while checking isHexPrefixed.");
+  }
+
+  return str.slice(0, 2) === '0x';
+}

package/dependencies/src/js-cuint-0.2.2/index.js

@@ -0,0 +1,2 @@
+exports.UINT32 = require('./lib/uint32')
+exports.UINT64 = require('./lib/uint64')