@shijiu/jsview 1.9.921 → 1.9.943-next-vue.0

package/patches/node_modules/@vue/compiler-sfc/dist/jsview-style-formator.cjs.js

@@ -0,0 +1,919 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Forge = {};
+
+class ErrCode {
+    static ToString(value) {
+        switch (value) {
+            case ErrCode.UnknownError:
+                return 'UnknownError(' + value + ')';
+            case ErrCode.UnimplementedError:
+                return 'UnimplementedError(' + value + ')';
+            case ErrCode.UnsupportedError:
+                return 'UnsupportedError(' + value + ')';
+            case ErrCode.NotFoundError:
+                return 'NotFoundError(' + value + ')';
+            case ErrCode.InvalidArgument:
+                return 'InvalidArgument(' + value + ')';
+            case ErrCode.BadArgumentSize:
+                return 'BadArgumentSize(' + value + ')';
+            case ErrCode.InvalidElement:
+                return 'InvalidElement(' + value + ')';
+            case ErrCode.BadElementType:
+                return 'BadElementType(' + value + ')';
+            case ErrCode.CssStyleNotExists:
+                return 'CssStyleNotExists(' + value + ')';
+            case ErrCode.CssStyleNotChanged:
+                return 'CssStyleNotChanged(' + value + ')';
+            case ErrCode.CssStyleBadType:
+                return 'CssStyleBadType(' + value + ')';
+            case ErrCode.CssClassNotChanged:
+                return 'CssClassNotChanged(' + value + ')';
+            case ErrCode.ForgeInsertView:
+                return 'ForgeInsertView(' + value + ')';
+            default:
+                return ("UnknownError(" + value + ")");
+        }
+    }
+    static GetFormattedMethod(prettyFunction) {
+        var begin = 0, length = 0;
+        begin = prettyFunction.indexOf(" ") + 1;
+        length = prettyFunction.indexOf("(") - begin;
+        const method = prettyFunction.substr(begin, length) + "()";
+        return method;
+    }
+    static GetErrorMessage(errMsgs = []) {
+        var oss = "";
+        for (const item of errMsgs) {
+            oss += item;
+        }
+        return oss;
+    }
+    static PrintErrorMessage(fileName, fileLine, errMsgs = []) {
+        const msg = ErrCode.GetErrorMessage(errMsgs);
+        console.error("ForgeDom", "Error@ " + fileName + ":" + fileLine + ", " + msg);
+    }
+    static UnknownError = -1;
+    static UnimplementedError = -2;
+    static UnsupportedError = -3;
+    static NotFoundError = -4;
+    static InvalidArgument = -5;
+    static BadArgumentSize = -6;
+    static InvalidElement = -100;
+    static BadElementType = -101;
+    static BadTaskType = -102;
+    static CssStyleNotExists = -120;
+    static CssStyleNotChanged = -121;
+    static CssStyleBadName = -122;
+    static CssStyleBadType = -123;
+    static CssClassNotChanged = -124;
+    static ForgeInsertView = -200;
+    /*** private ***/
+    constructor() { throw new Error("new ErrCode() is forbidden."); }
+}
+function ASSERT_AND_RETPTR(condition, retPtr, errMsgs = []) {
+    ASSERT_AND_RETURN(condition, ErrCode.GetErrorMessage(errMsgs), retPtr);
+}
+function CHECK_AND_RETVAL(errCode, retVal, errMsgs = []) {
+    CHECK_AND_RETURN(errCode, ErrCode.GetErrorMessage(errMsgs), retVal);
+}
+function CHECK_AND_RETURN(errCode, errMsgs, ret = undefined) {
+    if ((errCode) < 0) {
+        ErrCode.PrintErrorMessage("__FILE_NAME__", "__LINE__", [
+            ErrCode.ToString(errCode), ". ",
+            errMsgs,
+        ]);
+        throw new Error(ret);
+    }
+}
+function ASSERT_AND_RETURN(condition, errMsgs, ret = undefined) {
+    if (!(condition)) {
+        ErrCode.PrintErrorMessage("__FILE_NAME__", "__LINE__", [
+            "ASSERT(" + condition + ")", ". ",
+            errMsgs,
+        ]);
+        throw new Error(ret);
+    }
+}
+
+class StyleName {
+    static Layout = class {
+        static Height = "height";
+        static Left = "left";
+        static Top = "top";
+        static Width = "width";
+        constructor() { throw new Error("new StyleName.Layout() is forbidden."); }
+    };
+    static Background = class {
+        static BackgroundColor = "backgroundColor";
+        static BackgroundImage = "backgroundImage";
+        static BorderRadius = "borderRadius";
+        constructor() { throw new Error("new StyleName.Background() is forbidden."); }
+    };
+    static Effect = class {
+        static BackfaceVisibility = "backfaceVisibility";
+        static BorderImage = "borderImage";
+        static BorderImageWidth = "borderImageWidth";
+        static BorderImageOutset = "borderImageOutset";
+        // static ClipPath: string = "clipPath";
+        static Display = "display";
+        static ObjectFit = "objectFit";
+        static Opacity = "opacity";
+        static Overflow = "overflow";
+        static Perspective = "perspective";
+        static PerspectiveOrigin = "perspectiveOrigin";
+        static Transform = "transform";
+        static TransformOrigin = "transformOrigin";
+        static TransformStyle = "transformStyle";
+        static Visibility = "visibility";
+        static ZIndex = "zIndex";
+        constructor() { throw new Error("new StyleName.Effect() is forbidden."); }
+    };
+    static Text = class {
+        static Color = "color";
+        static FontFamily = "fontFamily";
+        static FontSize = "fontSize";
+        static FontStyle = "fontStyle";
+        static FontWeight = "fontWeight";
+        static LineHeight = "lineHeight";
+        static TextAlign = "textAlign";
+        static TextOverflow = "textOverflow";
+        static TextShadow = "textShadow";
+        static WebkitTextStroke = "WebkitTextStroke";
+        static WhiteSpace = "whiteSpace";
+        static WordWrap = "wordWrap";
+        static Direction = "direction";
+        static JsvTextEmoji = "JsvTextEmoji";
+        static JsvTextLatex = "JsvTextLatex";
+        static JsvTextAlignMinWidth = "JsvTextAlignMinWidth";
+        static JsvTextVerticalAlign = "JsvTextVerticalAlign";
+        static JsvTextLineAlign = "JsvTextLineAlign";
+        static JsvTextInnerDirection = "JsvTextInnerDirection";
+        constructor() { throw new Error("new StyleName.Text() is forbidden."); }
+    };
+    static Motion = class {
+        static Animation = "animation";
+        static Transition = "transition";
+        constructor() { throw new Error("new StyleName.Motion() is forbidden."); }
+    };
+    static HasGetterMethod(name) {
+        switch (name) {
+            case StyleName.Layout.Height:
+            case StyleName.Layout.Left:
+            case StyleName.Layout.Top:
+            case StyleName.Layout.Width:
+            case StyleName.Effect.ObjectFit:
+                return true;
+            default:
+                return false;
+        }
+    }
+    static ToConst(name) {
+        if (name == StyleName.Layout.Height) {
+            return StyleName.Layout.Height;
+        }
+        else if (name == StyleName.Layout.Left) {
+            return StyleName.Layout.Left;
+        }
+        else if (name == StyleName.Layout.Top) {
+            return StyleName.Layout.Top;
+        }
+        else if (name == StyleName.Layout.Width) {
+            return StyleName.Layout.Width;
+        }
+        else if (name == StyleName.Background.BackgroundColor) {
+            return StyleName.Background.BackgroundColor;
+        }
+        else if (name == StyleName.Background.BackgroundImage) {
+            return StyleName.Background.BackgroundImage;
+        }
+        else if (name == StyleName.Background.BorderRadius) {
+            return StyleName.Background.BorderRadius;
+        }
+        else if (name == StyleName.Effect.BackfaceVisibility) {
+            return StyleName.Effect.BackfaceVisibility;
+        }
+        else if (name == StyleName.Effect.BorderImage) {
+            return StyleName.Effect.BorderImage;
+        }
+        else if (name == StyleName.Effect.BorderImageWidth) {
+            return StyleName.Effect.BorderImageWidth;
+        }
+        else if (name == StyleName.Effect.BorderImageOutset) {
+            return StyleName.Effect.BorderImageOutset;
+        }
+        // else if (name == StyleName.Effect.ClipPath) { return StyleName.Effect.ClipPath; }
+        else if (name == StyleName.Effect.Display) {
+            return StyleName.Effect.Display;
+        }
+        else if (name == StyleName.Effect.ObjectFit) {
+            return StyleName.Effect.ObjectFit;
+        }
+        else if (name == StyleName.Effect.Opacity) {
+            return StyleName.Effect.Opacity;
+        }
+        else if (name == StyleName.Effect.Overflow) {
+            return StyleName.Effect.Overflow;
+        }
+        else if (name == StyleName.Effect.Perspective) {
+            return StyleName.Effect.Perspective;
+        }
+        else if (name == StyleName.Effect.PerspectiveOrigin) {
+            return StyleName.Effect.PerspectiveOrigin;
+        }
+        else if (name == StyleName.Effect.Transform) {
+            return StyleName.Effect.Transform;
+        }
+        else if (name == StyleName.Effect.TransformOrigin) {
+            return StyleName.Effect.TransformOrigin;
+        }
+        else if (name == StyleName.Effect.TransformStyle) {
+            return StyleName.Effect.TransformStyle;
+        }
+        else if (name == StyleName.Effect.Visibility) {
+            return StyleName.Effect.Visibility;
+        }
+        else if (name == StyleName.Effect.ZIndex) {
+            return StyleName.Effect.ZIndex;
+        }
+        else if (name == StyleName.Text.Color) {
+            return StyleName.Text.Color;
+        }
+        else if (name == StyleName.Text.FontFamily) {
+            return StyleName.Text.FontFamily;
+        }
+        else if (name == StyleName.Text.FontSize) {
+            return StyleName.Text.FontSize;
+        }
+        else if (name == StyleName.Text.FontStyle) {
+            return StyleName.Text.FontStyle;
+        }
+        else if (name == StyleName.Text.FontWeight) {
+            return StyleName.Text.FontWeight;
+        }
+        else if (name == StyleName.Text.LineHeight) {
+            return StyleName.Text.LineHeight;
+        }
+        else if (name == StyleName.Text.TextAlign) {
+            return StyleName.Text.TextAlign;
+        }
+        else if (name == StyleName.Text.TextOverflow) {
+            return StyleName.Text.TextOverflow;
+        }
+        else if (name == StyleName.Text.TextShadow) {
+            return StyleName.Text.TextShadow;
+        }
+        else if (name == StyleName.Text.WebkitTextStroke) {
+            return StyleName.Text.WebkitTextStroke;
+        }
+        else if (name == StyleName.Text.WhiteSpace) {
+            return StyleName.Text.WhiteSpace;
+        }
+        else if (name == StyleName.Text.WordWrap) {
+            return StyleName.Text.WordWrap;
+        }
+        else if (name == StyleName.Text.Direction) {
+            return StyleName.Text.Direction;
+        }
+        else if (name == StyleName.Text.JsvTextEmoji) {
+            return StyleName.Text.JsvTextEmoji;
+        }
+        else if (name == StyleName.Text.JsvTextLatex) {
+            return StyleName.Text.JsvTextLatex;
+        }
+        else if (name == StyleName.Text.JsvTextAlignMinWidth) {
+            return StyleName.Text.JsvTextAlignMinWidth;
+        }
+        else if (name == StyleName.Text.JsvTextVerticalAlign) {
+            return StyleName.Text.JsvTextVerticalAlign;
+        }
+        else if (name == StyleName.Text.JsvTextLineAlign) {
+            return StyleName.Text.JsvTextLineAlign;
+        }
+        else if (name == StyleName.Text.JsvTextInnerDirection) {
+            return StyleName.Text.JsvTextInnerDirection;
+        }
+        else if (name == StyleName.Motion.Animation) {
+            return StyleName.Motion.Animation;
+        }
+        else if (name == StyleName.Motion.Transition) {
+            return StyleName.Motion.Transition;
+        }
+        return null;
+    }
+    constructor() { throw new Error("new StyleName() is forbidden."); }
+}
+class StyleValue {
+    static Base = class {
+        constructor(rawValue) {
+            this.rawValue = rawValue;
+        }
+        rawValue;
+    };
+    static AnimationImpl = class extends StyleValue.Base {
+        constructor(rawValue) {
+            super(rawValue);
+        }
+        name = "";
+        duration = 0;
+        timingFunction = null;
+        delay = 0;
+        iterationCount = 0;
+        direction = false;
+    };
+    static CornerImpl = class extends StyleValue.Base {
+        constructor(rawValue) {
+            super(rawValue);
+        }
+        topLeft = 0;
+        topRight = 0;
+        bottomRight = 0;
+        bottomLeft = 0;
+    };
+    static RectImpl = class extends StyleValue.Base {
+        constructor(rawValue) {
+            super(rawValue);
+        }
+        top = 0;
+        right = 0;
+        left = 0;
+        bottom = 0;
+    };
+    static TextShadowImpl = class extends StyleValue.Base {
+        constructor(rawValue) {
+            super(rawValue);
+        }
+        hShadow = 0;
+        vShadow = 0;
+        blur = 0;
+        color = undefined;
+    };
+    static WebkitTextStrokeImpl = class extends StyleValue.Base {
+        constructor(rawValue) {
+            super(rawValue);
+        }
+        length = 0;
+        color = undefined;
+    };
+    static TransitionImpl = class extends StyleValue.Base {
+        constructor(rawValue) {
+            super(rawValue);
+        }
+        animationMap = new Map();
+    };
+    static BorderImageImpl = class extends StyleValue.Base {
+        constructor(rawValue) {
+            super(rawValue);
+        }
+        source = "";
+        slice = null;
+    };
+    static DataType = class {
+        static Null = 0;
+        static Int32 = 1;
+        static Float = 2;
+        static String = 3;
+        static Animation = 4;
+        static Corner = 5;
+        static Rect = 6;
+        static TextShadow = 7;
+        static WebkitTextStroke = 8;
+        static Transition = 9;
+        static BorderImage = 10;
+    };
+    static InvalidInt32 = Number.MIN_VALUE;
+    static InvalidFloat = Number.NaN;
+    static InvalidPointer = null;
+    constructor(data) {
+        let index = -1;
+        let value = null;
+        if (data == null) {
+            index = StyleValue.DataType.Null;
+        }
+        else if (Number(data) === data && data % 1 === 0) {
+            index = StyleValue.DataType.Int32;
+        }
+        else if (Number(data) === data && data % 1 !== 0) {
+            index = StyleValue.DataType.Float;
+        }
+        else if (typeof data === 'string' || data instanceof String) {
+            index = StyleValue.DataType.String;
+        }
+        else if (data instanceof StyleValue.AnimationImpl) {
+            index = StyleValue.DataType.Animation;
+        }
+        else if (data instanceof StyleValue.CornerImpl) {
+            index = StyleValue.DataType.Corner;
+        }
+        else if (data instanceof StyleValue.RectImpl) {
+            index = StyleValue.DataType.Rect;
+        }
+        else if (data instanceof StyleValue.TextShadowImpl) {
+            index = StyleValue.DataType.TextShadow;
+        }
+        else if (data instanceof StyleValue.WebkitTextStrokeImpl) {
+            index = StyleValue.DataType.WebkitTextStroke;
+        }
+        else if (data instanceof StyleValue.TransitionImpl) {
+            index = StyleValue.DataType.Transition;
+        }
+        else if (data instanceof StyleValue.BorderImageImpl) {
+            index = StyleValue.DataType.BorderImage;
+        }
+        if (data != StyleValue.InvalidInt32
+            && data != StyleValue.InvalidFloat
+            && data != StyleValue.InvalidPointer) {
+            value = data;
+        }
+        else {
+            index = StyleValue.DataType.Null;
+            value = null;
+        }
+        this.data = new StyleValue.DataInfo();
+        this.data.index = index;
+        this.data.value = value;
+    }
+    is(type) {
+        return this.data.index == type;
+    }
+    get() {
+        return this.data.value;
+    }
+    reset(rhs) {
+        this.data.value = rhs.data.value;
+        this.data.index = rhs.data.index;
+    }
+    equals(rhs) {
+        return (this.data.value === rhs.data.value
+            && this.data.index === rhs.data.index);
+    }
+    static DataInfo = class {
+        value = null;
+        index = -1;
+    };
+    data;
+}
+class StyleVariable {
+    static FormatVariableName(varName) {
+        if (varName.startsWith('--')) {
+            return 'var(' + varName + ')'; // var(--xxx)
+        }
+        else if (varName.startsWith('var(--')) {
+            return varName;
+        }
+        ASSERT_AND_RETPTR(false, null);
+        return null;
+    }
+    static IsVariable(value) {
+        let variable;
+        if (value instanceof StyleValue) {
+            if (value.is(StyleValue.DataType.String) == false) {
+                return false;
+            }
+            variable = value.get();
+        }
+        else if (typeof value === 'string') {
+            variable = value;
+        }
+        else {
+            return false;
+        }
+        const isVar = (variable.startsWith("--") || variable.startsWith("var(--"));
+        return isVar;
+    }
+    constructor() { throw new Error("new StyleVariable() is forbidden."); }
+}
+
+class StyleFormator {
+    /*** public ***/
+    static StringToInt32(value) {
+        let ret = StyleValue.InvalidInt32;
+        let int32Value = parseInt(value);
+        if (isNaN(int32Value) == false) {
+            ret = int32Value;
+        }
+        return ret;
+    }
+    static StringTrim(value) {
+        return value.trim();
+    }
+    static StringStartsWith(value, starting) {
+        return value.startsWith(starting);
+    }
+    static StringEndsWith(value, ending) {
+        return value.endsWith(ending);
+    }
+    static StringSplit(from, delimiter = " ") {
+        if (!from) {
+            from = "";
+        }
+        let arrays = from.trim().split(delimiter);
+        if (delimiter !== ' ') {
+            return arrays;
+        }
+        //去除多个空格的条件下的影响
+        let ret = [];
+        for (let item of arrays) {
+            if (!item) {
+                continue;
+            }
+            ret.push(item);
+        }
+        return ret;
+    }
+    static ConvertToInt32(value) {
+        if (value.is(StyleValue.DataType.Null)) {
+            return 0;
+        }
+        else if (value.is(StyleValue.DataType.String)) {
+            const strValue = value.get();
+            if (strValue === "") {
+                return 0;
+            }
+            else {
+                StyleFormator.StringTrim(strValue);
+                if (StyleFormator.StringEndsWith(strValue, "px")) {
+                    const msg = 'JsView Warning:'
+                        + ' Using px will make style performance lower,'
+                        + ' you can directly use numbers instead of "' + strValue + '".';
+                    console.warn(msg);
+                    return StyleFormator.StringToInt32(strValue);
+                }
+            }
+        }
+        else if (value.is(StyleValue.DataType.Int32)) {
+            return value.get();
+        }
+        else if (value.is(StyleValue.DataType.Float)) {
+            return value.get();
+        }
+        CHECK_AND_RETVAL(ErrCode.InvalidArgument, StyleValue.InvalidInt32);
+        return StyleValue.InvalidInt32;
+    }
+    static ConvertToFloat(value) {
+        if (value.is(StyleValue.DataType.Null)) {
+            return StyleValue.InvalidFloat;
+        }
+        else if (value.is(StyleValue.DataType.String) && value.get() === "") {
+            return 0;
+        }
+        else if (value.is(StyleValue.DataType.Int32)) {
+            return value.get();
+        }
+        else if (value.is(StyleValue.DataType.Float)) {
+            return value.get();
+        }
+        CHECK_AND_RETVAL(ErrCode.InvalidArgument, StyleValue.InvalidFloat);
+        return StyleValue.InvalidFloat;
+    }
+    static ConvertToString(value, upperCase = false) {
+        if (value.is(StyleValue.DataType.Null)) {
+            return StyleValue.InvalidPointer;
+        }
+        if (value.is(StyleValue.DataType.String) == false) {
+            CHECK_AND_RETVAL(ErrCode.InvalidArgument, StyleValue.InvalidPointer);
+        }
+        let propValue = value.get();
+        if (propValue == null || propValue.length <= 0) {
+            return StyleValue.InvalidPointer;
+        }
+        if (upperCase) {
+            propValue = propValue.toUpperCase();
+        }
+        return propValue;
+    }
+    static ConvertToCorner(value) {
+        if (value.is(StyleValue.DataType.Null)) {
+            return StyleValue.InvalidPointer;
+        }
+        let corner = null;
+        if (value.is(StyleValue.DataType.Int32)) {
+            const propValue = value.get();
+            corner = new StyleValue.CornerImpl(String(propValue));
+            corner.topLeft = propValue;
+            corner.topRight = propValue;
+            corner.bottomRight = propValue;
+            corner.bottomLeft = propValue;
+        }
+        else if (value.is(StyleValue.DataType.String)) {
+            const propValue = value.get();
+            if (propValue == null || propValue.length <= 0) {
+                return StyleValue.InvalidPointer;
+            }
+            const propValueArray = StyleFormator.StringSplit(propValue);
+            const propValueSize = propValueArray.length;
+            corner = new StyleValue.CornerImpl(propValue);
+            corner.topLeft = (propValueSize > 0 ? parseInt(propValueArray[0]) : 0);
+            corner.topRight = (propValueSize > 1 ? parseInt(propValueArray[1]) : corner.topLeft);
+            corner.bottomRight = (propValueSize > 2 ? parseInt(propValueArray[2]) : corner.topLeft);
+            corner.bottomLeft = (propValueSize > 3 ? parseInt(propValueArray[3]) : corner.bottomRight);
+        }
+        else {
+            CHECK_AND_RETVAL(ErrCode.InvalidArgument, StyleValue.InvalidPointer);
+        }
+        return corner;
+    }
+    static ConvertToRect(value) {
+        if (value.is(StyleValue.DataType.Null)) {
+            return StyleValue.InvalidPointer;
+        }
+        if (value.is(StyleValue.DataType.String) == false) {
+            CHECK_AND_RETVAL(ErrCode.InvalidArgument, StyleValue.InvalidPointer);
+        }
+        const propValue = value.get();
+        if (propValue == null || propValue.length <= 0) {
+            return StyleValue.InvalidPointer;
+        }
+        const rect = new StyleValue.RectImpl(propValue);
+        const propValueArray = StyleFormator.StringSplit(propValue);
+        const propValueSize = propValueArray.length;
+        rect.top = (propValueSize > 0 ? parseInt(propValueArray[0]) : 0);
+        rect.right = (propValueSize > 1 ? parseInt(propValueArray[1]) : rect.top);
+        rect.bottom = (propValueSize > 2 ? parseInt(propValueArray[2]) : rect.top);
+        rect.left = (propValueSize > 3 ? parseInt(propValueArray[3]) : rect.right);
+        return rect;
+    }
+    static ConvertToAnimation(value, compare = null) {
+        if (value.is(StyleValue.DataType.Null)) {
+            return StyleValue.InvalidPointer;
+        }
+        if (value.is(StyleValue.DataType.String) == false) {
+            CHECK_AND_RETVAL(ErrCode.InvalidArgument, StyleValue.InvalidPointer);
+        }
+        const propValue = value.get();
+        if (propValue == null || propValue.length <= 0) {
+            return StyleValue.InvalidPointer;
+        }
+        // 和compare相同，直接返回compare加速
+        if (compare != null && compare.rawValue != null
+            && compare.rawValue == propValue) {
+            return compare;
+        }
+        const anim = StyleFormator.ParseToAnimation(propValue);
+        return anim;
+    }
+    static ConvertToTransition(value, compare = null) {
+        if (value.is(StyleValue.DataType.Null)) {
+            return StyleValue.InvalidPointer;
+        }
+        if (value.is(StyleValue.DataType.String) == false) {
+            CHECK_AND_RETVAL(ErrCode.InvalidArgument, StyleValue.InvalidPointer);
+        }
+        const propValue = value.get();
+        if (propValue == null || propValue.length <= 0) {
+            return StyleValue.InvalidPointer;
+        }
+        // 和compare相同，直接返回compare加速
+        if (compare != null && compare.rawValue != null
+            && compare.rawValue == propValue) {
+            return compare;
+        }
+        let arrays = [];
+        const splitStr = StyleFormator.StringSplit(propValue, ",");
+        // 如果包含"(", 则将直到")"为止的内容当作一个部分
+        for (let idx = 0; idx < splitStr.length; idx++) {
+            if (splitStr[idx].indexOf('(') >= 0) {
+                let endIdx = idx;
+                while (endIdx < splitStr.length && splitStr[endIdx].indexOf(')') < 0) { // 没有包含")"
+                    endIdx++;
+                }
+                let concatStr = "";
+                for (let subIdx = idx; subIdx <= endIdx; subIdx++) {
+                    if (subIdx != idx) {
+                        concatStr += ",";
+                    }
+                    concatStr += splitStr[subIdx];
+                }
+                idx = endIdx;
+                arrays.push(concatStr);
+            }
+            else {
+                arrays.push(splitStr[idx]);
+            }
+        }
+        // console.warn("StyleFormator.ConvertToTransition() arrays=" + JSON.stringify(arrays));
+        const transition = new StyleValue.TransitionImpl(propValue);
+        for (const item of arrays) {
+            const ret = StyleFormator.ConvertToAnimation(new StyleValue(item));
+            if (ret == null) {
+                continue;
+            }
+            transition.animationMap.set(ret.name, ret);
+            if (ret?.name == "all") {
+                const allProps = ["opacity", "left", "top", "width", "height", "transform"];
+                for (const prop of allProps) {
+                    transition.animationMap.set(prop, ret);
+                }
+            }
+        }
+        return transition;
+    }
+    static ConvertToTextShadow(value) {
+        if (value.is(StyleValue.DataType.Null)) {
+            return StyleValue.InvalidPointer;
+        }
+        if (value.is(StyleValue.DataType.String) == false) {
+            CHECK_AND_RETVAL(ErrCode.InvalidArgument, StyleValue.InvalidPointer);
+        }
+        const propValue = value.get();
+        if (propValue == null || propValue.length <= 0) {
+            return StyleValue.InvalidPointer;
+        }
+        const textShadow = new StyleValue.TextShadowImpl(propValue);
+        const textShadowArray = StyleFormator.StringSplit(propValue);
+        if (textShadowArray.length > 0) {
+            textShadow.hShadow = parseInt(textShadowArray[0]);
+        }
+        if (textShadowArray.length > 1) {
+            textShadow.vShadow = parseInt(textShadowArray[1]);
+        }
+        if (textShadowArray.length > 2) {
+            textShadow.blur = parseInt(textShadowArray[2]);
+        }
+        let colorIndex = -1;
+        if (textShadowArray.length == 3) {
+            colorIndex = 2;
+        }
+        else if (textShadowArray.length > 3) {
+            colorIndex = 3;
+        }
+        if (colorIndex > 0) {
+            textShadow.color = textShadowArray[colorIndex];
+        }
+        return textShadow;
+    }
+    static ConvertToWebkitTextStroke(value) {
+        if (value.is(StyleValue.DataType.Null)) {
+            return StyleValue.InvalidPointer;
+        }
+        if (value.is(StyleValue.DataType.String) == false) {
+            CHECK_AND_RETVAL(ErrCode.InvalidArgument, StyleValue.InvalidPointer);
+        }
+        const propValue = value.get();
+        if (propValue == null || propValue.length <= 0) {
+            return StyleValue.InvalidPointer;
+        }
+        const webkitTextStroke = new StyleValue.WebkitTextStrokeImpl(propValue);
+        const webkitTextStrokeArray = StyleFormator.StringSplit(propValue);
+        if (webkitTextStrokeArray.length > 0) {
+            webkitTextStroke.length = parseInt(webkitTextStrokeArray[0]);
+        }
+        if (webkitTextStrokeArray.length > 1) {
+            webkitTextStroke.color = webkitTextStrokeArray[1];
+        }
+        return webkitTextStroke;
+    }
+    static ConvertToBorderImage(value) {
+        if (value.is(StyleValue.DataType.Null)) {
+            return StyleValue.InvalidPointer;
+        }
+        if (value.is(StyleValue.DataType.String) == false) {
+            CHECK_AND_RETVAL(ErrCode.InvalidArgument, StyleValue.InvalidPointer);
+        }
+        const propValue = value.get();
+        if (propValue == null || propValue.length <= 0) {
+            return StyleValue.InvalidPointer;
+        }
+        const borderImage = new StyleValue.BorderImageImpl(propValue);
+        const propValueArray = StyleFormator.StringSplit(propValue);
+        const propValueSize = propValueArray.length;
+        if (propValueSize > 0) {
+            borderImage.source = propValueArray[0];
+        }
+        if (propValueSize > 1) {
+            borderImage.slice = StyleFormator.ConvertToRect(new StyleValue(propValueArray[1]));
+        }
+        return borderImage;
+    }
+    static ParseToAnimation(value) {
+        const trimmed = StyleFormator.StringTrim(value);
+        let arrays = [];
+        const bezierStart = trimmed.indexOf("cubic-bezier");
+        if (bezierStart >= 0) { // 防止贝塞尔里面的空格被拆分
+            const bezierEnd = trimmed.indexOf(')');
+            const bezierStr = trimmed.substring(bezierStart, bezierEnd - 1);
+            const bezierArray = StyleFormator.StringSplit(trimmed, bezierStr);
+            for (const item of bezierArray) {
+                const subArrays = StyleFormator.StringSplit(item);
+                arrays.concat(subArrays);
+            }
+            arrays.push(bezierStr);
+        }
+        else {
+            arrays = StyleFormator.StringSplit(trimmed);
+        }
+        // 下面四个属性在animation字符串中是无序的，所以需要单独判断。
+        let timingFunction = "";
+        let delay = 0;
+        let iterationCount = 1;
+        let direction = (trimmed.indexOf("alternate") >= 0);
+        for (var idx = 2; idx < arrays.length; idx++) { // 前两个选项固定是name和duration
+            if (arrays[idx] == "infinite") {
+                iterationCount = -1; // -1表示无限循环
+                continue;
+            }
+            let num = StyleFormator.ParseToTimeMs(arrays[idx]);
+            if (isNaN(num) == false) { // 表示时间
+                delay = num;
+            }
+            else {
+                num = StyleFormator.ParseToFloat(arrays[idx]);
+                if (isNaN(num) == false) { // 表示次数
+                    iterationCount = num;
+                }
+                else { // 不是数字，直接赋给timingFunction，省略判断
+                    timingFunction = arrays[idx];
+                }
+            }
+        }
+        const duration = arrays.length > 1 ? StyleFormator.ParseToTimeMs(arrays[1]) : 0.0;
+        const anim = new StyleValue.AnimationImpl(trimmed);
+        anim.name = arrays.length > 0 ? arrays[0] : "";
+        anim.duration = duration;
+        anim.timingFunction = StyleFormator.ParseToEasing(timingFunction, duration);
+        anim.delay = delay;
+        anim.iterationCount = iterationCount;
+        anim.direction = direction;
+        //        .originStr      = propValue,
+        return anim;
+    }
+    static ParseToTimeMs(from) {
+        if (StyleFormator.StringEndsWith(from, "s") == false) { // ms / s
+            return NaN;
+        }
+        let timing = StyleFormator.ParseToFloat(from);
+        if (StyleFormator.StringEndsWith(from, "ms")) {
+            timing *= 1.0;
+        }
+        else if (StyleFormator.StringEndsWith(from, "s")) {
+            timing *= 1000.0;
+        }
+        //    timing *= std::stof(from);
+        return timing;
+    }
+    static ParseToFloat(from) {
+        const trimmed = StyleFormator.StringTrim(from);
+        return parseFloat(trimmed);
+    }
+    static ParseToEasing(from, duration) {
+        let easing = null;
+        if (from.indexOf("ease") >= 0) {
+            if (from.indexOf("-in-out") >= 0) {
+                easing = Forge.Easing.Circular.InOut;
+            }
+            else if (from.indexOf("-out") >= 0) {
+                easing = Forge.Easing.Circular.Out;
+            }
+            else if (from.indexOf("-in") >= 0) {
+                easing = Forge.Easing.Circular.In;
+            }
+            else {
+                easing = Forge.Easing.Circular.InOut;
+            }
+        }
+        else if (from.indexOf("linear") >= 0) {
+            easing = null; // null是匀速动画
+        }
+        else if (from.indexOf("cubic-bezier") >= 0) {
+            easing = StyleFormator.ParseToEasingBezier(from, duration);
+        }
+        else if (from.indexOf("steps") >= 0) {
+            easing = StyleFormator.ParseToEasingSteps(from);
+        }
+        return easing;
+    }
+    static ParseToEasingBezier(jsDescribe, duration) {
+        let startIdx = jsDescribe.indexOf('(');
+        if (startIdx >= 0) {
+            jsDescribe = jsDescribe.substring(startIdx + 1);
+        }
+        let arrays = StyleFormator.StringSplit(jsDescribe, ',');
+        let bezier = {
+            x1: arrays.length > 0 ? parseFloat(arrays[0]) : 0,
+            y1: arrays.length > 1 ? parseFloat(arrays[1]) : 0,
+            x2: arrays.length > 2 ? parseFloat(arrays[2]) : 0,
+            y2: arrays.length > 3 ? parseFloat(arrays[3]) : 0,
+        };
+        return new Forge.BezierEasing(bezier.x1, bezier.y1, bezier.x2, bezier.y2, duration);
+    }
+    static ParseToEasingSteps(jsDescribe) {
+        let startIdx = jsDescribe.indexOf('(');
+        if (startIdx >= 0) {
+            jsDescribe = jsDescribe.substring(startIdx + 1);
+        }
+        let arrays = StyleFormator.StringSplit(jsDescribe, ',');
+        let steps = {
+            steps: arrays.length > 0 ? parseInt(arrays[0]) : 1,
+            type: arrays.length > 1 ? (arrays[1].includes("start") ? 0 : 1) : 0,
+        };
+        return new Forge.StepsEasing(steps.steps, steps.type);
+    }
+    constructor() { throw new Error("new StyleGroup() is forbidden."); }
+}
+
+exports.StyleFormator = StyleFormator;
+exports.StyleName = StyleName;
+exports.StyleValue = StyleValue;
+exports.StyleVariable = StyleVariable;