@epignosis_llc/gnosis 2.1.7 → 2.2.1

package/dist/esm/node_modules/framer-motion/dist/es/render/html/utils/scrape-motion-values.mjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrape-motion-values.mjs.js","sources":["../../../../../../../../../node_modules/framer-motion/dist/es/render/html/utils/scrape-motion-values.mjs"],"sourcesContent":["import { isForcedMotionValue } from '../../../motion/utils/is-forced-motion-value.mjs';\nimport { isMotionValue } from '../../../value/utils/is-motion-value.mjs';\n\nfunction scrapeMotionValuesFromProps(props) {\n    var style = props.style;\n    var newValues = {};\n    for (var key in style) {\n        if (isMotionValue(style[key]) || isForcedMotionValue(key, props)) {\n            newValues[key] = style[key];\n        }\n    }\n    return newValues;\n}\n\nexport { scrapeMotionValuesFromProps };\n"],"names":[],"mappings":";;;;;;;;;;;AAGA,SAAS,2BAA2B,CAAC,KAAK,EAAE;AAC5C,IAAI,IAAI,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;AAC5B,IAAI,IAAI,SAAS,GAAG,EAAE,CAAC;AACvB,IAAI,KAAK,IAAI,GAAG,IAAI,KAAK,EAAE;AAC3B,QAAQ,IAAI,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,mBAAmB,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE;AAC1E,YAAY,SAAS,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;AACxC,SAAS;AACT,KAAK;AACL,IAAI,OAAO,SAAS,CAAC;AACrB;;;;"}

package/dist/esm/node_modules/framer-motion/dist/es/render/html/utils/transform.mjs.js

@@ -0,0 +1,50 @@
+
+  /**
+   * @license
+   * author: epignosis front-end team
+   * @epignosis_llc/gnosis.js v2.2.0
+   * Released under the MIT license.
+   */
+
+/**
+ * A list of all transformable axes. We'll use this list to generated a version
+ * of each axes for each transform.
+ */
+var transformAxes = ["", "X", "Y", "Z"];
+/**
+ * An ordered array of each transformable value. By default, transform values
+ * will be sorted to this order.
+ */
+var order = ["translate", "scale", "rotate", "skew"];
+/**
+ * Generate a list of every possible transform key.
+ */
+var transformProps = ["transformPerspective", "x", "y", "z"];
+order.forEach(function (operationKey) {
+    return transformAxes.forEach(function (axesKey) {
+        return transformProps.push(operationKey + axesKey);
+    });
+});
+/**
+ * A function to use with Array.sort to sort transform keys by their default order.
+ */
+function sortTransformProps(a, b) {
+    return transformProps.indexOf(a) - transformProps.indexOf(b);
+}
+/**
+ * A quick lookup for transform props.
+ */
+var transformPropSet = new Set(transformProps);
+function isTransformProp(key) {
+    return transformPropSet.has(key);
+}
+/**
+ * A quick lookup for transform origin props
+ */
+var transformOriginProps = new Set(["originX", "originY", "originZ"]);
+function isTransformOriginProp(key) {
+    return transformOriginProps.has(key);
+}
+
+export { isTransformOriginProp, isTransformProp, sortTransformProps, transformAxes, transformProps };
+//# sourceMappingURL=transform.mjs.js.map

