@highstate/designer 0.20.0 → 0.21.1

package/.output/server/node_modules/@vue/runtime-dom/dist/runtime-dom.cjs.prod.js

@@ -1,5 +1,5 @@
 /**
-* @vue/runtime-dom v3.5.28
+* @vue/runtime-dom v3.5.33
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -463,7 +463,19 @@ function patchStyle(el, prev, next) {
       if (key === "display") {
         hasControlledDisplay = true;
       }
-      setStyle(style, key, next[key]);
+      const value = next[key];
+      if (value != null) {
+        if (!shouldPreserveTextareaResizeStyle(
+          el,
+          key,
+          !shared.isString(prev) && prev ? prev[key] : void 0,
+          value
+        )) {
+          setStyle(style, key, value);
+        }
+      } else {
+        setStyle(style, key, "");
+      }
     }
   } else {
     if (isCssString) {
@@ -528,6 +540,9 @@ function autoPrefix(style, rawName) {
   }
   return rawName;
 }
+function shouldPreserveTextareaResizeStyle(el, key, prev, next) {
+  return el.tagName === "TEXTAREA" && (key === "width" || key === "height") && shared.isString(next) && prev === next;
+}
 
 const xlinkNS = "http://www.w3.org/1999/xlink";
 function patchAttr(el, key, value, isSVG, instance, isBoolean = shared.isSpecialBooleanAttr(key)) {
@@ -689,7 +704,9 @@ const patchProp = (el, key, prevValue, nextValue, namespace, parentComponent) =>
     }
   } else if (
     // #11081 force set props for possible async custom element
-    el._isVueCE && (/[A-Z]/.test(key) || !shared.isString(nextValue))
+    el._isVueCE && // #12408 check if it's declared prop or it's async custom element
+    (shouldSetAsPropForVueCE(el, key) || // @ts-expect-error _def is private
+    el._def.__asyncLoader && (/[A-Z]/.test(key) || !shared.isString(nextValue)))
   ) {
     patchDOMProp(el, shared.camelize(key), nextValue, parentComponent, key);
   } else {
@@ -737,6 +754,17 @@ function shouldSetAsProp(el, key, value, isSVG) {
   }
   return key in el;
 }
+function shouldSetAsPropForVueCE(el, key) {
+  const props = (
+    // @ts-expect-error _def is private
+    el._def.props
+  );
+  if (!props) {
+    return false;
+  }
+  const camelKey = shared.camelize(key);
+  return Array.isArray(props) ? props.some((prop) => shared.camelize(prop) === camelKey) : Object.keys(props).some((prop) => shared.camelize(prop) === camelKey);
+}
 
 const REMOVAL = {};
 // @__NO_SIDE_EFFECTS__
@@ -781,6 +809,7 @@ class VueElement extends BaseClass {
     this._dirty = false;
     this._numberProps = null;
     this._styleChildren = /* @__PURE__ */ new WeakSet();
