@highstate/designer 0.9.28 → 0.9.30

package/.output/server/node_modules/devalue/src/parse.js

@@ -44,7 +44,9 @@ export function unflatten(parsed, revivers) {
 		if (index === NEGATIVE_INFINITY) return -Infinity;
 		if (index === NEGATIVE_ZERO) return -0;
 
-		if (standalone) throw new Error(`Invalid input`);
+		if (standalone || typeof index !== 'number') {
+			throw new Error(`Invalid input`);
+		}
 
 		if (index in hydrated) return hydrated[index];
 
@@ -102,31 +104,60 @@ export function unflatten(parsed, revivers) {
 						}
 						break;
 
-          case "Int8Array":
-          case "Uint8Array":
-          case "Uint8ClampedArray":
-          case "Int16Array":
-          case "Uint16Array":
-          case "Int32Array":
-          case "Uint32Array":
-          case "Float32Array":
-          case "Float64Array":
-          case "BigInt64Array":
-          case "BigUint64Array": {
-            const TypedArrayConstructor = globalThis[type];
-            const base64 = value[1];
-            const arraybuffer = decode64(base64);
-            const typedArray = new TypedArrayConstructor(arraybuffer);
-            hydrated[index] = typedArray;
-            break;
-          }
-
-          case "ArrayBuffer": {
-            const base64 = value[1];
-            const arraybuffer = decode64(base64);
-            hydrated[index] = arraybuffer;
-            break;
-          }
+					case 'Int8Array':
+					case 'Uint8Array':
+					case 'Uint8ClampedArray':
+					case 'Int16Array':
+					case 'Uint16Array':
+					case 'Int32Array':
+					case 'Uint32Array':
+					case 'Float32Array':
+					case 'Float64Array':
+					case 'BigInt64Array':
+					case 'BigUint64Array': {
+						const TypedArrayConstructor = globalThis[type];
+						const typedArray = new TypedArrayConstructor(hydrate(value[1]));
+
+						hydrated[index] =
+							value[2] !== undefined
+								? typedArray.subarray(value[2], value[3])
+								: typedArray;
+
+						break;
+					}
+
+					case 'ArrayBuffer': {
+						const base64 = value[1];
+						const arraybuffer = decode64(base64);
+						hydrated[index] = arraybuffer;
+						break;
+					}
+
+					case 'Temporal.Duration':
+					case 'Temporal.Instant':
+					case 'Temporal.PlainDate':
+					case 'Temporal.PlainTime':
+					case 'Temporal.PlainDateTime':
+					case 'Temporal.PlainMonthDay':
+					case 'Temporal.PlainYearMonth':
+					case 'Temporal.ZonedDateTime': {
+						const temporalName = type.slice(9);
+						// @ts-expect-error TS doesn't know about Temporal yet
+						hydrated[index] = Temporal[temporalName].from(value[1]);
+						break;
+					}
+
+					case 'URL': {
+						const url = new URL(value[1]);
+						hydrated[index] = url;
+						break;
+					}
+
+					case 'URLSearchParams': {
+						const url = new URLSearchParams(value[1]);
+						hydrated[index] = url;
+						break;
+					}
 
 					default:
 						throw new Error(`Unknown type ${type}`);
@@ -148,6 +179,10 @@ export function unflatten(parsed, revivers) {
 			hydrated[index] = object;
 
 			for (const key in value) {
+				if (key === '__proto__') {
+					throw new Error('Cannot parse an object with a `__proto__` property');
+				}
+
 				const n = value[key];
 				object[key] = hydrate(n);
 			}

package/.output/server/node_modules/devalue/src/stringify.js

@@ -48,14 +48,14 @@ export function stringify(value, reducers) {
 			throw new DevalueError(`Cannot stringify a function`, keys);
 		}
 
-		if (indexes.has(thing)) return indexes.get(thing);
-
 		if (thing === undefined) return UNDEFINED;
 		if (Number.isNaN(thing)) return NAN;
 		if (thing === Infinity) return POSITIVE_INFINITY;
 		if (thing === -Infinity) return NEGATIVE_INFINITY;
 		if (thing === 0 && 1 / thing < 0) return NEGATIVE_ZERO;
 
+		if (indexes.has(thing)) return indexes.get(thing);
+
 		const index = p++;
 		indexes.set(thing, index);
 
@@ -90,6 +90,14 @@ export function stringify(value, reducers) {
 					str = `["Date","${valid ? thing.toISOString() : ''}"]`;
 					break;
 
+				case 'URL':
+					str = `["URL",${stringify_string(thing.toString())}]`;
+					break;
+
+				case 'URLSearchParams':
+					str = `["URLSearchParams",${stringify_string(thing.toString())}]`;
+					break;
+
 				case 'RegExp':
 					const { source, flags } = thing;
 					str = flags
@@ -140,33 +148,54 @@ export function stringify(value, reducers) {
 					str += ']';
 					break;
 
-				case "Int8Array":
-				case "Uint8Array":
-				case "Uint8ClampedArray":
-				case "Int16Array":
-				case "Uint16Array":
-				case "Int32Array":
-				case "Uint32Array":
-				case "Float32Array":
-				case "Float64Array":
-				case "BigInt64Array":
-				case "BigUint64Array": {
+				case 'Int8Array':
+				case 'Uint8Array':
+				case 'Uint8ClampedArray':
+				case 'Int16Array':
+				case 'Uint16Array':
+				case 'Int32Array':
+				case 'Uint32Array':
+				case 'Float32Array':
+				case 'Float64Array':
+				case 'BigInt64Array':
+				case 'BigUint64Array': {
 					/** @type {import("./types.js").TypedArray} */
 					const typedArray = thing;
-					const base64 = encode64(typedArray.buffer);
-					str = '["' + type + '","' + base64 + '"]';
+					str = '["' + type + '",' + flatten(typedArray.buffer);
+
+					const a = thing.byteOffset;
+					const b = a + thing.byteLength;
+
+					// handle subarrays
+					if (a > 0 || b !== typedArray.buffer.byteLength) {
+						const m = +/(\d+)/.exec(type)[1] / 8;
+						str += `,${a / m},${b / m}`;
+					}
+
+					str += ']';
 					break;
 				}
-					
-				case "ArrayBuffer": {
+
+				case 'ArrayBuffer': {
 					/** @type {ArrayBuffer} */
 					const arraybuffer = thing;
 					const base64 = encode64(arraybuffer);
-					
+
 					str = `["ArrayBuffer","${base64}"]`;
 					break;
 				}
-				
+
+				case 'Temporal.Duration':
+				case 'Temporal.Instant':
+				case 'Temporal.PlainDate':
+				case 'Temporal.PlainTime':
+				case 'Temporal.PlainDateTime':
+				case 'Temporal.PlainMonthDay':
+				case 'Temporal.PlainYearMonth':
+				case 'Temporal.ZonedDateTime':
+					str = `["${type}",${stringify_string(thing.toString())}]`;
+					break;
+
 				default:
 					if (!is_plain_object(thing)) {
 						throw new DevalueError(

package/.output/server/node_modules/devalue/src/uneval.js

@@ -59,6 +59,8 @@ export function uneval(value, replacer) {
 				case 'Boolean':
 				case 'Date':
 				case 'RegExp':
+				case 'URL':
+				case 'URLSearchParams':
 					return;
 
 				case 'Array':
@@ -82,21 +84,32 @@ export function uneval(value, replacer) {
 						keys.pop();
 					}
 					break;
-				
-				case "Int8Array":
-				case "Uint8Array":
-				case "Uint8ClampedArray":
-				case "Int16Array":
-				case "Uint16Array":
-				case "Int32Array":
-				case "Uint32Array":
-				case "Float32Array":
-				case "Float64Array":
-				case "BigInt64Array":
-				case "BigUint64Array":
+
+				case 'Int8Array':
+				case 'Uint8Array':
+				case 'Uint8ClampedArray':
+				case 'Int16Array':
+				case 'Uint16Array':
+				case 'Int32Array':
+				case 'Uint32Array':
+				case 'Float32Array':
+				case 'Float64Array':
+				case 'BigInt64Array':
+				case 'BigUint64Array':
+					walk(thing.buffer);
 					return;
-				
-				case "ArrayBuffer":
+
+				case 'ArrayBuffer':
+					return;
+
+				case 'Temporal.Duration':
+				case 'Temporal.Instant':
+				case 'Temporal.PlainDate':
+				case 'Temporal.PlainTime':
+				case 'Temporal.PlainDateTime':
+				case 'Temporal.PlainMonthDay':
+				case 'Temporal.PlainYearMonth':
+				case 'Temporal.ZonedDateTime':
 					return;
 
 				default:
@@ -167,6 +180,12 @@ export function uneval(value, replacer) {
 			case 'Date':
 				return `new Date(${thing.getTime()})`;
 
+			case 'URL':
+				return `new URL(${stringify_string(thing.toString())})`;
+
+			case 'URLSearchParams':
+				return `new URLSearchParams(${stringify_string(thing.toString())})`;
+
 			case 'Array':
 				const members = /** @type {any[]} */ (thing).map((v, i) =>
 					i in thing ? stringify(v) : ''
@@ -177,28 +196,54 @@ export function uneval(value, replacer) {
 			case 'Set':
 			case 'Map':
 				return `new ${type}([${Array.from(thing).map(stringify).join(',')}])`;
-			
-			case "Int8Array":
-			case "Uint8Array":
-			case "Uint8ClampedArray":
-			case "Int16Array":
-			case "Uint16Array":
-			case "Int32Array":
-			case "Uint32Array":
-			case "Float32Array":
-			case "Float64Array":
-			case "BigInt64Array":
-			case "BigUint64Array": {
-				/** @type {import("./types.js").TypedArray} */
-				const typedArray = thing;
-				return `new ${type}([${typedArray.toString()}])`;
+
+			case 'Int8Array':
+			case 'Uint8Array':
+			case 'Uint8ClampedArray':
+			case 'Int16Array':
+			case 'Uint16Array':
+			case 'Int32Array':
+			case 'Uint32Array':
+			case 'Float32Array':
+			case 'Float64Array':
+			case 'BigInt64Array':
+			case 'BigUint64Array': {
+				let str = `new ${type}`;
+
+				if (counts.get(thing.buffer) === 1) {
+					const array = new thing.constructor(thing.buffer);
+					str += `([${array}])`;
+				} else {
+					str += `([${stringify(thing.buffer)}])`;
+				}
+
+				const a = thing.byteOffset;
+				const b = a + thing.byteLength;
+
+				// handle subarrays
+				if (a > 0 || b !== thing.buffer.byteLength) {
+					const m = +/(\d+)/.exec(type)[1] / 8;
+					str += `.subarray(${a / m},${b / m})`;
+				}
+
+				return str;
 			}
-				
-			case "ArrayBuffer": {
+
+			case 'ArrayBuffer': {
 				const ui8 = new Uint8Array(thing);
 				return `new Uint8Array([${ui8.toString()}]).buffer`;
 			}
 
+			case 'Temporal.Duration':
+			case 'Temporal.Instant':
+			case 'Temporal.PlainDate':
+			case 'Temporal.PlainTime':
+			case 'Temporal.PlainDateTime':
+			case 'Temporal.PlainMonthDay':
+			case 'Temporal.PlainYearMonth':
+			case 'Temporal.ZonedDateTime':
+				return `${type}.from(${stringify_string(thing.toString())})`;
+
 			default:
 				const obj = `{${Object.keys(thing)
 					.map((key) => `${safe_key(key)}:${stringify(thing[key])}`)
@@ -281,6 +326,12 @@ export function uneval(value, replacer) {
 					);
 					break;
 
+				case 'ArrayBuffer':
+					values.push(
+						`new Uint8Array([${new Uint8Array(thing).join(',')}]).buffer`
+					);
+					break;
+
 				default:
 					values.push(
 						Object.getPrototypeOf(thing) === null ? 'Object.create(null)' : '{}'

package/.output/server/node_modules/devalue/src/utils.js

@@ -41,6 +41,7 @@ export function is_plain_object(thing) {
 	return (
 		proto === Object.prototype ||
 		proto === null ||
+		Object.getPrototypeOf(proto) === null ||
 		Object.getOwnPropertyNames(proto).sort().join('\0') === object_proto_names
 	);
 }