package/dist/esm/node_modules/framer-motion/dist/es/render/html/utils/transform.mjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.mjs.js","sources":["../../../../../../../../../node_modules/framer-motion/dist/es/render/html/utils/transform.mjs"],"sourcesContent":["/**\n * A list of all transformable axes. We'll use this list to generated a version\n * of each axes for each transform.\n */\nvar transformAxes = [\"\", \"X\", \"Y\", \"Z\"];\n/**\n * An ordered array of each transformable value. By default, transform values\n * will be sorted to this order.\n */\nvar order = [\"translate\", \"scale\", \"rotate\", \"skew\"];\n/**\n * Generate a list of every possible transform key.\n */\nvar transformProps = [\"transformPerspective\", \"x\", \"y\", \"z\"];\norder.forEach(function (operationKey) {\n    return transformAxes.forEach(function (axesKey) {\n        return transformProps.push(operationKey + axesKey);\n    });\n});\n/**\n * A function to use with Array.sort to sort transform keys by their default order.\n */\nfunction sortTransformProps(a, b) {\n    return transformProps.indexOf(a) - transformProps.indexOf(b);\n}\n/**\n * A quick lookup for transform props.\n */\nvar transformPropSet = new Set(transformProps);\nfunction isTransformProp(key) {\n    return transformPropSet.has(key);\n}\n/**\n * A quick lookup for transform origin props\n */\nvar transformOriginProps = new Set([\"originX\", \"originY\", \"originZ\"]);\nfunction isTransformOriginProp(key) {\n    return transformOriginProps.has(key);\n}\n\nexport { isTransformOriginProp, isTransformProp, sortTransformProps, transformAxes, transformProps };\n"],"names":[],"mappings":";;;;;;;;AAAA;AACA;AACA;AACA;AACG,IAAC,aAAa,GAAG,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE;AACxC;AACA;AACA;AACA;AACA,IAAI,KAAK,GAAG,CAAC,WAAW,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;AACrD;AACA;AACA;AACG,IAAC,cAAc,GAAG,CAAC,sBAAsB,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE;AAC7D,KAAK,CAAC,OAAO,CAAC,UAAU,YAAY,EAAE;AACtC,IAAI,OAAO,aAAa,CAAC,OAAO,CAAC,UAAU,OAAO,EAAE;AACpD,QAAQ,OAAO,cAAc,CAAC,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,CAAC;AAC3D,KAAK,CAAC,CAAC;AACP,CAAC,CAAC,CAAC;AACH;AACA;AACA;AACA,SAAS,kBAAkB,CAAC,CAAC,EAAE,CAAC,EAAE;AAClC,IAAI,OAAO,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;AACjE,CAAC;AACD;AACA;AACA;AACA,IAAI,gBAAgB,GAAG,IAAI,GAAG,CAAC,cAAc,CAAC,CAAC;AAC/C,SAAS,eAAe,CAAC,GAAG,EAAE;AAC9B,IAAI,OAAO,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACrC,CAAC;AACD;AACA;AACA;AACA,IAAI,oBAAoB,GAAG,IAAI,GAAG,CAAC,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC;AACtE,SAAS,qBAAqB,CAAC,GAAG,EAAE;AACpC,IAAI,OAAO,oBAAoB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACzC;;;;"}

package/dist/esm/node_modules/framer-motion/dist/es/render/html/visual-element.mjs.js

