@highstate/designer 0.9.16 → 0.9.19

package/.output/server/node_modules/superjson/dist/accessDeep.js

@@ -0,0 +1,123 @@
+import { isMap, isArray, isPlainObject, isSet } from './is.js';
+import { includes } from './util.js';
+const getNthKey = (value, n) => {
+    if (n > value.size)
+        throw new Error('index out of bounds');
+    const keys = value.keys();
+    while (n > 0) {
+        keys.next();
+        n--;
+    }
+    return keys.next().value;
+};
+function validatePath(path) {
+    if (includes(path, '__proto__')) {
+        throw new Error('__proto__ is not allowed as a property');
+    }
+    if (includes(path, 'prototype')) {
+        throw new Error('prototype is not allowed as a property');
+    }
+    if (includes(path, 'constructor')) {
+        throw new Error('constructor is not allowed as a property');
+    }
+}
+export const getDeep = (object, path) => {
+    validatePath(path);
+    for (let i = 0; i < path.length; i++) {
+        const key = path[i];
+        if (isSet(object)) {
+            object = getNthKey(object, +key);
+        }
+        else if (isMap(object)) {
+            const row = +key;
+            const type = +path[++i] === 0 ? 'key' : 'value';
+            const keyOfRow = getNthKey(object, row);
+            switch (type) {
+                case 'key':
+                    object = keyOfRow;
+                    break;
+                case 'value':
+                    object = object.get(keyOfRow);
+                    break;
+            }
+        }
+        else {
+            object = object[key];
+        }
+    }
+    return object;
+};
+export const setDeep = (object, path, mapper) => {
+    validatePath(path);
+    if (path.length === 0) {
+        return mapper(object);
+    }
+    let parent = object;
+    for (let i = 0; i < path.length - 1; i++) {
+        const key = path[i];
+        if (isArray(parent)) {
+            const index = +key;
+            parent = parent[index];
+        }
+        else if (isPlainObject(parent)) {
+            parent = parent[key];
+        }
+        else if (isSet(parent)) {
+            const row = +key;
+            parent = getNthKey(parent, row);
+        }
+        else if (isMap(parent)) {
+            const isEnd = i === path.length - 2;
+            if (isEnd) {
+                break;
+            }
+            const row = +key;
+            const type = +path[++i] === 0 ? 'key' : 'value';
+            const keyOfRow = getNthKey(parent, row);
+            switch (type) {
+                case 'key':
+                    parent = keyOfRow;
+                    break;
+                case 'value':
+                    parent = parent.get(keyOfRow);
+                    break;
+            }
+        }
+    }
+    const lastKey = path[path.length - 1];
+    if (isArray(parent)) {
+        parent[+lastKey] = mapper(parent[+lastKey]);
+    }
+    else if (isPlainObject(parent)) {
+        parent[lastKey] = mapper(parent[lastKey]);
+    }
+    if (isSet(parent)) {
+        const oldValue = getNthKey(parent, +lastKey);
+        const newValue = mapper(oldValue);
+        if (oldValue !== newValue) {
+            parent.delete(oldValue);
+            parent.add(newValue);
+        }
+    }
+    if (isMap(parent)) {
+        const row = +path[path.length - 2];
+        const keyToRow = getNthKey(parent, row);
+        const type = +lastKey === 0 ? 'key' : 'value';
+        switch (type) {
+            case 'key': {
+                const newKey = mapper(keyToRow);
+                parent.set(newKey, parent.get(keyToRow));
+                if (newKey !== keyToRow) {
+                    parent.delete(keyToRow);
+                }
+                break;
+            }
+            case 'value': {
+                parent.set(keyToRow, mapper(parent.get(keyToRow)));
+                break;
+            }
+        }
+    }
+    return object;
+};
+//# sourceMappingURL=accessDeep.js.map

package/.output/server/node_modules/superjson/dist/class-registry.js

