@trustchex/react-native-sdk 1.161.0

package/lib/module/Shared/EIDReader/fragmentBuffer.js

@@ -0,0 +1,130 @@
+"use strict";
+
+import { Fragment } from "./fragment.js";
+export class FragmentBuffer {
+  static DEFAULT_SIZE = 2000;
+  constructor(length = FragmentBuffer.DEFAULT_SIZE) {
+    this.buffer = new Uint8Array(length);
+    this.fragments = new Set();
+  }
+  updateFrom(other) {
+    for (const otherFragment of other.fragments) {
+      this.addFragmentBytesWithOffset(otherFragment.getOffset(), other.buffer, otherFragment.getOffset(), otherFragment.getLength());
+    }
+  }
+  addFragment(offset, b) {
+    this.addFragmentBytes(offset, new Uint8Array([b]));
+  }
+  addFragmentBytes(offset, bytes) {
+    this.addFragmentBytesWithOffset(offset, bytes, 0, bytes.length);
+  }
+  addFragmentBytesWithOffset(offset, bytes, srcOffset, srcLength) {
+    if (offset + srcLength > this.buffer.length) {
+      this.setLength(Math.max(2 * (offset + srcLength), this.buffer.length));
+    }
+    this.buffer.set(bytes.slice(srcOffset, srcOffset + srcLength), offset);
+    let thisOffset = offset;
+    let thisLength = srcLength;
+    const otherFragments = Array.from(this.fragments);
+    for (const other of otherFragments) {
+      if (other.getOffset() <= thisOffset && thisOffset + thisLength <= other.getOffset() + other.getLength()) {
+        return;
+      } else if (other.getOffset() <= thisOffset && thisOffset <= other.getOffset() + other.getLength()) {
+        thisLength = thisOffset + thisLength - other.getOffset();
+        thisOffset = other.getOffset();
+        this.fragments.delete(other);
+      } else if (thisOffset <= other.getOffset() && other.getOffset() + other.getLength() <= thisOffset + thisLength) {
+        this.fragments.delete(other);
+      } else if (thisOffset <= other.getOffset() && other.getOffset() <= thisOffset + thisLength) {
+        thisLength = other.getOffset() + other.getLength() - thisOffset;
+        this.fragments.delete(other);
+      }
+    }
+    this.fragments.add(new Fragment(thisOffset, thisLength));
+  }
+  getPosition() {
+    let result = 0;
+    for (let i = 0; i < this.buffer.length; i++) {
+      if (this.isCoveredByFragment(i)) {
+        result = i + 1;
+      }
+    }
+    return result;
+  }
+  getBytesBuffered() {
+    let result = 0;
+    for (let i = 0; i < this.buffer.length; i++) {
+      if (this.isCoveredByFragment(i)) {
+        result++;
+      }
+    }
+    return result;
+  }
+  isCoveredByFragment(offset) {
+    return this.isCoveredByFragmentWithLength(offset, 1);
+  }
+  isCoveredByFragmentWithLength(offset, length) {
+    for (const fragment of this.fragments) {
+      const left = fragment.getOffset();
+      const right = fragment.getOffset() + fragment.getLength();
+      if (left <= offset && offset + length <= right) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getBufferedLength(index) {
+    if (index >= this.buffer.length) {
+      return 0;
+    }
+    let result = 0;
+    for (const fragment of this.fragments) {
+      const left = fragment.getOffset();
+      const right = fragment.getOffset() + fragment.getLength();
+      if (left <= index && index < right) {
+        const newResult = right - index;
+        if (newResult > result) {
+          result = newResult;
+        }
+      }
+    }
+    return result;
+  }
+  getFragments() {
+    return this.fragments;
+  }
+  getBuffer() {
+    return this.buffer;
+  }
+  getLength() {
+    return this.buffer.length;
+  }
+  getSmallestUnbufferedFragment(offset, length) {
+    let thisOffset = offset;
+    let thisLength = length;
+    for (const other of this.fragments) {
+      if (other.getOffset() <= thisOffset && thisOffset + thisLength <= other.getOffset() + other.getLength()) {
+        thisLength = 0;
+        break;
+      } else if (other.getOffset() <= thisOffset && thisOffset < other.getOffset() + other.getLength()) {
+        const newOffset = other.getOffset() + other.getLength();
+        const newLength = thisOffset + thisLength - newOffset;
+        thisOffset = newOffset;
+        thisLength = newLength;
+      } else if (thisOffset <= other.getOffset() && other.getOffset() + other.getOffset() <= thisOffset + thisLength) {
+        continue;
+      } else if (offset <= other.getOffset() && other.getOffset() < thisOffset + thisLength) {
+        thisLength = other.getOffset() - thisOffset;
+      }
+    }
+    return new Fragment(thisOffset, thisLength);
+  }
+  setLength(length) {
+    if (length <= this.buffer.length) {
+      return;
+    }
+    const newBuffer = new Uint8Array(length);
+    newBuffer.set(this.buffer);
+    this.buffer = newBuffer;
+  }
+}

package/lib/module/Shared/EIDReader/java/byteArrayInputStream.js

@@ -0,0 +1,73 @@
+"use strict";
+
+import { InputStream } from "./inputStream.js";
+export class ByteArrayInputStream extends InputStream {
+  static MAX_TRANSFER_SIZE = 128 * 1024;
+  constructor(buf, offset = 0, length = buf.length) {
+    super();
+    this.buf = buf;
+    this.pos = offset;
+    this.count = Math.min(offset + length, buf.length);
+    this._mark = offset;
+  }
+  read() {
+    if (this.pos < this.count) {
+      return Promise.resolve(this.buf[this.pos++]);
+    }
+    return Promise.resolve(-1); // End of stream
+  }
+  readBytesWithOffset(b, off, len) {
+    if (this.pos >= this.count) {
+      return Promise.resolve(-1); // End of stream
+    }
+    const avail = this.count - this.pos;
+    const toRead = Math.min(len, avail);
+    if (toRead <= 0) {
+      return Promise.resolve(0); // Nothing to read
+    }
+    b.set(this.buf.subarray(this.pos, this.pos + toRead), off);
+    this.pos += toRead;
+    return Promise.resolve(toRead);
+  }
+  readAllBytes() {
+    const result = this.buf.subarray(this.pos, this.count);
+    this.pos = this.count;
+    return Promise.resolve(result);
+  }
+  async readNBytes(b, off, len) {
+    const n = await this.readBytesWithOffset(b, off, len);
+    return n === -1 ? 0 : n;
+  }
+  async transferTo(out) {
+    const len = this.count - this.pos;
+    if (len > 0) {
+      let nWritten = 0;
+      while (nWritten < len) {
+        const nByte = Math.min(len - nWritten, ByteArrayInputStream.MAX_TRANSFER_SIZE);
+        const chunk = this.buf.slice(this.pos, this.pos + nByte);
+        out.writeBytes(chunk);
+        this.pos += nByte;
+        nWritten += nByte;
+      }
+      return len;
+    }
+    return 0;
+  }
+  skip(n) {
+    const k = Math.min(n, this.count - this.pos);
+    this.pos += k;
+    return Promise.resolve(k);
+  }
+  available() {
+    return this.count - this.pos;
+  }
+  markSupported() {
+    return true;
+  }
+  mark(_readAheadLimit) {
+    this._mark = this.pos;
+  }
+  reset() {
+    this.pos = this._mark;
+  }
+}

package/lib/module/Shared/EIDReader/java/byteArrayOutputStream.js

@@ -0,0 +1,55 @@
+"use strict";
+
+import { OutputStream } from "./outputStream.js";
+import { Buffer } from 'buffer';
+export class ByteArrayOutputStream extends OutputStream {
+  static INITIAL_SIZE = 32;
+  constructor(size = ByteArrayOutputStream.INITIAL_SIZE) {
+    super();
+    if (size < 0) {
+      throw new Error(`Negative initial size: ${size}`);
+    }
+    this.buf = Buffer.alloc(size);
+    this.count = 0;
+  }
+  ensureCapacity(minCapacity) {
+    const oldCapacity = this.buf.length;
+    if (minCapacity > oldCapacity) {
+      const newCapacity = Math.max(oldCapacity * 2, minCapacity);
+      const newBuf = Buffer.alloc(newCapacity);
+      newBuf.set(this.buf);
+      this.buf = newBuf;
+    }
+  }
+  write(b) {
+    this.ensureCapacity(this.count + 1);
+    this.buf[this.count++] = b & 0xff;
+  }
+  writeBytes(b) {
+    this.writeBytesOffset(b, 0, b.length);
+  }
+  writeBytesOffset(b, off, len) {
+    if (off < 0 || len < 0 || off + len > b.length) {
+      throw new RangeError('Index out of bounds');
+    }
+    this.ensureCapacity(this.count + len);
+    this.buf.set(b.subarray(off, off + len), this.count);
+    this.count += len;
+  }
+  writeTo(out) {
+    const chunk = this.buf.slice(0, this.count);
+    return out.writeBytes(chunk);
+  }
+  reset() {
+    this.count = 0;
+  }
+  toByteArray() {
+    return this.buf.subarray(0, this.count);
+  }
+  size() {
+    return this.count;
+  }
+  close() {
+    // Do nothing
+  }
+}

package/lib/module/Shared/EIDReader/java/dataInput.js

@@ -0,0 +1 @@
+"use strict";

package/lib/module/Shared/EIDReader/java/dataInputStream.js

@@ -0,0 +1,167 @@
+"use strict";
+
+import { FilterInputStream } from "./filterInputStream.js";
+import { Buffer } from 'buffer';
+export class DataInputStream extends FilterInputStream {
+  static EMPTY_BYTE_ARRAY = new Uint8Array(0);
+  static EMPTY_CHAR_ARRAY = [];
+  readBuffer = Buffer.alloc(8);
+  bytearr = DataInputStream.EMPTY_BYTE_ARRAY;
+  chararr = DataInputStream.EMPTY_CHAR_ARRAY;
+  constructor(is) {
+    super(is);
+  }
+  async readBytes(b) {
+    return this.is.readBytesWithOffset(b, 0, b.length);
+  }
+  async readFully(b) {
+    await this.readFullyWithOffset(b, 0, b.length);
+  }
+  async readFullyWithOffset(b, off, len) {
+    let n = 0;
+    while (n < len) {
+      const count = await this.is.readBytesWithOffset(b, off + n, len - n);
+      if (count < 0) {
+        throw new Error('readBytesWithOffset: EOFException');
+      }
+      n += count;
+    }
+  }
+  async skipBytes(n) {
+    let total = 0;
+    let cur = 0;
+    while (total < n && (cur = await this.is.skip(n - total)) > 0) {
+      total += cur;
+    }
+    return total;
+  }
+  async readBoolean() {
+    return (await this.readByte()) !== 0;
+  }
+  async readByte() {
+    const ch = await this.is.read();
+    if (ch < 0) {
+      throw new Error('readByte: EOFException');
+    }
+    return ch;
+  }
+  async readUnsignedByte() {
+    const ch = await this.is.read();
+    if (ch < 0) {
+      throw new Error('readUnsignedByte: EOFException');
+    }
+    return ch;
+  }
+  async readShort() {
+    await this.readBytesWithOffset(this.readBuffer, 0, 2);
+    return Buffer.from(this.readBuffer).readInt16BE(0);
+  }
+  async readUnsignedShort() {
+    await this.readBytesWithOffset(this.readBuffer, 0, 2);
+    return Buffer.from(this.readBuffer).readUInt16BE(0);
+  }
+  async readChar() {
+    await this.readBytesWithOffset(this.readBuffer, 0, 2);
+    return Buffer.from(this.readBuffer).toString('utf16le');
+  }
+  async readInt() {
+    await this.readBytesWithOffset(this.readBuffer, 0, 4);
+    return Buffer.from(this.readBuffer).readInt32BE(0);
+  }
+  async readLong() {
+    await this.readBytesWithOffset(this.readBuffer, 0, 8);
+    return Buffer.from(this.readBuffer).readBigInt64BE(0);
+  }
+  async readFloat() {
+    return Number(await this.readInt());
+  }
+  async readDouble() {
+    return Number(await this.readLong());
+  }
+  async readUTF() {
+    return DataInputStream.readUTF(this);
+  }
+  static async readUTF(dataInput) {
+    const utflen = await dataInput.readUnsignedShort();
+    let bytearr = null;
+    let chararr = null;
+    if (dataInput instanceof DataInputStream) {
+      if (dataInput.bytearr.length < utflen) {
+        dataInput.bytearr = new Uint8Array(utflen * 2);
+        dataInput.chararr = new Array(utflen * 2);
+      }
+      chararr = dataInput.chararr;
+      bytearr = dataInput.bytearr;
+    } else {
+      bytearr = new Uint8Array(utflen);
+      chararr = new Array(utflen);
+    }
+    let c, char2, char3;
+    let count = 0;
+    let chararr_count = 0;
+    await dataInput.readFully(bytearr, 0, utflen);
+    while (count < utflen) {
+      c = bytearr[count] & 0xff;
+      if (c > 127) {
+        break;
+      }
+      count++;
+      chararr[chararr_count++] = String.fromCharCode(c);
+    }
+    while (count < utflen) {
+      c = bytearr[count] & 0xff;
+      switch (c >> 4) {
+        case 0:
+        case 1:
+        case 2:
+        case 3:
+        case 4:
+        case 5:
+        case 6:
+        case 7:
+          {
+            /* 0xxxxxxx*/
+            count++;
+            chararr[chararr_count++] = String.fromCharCode(c);
+            break;
+          }
+        case 12:
+        case 13:
+          {
+            /* 110x xxxx   10xx xxxx*/
+            count += 2;
+            if (count > utflen) {
+              throw new Error('malformed input: partial character at end');
+            }
+            char2 = bytearr[count - 1];
+            if ((char2 & 0xc0) !== 0x80) {
+              throw new Error('malformed input around byte ' + count);
+            }
+            chararr[chararr_count++] = String.fromCharCode((c & 0x1f) << 6 | char2 & 0x3f);
+            break;
+          }
+        case 14:
+          {
+            /* 1110 xxxx  10xx xxxx  10xx xxxx */
+            count += 3;
+            if (count > utflen) {
+              throw new Error('malformed input: partial character at end');
+            }
+            char2 = bytearr[count - 2];
+            char3 = bytearr[count - 1];
+            if ((char2 & 0xc0) !== 0x80 || (char3 & 0xc0) !== 0x80) {
+              throw new Error('malformed input around byte ' + count);
+            }
+            chararr[chararr_count++] = String.fromCharCode((c & 0x0f) << 12 | (char2 & 0x3f) << 6 | (char3 & 0x3f) << 0);
+            break;
+          }
+        default:
+          /* 10xx xxxx,  1111 xxxx */
+          throw new Error('malformed input around byte ' + count);
+      }
+    }
+
+    // The number of chars produced may be less than utflen
+    return chararr.slice(0, chararr_count).join('');
+  }
+}

package/lib/module/Shared/EIDReader/java/dataOutputStream.js

@@ -0,0 +1,91 @@
+"use strict";
+
+import { Buffer } from 'buffer';
+import { OutputStream } from "./outputStream.js";
+export class DataOutputStream extends OutputStream {
+  constructor(out) {
+    super();
+    this.out = out;
+    this.written = 0;
+  }
+  incCount(value) {
+    let temp = this.written + value;
+    if (temp < 0) {
+      temp = Number.MAX_VALUE;
+    }
+    this.written = temp;
+  }
+  write(b) {
+    this.out.write(b);
+    this.incCount(1);
+  }
+  writeBytes(bytes) {
+    this.out.writeBytes(bytes);
+    this.incCount(bytes.length);
+  }
+  writeShort(s) {
+    const buffer = Buffer.alloc(2);
+    buffer.writeInt16BE(s, 0);
+    this.out.writeBytes(Uint8Array.from(buffer));
+    this.incCount(2);
+  }
+  writeInt(i) {
+    const buffer = Buffer.alloc(4);
+    buffer.writeInt32BE(i, 0);
+    this.out.writeBytes(Uint8Array.from(buffer));
+    this.incCount(4);
+  }
+  writeLong(l) {
+    const buffer = Buffer.alloc(8);
+    buffer.writeBigUInt64BE(l, 0);
+    this.out.writeBytes(Uint8Array.from(buffer));
+    this.incCount(8);
+  }
+  writeUTF(str) {
+    const strlen = str.length;
+    let utflen = strlen;
+    for (let i = 0; i < strlen; i++) {
+      const c = str.charCodeAt(i);
+      if (c >= 0x80 || c === 0) {
+        utflen += c >= 0x800 ? 2 : 1;
+      }
+    }
+    if (utflen > 65535 || utflen < strlen) {
+      throw new Error(DataOutputStream.tooLongMsg(str, utflen));
+    }
+    const bytearr = new Array(utflen + 2);
+    let count = 0;
+    bytearr[count++] = utflen >>> 8 & 0xff;
+    bytearr[count++] = utflen & 0xff;
+    for (let i = 0; i < strlen; i++) {
+      const c = str.charCodeAt(i);
+      if (c < 0x80 && c !== 0) {
+        bytearr[count++] = c;
+      } else if (c >= 0x800) {
+        bytearr[count++] = 0xe0 | c >> 12 & 0x0f;
+        bytearr[count++] = 0x80 | c >> 6 & 0x3f;
+        bytearr[count++] = 0x80 | c >> 0 & 0x3f;
+      } else {
+        bytearr[count++] = 0xc0 | c >> 6 & 0x1f;
+        bytearr[count++] = 0x80 | c >> 0 & 0x3f;
+      }
+    }
+    this.out.writeBytesWithOffset(Uint8Array.from(bytearr), 0, utflen + 2);
+  }
+  size() {
+    return this.written;
+  }
+  flush() {
+    this.out.flush();
+  }
+  close() {
+    this.out.close();
+  }
+  static tooLongMsg(s, bits32) {
+    const sLen = s.length;
+    const head = s.substring(0, 8);
+    const tail = s.substring(sLen - 8, sLen);
+    const actualLength = sLen + (bits32 - sLen);
+    return `encoded string (${head}...${tail}) too long: ${actualLength} bytes`;
+  }
+}

package/lib/module/Shared/EIDReader/java/filterInputStream.js

@@ -0,0 +1,134 @@
+"use strict";
+
+import { InputStream } from "./inputStream.js";
+export class FilterInputStream extends InputStream {
+  /**
+   * The input stream to be filtered.
+   */
+
+  /**
+   * Creates a `FilterInputStream`
+   * by assigning the argument `in`
+   * to the field `this.in` so as
+   * to remember it for later use.
+   *
+   * @param   is   the underlying input stream, or `null` if
+   *          this instance is to be created without an underlying stream.
+   */
+  constructor(is) {
+    super();
+    this.is = is;
+  }
+
+  /**
+   * This method simply performs `in.read()` and returns the result.
+   *
+   * @return     the next byte of data, or -1 if the end of the stream is reached.
+   * @throws     IOException  if an I/O error occurs.
+   */
+  async read() {
+    return this.is.read();
+  }
+
+  /**
+   * Reads up to `b.length` bytes of data from this
+   * input stream into an array of bytes. This method blocks until some
+   * input is available.
+   *
+   * @param      b   the buffer into which the data is read.
+   * @return     the total number of bytes read into the buffer, or -1 if there is no more data because the end of the stream has been reached.
+   * @throws     IOException  if an I/O error occurs.
+   */
+  async readBytes(b) {
+    return this.readBytesWithOffset(b, 0, b.length);
+  }
+
+  /**
+   * Reads up to `len` bytes of data from this input stream
+   * into an array of bytes. If `len` is not zero, the method
+   * blocks until some input is available; otherwise, no
+   * bytes are read and `0` is returned.
+   *
+   * @param      b     the buffer into which the data is read.
+   * @param      off   the start offset in the destination array `b`.
+   * @param      len   the maximum number of bytes read.
+   * @return     the total number of bytes read into the buffer, or -1 if there is no more data because the end of the stream has been reached.
+   * @throws     NullPointerException if `b` is `null`.
+   * @throws     IndexOutOfBoundsException if `off` is negative, `len` is negative, or `len` is greater than `b.length - off`.
+   * @throws     IOException  if an I/O error occurs.
+   */
+  async readBytesWithOffset(b, off, len) {
+    return this.is.readBytesWithOffset(b, off, len);
+  }
+
+  /**
+   * Skips over and discards `n` bytes of data from the
+   * input stream. The `skip` method may, for a variety of
+   * reasons, end up skipping over some smaller number of bytes,
+   * possibly `0`. The actual number of bytes skipped is
+   * returned.
+   *
+   * @param      n   the number of bytes to be skipped.
+   * @return     the actual number of bytes skipped.
+   * @throws     IOException  if an I/O error occurs.
+   */
+  async skip(n) {
+    return this.is.skip(n);
+  }
+
+  /**
+   * Returns an estimate of the number of bytes that can be read (or
+   * skipped over) from this input stream without blocking by the next
+   * caller of a method for this input stream. The next caller might be
+   * the same thread or another thread. A single read or skip of this
+   * many bytes will not block, but may read or skip fewer bytes.
+   *
+   * @return     an estimate of the number of bytes that can be read (or
+   *             skipped over) from this input stream without blocking.
+   * @throws     IOException  if an I/O error occurs.
+   */
+  available() {
+    return this.is.available();
+  }
+
+  /**
+   * Closes this input stream and releases any system resources associated with the stream.
+   *
+   * @throws     IOException  if an I/O error occurs.
+   */
+  close() {
+    this.is.close();
+  }
+
+  /**
+   * Marks the current position in this input stream. A subsequent
+   * call to the `reset` method repositions this stream at
+   * the last marked position so that subsequent reads re-read the same bytes.
+   *
+   * @param   readLimit   the maximum limit of bytes that can be read before the mark position becomes invalid.
+   */
+  mark(readLimit) {
+    this.is.mark(readLimit);
+  }
+
+  /**
+   * Repositions this stream to the position at the time the
+   * `mark` method was last called on this input stream.
+   *
+   * @throws     IOException  if the stream has not been marked or if the mark has been invalidated.
+   */
+  reset() {
+    this.is.reset();
+  }
+
+  /**
+   * Tests if this input stream supports the `mark`
+   * and `reset` methods.
+   *
+   * @return  `true` if this stream type supports the
+   *          `mark` and `reset` method; `false` otherwise.
+   */
+  markSupported() {
+    return this.is.markSupported();
+  }
+}