@zylem/game-lib 0.3.15 → 0.3.17

package/dist/lib/camera/zylem-camera.js

@@ -0,0 +1,145 @@
+import { WebGLRenderer as c, Object3D as m, Vector3 as h, PerspectiveCamera as a, OrthographicCamera as o } from "three";
+import { OrbitControls as l } from "three/addons/controls/OrbitControls.js";
+import { Perspectives as t } from "./perspective.js";
+import { ThirdPersonCamera as n } from "./third-person.js";
+import { Fixed2DCamera as p } from "./fixed-2d.js";
+import { EffectComposer as u } from "three/examples/jsm/postprocessing/EffectComposer.js";
+import d from "../graphics/render-pass.js";
+class S {
+  cameraRig;
+  camera;
+  screenResolution;
+  renderer;
+  composer;
+  _perspective;
+  orbitControls = null;
+  target = null;
+  sceneRef = null;
+  frustumSize = 10;
+  // Perspective controller delegation
+  perspectiveController = null;
+  constructor(e, r, s = 10) {
+    this._perspective = e, this.screenResolution = r, this.frustumSize = s, this.renderer = new c({ antialias: !1, alpha: !0 }), this.renderer.setSize(r.x, r.y), this.renderer.shadowMap.enabled = !0, this.composer = new u(this.renderer);
+    const i = r.x / r.y;
+    this.camera = this.createCameraForPerspective(i), this.cameraRig = new m(), this.cameraRig.position.set(0, 3, 10), this.cameraRig.add(this.camera), this.camera.lookAt(new h(0, 2, 0)), this.initializePerspectiveController();
+  }
+  /**
+   * Setup the camera with a scene
+   */
+  async setup(e) {
+    this.sceneRef = e, this.orbitControls === null && (this.orbitControls = new l(this.camera, this.renderer.domElement), this.orbitControls.enableDamping = !0, this.orbitControls.dampingFactor = 0.05, this.orbitControls.screenSpacePanning = !1, this.orbitControls.minDistance = 1, this.orbitControls.maxDistance = 500, this.orbitControls.maxPolarAngle = Math.PI / 2);
+    let r = this.screenResolution.clone().divideScalar(2);
+    r.x |= 0, r.y |= 0;
+    const s = new d(r, e, this.camera);
+    this.composer.addPass(s), this.perspectiveController && this.perspectiveController.setup({
+      screenResolution: this.screenResolution,
+      renderer: this.renderer,
+      scene: e,
+      camera: this
+    }), this.renderer.setAnimationLoop((i) => {
+      this.update(i || 0);
+    });
+  }
+  /**
+   * Update camera and render
+   */
+  update(e) {
+    this.orbitControls?.update(), this.perspectiveController && this.perspectiveController.update(e), this.composer.render(e);
+  }
+  /**
+   * Dispose renderer, composer, controls, and detach from scene
+   */
+  destroy() {
+    try {
+      this.renderer.setAnimationLoop(null);
+    } catch {
+    }
+    try {
+      this.orbitControls?.dispose(), this.orbitControls = null;
+    } catch {
+    }
+    try {
+      this.composer?.passes?.forEach((e) => e.dispose?.()), this.composer?.dispose?.();
+    } catch {
+    }
+    try {
+      this.renderer.dispose();
+    } catch {
+    }
+    this.sceneRef = null;
+  }
+  /**
+   * Resize camera and renderer
+   */
+  resize(e, r) {
+    this.screenResolution.set(e, r), this.renderer.setSize(e, r, !0), this.composer.setSize(e, r), this.camera instanceof a && (this.camera.aspect = e / r, this.camera.updateProjectionMatrix()), this.perspectiveController && this.perspectiveController.resize(e, r);
+  }
+  /**
+   * Create camera based on perspective type
+   */
+  createCameraForPerspective(e) {
+    switch (this._perspective) {
+      case t.ThirdPerson:
+        return this.createThirdPersonCamera(e);
+      case t.FirstPerson:
+        return this.createFirstPersonCamera(e);
+      case t.Isometric:
+        return this.createIsometricCamera(e);
+      case t.Flat2D:
+        return this.createFlat2DCamera(e);
+      case t.Fixed2D:
+        return this.createFixed2DCamera(e);
+      default:
+        return this.createThirdPersonCamera(e);
+    }
+  }
+  /**
+   * Initialize perspective-specific controller
+   */
+  initializePerspectiveController() {
+    switch (this._perspective) {
+      case t.ThirdPerson:
+        this.perspectiveController = new n();
+        break;
+      case t.Fixed2D:
+        this.perspectiveController = new p();
+        break;
+      default:
+        this.perspectiveController = new n();
+    }
+  }
+  createThirdPersonCamera(e) {
+    return new a(75, e, 0.1, 1e3);
+  }
+  createFirstPersonCamera(e) {
+    return new a(75, e, 0.1, 1e3);
+  }
+  createIsometricCamera(e) {
+    return new o(this.frustumSize * e / -2, this.frustumSize * e / 2, this.frustumSize / 2, this.frustumSize / -2, 1, 1e3);
+  }
+  createFlat2DCamera(e) {
+    return new o(this.frustumSize * e / -2, this.frustumSize * e / 2, this.frustumSize / 2, this.frustumSize / -2, 1, 1e3);
+  }
+  createFixed2DCamera(e) {
+    return this.createFlat2DCamera(e);
+  }
+  // Movement methods
+  moveCamera(e) {
+    (this._perspective === t.Flat2D || this._perspective === t.Fixed2D) && (this.frustumSize = e.z), this.cameraRig.position.set(e.x, e.y, e.z);
+  }
+  move(e) {
+    this.moveCamera(e);
+  }
+  rotate(e, r, s) {
+    this.cameraRig.rotateX(e), this.cameraRig.rotateY(r), this.cameraRig.rotateZ(s);
+  }
+  /**
+   * Get the DOM element for the renderer
+   */
+  getDomElement() {
+    return this.renderer.domElement;
+  }
+}
+export {
+  S as ZylemCamera
+};

