@safe-engine/pixi 8.10.2 → 8.10.4

package/dist/packages/pixijs/src/scene/text-split/SplitText.d.ts

@@ -1,176 +0,0 @@
-import { type ContainerOptions } from '../container/Container';
-import { type Text } from '../text/Text';
-import { type AbstractSplitOptions, AbstractSplitText } from './AbstractSplitText';
-import { type TextSplitOutput } from './types';
-/**
- * Configuration options for Text splitting.
- * @category text
- * @standard
- * @interface
- */
-export interface SplitOptions extends AbstractSplitOptions {
-}
-/**
- * Configuration options for SplitText, combining container properties with text splitting settings.
- * @example Basic Usage
- * ```ts
- * const options: SplitTextOptions = {
- *   text: 'Hello World',
- *   style: { fontSize: 32, fill: 0xffffff },
- *   // Transform origins
- *   lineAnchor: 0.5,                // Center each line
- *   wordAnchor: { x: 0, y: 0.5 },  // Left-center each word
- *   charAnchor: { x: 0.5, y: 1 },  // Bottom-center each char
- * };
- * ```
- * @example Advanced Configuration
- * ```ts
- * const options: SplitTextOptions = {
- *   // Text content and style
- *   text: 'Multi\nLine Text',
- *   style: new TextStyle({
- *     fontSize: 24,
- *     fill: 'white',
- *     strokeThickness: 2,
- *   }),
- *
- *   // Container properties
- *   x: 100,
- *   y: 100,
- *   alpha: 0.8,
- *
- *   // Splitting settings
- *   autoSplit: true,
- *
- *   // Transform origins (normalized 0-1)
- *   lineAnchor: { x: 1, y: 0 },    // Top-right
- *   wordAnchor: 0.5,               // Center
- *   charAnchor: { x: 0, y: 1 },    // Bottom-left
- * };
- * ```
- *
- * Properties:
- * - Container options from {@link ContainerOptions}
- * - Text splitting options from {@link SplitOptions}
- * - Additional PixiJS-specific options from PixiMixins.SplitText
- * @see {@link SplitText} For the main implementation
- * @see {@link ContainerOptions} For base container properties
- * @see {@link SplitOptions} For text splitting options
- * @category text
- * @standard
- */
-export interface SplitTextOptions extends PixiMixins.SplitText, ContainerOptions, SplitOptions {
-}
-/**
- * @experimental
- * A container that splits text into individually manipulatable segments (lines, words, and characters)
- * for advanced text effects and animations.
- * Converts each segment into a separate Text object.
- * @example Basic Usage
- * ```ts
- * const text = new SplitText({
- *   text: "Hello World",
- *   style: { fontSize: 24 },
- *   // Origin points for transformations (0-1 range)
- *   lineAnchor: 0.5,  // Center of each line
- *   wordAnchor: { x: 0, y: 0.5 },  // Left-center of each word
- *   charAnchor: { x: 0.5, y: 1 },  // Bottom-center of each character
- *   autoSplit: true  // Auto-update segments on text/style changes
- * });
- * ```
- *
- * Features:
- * - Hierarchical text segmentation (lines → words → characters)
- * - Independent transformation origins for each segment level
- * - Automatic or manual segment updates
- * @example Animation Example
- * ```ts
- * // Character fade-in sequence
- * text.chars.forEach((char, i) => {
- *   gsap.from(char, {
- *     alpha: 0,
- *     delay: i * 0.1
- *   });
- * });
- *
- * // Word scale animation
- * text.words.forEach((word, i) => {
- *   gsap.to(word.scale, {
- *     x: 1.2, y: 1.2,
- *     yoyo: true,
- *     repeat: -1,
- *     delay: i * 0.2
- *   });
- * });
- *
- * // Line slide-in effect
- * text.lines.forEach((line, i) => {
- *   gsap.from(line, {
- *     x: -200,
- *     delay: i * 0.3
- *   });
- * });
- * ```
- *
- * Configuration Options:
- * - `text`: The string to render and segment
- * - `style`: TextStyle instance or configuration object
- * - `autoSplit`: Automatically update segments on changes (default: true)
- * - `lineAnchor`: Transform origin for lines (default: 0)
- * - `wordAnchor`: Transform origin for words (default: 0)
- * - `charAnchor`: Transform origin for characters (default: 0)
- *
- * > [!NOTE] Anchor points are normalized (0-1):
- * > - 0,0: Top-left
- * > - 0.5,0.5: Center
- * > - 1,1: Bottom-right
- *
- * > [!WARNING] Limitations
- * > - Character spacing may differ slightly from standard text due to browser
- * >   kerning being lost when characters are separated
- * @category text
- * @standard
- */
-export declare class SplitText extends AbstractSplitText<Text> {
-    /**
-     * Default configuration options for SplitText instances.
-     * @example
-     * ```ts
-     * // Override defaults globally
-     * SplitText.defaultOptions = {
-     *   autoSplit: false,
-     *   lineAnchor: 0.5,  // Center alignment
-     *   wordAnchor: { x: 0, y: 0.5 },  // Left-center
-     *   charAnchor: { x: 0.5, y: 1 }   // Bottom-center
-     * };
-     * ```
-     */
-    static defaultOptions: Partial<SplitTextOptions>;
-    constructor(config: SplitTextOptions);
-    /**
-     * Creates a SplitText instance from an existing text object.
-     * Useful for converting standard Text or Text objects into segmented versions.
-     * @param text - The source text object to convert
-     * @param options - Additional splitting options
-     * @returns A new SplitText instance
-     * @example
-     * ```ts
-     * const text = new Text({
-     *   text: 'Bitmap Text',
-     *   style: { fontFamily: 'Arial' }
-     * });
-     *
-     * const segmented = SplitText.from(text);
-     *
-     * // with additional options
-     * const segmentedWithOptions = SplitText.from(text, {
-     *   autoSplit: false,
-     *   lineAnchor: 0.5,
-     *   wordAnchor: { x: 0, y: 0.5 },
-     * })
-     * ```
-     */
-    static from(text: Text, options?: Omit<SplitTextOptions, 'text' | 'style'>): SplitText;
-    protected splitFn(): TextSplitOutput<Text>;
-}
-//# sourceMappingURL=SplitText.d.ts.map

