fix: numeric literals can be set as object keys and used to access objects

src/expression/node/AccessorNode.js

@@ -6,6 +6,7 @@ import {
   isIndexNode,
   isNode,
   isObjectNode,
+  isOperatorNode,
   isParenthesisNode,
   isSymbolNode
 } from '../../utils/is.js'
@@ -93,6 +94,15 @@ export const createAccessorNode = /* #__PURE__ */ factory(name, dependencies, ({
       const evalObject = this.object._compile(math, argNames)
       const evalIndex = this.index._compile(math, argNames)
 
+      // If index contains operator node, evaluate result of the operation and access object with result
+      if (isOperatorNode(this.index.dimensions[0]) && isObjectNode(this.object)) {
+        const operatorNode = this.index.dimensions[0]
+        return function evalAccessorNode (scope, args, context) {
+          const result = operatorNode._compile(math, argNames)(scope, args, context)
+          return getSafeProperty(evalObject(scope, args, context), String(result))
+        }
+      }
+
       if (this.index.isObjectProperty()) {
         const prop = this.index.getObjectProperty()
         return function evalAccessorNode (scope, args, context) {

src/expression/parse.js

@@ -1,5 +1,5 @@
 import { factory } from '../utils/factory.js'
-import { isAccessorNode, isConstantNode, isFunctionNode, isOperatorNode, isSymbolNode, rule2Node } from '../utils/is.js'
+import { isAccessorNode, isConstantNode, isFunctionNode, isObjectNode, isOperatorNode, isSymbolNode, rule2Node } from '../utils/is.js'
 import { deepMap } from '../utils/collection.js'
 import { safeNumberType } from '../utils/number.js'
 import { hasOwnProperty } from '../utils/object.js'
@@ -1413,6 +1413,12 @@ export const createParse = /* #__PURE__ */ factory(name, dependencies, ({
         closeParams(state)
         getToken(state)
 
+        // If param value is number and node is object node, make param value a string
+        if (typeof params[0].value === 'number' && isObjectNode(node) && params.length === 1 && isConstantNode(params[0])) {
+          // Number constructor is first used to manage situations of numbers with preceding zero digit(s)
+          params[0].value = String(Number(params[0].value))
+        }
+
         node = new AccessorNode(node, new IndexNode(params))
       } else {
         // dot notation like variable.prop
@@ -1615,11 +1621,11 @@ export const createParse = /* #__PURE__ */ factory(name, dependencies, ({
           // parse key
           if (state.token === '"' || state.token === "'") {
             key = parseStringToken(state, state.token)
-          } else if (state.tokenType === TOKENTYPE.SYMBOL || (state.tokenType === TOKENTYPE.DELIMITER && state.token in NAMED_DELIMITERS)) {
-            key = state.token
+          } else if (state.tokenType === TOKENTYPE.SYMBOL || (state.tokenType === TOKENTYPE.DELIMITER && state.token in NAMED_DELIMITERS) || state.tokenType === TOKENTYPE.NUMBER) {
+            key = state.tokenType === TOKENTYPE.NUMBER ? String(Number(state.token)) : state.token
             getToken(state)
           } else {
-            throw createSyntaxError(state, 'Symbol or string expected as object key')
+            throw createSyntaxError(state, 'Symbol, numeric literal or string expected as object key')
           }
 
           // parse key/value separator

test/unit-tests/expression/parse.test.js

@@ -919,6 +919,42 @@ describe('parse', function () {
       }, /Cannot apply a numeric index as object property/)
     })
 
+    it('should coerce numbers to string when trying to apply a numeric key in an object expression', function () {
+      assert.deepStrictEqual(parseAndEval('{2: 6}'), { 2: 6 })
+    })
+
+    it('should throw an error when negative numbers are applied as keys in an object expression', function () {
+      assert.throws(function () {
+        parseAndEval('{-1: 34}')
+      }, /Symbol, numeric literal or string expected as object key \(char 2\)/)
+    })
+
+    it('should coerce numbers to string when trying to access an object expression property with matrix index', function () {
+      assert.strictEqual(parseAndEval('{2: 6}[2]'), 6)
+      assert.strictEqual(parseAndEval('{2.5: 6}[2.5]'), 6)
+      assert.strictEqual(parseAndEval('{5: 16}[3]'), undefined)
+    })
+
+    it('should accept operations in a matrix when trying to access an object expression property', function () {
+      assert.strictEqual(parseAndEval('{2: 6}[2 * 1]'), 6)
+      assert.strictEqual(parseAndEval('{31: 7 - 4}[0.2 + 0.8]'), undefined)
+      assert.strictEqual(parseAndEval('{4: 11 * 4}[(2 ^ 2) * 1]'), 44)
+    })
+
+    it('should ignore leading zeros when trying to apply numeric keys in an object expression', function () {
+      assert.deepStrictEqual(parseAndEval('{02: 6}'), { 2: 6 })
+      assert.deepStrictEqual(parseAndEval('{0070: 6}'), { 70: 6 })
+      assert.deepStrictEqual(parseAndEval('{0.2: 6}'), { 0.2: 6 })
+      assert.deepStrictEqual(parseAndEval('{0010.0501: "haha"}'), { 10.0501: 'haha' })
+    })
+
+    it('should ignore leading zeros in a matrix index when trying to access an object expression property', function () {
+      assert.strictEqual(parseAndEval('{2: 6}[02]'), 6)
+      assert.strictEqual(parseAndEval('{70: 1 - 6}[0070]'), -5)
+      assert.strictEqual(parseAndEval('{0.2: 6}[000.2]'), 6)
+      assert.strictEqual(parseAndEval('{10.0501: "haha"}[0010.0501]'), 'haha')
+    })
+
     it('should set a nested matrix subset from an object property (1)', function () {
       const scope = { obj: { foo: [1, 2, 3] } }
       assert.deepStrictEqual(parseAndEval('obj.foo[2] = 6', scope), 6)