@marcuspuchalla/nachos 0.1.0

package/src/parser/__tests__/ast-tree-structure.test.ts

@@ -0,0 +1,311 @@
+import { describe, it, expect } from 'vitest'
+import { useCborParser } from '../composables/useCborParser'
+
+/**
+ * AST Tree Structure Tests
+ *
+ * These tests verify that the source map produces proper AST structure where:
+ * - Each node shows only its header bytes (type + length encoding)
+ * - Content is separated from headers
+ * - Nested structures are properly represented
+ */
+describe('AST Tree Structure', () => {
+  const { parseWithSourceMap } = useCborParser()
+
+  describe('Byte String AST Structure', () => {
+    it('should split byte string into header and content', () => {
+      // 54 = bytes(20)
+      // 736c6f6fc9942073e1b4892073e1b489c9a5ca87 = 20 bytes of data
+      const hex = '54736c6f6fc9942073e1b4892073e1b489c9a5ca87'
+      const result = parseWithSourceMap(hex)
+
+      expect(result.sourceMap).toHaveLength(2)
+
+      // Header entry (container)
+      const headerEntry = result.sourceMap[0]
+      expect(headerEntry.type).toBe('bytes(20)')
+      expect(headerEntry.start).toBe(0)
+      expect(headerEntry.end).toBe(1) // Only the "54" byte
+      expect(headerEntry.isHeader).toBe(true)
+      expect(headerEntry.headerEnd).toBe(1)
+      expect(headerEntry.contentPath).toBe('#content')
+      expect(headerEntry.children).toEqual(['#content']) // Header is a container
+
+      // Content entry (child of header)
+      const contentEntry = result.sourceMap[1]
+      expect(contentEntry.type).toBe('→ 20 bytes')
+      expect(contentEntry.start).toBe(1)
+      expect(contentEntry.end).toBe(21) // The 20 data bytes
+      expect(contentEntry.isContent).toBe(true)
+      expect(contentEntry.parent).toBe('') // Parent is the header
+    })
+
+    it('should handle empty byte string', () => {
+      // 40 = bytes(0)
+      const hex = '40'
+      const result = parseWithSourceMap(hex)
+
+      expect(result.sourceMap).toHaveLength(1)
+
+      // Only header, no content
+      const headerEntry = result.sourceMap[0]
+      expect(headerEntry.type).toBe('bytes(0)')
+      expect(headerEntry.start).toBe(0)
+      expect(headerEntry.end).toBe(1)
+      expect(headerEntry.isHeader).toBe(true)
+      expect(headerEntry.contentPath).toBeUndefined()
+    })
+  })
+
+  describe('Text String AST Structure', () => {
+    it('should split text string into header and content', () => {
+      // 64 = text(4)
+      // 49455446 = "IETF"
+      const hex = '6449455446'
+      const result = parseWithSourceMap(hex)
+
+      expect(result.sourceMap).toHaveLength(2)
+
+      // Header entry (container)
+      const headerEntry = result.sourceMap[0]
+      expect(headerEntry.type).toBe('text(4)')
+      expect(headerEntry.start).toBe(0)
+      expect(headerEntry.end).toBe(1) // Only the "64" byte
+      expect(headerEntry.isHeader).toBe(true)
+      expect(headerEntry.headerEnd).toBe(1)
+      expect(headerEntry.children).toEqual(['#content']) // Header is a container
+
+      // Content entry (child of header)
+      const contentEntry = result.sourceMap[1]
+      expect(contentEntry.type).toBe('→ "IETF"')
+      expect(contentEntry.start).toBe(1)
+      expect(contentEntry.end).toBe(5) // The 4 text bytes
+      expect(contentEntry.isContent).toBe(true)
+      expect(contentEntry.parent).toBe('') // Parent is the header
+    })
+  })
+
+  describe('Array AST Structure', () => {
+    it('should show array header separate from elements', () => {
+      // 82 = array(2)
+      // 01 = int 1
+      // 02 = int 2
+      const hex = '820102'
+      const result = parseWithSourceMap(hex)
+
+      // Should have: array header, element[0], element[1]
+      expect(result.sourceMap).toHaveLength(3)
+
+      // Array header
+      const arrayEntry = result.sourceMap[0]
+      expect(arrayEntry.type).toBe('array(2)')
+      expect(arrayEntry.start).toBe(0)
+      expect(arrayEntry.end).toBe(1) // Only the "82" byte
+      expect(arrayEntry.isHeader).toBe(true)
+      expect(arrayEntry.headerEnd).toBe(1)
+      expect(arrayEntry.children).toEqual(['[0]', '[1]'])
+
+      // First element
+      const elem0 = result.sourceMap[1]
+      expect(elem0.path).toBe('[0]')
+      expect(elem0.start).toBe(1)
+      expect(elem0.end).toBe(2) // The "01" byte
+      expect(elem0.parent).toBe('')
+
+      // Second element
+      const elem1 = result.sourceMap[2]
+      expect(elem1.path).toBe('[1]')
+      expect(elem1.start).toBe(2)
+      expect(elem1.end).toBe(3) // The "02" byte
+      expect(elem1.parent).toBe('')
+    })
+
+    it('should handle nested arrays with proper AST structure', () => {
+      // 82 = array(2)
+      //   82 = array(2)
+      //     58 20 = bytes(32)
+      //     00 = int 0
+      //   01 = int 1
+      const hex = '8282582048bd01d51e580cde15afa6d28f63d89c9137b93a910e5941192e26b129061067000001'
+      const result = parseWithSourceMap(hex)
+
+      // Outer array header
+      const outerArray = result.sourceMap[0]
+      expect(outerArray.type).toBe('array(2)')
+      expect(outerArray.start).toBe(0)
+      expect(outerArray.end).toBe(1) // Only first "82"
+      expect(outerArray.isHeader).toBe(true)
+
+      // Inner array header (first element of outer array)
+      const innerArray = result.sourceMap.find(e => e.path === '[0]' && e.type.startsWith('array'))
+      expect(innerArray).toBeDefined()
+      expect(innerArray!.type).toBe('array(2)')
+      expect(innerArray!.start).toBe(1)
+      expect(innerArray!.end).toBe(2) // Only second "82"
+      expect(innerArray!.isHeader).toBe(true)
+      expect(innerArray!.children).toEqual(['[0][0]', '[0][1]'])
+
+      // Byte string header inside inner array
+      const bytesHeader = result.sourceMap.find(e => e.path === '[0][0]' && e.isHeader === true)
+      expect(bytesHeader).toBeDefined()
+      expect(bytesHeader!.type).toBe('bytes(32)')
+      expect(bytesHeader!.start).toBe(2)
+      expect(bytesHeader!.end).toBe(4) // "58 20"
+      expect(bytesHeader!.isHeader).toBe(true)
+
+      // Byte string content
+      const bytesContent = result.sourceMap.find(e => e.path === '[0][0]#content')
+      expect(bytesContent).toBeDefined()
+      expect(bytesContent!.start).toBe(4)
+      expect(bytesContent!.end).toBe(36) // 32 bytes of data
+      expect(bytesContent!.isContent).toBe(true)
+
+      // Integer inside inner array
+      const intEntry = result.sourceMap.find(e => e.path === '[0][1]')
+      expect(intEntry).toBeDefined()
+      expect(intEntry!.start).toBe(36)
+      expect(intEntry!.end).toBe(37) // The "00" byte
+
+      // Second element of outer array
+      const secondElem = result.sourceMap.find(e => e.path === '[1]' && !e.type.startsWith('array'))
+      expect(secondElem).toBeDefined()
+      expect(secondElem!.start).toBe(37)
+      expect(secondElem!.end).toBe(38) // The "01" byte
+    })
+  })
+
+  describe('Map AST Structure', () => {
+    it('should show map header separate from key-value pairs', () => {
+      // a1 = map(1)
+      // 61 61 = text(1) "a"
+      // 01 = int 1
+      const hex = 'a16161 01'
+      const result = parseWithSourceMap(hex.replace(/\s/g, ''))
+
+      // Map header
+      const mapEntry = result.sourceMap[0]
+      expect(mapEntry.type).toBe('map(1)')
+      expect(mapEntry.start).toBe(0)
+      expect(mapEntry.end).toBe(1) // Only the "a1" byte
+      expect(mapEntry.isHeader).toBe(true)
+      expect(mapEntry.headerEnd).toBe(1)
+
+      // Should have children pointing to values (not keys)
+      expect(mapEntry.children).toBeDefined()
+      expect(mapEntry.children!.length).toBe(1)
+    })
+  })
+
+  describe('Tag AST Structure', () => {
+    it('should show tag header separate from tagged value', () => {
+      // c2 = tag(2) - bignum
+      // 41 ff = bytes(1) with value 0xff
+      const hex = 'c241ff'
+      const result = parseWithSourceMap(hex)
+
+      // Tag header
+      const tagEntry = result.sourceMap[0]
+      expect(tagEntry.type).toBe('tag(2)')
+      expect(tagEntry.start).toBe(0)
+      expect(tagEntry.end).toBe(1) // Only the "c2" byte
+      expect(tagEntry.isHeader).toBe(true)
+      expect(tagEntry.headerEnd).toBe(1)
+      expect(tagEntry.children).toEqual(['.value'])
+
+      // Tagged value - bytes header
+      const bytesHeader = result.sourceMap.find(e => e.path === '.value' && e.isHeader === true)
+      expect(bytesHeader).toBeDefined()
+      expect(bytesHeader!.type).toBe('bytes(1)')
+      expect(bytesHeader!.start).toBe(1)
+      expect(bytesHeader!.end).toBe(2) // The "41" byte
+      expect(bytesHeader!.parent).toBe('')
+
+      // Bytes content
+      const bytesContent = result.sourceMap.find(e => e.path === '.value#content')
+      expect(bytesContent).toBeDefined()
+      expect(bytesContent!.start).toBe(2)
+      expect(bytesContent!.end).toBe(3) // The "ff" byte
+    })
+
+    it('should handle tag 258 (Cardano set) with proper AST', () => {
+      // d9 0102 = tag(258)
+      // 81 = array(1)
+      // 01 = int 1
+      const hex = 'd901028101'
+      const result = parseWithSourceMap(hex)
+
+      // Tag header
+      const tagEntry = result.sourceMap[0]
+      expect(tagEntry.type).toBe('tag(258)')
+      expect(tagEntry.start).toBe(0)
+      expect(tagEntry.end).toBe(3) // "d9 01 02"
+      expect(tagEntry.isHeader).toBe(true)
+      expect(tagEntry.headerEnd).toBe(3)
+
+      // Array header (tagged value)
+      const arrayEntry = result.sourceMap.find(e => e.path === '.value' && e.type === 'array(1)')
+      expect(arrayEntry).toBeDefined()
+      expect(arrayEntry!.start).toBe(3)
+      expect(arrayEntry!.end).toBe(4) // Only the "81" byte
+      expect(arrayEntry!.isHeader).toBe(true)
+      expect(arrayEntry!.parent).toBe('')
+    })
+  })
+
+  describe('Complex Cardano Transaction Example', () => {
+    it('should produce proper AST for real Cardano UTXO', () => {
+      // This is the user's example from the conversation:
+      // 82 82 58 20 48bd... 00 82 58 39 00dae... 1a 000f4240
+      const hex = '8282582048bd01d51e580cde15afa6d28f63d89c9137b93a910e5941192e26b12906106700825839000dae074cac48222800da644971a35b68832abb40b619643efde77dc9db8ec58f9fa297093e286f81d37bea7154209064956254d5d4e2108d1a000f4240'
+      const result = parseWithSourceMap(hex)
+
+      // Outer array: 82 at offset 0
+      const outerArray = result.sourceMap[0]
+      expect(outerArray.type).toBe('array(2)')
+      expect(outerArray.start).toBe(0)
+      expect(outerArray.end).toBe(1) // Only first "82"
+      expect(outerArray.isHeader).toBe(true)
+
+      // First inner array: 82 at offset 1
+      const firstInnerArray = result.sourceMap.find(e => e.path === '[0]' && e.type === 'array(2)')
+      expect(firstInnerArray).toBeDefined()
+      expect(firstInnerArray!.start).toBe(1)
+      expect(firstInnerArray!.end).toBe(2) // Only second "82"
+      expect(firstInnerArray!.isHeader).toBe(true)
+
+      // Byte string header: 58 20 at offset 2-3
+      const bytesHeader = result.sourceMap.find(e => e.path === '[0][0]' && e.isHeader === true)
+      expect(bytesHeader).toBeDefined()
+      expect(bytesHeader!.type).toBe('bytes(32)')
+      expect(bytesHeader!.start).toBe(2)
+      expect(bytesHeader!.end).toBe(4) // "58 20"
+      expect(bytesHeader!.isHeader).toBe(true)
+
+      // Byte string content: 32 bytes starting at offset 4
+      const bytesContent = result.sourceMap.find(e => e.path === '[0][0]#content')
+      expect(bytesContent).toBeDefined()
+      expect(bytesContent!.start).toBe(4)
+      expect(bytesContent!.end).toBe(36) // 32 bytes
+      expect(bytesContent!.isContent).toBe(true)
+
+      // Integer: 00 at offset 36
+      const intEntry = result.sourceMap.find(e => e.path === '[0][1]')
+      expect(intEntry).toBeDefined()
+      expect(intEntry!.start).toBe(36)
+      expect(intEntry!.end).toBe(37)
+
+      // Second inner array: 82 at offset 37
+      const secondInnerArray = result.sourceMap.find(e => e.path === '[1]' && e.type === 'array(2)')
+      expect(secondInnerArray).toBeDefined()
+      expect(secondInnerArray!.start).toBe(37)
+      expect(secondInnerArray!.end).toBe(38) // Only the "82" byte
+      expect(secondInnerArray!.isHeader).toBe(true)
+
+      // Verify proper parent-child relationships
+      expect(firstInnerArray!.parent).toBe('')
+      expect(secondInnerArray!.parent).toBe('')
+      expect(bytesHeader!.parent).toBe('[0]')
+      expect(bytesContent!.parent).toBe('[0][0]')
+    })
+  })
+})

