@hot-updater/react-native 1.0.8 → 1.1.0

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

@@ -0,0 +1,143 @@
+/* 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;
+
+/**
+ * Utilities for building Huffman decoding tables.
+ */
+final class Huffman {
+
+  private static final int MAX_LENGTH = 15;
+
+  /**
+   * Returns reverse(reverse(key, len) + 1, len).
+   *
+   * <p> reverse(key, len) is the bit-wise reversal of the len least significant bits of key.
+   */
+  private static int getNextKey(int key, int len) {
+    int step = 1 << (len - 1);
+    while ((key & step) != 0) {
+      step = step >> 1;
+    }
+    return (key & (step - 1)) + step;
+  }
+
+  /**
+   * Stores {@code item} in {@code table[0], table[step], table[2 * step] .., table[end]}.
+   *
+   * <p> Assumes that end is an integer multiple of step.
+   */
+  private static void replicateValue(int[] table, int offset, int step, int end, int item) {
+    int pos = end;
+    while (pos > 0) {
+      pos -= step;
+      table[offset + pos] = item;
+    }
+  }
+
+  /**
+   * @param count histogram of bit lengths for the remaining symbols,
+   * @param len code length of the next processed symbol.
+   * @return table width of the next 2nd level table.
+   */
+  private static int nextTableBitSize(int[] count, int len, int rootBits) {
+    int bits = len;
+    int left = 1 << (bits - rootBits);
+    while (bits < MAX_LENGTH) {
+      left -= count[bits];
+      if (left <= 0) {
+        break;
+      }
+      bits++;
+      left = left << 1;
+    }
+    return bits - rootBits;
+  }
+
+  /**
+   * Builds Huffman lookup table assuming code lengths are in symbol order.
+   *
+   * @return number of slots used by resulting Huffman table
+   */
+  static int buildHuffmanTable(int[] tableGroup, int tableIdx, int rootBits, int[] codeLengths,
+      int codeLengthsSize) {
+    final int tableOffset = tableGroup[tableIdx];
+    final int[] sorted = new int[codeLengthsSize]; // Symbols sorted by code length.
+    // TODO(eustas): fill with zeroes?
+    final int[] count = new int[MAX_LENGTH + 1]; // Number of codes of each length.
+    final int[] offset = new int[MAX_LENGTH + 1]; // Offsets in sorted table for each length.
+
+    // Build histogram of code lengths.
+    for (int sym = 0; sym < codeLengthsSize; ++sym) {
+      count[codeLengths[sym]]++;
+    }
+
+    // Generate offsets into sorted symbol table by code length.
+    offset[1] = 0;
+    for (int len = 1; len < MAX_LENGTH; ++len) {
+      offset[len + 1] = offset[len] + count[len];
+    }
+
+    // Sort symbols by length, by symbol order within each length.
+    for (int sym = 0; sym < codeLengthsSize; ++sym) {
+      if (codeLengths[sym] != 0) {
+        sorted[offset[codeLengths[sym]]++] = sym;
+      }
+    }
+
+    int tableBits = rootBits;
+    int tableSize = 1 << tableBits;
+    int totalSize = tableSize;
+
+    // Special case code with only one value.
+    if (offset[MAX_LENGTH] == 1) {
+      for (int k = 0; k < totalSize; ++k) {
+        tableGroup[tableOffset + k] = sorted[0];
+      }
+      return totalSize;
+    }
+
+    // Fill in root table.
+    int key = 0;  // Reversed prefix code.
+    int symbol = 0;
+    int step = 1;
+    for (int len = 1; len <= rootBits; ++len) {
+      step = step << 1;
+      while (count[len] > 0) {
+        replicateValue(tableGroup, tableOffset + key, step, tableSize,
+            len << 16 | sorted[symbol++]);
+        key = getNextKey(key, len);
+        count[len]--;
+      }
+    }
+
+    // Fill in 2nd level tables and add pointers to root table.
+    final int mask = totalSize - 1;
+    int low = -1;
+    int currentOffset = tableOffset;
+    step = 1;
+    for (int len = rootBits + 1; len <= MAX_LENGTH; ++len) {
+      step = step << 1;
+      while (count[len] > 0) {
+        if ((key & mask) != low) {
+          currentOffset += tableSize;
+          tableBits = nextTableBitSize(count, len, rootBits);
+          tableSize = 1 << tableBits;
+          totalSize += tableSize;
+          low = key & mask;
+          tableGroup[tableOffset + low] =
+              (tableBits + rootBits) << 16 | (currentOffset - tableOffset - low);
+        }
+        replicateValue(tableGroup, currentOffset + (key >> rootBits), step, tableSize,
+            (len - rootBits) << 16 | sorted[symbol++]);
+        key = getNextKey(key, len);
+        count[len]--;
+      }
+    }
+    return totalSize;
+  }
+}