package/dist/lib/collision/collision-builder.js

@@ -0,0 +1,46 @@
+import { Vector3 as r, ActiveCollisionTypes as f, ColliderDesc as p, RigidBodyType as c, RigidBodyDesc as D } from "@dimforge/rapier3d-compat";
+const n = /* @__PURE__ */ new Map();
+let h = 0;
+function d(i) {
+  let e = n.get(i);
+  return e === void 0 && (e = h++ % 16, n.set(i, e)), e;
+}
+function C(i) {
+  let e = 0;
+  return i.forEach((s) => {
+    const t = d(s);
+    e |= 1 << t;
+  }), e;
+}
+class g {
+  static = !1;
+  sensor = !1;
+  gravity = new r(0, 0, 0);
+  build(e) {
+    const s = this.bodyDesc({
+      isDynamicBody: !this.static
+    }), t = this.collider(e), o = e.collisionType;
+    if (o) {
+      let u = d(o), l = 65535;
+      e.collisionFilter && (l = C(e.collisionFilter)), t.setCollisionGroups(u << 16 | l);
+    }
+    const { KINEMATIC_FIXED: a, DEFAULT: y } = f;
+    return t.activeCollisionTypes = this.sensor ? a : y, [s, t];
+  }
+  withCollision(e) {
+    return this.sensor = e?.sensor ?? this.sensor, this.static = e?.static ?? this.static, this;
+  }
+  collider(e) {
+    const s = e.size ?? new r(1, 1, 1), t = { x: s.x / 2, y: s.y / 2, z: s.z / 2 };
+    return p.cuboid(t.x, t.y, t.z);
+  }
+  bodyDesc({ isDynamicBody: e = !0 }) {
+    const s = e ? c.Dynamic : c.Fixed;
+    return new D(s).setTranslation(0, 0, 0).setGravityScale(1).setCanSleep(!1).setCcdEnabled(!0);
+  }
+}
+export {
+  g as CollisionBuilder,
+  C as createCollisionFilter,
+  d as getOrCreateCollisionGroupId
+};

package/dist/lib/collision/collision-delegate.js

@@ -0,0 +1,6 @@
+function e(n) {
+  return typeof n?.handlePostCollision == "function" && typeof n?.handleIntersectionEvent == "function";
+}
+export {
+  e as isCollisionHandlerDelegate
+};

package/dist/lib/collision/utils.js

@@ -0,0 +1,24 @@
+import { getOrCreateCollisionGroupId as o } from "./collision-builder.js";
+function u(i, n) {
+  if (!n)
+    return !0;
+  const r = i.name ?? "";
+  if ("name" in n) {
+    const e = n.name;
+    return e instanceof RegExp ? e.test(r) : Array.isArray(e) ? e.some((t) => t === r) : r === e;
+  } else if ("mask" in n) {
+    const e = n.mask;
+    if (e instanceof RegExp) {
+      const t = i.collisionType ?? "";
+      return e.test(t);
+    } else {
+      const t = i.collisionType ?? "", s = o(t);
+      return (e & 1 << s) !== 0;
+    }
+  } else if ("test" in n)
+    return !!n.test(i);
+  return !0;
+}
+export {
+  u as matchesCollisionSelector
+};

