main repo

node_modules/framer-motion/dist/cjs/client.js

@@ -0,0 +1,368 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var featureBundle = require('./feature-bundle-v2Gb94eA.js');
+require('react');
+require('motion-dom');
+require('motion-utils');
+require('react/jsx-runtime');
+
+function createMotionComponentWithFeatures(Component, options) {
+    return featureBundle.createMotionComponent(Component, options, featureBundle.featureBundle, featureBundle.createDomVisualElement);
+}
+
+/**
+ * HTML components
+ */
+const MotionA = /*@__PURE__*/ createMotionComponentWithFeatures("a");
+const MotionAbbr = /*@__PURE__*/ createMotionComponentWithFeatures("abbr");
+const MotionAddress = /*@__PURE__*/ createMotionComponentWithFeatures("address");
+const MotionArea = /*@__PURE__*/ createMotionComponentWithFeatures("area");
+const MotionArticle = /*@__PURE__*/ createMotionComponentWithFeatures("article");
+const MotionAside = /*@__PURE__*/ createMotionComponentWithFeatures("aside");
+const MotionAudio = /*@__PURE__*/ createMotionComponentWithFeatures("audio");
+const MotionB = /*@__PURE__*/ createMotionComponentWithFeatures("b");
+const MotionBase = /*@__PURE__*/ createMotionComponentWithFeatures("base");
+const MotionBdi = /*@__PURE__*/ createMotionComponentWithFeatures("bdi");
+const MotionBdo = /*@__PURE__*/ createMotionComponentWithFeatures("bdo");
+const MotionBig = /*@__PURE__*/ createMotionComponentWithFeatures("big");
+const MotionBlockquote = 
+/*@__PURE__*/ createMotionComponentWithFeatures("blockquote");
+const MotionBody = /*@__PURE__*/ createMotionComponentWithFeatures("body");
+const MotionButton = /*@__PURE__*/ createMotionComponentWithFeatures("button");
+const MotionCanvas = /*@__PURE__*/ createMotionComponentWithFeatures("canvas");
+const MotionCaption = /*@__PURE__*/ createMotionComponentWithFeatures("caption");
+const MotionCite = /*@__PURE__*/ createMotionComponentWithFeatures("cite");
+const MotionCode = /*@__PURE__*/ createMotionComponentWithFeatures("code");
+const MotionCol = /*@__PURE__*/ createMotionComponentWithFeatures("col");
+const MotionColgroup = /*@__PURE__*/ createMotionComponentWithFeatures("colgroup");
+const MotionData = /*@__PURE__*/ createMotionComponentWithFeatures("data");
+const MotionDatalist = /*@__PURE__*/ createMotionComponentWithFeatures("datalist");
+const MotionDd = /*@__PURE__*/ createMotionComponentWithFeatures("dd");
+const MotionDel = /*@__PURE__*/ createMotionComponentWithFeatures("del");
+const MotionDetails = /*@__PURE__*/ createMotionComponentWithFeatures("details");
+const MotionDfn = /*@__PURE__*/ createMotionComponentWithFeatures("dfn");
+const MotionDialog = /*@__PURE__*/ createMotionComponentWithFeatures("dialog");
+const MotionDiv = /*@__PURE__*/ createMotionComponentWithFeatures("div");
+const MotionDl = /*@__PURE__*/ createMotionComponentWithFeatures("dl");
+const MotionDt = /*@__PURE__*/ createMotionComponentWithFeatures("dt");
+const MotionEm = /*@__PURE__*/ createMotionComponentWithFeatures("em");
+const MotionEmbed = /*@__PURE__*/ createMotionComponentWithFeatures("embed");
+const MotionFieldset = /*@__PURE__*/ createMotionComponentWithFeatures("fieldset");
+const MotionFigcaption = 
+/*@__PURE__*/ createMotionComponentWithFeatures("figcaption");
+const MotionFigure = /*@__PURE__*/ createMotionComponentWithFeatures("figure");
+const MotionFooter = /*@__PURE__*/ createMotionComponentWithFeatures("footer");
+const MotionForm = /*@__PURE__*/ createMotionComponentWithFeatures("form");
+const MotionH1 = /*@__PURE__*/ createMotionComponentWithFeatures("h1");
+const MotionH2 = /*@__PURE__*/ createMotionComponentWithFeatures("h2");
+const MotionH3 = /*@__PURE__*/ createMotionComponentWithFeatures("h3");
+const MotionH4 = /*@__PURE__*/ createMotionComponentWithFeatures("h4");
+const MotionH5 = /*@__PURE__*/ createMotionComponentWithFeatures("h5");
+const MotionH6 = /*@__PURE__*/ createMotionComponentWithFeatures("h6");
+const MotionHead = /*@__PURE__*/ createMotionComponentWithFeatures("head");
+const MotionHeader = /*@__PURE__*/ createMotionComponentWithFeatures("header");
+const MotionHgroup = /*@__PURE__*/ createMotionComponentWithFeatures("hgroup");
+const MotionHr = /*@__PURE__*/ createMotionComponentWithFeatures("hr");
+const MotionHtml = /*@__PURE__*/ createMotionComponentWithFeatures("html");
+const MotionI = /*@__PURE__*/ createMotionComponentWithFeatures("i");
+const MotionIframe = /*@__PURE__*/ createMotionComponentWithFeatures("iframe");
+const MotionImg = /*@__PURE__*/ createMotionComponentWithFeatures("img");
+const MotionInput = /*@__PURE__*/ createMotionComponentWithFeatures("input");
+const MotionIns = /*@__PURE__*/ createMotionComponentWithFeatures("ins");
+const MotionKbd = /*@__PURE__*/ createMotionComponentWithFeatures("kbd");
+const MotionKeygen = /*@__PURE__*/ createMotionComponentWithFeatures("keygen");
+const MotionLabel = /*@__PURE__*/ createMotionComponentWithFeatures("label");
+const MotionLegend = /*@__PURE__*/ createMotionComponentWithFeatures("legend");
+const MotionLi = /*@__PURE__*/ createMotionComponentWithFeatures("li");
+const MotionLink = /*@__PURE__*/ createMotionComponentWithFeatures("link");
+const MotionMain = /*@__PURE__*/ createMotionComponentWithFeatures("main");
+const MotionMap = /*@__PURE__*/ createMotionComponentWithFeatures("map");
+const MotionMark = /*@__PURE__*/ createMotionComponentWithFeatures("mark");
+const MotionMenu = /*@__PURE__*/ createMotionComponentWithFeatures("menu");
+const MotionMenuitem = /*@__PURE__*/ createMotionComponentWithFeatures("menuitem");
+const MotionMeter = /*@__PURE__*/ createMotionComponentWithFeatures("meter");
+const MotionNav = /*@__PURE__*/ createMotionComponentWithFeatures("nav");
+const MotionObject = /*@__PURE__*/ createMotionComponentWithFeatures("object");
+const MotionOl = /*@__PURE__*/ createMotionComponentWithFeatures("ol");
+const MotionOptgroup = /*@__PURE__*/ createMotionComponentWithFeatures("optgroup");
+const MotionOption = /*@__PURE__*/ createMotionComponentWithFeatures("option");
+const MotionOutput = /*@__PURE__*/ createMotionComponentWithFeatures("output");
+const MotionP = /*@__PURE__*/ createMotionComponentWithFeatures("p");
+const MotionParam = /*@__PURE__*/ createMotionComponentWithFeatures("param");
+const MotionPicture = /*@__PURE__*/ createMotionComponentWithFeatures("picture");
+const MotionPre = /*@__PURE__*/ createMotionComponentWithFeatures("pre");
+const MotionProgress = /*@__PURE__*/ createMotionComponentWithFeatures("progress");
+const MotionQ = /*@__PURE__*/ createMotionComponentWithFeatures("q");
+const MotionRp = /*@__PURE__*/ createMotionComponentWithFeatures("rp");
+const MotionRt = /*@__PURE__*/ createMotionComponentWithFeatures("rt");
+const MotionRuby = /*@__PURE__*/ createMotionComponentWithFeatures("ruby");
+const MotionS = /*@__PURE__*/ createMotionComponentWithFeatures("s");
+const MotionSamp = /*@__PURE__*/ createMotionComponentWithFeatures("samp");
+const MotionScript = /*@__PURE__*/ createMotionComponentWithFeatures("script");
+const MotionSection = /*@__PURE__*/ createMotionComponentWithFeatures("section");
+const MotionSelect = /*@__PURE__*/ createMotionComponentWithFeatures("select");
+const MotionSmall = /*@__PURE__*/ createMotionComponentWithFeatures("small");
+const MotionSource = /*@__PURE__*/ createMotionComponentWithFeatures("source");
+const MotionSpan = /*@__PURE__*/ createMotionComponentWithFeatures("span");
+const MotionStrong = /*@__PURE__*/ createMotionComponentWithFeatures("strong");
+const MotionStyle = /*@__PURE__*/ createMotionComponentWithFeatures("style");
+const MotionSub = /*@__PURE__*/ createMotionComponentWithFeatures("sub");
+const MotionSummary = /*@__PURE__*/ createMotionComponentWithFeatures("summary");
+const MotionSup = /*@__PURE__*/ createMotionComponentWithFeatures("sup");
+const MotionTable = /*@__PURE__*/ createMotionComponentWithFeatures("table");
+const MotionTbody = /*@__PURE__*/ createMotionComponentWithFeatures("tbody");
+const MotionTd = /*@__PURE__*/ createMotionComponentWithFeatures("td");
+const MotionTextarea = /*@__PURE__*/ createMotionComponentWithFeatures("textarea");
+const MotionTfoot = /*@__PURE__*/ createMotionComponentWithFeatures("tfoot");
+const MotionTh = /*@__PURE__*/ createMotionComponentWithFeatures("th");
+const MotionThead = /*@__PURE__*/ createMotionComponentWithFeatures("thead");
+const MotionTime = /*@__PURE__*/ createMotionComponentWithFeatures("time");
+const MotionTitle = /*@__PURE__*/ createMotionComponentWithFeatures("title");
+const MotionTr = /*@__PURE__*/ createMotionComponentWithFeatures("tr");
+const MotionTrack = /*@__PURE__*/ createMotionComponentWithFeatures("track");
+const MotionU = /*@__PURE__*/ createMotionComponentWithFeatures("u");
+const MotionUl = /*@__PURE__*/ createMotionComponentWithFeatures("ul");
+const MotionVideo = /*@__PURE__*/ createMotionComponentWithFeatures("video");
+const MotionWbr = /*@__PURE__*/ createMotionComponentWithFeatures("wbr");
+const MotionWebview = /*@__PURE__*/ createMotionComponentWithFeatures("webview");
+/**
+ * SVG components
+ */
+const MotionAnimate = /*@__PURE__*/ createMotionComponentWithFeatures("animate");
+const MotionCircle = /*@__PURE__*/ createMotionComponentWithFeatures("circle");
+const MotionDefs = /*@__PURE__*/ createMotionComponentWithFeatures("defs");
+const MotionDesc = /*@__PURE__*/ createMotionComponentWithFeatures("desc");
+const MotionEllipse = /*@__PURE__*/ createMotionComponentWithFeatures("ellipse");
+const MotionG = /*@__PURE__*/ createMotionComponentWithFeatures("g");
+const MotionImage = /*@__PURE__*/ createMotionComponentWithFeatures("image");
+const MotionLine = /*@__PURE__*/ createMotionComponentWithFeatures("line");
+const MotionFilter = /*@__PURE__*/ createMotionComponentWithFeatures("filter");
+const MotionMarker = /*@__PURE__*/ createMotionComponentWithFeatures("marker");
+const MotionMask = /*@__PURE__*/ createMotionComponentWithFeatures("mask");
+const MotionMetadata = /*@__PURE__*/ createMotionComponentWithFeatures("metadata");
+const MotionPath = /*@__PURE__*/ createMotionComponentWithFeatures("path");
+const MotionPattern = /*@__PURE__*/ createMotionComponentWithFeatures("pattern");
+const MotionPolygon = /*@__PURE__*/ createMotionComponentWithFeatures("polygon");
+const MotionPolyline = /*@__PURE__*/ createMotionComponentWithFeatures("polyline");
+const MotionRect = /*@__PURE__*/ createMotionComponentWithFeatures("rect");
+const MotionStop = /*@__PURE__*/ createMotionComponentWithFeatures("stop");
+const MotionSvg = /*@__PURE__*/ createMotionComponentWithFeatures("svg");
+const MotionSymbol = /*@__PURE__*/ createMotionComponentWithFeatures("symbol");
+const MotionText = /*@__PURE__*/ createMotionComponentWithFeatures("text");
+const MotionTspan = /*@__PURE__*/ createMotionComponentWithFeatures("tspan");
+const MotionUse = /*@__PURE__*/ createMotionComponentWithFeatures("use");
+const MotionView = /*@__PURE__*/ createMotionComponentWithFeatures("view");
+const MotionClipPath = /*@__PURE__*/ createMotionComponentWithFeatures("clipPath");
+const MotionFeBlend = /*@__PURE__*/ createMotionComponentWithFeatures("feBlend");
+const MotionFeColorMatrix = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feColorMatrix");
+const MotionFeComponentTransfer = /*@__PURE__*/ createMotionComponentWithFeatures("feComponentTransfer");
+const MotionFeComposite = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feComposite");
+const MotionFeConvolveMatrix = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feConvolveMatrix");
+const MotionFeDiffuseLighting = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feDiffuseLighting");
+const MotionFeDisplacementMap = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feDisplacementMap");
+const MotionFeDistantLight = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feDistantLight");
+const MotionFeDropShadow = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feDropShadow");
+const MotionFeFlood = /*@__PURE__*/ createMotionComponentWithFeatures("feFlood");
+const MotionFeFuncA = /*@__PURE__*/ createMotionComponentWithFeatures("feFuncA");
+const MotionFeFuncB = /*@__PURE__*/ createMotionComponentWithFeatures("feFuncB");
+const MotionFeFuncG = /*@__PURE__*/ createMotionComponentWithFeatures("feFuncG");
+const MotionFeFuncR = /*@__PURE__*/ createMotionComponentWithFeatures("feFuncR");
+const MotionFeGaussianBlur = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feGaussianBlur");
+const MotionFeImage = /*@__PURE__*/ createMotionComponentWithFeatures("feImage");
+const MotionFeMerge = /*@__PURE__*/ createMotionComponentWithFeatures("feMerge");
+const MotionFeMergeNode = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feMergeNode");
+const MotionFeMorphology = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feMorphology");
+const MotionFeOffset = /*@__PURE__*/ createMotionComponentWithFeatures("feOffset");
+const MotionFePointLight = 
+/*@__PURE__*/ createMotionComponentWithFeatures("fePointLight");
+const MotionFeSpecularLighting = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feSpecularLighting");
+const MotionFeSpotLight = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feSpotLight");
+const MotionFeTile = /*@__PURE__*/ createMotionComponentWithFeatures("feTile");
+const MotionFeTurbulence = 
+/*@__PURE__*/ createMotionComponentWithFeatures("feTurbulence");
+const MotionForeignObject = 
+/*@__PURE__*/ createMotionComponentWithFeatures("foreignObject");
+const MotionLinearGradient = 
+/*@__PURE__*/ createMotionComponentWithFeatures("linearGradient");
+const MotionRadialGradient = 
+/*@__PURE__*/ createMotionComponentWithFeatures("radialGradient");
+const MotionTextPath = /*@__PURE__*/ createMotionComponentWithFeatures("textPath");
+
+exports.a = MotionA;
+exports.abbr = MotionAbbr;
+exports.address = MotionAddress;
+exports.animate = MotionAnimate;
+exports.area = MotionArea;
+exports.article = MotionArticle;
+exports.aside = MotionAside;
+exports.audio = MotionAudio;
+exports.b = MotionB;
+exports.base = MotionBase;
+exports.bdi = MotionBdi;
+exports.bdo = MotionBdo;
+exports.big = MotionBig;
+exports.blockquote = MotionBlockquote;
+exports.body = MotionBody;
+exports.button = MotionButton;
+exports.canvas = MotionCanvas;
+exports.caption = MotionCaption;
+exports.circle = MotionCircle;
+exports.cite = MotionCite;
+exports.clipPath = MotionClipPath;
+exports.code = MotionCode;
+exports.col = MotionCol;
+exports.colgroup = MotionColgroup;
+exports.data = MotionData;
+exports.datalist = MotionDatalist;
+exports.dd = MotionDd;
+exports.defs = MotionDefs;
+exports.del = MotionDel;
+exports.desc = MotionDesc;
+exports.details = MotionDetails;
+exports.dfn = MotionDfn;
+exports.dialog = MotionDialog;
+exports.div = MotionDiv;
+exports.dl = MotionDl;
+exports.dt = MotionDt;
+exports.ellipse = MotionEllipse;
+exports.em = MotionEm;
+exports.embed = MotionEmbed;
+exports.feBlend = MotionFeBlend;
+exports.feColorMatrix = MotionFeColorMatrix;
+exports.feComponentTransfer = MotionFeComponentTransfer;
+exports.feComposite = MotionFeComposite;
+exports.feConvolveMatrix = MotionFeConvolveMatrix;
+exports.feDiffuseLighting = MotionFeDiffuseLighting;
+exports.feDisplacementMap = MotionFeDisplacementMap;
+exports.feDistantLight = MotionFeDistantLight;
+exports.feDropShadow = MotionFeDropShadow;
+exports.feFlood = MotionFeFlood;
+exports.feFuncA = MotionFeFuncA;
+exports.feFuncB = MotionFeFuncB;
+exports.feFuncG = MotionFeFuncG;
+exports.feFuncR = MotionFeFuncR;
+exports.feGaussianBlur = MotionFeGaussianBlur;
+exports.feImage = MotionFeImage;
+exports.feMerge = MotionFeMerge;
+exports.feMergeNode = MotionFeMergeNode;
+exports.feMorphology = MotionFeMorphology;
+exports.feOffset = MotionFeOffset;
+exports.fePointLight = MotionFePointLight;
+exports.feSpecularLighting = MotionFeSpecularLighting;
+exports.feSpotLight = MotionFeSpotLight;
+exports.feTile = MotionFeTile;
+exports.feTurbulence = MotionFeTurbulence;
+exports.fieldset = MotionFieldset;
+exports.figcaption = MotionFigcaption;
+exports.figure = MotionFigure;
+exports.filter = MotionFilter;
+exports.footer = MotionFooter;
+exports.foreignObject = MotionForeignObject;
+exports.form = MotionForm;
+exports.g = MotionG;
+exports.h1 = MotionH1;
+exports.h2 = MotionH2;
+exports.h3 = MotionH3;
+exports.h4 = MotionH4;
+exports.h5 = MotionH5;
+exports.h6 = MotionH6;
+exports.head = MotionHead;
+exports.header = MotionHeader;
+exports.hgroup = MotionHgroup;
+exports.hr = MotionHr;
+exports.html = MotionHtml;
+exports.i = MotionI;
+exports.iframe = MotionIframe;
+exports.image = MotionImage;
+exports.img = MotionImg;
+exports.input = MotionInput;
+exports.ins = MotionIns;
+exports.kbd = MotionKbd;
+exports.keygen = MotionKeygen;
+exports.label = MotionLabel;
+exports.legend = MotionLegend;
+exports.li = MotionLi;
+exports.line = MotionLine;
+exports.linearGradient = MotionLinearGradient;
+exports.link = MotionLink;
+exports.main = MotionMain;
+exports.map = MotionMap;
+exports.mark = MotionMark;
+exports.marker = MotionMarker;
+exports.mask = MotionMask;
+exports.menu = MotionMenu;
+exports.menuitem = MotionMenuitem;
+exports.metadata = MotionMetadata;
+exports.meter = MotionMeter;
+exports.nav = MotionNav;
+exports.object = MotionObject;
+exports.ol = MotionOl;
+exports.optgroup = MotionOptgroup;
+exports.option = MotionOption;
+exports.output = MotionOutput;
+exports.p = MotionP;
+exports.param = MotionParam;
+exports.path = MotionPath;
+exports.pattern = MotionPattern;
+exports.picture = MotionPicture;
+exports.polygon = MotionPolygon;
+exports.polyline = MotionPolyline;
+exports.pre = MotionPre;
+exports.progress = MotionProgress;
+exports.q = MotionQ;
+exports.radialGradient = MotionRadialGradient;
+exports.rect = MotionRect;
+exports.rp = MotionRp;
+exports.rt = MotionRt;
+exports.ruby = MotionRuby;
+exports.s = MotionS;
+exports.samp = MotionSamp;
+exports.script = MotionScript;
+exports.section = MotionSection;
+exports.select = MotionSelect;
+exports.small = MotionSmall;
+exports.source = MotionSource;
+exports.span = MotionSpan;
+exports.stop = MotionStop;
+exports.strong = MotionStrong;
+exports.style = MotionStyle;
+exports.sub = MotionSub;
+exports.summary = MotionSummary;
+exports.sup = MotionSup;
+exports.svg = MotionSvg;
+exports.symbol = MotionSymbol;
+exports.table = MotionTable;
+exports.tbody = MotionTbody;
+exports.td = MotionTd;
+exports.text = MotionText;
+exports.textPath = MotionTextPath;
+exports.textarea = MotionTextarea;
+exports.tfoot = MotionTfoot;
+exports.th = MotionTh;
+exports.thead = MotionThead;
+exports.time = MotionTime;
+exports.title = MotionTitle;
+exports.tr = MotionTr;
+exports.track = MotionTrack;
+exports.tspan = MotionTspan;
+exports.u = MotionU;
+exports.ul = MotionUl;
+exports.use = MotionUse;
+exports.video = MotionVideo;
+exports.view = MotionView;
+exports.wbr = MotionWbr;
+exports.webview = MotionWebview;

