bard-legends-framework 0.9.5 → 0.9.7

package/dist/pixi/display-object/objects/sprite.js

@@ -1,258 +1,273 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? (o, m, k, k2) => {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = { enumerable: true, get: () => m[k] };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : (o, m, k, k2) => {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? (o, v) => {
+        Object.defineProperty(o, 'default', { enumerable: true, value: v });
+      }
+    : (o, v) => {
+        o['default'] = v;
+      });
+var __importStar =
+  (this && this.__importStar) ||
+  (mod => {
     if (mod && mod.__esModule) return mod;
     var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    if (mod != null) for (var k in mod) if (k !== 'default' && Object.hasOwn(mod, k)) __createBinding(result, mod, k);
     __setModuleDefault(result, mod);
     return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+  });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.Sprite = void 0;
-const helpers_lib_1 = require("helpers-lib");
-const PIXI = __importStar(require("pixi.js"));
-const __1 = require("../..");
-const game_assets_1 = require("../../helpers/game-assets");
-const position_conversion_helper_1 = require("../../helpers/position-conversion.helper");
-const container_1 = require("../container");
-const graphics_1 = require("./graphics");
-const glow_sprite_generator_1 = require("./helpers/glow-sprite-generator");
+const helpers_lib_1 = require('helpers-lib');
+const PIXI = __importStar(require('pixi.js'));
+const __1 = require('../..');
+const game_assets_1 = require('../../helpers/game-assets');
+const position_conversion_helper_1 = require('../../helpers/position-conversion.helper');
+const container_1 = require('../container');
+const graphics_1 = require('./graphics');
+const glow_sprite_generator_1 = require('./helpers/glow-sprite-generator');
 class Sprite extends container_1.Container {
-    static createSnapshotSprite(container) {
-        let pixiContainer = container['pixiContainer'];
-        let parent = pixiContainer.parent;
-        // The "renderer.generateTexture" is not working if the sprite has a parent with the PIXI version 7.4.2
-        // TODO: Check if this is still the case with a newer version of PIXI
-        if (parent) {
-            parent.removeChild(pixiContainer);
-        }
-        let texture = __1.Game.instance.renderer.generateTexture(pixiContainer, {
-            resolution: 2,
-            scaleMode: PIXI.SCALE_MODES.LINEAR,
-            multisample: PIXI.MSAA_QUALITY.HIGH
-        });
-        if (parent) {
-            parent.addChild(pixiContainer); // TODO: removing and re-adding the child changes the order, it would break the z-index order
-        }
-        let assetId = game_assets_1.GameAssets.insertAsset(texture);
-        let spriteDefinition = {
-            id: assetId,
-            scale: container.scale,
-            size: container.size,
-            anchor: helpers_lib_1.Vector.zero,
-            boundingShapes: undefined,
-            destroyAssetOnDestroy: true
-        };
-        return new Sprite(spriteDefinition, { ignoreAnchor: true });
-    }
-    constructor(spriteDefinition, options = {}) {
-        super();
-        this._textureScale = 1;
-        if (!spriteDefinition) {
-            throw new Error(`Sprite: spriteDefinition cannot be nullish!`);
-        }
-        this.spriteDefinition = spriteDefinition;
-        this.pixiSprite = new PIXI.Sprite(game_assets_1.GameAssets.getAsset(spriteDefinition.id));
-        this.pixiContainer.addChild(this.pixiSprite);
-        this.setTextureScale(spriteDefinition.scale);
-        if (options.textureSize) {
-            this.pixiSprite.width = options.textureSize.x;
-            this.pixiSprite.height = options.textureSize.y;
-        }
-        if (options.texturePosition) {
-            this.pixiSprite.position.set(options.texturePosition.x, options.texturePosition.y);
-        }
-        if (!options.ignoreAnchor) {
-            this.pixiSprite.anchor.set(spriteDefinition.anchor.x, spriteDefinition.anchor.y);
-        }
-    }
-    destroySelf() {
-        super.destroySelf();
-        !this.pixiGlowSprite?.destroyed && this.pixiGlowSprite?.destroy();
-        this.pixiGlowSprite = undefined;
-        this.mask?.destroy();
-        this.mask = undefined;
-        this.boundingShape?.destroy();
-        this.boundingShape = undefined;
-        if (this.spriteDefinition.destroyAssetOnDestroy) {
-            game_assets_1.GameAssets.destroyAsset(this.spriteDefinition.id);
-        }
-    }
-    setTextureScale(value) {
-        this.textureScale = value;
-        return this;
-    }
-    get textureScale() {
-        return this._textureScale;
-    }
-    set textureScale(value) {
-        this._textureScale = value;
-        this.pixiSprite.scale.set(value);
-    }
-    get size() {
-        // pixiContainer size can be different because glow filter can increase the size of the sprite
-        return new helpers_lib_1.Vector(this.pixiSprite.width, this.pixiSprite.height);
-    }
-    getMask() {
-        return this.pixiSprite;
-    }
-    set interactive(value) {
-        super.interactive = value;
-        if (value && this.spriteDefinition.boundingShapes && !this.pixiContainer.hitArea) {
-            this.pixiContainer.hitArea = new position_conversion_helper_1.CompositeHitArea(this.spriteDefinition.boundingShapes, this.size, helpers_lib_1.Vector.fromVec2(this.spriteDefinition.anchor));
-        }
+  static createSnapshotSprite(container) {
+    const pixiContainer = container['pixiContainer'];
+    const parent = pixiContainer.parent;
+    // The "renderer.generateTexture" is not working if the sprite has a parent with the PIXI version 7.4.2
+    // TODO: Check if this is still the case with a newer version of PIXI
+    if (parent) {
+      parent.removeChild(pixiContainer);
     }
-    setMipmap(value) {
-        this.mipmap = value;
-        return this;
+    const texture = __1.Game.instance.renderer.generateTexture(pixiContainer, {
+      resolution: 2,
+      scaleMode: PIXI.SCALE_MODES.LINEAR,
+      multisample: PIXI.MSAA_QUALITY.HIGH
+    });
+    if (parent) {
+      parent.addChild(pixiContainer); // TODO: removing and re-adding the child changes the order, it would break the z-index order
     }
-    get mipmap() {
-        return this.pixiSprite.texture.baseTexture.mipmap === PIXI.MIPMAP_MODES.ON;
+    const assetId = game_assets_1.GameAssets.insertAsset(texture);
+    const spriteDefinition = {
+      id: assetId,
+      scale: container.scale,
+      size: container.size,
+      anchor: helpers_lib_1.Vector.zero,
+      boundingShapes: undefined,
+      destroyAssetOnDestroy: true
+    };
+    return new Sprite(spriteDefinition, { ignoreAnchor: true });
+  }
+  constructor(spriteDefinition, options = {}) {
+    super();
+    this._textureScale = 1;
+    if (!spriteDefinition) {
+      throw new Error(`Sprite: spriteDefinition cannot be nullish!`);
     }
-    set mipmap(value) {
-        if (value) {
-            this.pixiSprite.texture.baseTexture.mipmap = PIXI.MIPMAP_MODES.ON;
-        }
-        else {
-            this.pixiSprite.texture.baseTexture.mipmap = PIXI.MIPMAP_MODES.OFF;
-        }
-    }
-    setBlendMode(value) {
-        this.blendMode = value;
-        return this;
-    }
-    get blendMode() {
-        return this.pixiSprite.blendMode;
-    }
-    set blendMode(value) {
-        this.pixiSprite.blendMode = value;
+    this.spriteDefinition = spriteDefinition;
+    this.pixiSprite = new PIXI.Sprite(game_assets_1.GameAssets.getAsset(spriteDefinition.id));
+    this.pixiContainer.addChild(this.pixiSprite);
+    this.setTextureScale(spriteDefinition.scale);
+    if (options.textureSize) {
+      this.pixiSprite.width = options.textureSize.x;
+      this.pixiSprite.height = options.textureSize.y;
     }
-    setTint(tint) {
-        this.tint = tint;
-        return this;
+    if (options.texturePosition) {
+      this.pixiSprite.position.set(options.texturePosition.x, options.texturePosition.y);
     }
-    get tint() {
-        return new PIXI.Color(this.pixiSprite.tint).toRgb();
+    if (!options.ignoreAnchor) {
+      this.pixiSprite.anchor.set(spriteDefinition.anchor.x, spriteDefinition.anchor.y);
     }
-    set tint(value) {
-        this.pixiSprite.tint = value;
+  }
+  destroySelf() {
+    super.destroySelf();
+    !this.pixiGlowSprite?.destroyed && this.pixiGlowSprite?.destroy();
+    this.pixiGlowSprite = undefined;
+    this.mask?.destroy();
+    this.mask = undefined;
+    this.boundingShape?.destroy();
+    this.boundingShape = undefined;
+    if (this.spriteDefinition.destroyAssetOnDestroy) {
+      game_assets_1.GameAssets.destroyAsset(this.spriteDefinition.id);
     }
-    setShapeAlpha(value) {
-        this.pixiSprite.alpha = value;
-        return this;
+  }
+  setTextureScale(value) {
+    this.textureScale = value;
+    return this;
+  }
+  get textureScale() {
+    return this._textureScale;
+  }
+  set textureScale(value) {
+    this._textureScale = value;
+    this.pixiSprite.scale.set(value);
+  }
+  get size() {
+    // pixiContainer size can be different because glow filter can increase the size of the sprite
+    return new helpers_lib_1.Vector(this.pixiSprite.width, this.pixiSprite.height);
+  }
+  getMask() {
+    return this.pixiSprite;
+  }
+  set interactive(value) {
+    super.interactive = value;
+    if (value && this.spriteDefinition.boundingShapes && !this.pixiContainer.hitArea) {
+      this.pixiContainer.hitArea = new position_conversion_helper_1.CompositeHitArea(
+        this.spriteDefinition.boundingShapes,
+        this.size,
+        helpers_lib_1.Vector.fromVec2(this.spriteDefinition.anchor)
+      );
     }
-    get shapeAlpha() {
-        return this.pixiSprite.alpha;
+  }
+  setMipmap(value) {
+    this.mipmap = value;
+    return this;
+  }
+  get mipmap() {
+    return this.pixiSprite.texture.baseTexture.mipmap === PIXI.MIPMAP_MODES.ON;
+  }
+  set mipmap(value) {
+    if (value) {
+      this.pixiSprite.texture.baseTexture.mipmap = PIXI.MIPMAP_MODES.ON;
+    } else {
+      this.pixiSprite.texture.baseTexture.mipmap = PIXI.MIPMAP_MODES.OFF;
     }
-    set shapeAlpha(value) {
-        this.pixiSprite.alpha = value;
-    }
-    setGlowAlpha(alpha) {
-        this.glowAlpha = alpha;
-        return this;
-    }
-    get glowAlpha() {
-        if (this.pixiGlowSprite) {
-            return this.pixiGlowSprite.alpha;
-        }
-        else {
-            throw new Error(`Sprite: getGlowFilterAlpha cannot be called before glow filter is added.`);
-        }
+  }
+  setBlendMode(value) {
+    this.blendMode = value;
+    return this;
+  }
+  get blendMode() {
+    return this.pixiSprite.blendMode;
+  }
+  set blendMode(value) {
+    this.pixiSprite.blendMode = value;
+  }
+  setTint(tint) {
+    this.tint = tint;
+    return this;
+  }
+  get tint() {
+    return new PIXI.Color(this.pixiSprite.tint).toRgb();
+  }
+  set tint(value) {
+    this.pixiSprite.tint = value;
+  }
+  setShapeAlpha(value) {
+    this.pixiSprite.alpha = value;
+    return this;
+  }
+  get shapeAlpha() {
+    return this.pixiSprite.alpha;
+  }
+  set shapeAlpha(value) {
+    this.pixiSprite.alpha = value;
+  }
+  setGlowAlpha(alpha) {
+    this.glowAlpha = alpha;
+    return this;
+  }
+  get glowAlpha() {
+    if (this.pixiGlowSprite) {
+      return this.pixiGlowSprite.alpha;
+    } else {
+      throw new Error(`Sprite: getGlowFilterAlpha cannot be called before glow filter is added.`);
     }
-    set glowAlpha(value) {
-        if (this.pixiGlowSprite) {
-            this.pixiGlowSprite.alpha = value;
-        }
-        else {
-            throw new Error(`Sprite: setGlowFilterAlpha cannot be called before glow filter is added.`);
-        }
+  }
+  set glowAlpha(value) {
+    if (this.pixiGlowSprite) {
+      this.pixiGlowSprite.alpha = value;
+    } else {
+      throw new Error(`Sprite: setGlowFilterAlpha cannot be called before glow filter is added.`);
     }
-    /**
-     * @param align the anchor of the desired alignment dimentions of the Sprite is from 0 to 1 like the anchor
-     * @returns the vector of the alignment to set the position for the children
-     */
-    getAlignmentVector(alignment) {
-        let direction = helpers_lib_1.Vector.fromVec2(this.spriteDefinition.anchor).fromTo(alignment);
-        return new helpers_lib_1.Vector(this.size.x * direction.x, this.size.y * direction.y);
+  }
+  /**
+   * @param align the anchor of the desired alignment dimentions of the Sprite is from 0 to 1 like the anchor
+   * @returns the vector of the alignment to set the position for the children
+   */
+  getAlignmentVector(alignment) {
+    const direction = helpers_lib_1.Vector.fromVec2(this.spriteDefinition.anchor).fromTo(alignment);
+    return new helpers_lib_1.Vector(this.size.x * direction.x, this.size.y * direction.y);
+  }
+  setGlowEffect(partialOptions) {
+    if (this.pixiGlowSprite) {
+      this.pixiGlowSprite.destroy();
+      this.pixiGlowSprite = undefined;
     }
-    setGlowEffect(partialOptions) {
-        if (this.pixiGlowSprite) {
-            this.pixiGlowSprite.destroy();
-            this.pixiGlowSprite = undefined;
-        }
-        if (partialOptions) {
-            this.pixiGlowSprite = glow_sprite_generator_1.GlowSpriteGenerator.createGlowSpriteFromSprite(this.pixiSprite, partialOptions, !this.spriteDefinition.destroyAssetOnDestroy);
-            this.pixiGlowSprite.position.set(this.pixiSprite.x, this.pixiSprite.y);
-            this.pixiGlowSprite.scale.set(this.pixiSprite.scale.x, this.pixiSprite.scale.y);
-            this.pixiContainer.addChild(this.pixiGlowSprite);
-        }
-        return this;
+    if (partialOptions) {
+      this.pixiGlowSprite = glow_sprite_generator_1.GlowSpriteGenerator.createGlowSpriteFromSprite(
+        this.pixiSprite,
+        partialOptions,
+        !this.spriteDefinition.destroyAssetOnDestroy
+      );
+      this.pixiGlowSprite.position.set(this.pixiSprite.x, this.pixiSprite.y);
+      this.pixiGlowSprite.scale.set(this.pixiSprite.scale.x, this.pixiSprite.scale.y);
+      this.pixiContainer.addChild(this.pixiGlowSprite);
     }
-    showBoundingShape(value) {
-        if (value) {
-            if (!this.boundingShape) {
-                this.boundingShape = this.createBoundingShape().setAlpha(0.3).setTint({ r: 0, g: 0, b: 200 }).displayParent(this);
-            }
-        }
-        else if (this.boundingShape) {
-            this.boundingShape.destroy();
-            this.boundingShape = undefined;
-        }
-        return this;
+    return this;
+  }
+  showBoundingShape(value) {
+    if (value) {
+      if (!this.boundingShape) {
+        this.boundingShape = this.createBoundingShape().setAlpha(0.3).setTint({ r: 0, g: 0, b: 200 }).displayParent(this);
+      }
+    } else if (this.boundingShape) {
+      this.boundingShape.destroy();
+      this.boundingShape = undefined;
     }
-    getBoundingMask() {
-        if (!this.mask) {
-            if (!this.spriteDefinition.boundingShapes) {
-                throw new Error(`Sprite: cropOverflowingParts cannot be used without polygonDefinition!`);
-            }
-            this.mask = this.createBoundingShape();
-            // PixiJS prevents mask sprites from being rendered, but when there is display object left that uses the mask, it will be rendered.
-            // to prevent this, we set the mask's renderable property to false and set the mask's maskRefCount to Number.POSITIVE_INFINITY
-            this.mask.pixiSprite['_maskRefCount'] = Number.POSITIVE_INFINITY;
-            this.mask.pixiSprite.renderable = false;
-            this.mask.displayParent(this);
-        }
-        return this.mask;
+    return this;
+  }
+  getBoundingMask() {
+    if (!this.mask) {
+      if (!this.spriteDefinition.boundingShapes) {
+        throw new Error(`Sprite: cropOverflowingParts cannot be used without polygonDefinition!`);
+      }
+      this.mask = this.createBoundingShape();
+      // PixiJS prevents mask sprites from being rendered, but when there is display object left that uses the mask, it will be rendered.
+      // to prevent this, we set the mask's renderable property to false and set the mask's maskRefCount to Number.POSITIVE_INFINITY
+      this.mask.pixiSprite['_maskRefCount'] = Number.POSITIVE_INFINITY;
+      this.mask.pixiSprite.renderable = false;
+      this.mask.displayParent(this);
     }
-    createBoundingShape() {
-        if (!this.spriteDefinition.boundingShapes) {
-            throw new Error(`Sprite: bounding shape cannot be created without polygonDefinition!`);
-        }
-        return graphics_1.Graphics.createPolygon(this.spriteDefinition.boundingShapes, helpers_lib_1.ColorHelper.white).toSprite().attach(this);
+    return this.mask;
+  }
+  createBoundingShape() {
+    if (!this.spriteDefinition.boundingShapes) {
+      throw new Error(`Sprite: bounding shape cannot be created without polygonDefinition!`);
     }
-    download() {
-        let canvas = __1.Game.instance.renderer.extract.canvas(this.pixiContainer);
-        if (!canvas.toBlob) {
-            throw new Error(`Sprite: canvas.toBlob is undefined!`);
-        }
-        canvas.toBlob(blob => {
-            if (!blob) {
-                throw new Error(`Sprite: blob is undefined!`);
-            }
-            let a = document.createElement('a');
-            document.body.append(a);
-            a.download = 'sprite.png';
-            a.href = URL.createObjectURL(blob);
-            a.click();
-            a.remove();
-        }, 'image/png');
-        return this;
+    return graphics_1.Graphics.createPolygon(this.spriteDefinition.boundingShapes, helpers_lib_1.ColorHelper.white)
+      .toSprite()
+      .attach(this);
+  }
+  download() {
+    const canvas = __1.Game.instance.renderer.extract.canvas(this.pixiContainer);
+    if (!canvas.toBlob) {
+      throw new Error(`Sprite: canvas.toBlob is undefined!`);
     }
+    canvas.toBlob(blob => {
+      if (!blob) {
+        throw new Error(`Sprite: blob is undefined!`);
+      }
+      const a = document.createElement('a');
+      document.body.append(a);
+      a.download = 'sprite.png';
+      a.href = URL.createObjectURL(blob);
+      a.click();
+      a.remove();
+    }, 'image/png');
+    return this;
+  }
 }
 exports.Sprite = Sprite;
-//# sourceMappingURL=sprite.js.map
+//# sourceMappingURL=sprite.js.map

package/dist/pixi/display-object/objects/text/helpers/process-steps/1-data-in-converter/rich-text-data-in-converter.js

@@ -78,7 +78,7 @@ class RichTextDataInConverter {
                 result = { ...result, ...options.styles[tag] };
             }
         }
-        let { wordWrapWidth, align, dropShadow, ...supportedStyles } = result;
+        let { wordWrapWidth: _wordWrapWidth, align: _align, dropShadow: _dropShadow, ...supportedStyles } = result;
         return supportedStyles;
     }
     static applyNewLines(tokens) {

package/dist/pixi/display-object/objects/text/helpers/process-steps/1-data-in-converter/rich-text-data-in-converter.test.js

@@ -32,14 +32,14 @@ const rich_text_data_in_converter_1 = require("./rich-text-data-in-converter");
 const DefaultColor = { r: 100, g: 50, b: 0 };
 const Style1Color = { r: 255, g: 255, b: 255 };
 const Style2Color = { r: 0, g: 100, b: 100 };
-const RichTextOptions = {
+const DefaultRichTextOptions = {
     default: { fontFamily: 'Arial', wordWrapWidth: 100, color: DefaultColor, fontSize: 20 },
     styles: {
         style1: { color: Style1Color, lineHeight: 25 },
         style2: { color: Style2Color, fontSize: 22 }
     }
 };
-const StyleNames = new Set(Object.keys(RichTextOptions.styles));
+const StyleNames = new Set(Object.keys(DefaultRichTextOptions.styles));
 const ExpectedResults = {
     default: { fontFamily: 'Arial', color: DefaultColor, fontSize: 20 },
     style1: { fontFamily: 'Arial', color: Style1Color, fontSize: 20, lineHeight: 25 },
@@ -59,7 +59,7 @@ const ExpectedPixiStyles = {
         (0, vitest_1.test)('should handle plain text without tags', () => {
             let text = 'Simple text without any tags';
             let textSegments = script_engine_lib_1.RichTextSeparator.process(text, StyleNames);
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['includeStylesToTags'](textSegments, RichTextOptions);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['includeStylesToTags'](textSegments, DefaultRichTextOptions);
             (0, vitest_1.expect)(result).toEqual([
                 {
                     text: 'Simple text without any tags',
@@ -73,7 +73,7 @@ const ExpectedPixiStyles = {
         (0, vitest_1.test)('should handle single style tag correctly', () => {
             let text = '<style1>Styled text</style1>';
             let textSegments = script_engine_lib_1.RichTextSeparator.process(text, StyleNames);
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['includeStylesToTags'](textSegments, RichTextOptions);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['includeStylesToTags'](textSegments, DefaultRichTextOptions);
             (0, vitest_1.expect)(result).toEqual([
                 {
                     text: 'Styled text',
@@ -87,7 +87,7 @@ const ExpectedPixiStyles = {
         (0, vitest_1.test)('should handle text with surrounding styles', () => {
             let text = 'plain text <style1>styled text</style1> more plain text';
             let textSegments = script_engine_lib_1.RichTextSeparator.process(text, StyleNames);
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['includeStylesToTags'](textSegments, RichTextOptions);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['includeStylesToTags'](textSegments, DefaultRichTextOptions);
             (0, vitest_1.expect)(result).toEqual([
                 {
                     text: 'plain text ',
@@ -115,7 +115,7 @@ const ExpectedPixiStyles = {
         (0, vitest_1.test)('should handle multiple styles', () => {
             let text = '<style1>Text with style1</style1> plain text <style2>text with style2</style2>';
             let textSegments = script_engine_lib_1.RichTextSeparator.process(text, StyleNames);
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['includeStylesToTags'](textSegments, RichTextOptions);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['includeStylesToTags'](textSegments, DefaultRichTextOptions);
             (0, vitest_1.expect)(result).toEqual([
                 {
                     text: 'Text with style1',
@@ -143,7 +143,7 @@ const ExpectedPixiStyles = {
         (0, vitest_1.test)('should handle nested styles', () => {
             let text = 'Text <style1>with <style2>nested</style2> styles</style1>';
             let textSegments = script_engine_lib_1.RichTextSeparator.process(text, StyleNames);
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['includeStylesToTags'](textSegments, RichTextOptions);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['includeStylesToTags'](textSegments, DefaultRichTextOptions);
             (0, vitest_1.expect)(result).toEqual([
                 {
                     text: 'Text ',
@@ -188,7 +188,7 @@ const ExpectedPixiStyles = {
         (0, vitest_1.test)('should not accept "default" as a valid tag', () => {
             let text = 'Text with no default tag';
             let textSegments = script_engine_lib_1.RichTextSeparator.process(text, StyleNames);
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['includeStylesToTags'](textSegments, RichTextOptions);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['includeStylesToTags'](textSegments, DefaultRichTextOptions);
             (0, vitest_1.expect)(result).toEqual([
                 {
                     text: 'Text with no default tag',
@@ -202,7 +202,7 @@ const ExpectedPixiStyles = {
         (0, vitest_1.test)('should match the example in comments', () => {
             let text = 'This is a sample <style1>Hello</style1><style2>World</style2> text';
             let textSegments = script_engine_lib_1.RichTextSeparator.process(text, StyleNames);
-            let result = rich_text_data_in_converter_1.RichTextDataInConverter['includeStylesToTags'](textSegments, RichTextOptions);
+            let result = rich_text_data_in_converter_1.RichTextDataInConverter['includeStylesToTags'](textSegments, DefaultRichTextOptions);
             (0, vitest_1.expect)(result).toEqual([
                 {
                     text: 'This is a sample ',

package/dist/pixi/display-object/objects/text/helpers/rich-text-to-plane-text.d.ts

@@ -1,7 +1,7 @@
 import * as PIXI from 'pixi.js';
 import { RichTextOptions } from '../rich-text';
-import { PartialTextOptions } from './process-steps/1-data-in-converter/pixi-text-style-converter';
 import { TextData } from '.';
+import { PartialTextOptions } from './process-steps/1-data-in-converter/pixi-text-style-converter';
 export interface ChunkStyle {
     readonly cacheKey: string;
     readonly width: number;