package/{LICENSE → android/src/main/java/com/hotupdater/vendor/brotli/dec/LICENSE}

@@ -1,6 +1,4 @@
-MIT License
-
-Copyright (c) 2023 Sungyu Kang 
+Copyright (c) 2009, 2010, 2013-2016 by the Brotli Authors.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -9,25 +7,13 @@ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
----
-
-ADDITIONAL DISCLAIMER
-
-The authors of this software shall not be held responsible for any legal issues,
-regulatory violations, policy violations, or disputes arising from the use,
-distribution, or integration of this software.
-
-Users are solely responsible for ensuring compliance with all applicable laws,
-regulations, and third-party policies (including but not limited to app store
-policies).
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

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

@@ -0,0 +1,39 @@
+# Vendored Brotli decoder
+
+These files are the Java Brotli decoder from
+[google/brotli v1.2.0](https://github.com/google/brotli/tree/v1.2.0/java/org/brotli/dec)
+(commit [028fb5a](https://github.com/google/brotli/commit/028fb5a23661f123017c060daa546b55cf4bde29)),
+under its MIT license in [LICENSE](LICENSE).
+
+**Why vendored:** the official `org.brotli:dec` package on Maven Central is
+stuck at v0.1.2 (May 2017), which has known vulnerabilities. v1.2.0 fixes them:
+
+- CVE-2020-8927: buffer overflow in Brotli versions before 1.0.8
+- CVE-2025-6176: denial of service in versions up to 1.1.0
+
+**Why sources, not a jar:** the decoder compiles into Hot Updater's own classes.
+Tools that merge a React Native app and its native modules into one AAR, such as
+React Native Brownfield's Gradle plugin, keep each module's classes but drop the
+jars a module depends on through `files(...)`.
+
+**Changes from upstream:** only the package. `package org.brotli.dec;` and
+`import static org.brotli.dec.` became `com.hotupdater.vendor.brotli.dec`, so
+Hot Updater's decoder never clashes with an app's own `org.brotli:dec`. The
+test files, `BUILD.bazel`, `pom.xml`, and the Kotlin port are not included.
+
+`proguard-rules.pro` keeps `com.hotupdater.vendor.brotli.**`: `Dictionary` loads
+`DictionaryData` by name.
+
+**Update:** copy the non-test `java/org/brotli/dec/*.java` files of the new
+release, rewrite the package lines as above, and update the version, commit,
+and CVE notes here.
+
+```bash
+git clone --depth 1 --branch <tag> https://github.com/google/brotli.git
+for f in brotli/java/org/brotli/dec/*.java; do
+  case "$f" in *Test.java|*TestUtils.java) continue ;; esac
+  sed -e 's/^package org\.brotli\.dec;/package com.hotupdater.vendor.brotli.dec;/' \
+    -e 's/^import static org\.brotli\.dec\./import static com.hotupdater.vendor.brotli.dec./' \
+    "$f" > "$(basename "$f")"
+done
+```

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

@@ -0,0 +1,100 @@
+/* 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.InputStream;
+
+final class State {
+  byte[] ringBuffer;
+  byte[] contextModes;
+  byte[] contextMap;
+  byte[] distContextMap;
+  byte[] distExtraBits;
+  byte[] output;
+  byte[] byteBuffer;  // BitReader
+
+  short[] shortBuffer; // BitReader
+
+  int[] intBuffer;  // BitReader
+  int[] rings;
+  int[] blockTrees;
+  int[] literalTreeGroup;
+  int[] commandTreeGroup;
+  int[] distanceTreeGroup;
+  int[] distOffset;
+
+  long accumulator64;  // BitReader: pre-fetched bits.
+
+  int runningState;  // Default value is 0 == Decode.UNINITIALIZED
+  int nextRunningState;
+  int accumulator32;  // BitReader: pre-fetched bits.
+  int bitOffset;  // BitReader: bit-reading position in accumulator.
+  int halfOffset;  // BitReader: offset of next item in intBuffer/shortBuffer.
+  int tailBytes;  // BitReader: number of bytes in unfinished half.
+  int endOfStreamReached;  // BitReader: input stream is finished.
+  int metaBlockLength;
+  int inputEnd;
+  int isUncompressed;
+  int isMetadata;
+  int literalBlockLength;
+  int numLiteralBlockTypes;
+  int commandBlockLength;
+  int numCommandBlockTypes;
+  int distanceBlockLength;
+  int numDistanceBlockTypes;
+  int pos;
+  int maxDistance;
+  int distRbIdx;
+  int trivialLiteralContext;
+  int literalTreeIdx;
+  int commandTreeIdx;
+  int j;
+  int insertLength;
+  int contextMapSlice;
+  int distContextMapSlice;
+  int contextLookupOffset1;
+  int contextLookupOffset2;
+  int distanceCode;
+  int numDirectDistanceCodes;
+  int distancePostfixBits;
+  int distance;
+  int copyLength;
+  int maxBackwardDistance;
+  int maxRingBufferSize;
+  int ringBufferSize;
+  int expectedTotalSize;
+  int outputOffset;
+  int outputLength;
+  int outputUsed;
+  int ringBufferBytesWritten;
+  int ringBufferBytesReady;
+  int isEager;
+  int isLargeWindow;
+
+  // Compound dictionary
+  int cdNumChunks;
+  int cdTotalSize;
+  int cdBrIndex;
+  int cdBrOffset;
+  int cdBrLength;
+  int cdBrCopied;
+  byte[][] cdChunks;
+  int[] cdChunkOffsets;
+  int cdBlockBits;
+  byte[] cdBlockMap;
+
+  InputStream input = Utils.makeEmptyInput();  // BitReader
+
+  State() {
+    this.ringBuffer = new byte[0];
+    this.rings = new int[10];
+    this.rings[0] = 16;
+    this.rings[1] = 15;
+    this.rings[2] = 11;
+    this.rings[3] = 4;
+  }
+}

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

@@ -0,0 +1,240 @@
+/* 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.nio.ByteBuffer;
+
+/**
+ * Transformations on dictionary words.
+ *
+ * Transform descriptor is a triplet: {prefix, operator, suffix}.
+ * "prefix" and "suffix" are short strings inserted before and after transformed dictionary word.
+ * "operator" is applied to dictionary word itself.
+ *
+ * Some operators has "built-in" parameters, i.e. parameter is defined by operator ordinal. Other
+ * operators have "external" parameters, supplied via additional table encoded in shared dictionary.
+ *
+ * Operators:
+ *  - IDENTITY (0): dictionary word is inserted "as is"
+ *  - OMIT_LAST_N (1 - 9): last N octets of dictionary word are not inserted; N == ordinal
+ *  - OMIT_FIRST_M (12-20): first M octets of dictionary word are not inserted; M == ordinal - 11
+ *  - UPPERCASE_FIRST (10): first "scalar" is XOR'ed with number 32
+ *  - UPPERCASE_ALL (11): all "scalars" are XOR'ed with number 32
+ *  - SHIFT_FIRST (21): first "scalar" is shifted by number form parameter table
+ *  - SHIFT_ALL (22): all "scalar" is shifted by number form parameter table
+ *
+ * Here "scalar" is a variable length character coding similar to UTF-8 encoding.
+ * UPPERCASE_XXX / SHIFT_XXX operators were designed to change the case of UTF-8 encoded characters.
+ * While UPPERCASE_XXX works well only on ASCII charset, SHIFT is much more generic and could be
+ * used for most (all?) alphabets.
+ */
+final class Transform {
+
+  static final class Transforms {
+    final int numTransforms;
+    final int[] triplets;
+    final byte[] prefixSuffixStorage;
+    final int[] prefixSuffixHeads;
+    final short[] params;
+
+    Transforms(int numTransforms, int prefixSuffixLen, int prefixSuffixCount) {
+      this.numTransforms = numTransforms;
+      this.triplets = new int[numTransforms * 3];
+      this.params = new short[numTransforms];
+      this.prefixSuffixStorage = new byte[prefixSuffixLen];
+      this.prefixSuffixHeads = new int[prefixSuffixCount + 1];
+    }
+  }
+
+  static final int NUM_RFC_TRANSFORMS = 121;
+  static final Transforms RFC_TRANSFORMS = new Transforms(NUM_RFC_TRANSFORMS, 167, 50);
+
+  private static final int OMIT_FIRST_LAST_LIMIT = 9;
+
+  private static final int IDENTITY = 0;
+  private static final int OMIT_LAST_BASE = IDENTITY + 1 - 1;  // there is no OMIT_LAST_0.
+  private static final int UPPERCASE_FIRST = OMIT_LAST_BASE + OMIT_FIRST_LAST_LIMIT + 1;
+  private static final int UPPERCASE_ALL = UPPERCASE_FIRST + 1;
+  private static final int OMIT_FIRST_BASE = UPPERCASE_ALL + 1 - 1;  // there is no OMIT_FIRST_0.
+  private static final int SHIFT_FIRST = OMIT_FIRST_BASE + OMIT_FIRST_LAST_LIMIT + 1;
+  private static final int SHIFT_ALL = SHIFT_FIRST + 1;
+
+  // Bundle of 0-terminated strings.
+  // typo:off
+  private static final String PREFIX_SUFFIX_SRC = "# #s #, #e #.# the #.com/#\u00C2\u00A0# of # and"
+      + " # in # to #\"#\">#\n#]# for # a # that #. # with #'# from # by #. The # on # as # is #ing"
+      + " #\n\t#:#ed #(# at #ly #=\"# of the #. This #,# not #er #al #='#ful #ive #less #est #ize #"
+      + "ous #";
+  private static final String TRANSFORMS_SRC = "     !! ! ,  *!  &!  \" !  ) *   * -  ! # !  #!*!  "
+      + "+  ,$ !  -  %  .  / #   0  1 .  \"   2  3!*   4%  ! # /   5  6  7  8 0  1 &   $   9 +   : "
+      + " ;  < '  !=  >  ?! 4  @ 4  2  &   A *# (   B  C& ) %  ) !*# *-% A +! *.  D! %'  & E *6  F "
+      + " G% ! *A *%  H! D  I!+!  J!+   K +- *4! A  L!*4  M  N +6  O!*% +.! K *G  P +%(  ! G *D +D "
+      + " Q +# *K!*G!+D!+# +G +A +4!+% +K!+4!*D!+K!*K";
+  // typo:on
+
+  private static void unpackTransforms(byte[] prefixSuffix,
+      int[] prefixSuffixHeads, int[] transforms, String prefixSuffixSrc, String transformsSrc) {
+    final int[] prefixSuffixBytes = Utils.toUtf8Runes(prefixSuffixSrc); 
+    final int n = prefixSuffixBytes.length;
+    int index = 1;
+    int j = 0;
+    for (int i = 0; i < n; ++i) {
+      final int c = prefixSuffixBytes[i];
+      if (c == 35) { // == #
+        prefixSuffixHeads[index++] = j;
+      } else {
+        prefixSuffix[j++] = (byte) c;
+      }
+    }
+
+    for (int i = 0; i < NUM_RFC_TRANSFORMS * 3; ++i) {
+      transforms[i] = (int) transformsSrc.charAt(i) - 32;
+    }
+  }
+
+  static {
+    unpackTransforms(RFC_TRANSFORMS.prefixSuffixStorage, RFC_TRANSFORMS.prefixSuffixHeads,
+        RFC_TRANSFORMS.triplets, PREFIX_SUFFIX_SRC, TRANSFORMS_SRC);
+  }
+
+  static int transformDictionaryWord(byte[] dst, int dstOffset, ByteBuffer src, int srcOffset,
+      int wordLen, Transforms transforms, int transformIndex) {
+    int offset = dstOffset;
+    final int[] triplets = transforms.triplets;
+    final byte[] prefixSuffixStorage = transforms.prefixSuffixStorage;
+    final int[] prefixSuffixHeads = transforms.prefixSuffixHeads;
+    final int transformOffset = 3 * transformIndex;
+    final int prefixIdx = triplets[transformOffset];
+    final int transformType = triplets[transformOffset + 1];
+    final int suffixIdx = triplets[transformOffset + 2];
+    int prefix = prefixSuffixHeads[prefixIdx];
+    final int prefixEnd = prefixSuffixHeads[prefixIdx + 1];
+    int suffix = prefixSuffixHeads[suffixIdx];
+    final int suffixEnd = prefixSuffixHeads[suffixIdx + 1];
+
+    int omitFirst = transformType - OMIT_FIRST_BASE;
+    int omitLast = transformType - OMIT_LAST_BASE;
+    if (omitFirst < 1 || omitFirst > OMIT_FIRST_LAST_LIMIT) {
+      omitFirst = 0;
+    }
+    if (omitLast < 1 || omitLast > OMIT_FIRST_LAST_LIMIT) {
+      omitLast = 0;
+    }
+
+    // Copy prefix.
+    while (prefix != prefixEnd) {
+      dst[offset++] = prefixSuffixStorage[prefix++];
+    }
+
+    int len = wordLen;
+    // Copy trimmed word.
+    if (omitFirst > len) {
+      omitFirst = len;
+    }
+    int dictOffset = srcOffset + omitFirst;
+    len -= omitFirst;
+    len -= omitLast;
+    int i = len;
+    while (i > 0) {
+      dst[offset++] = src.get(dictOffset++);
+      i--;
+    }
+
+    // Ferment.
+    if (transformType == UPPERCASE_FIRST || transformType == UPPERCASE_ALL) {
+      int uppercaseOffset = offset - len;
+      if (transformType == UPPERCASE_FIRST) {
+        len = 1;
+      }
+      while (len > 0) {
+        final int c0 = (int) dst[uppercaseOffset] & 0xFF;
+        if (c0 < 0xC0) {
+          if (c0 >= 97 && c0 <= 122) { // in [a..z] range
+            dst[uppercaseOffset] = (byte) ((int) dst[uppercaseOffset] ^ 32);
+          }
+          uppercaseOffset += 1;
+          len -= 1;
+        } else if (c0 < 0xE0) {
+          dst[uppercaseOffset + 1] = (byte) ((int) dst[uppercaseOffset + 1] ^ 32);
+          uppercaseOffset += 2;
+          len -= 2;
+        } else {
+          dst[uppercaseOffset + 2] = (byte) ((int) dst[uppercaseOffset + 2] ^ 5);
+          uppercaseOffset += 3;
+          len -= 3;
+        }
+      }
+    } else if (transformType == SHIFT_FIRST || transformType == SHIFT_ALL) {
+      int shiftOffset = offset - len;
+      final int param = (int) transforms.params[transformIndex];
+      /* Limited sign extension: scalar < (1 << 24). */
+      int scalar = (param & 0x7FFF) + (0x1000000 - (param & 0x8000));
+      while (len > 0) {
+        int step = 1;
+        final int c0 = (int) dst[shiftOffset] & 0xFF;
+        if (c0 < 0x80) {
+          /* 1-byte rune / 0sssssss / 7 bit scalar (ASCII). */
+          scalar += c0;
+          dst[shiftOffset] = (byte) (scalar & 0x7F);
+        } else if (c0 < 0xC0) {
+          /* Continuation / 10AAAAAA. */
+        } else if (c0 < 0xE0) {
+          /* 2-byte rune / 110sssss AAssssss / 11 bit scalar. */
+          if (len >= 2) {
+            final int c1 = (int) dst[shiftOffset + 1];
+            scalar += (c1 & 0x3F) | ((c0 & 0x1F) << 6);
+            dst[shiftOffset] = (byte) (0xC0 | ((scalar >> 6) & 0x1F));
+            dst[shiftOffset + 1] = (byte) ((c1 & 0xC0) | (scalar & 0x3F));
+            step = 2;
+          } else {
+            step = len;
+          }
+        } else if (c0 < 0xF0) {
+          /* 3-byte rune / 1110ssss AAssssss BBssssss / 16 bit scalar. */
+          if (len >= 3) {
+            final int c1 = (int) dst[shiftOffset + 1];
+            final int c2 = (int) dst[shiftOffset + 2];
+            scalar += (c2 & 0x3F) | ((c1 & 0x3F) << 6) | ((c0 & 0x0F) << 12);
+            dst[shiftOffset] = (byte) (0xE0 | ((scalar >> 12) & 0x0F));
+            dst[shiftOffset + 1] = (byte) ((c1 & 0xC0) | ((scalar >> 6) & 0x3F));
+            dst[shiftOffset + 2] = (byte) ((c2 & 0xC0) | (scalar & 0x3F));
+            step = 3;
+          } else {
+            step = len;
+          }
+        } else if (c0 < 0xF8) {
+          /* 4-byte rune / 11110sss AAssssss BBssssss CCssssss / 21 bit scalar. */
+          if (len >= 4) {
+            final int c1 = (int) dst[shiftOffset + 1];
+            final int c2 = (int) dst[shiftOffset + 2];
+            final int c3 = (int) dst[shiftOffset + 3];
+            scalar += (c3 & 0x3F) | ((c2 & 0x3F) << 6) | ((c1 & 0x3F) << 12) | ((c0 & 0x07) << 18);
+            dst[shiftOffset] = (byte) (0xF0 | ((scalar >> 18) & 0x07));
+            dst[shiftOffset + 1] = (byte) ((c1 & 0xC0) | ((scalar >> 12) & 0x3F));
+            dst[shiftOffset + 2] = (byte) ((c2 & 0xC0) | ((scalar >> 6) & 0x3F));
+            dst[shiftOffset + 3] = (byte) ((c3 & 0xC0) | (scalar & 0x3F));
+            step = 4;
+          } else {
+            step = len;
+          }
+        }
+        shiftOffset += step;
+        len -= step;
+        if (transformType == SHIFT_FIRST) {
+          len = 0;
+        }
+      }
+    }
+
+    // Copy suffix.
+    while (suffix != suffixEnd) {
+      dst[offset++] = prefixSuffixStorage[suffix++];
+    }
+
+    return offset - dstOffset;
+  }
+}