@@ -0,0 +1,5 @@
+---
+'devalue': patch
+---
+
+fix: get `uneval` type handling up to parity with `stringify`
@@ -67,6 +67,8 @@ export function stringify(value, reducers) {
 
 		if (typeof thing === 'function') {
 			throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
+		} else if (typeof thing === 'symbol') {
+			throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
 		}
 
 		let str = '';
 
@@ -136,6 +136,8 @@ export function uneval(value, replacer) {
 						keys.pop();
 					}
 			}
+		} else if (typeof thing === 'symbol') {
+			throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
 		}
 	}
 
@@ -284,11 +286,11 @@ export function uneval(value, replacer) {
 			case 'BigUint64Array': {
 				let str = `new ${type}`;
 
-				if (counts.get(thing.buffer) === 1) {
+				if (!names.has(thing.buffer)) {
 					const array = new thing.constructor(thing.buffer);
 					str += `([${array}])`;
 				} else {
-					str += `([${stringify(thing.buffer)}])`;
+					str += `(${stringify(thing.buffer)})`;
 				}
 
 				// handle subarrays
@@ -359,6 +361,7 @@ export function uneval(value, replacer) {
 				case 'Number':
 				case 'String':
 				case 'Boolean':
+				case 'BigInt':
 					values.push(`Object(${stringify(thing.valueOf())})`);
 					break;
 
@@ -370,6 +373,14 @@ export function uneval(value, replacer) {
 					values.push(`new Date(${thing.getTime()})`);
 					break;
 
+				case 'URL':
+					values.push(`new URL(${stringify_string(thing.toString())})`);
+					break;
+
+				case 'URLSearchParams':
+					values.push(`new URLSearchParams(${stringify_string(thing.toString())})`);
+					break;
+
 				case 'Array':
 					values.push(`Array(${thing.length})`);
 					/** @type {any[]} */ (thing).forEach((v, i) => {
@@ -395,8 +406,41 @@ export function uneval(value, replacer) {
 					);
 					break;
 
+				case 'Int8Array':
+				case 'Uint8Array':
+				case 'Uint8ClampedArray':
+				case 'Int16Array':
+				case 'Uint16Array':
+				case 'Float16Array':
+				case 'Int32Array':
+				case 'Uint32Array':
+				case 'Float32Array':
+				case 'Float64Array':
+				case 'BigInt64Array':
+				case 'BigUint64Array': {
+					let str = `new ${type}`;
+
+					if (!names.has(thing.buffer)) {
+						const array = new thing.constructor(thing.buffer);
+						str += `([${array}])`;
+					} else {
+						str += `(${stringify(thing.buffer)})`;
+					}
+
+					// handle subarrays
+					if (thing.byteLength !== thing.buffer.byteLength) {
+						const start = thing.byteOffset / thing.BYTES_PER_ELEMENT;
+						const end = start + thing.length;
+						str += `.subarray(${start},${end})`;
+					}
+
+					values.push(`{}`);
+					statements.push(`${name}=${str}`);
+					break;
+				}
+
 				case 'ArrayBuffer':
-					values.push(`new Uint8Array([${new Uint8Array(thing).join(',')}]).buffer`);
+					values.push(`new Uint8Array([${new Uint8Array(thing)}]).buffer`);
 					break;
 
 				default:
 
@@ -112,6 +112,7 @@ const fixtures = {
 			js: 'null',
 			json: '[null]'
 		}
+		// symbols are not supported; see further tests
 	],
 
 	boxed_primitives: [
@@ -192,6 +193,7 @@ const fixtures = {
 			json: '[["Object",1],["BigInt","1"]]'
 		}
 		// it's not possible to box undefined or null
+		// boxed symbols are not supported; see further tests
 	],
 
 	basics: [
@@ -564,7 +566,7 @@ const fixtures = {
 
 	repetition: [
 		{
-			name: 'String (repetition)',
+			name: 'string (repetition)',
 			value: ['a string', 'a string'],
 			js: '["a string","a string"]',
 			json: '[[1,1],"a string"]'
@@ -577,14 +579,60 @@ const fixtures = {
 			json: '[[1,1],null]'
 		},
 
-		((object) => {
-			return {
-				name: 'Object (repetition)',
-				value: [object, object],
-				js: '(function(a){return [a,a]}({}))',
-				json: '[[1,1],{}]'
-			};
-		})({}),
+		{
+			name: 'number: NaN (repetition)',
+			value: [NaN, NaN],
+			js: '[NaN,NaN]',
+			json: `[[${consts.NAN},${consts.NAN}]]`
+		},
+
+		{
+			name: 'Number (repetition)',
+			value: ((number) => [number, number])(Object(42)),
+			js: '(function(a){return [a,a]}(Object(42)))',
+			json: '[[1,1],["Object",2],42]',
+			validate: ([a, b]) => assert.is(a, b)
+		},
+
+		{
+			name: 'BigInt (repetition)',
+			value: ((bigint) => [bigint, bigint])(Object(1n)),
+			js: '(function(a){return [a,a]}(Object(1n)))',
+			json: '[[1,1],["Object",2],["BigInt","1"]]',
+			validate: ([a, b]) => assert.is(a, b)
+		},
+
+		{
+			name: 'Number: NaN (repetition)',
+			value: ((nan) => [nan, nan])(Object(NaN)),
+			js: '(function(a){return [a,a]}(Object(NaN)))',
+			json: `[[1,1],["Object",${consts.NAN}]]`,
+			validate: ([a, b]) => assert.is(a, b)
+		},
+
+		{
+			name: 'Object (repetition)',
+			value: ((object) => [object, object])({}),
+			js: '(function(a){return [a,a]}({}))',
+			json: '[[1,1],{}]',
+			validate: ([a, b]) => assert.is(a, b)
+		},
+
+		{
+			name: 'RegExp (repetition)',
+			value: ((regexp) => [regexp, regexp])(/regexp/),
+			js: '(function(a){return [a,a]}(/regexp/))',
+			json: '[[1,1],["RegExp","regexp"]]',
+			validate: ([a, b]) => assert.is(a, b)
+		},
+
+		{
+			name: 'Date (repetition)',
+			value: ((date) => [date, date])(new Date(1e12)),
+			js: '(function(a){return [a,a]}(new Date(1000000000000)))',
+			json: '[[1,1],["Date","2001-09-09T01:46:40.000Z"]]',
+			validate: ([a, b]) => assert.is(a, b)
+		},
 
 		{
 			name: 'Array buffer (repetition)',
@@ -598,11 +646,30 @@ const fixtures = {
 
 				return [uint8, uint16];
 			})(),
-			js: '(function(a){return [new Uint8Array([a]),new Uint16Array([a])]}(new Uint8Array([0,1,2,3,4,5,6,7,8,9]).buffer))',
+			js: '(function(a){return [new Uint8Array(a),new Uint16Array(a)]}(new Uint8Array([0,1,2,3,4,5,6,7,8,9]).buffer))',
 			json: '[[1,3],["Uint8Array",2],["ArrayBuffer","AAECAwQFBgcICQ=="],["Uint16Array",2]]',
-			validate: ([uint8, uint16]) => {
-				return uint8.buffer === uint16.buffer;
-			}
+			validate: ([uint8, uint16]) => assert.is(uint8.buffer, uint16.buffer)
+		},
+
+		{
+			name: 'TypedArray (repetition)',
+			value: (() => {
+				const uint8 = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+				return [uint8, uint8];
+			})(),
+			js: '(function(a){a=new Uint8Array([0,1,2,3,4,5,6,7,8,9]);return [a,a]}({}))',
+			json: '[[1,1],["Uint8Array",2],["ArrayBuffer","AAECAwQFBgcICQ=="]]'
+		},
+
+		{
+			name: 'Array Buffer and TypedArray (repetition)',
+			value: (() => {
+				const uint8 = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+				const uint16 = new Uint16Array(uint8.buffer);
+				return [uint8, uint8, uint16];
+			})(),
+			js: '(function(a,b){a=new Uint8Array(b);return [a,a,new Uint16Array(b)]}({},new Uint8Array([0,1,2,3,4,5,6,7,8,9]).buffer))',
+			json: '[[1,1,3],["Uint8Array",2],["ArrayBuffer","AAECAwQFBgcICQ=="],["Uint16Array",2]]'
 		}
 	],
 
@@ -1020,6 +1087,14 @@ for (const fn of [uneval, stringify]) {
 		assert.throws(() => fn(foo));
 	});
 
+	uvu.test(`${fn.name} throws for Symbols`, () => {
+		assert.throws(() => fn(Symbol('foo')));
+	});
+
+	uvu.test(`${fn.name} throws for boxed Symbols`, () => {
+		assert.throws(() => fn(Object(Symbol('foo'))));
+	});
+
 	uvu.test(`${fn.name} throws for symbolic keys`, () => {
 		assert.throws(() => fn({ [Symbol()]: null }));
 	});
-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +'devalue': patch
 +---
++
 +fix: get `uneval` type handling up to parity with `stringify`
Original file line number	Diff line number	Diff line change
`@@ -67,6 +67,8 @@ export function stringify(value, reducers) {`
`67`	`67`
`68`	`68`	`if (typeof thing === 'function') {`
`69`	`69`	throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
	`70`	`+ } else if (typeof thing === 'symbol') {`
	`71`	+ throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
`70`	`72`	`}`
`71`	`73`
`72`	`74`	`let str = '';`