@syzlm/ofdparser 0.0.1

package/src/lib/asn1/Stream.ts

@@ -0,0 +1,314 @@
+import Int10 from './int10';
+import oids from './oids';
+import stringCut from './string-cut';
+
+const b64Safe =
+  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+
+const reTimeS =
+  /^(\d\d)(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])([01]\d|2[0-3])(?:([0-5]\d)(?:([0-5]\d)(?:[.,](\d{1,3}))?)?)?(Z|[-+](?:[0]\d|1[0-2])([0-5]\d)?)?$/;
+const reTimeL =
+  /^(\d\d\d\d)(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])([01]\d|2[0-3])(?:([0-5]\d)(?:([0-5]\d)(?:[.,](\d{1,3}))?)?)?(Z|[-+](?:[0]\d|1[0-2])([0-5]\d)?)?$/;
+const ellipsis = '\u2026';
+function ex(c: number) {
+  // must be 10xxxxxx
+  if (c < 0x80 || c >= 0xc0)
+    throw new Error('Invalid UTF-8 continuation byte: ' + c);
+
+  return c & 0x3f;
+}
+
+function surrogate(cp: number) {
+  if (cp < 0x10000)
+    throw new Error(
+      'UTF-8 overlong encoding, codepoint encoded in 4 bytes: ' + cp
+    );
+  // we could use String.fromCodePoint(cp) but let's be nice to older browsers and use surrogate pairs
+
+  cp -= 0x10000;
+
+  return String.fromCharCode((cp >> 10) + 0xd800, (cp & 0x3ff) + 0xdc00);
+}
+
+class Stream {
+  enc: string | Uint8Array;
+  pos: number;
+  static hexDigits: '0123456789ABCDEF';
+  constructor(streams: Stream | string, pos?: number) {
+    if (streams instanceof Stream) {
+      this.enc = streams.enc;
+      this.pos = streams.pos;
+    } else {
+      // enc should be an array or a binary string
+      this.enc = streams;
+      this.pos = pos as number;
+    }
+  }
+
+  hexDigits = '0123456789ABCDEF';
+
+  get(pos?: number): number {
+    let cPos = pos;
+    if (cPos === undefined) {
+      cPos = this.pos++;
+    }
+    if (!this.enc || !this.enc.length) {
+      return 0;
+    }
+    if (this.enc && cPos >= this.enc.length)
+      throw (
+        'Requesting byte offset ' +
+        pos +
+        ' on a stream of length ' +
+        this.enc.length
+      );
+    return typeof this.enc == 'string'
+      ? this.enc.charCodeAt(cPos)
+      : this.enc[cPos];
+  }
+  hexByte(b: number): string {
+    return (
+      this.hexDigits.charAt((b >> 4) & 0xf) + this.hexDigits.charAt(b & 0xf)
+    );
+  }
+  hexDump(start: number, end: number, raw?: boolean) {
+    let s = '';
+    for (let i = start; i < end; ++i) {
+      s += this.hexByte(this.get(i));
+      if (raw !== true)
+        switch (i & 0xf) {
+          case 0x7:
+            s += '  ';
+            break;
+          case 0xf:
+            s += '\n';
+            break;
+          default:
+            s += ' ';
+        }
+    }
+    return s;
+  }
+  b64Dump(start: number, end: number) {
+    const extra = (end - start) % 3;
+    let s = '';
+    let i;
+    let c;
+    for (i = start; i + 2 < end; i += 3) {
+      c = (this.get(i) << 16) | (this.get(i + 1) << 8) | this.get(i + 2);
+      s += b64Safe.charAt((c >> 18) & 0x3f);
+      s += b64Safe.charAt((c >> 12) & 0x3f);
+      s += b64Safe.charAt((c >> 6) & 0x3f);
+      s += b64Safe.charAt(c & 0x3f);
+    }
+    if (extra > 0) {
+      c = this.get(i) << 16;
+      if (extra > 1) c |= this.get(i + 1) << 8;
+      s += b64Safe.charAt((c >> 18) & 0x3f);
+      s += b64Safe.charAt((c >> 12) & 0x3f);
+      if (extra === 2) s += b64Safe.charAt((c >> 6) & 0x3f);
+    }
+    return s;
+  }
+  isASCII(start: number, end: number) {
+    for (let i = start; i < end; ++i) {
+      var c = this.get(i);
+      if (c < 32 || c > 176) return false;
+    }
+    return true;
+  }
+
+  parseStringISO(start: number, end: number) {
+    let s = '';
+    for (let i = start; i < end; ++i) {
+      s += String.fromCharCode(this.get(i));
+    }
+    return s;
+  }
+  parseStringUTF(start: number, end: number) {
+    let s = '';
+    for (let i = start; i < end; ) {
+      const c = this.get(i++);
+      if (c < 0x80)
+        // 0xxxxxxx (7 bit)
+        s += String.fromCharCode(c);
+      else if (c < 0xc0) throw new Error('Invalid UTF-8 starting byte: ' + c);
+      else if (c < 0xe0)
+        // 110xxxxx 10xxxxxx (11 bit)
+        s += String.fromCharCode(((c & 0x1f) << 6) | ex(this.get(i++)));
+      else if (c < 0xf0)
+        // 1110xxxx 10xxxxxx 10xxxxxx (16 bit)
+        s += String.fromCharCode(
+          ((c & 0x0f) << 12) | (ex(this.get(i++)) << 6) | ex(this.get(i++))
+        );
+      else if (c < 0xf8)
+        // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx (21 bit)
+        s += surrogate(
+          ((c & 0x07) << 18) |
+            (ex(this.get(i++)) << 12) |
+            (ex(this.get(i++)) << 6) |
+            ex(this.get(i++))
+        );
+      else
+        throw new Error(
+          'Invalid UTF-8 starting byte (since 2003 it is restricted to 4 bytes): ' +
+            c
+        );
+    }
+    return s;
+  }
+  parseStringBMP(start: number, end: number): string {
+    let str = '';
+    let hi;
+    let lo;
+    for (let i = start; i < end; ) {
+      hi = this.get(i++);
+      lo = this.get(i++);
+      str += String.fromCharCode((hi << 8) | lo);
+    }
+    return str;
+  }
+  parseTime(start: number, end: number, shortYear: boolean) {
+    let s = this.parseStringISO(start, end);
+    const t = (shortYear ? reTimeS : reTimeL).exec(s);
+    if (!t) return 'Unrecognized time: ' + s;
+    const m: (number | string)[] = t;
+    if (shortYear) {
+      // to avoid querying the timer, use the fixed range [1970, 2069]
+      // it will conform with ITU X.400 [-10, +40] sliding window until 2030
+
+      m[1] = +Number(m[1]);
+      m[1] += Number(m[1]) < 70 ? 2000 : 1900;
+    }
+    s = m[1] + '-' + m[2] + '-' + m[3] + ' ' + m[4];
+    if (m[5]) {
+      s += ':' + m[5];
+      if (m[6]) {
+        s += ':' + m[6];
+        if (m[7]) s += '.' + m[7];
+      }
+    }
+    if (m[8]) {
+      s += ' UTC';
+      if (m[8] != 'Z') {
+        s += m[8];
+        if (m[9]) s += ':' + m[9];
+      }
+    }
+    return s;
+  }
+  parseInteger(start: number, end: number) {
+    let v = this.get(start),
+      neg = v > 127,
+      pad = neg ? 255 : 0,
+      len,
+      s = null;
+    // skip unuseful bits (not allowed in DER)
+    while (v === pad && ++start < end) {
+      v = this.get(start);
+    }
+    len = end - start;
+    if (len === 0) return neg ? '-1' : '0';
+    // show bit length of huge integers
+    if (len > 4) {
+      s = v;
+      len <<= 3;
+      while (((s ^ pad) & 0x80) === 0) {
+        s <<= 1;
+        --len;
+      }
+      s = '(' + len + ' bit)\n';
+    }
+    // decode the integer
+    if (neg) v = v - 256;
+
+    const n = new Int10(v);
+    for (let i = start + 1; i < end; ++i) {
+      n.mulAdd(256, this.get(i));
+    }
+
+    return s ? s + n.toString() : n.toString();
+  }
+  parseBitString(start: number, end: number, maxLength: number) {
+    var unusedBits = this.get(start);
+    if (unusedBits > 7) throw 'Invalid BitString with unusedBits=' + unusedBits;
+    var lenBit = ((end - start - 1) << 3) - unusedBits,
+      s = '';
+    for (var i = start + 1; i < end; ++i) {
+      var b = this.get(i),
+        skip = i == end - 1 ? unusedBits : 0;
+      for (var j = 7; j >= skip; --j) s += (b >> j) & 1 ? '1' : '0';
+      if (s.length > maxLength) s = stringCut(s, maxLength);
+    }
+    return { size: lenBit, str: s };
+  }
+  parseOctetString(start: number, end: number, maxLength: number) {
+    var len = end - start,
+      s;
+    try {
+      s = this.parseStringUTF(start, end);
+      var v;
+      for (i = 0; i < s.length; ++i) {
+        v = s.charCodeAt(i);
+        if (v < 32 && v != 9 && v != 10 && v != 13)
+          // [\t\r\n] are (kinda) printable
+          throw new Error(
+            'Unprintable character at index ' +
+              i +
+              ' (code ' +
+              s.charCodeAt(i) +
+              ')'
+          );
+      }
+      return { size: len, str: s };
+    } catch (e) {
+      // ignore
+    }
+    maxLength /= 2; // we work in bytes
+    if (len > maxLength) end = start + maxLength;
+    s = '';
+    for (var i = start; i < end; ++i) s += this.hexByte(this.get(i));
+    if (len > maxLength) s += ellipsis;
+    return { size: len, str: s };
+  }
+  parseOID(start: number, end: number, maxLength: number) {
+    let s = '';
+    let n = new Int10();
+    let bits = 0;
+    for (let i = start; i < end; ++i) {
+      var v = this.get(i);
+      n.mulAdd(128, v & 0x7f);
+      bits += 7;
+      if (!(v & 0x80)) {
+        // finished
+        if (s === '') {
+          n = n.simplify() as Int10;
+          if (n instanceof Int10) {
+            n.sub(80);
+
+            s = '2.' + n.toString();
+          } else {
+            const m = n < 80 ? (n < 40 ? 0 : 1) : 2;
+            s = m + '.' + (n - m * 40);
+          }
+        } else s += '.' + n.toString();
+        if (s.length > maxLength) return stringCut(s, maxLength);
+
+        n = new Int10();
+        bits = 0;
+      }
+    }
+    if (bits > 0) s += '.incomplete';
+    if (typeof oids === 'object') {
+      const oid = oids[s];
+      if (oid) {
+        if (oid.d) s += '\n' + oid.d;
+        if (oid.c) s += '\n' + oid.c;
+        if (oid.w) s += '\n(warning!)';
+      }
+    }
+    return s;
+  }
+}
+
+export default Stream;

