Initial commit

node_modules/@fluentui/react-motion-components-preview/lib-commonjs/components/Collapse/Collapse.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Collapse: function() {
+        return Collapse;
+    },
+    CollapseDelayed: function() {
+        return CollapseDelayed;
+    },
+    CollapseRelaxed: function() {
+        return CollapseRelaxed;
+    },
+    CollapseSnappy: function() {
+        return CollapseSnappy;
+    },
+    createCollapseDelayedPresence: function() {
+        return createCollapseDelayedPresence;
+    },
+    createCollapsePresence: function() {
+        return createCollapsePresence;
+    }
+});
+const _reactmotion = require("@fluentui/react-motion");
+const _collapseatoms = require("./collapse-atoms");
+const _fadeatom = require("../../atoms/fade-atom");
+const createCollapseDelayedPresence = ({ // enter
+enterSizeDuration = _reactmotion.motionTokens.durationNormal, enterOpacityDuration = enterSizeDuration, enterEasing = _reactmotion.motionTokens.curveEasyEaseMax, enterDelay = 0, // exit: durations and easing default to enter values for symmetry
+exitSizeDuration = enterSizeDuration, exitOpacityDuration = enterOpacityDuration, exitEasing = enterEasing, exitDelay = 0 } = {})=>({ element, animateOpacity = true, orientation = 'vertical' })=>{
+        // ----- ENTER -----
+        // The enter transition is an array of up to 3 motion atoms: size, whitespace and opacity.
+        const enterAtoms = [
+            (0, _collapseatoms.sizeEnterAtom)({
+                orientation,
+                duration: enterSizeDuration,
+                easing: enterEasing,
+                element
+            }),
+            (0, _collapseatoms.whitespaceAtom)({
+                direction: 'enter',
+                orientation,
+                duration: enterSizeDuration,
+                easing: enterEasing
+            })
+        ];
+        // Fade in only if animateOpacity is true. Otherwise, leave opacity unaffected.
+        if (animateOpacity) {
+            enterAtoms.push({
+                ...(0, _fadeatom.fadeAtom)({
+                    direction: 'enter',
+                    duration: enterOpacityDuration,
+                    easing: enterEasing
+                }),
+                delay: enterDelay,
+                fill: 'both'
+            });
+        }
+        // ----- EXIT -----
+        // The exit transition is an array of up to 3 motion atoms: opacity, size and whitespace.
+        const exitAtoms = [];
+        // Fade out only if animateOpacity is true. Otherwise, leave opacity unaffected.
+        if (animateOpacity) {
+            exitAtoms.push((0, _fadeatom.fadeAtom)({
+                direction: 'exit',
+                duration: exitOpacityDuration,
+                easing: exitEasing
+            }));
+        }
+        exitAtoms.push((0, _collapseatoms.sizeExitAtom)({
+            orientation,
+            duration: exitSizeDuration,
+            easing: exitEasing,
+            element,
+            delay: exitDelay
+        }), (0, _collapseatoms.whitespaceAtom)({
+            direction: 'exit',
+            orientation,
+            duration: exitSizeDuration,
+            easing: exitEasing,
+            delay: exitDelay
+        }));
+        return {
+            enter: enterAtoms,
+            exit: exitAtoms
+        };
+    };
+const createCollapsePresence = ({ enterDuration = _reactmotion.motionTokens.durationNormal, enterEasing = _reactmotion.motionTokens.curveEasyEaseMax, exitDuration = enterDuration, exitEasing = enterEasing } = {})=>// Implement a regular collapse as a special case of the delayed collapse,
+    // where the delays are zero, and the size and opacity durations are equal.
+    createCollapseDelayedPresence({
+        enterSizeDuration: enterDuration,
+        enterEasing,
+        exitSizeDuration: exitDuration,
+        exitEasing
+    });
+const Collapse = (0, _reactmotion.createPresenceComponent)(createCollapsePresence());
+const CollapseSnappy = (0, _reactmotion.createPresenceComponent)(createCollapsePresence({
+    enterDuration: _reactmotion.motionTokens.durationFast
+}));
+const CollapseRelaxed = (0, _reactmotion.createPresenceComponent)(createCollapsePresence({
+    enterDuration: _reactmotion.motionTokens.durationSlower
+}));
+const CollapseDelayed = (0, _reactmotion.createPresenceComponent)(createCollapseDelayedPresence({
+    enterSizeDuration: _reactmotion.motionTokens.durationNormal,
+    enterOpacityDuration: _reactmotion.motionTokens.durationSlower,
+    enterDelay: _reactmotion.motionTokens.durationNormal,
+    exitDelay: _reactmotion.motionTokens.durationSlower,
+    enterEasing: _reactmotion.motionTokens.curveEasyEase
+}));

