@drincs/pixi-vn 0.8.4 → 0.8.9

package/dist/functions/index.cjs

@@ -1607,14 +1607,14 @@ var init_uid = __esm({
 });
 
 // node_modules/pixi.js/lib/utils/logging/deprecation.mjs
-function deprecation(version, message, ignoreDepth = 3) {
+function deprecation(version2, message, ignoreDepth = 3) {
   if (warnings[message]) {
     return;
   }
   let stack = new Error().stack;
   if (typeof stack === "undefined") {
     console.warn("PixiJS Deprecation Warning: ", `${message}
-Deprecated since v${version}`);
+Deprecated since v${version2}`);
   } else {
     stack = stack.split("\n").splice(ignoreDepth).join("\n");
     if (console.groupCollapsed) {
@@ -1623,13 +1623,13 @@ Deprecated since v${version}`);
         "color:#614108;background:#fffbe6",
         "font-weight:normal;color:#614108;background:#fffbe6",
         `${message}
-Deprecated since v${version}`
+Deprecated since v${version2}`
       );
       console.warn(stack);
       console.groupEnd();
     } else {
       console.warn("PixiJS Deprecation Warning: ", `${message}
-Deprecated since v${version}`);
+Deprecated since v${version2}`);
       console.warn(stack);
     }
   }