package/dist/lib/collision/world.js

@@ -0,0 +1,77 @@
+import d from "@dimforge/rapier3d-compat";
+import { state as c } from "../game/game-state.js";
+import { ZylemActor as h } from "../entities/actor.js";
+import { isCollisionHandlerDelegate as n } from "./collision-delegate.js";
+class v {
+  type = "World";
+  world;
+  collisionMap = /* @__PURE__ */ new Map();
+  collisionBehaviorMap = /* @__PURE__ */ new Map();
+  _removalMap = /* @__PURE__ */ new Map();
+  static async loadPhysics(o) {
+    return await d.init(), new d.World(o);
+  }
+  constructor(o) {
+    this.world = o;
+  }
+  addEntity(o) {
+    const i = this.world.createRigidBody(o.bodyDesc);
+    o.body = i, o.body.userData = { uuid: o.uuid, ref: o }, this.world.gravity.x === 0 && this.world.gravity.y === 0 && this.world.gravity.z === 0 && (o.body.lockTranslations(!0, !0), o.body.lockRotations(!0, !0));
+    const e = this.world.createCollider(o.colliderDesc, o.body);
+    o.collider = e, (o.controlledRotation || o instanceof h) && (o.body.lockRotations(!0, !0), o.characterController = this.world.createCharacterController(0.01), o.characterController.setMaxSlopeClimbAngle(45 * Math.PI / 180), o.characterController.setMinSlopeSlideAngle(30 * Math.PI / 180), o.characterController.enableSnapToGround(0.01), o.characterController.setSlideEnabled(!0), o.characterController.setApplyImpulsesToDynamicBodies(!0), o.characterController.setCharacterMass(1)), this.collisionMap.set(o.uuid, o);
+  }
+  setForRemoval(o) {
+    o.body && this._removalMap.set(o.uuid, o);
+  }
+  destroyEntity(o) {
+    o.collider && this.world.removeCollider(o.collider, !0), o.body && (this.world.removeRigidBody(o.body), this.collisionMap.delete(o.uuid), this._removalMap.delete(o.uuid));
+  }
+  setup() {
+  }
+  update(o) {
+    const { delta: i } = o;
+    this.world && (this.updateColliders(i), this.updatePostCollisionBehaviors(i), this.world.step());
+  }
+  updatePostCollisionBehaviors(o) {
+    const i = this.collisionBehaviorMap;
+    for (let [e, a] of i) {
+      const r = a;
+      if (!n(r))
+        return;
+      r.handlePostCollision({ entity: r, delta: o }) || this.collisionBehaviorMap.delete(e);
+    }
+  }
+  updateColliders(o) {
+    const i = this.collisionMap;
+    for (let [e, a] of i) {
+      const r = a;
+      if (r.body) {
+        if (this._removalMap.get(r.uuid)) {
+          this.destroyEntity(r);
+          continue;
+        }
+        this.world.contactsWith(r.body.collider(0), (t) => {
+          const s = t._parent.userData.uuid, l = i.get(s);
+          l && r._collision && r._collision(l, c.globals);
+        }), this.world.intersectionsWith(r.body.collider(0), (t) => {
+          const s = t._parent.userData.uuid, l = i.get(s);
+          l && (r._collision && r._collision(l, c.globals), n(l) && (l.handleIntersectionEvent({ entity: l, other: r, delta: o }), this.collisionBehaviorMap.set(s, l)));
+        });
+      }
+    }
+  }
+  destroy() {
+    try {
+      for (const [, o] of this.collisionMap)
+        try {
+          this.destroyEntity(o);
+        } catch {
+        }
+      this.collisionMap.clear(), this.collisionBehaviorMap.clear(), this._removalMap.clear(), this.world = void 0;
+    } catch {
+    }
+  }
+}
+export {
+  v as ZylemWorld
+};

package/dist/lib/core/base-node-life-cycle.d.ts

@@ -32,6 +32,13 @@ export interface SetupContext<T, TGlobals extends Record<string, unknown> = any>
 export interface SetupFunction<T, TGlobals extends Record<string, unknown> = any> {
     (context: SetupContext<T, TGlobals>): void;
 }