node_modules/@fluentui/react-motion-components-preview/lib-commonjs/components/Collapse/collapse-atoms.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    sizeEnterAtom: function() {
+        return sizeEnterAtom;
+    },
+    sizeExitAtom: function() {
+        return sizeExitAtom;
+    },
+    whitespaceAtom: function() {
+        return whitespaceAtom;
+    }
+});
+// ----- SIZE -----
+const sizeValuesForOrientation = (orientation, element)=>{
+    const sizeName = orientation === 'horizontal' ? 'maxWidth' : 'maxHeight';
+    const overflowName = orientation === 'horizontal' ? 'overflowX' : 'overflowY';
+    const measuredSize = orientation === 'horizontal' ? element.scrollWidth : element.scrollHeight;
+    const toSize = `${measuredSize}px`;
+    return {
+        sizeName,
+        overflowName,
+        toSize
+    };
+};
+const sizeEnterAtom = ({ orientation, duration, easing, element, fromSize = '0' })=>{
+    const { sizeName, overflowName, toSize } = sizeValuesForOrientation(orientation, element);
+    return {
+        keyframes: [
+            {
+                [sizeName]: fromSize,
+                [overflowName]: 'hidden'
+            },
+            {
+                [sizeName]: toSize,
+                offset: 0.9999,
+                [overflowName]: 'hidden'
+            },
+            {
+                [sizeName]: 'unset',
+                [overflowName]: 'unset'
+            }
+        ],
+        duration,
+        easing
+    };
+};
+const sizeExitAtom = ({ orientation, duration, easing, element, delay = 0, fromSize = '0' })=>{
+    const { sizeName, overflowName, toSize } = sizeValuesForOrientation(orientation, element);
+    return {
+        keyframes: [
+            {
+                [sizeName]: toSize,
+                [overflowName]: 'hidden'
+            },
+            {
+                [sizeName]: fromSize,
+                [overflowName]: 'hidden'
+            }
+        ],
+        duration,
+        easing,
+        fill: 'both',
+        delay
+    };
+};
+// ----- WHITESPACE -----
+// Whitespace animation includes padding and margin.
+const whitespaceValuesForOrientation = (orientation)=>{
+    // horizontal whitespace collapse
+    if (orientation === 'horizontal') {
+        return {
+            paddingStart: 'paddingInlineStart',
+            paddingEnd: 'paddingInlineEnd',
+            marginStart: 'marginInlineStart',
+            marginEnd: 'marginInlineEnd'
+        };
+    }
+    // vertical whitespace collapse
+    return {
+        paddingStart: 'paddingBlockStart',
+        paddingEnd: 'paddingBlockEnd',
+        marginStart: 'marginBlockStart',
+        marginEnd: 'marginBlockEnd'
+    };
+};
+const whitespaceAtom = ({ direction, orientation, duration, easing, delay = 0 })=>{
+    const { paddingStart, paddingEnd, marginStart, marginEnd } = whitespaceValuesForOrientation(orientation);
+    // The keyframe with zero whitespace is at the start for enter and at the end for exit.
+    const offset = direction === 'enter' ? 0 : 1;
+    const keyframes = [
+        {
+            [paddingStart]: '0',
+            [paddingEnd]: '0',
+            [marginStart]: '0',
+            [marginEnd]: '0',
+            offset
+        }
+    ];
+    const atom = {
+        keyframes,
+        duration,
+        easing,
+        delay
+    };
+    if (direction === 'exit') {
+        atom.fill = 'forwards';
+    }
+    return atom;
+};

