{"version":3,"file":"defaultVendors-packages_cad-core_src_cad-view_cad-loading-page_tsx-packages_cad-core_src_use--dab281.057694adb2dc1433.prod.js","mappings":"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","sources":["webpack://aurora-new-frontend/./node_modules/mobx-react-lite/es/utils/assertEnvironment.js","webpack://aurora-new-frontend/./node_modules/mobx-react-lite/es/utils/observerBatching.js","webpack://aurora-new-frontend/./node_modules/mobx-react-lite/es/utils/FinalizationRegistryWrapper.js","webpack://aurora-new-frontend/./node_modules/mobx-react-lite/es/utils/reactionCleanupTrackingCommon.js","webpack://aurora-new-frontend/./node_modules/mobx-react-lite/es/utils/createTimerBasedReactionCleanupTracking.js","webpack://aurora-new-frontend/./node_modules/mobx-react-lite/es/utils/reactionCleanupTracking.js","webpack://aurora-new-frontend/./node_modules/mobx-react-lite/es/utils/createReactionCleanupTrackingUsingFinalizationRegister.js","webpack://aurora-new-frontend/./node_modules/mobx-react-lite/es/observer.js","webpack://aurora-new-frontend/./node_modules/mobx-react-lite/es/useLocalObservable.js","webpack://aurora-new-frontend/./node_modules/mobx-react-lite/es/useAsObservableSource.js","webpack://aurora-new-frontend/./node_modules/mobx-react-lite/es/index.js","webpack://aurora-new-frontend/./node_modules/mobx/dist/mobx.esm.js","webpack://aurora-new-frontend/./packages/cad-core/src/cad-view/loading-animation.tsx","webpack://aurora-new-frontend/./packages/cad-core/src/cad-view/cad-loading-page.tsx","webpack://aurora-new-frontend/./packages/cad-state/src/use-once-ref.ts","webpack://aurora-new-frontend/./packages/cad-state/src/use-reactive.ts","webpack://aurora-new-frontend/./packages/cad-core/src/cad-viewport/cad-page-viewports-state.tsx","webpack://aurora-new-frontend/./packages/cad-state/src/reactive-setup.tsx","webpack://aurora-new-frontend/./packages/cad-core/src/cad-viewport/cad-viewport-action-scheduler.tsx","webpack://aurora-new-frontend/./packages/cad-core/src/cad-viewport/constants.ts","webpack://aurora-new-frontend/./packages/cad-core/src/use-cad/cad-context.tsx","webpack://aurora-new-frontend/./packages/common/packages/cad-data-service/src/data-service.generated.tsx","webpack://aurora-new-frontend/./packages/common/packages/cad-data-service/src/data-service.ts","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/utils.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/acceleration.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/angle.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/apparentPower.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/area.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/charge.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/current.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/digital.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/each.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/energy.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/force.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/frequency.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/illuminance.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/length.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/mass.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/pace.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/partsPer.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/power.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/pressure.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/reactiveEnergy.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/reactivePower.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/speed.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/temperature.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/time.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/voltage.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/volume.js","webpack://aurora-new-frontend/./node_modules/units-converter/dist/es/units/volumeFlowRate.js","webpack://aurora-new-frontend/./packages/common/packages/numeric-conversion/src/numeric-conversion-util.ts","webpack://aurora-new-frontend/./packages/common/packages/cad-data-service/src/build-units-fns.ts","webpack://aurora-new-frontend/./packages/common/packages/module-loader/src/module-definitions/interfaces/CAD.ts","webpack://aurora-new-frontend/./packages/cad-core/src/types.ts","webpack://aurora-new-frontend/./packages/cad-core/src/use-cad/lead-capture-geodata-service.ts","webpack://aurora-new-frontend/./packages/cad-preferences/src/preference-descriptor-types.ts","webpack://aurora-new-frontend/./packages/cad-preferences/src/preference-providers.ts","webpack://aurora-new-frontend/./packages/cad-preferences/src/preference-manager.ts","webpack://aurora-new-frontend/./packages/cad-preferences/src/preference-utils.ts","webpack://aurora-new-frontend/./packages/cad-preferences/src/cad-preference-descriptors.ts","webpack://aurora-new-frontend/./packages/cad-state/src/active-tab-data/active-tab-state.tsx","webpack://aurora-new-frontend/./packages/cad-state/src/auto-designer-state/auto-designer-state.tsx","webpack://aurora-new-frontend/./packages/cad-state/src/modal-state/modal-state.tsx","webpack://aurora-new-frontend/./packages/cad-state/src/save-state/save-state.tsx","webpack://aurora-new-frontend/./packages/cad-state/src/cad-state.ts","webpack://aurora-new-frontend/./packages/cad-state/src/selected-types/selected-types-state.ts","webpack://aurora-new-frontend/./packages/cad-state/src/prism-state/prism-state.tsx","webpack://aurora-new-frontend/./packages/common/packages/data-store/src/redux/CAD/events.ts","webpack://aurora-new-frontend/./packages/common/packages/notifications/src/global-channels.ts","webpack://aurora-new-frontend/./packages/file-uploader/src/file-uploader.generated.tsx","webpack://aurora-new-frontend/./packages/file-uploader/src/hooks/use-create-bss-upload-urls.ts","webpack://aurora-new-frontend/./packages/file-uploader/src/hooks/use-upload-file-async-job.ts","webpack://aurora-new-frontend/./packages/file-uploader/src/hooks/use-upload-files.ts","webpack://aurora-new-frontend/./packages/cad-core/src/cad.generated.tsx","webpack://aurora-new-frontend/./packages/cad-core/src/cad-save-callback/cad-save-callback.generated.tsx","webpack://aurora-new-frontend/./packages/cad-core/src/cad-save-callback/take-save-screenshot.ts","webpack://aurora-new-frontend/./packages/cad-core/src/cad-save-callback/cad-save-callback-core.ts","webpack://aurora-new-frontend/./packages/cad-core/src/cad-save-callback/check-cad-can-save.ts","webpack://aurora-new-frontend/./packages/cad-core/src/cad-save-callback/get-cad-save-callback.ts","webpack://aurora-new-frontend/./packages/common/packages/core/src/utils/download-utils.ts","webpack://aurora-new-frontend/./packages/cad-core/src/downloads/download-dxf.ts","webpack://aurora-new-frontend/./packages/cad-core/src/downloads/asset.generated.tsx","webpack://aurora-new-frontend/./packages/cad-core/src/downloads/download-png.ts","webpack://aurora-new-frontend/./packages/cad-core/src/webgl-check.ts","webpack://aurora-new-frontend/./packages/cad-core/src/provide-cad/event-handler.ts","webpack://aurora-new-frontend/./packages/cad-core/src/use-cad/use-cad.tsx","webpack://aurora-new-frontend/./packages/common/packages/core/src/hooks/use-evict-cache/use-evict-cache.ts","webpack://aurora-new-frontend/./packages/cad-core/src/provide-cad/cleanup-cad.ts","webpack://aurora-new-frontend/./packages/cad-core/src/use-cad/use-lead-capture-cad.generated.tsx","webpack://aurora-new-frontend/./packages/cad-core/src/use-cad/use-lead-capture-cad.ts","webpack://aurora-new-frontend/./packages/cad-state/src/framework-deep.ts","webpack://aurora-new-frontend/./packages/cad-state/src/framework.ts","webpack://aurora-new-frontend/./packages/common/packages/core/src/utils/uuid.ts","webpack://aurora-new-frontend/./packages/common/packages/shared-domain/src/use-intercept-mouse/use-intercept-mouse.tsx","webpack://aurora-new-frontend/./packages/file-uploader/src/common/types.ts","webpack://aurora-new-frontend/./packages/file-uploader/src/common/utils.ts","webpack://aurora-new-frontend/./node_modules/uuid/dist/esm-browser/rng.js","webpack://aurora-new-frontend/./node_modules/uuid/dist/esm-browser/regex.js","webpack://aurora-new-frontend/./node_modules/uuid/dist/esm-browser/validate.js","webpack://aurora-new-frontend/./node_modules/uuid/dist/esm-browser/stringify.js","webpack://aurora-new-frontend/./node_modules/uuid/dist/esm-browser/v4.js"],"sourcesContent":["import { makeObservable } from \"mobx\";\nimport { useState } from \"react\";\nif (!useState) {\n    throw new Error(\"mobx-react-lite requires React with Hooks support\");\n}\nif (!makeObservable) {\n    throw new Error(\"mobx-react-lite@3 requires mobx at least version 6 to be available\");\n}\n//# sourceMappingURL=assertEnvironment.js.map","import { configure } from \"mobx\";\nexport function defaultNoopBatch(callback) {\n    callback();\n}\nexport function observerBatching(reactionScheduler) {\n    if (!reactionScheduler) {\n        reactionScheduler = defaultNoopBatch;\n        if (\"production\" !== process.env.NODE_ENV) {\n            console.warn(\"[MobX] Failed to get unstable_batched updates from react-dom / react-native\");\n        }\n    }\n    configure({ reactionScheduler: reactionScheduler });\n}\nexport var isObserverBatched = function () {\n    if (\"production\" !== process.env.NODE_ENV) {\n        console.warn(\"[MobX] Deprecated\");\n    }\n    return true;\n};\n//# sourceMappingURL=observerBatching.js.map","var FinalizationRegistryLocal = typeof FinalizationRegistry === \"undefined\" ? undefined : FinalizationRegistry;\nexport { FinalizationRegistryLocal as FinalizationRegistry };\n//# sourceMappingURL=FinalizationRegistryWrapper.js.map","export function createTrackingData(reaction) {\n    var trackingData = {\n        reaction: reaction,\n        mounted: false,\n        changedBeforeMount: false,\n        cleanAt: Date.now() + CLEANUP_LEAKED_REACTIONS_AFTER_MILLIS\n    };\n    return trackingData;\n}\n/**\n * The minimum time before we'll clean up a Reaction created in a render\n * for a component that hasn't managed to run its effects. This needs to\n * be big enough to ensure that a component won't turn up and have its\n * effects run without being re-rendered.\n */\nexport var CLEANUP_LEAKED_REACTIONS_AFTER_MILLIS = 10000;\n/**\n * The frequency with which we'll check for leaked reactions.\n */\nexport var CLEANUP_TIMER_LOOP_MILLIS = 10000;\n//# sourceMappingURL=reactionCleanupTrackingCommon.js.map","var __values = (this && this.__values) || function(o) {\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n    if (m) return m.call(o);\n    if (o && typeof o.length === \"number\") return {\n        next: function () {\n            if (o && i >= o.length) o = void 0;\n            return { value: o && o[i++], done: !o };\n        }\n    };\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n};\nimport { CLEANUP_TIMER_LOOP_MILLIS, createTrackingData } from \"./reactionCleanupTrackingCommon\";\n/**\n * timers, gc-style, uncommitted reaction cleanup\n */\nexport function createTimerBasedReactionCleanupTracking() {\n    /**\n     * Reactions created by components that have yet to be fully mounted.\n     */\n    var uncommittedReactionRefs = new Set();\n    /**\n     * Latest 'uncommitted reactions' cleanup timer handle.\n     */\n    var reactionCleanupHandle;\n    /* istanbul ignore next */\n    /**\n     * Only to be used by test functions; do not export outside of mobx-react-lite\n     */\n    function forceCleanupTimerToRunNowForTests() {\n        // This allows us to control the execution of the cleanup timer\n        // to force it to run at awkward times in unit tests.\n        if (reactionCleanupHandle) {\n            clearTimeout(reactionCleanupHandle);\n            cleanUncommittedReactions();\n        }\n    }\n    /* istanbul ignore next */\n    function resetCleanupScheduleForTests() {\n        var e_1, _a;\n        if (uncommittedReactionRefs.size > 0) {\n            try {\n                for (var uncommittedReactionRefs_1 = __values(uncommittedReactionRefs), uncommittedReactionRefs_1_1 = uncommittedReactionRefs_1.next(); !uncommittedReactionRefs_1_1.done; uncommittedReactionRefs_1_1 = uncommittedReactionRefs_1.next()) {\n                    var ref = uncommittedReactionRefs_1_1.value;\n                    var tracking = ref.current;\n                    if (tracking) {\n                        tracking.reaction.dispose();\n                        ref.current = null;\n                    }\n                }\n            }\n            catch (e_1_1) { e_1 = { error: e_1_1 }; }\n            finally {\n                try {\n                    if (uncommittedReactionRefs_1_1 && !uncommittedReactionRefs_1_1.done && (_a = uncommittedReactionRefs_1.return)) _a.call(uncommittedReactionRefs_1);\n                }\n                finally { if (e_1) throw e_1.error; }\n            }\n            uncommittedReactionRefs.clear();\n        }\n        if (reactionCleanupHandle) {\n            clearTimeout(reactionCleanupHandle);\n            reactionCleanupHandle = undefined;\n        }\n    }\n    function ensureCleanupTimerRunning() {\n        if (reactionCleanupHandle === undefined) {\n            reactionCleanupHandle = setTimeout(cleanUncommittedReactions, CLEANUP_TIMER_LOOP_MILLIS);\n        }\n    }\n    function scheduleCleanupOfReactionIfLeaked(ref) {\n        uncommittedReactionRefs.add(ref);\n        ensureCleanupTimerRunning();\n    }\n    function recordReactionAsCommitted(reactionRef) {\n        uncommittedReactionRefs.delete(reactionRef);\n    }\n    /**\n     * Run by the cleanup timer to dispose any outstanding reactions\n     */\n    function cleanUncommittedReactions() {\n        reactionCleanupHandle = undefined;\n        // Loop through all the candidate leaked reactions; those older\n        // than CLEANUP_LEAKED_REACTIONS_AFTER_MILLIS get tidied.\n        var now = Date.now();\n        uncommittedReactionRefs.forEach(function (ref) {\n            var tracking = ref.current;\n            if (tracking) {\n                if (now >= tracking.cleanAt) {\n                    // It's time to tidy up this leaked reaction.\n                    tracking.reaction.dispose();\n                    ref.current = null;\n                    uncommittedReactionRefs.delete(ref);\n                }\n            }\n        });\n        if (uncommittedReactionRefs.size > 0) {\n            // We've just finished a round of cleanups but there are still\n            // some leak candidates outstanding.\n            ensureCleanupTimerRunning();\n        }\n    }\n    return {\n        addReactionToTrack: function (reactionTrackingRef, reaction, \n        /**\n         * On timer based implementation we don't really need this object,\n         * but we keep the same api\n         */\n        objectRetainedByReact) {\n            reactionTrackingRef.current = createTrackingData(reaction);\n            scheduleCleanupOfReactionIfLeaked(reactionTrackingRef);\n            return reactionTrackingRef.current;\n        },\n        recordReactionAsCommitted: recordReactionAsCommitted,\n        forceCleanupTimerToRunNowForTests: forceCleanupTimerToRunNowForTests,\n        resetCleanupScheduleForTests: resetCleanupScheduleForTests\n    };\n}\n//# sourceMappingURL=createTimerBasedReactionCleanupTracking.js.map","import { FinalizationRegistry as FinalizationRegistryMaybeUndefined } from \"./FinalizationRegistryWrapper\";\nimport { createReactionCleanupTrackingUsingFinalizationRegister } from \"./createReactionCleanupTrackingUsingFinalizationRegister\";\nimport { createTimerBasedReactionCleanupTracking } from \"./createTimerBasedReactionCleanupTracking\";\nvar _a = FinalizationRegistryMaybeUndefined\n    ? createReactionCleanupTrackingUsingFinalizationRegister(FinalizationRegistryMaybeUndefined)\n    : createTimerBasedReactionCleanupTracking(), addReactionToTrack = _a.addReactionToTrack, recordReactionAsCommitted = _a.recordReactionAsCommitted, resetCleanupScheduleForTests = _a.resetCleanupScheduleForTests, forceCleanupTimerToRunNowForTests = _a.forceCleanupTimerToRunNowForTests;\nexport { addReactionToTrack, recordReactionAsCommitted, resetCleanupScheduleForTests, forceCleanupTimerToRunNowForTests };\n//# sourceMappingURL=reactionCleanupTracking.js.map","import { createTrackingData } from \"./reactionCleanupTrackingCommon\";\n/**\n * FinalizationRegistry-based uncommitted reaction cleanup\n */\nexport function createReactionCleanupTrackingUsingFinalizationRegister(FinalizationRegistry) {\n    var cleanupTokenToReactionTrackingMap = new Map();\n    var globalCleanupTokensCounter = 1;\n    var registry = new FinalizationRegistry(function cleanupFunction(token) {\n        var trackedReaction = cleanupTokenToReactionTrackingMap.get(token);\n        if (trackedReaction) {\n            trackedReaction.reaction.dispose();\n            cleanupTokenToReactionTrackingMap.delete(token);\n        }\n    });\n    return {\n        addReactionToTrack: function (reactionTrackingRef, reaction, objectRetainedByReact) {\n            var token = globalCleanupTokensCounter++;\n            registry.register(objectRetainedByReact, token, reactionTrackingRef);\n            reactionTrackingRef.current = createTrackingData(reaction);\n            reactionTrackingRef.current.finalizationRegistryCleanupToken = token;\n            cleanupTokenToReactionTrackingMap.set(token, reactionTrackingRef.current);\n            return reactionTrackingRef.current;\n        },\n        recordReactionAsCommitted: function (reactionRef) {\n            registry.unregister(reactionRef);\n            if (reactionRef.current && reactionRef.current.finalizationRegistryCleanupToken) {\n                cleanupTokenToReactionTrackingMap.delete(reactionRef.current.finalizationRegistryCleanupToken);\n            }\n        },\n        forceCleanupTimerToRunNowForTests: function () {\n            // When FinalizationRegistry in use, this this is no-op\n        },\n        resetCleanupScheduleForTests: function () {\n            // When FinalizationRegistry in use, this this is no-op\n        }\n    };\n}\n//# sourceMappingURL=createReactionCleanupTrackingUsingFinalizationRegister.js.map","import { forwardRef, memo } from \"react\";\nimport { isUsingStaticRendering } from \"./staticRendering\";\nimport { useObserver } from \"./useObserver\";\nvar warnObserverOptionsDeprecated = true;\nvar hasSymbol = typeof Symbol === \"function\" && Symbol.for;\n// Using react-is had some issues (and operates on elements, not on types), see #608 / #609\nvar ReactForwardRefSymbol = hasSymbol\n    ? Symbol.for(\"react.forward_ref\")\n    : typeof forwardRef === \"function\" && forwardRef(function (props) { return null; })[\"$$typeof\"];\nvar ReactMemoSymbol = hasSymbol\n    ? Symbol.for(\"react.memo\")\n    : typeof memo === \"function\" && memo(function (props) { return null; })[\"$$typeof\"];\n// n.b. base case is not used for actual typings or exported in the typing files\nexport function observer(baseComponent, \n// TODO remove in next major\noptions) {\n    var _a;\n    if (process.env.NODE_ENV !== \"production\" && warnObserverOptionsDeprecated && options) {\n        warnObserverOptionsDeprecated = false;\n        console.warn(\"[mobx-react-lite] `observer(fn, { forwardRef: true })` is deprecated, use `observer(React.forwardRef(fn))`\");\n    }\n    if (ReactMemoSymbol && baseComponent[\"$$typeof\"] === ReactMemoSymbol) {\n        throw new Error(\"[mobx-react-lite] You are trying to use `observer` on a function component wrapped in either another `observer` or `React.memo`. The observer already applies 'React.memo' for you.\");\n    }\n    // The working of observer is explained step by step in this talk: https://www.youtube.com/watch?v=cPF4iBedoF0&feature=youtu.be&t=1307\n    if (isUsingStaticRendering()) {\n        return baseComponent;\n    }\n    var useForwardRef = (_a = options === null || options === void 0 ? void 0 : options.forwardRef) !== null && _a !== void 0 ? _a : false;\n    var render = baseComponent;\n    var baseComponentName = baseComponent.displayName || baseComponent.name;\n    // If already wrapped with forwardRef, unwrap,\n    // so we can patch render and apply memo\n    if (ReactForwardRefSymbol && baseComponent[\"$$typeof\"] === ReactForwardRefSymbol) {\n        useForwardRef = true;\n        render = baseComponent[\"render\"];\n        if (typeof render !== \"function\") {\n            throw new Error(\"[mobx-react-lite] `render` property of ForwardRef was not a function\");\n        }\n    }\n    var observerComponent = function (props, ref) {\n        return useObserver(function () { return render(props, ref); }, baseComponentName);\n    };\n    // Don't set `displayName` for anonymous components,\n    // so the `displayName` can be customized by user, see #3192.\n    if (baseComponentName !== \"\") {\n        ;\n        observerComponent.displayName = baseComponentName;\n    }\n    // Support legacy context: `contextTypes` must be applied before `memo`\n    if (baseComponent.contextTypes) {\n        ;\n        observerComponent.contextTypes = baseComponent.contextTypes;\n    }\n    if (useForwardRef) {\n        // `forwardRef` must be applied prior `memo`\n        // `forwardRef(observer(cmp))` throws:\n        // \"forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))\"\n        observerComponent = forwardRef(observerComponent);\n    }\n    // memo; we are not interested in deep updates\n    // in props; we assume that if deep objects are changed,\n    // this is in observables, which would have been tracked anyway\n    observerComponent = memo(observerComponent);\n    copyStaticProperties(baseComponent, observerComponent);\n    if (\"production\" !== process.env.NODE_ENV) {\n        Object.defineProperty(observerComponent, \"contextTypes\", {\n            set: function () {\n                var _a;\n                throw new Error(\"[mobx-react-lite] `\".concat(this.displayName || ((_a = this.type) === null || _a === void 0 ? void 0 : _a.displayName) || \"Component\", \".contextTypes` must be set before applying `observer`.\"));\n            }\n        });\n    }\n    return observerComponent;\n}\n// based on https://github.com/mridgway/hoist-non-react-statics/blob/master/src/index.js\nvar hoistBlackList = {\n    $$typeof: true,\n    render: true,\n    compare: true,\n    type: true,\n    // Don't redefine `displayName`,\n    // it's defined as getter-setter pair on `memo` (see #3192).\n    displayName: true\n};\nfunction copyStaticProperties(base, target) {\n    Object.keys(base).forEach(function (key) {\n        if (!hoistBlackList[key]) {\n            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(base, key));\n        }\n    });\n}\n//# sourceMappingURL=observer.js.map","import { observable } from \"mobx\";\nimport { useState } from \"react\";\nexport function useLocalObservable(initializer, annotations) {\n    return useState(function () { return observable(initializer(), annotations, { autoBind: true }); })[0];\n}\n//# sourceMappingURL=useLocalObservable.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};\nimport { useDeprecated } from \"./utils/utils\";\nimport { observable, runInAction } from \"mobx\";\nimport { useState } from \"react\";\nexport function useAsObservableSource(current) {\n    if (\"production\" !== process.env.NODE_ENV)\n        useDeprecated(\"[mobx-react-lite] 'useAsObservableSource' is deprecated, please store the values directly in an observable, for example by using 'useLocalObservable', and sync future updates using 'useEffect' when needed. See the README for examples.\");\n    var _a = __read(useState(function () { return observable(current, {}, { deep: false }); }), 1), res = _a[0];\n    runInAction(function () {\n        Object.assign(res, current);\n    });\n    return res;\n}\n//# sourceMappingURL=useAsObservableSource.js.map","import \"./utils/assertEnvironment\";\nimport { unstable_batchedUpdates as batch } from \"./utils/reactBatchedUpdates\";\nimport { observerBatching } from \"./utils/observerBatching\";\nimport { useDeprecated } from \"./utils/utils\";\nimport { useObserver as useObserverOriginal } from \"./useObserver\";\nimport { enableStaticRendering } from \"./staticRendering\";\nobserverBatching(batch);\nexport { isUsingStaticRendering, enableStaticRendering } from \"./staticRendering\";\nexport { observer } from \"./observer\";\nexport { Observer } from \"./ObserverComponent\";\nexport { useLocalObservable } from \"./useLocalObservable\";\nexport { useLocalStore } from \"./useLocalStore\";\nexport { useAsObservableSource } from \"./useAsObservableSource\";\nexport { resetCleanupScheduleForTests as clearTimers } from \"./utils/reactionCleanupTracking\";\nexport function useObserver(fn, baseComponentName) {\n    if (baseComponentName === void 0) { baseComponentName = \"observed\"; }\n    if (\"production\" !== process.env.NODE_ENV) {\n        useDeprecated(\"[mobx-react-lite] 'useObserver(fn)' is deprecated. Use `<Observer>{fn}</Observer>` instead, or wrap the entire component in `observer`.\");\n    }\n    return useObserverOriginal(fn, baseComponentName);\n}\nexport { isObserverBatched, observerBatching } from \"./utils/observerBatching\";\nexport function useStaticRendering(enable) {\n    if (\"production\" !== process.env.NODE_ENV) {\n        console.warn(\"[mobx-react-lite] 'useStaticRendering' is deprecated, use 'enableStaticRendering' instead\");\n    }\n    enableStaticRendering(enable);\n}\n//# sourceMappingURL=index.js.map","var niceErrors = {\n  0: \"Invalid value for configuration 'enforceActions', expected 'never', 'always' or 'observed'\",\n  1: function _(annotationType, key) {\n    return \"Cannot apply '\" + annotationType + \"' to '\" + key.toString() + \"': Field not found.\";\n  },\n\n  /*\r\n  2(prop) {\r\n      return `invalid decorator for '${prop.toString()}'`\r\n  },\r\n  3(prop) {\r\n      return `Cannot decorate '${prop.toString()}': action can only be used on properties with a function value.`\r\n  },\r\n  4(prop) {\r\n      return `Cannot decorate '${prop.toString()}': computed can only be used on getter properties.`\r\n  },\r\n  */\n  5: \"'keys()' can only be used on observable objects, arrays, sets and maps\",\n  6: \"'values()' can only be used on observable objects, arrays, sets and maps\",\n  7: \"'entries()' can only be used on observable objects, arrays and maps\",\n  8: \"'set()' can only be used on observable objects, arrays and maps\",\n  9: \"'remove()' can only be used on observable objects, arrays and maps\",\n  10: \"'has()' can only be used on observable objects, arrays and maps\",\n  11: \"'get()' can only be used on observable objects, arrays and maps\",\n  12: \"Invalid annotation\",\n  13: \"Dynamic observable objects cannot be frozen. If you're passing observables to 3rd party component/function that calls Object.freeze, pass copy instead: toJS(observable)\",\n  14: \"Intercept handlers should return nothing or a change object\",\n  15: \"Observable arrays cannot be frozen. If you're passing observables to 3rd party component/function that calls Object.freeze, pass copy instead: toJS(observable)\",\n  16: \"Modification exception: the internal structure of an observable array was changed.\",\n  17: function _(index, length) {\n    return \"[mobx.array] Index out of bounds, \" + index + \" is larger than \" + length;\n  },\n  18: \"mobx.map requires Map polyfill for the current browser. Check babel-polyfill or core-js/es6/map.js\",\n  19: function _(other) {\n    return \"Cannot initialize from classes that inherit from Map: \" + other.constructor.name;\n  },\n  20: function _(other) {\n    return \"Cannot initialize map from \" + other;\n  },\n  21: function _(dataStructure) {\n    return \"Cannot convert to map from '\" + dataStructure + \"'\";\n  },\n  22: \"mobx.set requires Set polyfill for the current browser. Check babel-polyfill or core-js/es6/set.js\",\n  23: \"It is not possible to get index atoms from arrays\",\n  24: function _(thing) {\n    return \"Cannot obtain administration from \" + thing;\n  },\n  25: function _(property, name) {\n    return \"the entry '\" + property + \"' does not exist in the observable map '\" + name + \"'\";\n  },\n  26: \"please specify a property\",\n  27: function _(property, name) {\n    return \"no observable property '\" + property.toString() + \"' found on the observable object '\" + name + \"'\";\n  },\n  28: function _(thing) {\n    return \"Cannot obtain atom from \" + thing;\n  },\n  29: \"Expecting some object\",\n  30: \"invalid action stack. did you forget to finish an action?\",\n  31: \"missing option for computed: get\",\n  32: function _(name, derivation) {\n    return \"Cycle detected in computation \" + name + \": \" + derivation;\n  },\n  33: function _(name) {\n    return \"The setter of computed value '\" + name + \"' is trying to update itself. Did you intend to update an _observable_ value, instead of the computed property?\";\n  },\n  34: function _(name) {\n    return \"[ComputedValue '\" + name + \"'] It is not possible to assign a new value to a computed value.\";\n  },\n  35: \"There are multiple, different versions of MobX active. Make sure MobX is loaded only once or use `configure({ isolateGlobalState: true })`\",\n  36: \"isolateGlobalState should be called before MobX is running any reactions\",\n  37: function _(method) {\n    return \"[mobx] `observableArray.\" + method + \"()` mutates the array in-place, which is not allowed inside a derivation. Use `array.slice().\" + method + \"()` instead\";\n  },\n  38: \"'ownKeys()' can only be used on observable objects\",\n  39: \"'defineProperty()' can only be used on observable objects\"\n};\nvar errors = process.env.NODE_ENV !== \"production\" ? niceErrors : {};\nfunction die(error) {\n  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    args[_key - 1] = arguments[_key];\n  }\n\n  if (process.env.NODE_ENV !== \"production\") {\n    var e = typeof error === \"string\" ? error : errors[error];\n    if (typeof e === \"function\") e = e.apply(null, args);\n    throw new Error(\"[MobX] \" + e);\n  }\n\n  throw new Error(typeof error === \"number\" ? \"[MobX] minified error nr: \" + error + (args.length ? \" \" + args.map(String).join(\",\") : \"\") + \". Find the full error at: https://github.com/mobxjs/mobx/blob/main/packages/mobx/src/errors.ts\" : \"[MobX] \" + error);\n}\n\nvar mockGlobal = {};\nfunction getGlobal() {\n  if (typeof globalThis !== \"undefined\") {\n    return globalThis;\n  }\n\n  if (typeof window !== \"undefined\") {\n    return window;\n  }\n\n  if (typeof global !== \"undefined\") {\n    return global;\n  }\n\n  if (typeof self !== \"undefined\") {\n    return self;\n  }\n\n  return mockGlobal;\n}\n\nvar assign = Object.assign;\nvar getDescriptor = Object.getOwnPropertyDescriptor;\nvar defineProperty = Object.defineProperty;\nvar objectPrototype = Object.prototype;\nvar EMPTY_ARRAY = [];\nObject.freeze(EMPTY_ARRAY);\nvar EMPTY_OBJECT = {};\nObject.freeze(EMPTY_OBJECT);\nvar hasProxy = typeof Proxy !== \"undefined\";\nvar plainObjectString = /*#__PURE__*/Object.toString();\nfunction assertProxies() {\n  if (!hasProxy) {\n    die(process.env.NODE_ENV !== \"production\" ? \"`Proxy` objects are not available in the current environment. Please configure MobX to enable a fallback implementation.`\" : \"Proxy not available\");\n  }\n}\nfunction warnAboutProxyRequirement(msg) {\n  if (process.env.NODE_ENV !== \"production\" && globalState.verifyProxies) {\n    die(\"MobX is currently configured to be able to run in ES5 mode, but in ES5 MobX won't be able to \" + msg);\n  }\n}\nfunction getNextId() {\n  return ++globalState.mobxGuid;\n}\n/**\r\n * Makes sure that the provided function is invoked at most once.\r\n */\n\nfunction once(func) {\n  var invoked = false;\n  return function () {\n    if (invoked) {\n      return;\n    }\n\n    invoked = true;\n    return func.apply(this, arguments);\n  };\n}\nvar noop = function noop() {};\nfunction isFunction(fn) {\n  return typeof fn === \"function\";\n}\nfunction isStringish(value) {\n  var t = typeof value;\n\n  switch (t) {\n    case \"string\":\n    case \"symbol\":\n    case \"number\":\n      return true;\n  }\n\n  return false;\n}\nfunction isObject(value) {\n  return value !== null && typeof value === \"object\";\n}\nfunction isPlainObject(value) {\n  if (!isObject(value)) {\n    return false;\n  }\n\n  var proto = Object.getPrototypeOf(value);\n\n  if (proto == null) {\n    return true;\n  }\n\n  var protoConstructor = Object.hasOwnProperty.call(proto, \"constructor\") && proto.constructor;\n  return typeof protoConstructor === \"function\" && protoConstructor.toString() === plainObjectString;\n} // https://stackoverflow.com/a/37865170\n\nfunction isGenerator(obj) {\n  var constructor = obj == null ? void 0 : obj.constructor;\n\n  if (!constructor) {\n    return false;\n  }\n\n  if (\"GeneratorFunction\" === constructor.name || \"GeneratorFunction\" === constructor.displayName) {\n    return true;\n  }\n\n  return false;\n}\nfunction addHiddenProp(object, propName, value) {\n  defineProperty(object, propName, {\n    enumerable: false,\n    writable: true,\n    configurable: true,\n    value: value\n  });\n}\nfunction addHiddenFinalProp(object, propName, value) {\n  defineProperty(object, propName, {\n    enumerable: false,\n    writable: false,\n    configurable: true,\n    value: value\n  });\n}\nfunction createInstanceofPredicate(name, theClass) {\n  var propName = \"isMobX\" + name;\n  theClass.prototype[propName] = true;\n  return function (x) {\n    return isObject(x) && x[propName] === true;\n  };\n}\nfunction isES6Map(thing) {\n  return thing instanceof Map;\n}\nfunction isES6Set(thing) {\n  return thing instanceof Set;\n}\nvar hasGetOwnPropertySymbols = typeof Object.getOwnPropertySymbols !== \"undefined\";\n/**\r\n * Returns the following: own enumerable keys and symbols.\r\n */\n\nfunction getPlainObjectKeys(object) {\n  var keys = Object.keys(object); // Not supported in IE, so there are not going to be symbol props anyway...\n\n  if (!hasGetOwnPropertySymbols) {\n    return keys;\n  }\n\n  var symbols = Object.getOwnPropertySymbols(object);\n\n  if (!symbols.length) {\n    return keys;\n  }\n\n  return [].concat(keys, symbols.filter(function (s) {\n    return objectPrototype.propertyIsEnumerable.call(object, s);\n  }));\n} // From Immer utils\n// Returns all own keys, including non-enumerable and symbolic\n\nvar ownKeys = typeof Reflect !== \"undefined\" && Reflect.ownKeys ? Reflect.ownKeys : hasGetOwnPropertySymbols ? function (obj) {\n  return Object.getOwnPropertyNames(obj).concat(Object.getOwnPropertySymbols(obj));\n} :\n/* istanbul ignore next */\nObject.getOwnPropertyNames;\nfunction stringifyKey(key) {\n  if (typeof key === \"string\") {\n    return key;\n  }\n\n  if (typeof key === \"symbol\") {\n    return key.toString();\n  }\n\n  return new String(key).toString();\n}\nfunction toPrimitive(value) {\n  return value === null ? null : typeof value === \"object\" ? \"\" + value : value;\n}\nfunction hasProp(target, prop) {\n  return objectPrototype.hasOwnProperty.call(target, prop);\n} // From Immer utils\n\nvar getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || function getOwnPropertyDescriptors(target) {\n  // Polyfill needed for Hermes and IE, see https://github.com/facebook/hermes/issues/274\n  var res = {}; // Note: without polyfill for ownKeys, symbols won't be picked up\n\n  ownKeys(target).forEach(function (key) {\n    res[key] = getDescriptor(target, key);\n  });\n  return res;\n};\n\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  Object.defineProperty(Constructor, \"prototype\", {\n    writable: false\n  });\n  return Constructor;\n}\n\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nfunction _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n\n  _setPrototypeOf(subClass, superClass);\n}\n\nfunction _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}\n\nfunction _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\n\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n\n  return arr2;\n}\n\nfunction _createForOfIteratorHelperLoose(o, allowArrayLike) {\n  var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n  if (it) return (it = it.call(o)).next.bind(it);\n\n  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n    if (it) o = it;\n    var i = 0;\n    return function () {\n      if (i >= o.length) return {\n        done: true\n      };\n      return {\n        done: false,\n        value: o[i++]\n      };\n    };\n  }\n\n  throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nvar storedAnnotationsSymbol = /*#__PURE__*/Symbol(\"mobx-stored-annotations\");\n/**\r\n * Creates a function that acts as\r\n * - decorator\r\n * - annotation object\r\n */\n\nfunction createDecoratorAnnotation(annotation) {\n  function decorator(target, property) {\n    storeAnnotation(target, property, annotation);\n  }\n\n  return Object.assign(decorator, annotation);\n}\n/**\r\n * Stores annotation to prototype,\r\n * so it can be inspected later by `makeObservable` called from constructor\r\n */\n\nfunction storeAnnotation(prototype, key, annotation) {\n  if (!hasProp(prototype, storedAnnotationsSymbol)) {\n    addHiddenProp(prototype, storedAnnotationsSymbol, _extends({}, prototype[storedAnnotationsSymbol]));\n  } // @override must override something\n\n\n  if (process.env.NODE_ENV !== \"production\" && isOverride(annotation) && !hasProp(prototype[storedAnnotationsSymbol], key)) {\n    var fieldName = prototype.constructor.name + \".prototype.\" + key.toString();\n    die(\"'\" + fieldName + \"' is decorated with 'override', \" + \"but no such decorated member was found on prototype.\");\n  } // Cannot re-decorate\n\n\n  assertNotDecorated(prototype, annotation, key); // Ignore override\n\n  if (!isOverride(annotation)) {\n    prototype[storedAnnotationsSymbol][key] = annotation;\n  }\n}\n\nfunction assertNotDecorated(prototype, annotation, key) {\n  if (process.env.NODE_ENV !== \"production\" && !isOverride(annotation) && hasProp(prototype[storedAnnotationsSymbol], key)) {\n    var fieldName = prototype.constructor.name + \".prototype.\" + key.toString();\n    var currentAnnotationType = prototype[storedAnnotationsSymbol][key].annotationType_;\n    var requestedAnnotationType = annotation.annotationType_;\n    die(\"Cannot apply '@\" + requestedAnnotationType + \"' to '\" + fieldName + \"':\" + (\"\\nThe field is already decorated with '@\" + currentAnnotationType + \"'.\") + \"\\nRe-decorating fields is not allowed.\" + \"\\nUse '@override' decorator for methods overridden by subclass.\");\n  }\n}\n/**\r\n * Collects annotations from prototypes and stores them on target (instance)\r\n */\n\n\nfunction collectStoredAnnotations(target) {\n  if (!hasProp(target, storedAnnotationsSymbol)) {\n    if (process.env.NODE_ENV !== \"production\" && !target[storedAnnotationsSymbol]) {\n      die(\"No annotations were passed to makeObservable, but no decorated members have been found either\");\n    } // We need a copy as we will remove annotation from the list once it's applied.\n\n\n    addHiddenProp(target, storedAnnotationsSymbol, _extends({}, target[storedAnnotationsSymbol]));\n  }\n\n  return target[storedAnnotationsSymbol];\n}\n\nvar $mobx = /*#__PURE__*/Symbol(\"mobx administration\");\nvar Atom = /*#__PURE__*/function () {\n  // for effective unobserving. BaseAtom has true, for extra optimization, so its onBecomeUnobserved never gets called, because it's not needed\n\n  /**\r\n   * Create a new atom. For debugging purposes it is recommended to give it a name.\r\n   * The onBecomeObserved and onBecomeUnobserved callbacks can be used for resource management.\r\n   */\n  function Atom(name_) {\n    if (name_ === void 0) {\n      name_ = process.env.NODE_ENV !== \"production\" ? \"Atom@\" + getNextId() : \"Atom\";\n    }\n\n    this.name_ = void 0;\n    this.isPendingUnobservation_ = false;\n    this.isBeingObserved_ = false;\n    this.observers_ = new Set();\n    this.diffValue_ = 0;\n    this.lastAccessedBy_ = 0;\n    this.lowestObserverState_ = IDerivationState_.NOT_TRACKING_;\n    this.onBOL = void 0;\n    this.onBUOL = void 0;\n    this.name_ = name_;\n  } // onBecomeObservedListeners\n\n\n  var _proto = Atom.prototype;\n\n  _proto.onBO = function onBO() {\n    if (this.onBOL) {\n      this.onBOL.forEach(function (listener) {\n        return listener();\n      });\n    }\n  };\n\n  _proto.onBUO = function onBUO() {\n    if (this.onBUOL) {\n      this.onBUOL.forEach(function (listener) {\n        return listener();\n      });\n    }\n  }\n  /**\r\n   * Invoke this method to notify mobx that your atom has been used somehow.\r\n   * Returns true if there is currently a reactive context.\r\n   */\n  ;\n\n  _proto.reportObserved = function reportObserved$1() {\n    return reportObserved(this);\n  }\n  /**\r\n   * Invoke this method _after_ this method has changed to signal mobx that all its observers should invalidate.\r\n   */\n  ;\n\n  _proto.reportChanged = function reportChanged() {\n    startBatch();\n    propagateChanged(this);\n    endBatch();\n  };\n\n  _proto.toString = function toString() {\n    return this.name_;\n  };\n\n  return Atom;\n}();\nvar isAtom = /*#__PURE__*/createInstanceofPredicate(\"Atom\", Atom);\nfunction createAtom(name, onBecomeObservedHandler, onBecomeUnobservedHandler) {\n  if (onBecomeObservedHandler === void 0) {\n    onBecomeObservedHandler = noop;\n  }\n\n  if (onBecomeUnobservedHandler === void 0) {\n    onBecomeUnobservedHandler = noop;\n  }\n\n  var atom = new Atom(name); // default `noop` listener will not initialize the hook Set\n\n  if (onBecomeObservedHandler !== noop) {\n    onBecomeObserved(atom, onBecomeObservedHandler);\n  }\n\n  if (onBecomeUnobservedHandler !== noop) {\n    onBecomeUnobserved(atom, onBecomeUnobservedHandler);\n  }\n\n  return atom;\n}\n\nfunction identityComparer(a, b) {\n  return a === b;\n}\n\nfunction structuralComparer(a, b) {\n  return deepEqual(a, b);\n}\n\nfunction shallowComparer(a, b) {\n  return deepEqual(a, b, 1);\n}\n\nfunction defaultComparer(a, b) {\n  if (Object.is) {\n    return Object.is(a, b);\n  }\n\n  return a === b ? a !== 0 || 1 / a === 1 / b : a !== a && b !== b;\n}\n\nvar comparer = {\n  identity: identityComparer,\n  structural: structuralComparer,\n  \"default\": defaultComparer,\n  shallow: shallowComparer\n};\n\nfunction deepEnhancer(v, _, name) {\n  // it is an observable already, done\n  if (isObservable(v)) {\n    return v;\n  } // something that can be converted and mutated?\n\n\n  if (Array.isArray(v)) {\n    return observable.array(v, {\n      name: name\n    });\n  }\n\n  if (isPlainObject(v)) {\n    return observable.object(v, undefined, {\n      name: name\n    });\n  }\n\n  if (isES6Map(v)) {\n    return observable.map(v, {\n      name: name\n    });\n  }\n\n  if (isES6Set(v)) {\n    return observable.set(v, {\n      name: name\n    });\n  }\n\n  if (typeof v === \"function\" && !isAction(v) && !isFlow(v)) {\n    if (isGenerator(v)) {\n      return flow(v);\n    } else {\n      return autoAction(name, v);\n    }\n  }\n\n  return v;\n}\nfunction shallowEnhancer(v, _, name) {\n  if (v === undefined || v === null) {\n    return v;\n  }\n\n  if (isObservableObject(v) || isObservableArray(v) || isObservableMap(v) || isObservableSet(v)) {\n    return v;\n  }\n\n  if (Array.isArray(v)) {\n    return observable.array(v, {\n      name: name,\n      deep: false\n    });\n  }\n\n  if (isPlainObject(v)) {\n    return observable.object(v, undefined, {\n      name: name,\n      deep: false\n    });\n  }\n\n  if (isES6Map(v)) {\n    return observable.map(v, {\n      name: name,\n      deep: false\n    });\n  }\n\n  if (isES6Set(v)) {\n    return observable.set(v, {\n      name: name,\n      deep: false\n    });\n  }\n\n  if (process.env.NODE_ENV !== \"production\") {\n    die(\"The shallow modifier / decorator can only used in combination with arrays, objects, maps and sets\");\n  }\n}\nfunction referenceEnhancer(newValue) {\n  // never turn into an observable\n  return newValue;\n}\nfunction refStructEnhancer(v, oldValue) {\n  if (process.env.NODE_ENV !== \"production\" && isObservable(v)) {\n    die(\"observable.struct should not be used with observable values\");\n  }\n\n  if (deepEqual(v, oldValue)) {\n    return oldValue;\n  }\n\n  return v;\n}\n\nvar OVERRIDE = \"override\";\nvar override = /*#__PURE__*/createDecoratorAnnotation({\n  annotationType_: OVERRIDE,\n  make_: make_,\n  extend_: extend_\n});\nfunction isOverride(annotation) {\n  return annotation.annotationType_ === OVERRIDE;\n}\n\nfunction make_(adm, key) {\n  // Must not be plain object\n  if (process.env.NODE_ENV !== \"production\" && adm.isPlainObject_) {\n    die(\"Cannot apply '\" + this.annotationType_ + \"' to '\" + adm.name_ + \".\" + key.toString() + \"':\" + (\"\\n'\" + this.annotationType_ + \"' cannot be used on plain objects.\"));\n  } // Must override something\n\n\n  if (process.env.NODE_ENV !== \"production\" && !hasProp(adm.appliedAnnotations_, key)) {\n    die(\"'\" + adm.name_ + \".\" + key.toString() + \"' is annotated with '\" + this.annotationType_ + \"', \" + \"but no such annotated member was found on prototype.\");\n  }\n\n  return 0\n  /* Cancel */\n  ;\n}\n\nfunction extend_(adm, key, descriptor, proxyTrap) {\n  die(\"'\" + this.annotationType_ + \"' can only be used with 'makeObservable'\");\n}\n\nfunction createActionAnnotation(name, options) {\n  return {\n    annotationType_: name,\n    options_: options,\n    make_: make_$1,\n    extend_: extend_$1\n  };\n}\n\nfunction make_$1(adm, key, descriptor, source) {\n  var _this$options_;\n\n  // bound\n  if ((_this$options_ = this.options_) != null && _this$options_.bound) {\n    return this.extend_(adm, key, descriptor, false) === null ? 0\n    /* Cancel */\n    : 1\n    /* Break */\n    ;\n  } // own\n\n\n  if (source === adm.target_) {\n    return this.extend_(adm, key, descriptor, false) === null ? 0\n    /* Cancel */\n    : 2\n    /* Continue */\n    ;\n  } // prototype\n\n\n  if (isAction(descriptor.value)) {\n    // A prototype could have been annotated already by other constructor,\n    // rest of the proto chain must be annotated already\n    return 1\n    /* Break */\n    ;\n  }\n\n  var actionDescriptor = createActionDescriptor(adm, this, key, descriptor, false);\n  defineProperty(source, key, actionDescriptor);\n  return 2\n  /* Continue */\n  ;\n}\n\nfunction extend_$1(adm, key, descriptor, proxyTrap) {\n  var actionDescriptor = createActionDescriptor(adm, this, key, descriptor);\n  return adm.defineProperty_(key, actionDescriptor, proxyTrap);\n}\n\nfunction assertActionDescriptor(adm, _ref, key, _ref2) {\n  var annotationType_ = _ref.annotationType_;\n  var value = _ref2.value;\n\n  if (process.env.NODE_ENV !== \"production\" && !isFunction(value)) {\n    die(\"Cannot apply '\" + annotationType_ + \"' to '\" + adm.name_ + \".\" + key.toString() + \"':\" + (\"\\n'\" + annotationType_ + \"' can only be used on properties with a function value.\"));\n  }\n}\n\nfunction createActionDescriptor(adm, annotation, key, descriptor, // provides ability to disable safeDescriptors for prototypes\nsafeDescriptors) {\n  var _annotation$options_, _annotation$options_$, _annotation$options_2, _annotation$options_$2, _annotation$options_3, _annotation$options_4, _adm$proxy_2;\n\n  if (safeDescriptors === void 0) {\n    safeDescriptors = globalState.safeDescriptors;\n  }\n\n  assertActionDescriptor(adm, annotation, key, descriptor);\n  var value = descriptor.value;\n\n  if ((_annotation$options_ = annotation.options_) != null && _annotation$options_.bound) {\n    var _adm$proxy_;\n\n    value = value.bind((_adm$proxy_ = adm.proxy_) != null ? _adm$proxy_ : adm.target_);\n  }\n\n  return {\n    value: createAction((_annotation$options_$ = (_annotation$options_2 = annotation.options_) == null ? void 0 : _annotation$options_2.name) != null ? _annotation$options_$ : key.toString(), value, (_annotation$options_$2 = (_annotation$options_3 = annotation.options_) == null ? void 0 : _annotation$options_3.autoAction) != null ? _annotation$options_$2 : false, // https://github.com/mobxjs/mobx/discussions/3140\n    (_annotation$options_4 = annotation.options_) != null && _annotation$options_4.bound ? (_adm$proxy_2 = adm.proxy_) != null ? _adm$proxy_2 : adm.target_ : undefined),\n    // Non-configurable for classes\n    // prevents accidental field redefinition in subclass\n    configurable: safeDescriptors ? adm.isPlainObject_ : true,\n    // https://github.com/mobxjs/mobx/pull/2641#issuecomment-737292058\n    enumerable: false,\n    // Non-obsevable, therefore non-writable\n    // Also prevents rewriting in subclass constructor\n    writable: safeDescriptors ? false : true\n  };\n}\n\nfunction createFlowAnnotation(name, options) {\n  return {\n    annotationType_: name,\n    options_: options,\n    make_: make_$2,\n    extend_: extend_$2\n  };\n}\n\nfunction make_$2(adm, key, descriptor, source) {\n  var _this$options_;\n\n  // own\n  if (source === adm.target_) {\n    return this.extend_(adm, key, descriptor, false) === null ? 0\n    /* Cancel */\n    : 2\n    /* Continue */\n    ;\n  } // prototype\n  // bound - must annotate protos to support super.flow()\n\n\n  if ((_this$options_ = this.options_) != null && _this$options_.bound && (!hasProp(adm.target_, key) || !isFlow(adm.target_[key]))) {\n    if (this.extend_(adm, key, descriptor, false) === null) {\n      return 0\n      /* Cancel */\n      ;\n    }\n  }\n\n  if (isFlow(descriptor.value)) {\n    // A prototype could have been annotated already by other constructor,\n    // rest of the proto chain must be annotated already\n    return 1\n    /* Break */\n    ;\n  }\n\n  var flowDescriptor = createFlowDescriptor(adm, this, key, descriptor, false, false);\n  defineProperty(source, key, flowDescriptor);\n  return 2\n  /* Continue */\n  ;\n}\n\nfunction extend_$2(adm, key, descriptor, proxyTrap) {\n  var _this$options_2;\n\n  var flowDescriptor = createFlowDescriptor(adm, this, key, descriptor, (_this$options_2 = this.options_) == null ? void 0 : _this$options_2.bound);\n  return adm.defineProperty_(key, flowDescriptor, proxyTrap);\n}\n\nfunction assertFlowDescriptor(adm, _ref, key, _ref2) {\n  var annotationType_ = _ref.annotationType_;\n  var value = _ref2.value;\n\n  if (process.env.NODE_ENV !== \"production\" && !isFunction(value)) {\n    die(\"Cannot apply '\" + annotationType_ + \"' to '\" + adm.name_ + \".\" + key.toString() + \"':\" + (\"\\n'\" + annotationType_ + \"' can only be used on properties with a generator function value.\"));\n  }\n}\n\nfunction createFlowDescriptor(adm, annotation, key, descriptor, bound, // provides ability to disable safeDescriptors for prototypes\nsafeDescriptors) {\n  if (safeDescriptors === void 0) {\n    safeDescriptors = globalState.safeDescriptors;\n  }\n\n  assertFlowDescriptor(adm, annotation, key, descriptor);\n  var value = descriptor.value; // In case of flow.bound, the descriptor can be from already annotated prototype\n\n  if (!isFlow(value)) {\n    value = flow(value);\n  }\n\n  if (bound) {\n    var _adm$proxy_;\n\n    // We do not keep original function around, so we bind the existing flow\n    value = value.bind((_adm$proxy_ = adm.proxy_) != null ? _adm$proxy_ : adm.target_); // This is normally set by `flow`, but `bind` returns new function...\n\n    value.isMobXFlow = true;\n  }\n\n  return {\n    value: value,\n    // Non-configurable for classes\n    // prevents accidental field redefinition in subclass\n    configurable: safeDescriptors ? adm.isPlainObject_ : true,\n    // https://github.com/mobxjs/mobx/pull/2641#issuecomment-737292058\n    enumerable: false,\n    // Non-obsevable, therefore non-writable\n    // Also prevents rewriting in subclass constructor\n    writable: safeDescriptors ? false : true\n  };\n}\n\nfunction createComputedAnnotation(name, options) {\n  return {\n    annotationType_: name,\n    options_: options,\n    make_: make_$3,\n    extend_: extend_$3\n  };\n}\n\nfunction make_$3(adm, key, descriptor) {\n  return this.extend_(adm, key, descriptor, false) === null ? 0\n  /* Cancel */\n  : 1\n  /* Break */\n  ;\n}\n\nfunction extend_$3(adm, key, descriptor, proxyTrap) {\n  assertComputedDescriptor(adm, this, key, descriptor);\n  return adm.defineComputedProperty_(key, _extends({}, this.options_, {\n    get: descriptor.get,\n    set: descriptor.set\n  }), proxyTrap);\n}\n\nfunction assertComputedDescriptor(adm, _ref, key, _ref2) {\n  var annotationType_ = _ref.annotationType_;\n  var get = _ref2.get;\n\n  if (process.env.NODE_ENV !== \"production\" && !get) {\n    die(\"Cannot apply '\" + annotationType_ + \"' to '\" + adm.name_ + \".\" + key.toString() + \"':\" + (\"\\n'\" + annotationType_ + \"' can only be used on getter(+setter) properties.\"));\n  }\n}\n\nfunction createObservableAnnotation(name, options) {\n  return {\n    annotationType_: name,\n    options_: options,\n    make_: make_$4,\n    extend_: extend_$4\n  };\n}\n\nfunction make_$4(adm, key, descriptor) {\n  return this.extend_(adm, key, descriptor, false) === null ? 0\n  /* Cancel */\n  : 1\n  /* Break */\n  ;\n}\n\nfunction extend_$4(adm, key, descriptor, proxyTrap) {\n  var _this$options_$enhanc, _this$options_;\n\n  assertObservableDescriptor(adm, this, key, descriptor);\n  return adm.defineObservableProperty_(key, descriptor.value, (_this$options_$enhanc = (_this$options_ = this.options_) == null ? void 0 : _this$options_.enhancer) != null ? _this$options_$enhanc : deepEnhancer, proxyTrap);\n}\n\nfunction assertObservableDescriptor(adm, _ref, key, descriptor) {\n  var annotationType_ = _ref.annotationType_;\n\n  if (process.env.NODE_ENV !== \"production\" && !(\"value\" in descriptor)) {\n    die(\"Cannot apply '\" + annotationType_ + \"' to '\" + adm.name_ + \".\" + key.toString() + \"':\" + (\"\\n'\" + annotationType_ + \"' cannot be used on getter/setter properties\"));\n  }\n}\n\nvar AUTO = \"true\";\nvar autoAnnotation = /*#__PURE__*/createAutoAnnotation();\nfunction createAutoAnnotation(options) {\n  return {\n    annotationType_: AUTO,\n    options_: options,\n    make_: make_$5,\n    extend_: extend_$5\n  };\n}\n\nfunction make_$5(adm, key, descriptor, source) {\n  var _this$options_3, _this$options_4;\n\n  // getter -> computed\n  if (descriptor.get) {\n    return computed.make_(adm, key, descriptor, source);\n  } // lone setter -> action setter\n\n\n  if (descriptor.set) {\n    // TODO make action applicable to setter and delegate to action.make_\n    var set = createAction(key.toString(), descriptor.set); // own\n\n    if (source === adm.target_) {\n      return adm.defineProperty_(key, {\n        configurable: globalState.safeDescriptors ? adm.isPlainObject_ : true,\n        set: set\n      }) === null ? 0\n      /* Cancel */\n      : 2\n      /* Continue */\n      ;\n    } // proto\n\n\n    defineProperty(source, key, {\n      configurable: true,\n      set: set\n    });\n    return 2\n    /* Continue */\n    ;\n  } // function on proto -> autoAction/flow\n\n\n  if (source !== adm.target_ && typeof descriptor.value === \"function\") {\n    var _this$options_2;\n\n    if (isGenerator(descriptor.value)) {\n      var _this$options_;\n\n      var flowAnnotation = (_this$options_ = this.options_) != null && _this$options_.autoBind ? flow.bound : flow;\n      return flowAnnotation.make_(adm, key, descriptor, source);\n    }\n\n    var actionAnnotation = (_this$options_2 = this.options_) != null && _this$options_2.autoBind ? autoAction.bound : autoAction;\n    return actionAnnotation.make_(adm, key, descriptor, source);\n  } // other -> observable\n  // Copy props from proto as well, see test:\n  // \"decorate should work with Object.create\"\n\n\n  var observableAnnotation = ((_this$options_3 = this.options_) == null ? void 0 : _this$options_3.deep) === false ? observable.ref : observable; // if function respect autoBind option\n\n  if (typeof descriptor.value === \"function\" && (_this$options_4 = this.options_) != null && _this$options_4.autoBind) {\n    var _adm$proxy_;\n\n    descriptor.value = descriptor.value.bind((_adm$proxy_ = adm.proxy_) != null ? _adm$proxy_ : adm.target_);\n  }\n\n  return observableAnnotation.make_(adm, key, descriptor, source);\n}\n\nfunction extend_$5(adm, key, descriptor, proxyTrap) {\n  var _this$options_5, _this$options_6;\n\n  // getter -> computed\n  if (descriptor.get) {\n    return computed.extend_(adm, key, descriptor, proxyTrap);\n  } // lone setter -> action setter\n\n\n  if (descriptor.set) {\n    // TODO make action applicable to setter and delegate to action.extend_\n    return adm.defineProperty_(key, {\n      configurable: globalState.safeDescriptors ? adm.isPlainObject_ : true,\n      set: createAction(key.toString(), descriptor.set)\n    }, proxyTrap);\n  } // other -> observable\n  // if function respect autoBind option\n\n\n  if (typeof descriptor.value === \"function\" && (_this$options_5 = this.options_) != null && _this$options_5.autoBind) {\n    var _adm$proxy_2;\n\n    descriptor.value = descriptor.value.bind((_adm$proxy_2 = adm.proxy_) != null ? _adm$proxy_2 : adm.target_);\n  }\n\n  var observableAnnotation = ((_this$options_6 = this.options_) == null ? void 0 : _this$options_6.deep) === false ? observable.ref : observable;\n  return observableAnnotation.extend_(adm, key, descriptor, proxyTrap);\n}\n\nvar OBSERVABLE = \"observable\";\nvar OBSERVABLE_REF = \"observable.ref\";\nvar OBSERVABLE_SHALLOW = \"observable.shallow\";\nvar OBSERVABLE_STRUCT = \"observable.struct\"; // Predefined bags of create observable options, to avoid allocating temporarily option objects\n// in the majority of cases\n\nvar defaultCreateObservableOptions = {\n  deep: true,\n  name: undefined,\n  defaultDecorator: undefined,\n  proxy: true\n};\nObject.freeze(defaultCreateObservableOptions);\nfunction asCreateObservableOptions(thing) {\n  return thing || defaultCreateObservableOptions;\n}\nvar observableAnnotation = /*#__PURE__*/createObservableAnnotation(OBSERVABLE);\nvar observableRefAnnotation = /*#__PURE__*/createObservableAnnotation(OBSERVABLE_REF, {\n  enhancer: referenceEnhancer\n});\nvar observableShallowAnnotation = /*#__PURE__*/createObservableAnnotation(OBSERVABLE_SHALLOW, {\n  enhancer: shallowEnhancer\n});\nvar observableStructAnnotation = /*#__PURE__*/createObservableAnnotation(OBSERVABLE_STRUCT, {\n  enhancer: refStructEnhancer\n});\nvar observableDecoratorAnnotation = /*#__PURE__*/createDecoratorAnnotation(observableAnnotation);\nfunction getEnhancerFromOptions(options) {\n  return options.deep === true ? deepEnhancer : options.deep === false ? referenceEnhancer : getEnhancerFromAnnotation(options.defaultDecorator);\n}\nfunction getAnnotationFromOptions(options) {\n  var _options$defaultDecor;\n\n  return options ? (_options$defaultDecor = options.defaultDecorator) != null ? _options$defaultDecor : createAutoAnnotation(options) : undefined;\n}\nfunction getEnhancerFromAnnotation(annotation) {\n  var _annotation$options_$, _annotation$options_;\n\n  return !annotation ? deepEnhancer : (_annotation$options_$ = (_annotation$options_ = annotation.options_) == null ? void 0 : _annotation$options_.enhancer) != null ? _annotation$options_$ : deepEnhancer;\n}\n/**\r\n * Turns an object, array or function into a reactive structure.\r\n * @param v the value which should become observable.\r\n */\n\nfunction createObservable(v, arg2, arg3) {\n  // @observable someProp;\n  if (isStringish(arg2)) {\n    storeAnnotation(v, arg2, observableAnnotation);\n    return;\n  } // already observable - ignore\n\n\n  if (isObservable(v)) {\n    return v;\n  } // plain object\n\n\n  if (isPlainObject(v)) {\n    return observable.object(v, arg2, arg3);\n  } // Array\n\n\n  if (Array.isArray(v)) {\n    return observable.array(v, arg2);\n  } // Map\n\n\n  if (isES6Map(v)) {\n    return observable.map(v, arg2);\n  } // Set\n\n\n  if (isES6Set(v)) {\n    return observable.set(v, arg2);\n  } // other object - ignore\n\n\n  if (typeof v === \"object\" && v !== null) {\n    return v;\n  } // anything else\n\n\n  return observable.box(v, arg2);\n}\n\nObject.assign(createObservable, observableDecoratorAnnotation);\nvar observableFactories = {\n  box: function box(value, options) {\n    var o = asCreateObservableOptions(options);\n    return new ObservableValue(value, getEnhancerFromOptions(o), o.name, true, o.equals);\n  },\n  array: function array(initialValues, options) {\n    var o = asCreateObservableOptions(options);\n    return (globalState.useProxies === false || o.proxy === false ? createLegacyArray : createObservableArray)(initialValues, getEnhancerFromOptions(o), o.name);\n  },\n  map: function map(initialValues, options) {\n    var o = asCreateObservableOptions(options);\n    return new ObservableMap(initialValues, getEnhancerFromOptions(o), o.name);\n  },\n  set: function set(initialValues, options) {\n    var o = asCreateObservableOptions(options);\n    return new ObservableSet(initialValues, getEnhancerFromOptions(o), o.name);\n  },\n  object: function object(props, decorators, options) {\n    return extendObservable(globalState.useProxies === false || (options == null ? void 0 : options.proxy) === false ? asObservableObject({}, options) : asDynamicObservableObject({}, options), props, decorators);\n  },\n  ref: /*#__PURE__*/createDecoratorAnnotation(observableRefAnnotation),\n  shallow: /*#__PURE__*/createDecoratorAnnotation(observableShallowAnnotation),\n  deep: observableDecoratorAnnotation,\n  struct: /*#__PURE__*/createDecoratorAnnotation(observableStructAnnotation)\n}; // eslint-disable-next-line\n\nvar observable = /*#__PURE__*/assign(createObservable, observableFactories);\n\nvar COMPUTED = \"computed\";\nvar COMPUTED_STRUCT = \"computed.struct\";\nvar computedAnnotation = /*#__PURE__*/createComputedAnnotation(COMPUTED);\nvar computedStructAnnotation = /*#__PURE__*/createComputedAnnotation(COMPUTED_STRUCT, {\n  equals: comparer.structural\n});\n/**\r\n * Decorator for class properties: @computed get value() { return expr; }.\r\n * For legacy purposes also invokable as ES5 observable created: `computed(() => expr)`;\r\n */\n\nvar computed = function computed(arg1, arg2) {\n  if (isStringish(arg2)) {\n    // @computed\n    return storeAnnotation(arg1, arg2, computedAnnotation);\n  }\n\n  if (isPlainObject(arg1)) {\n    // @computed({ options })\n    return createDecoratorAnnotation(createComputedAnnotation(COMPUTED, arg1));\n  } // computed(expr, options?)\n\n\n  if (process.env.NODE_ENV !== \"production\") {\n    if (!isFunction(arg1)) {\n      die(\"First argument to `computed` should be an expression.\");\n    }\n\n    if (isFunction(arg2)) {\n      die(\"A setter as second argument is no longer supported, use `{ set: fn }` option instead\");\n    }\n  }\n\n  var opts = isPlainObject(arg2) ? arg2 : {};\n  opts.get = arg1;\n  opts.name || (opts.name = arg1.name || \"\");\n  /* for generated name */\n\n  return new ComputedValue(opts);\n};\nObject.assign(computed, computedAnnotation);\ncomputed.struct = /*#__PURE__*/createDecoratorAnnotation(computedStructAnnotation);\n\nvar _getDescriptor$config, _getDescriptor;\n// mobx versions\n\nvar currentActionId = 0;\nvar nextActionId = 1;\nvar isFunctionNameConfigurable = (_getDescriptor$config = (_getDescriptor = /*#__PURE__*/getDescriptor(function () {}, \"name\")) == null ? void 0 : _getDescriptor.configurable) != null ? _getDescriptor$config : false; // we can safely recycle this object\n\nvar tmpNameDescriptor = {\n  value: \"action\",\n  configurable: true,\n  writable: false,\n  enumerable: false\n};\nfunction createAction(actionName, fn, autoAction, ref) {\n  if (autoAction === void 0) {\n    autoAction = false;\n  }\n\n  if (process.env.NODE_ENV !== \"production\") {\n    if (!isFunction(fn)) {\n      die(\"`action` can only be invoked on functions\");\n    }\n\n    if (typeof actionName !== \"string\" || !actionName) {\n      die(\"actions should have valid names, got: '\" + actionName + \"'\");\n    }\n  }\n\n  function res() {\n    return executeAction(actionName, autoAction, fn, ref || this, arguments);\n  }\n\n  res.isMobxAction = true;\n\n  if (isFunctionNameConfigurable) {\n    tmpNameDescriptor.value = actionName;\n    Object.defineProperty(res, \"name\", tmpNameDescriptor);\n  }\n\n  return res;\n}\nfunction executeAction(actionName, canRunAsDerivation, fn, scope, args) {\n  var runInfo = _startAction(actionName, canRunAsDerivation, scope, args);\n\n  try {\n    return fn.apply(scope, args);\n  } catch (err) {\n    runInfo.error_ = err;\n    throw err;\n  } finally {\n    _endAction(runInfo);\n  }\n}\nfunction _startAction(actionName, canRunAsDerivation, // true for autoAction\nscope, args) {\n  var notifySpy_ = process.env.NODE_ENV !== \"production\" && isSpyEnabled() && !!actionName;\n  var startTime_ = 0;\n\n  if (process.env.NODE_ENV !== \"production\" && notifySpy_) {\n    startTime_ = Date.now();\n    var flattenedArgs = args ? Array.from(args) : EMPTY_ARRAY;\n    spyReportStart({\n      type: ACTION,\n      name: actionName,\n      object: scope,\n      arguments: flattenedArgs\n    });\n  }\n\n  var prevDerivation_ = globalState.trackingDerivation;\n  var runAsAction = !canRunAsDerivation || !prevDerivation_;\n  startBatch();\n  var prevAllowStateChanges_ = globalState.allowStateChanges; // by default preserve previous allow\n\n  if (runAsAction) {\n    untrackedStart();\n    prevAllowStateChanges_ = allowStateChangesStart(true);\n  }\n\n  var prevAllowStateReads_ = allowStateReadsStart(true);\n  var runInfo = {\n    runAsAction_: runAsAction,\n    prevDerivation_: prevDerivation_,\n    prevAllowStateChanges_: prevAllowStateChanges_,\n    prevAllowStateReads_: prevAllowStateReads_,\n    notifySpy_: notifySpy_,\n    startTime_: startTime_,\n    actionId_: nextActionId++,\n    parentActionId_: currentActionId\n  };\n  currentActionId = runInfo.actionId_;\n  return runInfo;\n}\nfunction _endAction(runInfo) {\n  if (currentActionId !== runInfo.actionId_) {\n    die(30);\n  }\n\n  currentActionId = runInfo.parentActionId_;\n\n  if (runInfo.error_ !== undefined) {\n    globalState.suppressReactionErrors = true;\n  }\n\n  allowStateChangesEnd(runInfo.prevAllowStateChanges_);\n  allowStateReadsEnd(runInfo.prevAllowStateReads_);\n  endBatch();\n\n  if (runInfo.runAsAction_) {\n    untrackedEnd(runInfo.prevDerivation_);\n  }\n\n  if (process.env.NODE_ENV !== \"production\" && runInfo.notifySpy_) {\n    spyReportEnd({\n      time: Date.now() - runInfo.startTime_\n    });\n  }\n\n  globalState.suppressReactionErrors = false;\n}\nfunction allowStateChanges(allowStateChanges, func) {\n  var prev = allowStateChangesStart(allowStateChanges);\n\n  try {\n    return func();\n  } finally {\n    allowStateChangesEnd(prev);\n  }\n}\nfunction allowStateChangesStart(allowStateChanges) {\n  var prev = globalState.allowStateChanges;\n  globalState.allowStateChanges = allowStateChanges;\n  return prev;\n}\nfunction allowStateChangesEnd(prev) {\n  globalState.allowStateChanges = prev;\n}\n\nvar _Symbol$toPrimitive;\nvar CREATE = \"create\";\n_Symbol$toPrimitive = Symbol.toPrimitive;\nvar ObservableValue = /*#__PURE__*/function (_Atom) {\n  _inheritsLoose(ObservableValue, _Atom);\n\n  function ObservableValue(value, enhancer, name_, notifySpy, equals) {\n    var _this;\n\n    if (name_ === void 0) {\n      name_ = process.env.NODE_ENV !== \"production\" ? \"ObservableValue@\" + getNextId() : \"ObservableValue\";\n    }\n\n    if (notifySpy === void 0) {\n      notifySpy = true;\n    }\n\n    if (equals === void 0) {\n      equals = comparer[\"default\"];\n    }\n\n    _this = _Atom.call(this, name_) || this;\n    _this.enhancer = void 0;\n    _this.name_ = void 0;\n    _this.equals = void 0;\n    _this.hasUnreportedChange_ = false;\n    _this.interceptors_ = void 0;\n    _this.changeListeners_ = void 0;\n    _this.value_ = void 0;\n    _this.dehancer = void 0;\n    _this.enhancer = enhancer;\n    _this.name_ = name_;\n    _this.equals = equals;\n    _this.value_ = enhancer(value, undefined, name_);\n\n    if (process.env.NODE_ENV !== \"production\" && notifySpy && isSpyEnabled()) {\n      // only notify spy if this is a stand-alone observable\n      spyReport({\n        type: CREATE,\n        object: _assertThisInitialized(_this),\n        observableKind: \"value\",\n        debugObjectName: _this.name_,\n        newValue: \"\" + _this.value_\n      });\n    }\n\n    return _this;\n  }\n\n  var _proto = ObservableValue.prototype;\n\n  _proto.dehanceValue = function dehanceValue(value) {\n    if (this.dehancer !== undefined) {\n      return this.dehancer(value);\n    }\n\n    return value;\n  };\n\n  _proto.set = function set(newValue) {\n    var oldValue = this.value_;\n    newValue = this.prepareNewValue_(newValue);\n\n    if (newValue !== globalState.UNCHANGED) {\n      var notifySpy = isSpyEnabled();\n\n      if (process.env.NODE_ENV !== \"production\" && notifySpy) {\n        spyReportStart({\n          type: UPDATE,\n          object: this,\n          observableKind: \"value\",\n          debugObjectName: this.name_,\n          newValue: newValue,\n          oldValue: oldValue\n        });\n      }\n\n      this.setNewValue_(newValue);\n\n      if (process.env.NODE_ENV !== \"production\" && notifySpy) {\n        spyReportEnd();\n      }\n    }\n  };\n\n  _proto.prepareNewValue_ = function prepareNewValue_(newValue) {\n    checkIfStateModificationsAreAllowed(this);\n\n    if (hasInterceptors(this)) {\n      var change = interceptChange(this, {\n        object: this,\n        type: UPDATE,\n        newValue: newValue\n      });\n\n      if (!change) {\n        return globalState.UNCHANGED;\n      }\n\n      newValue = change.newValue;\n    } // apply modifier\n\n\n    newValue = this.enhancer(newValue, this.value_, this.name_);\n    return this.equals(this.value_, newValue) ? globalState.UNCHANGED : newValue;\n  };\n\n  _proto.setNewValue_ = function setNewValue_(newValue) {\n    var oldValue = this.value_;\n    this.value_ = newValue;\n    this.reportChanged();\n\n    if (hasListeners(this)) {\n      notifyListeners(this, {\n        type: UPDATE,\n        object: this,\n        newValue: newValue,\n        oldValue: oldValue\n      });\n    }\n  };\n\n  _proto.get = function get() {\n    this.reportObserved();\n    return this.dehanceValue(this.value_);\n  };\n\n  _proto.intercept_ = function intercept_(handler) {\n    return registerInterceptor(this, handler);\n  };\n\n  _proto.observe_ = function observe_(listener, fireImmediately) {\n    if (fireImmediately) {\n      listener({\n        observableKind: \"value\",\n        debugObjectName: this.name_,\n        object: this,\n        type: UPDATE,\n        newValue: this.value_,\n        oldValue: undefined\n      });\n    }\n\n    return registerListener(this, listener);\n  };\n\n  _proto.raw = function raw() {\n    // used by MST ot get undehanced value\n    return this.value_;\n  };\n\n  _proto.toJSON = function toJSON() {\n    return this.get();\n  };\n\n  _proto.toString = function toString() {\n    return this.name_ + \"[\" + this.value_ + \"]\";\n  };\n\n  _proto.valueOf = function valueOf() {\n    return toPrimitive(this.get());\n  };\n\n  _proto[_Symbol$toPrimitive] = function () {\n    return this.valueOf();\n  };\n\n  return ObservableValue;\n}(Atom);\nvar isObservableValue = /*#__PURE__*/createInstanceofPredicate(\"ObservableValue\", ObservableValue);\n\nvar _Symbol$toPrimitive$1;\n/**\r\n * A node in the state dependency root that observes other nodes, and can be observed itself.\r\n *\r\n * ComputedValue will remember the result of the computation for the duration of the batch, or\r\n * while being observed.\r\n *\r\n * During this time it will recompute only when one of its direct dependencies changed,\r\n * but only when it is being accessed with `ComputedValue.get()`.\r\n *\r\n * Implementation description:\r\n * 1. First time it's being accessed it will compute and remember result\r\n *    give back remembered result until 2. happens\r\n * 2. First time any deep dependency change, propagate POSSIBLY_STALE to all observers, wait for 3.\r\n * 3. When it's being accessed, recompute if any shallow dependency changed.\r\n *    if result changed: propagate STALE to all observers, that were POSSIBLY_STALE from the last step.\r\n *    go to step 2. either way\r\n *\r\n * If at any point it's outside batch and it isn't observed: reset everything and go to 1.\r\n */\n\n_Symbol$toPrimitive$1 = Symbol.toPrimitive;\nvar ComputedValue = /*#__PURE__*/function () {\n  // nodes we are looking at. Our value depends on these nodes\n  // during tracking it's an array with new observed observers\n  // to check for cycles\n  // N.B: unminified as it is used by MST\n\n  /**\r\n   * Create a new computed value based on a function expression.\r\n   *\r\n   * The `name` property is for debug purposes only.\r\n   *\r\n   * The `equals` property specifies the comparer function to use to determine if a newly produced\r\n   * value differs from the previous value. Two comparers are provided in the library; `defaultComparer`\r\n   * compares based on identity comparison (===), and `structuralComparer` deeply compares the structure.\r\n   * Structural comparison can be convenient if you always produce a new aggregated object and\r\n   * don't want to notify observers if it is structurally the same.\r\n   * This is useful for working with vectors, mouse coordinates etc.\r\n   */\n  function ComputedValue(options) {\n    this.dependenciesState_ = IDerivationState_.NOT_TRACKING_;\n    this.observing_ = [];\n    this.newObserving_ = null;\n    this.isBeingObserved_ = false;\n    this.isPendingUnobservation_ = false;\n    this.observers_ = new Set();\n    this.diffValue_ = 0;\n    this.runId_ = 0;\n    this.lastAccessedBy_ = 0;\n    this.lowestObserverState_ = IDerivationState_.UP_TO_DATE_;\n    this.unboundDepsCount_ = 0;\n    this.value_ = new CaughtException(null);\n    this.name_ = void 0;\n    this.triggeredBy_ = void 0;\n    this.isComputing_ = false;\n    this.isRunningSetter_ = false;\n    this.derivation = void 0;\n    this.setter_ = void 0;\n    this.isTracing_ = TraceMode.NONE;\n    this.scope_ = void 0;\n    this.equals_ = void 0;\n    this.requiresReaction_ = void 0;\n    this.keepAlive_ = void 0;\n    this.onBOL = void 0;\n    this.onBUOL = void 0;\n\n    if (!options.get) {\n      die(31);\n    }\n\n    this.derivation = options.get;\n    this.name_ = options.name || (process.env.NODE_ENV !== \"production\" ? \"ComputedValue@\" + getNextId() : \"ComputedValue\");\n\n    if (options.set) {\n      this.setter_ = createAction(process.env.NODE_ENV !== \"production\" ? this.name_ + \"-setter\" : \"ComputedValue-setter\", options.set);\n    }\n\n    this.equals_ = options.equals || (options.compareStructural || options.struct ? comparer.structural : comparer[\"default\"]);\n    this.scope_ = options.context;\n    this.requiresReaction_ = options.requiresReaction;\n    this.keepAlive_ = !!options.keepAlive;\n  }\n\n  var _proto = ComputedValue.prototype;\n\n  _proto.onBecomeStale_ = function onBecomeStale_() {\n    propagateMaybeChanged(this);\n  };\n\n  _proto.onBO = function onBO() {\n    if (this.onBOL) {\n      this.onBOL.forEach(function (listener) {\n        return listener();\n      });\n    }\n  };\n\n  _proto.onBUO = function onBUO() {\n    if (this.onBUOL) {\n      this.onBUOL.forEach(function (listener) {\n        return listener();\n      });\n    }\n  }\n  /**\r\n   * Returns the current value of this computed value.\r\n   * Will evaluate its computation first if needed.\r\n   */\n  ;\n\n  _proto.get = function get() {\n    if (this.isComputing_) {\n      die(32, this.name_, this.derivation);\n    }\n\n    if (globalState.inBatch === 0 && // !globalState.trackingDerivatpion &&\n    this.observers_.size === 0 && !this.keepAlive_) {\n      if (shouldCompute(this)) {\n        this.warnAboutUntrackedRead_();\n        startBatch(); // See perf test 'computed memoization'\n\n        this.value_ = this.computeValue_(false);\n        endBatch();\n      }\n    } else {\n      reportObserved(this);\n\n      if (shouldCompute(this)) {\n        var prevTrackingContext = globalState.trackingContext;\n\n        if (this.keepAlive_ && !prevTrackingContext) {\n          globalState.trackingContext = this;\n        }\n\n        if (this.trackAndCompute()) {\n          propagateChangeConfirmed(this);\n        }\n\n        globalState.trackingContext = prevTrackingContext;\n      }\n    }\n\n    var result = this.value_;\n\n    if (isCaughtException(result)) {\n      throw result.cause;\n    }\n\n    return result;\n  };\n\n  _proto.set = function set(value) {\n    if (this.setter_) {\n      if (this.isRunningSetter_) {\n        die(33, this.name_);\n      }\n\n      this.isRunningSetter_ = true;\n\n      try {\n        this.setter_.call(this.scope_, value);\n      } finally {\n        this.isRunningSetter_ = false;\n      }\n    } else {\n      die(34, this.name_);\n    }\n  };\n\n  _proto.trackAndCompute = function trackAndCompute() {\n    // N.B: unminified as it is used by MST\n    var oldValue = this.value_;\n    var wasSuspended =\n    /* see #1208 */\n    this.dependenciesState_ === IDerivationState_.NOT_TRACKING_;\n    var newValue = this.computeValue_(true);\n    var changed = wasSuspended || isCaughtException(oldValue) || isCaughtException(newValue) || !this.equals_(oldValue, newValue);\n\n    if (changed) {\n      this.value_ = newValue;\n\n      if (process.env.NODE_ENV !== \"production\" && isSpyEnabled()) {\n        spyReport({\n          observableKind: \"computed\",\n          debugObjectName: this.name_,\n          object: this.scope_,\n          type: \"update\",\n          oldValue: oldValue,\n          newValue: newValue\n        });\n      }\n    }\n\n    return changed;\n  };\n\n  _proto.computeValue_ = function computeValue_(track) {\n    this.isComputing_ = true; // don't allow state changes during computation\n\n    var prev = allowStateChangesStart(false);\n    var res;\n\n    if (track) {\n      res = trackDerivedFunction(this, this.derivation, this.scope_);\n    } else {\n      if (globalState.disableErrorBoundaries === true) {\n        res = this.derivation.call(this.scope_);\n      } else {\n        try {\n          res = this.derivation.call(this.scope_);\n        } catch (e) {\n          res = new CaughtException(e);\n        }\n      }\n    }\n\n    allowStateChangesEnd(prev);\n    this.isComputing_ = false;\n    return res;\n  };\n\n  _proto.suspend_ = function suspend_() {\n    if (!this.keepAlive_) {\n      clearObserving(this);\n      this.value_ = undefined; // don't hold on to computed value!\n\n      if (process.env.NODE_ENV !== \"production\" && this.isTracing_ !== TraceMode.NONE) {\n        console.log(\"[mobx.trace] Computed value '\" + this.name_ + \"' was suspended and it will recompute on the next access.\");\n      }\n    }\n  };\n\n  _proto.observe_ = function observe_(listener, fireImmediately) {\n    var _this = this;\n\n    var firstTime = true;\n    var prevValue = undefined;\n    return autorun(function () {\n      // TODO: why is this in a different place than the spyReport() function? in all other observables it's called in the same place\n      var newValue = _this.get();\n\n      if (!firstTime || fireImmediately) {\n        var prevU = untrackedStart();\n        listener({\n          observableKind: \"computed\",\n          debugObjectName: _this.name_,\n          type: UPDATE,\n          object: _this,\n          newValue: newValue,\n          oldValue: prevValue\n        });\n        untrackedEnd(prevU);\n      }\n\n      firstTime = false;\n      prevValue = newValue;\n    });\n  };\n\n  _proto.warnAboutUntrackedRead_ = function warnAboutUntrackedRead_() {\n    if (!(process.env.NODE_ENV !== \"production\")) {\n      return;\n    }\n\n    if (this.isTracing_ !== TraceMode.NONE) {\n      console.log(\"[mobx.trace] Computed value '\" + this.name_ + \"' is being read outside a reactive context. Doing a full recompute.\");\n    }\n\n    if (typeof this.requiresReaction_ === \"boolean\" ? this.requiresReaction_ : globalState.computedRequiresReaction) {\n      console.warn(\"[mobx] Computed value '\" + this.name_ + \"' is being read outside a reactive context. Doing a full recompute.\");\n    }\n  };\n\n  _proto.toString = function toString() {\n    return this.name_ + \"[\" + this.derivation.toString() + \"]\";\n  };\n\n  _proto.valueOf = function valueOf() {\n    return toPrimitive(this.get());\n  };\n\n  _proto[_Symbol$toPrimitive$1] = function () {\n    return this.valueOf();\n  };\n\n  return ComputedValue;\n}();\nvar isComputedValue = /*#__PURE__*/createInstanceofPredicate(\"ComputedValue\", ComputedValue);\n\nvar IDerivationState_;\n\n(function (IDerivationState_) {\n  // before being run or (outside batch and not being observed)\n  // at this point derivation is not holding any data about dependency tree\n  IDerivationState_[IDerivationState_[\"NOT_TRACKING_\"] = -1] = \"NOT_TRACKING_\"; // no shallow dependency changed since last computation\n  // won't recalculate derivation\n  // this is what makes mobx fast\n\n  IDerivationState_[IDerivationState_[\"UP_TO_DATE_\"] = 0] = \"UP_TO_DATE_\"; // some deep dependency changed, but don't know if shallow dependency changed\n  // will require to check first if UP_TO_DATE or POSSIBLY_STALE\n  // currently only ComputedValue will propagate POSSIBLY_STALE\n  //\n  // having this state is second big optimization:\n  // don't have to recompute on every dependency change, but only when it's needed\n\n  IDerivationState_[IDerivationState_[\"POSSIBLY_STALE_\"] = 1] = \"POSSIBLY_STALE_\"; // A shallow dependency has changed since last computation and the derivation\n  // will need to recompute when it's needed next.\n\n  IDerivationState_[IDerivationState_[\"STALE_\"] = 2] = \"STALE_\";\n})(IDerivationState_ || (IDerivationState_ = {}));\n\nvar TraceMode;\n\n(function (TraceMode) {\n  TraceMode[TraceMode[\"NONE\"] = 0] = \"NONE\";\n  TraceMode[TraceMode[\"LOG\"] = 1] = \"LOG\";\n  TraceMode[TraceMode[\"BREAK\"] = 2] = \"BREAK\";\n})(TraceMode || (TraceMode = {}));\n\nvar CaughtException = function CaughtException(cause) {\n  this.cause = void 0;\n  this.cause = cause; // Empty\n};\nfunction isCaughtException(e) {\n  return e instanceof CaughtException;\n}\n/**\r\n * Finds out whether any dependency of the derivation has actually changed.\r\n * If dependenciesState is 1 then it will recalculate dependencies,\r\n * if any dependency changed it will propagate it by changing dependenciesState to 2.\r\n *\r\n * By iterating over the dependencies in the same order that they were reported and\r\n * stopping on the first change, all the recalculations are only called for ComputedValues\r\n * that will be tracked by derivation. That is because we assume that if the first x\r\n * dependencies of the derivation doesn't change then the derivation should run the same way\r\n * up until accessing x-th dependency.\r\n */\n\nfunction shouldCompute(derivation) {\n  switch (derivation.dependenciesState_) {\n    case IDerivationState_.UP_TO_DATE_:\n      return false;\n\n    case IDerivationState_.NOT_TRACKING_:\n    case IDerivationState_.STALE_:\n      return true;\n\n    case IDerivationState_.POSSIBLY_STALE_:\n      {\n        // state propagation can occur outside of action/reactive context #2195\n        var prevAllowStateReads = allowStateReadsStart(true);\n        var prevUntracked = untrackedStart(); // no need for those computeds to be reported, they will be picked up in trackDerivedFunction.\n\n        var obs = derivation.observing_,\n            l = obs.length;\n\n        for (var i = 0; i < l; i++) {\n          var obj = obs[i];\n\n          if (isComputedValue(obj)) {\n            if (globalState.disableErrorBoundaries) {\n              obj.get();\n            } else {\n              try {\n                obj.get();\n              } catch (e) {\n                // we are not interested in the value *or* exception at this moment, but if there is one, notify all\n                untrackedEnd(prevUntracked);\n                allowStateReadsEnd(prevAllowStateReads);\n                return true;\n              }\n            } // if ComputedValue `obj` actually changed it will be computed and propagated to its observers.\n            // and `derivation` is an observer of `obj`\n            // invariantShouldCompute(derivation)\n\n\n            if (derivation.dependenciesState_ === IDerivationState_.STALE_) {\n              untrackedEnd(prevUntracked);\n              allowStateReadsEnd(prevAllowStateReads);\n              return true;\n            }\n          }\n        }\n\n        changeDependenciesStateTo0(derivation);\n        untrackedEnd(prevUntracked);\n        allowStateReadsEnd(prevAllowStateReads);\n        return false;\n      }\n  }\n}\nfunction isComputingDerivation() {\n  return globalState.trackingDerivation !== null; // filter out actions inside computations\n}\nfunction checkIfStateModificationsAreAllowed(atom) {\n  if (!(process.env.NODE_ENV !== \"production\")) {\n    return;\n  }\n\n  var hasObservers = atom.observers_.size > 0; // Should not be possible to change observed state outside strict mode, except during initialization, see #563\n\n  if (!globalState.allowStateChanges && (hasObservers || globalState.enforceActions === \"always\")) {\n    console.warn(\"[MobX] \" + (globalState.enforceActions ? \"Since strict-mode is enabled, changing (observed) observable values without using an action is not allowed. Tried to modify: \" : \"Side effects like changing state are not allowed at this point. Are you trying to modify state from, for example, a computed value or the render function of a React component? You can wrap side effects in 'runInAction' (or decorate functions with 'action') if needed. Tried to modify: \") + atom.name_);\n  }\n}\nfunction checkIfStateReadsAreAllowed(observable) {\n  if (process.env.NODE_ENV !== \"production\" && !globalState.allowStateReads && globalState.observableRequiresReaction) {\n    console.warn(\"[mobx] Observable '\" + observable.name_ + \"' being read outside a reactive context.\");\n  }\n}\n/**\r\n * Executes the provided function `f` and tracks which observables are being accessed.\r\n * The tracking information is stored on the `derivation` object and the derivation is registered\r\n * as observer of any of the accessed observables.\r\n */\n\nfunction trackDerivedFunction(derivation, f, context) {\n  var prevAllowStateReads = allowStateReadsStart(true); // pre allocate array allocation + room for variation in deps\n  // array will be trimmed by bindDependencies\n\n  changeDependenciesStateTo0(derivation);\n  derivation.newObserving_ = new Array(derivation.observing_.length + 100);\n  derivation.unboundDepsCount_ = 0;\n  derivation.runId_ = ++globalState.runId;\n  var prevTracking = globalState.trackingDerivation;\n  globalState.trackingDerivation = derivation;\n  globalState.inBatch++;\n  var result;\n\n  if (globalState.disableErrorBoundaries === true) {\n    result = f.call(context);\n  } else {\n    try {\n      result = f.call(context);\n    } catch (e) {\n      result = new CaughtException(e);\n    }\n  }\n\n  globalState.inBatch--;\n  globalState.trackingDerivation = prevTracking;\n  bindDependencies(derivation);\n  warnAboutDerivationWithoutDependencies(derivation);\n  allowStateReadsEnd(prevAllowStateReads);\n  return result;\n}\n\nfunction warnAboutDerivationWithoutDependencies(derivation) {\n  if (!(process.env.NODE_ENV !== \"production\")) {\n    return;\n  }\n\n  if (derivation.observing_.length !== 0) {\n    return;\n  }\n\n  if (typeof derivation.requiresObservable_ === \"boolean\" ? derivation.requiresObservable_ : globalState.reactionRequiresObservable) {\n    console.warn(\"[mobx] Derivation '\" + derivation.name_ + \"' is created/updated without reading any observable value.\");\n  }\n}\n/**\r\n * diffs newObserving with observing.\r\n * update observing to be newObserving with unique observables\r\n * notify observers that become observed/unobserved\r\n */\n\n\nfunction bindDependencies(derivation) {\n  // invariant(derivation.dependenciesState !== IDerivationState.NOT_TRACKING, \"INTERNAL ERROR bindDependencies expects derivation.dependenciesState !== -1\");\n  var prevObserving = derivation.observing_;\n  var observing = derivation.observing_ = derivation.newObserving_;\n  var lowestNewObservingDerivationState = IDerivationState_.UP_TO_DATE_; // Go through all new observables and check diffValue: (this list can contain duplicates):\n  //   0: first occurrence, change to 1 and keep it\n  //   1: extra occurrence, drop it\n\n  var i0 = 0,\n      l = derivation.unboundDepsCount_;\n\n  for (var i = 0; i < l; i++) {\n    var dep = observing[i];\n\n    if (dep.diffValue_ === 0) {\n      dep.diffValue_ = 1;\n\n      if (i0 !== i) {\n        observing[i0] = dep;\n      }\n\n      i0++;\n    } // Upcast is 'safe' here, because if dep is IObservable, `dependenciesState` will be undefined,\n    // not hitting the condition\n\n\n    if (dep.dependenciesState_ > lowestNewObservingDerivationState) {\n      lowestNewObservingDerivationState = dep.dependenciesState_;\n    }\n  }\n\n  observing.length = i0;\n  derivation.newObserving_ = null; // newObserving shouldn't be needed outside tracking (statement moved down to work around FF bug, see #614)\n  // Go through all old observables and check diffValue: (it is unique after last bindDependencies)\n  //   0: it's not in new observables, unobserve it\n  //   1: it keeps being observed, don't want to notify it. change to 0\n\n  l = prevObserving.length;\n\n  while (l--) {\n    var _dep = prevObserving[l];\n\n    if (_dep.diffValue_ === 0) {\n      removeObserver(_dep, derivation);\n    }\n\n    _dep.diffValue_ = 0;\n  } // Go through all new observables and check diffValue: (now it should be unique)\n  //   0: it was set to 0 in last loop. don't need to do anything.\n  //   1: it wasn't observed, let's observe it. set back to 0\n\n\n  while (i0--) {\n    var _dep2 = observing[i0];\n\n    if (_dep2.diffValue_ === 1) {\n      _dep2.diffValue_ = 0;\n      addObserver(_dep2, derivation);\n    }\n  } // Some new observed derivations may become stale during this derivation computation\n  // so they have had no chance to propagate staleness (#916)\n\n\n  if (lowestNewObservingDerivationState !== IDerivationState_.UP_TO_DATE_) {\n    derivation.dependenciesState_ = lowestNewObservingDerivationState;\n    derivation.onBecomeStale_();\n  }\n}\n\nfunction clearObserving(derivation) {\n  // invariant(globalState.inBatch > 0, \"INTERNAL ERROR clearObserving should be called only inside batch\");\n  var obs = derivation.observing_;\n  derivation.observing_ = [];\n  var i = obs.length;\n\n  while (i--) {\n    removeObserver(obs[i], derivation);\n  }\n\n  derivation.dependenciesState_ = IDerivationState_.NOT_TRACKING_;\n}\nfunction untracked(action) {\n  var prev = untrackedStart();\n\n  try {\n    return action();\n  } finally {\n    untrackedEnd(prev);\n  }\n}\nfunction untrackedStart() {\n  var prev = globalState.trackingDerivation;\n  globalState.trackingDerivation = null;\n  return prev;\n}\nfunction untrackedEnd(prev) {\n  globalState.trackingDerivation = prev;\n}\nfunction allowStateReadsStart(allowStateReads) {\n  var prev = globalState.allowStateReads;\n  globalState.allowStateReads = allowStateReads;\n  return prev;\n}\nfunction allowStateReadsEnd(prev) {\n  globalState.allowStateReads = prev;\n}\n/**\r\n * needed to keep `lowestObserverState` correct. when changing from (2 or 1) to 0\r\n *\r\n */\n\nfunction changeDependenciesStateTo0(derivation) {\n  if (derivation.dependenciesState_ === IDerivationState_.UP_TO_DATE_) {\n    return;\n  }\n\n  derivation.dependenciesState_ = IDerivationState_.UP_TO_DATE_;\n  var obs = derivation.observing_;\n  var i = obs.length;\n\n  while (i--) {\n    obs[i].lowestObserverState_ = IDerivationState_.UP_TO_DATE_;\n  }\n}\n\n/**\r\n * These values will persist if global state is reset\r\n */\n\nvar persistentKeys = [\"mobxGuid\", \"spyListeners\", \"enforceActions\", \"computedRequiresReaction\", \"reactionRequiresObservable\", \"observableRequiresReaction\", \"allowStateReads\", \"disableErrorBoundaries\", \"runId\", \"UNCHANGED\", \"useProxies\"];\nvar MobXGlobals = function MobXGlobals() {\n  this.version = 6;\n  this.UNCHANGED = {};\n  this.trackingDerivation = null;\n  this.trackingContext = null;\n  this.runId = 0;\n  this.mobxGuid = 0;\n  this.inBatch = 0;\n  this.pendingUnobservations = [];\n  this.pendingReactions = [];\n  this.isRunningReactions = false;\n  this.allowStateChanges = false;\n  this.allowStateReads = true;\n  this.enforceActions = true;\n  this.spyListeners = [];\n  this.globalReactionErrorHandlers = [];\n  this.computedRequiresReaction = false;\n  this.reactionRequiresObservable = false;\n  this.observableRequiresReaction = false;\n  this.disableErrorBoundaries = false;\n  this.suppressReactionErrors = false;\n  this.useProxies = true;\n  this.verifyProxies = false;\n  this.safeDescriptors = true;\n};\nvar canMergeGlobalState = true;\nvar isolateCalled = false;\nvar globalState = /*#__PURE__*/function () {\n  var global = /*#__PURE__*/getGlobal();\n\n  if (global.__mobxInstanceCount > 0 && !global.__mobxGlobals) {\n    canMergeGlobalState = false;\n  }\n\n  if (global.__mobxGlobals && global.__mobxGlobals.version !== new MobXGlobals().version) {\n    canMergeGlobalState = false;\n  }\n\n  if (!canMergeGlobalState) {\n    // Because this is a IIFE we need to let isolateCalled a chance to change\n    // so we run it after the event loop completed at least 1 iteration\n    setTimeout(function () {\n      if (!isolateCalled) {\n        die(35);\n      }\n    }, 1);\n    return new MobXGlobals();\n  } else if (global.__mobxGlobals) {\n    global.__mobxInstanceCount += 1;\n\n    if (!global.__mobxGlobals.UNCHANGED) {\n      global.__mobxGlobals.UNCHANGED = {};\n    } // make merge backward compatible\n\n\n    return global.__mobxGlobals;\n  } else {\n    global.__mobxInstanceCount = 1;\n    return global.__mobxGlobals = /*#__PURE__*/new MobXGlobals();\n  }\n}();\nfunction isolateGlobalState() {\n  if (globalState.pendingReactions.length || globalState.inBatch || globalState.isRunningReactions) {\n    die(36);\n  }\n\n  isolateCalled = true;\n\n  if (canMergeGlobalState) {\n    var global = getGlobal();\n\n    if (--global.__mobxInstanceCount === 0) {\n      global.__mobxGlobals = undefined;\n    }\n\n    globalState = new MobXGlobals();\n  }\n}\nfunction getGlobalState() {\n  return globalState;\n}\n/**\r\n * For testing purposes only; this will break the internal state of existing observables,\r\n * but can be used to get back at a stable state after throwing errors\r\n */\n\nfunction resetGlobalState() {\n  var defaultGlobals = new MobXGlobals();\n\n  for (var key in defaultGlobals) {\n    if (persistentKeys.indexOf(key) === -1) {\n      globalState[key] = defaultGlobals[key];\n    }\n  }\n\n  globalState.allowStateChanges = !globalState.enforceActions;\n}\n\nfunction hasObservers(observable) {\n  return observable.observers_ && observable.observers_.size > 0;\n}\nfunction getObservers(observable) {\n  return observable.observers_;\n} // function invariantObservers(observable: IObservable) {\n//     const list = observable.observers\n//     const map = observable.observersIndexes\n//     const l = list.length\n//     for (let i = 0; i < l; i++) {\n//         const id = list[i].__mapid\n//         if (i) {\n//             invariant(map[id] === i, \"INTERNAL ERROR maps derivation.__mapid to index in list\") // for performance\n//         } else {\n//             invariant(!(id in map), \"INTERNAL ERROR observer on index 0 shouldn't be held in map.\") // for performance\n//         }\n//     }\n//     invariant(\n//         list.length === 0 || Object.keys(map).length === list.length - 1,\n//         \"INTERNAL ERROR there is no junk in map\"\n//     )\n// }\n\nfunction addObserver(observable, node) {\n  // invariant(node.dependenciesState !== -1, \"INTERNAL ERROR, can add only dependenciesState !== -1\");\n  // invariant(observable._observers.indexOf(node) === -1, \"INTERNAL ERROR add already added node\");\n  // invariantObservers(observable);\n  observable.observers_.add(node);\n\n  if (observable.lowestObserverState_ > node.dependenciesState_) {\n    observable.lowestObserverState_ = node.dependenciesState_;\n  } // invariantObservers(observable);\n  // invariant(observable._observers.indexOf(node) !== -1, \"INTERNAL ERROR didn't add node\");\n\n}\nfunction removeObserver(observable, node) {\n  // invariant(globalState.inBatch > 0, \"INTERNAL ERROR, remove should be called only inside batch\");\n  // invariant(observable._observers.indexOf(node) !== -1, \"INTERNAL ERROR remove already removed node\");\n  // invariantObservers(observable);\n  observable.observers_[\"delete\"](node);\n\n  if (observable.observers_.size === 0) {\n    // deleting last observer\n    queueForUnobservation(observable);\n  } // invariantObservers(observable);\n  // invariant(observable._observers.indexOf(node) === -1, \"INTERNAL ERROR remove already removed node2\");\n\n}\nfunction queueForUnobservation(observable) {\n  if (observable.isPendingUnobservation_ === false) {\n    // invariant(observable._observers.length === 0, \"INTERNAL ERROR, should only queue for unobservation unobserved observables\");\n    observable.isPendingUnobservation_ = true;\n    globalState.pendingUnobservations.push(observable);\n  }\n}\n/**\r\n * Batch starts a transaction, at least for purposes of memoizing ComputedValues when nothing else does.\r\n * During a batch `onBecomeUnobserved` will be called at most once per observable.\r\n * Avoids unnecessary recalculations.\r\n */\n\nfunction startBatch() {\n  globalState.inBatch++;\n}\nfunction endBatch() {\n  if (--globalState.inBatch === 0) {\n    runReactions(); // the batch is actually about to finish, all unobserving should happen here.\n\n    var list = globalState.pendingUnobservations;\n\n    for (var i = 0; i < list.length; i++) {\n      var observable = list[i];\n      observable.isPendingUnobservation_ = false;\n\n      if (observable.observers_.size === 0) {\n        if (observable.isBeingObserved_) {\n          // if this observable had reactive observers, trigger the hooks\n          observable.isBeingObserved_ = false;\n          observable.onBUO();\n        }\n\n        if (observable instanceof ComputedValue) {\n          // computed values are automatically teared down when the last observer leaves\n          // this process happens recursively, this computed might be the last observabe of another, etc..\n          observable.suspend_();\n        }\n      }\n    }\n\n    globalState.pendingUnobservations = [];\n  }\n}\nfunction reportObserved(observable) {\n  checkIfStateReadsAreAllowed(observable);\n  var derivation = globalState.trackingDerivation;\n\n  if (derivation !== null) {\n    /**\r\n     * Simple optimization, give each derivation run an unique id (runId)\r\n     * Check if last time this observable was accessed the same runId is used\r\n     * if this is the case, the relation is already known\r\n     */\n    if (derivation.runId_ !== observable.lastAccessedBy_) {\n      observable.lastAccessedBy_ = derivation.runId_; // Tried storing newObserving, or observing, or both as Set, but performance didn't come close...\n\n      derivation.newObserving_[derivation.unboundDepsCount_++] = observable;\n\n      if (!observable.isBeingObserved_ && globalState.trackingContext) {\n        observable.isBeingObserved_ = true;\n        observable.onBO();\n      }\n    }\n\n    return true;\n  } else if (observable.observers_.size === 0 && globalState.inBatch > 0) {\n    queueForUnobservation(observable);\n  }\n\n  return false;\n} // function invariantLOS(observable: IObservable, msg: string) {\n//     // it's expensive so better not run it in produciton. but temporarily helpful for testing\n//     const min = getObservers(observable).reduce((a, b) => Math.min(a, b.dependenciesState), 2)\n//     if (min >= observable.lowestObserverState) return // <- the only assumption about `lowestObserverState`\n//     throw new Error(\n//         \"lowestObserverState is wrong for \" +\n//             msg +\n//             \" because \" +\n//             min +\n//             \" < \" +\n//             observable.lowestObserverState\n//     )\n// }\n\n/**\r\n * NOTE: current propagation mechanism will in case of self reruning autoruns behave unexpectedly\r\n * It will propagate changes to observers from previous run\r\n * It's hard or maybe impossible (with reasonable perf) to get it right with current approach\r\n * Hopefully self reruning autoruns aren't a feature people should depend on\r\n * Also most basic use cases should be ok\r\n */\n// Called by Atom when its value changes\n\nfunction propagateChanged(observable) {\n  // invariantLOS(observable, \"changed start\");\n  if (observable.lowestObserverState_ === IDerivationState_.STALE_) {\n    return;\n  }\n\n  observable.lowestObserverState_ = IDerivationState_.STALE_; // Ideally we use for..of here, but the downcompiled version is really slow...\n\n  observable.observers_.forEach(function (d) {\n    if (d.dependenciesState_ === IDerivationState_.UP_TO_DATE_) {\n      if (process.env.NODE_ENV !== \"production\" && d.isTracing_ !== TraceMode.NONE) {\n        logTraceInfo(d, observable);\n      }\n\n      d.onBecomeStale_();\n    }\n\n    d.dependenciesState_ = IDerivationState_.STALE_;\n  }); // invariantLOS(observable, \"changed end\");\n} // Called by ComputedValue when it recalculate and its value changed\n\nfunction propagateChangeConfirmed(observable) {\n  // invariantLOS(observable, \"confirmed start\");\n  if (observable.lowestObserverState_ === IDerivationState_.STALE_) {\n    return;\n  }\n\n  observable.lowestObserverState_ = IDerivationState_.STALE_;\n  observable.observers_.forEach(function (d) {\n    if (d.dependenciesState_ === IDerivationState_.POSSIBLY_STALE_) {\n      d.dependenciesState_ = IDerivationState_.STALE_;\n\n      if (process.env.NODE_ENV !== \"production\" && d.isTracing_ !== TraceMode.NONE) {\n        logTraceInfo(d, observable);\n      }\n    } else if (d.dependenciesState_ === IDerivationState_.UP_TO_DATE_ // this happens during computing of `d`, just keep lowestObserverState up to date.\n    ) {\n      observable.lowestObserverState_ = IDerivationState_.UP_TO_DATE_;\n    }\n  }); // invariantLOS(observable, \"confirmed end\");\n} // Used by computed when its dependency changed, but we don't wan't to immediately recompute.\n\nfunction propagateMaybeChanged(observable) {\n  // invariantLOS(observable, \"maybe start\");\n  if (observable.lowestObserverState_ !== IDerivationState_.UP_TO_DATE_) {\n    return;\n  }\n\n  observable.lowestObserverState_ = IDerivationState_.POSSIBLY_STALE_;\n  observable.observers_.forEach(function (d) {\n    if (d.dependenciesState_ === IDerivationState_.UP_TO_DATE_) {\n      d.dependenciesState_ = IDerivationState_.POSSIBLY_STALE_;\n      d.onBecomeStale_();\n    }\n  }); // invariantLOS(observable, \"maybe end\");\n}\n\nfunction logTraceInfo(derivation, observable) {\n  console.log(\"[mobx.trace] '\" + derivation.name_ + \"' is invalidated due to a change in: '\" + observable.name_ + \"'\");\n\n  if (derivation.isTracing_ === TraceMode.BREAK) {\n    var lines = [];\n    printDepTree(getDependencyTree(derivation), lines, 1); // prettier-ignore\n\n    new Function(\"debugger;\\n/*\\nTracing '\" + derivation.name_ + \"'\\n\\nYou are entering this break point because derivation '\" + derivation.name_ + \"' is being traced and '\" + observable.name_ + \"' is now forcing it to update.\\nJust follow the stacktrace you should now see in the devtools to see precisely what piece of your code is causing this update\\nThe stackframe you are looking for is at least ~6-8 stack-frames up.\\n\\n\" + (derivation instanceof ComputedValue ? derivation.derivation.toString().replace(/[*]\\//g, \"/\") : \"\") + \"\\n\\nThe dependencies for this derivation are:\\n\\n\" + lines.join(\"\\n\") + \"\\n*/\\n    \")();\n  }\n}\n\nfunction printDepTree(tree, lines, depth) {\n  if (lines.length >= 1000) {\n    lines.push(\"(and many more)\");\n    return;\n  }\n\n  lines.push(\"\" + \"\\t\".repeat(depth - 1) + tree.name);\n\n  if (tree.dependencies) {\n    tree.dependencies.forEach(function (child) {\n      return printDepTree(child, lines, depth + 1);\n    });\n  }\n}\n\nvar Reaction = /*#__PURE__*/function () {\n  // nodes we are looking at. Our value depends on these nodes\n  function Reaction(name_, onInvalidate_, errorHandler_, requiresObservable_) {\n    if (name_ === void 0) {\n      name_ = process.env.NODE_ENV !== \"production\" ? \"Reaction@\" + getNextId() : \"Reaction\";\n    }\n\n    this.name_ = void 0;\n    this.onInvalidate_ = void 0;\n    this.errorHandler_ = void 0;\n    this.requiresObservable_ = void 0;\n    this.observing_ = [];\n    this.newObserving_ = [];\n    this.dependenciesState_ = IDerivationState_.NOT_TRACKING_;\n    this.diffValue_ = 0;\n    this.runId_ = 0;\n    this.unboundDepsCount_ = 0;\n    this.isDisposed_ = false;\n    this.isScheduled_ = false;\n    this.isTrackPending_ = false;\n    this.isRunning_ = false;\n    this.isTracing_ = TraceMode.NONE;\n    this.name_ = name_;\n    this.onInvalidate_ = onInvalidate_;\n    this.errorHandler_ = errorHandler_;\n    this.requiresObservable_ = requiresObservable_;\n  }\n\n  var _proto = Reaction.prototype;\n\n  _proto.onBecomeStale_ = function onBecomeStale_() {\n    this.schedule_();\n  };\n\n  _proto.schedule_ = function schedule_() {\n    if (!this.isScheduled_) {\n      this.isScheduled_ = true;\n      globalState.pendingReactions.push(this);\n      runReactions();\n    }\n  };\n\n  _proto.isScheduled = function isScheduled() {\n    return this.isScheduled_;\n  }\n  /**\r\n   * internal, use schedule() if you intend to kick off a reaction\r\n   */\n  ;\n\n  _proto.runReaction_ = function runReaction_() {\n    if (!this.isDisposed_) {\n      startBatch();\n      this.isScheduled_ = false;\n      var prev = globalState.trackingContext;\n      globalState.trackingContext = this;\n\n      if (shouldCompute(this)) {\n        this.isTrackPending_ = true;\n\n        try {\n          this.onInvalidate_();\n\n          if (process.env.NODE_ENV !== \"production\" && this.isTrackPending_ && isSpyEnabled()) {\n            // onInvalidate didn't trigger track right away..\n            spyReport({\n              name: this.name_,\n              type: \"scheduled-reaction\"\n            });\n          }\n        } catch (e) {\n          this.reportExceptionInDerivation_(e);\n        }\n      }\n\n      globalState.trackingContext = prev;\n      endBatch();\n    }\n  };\n\n  _proto.track = function track(fn) {\n    if (this.isDisposed_) {\n      return; // console.warn(\"Reaction already disposed\") // Note: Not a warning / error in mobx 4 either\n    }\n\n    startBatch();\n    var notify = isSpyEnabled();\n    var startTime;\n\n    if (process.env.NODE_ENV !== \"production\" && notify) {\n      startTime = Date.now();\n      spyReportStart({\n        name: this.name_,\n        type: \"reaction\"\n      });\n    }\n\n    this.isRunning_ = true;\n    var prevReaction = globalState.trackingContext; // reactions could create reactions...\n\n    globalState.trackingContext = this;\n    var result = trackDerivedFunction(this, fn, undefined);\n    globalState.trackingContext = prevReaction;\n    this.isRunning_ = false;\n    this.isTrackPending_ = false;\n\n    if (this.isDisposed_) {\n      // disposed during last run. Clean up everything that was bound after the dispose call.\n      clearObserving(this);\n    }\n\n    if (isCaughtException(result)) {\n      this.reportExceptionInDerivation_(result.cause);\n    }\n\n    if (process.env.NODE_ENV !== \"production\" && notify) {\n      spyReportEnd({\n        time: Date.now() - startTime\n      });\n    }\n\n    endBatch();\n  };\n\n  _proto.reportExceptionInDerivation_ = function reportExceptionInDerivation_(error) {\n    var _this = this;\n\n    if (this.errorHandler_) {\n      this.errorHandler_(error, this);\n      return;\n    }\n\n    if (globalState.disableErrorBoundaries) {\n      throw error;\n    }\n\n    var message = process.env.NODE_ENV !== \"production\" ? \"[mobx] Encountered an uncaught exception that was thrown by a reaction or observer component, in: '\" + this + \"'\" : \"[mobx] uncaught error in '\" + this + \"'\";\n\n    if (!globalState.suppressReactionErrors) {\n      console.error(message, error);\n      /** If debugging brought you here, please, read the above message :-). Tnx! */\n    } else if (process.env.NODE_ENV !== \"production\") {\n      console.warn(\"[mobx] (error in reaction '\" + this.name_ + \"' suppressed, fix error of causing action below)\");\n    } // prettier-ignore\n\n\n    if (process.env.NODE_ENV !== \"production\" && isSpyEnabled()) {\n      spyReport({\n        type: \"error\",\n        name: this.name_,\n        message: message,\n        error: \"\" + error\n      });\n    }\n\n    globalState.globalReactionErrorHandlers.forEach(function (f) {\n      return f(error, _this);\n    });\n  };\n\n  _proto.dispose = function dispose() {\n    if (!this.isDisposed_) {\n      this.isDisposed_ = true;\n\n      if (!this.isRunning_) {\n        // if disposed while running, clean up later. Maybe not optimal, but rare case\n        startBatch();\n        clearObserving(this);\n        endBatch();\n      }\n    }\n  };\n\n  _proto.getDisposer_ = function getDisposer_() {\n    var r = this.dispose.bind(this);\n    r[$mobx] = this;\n    return r;\n  };\n\n  _proto.toString = function toString() {\n    return \"Reaction[\" + this.name_ + \"]\";\n  };\n\n  _proto.trace = function trace$1(enterBreakPoint) {\n    if (enterBreakPoint === void 0) {\n      enterBreakPoint = false;\n    }\n\n    trace(this, enterBreakPoint);\n  };\n\n  return Reaction;\n}();\nfunction onReactionError(handler) {\n  globalState.globalReactionErrorHandlers.push(handler);\n  return function () {\n    var idx = globalState.globalReactionErrorHandlers.indexOf(handler);\n\n    if (idx >= 0) {\n      globalState.globalReactionErrorHandlers.splice(idx, 1);\n    }\n  };\n}\n/**\r\n * Magic number alert!\r\n * Defines within how many times a reaction is allowed to re-trigger itself\r\n * until it is assumed that this is gonna be a never ending loop...\r\n */\n\nvar MAX_REACTION_ITERATIONS = 100;\n\nvar reactionScheduler = function reactionScheduler(f) {\n  return f();\n};\n\nfunction runReactions() {\n  // Trampolining, if runReactions are already running, new reactions will be picked up\n  if (globalState.inBatch > 0 || globalState.isRunningReactions) {\n    return;\n  }\n\n  reactionScheduler(runReactionsHelper);\n}\n\nfunction runReactionsHelper() {\n  globalState.isRunningReactions = true;\n  var allReactions = globalState.pendingReactions;\n  var iterations = 0; // While running reactions, new reactions might be triggered.\n  // Hence we work with two variables and check whether\n  // we converge to no remaining reactions after a while.\n\n  while (allReactions.length > 0) {\n    if (++iterations === MAX_REACTION_ITERATIONS) {\n      console.error(process.env.NODE_ENV !== \"production\" ? \"Reaction doesn't converge to a stable state after \" + MAX_REACTION_ITERATIONS + \" iterations.\" + (\" Probably there is a cycle in the reactive function: \" + allReactions[0]) : \"[mobx] cycle in reaction: \" + allReactions[0]);\n      allReactions.splice(0); // clear reactions\n    }\n\n    var remainingReactions = allReactions.splice(0);\n\n    for (var i = 0, l = remainingReactions.length; i < l; i++) {\n      remainingReactions[i].runReaction_();\n    }\n  }\n\n  globalState.isRunningReactions = false;\n}\n\nvar isReaction = /*#__PURE__*/createInstanceofPredicate(\"Reaction\", Reaction);\nfunction setReactionScheduler(fn) {\n  var baseScheduler = reactionScheduler;\n\n  reactionScheduler = function reactionScheduler(f) {\n    return fn(function () {\n      return baseScheduler(f);\n    });\n  };\n}\n\nfunction isSpyEnabled() {\n  return process.env.NODE_ENV !== \"production\" && !!globalState.spyListeners.length;\n}\nfunction spyReport(event) {\n  if (!(process.env.NODE_ENV !== \"production\")) {\n    return;\n  } // dead code elimination can do the rest\n\n\n  if (!globalState.spyListeners.length) {\n    return;\n  }\n\n  var listeners = globalState.spyListeners;\n\n  for (var i = 0, l = listeners.length; i < l; i++) {\n    listeners[i](event);\n  }\n}\nfunction spyReportStart(event) {\n  if (!(process.env.NODE_ENV !== \"production\")) {\n    return;\n  }\n\n  var change = _extends({}, event, {\n    spyReportStart: true\n  });\n\n  spyReport(change);\n}\nvar END_EVENT = {\n  type: \"report-end\",\n  spyReportEnd: true\n};\nfunction spyReportEnd(change) {\n  if (!(process.env.NODE_ENV !== \"production\")) {\n    return;\n  }\n\n  if (change) {\n    spyReport(_extends({}, change, {\n      type: \"report-end\",\n      spyReportEnd: true\n    }));\n  } else {\n    spyReport(END_EVENT);\n  }\n}\nfunction spy(listener) {\n  if (!(process.env.NODE_ENV !== \"production\")) {\n    console.warn(\"[mobx.spy] Is a no-op in production builds\");\n    return function () {};\n  } else {\n    globalState.spyListeners.push(listener);\n    return once(function () {\n      globalState.spyListeners = globalState.spyListeners.filter(function (l) {\n        return l !== listener;\n      });\n    });\n  }\n}\n\nvar ACTION = \"action\";\nvar ACTION_BOUND = \"action.bound\";\nvar AUTOACTION = \"autoAction\";\nvar AUTOACTION_BOUND = \"autoAction.bound\";\nvar DEFAULT_ACTION_NAME = \"<unnamed action>\";\nvar actionAnnotation = /*#__PURE__*/createActionAnnotation(ACTION);\nvar actionBoundAnnotation = /*#__PURE__*/createActionAnnotation(ACTION_BOUND, {\n  bound: true\n});\nvar autoActionAnnotation = /*#__PURE__*/createActionAnnotation(AUTOACTION, {\n  autoAction: true\n});\nvar autoActionBoundAnnotation = /*#__PURE__*/createActionAnnotation(AUTOACTION_BOUND, {\n  autoAction: true,\n  bound: true\n});\n\nfunction createActionFactory(autoAction) {\n  var res = function action(arg1, arg2) {\n    // action(fn() {})\n    if (isFunction(arg1)) {\n      return createAction(arg1.name || DEFAULT_ACTION_NAME, arg1, autoAction);\n    } // action(\"name\", fn() {})\n\n\n    if (isFunction(arg2)) {\n      return createAction(arg1, arg2, autoAction);\n    } // @action\n\n\n    if (isStringish(arg2)) {\n      return storeAnnotation(arg1, arg2, autoAction ? autoActionAnnotation : actionAnnotation);\n    } // action(\"name\") & @action(\"name\")\n\n\n    if (isStringish(arg1)) {\n      return createDecoratorAnnotation(createActionAnnotation(autoAction ? AUTOACTION : ACTION, {\n        name: arg1,\n        autoAction: autoAction\n      }));\n    }\n\n    if (process.env.NODE_ENV !== \"production\") {\n      die(\"Invalid arguments for `action`\");\n    }\n  };\n\n  return res;\n}\n\nvar action = /*#__PURE__*/createActionFactory(false);\nObject.assign(action, actionAnnotation);\nvar autoAction = /*#__PURE__*/createActionFactory(true);\nObject.assign(autoAction, autoActionAnnotation);\naction.bound = /*#__PURE__*/createDecoratorAnnotation(actionBoundAnnotation);\nautoAction.bound = /*#__PURE__*/createDecoratorAnnotation(autoActionBoundAnnotation);\nfunction runInAction(fn) {\n  return executeAction(fn.name || DEFAULT_ACTION_NAME, false, fn, this, undefined);\n}\nfunction isAction(thing) {\n  return isFunction(thing) && thing.isMobxAction === true;\n}\n\n/**\r\n * Creates a named reactive view and keeps it alive, so that the view is always\r\n * updated if one of the dependencies changes, even when the view is not further used by something else.\r\n * @param view The reactive view\r\n * @returns disposer function, which can be used to stop the view from being updated in the future.\r\n */\n\nfunction autorun(view, opts) {\n  var _opts$name, _opts;\n\n  if (opts === void 0) {\n    opts = EMPTY_OBJECT;\n  }\n\n  if (process.env.NODE_ENV !== \"production\") {\n    if (!isFunction(view)) {\n      die(\"Autorun expects a function as first argument\");\n    }\n\n    if (isAction(view)) {\n      die(\"Autorun does not accept actions since actions are untrackable\");\n    }\n  }\n\n  var name = (_opts$name = (_opts = opts) == null ? void 0 : _opts.name) != null ? _opts$name : process.env.NODE_ENV !== \"production\" ? view.name || \"Autorun@\" + getNextId() : \"Autorun\";\n  var runSync = !opts.scheduler && !opts.delay;\n  var reaction;\n\n  if (runSync) {\n    // normal autorun\n    reaction = new Reaction(name, function () {\n      this.track(reactionRunner);\n    }, opts.onError, opts.requiresObservable);\n  } else {\n    var scheduler = createSchedulerFromOptions(opts); // debounced autorun\n\n    var isScheduled = false;\n    reaction = new Reaction(name, function () {\n      if (!isScheduled) {\n        isScheduled = true;\n        scheduler(function () {\n          isScheduled = false;\n\n          if (!reaction.isDisposed_) {\n            reaction.track(reactionRunner);\n          }\n        });\n      }\n    }, opts.onError, opts.requiresObservable);\n  }\n\n  function reactionRunner() {\n    view(reaction);\n  }\n\n  reaction.schedule_();\n  return reaction.getDisposer_();\n}\n\nvar run = function run(f) {\n  return f();\n};\n\nfunction createSchedulerFromOptions(opts) {\n  return opts.scheduler ? opts.scheduler : opts.delay ? function (f) {\n    return setTimeout(f, opts.delay);\n  } : run;\n}\n\nfunction reaction(expression, effect, opts) {\n  var _opts$name2;\n\n  if (opts === void 0) {\n    opts = EMPTY_OBJECT;\n  }\n\n  if (process.env.NODE_ENV !== \"production\") {\n    if (!isFunction(expression) || !isFunction(effect)) {\n      die(\"First and second argument to reaction should be functions\");\n    }\n\n    if (!isPlainObject(opts)) {\n      die(\"Third argument of reactions should be an object\");\n    }\n  }\n\n  var name = (_opts$name2 = opts.name) != null ? _opts$name2 : process.env.NODE_ENV !== \"production\" ? \"Reaction@\" + getNextId() : \"Reaction\";\n  var effectAction = action(name, opts.onError ? wrapErrorHandler(opts.onError, effect) : effect);\n  var runSync = !opts.scheduler && !opts.delay;\n  var scheduler = createSchedulerFromOptions(opts);\n  var firstTime = true;\n  var isScheduled = false;\n  var value;\n  var oldValue;\n  var equals = opts.compareStructural ? comparer.structural : opts.equals || comparer[\"default\"];\n  var r = new Reaction(name, function () {\n    if (firstTime || runSync) {\n      reactionRunner();\n    } else if (!isScheduled) {\n      isScheduled = true;\n      scheduler(reactionRunner);\n    }\n  }, opts.onError, opts.requiresObservable);\n\n  function reactionRunner() {\n    isScheduled = false;\n\n    if (r.isDisposed_) {\n      return;\n    }\n\n    var changed = false;\n    r.track(function () {\n      var nextValue = allowStateChanges(false, function () {\n        return expression(r);\n      });\n      changed = firstTime || !equals(value, nextValue);\n      oldValue = value;\n      value = nextValue;\n    });\n\n    if (firstTime && opts.fireImmediately) {\n      effectAction(value, oldValue, r);\n    } else if (!firstTime && changed) {\n      effectAction(value, oldValue, r);\n    }\n\n    firstTime = false;\n  }\n\n  r.schedule_();\n  return r.getDisposer_();\n}\n\nfunction wrapErrorHandler(errorHandler, baseFn) {\n  return function () {\n    try {\n      return baseFn.apply(this, arguments);\n    } catch (e) {\n      errorHandler.call(this, e);\n    }\n  };\n}\n\nvar ON_BECOME_OBSERVED = \"onBO\";\nvar ON_BECOME_UNOBSERVED = \"onBUO\";\nfunction onBecomeObserved(thing, arg2, arg3) {\n  return interceptHook(ON_BECOME_OBSERVED, thing, arg2, arg3);\n}\nfunction onBecomeUnobserved(thing, arg2, arg3) {\n  return interceptHook(ON_BECOME_UNOBSERVED, thing, arg2, arg3);\n}\n\nfunction interceptHook(hook, thing, arg2, arg3) {\n  var atom = typeof arg3 === \"function\" ? getAtom(thing, arg2) : getAtom(thing);\n  var cb = isFunction(arg3) ? arg3 : arg2;\n  var listenersKey = hook + \"L\";\n\n  if (atom[listenersKey]) {\n    atom[listenersKey].add(cb);\n  } else {\n    atom[listenersKey] = new Set([cb]);\n  }\n\n  return function () {\n    var hookListeners = atom[listenersKey];\n\n    if (hookListeners) {\n      hookListeners[\"delete\"](cb);\n\n      if (hookListeners.size === 0) {\n        delete atom[listenersKey];\n      }\n    }\n  };\n}\n\nvar NEVER = \"never\";\nvar ALWAYS = \"always\";\nvar OBSERVED = \"observed\"; // const IF_AVAILABLE = \"ifavailable\"\n\nfunction configure(options) {\n  if (options.isolateGlobalState === true) {\n    isolateGlobalState();\n  }\n\n  var useProxies = options.useProxies,\n      enforceActions = options.enforceActions;\n\n  if (useProxies !== undefined) {\n    globalState.useProxies = useProxies === ALWAYS ? true : useProxies === NEVER ? false : typeof Proxy !== \"undefined\";\n  }\n\n  if (useProxies === \"ifavailable\") {\n    globalState.verifyProxies = true;\n  }\n\n  if (enforceActions !== undefined) {\n    var ea = enforceActions === ALWAYS ? ALWAYS : enforceActions === OBSERVED;\n    globalState.enforceActions = ea;\n    globalState.allowStateChanges = ea === true || ea === ALWAYS ? false : true;\n  }\n  [\"computedRequiresReaction\", \"reactionRequiresObservable\", \"observableRequiresReaction\", \"disableErrorBoundaries\", \"safeDescriptors\"].forEach(function (key) {\n    if (key in options) {\n      globalState[key] = !!options[key];\n    }\n  });\n  globalState.allowStateReads = !globalState.observableRequiresReaction;\n\n  if (process.env.NODE_ENV !== \"production\" && globalState.disableErrorBoundaries === true) {\n    console.warn(\"WARNING: Debug feature only. MobX will NOT recover from errors when `disableErrorBoundaries` is enabled.\");\n  }\n\n  if (options.reactionScheduler) {\n    setReactionScheduler(options.reactionScheduler);\n  }\n}\n\nfunction extendObservable(target, properties, annotations, options) {\n  if (process.env.NODE_ENV !== \"production\") {\n    if (arguments.length > 4) {\n      die(\"'extendObservable' expected 2-4 arguments\");\n    }\n\n    if (typeof target !== \"object\") {\n      die(\"'extendObservable' expects an object as first argument\");\n    }\n\n    if (isObservableMap(target)) {\n      die(\"'extendObservable' should not be used on maps, use map.merge instead\");\n    }\n\n    if (!isPlainObject(properties)) {\n      die(\"'extendObservable' only accepts plain objects as second argument\");\n    }\n\n    if (isObservable(properties) || isObservable(annotations)) {\n      die(\"Extending an object with another observable (object) is not supported\");\n    }\n  } // Pull descriptors first, so we don't have to deal with props added by administration ($mobx)\n\n\n  var descriptors = getOwnPropertyDescriptors(properties);\n  var adm = asObservableObject(target, options)[$mobx];\n  startBatch();\n\n  try {\n    ownKeys(descriptors).forEach(function (key) {\n      adm.extend_(key, descriptors[key], // must pass \"undefined\" for { key: undefined }\n      !annotations ? true : key in annotations ? annotations[key] : true);\n    });\n  } finally {\n    endBatch();\n  }\n\n  return target;\n}\n\nfunction getDependencyTree(thing, property) {\n  return nodeToDependencyTree(getAtom(thing, property));\n}\n\nfunction nodeToDependencyTree(node) {\n  var result = {\n    name: node.name_\n  };\n\n  if (node.observing_ && node.observing_.length > 0) {\n    result.dependencies = unique(node.observing_).map(nodeToDependencyTree);\n  }\n\n  return result;\n}\n\nfunction getObserverTree(thing, property) {\n  return nodeToObserverTree(getAtom(thing, property));\n}\n\nfunction nodeToObserverTree(node) {\n  var result = {\n    name: node.name_\n  };\n\n  if (hasObservers(node)) {\n    result.observers = Array.from(getObservers(node)).map(nodeToObserverTree);\n  }\n\n  return result;\n}\n\nfunction unique(list) {\n  return Array.from(new Set(list));\n}\n\nvar generatorId = 0;\nfunction FlowCancellationError() {\n  this.message = \"FLOW_CANCELLED\";\n}\nFlowCancellationError.prototype = /*#__PURE__*/Object.create(Error.prototype);\nfunction isFlowCancellationError(error) {\n  return error instanceof FlowCancellationError;\n}\nvar flowAnnotation = /*#__PURE__*/createFlowAnnotation(\"flow\");\nvar flowBoundAnnotation = /*#__PURE__*/createFlowAnnotation(\"flow.bound\", {\n  bound: true\n});\nvar flow = /*#__PURE__*/Object.assign(function flow(arg1, arg2) {\n  // @flow\n  if (isStringish(arg2)) {\n    return storeAnnotation(arg1, arg2, flowAnnotation);\n  } // flow(fn)\n\n\n  if (process.env.NODE_ENV !== \"production\" && arguments.length !== 1) {\n    die(\"Flow expects single argument with generator function\");\n  }\n\n  var generator = arg1;\n  var name = generator.name || \"<unnamed flow>\"; // Implementation based on https://github.com/tj/co/blob/master/index.js\n\n  var res = function res() {\n    var ctx = this;\n    var args = arguments;\n    var runId = ++generatorId;\n    var gen = action(name + \" - runid: \" + runId + \" - init\", generator).apply(ctx, args);\n    var rejector;\n    var pendingPromise = undefined;\n    var promise = new Promise(function (resolve, reject) {\n      var stepId = 0;\n      rejector = reject;\n\n      function onFulfilled(res) {\n        pendingPromise = undefined;\n        var ret;\n\n        try {\n          ret = action(name + \" - runid: \" + runId + \" - yield \" + stepId++, gen.next).call(gen, res);\n        } catch (e) {\n          return reject(e);\n        }\n\n        next(ret);\n      }\n\n      function onRejected(err) {\n        pendingPromise = undefined;\n        var ret;\n\n        try {\n          ret = action(name + \" - runid: \" + runId + \" - yield \" + stepId++, gen[\"throw\"]).call(gen, err);\n        } catch (e) {\n          return reject(e);\n        }\n\n        next(ret);\n      }\n\n      function next(ret) {\n        if (isFunction(ret == null ? void 0 : ret.then)) {\n          // an async iterator\n          ret.then(next, reject);\n          return;\n        }\n\n        if (ret.done) {\n          return resolve(ret.value);\n        }\n\n        pendingPromise = Promise.resolve(ret.value);\n        return pendingPromise.then(onFulfilled, onRejected);\n      }\n\n      onFulfilled(undefined); // kick off the process\n    });\n    promise.cancel = action(name + \" - runid: \" + runId + \" - cancel\", function () {\n      try {\n        if (pendingPromise) {\n          cancelPromise(pendingPromise);\n        } // Finally block can return (or yield) stuff..\n\n\n        var _res = gen[\"return\"](undefined); // eat anything that promise would do, it's cancelled!\n\n\n        var yieldedPromise = Promise.resolve(_res.value);\n        yieldedPromise.then(noop, noop);\n        cancelPromise(yieldedPromise); // maybe it can be cancelled :)\n        // reject our original promise\n\n        rejector(new FlowCancellationError());\n      } catch (e) {\n        rejector(e); // there could be a throwing finally block\n      }\n    });\n    return promise;\n  };\n\n  res.isMobXFlow = true;\n  return res;\n}, flowAnnotation);\nflow.bound = /*#__PURE__*/createDecoratorAnnotation(flowBoundAnnotation);\n\nfunction cancelPromise(promise) {\n  if (isFunction(promise.cancel)) {\n    promise.cancel();\n  }\n}\n\nfunction flowResult(result) {\n  return result; // just tricking TypeScript :)\n}\nfunction isFlow(fn) {\n  return (fn == null ? void 0 : fn.isMobXFlow) === true;\n}\n\nfunction interceptReads(thing, propOrHandler, handler) {\n  var target;\n\n  if (isObservableMap(thing) || isObservableArray(thing) || isObservableValue(thing)) {\n    target = getAdministration(thing);\n  } else if (isObservableObject(thing)) {\n    if (process.env.NODE_ENV !== \"production\" && !isStringish(propOrHandler)) {\n      return die(\"InterceptReads can only be used with a specific property, not with an object in general\");\n    }\n\n    target = getAdministration(thing, propOrHandler);\n  } else if (process.env.NODE_ENV !== \"production\") {\n    return die(\"Expected observable map, object or array as first array\");\n  }\n\n  if (process.env.NODE_ENV !== \"production\" && target.dehancer !== undefined) {\n    return die(\"An intercept reader was already established\");\n  }\n\n  target.dehancer = typeof propOrHandler === \"function\" ? propOrHandler : handler;\n  return function () {\n    target.dehancer = undefined;\n  };\n}\n\nfunction intercept(thing, propOrHandler, handler) {\n  if (isFunction(handler)) {\n    return interceptProperty(thing, propOrHandler, handler);\n  } else {\n    return interceptInterceptable(thing, propOrHandler);\n  }\n}\n\nfunction interceptInterceptable(thing, handler) {\n  return getAdministration(thing).intercept_(handler);\n}\n\nfunction interceptProperty(thing, property, handler) {\n  return getAdministration(thing, property).intercept_(handler);\n}\n\nfunction _isComputed(value, property) {\n  if (property === undefined) {\n    return isComputedValue(value);\n  }\n\n  if (isObservableObject(value) === false) {\n    return false;\n  }\n\n  if (!value[$mobx].values_.has(property)) {\n    return false;\n  }\n\n  var atom = getAtom(value, property);\n  return isComputedValue(atom);\n}\nfunction isComputed(value) {\n  if (process.env.NODE_ENV !== \"production\" && arguments.length > 1) {\n    return die(\"isComputed expects only 1 argument. Use isComputedProp to inspect the observability of a property\");\n  }\n\n  return _isComputed(value);\n}\nfunction isComputedProp(value, propName) {\n  if (process.env.NODE_ENV !== \"production\" && !isStringish(propName)) {\n    return die(\"isComputed expected a property name as second argument\");\n  }\n\n  return _isComputed(value, propName);\n}\n\nfunction _isObservable(value, property) {\n  if (!value) {\n    return false;\n  }\n\n  if (property !== undefined) {\n    if (process.env.NODE_ENV !== \"production\" && (isObservableMap(value) || isObservableArray(value))) {\n      return die(\"isObservable(object, propertyName) is not supported for arrays and maps. Use map.has or array.length instead.\");\n    }\n\n    if (isObservableObject(value)) {\n      return value[$mobx].values_.has(property);\n    }\n\n    return false;\n  } // For first check, see #701\n\n\n  return isObservableObject(value) || !!value[$mobx] || isAtom(value) || isReaction(value) || isComputedValue(value);\n}\n\nfunction isObservable(value) {\n  if (process.env.NODE_ENV !== \"production\" && arguments.length !== 1) {\n    die(\"isObservable expects only 1 argument. Use isObservableProp to inspect the observability of a property\");\n  }\n\n  return _isObservable(value);\n}\nfunction isObservableProp(value, propName) {\n  if (process.env.NODE_ENV !== \"production\" && !isStringish(propName)) {\n    return die(\"expected a property name as second argument\");\n  }\n\n  return _isObservable(value, propName);\n}\n\nfunction keys(obj) {\n  if (isObservableObject(obj)) {\n    return obj[$mobx].keys_();\n  }\n\n  if (isObservableMap(obj) || isObservableSet(obj)) {\n    return Array.from(obj.keys());\n  }\n\n  if (isObservableArray(obj)) {\n    return obj.map(function (_, index) {\n      return index;\n    });\n  }\n\n  die(5);\n}\nfunction values(obj) {\n  if (isObservableObject(obj)) {\n    return keys(obj).map(function (key) {\n      return obj[key];\n    });\n  }\n\n  if (isObservableMap(obj)) {\n    return keys(obj).map(function (key) {\n      return obj.get(key);\n    });\n  }\n\n  if (isObservableSet(obj)) {\n    return Array.from(obj.values());\n  }\n\n  if (isObservableArray(obj)) {\n    return obj.slice();\n  }\n\n  die(6);\n}\nfunction entries(obj) {\n  if (isObservableObject(obj)) {\n    return keys(obj).map(function (key) {\n      return [key, obj[key]];\n    });\n  }\n\n  if (isObservableMap(obj)) {\n    return keys(obj).map(function (key) {\n      return [key, obj.get(key)];\n    });\n  }\n\n  if (isObservableSet(obj)) {\n    return Array.from(obj.entries());\n  }\n\n  if (isObservableArray(obj)) {\n    return obj.map(function (key, index) {\n      return [index, key];\n    });\n  }\n\n  die(7);\n}\nfunction set(obj, key, value) {\n  if (arguments.length === 2 && !isObservableSet(obj)) {\n    startBatch();\n    var _values = key;\n\n    try {\n      for (var _key in _values) {\n        set(obj, _key, _values[_key]);\n      }\n    } finally {\n      endBatch();\n    }\n\n    return;\n  }\n\n  if (isObservableObject(obj)) {\n    obj[$mobx].set_(key, value);\n  } else if (isObservableMap(obj)) {\n    obj.set(key, value);\n  } else if (isObservableSet(obj)) {\n    obj.add(key);\n  } else if (isObservableArray(obj)) {\n    if (typeof key !== \"number\") {\n      key = parseInt(key, 10);\n    }\n\n    if (key < 0) {\n      die(\"Invalid index: '\" + key + \"'\");\n    }\n\n    startBatch();\n\n    if (key >= obj.length) {\n      obj.length = key + 1;\n    }\n\n    obj[key] = value;\n    endBatch();\n  } else {\n    die(8);\n  }\n}\nfunction remove(obj, key) {\n  if (isObservableObject(obj)) {\n    obj[$mobx].delete_(key);\n  } else if (isObservableMap(obj)) {\n    obj[\"delete\"](key);\n  } else if (isObservableSet(obj)) {\n    obj[\"delete\"](key);\n  } else if (isObservableArray(obj)) {\n    if (typeof key !== \"number\") {\n      key = parseInt(key, 10);\n    }\n\n    obj.splice(key, 1);\n  } else {\n    die(9);\n  }\n}\nfunction has(obj, key) {\n  if (isObservableObject(obj)) {\n    return obj[$mobx].has_(key);\n  } else if (isObservableMap(obj)) {\n    return obj.has(key);\n  } else if (isObservableSet(obj)) {\n    return obj.has(key);\n  } else if (isObservableArray(obj)) {\n    return key >= 0 && key < obj.length;\n  }\n\n  die(10);\n}\nfunction get(obj, key) {\n  if (!has(obj, key)) {\n    return undefined;\n  }\n\n  if (isObservableObject(obj)) {\n    return obj[$mobx].get_(key);\n  } else if (isObservableMap(obj)) {\n    return obj.get(key);\n  } else if (isObservableArray(obj)) {\n    return obj[key];\n  }\n\n  die(11);\n}\nfunction apiDefineProperty(obj, key, descriptor) {\n  if (isObservableObject(obj)) {\n    return obj[$mobx].defineProperty_(key, descriptor);\n  }\n\n  die(39);\n}\nfunction apiOwnKeys(obj) {\n  if (isObservableObject(obj)) {\n    return obj[$mobx].ownKeys_();\n  }\n\n  die(38);\n}\n\nfunction observe(thing, propOrCb, cbOrFire, fireImmediately) {\n  if (isFunction(cbOrFire)) {\n    return observeObservableProperty(thing, propOrCb, cbOrFire, fireImmediately);\n  } else {\n    return observeObservable(thing, propOrCb, cbOrFire);\n  }\n}\n\nfunction observeObservable(thing, listener, fireImmediately) {\n  return getAdministration(thing).observe_(listener, fireImmediately);\n}\n\nfunction observeObservableProperty(thing, property, listener, fireImmediately) {\n  return getAdministration(thing, property).observe_(listener, fireImmediately);\n}\n\nfunction cache(map, key, value) {\n  map.set(key, value);\n  return value;\n}\n\nfunction toJSHelper(source, __alreadySeen) {\n  if (source == null || typeof source !== \"object\" || source instanceof Date || !isObservable(source)) {\n    return source;\n  }\n\n  if (isObservableValue(source) || isComputedValue(source)) {\n    return toJSHelper(source.get(), __alreadySeen);\n  }\n\n  if (__alreadySeen.has(source)) {\n    return __alreadySeen.get(source);\n  }\n\n  if (isObservableArray(source)) {\n    var res = cache(__alreadySeen, source, new Array(source.length));\n    source.forEach(function (value, idx) {\n      res[idx] = toJSHelper(value, __alreadySeen);\n    });\n    return res;\n  }\n\n  if (isObservableSet(source)) {\n    var _res = cache(__alreadySeen, source, new Set());\n\n    source.forEach(function (value) {\n      _res.add(toJSHelper(value, __alreadySeen));\n    });\n    return _res;\n  }\n\n  if (isObservableMap(source)) {\n    var _res2 = cache(__alreadySeen, source, new Map());\n\n    source.forEach(function (value, key) {\n      _res2.set(key, toJSHelper(value, __alreadySeen));\n    });\n    return _res2;\n  } else {\n    // must be observable object\n    var _res3 = cache(__alreadySeen, source, {});\n\n    apiOwnKeys(source).forEach(function (key) {\n      if (objectPrototype.propertyIsEnumerable.call(source, key)) {\n        _res3[key] = toJSHelper(source[key], __alreadySeen);\n      }\n    });\n    return _res3;\n  }\n}\n/**\r\n * Recursively converts an observable to it's non-observable native counterpart.\r\n * It does NOT recurse into non-observables, these are left as they are, even if they contain observables.\r\n * Computed and other non-enumerable properties are completely ignored.\r\n * Complex scenarios require custom solution, eg implementing `toJSON` or using `serializr` lib.\r\n */\n\n\nfunction toJS(source, options) {\n  if (process.env.NODE_ENV !== \"production\" && options) {\n    die(\"toJS no longer supports options\");\n  }\n\n  return toJSHelper(source, new Map());\n}\n\nfunction trace() {\n  if (!(process.env.NODE_ENV !== \"production\")) {\n    die(\"trace() is not available in production builds\");\n  }\n\n  var enterBreakPoint = false;\n\n  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n    args[_key] = arguments[_key];\n  }\n\n  if (typeof args[args.length - 1] === \"boolean\") {\n    enterBreakPoint = args.pop();\n  }\n\n  var derivation = getAtomFromArgs(args);\n\n  if (!derivation) {\n    return die(\"'trace(break?)' can only be used inside a tracked computed value or a Reaction. Consider passing in the computed value or reaction explicitly\");\n  }\n\n  if (derivation.isTracing_ === TraceMode.NONE) {\n    console.log(\"[mobx.trace] '\" + derivation.name_ + \"' tracing enabled\");\n  }\n\n  derivation.isTracing_ = enterBreakPoint ? TraceMode.BREAK : TraceMode.LOG;\n}\n\nfunction getAtomFromArgs(args) {\n  switch (args.length) {\n    case 0:\n      return globalState.trackingDerivation;\n\n    case 1:\n      return getAtom(args[0]);\n\n    case 2:\n      return getAtom(args[0], args[1]);\n  }\n}\n\n/**\r\n * During a transaction no views are updated until the end of the transaction.\r\n * The transaction will be run synchronously nonetheless.\r\n *\r\n * @param action a function that updates some reactive state\r\n * @returns any value that was returned by the 'action' parameter.\r\n */\n\nfunction transaction(action, thisArg) {\n  if (thisArg === void 0) {\n    thisArg = undefined;\n  }\n\n  startBatch();\n\n  try {\n    return action.apply(thisArg);\n  } finally {\n    endBatch();\n  }\n}\n\nfunction when(predicate, arg1, arg2) {\n  if (arguments.length === 1 || arg1 && typeof arg1 === \"object\") {\n    return whenPromise(predicate, arg1);\n  }\n\n  return _when(predicate, arg1, arg2 || {});\n}\n\nfunction _when(predicate, effect, opts) {\n  var timeoutHandle;\n\n  if (typeof opts.timeout === \"number\") {\n    var error = new Error(\"WHEN_TIMEOUT\");\n    timeoutHandle = setTimeout(function () {\n      if (!disposer[$mobx].isDisposed_) {\n        disposer();\n\n        if (opts.onError) {\n          opts.onError(error);\n        } else {\n          throw error;\n        }\n      }\n    }, opts.timeout);\n  }\n\n  opts.name = process.env.NODE_ENV !== \"production\" ? opts.name || \"When@\" + getNextId() : \"When\";\n  var effectAction = createAction(process.env.NODE_ENV !== \"production\" ? opts.name + \"-effect\" : \"When-effect\", effect); // eslint-disable-next-line\n\n  var disposer = autorun(function (r) {\n    // predicate should not change state\n    var cond = allowStateChanges(false, predicate);\n\n    if (cond) {\n      r.dispose();\n\n      if (timeoutHandle) {\n        clearTimeout(timeoutHandle);\n      }\n\n      effectAction();\n    }\n  }, opts);\n  return disposer;\n}\n\nfunction whenPromise(predicate, opts) {\n  if (process.env.NODE_ENV !== \"production\" && opts && opts.onError) {\n    return die(\"the options 'onError' and 'promise' cannot be combined\");\n  }\n\n  var cancel;\n  var res = new Promise(function (resolve, reject) {\n    var disposer = _when(predicate, resolve, _extends({}, opts, {\n      onError: reject\n    }));\n\n    cancel = function cancel() {\n      disposer();\n      reject(new Error(\"WHEN_CANCELLED\"));\n    };\n  });\n  res.cancel = cancel;\n  return res;\n}\n\nfunction getAdm(target) {\n  return target[$mobx];\n} // Optimization: we don't need the intermediate objects and could have a completely custom administration for DynamicObjects,\n// and skip either the internal values map, or the base object with its property descriptors!\n\n\nvar objectProxyTraps = {\n  has: function has(target, name) {\n    if (process.env.NODE_ENV !== \"production\" && globalState.trackingDerivation) {\n      warnAboutProxyRequirement(\"detect new properties using the 'in' operator. Use 'has' from 'mobx' instead.\");\n    }\n\n    return getAdm(target).has_(name);\n  },\n  get: function get(target, name) {\n    return getAdm(target).get_(name);\n  },\n  set: function set(target, name, value) {\n    var _getAdm$set_;\n\n    if (!isStringish(name)) {\n      return false;\n    }\n\n    if (process.env.NODE_ENV !== \"production\" && !getAdm(target).values_.has(name)) {\n      warnAboutProxyRequirement(\"add a new observable property through direct assignment. Use 'set' from 'mobx' instead.\");\n    } // null (intercepted) -> true (success)\n\n\n    return (_getAdm$set_ = getAdm(target).set_(name, value, true)) != null ? _getAdm$set_ : true;\n  },\n  deleteProperty: function deleteProperty(target, name) {\n    var _getAdm$delete_;\n\n    if (process.env.NODE_ENV !== \"production\") {\n      warnAboutProxyRequirement(\"delete properties from an observable object. Use 'remove' from 'mobx' instead.\");\n    }\n\n    if (!isStringish(name)) {\n      return false;\n    } // null (intercepted) -> true (success)\n\n\n    return (_getAdm$delete_ = getAdm(target).delete_(name, true)) != null ? _getAdm$delete_ : true;\n  },\n  defineProperty: function defineProperty(target, name, descriptor) {\n    var _getAdm$definePropert;\n\n    if (process.env.NODE_ENV !== \"production\") {\n      warnAboutProxyRequirement(\"define property on an observable object. Use 'defineProperty' from 'mobx' instead.\");\n    } // null (intercepted) -> true (success)\n\n\n    return (_getAdm$definePropert = getAdm(target).defineProperty_(name, descriptor)) != null ? _getAdm$definePropert : true;\n  },\n  ownKeys: function ownKeys(target) {\n    if (process.env.NODE_ENV !== \"production\" && globalState.trackingDerivation) {\n      warnAboutProxyRequirement(\"iterate keys to detect added / removed properties. Use 'keys' from 'mobx' instead.\");\n    }\n\n    return getAdm(target).ownKeys_();\n  },\n  preventExtensions: function preventExtensions(target) {\n    die(13);\n  }\n};\nfunction asDynamicObservableObject(target, options) {\n  var _target$$mobx, _target$$mobx$proxy_;\n\n  assertProxies();\n  target = asObservableObject(target, options);\n  return (_target$$mobx$proxy_ = (_target$$mobx = target[$mobx]).proxy_) != null ? _target$$mobx$proxy_ : _target$$mobx.proxy_ = new Proxy(target, objectProxyTraps);\n}\n\nfunction hasInterceptors(interceptable) {\n  return interceptable.interceptors_ !== undefined && interceptable.interceptors_.length > 0;\n}\nfunction registerInterceptor(interceptable, handler) {\n  var interceptors = interceptable.interceptors_ || (interceptable.interceptors_ = []);\n  interceptors.push(handler);\n  return once(function () {\n    var idx = interceptors.indexOf(handler);\n\n    if (idx !== -1) {\n      interceptors.splice(idx, 1);\n    }\n  });\n}\nfunction interceptChange(interceptable, change) {\n  var prevU = untrackedStart();\n\n  try {\n    // Interceptor can modify the array, copy it to avoid concurrent modification, see #1950\n    var interceptors = [].concat(interceptable.interceptors_ || []);\n\n    for (var i = 0, l = interceptors.length; i < l; i++) {\n      change = interceptors[i](change);\n\n      if (change && !change.type) {\n        die(14);\n      }\n\n      if (!change) {\n        break;\n      }\n    }\n\n    return change;\n  } finally {\n    untrackedEnd(prevU);\n  }\n}\n\nfunction hasListeners(listenable) {\n  return listenable.changeListeners_ !== undefined && listenable.changeListeners_.length > 0;\n}\nfunction registerListener(listenable, handler) {\n  var listeners = listenable.changeListeners_ || (listenable.changeListeners_ = []);\n  listeners.push(handler);\n  return once(function () {\n    var idx = listeners.indexOf(handler);\n\n    if (idx !== -1) {\n      listeners.splice(idx, 1);\n    }\n  });\n}\nfunction notifyListeners(listenable, change) {\n  var prevU = untrackedStart();\n  var listeners = listenable.changeListeners_;\n\n  if (!listeners) {\n    return;\n  }\n\n  listeners = listeners.slice();\n\n  for (var i = 0, l = listeners.length; i < l; i++) {\n    listeners[i](change);\n  }\n\n  untrackedEnd(prevU);\n}\n\nfunction makeObservable(target, annotations, options) {\n  var adm = asObservableObject(target, options)[$mobx];\n  startBatch();\n\n  try {\n    var _annotations;\n\n    if (process.env.NODE_ENV !== \"production\" && annotations && target[storedAnnotationsSymbol]) {\n      die(\"makeObservable second arg must be nullish when using decorators. Mixing @decorator syntax with annotations is not supported.\");\n    } // Default to decorators\n\n\n    (_annotations = annotations) != null ? _annotations : annotations = collectStoredAnnotations(target); // Annotate\n\n    ownKeys(annotations).forEach(function (key) {\n      return adm.make_(key, annotations[key]);\n    });\n  } finally {\n    endBatch();\n  }\n\n  return target;\n} // proto[keysSymbol] = new Set<PropertyKey>()\n\nvar keysSymbol = /*#__PURE__*/Symbol(\"mobx-keys\");\nfunction makeAutoObservable(target, overrides, options) {\n  if (process.env.NODE_ENV !== \"production\") {\n    if (!isPlainObject(target) && !isPlainObject(Object.getPrototypeOf(target))) {\n      die(\"'makeAutoObservable' can only be used for classes that don't have a superclass\");\n    }\n\n    if (isObservableObject(target)) {\n      die(\"makeAutoObservable can only be used on objects not already made observable\");\n    }\n  } // Optimization: avoid visiting protos\n  // Assumes that annotation.make_/.extend_ works the same for plain objects\n\n\n  if (isPlainObject(target)) {\n    return extendObservable(target, target, overrides, options);\n  }\n\n  var adm = asObservableObject(target, options)[$mobx]; // Optimization: cache keys on proto\n  // Assumes makeAutoObservable can be called only once per object and can't be used in subclass\n\n  if (!target[keysSymbol]) {\n    var proto = Object.getPrototypeOf(target);\n    var keys = new Set([].concat(ownKeys(target), ownKeys(proto)));\n    keys[\"delete\"](\"constructor\");\n    keys[\"delete\"]($mobx);\n    addHiddenProp(proto, keysSymbol, keys);\n  }\n\n  startBatch();\n\n  try {\n    target[keysSymbol].forEach(function (key) {\n      return adm.make_(key, // must pass \"undefined\" for { key: undefined }\n      !overrides ? true : key in overrides ? overrides[key] : true);\n    });\n  } finally {\n    endBatch();\n  }\n\n  return target;\n}\n\nvar SPLICE = \"splice\";\nvar UPDATE = \"update\";\nvar MAX_SPLICE_SIZE = 10000; // See e.g. https://github.com/mobxjs/mobx/issues/859\n\nvar arrayTraps = {\n  get: function get(target, name) {\n    var adm = target[$mobx];\n\n    if (name === $mobx) {\n      return adm;\n    }\n\n    if (name === \"length\") {\n      return adm.getArrayLength_();\n    }\n\n    if (typeof name === \"string\" && !isNaN(name)) {\n      return adm.get_(parseInt(name));\n    }\n\n    if (hasProp(arrayExtensions, name)) {\n      return arrayExtensions[name];\n    }\n\n    return target[name];\n  },\n  set: function set(target, name, value) {\n    var adm = target[$mobx];\n\n    if (name === \"length\") {\n      adm.setArrayLength_(value);\n    }\n\n    if (typeof name === \"symbol\" || isNaN(name)) {\n      target[name] = value;\n    } else {\n      // numeric string\n      adm.set_(parseInt(name), value);\n    }\n\n    return true;\n  },\n  preventExtensions: function preventExtensions() {\n    die(15);\n  }\n};\nvar ObservableArrayAdministration = /*#__PURE__*/function () {\n  // this is the prop that gets proxied, so can't replace it!\n  function ObservableArrayAdministration(name, enhancer, owned_, legacyMode_) {\n    if (name === void 0) {\n      name = process.env.NODE_ENV !== \"production\" ? \"ObservableArray@\" + getNextId() : \"ObservableArray\";\n    }\n\n    this.owned_ = void 0;\n    this.legacyMode_ = void 0;\n    this.atom_ = void 0;\n    this.values_ = [];\n    this.interceptors_ = void 0;\n    this.changeListeners_ = void 0;\n    this.enhancer_ = void 0;\n    this.dehancer = void 0;\n    this.proxy_ = void 0;\n    this.lastKnownLength_ = 0;\n    this.owned_ = owned_;\n    this.legacyMode_ = legacyMode_;\n    this.atom_ = new Atom(name);\n\n    this.enhancer_ = function (newV, oldV) {\n      return enhancer(newV, oldV, process.env.NODE_ENV !== \"production\" ? name + \"[..]\" : \"ObservableArray[..]\");\n    };\n  }\n\n  var _proto = ObservableArrayAdministration.prototype;\n\n  _proto.dehanceValue_ = function dehanceValue_(value) {\n    if (this.dehancer !== undefined) {\n      return this.dehancer(value);\n    }\n\n    return value;\n  };\n\n  _proto.dehanceValues_ = function dehanceValues_(values) {\n    if (this.dehancer !== undefined && values.length > 0) {\n      return values.map(this.dehancer);\n    }\n\n    return values;\n  };\n\n  _proto.intercept_ = function intercept_(handler) {\n    return registerInterceptor(this, handler);\n  };\n\n  _proto.observe_ = function observe_(listener, fireImmediately) {\n    if (fireImmediately === void 0) {\n      fireImmediately = false;\n    }\n\n    if (fireImmediately) {\n      listener({\n        observableKind: \"array\",\n        object: this.proxy_,\n        debugObjectName: this.atom_.name_,\n        type: \"splice\",\n        index: 0,\n        added: this.values_.slice(),\n        addedCount: this.values_.length,\n        removed: [],\n        removedCount: 0\n      });\n    }\n\n    return registerListener(this, listener);\n  };\n\n  _proto.getArrayLength_ = function getArrayLength_() {\n    this.atom_.reportObserved();\n    return this.values_.length;\n  };\n\n  _proto.setArrayLength_ = function setArrayLength_(newLength) {\n    if (typeof newLength !== \"number\" || isNaN(newLength) || newLength < 0) {\n      die(\"Out of range: \" + newLength);\n    }\n\n    var currentLength = this.values_.length;\n\n    if (newLength === currentLength) {\n      return;\n    } else if (newLength > currentLength) {\n      var newItems = new Array(newLength - currentLength);\n\n      for (var i = 0; i < newLength - currentLength; i++) {\n        newItems[i] = undefined;\n      } // No Array.fill everywhere...\n\n\n      this.spliceWithArray_(currentLength, 0, newItems);\n    } else {\n      this.spliceWithArray_(newLength, currentLength - newLength);\n    }\n  };\n\n  _proto.updateArrayLength_ = function updateArrayLength_(oldLength, delta) {\n    if (oldLength !== this.lastKnownLength_) {\n      die(16);\n    }\n\n    this.lastKnownLength_ += delta;\n\n    if (this.legacyMode_ && delta > 0) {\n      reserveArrayBuffer(oldLength + delta + 1);\n    }\n  };\n\n  _proto.spliceWithArray_ = function spliceWithArray_(index, deleteCount, newItems) {\n    var _this = this;\n\n    checkIfStateModificationsAreAllowed(this.atom_);\n    var length = this.values_.length;\n\n    if (index === undefined) {\n      index = 0;\n    } else if (index > length) {\n      index = length;\n    } else if (index < 0) {\n      index = Math.max(0, length + index);\n    }\n\n    if (arguments.length === 1) {\n      deleteCount = length - index;\n    } else if (deleteCount === undefined || deleteCount === null) {\n      deleteCount = 0;\n    } else {\n      deleteCount = Math.max(0, Math.min(deleteCount, length - index));\n    }\n\n    if (newItems === undefined) {\n      newItems = EMPTY_ARRAY;\n    }\n\n    if (hasInterceptors(this)) {\n      var change = interceptChange(this, {\n        object: this.proxy_,\n        type: SPLICE,\n        index: index,\n        removedCount: deleteCount,\n        added: newItems\n      });\n\n      if (!change) {\n        return EMPTY_ARRAY;\n      }\n\n      deleteCount = change.removedCount;\n      newItems = change.added;\n    }\n\n    newItems = newItems.length === 0 ? newItems : newItems.map(function (v) {\n      return _this.enhancer_(v, undefined);\n    });\n\n    if (this.legacyMode_ || process.env.NODE_ENV !== \"production\") {\n      var lengthDelta = newItems.length - deleteCount;\n      this.updateArrayLength_(length, lengthDelta); // checks if internal array wasn't modified\n    }\n\n    var res = this.spliceItemsIntoValues_(index, deleteCount, newItems);\n\n    if (deleteCount !== 0 || newItems.length !== 0) {\n      this.notifyArraySplice_(index, newItems, res);\n    }\n\n    return this.dehanceValues_(res);\n  };\n\n  _proto.spliceItemsIntoValues_ = function spliceItemsIntoValues_(index, deleteCount, newItems) {\n    if (newItems.length < MAX_SPLICE_SIZE) {\n      var _this$values_;\n\n      return (_this$values_ = this.values_).splice.apply(_this$values_, [index, deleteCount].concat(newItems));\n    } else {\n      // The items removed by the splice\n      var res = this.values_.slice(index, index + deleteCount); // The items that that should remain at the end of the array\n\n      var oldItems = this.values_.slice(index + deleteCount); // New length is the previous length + addition count - deletion count\n\n      this.values_.length += newItems.length - deleteCount;\n\n      for (var i = 0; i < newItems.length; i++) {\n        this.values_[index + i] = newItems[i];\n      }\n\n      for (var _i = 0; _i < oldItems.length; _i++) {\n        this.values_[index + newItems.length + _i] = oldItems[_i];\n      }\n\n      return res;\n    }\n  };\n\n  _proto.notifyArrayChildUpdate_ = function notifyArrayChildUpdate_(index, newValue, oldValue) {\n    var notifySpy = !this.owned_ && isSpyEnabled();\n    var notify = hasListeners(this);\n    var change = notify || notifySpy ? {\n      observableKind: \"array\",\n      object: this.proxy_,\n      type: UPDATE,\n      debugObjectName: this.atom_.name_,\n      index: index,\n      newValue: newValue,\n      oldValue: oldValue\n    } : null; // The reason why this is on right hand side here (and not above), is this way the uglifier will drop it, but it won't\n    // cause any runtime overhead in development mode without NODE_ENV set, unless spying is enabled\n\n    if (process.env.NODE_ENV !== \"production\" && notifySpy) {\n      spyReportStart(change);\n    }\n\n    this.atom_.reportChanged();\n\n    if (notify) {\n      notifyListeners(this, change);\n    }\n\n    if (process.env.NODE_ENV !== \"production\" && notifySpy) {\n      spyReportEnd();\n    }\n  };\n\n  _proto.notifyArraySplice_ = function notifyArraySplice_(index, added, removed) {\n    var notifySpy = !this.owned_ && isSpyEnabled();\n    var notify = hasListeners(this);\n    var change = notify || notifySpy ? {\n      observableKind: \"array\",\n      object: this.proxy_,\n      debugObjectName: this.atom_.name_,\n      type: SPLICE,\n      index: index,\n      removed: removed,\n      added: added,\n      removedCount: removed.length,\n      addedCount: added.length\n    } : null;\n\n    if (process.env.NODE_ENV !== \"production\" && notifySpy) {\n      spyReportStart(change);\n    }\n\n    this.atom_.reportChanged(); // conform: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/observe\n\n    if (notify) {\n      notifyListeners(this, change);\n    }\n\n    if (process.env.NODE_ENV !== \"production\" && notifySpy) {\n      spyReportEnd();\n    }\n  };\n\n  _proto.get_ = function get_(index) {\n    if (index < this.values_.length) {\n      this.atom_.reportObserved();\n      return this.dehanceValue_(this.values_[index]);\n    }\n\n    console.warn(process.env.NODE_ENV !== \"production\" ? \"[mobx] Out of bounds read: \" + index : \"[mobx.array] Attempt to read an array index (\" + index + \") that is out of bounds (\" + this.values_.length + \"). Please check length first. Out of bound indices will not be tracked by MobX\");\n  };\n\n  _proto.set_ = function set_(index, newValue) {\n    var values = this.values_;\n\n    if (index < values.length) {\n      // update at index in range\n      checkIfStateModificationsAreAllowed(this.atom_);\n      var oldValue = values[index];\n\n      if (hasInterceptors(this)) {\n        var change = interceptChange(this, {\n          type: UPDATE,\n          object: this.proxy_,\n          index: index,\n          newValue: newValue\n        });\n\n        if (!change) {\n          return;\n        }\n\n        newValue = change.newValue;\n      }\n\n      newValue = this.enhancer_(newValue, oldValue);\n      var changed = newValue !== oldValue;\n\n      if (changed) {\n        values[index] = newValue;\n        this.notifyArrayChildUpdate_(index, newValue, oldValue);\n      }\n    } else if (index === values.length) {\n      // add a new item\n      this.spliceWithArray_(index, 0, [newValue]);\n    } else {\n      // out of bounds\n      die(17, index, values.length);\n    }\n  };\n\n  return ObservableArrayAdministration;\n}();\nfunction createObservableArray(initialValues, enhancer, name, owned) {\n  if (name === void 0) {\n    name = process.env.NODE_ENV !== \"production\" ? \"ObservableArray@\" + getNextId() : \"ObservableArray\";\n  }\n\n  if (owned === void 0) {\n    owned = false;\n  }\n\n  assertProxies();\n  var adm = new ObservableArrayAdministration(name, enhancer, owned, false);\n  addHiddenFinalProp(adm.values_, $mobx, adm);\n  var proxy = new Proxy(adm.values_, arrayTraps);\n  adm.proxy_ = proxy;\n\n  if (initialValues && initialValues.length) {\n    var prev = allowStateChangesStart(true);\n    adm.spliceWithArray_(0, 0, initialValues);\n    allowStateChangesEnd(prev);\n  }\n\n  return proxy;\n} // eslint-disable-next-line\n\nvar arrayExtensions = {\n  clear: function clear() {\n    return this.splice(0);\n  },\n  replace: function replace(newItems) {\n    var adm = this[$mobx];\n    return adm.spliceWithArray_(0, adm.values_.length, newItems);\n  },\n  // Used by JSON.stringify\n  toJSON: function toJSON() {\n    return this.slice();\n  },\n\n  /*\r\n   * functions that do alter the internal structure of the array, (based on lib.es6.d.ts)\r\n   * since these functions alter the inner structure of the array, the have side effects.\r\n   * Because the have side effects, they should not be used in computed function,\r\n   * and for that reason the do not call dependencyState.notifyObserved\r\n   */\n  splice: function splice(index, deleteCount) {\n    for (var _len = arguments.length, newItems = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\n      newItems[_key - 2] = arguments[_key];\n    }\n\n    var adm = this[$mobx];\n\n    switch (arguments.length) {\n      case 0:\n        return [];\n\n      case 1:\n        return adm.spliceWithArray_(index);\n\n      case 2:\n        return adm.spliceWithArray_(index, deleteCount);\n    }\n\n    return adm.spliceWithArray_(index, deleteCount, newItems);\n  },\n  spliceWithArray: function spliceWithArray(index, deleteCount, newItems) {\n    return this[$mobx].spliceWithArray_(index, deleteCount, newItems);\n  },\n  push: function push() {\n    var adm = this[$mobx];\n\n    for (var _len2 = arguments.length, items = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      items[_key2] = arguments[_key2];\n    }\n\n    adm.spliceWithArray_(adm.values_.length, 0, items);\n    return adm.values_.length;\n  },\n  pop: function pop() {\n    return this.splice(Math.max(this[$mobx].values_.length - 1, 0), 1)[0];\n  },\n  shift: function shift() {\n    return this.splice(0, 1)[0];\n  },\n  unshift: function unshift() {\n    var adm = this[$mobx];\n\n    for (var _len3 = arguments.length, items = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n      items[_key3] = arguments[_key3];\n    }\n\n    adm.spliceWithArray_(0, 0, items);\n    return adm.values_.length;\n  },\n  reverse: function reverse() {\n    // reverse by default mutates in place before returning the result\n    // which makes it both a 'derivation' and a 'mutation'.\n    if (globalState.trackingDerivation) {\n      die(37, \"reverse\");\n    }\n\n    this.replace(this.slice().reverse());\n    return this;\n  },\n  sort: function sort() {\n    // sort by default mutates in place before returning the result\n    // which goes against all good practices. Let's not change the array in place!\n    if (globalState.trackingDerivation) {\n      die(37, \"sort\");\n    }\n\n    var copy = this.slice();\n    copy.sort.apply(copy, arguments);\n    this.replace(copy);\n    return this;\n  },\n  remove: function remove(value) {\n    var adm = this[$mobx];\n    var idx = adm.dehanceValues_(adm.values_).indexOf(value);\n\n    if (idx > -1) {\n      this.splice(idx, 1);\n      return true;\n    }\n\n    return false;\n  }\n};\n/**\r\n * Wrap function from prototype\r\n * Without this, everything works as well, but this works\r\n * faster as everything works on unproxied values\r\n */\n\naddArrayExtension(\"concat\", simpleFunc);\naddArrayExtension(\"flat\", simpleFunc);\naddArrayExtension(\"includes\", simpleFunc);\naddArrayExtension(\"indexOf\", simpleFunc);\naddArrayExtension(\"join\", simpleFunc);\naddArrayExtension(\"lastIndexOf\", simpleFunc);\naddArrayExtension(\"slice\", simpleFunc);\naddArrayExtension(\"toString\", simpleFunc);\naddArrayExtension(\"toLocaleString\", simpleFunc); // map\n\naddArrayExtension(\"every\", mapLikeFunc);\naddArrayExtension(\"filter\", mapLikeFunc);\naddArrayExtension(\"find\", mapLikeFunc);\naddArrayExtension(\"findIndex\", mapLikeFunc);\naddArrayExtension(\"flatMap\", mapLikeFunc);\naddArrayExtension(\"forEach\", mapLikeFunc);\naddArrayExtension(\"map\", mapLikeFunc);\naddArrayExtension(\"some\", mapLikeFunc); // reduce\n\naddArrayExtension(\"reduce\", reduceLikeFunc);\naddArrayExtension(\"reduceRight\", reduceLikeFunc);\n\nfunction addArrayExtension(funcName, funcFactory) {\n  if (typeof Array.prototype[funcName] === \"function\") {\n    arrayExtensions[funcName] = funcFactory(funcName);\n  }\n} // Report and delegate to dehanced array\n\n\nfunction simpleFunc(funcName) {\n  return function () {\n    var adm = this[$mobx];\n    adm.atom_.reportObserved();\n    var dehancedValues = adm.dehanceValues_(adm.values_);\n    return dehancedValues[funcName].apply(dehancedValues, arguments);\n  };\n} // Make sure callbacks recieve correct array arg #2326\n\n\nfunction mapLikeFunc(funcName) {\n  return function (callback, thisArg) {\n    var _this2 = this;\n\n    var adm = this[$mobx];\n    adm.atom_.reportObserved();\n    var dehancedValues = adm.dehanceValues_(adm.values_);\n    return dehancedValues[funcName](function (element, index) {\n      return callback.call(thisArg, element, index, _this2);\n    });\n  };\n} // Make sure callbacks recieve correct array arg #2326\n\n\nfunction reduceLikeFunc(funcName) {\n  return function () {\n    var _this3 = this;\n\n    var adm = this[$mobx];\n    adm.atom_.reportObserved();\n    var dehancedValues = adm.dehanceValues_(adm.values_); // #2432 - reduce behavior depends on arguments.length\n\n    var callback = arguments[0];\n\n    arguments[0] = function (accumulator, currentValue, index) {\n      return callback(accumulator, currentValue, index, _this3);\n    };\n\n    return dehancedValues[funcName].apply(dehancedValues, arguments);\n  };\n}\n\nvar isObservableArrayAdministration = /*#__PURE__*/createInstanceofPredicate(\"ObservableArrayAdministration\", ObservableArrayAdministration);\nfunction isObservableArray(thing) {\n  return isObject(thing) && isObservableArrayAdministration(thing[$mobx]);\n}\n\nvar _Symbol$iterator, _Symbol$toStringTag;\nvar ObservableMapMarker = {};\nvar ADD = \"add\";\nvar DELETE = \"delete\"; // just extend Map? See also https://gist.github.com/nestharus/13b4d74f2ef4a2f4357dbd3fc23c1e54\n// But: https://github.com/mobxjs/mobx/issues/1556\n\n_Symbol$iterator = Symbol.iterator;\n_Symbol$toStringTag = Symbol.toStringTag;\nvar ObservableMap = /*#__PURE__*/function () {\n  // hasMap, not hashMap >-).\n  function ObservableMap(initialData, enhancer_, name_) {\n    var _this = this;\n\n    if (enhancer_ === void 0) {\n      enhancer_ = deepEnhancer;\n    }\n\n    if (name_ === void 0) {\n      name_ = process.env.NODE_ENV !== \"production\" ? \"ObservableMap@\" + getNextId() : \"ObservableMap\";\n    }\n\n    this.enhancer_ = void 0;\n    this.name_ = void 0;\n    this[$mobx] = ObservableMapMarker;\n    this.data_ = void 0;\n    this.hasMap_ = void 0;\n    this.keysAtom_ = void 0;\n    this.interceptors_ = void 0;\n    this.changeListeners_ = void 0;\n    this.dehancer = void 0;\n    this.enhancer_ = enhancer_;\n    this.name_ = name_;\n\n    if (!isFunction(Map)) {\n      die(18);\n    }\n\n    this.keysAtom_ = createAtom(process.env.NODE_ENV !== \"production\" ? this.name_ + \".keys()\" : \"ObservableMap.keys()\");\n    this.data_ = new Map();\n    this.hasMap_ = new Map();\n    allowStateChanges(true, function () {\n      _this.merge(initialData);\n    });\n  }\n\n  var _proto = ObservableMap.prototype;\n\n  _proto.has_ = function has_(key) {\n    return this.data_.has(key);\n  };\n\n  _proto.has = function has(key) {\n    var _this2 = this;\n\n    if (!globalState.trackingDerivation) {\n      return this.has_(key);\n    }\n\n    var entry = this.hasMap_.get(key);\n\n    if (!entry) {\n      var newEntry = entry = new ObservableValue(this.has_(key), referenceEnhancer, process.env.NODE_ENV !== \"production\" ? this.name_ + \".\" + stringifyKey(key) + \"?\" : \"ObservableMap.key?\", false);\n      this.hasMap_.set(key, newEntry);\n      onBecomeUnobserved(newEntry, function () {\n        return _this2.hasMap_[\"delete\"](key);\n      });\n    }\n\n    return entry.get();\n  };\n\n  _proto.set = function set(key, value) {\n    var hasKey = this.has_(key);\n\n    if (hasInterceptors(this)) {\n      var change = interceptChange(this, {\n        type: hasKey ? UPDATE : ADD,\n        object: this,\n        newValue: value,\n        name: key\n      });\n\n      if (!change) {\n        return this;\n      }\n\n      value = change.newValue;\n    }\n\n    if (hasKey) {\n      this.updateValue_(key, value);\n    } else {\n      this.addValue_(key, value);\n    }\n\n    return this;\n  };\n\n  _proto[\"delete\"] = function _delete(key) {\n    var _this3 = this;\n\n    checkIfStateModificationsAreAllowed(this.keysAtom_);\n\n    if (hasInterceptors(this)) {\n      var change = interceptChange(this, {\n        type: DELETE,\n        object: this,\n        name: key\n      });\n\n      if (!change) {\n        return false;\n      }\n    }\n\n    if (this.has_(key)) {\n      var notifySpy = isSpyEnabled();\n      var notify = hasListeners(this);\n\n      var _change = notify || notifySpy ? {\n        observableKind: \"map\",\n        debugObjectName: this.name_,\n        type: DELETE,\n        object: this,\n        oldValue: this.data_.get(key).value_,\n        name: key\n      } : null;\n\n      if (process.env.NODE_ENV !== \"production\" && notifySpy) {\n        spyReportStart(_change);\n      } // TODO fix type\n\n\n      transaction(function () {\n        var _this3$hasMap_$get;\n\n        _this3.keysAtom_.reportChanged();\n\n        (_this3$hasMap_$get = _this3.hasMap_.get(key)) == null ? void 0 : _this3$hasMap_$get.setNewValue_(false);\n\n        var observable = _this3.data_.get(key);\n\n        observable.setNewValue_(undefined);\n\n        _this3.data_[\"delete\"](key);\n      });\n\n      if (notify) {\n        notifyListeners(this, _change);\n      }\n\n      if (process.env.NODE_ENV !== \"production\" && notifySpy) {\n        spyReportEnd();\n      }\n\n      return true;\n    }\n\n    return false;\n  };\n\n  _proto.updateValue_ = function updateValue_(key, newValue) {\n    var observable = this.data_.get(key);\n    newValue = observable.prepareNewValue_(newValue);\n\n    if (newValue !== globalState.UNCHANGED) {\n      var notifySpy = isSpyEnabled();\n      var notify = hasListeners(this);\n      var change = notify || notifySpy ? {\n        observableKind: \"map\",\n        debugObjectName: this.name_,\n        type: UPDATE,\n        object: this,\n        oldValue: observable.value_,\n        name: key,\n        newValue: newValue\n      } : null;\n\n      if (process.env.NODE_ENV !== \"production\" && notifySpy) {\n        spyReportStart(change);\n      } // TODO fix type\n\n\n      observable.setNewValue_(newValue);\n\n      if (notify) {\n        notifyListeners(this, change);\n      }\n\n      if (process.env.NODE_ENV !== \"production\" && notifySpy) {\n        spyReportEnd();\n      }\n    }\n  };\n\n  _proto.addValue_ = function addValue_(key, newValue) {\n    var _this4 = this;\n\n    checkIfStateModificationsAreAllowed(this.keysAtom_);\n    transaction(function () {\n      var _this4$hasMap_$get;\n\n      var observable = new ObservableValue(newValue, _this4.enhancer_, process.env.NODE_ENV !== \"production\" ? _this4.name_ + \".\" + stringifyKey(key) : \"ObservableMap.key\", false);\n\n      _this4.data_.set(key, observable);\n\n      newValue = observable.value_; // value might have been changed\n\n      (_this4$hasMap_$get = _this4.hasMap_.get(key)) == null ? void 0 : _this4$hasMap_$get.setNewValue_(true);\n\n      _this4.keysAtom_.reportChanged();\n    });\n    var notifySpy = isSpyEnabled();\n    var notify = hasListeners(this);\n    var change = notify || notifySpy ? {\n      observableKind: \"map\",\n      debugObjectName: this.name_,\n      type: ADD,\n      object: this,\n      name: key,\n      newValue: newValue\n    } : null;\n\n    if (process.env.NODE_ENV !== \"production\" && notifySpy) {\n      spyReportStart(change);\n    } // TODO fix type\n\n\n    if (notify) {\n      notifyListeners(this, change);\n    }\n\n    if (process.env.NODE_ENV !== \"production\" && notifySpy) {\n      spyReportEnd();\n    }\n  };\n\n  _proto.get = function get(key) {\n    if (this.has(key)) {\n      return this.dehanceValue_(this.data_.get(key).get());\n    }\n\n    return this.dehanceValue_(undefined);\n  };\n\n  _proto.dehanceValue_ = function dehanceValue_(value) {\n    if (this.dehancer !== undefined) {\n      return this.dehancer(value);\n    }\n\n    return value;\n  };\n\n  _proto.keys = function keys() {\n    this.keysAtom_.reportObserved();\n    return this.data_.keys();\n  };\n\n  _proto.values = function values() {\n    var self = this;\n    var keys = this.keys();\n    return makeIterable({\n      next: function next() {\n        var _keys$next = keys.next(),\n            done = _keys$next.done,\n            value = _keys$next.value;\n\n        return {\n          done: done,\n          value: done ? undefined : self.get(value)\n        };\n      }\n    });\n  };\n\n  _proto.entries = function entries() {\n    var self = this;\n    var keys = this.keys();\n    return makeIterable({\n      next: function next() {\n        var _keys$next2 = keys.next(),\n            done = _keys$next2.done,\n            value = _keys$next2.value;\n\n        return {\n          done: done,\n          value: done ? undefined : [value, self.get(value)]\n        };\n      }\n    });\n  };\n\n  _proto[_Symbol$iterator] = function () {\n    return this.entries();\n  };\n\n  _proto.forEach = function forEach(callback, thisArg) {\n    for (var _iterator = _createForOfIteratorHelperLoose(this), _step; !(_step = _iterator()).done;) {\n      var _step$value = _step.value,\n          key = _step$value[0],\n          value = _step$value[1];\n      callback.call(thisArg, value, key, this);\n    }\n  }\n  /** Merge another object into this object, returns this. */\n  ;\n\n  _proto.merge = function merge(other) {\n    var _this5 = this;\n\n    if (isObservableMap(other)) {\n      other = new Map(other);\n    }\n\n    transaction(function () {\n      if (isPlainObject(other)) {\n        getPlainObjectKeys(other).forEach(function (key) {\n          return _this5.set(key, other[key]);\n        });\n      } else if (Array.isArray(other)) {\n        other.forEach(function (_ref) {\n          var key = _ref[0],\n              value = _ref[1];\n          return _this5.set(key, value);\n        });\n      } else if (isES6Map(other)) {\n        if (other.constructor !== Map) {\n          die(19, other);\n        }\n\n        other.forEach(function (value, key) {\n          return _this5.set(key, value);\n        });\n      } else if (other !== null && other !== undefined) {\n        die(20, other);\n      }\n    });\n    return this;\n  };\n\n  _proto.clear = function clear() {\n    var _this6 = this;\n\n    transaction(function () {\n      untracked(function () {\n        for (var _iterator2 = _createForOfIteratorHelperLoose(_this6.keys()), _step2; !(_step2 = _iterator2()).done;) {\n          var key = _step2.value;\n\n          _this6[\"delete\"](key);\n        }\n      });\n    });\n  };\n\n  _proto.replace = function replace(values) {\n    var _this7 = this;\n\n    // Implementation requirements:\n    // - respect ordering of replacement map\n    // - allow interceptors to run and potentially prevent individual operations\n    // - don't recreate observables that already exist in original map (so we don't destroy existing subscriptions)\n    // - don't _keysAtom.reportChanged if the keys of resulting map are indentical (order matters!)\n    // - note that result map may differ from replacement map due to the interceptors\n    transaction(function () {\n      // Convert to map so we can do quick key lookups\n      var replacementMap = convertToMap(values);\n      var orderedData = new Map(); // Used for optimization\n\n      var keysReportChangedCalled = false; // Delete keys that don't exist in replacement map\n      // if the key deletion is prevented by interceptor\n      // add entry at the beginning of the result map\n\n      for (var _iterator3 = _createForOfIteratorHelperLoose(_this7.data_.keys()), _step3; !(_step3 = _iterator3()).done;) {\n        var key = _step3.value;\n\n        // Concurrently iterating/deleting keys\n        // iterator should handle this correctly\n        if (!replacementMap.has(key)) {\n          var deleted = _this7[\"delete\"](key); // Was the key removed?\n\n\n          if (deleted) {\n            // _keysAtom.reportChanged() was already called\n            keysReportChangedCalled = true;\n          } else {\n            // Delete prevented by interceptor\n            var value = _this7.data_.get(key);\n\n            orderedData.set(key, value);\n          }\n        }\n      } // Merge entries\n\n\n      for (var _iterator4 = _createForOfIteratorHelperLoose(replacementMap.entries()), _step4; !(_step4 = _iterator4()).done;) {\n        var _step4$value = _step4.value,\n            _key = _step4$value[0],\n            _value = _step4$value[1];\n\n        // We will want to know whether a new key is added\n        var keyExisted = _this7.data_.has(_key); // Add or update value\n\n\n        _this7.set(_key, _value); // The addition could have been prevent by interceptor\n\n\n        if (_this7.data_.has(_key)) {\n          // The update could have been prevented by interceptor\n          // and also we want to preserve existing values\n          // so use value from _data map (instead of replacement map)\n          var _value2 = _this7.data_.get(_key);\n\n          orderedData.set(_key, _value2); // Was a new key added?\n\n          if (!keyExisted) {\n            // _keysAtom.reportChanged() was already called\n            keysReportChangedCalled = true;\n          }\n        }\n      } // Check for possible key order change\n\n\n      if (!keysReportChangedCalled) {\n        if (_this7.data_.size !== orderedData.size) {\n          // If size differs, keys are definitely modified\n          _this7.keysAtom_.reportChanged();\n        } else {\n          var iter1 = _this7.data_.keys();\n\n          var iter2 = orderedData.keys();\n          var next1 = iter1.next();\n          var next2 = iter2.next();\n\n          while (!next1.done) {\n            if (next1.value !== next2.value) {\n              _this7.keysAtom_.reportChanged();\n\n              break;\n            }\n\n            next1 = iter1.next();\n            next2 = iter2.next();\n          }\n        }\n      } // Use correctly ordered map\n\n\n      _this7.data_ = orderedData;\n    });\n    return this;\n  };\n\n  _proto.toString = function toString() {\n    return \"[object ObservableMap]\";\n  };\n\n  _proto.toJSON = function toJSON() {\n    return Array.from(this);\n  };\n\n  /**\r\n   * Observes this object. Triggers for the events 'add', 'update' and 'delete'.\r\n   * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/observe\r\n   * for callback details\r\n   */\n  _proto.observe_ = function observe_(listener, fireImmediately) {\n    if (process.env.NODE_ENV !== \"production\" && fireImmediately === true) {\n      die(\"`observe` doesn't support fireImmediately=true in combination with maps.\");\n    }\n\n    return registerListener(this, listener);\n  };\n\n  _proto.intercept_ = function intercept_(handler) {\n    return registerInterceptor(this, handler);\n  };\n\n  _createClass(ObservableMap, [{\n    key: \"size\",\n    get: function get() {\n      this.keysAtom_.reportObserved();\n      return this.data_.size;\n    }\n  }, {\n    key: _Symbol$toStringTag,\n    get: function get() {\n      return \"Map\";\n    }\n  }]);\n\n  return ObservableMap;\n}(); // eslint-disable-next-line\n\nvar isObservableMap = /*#__PURE__*/createInstanceofPredicate(\"ObservableMap\", ObservableMap);\n\nfunction convertToMap(dataStructure) {\n  if (isES6Map(dataStructure) || isObservableMap(dataStructure)) {\n    return dataStructure;\n  } else if (Array.isArray(dataStructure)) {\n    return new Map(dataStructure);\n  } else if (isPlainObject(dataStructure)) {\n    var map = new Map();\n\n    for (var key in dataStructure) {\n      map.set(key, dataStructure[key]);\n    }\n\n    return map;\n  } else {\n    return die(21, dataStructure);\n  }\n}\n\nvar _Symbol$iterator$1, _Symbol$toStringTag$1;\nvar ObservableSetMarker = {};\n_Symbol$iterator$1 = Symbol.iterator;\n_Symbol$toStringTag$1 = Symbol.toStringTag;\nvar ObservableSet = /*#__PURE__*/function () {\n  function ObservableSet(initialData, enhancer, name_) {\n    if (enhancer === void 0) {\n      enhancer = deepEnhancer;\n    }\n\n    if (name_ === void 0) {\n      name_ = process.env.NODE_ENV !== \"production\" ? \"ObservableSet@\" + getNextId() : \"ObservableSet\";\n    }\n\n    this.name_ = void 0;\n    this[$mobx] = ObservableSetMarker;\n    this.data_ = new Set();\n    this.atom_ = void 0;\n    this.changeListeners_ = void 0;\n    this.interceptors_ = void 0;\n    this.dehancer = void 0;\n    this.enhancer_ = void 0;\n    this.name_ = name_;\n\n    if (!isFunction(Set)) {\n      die(22);\n    }\n\n    this.atom_ = createAtom(this.name_);\n\n    this.enhancer_ = function (newV, oldV) {\n      return enhancer(newV, oldV, name_);\n    };\n\n    if (initialData) {\n      this.replace(initialData);\n    }\n  }\n\n  var _proto = ObservableSet.prototype;\n\n  _proto.dehanceValue_ = function dehanceValue_(value) {\n    if (this.dehancer !== undefined) {\n      return this.dehancer(value);\n    }\n\n    return value;\n  };\n\n  _proto.clear = function clear() {\n    var _this = this;\n\n    transaction(function () {\n      untracked(function () {\n        for (var _iterator = _createForOfIteratorHelperLoose(_this.data_.values()), _step; !(_step = _iterator()).done;) {\n          var value = _step.value;\n\n          _this[\"delete\"](value);\n        }\n      });\n    });\n  };\n\n  _proto.forEach = function forEach(callbackFn, thisArg) {\n    for (var _iterator2 = _createForOfIteratorHelperLoose(this), _step2; !(_step2 = _iterator2()).done;) {\n      var value = _step2.value;\n      callbackFn.call(thisArg, value, value, this);\n    }\n  };\n\n  _proto.add = function add(value) {\n    var _this2 = this;\n\n    checkIfStateModificationsAreAllowed(this.atom_);\n\n    if (hasInterceptors(this)) {\n      var change = interceptChange(this, {\n        type: ADD,\n        object: this,\n        newValue: value\n      });\n\n      if (!change) {\n        return this;\n      } // ideally, value = change.value would be done here, so that values can be\n      // changed by interceptor. Same applies for other Set and Map api's.\n\n    }\n\n    if (!this.has(value)) {\n      transaction(function () {\n        _this2.data_.add(_this2.enhancer_(value, undefined));\n\n        _this2.atom_.reportChanged();\n      });\n      var notifySpy = process.env.NODE_ENV !== \"production\" && isSpyEnabled();\n      var notify = hasListeners(this);\n\n      var _change = notify || notifySpy ? {\n        observableKind: \"set\",\n        debugObjectName: this.name_,\n        type: ADD,\n        object: this,\n        newValue: value\n      } : null;\n\n      if (notifySpy && process.env.NODE_ENV !== \"production\") {\n        spyReportStart(_change);\n      }\n\n      if (notify) {\n        notifyListeners(this, _change);\n      }\n\n      if (notifySpy && process.env.NODE_ENV !== \"production\") {\n        spyReportEnd();\n      }\n    }\n\n    return this;\n  };\n\n  _proto[\"delete\"] = function _delete(value) {\n    var _this3 = this;\n\n    if (hasInterceptors(this)) {\n      var change = interceptChange(this, {\n        type: DELETE,\n        object: this,\n        oldValue: value\n      });\n\n      if (!change) {\n        return false;\n      }\n    }\n\n    if (this.has(value)) {\n      var notifySpy = process.env.NODE_ENV !== \"production\" && isSpyEnabled();\n      var notify = hasListeners(this);\n\n      var _change2 = notify || notifySpy ? {\n        observableKind: \"set\",\n        debugObjectName: this.name_,\n        type: DELETE,\n        object: this,\n        oldValue: value\n      } : null;\n\n      if (notifySpy && process.env.NODE_ENV !== \"production\") {\n        spyReportStart(_change2);\n      }\n\n      transaction(function () {\n        _this3.atom_.reportChanged();\n\n        _this3.data_[\"delete\"](value);\n      });\n\n      if (notify) {\n        notifyListeners(this, _change2);\n      }\n\n      if (notifySpy && process.env.NODE_ENV !== \"production\") {\n        spyReportEnd();\n      }\n\n      return true;\n    }\n\n    return false;\n  };\n\n  _proto.has = function has(value) {\n    this.atom_.reportObserved();\n    return this.data_.has(this.dehanceValue_(value));\n  };\n\n  _proto.entries = function entries() {\n    var nextIndex = 0;\n    var keys = Array.from(this.keys());\n    var values = Array.from(this.values());\n    return makeIterable({\n      next: function next() {\n        var index = nextIndex;\n        nextIndex += 1;\n        return index < values.length ? {\n          value: [keys[index], values[index]],\n          done: false\n        } : {\n          done: true\n        };\n      }\n    });\n  };\n\n  _proto.keys = function keys() {\n    return this.values();\n  };\n\n  _proto.values = function values() {\n    this.atom_.reportObserved();\n    var self = this;\n    var nextIndex = 0;\n    var observableValues = Array.from(this.data_.values());\n    return makeIterable({\n      next: function next() {\n        return nextIndex < observableValues.length ? {\n          value: self.dehanceValue_(observableValues[nextIndex++]),\n          done: false\n        } : {\n          done: true\n        };\n      }\n    });\n  };\n\n  _proto.replace = function replace(other) {\n    var _this4 = this;\n\n    if (isObservableSet(other)) {\n      other = new Set(other);\n    }\n\n    transaction(function () {\n      if (Array.isArray(other)) {\n        _this4.clear();\n\n        other.forEach(function (value) {\n          return _this4.add(value);\n        });\n      } else if (isES6Set(other)) {\n        _this4.clear();\n\n        other.forEach(function (value) {\n          return _this4.add(value);\n        });\n      } else if (other !== null && other !== undefined) {\n        die(\"Cannot initialize set from \" + other);\n      }\n    });\n    return this;\n  };\n\n  _proto.observe_ = function observe_(listener, fireImmediately) {\n    // ... 'fireImmediately' could also be true?\n    if (process.env.NODE_ENV !== \"production\" && fireImmediately === true) {\n      die(\"`observe` doesn't support fireImmediately=true in combination with sets.\");\n    }\n\n    return registerListener(this, listener);\n  };\n\n  _proto.intercept_ = function intercept_(handler) {\n    return registerInterceptor(this, handler);\n  };\n\n  _proto.toJSON = function toJSON() {\n    return Array.from(this);\n  };\n\n  _proto.toString = function toString() {\n    return \"[object ObservableSet]\";\n  };\n\n  _proto[_Symbol$iterator$1] = function () {\n    return this.values();\n  };\n\n  _createClass(ObservableSet, [{\n    key: \"size\",\n    get: function get() {\n      this.atom_.reportObserved();\n      return this.data_.size;\n    }\n  }, {\n    key: _Symbol$toStringTag$1,\n    get: function get() {\n      return \"Set\";\n    }\n  }]);\n\n  return ObservableSet;\n}(); // eslint-disable-next-line\n\nvar isObservableSet = /*#__PURE__*/createInstanceofPredicate(\"ObservableSet\", ObservableSet);\n\nvar descriptorCache = /*#__PURE__*/Object.create(null);\nvar REMOVE = \"remove\";\nvar ObservableObjectAdministration = /*#__PURE__*/function () {\n  function ObservableObjectAdministration(target_, values_, name_, // Used anytime annotation is not explicitely provided\n  defaultAnnotation_) {\n    if (values_ === void 0) {\n      values_ = new Map();\n    }\n\n    if (defaultAnnotation_ === void 0) {\n      defaultAnnotation_ = autoAnnotation;\n    }\n\n    this.target_ = void 0;\n    this.values_ = void 0;\n    this.name_ = void 0;\n    this.defaultAnnotation_ = void 0;\n    this.keysAtom_ = void 0;\n    this.changeListeners_ = void 0;\n    this.interceptors_ = void 0;\n    this.proxy_ = void 0;\n    this.isPlainObject_ = void 0;\n    this.appliedAnnotations_ = void 0;\n    this.pendingKeys_ = void 0;\n    this.target_ = target_;\n    this.values_ = values_;\n    this.name_ = name_;\n    this.defaultAnnotation_ = defaultAnnotation_;\n    this.keysAtom_ = new Atom(process.env.NODE_ENV !== \"production\" ? this.name_ + \".keys\" : \"ObservableObject.keys\"); // Optimization: we use this frequently\n\n    this.isPlainObject_ = isPlainObject(this.target_);\n\n    if (process.env.NODE_ENV !== \"production\" && !isAnnotation(this.defaultAnnotation_)) {\n      die(\"defaultAnnotation must be valid annotation\");\n    }\n\n    if (process.env.NODE_ENV !== \"production\") {\n      // Prepare structure for tracking which fields were already annotated\n      this.appliedAnnotations_ = {};\n    }\n  }\n\n  var _proto = ObservableObjectAdministration.prototype;\n\n  _proto.getObservablePropValue_ = function getObservablePropValue_(key) {\n    return this.values_.get(key).get();\n  };\n\n  _proto.setObservablePropValue_ = function setObservablePropValue_(key, newValue) {\n    var observable = this.values_.get(key);\n\n    if (observable instanceof ComputedValue) {\n      observable.set(newValue);\n      return true;\n    } // intercept\n\n\n    if (hasInterceptors(this)) {\n      var change = interceptChange(this, {\n        type: UPDATE,\n        object: this.proxy_ || this.target_,\n        name: key,\n        newValue: newValue\n      });\n\n      if (!change) {\n        return null;\n      }\n\n      newValue = change.newValue;\n    }\n\n    newValue = observable.prepareNewValue_(newValue); // notify spy & observers\n\n    if (newValue !== globalState.UNCHANGED) {\n      var notify = hasListeners(this);\n      var notifySpy = process.env.NODE_ENV !== \"production\" && isSpyEnabled();\n\n      var _change = notify || notifySpy ? {\n        type: UPDATE,\n        observableKind: \"object\",\n        debugObjectName: this.name_,\n        object: this.proxy_ || this.target_,\n        oldValue: observable.value_,\n        name: key,\n        newValue: newValue\n      } : null;\n\n      if (process.env.NODE_ENV !== \"production\" && notifySpy) {\n        spyReportStart(_change);\n      }\n      observable.setNewValue_(newValue);\n\n      if (notify) {\n        notifyListeners(this, _change);\n      }\n\n      if (process.env.NODE_ENV !== \"production\" && notifySpy) {\n        spyReportEnd();\n      }\n    }\n\n    return true;\n  };\n\n  _proto.get_ = function get_(key) {\n    if (globalState.trackingDerivation && !hasProp(this.target_, key)) {\n      // Key doesn't exist yet, subscribe for it in case it's added later\n      this.has_(key);\n    }\n\n    return this.target_[key];\n  }\n  /**\r\n   * @param {PropertyKey} key\r\n   * @param {any} value\r\n   * @param {Annotation|boolean} annotation true - use default annotation, false - copy as is\r\n   * @param {boolean} proxyTrap whether it's called from proxy trap\r\n   * @returns {boolean|null} true on success, false on failure (proxyTrap + non-configurable), null when cancelled by interceptor\r\n   */\n  ;\n\n  _proto.set_ = function set_(key, value, proxyTrap) {\n    if (proxyTrap === void 0) {\n      proxyTrap = false;\n    }\n\n    // Don't use .has(key) - we care about own\n    if (hasProp(this.target_, key)) {\n      // Existing prop\n      if (this.values_.has(key)) {\n        // Observable (can be intercepted)\n        return this.setObservablePropValue_(key, value);\n      } else if (proxyTrap) {\n        // Non-observable - proxy\n        return Reflect.set(this.target_, key, value);\n      } else {\n        // Non-observable\n        this.target_[key] = value;\n        return true;\n      }\n    } else {\n      // New prop\n      return this.extend_(key, {\n        value: value,\n        enumerable: true,\n        writable: true,\n        configurable: true\n      }, this.defaultAnnotation_, proxyTrap);\n    }\n  } // Trap for \"in\"\n  ;\n\n  _proto.has_ = function has_(key) {\n    if (!globalState.trackingDerivation) {\n      // Skip key subscription outside derivation\n      return key in this.target_;\n    }\n\n    this.pendingKeys_ || (this.pendingKeys_ = new Map());\n    var entry = this.pendingKeys_.get(key);\n\n    if (!entry) {\n      entry = new ObservableValue(key in this.target_, referenceEnhancer, process.env.NODE_ENV !== \"production\" ? this.name_ + \".\" + stringifyKey(key) + \"?\" : \"ObservableObject.key?\", false);\n      this.pendingKeys_.set(key, entry);\n    }\n\n    return entry.get();\n  }\n  /**\r\n   * @param {PropertyKey} key\r\n   * @param {Annotation|boolean} annotation true - use default annotation, false - ignore prop\r\n   */\n  ;\n\n  _proto.make_ = function make_(key, annotation) {\n    if (annotation === true) {\n      annotation = this.defaultAnnotation_;\n    }\n\n    if (annotation === false) {\n      return;\n    }\n\n    assertAnnotable(this, annotation, key);\n\n    if (!(key in this.target_)) {\n      var _this$target_$storedA;\n\n      // Throw on missing key, except for decorators:\n      // Decorator annotations are collected from whole prototype chain.\n      // When called from super() some props may not exist yet.\n      // However we don't have to worry about missing prop,\n      // because the decorator must have been applied to something.\n      if ((_this$target_$storedA = this.target_[storedAnnotationsSymbol]) != null && _this$target_$storedA[key]) {\n        return; // will be annotated by subclass constructor\n      } else {\n        die(1, annotation.annotationType_, this.name_ + \".\" + key.toString());\n      }\n    }\n\n    var source = this.target_;\n\n    while (source && source !== objectPrototype) {\n      var descriptor = getDescriptor(source, key);\n\n      if (descriptor) {\n        var outcome = annotation.make_(this, key, descriptor, source);\n\n        if (outcome === 0\n        /* Cancel */\n        ) {\n          return;\n        }\n\n        if (outcome === 1\n        /* Break */\n        ) {\n          break;\n        }\n      }\n\n      source = Object.getPrototypeOf(source);\n    }\n\n    recordAnnotationApplied(this, annotation, key);\n  }\n  /**\r\n   * @param {PropertyKey} key\r\n   * @param {PropertyDescriptor} descriptor\r\n   * @param {Annotation|boolean} annotation true - use default annotation, false - copy as is\r\n   * @param {boolean} proxyTrap whether it's called from proxy trap\r\n   * @returns {boolean|null} true on success, false on failure (proxyTrap + non-configurable), null when cancelled by interceptor\r\n   */\n  ;\n\n  _proto.extend_ = function extend_(key, descriptor, annotation, proxyTrap) {\n    if (proxyTrap === void 0) {\n      proxyTrap = false;\n    }\n\n    if (annotation === true) {\n      annotation = this.defaultAnnotation_;\n    }\n\n    if (annotation === false) {\n      return this.defineProperty_(key, descriptor, proxyTrap);\n    }\n\n    assertAnnotable(this, annotation, key);\n    var outcome = annotation.extend_(this, key, descriptor, proxyTrap);\n\n    if (outcome) {\n      recordAnnotationApplied(this, annotation, key);\n    }\n\n    return outcome;\n  }\n  /**\r\n   * @param {PropertyKey} key\r\n   * @param {PropertyDescriptor} descriptor\r\n   * @param {boolean} proxyTrap whether it's called from proxy trap\r\n   * @returns {boolean|null} true on success, false on failure (proxyTrap + non-configurable), null when cancelled by interceptor\r\n   */\n  ;\n\n  _proto.defineProperty_ = function defineProperty_(key, descriptor, proxyTrap) {\n    if (proxyTrap === void 0) {\n      proxyTrap = false;\n    }\n\n    try {\n      startBatch(); // Delete\n\n      var deleteOutcome = this.delete_(key);\n\n      if (!deleteOutcome) {\n        // Failure or intercepted\n        return deleteOutcome;\n      } // ADD interceptor\n\n\n      if (hasInterceptors(this)) {\n        var change = interceptChange(this, {\n          object: this.proxy_ || this.target_,\n          name: key,\n          type: ADD,\n          newValue: descriptor.value\n        });\n\n        if (!change) {\n          return null;\n        }\n\n        var newValue = change.newValue;\n\n        if (descriptor.value !== newValue) {\n          descriptor = _extends({}, descriptor, {\n            value: newValue\n          });\n        }\n      } // Define\n\n\n      if (proxyTrap) {\n        if (!Reflect.defineProperty(this.target_, key, descriptor)) {\n          return false;\n        }\n      } else {\n        defineProperty(this.target_, key, descriptor);\n      } // Notify\n\n\n      this.notifyPropertyAddition_(key, descriptor.value);\n    } finally {\n      endBatch();\n    }\n\n    return true;\n  } // If original descriptor becomes relevant, move this to annotation directly\n  ;\n\n  _proto.defineObservableProperty_ = function defineObservableProperty_(key, value, enhancer, proxyTrap) {\n    if (proxyTrap === void 0) {\n      proxyTrap = false;\n    }\n\n    try {\n      startBatch(); // Delete\n\n      var deleteOutcome = this.delete_(key);\n\n      if (!deleteOutcome) {\n        // Failure or intercepted\n        return deleteOutcome;\n      } // ADD interceptor\n\n\n      if (hasInterceptors(this)) {\n        var change = interceptChange(this, {\n          object: this.proxy_ || this.target_,\n          name: key,\n          type: ADD,\n          newValue: value\n        });\n\n        if (!change) {\n          return null;\n        }\n\n        value = change.newValue;\n      }\n\n      var cachedDescriptor = getCachedObservablePropDescriptor(key);\n      var descriptor = {\n        configurable: globalState.safeDescriptors ? this.isPlainObject_ : true,\n        enumerable: true,\n        get: cachedDescriptor.get,\n        set: cachedDescriptor.set\n      }; // Define\n\n      if (proxyTrap) {\n        if (!Reflect.defineProperty(this.target_, key, descriptor)) {\n          return false;\n        }\n      } else {\n        defineProperty(this.target_, key, descriptor);\n      }\n\n      var observable = new ObservableValue(value, enhancer, process.env.NODE_ENV !== \"production\" ? this.name_ + \".\" + key.toString() : \"ObservableObject.key\", false);\n      this.values_.set(key, observable); // Notify (value possibly changed by ObservableValue)\n\n      this.notifyPropertyAddition_(key, observable.value_);\n    } finally {\n      endBatch();\n    }\n\n    return true;\n  } // If original descriptor becomes relevant, move this to annotation directly\n  ;\n\n  _proto.defineComputedProperty_ = function defineComputedProperty_(key, options, proxyTrap) {\n    if (proxyTrap === void 0) {\n      proxyTrap = false;\n    }\n\n    try {\n      startBatch(); // Delete\n\n      var deleteOutcome = this.delete_(key);\n\n      if (!deleteOutcome) {\n        // Failure or intercepted\n        return deleteOutcome;\n      } // ADD interceptor\n\n\n      if (hasInterceptors(this)) {\n        var change = interceptChange(this, {\n          object: this.proxy_ || this.target_,\n          name: key,\n          type: ADD,\n          newValue: undefined\n        });\n\n        if (!change) {\n          return null;\n        }\n      }\n\n      options.name || (options.name = process.env.NODE_ENV !== \"production\" ? this.name_ + \".\" + key.toString() : \"ObservableObject.key\");\n      options.context = this.proxy_ || this.target_;\n      var cachedDescriptor = getCachedObservablePropDescriptor(key);\n      var descriptor = {\n        configurable: globalState.safeDescriptors ? this.isPlainObject_ : true,\n        enumerable: false,\n        get: cachedDescriptor.get,\n        set: cachedDescriptor.set\n      }; // Define\n\n      if (proxyTrap) {\n        if (!Reflect.defineProperty(this.target_, key, descriptor)) {\n          return false;\n        }\n      } else {\n        defineProperty(this.target_, key, descriptor);\n      }\n\n      this.values_.set(key, new ComputedValue(options)); // Notify\n\n      this.notifyPropertyAddition_(key, undefined);\n    } finally {\n      endBatch();\n    }\n\n    return true;\n  }\n  /**\r\n   * @param {PropertyKey} key\r\n   * @param {PropertyDescriptor} descriptor\r\n   * @param {boolean} proxyTrap whether it's called from proxy trap\r\n   * @returns {boolean|null} true on success, false on failure (proxyTrap + non-configurable), null when cancelled by interceptor\r\n   */\n  ;\n\n  _proto.delete_ = function delete_(key, proxyTrap) {\n    if (proxyTrap === void 0) {\n      proxyTrap = false;\n    }\n\n    // No such prop\n    if (!hasProp(this.target_, key)) {\n      return true;\n    } // Intercept\n\n\n    if (hasInterceptors(this)) {\n      var change = interceptChange(this, {\n        object: this.proxy_ || this.target_,\n        name: key,\n        type: REMOVE\n      }); // Cancelled\n\n      if (!change) {\n        return null;\n      }\n    } // Delete\n\n\n    try {\n      var _this$pendingKeys_, _this$pendingKeys_$ge;\n\n      startBatch();\n      var notify = hasListeners(this);\n      var notifySpy = process.env.NODE_ENV !== \"production\" && isSpyEnabled();\n      var observable = this.values_.get(key); // Value needed for spies/listeners\n\n      var value = undefined; // Optimization: don't pull the value unless we will need it\n\n      if (!observable && (notify || notifySpy)) {\n        var _getDescriptor;\n\n        value = (_getDescriptor = getDescriptor(this.target_, key)) == null ? void 0 : _getDescriptor.value;\n      } // delete prop (do first, may fail)\n\n\n      if (proxyTrap) {\n        if (!Reflect.deleteProperty(this.target_, key)) {\n          return false;\n        }\n      } else {\n        delete this.target_[key];\n      } // Allow re-annotating this field\n\n\n      if (process.env.NODE_ENV !== \"production\") {\n        delete this.appliedAnnotations_[key];\n      } // Clear observable\n\n\n      if (observable) {\n        this.values_[\"delete\"](key); // for computed, value is undefined\n\n        if (observable instanceof ObservableValue) {\n          value = observable.value_;\n        } // Notify: autorun(() => obj[key]), see #1796\n\n\n        propagateChanged(observable);\n      } // Notify \"keys/entries/values\" observers\n\n\n      this.keysAtom_.reportChanged(); // Notify \"has\" observers\n      // \"in\" as it may still exist in proto\n\n      (_this$pendingKeys_ = this.pendingKeys_) == null ? void 0 : (_this$pendingKeys_$ge = _this$pendingKeys_.get(key)) == null ? void 0 : _this$pendingKeys_$ge.set(key in this.target_); // Notify spies/listeners\n\n      if (notify || notifySpy) {\n        var _change2 = {\n          type: REMOVE,\n          observableKind: \"object\",\n          object: this.proxy_ || this.target_,\n          debugObjectName: this.name_,\n          oldValue: value,\n          name: key\n        };\n\n        if (process.env.NODE_ENV !== \"production\" && notifySpy) {\n          spyReportStart(_change2);\n        }\n\n        if (notify) {\n          notifyListeners(this, _change2);\n        }\n\n        if (process.env.NODE_ENV !== \"production\" && notifySpy) {\n          spyReportEnd();\n        }\n      }\n    } finally {\n      endBatch();\n    }\n\n    return true;\n  }\n  /**\r\n   * Observes this object. Triggers for the events 'add', 'update' and 'delete'.\r\n   * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/observe\r\n   * for callback details\r\n   */\n  ;\n\n  _proto.observe_ = function observe_(callback, fireImmediately) {\n    if (process.env.NODE_ENV !== \"production\" && fireImmediately === true) {\n      die(\"`observe` doesn't support the fire immediately property for observable objects.\");\n    }\n\n    return registerListener(this, callback);\n  };\n\n  _proto.intercept_ = function intercept_(handler) {\n    return registerInterceptor(this, handler);\n  };\n\n  _proto.notifyPropertyAddition_ = function notifyPropertyAddition_(key, value) {\n    var _this$pendingKeys_2, _this$pendingKeys_2$g;\n\n    var notify = hasListeners(this);\n    var notifySpy = process.env.NODE_ENV !== \"production\" && isSpyEnabled();\n\n    if (notify || notifySpy) {\n      var change = notify || notifySpy ? {\n        type: ADD,\n        observableKind: \"object\",\n        debugObjectName: this.name_,\n        object: this.proxy_ || this.target_,\n        name: key,\n        newValue: value\n      } : null;\n\n      if (process.env.NODE_ENV !== \"production\" && notifySpy) {\n        spyReportStart(change);\n      }\n\n      if (notify) {\n        notifyListeners(this, change);\n      }\n\n      if (process.env.NODE_ENV !== \"production\" && notifySpy) {\n        spyReportEnd();\n      }\n    }\n\n    (_this$pendingKeys_2 = this.pendingKeys_) == null ? void 0 : (_this$pendingKeys_2$g = _this$pendingKeys_2.get(key)) == null ? void 0 : _this$pendingKeys_2$g.set(true); // Notify \"keys/entries/values\" observers\n\n    this.keysAtom_.reportChanged();\n  };\n\n  _proto.ownKeys_ = function ownKeys_() {\n    this.keysAtom_.reportObserved();\n    return ownKeys(this.target_);\n  };\n\n  _proto.keys_ = function keys_() {\n    // Returns enumerable && own, but unfortunately keysAtom will report on ANY key change.\n    // There is no way to distinguish between Object.keys(object) and Reflect.ownKeys(object) - both are handled by ownKeys trap.\n    // We can either over-report in Object.keys(object) or under-report in Reflect.ownKeys(object)\n    // We choose to over-report in Object.keys(object), because:\n    // - typically it's used with simple data objects\n    // - when symbolic/non-enumerable keys are relevant Reflect.ownKeys works as expected\n    this.keysAtom_.reportObserved();\n    return Object.keys(this.target_);\n  };\n\n  return ObservableObjectAdministration;\n}();\nfunction asObservableObject(target, options) {\n  var _options$name;\n\n  if (process.env.NODE_ENV !== \"production\" && options && isObservableObject(target)) {\n    die(\"Options can't be provided for already observable objects.\");\n  }\n\n  if (hasProp(target, $mobx)) {\n    if (process.env.NODE_ENV !== \"production\" && !(getAdministration(target) instanceof ObservableObjectAdministration)) {\n      die(\"Cannot convert '\" + getDebugName(target) + \"' into observable object:\" + \"\\nThe target is already observable of different type.\" + \"\\nExtending builtins is not supported.\");\n    }\n\n    return target;\n  }\n\n  if (process.env.NODE_ENV !== \"production\" && !Object.isExtensible(target)) {\n    die(\"Cannot make the designated object observable; it is not extensible\");\n  }\n\n  var name = (_options$name = options == null ? void 0 : options.name) != null ? _options$name : process.env.NODE_ENV !== \"production\" ? (isPlainObject(target) ? \"ObservableObject\" : target.constructor.name) + \"@\" + getNextId() : \"ObservableObject\";\n  var adm = new ObservableObjectAdministration(target, new Map(), String(name), getAnnotationFromOptions(options));\n  addHiddenProp(target, $mobx, adm);\n  return target;\n}\nvar isObservableObjectAdministration = /*#__PURE__*/createInstanceofPredicate(\"ObservableObjectAdministration\", ObservableObjectAdministration);\n\nfunction getCachedObservablePropDescriptor(key) {\n  return descriptorCache[key] || (descriptorCache[key] = {\n    get: function get() {\n      return this[$mobx].getObservablePropValue_(key);\n    },\n    set: function set(value) {\n      return this[$mobx].setObservablePropValue_(key, value);\n    }\n  });\n}\n\nfunction isObservableObject(thing) {\n  if (isObject(thing)) {\n    return isObservableObjectAdministration(thing[$mobx]);\n  }\n\n  return false;\n}\nfunction recordAnnotationApplied(adm, annotation, key) {\n  var _adm$target_$storedAn;\n\n  if (process.env.NODE_ENV !== \"production\") {\n    adm.appliedAnnotations_[key] = annotation;\n  } // Remove applied decorator annotation so we don't try to apply it again in subclass constructor\n\n\n  (_adm$target_$storedAn = adm.target_[storedAnnotationsSymbol]) == null ? true : delete _adm$target_$storedAn[key];\n}\n\nfunction assertAnnotable(adm, annotation, key) {\n  // Valid annotation\n  if (process.env.NODE_ENV !== \"production\" && !isAnnotation(annotation)) {\n    die(\"Cannot annotate '\" + adm.name_ + \".\" + key.toString() + \"': Invalid annotation.\");\n  }\n  /*\r\n  // Configurable, not sealed, not frozen\r\n  // Possibly not needed, just a little better error then the one thrown by engine.\r\n  // Cases where this would be useful the most (subclass field initializer) are not interceptable by this.\r\n  if (__DEV__) {\r\n      const configurable = getDescriptor(adm.target_, key)?.configurable\r\n      const frozen = Object.isFrozen(adm.target_)\r\n      const sealed = Object.isSealed(adm.target_)\r\n      if (!configurable || frozen || sealed) {\r\n          const fieldName = `${adm.name_}.${key.toString()}`\r\n          const requestedAnnotationType = annotation.annotationType_\r\n          let error = `Cannot apply '${requestedAnnotationType}' to '${fieldName}':`\r\n          if (frozen) {\r\n              error += `\\nObject is frozen.`\r\n          }\r\n          if (sealed) {\r\n              error += `\\nObject is sealed.`\r\n          }\r\n          if (!configurable) {\r\n              error += `\\nproperty is not configurable.`\r\n              // Mention only if caused by us to avoid confusion\r\n              if (hasProp(adm.appliedAnnotations!, key)) {\r\n                  error += `\\nTo prevent accidental re-definition of a field by a subclass, `\r\n                  error += `all annotated fields of non-plain objects (classes) are not configurable.`\r\n              }\r\n          }\r\n          die(error)\r\n      }\r\n  }\r\n  */\n  // Not annotated\n\n\n  if (process.env.NODE_ENV !== \"production\" && !isOverride(annotation) && hasProp(adm.appliedAnnotations_, key)) {\n    var fieldName = adm.name_ + \".\" + key.toString();\n    var currentAnnotationType = adm.appliedAnnotations_[key].annotationType_;\n    var requestedAnnotationType = annotation.annotationType_;\n    die(\"Cannot apply '\" + requestedAnnotationType + \"' to '\" + fieldName + \"':\" + (\"\\nThe field is already annotated with '\" + currentAnnotationType + \"'.\") + \"\\nRe-annotating fields is not allowed.\" + \"\\nUse 'override' annotation for methods overridden by subclass.\");\n  }\n}\n\nvar ENTRY_0 = /*#__PURE__*/createArrayEntryDescriptor(0);\n/**\r\n * This array buffer contains two lists of properties, so that all arrays\r\n * can recycle their property definitions, which significantly improves performance of creating\r\n * properties on the fly.\r\n */\n\n\nvar OBSERVABLE_ARRAY_BUFFER_SIZE = 0; // Typescript workaround to make sure ObservableArray extends Array\n\nvar StubArray = function StubArray() {};\n\nfunction inherit(ctor, proto) {\n  if (Object.setPrototypeOf) {\n    Object.setPrototypeOf(ctor.prototype, proto);\n  } else if (ctor.prototype.__proto__ !== undefined) {\n    ctor.prototype.__proto__ = proto;\n  } else {\n    ctor.prototype = proto;\n  }\n}\n\ninherit(StubArray, Array.prototype); // Weex proto freeze protection was here,\n// but it is unclear why the hack is need as MobX never changed the prototype\n// anyway, so removed it in V6\n\nvar LegacyObservableArray = /*#__PURE__*/function (_StubArray, _Symbol$toStringTag, _Symbol$iterator) {\n  _inheritsLoose(LegacyObservableArray, _StubArray);\n\n  function LegacyObservableArray(initialValues, enhancer, name, owned) {\n    var _this;\n\n    if (name === void 0) {\n      name = process.env.NODE_ENV !== \"production\" ? \"ObservableArray@\" + getNextId() : \"ObservableArray\";\n    }\n\n    if (owned === void 0) {\n      owned = false;\n    }\n\n    _this = _StubArray.call(this) || this;\n    var adm = new ObservableArrayAdministration(name, enhancer, owned, true);\n    adm.proxy_ = _assertThisInitialized(_this);\n    addHiddenFinalProp(_assertThisInitialized(_this), $mobx, adm);\n\n    if (initialValues && initialValues.length) {\n      var prev = allowStateChangesStart(true); // @ts-ignore\n\n      _this.spliceWithArray(0, 0, initialValues);\n\n      allowStateChangesEnd(prev);\n    }\n\n    {\n      // Seems that Safari won't use numeric prototype setter untill any * numeric property is\n      // defined on the instance. After that it works fine, even if this property is deleted.\n      Object.defineProperty(_assertThisInitialized(_this), \"0\", ENTRY_0);\n    }\n\n    return _this;\n  }\n\n  var _proto = LegacyObservableArray.prototype;\n\n  _proto.concat = function concat() {\n    this[$mobx].atom_.reportObserved();\n\n    for (var _len = arguments.length, arrays = new Array(_len), _key = 0; _key < _len; _key++) {\n      arrays[_key] = arguments[_key];\n    }\n\n    return Array.prototype.concat.apply(this.slice(), //@ts-ignore\n    arrays.map(function (a) {\n      return isObservableArray(a) ? a.slice() : a;\n    }));\n  };\n\n  _proto[_Symbol$iterator] = function () {\n    var self = this;\n    var nextIndex = 0;\n    return makeIterable({\n      next: function next() {\n        return nextIndex < self.length ? {\n          value: self[nextIndex++],\n          done: false\n        } : {\n          done: true,\n          value: undefined\n        };\n      }\n    });\n  };\n\n  _createClass(LegacyObservableArray, [{\n    key: \"length\",\n    get: function get() {\n      return this[$mobx].getArrayLength_();\n    },\n    set: function set(newLength) {\n      this[$mobx].setArrayLength_(newLength);\n    }\n  }, {\n    key: _Symbol$toStringTag,\n    get: function get() {\n      return \"Array\";\n    }\n  }]);\n\n  return LegacyObservableArray;\n}(StubArray, Symbol.toStringTag, Symbol.iterator);\n\nObject.entries(arrayExtensions).forEach(function (_ref) {\n  var prop = _ref[0],\n      fn = _ref[1];\n\n  if (prop !== \"concat\") {\n    addHiddenProp(LegacyObservableArray.prototype, prop, fn);\n  }\n});\n\nfunction createArrayEntryDescriptor(index) {\n  return {\n    enumerable: false,\n    configurable: true,\n    get: function get() {\n      return this[$mobx].get_(index);\n    },\n    set: function set(value) {\n      this[$mobx].set_(index, value);\n    }\n  };\n}\n\nfunction createArrayBufferItem(index) {\n  defineProperty(LegacyObservableArray.prototype, \"\" + index, createArrayEntryDescriptor(index));\n}\n\nfunction reserveArrayBuffer(max) {\n  if (max > OBSERVABLE_ARRAY_BUFFER_SIZE) {\n    for (var index = OBSERVABLE_ARRAY_BUFFER_SIZE; index < max + 100; index++) {\n      createArrayBufferItem(index);\n    }\n\n    OBSERVABLE_ARRAY_BUFFER_SIZE = max;\n  }\n}\nreserveArrayBuffer(1000);\nfunction createLegacyArray(initialValues, enhancer, name) {\n  return new LegacyObservableArray(initialValues, enhancer, name);\n}\n\nfunction getAtom(thing, property) {\n  if (typeof thing === \"object\" && thing !== null) {\n    if (isObservableArray(thing)) {\n      if (property !== undefined) {\n        die(23);\n      }\n\n      return thing[$mobx].atom_;\n    }\n\n    if (isObservableSet(thing)) {\n      return thing[$mobx];\n    }\n\n    if (isObservableMap(thing)) {\n      if (property === undefined) {\n        return thing.keysAtom_;\n      }\n\n      var observable = thing.data_.get(property) || thing.hasMap_.get(property);\n\n      if (!observable) {\n        die(25, property, getDebugName(thing));\n      }\n\n      return observable;\n    }\n\n\n    if (isObservableObject(thing)) {\n      if (!property) {\n        return die(26);\n      }\n\n      var _observable = thing[$mobx].values_.get(property);\n\n      if (!_observable) {\n        die(27, property, getDebugName(thing));\n      }\n\n      return _observable;\n    }\n\n    if (isAtom(thing) || isComputedValue(thing) || isReaction(thing)) {\n      return thing;\n    }\n  } else if (isFunction(thing)) {\n    if (isReaction(thing[$mobx])) {\n      // disposer function\n      return thing[$mobx];\n    }\n  }\n\n  die(28);\n}\nfunction getAdministration(thing, property) {\n  if (!thing) {\n    die(29);\n  }\n\n  if (property !== undefined) {\n    return getAdministration(getAtom(thing, property));\n  }\n\n  if (isAtom(thing) || isComputedValue(thing) || isReaction(thing)) {\n    return thing;\n  }\n\n  if (isObservableMap(thing) || isObservableSet(thing)) {\n    return thing;\n  }\n\n  if (thing[$mobx]) {\n    return thing[$mobx];\n  }\n\n  die(24, thing);\n}\nfunction getDebugName(thing, property) {\n  var named;\n\n  if (property !== undefined) {\n    named = getAtom(thing, property);\n  } else if (isAction(thing)) {\n    return thing.name;\n  } else if (isObservableObject(thing) || isObservableMap(thing) || isObservableSet(thing)) {\n    named = getAdministration(thing);\n  } else {\n    // valid for arrays as well\n    named = getAtom(thing);\n  }\n\n  return named.name_;\n}\n\nvar toString = objectPrototype.toString;\nfunction deepEqual(a, b, depth) {\n  if (depth === void 0) {\n    depth = -1;\n  }\n\n  return eq(a, b, depth);\n} // Copied from https://github.com/jashkenas/underscore/blob/5c237a7c682fb68fd5378203f0bf22dce1624854/underscore.js#L1186-L1289\n// Internal recursive comparison function for `isEqual`.\n\nfunction eq(a, b, depth, aStack, bStack) {\n  // Identical objects are equal. `0 === -0`, but they aren't identical.\n  // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).\n  if (a === b) {\n    return a !== 0 || 1 / a === 1 / b;\n  } // `null` or `undefined` only equal to itself (strict comparison).\n\n\n  if (a == null || b == null) {\n    return false;\n  } // `NaN`s are equivalent, but non-reflexive.\n\n\n  if (a !== a) {\n    return b !== b;\n  } // Exhaust primitive checks\n\n\n  var type = typeof a;\n\n  if (type !== \"function\" && type !== \"object\" && typeof b != \"object\") {\n    return false;\n  } // Compare `[[Class]]` names.\n\n\n  var className = toString.call(a);\n\n  if (className !== toString.call(b)) {\n    return false;\n  }\n\n  switch (className) {\n    // Strings, numbers, regular expressions, dates, and booleans are compared by value.\n    case \"[object RegExp]\": // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')\n\n    case \"[object String]\":\n      // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n      // equivalent to `new String(\"5\")`.\n      return \"\" + a === \"\" + b;\n\n    case \"[object Number]\":\n      // `NaN`s are equivalent, but non-reflexive.\n      // Object(NaN) is equivalent to NaN.\n      if (+a !== +a) {\n        return +b !== +b;\n      } // An `egal` comparison is performed for other numeric values.\n\n\n      return +a === 0 ? 1 / +a === 1 / b : +a === +b;\n\n    case \"[object Date]\":\n    case \"[object Boolean]\":\n      // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n      // millisecond representations. Note that invalid dates with millisecond representations\n      // of `NaN` are not equivalent.\n      return +a === +b;\n\n    case \"[object Symbol]\":\n      return typeof Symbol !== \"undefined\" && Symbol.valueOf.call(a) === Symbol.valueOf.call(b);\n\n    case \"[object Map]\":\n    case \"[object Set]\":\n      // Maps and Sets are unwrapped to arrays of entry-pairs, adding an incidental level.\n      // Hide this extra level by increasing the depth.\n      if (depth >= 0) {\n        depth++;\n      }\n\n      break;\n  } // Unwrap any wrapped objects.\n\n\n  a = unwrap(a);\n  b = unwrap(b);\n  var areArrays = className === \"[object Array]\";\n\n  if (!areArrays) {\n    if (typeof a != \"object\" || typeof b != \"object\") {\n      return false;\n    } // Objects with different constructors are not equivalent, but `Object`s or `Array`s\n    // from different frames are.\n\n\n    var aCtor = a.constructor,\n        bCtor = b.constructor;\n\n    if (aCtor !== bCtor && !(isFunction(aCtor) && aCtor instanceof aCtor && isFunction(bCtor) && bCtor instanceof bCtor) && \"constructor\" in a && \"constructor\" in b) {\n      return false;\n    }\n  }\n\n  if (depth === 0) {\n    return false;\n  } else if (depth < 0) {\n    depth = -1;\n  } // Assume equality for cyclic structures. The algorithm for detecting cyclic\n  // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n  // Initializing stack of traversed objects.\n  // It's done here since we only need them for objects and arrays comparison.\n\n\n  aStack = aStack || [];\n  bStack = bStack || [];\n  var length = aStack.length;\n\n  while (length--) {\n    // Linear search. Performance is inversely proportional to the number of\n    // unique nested structures.\n    if (aStack[length] === a) {\n      return bStack[length] === b;\n    }\n  } // Add the first object to the stack of traversed objects.\n\n\n  aStack.push(a);\n  bStack.push(b); // Recursively compare objects and arrays.\n\n  if (areArrays) {\n    // Compare array lengths to determine if a deep comparison is necessary.\n    length = a.length;\n\n    if (length !== b.length) {\n      return false;\n    } // Deep compare the contents, ignoring non-numeric properties.\n\n\n    while (length--) {\n      if (!eq(a[length], b[length], depth - 1, aStack, bStack)) {\n        return false;\n      }\n    }\n  } else {\n    // Deep compare objects.\n    var keys = Object.keys(a);\n    var key;\n    length = keys.length; // Ensure that both objects contain the same number of properties before comparing deep equality.\n\n    if (Object.keys(b).length !== length) {\n      return false;\n    }\n\n    while (length--) {\n      // Deep compare each member\n      key = keys[length];\n\n      if (!(hasProp(b, key) && eq(a[key], b[key], depth - 1, aStack, bStack))) {\n        return false;\n      }\n    }\n  } // Remove the first object from the stack of traversed objects.\n\n\n  aStack.pop();\n  bStack.pop();\n  return true;\n}\n\nfunction unwrap(a) {\n  if (isObservableArray(a)) {\n    return a.slice();\n  }\n\n  if (isES6Map(a) || isObservableMap(a)) {\n    return Array.from(a.entries());\n  }\n\n  if (isES6Set(a) || isObservableSet(a)) {\n    return Array.from(a.entries());\n  }\n\n  return a;\n}\n\nfunction makeIterable(iterator) {\n  iterator[Symbol.iterator] = getSelf;\n  return iterator;\n}\n\nfunction getSelf() {\n  return this;\n}\n\nfunction isAnnotation(thing) {\n  return (// Can be function\n    thing instanceof Object && typeof thing.annotationType_ === \"string\" && isFunction(thing.make_) && isFunction(thing.extend_)\n  );\n}\n\n/**\r\n * (c) Michel Weststrate 2015 - 2020\r\n * MIT Licensed\r\n *\r\n * Welcome to the mobx sources! To get a global overview of how MobX internally works,\r\n * this is a good place to start:\r\n * https://medium.com/@mweststrate/becoming-fully-reactive-an-in-depth-explanation-of-mobservable-55995262a254#.xvbh6qd74\r\n *\r\n * Source folders:\r\n * ===============\r\n *\r\n * - api/     Most of the public static methods exposed by the module can be found here.\r\n * - core/    Implementation of the MobX algorithm; atoms, derivations, reactions, dependency trees, optimizations. Cool stuff can be found here.\r\n * - types/   All the magic that is need to have observable objects, arrays and values is in this folder. Including the modifiers like `asFlat`.\r\n * - utils/   Utility stuff.\r\n *\r\n */\n[\"Symbol\", \"Map\", \"Set\"].forEach(function (m) {\n  var g = getGlobal();\n\n  if (typeof g[m] === \"undefined\") {\n    die(\"MobX requires global '\" + m + \"' to be available or polyfilled\");\n  }\n});\n\nif (typeof __MOBX_DEVTOOLS_GLOBAL_HOOK__ === \"object\") {\n  // See: https://github.com/andykog/mobx-devtools/\n  __MOBX_DEVTOOLS_GLOBAL_HOOK__.injectMobx({\n    spy: spy,\n    extras: {\n      getDebugName: getDebugName\n    },\n    $mobx: $mobx\n  });\n}\n\nexport { $mobx, FlowCancellationError, ObservableMap, ObservableSet, Reaction, allowStateChanges as _allowStateChanges, runInAction as _allowStateChangesInsideComputed, allowStateReadsEnd as _allowStateReadsEnd, allowStateReadsStart as _allowStateReadsStart, autoAction as _autoAction, _endAction, getAdministration as _getAdministration, getGlobalState as _getGlobalState, interceptReads as _interceptReads, isComputingDerivation as _isComputingDerivation, resetGlobalState as _resetGlobalState, _startAction, action, autorun, comparer, computed, configure, createAtom, apiDefineProperty as defineProperty, entries, extendObservable, flow, flowResult, get, getAtom, getDebugName, getDependencyTree, getObserverTree, has, intercept, isAction, isObservableValue as isBoxedObservable, isComputed, isComputedProp, isFlow, isFlowCancellationError, isObservable, isObservableArray, isObservableMap, isObservableObject, isObservableProp, isObservableSet, keys, makeAutoObservable, makeObservable, observable, observe, onBecomeObserved, onBecomeUnobserved, onReactionError, override, apiOwnKeys as ownKeys, reaction, remove, runInAction, set, spy, toJS, trace, transaction, untracked, values, when };\n//# sourceMappingURL=mobx.esm.js.map\n","import { FC, lazy, memo, Suspense, useEffect, useState } from 'react';\n\nconst lazyLoadLottie: () => Promise<string> = async () => {\n  const lottie = (\n    await import(\n      /* webpackChunkName: 'cad-animations' */\n      /* webpackPrefetch: true */\n      `./loading-animation.lottie`\n    )\n  ).default;\n  return lottie;\n};\n\nexport const LoadingAnimation: FC<{}> = memo(() => {\n  const Lottie = lazy(() => import('react-lottie-player/dist/LottiePlayerLight'));\n\n  const [path, setPath] = useState<string>();\n\n  useEffect(() => {\n    const loadpath = async () => {\n      const pathData = await lazyLoadLottie();\n      setPath(pathData);\n    };\n\n    loadpath();\n  }, [path]);\n\n  return (\n    <Suspense fallback={null}>\n      <Lottie\n        className=\"chromatic-ignore\"\n        data-happo-hide\n        loop\n        path={path}\n        play\n        rendererSettings={{ preserveAspectRatio: 'xMidYMid meet' }}\n        style={{ backgroundColor: 'transparent', height: '100%', width: '100%' }}\n      />\n    </Suspense>\n  );\n});\n","import { FC } from 'react';\n\nimport * as DS from '@aurorasolar/ds';\nimport { styled, x } from '@xstyled/styled-components';\n\nimport { LoadingAnimation } from './loading-animation';\n\nconst LoadingText = styled.h1Box`\n  &::after {\n    display: inline-block;\n    animation: ellipsis 1s ease infinite;\n    content: '.';\n    width: 1em;\n    text-align: left;\n  }\n\n  @keyframes ellipsis {\n    0% {\n      content: '.';\n    }\n\n    33% {\n      content: '..';\n    }\n\n    66% {\n      content: '...';\n    }\n  }\n`;\n\nexport const CadLoadingPage: FC = () => {\n  return (\n    <DS.Flex alignItems=\"center\" flexDirection=\"column\" h=\"100%\" justifyContent=\"center\">\n      <DS.Box h=\"45%\" mb=\"7%\">\n        <LoadingAnimation />\n      </DS.Box>\n\n      <LoadingText data-chromatic=\"ignore\">Coming right up</LoadingText>\n\n      <x.h3 color=\"uiHelperCopy\" textAlign=\"center\">\n        Please wait while we load the design engine\n      </x.h3>\n    </DS.Flex>\n  );\n};\n","import { useRef } from 'react';\n\nexport const useOnceRef = <T>(fn: () => T) => {\n  const isInitialized = useRef(false);\n  const value = useRef(isInitialized.current ? (null as unknown as T) : fn());\n  isInitialized.current = true;\n  return value;\n};\n","/* eslint-disable react-hooks/exhaustive-deps */\nimport { useLocalObservable } from 'mobx-react-lite';\nimport { useCallback, useEffect, useRef, useState } from 'react';\nimport { effect } from './framework';\nimport { useOnceRef } from './use-once-ref';\n\n/**\n * `useReactive` is a hook that enables easy subscription to any MobX state.\n * The react component using the hook will subscribe to any reactive properties\n * accessed in `getReactive`, as well as deeply subscribe to any reactive objects\n * returned from it. Additionally, the hook can take a dependency array, shallow\n * changes to which will force `getReactive` to rerun and update the component's\n * reactive dependencies\n */\nexport const useReactive = <T>(\n  getReactive: () => T,\n  dependencyArray: ReadonlyArray<unknown> = [],\n) => {\n  const isWithinRender = useRef(true);\n  isWithinRender.current = true;\n\n  // `result` is a React ref holding the value returned from `getReactive`.\n  // `as unknown as T` here is safe because `result` will always initialize during the effect\n  const result = useRef(null as unknown as T);\n  const [, rerender] = useState(Symbol('useReactive'));\n\n  // Since `getReactive` is wrapped in `useCallback` with a dependency array, it'll change\n  // only when the dependency array is changed\n  const reactiveCallback = useCallback(getReactive, dependencyArray);\n  const lastReactiveCallbackRef = useRef(reactiveCallback);\n\n  // An observable for `getReactive` function which will be used in the effect\n  const reactiveObservable = useLocalObservable(() => ({\n    reactiveCallback,\n    setReactiveCallback: (newReactiveCallback: () => T) => {\n      reactiveObservable.reactiveCallback = newReactiveCallback;\n    },\n  }));\n\n  const stopEffect = useOnceRef(() =>\n    effect(\n      // Since we access `reactiveCallback` in this effect, when it is changed via\n      // `setReactiveCallback`, e.g. when the dependency array is modified, this effect\n      // will rerun as well\n      () => reactiveObservable.reactiveCallback(),\n      (value) => {\n        result.current = value;\n        // If the result is first initialized or changes due to the dependency array change\n        // during render, we do not need to rerender, but is rerendered upon other changes\n        if (!isWithinRender.current) {\n          rerender(Symbol('useReactive'));\n        }\n      },\n    ),\n  );\n\n  // The effect is stopped when component unmounts\n  useEffect(() => {\n    return () => {\n      stopEffect.current();\n    };\n  }, []);\n\n  // Upon dependency array change, if the callback is different, it'll recalculate\n  // the effect since it depends on it\n  if (lastReactiveCallbackRef.current !== reactiveCallback) {\n    lastReactiveCallbackRef.current = reactiveCallback;\n    reactiveObservable.setReactiveCallback(reactiveCallback);\n  }\n\n  isWithinRender.current = false;\n\n  // Returning the current value from `getReactive` since it'll be kept\n  // up to date due to rerendering\n  return result.current;\n};\n","import { createReactiveSetup, ViewSettingsLayers } from '@aurorasolar/cad-state';\nimport { DEFAULT_CAD_VIEWPORT_NAME } from './constants';\nimport {\n  CadViewportActionsScheduler,\n  createCadViewportActionsScheduler,\n} from './cad-viewport-action-scheduler';\nimport { CadViewCamera } from './camera-utils';\n\nconst createCadContainer = () => document.createElement('div');\n\nexport type CadViewportsData = {\n  // Default camera and layers are for storing camera and layer settings\n  // that have been provided upon CAD initialization. Final view settings\n  // for a given viewport will come from merging default settings with\n  // settings for that viewport\n  defaultCamera: null | CadViewCamera;\n  defaultLayers: null | ViewSettingsLayers;\n\n  // An array of all viewport names currently registered on the page\n  // to ensure only a single viewport of the same name is registered and\n  // to map a given viewport to a CAD container\n  viewports: Array<string>;\n\n  // When exclusive viewport name exists, all other CAD viewports are hidden\n  exclusiveViewportName: string | null;\n};\n\nexport type CadContainersData = {\n  // CAD containers for viewports specified in `CadViewportsData.viewports`.\n  // The index of the CAD containers matches the indices in `CadViewportsData.viewports`\n  cadContainers: Array<HTMLElement>;\n\n  // CAD container for a default viewport. Default viewport is the one with\n  // the name specified in DEFAULT_CAD_VIEWPORT_NAME. CAD always needs to have\n  // at least one viewport, and the viewport the engine is initialized with\n  // is the default viewport. The default viewport name can (and should) be reused\n  // just like any other viewport name, with the exception that it does not need\n  // to be explicitly added and removed from CAD because it'll always exist\n  defaultCadContainer: HTMLElement;\n};\n\nexport type CadPageViewportsActions = ReturnType<typeof createCadPageViewportsActions>;\n\nconst createCadViewportsData = (): CadViewportsData => {\n  return {\n    defaultCamera: null,\n    defaultLayers: null,\n    exclusiveViewportName: null,\n    viewports: [],\n  };\n};\n\n/**\n * Creates data for CAD containers. This needs to be separate from `CadViewportsData`\n * because we should avoid having HTML elements as part of reactive MobX data\n */\nconst createCadContainersData = (): CadContainersData => {\n  return {\n    cadContainers: [],\n    defaultCadContainer: createCadContainer(),\n  };\n};\n\nconst createCadPageViewportsActions = (\n  scheduler: CadViewportActionsScheduler,\n  data: CadViewportsData,\n  cadContainersData: CadContainersData,\n) => {\n  return {\n    addViewport: (name: string) => {\n      scheduler.scheduleAddViewport(() => {\n        if (data.viewports.indexOf(name) >= 0) {\n          throw new Error('Only one CAD view with the same \"name\" can be registered at once');\n        }\n\n        const { cadContainers, defaultCadContainer } = cadContainersData;\n\n        cadContainers.push(\n          name === DEFAULT_CAD_VIEWPORT_NAME ? defaultCadContainer : createCadContainer(),\n        );\n        data.viewports.push(name);\n      });\n    },\n\n    removeViewport: (name: string) => {\n      scheduler.scheduleRemoveViewport(() => {\n        const viewportIndex = data.viewports.indexOf(name);\n\n        if (viewportIndex >= 0) {\n          cadContainersData.cadContainers.splice(viewportIndex, 1);\n          data.viewports.splice(viewportIndex, 1);\n        }\n      });\n    },\n\n    setDefaultViewSettings: ({\n      camera,\n      layers,\n    }: {\n      camera?: null | CadViewCamera;\n      layers?: null | ViewSettingsLayers;\n    }) => {\n      if (layers !== undefined) {\n        data.defaultLayers = layers;\n      }\n      if (camera !== undefined) {\n        data.defaultCamera = camera;\n      }\n    },\n\n    setExclusiveViewportName: (newExclusiveViewportName: string | null) => {\n      data.exclusiveViewportName = newExclusiveViewportName;\n    },\n  };\n};\n\nexport const {\n  ReactiveContextProvider: CadPageViewportsStateProvider,\n  useReactiveState: useCadPageViewportsState,\n} = createReactiveSetup((makeReactive) => {\n  const data = makeReactive(createCadViewportsData());\n  const cadContainersData = createCadContainersData();\n  const scheduler = createCadViewportActionsScheduler(makeReactive);\n  const actions = makeReactive(createCadPageViewportsActions(scheduler, data, cadContainersData));\n  return {\n    actions,\n    cadContainersData,\n    data,\n  };\n});\n","import { createContext, FC, useContext } from 'react';\nimport { makeReactive, MakeReactive } from './framework';\nimport { useOnceRef } from './use-once-ref';\nimport { useReactive } from './use-reactive';\n\n/**\n * Creates hooks and providers that organize an instance of MobX state.\n * The state will be created when the provider mounts using the provided\n * `createState` function. `createState` takes `makeReactive` function as\n * an argument, which can be used to wrap objects and make them reactive.\n * The `useReactiveState` hook can be used to retrieve and automatically\n * subscribe to parts of the reactive state. `useReactiveState` takes a\n * function, whose first argument refers to the state; the component will\n * subscribe to anything accessed inside the function and deeply subscribe\n * to anything returned from the function. `useReactiveState` optionally\n * takes a dependency array, shallow changes to which will force\n * recalculation of the state and the component's dependencies\n */\nexport const createReactiveSetup = <State extends object>(\n  createState: (makeReactive: MakeReactive) => State,\n) => {\n  const ReactiveContext = createContext<State | null>(null);\n\n  const useReactiveContext = () => {\n    const result = useContext(ReactiveContext);\n    if (!result) {\n      throw new Error('Cannot use reactive context outside of corresponding reactive context');\n    }\n    return result;\n  };\n\n  const ReactiveContextProvider: FC = ({ children }) => {\n    const reactiveContextRef = useOnceRef(() => createState(makeReactive));\n    return (\n      <ReactiveContext.Provider value={reactiveContextRef.current}>\n        {children}\n      </ReactiveContext.Provider>\n    );\n  };\n\n  const useReactiveState = <T,>(\n    fn: (state: State) => T,\n    dependencyArray: ReadonlyArray<unknown> = [],\n  ) => {\n    const reactiveContext = useReactiveContext();\n    return useReactive(() => fn(reactiveContext), dependencyArray);\n  };\n\n  return { ReactiveContextProvider, useReactiveState };\n};\n","export type CadViewportActionsScheduler = ReturnType<typeof createCadViewportActionsScheduler>;\n\n/**\n * This is a workaround that ensures that `addViewport` is not called in the same\n * frame as `removeViewport`. This prevents a bug in CAD where, if the viewport\n * with the same `viewportName` is first removed, then added back in the same frame,\n * it would cause the viewport to break and not display anything\n */\nexport const createCadViewportActionsScheduler = (\n  makeReactive: <T extends object>(value: T) => T,\n) => {\n  const scheduledActions: Array<{ action: () => void; done: boolean; type: 'add' | 'remove' }> = [];\n\n  const { processActions } = makeReactive({\n    processActions: () => {\n      // Finding the first action that hasn't been done yet\n      let currentActionIndex = scheduledActions.findIndex(\n        (scheduledAction) => !scheduledAction.done,\n      );\n\n      if (currentActionIndex >= 0) {\n        const currentActionType = scheduledActions[currentActionIndex].type;\n\n        // Running all consecutive actions of the same type\n        for (; currentActionIndex < scheduledActions.length; currentActionIndex += 1) {\n          const scheduledAction = scheduledActions[currentActionIndex];\n          if (scheduledAction.type !== currentActionType) {\n            break;\n          } else {\n            scheduledAction.action();\n            scheduledAction.done = true;\n          }\n        }\n\n        // Removing all actions that have been done\n        scheduledActions.splice(0, currentActionIndex);\n      } else {\n        scheduledActions.splice(0, scheduledActions.length);\n      }\n\n      // All remaining actions should be run in the next frame\n      if (scheduledActions.length > 0) {\n        requestAnimationFrame(processActions);\n      }\n    },\n  });\n\n  return makeReactive({\n    scheduleAddViewport: (action: () => void) => {\n      if (scheduledActions.length === 0) {\n        requestAnimationFrame(processActions);\n      }\n      if (\n        scheduledActions.some(\n          (scheduledAction) => !scheduledAction.done || scheduledAction.type === 'remove',\n        )\n      ) {\n        scheduledActions.push({ action, done: false, type: 'add' });\n      } else {\n        action();\n        scheduledActions.push({ action, done: true, type: 'add' });\n      }\n    },\n\n    scheduleRemoveViewport: (action: () => void) => {\n      if (scheduledActions.length === 0) {\n        requestAnimationFrame(processActions);\n      }\n      if (\n        scheduledActions.some(\n          (scheduledAction) => !scheduledAction.done || scheduledAction.type === 'add',\n        )\n      ) {\n        scheduledActions.push({ action, done: false, type: 'remove' });\n      } else {\n        action();\n        scheduledActions.push({ action, done: true, type: 'remove' });\n      }\n    },\n  });\n};\n","export const DEFAULT_CAD_VIEWPORT_NAME = 'design-3d';\nexport const CAD_VIEWPORT_MIN_HEIGHT = '268px';\n","import { createContext, FC, useContext } from 'react';\nimport { Subject } from 'rxjs';\n\nimport { CadPreferences } from '@aurorasolar/cad-preferences';\nimport { CadState, useLocalObservable, useReactive } from '@aurorasolar/cad-state';\nimport { CadEvent, CadEventTypes } from '@aurorasolar/common-data-store';\nimport { CadEngine } from '@aurorasolar/common-module-loader';\nimport { CadPageViewportsStateProvider } from '../cad-viewport/cad-page-viewports-state';\n\ntype CadContextLoadedValue = {\n  designId: string;\n  engine: CadEngine;\n  engineSaveFn: null | ((options?: { saveScreenshot?: boolean }) => Promise<void>);\n  eventStream: Subject<CadEvent<CadEventTypes>> | null;\n  domNode: HTMLElement;\n  state: CadState;\n  preferences: CadPreferences;\n};\n\ntype CadContextInitialValue = {\n  [K in keyof CadContextLoadedValue]?: null;\n};\n\ntype CadInitializerContextValue = {\n  setCadContext: (cadContext: CadContextLoadedValue) => void;\n  clearCadContext: () => void;\n  setCadError: (error: Error) => void;\n};\n\ntype CadInitializerContextType = null | CadInitializerContextValue;\n\nexport enum CadStatus {\n  Loading,\n  Loaded,\n  Error,\n}\n\nexport type CadContextValue =\n  | ({\n      status: CadStatus.Loaded;\n      error: null;\n      isLoaded: true;\n    } & CadContextLoadedValue)\n  | ({\n      status: CadStatus.Loading;\n      error: null;\n      isLoaded: false;\n    } & CadContextInitialValue)\n  | ({\n      status: CadStatus.Error;\n      error: Error;\n      isLoaded: false;\n    } & CadContextInitialValue);\n\nexport type CadContextType = null | CadContextValue;\n\nexport const CadContext = createContext<CadContextType>(null);\n\nconst CadInitializerContext = createContext<CadInitializerContextType>(null);\n\nexport const useOptionalCadContext = () => {\n  const context = useContext(CadContext);\n  // Making sure component rerenders when `status` changes:\n  useReactive(() => context?.status, [context]);\n  return context;\n};\n\nexport const useCadContext = () => {\n  const context = useOptionalCadContext();\n  if (!context) {\n    throw new Error('Cad context is not provided');\n  }\n  return context;\n};\n\n/**\n * Only for use in `useCad` hook. Exposes functions to initialize and clear\n * cad context\n */\nexport const useCadInitializerContext = () => {\n  const context = useContext(CadInitializerContext);\n\n  if (!context) {\n    throw new Error('Cad context is not provided');\n  }\n\n  return context;\n};\n\nconst initialCadContext: Required<CadContextInitialValue> = {\n  designId: null,\n  domNode: null,\n  engine: null,\n  engineSaveFn: null,\n  eventStream: null,\n  preferences: null,\n  state: null,\n};\n\nexport const CadContextProvider: FC = ({ children }) => {\n  const cadContext: CadContextValue = useLocalObservable<CadContextValue>(() => ({\n    error: null,\n    isLoaded: false,\n    status: CadStatus.Loading,\n    ...initialCadContext,\n  }));\n  const cadContextInitializer = useLocalObservable<CadInitializerContextValue>(() => ({\n    clearCadContext() {\n      const fullContext: CadContextValue = {\n        error: null,\n        isLoaded: false,\n        status: CadStatus.Loading,\n        ...initialCadContext,\n      };\n      Object.assign(cadContext, fullContext);\n    },\n    setCadContext(newCadContext) {\n      const fullContext: CadContextValue = {\n        error: null,\n        isLoaded: true,\n        status: CadStatus.Loaded,\n        ...newCadContext,\n      };\n      Object.assign(cadContext, fullContext);\n    },\n    setCadError(error) {\n      const fullContext: CadContextValue = {\n        error,\n        isLoaded: false,\n        status: CadStatus.Error,\n        ...initialCadContext,\n      };\n      Object.assign(cadContext, fullContext);\n    },\n  }));\n  return (\n    <CadContext.Provider value={cadContext}>\n      <CadInitializerContext.Provider value={cadContextInitializer}>\n        <CadPageViewportsStateProvider>{children}</CadPageViewportsStateProvider>\n      </CadInitializerContext.Provider>\n    </CadContext.Provider>\n  );\n};\n","// @ts-ignore: Ignore unused { * as Types } import\nimport * as Types from '@aurorasolar/graphql-client-schema';\n\nimport { gql } from '@apollo/client';\nimport { CadRequiredComponentPropertiesFragmentDoc } from '../../data-access-layer/src/graphql/cad-electrical-components-fragment.generated';\nimport * as Apollo from '@apollo/client';\nconst defaultOptions = {} as const;\nexport type IsLidarAvailableQueryVariables = Types.Exact<{ [key: string]: never; }>;\n\n\nexport type IsLidarAvailableQuery = { __typename: 'Query', lidarController?: { __typename: 'LidarController', lidarAvailable?: boolean | null | undefined } | null | undefined };\n\nexport type CadProvideTenantInfoQueryVariables = Types.Exact<{ [key: string]: never; }>;\n\n\nexport type CadProvideTenantInfoQuery = { __typename: 'Query', apiInfo: { __typename: 'ApiInfo', tenant: { __typename: 'Tenant', id: string, temperatureUnit: Types.TemperatureUnit, units: Types.UnitSystem } } };\n\nexport type CadProvideProjectIdQueryVariables = Types.Exact<{\n  id: Types.Scalars['ID'];\n}>;\n\n\nexport type CadProvideProjectIdQuery = { __typename: 'Query', designById: { __typename: 'Design', project: { __typename: 'Project', id: string } } };\n\nexport type CadProvideProjectTypeQueryVariables = Types.Exact<{\n  id: Types.Scalars['ID'];\n}>;\n\n\nexport type CadProvideProjectTypeQuery = { __typename: 'Query', designById: { __typename: 'Design', project: { __typename: 'Project', projectType: Types.ProjectType } } };\n\nexport type CadProvideModuleSpacingSettingsQueryVariables = Types.Exact<{\n  id: Types.Scalars['ID'];\n}>;\n\n\nexport type CadProvideModuleSpacingSettingsQuery = { __typename: 'Query', design: { __typename: 'Design', rowSpacing?: number | null | undefined, interModuleSpacingX?: number | null | undefined, interModuleSpacingY?: number | null | undefined }, tenantSettings: { __typename: 'TenantConfigurationSettings', pitchedX?: { __typename: 'ConfigurationSettingFloat', value?: number | null | undefined } | null | undefined, pitchedY?: { __typename: 'ConfigurationSettingFloat', value?: number | null | undefined } | null | undefined, flatX?: { __typename: 'ConfigurationSettingFloat', value?: number | null | undefined } | null | undefined, flatY?: { __typename: 'ConfigurationSettingFloat', value?: number | null | undefined } | null | undefined, pitchedThreshold?: { __typename: 'ConfigurationSettingFloat', value?: number | null | undefined } | null | undefined } };\n\nexport type CadProvideTenantIdQueryVariables = Types.Exact<{\n  id: Types.Scalars['ID'];\n}>;\n\n\nexport type CadProvideTenantIdQuery = { __typename: 'Query', userById: { __typename: 'User', tenant?: { __typename: 'Tenant', id: string } | null | undefined } };\n\nexport type CadProvideDesignQueryVariables = Types.Exact<{\n  id: Types.Scalars['ID'];\n}>;\n\n\nexport type CadProvideDesignQuery = { __typename: 'Query', designById: { __typename: 'Design', longitude: number, latitude: number, savedFromNewCad: boolean, irradianceMapId?: string | null | undefined, irradianceMapStatus?: string | null | undefined, irradiancePanelsId?: string | null | undefined, irradiancePanelsStatus?: string | null | undefined, temperatureMax?: number | null | undefined, temperatureMin?: number | null | undefined, geodataBaseUrl?: string | null | undefined, geodataParentId?: number | null | undefined } };\n\nexport type CadProvideLeadCaptureDataQueryVariables = Types.Exact<{\n  id: Types.Scalars['ID'];\n}>;\n\n\nexport type CadProvideLeadCaptureDataQuery = { __typename: 'Query', getLeadCaptureProjectData: { __typename: 'LeadCaptureProject', id: string, location?: { __typename: 'LeadCaptureLocation', latitude: number, longitude: number } | null | undefined, pointCloud?: { __typename: 'LeadCapturePointCloud', id: string, data?: any | null | undefined } | null | undefined, image?: { __typename: 'LeadCaptureImage', id: string, dataUrl: string, worldfile: { __typename: 'Worldfile', a?: number | null | undefined, b?: number | null | undefined, c?: number | null | undefined, e?: number | null | undefined, d?: number | null | undefined, f?: number | null | undefined }, dimensions: { __typename: 'GeodataDimensions', height?: number | null | undefined, width?: number | null | undefined }, orthoImage: { __typename: 'OrthoImage', id: string, source: Types.OrthoImageSource, url?: string | null | undefined, name: string, active: boolean, opacity?: number | null | undefined, width?: number | null | undefined, height?: number | null | undefined, worldfileA?: number | null | undefined, worldfileB?: number | null | undefined, worldfileC?: number | null | undefined, worldfileD?: number | null | undefined, worldfileE?: number | null | undefined, worldfileF?: number | null | undefined, resource?: { __typename: 'GeodataResource', id?: string | null | undefined, source: string, url?: string | null | undefined, type: Types.GeodataResourceType, worldfile?: { __typename: 'Worldfile', a?: number | null | undefined, b?: number | null | undefined, c?: number | null | undefined, e?: number | null | undefined, d?: number | null | undefined, f?: number | null | undefined } | null | undefined, dimensions?: { __typename: 'GeodataDimensions', width?: number | null | undefined, height?: number | null | undefined } | null | undefined, metadata?: { __typename: 'GeodataMeta', opacity?: number | null | undefined, name?: string | null | undefined } | null | undefined } | null | undefined } } | null | undefined, site?: { __typename: 'LeadCaptureSite', id: string, data?: { __typename: 'LeadCaptureCadSite', baseElevation: number, centerLat: number, centerLng: number, roofPlanes: Array<{ __typename: 'LeadCaptureCadRoofPlane', height: number, pitch: number, azimuthEdgeIndex: number, shell: Array<{ __typename: 'LeadCaptureCadRoofPlaneNode', x: number, y: number, edgeType: string }>, holes: Array<Array<{ __typename: 'LeadCaptureCadRoofPlaneNode', x: number, y: number, edgeType: string }> | null | undefined> }>, obstructions: Array<{ __typename: 'LeadCaptureCadObstruction', shape: string, center: Array<number>, azimuthVector: Array<number>, radius?: number | null | undefined, width?: number | null | undefined, length?: number | null | undefined, flush: boolean, heightAbove?: number | null | undefined, confidence: number }> } | null | undefined } | null | undefined, irradianceMap?: { __typename: 'LeadCaptureIrradianceMap', id: string, annualUrl?: string | null | undefined, monthlyUrl?: string | null | undefined, metaUrl?: string | null | undefined } | null | undefined, scenarios: Array<{ __typename: 'LeadCaptureScenario', energyTarget?: number | null | undefined, design?: { __typename: 'LeadCaptureDesign', id: string, data?: any | null | undefined } | null | undefined, irradiancePanels?: { __typename: 'LeadCaptureIrradiancePanels', id: string, annualUrl?: string | null | undefined, monthlyUrl?: string | null | undefined, metaUrl?: string | null | undefined } | null | undefined }> } };\n\nexport type CadProvidePricePerWattQueryVariables = Types.Exact<{\n  id: Types.Scalars['ID'];\n}>;\n\n\nexport type CadProvidePricePerWattQuery = { __typename: 'Query', designById: { __typename: 'Design', pricePerWatt?: number | null | undefined } };\n\nexport type CadProvideTimeZoneOffsetQueryVariables = Types.Exact<{\n  id: Types.Scalars['ID'];\n}>;\n\n\nexport type CadProvideTimeZoneOffsetQuery = { __typename: 'Query', designById: { __typename: 'Design', project: { __typename: 'Project', timeZoneOffset?: number | null | undefined } } };\n\nexport type CadProvideTemplatesJsonQueryVariables = Types.Exact<{\n  id: Types.Scalars['ID'];\n}>;\n\n\nexport type CadProvideTemplatesJsonQuery = { __typename: 'Query', designById: { __typename: 'Design', templatesJson?: any | null | undefined } };\n\nexport type CadProvideSolarPanelQueryVariables = Types.Exact<{\n  id: Types.Scalars['ID'];\n}>;\n\n\nexport type CadProvideSolarPanelQuery = { __typename: 'Query', component?: { __typename: 'SolarPanel', efficiency?: number | null | undefined, height?: number | null | undefined, imp?: number | null | undefined, isc?: number | null | undefined, length?: number | null | undefined, noct?: number | null | undefined, panelType?: string | null | undefined, price?: number | null | undefined, ratingPtc?: number | null | undefined, ratingStc?: number | null | undefined, tempCoeffIsc?: number | null | undefined, tempCoeffPmax?: number | null | undefined, tempCoeffVoc?: number | null | undefined, vmp?: number | null | undefined, voc?: number | null | undefined, width?: number | null | undefined, id: string, name?: string | null | undefined, manufacturer?: { __typename: 'Manufacturer', id: string, displayName?: string | null | undefined, name?: string | null | undefined } | null | undefined, mlpe?: { __typename: 'MLPE', id: string, type?: string | null | undefined, isSolarInverter?: boolean | null | undefined, isDcOptimizer?: boolean | null | undefined, isCellStringOptimizer?: boolean | null | undefined, solarInverter?: { __typename: 'SolarInverter', id: string, efficiencyCec?: number | null | undefined, efficiencyEuropean?: number | null | undefined, efficiencyMax?: number | null | undefined, hasExternalMppt?: boolean | null | undefined, hasGlobalMppt?: boolean | null | undefined, inputVoltageMax?: number | null | undefined, inputVoltageMin?: number | null | undefined, inputVoltageSE?: number | null | undefined, isHuawei?: boolean | null | undefined, isSolarEdge?: boolean | null | undefined, isMicroinverter?: boolean | null | undefined, mpptRatedPowerVoltageMax?: number | null | undefined, mpptRatedPowerVoltageMin?: number | null | undefined, mppts?: number | null | undefined, name?: string | null | undefined, numPhases?: number | null | undefined, numPhysicalDcInputs?: number | null | undefined, outputCurrent?: number | null | undefined, outputVoltageNominal?: number | null | undefined, price?: number | null | undefined, ratedPower?: number | null | undefined, usableInputCurrentMax?: number | null | undefined, usableInputPowerMax?: number | null | undefined, manufacturer?: { __typename: 'Manufacturer', id: string, displayName?: string | null | undefined, name?: string | null | undefined } | null | undefined } | null | undefined, dcOptimizer?: { __typename: 'DcOptimizer', id: string, efficiency?: number | null | undefined, efficiencyMax?: number | null | undefined, hasGlobalMppt?: boolean | null | undefined, inputShortCircuitCurrentMax?: number | null | undefined, inputVoltageMax?: number | null | undefined, isExternalMppt?: boolean | null | undefined, isLongString?: boolean | null | undefined, isHuawei?: boolean | null | undefined, isSolarEdge?: boolean | null | undefined, maxInputCurrent?: number | null | undefined, mpptOperatingVoltageMax?: number | null | undefined, mpptOperatingVoltageMin?: number | null | undefined, mpptRangeMax?: number | null | undefined, mpptRangeMin?: number | null | undefined, name?: string | null | undefined, numInputs?: number | null | undefined, operatingModel?: string | null | undefined, optimizationBehavior?: string | null | undefined, outputCurrentMax?: number | null | undefined, outputVoltageMax?: number | null | undefined, price?: number | null | undefined, stcInputPowerMax?: number | null | undefined, systemVoltageMax?: number | null | undefined, usesSelectiveOptimization?: boolean | null | undefined, manufacturer?: { __typename: 'Manufacturer', id: string, displayName?: string | null | undefined, name?: string | null | undefined } | null | undefined } | null | undefined, cellStringOptimizer?: { __typename: 'CellStringOptimizer', id: string, name?: string | null | undefined, voltageLimit?: boolean | null | undefined, maxOutputVoltage?: number | null | undefined, manufacturer?: { __typename: 'Manufacturer', id: string, displayName?: string | null | undefined, name?: string | null | undefined } | null | undefined } | null | undefined } | null | undefined } | null | undefined };\n\nexport type CadProvideSolarInverterQueryVariables = Types.Exact<{\n  id: Types.Scalars['ID'];\n}>;\n\n\nexport type CadProvideSolarInverterQuery = { __typename: 'Query', component?: { __typename: 'SolarInverter', efficiencyCec?: number | null | undefined, efficiencyEuropean?: number | null | undefined, efficiencyMax?: number | null | undefined, hasExternalMppt?: boolean | null | undefined, hasGlobalMppt?: boolean | null | undefined, inputVoltageMax?: number | null | undefined, inputVoltageMin?: number | null | undefined, inputVoltageSE?: number | null | undefined, isHuawei?: boolean | null | undefined, isSolarEdge?: boolean | null | undefined, isMicroinverter?: boolean | null | undefined, mpptRatedPowerVoltageMax?: number | null | undefined, mpptRatedPowerVoltageMin?: number | null | undefined, mppts?: number | null | undefined, name?: string | null | undefined, numPhases?: number | null | undefined, numPhysicalDcInputs?: number | null | undefined, outputCurrent?: number | null | undefined, outputVoltageNominal?: number | null | undefined, price?: number | null | undefined, ratedPower?: number | null | undefined, usableInputCurrentMax?: number | null | undefined, usableInputPowerMax?: number | null | undefined, id: string, manufacturer?: { __typename: 'Manufacturer', id: string, displayName?: string | null | undefined, name?: string | null | undefined } | null | undefined } | null | undefined };\n\nexport type CadProvideDcOptimizerQueryVariables = Types.Exact<{\n  id: Types.Scalars['ID'];\n}>;\n\n\nexport type CadProvideDcOptimizerQuery = { __typename: 'Query', component: { __typename: 'DcOptimizer', efficiency?: number | null | undefined, efficiencyMax?: number | null | undefined, hasGlobalMppt?: boolean | null | undefined, inputShortCircuitCurrentMax?: number | null | undefined, inputVoltageMax?: number | null | undefined, isExternalMppt?: boolean | null | undefined, isLongString?: boolean | null | undefined, isHuawei?: boolean | null | undefined, isSolarEdge?: boolean | null | undefined, maxInputCurrent?: number | null | undefined, mpptOperatingVoltageMax?: number | null | undefined, mpptOperatingVoltageMin?: number | null | undefined, mpptRangeMax?: number | null | undefined, mpptRangeMin?: number | null | undefined, name?: string | null | undefined, numInputs?: number | null | undefined, operatingModel?: string | null | undefined, optimizationBehavior?: string | null | undefined, outputCurrentMax?: number | null | undefined, outputVoltageMax?: number | null | undefined, price?: number | null | undefined, stcInputPowerMax?: number | null | undefined, systemVoltageMax?: number | null | undefined, usesSelectiveOptimization?: boolean | null | undefined, id: string, manufacturer?: { __typename: 'Manufacturer', id: string, displayName?: string | null | undefined, name?: string | null | undefined } | null | undefined } };\n\nexport type CadProvideCombinerBoxQueryVariables = Types.Exact<{\n  id: Types.Scalars['ID'];\n}>;\n\n\nexport type CadProvideCombinerBoxQuery = { __typename: 'Query', component: { __typename: 'CombinerBox', id: string, voltageRating?: number | null | undefined, fuseRating?: number | null | undefined, nemaRating?: string | null | undefined } };\n\nexport type CadProvideDisconnectQueryVariables = Types.Exact<{\n  id: Types.Scalars['ID'];\n}>;\n\n\nexport type CadProvideDisconnectQuery = { __typename: 'Query', component: { __typename: 'Disconnect', fused?: boolean | null | undefined, fuseRating?: number | null | undefined, currentRating?: number | null | undefined, voltageRating?: number | null | undefined, id: string, name?: string | null | undefined, manufacturer?: { __typename: 'Manufacturer', id: string, name?: string | null | undefined, displayName?: string | null | undefined } | null | undefined } };\n\nexport type CadProvideLoadCenterQueryVariables = Types.Exact<{\n  id: Types.Scalars['ID'];\n}>;\n\n\nexport type CadProvideLoadCenterQuery = { __typename: 'Query', component: { __typename: 'LoadCenter', mainBreakerRating?: number | null | undefined, busRating?: number | null | undefined, isBreaker?: boolean | null | undefined, id: string, name?: string | null | undefined, manufacturer?: { __typename: 'Manufacturer', id: string, name?: string | null | undefined, displayName?: string | null | undefined } | null | undefined } };\n\nexport type CadProvideMeterQueryVariables = Types.Exact<{\n  id: Types.Scalars['ID'];\n}>;\n\n\nexport type CadProvideMeterQuery = { __typename: 'Query', component: { __typename: 'Meter', currentRating?: number | null | undefined, id: string, name?: string | null | undefined, manufacturer?: { __typename: 'Manufacturer', id: string, name?: string | null | undefined, displayName?: string | null | undefined } | null | undefined } };\n\nexport type CadProvideServicePanelQueryVariables = Types.Exact<{\n  id: Types.Scalars['ID'];\n}>;\n\n\nexport type CadProvideServicePanelQuery = { __typename: 'Query', component?: { __typename: 'ServicePanel', breakerRating?: number | null | undefined, busRating?: number | null | undefined, main?: boolean | null | undefined, id: string, name?: string | null | undefined, manufacturer?: { __typename: 'Manufacturer', id: string, name?: string | null | undefined, displayName?: string | null | undefined } | null | undefined } | null | undefined };\n\nexport type PanelIrradianceProgressQueryVariables = Types.Exact<{ [key: string]: never; }>;\n\n\nexport type PanelIrradianceProgressQuery = { __typename: 'Query', CAD: { __typename: 'CAD', irradianceState: { __typename: 'IrradianceState', panels: { __typename: 'IrradianceStateType', progress: number } } } };\n\nexport type RoofIrradianceProgressQueryVariables = Types.Exact<{ [key: string]: never; }>;\n\n\nexport type RoofIrradianceProgressQuery = { __typename: 'Query', CAD: { __typename: 'CAD', irradianceState: { __typename: 'IrradianceState', roof: { __typename: 'IrradianceStateType', progress: number } } } };\n\n\nexport const IsLidarAvailableDocument = gql`\n    query IsLidarAvailable @trace_info(traceInfo: {pod: cad}) {\n  lidarController @client {\n    lidarAvailable\n  }\n}\n    `;\n\n/**\n * __useIsLidarAvailableQuery__\n *\n * To run a query within a React component, call `useIsLidarAvailableQuery` and pass it any options that fit your needs.\n * When your component renders, `useIsLidarAvailableQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useIsLidarAvailableQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useIsLidarAvailableQuery(baseOptions?: Apollo.QueryHookOptions<IsLidarAvailableQuery, IsLidarAvailableQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<IsLidarAvailableQuery, IsLidarAvailableQueryVariables>(IsLidarAvailableDocument, options);\n      }\nexport function useIsLidarAvailableLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IsLidarAvailableQuery, IsLidarAvailableQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<IsLidarAvailableQuery, IsLidarAvailableQueryVariables>(IsLidarAvailableDocument, options);\n        }\nexport type IsLidarAvailableQueryHookResult = ReturnType<typeof useIsLidarAvailableQuery>;\nexport type IsLidarAvailableLazyQueryHookResult = ReturnType<typeof useIsLidarAvailableLazyQuery>;\nexport type IsLidarAvailableQueryResult = Apollo.QueryResult<IsLidarAvailableQuery, IsLidarAvailableQueryVariables>;\nexport const CadProvideTenantInfoDocument = gql`\n    query CadProvideTenantInfo @trace_info(traceInfo: {pod: cad}) {\n  apiInfo {\n    tenant {\n      id\n      temperatureUnit\n      units\n    }\n  }\n}\n    `;\n\n/**\n * __useCadProvideTenantInfoQuery__\n *\n * To run a query within a React component, call `useCadProvideTenantInfoQuery` and pass it any options that fit your needs.\n * When your component renders, `useCadProvideTenantInfoQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCadProvideTenantInfoQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useCadProvideTenantInfoQuery(baseOptions?: Apollo.QueryHookOptions<CadProvideTenantInfoQuery, CadProvideTenantInfoQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<CadProvideTenantInfoQuery, CadProvideTenantInfoQueryVariables>(CadProvideTenantInfoDocument, options);\n      }\nexport function useCadProvideTenantInfoLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CadProvideTenantInfoQuery, CadProvideTenantInfoQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<CadProvideTenantInfoQuery, CadProvideTenantInfoQueryVariables>(CadProvideTenantInfoDocument, options);\n        }\nexport type CadProvideTenantInfoQueryHookResult = ReturnType<typeof useCadProvideTenantInfoQuery>;\nexport type CadProvideTenantInfoLazyQueryHookResult = ReturnType<typeof useCadProvideTenantInfoLazyQuery>;\nexport type CadProvideTenantInfoQueryResult = Apollo.QueryResult<CadProvideTenantInfoQuery, CadProvideTenantInfoQueryVariables>;\nexport const CadProvideProjectIdDocument = gql`\n    query CadProvideProjectId($id: ID!) @trace_info(traceInfo: {pod: cad}) {\n  designById(id: $id) {\n    project {\n      id\n    }\n  }\n}\n    `;\n\n/**\n * __useCadProvideProjectIdQuery__\n *\n * To run a query within a React component, call `useCadProvideProjectIdQuery` and pass it any options that fit your needs.\n * When your component renders, `useCadProvideProjectIdQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCadProvideProjectIdQuery({\n *   variables: {\n *      id: // value for 'id'\n *   },\n * });\n */\nexport function useCadProvideProjectIdQuery(baseOptions: Apollo.QueryHookOptions<CadProvideProjectIdQuery, CadProvideProjectIdQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<CadProvideProjectIdQuery, CadProvideProjectIdQueryVariables>(CadProvideProjectIdDocument, options);\n      }\nexport function useCadProvideProjectIdLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CadProvideProjectIdQuery, CadProvideProjectIdQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<CadProvideProjectIdQuery, CadProvideProjectIdQueryVariables>(CadProvideProjectIdDocument, options);\n        }\nexport type CadProvideProjectIdQueryHookResult = ReturnType<typeof useCadProvideProjectIdQuery>;\nexport type CadProvideProjectIdLazyQueryHookResult = ReturnType<typeof useCadProvideProjectIdLazyQuery>;\nexport type CadProvideProjectIdQueryResult = Apollo.QueryResult<CadProvideProjectIdQuery, CadProvideProjectIdQueryVariables>;\nexport const CadProvideProjectTypeDocument = gql`\n    query CadProvideProjectType($id: ID!) @trace_info(traceInfo: {pod: cad}) {\n  designById(id: $id) {\n    project {\n      projectType\n    }\n  }\n}\n    `;\n\n/**\n * __useCadProvideProjectTypeQuery__\n *\n * To run a query within a React component, call `useCadProvideProjectTypeQuery` and pass it any options that fit your needs.\n * When your component renders, `useCadProvideProjectTypeQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCadProvideProjectTypeQuery({\n *   variables: {\n *      id: // value for 'id'\n *   },\n * });\n */\nexport function useCadProvideProjectTypeQuery(baseOptions: Apollo.QueryHookOptions<CadProvideProjectTypeQuery, CadProvideProjectTypeQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<CadProvideProjectTypeQuery, CadProvideProjectTypeQueryVariables>(CadProvideProjectTypeDocument, options);\n      }\nexport function useCadProvideProjectTypeLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CadProvideProjectTypeQuery, CadProvideProjectTypeQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<CadProvideProjectTypeQuery, CadProvideProjectTypeQueryVariables>(CadProvideProjectTypeDocument, options);\n        }\nexport type CadProvideProjectTypeQueryHookResult = ReturnType<typeof useCadProvideProjectTypeQuery>;\nexport type CadProvideProjectTypeLazyQueryHookResult = ReturnType<typeof useCadProvideProjectTypeLazyQuery>;\nexport type CadProvideProjectTypeQueryResult = Apollo.QueryResult<CadProvideProjectTypeQuery, CadProvideProjectTypeQueryVariables>;\nexport const CadProvideModuleSpacingSettingsDocument = gql`\n    query CadProvideModuleSpacingSettings($id: ID!) @trace_info(traceInfo: {pod: cad}) {\n  design: designById(id: $id) {\n    rowSpacing\n    interModuleSpacingX\n    interModuleSpacingY\n  }\n  tenantSettings {\n    pitchedX: autoDesignerOptionsColumnSpacingMDefault {\n      value\n    }\n    pitchedY: autoDesignerOptionsRowSpacingMDefault {\n      value\n    }\n    flatX: autoDesignerOptionsFlatFaceColumnSpacingMDefault {\n      value\n    }\n    flatY: autoDesignerOptionsFlatFaceRowSpacingMDefault {\n      value\n    }\n    pitchedThreshold: autoDesignerOptionsPitchedFaceTiltThresholdDeg {\n      value\n    }\n  }\n}\n    `;\n\n/**\n * __useCadProvideModuleSpacingSettingsQuery__\n *\n * To run a query within a React component, call `useCadProvideModuleSpacingSettingsQuery` and pass it any options that fit your needs.\n * When your component renders, `useCadProvideModuleSpacingSettingsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCadProvideModuleSpacingSettingsQuery({\n *   variables: {\n *      id: // value for 'id'\n *   },\n * });\n */\nexport function useCadProvideModuleSpacingSettingsQuery(baseOptions: Apollo.QueryHookOptions<CadProvideModuleSpacingSettingsQuery, CadProvideModuleSpacingSettingsQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<CadProvideModuleSpacingSettingsQuery, CadProvideModuleSpacingSettingsQueryVariables>(CadProvideModuleSpacingSettingsDocument, options);\n      }\nexport function useCadProvideModuleSpacingSettingsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CadProvideModuleSpacingSettingsQuery, CadProvideModuleSpacingSettingsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<CadProvideModuleSpacingSettingsQuery, CadProvideModuleSpacingSettingsQueryVariables>(CadProvideModuleSpacingSettingsDocument, options);\n        }\nexport type CadProvideModuleSpacingSettingsQueryHookResult = ReturnType<typeof useCadProvideModuleSpacingSettingsQuery>;\nexport type CadProvideModuleSpacingSettingsLazyQueryHookResult = ReturnType<typeof useCadProvideModuleSpacingSettingsLazyQuery>;\nexport type CadProvideModuleSpacingSettingsQueryResult = Apollo.QueryResult<CadProvideModuleSpacingSettingsQuery, CadProvideModuleSpacingSettingsQueryVariables>;\nexport const CadProvideTenantIdDocument = gql`\n    query CadProvideTenantId($id: ID!) @trace_info(traceInfo: {pod: cad}) {\n  userById(id: $id) {\n    tenant {\n      id\n    }\n  }\n}\n    `;\n\n/**\n * __useCadProvideTenantIdQuery__\n *\n * To run a query within a React component, call `useCadProvideTenantIdQuery` and pass it any options that fit your needs.\n * When your component renders, `useCadProvideTenantIdQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCadProvideTenantIdQuery({\n *   variables: {\n *      id: // value for 'id'\n *   },\n * });\n */\nexport function useCadProvideTenantIdQuery(baseOptions: Apollo.QueryHookOptions<CadProvideTenantIdQuery, CadProvideTenantIdQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<CadProvideTenantIdQuery, CadProvideTenantIdQueryVariables>(CadProvideTenantIdDocument, options);\n      }\nexport function useCadProvideTenantIdLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CadProvideTenantIdQuery, CadProvideTenantIdQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<CadProvideTenantIdQuery, CadProvideTenantIdQueryVariables>(CadProvideTenantIdDocument, options);\n        }\nexport type CadProvideTenantIdQueryHookResult = ReturnType<typeof useCadProvideTenantIdQuery>;\nexport type CadProvideTenantIdLazyQueryHookResult = ReturnType<typeof useCadProvideTenantIdLazyQuery>;\nexport type CadProvideTenantIdQueryResult = Apollo.QueryResult<CadProvideTenantIdQuery, CadProvideTenantIdQueryVariables>;\nexport const CadProvideDesignDocument = gql`\n    query CadProvideDesign($id: ID!) @trace_info(traceInfo: {pod: cad}) {\n  designById(id: $id) {\n    longitude\n    latitude\n    savedFromNewCad\n    irradianceMapId\n    irradianceMapStatus\n    irradiancePanelsId\n    irradiancePanelsStatus\n    temperatureMax\n    temperatureMin\n    geodataBaseUrl\n    geodataParentId\n  }\n}\n    `;\n\n/**\n * __useCadProvideDesignQuery__\n *\n * To run a query within a React component, call `useCadProvideDesignQuery` and pass it any options that fit your needs.\n * When your component renders, `useCadProvideDesignQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCadProvideDesignQuery({\n *   variables: {\n *      id: // value for 'id'\n *   },\n * });\n */\nexport function useCadProvideDesignQuery(baseOptions: Apollo.QueryHookOptions<CadProvideDesignQuery, CadProvideDesignQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<CadProvideDesignQuery, CadProvideDesignQueryVariables>(CadProvideDesignDocument, options);\n      }\nexport function useCadProvideDesignLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CadProvideDesignQuery, CadProvideDesignQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<CadProvideDesignQuery, CadProvideDesignQueryVariables>(CadProvideDesignDocument, options);\n        }\nexport type CadProvideDesignQueryHookResult = ReturnType<typeof useCadProvideDesignQuery>;\nexport type CadProvideDesignLazyQueryHookResult = ReturnType<typeof useCadProvideDesignLazyQuery>;\nexport type CadProvideDesignQueryResult = Apollo.QueryResult<CadProvideDesignQuery, CadProvideDesignQueryVariables>;\nexport const CadProvideLeadCaptureDataDocument = gql`\n    query CadProvideLeadCaptureData($id: ID!) @trace_info(traceInfo: {pod: cad}) {\n  getLeadCaptureProjectData(id: $id) {\n    id\n    location {\n      latitude\n      longitude\n    }\n    pointCloud {\n      id\n      data\n    }\n    image {\n      id\n      dataUrl\n      worldfile {\n        a\n        b\n        c\n        e\n        d\n        f\n      }\n      dimensions {\n        height\n        width\n      }\n      orthoImage {\n        id\n        source\n        url\n        name\n        active\n        opacity\n        width\n        height\n        worldfileA\n        worldfileB\n        worldfileC\n        worldfileD\n        worldfileE\n        worldfileF\n        resource {\n          id\n          source\n          url\n          type\n          worldfile {\n            a\n            b\n            c\n            e\n            d\n            f\n          }\n          dimensions {\n            width\n            height\n          }\n          metadata {\n            opacity\n            name\n          }\n        }\n      }\n    }\n    site {\n      id\n      data {\n        roofPlanes {\n          shell {\n            x\n            y\n            edgeType\n          }\n          holes {\n            x\n            y\n            edgeType\n          }\n          height\n          pitch\n          azimuthEdgeIndex\n        }\n        obstructions {\n          shape\n          center\n          azimuthVector\n          radius\n          width\n          length\n          flush\n          heightAbove\n          confidence\n        }\n        baseElevation\n        centerLat\n        centerLng\n      }\n    }\n    irradianceMap {\n      id\n      annualUrl\n      monthlyUrl\n      metaUrl\n    }\n    scenarios {\n      energyTarget\n      design {\n        id\n        data\n      }\n      irradiancePanels {\n        id\n        annualUrl\n        monthlyUrl\n        metaUrl\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useCadProvideLeadCaptureDataQuery__\n *\n * To run a query within a React component, call `useCadProvideLeadCaptureDataQuery` and pass it any options that fit your needs.\n * When your component renders, `useCadProvideLeadCaptureDataQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCadProvideLeadCaptureDataQuery({\n *   variables: {\n *      id: // value for 'id'\n *   },\n * });\n */\nexport function useCadProvideLeadCaptureDataQuery(baseOptions: Apollo.QueryHookOptions<CadProvideLeadCaptureDataQuery, CadProvideLeadCaptureDataQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<CadProvideLeadCaptureDataQuery, CadProvideLeadCaptureDataQueryVariables>(CadProvideLeadCaptureDataDocument, options);\n      }\nexport function useCadProvideLeadCaptureDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CadProvideLeadCaptureDataQuery, CadProvideLeadCaptureDataQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<CadProvideLeadCaptureDataQuery, CadProvideLeadCaptureDataQueryVariables>(CadProvideLeadCaptureDataDocument, options);\n        }\nexport type CadProvideLeadCaptureDataQueryHookResult = ReturnType<typeof useCadProvideLeadCaptureDataQuery>;\nexport type CadProvideLeadCaptureDataLazyQueryHookResult = ReturnType<typeof useCadProvideLeadCaptureDataLazyQuery>;\nexport type CadProvideLeadCaptureDataQueryResult = Apollo.QueryResult<CadProvideLeadCaptureDataQuery, CadProvideLeadCaptureDataQueryVariables>;\nexport const CadProvidePricePerWattDocument = gql`\n    query CadProvidePricePerWatt($id: ID!) @trace_info(traceInfo: {pod: cad}) {\n  designById(id: $id) {\n    pricePerWatt\n  }\n}\n    `;\n\n/**\n * __useCadProvidePricePerWattQuery__\n *\n * To run a query within a React component, call `useCadProvidePricePerWattQuery` and pass it any options that fit your needs.\n * When your component renders, `useCadProvidePricePerWattQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCadProvidePricePerWattQuery({\n *   variables: {\n *      id: // value for 'id'\n *   },\n * });\n */\nexport function useCadProvidePricePerWattQuery(baseOptions: Apollo.QueryHookOptions<CadProvidePricePerWattQuery, CadProvidePricePerWattQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<CadProvidePricePerWattQuery, CadProvidePricePerWattQueryVariables>(CadProvidePricePerWattDocument, options);\n      }\nexport function useCadProvidePricePerWattLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CadProvidePricePerWattQuery, CadProvidePricePerWattQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<CadProvidePricePerWattQuery, CadProvidePricePerWattQueryVariables>(CadProvidePricePerWattDocument, options);\n        }\nexport type CadProvidePricePerWattQueryHookResult = ReturnType<typeof useCadProvidePricePerWattQuery>;\nexport type CadProvidePricePerWattLazyQueryHookResult = ReturnType<typeof useCadProvidePricePerWattLazyQuery>;\nexport type CadProvidePricePerWattQueryResult = Apollo.QueryResult<CadProvidePricePerWattQuery, CadProvidePricePerWattQueryVariables>;\nexport const CadProvideTimeZoneOffsetDocument = gql`\n    query CadProvideTimeZoneOffset($id: ID!) @trace_info(traceInfo: {pod: cad}) {\n  designById(id: $id) {\n    project {\n      timeZoneOffset\n    }\n  }\n}\n    `;\n\n/**\n * __useCadProvideTimeZoneOffsetQuery__\n *\n * To run a query within a React component, call `useCadProvideTimeZoneOffsetQuery` and pass it any options that fit your needs.\n * When your component renders, `useCadProvideTimeZoneOffsetQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCadProvideTimeZoneOffsetQuery({\n *   variables: {\n *      id: // value for 'id'\n *   },\n * });\n */\nexport function useCadProvideTimeZoneOffsetQuery(baseOptions: Apollo.QueryHookOptions<CadProvideTimeZoneOffsetQuery, CadProvideTimeZoneOffsetQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<CadProvideTimeZoneOffsetQuery, CadProvideTimeZoneOffsetQueryVariables>(CadProvideTimeZoneOffsetDocument, options);\n      }\nexport function useCadProvideTimeZoneOffsetLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CadProvideTimeZoneOffsetQuery, CadProvideTimeZoneOffsetQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<CadProvideTimeZoneOffsetQuery, CadProvideTimeZoneOffsetQueryVariables>(CadProvideTimeZoneOffsetDocument, options);\n        }\nexport type CadProvideTimeZoneOffsetQueryHookResult = ReturnType<typeof useCadProvideTimeZoneOffsetQuery>;\nexport type CadProvideTimeZoneOffsetLazyQueryHookResult = ReturnType<typeof useCadProvideTimeZoneOffsetLazyQuery>;\nexport type CadProvideTimeZoneOffsetQueryResult = Apollo.QueryResult<CadProvideTimeZoneOffsetQuery, CadProvideTimeZoneOffsetQueryVariables>;\nexport const CadProvideTemplatesJsonDocument = gql`\n    query CadProvideTemplatesJson($id: ID!) @trace_info(traceInfo: {pod: cad}) {\n  designById(id: $id) {\n    templatesJson\n  }\n}\n    `;\n\n/**\n * __useCadProvideTemplatesJsonQuery__\n *\n * To run a query within a React component, call `useCadProvideTemplatesJsonQuery` and pass it any options that fit your needs.\n * When your component renders, `useCadProvideTemplatesJsonQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCadProvideTemplatesJsonQuery({\n *   variables: {\n *      id: // value for 'id'\n *   },\n * });\n */\nexport function useCadProvideTemplatesJsonQuery(baseOptions: Apollo.QueryHookOptions<CadProvideTemplatesJsonQuery, CadProvideTemplatesJsonQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<CadProvideTemplatesJsonQuery, CadProvideTemplatesJsonQueryVariables>(CadProvideTemplatesJsonDocument, options);\n      }\nexport function useCadProvideTemplatesJsonLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CadProvideTemplatesJsonQuery, CadProvideTemplatesJsonQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<CadProvideTemplatesJsonQuery, CadProvideTemplatesJsonQueryVariables>(CadProvideTemplatesJsonDocument, options);\n        }\nexport type CadProvideTemplatesJsonQueryHookResult = ReturnType<typeof useCadProvideTemplatesJsonQuery>;\nexport type CadProvideTemplatesJsonLazyQueryHookResult = ReturnType<typeof useCadProvideTemplatesJsonLazyQuery>;\nexport type CadProvideTemplatesJsonQueryResult = Apollo.QueryResult<CadProvideTemplatesJsonQuery, CadProvideTemplatesJsonQueryVariables>;\nexport const CadProvideSolarPanelDocument = gql`\n    query CadProvideSolarPanel($id: ID!) @trace_info(traceInfo: {pod: cad}) {\n  component: solarPanelById(id: $id) {\n    ...CadRequiredComponentProperties\n  }\n}\n    ${CadRequiredComponentPropertiesFragmentDoc}`;\n\n/**\n * __useCadProvideSolarPanelQuery__\n *\n * To run a query within a React component, call `useCadProvideSolarPanelQuery` and pass it any options that fit your needs.\n * When your component renders, `useCadProvideSolarPanelQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCadProvideSolarPanelQuery({\n *   variables: {\n *      id: // value for 'id'\n *   },\n * });\n */\nexport function useCadProvideSolarPanelQuery(baseOptions: Apollo.QueryHookOptions<CadProvideSolarPanelQuery, CadProvideSolarPanelQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<CadProvideSolarPanelQuery, CadProvideSolarPanelQueryVariables>(CadProvideSolarPanelDocument, options);\n      }\nexport function useCadProvideSolarPanelLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CadProvideSolarPanelQuery, CadProvideSolarPanelQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<CadProvideSolarPanelQuery, CadProvideSolarPanelQueryVariables>(CadProvideSolarPanelDocument, options);\n        }\nexport type CadProvideSolarPanelQueryHookResult = ReturnType<typeof useCadProvideSolarPanelQuery>;\nexport type CadProvideSolarPanelLazyQueryHookResult = ReturnType<typeof useCadProvideSolarPanelLazyQuery>;\nexport type CadProvideSolarPanelQueryResult = Apollo.QueryResult<CadProvideSolarPanelQuery, CadProvideSolarPanelQueryVariables>;\nexport const CadProvideSolarInverterDocument = gql`\n    query CadProvideSolarInverter($id: ID!) @trace_info(traceInfo: {pod: cad}) {\n  component: solarInverterById(id: $id) {\n    ...CadRequiredComponentProperties\n  }\n}\n    ${CadRequiredComponentPropertiesFragmentDoc}`;\n\n/**\n * __useCadProvideSolarInverterQuery__\n *\n * To run a query within a React component, call `useCadProvideSolarInverterQuery` and pass it any options that fit your needs.\n * When your component renders, `useCadProvideSolarInverterQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCadProvideSolarInverterQuery({\n *   variables: {\n *      id: // value for 'id'\n *   },\n * });\n */\nexport function useCadProvideSolarInverterQuery(baseOptions: Apollo.QueryHookOptions<CadProvideSolarInverterQuery, CadProvideSolarInverterQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<CadProvideSolarInverterQuery, CadProvideSolarInverterQueryVariables>(CadProvideSolarInverterDocument, options);\n      }\nexport function useCadProvideSolarInverterLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CadProvideSolarInverterQuery, CadProvideSolarInverterQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<CadProvideSolarInverterQuery, CadProvideSolarInverterQueryVariables>(CadProvideSolarInverterDocument, options);\n        }\nexport type CadProvideSolarInverterQueryHookResult = ReturnType<typeof useCadProvideSolarInverterQuery>;\nexport type CadProvideSolarInverterLazyQueryHookResult = ReturnType<typeof useCadProvideSolarInverterLazyQuery>;\nexport type CadProvideSolarInverterQueryResult = Apollo.QueryResult<CadProvideSolarInverterQuery, CadProvideSolarInverterQueryVariables>;\nexport const CadProvideDcOptimizerDocument = gql`\n    query CadProvideDcOptimizer($id: ID!) @trace_info(traceInfo: {pod: cad}) {\n  component: dcOptimizerById(id: $id) {\n    ...CadRequiredComponentProperties\n  }\n}\n    ${CadRequiredComponentPropertiesFragmentDoc}`;\n\n/**\n * __useCadProvideDcOptimizerQuery__\n *\n * To run a query within a React component, call `useCadProvideDcOptimizerQuery` and pass it any options that fit your needs.\n * When your component renders, `useCadProvideDcOptimizerQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCadProvideDcOptimizerQuery({\n *   variables: {\n *      id: // value for 'id'\n *   },\n * });\n */\nexport function useCadProvideDcOptimizerQuery(baseOptions: Apollo.QueryHookOptions<CadProvideDcOptimizerQuery, CadProvideDcOptimizerQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<CadProvideDcOptimizerQuery, CadProvideDcOptimizerQueryVariables>(CadProvideDcOptimizerDocument, options);\n      }\nexport function useCadProvideDcOptimizerLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CadProvideDcOptimizerQuery, CadProvideDcOptimizerQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<CadProvideDcOptimizerQuery, CadProvideDcOptimizerQueryVariables>(CadProvideDcOptimizerDocument, options);\n        }\nexport type CadProvideDcOptimizerQueryHookResult = ReturnType<typeof useCadProvideDcOptimizerQuery>;\nexport type CadProvideDcOptimizerLazyQueryHookResult = ReturnType<typeof useCadProvideDcOptimizerLazyQuery>;\nexport type CadProvideDcOptimizerQueryResult = Apollo.QueryResult<CadProvideDcOptimizerQuery, CadProvideDcOptimizerQueryVariables>;\nexport const CadProvideCombinerBoxDocument = gql`\n    query CadProvideCombinerBox($id: ID!) @trace_info(traceInfo: {pod: cad}) {\n  component: combinerBoxById(id: $id) {\n    id\n    voltageRating\n    fuseRating\n    nemaRating\n  }\n}\n    `;\n\n/**\n * __useCadProvideCombinerBoxQuery__\n *\n * To run a query within a React component, call `useCadProvideCombinerBoxQuery` and pass it any options that fit your needs.\n * When your component renders, `useCadProvideCombinerBoxQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCadProvideCombinerBoxQuery({\n *   variables: {\n *      id: // value for 'id'\n *   },\n * });\n */\nexport function useCadProvideCombinerBoxQuery(baseOptions: Apollo.QueryHookOptions<CadProvideCombinerBoxQuery, CadProvideCombinerBoxQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<CadProvideCombinerBoxQuery, CadProvideCombinerBoxQueryVariables>(CadProvideCombinerBoxDocument, options);\n      }\nexport function useCadProvideCombinerBoxLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CadProvideCombinerBoxQuery, CadProvideCombinerBoxQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<CadProvideCombinerBoxQuery, CadProvideCombinerBoxQueryVariables>(CadProvideCombinerBoxDocument, options);\n        }\nexport type CadProvideCombinerBoxQueryHookResult = ReturnType<typeof useCadProvideCombinerBoxQuery>;\nexport type CadProvideCombinerBoxLazyQueryHookResult = ReturnType<typeof useCadProvideCombinerBoxLazyQuery>;\nexport type CadProvideCombinerBoxQueryResult = Apollo.QueryResult<CadProvideCombinerBoxQuery, CadProvideCombinerBoxQueryVariables>;\nexport const CadProvideDisconnectDocument = gql`\n    query CadProvideDisconnect($id: ID!) @trace_info(traceInfo: {pod: cad}) {\n  component: disconnectById(id: $id) {\n    ...CadRequiredComponentProperties\n  }\n}\n    ${CadRequiredComponentPropertiesFragmentDoc}`;\n\n/**\n * __useCadProvideDisconnectQuery__\n *\n * To run a query within a React component, call `useCadProvideDisconnectQuery` and pass it any options that fit your needs.\n * When your component renders, `useCadProvideDisconnectQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCadProvideDisconnectQuery({\n *   variables: {\n *      id: // value for 'id'\n *   },\n * });\n */\nexport function useCadProvideDisconnectQuery(baseOptions: Apollo.QueryHookOptions<CadProvideDisconnectQuery, CadProvideDisconnectQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<CadProvideDisconnectQuery, CadProvideDisconnectQueryVariables>(CadProvideDisconnectDocument, options);\n      }\nexport function useCadProvideDisconnectLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CadProvideDisconnectQuery, CadProvideDisconnectQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<CadProvideDisconnectQuery, CadProvideDisconnectQueryVariables>(CadProvideDisconnectDocument, options);\n        }\nexport type CadProvideDisconnectQueryHookResult = ReturnType<typeof useCadProvideDisconnectQuery>;\nexport type CadProvideDisconnectLazyQueryHookResult = ReturnType<typeof useCadProvideDisconnectLazyQuery>;\nexport type CadProvideDisconnectQueryResult = Apollo.QueryResult<CadProvideDisconnectQuery, CadProvideDisconnectQueryVariables>;\nexport const CadProvideLoadCenterDocument = gql`\n    query CadProvideLoadCenter($id: ID!) @trace_info(traceInfo: {pod: cad}) {\n  component: loadCenterById(id: $id) {\n    ...CadRequiredComponentProperties\n  }\n}\n    ${CadRequiredComponentPropertiesFragmentDoc}`;\n\n/**\n * __useCadProvideLoadCenterQuery__\n *\n * To run a query within a React component, call `useCadProvideLoadCenterQuery` and pass it any options that fit your needs.\n * When your component renders, `useCadProvideLoadCenterQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCadProvideLoadCenterQuery({\n *   variables: {\n *      id: // value for 'id'\n *   },\n * });\n */\nexport function useCadProvideLoadCenterQuery(baseOptions: Apollo.QueryHookOptions<CadProvideLoadCenterQuery, CadProvideLoadCenterQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<CadProvideLoadCenterQuery, CadProvideLoadCenterQueryVariables>(CadProvideLoadCenterDocument, options);\n      }\nexport function useCadProvideLoadCenterLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CadProvideLoadCenterQuery, CadProvideLoadCenterQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<CadProvideLoadCenterQuery, CadProvideLoadCenterQueryVariables>(CadProvideLoadCenterDocument, options);\n        }\nexport type CadProvideLoadCenterQueryHookResult = ReturnType<typeof useCadProvideLoadCenterQuery>;\nexport type CadProvideLoadCenterLazyQueryHookResult = ReturnType<typeof useCadProvideLoadCenterLazyQuery>;\nexport type CadProvideLoadCenterQueryResult = Apollo.QueryResult<CadProvideLoadCenterQuery, CadProvideLoadCenterQueryVariables>;\nexport const CadProvideMeterDocument = gql`\n    query CadProvideMeter($id: ID!) @trace_info(traceInfo: {pod: cad}) {\n  component: meterById(id: $id) {\n    ...CadRequiredComponentProperties\n  }\n}\n    ${CadRequiredComponentPropertiesFragmentDoc}`;\n\n/**\n * __useCadProvideMeterQuery__\n *\n * To run a query within a React component, call `useCadProvideMeterQuery` and pass it any options that fit your needs.\n * When your component renders, `useCadProvideMeterQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCadProvideMeterQuery({\n *   variables: {\n *      id: // value for 'id'\n *   },\n * });\n */\nexport function useCadProvideMeterQuery(baseOptions: Apollo.QueryHookOptions<CadProvideMeterQuery, CadProvideMeterQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<CadProvideMeterQuery, CadProvideMeterQueryVariables>(CadProvideMeterDocument, options);\n      }\nexport function useCadProvideMeterLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CadProvideMeterQuery, CadProvideMeterQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<CadProvideMeterQuery, CadProvideMeterQueryVariables>(CadProvideMeterDocument, options);\n        }\nexport type CadProvideMeterQueryHookResult = ReturnType<typeof useCadProvideMeterQuery>;\nexport type CadProvideMeterLazyQueryHookResult = ReturnType<typeof useCadProvideMeterLazyQuery>;\nexport type CadProvideMeterQueryResult = Apollo.QueryResult<CadProvideMeterQuery, CadProvideMeterQueryVariables>;\nexport const CadProvideServicePanelDocument = gql`\n    query CadProvideServicePanel($id: ID!) @trace_info(traceInfo: {pod: cad}) {\n  component: servicePanelById(id: $id) {\n    ...CadRequiredComponentProperties\n  }\n}\n    ${CadRequiredComponentPropertiesFragmentDoc}`;\n\n/**\n * __useCadProvideServicePanelQuery__\n *\n * To run a query within a React component, call `useCadProvideServicePanelQuery` and pass it any options that fit your needs.\n * When your component renders, `useCadProvideServicePanelQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCadProvideServicePanelQuery({\n *   variables: {\n *      id: // value for 'id'\n *   },\n * });\n */\nexport function useCadProvideServicePanelQuery(baseOptions: Apollo.QueryHookOptions<CadProvideServicePanelQuery, CadProvideServicePanelQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<CadProvideServicePanelQuery, CadProvideServicePanelQueryVariables>(CadProvideServicePanelDocument, options);\n      }\nexport function useCadProvideServicePanelLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CadProvideServicePanelQuery, CadProvideServicePanelQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<CadProvideServicePanelQuery, CadProvideServicePanelQueryVariables>(CadProvideServicePanelDocument, options);\n        }\nexport type CadProvideServicePanelQueryHookResult = ReturnType<typeof useCadProvideServicePanelQuery>;\nexport type CadProvideServicePanelLazyQueryHookResult = ReturnType<typeof useCadProvideServicePanelLazyQuery>;\nexport type CadProvideServicePanelQueryResult = Apollo.QueryResult<CadProvideServicePanelQuery, CadProvideServicePanelQueryVariables>;\nexport const PanelIrradianceProgressDocument = gql`\n    query PanelIrradianceProgress @trace_info(traceInfo: {pod: cad}) {\n  CAD @client {\n    irradianceState {\n      panels {\n        progress\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __usePanelIrradianceProgressQuery__\n *\n * To run a query within a React component, call `usePanelIrradianceProgressQuery` and pass it any options that fit your needs.\n * When your component renders, `usePanelIrradianceProgressQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = usePanelIrradianceProgressQuery({\n *   variables: {\n *   },\n * });\n */\nexport function usePanelIrradianceProgressQuery(baseOptions?: Apollo.QueryHookOptions<PanelIrradianceProgressQuery, PanelIrradianceProgressQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<PanelIrradianceProgressQuery, PanelIrradianceProgressQueryVariables>(PanelIrradianceProgressDocument, options);\n      }\nexport function usePanelIrradianceProgressLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PanelIrradianceProgressQuery, PanelIrradianceProgressQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<PanelIrradianceProgressQuery, PanelIrradianceProgressQueryVariables>(PanelIrradianceProgressDocument, options);\n        }\nexport type PanelIrradianceProgressQueryHookResult = ReturnType<typeof usePanelIrradianceProgressQuery>;\nexport type PanelIrradianceProgressLazyQueryHookResult = ReturnType<typeof usePanelIrradianceProgressLazyQuery>;\nexport type PanelIrradianceProgressQueryResult = Apollo.QueryResult<PanelIrradianceProgressQuery, PanelIrradianceProgressQueryVariables>;\nexport const RoofIrradianceProgressDocument = gql`\n    query RoofIrradianceProgress @trace_info(traceInfo: {pod: cad}) {\n  CAD @client {\n    irradianceState {\n      roof {\n        progress\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useRoofIrradianceProgressQuery__\n *\n * To run a query within a React component, call `useRoofIrradianceProgressQuery` and pass it any options that fit your needs.\n * When your component renders, `useRoofIrradianceProgressQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useRoofIrradianceProgressQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useRoofIrradianceProgressQuery(baseOptions?: Apollo.QueryHookOptions<RoofIrradianceProgressQuery, RoofIrradianceProgressQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<RoofIrradianceProgressQuery, RoofIrradianceProgressQueryVariables>(RoofIrradianceProgressDocument, options);\n      }\nexport function useRoofIrradianceProgressLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<RoofIrradianceProgressQuery, RoofIrradianceProgressQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<RoofIrradianceProgressQuery, RoofIrradianceProgressQueryVariables>(RoofIrradianceProgressDocument, options);\n        }\nexport type RoofIrradianceProgressQueryHookResult = ReturnType<typeof useRoofIrradianceProgressQuery>;\nexport type RoofIrradianceProgressLazyQueryHookResult = ReturnType<typeof useRoofIrradianceProgressLazyQuery>;\nexport type RoofIrradianceProgressQueryResult = Apollo.QueryResult<RoofIrradianceProgressQuery, RoofIrradianceProgressQueryVariables>;","import {\n  ApolloClient,\n  DataProxy,\n  DocumentNode,\n  NormalizedCacheObject,\n  OperationVariables,\n} from '@apollo/client';\nimport { estimateProgress } from '@aurorasolar/common-core/src/utils';\nimport {\n  StartAsyncJobDocument,\n  StartAsyncJobMutation,\n  StartAsyncJobMutationVariables,\n} from '@aurorasolar/common-data-access-layer';\nimport {\n  GetTenantUnitSettingDocument,\n  GetTenantUnitSettingQuery,\n} from '@aurorasolar/common-numeric-conversion';\nimport {\n  AsyncJobParameters,\n  AsyncJobType,\n  ComponentTypes,\n} from '@aurorasolar/graphql-client-schema';\n\nimport { CadPreferences } from '@aurorasolar/cad-preferences';\nimport {\n  CadProvideCombinerBoxDocument,\n  CadProvideCombinerBoxQuery,\n  CadProvideDcOptimizerDocument,\n  CadProvideDcOptimizerQuery,\n  CadProvideDesignDocument,\n  CadProvideDesignQuery,\n  CadProvideDesignQueryVariables,\n  CadProvideDisconnectDocument,\n  CadProvideDisconnectQuery,\n  CadProvideLeadCaptureDataDocument,\n  CadProvideLeadCaptureDataQuery,\n  CadProvideLeadCaptureDataQueryVariables,\n  CadProvideLoadCenterDocument,\n  CadProvideLoadCenterQuery,\n  CadProvideMeterDocument,\n  CadProvideMeterQuery,\n  CadProvideModuleSpacingSettingsDocument,\n  CadProvideModuleSpacingSettingsQuery,\n  CadProvideModuleSpacingSettingsQueryVariables,\n  CadProvidePricePerWattDocument,\n  CadProvidePricePerWattQuery,\n  CadProvidePricePerWattQueryVariables,\n  CadProvideProjectIdDocument,\n  CadProvideProjectIdQuery,\n  CadProvideProjectIdQueryVariables,\n  CadProvideProjectTypeDocument,\n  CadProvideProjectTypeQuery,\n  CadProvideProjectTypeQueryVariables,\n  CadProvideServicePanelDocument,\n  CadProvideServicePanelQuery,\n  CadProvideSolarInverterDocument,\n  CadProvideSolarInverterQuery,\n  CadProvideSolarPanelDocument,\n  CadProvideSolarPanelQuery,\n  CadProvideTemplatesJsonDocument,\n  CadProvideTemplatesJsonQuery,\n  CadProvideTemplatesJsonQueryVariables,\n  CadProvideTimeZoneOffsetDocument,\n  CadProvideTimeZoneOffsetQuery,\n  CadProvideTimeZoneOffsetQueryVariables,\n  IsLidarAvailableDocument,\n  IsLidarAvailableQuery,\n  PanelIrradianceProgressDocument,\n  PanelIrradianceProgressQuery,\n  RoofIrradianceProgressDocument,\n  RoofIrradianceProgressQuery,\n} from './data-service.generated';\n\ntype KebabToCamel<S> = S extends `${infer H}-${infer T}`\n  ? T extends Capitalize<T>\n    ? `${H}-${KebabToCamel<T>}`\n    : `${H}${KebabToCamel<Capitalize<T>>}`\n  : S;\n\nexport const convertKebabToCamelCase = <T extends string>(s: T) =>\n  s.replace('.', '_').replace(/(\\w)-(\\w)/g, (_, a, b) => a + b.toUpperCase()) as KebabToCamel<T>;\n\nexport const convertSnakeToCamelCase = (s: string) =>\n  s.replace(/(\\w)_(\\w)/g, (_, a, b) => a + b.toUpperCase());\n\ntype ComponentQueryResult<T extends string = ComponentTypes> = T extends ComponentTypes.CombinerBox\n  ? CadProvideCombinerBoxQuery\n  : T extends ComponentTypes.DcOptimizer\n  ? CadProvideDcOptimizerQuery\n  : T extends ComponentTypes.Disconnect\n  ? CadProvideDisconnectQuery\n  : T extends ComponentTypes.LoadCenter\n  ? CadProvideLoadCenterQuery\n  : T extends ComponentTypes.Meter\n  ? CadProvideMeterQuery\n  : T extends ComponentTypes.ServicePanel\n  ? CadProvideServicePanelQuery\n  : T extends ComponentTypes.SolarInverter\n  ? CadProvideSolarInverterQuery\n  : T extends ComponentTypes.SolarPanel\n  ? CadProvideSolarPanelQuery\n  : never;\n\nconst getComponentReadQuery =\n  <T extends ComponentQueryResult, V = OperationVariables>(query: DocumentNode) =>\n  (client: ApolloClient<NormalizedCacheObject>, id: string) =>\n    client.cache.readQuery<T>({\n      query,\n      variables: {\n        id,\n      } as unknown as V,\n    } as DataProxy.ReadQueryOptions<T, V>);\n\nconst ComponentQueries = {\n  [ComponentTypes.CombinerBox]: getComponentReadQuery<CadProvideCombinerBoxQuery>(\n    CadProvideCombinerBoxDocument,\n  ),\n  [ComponentTypes.DcOptimizer]: getComponentReadQuery<CadProvideDcOptimizerQuery>(\n    CadProvideDcOptimizerDocument,\n  ),\n  [ComponentTypes.Disconnect]: getComponentReadQuery<CadProvideDisconnectQuery>(\n    CadProvideDisconnectDocument,\n  ),\n  [ComponentTypes.LoadCenter]: getComponentReadQuery<CadProvideLoadCenterQuery>(\n    CadProvideLoadCenterDocument,\n  ),\n  [ComponentTypes.Meter]: getComponentReadQuery<CadProvideMeterQuery>(CadProvideMeterDocument),\n  [ComponentTypes.SolarInverter]: getComponentReadQuery<CadProvideSolarInverterQuery>(\n    CadProvideSolarInverterDocument,\n  ),\n  [ComponentTypes.ServicePanel]: getComponentReadQuery<CadProvideServicePanelQuery>(\n    CadProvideServicePanelDocument,\n  ),\n  [ComponentTypes.SolarPanel]: getComponentReadQuery<CadProvideSolarPanelQuery>(\n    CadProvideSolarPanelDocument,\n  ),\n} as const;\n\n/** A subset of `ComponentTypes` that are used in the data service */\nexport type DataServiceComponentType = keyof typeof ComponentQueries;\n\nexport const getTenantInfo = (client: ApolloClient<NormalizedCacheObject>) => {\n  return client.readQuery<GetTenantUnitSettingQuery>({\n    query: GetTenantUnitSettingDocument,\n  });\n};\n\nexport const isLidarAvailable = (client: ApolloClient<NormalizedCacheObject>) =>\n  client.cache.readQuery<IsLidarAvailableQuery>({\n    query: IsLidarAvailableDocument,\n    returnPartialData: true,\n  })?.lidarController?.lidarAvailable ?? false;\n\nexport const getDesign = (\n  client: ApolloClient<NormalizedCacheObject>,\n  id: string,\n): CadProvideDesignQuery['designById'] | undefined =>\n  client.cache.readQuery<CadProvideDesignQuery, CadProvideDesignQueryVariables>({\n    query: CadProvideDesignDocument,\n    returnPartialData: true,\n    variables: {\n      id,\n    },\n  })?.designById;\n\nexport const getLeadCaptureDesign = (\n  client: ApolloClient<NormalizedCacheObject>,\n  id: string,\n): CadProvideLeadCaptureDataQuery['getLeadCaptureProjectData'] | undefined =>\n  client.cache.readQuery<CadProvideLeadCaptureDataQuery, CadProvideLeadCaptureDataQueryVariables>({\n    query: CadProvideLeadCaptureDataDocument,\n    returnPartialData: true,\n    variables: {\n      id,\n    },\n  })?.getLeadCaptureProjectData;\n\nexport const getProjectId = (client: ApolloClient<NormalizedCacheObject>, id: string) => {\n  const data = client.cache.readQuery<CadProvideProjectIdQuery, CadProvideProjectIdQueryVariables>({\n    query: CadProvideProjectIdDocument,\n    returnPartialData: true,\n    variables: {\n      id,\n    },\n  });\n\n  return data?.designById?.project?.id ?? '';\n};\n\nexport const getProjectType = (client: ApolloClient<NormalizedCacheObject>, id: string) => {\n  const data = client.cache.readQuery<\n    CadProvideProjectTypeQuery,\n    CadProvideProjectTypeQueryVariables\n  >({\n    query: CadProvideProjectTypeDocument,\n    returnPartialData: true,\n    variables: {\n      id,\n    },\n  });\n\n  return data?.designById?.project?.projectType || '';\n};\nexport type ModuleSpacingSettings = {\n  /** @deprecated - Old setting: used in place of `y` when the panel has a tilt **/\n  rowSpacing: number;\n  /** @deprecated - Old setting */\n  x: number;\n  /** @deprecated - Old setting: used when the panel has no tilt */\n  y: number;\n\n  /** Used when the roof is flat */\n  flatX: number;\n  /** Used when the roof is flat */\n  flatY: number;\n\n  /** Used when the roof is pitched */\n  pitchedX: number;\n  /** Used when the roof is pitched */\n  pitchedY: number;\n\n  pitchedThreshold: number;\n};\n\n/**\n * Gets the module spacing settings for CAD\n *\n * The deprecated fields `rowSpacing`, `x`, and `y` are taken from the design itself.\n * The flat and pitched specific fields are taken from user preferences, if available.\n */\nexport const getModuleSpacingSettings = (\n  client: ApolloClient<NormalizedCacheObject>,\n  designId: string,\n  preferences?: CadPreferences,\n) => {\n  const { design, tenantSettings } =\n    client.cache.readQuery<\n      CadProvideModuleSpacingSettingsQuery,\n      CadProvideModuleSpacingSettingsQueryVariables\n    >({\n      query: CadProvideModuleSpacingSettingsDocument,\n      variables: {\n        id: designId,\n      },\n    }) ?? {};\n\n  const panelPreferences = preferences?.get('panelPlaceMode');\n\n  const moduleSpacingSettings: ModuleSpacingSettings = {\n    flatX: panelPreferences?.flatIntermoduleSpacingX ?? tenantSettings?.flatX?.value ?? 0,\n    flatY: panelPreferences?.flatRowSpacing ?? tenantSettings?.flatY?.value ?? 0,\n    pitchedThreshold:\n      panelPreferences?.pitchedThreshold ?? tenantSettings?.pitchedThreshold?.value ?? 0,\n    pitchedX: panelPreferences?.pitchedIntermoduleSpacingX ?? tenantSettings?.pitchedX?.value ?? 0,\n    pitchedY: panelPreferences?.pitchedRowSpacing ?? tenantSettings?.pitchedY?.value ?? 0,\n    rowSpacing: design?.rowSpacing ?? 0,\n    x: design?.interModuleSpacingX ?? 0,\n    y: design?.interModuleSpacingY ?? 0,\n  };\n\n  return moduleSpacingSettings;\n};\n\nexport const getPricePerWatt = (client: ApolloClient<NormalizedCacheObject>, id: string) => {\n  const data = client.cache.readQuery<\n    CadProvidePricePerWattQuery,\n    CadProvidePricePerWattQueryVariables\n  >({\n    query: CadProvidePricePerWattDocument,\n    variables: {\n      id,\n    },\n  });\n\n  return data?.designById?.pricePerWatt ?? 0;\n};\n\nexport const getTimeZoneOffset = (client: ApolloClient<NormalizedCacheObject>, id: string) => {\n  const data = client.cache.readQuery<\n    CadProvideTimeZoneOffsetQuery,\n    CadProvideTimeZoneOffsetQueryVariables\n  >({\n    query: CadProvideTimeZoneOffsetDocument,\n    variables: {\n      id,\n    },\n  });\n\n  return data?.designById.project.timeZoneOffset ?? 0;\n};\n\nexport const isLidarAccessible = (\n  client: ApolloClient<NormalizedCacheObject>,\n  lidarFeatureAvailable: boolean,\n) => {\n  return !!lidarFeatureAvailable && isLidarAvailable(client);\n};\n\nexport const getTemplateJsonById = (client: ApolloClient<NormalizedCacheObject>, id: string) => {\n  const data = client.cache.readQuery<\n    CadProvideTemplatesJsonQuery,\n    CadProvideTemplatesJsonQueryVariables\n  >({\n    query: CadProvideTemplatesJsonDocument,\n    variables: {\n      id,\n    },\n  });\n\n  return data?.designById?.templatesJson?.[id] ?? null;\n};\n\nexport type MapType = 'roof' | 'panels';\ntype IrradianceStateQuery = PanelIrradianceProgressQuery | RoofIrradianceProgressQuery;\n\nconst setIrradianceProgress = <T extends MapType>(\n  client: ApolloClient<NormalizedCacheObject>,\n  mapType: T,\n  progress: number,\n) => {\n  client.writeQuery<IrradianceStateQuery>({\n    data: {\n      __typename: 'Query',\n      CAD: {\n        __typename: 'CAD',\n        irradianceState: {\n          __typename: 'IrradianceState',\n          [mapType]: {\n            __typename: 'IrradianceStateType',\n            progress,\n          },\n        },\n      },\n    } as IrradianceStateQuery,\n    query: mapType === 'panels' ? PanelIrradianceProgressDocument : RoofIrradianceProgressDocument,\n  });\n};\n\nexport const getIrradiance = async (\n  client: ApolloClient<NormalizedCacheObject>,\n  mapType: MapType,\n  designId: string,\n) => {\n  const settings = { designId, mapType };\n  const setProgress = (progress: number) => setIrradianceProgress(client, mapType, progress);\n  setProgress(0);\n  const stopEstimating = estimateProgress(30, setProgress);\n  const { data } = await client\n    .mutate<StartAsyncJobMutation, StartAsyncJobMutationVariables>({\n      mutation: StartAsyncJobDocument,\n      variables: {\n        settings,\n        type: AsyncJobType.Irradiance,\n      },\n    })\n    .catch((error) => {\n      stopEstimating();\n      setProgress(0);\n      throw error;\n    });\n  stopEstimating();\n  setProgress(100);\n  return data?.startAsyncJob ?? null;\n};\n\nexport const runAutoString = async (\n  client: ApolloClient<NormalizedCacheObject>,\n  params: AsyncJobParameters,\n) => {\n  const { data } = await client.mutate<StartAsyncJobMutation, StartAsyncJobMutationVariables>({\n    mutation: StartAsyncJobDocument,\n    variables: {\n      settings: params,\n      type: AsyncJobType.AutoString,\n    },\n  });\n\n  // We have to clone as CAD tries to modify and cache doesn't allow this\n  return JSON.parse(JSON.stringify(data?.startAsyncJob ?? null));\n};\n\nexport const getIrradianceState = (client: ApolloClient<NormalizedCacheObject>, id: string) => {\n  const design = getDesign(client, id);\n\n  if (!design) {\n    throw new Error('Could not get design for getIrradianceState');\n  }\n\n  return {\n    id,\n    panels: {\n      id: design.irradiancePanelsId,\n      status: design.irradiancePanelsStatus || 'invalid',\n    },\n    roof: {\n      id: design.irradianceMapId,\n      status: design.irradianceMapStatus || 'invalid',\n    },\n  };\n};\n\nexport const getIrradianceStateAutoRoof = (\n  client: ApolloClient<NormalizedCacheObject>,\n  id: string,\n) => {\n  const design = getDesign(client, id);\n\n  if (!design) {\n    throw new Error('Could not get design for getIrradianceStateAutoRoof');\n  }\n\n  return {\n    id,\n    panels: {\n      id: design.irradiancePanelsId || null,\n      status: design.irradiancePanelsStatus || 'invalid',\n    },\n    roof: {\n      id: design.irradianceMapId || null,\n      status: design.irradianceMapStatus || 'invalid',\n    },\n  };\n};\n\nconst formatMlpe = <T extends ComponentQueryResult['component']>(component: T): T => {\n  if (component?.__typename === 'SolarPanel' && component.mlpe) {\n    const { mlpe } = component;\n\n    if (mlpe.isDcOptimizer) {\n      return { ...component, mlpe: { ...mlpe, ...mlpe.dcOptimizer } };\n    }\n    if (mlpe.isSolarInverter) {\n      return { ...component, mlpe: { ...mlpe, ...mlpe.solarInverter } };\n    }\n    if (mlpe.isCellStringOptimizer) {\n      return { ...component, mlpe: { ...mlpe, ...mlpe.cellStringOptimizer } };\n    }\n  }\n  return component;\n};\n\nconst readComponent = <T extends DataServiceComponentType>(\n  client: ApolloClient<NormalizedCacheObject>,\n  type: T,\n  id: string,\n) => {\n  const queryComponent = ComponentQueries[type];\n  const result = queryComponent(client, id) as ComponentQueryResult<T> | null;\n  return result?.component ?? null;\n};\n\nexport const peekRecord = <T extends string>(\n  client: ApolloClient<NormalizedCacheObject>,\n  type: T,\n  compId: string,\n) => {\n  const typeCamelCase = convertKebabToCamelCase(type);\n  try {\n    if (!(typeCamelCase in ComponentQueries)) {\n      throw new Error(`Invalid type: ${type}`);\n    }\n    const result = readComponent(client, typeCamelCase as DataServiceComponentType, compId);\n    return result ? formatMlpe(result) : null;\n  } catch (e) {\n    console.error(e);\n    console.error(\n      `Failed to fetch a record from apollo cache: ${typeCamelCase} ${compId} does not exist. `,\n    );\n    throw e;\n  }\n};\n","const Converter = function (numerator, definitions) {\n  this.definitions = definitions;\n  this.val = numerator;\n};\n\nConverter.prototype.from = function (from) {\n  if (this.destination) { throw new Error('.from must be called before .to') }\n\n  this.origin = this.getUnit(from);\n\n  if (!this.origin) {\n    this.throwUnsupportedUnitError(from);\n  }\n\n  return this\n};\n\nConverter.prototype.to = function (to) {\n  if (!this.origin) { throw new Error('.to must be called after .from') }\n\n  this.destination = this.getUnit(to);\n\n  let result;\n\n  if (!this.destination) {\n    this.throwUnsupportedUnitError(to);\n  }\n\n  if (this.origin.abbr === this.destination.abbr) {\n    return Object.assign({ value: this.val }, this.describe(this.destination.abbr))\n  }\n\n  result = this.val * this.origin.unit.to_anchor;\n\n  if (this.origin.unit.anchor_shift) {\n    result -= this.origin.unit.anchor_shift;\n  }\n\n  if (this.origin.system !== this.destination.system) {\n    result = this.definitions[this.origin.system].transform(result);\n  }\n\n  if (this.destination.unit.anchor_shift !== undefined) {\n    result += this.destination.unit.anchor_shift;\n  }\n\n  return Object.assign({ value: result / this.destination.unit.to_anchor }, this.describe(this.destination.abbr))\n};\n\nConverter.prototype.toBest = function (options) {\n  if (!this.origin) { throw new Error('.toBest must be called after .from') }\n\n  options = Object.assign({\n    exclude: [],\n    cutOffNumber: 1\n  }, options);\n\n  return this.list()\n    .filter(item => !options.exclude.includes(item.unit) && this.describe(item.unit).system === this.origin.system)\n    .reduce((acc, item) => {\n      const result = this.to(item.unit);\n      if (!acc || (result.value >= options.cutOffNumber && result.value < acc.value)) {\n        return result\n      } else {\n        return acc\n      }\n    }, undefined)\n};\n\nConverter.prototype.getUnit = function (abbr) {\n  const systemNames = Object.keys(this.definitions);\n  const found = systemNames.map(systemName => {\n    if (this.definitions[systemName][abbr]) {\n      return {\n        abbr: abbr,\n        system: systemName,\n        unit: this.definitions[systemName][abbr]\n      }\n    }\n  }).filter(item => item !== undefined);\n\n  return Array.isArray(found) ? found[0] : undefined\n};\n\nConverter.prototype.list = function () {\n  return this.possibilities().map(abbr => this.describe(abbr))\n};\n\nConverter.prototype.throwUnsupportedUnitError = function (what) {\n  throw new Error('Unsupported unit ' + what)\n};\n\nConverter.prototype.describe = function (abbr) {\n  if (!abbr) { throw new Error('You must select a unit') }\n\n  const unit = this.getUnit(abbr);\n\n  return {\n    unit: unit.abbr,\n    system: unit.system,\n    singular: unit.unit.name.singular,\n    plural: unit.unit.name.plural\n  }\n};\n\nConverter.prototype.possibilities = function () {\n  return Array.prototype.concat(...Object.keys(this.definitions)\n    .map(systemName => {\n      return Object.keys(this.definitions[systemName]).splice(2)\n    }))\n};\n\nfunction converter (definitions) {\n  return (val) => {\n    return new Converter(val, definitions)\n  }\n}\n\nexport default converter;\n","import utils from '../utils.js';\n\nconst acceleration = {\n  metric: {\n    baseUnit: 'g-force',\n    transform: (val) => { return val * 1 },\n    'g-force': {\n      name: {\n        singular: 'g-force',\n        plural: 'g-forces'\n      },\n      to_anchor: 9.80665\n    },\n    'm/s2': {\n      name: {\n        singular: 'Metre per second squared',\n        plural: 'Metres per second squared'\n      },\n      to_anchor: 1\n    }\n  }\n};\n\nvar acceleration$1 = utils(acceleration);\n\nexport default acceleration$1;\n","import utils from '../utils.js';\n\nconst RATIO = 1;\nconst PI = 3.141592653589793;\n\nconst angle = {\n  metric: {\n    baseUnit: 'g-force',\n    transform: (val) => { return val * RATIO },\n    rad: {\n      name: {\n        singular: 'radian',\n        plural: 'radians'\n      },\n      to_anchor: 180 / PI\n    },\n    deg: {\n      name: {\n        singular: 'degree',\n        plural: 'degrees'\n      },\n      to_anchor: 1\n    },\n    grad: {\n      name: {\n        singular: 'gradian',\n        plural: 'gradians'\n      },\n      to_anchor: 9 / 10\n    },\n    arcmin: {\n      name: {\n        singular: 'arcminute',\n        plural: 'arcminutes'\n      },\n      to_anchor: 1 / 60\n    },\n    arcsec: {\n      name: {\n        singular: 'arcsecond',\n        plural: 'arcseconds'\n      },\n      to_anchor: 1 / 3600\n    }\n  }\n};\n\nvar angle$1 = utils(angle);\n\nexport default angle$1;\n","import utils from '../utils.js';\n\nconst apparentPower = {\n  metric: {\n    baseUnit: 'VA',\n    transform: (val) => { return val * 1 },\n    VA: {\n      name: {\n        singular: 'Volt-Ampere',\n        plural: 'Volt-Amperes'\n      },\n      to_anchor: 1\n    },\n    mVA: {\n      name: {\n        singular: 'Millivolt-Ampere',\n        plural: 'Millivolt-Amperes'\n      },\n      to_anchor: 0.001\n    },\n    kVA: {\n      name: {\n        singular: 'Kilovolt-Ampere',\n        plural: 'Kilovolt-Amperes'\n      },\n      to_anchor: 1000\n    },\n    MVA: {\n      name: {\n        singular: 'Megavolt-Ampere',\n        plural: 'Megavolt-Amperes'\n      },\n      to_anchor: 1000000\n    },\n    GVA: {\n      name: {\n        singular: 'Gigavolt-Ampere',\n        plural: 'Gigavolt-Amperes'\n      },\n      to_anchor: 1000000000\n    }\n  }\n};\n\nvar apparentPower$1 = utils(apparentPower);\n\nexport default apparentPower$1;\n","import utils from '../utils.js';\n\nconst RATIO = 10.7639;\n\nconst area = {\n  metric: {\n    baseUnit: 'm2',\n    transform: (val) => { return val * RATIO },\n    mm2: {\n      name: {\n        singular: 'Square Millimeter',\n        plural: 'Square Millimeters'\n      },\n      to_anchor: 1 / 1000000\n    },\n    cm2: {\n      name: {\n        singular: 'Square Centimeter',\n        plural: 'Square Centimeters'\n      },\n      to_anchor: 1 / 10000\n    },\n    m2: {\n      name: {\n        singular: 'Square Meter',\n        plural: 'Square Meters'\n      },\n      to_anchor: 1\n    },\n    ha: {\n      name: {\n        singular: 'Hectare',\n        plural: 'Hectares'\n      },\n      to_anchor: 10000\n    },\n    km2: {\n      name: {\n        singular: 'Square Kilometer',\n        plural: 'Square Kilometers'\n      },\n      to_anchor: 1000000\n    }\n  },\n  imperial: {\n    baseUnit: 'ft2',\n    transform: (val) => { return val * 1 / RATIO },\n    'in2': {\n      name: {\n        singular: 'Square Inch',\n        plural: 'Square Inches'\n      },\n      to_anchor: 1 / 144\n    },\n    yd2: {\n      name: {\n        singular: 'Square Yard',\n        plural: 'Square Yards'\n      },\n      to_anchor: 9\n    },\n    ft2: {\n      name: {\n        singular: 'Square Foot',\n        plural: 'Square Feet'\n      },\n      to_anchor: 1\n    },\n    ac: {\n      name: {\n        singular: 'Acre',\n        plural: 'Acres'\n      },\n      to_anchor: 43560\n    },\n    mi2: {\n      name: {\n        singular: 'Square Mile',\n        plural: 'Square Miles'\n      },\n      to_anchor: 27878400\n    }\n  }\n};\n\nvar area$1 = utils(area);\n\nexport default area$1;\n","import utils from '../utils.js';\n\nconst RATIO = 1;\n\nconst charge = {\n  metric: {\n    baseUnit: 'c',\n    transform: (val) => { return RATIO * val },\n    c: {\n      name: {\n        singular: 'Coulomb',\n        plural: 'Coulombs'\n      },\n      to_anchor: 1\n    },\n    mC: {\n      name: {\n        singular: 'Millicoulomb',\n        plural: 'Millicoulombs'\n      },\n      to_anchor: 1 / 1000\n    },\n    μC: {\n      name: {\n        singular: 'Microcoulomb',\n        plural: 'Microcoulombs'\n      },\n      to_anchor: 1 / 1000000\n    },\n    nC: {\n      name: {\n        singular: 'Nanocoulomb',\n        plural: 'Nanocoulombs'\n      },\n      to_anchor: 1e-9\n    },\n    pC: {\n      name: {\n        singular: 'Picocoulomb',\n        plural: 'Picocoulombs'\n      },\n      to_anchor: 1e-12\n    }\n  }\n};\n\nvar charge$1 = utils(charge);\n\nexport default charge$1;\n","import utils from '../utils.js';\n\nconst RATIO = 1;\n\nconst current = {\n  metric: {\n    baseUnit: 'a',\n    transform: (val) => { return RATIO * val },\n    A: {\n      name: {\n        singular: 'Ampere',\n        plural: 'Amperes'\n      },\n      to_anchor: 1\n    },\n    mA: {\n      name: {\n        singular: 'Milliampere',\n        plural: 'Milliamperes'\n      },\n      to_anchor: 0.001\n    },\n    kA: {\n      name: {\n        singular: 'Kiloampere',\n        plural: 'Kiloamperes'\n      },\n      to_anchor: 1000\n    }\n  }\n};\n\nvar current$1 = utils(current);\n\nexport default current$1;\n","import utils from '../utils.js';\n\nconst RATIO = 8;\n\nconst digitals = {\n  bits: {\n    baseUnit: 'b',\n    transform: (val) => { return val * 1 / RATIO },\n    b: {\n      name: {\n        singular: 'Bit',\n        plural: 'Bits'\n      },\n      to_anchor: 1\n    },\n    Kb: {\n      name: {\n        singular: 'Kilobit',\n        plural: 'Kilobits'\n      },\n      to_anchor: 1024\n    },\n    Mb: {\n      name: {\n        singular: 'Megabit',\n        plural: 'Megabits'\n      },\n      to_anchor: 1048576\n    },\n    Gb: {\n      name: {\n        singular: 'Gigabit',\n        plural: 'Gigabits'\n      },\n      to_anchor: 1073741824\n    },\n    Tb: {\n      name: {\n        singular: 'Terabit',\n        plural: 'Terabits'\n      },\n      to_anchor: 1099511627776\n    }\n  },\n\n  bytes: {\n    baseUnit: 'B',\n    transform: (val) => { return val * RATIO },\n    B: {\n      name: {\n        singular: 'Byte',\n        plural: 'Bytes'\n      },\n      to_anchor: 1\n    },\n    KB: {\n      name: {\n        singular: 'Kilobyte',\n        plural: 'Kilobytes'\n      },\n      to_anchor: 1024\n    },\n    MB: {\n      name: {\n        singular: 'Megabyte',\n        plural: 'Megabytes'\n      },\n      to_anchor: 1048576\n    },\n    GB: {\n      name: {\n        singular: 'Gigabyte',\n        plural: 'Gigabytes'\n      },\n      to_anchor: 1073741824\n    },\n    TB: {\n      name: {\n        singular: 'Terabyte',\n        plural: 'Terabytes'\n      },\n      to_anchor: 1099511627776\n    }\n  }\n};\n\nvar digital = utils(digitals);\n\nexport default digital;\n","import utils from '../utils.js';\n\nconst RATIO = 1;\nconst each = {\n  metric: {\n    baseUnit: 'ea',\n    transform: (val) => { return RATIO * val },\n    ea: {\n      name: {\n        singular: 'Each',\n        plural: 'Each'\n      },\n      to_anchor: 1\n    },\n    dz: {\n      name: {\n        singular: 'Dozen',\n        plural: 'Dozens'\n      },\n      to_anchor: 12\n    }\n  }\n};\n\nvar each$1 = utils(each);\n\nexport default each$1;\n","import utils from '../utils.js';\n\nconst RATIO = 1;\n\nconst energy = {\n  metric: {\n    baseUnit: 'J',\n    transform: (val) => { return RATIO * val },\n    Wh: {\n      name: {\n        singular: 'Watt-hour',\n        plural: 'Watt-hours'\n      },\n      to_anchor: 3600\n    },\n    mWh: {\n      name: {\n        singular: 'Milliwatt-hour',\n        plural: 'Milliwatt-hours'\n      },\n      to_anchor: 3.6\n    },\n    kWh: {\n      name: {\n        singular: 'Kilowatt-hour',\n        plural: 'Kilowatt-hours'\n      },\n      to_anchor: 3600000\n    },\n    MWh: {\n      name: {\n        singular: 'Megawatt-hour',\n        plural: 'Megawatt-hours'\n      },\n      to_anchor: 3600000000\n    },\n    GWh: {\n      name: {\n        singular: 'Gigawatt-hour',\n        plural: 'Gigawatt-hours'\n      },\n      to_anchor: 3600000000000\n    },\n    J: {\n      name: {\n        singular: 'Joule',\n        plural: 'Joules'\n      },\n      to_anchor: 1\n    },\n    kJ: {\n      name: {\n        singular: 'Kilojoule',\n        plural: 'Kilojoules'\n      },\n      to_anchor: 1000\n    }\n  }\n};\n\nvar energy$1 = utils(energy);\n\nexport default energy$1;\n","import utils from '../utils.js';\n\nconst RATIO = 4.44822;\n\nconst force = {\n  metric: {\n    baseUnit: 'N',\n    transform: (val) => { return val * 1 / RATIO },\n    N: {\n      name: {\n        singular: 'Newton',\n        plural: 'Newtons'\n      },\n      to_anchor: 1\n    },\n    kN: {\n      name: {\n        singular: 'Kilonewton',\n        plural: 'Kilonewtons'\n      },\n      to_anchor: 1000\n    }\n  },\n  imperial: {\n    baseUnit: 'lbf',\n    transform: (val) => { return RATIO * val },\n    lbf: {\n      name: {\n        singular: 'Pound-force',\n        plural: 'Pound-forces'\n      },\n      to_anchor: 1\n    }\n  }\n};\n\nvar force$1 = utils(force);\n\nexport default force$1;\n","import utils from '../utils.js';\n\nconst RATIO = 1;\nconst PI = 3.141592653589793;\n\nconst frequency = {\n  metric: {\n    baseUnit: 'Hz',\n    transform: (val) => { return RATIO * val },\n    mHz: {\n      name: {\n        singular: 'millihertz',\n        plural: 'millihertz'\n      },\n      to_anchor: 1 / 1000\n    },\n    Hz: {\n      name: {\n        singular: 'hertz',\n        plural: 'hertz'\n      },\n      to_anchor: 1\n    },\n    kHz: {\n      name: {\n        singular: 'kilohertz',\n        plural: 'kilohertz'\n      },\n      to_anchor: 1000\n    },\n    MHz: {\n      name: {\n        singular: 'megahertz',\n        plural: 'megahertz'\n      },\n      to_anchor: 1000 * 1000\n    },\n    GHz: {\n      name: {\n        singular: 'gigahertz',\n        plural: 'gigahertz'\n      },\n      to_anchor: 1000 * 1000 * 1000\n    },\n    THz: {\n      name: {\n        singular: 'terahertz',\n        plural: 'terahertz'\n      },\n      to_anchor: 1000 * 1000 * 1000 * 1000\n    },\n    rpm: {\n      name: {\n        singular: 'rotation per minute',\n        plural: 'rotations per minute'\n      },\n      to_anchor: 1 / 60\n    },\n    'deg/s': {\n      name: {\n        singular: 'degree per second',\n        plural: 'degrees per second'\n      },\n      to_anchor: 1 / 360\n    },\n    'rad/s': {\n      name: {\n        singular: 'radian per second',\n        plural: 'radians per second'\n      },\n      to_anchor: 1 / (PI * 2)\n    }\n  }\n};\n\nvar frequency$1 = utils(frequency);\n\nexport default frequency$1;\n","import utils from '../utils.js';\n\nconst RATIO = 10.76391;\n\nconst illuminance = {\n  metric: {\n    baseUnit: 'lx',\n    transform: (val) => { return val * 1 / RATIO },\n    'lx': {\n      name: {\n        singular: 'Lux',\n        plural: 'Lux'\n      },\n      to_anchor: 1\n    }\n  },\n  imperial: {\n    baseUnit: 'ft-cd',\n    transform: (val) => { return RATIO * val },\n    'ft-cd': {\n      name: {\n        singular: 'Foot-candle',\n        plural: 'Foot-candles'\n      },\n      to_anchor: 1\n    }\n  }\n};\n\nvar illuminance$1 = utils(illuminance);\n\nexport default illuminance$1;\n","import utils from '../utils.js';\n\nconst RATIO = 3.28084;\n\nconst length = {\n  metric: {\n    baseUnit: 'm',\n    transform: (val) => { return val * RATIO },\n    mm: {\n      name: {\n        singular: 'Millimeter',\n        plural: 'Millimeters'\n      },\n      to_anchor: 1 / 1000\n    },\n    cm: {\n      name: {\n        singular: 'Centimeter',\n        plural: 'Centimeters'\n      },\n      to_anchor: 1 / 100\n    },\n    m: {\n      name: {\n        singular: 'Meter',\n        plural: 'Meters'\n      },\n      to_anchor: 1\n    },\n    km: {\n      name: {\n        singular: 'Kilometer',\n        plural: 'Kilometers'\n      },\n      to_anchor: 1000\n    }\n  },\n  imperial: {\n    baseUnit: 'ft',\n    transform: (val) => { return val * 1 / RATIO },\n    'in': {\n      name: {\n        singular: 'Inch',\n        plural: 'Inches'\n      },\n      to_anchor: 1 / 12\n    },\n    yd: {\n      name: {\n        singular: 'Yard',\n        plural: 'Yards'\n      },\n      to_anchor: 3\n    },\n    'ft-us': {\n      name: {\n        singular: 'US Survey Foot',\n        plural: 'US Survey Feet'\n      },\n      to_anchor: 1.000002\n    },\n    ft: {\n      name: {\n        singular: 'Foot',\n        plural: 'Feet'\n      },\n      to_anchor: 1\n    },\n    fathom: {\n      name: {\n        singular: 'Fathom',\n        plural: 'Fathoms'\n      },\n      to_anchor: 6\n    },\n    mi: {\n      name: {\n        singular: 'Mile',\n        plural: 'Miles'\n      },\n      to_anchor: 5280\n    },\n    nMi: {\n      name: {\n        singular: 'Nautical Mile',\n        plural: 'Nautical Miles'\n      },\n      to_anchor: 6076.12\n    }\n  }\n};\n\nvar length$1 = utils(length);\n\nexport default length$1;\n","import utils from '../utils.js';\n\nconst RATIO = 453.592;\n\nconst mass = {\n  metric: {\n    baseUnit: 'g',\n    transform: (val) => { return val * 1 / RATIO },\n    mcg: {\n      name: {\n        singular: 'Microgram',\n        plural: 'Micrograms'\n      },\n      to_anchor: 1 / 1000000\n    },\n    mg: {\n      name: {\n        singular: 'Milligram',\n        plural: 'Milligrams'\n      },\n      to_anchor: 1 / 1000\n    },\n    g: {\n      name: {\n        singular: 'Gram',\n        plural: 'Grams'\n      },\n      to_anchor: 1\n    },\n    kg: {\n      name: {\n        singular: 'Kilogram',\n        plural: 'Kilograms'\n      },\n      to_anchor: 1000\n    },\n    mt: {\n      name: {\n        singular: 'Metric Tonne',\n        plural: 'Metric Tonnes'\n      },\n      to_anchor: 1000000\n    }\n  },\n  imperial: {\n    baseUnit: 'lb',\n    transform: (val) => { return val * RATIO },\n    oz: {\n      name: {\n        singular: 'Ounce',\n        plural: 'Ounces'\n      },\n      to_anchor: 1 / 16\n    },\n    lb: {\n      name: {\n        singular: 'Pound',\n        plural: 'Pounds'\n      },\n      to_anchor: 1\n    },\n    t: {\n      name: {\n        singular: 'Ton',\n        plural: 'Tons'\n      },\n      to_anchor: 2000\n    }\n  }\n};\n\nvar mass$1 = utils(mass);\n\nexport default mass$1;\n","import utils from '../utils.js';\n\nconst RATIO = 0.3048;\n\nconst pace = {\n  metric: {\n    baseUnit: 's/m',\n    transform: (val) => { return val * RATIO },\n    'min/km': {\n      name: {\n        singular: 'Minute per kilometre',\n        plural: 'Minutes per kilometre'\n      },\n      to_anchor: 0.06\n    },\n    's/m': {\n      name: {\n        singular: 'Second per metre',\n        plural: 'Seconds per metre'\n      },\n      to_anchor: 1\n    }\n  },\n  imperial: {\n    baseUnit: 's/ft',\n    transform: (val) => { return val * 1 / RATIO },\n    'min/mi': {\n      name: {\n        singular: 'Minute per mile',\n        plural: 'Minutes per mile'\n      },\n      to_anchor: 0.0113636\n    },\n    's/ft': {\n      name: {\n        singular: 'Second per foot',\n        plural: 'Seconds per foot'\n      },\n      to_anchor: 1\n    }\n  }\n};\n\nvar pace$1 = utils(pace);\n\nexport default pace$1;\n","import utils from '../utils.js';\n\nconst RATIO = 0.000001;\n\nconst partsPer = {\n  metric: {\n    baseUnit: 'ppm',\n    transform: (val) => { return val * RATIO },\n    ppm: {\n      name: {\n        singular: 'Part-per Million',\n        plural: 'Parts-per Million'\n      },\n      to_anchor: 1\n    },\n    ppb: {\n      name: {\n        singular: 'Part-per Billion',\n        plural: 'Parts-per Billion'\n      },\n      to_anchor: 0.001\n    },\n    ppt: {\n      name: {\n        singular: 'Part-per Trillion',\n        plural: 'Parts-per Trillion'\n      },\n      to_anchor: 0.000001\n    },\n    ppq: {\n      name: {\n        singular: 'Part-per Quadrillion',\n        plural: 'Parts-per Quadrillion'\n      },\n      to_anchor: 0.000000001\n    }\n  }\n};\n\nvar partsPer$1 = utils(partsPer);\n\nexport default partsPer$1;\n","import utils from '../utils.js';\n\nconst RATIO = 1;\n\nconst power = {\n  metric: {\n    baseUnit: 'W',\n    transform: (val) => { return val * RATIO },\n    W: {\n      name: {\n        singular: 'Watt',\n        plural: 'Watts'\n      },\n      to_anchor: 1\n    },\n    mW: {\n      name: {\n        singular: 'Milliwatt',\n        plural: 'Milliwatts'\n      },\n      to_anchor: 0.001\n    },\n    kW: {\n      name: {\n        singular: 'Kilowatt',\n        plural: 'Kilowatts'\n      },\n      to_anchor: 1000\n    },\n    MW: {\n      name: {\n        singular: 'Megawatt',\n        plural: 'Megawatts'\n      },\n      to_anchor: 1000000\n    },\n    GW: {\n      name: {\n        singular: 'Gigawatt',\n        plural: 'Gigawatts'\n      },\n      to_anchor: 1000000000\n    }\n  }\n};\nvar power$1 = utils(power);\n\nexport default power$1;\n","import utils from '../utils.js';\n\nconst RATIO = 0.00014503768078;\n\nconst pressure = {\n  metric: {\n    baseUnit: 'kPa',\n    transform: (val) => { return val * RATIO },\n    Pa: {\n      name: {\n        singular: 'pascal',\n        plural: 'pascals'\n      },\n      to_anchor: 1 / 1000\n    },\n    kPa: {\n      name: {\n        singular: 'kilopascal',\n        plural: 'kilopascals'\n      },\n      to_anchor: 1\n    },\n    MPa: {\n      name: {\n        singular: 'megapascal',\n        plural: 'megapascals'\n      },\n      to_anchor: 1000\n    },\n    hPa: {\n      name: {\n        singular: 'hectopascal',\n        plural: 'hectopascals'\n      },\n      to_anchor: 1 / 10\n    },\n    bar: {\n      name: {\n        singular: 'bar',\n        plural: 'bar'\n      },\n      to_anchor: 100\n    },\n    torr: {\n      name: {\n        singular: 'torr',\n        plural: 'torr'\n      },\n      to_anchor: 101325 / 760000\n    }\n  },\n\n  imperial: {\n    baseUnit: 'psi',\n    transform: (val) => { return val * 1 / RATIO },\n    psi: {\n      name: {\n        singular: 'pound per square inch',\n        plural: 'pounds per square inch'\n      },\n      to_anchor: 1 / 1000\n    },\n    ksi: {\n      name: {\n        singular: 'kilopound per square inch',\n        plural: 'kilopound per square inch'\n      },\n      to_anchor: 1\n    }\n  }\n};\n\nvar pressure$1 = utils(pressure);\n\nexport default pressure$1;\n","import utils from '../utils.js';\n\nconst RATIO = 1;\n\nconst reactiveEnergy = {\n  metric: {\n    baseUnit: 'VARh',\n    transform: (val) => { return val * RATIO },\n    VARh: {\n      name: {\n        singular: 'Volt-Ampere Reactive Hour',\n        plural: 'Volt-Amperes Reactive Hour'\n      },\n      to_anchor: 1\n    },\n    mVARh: {\n      name: {\n        singular: 'Millivolt-Ampere Reactive Hour',\n        plural: 'Millivolt-Amperes Reactive Hour'\n      },\n      to_anchor: 0.001\n    },\n    kVARh: {\n      name: {\n        singular: 'Kilovolt-Ampere Reactive Hour',\n        plural: 'Kilovolt-Amperes Reactive Hour'\n      },\n      to_anchor: 1000\n    },\n    MVARh: {\n      name: {\n        singular: 'Megavolt-Ampere Reactive Hour',\n        plural: 'Megavolt-Amperes Reactive Hour'\n      },\n      to_anchor: 1000000\n    },\n    GVARh: {\n      name: {\n        singular: 'Gigavolt-Ampere Reactive Hour',\n        plural: 'Gigavolt-Amperes Reactive Hour'\n      },\n      to_anchor: 1000000000\n    }\n  }\n};\n\nvar reactiveEnergy$1 = utils(reactiveEnergy);\n\nexport default reactiveEnergy$1;\n","import utils from '../utils.js';\n\nconst RATIO = 1;\n\nconst reactivePower = {\n  metric: {\n    baseUnit: 'VAR',\n    transform: (val) => { return val * RATIO },\n    VAR: {\n      name: {\n        singular: 'Volt-Ampere Reactive',\n        plural: 'Volt-Amperes Reactive'\n      },\n      to_anchor: 1\n    },\n    mVAR: {\n      name: {\n        singular: 'Millivolt-Ampere Reactive',\n        plural: 'Millivolt-Amperes Reactive'\n      },\n      to_anchor: 0.001\n    },\n    kVAR: {\n      name: {\n        singular: 'Kilovolt-Ampere Reactive',\n        plural: 'Kilovolt-Amperes Reactive'\n      },\n      to_anchor: 1000\n    },\n    MVAR: {\n      name: {\n        singular: 'Megavolt-Ampere Reactive',\n        plural: 'Megavolt-Amperes Reactive'\n      },\n      to_anchor: 1000000\n    },\n    GVAR: {\n      name: {\n        singular: 'Gigavolt-Ampere Reactive',\n        plural: 'Gigavolt-Amperes Reactive'\n      },\n      to_anchor: 1000000000\n    }\n  }\n};\n\nvar reactivePower$1 = utils(reactivePower);\n\nexport default reactivePower$1;\n","import utils from '../utils.js';\n\nconst RATIO = 1.609344;\n\nconst speed = {\n  metric: {\n    baseUnit: 'N',\n    transform: (val) => { return val * 1 / RATIO },\n    'm/s': {\n      name: {\n        singular: 'Metre per second',\n        plural: 'Metres per second'\n      },\n      to_anchor: 3.6\n    },\n    'km/h': {\n      name: {\n        singular: 'Kilometre per hour',\n        plural: 'Kilometres per hour'\n      },\n      to_anchor: 1\n    }\n  },\n  imperial: {\n    baseUnit: 'm/h',\n    transform: (val) => { return val * RATIO },\n    'm/h': {\n      name: {\n        singular: 'Mile per hour',\n        plural: 'Miles per hour'\n      },\n      to_anchor: 1\n    },\n    knot: {\n      name: {\n        singular: 'Knot',\n        plural: 'Knots'\n      },\n      to_anchor: 1.150779\n    },\n    'ft/s': {\n      name: {\n        singular: 'Foot per second',\n        plural: 'Feet per second'\n      },\n      to_anchor: 0.681818\n    }\n  }\n};\n\nvar speed$1 = utils(speed);\n\nexport default speed$1;\n","import utils from '../utils.js';\n\nconst temperature = {\n  metric: {\n    baseUnit: 'C',\n    transform: (val) => { return val / (5 / 9) + 32 },\n    C: {\n      name: {\n        singular: 'degree Celsius',\n        plural: 'degrees Celsius'\n      },\n      to_anchor: 1,\n      anchor_shift: 0\n    },\n    K: {\n      name: {\n        singular: 'degree Kelvin',\n        plural: 'degrees Kelvin'\n      },\n      to_anchor: 1,\n      anchor_shift: 273.15\n    }\n  },\n  imperial: {\n    baseUnit: 'F',\n    transform: (val) => { return (val - 32) * (5 / 9) },\n    F: {\n      name: {\n        singular: 'degree Fahrenheit',\n        plural: 'degrees Fahrenheit'\n      },\n      to_anchor: 1\n    },\n    R: {\n      name: {\n        singular: 'degree Rankine',\n        plural: 'degrees Rankine'\n      },\n      to_anchor: 1,\n      anchor_shift: 459.67\n    }\n  }\n};\n\nvar temperature$1 = utils(temperature);\n\nexport default temperature$1;\n","import utils from '../utils.js';\n\nconst RATIO = 1;\nconst daysInYear = 365.25;\n\nconst time = {\n  metric: {\n    baseUnit: 's',\n    transform: (val) => { return val * RATIO },\n    ns: {\n      name: {\n        singular: 'Nanosecond',\n        plural: 'Nanoseconds'\n      },\n      to_anchor: 1 / 1000000000\n    },\n    mu: {\n      name: {\n        singular: 'Microsecond',\n        plural: 'Microseconds'\n      },\n      to_anchor: 1 / 1000000\n    },\n    ms: {\n      name: {\n        singular: 'Millisecond',\n        plural: 'Milliseconds'\n      },\n      to_anchor: 1 / 1000\n    },\n    s: {\n      name: {\n        singular: 'Second',\n        plural: 'Seconds'\n      },\n      to_anchor: 1\n    },\n    min: {\n      name: {\n        singular: 'Minute',\n        plural: 'Minutes'\n      },\n      to_anchor: 60\n    },\n    h: {\n      name: {\n        singular: 'Hour',\n        plural: 'Hours'\n      },\n      to_anchor: 60 * 60\n    },\n    d: {\n      name: {\n        singular: 'Day',\n        plural: 'Days'\n      },\n      to_anchor: 60 * 60 * 24\n    },\n    week: {\n      name: {\n        singular: 'Week',\n        plural: 'Weeks'\n      },\n      to_anchor: 60 * 60 * 24 * 7\n    },\n    month: {\n      name: {\n        singular: 'Month',\n        plural: 'Months'\n      },\n      to_anchor: 60 * 60 * 24 * daysInYear / 12\n    },\n    year: {\n      name: {\n        singular: 'Year',\n        plural: 'Years'\n      },\n      to_anchor: 60 * 60 * 24 * daysInYear\n    }\n  }\n};\n\nvar time$1 = utils(time);\n\nexport default time$1;\n","import utils from '../utils.js';\n\nconst RATIO = 1;\n\nconst voltage = {\n  metric: {\n    baseUnit: 'V',\n    transform: (val) => { return val * RATIO },\n    V: {\n      name: {\n        singular: 'Volt',\n        plural: 'Volts'\n      },\n      to_anchor: 1\n    },\n    mV: {\n      name: {\n        singular: 'Millivolt',\n        plural: 'Millivolts'\n      },\n      to_anchor: 0.001\n    },\n    kV: {\n      name: {\n        singular: 'Kilovolt',\n        plural: 'Kilovolts'\n      },\n      to_anchor: 1000\n    }\n  }\n};\n\nvar voltage$1 = utils(voltage);\n\nexport default voltage$1;\n","import utils from '../utils.js';\n\nconst RATIO = 33.8140226;\n\nconst volume = {\n  metric: {\n    baseUnit: 'l',\n    transform: (val) => { return RATIO * val },\n    mm3: {\n      name: {\n        singular: 'Cubic Millimeter',\n        plural: 'Cubic Millimeters'\n      },\n      to_anchor: 1 / 1000000\n    },\n    cm3: {\n      name: {\n        singular: 'Cubic Centimeter',\n        plural: 'Cubic Centimeters'\n      },\n      to_anchor: 1 / 1000\n    },\n    ml: {\n      name: {\n        singular: 'Millilitre',\n        plural: 'Millilitres'\n      },\n      to_anchor: 1 / 1000\n    },\n    cl: {\n      name: {\n        singular: 'Centilitre',\n        plural: 'Centilitres'\n      },\n      to_anchor: 1 / 100\n    },\n    dl: {\n      name: {\n        singular: 'Decilitre',\n        plural: 'Decilitres'\n      },\n      to_anchor: 1 / 10\n    },\n    l: {\n      name: {\n        singular: 'Litre',\n        plural: 'Litres'\n      },\n      to_anchor: 1\n    },\n    kl: {\n      name: {\n        singular: 'Kilolitre',\n        plural: 'Kilolitres'\n      },\n      to_anchor: 1000\n    },\n    m3: {\n      name: {\n        singular: 'Cubic meter',\n        plural: 'Cubic meters'\n      },\n      to_anchor: 1000\n    },\n    km3: {\n      name: {\n        singular: 'Cubic kilometer',\n        plural: 'Cubic kilometers'\n      },\n      to_anchor: 1000000000000\n    },\n\n    // Swedish units\n    krm: {\n      name: {\n        singular: 'Matsked',\n        plural: 'Matskedar'\n      },\n      to_anchor: 1 / 1000\n    },\n    tsk: {\n      name: {\n        singular: 'Tesked',\n        plural: 'Teskedar'\n      },\n      to_anchor: 5 / 1000\n    },\n    msk: {\n      name: {\n        singular: 'Matsked',\n        plural: 'Matskedar'\n      },\n      to_anchor: 15 / 1000\n    },\n    kkp: {\n      name: {\n        singular: 'Kaffekopp',\n        plural: 'Kaffekoppar'\n      },\n      to_anchor: 150 / 1000\n    },\n    glas: {\n      name: {\n        singular: 'Glas',\n        plural: 'Glas'\n      },\n      to_anchor: 200 / 1000\n    },\n    kanna: {\n      name: {\n        singular: 'Kanna',\n        plural: 'Kannor'\n      },\n      to_anchor: 2.617\n    }\n  },\n\n  imperial: {\n    baseUnit: 'fl-oz',\n    transform: (val) => { return val * 1 / RATIO },\n    tsp: {\n      name: {\n        singular: 'Teaspoon',\n        plural: 'Teaspoons'\n      },\n      to_anchor: 1 / 6\n    },\n    Tbs: {\n      name: {\n        singular: 'Tablespoon',\n        plural: 'Tablespoons'\n      },\n      to_anchor: 1 / 2\n    },\n    in3: {\n      name: {\n        singular: 'Cubic inch',\n        plural: 'Cubic inches'\n      },\n      to_anchor: 0.55411\n    },\n    'fl-oz': {\n      name: {\n        singular: 'Fluid Ounce',\n        plural: 'Fluid Ounces'\n      },\n      to_anchor: 1\n    },\n    cup: {\n      name: {\n        singular: 'Cup',\n        plural: 'Cups'\n      },\n      to_anchor: 8\n    },\n    pnt: {\n      name: {\n        singular: 'Pint',\n        plural: 'Pints'\n      },\n      to_anchor: 16\n    },\n    qt: {\n      name: {\n        singular: 'Quart',\n        plural: 'Quarts'\n      },\n      to_anchor: 32\n    },\n    gal: {\n      name: {\n        singular: 'Gallon',\n        plural: 'Gallons'\n      },\n      to_anchor: 128\n    },\n    ft3: {\n      name: {\n        singular: 'Cubic foot',\n        plural: 'Cubic feet'\n      },\n      to_anchor: 957.506\n    },\n    yd3: {\n      name: {\n        singular: 'Cubic yard',\n        plural: 'Cubic yards'\n      },\n      to_anchor: 25852.7\n    }\n  }\n};\n\nvar volume$1 = utils(volume);\n\nexport default volume$1;\n","import utils from '../utils.js';\n\nconst RATIO = 33.8140227;\n\nconst volumeFlowRate = {\n  metric: {\n    baseUnit: 'l/s',\n    transform: (val) => { return val * RATIO },\n    'mm3/s': {\n      name: {\n        singular: 'Cubic Millimeter per second',\n        plural: 'Cubic Millimeters per second'\n      },\n      to_anchor: 1 / 1000000\n    },\n    'cm3/s': {\n      name: {\n        singular: 'Cubic Centimeter per second',\n        plural: 'Cubic Centimeters per second'\n      },\n      to_anchor: 1 / 1000\n    },\n    'ml/s': {\n      name: {\n        singular: 'Millilitre per second',\n        plural: 'Millilitres per second'\n      },\n      to_anchor: 1 / 1000\n    },\n    'cl/s': {\n      name: {\n        singular: 'Centilitre per second',\n        plural: 'Centilitres per second'\n      },\n      to_anchor: 1 / 100\n    },\n    'dl/s': {\n      name: {\n        singular: 'Decilitre per second',\n        plural: 'Decilitres per second'\n      },\n      to_anchor: 1 / 10\n    },\n    'l/s': {\n      name: {\n        singular: 'Litre per second',\n        plural: 'Litres per second'\n      },\n      to_anchor: 1\n    },\n    'l/min': {\n      name: {\n        singular: 'Litre per minute',\n        plural: 'Litres per minute'\n      },\n      to_anchor: 1 / 60\n    },\n    'l/h': {\n      name: {\n        singular: 'Litre per hour',\n        plural: 'Litres per hour'\n      },\n      to_anchor: 1 / 3600\n    },\n    'kl/s': {\n      name: {\n        singular: 'Kilolitre per second',\n        plural: 'Kilolitres per second'\n      },\n      to_anchor: 1000\n    },\n    'kl/min': {\n      name: {\n        singular: 'Kilolitre per minute',\n        plural: 'Kilolitres per minute'\n      },\n      to_anchor: 50 / 3\n    },\n    'kl/h': {\n      name: {\n        singular: 'Kilolitre per hour',\n        plural: 'Kilolitres per hour'\n      },\n      to_anchor: 5 / 18\n    },\n    'm3/s': {\n      name: {\n        singular: 'Cubic meter per second',\n        plural: 'Cubic meters per second'\n      },\n      to_anchor: 1000\n    },\n    'm3/min': {\n      name: {\n        singular: 'Cubic meter per minute',\n        plural: 'Cubic meters per minute'\n      },\n      to_anchor: 50 / 3\n    },\n    'm3/h': {\n      name: {\n        singular: 'Cubic meter per hour',\n        plural: 'Cubic meters per hour'\n      },\n      to_anchor: 5 / 18\n    },\n    'km3/s': {\n      name: {\n        singular: 'Cubic kilometer per second',\n        plural: 'Cubic kilometers per second'\n      },\n      to_anchor: 1000000000000\n    }\n  },\n  imperial: {\n    baseUnit: 'fl-oz/s',\n    transform: (val) => { return val * 1 / RATIO },\n    'tsp/s': {\n      name: {\n        singular: 'Teaspoon per second',\n        plural: 'Teaspoons per second'\n      },\n      to_anchor: 1 / 6\n    },\n    'Tbs/s': {\n      name: {\n        singular: 'Tablespoon per second',\n        plural: 'Tablespoons per second'\n      },\n      to_anchor: 1 / 2\n    },\n    'in3/s': {\n      name: {\n        singular: 'Cubic inch per second',\n        plural: 'Cubic inches per second'\n      },\n      to_anchor: 0.55411\n    },\n    'in3/min': {\n      name: {\n        singular: 'Cubic inch per minute',\n        plural: 'Cubic inches per minute'\n      },\n      to_anchor: 0.55411 / 60\n    },\n    'in3/h': {\n      name: {\n        singular: 'Cubic inch per hour',\n        plural: 'Cubic inches per hour'\n      },\n      to_anchor: 0.55411 / 3600\n    },\n    'fl-oz/s': {\n      name: {\n        singular: 'Fluid Ounce per second',\n        plural: 'Fluid Ounces per second'\n      },\n      to_anchor: 1\n    },\n    'fl-oz/min': {\n      name: {\n        singular: 'Fluid Ounce per minute',\n        plural: 'Fluid Ounces per minute'\n      },\n      to_anchor: 1 / 60\n    },\n    'fl-oz/h': {\n      name: {\n        singular: 'Fluid Ounce per hour',\n        plural: 'Fluid Ounces per hour'\n      },\n      to_anchor: 1 / 3600\n    },\n    'cup/s': {\n      name: {\n        singular: 'Cup per second',\n        plural: 'Cups per second'\n      },\n      to_anchor: 8\n    },\n    'pnt/s': {\n      name: {\n        singular: 'Pint per second',\n        plural: 'Pints per second'\n      },\n      to_anchor: 16\n    },\n    'pnt/min': {\n      name: {\n        singular: 'Pint per minute',\n        plural: 'Pints per minute'\n      },\n      to_anchor: 4 / 15\n    },\n    'pnt/h': {\n      name: {\n        singular: 'Pint per hour',\n        plural: 'Pints per hour'\n      },\n      to_anchor: 1 / 225\n    },\n    'qt/s': {\n      name: {\n        singular: 'Quart per second',\n        plural: 'Quarts per second'\n      },\n      to_anchor: 32\n    },\n    'gal/s': {\n      name: {\n        singular: 'Gallon per second',\n        plural: 'Gallons per second'\n      },\n      to_anchor: 128\n    },\n    'gal/min': {\n      name: {\n        singular: 'Gallon per minute',\n        plural: 'Gallons per minute'\n      },\n      to_anchor: 32 / 15\n    },\n    'gal/h': {\n      name: {\n        singular: 'Gallon per hour',\n        plural: 'Gallons per hour'\n      },\n      to_anchor: 8 / 225\n    },\n    'ft3/s': {\n      name: {\n        singular: 'Cubic foot per second',\n        plural: 'Cubic feet per second'\n      },\n      to_anchor: 957.506\n    },\n    'ft3/min': {\n      name: {\n        singular: 'Cubic foot per minute',\n        plural: 'Cubic feet per minute'\n      },\n      to_anchor: 957.506 / 60\n    },\n    'ft3/h': {\n      name: {\n        singular: 'Cubic foot per hour',\n        plural: 'Cubic feet per hour'\n      },\n      to_anchor: 957.506 / 3600\n    },\n    'yd3/s': {\n      name: {\n        singular: 'Cubic yard per second',\n        plural: 'Cubic yards per second'\n      },\n      to_anchor: 25852.7\n    },\n    'yd3/min': {\n      name: {\n        singular: 'Cubic yard per minute',\n        plural: 'Cubic yards per minute'\n      },\n      to_anchor: 25852.7 / 60\n    },\n    'yd3/h': {\n      name: {\n        singular: 'Cubic yard per hour',\n        plural: 'Cubic yards per hour'\n      },\n      to_anchor: 25852.7 / 3600\n    }\n  }\n};\n\nvar volumeFlowRate$1 = utils(volumeFlowRate);\n\nexport default volumeFlowRate$1;\n","import { area, length, mass, speed, temperature } from 'units-converter';\n\nimport { TemperatureUnit, UnitSystem } from '@aurorasolar/graphql-client-schema';\n\nimport type { INumericInputProps } from '@blueprintjs/core';\n\nimport type { UnitSystemsFragment } from './get-unit.generated';\n\nconst MAX_DECIMAL_PLACES = 16;\nexport type NumericConversion = (number: number) => number;\n// (32°F − 32) × 5/9 = 0°C\nexport const getDecimalPlaces = (n: number): number => {\n  const decimal = String(n).split('.')[1];\n  return typeof decimal === 'string' ? decimal.length : 0;\n};\n\nconst roundTo =\n  (decimalPlaces = MAX_DECIMAL_PLACES): NumericConversion =>\n  (n: number) => {\n    return Number(n.toFixed(Math.min(MAX_DECIMAL_PLACES, decimalPlaces)));\n  };\nconst pipe = (...fns: NumericConversion[]): NumericConversion =>\n  fns.reduce(\n    (prev, next) =>\n      (...args) =>\n        next(prev(...args)),\n    <T>(arg: T): T => arg,\n  );\n\nexport const celsiusToFahrenheit: NumericConversion = (celsius) =>\n  temperature(celsius).from('C').to('F').value;\n\nexport const fahrenheitToCelsius: NumericConversion = (fahrenheit) =>\n  temperature(fahrenheit).from('F').to('C').value;\n\nexport const decimalToPercentage: NumericConversion = (decimal) => decimal * 100;\n\nexport const percentageToDecimal: NumericConversion = (percentage) => percentage / 100;\n\nexport enum ConversionType {\n  None,\n  Area, // Square Feet or Square Meters\n  Distance, // Meters or Feet\n  DistanceSmall, // Centimeters or Inches\n  Load,\n  Mass,\n  Percentage, // Decimal to 0-100%\n  PricePerArea, // Price Per Square Foot or Price Per Square Meter\n  Speed,\n  Temperature,\n}\n\nexport enum UnitType {\n  Foot = 'ft',\n  Inch = 'in',\n  Fahrenheit = '°F',\n  Meter = 'm',\n  Centimeter = 'cm',\n  Celsius = '°C',\n  Pound = 'lb',\n  Kilogram = 'kg',\n  SquareFoot = 'ft2',\n  SquareMeter = 'm2',\n  MilesPerHour = 'm/h',\n  KilometersPerHour = 'km/h',\n  PricePerSquareFoot = '$/ft2',\n  PricePerSquareMeter = '$/m2',\n  PoundsPerSquareFoot = 'lb/ft2',\n  KilogramsPerSquareMeter = 'kg/m2',\n  Percent = '%',\n}\n\nconst unitsNeedingSuffixFormat = [\n  UnitType.SquareFoot,\n  UnitType.SquareMeter,\n  UnitType.PricePerSquareFoot,\n  UnitType.PricePerSquareMeter,\n  UnitType.PoundsPerSquareFoot,\n  UnitType.KilogramsPerSquareMeter,\n  UnitType.MilesPerHour,\n];\nexport const getUnitSuffix = (unitType: UnitType) =>\n  unitsNeedingSuffixFormat.includes(unitType)\n    ? unitType.replace('$', '').replace('2', '²').replace('m/h', 'mph')\n    : unitType;\n\nexport const areaConversion =\n  (from: UnitType, to: UnitType): NumericConversion =>\n  (n) =>\n    area(n).from(from).to(to).value;\n\nexport const squareFeetToSquareMeters = areaConversion(UnitType.SquareFoot, UnitType.SquareMeter);\nexport const squareMetersToSquareFeet = areaConversion(UnitType.SquareMeter, UnitType.SquareFoot);\nexport const pricePerSquareFootToPricePerSquareMeter = areaConversion(\n  UnitType.SquareMeter,\n  UnitType.SquareFoot,\n);\nexport const pricePerSquareMeterToPricePerSquareFoot = areaConversion(\n  UnitType.SquareFoot,\n  UnitType.SquareMeter,\n);\n\nexport const massConversion =\n  (from: UnitType, to: UnitType): NumericConversion =>\n  (n) =>\n    mass(n).from(from).to(to).value;\n\nexport const poundToKilogram = massConversion(UnitType.Pound, UnitType.Kilogram);\nexport const kilogramToPound = massConversion(UnitType.Kilogram, UnitType.Pound);\n\nexport const poundPerSquareFootToKilogramPerSquareMeter = pipe(\n  poundToKilogram,\n  squareMetersToSquareFeet,\n);\nexport const kilogramPerSquareMeterToPoundPerSquareFoot = pipe(\n  kilogramToPound,\n  squareFeetToSquareMeters,\n);\n\nexport const speedConversion =\n  (from: UnitType, to: UnitType): NumericConversion =>\n  (n) =>\n    speed(n).from(from).to(to).value;\n\nexport const milesPerHourToKilometersPerHour = speedConversion(\n  UnitType.MilesPerHour,\n  UnitType.KilometersPerHour,\n);\nexport const kilometersPerHourToMilesPerHour = speedConversion(\n  UnitType.KilometersPerHour,\n  UnitType.MilesPerHour,\n);\n\n// precise conversions for ensuring units converted back and forth between sq-ft and sq-m match up as much as possible\n// 1m = 3.280839895 ft\nconst multiplierForPreciseAreaConversion = 10.7639104166236;\n\nexport const preciseSquareFeetToSquareMeters = (squareMeters: number): number => {\n  return squareMeters / multiplierForPreciseAreaConversion;\n};\n\nexport const preciseSquareMetersToSquareFeet = (squareFeet: number): number => {\n  return squareFeet * multiplierForPreciseAreaConversion;\n};\n\nexport const precisePricePerSquareFootToPricePerSquareMeter = (\n  pricePerSquareFoot: number,\n): number => {\n  return pricePerSquareFoot * multiplierForPreciseAreaConversion;\n};\n\nexport const precisePricePerSquareMeterToPricePerSquareFoot = (\n  pricePerSquareMeter: number,\n): number => {\n  return pricePerSquareMeter / multiplierForPreciseAreaConversion;\n};\n\nconst multiplierForBuildingHeightConversion = 3;\n\nexport const metersToBuildingStories = (meters: number): number => {\n  return meters / multiplierForBuildingHeightConversion;\n};\n\nexport const buildingStoriesToMeters = (stories: number): number => {\n  return stories * multiplierForBuildingHeightConversion;\n};\n\nexport const lengthConversion =\n  (from: UnitType, to: UnitType): NumericConversion =>\n  (n) =>\n    length(n).from(from).to(to).value;\n\nexport const metersToInches = lengthConversion(UnitType.Meter, UnitType.Inch);\nexport const inchesToMeters = lengthConversion(UnitType.Inch, UnitType.Meter);\nexport const metersToCm = lengthConversion(UnitType.Meter, UnitType.Centimeter);\nexport const cmToMeters = lengthConversion(UnitType.Centimeter, UnitType.Meter);\nexport const metersToFeet = lengthConversion(UnitType.Meter, UnitType.Foot);\nexport const feetToMeters = lengthConversion(UnitType.Foot, UnitType.Meter);\n\nexport const noChange: NumericConversion = (n) => n;\n\nconst defaultUnitSystems: Omit<UnitSystemsFragment, '__typename'> & Partial<UnitSystemsFragment> = {\n  __typename: 'Tenant',\n  distanceUnit: UnitSystem.Metric,\n  temperatureUnit: TemperatureUnit.C,\n};\n\nexport const getUnitType = (\n  conversionType: ConversionType,\n  { distanceUnit, temperatureUnit } = defaultUnitSystems,\n) => {\n  const isMetric = distanceUnit === UnitSystem.Metric;\n  const isCelsius = temperatureUnit === TemperatureUnit.C;\n  switch (conversionType) {\n    case ConversionType.Percentage:\n      return UnitType.Percent;\n    case ConversionType.Temperature:\n      return isCelsius ? UnitType.Celsius : UnitType.Fahrenheit;\n    case ConversionType.Distance:\n      return isMetric ? UnitType.Meter : UnitType.Foot;\n    case ConversionType.DistanceSmall:\n      return isMetric ? UnitType.Centimeter : UnitType.Inch;\n    case ConversionType.PricePerArea:\n      return isMetric ? UnitType.PricePerSquareMeter : UnitType.PricePerSquareFoot;\n    case ConversionType.Mass:\n      return isMetric ? UnitType.Kilogram : UnitType.Pound;\n    case ConversionType.Load:\n      return isMetric ? UnitType.KilogramsPerSquareMeter : UnitType.PoundsPerSquareFoot;\n    case ConversionType.Speed:\n      return isMetric ? UnitType.KilometersPerHour : UnitType.MilesPerHour;\n    default:\n      return UnitType.Meter;\n  }\n};\nexport type ConversionTuple = [toInput: NumericConversion, fromInput: NumericConversion];\n\nexport const getConversionTuple = (unitType: UnitType, decimalPlaces?: number) => {\n  const round = (fn: NumericConversion) => pipe(fn, roundTo(decimalPlaces));\n  const map = new Map<UnitType, ConversionTuple>([\n    [UnitType.Inch, [round(metersToInches), inchesToMeters]],\n    [UnitType.Centimeter, [round(metersToCm), cmToMeters]],\n    [UnitType.Foot, [round(metersToFeet), feetToMeters]],\n    [UnitType.Fahrenheit, [round(celsiusToFahrenheit), round(fahrenheitToCelsius)]],\n    [UnitType.Kilogram, [round(kilogramToPound), round(poundToKilogram)]],\n    [\n      UnitType.KilogramsPerSquareMeter,\n      [\n        round(kilogramPerSquareMeterToPoundPerSquareFoot),\n        round(poundPerSquareFootToKilogramPerSquareMeter),\n      ],\n    ],\n    [\n      UnitType.KilometersPerHour,\n      [round(kilometersPerHourToMilesPerHour), round(milesPerHourToKilometersPerHour)],\n    ],\n    [\n      UnitType.PricePerSquareMeter,\n      [round(pricePerSquareFootToPricePerSquareMeter), pricePerSquareMeterToPricePerSquareFoot],\n    ],\n    [UnitType.Percent, [round(decimalToPercentage), percentageToDecimal]],\n  ]);\n  return map.get(unitType) ?? [round(noChange), noChange];\n};\n\nexport interface ConvertibleInputProps {\n  value?: number | string;\n  onValueChange: INumericInputProps['onValueChange'];\n  min?: number;\n  max?: number;\n  stepSize?: number;\n  sliderMin?: number;\n  sliderMax?: number;\n}\n\nexport const convertProps = <Props extends ConvertibleInputProps>(\n  originalProps: Props,\n  [inConversion, outConversion]: ConversionTuple,\n): Props => {\n  const inPropKeys = ['value', 'min', 'max', 'sliderMin', 'sliderMax'];\n  const inProps = Object.keys(originalProps)\n    .filter((key) => inPropKeys.includes(key))\n    // If the value is undefined, skip conversion\n    .filter((key) => originalProps[key] !== undefined)\n    .reduce((all, key) => ({ ...all, [key]: inConversion(originalProps[key]) }), {});\n\n  const onValueChange: ConvertibleInputProps['onValueChange'] = (numericValue) => {\n    const converted = outConversion(numericValue);\n    const noop = () => {};\n    return originalProps.onValueChange?.(converted, String(converted)) ?? noop;\n  };\n  return {\n    ...originalProps,\n    ...inProps,\n    onValueChange,\n  };\n};\n","import {\n  ConversionType,\n  UnitType,\n  getConversionTuple,\n  getUnitType,\n} from '@aurorasolar/common-numeric-conversion';\nimport { TemperatureUnit, UnitSystem } from '@aurorasolar/graphql-client-schema';\nimport { IIntlContext } from '@aurorasolar/intl';\n\nexport const buildUnitsAdapter = (\n  distanceUnit: UnitSystem,\n  temperatureUnit: TemperatureUnit,\n  intl: IIntlContext,\n) => {\n  const unitType = getUnitType(ConversionType.Distance, {\n    distanceUnit,\n    temperatureUnit,\n  });\n  const [convertIn, convertOut] = getConversionTuple(unitType);\n  return {\n    convert: convertIn,\n    distanceUnit: () => (distanceUnit === UnitSystem.Imperial ? 'ft' : 'm'),\n    // CAD calls format with a third parameter which is unused here.\n    format: (value: number, numFixed: number, _measurementType: string, footInchFormat = false) => {\n      const convertedValue = convertIn(value);\n      const formattedValue = intl.formatNumber(convertedValue, {\n        maximumFractionDigits: numFixed,\n        minimumFractionDigits: numFixed,\n      });\n      if (footInchFormat && unitType === UnitType.Foot) {\n        const feet = Math.floor(convertedValue);\n        const decimal = convertedValue % 1;\n        const inches = Math.floor(12 * decimal);\n        return `${feet}'-${inches}\"`;\n      }\n      return `${formattedValue} ${unitType}`;\n    },\n    smallDistanceUnit: () => (distanceUnit === UnitSystem.Imperial ? 'in' : 'cm'),\n    system: {\n      distance: distanceUnit,\n    },\n    unconvert: convertOut,\n  };\n};\n","import { ApolloClient, NormalizedCacheObject } from '@apollo/client';\n\nimport { SUPPORTED_LOCALES } from '@aurorasolar/intl';\nimport { AuroraApiEnvironment } from '../../api-environment';\nimport { CadBridge } from './CAD-geodata-service';\n\nexport interface CadEngine {\n  state: unknown;\n  bridge: {\n    designId?: string;\n    save: (options?: { saveScreenshot?: boolean }) => Promise<void>;\n    triggerAction: (\n      action: string,\n      payload: unknown,\n      _?: unknown,\n      debounce?: boolean,\n      defer?: number,\n    ) => void;\n  } & CadBridge;\n}\n\nexport interface CadSaveData {\n  designId: string;\n  jsonToSave: {\n    site: JSON;\n    system: JSON;\n    designJsonSchemaVersion: number;\n  };\n  saveVersion: string;\n  saveScreenshot: boolean;\n}\n\ninterface CadAutoRoofDataProviderFactory {\n  new (\n    graphqlClient: ApolloClient<NormalizedCacheObject>,\n    designId: string | null,\n    userId: string | null,\n    distanceUnits: 'metric' | 'imperial',\n    temperatureUnits: 'C' | 'F',\n    autoRoofData: unknown,\n  ): unknown;\n}\n\nexport enum CompassPosition {\n  LowerRight = 'LowerRight',\n  LowerRightCorner = 'LowerRightCorner',\n  UpperLeft = 'UpperLeft',\n  Invisible = 'Invisible',\n}\n\nexport interface CadEngineOptions {\n  dataProvider: unknown;\n  designJsonSchemaVersion: number;\n  designJson: { system: JSON; site: AutoRoofCadSite | JSON | {} };\n  dynamicMultiView?: boolean;\n  environment: AuroraApiEnvironment | undefined;\n  eventEmitter: unknown;\n  saveFormat: '1.0';\n  stateFramework: {\n    makeReactive<T extends object>(a: T): T;\n    effect<ReactiveValue>(\n      getReactive: () => ReactiveValue,\n      runEffect: (reactiveValue: ReactiveValue) => void,\n    ): () => void;\n    cloneInert<T extends object>(object: T): T;\n  };\n  lat: number;\n  lng: number;\n  renderMode: string;\n  stateMode: string;\n  useCompassPosition?: CompassPosition;\n  useMapView: boolean;\n  useStreetView: boolean;\n  useToastMessage: boolean;\n  useSimplePointerControls?: boolean;\n  useSimpleTouchControls?: boolean;\n  viewData: Array<{\n    camera?: {\n      verticalAngle?: number;\n      horizontalAngle?: number;\n      radius?: number;\n      lookatX?: number;\n      lookatY?: number;\n      lookatZ?: number;\n    };\n    domElement: HTMLElement;\n    name: string;\n    theme?: string;\n  }>;\n  viewSettings: {\n    'design-3d': ViewPortViewSettings;\n  };\n}\n\ninterface CadFactory {\n  getEngineInstance: (\n    designId: string,\n    options: CadEngineOptions,\n    forceRefresh: boolean,\n  ) => CadEngine;\n  initEngineInstance: (\n    engine: CadEngine,\n    dependencies: {\n      dataProvider: unknown;\n      eventEmitter: unknown;\n      geodataService?: unknown;\n      store: unknown;\n      saveHandler?: {\n        save: (saveData: CadSaveData) => Promise<void>;\n      };\n      irradianceMapService?: IrradianceMapService;\n      locale: SUPPORTED_LOCALES;\n    },\n  ) => Promise<unknown>;\n  getActiveEngineInstance(deisgnId: string): CadEngine | null;\n  cleanupEngineInstance(): void;\n}\n\ninterface AssetLoader {\n  instance: AssetLoader;\n  initialize(): AssetLoader;\n  startLoad(): Promise<PLEASE_DO_NOT_USE_THIS_ANY_FOR_MIGRATION_ONLY>;\n}\n\ninterface IrradianceMapService {\n  // eslint-disable-next-line\n  new (): IrradianceMapService;\n}\n\nexport interface ICADJSModule {\n  Factory: CadFactory;\n  AssetLoader: AssetLoader;\n  Services: {\n    IrradianceMapService: IrradianceMapService;\n    DataProviderAutoRoof: CadAutoRoofDataProviderFactory;\n  };\n}\n\nexport interface ICADProvider {\n  engineSaveFn: () => Promise<void>;\n  engine: CadEngine;\n}\n\nexport interface ICadFeatureGate {\n  aiSmartRoof?: boolean;\n  ambientOcclusion: boolean;\n  autoDesigner: boolean;\n  autoRoof: boolean;\n  balanceOfSystem: boolean;\n  /**\n   * @deprecated: we should use `compassPosition` in bridge,\n   * but keeping it for now, otherwise there's currently bugs\n   */\n  compassToLowerRight: boolean;\n  csvMonthly: boolean;\n  datamodelLibrary: boolean;\n  editSiteModel: boolean;\n  fillZone: boolean;\n  fitTreesToLidar: boolean;\n  lidar: boolean;\n  multiObjectSelectionTabs?: boolean;\n  panelPlaceMode?: boolean;\n  salesModeAutoString?: boolean;\n  saveDesignJsonSchemaVersion2: boolean;\n  walkway: boolean;\n  focusOnSelection: boolean;\n  useSimpleShaders?: boolean;\n}\n\n/*\n * TODO - These duplicate definitions in generated schema files but since we can't pull them in we'll\n * replace them later\n * */\n\ninterface AutoRoofCadObstruction {\n  shape: string;\n  center: number[];\n  azimuthVector: number[];\n  radius: number;\n  width: number;\n  length: number;\n  flush: boolean;\n  heightAbove: number;\n  confidence: number;\n}\n\ninterface AutoRoofCadRoofPlane {\n  shell: AutoRoofCadRoofPlaneNode[];\n  holes: AutoRoofCadRoofPlaneNode[][];\n  height: number;\n  pitch: number;\n  azimuthEdgeIndex: number;\n}\n\ninterface AutoRoofCadRoofPlaneNode {\n  x: number;\n  y: number;\n  edgeType: string;\n}\n\ninterface AutoRoofCadSite {\n  roofPlanes: AutoRoofCadRoofPlane[];\n  obstructions: AutoRoofCadObstruction[];\n  baseElevation: number;\n  centerLat: number;\n  centerLng: number;\n}\n\nexport type ViewPortViewSettings = {\n  azimuthArrows?: boolean;\n  buildings?: boolean;\n  connections?: boolean;\n  designComponents?: boolean;\n  disabledPanels?: boolean;\n  edges?: boolean;\n  electricalComponents?: boolean;\n  fillZones?: boolean;\n  ground?: boolean;\n  irradianceMap?: boolean;\n  irradianceMapPanels?: boolean;\n  lidar?: boolean;\n  map?: boolean;\n  mapImagery?: boolean;\n  mapView?: boolean;\n  measurements?: boolean;\n  projectCenter?: boolean;\n  rulers?: boolean;\n  setbacks?: boolean;\n  shadeReportLabels?: boolean;\n  shadows?: boolean;\n  sky?: boolean;\n  solarPanels?: boolean;\n  streetView?: boolean;\n  strings?: boolean;\n  sunpath?: boolean;\n  templates?: boolean;\n  toolbarExpanded?: boolean;\n  trees?: boolean;\n  visualModuleValidation?: boolean;\n  walkways?: boolean;\n};\n","export enum CadMode {\n  Site = 'default-site',\n  System = 'default-design',\n  Basic = 'default-basic',\n  /**\n   * A simplified CAD mode that allows panel toggling.  Used by Sales Mode and the Client SDK.\n   */\n  Limited = 'default-limited',\n  ReadOnly = 'read-only',\n  Advanced = 'advanced',\n  MoveRoof = 'move.roof',\n  Paste = 'place.paste',\n  DrawObstructionPolygon = 'draw.obstruction-polygon',\n  DrawObstructionCircle = 'draw.obstruction-circle',\n  DrawObstructionRectangle = 'draw.obstruction-rectangle',\n  PasteObstructionPolygon = 'place.paste.obstruction-polygon',\n  PasteObstructionCircle = 'place.paste.obstruction-circle',\n  PasteObstructionRectangle = 'place.paste.obstruction-rectangle',\n  DrawTree = 'draw.tree',\n  PasteTree = 'place.paste.tree',\n  EditOrthoImage = 'ortho-image-editing',\n  PlaceOrthoImage = 'place.ortho-image-editor',\n  DrawRuler = 'draw.ruler',\n  Roof = 'roof',\n  DrawRoof = 'draw.roof',\n  DrawRoofPlane = 'draw.roof-plane',\n  PasteRoof = 'place.paste.roof',\n  PlaceDormer = 'place.dormer',\n  PlaceKink = 'place.kink',\n  DragInternalEdge = 'internal-edge-drag',\n  DrawWalkway = 'draw.walkway',\n  PasteWalkway = 'place.paste.draw.walkway',\n  Stringing = 'stringing',\n  DrawFillZone = 'draw.fill-zone',\n  DrawSolarPanel = 'draw-solar-panel',\n  PasteDrawSolarPanel = 'place.paste.draw-solar-panel',\n  PasteDrawSolarArray = 'place.paste.draw-solar-array',\n  PlaceSolarArray = 'place.solar-array',\n  PlaceSolarInverter = 'place.solar-inverter',\n  PlaceCombinerBox = 'place.combiner-box',\n  PlaceLoadCenter = 'place.load-center',\n  PlaceServicePanel = 'place.service-panel',\n  PlaceMeter = 'place.meter',\n  PlaceDisconnect = 'place.disconnect',\n  FillRoofFace = 'fill-roof-face',\n  TogglePanels = 'toggle-panels',\n  DrawSolarArray = 'draw-solar-array',\n  EditPanelPlane = 'edit.panel-plane',\n}\n","import { CADTriggerActionTypes } from '@aurorasolar/common-data-store';\nimport { CadBridge, ICADGeodataService } from '@aurorasolar/common-module-loader';\n\nimport { LeadCaptureCadQuery } from './use-lead-capture-cad.generated';\n\nexport const getLeadCaptureGeodataService = (data: LeadCaptureCadQuery): ICADGeodataService => {\n  const processGroundTextures = async (cadBridge: CadBridge) => {\n    cadBridge.triggerAction(CADTriggerActionTypes.ProcessGroundTextures, {\n      orthoImages: [data.leadCadData.image!.orthoImage],\n    });\n  };\n\n  return {\n    deleteOrthoImage: async () => {},\n    detectAllObstructions: async () => {},\n    detectObstructions: async () => {},\n    initialize: async (cadBridge) => processGroundTextures(cadBridge),\n    initialized: true,\n    onOrthoImageBoundsIncrease: async () => {},\n    onProjectLocationChange: async () => {},\n    onSiteBoundsChange: async () => {},\n    onSpecifiedBoundsChange: async () => {},\n    updateOrthoImage: async () => {},\n    willDestroy: async () => {},\n  };\n};\n","export enum PreferenceScope {\n  /**\n   * Preference saved per design\n   */\n  Design,\n\n  /**\n   * Preference saved per project\n   */\n  Project,\n\n  /**\n   * Preference saved for the entire app\n   */\n  App,\n}\n\nexport enum ExpirationType {\n  /**\n   * Never expires. Try to avoid using\n   */\n  Never,\n\n  /**\n   * Expires when exiting preference instance, e.g.\n   * a single CAD instance\n   */\n  Instance,\n\n  /**\n   * Allows certain max number of preferences of the same type.\n   * Once that number is reached, the oldest preferences of the same\n   * type are removed when new ones are added\n   */\n  MaxCount,\n\n  /**\n   * Expires after a certain time period\n   */\n  MaxDuration,\n}\n\nexport enum UserScope {\n  /**\n   * Shared preference between all users. Default\n   * option\n   */\n  Shared,\n\n  /**\n   * Separate preference for every user\n   */\n  PerUser,\n}\n\n/**\n * Type for preference descriptors\n */\nexport type PreferenceDescriptor<T> = {\n  preferenceScope: PreferenceScope;\n  /**\n   * If not provided, defaults to UserScope.Shared\n   */\n  userScope?: UserScope;\n  isValid: (value: unknown) => value is T;\n} & (\n  | {\n      expirationType: ExpirationType.Never | ExpirationType.Instance;\n    }\n  | {\n      expirationType: ExpirationType.MaxCount;\n      maxCount: number;\n    }\n  | {\n      expirationType: ExpirationType.MaxDuration;\n      maxDurationMs: number;\n    }\n);\n","/**\n * This shape will be stored per value and should not change in breaking ways.\n * We may only be able to add optional properties\n */\nexport type StoredValue<T> = {\n  value: T;\n  timestamp: number;\n};\n\nexport type PreferenceProvider = {\n  getKeys(): string[];\n  has(key: string): boolean;\n  get(key: string): undefined | StoredValue<unknown>;\n  set(key: string, value: StoredValue<unknown>): void;\n  remove(key: string): void;\n};\n\n/**\n * Since stored value may be manually changed or become out of date with the latest code,\n * we're ensuring that the stored value corresponds to the correct JSON object\n */\nconst getLocalStorageStoredValue = (value: string): undefined | StoredValue<unknown> => {\n  try {\n    const json: number | string | Partial<{ [K in keyof StoredValue<unknown>]: unknown }> =\n      JSON.parse(value);\n    if (\n      json &&\n      typeof json === 'object' &&\n      'value' in json &&\n      'timestamp' in json &&\n      typeof json.timestamp === 'number'\n    ) {\n      return {\n        timestamp: json.timestamp,\n        value: json.value,\n      };\n    }\n    return undefined;\n  } catch (_) {\n    return undefined;\n  }\n};\n\n/**\n * Creates a local storage-based preference provider that keeps value in the browser\n * until it is cleaned up\n */\nexport const createLocalStoragePreferenceProvider = (storagePrefix: string) => {\n  const isCadKey = (key: string) => key.startsWith(storagePrefix);\n\n  const removeCadKeyPrefix = (key: string) => key.substring(storagePrefix.length);\n\n  const provider: PreferenceProvider = {\n    get(key) {\n      if (provider.has(key)) {\n        const item = localStorage.getItem(`${storagePrefix}${key}`);\n        if (typeof item === 'string') {\n          return getLocalStorageStoredValue(item);\n        }\n      }\n      return undefined;\n    },\n    getKeys() {\n      return Object.getOwnPropertyNames(localStorage).filter(isCadKey).map(removeCadKeyPrefix);\n    },\n    has(key) {\n      return localStorage.hasOwnProperty(`${storagePrefix}${key}`);\n    },\n    remove(key) {\n      localStorage.removeItem(`${storagePrefix}${key}`);\n    },\n    set(key, value) {\n      localStorage.setItem(`${storagePrefix}${key}`, JSON.stringify(value));\n    },\n  };\n\n  return provider;\n};\n\n/**\n * Creates a preference provider for a single instance of the preferences.\n * Since preferences are instantiated along with CAD, these preferences\n * are per CAD instance\n */\nexport const createInstancePreferenceProvider = () => {\n  const storage: { [k: string]: StoredValue<unknown> } = {};\n  const provider: PreferenceProvider = {\n    get(key) {\n      if (provider.has(key)) {\n        return storage[key];\n      }\n      return undefined;\n    },\n    getKeys() {\n      return Object.getOwnPropertyNames(storage);\n    },\n    has(key) {\n      return storage.hasOwnProperty(key);\n    },\n    remove(key) {\n      delete storage[key];\n    },\n    set(key, value) {\n      storage[key] = value;\n    },\n  };\n  return provider;\n};\n","import {\n  ExpirationType,\n  PreferenceDescriptor,\n  PreferenceScope,\n  UserScope,\n} from './preference-descriptor-types';\nimport {\n  createInstancePreferenceProvider,\n  createLocalStoragePreferenceProvider,\n  PreferenceProvider,\n} from './preference-providers';\nimport {\n  GeneralPreferenceDescriptors,\n  GetPreference,\n  getPreferenceIds,\n  KeysWithValuesOfType,\n  TypedPreferenceDescriptors,\n} from './preference-utils';\n\nexport type CurrentScope = {\n  getUserId: () => string | null;\n  getProjectId: () => string | null;\n  getDesignId: () => string | null;\n};\n\nexport const isDateMoreThanOneDayIntoTheFuture = (timestamp: number) =>\n  timestamp > Date.now() + 24 * 60 * 60 * 1000;\n\nexport const isPastExpiryDate = (timestamp: number, maxDurationMs: number) =>\n  Date.now() > timestamp + maxDurationMs;\n\n/**\n * Preferences are our way of storing user-, design-, project- and app-based user-entered\n * preferences. Preferences may be acquired and cleared via interactions with forms or, if\n * needed, via a dedicated page. Preferences are meant to be type-validated, type-safe and\n * geared towards long-term storage. Backwards compatibility and cleanup implications:\n * 1. Preferences must be backwards compatible. If we want to preserve the preference, then\n *    `storagePrefix` and preference IDs should not change, and `isValid` of the preference\n *    should remain `true` continuously (i.e. schema needs to be backwards compatible)\n * 2. The current maximum total storage should not exceed 5 megabytes, which should be\n *    sufficient for a lot of preferences. But, in order to keep that well below the limit,\n *    preferences should utilize `MaxCount` or `MaxDuration` expiry type as much as possible\n * 3. Cleanup (removal of stored preference) is performed when the number of preferences with\n *    the same ID exceeds max count or max duration (depending on its expiry type), when the\n *    setting's `isValid` returns false (e.g. when the schema changes in incompatible ways),\n *    or if the setting ID was removed\n * 4. We can evolve preference's expiry type over time and the preference should automatically\n *    be able to adapt to it. It is noteworthy that, as it stands, patching preference's scope\n *    and user scope will not make the preference automatically get inherited. For the preference\n *    to be retrieved correctly, it must have the exact same scope as at the time of storage.\n *    This behavior can be changed eventually, which is why there is no preference cleanup\n *    for preferences whose scope has changed since the preference introduction\n *\n * General note: preferences are designed to remove the need to write migrations, have a\n * clear cleanup strategy and provide type safety and type convenience throughout the\n * entirety of the codebase\n *\n * This function creates a preference manager for namespaced handling of preferences.\n * Provided `preferenceNames` and `preferenceDescriptors`\n * must satisfy the following constraints:\n * 1. `preferenceNames` is a map between meaningless preference IDs and\n *    meaningful preference names\n * 2. Every key of `preferenceDescriptors` should be a preference name\n *    defined in `preferenceNames` and vice versa\n * 3. `preferenceDescriptors` should be an object where every key matches\n *    `PreferenceDescriptor<T>` type\n */\nexport const createPreferencesManager = <\n  PreferenceNames extends object,\n  PreferenceDescriptors extends object,\n>(\n  preferenceNames: PreferenceNames,\n  preferenceDescriptors: PreferenceDescriptors,\n  storagePrefix: string,\n) => {\n  type Preference = GetPreference<PreferenceNames>;\n\n  /**\n   * Various type checks for PreferenceNames and PreferenceDescriptors. This error\n   * will be displayed as a result type if the type error occurs\n   */\n  type PreferenceTypeError = Preference['Name'] extends keyof PreferenceDescriptors\n    ? keyof PreferenceDescriptors extends Preference['Name']\n      ? PreferenceDescriptors extends GeneralPreferenceDescriptors<Preference['Names']>\n        ? PreferenceDescriptors extends TypedPreferenceDescriptors<\n            Preference['Names'],\n            PreferenceDescriptors\n          >\n          ? null\n          : 'Every descriptor should match PreferenceDescriptor<T>'\n        : 'Preference descriptors should be an object where values match PreferenceDescriptor<T>'\n      : 'Every key of preferenceDescriptors should appear in preferenceNames and vice versa'\n    : 'Every key of preferenceDescriptors should appear in preferenceNames and vice versa';\n\n  type PreferenceName = Preference['Name'] & keyof PreferenceDescriptors;\n\n  type GetPreferenceValue<Name extends keyof PreferenceDescriptors> =\n    PreferenceDescriptors[Name] extends { isValid: (value: unknown) => value is infer U }\n      ? U\n      : never;\n\n  type GetPreferenceDescriptor<Name extends keyof PreferenceDescriptors> = PreferenceDescriptor<\n    GetPreferenceValue<Name>\n  >;\n\n  /**\n   * This is a helper type that allows us to type-check and provide intellisense\n   * autocomplete for a map between an action and its corresponding preference\n   * property. The first argument the action is called with must be equal to the type\n   * of the preference property\n   */\n  type ActionPreferenceNames<Name extends PreferenceName, Actions> = {\n    [ActionName in keyof Actions]?: Actions[ActionName] extends (value: infer U) => void\n      ? KeysWithValuesOfType<Required<GetPreferenceValue<Name>>, Exclude<U, undefined>>\n      : never;\n  };\n\n  /**\n   * The map from preference name back to preference ID\n   */\n  const preferenceIds = getPreferenceIds(preferenceNames);\n\n  const createPreferences = (currentScope: CurrentScope) => {\n    const localStorageProvider = createLocalStoragePreferenceProvider(storagePrefix);\n    const instanceProvider = createInstancePreferenceProvider();\n    const providers = [localStorageProvider, instanceProvider];\n\n    const getProvider = <T>(descriptor: PreferenceDescriptor<T>): PreferenceProvider => {\n      if (descriptor.expirationType === ExpirationType.Instance) {\n        return instanceProvider;\n      }\n      return localStorageProvider;\n    };\n\n    const getDescriptor = <Name extends PreferenceName>(name: Name) => {\n      return preferenceDescriptors[name] as unknown as GetPreferenceDescriptor<Name>;\n    };\n\n    const getCurrentProviderKey = <Name extends PreferenceName>(name: Name): string => {\n      const preferenceId = String(preferenceIds[name]);\n      const descriptor = getDescriptor(name);\n      const userId = currentScope.getUserId();\n      const projectId = currentScope.getProjectId();\n      const designId = currentScope.getDesignId();\n      let prefix = `pref_id:${preferenceId}`;\n      if (userId && descriptor.userScope === UserScope.PerUser) {\n        prefix = `${prefix}/user_id:${userId}`;\n      }\n      if (\n        projectId &&\n        (descriptor.preferenceScope === PreferenceScope.Project ||\n          descriptor.preferenceScope === PreferenceScope.Design)\n      ) {\n        if (designId && descriptor.preferenceScope === PreferenceScope.Design) {\n          return `${prefix}/project_id:${projectId}/design_id:${designId}`;\n        }\n        return `${prefix}/project_id:${projectId}`;\n      }\n      return prefix;\n    };\n\n    const has = <Name extends PreferenceName>(name: Name): boolean => {\n      const providerKey = getCurrentProviderKey(name);\n      const descriptor = getDescriptor(name);\n      const provider = getProvider(descriptor);\n      return provider.has(providerKey);\n    };\n\n    const get = <Name extends PreferenceName>(name: Name): GetPreferenceValue<Name> | undefined => {\n      const providerKey = getCurrentProviderKey(name);\n      const descriptor = getDescriptor(name);\n      const provider = getProvider(descriptor);\n      const storedValue = provider.get(providerKey);\n\n      // In case \"get\" is performed before the cleanup is triggered,\n      // it is valuable to check for validity in case schema changed\n      // since last stored value\n      if (storedValue && descriptor.isValid(storedValue.value)) {\n        if (\n          descriptor.expirationType === ExpirationType.MaxDuration &&\n          (isDateMoreThanOneDayIntoTheFuture(storedValue.timestamp) ||\n            isPastExpiryDate(storedValue.timestamp, descriptor.maxDurationMs))\n        ) {\n          return undefined;\n        }\n        return storedValue.value;\n      }\n      return undefined;\n    };\n\n    const set = <Name extends PreferenceName>(\n      name: Name,\n      value: GetPreferenceValue<Name>,\n    ): void => {\n      const providerKey = getCurrentProviderKey(name);\n      const descriptor = getDescriptor(name);\n      const provider = getProvider(descriptor);\n      provider.set(providerKey, {\n        timestamp: Date.now(),\n        value,\n      });\n    };\n\n    const remove = <Name extends PreferenceName>(name: Name): void => {\n      const providerKey = getCurrentProviderKey(name);\n      const descriptor = getDescriptor(name);\n      const provider = getProvider(descriptor);\n      provider.remove(providerKey);\n    };\n\n    /**\n     * Wrapper function for automatically adjusting preferences whenever\n     * actions are called. This is geared towards preferences that are strictly\n     * typed objects. To wrap actions, provide an object that contains\n     * original actions and an object representing a map between an action\n     * and its corresponding preference property. Returns a new object\n     * with wrapped actions\n     */\n    const wrapActions = <Name extends PreferenceName, Actions>(\n      name: Name,\n      actions: Actions,\n      actionPreferenceNames: ActionPreferenceNames<Name, Actions>,\n    ): Actions => {\n      const newActions = { ...actions };\n      Object.keys(actionPreferenceNames).forEach((actionName: string) => {\n        const property = actionPreferenceNames[actionName];\n        newActions[actionName] = (newValue: unknown): unknown => {\n          const returnedValue = actions[actionName](newValue);\n          const preferences: unknown = get(name) ?? {};\n          if (preferences && typeof preferences === 'object') {\n            let result: object;\n            if (newValue === undefined) {\n              result = { ...preferences };\n              delete result[property];\n            } else {\n              result = {\n                ...preferences,\n                [property]: newValue,\n              };\n            }\n            set(name, result as GetPreferenceValue<Name>);\n          }\n          return returnedValue;\n        };\n      });\n      return newActions;\n    };\n\n    const getIdAndDescriptor = (providerKey: string) => {\n      const prefIdPrefix = 'pref_id:';\n      const preferenceId =\n        providerKey\n          .split('/')\n          .find((value) => value.startsWith(prefIdPrefix))\n          ?.substring(prefIdPrefix.length) ?? '';\n      const name: PreferenceName | undefined = preferenceNames[preferenceId];\n      const descriptor = name && getDescriptor(name);\n      return { descriptor, preferenceId };\n    };\n\n    /**\n     * A function for performing preference cleanup. The cleanup is for\n     * making sure preferences that were removed from codebase, got expired\n     * or exceed max count are cleaned up from the browser. It also ensures\n     * that the value is stored in the correct provider in case the property\n     * changes a provider\n     */\n    const cleanup = () => {\n      providers.forEach((provider) => {\n        const maxCountKeys: { [k: string]: Array<[timestamp: number, providerKey: string]> } = {};\n\n        /**\n         * If the preference changed providers, remove the value from\n         * the old provider and store it in the new one\n         */\n        provider.getKeys().forEach((providerKey) => {\n          const { descriptor } = getIdAndDescriptor(providerKey);\n          if (!descriptor) {\n            return;\n          }\n          const expectedProvider = getProvider(descriptor);\n          if (provider !== expectedProvider) {\n            const storedValue = provider.get(providerKey);\n            if (storedValue) {\n              provider.remove(providerKey);\n              expectedProvider.set(providerKey, storedValue);\n            }\n          }\n        });\n\n        provider.getKeys().forEach((providerKey) => {\n          const { preferenceId, descriptor } = getIdAndDescriptor(providerKey);\n          const storedValue = provider.get(providerKey);\n          if (\n            // If the stored value is invalid (e.g. user-modified):\n            !storedValue ||\n            // If preference ID was deleted from our codebase:\n            !(preferenceId in preferenceNames) ||\n            !descriptor ||\n            // If the value no longer matches schema:\n            !descriptor.isValid(storedValue.value) ||\n            // If the value expired:\n            (descriptor.expirationType === ExpirationType.MaxDuration &&\n              (isDateMoreThanOneDayIntoTheFuture(storedValue.timestamp) ||\n                isPastExpiryDate(storedValue.timestamp, descriptor.maxDurationMs)))\n          ) {\n            provider.remove(providerKey);\n          } else if (descriptor && descriptor.expirationType === ExpirationType.MaxCount) {\n            // Gathering information about values possibly exceeding max count\n            if (!maxCountKeys[preferenceId]) {\n              maxCountKeys[preferenceId] = [];\n            }\n            maxCountKeys[preferenceId].push([storedValue.timestamp, providerKey]);\n          }\n        });\n\n        // Clean up settings that exceeded max count\n        Object.keys(maxCountKeys).forEach((preferenceId) => {\n          const maxCountKey = maxCountKeys[preferenceId];\n          const name: PreferenceName = preferenceNames[preferenceId];\n          const descriptor = getDescriptor(name);\n          if (descriptor.expirationType === ExpirationType.MaxCount) {\n            const countDiff = maxCountKey.length - descriptor.maxCount;\n            if (countDiff > 0) {\n              maxCountKey\n                .sort(([t1], [t2]) => t1 - t2)\n                .forEach(([, providerKey], i) => {\n                  if (i < countDiff) {\n                    provider.remove(providerKey);\n                  }\n                });\n            }\n          }\n        });\n      });\n    };\n\n    return {\n      cleanup,\n      get,\n      has,\n      remove,\n      set,\n      wrapActions,\n    };\n  };\n\n  const manager = { createPreferences };\n  return manager as PreferenceTypeError extends null ? typeof manager : PreferenceTypeError;\n};\n","import { BaseSchema, InferType } from 'yup';\n\nimport { PreferenceDescriptor } from './preference-descriptor-types';\n\nexport type GetPreference<PreferenceNames> = {\n  Names: PreferenceNames;\n  Id: keyof PreferenceNames;\n  Name: PreferenceNames[keyof PreferenceNames] extends string | number | symbol\n    ? PreferenceNames[keyof PreferenceNames]\n    : never;\n};\n\nexport type GeneralPreferenceDescriptors<PreferenceNames> = {\n  [K in GetPreference<PreferenceNames>['Name']]: PreferenceDescriptor<unknown>;\n};\n\nexport type TypedPreferenceDescriptors<\n  PreferenceNames,\n  Descriptors extends GeneralPreferenceDescriptors<PreferenceNames>,\n> = {\n  [K in keyof Descriptors]: Descriptors[K] extends PreferenceDescriptor<infer U>\n    ? PreferenceDescriptor<U>\n    : never;\n};\n\n/**\n * Inverts a map from ID to name to be from name to ID\n */\nexport const getPreferenceIds = <PreferenceNames extends object>(\n  preferenceNames: PreferenceNames,\n) => {\n  type Preference = GetPreference<PreferenceNames>;\n\n  type GetPrefIdFromPrefName<PrefName> = {\n    [K in Preference['Id']]: PrefName extends Preference['Names'][K] ? K : never;\n  }[Preference['Id']];\n\n  type PreferenceIds = {\n    [K in Preference['Name']]: GetPrefIdFromPrefName<K>;\n  };\n\n  const result = {} as object;\n  Object.entries(preferenceNames).forEach(([key, value]) => {\n    result[value] = key as Preference['Id'];\n  });\n  return result as PreferenceIds;\n};\n\n/**\n * Returns an \"isValid\" check based on Yup schema. Additionally\n * fixes Yup's optional field behavior\n */\nexport const schemaCheck = <T>(schema: T) => {\n  type InferredType = T extends {\n    __inputType: unknown;\n    __outputType: unknown;\n  }\n    ? InferType<T>\n    : never;\n\n  type PickUndefined = {\n    [Key in keyof InferredType as undefined extends InferredType[Key]\n      ? Key\n      : never]: InferredType[Key];\n  };\n\n  type PickRequired = {\n    [Key in keyof InferredType as undefined extends InferredType[Key]\n      ? never\n      : Key]: InferredType[Key];\n  };\n\n  /**\n   * Note: this fixes an issue with Yup typescript where optional fields are\n   * still required in the schema. Here, if a field can be undefined, it is\n   * also considered optional\n   */\n  type SchemaType = {\n    [Key in keyof PickUndefined]?: InferredType[Key];\n  } & {\n    [Key in keyof PickRequired]: InferredType[Key];\n  };\n\n  return (value: unknown): value is SchemaType => {\n    return (schema as unknown as BaseSchema<unknown, unknown, T>).isValidSync(value);\n  };\n};\n\n/**\n * Gets keys of a type T where values are of type V\n */\nexport type KeysWithValuesOfType<T, V> = keyof {\n  /**\n   * Note: \"T[P] extends V && V extends T[P]\" is equivalent to saying that\n   * T[P] and V are completely equal types\n   */\n  [P in keyof T as T[P] extends V ? (V extends T[P] ? P : never) : never]: P;\n};\n","/* eslint-disable sort-keys */\nimport * as yup from 'yup';\nimport { ExpirationType, PreferenceScope } from './preference-descriptor-types';\nimport { createPreferencesManager, CurrentScope } from './preference-manager';\nimport { schemaCheck } from './preference-utils';\n\n/**\n * Prefix for local storage of CAD preferences. This should not change once\n * it goes in production, otherwise this would wipe out all preferences\n */\nconst CAD_PREFERENCE_STORAGE_PREFIX = 'CAD_PREF::';\n\n/**\n * An object that maps a preference ID to a meaningful name. The preference ID\n * should be meaningless so that it may be repurposed. We may add new IDs, remove\n * old IDs (in which case the preference will be cleaned up and removed from storage),\n * but we may never repeat previously used IDs. For that reason, we use an ID schema\n * \"p###\"\" where \"###\" are ever-increasing numbers. If we have to remove an ID with\n * the highest number, we should leave a comment here\n */\nconst preferenceNames = {\n  p000: 'panelPlaceMode',\n} as const;\n\n/**\n * Descriptors for every preference. Every preference in `preferenceNames` must be\n * defined and correspond to PreferenceDescriptor<T>. Schema should only change in\n * backwards compatible ways, otherwise the preference will be invalidated and cleaned\n * up. It is also important that these types are fully defined here rather than\n * being imported from other places to avoid accidental changes to the schema. When\n * adding or modifying preferences, it's vital to make sure that\n * `cad-preference-compatibility.test.ts` passes and that we add new test cases for\n * any new preferences / preference changes to keep them backwards compatible as the\n * schema evolves\n *\n * Reminder, preferences are our way of storing user-, design-, project- and app-based\n * user-entered preferences. Preferences may be acquired and cleared via interactions with\n * forms or, if needed, via a dedicated page. Preferences are meant to be type-validated,\n * type-safe and geared towards long-term storage with all the backwards compatibility\n * implications that are described in `createPreferencesManager`\n */\nconst preferenceDescriptors = {\n  panelPlaceMode: {\n    preferenceScope: PreferenceScope.Design,\n    expirationType: ExpirationType.MaxCount,\n    maxCount: 50,\n    isValid: schemaCheck(\n      yup\n        .object({\n          dcOptimizerId: yup.string().nullable(),\n          microinverterId: yup.string().nullable(),\n          solarPanelId: yup.string().nullable(),\n          minSap: yup.number(),\n\n          pitchedThreshold: yup.number(),\n\n          flatTilt: yup.number(),\n          flatRotation: yup.number(),\n          flatIntermoduleSpacingX: yup.number(),\n          flatRowSpacing: yup.number(),\n          flatOrientation: yup.mixed<'L' | 'P'>().oneOf(['L', 'P']),\n\n          pitchedTilt: yup.number(),\n          pitchedRotation: yup.number(),\n          pitchedIntermoduleSpacingX: yup.number(),\n          pitchedRowSpacing: yup.number(),\n          pitchedOrientation: yup.mixed<'L' | 'P'>().oneOf(['L', 'P']),\n        })\n        .required(),\n    ),\n  },\n} as const;\n\nconst cadPreferencesManager = createPreferencesManager(\n  preferenceNames,\n  preferenceDescriptors,\n  CAD_PREFERENCE_STORAGE_PREFIX,\n);\n\nexport type CadPreferences = ReturnType<typeof createCadPreferences>;\n\nexport const createCadPreferences = (currentScope: CurrentScope) => {\n  const preferences = cadPreferencesManager.createPreferences(currentScope);\n  /**\n   * Cleanup is performed right after preference initialization during\n   * browser's idle period in order to slightly speed up CAD initialization.\n   * Done immediately for browsers that don't support `requestIdleCallback`\n   * like Safari\n   */\n  if ('requestIdleCallback' in window) {\n    requestIdleCallback(preferences.cleanup);\n  } else {\n    preferences.cleanup();\n  }\n  return preferences;\n};\n","import {\n  CadSelectionMetadata,\n  CadSelectionMetadataActions,\n  CadSelectionType,\n  CadModeType,\n  PrimarySelectionKey,\n} from '../cad-engine-state';\n\nexport type ActiveInspectorTabType = null | 'sky' | 'lidar' | 'selectionList' | CadModeType;\nexport type ActiveTabType = CadSelectionType | ActiveInspectorTabType | null;\n\nexport const modeInspectorTabTypes: CadModeType[] = ['fill-roof-face', 'draw-solar-panel'];\n\ntype ActiveTabData = {\n  /**\n   * Inspector-specific tabs that don't have a corresponding CAD selection object\n   */\n  activeInspectorOnlyTab: ActiveInspectorTabType;\n\n  activeTab: ActiveTabType;\n};\n\nexport const createActiveTabData = (selectionMetadata: CadSelectionMetadata): ActiveTabData => {\n  return {\n    activeInspectorOnlyTab: null,\n\n    get activeTab() {\n      return selectionMetadata.primarySelectionKey ?? this.activeInspectorOnlyTab;\n    },\n  };\n};\n\nexport const createActiveTabActions = (\n  activeTabData: ActiveTabData,\n  selectionMetadataActions: CadSelectionMetadataActions,\n) => {\n  return {\n    setActiveTab: (newActiveTab: ActiveTabType) => {\n      if (\n        newActiveTab === 'sky' ||\n        newActiveTab === 'lidar' ||\n        newActiveTab === 'selectionList' ||\n        modeInspectorTabTypes.includes(newActiveTab as CadModeType)\n      ) {\n        selectionMetadataActions.setPrimarySelectionKey(null);\n        activeTabData.activeInspectorOnlyTab = newActiveTab as CadModeType;\n      } else {\n        selectionMetadataActions.setPrimarySelectionKey(newActiveTab as PrimarySelectionKey);\n        activeTabData.activeInspectorOnlyTab = null;\n      }\n    },\n  };\n};\n","import { performance } from '@aurorasolar/common-performance';\n\nconst { AutoDesignerStart, AutoDesignerFinished } = performance.MarkName;\nconst { AutoDesignerDuration } = performance.MeasureName;\n\nexport type AutoDesignerData = {\n  isAutoDesignerRunning: boolean;\n};\n\nexport const createAutoDesignerData = (): AutoDesignerData => {\n  return {\n    isAutoDesignerRunning: false,\n  };\n};\n\nexport const createAutoDesignerActions = (autoDesignerData: AutoDesignerData) => {\n  return {\n    autoDesignerFinish: () => {\n      autoDesignerData.isAutoDesignerRunning = false;\n      performance.mark(AutoDesignerFinished);\n      performance.measure(AutoDesignerDuration, AutoDesignerStart, AutoDesignerFinished);\n    },\n    autoDesignerStart: () => {\n      autoDesignerData.isAutoDesignerRunning = true;\n      performance.mark(AutoDesignerStart);\n    },\n  };\n};\n","export enum ModalType {\n  None,\n  Nearmap,\n  Vexcel,\n}\n\nexport enum OverlayType {\n  DesignSettings,\n}\n\nexport enum DesignSettingsTab {\n  System = 'design-settings-system-tab',\n  Simulation = 'design-settings-simulation-tab',\n}\n\nexport type OverlayData = {\n  type: OverlayType.DesignSettings;\n  data: {\n    tab: DesignSettingsTab;\n  };\n};\n\nexport type ModalData = {\n  activeModal: ModalType;\n  activeOverlays: OverlayData[];\n};\n\nexport const createModalData = (): ModalData => {\n  return {\n    activeModal: ModalType.None,\n    activeOverlays: [],\n  };\n};\n\nexport const createModalActions = (modalData: ModalData) => {\n  return {\n    closeModal: () => {\n      modalData.activeModal = ModalType.None;\n    },\n    closeOverlay: (overlayType: OverlayType) => {\n      const index = modalData.activeOverlays.findIndex((overlayDatum) => {\n        return overlayDatum.type === overlayType;\n      });\n      if (index !== -1) {\n        modalData.activeOverlays.splice(index, 1);\n      }\n    },\n    openModal: (modalType: ModalType) => {\n      modalData.activeModal = modalType;\n    },\n    openOverlay: (overlayData: OverlayData) => {\n      const index = modalData.activeOverlays.findIndex((overlayDatum) => {\n        return overlayDatum.type === overlayData.type;\n      });\n      if (index === -1) {\n        modalData.activeOverlays.push(overlayData);\n      }\n    },\n    setDesignSettingsTab: (designSettingsTab: DesignSettingsTab) => {\n      modalData.activeOverlays.forEach((overlayDatum) => {\n        if (overlayDatum.type === OverlayType.DesignSettings) {\n          overlayDatum.data.tab = designSettingsTab;\n        }\n      });\n    },\n  };\n};\n","import { HistoryData } from '../cad-engine-state';\n\nexport type SaveData = {\n  isSaving: boolean;\n  hasUnsavedChanges: boolean;\n  recentSavedVersion: string | null;\n};\n\nexport const createSaveData = (historyData: HistoryData): SaveData => {\n  return {\n    get hasUnsavedChanges() {\n      return this.recentSavedVersion !== historyData.recentVersion;\n    },\n    isSaving: false,\n    recentSavedVersion: historyData.recentVersion,\n  };\n};\n\nexport const createSaveActions = (saveData: SaveData) => {\n  return {\n    finishSaving: (saveVersion: string) => {\n      saveData.isSaving = false;\n      saveData.recentSavedVersion = saveVersion;\n    },\n    startSaving: () => {\n      saveData.isSaving = true;\n    },\n  };\n};\n","/* eslint-disable sort-keys */\nimport { createActiveTabActions, createActiveTabData } from './active-tab-data/active-tab-state';\nimport {\n  createAutoDesignerActions,\n  createAutoDesignerData,\n} from './auto-designer-state/auto-designer-state';\nimport { CadEngineState } from './cad-engine-state';\nimport { markDeepReadonly } from './deep-readonly-util';\nimport { makeReactive, provideCadStateTrace } from './framework';\nimport { createModalActions, createModalData } from './modal-state/modal-state';\nimport { createPrismActions, createPrismData } from './prism-state/prism-state';\nimport { createSaveActions, createSaveData } from './save-state/save-state';\nimport { createSelectedTypesData } from './selected-types/selected-types-state';\n\nexport type CadState = ReturnType<typeof createCadState>;\n\n/**\n * Creates CAD state that React components will be able to subscribe to\n *\n * CAD state is meant for combining and managing CAD-related V2 state tied to a single CAD instance. It\n * is meant for managing CAD-wide data related to forms, modals, interactions, operations in progress, etc.\n * The returned state combines V2-specific CAD state with CAD engine state (state maintained by CAD engine\n * itself). CAD state should not contain class instances or React nodes. The entirety of CAD state data should\n * be comprised of simple JS objects containing primitive values or other simple JS objects, and CAD state\n * actions should only contain functions that can take primitive values or simple JS objects\n */\nexport const createCadState = (cadEngineState: CadEngineState) => {\n  if (process.env.NODE_ENV === 'development') {\n    provideCadStateTrace();\n  }\n\n  const selectedTypeData = makeReactive(createSelectedTypesData(cadEngineState));\n  const modalData = makeReactive(createModalData());\n  const modalActions = makeReactive(createModalActions(modalData));\n  const autoDesignerData = makeReactive(createAutoDesignerData());\n  const autoDesignerActions = makeReactive(createAutoDesignerActions(autoDesignerData));\n  const saveData = makeReactive(createSaveData(cadEngineState.data.historyData));\n  const saveActions = makeReactive(createSaveActions(saveData));\n  const prismData = makeReactive(createPrismData());\n  const prismActions = makeReactive(createPrismActions(prismData));\n  const activeTabData = makeReactive(createActiveTabData(cadEngineState.data.selectionMetadata));\n  const activeTabActions = makeReactive(\n    createActiveTabActions(activeTabData, cadEngineState.actions.selectionMetadataActions),\n  );\n\n  return {\n    data: markDeepReadonly({\n      activeTabData,\n      autoDesignerData,\n      ...cadEngineState.data,\n      modalData,\n      prismData,\n      saveData,\n      selectedTypeData,\n    }),\n    actions: {\n      activeTabActions,\n      autoDesignerActions,\n      ...cadEngineState.actions,\n      modalActions,\n      prismActions,\n      saveActions,\n    },\n    stopEffects: {\n      ...cadEngineState.stopEffects,\n    },\n  };\n};\n\n/**\n * Cleans up CAD state by stopping all of its effects\n */\nexport const stopCadStateEffects = (cadState: CadState) => {\n  const items: Record<string, Record<string, () => void>> = cadState.stopEffects;\n  Object.keys(items).forEach((stopEffectMapKey) => {\n    const stopEffectMap = items[stopEffectMapKey];\n    Object.keys(stopEffectMap).forEach((stopEffectKey) => {\n      const stopEffect = stopEffectMap[stopEffectKey];\n      stopEffect();\n    });\n  });\n};\n","import { CadEngineState, CadSelectionType } from '../cad-engine-state';\n\nexport const createSelectedTypesData = (cadEngineState: CadEngineState) => {\n  return {\n    get selectedTypes() {\n      return Object.entries(cadEngineState.data.selectionData).reduce(\n        (types, [type, { count }]) => (count > 0 ? [...types, type] : types) as CadSelectionType[],\n        [] as CadSelectionType[],\n      );\n    },\n  };\n};\n","export type PrismData = {\n  isPrismCadOpen: boolean;\n};\n\nexport const createPrismData = (): PrismData => {\n  return {\n    isPrismCadOpen: false,\n  };\n};\n\nexport const createPrismActions = (prismData: PrismData) => {\n  return {\n    toggleIsPrismCadOpen: (newState: boolean) => {\n      prismData.isPrismCadOpen = newState;\n    },\n  };\n};\n","import { CadSelectionType } from '@aurorasolar/cad-state';\nimport { Notification } from '@aurorasolar/common-module-loader';\n\nimport { AiRoofType, ModalTrigger, ModalTriggerData } from './actions';\n\nexport enum CadEventTypes {\n  AutoRoofCancelled = 'autoRoofCancelled',\n  AutoRoofErrored = 'autoRoofErrored',\n  AutoRoofFinished = 'autoRoofFinished',\n  AutoRoofStarted = 'autoRoofStarted',\n  AutoStringCancelled = 'autoStringCancelled',\n  AutoStringErrored = 'autoStringErrored',\n  AutoStringFinished = 'autoStringFinished',\n  AutoStringStarted = 'autoStringStarted',\n  BeforeDrawWalkway = 'beforeDrawWalkway',\n  BeforeRunAutoRoof = 'beforeRunAutoRoof',\n  CadErrorOccurred = 'cadErrorOccurred',\n  CadGeometryErrorOccurred = 'cadGeometryErrorOccurred',\n  CadLoggedMessage = 'cadLoggedMessage',\n  DownloadDxf = 'downloadDxf',\n  DxfParams = 'generateDxfParams',\n  LoadSystemDesignFinished = 'loadSystemDesignFinished',\n  Notify = 'notify',\n  PlacePathwaysFinished = 'placePathwaysFinished',\n  RelayInternalCadState = 'relayInternalCadState',\n  SaveScreenshotAsset = 'saveScreenshotAsset',\n  CadScreenshot = 'cadScreenshot',\n  SetExternalStateData = 'setExternalStateData',\n  TrackAnalyticsAction = 'trackAnalyticsAction',\n  UndoFinished = 'undoFinished',\n  BoxSelectionChanged = 'boxSelectionChanged',\n  ClickSelected = 'clickSelected',\n  ClickDeselected = 'clickDeselected',\n}\n\nexport interface AutoRoofCompletion {\n  autoroofRequestId: string;\n  state?: string;\n  roofIds: string[];\n  obstructionIds: string[];\n  roofType: AiRoofType;\n  autoAccept: boolean;\n}\n\nexport interface AutoRoofError {\n  autoroofRequestId: string;\n  error?: Error;\n  roofIds?: string[];\n  obstructionIds?: string[];\n  roofType: AiRoofType;\n}\ninterface CadScreenshot {\n  id?: string | symbol;\n  imageType: 'png' | 'jpeg' | 'webp';\n  data: Blob;\n}\n\ntype AutoStringEventData = {\n  allPanelsStrung: boolean;\n  errorType: AutoStringErrorType;\n  error: Error;\n  inverterCount: number;\n};\n\nenum AutoStringErrorType {\n  RemoteError = 'remote-error',\n  PartialStringing = 'partial-stringing',\n}\n\nexport type CadEventProps = {\n  [CadEventTypes.Notify]: CadNotification;\n  [CadEventTypes.AutoRoofFinished]: AutoRoofCompletion;\n  [CadEventTypes.AutoRoofErrored]: AutoRoofError;\n  [CadEventTypes.CadScreenshot]: CadScreenshot;\n  [CadEventTypes.AutoRoofStarted]: { roofType: AiRoofType };\n  [CadEventTypes.AutoRoofCancelled]: { roofType: AiRoofType };\n  [CadEventTypes.CadErrorOccurred]: CadError;\n  [CadEventTypes.CadGeometryErrorOccurred]: CadError;\n  [CadEventTypes.CadLoggedMessage]: CadLogMessage;\n  [CadEventTypes.AutoStringErrored]: AutoStringEventData;\n  [CadEventTypes.AutoStringFinished]: AutoStringEventData;\n  [CadEventTypes.AutoStringCancelled]: AutoStringEventData;\n  [CadEventTypes.PlacePathwaysFinished]: { isChanged: boolean };\n  [CadEventTypes.ClickSelected]: {\n    selectionKey: CadSelectionType;\n  };\n  [CadEventTypes.ClickDeselected]: {\n    selectionKey: CadSelectionType;\n  };\n} & {\n  [K in ModalTrigger]: ModalTriggerData<K>;\n};\n\ntype CadNotification = {\n  message: string;\n  messageType: Notification.MessageType;\n  dismissType: Notification.DismissType;\n  title?: string;\n  variables: string[];\n};\n\nexport type CadEventPropType<A extends CadEventTypes> = A extends keyof CadEventProps\n  ? CadEventProps[A]\n  : undefined;\n\nexport type CadEvent<A extends CadEventTypes> = A extends keyof CadEventProps\n  ? { eventType: A; payload: CadEventPropType<A> }\n  : { eventType: A; payload: {} };\n\nexport type CadEventPayload<A extends CadEventTypes> = CadEvent<A>['payload'];\n\nexport interface ErrorWData extends Error {\n  cause?: unknown;\n}\n\nexport interface CadError {\n  err: ErrorWData;\n  message: string;\n}\n\nexport interface CadLogMessage {\n  message: string;\n  extraData?: Record<string, unknown>;\n}\n","export const NOVO_TOAST_CHANNEL = Symbol('novo toast channel');\nexport const TOAST_CHANNEL = Symbol('toast channel');\nexport const E_PROPOSAL_VALIDATION_ERROR_CHANNEL = Symbol('E-proposal validation error channel');\n","// @ts-ignore: Ignore unused { * as Types } import\nimport * as Types from '@aurorasolar/graphql-client-schema';\n\nimport { gql } from '@apollo/client';\nimport * as Apollo from '@apollo/client';\nconst defaultOptions = {} as const;\nexport type GetUserInfoQueryVariables = Types.Exact<{ [key: string]: never; }>;\n\n\nexport type GetUserInfoQuery = { __typename: 'Query', currentUser?: { __typename: 'User', id: string } | null | undefined };\n\nexport type CreateBssUploadUrlsMutationVariables = Types.Exact<{\n  createBSSUploadUrlsInput: Types.CreateBssUploadUrlsInput;\n}>;\n\n\nexport type CreateBssUploadUrlsMutation = { __typename: 'Mutation', createBSSUploadUrls?: Array<{ __typename: 'CreateFileBSSUploadUrl', blobId?: string | null | undefined, contentSha256?: string | null | undefined, uploadNeeded?: boolean | null | undefined, uploadUrl?: string | null | undefined, mandatoryUploadHeaders?: Array<{ __typename: 'MandatoryHeader', name?: string | null | undefined, value?: string | null | undefined } | null | undefined> | null | undefined } | null | undefined> | null | undefined };\n\n\nexport const GetUserInfoDocument = gql`\n    query GetUserInfo @trace_info(traceInfo: {pod: proposals}) {\n  currentUser {\n    id\n  }\n}\n    `;\n\n/**\n * __useGetUserInfoQuery__\n *\n * To run a query within a React component, call `useGetUserInfoQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetUserInfoQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetUserInfoQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useGetUserInfoQuery(baseOptions?: Apollo.QueryHookOptions<GetUserInfoQuery, GetUserInfoQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<GetUserInfoQuery, GetUserInfoQueryVariables>(GetUserInfoDocument, options);\n      }\nexport function useGetUserInfoLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetUserInfoQuery, GetUserInfoQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<GetUserInfoQuery, GetUserInfoQueryVariables>(GetUserInfoDocument, options);\n        }\nexport type GetUserInfoQueryHookResult = ReturnType<typeof useGetUserInfoQuery>;\nexport type GetUserInfoLazyQueryHookResult = ReturnType<typeof useGetUserInfoLazyQuery>;\nexport type GetUserInfoQueryResult = Apollo.QueryResult<GetUserInfoQuery, GetUserInfoQueryVariables>;\nexport const CreateBssUploadUrlsDocument = gql`\n    mutation CreateBSSUploadUrls($createBSSUploadUrlsInput: CreateBSSUploadUrlsInput!) @trace_info(traceInfo: {pod: proposals}) {\n  createBSSUploadUrls(createBSSUploadUrlsInput: $createBSSUploadUrlsInput) {\n    blobId\n    contentSha256\n    uploadNeeded\n    uploadUrl\n    mandatoryUploadHeaders {\n      name\n      value\n    }\n  }\n}\n    `;\nexport type CreateBssUploadUrlsMutationFn = Apollo.MutationFunction<CreateBssUploadUrlsMutation, CreateBssUploadUrlsMutationVariables>;\n\n/**\n * __useCreateBssUploadUrlsMutation__\n *\n * To run a mutation, you first call `useCreateBssUploadUrlsMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCreateBssUploadUrlsMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [createBssUploadUrlsMutation, { data, loading, error }] = useCreateBssUploadUrlsMutation({\n *   variables: {\n *      createBSSUploadUrlsInput: // value for 'createBSSUploadUrlsInput'\n *   },\n * });\n */\nexport function useCreateBssUploadUrlsMutation(baseOptions?: Apollo.MutationHookOptions<CreateBssUploadUrlsMutation, CreateBssUploadUrlsMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useMutation<CreateBssUploadUrlsMutation, CreateBssUploadUrlsMutationVariables>(CreateBssUploadUrlsDocument, options);\n      }\nexport type CreateBssUploadUrlsMutationHookResult = ReturnType<typeof useCreateBssUploadUrlsMutation>;\nexport type CreateBssUploadUrlsMutationResult = Apollo.MutationResult<CreateBssUploadUrlsMutation>;\nexport type CreateBssUploadUrlsMutationOptions = Apollo.BaseMutationOptions<CreateBssUploadUrlsMutation, CreateBssUploadUrlsMutationVariables>;","import { useCallback, useRef } from 'react';\n\nimport { ApolloClient, FileUploadHandler, useAppModule } from '@aurorasolar/common-module-loader';\n\nimport {\n  GetUserInfoDocument,\n  GetUserInfoQuery,\n  GetUserInfoQueryVariables,\n  useCreateBssUploadUrlsMutation,\n} from '../file-uploader.generated';\n\nexport const useCreateBssUploadUrls = () => {\n  const userId = useRef<string | undefined>();\n  const fileUploader = useAppModule(FileUploadHandler);\n  const client = useAppModule(ApolloClient);\n\n  const fetchUserId = useCallback(async () => {\n    if (!client) {\n      throw new Error('Apollo Client is not initialized');\n    }\n\n    if (userId.current) {\n      return userId.current;\n    }\n\n    const userData = await client.query<GetUserInfoQuery, GetUserInfoQueryVariables>({\n      fetchPolicy: 'cache-first',\n      query: GetUserInfoDocument,\n    });\n\n    const newUserId = userData.data.currentUser?.id;\n    userId.current = newUserId;\n    return newUserId;\n  }, [client]);\n\n  const [createBssUploadUrls] = useCreateBssUploadUrlsMutation();\n\n  const fetchBssUploadUrls = useCallback(\n    async (files: File[]) => {\n      let currentUserId = userId.current;\n      if (!currentUserId) {\n        try {\n          currentUserId = await fetchUserId();\n        } catch {\n          throw new Error('Failed to fetch userId');\n        }\n      }\n\n      // Fetch worked but still came back undefined\n      if (!currentUserId) {\n        throw new Error('Cannot request BSS Urls without a userId');\n      }\n\n      if (!fileUploader?.hashFile) {\n        throw new Error('fileUploader must be ready to use');\n      }\n\n      const bssUploadInputsPromises = files.map(async (file) => {\n        const hash = (await fileUploader?.hashFile?.(file)) ?? '';\n        return {\n          blobName: file.name,\n          contentLength: file.size,\n          contentSha256: hash,\n          mimeType: file.type,\n        };\n      });\n\n      const bssUploadInputs = await Promise.all(bssUploadInputsPromises);\n\n      try {\n        const result = await createBssUploadUrls({\n          variables: {\n            createBSSUploadUrlsInput: {\n              files: bssUploadInputs,\n              id: currentUserId,\n            },\n          },\n        });\n\n        return result.data?.createBSSUploadUrls;\n      } catch (e) {\n        throw new Error(`Failed to fetch BSS Upload tokens ${e}`);\n      }\n    },\n    [fileUploader, createBssUploadUrls, fetchUserId],\n  );\n\n  return fileUploader ? fetchBssUploadUrls : undefined;\n};\n","import { useCallback } from 'react';\n\nimport { useStartAsyncJobMutation } from '@aurorasolar/common-data-access-layer';\nimport { ApolloClient, AsyncJob, useAppModule } from '@aurorasolar/common-module-loader';\nimport {\n  AsyncJobType,\n  FileUploaderResult,\n  UserFileLabel,\n} from '@aurorasolar/graphql-client-schema';\n\nexport const useUploadFileAsyncJob = () => {\n  const [startAsyncJob] = useStartAsyncJobMutation();\n  const invalidateJobs = useAppModule(AsyncJob)?.invalidateJobs;\n  const client = useAppModule(ApolloClient);\n\n  const runUploadFileAsyncJob = useCallback(\n    async (\n      temporaryBlobId: string,\n      fileName: string,\n      label: UserFileLabel,\n      mimeType: string,\n      parentId?: string,\n      parentType?: string,\n      parentRoleType?: string,\n    ) => {\n      try {\n        const result = await startAsyncJob({\n          variables: {\n            settings: {\n              fileName,\n              label,\n              mimeType,\n              parentId,\n              parentRoleType,\n              parentType,\n              temporaryBlobId,\n            },\n            type: AsyncJobType.FileUploader,\n          },\n        });\n\n        return result?.data?.startAsyncJob as FileUploaderResult;\n      } catch (e) {\n        throw new Error(`Upload File async job failed ${e}`);\n      }\n    },\n    [startAsyncJob],\n  );\n\n  const invalidateUploadFileAsyncJob = useCallback(\n    (id) => {\n      invalidateJobs?.([`file_uploader_${id}`]);\n    },\n    [invalidateJobs],\n  );\n\n  return {\n    invalidateUploadFileAsyncJob: invalidateJobs ? invalidateUploadFileAsyncJob : undefined,\n    runUploadFileAsyncJob: client ? runUploadFileAsyncJob : undefined,\n  };\n};\n","import { useCallback, useEffect, useRef, useState } from 'react';\n\nimport { generateUuid } from '@aurorasolar/common-core/src/utils';\nimport { FileUploadHandler, useAppModule } from '@aurorasolar/common-module-loader';\nimport { UserFileLabel } from '@aurorasolar/graphql-client-schema';\n\nimport { FileResult, FileResultUploadStatus, getFileResultType } from '../common';\nimport { useCreateBssUploadUrls } from './use-create-bss-upload-urls';\nimport { useUploadFileAsyncJob } from './use-upload-file-async-job';\n\nexport const SERVER_ERROR_MESSAGE = 'Failed to upload to server';\n\nconst fileResultNotInProgress = (fileResult: FileResult): boolean => {\n  return fileResult.status !== FileResultUploadStatus.IN_PROGRESS;\n};\n\nexport interface UserFileOptions {\n  label: UserFileLabel;\n  parentId?: string;\n  parentType?: string;\n  parentRoleType?: string;\n}\n\nexport const useUploadFiles = (userFileOptions: UserFileOptions) => {\n  // Store fileResults in a ref so that they can be accessed inside a useCallback function without stale values\n  // Store in object so that getting fileResult by ID is quicker\n  const fileMap = useRef<{ [key: string]: FileResult }>({});\n  // fileResults is an array of references to items in the fileMap\n  // keeps ordering of files, when updated allows for rerender to give updated results\n  const [fileResults, setFileResults] = useState<FileResult[]>([]);\n\n  // Needed to get the signed urls for uploading file directly\n  const fetchBssUploadUrls = useCreateBssUploadUrls();\n  // fileUploader.uploadToSignedUrl makes POST request to upload file to signed url\n  const fileUploader = useAppModule(FileUploadHandler);\n  // runUploadFileAsyncJob used to tell BE file is ready to run validations on\n  //  returns results of successful validated UserFiles or validation errors\n  // invalidateUploadFileAsyncJob is used to cancel the asyncJob if the file upload is canceled\n  const { runUploadFileAsyncJob, invalidateUploadFileAsyncJob } = useUploadFileAsyncJob();\n\n  const updateFileResult = useCallback((id: string, updatedOptions: Partial<FileResult>) => {\n    setFileResults((prev) => {\n      const newFileResults = [...prev];\n      const updateIndex = newFileResults.findIndex((fileResult) => fileResult.id === id);\n      if (updateIndex >= 0) {\n        fileMap.current[id] = {\n          ...newFileResults[updateIndex],\n          ...updatedOptions,\n        };\n        newFileResults[updateIndex] = fileMap.current[id];\n\n        return newFileResults;\n      }\n      return prev;\n    });\n  }, []);\n\n  // Set the status of a fileResult to cancel to queue the canceling of asyncJob (if it exists)\n  const cancelFileUpload = useCallback(\n    (id: string) => {\n      const fileResult = fileMap.current[id];\n      if (\n        fileResult?.status === FileResultUploadStatus.IN_PROGRESS ||\n        fileResult?.status === FileResultUploadStatus.PENDING\n      ) {\n        updateFileResult(id, { status: FileResultUploadStatus.CANCELED });\n      } else {\n        console.warn(\n          `Cannot cancel file upload when file result status is \"${fileResult?.status}\". Status must be \"in-progress\" or \"pending\"`,\n        );\n      }\n    },\n    [updateFileResult],\n  );\n\n  // Set the status of the fileResult to pending to re-queue the file for upload\n  const retryFileUpload = useCallback(\n    (id: string) => {\n      const fileResult = fileMap.current[id];\n      if (\n        fileResult?.status === FileResultUploadStatus.NON_VALIDATION_ERROR ||\n        fileResult?.status === FileResultUploadStatus.VALIDATION_ERROR\n      ) {\n        updateFileResult(id, {\n          errorText: undefined,\n          result: undefined,\n          status: FileResultUploadStatus.PENDING,\n        });\n      } else {\n        console.warn(\n          `Cannot retry file upload when file result status is \"${fileResult?.status}\". Status must be \"validation-error\" or \"non-validation-error\"`,\n        );\n      }\n    },\n    [updateFileResult],\n  );\n\n  // Remove a fileResult from the array (used after canceling completed)\n  const removeFileUpload = useCallback((id: string) => {\n    setFileResults((prev) => {\n      const newFileResults = [...prev].filter((fileResult) => fileResult.id !== id);\n      delete fileMap.current[id];\n      return newFileResults;\n    });\n  }, []);\n\n  const clearResults = useCallback(() => {\n    setFileResults([]);\n    fileMap.current = {};\n  }, []);\n\n  // Used to add files that failed external validation to the results list\n  const addErroredFiles = useCallback((erroredFiles: { errorText: string; file: File }[]) => {\n    const newErroredFileResults = erroredFiles.map(({ errorText, file }) => {\n      const id = generateUuid();\n      const newErroredFileResult = {\n        errorText,\n        file,\n        fileType: getFileResultType(file.type),\n        id,\n        status: FileResultUploadStatus.VALIDATION_ERROR,\n      };\n\n      fileMap.current[id] = newErroredFileResult;\n      return fileMap.current[id];\n    });\n\n    setFileResults((prev) => [...prev, ...newErroredFileResults]);\n  }, []);\n\n  const uploadFiles = useCallback(async (newFiles: File[]) => {\n    const newFileResults = newFiles.map((newFile) => {\n      const id = generateUuid();\n      const newFileResult = {\n        file: newFile,\n        fileType: getFileResultType(newFile.type),\n        id,\n        status: FileResultUploadStatus.PENDING,\n      };\n\n      fileMap.current[id] = newFileResult;\n      return fileMap.current[id];\n    });\n\n    setFileResults((prev) => [...prev, ...newFileResults]);\n  }, []);\n\n  // LOGIC TO UPLOAD QUEUED PENDING FILES\n  useEffect(() => {\n    const asyncUploadFiles = async () => {\n      const pendingFileResults = fileResults.filter(\n        (fileResult) => fileResult.status === FileResultUploadStatus.PENDING,\n      );\n\n      if (pendingFileResults.length > 0) {\n        const pendingFiles = pendingFileResults.map((fileResult) => {\n          updateFileResult(fileResult.id, { status: FileResultUploadStatus.IN_PROGRESS });\n          return fileResult.file;\n        });\n\n        try {\n          // Get the all the signed urls needed to upload files\n          const bssUploadUrls = await fetchBssUploadUrls?.(pendingFiles);\n          bssUploadUrls?.forEach(async (uploadUrl, i) => {\n            const inProgressFileResult = fileMap.current[pendingFileResults[i]?.id];\n            if (uploadUrl) {\n              try {\n                // Stop upload process early if status has changed\n                if (fileResultNotInProgress(inProgressFileResult)) {\n                  return;\n                }\n\n                // Upload file directly to BSS from FE\n                const blobId = await fileUploader?.uploadToSignedUrl?.(pendingFiles[i], uploadUrl);\n\n                // Stop upload process early if status has changed\n                if (fileResultNotInProgress(inProgressFileResult)) {\n                  return;\n                }\n                if (blobId) {\n                  // Start the async job to run validations for label\n                  const result = await runUploadFileAsyncJob?.(\n                    blobId,\n                    pendingFiles[i].name,\n                    userFileOptions.label,\n                    pendingFiles[i].type,\n                    userFileOptions.parentId,\n                    userFileOptions.parentType,\n                    userFileOptions.parentRoleType,\n                  );\n\n                  updateFileResult(inProgressFileResult.id, { result });\n\n                  // Stop upload process early if status has changed\n                  if (fileResultNotInProgress(inProgressFileResult)) {\n                    return;\n                  }\n\n                  // Full upload has finished, save the result (either success or validation error)\n                  if (result?.errors?.length) {\n                    const [firstError] = result.errors;\n                    updateFileResult(inProgressFileResult.id, {\n                      errorText: firstError,\n                      status: FileResultUploadStatus.VALIDATION_ERROR,\n                    });\n                  } else {\n                    updateFileResult(inProgressFileResult?.id, {\n                      status: FileResultUploadStatus.COMPLETE,\n                    });\n                  }\n                }\n              } catch (e) {\n                // If something has errored during the individual file upload process set a non validation error\n                updateFileResult(inProgressFileResult?.id, {\n                  errorText: SERVER_ERROR_MESSAGE,\n                  status: FileResultUploadStatus.NON_VALIDATION_ERROR,\n                });\n              }\n            }\n          });\n        } catch (e) {\n          pendingFileResults.forEach((fileResult) => {\n            updateFileResult(fileResult.id, {\n              errorText: SERVER_ERROR_MESSAGE,\n              status: FileResultUploadStatus.NON_VALIDATION_ERROR,\n            });\n          });\n        }\n      }\n    };\n\n    if (fileResults && fetchBssUploadUrls && fileUploader && runUploadFileAsyncJob) {\n      asyncUploadFiles();\n    }\n  }, [\n    fileResults,\n    fetchBssUploadUrls,\n    updateFileResult,\n    fileUploader,\n    runUploadFileAsyncJob,\n    userFileOptions,\n  ]);\n\n  // LOGIC TO CANCEL UPLOAD FOR QUEUED CANCELED FILES\n  useEffect(() => {\n    const cancelFileResults = fileResults.filter(\n      (fileResult) => fileResult.status === FileResultUploadStatus.CANCELED,\n    );\n\n    if (cancelFileResults.length > 0 && invalidateUploadFileAsyncJob) {\n      cancelFileResults.forEach(async (fileResult) => {\n        await invalidateUploadFileAsyncJob(fileResult?.id);\n        removeFileUpload(fileResult.id);\n      });\n    }\n  }, [fileResults, removeFileUpload, invalidateUploadFileAsyncJob]);\n\n  return {\n    addErroredFiles,\n    cancelFileUpload,\n    clearResults,\n    results: fileResults,\n    retryFileUpload,\n    uploadFiles,\n  };\n};\n","// @ts-ignore: Ignore unused { * as Types } import\nimport * as Types from '@aurorasolar/graphql-client-schema';\n\nimport { gql } from '@apollo/client';\nimport * as Apollo from '@apollo/client';\nconst defaultOptions = {} as const;\nexport type SaveDesignMutationVariables = Types.Exact<{\n  designId: Types.Scalars['ID'];\n  cadUpdatedDesign: Types.CadUpdatedDesign;\n}>;\n\n\nexport type SaveDesignMutation = { __typename: 'Mutation', saveDesign: { __typename: 'Design', id: string, savesDisabled?: boolean | null | undefined, designString?: string | null | undefined, designJson?: any | null | undefined, siteString?: string | null | undefined, siteJson?: any | null | undefined, latitude: number, longitude: number, savedFromNewCad: boolean, irradianceMapId?: string | null | undefined, irradianceMapStatus?: string | null | undefined, irradiancePanelsId?: string | null | undefined, irradiancePanelsStatus?: string | null | undefined, temperatureMax?: number | null | undefined, temperatureMin?: number | null | undefined, geodataBaseUrl?: string | null | undefined, geodataParentId?: number | null | undefined, updatedAt?: string | null | undefined, energyOffsetPercent?: number | null | undefined, systemSize?: number | null | undefined, pricePerWatt?: number | null | undefined, addersAndDiscounts?: Array<{ __typename: 'Adder', id: string, adderName?: string | null | undefined, adderType?: Types.AdderType | null | undefined, adderValue?: number | null | undefined }> | null | undefined, avoidedCost: { __typename: 'AvoidedCost', id: string, valid?: boolean | null | undefined, billOffsetPercentage?: number | null | undefined }, masterPerformanceSimulation: { __typename: 'PerformanceSimulation', id: string, valid?: boolean | null | undefined }, financings?: Array<{ __typename: 'Financing', id: string, valid?: boolean | null | undefined }> | null | undefined, pricing: { __typename: 'Pricing', id: string, systemCost: number } } };\n\nexport type CadUberModeQueryVariables = Types.Exact<{ [key: string]: never; }>;\n\n\nexport type CadUberModeQuery = { __typename: 'Query', CAD: { __typename: 'CAD', uberMode: string } };\n\nexport type GetDesignByIdQueryVariables = Types.Exact<{\n  id: Types.Scalars['ID'];\n}>;\n\n\nexport type GetDesignByIdQuery = { __typename: 'Query', designById: { __typename: 'Design', id: string, savesDisabled?: boolean | null | undefined, designString?: string | null | undefined, designJson?: any | null | undefined, siteString?: string | null | undefined, siteJson?: any | null | undefined, latitude: number, longitude: number, savedFromNewCad: boolean, irradianceMapId?: string | null | undefined, irradianceMapStatus?: string | null | undefined, irradiancePanelsId?: string | null | undefined, irradiancePanelsStatus?: string | null | undefined, temperatureMax?: number | null | undefined, temperatureMin?: number | null | undefined, geodataBaseUrl?: string | null | undefined, geodataParentId?: number | null | undefined } };\n\nexport type CadModeQueryVariables = Types.Exact<{ [key: string]: never; }>;\n\n\nexport type CadModeQuery = { __typename: 'Query', CAD: { __typename: 'CAD', mode: string } };\n\n\nexport const SaveDesignDocument = gql`\n    mutation SaveDesign($designId: ID!, $cadUpdatedDesign: CadUpdatedDesign!) @trace_info(traceInfo: {pod: cad}) {\n  saveDesign(id: $designId, cadUpdatedDesign: $cadUpdatedDesign) {\n    id\n    savesDisabled\n    designString\n    designJson @client\n    siteString\n    siteJson @client\n    latitude\n    longitude\n    savedFromNewCad\n    irradianceMapId\n    irradianceMapStatus\n    irradiancePanelsId\n    irradiancePanelsStatus\n    temperatureMax\n    temperatureMin\n    geodataBaseUrl\n    geodataParentId\n    updatedAt\n    energyOffsetPercent\n    systemSize\n    pricePerWatt\n    addersAndDiscounts {\n      id\n      adderName\n      adderType\n      adderValue\n    }\n    avoidedCost {\n      id\n      valid\n      billOffsetPercentage\n    }\n    masterPerformanceSimulation {\n      id\n      valid\n    }\n    financings {\n      id\n      valid\n    }\n    pricing {\n      id\n      systemCost\n    }\n  }\n}\n    `;\nexport type SaveDesignMutationFn = Apollo.MutationFunction<SaveDesignMutation, SaveDesignMutationVariables>;\n\n/**\n * __useSaveDesignMutation__\n *\n * To run a mutation, you first call `useSaveDesignMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSaveDesignMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [saveDesignMutation, { data, loading, error }] = useSaveDesignMutation({\n *   variables: {\n *      designId: // value for 'designId'\n *      cadUpdatedDesign: // value for 'cadUpdatedDesign'\n *   },\n * });\n */\nexport function useSaveDesignMutation(baseOptions?: Apollo.MutationHookOptions<SaveDesignMutation, SaveDesignMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useMutation<SaveDesignMutation, SaveDesignMutationVariables>(SaveDesignDocument, options);\n      }\nexport type SaveDesignMutationHookResult = ReturnType<typeof useSaveDesignMutation>;\nexport type SaveDesignMutationResult = Apollo.MutationResult<SaveDesignMutation>;\nexport type SaveDesignMutationOptions = Apollo.BaseMutationOptions<SaveDesignMutation, SaveDesignMutationVariables>;\nexport const CadUberModeDocument = gql`\n    query CadUberMode @trace_info(traceInfo: {pod: cad}) {\n  CAD @client {\n    uberMode\n  }\n}\n    `;\n\n/**\n * __useCadUberModeQuery__\n *\n * To run a query within a React component, call `useCadUberModeQuery` and pass it any options that fit your needs.\n * When your component renders, `useCadUberModeQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCadUberModeQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useCadUberModeQuery(baseOptions?: Apollo.QueryHookOptions<CadUberModeQuery, CadUberModeQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<CadUberModeQuery, CadUberModeQueryVariables>(CadUberModeDocument, options);\n      }\nexport function useCadUberModeLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CadUberModeQuery, CadUberModeQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<CadUberModeQuery, CadUberModeQueryVariables>(CadUberModeDocument, options);\n        }\nexport type CadUberModeQueryHookResult = ReturnType<typeof useCadUberModeQuery>;\nexport type CadUberModeLazyQueryHookResult = ReturnType<typeof useCadUberModeLazyQuery>;\nexport type CadUberModeQueryResult = Apollo.QueryResult<CadUberModeQuery, CadUberModeQueryVariables>;\nexport const GetDesignByIdDocument = gql`\n    query GetDesignById($id: ID!) @trace_info(traceInfo: {pod: cad}) {\n  designById(id: $id) {\n    id\n    savesDisabled\n    designString\n    designJson @client\n    siteString\n    siteJson @client\n    latitude\n    longitude\n    savedFromNewCad\n    irradianceMapId\n    irradianceMapStatus\n    irradiancePanelsId\n    irradiancePanelsStatus\n    temperatureMax\n    temperatureMin\n    geodataBaseUrl\n    geodataParentId\n  }\n}\n    `;\n\n/**\n * __useGetDesignByIdQuery__\n *\n * To run a query within a React component, call `useGetDesignByIdQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetDesignByIdQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetDesignByIdQuery({\n *   variables: {\n *      id: // value for 'id'\n *   },\n * });\n */\nexport function useGetDesignByIdQuery(baseOptions: Apollo.QueryHookOptions<GetDesignByIdQuery, GetDesignByIdQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<GetDesignByIdQuery, GetDesignByIdQueryVariables>(GetDesignByIdDocument, options);\n      }\nexport function useGetDesignByIdLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetDesignByIdQuery, GetDesignByIdQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<GetDesignByIdQuery, GetDesignByIdQueryVariables>(GetDesignByIdDocument, options);\n        }\nexport type GetDesignByIdQueryHookResult = ReturnType<typeof useGetDesignByIdQuery>;\nexport type GetDesignByIdLazyQueryHookResult = ReturnType<typeof useGetDesignByIdLazyQuery>;\nexport type GetDesignByIdQueryResult = Apollo.QueryResult<GetDesignByIdQuery, GetDesignByIdQueryVariables>;\nexport const CadModeDocument = gql`\n    query CadMode @trace_info(traceInfo: {pod: cad}) {\n  CAD @client {\n    mode\n  }\n}\n    `;\n\n/**\n * __useCadModeQuery__\n *\n * To run a query within a React component, call `useCadModeQuery` and pass it any options that fit your needs.\n * When your component renders, `useCadModeQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCadModeQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useCadModeQuery(baseOptions?: Apollo.QueryHookOptions<CadModeQuery, CadModeQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<CadModeQuery, CadModeQueryVariables>(CadModeDocument, options);\n      }\nexport function useCadModeLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CadModeQuery, CadModeQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<CadModeQuery, CadModeQueryVariables>(CadModeDocument, options);\n        }\nexport type CadModeQueryHookResult = ReturnType<typeof useCadModeQuery>;\nexport type CadModeLazyQueryHookResult = ReturnType<typeof useCadModeLazyQuery>;\nexport type CadModeQueryResult = Apollo.QueryResult<CadModeQuery, CadModeQueryVariables>;","// @ts-ignore: Ignore unused { * as Types } import\nimport * as Types from '@aurorasolar/graphql-client-schema';\n\nimport { gql } from '@apollo/client';\nimport * as Apollo from '@apollo/client';\nconst defaultOptions = {} as const;\nexport type PreSaveQueryVariables = Types.Exact<{\n  designId: Types.Scalars['ID'];\n}>;\n\n\nexport type PreSaveQuery = { __typename: 'Query', design: { __typename: 'Design', id: string, savesDisabled?: boolean | null | undefined }, CAD: { __typename: 'CAD', irradiance: { __typename: 'IrradianceState', roof: { __typename: 'IrradianceStateType', mapId?: string | null | undefined, jobCanBeRun: boolean, status?: Types.IrradianceStates | null | undefined }, panels: { __typename: 'IrradianceStateType', mapId?: string | null | undefined, jobCanBeRun: boolean, status?: Types.IrradianceStates | null | undefined } } } };\n\n\nexport const PreSaveDocument = gql`\n    query PreSave($designId: ID!) @trace_info(traceInfo: {pod: cad}) {\n  design: designById(id: $designId) {\n    id\n    savesDisabled\n  }\n  CAD @client {\n    irradiance: irradianceState {\n      roof {\n        mapId\n        jobCanBeRun\n        status\n      }\n      panels {\n        mapId\n        jobCanBeRun\n        status\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __usePreSaveQuery__\n *\n * To run a query within a React component, call `usePreSaveQuery` and pass it any options that fit your needs.\n * When your component renders, `usePreSaveQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = usePreSaveQuery({\n *   variables: {\n *      designId: // value for 'designId'\n *   },\n * });\n */\nexport function usePreSaveQuery(baseOptions: Apollo.QueryHookOptions<PreSaveQuery, PreSaveQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<PreSaveQuery, PreSaveQueryVariables>(PreSaveDocument, options);\n      }\nexport function usePreSaveLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PreSaveQuery, PreSaveQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<PreSaveQuery, PreSaveQueryVariables>(PreSaveDocument, options);\n        }\nexport type PreSaveQueryHookResult = ReturnType<typeof usePreSaveQuery>;\nexport type PreSaveLazyQueryHookResult = ReturnType<typeof usePreSaveLazyQuery>;\nexport type PreSaveQueryResult = Apollo.QueryResult<PreSaveQuery, PreSaveQueryVariables>;","import { Store } from 'redux';\nimport { filter, firstValueFrom, map, Subject } from 'rxjs';\n\nimport {\n  CadEvent,\n  CadEventTypes,\n  CADTriggerActionTypes,\n  triggerCADAction,\n} from '@aurorasolar/common-data-store';\nimport { CadEngine } from '@aurorasolar/common-module-loader';\nimport { useUploadFiles } from '@aurorasolar/file-uploader';\n\nexport interface ScreenshotDeps {\n  cadEvents$: Subject<CadEvent<CadEventTypes>>;\n  designId: string;\n  engine: CadEngine;\n  fileUploader: ReturnType<typeof useUploadFiles>;\n  reduxStore: Store;\n  saveVersion: string;\n}\n\n/**\n * Adds a timeout to a Promise.\n * Throws the an error with the timeout message if the timeout is reached before the promise resolves.\n * */\nconst withTimeout = <T>(promise: Promise<T>, time: number, timeoutMessage: string) => {\n  const timeoutPromise = new Promise((resolve) => {\n    setTimeout(resolve, time);\n  }).then(() => {\n    throw new Error(timeoutMessage);\n  });\n  return Promise.race([promise, timeoutPromise]);\n};\n\n/**\n * Resolves a promise with the first screenshot event it sees with a matching id\n */\nconst listenForScreenshotResponse = (cadEvents$: Subject<CadEvent<CadEventTypes>>, id: string) =>\n  firstValueFrom(\n    cadEvents$.pipe(\n      filter(\n        (event): event is CadEvent<CadEventTypes.CadScreenshot> =>\n          event.eventType === CadEventTypes.CadScreenshot && event.payload.id === id,\n      ),\n      map((event) => event.payload),\n    ),\n  );\n\n/**\n * Requests a screenshot from CAD and then uploads that screenshot\n * with the fileUploader\n */\nexport const takeSaveScreenshot = async ({\n  cadEvents$,\n  designId,\n  engine,\n  fileUploader,\n  reduxStore,\n  saveVersion,\n}: ScreenshotDeps) => {\n  const screenshotPromise = listenForScreenshotResponse(cadEvents$, saveVersion);\n  reduxStore.dispatch(\n    triggerCADAction({\n      actionType: CADTriggerActionTypes.TakeScreenshot,\n      cadInstance: { engine },\n      props: { id: saveVersion, imageType: 'png' },\n    }),\n  );\n  const screenshotResponse = await withTimeout(\n    screenshotPromise,\n    30000,\n    'Timed out taking a screenshot',\n  );\n\n  const screenshotFile = new File(\n    [screenshotResponse.data],\n    `${designId}.${screenshotResponse.imageType}`,\n    { type: screenshotResponse.data.type },\n  );\n\n  await withTimeout(\n    fileUploader.uploadFiles([screenshotFile]),\n    60000,\n    'Screenshot upload timed out',\n  );\n};\n","import { Store } from 'redux';\nimport { Subject } from 'rxjs';\n\nimport { ApolloClient, NormalizedCacheObject } from '@apollo/client';\nimport { CadEvent, CadEventTypes } from '@aurorasolar/common-data-store';\nimport { CadEngine, CadSaveData } from '@aurorasolar/common-module-loader';\nimport { useUploadFiles } from '@aurorasolar/file-uploader';\nimport { Query, CadUpdatedDesign, IrradianceStates } from '@aurorasolar/graphql-client-schema';\nimport type { Reference, StoreObject } from '@apollo/client';\n\nimport {\n  SaveDesignDocument,\n  SaveDesignMutation,\n  SaveDesignMutationVariables,\n} from '../cad.generated';\nimport { CadContextType } from '../use-cad';\nimport { PreSaveDocument, PreSaveQuery } from './cad-save-callback.generated';\nimport { checkCadCanSave } from './check-cad-can-save';\nimport { takeSaveScreenshot } from './take-save-screenshot';\n\nexport interface CadSaveCallbackDeps {\n  apolloClient: ApolloClient<NormalizedCacheObject>;\n  cadContext: CadContextType;\n  cadEvents$: Subject<CadEvent<CadEventTypes>>;\n  engine: CadEngine;\n  fileUploader: ReturnType<typeof useUploadFiles>;\n  reduxStore: Store;\n  evictCache: <K extends string>(fieldName: K) => void;\n  evictCacheById: (storeObject: StoreObject | Reference) => void;\n}\n\n/**\n * Not to be used directly outside of `getCadSaveCallback()`.\n * This is the save callback that will be passed to the CAD engine during setup,\n * it only intended to be called by the CAD engine.\n * */\nexport const cadSaveCallbackCore = async (\n  {\n    apolloClient,\n    reduxStore,\n    engine,\n    evictCache,\n    evictCacheById,\n    cadEvents$,\n    fileUploader,\n    cadContext,\n  }: CadSaveCallbackDeps,\n  {\n    designId,\n    saveVersion,\n    jsonToSave: { site, system, designJsonSchemaVersion },\n    saveScreenshot = true,\n  }: CadSaveData,\n) => {\n  if (!(await checkCadCanSave(apolloClient, designId, cadContext))) {\n    return;\n  }\n\n  const { CAD } = await apolloClient\n    .query<PreSaveQuery>({\n      fetchPolicy: 'cache-first',\n      query: PreSaveDocument,\n      variables: { designId },\n    })\n    .then(({ data }) => data);\n\n  // indicate within CAD state that a save is in process\n  cadContext?.state?.actions?.saveActions.startSaving();\n\n  const systemStats = cadContext?.state?.data.systemStatsData;\n\n  const cadUpdatedDesign: CadUpdatedDesign = {\n    carportSystemSizeStc: systemStats?.offRoofSystemSizeStc,\n    design: JSON.stringify(system),\n    designJsonSchemaVersion: designJsonSchemaVersion ?? 0,\n    id: designId,\n    irradianceMapId: CAD.irradiance.roof.mapId,\n    irradianceMapStatus: CAD.irradiance.roof.status || IrradianceStates.Invalid,\n    irradiancePanelsId: CAD.irradiance.panels.mapId,\n    irradiancePanelsStatus: CAD.irradiance.panels.status || IrradianceStates.Invalid,\n    roofSystemSizeStc: systemStats?.roofSystemSizeStc,\n    site: JSON.stringify(site),\n    systemSizeAc: systemStats?.systemSizeAc,\n    systemSizePtc: systemStats?.systemSizePtc,\n    systemSizeStc: systemStats?.systemSizeStc,\n  };\n\n  const savePromise = apolloClient\n    .mutate<SaveDesignMutation, SaveDesignMutationVariables>({\n      awaitRefetchQueries: true,\n      mutation: SaveDesignDocument,\n      variables: {\n        cadUpdatedDesign,\n        designId,\n      },\n    })\n    .finally(() => {\n      evictCache<keyof Query>('componentSummaryByDesignId');\n      evictCacheById({\n        __typename: 'Design',\n        id: designId,\n      });\n    });\n\n  const screenshotPromise = saveScreenshot\n    ? takeSaveScreenshot({\n        cadEvents$,\n        designId,\n        engine,\n        fileUploader,\n        reduxStore,\n        saveVersion,\n      }).catch((error) => {\n        console.warn('Save screenshot failed');\n        console.warn(error);\n      })\n    : null;\n\n  await Promise.all([savePromise, screenshotPromise]);\n\n  cadContext?.state?.actions?.saveActions.finishSaving(saveVersion);\n};\n","import { ApolloClient, NormalizedCacheObject } from '@apollo/client';\nimport { CadContextType } from '../use-cad';\n\nimport { PreSaveDocument, PreSaveQuery } from './cad-save-callback.generated';\n\nexport const checkCadCanSave = async (\n  client: ApolloClient<NormalizedCacheObject>,\n  designId: string,\n  cadContext: CadContextType,\n) => {\n  const isSaving = cadContext?.state?.data.saveData.isSaving;\n  const { design } = await client\n    .query<PreSaveQuery>({\n      fetchPolicy: 'cache-first',\n      query: PreSaveDocument,\n      variables: { designId },\n    })\n\n    .then(({ data }) => data);\n\n  const canSave =\n    !design.savesDisabled && cadContext?.state?.data.saveData.hasUnsavedChanges && !isSaving;\n\n  return canSave;\n};\n","import { CadSaveData } from '@aurorasolar/common-module-loader';\n\nimport { cadSaveCallbackCore, CadSaveCallbackDeps } from './cad-save-callback-core';\n\nexport type SaveFn = typeof cadSaveCallbackCore;\n\n/**\n * This creates a callback to be passed in to the CAD engine during setup.\n * It ensures that only one save function will run at a time.\n * Subsequent save calls will be chained on to the end of the current call.\n */\nexport const getCadSaveCallback = (saveDependencies: CadSaveCallbackDeps) => {\n  let currentSave: Promise<void> = Promise.resolve();\n\n  return async (data: CadSaveData) => {\n    const result = currentSave.then(() => cadSaveCallbackCore(saveDependencies, data));\n\n    currentSave = result.catch(() => {});\n\n    await result;\n\n    if (result === currentSave) {\n      currentSave = Promise.resolve();\n    }\n  };\n};\n","export async function convertCanvasToBlob(\n  canvas: HTMLCanvasElement,\n  fileType: string,\n): Promise<Blob | undefined> {\n  const imageCanvas = document.createElement('canvas');\n  imageCanvas.width = canvas.width;\n  imageCanvas.height = canvas.height;\n  const imageContext = imageCanvas.getContext('2d')!;\n\n  imageContext.drawImage(canvas, 0, 0, imageCanvas.width, imageCanvas.height);\n\n  return new Promise<Blob | undefined>((resolve) => {\n    const resolver: BlobCallback = (blob) => {\n      resolve(blob || undefined);\n    };\n    imageCanvas.toBlob(resolver, fileType);\n  });\n}\n\nexport async function downloadCanvasAsPng(canvas: HTMLCanvasElement, filename?: string) {\n  const blob = await convertCanvasToBlob(canvas, 'image/png');\n\n  if (!blob) {\n    throw new Error('Could not create Canvas blob');\n  }\n\n  const url = URL.createObjectURL(blob);\n  downloadDataURL(url, filename);\n\n  // cleanup\n  URL.revokeObjectURL(url);\n}\n\nconst shouldEscapeCSV = ['\"', \"'\", ','];\nconst shouldSkipInCSV = ['\\n'];\nconst escapeCSVString = (str: string) => {\n  let escaped = '';\n  for (let i = 0; i < str.length; i += 1) {\n    const currentChar = str[i];\n    if (!shouldSkipInCSV.includes(currentChar)) {\n      if (shouldEscapeCSV.includes(currentChar)) {\n        escaped += `\"${currentChar}\"`;\n      } else {\n        escaped += currentChar;\n      }\n    }\n  }\n  return escaped;\n};\n\nconst CSV_DATA_URL_PREFIX = `data:text/csv;charset=utf-8,`;\nexport function createCSVDataURL(csv: string[][]) {\n  return `${CSV_DATA_URL_PREFIX}${csv.map((row) => row.map(escapeCSVString).join(',')).join('\\n')}`;\n}\n\nexport function downloadDataURL(\n  url: string,\n  filename: string = 'file.csv',\n  createLink: boolean = false,\n) {\n  const encodedURI = encodeURI(url);\n  const link = document.createElement('a');\n  link.setAttribute('href', encodedURI);\n  link.setAttribute('download', filename);\n  if (createLink) {\n    link.style.display = 'none';\n    document.body.appendChild(link);\n    link.click();\n    document.body.removeChild(link);\n  } else {\n    link.click();\n  }\n}\n","import { ApolloClient, NormalizedCacheObject } from '@apollo/client';\nimport { downloadDataURL } from '@aurorasolar/common-core/src/utils/download-utils';\nimport {\n  StartAsyncJobDocument,\n  StartAsyncJobMutation,\n  StartAsyncJobMutationVariables,\n} from '@aurorasolar/common-data-access-layer';\nimport { CADTriggerActionProps, CADTriggerActionTypes } from '@aurorasolar/common-data-store';\nimport { AsyncDxf, AsyncJobParameters, AsyncJobType } from '@aurorasolar/graphql-client-schema';\n\nexport const downloadDxf = async (\n  client: ApolloClient<NormalizedCacheObject>,\n  payload: AsyncJobParameters,\n) => {\n  const { data } = await client.mutate<StartAsyncJobMutation, StartAsyncJobMutationVariables>({\n    mutation: StartAsyncJobDocument,\n    variables: {\n      settings: payload,\n      type: AsyncJobType.Dxf,\n    },\n  });\n  const dxf = data?.startAsyncJob as AsyncDxf;\n  if (dxf.uri) {\n    downloadDataURL(dxf.uri, 'aurora_dxf.dxf');\n  }\n};\n\nexport type PublicDxfParams = {\n  Buildings: boolean;\n  Obstructions: boolean;\n  Setbacks: boolean;\n  Trees: boolean;\n  Modules: boolean;\n  Inverters: boolean;\n  'Balance Of System': boolean;\n  Connections: boolean;\n  Strings: boolean;\n};\n\nexport type PublicDxfParam = keyof PublicDxfParams;\nexport const PublicDxfParamsList: PublicDxfParam[] = [\n  'Buildings',\n  'Obstructions',\n  'Setbacks',\n  'Trees',\n  'Modules',\n  'Inverters',\n  'Balance Of System',\n  'Connections',\n  'Strings',\n];\n\nexport const translateDxfParams = (input: PublicDxfParams) => {\n  const output: CADTriggerActionProps[CADTriggerActionTypes.DXF] = {};\n  Object.entries(input).forEach(([k, v]) => {\n    if (k === 'Buildings') {\n      output.buildings = v;\n    } else if (k === 'Obstructions') {\n      output.obstructions = v;\n      output.walkways = v;\n    } else if (k === 'Setbacks') {\n      output.setbacks = v;\n    } else if (k === 'Trees') {\n      output.trees = v;\n    } else if (k === 'Modules') {\n      output.modules = v;\n      output.arrays = v;\n    } else if (k === 'Inverters') {\n      output.microinverters = v;\n      output.inverters = v;\n    } else if (k === 'Balance Of System') {\n      output.disconnects = v;\n      output.loadCenters = v;\n      output.meters = v;\n      output.servicePanels = v;\n      output.combinerBoxes = v;\n    } else if (k === 'Connections') {\n      output.connections = v;\n    } else if (k === 'Strings') {\n      output.strings = v;\n    }\n  });\n  return output;\n};\n","// @ts-ignore: Ignore unused { * as Types } import\nimport * as Types from '@aurorasolar/graphql-client-schema';\n\nimport { gql } from '@apollo/client';\nimport * as Apollo from '@apollo/client';\nconst defaultOptions = {} as const;\nexport type AddAssetMutationVariables = Types.Exact<{\n  newAsset: Types.NewAsset;\n}>;\n\n\nexport type AddAssetMutation = { __typename: 'Mutation', addAsset: { __typename: 'Asset', id: string, assetType: Types.AssetType, url?: string | null | undefined, designId?: string | null | undefined, projectId?: string | null | undefined, takenAt?: string | null | undefined, tenantId?: string | null | undefined, userId?: string | null | undefined } };\n\nexport type UpdateAssetMutationVariables = Types.Exact<{\n  updatedAsset: Types.UpdatedAsset;\n}>;\n\n\nexport type UpdateAssetMutation = { __typename: 'Mutation', updateAsset: { __typename: 'Asset', id: string, assetType: Types.AssetType, url?: string | null | undefined, designId?: string | null | undefined, projectId?: string | null | undefined, takenAt?: string | null | undefined, tenantId?: string | null | undefined, userId?: string | null | undefined } };\n\nexport type UploadInProgressQueryVariables = Types.Exact<{ [key: string]: never; }>;\n\n\nexport type UploadInProgressQuery = { __typename: 'Query', cadUploadState?: { __typename: 'CadUploadState', screenshotInProgress?: boolean | null | undefined } | null | undefined };\n\n\nexport const AddAssetDocument = gql`\n    mutation AddAsset($newAsset: NewAsset!) @trace_info(traceInfo: {pod: cad}) {\n  addAsset(newAsset: $newAsset) {\n    id\n    assetType\n    url\n    designId\n    projectId\n    takenAt\n    tenantId\n    userId\n  }\n}\n    `;\nexport type AddAssetMutationFn = Apollo.MutationFunction<AddAssetMutation, AddAssetMutationVariables>;\n\n/**\n * __useAddAssetMutation__\n *\n * To run a mutation, you first call `useAddAssetMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useAddAssetMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [addAssetMutation, { data, loading, error }] = useAddAssetMutation({\n *   variables: {\n *      newAsset: // value for 'newAsset'\n *   },\n * });\n */\nexport function useAddAssetMutation(baseOptions?: Apollo.MutationHookOptions<AddAssetMutation, AddAssetMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useMutation<AddAssetMutation, AddAssetMutationVariables>(AddAssetDocument, options);\n      }\nexport type AddAssetMutationHookResult = ReturnType<typeof useAddAssetMutation>;\nexport type AddAssetMutationResult = Apollo.MutationResult<AddAssetMutation>;\nexport type AddAssetMutationOptions = Apollo.BaseMutationOptions<AddAssetMutation, AddAssetMutationVariables>;\nexport const UpdateAssetDocument = gql`\n    mutation UpdateAsset($updatedAsset: UpdatedAsset!) @trace_info(traceInfo: {pod: cad}) {\n  updateAsset(updatedAsset: $updatedAsset) {\n    id\n    assetType\n    url\n    designId\n    projectId\n    takenAt\n    tenantId\n    userId\n  }\n}\n    `;\nexport type UpdateAssetMutationFn = Apollo.MutationFunction<UpdateAssetMutation, UpdateAssetMutationVariables>;\n\n/**\n * __useUpdateAssetMutation__\n *\n * To run a mutation, you first call `useUpdateAssetMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateAssetMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateAssetMutation, { data, loading, error }] = useUpdateAssetMutation({\n *   variables: {\n *      updatedAsset: // value for 'updatedAsset'\n *   },\n * });\n */\nexport function useUpdateAssetMutation(baseOptions?: Apollo.MutationHookOptions<UpdateAssetMutation, UpdateAssetMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useMutation<UpdateAssetMutation, UpdateAssetMutationVariables>(UpdateAssetDocument, options);\n      }\nexport type UpdateAssetMutationHookResult = ReturnType<typeof useUpdateAssetMutation>;\nexport type UpdateAssetMutationResult = Apollo.MutationResult<UpdateAssetMutation>;\nexport type UpdateAssetMutationOptions = Apollo.BaseMutationOptions<UpdateAssetMutation, UpdateAssetMutationVariables>;\nexport const UploadInProgressDocument = gql`\n    query UploadInProgress @trace_info(traceInfo: {pod: cad}) {\n  cadUploadState @client {\n    screenshotInProgress\n  }\n}\n    `;\n\n/**\n * __useUploadInProgressQuery__\n *\n * To run a query within a React component, call `useUploadInProgressQuery` and pass it any options that fit your needs.\n * When your component renders, `useUploadInProgressQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useUploadInProgressQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useUploadInProgressQuery(baseOptions?: Apollo.QueryHookOptions<UploadInProgressQuery, UploadInProgressQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<UploadInProgressQuery, UploadInProgressQueryVariables>(UploadInProgressDocument, options);\n      }\nexport function useUploadInProgressLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<UploadInProgressQuery, UploadInProgressQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<UploadInProgressQuery, UploadInProgressQueryVariables>(UploadInProgressDocument, options);\n        }\nexport type UploadInProgressQueryHookResult = ReturnType<typeof useUploadInProgressQuery>;\nexport type UploadInProgressLazyQueryHookResult = ReturnType<typeof useUploadInProgressLazyQuery>;\nexport type UploadInProgressQueryResult = Apollo.QueryResult<UploadInProgressQuery, UploadInProgressQueryVariables>;","import { ApolloClient, NormalizedCacheObject } from '@apollo/client';\nimport { downloadDataURL } from '@aurorasolar/common-core/src/utils/download-utils';\nimport { NewAsset } from '@aurorasolar/graphql-client-schema';\n\nimport {\n  AddAssetDocument,\n  AddAssetMutation,\n  AddAssetMutationVariables,\n  UpdateAssetDocument,\n  UpdateAssetMutation,\n  UpdateAssetMutationVariables,\n  UploadInProgressDocument,\n  UploadInProgressQuery,\n} from './asset.generated';\n\nexport const saveScreenshotAsset = async (\n  client: ApolloClient<NormalizedCacheObject>,\n  newAsset: NewAsset,\n  blob: Blob,\n) => {\n  const { data } = await client.mutate<AddAssetMutation, AddAssetMutationVariables>({\n    mutation: AddAssetDocument,\n    variables: {\n      newAsset,\n    },\n  });\n  const asset = data?.addAsset;\n\n  if (!asset?.url) {\n    return undefined;\n  }\n\n  await fetch(asset.url, {\n    body: blob,\n    headers: {\n      'Content-Type': 'image/png',\n    },\n    method: 'PUT',\n    mode: 'cors',\n  });\n\n  await client.mutate<UpdateAssetMutation, UpdateAssetMutationVariables>({\n    mutation: UpdateAssetDocument,\n    variables: {\n      updatedAsset: { id: asset.id, options: { uploadInProgress: false } },\n    },\n  });\n\n  return asset.url.split('?')[0];\n};\n\nexport const saveAndDownloadScreenshotAsset = async (\n  client: ApolloClient<NormalizedCacheObject>,\n  newAsset: NewAsset,\n  blob: Blob,\n) => {\n  client.writeQuery<UploadInProgressQuery>({\n    data: {\n      __typename: 'Query',\n      cadUploadState: {\n        __typename: 'CadUploadState',\n        screenshotInProgress: true,\n      },\n    },\n    query: UploadInProgressDocument,\n  });\n\n  try {\n    await saveScreenshotAsset(client, newAsset, blob);\n  } finally {\n    client.writeQuery<UploadInProgressQuery>({\n      data: {\n        __typename: 'Query',\n        cadUploadState: {\n          __typename: 'CadUploadState',\n          screenshotInProgress: false,\n        },\n      },\n      query: UploadInProgressDocument,\n    });\n  }\n\n  const url = window.URL.createObjectURL(blob);\n  if (shouldDownload(url, newAsset)) {\n    downloadDataURL(url, 'aurora_snapshot.png');\n  }\n};\n\n/**\n * Default behavior is to download, so unless the option is explicitly false, we download here.\n */\nfunction shouldDownload(url: string, newAsset: NewAsset) {\n  return url && newAsset.options.isDownload !== false;\n}\n","export type WebGLVersion = 'webgpu' | 'webgl2' | 'webgl1' | 'none';\n\ninterface IWebGLRenderingContext {\n  getExtension(str: 'WEBGL_lose_context'): WEBGL_lose_context | null;\n}\ninterface BrowserWebGlInfo {\n  /** The unmasked name of the GPU, or an explanation of why we can't get it. */\n  gpu: string;\n  /**\n   * The max webgl/webgpu version that is supported by the current browser\n   * or 'none' if webgql is not supported.\n   */\n  webgl: WebGLVersion;\n}\n\nfunction checkContext(\n  canvas: HTMLCanvasElement,\n  contextName: 'webgpu' | 'webgl2' | 'webgl',\n): boolean {\n  const context = canvas.getContext(contextName);\n  if (context) {\n    if (contextName === 'webgl2' || contextName === 'webgl') {\n      (context as IWebGLRenderingContext).getExtension('WEBGL_lose_context')?.loseContext();\n    }\n    return true;\n  }\n  return false;\n}\n\nfunction getMaxWebGLSupported(): WebGLVersion {\n  const testCanvas = document.createElement('canvas');\n  try {\n    // Source of production bug due to iOS upgrade:\n    // https://aurorasolar.atlassian.net/browse/APP-20756\n    // if (checkContext(testCanvas, 'webgpu')) {\n    //   return 'webgpu';\n    // }\n    if (checkContext(testCanvas, 'webgl2')) {\n      return 'webgl2';\n    }\n    if (checkContext(testCanvas, 'webgl')) {\n      return 'webgl1';\n    }\n    return 'none';\n  } catch (_) {\n    return 'none';\n  }\n}\n\nfunction getUnmaskedGPUName() {\n  const testCanvas = document.createElement('canvas');\n  try {\n    const context = testCanvas.getContext('webgl');\n    if (context) {\n      const debugInfo = context.getExtension('WEBGL_debug_renderer_info');\n      const renderer = debugInfo\n        ? (context.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) as string)\n        : 'no WEBGL_debug_renderer_info';\n\n      // lose context now so we don't have to wait for GC\n      context.getExtension('WEBGL_lose_context')?.loseContext();\n      return renderer;\n    }\n    return 'failed to get webgl context';\n  } catch (_) {\n    return 'error retrieving gpu name';\n  }\n}\n\nlet browserWebglInfo: BrowserWebGlInfo | null = null;\n\n/**\n * Checks the current browser's webgl/webgpu compatibility and which GPU it's using.\n *\n * The results are memoized because the checks are expensive.\n */\nexport const getBrowserWebglInfo = () => {\n  if (browserWebglInfo === null) {\n    browserWebglInfo = {\n      gpu: getUnmaskedGPUName(),\n      webgl: getMaxWebGLSupported(),\n    };\n  }\n  return browserWebglInfo!;\n};\n","import { Patch } from 'immer';\nimport { Store } from 'redux';\nimport { Subject } from 'rxjs';\n\nimport { ApolloClient, NormalizedCacheObject } from '@apollo/client';\nimport { convertSnakeToCamelCase } from '@aurorasolar/common-cad-data-service';\nimport {\n  CadActionTypes,\n  CadError,\n  CadEvent,\n  CadEventPayload,\n  CadEventPropType,\n  CadEventTypes,\n  CadLogMessage,\n  CADTriggerActionTypes,\n  eventIsModalTrigger,\n  eventIsRightPanelTrigger,\n  ModalTrigger,\n  ModalTriggerData,\n  RightPanelTrigger,\n  RightPanelTriggerData,\n  setCadModalAction,\n  setCadRightPanelAction,\n  setLocalStateAction,\n} from '@aurorasolar/common-data-store';\nimport {\n  AnalyticsEventTypes,\n  IAnalyticsProvider,\n  IAppConfig,\n  ITracking,\n} from '@aurorasolar/common-module-loader';\nimport {\n  AssetOptionsInput,\n  AssetType,\n  AsyncJobParameters,\n} from '@aurorasolar/graphql-client-schema';\n\nimport { downloadDxf } from '../downloads/download-dxf';\nimport { saveAndDownloadScreenshotAsset } from '../downloads/download-png';\nimport { getBrowserWebglInfo } from '../webgl-check';\n\nconst isEventOfType = <T extends CadEventTypes>(\n  event: CadEvent<CadEventTypes>,\n  eventType: T,\n): event is CadEvent<T> => {\n  return event.eventType === eventType;\n};\n\nexport const subscribeToCadEvent = <T extends CadEventTypes>(\n  eventStream: Subject<CadEvent<CadEventTypes>>,\n  eventType: T,\n  subscriber: (payload: CadEventPayload<T>) => void,\n) => {\n  return eventStream.subscribe((event) => {\n    if (isEventOfType(event, eventType)) {\n      subscriber(event.payload);\n    }\n  });\n};\n\nexport const stopEvents = (eventStream?: Subject<CadEvent<CadEventTypes>>) => {\n  eventStream?.complete();\n};\n\ninterface CadImageData {\n  blob: Blob;\n  metadata: { [key: string]: string | number };\n  options: AssetOptionsInput;\n}\n\ninterface CadAnalyticsEvent {\n  actionName: AnalyticsEventTypes;\n  properties: {\n    usedShortcut?: boolean;\n    [key: string]: unknown;\n  };\n}\n\nexport const getCadEventHandler = ({\n  appConfig,\n  client,\n  designId,\n  eventStream,\n  projectId,\n  store,\n  track,\n  trackingModule,\n}: {\n  appConfig: IAppConfig;\n  client: ApolloClient<NormalizedCacheObject>;\n  designId: string;\n  eventStream: Subject<CadEvent<CadEventTypes>>;\n  projectId: string;\n  store: Store;\n  track: IAnalyticsProvider['track'];\n  trackingModule: ITracking;\n}) => {\n  return <T extends CadEventTypes>(eventType: T, eventPayload: CadEventPropType<T>) => {\n    const payload = (eventPayload ?? {}) as CadEvent<T>['payload'];\n    const event = { eventType, payload } as CadEvent<T>;\n    eventStream.next(event);\n\n    // TODO move these to subscriptions\n    if (eventType === CadEventTypes.SetExternalStateData) {\n      store.dispatch(\n        setLocalStateAction({\n          patches: payload as unknown as Patch[],\n        }),\n      );\n      return;\n    }\n    if (eventType === CadEventTypes.TrackAnalyticsAction) {\n      const { actionName, properties } = payload as unknown as CadAnalyticsEvent;\n      const { usedShortcut, ...trackableProperties } = properties;\n      if (usedShortcut !== undefined) {\n        trackableProperties.used_shortcut = usedShortcut;\n      }\n      track(actionName, trackableProperties as PLEASE_DO_NOT_USE_THIS_ANY_FOR_MIGRATION_ONLY);\n      return;\n    }\n    if (\n      eventType === CadEventTypes.CadErrorOccurred ||\n      eventType === CadEventTypes.CadGeometryErrorOccurred\n    ) {\n      const { err, message } = payload as unknown as CadError;\n      console.error(message, err);\n\n      const data = getLogData(\n        appConfig,\n        designId,\n        projectId,\n        trackingModule.DataDog?.rum.getUser(),\n      );\n      data.message = message;\n      data.stack = err.stack;\n      data.logRocketURL = trackingModule.LogRocket.sessionURL;\n\n      if (err.cause != null) {\n        data.geometryData = JSON.stringify(err.cause);\n        trackingModule.DataDog?.logs.logger.info('cad-error', data);\n      } else {\n        trackingModule.DataDog?.logs.logger.error('cad-error', data);\n      }\n\n      return;\n    }\n    if (eventType === CadEventTypes.CadLoggedMessage) {\n      const { message, extraData } = payload as unknown as CadLogMessage;\n      const data = getLogData(\n        appConfig,\n        designId,\n        projectId,\n        trackingModule.DataDog?.rum.getUser(),\n      );\n      data.message = message;\n      if (extraData) {\n        data.extraData = JSON.stringify(extraData);\n      }\n      trackingModule.DataDog?.logs.logger.info('cad-log', data);\n    }\n    if (eventIsModalTrigger(eventType)) {\n      // TypeScript isn't smart enough to figure out\n      // how \"eventType\" overlaps with modal triggers\n      store.dispatch(\n        setCadModalAction(\n          eventType as unknown as ModalTrigger,\n          payload as unknown as ModalTriggerData<ModalTrigger>,\n        ),\n      );\n      return;\n    }\n    if (eventIsRightPanelTrigger(eventType)) {\n      // TypeScript isn't smart enough to figure out\n      // how \"eventType\" overlaps with right panel triggers\n      const rightPanelPayload = payload as {\n        rightPanelData?: RightPanelTriggerData<RightPanelTrigger>;\n      };\n      store.dispatch(\n        setCadRightPanelAction(eventType as RightPanelTrigger, rightPanelPayload.rightPanelData),\n      );\n      return;\n    }\n    if (eventType === CadEventTypes.RelayInternalCadState) {\n      store.dispatch({\n        payload,\n        type: 'RELAY_INTERNAL_CAD_STATE',\n      });\n    }\n    if (eventType === CadEventTypes.SaveScreenshotAsset) {\n      const { options } = payload as unknown as CadImageData;\n      const newOptions = getCamelCaseImageOptions(options);\n      saveAndDownloadScreenshotAsset(\n        client,\n        { assetType: AssetType.CadScreenshot, designId, options: newOptions, projectId },\n        (payload as unknown as CadImageData).blob,\n      );\n    }\n    if (eventType === CadEventTypes.DownloadDxf) {\n      downloadDxf(client, { ...payload, designId } as AsyncJobParameters);\n    }\n    if (eventType === CadEventTypes.BeforeDrawWalkway) {\n      store.dispatch({\n        payload: { actionType: CADTriggerActionTypes.DrawWalkway },\n        type: CadActionTypes.TRIGGER_CAD_ACTION,\n      });\n    }\n  };\n};\n\nconst getCamelCaseImageOptions = (options: AssetOptionsInput) => {\n  const newOptions: AssetOptionsInput = {};\n  Object.entries(options).forEach(([k, v]) => {\n    const newKey = convertSnakeToCamelCase(k);\n    newOptions[newKey] = v;\n  });\n  return newOptions;\n};\n\nfunction getLogData(appConfig: IAppConfig, designId: string, projectId: string, user: unknown) {\n  const data: Record<string, unknown> = {\n    ...getBrowserWebglInfo(),\n    cad_config: {\n      cadVersion: appConfig.cadVersion,\n      designId,\n      projectId,\n    },\n    host: window.location.host,\n    source: 'cad',\n    user,\n    v2_config: {\n      api_host: appConfig.apiHost,\n      app_name: appConfig.buildEnvironment.APP_NAME,\n      environment: appConfig.buildEnvironment.ENVIRONMENT,\n      git_branch: appConfig.buildEnvironment.GIT_BRANCH.trim(),\n      git_hash: appConfig.buildEnvironment.GIT_COMMIT_HASH.trim(),\n      release: appConfig.buildEnvironment.RELEASE_VERSION,\n    },\n  };\n  return data;\n}\n","import { useEffect, useRef } from 'react';\nimport { Subject } from 'rxjs';\n\nimport { ApolloClient, NormalizedCacheObject } from '@apollo/client';\nimport { createCadPreferences } from '@aurorasolar/cad-preferences';\nimport {\n  CadEngineState,\n  cloneInert,\n  createCadState,\n  effect,\n  makeReactive,\n  stopCadStateEffects,\n} from '@aurorasolar/cad-state';\nimport { CadEvent, CadEventTypes } from '@aurorasolar/common-data-store';\nimport {\n  Analytics,\n  AnalyticsEventTypes,\n  ApolloClient as ApolloClientModule,\n  AppConfig,\n  AuroraApiEnvironment,\n  AuthToken,\n  CadEngine,\n  CadEngineOptions,\n  CADLib,\n  FeatureFlags,\n  ICadDataServiceSettings,\n  ICadFeatureGate,\n  ICADGeodataService,\n  IOrgPermissions,\n  Notifications,\n  OrgPermissions,\n  ReduxStore,\n  Tracking,\n  useAppModule,\n} from '@aurorasolar/common-module-loader';\nimport { TOAST_CHANNEL } from '@aurorasolar/common-notifications';\nimport { useUploadFiles } from '@aurorasolar/file-uploader';\nimport { UserFileLabel } from '@aurorasolar/graphql-client-schema';\nimport { IIntlContext, SUPPORTED_LOCALES, useIntl } from '@aurorasolar/intl';\nimport { ParcelBounds } from '@aurorasolar/common-cad-data-service';\n\nimport { useEvictCache } from '@aurorasolar/common-core/src/hooks';\n\nimport { getCadSaveCallback } from '../cad-save-callback';\nimport { cleanupCad } from '../provide-cad/cleanup-cad';\nimport { getCadEventHandler, stopEvents, subscribeToCadEvent } from '../provide-cad/event-handler';\nimport { CadMode } from '../types';\nimport { getBrowserWebglInfo } from '../webgl-check';\nimport { useCadContext, useCadInitializerContext } from './cad-context';\n\nlet unknownProjectIdCount = 0;\nlet unknownDesignIdCount = 0;\n\nexport const WEBGL_ERROR = 'WebGL not supported by device';\n\nconst performUnknownProjectDesignEffect = (\n  providedProjectId: string | undefined,\n  providedDesignId: string | undefined,\n) => {\n  if (!providedProjectId) {\n    unknownProjectIdCount += 1;\n  }\n  if (!providedDesignId) {\n    unknownDesignIdCount += 1;\n  }\n  return () => {\n    if (!providedProjectId) {\n      unknownProjectIdCount -= 1;\n    }\n    if (!providedDesignId) {\n      unknownDesignIdCount -= 1;\n    }\n  };\n};\n\nconst performDOMEventsEffect = (cadContainer: HTMLElement) => {\n  const preventDefault = (e: Event) => {\n    e.preventDefault();\n  };\n  cadContainer.addEventListener('touchmove', preventDefault, {\n    passive: false,\n  });\n  cadContainer.addEventListener('contextmenu', preventDefault);\n  return () => {\n    cadContainer.removeEventListener('touchmove', preventDefault);\n    cadContainer.removeEventListener('contextmenu', preventDefault);\n  };\n};\n\ninterface CadDataServiceProps {\n  client?: ApolloClient<NormalizedCacheObject>;\n  environment: AuroraApiEnvironment;\n  orgPermissions?: IOrgPermissions;\n  parcelBounds?: ParcelBounds;\n  designId?: string;\n  featureGate: ICadFeatureGate;\n  intl: IIntlContext;\n  preferences: ReturnType<typeof createCadPreferences>;\n}\n\ninterface CadAsyncEngineInitProps {\n  engine: CadEngine;\n}\n\nexport interface UseCadProps {\n  isShown?: boolean;\n\n  // TODO: As of now, Homeowner Leave Behind does not\n  // have its own app container, so we cannot provide\n  // a different feature gate / org permissions. Hence,\n  // we have to rely on passing different featureGate\n  // for HLB. Ideally, we would handle this with a\n  // different org permissions module provider.\n  featureGate: ICadFeatureGate | undefined;\n\n  geodataService: ICADGeodataService | undefined;\n  parcelBounds?: ParcelBounds;\n  projectId?: string;\n  designId?: string;\n  userId?: string;\n  designRequestId?: string;\n  createDataProvider?: (props: CadDataServiceProps) => ICadDataServiceSettings;\n  engineOptions: Omit<\n    CadEngineOptions,\n    'dataProvider' | 'environment' | 'stateFramework' | 'eventEmitter' | 'stateMode'\n  > & { stateMode: CadMode };\n  asyncEngineInit?: (props: CadAsyncEngineInitProps) => void;\n  enableSave?: boolean;\n}\n\nexport const useCad = ({\n  isShown = true,\n  geodataService,\n  parcelBounds,\n  projectId: providedProjectId,\n  designId: providedDesignId,\n  userId,\n  designRequestId,\n  createDataProvider,\n  engineOptions,\n  featureGate,\n  asyncEngineInit,\n  enableSave = false,\n}: UseCadProps) => {\n  const config = useAppModule(AppConfig);\n  const authToken = useAppModule(AuthToken);\n  const cadLib = useAppModule(CADLib);\n  const reduxStore = useAppModule(ReduxStore);\n  const notifications = useAppModule(Notifications);\n  const trackingModule = useAppModule(Tracking);\n  const analytics = useAppModule(Analytics);\n  const orgPermissions = useAppModule(OrgPermissions);\n\n  const fileUploader = useUploadFiles({\n    label: UserFileLabel.Screenshot,\n    parentId: providedDesignId,\n    parentRoleType: 'save_auto_screenshot',\n    parentType: 'Design',\n  });\n  const featureFlags = useAppModule(FeatureFlags);\n  const cadContextValue = useCadContext();\n  const cadInitializerContextValue = useCadInitializerContext();\n  const { evictCache, evictCacheById } = useEvictCache();\n\n  // This ref is to ensure CAD is only initialized once per mount\n  const effectInfo = useRef({\n    effectCleanup: () => {},\n    isInitialized: false,\n  });\n\n  // Note: we'd like `useCad` to be mostly independent of apolloClient, so do not\n  // add extra dependencies on apolloClient within `useCad` other than for screenshots\n  // and DXF download handling.\n  const apolloClient = useAppModule(ApolloClientModule);\n\n  const intl = useIntl();\n\n  useEffect(() => {\n    const cadContainer = engineOptions.viewData[0].domElement;\n    if (\n      effectInfo.current.isInitialized ||\n      !isShown ||\n      !cadLib ||\n      !reduxStore ||\n      !notifications ||\n      !apolloClient ||\n      !config ||\n      !authToken ||\n      !trackingModule ||\n      !analytics ||\n      !geodataService ||\n      !featureGate ||\n      !createDataProvider ||\n      !featureFlags ||\n      !cadContainer\n    ) {\n      return;\n    }\n    effectInfo.current.isInitialized = true;\n\n    const preferences = createCadPreferences({\n      getDesignId: () => providedDesignId ?? null,\n      getProjectId: () => providedProjectId ?? null,\n      getUserId: () => userId ?? null,\n    });\n\n    if (getBrowserWebglInfo().webgl === 'none') {\n      cadInitializerContextValue.setCadError(new Error(WEBGL_ERROR));\n      return;\n    }\n\n    const events$ = new Subject<CadEvent<CadEventTypes>>();\n    const subscription = subscribeToCadEvent(\n      events$,\n      CadEventTypes.Notify,\n      ({ dismissType, message, messageType, title, variables }) => {\n        const channel = notifications.getChannel(TOAST_CHANNEL);\n        channel.push({ dismissType, message, messageType, title, variables }, Symbol(message));\n      },\n    );\n\n    const projectId = providedProjectId ?? `unknown-project-id-${unknownProjectIdCount}`;\n    const designId = providedDesignId ?? `unknown-design-id-${unknownDesignIdCount}`;\n    const cleanupDOMEventsEffect = performDOMEventsEffect(cadContainer);\n\n    const cleanupUnknownProjectDesignEffect = performUnknownProjectDesignEffect(\n      providedProjectId,\n      providedDesignId,\n    );\n\n    // todo add featuregate\n    const dataProvider = createDataProvider({\n      client: apolloClient,\n      designId,\n      environment: config.apiEnvironment,\n      featureGate,\n      intl,\n      orgPermissions,\n      parcelBounds,\n      preferences,\n    });\n\n    const eventEmitter = {\n      trigger: getCadEventHandler({\n        appConfig: config,\n        client: apolloClient,\n        designId,\n        eventStream: events$,\n        projectId,\n        store: reduxStore,\n        track: analytics.track,\n        trackingModule,\n      }),\n    };\n\n    const engine = cadLib.Factory.getEngineInstance(\n      designId,\n      {\n        ...engineOptions,\n        dataProvider,\n        environment: config.apiEnvironment,\n        eventEmitter,\n        stateFramework: {\n          cloneInert,\n          effect,\n          makeReactive,\n        },\n        useToastMessage: false,\n      },\n      true,\n    );\n\n    if (engine instanceof Error) {\n      cadInitializerContextValue.setCadError(engine);\n      return;\n    }\n\n    const locale: SUPPORTED_LOCALES = document.documentElement.lang as SUPPORTED_LOCALES;\n    const asyncInitEngineInstance = cadLib.Factory.initEngineInstance(engine, {\n      dataProvider,\n      eventEmitter,\n      geodataService,\n      irradianceMapService: new cadLib.Services.IrradianceMapService(),\n      locale,\n      saveHandler: {\n        save: enableSave\n          ? getCadSaveCallback({\n              apolloClient,\n              cadContext: cadContextValue,\n              cadEvents$: events$,\n              engine,\n              evictCache,\n              evictCacheById,\n              fileUploader,\n              reduxStore,\n            })\n          : () => Promise.reject(new Error('Saving is not enabled')),\n      },\n      store: dataProvider,\n    });\n\n    let isCadLoadCancelled = false;\n    asyncInitEngineInstance\n      .then(() => {\n        if (isCadLoadCancelled) {\n          return false;\n        }\n\n        const cadState = createCadState(engine.state as CadEngineState);\n\n        cadInitializerContextValue.setCadContext({\n          designId,\n          domNode: cadContainer,\n          engine,\n          engineSaveFn: enableSave\n            ? (options) => {\n                const engineScoped = cadLib?.Factory.getActiveEngineInstance(designId);\n                if (!engineScoped) {\n                  return Promise.reject();\n                }\n                analytics.track(AnalyticsEventTypes.DesignClickedSave);\n                return engineScoped.bridge.save(options);\n              }\n            : null,\n          eventStream: events$,\n          preferences,\n          state: cadState,\n        });\n\n        // TODO fix cad so this doesnt need to wait\n        geodataService.initialize(engine.bridge, {\n          designRequestId,\n          projectId,\n        });\n\n        window.cadReady = true;\n        if (CYPRESS_BUILD) {\n          window.cadReduxStore = reduxStore;\n          window.cadScreenshot$ = new Subject<Blob>();\n          window.cadActivity = { track() {} };\n          window.cadInstance = { cadState, engine };\n          // eslint-disable-next-line\n          import('sinon').then((sinon) => sinon.spy(reduxStore, 'dispatch')).catch(() => {});\n        }\n\n        asyncEngineInit?.({ engine });\n        return true;\n      })\n      .catch((e) => {\n        cadInitializerContextValue.setCadError(e);\n        return false;\n      });\n\n    effectInfo.current.effectCleanup = () => {\n      subscription.unsubscribe();\n      cleanupDOMEventsEffect();\n      cleanupUnknownProjectDesignEffect();\n      cleanupCad({ CadLib: cadLib, store: reduxStore });\n      stopEvents(events$);\n\n      if (cadContextValue.state) {\n        stopCadStateEffects(cadContextValue.state);\n      }\n      isCadLoadCancelled = true;\n      cadInitializerContextValue.clearCadContext();\n    };\n  }, [\n    effectInfo,\n    cadLib,\n    reduxStore,\n    notifications,\n    apolloClient,\n    config,\n    authToken,\n    fileUploader,\n    trackingModule,\n    analytics,\n    providedProjectId,\n    providedDesignId,\n    designRequestId,\n    createDataProvider,\n    engineOptions,\n    geodataService,\n    featureGate,\n    isShown,\n    cadContextValue,\n    cadInitializerContextValue,\n    orgPermissions,\n    asyncEngineInit,\n    featureFlags,\n    intl,\n    userId,\n    evictCache,\n    evictCacheById,\n    parcelBounds,\n    enableSave,\n  ]);\n\n  useEffect(() => {\n    return () => {\n      // Both the initialization and cleanup should only run once\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n      effectInfo.current.effectCleanup();\n    };\n  }, []);\n};\n","import { useCallback } from 'react';\n\nimport { ApolloClient, useAppModule } from '@aurorasolar/common-module-loader';\nimport { Query } from '@aurorasolar/graphql-client-schema';\n\nimport type { Reference, StoreObject } from '@apollo/client';\n\nexport const useEvictCache = () => {\n  const client = useAppModule(ApolloClient);\n\n  const evictCache = useCallback(\n    <K extends string = keyof Query>(fieldName: K) => {\n      client?.cache.evict({ fieldName });\n      client?.cache.gc();\n    },\n    [client],\n  );\n\n  const evictCacheById = useCallback(\n    (storeObject: StoreObject | Reference) => {\n      client?.cache.evict({ id: client.cache.identify(storeObject) });\n      client?.cache.gc();\n    },\n    [client],\n  );\n\n  return { evictCache, evictCacheById };\n};\n","import { Store } from 'redux';\n\nimport { clearLocalStateAction } from '@aurorasolar/common-data-store';\nimport { ICADJSModule, ICADProvider } from '@aurorasolar/common-module-loader';\n\ninterface CadCleanupDependencies {\n  CadLib: ICADJSModule | undefined;\n  store: Store;\n}\nexport const cleanupCad = async ({\n  CadLib,\n  store,\n}: CadCleanupDependencies): Promise<ICADProvider> => {\n  CadLib!.Factory.cleanupEngineInstance();\n\n  store.dispatch(clearLocalStateAction());\n  window.cadReady = false;\n  window.cadInstance = { cadState: null, engine: null };\n\n  return {} as ICADProvider;\n};\n","// @ts-ignore: Ignore unused { * as Types } import\nimport * as Types from '@aurorasolar/graphql-client-schema';\n\nimport { gql } from '@apollo/client';\nimport * as Apollo from '@apollo/client';\nconst defaultOptions = {} as const;\nexport type LeadCaptureCadQueryVariables = Types.Exact<{\n  id: Types.Scalars['ID'];\n}>;\n\n\nexport type LeadCaptureCadQuery = { __typename: 'Query', leadCadData: { __typename: 'LeadCaptureProject', id: string, location?: { __typename: 'LeadCaptureLocation', latitude: number, longitude: number } | null | undefined, image?: { __typename: 'LeadCaptureImage', id: string, orthoImage: { __typename: 'OrthoImage', id: string, source: Types.OrthoImageSource, url?: string | null | undefined, name: string, active: boolean, opacity?: number | null | undefined, width?: number | null | undefined, height?: number | null | undefined, worldfileA?: number | null | undefined, worldfileB?: number | null | undefined, worldfileC?: number | null | undefined, worldfileD?: number | null | undefined, worldfileE?: number | null | undefined, worldfileF?: number | null | undefined, resource?: { __typename: 'GeodataResource', id?: string | null | undefined, source: string, url?: string | null | undefined, type: Types.GeodataResourceType, worldfile?: { __typename: 'Worldfile', a?: number | null | undefined, b?: number | null | undefined, c?: number | null | undefined, e?: number | null | undefined, d?: number | null | undefined, f?: number | null | undefined } | null | undefined, dimensions?: { __typename: 'GeodataDimensions', width?: number | null | undefined, height?: number | null | undefined } | null | undefined, metadata?: { __typename: 'GeodataMeta', opacity?: number | null | undefined, name?: string | null | undefined } | null | undefined } | null | undefined } } | null | undefined, site?: { __typename: 'LeadCaptureSite', id: string, data?: { __typename: 'LeadCaptureCadSite', baseElevation: number, centerLat: number, centerLng: number, roofPlanes: Array<{ __typename: 'LeadCaptureCadRoofPlane', height: number, pitch: number, azimuthEdgeIndex: number, shell: Array<{ __typename: 'LeadCaptureCadRoofPlaneNode', x: number, y: number, edgeType: string }>, holes: Array<Array<{ __typename: 'LeadCaptureCadRoofPlaneNode', x: number, y: number, edgeType: string }> | null | undefined> }>, obstructions: Array<{ __typename: 'LeadCaptureCadObstruction', shape: string, center: Array<number>, azimuthVector: Array<number>, radius?: number | null | undefined, width?: number | null | undefined, length?: number | null | undefined, flush: boolean, heightAbove?: number | null | undefined, confidence: number }> } | null | undefined } | null | undefined, scenarios: Array<{ __typename: 'LeadCaptureScenario', design?: { __typename: 'LeadCaptureDesign', id: string, data?: any | null | undefined } | null | undefined }>, components?: { __typename: 'LeadCaptureComponents', panels: Array<{ __typename: 'SolarPanel', id: string, efficiency?: number | null | undefined, height?: number | null | undefined, imp?: number | null | undefined, isc?: number | null | undefined, length?: number | null | undefined, name?: string | null | undefined, noct?: number | null | undefined, panelType?: string | null | undefined, price?: number | null | undefined, ratingPtc?: number | null | undefined, ratingStc?: number | null | undefined, tempCoeffIsc?: number | null | undefined, tempCoeffPmax?: number | null | undefined, tempCoeffVoc?: number | null | undefined, vmp?: number | null | undefined, voc?: number | null | undefined, width?: number | null | undefined, manufacturer?: { __typename: 'Manufacturer', id: string, displayName?: string | null | undefined, name?: string | null | undefined } | null | undefined, mlpe?: { __typename: 'MLPE', id: string, type?: string | null | undefined, isSolarInverter?: boolean | null | undefined, isDcOptimizer?: boolean | null | undefined, isCellStringOptimizer?: boolean | null | undefined, solarInverter?: { __typename: 'SolarInverter', id: string, efficiencyCec?: number | null | undefined, efficiencyEuropean?: number | null | undefined, efficiencyMax?: number | null | undefined, hasGlobalMppt?: boolean | null | undefined, inputVoltageMax?: number | null | undefined, inputVoltageMin?: number | null | undefined, inputVoltageSE?: number | null | undefined, isSolarEdge?: boolean | null | undefined, mpptRatedPowerVoltageMax?: number | null | undefined, mpptRatedPowerVoltageMin?: number | null | undefined, mppts?: number | null | undefined, name?: string | null | undefined, numPhases?: number | null | undefined, numPhysicalDcInputs?: number | null | undefined, outputCurrent?: number | null | undefined, outputVoltageNominal?: number | null | undefined, price?: number | null | undefined, ratedPower?: number | null | undefined, usableInputCurrentMax?: number | null | undefined, usableInputPowerMax?: number | null | undefined, manufacturer?: { __typename: 'Manufacturer', id: string, displayName?: string | null | undefined, name?: string | null | undefined } | null | undefined } | null | undefined, dcOptimizer?: { __typename: 'DcOptimizer', id: string, efficiency?: number | null | undefined, efficiencyMax?: number | null | undefined, hasGlobalMppt?: boolean | null | undefined, inputShortCircuitCurrentMax?: number | null | undefined, inputVoltageMax?: number | null | undefined, isLongString?: boolean | null | undefined, isSolarEdge?: boolean | null | undefined, mpptOperatingVoltageMax?: number | null | undefined, mpptOperatingVoltageMin?: number | null | undefined, name?: string | null | undefined, numInputs?: number | null | undefined, operatingModel?: string | null | undefined, optimizationBehavior?: string | null | undefined, outputCurrentMax?: number | null | undefined, outputVoltageMax?: number | null | undefined, price?: number | null | undefined, stcInputPowerMax?: number | null | undefined, systemVoltageMax?: number | null | undefined, usesSelectiveOptimization?: boolean | null | undefined, manufacturer?: { __typename: 'Manufacturer', id: string, displayName?: string | null | undefined, name?: string | null | undefined } | null | undefined } | null | undefined, cellStringOptimizer?: { __typename: 'CellStringOptimizer', id: string, name?: string | null | undefined, voltageLimit?: boolean | null | undefined, maxOutputVoltage?: number | null | undefined, manufacturer?: { __typename: 'Manufacturer', id: string, displayName?: string | null | undefined, name?: string | null | undefined } | null | undefined } | null | undefined } | null | undefined }>, inverters: Array<{ __typename: 'SolarInverter', id: string, efficiencyCec?: number | null | undefined, efficiencyEuropean?: number | null | undefined, efficiencyMax?: number | null | undefined, hasGlobalMppt?: boolean | null | undefined, inputVoltageMax?: number | null | undefined, inputVoltageMin?: number | null | undefined, inputVoltageSE?: number | null | undefined, isSolarEdge?: boolean | null | undefined, mpptRatedPowerVoltageMin?: number | null | undefined, mppts?: number | null | undefined, name?: string | null | undefined, numPhases?: number | null | undefined, numPhysicalDcInputs?: number | null | undefined, outputCurrent?: number | null | undefined, outputVoltageNominal?: number | null | undefined, price?: number | null | undefined, ratedPower?: number | null | undefined, usableInputCurrentMax?: number | null | undefined, usableInputPowerMax?: number | null | undefined, manufacturer?: { __typename: 'Manufacturer', id: string, displayName?: string | null | undefined, name?: string | null | undefined } | null | undefined }> } | null | undefined } };\n\n\nexport const LeadCaptureCadDocument = gql`\n    query LeadCaptureCad($id: ID!) @trace_info(traceInfo: {pod: leads}) {\n  leadCadData: getLeadCaptureProjectData(id: $id) {\n    id\n    location {\n      latitude\n      longitude\n    }\n    image {\n      id\n      orthoImage {\n        id\n        source\n        url\n        name\n        active\n        opacity\n        width\n        height\n        worldfileA\n        worldfileB\n        worldfileC\n        worldfileD\n        worldfileE\n        worldfileF\n        resource {\n          id\n          source\n          url\n          type\n          worldfile {\n            a\n            b\n            c\n            e\n            d\n            f\n          }\n          dimensions {\n            width\n            height\n          }\n          metadata {\n            opacity\n            name\n          }\n        }\n      }\n    }\n    site {\n      id\n      data {\n        roofPlanes {\n          shell {\n            x\n            y\n            edgeType\n          }\n          holes {\n            x\n            y\n            edgeType\n          }\n          height\n          pitch\n          azimuthEdgeIndex\n        }\n        obstructions {\n          shape\n          center\n          azimuthVector\n          radius\n          width\n          length\n          flush\n          heightAbove\n          confidence\n        }\n        baseElevation\n        centerLat\n        centerLng\n      }\n    }\n    scenarios {\n      design {\n        id\n        data\n      }\n    }\n    components {\n      panels {\n        id\n        efficiency\n        height\n        imp\n        isc\n        length\n        name\n        noct\n        panelType\n        price\n        ratingPtc\n        ratingStc\n        tempCoeffIsc\n        tempCoeffPmax\n        tempCoeffVoc\n        vmp\n        voc\n        width\n        manufacturer {\n          id\n          displayName\n          name\n        }\n        mlpe {\n          id\n          type\n          isSolarInverter\n          isDcOptimizer\n          isCellStringOptimizer\n          solarInverter {\n            id\n            efficiencyCec\n            efficiencyEuropean\n            efficiencyMax\n            hasGlobalMppt\n            inputVoltageMax\n            inputVoltageMin\n            inputVoltageSE\n            isSolarEdge\n            mpptRatedPowerVoltageMax\n            mpptRatedPowerVoltageMin\n            mppts\n            name\n            numPhases\n            numPhysicalDcInputs\n            outputCurrent\n            outputVoltageNominal\n            price\n            ratedPower\n            usableInputCurrentMax\n            usableInputPowerMax\n            manufacturer {\n              id\n              displayName\n              name\n            }\n          }\n          dcOptimizer {\n            id\n            efficiency\n            efficiencyMax\n            hasGlobalMppt\n            inputShortCircuitCurrentMax\n            inputVoltageMax\n            isLongString\n            isSolarEdge\n            mpptOperatingVoltageMax\n            mpptOperatingVoltageMin\n            name\n            numInputs\n            operatingModel\n            optimizationBehavior\n            outputCurrentMax\n            outputVoltageMax\n            price\n            stcInputPowerMax\n            systemVoltageMax\n            usesSelectiveOptimization\n            manufacturer {\n              id\n              displayName\n              name\n            }\n          }\n          cellStringOptimizer {\n            id\n            name\n            voltageLimit\n            maxOutputVoltage\n            manufacturer {\n              id\n              displayName\n              name\n            }\n          }\n        }\n      }\n      inverters {\n        id\n        efficiencyCec\n        efficiencyEuropean\n        efficiencyMax\n        hasGlobalMppt\n        inputVoltageMax\n        inputVoltageMin\n        inputVoltageSE\n        isSolarEdge\n        mpptRatedPowerVoltageMin\n        mppts\n        name\n        numPhases\n        numPhysicalDcInputs\n        outputCurrent\n        outputVoltageNominal\n        price\n        ratedPower\n        usableInputCurrentMax\n        usableInputPowerMax\n        manufacturer {\n          id\n          displayName\n          name\n        }\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useLeadCaptureCadQuery__\n *\n * To run a query within a React component, call `useLeadCaptureCadQuery` and pass it any options that fit your needs.\n * When your component renders, `useLeadCaptureCadQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useLeadCaptureCadQuery({\n *   variables: {\n *      id: // value for 'id'\n *   },\n * });\n */\nexport function useLeadCaptureCadQuery(baseOptions: Apollo.QueryHookOptions<LeadCaptureCadQuery, LeadCaptureCadQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions}\n        return Apollo.useQuery<LeadCaptureCadQuery, LeadCaptureCadQueryVariables>(LeadCaptureCadDocument, options);\n      }\nexport function useLeadCaptureCadLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<LeadCaptureCadQuery, LeadCaptureCadQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions}\n          return Apollo.useLazyQuery<LeadCaptureCadQuery, LeadCaptureCadQueryVariables>(LeadCaptureCadDocument, options);\n        }\nexport type LeadCaptureCadQueryHookResult = ReturnType<typeof useLeadCaptureCadQuery>;\nexport type LeadCaptureCadLazyQueryHookResult = ReturnType<typeof useLeadCaptureCadLazyQuery>;\nexport type LeadCaptureCadQueryResult = Apollo.QueryResult<LeadCaptureCadQuery, LeadCaptureCadQueryVariables>;","import isChromatic from 'chromatic';\nimport { useMemo } from 'react';\n\nimport { ApolloClient as ApolloClientType, NormalizedCacheObject } from '@apollo/client';\nimport { buildUnitsAdapter, peekRecord } from '@aurorasolar/common-cad-data-service';\nimport { CADTriggerActionTypes } from '@aurorasolar/common-data-store';\nimport {\n  ApolloClient,\n  AuroraApiEnvironment,\n  CadEngine,\n  CompassPosition,\n  ICadDataServiceSettings,\n  ICadFeatureGate,\n  useAppModule,\n} from '@aurorasolar/common-module-loader';\nimport { IrradianceStates, TemperatureUnit, UnitSystem } from '@aurorasolar/graphql-client-schema';\nimport { IIntlContext, useIntl } from '@aurorasolar/intl';\n\nimport { CadMode } from '../types';\nimport { getLeadCaptureGeodataService } from './lead-capture-geodata-service';\nimport { useCad, UseCadProps } from './use-cad';\nimport { LeadCaptureCadQuery, useLeadCaptureCadQuery } from './use-lead-capture-cad.generated';\n\ninterface CreateLeadCaptureCadDataProviderProps {\n  client: ApolloClientType<NormalizedCacheObject>;\n  id: string;\n  intl: IIntlContext;\n  lat: number;\n  lng: number;\n}\n\nconst createLeadCaptureCadDataProvider = ({\n  client,\n  id,\n  intl,\n  lat,\n  lng,\n}: CreateLeadCaptureCadDataProviderProps) => {\n  return ({\n    environment,\n    featureGate,\n  }: {\n    featureGate: ICadFeatureGate;\n    environment: AuroraApiEnvironment;\n  }): ICadDataServiceSettings => ({\n    design: {\n      latitude: lat,\n      longitude: lng,\n    },\n    designId: id,\n    distanceUnit: UnitSystem.Metric,\n    environment,\n    featureGate,\n    getIrradiance: async () => null,\n    getTemplateJsonById: async () => null,\n    get irradianceState() {\n      return {\n        id,\n        panels: {\n          id: null,\n          status: IrradianceStates.Invalid,\n        },\n        roof: {\n          id: null,\n          status: IrradianceStates.Invalid,\n        },\n      };\n    },\n    lidarAccessible: false,\n    moduleSpacingSettings: {\n      rowSpacing: 0,\n      x: 0,\n      y: 0,\n    },\n    peekRecord(type: string, compId: string) {\n      return peekRecord(client, type, compId);\n    },\n    pricePerWatt: 0,\n    projectId: '',\n    projectType: '',\n    recentSavedVersion: '',\n    selectedImageryTypes: {\n      basic: true,\n    },\n    timeZoneOffset: Math.round(lng / 15),\n    units: buildUnitsAdapter(UnitSystem.Metric, TemperatureUnit.C, intl),\n  });\n};\n\nconst getLeadCaptureFeatureGate = () => ({\n  ambientOcclusion: false,\n  autoDesigner: false,\n  autoRoof: false,\n  balanceOfSystem: false,\n  compassToLowerRight: true,\n  csvMonthly: false,\n  datamodelLibrary: false,\n  editSiteModel: false,\n  fillZone: false,\n  fitTreesToLidar: false,\n  focusOnSelection: false,\n  lidar: false,\n  saveDesignJsonSchemaVersion2: false,\n  walkway: false,\n});\n\nconst getLeadCaptureViewSettings = () => ({\n  'design-3d': {\n    azimuthArrows: false,\n    edges: false,\n    ground: true,\n    irradianceMap: false,\n    irradianceMapPanels: false,\n    lidar: false,\n    mapImagery: true,\n    mapView: false,\n    measurements: false,\n    projectCenter: false,\n    setbacks: false,\n    shadows: true,\n    sky: true,\n    streetView: false,\n    sunpath: false,\n  },\n});\n\ninterface GetLeadCaptureAsyncEngineInitProps {\n  data: LeadCaptureCadQuery;\n  hasOrbitMode: boolean;\n}\n\nconst getLeadCaptureAsyncEngineInit = ({\n  data,\n  hasOrbitMode,\n}: GetLeadCaptureAsyncEngineInitProps) => {\n  return ({ engine }: { engine: CadEngine }): void => {\n    engine.bridge.triggerAction(CADTriggerActionTypes.DrawReconstructedRoofPlanes, {\n      ...data.leadCadData.site!.data,\n    });\n\n    engine.bridge.triggerAction(CADTriggerActionTypes.LoadSystemDesign, {\n      design: data.leadCadData.scenarios[0].design!.data,\n    });\n\n    if (!CYPRESS_BUILD && !isChromatic() && hasOrbitMode) {\n      engine.bridge.triggerAction(CADTriggerActionTypes.ZoomAndOrbit, {});\n    }\n  };\n};\n\ninterface UseLeadCaptureCadProps {\n  cadContainer: HTMLElement | null;\n  id: string;\n  hasOrbitMode?: boolean;\n  showCompass?: boolean;\n}\n\nexport const useLeadCaptureCad = ({\n  cadContainer,\n  id,\n  hasOrbitMode = false,\n  showCompass = false,\n}: UseLeadCaptureCadProps) => {\n  const client = useAppModule(ApolloClient);\n\n  const { data, loading } = useLeadCaptureCadQuery({\n    variables: { id },\n  });\n\n  const geodataService = useMemo(\n    () => (!data || loading ? undefined : getLeadCaptureGeodataService(data)),\n    [loading, data],\n  );\n\n  const intl = useIntl();\n\n  const lat = data?.leadCadData.location?.latitude || 0;\n  const lng = data?.leadCadData.location?.longitude || 0;\n\n  const createDataProvider = useMemo(() => {\n    if (loading || !client) {\n      return undefined;\n    }\n\n    return createLeadCaptureCadDataProvider({\n      client,\n      id,\n      intl,\n      lat,\n      lng,\n    });\n  }, [client, id, intl, lat, lng, loading]);\n\n  const asyncEngineInit = useMemo(() => {\n    if (loading || !data) {\n      return undefined;\n    }\n\n    return getLeadCaptureAsyncEngineInit({\n      data,\n      hasOrbitMode,\n    });\n  }, [data, loading, hasOrbitMode]);\n\n  const propsForUseCad = useMemo<UseCadProps>(\n    () => ({\n      asyncEngineInit,\n      createDataProvider,\n      designId: id,\n      engineOptions: {\n        designJson: {\n          site: {},\n          system: {} as JSON,\n        },\n        designJsonSchemaVersion: 1,\n        lat,\n        lng,\n        renderMode: 'main',\n        saveFormat: '1.0',\n        stateMode: CadMode.ReadOnly,\n        useCompassPosition: showCompass\n          ? CompassPosition.LowerRightCorner\n          : CompassPosition.Invisible,\n        useMapView: false,\n        useSimplePointerControls: true,\n        useSimpleTouchControls: false,\n        useStreetView: false,\n        useToastMessage: false,\n        viewData: [\n          {\n            domElement: cadContainer as HTMLElement,\n            name: 'design-3d',\n          },\n        ],\n        viewSettings: getLeadCaptureViewSettings(),\n      },\n      featureGate: getLeadCaptureFeatureGate(),\n      geodataService,\n      isShown: !!(id && createDataProvider),\n    }),\n    [asyncEngineInit, createDataProvider, id, lat, lng, cadContainer, geodataService, showCompass],\n  );\n\n  return useCad(propsForUseCad);\n};\n","/* eslint-disable sort-keys */\nimport {\n  isComputedProp,\n  isObservableArray,\n  isObservableMap,\n  isObservableObject,\n  isObservableSet,\n  observable,\n  toJS,\n} from 'mobx';\n\nlet reactiveRootId = 0;\n\nconst createDefaultReactiveName = () => {\n  const currentRootId = reactiveRootId;\n  reactiveRootId += 1;\n  return `reactive_root_${currentRootId}`;\n};\n\n/**\n * Types to improve readability of other types\n */\ntype Reactive = object;\ntype MobXObject = object;\ntype Inert = object;\n\nconst reactiveNameLookup = new WeakMap<Reactive, string>();\nconst isReactive = new WeakSet<Reactive>();\nconst reactiveLookup = new WeakMap<MobXObject, Reactive>();\nconst inertSetLookup = new WeakMap<Reactive, WeakSet<Inert>>();\nconst reactiveArrayOverridesLookup = new WeakMap<\n  Reactive,\n  ReturnType<typeof createReactiveArrayOverrides>\n>();\nconst reactiveSetOverridesLookup = new WeakMap<\n  Reactive,\n  ReturnType<typeof createReactiveSetOverrides>\n>();\nconst reactiveMapOverridesLookup = new WeakMap<\n  Reactive,\n  ReturnType<typeof createReactiveMapOverrides>\n>();\n\n/**\n * Convenience function to check if value is an object\n */\nexport const isObject = <T>(value: T): value is T & object => {\n  return value && typeof value === 'object';\n};\n\n/**\n * When changing a reactive object in any way, its values no longer\n * matches its original inert object. Hence, if that original\n * object is reassigned back to the same parent's property, we should\n * no longer prevent such reassignment\n */\nconst decoupleReactiveFromOriginal = (object: Reactive | MobXObject | undefined) => {\n  if (object) {\n    const reactive = reactiveLookup.get(object) ?? object;\n    inertSetLookup.delete(reactive);\n  }\n};\n\n/**\n * Wraps a method that causes a change in array, set or map to ensure\n * it is decoupled from its original inert object\n */\nconst wrapDecoupled = <Args extends Array<unknown>, Result>(\n  object: MobXObject,\n  method: (...args: Args) => Result,\n): ((...args: Args) => Result) => {\n  return (...args) => {\n    decoupleReactiveFromOriginal(object);\n    return method.apply(object, args);\n  };\n};\n\n/**\n * Returns whether reactive object corresponds to its\n * coupled original inert object\n */\nconst isReactiveObjectEqual = (reactiveOrMobX: Reactive | MobXObject, object: Inert): boolean => {\n  if (reactiveOrMobX === object) {\n    return true;\n  }\n  const reactive = reactiveLookup.get(reactiveOrMobX) ?? reactiveOrMobX;\n  const inertSet = inertSetLookup.get(reactive);\n  return !!inertSet && inertSet.has(object);\n};\n\n/**\n * Creates overrides for array methods so that newly added items are deeply reactive\n */\nconst createReactiveArrayOverrides = <T>(\n  mobxArray: T[],\n  initialIndex: number,\n): Pick<\n  Array<T>,\n  | 'push'\n  | 'splice'\n  | 'unshift'\n  | 'fill'\n  | 'indexOf'\n  | 'lastIndexOf'\n  | 'pop'\n  | 'reverse'\n  | 'shift'\n  | 'sort'\n> => {\n  let index = initialIndex;\n  return {\n    pop: wrapDecoupled(mobxArray, mobxArray.pop),\n    reverse: wrapDecoupled(mobxArray, mobxArray.reverse),\n    shift: wrapDecoupled(mobxArray, mobxArray.shift),\n    sort: wrapDecoupled(mobxArray, mobxArray.sort),\n    indexOf(searchElement: T, fromIndex?: number): number {\n      const foundIndex = mobxArray.indexOf(searchElement, fromIndex);\n      if (foundIndex >= 0 || !isObject(searchElement)) {\n        return foundIndex;\n      }\n      const foundItem = mobxArray.find((item) => {\n        return isObject(item) && isReactiveObjectEqual(item, searchElement);\n      });\n      return foundItem == null ? -1 : mobxArray.indexOf(foundItem);\n    },\n    lastIndexOf(searchElement: T, fromIndex?: number): number {\n      const foundIndex = mobxArray.lastIndexOf(searchElement, fromIndex);\n      if (foundIndex >= 0 || !isObject(searchElement)) {\n        return foundIndex;\n      }\n      const foundItem = mobxArray.find((item) => {\n        return isObject(item) && isReactiveObjectEqual(item, searchElement);\n      });\n      return foundItem == null ? -1 : mobxArray.lastIndexOf(foundItem);\n    },\n    push(...items: T[]): number {\n      const reactive = reactiveLookup.get(mobxArray) as T[];\n      const reactiveName = reactiveNameLookup.get(reactive)!;\n      const newItems = items.map((item) => {\n        const reactiveItem = makeDeepReactive(item, new Map(), `${reactiveName}[${index}]`);\n        index += 1;\n        return reactiveItem;\n      });\n      decoupleReactiveFromOriginal(reactive);\n      return mobxArray.push(...newItems);\n    },\n    splice(start: number, deleteCount: number, ...rest: T[]): T[] {\n      const reactive = reactiveLookup.get(mobxArray) as T[];\n      const reactiveName = reactiveNameLookup.get(reactive)!;\n      const newRestItems = rest.map((item) => {\n        const reactiveItem = makeDeepReactive(item, new Map(), `${reactiveName}[${index}]`);\n        index += 1;\n        return reactiveItem;\n      });\n      decoupleReactiveFromOriginal(reactive);\n      return mobxArray.splice(start, deleteCount, ...newRestItems);\n    },\n    unshift(...items: T[]): number {\n      const reactive = reactiveLookup.get(mobxArray) as T[];\n      const reactiveName = reactiveNameLookup.get(reactive)!;\n      const newItems = items.map((item) => {\n        const reactiveItem = makeDeepReactive(item, new Map(), `${reactiveName}[${index}]`);\n        index += 1;\n        return reactiveItem;\n      });\n      decoupleReactiveFromOriginal(reactive);\n      return mobxArray.unshift(...newItems);\n    },\n    fill(value: T, start?: number | undefined, end?: number | undefined) {\n      const reactive = reactiveLookup.get(mobxArray) as T[];\n      const reactiveName = reactiveNameLookup.get(reactive)!;\n      const newValue = makeDeepReactive(value, new Map(), `${reactiveName}[${index}]`);\n      index += 1;\n      mobxArray.fill(newValue, start, end);\n      decoupleReactiveFromOriginal(reactive);\n      return reactive;\n    },\n  };\n};\n\n/**\n * Creates overrides for set methods so that newly added items are deeply reactive\n */\nconst createReactiveSetOverrides = <V>(\n  mobxSet: Set<V>,\n  initialIndex: number,\n): Pick<Set<V>, 'add' | 'delete' | 'has' | 'clear'> => {\n  let index = initialIndex;\n\n  /**\n   * If provided value is an original object, returns\n   * its corresponding value in the reactive set\n   */\n  const getItem = (value: V): V | undefined => {\n    return Array.from(mobxSet).find((item) => {\n      if (isObject(item) && isObject(value)) {\n        return isReactiveObjectEqual(item, value);\n      }\n      return false;\n    });\n  };\n\n  return {\n    clear: wrapDecoupled(mobxSet, mobxSet.clear),\n    has(value) {\n      return getItem(value) != null || mobxSet.has(value);\n    },\n    delete(value) {\n      const searchedValue = getItem(value) ?? value;\n      return mobxSet.delete(searchedValue);\n    },\n    add(value) {\n      const reactive = reactiveLookup.get(mobxSet) as Set<V>;\n      if (getItem(value) == null) {\n        const reactiveName = reactiveNameLookup.get(reactive)!;\n        const newValue = makeDeepReactive(value, new Map(), `${reactiveName}.Item[${index}]`);\n        index += 1;\n        mobxSet.add(newValue);\n      }\n      return reactive;\n    },\n  };\n};\n\n/**\n * Creates overrides for map methods so that newly added items are deeply reactive\n */\nconst createReactiveMapOverrides = <K, V>(\n  mobxMap: Map<K, V>,\n  initialIndex: number,\n): Pick<Map<K, V>, 'set' | 'has' | 'get' | 'delete' | 'clear'> => {\n  let index = initialIndex;\n\n  /**\n   * If provided key is an original object, returns\n   * the actual map key\n   */\n  const getItemKey = (key: K): K | undefined => {\n    return Array.from(mobxMap.keys()).find((item) => {\n      if (isObject(item) && isObject(key)) {\n        return isReactiveObjectEqual(item, key);\n      }\n      return false;\n    });\n  };\n\n  /**\n   * Determines if the provided value, which may be an original\n   * object, is equal to the current Map's value stored at provided key\n   */\n  const isValueStoredAtKeyEqual = (existingKey: K | undefined, value: V) => {\n    if (existingKey == null) {\n      return false;\n    }\n    const existingValue = mobxMap.get(existingKey);\n    if (isObject(value) && isObject(existingValue)) {\n      return isReactiveObjectEqual(existingValue, value);\n    }\n    return mobxMap.has(existingKey) && value === existingValue;\n  };\n\n  return {\n    clear: wrapDecoupled(mobxMap, mobxMap.clear),\n    has(key) {\n      return getItemKey(key) != null || mobxMap.has(key);\n    },\n    get(key) {\n      return mobxMap.get(getItemKey(key) ?? key);\n    },\n    delete(key) {\n      const searchedValue = getItemKey(key) ?? key;\n      decoupleReactiveFromOriginal(mobxMap);\n      return mobxMap.delete(searchedValue);\n    },\n    set(key, value) {\n      const reactive = reactiveLookup.get(mobxMap) as Map<K, V>;\n      const reactiveName = reactiveNameLookup.get(reactive)!;\n      let stringKey = typeof key === 'string' || typeof key === 'number' ? `${key}` : null;\n      if (stringKey == null) {\n        stringKey = `${index}`;\n        index += 1;\n      }\n      const existingKey = getItemKey(key);\n      // If the value is already equal to what is stored in the map,\n      // no need to propagate the update to MobX\n      if (!isValueStoredAtKeyEqual(existingKey, value)) {\n        const newKey =\n          existingKey ?? makeDeepReactive(key, new Map(), `${reactiveName}.Key[${stringKey}]`);\n        const newValue = makeDeepReactive(value, new Map(), `${reactiveName}.Value[${stringKey}]`);\n        decoupleReactiveFromOriginal(reactive);\n        mobxMap.set(newKey, newValue);\n      }\n      return reactive;\n    },\n  };\n};\n\n/**\n * Wraps MobX object with our own reactive proxy, as well as provides\n * necessary values and connections to customize reactive behavior\n */\nconst createReactive = <T extends object>(name: string, inert: T, mobxObject: T): T => {\n  const reactive = new Proxy(mobxObject, reactiveProxyHandler) as T;\n  isReactive.add(reactive);\n  reactiveNameLookup.set(reactive, name);\n  reactiveLookup.set(mobxObject, reactive);\n  const inertSet = new WeakSet([inert]);\n  inertSetLookup.set(reactive, inertSet);\n  return reactive;\n};\n\n/**\n * Returns an object equivalent to the provided one, but deeply wrapped\n * to provide MobX reactivity, as well as customize MobX via our own\n * reactive proxy\n */\nexport const makeDeepReactive = <T>(\n  object: T,\n  seenObjects: Map<Inert, Reactive>,\n  currentPath: string = createDefaultReactiveName(),\n): T => {\n  if (!isObject(object) || isReactive.has(object)) {\n    return object;\n  }\n\n  const proxy = seenObjects.get(object);\n  if (proxy) {\n    return proxy as unknown as T;\n  }\n\n  if (Array.isArray(object)) {\n    const mobxObject = observable.array(undefined, {\n      name: currentPath,\n    });\n    const reactive = createReactive<unknown[]>(currentPath, object, mobxObject);\n    seenObjects.set(object, reactive);\n    object.forEach((item, i) => {\n      mobxObject.push(makeDeepReactive(item, seenObjects, `${currentPath}[${i}]`));\n    });\n    reactiveArrayOverridesLookup.set(\n      reactive,\n      createReactiveArrayOverrides(mobxObject, reactive.length),\n    );\n    return reactive as unknown as T;\n  }\n\n  if (object instanceof Set) {\n    const mobxObject = observable.set(undefined, {\n      name: currentPath,\n    });\n    const reactive = createReactive<Set<unknown>>(currentPath, object, mobxObject);\n    seenObjects.set(object, reactive);\n    let index = 0;\n    object.forEach((item) => {\n      mobxObject.add(makeDeepReactive(item, seenObjects, `${currentPath}.Item[${index}]`));\n      index += 1;\n    });\n    reactiveSetOverridesLookup.set(reactive, createReactiveSetOverrides(mobxObject, index));\n    return reactive as unknown as T;\n  }\n\n  if (object instanceof Map) {\n    const mobxObject = observable.map(undefined, {\n      name: currentPath,\n    });\n    const reactive = createReactive<Map<unknown, unknown>>(currentPath, object, mobxObject);\n    seenObjects.set(object, reactive);\n    let index = 0;\n    object.forEach((value, key) => {\n      let stringKey = typeof key === 'string' || typeof key === 'number' ? `${key}` : null;\n      if (stringKey == null) {\n        stringKey = `${index}`;\n        index += 1;\n      }\n      const reactiveKey = makeDeepReactive(key, seenObjects, `${currentPath}.Key[${stringKey}]`);\n      const reactiveValue = makeDeepReactive(\n        value,\n        seenObjects,\n        `${currentPath}.Value[${stringKey}]`,\n      );\n      mobxObject.set(reactiveKey, reactiveValue);\n    });\n    reactiveMapOverridesLookup.set(reactive, createReactiveMapOverrides(mobxObject, index));\n    return reactive as unknown as T;\n  }\n\n  const mobxObject = observable.object(object, undefined, {\n    name: currentPath,\n  });\n  const reactive = createReactive<object>(currentPath, object, mobxObject);\n  seenObjects.set(object, reactive);\n  Object.keys(object).forEach((name) => {\n    if (!isComputedProp(reactive, name)) {\n      mobxObject[name] = makeDeepReactive(object[name], seenObjects, `${currentPath}.${name}`);\n    }\n  });\n  return reactive as unknown as T;\n};\n\n/**\n * This reactive proxy is assigned on top of MobX proxy in order to\n * customize its functionality\n */\nconst reactiveProxyHandler: ProxyHandler<object> = {\n  /**\n   * MobX makes actions and computed properties non-enumerable, which\n   * leads to certain issues, such as \"Object.keys\" not returning computed\n   * properties or not being able to iterate over them in \"for-in\" loops.\n   * This is an unfortunate design decision, which could be rectified\n   * by creating the proxy trap and overriding enumerable behavior.\n   * Note: since MobX observable objects are themselves proxies, we cannot\n   * simply recreate the object via defining property descriptors upon\n   * reactive object creation, and, instead, we have to have an additional\n   * proxy\n   */\n  getOwnPropertyDescriptor(target, property) {\n    const mobxDescriptor = Reflect.getOwnPropertyDescriptor(target, property);\n    if (isObservableObject(target) && mobxDescriptor && typeof property === 'string') {\n      return {\n        ...mobxDescriptor,\n        enumerable: true,\n      };\n    }\n    return mobxDescriptor;\n  },\n\n  /**\n   * This trap overrides various methods for arrays, sets and maps,\n   * in order to ensure newly added items are made deeply reactive,\n   * as well as accessing elements via original objects is possible\n   */\n  get(target, property, receiver) {\n    const reactive = reactiveLookup.get(target);\n    const reactiveArrayOverrides = reactive && reactiveArrayOverridesLookup.get(reactive);\n    if (reactiveArrayOverrides && reactiveArrayOverrides[property]) {\n      return reactiveArrayOverrides[property];\n    }\n    const reactiveSetOverrides = reactive && reactiveSetOverridesLookup.get(reactive);\n    if (reactiveSetOverrides && reactiveSetOverrides[property]) {\n      return reactiveSetOverrides[property];\n    }\n    const reactiveMapOverrides = reactive && reactiveMapOverridesLookup.get(reactive);\n    if (reactiveMapOverrides && reactiveMapOverrides[property]) {\n      return reactiveMapOverrides[property];\n    }\n    return Reflect.get(target, property, receiver);\n  },\n\n  /**\n   * This proxy trap has 2 goals:\n   *\n   * 1. Reduce effect retriggers by not propagating the change to MobX\n   *    when value is the same as before. This applies to assigning\n   *    the same objects, which is complicated by the fact that MobX\n   *    proxy is not strictly equal to its target, in addition to the\n   *    fact that MobX proxy doesn't directly manage provided object, but\n   *    creates a new object to use as MobX proxy target. In order to weakly\n   *    couple the original object to our reactive proxy, we use `inertSetLookup`,\n   *    which maps the resulting reactive proxy to a WeakSet of original\n   *    targets (there is always only one target, but WeakSet has a better\n   *    browser support than WeakRef)\n   *\n   * 2. Deeply make objects, arrays, sets and maps appearing inside the\n   *    object reative\n   */\n  set(target, property, newValue, receiver) {\n    if (property in target && target[property] === newValue) {\n      /**\n       * This avoids updates when the value is assigned to what it was\n       * before\n       */\n      return true;\n    }\n\n    const reactive = reactiveLookup.get(target);\n    if (reactive && isObject(newValue)) {\n      const currentReactiveValue = reactive[property];\n      if (currentReactiveValue && isReactive.has(currentReactiveValue)) {\n        if (isReactiveObjectEqual(currentReactiveValue, newValue)) {\n          /**\n           * The case of reassigning to the same object. We should do\n           * nothing here, hereby overriding default behavior of MobX\n           * that causes effects to get retriggered when assigning the\n           * same object. We wish to avoid effects retriggers when\n           * assigning the same object to the property\n           */\n          return true;\n        }\n      }\n\n      const currentPath = reactiveNameLookup.get(reactive) ?? undefined;\n      decoupleReactiveFromOriginal(reactive);\n      return Reflect.set(\n        target,\n        property,\n        makeDeepReactive(newValue, new Map(), `${currentPath}.${String(property)}`),\n        receiver,\n      );\n    }\n\n    decoupleReactiveFromOriginal(reactive);\n    return Reflect.set(target, property, newValue, receiver);\n  },\n};\n\n/**\n * Walks through the object deeply, accessing all of direct and downstream\n * properties, for example to allow effects to subscribe to any change in a\n * reactive object\n */\nexport const deepAccessReactive = <T>(object: T, seenObjects: Set<object>): void => {\n  if (isObject(object) && seenObjects.has(object as unknown as object)) {\n    return;\n  }\n  if (isObject(object) && (Array.isArray(object) || isObservableArray(object))) {\n    seenObjects.add(object);\n    object.forEach((item) => {\n      deepAccessReactive(item, seenObjects);\n    });\n  } else if (object instanceof Set || isObservableSet(object)) {\n    seenObjects.add(object);\n    object.forEach((item) => {\n      deepAccessReactive(item, seenObjects);\n    });\n  } else if (object instanceof Map || isObservableMap(object)) {\n    seenObjects.add(object);\n    object.forEach((value, key) => {\n      deepAccessReactive(key, seenObjects);\n      deepAccessReactive(value, seenObjects);\n    });\n  } else if (isObject(object)) {\n    seenObjects.add(object as unknown as object);\n    Object.keys(object).forEach((name) => {\n      deepAccessReactive(object[name], seenObjects);\n    });\n  }\n};\n\n/**\n * Deeply clones a reactive object. Simply re-creates all arrays, objects,\n * maps and sets; for all other types (which should mostly just be primitives),\n * defaults to `toJS` provided by MobX. Supports cycles via \"seenObjects\" map\n */\nexport const deepCloneReactiveToInert = <T>(object: T, seenObjects: Map<object, object>): T => {\n  if (object && typeof object === 'object') {\n    const seenObject = seenObjects.get(object as unknown as object);\n    if (seenObject) {\n      return seenObject as unknown as T;\n    }\n  }\n  if (\n    object &&\n    typeof object === 'object' &&\n    (Array.isArray(object) || isObservableArray(object))\n  ) {\n    const array: unknown[] = [];\n    seenObjects.set(object, array);\n    object.forEach((item) => {\n      array.push(deepCloneReactiveToInert(item, seenObjects));\n    });\n    return array as unknown as T;\n  }\n  if (object instanceof Set || isObservableSet(object)) {\n    const set = new Set<unknown>();\n    seenObjects.set(object, set);\n    object.forEach((item) => {\n      set.add(deepCloneReactiveToInert(item, seenObjects));\n    });\n    return set as unknown as T;\n  }\n  if (object instanceof Map || isObservableMap(object)) {\n    const map = new Map<unknown, unknown>();\n    seenObjects.set(object, map);\n    object.forEach((value, key) => {\n      map.set(\n        deepCloneReactiveToInert(key, seenObjects),\n        deepCloneReactiveToInert(value, seenObjects),\n      );\n    });\n    return map as unknown as T;\n  }\n  if (object && typeof object === 'object') {\n    const newObject = {} as T;\n    seenObjects.set(object as unknown as object, newObject as unknown as object);\n    Object.keys(object).forEach((name) => {\n      newObject[name] = deepCloneReactiveToInert(object[name], seenObjects);\n    });\n    return newObject;\n  }\n  return toJS(object);\n};\n","/**\n * This file is to wrap / re-export MobX's functions so that we can:\n * 1. Depend on the limited set of MobX's functionality\n * 2. Depend on our own internal functions for majority of codebase rather\n *    than requiring MobX everywhere\n * 3. Wrap important MobX defaults\n */\nimport { configure, reaction, trace } from 'mobx';\nimport { observer, useLocalObservable } from 'mobx-react-lite';\n\nimport {\n  deepAccessReactive,\n  deepCloneReactiveToInert,\n  isObject,\n  makeDeepReactive,\n} from './framework-deep';\n\nexport type MakeReactive = <T extends object>(object: T) => T;\n\nexport type Effect = <ReactiveValue>(\n  getReactive: () => ReactiveValue,\n  runEffect: (reactiveValue: ReactiveValue) => void,\n) => () => void;\n\nconfigure({\n  /**\n   * Note: for the purposes of mocking, it is useful to be able to\n   * override certain state and actions outside of a MobX action\n   */\n  enforceActions: process.env.NODE_ENV === 'test' ? 'never' : 'observed',\n\n  /**\n   * We want to isolate the MobX global state\n   * to prevent issues with multiple instances of MobX\n   * in the same app (specifically with CSDK applications)\n   * https://mobx.js.org/configuration.html#isolateglobalstate-boolean\n   */\n  isolateGlobalState: true,\n});\n\n/**\n * For debugging, allows us to use \"window.cadState.trace()\" function inside\n * a computed property / observer to determine the reason for computed value\n * updates by showing the current update tree\n */\nexport const provideCadStateTrace = () => {\n  if ('cadState' in window) {\n    return;\n  }\n  const value = { trace };\n  Object.freeze(value);\n  Object.defineProperty(window, 'cadState', {\n    configurable: false,\n    enumerable: false,\n    value,\n    writable: false,\n  });\n};\n\n/**\n * Wrapper around objects to return reactive copy of the object. Reactive objects can\n * consist of independent properties, getters (aka computed properties) and functions\n * (aka actions). What makes reactive objects special is that the computed properties\n * are cached and only recalculated when its dependencies change, actions batch changes\n * to reactive properties, and any changes to reactive properties (either independent or\n * computed) trigger rerunning of the effects that depend on them. Under the hood, it\n * wraps a MobX function and provides defaults\n */\nexport const makeReactive: MakeReactive = <T extends object>(object: T): T => {\n  return makeDeepReactive(object, new Map()) as T;\n};\n\n/**\n * Effects is a way to react to state changes and perform updates. For example,\n * every React component that depends on a subset of the state will have an effect\n * to rerender whenever this subset changes. The effect takes two functions:\n * 1. Reactive part. All reactive properties accessed inside the reactive part will\n *    subscribe the effect to the changes. In addition, the effect will be deeply\n *    subscribed to anything reactive returned from the reactive part\n * 2. Inert part. This function is called immediately after the reactive part. It will\n *    receive the result returned from the reactive part and can safely perform any\n *    work or any side effect without subscribing the effect to anything further\n *\n * The effect is called immediately when `effect(reactive, inert)` is called and any\n * time the subset of the state accessed in (or returned from) reactive part changes.\n * We MUST clean up the effects whenever they are no longer needed (e.g. when the React\n * component unmounts). The cleanup function is returned from the `effect` call\n *\n * Internally, this wraps MobX's \"reaction\" and provides useful defaults.\n * Renamed from \"reaction\" to \"effect\" in order to indicate the intent is\n * for external effects\n */\nexport const effect: Effect = (getReactive, runEffect) => {\n  const getAccessedReactive = () => {\n    const result = getReactive();\n    /**\n     * For every effect, we should deeply access its reactive object so that a change\n     * in any downstream property leads to retriggering of the effect. This makes effects\n     * reliable and easy to work with, but still avoids deep clones\n     */\n    deepAccessReactive(result, new Set());\n    return result;\n  };\n\n  return reaction(getAccessedReactive, runEffect, {\n    /**\n     * Note: default MobX behavior is to avoid running effects when\n     * the result of reactive part is strictly the same (===) as before.\n     * This can also be altered by choosing a deep equality (comparer.structural)\n     * comparer instead.\n     *\n     * If we choose default strict equality comparer, we cannot return\n     * the same object as before from the effect, because in such a case,\n     * the effect will not be rerun, even if the returned object has\n     * been modified, which lead to the effect in the first place.\n     * Hence we are only limited to returning primitives from the\n     * reactive part of the effect.\n     *\n     * If we choose deep equality comparer, when returning a reactive\n     * object directly from the reactive part, this will result in no\n     * effect triggered, even if the object was modified. The only way\n     * to correctly trigger the update would be to return deeply cloned\n     * object from the reactive part, because references will be\n     * different and deep comparison will auto-determine that change happened.\n     * However, this is very expensive, because the object needs to be deeply\n     * cloned and then deeply compared to the old one.\n     *\n     * The solution is to\n     *\n     * 1. Avoid triggering updates for reactive objects when the property\n     *    value is the same as before via our own `reactiveProxy`\n     *\n     * 2. Allow updates to cause effects regardless of the value returned\n     *    from the effect, so that we can return reactive objects\n     *    directly, without having to deep clone them\n     */\n    equals: (a: unknown, b: unknown) => {\n      if (isObject(a) && isObject(b)) {\n        return false;\n      }\n      return a === b;\n    },\n\n    /**\n     * There are very few circumstances where we don't want to run\n     * the effects immediately, in which cases we can easily handle that\n     * inside effect creation functions\n     */\n    fireImmediately: true,\n  });\n};\n\n/**\n * Get a non-reactive deep clone of a reactive object\n */\nexport const cloneInert = <T>(object: T): T => {\n  return deepCloneReactiveToInert(object, new Map());\n};\n\n/**\n * Renamed MobX's \"observer\" to \"stateObserver\" to make it more clear and searchable\n */\nexport { observer as stateObserver, useLocalObservable };\n","import { v4 as uuidv4 } from 'uuid';\n\nexport const generateUuid = (): string => uuidv4();\n","import { useEffect, useState } from 'react';\n\ninterface UseInterceptMouseProps {\n  cadDomNode?: HTMLCanvasElement | null;\n}\n\nexport const useInterceptMouse = ({ cadDomNode }: UseInterceptMouseProps) => {\n  const [clicked, setClicked] = useState<boolean>(false);\n\n  useEffect(() => {\n    if (!cadDomNode) return undefined;\n    const onMouse = () => {\n      setClicked(true);\n    };\n    const options = { capture: true, once: true, passive: true };\n    // NOTE: This may fire more than once, but the total number of events should be small\n    cadDomNode.addEventListener('pointerdown', onMouse, options);\n\n    return () => {\n      cadDomNode.removeEventListener('pointerdown', onMouse, options);\n    };\n  }, [cadDomNode]);\n\n  return clicked;\n};\n","import { FileUploaderResult } from '@aurorasolar/graphql-client-schema';\n\nexport enum FileResultType {\n  IMAGE = 'image',\n  DOCUMENT = 'document',\n  VIDEO = 'video',\n  UNKNOWN = 'unknown',\n}\n\nexport enum FileResultUploadStatus {\n  // Upload manually canceled\n  CANCELED = 'canceled',\n  COMPLETE = 'complete',\n  IN_PROGRESS = 'in-progress',\n  // Unknown error - can retry upload\n  NON_VALIDATION_ERROR = 'non-validation-error',\n  // Awaiting upload kickoff\n  PENDING = 'pending',\n  // File will not pass validation, do not allow retry upload\n  VALIDATION_ERROR = 'validation-error',\n}\n\nexport interface FileResult {\n  errorText?: string;\n  file: File;\n  fileType: FileResultType;\n  status: FileResultUploadStatus;\n  id: string;\n  result?: FileUploaderResult | null;\n}\n\nexport interface BSSClientResponse {\n  blob_id: string;\n  upload_needed: boolean;\n  upload_url: string;\n  mandatory_upload_headers?:\n    | ({ name?: string | null; value?: string | null } | null | undefined)[]\n    | null;\n}\n\nexport enum SupportedMimeTypes {\n  GIF = 'image/gif',\n  HEIC = 'image/heic',\n  JPEG = 'image/jpeg',\n  PDF = 'application/pdf',\n  PNG = 'image/png',\n  WEBP = 'image/webp',\n  ZIP = 'application/zip',\n  DXF = 'image/vnd.dxf',\n  DWG = 'image/vnd.dwg',\n}\n","import { FileResultType, SupportedMimeTypes } from './types';\n\nexport const getFileResultType = (mimeType: string) => {\n  switch (mimeType) {\n    case SupportedMimeTypes.GIF:\n    case SupportedMimeTypes.JPEG:\n    case SupportedMimeTypes.PNG:\n    case SupportedMimeTypes.WEBP:\n    case SupportedMimeTypes.HEIC:\n    case SupportedMimeTypes.DXF:\n    case SupportedMimeTypes.DWG:\n      return FileResultType.IMAGE;\n    case SupportedMimeTypes.PDF:\n      return FileResultType.DOCUMENT;\n    default:\n      return FileResultType.UNKNOWN;\n  }\n};\n\nexport const getFileSizeFormatted = (fileSize: number): string => {\n  if (fileSize <= 0) {\n    return '0 KB';\n  }\n  const kbSize = Math.round((fileSize / 1024) * 100) / 100;\n  if (kbSize < 1024) {\n    return `${kbSize} KB`;\n  }\n  const mbSize = Math.round((kbSize / 1024) * 100) / 100;\n  if (mbSize < 1024) {\n    return `${mbSize} MB`;\n  }\n  const gbSize = Math.round((mbSize / 1024) * 100) / 100;\n  return `${gbSize} GB`;\n};\n","// Unique ID creation requires a high quality random # generator. In the browser we therefore\n// require the crypto API and do not support built-in fallback to lower quality random number\n// generators (like Math.random()).\nvar getRandomValues;\nvar rnds8 = new Uint8Array(16);\nexport default function rng() {\n  // lazy load so that environments that need to polyfill have a chance to do so\n  if (!getRandomValues) {\n    // getRandomValues needs to be invoked in a context where \"this\" is a Crypto implementation. Also,\n    // find the complete implementation of crypto (msCrypto) on IE11.\n    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);\n\n    if (!getRandomValues) {\n      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');\n    }\n  }\n\n  return getRandomValues(rnds8);\n}","export default /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;","import REGEX from './regex.js';\n\nfunction validate(uuid) {\n  return typeof uuid === 'string' && REGEX.test(uuid);\n}\n\nexport default validate;","import validate from './validate.js';\n/**\n * Convert array of 16 byte values to UUID string format of the form:\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\n */\n\nvar byteToHex = [];\n\nfor (var i = 0; i < 256; ++i) {\n  byteToHex.push((i + 0x100).toString(16).substr(1));\n}\n\nfunction stringify(arr) {\n  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  // Note: Be careful editing this code!  It's been tuned for performance\n  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434\n  var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one\n  // of the following:\n  // - One or more input array values don't map to a hex octet (leading to\n  // \"undefined\" in the uuid)\n  // - Invalid input values for the RFC `version` or `variant` fields\n\n  if (!validate(uuid)) {\n    throw TypeError('Stringified UUID is invalid');\n  }\n\n  return uuid;\n}\n\nexport default stringify;","import rng from './rng.js';\nimport stringify from './stringify.js';\n\nfunction v4(options, buf, offset) {\n  options = options || {};\n  var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n\n  rnds[6] = rnds[6] & 0x0f | 0x40;\n  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided\n\n  if (buf) {\n    offset = offset || 0;\n\n    for (var i = 0; i < 16; ++i) {\n      buf[offset + i] = rnds[i];\n    }\n\n    return buf;\n  }\n\n  return stringify(rnds);\n}\n\nexport default v4;"],"names":["useState","Error","defaultNoopBatch","callback","FinalizationRegistryLocal","FinalizationRegistry","undefined","createTrackingData","reaction","mounted","changedBeforeMount","cleanAt","Date","now","CLEANUP_LEAKED_REACTIONS_AFTER_MILLIS","__values","o","s","Symbol","iterator","m","i","call","length","next","value","done","TypeError","_a","cleanupTokenToReactionTrackingMap","Map","globalCleanupTokensCounter","registry","token","trackedReaction","get","dispose","delete","addReactionToTrack","reactionTrackingRef","objectRetainedByReact","register","current","finalizationRegistryCleanupToken","set","recordReactionAsCommitted","reactionRef","unregister","forceCleanupTimerToRunNowForTests","resetCleanupScheduleForTests","createReactionCleanupTrackingUsingFinalizationRegister","reactionCleanupHandle","uncommittedReactionRefs","Set","ensureCleanupTimerRunning","setTimeout","cleanUncommittedReactions","forEach","ref","tracking","size","add","clearTimeout","e_1","uncommittedReactionRefs_1","uncommittedReactionRefs_1_1","e_1_1","error","return","clear","createTimerBasedReactionCleanupTracking","hasSymbol","for","forwardRef","props","memo","useLocalObservable","initializer","annotations","autoBind","reactionScheduler","die","_len","arguments","args","Array","_key","map","String","join","mockGlobal","getGlobal","globalThis","window","g","self","assign","Object","getDescriptor","getOwnPropertyDescriptor","defineProperty","objectPrototype","prototype","EMPTY_ARRAY","freeze","EMPTY_OBJECT","hasProxy","Proxy","plainObjectString","toString","assertProxies","once","func","invoked","apply","this","noop","isFunction","fn","isStringish","isObject","isPlainObject","proto","getPrototypeOf","protoConstructor","hasOwnProperty","constructor","isGenerator","obj","name","displayName","addHiddenProp","object","propName","enumerable","writable","configurable","addHiddenFinalProp","createInstanceofPredicate","theClass","x","isES6Map","thing","isES6Set","hasGetOwnPropertySymbols","getOwnPropertySymbols","ownKeys","Reflect","getOwnPropertyNames","concat","toPrimitive","hasProp","target","prop","getOwnPropertyDescriptors","res","key","_defineProperties","descriptor","_createClass","Constructor","protoProps","staticProps","_extends","source","_inheritsLoose","subClass","superClass","create","_setPrototypeOf","p","setPrototypeOf","__proto__","_assertThisInitialized","ReferenceError","_arrayLikeToArray","arr","len","arr2","_createForOfIteratorHelperLoose","allowArrayLike","it","bind","isArray","minLen","n","slice","from","test","_unsupportedIterableToArray","storedAnnotationsSymbol","createDecoratorAnnotation","annotation","property","storeAnnotation","annotationType_","OVERRIDE","isOverride","$mobx","Atom","name_","isPendingUnobservation_","isBeingObserved_","observers_","diffValue_","lastAccessedBy_","lowestObserverState_","IDerivationState_","NOT_TRACKING_","onBOL","onBUOL","_proto","onBO","listener","onBUO","reportObserved","reportChanged","startBatch","propagateChanged","endBatch","isAtom","createAtom","onBecomeObservedHandler","onBecomeUnobservedHandler","arg3","atom","interceptHook","ON_BECOME_OBSERVED","onBecomeUnobserved","comparer","identity","a","b","structural","deepEqual","is","shallow","deepEnhancer","v","_","isObservable","observable","array","isAction","isFlow","flow","autoAction","referenceEnhancer","newValue","createActionAnnotation","options","options_","make_","make_$1","extend_","extend_$1","adm","_this$options_","bound","target_","actionDescriptor","createActionDescriptor","proxyTrap","defineProperty_","safeDescriptors","_annotation$options_","_annotation$options_$","_annotation$options_2","_annotation$options_$2","_annotation$options_3","_annotation$options_4","_adm$proxy_2","_ref2","globalState","_adm$proxy_","proxy_","createAction","isPlainObject_","createFlowAnnotation","make_$2","extend_$2","flowDescriptor","createFlowDescriptor","_this$options_2","isMobXFlow","createComputedAnnotation","make_$3","extend_$3","_ref","assertComputedDescriptor","defineComputedProperty_","createObservableAnnotation","make_$4","extend_$4","_this$options_$enhanc","assertObservableDescriptor","defineObservableProperty_","enhancer","AUTO","autoAnnotation","createAutoAnnotation","make_$5","extend_$5","_this$options_3","_this$options_4","computed","observableAnnotation","deep","_this$options_5","_this$options_6","defaultCreateObservableOptions","defaultDecorator","proxy","asCreateObservableOptions","observableRefAnnotation","observableShallowAnnotation","isObservableObject","isObservableArray","isObservableMap","isObservableSet","observableStructAnnotation","oldValue","observableDecoratorAnnotation","getEnhancerFromOptions","createObservable","arg2","box","_getDescriptor$config","_getDescriptor","ObservableValue","equals","initialValues","useProxies","createLegacyArray","createObservableArray","ObservableMap","ObservableSet","decorators","extendObservable","asObservableObject","_target$$mobx","_target$$mobx$proxy_","objectProxyTraps","asDynamicObservableObject","struct","COMPUTED","computedAnnotation","computedStructAnnotation","arg1","opts","ComputedValue","_Symbol$toPrimitive","currentActionId","nextActionId","isFunctionNameConfigurable","tmpNameDescriptor","actionName","executeAction","isMobxAction","canRunAsDerivation","scope","runInfo","notifySpy_","startTime_","prevDerivation_","trackingDerivation","runAsAction","prevAllowStateChanges_","allowStateChanges","untrackedStart","allowStateChangesStart","prevAllowStateReads_","allowStateReadsStart","runAsAction_","actionId_","parentActionId_","_startAction","err","error_","suppressReactionErrors","allowStateChangesEnd","allowStateReadsEnd","untrackedEnd","_endAction","prev","_Symbol$toPrimitive$1","_Atom","notifySpy","_this","hasUnreportedChange_","interceptors_","changeListeners_","value_","dehancer","dehanceValue","prepareNewValue_","UNCHANGED","setNewValue_","checkIfStateModificationsAreAllowed","hasInterceptors","change","interceptChange","type","UPDATE","hasListeners","notifyListeners","intercept_","handler","registerInterceptor","observe_","fireImmediately","observableKind","debugObjectName","registerListener","raw","toJSON","valueOf","isObservableValue","TraceMode","dependenciesState_","observing_","newObserving_","runId_","UP_TO_DATE_","unboundDepsCount_","CaughtException","triggeredBy_","isComputing_","isRunningSetter_","derivation","setter_","isTracing_","NONE","scope_","equals_","requiresReaction_","keepAlive_","compareStructural","context","requiresReaction","keepAlive","onBecomeStale_","POSSIBLY_STALE_","d","propagateMaybeChanged","inBatch","shouldCompute","prevTrackingContext","trackingContext","trackAndCompute","STALE_","propagateChangeConfirmed","warnAboutUntrackedRead_","computeValue_","result","isCaughtException","cause","wasSuspended","changed","track","trackDerivedFunction","disableErrorBoundaries","e","suspend_","clearObserving","firstTime","prevValue","autorun","prevU","isComputedValue","prevAllowStateReads","prevUntracked","obs","l","changeDependenciesStateTo0","f","runId","prevTracking","prevObserving","observing","lowestNewObservingDerivationState","i0","dep","_dep","removeObserver","_dep2","addObserver","bindDependencies","untracked","action","allowStateReads","MobXGlobals","version","mobxGuid","pendingUnobservations","pendingReactions","isRunningReactions","enforceActions","spyListeners","globalReactionErrorHandlers","computedRequiresReaction","reactionRequiresObservable","observableRequiresReaction","verifyProxies","canMergeGlobalState","isolateCalled","global","__mobxInstanceCount","__mobxGlobals","node","queueForUnobservation","push","runReactions","list","Reaction","onInvalidate_","errorHandler_","requiresObservable_","isDisposed_","isScheduled_","isTrackPending_","isRunning_","schedule_","isScheduled","runReaction_","reportExceptionInDerivation_","prevReaction","message","console","getDisposer_","r","trace","enterBreakPoint","pop","getAtom","getAtomFromArgs","log","BREAK","LOG","MAX_REACTION_ITERATIONS","runReactionsHelper","allReactions","iterations","splice","remainingReactions","isReaction","ACTION","AUTOACTION","DEFAULT_ACTION_NAME","actionAnnotation","actionBoundAnnotation","autoActionAnnotation","autoActionBoundAnnotation","createActionFactory","view","_opts$name","_opts","scheduler","delay","reactionRunner","onError","requiresObservable","createSchedulerFromOptions","run","expression","effect","_opts$name2","errorHandler","baseFn","effectAction","runSync","nextValue","ON_BECOME_UNOBSERVED","hook","cb","listenersKey","hookListeners","NEVER","ALWAYS","OBSERVED","configure","isolateGlobalState","baseScheduler","ea","properties","descriptors","getDependencyTree","nodeToDependencyTree","dependencies","generatorId","FlowCancellationError","flowAnnotation","flowBoundAnnotation","generator","rejector","gen","pendingPromise","promise","Promise","resolve","reject","stepId","onFulfilled","ret","onRejected","then","cancel","cancelPromise","_res","yieldedPromise","_isComputed","values_","has","isComputedProp","_isObservable","cache","toJSHelper","__alreadySeen","idx","_res2","_res3","ownKeys_","apiOwnKeys","propertyIsEnumerable","toJS","transaction","thisArg","getAdm","has_","get_","_getAdm$set_","set_","deleteProperty","_getAdm$delete_","delete_","_getAdm$definePropert","preventExtensions","interceptable","interceptors","indexOf","listenable","listeners","makeObservable","collectStoredAnnotations","SPLICE","arrayTraps","getArrayLength_","isNaN","arrayExtensions","parseInt","setArrayLength_","ObservableArrayAdministration","owned_","legacyMode_","atom_","enhancer_","lastKnownLength_","newV","oldV","dehanceValue_","dehanceValues_","values","index","added","addedCount","removed","removedCount","newLength","currentLength","newItems","spliceWithArray_","updateArrayLength_","oldLength","delta","reserveArrayBuffer","deleteCount","Math","max","min","lengthDelta","spliceItemsIntoValues_","notifyArraySplice_","_this$values_","oldItems","_i","notifyArrayChildUpdate_","notify","warn","owned","replace","spliceWithArray","_len2","items","_key2","shift","unshift","_len3","_key3","reverse","sort","copy","remove","addArrayExtension","funcName","funcFactory","simpleFunc","dehancedValues","mapLikeFunc","_this2","element","reduceLikeFunc","_this3","accumulator","currentValue","_Symbol$iterator","_Symbol$toStringTag","isObservableArrayAdministration","ObservableMapMarker","ADD","DELETE","toStringTag","_Symbol$iterator$1","_Symbol$toStringTag$1","initialData","data_","hasMap_","keysAtom_","merge","entry","newEntry","hasKey","updateValue_","addValue_","_change","_this3$hasMap_$get","_this4","_this4$hasMap_$get","keys","makeIterable","_keys$next","entries","_keys$next2","_step","_iterator","_step$value","other","_this5","symbols","filter","getPlainObjectKeys","_this6","_step2","_iterator2","_this7","_step3","replacementMap","dataStructure","convertToMap","orderedData","keysReportChangedCalled","_iterator3","_step4","_iterator4","_step4$value","_value","keyExisted","_value2","iter1","iter2","next1","next2","ObservableSetMarker","callbackFn","_change2","nextIndex","observableValues","descriptorCache","REMOVE","ObservableObjectAdministration","defaultAnnotation_","appliedAnnotations_","pendingKeys_","getObservablePropValue_","setObservablePropValue_","assertAnnotable","_this$target_$storedA","outcome","recordAnnotationApplied","deleteOutcome","notifyPropertyAddition_","cachedDescriptor","getCachedObservablePropDescriptor","_this$pendingKeys_","_this$pendingKeys_$ge","_this$pendingKeys_2","_this$pendingKeys_2$g","keys_","_options$name","_options$defaultDecor","getAnnotationFromOptions","isObservableObjectAdministration","_adm$target_$storedAn","ctor","ENTRY_0","createArrayEntryDescriptor","OBSERVABLE_ARRAY_BUFFER_SIZE","StubArray","LegacyObservableArray","_StubArray","arrays","createArrayBufferItem","getDebugName","_observable","getAdministration","named","depth","eq","aStack","bStack","className","unwrap","areArrays","aCtor","bCtor","getSelf","__MOBX_DEVTOOLS_GLOBAL_HOOK__","injectMobx","spy","extras","LoadingAnimation","Lottie","lazy","path","setPath","useEffect","async","pathData","default","lazyLoadLottie","loadpath","Suspense","fallback","loop","play","rendererSettings","preserveAspectRatio","style","backgroundColor","height","width","LoadingText","h1Box","CadLoadingPage","alignItems","flexDirection","h","justifyContent","mb","h3","color","textAlign","useOnceRef","isInitialized","useRef","useReactive","getReactive","dependencyArray","isWithinRender","rerender","reactiveCallback","useCallback","lastReactiveCallbackRef","reactiveObservable","setReactiveCallback","newReactiveCallback","stopEffect","createCadContainer","document","createElement","ReactiveContextProvider","CadPageViewportsStateProvider","useReactiveState","useCadPageViewportsState","createState","ReactiveContext","createContext","children","reactiveContextRef","Provider","reactiveContext","useContext","useReactiveContext","createReactiveSetup","makeReactive","data","defaultCamera","defaultLayers","exclusiveViewportName","viewports","cadContainersData","cadContainers","defaultCadContainer","scheduledActions","processActions","currentActionIndex","findIndex","scheduledAction","currentActionType","requestAnimationFrame","scheduleAddViewport","some","scheduleRemoveViewport","createCadViewportActionsScheduler","actions","addViewport","removeViewport","viewportIndex","setDefaultViewSettings","camera","layers","setExclusiveViewportName","newExclusiveViewportName","createCadPageViewportsActions","CadStatus","CadContext","CadInitializerContext","useCadContext","status","useOptionalCadContext","useCadInitializerContext","initialCadContext","designId","domNode","engine","engineSaveFn","eventStream","preferences","state","CadContextProvider","cadContext","isLoaded","Loading","cadContextInitializer","clearCadContext","fullContext","setCadContext","newCadContext","Loaded","setCadError","CadProvideSolarPanelDocument","CadProvideSolarInverterDocument","CadProvideDcOptimizerDocument","CadProvideCombinerBoxDocument","CadProvideDisconnectDocument","CadProvideLoadCenterDocument","CadProvideMeterDocument","CadProvideServicePanelDocument","getComponentReadQuery","query","client","id","readQuery","variables","ComponentQueries","CombinerBox","DcOptimizer","Disconnect","LoadCenter","Meter","SolarInverter","ServicePanel","SolarPanel","peekRecord","compId","typeCamelCase","toUpperCase","queryComponent","component","readComponent","__typename","mlpe","isDcOptimizer","dcOptimizer","isSolarInverter","solarInverter","isCellStringOptimizer","cellStringOptimizer","formatMlpe","Converter","numerator","definitions","val","destination","origin","getUnit","throwUnsupportedUnitError","to","abbr","describe","unit","to_anchor","anchor_shift","system","transform","toBest","exclude","cutOffNumber","item","includes","reduce","acc","found","systemName","possibilities","what","singular","plural","utils","metric","baseUnit","rad","deg","grad","arcmin","arcsec","VA","mVA","kVA","MVA","GVA","mm2","cm2","m2","ha","km2","imperial","yd2","ft2","ac","mi2","c","mC","nC","pC","A","mA","kA","bits","Kb","Mb","Gb","Tb","bytes","B","KB","MB","GB","TB","dz","Wh","mWh","kWh","MWh","GWh","J","kJ","N","kN","lbf","mHz","Hz","kHz","MHz","GHz","THz","rpm","mm","cm","km","yd","ft","fathom","mi","nMi","mcg","mg","kg","mt","oz","lb","t","ppm","ppb","ppt","ppq","W","mW","kW","MW","GW","Pa","kPa","MPa","hPa","bar","torr","psi","ksi","VARh","mVARh","kVARh","MVARh","GVARh","VAR","mVAR","kVAR","MVAR","GVAR","knot","C","K","F","R","ns","mu","ms","week","month","year","V","mV","kV","mm3","cm3","ml","cl","dl","kl","m3","km3","krm","tsk","msk","kkp","glas","kanna","tsp","Tbs","in3","cup","pnt","qt","gal","ft3","yd3","pipe","fns","arg","celsiusToFahrenheit","celsius","fahrenheitToCelsius","fahrenheit","decimalToPercentage","decimal","percentageToDecimal","percentage","ConversionType","UnitType","SquareFoot","SquareMeter","PricePerSquareFoot","PricePerSquareMeter","PoundsPerSquareFoot","KilogramsPerSquareMeter","MilesPerHour","areaConversion","squareFeetToSquareMeters","squareMetersToSquareFeet","pricePerSquareFootToPricePerSquareMeter","pricePerSquareMeterToPricePerSquareFoot","massConversion","poundToKilogram","Pound","Kilogram","kilogramToPound","poundPerSquareFootToKilogramPerSquareMeter","kilogramPerSquareMeterToPoundPerSquareFoot","speedConversion","milesPerHourToKilometersPerHour","KilometersPerHour","kilometersPerHourToMilesPerHour","lengthConversion","metersToInches","Inch","inchesToMeters","metersToCm","Centimeter","cmToMeters","metersToFeet","Foot","feetToMeters","noChange","defaultUnitSystems","distanceUnit","Metric","temperatureUnit","getConversionTuple","unitType","decimalPlaces","round","Number","toFixed","roundTo","Fahrenheit","Percent","buildUnitsAdapter","intl","conversionType","isMetric","isCelsius","Percentage","Temperature","Celsius","Distance","DistanceSmall","PricePerArea","Mass","Load","Speed","getUnitType","convertIn","convertOut","convert","Imperial","format","numFixed","_measurementType","footInchFormat","convertedValue","formattedValue","formatNumber","maximumFractionDigits","minimumFractionDigits","floor","smallDistanceUnit","distance","unconvert","CompassPosition","CadMode","getLeadCaptureGeodataService","deleteOrthoImage","detectAllObstructions","detectObstructions","initialize","cadBridge","triggerAction","ProcessGroundTextures","orthoImages","leadCadData","image","orthoImage","processGroundTextures","initialized","onOrthoImageBoundsIncrease","onProjectLocationChange","onSiteBoundsChange","onSpecifiedBoundsChange","updateOrthoImage","willDestroy","PreferenceScope","ExpirationType","UserScope","createLocalStoragePreferenceProvider","storagePrefix","isCadKey","startsWith","removeCadKeyPrefix","substring","provider","localStorage","getItem","json","JSON","parse","timestamp","getLocalStorageStoredValue","getKeys","removeItem","setItem","stringify","isDateMoreThanOneDayIntoTheFuture","isPastExpiryDate","maxDurationMs","schema","cadPreferencesManager","preferenceNames","preferenceDescriptors","preferenceIds","getPreferenceIds","manager","createPreferences","currentScope","localStorageProvider","instanceProvider","storage","createInstancePreferenceProvider","providers","getProvider","expirationType","Instance","getCurrentProviderKey","preferenceId","userId","getUserId","projectId","getProjectId","getDesignId","prefix","userScope","PerUser","preferenceScope","Project","Design","providerKey","storedValue","isValid","MaxDuration","getIdAndDescriptor","prefIdPrefix","split","find","cleanup","maxCountKeys","expectedProvider","MaxCount","maxCountKey","countDiff","maxCount","t1","t2","wrapActions","actionPreferenceNames","newActions","returnedValue","createPreferencesManager","p000","panelPlaceMode","dcOptimizerId","nullable","microinverterId","solarPanelId","minSap","pitchedThreshold","flatTilt","flatRotation","flatIntermoduleSpacingX","flatRowSpacing","flatOrientation","oneOf","pitchedTilt","pitchedRotation","pitchedIntermoduleSpacingX","pitchedRowSpacing","pitchedOrientation","required","isValidSync","modeInspectorTabTypes","createActiveTabData","selectionMetadata","activeInspectorOnlyTab","activeTab","primarySelectionKey","AutoDesignerStart","AutoDesignerFinished","performance","MarkName","AutoDesignerDuration","MeasureName","ModalType","OverlayType","DesignSettingsTab","createSaveData","historyData","hasUnsavedChanges","recentSavedVersion","recentVersion","isSaving","createCadState","cadEngineState","selectedTypeData","selectedTypes","selectionData","types","count","createSelectedTypesData","modalData","activeModal","None","activeOverlays","modalActions","closeModal","closeOverlay","overlayType","overlayDatum","openModal","modalType","openOverlay","overlayData","setDesignSettingsTab","designSettingsTab","DesignSettings","tab","createModalActions","autoDesignerData","isAutoDesignerRunning","autoDesignerActions","autoDesignerFinish","mark","measure","autoDesignerStart","createAutoDesignerActions","saveData","saveActions","finishSaving","saveVersion","startSaving","createSaveActions","prismData","isPrismCadOpen","prismActions","toggleIsPrismCadOpen","newState","createPrismActions","activeTabData","activeTabActions","selectionMetadataActions","setActiveTab","newActiveTab","setPrimarySelectionKey","createActiveTabActions","stopEffects","CadEventTypes","AutoStringErrorType","TOAST_CHANNEL","GetUserInfoDocument","CreateBssUploadUrlsDocument","useCreateBssUploadUrls","fileUploader","fetchUserId","userData","fetchPolicy","newUserId","currentUser","createBssUploadUrls","baseOptions","useCreateBssUploadUrlsMutation","fetchBssUploadUrls","files","currentUserId","hashFile","bssUploadInputsPromises","file","hash","blobName","contentLength","contentSha256","mimeType","bssUploadInputs","all","createBSSUploadUrlsInput","createBSSUploadUrls","SERVER_ERROR_MESSAGE","fileResultNotInProgress","fileResult","IN_PROGRESS","useUploadFiles","userFileOptions","fileMap","fileResults","setFileResults","runUploadFileAsyncJob","invalidateUploadFileAsyncJob","startAsyncJob","invalidateJobs","temporaryBlobId","fileName","label","parentId","parentType","parentRoleType","settings","FileUploader","useUploadFileAsyncJob","updateFileResult","updatedOptions","newFileResults","updateIndex","cancelFileUpload","PENDING","CANCELED","retryFileUpload","NON_VALIDATION_ERROR","VALIDATION_ERROR","errorText","removeFileUpload","clearResults","addErroredFiles","erroredFiles","newErroredFileResults","newErroredFileResult","fileType","uploadFiles","newFiles","newFile","newFileResult","pendingFileResults","pendingFiles","bssUploadUrls","uploadUrl","inProgressFileResult","blobId","uploadToSignedUrl","errors","firstError","COMPLETE","asyncUploadFiles","cancelFileResults","results","SaveDesignDocument","PreSaveDocument","withTimeout","time","timeoutMessage","timeoutPromise","race","takeSaveScreenshot","cadEvents$","reduxStore","screenshotPromise","firstValueFrom","event","eventType","CadScreenshot","payload","listenForScreenshotResponse","dispatch","actionType","TakeScreenshot","cadInstance","imageType","screenshotResponse","screenshotFile","File","cadSaveCallbackCore","apolloClient","evictCache","evictCacheById","jsonToSave","site","designJsonSchemaVersion","saveScreenshot","design","savesDisabled","checkCadCanSave","CAD","systemStats","systemStatsData","cadUpdatedDesign","carportSystemSizeStc","offRoofSystemSizeStc","irradianceMapId","irradiance","roof","mapId","irradianceMapStatus","Invalid","irradiancePanelsId","panels","irradiancePanelsStatus","roofSystemSizeStc","systemSizeAc","systemSizePtc","systemSizeStc","savePromise","mutate","awaitRefetchQueries","mutation","finally","catch","getCadSaveCallback","saveDependencies","currentSave","downloadDataURL","url","filename","createLink","encodedURI","encodeURI","link","setAttribute","display","body","appendChild","click","removeChild","AddAssetDocument","UpdateAssetDocument","UploadInProgressDocument","saveAndDownloadScreenshotAsset","newAsset","blob","writeQuery","cadUploadState","screenshotInProgress","asset","addAsset","fetch","headers","method","mode","updatedAsset","uploadInProgress","saveScreenshotAsset","URL","createObjectURL","isDownload","shouldDownload","checkContext","canvas","contextName","getContext","getExtension","loseContext","getMaxWebGLSupported","testCanvas","getUnmaskedGPUName","debugInfo","renderer","getParameter","UNMASKED_RENDERER_WEBGL","browserWebglInfo","getBrowserWebglInfo","gpu","webgl","getCadEventHandler","appConfig","store","trackingModule","eventPayload","SetExternalStateData","TrackAnalyticsAction","usedShortcut","trackableProperties","used_shortcut","CadErrorOccurred","CadGeometryErrorOccurred","getLogData","DataDog","rum","getUser","stack","logRocketURL","LogRocket","sessionURL","geometryData","logs","logger","info","CadLoggedMessage","extraData","rightPanelPayload","rightPanelData","RelayInternalCadState","SaveScreenshotAsset","newOptions","getCamelCaseImageOptions","assetType","DownloadDxf","Dxf","dxf","uri","downloadDxf","BeforeDrawWalkway","DrawWalkway","TRIGGER_CAD_ACTION","patches","k","newKey","user","cad_config","cadVersion","host","location","v2_config","api_host","apiHost","app_name","buildEnvironment","APP_NAME","environment","ENVIRONMENT","git_branch","GIT_BRANCH","trim","git_hash","GIT_COMMIT_HASH","release","RELEASE_VERSION","unknownProjectIdCount","unknownDesignIdCount","useCad","isShown","geodataService","parcelBounds","providedProjectId","providedDesignId","designRequestId","createDataProvider","engineOptions","featureGate","asyncEngineInit","enableSave","config","authToken","cadLib","notifications","analytics","orgPermissions","Screenshot","featureFlags","cadContextValue","cadInitializerContextValue","fieldName","evict","gc","storeObject","identify","useEvictCache","effectInfo","effectCleanup","cadContainer","viewData","domElement","requestIdleCallback","createCadPreferences","events$","Subject","subscription","Notify","subscriber","dismissType","messageType","title","getChannel","subscribe","isEventOfType","cleanupDOMEventsEffect","preventDefault","addEventListener","passive","removeEventListener","performDOMEventsEffect","cleanupUnknownProjectDesignEffect","performUnknownProjectDesignEffect","dataProvider","apiEnvironment","eventEmitter","trigger","Factory","getEngineInstance","stateFramework","cloneInert","useToastMessage","locale","documentElement","lang","asyncInitEngineInstance","initEngineInstance","irradianceMapService","Services","IrradianceMapService","saveHandler","save","isCadLoadCancelled","cadState","engineScoped","getActiveEngineInstance","DesignClickedSave","bridge","cadReady","unsubscribe","CadLib","cleanupEngineInstance","cleanupCad","complete","stopEvents","stopEffectMapKey","stopEffectMap","stopEffectKey","stopCadStateEffects","LeadCaptureCadDocument","useLeadCaptureCad","hasOrbitMode","showCompass","loading","useLeadCaptureCadQuery","useMemo","lat","latitude","lng","longitude","getIrradiance","getTemplateJsonById","irradianceState","lidarAccessible","moduleSpacingSettings","rowSpacing","y","pricePerWatt","projectType","selectedImageryTypes","basic","timeZoneOffset","units","createLeadCaptureCadDataProvider","DrawReconstructedRoofPlanes","LoadSystemDesign","scenarios","isChromatic","ZoomAndOrbit","getLeadCaptureAsyncEngineInit","propsForUseCad","designJson","renderMode","saveFormat","stateMode","ReadOnly","useCompassPosition","LowerRightCorner","Invisible","useMapView","useSimplePointerControls","useSimpleTouchControls","useStreetView","viewSettings","azimuthArrows","edges","ground","irradianceMap","irradianceMapPanels","lidar","mapImagery","mapView","measurements","projectCenter","setbacks","shadows","sky","streetView","sunpath","ambientOcclusion","autoDesigner","autoRoof","balanceOfSystem","compassToLowerRight","csvMonthly","datamodelLibrary","editSiteModel","fillZone","fitTreesToLidar","focusOnSelection","saveDesignJsonSchemaVersion2","walkway","reactiveRootId","reactiveNameLookup","WeakMap","isReactive","WeakSet","reactiveLookup","inertSetLookup","reactiveArrayOverridesLookup","reactiveSetOverridesLookup","reactiveMapOverridesLookup","decoupleReactiveFromOriginal","reactive","wrapDecoupled","isReactiveObjectEqual","reactiveOrMobX","inertSet","createReactiveMapOverrides","mobxMap","initialIndex","getItemKey","searchedValue","reactiveName","stringKey","existingKey","existingValue","isValueStoredAtKeyEqual","makeDeepReactive","createReactive","inert","mobxObject","reactiveProxyHandler","seenObjects","currentPath","currentRootId","createDefaultReactiveName","mobxArray","searchElement","fromIndex","foundIndex","foundItem","lastIndexOf","reactiveItem","start","rest","newRestItems","fill","end","createReactiveArrayOverrides","mobxSet","createReactiveSetOverrides","reactiveKey","reactiveValue","mobxDescriptor","receiver","reactiveArrayOverrides","reactiveSetOverrides","reactiveMapOverrides","currentReactiveValue","deepAccessReactive","deepCloneReactiveToInert","seenObject","newObject","runEffect","generateUuid","useInterceptMouse","cadDomNode","clicked","setClicked","onMouse","capture","FileResultType","FileResultUploadStatus","SupportedMimeTypes","getFileResultType","GIF","JPEG","PNG","WEBP","HEIC","DXF","DWG","IMAGE","PDF","DOCUMENT","UNKNOWN","getFileSizeFormatted","fileSize","kbSize","mbSize","getRandomValues","rnds8","Uint8Array","rng","crypto","msCrypto","uuid","byteToHex","substr","offset","toLowerCase","buf","rnds","random"],"sourceRoot":""}