Cómo escribir un analizador para construir el JavaScript AST MemberExpression para la expresión de una.b[c.d][e].f[g[h[i.j]]]?

Siguiendo a lo largo de las líneas de Cómo representan claramente un.b[c.d][e].f[g[h[i.j]]] como un árbol de objetos?, ¿cómo podría usted escribir un algoritmo para generar ese JS AST a partir de la expresión a.b[c.d][e].f[g[h[i.j]]]? Estoy tratando de escribir un analizador para generar algún tipo de estructura de objetos a partir de esta expresión (idealmente más intuitivo que el JS AST MemberExpression uno, de ahí que otra pregunta). Me gustaría ver cómo funciona el algoritmo para construir el JavaScript MemberExpression árbol.

Actualmente tengo este tipo de algoritmo para generar algún tipo de árbol (pero parece ser incorrectas en la actualidad):

const patterns = [
  [/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*/, 'name'],
  [/^\[/, 'open'],
  [/^\]/, 'close'],
  [/^\./, 'stem']
]

console.log(parsePath('a.b[c.d][e].f[g[h[i.j]]]'))

function parsePath(str) {
  let node
  let nest = []
  let result = nest
  let stack = [nest]
  while (str.length) {
    nest = stack[stack.length - 1]
    p:
    for (let pattern of patterns) {
      let match = str.match(pattern[0])
      if (match) {
        if (pattern[1] === 'name') {
          node = {
            form: `term`,
            name: match[0],
            link: []
          }
          nest.push(node)
        } else if (pattern[1] === 'stem') {
          stack.push(node.link)
        } else if (pattern[1] === 'open') {
          node = {
            form: 'read',
            link: []
          }
          nest.push(node)
          stack.push(node.link)
        } else if (pattern[1] === 'close') {
          stack.pop()
        }

        str = str.substr(match[0].length)
        break p
      }
    }
  }
  return result[0]
}

El resultado deseado es esta (o mejor, más intuitiva estructura de datos si usted está tan inclinado a crear uno):

{
  "type": "MemberExpression",
  "object": {
    "type": "MemberExpression",
    "object": {
      "type": "MemberExpression",
      "object": {
        "type": "MemberExpression",
        "object": {
          "type": "MemberExpression",
          "object": {
            "type": "Identifier",
            "name": "a"
          },
          "property": {
            "type": "Identifier",
            "name": "b"
          },
          "computed": false
        },
        "property": {
          "type": "MemberExpression",
          "object": {
            "type": "Identifier",
            "name": "c"
          },
          "property": {
            "type": "Identifier",
            "name": "d"
          },
          "computed": false
        },
        "computed": true
      },
      "property": {
        "type": "Identifier",
        "name": "e"
      },
      "computed": true
    },
    "property": {
      "type": "Identifier",
      "name": "f"
    },
    "computed": false
  },
  "property": {
    "type": "MemberExpression",
    "object": {
      "type": "Identifier",
      "name": "g"
    },
    "property": {
      "type": "MemberExpression",
      "object": {
        "type": "Identifier",
        "name": "h"
      },
      "property": {
        "type": "MemberExpression",
        "object": {
          "type": "Identifier",
          "name": "i"
        },
        "property": {
          "type": "Identifier",
          "name": "j"
        },
        "computed": false
      },
      "computed": true
    },
    "computed": true
  },
  "computed": true
}

La razón por la que estoy luchando (parcialmente) es que no me gusta este MemberExpression la estructura de árbol, es hacia atrás sentimiento, y no es muy intuitivo. Así que si usted puede construir una más simple, más sencilla estructura de datos que sería lo ideal (que era la otra pregunta), pero si no, entonces sólo un algoritmo para la construcción de esta me va.

Personalmente, prefiero intentar generar esta estructura, ya que me parece más intuitiva:

{
  type: 'site',
  site: [
    {
      type: 'term',
      term: 'a'
    },
    {
      type: 'term',
      term: 'b'
    },
    {
      type: 'sink',
      sink: [
        {
          type: 'term',
          term: 'c'
        },
        {
          type: 'term',
          term: 'd'
        }
      ]
    },
    {
      type: 'sink',
      sink: [
        {
          type: 'term',
          term: 'e'
        }
      ]
    },
    {
      type: 'term',
      term: 'f'
    },
    {
      type: 'sink',
      sink: [
        {
          type: 'term',
          term: 'g'
        },
        {
          type: 'sink',
          sink: [
            {
              type: 'term',
              term: 'h'
            },
            {
              type: 'sink',
              sink: [
                {
                  type: 'term',
                  term: 'i'
                },
                {
                  type: 'term',
                  term: 'j'
                }
              ]
            }
          ]
        }
      ]
    }
  ]
}

Pero uno de ellos me funciona (o ambos).

Si vamos con el segundo, mi siguiente problema será cómo convertir los datos a la estructura en la MemberExpression árbol/estructura de datos :) Pero voy a tratar de hacer que a mí primero. Así que probablemente sea mejor para la construcción de la MemberExpression en esta pregunta, entonces puedo trabajar fuera de eso.