@drincs/pixi-vn 0.6.1 → 0.6.2

package/dist/labels/TintingTestLabel.mjs

@@ -1,1780 +0,0 @@
-import { Rectangle, Sprite, Container, Application, Assets, Texture, Text } from 'pixi.js';
-import 'deep-diff';
-import sha1 from 'crypto-js/sha1';
-
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-
-// src/decorators/CanvasElementDecorator.ts
-var registeredCanvasElement = {};
-function canvasElementDecorator(name) {
-  return function(target) {
-    if (!name) {
-      name = target.name;
-    }
-    if (registeredCanvasElement[name]) {
-      console.warn(`[Pixi'VN] CanvasElement ${name} already registered`);
-    }
-    registeredCanvasElement[name] = target;
-  };
-}
-function getCanvasElementInstanceByClassName(canvasName) {
-  try {
-    let eventType = registeredCanvasElement[canvasName];
-    if (!eventType) {
-      if (canvasName === "CanvasContainer") {
-        eventType = CanvasContainer;
-      } else if (canvasName === "CanvasImage") {
-        eventType = CanvasImage;
-      } else if (canvasName === "CanvasSprite") {
-        eventType = CanvasSprite;
-      } else if (canvasName === "CanvasText") {
-        eventType = CanvasText;
-      }
-    }
-    if (!eventType) {
-      console.error(`[Pixi'VN] CanvasElement ${canvasName} not found`);
-      return;
-    }
-    let canvasElement = new eventType();
-    return canvasElement;
-  } catch (e) {
-    console.error(`[Pixi'VN] Error while getting CanvasElement ${canvasName}`, e);
-    return;
-  }
-}
-
-// src/functions/CanvasUtility.ts
-function getTextureMemory(texture) {
-  let sourceTexture = texture.source;
-  let textureMemory = {
-    image: sourceTexture.label
-  };
-  return textureMemory;
-}
-function exportCanvasElement(element) {
-  return element.memory;
-}
-function importCanvasElement(memory) {
-  let element = getCanvasElementInstanceByClassName(memory.className);
-  if (element) {
-    element.memory = memory;
-  } else {
-    throw new Error("[Pixi'VN] The element " + memory.className + " could not be created");
-  }
-  return element;
-}
-
-// src/classes/canvas/CanvasContainer.ts
-var CanvasContainer = class extends Container {
-  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) {
-  return {
-    className: "CanvasContainer",
-    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,
-    culled: element.culled,
-    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) {
-  memory.width && (element.width = memory.width);
-  memory.height && (element.height = memory.height);
-  memory.isRenderGroup && (element.isRenderGroup = memory.isRenderGroup);
-  memory.blendMode && (element.blendMode = memory.blendMode);
-  memory.tint && (element.tint = memory.tint);
-  memory.alpha && (element.alpha = memory.alpha);
-  memory.angle && (element.angle = memory.angle);
-  memory.renderable && (element.renderable = memory.renderable);
-  memory.rotation && (element.rotation = memory.rotation);
-  if (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 (memory.pivot) {
-    if (typeof memory.pivot === "number") {
-      element.pivot.set(memory.pivot, memory.pivot);
-    } else {
-      element.pivot.set(memory.pivot.x, memory.pivot.y);
-    }
-  }
-  memory.position && element.position.set(memory.position.x, memory.position.y);
-  memory.skew && element.skew.set(memory.skew.x, memory.skew.y);
-  memory.visible && (element.visible = memory.visible);
-  memory.culled && (element.culled = memory.culled);
-  memory.x && (element.x = memory.x);
-  memory.y && (element.y = memory.y);
-  memory.boundsArea && (element.boundsArea = memory.boundsArea);
-  memory.cursor && (element.cursor = memory.cursor);
-  memory.eventMode && (element.eventMode = memory.eventMode);
-  memory.interactive && (element.interactive = memory.interactive);
-  memory.interactiveChildren && (element.interactiveChildren = memory.interactiveChildren);
-  memory.hitArea && (element.hitArea = memory.hitArea);
-}
-function getTexture(imageUrl) {
-  return __async(this, null, function* () {
-    if (Assets.cache.has(imageUrl)) {
-      return Assets.get(imageUrl);
-    }
-    return Assets.load(imageUrl).then((texture) => {
-      if (!texture) {
-        console.error("[Pixi'VN] Texture not found", imageUrl);
-        return;
-      }
-      if (!(texture instanceof Texture)) {
-        console.error("[Pixi'VN] File not is a image", imageUrl);
-        return;
-      }
-      return texture;
-    }).catch((e) => {
-      console.error("[Pixi'VN] Error loading image", e);
-      return;
-    });
-  });
-}
-function getTextStyle(style) {
-  let fill = style.fill;
-  if (fill instanceof Object) {
-    console.warn("[Pixi'VN] CanvasText.style.fill is a FillGradient or FillPattern, this is not supported yet.", fill);
-    fill = "#00FF00";
-  }
-  return {
-    align: style.align,
-    breakWords: style.breakWords,
-    dropShadow: style.dropShadow,
-    fill,
-    fontFamily: style.fontFamily,
-    fontSize: style.fontSize,
-    fontStyle: style.fontStyle,
-    fontVariant: style.fontVariant,
-    fontWeight: style.fontWeight,
-    leading: style.leading,
-    letterSpacing: style.letterSpacing,
-    lineHeight: style.lineHeight,
-    padding: style.padding,
-    stroke: style.stroke,
-    textBaseline: style.textBaseline,
-    trim: style.trim,
-    whiteSpace: style.whiteSpace,
-    wordWrap: style.wordWrap,
-    wordWrapWidth: style.wordWrapWidth
-  };
-}
-
-// src/decorators/EventDecorator.ts
-var registeredEvents = {};
-function getEventTypeByClassName(eventName) {
-  try {
-    let eventType = registeredEvents[eventName];
-    if (!eventType) {
-      console.error(`[Pixi'VN] Event ${eventName} not found`);
-      return;
-    }
-    new eventType();
-    return eventType;
-  } catch (e) {
-    console.error(`[Pixi'VN] Error while getting Event ${eventName}`, e);
-    return;
-  }
-}
-function getEventInstanceByClassName(eventName) {
-  try {
-    let eventType = registeredEvents[eventName];
-    if (!eventType) {
-      console.error(`[Pixi'VN] Event ${eventName} not found`);
-      return;
-    }
-    let event = new eventType();
-    return event;
-  } catch (e) {
-    console.error(`[Pixi'VN] Error while getting Event ${eventName}`, e);
-    return;
-  }
-}
-
-// src/classes/canvas/CanvasSprite.ts
-var CanvasSprite = class _CanvasSprite extends Sprite {
-  constructor() {
-    super(...arguments);
-    this._onEvents = {};
-  }
-  get memory() {
-    return getMemorySprite(this);
-  }
-  set memory(value) {
-    setMemorySprite(this, value);
-  }
-  get onEvents() {
-    return this._onEvents;
-  }
-  /**
-   * 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<CanvasSprite> {
-   *     override fn(event: CanvasEventNamesType, sprite: CanvasSprite): 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);
-   *
-   * GameWindowManager.addCanvasElement("bunny", sprite);
-   * ```
-   */
-  onEvent(event, eventClass) {
-    let className = eventClass.name;
-    let instance = getEventInstanceByClassName(className);
-    this._onEvents[event] = className;
-    if (instance) {
-      super.on(event, () => {
-        instance.fn(event, this);
-      });
-    }
-    return this;
-  }
-  /**
-   * on() does not keep in memory the event class, use onEvent() instead
-   * @deprecated
-   * @private
-   * @param event 
-   * @param fn 
-   * @param context 
-   */
-  on(event, fn, context) {
-    return super.on(event, fn, context);
-  }
-  static from(source, skipCache) {
-    let sprite = Sprite.from(source, skipCache);
-    let mySprite = new _CanvasSprite();
-    mySprite.texture = sprite.texture;
-    return mySprite;
-  }
-};
-function getMemorySprite(element) {
-  let temp = getMemoryContainer(element);
-  return __spreadProps(__spreadValues({}, temp), {
-    className: "CanvasSprite",
-    textureImage: getTextureMemory(element.texture),
-    anchor: { x: element.anchor.x, y: element.anchor.y },
-    roundPixels: element.roundPixels,
-    onEvents: element.onEvents
-  });
-}
-function setMemorySprite(element, memory) {
-  setMemoryContainer(element, memory);
-  getTexture(memory.textureImage.image).then((texture) => {
-    if (texture) {
-      element.texture = texture;
-    }
-  });
-  if (memory.anchor) {
-    if (typeof memory.anchor === "number") {
-      element.anchor.set(memory.anchor, memory.anchor);
-    } else {
-      element.anchor.set(memory.anchor.x, memory.anchor.y);
-    }
-  }
-  memory.roundPixels && (element.roundPixels = memory.roundPixels);
-  for (let event in memory.onEvents) {
-    let className = memory.onEvents[event];
-    let instance = getEventTypeByClassName(className);
-    if (instance) {
-      element.onEvent(event, instance);
-    }
-  }
-}
-
-// src/classes/canvas/CanvasImage.ts
-var CanvasImage = class _CanvasImage extends CanvasSprite {
-  constructor(options, imageLink) {
-    super(options);
-    this.imageLink = "";
-    if (imageLink) {
-      this.imageLink = imageLink;
-    }
-  }
-  get memory() {
-    return __spreadProps(__spreadValues({}, getMemorySprite(this)), {
-      className: "CanvasImage",
-      textureImage: { image: this.imageLink }
-    });
-  }
-  set memory(memory) {
-    setMemorySprite(this, memory);
-  }
-  static from(source, skipCache) {
-    let sprite = Sprite.from(source, skipCache);
-    let mySprite = new _CanvasImage();
-    mySprite.texture = sprite.texture;
-    return mySprite;
-  }
-  /** 
-   * Load the image from the link and set the texture of the sprite.
-   * @param image The link of the image. If it is not set, it will use the imageLink property.
-   * @returns A promise that resolves when the image is loaded.
-   */
-  load(image) {
-    return __async(this, null, function* () {
-      if (!image) {
-        image = this.imageLink;
-      }
-      return getTexture(this.imageLink).then((texture) => {
-        if (texture) {
-          this.texture = texture;
-        }
-      }).catch((e) => {
-        console.error("[Pixi'VN] Error into CanvasImage.load()", e);
-      });
-    });
-  }
-};
-var CanvasText = class extends Text {
-  constructor() {
-    super(...arguments);
-    this._onEvents = {};
-  }
-  get memory() {
-    return getMemoryText(this);
-  }
-  set memory(value) {
-    setMemoryText(this, value);
-  }
-  get onEvents() {
-    return this._onEvents;
-  }
-  /**
-   * 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<CanvasText> {
-   *     override fn(event: CanvasEventNamesType, text: CanvasText): void {
-   *         if (event === 'pointerdown') {
-   *             text.scale.x *= 1.25;
-   *             text.scale.y *= 1.25;
-   *         }
-   *     }
-   * }
-   * ```
-   * 
-   * ```typescript
-   * const text = new CanvasText();
-   * text.text = "Hello World"
-   *
-   * text.eventMode = 'static';
-   * text.cursor = 'pointer';
-   * text.onEvent('pointerdown', EventTest);
-   *
-   * GameWindowManager.addCanvasElement("text", text);
-   * ```
-   */
-  onEvent(event, eventClass) {
-    let className = eventClass.name;
-    let instance = getEventInstanceByClassName(className);
-    this._onEvents[event] = className;
-    if (instance) {
-      super.on(event, () => {
-        instance.fn(event, this);
-      });
-    }
-    return this;
-  }
-  /**
-   * on() does not keep in memory the event class, use onEvent() instead
-   * @deprecated
-   * @private
-   * @param event 
-   * @param fn 
-   * @param context 
-   */
-  on(event, fn, context) {
-    return super.on(event, fn, context);
-  }
-};
-function getMemoryText(element) {
-  let temp = getMemoryContainer(element);
-  return __spreadProps(__spreadValues({}, temp), {
-    className: "CanvasText",
-    anchor: { x: element.anchor.x, y: element.anchor.y },
-    text: element.text,
-    resolution: element.resolution,
-    style: getTextStyle(element.style),
-    roundPixels: element.roundPixels,
-    onEvents: element.onEvents
-  });
-}
-function setMemoryText(element, memory) {
-  setMemoryContainer(element, memory);
-  if (memory.anchor) {
-    if (typeof memory.anchor === "number") {
-      element.anchor.set(memory.anchor, memory.anchor);
-    } else {
-      element.anchor.set(memory.anchor.x, memory.anchor.y);
-    }
-  }
-  memory.text && (element.text = memory.text);
-  memory.resolution && (element.resolution = memory.resolution);
-  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);
-    if (instance) {
-      element.onEvent(event, instance);
-    }
-  }
-}
-function checkIfStepsIsEqual(step1, step2) {
-  return step1 === step2;
-}
-
-// src/classes/Label.ts
-var Label = class {
-  /**
-   * @param id is the id of the label
-   * @param steps is the list of steps that the label will perform
-   * @param onStepRun is a function that will be executed before any step is executed, is useful for example to make sure all images used have been cached
-   * @param choiseIndex is the index of the choice that the label will perform
-   */
-  constructor(id, steps, onStepRun, choiseIndex) {
-    this._id = id;
-    this._steps = steps;
-    this._onStepRun = onStepRun;
-    this._choiseIndex = choiseIndex;
-  }
-  /**
-   * Get the id of the label
-   */
-  get id() {
-    return this._id;
-  }
-  /**
-   * Get the steps of the label.
-   * This class should be extended and the steps method should be overridden.
-   * Every time you update this list will also be updated when the other game versions load.
-   */
-  get steps() {
-    if (typeof this._steps === "function") {
-      return this._steps();
-    }
-    return this._steps;
-  }
-  /**
-   * Get the corresponding steps number
-   * @param externalSteps
-   * @returns Numer of corresponding steps, for example, if externalSteps is [ABC, DEF, GHI] and the steps of the label is [ABC, GHT], the result will be 1
-   */
-  getCorrespondingStepsNumber(externalSteps) {
-    if (externalSteps.length === 0) {
-      return 0;
-    }
-    let res = 0;
-    externalSteps.forEach((step, index) => {
-      if (checkIfStepsIsEqual(step, this.steps[index])) {
-        res = index;
-      }
-    });
-    return res;
-  }
-  /**
-   * Get the function that will be executed before any step is executed, is useful for example to make sure all images used have been cached
-   * @returns Promise<void> or void
-   * @example
-   * ```typescript
-   * newLabel("id", [], () => {
-   *     Assets.load('path/to/image1.png')
-   *     Assets.load('path/to/image2.png')
-   * })
-   * ```
-   */
-  get onStepRun() {
-    return this._onStepRun;
-  }
-  get choiseIndex() {
-    return this._choiseIndex;
-  }
-};
-
-// src/constants.ts
-var Repeat = "repeat";
-
-// src/functions/ExportUtility.ts
-function createExportableElement(element) {
-  try {
-    let elementString = JSON.stringify(element);
-    return JSON.parse(elementString);
-  } catch (e) {
-    console.error("[Pixi'VN] Error creating exportable element", e);
-    throw new Error("[Pixi'VN] Error creating exportable element");
-  }
-}
-
-// src/classes/ticker/TickerBase.ts
-var TickerBase = class {
-  /**
-   * @param args The arguments that you want to pass to the ticker.
-   * @param duration The duration of the ticker in seconds. If is undefined, the step will end only when the animation is finished (if the animation doesn't have a goal to reach then it won't finish). @default undefined
-   * @param priority The priority of the ticker. @default UPDATE_PRIORITY.NORMAL
-   */
-  constructor(args, duration, priority) {
-    this.args = args;
-    this.duration = duration;
-    this.priority = priority;
-  }
-  /**
-   * The method that will be called every frame.
-   * This method should be overridden and you can use GameWindowManager.addCanvasElement() to get the canvas element of the canvas, and edit them.
-   * @param _ticker The ticker that is calling this method
-   * @param _args The arguments that you passed when you added the ticker
-   * @param _tags The tags of the canvas elements that are connected to this ticker
-   * @param _tickerId The id of the ticker. You can use this to get the ticker from the {@link GameWindowManager.currentTickers}
-   */
-  fn(_ticker, _args, _tags, _tickerId) {
-    throw new Error("[Pixi'VN] The method TickerBase.fn() must be overridden");
-  }
-};
-
-// src/decorators/TickerDecorator.ts
-var registeredTickers = {};
-function tickerDecorator(name) {
-  return function(target) {
-    if (!name) {
-      name = target.name;
-    }
-    if (registeredTickers[name]) {
-      console.info(`[Pixi'VN] Ticker ${name} already exists, it will be overwritten`);
-    }
-    registeredTickers[name] = target;
-  };
-}
-function geTickerInstanceByClassName(tickerName, args, duration, priority) {
-  try {
-    let ticker = registeredTickers[tickerName];
-    if (!ticker) {
-      console.error(`[Pixi'VN] Ticker ${tickerName} not found`);
-      return;
-    }
-    return new ticker(args, duration, priority);
-  } catch (e) {
-    console.error(`[Pixi'VN] Error while getting Ticker ${tickerName}`, e);
-    return;
-  }
-}
-
-// src/functions/EasterEgg.ts
-function asciiArtLog() {
-  console.info(`
-    ____  _      _ ___     ___   _ 
-    |  _ \\(_)_  _(_| ) \\   / / \\ | |
-    | |_) | \\ \\/ / |/ \\ \\ / /|  \\| |
-    |  __/| |>  <| |   \\ V / | |\\  |
-    |_|   |_/_/\\_\\_|    \\_/  |_| \\_|
-    `);
-}
-
-// src/types/ticker/TagToRemoveAfterType.ts
-var tagToRemoveAfter = "tagToRemoveAfter";
-
-// src/managers/WindowManager.ts
-var _GameWindowManager = class _GameWindowManager {
-  constructor() {
-  }
-  /**
-   * The PIXI Application instance.
-   * It not recommended to use this property directly.
-   */
-  static get app() {
-    if (!_GameWindowManager._app) {
-      throw new Error("[Pixi'VN] GameWindowManager.app is undefined");
-    }
-    return _GameWindowManager._app;
-  }
-  /**
-   * If the manager is initialized.
-   */
-  static get isInitialized() {
-    return _GameWindowManager._isInitialized;
-  }
-  static get screen() {
-    return _GameWindowManager.app.screen;
-  }
-  /**
-   * Initialize the PIXI Application and the interface div.
-   * This method should be called before any other method.
-   * @param element The html element where I will put the canvas. Example: document.body
-   * @param width The width of the canvas
-   * @param height The height of the canvas
-   * @param options The options of PIXI Application
-   * @example
-   * ```typescript
-   * const body = document.body
-   * if (!body) {
-   *     throw new Error('body element not found')
-   * }
-   * await GameWindowManager.initialize(body, 1920, 1080, {
-   *     backgroundColor: "#303030"
-   * })
-   * ```
-   */
-  static initialize(element, width, height, options) {
-    return __async(this, null, function* () {
-      _GameWindowManager.canvasWidth = width;
-      _GameWindowManager.canvasHeight = height;
-      _GameWindowManager._app = new Application();
-      return _GameWindowManager.app.init(__spreadValues({
-        resolution: window.devicePixelRatio || 1,
-        autoDensity: true,
-        width,
-        height
-      }, options)).then(() => {
-        _GameWindowManager._isInitialized = true;
-        this.addCanvasIntoElement(element);
-        window.addEventListener("resize", _GameWindowManager.resize);
-        _GameWindowManager.resize();
-        asciiArtLog();
-      });
-    });
-  }
-  /**
-   * Add the canvas into a html element.
-   * @param element it is the html element where I will put the canvas. Example: document.body
-   */
-  static addCanvasIntoElement(element) {
-    if (_GameWindowManager.isInitialized) {
-      element.appendChild(_GameWindowManager.app.canvas);
-    } else {
-      console.error("[Pixi'VN] GameWindowManager is not initialized");
-    }
-  }
-  /**
-   * Initialize the interface div and add it into a html element.
-   * @param element it is the html element where I will put the interface div. Example: document.getElementById('root')
-   * @example
-   * ```tsx
-   * const root = document.getElementById('root')
-   * if (!root) {
-   *     throw new Error('root element not found')
-   * }
-   * GameWindowManager.initializeHTMLLayout(root)
-   * const reactRoot = createRoot(GameWindowManager.htmlLayout)
-   * reactRoot.render(
-   *     <App />
-   * )
-   * ```
-   */
-  static initializeHTMLLayout(element) {
-    let div = document.createElement("div");
-    div.style.position = "absolute";
-    div.style.pointerEvents = "none";
-    element.appendChild(div);
-    _GameWindowManager.htmlLayout = div;
-    _GameWindowManager.resize();
-  }
-  /* Resize Metods */
-  /**
-   * This method returns the scale of the screen.
-   */
-  static get screenScale() {
-    let screenWidth = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);
-    let screenHeight = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);
-    return Math.min(screenWidth / _GameWindowManager.canvasWidth, screenHeight / _GameWindowManager.canvasHeight);
-  }
-  /**
-   * This method returns the width of the screen enlarged by the scale.
-   */
-  static get screenWidth() {
-    return Math.floor(_GameWindowManager.screenScale * _GameWindowManager.canvasWidth);
-  }
-  /**
-   * This method returns the height of the screen enlarged by the scale.
-   */
-  static get screenHeight() {
-    return Math.floor(_GameWindowManager.screenScale * _GameWindowManager.canvasHeight);
-  }
-  /**
-   * This method returns the horizontal margin of the screen.
-   */
-  static get horizontalMargin() {
-    let screenWidth = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);
-    return (screenWidth - _GameWindowManager.screenWidth) / 2;
-  }
-  /**
-   * This method returns the vertical margin of the screen.
-   */
-  static get verticalMargin() {
-    let screenHeight = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);
-    return (screenHeight - _GameWindowManager.screenHeight) / 2;
-  }
-  /**
-   * This method is called when the screen is resized.
-   */
-  static resize() {
-    if (_GameWindowManager.isInitialized) {
-      let style = _GameWindowManager.app.canvas.style;
-      style.width = `${_GameWindowManager.screenWidth}px`;
-      style.height = `${_GameWindowManager.screenHeight}px`;
-      style.marginLeft = `${_GameWindowManager.horizontalMargin}px`;
-      style.marginRight = `${_GameWindowManager.horizontalMargin}px`;
-      style.marginTop = `${_GameWindowManager.verticalMargin}px`;
-      style.marginBottom = `${_GameWindowManager.verticalMargin}px`;
-    }
-    if (_GameWindowManager.htmlLayout) {
-      _GameWindowManager.htmlLayout.style.width = `${_GameWindowManager.screenWidth}px`;
-      _GameWindowManager.htmlLayout.style.height = `${_GameWindowManager.screenHeight}px`;
-      _GameWindowManager.htmlLayout.style.marginLeft = `${_GameWindowManager.horizontalMargin}px`;
-      _GameWindowManager.htmlLayout.style.marginRight = `${_GameWindowManager.horizontalMargin}px`;
-      _GameWindowManager.htmlLayout.style.marginTop = `${_GameWindowManager.verticalMargin}px`;
-      _GameWindowManager.htmlLayout.style.marginBottom = `${_GameWindowManager.verticalMargin}px`;
-    }
-  }
-  /* Edit Canvas Elements Methods */
-  /**
-   * This is a dictionary that contains all Canvas Elements of Canvas, currently.
-   */
-  static get currentCanvasElements() {
-    return _GameWindowManager._children;
-  }
-  /**
-   * Add a canvas element to the canvas.
-   * If there is a canvas element with the same tag, it will be removed.
-   * @param tag The tag of the canvas element.
-   * @param canvasElement The canvas elements to be added.
-   * @example
-   * ```typescript
-   * const texture = await Assets.load('https://pixijs.com/assets/bunny.png');
-   * const sprite = CanvasSprite.from(texture);
-   * GameWindowManager.addCanvasElement("bunny", sprite);
-   * ```
-   */
-  static addCanvasElement(tag, canvasElement) {
-    if (_GameWindowManager._children[tag]) {
-      _GameWindowManager.removeCanvasElement(tag);
-    }
-    _GameWindowManager.app.stage.addChild(canvasElement);
-    _GameWindowManager._children[tag] = canvasElement;
-    _GameWindowManager.childrenTagsOrder.push(tag);
-  }
-  /**
-   * Remove a canvas element from the canvas.
-   * And remove all tickers that are not connected to any canvas element.
-   * @param tags The tag of the canvas element to be removed.
-   * @returns 
-   * @example
-   * ```typescript
-   * GameWindowManager.removeCanvasElement("bunny");
-   * ```
-   */
-  static removeCanvasElement(tags) {
-    if (typeof tags === "string") {
-      tags = [tags];
-    }
-    tags.forEach((tag) => {
-      if (_GameWindowManager._children[tag]) {
-        _GameWindowManager.app.stage.removeChild(_GameWindowManager._children[tag]);
-        delete _GameWindowManager._children[tag];
-        _GameWindowManager.removeTickerByCanvasElement(tag);
-      }
-    });
-    _GameWindowManager.childrenTagsOrder = _GameWindowManager.childrenTagsOrder.filter((t) => !tags.includes(t));
-  }
-  /**
-   * Get a canvas element by the tag.
-   * @param tag The tag of the canvas element.
-   * @returns The canvas element.
-   * @example
-   * ```typescript
-   * const sprite = GameWindowManager.getCanvasElement<CanvasSprite>("bunny");
-   * ```
-   */
-  static getCanvasElement(tag) {
-    return _GameWindowManager._children[tag];
-  }
-  /**
-   * Check if a DisplayObject is on the canvas.
-   * @param pixiElement The DisplayObject to be checked.
-   * @returns If the DisplayObject is on the canvas.
-   */
-  static canvasElementIsOnCanvas(pixiElement) {
-    return _GameWindowManager.app.stage.children.includes(pixiElement);
-  }
-  /**
-   * Remove all canvas elements from the canvas.
-   * And remove all tickers that are not connected to any canvas element.
-   */
-  static removeCanvasElements() {
-    _GameWindowManager.app.stage.removeChildren();
-    _GameWindowManager._children = {};
-    _GameWindowManager.childrenTagsOrder = [];
-    _GameWindowManager.removeAllTickers();
-  }
-  /**
-   * Edit the tag of a canvas element.
-   * @param oldTag The old tag of the canvas element.
-   * @param newTag The new tag of the canvas element.
-   */
-  static editCanvasElementTag(oldTag, newTag) {
-    if (_GameWindowManager._children[oldTag]) {
-      _GameWindowManager._children[newTag] = _GameWindowManager._children[oldTag];
-      delete _GameWindowManager._children[oldTag];
-    }
-    if (_GameWindowManager._currentTickersSteps[oldTag]) {
-      _GameWindowManager._currentTickersSteps[newTag] = _GameWindowManager._currentTickersSteps[oldTag];
-      delete _GameWindowManager._currentTickersSteps[oldTag];
-    }
-    for (let id in _GameWindowManager._currentTickers) {
-      let ticker = _GameWindowManager._currentTickers[id];
-      if (ticker.canvasElementTags.includes(oldTag)) {
-        ticker.canvasElementTags = ticker.canvasElementTags.map((t) => t === oldTag ? newTag : t);
-        if (ticker.args.hasOwnProperty(tagToRemoveAfter)) {
-          let tagToRemoveAfter2 = ticker.args.tagToRemoveAfter;
-          if (typeof tagToRemoveAfter2 === "string") {
-            tagToRemoveAfter2 = [tagToRemoveAfter2];
-          }
-          if (Array.isArray(tagToRemoveAfter2)) {
-            ticker.args.tagToRemoveAfter = tagToRemoveAfter2.map((t) => t === oldTag ? newTag : t);
-          }
-        }
-      }
-    }
-    for (let timeout in _GameWindowManager._currentTickersTimeouts) {
-      let TickerTimeout = _GameWindowManager._currentTickersTimeouts[timeout];
-      if (TickerTimeout.tags.includes(oldTag)) {
-        TickerTimeout.tags = TickerTimeout.tags.map((t) => t === oldTag ? newTag : t);
-      }
-    }
-  }
-  /** Edit Tickers Methods */
-  /**
-   * Currently tickers that are running.
-   */
-  static get currentTickers() {
-    return _GameWindowManager._currentTickers;
-  }
-  static get currentTickersList() {
-    return Object.values(_GameWindowManager._currentTickers);
-  }
-  static get currentTickersWithoutCreatedBySteps() {
-    return Object.fromEntries(Object.entries(_GameWindowManager._currentTickers).filter(([_, ticker]) => !ticker.createdByTicketStepsId));
-  }
-  /**
-   * The steps of the tickers
-   */
-  static get currentTickersSteps() {
-    return _GameWindowManager._currentTickersSteps;
-  }
-  static generateTickerId(tickerData) {
-    try {
-      return sha1(JSON.stringify(tickerData)).toString() + "_" + Math.random().toString(36).substring(7);
-    } catch (e) {
-      throw new Error(`[Pixi'VN] Error to generate ticker id: ${e}`);
-    }
-  }
-  /**
-   * Run a ticker. You can run multiple addTicker with the same tag and different tickerClasses.
-   * If you run a ticker with the same tag and tickerClass, the old ticker will be removed.
-   * If already exists a sequence of tickers with the same tag, it will be removed.
-   * @param canvasEslementTag The tag of the canvas element that will use the ticker.
-   * @param ticker The ticker class to be run.
-   * @param args The arguments to be used in the ticker.
-   * @param duration The time to be used in the ticker. This number is in seconds. If it is undefined, the ticker will run forever.
-   * @param priority The priority to be used in the ticker.
-   * @returns 
-   * @example
-   * ```typescript
-   * GameWindowManager.addTicker("alien", new RotateTicker({ speed: 0.2 }))
-   * ```
-   */
-  static addTicker(canvasElementTag, ticker) {
-    let tickerName = ticker.constructor.name;
-    if (typeof canvasElementTag === "string") {
-      canvasElementTag = [canvasElementTag];
-    }
-    if (!geTickerInstanceByClassName(tickerName, ticker.args, ticker.duration, ticker.priority)) {
-      console.error(`[Pixi'VN] Ticker ${tickerName} not found`);
-      return;
-    }
-    let tickerHistory = {
-      fn: () => {
-      },
-      className: tickerName,
-      args: createExportableElement(ticker.args),
-      canvasElementTags: canvasElementTag,
-      priority: ticker.priority,
-      duration: ticker.duration
-    };
-    let id = _GameWindowManager.generateTickerId(tickerHistory);
-    _GameWindowManager.pushTicker(id, tickerHistory, ticker);
-    if (ticker.duration) {
-      let timeout = setTimeout(() => {
-        _GameWindowManager.removeTickerTimeoutInfo(timeout);
-        let tickerTimeoutInfo = _GameWindowManager._currentTickersTimeouts[timeout.toString()];
-        if (tickerTimeoutInfo) {
-          _GameWindowManager.removeTicker(id);
-        }
-      }, ticker.duration * 1e3);
-      _GameWindowManager.addTickerTimeoutInfo(canvasElementTag, tickerName, timeout.toString(), true);
-    }
-  }
-  static pushTicker(id, tickerData, ticker) {
-    _GameWindowManager.removeAssociationBetweenTickerCanvasElement(tickerData.canvasElementTags, tickerData);
-    _GameWindowManager._currentTickers[id] = tickerData;
-    tickerData.fn = (t) => {
-      let data = _GameWindowManager._currentTickers[id];
-      if (data) {
-        ticker == null ? void 0 : ticker.fn(t, data.args, data.canvasElementTags, id);
-      }
-    };
-    _GameWindowManager.app.ticker.add(tickerData.fn, void 0, tickerData.priority);
-  }
-  /**
-   * Run a sequence of tickers. If exists a ticker steps with the same tag, it will be removed.
-   * @param tag The tag of canvas element that will use the tickers.
-   * @param steps The steps of the tickers.
-   * @param currentStepNumber The current step number. It is used to continue the sequence of tickers.
-   * @returns
-   * @example
-   * ```typescript
-   * GameWindowManager.addTickersSteps("alien", [
-   *     new RotateTicker({ speed: 0.1, clockwise: true }, 2), // 2 seconds
-   *     Pause(1), // 1 second
-   *     new RotateTicker({ speed: 0.2, clockwise: false }, 2),
-   *     Repeat,
-   * ])
-   * ```
-   */
-  static addTickersSteps(tag, steps, currentStepNumber = 0) {
-    if (steps.length == 0) {
-      console.warn("[Pixi'VN] The steps of the tickers is empty");
-      return;
-    }
-    _GameWindowManager.removeTickerStepByCanvasElement(tag);
-    _GameWindowManager._currentTickersSteps[tag] = {
-      currentStepNumber,
-      steps: steps.map((step) => {
-        if (step === Repeat) {
-          return step;
-        }
-        if (step.hasOwnProperty("type") && step.type === "pause") {
-          return step;
-        }
-        let tickerName = step.constructor.name;
-        return {
-          ticker: tickerName,
-          args: createExportableElement(step.args),
-          duration: step.duration
-        };
-      })
-    };
-    _GameWindowManager.runTickersSteps(tag);
-  }
-  static restoneTickersSteps(data) {
-    for (let tag in data) {
-      let steps = data[tag];
-      _GameWindowManager._currentTickersSteps[tag] = steps;
-      _GameWindowManager.runTickersSteps(tag);
-    }
-  }
-  static runTickersSteps(tag) {
-    let step = _GameWindowManager._currentTickersSteps[tag].steps[_GameWindowManager._currentTickersSteps[tag].currentStepNumber];
-    if (step === Repeat) {
-      step = _GameWindowManager._currentTickersSteps[tag].steps[0];
-      _GameWindowManager._currentTickersSteps[tag].currentStepNumber = 0;
-      if (step === Repeat) {
-        console.error("[Pixi'VN] TikersSteps has a RepeatType in the first step");
-        return;
-      }
-    }
-    if (step.hasOwnProperty("type") && step.type === "pause") {
-      let timeout = setTimeout(() => {
-        let tickerTimeoutInfo = _GameWindowManager._currentTickersTimeouts[timeout.toString()];
-        if (tickerTimeoutInfo) {
-          tickerTimeoutInfo.tags.forEach((tag2) => {
-            _GameWindowManager.nextTickerStep(tag2);
-          });
-        }
-        _GameWindowManager.removeTickerTimeoutInfo(timeout);
-      }, step.duration * 1e3);
-      _GameWindowManager.addTickerTimeoutInfo(tag, "steps", timeout.toString(), false);
-      return;
-    }
-    let ticker = geTickerInstanceByClassName(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 tickerHistory = {
-      fn: () => {
-      },
-      className: tickerName,
-      args: createExportableElement(ticker.args),
-      canvasElementTags: [tag],
-      priority: ticker.priority,
-      duration: ticker.duration,
-      createdByTicketStepsId: tag
-    };
-    let id = _GameWindowManager.generateTickerId(tickerHistory);
-    _GameWindowManager.pushTicker(id, tickerHistory, ticker);
-    if (ticker.duration) {
-      let timeout = setTimeout(() => {
-        let tickerTimeoutInfo = _GameWindowManager._currentTickersTimeouts[timeout.toString()];
-        if (tickerTimeoutInfo) {
-          _GameWindowManager.removeTicker(id);
-          tickerTimeoutInfo.tags.forEach((tag2) => {
-            _GameWindowManager.nextTickerStep(tag2);
-          });
-        }
-        _GameWindowManager.removeTickerTimeoutInfo(timeout);
-      }, ticker.duration * 1e3);
-      _GameWindowManager.addTickerTimeoutInfo(tag, tickerName, timeout.toString(), false);
-    }
-  }
-  static nextTickerStep(tag) {
-    if (_GameWindowManager._currentTickersSteps[tag]) {
-      let steps = _GameWindowManager._currentTickersSteps[tag];
-      if (steps.currentStepNumber + 1 < steps.steps.length) {
-        steps.currentStepNumber++;
-        _GameWindowManager._currentTickersSteps[tag] = steps;
-        _GameWindowManager.runTickersSteps(tag);
-      } else {
-        _GameWindowManager.removeTickerStepByCanvasElement(tag);
-      }
-    }
-  }
-  static onEndOfTicker(canvasElementTags, ticker, canvasElementTagsToDelete, tickerId) {
-    let tickerData = _GameWindowManager._currentTickers[tickerId];
-    _GameWindowManager.removeAssociationBetweenTickerCanvasElement(canvasElementTags, ticker);
-    _GameWindowManager.removeCanvasElement(canvasElementTagsToDelete);
-    if (tickerData) {
-      _GameWindowManager.removeTicker(tickerId);
-      if (tickerData.duration == void 0 && tickerData.createdByTicketStepsId) {
-        _GameWindowManager.nextTickerStep(tickerData.createdByTicketStepsId);
-      }
-    }
-  }
-  /**
-   * Remove a connection between a canvas element and a ticker.
-   * And remove the ticker if there is no canvas element connected to it.
-   * @param tags The tag of the canvas element that will use the ticker.
-   * @param ticker The ticker class to be removed.
-   * @example
-   * ```typescript
-   * GameWindowManager.removeAssociationBetweenTickerCanvasElement("alien", RotateTicker)
-   * ```
-   */
-  static removeAssociationBetweenTickerCanvasElement(tags, ticker) {
-    let tickerName;
-    if (typeof ticker === "string") {
-      tickerName = ticker;
-    } else if (ticker instanceof TickerBase) {
-      tickerName = ticker.constructor.name;
-    } else {
-      tickerName = ticker.name;
-    }
-    if (typeof tags === "string") {
-      tags = [tags];
-    }
-    for (let id in _GameWindowManager._currentTickers) {
-      let ticker2 = _GameWindowManager._currentTickers[id];
-      if (ticker2.className === tickerName) {
-        _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) {
-        _GameWindowManager._currentTickersTimeouts[timeout].tags = TickerTimeout.tags.filter((t) => !tags.includes(t));
-      }
-    }
-    _GameWindowManager.removeTickersWithoutAssociatedCanvasElement();
-  }
-  /**
-   * Remove all tickers that are not connected to any existing canvas element.
-   */
-  static removeTickersWithoutAssociatedCanvasElement() {
-    for (let id in _GameWindowManager._currentTickers) {
-      let ticker = _GameWindowManager._currentTickers[id];
-      ticker.canvasElementTags = ticker.canvasElementTags.filter((e) => _GameWindowManager._children[e]);
-      if (ticker.canvasElementTags.length === 0) {
-        _GameWindowManager.removeTicker(id);
-      }
-    }
-    for (let tag in _GameWindowManager._currentTickersSteps) {
-      if (_GameWindowManager._children[tag] === void 0) {
-        delete _GameWindowManager._currentTickersSteps[tag];
-      }
-    }
-    Object.entries(_GameWindowManager._currentTickersTimeouts).forEach(([timeout, { tags }]) => {
-      if (tags.length === 0) {
-        _GameWindowManager.removeTickerTimeout(timeout);
-      }
-    });
-  }
-  static addTickerTimeoutInfo(tags, ticker, timeout, canBeDeletedBeforeEnd) {
-    if (typeof tags === "string") {
-      tags = [tags];
-    }
-    _GameWindowManager._currentTickersTimeouts[timeout] = {
-      tags,
-      ticker,
-      canBeDeletedBeforeEnd
-    };
-  }
-  static removeTickerTimeoutInfo(timeout) {
-    if (typeof timeout !== "string") {
-      timeout = timeout.toString();
-    }
-    if (_GameWindowManager._currentTickersTimeouts[timeout]) {
-      delete _GameWindowManager._currentTickersTimeouts[timeout];
-    }
-  }
-  static removeTickerTimeout(timeout) {
-    if (typeof timeout !== "string") {
-      timeout = timeout.toString();
-    }
-    clearTimeout(Number(timeout));
-    _GameWindowManager.removeTickerTimeoutInfo(timeout);
-  }
-  static removeTickerTimeoutsByTag(tag, checkCanBeDeletedBeforeEnd) {
-    for (let timeout in _GameWindowManager._currentTickersTimeouts) {
-      let tagsWithoutTagToRemove = _GameWindowManager._currentTickersTimeouts[timeout].tags.filter((t) => t !== tag);
-      if (tagsWithoutTagToRemove.length === 0) {
-        let canBeDeletedBeforeEnd = _GameWindowManager._currentTickersTimeouts[timeout].canBeDeletedBeforeEnd;
-        if (!checkCanBeDeletedBeforeEnd || canBeDeletedBeforeEnd) {
-          _GameWindowManager.removeTickerTimeout(timeout);
-        }
-      } else {
-        _GameWindowManager._currentTickersTimeouts[timeout].tags = tagsWithoutTagToRemove;
-      }
-    }
-  }
-  /**
-   * Remove all tickers from the canvas.
-   */
-  static removeAllTickers() {
-    _GameWindowManager._currentTickersSteps = {};
-    Object.keys(_GameWindowManager._currentTickers).forEach((id) => {
-      _GameWindowManager.removeTicker(id);
-    });
-    _GameWindowManager._currentTickers = {};
-    for (let timeout in _GameWindowManager._currentTickersTimeouts) {
-      _GameWindowManager.removeTickerTimeout(timeout);
-    }
-  }
-  /**
-   * Remove all tickers from a canvas element.
-   * @param tag The tag of the canvas element that will use the ticker.
-   */
-  static removeTickerByCanvasElement(tag) {
-    if (typeof tag === "string") {
-      tag = [tag];
-    }
-    tag.forEach((tag2) => {
-      for (let id in _GameWindowManager._currentTickers) {
-        let ticker = _GameWindowManager._currentTickers[id];
-        if (ticker.canvasElementTags.includes(tag2)) {
-          _GameWindowManager.removeTicker(id);
-        }
-      }
-      if (_GameWindowManager._currentTickersSteps[tag2]) {
-        delete _GameWindowManager._currentTickersSteps[tag2];
-      }
-      _GameWindowManager.removeTickerTimeoutsByTag(tag2, false);
-      delete _GameWindowManager._currentTickersSteps[tag2];
-    });
-  }
-  static removeTickerStepByCanvasElement(tag) {
-    if (_GameWindowManager._currentTickersSteps[tag]) {
-      delete _GameWindowManager._currentTickersSteps[tag];
-    }
-    for (let id in _GameWindowManager._currentTickers) {
-      let ticker = _GameWindowManager._currentTickers[id];
-      if (ticker.createdByTicketStepsId === tag) {
-        _GameWindowManager.removeTicker(id);
-      }
-    }
-  }
-  static removeTicker(tickerId) {
-    let ticker = _GameWindowManager._currentTickers[tickerId];
-    if (ticker) {
-      if (ticker.args.hasOwnProperty(tagToRemoveAfter)) {
-        let tagToRemoveAfter2 = ticker.args.tagToRemoveAfter;
-        _GameWindowManager.removeCanvasElement(tagToRemoveAfter2);
-      }
-      _GameWindowManager.app.ticker.remove(ticker.fn);
-      delete _GameWindowManager._currentTickers[tickerId];
-    }
-  }
-  /**
-   * Clear the canvas and the tickers.
-   */
-  static clear() {
-    _GameWindowManager.removeCanvasElements();
-  }
-  /* Export and Import Methods */
-  /**
-   * Export the canvas and the tickers to a JSON string.
-   * @returns The JSON string.
-   */
-  static exportJson() {
-    return JSON.stringify(this.export());
-  }
-  /**
-   * Export the canvas and the tickers to an object.
-   * @returns The object.
-   */
-  static export() {
-    let currentElements = {};
-    for (let tag in _GameWindowManager._children) {
-      currentElements[tag] = exportCanvasElement(_GameWindowManager._children[tag]);
-    }
-    return {
-      currentTickers: createExportableElement(_GameWindowManager.currentTickersWithoutCreatedBySteps),
-      currentTickersSteps: createExportableElement(_GameWindowManager._currentTickersSteps),
-      currentElements: createExportableElement(currentElements),
-      childrenTagsOrder: createExportableElement(_GameWindowManager.childrenTagsOrder)
-    };
-  }
-  /**
-   * Import the canvas and the tickers from a JSON string.
-   * @param dataString The JSON string.
-   */
-  static importJson(dataString) {
-    _GameWindowManager.import(JSON.parse(dataString));
-  }
-  /**
-   * Import the canvas and the tickers from an object.
-   * @param data The object.
-   */
-  static import(data) {
-    _GameWindowManager.clear();
-    try {
-      if (data.hasOwnProperty("childrenTagsOrder") && data.hasOwnProperty("currentElements")) {
-        let currentElements = data["currentElements"];
-        let childrenTagsOrder = data["childrenTagsOrder"];
-        childrenTagsOrder.forEach((tag) => {
-          if (currentElements[tag]) {
-            let element = importCanvasElement(currentElements[tag]);
-            _GameWindowManager.addCanvasElement(tag, element);
-            _GameWindowManager.childrenTagsOrder.push(tag);
-          }
-        });
-      } else {
-        console.error("[Pixi'VN] The data does not have the properties childrenTagsOrder and currentElements");
-        return;
-      }
-      if (data.hasOwnProperty("currentTickers")) {
-        let currentTickers = data["currentTickers"];
-        for (let id in currentTickers) {
-          let t = currentTickers[id];
-          let tags = t.canvasElementTags;
-          let ticker = geTickerInstanceByClassName(t.className, t.args, t.duration, t.priority);
-          if (ticker) {
-            _GameWindowManager.addTicker(tags, ticker);
-          } else {
-            console.error(`[Pixi'VN] Ticker ${t.className} not found`);
-          }
-        }
-      }
-      if (data.hasOwnProperty("currentTickersSteps")) {
-        let currentTickersSteps = data["currentTickersSteps"];
-        _GameWindowManager.restoneTickersSteps(currentTickersSteps);
-      }
-    } catch (e) {
-      console.error("[Pixi'VN] Error importing data", e);
-    }
-  }
-};
-_GameWindowManager._app = void 0;
-_GameWindowManager._isInitialized = false;
-_GameWindowManager._children = {};
-/**
- * The order of the children tags.
- */
-_GameWindowManager.childrenTagsOrder = [];
-_GameWindowManager._currentTickers = {};
-_GameWindowManager._currentTickersSteps = {};
-_GameWindowManager._currentTickersTimeouts = {};
-var GameWindowManager = _GameWindowManager;
-
-// src/decorators/LabelDecorator.ts
-var registeredLabels = {};
-function newLabel(id, steps, onStepRun) {
-  if (registeredLabels[id]) {
-    console.info(`[Pixi'VN] Label ${id} already exists, it will be overwritten`);
-  }
-  let label = new Label(id, steps, onStepRun);
-  registeredLabels[id] = label;
-  return label;
-}
-
-// src/classes/ticker/FadeAlphaTicker.ts
-var FadeAlphaTicker = class extends TickerBase {
-  fn(ticker, args, tags, tickerId) {
-    let type = args.type === void 0 ? "hide" : args.type;
-    let duration = args.duration === void 0 ? 1 : args.duration;
-    let speed = 1 / (duration * 60);
-    let limit = args.limit === void 0 ? type === "hide" ? 0 : 1 : args.limit;
-    let tagToRemoveAfter2 = args.tagToRemoveAfter || [];
-    if (typeof tagToRemoveAfter2 === "string") {
-      tagToRemoveAfter2 = [tagToRemoveAfter2];
-    }
-    if (type === "hide" && limit < 0) {
-      limit = 0;
-    }
-    if (type === "show" && limit > 1) {
-      limit = 1;
-    }
-    tags.filter((tag) => {
-      var _a;
-      let element = GameWindowManager.getCanvasElement(tag);
-      if (args.startOnlyIfHaveTexture) {
-        if (element && element instanceof Sprite && ((_a = element.texture) == null ? void 0 : _a.label) == "EMPTY") {
-          return false;
-        }
-      }
-      return true;
-    }).forEach((tag) => {
-      let element = GameWindowManager.getCanvasElement(tag);
-      if (element && element instanceof Container) {
-        if (type === "show" && element.alpha < limit) {
-          element.alpha += speed * ticker.deltaTime;
-        } else if (type === "hide" && element.alpha > limit) {
-          element.alpha -= speed * ticker.deltaTime;
-        }
-        if (type === "show" && element.alpha >= limit) {
-          element.alpha = limit;
-          GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
-        } else if (type === "hide" && element.alpha <= limit) {
-          element.alpha = limit;
-          GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
-        }
-      }
-    });
-  }
-};
-FadeAlphaTicker = __decorateClass([
-  tickerDecorator()
-], FadeAlphaTicker);
-
-// src/functions/TickerUtility.ts
-function updateTickerProgression(args, propertyName, progression) {
-  if (args[propertyName] === void 0 || !progression || args[propertyName] === progression.limit) {
-    return;
-  }
-  if (typeof args[propertyName] === "number") {
-    if (progression.type === "linear") {
-      args[propertyName] = getLinearProgression(args[propertyName], progression);
-    } else if (progression.type === "exponential") {
-      args[propertyName] = getExponentialProgression(args[propertyName], progression);
-    }
-  } else if (args[propertyName] !== void 0 && typeof args[propertyName] === "object" && args[propertyName].haveOwnProperty("x") && args[propertyName].haveOwnProperty("y") && typeof args[propertyName].x === "number" && typeof args[propertyName].y === "number") {
-    if (progression.type === "linear") {
-      args[propertyName].x = getLinearProgression(args[propertyName].x, progression);
-      args[propertyName].y = getLinearProgression(args[propertyName].y, progression);
-    } else if (progression.type === "exponential") {
-      args[propertyName].x = getExponentialProgression(args[propertyName].x, progression);
-      args[propertyName].y = getExponentialProgression(args[propertyName].y, progression);
-    }
-  }
-}
-function getLinearProgression(number, progression) {
-  if (progression.limit !== void 0) {
-    if (number > progression.limit && progression.amt > 0) {
-      return progression.limit;
-    } else if (number < progression.limit && progression.amt < 0) {
-      return progression.limit;
-    }
-  }
-  return number + progression.amt / 60;
-}
-function getExponentialProgression(number, progression) {
-  if (progression.limit !== void 0) {
-    if (number > progression.limit && progression.percentage > 0) {
-      return progression.limit;
-    } else if (number < progression.limit && progression.percentage < 0) {
-      return progression.limit;
-    }
-  }
-  return number + number * progression.percentage;
-}
-
-// src/classes/ticker/MoveTicker.ts
-var MoveTicker = class extends TickerBase {
-  fn(ticker, args, tags, tickerId) {
-    let xSpeed = 1;
-    let ySpeed = 1;
-    if (args.speed) {
-      if (typeof args.speed === "number") {
-        xSpeed = args.speed;
-        ySpeed = args.speed;
-      } else {
-        xSpeed = args.speed.x;
-        ySpeed = args.speed.y;
-      }
-    }
-    xSpeed /= 60;
-    ySpeed /= 60;
-    let destination = args.destination;
-    let tagToRemoveAfter2 = args.tagToRemoveAfter || [];
-    if (typeof tagToRemoveAfter2 === "string") {
-      tagToRemoveAfter2 = [tagToRemoveAfter2];
-    }
-    tags.filter((tag) => {
-      var _a;
-      let element = GameWindowManager.getCanvasElement(tag);
-      if (args.startOnlyIfHaveTexture) {
-        if (element && element instanceof Sprite && ((_a = element.texture) == null ? void 0 : _a.label) == "EMPTY") {
-          return false;
-        }
-      }
-      return true;
-    }).forEach((tag) => {
-      let element = GameWindowManager.getCanvasElement(tag);
-      if (element && element instanceof Container) {
-        let xDistance = destination.x - element.x > 0 ? 1 : -1;
-        if (xDistance != 0) {
-          element.x += xDistance * xSpeed * ticker.deltaTime;
-          let newDistance = destination.x - element.x;
-          if (xDistance < 0 && newDistance > 0 || xDistance > 0 && newDistance < 0) {
-            element.x = destination.x;
-          }
-        }
-        let yDistance = destination.y - element.y > 0 ? 1 : -1;
-        if (yDistance != 0) {
-          element.y += yDistance * ySpeed * ticker.deltaTime;
-          let newDistance = destination.y - element.y;
-          if (yDistance < 0 && newDistance > 0 || yDistance > 0 && newDistance < 0) {
-            element.y = destination.y;
-          }
-        }
-        if (element.x == destination.x && element.y == destination.y) {
-          GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
-        }
-      }
-    });
-    if (args.speedProgression)
-      updateTickerProgression(args, "speed", args.speedProgression);
-  }
-};
-MoveTicker = __decorateClass([
-  tickerDecorator()
-], MoveTicker);
-var RotateTicker = class extends TickerBase {
-  fn(ticker, args, tags, tickerId) {
-    let speed = (args.speed === void 0 ? 1 : args.speed) / 60;
-    let clockwise = args.clockwise === void 0 ? true : args.clockwise;
-    let tagToRemoveAfter2 = args.tagToRemoveAfter || [];
-    if (typeof tagToRemoveAfter2 === "string") {
-      tagToRemoveAfter2 = [tagToRemoveAfter2];
-    }
-    tags.filter((tag) => {
-      var _a;
-      let element = GameWindowManager.getCanvasElement(tag);
-      if (args.startOnlyIfHaveTexture) {
-        if (element && element instanceof Sprite && ((_a = element.texture) == null ? void 0 : _a.label) == "EMPTY") {
-          return false;
-        }
-      }
-      return true;
-    }).forEach((tag) => {
-      let element = GameWindowManager.getCanvasElement(tag);
-      if (element && element instanceof Container) {
-        if (clockwise)
-          element.rotation += speed * ticker.deltaTime;
-        else
-          element.rotation -= speed * ticker.deltaTime;
-        if (speed < 1e-5 && !(args.speedProgression && args.speedProgression.type == "linear" && args.speedProgression.amt != 0)) {
-          GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
-        }
-      }
-    });
-    if (args.speedProgression)
-      updateTickerProgression(args, "speed", args.speedProgression);
-  }
-};
-RotateTicker = __decorateClass([
-  tickerDecorator()
-], RotateTicker);
-var ZoomTicker = class extends TickerBase {
-  fn(ticker, args, tags, tickerId) {
-    let xSpeed = 0.1;
-    let ySpeed = 0.1;
-    if (args.speed) {
-      if (typeof args.speed === "number") {
-        xSpeed = args.speed;
-        ySpeed = args.speed;
-      } else {
-        xSpeed = args.speed.x;
-        ySpeed = args.speed.y;
-      }
-    }
-    xSpeed /= 60;
-    ySpeed /= 60;
-    let tagToRemoveAfter2 = args.tagToRemoveAfter || [];
-    if (typeof tagToRemoveAfter2 === "string") {
-      tagToRemoveAfter2 = [tagToRemoveAfter2];
-    }
-    let type = args.type || "zoom";
-    let xLimit = Infinity;
-    let yLimit = Infinity;
-    if (args.limit) {
-      if (typeof args.limit === "number") {
-        xLimit = args.limit;
-        yLimit = args.limit;
-      } else {
-        xLimit = args.limit.x;
-        yLimit = args.limit.y;
-      }
-    }
-    tags.filter((tag) => {
-      var _a;
-      let element = GameWindowManager.getCanvasElement(tag);
-      if (args.startOnlyIfHaveTexture) {
-        if (element && element instanceof Sprite && ((_a = element.texture) == null ? void 0 : _a.label) == "EMPTY") {
-          return false;
-        }
-      }
-      return true;
-    }).forEach((tag) => {
-      let element = GameWindowManager.getCanvasElement(tag);
-      if (element && element instanceof Container) {
-        if (type === "zoom" && (element.scale.x < xLimit || element.scale.y < yLimit)) {
-          element.scale.x += xSpeed * ticker.deltaTime;
-          element.scale.y += ySpeed * ticker.deltaTime;
-        } else if (type === "unzoom" && (element.scale.x > xLimit || element.scale.y > yLimit)) {
-          element.scale.x -= xSpeed * ticker.deltaTime;
-          element.scale.y -= ySpeed * ticker.deltaTime;
-        }
-        if (type === "zoom") {
-          if (element.scale.x > xLimit) {
-            element.scale.x = xLimit;
-          }
-          if (element.scale.y > yLimit) {
-            element.scale.y = yLimit;
-          }
-          if (element.scale.x >= xLimit && element.scale.y >= yLimit) {
-            element.scale.x = xLimit;
-            element.scale.y = yLimit;
-            GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
-          }
-        } else if (type === "unzoom") {
-          if (element.scale.x < xLimit) {
-            element.scale.x = xLimit;
-          }
-          if (element.scale.y < yLimit) {
-            element.scale.y = yLimit;
-          }
-          if (element.scale.x <= xLimit && element.scale.y <= yLimit) {
-            element.scale.x = xLimit;
-            element.scale.y = yLimit;
-            GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
-          }
-        }
-        if (xSpeed < 1e-5 && ySpeed < 1e-5 && !(args.speedProgression && args.speedProgression.type == "linear" && args.speedProgression.amt != 0)) {
-          GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
-        }
-      }
-    });
-    if (args.speedProgression)
-      updateTickerProgression(args, "speed", args.speedProgression);
-  }
-};
-ZoomTicker = __decorateClass([
-  tickerDecorator()
-], ZoomTicker);
-
-// src/labels/TintingTestLabel.ts
-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,
-      className: "AlienTintingTest"
-    });
-  }
-  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()
-], 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()
-], TintingTestTicker);
-var tintingTestLabel = newLabel(
-  "TintingTestLabel",
-  [
-    () => __async(void 0, null, function* () {
-      const totalDudes = 100;
-      for (let i = 0; i < totalDudes; i++) {
-        const texture = yield Assets.load("https://pixijs.com/assets/eggHead.png");
-        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());
-      }
-    })
-  ]
-);
-
-export { TintingTestTicker, tintingTestLabel };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=TintingTestLabel.mjs.map