hyperstorage-js 5.1.0 → 6.0.1

package/dist/index.mjs

@@ -1,3 +1,861 @@
+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();
+    }
+}
+
+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);
+    }
+}
+
+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);
+    }
+}
+
+function valuesOfObj(record) {
+    if ('values' in Object) {
+        // eslint-disable-next-line es5/no-es6-methods
+        return Object.values(record);
+    }
+    const values = [];
+    // eslint-disable-next-line no-restricted-syntax
+    for (const key in record) {
+        if (record.hasOwnProperty(key)) {
+            values.push(record[key]);
+        }
+    }
+    return values;
+}
+function find(record, predicate) {
+    const values = valuesOfObj(record);
+    if ('find' in values) {
+        // eslint-disable-next-line es5/no-es6-methods
+        return values.find(predicate);
+    }
+    const valuesNotNever = values;
+    for (let i = 0; i < valuesNotNever.length; i++) {
+        const value = valuesNotNever[i];
+        if (predicate(value)) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function forEach(record, run) {
+    Object.entries(record).forEach(([key, value]) => run(value, key));
+}
+function includes(arr, value) {
+    return arr.indexOf(value) !== -1;
+}
+function findArr(record, predicate) {
+    for (let i = 0; i < record.length; i++) {
+        const value = record[i];
+        if (predicate(value)) {
+            return value;
+        }
+    }
+    return undefined;
+}
+
+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];
+    }
+}
+
+const getType$1 = (payload) => Object.prototype.toString.call(payload).slice(8, -1);
+const isUndefined = (payload) => typeof payload === 'undefined';
+const isNull = (payload) => payload === null;
+const isPlainObject$1 = (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;
+};
+const isEmptyObject = (payload) => isPlainObject$1(payload) && Object.keys(payload).length === 0;
+const isArray$1 = (payload) => Array.isArray(payload);
+const isString = (payload) => typeof payload === 'string';
+const isNumber = (payload) => typeof payload === 'number' && !isNaN(payload);
+const isBoolean = (payload) => typeof payload === 'boolean';
+const isRegExp = (payload) => payload instanceof RegExp;
+const isMap = (payload) => payload instanceof Map;
+const isSet = (payload) => payload instanceof Set;
+const isSymbol = (payload) => getType$1(payload) === 'Symbol';
+const isDate = (payload) => payload instanceof Date && !isNaN(payload.valueOf());
+const isError = (payload) => payload instanceof Error;
+const isNaNValue = (payload) => typeof payload === 'number' && isNaN(payload);
+const isPrimitive = (payload) => isBoolean(payload) ||
+    isNull(payload) ||
+    isUndefined(payload) ||
+    isNumber(payload) ||
+    isString(payload) ||
+    isSymbol(payload);
+const isBigint = (payload) => typeof payload === 'bigint';
+const isInfinite = (payload) => payload === Infinity || payload === -Infinity;
+const isTypedArray = (payload) => ArrayBuffer.isView(payload) && !(payload instanceof DataView);
+const isURL = (payload) => payload instanceof URL;
+
+const escapeKey = (key) => key.replace(/\\/g, '\\\\').replace(/\./g, '\\.');
+const stringifyPath = (path) => path
+    .map(String)
+    .map(escapeKey)
+    .join('.');
+const parsePath = (string, legacyPaths) => {
+    const result = [];
+    let segment = '';
+    for (let i = 0; i < string.length; i++) {
+        let char = string.charAt(i);
+        if (!legacyPaths && char === '\\') {
+            const escaped = string.charAt(i + 1);
+            if (escaped === '\\') {
+                segment += '\\';
+                i++;
+                continue;
+            }
+            else if (escaped !== '.') {
+                throw Error('invalid path');
+            }
+        }
+        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;
+};
+
+function simpleTransformation(isApplicable, annotation, transform, untransform) {
+    return {
+        isApplicable,
+        annotation,
+        transform,
+        untransform,
+    };
+}
+const simpleRules = [
+    simpleTransformation(isUndefined, 'undefined', () => null, () => undefined),
+    simpleTransformation(isBigint, 'bigint', v => v.toString(), v => {
+        if (typeof BigInt !== 'undefined') {
+            return BigInt(v);
+        }
+        console.error('Please add a BigInt polyfill.');
+        return v;
+    }),
+    simpleTransformation(isDate, 'Date', v => v.toISOString(), v => new Date(v)),
+    simpleTransformation(isError, 'Error', (v, superJson) => {
+        const baseError = {
+            name: v.name,
+            message: v.message,
+        };
+        if ('cause' in v) {
+            baseError.cause = v.cause;
+        }
+        superJson.allowedErrorProps.forEach(prop => {
+            baseError[prop] = v[prop];
+        });
+        return baseError;
+    }, (v, superJson) => {
+        const e = new Error(v.message, { cause: v.cause });
+        e.name = v.name;
+        e.stack = v.stack;
+        superJson.allowedErrorProps.forEach(prop => {
+            e[prop] = v[prop];
+        });
+        return e;
+    }),
+    simpleTransformation(isRegExp, 'regexp', v => '' + v, regex => {
+        const body = regex.slice(1, regex.lastIndexOf('/'));
+        const flags = regex.slice(regex.lastIndexOf('/') + 1);
+        return new RegExp(body, flags);
+    }),
+    simpleTransformation(isSet, 'set', 
+    // (sets only exist in es6+)
+    // eslint-disable-next-line es5/no-es6-methods
+    v => [...v.values()], v => new Set(v)),
+    simpleTransformation(isMap, 'map', v => [...v.entries()], v => new Map(v)),
+    simpleTransformation((v) => isNaNValue(v) || isInfinite(v), 'number', v => {
+        if (isNaNValue(v)) {
+            return 'NaN';
+        }
+        if (v > 0) {
+            return 'Infinity';
+        }
+        else {
+            return '-Infinity';
+        }
+    }, Number),
+    simpleTransformation((v) => v === 0 && 1 / v === -Infinity, 'number', () => {
+        return '-0';
+    }, Number),
+    simpleTransformation(isURL, 'URL', v => v.toString(), v => new URL(v)),
+];
+function compositeTransformation(isApplicable, annotation, transform, untransform) {
+    return {
+        isApplicable,
+        annotation,
+        transform,
+        untransform,
+    };
+}
+const symbolRule = compositeTransformation((s, superJson) => {
+    if (isSymbol(s)) {
+        const isRegistered = !!superJson.symbolRegistry.getIdentifier(s);
+        return isRegistered;
+    }
+    return false;
+}, (s, superJson) => {
+    const identifier = superJson.symbolRegistry.getIdentifier(s);
+    return ['symbol', identifier];
+}, v => v.description, (_, a, superJson) => {
+    const value = superJson.symbolRegistry.getValue(a[1]);
+    if (!value) {
+        throw new Error('Trying to deserialize unknown symbol');
+    }
+    return value;
+});
+const constructorToName = [
+    Int8Array,
+    Uint8Array,
+    Int16Array,
+    Uint16Array,
+    Int32Array,
+    Uint32Array,
+    Float32Array,
+    Float64Array,
+    Uint8ClampedArray,
+].reduce((obj, ctor) => {
+    obj[ctor.name] = ctor;
+    return obj;
+}, {});
+const typedArrayRule = compositeTransformation(isTypedArray, v => ['typed-array', v.constructor.name], v => [...v], (v, a) => {
+    const ctor = constructorToName[a[1]];
+    if (!ctor) {
+        throw new Error('Trying to deserialize unknown typed array');
+    }
+    return new ctor(v);
+});
+function isInstanceOfRegisteredClass(potentialClass, superJson) {
+    if (potentialClass?.constructor) {
+        const isRegistered = !!superJson.classRegistry.getIdentifier(potentialClass.constructor);
+        return isRegistered;
+    }
+    return false;
+}
+const classRule = compositeTransformation(isInstanceOfRegisteredClass, (clazz, superJson) => {
+    const identifier = superJson.classRegistry.getIdentifier(clazz.constructor);
+    return ['class', identifier];
+}, (clazz, superJson) => {
+    const allowedProps = superJson.classRegistry.getAllowedProps(clazz.constructor);
+    if (!allowedProps) {
+        return { ...clazz };
+    }
+    const result = {};
+    allowedProps.forEach(prop => {
+        result[prop] = clazz[prop];
+    });
+    return result;
+}, (v, a, superJson) => {
+    const clazz = superJson.classRegistry.getValue(a[1]);
+    if (!clazz) {
+        throw new Error(`Trying to deserialize unknown class '${a[1]}' - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564`);
+    }
+    return Object.assign(Object.create(clazz.prototype), v);
+});
+const customRule = compositeTransformation((value, superJson) => {
+    return !!superJson.customTransformerRegistry.findApplicable(value);
+}, (value, superJson) => {
+    const transformer = superJson.customTransformerRegistry.findApplicable(value);
+    return ['custom', transformer.name];
+}, (value, superJson) => {
+    const transformer = superJson.customTransformerRegistry.findApplicable(value);
+    return transformer.serialize(value);
+}, (v, a, superJson) => {
+    const transformer = superJson.customTransformerRegistry.findByName(a[1]);
+    if (!transformer) {
+        throw new Error('Trying to deserialize unknown custom value');
+    }
+    return transformer.deserialize(v);
+});
+const compositeRules = [classRule, symbolRule, customRule, typedArrayRule];
+const transformValue = (value, superJson) => {
+    const applicableCompositeRule = findArr(compositeRules, rule => rule.isApplicable(value, superJson));
+    if (applicableCompositeRule) {
+        return {
+            value: applicableCompositeRule.transform(value, superJson),
+            type: applicableCompositeRule.annotation(value, superJson),
+        };
+    }
+    const applicableSimpleRule = findArr(simpleRules, rule => rule.isApplicable(value, superJson));
+    if (applicableSimpleRule) {
+        return {
+            value: applicableSimpleRule.transform(value, superJson),
+            type: applicableSimpleRule.annotation,
+        };
+    }
+    return undefined;
+};
+const simpleRulesByAnnotation = {};
+simpleRules.forEach(rule => {
+    simpleRulesByAnnotation[rule.annotation] = rule;
+});
+const untransformValue = (json, type, superJson) => {
+    if (isArray$1(type)) {
+        switch (type[0]) {
+            case 'symbol':
+                return symbolRule.untransform(json, type, superJson);
+            case 'class':
+                return classRule.untransform(json, type, superJson);
+            case 'custom':
+                return customRule.untransform(json, type, superJson);
+            case 'typed-array':
+                return typedArrayRule.untransform(json, type, superJson);
+            default:
+                throw new Error('Unknown transformation: ' + type);
+        }
+    }
+    else {
+        const transformation = simpleRulesByAnnotation[type];
+        if (!transformation) {
+            throw new Error('Unknown transformation: ' + type);
+        }
+        return transformation.untransform(json, superJson);
+    }
+};
+
+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');
+    }
+}
+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;
+};
+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$1(parent)) {
+            const index = +key;
+            parent = parent[index];
+        }
+        else if (isPlainObject$1(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$1(parent)) {
+        parent[+lastKey] = mapper(parent[+lastKey]);
+    }
+    else if (isPlainObject$1(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;
+};
+
+const enableLegacyPaths = (version) => version < 1;
+function traverse(tree, walker, version, origin = []) {
+    if (!tree) {
+        return;
+    }
+    const legacyPaths = enableLegacyPaths(version);
+    if (!isArray$1(tree)) {
+        forEach(tree, (subtree, key) => traverse(subtree, walker, version, [
+            ...origin,
+            ...parsePath(key, legacyPaths),
+        ]));
+        return;
+    }
+    const [nodeValue, children] = tree;
+    if (children) {
+        forEach(children, (child, key) => {
+            traverse(child, walker, version, [
+                ...origin,
+                ...parsePath(key, legacyPaths),
+            ]);
+        });
+    }
+    walker(nodeValue, origin);
+}
+function applyValueAnnotations(plain, annotations, version, superJson) {
+    traverse(annotations, (type, path) => {
+        plain = setDeep(plain, path, v => untransformValue(v, type, superJson));
+    }, version);
+    return plain;
+}
+function applyReferentialEqualityAnnotations(plain, annotations, version) {
+    const legacyPaths = enableLegacyPaths(version);
+    function apply(identicalPaths, path) {
+        const object = getDeep(plain, parsePath(path, legacyPaths));
+        identicalPaths
+            .map(path => parsePath(path, legacyPaths))
+            .forEach(identicalObjectPath => {
+            plain = setDeep(plain, identicalObjectPath, () => object);
+        });
+    }
+    if (isArray$1(annotations)) {
+        const [root, other] = annotations;
+        root.forEach(identicalPath => {
+            plain = setDeep(plain, parsePath(identicalPath, legacyPaths), () => plain);
+        });
+        if (other) {
+            forEach(other, apply);
+        }
+    }
+    else {
+        forEach(annotations, apply);
+    }
+    return plain;
+}
+const isDeep = (object, superJson) => isPlainObject$1(object) ||
+    isArray$1(object) ||
+    isMap(object) ||
+    isSet(object) ||
+    isError(object) ||
+    isInstanceOfRegisteredClass(object, superJson);
+function addIdentity(object, path, identities) {
+    const existingSet = identities.get(object);
+    if (existingSet) {
+        existingSet.push(path);
+    }
+    else {
+        identities.set(object, [path]);
+    }
+}
+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;
+    }
+}
+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$1(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$1(recursiveResult.annotations)) {
+            innerAnnotations[escapeKey(index)] = recursiveResult.annotations;
+        }
+        else if (isPlainObject$1(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;
+};
+
+/** Returns the object type of the given payload */
+function getType(payload) {
+    return Object.prototype.toString.call(payload).slice(8, -1);
+}
+
+/** Returns whether the payload is an array */
+function isArray(payload) {
+    return getType(payload) === 'Array';
+}
+
+/**
+ * Returns whether the payload is a plain JavaScript object (excluding special classes or objects
+ * with other prototypes)
+ */
+function isPlainObject(payload) {
+    if (getType(payload) !== 'Object')
+        return false;
+    const prototype = Object.getPrototypeOf(payload);
+    return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
+}
+
+function assignProp(carry, key, newVal, originalObject, includeNonenumerable) {
+    const propType = {}.propertyIsEnumerable.call(originalObject, key)
+        ? 'enumerable'
+        : 'nonenumerable';
+    if (propType === 'enumerable')
+        carry[key] = newVal;
+    if (includeNonenumerable && propType === 'nonenumerable') {
+        Object.defineProperty(carry, key, {
+            value: newVal,
+            enumerable: false,
+            writable: true,
+            configurable: true,
+        });
+    }
+}
+/**
+ * Copy (clone) an object and all its props recursively to get rid of any prop referenced of the
+ * original object. Arrays are also cloned, however objects inside arrays are still linked.
+ *
+ * @param target Target can be anything
+ * @param [options={}] See type {@link Options} for more details.
+ *
+ *   - `{ props: ['key1'] }` will only copy the `key1` property. When using this you will need to cast
+ *       the return type manually (in order to keep the TS implementation in here simple I didn't
+ *       built a complex auto resolved type for those few cases people want to use this option)
+ *   - `{ nonenumerable: true }` will copy all non-enumerable properties. Default is `{}`
+ *
+ * @returns The target with replaced values
+ */
+function copy(target, options = {}) {
+    if (isArray(target)) {
+        return target.map((item) => copy(item, options));
+    }
+    if (!isPlainObject(target)) {
+        return target;
+    }
+    const props = Object.getOwnPropertyNames(target);
+    const symbols = Object.getOwnPropertySymbols(target);
+    return [...props, ...symbols].reduce((carry, key) => {
+        // Skip __proto__ properties to prevent prototype pollution
+        if (key === '__proto__')
+            return carry;
+        if (isArray(options.props) && !options.props.includes(key)) {
+            return carry;
+        }
+        const val = target[key];
+        const newVal = copy(val, options);
+        assignProp(carry, key, newVal, target, options.nonenumerable);
+        return carry;
+    }, {});
+}
+
+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,
+            };
+        }
+        if (res.meta)
+            res.meta.v = 1;
+        return res;
+    }
+    deserialize(payload, options) {
+        const { json, meta } = payload;
+        let result = options?.inPlace ? json : copy(json);
+        if (meta?.values) {
+            result = applyValueAnnotations(result, meta.values, meta.v ?? 0, this);
+        }
+        if (meta?.referentialEqualities) {
+            result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities, meta.v ?? 0);
+        }
+        return result;
+    }
+    stringify(object) {
+        return JSON.stringify(this.serialize(object));
+    }
+    parse(string) {
+        return this.deserialize(JSON.parse(string), { inPlace: true });
+    }
+    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);
+SuperJSON.serialize;
+SuperJSON.deserialize;
+SuperJSON.stringify;
+SuperJSON.parse;
+SuperJSON.registerClass;
+SuperJSON.registerCustom;
+SuperJSON.registerSymbol;
+SuperJSON.allowErrorProps;
+
 /**
  * @class HyperStorage
  * @classdesc A lightweight wrapper for localStorage/sessionStorage
@@ -7,7 +865,8 @@
  */
 class HyperStorage {
     /** Version of the library, injected via Rollup replace plugin. */
-    static version = "5.1.0";
+    static version = "6.0.1";
+    static superjson = SuperJSON;
     /** Key name under which the data is stored. */
     itemName;
     /** Default value used when the key does not exist in storage. */
@@ -26,7 +885,7 @@ class HyperStorage {
      * @param {string} itemName - The key name under which the data will be stored.
      * @param {T} [defaultValue] - Default value assigned to the key if it does not exist yet.
      * @param {Object} [options={}] - Optional configuration parameters.
-     * @param {(value: string) => string} [options.encodeFn] - Optional function to encode stored values.
+     * @param {(value: T) => string} [options.encodeFn] - Optional function to encode stored values.
      * @param {(value: string) => string} [options.decodeFn] - Optional function to decode stored values.
      * @param {Storage} [options.storage=window.localStorage] - Optional custom storage backend.
      *
@@ -42,10 +901,10 @@ class HyperStorage {
         this.defaultValue = defaultValue;
         if (encodeFn && typeof encodeFn !== 'function')
             throw new TypeError('encodeFn is defined but is not a function');
-        this.encodeFn = encodeFn || ((v) => v);
+        this.encodeFn = encodeFn || ((v) => HyperStorage.superjson.stringify(v));
         if (decodeFn && typeof decodeFn !== 'function')
             throw new TypeError('decodeFn is defined but is not a function');
-        this.decodeFn = decodeFn || ((v) => v);
+        this.decodeFn = decodeFn || ((v) => HyperStorage.superjson.parse(v));
         if (!(storage instanceof Storage))
             throw new TypeError('storage must be an instance of Storage');
         this.storage = storage;
@@ -58,24 +917,7 @@ class HyperStorage {
     set value(value) {
         // Cache real value
         this.#value = value;
-        // Store stringified value with prefix to distinguish from raw strings
-        let stringValue;
-        if (typeof value === 'string') {
-            if (value[0] === '\0')
-                stringValue = '\0' + value;
-            else
-                stringValue = value;
-        }
-        else if (value === undefined ||
-            (typeof value === 'number' &&
-                (isNaN(value) || value === Infinity || value === -Infinity))) {
-            // Manually stringify non-JSON values
-            stringValue = '\0' + String(value);
-        }
-        else {
-            stringValue = '\0' + JSON.stringify(value);
-        }
-        this.storage.setItem(this.itemName, this.encodeFn(stringValue));
+        this.storage.setItem(this.itemName, this.encodeFn(value));
     }
     /**
      * Gets the current cached value.
@@ -83,11 +925,11 @@ class HyperStorage {
     get value() {
         return this.#value ?? this.defaultValue;
     }
-    /**
-     * Allows using the setter with a callback.
-     */
-    set(callback) {
-        return (this.value = callback(this.value));
+    set(keyOrCallback, value) {
+        if (typeof keyOrCallback === 'function')
+            return (this.value = keyOrCallback(this.value));
+        this.value[keyOrCallback] = value;
+        return this.value;
     }
     /**
      * Synchronizes the internal cache (`#value`) with the actual value in storage.
@@ -96,35 +938,19 @@ class HyperStorage {
      * Using this function should be avoided when possible and is not type safe.
      */
     sync(decodeFn = this.decodeFn) {
-        let value = this.storage.getItem(this.itemName);
+        let json = this.storage.getItem(this.itemName);
         // Reset value to defaultValue if it does not exist in storage
-        if (typeof value !== 'string')
+        if (typeof json !== 'string')
             return this.reset();
         // Reset value to defaultValue if the incoming value is not properly encoded
         try {
-            value = decodeFn(value);
+            return (this.value = decodeFn(json));
         }
         catch (err) {
             this.reset();
             console.error(err);
             return err;
         }
-        if (value[0] !== '\0')
-            return (this.value = value); // Raw string value
-        // Slice off '\0' prefix
-        value = value.slice(1);
-        if (value[0] === '\0')
-            return (this.value = value); // Raw string value that started with '\0'
-        // Parse non JSON
-        if (value === 'undefined')
-            return (this.value = undefined);
-        if (value === 'NaN')
-            return (this.value = NaN);
-        if (value === 'Infinity')
-            return (this.value = Infinity);
-        if (value === '-Infinity')
-            return (this.value = -Infinity);
-        return (this.value = JSON.parse(value));
     }
     /**
      * Resets the stored value to its configured default.