docs: function NamePath(base, pathName, skipArray) {
    this.base = base;
    this.name = pathName;
  
    if (base instanceof NamePath) {
      base = base.tail;
    }
  
    const path = (this.path = pathName.length ? pathName.split('.') : []),
      plen = path.length,
      pathFields = (this.fields = new Array(plen));
  
    let at = base;
  
    let pi = 0,
      denormal;
  
    nextPath: while (pi < plen) {
      const name = path[pi];
      let def = at.def;
  
      if (name === '_') {
        if (!at.of) {
          throw new Error(`"${name}" in "${pathName}" is not an array or map.`);
        }
  
        at = at.of;
        pathFields[pi++] = at;
        continue nextPath;
      }
  
      if (
        name.match(NamePath._numberRegex) &&
        pi &&
        pathFields[pi - 1].type.name === 'array'
      ) {
        at = at.of;
        pathFields[pi++] = at;
        continue nextPath;
      }
  
      if (!at.fields) {
        const aAt = NamePath._skipArray(at);
  
        if (aAt && aAt.fields && aAt.fields[name]) {
          at = aAt;
          def = at.def;
        } else {
          if (!def.keys) {
            throw new Error(
              `"${name}" in "${pathName}" is not valid` +
                (at.link ? '" (maybe need advanced population syntax)' : '')
            );
          }
        }
      }
  
      const f = at.fields;
      if ((!f || !f[name]) && def.keys) {
        at = at.of;
        pathFields[pi++] = at;
        continue nextPath;
      }
  
      const parentAt = at;
      at = f[name];
      if (!at && /.+[$_]$/.test(name)) {
        const _name = name.substring(0, name.length - 1);
  
        while (/* if */ _name) {
          const _at = parentAt.fields[_name];
          if (!_at) {
            throw new Error(`"${_name}" in "${pathName}" is not a valid field.`);
          }
  
          const denormalization = name.endsWith('_');
  
          if (denormalization) {
            if (!denormal) {
              denormal = _at.def.denormal;
              if (!denormal) {
                break;
              }
            } else {
              if (!denormal[_name]) {
                break;
              }
  
              denormal = denormal[_name];
            }
          } else {
            denormal = null;
          }
  
          at = _at;
          pathFields[pi++] = at;
          at = at.link;
          continue nextPath;
        }
      }
  
      if (skipArray && (pi + 1 >= plen || path[pi + 1] !== '_')) {
        at = NamePath._skipArray(at);
      }
  
      if (!at) {
        throw new Error(
          `Cannot find field "${this.pathName(
            pi
          )}" in path "${base.toString()}::${this.name}"`
        );
      }
  
      pathFields[pi++] = at;
    }
  }