@leafer-game/miniapp 1.0.8

package/dist/miniapp.cjs

@@ -0,0 +1,703 @@
+'use strict';
+
+var miniapp = require('@leafer-ui/miniapp');
+var robot = require('@leafer-in/robot');
+var draw = require('@leafer-ui/draw');
+var core = require('@leafer-ui/core');
+var animate = require('@leafer-in/animate');
+var core$1 = require('@leafer/core');
+
+function stateType(defaultValue, styleName) {
+    return draw.decorateLeafAttr(defaultValue, (key) => draw.attr({
+        set(value) {
+            this.__setAttr(key, value);
+            this.waitLeafer(() => styleName ? draw.State.setStyleName(this, styleName, value) : draw.State.set(this, value));
+        }
+    }));
+}
+function stateStyleType(defaultValue) {
+    return draw.decorateLeafAttr(defaultValue, (key) => draw.attr({
+        set(value) {
+            this.__setAttr(key, value);
+            this.__layout.stateStyleChanged = true;
+        }
+    }));
+}
+
+function findParentButton(leaf, button) {
+    if (button && button !== true)
+        return button;
+    if (!leaf.button) {
+        let { parent } = leaf;
+        for (let i = 0; i < 2; i++) {
+            if (parent) {
+                if (parent.button)
+                    return parent;
+                parent = parent.parent;
+            }
+        }
+    }
+    return null;
+}
+
+function setStyle(leaf, style) {
+    if (typeof style !== 'object')
+        style = undefined;
+    updateStyle(leaf, style, 'in');
+}
+function unsetStyle(leaf, style) {
+    const { normalStyle } = leaf;
+    if (typeof style !== 'object')
+        style = undefined;
+    if (normalStyle) {
+        if (!style)
+            style = normalStyle;
+        updateStyle(leaf, style, 'out');
+    }
+}
+const emprtyStyle = {};
+function updateStyle(leaf, style, type) {
+    const { normalStyle } = leaf;
+    if (!style)
+        style = emprtyStyle;
+    if (style.scale) {
+        core.MathHelper.assignScale(style, style.scale);
+        delete style.scale;
+    }
+    if (style === emprtyStyle || !core.State.canAnimate)
+        type = null;
+    let transition = type ? getTransition(type, style, leaf) : false;
+    const fromStyle = transition ? getFromStyle(leaf, style) : undefined;
+    leaf.killAnimate('transition');
+    if (normalStyle)
+        leaf.set(normalStyle, true);
+    const statesStyle = getStyle(leaf);
+    if (statesStyle) {
+        const { animation } = statesStyle;
+        if (animation) {
+            const animate = leaf.animate(animation, undefined, 'animation', true);
+            Object.assign(statesStyle, animate.endingStyle);
+            if (type !== 'in' || style.animation !== animation)
+                animate.kill();
+            else
+                transition = false;
+            delete statesStyle.animation;
+        }
+        leaf.normalStyle = filterStyle(statesStyle, leaf);
+        leaf.set(statesStyle, true);
+    }
+    else {
+        leaf.normalStyle = undefined;
+    }
+    if (transition) {
+        const toStyle = filterStyle(fromStyle, leaf);
+        leaf.set(fromStyle, true);
+        leaf.animate([fromStyle, toStyle], transition, 'transition', true);
+    }
+    leaf.__layout.stateStyleChanged = false;
+}
+function getStyle(leaf) {
+    let exist;
+    const style = {}, { state } = leaf, button = findParentButton(leaf);
+    const stateStyle = state && leaf.states[state];
+    if (stateStyle && core.State.isState(state, leaf, button))
+        exist = assign(style, stateStyle);
+    const selectedStyle = style.selectedStyle || leaf.selectedStyle;
+    if (selectedStyle && core.State.isSelected(leaf, button))
+        exist = assign(style, selectedStyle);
+    if (core.State.isDisabled(leaf, button)) {
+        const disabledStyle = style.disabledStyle || leaf.disabledStyle;
+        if (disabledStyle)
+            exist = assign(style, disabledStyle);
+    }
+    else {
+        const focusStyle = style.focusStyle || leaf.focusStyle;
+        if (focusStyle && core.State.isFocus(leaf, button))
+            exist = assign(style, focusStyle);
+        const hoverStyle = style.hoverStyle || leaf.hoverStyle;
+        if (hoverStyle && core.State.isHover(leaf, button))
+            exist = assign(style, hoverStyle);
+        const pressStyle = style.pressStyle || leaf.pressStyle;
+        if (pressStyle && core.State.isPress(leaf, button))
+            exist = assign(style, pressStyle);
+    }
+    return exist ? style : undefined;
+}
+function filterStyle(style, data, addStyle, useAnimateExcludes) {
+    const to = addStyle ? style : {}, forStyle = addStyle || style;
+    for (let key in forStyle) {
+        if (useAnimateExcludes) {
+            if (!core.State.animateExcludes[key])
+                to[key] = data[key];
+        }
+        else
+            to[key] = data[key];
+    }
+    return to;
+}
+function filterAnimateStyle(style, data, addStyle) {
+    return filterStyle(style, data, addStyle, true);
+}
+function getFromStyle(leaf, style) {
+    const fromStyle = filterAnimateStyle(style, leaf), animate = leaf.animate();
+    if (animate)
+        filterAnimateStyle(fromStyle, leaf, animate.fromStyle);
+    return fromStyle;
+}
+function getTransition(type, style, data) {
+    let name = type === 'in' ? 'transition' : 'transitionOut';
+    if (type === 'out' && core.isNull(data[name]) && core.isNull(style[name]))
+        name = 'transition';
+    return core.isNull(style[name]) ? data[name] : style[name];
+}
+function assign(style, stateStyle) {
+    Object.assign(style, stateStyle);
+    return true;
+}
+
+function setPointerState(leaf, stateName) {
+    const style = leaf[stateName];
+    if (style)
+        setStyle(leaf, style);
+    if (leaf.button)
+        setChildrenState(leaf.children, stateName);
+}
+function setState(leaf, stateName, stateStyle) {
+    if (!stateStyle)
+        stateStyle = leaf.states[stateName];
+    setStyle(leaf, stateStyle);
+    if (leaf.button)
+        setChildrenState(leaf.children, null, stateName);
+}
+function setChildrenState(children, stateType, state) {
+    if (!children)
+        return;
+    let leaf, update;
+    for (let i = 0, len = children.length; i < len; i++) {
+        leaf = children[i];
+        if (stateType) {
+            update = true;
+            switch (stateType) {
+                case 'hoverStyle':
+                    if (core.State.isHover(leaf))
+                        update = false;
+                    break;
+                case 'pressStyle':
+                    if (core.State.isPress(leaf))
+                        update = false;
+                    break;
+                case 'focusStyle':
+                    if (core.State.isFocus(leaf))
+                        update = false;
+            }
+            if (update)
+                setPointerState(leaf, stateType);
+        }
+        else if (state)
+            setState(leaf, state);
+        if (leaf.isBranch)
+            setChildrenState(leaf.children, stateType, state);
+    }
+}
+
+function unsetPointerState(leaf, stateName) {
+    const style = leaf[stateName];
+    if (style)
+        unsetStyle(leaf, style);
+    if (leaf.button)
+        unsetChildrenState(leaf.children, stateName);
+}
+function unsetState(leaf, stateName, stateStyle) {
+    unsetStyle(leaf, stateStyle);
+    if (leaf.button)
+        unsetChildrenState(leaf.children, null, stateName);
+}
+function unsetChildrenState(children, stateType, state) {
+    if (!children)
+        return;
+    let leaf;
+    for (let i = 0, len = children.length; i < len; i++) {
+        leaf = children[i];
+        if (stateType)
+            unsetPointerState(leaf, stateType);
+        else if (state)
+            unsetState(leaf, state);
+        if (leaf.isBranch)
+            unsetChildrenState(leaf.children, stateType, state);
+    }
+}
+
+function updateEventStyle(leaf, eventType) {
+    switch (eventType) {
+        case core.PointerEvent.ENTER:
+            setPointerState(leaf, 'hoverStyle');
+            break;
+        case core.PointerEvent.LEAVE:
+            unsetPointerState(leaf, 'hoverStyle');
+            break;
+        case core.PointerEvent.DOWN:
+            setPointerState(leaf, 'pressStyle');
+            break;
+        case core.PointerEvent.UP:
+            unsetPointerState(leaf, 'pressStyle');
+            break;
+    }
+}
+
+function checkPointerState(fnName, leaf, button) {
+    let find;
+    const interaction = leaf.leafer ? leaf.leafer.interaction : null;
+    if (interaction) {
+        find = interaction[fnName](leaf);
+        if (!find && button) {
+            const parentButton = findParentButton(leaf, button);
+            if (parentButton)
+                find = interaction[fnName](parentButton);
+        }
+    }
+    return find;
+}
+function checkFixedState(attrName, leaf, button) {
+    let find = leaf[attrName];
+    if (!find && button) {
+        const parentButton = findParentButton(leaf, button);
+        if (parentButton)
+            find = parentButton[attrName];
+    }
+    return find;
+}
+function checkState(stateName, leaf, button) {
+    let find = leaf.states[stateName];
+    if (!find && button) {
+        const parentButton = findParentButton(leaf, button);
+        if (parentButton)
+            find = parentButton.states[stateName];
+    }
+    return !!find;
+}
+
+core.State.animateExcludes = {
+    animation: 1,
+    animationOut: 1,
+    transition: 1,
+    transitionOut: 1,
+    states: 1,
+    state: 1,
+    normalStyle: 1,
+    hoverStyle: 1,
+    pressStyle: 1,
+    focusStyle: 1,
+    selectedStyle: 1,
+    disabledStyle: 1
+};
+core.State.isState = function (state, leaf, button) { return checkState(state, leaf, button); };
+core.State.isSelected = function (leaf, button) { return checkFixedState('selected', leaf, button); };
+core.State.isDisabled = function (leaf, button) { return checkFixedState('disabled', leaf, button); };
+core.State.isFocus = function (leaf, button) { return checkPointerState('isFocus', leaf, button); };
+core.State.isHover = function (leaf, button) { return checkPointerState('isHover', leaf, button); };
+core.State.isPress = function (leaf, button) { return checkPointerState('isPress', leaf, button); };
+core.State.isDrag = function (leaf, button) { return checkPointerState('isDrag', leaf, button); };
+core.State.setStyleName = function (leaf, stateType, value) { value ? setState(leaf, stateType, leaf[stateType]) : unsetState(leaf, stateType, leaf[stateType]); };
+core.State.set = function (leaf, stateName) { const style = leaf.states[stateName]; style ? setState(leaf, stateName, style) : unsetState(leaf, stateName, style); };
+core.State.getStyle = getStyle;
+core.State.updateStyle = updateStyle;
+core.State.updateEventStyle = updateEventStyle;
+const ui$1 = core.UI.prototype;
+stateType(false, 'selectedStyle')(ui$1, 'selected');
+stateType(false, 'disabledStyle')(ui$1, 'disabled');
+stateStyleType({})(ui$1, 'states');
+stateType('')(ui$1, 'state');
+core.dataType()(ui$1, 'normalStyle');
+stateStyleType()(ui$1, 'hoverStyle');
+stateStyleType()(ui$1, 'pressStyle');
+stateStyleType()(ui$1, 'focusStyle');
+stateStyleType()(ui$1, 'selectedStyle');
+stateStyleType()(ui$1, 'disabledStyle');
+core.dataType(false)(ui$1, 'button');
+ui$1.focus = function (value = true) {
+    this.waitLeafer(() => {
+        let { focusData } = this.app.interaction;
+        if (value) {
+            if (focusData)
+                focusData.focus(false);
+            focusData = this;
+        }
+        else
+            focusData = null;
+        this.app.interaction.focusData = focusData;
+        value ? setPointerState(this, 'focusStyle') : unsetPointerState(this, 'focusStyle');
+    });
+};
+ui$1.updateState = function () {
+    core.State.updateStyle(this, undefined, 'in');
+};
+
+const gaussNodes = [0.1488743389, 0.4333953941, 0.6794095682, 0.8650633666, 0.9739065285];
+const gaussWeights = [0.2955242247, 0.2692667193, 0.2190863625, 0.1494513491, 0.0666713443];
+const { sqrt } = Math;
+const HighBezierHelper = {
+    getDistance(fromX, fromY, x1, y1, x2, y2, toX, toY) {
+        let distance = 0, t1, t2, d1X, d1Y, d2X, d2Y;
+        for (let i = 0; i < gaussNodes.length; i++) {
+            t1 = 0.5 * (1 + gaussNodes[i]);
+            t2 = 0.5 * (1 - gaussNodes[i]);
+            d1X = getDerivative(t1, fromX, x1, x2, toX);
+            d1Y = getDerivative(t1, fromY, y1, y2, toY);
+            d2X = getDerivative(t2, fromX, x1, x2, toX);
+            d2Y = getDerivative(t2, fromY, y1, y2, toY);
+            distance += gaussWeights[i] * (sqrt(d1X * d1X + d1Y * d1Y) + sqrt(d2X * d2X + d2Y * d2Y));
+        }
+        return distance * 0.5;
+    },
+    getDerivative(t, fromV, v1, v2, toV) {
+        const o = 1 - t;
+        return 3 * o * o * (v1 - fromV) + 6 * o * t * (v2 - v1) + 3 * t * t * (toV - v2);
+    },
+    cut(data, t, fromX, fromY, x1, y1, x2, y2, toX, toY) {
+        const o = 1 - t;
+        const ax = o * fromX + t * x1, ay = o * fromY + t * y1;
+        const mbx = o * x1 + t * x2, mby = o * y1 + t * y2;
+        const mcx = o * x2 + t * toX, mcy = o * y2 + t * toY;
+        const bx = o * ax + t * mbx, by = o * ay + t * mby;
+        const mbcx = o * mbx + t * mcx, mbcy = o * mby + t * mcy;
+        const cx = o * bx + t * mbcx, cy = o * by + t * mbcy;
+        data.push(draw.PathCommandMap.C, ax, ay, bx, by, cx, cy);
+    }
+};
+const { getDerivative } = HighBezierHelper;
+
+const { M, L, C, Z } = draw.PathCommandMap;
+const tempPoint = {}, tempFrom = {};
+const HighCurveHelper = {
+    transform(data, matrix) {
+        let i = 0, command;
+        const len = data.length;
+        while (i < len) {
+            command = data[i];
+            switch (command) {
+                case M:
+                case L:
+                    HighCurveHelper.transformPoints(data, matrix, i, 1);
+                    i += 3;
+                    break;
+                case C:
+                    HighCurveHelper.transformPoints(data, matrix, i, 3);
+                    i += 7;
+                    break;
+                case Z:
+                    i += 1;
+            }
+        }
+    },
+    transformPoints(data, matrix, start, pointCount) {
+        for (let i = start + 1, end = i + pointCount * 2; i < end; i += 2) {
+            tempPoint.x = data[i];
+            tempPoint.y = data[i + 1];
+            draw.MatrixHelper.toOuterPoint(matrix, tempPoint);
+            data[i] = tempPoint.x;
+            data[i + 1] = tempPoint.y;
+        }
+    },
+    getMotionPathData(data) {
+        let total = 0, distance, segments = [];
+        let i = 0, x = 0, y = 0, toX, toY, command;
+        const len = data.length;
+        while (i < len) {
+            command = data[i];
+            switch (command) {
+                case M:
+                case L:
+                    toX = data[i + 1];
+                    toY = data[i + 2];
+                    distance = (command === L && i > 0) ? draw.PointHelper.getDistanceFrom(x, y, toX, toY) : 0;
+                    x = toX;
+                    y = toY;
+                    i += 3;
+                    break;
+                case C:
+                    toX = data[i + 5];
+                    toY = data[i + 6];
+                    distance = HighBezierHelper.getDistance(x, y, data[i + 1], data[i + 2], data[i + 3], data[i + 4], toX, toY);
+                    x = toX;
+                    y = toY;
+                    i += 7;
+                    break;
+                case Z:
+                    i += 1;
+                default:
+                    distance = 0;
+            }
+            segments.push(distance);
+            total += distance;
+        }
+        return { total, segments, data };
+    },
+    getDistancePoint(distanceData, motionDistance) {
+        const { segments, data } = distanceData;
+        motionDistance = draw.UnitConvert.number(motionDistance, distanceData.total);
+        let total = 0, distance, to = {};
+        let i = 0, index = 0, x = 0, y = 0, toX, toY, command;
+        const len = data.length;
+        while (i < len) {
+            command = data[i];
+            switch (command) {
+                case M:
+                case L:
+                    toX = data[i + 1];
+                    toY = data[i + 2];
+                    distance = segments[index];
+                    if (total + distance > motionDistance || !distanceData.total) {
+                        if (!i)
+                            x = toX, y = toY;
+                        tempFrom.x = x;
+                        tempFrom.y = y;
+                        to.x = toX;
+                        to.y = toY;
+                        draw.PointHelper.getDistancePoint(tempFrom, to, motionDistance - total, true);
+                        to.rotation = draw.PointHelper.getAngle(tempFrom, to);
+                        return to;
+                    }
+                    x = toX;
+                    y = toY;
+                    i += 3;
+                    break;
+                case C:
+                    toX = data[i + 5];
+                    toY = data[i + 6];
+                    distance = segments[index];
+                    if (total + distance > motionDistance) {
+                        const x1 = data[i + 1], y1 = data[i + 2], x2 = data[i + 3], y2 = data[i + 4];
+                        motionDistance -= total;
+                        draw.BezierHelper.getPointAndSet(motionDistance / distance, x, y, x1, y1, x2, y2, toX, toY, to);
+                        draw.BezierHelper.getPointAndSet(Math.max(0, motionDistance - 0.1) / distance, x, y, x1, y1, x2, y2, toX, toY, tempFrom);
+                        to.rotation = draw.PointHelper.getAngle(tempFrom, to);
+                        return to;
+                    }
+                    x = toX;
+                    y = toY;
+                    i += 7;
+                    break;
+                case Z:
+                    i += 1;
+                default:
+                    distance = 0;
+            }
+            index++;
+            total += distance;
+        }
+        return to;
+    },
+    getDistancePath(distanceData, motionDistance) {
+        const { segments, data } = distanceData, path = [];
+        motionDistance = draw.UnitConvert.number(motionDistance, distanceData.total);
+        let total = 0, distance, to = {};
+        let i = 0, index = 0, x = 0, y = 0, toX, toY, command;
+        const len = data.length;
+        while (i < len) {
+            command = data[i];
+            switch (command) {
+                case M:
+                case L:
+                    toX = data[i + 1];
+                    toY = data[i + 2];
+                    distance = segments[index];
+                    if (total + distance > motionDistance || !distanceData.total) {
+                        if (!i)
+                            x = toX, y = toY;
+                        tempFrom.x = x;
+                        tempFrom.y = y;
+                        to.x = toX;
+                        to.y = toY;
+                        draw.PointHelper.getDistancePoint(tempFrom, to, motionDistance - total, true);
+                        path.push(command, to.x, to.y);
+                        return path;
+                    }
+                    x = toX;
+                    y = toY;
+                    i += 3;
+                    path.push(command, x, y);
+                    break;
+                case C:
+                    const x1 = data[i + 1], y1 = data[i + 2], x2 = data[i + 3], y2 = data[i + 4];
+                    toX = data[i + 5];
+                    toY = data[i + 6];
+                    distance = segments[index];
+                    if (total + distance > motionDistance) {
+                        HighBezierHelper.cut(path, (motionDistance - total) / distance, x, y, x1, y1, x2, y2, toX, toY);
+                        return path;
+                    }
+                    x = toX;
+                    y = toY;
+                    i += 7;
+                    path.push(command, x1, y1, x2, y2, toX, toY);
+                    break;
+                case Z:
+                    i += 1;
+                    path.push(command);
+                default:
+                    distance = 0;
+            }
+            index++;
+            total += distance;
+        }
+        return path;
+    }
+};
+
+function motionPathType(defaultValue) {
+    return draw.decorateLeafAttr(defaultValue, (key) => draw.attr({
+        set(value) {
+            this.__setAttr(key, value);
+            this.__hasMotionPath = this.motionPath || !draw.isNull(this.motion);
+            this.__layout.matrixChanged || this.__layout.matrixChange();
+        }
+    }));
+}
+
+draw.Transition.register('motion', function (from, to, t, target) {
+    if (!from)
+        from = 0;
+    else if (typeof from === 'object')
+        from = draw.UnitConvert.number(from, target.getMotionTotal());
+    if (!to)
+        to = 0;
+    else if (typeof to === 'object')
+        to = draw.UnitConvert.number(to, target.getMotionTotal());
+    return draw.Transition.number(from, to, t);
+});
+draw.Transition.register('motionRotation', function (from, to, t) {
+    return draw.Transition.number(from, to, t);
+});
+const ui = draw.UI.prototype;
+const { updateMatrix, updateAllMatrix } = draw.LeafHelper;
+const { updateBounds } = draw.BranchHelper;
+motionPathType()(ui, 'motionPath');
+motionPathType()(ui, 'motion');
+motionPathType(true)(ui, 'motionRotation');
+ui.getMotionPathData = function () {
+    return getMotionPathData(getMotionPath(this));
+};
+ui.getMotionPoint = function (motionDistance) {
+    const path = getMotionPath(this);
+    const data = getMotionPathData(path);
+    if (!data.total)
+        return {};
+    const point = HighCurveHelper.getDistancePoint(data, motionDistance);
+    draw.MatrixHelper.toOuterPoint(path.localTransform, point);
+    const { motionRotation } = this;
+    if (motionRotation === false)
+        delete point.rotation;
+    else if (typeof motionRotation === 'number')
+        point.rotation += motionRotation;
+    return point;
+};
+ui.getMotionTotal = function () {
+    return this.getMotionPathData().total;
+};
+ui.__updateMotionPath = function () {
+    const data = this.__;
+    if (this.__layout.resized && data.__pathForMotion)
+        data.__pathForMotion = undefined;
+    if (this.motionPath) {
+        let child;
+        const { children } = this.parent, { leaferIsReady } = this;
+        for (let i = 0; i < children.length; i++) {
+            child = children[i];
+            if (!draw.isNull(child.motion) && !child.__layout.matrixChanged) {
+                if (leaferIsReady && child !== this)
+                    this.leafer.layouter.addExtra(child);
+                updateMotion(child);
+            }
+        }
+    }
+    else
+        updateMotion(this);
+};
+function updateMotion(leaf) {
+    const { motion, leaferIsCreated } = leaf;
+    if (draw.isNull(motion))
+        return;
+    if (leaferIsCreated)
+        leaf.leafer.created = false;
+    if (leaf.motionPath) {
+        const data = getMotionPathData(leaf);
+        if (data.total)
+            leaf.__.__pathForRender = HighCurveHelper.getDistancePath(data, motion);
+    }
+    else {
+        leaf.set(leaf.getMotionPoint(motion));
+        if (!leaf.__hasAutoLayout) {
+            if (leaf.isBranch)
+                updateAllMatrix(leaf), updateBounds(leaf, leaf);
+            else
+                updateMatrix(leaf);
+        }
+    }
+    if (leaferIsCreated)
+        leaf.leafer.created = true;
+}
+function getMotionPath(leaf) {
+    const { parent } = leaf;
+    if (!leaf.motionPath && parent) {
+        const { children } = parent;
+        for (let i = 0; i < children.length; i++) {
+            if (children[i].motionPath)
+                return children[i];
+        }
+    }
+    return leaf;
+}
+function getMotionPathData(leaf) {
+    const data = leaf.__;
+    if (data.__pathForMotion)
+        return data.__pathForMotion;
+    return data.__pathForMotion = HighCurveHelper.getMotionPathData(leaf.getPath(true, true));
+}
+
+const systemInfo = wx.getSystemInfoSync();
+const platform = systemInfo.platform;
+if (platform === 'ios') {
+    core$1.LeaferImage.prototype.getPattern = function (canvas, repeat, transform, paint) {
+        const pattern = core$1.Platform.canvas.createPattern(this.view, repeat);
+        const { width, height } = canvas;
+        if (this.width !== width || this.height !== height) {
+            if (!transform)
+                transform = core$1.MatrixHelper.get();
+            core$1.MatrixHelper.scale(transform, width / this.width, height / this.height);
+        }
+        try {
+            if (transform && pattern.setTransform) {
+                pattern.setTransform(transform);
+                transform = null;
+            }
+        }
+        catch (_a) { }
+        if (paint)
+            paint.transform = transform;
+        return pattern;
+    };
+}
+
+exports.HighBezierHelper = HighBezierHelper;
+exports.HighCurveHelper = HighCurveHelper;
+exports.motionPathType = motionPathType;
+exports.stateStyleType = stateStyleType;
+exports.stateType = stateType;
+Object.keys(miniapp).forEach(function (k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () { return miniapp[k]; }
+    });
+});
+Object.keys(robot).forEach(function (k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () { return robot[k]; }
+    });
+});
+Object.keys(animate).forEach(function (k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () { return animate[k]; }
+    });
+});