fix typos

pkg/eval/builtin/core.go

@@ -310,19 +310,19 @@ func rangeFunction(ctx types.Context, args []ast.Expression) (any, error) {
 	if size == 1 {
 		varNameIdent, ok := namingVector.Expressions[0].(ast.Identifier)
 		if !ok {
-			return nil, fmt.Errorf("loop variable name must be an identifer, got %T", namingVector.Expressions[0])
+			return nil, fmt.Errorf("loop variable name must be an identifier, got %T", namingVector.Expressions[0])
 		}
 
 		loopVarName = string(varNameIdent)
 	} else {
 		indexIdent, ok := namingVector.Expressions[0].(ast.Identifier)
 		if !ok {
-			return nil, fmt.Errorf("loop index name must be an identifer, got %T", namingVector.Expressions[0])
+			return nil, fmt.Errorf("loop index name must be an identifier, got %T", namingVector.Expressions[0])
 		}
 
 		varNameIdent, ok := namingVector.Expressions[1].(ast.Identifier)
 		if !ok {
-			return nil, fmt.Errorf("loop variable name must be an identifer, got %T", namingVector.Expressions[0])
+			return nil, fmt.Errorf("loop variable name must be an identifier, got %T", namingVector.Expressions[0])
 		}
 
 		loopIndexName = string(indexIdent)

pkg/eval/builtin/core_test.go

@@ -280,7 +280,7 @@ func TestHasFunction(t *testing.T) {
 
 	testVariables := types.Variables{
 		// value does not matter here, but this testcase is still meant
-		// to ensure the missing path is detected, not detect an uknown variable
+		// to ensure the missing path is detected, not detect an unknown variable
 		"myvar":  42,
 		"obj":    testObjDocument,
 		"vec":    testVecDocument,

pkg/eval/builtin/encoding_test.go

@@ -102,12 +102,12 @@ func TestFromBase64Function(t *testing.T) {
 			invalid: true,
 		},
 		{
-			expr:    `(from-base64 "definitly-not-base64")`,
+			expr:    `(from-base64 "definitely-not-base64")`,
 			invalid: true,
 		},
 		{
 			// should be able to recover
-			expr:     `(try (from-base64 "definitly-not-base64") "fallback")`,
+			expr:     `(try (from-base64 "definitely-not-base64") "fallback")`,
 			expected: "fallback",
 		},
 		{

pkg/eval/coalescing/funcs.go

@@ -149,7 +149,7 @@ func IsEmpty(val any) (bool, error) {
 	default:
 		lit, ok := val.(ast.Literal)
 		if !ok {
-			return false, fmt.Errorf("cannot termine emptiness oT %s", val)
+			return false, fmt.Errorf("cannot determine emptiness oT %s", val)
 		}
 
 		return IsEmpty(lit.LiteralValue())

pkg/eval/eval_symbol.go

@@ -30,7 +30,7 @@ func EvalSymbolWithEvaluatedPath(ctx types.Context, sym ast.Symbol, path ast.Eva
 	rootDoc := ctx.GetDocument()
 	rootValue := rootDoc.Get()
 
-	// santity check
+	// sanity check
 	if sym.Variable == nil && sym.PathExpression == nil {
 		return ctx, nil, errors.New("invalid symbol")
 	}

pkg/lang/grammar/otto.peg

@@ -161,37 +161,6 @@ KeyValuePair <- (key:ScalarExpression __ value:Expression) {
 //////////////////////////////////////////////////////////
 // path expressions
 
-/*
-possible symbols:
-
-   (each step is evaluated immediately, so foo.bar[0] is (foo.bar)[0], not foo.(bar[0]))
-
-// regular identifier
-identifier
-
-// regular variable
-$var
-
-// traverse variable
-$var.subkey
-$var[0]
-$var[$var]
-$var[(add $var 1)]
-
-// deeper traversal
-$var.subkey[0].$othervar.subkey
-
-// instead of traversing starting with a var, you can also
-// start traversing the current object
-.subkey
-.subkey[$index].subsubkey.$varstep
-
-// array acces on the global document; this needs a leading dot to distinguish
-// it from a bare "[index]", which constructs an array with 1 element in it
-.[index]
-
-*/
-
 Symbol <- '.' acc:VectorAccessor expr:AnyQualifiedPathExpression? {
    arrAcc := acc.(ast.Expression)