package/src/lib/asn1/asn1.ts

@@ -0,0 +1,120 @@
+// ASN.1 JavaScript decoder
+// Copyright (c) 2008-2021 Lapo Luchini <lapo@lapo.it>
+
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+import Stream from './Stream';
+import ASN1, { ASN1Tag } from './Asn.1';
+
+export function decodeLength(stream: Stream) {
+  let buf = stream.get(),
+    len = buf & 0x7f;
+  if (len == buf)
+    // first bit was 0, short form
+    return len;
+  if (len === 0)
+    // long form with length 0 is a special case
+    return null; // undefined length
+  if (len > 6)
+    // no reason to use Int10, as it would be a huge buffer anyways
+    throw 'Length over 48 bits not supported at position ' + (stream.pos - 1);
+  buf = 0;
+  for (var i = 0; i < len; ++i) buf = buf * 256 + stream.get();
+  return buf;
+}
+
+export function decode(pStream: Stream | string, offset?: number): any {
+  let stream: Stream =
+    pStream instanceof Stream ? pStream : new Stream(pStream, offset || 0);
+  const streamStart = new Stream(stream);
+  let tag = new ASN1Tag(stream);
+  const tagLen = stream.pos - streamStart.pos;
+  let len = decodeLength(stream);
+  let start = stream.pos;
+  const header = start - streamStart.pos;
+  let sub: any = null;
+  const getSub = () => {
+    sub = [];
+    if (len !== null) {
+      // definite length
+      var end = start + len;
+      // @ts-ignore
+      if (end > stream.enc.length)
+        throw (
+          'Container at offset ' +
+          start +
+          ' has a length of ' +
+          len +
+          ', which is past the end of the stream'
+        );
+      while (stream.pos < end) {
+        sub[sub.length] = decode(stream);
+      }
+      if (stream.pos != end)
+        throw 'Content size is not correct for container at offset ' + start;
+    } else {
+      // undefined length
+      try {
+        for (;;) {
+          var s = decode(stream);
+          if (s.tag.isEOC()) break;
+          sub[sub.length] = s;
+        }
+        len = start - stream.pos; // undefined lengths are represented as negative values
+      } catch (e) {
+        throw (
+          'Exception while decoding undefined length content at offset ' +
+          start +
+          ': ' +
+          e
+        );
+      }
+    }
+  };
+  if (tag.tagConstructed) {
+    // must have valid content
+    getSub();
+  } else if (
+    tag.isUniversal() &&
+    (tag.tagNumber == 0x03 || tag.tagNumber == 0x04)
+  ) {
+    // sometimes BitString and OctetString are used to encapsulate ASN.1
+    try {
+      if (tag.tagNumber == 0x03)
+        if (stream.get() != 0)
+          throw 'BIT STRINGs with unused bits cannot encapsulate.';
+      getSub();
+      if (sub) {
+        for (var i = 0; i < sub.length; ++i)
+          if (sub[i].tag.isEOC())
+            throw 'EOC is not supposed to be actual content.';
+      }
+    } catch (e) {
+      // but silently ignore when they don't
+      sub = null;
+      //DEBUG console.log('Could not decode structure at ' + start + ':', e);
+    }
+  }
+  if (sub === null) {
+    if (len === null)
+      throw (
+        "We can't skip over an invalid tag with undefined length at offset " +
+        start
+      );
+    stream.pos = start + Math.abs(len);
+  }
+
+  return new ASN1(streamStart, header, len as number, tag, tagLen, sub);
+}
+
+export default decode;

