@highstate/designer 0.9.3 → 0.9.5

package/.output/server/node_modules/devalue/index.js

@@ -1,3 +0,0 @@
-export { uneval } from './src/uneval.js';
-export { parse, unflatten } from './src/parse.js';
-export { stringify } from './src/stringify.js';

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

@@ -1,34 +0,0 @@
-{
-  "name": "devalue",
-  "description": "Gets the job done when JSON.stringify can't",
-  "version": "5.1.1",
-  "repository": "Rich-Harris/devalue",
-  "sideEffects": false,
-  "exports": {
-    ".": {
-      "types": "./types/index.d.ts",
-      "import": "./index.js",
-      "default": "./index.js"
-    }
-  },
-  "files": [
-    "index.js",
-    "src",
-    "types"
-  ],
-  "types": "./types/index.d.ts",
-  "devDependencies": {
-    "dts-buddy": "^0.0.4",
-    "publint": "^0.1.7",
-    "typescript": "^3.1.3",
-    "uvu": "^0.5.6"
-  },
-  "scripts": {
-    "build": "dts-buddy",
-    "test": "uvu test",
-    "prepublishOnly": "npm test && npm run build && publint"
-  },
-  "license": "MIT",
-  "type": "module",
-  "packageManager": "pnpm@8.5.1"
-}

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

@@ -1,110 +0,0 @@
-/**
- * Base64 Encodes an arraybuffer
- * @param {ArrayBuffer} arraybuffer
- * @returns {string}
- */
-export function encode64(arraybuffer) {
-  const dv = new DataView(arraybuffer);
-  let binaryString = "";
-
-  for (let i = 0; i < arraybuffer.byteLength; i++) {
-    binaryString += String.fromCharCode(dv.getUint8(i));
-  }
-
-  return binaryToAscii(binaryString);
-}
-
-/**
- * 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);
-
-  for (let i = 0; i < arraybuffer.byteLength; i++) {
-    dv.setUint8(i, binaryString.charCodeAt(i));
-  }
-
-  return arraybuffer;
-}
-
-const KEY_STRING =
-  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-/**
- * 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(/==?$/, "");
-  }
-
-  let output = "";
-  let buffer = 0;
-  let accumulatedBits = 0;
-
-  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;
-}
-
-/**
- * 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;
-}

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

@@ -1,6 +0,0 @@
-export const UNDEFINED = -1;
-export const HOLE = -2;
-export const NAN = -3;
-export const POSITIVE_INFINITY = -4;
-export const NEGATIVE_INFINITY = -5;
-export const NEGATIVE_ZERO = -6;

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

@@ -1,160 +0,0 @@
-import { decode64 } from './base64.js';
-import {
-	HOLE,
-	NAN,
-	NEGATIVE_INFINITY,
-	NEGATIVE_ZERO,
-	POSITIVE_INFINITY,
-	UNDEFINED
-} from './constants.js';
-
-/**
- * Revive a value serialized with `devalue.stringify`
- * @param {string} serialized
- * @param {Record<string, (value: any) => any>} [revivers]
- */
-export function parse(serialized, revivers) {
-	return unflatten(JSON.parse(serialized), revivers);
-}
-
-/**
- * Revive a value flattened with `devalue.stringify`
- * @param {number | any[]} parsed
- * @param {Record<string, (value: any) => any>} [revivers]
- */
-export function unflatten(parsed, revivers) {
-	if (typeof parsed === 'number') return hydrate(parsed, true);
-
-	if (!Array.isArray(parsed) || parsed.length === 0) {
-		throw new Error('Invalid input');
-	}
-
-	const values = /** @type {any[]} */ (parsed);
-
-	const hydrated = Array(values.length);
-
-	/**
-	 * @param {number} index
-	 * @returns {any}
-	 */
-	function hydrate(index, standalone = false) {
-		if (index === UNDEFINED) return undefined;
-		if (index === NAN) return NaN;
-		if (index === POSITIVE_INFINITY) return Infinity;
-		if (index === NEGATIVE_INFINITY) return -Infinity;
-		if (index === NEGATIVE_ZERO) return -0;
-
-		if (standalone) throw new Error(`Invalid input`);
-
-		if (index in hydrated) return hydrated[index];
-
-		const value = values[index];
-
-		if (!value || typeof value !== 'object') {
-			hydrated[index] = value;
-		} else if (Array.isArray(value)) {
-			if (typeof value[0] === 'string') {
-				const type = value[0];
-
-				const reviver = revivers?.[type];
-				if (reviver) {
-					return (hydrated[index] = reviver(hydrate(value[1])));
-				}
-
-				switch (type) {
-					case 'Date':
-						hydrated[index] = new Date(value[1]);
-						break;
-
-					case 'Set':
-						const set = new Set();
-						hydrated[index] = set;
-						for (let i = 1; i < value.length; i += 1) {
-							set.add(hydrate(value[i]));
-						}
-						break;
-
-					case 'Map':
-						const map = new Map();
-						hydrated[index] = map;
-						for (let i = 1; i < value.length; i += 2) {
-							map.set(hydrate(value[i]), hydrate(value[i + 1]));
-						}
-						break;
-
-					case 'RegExp':
-						hydrated[index] = new RegExp(value[1], value[2]);
-						break;
-
-					case 'Object':
-						hydrated[index] = Object(value[1]);
-						break;
-
-					case 'BigInt':
-						hydrated[index] = BigInt(value[1]);
-						break;
-
-					case 'null':
-						const obj = Object.create(null);
-						hydrated[index] = obj;
-						for (let i = 1; i < value.length; i += 2) {
-							obj[value[i]] = hydrate(value[i + 1]);
-						}
-						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;
-          }
-
-					default:
-						throw new Error(`Unknown type ${type}`);
-				}
-			} else {
-				const array = new Array(value.length);
-				hydrated[index] = array;
-
-				for (let i = 0; i < value.length; i += 1) {
-					const n = value[i];
-					if (n === HOLE) continue;
-
-					array[i] = hydrate(n);
-				}
-			}
-		} else {
-			/** @type {Record<string, any>} */
-			const object = {};
-			hydrated[index] = object;
-
-			for (const key in value) {
-				const n = value[key];
-				object[key] = hydrate(n);
-			}
-		}
-
-		return hydrated[index];
-	}
-
-	return hydrate(0);
-}

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

