@highstate/designer 0.19.1 → 0.20.0

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

@@ -5,6 +5,7 @@ import {
 	NEGATIVE_INFINITY,
 	NEGATIVE_ZERO,
 	POSITIVE_INFINITY,
+	SPARSE,
 	UNDEFINED
 } from './constants.js';
 
@@ -33,6 +34,13 @@ export function unflatten(parsed, revivers) {
 
 	const hydrated = Array(values.length);
 
+	/**
+	 * A set of values currently being hydrated with custom revivers,
+	 * used to detect invalid cyclical dependencies
+	 * @type {Set<number> | null}
+	 */
+	let hydrating = null;
+
 	/**
 	 * @param {number} index
 	 * @returns {any}
@@ -58,9 +66,30 @@ export function unflatten(parsed, revivers) {
 			if (typeof value[0] === 'string') {
 				const type = value[0];
 
-				const reviver = revivers?.[type];
+				const reviver =
+					revivers && Object.hasOwn(revivers, type)
+						? revivers[type]
+						: undefined;
+
 				if (reviver) {
-					return (hydrated[index] = reviver(hydrate(value[1])));
+					let i = value[1];
+					if (typeof i !== 'number') {
+						// if it's not a number, it was serialized by a builtin reviver
+						// so we need to munge it into the format expected by a custom reviver
+						i = values.push(value[1]) - 1;
+					}
+
+					hydrating ??= new Set();
+
+					if (hydrating.has(i)) {
+						throw new Error('Invalid circular reference');
+					}
+
+					hydrating.add(i);
+					hydrated[index] = reviver(hydrate(i));
+					hydrating.delete(i);
+
+					return hydrated[index];
 				}
 
 				switch (type) {
@@ -115,8 +144,16 @@ export function unflatten(parsed, revivers) {
 					case 'Float64Array':
 					case 'BigInt64Array':
 					case 'BigUint64Array': {
+						if (values[value[1]][0] !== 'ArrayBuffer') {
+							// without this, if we receive malformed input we could
+							// end up trying to hydrate in a circle or allocate
+							// huge amounts of memory when we call `new TypedArrayConstructor(buffer)`
+							throw new Error('Invalid data');
+						}
+
 						const TypedArrayConstructor = globalThis[type];
-						const typedArray = new TypedArrayConstructor(hydrate(value[1]));
+						const buffer = hydrate(value[1]);
+						const typedArray = new TypedArrayConstructor(buffer);
 
 						hydrated[index] =
 							value[2] !== undefined
@@ -128,6 +165,9 @@ export function unflatten(parsed, revivers) {
 
 					case 'ArrayBuffer': {
 						const base64 = value[1];
+						if (typeof base64 !== 'string') {
+							throw new Error('Invalid ArrayBuffer encoding');
+						}
 						const arraybuffer = decode64(base64);
 						hydrated[index] = arraybuffer;
 						break;
@@ -162,6 +202,17 @@ export function unflatten(parsed, revivers) {
 					default:
 						throw new Error(`Unknown type ${type}`);
 				}
+			} else if (value[0] === SPARSE) {
+				// Sparse array encoding: [SPARSE, length, idx, val, idx, val, ...]
+				const len = value[1];
+
+				const array = new Array(len);
+				hydrated[index] = array;
+
+				for (let i = 2; i < value.length; i += 2) {
+					const idx = value[i];
+					array[idx] = hydrate(value[i + 1]);
+				}
 			} else {
 				const array = new Array(value.length);
 				hydrated[index] = array;
@@ -178,7 +229,7 @@ export function unflatten(parsed, revivers) {
 			const object = {};
 			hydrated[index] = object;
 
-			for (const key in value) {
+			for (const key of Object.keys(value)) {
 				if (key === '__proto__') {
 					throw new Error('Cannot parse an object with a `__proto__` property');
 				}

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

@@ -5,7 +5,8 @@ import {
 	is_plain_object,
 	is_primitive,
 	stringify_key,
-	stringify_string
+	stringify_string,
+	valid_array_indices
 } from './utils.js';
 import {
 	HOLE,
@@ -13,6 +14,7 @@ import {
 	NEGATIVE_INFINITY,
 	NEGATIVE_ZERO,
 	POSITIVE_INFINITY,
+	SPARSE,
 	UNDEFINED
 } from './constants.js';
 import { encode64 } from './base64.js';
@@ -44,10 +46,6 @@ export function stringify(value, reducers) {
 
 	/** @param {any} thing */
 	function flatten(thing) {
-		if (typeof thing === 'function') {
-			throw new DevalueError(`Cannot stringify a function`, keys);
-		}
-
 		if (thing === undefined) return UNDEFINED;
 		if (Number.isNaN(thing)) return NAN;
 		if (thing === Infinity) return POSITIVE_INFINITY;
@@ -67,6 +65,10 @@ export function stringify(value, reducers) {
 			}
 		}
 
+		if (typeof thing === 'function') {
+			throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
+		}
+
 		let str = '';
 
 		if (is_primitive(thing)) {
@@ -105,24 +107,89 @@ export function stringify(value, reducers) {
 						: `["RegExp",${stringify_string(source)}]`;
 					break;
 
-				case 'Array':
+				case 'Array': {
+					// For dense arrays (no holes), we iterate normally.
+					// When we encounter the first hole, we call Object.keys
+					// to determine the sparseness, then decide between:
+					//   - HOLE encoding: [-2, val, -2, ...] (default)
+					//   - Sparse encoding: [-7, length, idx, val, ...] (for very sparse arrays)
+					// Only the sparse path avoids iterating every slot, which
+					// is what protects against the DoS of e.g. `arr[1000000] = 1`.
+					let mostly_dense = false;
+
 					str = '[';
 
 					for (let i = 0; i < thing.length; i += 1) {
 						if (i > 0) str += ',';
 
-						if (i in thing) {
+						if (Object.hasOwn(thing, i)) {
 							keys.push(`[${i}]`);
 							str += flatten(thing[i]);
 							keys.pop();
-						} else {
+						} else if (mostly_dense) {
+							// Use dense encoding. The heuristic guarantees the
+							// array is only mildly sparse, so iterating over every
+							// slot is fine.
 							str += HOLE;
+						} else {
+							// Decide between HOLE encoding and sparse encoding.
+							//
+							// HOLE encoding: each hole is serialized as the HOLE
+							// sentinel (-2). For example, [, "a", ,] becomes
+							// [-2, 0, -2]. Each hole costs 3 chars ("-2" + comma).
+							//
+							// Sparse encoding: lists only populated indices.
+							// For example, [, "a", ,] becomes [-7, 3, 1, 0] — the
+							// -7 sentinel, the array length (3), then index-value
+							// pairs. This avoids paying per-hole, but each element
+							// costs extra chars to write its index.
+							//
+							// The values are the same size either way, so the
+							// choice comes down to structural overhead:
+							//
+							//   HOLE overhead:
+							//     3 chars per hole ("-2" + comma)
+							//     = (L - P) * 3
+							//
+							//   Sparse overhead:
+							//     "-7,"          — 3 chars (sparse sentinel + comma)
+							//     + length + "," — (d + 1) chars (array length + comma)
+							//     + per element: index + "," — (d + 1) chars
+							//     = (4 + d) + P * (d + 1)
+							//
+							// where L is the array length, P is the number of
+							// populated elements, and d is the number of digits
+							// in L (an upper bound on the digits in any index).
+							//
+							// Sparse encoding is cheaper when:
+							//   (4 + d) + P * (d + 1) < (L - P) * 3
+							const populated_keys = valid_array_indices(/** @type {any[]} */ (thing));
+							const population = populated_keys.length;
+							const d = String(thing.length).length;
+
+							const hole_cost = (thing.length - population) * 3;
+							const sparse_cost = 4 + d + population * (d + 1);
+
+							if (hole_cost > sparse_cost) {
+								str = '[' + SPARSE + ',' + thing.length;
+								for (let j = 0; j < populated_keys.length; j++) {
+									const key = populated_keys[j];
+									keys.push(`[${key}]`);
+									str += ',' + key + ',' + flatten(thing[key]);
+									keys.pop();
+								}
+								break;
+							} else {
+								mostly_dense = true;
+								str += HOLE;
+							}
 						}
 					}
 
 					str += ']';
 
 					break;
+				}
 
 				case 'Set':
 					str = '["Set"';
@@ -200,20 +267,33 @@ export function stringify(value, reducers) {
 					if (!is_plain_object(thing)) {
 						throw new DevalueError(
 							`Cannot stringify arbitrary non-POJOs`,
-							keys
+							keys,
+							thing,
+							value
 						);
 					}
 
 					if (enumerable_symbols(thing).length > 0) {
 						throw new DevalueError(
 							`Cannot stringify POJOs with symbolic keys`,
-							keys
+							keys,
+							thing,
+							value
 						);
 					}
 
 					if (Object.getPrototypeOf(thing) === null) {
 						str = '["null"';
-						for (const key in thing) {
+						for (const key of Object.keys(thing)) {
+							if (key === '__proto__') {
+								throw new DevalueError(
+									`Cannot stringify objects with __proto__ keys`,
+									keys,
+									thing,
+									value
+								);
+							}
+
 							keys.push(stringify_key(key));
 							str += `,${stringify_string(key)},${flatten(thing[key])}`;
 							keys.pop();
@@ -222,7 +302,16 @@ export function stringify(value, reducers) {
 					} else {
 						str = '{';
 						let started = false;
-						for (const key in thing) {
+						for (const key of Object.keys(thing)) {
+							if (key === '__proto__') {
+								throw new DevalueError(
+									`Cannot stringify objects with __proto__ keys`,
+									keys,
+									thing,
+									value
+								);
+							}
+
 							if (started) str += ',';
 							started = true;
 							keys.push(stringify_key(key));

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

@@ -6,7 +6,8 @@ import {
 	is_plain_object,
 	is_primitive,
 	stringify_key,
-	stringify_string
+	stringify_string,
+	valid_array_indices
 } from './utils.js';
 
 const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$';
@@ -29,10 +30,6 @@ export function uneval(value, replacer) {
 
 	/** @param {any} thing */
 	function walk(thing) {
-		if (typeof thing === 'function') {
-			throw new DevalueError(`Cannot stringify a function`, keys);
-		}
-
 		if (!is_primitive(thing)) {
 			if (counts.has(thing)) {
 				counts.set(thing, counts.get(thing) + 1);
@@ -50,6 +47,10 @@ export function uneval(value, replacer) {
 				}
 			}
 
+			if (typeof thing === 'function') {
+				throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
+			}
+
 			const type = get_type(thing);
 
 			switch (type) {
@@ -116,18 +117,31 @@ export function uneval(value, replacer) {
 					if (!is_plain_object(thing)) {
 						throw new DevalueError(
 							`Cannot stringify arbitrary non-POJOs`,
-							keys
+							keys,
+							thing,
+							value
 						);
 					}
 
 					if (enumerable_symbols(thing).length > 0) {
 						throw new DevalueError(
 							`Cannot stringify POJOs with symbolic keys`,
-							keys
+							keys,
+							thing,
+							value
 						);
 					}
 
-					for (const key in thing) {
+					for (const key of Object.keys(thing)) {
+						if (key === '__proto__') {
+							throw new DevalueError(
+								`Cannot stringify objects with __proto__ keys`,
+								keys,
+								thing,
+								value
+							);
+						}
+
 						keys.push(stringify_key(key));
 						walk(thing[key]);
 						keys.pop();
@@ -186,12 +200,85 @@ export function uneval(value, replacer) {
 			case 'URLSearchParams':
 				return `new URLSearchParams(${stringify_string(thing.toString())})`;
 
-			case 'Array':
-				const members = /** @type {any[]} */ (thing).map((v, i) =>
-					i in thing ? stringify(v) : ''
-				);
+			case 'Array': {
+				// For dense arrays (no holes), we iterate normally.
+				// When we encounter the first hole, we call Object.keys
+				// to determine the sparseness, then decide between:
+				//   - Array literal with holes: [,"a",,] (default)
+				//   - Object.assign: Object.assign(Array(n),{...}) (for very sparse arrays)
+				// Only the Object.assign path avoids iterating every slot, which
+				// is what protects against the DoS of e.g. `arr[1000000] = 1`.
+				let has_holes = false;
+
+				let result = '[';
+
+				for (let i = 0; i < thing.length; i += 1) {
+					if (i > 0) result += ',';
+
+					if (Object.hasOwn(thing, i)) {
+						result += stringify(thing[i]);
+					} else if (!has_holes) {
+						// Decide between array literal and Object.assign.
+						//
+						// Array literal: holes are consecutive commas.
+						// For example, [, "a", ,] is written as [,"a",,].
+						// Each hole costs 1 char (a comma).
+						//
+						// Object.assign: populated indices are listed explicitly.
+						// For example, [, "a", ,] would be written as
+						// Object.assign(Array(3),{1:"a"}). This avoids paying
+						// per-hole, but has a large fixed overhead for the
+						// "Object.assign(Array(n),{...})" wrapper, and each
+						// element costs extra chars for its index and colon.
+						//
+						// The serialized values are the same size either way, so
+						// the choice comes down to the structural overhead:
+						//
+						//   Array literal overhead:
+						//     1 char per element or hole (comma separators)
+						//     + 2 chars for "[" and "]"
+						//     = L + 2
+						//
+						//   Object.assign overhead:
+						//     "Object.assign(Array(" — 20 chars
+						//     + length              — d chars
+						//     + "),{"               — 3 chars
+						//     + for each populated element:
+						//       index + ":" + ","   — (d + 2) chars
+						//     + "})"                — 2 chars
+						//     = (25 + d) + P * (d + 2)
+						//
+						// where L is the array length, P is the number of
+						// populated elements, and d is the number of digits
+						// in L (an upper bound on the digits in any index).
+						//
+						// Object.assign is cheaper when:
+						//   (25 + d) + P * (d + 2) < L + 2
+						const populated_keys = valid_array_indices(/** @type {any[]} */ (thing));
+						const population = populated_keys.length;
+						const d = String(thing.length).length;
+
+						const hole_cost = thing.length + 2;
+						const sparse_cost = (25 + d) + population * (d + 2);
+
+						if (hole_cost > sparse_cost) {
+							const entries = populated_keys
+								.map((k) => `${k}:${stringify(thing[k])}`)
+								.join(',');
+							return `Object.assign(Array(${thing.length}),{${entries}})`;
+						}
+
+						// Re-process this index as a hole in the array literal
+						has_holes = true;
+						i -= 1;
+					}
+					// else: already decided on array literal, hole is just an empty slot
+					// (the comma separator is all we need — no content for this position)
+				}
+
 				const tail = thing.length === 0 || thing.length - 1 in thing ? '' : ',';
-				return `[${members.join(',')}${tail}]`;
+				return result + tail + ']';
+			}
 
 			case 'Set':
 			case 'Map':

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

@@ -15,11 +15,15 @@ export class DevalueError extends Error {
 	/**
 	 * @param {string} message
 	 * @param {string[]} keys
+	 * @param {any} [value] - The value that failed to be serialized
+	 * @param {any} [root] - The root value being serialized
 	 */
-	constructor(message, keys) {
+	constructor(message, keys, value, root) {
 		super(message);
 		this.name = 'DevalueError';
 		this.path = keys.join('');
+		this.value = value;
+		this.root = root;
 	}
 }
 
@@ -112,3 +116,33 @@ const is_identifier = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
 export function stringify_key(key) {
 	return is_identifier.test(key) ? '.' + key : '[' + JSON.stringify(key) + ']';
 }
+
+/** @param {string} s */
+function is_valid_array_index(s) {
+	if (s.length === 0) return false;
+	if (s.length > 1 && s.charCodeAt(0) === 48) return false; // leading zero
+	for (let i = 0; i < s.length; i++) {
+		const c = s.charCodeAt(i);
+		if (c < 48 || c > 57) return false;
+	}
+	// by this point we know it's a string of digits, but it has to be within the range of valid array indices
+	const n = +s;
+	if (n >= 2 ** 32 - 1) return false;
+	if (n < 0) return false;
+	return true;
+}
+
+/**
+ * Finds the populated indices of an array.
+ * @param {unknown[]} array
+ */
+export function valid_array_indices(array) {
+	const keys = Object.keys(array);
+	for (var i = keys.length - 1; i >= 0; i--) {
+		if (is_valid_array_index(keys[i])) {
+			break;
+		}
+	}
+	keys.length = i + 1;
+	return keys;
+}

package/.output/server/node_modules/entities/{lib/decode_codepoint.js → dist/commonjs/decode-codepoint.js}

@@ -2,8 +2,10 @@
 // Adapted from https://github.com/mathiasbynens/he/blob/36afe179392226cf1b6ccdb16ebbb7a5a844d93a/src/he.js#L106-L134
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.replaceCodePoint = exports.fromCodePoint = void 0;
-var decodeMap = new Map([
+exports.fromCodePoint = void 0;
+exports.replaceCodePoint = replaceCodePoint;
+exports.decodeCodePoint = decodeCodePoint;
+const decodeMap = new Map([
     [0, 65533],
     // C1 Unicode control character reference replacements
     [128, 8364],
@@ -38,17 +40,17 @@ var decodeMap = new Map([
  * Polyfill for `String.fromCodePoint`. It is used to create a string from a Unicode code point.
  */
 exports.fromCodePoint = 
-// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, node/no-unsupported-features/es-builtins
-(_a = String.fromCodePoint) !== null && _a !== void 0 ? _a : function (codePoint) {
-    var output = "";
-    if (codePoint > 0xffff) {
-        codePoint -= 0x10000;
-        output += String.fromCharCode(((codePoint >>> 10) & 0x3ff) | 0xd800);
-        codePoint = 0xdc00 | (codePoint & 0x3ff);
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, n/no-unsupported-features/es-builtins
+(_a = String.fromCodePoint) !== null && _a !== void 0 ? _a : ((codePoint) => {
+    let output = "";
+    if (codePoint > 65535) {
+        codePoint -= 65536;
+        output += String.fromCharCode(((codePoint >>> 10) & 1023) | 55296);
+        codePoint = 56320 | (codePoint & 1023);
     }
     output += String.fromCharCode(codePoint);
     return output;
-};
+});
 /**
  * Replace the given code point with a replacement character if it is a
  * surrogate or is outside the valid range. Otherwise return the code
@@ -56,12 +58,12 @@ exports.fromCodePoint =
  */
 function replaceCodePoint(codePoint) {
     var _a;
-    if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
-        return 0xfffd;
+    if ((codePoint >= 55296 && codePoint <= 57343) ||
+        codePoint > 1114111) {
+        return 65533;
     }
     return (_a = decodeMap.get(codePoint)) !== null && _a !== void 0 ? _a : codePoint;
 }
-exports.replaceCodePoint = replaceCodePoint;
 /**
  * Replace the code point if relevant, then convert it to a string.
  *
@@ -72,5 +74,4 @@ exports.replaceCodePoint = replaceCodePoint;
 function decodeCodePoint(codePoint) {
     return (0, exports.fromCodePoint)(replaceCodePoint(codePoint));
 }
-exports.default = decodeCodePoint;
-//# sourceMappingURL=decode_codepoint.js.map
+//# sourceMappingURL=decode-codepoint.js.map