@drincs/pixi-vn 0.9.1 → 0.9.5

package/README.md

@@ -1,4 +1,4 @@
-# Pixi'VN - PixiJS Visual Novel Engine
+# Pixi’VN - PixiJS Visual Novel Engine
 
 ![pixi-vn-cover](https://github.com/user-attachments/assets/28c41fe1-c539-4ebb-b7d4-8cb9f79e089e)
 

package/dist/ContainerChild-CEuXVx00.d.cts

@@ -0,0 +1,275 @@
+import { ContainerOptions, PointData, SpriteOptions, TextOptions, Container, Sprite as Sprite$1, Texture, ContainerEvents, ContainerChild as ContainerChild$1, EventEmitter, TextureSourceLike, TextureSource, ObservablePoint } from 'pixi.js';
+import TextureMemory from './interface/canvas/TextureMemory.cjs';
+import AdditionalPositionsExtension, { AdditionalPositionsExtensionProps } from './classes/canvas/AdditionalPositions.cjs';
+import { AnchorExtensionProps } from './classes/canvas/AnchorExtension.cjs';
+import CanvasEventNamesType from './types/CanvasEventNamesType.cjs';
+import CanvasEvent from './classes/CanvasEvent.cjs';
+import { EventIdType } from './types/EventIdType.cjs';
+
+/**
+ * Interface for the canvas base memory
+ */
+interface CanvasBaseItemMemory {
+    pixivnId: string;
+}
+/**
+ * Interface for the canvas container memory
+ */
+interface ContainerMemory<C extends ContainerChild = ContainerChild> extends ContainerOptions<C>, CanvasBaseItemMemory {
+    elements: CanvasBaseItemMemory[];
+}
+/**
+ * Interface for the canvas container memory
+ */
+interface ImageContainerMemory extends ContainerMemory<ImageSprite> {
+    elements: ImageSpriteMemory[];
+    anchor?: PointData;
+    align?: Partial<PointData>;
+    percentagePosition?: Partial<PointData>;
+    loadIsStarted: boolean;
+}
+interface SpriteBaseMemory extends SpriteOptions, CanvasBaseItemMemory {
+    /**
+     * @deprecated
+     */
+    textureImage?: TextureMemory;
+    textureData: TextureMemory;
+    onEvents: {
+        [name: CanvasEventNamesType]: EventIdType;
+    };
+}
+/**
+ * Interface for the canvas sprite memory
+ */
+interface SpriteMemory extends SpriteBaseMemory {
+}
+/**
+ * Interface for the canvas text memory
+ */
+interface TextMemory extends TextOptions, CanvasBaseItemMemory {
+    onEvents: {
+        [name: CanvasEventNamesType]: EventIdType;
+    };
+}
+/**
+ * The memory of the image. It uses for save the state of the image.
+ */
+interface ImageSpriteMemory extends SpriteBaseMemory {
+    /**
+     * @deprecated use SpriteBaseMemory.textureAlias
+     */
+    imageLink?: string;
+    align?: Partial<PointData>;
+    percentagePosition?: Partial<PointData>;
+    loadIsStarted: boolean;
+}
+/**
+ * The memory of the video. It uses for save the state of the video.
+ */
+interface VideoSpriteMemory extends ImageSpriteMemory {
+    loop: boolean;
+    paused: boolean;
+    currentTime: number;
+}
+
+interface ImageContainerOptions<C extends ContainerChild = ContainerChild> extends ContainerOptions<C>, AnchorExtensionProps, AdditionalPositionsExtensionProps {
+}
+interface ImageSpriteOptions extends SpriteOptions, AdditionalPositionsExtensionProps {
+}
+
+/**
+ * This class is used to create a canvas element to add into a Pixi Application.
+ * You can use {@link canvas.add()} to add this element into the application.
+ * This class should be implemented and the memory method should be overridden.
+ * You must use the {@link canvasElementDecorator} to register the canvas in the game.
+ * In Ren'Py is a displayable.
+ * @example
+ * ```typescript
+ * \@canvasElementDecorator() // this is equivalent to canvasElementDecorator("CanvasExample")
+ * export class CanvasExample extends Container implements CanvasBaseItem<ICanvasExampleMemory> {
+ *     get memory(): ICanvasExampleMemory {
+ *         return {
+ *             pixivnId: "CanvasExample",
+ *             // ... other properties
+ *         }
+ *     }
+ *     set memory(value: ICanvasExampleMemory) {
+ *         // ... set other properties
+ *     }
+ * }
+ * ```
+ */
+declare class CanvasBaseItem<T2 extends CanvasBaseItemMemory> extends Container {
+    /**
+     * This method return the memory of the canvas element.
+     */
+    get memory(): T2;
+    /**
+     * This method set the memory of the canvas element.
+     */
+    set memory(_value: T2);
+    /**
+     * This method set the memory of the canvas element. Is equivalent to the {@link CanvasBaseItem.memory} method, but this method is async.
+     */
+    setMemory(_value: T2): Promise<void> | void;
+    /**
+     * Get the id of the canvas element. This variable is used in the system to get the canvas element by id, {@link getCanvasElementInstanceById}
+     */
+    pixivnId: string;
+}
+
+/**
+ * This class is a extension of the [PIXI.Sprite class](https://pixijs.com/8.x/examples/sprite/basic), it has the same properties and methods,
+ * but it has the ability to be saved and loaded by the Pixi’VN library.
+ * @example
+ * ```typescript
+ * const texture = await Assets.load('https://pixijs.com/assets/bunny.png');
+ * const sprite = Sprite.from(texture);
+ *
+ * sprite.anchor.set(0.5);
+ * sprite.x = canvas.screen.width / 2;
+ * sprite.y = canvas.screen.height / 2;
+ *
+ * sprite.eventMode = 'static';
+ * sprite.cursor = 'pointer';
+ * sprite.onEvent('pointerdown', EventTest);
+ *
+ * canvas.add("bunny", sprite);
+ * ```
+ */
+declare class Sprite<Memory extends SpriteOptions & CanvasBaseItemMemory = SpriteMemory> extends Sprite$1 implements CanvasBaseItem<Memory | SpriteMemory> {
+    constructor(options?: SpriteOptions | Texture);
+    pixivnId: string;
+    private _textureAlias?;
+    get textureAlias(): string;
+    set textureAlias(value: string);
+    get memory(): Memory | SpriteMemory;
+    set memory(value: SpriteMemory);
+    setMemory(value: Memory | SpriteMemory): Promise<void>;
+    private _onEvents;
+    get onEvents(): {
+        [name: string]: string;
+        [name: symbol]: string;
+    };
+    /**
+     * is same function as on(), but it keeps in memory the children.
+     * @param event The event type, e.g., 'click', 'mousedown', 'mouseup', 'pointerdown', etc.
+     * @param eventClass The class that extends CanvasEvent.
+     * @returns
+     * @example
+     * ```typescript
+     * \@eventDecorator()
+     * export class EventTest extends CanvasEvent<Sprite> {
+     *     override fn(event: CanvasEventNamesType, sprite: Sprite): void {
+     *         if (event === 'pointerdown') {
+     *             sprite.scale.x *= 1.25;
+     *             sprite.scale.y *= 1.25;
+     *         }
+     *     }
+     * }
+     * ```
+     *
+     * ```typescript
+     * let sprite = addImage("alien", 'https://pixijs.com/assets/eggHead.png')
+     * await sprite.load()
+     *
+     * sprite.eventMode = 'static';
+     * sprite.cursor = 'pointer';
+     * sprite.onEvent('pointerdown', EventTest);
+     *
+     * canvas.add("bunny", sprite);
+     * ```
+     */
+    onEvent<T extends CanvasEventNamesType, T2 extends typeof CanvasEvent<typeof this>>(event: T, eventClass: T2): this;
+    /**
+     * on() does not keep in memory the event class, use onEvent() instead
+     * @deprecated
+     * @private
+     * @param event
+     * @param fn
+     * @param context
+     */
+    on<T extends keyof ContainerEvents<ContainerChild$1> | keyof {
+        [K: symbol]: any;
+        [K: {} & string]: any;
+    }>(event: T, fn: (...args: EventEmitter.ArgumentMap<ContainerEvents<ContainerChild$1> & {
+        [K: symbol]: any;
+        [K: {} & string]: any;
+    }>[Extract<T, keyof ContainerEvents<ContainerChild$1> | keyof {
+        [K: symbol]: any;
+        [K: {} & string]: any;
+    }>]) => void, context?: any): this;
+    static from(source: Texture | TextureSourceLike, skipCache?: boolean): Sprite<any>;
+}
+declare function getMemorySprite<T extends Sprite<any>>(element: T | Sprite<any>): SpriteMemory;
+declare function setMemorySprite<Memory extends SpriteBaseMemory>(element: Sprite<any>, memory: Memory | {}, options?: {
+    half?: () => Promise<void>;
+}): Promise<void>;
+
+/**
+ * This class is a extension of the {@link Sprite} class, it has the same properties and methods,
+ * but it has some features that make texture management easier.
+ * You need to use {@link ImageSprite.load()} to show the image in the canvas.
+ * This class is used for functions like {@link addImage}, {@link loadImage} and {@link showWithDissolveTransition}.
+ * @example
+ * ```typescript
+ * let alien = new ImageSprite({
+ *     anchor: { x: 0.5, y: 0.5 },
+ *     x: 100,
+ *     y: 100,
+ * }, 'https://pixijs.com/assets/eggHead.png')
+ * await alien.load()
+ * canvas.add("alien", alien)
+ * ```
+ * @example
+ * ```typescript
+ * let alien = addImage("alien", 'https://pixijs.com/assets/eggHead.png')
+ * alien.anchor.set(0.5);
+ * alien.x = 100
+ * alien.y = 100
+ * await alien.load()
+ * ```
+ */
+declare class ImageSprite<Memory extends ImageSpriteMemory = ImageSpriteMemory> extends Sprite<Memory> implements AdditionalPositionsExtension {
+    pixivnId: string;
+    constructor(options?: ImageSpriteOptions | Texture | undefined, textureAlias?: string);
+    get memory(): ImageSpriteMemory;
+    set memory(value: ImageSpriteMemory);
+    setMemory(value: ImageSpriteMemory): Promise<void>;
+    static from(source: Texture | TextureSourceLike, skipCache?: boolean): ImageSprite<ImageSpriteMemory>;
+    private _loadIsStarted;
+    get loadIsStarted(): boolean;
+    /**
+     * Load the image from the link and set the texture of the sprite.
+     * @returns A promise that resolves when the image is loaded.
+     */
+    load(): Promise<void>;
+    set texture(value: Texture<TextureSource<any>>);
+    get texture(): Texture<TextureSource<any>>;
+    /**
+     * Check if the texture is empty.
+     * @returns A boolean that is true if the texture is empty.
+     */
+    get haveEmptyTexture(): boolean;
+    /** AdditionalPositions */
+    private _align;
+    set align(value: Partial<PointData> | number);
+    set xAlign(value: number);
+    set yAlign(value: number);
+    private _percentagePosition;
+    set percentagePosition(value: Partial<PointData> | number);
+    set xPercentagePosition(_value: number);
+    set yPercentagePosition(_value: number);
+    private reloadPosition;
+    get position(): ObservablePoint;
+    set position(value: ObservablePoint);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+}
+declare function setMemoryImageSprite(element: ImageSprite, memory: ImageSpriteMemory | {}): Promise<void>;
+
+type ContainerChild = Container & CanvasBaseItem<any>;
+
+export { CanvasBaseItem as C, ImageSprite as I, Sprite as S, type TextMemory as T, type VideoSpriteMemory as V, type CanvasBaseItemMemory as a, type ContainerMemory as b, type ImageSpriteMemory as c, type SpriteBaseMemory as d, type SpriteMemory as e, type ImageContainerMemory as f, type ImageContainerOptions as g, type ImageSpriteOptions as h, type ContainerChild as i, getMemorySprite as j, setMemoryImageSprite as k, setMemorySprite as s };

package/dist/ContainerChild-HBivknFV.d.ts

@@ -0,0 +1,275 @@
+import { ContainerOptions, PointData, SpriteOptions, TextOptions, Container, Sprite as Sprite$1, Texture, ContainerEvents, ContainerChild as ContainerChild$1, EventEmitter, TextureSourceLike, TextureSource, ObservablePoint } from 'pixi.js';
+import TextureMemory from './interface/canvas/TextureMemory.js';
+import AdditionalPositionsExtension, { AdditionalPositionsExtensionProps } from './classes/canvas/AdditionalPositions.js';
+import { AnchorExtensionProps } from './classes/canvas/AnchorExtension.js';
+import CanvasEventNamesType from './types/CanvasEventNamesType.js';
+import CanvasEvent from './classes/CanvasEvent.js';
+import { EventIdType } from './types/EventIdType.js';
+
+/**
+ * Interface for the canvas base memory
+ */
+interface CanvasBaseItemMemory {
+    pixivnId: string;
+}
+/**
+ * Interface for the canvas container memory
+ */
+interface ContainerMemory<C extends ContainerChild = ContainerChild> extends ContainerOptions<C>, CanvasBaseItemMemory {
+    elements: CanvasBaseItemMemory[];
+}
+/**
+ * Interface for the canvas container memory
+ */
+interface ImageContainerMemory extends ContainerMemory<ImageSprite> {
+    elements: ImageSpriteMemory[];
+    anchor?: PointData;
+    align?: Partial<PointData>;
+    percentagePosition?: Partial<PointData>;
+    loadIsStarted: boolean;
+}
+interface SpriteBaseMemory extends SpriteOptions, CanvasBaseItemMemory {
+    /**
+     * @deprecated
+     */
+    textureImage?: TextureMemory;
+    textureData: TextureMemory;
+    onEvents: {
+        [name: CanvasEventNamesType]: EventIdType;
+    };
+}
+/**
+ * Interface for the canvas sprite memory
+ */
+interface SpriteMemory extends SpriteBaseMemory {
+}
+/**
+ * Interface for the canvas text memory
+ */
+interface TextMemory extends TextOptions, CanvasBaseItemMemory {
+    onEvents: {
+        [name: CanvasEventNamesType]: EventIdType;
+    };
+}
+/**
+ * The memory of the image. It uses for save the state of the image.
+ */
+interface ImageSpriteMemory extends SpriteBaseMemory {
+    /**
+     * @deprecated use SpriteBaseMemory.textureAlias
+     */
+    imageLink?: string;
+    align?: Partial<PointData>;
+    percentagePosition?: Partial<PointData>;
+    loadIsStarted: boolean;
+}
+/**
+ * The memory of the video. It uses for save the state of the video.
+ */
+interface VideoSpriteMemory extends ImageSpriteMemory {
+    loop: boolean;
+    paused: boolean;
+    currentTime: number;
+}
+
+interface ImageContainerOptions<C extends ContainerChild = ContainerChild> extends ContainerOptions<C>, AnchorExtensionProps, AdditionalPositionsExtensionProps {
+}
+interface ImageSpriteOptions extends SpriteOptions, AdditionalPositionsExtensionProps {
+}
+
+/**
+ * This class is used to create a canvas element to add into a Pixi Application.
+ * You can use {@link canvas.add()} to add this element into the application.
+ * This class should be implemented and the memory method should be overridden.
+ * You must use the {@link canvasElementDecorator} to register the canvas in the game.
+ * In Ren'Py is a displayable.
+ * @example
+ * ```typescript
+ * \@canvasElementDecorator() // this is equivalent to canvasElementDecorator("CanvasExample")
+ * export class CanvasExample extends Container implements CanvasBaseItem<ICanvasExampleMemory> {
+ *     get memory(): ICanvasExampleMemory {
+ *         return {
+ *             pixivnId: "CanvasExample",
+ *             // ... other properties
+ *         }
+ *     }
+ *     set memory(value: ICanvasExampleMemory) {
+ *         // ... set other properties
+ *     }
+ * }
+ * ```
+ */
+declare class CanvasBaseItem<T2 extends CanvasBaseItemMemory> extends Container {
+    /**
+     * This method return the memory of the canvas element.
+     */
+    get memory(): T2;
+    /**
+     * This method set the memory of the canvas element.
+     */
+    set memory(_value: T2);
+    /**
+     * This method set the memory of the canvas element. Is equivalent to the {@link CanvasBaseItem.memory} method, but this method is async.
+     */
+    setMemory(_value: T2): Promise<void> | void;
+    /**
+     * Get the id of the canvas element. This variable is used in the system to get the canvas element by id, {@link getCanvasElementInstanceById}
+     */
+    pixivnId: string;
+}
+
+/**
+ * This class is a extension of the [PIXI.Sprite class](https://pixijs.com/8.x/examples/sprite/basic), it has the same properties and methods,
+ * but it has the ability to be saved and loaded by the Pixi’VN library.
+ * @example
+ * ```typescript
+ * const texture = await Assets.load('https://pixijs.com/assets/bunny.png');
+ * const sprite = Sprite.from(texture);
+ *
+ * sprite.anchor.set(0.5);
+ * sprite.x = canvas.screen.width / 2;
+ * sprite.y = canvas.screen.height / 2;
+ *
+ * sprite.eventMode = 'static';
+ * sprite.cursor = 'pointer';
+ * sprite.onEvent('pointerdown', EventTest);
+ *
+ * canvas.add("bunny", sprite);
+ * ```
+ */
+declare class Sprite<Memory extends SpriteOptions & CanvasBaseItemMemory = SpriteMemory> extends Sprite$1 implements CanvasBaseItem<Memory | SpriteMemory> {
+    constructor(options?: SpriteOptions | Texture);
+    pixivnId: string;
+    private _textureAlias?;
+    get textureAlias(): string;
+    set textureAlias(value: string);
+    get memory(): Memory | SpriteMemory;
+    set memory(value: SpriteMemory);
+    setMemory(value: Memory | SpriteMemory): Promise<void>;
+    private _onEvents;
+    get onEvents(): {
+        [name: string]: string;
+        [name: symbol]: string;
+    };
+    /**
+     * is same function as on(), but it keeps in memory the children.
+     * @param event The event type, e.g., 'click', 'mousedown', 'mouseup', 'pointerdown', etc.
+     * @param eventClass The class that extends CanvasEvent.
+     * @returns
+     * @example
+     * ```typescript
+     * \@eventDecorator()
+     * export class EventTest extends CanvasEvent<Sprite> {
+     *     override fn(event: CanvasEventNamesType, sprite: Sprite): void {
+     *         if (event === 'pointerdown') {
+     *             sprite.scale.x *= 1.25;
+     *             sprite.scale.y *= 1.25;
+     *         }
+     *     }
+     * }
+     * ```
+     *
+     * ```typescript
+     * let sprite = addImage("alien", 'https://pixijs.com/assets/eggHead.png')
+     * await sprite.load()
+     *
+     * sprite.eventMode = 'static';
+     * sprite.cursor = 'pointer';
+     * sprite.onEvent('pointerdown', EventTest);
+     *
+     * canvas.add("bunny", sprite);
+     * ```
+     */
+    onEvent<T extends CanvasEventNamesType, T2 extends typeof CanvasEvent<typeof this>>(event: T, eventClass: T2): this;
+    /**
+     * on() does not keep in memory the event class, use onEvent() instead
+     * @deprecated
+     * @private
+     * @param event
+     * @param fn
+     * @param context
+     */
+    on<T extends keyof ContainerEvents<ContainerChild$1> | keyof {
+        [K: symbol]: any;
+        [K: {} & string]: any;
+    }>(event: T, fn: (...args: EventEmitter.ArgumentMap<ContainerEvents<ContainerChild$1> & {
+        [K: symbol]: any;
+        [K: {} & string]: any;
+    }>[Extract<T, keyof ContainerEvents<ContainerChild$1> | keyof {
+        [K: symbol]: any;
+        [K: {} & string]: any;
+    }>]) => void, context?: any): this;
+    static from(source: Texture | TextureSourceLike, skipCache?: boolean): Sprite<any>;
+}
+declare function getMemorySprite<T extends Sprite<any>>(element: T | Sprite<any>): SpriteMemory;
+declare function setMemorySprite<Memory extends SpriteBaseMemory>(element: Sprite<any>, memory: Memory | {}, options?: {
+    half?: () => Promise<void>;
+}): Promise<void>;
+
+/**
+ * This class is a extension of the {@link Sprite} class, it has the same properties and methods,
+ * but it has some features that make texture management easier.
+ * You need to use {@link ImageSprite.load()} to show the image in the canvas.
+ * This class is used for functions like {@link addImage}, {@link loadImage} and {@link showWithDissolveTransition}.
+ * @example
+ * ```typescript
+ * let alien = new ImageSprite({
+ *     anchor: { x: 0.5, y: 0.5 },
+ *     x: 100,
+ *     y: 100,
+ * }, 'https://pixijs.com/assets/eggHead.png')
+ * await alien.load()
+ * canvas.add("alien", alien)
+ * ```
+ * @example
+ * ```typescript
+ * let alien = addImage("alien", 'https://pixijs.com/assets/eggHead.png')
+ * alien.anchor.set(0.5);
+ * alien.x = 100
+ * alien.y = 100
+ * await alien.load()
+ * ```
+ */
+declare class ImageSprite<Memory extends ImageSpriteMemory = ImageSpriteMemory> extends Sprite<Memory> implements AdditionalPositionsExtension {
+    pixivnId: string;
+    constructor(options?: ImageSpriteOptions | Texture | undefined, textureAlias?: string);
+    get memory(): ImageSpriteMemory;
+    set memory(value: ImageSpriteMemory);
+    setMemory(value: ImageSpriteMemory): Promise<void>;
+    static from(source: Texture | TextureSourceLike, skipCache?: boolean): ImageSprite<ImageSpriteMemory>;
+    private _loadIsStarted;
+    get loadIsStarted(): boolean;
+    /**
+     * Load the image from the link and set the texture of the sprite.
+     * @returns A promise that resolves when the image is loaded.
+     */
+    load(): Promise<void>;
+    set texture(value: Texture<TextureSource<any>>);
+    get texture(): Texture<TextureSource<any>>;
+    /**
+     * Check if the texture is empty.
+     * @returns A boolean that is true if the texture is empty.
+     */
+    get haveEmptyTexture(): boolean;
+    /** AdditionalPositions */
+    private _align;
+    set align(value: Partial<PointData> | number);
+    set xAlign(value: number);
+    set yAlign(value: number);
+    private _percentagePosition;
+    set percentagePosition(value: Partial<PointData> | number);
+    set xPercentagePosition(_value: number);
+    set yPercentagePosition(_value: number);
+    private reloadPosition;
+    get position(): ObservablePoint;
+    set position(value: ObservablePoint);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+}
+declare function setMemoryImageSprite(element: ImageSprite, memory: ImageSpriteMemory | {}): Promise<void>;
+
+type ContainerChild = Container & CanvasBaseItem<any>;
+
+export { CanvasBaseItem as C, ImageSprite as I, Sprite as S, type TextMemory as T, type VideoSpriteMemory as V, type CanvasBaseItemMemory as a, type ContainerMemory as b, type ImageSpriteMemory as c, type SpriteBaseMemory as d, type SpriteMemory as e, type ImageContainerMemory as f, type ImageContainerOptions as g, type ImageSpriteOptions as h, type ContainerChild as i, getMemorySprite as j, setMemoryImageSprite as k, setMemorySprite as s };

package/dist/WebGLRenderer-U57ZOBH6.js

@@ -0,0 +1,9 @@
+import {
+  WebGLRenderer
+} from "./chunk-73ID6GAW.js";
+import "./chunk-5VX2VTDZ.js";
+import "./chunk-PP3SBC3C.js";
+import "./chunk-N342G4HO.js";
+export {
+  WebGLRenderer
+};

package/dist/WebGPURenderer-EYIZ7IXV.js

@@ -0,0 +1,10 @@
+import {
+  WebGPURenderer
+} from "./chunk-ODIEVSQX.js";
+import "./chunk-5JREOVCG.js";
+import "./chunk-5VX2VTDZ.js";
+import "./chunk-PP3SBC3C.js";
+import "./chunk-N342G4HO.js";
+export {
+  WebGPURenderer
+};

package/dist/{browserAll-33PYKKE2.js → browserAll-2HD5EH7K.js}

@@ -1,16 +1,16 @@
-import "./chunk-KZYJO7H5.js";
+import "./chunk-Y3WNBACN.js";
 import {
   AccessibilitySystem,
   EventSystem,
   FederatedContainer,
   accessibilityTarget
-} from "./chunk-XVXD2VT7.js";
-import "./chunk-JNSNLO3T.js";
-import "./chunk-7JQTY54X.js";
+} from "./chunk-SAUNZQHZ.js";
+import "./chunk-CAWOWL3P.js";
+import "./chunk-5JREOVCG.js";
 import {
   Container,
   extensions
-} from "./chunk-Y3QDHFJM.js";
+} from "./chunk-PP3SBC3C.js";
 import "./chunk-N342G4HO.js";
 
 // node_modules/pixi.js/lib/accessibility/init.mjs