node_modules/@fluentui/react-motion-components-preview/lib-commonjs/components/Collapse/collapse-types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-motion-components-preview/lib-commonjs/components/Collapse/collapse-types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"rangeMappings":"","mappings":""}

node_modules/@fluentui/react-motion-components-preview/lib-commonjs/components/Collapse/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Collapse: function() {
+        return _Collapse.Collapse;
+    },
+    CollapseDelayed: function() {
+        return _Collapse.CollapseDelayed;
+    },
+    CollapseRelaxed: function() {
+        return _Collapse.CollapseRelaxed;
+    },
+    CollapseSnappy: function() {
+        return _Collapse.CollapseSnappy;
+    },
+    createCollapseDelayedPresence: function() {
+        return _Collapse.createCollapseDelayedPresence;
+    },
+    createCollapsePresence: function() {
+        return _Collapse.createCollapsePresence;
+    }
+});
+const _Collapse = require("./Collapse");

node_modules/@fluentui/react-motion-components-preview/lib-commonjs/components/Collapse/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Collapse/index.ts"],"sourcesContent":["export {\n  Collapse,\n  CollapseDelayed,\n  CollapseRelaxed,\n  CollapseSnappy,\n  createCollapseDelayedPresence,\n  createCollapsePresence,\n} from './Collapse';\nexport type { CollapseRuntimeParams } from './collapse-types';\n"],"names":["Collapse","CollapseDelayed","CollapseRelaxed","CollapseSnappy","createCollapseDelayedPresence","createCollapsePresence"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IACEA,QAAQ;eAARA,kBAAQ;;IACRC,eAAe;eAAfA,yBAAe;;IACfC,eAAe;eAAfA,yBAAe;;IACfC,cAAc;eAAdA,wBAAc;;IACdC,6BAA6B;eAA7BA,uCAA6B;;IAC7BC,sBAAsB;eAAtBA,gCAAsB;;;0BACjB"}

node_modules/@fluentui/react-motion-components-preview/lib-commonjs/components/Fade/Fade.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Fade: function() {
+        return Fade;
+    },
+    FadeRelaxed: function() {
+        return FadeRelaxed;
+    },
+    FadeSnappy: function() {
+        return FadeSnappy;
+    },
+    createFadePresence: function() {
+        return createFadePresence;
+    }
+});
+const _reactmotion = require("@fluentui/react-motion");
+const _fadeatom = require("../../atoms/fade-atom");
+const createFadePresence = ({ enterDuration = _reactmotion.motionTokens.durationNormal, enterEasing = _reactmotion.motionTokens.curveEasyEase, exitDuration = enterDuration, exitEasing = enterEasing } = {})=>({
+        enter: (0, _fadeatom.fadeAtom)({
+            direction: 'enter',
+            duration: enterDuration,
+            easing: enterEasing
+        }),
+        exit: (0, _fadeatom.fadeAtom)({
+            direction: 'exit',
+            duration: exitDuration,
+            easing: exitEasing
+        })
+    });
+const Fade = (0, _reactmotion.createPresenceComponent)(createFadePresence());
+const FadeSnappy = (0, _reactmotion.createPresenceComponent)(createFadePresence({
+    enterDuration: _reactmotion.motionTokens.durationFast
+}));
+const FadeRelaxed = (0, _reactmotion.createPresenceComponent)(createFadePresence({
+    enterDuration: _reactmotion.motionTokens.durationGentle
+}));