+export interface LoadedFunction<T, TGlobals extends Record<string, unknown> = any> {
+    (context: LoadedContext<T, TGlobals>): void;
+}
+export interface LoadedContext<T, TGlobals extends Record<string, unknown> = any> {
+    me: T;
+    globals: TGlobals;
+}
 export type UpdateContext<T, TGlobals extends Record<string, unknown> = any> = {
     me: T;
     delta: number;
@@ -51,3 +58,10 @@ export interface DestroyContext<T, TGlobals extends Record<string, unknown> = an
 export interface DestroyFunction<T, TGlobals extends Record<string, unknown> = any> {
     (context: DestroyContext<T, TGlobals>): void;
 }
+export interface CleanupFunction<T, TGlobals extends Record<string, unknown> = any> {
+    (context: CleanupContext<T, TGlobals>): void;
+}
+export interface CleanupContext<T, TGlobals extends Record<string, unknown> = any> {
+    me: T;
+    globals: TGlobals;
+}

package/dist/lib/core/base-node.d.ts

@@ -1,5 +1,5 @@
 import { Behavior } from "~/lib/actions/behaviors/behavior";
-import { DestroyContext, DestroyFunction, SetupContext, SetupFunction, UpdateContext, UpdateFunction } from "./base-node-life-cycle";
+import { CleanupContext, CleanupFunction, DestroyContext, DestroyFunction, LoadedContext, LoadedFunction, SetupContext, SetupFunction, UpdateContext, UpdateFunction } from "./base-node-life-cycle";
 export type BaseNodeOptions<T = any> = BaseNode | Partial<T>;
 export declare abstract class BaseNode<Options = any, T = any> {
     protected parent: BaseNode | null;
@@ -10,9 +10,11 @@ export declare abstract class BaseNode<Options = any, T = any> {
     uuid: string;
     name: string;
     markedForRemoval: boolean;
-    update: UpdateFunction<this>;
     setup: SetupFunction<this>;
+    loaded: LoadedFunction<this>;
+    update: UpdateFunction<this>;
     destroy: DestroyFunction<this>;
+    cleanup: CleanupFunction<this>;
     constructor(args?: BaseNodeOptions[]);
     setParent(parent: BaseNode | null): void;
     getParent(): BaseNode | null;
@@ -22,8 +24,10 @@ export declare abstract class BaseNode<Options = any, T = any> {
     isComposite(): boolean;
     abstract create(): T;
     protected abstract _setup(params: SetupContext<this>): void;
+    protected abstract _loaded(params: LoadedContext<this>): Promise<void>;
     protected abstract _update(params: UpdateContext<this>): void;
     protected abstract _destroy(params: DestroyContext<this>): void;
+    protected abstract _cleanup(params: CleanupContext<this>): Promise<void>;
     nodeSetup(params: SetupContext<this>): void;
     nodeUpdate(params: UpdateContext<this>): void;
     nodeDestroy(params: DestroyContext<this>): void;

package/dist/lib/core/base-node.js

@@ -0,0 +1,62 @@
+import { nanoid as o } from "nanoid";
+class s {
+  parent = null;
+  children = [];
+  behaviors = [];
+  options;
+  eid = 0;
+  uuid = "";
+  name = "";
+  markedForRemoval = !1;
+  setup = () => {
+  };
+  loaded = () => {
+  };
+  update = () => {
+  };
+  destroy = () => {
+  };
+  cleanup = () => {
+  };
+  constructor(t = []) {
+    const e = t.filter((i) => !(i instanceof s)).reduce((i, n) => ({ ...i, ...n }), {});
+    this.options = e, this.uuid = o();
+  }
+  setParent(t) {
+    this.parent = t;
+  }
+  getParent() {
+    return this.parent;
+  }
+  add(t) {
+    this.children.push(t), t.setParent(this);
+  }
+  remove(t) {
+    const e = this.children.indexOf(t);
+    e !== -1 && (this.children.splice(e, 1), t.setParent(null));
+  }
+  getChildren() {
+    return this.children;
+  }
+  isComposite() {
+    return this.children.length > 0;
+  }
+  nodeSetup(t) {
+    typeof this._setup == "function" && this._setup(t), this.setup && this.setup(t), this.children.forEach((e) => e.nodeSetup(t));
+  }
+  nodeUpdate(t) {
+    this.markedForRemoval || (typeof this._update == "function" && this._update(t), this.update && this.update(t), this.children.forEach((e) => e.nodeUpdate(t)));
+  }
+  nodeDestroy(t) {
+    this.children.forEach((e) => e.nodeDestroy(t)), this.destroy && this.destroy(t), typeof this._destroy == "function" && this._destroy(t), this.markedForRemoval = !0;
+  }
+  getOptions() {
+    return this.options;
+  }
+  setOptions(t) {
+    this.options = { ...this.options, ...t };
+  }
+}
+export {
+  s as BaseNode
+};

package/dist/lib/core/entity-asset-loader.js

@@ -0,0 +1,57 @@
+import { FBXLoader as d } from "three/addons/loaders/FBXLoader.js";
+import { GLTFLoader as i } from "three/addons/loaders/GLTFLoader.js";
+var t;
+(function(r) {
+  r.FBX = "fbx", r.GLTF = "gltf";
+})(t || (t = {}));
+class l {
+  loader = new d();
+  isSupported(e) {
+    return e.toLowerCase().endsWith(t.FBX);
+  }
+  async load(e) {
+    return new Promise((o, s) => {
+      this.loader.load(e, (a) => {
+        const n = a.animations[0];
+        o({
+          object: a,
+          animation: n
+        });
+      }, void 0, s);
+    });
+  }
+}
+class p {
+  loader = new i();
+  isSupported(e) {
+    return e.toLowerCase().endsWith(t.GLTF);
+  }
+  async load(e) {
+    return new Promise((o, s) => {
+      this.loader.load(e, (a) => {
+        o({
+          object: a.scene,
+          gltf: a
+        });
+      }, void 0, s);
+    });
+  }
+}
+class u {
+  loaders = [
+    new l(),
+    new p()
+  ];
+  async loadFile(e) {
+    const o = this.loaders.find((s) => s.isSupported(e));
+    if (!o)
+      throw new Error(`Unsupported file type: ${e}`);
+    return o.load(e);
+  }
+}
+export {
+  u as EntityAssetLoader,
+  l as FBXAssetLoader,
+  t as FileExtensionTypes,
+  p as GLTFAssetLoader
+};

package/dist/lib/core/lazy-loader.d.ts

@@ -14,7 +14,7 @@
 export declare const loadFoundation: () => Promise<{
     baseNode: typeof import("./base-node");
     lifeCycle: typeof import("./base-node-life-cycle");
-    utility: typeof import("./utility");
+    utility: typeof import("./utility/vector");
     vector: typeof import("./vector");
 }>;
 export declare const loadState: () => Promise<typeof import("../game/game-state")>;
@@ -48,7 +48,7 @@ export declare const loadFullGame: () => Promise<{
     foundation: {
         baseNode: typeof import("./base-node");
         lifeCycle: typeof import("./base-node-life-cycle");
-        utility: typeof import("./utility");
+        utility: typeof import("./utility/vector");
         vector: typeof import("./vector");
     };
     state: typeof import("../game/game-state");

package/dist/lib/core/lifecycle-base.js

@@ -0,0 +1,20 @@
+class e {
+  update = () => {
+  };
+  setup = () => {
+  };
+  destroy = () => {
+  };
+  nodeSetup(t) {
+    typeof this._setup == "function" && this._setup(t), this.setup && this.setup(t);
+  }
+  nodeUpdate(t) {
+    typeof this._update == "function" && this._update(t), this.update && this.update(t);
+  }
+  nodeDestroy(t) {
+    this.destroy && this.destroy(t), typeof this._destroy == "function" && this._destroy(t);
+  }
+}
+export {
+  e as LifeCycleBase
+};

package/dist/lib/core/preset-shader.js

@@ -0,0 +1,30 @@
+import r from "../graphics/shaders/fragment/stars.glsl.js";
+import a from "../graphics/shaders/fragment/fire.glsl.js";
+import d from "../graphics/shaders/fragment/standard.glsl.js";
+import f from "../graphics/shaders/fragment/debug.glsl.js";
+import t from "../graphics/shaders/vertex/object-shader.glsl.js";
+import o from "../graphics/shaders/vertex/debug.glsl.js";
+const s = {
+  fragment: r,
+  vertex: t
+}, m = {
+  fragment: a,
+  vertex: t
+}, n = {
+  fragment: d,
+  vertex: t
+}, u = {
+  fragment: f,
+  vertex: o
+}, e = /* @__PURE__ */ new Map();
+e.set("standard", n);
+e.set("fire", m);
+e.set("star", s);
+e.set("debug", u);
+export {
+  u as debugShader,
+  e as default,
+  m as fireShader,
+  n as standardShader,
+  s as starShader
+};

package/dist/lib/core/three-addons/Timer.js

@@ -0,0 +1,103 @@
+class n {
+  _previousTime;
+  _currentTime;
+  _startTime;
+  _delta;
+  _elapsed;
+  _timescale;
+  _document;
+  _pageVisibilityHandler;
+  /**
+   * Constructs a new timer.
+   */
+  constructor() {
+    this._previousTime = 0, this._currentTime = 0, this._startTime = e(), this._delta = 0, this._elapsed = 0, this._timescale = 1, this._document = null, this._pageVisibilityHandler = null;
+  }
+  /**
+   * Connect the timer to the given document.Calling this method is not mandatory to
+   * use the timer but enables the usage of the Page Visibility API to avoid large time
+   * delta values.
+   *
+   * @param {Document} document - The document.
+   */
+  connect(i) {
+    this._document = i, i.hidden !== void 0 && (this._pageVisibilityHandler = t.bind(this), i.addEventListener("visibilitychange", this._pageVisibilityHandler, !1));
+  }
+  /**
+   * Disconnects the timer from the DOM and also disables the usage of the Page Visibility API.
+   */
+  disconnect() {
+    this._pageVisibilityHandler !== null && (this._document.removeEventListener("visibilitychange", this._pageVisibilityHandler), this._pageVisibilityHandler = null), this._document = null;
+  }
+  /**
+   * Returns the time delta in seconds.
+   *
+   * @return {number} The time delta in second.
+   */
+  getDelta() {
+    return this._delta / 1e3;
+  }
+  /**
+   * Returns the elapsed time in seconds.
+   *
+   * @return {number} The elapsed time in second.
+   */
+  getElapsed() {
+    return this._elapsed / 1e3;
+  }
+  /**
+   * Returns the timescale.
+   *
+   * @return {number} The timescale.
+   */
+  getTimescale() {
+    return this._timescale;
+  }
+  /**
+   * Sets the given timescale which scale the time delta computation
+   * in `update()`.
+   *
+   * @param {number} timescale - The timescale to set.
+   * @return {Timer} A reference to this timer.
+   */
+  setTimescale(i) {
+    return this._timescale = i, this;
+  }
+  /**
+   * Resets the time computation for the current simulation step.
+   *
+   * @return {Timer} A reference to this timer.
+   */
+  reset() {
+    return this._currentTime = e() - this._startTime, this;
+  }
+  /**
+   * Can be used to free all internal resources. Usually called when
+   * the timer instance isn't required anymore.
+   */
+  dispose() {
+    this.disconnect();
+  }
+  /**
+   * Updates the internal state of the timer. This method should be called
+   * once per simulation step and before you perform queries against the timer
+   * (e.g. via `getDelta()`).
+   *
+   * @param {number} timestamp - The current time in milliseconds. Can be obtained
+   * from the `requestAnimationFrame` callback argument. If not provided, the current
+   * time will be determined with `performance.now`.
+   * @return {Timer} A reference to this timer.
+   */
+  update(i) {
+    return this._pageVisibilityHandler !== null && this._document.hidden === !0 ? this._delta = 0 : (this._previousTime = this._currentTime, this._currentTime = (i !== void 0 ? i : e()) - this._startTime, this._delta = (this._currentTime - this._previousTime) * this._timescale, this._elapsed += this._delta), this;
+  }
+}
+function e() {
+  return performance.now();
+}
+function t() {
+  this._document.hidden === !1 && this.reset();
+}
+export {
+  n as Timer
+};

package/dist/lib/core/utility/nodes.d.ts

@@ -0,0 +1,11 @@
+import { BaseNode } from '../base-node';
+import { Stage } from '../../stage/stage';
+import { GameEntityLifeCycle } from '../../entities/entity';
+import { BasicTypes, GlobalVariablesType, ZylemGameConfig } from '../../game/game-interfaces';
+import { GameConfigLike } from '~/lib/game/game-config';
+export type GameOptions<TGlobals extends Record<string, BasicTypes> = GlobalVariablesType> = Array<ZylemGameConfig<Stage, any, TGlobals> | GameConfigLike | Stage | GameEntityLifeCycle | BaseNode>;
+export declare function convertNodes<TGlobals extends Record<string, BasicTypes> = GlobalVariablesType>(_options: GameOptions<TGlobals>): Promise<{
+    id: string;
+    globals: TGlobals;
+    stages: Stage[];
+}>;