@galacean/effects-plugin-rich-text 0.0.0-experimental-20250512

package/dist/index.mjs

@@ -0,0 +1,620 @@
+/*!
+ * Name: @galacean/effects-plugin-rich-text
+ * Description: Galacean Effects player rich text plugin
+ * Author: Ant Group CO., Ltd.
+ * Contributors: 云垣
+ * Version: v0.0.0-experimental-20250512
+ */
+
+import * as EFFECTS from '@galacean/effects';
+import { AbstractPlugin, effectsClass, spec, math, assertExist, Texture, glContext, TextStyle, TextLayout, TextComponent, registerPlugin, VFXItem, logger } from '@galacean/effects';
+
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+
+var RichTextLoader = /*#__PURE__*/ function(AbstractPlugin) {
+    _inherits(RichTextLoader, AbstractPlugin);
+    function RichTextLoader() {
+        var _this;
+        _this = AbstractPlugin.apply(this, arguments) || this;
+        _this.name = "rich-text";
+        return _this;
+    }
+    return RichTextLoader;
+}(AbstractPlugin);
+
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+
+function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
+    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+    if (it) return (it = it.call(o)).next.bind(it);
+    // Fallback for engines without symbol support
+    if (Array.isArray(o) || (it = _unsupported_iterable_to_array(o)) || allowArrayLike && o && typeof o.length === "number") {
+        if (it) o = it;
+        var i = 0;
+        return function() {
+            if (i >= o.length) return {
+                done: true
+            };
+            return {
+                done: false,
+                value: o[i++]
+            };
+        };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+var TokenType;
+(function(TokenType) {
+    TokenType["ContextStart"] = "ContextStart";
+    TokenType["Text"] = "Text";
+    TokenType["ContextEnd"] = "ContextEnd";
+})(TokenType || (TokenType = {}));
+var contextStartRegexp = /^<([a-z]+)(=([^>]+))?>$/;
+var contextEndRegexp = /^<\/([a-z]+)>$/;
+var rules = [
+    [
+        "ContextStart",
+        /^<[a-z]+(=[^>]+)?>/
+    ],
+    [
+        "Text",
+        /^[^</>=]+/
+    ],
+    [
+        "ContextEnd",
+        /^<\/[a-z]+>/
+    ]
+];
+var lexer = function(input, lexed, cursor) {
+    if (lexed === void 0) lexed = [];
+    if (cursor === void 0) cursor = 0;
+    if (!input) {
+        return lexed;
+    }
+    for(var _iterator = _create_for_of_iterator_helper_loose(rules), _step; !(_step = _iterator()).done;){
+        var _step_value = _step.value, tokenType = _step_value[0], regex = _step_value[1];
+        var _regex_exec;
+        var _ref = (_regex_exec = regex.exec(input)) != null ? _regex_exec : [], tokenMatch = _ref[0];
+        if (tokenMatch) {
+            var len = tokenMatch.length;
+            return lexer(input.slice(len), lexed.concat({
+                tokenType: tokenType,
+                value: tokenMatch
+            }), cursor + len);
+        }
+    }
+    throw new Error('Unexpected token: "' + input[0] + '" at position ' + cursor + ' while reading "' + input + '"');
+};
+var richTextParser = function(input) {
+    var Text = function Text() {
+        var maybeText = peek();
+        if ((maybeText == null ? void 0 : maybeText.tokenType) === "Text") {
+            shift();
+            return maybeText.value;
+        }
+        return undefined;
+    };
+    var ContextStart = function ContextStart() {
+        var maybeContextStart = peek();
+        if ((maybeContextStart == null ? void 0 : maybeContextStart.tokenType) === "ContextStart") {
+            shift();
+            var matches = maybeContextStart.value.match(contextStartRegexp);
+            if (matches) {
+                var attributeName = matches[1];
+                var _matches_;
+                var attributeParam = (_matches_ = matches[3]) != null ? _matches_ : "";
+                return {
+                    attributeName: attributeName,
+                    attributeParam: attributeParam
+                };
+            }
+            throw new Error("Expected a start tag marker at position " + cursor);
+        }
+        return {};
+    };
+    var ContextEnd = function ContextEnd() {
+        var maybeContextEnd = peek();
+        if ((maybeContextEnd == null ? void 0 : maybeContextEnd.tokenType) === "ContextEnd") {
+            shift();
+            var matches = maybeContextEnd.value.match(contextEndRegexp);
+            if (matches) {
+                var attributeName = matches[1];
+                return {
+                    attributeName: attributeName
+                };
+            }
+            throw new Error("Expect an end tag marker at position " + cursor);
+        }
+        return {};
+    };
+    var lexed = lexer(input);
+    var cursor = 0;
+    var shift = function() {
+        var shifted = lexed.shift();
+        var _shifted_value_length;
+        cursor += (_shifted_value_length = shifted == null ? void 0 : shifted.value.length) != null ? _shifted_value_length : 0;
+        return shifted;
+    };
+    var peek = function() {
+        return lexed[0];
+    };
+    var ast = [];
+    function Grammar(attributes, expectedEndAttributeName) {
+        if (attributes === void 0) attributes = [];
+        if (expectedEndAttributeName === void 0) expectedEndAttributeName = "";
+        var parsing = true;
+        while(parsing){
+            var maybeText = Text();
+            if (maybeText) {
+                ast.push({
+                    attributes: attributes,
+                    text: maybeText
+                });
+                continue;
+            }
+            var _ContextStart = ContextStart(), attributeName = _ContextStart.attributeName, attributeParam = _ContextStart.attributeParam;
+            if (attributeName) {
+                Grammar(attributes.concat({
+                    attributeName: attributeName,
+                    attributeParam: attributeParam
+                }), attributeName);
+                continue;
+            }
+            if (expectedEndAttributeName) {
+                var _ContextEnd = ContextEnd(), endAttributeName = _ContextEnd.attributeName;
+                if (!endAttributeName) {
+                    throw new Error('Expect an end tag marker "' + expectedEndAttributeName + '" at position ' + cursor + " but found no tag!");
+                }
+                if (endAttributeName !== expectedEndAttributeName) {
+                    throw new Error('Expect an end tag marker "' + expectedEndAttributeName + '" at position ' + cursor + ' but found tag "' + endAttributeName + '"');
+                }
+                return;
+            }
+            break;
+        }
+    }
+    Grammar();
+    return ast;
+};
+function generateProgram(textHandler) {
+    return function(richText) {
+        var ast = richTextParser(richText);
+        for(var _iterator = _create_for_of_iterator_helper_loose(ast), _step; !(_step = _iterator()).done;){
+            var node = _step.value;
+            var text = node.text;
+            var context = node.attributes.reduce(function(ctx, param) {
+                var attributeName = param.attributeName, attributeParam = param.attributeParam;
+                if (attributeName) {
+                    ctx[attributeName] = attributeParam;
+                }
+                return ctx;
+            }, {});
+            textHandler(text, context);
+        }
+    };
+}
+function isRichText(text) {
+    var lexed = lexer(text);
+    var contextTokens = lexed.filter(function(param) {
+        var tokenType = param.tokenType;
+        return tokenType === "ContextStart" || tokenType === "ContextEnd";
+    });
+    var contextStartTokens = contextTokens.filter(function(param) {
+        var tokenType = param.tokenType;
+        return tokenType === "ContextStart";
+    });
+    var contextEndTokens = contextTokens.filter(function(param) {
+        var tokenType = param.tokenType;
+        return tokenType === "ContextEnd";
+    });
+    if (contextStartTokens.length !== contextEndTokens.length || !contextStartTokens.length) {
+        return false;
+    }
+    var tokensOfAttribute = contextTokens.map(function(param) {
+        var tokenType = param.tokenType, value = param.value;
+        return {
+            tokenType: tokenType,
+            value: tokenType === "ContextStart" ? value.match(contextStartRegexp)[1] : value.match(contextEndRegexp)[1]
+        };
+    });
+    function checkPaired(param, startContextAttributes) {
+        var token = param[0], restToken = param.slice(1);
+        if (startContextAttributes === void 0) startContextAttributes = [];
+        if (!token) {
+            return startContextAttributes.length === 0;
+        }
+        if (token.tokenType === "ContextStart") {
+            return checkPaired(restToken, startContextAttributes.concat(token.value));
+        } else if (token.tokenType === "ContextEnd") {
+            var attributeName = startContextAttributes[startContextAttributes.length - 1];
+            if (attributeName !== token.value) {
+                return false;
+            }
+            return checkPaired(restToken, startContextAttributes.slice(0, -1));
+        }
+        throw new Error("Unexpected token: " + token.tokenType);
+    }
+    return checkPaired(tokensOfAttribute);
+}
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+typeof SuppressedError === "function" ? SuppressedError : function _SuppressedError(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * 将颜色名称转换为 RGBA
+ * @param colorName - 颜色名称
+ * @returns RGBA 颜色字符串
+ */ function colorNameToRGBA(colorName) {
+    if (typeof colorName !== "string" || !colorName) {
+        throw new Error("Invalid color name provided");
+    }
+    if (typeof document === "undefined") {
+        throw new Error("This method requires a browser environment");
+    }
+    var canvas = document.createElement("canvas");
+    var context = canvas.getContext("2d");
+    if (context) {
+        try {
+            context.fillStyle = colorName;
+            var result = context.fillStyle;
+            return result;
+        } finally{
+            // Clean up DOM element
+            canvas.remove();
+        }
+    }
+    throw new Error("Failed to get 2D context for color conversion!");
+}
+/**
+ * 将 16 进制颜色转换为 RGBA
+ * @param hex - 16 进制颜色
+ * @param alpha - 透明度
+ * @returns - RGBA 颜色
+ */ function hexToRGBA(hex, alpha) {
+    if (alpha === void 0) alpha = 1;
+    hex = hex.replace(/^#/, "");
+    if (hex.length === 3 || hex.length === 4) {
+        hex = hex.split("").map(function(char) {
+            return char + char;
+        }).join("");
+    }
+    // Handle alpha channel in hex
+    if (hex.length === 8) {
+        var a = parseInt(hex.slice(6, 8), 16) / 255;
+        hex = hex.slice(0, 6);
+        alpha = a;
+    }
+    var bigint = parseInt(hex, 16);
+    var r = bigint >> 16 & 255;
+    var g = bigint >> 8 & 255;
+    var b = bigint & 255;
+    return [
+        r,
+        g,
+        b,
+        alpha
+    ];
+}
+/**
+ * 将颜色字符串转换为 RGBA
+ * @param color - 颜色字符串
+ * @param alpha - 透明度
+ * @returns - RGBA 颜色
+ */ function toRGBA(color, alpha) {
+    if (alpha === void 0) alpha = 1;
+    if (typeof color !== "string" || !color) {
+        throw new Error("Invalid color string");
+    }
+    if (color.startsWith("#")) {
+        return hexToRGBA(color, alpha);
+    } else {
+        return hexToRGBA(colorNameToRGBA(color));
+    }
+}
+
+var seed = 0;
+var RichTextComponent = /*#__PURE__*/ function(TextComponent) {
+    _inherits(RichTextComponent, TextComponent);
+    function RichTextComponent(engine) {
+        var _this;
+        _this = TextComponent.call(this, engine) || this;
+        _this.processedTextOptions = [];
+        _this.singleLineHeight = 1.571;
+        _this.size = null;
+        /**
+   * 获取第一次渲染的 size
+   */ _this.initialized = false;
+        /**
+   * canvas 大小
+   */ _this.canvasSize = null;
+        _this.name = "MRichText" + seed++;
+        return _this;
+    }
+    var _proto = RichTextComponent.prototype;
+    _proto.generateTextProgram = function generateTextProgram(text) {
+        var _this = this;
+        this.processedTextOptions = [];
+        var program = generateProgram(function(text, context) {
+            // 如果富文本仅包含换行符，则在每个换行符后添加一个空格
+            if (/^\n+$/.test(text)) {
+                text = text.replace(/\n/g, "\n ");
+            }
+            var textArr = text.split("\n");
+            textArr.forEach(function(text, index) {
+                var options = {
+                    text: text,
+                    fontSize: _this.textStyle.fontSize,
+                    isNewLine: false
+                };
+                if (index > 0) {
+                    options.isNewLine = true;
+                }
+                if ("b" in context) {
+                    options.fontWeight = spec.TextWeight.bold;
+                }
+                if ("i" in context) {
+                    options.fontStyle = spec.FontStyle.italic;
+                }
+                if ("size" in context && context.size) {
+                    options.fontSize = parseInt(context.size, 10);
+                }
+                if ("color" in context && context.color) {
+                    options.fontColor = toRGBA(context.color);
+                }
+                _this.processedTextOptions.push(options);
+            });
+        });
+        program(text);
+    };
+    _proto.updateTexture = function updateTexture(flipY) {
+        var _this = this;
+        if (flipY === void 0) flipY = true;
+        if (!this.isDirty || !this.context || !this.canvas) {
+            return;
+        }
+        this.generateTextProgram(this.text);
+        var width = 0, height = 0;
+        var _this1 = this, textLayout = _this1.textLayout, textStyle = _this1.textStyle;
+        var overflow = textLayout.overflow, _textLayout_letterSpace = textLayout.letterSpace, letterSpace = _textLayout_letterSpace === void 0 ? 0 : _textLayout_letterSpace;
+        var context = this.context;
+        context.save();
+        var charsInfo = [];
+        var fontHeight = textStyle.fontSize * this.textStyle.fontScale;
+        var charInfo = {
+            richOptions: [],
+            offsetX: [],
+            width: 0,
+            lineHeight: fontHeight * this.singleLineHeight,
+            offsetY: fontHeight * (this.singleLineHeight - 1) / 2
+        };
+        this.processedTextOptions.forEach(function(options) {
+            var text = options.text, isNewLine = options.isNewLine, fontSize = options.fontSize;
+            if (isNewLine) {
+                charsInfo.push(charInfo);
+                width = Math.max(width, charInfo.width);
+                charInfo = {
+                    richOptions: [],
+                    offsetX: [],
+                    width: 0,
+                    lineHeight: fontHeight * _this.singleLineHeight,
+                    offsetY: fontHeight * (_this.singleLineHeight - 1) / 2
+                };
+                height += charInfo.lineHeight;
+            }
+            //恢复默认设置
+            context.font = (options.fontWeight || textStyle.textWeight) + " 10px " + (options.fontFamily || textStyle.fontFamily);
+            var textWidth = context.measureText(text).width;
+            var textHeight = fontSize * _this.singleLineHeight * _this.textStyle.fontScale;
+            if (textHeight > charInfo.lineHeight) {
+                height += textHeight - charInfo.lineHeight;
+                charInfo.lineHeight = textHeight;
+                charInfo.offsetY = fontSize * _this.textStyle.fontScale * (_this.singleLineHeight - 1) / 2;
+            }
+            charInfo.offsetX.push(charInfo.width);
+            charInfo.width += (textWidth <= 0 ? 0 : textWidth) * fontSize * _this.SCALE_FACTOR * _this.textStyle.fontScale + text.length * letterSpace;
+            charInfo.richOptions.push(options);
+        });
+        charsInfo.push(charInfo);
+        width = Math.max(width, charInfo.width);
+        height += charInfo.lineHeight;
+        if (width === 0 || height === 0) {
+            this.isDirty = false;
+            return;
+        }
+        if (this.size === undefined || this.size === null) {
+            this.size = this.item.transform.size.clone();
+        }
+        var _this_size = this.size, _this_size_x = _this_size.x, x = _this_size_x === void 0 ? 1 : _this_size_x, _this_size_y = _this_size.y, y = _this_size_y === void 0 ? 1 : _this_size_y;
+        if (!this.initialized) {
+            this.canvasSize = !this.canvasSize ? new math.Vector2(width, height) : this.canvasSize;
+            var _this_canvasSize = this.canvasSize, canvasWidth = _this_canvasSize.x, canvasHeight = _this_canvasSize.y;
+            this.item.transform.size.set(x * canvasWidth * this.SCALE_FACTOR * this.SCALE_FACTOR, y * canvasHeight * this.SCALE_FACTOR * this.SCALE_FACTOR);
+            this.size = this.item.transform.size.clone();
+            this.initialized = true;
+        }
+        assertExist(this.canvasSize);
+        var _this_canvasSize1 = this.canvasSize, canvasWidth1 = _this_canvasSize1.x, canvasHeight1 = _this_canvasSize1.y;
+        this.textLayout.width = canvasWidth1 / textStyle.fontScale;
+        this.textLayout.height = canvasHeight1 / textStyle.fontScale;
+        this.canvas.width = canvasWidth1;
+        this.canvas.height = canvasHeight1;
+        context.clearRect(0, 0, canvasWidth1, canvasHeight1);
+        // fix bug 1/255
+        context.fillStyle = "rgba(255, 255, 255, " + this.ALPHA_FIX_VALUE + ")";
+        if (!flipY) {
+            context.translate(0, canvasHeight1);
+            context.scale(1, -1);
+        }
+        if (charsInfo.length === 0) {
+            return;
+        }
+        var charsLineHeight = textLayout.getOffsetY(textStyle, charsInfo.length, fontHeight * this.singleLineHeight, textStyle.fontSize);
+        charsInfo.forEach(function(charInfo, index) {
+            var richOptions = charInfo.richOptions, offsetX = charInfo.offsetX, width = charInfo.width;
+            var charWidth = width;
+            var offset = offsetX;
+            if (overflow === spec.TextOverflow.display) {
+                if (width > canvasWidth1) {
+                    var canvasScale = canvasWidth1 / width;
+                    charWidth *= canvasScale;
+                    offset = offsetX.map(function(x) {
+                        return x * canvasScale;
+                    });
+                }
+            }
+            var x = _this.textLayout.getOffsetX(textStyle, charWidth);
+            if (index > 0) {
+                charsLineHeight += charInfo.lineHeight - charInfo.offsetY;
+            }
+            richOptions.forEach(function(options, index) {
+                var fontScale = textStyle.fontScale, textColor = textStyle.textColor, textFamily = textStyle.fontFamily, textWeight = textStyle.textWeight, richStyle = textStyle.fontStyle;
+                var text = options.text, fontSize = options.fontSize, _options_fontColor = options.fontColor, fontColor = _options_fontColor === void 0 ? textColor : _options_fontColor, _options_fontFamily = options.fontFamily, fontFamily = _options_fontFamily === void 0 ? textFamily : _options_fontFamily, _options_fontWeight = options.fontWeight, fontWeight = _options_fontWeight === void 0 ? textWeight : _options_fontWeight, _options_fontStyle = options.fontStyle, fontStyle = _options_fontStyle === void 0 ? richStyle : _options_fontStyle;
+                var textSize = fontSize;
+                if (overflow === spec.TextOverflow.display) {
+                    if (width > canvasWidth1) {
+                        textSize /= width / canvasWidth1;
+                    }
+                }
+                context.font = fontStyle + " " + fontWeight + " " + textSize * fontScale + "px " + fontFamily;
+                context.fillStyle = "rgba(" + fontColor[0] + ", " + fontColor[1] + ", " + fontColor[2] + ", " + fontColor[3] + ")";
+                var strOffsetX = offset[index] + x;
+                if (text === " ") {
+                    context.fillText(text, offset[index] + x, charsLineHeight);
+                } else {
+                    for(var i = 0; i < text.length; i++){
+                        var str = text[i];
+                        var x1 = context.measureText(str).width;
+                        context.fillText(str, strOffsetX, charsLineHeight);
+                        strOffsetX += x1 + (i === text.length - 1 || text === " " ? 0 : letterSpace * textSize / fontSize);
+                    }
+                }
+            });
+        });
+        //与 toDataURL() 两种方式都需要像素读取操作
+        var imageData = context.getImageData(0, 0, this.canvas.width, this.canvas.height);
+        var texture = Texture.createWithData(this.engine, {
+            data: new Uint8Array(imageData.data),
+            width: imageData.width,
+            height: imageData.height
+        }, {
+            flipY: flipY,
+            magFilter: glContext.LINEAR,
+            minFilter: glContext.LINEAR,
+            wrapS: glContext.CLAMP_TO_EDGE,
+            wrapT: glContext.CLAMP_TO_EDGE
+        });
+        this.renderer.texture = texture;
+        this.material.setTexture("_MainTex", texture);
+        this.isDirty = false;
+        context.restore();
+    };
+    /**
+   * 该方法富文本组件不支持
+   * @param value - 水平偏移距离
+   * @returns
+   */ _proto.setShadowOffsetY = function setShadowOffsetY(value) {
+        throw new Error("Method not implemented.");
+    };
+    /**
+   * 该方法富文本组件不支持
+   * @param value - 模糊程度
+   */ _proto.setShadowBlur = function setShadowBlur(value) {
+        throw new Error("Method not implemented.");
+    };
+    /**
+   * 该方法富文本组件不支持
+   * @param value - 水平偏移距离
+   */ _proto.setShadowOffsetX = function setShadowOffsetX(value) {
+        throw new Error("Method not implemented.");
+    };
+    /**
+   * 该方法富文本组件不支持
+   * @param value - 阴影颜色
+   */ _proto.setShadowColor = function setShadowColor(value) {
+        throw new Error("Method not implemented.");
+    };
+    /**
+   * 该方法富文本组件不支持
+   * @param value - 外描边宽度
+   * @returns
+   */ _proto.setOutlineWidth = function setOutlineWidth(value) {
+        throw new Error("Method not implemented.");
+    };
+    /**
+   * 该方法富文本组件不支持
+   * @param value - 是否自动设置宽度
+   */ _proto.setAutoWidth = function setAutoWidth(value) {
+        throw new Error("Method not implemented.");
+    };
+    _proto.updateWithOptions = function updateWithOptions(options) {
+        this.textStyle = new TextStyle(options);
+        this.textLayout = new TextLayout(options);
+        this.textLayout.textBaseline = options.textBaseline || spec.TextBaseline.middle;
+        this.text = options.text ? options.text.toString() : " ";
+    };
+    _proto.renderText = function renderText(options) {
+        var size = options.size;
+        if (size) {
+            this.canvasSize = new math.Vector2(size[0], size[1]);
+        }
+        this.updateTexture();
+    };
+    return RichTextComponent;
+}(TextComponent);
+RichTextComponent = __decorate([
+    effectsClass(spec.DataType.RichTextComponent)
+], RichTextComponent);
+
+/**
+ * 插件版本号
+ */ var version = "0.0.0-experimental-20250512";
+registerPlugin("rich-text", RichTextLoader, VFXItem);
+logger.info("Plugin rich text version: " + version + ".");
+if (version !== EFFECTS.version) {
+    console.error("注意：请统一 RichText 插件与 Player 版本，不统一的版本混用会有不可预知的后果！", "\nAttention: Please ensure the RichText plugin is synchronized with the Player version. Mixing and matching incompatible versions may result in unpredictable consequences!");
+}
+
+export { RichTextComponent, RichTextLoader, generateProgram, isRichText, lexer, richTextParser, version };
+//# sourceMappingURL=index.mjs.map