node_modules/@fluentui/react-motion-components-preview/lib-commonjs/components/Fade/Fade.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Fade/Fade.ts"],"sourcesContent":["import { motionTokens, createPresenceComponent } from '@fluentui/react-motion';\nimport type { PresenceMotionCreator } from '../../types';\nimport { fadeAtom } from '../../atoms/fade-atom';\n\ntype FadeVariantParams = {\n  /** Time (ms) for the enter transition (fade-in). Defaults to the `durationNormal` value (200 ms). */\n  enterDuration?: number;\n\n  /** Easing curve for the enter transition (fade-in). Defaults to the `easeEase` value.  */\n  enterEasing?: string;\n\n  /** Time (ms) for the exit transition (fade-out). Defaults to the `enterDuration` param for symmetry. */\n  exitDuration?: number;\n\n  /** Easing curve for the exit transition (fade-out). Defaults to the `enterEasing` param for symmetry.  */\n  exitEasing?: string;\n};\n\n/** Define a presence motion for fade in/out  */\nexport const createFadePresence: PresenceMotionCreator<FadeVariantParams> = ({\n  enterDuration = motionTokens.durationNormal,\n  enterEasing = motionTokens.curveEasyEase,\n  exitDuration = enterDuration,\n  exitEasing = enterEasing,\n} = {}) => ({\n  enter: fadeAtom({ direction: 'enter', duration: enterDuration, easing: enterEasing }),\n  exit: fadeAtom({ direction: 'exit', duration: exitDuration, easing: exitEasing }),\n});\n\n/** A React component that applies fade in/out transitions to its children. */\nexport const Fade = createPresenceComponent(createFadePresence());\n\nexport const FadeSnappy = createPresenceComponent(createFadePresence({ enterDuration: motionTokens.durationFast }));\n\nexport const FadeRelaxed = createPresenceComponent(createFadePresence({ enterDuration: motionTokens.durationGentle }));\n"],"names":["Fade","FadeRelaxed","FadeSnappy","createFadePresence","enterDuration","motionTokens","durationNormal","enterEasing","curveEasyEase","exitDuration","exitEasing","enter","fadeAtom","direction","duration","easing","exit","createPresenceComponent","durationFast","durationGentle"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IA8BaA,IAAI;eAAJA;;IAIAC,WAAW;eAAXA;;IAFAC,UAAU;eAAVA;;IAbAC,kBAAkB;eAAlBA;;;6BAnByC;0BAE7B;AAiBlB,MAAMA,qBAA+D,CAAC,EAC3EC,gBAAgBC,yBAAY,CAACC,cAAc,EAC3CC,cAAcF,yBAAY,CAACG,aAAa,EACxCC,eAAeL,aAAa,EAC5BM,aAAaH,WAAW,EACzB,GAAG,CAAC,CAAC,GAAM,CAAA;QACVI,OAAOC,IAAAA,kBAAQ,EAAC;YAAEC,WAAW;YAASC,UAAUV;YAAeW,QAAQR;QAAY;QACnFS,MAAMJ,IAAAA,kBAAQ,EAAC;YAAEC,WAAW;YAAQC,UAAUL;YAAcM,QAAQL;QAAW;IACjF,CAAA;AAGO,MAAMV,OAAOiB,IAAAA,oCAAuB,EAACd;AAErC,MAAMD,aAAae,IAAAA,oCAAuB,EAACd,mBAAmB;IAAEC,eAAeC,yBAAY,CAACa,YAAY;AAAC;AAEzG,MAAMjB,cAAcgB,IAAAA,oCAAuB,EAACd,mBAAmB;IAAEC,eAAeC,yBAAY,CAACc,cAAc;AAAC"}

node_modules/@fluentui/react-motion-components-preview/lib-commonjs/components/Fade/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Fade: function() {
+        return _Fade.Fade;
+    },
+    FadeRelaxed: function() {
+        return _Fade.FadeRelaxed;
+    },
+    FadeSnappy: function() {
+        return _Fade.FadeSnappy;
+    },
+    createFadePresence: function() {
+        return _Fade.createFadePresence;
+    }
+});
+const _Fade = require("./Fade");

