{"version":3,"file":"static/js/3299_5a1a4873495fafa4fe5d.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/superjson@1.13.3/node_modules/superjson/dist/esm/double-indexed-kv.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/superjson@1.13.3/node_modules/superjson/dist/esm/class-registry.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/superjson@1.13.3/node_modules/superjson/dist/esm/registry.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/superjson@1.13.3/node_modules/superjson/dist/esm/util.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/superjson@1.13.3/node_modules/superjson/dist/esm/custom-transformer-registry.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/superjson@1.13.3/node_modules/superjson/dist/esm/is.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/superjson@1.13.3/node_modules/superjson/dist/esm/pathstringifier.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/superjson@1.13.3/node_modules/superjson/dist/esm/transformer.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/superjson@1.13.3/node_modules/superjson/dist/esm/accessDeep.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/superjson@1.13.3/node_modules/superjson/dist/esm/plainer.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/superjson@1.13.3/node_modules/superjson/dist/esm/index.js"],"sourcesContent":["var DoubleIndexedKV = /** @class */ (function () {\n    function DoubleIndexedKV() {\n        this.keyToValue = new Map();\n        this.valueToKey = new Map();\n    }\n    DoubleIndexedKV.prototype.set = function (key, value) {\n        this.keyToValue.set(key, value);\n        this.valueToKey.set(value, key);\n    };\n    DoubleIndexedKV.prototype.getByKey = function (key) {\n        return this.keyToValue.get(key);\n    };\n    DoubleIndexedKV.prototype.getByValue = function (value) {\n        return this.valueToKey.get(value);\n    };\n    DoubleIndexedKV.prototype.clear = function () {\n        this.keyToValue.clear();\n        this.valueToKey.clear();\n    };\n    return DoubleIndexedKV;\n}());\nexport { DoubleIndexedKV };\n//# sourceMappingURL=double-indexed-kv.js.map","var __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nimport { Registry } from './registry';\nvar ClassRegistry = /** @class */ (function (_super) {\n    __extends(ClassRegistry, _super);\n    function ClassRegistry() {\n        var _this = _super.call(this, function (c) { return c.name; }) || this;\n        _this.classToAllowedProps = new Map();\n        return _this;\n    }\n    ClassRegistry.prototype.register = function (value, options) {\n        if (typeof options === 'object') {\n            if (options.allowProps) {\n                this.classToAllowedProps.set(value, options.allowProps);\n            }\n            _super.prototype.register.call(this, value, options.identifier);\n        }\n        else {\n            _super.prototype.register.call(this, value, options);\n        }\n    };\n    ClassRegistry.prototype.getAllowedProps = function (value) {\n        return this.classToAllowedProps.get(value);\n    };\n    return ClassRegistry;\n}(Registry));\nexport { ClassRegistry };\n//# sourceMappingURL=class-registry.js.map","import { DoubleIndexedKV } from './double-indexed-kv';\nvar Registry = /** @class */ (function () {\n    function Registry(generateIdentifier) {\n        this.generateIdentifier = generateIdentifier;\n        this.kv = new DoubleIndexedKV();\n    }\n    Registry.prototype.register = function (value, identifier) {\n        if (this.kv.getByValue(value)) {\n            return;\n        }\n        if (!identifier) {\n            identifier = this.generateIdentifier(value);\n        }\n        this.kv.set(identifier, value);\n    };\n    Registry.prototype.clear = function () {\n        this.kv.clear();\n    };\n    Registry.prototype.getIdentifier = function (value) {\n        return this.kv.getByValue(value);\n    };\n    Registry.prototype.getValue = function (identifier) {\n        return this.kv.getByKey(identifier);\n    };\n    return Registry;\n}());\nexport { Registry };\n//# sourceMappingURL=registry.js.map","var __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nfunction valuesOfObj(record) {\n    if ('values' in Object) {\n        // eslint-disable-next-line es5/no-es6-methods\n        return Object.values(record);\n    }\n    var values = [];\n    // eslint-disable-next-line no-restricted-syntax\n    for (var key in record) {\n        if (record.hasOwnProperty(key)) {\n            values.push(record[key]);\n        }\n    }\n    return values;\n}\nexport function find(record, predicate) {\n    var values = valuesOfObj(record);\n    if ('find' in values) {\n        // eslint-disable-next-line es5/no-es6-methods\n        return values.find(predicate);\n    }\n    var valuesNotNever = values;\n    for (var i = 0; i < valuesNotNever.length; i++) {\n        var value = valuesNotNever[i];\n        if (predicate(value)) {\n            return value;\n        }\n    }\n    return undefined;\n}\nexport function forEach(record, run) {\n    Object.entries(record).forEach(function (_a) {\n        var _b = __read(_a, 2), key = _b[0], value = _b[1];\n        return run(value, key);\n    });\n}\nexport function includes(arr, value) {\n    return arr.indexOf(value) !== -1;\n}\nexport function findArr(record, predicate) {\n    for (var i = 0; i < record.length; i++) {\n        var value = record[i];\n        if (predicate(value)) {\n            return value;\n        }\n    }\n    return undefined;\n}\n//# sourceMappingURL=util.js.map","import { find } from './util';\nvar CustomTransformerRegistry = /** @class */ (function () {\n    function CustomTransformerRegistry() {\n        this.transfomers = {};\n    }\n    CustomTransformerRegistry.prototype.register = function (transformer) {\n        this.transfomers[transformer.name] = transformer;\n    };\n    CustomTransformerRegistry.prototype.findApplicable = function (v) {\n        return find(this.transfomers, function (transformer) {\n            return transformer.isApplicable(v);\n        });\n    };\n    CustomTransformerRegistry.prototype.findByName = function (name) {\n        return this.transfomers[name];\n    };\n    return CustomTransformerRegistry;\n}());\nexport { CustomTransformerRegistry };\n//# sourceMappingURL=custom-transformer-registry.js.map","var getType = function (payload) {\n    return Object.prototype.toString.call(payload).slice(8, -1);\n};\nexport var isUndefined = function (payload) {\n    return typeof payload === 'undefined';\n};\nexport var isNull = function (payload) { return payload === null; };\nexport var isPlainObject = function (payload) {\n    if (typeof payload !== 'object' || payload === null)\n        return false;\n    if (payload === Object.prototype)\n        return false;\n    if (Object.getPrototypeOf(payload) === null)\n        return true;\n    return Object.getPrototypeOf(payload) === Object.prototype;\n};\nexport var isEmptyObject = function (payload) {\n    return isPlainObject(payload) && Object.keys(payload).length === 0;\n};\nexport var isArray = function (payload) {\n    return Array.isArray(payload);\n};\nexport var isString = function (payload) {\n    return typeof payload === 'string';\n};\nexport var isNumber = function (payload) {\n    return typeof payload === 'number' && !isNaN(payload);\n};\nexport var isBoolean = function (payload) {\n    return typeof payload === 'boolean';\n};\nexport var isRegExp = function (payload) {\n    return payload instanceof RegExp;\n};\nexport var isMap = function (payload) {\n    return payload instanceof Map;\n};\nexport var isSet = function (payload) {\n    return payload instanceof Set;\n};\nexport var isSymbol = function (payload) {\n    return getType(payload) === 'Symbol';\n};\nexport var isDate = function (payload) {\n    return payload instanceof Date && !isNaN(payload.valueOf());\n};\nexport var isError = function (payload) {\n    return payload instanceof Error;\n};\nexport var isNaNValue = function (payload) {\n    return typeof payload === 'number' && isNaN(payload);\n};\nexport var isPrimitive = function (payload) {\n    return isBoolean(payload) ||\n        isNull(payload) ||\n        isUndefined(payload) ||\n        isNumber(payload) ||\n        isString(payload) ||\n        isSymbol(payload);\n};\nexport var isBigint = function (payload) {\n    return typeof payload === 'bigint';\n};\nexport var isInfinite = function (payload) {\n    return payload === Infinity || payload === -Infinity;\n};\nexport var isTypedArray = function (payload) {\n    return ArrayBuffer.isView(payload) && !(payload instanceof DataView);\n};\nexport var isURL = function (payload) { return payload instanceof URL; };\n//# sourceMappingURL=is.js.map","export var escapeKey = function (key) { return key.replace(/\\./g, '\\\\.'); };\nexport var stringifyPath = function (path) {\n    return path\n        .map(String)\n        .map(escapeKey)\n        .join('.');\n};\nexport var parsePath = function (string) {\n    var result = [];\n    var segment = '';\n    for (var i = 0; i < string.length; i++) {\n        var char = string.charAt(i);\n        var isEscapedDot = char === '\\\\' && string.charAt(i + 1) === '.';\n        if (isEscapedDot) {\n            segment += '.';\n            i++;\n            continue;\n        }\n        var isEndOfSegment = char === '.';\n        if (isEndOfSegment) {\n            result.push(segment);\n            segment = '';\n            continue;\n        }\n        segment += char;\n    }\n    var lastSegment = segment;\n    result.push(lastSegment);\n    return result;\n};\n//# sourceMappingURL=pathstringifier.js.map","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __spreadArray = (this && this.__spreadArray) || function (to, from) {\n    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\n        to[j] = from[i];\n    return to;\n};\nimport { isBigint, isDate, isInfinite, isMap, isNaNValue, isRegExp, isSet, isUndefined, isSymbol, isArray, isError, isTypedArray, isURL, } from './is';\nimport { findArr } from './util';\nfunction simpleTransformation(isApplicable, annotation, transform, untransform) {\n    return {\n        isApplicable: isApplicable,\n        annotation: annotation,\n        transform: transform,\n        untransform: untransform\n    };\n}\nvar simpleRules = [\n    simpleTransformation(isUndefined, 'undefined', function () { return null; }, function () { return undefined; }),\n    simpleTransformation(isBigint, 'bigint', function (v) { return v.toString(); }, function (v) {\n        if (typeof BigInt !== 'undefined') {\n            return BigInt(v);\n        }\n        console.error('Please add a BigInt polyfill.');\n        return v;\n    }),\n    simpleTransformation(isDate, 'Date', function (v) { return v.toISOString(); }, function (v) { return new Date(v); }),\n    simpleTransformation(isError, 'Error', function (v, superJson) {\n        var baseError = {\n            name: v.name,\n            message: v.message\n        };\n        superJson.allowedErrorProps.forEach(function (prop) {\n            baseError[prop] = v[prop];\n        });\n        return baseError;\n    }, function (v, superJson) {\n        var e = new Error(v.message);\n        e.name = v.name;\n        e.stack = v.stack;\n        superJson.allowedErrorProps.forEach(function (prop) {\n            e[prop] = v[prop];\n        });\n        return e;\n    }),\n    simpleTransformation(isRegExp, 'regexp', function (v) { return '' + v; }, function (regex) {\n        var body = regex.slice(1, regex.lastIndexOf('/'));\n        var flags = regex.slice(regex.lastIndexOf('/') + 1);\n        return new RegExp(body, flags);\n    }),\n    simpleTransformation(isSet, 'set', \n    // (sets only exist in es6+)\n    // eslint-disable-next-line es5/no-es6-methods\n    function (v) { return __spreadArray([], __read(v.values())); }, function (v) { return new Set(v); }),\n    simpleTransformation(isMap, 'map', function (v) { return __spreadArray([], __read(v.entries())); }, function (v) { return new Map(v); }),\n    simpleTransformation(function (v) { return isNaNValue(v) || isInfinite(v); }, 'number', function (v) {\n        if (isNaNValue(v)) {\n            return 'NaN';\n        }\n        if (v > 0) {\n            return 'Infinity';\n        }\n        else {\n            return '-Infinity';\n        }\n    }, Number),\n    simpleTransformation(function (v) { return v === 0 && 1 / v === -Infinity; }, 'number', function () {\n        return '-0';\n    }, Number),\n    simpleTransformation(isURL, 'URL', function (v) { return v.toString(); }, function (v) { return new URL(v); }),\n];\nfunction compositeTransformation(isApplicable, annotation, transform, untransform) {\n    return {\n        isApplicable: isApplicable,\n        annotation: annotation,\n        transform: transform,\n        untransform: untransform\n    };\n}\nvar symbolRule = compositeTransformation(function (s, superJson) {\n    if (isSymbol(s)) {\n        var isRegistered = !!superJson.symbolRegistry.getIdentifier(s);\n        return isRegistered;\n    }\n    return false;\n}, function (s, superJson) {\n    var identifier = superJson.symbolRegistry.getIdentifier(s);\n    return ['symbol', identifier];\n}, function (v) { return v.description; }, function (_, a, superJson) {\n    var value = superJson.symbolRegistry.getValue(a[1]);\n    if (!value) {\n        throw new Error('Trying to deserialize unknown symbol');\n    }\n    return value;\n});\nvar constructorToName = [\n    Int8Array,\n    Uint8Array,\n    Int16Array,\n    Uint16Array,\n    Int32Array,\n    Uint32Array,\n    Float32Array,\n    Float64Array,\n    Uint8ClampedArray,\n].reduce(function (obj, ctor) {\n    obj[ctor.name] = ctor;\n    return obj;\n}, {});\nvar typedArrayRule = compositeTransformation(isTypedArray, function (v) { return ['typed-array', v.constructor.name]; }, function (v) { return __spreadArray([], __read(v)); }, function (v, a) {\n    var ctor = constructorToName[a[1]];\n    if (!ctor) {\n        throw new Error('Trying to deserialize unknown typed array');\n    }\n    return new ctor(v);\n});\nexport function isInstanceOfRegisteredClass(potentialClass, superJson) {\n    if (potentialClass === null || potentialClass === void 0 ? void 0 : potentialClass.constructor) {\n        var isRegistered = !!superJson.classRegistry.getIdentifier(potentialClass.constructor);\n        return isRegistered;\n    }\n    return false;\n}\nvar classRule = compositeTransformation(isInstanceOfRegisteredClass, function (clazz, superJson) {\n    var identifier = superJson.classRegistry.getIdentifier(clazz.constructor);\n    return ['class', identifier];\n}, function (clazz, superJson) {\n    var allowedProps = superJson.classRegistry.getAllowedProps(clazz.constructor);\n    if (!allowedProps) {\n        return __assign({}, clazz);\n    }\n    var result = {};\n    allowedProps.forEach(function (prop) {\n        result[prop] = clazz[prop];\n    });\n    return result;\n}, function (v, a, superJson) {\n    var clazz = superJson.classRegistry.getValue(a[1]);\n    if (!clazz) {\n        throw new Error('Trying to deserialize unknown class - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564');\n    }\n    return Object.assign(Object.create(clazz.prototype), v);\n});\nvar customRule = compositeTransformation(function (value, superJson) {\n    return !!superJson.customTransformerRegistry.findApplicable(value);\n}, function (value, superJson) {\n    var transformer = superJson.customTransformerRegistry.findApplicable(value);\n    return ['custom', transformer.name];\n}, function (value, superJson) {\n    var transformer = superJson.customTransformerRegistry.findApplicable(value);\n    return transformer.serialize(value);\n}, function (v, a, superJson) {\n    var transformer = superJson.customTransformerRegistry.findByName(a[1]);\n    if (!transformer) {\n        throw new Error('Trying to deserialize unknown custom value');\n    }\n    return transformer.deserialize(v);\n});\nvar compositeRules = [classRule, symbolRule, customRule, typedArrayRule];\nexport var transformValue = function (value, superJson) {\n    var applicableCompositeRule = findArr(compositeRules, function (rule) {\n        return rule.isApplicable(value, superJson);\n    });\n    if (applicableCompositeRule) {\n        return {\n            value: applicableCompositeRule.transform(value, superJson),\n            type: applicableCompositeRule.annotation(value, superJson)\n        };\n    }\n    var applicableSimpleRule = findArr(simpleRules, function (rule) {\n        return rule.isApplicable(value, superJson);\n    });\n    if (applicableSimpleRule) {\n        return {\n            value: applicableSimpleRule.transform(value, superJson),\n            type: applicableSimpleRule.annotation\n        };\n    }\n    return undefined;\n};\nvar simpleRulesByAnnotation = {};\nsimpleRules.forEach(function (rule) {\n    simpleRulesByAnnotation[rule.annotation] = rule;\n});\nexport var untransformValue = function (json, type, superJson) {\n    if (isArray(type)) {\n        switch (type[0]) {\n            case 'symbol':\n                return symbolRule.untransform(json, type, superJson);\n            case 'class':\n                return classRule.untransform(json, type, superJson);\n            case 'custom':\n                return customRule.untransform(json, type, superJson);\n            case 'typed-array':\n                return typedArrayRule.untransform(json, type, superJson);\n            default:\n                throw new Error('Unknown transformation: ' + type);\n        }\n    }\n    else {\n        var transformation = simpleRulesByAnnotation[type];\n        if (!transformation) {\n            throw new Error('Unknown transformation: ' + type);\n        }\n        return transformation.untransform(json, superJson);\n    }\n};\n//# sourceMappingURL=transformer.js.map","import { isMap, isArray, isPlainObject, isSet } from './is';\nimport { includes } from './util';\nvar getNthKey = function (value, n) {\n    var keys = value.keys();\n    while (n > 0) {\n        keys.next();\n        n--;\n    }\n    return keys.next().value;\n};\nfunction validatePath(path) {\n    if (includes(path, '__proto__')) {\n        throw new Error('__proto__ is not allowed as a property');\n    }\n    if (includes(path, 'prototype')) {\n        throw new Error('prototype is not allowed as a property');\n    }\n    if (includes(path, 'constructor')) {\n        throw new Error('constructor is not allowed as a property');\n    }\n}\nexport var getDeep = function (object, path) {\n    validatePath(path);\n    for (var i = 0; i < path.length; i++) {\n        var key = path[i];\n        if (isSet(object)) {\n            object = getNthKey(object, +key);\n        }\n        else if (isMap(object)) {\n            var row = +key;\n            var type = +path[++i] === 0 ? 'key' : 'value';\n            var keyOfRow = getNthKey(object, row);\n            switch (type) {\n                case 'key':\n                    object = keyOfRow;\n                    break;\n                case 'value':\n                    object = object.get(keyOfRow);\n                    break;\n            }\n        }\n        else {\n            object = object[key];\n        }\n    }\n    return object;\n};\nexport var setDeep = function (object, path, mapper) {\n    validatePath(path);\n    if (path.length === 0) {\n        return mapper(object);\n    }\n    var parent = object;\n    for (var i = 0; i < path.length - 1; i++) {\n        var key = path[i];\n        if (isArray(parent)) {\n            var index = +key;\n            parent = parent[index];\n        }\n        else if (isPlainObject(parent)) {\n            parent = parent[key];\n        }\n        else if (isSet(parent)) {\n            var row = +key;\n            parent = getNthKey(parent, row);\n        }\n        else if (isMap(parent)) {\n            var isEnd = i === path.length - 2;\n            if (isEnd) {\n                break;\n            }\n            var row = +key;\n            var type = +path[++i] === 0 ? 'key' : 'value';\n            var keyOfRow = getNthKey(parent, row);\n            switch (type) {\n                case 'key':\n                    parent = keyOfRow;\n                    break;\n                case 'value':\n                    parent = parent.get(keyOfRow);\n                    break;\n            }\n        }\n    }\n    var lastKey = path[path.length - 1];\n    if (isArray(parent)) {\n        parent[+lastKey] = mapper(parent[+lastKey]);\n    }\n    else if (isPlainObject(parent)) {\n        parent[lastKey] = mapper(parent[lastKey]);\n    }\n    if (isSet(parent)) {\n        var oldValue = getNthKey(parent, +lastKey);\n        var newValue = mapper(oldValue);\n        if (oldValue !== newValue) {\n            parent[\"delete\"](oldValue);\n            parent.add(newValue);\n        }\n    }\n    if (isMap(parent)) {\n        var row = +path[path.length - 2];\n        var keyToRow = getNthKey(parent, row);\n        var type = +lastKey === 0 ? 'key' : 'value';\n        switch (type) {\n            case 'key': {\n                var newKey = mapper(keyToRow);\n                parent.set(newKey, parent.get(keyToRow));\n                if (newKey !== keyToRow) {\n                    parent[\"delete\"](keyToRow);\n                }\n                break;\n            }\n            case 'value': {\n                parent.set(keyToRow, mapper(parent.get(keyToRow)));\n                break;\n            }\n        }\n    }\n    return object;\n};\n//# sourceMappingURL=accessDeep.js.map","var __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __spreadArray = (this && this.__spreadArray) || function (to, from) {\n    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\n        to[j] = from[i];\n    return to;\n};\nimport { isArray, isEmptyObject, isMap, isPlainObject, isPrimitive, isSet, } from './is';\nimport { escapeKey, stringifyPath } from './pathstringifier';\nimport { isInstanceOfRegisteredClass, transformValue, untransformValue, } from './transformer';\nimport { includes, forEach } from './util';\nimport { parsePath } from './pathstringifier';\nimport { getDeep, setDeep } from './accessDeep';\nfunction traverse(tree, walker, origin) {\n    if (origin === void 0) { origin = []; }\n    if (!tree) {\n        return;\n    }\n    if (!isArray(tree)) {\n        forEach(tree, function (subtree, key) {\n            return traverse(subtree, walker, __spreadArray(__spreadArray([], __read(origin)), __read(parsePath(key))));\n        });\n        return;\n    }\n    var _a = __read(tree, 2), nodeValue = _a[0], children = _a[1];\n    if (children) {\n        forEach(children, function (child, key) {\n            traverse(child, walker, __spreadArray(__spreadArray([], __read(origin)), __read(parsePath(key))));\n        });\n    }\n    walker(nodeValue, origin);\n}\nexport function applyValueAnnotations(plain, annotations, superJson) {\n    traverse(annotations, function (type, path) {\n        plain = setDeep(plain, path, function (v) { return untransformValue(v, type, superJson); });\n    });\n    return plain;\n}\nexport function applyReferentialEqualityAnnotations(plain, annotations) {\n    function apply(identicalPaths, path) {\n        var object = getDeep(plain, parsePath(path));\n        identicalPaths.map(parsePath).forEach(function (identicalObjectPath) {\n            plain = setDeep(plain, identicalObjectPath, function () { return object; });\n        });\n    }\n    if (isArray(annotations)) {\n        var _a = __read(annotations, 2), root = _a[0], other = _a[1];\n        root.forEach(function (identicalPath) {\n            plain = setDeep(plain, parsePath(identicalPath), function () { return plain; });\n        });\n        if (other) {\n            forEach(other, apply);\n        }\n    }\n    else {\n        forEach(annotations, apply);\n    }\n    return plain;\n}\nvar isDeep = function (object, superJson) {\n    return isPlainObject(object) ||\n        isArray(object) ||\n        isMap(object) ||\n        isSet(object) ||\n        isInstanceOfRegisteredClass(object, superJson);\n};\nfunction addIdentity(object, path, identities) {\n    var existingSet = identities.get(object);\n    if (existingSet) {\n        existingSet.push(path);\n    }\n    else {\n        identities.set(object, [path]);\n    }\n}\nexport function generateReferentialEqualityAnnotations(identitites, dedupe) {\n    var result = {};\n    var rootEqualityPaths = undefined;\n    identitites.forEach(function (paths) {\n        if (paths.length <= 1) {\n            return;\n        }\n        // if we're not deduping, all of these objects continue existing.\n        // putting the shortest path first makes it easier to parse for humans\n        // if we're deduping though, only the first entry will still exist, so we can't do this optimisation.\n        if (!dedupe) {\n            paths = paths\n                .map(function (path) { return path.map(String); })\n                .sort(function (a, b) { return a.length - b.length; });\n        }\n        var _a = __read(paths), representativePath = _a[0], identicalPaths = _a.slice(1);\n        if (representativePath.length === 0) {\n            rootEqualityPaths = identicalPaths.map(stringifyPath);\n        }\n        else {\n            result[stringifyPath(representativePath)] = identicalPaths.map(stringifyPath);\n        }\n    });\n    if (rootEqualityPaths) {\n        if (isEmptyObject(result)) {\n            return [rootEqualityPaths];\n        }\n        else {\n            return [rootEqualityPaths, result];\n        }\n    }\n    else {\n        return isEmptyObject(result) ? undefined : result;\n    }\n}\nexport var walker = function (object, identities, superJson, dedupe, path, objectsInThisPath, seenObjects) {\n    var _a;\n    if (path === void 0) { path = []; }\n    if (objectsInThisPath === void 0) { objectsInThisPath = []; }\n    if (seenObjects === void 0) { seenObjects = new Map(); }\n    var primitive = isPrimitive(object);\n    if (!primitive) {\n        addIdentity(object, path, identities);\n        var seen = seenObjects.get(object);\n        if (seen) {\n            // short-circuit result if we've seen this object before\n            return dedupe\n                ? {\n                    transformedValue: null\n                }\n                : seen;\n        }\n    }\n    if (!isDeep(object, superJson)) {\n        var transformed_1 = transformValue(object, superJson);\n        var result_1 = transformed_1\n            ? {\n                transformedValue: transformed_1.value,\n                annotations: [transformed_1.type]\n            }\n            : {\n                transformedValue: object\n            };\n        if (!primitive) {\n            seenObjects.set(object, result_1);\n        }\n        return result_1;\n    }\n    if (includes(objectsInThisPath, object)) {\n        // prevent circular references\n        return {\n            transformedValue: null\n        };\n    }\n    var transformationResult = transformValue(object, superJson);\n    var transformed = (_a = transformationResult === null || transformationResult === void 0 ? void 0 : transformationResult.value) !== null && _a !== void 0 ? _a : object;\n    var transformedValue = isArray(transformed) ? [] : {};\n    var innerAnnotations = {};\n    forEach(transformed, function (value, index) {\n        var recursiveResult = walker(value, identities, superJson, dedupe, __spreadArray(__spreadArray([], __read(path)), [index]), __spreadArray(__spreadArray([], __read(objectsInThisPath)), [object]), seenObjects);\n        transformedValue[index] = recursiveResult.transformedValue;\n        if (isArray(recursiveResult.annotations)) {\n            innerAnnotations[index] = recursiveResult.annotations;\n        }\n        else if (isPlainObject(recursiveResult.annotations)) {\n            forEach(recursiveResult.annotations, function (tree, key) {\n                innerAnnotations[escapeKey(index) + '.' + key] = tree;\n            });\n        }\n    });\n    var result = isEmptyObject(innerAnnotations)\n        ? {\n            transformedValue: transformedValue,\n            annotations: !!transformationResult\n                ? [transformationResult.type]\n                : undefined\n        }\n        : {\n            transformedValue: transformedValue,\n            annotations: !!transformationResult\n                ? [transformationResult.type, innerAnnotations]\n                : innerAnnotations\n        };\n    if (!primitive) {\n        seenObjects.set(object, result);\n    }\n    return result;\n};\n//# sourceMappingURL=plainer.js.map","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __spreadArray = (this && this.__spreadArray) || function (to, from) {\n    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\n        to[j] = from[i];\n    return to;\n};\nimport { ClassRegistry } from './class-registry';\nimport { Registry } from './registry';\nimport { CustomTransformerRegistry, } from './custom-transformer-registry';\nimport { applyReferentialEqualityAnnotations, applyValueAnnotations, generateReferentialEqualityAnnotations, walker, } from './plainer';\nimport { copy } from 'copy-anything';\nvar SuperJSON = /** @class */ (function () {\n    /**\n     * @param dedupeReferentialEqualities  If true, SuperJSON will make sure only one instance of referentially equal objects are serialized and the rest are replaced with `null`.\n     */\n    function SuperJSON(_a) {\n        var _b = _a === void 0 ? {} : _a, _c = _b.dedupe, dedupe = _c === void 0 ? false : _c;\n        this.classRegistry = new ClassRegistry();\n        this.symbolRegistry = new Registry(function (s) { var _a; return (_a = s.description) !== null && _a !== void 0 ? _a : ''; });\n        this.customTransformerRegistry = new CustomTransformerRegistry();\n        this.allowedErrorProps = [];\n        this.dedupe = dedupe;\n    }\n    SuperJSON.prototype.serialize = function (object) {\n        var identities = new Map();\n        var output = walker(object, identities, this, this.dedupe);\n        var res = {\n            json: output.transformedValue\n        };\n        if (output.annotations) {\n            res.meta = __assign(__assign({}, res.meta), { values: output.annotations });\n        }\n        var equalityAnnotations = generateReferentialEqualityAnnotations(identities, this.dedupe);\n        if (equalityAnnotations) {\n            res.meta = __assign(__assign({}, res.meta), { referentialEqualities: equalityAnnotations });\n        }\n        return res;\n    };\n    SuperJSON.prototype.deserialize = function (payload) {\n        var json = payload.json, meta = payload.meta;\n        var result = copy(json);\n        if (meta === null || meta === void 0 ? void 0 : meta.values) {\n            result = applyValueAnnotations(result, meta.values, this);\n        }\n        if (meta === null || meta === void 0 ? void 0 : meta.referentialEqualities) {\n            result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities);\n        }\n        return result;\n    };\n    SuperJSON.prototype.stringify = function (object) {\n        return JSON.stringify(this.serialize(object));\n    };\n    SuperJSON.prototype.parse = function (string) {\n        return this.deserialize(JSON.parse(string));\n    };\n    SuperJSON.prototype.registerClass = function (v, options) {\n        this.classRegistry.register(v, options);\n    };\n    SuperJSON.prototype.registerSymbol = function (v, identifier) {\n        this.symbolRegistry.register(v, identifier);\n    };\n    SuperJSON.prototype.registerCustom = function (transformer, name) {\n        this.customTransformerRegistry.register(__assign({ name: name }, transformer));\n    };\n    SuperJSON.prototype.allowErrorProps = function () {\n        var _a;\n        var props = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            props[_i] = arguments[_i];\n        }\n        (_a = this.allowedErrorProps).push.apply(_a, __spreadArray([], __read(props)));\n    };\n    SuperJSON.defaultInstance = new SuperJSON();\n    SuperJSON.serialize = SuperJSON.defaultInstance.serialize.bind(SuperJSON.defaultInstance);\n    SuperJSON.deserialize = SuperJSON.defaultInstance.deserialize.bind(SuperJSON.defaultInstance);\n    SuperJSON.stringify = SuperJSON.defaultInstance.stringify.bind(SuperJSON.defaultInstance);\n    SuperJSON.parse = SuperJSON.defaultInstance.parse.bind(SuperJSON.defaultInstance);\n    SuperJSON.registerClass = SuperJSON.defaultInstance.registerClass.bind(SuperJSON.defaultInstance);\n    SuperJSON.registerSymbol = SuperJSON.defaultInstance.registerSymbol.bind(SuperJSON.defaultInstance);\n    SuperJSON.registerCustom = SuperJSON.defaultInstance.registerCustom.bind(SuperJSON.defaultInstance);\n    SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(SuperJSON.defaultInstance);\n    return SuperJSON;\n}());\nexport default SuperJSON;\nexport { SuperJSON };\nexport var serialize = SuperJSON.serialize;\nexport var deserialize = SuperJSON.deserialize;\nexport var stringify = SuperJSON.stringify;\nexport var parse = SuperJSON.parse;\nexport var registerClass = SuperJSON.registerClass;\nexport var registerCustom = SuperJSON.registerCustom;\nexport var registerSymbol = SuperJSON.registerSymbol;\nexport var allowErrorProps = SuperJSON.allowErrorProps;\n//# sourceMappingURL=index.js.map"],"names":["extendStatics","DoubleIndexedKV","this","keyToValue","Map","valueToKey","prototype","set","key","value","getByKey","get","getByValue","clear","Registry","generateIdentifier","kv","register","identifier","getIdentifier","getValue","__extends","d","b","Object","setPrototypeOf","__proto__","Array","p","hasOwnProperty","call","TypeError","String","__","constructor","create","ClassRegistry","_super","_this","c","name","classToAllowedProps","options","allowProps","getAllowedProps","__read","o","n","m","Symbol","iterator","r","e","i","ar","next","done","push","error","find","record","predicate","values","valuesOfObj","valuesNotNever","length","forEach","run","entries","_a","_b","includes","arr","indexOf","findArr","CustomTransformerRegistry","transfomers","transformer","findApplicable","v","isApplicable","findByName","isUndefined","payload","isPlainObject","getPrototypeOf","isEmptyObject","keys","isArray","isMap","isSet","Set","isSymbol","toString","slice","getType","isNaNValue","isNaN","isPrimitive","isBoolean","isNull","isNumber","isString","escapeKey","replace","stringifyPath","path","map","join","parsePath","string","result","segment","char","charAt","lastSegment","__assign","assign","t","s","arguments","apply","__spreadArray","to","from","il","j","simpleTransformation","annotation","transform","untransform","simpleRules","BigInt","console","Date","valueOf","toISOString","Error","superJson","baseError","message","allowedErrorProps","prop","stack","RegExp","regex","body","lastIndexOf","flags","Infinity","Number","URL","compositeTransformation","symbolRule","symbolRegistry","description","_","a","constructorToName","Int8Array","Uint8Array","Int16Array","Uint16Array","Int32Array","Uint32Array","Float32Array","Float64Array","Uint8ClampedArray","reduce","obj","ctor","typedArrayRule","ArrayBuffer","isView","DataView","isInstanceOfRegisteredClass","potentialClass","classRegistry","classRule","clazz","allowedProps","customRule","customTransformerRegistry","serialize","deserialize","compositeRules","transformValue","applicableCompositeRule","rule","type","applicableSimpleRule","simpleRulesByAnnotation","getNthKey","validatePath","setDeep","object","mapper","parent","row","keyOfRow","lastKey","oldValue","newValue","add","keyToRow","newKey","traverse","tree","walker","origin","nodeValue","children","child","subtree","applyValueAnnotations","plain","annotations","json","transformation","untransformValue","applyReferentialEqualityAnnotations","identicalPaths","getDeep","identicalObjectPath","root","other","identicalPath","identities","dedupe","objectsInThisPath","seenObjects","primitive","existingSet","addIdentity","seen","transformedValue","isDeep","transformed_1","result_1","transformationResult","transformed","innerAnnotations","index","recursiveResult","undefined","SuperJSON","_c","output","res","meta","identitites","rootEqualityPaths","equalityAnnotations","paths","sort","representativePath","referentialEqualities","stringify","JSON","parse","registerClass","registerSymbol","registerCustom","allowErrorProps","props","_i","defaultInstance","bind"],"sourceRoot":""}