Method performEncode

src/Encoder/TrifidCipher.js:59–118

* Performs encode on given content. * @protected * @param {Chain} content * @return {number[]|string|Uint8Array|Chain} Encoded content

(content)

   * @return {number[]|string|Uint8Array|Chain} Encoded content
   */
  async performEncode (content) {
    const { key, groupSize } = this.getSettingValues()

    // Derive mixed-alphabet from key
    const alphabet = Chain.wrap(key).extend(baseAlphabet).getCodePoints()

    // Map Unicode code points to their respective alphabet positions
    const positions =
      content.toLowerCase().getCodePoints()
        .map(codePoint => alphabet.indexOf(codePoint))
        .filter(codePoint => codePoint !== -1)

    // Delastelle says: 'We start by writing vertically under each letter, the
    // numerical trigram that corresponds to it in the enciphering alphabet'
    // a i d e t   o i l e c
    // 1 1 1 1 2   3 1 1 1 2
    // 3 2 3 1 1   1 2 1 1 2
    // 1 1 3 2 2   1 1 3 2 1

    // Thus working with a one-dimensional array to represent the above table
    // we enumerate coordinates like this:
    // a  i  d  e  t    o  i  l  e  c
    // 01 02 03 04 05   21 22 23 24 25
    // 06 07 08 09 10   26 27 28 29 30
    // 11 12 13 14 15   31 32 33 34 35
    // 16 17 18 19 20   36 37 38 39 40
    const length = positions.length
    const table = new Array(length * 3)
    let i, j, coordinates, group, index, size

    for (i = 0; i < length; i++) {
      // Gather group number, character index inside group and group size, which
      // may be shorter for the last group
      group = Math.floor(i / groupSize)
      index = i - group * groupSize
      size = Math.min(groupSize, length - group * groupSize)

      // Position group coordinates vertically inside the one-dimensional table
      coordinates = this.cartesianCoordinatesFromIndex(positions[i])
      for (j = 0; j < 3; j++) {
        table[index + group * groupSize * 3 + size * j] = coordinates[j]
      }
    }

    // Following Delastelle: 'Proceeding horizontally as if the numbers were
    // written on a single line, we take groups of three numbers, look them up
    // in the deciphering alphabet'
    // Having built a one-dimensional array, we read 3-element cartesian
    // coordinates successively, translate them to one-dimensional indexes and
    // map each of them to the corresponding alphabet character
    const result = new Array(length)

    for (i = 0; i < length; i++) {
      coordinates = table.slice(i * 3, (i + 1) * 3)
      index = this.indexFromCartesianCoordinates(coordinates)
      result[i] = alphabet[index]
    }