@atproto/lex-json 0.0.14 → 0.0.16

package/src/lex-json.test.ts

@@ -1,7 +1,13 @@
-import { describe, expect, it } from 'vitest'
+import { describe, expect, test } from 'vitest'
 import { LexValue, lexEquals, parseCid } from '@atproto/lex-data'
 import { JsonValue } from './json.js'
-import { jsonToLex, lexParse, lexStringify, lexToJson } from './lex-json.js'
+import {
+  jsonToLex,
+  lexParse,
+  lexParseJsonBytes,
+  lexStringify,
+  lexToJson,
+} from './lex-json.js'
 
 export const validVectors: Array<{
   name: string
@@ -330,6 +336,24 @@ export const acceptableVectors: Array<{
       $link: 'bafkreiccldh766hwcnuxnf2wh6jgzepf2nlu2lvcllt63eww5p6chi4ity',
     },
   },
+  {
+    note: 'blob with CBOR CID ref',
+    json: {
+      $type: 'blob',
+      ref: {
+        $link: 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+      },
+      mimeType: 'image/png',
+      size: 1,
+    },
+  },
+  {
+    note: 'object with empty $type',
+    json: {
+      $type: '',
+      foo: 'bar',
+    },
+  },
 ]
 
 export const invalidVectors: Array<{
@@ -364,58 +388,143 @@ export const invalidVectors: Array<{
 
 describe(lexParse, () => {
   describe('valid vectors', () => {
-    for (const { name, json, lex } of validVectors) {
-      describe(name, () => {
-        it('parses lex from string', () => {
+    describe('strict mode', () => {
+      for (const { name, json, lex } of validVectors) {
+        test(name, () => {
           expect(
-            lexEquals(lex, lexParse(JSON.stringify(json), { strict: false })),
+            lexEquals(lex, lexParse(JSON.stringify(json), { strict: true })),
           ).toBe(true)
+        })
+      }
+    })
+    describe('non-strict mode', () => {
+      for (const { name, json, lex } of validVectors) {
+        test(name, () => {
           expect(
-            lexEquals(lex, lexParse(JSON.stringify(json), { strict: true })),
+            lexEquals(lex, lexParse(JSON.stringify(json), { strict: false })),
           ).toBe(true)
         })
-      })
-    }
+      }
+    })
   })
 
   describe('acceptable vectors', () => {
-    for (const { note, json } of acceptableVectors) {
-      describe(note, () => {
-        it('parses lex from string in non-strict mode', () => {
+    describe('strict mode', () => {
+      for (const { note, json } of acceptableVectors) {
+        test(note, () => {
+          expect(() =>
+            lexParse(JSON.stringify(json), { strict: true }),
+          ).toThrow()
+        })
+      }
+    })
+    describe('non-strict mode', () => {
+      for (const { note, json } of acceptableVectors) {
+        test(note, () => {
           expect(() =>
             lexParse(JSON.stringify(json), { strict: false }),
           ).not.toThrow()
         })
+      }
+    })
+  })
 
-        it('parses lex from string in strict mode', () => {
+  describe('invalid vectors', () => {
+    describe('strict mode', () => {
+      for (const { note, json } of invalidVectors) {
+        test(note, () => {
           expect(() =>
             lexParse(JSON.stringify(json), { strict: true }),
           ).toThrow()
         })
+      }
+    })
+    describe('non-strict mode', () => {
+      for (const { note, json } of invalidVectors) {
+        test(note, () => {
+          expect(() =>
+            lexParse(JSON.stringify(json), { strict: false }),
+          ).not.toThrow()
+        })
+      }
+    })
+  })
+})
+
+describe(lexParseJsonBytes, () => {
+  describe('valid vectors', () => {
+    describe('strict mode', () => {
+      describe('with pretty-printed JSON', () => {
+        for (const { name, json, lex } of validVectors) {
+          test(name, () => {
+            const jsonBytes = Buffer.from(JSON.stringify(json, undefined, 4))
+            expect(
+              lexEquals(lex, lexParseJsonBytes(jsonBytes, { strict: true })),
+            ).toBe(true)
+          })
+        }
       })
-    }
+      describe('with compact JSON', () => {
+        for (const { name, json, lex } of validVectors) {
+          test(name, () => {
+            const jsonBytes = Buffer.from(JSON.stringify(json))
+            expect(
+              lexEquals(lex, lexParseJsonBytes(jsonBytes, { strict: true })),
+            ).toBe(true)
+          })
+        }
+      })
+    })
+
+    describe('non-strict mode', () => {
+      for (const { name, json, lex } of validVectors) {
+        test(name, () => {
+          const jsonBytes = Buffer.from(JSON.stringify(json))
+          expect(
+            lexEquals(lex, lexParseJsonBytes(jsonBytes, { strict: false })),
+          ).toBe(true)
+        })
+      }
+    })
+  })
+
+  describe('acceptable vectors', () => {
+    describe('strict mode', () => {
+      for (const { note, json } of acceptableVectors) {
+        test(note, () => {
+          const jsonBytes = Buffer.from(JSON.stringify(json))
+          expect(() => lexParseJsonBytes(jsonBytes, { strict: true })).toThrow()
+        })
+      }
+    })
+    describe('non-strict mode', () => {
+      for (const { note, json } of acceptableVectors) {
+        test(note, () => {
+          const jsonBytes = Buffer.from(JSON.stringify(json))
+          expect(() =>
+            lexParseJsonBytes(jsonBytes, { strict: false }),
+          ).not.toThrow()
+        })
+      }
+    })
   })
 
   describe('invalid vectors', () => {
     describe('strict mode', () => {
       for (const { note, json } of invalidVectors) {
-        describe(note, () => {
-          it('throws when parsing malformed JSON', () => {
-            expect(() =>
-              lexParse(JSON.stringify(json), { strict: true }),
-            ).toThrow()
-          })
+        test(note, () => {
+          const jsonBytes = Buffer.from(JSON.stringify(json))
+          expect(() => lexParseJsonBytes(jsonBytes, { strict: true })).toThrow()
         })
       }
     })
     describe('non-strict mode', () => {
       for (const { note, json } of invalidVectors) {
-        describe(note, () => {
-          it('does not throws when parsing malformed JSON', () => {
-            expect(() =>
-              lexParse(JSON.stringify(json), { strict: false }),
-            ).not.toThrow()
-          })
+        test(note, () => {
+          const jsonBytes = Buffer.from(JSON.stringify(json))
+          expect(() =>
+            lexParseJsonBytes(jsonBytes, { strict: false }),
+          ).not.toThrow()
         })
       }
     })
@@ -425,10 +534,8 @@ describe(lexParse, () => {
 describe(lexStringify, () => {
   describe('valid vectors', () => {
     for (const { name, json, lex } of validVectors) {
-      describe(name, () => {
-        it('stringifies lex to string', () => {
-          expect(JSON.parse(lexStringify(lex))).toEqual(json)
-        })
+      test(name, () => {
+        expect(JSON.parse(lexStringify(lex))).toStrictEqual(json)
       })
     }
   })
@@ -436,63 +543,66 @@ describe(lexStringify, () => {
 
 describe(jsonToLex, () => {
   describe('valid vectors', () => {
-    for (const { name, json, lex } of validVectors) {
-      describe(name, () => {
-        it('converts json to lex (in strict mode)', () => {
+    describe('strict mode', () => {
+      for (const { name, json, lex } of validVectors) {
+        test(name, () => {
           expect(lexEquals(jsonToLex(json, { strict: true }), lex)).toBe(true)
           expect(lexEquals(lex, jsonToLex(json, { strict: true }))).toBe(true)
         })
+      }
+    })
 
-        it('converts json to lex (in non-strict mode)', () => {
+    describe('non-strict mode', () => {
+      for (const { name, json, lex } of validVectors) {
+        test(name, () => {
           expect(lexEquals(jsonToLex(json, { strict: false }), lex)).toBe(true)
           expect(lexEquals(lex, jsonToLex(json, { strict: false }))).toBe(true)
         })
-      })
-    }
+      }
+    })
   })
 
   describe('acceptable vectors', () => {
-    for (const { note, json } of acceptableVectors) {
-      describe(note, () => {
-        it('parses lex from json in strict mode', () => {
+    describe('strict mode', () => {
+      for (const { note, json } of acceptableVectors) {
+        test(note, () => {
           expect(() => jsonToLex(json, { strict: true })).toThrow()
         })
+      }
+    })
 
-        it('parses lex from json in non-strict mode', () => {
+    describe('non-strict mode', () => {
+      for (const { note, json } of acceptableVectors) {
+        test(note, () => {
           expect(() => jsonToLex(json, { strict: false })).not.toThrow()
         })
-      })
-    }
+      }
+    })
   })
 
   describe('invalid vectors', () => {
-    for (const { note, json } of invalidVectors) {
-      describe(note, () => {
-        it(`throws for malformed object`, () => {
+    describe('strict mode', () => {
+      for (const { note, json } of invalidVectors) {
+        test(note, () => {
           expect(() => jsonToLex(json, { strict: true })).toThrow()
         })
-
-        it('throws for nested malformed object', () => {
-          expect(() => jsonToLex({ nested: json }, { strict: true })).toThrow()
-          expect(() => jsonToLex([json], { strict: true })).toThrow()
-        })
-
-        it('does not throw in non-strict mode', () => {
+      }
+    })
+    describe('non-strict mode', () => {
+      for (const { note, json } of invalidVectors) {
+        test(note, () => {
           expect(() => jsonToLex(json, { strict: false })).not.toThrow()
         })
-      })
-    }
+      }
+    })
   })
 })
 
 describe(lexToJson, () => {
   describe('valid vectors', () => {
     for (const { name, json, lex } of validVectors) {
-      describe(name, () => {
-        it('converts lex to json', () => {
-          expect(lexToJson(lex)).toEqual(json)
-          expect(lexToJson(lex)).toEqual(json)
-        })
+      test(name, () => {
+        expect(lexToJson(lex)).toStrictEqual(json)
       })
     }
   })
@@ -501,10 +611,19 @@ describe(lexToJson, () => {
 describe('json > lex > json', () => {
   describe('valid vectors', () => {
     for (const { name, json } of validVectors) {
-      describe(name, () => {
-        it('converts json to lex', () => {
-          expect(lexToJson(jsonToLex(json))).toEqual(json)
-        })
+      test(name, () => {
+        expect(lexToJson(jsonToLex(json))).toStrictEqual(json)
+      })
+    }
+  })
+})
+
+describe('json (binary) > lex > json', () => {
+  describe('valid vectors', () => {
+    for (const { name, json } of validVectors) {
+      test(name, () => {
+        const jsonBytes = Buffer.from(JSON.stringify(json, undefined, 4))
+        expect(lexToJson(lexParseJsonBytes(jsonBytes))).toStrictEqual(json)
       })
     }
   })
@@ -513,13 +632,360 @@ describe('json > lex > json', () => {
 describe('lex > json > lex', () => {
   describe('valid vectors', () => {
     for (const { name, lex } of validVectors) {
-      describe(name, () => {
-        it('converts lex to json', () => {
-          ;('')
-          expect(lexEquals(jsonToLex(lexToJson(lex)), lex)).toBe(true)
-          expect(lexEquals(lex, jsonToLex(lexToJson(lex)))).toBe(true)
-        })
+      test(name, () => {
+        expect(lexEquals(jsonToLex(lexToJson(lex)), lex)).toBe(true)
+        expect(lexEquals(lex, jsonToLex(lexToJson(lex)))).toBe(true)
       })
     }
   })
 })
+
+describe('lexParseJsonBytes strict mode error parity with lexParse', () => {
+  describe('invalid JSON input throws SyntaxError containing "Unexpected token"', () => {
+    test('lexParse throws with Unexpected token', () => {
+      expect(() => lexParse('not valid json', { strict: true })).toThrow(
+        /Unexpected token/,
+      )
+    })
+
+    test('lexParseJsonBytes throws with Unexpected token', () => {
+      expect(() =>
+        lexParseJsonBytes(Buffer.from('not valid json'), { strict: true }),
+      ).toThrow(/Unexpected token/)
+    })
+
+    test('lexParseJsonBytes non-strict also throws with Unexpected token for invalid JSON', () => {
+      expect(() =>
+        lexParseJsonBytes(Buffer.from('not valid json'), { strict: false }),
+      ).toThrow(/Unexpected token/)
+    })
+  })
+
+  describe('float numbers: strict throws TypeError, non-strict accepts', () => {
+    const jsonStr = '{"value":1.5}'
+
+    test('lexParse strict throws TypeError with value in message', () => {
+      expect(() => lexParse(jsonStr, { strict: true })).toThrow(TypeError)
+      expect(() => lexParse(jsonStr, { strict: true })).toThrow(
+        'Invalid non-integer number: 1.5',
+      )
+    })
+
+    test('lexParseJsonBytes strict throws same TypeError', () => {
+      const bytes = Buffer.from(jsonStr)
+      expect(() => lexParseJsonBytes(bytes, { strict: true })).toThrow(
+        TypeError,
+      )
+      expect(() => lexParseJsonBytes(bytes, { strict: true })).toThrow(
+        'Invalid non-integer number: 1.5',
+      )
+    })
+
+    test('lexParse non-strict accepts float', () => {
+      expect(() => lexParse(jsonStr, { strict: false })).not.toThrow()
+    })
+
+    test('lexParseJsonBytes non-strict accepts float', () => {
+      expect(() =>
+        lexParseJsonBytes(Buffer.from(jsonStr), { strict: false }),
+      ).not.toThrow()
+    })
+  })
+
+  describe('exponent notation: safe integers accepted, unsafe integers rejected', () => {
+    test('lexParse strict accepts 1e10 (safe integer)', () => {
+      expect(lexParse('1e10', { strict: true })).toBe(1e10)
+    })
+
+    test('lexParseJsonBytes strict accepts 1e10 (safe integer)', () => {
+      expect(lexParseJsonBytes(Buffer.from('1e10'), { strict: true })).toBe(
+        1e10,
+      )
+    })
+
+    test('lexParse strict rejects 1e20 (unsafe integer)', () => {
+      expect(() => lexParse('1e20', { strict: true })).toThrow(TypeError)
+    })
+
+    test('lexParseJsonBytes strict rejects 1e20 (unsafe integer)', () => {
+      expect(() =>
+        lexParseJsonBytes(Buffer.from('1e20'), { strict: true }),
+      ).toThrow(TypeError)
+    })
+  })
+
+  describe('invalid blob: strict throws TypeError, non-strict returns plain object', () => {
+    const invalidBlobJson = '{"$type":"blob"}'
+
+    test('lexParse strict throws TypeError with "Invalid blob object"', () => {
+      expect(() => lexParse(invalidBlobJson, { strict: true })).toThrow(
+        TypeError,
+      )
+      expect(() => lexParse(invalidBlobJson, { strict: true })).toThrow(
+        'Invalid blob object',
+      )
+    })
+
+    test('lexParseJsonBytes strict throws same TypeError', () => {
+      const bytes = Buffer.from(invalidBlobJson)
+      expect(() => lexParseJsonBytes(bytes, { strict: true })).toThrow(
+        TypeError,
+      )
+      expect(() => lexParseJsonBytes(bytes, { strict: true })).toThrow(
+        'Invalid blob object',
+      )
+    })
+
+    test('lexParse non-strict returns plain object', () => {
+      expect(() => lexParse(invalidBlobJson, { strict: false })).not.toThrow()
+    })
+
+    test('lexParseJsonBytes non-strict returns plain object', () => {
+      expect(() =>
+        lexParseJsonBytes(Buffer.from(invalidBlobJson), { strict: false }),
+      ).not.toThrow()
+    })
+  })
+
+  describe('blob with CBOR CID: strict throws TypeError, non-strict returns plain object', () => {
+    const blobWithCborCidJson = JSON.stringify({
+      $type: 'blob',
+      ref: {
+        $link: 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+      },
+      mimeType: 'image/png',
+      size: 1,
+    })
+
+    test('lexParse strict throws TypeError with "Invalid blob object"', () => {
+      expect(() => lexParse(blobWithCborCidJson, { strict: true })).toThrow(
+        TypeError,
+      )
+      expect(() => lexParse(blobWithCborCidJson, { strict: true })).toThrow(
+        'Invalid blob object',
+      )
+    })
+
+    test('lexParseJsonBytes strict throws same TypeError', () => {
+      const bytes = Buffer.from(blobWithCborCidJson)
+      expect(() => lexParseJsonBytes(bytes, { strict: true })).toThrow(
+        TypeError,
+      )
+      expect(() => lexParseJsonBytes(bytes, { strict: true })).toThrow(
+        'Invalid blob object',
+      )
+    })
+
+    test('lexParse non-strict returns plain object', () => {
+      expect(() =>
+        lexParse(blobWithCborCidJson, { strict: false }),
+      ).not.toThrow()
+    })
+
+    test('lexParseJsonBytes non-strict returns plain object', () => {
+      expect(() =>
+        lexParseJsonBytes(Buffer.from(blobWithCborCidJson), { strict: false }),
+      ).not.toThrow()
+    })
+  })
+
+  describe('invalid $link: strict throws TypeError, non-strict returns plain object', () => {
+    const invalidLinkJson = '{"$link":"."}'
+
+    test('lexParse strict throws TypeError with "Invalid $link object"', () => {
+      expect(() => lexParse(invalidLinkJson, { strict: true })).toThrow(
+        TypeError,
+      )
+      expect(() => lexParse(invalidLinkJson, { strict: true })).toThrow(
+        'Invalid $link object',
+      )
+    })
+
+    test('lexParseJsonBytes strict throws same TypeError', () => {
+      const bytes = Buffer.from(invalidLinkJson)
+      expect(() => lexParseJsonBytes(bytes, { strict: true })).toThrow(
+        TypeError,
+      )
+      expect(() => lexParseJsonBytes(bytes, { strict: true })).toThrow(
+        'Invalid $link object',
+      )
+    })
+
+    test('lexParse non-strict returns plain object', () => {
+      expect(() => lexParse(invalidLinkJson, { strict: false })).not.toThrow()
+    })
+
+    test('lexParseJsonBytes non-strict returns plain object', () => {
+      expect(() =>
+        lexParseJsonBytes(Buffer.from(invalidLinkJson), { strict: false }),
+      ).not.toThrow()
+    })
+  })
+
+  describe('$link with extra fields: strict throws TypeError, non-strict returns plain object', () => {
+    const linkWithExtraJson =
+      '{"$link":"bafkreiccldh766hwcnuxnf2wh6jgzepf2nlu2lvcllt63eww5p6chi4ity","extra":"field"}'
+
+    test('lexParse strict throws TypeError with "Invalid $link object"', () => {
+      expect(() => lexParse(linkWithExtraJson, { strict: true })).toThrow(
+        TypeError,
+      )
+      expect(() => lexParse(linkWithExtraJson, { strict: true })).toThrow(
+        'Invalid $link object',
+      )
+    })
+
+    test('lexParseJsonBytes strict throws same TypeError', () => {
+      const bytes = Buffer.from(linkWithExtraJson)
+      expect(() => lexParseJsonBytes(bytes, { strict: true })).toThrow(
+        TypeError,
+      )
+      expect(() => lexParseJsonBytes(bytes, { strict: true })).toThrow(
+        'Invalid $link object',
+      )
+    })
+
+    test('lexParse non-strict returns plain object', () => {
+      expect(() => lexParse(linkWithExtraJson, { strict: false })).not.toThrow()
+    })
+
+    test('lexParseJsonBytes non-strict returns plain object', () => {
+      expect(() =>
+        lexParseJsonBytes(Buffer.from(linkWithExtraJson), { strict: false }),
+      ).not.toThrow()
+    })
+  })
+
+  describe('invalid $bytes: strict throws TypeError, non-strict returns plain object', () => {
+    const invalidBytesJson = '{"$bytes":"🐻"}'
+
+    test('lexParse strict throws TypeError with "Invalid $bytes object"', () => {
+      expect(() => lexParse(invalidBytesJson, { strict: true })).toThrow(
+        TypeError,
+      )
+      expect(() => lexParse(invalidBytesJson, { strict: true })).toThrow(
+        'Invalid $bytes object',
+      )
+    })
+
+    test('lexParseJsonBytes strict throws same TypeError', () => {
+      const bytes = Buffer.from(invalidBytesJson)
+      expect(() => lexParseJsonBytes(bytes, { strict: true })).toThrow(
+        TypeError,
+      )
+      expect(() => lexParseJsonBytes(bytes, { strict: true })).toThrow(
+        'Invalid $bytes object',
+      )
+    })
+
+    test('lexParse non-strict returns plain object', () => {
+      expect(() => lexParse(invalidBytesJson, { strict: false })).not.toThrow()
+    })
+
+    test('lexParseJsonBytes non-strict returns plain object', () => {
+      expect(() =>
+        lexParseJsonBytes(Buffer.from(invalidBytesJson), { strict: false }),
+      ).not.toThrow()
+    })
+  })
+
+  describe('$bytes with extra fields: strict throws TypeError, non-strict returns plain object', () => {
+    const bytesWithExtraJson =
+      '{"$bytes":"nFERjvLLiw9qm45JrqH9QTzyC2Lu1Xb4ne6+sBrCzI0","extra":"field"}'
+
+    test('lexParse strict throws TypeError with "Invalid $bytes object"', () => {
+      expect(() => lexParse(bytesWithExtraJson, { strict: true })).toThrow(
+        TypeError,
+      )
+      expect(() => lexParse(bytesWithExtraJson, { strict: true })).toThrow(
+        'Invalid $bytes object',
+      )
+    })
+
+    test('lexParseJsonBytes strict throws same TypeError', () => {
+      const bytes = Buffer.from(bytesWithExtraJson)
+      expect(() => lexParseJsonBytes(bytes, { strict: true })).toThrow(
+        TypeError,
+      )
+      expect(() => lexParseJsonBytes(bytes, { strict: true })).toThrow(
+        'Invalid $bytes object',
+      )
+    })
+
+    test('lexParse non-strict returns plain object', () => {
+      expect(() =>
+        lexParse(bytesWithExtraJson, { strict: false }),
+      ).not.toThrow()
+    })
+
+    test('lexParseJsonBytes non-strict returns plain object', () => {
+      expect(() =>
+        lexParseJsonBytes(Buffer.from(bytesWithExtraJson), { strict: false }),
+      ).not.toThrow()
+    })
+  })
+
+  describe('empty $type: strict throws TypeError, non-strict returns plain object', () => {
+    const emptyTypeJson = '{"$type":"","foo":"bar"}'
+
+    test('lexParse strict throws TypeError with "Empty $type property"', () => {
+      expect(() => lexParse(emptyTypeJson, { strict: true })).toThrow(TypeError)
+      expect(() => lexParse(emptyTypeJson, { strict: true })).toThrow(
+        'Empty $type property',
+      )
+    })
+
+    test('lexParseJsonBytes strict throws same TypeError', () => {
+      const bytes = Buffer.from(emptyTypeJson)
+      expect(() => lexParseJsonBytes(bytes, { strict: true })).toThrow(
+        TypeError,
+      )
+      expect(() => lexParseJsonBytes(bytes, { strict: true })).toThrow(
+        'Empty $type property',
+      )
+    })
+
+    test('lexParse non-strict returns plain object', () => {
+      expect(() => lexParse(emptyTypeJson, { strict: false })).not.toThrow()
+    })
+
+    test('lexParseJsonBytes non-strict returns plain object', () => {
+      expect(() =>
+        lexParseJsonBytes(Buffer.from(emptyTypeJson), { strict: false }),
+      ).not.toThrow()
+    })
+  })
+
+  describe('non-string $type: strict throws TypeError, non-strict returns plain object', () => {
+    const nonStringTypeJson = '{"$type":123,"foo":"bar"}'
+
+    test('lexParse strict throws TypeError with type name in message', () => {
+      expect(() => lexParse(nonStringTypeJson, { strict: true })).toThrow(
+        TypeError,
+      )
+      expect(() => lexParse(nonStringTypeJson, { strict: true })).toThrow(
+        'Invalid $type property (number)',
+      )
+    })
+
+    test('lexParseJsonBytes strict throws same TypeError', () => {
+      const bytes = Buffer.from(nonStringTypeJson)
+      expect(() => lexParseJsonBytes(bytes, { strict: true })).toThrow(
+        TypeError,
+      )
+      expect(() => lexParseJsonBytes(bytes, { strict: true })).toThrow(
+        'Invalid $type property (number)',
+      )
+    })
+
+    test('lexParse non-strict returns plain object', () => {
+      expect(() => lexParse(nonStringTypeJson, { strict: false })).not.toThrow()
+    })
+
+    test('lexParseJsonBytes non-strict returns plain object', () => {
+      expect(() =>
+        lexParseJsonBytes(Buffer.from(nonStringTypeJson), { strict: false }),
+      ).not.toThrow()
+    })
+  })
+})