@@ -0,0 +1,22 @@
+import { Registry } from './registry.js';
+export class ClassRegistry extends Registry {
+    constructor() {
+        super(c => c.name);
+        this.classToAllowedProps = new Map();
+    }
+    register(value, options) {
+        if (typeof options === 'object') {
+            if (options.allowProps) {
+                this.classToAllowedProps.set(value, options.allowProps);
+            }
+            super.register(value, options.identifier);
+        }
+        else {
+            super.register(value, options);
+        }
+    }
+    getAllowedProps(value) {
+        return this.classToAllowedProps.get(value);
+    }
+}
+//# sourceMappingURL=class-registry.js.map

package/.output/server/node_modules/superjson/dist/custom-transformer-registry.js

@@ -0,0 +1,16 @@
+import { find } from './util.js';
+export class CustomTransformerRegistry {
+    constructor() {
+        this.transfomers = {};
+    }
+    register(transformer) {
+        this.transfomers[transformer.name] = transformer;
+    }
+    findApplicable(v) {
+        return find(this.transfomers, transformer => transformer.isApplicable(v));
+    }
+    findByName(name) {
+        return this.transfomers[name];
+    }
+}
+//# sourceMappingURL=custom-transformer-registry.js.map

package/.output/server/node_modules/superjson/dist/double-indexed-kv.js

@@ -0,0 +1,21 @@
+export class DoubleIndexedKV {
+    constructor() {
+        this.keyToValue = new Map();
+        this.valueToKey = new Map();
+    }
+    set(key, value) {
+        this.keyToValue.set(key, value);
+        this.valueToKey.set(value, key);
+    }
+    getByKey(key) {
+        return this.keyToValue.get(key);
+    }
+    getByValue(value) {
+        return this.valueToKey.get(value);
+    }
+    clear() {
+        this.keyToValue.clear();
+        this.valueToKey.clear();
+    }
+}
+//# sourceMappingURL=double-indexed-kv.js.map

package/.output/server/node_modules/superjson/dist/index.js

@@ -0,0 +1,89 @@
+import { ClassRegistry } from './class-registry.js';
+import { Registry } from './registry.js';
+import { CustomTransformerRegistry, } from './custom-transformer-registry.js';
+import { applyReferentialEqualityAnnotations, applyValueAnnotations, generateReferentialEqualityAnnotations, walker, } from './plainer.js';
+import { copy } from 'copy-anything';
+export default class SuperJSON {
+    /**
+     * @param dedupeReferentialEqualities  If true, SuperJSON will make sure only one instance of referentially equal objects are serialized and the rest are replaced with `null`.
+     */
+    constructor({ dedupe = false, } = {}) {
+        this.classRegistry = new ClassRegistry();
+        this.symbolRegistry = new Registry(s => s.description ?? '');
+        this.customTransformerRegistry = new CustomTransformerRegistry();
+        this.allowedErrorProps = [];
+        this.dedupe = dedupe;
+    }
+    serialize(object) {
+        const identities = new Map();
+        const output = walker(object, identities, this, this.dedupe);
+        const res = {
+            json: output.transformedValue,
+        };
+        if (output.annotations) {
+            res.meta = {
+                ...res.meta,
+                values: output.annotations,
+            };
+        }
+        const equalityAnnotations = generateReferentialEqualityAnnotations(identities, this.dedupe);
+        if (equalityAnnotations) {
+            res.meta = {
+                ...res.meta,
+                referentialEqualities: equalityAnnotations,
+            };
+        }
+        return res;
+    }
+    deserialize(payload) {
+        const { json, meta } = payload;
+        let result = copy(json);
+        if (meta?.values) {
+            result = applyValueAnnotations(result, meta.values, this);
+        }
+        if (meta?.referentialEqualities) {
+            result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities);
+        }
+        return result;
+    }
+    stringify(object) {
+        return JSON.stringify(this.serialize(object));
+    }
+    parse(string) {
+        return this.deserialize(JSON.parse(string));
+    }
+    registerClass(v, options) {
+        this.classRegistry.register(v, options);
+    }
+    registerSymbol(v, identifier) {
+        this.symbolRegistry.register(v, identifier);
+    }
+    registerCustom(transformer, name) {
+        this.customTransformerRegistry.register({
+            name,
+            ...transformer,
+        });
+    }
+    allowErrorProps(...props) {
+        this.allowedErrorProps.push(...props);
+    }
+}
+SuperJSON.defaultInstance = new SuperJSON();
+SuperJSON.serialize = SuperJSON.defaultInstance.serialize.bind(SuperJSON.defaultInstance);
+SuperJSON.deserialize = SuperJSON.defaultInstance.deserialize.bind(SuperJSON.defaultInstance);
+SuperJSON.stringify = SuperJSON.defaultInstance.stringify.bind(SuperJSON.defaultInstance);
+SuperJSON.parse = SuperJSON.defaultInstance.parse.bind(SuperJSON.defaultInstance);
+SuperJSON.registerClass = SuperJSON.defaultInstance.registerClass.bind(SuperJSON.defaultInstance);
+SuperJSON.registerSymbol = SuperJSON.defaultInstance.registerSymbol.bind(SuperJSON.defaultInstance);
+SuperJSON.registerCustom = SuperJSON.defaultInstance.registerCustom.bind(SuperJSON.defaultInstance);
+SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(SuperJSON.defaultInstance);
+export { SuperJSON };
+export const serialize = SuperJSON.serialize;
+export const deserialize = SuperJSON.deserialize;
+export const stringify = SuperJSON.stringify;
+export const parse = SuperJSON.parse;
+export const registerClass = SuperJSON.registerClass;
+export const registerCustom = SuperJSON.registerCustom;
+export const registerSymbol = SuperJSON.registerSymbol;
+export const allowErrorProps = SuperJSON.allowErrorProps;
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/superjson/dist/is.js