package/dist/packages/pixijs/src/scene/text-split/SplitText.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SplitText.d.ts","sourceRoot":"","sources":["../../../../../../packages/pixijs/src/scene/text-split/SplitText.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,cAAc,CAAC;AAGzC,OAAO,EAAE,KAAK,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACnF,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;GAKG;AAEH,MAAM,WAAW,YAAa,SAAQ,oBAAoB;CAAG;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,MAAM,WAAW,gBAAiB,SAAQ,UAAU,CAAC,SAAS,EAAE,gBAAgB,EAAE,YAAY;CAAG;AAEjG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AACH,qBAAa,SAAU,SAAQ,iBAAiB,CAAC,IAAI,CAAC;IAElD;;;;;;;;;;;;OAYG;IACH,OAAc,cAAc,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAKxB;gBAEnB,MAAM,EAAE,gBAAgB;IAUpC;;;;;;;;;;;;;;;;;;;;;;OAsBG;WACW,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,SAAS;IAc7F,SAAS,CAAC,OAAO,IAAI,eAAe,CAAC,IAAI,CAAC;CAQ7C"}

package/dist/packages/pixijs/src/scene/text-split/SplitText.js

@@ -1,132 +0,0 @@
-import { TextStyle } from '../text/TextStyle';
-import { canvasTextSplit } from '../text/utils/canvasTextSplit';
-import { AbstractSplitText } from './AbstractSplitText';
-/**
- * @experimental
- * A container that splits text into individually manipulatable segments (lines, words, and characters)
- * for advanced text effects and animations.
- * Converts each segment into a separate Text object.
- * @example Basic Usage
- * ```ts
- * const text = new SplitText({
- *   text: "Hello World",
- *   style: { fontSize: 24 },
- *   // Origin points for transformations (0-1 range)
- *   lineAnchor: 0.5,  // Center of each line
- *   wordAnchor: { x: 0, y: 0.5 },  // Left-center of each word
- *   charAnchor: { x: 0.5, y: 1 },  // Bottom-center of each character
- *   autoSplit: true  // Auto-update segments on text/style changes
- * });
- * ```
- *
- * Features:
- * - Hierarchical text segmentation (lines → words → characters)
- * - Independent transformation origins for each segment level
- * - Automatic or manual segment updates
- * @example Animation Example
- * ```ts
- * // Character fade-in sequence
- * text.chars.forEach((char, i) => {
- *   gsap.from(char, {
- *     alpha: 0,
- *     delay: i * 0.1
- *   });
- * });
- *
- * // Word scale animation
- * text.words.forEach((word, i) => {
- *   gsap.to(word.scale, {
- *     x: 1.2, y: 1.2,
- *     yoyo: true,
- *     repeat: -1,
- *     delay: i * 0.2
- *   });
- * });
- *
- * // Line slide-in effect
- * text.lines.forEach((line, i) => {
- *   gsap.from(line, {
- *     x: -200,
- *     delay: i * 0.3
- *   });
- * });
- * ```
- *
- * Configuration Options:
- * - `text`: The string to render and segment
- * - `style`: TextStyle instance or configuration object
- * - `autoSplit`: Automatically update segments on changes (default: true)
- * - `lineAnchor`: Transform origin for lines (default: 0)
- * - `wordAnchor`: Transform origin for words (default: 0)
- * - `charAnchor`: Transform origin for characters (default: 0)
- *
- * > [!NOTE] Anchor points are normalized (0-1):
- * > - 0,0: Top-left
- * > - 0.5,0.5: Center
- * > - 1,1: Bottom-right
- *
- * > [!WARNING] Limitations
- * > - Character spacing may differ slightly from standard text due to browser
- * >   kerning being lost when characters are separated
- * @category text
- * @standard
- */
-export class SplitText extends AbstractSplitText {
-    constructor(config) {
-        const completeOptions = Object.assign(Object.assign({}, SplitText.defaultOptions), config);
-        super(completeOptions);
-    }
-    /**
-     * Creates a SplitText instance from an existing text object.
-     * Useful for converting standard Text or Text objects into segmented versions.
-     * @param text - The source text object to convert
-     * @param options - Additional splitting options
-     * @returns A new SplitText instance
-     * @example
-     * ```ts
-     * const text = new Text({
-     *   text: 'Bitmap Text',
-     *   style: { fontFamily: 'Arial' }
-     * });
-     *
-     * const segmented = SplitText.from(text);
-     *
-     * // with additional options
-     * const segmentedWithOptions = SplitText.from(text, {
-     *   autoSplit: false,
-     *   lineAnchor: 0.5,
-     *   wordAnchor: { x: 0, y: 0.5 },
-     * })
-     * ```
-     */
-    static from(text, options) {
-        const completeOptions = Object.assign(Object.assign(Object.assign({}, SplitText.defaultOptions), options), { text: text.text, style: new TextStyle(text.style) });
-        return new SplitText(Object.assign({}, completeOptions));
-    }
-    splitFn() {
-        return canvasTextSplit({
-            text: this._originalText,
-            style: this._style,
-            chars: this._canReuseChars ? this.chars : [],
-        });
-    }
-}
-/**
- * Default configuration options for SplitText instances.
- * @example
- * ```ts
- * // Override defaults globally
- * SplitText.defaultOptions = {
- *   autoSplit: false,
- *   lineAnchor: 0.5,  // Center alignment
- *   wordAnchor: { x: 0, y: 0.5 },  // Left-center
- *   charAnchor: { x: 0.5, y: 1 }   // Bottom-center
- * };
- * ```
- */
-SplitText.defaultOptions = {
-    autoSplit: true, // Auto-update on text/style changes
-    lineAnchor: 0, // Top-left alignment
-    wordAnchor: 0, // Top-left alignment
-    charAnchor: 0, // Top-left alignment
-};