package/src/lib/asn1/base64.ts

@@ -0,0 +1,97 @@
+// Base64 JavaScript decoder
+// Copyright (c) 2008-2021 Lapo Luchini <lapo@lapo.it>
+
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+var decoder: any[] | undefined, // populated on first usage
+  haveU8 = typeof Uint8Array == 'function';
+
+export const decode = function (a: any) {
+  var isString = typeof a == 'string';
+  var i;
+  if (decoder === undefined) {
+    var b64 =
+        'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
+      ignore = '= \f\n\r\t\u00A0\u2028\u2029';
+    decoder = [];
+    for (i = 0; i < 64; ++i) decoder[b64.charCodeAt(i)] = i;
+    for (i = 0; i < ignore.length; ++i) decoder[ignore.charCodeAt(i)] = -1;
+    // RFC 3548 URL & file safe encoding
+    decoder['-'.charCodeAt(0)] = decoder['+'.charCodeAt(0)];
+    decoder['_'.charCodeAt(0)] = decoder['/'.charCodeAt(0)];
+  }
+  var out: any = haveU8 ? new Uint8Array((a.length * 3) >> 2) : [];
+  var bits = 0,
+    char_count = 0,
+    len = 0;
+  for (i = 0; i < a.length; ++i) {
+    var c = isString ? a.charCodeAt(i) : a[i];
+    if (c == 61)
+      // '='.charCodeAt(0)
+      break;
+    c = decoder[c];
+    if (c == -1) continue;
+    if (c === undefined) throw 'Illegal character at offset ' + i;
+    bits |= c;
+    if (++char_count >= 4) {
+      out[len++] = bits >> 16;
+      out[len++] = (bits >> 8) & 0xff;
+      out[len++] = bits & 0xff;
+      bits = 0;
+      char_count = 0;
+    } else {
+      bits <<= 6;
+    }
+  }
+  switch (char_count) {
+    case 1:
+      throw 'Base64 encoding incomplete: at least 2 bits missing';
+    case 2:
+      out[len++] = bits >> 10;
+      break;
+    case 3:
+      out[len++] = bits >> 16;
+      out[len++] = (bits >> 8) & 0xff;
+      break;
+  }
+  if (haveU8 && out.length > len) {
+    // in case it was originally longer because of ignored characters
+    out = out.subarray(0, len);
+  }
+  return out;
+};
+
+export const pretty = function (str: string) {
+  // fix padding
+  if (str.length % 4 > 0)
+    str = (str + '===').slice(0, str.length + (str.length % 4));
+  // convert RFC 3548 to standard Base64
+  str = str.replace(/-/g, '+').replace(/_/g, '/');
+  // 80 column width
+  return str.replace(/(.{80})/g, '$1\n');
+};
+
+export const re =
+  /-----BEGIN [^-]+-----([A-Za-z0-9+/=\s]+)-----END [^-]+-----|begin-base64[^\n]+\n([A-Za-z0-9+/=\s]+)====|^([A-Za-z0-9+/=\s]+)$/;
+
+export const unarmor = function (a: any) {
+  var m = re.exec(a);
+  if (m) {
+    if (m[1]) a = m[1];
+    else if (m[2]) a = m[2];
+    else if (m[3]) a = m[3];
+    else throw 'RegExp out of sync';
+  }
+
+  return decode(a);
+};

