function transformDictionaryWord(dst, dstOffset, src, srcOffset, len, transforms, transformIndex) {
    let /** @type{number} */ offset = dstOffset;
    let /** @type{!Int32Array} */ triplets = transforms.triplets;
    let /** @type{!Int8Array} */ prefixSuffixStorage = transforms.prefixSuffixStorage;
    let /** @type{!Int32Array} */ prefixSuffixHeads = transforms.prefixSuffixHeads;
    let /** @type{number} */ transformOffset = 3 * transformIndex;
    let /** @type{number} */ prefixIdx = triplets[transformOffset];
    let /** @type{number} */ transformType = triplets[transformOffset + 1];
    let /** @type{number} */ suffixIdx = triplets[transformOffset + 2];
    let /** @type{number} */ prefix = prefixSuffixHeads[prefixIdx];
    let /** @type{number} */ prefixEnd = prefixSuffixHeads[prefixIdx + 1];
    let /** @type{number} */ suffix = prefixSuffixHeads[suffixIdx];
    let /** @type{number} */ suffixEnd = prefixSuffixHeads[suffixIdx + 1];
    let /** @type{number} */ omitFirst = transformType - 11;
    let /** @type{number} */ omitLast = transformType - 0;
    if (omitFirst < 1 || omitFirst > 9) {
      omitFirst = 0;
    }
    if (omitLast < 1 || omitLast > 9) {
      omitLast = 0;
    }
    while (prefix != prefixEnd) {
      dst[offset++] = prefixSuffixStorage[prefix++];
    }
    if (omitFirst > len) {
      omitFirst = len;
    }
    srcOffset += omitFirst;
    len -= omitFirst;
    len -= omitLast;
    let /** @type{number} */ i = len;
    while (i > 0) {
      dst[offset++] = src[srcOffset++];
      i--;
    }
    if (transformType == 10 || transformType == 11) {
      let /** @type{number} */ uppercaseOffset = offset - len;
      if (transformType == 10) {
        len = 1;
      }
      while (len > 0) {
        let /** @type{number} */ c0 = dst[uppercaseOffset] & 0xFF;
        if (c0 < 0xC0) {
          if (c0 >= 97 && c0 <= 122) {
            dst[uppercaseOffset] ^= 32;
          }
          uppercaseOffset += 1;
          len -= 1;
        } else if (c0 < 0xE0) {
          dst[uppercaseOffset + 1] ^= 32;
          uppercaseOffset += 2;
          len -= 2;
        } else {
          dst[uppercaseOffset + 2] ^= 5;
          uppercaseOffset += 3;
          len -= 3;
        }
      }
    } else if (transformType == 21 || transformType == 22) {
      let /** @type{number} */ shiftOffset = offset - len;
      let /** @type{number} */ param = transforms.params[transformIndex];
      let /** @type{number} */ scalar = (param & 0x7FFF) + (0x1000000 - (param & 0x8000));
      while (len > 0) {
        let /** @type{number} */ step = 1;
        let /** @type{number} */ c0 = dst[shiftOffset] & 0xFF;
        if (c0 < 0x80) {
          scalar += c0;
          dst[shiftOffset] = (scalar & 0x7F);
        } else if (c0 < 0xC0) {
        } else if (c0 < 0xE0) {
          if (len >= 2) {
            let /** @type{number} */ c1 = dst[shiftOffset + 1];
            scalar += (c1 & 0x3F) | ((c0 & 0x1F) << 6);
            dst[shiftOffset] = (0xC0 | ((scalar >> 6) & 0x1F));
            dst[shiftOffset + 1] = ((c1 & 0xC0) | (scalar & 0x3F));
            step = 2;
          } else {
            step = len;
          }
        } else if (c0 < 0xF0) {
          if (len >= 3) {
            let /** @type{number} */ c1 = dst[shiftOffset + 1];
            let /** @type{number} */ c2 = dst[shiftOffset + 2];
            scalar += (c2 & 0x3F) | ((c1 & 0x3F) << 6) | ((c0 & 0x0F) << 12);
            dst[shiftOffset] = (0xE0 | ((scalar >> 12) & 0x0F));
            dst[shiftOffset + 1] = ((c1 & 0xC0) | ((scalar >> 6) & 0x3F));
            dst[shiftOffset + 2] = ((c2 & 0xC0) | (scalar & 0x3F));
            step = 3;
          } else {
            step = len;
          }
        } else if (c0 < 0xF8) {
          if (len >= 4) {
            let /** @type{number} */ c1 = dst[shiftOffset + 1];
            let /** @type{number} */ c2 = dst[shiftOffset + 2];
            let /** @type{number} */ c3 = dst[shiftOffset + 3];
            scalar += (c3 & 0x3F) | ((c2 & 0x3F) << 6) | ((c1 & 0x3F) << 12) | ((c0 & 0x07) << 18);
            dst[shiftOffset] = (0xF0 | ((scalar >> 18) & 0x07));
            dst[shiftOffset + 1] = ((c1 & 0xC0) | ((scalar >> 12) & 0x3F));
            dst[shiftOffset + 2] = ((c2 & 0xC0) | ((scalar >> 6) & 0x3F));
            dst[shiftOffset + 3] = ((c3 & 0xC0) | (scalar & 0x3F));
            step = 4;
          } else {
            step = len;
          }
        }
        shiftOffset += step;
        len -= step;
        if (transformType == 21) {
          len = 0;
        }
      }
    }
    while (suffix != suffixEnd) {
      dst[offset++] = prefixSuffixStorage[suffix++];
    }
    return offset - dstOffset;
  }
@param {!Int8Array} dst
@param {number} dstOffset
@param {!Int8Array} src
@param {number} srcOffset
@param {number} len
@param {!Transforms} transforms
@param {number} transformIndex
@return {number}