{"version":3,"file":"Container.mjs","sources":["../../../src/scene/container/Container.ts"],"sourcesContent":["import EventEmitter from 'eventemitter3';\nimport { Color, type ColorSource } from '../../color/Color';\nimport { cullingMixin } from '../../culling/cullingMixin';\nimport { extensions } from '../../extensions/Extensions';\nimport { Matrix } from '../../maths/matrix/Matrix';\nimport { DEG_TO_RAD, RAD_TO_DEG } from '../../maths/misc/const';\nimport { ObservablePoint } from '../../maths/point/ObservablePoint';\nimport { uid } from '../../utils/data/uid';\nimport { deprecation, v8_0_0 } from '../../utils/logging/deprecation';\nimport { warn } from '../../utils/logging/warn';\nimport { BigPool } from '../../utils/pool/PoolGroup';\nimport { type IRenderLayer } from '../layers/RenderLayer';\nimport { cacheAsTextureMixin } from './container-mixins/cacheAsTextureMixin';\nimport { childrenHelperMixin } from './container-mixins/childrenHelperMixin';\nimport { collectRenderablesMixin } from './container-mixins/collectRenderablesMixin';\nimport { effectsMixin } from './container-mixins/effectsMixin';\nimport { findMixin } from './container-mixins/findMixin';\nimport { getFastGlobalBoundsMixin } from './container-mixins/getFastGlobalBoundsMixin';\nimport { bgr2rgb, getGlobalMixin } from './container-mixins/getGlobalMixin';\nimport { measureMixin } from './container-mixins/measureMixin';\nimport { onRenderMixin } from './container-mixins/onRenderMixin';\nimport { sortMixin } from './container-mixins/sortMixin';\nimport { toLocalGlobalMixin } from './container-mixins/toLocalGlobalMixin';\nimport { RenderGroup } from './RenderGroup';\nimport { assignWithIgnore } from './utils/assignWithIgnore';\n\nimport type { Size } from '../../maths/misc/Size';\nimport type { PointData } from '../../maths/point/PointData';\nimport type { Rectangle } from '../../maths/shapes/Rectangle';\nimport type { BLEND_MODES } from '../../rendering/renderers/shared/state/const';\nimport type { Dict } from '../../utils/types';\nimport type { Optional } from './container-mixins/measureMixin';\nimport type { DestroyOptions } from './destroyTypes';\n\n/**\n * The type of child that can be added to a {@link Container}.\n * This is a generic type that extends the {@link Container} class.\n * @category scene\n * @standard\n */\nexport type ContainerChild = Container;\n\n// as pivot and skew are the least used properties of a container, we can use this optimisation\n// to avoid allocating lots of unnecessary objects for them.\nconst defaultSkew = new ObservablePoint(null);\nconst defaultPivot = new ObservablePoint(null);\nconst defaultScale = new ObservablePoint(null, 1, 1);\nconst defaultOrigin = new ObservablePoint(null);\n\n/**\n * Events that can be emitted by a Container. These events provide lifecycle hooks and notifications\n * for container state changes.\n * @example\n * ```ts\n * import { Container, Sprite } from 'pixi.js';\n *\n * // Setup container with event listeners\n * const container = new Container();\n *\n * // Listen for child additions\n * container.on('childAdded', (child, container, index) => {\n *     console.log(`Child added at index ${index}:`, child);\n * });\n *\n * // Listen for child removals\n * container.on('childRemoved', (child, container, index) => {\n *     console.log(`Child removed from index ${index}:`, child);\n * });\n *\n * // Listen for when container is added to parent\n * container.on('added', (parent) => {\n *     console.log('Added to parent:', parent);\n * });\n *\n * // Listen for when container is removed from parent\n * container.on('removed', (parent) => {\n *     console.log('Removed from parent:', parent);\n * });\n *\n * // Listen for container destruction\n * container.on('destroyed', (container) => {\n *     console.log('Container destroyed:', container);\n * });\n * ```\n * @category scene\n * @standard\n */\nexport interface ContainerEvents<C extends ContainerChild> extends PixiMixins.ContainerEvents\n{\n    /**\n     * Emitted when this container is added to a new container.\n     * Useful for setting up parent-specific behaviors.\n     * @param container - The parent container this was added to\n     * @example\n     * ```ts\n     * const child = new Container();\n     * child.on('added', (parent) => {\n     *     console.log('Child added to parent:', parent.label);\n     * });\n     * parentContainer.addChild(child);\n     * ```\n     */\n    added: [container: Container];\n\n    /**\n     * Emitted when a child is added to this container.\n     * Useful for tracking container composition changes.\n     * @param child - The child that was added\n     * @param container - The container the child was added to (this container)\n     * @param index - The index at which the child was added\n     * @example\n     * ```ts\n     * const parent = new Container();\n     * parent.on('childAdded', (child, container, index) => {\n     *     console.log(`New child at index ${index}:`, child);\n     * });\n     * ```\n     */\n    childAdded: [child: C, container: Container, index: number];\n\n    /**\n     * Emitted when this container is removed from its parent.\n     * Useful for cleanup and state management.\n     * @param container - The parent container this was removed from\n     * @example\n     * ```ts\n     * const child = new Container();\n     * child.on('removed', (oldParent) => {\n     *     console.log('Child removed from parent:', oldParent.label);\n     * });\n     * ```\n     */\n    removed: [container: Container];\n\n    /**\n     * Emitted when a child is removed from this container.\n     * Useful for cleanup and maintaining container state.\n     * @param child - The child that was removed\n     * @param container - The container the child was removed from (this container)\n     * @param index - The index from which the child was removed\n     * @example\n     * ```ts\n     * const parent = new Container();\n     * parent.on('childRemoved', (child, container, index) => {\n     *     console.log(`Child removed from index ${index}:`, child);\n     * });\n     * ```\n     */\n    childRemoved: [child: C, container: Container, index: number];\n\n    /**\n     * Emitted when the container is destroyed.\n     * Useful for final cleanup and resource management.\n     * @param container - The container that was destroyed\n     * @example\n     * ```ts\n     * const container = new Container();\n     * container.on('destroyed', (container) => {\n     *     console.log('Container destroyed:', container.label);\n     * });\n     * ```\n     */\n    destroyed: [container: Container];\n}\n\ntype AnyEvent = {\n    // The following is a hack to allow any custom event while maintaining type safety.\n    // For some reason, the tsc compiler gets angry about error TS1023\n    // \"An index signature parameter type must be either 'string' or 'number'.\"\n    // This is really odd since ({}&string) should interpret as string, but then again\n    // there is some black magic behind why this works in the first place.\n    // Closest thing to an explanation:\n    // https://stackoverflow.com/questions/70144348/why-does-a-union-of-type-literals-and-string-cause-ide-code-completion-wh\n    //\n    // Side note, we disable @typescript-eslint/ban-types since {}&string is the only syntax that works.\n    // Nor of the Record/unknown/never alternatives work.\n    [K: ({} & string) | ({} & symbol)]: any;\n};\n\n/** @internal */\nexport const UPDATE_COLOR = 0b0001;\n/** @internal */\nexport const UPDATE_BLEND = 0b0010;\n/** @internal */\nexport const UPDATE_VISIBLE = 0b0100;\n/** @internal */\nexport const UPDATE_TRANSFORM = 0b1000;\n\n/**\n * Options for updating the transform of a container.\n * @category scene\n * @standard\n */\nexport interface UpdateTransformOptions\n{\n    x: number;\n    y: number;\n    scaleX: number;\n    scaleY: number;\n    rotation: number;\n    skewX: number;\n    skewY: number;\n    pivotX: number;\n    pivotY: number;\n    originX: number;\n    originY: number;\n}\n\n/**\n * Constructor options used for `Container` instances.\n * ```js\n * const container = new Container({\n *    position: new Point(100, 200),\n *    scale: new Point(2, 2),\n *    rotation: Math.PI / 2,\n * });\n * ```\n * @category scene\n * @standard\n * @see Container\n */\nexport interface ContainerOptions<C extends ContainerChild = ContainerChild> extends PixiMixins.ContainerOptions\n{\n    /** @see Container#isRenderGroup */\n    isRenderGroup?: boolean;\n\n    /**\n     * The blend mode to be applied to the sprite. Controls how pixels are blended when rendering.\n     *\n     * Setting to 'normal' will reset to default blending.\n     * > [!NOTE] More blend modes are available after importing the `pixi.js/advanced-blend-modes` sub-export.\n     * @example\n     * ```ts\n     * // Basic blend modes\n     * new Container({ blendMode: 'normal' }); // Default blending\n     * new Container({ blendMode: 'add' });    // Additive blending\n     * new Container({ blendMode: 'multiply' }); // Multiply colors\n     * new Container({ blendMode: 'screen' }); // Screen blend\n     * ```\n     * @default 'normal'\n     * @see {@link Container#alpha} For transparency\n     * @see {@link Container#tint} For color adjustments\n     */\n    blendMode?: BLEND_MODES;\n    /**\n     * The tint applied to the sprite.\n     *\n     * This can be any valid {@link ColorSource}.\n     * @example\n     * ```ts\n     * new Container({ tint: 0xff0000 }); // Red tint\n     * new Container({ tint: 'blue' }); // Blue tint\n     * new Container({ tint: '#00ff00' }); // Green tint\n     * new Container({ tint: 'rgb(0,0,255)' }); // Blue tint\n     * ```\n     * @default 0xFFFFFF\n     * @see {@link Container#alpha} For transparency\n     * @see {@link Container#visible} For visibility control\n     */\n    tint?: ColorSource;\n\n    /**\n     * The opacity of the object relative to its parent's opacity.\n     * Value ranges from 0 (fully transparent) to 1 (fully opaque).\n     * @example\n     * ```ts\n     * new Container({ alpha: 0.5 }); // 50% opacity\n     * new Container({ alpha: 1 }); // Fully opaque\n     * ```\n     * @default 1\n     * @see {@link Container#visible} For toggling visibility\n     * @see {@link Container#renderable} For render control\n     */\n    alpha?: number;\n    /**\n     * The angle of the object in degrees.\n     *\n     * > [!NOTE] 'rotation' and 'angle' have the same effect on a display object;\n     * > rotation is in radians, angle is in degrees.\n     * @example\n     * ```ts\n     * new Container({ angle: 45 }); // Rotate 45 degrees\n     * new Container({ angle: 90 }); // Rotate 90 degrees\n     * ```\n     */\n    angle?: number;\n    /**\n     * The array of children of this container. Each child must be a Container or extend from it.\n     *\n     * The array is read-only, but its contents can be modified using Container methods.\n     * @example\n     * ```ts\n     * new Container({\n     *    children: [\n     *        new Container(), // First child\n     *        new Container(), // Second child\n     *    ],\n     * });\n     * ```\n     * @readonly\n     * @see {@link Container#addChild} For adding children\n     * @see {@link Container#removeChild} For removing children\n     */\n    children?: C[];\n    /**\n     * The display object container that contains this display object.\n     * This represents the parent-child relationship in the display tree.\n     * @readonly\n     * @see {@link Container#addChild} For adding to a parent\n     * @see {@link Container#removeChild} For removing from parent\n     */\n    parent?: Container;\n    /**\n     * Controls whether this object can be rendered. If false the object will not be drawn,\n     * but the transform will still be updated. This is different from visible, which skips\n     * transform updates.\n     * @example\n     * ```ts\n     * new Container({ renderable: false }); // Will not be drawn, but transforms will update\n     * ```\n     * @default true\n     * @see {@link Container#visible} For skipping transform updates\n     * @see {@link Container#alpha} For transparency\n     */\n    renderable?: boolean;\n    /**\n     * The rotation of the object in radians.\n     *\n     * > [!NOTE] 'rotation' and 'angle' have the same effect on a display object;\n     * > rotation is in radians, angle is in degrees.\n     * @example\n     * ```ts\n     * new Container({ rotation: Math.PI / 4 }); // Rotate 45 degrees\n     * new Container({ rotation: Math.PI / 2 }); // Rotate 90 degrees\n     * ```\n     */\n    rotation?: number;\n    /**\n     * The scale factors of this object along the local coordinate axes.\n     *\n     * The default scale is (1, 1).\n     * @example\n     * ```ts\n     * new Container({ scale: new Point(2, 2) }); // Scale by 2x\n     * new Container({ scale: 0.5 }); // Scale by 0.5x\n     * new Container({ scale: { x: 1.5, y: 1.5 } }); // Scale by 1.5x\n     * ```\n     */\n    scale?: PointData | number;\n    /**\n     * The center of rotation, scaling, and skewing for this display object in its local space.\n     * The `position` is the projection of `pivot` in the parent's local space.\n     *\n     * By default, the pivot is the origin (0, 0).\n     * @example\n     * ```ts\n     * new Container({ pivot: new Point(100, 200) }); // Set pivot to (100, 200)\n     * new Container({ pivot: 50 }); // Set pivot to (50, 50)\n     * new Container({ pivot: { x: 150, y: 150 } }); // Set pivot to (150, 150)\n     * ```\n     */\n    pivot?: PointData | number;\n    /**\n     * The origin point around which the container rotates and scales.\n     * Unlike pivot, changing origin will not move the container's position.\n     * @example\n     * ```ts\n     * new Container({ origin: new Point(100, 100) }); // Rotate around point (100,100)\n     * new Container({ origin: 50 }); // Rotate around point (50, 50)\n     * new Container({ origin: { x: 150, y: 150 } }); // Rotate around point (150, 150)\n     * ```\n     */\n    origin?: PointData | number;\n    /**\n     * The coordinate of the object relative to the local coordinates of the parent.\n     * @example\n     * ```ts\n     * new Container({ position: new Point(100, 200) }); // Set position to (100, 200)\n     * new Container({ position: { x: 150, y: 150 } }); // Set position to (150, 150)\n     * ```\n     */\n    position?: PointData;\n    /**\n     * The skew factor for the object in radians. Skewing is a transformation that distorts\n     * the object by rotating it differently at each point, creating a non-uniform shape.\n     * @example\n     * ```ts\n     * new Container({ skew: new Point(0.1, 0.2) }); // Skew by 0.1 radians on x and 0.2 radians on y\n     * new Container({ skew: { x: 0.1, y: 0.2 } }); // Skew by 0.1 radians on x and 0.2 radians on y\n     * ```\n     * @default { x: 0, y: 0 }\n     */\n    skew?: PointData;\n    /**\n     * The visibility of the object. If false the object will not be drawn,\n     * and the transform will not be updated.\n     * @example\n     * ```ts\n     * new Container({ visible: false }); // Will not be drawn and transforms will not update\n     * new Container({ visible: true }); // Will be drawn and transforms will update\n     * ```\n     * @default true\n     * @see {@link Container#renderable} For render-only control\n     * @see {@link Container#alpha} For transparency\n     */\n    visible?: boolean;\n    /**\n     * The position of the container on the x axis relative to the local coordinates of the parent.\n     *\n     * An alias to position.x\n     * @example\n     * ```ts\n     * new Container({ x: 100 }); // Set x position to 100\n     * ```\n     */\n    x?: number;\n    /**\n     * The position of the container on the y axis relative to the local coordinates of the parent.\n     *\n     * An alias to position.y\n     * @example\n     * ```ts\n     * new Container({ y: 200 }); // Set y position to 200\n     * ```\n     */\n    y?: number;\n    /**\n     * An optional bounds area for this container. Setting this rectangle will stop the renderer\n     * from recursively measuring the bounds of each children and instead use this single boundArea.\n     *\n     * > [!IMPORTANT] This is great for optimisation! If for example you have a\n     * > 1000 spinning particles and you know they all sit within a specific bounds,\n     * > then setting it will mean the renderer will not need to measure the\n     * > 1000 children to find the bounds. Instead it will just use the bounds you set.\n     * @example\n     * ```ts\n     * const container = new Container({\n     *    boundsArea: new Rectangle(0, 0, 500, 500) // Set a fixed bounds area\n     * });\n     * ```\n     */\n    boundsArea?: Rectangle;\n}\n\n// eslint-disable-next-line requireExport/require-export-jsdoc, requireMemberAPI/require-member-api-doc\nexport interface Container<C extends ContainerChild>\n    extends PixiMixins.Container<C>, EventEmitter<ContainerEvents<C> & AnyEvent> {}\n\n/**\n * Container is a general-purpose display object that holds children. It also adds built-in support for advanced\n * rendering features like masking and filtering.\n *\n * It is the base class of all display objects that act as a container for other objects, including Graphics\n * and Sprite.\n *\n * <details id=\"transforms\">\n *\n * <summary>Transforms</summary>\n *\n * The [transform]{@link Container#localTransform} of a display object describes the projection from its\n * local coordinate space to its parent's local coordinate space. The following properties are derived\n * from the transform:\n *\n * <table>\n *   <thead>\n *     <tr>\n *       <th>Property</th>\n *       <th>Description</th>\n *     </tr>\n *   </thead>\n *   <tbody>\n *     <tr>\n *       <td>[pivot]{@link Container#pivot}</td>\n *       <td>\n *         Invariant under rotation, scaling, and skewing. The projection of into the parent's space of the pivot\n *         is equal to position, regardless of the other three transformations. In other words, It is the center of\n *         rotation, scaling, and skewing.\n *       </td>\n *     </tr>\n *     <tr>\n *       <td>[position]{@link Container#position}</td>\n *       <td>\n *         Translation. This is the position of the [pivot]{@link Container#pivot} in the parent's local\n *         space. The default value of the pivot is the origin (0,0). If the top-left corner of your display object\n *         is (0,0) in its local space, then the position will be its top-left corner in the parent's local space.\n *       </td>\n *     </tr>\n *     <tr>\n *       <td>[scale]{@link Container#scale}</td>\n *       <td>\n *         Scaling. This will stretch (or compress) the display object's projection. The scale factors are along the\n *         local coordinate axes. In other words, the display object is scaled before rotated or skewed. The center\n *         of scaling is the [pivot]{@link Container#pivot}.\n *       </td>\n *     </tr>\n *     <tr>\n *       <td>[rotation]{@link Container#rotation}</td>\n *       <td>\n *          Rotation. This will rotate the display object's projection by this angle (in radians).\n *       </td>\n *     </tr>\n *     <tr>\n *       <td>[skew]{@link Container#skew}</td>\n *       <td>\n *         <p>Skewing. This can be used to deform a rectangular display object into a parallelogram.</p>\n *         <p>\n *         In PixiJS, skew has a slightly different behaviour than the conventional meaning. It can be\n *         thought of the net rotation applied to the coordinate axes (separately). For example, if \"skew.x\" is\n *         ⍺ and \"skew.y\" is β, then the line x = 0 will be rotated by ⍺ (y = -x*cot⍺) and the line y = 0 will be\n *         rotated by β (y = x*tanβ). A line y = x*tanϴ (i.e. a line at angle ϴ to the x-axis in local-space) will\n *         be rotated by an angle between ⍺ and β.\n *         </p>\n *         <p>\n *         It can be observed that if skew is applied equally to both axes, then it will be equivalent to applying\n *         a rotation. Indeed, if \"skew.x\" = -ϴ and \"skew.y\" = ϴ, it will produce an equivalent of \"rotation\" = ϴ.\n *         </p>\n *         <p>\n *         Another quite interesting observation is that \"skew.x\", \"skew.y\", rotation are commutative operations. Indeed,\n *         because rotation is essentially a careful combination of the two.\n *         </p>\n *       </td>\n *     </tr>\n *     <tr>\n *       <td>[angle]{@link Container#angle}</td>\n *       <td>Rotation. This is an alias for [rotation]{@link Container#rotation}, but in degrees.</td>\n *     </tr>\n *     <tr>\n *       <td>[x]{@link Container#x}</td>\n *       <td>Translation. This is an alias for position.x!</td>\n *     </tr>\n *     <tr>\n *       <td>[y]{@link Container#y}</td>\n *       <td>Translation. This is an alias for position.y!</td>\n *     </tr>\n *     <tr>\n *       <td>[width]{@link Container#width}</td>\n *       <td>\n *         Implemented in [Container]{@link Container}. Scaling. The width property calculates scale.x by dividing\n *         the \"requested\" width by the local bounding box width. It is indirectly an abstraction over scale.x, and there\n *         is no concept of user-defined width.\n *       </td>\n *     </tr>\n *     <tr>\n *       <td>[height]{@link Container#height}</td>\n *       <td>\n *         Implemented in [Container]{@link Container}. Scaling. The height property calculates scale.y by dividing\n *         the \"requested\" height by the local bounding box height. It is indirectly an abstraction over scale.y, and there\n *         is no concept of user-defined height.\n *       </td>\n *     </tr>\n *   </tbody>\n * </table>\n * </details>\n *\n * <details id=\"alpha\">\n * <summary>Alpha</summary>\n *\n * This alpha sets a display object's **relative opacity** w.r.t its parent. For example, if the alpha of a display\n * object is 0.5 and its parent's alpha is 0.5, then it will be rendered with 25% opacity (assuming alpha is not\n * applied on any ancestor further up the chain).\n * </details>\n *\n * <details id=\"visible\">\n * <summary>Renderable vs Visible</summary>\n *\n * The `renderable` and `visible` properties can be used to prevent a display object from being rendered to the\n * screen. However, there is a subtle difference between the two. When using `renderable`, the transforms  of the display\n * object (and its children subtree) will continue to be calculated. When using `visible`, the transforms will not\n * be calculated.\n * ```ts\n * import { BlurFilter, Container, Graphics, Sprite } from 'pixi.js';\n *\n * const container = new Container();\n * const sprite = Sprite.from('https://s3-us-west-2.amazonaws.com/s.cdpn.io/693612/IaUrttj.png');\n *\n * sprite.width = 512;\n * sprite.height = 512;\n *\n * // Adds a sprite as a child to this container. As a result, the sprite will be rendered whenever the container\n * // is rendered.\n * container.addChild(sprite);\n *\n * // Blurs whatever is rendered by the container\n * container.filters = [new BlurFilter()];\n *\n * // Only the contents within a circle at the center should be rendered onto the screen.\n * container.mask = new Graphics()\n *     .beginFill(0xffffff)\n *     .drawCircle(sprite.width / 2, sprite.height / 2, Math.min(sprite.width, sprite.height) / 2)\n *     .endFill();\n * ```\n *\n * </details>\n *\n * <details id=\"renderGroup\">\n * <summary>RenderGroup</summary>\n *\n * In PixiJS v8, containers can be set to operate in 'render group mode',\n * transforming them into entities akin to a stage in traditional rendering paradigms.\n * A render group is a root renderable entity, similar to a container,\n * but it's rendered in a separate pass with its own unique set of rendering instructions.\n * This approach enhances rendering efficiency and organization, particularly in complex scenes.\n *\n * You can enable render group mode on any container using container.enableRenderGroup()\n * or by initializing a new container with the render group property set to true (new Container({isRenderGroup: true})).\n *  The method you choose depends on your specific use case and setup requirements.\n *\n * An important aspect of PixiJS’s rendering process is the automatic treatment of rendered scenes as render groups.\n * This conversion streamlines the rendering process, but understanding when and how this happens is crucial\n * to fully leverage its benefits.\n *\n * One of the key advantages of using render groups is the performance efficiency in moving them. Since transformations\n *  are applied at the GPU level, moving a render group, even one with complex and numerous children,\n * doesn't require recalculating the rendering instructions or performing transformations on each child.\n * This makes operations like panning a large game world incredibly efficient.\n *\n * However, it's crucial to note that render groups do not batch together.\n * This means that turning every container into a render group could actually slow things down,\n * as each render group is processed separately. It's best to use render groups judiciously, at a broader level,\n * rather than on a per-child basis.\n * This approach ensures you get the performance benefits without overburdening the rendering process.\n *\n * RenderGroups maintain their own set of rendering instructions,\n * ensuring that changes or updates within a render group don't affect the rendering\n * instructions of its parent or other render groups.\n *  This isolation ensures more stable and predictable rendering behavior.\n *\n * Additionally, renderGroups can be nested, allowing for powerful options in organizing different aspects of your scene.\n * This feature is particularly beneficial for separating complex game graphics from UI elements,\n * enabling intricate and efficient scene management in complex applications.\n *\n * This means that Containers have 3 levels of matrix to be mindful of:\n *\n * 1. localTransform, this is the transform of the container based on its own properties\n * 2. groupTransform, this it the transform of the container relative to the renderGroup it belongs too\n * 3. worldTransform, this is the transform of the container relative to the Scene being rendered\n * </details>\n * @category scene\n * @standard\n */\nexport class Container<C extends ContainerChild = ContainerChild> extends EventEmitter<ContainerEvents<C> & AnyEvent>\n{\n    /**\n     * Mixes all enumerable properties and methods from a source object to Container.\n     * @param source - The source of properties and methods to mix in.\n     * @deprecated since 8.8.0\n     */\n    public static mixin(source: Dict<any>): void\n    {\n        // #if _DEBUG\n        deprecation('8.8.0', 'Container.mixin is deprecated, please use extensions.mixin instead.');\n        // #endif\n        extensions.mixin(Container, source);\n    }\n\n    /**\n     * unique id for this container\n     * @internal\n     */\n    public readonly uid: number = uid('renderable');\n\n    /** @private */\n    public _updateFlags = 0b1111;\n\n    // the render group this container owns\n    /** @private */\n    public renderGroup: RenderGroup = null;\n    // the render group this container belongs to\n    /** @private */\n    public parentRenderGroup: RenderGroup = null;\n    // the index of the container in the render group\n    /** @private */\n    public parentRenderGroupIndex: number = 0;\n\n    // set to true if the container has changed. It is reset once the changes have been applied\n    // by the transform system\n    // its here to stop ensure that when things change, only one update gets registers with the transform system\n    /** @private */\n    public didChange = false;\n    // same as above, but for the renderable\n    /** @private */\n    public didViewUpdate = false;\n\n    // how deep is the container relative to its render group..\n    // unless the element is the root render group - it will be relative to its parent\n    /** @private */\n    public relativeRenderGroupDepth = 0;\n\n    /**\n     * The array of children of this container. Each child must be a Container or extend from it.\n     *\n     * The array is read-only, but its contents can be modified using Container methods.\n     * @example\n     * ```ts\n     * // Access children\n     * const firstChild = container.children[0];\n     * const lastChild = container.children[container.children.length - 1];\n     * ```\n     * @readonly\n     * @see {@link Container#addChild} For adding children\n     * @see {@link Container#removeChild} For removing children\n     */\n    public children: C[] = [];\n    /**\n     * The display object container that contains this display object.\n     * This represents the parent-child relationship in the display tree.\n     * @example\n     * ```ts\n     * // Basic parent access\n     * const parent = sprite.parent;\n     *\n     * // Walk up the tree\n     * let current = sprite;\n     * while (current.parent) {\n     *     console.log('Level up:', current.parent.constructor.name);\n     *     current = current.parent;\n     * }\n     * ```\n     * @readonly\n     * @see {@link Container#addChild} For adding to a parent\n     * @see {@link Container#removeChild} For removing from parent\n     */\n    public parent: Container | null = null;\n\n    // used internally for changing up the render order.. mainly for masks and filters\n    // TODO setting this should cause a rebuild??\n    /** @private */\n    public includeInBuild = true;\n    /** @private */\n    public measurable = true;\n    /** @private */\n    public isSimple = true;\n\n    /**\n     * The RenderLayer this container belongs to, if any.\n     * If it belongs to a RenderLayer, it will be rendered from the RenderLayer's position in the scene.\n     * @readonly\n     * @advanced\n     */\n    public parentRenderLayer: IRenderLayer;\n\n    // / /////////////Transform related props//////////////\n\n    // used by the transform system to check if a container needs to be updated that frame\n    // if the tick matches the current transform system tick, it is not updated again\n    /** @internal */\n    public updateTick = -1;\n\n    /**\n     * Current transform of the object based on local factors: position, scale, other stuff.\n     * This matrix represents the local transformation without any parent influence.\n     * @example\n     * ```ts\n     * // Basic transform access\n     * const localMatrix = sprite.localTransform;\n     * console.log(localMatrix.toString());\n     * ```\n     * @readonly\n     * @see {@link Container#worldTransform} For global transform\n     * @see {@link Container#groupTransform} For render group transform\n     */\n    public localTransform: Matrix = new Matrix();\n    /**\n     * The relative group transform is a transform relative to the render group it belongs too. It will include all parent\n     * transforms and up to the render group (think of it as kind of like a stage - but the stage can be nested).\n     * If this container is is self a render group matrix will be relative to its parent render group\n     * @readonly\n     * @advanced\n     */\n    public relativeGroupTransform: Matrix = new Matrix();\n    /**\n     * The group transform is a transform relative to the render group it belongs too.\n     * If this container is render group then this will be an identity matrix. other wise it\n     * will be the same as the relativeGroupTransform.\n     * Use this value when actually rendering things to the screen\n     * @readonly\n     * @advanced\n     */\n    public groupTransform: Matrix = this.relativeGroupTransform;\n\n    // the global transform taking into account the render group and all parents\n    private _worldTransform: Matrix;\n\n    /**\n     * Whether this object has been destroyed. If true, the object should no longer be used.\n     * After an object is destroyed, all of its functionality is disabled and references are removed.\n     * @example\n     * ```ts\n     * // Cleanup with destroy\n     * sprite.destroy();\n     * console.log(sprite.destroyed); // true\n     * ```\n     * @default false\n     * @see {@link Container#destroy} For destroying objects\n     */\n    public destroyed = false;\n\n    // transform data..\n    /**\n     * The coordinate of the object relative to the local coordinates of the parent.\n     * @internal\n     */\n    public _position: ObservablePoint = new ObservablePoint(this, 0, 0);\n\n    /**\n     * The scale factor of the object.\n     * @internal\n     */\n    public _scale: ObservablePoint = defaultScale;\n\n    /**\n     * The pivot point of the container that it rotates around.\n     * @internal\n     */\n    public _pivot: ObservablePoint = defaultPivot;\n\n    /**\n     * The origin point around which the container rotates and scales.\n     * Unlike pivot, changing origin will not move the container's position.\n     * @private\n     */\n    public _origin: ObservablePoint = defaultOrigin;\n\n    /**\n     * The skew amount, on the x and y axis.\n     * @internal\n     */\n    public _skew: ObservablePoint = defaultSkew;\n\n    /**\n     * The X-coordinate value of the normalized local X axis,\n     * the first column of the local transformation matrix without a scale.\n     * @internal\n     */\n    public _cx = 1;\n\n    /**\n     * The Y-coordinate value of the normalized local X axis,\n     * the first column of the local transformation matrix without a scale.\n     * @internal\n     */\n    public _sx = 0;\n\n    /**\n     * The X-coordinate value of the normalized local Y axis,\n     * the second column of the local transformation matrix without a scale.\n     * @internal\n     */\n    public _cy = 0;\n\n    /**\n     * The Y-coordinate value of the normalized local Y axis,\n     * the second column of the local transformation matrix without a scale.\n     * @internal\n     */\n    public _sy = 1;\n\n    /**\n     * The rotation amount.\n     * @internal\n     */\n    private _rotation = 0;\n\n    // / COLOR related props //////////////\n\n    // color stored as ABGR\n    /** @internal */\n    public localColor = 0xFFFFFF;\n    /** @internal */\n    public localAlpha = 1;\n\n    /** @internal */\n    public groupAlpha = 1; // A\n    /** @internal */\n    public groupColor = 0xFFFFFF; // BGR\n    /** @internal */\n    public groupColorAlpha = 0xFFFFFFFF; // ABGR\n\n    // / BLEND related props //////////////\n\n    /** @internal */\n    public localBlendMode: BLEND_MODES = 'inherit';\n    /** @internal */\n    public groupBlendMode: BLEND_MODES = 'normal';\n\n    // / VISIBILITY related props //////////////\n\n    // visibility\n    // 0b11\n    // first bit is visible, second bit is renderable\n    /**\n     * This property holds three bits: culled, visible, renderable\n     * the third bit represents culling (0 = culled, 1 = not culled) 0b100\n     * the second bit represents visibility (0 = not visible, 1 = visible) 0b010\n     * the first bit represents renderable (0 = not renderable, 1 = renderable) 0b001\n     * @internal\n     */\n    public localDisplayStatus = 0b111; // 0b11 | 0b10 | 0b01 | 0b00\n    /** @internal */\n    public globalDisplayStatus = 0b111; // 0b11 | 0b10 | 0b01 | 0b00\n\n    /** @internal */\n    public readonly renderPipeId: string;\n\n    /**\n     * An optional bounds area for this container. Setting this rectangle will stop the renderer\n     * from recursively measuring the bounds of each children and instead use this single boundArea.\n     *\n     * > [!IMPORTANT] This is great for optimisation! If for example you have a\n     * > 1000 spinning particles and you know they all sit within a specific bounds,\n     * > then setting it will mean the renderer will not need to measure the\n     * > 1000 children to find the bounds. Instead it will just use the bounds you set.\n     * @example\n     * ```ts\n     * const container = new Container();\n     * container.boundsArea = new Rectangle(0, 0, 500, 500);\n     * ```\n     */\n    public boundsArea: Rectangle;\n\n    /**\n     * A value that increments each time the containe is modified\n     * eg children added, removed etc\n     * @ignore\n     */\n    public _didContainerChangeTick = 0;\n    /**\n     * A value that increments each time the container view is modified\n     * eg texture swap, geometry change etc\n     * @ignore\n     */\n    public _didViewChangeTick = 0;\n\n    /** @internal */\n    public layerParentId: string;// = 'default';\n    /**\n     * We now use the _didContainerChangeTick and _didViewChangeTick to track changes\n     * @deprecated since 8.2.6\n     * @ignore\n     */\n    set _didChangeId(value: number)\n    {\n        this._didViewChangeTick = (value >> 12) & 0xFFF; // Extract the upper 12 bits\n        this._didContainerChangeTick = value & 0xFFF; // Extract the lower 12 bits\n    }\n    /** @ignore */\n    get _didChangeId(): number\n    {\n        return (this._didContainerChangeTick & 0xfff) | ((this._didViewChangeTick & 0xfff) << 12);\n    }\n\n    /**\n     * property that tracks if the container transform has changed\n     * @ignore\n     */\n    private _didLocalTransformChangeId = -1;\n\n    constructor(options: ContainerOptions<C> = {})\n    {\n        super();\n\n        this.effects = [];\n        assignWithIgnore(this, options, {\n            children: true,\n            parent: true,\n            effects: true,\n        });\n\n        options.children?.forEach((child) => this.addChild(child));\n        options.parent?.addChild(this);\n    }\n\n    /**\n     * Adds one or more children to the container.\n     * The children will be rendered as part of this container's display list.\n     * @example\n     * ```ts\n     * // Add a single child\n     * container.addChild(sprite);\n     *\n     * // Add multiple children\n     * container.addChild(background, player, foreground);\n     *\n     * // Add with type checking\n     * const sprite = container.addChild<Sprite>(new Sprite(texture));\n     * sprite.tint = 'red';\n     * ```\n     * @param children - The Container(s) to add to the container\n     * @returns The first child that was added\n     * @see {@link Container#removeChild} For removing children\n     * @see {@link Container#addChildAt} For adding at specific index\n     */\n    public addChild<U extends(C | IRenderLayer)[]>(...children: U): U[0]\n    {\n        // #if _DEBUG\n        if (!this.allowChildren)\n        {\n            deprecation(v8_0_0, 'addChild: Only Containers will be allowed to add children in v8.0.0');\n        }\n        // #endif\n\n        if (children.length > 1)\n        {\n            // loop through the array and add all children\n            for (let i = 0; i < children.length; i++)\n            {\n                this.addChild(children[i]);\n            }\n\n            return children[0];\n        }\n\n        const child = children[0] as C;\n\n        const renderGroup = this.renderGroup || this.parentRenderGroup;\n\n        if (child.parent === this)\n        {\n            this.children.splice(this.children.indexOf(child), 1);\n            this.children.push(child);\n\n            if (renderGroup)\n            {\n                renderGroup.structureDidChange = true;\n            }\n\n            return child;\n        }\n\n        if (child.parent)\n        {\n            // TODO Optimisation...if the parent has the same render group, this does not need to change!\n            child.parent.removeChild(child);\n        }\n\n        this.children.push(child);\n\n        if (this.sortableChildren) this.sortDirty = true;\n\n        child.parent = this;\n\n        child.didChange = true;\n\n        // TODO - Optimise this? could check what the parent has set?\n        child._updateFlags = 0b1111;\n\n        if (renderGroup)\n        {\n            renderGroup.addChild(child);\n        }\n\n        this.emit('childAdded', child, this, this.children.length - 1);\n        child.emit('added', this);\n\n        this._didViewChangeTick++;\n\n        if (child._zIndex !== 0)\n        {\n            child.depthOfChildModified();\n        }\n\n        return child;\n    }\n\n    /**\n     * Removes one or more children from the container.\n     * When removing multiple children, events will be triggered for each child in sequence.\n     * @example\n     * ```ts\n     * // Remove a single child\n     * const removed = container.removeChild(sprite);\n     *\n     * // Remove multiple children\n     * const bg = container.removeChild(background, player, userInterface);\n     *\n     * // Remove with type checking\n     * const sprite = container.removeChild<Sprite>(childSprite);\n     * sprite.texture = newTexture;\n     * ```\n     * @param children - The Container(s) to remove\n     * @returns The first child that was removed\n     * @see {@link Container#addChild} For adding children\n     * @see {@link Container#removeChildren} For removing multiple children\n     */\n    public removeChild<U extends(C | IRenderLayer)[]>(...children: U): U[0]\n    {\n        // if there is only one argument we can bypass looping through the them\n        if (children.length > 1)\n        {\n            // loop through the arguments property and remove all children\n            for (let i = 0; i < children.length; i++)\n            {\n                this.removeChild(children[i]);\n            }\n\n            return children[0];\n        }\n\n        const child = children[0] as C;\n\n        const index = this.children.indexOf(child);\n\n        if (index > -1)\n        {\n            this._didViewChangeTick++;\n\n            this.children.splice(index, 1);\n\n            if (this.renderGroup)\n            {\n                this.renderGroup.removeChild(child);\n            }\n            else if (this.parentRenderGroup)\n            {\n                this.parentRenderGroup.removeChild(child);\n            }\n\n            if (child.parentRenderLayer)\n            {\n                child.parentRenderLayer.detach(child);\n            }\n\n            child.parent = null;\n            this.emit('childRemoved', child, this, index);\n            child.emit('removed', this);\n        }\n\n        return child;\n    }\n\n    /** @ignore */\n    public _onUpdate(point?: ObservablePoint)\n    {\n        if (point)\n        {\n            //   this.updateFlags |= UPDATE_TRANSFORM;\n\n            if (point === this._skew)\n            {\n                this._updateSkew();\n            }\n        }\n\n        this._didContainerChangeTick++;\n\n        if (this.didChange) return;\n        this.didChange = true;\n\n        if (this.parentRenderGroup)\n        {\n            this.parentRenderGroup.onChildUpdate(this);\n        }\n    }\n\n    set isRenderGroup(value: boolean)\n    {\n        if (!!this.renderGroup === value) return;\n\n        if (value)\n        {\n            this.enableRenderGroup();\n        }\n        else\n        {\n            this.disableRenderGroup();\n        }\n    }\n\n    /**\n     * Returns true if this container is a render group.\n     * This means that it will be rendered as a separate pass, with its own set of instructions\n     * @advanced\n     */\n    get isRenderGroup(): boolean\n    {\n        return !!this.renderGroup;\n    }\n\n    /**\n     * Calling this enables a render group for this container.\n     * This means it will be rendered as a separate set of instructions.\n     * The transform of the container will also be handled on the GPU rather than the CPU.\n     * @advanced\n     */\n    public enableRenderGroup(): void\n    {\n        if (this.renderGroup) return;\n\n        const parentRenderGroup = this.parentRenderGroup;\n\n        parentRenderGroup?.removeChild(this);\n\n        this.renderGroup = BigPool.get(RenderGroup, this);\n\n        // this group matrix will now be an identity matrix,\n        // as its own transform will be passed to the GPU\n        this.groupTransform = Matrix.IDENTITY;\n\n        parentRenderGroup?.addChild(this);\n\n        this._updateIsSimple();\n    }\n\n    /**\n     * This will disable the render group for this container.\n     * @advanced\n     */\n    public disableRenderGroup(): void\n    {\n        if (!this.renderGroup) return;\n\n        const parentRenderGroup = this.parentRenderGroup;\n\n        parentRenderGroup?.removeChild(this);\n\n        BigPool.return(this.renderGroup);\n\n        this.renderGroup = null;\n        this.groupTransform = this.relativeGroupTransform;\n\n        parentRenderGroup?.addChild(this);\n\n        this._updateIsSimple();\n    }\n\n    /** @ignore */\n    public _updateIsSimple()\n    {\n        this.isSimple = !(this.renderGroup) && (this.effects.length === 0);\n    }\n\n    /**\n     * Current transform of the object based on world (parent) factors.\n     *\n     * This matrix represents the absolute transformation in the scene graph.\n     * @example\n     * ```ts\n     * // Get world position\n     * const worldPos = container.worldTransform;\n     * console.log(`World position: (${worldPos.tx}, ${worldPos.ty})`);\n     * ```\n     * @readonly\n     * @see {@link Container#localTransform} For local space transform\n     */\n    get worldTransform()\n    {\n        this._worldTransform ||= new Matrix();\n\n        if (this.renderGroup)\n        {\n            this._worldTransform.copyFrom(this.renderGroup.worldTransform);\n        }\n        else if (this.parentRenderGroup)\n        {\n            this._worldTransform.appendFrom(this.relativeGroupTransform, this.parentRenderGroup.worldTransform);\n        }\n\n        return this._worldTransform;\n    }\n\n    /**\n     * The position of the container on the x axis relative to the local coordinates of the parent.\n     *\n     * An alias to position.x\n     * @example\n     * ```ts\n     * // Basic position\n     * container.x = 100;\n     * ```\n     */\n    get x(): number\n    {\n        return this._position.x;\n    }\n\n    set x(value: number)\n    {\n        this._position.x = value;\n    }\n\n    /**\n     * The position of the container on the y axis relative to the local coordinates of the parent.\n     *\n     * An alias to position.y\n     * @example\n     * ```ts\n     * // Basic position\n     * container.y = 200;\n     * ```\n     */\n    get y(): number\n    {\n        return this._position.y;\n    }\n\n    set y(value: number)\n    {\n        this._position.y = value;\n    }\n\n    /**\n     * The coordinate of the object relative to the local coordinates of the parent.\n     * @example\n     * ```ts\n     * // Basic position setting\n     * container.position.set(100, 200);\n     * container.position.set(100); // Sets both x and y to 100\n     * // Using point data\n     * container.position = { x: 50, y: 75 };\n     * ```\n     * @since 4.0.0\n     */\n    get position(): ObservablePoint\n    {\n        return this._position;\n    }\n\n    set position(value: PointData)\n    {\n        this._position.copyFrom(value);\n    }\n\n    /**\n     * The rotation of the object in radians.\n     *\n     * > [!NOTE] 'rotation' and 'angle' have the same effect on a display object;\n     * > rotation is in radians, angle is in degrees.\n     * @example\n     * ```ts\n     * // Basic rotation\n     * container.rotation = Math.PI / 4; // 45 degrees\n     *\n     * // Convert from degrees\n     * const degrees = 45;\n     * container.rotation = degrees * Math.PI / 180;\n     *\n     * // Rotate around center\n     * container.pivot.set(container.width / 2, container.height / 2);\n     * container.rotation = Math.PI; // 180 degrees\n     *\n     * // Rotate around center with origin\n     * container.origin.set(container.width / 2, container.height / 2);\n     * container.rotation = Math.PI; // 180 degrees\n     * ```\n     */\n    get rotation(): number\n    {\n        return this._rotation;\n    }\n\n    set rotation(value: number)\n    {\n        if (this._rotation !== value)\n        {\n            this._rotation = value;\n            this._onUpdate(this._skew);\n        }\n    }\n\n    /**\n     * The angle of the object in degrees.\n     *\n     * > [!NOTE] 'rotation' and 'angle' have the same effect on a display object;\n     * > rotation is in radians, angle is in degrees.\n     * @example\n     * ```ts\n     * // Basic angle rotation\n     * sprite.angle = 45; // 45 degrees\n     *\n     * // Rotate around center\n     * sprite.pivot.set(sprite.width / 2, sprite.height / 2);\n     * sprite.angle = 180; // Half rotation\n     *\n     * // Rotate around center with origin\n     * sprite.origin.set(sprite.width / 2, sprite.height / 2);\n     * sprite.angle = 180; // Half rotation\n     *\n     * // Reset rotation\n     * sprite.angle = 0;\n     * ```\n     */\n    get angle(): number\n    {\n        return this.rotation * RAD_TO_DEG;\n    }\n\n    set angle(value: number)\n    {\n        this.rotation = value * DEG_TO_RAD;\n    }\n\n    /**\n     * The center of rotation, scaling, and skewing for this display object in its local space.\n     * The `position` is the projection of `pivot` in the parent's local space.\n     *\n     * By default, the pivot is the origin (0, 0).\n     * @example\n     * ```ts\n     * // Rotate around center\n     * container.pivot.set(container.width / 2, container.height / 2);\n     * container.rotation = Math.PI; // Rotates around center\n     * ```\n     * @since 4.0.0\n     */\n    get pivot(): ObservablePoint\n    {\n        if (this._pivot === defaultPivot)\n        {\n            this._pivot = new ObservablePoint(this, 0, 0);\n        }\n\n        return this._pivot;\n    }\n\n    set pivot(value: PointData | number)\n    {\n        if (this._pivot === defaultPivot)\n        {\n            this._pivot = new ObservablePoint(this, 0, 0);\n\n            // #if _DEBUG\n            if (this._origin !== defaultOrigin)\n            {\n                // eslint-disable-next-line max-len\n                warn(`Setting both a pivot and origin on a Container is not recommended. This can lead to unexpected behavior if not handled carefully.`);\n            }\n            // #endif\n        }\n\n        typeof value === 'number' ? this._pivot.set(value) : this._pivot.copyFrom(value);\n    }\n\n    /**\n     * The skew factor for the object in radians. Skewing is a transformation that distorts\n     * the object by rotating it differently at each point, creating a non-uniform shape.\n     * @example\n     * ```ts\n     * // Basic skewing\n     * container.skew.set(0.5, 0); // Skew horizontally\n     * container.skew.set(0, 0.5); // Skew vertically\n     *\n     * // Skew with point data\n     * container.skew = { x: 0.3, y: 0.3 }; // Diagonal skew\n     *\n     * // Reset skew\n     * container.skew.set(0, 0);\n     *\n     * // Animate skew\n     * app.ticker.add(() => {\n     *     // Create wave effect\n     *     container.skew.x = Math.sin(Date.now() / 1000) * 0.3;\n     * });\n     *\n     * // Combine with rotation\n     * container.rotation = Math.PI / 4; // 45 degrees\n     * container.skew.set(0.2, 0.2); // Skew the rotated object\n     * ```\n     * @since 4.0.0\n     * @type {ObservablePoint} Point-like object with x/y properties in radians\n     * @default {x: 0, y: 0}\n     */\n    get skew(): ObservablePoint\n    {\n        if (this._skew === defaultSkew)\n        {\n            this._skew = new ObservablePoint(this, 0, 0);\n        }\n\n        return this._skew;\n    }\n\n    set skew(value: PointData)\n    {\n        if (this._skew === defaultSkew)\n        {\n            this._skew = new ObservablePoint(this, 0, 0);\n        }\n\n        this._skew.copyFrom(value);\n    }\n\n    /**\n     * The scale factors of this object along the local coordinate axes.\n     *\n     * The default scale is (1, 1).\n     * @example\n     * ```ts\n     * // Basic scaling\n     * container.scale.set(2, 2); // Scales to double size\n     * container.scale.set(2); // Scales uniformly to double size\n     * container.scale = 2; // Scales uniformly to double size\n     * // Scale to a specific width and height\n     * container.setSize(200, 100); // Sets width to 200 and height to 100\n     * ```\n     * @since 4.0.0\n     */\n    get scale(): ObservablePoint\n    {\n        if (this._scale === defaultScale)\n        {\n            this._scale = new ObservablePoint(this, 1, 1);\n        }\n\n        return this._scale;\n    }\n\n    set scale(value: PointData | number | string)\n    {\n        if (this._scale === defaultScale)\n        {\n            this._scale = new ObservablePoint(this, 0, 0);\n        }\n\n        if (typeof value === 'string')\n        {\n            value = parseFloat(value);\n        }\n\n        typeof value === 'number' ? this._scale.set(value) : this._scale.copyFrom(value);\n    }\n\n    /**\n     * @experimental\n     * The origin point around which the container rotates and scales without affecting its position.\n     * Unlike pivot, changing the origin will not move the container's position.\n     * @example\n     * ```ts\n     * // Rotate around center point\n     * container.origin.set(container.width / 2, container.height / 2);\n     * container.rotation = Math.PI; // Rotates around center\n     *\n     * // Reset origin\n     * container.origin.set(0, 0);\n     * ```\n     */\n    get origin(): ObservablePoint\n    {\n        if (this._origin === defaultOrigin)\n        {\n            this._origin = new ObservablePoint(this, 0, 0);\n        }\n\n        return this._origin;\n    }\n\n    set origin(value: PointData | number)\n    {\n        if (this._origin === defaultOrigin)\n        {\n            this._origin = new ObservablePoint(this, 0, 0);\n\n            // #if _DEBUG\n            if (this._pivot !== defaultPivot)\n            {\n                // eslint-disable-next-line max-len\n                warn(`Setting both a pivot and origin on a Container is not recommended. This can lead to unexpected behavior if not handled carefully.`);\n            }\n            // #endif\n        }\n\n        typeof value === 'number' ? this._origin.set(value) : this._origin.copyFrom(value);\n    }\n\n    /**\n     * The width of the Container, setting this will actually modify the scale to achieve the value set.\n     * > [!NOTE] Changing the width will adjust the scale.x property of the container while maintaining its aspect ratio.\n     * > [!NOTE] If you want to set both width and height at the same time, use {@link Container#setSize}\n     * as it is more optimized by not recalculating the local bounds twice.\n     * @example\n     * ```ts\n     * // Basic width setting\n     * container.width = 100;\n     * // Optimized width setting\n     * container.setSize(100, 100);\n     * ```\n     */\n    get width(): number\n    {\n        return Math.abs(this.scale.x * this.getLocalBounds().width);\n    }\n\n    set width(value: number)\n    {\n        const localWidth = this.getLocalBounds().width;\n\n        this._setWidth(value, localWidth);\n    }\n\n    /**\n     * The height of the Container,\n     * > [!NOTE] Changing the height will adjust the scale.y property of the container while maintaining its aspect ratio.\n     * > [!NOTE] If you want to set both width and height at the same time, use {@link Container#setSize}\n     * as it is more optimized by not recalculating the local bounds twice.\n     * @example\n     * ```ts\n     * // Basic height setting\n     * container.height = 200;\n     * // Optimized height setting\n     * container.setSize(100, 200);\n     * ```\n     */\n    get height(): number\n    {\n        return Math.abs(this.scale.y * this.getLocalBounds().height);\n    }\n\n    set height(value: number)\n    {\n        const localHeight = this.getLocalBounds().height;\n\n        this._setHeight(value, localHeight);\n    }\n\n    /**\n     * Retrieves the size of the container as a [Size]{@link Size} object.\n     *\n     * This is faster than get the width and height separately.\n     * @example\n     * ```ts\n     * // Basic size retrieval\n     * const size = container.getSize();\n     * console.log(`Size: ${size.width}x${size.height}`);\n     *\n     * // Reuse existing size object\n     * const reuseSize = { width: 0, height: 0 };\n     * container.getSize(reuseSize);\n     * ```\n     * @param out - Optional object to store the size in.\n     * @returns The size of the container.\n     */\n    public getSize(out?: Size): Size\n    {\n        if (!out)\n        {\n            out = {} as Size;\n        }\n\n        const bounds = this.getLocalBounds();\n\n        out.width = Math.abs(this.scale.x * bounds.width);\n        out.height = Math.abs(this.scale.y * bounds.height);\n\n        return out;\n    }\n\n    /**\n     * Sets the size of the container to the specified width and height.\n     * This is more efficient than setting width and height separately as it only recalculates bounds once.\n     * @example\n     * ```ts\n     * // Basic size setting\n     * container.setSize(100, 200);\n     *\n     * // Set uniform size\n     * container.setSize(100); // Sets both width and height to 100\n     * ```\n     * @param value - This can be either a number or a [Size]{@link Size} object.\n     * @param height - The height to set. Defaults to the value of `width` if not provided.\n     */\n    public setSize(value: number | Optional<Size, 'height'>, height?: number)\n    {\n        const size = this.getLocalBounds();\n\n        if (typeof value === 'object')\n        {\n            height = value.height ?? value.width;\n            value = value.width;\n        }\n        else\n        {\n            height ??= value;\n        }\n\n        value !== undefined && this._setWidth(value, size.width);\n        height !== undefined && this._setHeight(height, size.height);\n    }\n\n    /** Called when the skew or the rotation changes. */\n    private _updateSkew(): void\n    {\n        const rotation = this._rotation;\n        const skew = this._skew;\n\n        this._cx = Math.cos(rotation + skew._y);\n        this._sx = Math.sin(rotation + skew._y);\n        this._cy = -Math.sin(rotation - skew._x); // cos, added PI/2\n        this._sy = Math.cos(rotation - skew._x); // sin, added PI/2\n    }\n\n    /**\n     * Updates the transform properties of the container.\n     * Allows partial updates of transform properties for optimized manipulation.\n     * @example\n     * ```ts\n     * // Basic transform update\n     * container.updateTransform({\n     *     x: 100,\n     *     y: 200,\n     *     rotation: Math.PI / 4\n     * });\n     *\n     * // Scale and rotate around center\n     * sprite.updateTransform({\n     *     pivotX: sprite.width / 2,\n     *     pivotY: sprite.height / 2,\n     *     scaleX: 2,\n     *     scaleY: 2,\n     *     rotation: Math.PI\n     * });\n     *\n     * // Update position only\n     * button.updateTransform({\n     *     x: button.x + 10, // Move right\n     *     y: button.y      // Keep same y\n     * });\n     * ```\n     * @param opts - Transform options to update\n     * @param opts.x - The x position\n     * @param opts.y - The y position\n     * @param opts.scaleX - The x-axis scale factor\n     * @param opts.scaleY - The y-axis scale factor\n     * @param opts.rotation - The rotation in radians\n     * @param opts.skewX - The x-axis skew factor\n     * @param opts.skewY - The y-axis skew factor\n     * @param opts.pivotX - The x-axis pivot point\n     * @param opts.pivotY - The y-axis pivot point\n     * @returns This container, for chaining\n     * @see {@link Container#setFromMatrix} For matrix-based transforms\n     * @see {@link Container#position} For direct position access\n     */\n    public updateTransform(opts: Partial<UpdateTransformOptions>): this\n    {\n        this.position.set(\n            typeof opts.x === 'number' ? opts.x : this.position.x,\n            typeof opts.y === 'number' ? opts.y : this.position.y\n        );\n        this.scale.set(\n            typeof opts.scaleX === 'number' ? opts.scaleX || 1 : this.scale.x,\n            typeof opts.scaleY === 'number' ? opts.scaleY || 1 : this.scale.y\n        );\n        this.rotation = typeof opts.rotation === 'number' ? opts.rotation : this.rotation;\n        this.skew.set(\n            typeof opts.skewX === 'number' ? opts.skewX : this.skew.x,\n            typeof opts.skewY === 'number' ? opts.skewY : this.skew.y\n        );\n        this.pivot.set(\n            typeof opts.pivotX === 'number' ? opts.pivotX : this.pivot.x,\n            typeof opts.pivotY === 'number' ? opts.pivotY : this.pivot.y\n        );\n        this.origin.set(\n            typeof opts.originX === 'number' ? opts.originX : this.origin.x,\n            typeof opts.originY === 'number' ? opts.originY : this.origin.y\n        );\n\n        return this;\n    }\n\n    /**\n     * Updates the local transform properties by decomposing the given matrix.\n     * Extracts position, scale, rotation, and skew from a transformation matrix.\n     * @example\n     * ```ts\n     * // Basic matrix transform\n     * const matrix = new Matrix()\n     *     .translate(100, 100)\n     *     .rotate(Math.PI / 4)\n     *     .scale(2, 2);\n     *\n     * container.setFromMatrix(matrix);\n     *\n     * // Copy transform from another container\n     * const source = new Container();\n     * source.position.set(100, 100);\n     * source.rotation = Math.PI / 2;\n     *\n     * target.setFromMatrix(source.localTransform);\n     *\n     * // Reset transform\n     * container.setFromMatrix(Matrix.IDENTITY);\n     * ```\n     * @param matrix - The matrix to use for updating the transform\n     * @see {@link Container#updateTransform} For property-based updates\n     * @see {@link Matrix#decompose} For matrix decomposition details\n     */\n    public setFromMatrix(matrix: Matrix): void\n    {\n        matrix.decompose(this);\n    }\n\n    /** Updates the local transform. */\n    public updateLocalTransform(): void\n    {\n        const localTransformChangeId = this._didContainerChangeTick;\n\n        if (this._didLocalTransformChangeId === localTransformChangeId) return;\n\n        this._didLocalTransformChangeId = localTransformChangeId;\n\n        const lt = this.localTransform;\n        const scale = this._scale;\n        const pivot = this._pivot;\n        const origin = this._origin;\n        const position = this._position;\n\n        const sx = scale._x;\n        const sy = scale._y;\n\n        const px = pivot._x;\n        const py = pivot._y;\n\n        const ox = -origin._x;\n        const oy = -origin._y;\n\n        // get the matrix values of the container based on its this properties..\n        lt.a = this._cx * sx;\n        lt.b = this._sx * sx;\n        lt.c = this._cy * sy;\n        lt.d = this._sy * sy;\n\n        lt.tx = position._x - ((px * lt.a) + (py * lt.c)) // Pivot offset\n            + ((ox * lt.a) + (oy * lt.c)) // Origin offset for rotation and scaling\n            - ox; // Remove origin to maintain position\n        lt.ty = position._y - ((px * lt.b) + (py * lt.d)) // Pivot offset\n            + ((ox * lt.b) + (oy * lt.d)) // Origin offset for rotation and scaling\n            - oy; // Remove origin to maintain position\n    }\n\n    // / ///// color related stuff\n\n    set alpha(value: number)\n    {\n        if (value === this.localAlpha) return;\n\n        this.localAlpha = value;\n\n        this._updateFlags |= UPDATE_COLOR;\n\n        this._onUpdate();\n    }\n\n    /**\n     * The opacity of the object relative to its parent's opacity.\n     * Value ranges from 0 (fully transparent) to 1 (fully opaque).\n     * @example\n     * ```ts\n     * // Basic transparency\n     * sprite.alpha = 0.5; // 50% opacity\n     *\n     * // Inherited opacity\n     * container.alpha = 0.5;\n     * const child = new Sprite(texture);\n     * child.alpha = 0.5;\n     * container.addChild(child);\n     * // child's effective opacity is 0.25 (0.5 * 0.5)\n     * ```\n     * @default 1\n     * @see {@link Container#visible} For toggling visibility\n     * @see {@link Container#renderable} For render control\n     */\n    get alpha(): number\n    {\n        return this.localAlpha;\n    }\n\n    set tint(value: ColorSource)\n    {\n        const tempColor = Color.shared.setValue(value ?? 0xFFFFFF);\n        const bgr = tempColor.toBgrNumber();\n\n        if (bgr === this.localColor) return;\n\n        this.localColor = bgr;\n\n        this._updateFlags |= UPDATE_COLOR;\n\n        this._onUpdate();\n    }\n\n    /**\n     * The tint applied to the sprite.\n     *\n     * This can be any valid {@link ColorSource}.\n     * @example\n     * ```ts\n     * // Basic color tinting\n     * container.tint = 0xff0000; // Red tint\n     * container.tint = 'red';    // Same as above\n     * container.tint = '#00ff00'; // Green\n     * container.tint = 'rgb(0,0,255)'; // Blue\n     *\n     * // Remove tint\n     * container.tint = 0xffffff; // White = no tint\n     * container.tint = null;     // Also removes tint\n     * ```\n     * @default 0xFFFFFF\n     * @see {@link Container#alpha} For transparency\n     * @see {@link Container#visible} For visibility control\n     */\n    get tint(): number\n    {\n        // convert bgr to rgb..\n        return bgr2rgb(this.localColor);\n    }\n\n    // / //////////////// blend related stuff\n\n    set blendMode(value: BLEND_MODES)\n    {\n        if (this.localBlendMode === value) return;\n        if (this.parentRenderGroup)\n        {\n            this.parentRenderGroup.structureDidChange = true;\n        }\n\n        this._updateFlags |= UPDATE_BLEND;\n\n        this.localBlendMode = value;\n\n        this._onUpdate();\n    }\n\n    /**\n     * The blend mode to be applied to the sprite. Controls how pixels are blended when rendering.\n     *\n     * Setting to 'normal' will reset to default blending.\n     * > [!NOTE] More blend modes are available after importing the `pixi.js/advanced-blend-modes` sub-export.\n     * @example\n     * ```ts\n     * // Basic blend modes\n     * sprite.blendMode = 'add';        // Additive blending\n     * sprite.blendMode = 'multiply';   // Multiply colors\n     * sprite.blendMode = 'screen';     // Screen blend\n     *\n     * // Reset blend mode\n     * sprite.blendMode = 'normal';     // Normal blending\n     * ```\n     * @default 'normal'\n     * @see {@link Container#alpha} For transparency\n     * @see {@link Container#tint} For color adjustments\n     */\n    get blendMode(): BLEND_MODES\n    {\n        return this.localBlendMode;\n    }\n\n    // / ///////// VISIBILITY / RENDERABLE /////////////////\n\n    /**\n     * The visibility of the object. If false the object will not be drawn,\n     * and the transform will not be updated.\n     * @example\n     * ```ts\n     * // Basic visibility toggle\n     * sprite.visible = false; // Hide sprite\n     * sprite.visible = true;  // Show sprite\n     * ```\n     * @default true\n     * @see {@link Container#renderable} For render-only control\n     * @see {@link Container#alpha} For transparency\n     */\n    get visible()\n    {\n        return !!(this.localDisplayStatus & 0b010);\n    }\n\n    set visible(value: boolean)\n    {\n        const valueNumber = value ? 0b010 : 0;\n\n        if ((this.localDisplayStatus & 0b010) === valueNumber) return;\n\n        if (this.parentRenderGroup)\n        {\n            this.parentRenderGroup.structureDidChange = true;\n        }\n\n        this._updateFlags |= UPDATE_VISIBLE;\n\n        this.localDisplayStatus ^= 0b010;\n\n        this._onUpdate();\n    }\n\n    /** @ignore */\n    get culled()\n    {\n        return !(this.localDisplayStatus & 0b100);\n    }\n\n    /** @ignore */\n    set culled(value: boolean)\n    {\n        const valueNumber = value ? 0 : 0b100;\n\n        if ((this.localDisplayStatus & 0b100) === valueNumber) return;\n\n        if (this.parentRenderGroup)\n        {\n            this.parentRenderGroup.structureDidChange = true;\n        }\n\n        this._updateFlags |= UPDATE_VISIBLE;\n        this.localDisplayStatus ^= 0b100;\n\n        this._onUpdate();\n    }\n\n    /**\n     * Controls whether this object can be rendered. If false the object will not be drawn,\n     * but the transform will still be updated. This is different from visible, which skips\n     * transform updates.\n     * @example\n     * ```ts\n     * // Basic render control\n     * sprite.renderable = false; // Skip rendering\n     * sprite.renderable = true;  // Enable rendering\n     * ```\n     * @default true\n     * @see {@link Container#visible} For skipping transform updates\n     * @see {@link Container#alpha} For transparency\n     */\n    get renderable()\n    {\n        return !!(this.localDisplayStatus & 0b001);\n    }\n\n    set renderable(value: boolean)\n    {\n        const valueNumber = value ? 0b001 : 0;\n\n        if ((this.localDisplayStatus & 0b001) === valueNumber) return;\n\n        this._updateFlags |= UPDATE_VISIBLE;\n        this.localDisplayStatus ^= 0b001;\n\n        if (this.parentRenderGroup)\n        {\n            this.parentRenderGroup.structureDidChange = true;\n        }\n\n        this._onUpdate();\n    }\n\n    /**\n     * Whether or not the object should be rendered.\n     * @advanced\n     */\n    get isRenderable(): boolean\n    {\n        return (this.localDisplayStatus === 0b111 && this.groupAlpha > 0);\n    }\n\n    /**\n     * Removes all internal references and listeners as well as removes children from the display list.\n     * Do not use a Container after calling `destroy`.\n     * @param options - Options parameter. A boolean will act as if all options\n     *  have been set to that value\n     * @example\n     * ```ts\n     * container.destroy();\n     * container.destroy(true);\n     * container.destroy({ children: true });\n     * container.destroy({ children: true, texture: true, textureSource: true });\n     * ```\n     */\n    public destroy(options: DestroyOptions = false): void\n    {\n        if (this.destroyed) return;\n        this.destroyed = true;\n\n        // remove children is faster than removeChild..\n\n        let oldChildren: ContainerChild[];\n\n        // we add this check as calling removeChildren on particle container will throw an error\n        // As we know it does cannot have any children, check before calling the function.\n        if (this.children.length)\n        {\n            oldChildren = this.removeChildren(0, this.children.length);\n        }\n\n        this.removeFromParent();\n        this.parent = null;\n        this._maskEffect = null;\n        this._filterEffect = null;\n        this.effects = null;\n        this._position = null;\n        this._scale = null;\n        this._pivot = null;\n        this._origin = null;\n        this._skew = null;\n\n        this.emit('destroyed', this);\n\n        this.removeAllListeners();\n\n        const destroyChildren = typeof options === 'boolean' ? options : options?.children;\n\n        if (destroyChildren && oldChildren)\n        {\n            for (let i = 0; i < oldChildren.length; ++i)\n            {\n                oldChildren[i].destroy(options);\n            }\n        }\n\n        this.renderGroup?.destroy();\n        this.renderGroup = null;\n    }\n}\n\nextensions.mixin(\n    Container,\n    childrenHelperMixin,\n    getFastGlobalBoundsMixin,\n    toLocalGlobalMixin,\n    onRenderMixin,\n    measureMixin,\n    effectsMixin,\n    findMixin,\n    sortMixin,\n    cullingMixin,\n    cacheAsTextureMixin,\n    getGlobalMixin,\n    collectRenderablesMixin,\n);\n"],"names":[],"mappings":"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"}