package/src/lib/asn1/hex.ts

@@ -0,0 +1,60 @@
+// Hex JavaScript decoder
+// Copyright (c) 2008-2021 Lapo Luchini <lapo@lapo.it>
+
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+var decoder: number[] | undefined, // populated on first usage
+  haveU8 = typeof Uint8Array == 'function';
+
+/**
+ * Decodes an hexadecimal value.
+ * @param {string|Array|Uint8Array} a - a string representing hexadecimal data, or an array representation of its charcodes
+ */
+export const hexDecode = function (a: any): any {
+  var isString = typeof a == 'string';
+  var i;
+  if (decoder === undefined) {
+    var hex = '0123456789ABCDEF',
+      ignore = ' \f\n\r\t\u00A0\u2028\u2029';
+    decoder = [];
+    for (i = 0; i < 16; ++i) decoder[hex.charCodeAt(i)] = i;
+    hex = hex.toLowerCase();
+    for (i = 10; i < 16; ++i) decoder[hex.charCodeAt(i)] = i;
+    for (i = 0; i < ignore.length; ++i) decoder[ignore.charCodeAt(i)] = -1;
+  }
+  var out = haveU8 ? new Uint8Array(a.length >> 1) : [],
+    bits = 0,
+    char_count = 0,
+    len = 0;
+  for (i = 0; i < a.length; ++i) {
+    // @ts-ignore
+    var c = isString ? a.charCodeAt(i) : a[i];
+    c = decoder[c];
+    if (c == -1) continue;
+    if (c === undefined) throw 'Illegal character at offset ' + i;
+    bits |= c;
+    if (++char_count >= 2) {
+      out[len++] = bits;
+      bits = 0;
+      char_count = 0;
+    } else {
+      bits <<= 4;
+    }
+  }
+  if (char_count) throw 'Hex encoding incomplete: 4 bits missing';
+  if (haveU8 && out.length > len)
+    // in case it was originally longer because of ignored characters
+    // @ts-ignore
+    out = out.subarray(0, len);
+  return out;
+};