package/dist/packages/pixijs/src/scene/text-split/__tests__/SegmentedText.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=SegmentedText.test.d.ts.map

package/dist/packages/pixijs/src/scene/text-split/__tests__/SegmentedText.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SegmentedText.test.d.ts","sourceRoot":"","sources":["../../../../../../../packages/pixijs/src/scene/text-split/__tests__/SegmentedText.test.ts"],"names":[],"mappings":""}

package/dist/packages/pixijs/src/scene/text-split/__tests__/SegmentedText.test.js

@@ -1,179 +0,0 @@
-import { Text } from '../../text/Text';
-import { TextStyle } from '../../text/TextStyle';
-import { BitmapText } from '../../text-bitmap/BitmapText';
-import { SplitBitmapText } from '../SplitBitmapText';
-import { SplitText } from '../SplitText';
-describe('SegmentedText', () => {
-    describe('constructor', () => {
-        it('should create instance with default options', () => {
-            const text = new SplitText({
-                text: 'Hello',
-                style: { fontSize: 24 },
-            });
-            expect(text.text).toBe('Hello');
-            expect(text.chars).toBeInstanceOf(Array);
-            expect(text.words).toBeInstanceOf(Array);
-            expect(text.lines).toBeInstanceOf(Array);
-            expect(text.style).toBeInstanceOf(TextStyle);
-        });
-        it('should respect custom options', () => {
-            const text = new SplitText({
-                text: 'Hello',
-                style: { fontSize: 24 },
-                autoSplit: false,
-                lineAnchor: 0.5,
-                wordAnchor: { x: 0, y: 1 },
-                charAnchor: { x: 0.5, y: 0.5 },
-            });
-            expect(text.lineAnchor).toEqual(0.5);
-            expect(text.wordAnchor).toEqual({ x: 0, y: 1 });
-            expect(text.charAnchor).toEqual({ x: 0.5, y: 0.5 });
-        });
-    });
-    describe('static from()', () => {
-        it('should create from Text instance', () => {
-            const sourceText = new Text({
-                text: 'Convert me',
-                style: { fontSize: 24 },
-            });
-            const segmented = SplitText.from(sourceText, {
-                lineAnchor: 0.5,
-            });
-            expect(segmented).toBeInstanceOf(SplitText);
-            expect(segmented.text).toBe('Convert me');
-            expect(segmented.lineAnchor).toEqual(0.5);
-        });
-        it('should create from BitmapText instance', () => {
-            const bitmapText = new BitmapText({
-                text: 'Bitmap',
-                style: { fontFamily: 'Arial' },
-            });
-            const segmented = SplitBitmapText.from(bitmapText);
-            expect(segmented).toBeInstanceOf(SplitBitmapText);
-            expect(segmented.text).toBe('Bitmap');
-        });
-    });
-    describe('segmentation', () => {
-        it('should segment text into chars, words, and lines', () => {
-            const text = new SplitText({
-                text: 'Hello World',
-                style: { fontSize: 24 },
-            });
-            expect(text.chars.length).toBeGreaterThan(0);
-            expect(text.words.length).toBe(2);
-            expect(text.lines.length).toBe(1);
-        });
-        it('should handle multi-line text', () => {
-            const text = new SplitText({
-                text: 'Hello\nWorld',
-                style: { fontSize: 24 },
-            });
-            expect(text.lines.length).toBe(2);
-        });
-        it('should respect text alignment', () => {
-            const text = new SplitBitmapText({
-                text: 'Right\nAligned',
-                style: {
-                    align: 'right',
-                },
-            });
-            const firstWord = text.words[0];
-            expect(firstWord.x).not.toBe(0); // Should be offset for right alignment
-            expect(text.lines.length).toBe(2);
-            expect(text.words.length).toBe(2);
-            expect(text.chars.length).toBe(12); // 'Right' + 'Aligned'
-        });
-        it('should respect autoSegment option', () => {
-            const text = new SplitText({
-                text: 'Hello',
-                style: { fontSize: 24 },
-                autoSplit: false,
-            });
-            expect(text.chars.length).toBe(0); // No segmentation done
-            text.split();
-            expect(text.chars.length).toBe(5); // Now segmented
-            text.text = 'Changed';
-            expect(text.chars.length).toBe(0); // Should not auto-segment
-            text.split();
-            expect(text.chars[0].text).toBe('C'); // Now updated
-        });
-    });
-    describe('transform origins', () => {
-        it('should set numeric origins', () => {
-            const text = new SplitText({
-                text: 'Test',
-                style: { fontSize: 24 },
-            });
-            text.lineAnchor = 0.5;
-            expect(text.lineAnchor).toEqual(0.5);
-            text.wordAnchor = 0.5;
-            expect(text.wordAnchor).toEqual(0.5);
-            text.charAnchor = 0.5;
-            expect(text.charAnchor).toEqual(0.5);
-        });
-        it('should set point origins', () => {
-            const text = new SplitText({
-                text: 'Test',
-                style: { fontSize: 24 },
-            });
-            const point = { x: 0.5, y: 1 };
-            text.lineAnchor = point;
-            expect(text.lineAnchor).toEqual(point);
-        });
-        it('should update origins after text changes', () => {
-            const text = new SplitText({
-                text: 'Test',
-                style: { fontSize: 24 },
-                charAnchor: 0.5,
-            });
-            const originalOrigin = text.chars[0].origin.x;
-            text.text = 'New';
-            expect(text.chars[0].origin.x).not.toBe(originalOrigin);
-        });
-    });
-    describe('style updates', () => {
-        it('should update style properties', () => {
-            const text = new SplitText({
-                text: 'Test',
-                style: { fontSize: 24 },
-            });
-            text.style = { fontSize: 48 };
-            expect(text.style.fontSize).toBe(48);
-        });
-        it('should trigger segmentation on style change', () => {
-            const text = new SplitText({
-                text: 'Test',
-                style: { fontSize: 24 },
-            });
-            const char = text.chars[0];
-            const originalBounds = char.getBounds();
-            text.style = { fontSize: 48 };
-            const newChar = text.chars[0];
-            const newBounds = newChar.getBounds();
-            expect(newBounds.height).toBeGreaterThan(originalBounds.height);
-        });
-    });
-    describe('destroy', () => {
-        it('should clean up resources', () => {
-            const text = new SplitText({
-                text: 'Test',
-                style: { fontSize: 24 },
-            });
-            text.destroy({ children: true, texture: true, style: true });
-            expect(text.chars).toEqual([]);
-            expect(text.words).toEqual([]);
-            expect(text.lines).toEqual([]);
-            expect(text.style).toBeNull();
-        });
-        it('should handle partial cleanup', () => {
-            const text = new SplitText({
-                text: 'Test',
-                style: { fontSize: 24 },
-            });
-            const style = text.style;
-            text.destroy({ children: true, style: false });
-            expect(text.chars).toEqual([]);
-            expect(style).not.toBeNull();
-        });
-    });
-});