@@ -0,0 +1,35 @@
+const getType = (payload) => Object.prototype.toString.call(payload).slice(8, -1);
+export const isUndefined = (payload) => typeof payload === 'undefined';
+export const isNull = (payload) => payload === null;
+export const isPlainObject = (payload) => {
+    if (typeof payload !== 'object' || payload === null)
+        return false;
+    if (payload === Object.prototype)
+        return false;
+    if (Object.getPrototypeOf(payload) === null)
+        return true;
+    return Object.getPrototypeOf(payload) === Object.prototype;
+};
+export const isEmptyObject = (payload) => isPlainObject(payload) && Object.keys(payload).length === 0;
+export const isArray = (payload) => Array.isArray(payload);
+export const isString = (payload) => typeof payload === 'string';
+export const isNumber = (payload) => typeof payload === 'number' && !isNaN(payload);
+export const isBoolean = (payload) => typeof payload === 'boolean';
+export const isRegExp = (payload) => payload instanceof RegExp;
+export const isMap = (payload) => payload instanceof Map;
+export const isSet = (payload) => payload instanceof Set;
+export const isSymbol = (payload) => getType(payload) === 'Symbol';
+export const isDate = (payload) => payload instanceof Date && !isNaN(payload.valueOf());
+export const isError = (payload) => payload instanceof Error;
+export const isNaNValue = (payload) => typeof payload === 'number' && isNaN(payload);
+export const isPrimitive = (payload) => isBoolean(payload) ||
+    isNull(payload) ||
+    isUndefined(payload) ||
+    isNumber(payload) ||
+    isString(payload) ||
+    isSymbol(payload);
+export const isBigint = (payload) => typeof payload === 'bigint';
+export const isInfinite = (payload) => payload === Infinity || payload === -Infinity;
+export const isTypedArray = (payload) => ArrayBuffer.isView(payload) && !(payload instanceof DataView);
+export const isURL = (payload) => payload instanceof URL;
+//# sourceMappingURL=is.js.map

package/.output/server/node_modules/superjson/dist/pathstringifier.js