@@ -42998,7 +42998,7 @@ var require_dom = __commonJS({
        * @see https://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-5CED94D7 DOM Level 1 Core
        * @see https://dom.spec.whatwg.org/#dom-domimplementation-hasfeature DOM Living Standard
        */
-      hasFeature: function(feature, version) {
+      hasFeature: function(feature, version2) {
         return true;
       },
       /**
@@ -43119,8 +43119,8 @@ var require_dom = __commonJS({
         }
       },
       // Introduced in DOM Level 2:
-      isSupported: function(feature, version) {
-        return this.ownerDocument.implementation.hasFeature(feature, version);
+      isSupported: function(feature, version2) {
+        return this.ownerDocument.implementation.hasFeature(feature, version2);
       },
       // Introduced in DOM Level 2:
       hasAttributes: function() {
@@ -54716,12 +54716,15 @@ __export(functions_exports, {
   loadVideo: () => loadVideo,
   moveIn: () => moveIn,
   moveOut: () => moveOut,
+  pushIn: () => pushIn,
+  pushOut: () => pushOut,
   removeCanvasElement: () => removeCanvasElement,
   removeWithDissolveTransition: () => removeWithDissolveTransition,
   removeWithFadeTransition: () => removeWithFadeTransition,
   setChoiceMenuOptions: () => setChoiceMenuOptions,
   setDialogue: () => setDialogue,
   setFlag: () => setFlag,
+  shakeEffect: () => shakeEffect,
   showImage: () => showImage,
   showVideo: () => showVideo,
   showWithDissolveTransition: () => showWithDissolveTransition,
@@ -54731,6 +54734,9 @@ __export(functions_exports, {
 });
 module.exports = __toCommonJS(functions_exports);
 
+// src/classes/ticker/FadeAlphaTicker.ts
+init_lib();
+
 // src/classes/canvas/CanvasAVideo.ts
 init_lib();
 
@@ -57421,8 +57427,10 @@ extensions.add(soundAsset);
 // node_modules/@pixi/sound/lib/index.mjs
 var sound = setInstance(new SoundLibrary());
 
+// package.json
+var version = "0.8.9";
+
 // src/constants.ts
-var PIXIVN_VERSION = "0.8.3";
 var Repeat = "repeat";
 function Pause(duration) {
   return {
@@ -57541,6 +57549,7 @@ var videoFormats = [
   "asf",
   "vob"
 ];
+var CANVAS_APP_STAGE_ALIAS = "_stage_";
 
 // src/managers/CanvasManager.ts
 init_lib();
@@ -57548,6 +57557,111 @@ init_lib();
 // src/classes/canvas/CanvasContainer.ts
 init_lib();
 
+// src/functions/canvas/canvas-memory-utility.ts
+function exportCanvasElement(element) {
+  return element.memory;
+}
+function importCanvasElement(memory) {
+  let element = getCanvasElementInstanceById(memory.pixivnId);
+  if (element) {
+    element.memory = memory;
+  } else {
+    throw new Error("[Pixi\u2019VN] The element " + memory.pixivnId + " could not be created");
+  }
+  return element;
+}
+
+// src/classes/canvas/CanvasContainer.ts
+var CANVAS_CONTAINER_ID = "Container";
+var CanvasContainer = class extends Container {
+  constructor(options) {
+    super(options);
+    this.pixivnId = this.constructor.prototype.pixivnId || CANVAS_CONTAINER_ID;
+  }
+  pixivnId = CANVAS_CONTAINER_ID;
+  get memory() {
+    let memory = getMemoryContainer(this);
+    this.children.forEach((child) => {
+      memory.elements.push(exportCanvasElement(child));
+    });
+    return memory;
+  }
+  set memory(value) {
+    setMemoryContainer(this, value);
+    value.elements.forEach((child) => {
+      this.addChild(importCanvasElement(child));
+    });
+  }
+};
+function getMemoryContainer(element) {
+  let className = CANVAS_CONTAINER_ID;
+  if (element.hasOwnProperty("pixivnId")) {
+    className = element.pixivnId;
+  }
+  return {
+    pixivnId: className,
+    elements: [],
+    width: element.width,
+    height: element.height,
+    isRenderGroup: element.isRenderGroup,
+    blendMode: element.blendMode,
+    tint: element.tint,
+    alpha: element.alpha,
+    angle: element.angle,
+    renderable: element.renderable,
+    rotation: element.rotation,
+    scale: { x: element.scale.x, y: element.scale.y },
+    pivot: { x: element.pivot.x, y: element.pivot.y },
+    position: { x: element.position.x, y: element.position.y },
+    skew: { x: element.skew.x, y: element.skew.y },
+    visible: element.visible,
+    x: element.x,
+    y: element.y,
+    boundsArea: element.boundsArea,
+    cursor: element.cursor,
+    eventMode: element.eventMode,
+    interactive: element.interactive,
+    interactiveChildren: element.interactiveChildren,
+    hitArea: element.hitArea
+  };
+}
+function setMemoryContainer(element, memory) {
+  "isRenderGroup" in memory && memory.isRenderGroup && (element.isRenderGroup = memory.isRenderGroup);
+  "blendMode" in memory && memory.blendMode && (element.blendMode = memory.blendMode);
+  "tint" in memory && memory.tint && (element.tint = memory.tint);
+  "alpha" in memory && memory.alpha && (element.alpha = memory.alpha);
+  "angle" in memory && memory.angle && (element.angle = memory.angle);
+  "renderable" in memory && memory.renderable && (element.renderable = memory.renderable);
+  "rotation" in memory && memory.rotation && (element.rotation = memory.rotation);
+  if ("scale" in memory && memory.scale) {
+    if (typeof memory.scale === "number") {
+      element.scale.set(memory.scale, memory.scale);
+    } else {
+      element.scale.set(memory.scale.x, memory.scale.y);
+    }
+  }
+  if ("pivot" in memory && memory.pivot) {
+    if (typeof memory.pivot === "number") {
+      element.pivot.set(memory.pivot, memory.pivot);
+    } else {
+      element.pivot.set(memory.pivot.x, memory.pivot.y);
+    }
+  }
+  "position" in memory && memory.position && element.position.set(memory.position.x, memory.position.y);
+  "skew" in memory && memory.skew && element.skew.set(memory.skew.x, memory.skew.y);
+  "visible" in memory && memory.visible && (element.visible = memory.visible);
+  "x" in memory && memory.x && (element.x = memory.x);
+  "y" in memory && memory.y && (element.y = memory.y);
+  "boundsArea" in memory && memory.boundsArea && (element.boundsArea = memory.boundsArea);
+  "cursor" in memory && memory.cursor && (element.cursor = memory.cursor);
+  "eventMode" in memory && memory.eventMode && (element.eventMode = memory.eventMode);
+  "interactive" in memory && memory.interactive && (element.interactive = memory.interactive);
+  "interactiveChildren" in memory && memory.interactiveChildren && (element.interactiveChildren = memory.interactiveChildren);
+  "hitArea" in memory && memory.hitArea && (element.hitArea = memory.hitArea);
+  "width" in memory && memory.width && (element.width = memory.width);
+  "height" in memory && memory.height && (element.height = memory.height);
+}
+
 // src/classes/canvas/CanvasText.ts
 init_lib();
 var CANVAS_TEXT_ID = "Text";
@@ -57656,141 +57770,6 @@ function setMemoryText(element, memory) {
   }
 }
 
-// src/decorators/canvas-element-decorator.ts
-var registeredCanvasElement = {};
-function getCanvasElementInstanceById(canvasId) {
-  try {
-    let eventType = registeredCanvasElement[canvasId];
-    if (!eventType) {
-      if (canvasId === CANVAS_CONTAINER_ID) {
-        eventType = CanvasContainer;
-      } else if (canvasId === CANVAS_VIDEO_ID) {
-        eventType = CanvasVideo;
-      } else if (canvasId === CANVAS_IMAGE_ID) {
-        eventType = CanvasImage;
-      } else if (canvasId === CANVAS_SPRITE_ID) {
-        eventType = CanvasSprite;
-      } else if (canvasId === CANVAS_TEXT_ID) {
-        eventType = CanvasText;
-      }
-    }
-    if (!eventType) {
-      console.error(`[Pixi\u2019VN] CanvasElement ${canvasId} not found`);
-      return;
-    }
-    let canvasElement = new eventType();
-    return canvasElement;
-  } catch (e2) {
-    console.error(`[Pixi\u2019VN] Error while getting CanvasElement ${canvasId}`, e2);
-    return;
-  }
-}
-
-// src/functions/canvas/canvas-memory-utility.ts
-function exportCanvasElement(element) {
-  return element.memory;
-}
-function importCanvasElement(memory) {
-  let element = getCanvasElementInstanceById(memory.pixivnId);
-  if (element) {
-    element.memory = memory;
-  } else {
-    throw new Error("[Pixi\u2019VN] The element " + memory.pixivnId + " could not be created");
-  }
-  return element;
-}
-
-// src/classes/canvas/CanvasContainer.ts
-var CANVAS_CONTAINER_ID = "Container";
-var CanvasContainer = class extends Container {
-  constructor(options) {
-    super(options);
-    this.pixivnId = this.constructor.prototype.pixivnId || CANVAS_CONTAINER_ID;
-  }
-  pixivnId = CANVAS_CONTAINER_ID;
-  get memory() {
-    let memory = getMemoryContainer(this);
-    this.children.forEach((child) => {
-      memory.elements.push(exportCanvasElement(child));
-    });
-    return memory;
-  }
-  set memory(value) {
-    setMemoryContainer(this, value);
-    value.elements.forEach((child) => {
-      this.addChild(importCanvasElement(child));
-    });
-  }
-};
-function getMemoryContainer(element) {
-  let className = CANVAS_CONTAINER_ID;
-  if (element.hasOwnProperty("pixivnId")) {
-    className = element.pixivnId;
-  }
-  return {
-    pixivnId: className,
-    elements: [],
-    width: element.width,
-    height: element.height,
-    isRenderGroup: element.isRenderGroup,
-    blendMode: element.blendMode,
-    tint: element.tint,
-    alpha: element.alpha,
-    angle: element.angle,
-    renderable: element.renderable,
-    rotation: element.rotation,
-    scale: { x: element.scale.x, y: element.scale.y },
-    pivot: { x: element.pivot.x, y: element.pivot.y },
-    position: { x: element.position.x, y: element.position.y },
-    skew: { x: element.skew.x, y: element.skew.y },
-    visible: element.visible,
-    x: element.x,
-    y: element.y,
-    boundsArea: element.boundsArea,
-    cursor: element.cursor,
-    eventMode: element.eventMode,
-    interactive: element.interactive,
-    interactiveChildren: element.interactiveChildren,
-    hitArea: element.hitArea
-  };
-}
-function setMemoryContainer(element, memory) {
-  "isRenderGroup" in memory && memory.isRenderGroup && (element.isRenderGroup = memory.isRenderGroup);
-  "blendMode" in memory && memory.blendMode && (element.blendMode = memory.blendMode);
-  "tint" in memory && memory.tint && (element.tint = memory.tint);
-  "alpha" in memory && memory.alpha && (element.alpha = memory.alpha);
-  "angle" in memory && memory.angle && (element.angle = memory.angle);
-  "renderable" in memory && memory.renderable && (element.renderable = memory.renderable);
-  "rotation" in memory && memory.rotation && (element.rotation = memory.rotation);
-  if ("scale" in memory && memory.scale) {
-    if (typeof memory.scale === "number") {
-      element.scale.set(memory.scale, memory.scale);
-    } else {
-      element.scale.set(memory.scale.x, memory.scale.y);
-    }
-  }
-  if ("pivot" in memory && memory.pivot) {
-    if (typeof memory.pivot === "number") {
-      element.pivot.set(memory.pivot, memory.pivot);
-    } else {
-      element.pivot.set(memory.pivot.x, memory.pivot.y);
-    }
-  }
-  "position" in memory && memory.position && element.position.set(memory.position.x, memory.position.y);
-  "skew" in memory && memory.skew && element.skew.set(memory.skew.x, memory.skew.y);
-  "visible" in memory && memory.visible && (element.visible = memory.visible);
-  "x" in memory && memory.x && (element.x = memory.x);
-  "y" in memory && memory.y && (element.y = memory.y);
-  "boundsArea" in memory && memory.boundsArea && (element.boundsArea = memory.boundsArea);
-  "cursor" in memory && memory.cursor && (element.cursor = memory.cursor);
-  "eventMode" in memory && memory.eventMode && (element.eventMode = memory.eventMode);
-  "interactive" in memory && memory.interactive && (element.interactive = memory.interactive);
-  "interactiveChildren" in memory && memory.interactiveChildren && (element.interactiveChildren = memory.interactiveChildren);
-  "hitArea" in memory && memory.hitArea && (element.hitArea = memory.hitArea);
-  "width" in memory && memory.width && (element.width = memory.width);
-  "height" in memory && memory.height && (element.height = memory.height);
-}
-
 // src/classes/ticker/TickerBase.ts
 var TickerBase = class {
   /**
@@ -57881,7 +57860,7 @@ function createExportableElement(element) {
     let elementString = JSON.stringify(element);
     return JSON.parse(elementString);
   } catch (e2) {
-    console.error("[Pixi\u2019VN] Error creating exportable element", e2);
+    console.error("[Pixi\u2019VN] Error creating exportable element", element, e2);
     throw new Error("[Pixi\u2019VN] Error creating exportable element");
   }
 }
@@ -58314,6 +58293,10 @@ var CanvasManager = class {
    * ```
    */
   add(alias, canvasElement, options = {}) {
+    if (alias === CANVAS_APP_STAGE_ALIAS) {
+      console.error(`[Pixi\u2019VN] The alias ${CANVAS_APP_STAGE_ALIAS} is reserved`);
+      return;
+    }
     let ignoreOldStyle = options?.ignoreOldStyle;
     let oldCanvasElement = this.find(alias);
     if (oldCanvasElement) {
@@ -58344,6 +58327,10 @@ var CanvasManager = class {
    * ```
    */
   remove(alias, options = {}) {
+    if (alias === CANVAS_APP_STAGE_ALIAS) {
+      console.error(`[Pixi\u2019VN] The alias ${CANVAS_APP_STAGE_ALIAS} is reserved`);
+      return;
+    }
     let ignoreTickers = options.ignoreTickers;
     if (typeof alias === "string") {
       alias = [alias];
@@ -58372,6 +58359,9 @@ var CanvasManager = class {
    * ```
    */
   find(alias) {
+    if (alias === CANVAS_APP_STAGE_ALIAS) {
+      return this.app.stage;
+    }
     return CanvasManagerStatic._children[alias];
   }
   /**
@@ -58398,16 +58388,17 @@ var CanvasManager = class {
     this.removeAllTickers();
   }
   /**
-   * Edit the alias of a canvas element.
+   * Edit the alias of a canvas element. The tickers that are connected to the canvas element will be transferred.
    * @param oldAlias The old alias of the canvas element.
    * @param newAlias The new alias of the canvas element.
+   * @param options The options of the canvas element.
    */
-  editAlias(oldAlias, newAlias) {
+  editAlias(oldAlias, newAlias, options = {}) {
     if (CanvasManagerStatic._children[oldAlias]) {
       CanvasManagerStatic._children[newAlias] = CanvasManagerStatic._children[oldAlias];
       delete CanvasManagerStatic._children[oldAlias];
     }
-    this.transferTickers(oldAlias, newAlias, "move");
+    !options.ignoreTickers && this.transferTickers(oldAlias, newAlias, "move");
   }
   /** Edit Tickers Methods */
   /**
@@ -58482,12 +58473,16 @@ var CanvasManager = class {
   pushTicker(id3, tickerData, ticker) {
     CanvasManagerStatic._currentTickers[id3] = tickerData;
     tickerData.fn = (t2) => {
-      if (tickerData.createdByTicketSteps && this.isTickerPaused(tickerData.createdByTicketSteps.canvasElementAlias, tickerData.createdByTicketSteps.id)) {
-        return;
-      }
       let data = CanvasManagerStatic._currentTickers[id3];
       if (data) {
-        let canvasElementAliases = data.canvasElementAliases.filter((alias) => !this.isTickerPaused(alias, id3));
+        let canvasElementAliases = data.canvasElementAliases;
+        if (tickerData.createdByTicketSteps) {
+          if (this.isTickerPaused(tickerData.createdByTicketSteps.canvasElementAlias, tickerData.createdByTicketSteps.id)) {
+            return;
+          }
+        } else {
+          canvasElementAliases = canvasElementAliases.filter((alias) => !this.isTickerPaused(alias, id3));
+        }
         ticker?.fn(t2, data.args, canvasElementAliases, id3);
       }
     };
@@ -58834,15 +58829,19 @@ var CanvasManager = class {
     });
     CanvasManagerStatic._tickersMustBeCompletedBeforeNextStep.stepAlias.forEach(({ alias, id: id3 }) => {
       let ticker = CanvasManagerStatic._currentTickersSteps[alias];
-      if (ticker && ticker[id3] && !ticker[id3].steps.includes(Repeat)) {
-        ticker[id3].steps.forEach((step) => {
-          if (typeof step === "object" && "ticker" in step) {
-            let ticker2 = geTickerInstanceById(step.ticker, step.args, step.duration, step.priority);
-            if (ticker2) {
-              ticker2.onEndOfTicker([alias], id3, step.args);
+      if (ticker && ticker[id3]) {
+        if (ticker[id3].steps.includes(Repeat)) {
+          console.error(`[Pixi\u2019VN] The ticker alias: ${alias} id: ${id3} contains a RepeatType, so it can't be forced to complete`, ticker[id3]);
+        } else {
+          ticker[id3].steps.forEach((step) => {
+            if (typeof step === "object" && "ticker" in step) {
+              let ticker2 = geTickerInstanceById(step.ticker, step.args, step.duration, step.priority);
+              if (ticker2) {
+                ticker2.onEndOfTicker([alias], id3, step.args);
+              }
             }
-          }
-        });
+          });
+        }
       }
     });
     CanvasManagerStatic._tickersMustBeCompletedBeforeNextStep = { tikersIds: [], stepAlias: [] };
@@ -58883,6 +58882,7 @@ var CanvasManager = class {
       tickers: createExportableElement(CanvasManagerStatic.currentTickersWithoutCreatedBySteps),
       tickersSteps: createExportableElement(CanvasManagerStatic._currentTickersSteps),
       elements: createExportableElement(currentElements),
+      stage: createExportableElement(getMemoryContainer(this.app.stage)),
       elementAliasesOrder: createExportableElement(CanvasManagerStatic.childrenAliasesOrder),
       tickersOnPause: createExportableElement(CanvasManagerStatic._tickersOnPause)
     };
@@ -58916,6 +58916,11 @@ var CanvasManager = class {
         console.error("[Pixi\u2019VN] The data does not have the properties elementAliasesOrder and elements");
         return;
       }
+      if (data.hasOwnProperty("stage") && data.hasOwnProperty("stage")) {
+        setMemoryContainer(this.app.stage, data["stage"]);
+      } else {
+        console.error("[Pixi\u2019VN] The data does not have the properties stage");
+      }
       if (data.hasOwnProperty("tickers")) {
         let tickers = data["tickers"];
         Object.entries(tickers).forEach(([oldId, t2]) => {
@@ -58956,17 +58961,6 @@ var CanvasManager = class {
 // src/managers/NarrationManager.ts
 var import_deep_diff = __toESM(require_deep_diff(), 1);
 
-// src/decorators/label-decorator.ts
-var registeredLabels = {};
-function getLabelById(id3) {
-  let label = registeredLabels[id3];
-  if (!label) {
-    console.error(`[Pixi\u2019VN] Label ${id3} not found`);
-    return;
-  }
-  return label;
-}
-
 // src/types/CloseType.ts
 var Close = "close";
 
@@ -59222,6 +59216,17 @@ var ChoiceMenuOptionClose = class {
   }
 };
 
+// src/decorators/label-decorator.ts
+var registeredLabels = {};
+function getLabelById(id3) {
+  let label = registeredLabels[id3];
+  if (!label) {
+    console.error(`[Pixi\u2019VN] Label ${id3} not found`);
+    return;
+  }
+  return label;
+}
+
 // src/functions/diff-utility.ts
 function restoreDeepDiffChanges(data, differences) {
   let result = createExportableElement(data);
@@ -59444,6 +59449,7 @@ var NarrationManagerStatic = class _NarrationManagerStatic {
         canvas: {
           elementAliasesOrder: [],
           elements: {},
+          stage: {},
           tickers: {},
           tickersSteps: {},
           tickersOnPause: {}
@@ -60023,8 +60029,10 @@ var NarrationManager = class {
           console.warn("[Pixi\u2019VN] stepSha not found");
         }
         try {
+          if (NarrationManagerStatic.stepsRunning === 0) {
+            canvas.forceCompletionOfReportedTickers();
+          }
           NarrationManagerStatic.stepsRunning++;
-          canvas.forceCompletionOfReportedTickers();
           let result = await step(props);
           if (this.choiceMenuOptions?.length === 1 && this.choiceMenuOptions[0].autoSelect) {
             let choice = this.choiceMenuOptions[0];
@@ -61450,8 +61458,37 @@ var Sound2 = class _Sound2 extends Sound {
   }
 };
 
+// src/decorators/canvas-element-decorator.ts
+var registeredCanvasElement = {};
+function getCanvasElementInstanceById(canvasId) {
+  try {
+    let eventType = registeredCanvasElement[canvasId];
+    if (!eventType) {
+      if (canvasId === CANVAS_CONTAINER_ID) {
+        eventType = CanvasContainer;
+      } else if (canvasId === CANVAS_VIDEO_ID) {
+        eventType = CanvasVideo;
+      } else if (canvasId === CANVAS_IMAGE_ID) {
+        eventType = CanvasImage;
+      } else if (canvasId === CANVAS_SPRITE_ID) {
+        eventType = CanvasSprite;
+      } else if (canvasId === CANVAS_TEXT_ID) {
+        eventType = CanvasText;
+      }
+    }
+    if (!eventType) {
+      console.error(`[Pixi\u2019VN] CanvasElement ${canvasId} not found`);
+      return;
+    }
+    let canvasElement = new eventType();
+    return canvasElement;
+  } catch (e2) {
+    console.error(`[Pixi\u2019VN] Error while getting CanvasElement ${canvasId}`, e2);
+    return;
+  }
+}
+
 // src/classes/ticker/FadeAlphaTicker.ts
-init_lib();
 var FadeAlphaTicker = class extends TickerBase {
   fn(ticker, args, aliases, tickerId) {
     let type = args.type === void 0 ? "hide" : args.type;
@@ -61571,8 +61608,8 @@ function getExponentialProgression(number, progression, valueConvert) {
 // src/classes/ticker/MoveTicker.ts
 var MoveTicker = class extends TickerBase {
   fn(ticker, args, aliases, tickerId) {
-    let xSpeed = 1;
-    let ySpeed = 1;
+    let xSpeed = 10;
+    let ySpeed = 10;
     if (args.speed) {
       if (typeof args.speed === "number") {
         xSpeed = this.speedConvert(args.speed);
@@ -61636,6 +61673,10 @@ var MoveTicker = class extends TickerBase {
         let destination = args.destination;
         element.x = destination.x;
         element.y = destination.y;
+        if (args.isPushInOut && element.children.length > 0) {
+          let elementChild = element.children[0];
+          canvas.add(alias2, elementChild, { ignoreOldStyle: true });
+        }
       }
     });
     super.onEndOfTicker(alias, tickerId, args);
@@ -61826,6 +61867,88 @@ ZoomTicker = __decorateClass([
   tickerDecorator()
 ], ZoomTicker);
 
+// src/functions/canvas/canvas-effect.ts
+async function shakeEffect(alias, props = {}, priority) {
+  let elemet = canvas.find(alias);
+  if (!elemet) {
+    console.error(`[Pixi\u2019VN] The element with the alias ${alias} does not exist. So the shake effect can't be applied.`);
+    return;
+  }
+  let position = { x: elemet.position.x, y: elemet.position.y };
+  let speed = props.speed || 20;
+  let speedProgression = props.speedProgression || void 0;
+  let startOnlyIfHaveTexture = props.startOnlyIfHaveTexture || false;
+  let type = props.type || "horizontal";
+  let maximumShockSize = props.maximumShockSize || 10;
+  let shocksNumber = (props.shocksNumber || 10) - 1;
+  if (shocksNumber < 2) {
+    console.error("[Pixi\u2019VN] The number of shocks must be at least 3.");
+    return;
+  }
+  let upshocksNumber = Math.floor(shocksNumber / 2);
+  let downshocksNumber = Math.ceil(shocksNumber / 2);
+  let moveTickers = [];
+  for (let i3 = 0; i3 < upshocksNumber; i3++) {
+    let destination = { x: position.x, y: position.y };
+    let shockSize = maximumShockSize * (i3 + 1) / upshocksNumber;
+    if (type === "horizontal") {
+      if (i3 % 2 !== 0) {
+        destination.x = position.x + shockSize;
+      } else {
+        destination.x = position.x - shockSize;
+      }
+    } else {
+      if (i3 % 2 !== 0) {
+        destination.y = position.y + shockSize;
+      } else {
+        destination.y = position.y - shockSize;
+      }
+    }
+    moveTickers.push(new MoveTicker({
+      destination,
+      speed,
+      speedProgression,
+      startOnlyIfHaveTexture
+    }, void 0, priority));
+  }
+  let lastItemIsLeft = upshocksNumber % 2 === 0;
+  for (let i3 = downshocksNumber; i3 > 0; i3--) {
+    let destination = { x: position.x, y: position.y };
+    let shockSize = maximumShockSize * (i3 + 1) / (downshocksNumber - 1);
+    if (type === "horizontal") {
+      if (i3 % 2 === 0 && !lastItemIsLeft || i3 % 2 !== 0 && lastItemIsLeft) {
+        destination.x = position.x - shockSize;
+      } else {
+        destination.x = position.x + shockSize;
+      }
+    } else {
+      if (i3 % 2 === 0 && !lastItemIsLeft || i3 % 2 !== 0 && lastItemIsLeft) {
+        destination.y = position.y - shockSize;
+      } else {
+        destination.y = position.y + shockSize;
+      }
+    }
+    moveTickers.push(new MoveTicker({
+      destination,
+      speed,
+      speedProgression,
+      startOnlyIfHaveTexture
+    }, void 0, priority));
+  }
+  moveTickers.push(new MoveTicker({
+    destination: position,
+    speed,
+    speedProgression,
+    startOnlyIfHaveTexture,
+    tickerAliasToResume: alias
+  }, void 0, priority));
+  let id3 = canvas.addTickersSteps(alias, moveTickers);
+  if (id3) {
+    canvas.addTickerMustBeCompletedBeforeNextStep({ id: id3, alias });
+    canvas.putOnPauseTicker(alias, id3);
+  }
+}
+
 // src/functions/canvas/image-utility.ts
 function addImage(alias, imageUrl) {
   let image = new CanvasImage();
@@ -61892,6 +62015,7 @@ async function showVideo(alias, videoUrl) {
 
 // src/functions/canvas/canvas-transition.ts
 async function showWithDissolveTransition(alias, image, props = {}, priority) {
+  let mustBeCompletedBeforeNextStep = props.mustBeCompletedBeforeNextStep ?? true;
   let oldCanvasAlias = void 0;
   if (canvas.find(alias)) {
     oldCanvasAlias = alias + "_temp_disolve";
@@ -61921,10 +62045,13 @@ async function showWithDissolveTransition(alias, image, props = {}, priority) {
     startOnlyIfHaveTexture: true
   }, 10, priority);
   let id3 = canvas.addTicker(alias, effect);
-  id3 && canvas.addTickerMustBeCompletedBeforeNextStep({ id: id3 });
-  return;
+  if (id3) {
+    mustBeCompletedBeforeNextStep && canvas.addTickerMustBeCompletedBeforeNextStep({ id: id3 });
+    return [id3];
+  }
 }
 function removeWithDissolveTransition(alias, props = {}, priority) {
+  let mustBeCompletedBeforeNextStep = props.mustBeCompletedBeforeNextStep ?? true;
   if (typeof alias === "string") {
     alias = [alias];
   }
@@ -61934,12 +62061,17 @@ function removeWithDissolveTransition(alias, props = {}, priority) {
     aliasToRemoveAfter: alias,
     startOnlyIfHaveTexture: true
   }, 10, priority);
-  canvas.addTicker(alias, effect);
+  let id3 = canvas.addTicker(alias, effect);
+  if (id3) {
+    mustBeCompletedBeforeNextStep && canvas.addTickerMustBeCompletedBeforeNextStep({ id: id3 });
+    return [id3];
+  }
 }
 async function showWithFadeTransition(alias, image, props = {}, priority) {
   if (!canvas.find(alias)) {
     return showWithDissolveTransition(alias, image, props, priority);
   }
+  let mustBeCompletedBeforeNextStep = props.mustBeCompletedBeforeNextStep ?? true;
   let oldCanvasAlias = alias + "_temp_fade";
   canvas.editAlias(alias, oldCanvasAlias);
   let canvasElement;
@@ -61975,14 +62107,23 @@ async function showWithFadeTransition(alias, image, props = {}, priority) {
       aliasToRemoveAfter: oldCanvasAlias
     }, void 0, priority)
   ]);
-  id1 && canvas.addTickerMustBeCompletedBeforeNextStep({ id: id1, alias });
-  id22 && canvas.addTickerMustBeCompletedBeforeNextStep({ id: id22, alias });
+  let res = void 0;
+  if (id1) {
+    res = [id1];
+    mustBeCompletedBeforeNextStep && canvas.addTickerMustBeCompletedBeforeNextStep({ id: id1, alias });
+  }
+  if (id22) {
+    res ? res.push(id22) : res = [id22];
+    mustBeCompletedBeforeNextStep && canvas.addTickerMustBeCompletedBeforeNextStep({ id: id22, alias });
+  }
+  return res;
 }
 function removeWithFadeTransition(alias, props = {}, priority) {
   return removeWithDissolveTransition(alias, props, priority);
 }
 async function moveIn(alias, image, props = {}, priority) {
   let direction = props.direction || "right";
+  let mustBeCompletedBeforeNextStep = props.mustBeCompletedBeforeNextStep ?? true;
   let tickerAliasToResume = typeof props.tickerAliasToResume === "string" ? [props.tickerAliasToResume] : props.tickerAliasToResume || [];
   tickerAliasToResume.push(alias);
   let canvasElement;
@@ -62023,10 +62164,15 @@ async function moveIn(alias, image, props = {}, priority) {
   let id3 = canvas.addTicker(alias, effect);
   if (id3) {
     canvas.putOnPauseTicker(alias, id3);
+    mustBeCompletedBeforeNextStep && canvas.addTickerMustBeCompletedBeforeNextStep({ id: id3 });
+    return [id3];
   }
 }
 function moveOut(alias, props = {}, priority) {
   let direction = props.direction || "right";
+  let mustBeCompletedBeforeNextStep = props.mustBeCompletedBeforeNextStep ?? true;
+  let tickerAliasToResume = typeof props.tickerAliasToResume === "string" ? [props.tickerAliasToResume] : props.tickerAliasToResume || [];
+  tickerAliasToResume.push(alias);
   let canvasElement = canvas.find(alias);
   if (!canvasElement) {
     console.warn("[Pixi\u2019VN] The canvas element is not found.");
@@ -62049,13 +62195,20 @@ function moveOut(alias, props = {}, priority) {
   }
   let effect = new MoveTicker({
     ...props,
+    tickerAliasToResume,
     destination,
     startOnlyIfHaveTexture: true,
     aliasToRemoveAfter: alias
   }, void 0, priority);
-  canvas.addTicker(alias, effect);
+  let id3 = canvas.addTicker(alias, effect);
+  if (id3) {
+    canvas.putOnPauseTicker(alias, id3);
+    mustBeCompletedBeforeNextStep && canvas.addTickerMustBeCompletedBeforeNextStep({ id: id3 });
+    return [id3];
+  }
 }
 async function zoomIn(alias, image, props = { direction: "right" }, priority) {
+  let mustBeCompletedBeforeNextStep = props.mustBeCompletedBeforeNextStep ?? true;
   let tickerAliasToResume = typeof props.tickerAliasToResume === "string" ? [props.tickerAliasToResume] : props.tickerAliasToResume || [];
   tickerAliasToResume.push(alias);
   let canvasElement;
@@ -62068,7 +62221,9 @@ async function zoomIn(alias, image, props = { direction: "right" }, priority) {
   } else {
     canvasElement = image;
   }
-  canvas.copyCanvasElementProperty(alias, canvasElement);
+  if (canvas.find(alias)) {
+    canvas.copyCanvasElementProperty(alias, canvasElement);
+  }
   let container = new CanvasContainer();
   container.addChild(canvasElement);
   container.height = canvas.canvasHeight;
@@ -62110,9 +62265,14 @@ async function zoomIn(alias, image, props = { direction: "right" }, priority) {
   let id3 = canvas.addTicker(alias, effect);
   if (id3) {
     canvas.putOnPauseTicker(alias, id3);
+    mustBeCompletedBeforeNextStep && canvas.addTickerMustBeCompletedBeforeNextStep({ id: id3 });
+    return [id3];
   }
 }
 function zoomOut(alias, props = { direction: "right" }, priority) {
+  let mustBeCompletedBeforeNextStep = props.mustBeCompletedBeforeNextStep ?? true;
+  let tickerAliasToResume = typeof props.tickerAliasToResume === "string" ? [props.tickerAliasToResume] : props.tickerAliasToResume || [];
+  tickerAliasToResume.push(alias);
   let canvasElement = canvas.find(alias);
   if (!canvasElement) {
     console.warn("[Pixi\u2019VN] The canvas element is not found.");
@@ -62147,13 +62307,116 @@ function zoomOut(alias, props = { direction: "right" }, priority) {
   container.scale.set(1);
   let effect = new ZoomTicker({
     ...props,
+    tickerAliasToResume,
     startOnlyIfHaveTexture: true,
     type: "unzoom",
     limit: 0,
     aliasToRemoveAfter: alias,
     isZoomInOut: true
   }, void 0, priority);
-  canvas.addTicker(alias, effect);
+  let id3 = canvas.addTicker(alias, effect);
+  if (id3) {
+    canvas.putOnPauseTicker(alias, id3);
+    mustBeCompletedBeforeNextStep && canvas.addTickerMustBeCompletedBeforeNextStep({ id: id3 });
+    return [id3];
+  }
+}
+async function pushIn(alias, image, props = { direction: "right" }, priority) {
+  let oldCanvasAlias = alias + "_temp_push";
+  let mustBeCompletedBeforeNextStep = props.mustBeCompletedBeforeNextStep ?? true;
+  let tickerAliasToResume = typeof props.tickerAliasToResume === "string" ? [props.tickerAliasToResume] : props.tickerAliasToResume || [];
+  tickerAliasToResume.push(alias);
+  let canvasElement;
+  if (typeof image === "string") {
+    if (checkIfVideo(image)) {
+      canvasElement = new CanvasVideo({}, image);
+    } else {
+      canvasElement = new CanvasImage({}, image);
+    }
+  } else {
+    canvasElement = image;
+  }
+  let oldCanvas = canvas.find(alias);
+  if (oldCanvas) {
+    canvas.copyCanvasElementProperty(oldCanvas, canvasElement);
+    canvas.editAlias(alias, oldCanvasAlias, { ignoreTickers: true });
+    pushOut(oldCanvasAlias, props, priority);
+  }
+  let container = new CanvasContainer();
+  container.height = canvas.canvasHeight;
+  container.width = canvas.canvasWidth;
+  container.addChild(canvasElement);
+  canvas.add(alias, container, { ignoreOldStyle: true });
+  if (canvasElement instanceof CanvasImage && canvasElement.texture?.label == "EMPTY") {
+    await canvasElement.load();
+  }
+  if (props.direction == "up") {
+    container.x = 0;
+    container.y = -canvas.canvasHeight;
+  } else if (props.direction == "down") {
+    container.x = 0;
+    container.y = canvas.canvasHeight;
+  } else if (props.direction == "left") {
+    container.x = canvas.canvasWidth;
+    container.y = 0;
+  } else if (props.direction == "right") {
+    container.x = -canvas.canvasWidth;
+    container.y = 0;
+  }
+  let effect = new MoveTicker({
+    ...props,
+    tickerAliasToResume,
+    startOnlyIfHaveTexture: true,
+    isPushInOut: true,
+    destination: { x: 0, y: 0 }
+  }, void 0, priority);
+  let id3 = canvas.addTicker(alias, effect);
+  if (id3) {
+    canvas.putOnPauseTicker(alias, id3);
+    mustBeCompletedBeforeNextStep && canvas.addTickerMustBeCompletedBeforeNextStep({ id: id3 });
+    return [id3];
+  }
+}
+function pushOut(alias, props = { direction: "right" }, priority) {
+  let mustBeCompletedBeforeNextStep = props.mustBeCompletedBeforeNextStep ?? true;
+  let tickerAliasToResume = typeof props.tickerAliasToResume === "string" ? [props.tickerAliasToResume] : props.tickerAliasToResume || [];
+  tickerAliasToResume.push(alias);
+  let canvasElement = canvas.find(alias);
+  if (!canvasElement) {
+    console.warn("[Pixi\u2019VN] The canvas element is not found.");
+    return;
+  }
+  let container = new CanvasContainer();
+  container.pivot.x = 0;
+  container.pivot.y = 0;
+  container.x = 0;
+  container.y = 0;
+  container.addChild(canvasElement);
+  canvas.add(alias, container, { ignoreOldStyle: true });
+  let destination = { x: 0, y: 0 };
+  if (props.direction == "up") {
+    destination.y = canvas.canvasHeight;
+  } else if (props.direction == "down") {
+    destination.y = -canvas.canvasHeight;
+  } else if (props.direction == "left") {
+    destination.x = -canvas.canvasWidth;
+  } else if (props.direction == "right") {
+    destination.x = canvas.canvasWidth;
+  }
+  let effect = new MoveTicker({
+    ...props,
+    tickerAliasToResume,
+    startOnlyIfHaveTexture: true,
+    destination,
+    aliasToRemoveAfter: alias,
+    isPushInOut: true
+  }, void 0, priority);
+  let id3 = canvas.addTicker(alias, effect);
+  if (id3) {
+    canvas.putOnPauseTicker(alias, id3);
+    mustBeCompletedBeforeNextStep && canvas.addTickerMustBeCompletedBeforeNextStep({ id: id3 });
+    return [id3];
+  }
 }
 
 // src/functions/dialogue-utility.ts
@@ -62207,7 +62470,7 @@ function clearAllGameDatas() {
 // src/functions/saves-utility.ts
 function getSaveData() {
   return {
-    pixivn_version: PIXIVN_VERSION,
+    pixivn_version: version,
     stepData: narration.export(),
     storageData: storage.export(),
     canvasData: canvas.export(),
@@ -62252,12 +62515,15 @@ function jsonToSaveData(json) {
   loadVideo,
   moveIn,
   moveOut,
+  pushIn,
+  pushOut,
   removeCanvasElement,
   removeWithDissolveTransition,
   removeWithFadeTransition,
   setChoiceMenuOptions,
   setDialogue,
   setFlag,
+  shakeEffect,
   showImage,
   showVideo,
   showWithDissolveTransition,