node_modules/framer-motion/dist/cjs/debug.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var motionDom = require('motion-dom');
+
+
+
+Object.defineProperty(exports, "recordStats", {
+	enumerable: true,
+	get: function () { return motionDom.recordStats; }
+});

node_modules/framer-motion/dist/cjs/dom-mini.js

@@ -0,0 +1,461 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var motionDom = require('motion-dom');
+var motionUtils = require('motion-utils');
+
+function isDOMKeyframes(keyframes) {
+    return typeof keyframes === "object" && !Array.isArray(keyframes);
+}
+
+function resolveSubjects(subject, keyframes, scope, selectorCache) {
+    if (typeof subject === "string" && isDOMKeyframes(keyframes)) {
+        return motionDom.resolveElements(subject, scope, selectorCache);
+    }
+    else if (subject instanceof NodeList) {
+        return Array.from(subject);
+    }
+    else if (Array.isArray(subject)) {
+        return subject;
+    }
+    else {
+        return [subject];
+    }
+}
+
+function calculateRepeatDuration(duration, repeat, _repeatDelay) {
+    return duration * (repeat + 1);
+}
+
+/**
+ * Given a absolute or relative time definition and current/prev time state of the sequence,
+ * calculate an absolute time for the next keyframes.
+ */
+function calcNextTime(current, next, prev, labels) {
+    if (typeof next === "number") {
+        return next;
+    }
+    else if (next.startsWith("-") || next.startsWith("+")) {
+        return Math.max(0, current + parseFloat(next));
+    }
+    else if (next === "<") {
+        return prev;
+    }
+    else if (next.startsWith("<")) {
+        return Math.max(0, prev + parseFloat(next.slice(1)));
+    }
+    else {
+        return labels.get(next) ?? current;
+    }
+}
+
+function eraseKeyframes(sequence, startTime, endTime) {
+    for (let i = 0; i < sequence.length; i++) {
+        const keyframe = sequence[i];
+        if (keyframe.at > startTime && keyframe.at < endTime) {
+            motionUtils.removeItem(sequence, keyframe);
+            // If we remove this item we have to push the pointer back one
+            i--;
+        }
+    }
+}
+function addKeyframes(sequence, keyframes, easing, offset, startTime, endTime) {
+    /**
+     * Erase every existing value between currentTime and targetTime,
+     * this will essentially splice this timeline into any currently
+     * defined ones.
+     */
+    eraseKeyframes(sequence, startTime, endTime);
+    for (let i = 0; i < keyframes.length; i++) {
+        sequence.push({
+            value: keyframes[i],
+            at: motionDom.mixNumber(startTime, endTime, offset[i]),
+            easing: motionUtils.getEasingForSegment(easing, i),
+        });
+    }
+}
+
+/**
+ * Take an array of times that represent repeated keyframes. For instance
+ * if we have original times of [0, 0.5, 1] then our repeated times will
+ * be [0, 0.5, 1, 1, 1.5, 2]. Loop over the times and scale them back
+ * down to a 0-1 scale.
+ */
+function normalizeTimes(times, repeat) {
+    for (let i = 0; i < times.length; i++) {
+        times[i] = times[i] / (repeat + 1);
+    }
+}
+
+function compareByTime(a, b) {
+    if (a.at === b.at) {
+        if (a.value === null)
+            return 1;
+        if (b.value === null)
+            return -1;
+        return 0;
+    }
+    else {
+        return a.at - b.at;
+    }
+}
+
+const defaultSegmentEasing = "easeInOut";
+const MAX_REPEAT = 20;
+function createAnimationsFromSequence(sequence, { defaultTransition = {}, ...sequenceTransition } = {}, scope, generators) {
+    const defaultDuration = defaultTransition.duration || 0.3;
+    const animationDefinitions = new Map();
+    const sequences = new Map();
+    const elementCache = {};
+    const timeLabels = new Map();
+    let prevTime = 0;
+    let currentTime = 0;
+    let totalDuration = 0;
+    /**
+     * Build the timeline by mapping over the sequence array and converting
+     * the definitions into keyframes and offsets with absolute time values.
+     * These will later get converted into relative offsets in a second pass.
+     */
+    for (let i = 0; i < sequence.length; i++) {
+        const segment = sequence[i];
+        /**
+         * If this is a timeline label, mark it and skip the rest of this iteration.
+         */
+        if (typeof segment === "string") {
+            timeLabels.set(segment, currentTime);
+            continue;
+        }
+        else if (!Array.isArray(segment)) {
+            timeLabels.set(segment.name, calcNextTime(currentTime, segment.at, prevTime, timeLabels));
+            continue;
+        }
+        let [subject, keyframes, transition = {}] = segment;
+        /**
+         * If a relative or absolute time value has been specified we need to resolve
+         * it in relation to the currentTime.
+         */
+        if (transition.at !== undefined) {
+            currentTime = calcNextTime(currentTime, transition.at, prevTime, timeLabels);
+        }
+        /**
+         * Keep track of the maximum duration in this definition. This will be
+         * applied to currentTime once the definition has been parsed.
+         */
+        let maxDuration = 0;
+        const resolveValueSequence = (valueKeyframes, valueTransition, valueSequence, elementIndex = 0, numSubjects = 0) => {
+            const valueKeyframesAsList = keyframesAsList(valueKeyframes);
+            const { delay = 0, times = motionDom.defaultOffset(valueKeyframesAsList), type = "keyframes", repeat, repeatType, repeatDelay = 0, ...remainingTransition } = valueTransition;
+            let { ease = defaultTransition.ease || "easeOut", duration } = valueTransition;
+            /**
+             * Resolve stagger() if defined.
+             */
+            const calculatedDelay = typeof delay === "function"
+                ? delay(elementIndex, numSubjects)
+                : delay;
+            /**
+             * If this animation should and can use a spring, generate a spring easing function.
+             */
+            const numKeyframes = valueKeyframesAsList.length;
+            const createGenerator = motionDom.isGenerator(type)
+                ? type
+                : generators?.[type || "keyframes"];
+            if (numKeyframes <= 2 && createGenerator) {
+                /**
+                 * As we're creating an easing function from a spring,
+                 * ideally we want to generate it using the real distance
+                 * between the two keyframes. However this isn't always
+                 * possible - in these situations we use 0-100.
+                 */
+                let absoluteDelta = 100;
+                if (numKeyframes === 2 &&
+                    isNumberKeyframesArray(valueKeyframesAsList)) {
+                    const delta = valueKeyframesAsList[1] - valueKeyframesAsList[0];
+                    absoluteDelta = Math.abs(delta);
+                }
+                const springTransition = { ...remainingTransition };
+                if (duration !== undefined) {
+                    springTransition.duration = motionUtils.secondsToMilliseconds(duration);
+                }
+                const springEasing = motionDom.createGeneratorEasing(springTransition, absoluteDelta, createGenerator);
+                ease = springEasing.ease;
+                duration = springEasing.duration;
+            }
+            duration ?? (duration = defaultDuration);
+            const startTime = currentTime + calculatedDelay;
+            /**
+             * If there's only one time offset of 0, fill in a second with length 1
+             */
+            if (times.length === 1 && times[0] === 0) {
+                times[1] = 1;
+            }
+            /**
+             * Fill out if offset if fewer offsets than keyframes
+             */
+            const remainder = times.length - valueKeyframesAsList.length;
+            remainder > 0 && motionDom.fillOffset(times, remainder);
+            /**
+             * If only one value has been set, ie [1], push a null to the start of
+             * the keyframe array. This will let us mark a keyframe at this point
+             * that will later be hydrated with the previous value.
+             */
+            valueKeyframesAsList.length === 1 &&
+                valueKeyframesAsList.unshift(null);
+            /**
+             * Handle repeat options
+             */
+            if (repeat) {
+                motionUtils.invariant(repeat < MAX_REPEAT, "Repeat count too high, must be less than 20", "repeat-count-high");
+                duration = calculateRepeatDuration(duration, repeat);
+                const originalKeyframes = [...valueKeyframesAsList];
+                const originalTimes = [...times];
+                ease = Array.isArray(ease) ? [...ease] : [ease];
+                const originalEase = [...ease];
+                for (let repeatIndex = 0; repeatIndex < repeat; repeatIndex++) {
+                    valueKeyframesAsList.push(...originalKeyframes);
+                    for (let keyframeIndex = 0; keyframeIndex < originalKeyframes.length; keyframeIndex++) {
+                        times.push(originalTimes[keyframeIndex] + (repeatIndex + 1));
+                        ease.push(keyframeIndex === 0
+                            ? "linear"
+                            : motionUtils.getEasingForSegment(originalEase, keyframeIndex - 1));
+                    }
+                }
+                normalizeTimes(times, repeat);
+            }
+            const targetTime = startTime + duration;
+            /**
+             * Add keyframes, mapping offsets to absolute time.
+             */
+            addKeyframes(valueSequence, valueKeyframesAsList, ease, times, startTime, targetTime);
+            maxDuration = Math.max(calculatedDelay + duration, maxDuration);
+            totalDuration = Math.max(targetTime, totalDuration);
+        };
+        if (motionDom.isMotionValue(subject)) {
+            const subjectSequence = getSubjectSequence(subject, sequences);
+            resolveValueSequence(keyframes, transition, getValueSequence("default", subjectSequence));
+        }
+        else {
+            const subjects = resolveSubjects(subject, keyframes, scope, elementCache);
+            const numSubjects = subjects.length;
+            /**
+             * For every element in this segment, process the defined values.
+             */
+            for (let subjectIndex = 0; subjectIndex < numSubjects; subjectIndex++) {
+                /**
+                 * Cast necessary, but we know these are of this type
+                 */
+                keyframes = keyframes;
+                transition = transition;
+                const thisSubject = subjects[subjectIndex];
+                const subjectSequence = getSubjectSequence(thisSubject, sequences);
+                for (const key in keyframes) {
+                    resolveValueSequence(keyframes[key], getValueTransition(transition, key), getValueSequence(key, subjectSequence), subjectIndex, numSubjects);
+                }
+            }
+        }
+        prevTime = currentTime;
+        currentTime += maxDuration;
+    }
+    /**
+     * For every element and value combination create a new animation.
+     */
+    sequences.forEach((valueSequences, element) => {
+        for (const key in valueSequences) {
+            const valueSequence = valueSequences[key];
+            /**
+             * Arrange all the keyframes in ascending time order.
+             */
+            valueSequence.sort(compareByTime);
+            const keyframes = [];
+            const valueOffset = [];
+            const valueEasing = [];
+            /**
+             * For each keyframe, translate absolute times into
+             * relative offsets based on the total duration of the timeline.
+             */
+            for (let i = 0; i < valueSequence.length; i++) {
+                const { at, value, easing } = valueSequence[i];
+                keyframes.push(value);
+                valueOffset.push(motionUtils.progress(0, totalDuration, at));
+                valueEasing.push(easing || "easeOut");
+            }
+            /**
+             * If the first keyframe doesn't land on offset: 0
+             * provide one by duplicating the initial keyframe. This ensures
+             * it snaps to the first keyframe when the animation starts.
+             */
+            if (valueOffset[0] !== 0) {
+                valueOffset.unshift(0);
+                keyframes.unshift(keyframes[0]);
+                valueEasing.unshift(defaultSegmentEasing);
+            }
+            /**
+             * If the last keyframe doesn't land on offset: 1
+             * provide one with a null wildcard value. This will ensure it
+             * stays static until the end of the animation.
+             */
+            if (valueOffset[valueOffset.length - 1] !== 1) {
+                valueOffset.push(1);
+                keyframes.push(null);
+            }
+            if (!animationDefinitions.has(element)) {
+                animationDefinitions.set(element, {
+                    keyframes: {},
+                    transition: {},
+                });
+            }
+            const definition = animationDefinitions.get(element);
+            definition.keyframes[key] = keyframes;
+            definition.transition[key] = {
+                ...defaultTransition,
+                duration: totalDuration,
+                ease: valueEasing,
+                times: valueOffset,
+                ...sequenceTransition,
+            };
+        }
+    });
+    return animationDefinitions;
+}
+function getSubjectSequence(subject, sequences) {
+    !sequences.has(subject) && sequences.set(subject, {});
+    return sequences.get(subject);
+}
+function getValueSequence(name, sequences) {
+    if (!sequences[name])
+        sequences[name] = [];
+    return sequences[name];
+}
+function keyframesAsList(keyframes) {
+    return Array.isArray(keyframes) ? keyframes : [keyframes];
+}
+function getValueTransition(transition, key) {
+    return transition && transition[key]
+        ? {
+            ...transition,
+            ...transition[key],
+        }
+        : { ...transition };
+}
+const isNumber = (keyframe) => typeof keyframe === "number";
+const isNumberKeyframesArray = (keyframes) => keyframes.every(isNumber);
+
+function animateElements(elementOrSelector, keyframes, options, scope) {
+    const elements = motionDom.resolveElements(elementOrSelector, scope);
+    const numElements = elements.length;
+    motionUtils.invariant(Boolean(numElements), "No valid elements provided.", "no-valid-elements");
+    /**
+     * WAAPI doesn't support interrupting animations.
+     *
+     * Therefore, starting animations requires a three-step process:
+     * 1. Stop existing animations (write styles to DOM)
+     * 2. Resolve keyframes (read styles from DOM)
+     * 3. Create new animations (write styles to DOM)
+     *
+     * The hybrid `animate()` function uses AsyncAnimation to resolve
+     * keyframes before creating new animations, which removes style
+     * thrashing. Here, we have much stricter filesize constraints.
+     * Therefore we do this in a synchronous way that ensures that
+     * at least within `animate()` calls there is no style thrashing.
+     *
+     * In the motion-native-animate-mini-interrupt benchmark this
+     * was 80% faster than a single loop.
+     */
+    const animationDefinitions = [];
+    /**
+     * Step 1: Build options and stop existing animations (write)
+     */
+    for (let i = 0; i < numElements; i++) {
+        const element = elements[i];
+        const elementTransition = { ...options };
+        /**
+         * Resolve stagger function if provided.
+         */
+        if (typeof elementTransition.delay === "function") {
+            elementTransition.delay = elementTransition.delay(i, numElements);
+        }
+        for (const valueName in keyframes) {
+            let valueKeyframes = keyframes[valueName];
+            if (!Array.isArray(valueKeyframes)) {
+                valueKeyframes = [valueKeyframes];
+            }
+            const valueOptions = {
+                ...motionDom.getValueTransition(elementTransition, valueName),
+            };
+            valueOptions.duration && (valueOptions.duration = motionUtils.secondsToMilliseconds(valueOptions.duration));
+            valueOptions.delay && (valueOptions.delay = motionUtils.secondsToMilliseconds(valueOptions.delay));
+            /**
+             * If there's an existing animation playing on this element then stop it
+             * before creating a new one.
+             */
+            const map = motionDom.getAnimationMap(element);
+            const key = motionDom.animationMapKey(valueName, valueOptions.pseudoElement || "");
+            const currentAnimation = map.get(key);
+            currentAnimation && currentAnimation.stop();
+            animationDefinitions.push({
+                map,
+                key,
+                unresolvedKeyframes: valueKeyframes,
+                options: {
+                    ...valueOptions,
+                    element,
+                    name: valueName,
+                    allowFlatten: !elementTransition.type && !elementTransition.ease,
+                },
+            });
+        }
+    }
+    /**
+     * Step 2: Resolve keyframes (read)
+     */
+    for (let i = 0; i < animationDefinitions.length; i++) {
+        const { unresolvedKeyframes, options: animationOptions } = animationDefinitions[i];
+        const { element, name, pseudoElement } = animationOptions;
+        if (!pseudoElement && unresolvedKeyframes[0] === null) {
+            unresolvedKeyframes[0] = motionDom.getComputedStyle(element, name);
+        }
+        motionDom.fillWildcards(unresolvedKeyframes);
+        motionDom.applyPxDefaults(unresolvedKeyframes, name);
+        /**
+         * If we only have one keyframe, explicitly read the initial keyframe
+         * from the computed style. This is to ensure consistency with WAAPI behaviour
+         * for restarting animations, for instance .play() after finish, when it
+         * has one vs two keyframes.
+         */
+        if (!pseudoElement && unresolvedKeyframes.length < 2) {
+            unresolvedKeyframes.unshift(motionDom.getComputedStyle(element, name));
+        }
+        animationOptions.keyframes = unresolvedKeyframes;
+    }
+    /**
+     * Step 3: Create new animations (write)
+     */
+    const animations = [];
+    for (let i = 0; i < animationDefinitions.length; i++) {
+        const { map, key, options: animationOptions } = animationDefinitions[i];
+        const animation = new motionDom.NativeAnimation(animationOptions);
+        map.set(key, animation);
+        animation.finished.finally(() => map.delete(key));
+        animations.push(animation);
+    }
+    return animations;
+}
+
+function animateSequence(definition, options) {
+    const animations = [];
+    createAnimationsFromSequence(definition, options).forEach(({ keyframes, transition }, element) => {
+        animations.push(...animateElements(element, keyframes, transition));
+    });
+    return new motionDom.GroupAnimationWithThen(animations);
+}
+
+const createScopedWaapiAnimate = (scope) => {
+    function scopedAnimate(elementOrSelector, keyframes, options) {
+        return new motionDom.GroupAnimationWithThen(animateElements(elementOrSelector, keyframes, options, scope));
+    }
+    return scopedAnimate;
+};
+const animateMini = /*@__PURE__*/ createScopedWaapiAnimate();
+
+exports.animate = animateMini;
+exports.animateSequence = animateSequence;