package/src/parser/__tests__/cbor-collection-errors.test.ts

@@ -0,0 +1,296 @@
+/**
+ * CBOR Collection Parser Error Handling Tests
+ * Tests all error cases and edge cases for 100% code coverage
+ */
+
+import { describe, it, expect } from 'vitest'
+import { useCborCollection } from '../composables/useCborCollection'
+
+describe('useCborCollection - Error Handling', () => {
+  describe('parseItem - Unexpected End of Buffer', () => {
+    it('should throw error when offset is at end of buffer', () => {
+      const { parseArray } = useCborCollection()
+
+      // Array with 2 elements, but only 1 element provided
+      // 82 (array of 2) + 01 (element 1) - missing element 2
+      expect(() => parseArray('8201')).toThrow('Unexpected end of buffer')
+    })
+
+    it('should throw error when buffer ends mid-element', () => {
+      const { parseArray } = useCborCollection()
+
+      // Array with nested array that's incomplete
+      // 82 (array of 2) + 01 (element 1) + 82 (nested array of 2, incomplete)
+      expect(() => parseArray('820182')).toThrow('Unexpected end of buffer')
+    })
+  })
+
+  describe('parseItem - Tag Parsing Support', () => {
+    it('should successfully parse array containing a tag', () => {
+      const { parseArray } = useCborCollection()
+
+      // Array containing a tag (now properly supported)
+      // 81 (array of 1) + c0 (tag 0) + 00 (value)
+      const result = parseArray('81c000')
+      expect(result.value).toBeInstanceOf(Array)
+      expect(result.value).toHaveLength(1)
+      expect(result.value[0].tag).toBe(0)
+      expect(result.value[0].value).toBe(0)
+    })
+
+    it('should successfully parse map with tag as value', () => {
+      const { parseMap } = useCborCollection()
+
+      // Map with tag as value (now properly supported)
+      // a1 (map of 1) + 01 (key) + c0 (tag 0) + 00 (value)
+      const result = parseMap('a101c000')
+      expect(result.value.get(1)).toBeDefined()
+      expect(result.value.get(1).tag).toBe(0)
+      expect(result.value.get(1).value).toBe(0)
+    })
+  })
+
+  describe('parseLength - All Encoding Sizes for Collections', () => {
+    it('should parse array with 4-byte length (AI 26)', () => {
+      const { parseArray } = useCborCollection()
+
+      // Array with 1000 elements (using 4-byte length)
+      // 9a (MT 4, AI 26) + 000003e8 (1000 in 4 bytes) + 1000x 00 (zeros)
+      const elements = '00'.repeat(1000)
+      const result = parseArray('9a000003e8' + elements)
+      expect(result.value.length).toBe(1000)
+    })
+
+    it('should parse array with 8-byte length (AI 27)', () => {
+      const { parseArray } = useCborCollection()
+
+      // Array with 100 elements (using 8-byte length)
+      // 9b (MT 4, AI 27) + 0000000000000064 (100 in 8 bytes) + 100x 00
+      const elements = '00'.repeat(100)
+      const result = parseArray('9b0000000000000064' + elements)
+      expect(result.value.length).toBe(100)
+    })
+
+    it('should parse map with 4-byte length (AI 26)', () => {
+      const { parseMap } = useCborCollection()
+
+      // Map with 100 entries (using 4-byte length)
+      // ba (MT 5, AI 26) + 00000064 (100 in 4 bytes) + 100x unique key-value pairs
+      // Use 1-byte encoding for keys to avoid reserved AI values (28-31)
+      const entries = Array.from({ length: 100 }, (_, i) => {
+        const keyHex = '18' + (24 + i).toString(16).padStart(2, '0')
+        const valueHex = '18' + (124 + i).toString(16).padStart(2, '0')
+        return keyHex + valueHex
+      }).join('')
+      const result = parseMap('ba00000064' + entries)
+      expect(result.value.size).toBe(100)
+    })
+
+    it('should parse map with 8-byte length (AI 27)', () => {
+      const { parseMap } = useCborCollection()
+
+      // Map with 50 entries (using 8-byte length)
+      // bb (MT 5, AI 27) + 0000000000000032 (50 in 8 bytes) + 50x unique key-value pairs
+      const entries = Array.from({ length: 50 }, (_, i) => {
+        const keyHex = '18' + (30 + i).toString(16).padStart(2, '0')
+        const valueHex = '18' + (80 + i).toString(16).padStart(2, '0')
+        return keyHex + valueHex
+      }).join('')
+      const result = parseMap('bb0000000000000032' + entries)
+      expect(result.value.size).toBe(50)
+    })
+  })
+
+  describe('parseLength - Invalid Additional Info', () => {
+    it('should throw error for array with reserved AI 28', () => {
+      const { parseArray } = useCborCollection()
+
+      // MT 4, AI 28 - reserved
+      expect(() => parseArray('9c')).toThrow('Invalid additional info: 28')
+    })
+
+    it('should throw error for array with reserved AI 29', () => {
+      const { parseArray } = useCborCollection()
+
+      // MT 4, AI 29 - reserved
+      expect(() => parseArray('9d')).toThrow('Invalid additional info: 29')
+    })
+
+    it('should throw error for array with reserved AI 30', () => {
+      const { parseArray } = useCborCollection()
+
+      // MT 4, AI 30 - reserved
+      expect(() => parseArray('9e')).toThrow('Invalid additional info: 30')
+    })
+
+    it('should throw error for map with reserved AI 28', () => {
+      const { parseMap } = useCborCollection()
+
+      // MT 5, AI 28 - reserved
+      expect(() => parseMap('bc')).toThrow('Invalid additional info: 28')
+    })
+
+    it('should throw error for map with reserved AI 29', () => {
+      const { parseMap } = useCborCollection()
+
+      // MT 5, AI 29 - reserved
+      expect(() => parseMap('bd')).toThrow('Invalid additional info: 29')
+    })
+
+    it('should throw error for map with reserved AI 30', () => {
+      const { parseMap } = useCborCollection()
+
+      // MT 5, AI 30 - reserved
+      expect(() => parseMap('be')).toThrow('Invalid additional info: 30')
+    })
+  })
+
+  describe('parseArray - Wrong Major Type', () => {
+    it('should throw error when major type is not 4', () => {
+      const { parseArray } = useCborCollection()
+
+      // MT 0 (integer) is not an array
+      expect(() => parseArray('00')).toThrow('Expected major type 4 (array), got 0')
+    })
+
+    it('should throw error for MT 5 (map)', () => {
+      const { parseArray } = useCborCollection()
+
+      // MT 5 (map) is not an array
+      expect(() => parseArray('a0')).toThrow('Expected major type 4 (array), got 5')
+    })
+  })
+
+  describe('parseMap - Wrong Major Type', () => {
+    it('should throw error when major type is not 5', () => {
+      const { parseMap } = useCborCollection()
+
+      // MT 0 (integer) is not a map
+      expect(() => parseMap('00')).toThrow('Expected major type 5 (map), got 0')
+    })
+
+    it('should throw error for MT 4 (array)', () => {
+      const { parseMap } = useCborCollection()
+
+      // MT 4 (array) is not a map
+      expect(() => parseMap('80')).toThrow('Expected major type 5 (map), got 4')
+    })
+  })
+
+  describe('parseArray - Insufficient Data', () => {
+    it('should throw error when array element is missing', () => {
+      const { parseArray } = useCborCollection()
+
+      // Array of 3, but only 2 elements
+      expect(() => parseArray('830102')).toThrow('Unexpected end of buffer while parsing array element 2/3')
+    })
+
+    it('should throw error when nested array is incomplete', () => {
+      const { parseArray } = useCborCollection()
+
+      // Array with incomplete nested structure
+      // 82 (array of 2) + 01 + 8301 (nested array of 3 with only 1 element)
+      expect(() => parseArray('8201830102')).toThrow('Unexpected end of buffer while parsing array element 2/3')
+    })
+  })
+
+  describe('parseMap - Insufficient Data', () => {
+    it('should throw error when map entry is missing', () => {
+      const { parseMap } = useCborCollection()
+
+      // Map of 2, but only 1 entry
+      expect(() => parseMap('a20102')).toThrow('Unexpected end of buffer while parsing map entry 1/2')
+    })
+
+    it('should throw error when map value is missing', () => {
+      const { parseMap } = useCborCollection()
+
+      // Map of 1, with key but no value
+      expect(() => parseMap('a101')).toThrow('Unexpected end of buffer while parsing map value for entry 0/1')
+    })
+
+    it('should throw error in indefinite map when value is missing after key', () => {
+      const { parseMap } = useCborCollection()
+
+      // Indefinite map with key but no value before break
+      // bf (indefinite map) + 01 (key) - missing value
+      expect(() => parseMap('bf01')).toThrow('Unexpected end of buffer while parsing map value')
+    })
+  })
+
+  describe('Indefinite-Length Collections', () => {
+    it('should parse indefinite array with proper break', () => {
+      const { parseArray } = useCborCollection()
+
+      // 9f (indefinite array) + 01 02 03 + ff (break)
+      const result = parseArray('9f010203ff')
+      // Use spread to get clean array without Symbol metadata
+      expect([...result.value]).toEqual([1, 2, 3])
+    })
+
+    it('should parse indefinite map with proper break', () => {
+      const { parseMap } = useCborCollection()
+
+      // bf (indefinite map) + 01 02 03 04 + ff (break)
+      const result = parseMap('bf01020304ff')
+      // Use spread to get clean map without Symbol metadata
+      expect(new Map([...result.value])).toEqual(new Map([[1, 2], [3, 4]]))
+    })
+
+    it('should parse nested indefinite structures', () => {
+      const { parseArray } = useCborCollection()
+
+      // 9f (indefinite array) + 9f 01 ff (nested indefinite array [1]) + ff (break)
+      const result = parseArray('9f9f01ffff')
+      // Use spread to get clean arrays without Symbol metadata
+      expect([...result.value].map(inner => [...inner])).toEqual([[1]])
+    })
+  })
+
+  describe('Complex Nested Structures', () => {
+    it('should parse deeply nested arrays', () => {
+      const { parseArray } = useCborCollection()
+
+      // [[[[1]]]]
+      const result = parseArray('81818181 01'.replace(/\s/g, ''))
+      expect(result.value).toEqual([[[[1]]]])
+    })
+
+    it('should parse map with array values', () => {
+      const { parseMap } = useCborCollection()
+
+      // {"a": [1, 2], "b": [3, 4]}
+      const result = parseMap('a261618201026162820304')
+      expect(result.value).toEqual(new Map([['a', [1, 2]], ['b', [3, 4]]]))
+    })
+
+    it('should parse array with map values', () => {
+      const { parseArray } = useCborCollection()
+
+      // [{"x": 1}, {"y": 2}]
+      const result = parseArray('82a16178 01a16179 02'.replace(/\s/g, ''))
+      expect(result.value).toEqual([new Map([['x', 1]]), new Map([['y', 2]])])
+    })
+  })
+
+  describe('All Major Types in Collections', () => {
+    it('should parse array containing all major types', () => {
+      const { parseArray } = useCborCollection()
+
+      // Array with: integer, negative, text string, byte string, array, map, simple
+      // [0, -1, "", h'', [], {}, false]
+      // 87 (array of 7) + 00 (0) + 20 (-1) + 60 ("") + 40 (h'') + 80 ([]) + a0 ({}) + f4 (false)
+      const result = parseArray('8700206040 80a0f4'.replace(/\s/g, ''))
+      expect(result.value).toEqual([0, -1, '', new Uint8Array([]), [], new Map(), false])
+    })
+
+    it('should handle map with various key types', () => {
+      const { parseMap } = useCborCollection()
+
+      // Map with integer and string keys
+      // {1: "a", "b": 2}
+      const result = parseMap('a2016161616202')
+      expect(result.value).toEqual(new Map([[1, 'a'], ['b', 2]]))
+    })
+  })
+})