@hot-updater/react-native 1.0.7 → 1.1.0

package/android/src/main/java/com/hotupdater/vendor/brotli/dec/BitReader.java

@@ -0,0 +1,314 @@
+/* Copyright 2015 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
+package com.hotupdater.vendor.brotli.dec;
+
+import static com.hotupdater.vendor.brotli.dec.BrotliError.BROTLI_ERROR;
+import static com.hotupdater.vendor.brotli.dec.BrotliError.BROTLI_ERROR_CORRUPTED_PADDING_BITS;
+import static com.hotupdater.vendor.brotli.dec.BrotliError.BROTLI_ERROR_READ_AFTER_END;
+import static com.hotupdater.vendor.brotli.dec.BrotliError.BROTLI_ERROR_TRUNCATED_INPUT;
+import static com.hotupdater.vendor.brotli.dec.BrotliError.BROTLI_ERROR_UNUSED_BYTES_AFTER_END;
+import static com.hotupdater.vendor.brotli.dec.BrotliError.BROTLI_OK;
+import static com.hotupdater.vendor.brotli.dec.BrotliError.BROTLI_PANIC_UNALIGNED_COPY_BYTES;
+
+/**
+ * Bit reading helpers.
+ */
+final class BitReader {
+
+  // Possible values: {5, 6}.  5 corresponds to 32-bit build, 6 to 64-bit. This value is used for
+  // JIT conditional compilation.
+  private static final int LOG_BITNESS = Utils.getLogBintness();
+
+  // Not only Java compiler prunes "if (const false)" code, but JVM as well.
+  // Code under "if (BIT_READER_DEBUG != 0)" have zero performance impact (outside unit tests).
+  private static final int BIT_READER_DEBUG = Utils.isDebugMode();
+
+  static final int BITNESS = 1 << LOG_BITNESS;
+
+  private static final int BYTENESS = BITNESS / 8;
+  private static final int CAPACITY = 4096;
+  // After encountering the end of the input stream, this amount of zero bytes will be appended.
+  private static final int SLACK = 64;
+  private static final int BUFFER_SIZE = CAPACITY + SLACK;
+  // Don't bother to replenish the buffer while this number of bytes is available.
+  private static final int SAFEGUARD = 36;
+  private static final int WATERLINE = CAPACITY - SAFEGUARD;
+
+  // "Half" refers to "half of native integer type", i.e. on 64-bit machines it is 32-bit type,
+  // on 32-bit machines it is 16-bit.
+  private static final int HALF_BITNESS = BITNESS / 2;
+  private static final int HALF_SIZE = BYTENESS / 2;
+  private static final int HALVES_CAPACITY = CAPACITY / HALF_SIZE;
+  private static final int HALF_BUFFER_SIZE = BUFFER_SIZE / HALF_SIZE;
+
+  private static final int LOG_HALF_SIZE = LOG_BITNESS - 4;
+
+  static final int HALF_WATERLINE = WATERLINE / HALF_SIZE;
+
+  /**
+   * Fills up the input buffer.
+   *
+   * <p> Should not be called if there are at least 36 bytes present after current position.
+   *
+   * <p> After encountering the end of the input stream, 64 additional zero bytes are copied to the
+   * buffer.
+   */
+  static int readMoreInput(State s) {
+    if (s.endOfStreamReached != 0) {
+      if (halfAvailable(s) >= -2) {
+        return BROTLI_OK;
+      }
+      return Utils.makeError(s, BROTLI_ERROR_TRUNCATED_INPUT);
+    }
+    final int readOffset = s.halfOffset << LOG_HALF_SIZE;
+    int bytesInBuffer = CAPACITY - readOffset;
+    // Move unused bytes to the head of the buffer.
+    Utils.copyBytesWithin(s.byteBuffer, 0, readOffset, CAPACITY);
+    s.halfOffset = 0;
+    while (bytesInBuffer < CAPACITY) {
+      final int spaceLeft = CAPACITY - bytesInBuffer;
+      final int len = Utils.readInput(s, s.byteBuffer, bytesInBuffer, spaceLeft);
+      if (len < BROTLI_ERROR) {
+        return len;
+      }
+      // EOF is -1 in Java, but 0 in C#.
+      if (len <= 0) {
+        s.endOfStreamReached = 1;
+        s.tailBytes = bytesInBuffer;
+        bytesInBuffer += HALF_SIZE - 1;
+        break;
+      }
+      bytesInBuffer += len;
+    }
+    bytesToNibbles(s, bytesInBuffer);
+    return BROTLI_OK;
+  }
+
+  static int checkHealth(State s, int endOfStream) {
+    if (s.endOfStreamReached == 0) {
+      return BROTLI_OK;
+    }
+    final int byteOffset = (s.halfOffset << LOG_HALF_SIZE) + ((s.bitOffset + 7) >> 3) - BYTENESS;
+    if (byteOffset > s.tailBytes) {
+      return Utils.makeError(s, BROTLI_ERROR_READ_AFTER_END);
+    }
+    if ((endOfStream != 0) && (byteOffset != s.tailBytes)) {
+      return Utils.makeError(s, BROTLI_ERROR_UNUSED_BYTES_AFTER_END);
+    }
+    return BROTLI_OK;
+  }
+
+  static void assertAccumulatorHealthy(State s) {
+    if (s.bitOffset > BITNESS) {
+      throw new IllegalStateException("Accumulator underloaded: " + s.bitOffset);
+    }
+  }
+
+  static void fillBitWindow(State s) {
+    if (BIT_READER_DEBUG != 0) {
+      assertAccumulatorHealthy(s);
+    }
+    if (s.bitOffset >= HALF_BITNESS) {
+      // Same as doFillBitWindow. JVM fails to inline it.
+      if (BITNESS == 64) {
+        s.accumulator64 = ((long) s.intBuffer[s.halfOffset++] << HALF_BITNESS)
+            | Utils.shr64(s.accumulator64, HALF_BITNESS);
+      } else {
+        s.accumulator32 = ((int) s.shortBuffer[s.halfOffset++] << HALF_BITNESS)
+            | Utils.shr32(s.accumulator32, HALF_BITNESS);
+      }
+      s.bitOffset -= HALF_BITNESS;
+    }
+  }
+
+  static void doFillBitWindow(State s) {
+    if (BIT_READER_DEBUG != 0) {
+      assertAccumulatorHealthy(s);
+    }
+    if (BITNESS == 64) {
+      s.accumulator64 = ((long) s.intBuffer[s.halfOffset++] << HALF_BITNESS)
+          | Utils.shr64(s.accumulator64, HALF_BITNESS);
+    } else {
+      s.accumulator32 = ((int) s.shortBuffer[s.halfOffset++] << HALF_BITNESS)
+          | Utils.shr32(s.accumulator32, HALF_BITNESS);
+    }
+    s.bitOffset -= HALF_BITNESS;
+  }
+
+  static int peekBits(State s) {
+    if (BITNESS == 64) {
+      return (int) Utils.shr64(s.accumulator64, s.bitOffset);
+    } else {
+      return Utils.shr32(s.accumulator32, s.bitOffset);
+    }
+  }
+
+  /**
+   * Fetches bits from accumulator.
+   *
+   * WARNING: accumulator MUST contain at least the specified amount of bits,
+   * otherwise BitReader will become broken.
+   */
+  static int readFewBits(State s, int n) {
+    final int v = peekBits(s) & ((1 << n) - 1);
+    s.bitOffset += n;
+    return v;
+  }
+
+  static int readBits(State s, int n) {
+    if (HALF_BITNESS >= 24) {
+      return readFewBits(s, n);
+    } else {
+      return (n <= 16) ? readFewBits(s, n) : readManyBits(s, n);
+    }
+  }
+
+  private static int readManyBits(State s, int n) {
+    final int low = readFewBits(s, 16);
+    doFillBitWindow(s);
+    return low | (readFewBits(s, n - 16) << 16);
+  }
+
+  static int initBitReader(State s) {
+    s.byteBuffer = new byte[BUFFER_SIZE];
+    if (BITNESS == 64) {
+      s.accumulator64 = 0;
+      s.intBuffer = new int[HALF_BUFFER_SIZE];
+    } else {
+      s.accumulator32 = 0;
+      s.shortBuffer = new short[HALF_BUFFER_SIZE];
+    }
+    s.bitOffset = BITNESS;
+    s.halfOffset = HALVES_CAPACITY;
+    s.endOfStreamReached = 0;
+    return prepare(s);
+  }
+
+  private static int prepare(State s) {
+    if (s.halfOffset > BitReader.HALF_WATERLINE) {
+      final int result = readMoreInput(s);
+      if (result != BROTLI_OK) {
+        return result;
+      }
+    }
+    int health = checkHealth(s, 0);
+    if (health != BROTLI_OK) {
+      return health;
+    }
+    doFillBitWindow(s);
+    doFillBitWindow(s);
+    return BROTLI_OK;
+  }
+
+  static int reload(State s) {
+    if (s.bitOffset == BITNESS) {
+      return prepare(s);
+    }
+    return BROTLI_OK;
+  }
+
+  static int jumpToByteBoundary(State s) {
+    final int padding = (BITNESS - s.bitOffset) & 7;
+    if (padding != 0) {
+      final int paddingBits = readFewBits(s, padding);
+      if (paddingBits != 0) {
+        return Utils.makeError(s, BROTLI_ERROR_CORRUPTED_PADDING_BITS);
+      }
+    }
+    return BROTLI_OK;
+  }
+
+  static int halfAvailable(State s) {
+    int limit = HALVES_CAPACITY;
+    if (s.endOfStreamReached != 0) {
+      limit = (s.tailBytes + (HALF_SIZE - 1)) >> LOG_HALF_SIZE;
+    }
+    return limit - s.halfOffset;
+  }
+
+  static int copyRawBytes(State s, byte[] data, int offset, int length) {
+    int pos = offset;
+    int len = length;
+    if ((s.bitOffset & 7) != 0) {
+      return Utils.makeError(s, BROTLI_PANIC_UNALIGNED_COPY_BYTES);
+    }
+
+    // Drain accumulator.
+    while ((s.bitOffset != BITNESS) && (len != 0)) {
+      data[pos++] = (byte) peekBits(s);
+      s.bitOffset += 8;
+      len--;
+    }
+    if (len == 0) {
+      return BROTLI_OK;
+    }
+
+    // Get data from shadow buffer with "sizeof(int)" granularity.
+    final int copyNibbles = Utils.min(halfAvailable(s), len >> LOG_HALF_SIZE);
+    if (copyNibbles > 0) {
+      final int readOffset = s.halfOffset << LOG_HALF_SIZE;
+      final int delta = copyNibbles << LOG_HALF_SIZE;
+      Utils.copyBytes(data, pos, s.byteBuffer, readOffset, readOffset + delta);
+      pos += delta;
+      len -= delta;
+      s.halfOffset += copyNibbles;
+    }
+    if (len == 0) {
+      return BROTLI_OK;
+    }
+
+    // Read tail bytes.
+    if (halfAvailable(s) > 0) {
+      // length = 1..3
+      fillBitWindow(s);
+      while (len != 0) {
+        data[pos++] = (byte) peekBits(s);
+        s.bitOffset += 8;
+        len--;
+      }
+      return checkHealth(s, 0);
+    }
+
+    // Now it is possible to copy bytes directly.
+    while (len > 0) {
+      final int chunkLen = Utils.readInput(s, data, pos, len);
+      if (chunkLen < BROTLI_ERROR) {
+        return chunkLen;
+      }
+      // EOF is -1 in Java, but 0 in C#.
+      if (chunkLen <= 0) {
+        return Utils.makeError(s, BROTLI_ERROR_TRUNCATED_INPUT);
+      }
+      pos += chunkLen;
+      len -= chunkLen;
+    }
+    return BROTLI_OK;
+  }
+
+  /**
+   * Translates bytes to halves (int/short).
+   */
+  static void bytesToNibbles(State s, int byteLen) {
+    final byte[] byteBuffer = s.byteBuffer;
+    final int halfLen = byteLen >> LOG_HALF_SIZE;
+    if (BITNESS == 64) {
+      final int[] intBuffer = s.intBuffer;
+      for (int i = 0; i < halfLen; ++i) {
+        intBuffer[i] = ((int) byteBuffer[i * 4] & 0xFF)
+            | (((int) byteBuffer[(i * 4) + 1] & 0xFF) << 8)
+            | (((int) byteBuffer[(i * 4) + 2] & 0xFF) << 16)
+            | (((int) byteBuffer[(i * 4) + 3] & 0xFF) << 24);
+      }
+    } else {
+      final short[] shortBuffer = s.shortBuffer;
+      for (int i = 0; i < halfLen; ++i) {
+        shortBuffer[i] = (short) (((int) byteBuffer[i * 2] & 0xFF)
+            | (((int) byteBuffer[(i * 2) + 1] & 0xFF) << 8));
+      }
+    }
+  }
+}

