@zylem/game-lib 0.3.14 → 0.3.16

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.d.ts

@@ -1,5 +1,4 @@
 import { ColliderDesc, RigidBodyDesc } from "@dimforge/rapier3d-compat";
-import { PhysicsOptions } from "./physics";
 import { Vec3 } from "../core/vector";
 import { CollisionOptions } from "./collision";
 export declare function getOrCreateCollisionGroupId(type: string): number;
@@ -15,7 +14,6 @@ export declare class CollisionBuilder {
     gravity: Vec3;
     build(options: Partial<CollisionOptions>): [RigidBodyDesc, ColliderDesc];
     withCollision(collisionOptions: Partial<CollisionOptions>): this;
-    withPhysics(physicsOptions: Partial<PhysicsOptions>): this;
     collider(options: CollisionOptions): ColliderDesc;
     bodyDesc({ isDynamicBody }: {
         isDynamicBody?: boolean | undefined;

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/collision-group.d.ts

@@ -1,5 +1,4 @@
 import { GameEntity } from '../entities/entity';
-import { CollisionContext } from '../entities/entity';
 /**
  * Configure an entity's collision groups to only collide with the specified types.
  * This uses Rapier's built-in collision group system for efficient filtering.
@@ -9,19 +8,3 @@ import { CollisionContext } from '../entities/entity';
  * @returns The entity for method chaining
  */
 export declare function collisionGroup<T extends GameEntity<any>>(entity: T, allowedTypes: string[]): T;
-/**
- * Legacy type definitions for backward compatibility
- * @deprecated Use the new collisionGroup function instead
- */
-export type CollisionCallback = (ctx: CollisionContext<any, any>) => void;
-export type CollisionGroupWrapper = (...actions: CollisionCallback[]) => CollisionCallback;
-/**
- * @deprecated This function is deprecated. Use the new collisionGroup function instead.
- */
-export declare function legacyCollisionGroup(...args: (string | GameEntity<any> | {
-    includeSameType?: boolean;
-})[]): CollisionGroupWrapper;
-/**
- * @deprecated This function is deprecated.
- */
-export declare function combineCollisionGroups(...wrappers: CollisionGroupWrapper[]): CollisionGroupWrapper;

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.js

@@ -0,0 +1,58 @@
+import { nanoid as o } from "nanoid";
+class s {
+  parent = null;
+  children = [];
+  behaviors = [];
+  options;
+  eid = 0;
+  uuid = "";
+  name = "";
+  markedForRemoval = !1;
+  update = () => {
+  };
+  setup = () => {
+  };
+  destroy = () => {
+  };
+  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

@@ -24,7 +24,6 @@ export declare const loadGraphics: () => Promise<{
     mesh: typeof import("../graphics/mesh");
 }>;
 export declare const loadPhysics: () => Promise<{
-    physics: typeof import("../collision/physics");
     collision: typeof import("../collision/collision");
     collisionBuilder: typeof import("../collision/collision-builder");
 }>;
@@ -59,7 +58,6 @@ export declare const loadFullGame: () => Promise<{
         mesh: typeof import("../graphics/mesh");
     };
     physics: {
-        physics: typeof import("../collision/physics");
         collision: typeof import("../collision/collision");
         collisionBuilder: typeof import("../collision/collision-builder");
     };

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.d.ts

@@ -5,6 +5,7 @@ export type ZylemShaderObject = {
 export declare const starShader: ZylemShaderObject;
 export declare const fireShader: ZylemShaderObject;
 export declare const standardShader: ZylemShaderObject;
-export type ZylemShaderType = 'standard' | 'fire' | 'star';
+export declare const debugShader: ZylemShaderObject;
+export type ZylemShaderType = 'standard' | 'fire' | 'star' | 'debug';
 declare const shaderMap: Map<ZylemShaderType, ZylemShaderObject>;
 export default shaderMap;

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.js

@@ -0,0 +1,20 @@
+import { Color as i } from "three";
+import { Vector3 as n } from "@dimforge/rapier3d-compat";
+const u = new i("#0333EC");
+function f(r) {
+  const e = Object.keys(r).sort().reduce((t, o) => (t[o] = r[o], t), {});
+  return JSON.stringify(e);
+}
+function h(r) {
+  let e = 0;
+  for (let t = 0; t < r.length; t++)
+    e = Math.imul(31, e) + r.charCodeAt(t) | 0;
+  return e.toString(36);
+}
+new n(0, 0, 0);
+new n(1, 1, 1);
+export {
+  u as ZylemBlueColor,
+  h as shortHash,
+  f as sortedStringify
+};

package/dist/lib/core/vessel.js

@@ -0,0 +1,23 @@
+import { BaseNode as a } from "./base-node.js";
+const r = Symbol("vessel");
+class n extends a {
+  static type = r;
+  _setup(e) {
+  }
+  _update(e) {
+  }
+  _destroy(e) {
+  }
+  create() {
+    return this;
+  }
+}
+function c(...s) {
+  const e = new n();
+  return s.forEach((t) => e.add(t)), e;
+}
+export {
+  r as VESSEL_TYPE,
+  n as Vessel,
+  c as vessel
+};