package/src/lib/asn1/index.ts

@@ -0,0 +1,5 @@
+export * as Hex from './hex';
+export * as Asn1 from './asn1';
+export { default as Int10 } from './int10';
+export { default as Oids } from './oids';
+export * as Base64 from './base64';

package/src/lib/asn1/int10.ts

@@ -0,0 +1,103 @@
+// Big integer base-10 printing library
+// Copyright (c) 2008-2021 Lapo Luchini <lapo@lapo.it>
+
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+var max = 10000000000000; // biggest 10^n integer that can still fit 2^53 when multiplied by 256
+
+/**
+ * Arbitrary length base-10 value.
+ * @param {number} value - Optional initial value (will be 0 otherwise).
+ */
+class Int10 {
+  buf: number[];
+  constructor(value?: number) {
+    this.buf = value ? [+value] : [0];
+  }
+
+  /**
+   * Multiply value by m and add c.
+   * @param {number} m - multiplier, must be < =256
+   * @param {number} c - value to add
+   */
+  mulAdd(m: number, c: number) {
+    // assert(m <= 256)
+    var b = this.buf,
+      l = b.length,
+      i,
+      t;
+    for (i = 0; i < l; ++i) {
+      t = b[i] * m + c;
+      if (t < max) c = 0;
+      else {
+        c = 0 | (t / max);
+        t -= c * max;
+      }
+      b[i] = t;
+    }
+    if (c > 0) b[i] = c;
+  }
+
+  /**
+   * Subtract value.
+   * @param {number} c - value to subtract
+   */
+  sub(c: number) {
+    var b = this.buf,
+      l = b.length,
+      i,
+      t;
+    for (i = 0; i < l; ++i) {
+      t = b[i] - c;
+      if (t < 0) {
+        t += max;
+        c = 1;
+      } else c = 0;
+      b[i] = t;
+    }
+    while (b[b.length - 1] === 0) b.pop();
+  }
+
+  /**
+   * Convert to decimal string representation.
+   * @param {*} base - optional value, only value accepted is 10
+   */
+  toString(base?: any) {
+    if ((base || 10) != 10) throw 'only base 10 is supported';
+    var b = this.buf,
+      s = b[b.length - 1].toString();
+    for (var i = b.length - 2; i >= 0; --i)
+      s += (max + b[i]).toString().substring(1);
+    return s;
+  }
+
+  /**
+   * Convert to Number value representation.
+   * Will probably overflow 2^53 and thus become approximate.
+   */
+  valueOf() {
+    var b = this.buf,
+      v = 0;
+    for (var i = b.length - 1; i >= 0; --i) v = v * max + b[i];
+    return v;
+  }
+
+  /**
+   * Return value as a simple Number (if it is <= 10000000000000), or return this.
+   */
+  simplify() {
+    var b = this.buf;
+    return b.length == 1 ? b[0] : this;
+  }
+}
+export default Int10;