package/dist/packages/pixijs/src/scene/text-split/types.d.ts

@@ -1,46 +0,0 @@
-import { type Container } from '../container/Container';
-import { type Text } from '../text/Text';
-import { type BitmapText } from '../text-bitmap/BitmapText';
-/**
- * Types of text objects that can be split into characters, words, and lines.
- * Currently supports Text and BitmapText instances.
- * @internal
- */
-export type SplitableTextObject = Text | BitmapText;
-/**
- * Contains the output elements from a text split operation.
- * Provides access to the hierarchical structure of split text elements.
- * @example
- * ```ts
- * const splitResult = Text.split(myText);
- *
- * // Access individual characters
- * splitResult.chars.forEach(char => {
- *     char.alpha = 0;
- *     gsap.to(char, { alpha: 1, duration: 0.5 });
- * });
- *
- * // Access words (groups of characters)
- * splitResult.words.forEach(word => {
- *     word.scale.set(0);
- *     gsap.to(word.scale, { x: 1, y: 1, duration: 0.5 });
- * });
- *
- * // Access lines (groups of words)
- * splitResult.lines.forEach(line => {
- *     line.x = -200;
- *     gsap.to(line, { x: 0, duration: 0.5 });
- * });
- * ```
- * @category text
- * @standard
- */
-export interface TextSplitOutput<T extends SplitableTextObject> {
-    /** Array of individual character Text objects */
-    chars: T[];
-    /** Array of word containers, each containing character objects */
-    words: Container[];
-    /** Array of line containers, each containing word containers */
-    lines: Container[];
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/packages/pixijs/src/scene/text-split/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../packages/pixijs/src/scene/text-split/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAE5D;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,IAAI,GAAG,UAAU,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,mBAAmB;IAE1D,iDAAiD;IACjD,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,kEAAkE;IAClE,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,gEAAgE;IAChE,KAAK,EAAE,SAAS,EAAE,CAAC;CACtB"}

package/dist/packages/pixijs/src/scene/text-split/types.js

@@ -1 +0,0 @@
-export {};

package/dist/packages/pixijs/src/scene/view/ViewContainer.d.ts

@@ -1,103 +0,0 @@
-import { type InstructionSet } from '../../rendering/renderers/shared/instructions/InstructionSet';
-import { type Renderer } from '../../rendering/renderers/types';
-import { Bounds } from '../container/bounds/Bounds';
-import { Container, type ContainerOptions } from '../container/Container';
-import { type RenderLayer } from '../layers/RenderLayer';
-import type { PointData } from '../../maths/point/PointData';
-import type { View } from '../../rendering/renderers/shared/view/View';
-import type { DestroyOptions } from '../container/destroyTypes';
-/** @internal */
-export interface GPUData {
-    destroy: () => void;
-}
-/**
- * Options for the construction of a ViewContainer.
- * @category scene
- * @advanced
- */
-export interface ViewContainerOptions extends ContainerOptions, PixiMixins.ViewContainerOptions {
-}
-export interface ViewContainer<GPU_DATA extends GPUData = any> extends PixiMixins.ViewContainer, Container {
-    _gpuData: Record<number, GPU_DATA>;
-}
-/**
- * A ViewContainer is a type of container that represents a view.
- * This view can be a Sprite, a Graphics object, or any other object that can be rendered.
- * This class is abstract and should not be used directly.
- * @category scene
- * @advanced
- */
-export declare abstract class ViewContainer<GPU_DATA extends GPUData = any> extends Container implements View {
-    /** @internal */
-    readonly renderPipeId: string;
-    /** @internal */
-    readonly canBundle = true;
-    /** @internal */
-    allowChildren: boolean;
-    /** @internal */
-    _roundPixels: 0 | 1;
-    /** @internal */
-    _lastUsed: number;
-    /** @internal */
-    _gpuData: Record<number, GPU_DATA>;
-    protected _bounds: Bounds;
-    protected _boundsDirty: boolean;
-    /**
-     * The local bounds of the view in its own coordinate space.
-     * Bounds are automatically updated when the view's content changes.
-     * @example
-     * ```ts
-     * // Get bounds dimensions
-     * const bounds = view.bounds;
-     * console.log(`Width: ${bounds.maxX - bounds.minX}`);
-     * console.log(`Height: ${bounds.maxY - bounds.minY}`);
-     * ```
-     * @returns The rectangular bounds of the view
-     * @see {@link Bounds} For bounds operations
-     */
-    get bounds(): Bounds;
-    /** @private */
-    protected abstract updateBounds(): void;
-    /**
-     * Whether or not to round the x/y position of the sprite.
-     * @example
-     * ```ts
-     * // Enable pixel rounding for crisp rendering
-     * view.roundPixels = true;
-     * ```
-     * @default false
-     */
-    get roundPixels(): boolean;
-    set roundPixels(value: boolean);
-    constructor(options: ViewContainerOptions);
-    /**
-     * Checks if the object contains the given point in local coordinates.
-     * Uses the view's bounds for hit testing.
-     * @example
-     * ```ts
-     * // Basic point check
-     * const localPoint = { x: 50, y: 25 };
-     * const contains = view.containsPoint(localPoint);
-     * console.log('Point is inside:', contains);
-     * ```
-     * @param point - The point to check in local coordinates
-     * @returns True if the point is within the view's bounds
-     * @see {@link ViewContainer#bounds} For the bounds used in hit testing
-     * @see {@link Container#toLocal} For converting global coordinates to local
-     */
-    containsPoint(point: PointData): boolean;
-    /** @private */
-    abstract batched: boolean;
-    /** @private */
-    protected onViewUpdate(): void;
-    destroy(options?: DestroyOptions): void;
-    /**
-     * Collects renderables for the view container.
-     * @param instructionSet - The instruction set to collect renderables for.
-     * @param renderer - The renderer to collect renderables for.
-     * @param currentLayer - The current render layer.
-     * @internal
-     */
-    collectRenderablesSimple(instructionSet: InstructionSet, renderer: Renderer, currentLayer: RenderLayer): void;
-}
-//# sourceMappingURL=ViewContainer.d.ts.map

package/dist/packages/pixijs/src/scene/view/ViewContainer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ViewContainer.d.ts","sourceRoot":"","sources":["../../../../../../packages/pixijs/src/scene/view/ViewContainer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,8DAA8D,CAAC;AAEnG,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAChE,OAAO,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1E,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,4CAA4C,CAAC;AACvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAEhE,gBAAgB;AAChB,MAAM,WAAW,OAAO;IAEpB,OAAO,EAAE,MAAM,IAAI,CAAC;CACvB;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAqB,SAAQ,gBAAgB,EAAE,UAAU,CAAC,oBAAoB;CAAG;AAElG,MAAM,WAAW,aAAa,CAAC,QAAQ,SAAS,OAAO,GAAG,GAAG,CAAE,SAAQ,UAAU,CAAC,aAAa,EAAE,SAAS;IAGtG,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;CACtC;AAED;;;;;;GAMG;AACH,8BAAsB,aAAa,CAAC,QAAQ,SAAS,OAAO,GAAG,GAAG,CAAE,SAAQ,SAAU,YAAW,IAAI;IAEjG,gBAAgB;IAChB,SAAyB,YAAY,EAAE,MAAM,CAAC;IAC9C,gBAAgB;IAChB,SAAgB,SAAS,QAAQ;IACjC,gBAAgB;IACA,aAAa,UAAS;IAEtC,gBAAgB;IACT,YAAY,EAAE,CAAC,GAAG,CAAC,CAAK;IAC/B,gBAAgB;IACT,SAAS,SAAM;IAEtB,gBAAgB;IACT,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAuB;IAEhE,SAAS,CAAC,OAAO,EAAE,MAAM,CAA0B;IACnD,SAAS,CAAC,YAAY,UAAQ;IAE9B;;;;;;;;;;;;OAYG;IACH,IAAW,MAAM,WAShB;IAED,eAAe;IACf,SAAS,CAAC,QAAQ,CAAC,YAAY,IAAI,IAAI;IAEvC;;;;;;;;OAQG;IACH,IAAI,WAAW,IAKQ,OAAO,CAF7B;IAED,IAAI,WAAW,CAAC,KAAK,EAAE,OAAO,EAG7B;gBAGW,OAAO,EAAE,oBAAoB;IAKzC;;;;;;;;;;;;;;OAcG;IACI,aAAa,CAAC,KAAK,EAAE,SAAS;IAWrC,eAAe;IACf,SAAgB,OAAO,EAAE,OAAO,CAAC;IAEjC,eAAe;IACf,SAAS,CAAC,YAAY;IAiBN,OAAO,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI;IAcvD;;;;;;OAMG;IACa,wBAAwB,CACpC,cAAc,EAAE,cAAc,EAC9B,QAAQ,EAAE,QAAQ,EAClB,YAAY,EAAE,WAAW,GAC1B,IAAI;CAqBV"}