@@ -0,0 +1,119 @@
+
+  /**
+   * @license
+   * author: epignosis front-end team
+   * @epignosis_llc/gnosis.js v2.2.0
+   * Released under the MIT license.
+   */
+
+import { __rest, __assign } from '../../../../../tslib/tslib.es6.js';
+import { visualElement } from '../index.mjs.js';
+import { getOrigin, checkTargetForNewValues } from '../utils/setters.mjs.js';
+import { buildHTMLStyles } from './utils/build-styles.mjs.js';
+import { isCSSVariable } from '../dom/utils/is-css-variable.mjs.js';
+import { parseDomVariant } from '../dom/utils/parse-dom-variant.mjs.js';
+import { isTransformProp } from './utils/transform.mjs.js';
+import { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs.js';
+import { renderHTML } from './utils/render.mjs.js';
+import { getDefaultValueType } from '../dom/value-types/defaults.mjs.js';
+import { measureViewportBox } from '../../projection/utils/measure.mjs.js';
+
+function getComputedStyle(element) {
+    return window.getComputedStyle(element);
+}
+var htmlConfig = {
+    treeType: "dom",
+    readValueFromInstance: function (domElement, key) {
+        if (isTransformProp(key)) {
+            var defaultType = getDefaultValueType(key);
+            return defaultType ? defaultType.default || 0 : 0;
+        }
+        else {
+            var computedStyle = getComputedStyle(domElement);
+            return ((isCSSVariable(key)
+                ? computedStyle.getPropertyValue(key)
+                : computedStyle[key]) || 0);
+        }
+    },
+    sortNodePosition: function (a, b) {
+        /**
+         * compareDocumentPosition returns a bitmask, by using the bitwise &
+         * we're returning true if 2 in that bitmask is set to true. 2 is set
+         * to true if b preceeds a.
+         */
+        return a.compareDocumentPosition(b) & 2 ? 1 : -1;
+    },
+    getBaseTarget: function (props, key) {
+        var _a;
+        return (_a = props.style) === null || _a === void 0 ? void 0 : _a[key];
+    },
+    measureViewportBox: function (element, _a) {
+        var transformPagePoint = _a.transformPagePoint;
+        return measureViewportBox(element, transformPagePoint);
+    },
+    /**
+     * Reset the transform on the current Element. This is called as part
+     * of a batched process across the entire layout tree. To remove this write
+     * cycle it'd be interesting to see if it's possible to "undo" all the current
+     * layout transforms up the tree in the same way this.getBoundingBoxWithoutTransforms
+     * works
+     */
+    resetTransform: function (element, domElement, props) {
+        var transformTemplate = props.transformTemplate;
+        domElement.style.transform = transformTemplate
+            ? transformTemplate({}, "")
+            : "none";
+        // Ensure that whatever happens next, we restore our transform on the next frame
+        element.scheduleRender();
+    },
+    restoreTransform: function (instance, mutableState) {
+        instance.style.transform = mutableState.style.transform;
+    },
+    removeValueFromRenderState: function (key, _a) {
+        var vars = _a.vars, style = _a.style;
+        delete vars[key];
+        delete style[key];
+    },
+    /**
+     * Ensure that HTML and Framer-specific value types like `px`->`%` and `Color`
+     * can be animated by Motion.
+     */
+    makeTargetAnimatable: function (element, _a, _b, isMounted) {
+        var transformValues = _b.transformValues;
+        if (isMounted === void 0) { isMounted = true; }
+        var transition = _a.transition, transitionEnd = _a.transitionEnd, target = __rest(_a, ["transition", "transitionEnd"]);
+        var origin = getOrigin(target, transition || {}, element);
+        /**
+         * If Framer has provided a function to convert `Color` etc value types, convert them
+         */
+        if (transformValues) {
+            if (transitionEnd)
+                transitionEnd = transformValues(transitionEnd);
+            if (target)
+                target = transformValues(target);
+            if (origin)
+                origin = transformValues(origin);
+        }
+        if (isMounted) {
+            checkTargetForNewValues(element, target, origin);
+            var parsed = parseDomVariant(element, target, origin, transitionEnd);
+            transitionEnd = parsed.transitionEnd;
+            target = parsed.target;
+        }
+        return __assign({ transition: transition, transitionEnd: transitionEnd }, target);
+    },
+    scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,
+    build: function (element, renderState, latestValues, options, props) {
+        if (element.isVisible !== undefined) {
+            renderState.style.visibility = element.isVisible
+                ? "visible"
+                : "hidden";
+        }
+        buildHTMLStyles(renderState, latestValues, options, props.transformTemplate);
+    },
+    render: renderHTML,
+};
+var htmlVisualElement = visualElement(htmlConfig);
+
+export { getComputedStyle, htmlConfig, htmlVisualElement };
+//# sourceMappingURL=visual-element.mjs.js.map

package/dist/esm/node_modules/framer-motion/dist/es/render/html/visual-element.mjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visual-element.mjs.js","sources":["../../../../../../../../node_modules/framer-motion/dist/es/render/html/visual-element.mjs"],"sourcesContent":["import { __rest, __assign } from 'tslib';\nimport { visualElement } from '../index.mjs';\nimport { getOrigin, checkTargetForNewValues } from '../utils/setters.mjs';\nimport { buildHTMLStyles } from './utils/build-styles.mjs';\nimport { isCSSVariable } from '../dom/utils/is-css-variable.mjs';\nimport { parseDomVariant } from '../dom/utils/parse-dom-variant.mjs';\nimport { isTransformProp } from './utils/transform.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { renderHTML } from './utils/render.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\nimport { measureViewportBox } from '../../projection/utils/measure.mjs';\n\nfunction getComputedStyle(element) {\n    return window.getComputedStyle(element);\n}\nvar htmlConfig = {\n    treeType: \"dom\",\n    readValueFromInstance: function (domElement, key) {\n        if (isTransformProp(key)) {\n            var defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 0;\n        }\n        else {\n            var computedStyle = getComputedStyle(domElement);\n            return ((isCSSVariable(key)\n                ? computedStyle.getPropertyValue(key)\n                : computedStyle[key]) || 0);\n        }\n    },\n    sortNodePosition: function (a, b) {\n        /**\n         * compareDocumentPosition returns a bitmask, by using the bitwise &\n         * we're returning true if 2 in that bitmask is set to true. 2 is set\n         * to true if b preceeds a.\n         */\n        return a.compareDocumentPosition(b) & 2 ? 1 : -1;\n    },\n    getBaseTarget: function (props, key) {\n        var _a;\n        return (_a = props.style) === null || _a === void 0 ? void 0 : _a[key];\n    },\n    measureViewportBox: function (element, _a) {\n        var transformPagePoint = _a.transformPagePoint;\n        return measureViewportBox(element, transformPagePoint);\n    },\n    /**\n     * Reset the transform on the current Element. This is called as part\n     * of a batched process across the entire layout tree. To remove this write\n     * cycle it'd be interesting to see if it's possible to \"undo\" all the current\n     * layout transforms up the tree in the same way this.getBoundingBoxWithoutTransforms\n     * works\n     */\n    resetTransform: function (element, domElement, props) {\n        var transformTemplate = props.transformTemplate;\n        domElement.style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        // Ensure that whatever happens next, we restore our transform on the next frame\n        element.scheduleRender();\n    },\n    restoreTransform: function (instance, mutableState) {\n        instance.style.transform = mutableState.style.transform;\n    },\n    removeValueFromRenderState: function (key, _a) {\n        var vars = _a.vars, style = _a.style;\n        delete vars[key];\n        delete style[key];\n    },\n    /**\n     * Ensure that HTML and Framer-specific value types like `px`->`%` and `Color`\n     * can be animated by Motion.\n     */\n    makeTargetAnimatable: function (element, _a, _b, isMounted) {\n        var transformValues = _b.transformValues;\n        if (isMounted === void 0) { isMounted = true; }\n        var transition = _a.transition, transitionEnd = _a.transitionEnd, target = __rest(_a, [\"transition\", \"transitionEnd\"]);\n        var origin = getOrigin(target, transition || {}, element);\n        /**\n         * If Framer has provided a function to convert `Color` etc value types, convert them\n         */\n        if (transformValues) {\n            if (transitionEnd)\n                transitionEnd = transformValues(transitionEnd);\n            if (target)\n                target = transformValues(target);\n            if (origin)\n                origin = transformValues(origin);\n        }\n        if (isMounted) {\n            checkTargetForNewValues(element, target, origin);\n            var parsed = parseDomVariant(element, target, origin, transitionEnd);\n            transitionEnd = parsed.transitionEnd;\n            target = parsed.target;\n        }\n        return __assign({ transition: transition, transitionEnd: transitionEnd }, target);\n    },\n    scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n    build: function (element, renderState, latestValues, options, props) {\n        if (element.isVisible !== undefined) {\n            renderState.style.visibility = element.isVisible\n                ? \"visible\"\n                : \"hidden\";\n        }\n        buildHTMLStyles(renderState, latestValues, options, props.transformTemplate);\n    },\n    render: renderHTML,\n};\nvar htmlVisualElement = visualElement(htmlConfig);\n\nexport { getComputedStyle, htmlConfig, htmlVisualElement };\n"],"names":[],"mappings":"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"}