@@ -1,232 +0,0 @@
-import {
-	DevalueError,
-	enumerable_symbols,
-	get_type,
-	is_plain_object,
-	is_primitive,
-	stringify_key,
-	stringify_string
-} from './utils.js';
-import {
-	HOLE,
-	NAN,
-	NEGATIVE_INFINITY,
-	NEGATIVE_ZERO,
-	POSITIVE_INFINITY,
-	UNDEFINED
-} from './constants.js';
-import { encode64 } from './base64.js';
-
-/**
- * Turn a value into a JSON string that can be parsed with `devalue.parse`
- * @param {any} value
- * @param {Record<string, (value: any) => any>} [reducers]
- */
-export function stringify(value, reducers) {
-	/** @type {any[]} */
-	const stringified = [];
-
-	/** @type {Map<any, number>} */
-	const indexes = new Map();
-
-	/** @type {Array<{ key: string, fn: (value: any) => any }>} */
-	const custom = [];
-	if (reducers) {
-		for (const key of Object.getOwnPropertyNames(reducers)) {
-			custom.push({ key, fn: reducers[key] });
-		}
-	}
-
-	/** @type {string[]} */
-	const keys = [];
-
-	let p = 0;
-
-	/** @param {any} thing */
-	function flatten(thing) {
-		if (typeof thing === 'function') {
-			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;
-
-		const index = p++;
-		indexes.set(thing, index);
-
-		for (const { key, fn } of custom) {
-			const value = fn(thing);
-			if (value) {
-				stringified[index] = `["${key}",${flatten(value)}]`;
-				return index;
-			}
-		}
-
-		let str = '';
-
-		if (is_primitive(thing)) {
-			str = stringify_primitive(thing);
-		} else {
-			const type = get_type(thing);
-
-			switch (type) {
-				case 'Number':
-				case 'String':
-				case 'Boolean':
-					str = `["Object",${stringify_primitive(thing)}]`;
-					break;
-
-				case 'BigInt':
-					str = `["BigInt",${thing}]`;
-					break;
-
-				case 'Date':
-					const valid = !isNaN(thing.getDate());
-					str = `["Date","${valid ? thing.toISOString() : ''}"]`;
-					break;
-
-				case 'RegExp':
-					const { source, flags } = thing;
-					str = flags
-						? `["RegExp",${stringify_string(source)},"${flags}"]`
-						: `["RegExp",${stringify_string(source)}]`;
-					break;
-
-				case 'Array':
-					str = '[';
-
-					for (let i = 0; i < thing.length; i += 1) {
-						if (i > 0) str += ',';
-
-						if (i in thing) {
-							keys.push(`[${i}]`);
-							str += flatten(thing[i]);
-							keys.pop();
-						} else {
-							str += HOLE;
-						}
-					}
-
-					str += ']';
-
-					break;
-
-				case 'Set':
-					str = '["Set"';
-
-					for (const value of thing) {
-						str += `,${flatten(value)}`;
-					}
-
-					str += ']';
-					break;
-
-				case 'Map':
-					str = '["Map"';
-
-					for (const [key, value] of thing) {
-						keys.push(
-							`.get(${is_primitive(key) ? stringify_primitive(key) : '...'})`
-						);
-						str += `,${flatten(key)},${flatten(value)}`;
-						keys.pop();
-					}
-
-					str += ']';
-					break;
-
-				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 + '"]';
-					break;
-				}
-					
-				case "ArrayBuffer": {
-					/** @type {ArrayBuffer} */
-					const arraybuffer = thing;
-					const base64 = encode64(arraybuffer);
-					
-					str = `["ArrayBuffer","${base64}"]`;
-					break;
-				}
-				
-				default:
-					if (!is_plain_object(thing)) {
-						throw new DevalueError(
-							`Cannot stringify arbitrary non-POJOs`,
-							keys
-						);
-					}
-
-					if (enumerable_symbols(thing).length > 0) {
-						throw new DevalueError(
-							`Cannot stringify POJOs with symbolic keys`,
-							keys
-						);
-					}
-
-					if (Object.getPrototypeOf(thing) === null) {
-						str = '["null"';
-						for (const key in thing) {
-							keys.push(stringify_key(key));
-							str += `,${stringify_string(key)},${flatten(thing[key])}`;
-							keys.pop();
-						}
-						str += ']';
-					} else {
-						str = '{';
-						let started = false;
-						for (const key in thing) {
-							if (started) str += ',';
-							started = true;
-							keys.push(stringify_key(key));
-							str += `${stringify_string(key)}:${flatten(thing[key])}`;
-							keys.pop();
-						}
-						str += '}';
-					}
-			}
-		}
-
-		stringified[index] = str;
-		return index;
-	}
-
-	const index = flatten(value);
-
-	// special case — value is represented as a negative index
-	if (index < 0) return `${index}`;
-
-	return `[${stringified.join(',')}]`;
-}
-
-/**
- * @param {any} thing
- * @returns {string}
- */
-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}"]`;
-	return String(thing);
-}