package/android/src/main/java/com/hotupdater/vendor/brotli/dec/BrotliError.java

@@ -0,0 +1,47 @@
+/* Copyright 2025 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
+package com.hotupdater.vendor.brotli.dec;
+
+/**
+ * Possible errors from decoder.
+ */
+public class BrotliError {
+  public static final int BROTLI_OK = 0;
+  public static final int BROTLI_OK_DONE = BROTLI_OK + 1;
+  public static final int BROTLI_OK_NEED_MORE_OUTPUT = BROTLI_OK + 2;
+
+  // It is important that actual error codes are LESS than -1!
+  public static final int BROTLI_ERROR = -1;
+  public static final int BROTLI_ERROR_CORRUPTED_CODE_LENGTH_TABLE = BROTLI_ERROR - 1;
+  public static final int BROTLI_ERROR_CORRUPTED_CONTEXT_MAP = BROTLI_ERROR - 2;
+  public static final int BROTLI_ERROR_CORRUPTED_HUFFMAN_CODE_HISTOGRAM = BROTLI_ERROR - 3;
+  public static final int BROTLI_ERROR_CORRUPTED_PADDING_BITS = BROTLI_ERROR - 4;
+  public static final int BROTLI_ERROR_CORRUPTED_RESERVED_BIT = BROTLI_ERROR - 5;
+  public static final int BROTLI_ERROR_DUPLICATE_SIMPLE_HUFFMAN_SYMBOL = BROTLI_ERROR - 6;
+  public static final int BROTLI_ERROR_EXUBERANT_NIBBLE = BROTLI_ERROR - 7;
+  public static final int BROTLI_ERROR_INVALID_BACKWARD_REFERENCE = BROTLI_ERROR - 8;
+  public static final int BROTLI_ERROR_INVALID_METABLOCK_LENGTH = BROTLI_ERROR - 9;
+  public static final int BROTLI_ERROR_INVALID_WINDOW_BITS = BROTLI_ERROR - 10;
+  public static final int BROTLI_ERROR_NEGATIVE_DISTANCE = BROTLI_ERROR - 11;
+  public static final int BROTLI_ERROR_READ_AFTER_END = BROTLI_ERROR - 12;
+  public static final int BROTLI_ERROR_READ_FAILED = BROTLI_ERROR - 13;
+  public static final int BROTLI_ERROR_SYMBOL_OUT_OF_RANGE = BROTLI_ERROR - 14;
+  public static final int BROTLI_ERROR_TRUNCATED_INPUT = BROTLI_ERROR - 15;
+  public static final int BROTLI_ERROR_UNUSED_BYTES_AFTER_END = BROTLI_ERROR - 16;
+  public static final int BROTLI_ERROR_UNUSED_HUFFMAN_SPACE = BROTLI_ERROR - 17;
+
+  public static final int BROTLI_PANIC = -21;
+  public static final int BROTLI_PANIC_ALREADY_CLOSED = BROTLI_PANIC - 1;
+  public static final int BROTLI_PANIC_MAX_DISTANCE_TOO_SMALL = BROTLI_PANIC - 2;
+  public static final int BROTLI_PANIC_STATE_NOT_FRESH = BROTLI_PANIC - 3;
+  public static final int BROTLI_PANIC_STATE_NOT_INITIALIZED = BROTLI_PANIC - 4;
+  public static final int BROTLI_PANIC_STATE_NOT_UNINITIALIZED = BROTLI_PANIC - 5;
+  public static final int BROTLI_PANIC_TOO_MANY_DICTIONARY_CHUNKS = BROTLI_PANIC - 6;
+  public static final int BROTLI_PANIC_UNEXPECTED_STATE = BROTLI_PANIC - 7;
+  public static final int BROTLI_PANIC_UNREACHABLE = BROTLI_PANIC - 8;
+  public static final int BROTLI_PANIC_UNALIGNED_COPY_BYTES = BROTLI_PANIC - 9;
+}

