@drincs/pixi-vn 0.6.1 → 0.6.2

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { Container, Sprite, Text, Assets, Texture, Application } from 'pixi.js';
+import { Container, Sprite, Text, Assets, Texture, Application, Rectangle } from 'pixi.js';
 export { Assets } from 'pixi.js';
 import { diff } from 'deep-diff';
 import sha1 from 'crypto-js/sha1';
@@ -54,6 +54,13 @@ var __async = (__this, __arguments, generator) => {
 
 // src/classes/CanvasEvent.ts
 var CanvasEvent = class {
+  constructor() {
+    /**
+     * Get the id of the event. This variable is used in the system to get the event by id, {@link getEventInstanceById}
+     */
+    this.id = "event_id_not_set";
+    this.id = this.constructor.prototype.id;
+  }
   fn(_event, _element) {
     throw new Error("[Pixi'VN] The method CanvasEvent.fn() must be overridden");
   }
@@ -81,7 +88,7 @@ var Label = class {
     this._choiseIndex = choiseIndex;
   }
   /**
-   * Get the id of the label
+   * Get the id of the label. This variable is used in the system to get the label by id, {@link getLabelById}
    */
   get id() {
     return this._id;
@@ -158,6 +165,13 @@ function getLabelById(id) {
   return label;
 }
 var CanvasBase = class extends Container {
+  constructor() {
+    super(...arguments);
+    /**
+     * Get the id of the canvas element. This variable is used in the system to get the canvas element by id, {@link getCanvasElementInstanceById}
+     */
+    this.pixivnId = "canvas_element_id_not_set";
+  }
   /**
    * This method return the memory of the canvas element.
    */
@@ -184,17 +198,23 @@ function exportCanvasElement(element) {
   return element.memory;
 }
 function importCanvasElement(memory) {
-  let element = getCanvasElementInstanceByClassName(memory.className);
+  let element = getCanvasElementInstanceById(memory.pixivnId);
   if (element) {
     element.memory = memory;
   } else {
-    throw new Error("[Pixi'VN] The element " + memory.className + " could not be created");
+    throw new Error("[Pixi'VN] The element " + memory.pixivnId + " could not be created");
   }
   return element;
 }
 
 // src/classes/canvas/CanvasContainer.ts
+var CANVAS_CONTAINER_ID = "CanvasContainer";
 var CanvasContainer = class extends Container {
+  constructor(options) {
+    super(options);
+    this.pixivnId = CANVAS_CONTAINER_ID;
+    this.pixivnId = this.constructor.prototype.pixivnId;
+  }
   get memory() {
     let memory = getMemoryContainer(this);
     this.children.forEach((child) => {
@@ -210,8 +230,12 @@ var CanvasContainer = class extends Container {
   }
 };
 function getMemoryContainer(element) {
+  let className = "CanvasContainer";
+  if (element.hasOwnProperty("pixivnId")) {
+    className = element.pixivnId;
+  }
   return {
-    className: "CanvasContainer",
+    pixivnId: className,
     elements: [],
     width: element.width,
     height: element.height,
@@ -335,43 +359,47 @@ function eventDecorator(name) {
     if (registeredEvents[name]) {
       console.info(`[Pixi'VN] Event ${name} already exists, it will be overwritten`);
     }
+    target.prototype.id = name;
     registeredEvents[name] = target;
   };
 }
-function getEventTypeByClassName(eventName) {
+function getEventTypeById(eventId) {
   try {
-    let eventType = registeredEvents[eventName];
+    let eventType = registeredEvents[eventId];
     if (!eventType) {
-      console.error(`[Pixi'VN] Event ${eventName} not found`);
+      console.error(`[Pixi'VN] Event ${eventId} not found`);
       return;
     }
     new eventType();
     return eventType;
   } catch (e) {
-    console.error(`[Pixi'VN] Error while getting Event ${eventName}`, e);
+    console.error(`[Pixi'VN] Error while getting Event ${eventId}`, e);
     return;
   }
 }
-function getEventInstanceByClassName(eventName) {
+function getEventInstanceById(eventId) {
   try {
-    let eventType = registeredEvents[eventName];
+    let eventType = registeredEvents[eventId];
     if (!eventType) {
-      console.error(`[Pixi'VN] Event ${eventName} not found`);
+      console.error(`[Pixi'VN] Event ${eventId} not found`);
       return;
     }
     let event = new eventType();
     return event;
   } catch (e) {
-    console.error(`[Pixi'VN] Error while getting Event ${eventName}`, e);
+    console.error(`[Pixi'VN] Error while getting Event ${eventId}`, e);
     return;
   }
 }
 
 // src/classes/canvas/CanvasSprite.ts
+var CANVAS_SPRITE_ID = "CanvasSprite";
 var CanvasSprite = class _CanvasSprite extends Sprite {
-  constructor() {
-    super(...arguments);
+  constructor(options) {
+    super(options);
+    this.pixivnId = CANVAS_SPRITE_ID;
     this._onEvents = {};
+    this.pixivnId = this.constructor.prototype.pixivnId;
   }
   get memory() {
     return getMemorySprite(this);
@@ -412,9 +440,9 @@ var CanvasSprite = class _CanvasSprite extends Sprite {
    * ```
    */
   onEvent(event, eventClass) {
-    let className = eventClass.name;
-    let instance = getEventInstanceByClassName(className);
-    this._onEvents[event] = className;
+    let id = eventClass.prototype.id;
+    let instance = getEventInstanceById(id);
+    this._onEvents[event] = id;
     if (instance) {
       super.on(event, () => {
         instance.fn(event, this);
@@ -443,7 +471,7 @@ var CanvasSprite = class _CanvasSprite extends Sprite {
 function getMemorySprite(element) {
   let temp = getMemoryContainer(element);
   return __spreadProps(__spreadValues({}, temp), {
-    className: "CanvasSprite",
+    pixivnId: element.pixivnId,
     textureImage: getTextureMemory(element.texture),
     anchor: { x: element.anchor.x, y: element.anchor.y },
     roundPixels: element.roundPixels,
@@ -466,8 +494,8 @@ function setMemorySprite(element, memory) {
   }
   memory.roundPixels && (element.roundPixels = memory.roundPixels);
   for (let event in memory.onEvents) {
-    let className = memory.onEvents[event];
-    let instance = getEventTypeByClassName(className);
+    let id = memory.onEvents[event];
+    let instance = getEventTypeById(id);
     if (instance) {
       element.onEvent(event, instance);
     }
@@ -475,9 +503,11 @@ function setMemorySprite(element, memory) {
 }
 
 // src/classes/canvas/CanvasImage.ts
+var CANVAS_IMAGE_ID = "CanvasImage";
 var CanvasImage = class _CanvasImage extends CanvasSprite {
   constructor(options, imageLink) {
     super(options);
+    this.pixivnId = CANVAS_IMAGE_ID;
     this.imageLink = "";
     if (imageLink) {
       this.imageLink = imageLink;
@@ -485,12 +515,13 @@ var CanvasImage = class _CanvasImage extends CanvasSprite {
   }
   get memory() {
     return __spreadProps(__spreadValues({}, getMemorySprite(this)), {
-      className: "CanvasImage",
-      textureImage: { image: this.imageLink }
+      pixivnId: this.pixivnId,
+      imageLink: this.imageLink
     });
   }
   set memory(memory) {
     setMemorySprite(this, memory);
+    this.imageLink = memory.imageLink;
   }
   static from(source, skipCache) {
     let sprite = Sprite.from(source, skipCache);
@@ -518,10 +549,13 @@ var CanvasImage = class _CanvasImage extends CanvasSprite {
     });
   }
 };
+var CANVAS_TEXT_ID = "CanvasText";
 var CanvasText = class extends Text {
-  constructor() {
-    super(...arguments);
+  constructor(options) {
+    super(options);
+    this.pixivnId = CANVAS_TEXT_ID;
     this._onEvents = {};
+    this.pixivnId = this.constructor.prototype.pixivnId;
   }
   get memory() {
     return getMemoryText(this);
@@ -562,9 +596,9 @@ var CanvasText = class extends Text {
    * ```
    */
   onEvent(event, eventClass) {
-    let className = eventClass.name;
-    let instance = getEventInstanceByClassName(className);
-    this._onEvents[event] = className;
+    let id = eventClass.prototype.id;
+    let instance = getEventInstanceById(id);
+    this._onEvents[event] = id;
     if (instance) {
       super.on(event, () => {
         instance.fn(event, this);
@@ -587,7 +621,7 @@ var CanvasText = class extends Text {
 function getMemoryText(element) {
   let temp = getMemoryContainer(element);
   return __spreadProps(__spreadValues({}, temp), {
-    className: "CanvasText",
+    pixivnId: element.pixivnId,
     anchor: { x: element.anchor.x, y: element.anchor.y },
     text: element.text,
     resolution: element.resolution,
@@ -610,8 +644,8 @@ function setMemoryText(element, memory) {
   memory.style && (element.style = memory.style);
   memory.roundPixels && (element.roundPixels = memory.roundPixels);
   for (let event in memory.onEvents) {
-    let className = memory.onEvents[event];
-    let instance = getEventTypeByClassName(className);
+    let id = memory.onEvents[event];
+    let instance = getEventTypeById(id);
     if (instance) {
       element.onEvent(event, instance);
     }
@@ -628,31 +662,32 @@ function canvasElementDecorator(name) {
     if (registeredCanvasElement[name]) {
       console.warn(`[Pixi'VN] CanvasElement ${name} already registered`);
     }
+    target.prototype.pixivnId = name;
     registeredCanvasElement[name] = target;
   };
 }
-function getCanvasElementInstanceByClassName(canvasName) {
+function getCanvasElementInstanceById(canvasId) {
   try {
-    let eventType = registeredCanvasElement[canvasName];
+    let eventType = registeredCanvasElement[canvasId];
     if (!eventType) {
-      if (canvasName === "CanvasContainer") {
+      if (canvasId === CANVAS_CONTAINER_ID) {
         eventType = CanvasContainer;
-      } else if (canvasName === "CanvasImage") {
+      } else if (canvasId === CANVAS_IMAGE_ID) {
         eventType = CanvasImage;
-      } else if (canvasName === "CanvasSprite") {
+      } else if (canvasId === CANVAS_SPRITE_ID) {
         eventType = CanvasSprite;
-      } else if (canvasName === "CanvasText") {
+      } else if (canvasId === CANVAS_TEXT_ID) {
         eventType = CanvasText;
       }
     }
     if (!eventType) {
-      console.error(`[Pixi'VN] CanvasElement ${canvasName} not found`);
+      console.error(`[Pixi'VN] CanvasElement ${canvasId} not found`);
       return;
     }
     let canvasElement = new eventType();
     return canvasElement;
   } catch (e) {
-    console.error(`[Pixi'VN] Error while getting CanvasElement ${canvasName}`, e);
+    console.error(`[Pixi'VN] Error while getting CanvasElement ${canvasId}`, e);
     return;
   }
 }
@@ -696,19 +731,20 @@ function tickerDecorator(name) {
     if (registeredTickers[name]) {
       console.info(`[Pixi'VN] Ticker ${name} already exists, it will be overwritten`);
     }
+    target.prototype.id = name;
     registeredTickers[name] = target;
   };
 }
-function geTickerInstanceByClassName(tickerName, args, duration, priority) {
+function geTickerInstanceById(tickerId, args, duration, priority) {
   try {
-    let ticker = registeredTickers[tickerName];
+    let ticker = registeredTickers[tickerId];
     if (!ticker) {
-      console.error(`[Pixi'VN] Ticker ${tickerName} not found`);
+      console.error(`[Pixi'VN] Ticker ${tickerId} not found`);
       return;
     }
     return new ticker(args, duration, priority);
   } catch (e) {
-    console.error(`[Pixi'VN] Error while getting Ticker ${tickerName}`, e);
+    console.error(`[Pixi'VN] Error while getting Ticker ${tickerId}`, e);
     return;
   }
 }
@@ -771,21 +807,21 @@ var ChoiceMenuOptionClose = class {
 // src/functions/DialogueUtility.ts
 function setDialogue(props) {
   let text = "";
-  let characterId = void 0;
+  let character = void 0;
   let dialogue;
   if (typeof props === "string") {
     text = props;
-    dialogue = new DialogueBaseModel(text, characterId);
+    dialogue = new DialogueBaseModel(text, character);
   } else if (!(props instanceof DialogueBaseModel)) {
     text = props.text;
     if (props.character) {
       if (typeof props.character === "string") {
-        characterId = props.character;
+        character = props.character;
       } else {
-        characterId = props.character.id;
+        character = props.character.id;
       }
     }
-    dialogue = new DialogueBaseModel(text, characterId);
+    dialogue = new DialogueBaseModel(text, character);
   } else {
     dialogue = props;
   }
@@ -916,9 +952,14 @@ var TickerBase = class {
    * @param priority The priority of the ticker. @default UPDATE_PRIORITY.NORMAL
    */
   constructor(args, duration, priority) {
+    /**
+     * Get the id of the ticker. This variable is used in the system to get the ticker by id, {@link geTickerInstanceById}
+     */
+    this.id = "ticker_id_not_set";
     this.args = args;
     this.duration = duration;
     this.priority = priority;
+    this.id = this.constructor.prototype.id;
   }
   /**
    * The method that will be called every frame.
@@ -1141,8 +1182,8 @@ var ZoomTicker = class extends TickerBase {
       tagToRemoveAfter2 = [tagToRemoveAfter2];
     }
     let type = args.type || "zoom";
-    let xLimit = Infinity;
-    let yLimit = Infinity;
+    let xLimit = type === "zoom" ? Infinity : 0;
+    let yLimit = type === "zoom" ? Infinity : 0;
     if (args.limit) {
       if (typeof args.limit === "number") {
         xLimit = args.limit;
@@ -1181,7 +1222,7 @@ var ZoomTicker = class extends TickerBase {
           if (element.scale.x >= xLimit && element.scale.y >= yLimit) {
             element.scale.x = xLimit;
             element.scale.y = yLimit;
-            GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
+            this.onEndOfTicker(tag, tickerId, element, tagToRemoveAfter2);
           }
         } else if (type === "unzoom") {
           if (element.scale.x < xLimit) {
@@ -1193,24 +1234,39 @@ var ZoomTicker = class extends TickerBase {
           if (element.scale.x <= xLimit && element.scale.y <= yLimit) {
             element.scale.x = xLimit;
             element.scale.y = yLimit;
-            GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
+            this.onEndOfTicker(tag, tickerId, element, tagToRemoveAfter2);
           }
         }
         if (xSpeed < 1e-5 && ySpeed < 1e-5 && !(args.speedProgression && args.speedProgression.type == "linear" && args.speedProgression.amt != 0)) {
-          GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
+          this.onEndOfTicker(tag, tickerId, element, tagToRemoveAfter2);
         }
       }
     });
     if (args.speedProgression)
       updateTickerProgression(args, "speed", args.speedProgression);
   }
+  onEndOfTicker(tag, tickerId, _element, tagToRemoveAfter2) {
+    GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
+  }
 };
 ZoomTicker = __decorateClass([
   tickerDecorator()
 ], ZoomTicker);
+var ZoomInOutTicker = class extends ZoomTicker {
+  constructor(props, duration, priority) {
+    super(props, duration, priority);
+  }
+  onEndOfTicker(tag, tickerId, element, tagToRemoveAfter2) {
+    if (element.children.length > 0) {
+      let elementChild = element.children[0];
+      GameWindowManager.addCanvasElement(tag, elementChild);
+    }
+    super.onEndOfTicker(tag, tickerId, element, tagToRemoveAfter2);
+  }
+};
 
 // src/constants.ts
-var PIXIVN_VERSION = "0.6.1";
+var PIXIVN_VERSION = "0.6.2";
 var Repeat = "repeat";
 function Pause(duration) {
   return {
@@ -1333,6 +1389,147 @@ function showWithFadeTransition(_0, _1) {
 function removeWithFadeTransition(tag, props = {}, priority) {
   return removeWithDissolveTransition(tag, props, priority);
 }
+function moveIn(_0, _1) {
+  return __async(this, arguments, function* (tag, image, props = { direction: "right" }, priority) {
+    var _a;
+    let canvasElement;
+    if (typeof image === "string") {
+      canvasElement = addImage(tag, image);
+    } else {
+      canvasElement = image;
+      GameWindowManager.addCanvasElement(tag, canvasElement);
+    }
+    if (canvasElement instanceof CanvasImage && ((_a = canvasElement.texture) == null ? void 0 : _a.label) == "EMPTY") {
+      yield canvasElement.load();
+    }
+    let destination = { x: canvasElement.x, y: canvasElement.y };
+    if (props.direction == "up") {
+      canvasElement.y = GameWindowManager.canvasHeight + canvasElement.height;
+    } else if (props.direction == "down") {
+      canvasElement.y = -canvasElement.height;
+    } else if (props.direction == "left") {
+      canvasElement.x = GameWindowManager.canvasWidth + canvasElement.width;
+    } else if (props.direction == "right") {
+      canvasElement.x = -canvasElement.width;
+    }
+    let effect = new MoveTicker(__spreadProps(__spreadValues({}, props), {
+      destination,
+      startOnlyIfHaveTexture: true
+    }), priority);
+    GameWindowManager.addTicker(tag, effect);
+  });
+}
+function moveOut(tag, props = { direction: "right" }, priority) {
+  let canvasElement = GameWindowManager.getCanvasElement(tag);
+  if (!canvasElement) {
+    console.warn("[Pixi'VN] The canvas element is not found.");
+    return;
+  }
+  let destination = { x: canvasElement.x, y: canvasElement.y };
+  if (props.direction == "up") {
+    destination.y = -canvasElement.height;
+  } else if (props.direction == "down") {
+    destination.y = GameWindowManager.canvasHeight + canvasElement.height;
+  } else if (props.direction == "left") {
+    destination.x = -canvasElement.width;
+  } else if (props.direction == "right") {
+    destination.x = GameWindowManager.canvasWidth + canvasElement.width;
+  }
+  let effect = new MoveTicker(__spreadProps(__spreadValues({}, props), {
+    destination,
+    startOnlyIfHaveTexture: true,
+    tagToRemoveAfter: tag
+  }), priority);
+  GameWindowManager.addTicker(tag, effect);
+}
+function zoomIn(_0, _1) {
+  return __async(this, arguments, function* (tag, image, props = { direction: "right" }, priority) {
+    var _a;
+    let canvasElement;
+    if (typeof image === "string") {
+      canvasElement = new CanvasImage({}, image);
+    } else {
+      canvasElement = image;
+    }
+    if (canvasElement instanceof CanvasImage && ((_a = canvasElement.texture) == null ? void 0 : _a.label) == "EMPTY") {
+      yield canvasElement.load();
+    }
+    let container = new CanvasContainer();
+    container.addChild(canvasElement);
+    container.height = GameWindowManager.canvasHeight;
+    container.width = GameWindowManager.canvasWidth;
+    GameWindowManager.addCanvasElement(tag, container);
+    if (props.direction == "up") {
+      container.pivot.y = GameWindowManager.canvasHeight;
+      container.pivot.x = GameWindowManager.canvasWidth / 2;
+      container.y = GameWindowManager.canvasHeight;
+      container.x = GameWindowManager.canvasWidth / 2;
+    } else if (props.direction == "down") {
+      container.pivot.y = 0;
+      container.pivot.x = GameWindowManager.canvasWidth / 2;
+      container.y = 0;
+      container.x = GameWindowManager.canvasWidth / 2;
+    } else if (props.direction == "left") {
+      container.pivot.x = GameWindowManager.canvasWidth;
+      container.pivot.y = GameWindowManager.canvasHeight / 2;
+      container.x = GameWindowManager.canvasWidth;
+      container.y = GameWindowManager.canvasHeight / 2;
+    } else if (props.direction == "right") {
+      container.pivot.x = 0;
+      container.pivot.y = GameWindowManager.canvasHeight / 2;
+      container.x = 0;
+      container.y = GameWindowManager.canvasHeight / 2;
+    }
+    container.scale.set(0);
+    let effect = new ZoomInOutTicker(__spreadProps(__spreadValues({}, props), {
+      startOnlyIfHaveTexture: true,
+      type: "zoom",
+      limit: 1
+    }), priority);
+    GameWindowManager.addTicker(tag, effect);
+  });
+}
+function zoomOut(tag, props = { direction: "right" }, priority) {
+  let canvasElement = GameWindowManager.getCanvasElement(tag);
+  if (!canvasElement) {
+    console.warn("[Pixi'VN] The canvas element is not found.");
+    return;
+  }
+  let container = new CanvasContainer();
+  container.addChild(canvasElement);
+  container.height = GameWindowManager.canvasHeight;
+  container.width = GameWindowManager.canvasWidth;
+  GameWindowManager.addCanvasElement(tag, container);
+  if (props.direction == "up") {
+    container.pivot.y = GameWindowManager.canvasHeight;
+    container.pivot.x = GameWindowManager.canvasWidth / 2;
+    container.y = GameWindowManager.canvasHeight;
+    container.x = GameWindowManager.canvasWidth / 2;
+  } else if (props.direction == "down") {
+    container.pivot.y = 0;
+    container.pivot.x = GameWindowManager.canvasWidth / 2;
+    container.y = 0;
+    container.x = GameWindowManager.canvasWidth / 2;
+  } else if (props.direction == "left") {
+    container.pivot.x = GameWindowManager.canvasWidth;
+    container.pivot.y = GameWindowManager.canvasHeight / 2;
+    container.x = GameWindowManager.canvasWidth;
+    container.y = GameWindowManager.canvasHeight / 2;
+  } else if (props.direction == "right") {
+    container.pivot.x = 0;
+    container.pivot.y = GameWindowManager.canvasHeight / 2;
+    container.x = 0;
+    container.y = GameWindowManager.canvasHeight / 2;
+  }
+  container.scale.set(1);
+  let effect = new ZoomInOutTicker(__spreadProps(__spreadValues({}, props), {
+    startOnlyIfHaveTexture: true,
+    type: "unzoom",
+    limit: 0,
+    tagToRemoveAfter: tag
+  }), priority);
+  GameWindowManager.addTicker(tag, effect);
+}
 
 // src/functions/SavesUtility.ts
 function getSaveData() {
@@ -1822,18 +2019,18 @@ var _GameWindowManager = class _GameWindowManager {
    * ```
    */
   static addTicker(canvasElementTag, ticker) {
-    let tickerName = ticker.constructor.name;
+    let tickerId = ticker.id;
     if (typeof canvasElementTag === "string") {
       canvasElementTag = [canvasElementTag];
     }
-    if (!geTickerInstanceByClassName(tickerName, ticker.args, ticker.duration, ticker.priority)) {
-      console.error(`[Pixi'VN] Ticker ${tickerName} not found`);
+    if (!geTickerInstanceById(tickerId, ticker.args, ticker.duration, ticker.priority)) {
+      console.error(`[Pixi'VN] Ticker ${tickerId} not found`);
       return;
     }
     let tickerHistory = {
       fn: () => {
       },
-      className: tickerName,
+      id: tickerId,
       args: createExportableElement(ticker.args),
       canvasElementTags: canvasElementTag,
       priority: ticker.priority,
@@ -1849,11 +2046,11 @@ var _GameWindowManager = class _GameWindowManager {
           _GameWindowManager.removeTicker(id);
         }
       }, ticker.duration * 1e3);
-      _GameWindowManager.addTickerTimeoutInfo(canvasElementTag, tickerName, timeout.toString(), true);
+      _GameWindowManager.addTickerTimeoutInfo(canvasElementTag, tickerId, timeout.toString(), true);
     }
   }
   static pushTicker(id, tickerData, ticker) {
-    _GameWindowManager.removeAssociationBetweenTickerCanvasElement(tickerData.canvasElementTags, tickerData);
+    _GameWindowManager.removeAssociationBetweenTickerCanvasElement(tickerData.canvasElementTags, ticker);
     _GameWindowManager._currentTickers[id] = tickerData;
     tickerData.fn = (t) => {
       let data = _GameWindowManager._currentTickers[id];
@@ -1894,9 +2091,9 @@ var _GameWindowManager = class _GameWindowManager {
         if (step.hasOwnProperty("type") && step.type === "pause") {
           return step;
         }
-        let tickerName = step.constructor.name;
+        let tickerId = step.id;
         return {
-          ticker: tickerName,
+          ticker: tickerId,
           args: createExportableElement(step.args),
           duration: step.duration
         };
@@ -1934,16 +2131,16 @@ var _GameWindowManager = class _GameWindowManager {
       _GameWindowManager.addTickerTimeoutInfo(tag, "steps", timeout.toString(), false);
       return;
     }
-    let ticker = geTickerInstanceByClassName(step.ticker, step.args, step.duration, step.priority);
+    let ticker = geTickerInstanceById(step.ticker, step.args, step.duration, step.priority);
     if (!ticker) {
       console.error(`[Pixi'VN] Ticker ${step.ticker} not found`);
       return;
     }
-    let tickerName = ticker.constructor.name;
+    let tickerName = ticker.id;
     let tickerHistory = {
       fn: () => {
       },
-      className: tickerName,
+      id: tickerName,
       args: createExportableElement(ticker.args),
       canvasElementTags: [tag],
       priority: ticker.priority,
@@ -2000,26 +2197,26 @@ var _GameWindowManager = class _GameWindowManager {
    * ```
    */
   static removeAssociationBetweenTickerCanvasElement(tags, ticker) {
-    let tickerName;
+    let tickerId;
     if (typeof ticker === "string") {
-      tickerName = ticker;
+      tickerId = ticker;
     } else if (ticker instanceof TickerBase) {
-      tickerName = ticker.constructor.name;
+      tickerId = ticker.id;
     } else {
-      tickerName = ticker.name;
+      tickerId = ticker.prototype.id;
     }
     if (typeof tags === "string") {
       tags = [tags];
     }
     for (let id in _GameWindowManager._currentTickers) {
       let ticker2 = _GameWindowManager._currentTickers[id];
-      if (ticker2.className === tickerName) {
+      if (ticker2.id === tickerId) {
         _GameWindowManager._currentTickers[id].canvasElementTags = ticker2.canvasElementTags.filter((e) => !tags.includes(e));
       }
     }
     for (let timeout in _GameWindowManager._currentTickersTimeouts) {
       let TickerTimeout = _GameWindowManager._currentTickersTimeouts[timeout];
-      if (TickerTimeout.ticker === tickerName && TickerTimeout.canBeDeletedBeforeEnd) {
+      if (TickerTimeout.ticker === tickerId && TickerTimeout.canBeDeletedBeforeEnd) {
         _GameWindowManager._currentTickersTimeouts[timeout].tags = TickerTimeout.tags.filter((t) => !tags.includes(t));
       }
     }
@@ -2205,11 +2402,11 @@ var _GameWindowManager = class _GameWindowManager {
         for (let id in currentTickers) {
           let t = currentTickers[id];
           let tags = t.canvasElementTags;
-          let ticker = geTickerInstanceByClassName(t.className, t.args, t.duration, t.priority);
+          let ticker = geTickerInstanceById(t.id, t.args, t.duration, t.priority);
           if (ticker) {
             _GameWindowManager.addTicker(tags, ticker);
           } else {
-            console.error(`[Pixi'VN] Ticker ${t.className} not found`);
+            console.error(`[Pixi'VN] Ticker ${t.id} not found`);
           }
         }
       }
@@ -2410,6 +2607,13 @@ var _GameStepManager = class _GameStepManager {
     _GameStepManager._openedLabels = _GameStepManager.originalStepData.openedLabels;
   }
   /* Run Methods */
+  static get canGoNext() {
+    let options = getChoiceMenuOptions();
+    if (options && options.length > 0) {
+      return false;
+    }
+    return true;
+  }
   /**
    * Execute the next step and add it to the history.
    * @param props The props to pass to the step.
@@ -2419,7 +2623,7 @@ var _GameStepManager = class _GameStepManager {
    * ```typescript
    *     function nextOnClick() {
    *     setLoading(true)
-   *     GameStepManager.runNextStep(yourParams)
+   *     GameStepManager.goNext(yourParams)
    *         .then((result) => {
    *             setUpdate((p) => p + 1)
    *             setLoading(false)
@@ -2434,8 +2638,12 @@ var _GameStepManager = class _GameStepManager {
    * }
    * ```
    */
-  static runNextStep(props, choiseMade) {
+  static goNext(props, choiseMade) {
     return __async(this, null, function* () {
+      if (!_GameStepManager.canGoNext) {
+        console.warn("[Pixi'VN] The player must make a choice");
+        return;
+      }
       _GameStepManager.increaseCurrentStepIndex();
       return yield _GameStepManager.runCurrentStep(props, choiseMade);
     });
@@ -2466,7 +2674,7 @@ var _GameStepManager = class _GameStepManager {
           return result;
         } else if (_GameStepManager.openedLabels.length > 1) {
           _GameStepManager.closeCurrentLabel();
-          return yield _GameStepManager.runNextStep(props, choiseMade);
+          return yield _GameStepManager.goNext(props, choiseMade);
         } else {
           _GameStepManager.restorLastLabelList();
           console.error("[Pixi'VN] The end of the game is not managed, so the game is blocked. Read this documentation to know how to manage the end of the game: https://pixi-vn.web.app/start/labels.html#how-manage-the-end-of-the-game");
@@ -2614,7 +2822,7 @@ var _GameStepManager = class _GameStepManager {
       if (choice.closeCurrentLabel) {
         _GameStepManager.closeCurrentLabel();
       }
-      return _GameStepManager.runNextStep(props, choiseMade);
+      return _GameStepManager.goNext(props, choiseMade);
     });
   }
   /* After Update Methods */
@@ -2942,15 +3150,15 @@ var DialogueBaseModel = class {
     if (typeof text === "string") {
       this.text = text;
       if (typeof character === "string") {
-        this.characterId = character;
+        this.character = character;
       } else {
-        this.characterId = character == null ? void 0 : character.id;
+        this.character = character == null ? void 0 : character.id;
       }
       this.oltherParams = oltherParams;
     } else {
       this.text = text.text;
-      if (text.characterId) {
-        this.characterId = text.characterId;
+      if (text.character) {
+        this.character = text.character;
       }
       this.oltherParams = text.oltherParams || {};
     }
@@ -2963,7 +3171,7 @@ var DialogueBaseModel = class {
   export() {
     return {
       text: this.text,
-      characterId: this.characterId,
+      character: this.character,
       oltherParams: this.oltherParams
     };
   }
@@ -2985,81 +3193,214 @@ var helmlokImage = "https://pixijs.com/assets/helmlok.png";
 var helmlokName = `<span style="color:blue">Helmlok</span>`;
 var skullyImage = "https://pixijs.com/assets/skully.png";
 var skullyName = `<span style="color:red">Skully</span>`;
+var bunnyImage = "https://pixijs.com/assets/bunny.png";
+var bunnyName = `Bunny`;
 
-// src/labels/MarkdownTest.ts
-var MARKDOWN_TEST_LABEL = "___pixi_vn_markdown_test___";
-var markdownTest = newLabel(MARKDOWN_TEST_LABEL, [
-  () => __async(void 0, null, function* () {
-    setDialogue({
+// src/labels/CanvasEventsTestLabel.ts
+var EventTest1 = class extends CanvasEvent {
+  fn(event, sprite) {
+    if (event === "pointerdown") {
+      sprite.scale.x *= 1.25;
+      sprite.scale.y *= 1.25;
+    }
+  }
+};
+EventTest1 = __decorateClass([
+  eventDecorator("___pixi_vn_canvas_events_test_event1___")
+], EventTest1);
+var EventTest2 = class extends CanvasEvent {
+  constructor() {
+    super(...arguments);
+    this.textureButtonDown = Texture.from("https://pixijs.com/assets/button_down.png");
+    this.textureButtonOver = Texture.from("https://pixijs.com/assets/button_over.png");
+    this.textureButton = Texture.from("https://pixijs.com/assets/button.png");
+  }
+  fn(event, sprite) {
+    if (event === "pointerdown") {
+      sprite.isdown = true;
+      sprite.texture = this.textureButtonDown;
+      sprite.alpha = 1;
+    } else if (event === "pointerup" || event === "pointerupoutside") {
+      sprite.isdown = false;
+      if (sprite.isOver) {
+        sprite.texture = this.textureButtonOver;
+      } else {
+        sprite.texture = this.textureButton;
+      }
+    } else if (event === "pointerover") {
+      sprite.isOver = true;
+      if (sprite.isdown) {
+        return;
+      }
+      sprite.texture = this.textureButtonOver;
+    } else if (event === "pointerout") {
+      sprite.isOver = false;
+      if (sprite.isdown) {
+        return;
+      }
+      sprite.texture = this.textureButton;
+    }
+  }
+};
+EventTest2 = __decorateClass([
+  eventDecorator("___pixi_vn_canvas_events_test_event2___")
+], EventTest2);
+var CANVAS_EVENTS_TEST_LABEL = "___pixi_vn_canvas_events_test___";
+var canvasEventsTestLabel = newLabel(
+  CANVAS_EVENTS_TEST_LABEL,
+  [
+    () => setDialogue({
       character: juliette,
-      text: `
-# Markdown Test
-
-Hello, this is a test of the markdown parser. Pixi'VN does not manage markdown, but you can implement a markdown parser to display text with markdown syntax.
-
-For example in React, you can use the library [react-markdown](https://www.npmjs.com/package/react-markdown).
-
-## Colored Text
-
-<span style="color:blue">some *blue* text</span>.
-
-<span style="color:red">some *red* text</span>.
-
-<span style="color:green">some *green* text</span>.
-
-## Bold Text
-
-**This is bold text.**
-
-## Italic Text
-
-*This is italic text.*
-
-## Delete Text
-
-~~This is deleted text.~~
-
-## Link Test
-
-[Link to Google](https://www.google.com)
-
-## H2 Test
-
-### H3 Test
-
-#### H4 Test
- 
-## Code Test
-
-\`Hello World\`
-
-\`\`\`js
-console.log("Hello World")
-\`\`\`
-
-## List Test
-
-- Item 1
-* Item 2
-- [x] Item 3
-
-## Table Test
-
-| Header 1 | Header 2 |
-| -------- | -------- |
-| Cell 1   | Cell 2   |
-
-## Separator Test
-
-***
-Footer
-
-`
+      text: "This is the test of clickable elements in a canvas."
+    }),
+    () => __async(void 0, null, function* () {
+      setDialogue({
+        character: juliette,
+        text: `This is my friend, ${bunnyName}. It's small now, but if you try to click on it it will get bigger and bigger. (This example is from the official [PixiJS website](https://pixijs.com/8.x/examples/events/click).)`
+      });
+      const texture = yield Assets.load(bunnyImage);
+      const sprite = CanvasSprite.from(texture);
+      sprite.anchor.set(0.5);
+      sprite.x = GameWindowManager.screen.width / 2;
+      sprite.y = GameWindowManager.screen.height / 2;
+      sprite.eventMode = "static";
+      sprite.cursor = "pointer";
+      sprite.onEvent("pointerdown", EventTest1);
+      GameWindowManager.addCanvasElement("bunny", sprite);
+    }),
+    () => __async(void 0, null, function* () {
+      GameWindowManager.clear();
+      setDialogue({
+        character: juliette,
+        text: `This is the test of buttons in a canvas. (This example is from the official [PixiJS website](https://pixijs.com/8.x/examples/events/interactivity).)`
+      });
+      yield Assets.load([
+        "https://pixijs.com/assets/bg_button.jpg",
+        "https://pixijs.com/assets/button.png",
+        "https://pixijs.com/assets/button_down.png",
+        "https://pixijs.com/assets/button_over.png"
+      ]);
+      const background = CanvasSprite.from("https://pixijs.com/assets/bg_button.jpg");
+      background.width = GameWindowManager.screen.width;
+      background.height = GameWindowManager.screen.height;
+      GameWindowManager.addCanvasElement("bg", background);
+      const textureButton = Texture.from("https://pixijs.com/assets/button.png");
+      const buttons = [];
+      const buttonPositions = [175, 75, 655, 75, 410, 325, 150, 465, 685, 445];
+      for (let i = 0; i < 5; i++) {
+        const button = new CanvasSprite(textureButton);
+        button.anchor.set(0.5);
+        button.x = buttonPositions[i * 2];
+        button.y = buttonPositions[i * 2 + 1];
+        button.eventMode = "static";
+        button.cursor = "pointer";
+        button.onEvent("pointerdown", EventTest2).onEvent("pointerup", EventTest2).onEvent("pointerupoutside", EventTest2).onEvent("pointerover", EventTest2).onEvent("pointerout", EventTest2);
+        GameWindowManager.addCanvasElement("button" + i, button);
+        buttons.push(button);
+      }
+      buttons[0].scale.set(1.2);
+      buttons[2].rotation = Math.PI / 10;
+      buttons[3].scale.set(0.8);
+      buttons[4].scale.set(0.8, 1.2);
+      buttons[4].rotation = Math.PI;
+    })
+  ]
+);
+var AlienTintingTest = class extends CanvasSprite {
+  constructor() {
+    super(...arguments);
+    this.direction = 0;
+    this.turningSpeed = 0;
+    this.speed = 0;
+  }
+  get memory() {
+    return __spreadProps(__spreadValues({}, super.memory), {
+      direction: this.direction,
+      turningSpeed: this.turningSpeed,
+      speed: this.speed
     });
-  })
-]);
+  }
+  set memory(memory) {
+    super.memory = memory;
+    this.direction = memory.direction;
+    this.turningSpeed = memory.turningSpeed;
+    this.speed = memory.speed;
+  }
+  static from(source, skipCache) {
+    let sprite = Sprite.from(source, skipCache);
+    let mySprite = new AlienTintingTest();
+    mySprite.texture = sprite.texture;
+    return mySprite;
+  }
+};
+AlienTintingTest = __decorateClass([
+  canvasElementDecorator("___pixi_vn_custom_canvas_element___")
+], AlienTintingTest);
+var TintingTestTicker = class extends TickerBase {
+  constructor() {
+    super({});
+  }
+  fn(_t, _args, tags) {
+    tags.forEach((tag) => {
+      const dudeBoundsPadding = 100;
+      const dudeBounds = new Rectangle(
+        -dudeBoundsPadding,
+        -dudeBoundsPadding,
+        GameWindowManager.screen.width + dudeBoundsPadding * 2,
+        GameWindowManager.screen.height + dudeBoundsPadding * 2
+      );
+      let dude = GameWindowManager.getCanvasElement(tag);
+      if (dude && dude instanceof AlienTintingTest) {
+        dude.direction += dude.turningSpeed * 0.01;
+        dude.x += Math.sin(dude.direction) * dude.speed;
+        dude.y += Math.cos(dude.direction) * dude.speed;
+        dude.rotation = -dude.direction - Math.PI / 2;
+        if (dude.x < dudeBounds.x) {
+          dude.x += dudeBounds.width;
+        } else if (dude.x > dudeBounds.x + dudeBounds.width) {
+          dude.x -= dudeBounds.width;
+        }
+        if (dude.y < dudeBounds.y) {
+          dude.y += dudeBounds.height;
+        } else if (dude.y > dudeBounds.y + dudeBounds.height) {
+          dude.y -= dudeBounds.height;
+        }
+      }
+    });
+  }
+};
+TintingTestTicker = __decorateClass([
+  tickerDecorator("___pixi_vn_custom_ticker___")
+], TintingTestTicker);
+var CUSTOM_TICKER_CANVAS_ELEMENT_TEST_LABEL = "___pixi_vn_custom_ticker_canvas_element_test___";
+var customTickerCanvasElementTestLabel = newLabel(
+  CUSTOM_TICKER_CANVAS_ELEMENT_TEST_LABEL,
+  [
+    () => __async(void 0, null, function* () {
+      const totalDudes = 100;
+      for (let i = 0; i < totalDudes; i++) {
+        const texture = yield Assets.load(eggHeadImage);
+        const dude = AlienTintingTest.from(texture);
+        dude.anchor.set(0.5);
+        dude.scale.set(0.8 + Math.random() * 0.3);
+        dude.x = Math.random() * GameWindowManager.screen.width;
+        dude.y = Math.random() * GameWindowManager.screen.height;
+        dude.tint = Math.random() * 16777215;
+        dude.direction = Math.random() * Math.PI * 2;
+        dude.turningSpeed = Math.random() - 0.8;
+        dude.speed = 2 + Math.random() * 2;
+        GameWindowManager.addCanvasElement("alien" + i, dude);
+        GameWindowManager.addTicker("alien" + i, new TintingTestTicker());
+      }
+      setDialogue({
+        character: juliette,
+        text: `This is a test of custom ticker and canvas element. In this test, we have created ${totalDudes} ${eggHeadName} with random tint, scale, position, direction, turning speed, and speed. With the custom ticker, we are moving the custom canvas element in a random direction. (This example is from the official [PixiJS website](https://pixijs.com/8.x/examples/events/interactivity).)`
+      });
+    })
+  ]
+);
 
-// src/labels/ShowImageTest.ts
+// src/labels/ImagesAnimationsTestLabel.ts
 var IMAGE_ANIMAIONS_TEST_LABEL = "___pixi_vn_images_animations_test___";
 var imagesAnimationsTest = newLabel(IMAGE_ANIMAIONS_TEST_LABEL, [
   () => __async(void 0, null, function* () {
@@ -3088,6 +3429,8 @@ var imagesAnimationsTest = newLabel(IMAGE_ANIMAIONS_TEST_LABEL, [
       new ChoiceMenuOption("Rotate", imagesRotateTest),
       new ChoiceMenuOption("Move", imagesMoveTest),
       new ChoiceMenuOption("Zoom", imagesZoomTest),
+      new ChoiceMenuOption("Move in/out", imagesMoveInOutTest),
+      new ChoiceMenuOption("Zoom in/out", imagesZoomInOutTest),
       new ChoiceMenuOptionClose("Cancel", true)
     ]);
   }),
@@ -3342,6 +3685,148 @@ var imagesZoomTest = newLabel("___pixi_vn_images_zoom_test___", [
     ]);
   }
 ]);
+var imagesMoveInOutTest = newLabel("___pixi_vn_images_move_in_out_test___", [
+  () => __async(void 0, null, function* () {
+    setDialogue({
+      character: juliette,
+      text: `Here's what's going to happen:
+- ${eggHeadName} will move in from the top with a speed of 800. If you go next, ${eggHeadName} will move out from the bottom with a speed of 800.
+- ${flowerTopName} will move in from the right with a speed of 800 and a speed progression of 0.02. If you go next, ${flowerTopName} will move out from the left with a speed of 800 and a speed progression of 0.02.
+- ${helmlokName} will move in from the left with a speed of 800. If you go next, ${helmlokName} will move out from the right with a speed of 800.
+- ${skullyName} will move in from the bottom with a speed of 800 and a speed progression of 0.02. If you go next, ${skullyName} will move out from the top with a speed of 800 and a speed progression of 0.02.`
+    });
+    let eggHead = new CanvasImage({ x: 100, y: 100 }, eggHeadImage);
+    let flowerTop = new CanvasImage({ x: 300, y: 100 }, flowerTopImage);
+    let helmlok = new CanvasImage({ x: 100, y: 300 }, helmlokImage);
+    let skully = new CanvasImage({ x: 300, y: 300 }, skullyImage);
+    moveIn("eggHead", eggHead, { speed: 800, direction: "down" });
+    moveIn("flowerTop", flowerTop, {
+      speed: 800,
+      direction: "left",
+      speedProgression: { type: "exponential", percentage: 0.02 }
+    });
+    moveIn("helmlok", helmlok, { speed: 800, direction: "right" });
+    moveIn("skully", skully, {
+      speed: 800,
+      direction: "up",
+      speedProgression: { type: "exponential", percentage: 0.02 }
+    });
+  }),
+  () => {
+    moveOut("eggHead", { speed: 800, direction: "down" });
+    moveOut("flowerTop", { speed: 800, direction: "left" });
+    moveOut("helmlok", { speed: 800, direction: "right" });
+    moveOut("skully", { speed: 800, direction: "up" });
+  }
+]);
+var imagesZoomInOutTest = newLabel("___pixi_vn_images_zoom_in_out_test___", [
+  () => __async(void 0, null, function* () {
+    GameWindowManager.removeCanvasElements();
+    let eggHead = new CanvasImage({ x: 100, y: 100 }, eggHeadImage);
+    let flowerTop = new CanvasImage({ x: 300, y: 100 }, flowerTopImage);
+    let helmlok = new CanvasImage({ x: 100, y: 300 }, helmlokImage);
+    let skully = new CanvasImage({ x: 300, y: 300 }, skullyImage);
+    zoomIn("eggHead", eggHead, { speed: 3, direction: "down" });
+    zoomIn("flowerTop", flowerTop, {
+      speed: 3,
+      direction: "left",
+      speedProgression: { type: "exponential", percentage: 0.02 }
+    });
+    zoomIn("helmlok", helmlok, { speed: 3, direction: "right" });
+    zoomIn("skully", skully, {
+      speed: 3,
+      direction: "up",
+      speedProgression: { type: "exponential", percentage: 0.02 }
+    });
+  }),
+  () => __async(void 0, null, function* () {
+    zoomOut("eggHead", {
+      speed: 3,
+      direction: "down",
+      speedProgression: { type: "exponential", percentage: 0.02 }
+    });
+    zoomOut("flowerTop", { speed: 3, direction: "left" });
+    zoomOut("helmlok", { speed: 3, direction: "right" });
+    zoomOut("skully", {
+      speed: 3,
+      direction: "up",
+      speedProgression: { type: "exponential", percentage: 0.02 }
+    });
+  })
+]);
+
+// src/labels/MarkdownTest.ts
+var MARKDOWN_TEST_LABEL = "___pixi_vn_markdown_test___";
+var markdownTest = newLabel(MARKDOWN_TEST_LABEL, [
+  () => __async(void 0, null, function* () {
+    setDialogue({
+      character: juliette,
+      text: `
+# Markdown Test
+
+Hello, this is a test of the markdown parser. Pixi'VN does not manage markdown, but you can implement a markdown parser to display text with markdown syntax.
+
+For example in React, you can use the library [react-markdown](https://www.npmjs.com/package/react-markdown).
+
+## Colored Text
+
+<span style="color:blue">some *blue* text</span>.
+
+<span style="color:red">some *red* text</span>.
+
+<span style="color:green">some *green* text</span>.
+
+## Bold Text
+
+**This is bold text.**
+
+## Italic Text
+
+*This is italic text.*
+
+## Delete Text
+
+~~This is deleted text.~~
+
+## Link Test
+
+[Link to Google](https://www.google.com)
+
+## H2 Test
+
+### H3 Test
+
+#### H4 Test
+ 
+## Code Test
+
+\`Hello World\`
+
+\`\`\`js
+console.log("Hello World")
+\`\`\`
+
+## List Test
+
+- Item 1
+* Item 2
+- [x] Item 3
+
+## Table Test
+
+| Header 1 | Header 2 |
+| -------- | -------- |
+| Cell 1   | Cell 2   |
+
+## Separator Test
+
+***
+Footer
+
+`
+    });
+  })
+]);
 
 // src/labels/StartLabel.ts
 var pixivnTestStartLabel = newLabel(
@@ -3373,7 +3858,9 @@ var pixivnTestStartLabel2 = newLabel(
       GameWindowManager.clear();
       setDialogue({ character: juliette, text: "Which test would you like to start with?" });
       setChoiceMenuOptions([
-        new ChoiceMenuOption("Images and Animations", imagesAnimationsTest),
+        new ChoiceMenuOption("Images, Transitions and Animations Test", imagesAnimationsTest),
+        new ChoiceMenuOption("Canvas Events Test Label", canvasEventsTestLabel),
+        new ChoiceMenuOption("Custom Ticker Canvas Element Test", customTickerCanvasElementTestLabel),
         new ChoiceMenuOption("Markdown Test", markdownTest)
       ]);
     },
@@ -3381,6 +3868,6 @@ var pixivnTestStartLabel2 = newLabel(
   ]
 );
 
-export { CanvasBase, CanvasContainer, CanvasEvent, CanvasImage, CanvasSprite, CanvasText, CharacterBaseModel2 as CharacterBaseModel, ChoiceMenuOption, ChoiceMenuOptionClose, Close, DialogueBaseModel, FadeAlphaTicker, GameStepManager, GameStorageManager, GameWindowManager, Label, MoveTicker, Pause, Repeat, RotateTicker, StoredClassModel, TickerBase, ZoomTicker, addImage, canvasElementDecorator, clearAllGameDatas, clearChoiceMenuOptions, clearDialogue, eventDecorator, getAllCharacters, getCharacterById, getChoiceMenuOptions, getDialogue, getDialogueHistory, getFlag, getLabelById, getSaveData, getSaveJson, getTexture, juliette, loadImage, loadSaveData, loadSaveJson, newLabel, pixivnTestStartLabel, removeCanvasElement, removeWithDissolveTransition, removeWithFadeTransition, saveCharacter, setChoiceMenuOptions, setDialogue, setFlag, showImage, showWithDissolveTransition, showWithFadeTransition, tickerDecorator };
+export { CanvasBase, CanvasContainer, CanvasEvent, CanvasImage, CanvasSprite, CanvasText, CharacterBaseModel2 as CharacterBaseModel, ChoiceMenuOption, ChoiceMenuOptionClose, Close, DialogueBaseModel, FadeAlphaTicker, GameStepManager, GameStorageManager, GameWindowManager, Label, MoveTicker, Pause, Repeat, RotateTicker, StoredClassModel, TickerBase, ZoomTicker, addImage, canvasElementDecorator, clearAllGameDatas, clearChoiceMenuOptions, clearDialogue, eventDecorator, getAllCharacters, getCharacterById, getChoiceMenuOptions, getDialogue, getDialogueHistory, getFlag, getLabelById, getSaveData, getSaveJson, getTexture, juliette, loadImage, loadSaveData, loadSaveJson, moveIn, moveOut, newLabel, pixivnTestStartLabel, removeCanvasElement, removeWithDissolveTransition, removeWithFadeTransition, saveCharacter, setChoiceMenuOptions, setDialogue, setFlag, showImage, showWithDissolveTransition, showWithFadeTransition, tickerDecorator, zoomIn, zoomOut };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.mjs.map