@@ -0,0 +1,29 @@
+export const escapeKey = (key) => key.replace(/\./g, '\\.');
+export const stringifyPath = (path) => path
+    .map(String)
+    .map(escapeKey)
+    .join('.');
+export const parsePath = (string) => {
+    const result = [];
+    let segment = '';
+    for (let i = 0; i < string.length; i++) {
+        let char = string.charAt(i);
+        const isEscapedDot = char === '\\' && string.charAt(i + 1) === '.';
+        if (isEscapedDot) {
+            segment += '.';
+            i++;
+            continue;
+        }
+        const isEndOfSegment = char === '.';
+        if (isEndOfSegment) {
+            result.push(segment);
+            segment = '';
+            continue;
+        }
+        segment += char;
+    }
+    const lastSegment = segment;
+    result.push(lastSegment);
+    return result;
+};
+//# sourceMappingURL=pathstringifier.js.map

package/.output/server/node_modules/superjson/dist/plainer.js

@@ -0,0 +1,173 @@
+import { isArray, isEmptyObject, isMap, isPlainObject, isPrimitive, isSet, } from './is.js';
+import { escapeKey, stringifyPath } from './pathstringifier.js';
+import { isInstanceOfRegisteredClass, transformValue, untransformValue, } from './transformer.js';
+import { includes, forEach } from './util.js';
+import { parsePath } from './pathstringifier.js';
+import { getDeep, setDeep } from './accessDeep.js';
+function traverse(tree, walker, origin = []) {
+    if (!tree) {
+        return;
+    }
+    if (!isArray(tree)) {
+        forEach(tree, (subtree, key) => traverse(subtree, walker, [...origin, ...parsePath(key)]));
+        return;
+    }
+    const [nodeValue, children] = tree;
+    if (children) {
+        forEach(children, (child, key) => {
+            traverse(child, walker, [...origin, ...parsePath(key)]);
+        });
+    }
+    walker(nodeValue, origin);
+}
+export function applyValueAnnotations(plain, annotations, superJson) {
+    traverse(annotations, (type, path) => {
+        plain = setDeep(plain, path, v => untransformValue(v, type, superJson));
+    });
+    return plain;
+}
+export function applyReferentialEqualityAnnotations(plain, annotations) {
+    function apply(identicalPaths, path) {
+        const object = getDeep(plain, parsePath(path));
+        identicalPaths.map(parsePath).forEach(identicalObjectPath => {
+            plain = setDeep(plain, identicalObjectPath, () => object);
+        });
+    }
+    if (isArray(annotations)) {
+        const [root, other] = annotations;
+        root.forEach(identicalPath => {
+            plain = setDeep(plain, parsePath(identicalPath), () => plain);
+        });
+        if (other) {
+            forEach(other, apply);
+        }
+    }
+    else {
+        forEach(annotations, apply);
+    }
+    return plain;
+}
+const isDeep = (object, superJson) => isPlainObject(object) ||
+    isArray(object) ||
+    isMap(object) ||
+    isSet(object) ||
+    isInstanceOfRegisteredClass(object, superJson);
+function addIdentity(object, path, identities) {
+    const existingSet = identities.get(object);
+    if (existingSet) {
+        existingSet.push(path);
+    }
+    else {
+        identities.set(object, [path]);
+    }
+}
+export function generateReferentialEqualityAnnotations(identitites, dedupe) {
+    const result = {};
+    let rootEqualityPaths = undefined;
+    identitites.forEach(paths => {
+        if (paths.length <= 1) {
+            return;
+        }
+        // if we're not deduping, all of these objects continue existing.
+        // putting the shortest path first makes it easier to parse for humans
+        // if we're deduping though, only the first entry will still exist, so we can't do this optimisation.
+        if (!dedupe) {
+            paths = paths
+                .map(path => path.map(String))
+                .sort((a, b) => a.length - b.length);
+        }
+        const [representativePath, ...identicalPaths] = paths;
+        if (representativePath.length === 0) {
+            rootEqualityPaths = identicalPaths.map(stringifyPath);
+        }
+        else {
+            result[stringifyPath(representativePath)] = identicalPaths.map(stringifyPath);
+        }
+    });
+    if (rootEqualityPaths) {
+        if (isEmptyObject(result)) {
+            return [rootEqualityPaths];
+        }
+        else {
+            return [rootEqualityPaths, result];
+        }
+    }
+    else {
+        return isEmptyObject(result) ? undefined : result;
+    }
+}
+export const walker = (object, identities, superJson, dedupe, path = [], objectsInThisPath = [], seenObjects = new Map()) => {
+    const primitive = isPrimitive(object);
+    if (!primitive) {
+        addIdentity(object, path, identities);
+        const seen = seenObjects.get(object);
+        if (seen) {
+            // short-circuit result if we've seen this object before
+            return dedupe
+                ? {
+                    transformedValue: null,
+                }
+                : seen;
+        }
+    }
+    if (!isDeep(object, superJson)) {
+        const transformed = transformValue(object, superJson);
+        const result = transformed
+            ? {
+                transformedValue: transformed.value,
+                annotations: [transformed.type],
+            }
+            : {
+                transformedValue: object,
+            };
+        if (!primitive) {
+            seenObjects.set(object, result);
+        }
+        return result;
+    }
+    if (includes(objectsInThisPath, object)) {
+        // prevent circular references
+        return {
+            transformedValue: null,
+        };
+    }
+    const transformationResult = transformValue(object, superJson);
+    const transformed = transformationResult?.value ?? object;
+    const transformedValue = isArray(transformed) ? [] : {};
+    const innerAnnotations = {};
+    forEach(transformed, (value, index) => {
+        if (index === '__proto__' ||
+            index === 'constructor' ||
+            index === 'prototype') {
+            throw new Error(`Detected property ${index}. This is a prototype pollution risk, please remove it from your object.`);
+        }
+        const recursiveResult = walker(value, identities, superJson, dedupe, [...path, index], [...objectsInThisPath, object], seenObjects);
+        transformedValue[index] = recursiveResult.transformedValue;
+        if (isArray(recursiveResult.annotations)) {
+            innerAnnotations[index] = recursiveResult.annotations;
+        }
+        else if (isPlainObject(recursiveResult.annotations)) {
+            forEach(recursiveResult.annotations, (tree, key) => {
+                innerAnnotations[escapeKey(index) + '.' + key] = tree;
+            });
+        }
+    });
+    const result = isEmptyObject(innerAnnotations)
+        ? {
+            transformedValue,
+            annotations: !!transformationResult
+                ? [transformationResult.type]
+                : undefined,
+        }
+        : {
+            transformedValue,
+            annotations: !!transformationResult
+                ? [transformationResult.type, innerAnnotations]
+                : innerAnnotations,
+        };
+    if (!primitive) {
+        seenObjects.set(object, result);
+    }
+    return result;
+};
+//# sourceMappingURL=plainer.js.map

package/.output/server/node_modules/superjson/dist/registry.js

@@ -0,0 +1,26 @@
+import { DoubleIndexedKV } from './double-indexed-kv.js';
+export class Registry {
+    constructor(generateIdentifier) {
+        this.generateIdentifier = generateIdentifier;
+        this.kv = new DoubleIndexedKV();
+    }
+    register(value, identifier) {
+        if (this.kv.getByValue(value)) {
+            return;
+        }
+        if (!identifier) {
+            identifier = this.generateIdentifier(value);
+        }
+        this.kv.set(identifier, value);
+    }
+    clear() {
+        this.kv.clear();
+    }
+    getIdentifier(value) {
+        return this.kv.getByValue(value);
+    }
+    getValue(identifier) {
+        return this.kv.getByKey(identifier);
+    }
+}
+//# sourceMappingURL=registry.js.map