+    this._styleAnchors = /* @__PURE__ */ new WeakMap();
     this._ob = null;
     if (this.shadowRoot && _createApp !== createApp) {
       this._root = this.shadowRoot;
@@ -804,7 +833,8 @@ class VueElement extends BaseClass {
     }
     this._connected = true;
     let parent = this;
-    while (parent = parent && (parent.parentNode || parent.host)) {
+    while (parent = parent && // #12479 should check assignedSlot first to get correct parent
+    (parent.assignedSlot || parent.parentNode || parent.host)) {
       if (parent instanceof VueElement) {
         this._parent = parent;
         break;
@@ -1030,7 +1060,7 @@ class VueElement extends BaseClass {
     }
     return vnode;
   }
-  _applyStyles(styles, owner) {
+  _applyStyles(styles, owner, parentComp) {
     if (!styles) return;
     if (owner) {
       if (owner === this._def || this._styleChildren.has(owner)) {
@@ -1039,13 +1069,43 @@ class VueElement extends BaseClass {
       this._styleChildren.add(owner);
     }
     const nonce = this._nonce;
+    const root = this.shadowRoot;
+    const insertionAnchor = parentComp ? this._getStyleAnchor(parentComp) || this._getStyleAnchor(this._def) : this._getRootStyleInsertionAnchor(root);
+    let last = null;
     for (let i = styles.length - 1; i >= 0; i--) {
       const s = document.createElement("style");
       if (nonce) s.setAttribute("nonce", nonce);
       s.textContent = styles[i];
-      this.shadowRoot.prepend(s);
+      root.insertBefore(s, last || insertionAnchor);
+      last = s;
+      if (i === 0) {
+        if (!parentComp) this._styleAnchors.set(this._def, s);
+        if (owner) this._styleAnchors.set(owner, s);
+      }
     }
   }
+  _getStyleAnchor(comp) {
+    if (!comp) {
+      return null;
+    }
+    const anchor = this._styleAnchors.get(comp);
+    if (anchor && anchor.parentNode === this.shadowRoot) {
+      return anchor;
+    }
+    if (anchor) {
+      this._styleAnchors.delete(comp);
+    }
+    return null;
+  }
+  _getRootStyleInsertionAnchor(root) {
+    for (let i = 0; i < root.childNodes.length; i++) {
+      const node = root.childNodes[i];
+      if (!(node instanceof HTMLStyleElement)) {
+        return node;
+      }
+    }
+    return null;
+  }
   /**
    * Only called when shadowRoot is false
    */
@@ -1108,8 +1168,8 @@ class VueElement extends BaseClass {
   /**
    * @internal
    */
-  _injectChildStyle(comp) {
-    this._applyStyles(comp.styles, comp);
+  _injectChildStyle(comp, parentComp) {
+    this._applyStyles(comp.styles, comp, parentComp);
   }
   /**
    * @internal
@@ -1372,7 +1432,8 @@ const vModelText = {
     if (elValue === newValue) {
       return;
     }
-    if (document.activeElement === el && el.type !== "range") {
+    const rootNode = el.getRootNode();
+    if ((rootNode instanceof Document || rootNode instanceof ShadowRoot) && rootNode.activeElement === el && el.type !== "range") {
       if (lazy && value === oldValue) {
         return;
       }

package/.output/server/node_modules/@vue/runtime-dom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue/runtime-dom",
-  "version": "3.5.28",
+  "version": "3.5.33",
   "description": "@vue/runtime-dom",
   "main": "index.js",
   "module": "dist/runtime-dom.esm-bundler.js",
@@ -50,9 +50,9 @@
   "homepage": "https://github.com/vuejs/core/tree/main/packages/runtime-dom#readme",
   "dependencies": {
     "csstype": "^3.2.3",
-    "@vue/runtime-core": "3.5.28",
-    "@vue/reactivity": "3.5.28",
-    "@vue/shared": "3.5.28"
+    "@vue/runtime-core": "3.5.33",
+    "@vue/shared": "3.5.33",
+    "@vue/reactivity": "3.5.33"
   },
   "devDependencies": {
     "@types/trusted-types": "^2.0.7"

package/.output/server/node_modules/@vue/server-renderer/dist/server-renderer.cjs.prod.js

@@ -1,5 +1,5 @@
 /**
-* @vue/server-renderer v3.5.28
+* @vue/server-renderer v3.5.33
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -36,10 +36,14 @@ function ssrRenderAttrs(props, tag) {
     }
     const value = props[key];
     if (key.startsWith("^")) key = key.slice(1);
-    if (key === "class" || key === "className") {
+    if (key === "class") {
       ret += ` class="${ssrRenderClass(value)}"`;
     } else if (key === "style") {
       ret += ` style="${ssrRenderStyle(value)}"`;
+    } else if (key === "className") {
+      if (value != null) {
+        ret += ` class="${shared.escapeHtml(String(value))}"`;
+      }
     } else {
       ret += ssrRenderDynamicAttr(key, value, tag);
     }

package/.output/server/node_modules/@vue/server-renderer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue/server-renderer",
-  "version": "3.5.28",
+  "version": "3.5.33",
   "description": "@vue/server-renderer",
   "main": "index.js",
   "module": "dist/server-renderer.esm-bundler.js",
@@ -46,10 +46,10 @@
   },
   "homepage": "https://github.com/vuejs/core/tree/main/packages/server-renderer#readme",
   "peerDependencies": {
-    "vue": "3.5.28"
+    "vue": "3.5.33"
   },
   "dependencies": {
-    "@vue/shared": "3.5.28",
-    "@vue/compiler-ssr": "3.5.28"
+    "@vue/shared": "3.5.33",
+    "@vue/compiler-ssr": "3.5.33"
   }
 }

package/.output/server/node_modules/@vue/shared/dist/shared.cjs.prod.js

@@ -1,5 +1,5 @@
 /**
-* @vue/shared v3.5.28
+* @vue/shared v3.5.33
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/

package/.output/server/node_modules/@vue/shared/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue/shared",
-  "version": "3.5.28",
+  "version": "3.5.33",
   "description": "internal utils shared across @vue packages",
   "main": "index.js",
   "module": "dist/shared.esm-bundler.js",

package/.output/server/node_modules/devalue/package.json

@@ -1,7 +1,7 @@
 {
   "name": "devalue",
   "description": "Gets the job done when JSON.stringify can't",
-  "version": "5.6.3",
+  "version": "5.7.1",
   "repository": "sveltejs/devalue",
   "sideEffects": false,
   "exports": {
@@ -20,6 +20,7 @@
   "devDependencies": {
     "@changesets/cli": "^2.29.6",
     "@js-temporal/polyfill": "^0.5.1",
+    "@types/node": "^24.12.0",
     "dts-buddy": "^0.6.2",
     "publint": "^0.3.12",
     "typescript": "^5.9.2",
@@ -32,6 +33,8 @@
     "changeset:version": "changeset version",
     "changeset:publish": "changeset publish",
     "build": "dts-buddy",
-    "test": "uvu"
+    "test": "uvu",
+    "bench": "node --allow-natives-syntax ./benchmarking/run.js",
+    "bench:compare": "node --allow-natives-syntax ./benchmarking/compare/index.js"
   }
 }

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

@@ -1,110 +1,60 @@
-/**
- * Base64 Encodes an arraybuffer
- * @param {ArrayBuffer} arraybuffer
- * @returns {string}
- */
-export function encode64(arraybuffer) {
-  const dv = new DataView(arraybuffer);
-  let binaryString = "";
+/* Baseline 2025 runtimes */
 
-  for (let i = 0; i < arraybuffer.byteLength; i++) {
-    binaryString += String.fromCharCode(dv.getUint8(i));
-  }
+/**	@type {(array_buffer: ArrayBuffer) => string} */
+export function encode_native(array_buffer) {
+	return new Uint8Array(array_buffer).toBase64();
+}
 
-  return binaryToAscii(binaryString);
+/**	@type {(base64: string) => ArrayBuffer} */
+export function decode_native(base64) {
+	return Uint8Array.fromBase64(base64).buffer;
 }
 
-/**
- * Decodes a base64 string into an arraybuffer
- * @param {string} string
- * @returns {ArrayBuffer}
- */
-export function decode64(string) {
-  const binaryString = asciiToBinary(string);
-  const arraybuffer = new ArrayBuffer(binaryString.length);
-  const dv = new DataView(arraybuffer);
+/* Node-compatible runtimes */
 
-  for (let i = 0; i < arraybuffer.byteLength; i++) {
-    dv.setUint8(i, binaryString.charCodeAt(i));
-  }
+/** @type {(array_buffer: ArrayBuffer) => string} */
+export function encode_buffer(array_buffer) {
+	return Buffer.from(array_buffer).toString('base64');
+}
 
-  return arraybuffer;
+/**	@type {(base64: string) => ArrayBuffer} */
+export function decode_buffer(base64) {
+	return Uint8Array.from(Buffer.from(base64, 'base64')).buffer;
 }
 
-const KEY_STRING =
-  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+/* Legacy runtimes */
 
-/**
- * Substitute for atob since it's deprecated in node.
- * Does not do any input validation.
- *
- * @see https://github.com/jsdom/abab/blob/master/lib/atob.js
- *
- * @param {string} data
- * @returns {string}
- */
-function asciiToBinary(data) {
-  if (data.length % 4 === 0) {
-    data = data.replace(/==?$/, "");
-  }
+/** @type {(array_buffer: ArrayBuffer) => string} */
+export function encode_legacy(array_buffer) {
+	const array = new Uint8Array(array_buffer);
+	let binary = '';
 
-  let output = "";
-  let buffer = 0;
-  let accumulatedBits = 0;
+	// the maximum number of arguments to String.fromCharCode.apply
+	// should be around 0xFFFF in modern engines
+	const chunk_size = 0x8000;
+	for (let i = 0; i < array.length; i += chunk_size) {
+		const chunk = array.subarray(i, i + chunk_size);
+		binary += String.fromCharCode.apply(null, chunk);
+	}
 
-  for (let i = 0; i < data.length; i++) {
-    buffer <<= 6;
-    buffer |= KEY_STRING.indexOf(data[i]);
-    accumulatedBits += 6;
-    if (accumulatedBits === 24) {
-      output += String.fromCharCode((buffer & 0xff0000) >> 16);
-      output += String.fromCharCode((buffer & 0xff00) >> 8);
-      output += String.fromCharCode(buffer & 0xff);
-      buffer = accumulatedBits = 0;
-    }
-  }
-  if (accumulatedBits === 12) {
-    buffer >>= 4;
-    output += String.fromCharCode(buffer);
-  } else if (accumulatedBits === 18) {
-    buffer >>= 2;
-    output += String.fromCharCode((buffer & 0xff00) >> 8);
-    output += String.fromCharCode(buffer & 0xff);
-  }
-  return output;
+	return btoa(binary);
 }
 
-/**
- * Substitute for btoa since it's deprecated in node.
- * Does not do any input validation.
- *
- * @see https://github.com/jsdom/abab/blob/master/lib/btoa.js
- *
- * @param {string} str
- * @returns {string}
- */
-function binaryToAscii(str) {
-  let out = "";
-  for (let i = 0; i < str.length; i += 3) {
-    /** @type {[number, number, number, number]} */
-    const groupsOfSix = [undefined, undefined, undefined, undefined];
-    groupsOfSix[0] = str.charCodeAt(i) >> 2;
-    groupsOfSix[1] = (str.charCodeAt(i) & 0x03) << 4;
-    if (str.length > i + 1) {
-      groupsOfSix[1] |= str.charCodeAt(i + 1) >> 4;
-      groupsOfSix[2] = (str.charCodeAt(i + 1) & 0x0f) << 2;
-    }
-    if (str.length > i + 2) {
-      groupsOfSix[2] |= str.charCodeAt(i + 2) >> 6;
-      groupsOfSix[3] = str.charCodeAt(i + 2) & 0x3f;
-    }
-    for (let j = 0; j < groupsOfSix.length; j++) {
-      if (typeof groupsOfSix[j] === "undefined") {
-        out += "=";
-      } else {
-        out += KEY_STRING[groupsOfSix[j]];
-      }
-    }
-  }
-  return out;
+/**	@type {(base64: string) => ArrayBuffer} */
+export function decode_legacy(base64) {
+	const binary_string = atob(base64);
+	const len = binary_string.length;
+	const array = new Uint8Array(len);
+
+	for (let i = 0; i < len; i++) {
+		array[i] = binary_string.charCodeAt(i);
+	}
+
+	return array.buffer;
 }
+
+const native = typeof Uint8Array.fromBase64 === 'function';
+const buffer = typeof process === 'object' && process.versions?.node !== undefined;
+
+export const encode64 = native ? encode_native : buffer ? encode_buffer : encode_legacy;
+export const decode64 = native ? decode_native : buffer ? decode_buffer : decode_legacy;

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

@@ -66,10 +66,7 @@ export function unflatten(parsed, revivers) {
 			if (typeof value[0] === 'string') {
 				const type = value[0];
 
-				const reviver =
-					revivers && Object.hasOwn(revivers, type)
-						? revivers[type]
-						: undefined;
+				const reviver = revivers && Object.hasOwn(revivers, type) ? revivers[type] : undefined;
 
 				if (reviver) {
 					let i = value[1];
@@ -117,9 +114,20 @@ export function unflatten(parsed, revivers) {
 						hydrated[index] = new RegExp(value[1], value[2]);
 						break;
 
-					case 'Object':
-						hydrated[index] = Object(value[1]);
+					case 'Object': {
+						const wrapped_index = value[1];
+
+						if (
+							typeof values[wrapped_index] === 'object' &&
+							values[wrapped_index][0] !== 'BigInt'
+						) {
+							// avoid infinite recusion in case of malformed input
+							throw new Error('Invalid input');
+						}
+
+						hydrated[index] = Object(hydrate(wrapped_index));
 						break;
+					}
 
 					case 'BigInt':
 						hydrated[index] = BigInt(value[1]);
@@ -129,6 +137,10 @@ export function unflatten(parsed, revivers) {
 						const obj = Object.create(null);
 						hydrated[index] = obj;
 						for (let i = 1; i < value.length; i += 2) {
+							if (value[i] === '__proto__') {
+								throw new Error('Cannot parse an object with a `__proto__` property');
+							}
+
 							obj[value[i]] = hydrate(value[i + 1]);
 						}
 						break;
@@ -138,12 +150,14 @@ export function unflatten(parsed, revivers) {
 					case 'Uint8ClampedArray':
 					case 'Int16Array':
 					case 'Uint16Array':
+					case 'Float16Array':
 					case 'Int32Array':
 					case 'Uint32Array':
 					case 'Float32Array':
 					case 'Float64Array':
 					case 'BigInt64Array':
-					case 'BigUint64Array': {
+					case 'BigUint64Array':
+					case 'DataView': {
 						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
@@ -153,12 +167,11 @@ export function unflatten(parsed, revivers) {
 
 						const TypedArrayConstructor = globalThis[type];
 						const buffer = hydrate(value[1]);
-						const typedArray = new TypedArrayConstructor(buffer);
 
 						hydrated[index] =
 							value[2] !== undefined
-								? typedArray.subarray(value[2], value[3])
-								: typedArray;
+								? new TypedArrayConstructor(buffer, value[2], value[3])
+								: new TypedArrayConstructor(buffer);
 
 						break;
 					}
@@ -206,11 +219,20 @@ export function unflatten(parsed, revivers) {
 				// Sparse array encoding: [SPARSE, length, idx, val, idx, val, ...]
 				const len = value[1];
 
+				if (!Number.isInteger(len) || len < 0) {
+					throw new Error('Invalid input');
+				}
+
 				const array = new Array(len);
 				hydrated[index] = array;
 
 				for (let i = 2; i < value.length; i += 2) {
 					const idx = value[i];
+
+					if (!Number.isInteger(idx) || idx < 0 || idx >= len) {
+						throw new Error('Invalid input');
+					}
+
 					array[idx] = hydrate(value[i + 1]);
 				}
 			} else {

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

@@ -52,7 +52,7 @@ export function stringify(value, reducers) {
 		if (thing === -Infinity) return NEGATIVE_INFINITY;
 		if (thing === 0 && 1 / thing < 0) return NEGATIVE_ZERO;
 
-		if (indexes.has(thing)) return indexes.get(thing);
+		if (indexes.has(thing)) return /** @type {number} */ (indexes.get(thing));
 
 		const index = p++;
 		indexes.set(thing, index);
@@ -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 = '';
@@ -80,11 +82,8 @@ export function stringify(value, reducers) {
 				case 'Number':
 				case 'String':
 				case 'Boolean':
-					str = `["Object",${stringify_primitive(thing)}]`;
-					break;
-
 				case 'BigInt':
-					str = `["BigInt",${thing}]`;
+					str = `["Object",${flatten(thing.valueOf())}]`;
 					break;
 
 				case 'Date':
@@ -205,9 +204,7 @@ export function stringify(value, reducers) {
 					str = '["Map"';
 
 					for (const [key, value] of thing) {
-						keys.push(
-							`.get(${is_primitive(key) ? stringify_primitive(key) : '...'})`
-						);
+						keys.push(`.get(${is_primitive(key) ? stringify_primitive(key) : '...'})`);
 						str += `,${flatten(key)},${flatten(value)}`;
 						keys.pop();
 					}
@@ -220,23 +217,22 @@ export function stringify(value, reducers) {
 				case 'Uint8ClampedArray':
 				case 'Int16Array':
 				case 'Uint16Array':
+				case 'Float16Array':
 				case 'Int32Array':
 				case 'Uint32Array':
 				case 'Float32Array':
 				case 'Float64Array':
 				case 'BigInt64Array':
-				case 'BigUint64Array': {
+				case 'BigUint64Array':
+				case 'DataView': {
 					/** @type {import("./types.js").TypedArray} */
 					const typedArray = thing;
 					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}`;
+					if (typedArray.byteLength !== typedArray.buffer.byteLength) {
+						// to be used with `new TypedArray(buffer, byteOffset, length)`
+						str += `,${typedArray.byteOffset},${typedArray.length}`;
 					}
 
 					str += ']';
@@ -265,21 +261,11 @@ export function stringify(value, reducers) {
 
 				default:
 					if (!is_plain_object(thing)) {
-						throw new DevalueError(
-							`Cannot stringify arbitrary non-POJOs`,
-							keys,
-							thing,
-							value
-						);
+						throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys, thing, value);
 					}
 
 					if (enumerable_symbols(thing).length > 0) {
-						throw new DevalueError(
-							`Cannot stringify POJOs with symbolic keys`,
-							keys,
-							thing,
-							value
-						);
+						throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys, thing, value);
 					}
 
 					if (Object.getPrototypeOf(thing) === null) {
@@ -342,7 +328,6 @@ export function stringify(value, reducers) {
 function stringify_primitive(thing) {
 	const type = typeof thing;
 	if (type === 'string') return stringify_string(thing);
-	if (thing instanceof String) return stringify_string(thing.toString());
 	if (thing === void 0) return UNDEFINED.toString();
 	if (thing === 0 && 1 / thing < 0) return NEGATIVE_ZERO.toString();
 	if (type === 'bigint') return `["BigInt","${thing}"]`;