node_modules/framer-motion/dist/cjs/mini.js

@@ -0,0 +1,148 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var react = require('react');
+var motionDom = require('motion-dom');
+var motionUtils = require('motion-utils');
+
+/**
+ * Creates a constant value over the lifecycle of a component.
+ *
+ * Even if `useMemo` is provided an empty array as its final argument, it doesn't offer
+ * a guarantee that it won't re-run for performance reasons later on. By using `useConstant`
+ * you can ensure that initialisers don't execute twice or more.
+ */
+function useConstant(init) {
+    const ref = react.useRef(null);
+    if (ref.current === null) {
+        ref.current = init();
+    }
+    return ref.current;
+}
+
+function useUnmountEffect(callback) {
+    return react.useEffect(() => () => callback(), []);
+}
+
+function animateElements(elementOrSelector, keyframes, options, scope) {
+    const elements = motionDom.resolveElements(elementOrSelector, scope);
+    const numElements = elements.length;
+    motionUtils.invariant(Boolean(numElements), "No valid elements provided.", "no-valid-elements");
+    /**
+     * WAAPI doesn't support interrupting animations.
+     *
+     * Therefore, starting animations requires a three-step process:
+     * 1. Stop existing animations (write styles to DOM)
+     * 2. Resolve keyframes (read styles from DOM)
+     * 3. Create new animations (write styles to DOM)
+     *
+     * The hybrid `animate()` function uses AsyncAnimation to resolve
+     * keyframes before creating new animations, which removes style
+     * thrashing. Here, we have much stricter filesize constraints.
+     * Therefore we do this in a synchronous way that ensures that
+     * at least within `animate()` calls there is no style thrashing.
+     *
+     * In the motion-native-animate-mini-interrupt benchmark this
+     * was 80% faster than a single loop.
+     */
+    const animationDefinitions = [];
+    /**
+     * Step 1: Build options and stop existing animations (write)
+     */
+    for (let i = 0; i < numElements; i++) {
+        const element = elements[i];
+        const elementTransition = { ...options };
+        /**
+         * Resolve stagger function if provided.
+         */
+        if (typeof elementTransition.delay === "function") {
+            elementTransition.delay = elementTransition.delay(i, numElements);
+        }
+        for (const valueName in keyframes) {
+            let valueKeyframes = keyframes[valueName];
+            if (!Array.isArray(valueKeyframes)) {
+                valueKeyframes = [valueKeyframes];
+            }
+            const valueOptions = {
+                ...motionDom.getValueTransition(elementTransition, valueName),
+            };
+            valueOptions.duration && (valueOptions.duration = motionUtils.secondsToMilliseconds(valueOptions.duration));
+            valueOptions.delay && (valueOptions.delay = motionUtils.secondsToMilliseconds(valueOptions.delay));
+            /**
+             * If there's an existing animation playing on this element then stop it
+             * before creating a new one.
+             */
+            const map = motionDom.getAnimationMap(element);
+            const key = motionDom.animationMapKey(valueName, valueOptions.pseudoElement || "");
+            const currentAnimation = map.get(key);
+            currentAnimation && currentAnimation.stop();
+            animationDefinitions.push({
+                map,
+                key,
+                unresolvedKeyframes: valueKeyframes,
+                options: {
+                    ...valueOptions,
+                    element,
+                    name: valueName,
+                    allowFlatten: !elementTransition.type && !elementTransition.ease,
+                },
+            });
+        }
+    }
+    /**
+     * Step 2: Resolve keyframes (read)
+     */
+    for (let i = 0; i < animationDefinitions.length; i++) {
+        const { unresolvedKeyframes, options: animationOptions } = animationDefinitions[i];
+        const { element, name, pseudoElement } = animationOptions;
+        if (!pseudoElement && unresolvedKeyframes[0] === null) {
+            unresolvedKeyframes[0] = motionDom.getComputedStyle(element, name);
+        }
+        motionDom.fillWildcards(unresolvedKeyframes);
+        motionDom.applyPxDefaults(unresolvedKeyframes, name);
+        /**
+         * If we only have one keyframe, explicitly read the initial keyframe
+         * from the computed style. This is to ensure consistency with WAAPI behaviour
+         * for restarting animations, for instance .play() after finish, when it
+         * has one vs two keyframes.
+         */
+        if (!pseudoElement && unresolvedKeyframes.length < 2) {
+            unresolvedKeyframes.unshift(motionDom.getComputedStyle(element, name));
+        }
+        animationOptions.keyframes = unresolvedKeyframes;
+    }
+    /**
+     * Step 3: Create new animations (write)
+     */
+    const animations = [];
+    for (let i = 0; i < animationDefinitions.length; i++) {
+        const { map, key, options: animationOptions } = animationDefinitions[i];
+        const animation = new motionDom.NativeAnimation(animationOptions);
+        map.set(key, animation);
+        animation.finished.finally(() => map.delete(key));
+        animations.push(animation);
+    }
+    return animations;
+}
+
+const createScopedWaapiAnimate = (scope) => {
+    function scopedAnimate(elementOrSelector, keyframes, options) {
+        return new motionDom.GroupAnimationWithThen(animateElements(elementOrSelector, keyframes, options, scope));
+    }
+    return scopedAnimate;
+};
+
+function useAnimateMini() {
+    const scope = useConstant(() => ({
+        current: null, // Will be hydrated by React
+        animations: [],
+    }));
+    const animate = useConstant(() => createScopedWaapiAnimate(scope));
+    useUnmountEffect(() => {
+        scope.animations.forEach((animation) => animation.stop());
+    });
+    return [scope, animate];
+}
+
+exports.useAnimate = useAnimateMini;