package/dist/{chunk-7JQTY54X.js → chunk-5JREOVCG.js}

@@ -4,7 +4,7 @@ import {
   Texture,
   getMaxTexturesPerBatch,
   nextPow2
-} from "./chunk-Y3QDHFJM.js";
+} from "./chunk-PP3SBC3C.js";
 
 // node_modules/pixi.js/lib/rendering/batcher/gpu/getTextureBatchBindGroup.mjs
 var cachedGroups = {};

package/dist/{chunk-LAV52DFC.js → chunk-5VX2VTDZ.js}

@@ -42,7 +42,7 @@ import {
   uid,
   v8_0_0,
   warn
-} from "./chunk-Y3QDHFJM.js";
+} from "./chunk-PP3SBC3C.js";
 
 // node_modules/pixi.js/lib/filters/Filter.mjs
 var _Filter = class _Filter2 extends Shader {
@@ -146,7 +146,7 @@ function unsafeEvalSupported() {
   try {
     const func = new Function("param1", "param2", "param3", "return param1[param2] === param3;");
     unsafeEval = func({ a: "b" }, "a", "b") === true;
-  } catch (e) {
+  } catch (_e) {
     unsafeEval = false;
   }
   return unsafeEval;
@@ -174,12 +174,12 @@ var SystemRunner = class {
     this.items = [];
     this._name = name;
   }
-  /* eslint-disable jsdoc/require-param, jsdoc/check-param-names */
+  /* jsdoc/check-param-names */
   /**
    * Dispatch/Broadcast Runner to all listeners added to the queue.
    * @param {...any} params - (optional) parameters to pass to each listener
    */
-  /*  eslint-enable jsdoc/require-param, jsdoc/check-param-names */
+  /* jsdoc/check-param-names */
   emit(a0, a1, a2, a3, a4, a5, a6, a7) {
     const { name, items } = this;
     for (let i = 0, len = items.length; i < len; i++) {
@@ -1152,7 +1152,7 @@ SpritePipe.extension = {
 
 // node_modules/pixi.js/lib/utils/const.mjs
 var DATA_URI = /^\s*data:(?:([\w-]+)\/([\w+.-]+))?(?:;charset=([\w-]+))?(?:;(base64))?,(.*)/i;
-var VERSION = "8.6.3";
+var VERSION = "8.6.4";
 
 // node_modules/pixi.js/lib/utils/global/globalHooks.mjs
 var ApplicationInitHook = class {

package/dist/{chunk-63AQP2C4.js → chunk-6GJXIPNB.js}

@@ -1,6 +1,6 @@
 import {
   Container
-} from "./chunk-Y3QDHFJM.js";
+} from "./chunk-PP3SBC3C.js";
 
 // src/classes/canvas/CanvasBaseItem.ts
 var CanvasBaseItem = class extends Container {
@@ -16,6 +16,12 @@ var CanvasBaseItem = class extends Container {
   set memory(_value) {
     throw new Error("[Pixi\u2019VN] The method CanvasBaseItems.memory must be overridden");
   }
+  /**
+   * This method set the memory of the canvas element. Is equivalent to the {@link CanvasBaseItem.memory} method, but this method is async.
+   */
+  setMemory(_value) {
+    throw new Error("[Pixi\u2019VN] The method CanvasBaseItems.memory must be overridden");
+  }
   /**
    * Get the id of the canvas element. This variable is used in the system to get the canvas element by id, {@link getCanvasElementInstanceById}
    */