package/dist/esm/node_modules/framer-motion/dist/es/render/index.mjs.js

@@ -0,0 +1,410 @@
+
+  /**
+   * @license
+   * author: epignosis front-end team
+   * @epignosis_llc/gnosis.js v2.2.0
+   * Released under the MIT license.
+   */
+
+import { __assign, __spreadArray, __read } from '../../../../tslib/tslib.es6.js';
+import sync, { cancelSync } from '../../../../framesync/dist/es/index.mjs.js';
+import { motionValue } from '../value/index.mjs.js';
+import { isMotionValue } from '../value/utils/is-motion-value.mjs.js';
+import { variantPriorityOrder } from './utils/animation-state.mjs.js';
+import { createLifecycles } from './utils/lifecycles.mjs.js';
+import { updateMotionValuesFromProps } from './utils/motion-values.mjs.js';
+import { checkIfControllingVariants, checkIfVariantNode, isVariantLabel } from './utils/variants.mjs.js';
+
+var visualElement = function (_a) {
+    var _b = _a.treeType, treeType = _b === void 0 ? "" : _b, build = _a.build, getBaseTarget = _a.getBaseTarget, makeTargetAnimatable = _a.makeTargetAnimatable, measureViewportBox = _a.measureViewportBox, renderInstance = _a.render, readValueFromInstance = _a.readValueFromInstance, removeValueFromRenderState = _a.removeValueFromRenderState, sortNodePosition = _a.sortNodePosition, scrapeMotionValuesFromProps = _a.scrapeMotionValuesFromProps;
+    return function (_a, options) {
+        var parent = _a.parent, props = _a.props, presenceId = _a.presenceId, blockInitialAnimation = _a.blockInitialAnimation, visualState = _a.visualState, shouldReduceMotion = _a.shouldReduceMotion;
+        if (options === void 0) { options = {}; }
+        var isMounted = false;
+        var latestValues = visualState.latestValues, renderState = visualState.renderState;
+        /**
+         * The instance of the render-specific node that will be hydrated by the
+         * exposed React ref. So for example, this visual element can host a
+         * HTMLElement, plain object, or Three.js object. The functions provided
+         * in VisualElementConfig allow us to interface with this instance.
+         */
+        var instance;
+        /**
+         * Manages the subscriptions for a visual element's lifecycle, for instance
+         * onRender
+         */
+        var lifecycles = createLifecycles();
+        /**
+         * A map of all motion values attached to this visual element. Motion
+         * values are source of truth for any given animated value. A motion
+         * value might be provided externally by the component via props.
+         */
+        var values = new Map();
+        /**
+         * A map of every subscription that binds the provided or generated
+         * motion values onChange listeners to this visual element.
+         */
+        var valueSubscriptions = new Map();
+        /**
+         * A reference to the previously-provided motion values as returned
+         * from scrapeMotionValuesFromProps. We use the keys in here to determine
+         * if any motion values need to be removed after props are updated.
+         */
+        var prevMotionValues = {};
+        /**
+         * When values are removed from all animation props we need to search
+         * for a fallback value to animate to. These values are tracked in baseTarget.
+         */
+        var baseTarget = __assign({}, latestValues);
+        // Internal methods ========================
+        /**
+         * On mount, this will be hydrated with a callback to disconnect
+         * this visual element from its parent on unmount.
+         */
+        var removeFromVariantTree;
+        /**
+         * Render the element with the latest styles outside of the React
+         * render lifecycle
+         */
+        function render() {
+            if (!instance || !isMounted)
+                return;
+            triggerBuild();
+            renderInstance(instance, renderState, props.style, element.projection);
+        }
+        function triggerBuild() {
+            build(element, renderState, latestValues, options, props);
+        }
+        function update() {
+            lifecycles.notifyUpdate(latestValues);
+        }
+        /**
+         *
+         */
+        function bindToMotionValue(key, value) {
+            var removeOnChange = value.onChange(function (latestValue) {
+                latestValues[key] = latestValue;
+                props.onUpdate && sync.update(update, false, true);
+            });
+            var removeOnRenderRequest = value.onRenderRequest(element.scheduleRender);
+            valueSubscriptions.set(key, function () {
+                removeOnChange();
+                removeOnRenderRequest();
+            });
+        }
+        /**
+         * Any motion values that are provided to the element when created
+         * aren't yet bound to the element, as this would technically be impure.
+         * However, we iterate through the motion values and set them to the
+         * initial values for this component.
+         *
+         * TODO: This is impure and we should look at changing this to run on mount.
+         * Doing so will break some tests but this isn't neccessarily a breaking change,
+         * more a reflection of the test.
+         */
+        var initialMotionValues = scrapeMotionValuesFromProps(props);
+        for (var key in initialMotionValues) {
+            var value = initialMotionValues[key];
+            if (latestValues[key] !== undefined && isMotionValue(value)) {
+                value.set(latestValues[key], false);
+            }
+        }
+        /**
+         * Determine what role this visual element should take in the variant tree.
+         */
+        var isControllingVariants = checkIfControllingVariants(props);
+        var isVariantNode = checkIfVariantNode(props);
+        var element = __assign(__assign({ treeType: treeType, 
+            /**
+             * This is a mirror of the internal instance prop, which keeps
+             * VisualElement type-compatible with React's RefObject.
+             */
+            current: null, 
+            /**
+             * The depth of this visual element within the visual element tree.
+             */
+            depth: parent ? parent.depth + 1 : 0, parent: parent, children: new Set(), 
+            /**
+             *
+             */
+            presenceId: presenceId, shouldReduceMotion: shouldReduceMotion, 
+            /**
+             * If this component is part of the variant tree, it should track
+             * any children that are also part of the tree. This is essentially
+             * a shadow tree to simplify logic around how to stagger over children.
+             */
+            variantChildren: isVariantNode ? new Set() : undefined, 
+            /**
+             * Whether this instance is visible. This can be changed imperatively
+             * by the projection tree, is analogous to CSS's visibility in that
+             * hidden elements should take up layout, and needs enacting by the configured
+             * render function.
+             */
+            isVisible: undefined, 
+            /**
+             * Normally, if a component is controlled by a parent's variants, it can
+             * rely on that ancestor to trigger animations further down the tree.
+             * However, if a component is created after its parent is mounted, the parent
+             * won't trigger that mount animation so the child needs to.
+             *
+             * TODO: This might be better replaced with a method isParentMounted
+             */
+            manuallyAnimateOnMount: Boolean(parent === null || parent === void 0 ? void 0 : parent.isMounted()), 
+            /**
+             * This can be set by AnimatePresence to force components that mount
+             * at the same time as it to mount as if they have initial={false} set.
+             */
+            blockInitialAnimation: blockInitialAnimation, 
+            /**
+             * Determine whether this component has mounted yet. This is mostly used
+             * by variant children to determine whether they need to trigger their
+             * own animations on mount.
+             */
+            isMounted: function () { return Boolean(instance); }, mount: function (newInstance) {
+                isMounted = true;
+                instance = element.current = newInstance;
+                if (element.projection) {
+                    element.projection.mount(newInstance);
+                }
+                if (isVariantNode && parent && !isControllingVariants) {
+                    removeFromVariantTree = parent === null || parent === void 0 ? void 0 : parent.addVariantChild(element);
+                }
+                values.forEach(function (value, key) { return bindToMotionValue(key, value); });
+                parent === null || parent === void 0 ? void 0 : parent.children.add(element);
+                element.setProps(props);
+            }, 
+            /**
+             *
+             */
+            unmount: function () {
+                var _a;
+                (_a = element.projection) === null || _a === void 0 ? void 0 : _a.unmount();
+                cancelSync.update(update);
+                cancelSync.render(render);
+                valueSubscriptions.forEach(function (remove) { return remove(); });
+                removeFromVariantTree === null || removeFromVariantTree === void 0 ? void 0 : removeFromVariantTree();
+                parent === null || parent === void 0 ? void 0 : parent.children.delete(element);
+                lifecycles.clearAllListeners();
+                instance = undefined;
+                isMounted = false;
+            }, 
+            /**
+             * Add a child visual element to our set of children.
+             */
+            addVariantChild: function (child) {
+                var _a;
+                var closestVariantNode = element.getClosestVariantNode();
+                if (closestVariantNode) {
+                    (_a = closestVariantNode.variantChildren) === null || _a === void 0 ? void 0 : _a.add(child);
+                    return function () {
+                        return closestVariantNode.variantChildren.delete(child);
+                    };
+                }
+            }, sortNodePosition: function (other) {
+                /**
+                 * If these nodes aren't even of the same type we can't compare their depth.
+                 */
+                if (!sortNodePosition || treeType !== other.treeType)
+                    return 0;
+                return sortNodePosition(element.getInstance(), other.getInstance());
+            }, 
+            /**
+             * Returns the closest variant node in the tree starting from
+             * this visual element.
+             */
+            getClosestVariantNode: function () {
+                return isVariantNode ? element : parent === null || parent === void 0 ? void 0 : parent.getClosestVariantNode();
+            }, 
+            /**
+             * Expose the latest layoutId prop.
+             */
+            getLayoutId: function () { return props.layoutId; }, 
+            /**
+             * Returns the current instance.
+             */
+            getInstance: function () { return instance; }, 
+            /**
+             * Get/set the latest static values.
+             */
+            getStaticValue: function (key) { return latestValues[key]; }, setStaticValue: function (key, value) { return (latestValues[key] = value); }, 
+            /**
+             * Returns the latest motion value state. Currently only used to take
+             * a snapshot of the visual element - perhaps this can return the whole
+             * visual state
+             */
+            getLatestValues: function () { return latestValues; }, 
+            /**
+             * Set the visiblity of the visual element. If it's changed, schedule
+             * a render to reflect these changes.
+             */
+            setVisibility: function (visibility) {
+                if (element.isVisible === visibility)
+                    return;
+                element.isVisible = visibility;
+                element.scheduleRender();
+            }, 
+            /**
+             * Make a target animatable by Popmotion. For instance, if we're
+             * trying to animate width from 100px to 100vw we need to measure 100vw
+             * in pixels to determine what we really need to animate to. This is also
+             * pluggable to support Framer's custom value types like Color,
+             * and CSS variables.
+             */
+            makeTargetAnimatable: function (target, canMutate) {
+                if (canMutate === void 0) { canMutate = true; }
+                return makeTargetAnimatable(element, target, props, canMutate);
+            }, 
+            /**
+             * Measure the current viewport box with or without transforms.
+             * Only measures axis-aligned boxes, rotate and skew must be manually
+             * removed with a re-render to work.
+             */
+            measureViewportBox: function () {
+                return measureViewportBox(instance, props);
+            }, 
+            // Motion values ========================
+            /**
+             * Add a motion value and bind it to this visual element.
+             */
+            addValue: function (key, value) {
+                // Remove existing value if it exists
+                if (element.hasValue(key))
+                    element.removeValue(key);
+                values.set(key, value);
+                latestValues[key] = value.get();
+                bindToMotionValue(key, value);
+            }, 
+            /**
+             * Remove a motion value and unbind any active subscriptions.
+             */
+            removeValue: function (key) {
+                var _a;
+                values.delete(key);
+                (_a = valueSubscriptions.get(key)) === null || _a === void 0 ? void 0 : _a();
+                valueSubscriptions.delete(key);
+                delete latestValues[key];
+                removeValueFromRenderState(key, renderState);
+            }, 
+            /**
+             * Check whether we have a motion value for this key
+             */
+            hasValue: function (key) { return values.has(key); }, 
+            /**
+             * Get a motion value for this key. If called with a default
+             * value, we'll create one if none exists.
+             */
+            getValue: function (key, defaultValue) {
+                var value = values.get(key);
+                if (value === undefined && defaultValue !== undefined) {
+                    value = motionValue(defaultValue);
+                    element.addValue(key, value);
+                }
+                return value;
+            }, 
+            /**
+             * Iterate over our motion values.
+             */
+            forEachValue: function (callback) { return values.forEach(callback); }, 
+            /**
+             * If we're trying to animate to a previously unencountered value,
+             * we need to check for it in our state and as a last resort read it
+             * directly from the instance (which might have performance implications).
+             */
+            readValue: function (key) {
+                var _a;
+                return (_a = latestValues[key]) !== null && _a !== void 0 ? _a : readValueFromInstance(instance, key, options);
+            }, 
+            /**
+             * Set the base target to later animate back to. This is currently
+             * only hydrated on creation and when we first read a value.
+             */
+            setBaseTarget: function (key, value) {
+                baseTarget[key] = value;
+            }, 
+            /**
+             * Find the base target for a value thats been removed from all animation
+             * props.
+             */
+            getBaseTarget: function (key) {
+                if (getBaseTarget) {
+                    var target = getBaseTarget(props, key);
+                    if (target !== undefined && !isMotionValue(target))
+                        return target;
+                }
+                return baseTarget[key];
+            } }, lifecycles), { 
+            /**
+             * Build the renderer state based on the latest visual state.
+             */
+            build: function () {
+                triggerBuild();
+                return renderState;
+            }, 
+            /**
+             * Schedule a render on the next animation frame.
+             */
+            scheduleRender: function () {
+                sync.render(render, false, true);
+            }, 
+            /**
+             * Synchronously fire render. It's prefered that we batch renders but
+             * in many circumstances, like layout measurement, we need to run this
+             * synchronously. However in those instances other measures should be taken
+             * to batch reads/writes.
+             */
+            syncRender: render, 
+            /**
+             * Update the provided props. Ensure any newly-added motion values are
+             * added to our map, old ones removed, and listeners updated.
+             */
+            setProps: function (newProps) {
+                if (newProps.transformTemplate || props.transformTemplate) {
+                    element.scheduleRender();
+                }
+                props = newProps;
+                lifecycles.updatePropListeners(newProps);
+                prevMotionValues = updateMotionValuesFromProps(element, scrapeMotionValuesFromProps(props), prevMotionValues);
+            }, getProps: function () { return props; }, 
+            // Variants ==============================
+            /**
+             * Returns the variant definition with a given name.
+             */
+            getVariant: function (name) { var _a; return (_a = props.variants) === null || _a === void 0 ? void 0 : _a[name]; }, 
+            /**
+             * Returns the defined default transition on this component.
+             */
+            getDefaultTransition: function () { return props.transition; }, getTransformPagePoint: function () {
+                return props.transformPagePoint;
+            }, 
+            /**
+             * Used by child variant nodes to get the closest ancestor variant props.
+             */
+            getVariantContext: function (startAtParent) {
+                if (startAtParent === void 0) { startAtParent = false; }
+                if (startAtParent)
+                    return parent === null || parent === void 0 ? void 0 : parent.getVariantContext();
+                if (!isControllingVariants) {
+                    var context_1 = (parent === null || parent === void 0 ? void 0 : parent.getVariantContext()) || {};
+                    if (props.initial !== undefined) {
+                        context_1.initial = props.initial;
+                    }
+                    return context_1;
+                }
+                var context = {};
+                for (var i = 0; i < numVariantProps; i++) {
+                    var name_1 = variantProps[i];
+                    var prop = props[name_1];
+                    if (isVariantLabel(prop) || prop === false) {
+                        context[name_1] = prop;
+                    }
+                }
+                return context;
+            } });
+        return element;
+    };
+};
+var variantProps = __spreadArray(["initial"], __read(variantPriorityOrder), false);
+var numVariantProps = variantProps.length;
+
+export { visualElement };
+//# sourceMappingURL=index.mjs.js.map