node_modules/@fluentui/react-motion-components-preview/lib-commonjs/components/Fade/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Fade/index.ts"],"sourcesContent":["export { Fade, FadeRelaxed, FadeSnappy, createFadePresence } from './Fade';\n"],"names":["Fade","FadeRelaxed","FadeSnappy","createFadePresence"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAASA,IAAI;eAAJA,UAAI;;IAAEC,WAAW;eAAXA,iBAAW;;IAAEC,UAAU;eAAVA,gBAAU;;IAAEC,kBAAkB;eAAlBA,wBAAkB;;;sBAAQ"}

node_modules/@fluentui/react-motion-components-preview/lib-commonjs/components/Scale/Scale.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Scale: function() {
+        return Scale;
+    },
+    ScaleRelaxed: function() {
+        return ScaleRelaxed;
+    },
+    ScaleSnappy: function() {
+        return ScaleSnappy;
+    },
+    createScalePresence: function() {
+        return createScalePresence;
+    }
+});
+const _reactmotion = require("@fluentui/react-motion");
+const createScalePresence = ({ enterDuration = _reactmotion.motionTokens.durationGentle, enterEasing = _reactmotion.motionTokens.curveDecelerateMax, exitDuration = _reactmotion.motionTokens.durationNormal, exitEasing = _reactmotion.motionTokens.curveAccelerateMax } = {})=>({ animateOpacity = true })=>{
+        const fromOpacity = animateOpacity ? 0 : 1;
+        const toOpacity = 1;
+        const fromScale = 0.9; // Could be a custom param in the future
+        const toScale = 1;
+        const enterKeyframes = [
+            {
+                opacity: fromOpacity,
+                transform: `scale3d(${fromScale}, ${fromScale}, 1)`,
+                visibility: 'visible'
+            },
+            {
+                opacity: toOpacity,
+                transform: `scale3d(${toScale}, ${toScale}, 1)`
+            }
+        ];
+        const exitKeyframes = [
+            {
+                opacity: toOpacity,
+                transform: `scale3d(${toScale}, ${toScale}, 1)`
+            },
+            {
+                opacity: fromOpacity,
+                transform: `scale3d(${fromScale}, ${fromScale}, 1)`,
+                visibility: 'hidden'
+            }
+        ];
+        return {
+            enter: {
+                duration: enterDuration,
+                easing: enterEasing,
+                keyframes: enterKeyframes
+            },
+            exit: {
+                duration: exitDuration,
+                easing: exitEasing,
+                keyframes: exitKeyframes
+            }
+        };
+    };
+const Scale = (0, _reactmotion.createPresenceComponent)(createScalePresence());
+const ScaleSnappy = (0, _reactmotion.createPresenceComponent)(createScalePresence({
+    enterDuration: _reactmotion.motionTokens.durationNormal,
+    enterEasing: _reactmotion.motionTokens.curveDecelerateMax,
+    exitDuration: _reactmotion.motionTokens.durationFast,
+    exitEasing: _reactmotion.motionTokens.curveAccelerateMax
+}));
+const ScaleRelaxed = (0, _reactmotion.createPresenceComponent)(createScalePresence({
+    enterDuration: _reactmotion.motionTokens.durationSlow,
+    enterEasing: _reactmotion.motionTokens.curveDecelerateMax,
+    exitDuration: _reactmotion.motionTokens.durationGentle,
+    exitEasing: _reactmotion.motionTokens.curveAccelerateMax
+}));