package/android/src/main/java/com/hotupdater/vendor/brotli/dec/BrotliInputStream.java

@@ -0,0 +1,174 @@
+/* Copyright 2015 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
+package com.hotupdater.vendor.brotli.dec;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * {@link InputStream} decorator that decompresses brotli data.
+ *
+ * <p> Not thread-safe.
+ */
+public class BrotliInputStream extends InputStream {
+
+  public static final int DEFAULT_INTERNAL_BUFFER_SIZE = 256;
+
+  /**
+   * Value expected by InputStream contract when stream is over.
+   *
+   * In Java it is -1.
+   * In C# it is 0 (should be patched during transpilation).
+   */
+  private static final int END_OF_STREAM_MARKER = -1;
+
+  /**
+   * Internal buffer used for efficient byte-by-byte reading.
+   */
+  private byte[] buffer;
+
+  /**
+   * Number of decoded but still unused bytes in internal buffer.
+   */
+  private int remainingBufferBytes;
+
+  /**
+   * Next unused byte offset.
+   */
+  private int bufferOffset;
+
+  /**
+   * Decoder state.
+   */
+  private final State state = new State();
+
+  /**
+   * Creates a {@link InputStream} wrapper that decompresses brotli data.
+   *
+   * <p> For byte-by-byte reading ({@link #read()}) internal buffer with
+   * {@link #DEFAULT_INTERNAL_BUFFER_SIZE} size is allocated and used.
+   *
+   * <p> Will block the thread until first {@link BitReader#CAPACITY} bytes of data of source
+   * are available.
+   *
+   * @param source underlying data source
+   * @throws IOException in case of corrupted data or source stream problems
+   */
+  public BrotliInputStream(InputStream source) throws IOException {
+    this(source, DEFAULT_INTERNAL_BUFFER_SIZE);
+  }
+
+  /**
+   * Creates a {@link InputStream} wrapper that decompresses brotli data.
+   *
+   * <p> For byte-by-byte reading ({@link #read()}) internal buffer of specified size is
+   * allocated and used.
+   *
+   * <p> Will block the thread until first {@link BitReader#CAPACITY} bytes of data of source
+   * are available.
+   *
+   * @param source compressed data source
+   * @param byteReadBufferSize size of internal buffer used in case of
+   *        byte-by-byte reading
+   * @throws IOException in case of corrupted data or source stream problems
+   */
+  public BrotliInputStream(InputStream source, int byteReadBufferSize) throws IOException {
+    if (byteReadBufferSize <= 0) {
+      throw new IllegalArgumentException("Bad buffer size:" + byteReadBufferSize);
+    } else if (source == null) {
+      throw new IllegalArgumentException("source is null");
+    }
+    this.buffer = new byte[byteReadBufferSize];
+    this.remainingBufferBytes = 0;
+    this.bufferOffset = 0;
+    try {
+      state.input = source;
+      Decode.initState(state);
+    } catch (BrotliRuntimeException ex) {
+      throw new IOException("Brotli decoder initialization failed", ex);
+    }
+  }
+
+  public void attachDictionaryChunk(byte[] data) {
+    Decode.attachDictionaryChunk(state, data);
+  }
+
+  public void enableEagerOutput() {
+    Decode.enableEagerOutput(state);
+  }
+
+  public void enableLargeWindow() {
+    Decode.enableLargeWindow(state);
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  @Override
+  public void close() throws IOException {
+    Decode.close(state);
+    Utils.closeInput(state);
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  @Override
+  public int read() throws IOException {
+    if (bufferOffset >= remainingBufferBytes) {
+      remainingBufferBytes = read(buffer, 0, buffer.length);
+      bufferOffset = 0;
+      if (remainingBufferBytes == END_OF_STREAM_MARKER) {
+        // Both Java and C# return the same value for EOF on single-byte read.
+        return -1;
+      }
+    }
+    return buffer[bufferOffset++] & 0xFF;
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  @Override
+  public int read(byte[] destBuffer, int destOffset, int destLen) throws IOException {
+    if (destOffset < 0) {
+      throw new IllegalArgumentException("Bad offset: " + destOffset);
+    } else if (destLen < 0) {
+      throw new IllegalArgumentException("Bad length: " + destLen);
+    } else if (destOffset + destLen > destBuffer.length) {
+      throw new IllegalArgumentException(
+          "Buffer overflow: " + (destOffset + destLen) + " > " + destBuffer.length);
+    } else if (destLen == 0) {
+      return 0;
+    }
+    int copyLen = Math.max(remainingBufferBytes - bufferOffset, 0);
+    if (copyLen != 0) {
+      copyLen = Math.min(copyLen, destLen);
+      System.arraycopy(buffer, bufferOffset, destBuffer, destOffset, copyLen);
+      bufferOffset += copyLen;
+      destOffset += copyLen;
+      destLen -= copyLen;
+      if (destLen == 0) {
+        return copyLen;
+      }
+    }
+    try {
+      state.output = destBuffer;
+      state.outputOffset = destOffset;
+      state.outputLength = destLen;
+      state.outputUsed = 0;
+      Decode.decompress(state);
+      copyLen += state.outputUsed;
+      copyLen = (copyLen > 0) ? copyLen : END_OF_STREAM_MARKER;
+      return copyLen;
+    } catch (BrotliRuntimeException ex) {
+      throw new IOException("Brotli stream decoding failed", ex);
+    }
+
+    // <{[INJECTED CODE]}>
+  }
+}

package/android/src/main/java/com/hotupdater/vendor/brotli/dec/BrotliRuntimeException.java

@@ -0,0 +1,21 @@
+/* Copyright 2015 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
+package com.hotupdater.vendor.brotli.dec;
+
+/**
+ * Unchecked exception used internally.
+ */
+class BrotliRuntimeException extends RuntimeException {
+
+  BrotliRuntimeException(String message) {
+    super(message);
+  }
+
+  BrotliRuntimeException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}

package/android/src/main/java/com/hotupdater/vendor/brotli/dec/Context.java

@@ -0,0 +1,58 @@
+/* Copyright 2015 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
+package com.hotupdater.vendor.brotli.dec;
+
+/**
+ * Common context lookup table for all context modes.
+ */
+final class Context {
+
+  static final int[] LOOKUP = new int[2048];
+
+  private static final String UTF_MAP = "         !!  !                  \"#$##%#$&'##(#)#+++++++++"
+      + "+((&*'##,---,---,-----,-----,-----&#'###.///.///./////./////./////&#'# ";
+  private static final String UTF_RLE = "A/*  ':  & : $  \u0081 @";
+
+  private static void unpackLookupTable(int[] lookup, String utfMap, String utfRle) {
+    // LSB6, MSB6, SIGNED
+    for (int i = 0; i < 256; ++i) {
+      lookup[i] = i & 0x3F;
+      lookup[512 + i] = i >> 2;
+      lookup[1792 + i] = 2 + (i >> 6);
+    }
+    // UTF8
+    for (int i = 0; i < 128; ++i) {
+      lookup[1024 + i] = 4 * ((int) utfMap.charAt(i) - 32);
+    }
+    for (int i = 0; i < 64; ++i) {
+      lookup[1152 + i] = i & 1;
+      lookup[1216 + i] = 2 + (i & 1);
+    }
+    int offset = 1280;
+    for (int k = 0; k < 19; ++k) {
+      final int value = k & 3;
+      final int rep = (int) utfRle.charAt(k) - 32;
+      for (int i = 0; i < rep; ++i) {
+        lookup[offset++] = value;
+      }
+    }
+    // SIGNED
+    for (int i = 0; i < 16; ++i) {
+      lookup[1792 + i] = 1;
+      lookup[2032 + i] = 6;
+    }
+    lookup[1792] = 0;
+    lookup[2047] = 7;
+    for (int i = 0; i < 256; ++i) {
+      lookup[1536 + i] = lookup[1792 + i] << 3;
+    }
+  }
+
+  static {
+    unpackLookupTable(LOOKUP, UTF_MAP, UTF_RLE);
+  }
+}