Improve simple paths

src/config/normalize/lib/wild_wild_path/iterate.js

@@ -1,6 +1,6 @@
 import { groupBy } from '../../../../utils/group.js'
 
-import { equalsSimple, isSameToken } from './parsing/compare.js'
+import { fastEqualsSimple, isSameToken } from './parsing/compare.js'
 import { parse } from './parsing/parse.js'
 import { serialize } from './parsing/serialize.js'
 import { getObjectTokenType } from './tokens/main.js'
@@ -61,7 +61,7 @@ const isDuplicate = function (
   { simplePath: simplePathB, path: pathB },
 ) {
   return (
-    equalsSimple(simplePathA, simplePathB) &&
+    fastEqualsSimple(simplePathA, simplePathB) &&
     pathA.length === pathB.length &&
     pathA.every(
       (tokenA, index) =>

src/config/normalize/lib/wild_wild_path/parsing/compare.js

@@ -1,5 +1,6 @@
 import { getObjectTokenType } from '../tokens/main.js'
 
+import { validateSimplePath } from './normalize.js'
 import { parse } from './parse.js'
 
 // Check if two queries are equal.
@@ -19,6 +20,13 @@ export const equals = function (queryOrPathsA, queryOrPathsB) {
 
 // Check if two simple paths are equal
 export const equalsSimple = function (simplePathA, simplePathB) {
+  validateSimplePath(simplePathA)
+  validateSimplePath(simplePathB)
+  return fastEqualsSimple(simplePathA, simplePathB)
+}
+
+// Same as `equalsSimple()` but without validation
+export const fastEqualsSimple = function (simplePathA, simplePathB) {
   return (
     simplePathA.length === simplePathB.length &&
     simplePathA.every((prop, index) => simplePathB[index] === prop)

src/config/normalize/lib/wild_wild_path/parsing/normalize.js

@@ -1,13 +1,37 @@
 import { inspect } from 'util'
 
-import { getObjectTokenType } from '../tokens/main.js'
+import { getObjectTokenType, getSObjectTokenType } from '../tokens/main.js'
 
 // Most methods accept both query and path syntaxes.
 // This checks which one is used.
 export const isQueryString = function (queryOrPaths) {
   return typeof queryOrPaths === 'string'
 }
 
+// Simple paths are a subset of paths which uses no unions and only array|prop
+// tokens.
+// Those are the ones exposed in output, as opposed to normal paths which are
+// exposed in input.
+export const validateSimplePath = function (simplePath) {
+  if (!Array.isArray(simplePath)) {
+    throwPathError(simplePath, 'It must be an array.')
+  }
+
+  simplePath.forEach((prop) => {
+    validateProp(prop, simplePath)
+  })
+}
+
+const validateProp = function (prop, simplePath) {
+  if (getSObjectTokenType(prop) === undefined) {
+    throwTokenError(
+      simplePath,
+      prop,
+      'It must be a property name (string) or an array index (positive integer).',
+    )
+  }
+}
+
 // Normalize paths of tokens
 export const normalizePaths = function (paths) {
   validatePaths(paths)

src/config/normalize/lib/wild_wild_path/tokens/main.js

@@ -1,3 +1,4 @@
+import { ARRAY_TOKEN } from './array.js'
 import { OTHER_TOKEN_TYPES } from './other.js'
 import { PROP_TOKEN } from './prop.js'
 
@@ -15,3 +16,10 @@ export const getStringTokenType = function (chars, isProp) {
 
 // Order is significant as they are tested serially
 const TOKEN_TYPES = [...OTHER_TOKEN_TYPES, PROP_TOKEN]
+
+// Like `getObjectTokenType()` but for simple paths
+export const getSObjectTokenType = function (token) {
+  return SIMPLE_TOKEN_TYPES.find((tokenType) => tokenType.testObject(token))
+}
+
+const SIMPLE_TOKEN_TYPES = [ARRAY_TOKEN, PROP_TOKEN]