node_modules/@fluentui/react-motion-components-preview/lib-commonjs/components/Scale/Scale.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Scale/Scale.ts"],"sourcesContent":["import { motionTokens, createPresenceComponent } from '@fluentui/react-motion';\nimport { PresenceMotionFnCreator } from '../../types';\nimport { ScaleRuntimeParams_unstable, ScaleVariantParams_unstable } from './Scale.types';\n\n/** Define a presence motion for scale in/out */\nexport const createScalePresence: PresenceMotionFnCreator<ScaleVariantParams_unstable, ScaleRuntimeParams_unstable> =\n  ({\n    enterDuration = motionTokens.durationGentle,\n    enterEasing = motionTokens.curveDecelerateMax,\n    exitDuration = motionTokens.durationNormal,\n    exitEasing = motionTokens.curveAccelerateMax,\n  } = {}) =>\n  ({ animateOpacity = true }) => {\n    const fromOpacity = animateOpacity ? 0 : 1;\n    const toOpacity = 1;\n    const fromScale = 0.9; // Could be a custom param in the future\n    const toScale = 1;\n\n    const enterKeyframes = [\n      { opacity: fromOpacity, transform: `scale3d(${fromScale}, ${fromScale}, 1)`, visibility: 'visible' },\n      { opacity: toOpacity, transform: `scale3d(${toScale}, ${toScale}, 1)` },\n    ];\n\n    const exitKeyframes = [\n      { opacity: toOpacity, transform: `scale3d(${toScale}, ${toScale}, 1)` },\n      { opacity: fromOpacity, transform: `scale3d(${fromScale}, ${fromScale}, 1)`, visibility: 'hidden' },\n    ];\n    return {\n      enter: {\n        duration: enterDuration,\n        easing: enterEasing,\n        keyframes: enterKeyframes,\n      },\n      exit: { duration: exitDuration, easing: exitEasing, keyframes: exitKeyframes },\n    };\n  };\n\n/** A React component that applies scale in/out transitions to its children. */\nexport const Scale = createPresenceComponent(createScalePresence());\n\nexport const ScaleSnappy = createPresenceComponent(\n  createScalePresence({\n    enterDuration: motionTokens.durationNormal,\n    enterEasing: motionTokens.curveDecelerateMax,\n    exitDuration: motionTokens.durationFast,\n    exitEasing: motionTokens.curveAccelerateMax,\n  }),\n);\n\nexport const ScaleRelaxed = createPresenceComponent(\n  createScalePresence({\n    enterDuration: motionTokens.durationSlow,\n    enterEasing: motionTokens.curveDecelerateMax,\n    exitDuration: motionTokens.durationGentle,\n    exitEasing: motionTokens.curveAccelerateMax,\n  }),\n);\n"],"names":["Scale","ScaleRelaxed","ScaleSnappy","createScalePresence","enterDuration","motionTokens","durationGentle","enterEasing","curveDecelerateMax","exitDuration","durationNormal","exitEasing","curveAccelerateMax","animateOpacity","fromOpacity","toOpacity","fromScale","toScale","enterKeyframes","opacity","transform","visibility","exitKeyframes","enter","duration","easing","keyframes","exit","createPresenceComponent","durationFast","durationSlow"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAsCaA,KAAK;eAALA;;IAWAC,YAAY;eAAZA;;IATAC,WAAW;eAAXA;;IAnCAC,mBAAmB;eAAnBA;;;6BALyC;AAK/C,MAAMA,sBACX,CAAC,EACCC,gBAAgBC,yBAAY,CAACC,cAAc,EAC3CC,cAAcF,yBAAY,CAACG,kBAAkB,EAC7CC,eAAeJ,yBAAY,CAACK,cAAc,EAC1CC,aAAaN,yBAAY,CAACO,kBAAkB,EAC7C,GAAG,CAAC,CAAC,GACN,CAAC,EAAEC,iBAAiB,IAAI,EAAE;QACxB,MAAMC,cAAcD,iBAAiB,IAAI;QACzC,MAAME,YAAY;QAClB,MAAMC,YAAY,KAAK,wCAAwC;QAC/D,MAAMC,UAAU;QAEhB,MAAMC,iBAAiB;YACrB;gBAAEC,SAASL;gBAAaM,WAAW,CAAC,QAAQ,EAAEJ,UAAU,EAAE,EAAEA,UAAU,IAAI,CAAC;gBAAEK,YAAY;YAAU;YACnG;gBAAEF,SAASJ;gBAAWK,WAAW,CAAC,QAAQ,EAAEH,QAAQ,EAAE,EAAEA,QAAQ,IAAI,CAAC;YAAC;SACvE;QAED,MAAMK,gBAAgB;YACpB;gBAAEH,SAASJ;gBAAWK,WAAW,CAAC,QAAQ,EAAEH,QAAQ,EAAE,EAAEA,QAAQ,IAAI,CAAC;YAAC;YACtE;gBAAEE,SAASL;gBAAaM,WAAW,CAAC,QAAQ,EAAEJ,UAAU,EAAE,EAAEA,UAAU,IAAI,CAAC;gBAAEK,YAAY;YAAS;SACnG;QACD,OAAO;YACLE,OAAO;gBACLC,UAAUpB;gBACVqB,QAAQlB;gBACRmB,WAAWR;YACb;YACAS,MAAM;gBAAEH,UAAUf;gBAAcgB,QAAQd;gBAAYe,WAAWJ;YAAc;QAC/E;IACF;AAGK,MAAMtB,QAAQ4B,IAAAA,oCAAuB,EAACzB;AAEtC,MAAMD,cAAc0B,IAAAA,oCAAuB,EAChDzB,oBAAoB;IAClBC,eAAeC,yBAAY,CAACK,cAAc;IAC1CH,aAAaF,yBAAY,CAACG,kBAAkB;IAC5CC,cAAcJ,yBAAY,CAACwB,YAAY;IACvClB,YAAYN,yBAAY,CAACO,kBAAkB;AAC7C;AAGK,MAAMX,eAAe2B,IAAAA,oCAAuB,EACjDzB,oBAAoB;IAClBC,eAAeC,yBAAY,CAACyB,YAAY;IACxCvB,aAAaF,yBAAY,CAACG,kBAAkB;IAC5CC,cAAcJ,yBAAY,CAACC,cAAc;IACzCK,YAAYN,yBAAY,CAACO,kBAAkB;AAC7C"}

node_modules/@fluentui/react-motion-components-preview/lib-commonjs/components/Scale/Scale.types.js

@@ -0,0 +1,5 @@
+// eslint-disable-next-line @typescript-eslint/naming-convention
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-motion-components-preview/lib-commonjs/components/Scale/Scale.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Scale/Scale.types.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/naming-convention\nexport type ScaleVariantParams_unstable = {\n  /** Time (ms) for the enter transition. Defaults to the `durationNormal` value (200 ms). */\n  enterDuration?: number;\n\n  /** Easing curve for the enter transition. Defaults to the `easeEaseMax` value.  */\n  enterEasing?: string;\n\n  /** Time (ms) for the exit transition. Defaults to the `enterDuration` param for symmetry. */\n  exitDuration?: number;\n\n  /** Easing curve for the exit transition. Defaults to the `enterEasing` param for symmetry.  */\n  exitEasing?: string;\n};\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport type ScaleRuntimeParams_unstable = {\n  /** Whether to animate the opacity. Defaults to `true`. */\n  animateOpacity?: boolean;\n};\n"],"names":[],"rangeMappings":"","mappings":"AAAA,gEAAgE"}

node_modules/@fluentui/react-motion-components-preview/lib-commonjs/components/Scale/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Scale: function() {
+        return _Scale.Scale;
+    },
+    ScaleRelaxed: function() {
+        return _Scale.ScaleRelaxed;
+    },
+    ScaleSnappy: function() {
+        return _Scale.ScaleSnappy;
+    },
+    createScalePresence: function() {
+        return _Scale.createScalePresence;
+    }
+});
+const _Scale = require("./Scale");

node_modules/@fluentui/react-motion-components-preview/lib-commonjs/components/Scale/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Scale/index.ts"],"sourcesContent":["export { Scale, ScaleRelaxed, ScaleSnappy, createScalePresence } from './Scale';\n"],"names":["Scale","ScaleRelaxed","ScaleSnappy","createScalePresence"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAASA,KAAK;eAALA,YAAK;;IAAEC,YAAY;eAAZA,mBAAY;;IAAEC,WAAW;eAAXA,kBAAW;;IAAEC,mBAAmB;eAAnBA,0BAAmB;;;uBAAQ"}